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"
128 #include "elf/moxie.h"
130 #include "elf/msp430.h"
131 #include "elf/or32.h"
134 #include "elf/ppc64.h"
136 #include "elf/s390.h"
137 #include "elf/score.h"
139 #include "elf/sparc.h"
141 #include "elf/tic6x.h"
142 #include "elf/v850.h"
144 #include "elf/x86-64.h"
145 #include "elf/xc16x.h"
146 #include "elf/xstormy16.h"
147 #include "elf/xtensa.h"
152 #include "libiberty.h"
153 #include "safe-ctype.h"
154 #include "filenames.h"
156 char * program_name
= "readelf";
157 static long archive_file_offset
;
158 static unsigned long archive_file_size
;
159 static unsigned long dynamic_addr
;
160 static bfd_size_type dynamic_size
;
161 static unsigned int dynamic_nent
;
162 static char * dynamic_strings
;
163 static unsigned long dynamic_strings_length
;
164 static char * string_table
;
165 static unsigned long string_table_length
;
166 static unsigned long num_dynamic_syms
;
167 static Elf_Internal_Sym
* dynamic_symbols
;
168 static Elf_Internal_Syminfo
* dynamic_syminfo
;
169 static unsigned long dynamic_syminfo_offset
;
170 static unsigned int dynamic_syminfo_nent
;
171 static char program_interpreter
[PATH_MAX
];
172 static bfd_vma dynamic_info
[DT_ENCODING
];
173 static bfd_vma dynamic_info_DT_GNU_HASH
;
174 static bfd_vma version_info
[16];
175 static Elf_Internal_Ehdr elf_header
;
176 static Elf_Internal_Shdr
* section_headers
;
177 static Elf_Internal_Phdr
* program_headers
;
178 static Elf_Internal_Dyn
* dynamic_section
;
179 static Elf_Internal_Shdr
* symtab_shndx_hdr
;
180 static int show_name
;
181 static int do_dynamic
;
183 static int do_dyn_syms
;
185 static int do_sections
;
186 static int do_section_groups
;
187 static int do_section_details
;
188 static int do_segments
;
189 static int do_unwind
;
190 static int do_using_dynamic
;
191 static int do_header
;
193 static int do_version
;
194 static int do_histogram
;
195 static int do_debugging
;
198 static int do_archive_index
;
199 static int is_32bit_elf
;
203 struct group_list
* next
;
204 unsigned int section_index
;
209 struct group_list
* root
;
210 unsigned int group_index
;
213 static size_t group_count
;
214 static struct group
* section_groups
;
215 static struct group
** section_headers_groups
;
218 /* Flag bits indicating particular types of dump. */
219 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
220 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
221 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
222 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
223 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
225 typedef unsigned char dump_type
;
227 /* A linked list of the section names for which dumps were requested. */
228 struct dump_list_entry
232 struct dump_list_entry
* next
;
234 static struct dump_list_entry
* dump_sects_byname
;
236 /* A dynamic array of flags indicating for which sections a dump
237 has been requested via command line switches. */
238 static dump_type
* cmdline_dump_sects
= NULL
;
239 static unsigned int num_cmdline_dump_sects
= 0;
241 /* A dynamic array of flags indicating for which sections a dump of
242 some kind has been requested. It is reset on a per-object file
243 basis and then initialised from the cmdline_dump_sects array,
244 the results of interpreting the -w switch, and the
245 dump_sects_byname list. */
246 static dump_type
* dump_sects
= NULL
;
247 static unsigned int num_dump_sects
= 0;
250 /* How to print a vma value. */
251 typedef enum print_mode
263 static void (* byte_put
) (unsigned char *, bfd_vma
, int);
267 #define SECTION_NAME(X) \
268 ((X) == NULL ? _("<none>") \
269 : string_table == NULL ? _("<no-name>") \
270 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
271 : string_table + (X)->sh_name))
273 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
275 #define BYTE_GET(field) byte_get (field, sizeof (field))
276 #define BYTE_GET_SIGNED(field) byte_get_signed (field, sizeof (field))
278 #define GET_ELF_SYMBOLS(file, section) \
279 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
280 : get_64bit_elf_symbols (file, section))
282 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
283 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
284 already been called and verified that the string exists. */
285 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
287 /* This is just a bit of syntatic sugar. */
288 #define streq(a,b) (strcmp ((a), (b)) == 0)
289 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
290 #define const_strneq(a,b) (strncmp ((a), (b), sizeof (b) - 1) == 0)
292 #define REMOVE_ARCH_BITS(ADDR) do { \
293 if (elf_header.e_machine == EM_ARM) \
298 get_data (void * var
, FILE * file
, long offset
, size_t size
, size_t nmemb
,
303 if (size
== 0 || nmemb
== 0)
306 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
308 error (_("Unable to seek to 0x%lx for %s\n"),
309 (unsigned long) archive_file_offset
+ offset
, reason
);
316 /* Check for overflow. */
317 if (nmemb
< (~(size_t) 0 - 1) / size
)
318 /* + 1 so that we can '\0' terminate invalid string table sections. */
319 mvar
= malloc (size
* nmemb
+ 1);
323 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
324 (unsigned long)(size
* nmemb
), reason
);
328 ((char *) mvar
)[size
* nmemb
] = '\0';
331 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
333 error (_("Unable to read in 0x%lx bytes of %s\n"),
334 (unsigned long)(size
* nmemb
), reason
);
344 byte_put_little_endian (unsigned char * field
, bfd_vma value
, int size
)
349 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
350 field
[6] = ((value
>> 24) >> 24) & 0xff;
351 field
[5] = ((value
>> 24) >> 16) & 0xff;
352 field
[4] = ((value
>> 24) >> 8) & 0xff;
355 field
[3] = (value
>> 24) & 0xff;
358 field
[2] = (value
>> 16) & 0xff;
361 field
[1] = (value
>> 8) & 0xff;
364 field
[0] = value
& 0xff;
368 error (_("Unhandled data length: %d\n"), size
);
373 /* Print a VMA value. */
376 print_vma (bfd_vma vma
, print_mode mode
)
389 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
396 return printf ("%5" BFD_VMA_FMT
"d", vma
);
404 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
407 return printf ("%" BFD_VMA_FMT
"d", vma
);
410 return printf ("%" BFD_VMA_FMT
"u", vma
);
415 /* Display a symbol on stdout. Handles the display of non-printing characters.
417 If DO_WIDE is not true then format the symbol to be at most WIDTH characters,
418 truncating as necessary. If WIDTH is negative then format the string to be
419 exactly - WIDTH characters, truncating or padding as necessary.
421 Returns the number of emitted characters. */
424 print_symbol (int width
, const char * symbol
)
427 bfd_boolean extra_padding
= FALSE
;
428 unsigned int num_printed
= 0;
432 /* Set the width to a very large value. This simplifies the code below. */
437 /* Keep the width positive. This also helps. */
439 extra_padding
= TRUE
;
448 /* Look for non-printing symbols inside the symbol's name.
449 This test is triggered in particular by the names generated
450 by the assembler for local labels. */
451 while (ISPRINT (* c
))
461 printf ("%.*s", len
, symbol
);
467 if (* c
== 0 || width
== 0)
470 /* Now display the non-printing character, if
471 there is room left in which to dipslay it. */
477 printf ("^%c", *c
+ 0x40);
487 printf ("<0x%.2x>", *c
);
496 if (extra_padding
&& width
> 0)
498 /* Fill in the remaining spaces. */
499 printf ("%-*s", width
, " ");
507 byte_put_big_endian (unsigned char * field
, bfd_vma value
, int size
)
512 field
[7] = value
& 0xff;
513 field
[6] = (value
>> 8) & 0xff;
514 field
[5] = (value
>> 16) & 0xff;
515 field
[4] = (value
>> 24) & 0xff;
520 field
[3] = value
& 0xff;
524 field
[2] = value
& 0xff;
528 field
[1] = value
& 0xff;
532 field
[0] = value
& 0xff;
536 error (_("Unhandled data length: %d\n"), size
);
541 /* Return a pointer to section NAME, or NULL if no such section exists. */
543 static Elf_Internal_Shdr
*
544 find_section (const char * name
)
548 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
549 if (streq (SECTION_NAME (section_headers
+ i
), name
))
550 return section_headers
+ i
;
555 /* Return a pointer to a section containing ADDR, or NULL if no such
558 static Elf_Internal_Shdr
*
559 find_section_by_address (bfd_vma addr
)
563 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
565 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
566 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
573 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
577 read_uleb128 (unsigned char *data
, unsigned int *length_return
)
579 return read_leb128 (data
, length_return
, 0);
582 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
583 This OS has so many departures from the ELF standard that we test it at
589 return elf_header
.e_machine
== EM_IA_64
590 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
593 /* Guess the relocation size commonly used by the specific machines. */
596 guess_is_rela (unsigned int e_machine
)
600 /* Targets that use REL relocations. */
616 /* Targets that use RELA relocations. */
620 case EM_ALTERA_NIOS2
:
640 case EM_LATTICEMICO32
:
648 case EM_CYGNUS_MN10200
:
650 case EM_CYGNUS_MN10300
:
676 case EM_MICROBLAZE_OLD
:
697 warn (_("Don't know about relocations on this machine architecture\n"));
703 slurp_rela_relocs (FILE * file
,
704 unsigned long rel_offset
,
705 unsigned long rel_size
,
706 Elf_Internal_Rela
** relasp
,
707 unsigned long * nrelasp
)
709 Elf_Internal_Rela
* relas
;
710 unsigned long nrelas
;
715 Elf32_External_Rela
* erelas
;
717 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
718 rel_size
, _("relocs"));
722 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
724 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
725 sizeof (Elf_Internal_Rela
));
730 error (_("out of memory parsing relocs\n"));
734 for (i
= 0; i
< nrelas
; i
++)
736 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
737 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
738 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
745 Elf64_External_Rela
* erelas
;
747 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
748 rel_size
, _("relocs"));
752 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
754 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
755 sizeof (Elf_Internal_Rela
));
760 error (_("out of memory parsing relocs\n"));
764 for (i
= 0; i
< nrelas
; i
++)
766 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
767 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
768 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
770 /* The #ifdef BFD64 below is to prevent a compile time
771 warning. We know that if we do not have a 64 bit data
772 type that we will never execute this code anyway. */
774 if (elf_header
.e_machine
== EM_MIPS
775 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
777 /* In little-endian objects, r_info isn't really a
778 64-bit little-endian value: it has a 32-bit
779 little-endian symbol index followed by four
780 individual byte fields. Reorder INFO
782 bfd_vma inf
= relas
[i
].r_info
;
783 inf
= (((inf
& 0xffffffff) << 32)
784 | ((inf
>> 56) & 0xff)
785 | ((inf
>> 40) & 0xff00)
786 | ((inf
>> 24) & 0xff0000)
787 | ((inf
>> 8) & 0xff000000));
788 relas
[i
].r_info
= inf
;
801 slurp_rel_relocs (FILE * file
,
802 unsigned long rel_offset
,
803 unsigned long rel_size
,
804 Elf_Internal_Rela
** relsp
,
805 unsigned long * nrelsp
)
807 Elf_Internal_Rela
* rels
;
813 Elf32_External_Rel
* erels
;
815 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
816 rel_size
, _("relocs"));
820 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
822 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
827 error (_("out of memory parsing relocs\n"));
831 for (i
= 0; i
< nrels
; i
++)
833 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
834 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
835 rels
[i
].r_addend
= 0;
842 Elf64_External_Rel
* erels
;
844 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
845 rel_size
, _("relocs"));
849 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
851 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
856 error (_("out of memory parsing relocs\n"));
860 for (i
= 0; i
< nrels
; i
++)
862 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
863 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
864 rels
[i
].r_addend
= 0;
866 /* The #ifdef BFD64 below is to prevent a compile time
867 warning. We know that if we do not have a 64 bit data
868 type that we will never execute this code anyway. */
870 if (elf_header
.e_machine
== EM_MIPS
871 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
873 /* In little-endian objects, r_info isn't really a
874 64-bit little-endian value: it has a 32-bit
875 little-endian symbol index followed by four
876 individual byte fields. Reorder INFO
878 bfd_vma inf
= rels
[i
].r_info
;
879 inf
= (((inf
& 0xffffffff) << 32)
880 | ((inf
>> 56) & 0xff)
881 | ((inf
>> 40) & 0xff00)
882 | ((inf
>> 24) & 0xff0000)
883 | ((inf
>> 8) & 0xff000000));
884 rels
[i
].r_info
= inf
;
896 /* Returns the reloc type extracted from the reloc info field. */
899 get_reloc_type (bfd_vma reloc_info
)
902 return ELF32_R_TYPE (reloc_info
);
904 switch (elf_header
.e_machine
)
907 /* Note: We assume that reloc_info has already been adjusted for us. */
908 return ELF64_MIPS_R_TYPE (reloc_info
);
911 return ELF64_R_TYPE_ID (reloc_info
);
914 return ELF64_R_TYPE (reloc_info
);
918 /* Return the symbol index extracted from the reloc info field. */
921 get_reloc_symindex (bfd_vma reloc_info
)
923 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
926 /* Display the contents of the relocation data found at the specified
930 dump_relocations (FILE * file
,
931 unsigned long rel_offset
,
932 unsigned long rel_size
,
933 Elf_Internal_Sym
* symtab
,
936 unsigned long strtablen
,
940 Elf_Internal_Rela
* rels
;
942 if (is_rela
== UNKNOWN
)
943 is_rela
= guess_is_rela (elf_header
.e_machine
);
947 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
952 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
961 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
963 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
968 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
970 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
978 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
980 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
985 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
987 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
991 for (i
= 0; i
< rel_size
; i
++)
996 bfd_vma symtab_index
;
999 offset
= rels
[i
].r_offset
;
1000 inf
= rels
[i
].r_info
;
1002 type
= get_reloc_type (inf
);
1003 symtab_index
= get_reloc_symindex (inf
);
1007 printf ("%8.8lx %8.8lx ",
1008 (unsigned long) offset
& 0xffffffff,
1009 (unsigned long) inf
& 0xffffffff);
1013 #if BFD_HOST_64BIT_LONG
1015 ? "%16.16lx %16.16lx "
1016 : "%12.12lx %12.12lx ",
1018 #elif BFD_HOST_64BIT_LONG_LONG
1021 ? "%16.16llx %16.16llx "
1022 : "%12.12llx %12.12llx ",
1026 ? "%16.16I64x %16.16I64x "
1027 : "%12.12I64x %12.12I64x ",
1032 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1033 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1034 _bfd_int64_high (offset
),
1035 _bfd_int64_low (offset
),
1036 _bfd_int64_high (inf
),
1037 _bfd_int64_low (inf
));
1041 switch (elf_header
.e_machine
)
1048 case EM_CYGNUS_M32R
:
1049 rtype
= elf_m32r_reloc_type (type
);
1054 rtype
= elf_i386_reloc_type (type
);
1059 rtype
= elf_m68hc11_reloc_type (type
);
1063 rtype
= elf_m68k_reloc_type (type
);
1067 rtype
= elf_i960_reloc_type (type
);
1072 rtype
= elf_avr_reloc_type (type
);
1075 case EM_OLD_SPARCV9
:
1076 case EM_SPARC32PLUS
:
1079 rtype
= elf_sparc_reloc_type (type
);
1083 rtype
= elf_spu_reloc_type (type
);
1087 case EM_CYGNUS_V850
:
1088 rtype
= v850_reloc_type (type
);
1092 case EM_CYGNUS_D10V
:
1093 rtype
= elf_d10v_reloc_type (type
);
1097 case EM_CYGNUS_D30V
:
1098 rtype
= elf_d30v_reloc_type (type
);
1102 rtype
= elf_dlx_reloc_type (type
);
1106 rtype
= elf_sh_reloc_type (type
);
1110 case EM_CYGNUS_MN10300
:
1111 rtype
= elf_mn10300_reloc_type (type
);
1115 case EM_CYGNUS_MN10200
:
1116 rtype
= elf_mn10200_reloc_type (type
);
1120 case EM_CYGNUS_FR30
:
1121 rtype
= elf_fr30_reloc_type (type
);
1125 rtype
= elf_frv_reloc_type (type
);
1129 rtype
= elf_mcore_reloc_type (type
);
1133 rtype
= elf_mmix_reloc_type (type
);
1137 rtype
= elf_moxie_reloc_type (type
);
1142 rtype
= elf_msp430_reloc_type (type
);
1146 rtype
= elf_ppc_reloc_type (type
);
1150 rtype
= elf_ppc64_reloc_type (type
);
1154 case EM_MIPS_RS3_LE
:
1155 rtype
= elf_mips_reloc_type (type
);
1159 rtype
= elf_alpha_reloc_type (type
);
1163 rtype
= elf_arm_reloc_type (type
);
1167 rtype
= elf_arc_reloc_type (type
);
1171 rtype
= elf_hppa_reloc_type (type
);
1177 rtype
= elf_h8_reloc_type (type
);
1182 rtype
= elf_or32_reloc_type (type
);
1187 rtype
= elf_pj_reloc_type (type
);
1190 rtype
= elf_ia64_reloc_type (type
);
1194 rtype
= elf_cris_reloc_type (type
);
1198 rtype
= elf_i860_reloc_type (type
);
1203 rtype
= elf_x86_64_reloc_type (type
);
1207 rtype
= i370_reloc_type (type
);
1212 rtype
= elf_s390_reloc_type (type
);
1216 rtype
= elf_score_reloc_type (type
);
1220 rtype
= elf_xstormy16_reloc_type (type
);
1224 rtype
= elf_crx_reloc_type (type
);
1228 rtype
= elf_vax_reloc_type (type
);
1233 rtype
= elf_ip2k_reloc_type (type
);
1237 rtype
= elf_iq2000_reloc_type (type
);
1242 rtype
= elf_xtensa_reloc_type (type
);
1245 case EM_LATTICEMICO32
:
1246 rtype
= elf_lm32_reloc_type (type
);
1251 rtype
= elf_m32c_reloc_type (type
);
1255 rtype
= elf_mt_reloc_type (type
);
1259 rtype
= elf_bfin_reloc_type (type
);
1263 rtype
= elf_mep_reloc_type (type
);
1268 rtype
= elf_cr16_reloc_type (type
);
1272 case EM_MICROBLAZE_OLD
:
1273 rtype
= elf_microblaze_reloc_type (type
);
1277 rtype
= elf_rx_reloc_type (type
);
1282 rtype
= elf_xc16x_reloc_type (type
);
1286 rtype
= elf_tic6x_reloc_type (type
);
1291 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1293 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1295 if (elf_header
.e_machine
== EM_ALPHA
1297 && streq (rtype
, "R_ALPHA_LITUSE")
1300 switch (rels
[i
].r_addend
)
1302 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1303 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1304 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1305 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1306 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1307 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1308 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1309 default: rtype
= NULL
;
1312 printf (" (%s)", rtype
);
1316 printf (_("<unknown addend: %lx>"),
1317 (unsigned long) rels
[i
].r_addend
);
1320 else if (symtab_index
)
1322 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1323 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index
);
1326 Elf_Internal_Sym
* psym
;
1328 psym
= symtab
+ symtab_index
;
1332 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1336 unsigned int width
= is_32bit_elf
? 8 : 14;
1338 /* Relocations against GNU_IFUNC symbols do not use the value
1339 of the symbol as the address to relocate against. Instead
1340 they invoke the function named by the symbol and use its
1341 result as the address for relocation.
1343 To indicate this to the user, do not display the value of
1344 the symbol in the "Symbols's Value" field. Instead show
1345 its name followed by () as a hint that the symbol is
1349 || psym
->st_name
== 0
1350 || psym
->st_name
>= strtablen
)
1353 name
= strtab
+ psym
->st_name
;
1355 len
= print_symbol (width
, name
);
1356 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1360 print_vma (psym
->st_value
, LONG_HEX
);
1362 printf (is_32bit_elf
? " " : " ");
1365 if (psym
->st_name
== 0)
1367 const char * sec_name
= "<null>";
1370 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1372 if (psym
->st_shndx
< elf_header
.e_shnum
)
1374 = SECTION_NAME (section_headers
+ psym
->st_shndx
);
1375 else if (psym
->st_shndx
== SHN_ABS
)
1377 else if (psym
->st_shndx
== SHN_COMMON
)
1378 sec_name
= "COMMON";
1379 else if (elf_header
.e_machine
== EM_MIPS
1380 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1381 sec_name
= "SCOMMON";
1382 else if (elf_header
.e_machine
== EM_MIPS
1383 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1384 sec_name
= "SUNDEF";
1385 else if ((elf_header
.e_machine
== EM_X86_64
1386 || elf_header
.e_machine
== EM_L1OM
)
1387 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1388 sec_name
= "LARGE_COMMON";
1389 else if (elf_header
.e_machine
== EM_IA_64
1390 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1391 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1392 sec_name
= "ANSI_COM";
1393 else if (is_ia64_vms ()
1394 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1395 sec_name
= "VMS_SYMVEC";
1398 sprintf (name_buf
, "<section 0x%x>",
1399 (unsigned int) psym
->st_shndx
);
1400 sec_name
= name_buf
;
1403 print_symbol (22, sec_name
);
1405 else if (strtab
== NULL
)
1406 printf (_("<string table index: %3ld>"), psym
->st_name
);
1407 else if (psym
->st_name
>= strtablen
)
1408 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1410 print_symbol (22, strtab
+ psym
->st_name
);
1414 bfd_signed_vma off
= rels
[i
].r_addend
;
1417 printf (" - %" BFD_VMA_FMT
"x", - off
);
1419 printf (" + %" BFD_VMA_FMT
"x", off
);
1425 printf ("%*c", is_32bit_elf
?
1426 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1427 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1430 if (elf_header
.e_machine
== EM_SPARCV9
1432 && streq (rtype
, "R_SPARC_OLO10"))
1433 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1438 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1440 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1441 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1442 const char * rtype2
= elf_mips_reloc_type (type2
);
1443 const char * rtype3
= elf_mips_reloc_type (type3
);
1445 printf (" Type2: ");
1448 printf (_("unrecognized: %-7lx"),
1449 (unsigned long) type2
& 0xffffffff);
1451 printf ("%-17.17s", rtype2
);
1453 printf ("\n Type3: ");
1456 printf (_("unrecognized: %-7lx"),
1457 (unsigned long) type3
& 0xffffffff);
1459 printf ("%-17.17s", rtype3
);
1470 get_mips_dynamic_type (unsigned long type
)
1474 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1475 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1476 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1477 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1478 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1479 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1480 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1481 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1482 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1483 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1484 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1485 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1486 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1487 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1488 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1489 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1490 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1491 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1492 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1493 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1494 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1495 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1496 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1497 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1498 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1499 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1500 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1501 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1502 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1503 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1504 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1505 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1506 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1507 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1508 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1509 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1510 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1511 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1512 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1513 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1514 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1515 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1516 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1517 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1518 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1525 get_sparc64_dynamic_type (unsigned long type
)
1529 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1536 get_ppc_dynamic_type (unsigned long type
)
1540 case DT_PPC_GOT
: return "PPC_GOT";
1541 case DT_PPC_TLSOPT
: return "PPC_TLSOPT";
1548 get_ppc64_dynamic_type (unsigned long type
)
1552 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1553 case DT_PPC64_OPD
: return "PPC64_OPD";
1554 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1555 case DT_PPC64_TLSOPT
: return "PPC64_TLSOPT";
1562 get_parisc_dynamic_type (unsigned long type
)
1566 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1567 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1568 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1569 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1570 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1571 case DT_HP_PREINIT
: return "HP_PREINIT";
1572 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1573 case DT_HP_NEEDED
: return "HP_NEEDED";
1574 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1575 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1576 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1577 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1578 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1579 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1580 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1581 case DT_HP_FILTERED
: return "HP_FILTERED";
1582 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1583 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1584 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1585 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1586 case DT_PLT
: return "PLT";
1587 case DT_PLT_SIZE
: return "PLT_SIZE";
1588 case DT_DLT
: return "DLT";
1589 case DT_DLT_SIZE
: return "DLT_SIZE";
1596 get_ia64_dynamic_type (unsigned long type
)
1600 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1601 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1602 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1603 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1604 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1605 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1606 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1607 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1608 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1609 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1610 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1611 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1612 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1613 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1614 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1615 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1616 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1617 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1618 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1619 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1620 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1621 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1622 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1623 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1624 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1625 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1626 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1627 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1628 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1629 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1630 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1637 get_alpha_dynamic_type (unsigned long type
)
1641 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1648 get_score_dynamic_type (unsigned long type
)
1652 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1653 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1654 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1655 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1656 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1657 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1664 get_tic6x_dynamic_type (unsigned long type
)
1668 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1669 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1670 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1671 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1672 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1673 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1680 get_dynamic_type (unsigned long type
)
1682 static char buff
[64];
1686 case DT_NULL
: return "NULL";
1687 case DT_NEEDED
: return "NEEDED";
1688 case DT_PLTRELSZ
: return "PLTRELSZ";
1689 case DT_PLTGOT
: return "PLTGOT";
1690 case DT_HASH
: return "HASH";
1691 case DT_STRTAB
: return "STRTAB";
1692 case DT_SYMTAB
: return "SYMTAB";
1693 case DT_RELA
: return "RELA";
1694 case DT_RELASZ
: return "RELASZ";
1695 case DT_RELAENT
: return "RELAENT";
1696 case DT_STRSZ
: return "STRSZ";
1697 case DT_SYMENT
: return "SYMENT";
1698 case DT_INIT
: return "INIT";
1699 case DT_FINI
: return "FINI";
1700 case DT_SONAME
: return "SONAME";
1701 case DT_RPATH
: return "RPATH";
1702 case DT_SYMBOLIC
: return "SYMBOLIC";
1703 case DT_REL
: return "REL";
1704 case DT_RELSZ
: return "RELSZ";
1705 case DT_RELENT
: return "RELENT";
1706 case DT_PLTREL
: return "PLTREL";
1707 case DT_DEBUG
: return "DEBUG";
1708 case DT_TEXTREL
: return "TEXTREL";
1709 case DT_JMPREL
: return "JMPREL";
1710 case DT_BIND_NOW
: return "BIND_NOW";
1711 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1712 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1713 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1714 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1715 case DT_RUNPATH
: return "RUNPATH";
1716 case DT_FLAGS
: return "FLAGS";
1718 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1719 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1721 case DT_CHECKSUM
: return "CHECKSUM";
1722 case DT_PLTPADSZ
: return "PLTPADSZ";
1723 case DT_MOVEENT
: return "MOVEENT";
1724 case DT_MOVESZ
: return "MOVESZ";
1725 case DT_FEATURE
: return "FEATURE";
1726 case DT_POSFLAG_1
: return "POSFLAG_1";
1727 case DT_SYMINSZ
: return "SYMINSZ";
1728 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1730 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1731 case DT_CONFIG
: return "CONFIG";
1732 case DT_DEPAUDIT
: return "DEPAUDIT";
1733 case DT_AUDIT
: return "AUDIT";
1734 case DT_PLTPAD
: return "PLTPAD";
1735 case DT_MOVETAB
: return "MOVETAB";
1736 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1738 case DT_VERSYM
: return "VERSYM";
1740 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1741 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1742 case DT_RELACOUNT
: return "RELACOUNT";
1743 case DT_RELCOUNT
: return "RELCOUNT";
1744 case DT_FLAGS_1
: return "FLAGS_1";
1745 case DT_VERDEF
: return "VERDEF";
1746 case DT_VERDEFNUM
: return "VERDEFNUM";
1747 case DT_VERNEED
: return "VERNEED";
1748 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1750 case DT_AUXILIARY
: return "AUXILIARY";
1751 case DT_USED
: return "USED";
1752 case DT_FILTER
: return "FILTER";
1754 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1755 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1756 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1757 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1758 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1759 case DT_GNU_HASH
: return "GNU_HASH";
1762 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1764 const char * result
;
1766 switch (elf_header
.e_machine
)
1769 case EM_MIPS_RS3_LE
:
1770 result
= get_mips_dynamic_type (type
);
1773 result
= get_sparc64_dynamic_type (type
);
1776 result
= get_ppc_dynamic_type (type
);
1779 result
= get_ppc64_dynamic_type (type
);
1782 result
= get_ia64_dynamic_type (type
);
1785 result
= get_alpha_dynamic_type (type
);
1788 result
= get_score_dynamic_type (type
);
1791 result
= get_tic6x_dynamic_type (type
);
1801 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1803 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1804 || (elf_header
.e_machine
== EM_PARISC
1805 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1807 const char * result
;
1809 switch (elf_header
.e_machine
)
1812 result
= get_parisc_dynamic_type (type
);
1815 result
= get_ia64_dynamic_type (type
);
1825 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1829 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1836 get_file_type (unsigned e_type
)
1838 static char buff
[32];
1842 case ET_NONE
: return _("NONE (None)");
1843 case ET_REL
: return _("REL (Relocatable file)");
1844 case ET_EXEC
: return _("EXEC (Executable file)");
1845 case ET_DYN
: return _("DYN (Shared object file)");
1846 case ET_CORE
: return _("CORE (Core file)");
1849 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1850 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1851 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1852 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1854 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1860 get_machine_name (unsigned e_machine
)
1862 static char buff
[64]; /* XXX */
1866 case EM_NONE
: return _("None");
1867 case EM_M32
: return "WE32100";
1868 case EM_SPARC
: return "Sparc";
1869 case EM_SPU
: return "SPU";
1870 case EM_386
: return "Intel 80386";
1871 case EM_68K
: return "MC68000";
1872 case EM_88K
: return "MC88000";
1873 case EM_486
: return "Intel 80486";
1874 case EM_860
: return "Intel 80860";
1875 case EM_MIPS
: return "MIPS R3000";
1876 case EM_S370
: return "IBM System/370";
1877 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1878 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1879 case EM_PARISC
: return "HPPA";
1880 case EM_PPC_OLD
: return "Power PC (old)";
1881 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1882 case EM_960
: return "Intel 90860";
1883 case EM_PPC
: return "PowerPC";
1884 case EM_PPC64
: return "PowerPC64";
1885 case EM_V800
: return "NEC V800";
1886 case EM_FR20
: return "Fujitsu FR20";
1887 case EM_RH32
: return "TRW RH32";
1888 case EM_MCORE
: return "MCORE";
1889 case EM_ARM
: return "ARM";
1890 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1891 case EM_SH
: return "Renesas / SuperH SH";
1892 case EM_SPARCV9
: return "Sparc v9";
1893 case EM_TRICORE
: return "Siemens Tricore";
1894 case EM_ARC
: return "ARC";
1895 case EM_H8_300
: return "Renesas H8/300";
1896 case EM_H8_300H
: return "Renesas H8/300H";
1897 case EM_H8S
: return "Renesas H8S";
1898 case EM_H8_500
: return "Renesas H8/500";
1899 case EM_IA_64
: return "Intel IA-64";
1900 case EM_MIPS_X
: return "Stanford MIPS-X";
1901 case EM_COLDFIRE
: return "Motorola Coldfire";
1902 case EM_68HC12
: return "Motorola M68HC12";
1903 case EM_ALPHA
: return "Alpha";
1904 case EM_CYGNUS_D10V
:
1905 case EM_D10V
: return "d10v";
1906 case EM_CYGNUS_D30V
:
1907 case EM_D30V
: return "d30v";
1908 case EM_CYGNUS_M32R
:
1909 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1910 case EM_CYGNUS_V850
:
1911 case EM_V850
: return "NEC v850";
1912 case EM_CYGNUS_MN10300
:
1913 case EM_MN10300
: return "mn10300";
1914 case EM_CYGNUS_MN10200
:
1915 case EM_MN10200
: return "mn10200";
1916 case EM_MOXIE
: return "Moxie";
1917 case EM_CYGNUS_FR30
:
1918 case EM_FR30
: return "Fujitsu FR30";
1919 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1921 case EM_PJ
: return "picoJava";
1922 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1923 case EM_PCP
: return "Siemens PCP";
1924 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1925 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1926 case EM_STARCORE
: return "Motorola Star*Core processor";
1927 case EM_ME16
: return "Toyota ME16 processor";
1928 case EM_ST100
: return "STMicroelectronics ST100 processor";
1929 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1930 case EM_PDSP
: return "Sony DSP processor";
1931 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
1932 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
1933 case EM_FX66
: return "Siemens FX66 microcontroller";
1934 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1935 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1936 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1937 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1938 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1939 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1940 case EM_SVX
: return "Silicon Graphics SVx";
1941 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1942 case EM_VAX
: return "Digital VAX";
1944 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1945 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1946 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1947 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1948 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1949 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1950 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1951 case EM_PRISM
: return "Vitesse Prism";
1952 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1953 case EM_L1OM
: return "Intel L1OM";
1955 case EM_S390
: return "IBM S/390";
1956 case EM_SCORE
: return "SUNPLUS S+Core";
1957 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1959 case EM_OR32
: return "OpenRISC";
1960 case EM_ARC_A5
: return "ARC International ARCompact processor";
1961 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1962 case EM_DLX
: return "OpenDLX";
1964 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1965 case EM_IQ2000
: return "Vitesse IQ2000";
1967 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1968 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
1969 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
1970 case EM_NS32K
: return "National Semiconductor 32000 series";
1971 case EM_TPC
: return "Tenor Network TPC processor";
1972 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
1973 case EM_MAX
: return "MAX Processor";
1974 case EM_CR
: return "National Semiconductor CompactRISC";
1975 case EM_F2MC16
: return "Fujitsu F2MC16";
1976 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
1977 case EM_LATTICEMICO32
: return "Lattice Mico32";
1979 case EM_M32C
: return "Renesas M32c";
1980 case EM_MT
: return "Morpho Techologies MT processor";
1981 case EM_BLACKFIN
: return "Analog Devices Blackfin";
1982 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
1983 case EM_SEP
: return "Sharp embedded microprocessor";
1984 case EM_ARCA
: return "Arca RISC microprocessor";
1985 case EM_UNICORE
: return "Unicore";
1986 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
1987 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
1988 case EM_NIOS32
: return "Altera Nios";
1989 case EM_ALTERA_NIOS2
: return "Altera Nios II";
1991 case EM_XC16X
: return "Infineon Technologies xc16x";
1992 case EM_M16C
: return "Renesas M16C series microprocessors";
1993 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
1994 case EM_CE
: return "Freescale Communication Engine RISC core";
1995 case EM_TSK3000
: return "Altium TSK3000 core";
1996 case EM_RS08
: return "Freescale RS08 embedded processor";
1997 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
1998 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
1999 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2000 case EM_SE_C17
: return "Seiko Epson C17 family";
2001 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2002 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2003 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2004 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2005 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2006 case EM_R32C
: return "Renesas R32C series microprocessors";
2007 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2008 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2009 case EM_8051
: return "Intel 8051 and variants";
2010 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2011 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2012 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2013 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2014 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2015 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2016 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2017 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2019 case EM_CR16_OLD
: return "National Semiconductor's CR16";
2020 case EM_MICROBLAZE
: return "Xilinx MicroBlaze";
2021 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2022 case EM_RX
: return "Renesas RX";
2023 case EM_METAG
: return "Imagination Technologies META processor architecture";
2024 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2025 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2026 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2027 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2028 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
2029 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2030 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2031 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2032 case EM_CUDA
: return "NVIDIA CUDA architecture";
2034 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2040 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2045 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2046 e_flags
&= ~ EF_ARM_EABIMASK
;
2048 /* Handle "generic" ARM flags. */
2049 if (e_flags
& EF_ARM_RELEXEC
)
2051 strcat (buf
, ", relocatable executable");
2052 e_flags
&= ~ EF_ARM_RELEXEC
;
2055 if (e_flags
& EF_ARM_HASENTRY
)
2057 strcat (buf
, ", has entry point");
2058 e_flags
&= ~ EF_ARM_HASENTRY
;
2061 /* Now handle EABI specific flags. */
2065 strcat (buf
, ", <unrecognized EABI>");
2070 case EF_ARM_EABI_VER1
:
2071 strcat (buf
, ", Version1 EABI");
2076 /* Process flags one bit at a time. */
2077 flag
= e_flags
& - e_flags
;
2082 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2083 strcat (buf
, ", sorted symbol tables");
2093 case EF_ARM_EABI_VER2
:
2094 strcat (buf
, ", Version2 EABI");
2099 /* Process flags one bit at a time. */
2100 flag
= e_flags
& - e_flags
;
2105 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2106 strcat (buf
, ", sorted symbol tables");
2109 case EF_ARM_DYNSYMSUSESEGIDX
:
2110 strcat (buf
, ", dynamic symbols use segment index");
2113 case EF_ARM_MAPSYMSFIRST
:
2114 strcat (buf
, ", mapping symbols precede others");
2124 case EF_ARM_EABI_VER3
:
2125 strcat (buf
, ", Version3 EABI");
2128 case EF_ARM_EABI_VER4
:
2129 strcat (buf
, ", Version4 EABI");
2132 case EF_ARM_EABI_VER5
:
2133 strcat (buf
, ", Version5 EABI");
2139 /* Process flags one bit at a time. */
2140 flag
= e_flags
& - e_flags
;
2146 strcat (buf
, ", BE8");
2150 strcat (buf
, ", LE8");
2160 case EF_ARM_EABI_UNKNOWN
:
2161 strcat (buf
, ", GNU EABI");
2166 /* Process flags one bit at a time. */
2167 flag
= e_flags
& - e_flags
;
2172 case EF_ARM_INTERWORK
:
2173 strcat (buf
, ", interworking enabled");
2176 case EF_ARM_APCS_26
:
2177 strcat (buf
, ", uses APCS/26");
2180 case EF_ARM_APCS_FLOAT
:
2181 strcat (buf
, ", uses APCS/float");
2185 strcat (buf
, ", position independent");
2189 strcat (buf
, ", 8 bit structure alignment");
2192 case EF_ARM_NEW_ABI
:
2193 strcat (buf
, ", uses new ABI");
2196 case EF_ARM_OLD_ABI
:
2197 strcat (buf
, ", uses old ABI");
2200 case EF_ARM_SOFT_FLOAT
:
2201 strcat (buf
, ", software FP");
2204 case EF_ARM_VFP_FLOAT
:
2205 strcat (buf
, ", VFP");
2208 case EF_ARM_MAVERICK_FLOAT
:
2209 strcat (buf
, ", Maverick FP");
2220 strcat (buf
,_(", <unknown>"));
2224 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2226 static char buf
[1024];
2238 decode_ARM_machine_flags (e_flags
, buf
);
2242 if (e_flags
& EF_BFIN_PIC
)
2243 strcat (buf
, ", PIC");
2245 if (e_flags
& EF_BFIN_FDPIC
)
2246 strcat (buf
, ", FDPIC");
2248 if (e_flags
& EF_BFIN_CODE_IN_L1
)
2249 strcat (buf
, ", code in L1");
2251 if (e_flags
& EF_BFIN_DATA_IN_L1
)
2252 strcat (buf
, ", data in L1");
2257 switch (e_flags
& EF_FRV_CPU_MASK
)
2259 case EF_FRV_CPU_GENERIC
:
2263 strcat (buf
, ", fr???");
2266 case EF_FRV_CPU_FR300
:
2267 strcat (buf
, ", fr300");
2270 case EF_FRV_CPU_FR400
:
2271 strcat (buf
, ", fr400");
2273 case EF_FRV_CPU_FR405
:
2274 strcat (buf
, ", fr405");
2277 case EF_FRV_CPU_FR450
:
2278 strcat (buf
, ", fr450");
2281 case EF_FRV_CPU_FR500
:
2282 strcat (buf
, ", fr500");
2284 case EF_FRV_CPU_FR550
:
2285 strcat (buf
, ", fr550");
2288 case EF_FRV_CPU_SIMPLE
:
2289 strcat (buf
, ", simple");
2291 case EF_FRV_CPU_TOMCAT
:
2292 strcat (buf
, ", tomcat");
2298 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2299 strcat (buf
, ", m68000");
2300 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2301 strcat (buf
, ", cpu32");
2302 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2303 strcat (buf
, ", fido_a");
2306 char const * isa
= _("unknown");
2307 char const * mac
= _("unknown mac");
2308 char const * additional
= NULL
;
2310 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2312 case EF_M68K_CF_ISA_A_NODIV
:
2314 additional
= ", nodiv";
2316 case EF_M68K_CF_ISA_A
:
2319 case EF_M68K_CF_ISA_A_PLUS
:
2322 case EF_M68K_CF_ISA_B_NOUSP
:
2324 additional
= ", nousp";
2326 case EF_M68K_CF_ISA_B
:
2329 case EF_M68K_CF_ISA_C
:
2332 case EF_M68K_CF_ISA_C_NODIV
:
2334 additional
= ", nodiv";
2337 strcat (buf
, ", cf, isa ");
2340 strcat (buf
, additional
);
2341 if (e_flags
& EF_M68K_CF_FLOAT
)
2342 strcat (buf
, ", float");
2343 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2348 case EF_M68K_CF_MAC
:
2351 case EF_M68K_CF_EMAC
:
2354 case EF_M68K_CF_EMAC_B
:
2367 if (e_flags
& EF_PPC_EMB
)
2368 strcat (buf
, ", emb");
2370 if (e_flags
& EF_PPC_RELOCATABLE
)
2371 strcat (buf
, _(", relocatable"));
2373 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2374 strcat (buf
, _(", relocatable-lib"));
2378 case EM_CYGNUS_V850
:
2379 switch (e_flags
& EF_V850_ARCH
)
2381 case E_V850E2V3_ARCH
:
2382 strcat (buf
, ", v850e2v3");
2385 strcat (buf
, ", v850e2");
2388 strcat (buf
, ", v850e1");
2391 strcat (buf
, ", v850e");
2394 strcat (buf
, ", v850");
2397 strcat (buf
, _(", unknown v850 architecture variant"));
2403 case EM_CYGNUS_M32R
:
2404 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2405 strcat (buf
, ", m32r");
2409 case EM_MIPS_RS3_LE
:
2410 if (e_flags
& EF_MIPS_NOREORDER
)
2411 strcat (buf
, ", noreorder");
2413 if (e_flags
& EF_MIPS_PIC
)
2414 strcat (buf
, ", pic");
2416 if (e_flags
& EF_MIPS_CPIC
)
2417 strcat (buf
, ", cpic");
2419 if (e_flags
& EF_MIPS_UCODE
)
2420 strcat (buf
, ", ugen_reserved");
2422 if (e_flags
& EF_MIPS_ABI2
)
2423 strcat (buf
, ", abi2");
2425 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2426 strcat (buf
, ", odk first");
2428 if (e_flags
& EF_MIPS_32BITMODE
)
2429 strcat (buf
, ", 32bitmode");
2431 switch ((e_flags
& EF_MIPS_MACH
))
2433 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2434 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2435 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2436 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2437 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2438 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2439 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2440 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2441 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2442 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2443 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2444 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2445 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
2446 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2447 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
2448 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
2450 /* We simply ignore the field in this case to avoid confusion:
2451 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2454 default: strcat (buf
, _(", unknown CPU")); break;
2457 switch ((e_flags
& EF_MIPS_ABI
))
2459 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2460 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2461 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2462 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2464 /* We simply ignore the field in this case to avoid confusion:
2465 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2466 This means it is likely to be an o32 file, but not for
2469 default: strcat (buf
, _(", unknown ABI")); break;
2472 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2473 strcat (buf
, ", mdmx");
2475 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2476 strcat (buf
, ", mips16");
2478 switch ((e_flags
& EF_MIPS_ARCH
))
2480 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2481 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2482 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2483 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2484 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2485 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2486 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2487 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2488 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2489 default: strcat (buf
, _(", unknown ISA")); break;
2492 if (e_flags
& EF_SH_PIC
)
2493 strcat (buf
, ", pic");
2495 if (e_flags
& EF_SH_FDPIC
)
2496 strcat (buf
, ", fdpic");
2500 switch ((e_flags
& EF_SH_MACH_MASK
))
2502 case EF_SH1
: strcat (buf
, ", sh1"); break;
2503 case EF_SH2
: strcat (buf
, ", sh2"); break;
2504 case EF_SH3
: strcat (buf
, ", sh3"); break;
2505 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2506 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2507 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2508 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2509 case EF_SH4
: strcat (buf
, ", sh4"); break;
2510 case EF_SH5
: strcat (buf
, ", sh5"); break;
2511 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2512 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2513 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2514 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2515 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2516 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2517 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2518 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2519 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2520 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2521 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2522 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2523 default: strcat (buf
, _(", unknown ISA")); break;
2529 if (e_flags
& EF_SPARC_32PLUS
)
2530 strcat (buf
, ", v8+");
2532 if (e_flags
& EF_SPARC_SUN_US1
)
2533 strcat (buf
, ", ultrasparcI");
2535 if (e_flags
& EF_SPARC_SUN_US3
)
2536 strcat (buf
, ", ultrasparcIII");
2538 if (e_flags
& EF_SPARC_HAL_R1
)
2539 strcat (buf
, ", halr1");
2541 if (e_flags
& EF_SPARC_LEDATA
)
2542 strcat (buf
, ", ledata");
2544 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2545 strcat (buf
, ", tso");
2547 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2548 strcat (buf
, ", pso");
2550 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2551 strcat (buf
, ", rmo");
2555 switch (e_flags
& EF_PARISC_ARCH
)
2557 case EFA_PARISC_1_0
:
2558 strcpy (buf
, ", PA-RISC 1.0");
2560 case EFA_PARISC_1_1
:
2561 strcpy (buf
, ", PA-RISC 1.1");
2563 case EFA_PARISC_2_0
:
2564 strcpy (buf
, ", PA-RISC 2.0");
2569 if (e_flags
& EF_PARISC_TRAPNIL
)
2570 strcat (buf
, ", trapnil");
2571 if (e_flags
& EF_PARISC_EXT
)
2572 strcat (buf
, ", ext");
2573 if (e_flags
& EF_PARISC_LSB
)
2574 strcat (buf
, ", lsb");
2575 if (e_flags
& EF_PARISC_WIDE
)
2576 strcat (buf
, ", wide");
2577 if (e_flags
& EF_PARISC_NO_KABP
)
2578 strcat (buf
, ", no kabp");
2579 if (e_flags
& EF_PARISC_LAZYSWAP
)
2580 strcat (buf
, ", lazyswap");
2585 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2586 strcat (buf
, ", new calling convention");
2588 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2589 strcat (buf
, ", gnu calling convention");
2593 if ((e_flags
& EF_IA_64_ABI64
))
2594 strcat (buf
, ", 64-bit");
2596 strcat (buf
, ", 32-bit");
2597 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2598 strcat (buf
, ", reduced fp model");
2599 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2600 strcat (buf
, ", no function descriptors, constant gp");
2601 else if ((e_flags
& EF_IA_64_CONS_GP
))
2602 strcat (buf
, ", constant gp");
2603 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2604 strcat (buf
, ", absolute");
2605 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
2607 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
2608 strcat (buf
, ", vms_linkages");
2609 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
2611 case EF_IA_64_VMS_COMCOD_SUCCESS
:
2613 case EF_IA_64_VMS_COMCOD_WARNING
:
2614 strcat (buf
, ", warning");
2616 case EF_IA_64_VMS_COMCOD_ERROR
:
2617 strcat (buf
, ", error");
2619 case EF_IA_64_VMS_COMCOD_ABORT
:
2620 strcat (buf
, ", abort");
2629 if ((e_flags
& EF_VAX_NONPIC
))
2630 strcat (buf
, ", non-PIC");
2631 if ((e_flags
& EF_VAX_DFLOAT
))
2632 strcat (buf
, ", D-Float");
2633 if ((e_flags
& EF_VAX_GFLOAT
))
2634 strcat (buf
, ", G-Float");
2638 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
2639 strcat (buf
, ", 64-bit doubles");
2640 if (e_flags
& E_FLAG_RX_DSP
)
2641 strcat (buf
, ", dsp");
2644 if (e_flags
& EF_S390_HIGH_GPRS
)
2645 strcat (buf
, ", highgprs");
2648 if ((e_flags
& EF_C6000_REL
))
2649 strcat (buf
, ", relocatable module");
2657 get_osabi_name (unsigned int osabi
)
2659 static char buff
[32];
2663 case ELFOSABI_NONE
: return "UNIX - System V";
2664 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2665 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2666 case ELFOSABI_LINUX
: return "UNIX - Linux";
2667 case ELFOSABI_HURD
: return "GNU/Hurd";
2668 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2669 case ELFOSABI_AIX
: return "UNIX - AIX";
2670 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2671 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2672 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2673 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2674 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2675 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2676 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2677 case ELFOSABI_AROS
: return "AROS";
2678 case ELFOSABI_FENIXOS
: return "FenixOS";
2681 switch (elf_header
.e_machine
)
2686 case ELFOSABI_ARM
: return "ARM";
2696 case ELFOSABI_STANDALONE
: return _("Standalone App");
2705 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
2706 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
2715 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2721 get_arm_segment_type (unsigned long type
)
2735 get_mips_segment_type (unsigned long type
)
2739 case PT_MIPS_REGINFO
:
2741 case PT_MIPS_RTPROC
:
2743 case PT_MIPS_OPTIONS
:
2753 get_parisc_segment_type (unsigned long type
)
2757 case PT_HP_TLS
: return "HP_TLS";
2758 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2759 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2760 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2761 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2762 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2763 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2764 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2765 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2766 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2767 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2768 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2769 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2770 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2771 case PT_HP_STACK
: return "HP_STACK";
2772 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2773 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2774 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2775 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2784 get_ia64_segment_type (unsigned long type
)
2788 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2789 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2790 case PT_HP_TLS
: return "HP_TLS";
2791 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2792 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2793 case PT_IA_64_HP_STACK
: return "HP_STACK";
2802 get_tic6x_segment_type (unsigned long type
)
2806 case PT_C6000_PHATTR
: return "C6000_PHATTR";
2815 get_segment_type (unsigned long p_type
)
2817 static char buff
[32];
2821 case PT_NULL
: return "NULL";
2822 case PT_LOAD
: return "LOAD";
2823 case PT_DYNAMIC
: return "DYNAMIC";
2824 case PT_INTERP
: return "INTERP";
2825 case PT_NOTE
: return "NOTE";
2826 case PT_SHLIB
: return "SHLIB";
2827 case PT_PHDR
: return "PHDR";
2828 case PT_TLS
: return "TLS";
2830 case PT_GNU_EH_FRAME
:
2831 return "GNU_EH_FRAME";
2832 case PT_GNU_STACK
: return "GNU_STACK";
2833 case PT_GNU_RELRO
: return "GNU_RELRO";
2836 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2838 const char * result
;
2840 switch (elf_header
.e_machine
)
2843 result
= get_arm_segment_type (p_type
);
2846 case EM_MIPS_RS3_LE
:
2847 result
= get_mips_segment_type (p_type
);
2850 result
= get_parisc_segment_type (p_type
);
2853 result
= get_ia64_segment_type (p_type
);
2856 result
= get_tic6x_segment_type (p_type
);
2866 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2868 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2870 const char * result
;
2872 switch (elf_header
.e_machine
)
2875 result
= get_parisc_segment_type (p_type
);
2878 result
= get_ia64_segment_type (p_type
);
2888 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2891 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2898 get_mips_section_type_name (unsigned int sh_type
)
2902 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2903 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2904 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2905 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2906 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2907 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2908 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2909 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2910 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2911 case SHT_MIPS_RELD
: return "MIPS_RELD";
2912 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2913 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2914 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2915 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2916 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2917 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2918 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2919 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2920 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2921 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2922 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2923 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2924 case SHT_MIPS_LINE
: return "MIPS_LINE";
2925 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2926 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2927 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2928 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2929 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2930 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2931 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2932 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2933 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2934 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2935 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2936 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2937 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2938 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2939 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2940 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2948 get_parisc_section_type_name (unsigned int sh_type
)
2952 case SHT_PARISC_EXT
: return "PARISC_EXT";
2953 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2954 case SHT_PARISC_DOC
: return "PARISC_DOC";
2955 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2956 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2957 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2958 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2966 get_ia64_section_type_name (unsigned int sh_type
)
2968 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2969 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2970 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2974 case SHT_IA_64_EXT
: return "IA_64_EXT";
2975 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2976 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2977 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
2978 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
2979 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
2980 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
2981 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
2982 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
2983 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
2991 get_x86_64_section_type_name (unsigned int sh_type
)
2995 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3003 get_arm_section_type_name (unsigned int sh_type
)
3007 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3008 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3009 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3010 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3011 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
3019 get_tic6x_section_type_name (unsigned int sh_type
)
3023 case SHT_C6000_UNWIND
:
3024 return "C6000_UNWIND";
3025 case SHT_C6000_PREEMPTMAP
:
3026 return "C6000_PREEMPTMAP";
3027 case SHT_C6000_ATTRIBUTES
:
3028 return "C6000_ATTRIBUTES";
3033 case SHT_TI_HANDLER
:
3034 return "TI_HANDLER";
3035 case SHT_TI_INITINFO
:
3036 return "TI_INITINFO";
3037 case SHT_TI_PHATTRS
:
3038 return "TI_PHATTRS";
3046 get_section_type_name (unsigned int sh_type
)
3048 static char buff
[32];
3052 case SHT_NULL
: return "NULL";
3053 case SHT_PROGBITS
: return "PROGBITS";
3054 case SHT_SYMTAB
: return "SYMTAB";
3055 case SHT_STRTAB
: return "STRTAB";
3056 case SHT_RELA
: return "RELA";
3057 case SHT_HASH
: return "HASH";
3058 case SHT_DYNAMIC
: return "DYNAMIC";
3059 case SHT_NOTE
: return "NOTE";
3060 case SHT_NOBITS
: return "NOBITS";
3061 case SHT_REL
: return "REL";
3062 case SHT_SHLIB
: return "SHLIB";
3063 case SHT_DYNSYM
: return "DYNSYM";
3064 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
3065 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
3066 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
3067 case SHT_GNU_HASH
: return "GNU_HASH";
3068 case SHT_GROUP
: return "GROUP";
3069 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
3070 case SHT_GNU_verdef
: return "VERDEF";
3071 case SHT_GNU_verneed
: return "VERNEED";
3072 case SHT_GNU_versym
: return "VERSYM";
3073 case 0x6ffffff0: return "VERSYM";
3074 case 0x6ffffffc: return "VERDEF";
3075 case 0x7ffffffd: return "AUXILIARY";
3076 case 0x7fffffff: return "FILTER";
3077 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
3080 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
3082 const char * result
;
3084 switch (elf_header
.e_machine
)
3087 case EM_MIPS_RS3_LE
:
3088 result
= get_mips_section_type_name (sh_type
);
3091 result
= get_parisc_section_type_name (sh_type
);
3094 result
= get_ia64_section_type_name (sh_type
);
3098 result
= get_x86_64_section_type_name (sh_type
);
3101 result
= get_arm_section_type_name (sh_type
);
3104 result
= get_tic6x_section_type_name (sh_type
);
3114 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
3116 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
3118 const char * result
;
3120 switch (elf_header
.e_machine
)
3123 result
= get_ia64_section_type_name (sh_type
);
3133 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
3135 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
3136 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
3138 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
3144 #define OPTION_DEBUG_DUMP 512
3145 #define OPTION_DYN_SYMS 513
3147 static struct option options
[] =
3149 {"all", no_argument
, 0, 'a'},
3150 {"file-header", no_argument
, 0, 'h'},
3151 {"program-headers", no_argument
, 0, 'l'},
3152 {"headers", no_argument
, 0, 'e'},
3153 {"histogram", no_argument
, 0, 'I'},
3154 {"segments", no_argument
, 0, 'l'},
3155 {"sections", no_argument
, 0, 'S'},
3156 {"section-headers", no_argument
, 0, 'S'},
3157 {"section-groups", no_argument
, 0, 'g'},
3158 {"section-details", no_argument
, 0, 't'},
3159 {"full-section-name",no_argument
, 0, 'N'},
3160 {"symbols", no_argument
, 0, 's'},
3161 {"syms", no_argument
, 0, 's'},
3162 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
3163 {"relocs", no_argument
, 0, 'r'},
3164 {"notes", no_argument
, 0, 'n'},
3165 {"dynamic", no_argument
, 0, 'd'},
3166 {"arch-specific", no_argument
, 0, 'A'},
3167 {"version-info", no_argument
, 0, 'V'},
3168 {"use-dynamic", no_argument
, 0, 'D'},
3169 {"unwind", no_argument
, 0, 'u'},
3170 {"archive-index", no_argument
, 0, 'c'},
3171 {"hex-dump", required_argument
, 0, 'x'},
3172 {"relocated-dump", required_argument
, 0, 'R'},
3173 {"string-dump", required_argument
, 0, 'p'},
3174 #ifdef SUPPORT_DISASSEMBLY
3175 {"instruction-dump", required_argument
, 0, 'i'},
3177 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
3179 {"version", no_argument
, 0, 'v'},
3180 {"wide", no_argument
, 0, 'W'},
3181 {"help", no_argument
, 0, 'H'},
3182 {0, no_argument
, 0, 0}
3186 usage (FILE * stream
)
3188 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
3189 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
3190 fprintf (stream
, _(" Options are:\n\
3191 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3192 -h --file-header Display the ELF file header\n\
3193 -l --program-headers Display the program headers\n\
3194 --segments An alias for --program-headers\n\
3195 -S --section-headers Display the sections' header\n\
3196 --sections An alias for --section-headers\n\
3197 -g --section-groups Display the section groups\n\
3198 -t --section-details Display the section details\n\
3199 -e --headers Equivalent to: -h -l -S\n\
3200 -s --syms Display the symbol table\n\
3201 --symbols An alias for --syms\n\
3202 --dyn-syms Display the dynamic symbol table\n\
3203 -n --notes Display the core notes (if present)\n\
3204 -r --relocs Display the relocations (if present)\n\
3205 -u --unwind Display the unwind info (if present)\n\
3206 -d --dynamic Display the dynamic section (if present)\n\
3207 -V --version-info Display the version sections (if present)\n\
3208 -A --arch-specific Display architecture specific information (if any).\n\
3209 -c --archive-index Display the symbol/file index in an archive\n\
3210 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3211 -x --hex-dump=<number|name>\n\
3212 Dump the contents of section <number|name> as bytes\n\
3213 -p --string-dump=<number|name>\n\
3214 Dump the contents of section <number|name> as strings\n\
3215 -R --relocated-dump=<number|name>\n\
3216 Dump the contents of section <number|name> as relocated bytes\n\
3217 -w[lLiaprmfFsoRt] or\n\
3218 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3219 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3220 =trace_info,=trace_abbrev,=trace_aranges]\n\
3221 Display the contents of DWARF2 debug sections\n"));
3222 #ifdef SUPPORT_DISASSEMBLY
3223 fprintf (stream
, _("\
3224 -i --instruction-dump=<number|name>\n\
3225 Disassemble the contents of section <number|name>\n"));
3227 fprintf (stream
, _("\
3228 -I --histogram Display histogram of bucket list lengths\n\
3229 -W --wide Allow output width to exceed 80 characters\n\
3230 @<file> Read options from <file>\n\
3231 -H --help Display this information\n\
3232 -v --version Display the version number of readelf\n"));
3234 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3235 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
3237 exit (stream
== stdout
? 0 : 1);
3240 /* Record the fact that the user wants the contents of section number
3241 SECTION to be displayed using the method(s) encoded as flags bits
3242 in TYPE. Note, TYPE can be zero if we are creating the array for
3246 request_dump_bynumber (unsigned int section
, dump_type type
)
3248 if (section
>= num_dump_sects
)
3250 dump_type
* new_dump_sects
;
3252 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
3253 sizeof (* dump_sects
));
3255 if (new_dump_sects
== NULL
)
3256 error (_("Out of memory allocating dump request table.\n"));
3259 /* Copy current flag settings. */
3260 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
3264 dump_sects
= new_dump_sects
;
3265 num_dump_sects
= section
+ 1;
3270 dump_sects
[section
] |= type
;
3275 /* Request a dump by section name. */
3278 request_dump_byname (const char * section
, dump_type type
)
3280 struct dump_list_entry
* new_request
;
3282 new_request
= (struct dump_list_entry
*)
3283 malloc (sizeof (struct dump_list_entry
));
3285 error (_("Out of memory allocating dump request table.\n"));
3287 new_request
->name
= strdup (section
);
3288 if (!new_request
->name
)
3289 error (_("Out of memory allocating dump request table.\n"));
3291 new_request
->type
= type
;
3293 new_request
->next
= dump_sects_byname
;
3294 dump_sects_byname
= new_request
;
3298 request_dump (dump_type type
)
3304 section
= strtoul (optarg
, & cp
, 0);
3306 if (! *cp
&& section
>= 0)
3307 request_dump_bynumber (section
, type
);
3309 request_dump_byname (optarg
, type
);
3314 parse_args (int argc
, char ** argv
)
3321 while ((c
= getopt_long
3322 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
3340 do_section_groups
++;
3348 do_section_groups
++;
3353 do_section_details
++;
3397 request_dump (HEX_DUMP
);
3400 request_dump (STRING_DUMP
);
3403 request_dump (RELOC_DUMP
);
3410 dwarf_select_sections_all ();
3415 dwarf_select_sections_by_letters (optarg
);
3418 case OPTION_DEBUG_DUMP
:
3425 dwarf_select_sections_by_names (optarg
);
3428 case OPTION_DYN_SYMS
:
3431 #ifdef SUPPORT_DISASSEMBLY
3433 request_dump (DISASS_DUMP
);
3437 print_version (program_name
);
3446 /* xgettext:c-format */
3447 error (_("Invalid option '-%c'\n"), c
);
3454 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3455 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3456 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3457 && !do_section_groups
&& !do_archive_index
3462 warn (_("Nothing to do.\n"));
3468 get_elf_class (unsigned int elf_class
)
3470 static char buff
[32];
3474 case ELFCLASSNONE
: return _("none");
3475 case ELFCLASS32
: return "ELF32";
3476 case ELFCLASS64
: return "ELF64";
3478 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3484 get_data_encoding (unsigned int encoding
)
3486 static char buff
[32];
3490 case ELFDATANONE
: return _("none");
3491 case ELFDATA2LSB
: return _("2's complement, little endian");
3492 case ELFDATA2MSB
: return _("2's complement, big endian");
3494 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3499 /* Decode the data held in 'elf_header'. */
3502 process_file_header (void)
3504 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3505 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3506 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3507 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3510 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3514 init_dwarf_regnames (elf_header
.e_machine
);
3520 printf (_("ELF Header:\n"));
3521 printf (_(" Magic: "));
3522 for (i
= 0; i
< EI_NIDENT
; i
++)
3523 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3525 printf (_(" Class: %s\n"),
3526 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3527 printf (_(" Data: %s\n"),
3528 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3529 printf (_(" Version: %d %s\n"),
3530 elf_header
.e_ident
[EI_VERSION
],
3531 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3533 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3534 ? _("<unknown: %lx>")
3536 printf (_(" OS/ABI: %s\n"),
3537 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3538 printf (_(" ABI Version: %d\n"),
3539 elf_header
.e_ident
[EI_ABIVERSION
]);
3540 printf (_(" Type: %s\n"),
3541 get_file_type (elf_header
.e_type
));
3542 printf (_(" Machine: %s\n"),
3543 get_machine_name (elf_header
.e_machine
));
3544 printf (_(" Version: 0x%lx\n"),
3545 (unsigned long) elf_header
.e_version
);
3547 printf (_(" Entry point address: "));
3548 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3549 printf (_("\n Start of program headers: "));
3550 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3551 printf (_(" (bytes into file)\n Start of section headers: "));
3552 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3553 printf (_(" (bytes into file)\n"));
3555 printf (_(" Flags: 0x%lx%s\n"),
3556 (unsigned long) elf_header
.e_flags
,
3557 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3558 printf (_(" Size of this header: %ld (bytes)\n"),
3559 (long) elf_header
.e_ehsize
);
3560 printf (_(" Size of program headers: %ld (bytes)\n"),
3561 (long) elf_header
.e_phentsize
);
3562 printf (_(" Number of program headers: %ld"),
3563 (long) elf_header
.e_phnum
);
3564 if (section_headers
!= NULL
3565 && elf_header
.e_phnum
== PN_XNUM
3566 && section_headers
[0].sh_info
!= 0)
3567 printf (" (%ld)", (long) section_headers
[0].sh_info
);
3568 putc ('\n', stdout
);
3569 printf (_(" Size of section headers: %ld (bytes)\n"),
3570 (long) elf_header
.e_shentsize
);
3571 printf (_(" Number of section headers: %ld"),
3572 (long) elf_header
.e_shnum
);
3573 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
3574 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3575 putc ('\n', stdout
);
3576 printf (_(" Section header string table index: %ld"),
3577 (long) elf_header
.e_shstrndx
);
3578 if (section_headers
!= NULL
3579 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3580 printf (" (%u)", section_headers
[0].sh_link
);
3581 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3582 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3583 printf (_(" <corrupt: out of range>"));
3584 putc ('\n', stdout
);
3587 if (section_headers
!= NULL
)
3589 if (elf_header
.e_phnum
== PN_XNUM
3590 && section_headers
[0].sh_info
!= 0)
3591 elf_header
.e_phnum
= section_headers
[0].sh_info
;
3592 if (elf_header
.e_shnum
== SHN_UNDEF
)
3593 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3594 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3595 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3596 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3597 elf_header
.e_shstrndx
= SHN_UNDEF
;
3598 free (section_headers
);
3599 section_headers
= NULL
;
3607 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3609 Elf32_External_Phdr
* phdrs
;
3610 Elf32_External_Phdr
* external
;
3611 Elf_Internal_Phdr
* internal
;
3614 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3615 elf_header
.e_phentsize
,
3617 _("program headers"));
3621 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3622 i
< elf_header
.e_phnum
;
3623 i
++, internal
++, external
++)
3625 internal
->p_type
= BYTE_GET (external
->p_type
);
3626 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3627 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3628 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3629 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3630 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3631 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3632 internal
->p_align
= BYTE_GET (external
->p_align
);
3641 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3643 Elf64_External_Phdr
* phdrs
;
3644 Elf64_External_Phdr
* external
;
3645 Elf_Internal_Phdr
* internal
;
3648 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3649 elf_header
.e_phentsize
,
3651 _("program headers"));
3655 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3656 i
< elf_header
.e_phnum
;
3657 i
++, internal
++, external
++)
3659 internal
->p_type
= BYTE_GET (external
->p_type
);
3660 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3661 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3662 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3663 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3664 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3665 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3666 internal
->p_align
= BYTE_GET (external
->p_align
);
3674 /* Returns 1 if the program headers were read into `program_headers'. */
3677 get_program_headers (FILE * file
)
3679 Elf_Internal_Phdr
* phdrs
;
3681 /* Check cache of prior read. */
3682 if (program_headers
!= NULL
)
3685 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
3686 sizeof (Elf_Internal_Phdr
));
3690 error (_("Out of memory\n"));
3695 ? get_32bit_program_headers (file
, phdrs
)
3696 : get_64bit_program_headers (file
, phdrs
))
3698 program_headers
= phdrs
;
3706 /* Returns 1 if the program headers were loaded. */
3709 process_program_headers (FILE * file
)
3711 Elf_Internal_Phdr
* segment
;
3714 if (elf_header
.e_phnum
== 0)
3717 printf (_("\nThere are no program headers in this file.\n"));
3721 if (do_segments
&& !do_header
)
3723 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3724 printf (_("Entry point "));
3725 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3726 printf (_("\nThere are %d program headers, starting at offset "),
3727 elf_header
.e_phnum
);
3728 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3732 if (! get_program_headers (file
))
3737 if (elf_header
.e_phnum
> 1)
3738 printf (_("\nProgram Headers:\n"));
3740 printf (_("\nProgram Headers:\n"));
3744 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3747 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3751 (_(" Type Offset VirtAddr PhysAddr\n"));
3753 (_(" FileSiz MemSiz Flags Align\n"));
3760 for (i
= 0, segment
= program_headers
;
3761 i
< elf_header
.e_phnum
;
3766 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3770 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3771 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3772 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3773 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3774 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3776 (segment
->p_flags
& PF_R
? 'R' : ' '),
3777 (segment
->p_flags
& PF_W
? 'W' : ' '),
3778 (segment
->p_flags
& PF_X
? 'E' : ' '));
3779 printf ("%#lx", (unsigned long) segment
->p_align
);
3783 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3784 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3787 print_vma (segment
->p_offset
, FULL_HEX
);
3791 print_vma (segment
->p_vaddr
, FULL_HEX
);
3793 print_vma (segment
->p_paddr
, FULL_HEX
);
3796 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3797 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3800 print_vma (segment
->p_filesz
, FULL_HEX
);
3804 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3805 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3808 print_vma (segment
->p_offset
, FULL_HEX
);
3812 (segment
->p_flags
& PF_R
? 'R' : ' '),
3813 (segment
->p_flags
& PF_W
? 'W' : ' '),
3814 (segment
->p_flags
& PF_X
? 'E' : ' '));
3816 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3817 printf ("%#lx", (unsigned long) segment
->p_align
);
3820 print_vma (segment
->p_align
, PREFIX_HEX
);
3825 print_vma (segment
->p_offset
, FULL_HEX
);
3827 print_vma (segment
->p_vaddr
, FULL_HEX
);
3829 print_vma (segment
->p_paddr
, FULL_HEX
);
3831 print_vma (segment
->p_filesz
, FULL_HEX
);
3833 print_vma (segment
->p_memsz
, FULL_HEX
);
3835 (segment
->p_flags
& PF_R
? 'R' : ' '),
3836 (segment
->p_flags
& PF_W
? 'W' : ' '),
3837 (segment
->p_flags
& PF_X
? 'E' : ' '));
3838 print_vma (segment
->p_align
, HEX
);
3842 switch (segment
->p_type
)
3846 error (_("more than one dynamic segment\n"));
3848 /* By default, assume that the .dynamic section is the first
3849 section in the DYNAMIC segment. */
3850 dynamic_addr
= segment
->p_offset
;
3851 dynamic_size
= segment
->p_filesz
;
3853 /* Try to locate the .dynamic section. If there is
3854 a section header table, we can easily locate it. */
3855 if (section_headers
!= NULL
)
3857 Elf_Internal_Shdr
* sec
;
3859 sec
= find_section (".dynamic");
3860 if (sec
== NULL
|| sec
->sh_size
== 0)
3862 /* A corresponding .dynamic section is expected, but on
3863 IA-64/OpenVMS it is OK for it to be missing. */
3864 if (!is_ia64_vms ())
3865 error (_("no .dynamic section in the dynamic segment\n"));
3869 if (sec
->sh_type
== SHT_NOBITS
)
3875 dynamic_addr
= sec
->sh_offset
;
3876 dynamic_size
= sec
->sh_size
;
3878 if (dynamic_addr
< segment
->p_offset
3879 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3880 warn (_("the .dynamic section is not contained"
3881 " within the dynamic segment\n"));
3882 else if (dynamic_addr
> segment
->p_offset
)
3883 warn (_("the .dynamic section is not the first section"
3884 " in the dynamic segment.\n"));
3889 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3891 error (_("Unable to find program interpreter name\n"));
3895 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
3897 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
3898 error (_("Internal error: failed to create format string to display program interpreter\n"));
3900 program_interpreter
[0] = 0;
3901 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
3902 error (_("Unable to read program interpreter name\n"));
3905 printf (_("\n [Requesting program interpreter: %s]"),
3906 program_interpreter
);
3912 putc ('\n', stdout
);
3915 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3917 printf (_("\n Section to Segment mapping:\n"));
3918 printf (_(" Segment Sections...\n"));
3920 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3923 Elf_Internal_Shdr
* section
;
3925 segment
= program_headers
+ i
;
3926 section
= section_headers
+ 1;
3928 printf (" %2.2d ", i
);
3930 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3932 if (!ELF_TBSS_SPECIAL (section
, segment
)
3933 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
3934 printf ("%s ", SECTION_NAME (section
));
3945 /* Find the file offset corresponding to VMA by using the program headers. */
3948 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
3950 Elf_Internal_Phdr
* seg
;
3952 if (! get_program_headers (file
))
3954 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3958 for (seg
= program_headers
;
3959 seg
< program_headers
+ elf_header
.e_phnum
;
3962 if (seg
->p_type
!= PT_LOAD
)
3965 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3966 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3967 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3970 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3971 (unsigned long) vma
);
3977 get_32bit_section_headers (FILE * file
, unsigned int num
)
3979 Elf32_External_Shdr
* shdrs
;
3980 Elf_Internal_Shdr
* internal
;
3983 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
3984 elf_header
.e_shentsize
, num
,
3985 _("section headers"));
3989 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
3990 sizeof (Elf_Internal_Shdr
));
3992 if (section_headers
== NULL
)
3994 error (_("Out of memory\n"));
3998 for (i
= 0, internal
= section_headers
;
4002 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4003 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4004 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4005 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4006 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4007 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4008 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4009 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4010 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4011 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4020 get_64bit_section_headers (FILE * file
, unsigned int num
)
4022 Elf64_External_Shdr
* shdrs
;
4023 Elf_Internal_Shdr
* internal
;
4026 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4027 elf_header
.e_shentsize
, num
,
4028 _("section headers"));
4032 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4033 sizeof (Elf_Internal_Shdr
));
4035 if (section_headers
== NULL
)
4037 error (_("Out of memory\n"));
4041 for (i
= 0, internal
= section_headers
;
4045 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4046 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4047 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4048 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4049 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4050 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4051 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4052 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4053 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4054 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4062 static Elf_Internal_Sym
*
4063 get_32bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
4065 unsigned long number
;
4066 Elf32_External_Sym
* esyms
= NULL
;
4067 Elf_External_Sym_Shndx
* shndx
;
4068 Elf_Internal_Sym
* isyms
= NULL
;
4069 Elf_Internal_Sym
* psym
;
4072 /* Run some sanity checks first. */
4073 if (section
->sh_entsize
== 0)
4075 error (_("sh_entsize is zero\n"));
4079 number
= section
->sh_size
/ section
->sh_entsize
;
4081 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
4083 error (_("Invalid sh_entsize\n"));
4087 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4088 section
->sh_size
, _("symbols"));
4093 if (symtab_shndx_hdr
!= NULL
4094 && (symtab_shndx_hdr
->sh_link
4095 == (unsigned long) (section
- section_headers
)))
4097 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4098 symtab_shndx_hdr
->sh_offset
,
4099 1, symtab_shndx_hdr
->sh_size
,
4105 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4109 error (_("Out of memory\n"));
4113 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4115 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4116 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4117 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4118 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4119 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4121 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4122 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4123 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4124 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4125 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4137 static Elf_Internal_Sym
*
4138 get_64bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
4140 unsigned long number
;
4141 Elf64_External_Sym
* esyms
;
4142 Elf_External_Sym_Shndx
* shndx
;
4143 Elf_Internal_Sym
* isyms
;
4144 Elf_Internal_Sym
* psym
;
4147 /* Run some sanity checks first. */
4148 if (section
->sh_entsize
== 0)
4150 error (_("sh_entsize is zero\n"));
4154 number
= section
->sh_size
/ section
->sh_entsize
;
4156 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
4158 error (_("Invalid sh_entsize\n"));
4162 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4163 section
->sh_size
, _("symbols"));
4168 if (symtab_shndx_hdr
!= NULL
4169 && (symtab_shndx_hdr
->sh_link
4170 == (unsigned long) (section
- section_headers
)))
4172 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4173 symtab_shndx_hdr
->sh_offset
,
4174 1, symtab_shndx_hdr
->sh_size
,
4183 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4187 error (_("Out of memory\n"));
4194 for (j
= 0, psym
= isyms
;
4198 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4199 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4200 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4201 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4202 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4204 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4205 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4206 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4207 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4208 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4219 get_elf_section_flags (bfd_vma sh_flags
)
4221 static char buff
[1024];
4223 int field_size
= is_32bit_elf
? 8 : 16;
4225 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
4226 bfd_vma os_flags
= 0;
4227 bfd_vma proc_flags
= 0;
4228 bfd_vma unknown_flags
= 0;
4236 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4237 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4238 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4239 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4240 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4241 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4242 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4243 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4244 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4245 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4246 /* IA-64 specific. */
4247 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4248 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4249 /* IA-64 OpenVMS specific. */
4250 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4251 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4252 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4253 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4254 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4255 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4257 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4258 /* SPARC specific. */
4259 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4262 if (do_section_details
)
4264 sprintf (buff
, "[%*.*lx]: ",
4265 field_size
, field_size
, (unsigned long) sh_flags
);
4266 p
+= field_size
+ 4;
4273 flag
= sh_flags
& - sh_flags
;
4276 if (do_section_details
)
4280 case SHF_WRITE
: sindex
= 0; break;
4281 case SHF_ALLOC
: sindex
= 1; break;
4282 case SHF_EXECINSTR
: sindex
= 2; break;
4283 case SHF_MERGE
: sindex
= 3; break;
4284 case SHF_STRINGS
: sindex
= 4; break;
4285 case SHF_INFO_LINK
: sindex
= 5; break;
4286 case SHF_LINK_ORDER
: sindex
= 6; break;
4287 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
4288 case SHF_GROUP
: sindex
= 8; break;
4289 case SHF_TLS
: sindex
= 9; break;
4290 case SHF_EXCLUDE
: sindex
= 18; break;
4294 switch (elf_header
.e_machine
)
4297 if (flag
== SHF_IA_64_SHORT
)
4299 else if (flag
== SHF_IA_64_NORECOV
)
4302 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
4305 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
4306 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
4307 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
4308 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
4309 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
4310 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
4320 case EM_OLD_SPARCV9
:
4321 case EM_SPARC32PLUS
:
4324 if (flag
== SHF_ORDERED
)
4334 if (p
!= buff
+ field_size
+ 4)
4336 if (size
< (10 + 2))
4343 size
-= flags
[sindex
].len
;
4344 p
= stpcpy (p
, flags
[sindex
].str
);
4346 else if (flag
& SHF_MASKOS
)
4348 else if (flag
& SHF_MASKPROC
)
4351 unknown_flags
|= flag
;
4357 case SHF_WRITE
: *p
= 'W'; break;
4358 case SHF_ALLOC
: *p
= 'A'; break;
4359 case SHF_EXECINSTR
: *p
= 'X'; break;
4360 case SHF_MERGE
: *p
= 'M'; break;
4361 case SHF_STRINGS
: *p
= 'S'; break;
4362 case SHF_INFO_LINK
: *p
= 'I'; break;
4363 case SHF_LINK_ORDER
: *p
= 'L'; break;
4364 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
4365 case SHF_GROUP
: *p
= 'G'; break;
4366 case SHF_TLS
: *p
= 'T'; break;
4367 case SHF_EXCLUDE
: *p
= 'E'; break;
4370 if ((elf_header
.e_machine
== EM_X86_64
4371 || elf_header
.e_machine
== EM_L1OM
)
4372 && flag
== SHF_X86_64_LARGE
)
4374 else if (flag
& SHF_MASKOS
)
4377 sh_flags
&= ~ SHF_MASKOS
;
4379 else if (flag
& SHF_MASKPROC
)
4382 sh_flags
&= ~ SHF_MASKPROC
;
4392 if (do_section_details
)
4396 size
-= 5 + field_size
;
4397 if (p
!= buff
+ field_size
+ 4)
4405 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4406 (unsigned long) os_flags
);
4407 p
+= 5 + field_size
;
4411 size
-= 7 + field_size
;
4412 if (p
!= buff
+ field_size
+ 4)
4420 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4421 (unsigned long) proc_flags
);
4422 p
+= 7 + field_size
;
4426 size
-= 10 + field_size
;
4427 if (p
!= buff
+ field_size
+ 4)
4435 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
4436 (unsigned long) unknown_flags
);
4437 p
+= 10 + field_size
;
4446 process_section_headers (FILE * file
)
4448 Elf_Internal_Shdr
* section
;
4451 section_headers
= NULL
;
4453 if (elf_header
.e_shnum
== 0)
4456 printf (_("\nThere are no sections in this file.\n"));
4461 if (do_sections
&& !do_header
)
4462 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4463 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4467 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4470 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4473 /* Read in the string table, so that we have names to display. */
4474 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4475 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4477 section
= section_headers
+ elf_header
.e_shstrndx
;
4479 if (section
->sh_size
!= 0)
4481 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4482 1, section
->sh_size
,
4485 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4489 /* Scan the sections for the dynamic symbol table
4490 and dynamic string table and debug sections. */
4491 dynamic_symbols
= NULL
;
4492 dynamic_strings
= NULL
;
4493 dynamic_syminfo
= NULL
;
4494 symtab_shndx_hdr
= NULL
;
4496 eh_addr_size
= is_32bit_elf
? 4 : 8;
4497 switch (elf_header
.e_machine
)
4500 case EM_MIPS_RS3_LE
:
4501 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4502 FDE addresses. However, the ABI also has a semi-official ILP32
4503 variant for which the normal FDE address size rules apply.
4505 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4506 section, where XX is the size of longs in bits. Unfortunately,
4507 earlier compilers provided no way of distinguishing ILP32 objects
4508 from LP64 objects, so if there's any doubt, we should assume that
4509 the official LP64 form is being used. */
4510 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4511 && find_section (".gcc_compiled_long32") == NULL
)
4517 switch (elf_header
.e_flags
& EF_H8_MACH
)
4519 case E_H8_MACH_H8300
:
4520 case E_H8_MACH_H8300HN
:
4521 case E_H8_MACH_H8300SN
:
4522 case E_H8_MACH_H8300SXN
:
4525 case E_H8_MACH_H8300H
:
4526 case E_H8_MACH_H8300S
:
4527 case E_H8_MACH_H8300SX
:
4535 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
4537 case EF_M32C_CPU_M16C
:
4544 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4547 size_t expected_entsize \
4548 = is_32bit_elf ? size32 : size64; \
4549 if (section->sh_entsize != expected_entsize) \
4550 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4551 i, (unsigned long int) section->sh_entsize, \
4552 (unsigned long int) expected_entsize); \
4553 section->sh_entsize = expected_entsize; \
4556 #define CHECK_ENTSIZE(section, i, type) \
4557 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4558 sizeof (Elf64_External_##type))
4560 for (i
= 0, section
= section_headers
;
4561 i
< elf_header
.e_shnum
;
4564 char * name
= SECTION_NAME (section
);
4566 if (section
->sh_type
== SHT_DYNSYM
)
4568 if (dynamic_symbols
!= NULL
)
4570 error (_("File contains multiple dynamic symbol tables\n"));
4574 CHECK_ENTSIZE (section
, i
, Sym
);
4575 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4576 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4578 else if (section
->sh_type
== SHT_STRTAB
4579 && streq (name
, ".dynstr"))
4581 if (dynamic_strings
!= NULL
)
4583 error (_("File contains multiple dynamic string tables\n"));
4587 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4588 1, section
->sh_size
,
4589 _("dynamic strings"));
4590 dynamic_strings_length
= section
->sh_size
;
4592 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4594 if (symtab_shndx_hdr
!= NULL
)
4596 error (_("File contains multiple symtab shndx tables\n"));
4599 symtab_shndx_hdr
= section
;
4601 else if (section
->sh_type
== SHT_SYMTAB
)
4602 CHECK_ENTSIZE (section
, i
, Sym
);
4603 else if (section
->sh_type
== SHT_GROUP
)
4604 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4605 else if (section
->sh_type
== SHT_REL
)
4606 CHECK_ENTSIZE (section
, i
, Rel
);
4607 else if (section
->sh_type
== SHT_RELA
)
4608 CHECK_ENTSIZE (section
, i
, Rela
);
4609 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4610 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
4611 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
4612 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
)
4613 && (const_strneq (name
, ".debug_")
4614 || const_strneq (name
, ".zdebug_")))
4617 name
+= sizeof (".zdebug_") - 1;
4619 name
+= sizeof (".debug_") - 1;
4622 || (do_debug_info
&& streq (name
, "info"))
4623 || (do_debug_info
&& streq (name
, "types"))
4624 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4625 || (do_debug_lines
&& streq (name
, "line"))
4626 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4627 || (do_debug_pubtypes
&& streq (name
, "pubtypes"))
4628 || (do_debug_aranges
&& streq (name
, "aranges"))
4629 || (do_debug_ranges
&& streq (name
, "ranges"))
4630 || (do_debug_frames
&& streq (name
, "frame"))
4631 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4632 || (do_debug_str
&& streq (name
, "str"))
4633 || (do_debug_loc
&& streq (name
, "loc"))
4635 request_dump_bynumber (i
, DEBUG_DUMP
);
4637 /* Linkonce section to be combined with .debug_info at link time. */
4638 else if ((do_debugging
|| do_debug_info
)
4639 && const_strneq (name
, ".gnu.linkonce.wi."))
4640 request_dump_bynumber (i
, DEBUG_DUMP
);
4641 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4642 request_dump_bynumber (i
, DEBUG_DUMP
);
4643 /* Trace sections for Itanium VMS. */
4644 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
4645 || do_trace_aranges
)
4646 && const_strneq (name
, ".trace_"))
4648 name
+= sizeof (".trace_") - 1;
4651 || (do_trace_info
&& streq (name
, "info"))
4652 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
4653 || (do_trace_aranges
&& streq (name
, "aranges"))
4655 request_dump_bynumber (i
, DEBUG_DUMP
);
4663 if (elf_header
.e_shnum
> 1)
4664 printf (_("\nSection Headers:\n"));
4666 printf (_("\nSection Header:\n"));
4670 if (do_section_details
)
4672 printf (_(" [Nr] Name\n"));
4673 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4677 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4681 if (do_section_details
)
4683 printf (_(" [Nr] Name\n"));
4684 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4688 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4692 if (do_section_details
)
4694 printf (_(" [Nr] Name\n"));
4695 printf (_(" Type Address Offset Link\n"));
4696 printf (_(" Size EntSize Info Align\n"));
4700 printf (_(" [Nr] Name Type Address Offset\n"));
4701 printf (_(" Size EntSize Flags Link Info Align\n"));
4705 if (do_section_details
)
4706 printf (_(" Flags\n"));
4708 for (i
= 0, section
= section_headers
;
4709 i
< elf_header
.e_shnum
;
4712 if (do_section_details
)
4714 printf (" [%2u] %s\n",
4716 SECTION_NAME (section
));
4717 if (is_32bit_elf
|| do_wide
)
4718 printf (" %-15.15s ",
4719 get_section_type_name (section
->sh_type
));
4722 printf ((do_wide
? " [%2u] %-17s %-15s "
4723 : " [%2u] %-17.17s %-15.15s "),
4725 SECTION_NAME (section
),
4726 get_section_type_name (section
->sh_type
));
4730 const char * link_too_big
= NULL
;
4732 print_vma (section
->sh_addr
, LONG_HEX
);
4734 printf ( " %6.6lx %6.6lx %2.2lx",
4735 (unsigned long) section
->sh_offset
,
4736 (unsigned long) section
->sh_size
,
4737 (unsigned long) section
->sh_entsize
);
4739 if (do_section_details
)
4740 fputs (" ", stdout
);
4742 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4744 if (section
->sh_link
>= elf_header
.e_shnum
)
4747 /* The sh_link value is out of range. Normally this indicates
4748 an error but it can have special values in Solaris binaries. */
4749 switch (elf_header
.e_machine
)
4755 case EM_OLD_SPARCV9
:
4756 case EM_SPARC32PLUS
:
4759 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
4760 link_too_big
= "BEFORE";
4761 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
4762 link_too_big
= "AFTER";
4769 if (do_section_details
)
4771 if (link_too_big
!= NULL
&& * link_too_big
)
4772 printf ("<%s> ", link_too_big
);
4774 printf ("%2u ", section
->sh_link
);
4775 printf ("%3u %2lu\n", section
->sh_info
,
4776 (unsigned long) section
->sh_addralign
);
4779 printf ("%2u %3u %2lu\n",
4782 (unsigned long) section
->sh_addralign
);
4784 if (link_too_big
&& ! * link_too_big
)
4785 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4786 i
, section
->sh_link
);
4790 print_vma (section
->sh_addr
, LONG_HEX
);
4792 if ((long) section
->sh_offset
== section
->sh_offset
)
4793 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4797 print_vma (section
->sh_offset
, LONG_HEX
);
4800 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4801 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4805 print_vma (section
->sh_size
, LONG_HEX
);
4808 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4809 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4813 print_vma (section
->sh_entsize
, LONG_HEX
);
4816 if (do_section_details
)
4817 fputs (" ", stdout
);
4819 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4821 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
4823 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4824 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
4827 print_vma (section
->sh_addralign
, DEC
);
4831 else if (do_section_details
)
4833 printf (" %-15.15s ",
4834 get_section_type_name (section
->sh_type
));
4835 print_vma (section
->sh_addr
, LONG_HEX
);
4836 if ((long) section
->sh_offset
== section
->sh_offset
)
4837 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4841 print_vma (section
->sh_offset
, LONG_HEX
);
4843 printf (" %u\n ", section
->sh_link
);
4844 print_vma (section
->sh_size
, LONG_HEX
);
4846 print_vma (section
->sh_entsize
, LONG_HEX
);
4848 printf (" %-16u %lu\n",
4850 (unsigned long) section
->sh_addralign
);
4855 print_vma (section
->sh_addr
, LONG_HEX
);
4856 if ((long) section
->sh_offset
== section
->sh_offset
)
4857 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4861 print_vma (section
->sh_offset
, LONG_HEX
);
4864 print_vma (section
->sh_size
, LONG_HEX
);
4866 print_vma (section
->sh_entsize
, LONG_HEX
);
4868 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4870 printf (" %2u %3u %lu\n",
4873 (unsigned long) section
->sh_addralign
);
4876 if (do_section_details
)
4877 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4880 if (!do_section_details
)
4882 if (elf_header
.e_machine
== EM_X86_64
4883 || elf_header
.e_machine
== EM_L1OM
)
4884 printf (_("Key to Flags:\n\
4885 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
4886 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
4887 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4889 printf (_("Key to Flags:\n\
4890 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4891 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
4892 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4899 get_group_flags (unsigned int flags
)
4901 static char buff
[32];
4911 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
4918 process_section_groups (FILE * file
)
4920 Elf_Internal_Shdr
* section
;
4922 struct group
* group
;
4923 Elf_Internal_Shdr
* symtab_sec
;
4924 Elf_Internal_Shdr
* strtab_sec
;
4925 Elf_Internal_Sym
* symtab
;
4929 /* Don't process section groups unless needed. */
4930 if (!do_unwind
&& !do_section_groups
)
4933 if (elf_header
.e_shnum
== 0)
4935 if (do_section_groups
)
4936 printf (_("\nThere are no sections in this file.\n"));
4941 if (section_headers
== NULL
)
4943 error (_("Section headers are not available!\n"));
4947 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
4948 sizeof (struct group
*));
4950 if (section_headers_groups
== NULL
)
4952 error (_("Out of memory\n"));
4956 /* Scan the sections for the group section. */
4958 for (i
= 0, section
= section_headers
;
4959 i
< elf_header
.e_shnum
;
4961 if (section
->sh_type
== SHT_GROUP
)
4964 if (group_count
== 0)
4966 if (do_section_groups
)
4967 printf (_("\nThere are no section groups in this file.\n"));
4972 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
4974 if (section_groups
== NULL
)
4976 error (_("Out of memory\n"));
4985 for (i
= 0, section
= section_headers
, group
= section_groups
;
4986 i
< elf_header
.e_shnum
;
4989 if (section
->sh_type
== SHT_GROUP
)
4991 char * name
= SECTION_NAME (section
);
4993 unsigned char * start
;
4994 unsigned char * indices
;
4995 unsigned int entry
, j
, size
;
4996 Elf_Internal_Shdr
* sec
;
4997 Elf_Internal_Sym
* sym
;
4999 /* Get the symbol table. */
5000 if (section
->sh_link
>= elf_header
.e_shnum
5001 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
5004 error (_("Bad sh_link in group section `%s'\n"), name
);
5008 if (symtab_sec
!= sec
)
5013 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
5018 error (_("Corrupt header in group section `%s'\n"), name
);
5022 sym
= symtab
+ section
->sh_info
;
5024 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
5026 if (sym
->st_shndx
== 0
5027 || sym
->st_shndx
>= elf_header
.e_shnum
)
5029 error (_("Bad sh_info in group section `%s'\n"), name
);
5033 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
5042 /* Get the string table. */
5043 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
5052 != (sec
= section_headers
+ symtab_sec
->sh_link
))
5057 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
5058 1, strtab_sec
->sh_size
,
5060 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
5062 group_name
= sym
->st_name
< strtab_size
5063 ? strtab
+ sym
->st_name
: _("<corrupt>");
5066 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
5067 1, section
->sh_size
,
5071 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
5072 entry
= byte_get (indices
, 4);
5075 if (do_section_groups
)
5077 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5078 get_group_flags (entry
), i
, name
, group_name
, size
);
5080 printf (_(" [Index] Name\n"));
5083 group
->group_index
= i
;
5085 for (j
= 0; j
< size
; j
++)
5087 struct group_list
* g
;
5089 entry
= byte_get (indices
, 4);
5092 if (entry
>= elf_header
.e_shnum
)
5094 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5095 entry
, i
, elf_header
.e_shnum
- 1);
5099 if (section_headers_groups
[entry
] != NULL
)
5103 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5105 section_headers_groups
[entry
]->group_index
);
5110 /* Intel C/C++ compiler may put section 0 in a
5111 section group. We just warn it the first time
5112 and ignore it afterwards. */
5113 static int warned
= 0;
5116 error (_("section 0 in group section [%5u]\n"),
5117 section_headers_groups
[entry
]->group_index
);
5123 section_headers_groups
[entry
] = group
;
5125 if (do_section_groups
)
5127 sec
= section_headers
+ entry
;
5128 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
5131 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
5132 g
->section_index
= entry
;
5133 g
->next
= group
->root
;
5151 /* Data used to display dynamic fixups. */
5153 struct ia64_vms_dynfixup
5155 bfd_vma needed_ident
; /* Library ident number. */
5156 bfd_vma needed
; /* Index in the dstrtab of the library name. */
5157 bfd_vma fixup_needed
; /* Index of the library. */
5158 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
5159 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
5162 /* Data used to display dynamic relocations. */
5164 struct ia64_vms_dynimgrela
5166 bfd_vma img_rela_cnt
; /* Number of relocations. */
5167 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
5170 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5174 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
5175 const char *strtab
, unsigned int strtab_sz
)
5177 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
5179 const char *lib_name
;
5181 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
5182 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
5183 _("dynamic section image fixups"));
5187 if (fixup
->needed
< strtab_sz
)
5188 lib_name
= strtab
+ fixup
->needed
;
5191 warn ("corrupt library name index of 0x%lx found in dynamic entry",
5192 (unsigned long) fixup
->needed
);
5195 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5196 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
5198 (_("Seg Offset Type SymVec DataType\n"));
5200 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
5205 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
5206 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
5207 type
= BYTE_GET (imfs
[i
].type
);
5208 rtype
= elf_ia64_reloc_type (type
);
5210 printf (" 0x%08x ", type
);
5212 printf (" %-32s ", rtype
);
5213 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
5214 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
5220 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5223 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
5225 Elf64_External_VMS_IMAGE_RELA
*imrs
;
5228 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
5229 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
5230 _("dynamic section image relas"));
5234 printf (_("\nImage relocs\n"));
5236 (_("Seg Offset Type Addend Seg Sym Off\n"));
5238 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
5243 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
5244 printf ("%08" BFD_VMA_FMT
"x ",
5245 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
5246 type
= BYTE_GET (imrs
[i
].type
);
5247 rtype
= elf_ia64_reloc_type (type
);
5249 printf ("0x%08x ", type
);
5251 printf ("%-31s ", rtype
);
5252 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
5253 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
5254 printf ("%08" BFD_VMA_FMT
"x\n",
5255 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
5261 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
5264 process_ia64_vms_dynamic_relocs (FILE *file
)
5266 struct ia64_vms_dynfixup fixup
;
5267 struct ia64_vms_dynimgrela imgrela
;
5268 Elf_Internal_Dyn
*entry
;
5270 bfd_vma strtab_off
= 0;
5271 bfd_vma strtab_sz
= 0;
5272 char *strtab
= NULL
;
5274 memset (&fixup
, 0, sizeof (fixup
));
5275 memset (&imgrela
, 0, sizeof (imgrela
));
5277 /* Note: the order of the entries is specified by the OpenVMS specs. */
5278 for (entry
= dynamic_section
;
5279 entry
< dynamic_section
+ dynamic_nent
;
5282 switch (entry
->d_tag
)
5284 case DT_IA_64_VMS_STRTAB_OFFSET
:
5285 strtab_off
= entry
->d_un
.d_val
;
5288 strtab_sz
= entry
->d_un
.d_val
;
5290 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
5291 1, strtab_sz
, _("dynamic string section"));
5294 case DT_IA_64_VMS_NEEDED_IDENT
:
5295 fixup
.needed_ident
= entry
->d_un
.d_val
;
5298 fixup
.needed
= entry
->d_un
.d_val
;
5300 case DT_IA_64_VMS_FIXUP_NEEDED
:
5301 fixup
.fixup_needed
= entry
->d_un
.d_val
;
5303 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
5304 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
5306 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
5307 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
5309 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
5312 case DT_IA_64_VMS_IMG_RELA_CNT
:
5313 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
5315 case DT_IA_64_VMS_IMG_RELA_OFF
:
5316 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
5318 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
5338 } dynamic_relocations
[] =
5340 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
5341 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
5342 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
5345 /* Process the reloc section. */
5348 process_relocs (FILE * file
)
5350 unsigned long rel_size
;
5351 unsigned long rel_offset
;
5357 if (do_using_dynamic
)
5361 int has_dynamic_reloc
;
5364 has_dynamic_reloc
= 0;
5366 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
5368 is_rela
= dynamic_relocations
[i
].rela
;
5369 name
= dynamic_relocations
[i
].name
;
5370 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
5371 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
5373 has_dynamic_reloc
|= rel_size
;
5375 if (is_rela
== UNKNOWN
)
5377 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
5378 switch (dynamic_info
[DT_PLTREL
])
5392 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5393 name
, rel_offset
, rel_size
);
5395 dump_relocations (file
,
5396 offset_from_vma (file
, rel_offset
, rel_size
),
5398 dynamic_symbols
, num_dynamic_syms
,
5399 dynamic_strings
, dynamic_strings_length
, is_rela
);
5404 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
5406 if (! has_dynamic_reloc
)
5407 printf (_("\nThere are no dynamic relocations in this file.\n"));
5411 Elf_Internal_Shdr
* section
;
5415 for (i
= 0, section
= section_headers
;
5416 i
< elf_header
.e_shnum
;
5419 if ( section
->sh_type
!= SHT_RELA
5420 && section
->sh_type
!= SHT_REL
)
5423 rel_offset
= section
->sh_offset
;
5424 rel_size
= section
->sh_size
;
5428 Elf_Internal_Shdr
* strsec
;
5431 printf (_("\nRelocation section "));
5433 if (string_table
== NULL
)
5434 printf ("%d", section
->sh_name
);
5436 printf (_("'%s'"), SECTION_NAME (section
));
5438 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5439 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
5441 is_rela
= section
->sh_type
== SHT_RELA
;
5443 if (section
->sh_link
!= 0
5444 && section
->sh_link
< elf_header
.e_shnum
)
5446 Elf_Internal_Shdr
* symsec
;
5447 Elf_Internal_Sym
* symtab
;
5448 unsigned long nsyms
;
5449 unsigned long strtablen
= 0;
5450 char * strtab
= NULL
;
5452 symsec
= section_headers
+ section
->sh_link
;
5453 if (symsec
->sh_type
!= SHT_SYMTAB
5454 && symsec
->sh_type
!= SHT_DYNSYM
)
5457 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
5458 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
5463 if (symsec
->sh_link
!= 0
5464 && symsec
->sh_link
< elf_header
.e_shnum
)
5466 strsec
= section_headers
+ symsec
->sh_link
;
5468 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5471 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
5474 dump_relocations (file
, rel_offset
, rel_size
,
5475 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
5481 dump_relocations (file
, rel_offset
, rel_size
,
5482 NULL
, 0, NULL
, 0, is_rela
);
5489 printf (_("\nThere are no relocations in this file.\n"));
5495 /* Process the unwind section. */
5497 #include "unwind-ia64.h"
5499 /* An absolute address consists of a section and an offset. If the
5500 section is NULL, the offset itself is the address, otherwise, the
5501 address equals to LOAD_ADDRESS(section) + offset. */
5505 unsigned short section
;
5509 #define ABSADDR(a) \
5511 ? section_headers [(a).section].sh_addr + (a).offset \
5514 struct ia64_unw_table_entry
5516 struct absaddr start
;
5518 struct absaddr info
;
5521 struct ia64_unw_aux_info
5524 struct ia64_unw_table_entry
*table
; /* Unwind table. */
5525 unsigned long table_len
; /* Length of unwind table. */
5526 unsigned char * info
; /* Unwind info. */
5527 unsigned long info_size
; /* Size of unwind info. */
5528 bfd_vma info_addr
; /* starting address of unwind info. */
5529 bfd_vma seg_base
; /* Starting address of segment. */
5530 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5531 unsigned long nsyms
; /* Number of symbols. */
5532 char * strtab
; /* The string table. */
5533 unsigned long strtab_size
; /* Size of string table. */
5537 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
5538 unsigned long nsyms
,
5539 const char * strtab
,
5540 unsigned long strtab_size
,
5541 struct absaddr addr
,
5542 const char ** symname
,
5545 bfd_vma dist
= 0x100000;
5546 Elf_Internal_Sym
* sym
;
5547 Elf_Internal_Sym
* best
= NULL
;
5550 REMOVE_ARCH_BITS (addr
.offset
);
5552 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
5554 bfd_vma value
= sym
->st_value
;
5556 REMOVE_ARCH_BITS (value
);
5558 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
5559 && sym
->st_name
!= 0
5560 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
5561 && addr
.offset
>= value
5562 && addr
.offset
- value
< dist
)
5565 dist
= addr
.offset
- value
;
5572 *symname
= (best
->st_name
>= strtab_size
5573 ? _("<corrupt>") : strtab
+ best
->st_name
);
5578 *offset
= addr
.offset
;
5582 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
5584 struct ia64_unw_table_entry
* tp
;
5587 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5591 const unsigned char * dp
;
5592 const unsigned char * head
;
5593 const char * procname
;
5595 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5596 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
5598 fputs ("\n<", stdout
);
5602 fputs (procname
, stdout
);
5605 printf ("+%lx", (unsigned long) offset
);
5608 fputs (">: [", stdout
);
5609 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5610 fputc ('-', stdout
);
5611 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5612 printf ("], info at +0x%lx\n",
5613 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
5615 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
5616 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
5618 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5619 (unsigned) UNW_VER (stamp
),
5620 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
5621 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
5622 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
5623 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
5625 if (UNW_VER (stamp
) != 1)
5627 printf (_("\tUnknown version.\n"));
5632 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
5633 dp
= unw_decode (dp
, in_body
, & in_body
);
5638 slurp_ia64_unwind_table (FILE * file
,
5639 struct ia64_unw_aux_info
* aux
,
5640 Elf_Internal_Shdr
* sec
)
5642 unsigned long size
, nrelas
, i
;
5643 Elf_Internal_Phdr
* seg
;
5644 struct ia64_unw_table_entry
* tep
;
5645 Elf_Internal_Shdr
* relsec
;
5646 Elf_Internal_Rela
* rela
;
5647 Elf_Internal_Rela
* rp
;
5648 unsigned char * table
;
5650 Elf_Internal_Sym
* sym
;
5651 const char * relname
;
5653 /* First, find the starting address of the segment that includes
5656 if (elf_header
.e_phnum
)
5658 if (! get_program_headers (file
))
5661 for (seg
= program_headers
;
5662 seg
< program_headers
+ elf_header
.e_phnum
;
5665 if (seg
->p_type
!= PT_LOAD
)
5668 if (sec
->sh_addr
>= seg
->p_vaddr
5669 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5671 aux
->seg_base
= seg
->p_vaddr
;
5677 /* Second, build the unwind table from the contents of the unwind section: */
5678 size
= sec
->sh_size
;
5679 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
5684 aux
->table
= (struct ia64_unw_table_entry
*)
5685 xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
5687 for (tp
= table
; tp
< table
+ size
; ++tep
)
5689 tep
->start
.section
= SHN_UNDEF
;
5690 tep
->end
.section
= SHN_UNDEF
;
5691 tep
->info
.section
= SHN_UNDEF
;
5692 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5693 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5694 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5695 tep
->start
.offset
+= aux
->seg_base
;
5696 tep
->end
.offset
+= aux
->seg_base
;
5697 tep
->info
.offset
+= aux
->seg_base
;
5701 /* Third, apply any relocations to the unwind table: */
5702 for (relsec
= section_headers
;
5703 relsec
< section_headers
+ elf_header
.e_shnum
;
5706 if (relsec
->sh_type
!= SHT_RELA
5707 || relsec
->sh_info
>= elf_header
.e_shnum
5708 || section_headers
+ relsec
->sh_info
!= sec
)
5711 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5715 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5717 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5718 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5720 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5722 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5726 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5728 switch (rp
->r_offset
/eh_addr_size
% 3)
5731 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5732 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
5735 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5736 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
5739 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5740 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
5750 aux
->table_len
= size
/ (3 * eh_addr_size
);
5755 ia64_process_unwind (FILE * file
)
5757 Elf_Internal_Shdr
* sec
;
5758 Elf_Internal_Shdr
* unwsec
= NULL
;
5759 Elf_Internal_Shdr
* strsec
;
5760 unsigned long i
, unwcount
= 0, unwstart
= 0;
5761 struct ia64_unw_aux_info aux
;
5763 memset (& aux
, 0, sizeof (aux
));
5765 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5767 if (sec
->sh_type
== SHT_SYMTAB
5768 && sec
->sh_link
< elf_header
.e_shnum
)
5770 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5771 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5773 strsec
= section_headers
+ sec
->sh_link
;
5774 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5777 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5779 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5784 printf (_("\nThere are no unwind sections in this file.\n"));
5786 while (unwcount
-- > 0)
5791 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5792 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5793 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5800 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5802 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5804 /* We need to find which section group it is in. */
5805 struct group_list
* g
= section_headers_groups
[i
]->root
;
5807 for (; g
!= NULL
; g
= g
->next
)
5809 sec
= section_headers
+ g
->section_index
;
5811 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5816 i
= elf_header
.e_shnum
;
5818 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5820 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5821 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5822 suffix
= SECTION_NAME (unwsec
) + len
;
5823 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5825 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5826 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5831 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5832 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5833 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5834 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5836 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5837 suffix
= SECTION_NAME (unwsec
) + len
;
5838 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5840 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5841 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5845 if (i
== elf_header
.e_shnum
)
5847 printf (_("\nCould not find unwind info section for "));
5849 if (string_table
== NULL
)
5850 printf ("%d", unwsec
->sh_name
);
5852 printf (_("'%s'"), SECTION_NAME (unwsec
));
5856 aux
.info_size
= sec
->sh_size
;
5857 aux
.info_addr
= sec
->sh_addr
;
5858 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
5862 printf (_("\nUnwind section "));
5864 if (string_table
== NULL
)
5865 printf ("%d", unwsec
->sh_name
);
5867 printf (_("'%s'"), SECTION_NAME (unwsec
));
5869 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5870 (unsigned long) unwsec
->sh_offset
,
5871 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5873 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5875 if (aux
.table_len
> 0)
5876 dump_ia64_unwind (& aux
);
5879 free ((char *) aux
.table
);
5881 free ((char *) aux
.info
);
5890 free ((char *) aux
.strtab
);
5895 struct hppa_unw_table_entry
5897 struct absaddr start
;
5899 unsigned int Cannot_unwind
:1; /* 0 */
5900 unsigned int Millicode
:1; /* 1 */
5901 unsigned int Millicode_save_sr0
:1; /* 2 */
5902 unsigned int Region_description
:2; /* 3..4 */
5903 unsigned int reserved1
:1; /* 5 */
5904 unsigned int Entry_SR
:1; /* 6 */
5905 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5906 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5907 unsigned int Args_stored
:1; /* 16 */
5908 unsigned int Variable_Frame
:1; /* 17 */
5909 unsigned int Separate_Package_Body
:1; /* 18 */
5910 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5911 unsigned int Stack_Overflow_Check
:1; /* 20 */
5912 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5913 unsigned int Ada_Region
:1; /* 22 */
5914 unsigned int cxx_info
:1; /* 23 */
5915 unsigned int cxx_try_catch
:1; /* 24 */
5916 unsigned int sched_entry_seq
:1; /* 25 */
5917 unsigned int reserved2
:1; /* 26 */
5918 unsigned int Save_SP
:1; /* 27 */
5919 unsigned int Save_RP
:1; /* 28 */
5920 unsigned int Save_MRP_in_frame
:1; /* 29 */
5921 unsigned int extn_ptr_defined
:1; /* 30 */
5922 unsigned int Cleanup_defined
:1; /* 31 */
5924 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5925 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5926 unsigned int Large_frame
:1; /* 2 */
5927 unsigned int Pseudo_SP_Set
:1; /* 3 */
5928 unsigned int reserved4
:1; /* 4 */
5929 unsigned int Total_frame_size
:27; /* 5..31 */
5932 struct hppa_unw_aux_info
5934 struct hppa_unw_table_entry
*table
; /* Unwind table. */
5935 unsigned long table_len
; /* Length of unwind table. */
5936 bfd_vma seg_base
; /* Starting address of segment. */
5937 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5938 unsigned long nsyms
; /* Number of symbols. */
5939 char * strtab
; /* The string table. */
5940 unsigned long strtab_size
; /* Size of string table. */
5944 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
5946 struct hppa_unw_table_entry
* tp
;
5948 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5951 const char * procname
;
5953 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5954 aux
->strtab_size
, tp
->start
, &procname
,
5957 fputs ("\n<", stdout
);
5961 fputs (procname
, stdout
);
5964 printf ("+%lx", (unsigned long) offset
);
5967 fputs (">: [", stdout
);
5968 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5969 fputc ('-', stdout
);
5970 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5973 #define PF(_m) if (tp->_m) printf (#_m " ");
5974 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5977 PF(Millicode_save_sr0
);
5978 /* PV(Region_description); */
5984 PF(Separate_Package_Body
);
5985 PF(Frame_Extension_Millicode
);
5986 PF(Stack_Overflow_Check
);
5987 PF(Two_Instruction_SP_Increment
);
5991 PF(sched_entry_seq
);
5994 PF(Save_MRP_in_frame
);
5995 PF(extn_ptr_defined
);
5996 PF(Cleanup_defined
);
5997 PF(MPE_XL_interrupt_marker
);
5998 PF(HP_UX_interrupt_marker
);
6001 PV(Total_frame_size
);
6010 slurp_hppa_unwind_table (FILE * file
,
6011 struct hppa_unw_aux_info
* aux
,
6012 Elf_Internal_Shdr
* sec
)
6014 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
6015 Elf_Internal_Phdr
* seg
;
6016 struct hppa_unw_table_entry
* tep
;
6017 Elf_Internal_Shdr
* relsec
;
6018 Elf_Internal_Rela
* rela
;
6019 Elf_Internal_Rela
* rp
;
6020 unsigned char * table
;
6022 Elf_Internal_Sym
* sym
;
6023 const char * relname
;
6025 /* First, find the starting address of the segment that includes
6028 if (elf_header
.e_phnum
)
6030 if (! get_program_headers (file
))
6033 for (seg
= program_headers
;
6034 seg
< program_headers
+ elf_header
.e_phnum
;
6037 if (seg
->p_type
!= PT_LOAD
)
6040 if (sec
->sh_addr
>= seg
->p_vaddr
6041 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6043 aux
->seg_base
= seg
->p_vaddr
;
6049 /* Second, build the unwind table from the contents of the unwind
6051 size
= sec
->sh_size
;
6052 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6058 nentries
= size
/ unw_ent_size
;
6059 size
= unw_ent_size
* nentries
;
6061 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
6062 xcmalloc (nentries
, sizeof (aux
->table
[0]));
6064 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
6066 unsigned int tmp1
, tmp2
;
6068 tep
->start
.section
= SHN_UNDEF
;
6069 tep
->end
.section
= SHN_UNDEF
;
6071 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
6072 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
6073 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
6074 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
6076 tep
->start
.offset
+= aux
->seg_base
;
6077 tep
->end
.offset
+= aux
->seg_base
;
6079 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
6080 tep
->Millicode
= (tmp1
>> 30) & 0x1;
6081 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
6082 tep
->Region_description
= (tmp1
>> 27) & 0x3;
6083 tep
->reserved1
= (tmp1
>> 26) & 0x1;
6084 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
6085 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
6086 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
6087 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
6088 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
6089 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
6090 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
6091 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
6092 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
6093 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
6094 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
6095 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
6096 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
6097 tep
->reserved2
= (tmp1
>> 5) & 0x1;
6098 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
6099 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
6100 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
6101 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
6102 tep
->Cleanup_defined
= tmp1
& 0x1;
6104 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
6105 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
6106 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
6107 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
6108 tep
->reserved4
= (tmp2
>> 27) & 0x1;
6109 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
6113 /* Third, apply any relocations to the unwind table. */
6114 for (relsec
= section_headers
;
6115 relsec
< section_headers
+ elf_header
.e_shnum
;
6118 if (relsec
->sh_type
!= SHT_RELA
6119 || relsec
->sh_info
>= elf_header
.e_shnum
6120 || section_headers
+ relsec
->sh_info
!= sec
)
6123 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6127 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6129 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
6130 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6132 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
6133 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
6135 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6139 i
= rp
->r_offset
/ unw_ent_size
;
6141 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
6144 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6145 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
6148 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6149 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
6159 aux
->table_len
= nentries
;
6165 hppa_process_unwind (FILE * file
)
6167 struct hppa_unw_aux_info aux
;
6168 Elf_Internal_Shdr
* unwsec
= NULL
;
6169 Elf_Internal_Shdr
* strsec
;
6170 Elf_Internal_Shdr
* sec
;
6173 memset (& aux
, 0, sizeof (aux
));
6175 if (string_table
== NULL
)
6178 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6180 if (sec
->sh_type
== SHT_SYMTAB
6181 && sec
->sh_link
< elf_header
.e_shnum
)
6183 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
6184 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
6186 strsec
= section_headers
+ sec
->sh_link
;
6187 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6190 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6192 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6197 printf (_("\nThere are no unwind sections in this file.\n"));
6199 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6201 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6203 printf (_("\nUnwind section "));
6204 printf (_("'%s'"), SECTION_NAME (sec
));
6206 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6207 (unsigned long) sec
->sh_offset
,
6208 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
6210 slurp_hppa_unwind_table (file
, &aux
, sec
);
6211 if (aux
.table_len
> 0)
6212 dump_hppa_unwind (&aux
);
6215 free ((char *) aux
.table
);
6223 free ((char *) aux
.strtab
);
6230 unsigned char *data
;
6232 Elf_Internal_Shdr
*sec
;
6233 Elf_Internal_Rela
*rela
;
6234 unsigned long nrelas
;
6235 unsigned int rel_type
;
6237 Elf_Internal_Rela
*next_rela
;
6240 struct arm_unw_aux_info
6244 Elf_Internal_Sym
*symtab
; /* The symbol table. */
6245 unsigned long nsyms
; /* Number of symbols. */
6246 char *strtab
; /* The string table. */
6247 unsigned long strtab_size
; /* Size of string table. */
6251 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
6252 bfd_vma fn
, struct absaddr addr
)
6254 const char *procname
;
6257 if (addr
.section
== SHN_UNDEF
)
6260 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6261 aux
->strtab_size
, addr
, &procname
,
6264 print_vma (fn
, PREFIX_HEX
);
6268 fputs (" <", stdout
);
6269 fputs (procname
, stdout
);
6272 printf ("+0x%lx", (unsigned long) sym_offset
);
6273 fputc ('>', stdout
);
6280 arm_free_section (struct arm_section
*arm_sec
)
6282 if (arm_sec
->data
!= NULL
)
6283 free (arm_sec
->data
);
6285 if (arm_sec
->rela
!= NULL
)
6286 free (arm_sec
->rela
);
6290 arm_section_get_word (struct arm_unw_aux_info
*aux
,
6291 struct arm_section
*arm_sec
,
6292 Elf_Internal_Shdr
*sec
, bfd_vma word_offset
,
6293 unsigned int *wordp
, struct absaddr
*addr
)
6295 Elf_Internal_Rela
*rp
;
6296 Elf_Internal_Sym
*sym
;
6297 const char * relname
;
6299 bfd_boolean wrapped
;
6301 addr
->section
= SHN_UNDEF
;
6304 if (sec
!= arm_sec
->sec
)
6306 Elf_Internal_Shdr
*relsec
;
6308 arm_free_section (arm_sec
);
6311 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
6312 sec
->sh_size
, _("unwind data"));
6314 arm_sec
->rela
= NULL
;
6315 arm_sec
->nrelas
= 0;
6317 for (relsec
= section_headers
;
6318 relsec
< section_headers
+ elf_header
.e_shnum
;
6321 if (relsec
->sh_info
>= elf_header
.e_shnum
6322 || section_headers
+ relsec
->sh_info
!= sec
)
6325 if (relsec
->sh_type
== SHT_REL
)
6327 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
6329 & arm_sec
->rela
, & arm_sec
->nrelas
))
6333 else if (relsec
->sh_type
== SHT_RELA
)
6335 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
6337 & arm_sec
->rela
, & arm_sec
->nrelas
))
6343 arm_sec
->next_rela
= arm_sec
->rela
;
6346 if (arm_sec
->data
== NULL
)
6349 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
6352 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
6354 bfd_vma prelval
, offset
;
6356 if (rp
->r_offset
> word_offset
&& !wrapped
)
6361 if (rp
->r_offset
> word_offset
)
6364 if (rp
->r_offset
& 3)
6366 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6367 (unsigned long) rp
->r_offset
);
6371 if (rp
->r_offset
< word_offset
)
6374 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
6376 if (streq (relname
, "R_ARM_NONE"))
6379 if (! streq (relname
, "R_ARM_PREL31"))
6381 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6385 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
6387 if (arm_sec
->rel_type
== SHT_REL
)
6389 offset
= word
& 0x7fffffff;
6390 if (offset
& 0x40000000)
6391 offset
|= ~ (bfd_vma
) 0x7fffffff;
6394 offset
= rp
->r_addend
;
6396 offset
+= sym
->st_value
;
6397 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
6399 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
6400 addr
->section
= sym
->st_shndx
;
6401 addr
->offset
= offset
;
6406 arm_sec
->next_rela
= rp
;
6412 decode_arm_unwind (struct arm_unw_aux_info
*aux
,
6413 unsigned int word
, unsigned int remaining
,
6414 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
6415 struct arm_section
*data_arm_sec
)
6418 unsigned int more_words
;
6419 struct absaddr addr
;
6422 if (remaining == 0 && more_words) \
6425 if (!arm_section_get_word (aux, data_arm_sec, data_sec, \
6426 data_offset, &word, &addr)) \
6432 #define GET_OP(OP) \
6437 (OP) = word >> 24; \
6442 printf (_("[Truncated opcode]\n")); \
6445 printf ("0x%02x ", OP)
6449 /* Fetch the first word. */
6450 if (!arm_section_get_word (aux
, data_arm_sec
, data_sec
, data_offset
,
6456 if ((word
& 0x80000000) == 0)
6458 /* Expand prel31 for personality routine. */
6460 const char *procname
;
6463 if (fn
& 0x40000000)
6464 fn
|= ~ (bfd_vma
) 0x7fffffff;
6465 fn
= fn
+ data_sec
->sh_addr
+ data_offset
;
6467 printf (_(" Personality routine: "));
6468 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
6469 fputc ('\n', stdout
);
6471 /* The GCC personality routines use the standard compact
6472 encoding, starting with one byte giving the number of
6474 if (procname
!= NULL
6475 && (const_strneq (procname
, "__gcc_personality_v0")
6476 || const_strneq (procname
, "__gxx_personality_v0")
6477 || const_strneq (procname
, "__gcj_personality_v0")
6478 || const_strneq (procname
, "__gnu_objc_personality_v0")))
6485 printf (_(" [Truncated data]\n"));
6488 more_words
= word
>> 24;
6497 per_index
= (word
>> 24) & 0x7f;
6498 if (per_index
!= 0 && per_index
!= 1 && per_index
!= 2)
6500 printf (_(" [reserved compact index %d]\n"), per_index
);
6504 printf (_(" Compact model %d\n"), per_index
);
6513 more_words
= (word
>> 16) & 0xff;
6519 /* Decode the unwinding instructions. */
6522 unsigned int op
, op2
;
6531 printf (" 0x%02x ", op
);
6533 if ((op
& 0xc0) == 0x00)
6535 int offset
= ((op
& 0x3f) << 2) + 4;
6536 printf (" vsp = vsp + %d", offset
);
6538 else if ((op
& 0xc0) == 0x40)
6540 int offset
= ((op
& 0x3f) << 2) + 4;
6541 printf (" vsp = vsp - %d", offset
);
6543 else if ((op
& 0xf0) == 0x80)
6546 if (op
== 0x80 && op2
== 0)
6547 printf (_("Refuse to unwind"));
6550 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
6555 for (i
= 0; i
< 12; i
++)
6556 if (mask
& (1 << i
))
6562 printf ("r%d", 4 + i
);
6567 else if ((op
& 0xf0) == 0x90)
6569 if (op
== 0x9d || op
== 0x9f)
6570 printf (_(" [Reserved]"));
6572 printf (" vsp = r%d", op
& 0x0f);
6574 else if ((op
& 0xf0) == 0xa0)
6576 int end
= 4 + (op
& 0x07);
6580 for (i
= 4; i
<= end
; i
++)
6596 else if (op
== 0xb0)
6597 printf (_(" finish"));
6598 else if (op
== 0xb1)
6601 if (op2
== 0 || (op2
& 0xf0) != 0)
6602 printf (_("[Spare]"));
6605 unsigned int mask
= op2
& 0x0f;
6609 for (i
= 0; i
< 12; i
++)
6610 if (mask
& (1 << i
))
6621 else if (op
== 0xb2)
6623 unsigned char buf
[9];
6624 unsigned int i
, len
;
6625 unsigned long offset
;
6626 for (i
= 0; i
< sizeof (buf
); i
++)
6629 if ((buf
[i
] & 0x80) == 0)
6632 assert (i
< sizeof (buf
));
6633 offset
= read_uleb128 (buf
, &len
);
6634 assert (len
== i
+ 1);
6635 offset
= offset
* 4 + 0x204;
6636 printf ("vsp = vsp + %ld", offset
);
6640 if (op
== 0xb3 || op
== 0xc6 || op
== 0xc7 || op
== 0xc8 || op
== 0xc9)
6643 printf (_("[unsupported two-byte opcode]"));
6647 printf (_(" [unsupported opcode]"));
6653 /* Decode the descriptors. Not implemented. */
6657 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
6659 struct arm_section exidx_arm_sec
, extab_arm_sec
;
6660 unsigned int i
, exidx_len
;
6662 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
6663 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
6664 exidx_len
= exidx_sec
->sh_size
/ 8;
6666 for (i
= 0; i
< exidx_len
; i
++)
6668 unsigned int exidx_fn
, exidx_entry
;
6669 struct absaddr fn_addr
, entry_addr
;
6672 fputc ('\n', stdout
);
6674 if (!arm_section_get_word (aux
, &exidx_arm_sec
, exidx_sec
,
6675 8 * i
, &exidx_fn
, &fn_addr
)
6676 || !arm_section_get_word (aux
, &exidx_arm_sec
, exidx_sec
,
6677 8 * i
+ 4, &exidx_entry
, &entry_addr
))
6679 arm_free_section (&exidx_arm_sec
);
6680 arm_free_section (&extab_arm_sec
);
6684 fn
= exidx_fn
& 0x7fffffff;
6685 if (fn
& 0x40000000)
6686 fn
|= ~ (bfd_vma
) 0x7fffffff;
6687 fn
= fn
+ exidx_sec
->sh_addr
+ 8 * i
;
6689 arm_print_vma_and_name (aux
, fn
, entry_addr
);
6690 fputs (": ", stdout
);
6692 if (exidx_entry
== 1)
6694 print_vma (exidx_entry
, PREFIX_HEX
);
6695 fputs (" [cantunwind]\n", stdout
);
6697 else if (exidx_entry
& 0x80000000)
6699 print_vma (exidx_entry
, PREFIX_HEX
);
6700 fputc ('\n', stdout
);
6701 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
6705 bfd_vma table
, table_offset
= 0;
6706 Elf_Internal_Shdr
*table_sec
;
6708 fputs ("@", stdout
);
6709 table
= exidx_entry
;
6710 if (table
& 0x40000000)
6711 table
|= ~ (bfd_vma
) 0x7fffffff;
6712 table
= table
+ exidx_sec
->sh_addr
+ 8 * i
+ 4;
6713 print_vma (table
, PREFIX_HEX
);
6716 /* Locate the matching .ARM.extab. */
6717 if (entry_addr
.section
!= SHN_UNDEF
6718 && entry_addr
.section
< elf_header
.e_shnum
)
6720 table_sec
= section_headers
+ entry_addr
.section
;
6721 table_offset
= entry_addr
.offset
;
6725 table_sec
= find_section_by_address (table
);
6726 if (table_sec
!= NULL
)
6727 table_offset
= table
- table_sec
->sh_addr
;
6729 if (table_sec
== NULL
)
6731 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
6732 (unsigned long) table
);
6735 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
6742 arm_free_section (&exidx_arm_sec
);
6743 arm_free_section (&extab_arm_sec
);
6747 arm_process_unwind (FILE *file
)
6749 struct arm_unw_aux_info aux
;
6750 Elf_Internal_Shdr
*unwsec
= NULL
;
6751 Elf_Internal_Shdr
*strsec
;
6752 Elf_Internal_Shdr
*sec
;
6755 memset (& aux
, 0, sizeof (aux
));
6758 if (string_table
== NULL
)
6761 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6763 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
6765 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
6766 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
6768 strsec
= section_headers
+ sec
->sh_link
;
6769 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
6770 1, strsec
->sh_size
, _("string table"));
6771 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6773 else if (sec
->sh_type
== SHT_ARM_EXIDX
)
6778 printf (_("\nThere are no unwind sections in this file.\n"));
6780 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6782 if (sec
->sh_type
== SHT_ARM_EXIDX
)
6784 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
6786 (unsigned long) sec
->sh_offset
,
6787 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
6789 dump_arm_unwind (&aux
, sec
);
6796 free ((char *) aux
.strtab
);
6802 process_unwind (FILE * file
)
6804 struct unwind_handler
6807 int (* handler
)(FILE *);
6810 { EM_ARM
, arm_process_unwind
},
6811 { EM_IA_64
, ia64_process_unwind
},
6812 { EM_PARISC
, hppa_process_unwind
},
6820 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
6821 if (elf_header
.e_machine
== handlers
[i
].machtype
)
6822 return handlers
[i
].handler (file
);
6824 printf (_("\nThere are no unwind sections in this file.\n"));
6829 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
6831 switch (entry
->d_tag
)
6834 if (entry
->d_un
.d_val
== 0)
6835 printf (_("NONE\n"));
6838 static const char * opts
[] =
6840 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
6841 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
6842 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
6843 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
6849 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
6850 if (entry
->d_un
.d_val
& (1 << cnt
))
6852 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
6859 case DT_MIPS_IVERSION
:
6860 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6861 printf (_("Interface Version: %s\n"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
6863 printf (_("<corrupt: %ld>\n"), (long) entry
->d_un
.d_ptr
);
6866 case DT_MIPS_TIME_STAMP
:
6871 time_t atime
= entry
->d_un
.d_val
;
6872 tmp
= gmtime (&atime
);
6873 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
6874 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6875 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6876 printf (_("Time Stamp: %s\n"), timebuf
);
6880 case DT_MIPS_RLD_VERSION
:
6881 case DT_MIPS_LOCAL_GOTNO
:
6882 case DT_MIPS_CONFLICTNO
:
6883 case DT_MIPS_LIBLISTNO
:
6884 case DT_MIPS_SYMTABNO
:
6885 case DT_MIPS_UNREFEXTNO
:
6886 case DT_MIPS_HIPAGENO
:
6887 case DT_MIPS_DELTA_CLASS_NO
:
6888 case DT_MIPS_DELTA_INSTANCE_NO
:
6889 case DT_MIPS_DELTA_RELOC_NO
:
6890 case DT_MIPS_DELTA_SYM_NO
:
6891 case DT_MIPS_DELTA_CLASSSYM_NO
:
6892 case DT_MIPS_COMPACT_SIZE
:
6893 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
6897 printf ("%#lx\n", (unsigned long) entry
->d_un
.d_ptr
);
6902 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
6904 switch (entry
->d_tag
)
6906 case DT_HP_DLD_FLAGS
:
6915 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
6916 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
6917 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
6918 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
6919 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
6920 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
6921 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
6922 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
6923 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
6924 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
6925 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
6926 { DT_HP_GST
, "HP_GST" },
6927 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
6928 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
6929 { DT_HP_NODELETE
, "HP_NODELETE" },
6930 { DT_HP_GROUP
, "HP_GROUP" },
6931 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
6935 bfd_vma val
= entry
->d_un
.d_val
;
6937 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
6938 if (val
& flags
[cnt
].bit
)
6942 fputs (flags
[cnt
].str
, stdout
);
6944 val
^= flags
[cnt
].bit
;
6947 if (val
!= 0 || first
)
6951 print_vma (val
, HEX
);
6957 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
6965 /* VMS vs Unix time offset and factor. */
6967 #define VMS_EPOCH_OFFSET 35067168000000000LL
6968 #define VMS_GRANULARITY_FACTOR 10000000
6970 /* Display a VMS time in a human readable format. */
6973 print_vms_time (bfd_int64_t vmstime
)
6978 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
6979 tm
= gmtime (&unxtime
);
6980 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
6981 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
6982 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
6987 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
6989 switch (entry
->d_tag
)
6991 case DT_IA_64_PLT_RESERVE
:
6992 /* First 3 slots reserved. */
6993 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
6995 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
6998 case DT_IA_64_VMS_LINKTIME
:
7000 print_vms_time (entry
->d_un
.d_val
);
7004 case DT_IA_64_VMS_LNKFLAGS
:
7005 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7006 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
7007 printf (" CALL_DEBUG");
7008 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
7009 printf (" NOP0BUFS");
7010 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
7011 printf (" P0IMAGE");
7012 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
7013 printf (" MKTHREADS");
7014 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
7015 printf (" UPCALLS");
7016 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
7018 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
7019 printf (" INITIALIZE");
7020 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
7022 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
7023 printf (" EXE_INIT");
7024 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
7025 printf (" TBK_IN_IMG");
7026 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
7027 printf (" DBG_IN_IMG");
7028 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
7029 printf (" TBK_IN_DSF");
7030 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
7031 printf (" DBG_IN_DSF");
7032 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
7033 printf (" SIGNATURES");
7034 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
7035 printf (" REL_SEG_OFF");
7039 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7046 get_32bit_dynamic_section (FILE * file
)
7048 Elf32_External_Dyn
* edyn
;
7049 Elf32_External_Dyn
* ext
;
7050 Elf_Internal_Dyn
* entry
;
7052 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
7053 dynamic_size
, _("dynamic section"));
7057 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7058 might not have the luxury of section headers. Look for the DT_NULL
7059 terminator to determine the number of entries. */
7060 for (ext
= edyn
, dynamic_nent
= 0;
7061 (char *) ext
< (char *) edyn
+ dynamic_size
;
7065 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
7069 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
7071 if (dynamic_section
== NULL
)
7073 error (_("Out of memory\n"));
7078 for (ext
= edyn
, entry
= dynamic_section
;
7079 entry
< dynamic_section
+ dynamic_nent
;
7082 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
7083 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
7092 get_64bit_dynamic_section (FILE * file
)
7094 Elf64_External_Dyn
* edyn
;
7095 Elf64_External_Dyn
* ext
;
7096 Elf_Internal_Dyn
* entry
;
7098 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
7099 dynamic_size
, _("dynamic section"));
7103 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7104 might not have the luxury of section headers. Look for the DT_NULL
7105 terminator to determine the number of entries. */
7106 for (ext
= edyn
, dynamic_nent
= 0;
7107 (char *) ext
< (char *) edyn
+ dynamic_size
;
7111 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
7115 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
7117 if (dynamic_section
== NULL
)
7119 error (_("Out of memory\n"));
7124 for (ext
= edyn
, entry
= dynamic_section
;
7125 entry
< dynamic_section
+ dynamic_nent
;
7128 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
7129 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
7138 print_dynamic_flags (bfd_vma flags
)
7146 flag
= flags
& - flags
;
7156 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
7157 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
7158 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
7159 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
7160 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
7161 default: fputs (_("unknown"), stdout
); break;
7167 /* Parse and display the contents of the dynamic section. */
7170 process_dynamic_section (FILE * file
)
7172 Elf_Internal_Dyn
* entry
;
7174 if (dynamic_size
== 0)
7177 printf (_("\nThere is no dynamic section in this file.\n"));
7184 if (! get_32bit_dynamic_section (file
))
7187 else if (! get_64bit_dynamic_section (file
))
7190 /* Find the appropriate symbol table. */
7191 if (dynamic_symbols
== NULL
)
7193 for (entry
= dynamic_section
;
7194 entry
< dynamic_section
+ dynamic_nent
;
7197 Elf_Internal_Shdr section
;
7199 if (entry
->d_tag
!= DT_SYMTAB
)
7202 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
7204 /* Since we do not know how big the symbol table is,
7205 we default to reading in the entire file (!) and
7206 processing that. This is overkill, I know, but it
7208 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
7210 if (archive_file_offset
!= 0)
7211 section
.sh_size
= archive_file_size
- section
.sh_offset
;
7214 if (fseek (file
, 0, SEEK_END
))
7215 error (_("Unable to seek to end of file!\n"));
7217 section
.sh_size
= ftell (file
) - section
.sh_offset
;
7221 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
7223 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
7225 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
7226 if (num_dynamic_syms
< 1)
7228 error (_("Unable to determine the number of symbols to load\n"));
7232 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
7236 /* Similarly find a string table. */
7237 if (dynamic_strings
== NULL
)
7239 for (entry
= dynamic_section
;
7240 entry
< dynamic_section
+ dynamic_nent
;
7243 unsigned long offset
;
7246 if (entry
->d_tag
!= DT_STRTAB
)
7249 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
7251 /* Since we do not know how big the string table is,
7252 we default to reading in the entire file (!) and
7253 processing that. This is overkill, I know, but it
7256 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
7258 if (archive_file_offset
!= 0)
7259 str_tab_len
= archive_file_size
- offset
;
7262 if (fseek (file
, 0, SEEK_END
))
7263 error (_("Unable to seek to end of file\n"));
7264 str_tab_len
= ftell (file
) - offset
;
7267 if (str_tab_len
< 1)
7270 (_("Unable to determine the length of the dynamic string table\n"));
7274 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
7276 _("dynamic string table"));
7277 dynamic_strings_length
= str_tab_len
;
7282 /* And find the syminfo section if available. */
7283 if (dynamic_syminfo
== NULL
)
7285 unsigned long syminsz
= 0;
7287 for (entry
= dynamic_section
;
7288 entry
< dynamic_section
+ dynamic_nent
;
7291 if (entry
->d_tag
== DT_SYMINENT
)
7293 /* Note: these braces are necessary to avoid a syntax
7294 error from the SunOS4 C compiler. */
7295 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
7297 else if (entry
->d_tag
== DT_SYMINSZ
)
7298 syminsz
= entry
->d_un
.d_val
;
7299 else if (entry
->d_tag
== DT_SYMINFO
)
7300 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
7304 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
7306 Elf_External_Syminfo
* extsyminfo
;
7307 Elf_External_Syminfo
* extsym
;
7308 Elf_Internal_Syminfo
* syminfo
;
7310 /* There is a syminfo section. Read the data. */
7311 extsyminfo
= (Elf_External_Syminfo
*)
7312 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
7313 _("symbol information"));
7317 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
7318 if (dynamic_syminfo
== NULL
)
7320 error (_("Out of memory\n"));
7324 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
7325 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
7326 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
7327 ++syminfo
, ++extsym
)
7329 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
7330 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
7337 if (do_dynamic
&& dynamic_addr
)
7338 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7339 dynamic_addr
, dynamic_nent
);
7341 printf (_(" Tag Type Name/Value\n"));
7343 for (entry
= dynamic_section
;
7344 entry
< dynamic_section
+ dynamic_nent
;
7352 print_vma (entry
->d_tag
, FULL_HEX
);
7353 dtype
= get_dynamic_type (entry
->d_tag
);
7354 printf (" (%s)%*s", dtype
,
7355 ((is_32bit_elf
? 27 : 19)
7356 - (int) strlen (dtype
)),
7360 switch (entry
->d_tag
)
7364 print_dynamic_flags (entry
->d_un
.d_val
);
7374 switch (entry
->d_tag
)
7377 printf (_("Auxiliary library"));
7381 printf (_("Filter library"));
7385 printf (_("Configuration file"));
7389 printf (_("Dependency audit library"));
7393 printf (_("Audit library"));
7397 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7398 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
7402 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7411 printf (_("Flags:"));
7413 if (entry
->d_un
.d_val
== 0)
7414 printf (_(" None\n"));
7417 unsigned long int val
= entry
->d_un
.d_val
;
7419 if (val
& DTF_1_PARINIT
)
7421 printf (" PARINIT");
7422 val
^= DTF_1_PARINIT
;
7424 if (val
& DTF_1_CONFEXP
)
7426 printf (" CONFEXP");
7427 val
^= DTF_1_CONFEXP
;
7430 printf (" %lx", val
);
7439 printf (_("Flags:"));
7441 if (entry
->d_un
.d_val
== 0)
7442 printf (_(" None\n"));
7445 unsigned long int val
= entry
->d_un
.d_val
;
7447 if (val
& DF_P1_LAZYLOAD
)
7449 printf (" LAZYLOAD");
7450 val
^= DF_P1_LAZYLOAD
;
7452 if (val
& DF_P1_GROUPPERM
)
7454 printf (" GROUPPERM");
7455 val
^= DF_P1_GROUPPERM
;
7458 printf (" %lx", val
);
7467 printf (_("Flags:"));
7468 if (entry
->d_un
.d_val
== 0)
7469 printf (_(" None\n"));
7472 unsigned long int val
= entry
->d_un
.d_val
;
7479 if (val
& DF_1_GLOBAL
)
7484 if (val
& DF_1_GROUP
)
7489 if (val
& DF_1_NODELETE
)
7491 printf (" NODELETE");
7492 val
^= DF_1_NODELETE
;
7494 if (val
& DF_1_LOADFLTR
)
7496 printf (" LOADFLTR");
7497 val
^= DF_1_LOADFLTR
;
7499 if (val
& DF_1_INITFIRST
)
7501 printf (" INITFIRST");
7502 val
^= DF_1_INITFIRST
;
7504 if (val
& DF_1_NOOPEN
)
7509 if (val
& DF_1_ORIGIN
)
7514 if (val
& DF_1_DIRECT
)
7519 if (val
& DF_1_TRANS
)
7524 if (val
& DF_1_INTERPOSE
)
7526 printf (" INTERPOSE");
7527 val
^= DF_1_INTERPOSE
;
7529 if (val
& DF_1_NODEFLIB
)
7531 printf (" NODEFLIB");
7532 val
^= DF_1_NODEFLIB
;
7534 if (val
& DF_1_NODUMP
)
7539 if (val
& DF_1_CONLFAT
)
7541 printf (" CONLFAT");
7542 val
^= DF_1_CONLFAT
;
7545 printf (" %lx", val
);
7552 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
7554 puts (get_dynamic_type (entry
->d_un
.d_val
));
7574 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
7580 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7581 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
7587 switch (entry
->d_tag
)
7590 printf (_("Shared library: [%s]"), name
);
7592 if (streq (name
, program_interpreter
))
7593 printf (_(" program interpreter"));
7597 printf (_("Library soname: [%s]"), name
);
7601 printf (_("Library rpath: [%s]"), name
);
7605 printf (_("Library runpath: [%s]"), name
);
7609 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7614 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7627 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
7631 case DT_INIT_ARRAYSZ
:
7632 case DT_FINI_ARRAYSZ
:
7633 case DT_GNU_CONFLICTSZ
:
7634 case DT_GNU_LIBLISTSZ
:
7637 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
7638 printf (_(" (bytes)\n"));
7648 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
7661 if (entry
->d_tag
== DT_USED
7662 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7664 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
7668 printf (_("Not needed object: [%s]\n"), name
);
7673 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7679 /* The value of this entry is ignored. */
7684 case DT_GNU_PRELINKED
:
7688 time_t atime
= entry
->d_un
.d_val
;
7690 tmp
= gmtime (&atime
);
7691 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
7692 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
7693 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
7699 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
7702 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7708 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
7709 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
7714 switch (elf_header
.e_machine
)
7717 case EM_MIPS_RS3_LE
:
7718 dynamic_section_mips_val (entry
);
7721 dynamic_section_parisc_val (entry
);
7724 dynamic_section_ia64_val (entry
);
7727 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7739 get_ver_flags (unsigned int flags
)
7741 static char buff
[32];
7748 if (flags
& VER_FLG_BASE
)
7749 strcat (buff
, "BASE ");
7751 if (flags
& VER_FLG_WEAK
)
7753 if (flags
& VER_FLG_BASE
)
7754 strcat (buff
, "| ");
7756 strcat (buff
, "WEAK ");
7759 if (flags
& VER_FLG_INFO
)
7761 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
7762 strcat (buff
, "| ");
7764 strcat (buff
, "INFO ");
7767 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
7768 strcat (buff
, _("| <unknown>"));
7773 /* Display the contents of the version sections. */
7776 process_version_sections (FILE * file
)
7778 Elf_Internal_Shdr
* section
;
7785 for (i
= 0, section
= section_headers
;
7786 i
< elf_header
.e_shnum
;
7789 switch (section
->sh_type
)
7791 case SHT_GNU_verdef
:
7793 Elf_External_Verdef
* edefs
;
7801 (_("\nVersion definition section '%s' contains %u entries:\n"),
7802 SECTION_NAME (section
), section
->sh_info
);
7804 printf (_(" Addr: 0x"));
7805 printf_vma (section
->sh_addr
);
7806 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
7807 (unsigned long) section
->sh_offset
, section
->sh_link
,
7808 section
->sh_link
< elf_header
.e_shnum
7809 ? SECTION_NAME (section_headers
+ section
->sh_link
)
7812 edefs
= (Elf_External_Verdef
*)
7813 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
7814 _("version definition section"));
7815 endbuf
= (char *) edefs
+ section
->sh_size
;
7819 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
7822 Elf_External_Verdef
* edef
;
7823 Elf_Internal_Verdef ent
;
7824 Elf_External_Verdaux
* eaux
;
7825 Elf_Internal_Verdaux aux
;
7829 /* Check for negative or very large indicies. */
7830 if ((unsigned char *) edefs
+ idx
< (unsigned char *) edefs
)
7833 vstart
= ((char *) edefs
) + idx
;
7834 if (vstart
+ sizeof (*edef
) > endbuf
)
7837 edef
= (Elf_External_Verdef
*) vstart
;
7839 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
7840 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
7841 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
7842 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
7843 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
7844 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
7845 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
7847 printf (_(" %#06x: Rev: %d Flags: %s"),
7848 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
7850 printf (_(" Index: %d Cnt: %d "),
7851 ent
.vd_ndx
, ent
.vd_cnt
);
7853 /* Check for overflow. */
7854 if ((unsigned char *)(vstart
+ ent
.vd_aux
) < (unsigned char *) vstart
7855 || (unsigned char *)(vstart
+ ent
.vd_aux
) > (unsigned char *) endbuf
)
7858 vstart
+= ent
.vd_aux
;
7860 eaux
= (Elf_External_Verdaux
*) vstart
;
7862 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
7863 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
7865 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
7866 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
7868 printf (_("Name index: %ld\n"), aux
.vda_name
);
7870 isum
= idx
+ ent
.vd_aux
;
7872 for (j
= 1; j
< ent
.vd_cnt
; j
++)
7874 /* Check for overflow. */
7875 if ((unsigned char *)(vstart
+ aux
.vda_next
) < (unsigned char *) vstart
7876 || (unsigned char *)(vstart
+ aux
.vda_next
) > (unsigned char *) endbuf
)
7879 isum
+= aux
.vda_next
;
7880 vstart
+= aux
.vda_next
;
7882 eaux
= (Elf_External_Verdaux
*) vstart
;
7883 if (vstart
+ sizeof (*eaux
) > endbuf
)
7886 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
7887 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
7889 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
7890 printf (_(" %#06x: Parent %d: %s\n"),
7891 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
7893 printf (_(" %#06x: Parent %d, name index: %ld\n"),
7894 isum
, j
, aux
.vda_name
);
7898 printf (_(" Version def aux past end of section\n"));
7903 if (cnt
< section
->sh_info
)
7904 printf (_(" Version definition past end of section\n"));
7910 case SHT_GNU_verneed
:
7912 Elf_External_Verneed
* eneed
;
7919 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
7920 SECTION_NAME (section
), section
->sh_info
);
7922 printf (_(" Addr: 0x"));
7923 printf_vma (section
->sh_addr
);
7924 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
7925 (unsigned long) section
->sh_offset
, section
->sh_link
,
7926 section
->sh_link
< elf_header
.e_shnum
7927 ? SECTION_NAME (section_headers
+ section
->sh_link
)
7930 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
7931 section
->sh_offset
, 1,
7933 _("version need section"));
7934 endbuf
= (char *) eneed
+ section
->sh_size
;
7938 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
7940 Elf_External_Verneed
* entry
;
7941 Elf_Internal_Verneed ent
;
7946 if ((unsigned char *) eneed
+ idx
< (unsigned char *) eneed
)
7949 vstart
= ((char *) eneed
) + idx
;
7950 if (vstart
+ sizeof (*entry
) > endbuf
)
7953 entry
= (Elf_External_Verneed
*) vstart
;
7955 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
7956 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
7957 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
7958 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
7959 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
7961 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
7963 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
7964 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
7966 printf (_(" File: %lx"), ent
.vn_file
);
7968 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
7970 /* Check for overflow. */
7971 if ((unsigned char *)(vstart
+ ent
.vn_aux
) < (unsigned char *) vstart
7972 || (unsigned char *)(vstart
+ ent
.vn_aux
) > (unsigned char *) endbuf
)
7975 vstart
+= ent
.vn_aux
;
7977 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
7979 Elf_External_Vernaux
* eaux
;
7980 Elf_Internal_Vernaux aux
;
7982 if (vstart
+ sizeof (*eaux
) > endbuf
)
7984 eaux
= (Elf_External_Vernaux
*) vstart
;
7986 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
7987 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
7988 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
7989 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
7990 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
7992 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
7993 printf (_(" %#06x: Name: %s"),
7994 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
7996 printf (_(" %#06x: Name index: %lx"),
7997 isum
, aux
.vna_name
);
7999 printf (_(" Flags: %s Version: %d\n"),
8000 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
8002 /* Check for overflow. */
8003 if ((unsigned char *)(vstart
+ aux
.vna_next
) < (unsigned char *) vstart
8004 || (unsigned char *)(vstart
+ aux
.vna_next
) > (unsigned char *) endbuf
)
8007 isum
+= aux
.vna_next
;
8008 vstart
+= aux
.vna_next
;
8011 printf (_(" Version need aux past end of section\n"));
8015 if (cnt
< section
->sh_info
)
8016 printf (_(" Version need past end of section\n"));
8022 case SHT_GNU_versym
:
8024 Elf_Internal_Shdr
* link_section
;
8027 unsigned char * edata
;
8028 unsigned short * data
;
8030 Elf_Internal_Sym
* symbols
;
8031 Elf_Internal_Shdr
* string_sec
;
8034 if (section
->sh_link
>= elf_header
.e_shnum
)
8037 link_section
= section_headers
+ section
->sh_link
;
8038 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
8040 if (link_section
->sh_link
>= elf_header
.e_shnum
)
8045 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
8046 if (symbols
== NULL
)
8049 string_sec
= section_headers
+ link_section
->sh_link
;
8051 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
8052 string_sec
->sh_size
,
8053 _("version string table"));
8057 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8058 SECTION_NAME (section
), total
);
8060 printf (_(" Addr: "));
8061 printf_vma (section
->sh_addr
);
8062 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8063 (unsigned long) section
->sh_offset
, section
->sh_link
,
8064 SECTION_NAME (link_section
));
8066 off
= offset_from_vma (file
,
8067 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
8068 total
* sizeof (short));
8069 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
8071 _("version symbol data"));
8078 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
8080 for (cnt
= total
; cnt
--;)
8081 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
8086 for (cnt
= 0; cnt
< total
; cnt
+= 4)
8089 int check_def
, check_need
;
8092 printf (" %03x:", cnt
);
8094 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
8095 switch (data
[cnt
+ j
])
8098 fputs (_(" 0 (*local*) "), stdout
);
8102 fputs (_(" 1 (*global*) "), stdout
);
8106 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
8107 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
8109 /* If this index value is greater than the size of the symbols
8110 array, break to avoid an out-of-bounds read, */
8111 if ((unsigned long)(cnt
+ j
) >=
8112 ((unsigned long)link_section
->sh_size
/
8113 (unsigned long)link_section
->sh_entsize
))
8115 warn (_("invalid index into symbol array\n"));
8121 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
8122 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
8125 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
8132 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
8134 Elf_Internal_Verneed ivn
;
8135 unsigned long offset
;
8137 offset
= offset_from_vma
8138 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
8139 sizeof (Elf_External_Verneed
));
8143 Elf_Internal_Vernaux ivna
;
8144 Elf_External_Verneed evn
;
8145 Elf_External_Vernaux evna
;
8146 unsigned long a_off
;
8148 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
8151 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
8152 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
8154 a_off
= offset
+ ivn
.vn_aux
;
8158 get_data (&evna
, file
, a_off
, sizeof (evna
),
8159 1, _("version need aux (2)"));
8161 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
8162 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
8164 a_off
+= ivna
.vna_next
;
8166 while (ivna
.vna_other
!= data
[cnt
+ j
]
8167 && ivna
.vna_next
!= 0);
8169 if (ivna
.vna_other
== data
[cnt
+ j
])
8171 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
8173 if (ivna
.vna_name
>= string_sec
->sh_size
)
8174 name
= _("*invalid*");
8176 name
= strtab
+ ivna
.vna_name
;
8177 nn
+= printf ("(%s%-*s",
8179 12 - (int) strlen (name
),
8185 offset
+= ivn
.vn_next
;
8187 while (ivn
.vn_next
);
8190 if (check_def
&& data
[cnt
+ j
] != 0x8001
8191 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
8193 Elf_Internal_Verdef ivd
;
8194 Elf_External_Verdef evd
;
8195 unsigned long offset
;
8197 offset
= offset_from_vma
8198 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
8203 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
8206 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
8207 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
8209 offset
+= ivd
.vd_next
;
8211 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
8212 && ivd
.vd_next
!= 0);
8214 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
8216 Elf_External_Verdaux evda
;
8217 Elf_Internal_Verdaux ivda
;
8219 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
8221 get_data (&evda
, file
,
8222 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
8224 _("version def aux"));
8226 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
8228 if (ivda
.vda_name
>= string_sec
->sh_size
)
8229 name
= _("*invalid*");
8231 name
= strtab
+ ivda
.vda_name
;
8232 nn
+= printf ("(%s%-*s",
8234 12 - (int) strlen (name
),
8240 printf ("%*c", 18 - nn
, ' ');
8258 printf (_("\nNo version information found in this file.\n"));
8264 get_symbol_binding (unsigned int binding
)
8266 static char buff
[32];
8270 case STB_LOCAL
: return "LOCAL";
8271 case STB_GLOBAL
: return "GLOBAL";
8272 case STB_WEAK
: return "WEAK";
8274 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
8275 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
8277 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
8279 if (binding
== STB_GNU_UNIQUE
8280 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
8281 /* GNU/Linux is still using the default value 0. */
8282 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
8284 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
8287 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
8293 get_symbol_type (unsigned int type
)
8295 static char buff
[32];
8299 case STT_NOTYPE
: return "NOTYPE";
8300 case STT_OBJECT
: return "OBJECT";
8301 case STT_FUNC
: return "FUNC";
8302 case STT_SECTION
: return "SECTION";
8303 case STT_FILE
: return "FILE";
8304 case STT_COMMON
: return "COMMON";
8305 case STT_TLS
: return "TLS";
8306 case STT_RELC
: return "RELC";
8307 case STT_SRELC
: return "SRELC";
8309 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
8311 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
8312 return "THUMB_FUNC";
8314 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
8317 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
8318 return "PARISC_MILLI";
8320 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
8322 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
8324 if (elf_header
.e_machine
== EM_PARISC
)
8326 if (type
== STT_HP_OPAQUE
)
8328 if (type
== STT_HP_STUB
)
8332 if (type
== STT_GNU_IFUNC
8333 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
8334 /* GNU/Linux is still using the default value 0. */
8335 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
8338 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
8341 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
8347 get_symbol_visibility (unsigned int visibility
)
8351 case STV_DEFAULT
: return "DEFAULT";
8352 case STV_INTERNAL
: return "INTERNAL";
8353 case STV_HIDDEN
: return "HIDDEN";
8354 case STV_PROTECTED
: return "PROTECTED";
8360 get_mips_symbol_other (unsigned int other
)
8364 case STO_OPTIONAL
: return "OPTIONAL";
8365 case STO_MIPS16
: return "MIPS16";
8366 case STO_MIPS_PLT
: return "MIPS PLT";
8367 case STO_MIPS_PIC
: return "MIPS PIC";
8368 default: return NULL
;
8373 get_ia64_symbol_other (unsigned int other
)
8377 static char res
[32];
8381 /* Function types is for images and .STB files only. */
8382 switch (elf_header
.e_type
)
8386 switch (VMS_ST_FUNC_TYPE (other
))
8388 case VMS_SFT_CODE_ADDR
:
8389 strcat (res
, " CA");
8391 case VMS_SFT_SYMV_IDX
:
8392 strcat (res
, " VEC");
8395 strcat (res
, " FD");
8397 case VMS_SFT_RESERVE
:
8398 strcat (res
, " RSV");
8407 switch (VMS_ST_LINKAGE (other
))
8409 case VMS_STL_IGNORE
:
8410 strcat (res
, " IGN");
8412 case VMS_STL_RESERVE
:
8413 strcat (res
, " RSV");
8416 strcat (res
, " STD");
8419 strcat (res
, " LNK");
8434 get_symbol_other (unsigned int other
)
8436 const char * result
= NULL
;
8437 static char buff
[32];
8442 switch (elf_header
.e_machine
)
8445 result
= get_mips_symbol_other (other
);
8448 result
= get_ia64_symbol_other (other
);
8457 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
8462 get_symbol_index_type (unsigned int type
)
8464 static char buff
[32];
8468 case SHN_UNDEF
: return "UND";
8469 case SHN_ABS
: return "ABS";
8470 case SHN_COMMON
: return "COM";
8472 if (type
== SHN_IA_64_ANSI_COMMON
8473 && elf_header
.e_machine
== EM_IA_64
8474 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
8476 else if ((elf_header
.e_machine
== EM_X86_64
8477 || elf_header
.e_machine
== EM_L1OM
)
8478 && type
== SHN_X86_64_LCOMMON
)
8480 else if (type
== SHN_MIPS_SCOMMON
8481 && elf_header
.e_machine
== EM_MIPS
)
8483 else if (type
== SHN_MIPS_SUNDEFINED
8484 && elf_header
.e_machine
== EM_MIPS
)
8486 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
8487 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
8488 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
8489 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
8490 else if (type
>= SHN_LORESERVE
)
8491 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
8493 sprintf (buff
, "%3d", type
);
8501 get_dynamic_data (FILE * file
, unsigned int number
, unsigned int ent_size
)
8503 unsigned char * e_data
;
8506 e_data
= (unsigned char *) cmalloc (number
, ent_size
);
8510 error (_("Out of memory\n"));
8514 if (fread (e_data
, ent_size
, number
, file
) != number
)
8516 error (_("Unable to read in dynamic data\n"));
8520 i_data
= (bfd_vma
*) cmalloc (number
, sizeof (*i_data
));
8524 error (_("Out of memory\n"));
8530 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
8538 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
8540 Elf_Internal_Sym
* psym
;
8543 psym
= dynamic_symbols
+ si
;
8545 n
= print_vma (si
, DEC_5
);
8547 fputs (" " + n
, stdout
);
8548 printf (" %3lu: ", hn
);
8549 print_vma (psym
->st_value
, LONG_HEX
);
8551 print_vma (psym
->st_size
, DEC_5
);
8553 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
8554 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
8555 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
8556 /* Check to see if any other bits in the st_other field are set.
8557 Note - displaying this information disrupts the layout of the
8558 table being generated, but for the moment this case is very
8560 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
8561 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
8562 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
8563 if (VALID_DYNAMIC_NAME (psym
->st_name
))
8564 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
8566 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
8570 /* Dump the symbol table. */
8572 process_symbol_table (FILE * file
)
8574 Elf_Internal_Shdr
* section
;
8575 bfd_vma nbuckets
= 0;
8576 bfd_vma nchains
= 0;
8577 bfd_vma
* buckets
= NULL
;
8578 bfd_vma
* chains
= NULL
;
8579 bfd_vma ngnubuckets
= 0;
8580 bfd_vma
* gnubuckets
= NULL
;
8581 bfd_vma
* gnuchains
= NULL
;
8582 bfd_vma gnusymidx
= 0;
8584 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
8587 if (dynamic_info
[DT_HASH
]
8589 || (do_using_dynamic
8591 && dynamic_strings
!= NULL
)))
8593 unsigned char nb
[8];
8594 unsigned char nc
[8];
8595 int hash_ent_size
= 4;
8597 if ((elf_header
.e_machine
== EM_ALPHA
8598 || elf_header
.e_machine
== EM_S390
8599 || elf_header
.e_machine
== EM_S390_OLD
)
8600 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
8604 (archive_file_offset
8605 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
8606 sizeof nb
+ sizeof nc
)),
8609 error (_("Unable to seek to start of dynamic information\n"));
8613 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
8615 error (_("Failed to read in number of buckets\n"));
8619 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
8621 error (_("Failed to read in number of chains\n"));
8625 nbuckets
= byte_get (nb
, hash_ent_size
);
8626 nchains
= byte_get (nc
, hash_ent_size
);
8628 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
8629 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
8632 if (buckets
== NULL
|| chains
== NULL
)
8634 if (do_using_dynamic
)
8645 if (dynamic_info_DT_GNU_HASH
8647 || (do_using_dynamic
8649 && dynamic_strings
!= NULL
)))
8651 unsigned char nb
[16];
8652 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
8653 bfd_vma buckets_vma
;
8656 (archive_file_offset
8657 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
8661 error (_("Unable to seek to start of dynamic information\n"));
8665 if (fread (nb
, 16, 1, file
) != 1)
8667 error (_("Failed to read in number of buckets\n"));
8671 ngnubuckets
= byte_get (nb
, 4);
8672 gnusymidx
= byte_get (nb
+ 4, 4);
8673 bitmaskwords
= byte_get (nb
+ 8, 4);
8674 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
8676 buckets_vma
+= bitmaskwords
* 4;
8678 buckets_vma
+= bitmaskwords
* 8;
8681 (archive_file_offset
8682 + offset_from_vma (file
, buckets_vma
, 4)),
8685 error (_("Unable to seek to start of dynamic information\n"));
8689 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
8691 if (gnubuckets
== NULL
)
8694 for (i
= 0; i
< ngnubuckets
; i
++)
8695 if (gnubuckets
[i
] != 0)
8697 if (gnubuckets
[i
] < gnusymidx
)
8700 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
8701 maxchain
= gnubuckets
[i
];
8704 if (maxchain
== 0xffffffff)
8707 maxchain
-= gnusymidx
;
8710 (archive_file_offset
8711 + offset_from_vma (file
, buckets_vma
8712 + 4 * (ngnubuckets
+ maxchain
), 4)),
8715 error (_("Unable to seek to start of dynamic information\n"));
8721 if (fread (nb
, 4, 1, file
) != 1)
8723 error (_("Failed to determine last chain length\n"));
8727 if (maxchain
+ 1 == 0)
8732 while ((byte_get (nb
, 4) & 1) == 0);
8735 (archive_file_offset
8736 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
8739 error (_("Unable to seek to start of dynamic information\n"));
8743 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
8746 if (gnuchains
== NULL
)
8751 if (do_using_dynamic
)
8756 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
8759 && dynamic_strings
!= NULL
)
8763 if (dynamic_info
[DT_HASH
])
8767 printf (_("\nSymbol table for image:\n"));
8769 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8771 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8773 for (hn
= 0; hn
< nbuckets
; hn
++)
8778 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
8779 print_dynamic_symbol (si
, hn
);
8783 if (dynamic_info_DT_GNU_HASH
)
8785 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
8787 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8789 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8791 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
8792 if (gnubuckets
[hn
] != 0)
8794 bfd_vma si
= gnubuckets
[hn
];
8795 bfd_vma off
= si
- gnusymidx
;
8799 print_dynamic_symbol (si
, hn
);
8802 while ((gnuchains
[off
++] & 1) == 0);
8806 else if (do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
8810 for (i
= 0, section
= section_headers
;
8811 i
< elf_header
.e_shnum
;
8815 char * strtab
= NULL
;
8816 unsigned long int strtab_size
= 0;
8817 Elf_Internal_Sym
* symtab
;
8818 Elf_Internal_Sym
* psym
;
8820 if ((section
->sh_type
!= SHT_SYMTAB
8821 && section
->sh_type
!= SHT_DYNSYM
)
8823 && section
->sh_type
== SHT_SYMTAB
))
8826 if (section
->sh_entsize
== 0)
8828 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
8829 SECTION_NAME (section
));
8833 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
8834 SECTION_NAME (section
),
8835 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
8838 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
8840 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
8842 symtab
= GET_ELF_SYMBOLS (file
, section
);
8846 if (section
->sh_link
== elf_header
.e_shstrndx
)
8848 strtab
= string_table
;
8849 strtab_size
= string_table_length
;
8851 else if (section
->sh_link
< elf_header
.e_shnum
)
8853 Elf_Internal_Shdr
* string_sec
;
8855 string_sec
= section_headers
+ section
->sh_link
;
8857 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
8858 1, string_sec
->sh_size
,
8860 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
8863 for (si
= 0, psym
= symtab
;
8864 si
< section
->sh_size
/ section
->sh_entsize
;
8867 printf ("%6d: ", si
);
8868 print_vma (psym
->st_value
, LONG_HEX
);
8870 print_vma (psym
->st_size
, DEC_5
);
8871 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
8872 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
8873 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
8874 /* Check to see if any other bits in the st_other field are set.
8875 Note - displaying this information disrupts the layout of the
8876 table being generated, but for the moment this case is very rare. */
8877 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
8878 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
8879 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
8880 print_symbol (25, psym
->st_name
< strtab_size
8881 ? strtab
+ psym
->st_name
: _("<corrupt>"));
8883 if (section
->sh_type
== SHT_DYNSYM
&&
8884 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
8886 unsigned char data
[2];
8887 unsigned short vers_data
;
8888 unsigned long offset
;
8892 offset
= offset_from_vma
8893 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
8894 sizeof data
+ si
* sizeof (vers_data
));
8896 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
8897 sizeof (data
), 1, _("version data"));
8899 vers_data
= byte_get (data
, 2);
8901 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
8902 && section_headers
[psym
->st_shndx
].sh_type
8905 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
8907 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
8909 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
8910 && (is_nobits
|| ! check_def
))
8912 Elf_External_Verneed evn
;
8913 Elf_Internal_Verneed ivn
;
8914 Elf_Internal_Vernaux ivna
;
8916 /* We must test both. */
8917 offset
= offset_from_vma
8918 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
8923 unsigned long vna_off
;
8925 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
8928 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
8929 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
8931 vna_off
= offset
+ ivn
.vn_aux
;
8935 Elf_External_Vernaux evna
;
8937 get_data (&evna
, file
, vna_off
,
8939 _("version need aux (3)"));
8941 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
8942 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
8943 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
8945 vna_off
+= ivna
.vna_next
;
8947 while (ivna
.vna_other
!= vers_data
8948 && ivna
.vna_next
!= 0);
8950 if (ivna
.vna_other
== vers_data
)
8953 offset
+= ivn
.vn_next
;
8955 while (ivn
.vn_next
!= 0);
8957 if (ivna
.vna_other
== vers_data
)
8960 ivna
.vna_name
< strtab_size
8961 ? strtab
+ ivna
.vna_name
: _("<corrupt>"),
8965 else if (! is_nobits
)
8966 error (_("bad dynamic symbol\n"));
8973 if (vers_data
!= 0x8001
8974 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
8976 Elf_Internal_Verdef ivd
;
8977 Elf_Internal_Verdaux ivda
;
8978 Elf_External_Verdaux evda
;
8981 off
= offset_from_vma
8983 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
8984 sizeof (Elf_External_Verdef
));
8988 Elf_External_Verdef evd
;
8990 get_data (&evd
, file
, off
, sizeof (evd
),
8991 1, _("version def"));
8993 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
8994 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
8995 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
8999 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
9000 && ivd
.vd_next
!= 0);
9005 get_data (&evda
, file
, off
, sizeof (evda
),
9006 1, _("version def aux"));
9008 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
9010 if (psym
->st_name
!= ivda
.vda_name
)
9011 printf ((vers_data
& VERSYM_HIDDEN
)
9013 ivda
.vda_name
< strtab_size
9014 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
9024 if (strtab
!= string_table
)
9030 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9032 if (do_histogram
&& buckets
!= NULL
)
9034 unsigned long * lengths
;
9035 unsigned long * counts
;
9038 unsigned long maxlength
= 0;
9039 unsigned long nzero_counts
= 0;
9040 unsigned long nsyms
= 0;
9042 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9043 (unsigned long) nbuckets
);
9044 printf (_(" Length Number %% of total Coverage\n"));
9046 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
9047 if (lengths
== NULL
)
9049 error (_("Out of memory\n"));
9052 for (hn
= 0; hn
< nbuckets
; ++hn
)
9054 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
9057 if (maxlength
< ++lengths
[hn
])
9062 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
9065 error (_("Out of memory\n"));
9069 for (hn
= 0; hn
< nbuckets
; ++hn
)
9070 ++counts
[lengths
[hn
]];
9075 printf (" 0 %-10lu (%5.1f%%)\n",
9076 counts
[0], (counts
[0] * 100.0) / nbuckets
);
9077 for (i
= 1; i
<= maxlength
; ++i
)
9079 nzero_counts
+= counts
[i
] * i
;
9080 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9081 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
9082 (nzero_counts
* 100.0) / nsyms
);
9090 if (buckets
!= NULL
)
9096 if (do_histogram
&& gnubuckets
!= NULL
)
9098 unsigned long * lengths
;
9099 unsigned long * counts
;
9101 unsigned long maxlength
= 0;
9102 unsigned long nzero_counts
= 0;
9103 unsigned long nsyms
= 0;
9105 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
9106 if (lengths
== NULL
)
9108 error (_("Out of memory\n"));
9112 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9113 (unsigned long) ngnubuckets
);
9114 printf (_(" Length Number %% of total Coverage\n"));
9116 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9117 if (gnubuckets
[hn
] != 0)
9119 bfd_vma off
, length
= 1;
9121 for (off
= gnubuckets
[hn
] - gnusymidx
;
9122 (gnuchains
[off
] & 1) == 0; ++off
)
9124 lengths
[hn
] = length
;
9125 if (length
> maxlength
)
9130 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
9133 error (_("Out of memory\n"));
9137 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9138 ++counts
[lengths
[hn
]];
9140 if (ngnubuckets
> 0)
9143 printf (" 0 %-10lu (%5.1f%%)\n",
9144 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
9145 for (j
= 1; j
<= maxlength
; ++j
)
9147 nzero_counts
+= counts
[j
] * j
;
9148 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9149 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
9150 (nzero_counts
* 100.0) / nsyms
);
9164 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
9168 if (dynamic_syminfo
== NULL
9170 /* No syminfo, this is ok. */
9173 /* There better should be a dynamic symbol section. */
9174 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
9178 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9179 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
9181 printf (_(" Num: Name BoundTo Flags\n"));
9182 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
9184 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
9186 printf ("%4d: ", i
);
9187 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
9188 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
9190 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
9193 switch (dynamic_syminfo
[i
].si_boundto
)
9195 case SYMINFO_BT_SELF
:
9196 fputs ("SELF ", stdout
);
9198 case SYMINFO_BT_PARENT
:
9199 fputs ("PARENT ", stdout
);
9202 if (dynamic_syminfo
[i
].si_boundto
> 0
9203 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
9204 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
9206 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
9210 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
9214 if (flags
& SYMINFO_FLG_DIRECT
)
9216 if (flags
& SYMINFO_FLG_PASSTHRU
)
9217 printf (" PASSTHRU");
9218 if (flags
& SYMINFO_FLG_COPY
)
9220 if (flags
& SYMINFO_FLG_LAZYLOAD
)
9221 printf (" LAZYLOAD");
9229 /* Check to see if the given reloc needs to be handled in a target specific
9230 manner. If so then process the reloc and return TRUE otherwise return
9234 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
9235 unsigned char * start
,
9236 Elf_Internal_Sym
* symtab
)
9238 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
9240 switch (elf_header
.e_machine
)
9243 case EM_CYGNUS_MN10300
:
9245 static Elf_Internal_Sym
* saved_sym
= NULL
;
9249 case 34: /* R_MN10300_ALIGN */
9251 case 33: /* R_MN10300_SYM_DIFF */
9252 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
9254 case 1: /* R_MN10300_32 */
9255 case 2: /* R_MN10300_16 */
9256 if (saved_sym
!= NULL
)
9260 value
= reloc
->r_addend
9261 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
9262 - saved_sym
->st_value
);
9264 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
9271 if (saved_sym
!= NULL
)
9272 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9282 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9283 DWARF debug sections. This is a target specific test. Note - we do not
9284 go through the whole including-target-headers-multiple-times route, (as
9285 we have already done with <elf/h8.h>) because this would become very
9286 messy and even then this function would have to contain target specific
9287 information (the names of the relocs instead of their numeric values).
9288 FIXME: This is not the correct way to solve this problem. The proper way
9289 is to have target specific reloc sizing and typing functions created by
9290 the reloc-macros.h header, in the same way that it already creates the
9291 reloc naming functions. */
9294 is_32bit_abs_reloc (unsigned int reloc_type
)
9296 switch (elf_header
.e_machine
)
9300 return reloc_type
== 1; /* R_386_32. */
9302 return reloc_type
== 1; /* R_68K_32. */
9304 return reloc_type
== 1; /* R_860_32. */
9306 return reloc_type
== 2; /* R_960_32. */
9308 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
9310 return reloc_type
== 1; /* R_ARC_32. */
9312 return reloc_type
== 2; /* R_ARM_ABS32 */
9315 return reloc_type
== 1;
9317 return reloc_type
== 0x12; /* R_byte4_data. */
9319 return reloc_type
== 3; /* R_CRIS_32. */
9322 return reloc_type
== 3; /* R_CR16_NUM32. */
9324 return reloc_type
== 15; /* R_CRX_NUM32. */
9326 return reloc_type
== 1;
9327 case EM_CYGNUS_D10V
:
9329 return reloc_type
== 6; /* R_D10V_32. */
9330 case EM_CYGNUS_D30V
:
9332 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
9334 return reloc_type
== 3; /* R_DLX_RELOC_32. */
9335 case EM_CYGNUS_FR30
:
9337 return reloc_type
== 3; /* R_FR30_32. */
9341 return reloc_type
== 1; /* R_H8_DIR32. */
9343 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
9346 return reloc_type
== 2; /* R_IP2K_32. */
9348 return reloc_type
== 2; /* R_IQ2000_32. */
9349 case EM_LATTICEMICO32
:
9350 return reloc_type
== 3; /* R_LM32_32. */
9353 return reloc_type
== 3; /* R_M32C_32. */
9355 return reloc_type
== 34; /* R_M32R_32_RELA. */
9357 return reloc_type
== 1; /* R_MCORE_ADDR32. */
9359 return reloc_type
== 4; /* R_MEP_32. */
9361 return reloc_type
== 1; /* R_MICROBLAZE_32. */
9363 return reloc_type
== 2; /* R_MIPS_32. */
9365 return reloc_type
== 4; /* R_MMIX_32. */
9366 case EM_CYGNUS_MN10200
:
9368 return reloc_type
== 1; /* R_MN10200_32. */
9369 case EM_CYGNUS_MN10300
:
9371 return reloc_type
== 1; /* R_MN10300_32. */
9373 return reloc_type
== 1; /* R_MOXIE_32. */
9376 return reloc_type
== 1; /* R_MSP43_32. */
9378 return reloc_type
== 2; /* R_MT_32. */
9379 case EM_ALTERA_NIOS2
:
9381 return reloc_type
== 1; /* R_NIOS_32. */
9384 return reloc_type
== 1; /* R_OR32_32. */
9386 return (reloc_type
== 1 /* R_PARISC_DIR32. */
9387 || reloc_type
== 41); /* R_PARISC_SECREL32. */
9390 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
9392 return reloc_type
== 1; /* R_PPC64_ADDR32. */
9394 return reloc_type
== 1; /* R_PPC_ADDR32. */
9396 return reloc_type
== 1; /* R_RX_DIR32. */
9398 return reloc_type
== 1; /* R_I370_ADDR31. */
9401 return reloc_type
== 4; /* R_S390_32. */
9403 return reloc_type
== 8; /* R_SCORE_ABS32. */
9405 return reloc_type
== 1; /* R_SH_DIR32. */
9406 case EM_SPARC32PLUS
:
9409 return reloc_type
== 3 /* R_SPARC_32. */
9410 || reloc_type
== 23; /* R_SPARC_UA32. */
9412 return reloc_type
== 6; /* R_SPU_ADDR32 */
9414 return reloc_type
== 1; /* R_C6000_ABS32. */
9415 case EM_CYGNUS_V850
:
9417 return reloc_type
== 6; /* R_V850_ABS32. */
9419 return reloc_type
== 1; /* R_VAX_32. */
9422 return reloc_type
== 10; /* R_X86_64_32. */
9425 return reloc_type
== 3; /* R_XC16C_ABS_32. */
9427 return reloc_type
== 1; /* R_XSTROMY16_32. */
9430 return reloc_type
== 1; /* R_XTENSA_32. */
9432 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
9433 elf_header
.e_machine
);
9438 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9439 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
9442 is_32bit_pcrel_reloc (unsigned int reloc_type
)
9444 switch (elf_header
.e_machine
)
9448 return reloc_type
== 2; /* R_386_PC32. */
9450 return reloc_type
== 4; /* R_68K_PC32. */
9452 return reloc_type
== 10; /* R_ALPHA_SREL32. */
9454 return reloc_type
== 3; /* R_ARM_REL32 */
9456 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
9458 return reloc_type
== 9; /* R_PARISC_PCREL32. */
9460 return reloc_type
== 26; /* R_PPC_REL32. */
9462 return reloc_type
== 26; /* R_PPC64_REL32. */
9465 return reloc_type
== 5; /* R_390_PC32. */
9467 return reloc_type
== 2; /* R_SH_REL32. */
9468 case EM_SPARC32PLUS
:
9471 return reloc_type
== 6; /* R_SPARC_DISP32. */
9473 return reloc_type
== 13; /* R_SPU_REL32. */
9476 return reloc_type
== 2; /* R_X86_64_PC32. */
9479 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
9481 /* Do not abort or issue an error message here. Not all targets use
9482 pc-relative 32-bit relocs in their DWARF debug information and we
9483 have already tested for target coverage in is_32bit_abs_reloc. A
9484 more helpful warning message will be generated by apply_relocations
9485 anyway, so just return. */
9490 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9491 a 64-bit absolute RELA relocation used in DWARF debug sections. */
9494 is_64bit_abs_reloc (unsigned int reloc_type
)
9496 switch (elf_header
.e_machine
)
9499 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
9501 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
9503 return reloc_type
== 80; /* R_PARISC_DIR64. */
9505 return reloc_type
== 38; /* R_PPC64_ADDR64. */
9506 case EM_SPARC32PLUS
:
9509 return reloc_type
== 54; /* R_SPARC_UA64. */
9512 return reloc_type
== 1; /* R_X86_64_64. */
9515 return reloc_type
== 22; /* R_S390_64 */
9517 return reloc_type
== 18; /* R_MIPS_64 */
9523 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
9524 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
9527 is_64bit_pcrel_reloc (unsigned int reloc_type
)
9529 switch (elf_header
.e_machine
)
9532 return reloc_type
== 11; /* R_ALPHA_SREL64 */
9534 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB */
9536 return reloc_type
== 72; /* R_PARISC_PCREL64 */
9538 return reloc_type
== 44; /* R_PPC64_REL64 */
9539 case EM_SPARC32PLUS
:
9542 return reloc_type
== 46; /* R_SPARC_DISP64 */
9545 return reloc_type
== 24; /* R_X86_64_PC64 */
9548 return reloc_type
== 23; /* R_S390_PC64 */
9554 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9555 a 24-bit absolute RELA relocation used in DWARF debug sections. */
9558 is_24bit_abs_reloc (unsigned int reloc_type
)
9560 switch (elf_header
.e_machine
)
9562 case EM_CYGNUS_MN10200
:
9564 return reloc_type
== 4; /* R_MN10200_24. */
9570 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9571 a 16-bit absolute RELA relocation used in DWARF debug sections. */
9574 is_16bit_abs_reloc (unsigned int reloc_type
)
9576 switch (elf_header
.e_machine
)
9580 return reloc_type
== 4; /* R_AVR_16. */
9581 case EM_CYGNUS_D10V
:
9583 return reloc_type
== 3; /* R_D10V_16. */
9587 return reloc_type
== R_H8_DIR16
;
9590 return reloc_type
== 1; /* R_IP2K_16. */
9593 return reloc_type
== 1; /* R_M32C_16 */
9596 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
9597 case EM_ALTERA_NIOS2
:
9599 return reloc_type
== 9; /* R_NIOS_16. */
9601 return reloc_type
== 2; /* R_C6000_ABS16. */
9604 return reloc_type
== 2; /* R_XC16C_ABS_16. */
9610 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
9611 relocation entries (possibly formerly used for SHT_GROUP sections). */
9614 is_none_reloc (unsigned int reloc_type
)
9616 switch (elf_header
.e_machine
)
9618 case EM_68K
: /* R_68K_NONE. */
9619 case EM_386
: /* R_386_NONE. */
9620 case EM_SPARC32PLUS
:
9622 case EM_SPARC
: /* R_SPARC_NONE. */
9623 case EM_MIPS
: /* R_MIPS_NONE. */
9624 case EM_PARISC
: /* R_PARISC_NONE. */
9625 case EM_ALPHA
: /* R_ALPHA_NONE. */
9626 case EM_PPC
: /* R_PPC_NONE. */
9627 case EM_PPC64
: /* R_PPC64_NONE. */
9628 case EM_ARM
: /* R_ARM_NONE. */
9629 case EM_IA_64
: /* R_IA64_NONE. */
9630 case EM_SH
: /* R_SH_NONE. */
9632 case EM_S390
: /* R_390_NONE. */
9633 case EM_CRIS
: /* R_CRIS_NONE. */
9634 case EM_X86_64
: /* R_X86_64_NONE. */
9635 case EM_L1OM
: /* R_X86_64_NONE. */
9636 case EM_MN10300
: /* R_MN10300_NONE. */
9637 case EM_MOXIE
: /* R_MOXIE_NONE. */
9638 case EM_M32R
: /* R_M32R_NONE. */
9639 case EM_TI_C6000
:/* R_C6000_NONE. */
9641 case EM_C166
: /* R_XC16X_NONE. */
9642 return reloc_type
== 0;
9645 return (reloc_type
== 0 /* R_XTENSA_NONE. */
9646 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
9647 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
9648 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
9653 /* Apply relocations to a section.
9654 Note: So far support has been added only for those relocations
9655 which can be found in debug sections.
9656 FIXME: Add support for more relocations ? */
9659 apply_relocations (void * file
,
9660 Elf_Internal_Shdr
* section
,
9661 unsigned char * start
)
9663 Elf_Internal_Shdr
* relsec
;
9664 unsigned char * end
= start
+ section
->sh_size
;
9666 if (elf_header
.e_type
!= ET_REL
)
9669 /* Find the reloc section associated with the section. */
9670 for (relsec
= section_headers
;
9671 relsec
< section_headers
+ elf_header
.e_shnum
;
9674 bfd_boolean is_rela
;
9675 unsigned long num_relocs
;
9676 Elf_Internal_Rela
* relocs
;
9677 Elf_Internal_Rela
* rp
;
9678 Elf_Internal_Shdr
* symsec
;
9679 Elf_Internal_Sym
* symtab
;
9680 Elf_Internal_Sym
* sym
;
9682 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
9683 || relsec
->sh_info
>= elf_header
.e_shnum
9684 || section_headers
+ relsec
->sh_info
!= section
9685 || relsec
->sh_size
== 0
9686 || relsec
->sh_link
>= elf_header
.e_shnum
)
9689 is_rela
= relsec
->sh_type
== SHT_RELA
;
9693 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
9694 relsec
->sh_size
, & relocs
, & num_relocs
))
9699 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
9700 relsec
->sh_size
, & relocs
, & num_relocs
))
9704 /* SH uses RELA but uses in place value instead of the addend field. */
9705 if (elf_header
.e_machine
== EM_SH
)
9708 symsec
= section_headers
+ relsec
->sh_link
;
9709 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
);
9711 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
9714 unsigned int reloc_type
;
9715 unsigned int reloc_size
;
9716 unsigned char * rloc
;
9718 reloc_type
= get_reloc_type (rp
->r_info
);
9720 if (target_specific_reloc_handling (rp
, start
, symtab
))
9722 else if (is_none_reloc (reloc_type
))
9724 else if (is_32bit_abs_reloc (reloc_type
)
9725 || is_32bit_pcrel_reloc (reloc_type
))
9727 else if (is_64bit_abs_reloc (reloc_type
)
9728 || is_64bit_pcrel_reloc (reloc_type
))
9730 else if (is_24bit_abs_reloc (reloc_type
))
9732 else if (is_16bit_abs_reloc (reloc_type
))
9736 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
9737 reloc_type
, SECTION_NAME (section
));
9741 rloc
= start
+ rp
->r_offset
;
9742 if ((rloc
+ reloc_size
) > end
)
9744 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
9745 (unsigned long) rp
->r_offset
,
9746 SECTION_NAME (section
));
9750 sym
= symtab
+ get_reloc_symindex (rp
->r_info
);
9752 /* If the reloc has a symbol associated with it,
9753 make sure that it is of an appropriate type.
9755 Relocations against symbols without type can happen.
9756 Gcc -feliminate-dwarf2-dups may generate symbols
9757 without type for debug info.
9759 Icc generates relocations against function symbols
9760 instead of local labels.
9762 Relocations against object symbols can happen, eg when
9763 referencing a global array. For an example of this see
9764 the _clz.o binary in libgcc.a. */
9766 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
9768 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
9769 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
9770 (long int)(rp
- relocs
),
9771 SECTION_NAME (relsec
));
9777 addend
+= rp
->r_addend
;
9778 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
9781 || (elf_header
.e_machine
== EM_XTENSA
9783 || ((elf_header
.e_machine
== EM_PJ
9784 || elf_header
.e_machine
== EM_PJ_OLD
)
9786 || ((elf_header
.e_machine
== EM_D30V
9787 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
9788 && reloc_type
== 12))
9789 addend
+= byte_get (rloc
, reloc_size
);
9791 if (is_32bit_pcrel_reloc (reloc_type
)
9792 || is_64bit_pcrel_reloc (reloc_type
))
9794 /* On HPPA, all pc-relative relocations are biased by 8. */
9795 if (elf_header
.e_machine
== EM_PARISC
)
9797 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
9801 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
9810 #ifdef SUPPORT_DISASSEMBLY
9812 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
9814 printf (_("\nAssembly dump of section %s\n"),
9815 SECTION_NAME (section
));
9817 /* XXX -- to be done --- XXX */
9823 /* Reads in the contents of SECTION from FILE, returning a pointer
9824 to a malloc'ed buffer or NULL if something went wrong. */
9827 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
9829 bfd_size_type num_bytes
;
9831 num_bytes
= section
->sh_size
;
9833 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
9835 printf (_("\nSection '%s' has no data to dump.\n"),
9836 SECTION_NAME (section
));
9840 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
9841 _("section contents"));
9846 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
9848 Elf_Internal_Shdr
* relsec
;
9849 bfd_size_type num_bytes
;
9853 char * name
= SECTION_NAME (section
);
9854 bfd_boolean some_strings_shown
;
9856 start
= get_section_contents (section
, file
);
9860 printf (_("\nString dump of section '%s':\n"), name
);
9862 /* If the section being dumped has relocations against it the user might
9863 be expecting these relocations to have been applied. Check for this
9864 case and issue a warning message in order to avoid confusion.
9865 FIXME: Maybe we ought to have an option that dumps a section with
9867 for (relsec
= section_headers
;
9868 relsec
< section_headers
+ elf_header
.e_shnum
;
9871 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
9872 || relsec
->sh_info
>= elf_header
.e_shnum
9873 || section_headers
+ relsec
->sh_info
!= section
9874 || relsec
->sh_size
== 0
9875 || relsec
->sh_link
>= elf_header
.e_shnum
)
9878 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
9882 num_bytes
= section
->sh_size
;
9884 end
= start
+ num_bytes
;
9885 some_strings_shown
= FALSE
;
9889 while (!ISPRINT (* data
))
9896 /* PR 11128: Use two separate invocations in order to work
9897 around bugs in the Solaris 8 implementation of printf. */
9898 printf (" [%6tx] ", data
- start
);
9899 printf ("%s\n", data
);
9901 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
9903 data
+= strlen (data
);
9904 some_strings_shown
= TRUE
;
9908 if (! some_strings_shown
)
9909 printf (_(" No strings found in this section."));
9917 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
9919 bfd_boolean relocate
)
9921 Elf_Internal_Shdr
* relsec
;
9922 bfd_size_type bytes
;
9924 unsigned char * data
;
9925 unsigned char * start
;
9927 start
= (unsigned char *) get_section_contents (section
, file
);
9931 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
9935 apply_relocations (file
, section
, start
);
9939 /* If the section being dumped has relocations against it the user might
9940 be expecting these relocations to have been applied. Check for this
9941 case and issue a warning message in order to avoid confusion.
9942 FIXME: Maybe we ought to have an option that dumps a section with
9944 for (relsec
= section_headers
;
9945 relsec
< section_headers
+ elf_header
.e_shnum
;
9948 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
9949 || relsec
->sh_info
>= elf_header
.e_shnum
9950 || section_headers
+ relsec
->sh_info
!= section
9951 || relsec
->sh_size
== 0
9952 || relsec
->sh_link
>= elf_header
.e_shnum
)
9955 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
9960 addr
= section
->sh_addr
;
9961 bytes
= section
->sh_size
;
9970 lbytes
= (bytes
> 16 ? 16 : bytes
);
9972 printf (" 0x%8.8lx ", (unsigned long) addr
);
9974 for (j
= 0; j
< 16; j
++)
9977 printf ("%2.2x", data
[j
]);
9985 for (j
= 0; j
< lbytes
; j
++)
9988 if (k
>= ' ' && k
< 0x7f)
10006 /* Uncompresses a section that was compressed using zlib, in place. */
10009 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED
,
10010 dwarf_size_type
*size ATTRIBUTE_UNUSED
)
10012 #ifndef HAVE_ZLIB_H
10015 dwarf_size_type compressed_size
= *size
;
10016 unsigned char * compressed_buffer
= *buffer
;
10017 dwarf_size_type uncompressed_size
;
10018 unsigned char * uncompressed_buffer
;
10021 dwarf_size_type header_size
= 12;
10023 /* Read the zlib header. In this case, it should be "ZLIB" followed
10024 by the uncompressed section size, 8 bytes in big-endian order. */
10025 if (compressed_size
< header_size
10026 || ! streq ((char *) compressed_buffer
, "ZLIB"))
10029 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
10030 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
10031 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
10032 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
10033 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
10034 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
10035 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
10036 uncompressed_size
+= compressed_buffer
[11];
10038 /* It is possible the section consists of several compressed
10039 buffers concatenated together, so we uncompress in a loop. */
10040 strm
.zalloc
= NULL
;
10042 strm
.opaque
= NULL
;
10043 strm
.avail_in
= compressed_size
- header_size
;
10044 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
10045 strm
.avail_out
= uncompressed_size
;
10046 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
10048 rc
= inflateInit (& strm
);
10049 while (strm
.avail_in
> 0)
10053 strm
.next_out
= ((Bytef
*) uncompressed_buffer
10054 + (uncompressed_size
- strm
.avail_out
));
10055 rc
= inflate (&strm
, Z_FINISH
);
10056 if (rc
!= Z_STREAM_END
)
10058 rc
= inflateReset (& strm
);
10060 rc
= inflateEnd (& strm
);
10062 || strm
.avail_out
!= 0)
10065 free (compressed_buffer
);
10066 *buffer
= uncompressed_buffer
;
10067 *size
= uncompressed_size
;
10071 free (uncompressed_buffer
);
10072 /* Indicate decompression failure. */
10075 #endif /* HAVE_ZLIB_H */
10079 load_specific_debug_section (enum dwarf_section_display_enum debug
,
10080 Elf_Internal_Shdr
* sec
, void * file
)
10082 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
10085 /* If it is already loaded, do nothing. */
10086 if (section
->start
!= NULL
)
10089 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
10090 section
->address
= sec
->sh_addr
;
10091 section
->size
= sec
->sh_size
;
10092 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
10094 sec
->sh_size
, buf
);
10095 if (uncompress_section_contents (§ion
->start
, §ion
->size
))
10096 sec
->sh_size
= section
->size
;
10098 if (section
->start
== NULL
)
10101 if (debug_displays
[debug
].relocate
)
10102 apply_relocations ((FILE *) file
, sec
, section
->start
);
10108 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
10110 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
10111 Elf_Internal_Shdr
* sec
;
10113 /* Locate the debug section. */
10114 sec
= find_section (section
->uncompressed_name
);
10116 section
->name
= section
->uncompressed_name
;
10119 sec
= find_section (section
->compressed_name
);
10121 section
->name
= section
->compressed_name
;
10126 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
10130 free_debug_section (enum dwarf_section_display_enum debug
)
10132 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
10134 if (section
->start
== NULL
)
10137 free ((char *) section
->start
);
10138 section
->start
= NULL
;
10139 section
->address
= 0;
10144 display_debug_section (Elf_Internal_Shdr
* section
, FILE * file
)
10146 char * name
= SECTION_NAME (section
);
10147 bfd_size_type length
;
10151 length
= section
->sh_size
;
10154 printf (_("\nSection '%s' has no debugging data.\n"), name
);
10157 if (section
->sh_type
== SHT_NOBITS
)
10159 /* There is no point in dumping the contents of a debugging section
10160 which has the NOBITS type - the bits in the file will be random.
10161 This can happen when a file containing a .eh_frame section is
10162 stripped with the --only-keep-debug command line option. */
10163 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name
);
10167 if (const_strneq (name
, ".gnu.linkonce.wi."))
10168 name
= ".debug_info";
10170 /* See if we know how to display the contents of this section. */
10171 for (i
= 0; i
< max
; i
++)
10172 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
10173 || streq (debug_displays
[i
].section
.compressed_name
, name
))
10175 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
10176 int secondary
= (section
!= find_section (name
));
10179 free_debug_section ((enum dwarf_section_display_enum
) i
);
10181 if (streq (sec
->uncompressed_name
, name
))
10182 sec
->name
= sec
->uncompressed_name
;
10184 sec
->name
= sec
->compressed_name
;
10185 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
10188 result
&= debug_displays
[i
].display (sec
, file
);
10190 if (secondary
|| (i
!= info
&& i
!= abbrev
))
10191 free_debug_section ((enum dwarf_section_display_enum
) i
);
10199 printf (_("Unrecognized debug section: %s\n"), name
);
10206 /* Set DUMP_SECTS for all sections where dumps were requested
10207 based on section name. */
10210 initialise_dumps_byname (void)
10212 struct dump_list_entry
* cur
;
10214 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
10219 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
10220 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
10222 request_dump_bynumber (i
, cur
->type
);
10227 warn (_("Section '%s' was not dumped because it does not exist!\n"),
10233 process_section_contents (FILE * file
)
10235 Elf_Internal_Shdr
* section
;
10241 initialise_dumps_byname ();
10243 for (i
= 0, section
= section_headers
;
10244 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
10247 #ifdef SUPPORT_DISASSEMBLY
10248 if (dump_sects
[i
] & DISASS_DUMP
)
10249 disassemble_section (section
, file
);
10251 if (dump_sects
[i
] & HEX_DUMP
)
10252 dump_section_as_bytes (section
, file
, FALSE
);
10254 if (dump_sects
[i
] & RELOC_DUMP
)
10255 dump_section_as_bytes (section
, file
, TRUE
);
10257 if (dump_sects
[i
] & STRING_DUMP
)
10258 dump_section_as_strings (section
, file
);
10260 if (dump_sects
[i
] & DEBUG_DUMP
)
10261 display_debug_section (section
, file
);
10264 /* Check to see if the user requested a
10265 dump of a section that does not exist. */
10266 while (i
++ < num_dump_sects
)
10268 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
10272 process_mips_fpe_exception (int mask
)
10277 if (mask
& OEX_FPU_INEX
)
10278 fputs ("INEX", stdout
), first
= 0;
10279 if (mask
& OEX_FPU_UFLO
)
10280 printf ("%sUFLO", first
? "" : "|"), first
= 0;
10281 if (mask
& OEX_FPU_OFLO
)
10282 printf ("%sOFLO", first
? "" : "|"), first
= 0;
10283 if (mask
& OEX_FPU_DIV0
)
10284 printf ("%sDIV0", first
? "" : "|"), first
= 0;
10285 if (mask
& OEX_FPU_INVAL
)
10286 printf ("%sINVAL", first
? "" : "|");
10289 fputs ("0", stdout
);
10292 /* ARM EABI attributes section. */
10297 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
10299 const char ** table
;
10300 } arm_attr_public_tag
;
10302 static const char * arm_attr_tag_CPU_arch
[] =
10303 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
10304 "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
10305 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
10306 static const char * arm_attr_tag_THUMB_ISA_use
[] =
10307 {"No", "Thumb-1", "Thumb-2"};
10308 static const char * arm_attr_tag_FP_arch
[] =
10309 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
10310 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
10311 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
10312 {"No", "NEONv1", "NEONv1 with Fused-MAC"};
10313 static const char * arm_attr_tag_PCS_config
[] =
10314 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
10315 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
10316 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
10317 {"V6", "SB", "TLS", "Unused"};
10318 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
10319 {"Absolute", "PC-relative", "SB-relative", "None"};
10320 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
10321 {"Absolute", "PC-relative", "None"};
10322 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
10323 {"None", "direct", "GOT-indirect"};
10324 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
10325 {"None", "??? 1", "2", "??? 3", "4"};
10326 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
10327 static const char * arm_attr_tag_ABI_FP_denormal
[] =
10328 {"Unused", "Needed", "Sign only"};
10329 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
10330 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
10331 static const char * arm_attr_tag_ABI_FP_number_model
[] =
10332 {"Unused", "Finite", "RTABI", "IEEE 754"};
10333 static const char * arm_attr_tag_ABI_enum_size
[] =
10334 {"Unused", "small", "int", "forced to int"};
10335 static const char * arm_attr_tag_ABI_HardFP_use
[] =
10336 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
10337 static const char * arm_attr_tag_ABI_VFP_args
[] =
10338 {"AAPCS", "VFP registers", "custom"};
10339 static const char * arm_attr_tag_ABI_WMMX_args
[] =
10340 {"AAPCS", "WMMX registers", "custom"};
10341 static const char * arm_attr_tag_ABI_optimization_goals
[] =
10342 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10343 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
10344 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
10345 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10346 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
10347 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
10348 static const char * arm_attr_tag_FP_HP_extension
[] =
10349 {"Not Allowed", "Allowed"};
10350 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
10351 {"None", "IEEE 754", "Alternative Format"};
10352 static const char * arm_attr_tag_MPextension_use
[] =
10353 {"Not Allowed", "Allowed"};
10354 static const char * arm_attr_tag_DIV_use
[] =
10355 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
10356 "Allowed in v7-A with integer division extension"};
10357 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
10358 static const char * arm_attr_tag_Virtualization_use
[] =
10359 {"Not Allowed", "TrustZone", "Virtualization Extensions",
10360 "TrustZone and Virtualization Extensions"};
10361 static const char * arm_attr_tag_MPextension_use_legacy
[] =
10362 {"Not Allowed", "Allowed"};
10364 #define LOOKUP(id, name) \
10365 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
10366 static arm_attr_public_tag arm_attr_public_tags
[] =
10368 {4, "CPU_raw_name", 1, NULL
},
10369 {5, "CPU_name", 1, NULL
},
10370 LOOKUP(6, CPU_arch
),
10371 {7, "CPU_arch_profile", 0, NULL
},
10372 LOOKUP(8, ARM_ISA_use
),
10373 LOOKUP(9, THUMB_ISA_use
),
10374 LOOKUP(10, FP_arch
),
10375 LOOKUP(11, WMMX_arch
),
10376 LOOKUP(12, Advanced_SIMD_arch
),
10377 LOOKUP(13, PCS_config
),
10378 LOOKUP(14, ABI_PCS_R9_use
),
10379 LOOKUP(15, ABI_PCS_RW_data
),
10380 LOOKUP(16, ABI_PCS_RO_data
),
10381 LOOKUP(17, ABI_PCS_GOT_use
),
10382 LOOKUP(18, ABI_PCS_wchar_t
),
10383 LOOKUP(19, ABI_FP_rounding
),
10384 LOOKUP(20, ABI_FP_denormal
),
10385 LOOKUP(21, ABI_FP_exceptions
),
10386 LOOKUP(22, ABI_FP_user_exceptions
),
10387 LOOKUP(23, ABI_FP_number_model
),
10388 {24, "ABI_align_needed", 0, NULL
},
10389 {25, "ABI_align_preserved", 0, NULL
},
10390 LOOKUP(26, ABI_enum_size
),
10391 LOOKUP(27, ABI_HardFP_use
),
10392 LOOKUP(28, ABI_VFP_args
),
10393 LOOKUP(29, ABI_WMMX_args
),
10394 LOOKUP(30, ABI_optimization_goals
),
10395 LOOKUP(31, ABI_FP_optimization_goals
),
10396 {32, "compatibility", 0, NULL
},
10397 LOOKUP(34, CPU_unaligned_access
),
10398 LOOKUP(36, FP_HP_extension
),
10399 LOOKUP(38, ABI_FP_16bit_format
),
10400 LOOKUP(42, MPextension_use
),
10401 LOOKUP(44, DIV_use
),
10402 {64, "nodefaults", 0, NULL
},
10403 {65, "also_compatible_with", 0, NULL
},
10404 LOOKUP(66, T2EE_use
),
10405 {67, "conformance", 1, NULL
},
10406 LOOKUP(68, Virtualization_use
),
10407 LOOKUP(70, MPextension_use_legacy
)
10411 static unsigned char *
10412 display_arm_attribute (unsigned char * p
)
10417 arm_attr_public_tag
* attr
;
10421 tag
= read_uleb128 (p
, &len
);
10424 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
10426 if (arm_attr_public_tags
[i
].tag
== tag
)
10428 attr
= &arm_attr_public_tags
[i
];
10435 printf (" Tag_%s: ", attr
->name
);
10436 switch (attr
->type
)
10441 case 7: /* Tag_CPU_arch_profile. */
10442 val
= read_uleb128 (p
, &len
);
10446 case 0: printf (_("None\n")); break;
10447 case 'A': printf (_("Application\n")); break;
10448 case 'R': printf (_("Realtime\n")); break;
10449 case 'M': printf (_("Microcontroller\n")); break;
10450 case 'S': printf (_("Application or Realtime\n")); break;
10451 default: printf ("??? (%d)\n", val
); break;
10455 case 24: /* Tag_align_needed. */
10456 val
= read_uleb128 (p
, &len
);
10460 case 0: printf (_("None\n")); break;
10461 case 1: printf (_("8-byte\n")); break;
10462 case 2: printf (_("4-byte\n")); break;
10463 case 3: printf ("??? 3\n"); break;
10466 printf (_("8-byte and up to %d-byte extended\n"),
10469 printf ("??? (%d)\n", val
);
10474 case 25: /* Tag_align_preserved. */
10475 val
= read_uleb128 (p
, &len
);
10479 case 0: printf (_("None\n")); break;
10480 case 1: printf (_("8-byte, except leaf SP\n")); break;
10481 case 2: printf (_("8-byte\n")); break;
10482 case 3: printf ("??? 3\n"); break;
10485 printf (_("8-byte and up to %d-byte extended\n"),
10488 printf ("??? (%d)\n", val
);
10493 case 32: /* Tag_compatibility. */
10494 val
= read_uleb128 (p
, &len
);
10496 printf (_("flag = %d, vendor = %s\n"), val
, p
);
10497 p
+= strlen ((char *) p
) + 1;
10500 case 64: /* Tag_nodefaults. */
10502 printf (_("True\n"));
10505 case 65: /* Tag_also_compatible_with. */
10506 val
= read_uleb128 (p
, &len
);
10508 if (val
== 6 /* Tag_CPU_arch. */)
10510 val
= read_uleb128 (p
, &len
);
10512 if ((unsigned int)val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
10513 printf ("??? (%d)\n", val
);
10515 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
10519 while (*(p
++) != '\0' /* NUL terminator. */);
10533 assert (attr
->type
& 0x80);
10534 val
= read_uleb128 (p
, &len
);
10536 type
= attr
->type
& 0x7f;
10538 printf ("??? (%d)\n", val
);
10540 printf ("%s\n", attr
->table
[val
]);
10547 type
= 1; /* String. */
10549 type
= 2; /* uleb128. */
10550 printf (" Tag_unknown_%d: ", tag
);
10555 printf ("\"%s\"\n", p
);
10556 p
+= strlen ((char *) p
) + 1;
10560 val
= read_uleb128 (p
, &len
);
10562 printf ("%d (0x%x)\n", val
, val
);
10568 static unsigned char *
10569 display_gnu_attribute (unsigned char * p
,
10570 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
10577 tag
= read_uleb128 (p
, &len
);
10580 /* Tag_compatibility is the only generic GNU attribute defined at
10584 val
= read_uleb128 (p
, &len
);
10586 printf (_("flag = %d, vendor = %s\n"), val
, p
);
10587 p
+= strlen ((char *) p
) + 1;
10591 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
10592 return display_proc_gnu_attribute (p
, tag
);
10595 type
= 1; /* String. */
10597 type
= 2; /* uleb128. */
10598 printf (" Tag_unknown_%d: ", tag
);
10602 printf ("\"%s\"\n", p
);
10603 p
+= strlen ((char *) p
) + 1;
10607 val
= read_uleb128 (p
, &len
);
10609 printf ("%d (0x%x)\n", val
, val
);
10615 static unsigned char *
10616 display_power_gnu_attribute (unsigned char * p
, int tag
)
10622 if (tag
== Tag_GNU_Power_ABI_FP
)
10624 val
= read_uleb128 (p
, &len
);
10626 printf (" Tag_GNU_Power_ABI_FP: ");
10631 printf (_("Hard or soft float\n"));
10634 printf (_("Hard float\n"));
10637 printf (_("Soft float\n"));
10640 printf (_("Single-precision hard float\n"));
10643 printf ("??? (%d)\n", val
);
10649 if (tag
== Tag_GNU_Power_ABI_Vector
)
10651 val
= read_uleb128 (p
, &len
);
10653 printf (" Tag_GNU_Power_ABI_Vector: ");
10657 printf (_("Any\n"));
10660 printf (_("Generic\n"));
10663 printf ("AltiVec\n");
10669 printf ("??? (%d)\n", val
);
10675 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
10677 val
= read_uleb128 (p
, &len
);
10679 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
10683 printf (_("Any\n"));
10686 printf ("r3/r4\n");
10689 printf (_("Memory\n"));
10692 printf ("??? (%d)\n", val
);
10699 type
= 1; /* String. */
10701 type
= 2; /* uleb128. */
10702 printf (" Tag_unknown_%d: ", tag
);
10706 printf ("\"%s\"\n", p
);
10707 p
+= strlen ((char *) p
) + 1;
10711 val
= read_uleb128 (p
, &len
);
10713 printf ("%d (0x%x)\n", val
, val
);
10719 static unsigned char *
10720 display_mips_gnu_attribute (unsigned char * p
, int tag
)
10726 if (tag
== Tag_GNU_MIPS_ABI_FP
)
10728 val
= read_uleb128 (p
, &len
);
10730 printf (" Tag_GNU_MIPS_ABI_FP: ");
10735 printf (_("Hard or soft float\n"));
10738 printf (_("Hard float (double precision)\n"));
10741 printf (_("Hard float (single precision)\n"));
10744 printf (_("Soft float\n"));
10747 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
10750 printf ("??? (%d)\n", val
);
10757 type
= 1; /* String. */
10759 type
= 2; /* uleb128. */
10760 printf (" Tag_unknown_%d: ", tag
);
10764 printf ("\"%s\"\n", p
);
10765 p
+= strlen ((char *) p
) + 1;
10769 val
= read_uleb128 (p
, &len
);
10771 printf ("%d (0x%x)\n", val
, val
);
10777 static unsigned char *
10778 display_tic6x_attribute (unsigned char * p
)
10784 tag
= read_uleb128 (p
, &len
);
10790 val
= read_uleb128 (p
, &len
);
10792 printf (" Tag_ISA: ");
10796 case C6XABI_Tag_ISA_none
:
10797 printf (_("None\n"));
10799 case C6XABI_Tag_ISA_C62X
:
10802 case C6XABI_Tag_ISA_C67X
:
10805 case C6XABI_Tag_ISA_C67XP
:
10806 printf ("C67x+\n");
10808 case C6XABI_Tag_ISA_C64X
:
10811 case C6XABI_Tag_ISA_C64XP
:
10812 printf ("C64x+\n");
10814 case C6XABI_Tag_ISA_C674X
:
10815 printf ("C674x\n");
10818 printf ("??? (%d)\n", val
);
10823 case Tag_ABI_wchar_t
:
10824 val
= read_uleb128 (p
, &len
);
10826 printf (" Tag_ABI_wchar_t: ");
10830 printf (_("Not used\n"));
10833 printf (_("2 bytes\n"));
10836 printf (_("4 bytes\n"));
10839 printf ("??? (%d)\n", val
);
10844 case Tag_ABI_stack_align_needed
:
10845 val
= read_uleb128 (p
, &len
);
10847 printf (" Tag_ABI_stack_align_needed: ");
10851 printf (_("8-byte\n"));
10854 printf (_("16-byte\n"));
10857 printf ("??? (%d)\n", val
);
10862 case Tag_ABI_stack_align_preserved
:
10863 val
= read_uleb128 (p
, &len
);
10865 printf (" Tag_ABI_stack_align_preserved: ");
10869 printf (_("8-byte\n"));
10872 printf (_("16-byte\n"));
10875 printf ("??? (%d)\n", val
);
10881 val
= read_uleb128 (p
, &len
);
10883 printf (" Tag_ABI_DSBT: ");
10887 printf (_("DSBT addressing not used\n"));
10890 printf (_("DSBT addressing used\n"));
10893 printf ("??? (%d)\n", val
);
10899 val
= read_uleb128 (p
, &len
);
10901 printf (" Tag_ABI_PID: ");
10905 printf (_("Data addressing position-dependent\n"));
10908 printf (_("Data addressing position-independent, GOT near DP\n"));
10911 printf (_("Data addressing position-independent, GOT far from DP\n"));
10914 printf ("??? (%d)\n", val
);
10920 val
= read_uleb128 (p
, &len
);
10922 printf (" Tag_ABI_PIC: ");
10926 printf (_("Code addressing position-dependent\n"));
10929 printf (_("Code addressing position-independent\n"));
10932 printf ("??? (%d)\n", val
);
10937 case Tag_ABI_array_object_alignment
:
10938 val
= read_uleb128 (p
, &len
);
10940 printf (" Tag_ABI_array_object_alignment: ");
10944 printf (_("8-byte\n"));
10947 printf (_("4-byte\n"));
10950 printf (_("16-byte\n"));
10953 printf ("??? (%d)\n", val
);
10958 case Tag_ABI_array_object_align_expected
:
10959 val
= read_uleb128 (p
, &len
);
10961 printf (" Tag_ABI_array_object_align_expected: ");
10965 printf (_("8-byte\n"));
10968 printf (_("4-byte\n"));
10971 printf (_("16-byte\n"));
10974 printf ("??? (%d)\n", val
);
10979 case Tag_ABI_compatibility
:
10980 val
= read_uleb128 (p
, &len
);
10982 printf (" Tag_ABI_compatibility: ");
10983 printf (_("flag = %d, vendor = %s\n"), val
, p
);
10984 p
+= strlen ((char *) p
) + 1;
10987 case Tag_ABI_conformance
:
10988 printf (" Tag_ABI_conformance: ");
10989 printf ("\"%s\"\n", p
);
10990 p
+= strlen ((char *) p
) + 1;
10994 printf (" Tag_unknown_%d: ", tag
);
10998 printf ("\"%s\"\n", p
);
10999 p
+= strlen ((char *) p
) + 1;
11003 val
= read_uleb128 (p
, &len
);
11005 printf ("%d (0x%x)\n", val
, val
);
11012 process_attributes (FILE * file
,
11013 const char * public_name
,
11014 unsigned int proc_type
,
11015 unsigned char * (* display_pub_attribute
) (unsigned char *),
11016 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
11018 Elf_Internal_Shdr
* sect
;
11019 unsigned char * contents
;
11021 unsigned char * end
;
11022 bfd_vma section_len
;
11026 /* Find the section header so that we get the size. */
11027 for (i
= 0, sect
= section_headers
;
11028 i
< elf_header
.e_shnum
;
11031 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
11034 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
11035 sect
->sh_size
, _("attributes"));
11036 if (contents
== NULL
)
11042 len
= sect
->sh_size
- 1;
11048 bfd_boolean public_section
;
11049 bfd_boolean gnu_section
;
11051 section_len
= byte_get (p
, 4);
11054 if (section_len
> len
)
11056 printf (_("ERROR: Bad section length (%d > %d)\n"),
11057 (int) section_len
, (int) len
);
11061 len
-= section_len
;
11062 printf (_("Attribute Section: %s\n"), p
);
11064 if (public_name
&& streq ((char *) p
, public_name
))
11065 public_section
= TRUE
;
11067 public_section
= FALSE
;
11069 if (streq ((char *) p
, "gnu"))
11070 gnu_section
= TRUE
;
11072 gnu_section
= FALSE
;
11074 namelen
= strlen ((char *) p
) + 1;
11076 section_len
-= namelen
+ 4;
11078 while (section_len
> 0)
11084 size
= byte_get (p
, 4);
11085 if (size
> section_len
)
11087 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
11088 (int) size
, (int) section_len
);
11089 size
= section_len
;
11092 section_len
-= size
;
11093 end
= p
+ size
- 1;
11099 printf (_("File Attributes\n"));
11102 printf (_("Section Attributes:"));
11105 printf (_("Symbol Attributes:"));
11111 val
= read_uleb128 (p
, &j
);
11115 printf (" %d", val
);
11120 printf (_("Unknown tag: %d\n"), tag
);
11121 public_section
= FALSE
;
11125 if (public_section
)
11128 p
= display_pub_attribute (p
);
11130 else if (gnu_section
)
11133 p
= display_gnu_attribute (p
,
11134 display_proc_gnu_attribute
);
11138 /* ??? Do something sensible, like dump hex. */
11139 printf (_(" Unknown section contexts\n"));
11146 printf (_("Unknown format '%c'\n"), *p
);
11154 process_arm_specific (FILE * file
)
11156 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
11157 display_arm_attribute
, NULL
);
11161 process_power_specific (FILE * file
)
11163 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
11164 display_power_gnu_attribute
);
11168 process_tic6x_specific (FILE * file
)
11170 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
11171 display_tic6x_attribute
, NULL
);
11174 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
11175 Print the Address, Access and Initial fields of an entry at VMA ADDR
11176 and return the VMA of the next entry. */
11179 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
11182 print_vma (addr
, LONG_HEX
);
11184 if (addr
< pltgot
+ 0xfff0)
11185 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
11187 printf ("%10s", "");
11190 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
11195 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
11196 print_vma (entry
, LONG_HEX
);
11198 return addr
+ (is_32bit_elf
? 4 : 8);
11201 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
11202 PLTGOT. Print the Address and Initial fields of an entry at VMA
11203 ADDR and return the VMA of the next entry. */
11206 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
11209 print_vma (addr
, LONG_HEX
);
11212 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
11217 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
11218 print_vma (entry
, LONG_HEX
);
11220 return addr
+ (is_32bit_elf
? 4 : 8);
11224 process_mips_specific (FILE * file
)
11226 Elf_Internal_Dyn
* entry
;
11227 size_t liblist_offset
= 0;
11228 size_t liblistno
= 0;
11229 size_t conflictsno
= 0;
11230 size_t options_offset
= 0;
11231 size_t conflicts_offset
= 0;
11232 size_t pltrelsz
= 0;
11234 bfd_vma pltgot
= 0;
11235 bfd_vma mips_pltgot
= 0;
11236 bfd_vma jmprel
= 0;
11237 bfd_vma local_gotno
= 0;
11238 bfd_vma gotsym
= 0;
11239 bfd_vma symtabno
= 0;
11241 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
11242 display_mips_gnu_attribute
);
11244 /* We have a lot of special sections. Thanks SGI! */
11245 if (dynamic_section
== NULL
)
11246 /* No information available. */
11249 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
11250 switch (entry
->d_tag
)
11252 case DT_MIPS_LIBLIST
:
11254 = offset_from_vma (file
, entry
->d_un
.d_val
,
11255 liblistno
* sizeof (Elf32_External_Lib
));
11257 case DT_MIPS_LIBLISTNO
:
11258 liblistno
= entry
->d_un
.d_val
;
11260 case DT_MIPS_OPTIONS
:
11261 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
11263 case DT_MIPS_CONFLICT
:
11265 = offset_from_vma (file
, entry
->d_un
.d_val
,
11266 conflictsno
* sizeof (Elf32_External_Conflict
));
11268 case DT_MIPS_CONFLICTNO
:
11269 conflictsno
= entry
->d_un
.d_val
;
11272 pltgot
= entry
->d_un
.d_ptr
;
11274 case DT_MIPS_LOCAL_GOTNO
:
11275 local_gotno
= entry
->d_un
.d_val
;
11277 case DT_MIPS_GOTSYM
:
11278 gotsym
= entry
->d_un
.d_val
;
11280 case DT_MIPS_SYMTABNO
:
11281 symtabno
= entry
->d_un
.d_val
;
11283 case DT_MIPS_PLTGOT
:
11284 mips_pltgot
= entry
->d_un
.d_ptr
;
11287 pltrel
= entry
->d_un
.d_val
;
11290 pltrelsz
= entry
->d_un
.d_val
;
11293 jmprel
= entry
->d_un
.d_ptr
;
11299 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
11301 Elf32_External_Lib
* elib
;
11304 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
11306 sizeof (Elf32_External_Lib
),
11310 printf (_("\nSection '.liblist' contains %lu entries:\n"),
11311 (unsigned long) liblistno
);
11312 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
11315 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
11322 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11323 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11324 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11325 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11326 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11328 tmp
= gmtime (&atime
);
11329 snprintf (timebuf
, sizeof (timebuf
),
11330 "%04u-%02u-%02uT%02u:%02u:%02u",
11331 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11332 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11334 printf ("%3lu: ", (unsigned long) cnt
);
11335 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
11336 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
11338 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
11339 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
11340 liblist
.l_version
);
11342 if (liblist
.l_flags
== 0)
11346 static const struct
11353 { " EXACT_MATCH", LL_EXACT_MATCH
},
11354 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
11355 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
11356 { " EXPORTS", LL_EXPORTS
},
11357 { " DELAY_LOAD", LL_DELAY_LOAD
},
11358 { " DELTA", LL_DELTA
}
11360 int flags
= liblist
.l_flags
;
11363 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
11364 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
11366 fputs (l_flags_vals
[fcnt
].name
, stdout
);
11367 flags
^= l_flags_vals
[fcnt
].bit
;
11370 printf (" %#x", (unsigned int) flags
);
11380 if (options_offset
!= 0)
11382 Elf_External_Options
* eopt
;
11383 Elf_Internal_Shdr
* sect
= section_headers
;
11384 Elf_Internal_Options
* iopt
;
11385 Elf_Internal_Options
* option
;
11389 /* Find the section header so that we get the size. */
11390 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
11393 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
11394 sect
->sh_size
, _("options"));
11397 iopt
= (Elf_Internal_Options
*)
11398 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
11401 error (_("Out of memory\n"));
11408 while (offset
< sect
->sh_size
)
11410 Elf_External_Options
* eoption
;
11412 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
11414 option
->kind
= BYTE_GET (eoption
->kind
);
11415 option
->size
= BYTE_GET (eoption
->size
);
11416 option
->section
= BYTE_GET (eoption
->section
);
11417 option
->info
= BYTE_GET (eoption
->info
);
11419 offset
+= option
->size
;
11425 printf (_("\nSection '%s' contains %d entries:\n"),
11426 SECTION_NAME (sect
), cnt
);
11434 switch (option
->kind
)
11437 /* This shouldn't happen. */
11438 printf (" NULL %d %lx", option
->section
, option
->info
);
11441 printf (" REGINFO ");
11442 if (elf_header
.e_machine
== EM_MIPS
)
11445 Elf32_External_RegInfo
* ereg
;
11446 Elf32_RegInfo reginfo
;
11448 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
11449 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11450 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11451 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11452 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11453 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11454 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11456 printf ("GPR %08lx GP 0x%lx\n",
11457 reginfo
.ri_gprmask
,
11458 (unsigned long) reginfo
.ri_gp_value
);
11459 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11460 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11461 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11466 Elf64_External_RegInfo
* ereg
;
11467 Elf64_Internal_RegInfo reginfo
;
11469 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
11470 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11471 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11472 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11473 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11474 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11475 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11477 printf ("GPR %08lx GP 0x",
11478 reginfo
.ri_gprmask
);
11479 printf_vma (reginfo
.ri_gp_value
);
11482 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11483 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11484 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11488 case ODK_EXCEPTIONS
:
11489 fputs (" EXCEPTIONS fpe_min(", stdout
);
11490 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
11491 fputs (") fpe_max(", stdout
);
11492 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
11493 fputs (")", stdout
);
11495 if (option
->info
& OEX_PAGE0
)
11496 fputs (" PAGE0", stdout
);
11497 if (option
->info
& OEX_SMM
)
11498 fputs (" SMM", stdout
);
11499 if (option
->info
& OEX_FPDBUG
)
11500 fputs (" FPDBUG", stdout
);
11501 if (option
->info
& OEX_DISMISS
)
11502 fputs (" DISMISS", stdout
);
11505 fputs (" PAD ", stdout
);
11506 if (option
->info
& OPAD_PREFIX
)
11507 fputs (" PREFIX", stdout
);
11508 if (option
->info
& OPAD_POSTFIX
)
11509 fputs (" POSTFIX", stdout
);
11510 if (option
->info
& OPAD_SYMBOL
)
11511 fputs (" SYMBOL", stdout
);
11514 fputs (" HWPATCH ", stdout
);
11515 if (option
->info
& OHW_R4KEOP
)
11516 fputs (" R4KEOP", stdout
);
11517 if (option
->info
& OHW_R8KPFETCH
)
11518 fputs (" R8KPFETCH", stdout
);
11519 if (option
->info
& OHW_R5KEOP
)
11520 fputs (" R5KEOP", stdout
);
11521 if (option
->info
& OHW_R5KCVTL
)
11522 fputs (" R5KCVTL", stdout
);
11525 fputs (" FILL ", stdout
);
11526 /* XXX Print content of info word? */
11529 fputs (" TAGS ", stdout
);
11530 /* XXX Print content of info word? */
11533 fputs (" HWAND ", stdout
);
11534 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11535 fputs (" R4KEOP_CHECKED", stdout
);
11536 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11537 fputs (" R4KEOP_CLEAN", stdout
);
11540 fputs (" HWOR ", stdout
);
11541 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11542 fputs (" R4KEOP_CHECKED", stdout
);
11543 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11544 fputs (" R4KEOP_CLEAN", stdout
);
11547 printf (" GP_GROUP %#06lx self-contained %#06lx",
11548 option
->info
& OGP_GROUP
,
11549 (option
->info
& OGP_SELF
) >> 16);
11552 printf (" IDENT %#06lx self-contained %#06lx",
11553 option
->info
& OGP_GROUP
,
11554 (option
->info
& OGP_SELF
) >> 16);
11557 /* This shouldn't happen. */
11558 printf (" %3d ??? %d %lx",
11559 option
->kind
, option
->section
, option
->info
);
11563 len
= sizeof (* eopt
);
11564 while (len
< option
->size
)
11565 if (((char *) option
)[len
] >= ' '
11566 && ((char *) option
)[len
] < 0x7f)
11567 printf ("%c", ((char *) option
)[len
++]);
11569 printf ("\\%03o", ((char *) option
)[len
++]);
11571 fputs ("\n", stdout
);
11579 if (conflicts_offset
!= 0 && conflictsno
!= 0)
11581 Elf32_Conflict
* iconf
;
11584 if (dynamic_symbols
== NULL
)
11586 error (_("conflict list found without a dynamic symbol table\n"));
11590 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
11593 error (_("Out of memory\n"));
11599 Elf32_External_Conflict
* econf32
;
11601 econf32
= (Elf32_External_Conflict
*)
11602 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
11603 sizeof (* econf32
), _("conflict"));
11607 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11608 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
11614 Elf64_External_Conflict
* econf64
;
11616 econf64
= (Elf64_External_Conflict
*)
11617 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
11618 sizeof (* econf64
), _("conflict"));
11622 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11623 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
11628 printf (_("\nSection '.conflict' contains %lu entries:\n"),
11629 (unsigned long) conflictsno
);
11630 puts (_(" Num: Index Value Name"));
11632 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11634 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
11636 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
11637 print_vma (psym
->st_value
, FULL_HEX
);
11639 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11640 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11642 printf (_("<corrupt: %14ld>"), psym
->st_name
);
11649 if (pltgot
!= 0 && local_gotno
!= 0)
11651 bfd_vma ent
, local_end
, global_end
;
11653 unsigned char * data
;
11657 addr_size
= (is_32bit_elf
? 4 : 8);
11658 local_end
= pltgot
+ local_gotno
* addr_size
;
11659 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
11661 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
11662 data
= (unsigned char *) get_data (NULL
, file
, offset
,
11663 global_end
- pltgot
, 1, _("GOT"));
11664 printf (_("\nPrimary GOT:\n"));
11665 printf (_(" Canonical gp value: "));
11666 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
11669 printf (_(" Reserved entries:\n"));
11670 printf (_(" %*s %10s %*s Purpose\n"),
11671 addr_size
* 2, _("Address"), _("Access"),
11672 addr_size
* 2, _("Initial"));
11673 ent
= print_mips_got_entry (data
, pltgot
, ent
);
11674 printf (_(" Lazy resolver\n"));
11676 && (byte_get (data
+ ent
- pltgot
, addr_size
)
11677 >> (addr_size
* 8 - 1)) != 0)
11679 ent
= print_mips_got_entry (data
, pltgot
, ent
);
11680 printf (_(" Module pointer (GNU extension)\n"));
11684 if (ent
< local_end
)
11686 printf (_(" Local entries:\n"));
11687 printf (" %*s %10s %*s\n",
11688 addr_size
* 2, _("Address"), _("Access"),
11689 addr_size
* 2, _("Initial"));
11690 while (ent
< local_end
)
11692 ent
= print_mips_got_entry (data
, pltgot
, ent
);
11698 if (gotsym
< symtabno
)
11702 printf (_(" Global entries:\n"));
11703 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
11704 addr_size
* 2, _("Address"), _("Access"),
11705 addr_size
* 2, _("Initial"),
11706 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
11707 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
11708 for (i
= gotsym
; i
< symtabno
; i
++)
11710 Elf_Internal_Sym
* psym
;
11712 psym
= dynamic_symbols
+ i
;
11713 ent
= print_mips_got_entry (data
, pltgot
, ent
);
11715 print_vma (psym
->st_value
, LONG_HEX
);
11716 printf (" %-7s %3s ",
11717 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
11718 get_symbol_index_type (psym
->st_shndx
));
11719 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11720 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
11722 printf (_("<corrupt: %14ld>"), psym
->st_name
);
11732 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
11735 size_t offset
, rel_offset
;
11736 unsigned long count
, i
;
11737 unsigned char * data
;
11738 int addr_size
, sym_width
;
11739 Elf_Internal_Rela
* rels
;
11741 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
11742 if (pltrel
== DT_RELA
)
11744 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
11749 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
11754 addr_size
= (is_32bit_elf
? 4 : 8);
11755 end
= mips_pltgot
+ (2 + count
) * addr_size
;
11757 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
11758 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
11760 printf (_("\nPLT GOT:\n\n"));
11761 printf (_(" Reserved entries:\n"));
11762 printf (_(" %*s %*s Purpose\n"),
11763 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
11764 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
11765 printf (_(" PLT lazy resolver\n"));
11766 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
11767 printf (_(" Module pointer\n"));
11770 printf (_(" Entries:\n"));
11771 printf (" %*s %*s %*s %-7s %3s %s\n",
11772 addr_size
* 2, _("Address"),
11773 addr_size
* 2, _("Initial"),
11774 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
11775 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
11776 for (i
= 0; i
< count
; i
++)
11778 Elf_Internal_Sym
* psym
;
11780 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
11781 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
11783 print_vma (psym
->st_value
, LONG_HEX
);
11784 printf (" %-7s %3s ",
11785 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
11786 get_symbol_index_type (psym
->st_shndx
));
11787 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11788 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
11790 printf (_("<corrupt: %14ld>"), psym
->st_name
);
11804 process_gnu_liblist (FILE * file
)
11806 Elf_Internal_Shdr
* section
;
11807 Elf_Internal_Shdr
* string_sec
;
11808 Elf32_External_Lib
* elib
;
11810 size_t strtab_size
;
11817 for (i
= 0, section
= section_headers
;
11818 i
< elf_header
.e_shnum
;
11821 switch (section
->sh_type
)
11823 case SHT_GNU_LIBLIST
:
11824 if (section
->sh_link
>= elf_header
.e_shnum
)
11827 elib
= (Elf32_External_Lib
*)
11828 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
11833 string_sec
= section_headers
+ section
->sh_link
;
11835 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
11836 string_sec
->sh_size
,
11837 _("liblist string table"));
11838 strtab_size
= string_sec
->sh_size
;
11841 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
11847 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
11848 SECTION_NAME (section
),
11849 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
11851 puts (_(" Library Time Stamp Checksum Version Flags"));
11853 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
11861 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11862 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11863 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11864 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11865 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11867 tmp
= gmtime (&atime
);
11868 snprintf (timebuf
, sizeof (timebuf
),
11869 "%04u-%02u-%02uT%02u:%02u:%02u",
11870 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11871 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11873 printf ("%3lu: ", (unsigned long) cnt
);
11875 printf ("%-20s", liblist
.l_name
< strtab_size
11876 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
11878 printf ("%-20.20s", liblist
.l_name
< strtab_size
11879 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
11880 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
11881 liblist
.l_version
, liblist
.l_flags
);
11891 static const char *
11892 get_note_type (unsigned e_type
)
11894 static char buff
[64];
11896 if (elf_header
.e_type
== ET_CORE
)
11900 return _("NT_AUXV (auxiliary vector)");
11902 return _("NT_PRSTATUS (prstatus structure)");
11904 return _("NT_FPREGSET (floating point registers)");
11906 return _("NT_PRPSINFO (prpsinfo structure)");
11907 case NT_TASKSTRUCT
:
11908 return _("NT_TASKSTRUCT (task structure)");
11910 return _("NT_PRXFPREG (user_xfpregs structure)");
11912 return _("NT_PPC_VMX (ppc Altivec registers)");
11914 return _("NT_PPC_VSX (ppc VSX registers)");
11915 case NT_X86_XSTATE
:
11916 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
11917 case NT_S390_HIGH_GPRS
:
11918 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
11919 case NT_S390_TIMER
:
11920 return _("NT_S390_TIMER (s390 timer register)");
11921 case NT_S390_TODCMP
:
11922 return _("NT_S390_TODCMP (s390 TOD comparator register)");
11923 case NT_S390_TODPREG
:
11924 return _("NT_S390_TODPREG (s390 TOD programmable register)");
11926 return _("NT_S390_CTRS (s390 control registers)");
11927 case NT_S390_PREFIX
:
11928 return _("NT_S390_PREFIX (s390 prefix register)");
11930 return _("NT_PSTATUS (pstatus structure)");
11932 return _("NT_FPREGS (floating point registers)");
11934 return _("NT_PSINFO (psinfo structure)");
11936 return _("NT_LWPSTATUS (lwpstatus_t structure)");
11938 return _("NT_LWPSINFO (lwpsinfo_t structure)");
11939 case NT_WIN32PSTATUS
:
11940 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11948 return _("NT_VERSION (version)");
11950 return _("NT_ARCH (architecture)");
11955 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11959 static const char *
11960 get_gnu_elf_note_type (unsigned e_type
)
11962 static char buff
[64];
11966 case NT_GNU_ABI_TAG
:
11967 return _("NT_GNU_ABI_TAG (ABI version tag)");
11969 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
11970 case NT_GNU_BUILD_ID
:
11971 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
11972 case NT_GNU_GOLD_VERSION
:
11973 return _("NT_GNU_GOLD_VERSION (gold version)");
11978 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11982 static const char *
11983 get_netbsd_elfcore_note_type (unsigned e_type
)
11985 static char buff
[64];
11987 if (e_type
== NT_NETBSDCORE_PROCINFO
)
11989 /* NetBSD core "procinfo" structure. */
11990 return _("NetBSD procinfo structure");
11993 /* As of Jan 2002 there are no other machine-independent notes
11994 defined for NetBSD core files. If the note type is less
11995 than the start of the machine-dependent note types, we don't
11998 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
12000 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
12004 switch (elf_header
.e_machine
)
12006 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
12007 and PT_GETFPREGS == mach+2. */
12012 case EM_SPARC32PLUS
:
12016 case NT_NETBSDCORE_FIRSTMACH
+ 0:
12017 return _("PT_GETREGS (reg structure)");
12018 case NT_NETBSDCORE_FIRSTMACH
+ 2:
12019 return _("PT_GETFPREGS (fpreg structure)");
12025 /* On all other arch's, PT_GETREGS == mach+1 and
12026 PT_GETFPREGS == mach+3. */
12030 case NT_NETBSDCORE_FIRSTMACH
+ 1:
12031 return _("PT_GETREGS (reg structure)");
12032 case NT_NETBSDCORE_FIRSTMACH
+ 3:
12033 return _("PT_GETFPREGS (fpreg structure)");
12039 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
12040 e_type
- NT_NETBSDCORE_FIRSTMACH
);
12044 /* Note that by the ELF standard, the name field is already null byte
12045 terminated, and namesz includes the terminating null byte.
12046 I.E. the value of namesz for the name "FSF" is 4.
12048 If the value of namesz is zero, there is no name present. */
12050 process_note (Elf_Internal_Note
* pnote
)
12052 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
12055 if (pnote
->namesz
== 0)
12056 /* If there is no note name, then use the default set of
12057 note type strings. */
12058 nt
= get_note_type (pnote
->type
);
12060 else if (const_strneq (pnote
->namedata
, "GNU"))
12061 /* GNU-specific object file notes. */
12062 nt
= get_gnu_elf_note_type (pnote
->type
);
12064 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
12065 /* NetBSD-specific core file notes. */
12066 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
12068 else if (strneq (pnote
->namedata
, "SPU/", 4))
12070 /* SPU-specific core file notes. */
12071 nt
= pnote
->namedata
+ 4;
12076 /* Don't recognize this note name; just use the default set of
12077 note type strings. */
12078 nt
= get_note_type (pnote
->type
);
12080 printf (" %s\t\t0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
12086 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
12088 Elf_External_Note
* pnotes
;
12089 Elf_External_Note
* external
;
12095 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
12097 if (pnotes
== NULL
)
12102 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
12103 (unsigned long) offset
, (unsigned long) length
);
12104 printf (_(" Owner\t\tData size\tDescription\n"));
12106 while (external
< (Elf_External_Note
*) ((char *) pnotes
+ length
))
12108 Elf_External_Note
* next
;
12109 Elf_Internal_Note inote
;
12110 char * temp
= NULL
;
12112 inote
.type
= BYTE_GET (external
->type
);
12113 inote
.namesz
= BYTE_GET (external
->namesz
);
12114 inote
.namedata
= external
->name
;
12115 inote
.descsz
= BYTE_GET (external
->descsz
);
12116 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
12117 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
12119 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
12121 if ( ((char *) next
> ((char *) pnotes
) + length
)
12122 || ((char *) next
< (char *) pnotes
))
12124 warn (_("corrupt note found at offset %lx into core notes\n"),
12125 (unsigned long) ((char *) external
- (char *) pnotes
));
12126 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
12127 inote
.type
, inote
.namesz
, inote
.descsz
);
12133 /* Prevent out-of-bounds indexing. */
12134 if (inote
.namedata
+ inote
.namesz
>= (char *) pnotes
+ length
12135 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
12137 warn (_("corrupt note found at offset %lx into core notes\n"),
12138 (unsigned long) ((char *) external
- (char *) pnotes
));
12139 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
12140 inote
.type
, inote
.namesz
, inote
.descsz
);
12144 /* Verify that name is null terminated. It appears that at least
12145 one version of Linux (RedHat 6.0) generates corefiles that don't
12146 comply with the ELF spec by failing to include the null byte in
12148 if (inote
.namedata
[inote
.namesz
] != '\0')
12150 temp
= (char *) malloc (inote
.namesz
+ 1);
12154 error (_("Out of memory\n"));
12159 strncpy (temp
, inote
.namedata
, inote
.namesz
);
12160 temp
[inote
.namesz
] = 0;
12162 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
12163 inote
.namedata
= temp
;
12166 res
&= process_note (& inote
);
12181 process_corefile_note_segments (FILE * file
)
12183 Elf_Internal_Phdr
* segment
;
12187 if (! get_program_headers (file
))
12190 for (i
= 0, segment
= program_headers
;
12191 i
< elf_header
.e_phnum
;
12194 if (segment
->p_type
== PT_NOTE
)
12195 res
&= process_corefile_note_segment (file
,
12196 (bfd_vma
) segment
->p_offset
,
12197 (bfd_vma
) segment
->p_filesz
);
12204 process_note_sections (FILE * file
)
12206 Elf_Internal_Shdr
* section
;
12210 for (i
= 0, section
= section_headers
;
12211 i
< elf_header
.e_shnum
;
12213 if (section
->sh_type
== SHT_NOTE
)
12214 res
&= process_corefile_note_segment (file
,
12215 (bfd_vma
) section
->sh_offset
,
12216 (bfd_vma
) section
->sh_size
);
12222 process_notes (FILE * file
)
12224 /* If we have not been asked to display the notes then do nothing. */
12228 if (elf_header
.e_type
!= ET_CORE
)
12229 return process_note_sections (file
);
12231 /* No program headers means no NOTE segment. */
12232 if (elf_header
.e_phnum
> 0)
12233 return process_corefile_note_segments (file
);
12235 printf (_("No note segments present in the core file.\n"));
12240 process_arch_specific (FILE * file
)
12245 switch (elf_header
.e_machine
)
12248 return process_arm_specific (file
);
12250 case EM_MIPS_RS3_LE
:
12251 return process_mips_specific (file
);
12254 return process_power_specific (file
);
12257 return process_tic6x_specific (file
);
12266 get_file_header (FILE * file
)
12268 /* Read in the identity array. */
12269 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
12272 /* Determine how to read the rest of the header. */
12273 switch (elf_header
.e_ident
[EI_DATA
])
12275 default: /* fall through */
12276 case ELFDATANONE
: /* fall through */
12278 byte_get
= byte_get_little_endian
;
12279 byte_put
= byte_put_little_endian
;
12282 byte_get
= byte_get_big_endian
;
12283 byte_put
= byte_put_big_endian
;
12287 /* For now we only support 32 bit and 64 bit ELF files. */
12288 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
12290 /* Read in the rest of the header. */
12293 Elf32_External_Ehdr ehdr32
;
12295 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
12298 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
12299 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
12300 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
12301 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
12302 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
12303 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
12304 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
12305 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
12306 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
12307 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
12308 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
12309 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
12310 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
12314 Elf64_External_Ehdr ehdr64
;
12316 /* If we have been compiled with sizeof (bfd_vma) == 4, then
12317 we will not be able to cope with the 64bit data found in
12318 64 ELF files. Detect this now and abort before we start
12319 overwriting things. */
12320 if (sizeof (bfd_vma
) < 8)
12322 error (_("This instance of readelf has been built without support for a\n\
12323 64 bit data type and so it cannot read 64 bit ELF files.\n"));
12327 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
12330 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
12331 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
12332 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
12333 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
12334 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
12335 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
12336 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
12337 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
12338 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
12339 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
12340 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
12341 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
12342 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
12345 if (elf_header
.e_shoff
)
12347 /* There may be some extensions in the first section header. Don't
12348 bomb if we can't read it. */
12350 get_32bit_section_headers (file
, 1);
12352 get_64bit_section_headers (file
, 1);
12358 /* Process one ELF object file according to the command line options.
12359 This file may actually be stored in an archive. The file is
12360 positioned at the start of the ELF object. */
12363 process_object (char * file_name
, FILE * file
)
12367 if (! get_file_header (file
))
12369 error (_("%s: Failed to read file header\n"), file_name
);
12373 /* Initialise per file variables. */
12374 for (i
= ARRAY_SIZE (version_info
); i
--;)
12375 version_info
[i
] = 0;
12377 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
12378 dynamic_info
[i
] = 0;
12380 /* Process the file. */
12382 printf (_("\nFile: %s\n"), file_name
);
12384 /* Initialise the dump_sects array from the cmdline_dump_sects array.
12385 Note we do this even if cmdline_dump_sects is empty because we
12386 must make sure that the dump_sets array is zeroed out before each
12387 object file is processed. */
12388 if (num_dump_sects
> num_cmdline_dump_sects
)
12389 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
12391 if (num_cmdline_dump_sects
> 0)
12393 if (num_dump_sects
== 0)
12394 /* A sneaky way of allocating the dump_sects array. */
12395 request_dump_bynumber (num_cmdline_dump_sects
, 0);
12397 assert (num_dump_sects
>= num_cmdline_dump_sects
);
12398 memcpy (dump_sects
, cmdline_dump_sects
,
12399 num_cmdline_dump_sects
* sizeof (* dump_sects
));
12402 if (! process_file_header ())
12405 if (! process_section_headers (file
))
12407 /* Without loaded section headers we cannot process lots of
12409 do_unwind
= do_version
= do_dump
= do_arch
= 0;
12411 if (! do_using_dynamic
)
12412 do_syms
= do_dyn_syms
= do_reloc
= 0;
12415 if (! process_section_groups (file
))
12417 /* Without loaded section groups we cannot process unwind. */
12421 if (process_program_headers (file
))
12422 process_dynamic_section (file
);
12424 process_relocs (file
);
12426 process_unwind (file
);
12428 process_symbol_table (file
);
12430 process_syminfo (file
);
12432 process_version_sections (file
);
12434 process_section_contents (file
);
12436 process_notes (file
);
12438 process_gnu_liblist (file
);
12440 process_arch_specific (file
);
12442 if (program_headers
)
12444 free (program_headers
);
12445 program_headers
= NULL
;
12448 if (section_headers
)
12450 free (section_headers
);
12451 section_headers
= NULL
;
12456 free (string_table
);
12457 string_table
= NULL
;
12458 string_table_length
= 0;
12461 if (dynamic_strings
)
12463 free (dynamic_strings
);
12464 dynamic_strings
= NULL
;
12465 dynamic_strings_length
= 0;
12468 if (dynamic_symbols
)
12470 free (dynamic_symbols
);
12471 dynamic_symbols
= NULL
;
12472 num_dynamic_syms
= 0;
12475 if (dynamic_syminfo
)
12477 free (dynamic_syminfo
);
12478 dynamic_syminfo
= NULL
;
12481 if (section_headers_groups
)
12483 free (section_headers_groups
);
12484 section_headers_groups
= NULL
;
12487 if (section_groups
)
12489 struct group_list
* g
;
12490 struct group_list
* next
;
12492 for (i
= 0; i
< group_count
; i
++)
12494 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
12501 free (section_groups
);
12502 section_groups
= NULL
;
12505 free_debug_memory ();
12510 /* Return the path name for a proxy entry in a thin archive, adjusted relative
12511 to the path name of the thin archive itself if necessary. Always returns
12512 a pointer to malloc'ed memory. */
12515 adjust_relative_path (char * file_name
, char * name
, int name_len
)
12517 char * member_file_name
;
12518 const char * base_name
= lbasename (file_name
);
12520 /* This is a proxy entry for a thin archive member.
12521 If the extended name table contains an absolute path
12522 name, or if the archive is in the current directory,
12523 use the path name as given. Otherwise, we need to
12524 find the member relative to the directory where the
12525 archive is located. */
12526 if (IS_ABSOLUTE_PATH (name
) || base_name
== file_name
)
12528 member_file_name
= (char *) malloc (name_len
+ 1);
12529 if (member_file_name
== NULL
)
12531 error (_("Out of memory\n"));
12534 memcpy (member_file_name
, name
, name_len
);
12535 member_file_name
[name_len
] = '\0';
12539 /* Concatenate the path components of the archive file name
12540 to the relative path name from the extended name table. */
12541 size_t prefix_len
= base_name
- file_name
;
12542 member_file_name
= (char *) malloc (prefix_len
+ name_len
+ 1);
12543 if (member_file_name
== NULL
)
12545 error (_("Out of memory\n"));
12548 memcpy (member_file_name
, file_name
, prefix_len
);
12549 memcpy (member_file_name
+ prefix_len
, name
, name_len
);
12550 member_file_name
[prefix_len
+ name_len
] = '\0';
12552 return member_file_name
;
12555 /* Structure to hold information about an archive file. */
12557 struct archive_info
12559 char * file_name
; /* Archive file name. */
12560 FILE * file
; /* Open file descriptor. */
12561 unsigned long index_num
; /* Number of symbols in table. */
12562 unsigned long * index_array
; /* The array of member offsets. */
12563 char * sym_table
; /* The symbol table. */
12564 unsigned long sym_size
; /* Size of the symbol table. */
12565 char * longnames
; /* The long file names table. */
12566 unsigned long longnames_size
; /* Size of the long file names table. */
12567 unsigned long nested_member_origin
; /* Origin in the nested archive of the current member. */
12568 unsigned long next_arhdr_offset
; /* Offset of the next archive header. */
12569 bfd_boolean is_thin_archive
; /* TRUE if this is a thin archive. */
12570 struct ar_hdr arhdr
; /* Current archive header. */
12573 /* Read the symbol table and long-name table from an archive. */
12576 setup_archive (struct archive_info
* arch
, char * file_name
, FILE * file
,
12577 bfd_boolean is_thin_archive
, bfd_boolean read_symbols
)
12580 unsigned long size
;
12582 arch
->file_name
= strdup (file_name
);
12584 arch
->index_num
= 0;
12585 arch
->index_array
= NULL
;
12586 arch
->sym_table
= NULL
;
12587 arch
->sym_size
= 0;
12588 arch
->longnames
= NULL
;
12589 arch
->longnames_size
= 0;
12590 arch
->nested_member_origin
= 0;
12591 arch
->is_thin_archive
= is_thin_archive
;
12592 arch
->next_arhdr_offset
= SARMAG
;
12594 /* Read the first archive member header. */
12595 if (fseek (file
, SARMAG
, SEEK_SET
) != 0)
12597 error (_("%s: failed to seek to first archive header\n"), file_name
);
12600 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
12601 if (got
!= sizeof arch
->arhdr
)
12606 error (_("%s: failed to read archive header\n"), file_name
);
12610 /* See if this is the archive symbol table. */
12611 if (const_strneq (arch
->arhdr
.ar_name
, "/ ")
12612 || const_strneq (arch
->arhdr
.ar_name
, "/SYM64/ "))
12614 size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
12615 size
= size
+ (size
& 1);
12617 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ size
;
12622 /* A buffer used to hold numbers read in from an archive index.
12623 These are always 4 bytes long and stored in big-endian format. */
12624 #define SIZEOF_AR_INDEX_NUMBERS 4
12625 unsigned char integer_buffer
[SIZEOF_AR_INDEX_NUMBERS
];
12626 unsigned char * index_buffer
;
12628 /* Check the size of the archive index. */
12629 if (size
< SIZEOF_AR_INDEX_NUMBERS
)
12631 error (_("%s: the archive index is empty\n"), file_name
);
12635 /* Read the numer of entries in the archive index. */
12636 got
= fread (integer_buffer
, 1, sizeof integer_buffer
, file
);
12637 if (got
!= sizeof (integer_buffer
))
12639 error (_("%s: failed to read archive index\n"), file_name
);
12642 arch
->index_num
= byte_get_big_endian (integer_buffer
, sizeof integer_buffer
);
12643 size
-= SIZEOF_AR_INDEX_NUMBERS
;
12645 /* Read in the archive index. */
12646 if (size
< arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
)
12648 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
12649 file_name
, arch
->index_num
);
12652 index_buffer
= (unsigned char *)
12653 malloc (arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
);
12654 if (index_buffer
== NULL
)
12656 error (_("Out of memory whilst trying to read archive symbol index\n"));
12659 got
= fread (index_buffer
, SIZEOF_AR_INDEX_NUMBERS
, arch
->index_num
, file
);
12660 if (got
!= arch
->index_num
)
12662 free (index_buffer
);
12663 error (_("%s: failed to read archive index\n"), file_name
);
12666 size
-= arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
;
12668 /* Convert the index numbers into the host's numeric format. */
12669 arch
->index_array
= (long unsigned int *)
12670 malloc (arch
->index_num
* sizeof (* arch
->index_array
));
12671 if (arch
->index_array
== NULL
)
12673 free (index_buffer
);
12674 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
12678 for (i
= 0; i
< arch
->index_num
; i
++)
12679 arch
->index_array
[i
] = byte_get_big_endian ((unsigned char *) (index_buffer
+ (i
* SIZEOF_AR_INDEX_NUMBERS
)),
12680 SIZEOF_AR_INDEX_NUMBERS
);
12681 free (index_buffer
);
12683 /* The remaining space in the header is taken up by the symbol table. */
12686 error (_("%s: the archive has an index but no symbols\n"), file_name
);
12689 arch
->sym_table
= (char *) malloc (size
);
12690 arch
->sym_size
= size
;
12691 if (arch
->sym_table
== NULL
)
12693 error (_("Out of memory whilst trying to read archive index symbol table\n"));
12696 got
= fread (arch
->sym_table
, 1, size
, file
);
12699 error (_("%s: failed to read archive index symbol table\n"), file_name
);
12705 if (fseek (file
, size
, SEEK_CUR
) != 0)
12707 error (_("%s: failed to skip archive symbol table\n"), file_name
);
12712 /* Read the next archive header. */
12713 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
12714 if (got
!= sizeof arch
->arhdr
)
12718 error (_("%s: failed to read archive header following archive index\n"), file_name
);
12722 else if (read_symbols
)
12723 printf (_("%s has no archive index\n"), file_name
);
12725 if (const_strneq (arch
->arhdr
.ar_name
, "// "))
12727 /* This is the archive string table holding long member names. */
12728 arch
->longnames_size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
12729 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ arch
->longnames_size
;
12731 arch
->longnames
= (char *) malloc (arch
->longnames_size
);
12732 if (arch
->longnames
== NULL
)
12734 error (_("Out of memory reading long symbol names in archive\n"));
12738 if (fread (arch
->longnames
, arch
->longnames_size
, 1, file
) != 1)
12740 free (arch
->longnames
);
12741 arch
->longnames
= NULL
;
12742 error (_("%s: failed to read long symbol name string table\n"), file_name
);
12746 if ((arch
->longnames_size
& 1) != 0)
12753 /* Release the memory used for the archive information. */
12756 release_archive (struct archive_info
* arch
)
12758 if (arch
->file_name
!= NULL
)
12759 free (arch
->file_name
);
12760 if (arch
->index_array
!= NULL
)
12761 free (arch
->index_array
);
12762 if (arch
->sym_table
!= NULL
)
12763 free (arch
->sym_table
);
12764 if (arch
->longnames
!= NULL
)
12765 free (arch
->longnames
);
12768 /* Open and setup a nested archive, if not already open. */
12771 setup_nested_archive (struct archive_info
* nested_arch
, char * member_file_name
)
12773 FILE * member_file
;
12775 /* Have we already setup this archive? */
12776 if (nested_arch
->file_name
!= NULL
12777 && streq (nested_arch
->file_name
, member_file_name
))
12780 /* Close previous file and discard cached information. */
12781 if (nested_arch
->file
!= NULL
)
12782 fclose (nested_arch
->file
);
12783 release_archive (nested_arch
);
12785 member_file
= fopen (member_file_name
, "rb");
12786 if (member_file
== NULL
)
12788 return setup_archive (nested_arch
, member_file_name
, member_file
, FALSE
, FALSE
);
12792 get_archive_member_name_at (struct archive_info
* arch
,
12793 unsigned long offset
,
12794 struct archive_info
* nested_arch
);
12796 /* Get the name of an archive member from the current archive header.
12797 For simple names, this will modify the ar_name field of the current
12798 archive header. For long names, it will return a pointer to the
12799 longnames table. For nested archives, it will open the nested archive
12800 and get the name recursively. NESTED_ARCH is a single-entry cache so
12801 we don't keep rereading the same information from a nested archive. */
12804 get_archive_member_name (struct archive_info
* arch
,
12805 struct archive_info
* nested_arch
)
12807 unsigned long j
, k
;
12809 if (arch
->arhdr
.ar_name
[0] == '/')
12811 /* We have a long name. */
12813 char * member_file_name
;
12814 char * member_name
;
12816 arch
->nested_member_origin
= 0;
12817 k
= j
= strtoul (arch
->arhdr
.ar_name
+ 1, &endp
, 10);
12818 if (arch
->is_thin_archive
&& endp
!= NULL
&& * endp
== ':')
12819 arch
->nested_member_origin
= strtoul (endp
+ 1, NULL
, 10);
12821 while ((j
< arch
->longnames_size
)
12822 && (arch
->longnames
[j
] != '\n')
12823 && (arch
->longnames
[j
] != '\0'))
12825 if (arch
->longnames
[j
-1] == '/')
12827 arch
->longnames
[j
] = '\0';
12829 if (!arch
->is_thin_archive
|| arch
->nested_member_origin
== 0)
12830 return arch
->longnames
+ k
;
12832 /* This is a proxy for a member of a nested archive.
12833 Find the name of the member in that archive. */
12834 member_file_name
= adjust_relative_path (arch
->file_name
,
12835 arch
->longnames
+ k
, j
- k
);
12836 if (member_file_name
!= NULL
12837 && setup_nested_archive (nested_arch
, member_file_name
) == 0)
12839 member_name
= get_archive_member_name_at (nested_arch
,
12840 arch
->nested_member_origin
,
12842 if (member_name
!= NULL
)
12844 free (member_file_name
);
12845 return member_name
;
12848 free (member_file_name
);
12850 /* Last resort: just return the name of the nested archive. */
12851 return arch
->longnames
+ k
;
12854 /* We have a normal (short) name. */
12855 for (j
= 0; j
< sizeof (arch
->arhdr
.ar_name
); j
++)
12856 if (arch
->arhdr
.ar_name
[j
] == '/')
12858 arch
->arhdr
.ar_name
[j
] = '\0';
12859 return arch
->arhdr
.ar_name
;
12862 /* The full ar_name field is used. Don't rely on ar_date starting
12863 with a zero byte. */
12865 char *name
= xmalloc (sizeof (arch
->arhdr
.ar_name
) + 1);
12866 memcpy (name
, arch
->arhdr
.ar_name
, sizeof (arch
->arhdr
.ar_name
));
12867 name
[sizeof (arch
->arhdr
.ar_name
)] = '\0';
12872 /* Get the name of an archive member at a given OFFSET within an archive ARCH. */
12875 get_archive_member_name_at (struct archive_info
* arch
,
12876 unsigned long offset
,
12877 struct archive_info
* nested_arch
)
12881 if (fseek (arch
->file
, offset
, SEEK_SET
) != 0)
12883 error (_("%s: failed to seek to next file name\n"), arch
->file_name
);
12886 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, arch
->file
);
12887 if (got
!= sizeof arch
->arhdr
)
12889 error (_("%s: failed to read archive header\n"), arch
->file_name
);
12892 if (memcmp (arch
->arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
12894 error (_("%s: did not find a valid archive header\n"), arch
->file_name
);
12898 return get_archive_member_name (arch
, nested_arch
);
12901 /* Construct a string showing the name of the archive member, qualified
12902 with the name of the containing archive file. For thin archives, we
12903 use square brackets to denote the indirection. For nested archives,
12904 we show the qualified name of the external member inside the square
12905 brackets (e.g., "thin.a[normal.a(foo.o)]"). */
12908 make_qualified_name (struct archive_info
* arch
,
12909 struct archive_info
* nested_arch
,
12910 char * member_name
)
12915 len
= strlen (arch
->file_name
) + strlen (member_name
) + 3;
12916 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
12917 len
+= strlen (nested_arch
->file_name
) + 2;
12919 name
= (char *) malloc (len
);
12922 error (_("Out of memory\n"));
12926 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
12927 snprintf (name
, len
, "%s[%s(%s)]", arch
->file_name
, nested_arch
->file_name
, member_name
);
12928 else if (arch
->is_thin_archive
)
12929 snprintf (name
, len
, "%s[%s]", arch
->file_name
, member_name
);
12931 snprintf (name
, len
, "%s(%s)", arch
->file_name
, member_name
);
12936 /* Process an ELF archive.
12937 On entry the file is positioned just after the ARMAG string. */
12940 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
12942 struct archive_info arch
;
12943 struct archive_info nested_arch
;
12949 /* The ARCH structure is used to hold information about this archive. */
12950 arch
.file_name
= NULL
;
12952 arch
.index_array
= NULL
;
12953 arch
.sym_table
= NULL
;
12954 arch
.longnames
= NULL
;
12956 /* The NESTED_ARCH structure is used as a single-item cache of information
12957 about a nested archive (when members of a thin archive reside within
12958 another regular archive file). */
12959 nested_arch
.file_name
= NULL
;
12960 nested_arch
.file
= NULL
;
12961 nested_arch
.index_array
= NULL
;
12962 nested_arch
.sym_table
= NULL
;
12963 nested_arch
.longnames
= NULL
;
12965 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
12971 if (do_archive_index
)
12973 if (arch
.sym_table
== NULL
)
12974 error (_("%s: unable to dump the index as none was found\n"), file_name
);
12978 unsigned long current_pos
;
12980 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
12981 file_name
, arch
.index_num
, arch
.sym_size
);
12982 current_pos
= ftell (file
);
12984 for (i
= l
= 0; i
< arch
.index_num
; i
++)
12986 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
12988 char * member_name
;
12990 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
12992 if (member_name
!= NULL
)
12994 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
12996 if (qualified_name
!= NULL
)
12998 printf (_("Binary %s contains:\n"), qualified_name
);
12999 free (qualified_name
);
13004 if (l
>= arch
.sym_size
)
13006 error (_("%s: end of the symbol table reached before the end of the index\n"),
13010 printf ("\t%s\n", arch
.sym_table
+ l
);
13011 l
+= strlen (arch
.sym_table
+ l
) + 1;
13016 if (l
< arch
.sym_size
)
13017 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
13020 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
13022 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
13028 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
13029 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
13030 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
13031 && !do_section_groups
&& !do_dyn_syms
)
13033 ret
= 0; /* Archive index only. */
13044 char * qualified_name
;
13046 /* Read the next archive header. */
13047 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
13049 error (_("%s: failed to seek to next archive header\n"), file_name
);
13052 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
13053 if (got
!= sizeof arch
.arhdr
)
13057 error (_("%s: failed to read archive header\n"), file_name
);
13061 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
13063 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
13068 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
13070 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
13071 if (archive_file_size
& 01)
13072 ++archive_file_size
;
13074 name
= get_archive_member_name (&arch
, &nested_arch
);
13077 error (_("%s: bad archive file name\n"), file_name
);
13081 namelen
= strlen (name
);
13083 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
13084 if (qualified_name
== NULL
)
13086 error (_("%s: bad archive file name\n"), file_name
);
13091 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
13093 /* This is a proxy for an external member of a thin archive. */
13094 FILE * member_file
;
13095 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
13096 if (member_file_name
== NULL
)
13102 member_file
= fopen (member_file_name
, "rb");
13103 if (member_file
== NULL
)
13105 error (_("Input file '%s' is not readable.\n"), member_file_name
);
13106 free (member_file_name
);
13111 archive_file_offset
= arch
.nested_member_origin
;
13113 ret
|= process_object (qualified_name
, member_file
);
13115 fclose (member_file
);
13116 free (member_file_name
);
13118 else if (is_thin_archive
)
13120 /* This is a proxy for a member of a nested archive. */
13121 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
13123 /* The nested archive file will have been opened and setup by
13124 get_archive_member_name. */
13125 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
13127 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
13132 ret
|= process_object (qualified_name
, nested_arch
.file
);
13136 archive_file_offset
= arch
.next_arhdr_offset
;
13137 arch
.next_arhdr_offset
+= archive_file_size
;
13139 ret
|= process_object (qualified_name
, file
);
13142 free (qualified_name
);
13146 if (nested_arch
.file
!= NULL
)
13147 fclose (nested_arch
.file
);
13148 release_archive (&nested_arch
);
13149 release_archive (&arch
);
13155 process_file (char * file_name
)
13158 struct stat statbuf
;
13159 char armag
[SARMAG
];
13162 if (stat (file_name
, &statbuf
) < 0)
13164 if (errno
== ENOENT
)
13165 error (_("'%s': No such file\n"), file_name
);
13167 error (_("Could not locate '%s'. System error message: %s\n"),
13168 file_name
, strerror (errno
));
13172 if (! S_ISREG (statbuf
.st_mode
))
13174 error (_("'%s' is not an ordinary file\n"), file_name
);
13178 file
= fopen (file_name
, "rb");
13181 error (_("Input file '%s' is not readable.\n"), file_name
);
13185 if (fread (armag
, SARMAG
, 1, file
) != 1)
13187 error (_("%s: Failed to read file's magic number\n"), file_name
);
13192 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
13193 ret
= process_archive (file_name
, file
, FALSE
);
13194 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
13195 ret
= process_archive (file_name
, file
, TRUE
);
13198 if (do_archive_index
)
13199 error (_("File %s is not an archive so its index cannot be displayed.\n"),
13203 archive_file_size
= archive_file_offset
= 0;
13204 ret
= process_object (file_name
, file
);
13212 #ifdef SUPPORT_DISASSEMBLY
13213 /* Needed by the i386 disassembler. For extra credit, someone could
13214 fix this so that we insert symbolic addresses here, esp for GOT/PLT
13218 print_address (unsigned int addr
, FILE * outfile
)
13220 fprintf (outfile
,"0x%8.8x", addr
);
13223 /* Needed by the i386 disassembler. */
13225 db_task_printsym (unsigned int addr
)
13227 print_address (addr
, stderr
);
13232 main (int argc
, char ** argv
)
13236 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
13237 setlocale (LC_MESSAGES
, "");
13239 #if defined (HAVE_SETLOCALE)
13240 setlocale (LC_CTYPE
, "");
13242 bindtextdomain (PACKAGE
, LOCALEDIR
);
13243 textdomain (PACKAGE
);
13245 expandargv (&argc
, &argv
);
13247 parse_args (argc
, argv
);
13249 if (num_dump_sects
> 0)
13251 /* Make a copy of the dump_sects array. */
13252 cmdline_dump_sects
= (dump_type
*)
13253 malloc (num_dump_sects
* sizeof (* dump_sects
));
13254 if (cmdline_dump_sects
== NULL
)
13255 error (_("Out of memory allocating dump request table.\n"));
13258 memcpy (cmdline_dump_sects
, dump_sects
,
13259 num_dump_sects
* sizeof (* dump_sects
));
13260 num_cmdline_dump_sects
= num_dump_sects
;
13264 if (optind
< (argc
- 1))
13268 while (optind
< argc
)
13269 err
|= process_file (argv
[optind
++]);
13271 if (dump_sects
!= NULL
)
13273 if (cmdline_dump_sects
!= NULL
)
13274 free (cmdline_dump_sects
);