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 switch (e_flags
& EF_FRV_CPU_MASK
)
2244 case EF_FRV_CPU_GENERIC
:
2248 strcat (buf
, ", fr???");
2251 case EF_FRV_CPU_FR300
:
2252 strcat (buf
, ", fr300");
2255 case EF_FRV_CPU_FR400
:
2256 strcat (buf
, ", fr400");
2258 case EF_FRV_CPU_FR405
:
2259 strcat (buf
, ", fr405");
2262 case EF_FRV_CPU_FR450
:
2263 strcat (buf
, ", fr450");
2266 case EF_FRV_CPU_FR500
:
2267 strcat (buf
, ", fr500");
2269 case EF_FRV_CPU_FR550
:
2270 strcat (buf
, ", fr550");
2273 case EF_FRV_CPU_SIMPLE
:
2274 strcat (buf
, ", simple");
2276 case EF_FRV_CPU_TOMCAT
:
2277 strcat (buf
, ", tomcat");
2283 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2284 strcat (buf
, ", m68000");
2285 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2286 strcat (buf
, ", cpu32");
2287 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2288 strcat (buf
, ", fido_a");
2291 char const * isa
= _("unknown");
2292 char const * mac
= _("unknown mac");
2293 char const * additional
= NULL
;
2295 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2297 case EF_M68K_CF_ISA_A_NODIV
:
2299 additional
= ", nodiv";
2301 case EF_M68K_CF_ISA_A
:
2304 case EF_M68K_CF_ISA_A_PLUS
:
2307 case EF_M68K_CF_ISA_B_NOUSP
:
2309 additional
= ", nousp";
2311 case EF_M68K_CF_ISA_B
:
2314 case EF_M68K_CF_ISA_C
:
2317 case EF_M68K_CF_ISA_C_NODIV
:
2319 additional
= ", nodiv";
2322 strcat (buf
, ", cf, isa ");
2325 strcat (buf
, additional
);
2326 if (e_flags
& EF_M68K_CF_FLOAT
)
2327 strcat (buf
, ", float");
2328 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2333 case EF_M68K_CF_MAC
:
2336 case EF_M68K_CF_EMAC
:
2339 case EF_M68K_CF_EMAC_B
:
2352 if (e_flags
& EF_PPC_EMB
)
2353 strcat (buf
, ", emb");
2355 if (e_flags
& EF_PPC_RELOCATABLE
)
2356 strcat (buf
, _(", relocatable"));
2358 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2359 strcat (buf
, _(", relocatable-lib"));
2363 case EM_CYGNUS_V850
:
2364 switch (e_flags
& EF_V850_ARCH
)
2366 case E_V850E2V3_ARCH
:
2367 strcat (buf
, ", v850e2v3");
2370 strcat (buf
, ", v850e2");
2373 strcat (buf
, ", v850e1");
2376 strcat (buf
, ", v850e");
2379 strcat (buf
, ", v850");
2382 strcat (buf
, _(", unknown v850 architecture variant"));
2388 case EM_CYGNUS_M32R
:
2389 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2390 strcat (buf
, ", m32r");
2394 case EM_MIPS_RS3_LE
:
2395 if (e_flags
& EF_MIPS_NOREORDER
)
2396 strcat (buf
, ", noreorder");
2398 if (e_flags
& EF_MIPS_PIC
)
2399 strcat (buf
, ", pic");
2401 if (e_flags
& EF_MIPS_CPIC
)
2402 strcat (buf
, ", cpic");
2404 if (e_flags
& EF_MIPS_UCODE
)
2405 strcat (buf
, ", ugen_reserved");
2407 if (e_flags
& EF_MIPS_ABI2
)
2408 strcat (buf
, ", abi2");
2410 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2411 strcat (buf
, ", odk first");
2413 if (e_flags
& EF_MIPS_32BITMODE
)
2414 strcat (buf
, ", 32bitmode");
2416 switch ((e_flags
& EF_MIPS_MACH
))
2418 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2419 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2420 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2421 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2422 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2423 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2424 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2425 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2426 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2427 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2428 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2429 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2430 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
2431 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2432 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
2433 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
2435 /* We simply ignore the field in this case to avoid confusion:
2436 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2439 default: strcat (buf
, _(", unknown CPU")); break;
2442 switch ((e_flags
& EF_MIPS_ABI
))
2444 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2445 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2446 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2447 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2449 /* We simply ignore the field in this case to avoid confusion:
2450 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2451 This means it is likely to be an o32 file, but not for
2454 default: strcat (buf
, _(", unknown ABI")); break;
2457 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2458 strcat (buf
, ", mdmx");
2460 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2461 strcat (buf
, ", mips16");
2463 switch ((e_flags
& EF_MIPS_ARCH
))
2465 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2466 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2467 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2468 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2469 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2470 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2471 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2472 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2473 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2474 default: strcat (buf
, _(", unknown ISA")); break;
2477 if (e_flags
& EF_SH_PIC
)
2478 strcat (buf
, ", pic");
2480 if (e_flags
& EF_SH_FDPIC
)
2481 strcat (buf
, ", fdpic");
2485 switch ((e_flags
& EF_SH_MACH_MASK
))
2487 case EF_SH1
: strcat (buf
, ", sh1"); break;
2488 case EF_SH2
: strcat (buf
, ", sh2"); break;
2489 case EF_SH3
: strcat (buf
, ", sh3"); break;
2490 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2491 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2492 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2493 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2494 case EF_SH4
: strcat (buf
, ", sh4"); break;
2495 case EF_SH5
: strcat (buf
, ", sh5"); break;
2496 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2497 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2498 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2499 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2500 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2501 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2502 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2503 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2504 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2505 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2506 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2507 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2508 default: strcat (buf
, _(", unknown ISA")); break;
2514 if (e_flags
& EF_SPARC_32PLUS
)
2515 strcat (buf
, ", v8+");
2517 if (e_flags
& EF_SPARC_SUN_US1
)
2518 strcat (buf
, ", ultrasparcI");
2520 if (e_flags
& EF_SPARC_SUN_US3
)
2521 strcat (buf
, ", ultrasparcIII");
2523 if (e_flags
& EF_SPARC_HAL_R1
)
2524 strcat (buf
, ", halr1");
2526 if (e_flags
& EF_SPARC_LEDATA
)
2527 strcat (buf
, ", ledata");
2529 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2530 strcat (buf
, ", tso");
2532 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2533 strcat (buf
, ", pso");
2535 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2536 strcat (buf
, ", rmo");
2540 switch (e_flags
& EF_PARISC_ARCH
)
2542 case EFA_PARISC_1_0
:
2543 strcpy (buf
, ", PA-RISC 1.0");
2545 case EFA_PARISC_1_1
:
2546 strcpy (buf
, ", PA-RISC 1.1");
2548 case EFA_PARISC_2_0
:
2549 strcpy (buf
, ", PA-RISC 2.0");
2554 if (e_flags
& EF_PARISC_TRAPNIL
)
2555 strcat (buf
, ", trapnil");
2556 if (e_flags
& EF_PARISC_EXT
)
2557 strcat (buf
, ", ext");
2558 if (e_flags
& EF_PARISC_LSB
)
2559 strcat (buf
, ", lsb");
2560 if (e_flags
& EF_PARISC_WIDE
)
2561 strcat (buf
, ", wide");
2562 if (e_flags
& EF_PARISC_NO_KABP
)
2563 strcat (buf
, ", no kabp");
2564 if (e_flags
& EF_PARISC_LAZYSWAP
)
2565 strcat (buf
, ", lazyswap");
2570 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2571 strcat (buf
, ", new calling convention");
2573 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2574 strcat (buf
, ", gnu calling convention");
2578 if ((e_flags
& EF_IA_64_ABI64
))
2579 strcat (buf
, ", 64-bit");
2581 strcat (buf
, ", 32-bit");
2582 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2583 strcat (buf
, ", reduced fp model");
2584 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2585 strcat (buf
, ", no function descriptors, constant gp");
2586 else if ((e_flags
& EF_IA_64_CONS_GP
))
2587 strcat (buf
, ", constant gp");
2588 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2589 strcat (buf
, ", absolute");
2590 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
2592 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
2593 strcat (buf
, ", vms_linkages");
2594 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
2596 case EF_IA_64_VMS_COMCOD_SUCCESS
:
2598 case EF_IA_64_VMS_COMCOD_WARNING
:
2599 strcat (buf
, ", warning");
2601 case EF_IA_64_VMS_COMCOD_ERROR
:
2602 strcat (buf
, ", error");
2604 case EF_IA_64_VMS_COMCOD_ABORT
:
2605 strcat (buf
, ", abort");
2614 if ((e_flags
& EF_VAX_NONPIC
))
2615 strcat (buf
, ", non-PIC");
2616 if ((e_flags
& EF_VAX_DFLOAT
))
2617 strcat (buf
, ", D-Float");
2618 if ((e_flags
& EF_VAX_GFLOAT
))
2619 strcat (buf
, ", G-Float");
2623 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
2624 strcat (buf
, ", 64-bit doubles");
2625 if (e_flags
& E_FLAG_RX_DSP
)
2626 strcat (buf
, ", dsp");
2629 if (e_flags
& EF_S390_HIGH_GPRS
)
2630 strcat (buf
, ", highgprs");
2633 if ((e_flags
& EF_C6000_REL
))
2634 strcat (buf
, ", relocatable module");
2642 get_osabi_name (unsigned int osabi
)
2644 static char buff
[32];
2648 case ELFOSABI_NONE
: return "UNIX - System V";
2649 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2650 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2651 case ELFOSABI_LINUX
: return "UNIX - Linux";
2652 case ELFOSABI_HURD
: return "GNU/Hurd";
2653 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2654 case ELFOSABI_AIX
: return "UNIX - AIX";
2655 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2656 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2657 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2658 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2659 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2660 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2661 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2662 case ELFOSABI_AROS
: return "AROS";
2663 case ELFOSABI_FENIXOS
: return "FenixOS";
2666 switch (elf_header
.e_machine
)
2671 case ELFOSABI_ARM
: return "ARM";
2681 case ELFOSABI_STANDALONE
: return _("Standalone App");
2690 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
2691 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
2700 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2706 get_arm_segment_type (unsigned long type
)
2720 get_mips_segment_type (unsigned long type
)
2724 case PT_MIPS_REGINFO
:
2726 case PT_MIPS_RTPROC
:
2728 case PT_MIPS_OPTIONS
:
2738 get_parisc_segment_type (unsigned long type
)
2742 case PT_HP_TLS
: return "HP_TLS";
2743 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2744 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2745 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2746 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2747 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2748 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2749 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2750 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2751 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2752 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2753 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2754 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2755 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2756 case PT_HP_STACK
: return "HP_STACK";
2757 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2758 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2759 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2760 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2769 get_ia64_segment_type (unsigned long type
)
2773 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2774 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2775 case PT_HP_TLS
: return "HP_TLS";
2776 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2777 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2778 case PT_IA_64_HP_STACK
: return "HP_STACK";
2787 get_tic6x_segment_type (unsigned long type
)
2791 case PT_C6000_PHATTR
: return "C6000_PHATTR";
2800 get_segment_type (unsigned long p_type
)
2802 static char buff
[32];
2806 case PT_NULL
: return "NULL";
2807 case PT_LOAD
: return "LOAD";
2808 case PT_DYNAMIC
: return "DYNAMIC";
2809 case PT_INTERP
: return "INTERP";
2810 case PT_NOTE
: return "NOTE";
2811 case PT_SHLIB
: return "SHLIB";
2812 case PT_PHDR
: return "PHDR";
2813 case PT_TLS
: return "TLS";
2815 case PT_GNU_EH_FRAME
:
2816 return "GNU_EH_FRAME";
2817 case PT_GNU_STACK
: return "GNU_STACK";
2818 case PT_GNU_RELRO
: return "GNU_RELRO";
2821 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2823 const char * result
;
2825 switch (elf_header
.e_machine
)
2828 result
= get_arm_segment_type (p_type
);
2831 case EM_MIPS_RS3_LE
:
2832 result
= get_mips_segment_type (p_type
);
2835 result
= get_parisc_segment_type (p_type
);
2838 result
= get_ia64_segment_type (p_type
);
2841 result
= get_tic6x_segment_type (p_type
);
2851 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2853 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2855 const char * result
;
2857 switch (elf_header
.e_machine
)
2860 result
= get_parisc_segment_type (p_type
);
2863 result
= get_ia64_segment_type (p_type
);
2873 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2876 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2883 get_mips_section_type_name (unsigned int sh_type
)
2887 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2888 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2889 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2890 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2891 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2892 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2893 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2894 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2895 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2896 case SHT_MIPS_RELD
: return "MIPS_RELD";
2897 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2898 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2899 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2900 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2901 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2902 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2903 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2904 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2905 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2906 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2907 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2908 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2909 case SHT_MIPS_LINE
: return "MIPS_LINE";
2910 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2911 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2912 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2913 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2914 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2915 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2916 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2917 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2918 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2919 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2920 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2921 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2922 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2923 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2924 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2925 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2933 get_parisc_section_type_name (unsigned int sh_type
)
2937 case SHT_PARISC_EXT
: return "PARISC_EXT";
2938 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2939 case SHT_PARISC_DOC
: return "PARISC_DOC";
2940 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2941 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2942 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2943 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2951 get_ia64_section_type_name (unsigned int sh_type
)
2953 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2954 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2955 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2959 case SHT_IA_64_EXT
: return "IA_64_EXT";
2960 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2961 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2962 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
2963 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
2964 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
2965 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
2966 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
2967 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
2968 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
2976 get_x86_64_section_type_name (unsigned int sh_type
)
2980 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2988 get_arm_section_type_name (unsigned int sh_type
)
2992 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
2993 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
2994 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
2995 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
2996 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
3004 get_tic6x_section_type_name (unsigned int sh_type
)
3008 case SHT_C6000_UNWIND
:
3009 return "C6000_UNWIND";
3010 case SHT_C6000_PREEMPTMAP
:
3011 return "C6000_PREEMPTMAP";
3012 case SHT_C6000_ATTRIBUTES
:
3013 return "C6000_ATTRIBUTES";
3018 case SHT_TI_HANDLER
:
3019 return "TI_HANDLER";
3020 case SHT_TI_INITINFO
:
3021 return "TI_INITINFO";
3022 case SHT_TI_PHATTRS
:
3023 return "TI_PHATTRS";
3031 get_section_type_name (unsigned int sh_type
)
3033 static char buff
[32];
3037 case SHT_NULL
: return "NULL";
3038 case SHT_PROGBITS
: return "PROGBITS";
3039 case SHT_SYMTAB
: return "SYMTAB";
3040 case SHT_STRTAB
: return "STRTAB";
3041 case SHT_RELA
: return "RELA";
3042 case SHT_HASH
: return "HASH";
3043 case SHT_DYNAMIC
: return "DYNAMIC";
3044 case SHT_NOTE
: return "NOTE";
3045 case SHT_NOBITS
: return "NOBITS";
3046 case SHT_REL
: return "REL";
3047 case SHT_SHLIB
: return "SHLIB";
3048 case SHT_DYNSYM
: return "DYNSYM";
3049 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
3050 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
3051 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
3052 case SHT_GNU_HASH
: return "GNU_HASH";
3053 case SHT_GROUP
: return "GROUP";
3054 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
3055 case SHT_GNU_verdef
: return "VERDEF";
3056 case SHT_GNU_verneed
: return "VERNEED";
3057 case SHT_GNU_versym
: return "VERSYM";
3058 case 0x6ffffff0: return "VERSYM";
3059 case 0x6ffffffc: return "VERDEF";
3060 case 0x7ffffffd: return "AUXILIARY";
3061 case 0x7fffffff: return "FILTER";
3062 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
3065 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
3067 const char * result
;
3069 switch (elf_header
.e_machine
)
3072 case EM_MIPS_RS3_LE
:
3073 result
= get_mips_section_type_name (sh_type
);
3076 result
= get_parisc_section_type_name (sh_type
);
3079 result
= get_ia64_section_type_name (sh_type
);
3083 result
= get_x86_64_section_type_name (sh_type
);
3086 result
= get_arm_section_type_name (sh_type
);
3089 result
= get_tic6x_section_type_name (sh_type
);
3099 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
3101 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
3103 const char * result
;
3105 switch (elf_header
.e_machine
)
3108 result
= get_ia64_section_type_name (sh_type
);
3118 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
3120 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
3121 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
3123 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
3129 #define OPTION_DEBUG_DUMP 512
3130 #define OPTION_DYN_SYMS 513
3132 static struct option options
[] =
3134 {"all", no_argument
, 0, 'a'},
3135 {"file-header", no_argument
, 0, 'h'},
3136 {"program-headers", no_argument
, 0, 'l'},
3137 {"headers", no_argument
, 0, 'e'},
3138 {"histogram", no_argument
, 0, 'I'},
3139 {"segments", no_argument
, 0, 'l'},
3140 {"sections", no_argument
, 0, 'S'},
3141 {"section-headers", no_argument
, 0, 'S'},
3142 {"section-groups", no_argument
, 0, 'g'},
3143 {"section-details", no_argument
, 0, 't'},
3144 {"full-section-name",no_argument
, 0, 'N'},
3145 {"symbols", no_argument
, 0, 's'},
3146 {"syms", no_argument
, 0, 's'},
3147 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
3148 {"relocs", no_argument
, 0, 'r'},
3149 {"notes", no_argument
, 0, 'n'},
3150 {"dynamic", no_argument
, 0, 'd'},
3151 {"arch-specific", no_argument
, 0, 'A'},
3152 {"version-info", no_argument
, 0, 'V'},
3153 {"use-dynamic", no_argument
, 0, 'D'},
3154 {"unwind", no_argument
, 0, 'u'},
3155 {"archive-index", no_argument
, 0, 'c'},
3156 {"hex-dump", required_argument
, 0, 'x'},
3157 {"relocated-dump", required_argument
, 0, 'R'},
3158 {"string-dump", required_argument
, 0, 'p'},
3159 #ifdef SUPPORT_DISASSEMBLY
3160 {"instruction-dump", required_argument
, 0, 'i'},
3162 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
3164 {"version", no_argument
, 0, 'v'},
3165 {"wide", no_argument
, 0, 'W'},
3166 {"help", no_argument
, 0, 'H'},
3167 {0, no_argument
, 0, 0}
3171 usage (FILE * stream
)
3173 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
3174 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
3175 fprintf (stream
, _(" Options are:\n\
3176 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3177 -h --file-header Display the ELF file header\n\
3178 -l --program-headers Display the program headers\n\
3179 --segments An alias for --program-headers\n\
3180 -S --section-headers Display the sections' header\n\
3181 --sections An alias for --section-headers\n\
3182 -g --section-groups Display the section groups\n\
3183 -t --section-details Display the section details\n\
3184 -e --headers Equivalent to: -h -l -S\n\
3185 -s --syms Display the symbol table\n\
3186 --symbols An alias for --syms\n\
3187 --dyn-syms Display the dynamic symbol table\n\
3188 -n --notes Display the core notes (if present)\n\
3189 -r --relocs Display the relocations (if present)\n\
3190 -u --unwind Display the unwind info (if present)\n\
3191 -d --dynamic Display the dynamic section (if present)\n\
3192 -V --version-info Display the version sections (if present)\n\
3193 -A --arch-specific Display architecture specific information (if any).\n\
3194 -c --archive-index Display the symbol/file index in an archive\n\
3195 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3196 -x --hex-dump=<number|name>\n\
3197 Dump the contents of section <number|name> as bytes\n\
3198 -p --string-dump=<number|name>\n\
3199 Dump the contents of section <number|name> as strings\n\
3200 -R --relocated-dump=<number|name>\n\
3201 Dump the contents of section <number|name> as relocated bytes\n\
3202 -w[lLiaprmfFsoRt] or\n\
3203 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3204 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3205 =trace_info,=trace_abbrev,=trace_aranges]\n\
3206 Display the contents of DWARF2 debug sections\n"));
3207 #ifdef SUPPORT_DISASSEMBLY
3208 fprintf (stream
, _("\
3209 -i --instruction-dump=<number|name>\n\
3210 Disassemble the contents of section <number|name>\n"));
3212 fprintf (stream
, _("\
3213 -I --histogram Display histogram of bucket list lengths\n\
3214 -W --wide Allow output width to exceed 80 characters\n\
3215 @<file> Read options from <file>\n\
3216 -H --help Display this information\n\
3217 -v --version Display the version number of readelf\n"));
3219 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3220 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
3222 exit (stream
== stdout
? 0 : 1);
3225 /* Record the fact that the user wants the contents of section number
3226 SECTION to be displayed using the method(s) encoded as flags bits
3227 in TYPE. Note, TYPE can be zero if we are creating the array for
3231 request_dump_bynumber (unsigned int section
, dump_type type
)
3233 if (section
>= num_dump_sects
)
3235 dump_type
* new_dump_sects
;
3237 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
3238 sizeof (* dump_sects
));
3240 if (new_dump_sects
== NULL
)
3241 error (_("Out of memory allocating dump request table.\n"));
3244 /* Copy current flag settings. */
3245 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
3249 dump_sects
= new_dump_sects
;
3250 num_dump_sects
= section
+ 1;
3255 dump_sects
[section
] |= type
;
3260 /* Request a dump by section name. */
3263 request_dump_byname (const char * section
, dump_type type
)
3265 struct dump_list_entry
* new_request
;
3267 new_request
= (struct dump_list_entry
*)
3268 malloc (sizeof (struct dump_list_entry
));
3270 error (_("Out of memory allocating dump request table.\n"));
3272 new_request
->name
= strdup (section
);
3273 if (!new_request
->name
)
3274 error (_("Out of memory allocating dump request table.\n"));
3276 new_request
->type
= type
;
3278 new_request
->next
= dump_sects_byname
;
3279 dump_sects_byname
= new_request
;
3283 request_dump (dump_type type
)
3289 section
= strtoul (optarg
, & cp
, 0);
3291 if (! *cp
&& section
>= 0)
3292 request_dump_bynumber (section
, type
);
3294 request_dump_byname (optarg
, type
);
3299 parse_args (int argc
, char ** argv
)
3306 while ((c
= getopt_long
3307 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
3325 do_section_groups
++;
3333 do_section_groups
++;
3338 do_section_details
++;
3382 request_dump (HEX_DUMP
);
3385 request_dump (STRING_DUMP
);
3388 request_dump (RELOC_DUMP
);
3395 dwarf_select_sections_all ();
3400 dwarf_select_sections_by_letters (optarg
);
3403 case OPTION_DEBUG_DUMP
:
3410 dwarf_select_sections_by_names (optarg
);
3413 case OPTION_DYN_SYMS
:
3416 #ifdef SUPPORT_DISASSEMBLY
3418 request_dump (DISASS_DUMP
);
3422 print_version (program_name
);
3431 /* xgettext:c-format */
3432 error (_("Invalid option '-%c'\n"), c
);
3439 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3440 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3441 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3442 && !do_section_groups
&& !do_archive_index
3447 warn (_("Nothing to do.\n"));
3453 get_elf_class (unsigned int elf_class
)
3455 static char buff
[32];
3459 case ELFCLASSNONE
: return _("none");
3460 case ELFCLASS32
: return "ELF32";
3461 case ELFCLASS64
: return "ELF64";
3463 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3469 get_data_encoding (unsigned int encoding
)
3471 static char buff
[32];
3475 case ELFDATANONE
: return _("none");
3476 case ELFDATA2LSB
: return _("2's complement, little endian");
3477 case ELFDATA2MSB
: return _("2's complement, big endian");
3479 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3484 /* Decode the data held in 'elf_header'. */
3487 process_file_header (void)
3489 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3490 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3491 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3492 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3495 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3499 init_dwarf_regnames (elf_header
.e_machine
);
3505 printf (_("ELF Header:\n"));
3506 printf (_(" Magic: "));
3507 for (i
= 0; i
< EI_NIDENT
; i
++)
3508 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3510 printf (_(" Class: %s\n"),
3511 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3512 printf (_(" Data: %s\n"),
3513 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3514 printf (_(" Version: %d %s\n"),
3515 elf_header
.e_ident
[EI_VERSION
],
3516 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3518 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3519 ? _("<unknown: %lx>")
3521 printf (_(" OS/ABI: %s\n"),
3522 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3523 printf (_(" ABI Version: %d\n"),
3524 elf_header
.e_ident
[EI_ABIVERSION
]);
3525 printf (_(" Type: %s\n"),
3526 get_file_type (elf_header
.e_type
));
3527 printf (_(" Machine: %s\n"),
3528 get_machine_name (elf_header
.e_machine
));
3529 printf (_(" Version: 0x%lx\n"),
3530 (unsigned long) elf_header
.e_version
);
3532 printf (_(" Entry point address: "));
3533 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3534 printf (_("\n Start of program headers: "));
3535 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3536 printf (_(" (bytes into file)\n Start of section headers: "));
3537 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3538 printf (_(" (bytes into file)\n"));
3540 printf (_(" Flags: 0x%lx%s\n"),
3541 (unsigned long) elf_header
.e_flags
,
3542 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3543 printf (_(" Size of this header: %ld (bytes)\n"),
3544 (long) elf_header
.e_ehsize
);
3545 printf (_(" Size of program headers: %ld (bytes)\n"),
3546 (long) elf_header
.e_phentsize
);
3547 printf (_(" Number of program headers: %ld"),
3548 (long) elf_header
.e_phnum
);
3549 if (section_headers
!= NULL
3550 && elf_header
.e_phnum
== PN_XNUM
3551 && section_headers
[0].sh_info
!= 0)
3552 printf (_(" (%ld)"), (long) section_headers
[0].sh_info
);
3553 putc ('\n', stdout
);
3554 printf (_(" Size of section headers: %ld (bytes)\n"),
3555 (long) elf_header
.e_shentsize
);
3556 printf (_(" Number of section headers: %ld"),
3557 (long) elf_header
.e_shnum
);
3558 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
3559 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3560 putc ('\n', stdout
);
3561 printf (_(" Section header string table index: %ld"),
3562 (long) elf_header
.e_shstrndx
);
3563 if (section_headers
!= NULL
3564 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3565 printf (" (%u)", section_headers
[0].sh_link
);
3566 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3567 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3568 printf (_(" <corrupt: out of range>"));
3569 putc ('\n', stdout
);
3572 if (section_headers
!= NULL
)
3574 if (elf_header
.e_phnum
== PN_XNUM
3575 && section_headers
[0].sh_info
!= 0)
3576 elf_header
.e_phnum
= section_headers
[0].sh_info
;
3577 if (elf_header
.e_shnum
== SHN_UNDEF
)
3578 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3579 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3580 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3581 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3582 elf_header
.e_shstrndx
= SHN_UNDEF
;
3583 free (section_headers
);
3584 section_headers
= NULL
;
3592 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3594 Elf32_External_Phdr
* phdrs
;
3595 Elf32_External_Phdr
* external
;
3596 Elf_Internal_Phdr
* internal
;
3599 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3600 elf_header
.e_phentsize
,
3602 _("program headers"));
3606 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3607 i
< elf_header
.e_phnum
;
3608 i
++, internal
++, external
++)
3610 internal
->p_type
= BYTE_GET (external
->p_type
);
3611 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3612 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3613 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3614 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3615 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3616 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3617 internal
->p_align
= BYTE_GET (external
->p_align
);
3626 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3628 Elf64_External_Phdr
* phdrs
;
3629 Elf64_External_Phdr
* external
;
3630 Elf_Internal_Phdr
* internal
;
3633 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3634 elf_header
.e_phentsize
,
3636 _("program headers"));
3640 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3641 i
< elf_header
.e_phnum
;
3642 i
++, internal
++, external
++)
3644 internal
->p_type
= BYTE_GET (external
->p_type
);
3645 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3646 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3647 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3648 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3649 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3650 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3651 internal
->p_align
= BYTE_GET (external
->p_align
);
3659 /* Returns 1 if the program headers were read into `program_headers'. */
3662 get_program_headers (FILE * file
)
3664 Elf_Internal_Phdr
* phdrs
;
3666 /* Check cache of prior read. */
3667 if (program_headers
!= NULL
)
3670 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
3671 sizeof (Elf_Internal_Phdr
));
3675 error (_("Out of memory\n"));
3680 ? get_32bit_program_headers (file
, phdrs
)
3681 : get_64bit_program_headers (file
, phdrs
))
3683 program_headers
= phdrs
;
3691 /* Returns 1 if the program headers were loaded. */
3694 process_program_headers (FILE * file
)
3696 Elf_Internal_Phdr
* segment
;
3699 if (elf_header
.e_phnum
== 0)
3702 printf (_("\nThere are no program headers in this file.\n"));
3706 if (do_segments
&& !do_header
)
3708 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3709 printf (_("Entry point "));
3710 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3711 printf (_("\nThere are %d program headers, starting at offset "),
3712 elf_header
.e_phnum
);
3713 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3717 if (! get_program_headers (file
))
3722 if (elf_header
.e_phnum
> 1)
3723 printf (_("\nProgram Headers:\n"));
3725 printf (_("\nProgram Headers:\n"));
3729 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3732 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3736 (_(" Type Offset VirtAddr PhysAddr\n"));
3738 (_(" FileSiz MemSiz Flags Align\n"));
3745 for (i
= 0, segment
= program_headers
;
3746 i
< elf_header
.e_phnum
;
3751 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3755 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3756 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3757 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3758 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3759 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3761 (segment
->p_flags
& PF_R
? 'R' : ' '),
3762 (segment
->p_flags
& PF_W
? 'W' : ' '),
3763 (segment
->p_flags
& PF_X
? 'E' : ' '));
3764 printf ("%#lx", (unsigned long) segment
->p_align
);
3768 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3769 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3772 print_vma (segment
->p_offset
, FULL_HEX
);
3776 print_vma (segment
->p_vaddr
, FULL_HEX
);
3778 print_vma (segment
->p_paddr
, FULL_HEX
);
3781 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3782 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3785 print_vma (segment
->p_filesz
, FULL_HEX
);
3789 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3790 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3793 print_vma (segment
->p_offset
, FULL_HEX
);
3797 (segment
->p_flags
& PF_R
? 'R' : ' '),
3798 (segment
->p_flags
& PF_W
? 'W' : ' '),
3799 (segment
->p_flags
& PF_X
? 'E' : ' '));
3801 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3802 printf ("%#lx", (unsigned long) segment
->p_align
);
3805 print_vma (segment
->p_align
, PREFIX_HEX
);
3810 print_vma (segment
->p_offset
, FULL_HEX
);
3812 print_vma (segment
->p_vaddr
, FULL_HEX
);
3814 print_vma (segment
->p_paddr
, FULL_HEX
);
3816 print_vma (segment
->p_filesz
, FULL_HEX
);
3818 print_vma (segment
->p_memsz
, FULL_HEX
);
3820 (segment
->p_flags
& PF_R
? 'R' : ' '),
3821 (segment
->p_flags
& PF_W
? 'W' : ' '),
3822 (segment
->p_flags
& PF_X
? 'E' : ' '));
3823 print_vma (segment
->p_align
, HEX
);
3827 switch (segment
->p_type
)
3831 error (_("more than one dynamic segment\n"));
3833 /* By default, assume that the .dynamic section is the first
3834 section in the DYNAMIC segment. */
3835 dynamic_addr
= segment
->p_offset
;
3836 dynamic_size
= segment
->p_filesz
;
3838 /* Try to locate the .dynamic section. If there is
3839 a section header table, we can easily locate it. */
3840 if (section_headers
!= NULL
)
3842 Elf_Internal_Shdr
* sec
;
3844 sec
= find_section (".dynamic");
3845 if (sec
== NULL
|| sec
->sh_size
== 0)
3847 /* A corresponding .dynamic section is expected, but on
3848 IA-64/OpenVMS it is OK for it to be missing. */
3849 if (!is_ia64_vms ())
3850 error (_("no .dynamic section in the dynamic segment\n"));
3854 if (sec
->sh_type
== SHT_NOBITS
)
3860 dynamic_addr
= sec
->sh_offset
;
3861 dynamic_size
= sec
->sh_size
;
3863 if (dynamic_addr
< segment
->p_offset
3864 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3865 warn (_("the .dynamic section is not contained"
3866 " within the dynamic segment\n"));
3867 else if (dynamic_addr
> segment
->p_offset
)
3868 warn (_("the .dynamic section is not the first section"
3869 " in the dynamic segment.\n"));
3874 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3876 error (_("Unable to find program interpreter name\n"));
3880 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
3882 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
3883 error (_("Internal error: failed to create format string to display program interpreter\n"));
3885 program_interpreter
[0] = 0;
3886 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
3887 error (_("Unable to read program interpreter name\n"));
3890 printf (_("\n [Requesting program interpreter: %s]"),
3891 program_interpreter
);
3897 putc ('\n', stdout
);
3900 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3902 printf (_("\n Section to Segment mapping:\n"));
3903 printf (_(" Segment Sections...\n"));
3905 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3908 Elf_Internal_Shdr
* section
;
3910 segment
= program_headers
+ i
;
3911 section
= section_headers
+ 1;
3913 printf (" %2.2d ", i
);
3915 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3917 if (!ELF_TBSS_SPECIAL (section
, segment
)
3918 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
3919 printf ("%s ", SECTION_NAME (section
));
3930 /* Find the file offset corresponding to VMA by using the program headers. */
3933 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
3935 Elf_Internal_Phdr
* seg
;
3937 if (! get_program_headers (file
))
3939 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3943 for (seg
= program_headers
;
3944 seg
< program_headers
+ elf_header
.e_phnum
;
3947 if (seg
->p_type
!= PT_LOAD
)
3950 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3951 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3952 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3955 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3956 (unsigned long) vma
);
3962 get_32bit_section_headers (FILE * file
, unsigned int num
)
3964 Elf32_External_Shdr
* shdrs
;
3965 Elf_Internal_Shdr
* internal
;
3968 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
3969 elf_header
.e_shentsize
, num
,
3970 _("section headers"));
3974 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
3975 sizeof (Elf_Internal_Shdr
));
3977 if (section_headers
== NULL
)
3979 error (_("Out of memory\n"));
3983 for (i
= 0, internal
= section_headers
;
3987 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3988 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3989 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3990 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3991 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3992 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3993 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3994 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3995 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3996 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4005 get_64bit_section_headers (FILE * file
, unsigned int num
)
4007 Elf64_External_Shdr
* shdrs
;
4008 Elf_Internal_Shdr
* internal
;
4011 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4012 elf_header
.e_shentsize
, num
,
4013 _("section headers"));
4017 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4018 sizeof (Elf_Internal_Shdr
));
4020 if (section_headers
== NULL
)
4022 error (_("Out of memory\n"));
4026 for (i
= 0, internal
= section_headers
;
4030 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4031 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4032 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4033 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4034 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4035 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4036 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4037 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4038 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4039 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4047 static Elf_Internal_Sym
*
4048 get_32bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
4050 unsigned long number
;
4051 Elf32_External_Sym
* esyms
= NULL
;
4052 Elf_External_Sym_Shndx
* shndx
;
4053 Elf_Internal_Sym
* isyms
= NULL
;
4054 Elf_Internal_Sym
* psym
;
4057 /* Run some sanity checks first. */
4058 if (section
->sh_entsize
== 0)
4060 error (_("sh_entsize is zero\n"));
4064 number
= section
->sh_size
/ section
->sh_entsize
;
4066 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
4068 error (_("Invalid sh_entsize\n"));
4072 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4073 section
->sh_size
, _("symbols"));
4078 if (symtab_shndx_hdr
!= NULL
4079 && (symtab_shndx_hdr
->sh_link
4080 == (unsigned long) (section
- section_headers
)))
4082 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4083 symtab_shndx_hdr
->sh_offset
,
4084 1, symtab_shndx_hdr
->sh_size
,
4090 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4094 error (_("Out of memory\n"));
4098 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4100 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4101 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4102 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4103 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4104 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4106 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4107 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4108 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4109 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4110 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4122 static Elf_Internal_Sym
*
4123 get_64bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
4125 unsigned long number
;
4126 Elf64_External_Sym
* esyms
;
4127 Elf_External_Sym_Shndx
* shndx
;
4128 Elf_Internal_Sym
* isyms
;
4129 Elf_Internal_Sym
* psym
;
4132 /* Run some sanity checks first. */
4133 if (section
->sh_entsize
== 0)
4135 error (_("sh_entsize is zero\n"));
4139 number
= section
->sh_size
/ section
->sh_entsize
;
4141 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
4143 error (_("Invalid sh_entsize\n"));
4147 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4148 section
->sh_size
, _("symbols"));
4153 if (symtab_shndx_hdr
!= NULL
4154 && (symtab_shndx_hdr
->sh_link
4155 == (unsigned long) (section
- section_headers
)))
4157 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4158 symtab_shndx_hdr
->sh_offset
,
4159 1, symtab_shndx_hdr
->sh_size
,
4168 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4172 error (_("Out of memory\n"));
4179 for (j
= 0, psym
= isyms
;
4183 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4184 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4185 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4186 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4187 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4189 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4190 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4191 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4192 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4193 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4204 get_elf_section_flags (bfd_vma sh_flags
)
4206 static char buff
[1024];
4208 int field_size
= is_32bit_elf
? 8 : 16;
4210 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
4211 bfd_vma os_flags
= 0;
4212 bfd_vma proc_flags
= 0;
4213 bfd_vma unknown_flags
= 0;
4221 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4222 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4223 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4224 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4225 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4226 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4227 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4228 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4229 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4230 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4231 /* IA-64 specific. */
4232 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4233 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4234 /* IA-64 OpenVMS specific. */
4235 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4236 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4237 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4238 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4239 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4240 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4242 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4243 /* SPARC specific. */
4244 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4247 if (do_section_details
)
4249 sprintf (buff
, "[%*.*lx]: ",
4250 field_size
, field_size
, (unsigned long) sh_flags
);
4251 p
+= field_size
+ 4;
4258 flag
= sh_flags
& - sh_flags
;
4261 if (do_section_details
)
4265 case SHF_WRITE
: sindex
= 0; break;
4266 case SHF_ALLOC
: sindex
= 1; break;
4267 case SHF_EXECINSTR
: sindex
= 2; break;
4268 case SHF_MERGE
: sindex
= 3; break;
4269 case SHF_STRINGS
: sindex
= 4; break;
4270 case SHF_INFO_LINK
: sindex
= 5; break;
4271 case SHF_LINK_ORDER
: sindex
= 6; break;
4272 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
4273 case SHF_GROUP
: sindex
= 8; break;
4274 case SHF_TLS
: sindex
= 9; break;
4275 case SHF_EXCLUDE
: sindex
= 18; break;
4279 switch (elf_header
.e_machine
)
4282 if (flag
== SHF_IA_64_SHORT
)
4284 else if (flag
== SHF_IA_64_NORECOV
)
4287 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
4290 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
4291 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
4292 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
4293 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
4294 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
4295 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
4305 case EM_OLD_SPARCV9
:
4306 case EM_SPARC32PLUS
:
4309 if (flag
== SHF_ORDERED
)
4319 if (p
!= buff
+ field_size
+ 4)
4321 if (size
< (10 + 2))
4328 size
-= flags
[sindex
].len
;
4329 p
= stpcpy (p
, flags
[sindex
].str
);
4331 else if (flag
& SHF_MASKOS
)
4333 else if (flag
& SHF_MASKPROC
)
4336 unknown_flags
|= flag
;
4342 case SHF_WRITE
: *p
= 'W'; break;
4343 case SHF_ALLOC
: *p
= 'A'; break;
4344 case SHF_EXECINSTR
: *p
= 'X'; break;
4345 case SHF_MERGE
: *p
= 'M'; break;
4346 case SHF_STRINGS
: *p
= 'S'; break;
4347 case SHF_INFO_LINK
: *p
= 'I'; break;
4348 case SHF_LINK_ORDER
: *p
= 'L'; break;
4349 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
4350 case SHF_GROUP
: *p
= 'G'; break;
4351 case SHF_TLS
: *p
= 'T'; break;
4352 case SHF_EXCLUDE
: *p
= 'E'; break;
4355 if ((elf_header
.e_machine
== EM_X86_64
4356 || elf_header
.e_machine
== EM_L1OM
)
4357 && flag
== SHF_X86_64_LARGE
)
4359 else if (flag
& SHF_MASKOS
)
4362 sh_flags
&= ~ SHF_MASKOS
;
4364 else if (flag
& SHF_MASKPROC
)
4367 sh_flags
&= ~ SHF_MASKPROC
;
4377 if (do_section_details
)
4381 size
-= 5 + field_size
;
4382 if (p
!= buff
+ field_size
+ 4)
4390 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4391 (unsigned long) os_flags
);
4392 p
+= 5 + field_size
;
4396 size
-= 7 + field_size
;
4397 if (p
!= buff
+ field_size
+ 4)
4405 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4406 (unsigned long) proc_flags
);
4407 p
+= 7 + field_size
;
4411 size
-= 10 + field_size
;
4412 if (p
!= buff
+ field_size
+ 4)
4420 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
4421 (unsigned long) unknown_flags
);
4422 p
+= 10 + field_size
;
4431 process_section_headers (FILE * file
)
4433 Elf_Internal_Shdr
* section
;
4436 section_headers
= NULL
;
4438 if (elf_header
.e_shnum
== 0)
4441 printf (_("\nThere are no sections in this file.\n"));
4446 if (do_sections
&& !do_header
)
4447 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4448 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4452 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4455 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4458 /* Read in the string table, so that we have names to display. */
4459 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4460 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4462 section
= section_headers
+ elf_header
.e_shstrndx
;
4464 if (section
->sh_size
!= 0)
4466 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4467 1, section
->sh_size
,
4470 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4474 /* Scan the sections for the dynamic symbol table
4475 and dynamic string table and debug sections. */
4476 dynamic_symbols
= NULL
;
4477 dynamic_strings
= NULL
;
4478 dynamic_syminfo
= NULL
;
4479 symtab_shndx_hdr
= NULL
;
4481 eh_addr_size
= is_32bit_elf
? 4 : 8;
4482 switch (elf_header
.e_machine
)
4485 case EM_MIPS_RS3_LE
:
4486 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4487 FDE addresses. However, the ABI also has a semi-official ILP32
4488 variant for which the normal FDE address size rules apply.
4490 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4491 section, where XX is the size of longs in bits. Unfortunately,
4492 earlier compilers provided no way of distinguishing ILP32 objects
4493 from LP64 objects, so if there's any doubt, we should assume that
4494 the official LP64 form is being used. */
4495 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4496 && find_section (".gcc_compiled_long32") == NULL
)
4502 switch (elf_header
.e_flags
& EF_H8_MACH
)
4504 case E_H8_MACH_H8300
:
4505 case E_H8_MACH_H8300HN
:
4506 case E_H8_MACH_H8300SN
:
4507 case E_H8_MACH_H8300SXN
:
4510 case E_H8_MACH_H8300H
:
4511 case E_H8_MACH_H8300S
:
4512 case E_H8_MACH_H8300SX
:
4520 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
4522 case EF_M32C_CPU_M16C
:
4529 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4532 size_t expected_entsize \
4533 = is_32bit_elf ? size32 : size64; \
4534 if (section->sh_entsize != expected_entsize) \
4535 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4536 i, (unsigned long int) section->sh_entsize, \
4537 (unsigned long int) expected_entsize); \
4538 section->sh_entsize = expected_entsize; \
4541 #define CHECK_ENTSIZE(section, i, type) \
4542 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4543 sizeof (Elf64_External_##type))
4545 for (i
= 0, section
= section_headers
;
4546 i
< elf_header
.e_shnum
;
4549 char * name
= SECTION_NAME (section
);
4551 if (section
->sh_type
== SHT_DYNSYM
)
4553 if (dynamic_symbols
!= NULL
)
4555 error (_("File contains multiple dynamic symbol tables\n"));
4559 CHECK_ENTSIZE (section
, i
, Sym
);
4560 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4561 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4563 else if (section
->sh_type
== SHT_STRTAB
4564 && streq (name
, ".dynstr"))
4566 if (dynamic_strings
!= NULL
)
4568 error (_("File contains multiple dynamic string tables\n"));
4572 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4573 1, section
->sh_size
,
4574 _("dynamic strings"));
4575 dynamic_strings_length
= section
->sh_size
;
4577 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4579 if (symtab_shndx_hdr
!= NULL
)
4581 error (_("File contains multiple symtab shndx tables\n"));
4584 symtab_shndx_hdr
= section
;
4586 else if (section
->sh_type
== SHT_SYMTAB
)
4587 CHECK_ENTSIZE (section
, i
, Sym
);
4588 else if (section
->sh_type
== SHT_GROUP
)
4589 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4590 else if (section
->sh_type
== SHT_REL
)
4591 CHECK_ENTSIZE (section
, i
, Rel
);
4592 else if (section
->sh_type
== SHT_RELA
)
4593 CHECK_ENTSIZE (section
, i
, Rela
);
4594 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4595 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
4596 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
4597 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
)
4598 && (const_strneq (name
, ".debug_")
4599 || const_strneq (name
, ".zdebug_")))
4602 name
+= sizeof (".zdebug_") - 1;
4604 name
+= sizeof (".debug_") - 1;
4607 || (do_debug_info
&& streq (name
, "info"))
4608 || (do_debug_info
&& streq (name
, "types"))
4609 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4610 || (do_debug_lines
&& streq (name
, "line"))
4611 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4612 || (do_debug_pubtypes
&& streq (name
, "pubtypes"))
4613 || (do_debug_aranges
&& streq (name
, "aranges"))
4614 || (do_debug_ranges
&& streq (name
, "ranges"))
4615 || (do_debug_frames
&& streq (name
, "frame"))
4616 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4617 || (do_debug_str
&& streq (name
, "str"))
4618 || (do_debug_loc
&& streq (name
, "loc"))
4620 request_dump_bynumber (i
, DEBUG_DUMP
);
4622 /* Linkonce section to be combined with .debug_info at link time. */
4623 else if ((do_debugging
|| do_debug_info
)
4624 && const_strneq (name
, ".gnu.linkonce.wi."))
4625 request_dump_bynumber (i
, DEBUG_DUMP
);
4626 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4627 request_dump_bynumber (i
, DEBUG_DUMP
);
4628 /* Trace sections for Itanium VMS. */
4629 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
4630 || do_trace_aranges
)
4631 && const_strneq (name
, ".trace_"))
4633 name
+= sizeof (".trace_") - 1;
4636 || (do_trace_info
&& streq (name
, "info"))
4637 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
4638 || (do_trace_aranges
&& streq (name
, "aranges"))
4640 request_dump_bynumber (i
, DEBUG_DUMP
);
4648 if (elf_header
.e_shnum
> 1)
4649 printf (_("\nSection Headers:\n"));
4651 printf (_("\nSection Header:\n"));
4655 if (do_section_details
)
4657 printf (_(" [Nr] Name\n"));
4658 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4662 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4666 if (do_section_details
)
4668 printf (_(" [Nr] Name\n"));
4669 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4673 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4677 if (do_section_details
)
4679 printf (_(" [Nr] Name\n"));
4680 printf (_(" Type Address Offset Link\n"));
4681 printf (_(" Size EntSize Info Align\n"));
4685 printf (_(" [Nr] Name Type Address Offset\n"));
4686 printf (_(" Size EntSize Flags Link Info Align\n"));
4690 if (do_section_details
)
4691 printf (_(" Flags\n"));
4693 for (i
= 0, section
= section_headers
;
4694 i
< elf_header
.e_shnum
;
4697 if (do_section_details
)
4699 printf (" [%2u] %s\n",
4701 SECTION_NAME (section
));
4702 if (is_32bit_elf
|| do_wide
)
4703 printf (" %-15.15s ",
4704 get_section_type_name (section
->sh_type
));
4707 printf ((do_wide
? " [%2u] %-17s %-15s "
4708 : " [%2u] %-17.17s %-15.15s "),
4710 SECTION_NAME (section
),
4711 get_section_type_name (section
->sh_type
));
4715 const char * link_too_big
= NULL
;
4717 print_vma (section
->sh_addr
, LONG_HEX
);
4719 printf ( " %6.6lx %6.6lx %2.2lx",
4720 (unsigned long) section
->sh_offset
,
4721 (unsigned long) section
->sh_size
,
4722 (unsigned long) section
->sh_entsize
);
4724 if (do_section_details
)
4725 fputs (" ", stdout
);
4727 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4729 if (section
->sh_link
>= elf_header
.e_shnum
)
4732 /* The sh_link value is out of range. Normally this indicates
4733 an error but it can have special values in Solaris binaries. */
4734 switch (elf_header
.e_machine
)
4740 case EM_OLD_SPARCV9
:
4741 case EM_SPARC32PLUS
:
4744 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
4745 link_too_big
= "BEFORE";
4746 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
4747 link_too_big
= "AFTER";
4754 if (do_section_details
)
4756 if (link_too_big
!= NULL
&& * link_too_big
)
4757 printf ("<%s> ", link_too_big
);
4759 printf ("%2u ", section
->sh_link
);
4760 printf ("%3u %2lu\n", section
->sh_info
,
4761 (unsigned long) section
->sh_addralign
);
4764 printf ("%2u %3u %2lu\n",
4767 (unsigned long) section
->sh_addralign
);
4769 if (link_too_big
&& ! * link_too_big
)
4770 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4771 i
, section
->sh_link
);
4775 print_vma (section
->sh_addr
, LONG_HEX
);
4777 if ((long) section
->sh_offset
== section
->sh_offset
)
4778 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4782 print_vma (section
->sh_offset
, LONG_HEX
);
4785 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4786 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4790 print_vma (section
->sh_size
, LONG_HEX
);
4793 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4794 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4798 print_vma (section
->sh_entsize
, LONG_HEX
);
4801 if (do_section_details
)
4802 fputs (" ", stdout
);
4804 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4806 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
4808 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4809 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
4812 print_vma (section
->sh_addralign
, DEC
);
4816 else if (do_section_details
)
4818 printf (" %-15.15s ",
4819 get_section_type_name (section
->sh_type
));
4820 print_vma (section
->sh_addr
, LONG_HEX
);
4821 if ((long) section
->sh_offset
== section
->sh_offset
)
4822 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4826 print_vma (section
->sh_offset
, LONG_HEX
);
4828 printf (" %u\n ", section
->sh_link
);
4829 print_vma (section
->sh_size
, LONG_HEX
);
4831 print_vma (section
->sh_entsize
, LONG_HEX
);
4833 printf (" %-16u %lu\n",
4835 (unsigned long) section
->sh_addralign
);
4840 print_vma (section
->sh_addr
, LONG_HEX
);
4841 if ((long) section
->sh_offset
== section
->sh_offset
)
4842 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4846 print_vma (section
->sh_offset
, LONG_HEX
);
4849 print_vma (section
->sh_size
, LONG_HEX
);
4851 print_vma (section
->sh_entsize
, LONG_HEX
);
4853 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4855 printf (" %2u %3u %lu\n",
4858 (unsigned long) section
->sh_addralign
);
4861 if (do_section_details
)
4862 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4865 if (!do_section_details
)
4867 if (elf_header
.e_machine
== EM_X86_64
4868 || elf_header
.e_machine
== EM_L1OM
)
4869 printf (_("Key to Flags:\n\
4870 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
4871 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
4872 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4874 printf (_("Key to Flags:\n\
4875 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4876 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
4877 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4884 get_group_flags (unsigned int flags
)
4886 static char buff
[32];
4896 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
4903 process_section_groups (FILE * file
)
4905 Elf_Internal_Shdr
* section
;
4907 struct group
* group
;
4908 Elf_Internal_Shdr
* symtab_sec
;
4909 Elf_Internal_Shdr
* strtab_sec
;
4910 Elf_Internal_Sym
* symtab
;
4914 /* Don't process section groups unless needed. */
4915 if (!do_unwind
&& !do_section_groups
)
4918 if (elf_header
.e_shnum
== 0)
4920 if (do_section_groups
)
4921 printf (_("\nThere are no sections in this file.\n"));
4926 if (section_headers
== NULL
)
4928 error (_("Section headers are not available!\n"));
4932 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
4933 sizeof (struct group
*));
4935 if (section_headers_groups
== NULL
)
4937 error (_("Out of memory\n"));
4941 /* Scan the sections for the group section. */
4943 for (i
= 0, section
= section_headers
;
4944 i
< elf_header
.e_shnum
;
4946 if (section
->sh_type
== SHT_GROUP
)
4949 if (group_count
== 0)
4951 if (do_section_groups
)
4952 printf (_("\nThere are no section groups in this file.\n"));
4957 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
4959 if (section_groups
== NULL
)
4961 error (_("Out of memory\n"));
4970 for (i
= 0, section
= section_headers
, group
= section_groups
;
4971 i
< elf_header
.e_shnum
;
4974 if (section
->sh_type
== SHT_GROUP
)
4976 char * name
= SECTION_NAME (section
);
4978 unsigned char * start
;
4979 unsigned char * indices
;
4980 unsigned int entry
, j
, size
;
4981 Elf_Internal_Shdr
* sec
;
4982 Elf_Internal_Sym
* sym
;
4984 /* Get the symbol table. */
4985 if (section
->sh_link
>= elf_header
.e_shnum
4986 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
4989 error (_("Bad sh_link in group section `%s'\n"), name
);
4993 if (symtab_sec
!= sec
)
4998 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
5003 error (_("Corrupt header in group section `%s'\n"), name
);
5007 sym
= symtab
+ section
->sh_info
;
5009 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
5011 if (sym
->st_shndx
== 0
5012 || sym
->st_shndx
>= elf_header
.e_shnum
)
5014 error (_("Bad sh_info in group section `%s'\n"), name
);
5018 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
5027 /* Get the string table. */
5028 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
5037 != (sec
= section_headers
+ symtab_sec
->sh_link
))
5042 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
5043 1, strtab_sec
->sh_size
,
5045 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
5047 group_name
= sym
->st_name
< strtab_size
5048 ? strtab
+ sym
->st_name
: _("<corrupt>");
5051 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
5052 1, section
->sh_size
,
5056 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
5057 entry
= byte_get (indices
, 4);
5060 if (do_section_groups
)
5062 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5063 get_group_flags (entry
), i
, name
, group_name
, size
);
5065 printf (_(" [Index] Name\n"));
5068 group
->group_index
= i
;
5070 for (j
= 0; j
< size
; j
++)
5072 struct group_list
* g
;
5074 entry
= byte_get (indices
, 4);
5077 if (entry
>= elf_header
.e_shnum
)
5079 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5080 entry
, i
, elf_header
.e_shnum
- 1);
5084 if (section_headers_groups
[entry
] != NULL
)
5088 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5090 section_headers_groups
[entry
]->group_index
);
5095 /* Intel C/C++ compiler may put section 0 in a
5096 section group. We just warn it the first time
5097 and ignore it afterwards. */
5098 static int warned
= 0;
5101 error (_("section 0 in group section [%5u]\n"),
5102 section_headers_groups
[entry
]->group_index
);
5108 section_headers_groups
[entry
] = group
;
5110 if (do_section_groups
)
5112 sec
= section_headers
+ entry
;
5113 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
5116 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
5117 g
->section_index
= entry
;
5118 g
->next
= group
->root
;
5136 /* Data used to display dynamic fixups. */
5138 struct ia64_vms_dynfixup
5140 bfd_vma needed_ident
; /* Library ident number. */
5141 bfd_vma needed
; /* Index in the dstrtab of the library name. */
5142 bfd_vma fixup_needed
; /* Index of the library. */
5143 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
5144 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
5147 /* Data used to display dynamic relocations. */
5149 struct ia64_vms_dynimgrela
5151 bfd_vma img_rela_cnt
; /* Number of relocations. */
5152 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
5155 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5159 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
5160 const char *strtab
, unsigned int strtab_sz
)
5162 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
5164 const char *lib_name
;
5166 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
5167 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
5168 _("dynamic section image fixups"));
5172 if (fixup
->needed
< strtab_sz
)
5173 lib_name
= strtab
+ fixup
->needed
;
5176 warn ("corrupt library name index of 0x%lx found in dynamic entry",
5177 (unsigned long) fixup
->needed
);
5180 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5181 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
5183 (_("Seg Offset Type SymVec DataType\n"));
5185 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
5190 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
5191 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
5192 type
= BYTE_GET (imfs
[i
].type
);
5193 rtype
= elf_ia64_reloc_type (type
);
5195 printf (" 0x%08x ", type
);
5197 printf (" %-32s ", rtype
);
5198 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
5199 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
5205 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5208 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
5210 Elf64_External_VMS_IMAGE_RELA
*imrs
;
5213 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
5214 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
5215 _("dynamic section image relas"));
5219 printf (_("\nImage relocs\n"));
5221 (_("Seg Offset Type Addend Seg Sym Off\n"));
5223 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
5228 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
5229 printf ("%08" BFD_VMA_FMT
"x ",
5230 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
5231 type
= BYTE_GET (imrs
[i
].type
);
5232 rtype
= elf_ia64_reloc_type (type
);
5234 printf ("0x%08x ", type
);
5236 printf ("%-31s ", rtype
);
5237 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
5238 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
5239 printf ("%08" BFD_VMA_FMT
"x\n",
5240 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
5246 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
5249 process_ia64_vms_dynamic_relocs (FILE *file
)
5251 struct ia64_vms_dynfixup fixup
;
5252 struct ia64_vms_dynimgrela imgrela
;
5253 Elf_Internal_Dyn
*entry
;
5255 bfd_vma strtab_off
= 0;
5256 bfd_vma strtab_sz
= 0;
5257 char *strtab
= NULL
;
5259 memset (&fixup
, 0, sizeof (fixup
));
5260 memset (&imgrela
, 0, sizeof (imgrela
));
5262 /* Note: the order of the entries is specified by the OpenVMS specs. */
5263 for (entry
= dynamic_section
;
5264 entry
< dynamic_section
+ dynamic_nent
;
5267 switch (entry
->d_tag
)
5269 case DT_IA_64_VMS_STRTAB_OFFSET
:
5270 strtab_off
= entry
->d_un
.d_val
;
5273 strtab_sz
= entry
->d_un
.d_val
;
5275 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
5276 1, strtab_sz
, _("dynamic string section"));
5279 case DT_IA_64_VMS_NEEDED_IDENT
:
5280 fixup
.needed_ident
= entry
->d_un
.d_val
;
5283 fixup
.needed
= entry
->d_un
.d_val
;
5285 case DT_IA_64_VMS_FIXUP_NEEDED
:
5286 fixup
.fixup_needed
= entry
->d_un
.d_val
;
5288 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
5289 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
5291 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
5292 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
5294 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
5297 case DT_IA_64_VMS_IMG_RELA_CNT
:
5298 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
5300 case DT_IA_64_VMS_IMG_RELA_OFF
:
5301 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
5303 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
5323 } dynamic_relocations
[] =
5325 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
5326 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
5327 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
5330 /* Process the reloc section. */
5333 process_relocs (FILE * file
)
5335 unsigned long rel_size
;
5336 unsigned long rel_offset
;
5342 if (do_using_dynamic
)
5346 int has_dynamic_reloc
;
5349 has_dynamic_reloc
= 0;
5351 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
5353 is_rela
= dynamic_relocations
[i
].rela
;
5354 name
= dynamic_relocations
[i
].name
;
5355 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
5356 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
5358 has_dynamic_reloc
|= rel_size
;
5360 if (is_rela
== UNKNOWN
)
5362 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
5363 switch (dynamic_info
[DT_PLTREL
])
5377 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5378 name
, rel_offset
, rel_size
);
5380 dump_relocations (file
,
5381 offset_from_vma (file
, rel_offset
, rel_size
),
5383 dynamic_symbols
, num_dynamic_syms
,
5384 dynamic_strings
, dynamic_strings_length
, is_rela
);
5389 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
5391 if (! has_dynamic_reloc
)
5392 printf (_("\nThere are no dynamic relocations in this file.\n"));
5396 Elf_Internal_Shdr
* section
;
5400 for (i
= 0, section
= section_headers
;
5401 i
< elf_header
.e_shnum
;
5404 if ( section
->sh_type
!= SHT_RELA
5405 && section
->sh_type
!= SHT_REL
)
5408 rel_offset
= section
->sh_offset
;
5409 rel_size
= section
->sh_size
;
5413 Elf_Internal_Shdr
* strsec
;
5416 printf (_("\nRelocation section "));
5418 if (string_table
== NULL
)
5419 printf ("%d", section
->sh_name
);
5421 printf (_("'%s'"), SECTION_NAME (section
));
5423 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5424 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
5426 is_rela
= section
->sh_type
== SHT_RELA
;
5428 if (section
->sh_link
!= 0
5429 && section
->sh_link
< elf_header
.e_shnum
)
5431 Elf_Internal_Shdr
* symsec
;
5432 Elf_Internal_Sym
* symtab
;
5433 unsigned long nsyms
;
5434 unsigned long strtablen
= 0;
5435 char * strtab
= NULL
;
5437 symsec
= section_headers
+ section
->sh_link
;
5438 if (symsec
->sh_type
!= SHT_SYMTAB
5439 && symsec
->sh_type
!= SHT_DYNSYM
)
5442 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
5443 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
5448 if (symsec
->sh_link
!= 0
5449 && symsec
->sh_link
< elf_header
.e_shnum
)
5451 strsec
= section_headers
+ symsec
->sh_link
;
5453 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5456 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
5459 dump_relocations (file
, rel_offset
, rel_size
,
5460 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
5466 dump_relocations (file
, rel_offset
, rel_size
,
5467 NULL
, 0, NULL
, 0, is_rela
);
5474 printf (_("\nThere are no relocations in this file.\n"));
5480 /* Process the unwind section. */
5482 #include "unwind-ia64.h"
5484 /* An absolute address consists of a section and an offset. If the
5485 section is NULL, the offset itself is the address, otherwise, the
5486 address equals to LOAD_ADDRESS(section) + offset. */
5490 unsigned short section
;
5494 #define ABSADDR(a) \
5496 ? section_headers [(a).section].sh_addr + (a).offset \
5499 struct ia64_unw_table_entry
5501 struct absaddr start
;
5503 struct absaddr info
;
5506 struct ia64_unw_aux_info
5509 struct ia64_unw_table_entry
*table
; /* Unwind table. */
5510 unsigned long table_len
; /* Length of unwind table. */
5511 unsigned char * info
; /* Unwind info. */
5512 unsigned long info_size
; /* Size of unwind info. */
5513 bfd_vma info_addr
; /* starting address of unwind info. */
5514 bfd_vma seg_base
; /* Starting address of segment. */
5515 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5516 unsigned long nsyms
; /* Number of symbols. */
5517 char * strtab
; /* The string table. */
5518 unsigned long strtab_size
; /* Size of string table. */
5522 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
5523 unsigned long nsyms
,
5524 const char * strtab
,
5525 unsigned long strtab_size
,
5526 struct absaddr addr
,
5527 const char ** symname
,
5530 bfd_vma dist
= 0x100000;
5531 Elf_Internal_Sym
* sym
;
5532 Elf_Internal_Sym
* best
= NULL
;
5535 REMOVE_ARCH_BITS (addr
.offset
);
5537 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
5539 bfd_vma value
= sym
->st_value
;
5541 REMOVE_ARCH_BITS (value
);
5543 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
5544 && sym
->st_name
!= 0
5545 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
5546 && addr
.offset
>= value
5547 && addr
.offset
- value
< dist
)
5550 dist
= addr
.offset
- value
;
5557 *symname
= (best
->st_name
>= strtab_size
5558 ? _("<corrupt>") : strtab
+ best
->st_name
);
5563 *offset
= addr
.offset
;
5567 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
5569 struct ia64_unw_table_entry
* tp
;
5572 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5576 const unsigned char * dp
;
5577 const unsigned char * head
;
5578 const char * procname
;
5580 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5581 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
5583 fputs ("\n<", stdout
);
5587 fputs (procname
, stdout
);
5590 printf ("+%lx", (unsigned long) offset
);
5593 fputs (">: [", stdout
);
5594 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5595 fputc ('-', stdout
);
5596 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5597 printf ("], info at +0x%lx\n",
5598 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
5600 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
5601 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
5603 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5604 (unsigned) UNW_VER (stamp
),
5605 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
5606 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
5607 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
5608 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
5610 if (UNW_VER (stamp
) != 1)
5612 printf (_("\tUnknown version.\n"));
5617 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
5618 dp
= unw_decode (dp
, in_body
, & in_body
);
5623 slurp_ia64_unwind_table (FILE * file
,
5624 struct ia64_unw_aux_info
* aux
,
5625 Elf_Internal_Shdr
* sec
)
5627 unsigned long size
, nrelas
, i
;
5628 Elf_Internal_Phdr
* seg
;
5629 struct ia64_unw_table_entry
* tep
;
5630 Elf_Internal_Shdr
* relsec
;
5631 Elf_Internal_Rela
* rela
;
5632 Elf_Internal_Rela
* rp
;
5633 unsigned char * table
;
5635 Elf_Internal_Sym
* sym
;
5636 const char * relname
;
5638 /* First, find the starting address of the segment that includes
5641 if (elf_header
.e_phnum
)
5643 if (! get_program_headers (file
))
5646 for (seg
= program_headers
;
5647 seg
< program_headers
+ elf_header
.e_phnum
;
5650 if (seg
->p_type
!= PT_LOAD
)
5653 if (sec
->sh_addr
>= seg
->p_vaddr
5654 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5656 aux
->seg_base
= seg
->p_vaddr
;
5662 /* Second, build the unwind table from the contents of the unwind section: */
5663 size
= sec
->sh_size
;
5664 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
5669 aux
->table
= (struct ia64_unw_table_entry
*)
5670 xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
5672 for (tp
= table
; tp
< table
+ size
; ++tep
)
5674 tep
->start
.section
= SHN_UNDEF
;
5675 tep
->end
.section
= SHN_UNDEF
;
5676 tep
->info
.section
= SHN_UNDEF
;
5677 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5678 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5679 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5680 tep
->start
.offset
+= aux
->seg_base
;
5681 tep
->end
.offset
+= aux
->seg_base
;
5682 tep
->info
.offset
+= aux
->seg_base
;
5686 /* Third, apply any relocations to the unwind table: */
5687 for (relsec
= section_headers
;
5688 relsec
< section_headers
+ elf_header
.e_shnum
;
5691 if (relsec
->sh_type
!= SHT_RELA
5692 || relsec
->sh_info
>= elf_header
.e_shnum
5693 || section_headers
+ relsec
->sh_info
!= sec
)
5696 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5700 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5702 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5703 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5705 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5707 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5711 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5713 switch (rp
->r_offset
/eh_addr_size
% 3)
5716 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5717 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
5720 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5721 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
5724 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5725 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
5735 aux
->table_len
= size
/ (3 * eh_addr_size
);
5740 ia64_process_unwind (FILE * file
)
5742 Elf_Internal_Shdr
* sec
;
5743 Elf_Internal_Shdr
* unwsec
= NULL
;
5744 Elf_Internal_Shdr
* strsec
;
5745 unsigned long i
, unwcount
= 0, unwstart
= 0;
5746 struct ia64_unw_aux_info aux
;
5748 memset (& aux
, 0, sizeof (aux
));
5750 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5752 if (sec
->sh_type
== SHT_SYMTAB
5753 && sec
->sh_link
< elf_header
.e_shnum
)
5755 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5756 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5758 strsec
= section_headers
+ sec
->sh_link
;
5759 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5762 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5764 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5769 printf (_("\nThere are no unwind sections in this file.\n"));
5771 while (unwcount
-- > 0)
5776 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5777 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5778 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5785 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5787 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5789 /* We need to find which section group it is in. */
5790 struct group_list
* g
= section_headers_groups
[i
]->root
;
5792 for (; g
!= NULL
; g
= g
->next
)
5794 sec
= section_headers
+ g
->section_index
;
5796 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5801 i
= elf_header
.e_shnum
;
5803 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5805 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5806 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5807 suffix
= SECTION_NAME (unwsec
) + len
;
5808 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5810 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5811 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5816 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5817 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5818 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5819 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5821 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
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
, len2
)
5826 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5830 if (i
== elf_header
.e_shnum
)
5832 printf (_("\nCould not find unwind info section for "));
5834 if (string_table
== NULL
)
5835 printf ("%d", unwsec
->sh_name
);
5837 printf (_("'%s'"), SECTION_NAME (unwsec
));
5841 aux
.info_size
= sec
->sh_size
;
5842 aux
.info_addr
= sec
->sh_addr
;
5843 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
5847 printf (_("\nUnwind section "));
5849 if (string_table
== NULL
)
5850 printf ("%d", unwsec
->sh_name
);
5852 printf (_("'%s'"), SECTION_NAME (unwsec
));
5854 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5855 (unsigned long) unwsec
->sh_offset
,
5856 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5858 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5860 if (aux
.table_len
> 0)
5861 dump_ia64_unwind (& aux
);
5864 free ((char *) aux
.table
);
5866 free ((char *) aux
.info
);
5875 free ((char *) aux
.strtab
);
5880 struct hppa_unw_table_entry
5882 struct absaddr start
;
5884 unsigned int Cannot_unwind
:1; /* 0 */
5885 unsigned int Millicode
:1; /* 1 */
5886 unsigned int Millicode_save_sr0
:1; /* 2 */
5887 unsigned int Region_description
:2; /* 3..4 */
5888 unsigned int reserved1
:1; /* 5 */
5889 unsigned int Entry_SR
:1; /* 6 */
5890 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5891 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5892 unsigned int Args_stored
:1; /* 16 */
5893 unsigned int Variable_Frame
:1; /* 17 */
5894 unsigned int Separate_Package_Body
:1; /* 18 */
5895 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5896 unsigned int Stack_Overflow_Check
:1; /* 20 */
5897 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5898 unsigned int Ada_Region
:1; /* 22 */
5899 unsigned int cxx_info
:1; /* 23 */
5900 unsigned int cxx_try_catch
:1; /* 24 */
5901 unsigned int sched_entry_seq
:1; /* 25 */
5902 unsigned int reserved2
:1; /* 26 */
5903 unsigned int Save_SP
:1; /* 27 */
5904 unsigned int Save_RP
:1; /* 28 */
5905 unsigned int Save_MRP_in_frame
:1; /* 29 */
5906 unsigned int extn_ptr_defined
:1; /* 30 */
5907 unsigned int Cleanup_defined
:1; /* 31 */
5909 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5910 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5911 unsigned int Large_frame
:1; /* 2 */
5912 unsigned int Pseudo_SP_Set
:1; /* 3 */
5913 unsigned int reserved4
:1; /* 4 */
5914 unsigned int Total_frame_size
:27; /* 5..31 */
5917 struct hppa_unw_aux_info
5919 struct hppa_unw_table_entry
*table
; /* Unwind table. */
5920 unsigned long table_len
; /* Length of unwind table. */
5921 bfd_vma seg_base
; /* Starting address of segment. */
5922 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5923 unsigned long nsyms
; /* Number of symbols. */
5924 char * strtab
; /* The string table. */
5925 unsigned long strtab_size
; /* Size of string table. */
5929 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
5931 struct hppa_unw_table_entry
* tp
;
5933 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5936 const char * procname
;
5938 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5939 aux
->strtab_size
, tp
->start
, &procname
,
5942 fputs ("\n<", stdout
);
5946 fputs (procname
, stdout
);
5949 printf ("+%lx", (unsigned long) offset
);
5952 fputs (">: [", stdout
);
5953 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5954 fputc ('-', stdout
);
5955 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5958 #define PF(_m) if (tp->_m) printf (#_m " ");
5959 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5962 PF(Millicode_save_sr0
);
5963 /* PV(Region_description); */
5969 PF(Separate_Package_Body
);
5970 PF(Frame_Extension_Millicode
);
5971 PF(Stack_Overflow_Check
);
5972 PF(Two_Instruction_SP_Increment
);
5976 PF(sched_entry_seq
);
5979 PF(Save_MRP_in_frame
);
5980 PF(extn_ptr_defined
);
5981 PF(Cleanup_defined
);
5982 PF(MPE_XL_interrupt_marker
);
5983 PF(HP_UX_interrupt_marker
);
5986 PV(Total_frame_size
);
5995 slurp_hppa_unwind_table (FILE * file
,
5996 struct hppa_unw_aux_info
* aux
,
5997 Elf_Internal_Shdr
* sec
)
5999 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
6000 Elf_Internal_Phdr
* seg
;
6001 struct hppa_unw_table_entry
* tep
;
6002 Elf_Internal_Shdr
* relsec
;
6003 Elf_Internal_Rela
* rela
;
6004 Elf_Internal_Rela
* rp
;
6005 unsigned char * table
;
6007 Elf_Internal_Sym
* sym
;
6008 const char * relname
;
6010 /* First, find the starting address of the segment that includes
6013 if (elf_header
.e_phnum
)
6015 if (! get_program_headers (file
))
6018 for (seg
= program_headers
;
6019 seg
< program_headers
+ elf_header
.e_phnum
;
6022 if (seg
->p_type
!= PT_LOAD
)
6025 if (sec
->sh_addr
>= seg
->p_vaddr
6026 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6028 aux
->seg_base
= seg
->p_vaddr
;
6034 /* Second, build the unwind table from the contents of the unwind
6036 size
= sec
->sh_size
;
6037 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6043 nentries
= size
/ unw_ent_size
;
6044 size
= unw_ent_size
* nentries
;
6046 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
6047 xcmalloc (nentries
, sizeof (aux
->table
[0]));
6049 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
6051 unsigned int tmp1
, tmp2
;
6053 tep
->start
.section
= SHN_UNDEF
;
6054 tep
->end
.section
= SHN_UNDEF
;
6056 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
6057 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
6058 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
6059 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
6061 tep
->start
.offset
+= aux
->seg_base
;
6062 tep
->end
.offset
+= aux
->seg_base
;
6064 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
6065 tep
->Millicode
= (tmp1
>> 30) & 0x1;
6066 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
6067 tep
->Region_description
= (tmp1
>> 27) & 0x3;
6068 tep
->reserved1
= (tmp1
>> 26) & 0x1;
6069 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
6070 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
6071 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
6072 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
6073 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
6074 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
6075 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
6076 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
6077 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
6078 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
6079 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
6080 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
6081 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
6082 tep
->reserved2
= (tmp1
>> 5) & 0x1;
6083 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
6084 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
6085 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
6086 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
6087 tep
->Cleanup_defined
= tmp1
& 0x1;
6089 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
6090 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
6091 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
6092 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
6093 tep
->reserved4
= (tmp2
>> 27) & 0x1;
6094 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
6098 /* Third, apply any relocations to the unwind table. */
6099 for (relsec
= section_headers
;
6100 relsec
< section_headers
+ elf_header
.e_shnum
;
6103 if (relsec
->sh_type
!= SHT_RELA
6104 || relsec
->sh_info
>= elf_header
.e_shnum
6105 || section_headers
+ relsec
->sh_info
!= sec
)
6108 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6112 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6114 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
6115 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6117 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
6118 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
6120 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6124 i
= rp
->r_offset
/ unw_ent_size
;
6126 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
6129 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6130 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
6133 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6134 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
6144 aux
->table_len
= nentries
;
6150 hppa_process_unwind (FILE * file
)
6152 struct hppa_unw_aux_info aux
;
6153 Elf_Internal_Shdr
* unwsec
= NULL
;
6154 Elf_Internal_Shdr
* strsec
;
6155 Elf_Internal_Shdr
* sec
;
6158 memset (& aux
, 0, sizeof (aux
));
6160 if (string_table
== NULL
)
6163 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6165 if (sec
->sh_type
== SHT_SYMTAB
6166 && sec
->sh_link
< elf_header
.e_shnum
)
6168 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
6169 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
6171 strsec
= section_headers
+ sec
->sh_link
;
6172 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6175 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6177 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6182 printf (_("\nThere are no unwind sections in this file.\n"));
6184 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6186 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6188 printf (_("\nUnwind section "));
6189 printf (_("'%s'"), SECTION_NAME (sec
));
6191 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6192 (unsigned long) sec
->sh_offset
,
6193 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
6195 slurp_hppa_unwind_table (file
, &aux
, sec
);
6196 if (aux
.table_len
> 0)
6197 dump_hppa_unwind (&aux
);
6200 free ((char *) aux
.table
);
6208 free ((char *) aux
.strtab
);
6215 unsigned char *data
;
6217 Elf_Internal_Shdr
*sec
;
6218 Elf_Internal_Rela
*rela
;
6219 unsigned long nrelas
;
6220 unsigned int rel_type
;
6222 Elf_Internal_Rela
*next_rela
;
6225 struct arm_unw_aux_info
6229 Elf_Internal_Sym
*symtab
; /* The symbol table. */
6230 unsigned long nsyms
; /* Number of symbols. */
6231 char *strtab
; /* The string table. */
6232 unsigned long strtab_size
; /* Size of string table. */
6236 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
6237 bfd_vma fn
, struct absaddr addr
)
6239 const char *procname
;
6242 if (addr
.section
== SHN_UNDEF
)
6245 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6246 aux
->strtab_size
, addr
, &procname
,
6249 print_vma (fn
, PREFIX_HEX
);
6253 fputs (" <", stdout
);
6254 fputs (procname
, stdout
);
6257 printf ("+0x%lx", (unsigned long) sym_offset
);
6258 fputc ('>', stdout
);
6265 arm_free_section (struct arm_section
*arm_sec
)
6267 if (arm_sec
->data
!= NULL
)
6268 free (arm_sec
->data
);
6270 if (arm_sec
->rela
!= NULL
)
6271 free (arm_sec
->rela
);
6275 arm_section_get_word (struct arm_unw_aux_info
*aux
,
6276 struct arm_section
*arm_sec
,
6277 Elf_Internal_Shdr
*sec
, bfd_vma word_offset
,
6278 unsigned int *wordp
, struct absaddr
*addr
)
6280 Elf_Internal_Rela
*rp
;
6281 Elf_Internal_Sym
*sym
;
6282 const char * relname
;
6284 bfd_boolean wrapped
;
6286 addr
->section
= SHN_UNDEF
;
6289 if (sec
!= arm_sec
->sec
)
6291 Elf_Internal_Shdr
*relsec
;
6293 arm_free_section (arm_sec
);
6296 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
6297 sec
->sh_size
, _("unwind data"));
6299 arm_sec
->rela
= NULL
;
6300 arm_sec
->nrelas
= 0;
6302 for (relsec
= section_headers
;
6303 relsec
< section_headers
+ elf_header
.e_shnum
;
6306 if (relsec
->sh_info
>= elf_header
.e_shnum
6307 || section_headers
+ relsec
->sh_info
!= sec
)
6310 if (relsec
->sh_type
== SHT_REL
)
6312 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
6314 & arm_sec
->rela
, & arm_sec
->nrelas
))
6318 else if (relsec
->sh_type
== SHT_RELA
)
6320 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
6322 & arm_sec
->rela
, & arm_sec
->nrelas
))
6328 arm_sec
->next_rela
= arm_sec
->rela
;
6331 if (arm_sec
->data
== NULL
)
6334 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
6337 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
6339 bfd_vma prelval
, offset
;
6341 if (rp
->r_offset
> word_offset
&& !wrapped
)
6346 if (rp
->r_offset
> word_offset
)
6349 if (rp
->r_offset
& 3)
6351 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6352 (unsigned long) rp
->r_offset
);
6356 if (rp
->r_offset
< word_offset
)
6359 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
6361 if (streq (relname
, "R_ARM_NONE"))
6364 if (! streq (relname
, "R_ARM_PREL31"))
6366 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6370 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
6372 if (arm_sec
->rel_type
== SHT_REL
)
6374 offset
= word
& 0x7fffffff;
6375 if (offset
& 0x40000000)
6376 offset
|= ~ (bfd_vma
) 0x7fffffff;
6379 offset
= rp
->r_addend
;
6381 offset
+= sym
->st_value
;
6382 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
6384 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
6385 addr
->section
= sym
->st_shndx
;
6386 addr
->offset
= offset
;
6391 arm_sec
->next_rela
= rp
;
6397 decode_arm_unwind (struct arm_unw_aux_info
*aux
,
6398 unsigned int word
, unsigned int remaining
,
6399 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
6400 struct arm_section
*data_arm_sec
)
6403 unsigned int more_words
;
6404 struct absaddr addr
;
6407 if (remaining == 0 && more_words) \
6410 if (!arm_section_get_word (aux, data_arm_sec, data_sec, \
6411 data_offset, &word, &addr)) \
6417 #define GET_OP(OP) \
6422 (OP) = word >> 24; \
6427 printf (_("[Truncated opcode]\n")); \
6430 printf (_("0x%02x "), OP)
6434 /* Fetch the first word. */
6435 if (!arm_section_get_word (aux
, data_arm_sec
, data_sec
, data_offset
,
6441 if ((word
& 0x80000000) == 0)
6443 /* Expand prel31 for personality routine. */
6445 const char *procname
;
6448 if (fn
& 0x40000000)
6449 fn
|= ~ (bfd_vma
) 0x7fffffff;
6450 fn
= fn
+ data_sec
->sh_addr
+ data_offset
;
6452 printf (_(" Personality routine: "));
6453 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
6454 fputc ('\n', stdout
);
6456 /* The GCC personality routines use the standard compact
6457 encoding, starting with one byte giving the number of
6459 if (procname
!= NULL
6460 && (const_strneq (procname
, "__gcc_personality_v0")
6461 || const_strneq (procname
, "__gxx_personality_v0")
6462 || const_strneq (procname
, "__gcj_personality_v0")
6463 || const_strneq (procname
, "__gnu_objc_personality_v0")))
6470 printf (_(" [Truncated data]\n"));
6473 more_words
= word
>> 24;
6482 per_index
= (word
>> 24) & 0x7f;
6483 if (per_index
!= 0 && per_index
!= 1 && per_index
!= 2)
6485 printf (_(" [reserved compact index %d]\n"), per_index
);
6489 printf (_(" Compact model %d\n"), per_index
);
6498 more_words
= (word
>> 16) & 0xff;
6504 /* Decode the unwinding instructions. */
6507 unsigned int op
, op2
;
6516 printf (_(" 0x%02x "), op
);
6518 if ((op
& 0xc0) == 0x00)
6520 int offset
= ((op
& 0x3f) << 2) + 4;
6521 printf (_(" vsp = vsp + %d"), offset
);
6523 else if ((op
& 0xc0) == 0x40)
6525 int offset
= ((op
& 0x3f) << 2) + 4;
6526 printf (_(" vsp = vsp - %d"), offset
);
6528 else if ((op
& 0xf0) == 0x80)
6531 if (op
== 0x80 && op2
== 0)
6532 printf (_("Refuse to unwind"));
6535 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
6540 for (i
= 0; i
< 12; i
++)
6541 if (mask
& (1 << i
))
6547 printf ("r%d", 4 + i
);
6552 else if ((op
& 0xf0) == 0x90)
6554 if (op
== 0x9d || op
== 0x9f)
6555 printf (_(" [Reserved]"));
6557 printf (_(" vsp = r%d"), op
& 0x0f);
6559 else if ((op
& 0xf0) == 0xa0)
6561 int end
= 4 + (op
& 0x07);
6565 for (i
= 4; i
<= end
; i
++)
6581 else if (op
== 0xb0)
6582 printf (_(" finish"));
6583 else if (op
== 0xb1)
6586 if (op2
== 0 || (op2
& 0xf0) != 0)
6587 printf (_("[Spare]"));
6590 unsigned int mask
= op2
& 0x0f;
6594 for (i
= 0; i
< 12; i
++)
6595 if (mask
& (1 << i
))
6606 else if (op
== 0xb2)
6608 unsigned char buf
[9];
6609 unsigned int i
, len
;
6610 unsigned long offset
;
6611 for (i
= 0; i
< sizeof (buf
); i
++)
6614 if ((buf
[i
] & 0x80) == 0)
6617 assert (i
< sizeof (buf
));
6618 offset
= read_uleb128 (buf
, &len
);
6619 assert (len
== i
+ 1);
6620 offset
= offset
* 4 + 0x204;
6621 printf (_("vsp = vsp + %ld"), offset
);
6625 if (op
== 0xb3 || op
== 0xc6 || op
== 0xc7 || op
== 0xc8 || op
== 0xc9)
6628 printf (_("[unsupported two-byte opcode]"));
6632 printf (_(" [unsupported opcode]"));
6638 /* Decode the descriptors. Not implemented. */
6642 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
6644 struct arm_section exidx_arm_sec
, extab_arm_sec
;
6645 unsigned int i
, exidx_len
;
6647 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
6648 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
6649 exidx_len
= exidx_sec
->sh_size
/ 8;
6651 for (i
= 0; i
< exidx_len
; i
++)
6653 unsigned int exidx_fn
, exidx_entry
;
6654 struct absaddr fn_addr
, entry_addr
;
6657 fputc ('\n', stdout
);
6659 if (!arm_section_get_word (aux
, &exidx_arm_sec
, exidx_sec
,
6660 8 * i
, &exidx_fn
, &fn_addr
)
6661 || !arm_section_get_word (aux
, &exidx_arm_sec
, exidx_sec
,
6662 8 * i
+ 4, &exidx_entry
, &entry_addr
))
6664 arm_free_section (&exidx_arm_sec
);
6665 arm_free_section (&extab_arm_sec
);
6669 fn
= exidx_fn
& 0x7fffffff;
6670 if (fn
& 0x40000000)
6671 fn
|= ~ (bfd_vma
) 0x7fffffff;
6672 fn
= fn
+ exidx_sec
->sh_addr
+ 8 * i
;
6674 arm_print_vma_and_name (aux
, fn
, entry_addr
);
6675 fputs (": ", stdout
);
6677 if (exidx_entry
== 1)
6679 print_vma (exidx_entry
, PREFIX_HEX
);
6680 fputs (" [cantunwind]\n", stdout
);
6682 else if (exidx_entry
& 0x80000000)
6684 print_vma (exidx_entry
, PREFIX_HEX
);
6685 fputc ('\n', stdout
);
6686 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
6690 bfd_vma table
, table_offset
= 0;
6691 Elf_Internal_Shdr
*table_sec
;
6693 fputs ("@", stdout
);
6694 table
= exidx_entry
;
6695 if (table
& 0x40000000)
6696 table
|= ~ (bfd_vma
) 0x7fffffff;
6697 table
= table
+ exidx_sec
->sh_addr
+ 8 * i
+ 4;
6698 print_vma (table
, PREFIX_HEX
);
6701 /* Locate the matching .ARM.extab. */
6702 if (entry_addr
.section
!= SHN_UNDEF
6703 && entry_addr
.section
< elf_header
.e_shnum
)
6705 table_sec
= section_headers
+ entry_addr
.section
;
6706 table_offset
= entry_addr
.offset
;
6710 table_sec
= find_section_by_address (table
);
6711 if (table_sec
!= NULL
)
6712 table_offset
= table
- table_sec
->sh_addr
;
6714 if (table_sec
== NULL
)
6716 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
6717 (unsigned long) table
);
6720 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
6727 arm_free_section (&exidx_arm_sec
);
6728 arm_free_section (&extab_arm_sec
);
6732 arm_process_unwind (FILE *file
)
6734 struct arm_unw_aux_info aux
;
6735 Elf_Internal_Shdr
*unwsec
= NULL
;
6736 Elf_Internal_Shdr
*strsec
;
6737 Elf_Internal_Shdr
*sec
;
6740 memset (& aux
, 0, sizeof (aux
));
6743 if (string_table
== NULL
)
6746 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6748 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
6750 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
6751 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
6753 strsec
= section_headers
+ sec
->sh_link
;
6754 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
6755 1, strsec
->sh_size
, _("string table"));
6756 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6758 else if (sec
->sh_type
== SHT_ARM_EXIDX
)
6763 printf (_("\nThere are no unwind sections in this file.\n"));
6765 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6767 if (sec
->sh_type
== SHT_ARM_EXIDX
)
6769 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
6771 (unsigned long) sec
->sh_offset
,
6772 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
6774 dump_arm_unwind (&aux
, sec
);
6781 free ((char *) aux
.strtab
);
6787 process_unwind (FILE * file
)
6789 struct unwind_handler
6792 int (* handler
)(FILE *);
6795 { EM_ARM
, arm_process_unwind
},
6796 { EM_IA_64
, ia64_process_unwind
},
6797 { EM_PARISC
, hppa_process_unwind
},
6805 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
6806 if (elf_header
.e_machine
== handlers
[i
].machtype
)
6807 return handlers
[i
].handler (file
);
6809 printf (_("\nThere are no unwind sections in this file.\n"));
6814 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
6816 switch (entry
->d_tag
)
6819 if (entry
->d_un
.d_val
== 0)
6820 printf (_("NONE\n"));
6823 static const char * opts
[] =
6825 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
6826 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
6827 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
6828 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
6834 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
6835 if (entry
->d_un
.d_val
& (1 << cnt
))
6837 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
6844 case DT_MIPS_IVERSION
:
6845 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6846 printf (_("Interface Version: %s\n"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
6848 printf (_("<corrupt: %ld>\n"), (long) entry
->d_un
.d_ptr
);
6851 case DT_MIPS_TIME_STAMP
:
6856 time_t atime
= entry
->d_un
.d_val
;
6857 tmp
= gmtime (&atime
);
6858 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
6859 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6860 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6861 printf (_("Time Stamp: %s\n"), timebuf
);
6865 case DT_MIPS_RLD_VERSION
:
6866 case DT_MIPS_LOCAL_GOTNO
:
6867 case DT_MIPS_CONFLICTNO
:
6868 case DT_MIPS_LIBLISTNO
:
6869 case DT_MIPS_SYMTABNO
:
6870 case DT_MIPS_UNREFEXTNO
:
6871 case DT_MIPS_HIPAGENO
:
6872 case DT_MIPS_DELTA_CLASS_NO
:
6873 case DT_MIPS_DELTA_INSTANCE_NO
:
6874 case DT_MIPS_DELTA_RELOC_NO
:
6875 case DT_MIPS_DELTA_SYM_NO
:
6876 case DT_MIPS_DELTA_CLASSSYM_NO
:
6877 case DT_MIPS_COMPACT_SIZE
:
6878 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
6882 printf ("%#lx\n", (unsigned long) entry
->d_un
.d_ptr
);
6887 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
6889 switch (entry
->d_tag
)
6891 case DT_HP_DLD_FLAGS
:
6900 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
6901 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
6902 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
6903 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
6904 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
6905 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
6906 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
6907 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
6908 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
6909 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
6910 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
6911 { DT_HP_GST
, "HP_GST" },
6912 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
6913 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
6914 { DT_HP_NODELETE
, "HP_NODELETE" },
6915 { DT_HP_GROUP
, "HP_GROUP" },
6916 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
6920 bfd_vma val
= entry
->d_un
.d_val
;
6922 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
6923 if (val
& flags
[cnt
].bit
)
6927 fputs (flags
[cnt
].str
, stdout
);
6929 val
^= flags
[cnt
].bit
;
6932 if (val
!= 0 || first
)
6936 print_vma (val
, HEX
);
6942 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
6950 /* VMS vs Unix time offset and factor. */
6952 #define VMS_EPOCH_OFFSET 35067168000000000LL
6953 #define VMS_GRANULARITY_FACTOR 10000000
6955 /* Display a VMS time in a human readable format. */
6958 print_vms_time (bfd_int64_t vmstime
)
6963 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
6964 tm
= gmtime (&unxtime
);
6965 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
6966 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
6967 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
6972 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
6974 switch (entry
->d_tag
)
6976 case DT_IA_64_PLT_RESERVE
:
6977 /* First 3 slots reserved. */
6978 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
6980 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
6983 case DT_IA_64_VMS_LINKTIME
:
6985 print_vms_time (entry
->d_un
.d_val
);
6989 case DT_IA_64_VMS_LNKFLAGS
:
6990 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
6991 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
6992 printf (" CALL_DEBUG");
6993 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
6994 printf (" NOP0BUFS");
6995 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
6996 printf (" P0IMAGE");
6997 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
6998 printf (" MKTHREADS");
6999 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
7000 printf (" UPCALLS");
7001 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
7003 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
7004 printf (" INITIALIZE");
7005 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
7007 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
7008 printf (" EXE_INIT");
7009 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
7010 printf (" TBK_IN_IMG");
7011 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
7012 printf (" DBG_IN_IMG");
7013 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
7014 printf (" TBK_IN_DSF");
7015 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
7016 printf (" DBG_IN_DSF");
7017 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
7018 printf (" SIGNATURES");
7019 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
7020 printf (" REL_SEG_OFF");
7024 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7031 get_32bit_dynamic_section (FILE * file
)
7033 Elf32_External_Dyn
* edyn
;
7034 Elf32_External_Dyn
* ext
;
7035 Elf_Internal_Dyn
* entry
;
7037 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
7038 dynamic_size
, _("dynamic section"));
7042 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7043 might not have the luxury of section headers. Look for the DT_NULL
7044 terminator to determine the number of entries. */
7045 for (ext
= edyn
, dynamic_nent
= 0;
7046 (char *) ext
< (char *) edyn
+ dynamic_size
;
7050 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
7054 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
7056 if (dynamic_section
== NULL
)
7058 error (_("Out of memory\n"));
7063 for (ext
= edyn
, entry
= dynamic_section
;
7064 entry
< dynamic_section
+ dynamic_nent
;
7067 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
7068 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
7077 get_64bit_dynamic_section (FILE * file
)
7079 Elf64_External_Dyn
* edyn
;
7080 Elf64_External_Dyn
* ext
;
7081 Elf_Internal_Dyn
* entry
;
7083 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
7084 dynamic_size
, _("dynamic section"));
7088 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7089 might not have the luxury of section headers. Look for the DT_NULL
7090 terminator to determine the number of entries. */
7091 for (ext
= edyn
, dynamic_nent
= 0;
7092 (char *) ext
< (char *) edyn
+ dynamic_size
;
7096 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
7100 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
7102 if (dynamic_section
== NULL
)
7104 error (_("Out of memory\n"));
7109 for (ext
= edyn
, entry
= dynamic_section
;
7110 entry
< dynamic_section
+ dynamic_nent
;
7113 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
7114 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
7123 print_dynamic_flags (bfd_vma flags
)
7131 flag
= flags
& - flags
;
7141 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
7142 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
7143 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
7144 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
7145 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
7146 default: fputs (_("unknown"), stdout
); break;
7152 /* Parse and display the contents of the dynamic section. */
7155 process_dynamic_section (FILE * file
)
7157 Elf_Internal_Dyn
* entry
;
7159 if (dynamic_size
== 0)
7162 printf (_("\nThere is no dynamic section in this file.\n"));
7169 if (! get_32bit_dynamic_section (file
))
7172 else if (! get_64bit_dynamic_section (file
))
7175 /* Find the appropriate symbol table. */
7176 if (dynamic_symbols
== NULL
)
7178 for (entry
= dynamic_section
;
7179 entry
< dynamic_section
+ dynamic_nent
;
7182 Elf_Internal_Shdr section
;
7184 if (entry
->d_tag
!= DT_SYMTAB
)
7187 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
7189 /* Since we do not know how big the symbol table is,
7190 we default to reading in the entire file (!) and
7191 processing that. This is overkill, I know, but it
7193 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
7195 if (archive_file_offset
!= 0)
7196 section
.sh_size
= archive_file_size
- section
.sh_offset
;
7199 if (fseek (file
, 0, SEEK_END
))
7200 error (_("Unable to seek to end of file!\n"));
7202 section
.sh_size
= ftell (file
) - section
.sh_offset
;
7206 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
7208 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
7210 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
7211 if (num_dynamic_syms
< 1)
7213 error (_("Unable to determine the number of symbols to load\n"));
7217 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
7221 /* Similarly find a string table. */
7222 if (dynamic_strings
== NULL
)
7224 for (entry
= dynamic_section
;
7225 entry
< dynamic_section
+ dynamic_nent
;
7228 unsigned long offset
;
7231 if (entry
->d_tag
!= DT_STRTAB
)
7234 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
7236 /* Since we do not know how big the string table is,
7237 we default to reading in the entire file (!) and
7238 processing that. This is overkill, I know, but it
7241 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
7243 if (archive_file_offset
!= 0)
7244 str_tab_len
= archive_file_size
- offset
;
7247 if (fseek (file
, 0, SEEK_END
))
7248 error (_("Unable to seek to end of file\n"));
7249 str_tab_len
= ftell (file
) - offset
;
7252 if (str_tab_len
< 1)
7255 (_("Unable to determine the length of the dynamic string table\n"));
7259 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
7261 _("dynamic string table"));
7262 dynamic_strings_length
= str_tab_len
;
7267 /* And find the syminfo section if available. */
7268 if (dynamic_syminfo
== NULL
)
7270 unsigned long syminsz
= 0;
7272 for (entry
= dynamic_section
;
7273 entry
< dynamic_section
+ dynamic_nent
;
7276 if (entry
->d_tag
== DT_SYMINENT
)
7278 /* Note: these braces are necessary to avoid a syntax
7279 error from the SunOS4 C compiler. */
7280 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
7282 else if (entry
->d_tag
== DT_SYMINSZ
)
7283 syminsz
= entry
->d_un
.d_val
;
7284 else if (entry
->d_tag
== DT_SYMINFO
)
7285 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
7289 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
7291 Elf_External_Syminfo
* extsyminfo
;
7292 Elf_External_Syminfo
* extsym
;
7293 Elf_Internal_Syminfo
* syminfo
;
7295 /* There is a syminfo section. Read the data. */
7296 extsyminfo
= (Elf_External_Syminfo
*)
7297 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
7298 _("symbol information"));
7302 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
7303 if (dynamic_syminfo
== NULL
)
7305 error (_("Out of memory\n"));
7309 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
7310 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
7311 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
7312 ++syminfo
, ++extsym
)
7314 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
7315 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
7322 if (do_dynamic
&& dynamic_addr
)
7323 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7324 dynamic_addr
, dynamic_nent
);
7326 printf (_(" Tag Type Name/Value\n"));
7328 for (entry
= dynamic_section
;
7329 entry
< dynamic_section
+ dynamic_nent
;
7337 print_vma (entry
->d_tag
, FULL_HEX
);
7338 dtype
= get_dynamic_type (entry
->d_tag
);
7339 printf (" (%s)%*s", dtype
,
7340 ((is_32bit_elf
? 27 : 19)
7341 - (int) strlen (dtype
)),
7345 switch (entry
->d_tag
)
7349 print_dynamic_flags (entry
->d_un
.d_val
);
7359 switch (entry
->d_tag
)
7362 printf (_("Auxiliary library"));
7366 printf (_("Filter library"));
7370 printf (_("Configuration file"));
7374 printf (_("Dependency audit library"));
7378 printf (_("Audit library"));
7382 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7383 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
7387 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7396 printf (_("Flags:"));
7398 if (entry
->d_un
.d_val
== 0)
7399 printf (_(" None\n"));
7402 unsigned long int val
= entry
->d_un
.d_val
;
7404 if (val
& DTF_1_PARINIT
)
7406 printf (" PARINIT");
7407 val
^= DTF_1_PARINIT
;
7409 if (val
& DTF_1_CONFEXP
)
7411 printf (" CONFEXP");
7412 val
^= DTF_1_CONFEXP
;
7415 printf (" %lx", val
);
7424 printf (_("Flags:"));
7426 if (entry
->d_un
.d_val
== 0)
7427 printf (_(" None\n"));
7430 unsigned long int val
= entry
->d_un
.d_val
;
7432 if (val
& DF_P1_LAZYLOAD
)
7434 printf (" LAZYLOAD");
7435 val
^= DF_P1_LAZYLOAD
;
7437 if (val
& DF_P1_GROUPPERM
)
7439 printf (" GROUPPERM");
7440 val
^= DF_P1_GROUPPERM
;
7443 printf (" %lx", val
);
7452 printf (_("Flags:"));
7453 if (entry
->d_un
.d_val
== 0)
7454 printf (_(" None\n"));
7457 unsigned long int val
= entry
->d_un
.d_val
;
7464 if (val
& DF_1_GLOBAL
)
7469 if (val
& DF_1_GROUP
)
7474 if (val
& DF_1_NODELETE
)
7476 printf (" NODELETE");
7477 val
^= DF_1_NODELETE
;
7479 if (val
& DF_1_LOADFLTR
)
7481 printf (" LOADFLTR");
7482 val
^= DF_1_LOADFLTR
;
7484 if (val
& DF_1_INITFIRST
)
7486 printf (" INITFIRST");
7487 val
^= DF_1_INITFIRST
;
7489 if (val
& DF_1_NOOPEN
)
7494 if (val
& DF_1_ORIGIN
)
7499 if (val
& DF_1_DIRECT
)
7504 if (val
& DF_1_TRANS
)
7509 if (val
& DF_1_INTERPOSE
)
7511 printf (" INTERPOSE");
7512 val
^= DF_1_INTERPOSE
;
7514 if (val
& DF_1_NODEFLIB
)
7516 printf (" NODEFLIB");
7517 val
^= DF_1_NODEFLIB
;
7519 if (val
& DF_1_NODUMP
)
7524 if (val
& DF_1_CONLFAT
)
7526 printf (" CONLFAT");
7527 val
^= DF_1_CONLFAT
;
7530 printf (" %lx", val
);
7537 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
7539 puts (get_dynamic_type (entry
->d_un
.d_val
));
7559 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
7565 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7566 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
7572 switch (entry
->d_tag
)
7575 printf (_("Shared library: [%s]"), name
);
7577 if (streq (name
, program_interpreter
))
7578 printf (_(" program interpreter"));
7582 printf (_("Library soname: [%s]"), name
);
7586 printf (_("Library rpath: [%s]"), name
);
7590 printf (_("Library runpath: [%s]"), name
);
7594 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7599 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7612 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
7616 case DT_INIT_ARRAYSZ
:
7617 case DT_FINI_ARRAYSZ
:
7618 case DT_GNU_CONFLICTSZ
:
7619 case DT_GNU_LIBLISTSZ
:
7622 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
7623 printf (_(" (bytes)\n"));
7633 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
7646 if (entry
->d_tag
== DT_USED
7647 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7649 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
7653 printf (_("Not needed object: [%s]\n"), name
);
7658 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7664 /* The value of this entry is ignored. */
7669 case DT_GNU_PRELINKED
:
7673 time_t atime
= entry
->d_un
.d_val
;
7675 tmp
= gmtime (&atime
);
7676 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
7677 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
7678 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
7684 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
7687 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7693 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
7694 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
7699 switch (elf_header
.e_machine
)
7702 case EM_MIPS_RS3_LE
:
7703 dynamic_section_mips_val (entry
);
7706 dynamic_section_parisc_val (entry
);
7709 dynamic_section_ia64_val (entry
);
7712 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7724 get_ver_flags (unsigned int flags
)
7726 static char buff
[32];
7733 if (flags
& VER_FLG_BASE
)
7734 strcat (buff
, "BASE ");
7736 if (flags
& VER_FLG_WEAK
)
7738 if (flags
& VER_FLG_BASE
)
7739 strcat (buff
, "| ");
7741 strcat (buff
, "WEAK ");
7744 if (flags
& VER_FLG_INFO
)
7746 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
7747 strcat (buff
, "| ");
7749 strcat (buff
, "INFO ");
7752 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
7753 strcat (buff
, _("| <unknown>"));
7758 /* Display the contents of the version sections. */
7761 process_version_sections (FILE * file
)
7763 Elf_Internal_Shdr
* section
;
7770 for (i
= 0, section
= section_headers
;
7771 i
< elf_header
.e_shnum
;
7774 switch (section
->sh_type
)
7776 case SHT_GNU_verdef
:
7778 Elf_External_Verdef
* edefs
;
7786 (_("\nVersion definition section '%s' contains %u entries:\n"),
7787 SECTION_NAME (section
), section
->sh_info
);
7789 printf (_(" Addr: 0x"));
7790 printf_vma (section
->sh_addr
);
7791 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
7792 (unsigned long) section
->sh_offset
, section
->sh_link
,
7793 section
->sh_link
< elf_header
.e_shnum
7794 ? SECTION_NAME (section_headers
+ section
->sh_link
)
7797 edefs
= (Elf_External_Verdef
*)
7798 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
7799 _("version definition section"));
7800 endbuf
= (char *) edefs
+ section
->sh_size
;
7804 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
7807 Elf_External_Verdef
* edef
;
7808 Elf_Internal_Verdef ent
;
7809 Elf_External_Verdaux
* eaux
;
7810 Elf_Internal_Verdaux aux
;
7814 /* Check for negative or very large indicies. */
7815 if ((unsigned char *) edefs
+ idx
< (unsigned char *) edefs
)
7818 vstart
= ((char *) edefs
) + idx
;
7819 if (vstart
+ sizeof (*edef
) > endbuf
)
7822 edef
= (Elf_External_Verdef
*) vstart
;
7824 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
7825 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
7826 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
7827 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
7828 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
7829 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
7830 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
7832 printf (_(" %#06x: Rev: %d Flags: %s"),
7833 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
7835 printf (_(" Index: %d Cnt: %d "),
7836 ent
.vd_ndx
, ent
.vd_cnt
);
7838 /* Check for overflow. */
7839 if ((unsigned char *)(vstart
+ ent
.vd_aux
) < (unsigned char *) vstart
7840 || (unsigned char *)(vstart
+ ent
.vd_aux
) > (unsigned char *) endbuf
)
7843 vstart
+= ent
.vd_aux
;
7845 eaux
= (Elf_External_Verdaux
*) vstart
;
7847 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
7848 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
7850 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
7851 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
7853 printf (_("Name index: %ld\n"), aux
.vda_name
);
7855 isum
= idx
+ ent
.vd_aux
;
7857 for (j
= 1; j
< ent
.vd_cnt
; j
++)
7859 /* Check for overflow. */
7860 if ((unsigned char *)(vstart
+ aux
.vda_next
) < (unsigned char *) vstart
7861 || (unsigned char *)(vstart
+ aux
.vda_next
) > (unsigned char *) endbuf
)
7864 isum
+= aux
.vda_next
;
7865 vstart
+= aux
.vda_next
;
7867 eaux
= (Elf_External_Verdaux
*) vstart
;
7868 if (vstart
+ sizeof (*eaux
) > endbuf
)
7871 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
7872 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
7874 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
7875 printf (_(" %#06x: Parent %d: %s\n"),
7876 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
7878 printf (_(" %#06x: Parent %d, name index: %ld\n"),
7879 isum
, j
, aux
.vda_name
);
7883 printf (_(" Version def aux past end of section\n"));
7888 if (cnt
< section
->sh_info
)
7889 printf (_(" Version definition past end of section\n"));
7895 case SHT_GNU_verneed
:
7897 Elf_External_Verneed
* eneed
;
7904 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
7905 SECTION_NAME (section
), section
->sh_info
);
7907 printf (_(" Addr: 0x"));
7908 printf_vma (section
->sh_addr
);
7909 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
7910 (unsigned long) section
->sh_offset
, section
->sh_link
,
7911 section
->sh_link
< elf_header
.e_shnum
7912 ? SECTION_NAME (section_headers
+ section
->sh_link
)
7915 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
7916 section
->sh_offset
, 1,
7918 _("version need section"));
7919 endbuf
= (char *) eneed
+ section
->sh_size
;
7923 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
7925 Elf_External_Verneed
* entry
;
7926 Elf_Internal_Verneed ent
;
7931 if ((unsigned char *) eneed
+ idx
< (unsigned char *) eneed
)
7934 vstart
= ((char *) eneed
) + idx
;
7935 if (vstart
+ sizeof (*entry
) > endbuf
)
7938 entry
= (Elf_External_Verneed
*) vstart
;
7940 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
7941 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
7942 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
7943 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
7944 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
7946 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
7948 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
7949 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
7951 printf (_(" File: %lx"), ent
.vn_file
);
7953 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
7955 /* Check for overflow. */
7956 if ((unsigned char *)(vstart
+ ent
.vn_aux
) < (unsigned char *) vstart
7957 || (unsigned char *)(vstart
+ ent
.vn_aux
) > (unsigned char *) endbuf
)
7960 vstart
+= ent
.vn_aux
;
7962 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
7964 Elf_External_Vernaux
* eaux
;
7965 Elf_Internal_Vernaux aux
;
7967 if (vstart
+ sizeof (*eaux
) > endbuf
)
7969 eaux
= (Elf_External_Vernaux
*) vstart
;
7971 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
7972 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
7973 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
7974 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
7975 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
7977 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
7978 printf (_(" %#06x: Name: %s"),
7979 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
7981 printf (_(" %#06x: Name index: %lx"),
7982 isum
, aux
.vna_name
);
7984 printf (_(" Flags: %s Version: %d\n"),
7985 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
7987 /* Check for overflow. */
7988 if ((unsigned char *)(vstart
+ aux
.vna_next
) < (unsigned char *) vstart
7989 || (unsigned char *)(vstart
+ aux
.vna_next
) > (unsigned char *) endbuf
)
7992 isum
+= aux
.vna_next
;
7993 vstart
+= aux
.vna_next
;
7996 printf (_(" Version need aux past end of section\n"));
8000 if (cnt
< section
->sh_info
)
8001 printf (_(" Version need past end of section\n"));
8007 case SHT_GNU_versym
:
8009 Elf_Internal_Shdr
* link_section
;
8012 unsigned char * edata
;
8013 unsigned short * data
;
8015 Elf_Internal_Sym
* symbols
;
8016 Elf_Internal_Shdr
* string_sec
;
8019 if (section
->sh_link
>= elf_header
.e_shnum
)
8022 link_section
= section_headers
+ section
->sh_link
;
8023 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
8025 if (link_section
->sh_link
>= elf_header
.e_shnum
)
8030 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
8031 if (symbols
== NULL
)
8034 string_sec
= section_headers
+ link_section
->sh_link
;
8036 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
8037 string_sec
->sh_size
,
8038 _("version string table"));
8042 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8043 SECTION_NAME (section
), total
);
8045 printf (_(" Addr: "));
8046 printf_vma (section
->sh_addr
);
8047 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8048 (unsigned long) section
->sh_offset
, section
->sh_link
,
8049 SECTION_NAME (link_section
));
8051 off
= offset_from_vma (file
,
8052 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
8053 total
* sizeof (short));
8054 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
8056 _("version symbol data"));
8063 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
8065 for (cnt
= total
; cnt
--;)
8066 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
8071 for (cnt
= 0; cnt
< total
; cnt
+= 4)
8074 int check_def
, check_need
;
8077 printf (" %03x:", cnt
);
8079 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
8080 switch (data
[cnt
+ j
])
8083 fputs (_(" 0 (*local*) "), stdout
);
8087 fputs (_(" 1 (*global*) "), stdout
);
8091 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
8092 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
8094 /* If this index value is greater than the size of the symbols
8095 array, break to avoid an out-of-bounds read, */
8096 if ((unsigned long)(cnt
+ j
) >=
8097 ((unsigned long)link_section
->sh_size
/
8098 (unsigned long)link_section
->sh_entsize
))
8100 warn (_("invalid index into symbol array\n"));
8106 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
8107 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
8110 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
8117 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
8119 Elf_Internal_Verneed ivn
;
8120 unsigned long offset
;
8122 offset
= offset_from_vma
8123 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
8124 sizeof (Elf_External_Verneed
));
8128 Elf_Internal_Vernaux ivna
;
8129 Elf_External_Verneed evn
;
8130 Elf_External_Vernaux evna
;
8131 unsigned long a_off
;
8133 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
8136 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
8137 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
8139 a_off
= offset
+ ivn
.vn_aux
;
8143 get_data (&evna
, file
, a_off
, sizeof (evna
),
8144 1, _("version need aux (2)"));
8146 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
8147 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
8149 a_off
+= ivna
.vna_next
;
8151 while (ivna
.vna_other
!= data
[cnt
+ j
]
8152 && ivna
.vna_next
!= 0);
8154 if (ivna
.vna_other
== data
[cnt
+ j
])
8156 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
8158 if (ivna
.vna_name
>= string_sec
->sh_size
)
8159 name
= _("*invalid*");
8161 name
= strtab
+ ivna
.vna_name
;
8162 nn
+= printf ("(%s%-*s",
8164 12 - (int) strlen (name
),
8170 offset
+= ivn
.vn_next
;
8172 while (ivn
.vn_next
);
8175 if (check_def
&& data
[cnt
+ j
] != 0x8001
8176 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
8178 Elf_Internal_Verdef ivd
;
8179 Elf_External_Verdef evd
;
8180 unsigned long offset
;
8182 offset
= offset_from_vma
8183 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
8188 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
8191 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
8192 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
8194 offset
+= ivd
.vd_next
;
8196 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
8197 && ivd
.vd_next
!= 0);
8199 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
8201 Elf_External_Verdaux evda
;
8202 Elf_Internal_Verdaux ivda
;
8204 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
8206 get_data (&evda
, file
,
8207 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
8209 _("version def aux"));
8211 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
8213 if (ivda
.vda_name
>= string_sec
->sh_size
)
8214 name
= _("*invalid*");
8216 name
= strtab
+ ivda
.vda_name
;
8217 nn
+= printf ("(%s%-*s",
8219 12 - (int) strlen (name
),
8225 printf ("%*c", 18 - nn
, ' ');
8243 printf (_("\nNo version information found in this file.\n"));
8249 get_symbol_binding (unsigned int binding
)
8251 static char buff
[32];
8255 case STB_LOCAL
: return "LOCAL";
8256 case STB_GLOBAL
: return "GLOBAL";
8257 case STB_WEAK
: return "WEAK";
8259 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
8260 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
8262 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
8264 if (binding
== STB_GNU_UNIQUE
8265 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
8266 /* GNU/Linux is still using the default value 0. */
8267 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
8269 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
8272 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
8278 get_symbol_type (unsigned int type
)
8280 static char buff
[32];
8284 case STT_NOTYPE
: return "NOTYPE";
8285 case STT_OBJECT
: return "OBJECT";
8286 case STT_FUNC
: return "FUNC";
8287 case STT_SECTION
: return "SECTION";
8288 case STT_FILE
: return "FILE";
8289 case STT_COMMON
: return "COMMON";
8290 case STT_TLS
: return "TLS";
8291 case STT_RELC
: return "RELC";
8292 case STT_SRELC
: return "SRELC";
8294 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
8296 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
8297 return "THUMB_FUNC";
8299 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
8302 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
8303 return "PARISC_MILLI";
8305 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
8307 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
8309 if (elf_header
.e_machine
== EM_PARISC
)
8311 if (type
== STT_HP_OPAQUE
)
8313 if (type
== STT_HP_STUB
)
8317 if (type
== STT_GNU_IFUNC
8318 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
8319 /* GNU/Linux is still using the default value 0. */
8320 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
8323 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
8326 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
8332 get_symbol_visibility (unsigned int visibility
)
8336 case STV_DEFAULT
: return "DEFAULT";
8337 case STV_INTERNAL
: return "INTERNAL";
8338 case STV_HIDDEN
: return "HIDDEN";
8339 case STV_PROTECTED
: return "PROTECTED";
8345 get_mips_symbol_other (unsigned int other
)
8349 case STO_OPTIONAL
: return "OPTIONAL";
8350 case STO_MIPS16
: return "MIPS16";
8351 case STO_MIPS_PLT
: return "MIPS PLT";
8352 case STO_MIPS_PIC
: return "MIPS PIC";
8353 default: return NULL
;
8358 get_ia64_symbol_other (unsigned int other
)
8362 static char res
[32];
8366 /* Function types is for images and .STB files only. */
8367 switch (elf_header
.e_type
)
8371 switch (VMS_ST_FUNC_TYPE (other
))
8373 case VMS_SFT_CODE_ADDR
:
8374 strcat (res
, " CA");
8376 case VMS_SFT_SYMV_IDX
:
8377 strcat (res
, " VEC");
8380 strcat (res
, " FD");
8382 case VMS_SFT_RESERVE
:
8383 strcat (res
, " RSV");
8392 switch (VMS_ST_LINKAGE (other
))
8394 case VMS_STL_IGNORE
:
8395 strcat (res
, " IGN");
8397 case VMS_STL_RESERVE
:
8398 strcat (res
, " RSV");
8401 strcat (res
, " STD");
8404 strcat (res
, " LNK");
8419 get_symbol_other (unsigned int other
)
8421 const char * result
= NULL
;
8422 static char buff
[32];
8427 switch (elf_header
.e_machine
)
8430 result
= get_mips_symbol_other (other
);
8433 result
= get_ia64_symbol_other (other
);
8442 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
8447 get_symbol_index_type (unsigned int type
)
8449 static char buff
[32];
8453 case SHN_UNDEF
: return "UND";
8454 case SHN_ABS
: return "ABS";
8455 case SHN_COMMON
: return "COM";
8457 if (type
== SHN_IA_64_ANSI_COMMON
8458 && elf_header
.e_machine
== EM_IA_64
8459 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
8461 else if ((elf_header
.e_machine
== EM_X86_64
8462 || elf_header
.e_machine
== EM_L1OM
)
8463 && type
== SHN_X86_64_LCOMMON
)
8465 else if (type
== SHN_MIPS_SCOMMON
8466 && elf_header
.e_machine
== EM_MIPS
)
8468 else if (type
== SHN_MIPS_SUNDEFINED
8469 && elf_header
.e_machine
== EM_MIPS
)
8471 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
8472 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
8473 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
8474 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
8475 else if (type
>= SHN_LORESERVE
)
8476 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
8478 sprintf (buff
, "%3d", type
);
8486 get_dynamic_data (FILE * file
, unsigned int number
, unsigned int ent_size
)
8488 unsigned char * e_data
;
8491 e_data
= (unsigned char *) cmalloc (number
, ent_size
);
8495 error (_("Out of memory\n"));
8499 if (fread (e_data
, ent_size
, number
, file
) != number
)
8501 error (_("Unable to read in dynamic data\n"));
8505 i_data
= (bfd_vma
*) cmalloc (number
, sizeof (*i_data
));
8509 error (_("Out of memory\n"));
8515 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
8523 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
8525 Elf_Internal_Sym
* psym
;
8528 psym
= dynamic_symbols
+ si
;
8530 n
= print_vma (si
, DEC_5
);
8532 fputs (" " + n
, stdout
);
8533 printf (" %3lu: ", hn
);
8534 print_vma (psym
->st_value
, LONG_HEX
);
8536 print_vma (psym
->st_size
, DEC_5
);
8538 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
8539 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
8540 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
8541 /* Check to see if any other bits in the st_other field are set.
8542 Note - displaying this information disrupts the layout of the
8543 table being generated, but for the moment this case is very
8545 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
8546 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
8547 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
8548 if (VALID_DYNAMIC_NAME (psym
->st_name
))
8549 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
8551 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
8555 /* Dump the symbol table. */
8557 process_symbol_table (FILE * file
)
8559 Elf_Internal_Shdr
* section
;
8560 bfd_vma nbuckets
= 0;
8561 bfd_vma nchains
= 0;
8562 bfd_vma
* buckets
= NULL
;
8563 bfd_vma
* chains
= NULL
;
8564 bfd_vma ngnubuckets
= 0;
8565 bfd_vma
* gnubuckets
= NULL
;
8566 bfd_vma
* gnuchains
= NULL
;
8567 bfd_vma gnusymidx
= 0;
8569 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
8572 if (dynamic_info
[DT_HASH
]
8574 || (do_using_dynamic
8576 && dynamic_strings
!= NULL
)))
8578 unsigned char nb
[8];
8579 unsigned char nc
[8];
8580 int hash_ent_size
= 4;
8582 if ((elf_header
.e_machine
== EM_ALPHA
8583 || elf_header
.e_machine
== EM_S390
8584 || elf_header
.e_machine
== EM_S390_OLD
)
8585 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
8589 (archive_file_offset
8590 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
8591 sizeof nb
+ sizeof nc
)),
8594 error (_("Unable to seek to start of dynamic information\n"));
8598 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
8600 error (_("Failed to read in number of buckets\n"));
8604 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
8606 error (_("Failed to read in number of chains\n"));
8610 nbuckets
= byte_get (nb
, hash_ent_size
);
8611 nchains
= byte_get (nc
, hash_ent_size
);
8613 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
8614 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
8617 if (buckets
== NULL
|| chains
== NULL
)
8619 if (do_using_dynamic
)
8630 if (dynamic_info_DT_GNU_HASH
8632 || (do_using_dynamic
8634 && dynamic_strings
!= NULL
)))
8636 unsigned char nb
[16];
8637 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
8638 bfd_vma buckets_vma
;
8641 (archive_file_offset
8642 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
8646 error (_("Unable to seek to start of dynamic information\n"));
8650 if (fread (nb
, 16, 1, file
) != 1)
8652 error (_("Failed to read in number of buckets\n"));
8656 ngnubuckets
= byte_get (nb
, 4);
8657 gnusymidx
= byte_get (nb
+ 4, 4);
8658 bitmaskwords
= byte_get (nb
+ 8, 4);
8659 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
8661 buckets_vma
+= bitmaskwords
* 4;
8663 buckets_vma
+= bitmaskwords
* 8;
8666 (archive_file_offset
8667 + offset_from_vma (file
, buckets_vma
, 4)),
8670 error (_("Unable to seek to start of dynamic information\n"));
8674 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
8676 if (gnubuckets
== NULL
)
8679 for (i
= 0; i
< ngnubuckets
; i
++)
8680 if (gnubuckets
[i
] != 0)
8682 if (gnubuckets
[i
] < gnusymidx
)
8685 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
8686 maxchain
= gnubuckets
[i
];
8689 if (maxchain
== 0xffffffff)
8692 maxchain
-= gnusymidx
;
8695 (archive_file_offset
8696 + offset_from_vma (file
, buckets_vma
8697 + 4 * (ngnubuckets
+ maxchain
), 4)),
8700 error (_("Unable to seek to start of dynamic information\n"));
8706 if (fread (nb
, 4, 1, file
) != 1)
8708 error (_("Failed to determine last chain length\n"));
8712 if (maxchain
+ 1 == 0)
8717 while ((byte_get (nb
, 4) & 1) == 0);
8720 (archive_file_offset
8721 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
8724 error (_("Unable to seek to start of dynamic information\n"));
8728 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
8731 if (gnuchains
== NULL
)
8736 if (do_using_dynamic
)
8741 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
8744 && dynamic_strings
!= NULL
)
8748 if (dynamic_info
[DT_HASH
])
8752 printf (_("\nSymbol table for image:\n"));
8754 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8756 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8758 for (hn
= 0; hn
< nbuckets
; hn
++)
8763 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
8764 print_dynamic_symbol (si
, hn
);
8768 if (dynamic_info_DT_GNU_HASH
)
8770 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
8772 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8774 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8776 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
8777 if (gnubuckets
[hn
] != 0)
8779 bfd_vma si
= gnubuckets
[hn
];
8780 bfd_vma off
= si
- gnusymidx
;
8784 print_dynamic_symbol (si
, hn
);
8787 while ((gnuchains
[off
++] & 1) == 0);
8791 else if (do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
8795 for (i
= 0, section
= section_headers
;
8796 i
< elf_header
.e_shnum
;
8800 char * strtab
= NULL
;
8801 unsigned long int strtab_size
= 0;
8802 Elf_Internal_Sym
* symtab
;
8803 Elf_Internal_Sym
* psym
;
8805 if ((section
->sh_type
!= SHT_SYMTAB
8806 && section
->sh_type
!= SHT_DYNSYM
)
8808 && section
->sh_type
== SHT_SYMTAB
))
8811 if (section
->sh_entsize
== 0)
8813 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
8814 SECTION_NAME (section
));
8818 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
8819 SECTION_NAME (section
),
8820 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
8823 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
8825 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
8827 symtab
= GET_ELF_SYMBOLS (file
, section
);
8831 if (section
->sh_link
== elf_header
.e_shstrndx
)
8833 strtab
= string_table
;
8834 strtab_size
= string_table_length
;
8836 else if (section
->sh_link
< elf_header
.e_shnum
)
8838 Elf_Internal_Shdr
* string_sec
;
8840 string_sec
= section_headers
+ section
->sh_link
;
8842 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
8843 1, string_sec
->sh_size
,
8845 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
8848 for (si
= 0, psym
= symtab
;
8849 si
< section
->sh_size
/ section
->sh_entsize
;
8852 printf ("%6d: ", si
);
8853 print_vma (psym
->st_value
, LONG_HEX
);
8855 print_vma (psym
->st_size
, DEC_5
);
8856 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
8857 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
8858 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
8859 /* Check to see if any other bits in the st_other field are set.
8860 Note - displaying this information disrupts the layout of the
8861 table being generated, but for the moment this case is very rare. */
8862 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
8863 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
8864 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
8865 print_symbol (25, psym
->st_name
< strtab_size
8866 ? strtab
+ psym
->st_name
: _("<corrupt>"));
8868 if (section
->sh_type
== SHT_DYNSYM
&&
8869 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
8871 unsigned char data
[2];
8872 unsigned short vers_data
;
8873 unsigned long offset
;
8877 offset
= offset_from_vma
8878 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
8879 sizeof data
+ si
* sizeof (vers_data
));
8881 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
8882 sizeof (data
), 1, _("version data"));
8884 vers_data
= byte_get (data
, 2);
8886 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
8887 && section_headers
[psym
->st_shndx
].sh_type
8890 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
8892 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
8894 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
8895 && (is_nobits
|| ! check_def
))
8897 Elf_External_Verneed evn
;
8898 Elf_Internal_Verneed ivn
;
8899 Elf_Internal_Vernaux ivna
;
8901 /* We must test both. */
8902 offset
= offset_from_vma
8903 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
8908 unsigned long vna_off
;
8910 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
8913 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
8914 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
8916 vna_off
= offset
+ ivn
.vn_aux
;
8920 Elf_External_Vernaux evna
;
8922 get_data (&evna
, file
, vna_off
,
8924 _("version need aux (3)"));
8926 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
8927 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
8928 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
8930 vna_off
+= ivna
.vna_next
;
8932 while (ivna
.vna_other
!= vers_data
8933 && ivna
.vna_next
!= 0);
8935 if (ivna
.vna_other
== vers_data
)
8938 offset
+= ivn
.vn_next
;
8940 while (ivn
.vn_next
!= 0);
8942 if (ivna
.vna_other
== vers_data
)
8945 ivna
.vna_name
< strtab_size
8946 ? strtab
+ ivna
.vna_name
: _("<corrupt>"),
8950 else if (! is_nobits
)
8951 error (_("bad dynamic symbol\n"));
8958 if (vers_data
!= 0x8001
8959 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
8961 Elf_Internal_Verdef ivd
;
8962 Elf_Internal_Verdaux ivda
;
8963 Elf_External_Verdaux evda
;
8966 off
= offset_from_vma
8968 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
8969 sizeof (Elf_External_Verdef
));
8973 Elf_External_Verdef evd
;
8975 get_data (&evd
, file
, off
, sizeof (evd
),
8976 1, _("version def"));
8978 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
8979 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
8980 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
8984 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
8985 && ivd
.vd_next
!= 0);
8990 get_data (&evda
, file
, off
, sizeof (evda
),
8991 1, _("version def aux"));
8993 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
8995 if (psym
->st_name
!= ivda
.vda_name
)
8996 printf ((vers_data
& VERSYM_HIDDEN
)
8998 ivda
.vda_name
< strtab_size
8999 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
9009 if (strtab
!= string_table
)
9015 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9017 if (do_histogram
&& buckets
!= NULL
)
9019 unsigned long * lengths
;
9020 unsigned long * counts
;
9023 unsigned long maxlength
= 0;
9024 unsigned long nzero_counts
= 0;
9025 unsigned long nsyms
= 0;
9027 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9028 (unsigned long) nbuckets
);
9029 printf (_(" Length Number %% of total Coverage\n"));
9031 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
9032 if (lengths
== NULL
)
9034 error (_("Out of memory\n"));
9037 for (hn
= 0; hn
< nbuckets
; ++hn
)
9039 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
9042 if (maxlength
< ++lengths
[hn
])
9047 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
9050 error (_("Out of memory\n"));
9054 for (hn
= 0; hn
< nbuckets
; ++hn
)
9055 ++counts
[lengths
[hn
]];
9060 printf (" 0 %-10lu (%5.1f%%)\n",
9061 counts
[0], (counts
[0] * 100.0) / nbuckets
);
9062 for (i
= 1; i
<= maxlength
; ++i
)
9064 nzero_counts
+= counts
[i
] * i
;
9065 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9066 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
9067 (nzero_counts
* 100.0) / nsyms
);
9075 if (buckets
!= NULL
)
9081 if (do_histogram
&& gnubuckets
!= NULL
)
9083 unsigned long * lengths
;
9084 unsigned long * counts
;
9086 unsigned long maxlength
= 0;
9087 unsigned long nzero_counts
= 0;
9088 unsigned long nsyms
= 0;
9090 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
9091 if (lengths
== NULL
)
9093 error (_("Out of memory\n"));
9097 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9098 (unsigned long) ngnubuckets
);
9099 printf (_(" Length Number %% of total Coverage\n"));
9101 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9102 if (gnubuckets
[hn
] != 0)
9104 bfd_vma off
, length
= 1;
9106 for (off
= gnubuckets
[hn
] - gnusymidx
;
9107 (gnuchains
[off
] & 1) == 0; ++off
)
9109 lengths
[hn
] = length
;
9110 if (length
> maxlength
)
9115 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
9118 error (_("Out of memory\n"));
9122 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9123 ++counts
[lengths
[hn
]];
9125 if (ngnubuckets
> 0)
9128 printf (" 0 %-10lu (%5.1f%%)\n",
9129 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
9130 for (j
= 1; j
<= maxlength
; ++j
)
9132 nzero_counts
+= counts
[j
] * j
;
9133 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9134 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
9135 (nzero_counts
* 100.0) / nsyms
);
9149 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
9153 if (dynamic_syminfo
== NULL
9155 /* No syminfo, this is ok. */
9158 /* There better should be a dynamic symbol section. */
9159 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
9163 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9164 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
9166 printf (_(" Num: Name BoundTo Flags\n"));
9167 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
9169 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
9171 printf ("%4d: ", i
);
9172 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
9173 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
9175 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
9178 switch (dynamic_syminfo
[i
].si_boundto
)
9180 case SYMINFO_BT_SELF
:
9181 fputs ("SELF ", stdout
);
9183 case SYMINFO_BT_PARENT
:
9184 fputs ("PARENT ", stdout
);
9187 if (dynamic_syminfo
[i
].si_boundto
> 0
9188 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
9189 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
9191 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
9195 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
9199 if (flags
& SYMINFO_FLG_DIRECT
)
9201 if (flags
& SYMINFO_FLG_PASSTHRU
)
9202 printf (" PASSTHRU");
9203 if (flags
& SYMINFO_FLG_COPY
)
9205 if (flags
& SYMINFO_FLG_LAZYLOAD
)
9206 printf (" LAZYLOAD");
9214 /* Check to see if the given reloc needs to be handled in a target specific
9215 manner. If so then process the reloc and return TRUE otherwise return
9219 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
9220 unsigned char * start
,
9221 Elf_Internal_Sym
* symtab
)
9223 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
9225 switch (elf_header
.e_machine
)
9228 case EM_CYGNUS_MN10300
:
9230 static Elf_Internal_Sym
* saved_sym
= NULL
;
9234 case 34: /* R_MN10300_ALIGN */
9236 case 33: /* R_MN10300_SYM_DIFF */
9237 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
9239 case 1: /* R_MN10300_32 */
9240 case 2: /* R_MN10300_16 */
9241 if (saved_sym
!= NULL
)
9245 value
= reloc
->r_addend
9246 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
9247 - saved_sym
->st_value
);
9249 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
9256 if (saved_sym
!= NULL
)
9257 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9267 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9268 DWARF debug sections. This is a target specific test. Note - we do not
9269 go through the whole including-target-headers-multiple-times route, (as
9270 we have already done with <elf/h8.h>) because this would become very
9271 messy and even then this function would have to contain target specific
9272 information (the names of the relocs instead of their numeric values).
9273 FIXME: This is not the correct way to solve this problem. The proper way
9274 is to have target specific reloc sizing and typing functions created by
9275 the reloc-macros.h header, in the same way that it already creates the
9276 reloc naming functions. */
9279 is_32bit_abs_reloc (unsigned int reloc_type
)
9281 switch (elf_header
.e_machine
)
9285 return reloc_type
== 1; /* R_386_32. */
9287 return reloc_type
== 1; /* R_68K_32. */
9289 return reloc_type
== 1; /* R_860_32. */
9291 return reloc_type
== 2; /* R_960_32. */
9293 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
9295 return reloc_type
== 1; /* R_ARC_32. */
9297 return reloc_type
== 2; /* R_ARM_ABS32 */
9300 return reloc_type
== 1;
9302 return reloc_type
== 0x12; /* R_byte4_data. */
9304 return reloc_type
== 3; /* R_CRIS_32. */
9307 return reloc_type
== 3; /* R_CR16_NUM32. */
9309 return reloc_type
== 15; /* R_CRX_NUM32. */
9311 return reloc_type
== 1;
9312 case EM_CYGNUS_D10V
:
9314 return reloc_type
== 6; /* R_D10V_32. */
9315 case EM_CYGNUS_D30V
:
9317 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
9319 return reloc_type
== 3; /* R_DLX_RELOC_32. */
9320 case EM_CYGNUS_FR30
:
9322 return reloc_type
== 3; /* R_FR30_32. */
9326 return reloc_type
== 1; /* R_H8_DIR32. */
9328 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
9331 return reloc_type
== 2; /* R_IP2K_32. */
9333 return reloc_type
== 2; /* R_IQ2000_32. */
9334 case EM_LATTICEMICO32
:
9335 return reloc_type
== 3; /* R_LM32_32. */
9338 return reloc_type
== 3; /* R_M32C_32. */
9340 return reloc_type
== 34; /* R_M32R_32_RELA. */
9342 return reloc_type
== 1; /* R_MCORE_ADDR32. */
9344 return reloc_type
== 4; /* R_MEP_32. */
9346 return reloc_type
== 1; /* R_MICROBLAZE_32. */
9348 return reloc_type
== 2; /* R_MIPS_32. */
9350 return reloc_type
== 4; /* R_MMIX_32. */
9351 case EM_CYGNUS_MN10200
:
9353 return reloc_type
== 1; /* R_MN10200_32. */
9354 case EM_CYGNUS_MN10300
:
9356 return reloc_type
== 1; /* R_MN10300_32. */
9358 return reloc_type
== 1; /* R_MOXIE_32. */
9361 return reloc_type
== 1; /* R_MSP43_32. */
9363 return reloc_type
== 2; /* R_MT_32. */
9364 case EM_ALTERA_NIOS2
:
9366 return reloc_type
== 1; /* R_NIOS_32. */
9369 return reloc_type
== 1; /* R_OR32_32. */
9371 return (reloc_type
== 1 /* R_PARISC_DIR32. */
9372 || reloc_type
== 41); /* R_PARISC_SECREL32. */
9375 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
9377 return reloc_type
== 1; /* R_PPC64_ADDR32. */
9379 return reloc_type
== 1; /* R_PPC_ADDR32. */
9381 return reloc_type
== 1; /* R_RX_DIR32. */
9383 return reloc_type
== 1; /* R_I370_ADDR31. */
9386 return reloc_type
== 4; /* R_S390_32. */
9388 return reloc_type
== 8; /* R_SCORE_ABS32. */
9390 return reloc_type
== 1; /* R_SH_DIR32. */
9391 case EM_SPARC32PLUS
:
9394 return reloc_type
== 3 /* R_SPARC_32. */
9395 || reloc_type
== 23; /* R_SPARC_UA32. */
9397 return reloc_type
== 6; /* R_SPU_ADDR32 */
9399 return reloc_type
== 1; /* R_C6000_ABS32. */
9400 case EM_CYGNUS_V850
:
9402 return reloc_type
== 6; /* R_V850_ABS32. */
9404 return reloc_type
== 1; /* R_VAX_32. */
9407 return reloc_type
== 10; /* R_X86_64_32. */
9410 return reloc_type
== 3; /* R_XC16C_ABS_32. */
9412 return reloc_type
== 1; /* R_XSTROMY16_32. */
9415 return reloc_type
== 1; /* R_XTENSA_32. */
9417 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
9418 elf_header
.e_machine
);
9423 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9424 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
9427 is_32bit_pcrel_reloc (unsigned int reloc_type
)
9429 switch (elf_header
.e_machine
)
9433 return reloc_type
== 2; /* R_386_PC32. */
9435 return reloc_type
== 4; /* R_68K_PC32. */
9437 return reloc_type
== 10; /* R_ALPHA_SREL32. */
9439 return reloc_type
== 3; /* R_ARM_REL32 */
9441 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
9443 return reloc_type
== 9; /* R_PARISC_PCREL32. */
9445 return reloc_type
== 26; /* R_PPC_REL32. */
9447 return reloc_type
== 26; /* R_PPC64_REL32. */
9450 return reloc_type
== 5; /* R_390_PC32. */
9452 return reloc_type
== 2; /* R_SH_REL32. */
9453 case EM_SPARC32PLUS
:
9456 return reloc_type
== 6; /* R_SPARC_DISP32. */
9458 return reloc_type
== 13; /* R_SPU_REL32. */
9461 return reloc_type
== 2; /* R_X86_64_PC32. */
9464 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
9466 /* Do not abort or issue an error message here. Not all targets use
9467 pc-relative 32-bit relocs in their DWARF debug information and we
9468 have already tested for target coverage in is_32bit_abs_reloc. A
9469 more helpful warning message will be generated by apply_relocations
9470 anyway, so just return. */
9475 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9476 a 64-bit absolute RELA relocation used in DWARF debug sections. */
9479 is_64bit_abs_reloc (unsigned int reloc_type
)
9481 switch (elf_header
.e_machine
)
9484 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
9486 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
9488 return reloc_type
== 80; /* R_PARISC_DIR64. */
9490 return reloc_type
== 38; /* R_PPC64_ADDR64. */
9491 case EM_SPARC32PLUS
:
9494 return reloc_type
== 54; /* R_SPARC_UA64. */
9497 return reloc_type
== 1; /* R_X86_64_64. */
9500 return reloc_type
== 22; /* R_S390_64 */
9502 return reloc_type
== 18; /* R_MIPS_64 */
9508 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
9509 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
9512 is_64bit_pcrel_reloc (unsigned int reloc_type
)
9514 switch (elf_header
.e_machine
)
9517 return reloc_type
== 11; /* R_ALPHA_SREL64 */
9519 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB */
9521 return reloc_type
== 72; /* R_PARISC_PCREL64 */
9523 return reloc_type
== 44; /* R_PPC64_REL64 */
9524 case EM_SPARC32PLUS
:
9527 return reloc_type
== 46; /* R_SPARC_DISP64 */
9530 return reloc_type
== 24; /* R_X86_64_PC64 */
9533 return reloc_type
== 23; /* R_S390_PC64 */
9539 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9540 a 24-bit absolute RELA relocation used in DWARF debug sections. */
9543 is_24bit_abs_reloc (unsigned int reloc_type
)
9545 switch (elf_header
.e_machine
)
9547 case EM_CYGNUS_MN10200
:
9549 return reloc_type
== 4; /* R_MN10200_24. */
9555 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9556 a 16-bit absolute RELA relocation used in DWARF debug sections. */
9559 is_16bit_abs_reloc (unsigned int reloc_type
)
9561 switch (elf_header
.e_machine
)
9565 return reloc_type
== 4; /* R_AVR_16. */
9566 case EM_CYGNUS_D10V
:
9568 return reloc_type
== 3; /* R_D10V_16. */
9572 return reloc_type
== R_H8_DIR16
;
9575 return reloc_type
== 1; /* R_IP2K_16. */
9578 return reloc_type
== 1; /* R_M32C_16 */
9581 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
9582 case EM_ALTERA_NIOS2
:
9584 return reloc_type
== 9; /* R_NIOS_16. */
9586 return reloc_type
== 2; /* R_C6000_ABS16. */
9589 return reloc_type
== 2; /* R_XC16C_ABS_16. */
9595 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
9596 relocation entries (possibly formerly used for SHT_GROUP sections). */
9599 is_none_reloc (unsigned int reloc_type
)
9601 switch (elf_header
.e_machine
)
9603 case EM_68K
: /* R_68K_NONE. */
9604 case EM_386
: /* R_386_NONE. */
9605 case EM_SPARC32PLUS
:
9607 case EM_SPARC
: /* R_SPARC_NONE. */
9608 case EM_MIPS
: /* R_MIPS_NONE. */
9609 case EM_PARISC
: /* R_PARISC_NONE. */
9610 case EM_ALPHA
: /* R_ALPHA_NONE. */
9611 case EM_PPC
: /* R_PPC_NONE. */
9612 case EM_PPC64
: /* R_PPC64_NONE. */
9613 case EM_ARM
: /* R_ARM_NONE. */
9614 case EM_IA_64
: /* R_IA64_NONE. */
9615 case EM_SH
: /* R_SH_NONE. */
9617 case EM_S390
: /* R_390_NONE. */
9618 case EM_CRIS
: /* R_CRIS_NONE. */
9619 case EM_X86_64
: /* R_X86_64_NONE. */
9620 case EM_L1OM
: /* R_X86_64_NONE. */
9621 case EM_MN10300
: /* R_MN10300_NONE. */
9622 case EM_MOXIE
: /* R_MOXIE_NONE. */
9623 case EM_M32R
: /* R_M32R_NONE. */
9624 case EM_TI_C6000
:/* R_C6000_NONE. */
9626 case EM_C166
: /* R_XC16X_NONE. */
9627 return reloc_type
== 0;
9630 return (reloc_type
== 0 /* R_XTENSA_NONE. */
9631 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
9632 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
9633 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
9638 /* Apply relocations to a section.
9639 Note: So far support has been added only for those relocations
9640 which can be found in debug sections.
9641 FIXME: Add support for more relocations ? */
9644 apply_relocations (void * file
,
9645 Elf_Internal_Shdr
* section
,
9646 unsigned char * start
)
9648 Elf_Internal_Shdr
* relsec
;
9649 unsigned char * end
= start
+ section
->sh_size
;
9651 if (elf_header
.e_type
!= ET_REL
)
9654 /* Find the reloc section associated with the section. */
9655 for (relsec
= section_headers
;
9656 relsec
< section_headers
+ elf_header
.e_shnum
;
9659 bfd_boolean is_rela
;
9660 unsigned long num_relocs
;
9661 Elf_Internal_Rela
* relocs
;
9662 Elf_Internal_Rela
* rp
;
9663 Elf_Internal_Shdr
* symsec
;
9664 Elf_Internal_Sym
* symtab
;
9665 Elf_Internal_Sym
* sym
;
9667 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
9668 || relsec
->sh_info
>= elf_header
.e_shnum
9669 || section_headers
+ relsec
->sh_info
!= section
9670 || relsec
->sh_size
== 0
9671 || relsec
->sh_link
>= elf_header
.e_shnum
)
9674 is_rela
= relsec
->sh_type
== SHT_RELA
;
9678 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
9679 relsec
->sh_size
, & relocs
, & num_relocs
))
9684 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
9685 relsec
->sh_size
, & relocs
, & num_relocs
))
9689 /* SH uses RELA but uses in place value instead of the addend field. */
9690 if (elf_header
.e_machine
== EM_SH
)
9693 symsec
= section_headers
+ relsec
->sh_link
;
9694 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
);
9696 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
9699 unsigned int reloc_type
;
9700 unsigned int reloc_size
;
9701 unsigned char * rloc
;
9703 reloc_type
= get_reloc_type (rp
->r_info
);
9705 if (target_specific_reloc_handling (rp
, start
, symtab
))
9707 else if (is_none_reloc (reloc_type
))
9709 else if (is_32bit_abs_reloc (reloc_type
)
9710 || is_32bit_pcrel_reloc (reloc_type
))
9712 else if (is_64bit_abs_reloc (reloc_type
)
9713 || is_64bit_pcrel_reloc (reloc_type
))
9715 else if (is_24bit_abs_reloc (reloc_type
))
9717 else if (is_16bit_abs_reloc (reloc_type
))
9721 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
9722 reloc_type
, SECTION_NAME (section
));
9726 rloc
= start
+ rp
->r_offset
;
9727 if ((rloc
+ reloc_size
) > end
)
9729 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
9730 (unsigned long) rp
->r_offset
,
9731 SECTION_NAME (section
));
9735 sym
= symtab
+ get_reloc_symindex (rp
->r_info
);
9737 /* If the reloc has a symbol associated with it,
9738 make sure that it is of an appropriate type.
9740 Relocations against symbols without type can happen.
9741 Gcc -feliminate-dwarf2-dups may generate symbols
9742 without type for debug info.
9744 Icc generates relocations against function symbols
9745 instead of local labels.
9747 Relocations against object symbols can happen, eg when
9748 referencing a global array. For an example of this see
9749 the _clz.o binary in libgcc.a. */
9751 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
9753 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
9754 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
9755 (long int)(rp
- relocs
),
9756 SECTION_NAME (relsec
));
9762 addend
+= rp
->r_addend
;
9763 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
9766 || (elf_header
.e_machine
== EM_XTENSA
9768 || ((elf_header
.e_machine
== EM_PJ
9769 || elf_header
.e_machine
== EM_PJ_OLD
)
9771 || ((elf_header
.e_machine
== EM_D30V
9772 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
9773 && reloc_type
== 12))
9774 addend
+= byte_get (rloc
, reloc_size
);
9776 if (is_32bit_pcrel_reloc (reloc_type
)
9777 || is_64bit_pcrel_reloc (reloc_type
))
9779 /* On HPPA, all pc-relative relocations are biased by 8. */
9780 if (elf_header
.e_machine
== EM_PARISC
)
9782 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
9786 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
9795 #ifdef SUPPORT_DISASSEMBLY
9797 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
9799 printf (_("\nAssembly dump of section %s\n"),
9800 SECTION_NAME (section
));
9802 /* XXX -- to be done --- XXX */
9808 /* Reads in the contents of SECTION from FILE, returning a pointer
9809 to a malloc'ed buffer or NULL if something went wrong. */
9812 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
9814 bfd_size_type num_bytes
;
9816 num_bytes
= section
->sh_size
;
9818 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
9820 printf (_("\nSection '%s' has no data to dump.\n"),
9821 SECTION_NAME (section
));
9825 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
9826 _("section contents"));
9831 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
9833 Elf_Internal_Shdr
* relsec
;
9834 bfd_size_type num_bytes
;
9838 char * name
= SECTION_NAME (section
);
9839 bfd_boolean some_strings_shown
;
9841 start
= get_section_contents (section
, file
);
9845 printf (_("\nString dump of section '%s':\n"), name
);
9847 /* If the section being dumped has relocations against it the user might
9848 be expecting these relocations to have been applied. Check for this
9849 case and issue a warning message in order to avoid confusion.
9850 FIXME: Maybe we ought to have an option that dumps a section with
9852 for (relsec
= section_headers
;
9853 relsec
< section_headers
+ elf_header
.e_shnum
;
9856 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
9857 || relsec
->sh_info
>= elf_header
.e_shnum
9858 || section_headers
+ relsec
->sh_info
!= section
9859 || relsec
->sh_size
== 0
9860 || relsec
->sh_link
>= elf_header
.e_shnum
)
9863 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
9867 num_bytes
= section
->sh_size
;
9869 end
= start
+ num_bytes
;
9870 some_strings_shown
= FALSE
;
9874 while (!ISPRINT (* data
))
9881 /* PR 11128: Use two separate invocations in order to work
9882 around bugs in the Solaris 8 implementation of printf. */
9883 printf (" [%6tx] ", data
- start
);
9884 printf ("%s\n", data
);
9886 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
9888 data
+= strlen (data
);
9889 some_strings_shown
= TRUE
;
9893 if (! some_strings_shown
)
9894 printf (_(" No strings found in this section."));
9902 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
9904 bfd_boolean relocate
)
9906 Elf_Internal_Shdr
* relsec
;
9907 bfd_size_type bytes
;
9909 unsigned char * data
;
9910 unsigned char * start
;
9912 start
= (unsigned char *) get_section_contents (section
, file
);
9916 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
9920 apply_relocations (file
, section
, start
);
9924 /* If the section being dumped has relocations against it the user might
9925 be expecting these relocations to have been applied. Check for this
9926 case and issue a warning message in order to avoid confusion.
9927 FIXME: Maybe we ought to have an option that dumps a section with
9929 for (relsec
= section_headers
;
9930 relsec
< section_headers
+ elf_header
.e_shnum
;
9933 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
9934 || relsec
->sh_info
>= elf_header
.e_shnum
9935 || section_headers
+ relsec
->sh_info
!= section
9936 || relsec
->sh_size
== 0
9937 || relsec
->sh_link
>= elf_header
.e_shnum
)
9940 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
9945 addr
= section
->sh_addr
;
9946 bytes
= section
->sh_size
;
9955 lbytes
= (bytes
> 16 ? 16 : bytes
);
9957 printf (" 0x%8.8lx ", (unsigned long) addr
);
9959 for (j
= 0; j
< 16; j
++)
9962 printf ("%2.2x", data
[j
]);
9970 for (j
= 0; j
< lbytes
; j
++)
9973 if (k
>= ' ' && k
< 0x7f)
9991 /* Uncompresses a section that was compressed using zlib, in place. */
9994 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED
,
9995 dwarf_size_type
*size ATTRIBUTE_UNUSED
)
10000 dwarf_size_type compressed_size
= *size
;
10001 unsigned char * compressed_buffer
= *buffer
;
10002 dwarf_size_type uncompressed_size
;
10003 unsigned char * uncompressed_buffer
;
10006 dwarf_size_type header_size
= 12;
10008 /* Read the zlib header. In this case, it should be "ZLIB" followed
10009 by the uncompressed section size, 8 bytes in big-endian order. */
10010 if (compressed_size
< header_size
10011 || ! streq ((char *) compressed_buffer
, "ZLIB"))
10014 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
10015 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
10016 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
10017 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
10018 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
10019 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
10020 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
10021 uncompressed_size
+= compressed_buffer
[11];
10023 /* It is possible the section consists of several compressed
10024 buffers concatenated together, so we uncompress in a loop. */
10025 strm
.zalloc
= NULL
;
10027 strm
.opaque
= NULL
;
10028 strm
.avail_in
= compressed_size
- header_size
;
10029 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
10030 strm
.avail_out
= uncompressed_size
;
10031 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
10033 rc
= inflateInit (& strm
);
10034 while (strm
.avail_in
> 0)
10038 strm
.next_out
= ((Bytef
*) uncompressed_buffer
10039 + (uncompressed_size
- strm
.avail_out
));
10040 rc
= inflate (&strm
, Z_FINISH
);
10041 if (rc
!= Z_STREAM_END
)
10043 rc
= inflateReset (& strm
);
10045 rc
= inflateEnd (& strm
);
10047 || strm
.avail_out
!= 0)
10050 free (compressed_buffer
);
10051 *buffer
= uncompressed_buffer
;
10052 *size
= uncompressed_size
;
10056 free (uncompressed_buffer
);
10057 /* Indicate decompression failure. */
10060 #endif /* HAVE_ZLIB_H */
10064 load_specific_debug_section (enum dwarf_section_display_enum debug
,
10065 Elf_Internal_Shdr
* sec
, void * file
)
10067 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
10070 /* If it is already loaded, do nothing. */
10071 if (section
->start
!= NULL
)
10074 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
10075 section
->address
= sec
->sh_addr
;
10076 section
->size
= sec
->sh_size
;
10077 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
10079 sec
->sh_size
, buf
);
10080 if (uncompress_section_contents (§ion
->start
, §ion
->size
))
10081 sec
->sh_size
= section
->size
;
10083 if (section
->start
== NULL
)
10086 if (debug_displays
[debug
].relocate
)
10087 apply_relocations ((FILE *) file
, sec
, section
->start
);
10093 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
10095 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
10096 Elf_Internal_Shdr
* sec
;
10098 /* Locate the debug section. */
10099 sec
= find_section (section
->uncompressed_name
);
10101 section
->name
= section
->uncompressed_name
;
10104 sec
= find_section (section
->compressed_name
);
10106 section
->name
= section
->compressed_name
;
10111 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
10115 free_debug_section (enum dwarf_section_display_enum debug
)
10117 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
10119 if (section
->start
== NULL
)
10122 free ((char *) section
->start
);
10123 section
->start
= NULL
;
10124 section
->address
= 0;
10129 display_debug_section (Elf_Internal_Shdr
* section
, FILE * file
)
10131 char * name
= SECTION_NAME (section
);
10132 bfd_size_type length
;
10136 length
= section
->sh_size
;
10139 printf (_("\nSection '%s' has no debugging data.\n"), name
);
10142 if (section
->sh_type
== SHT_NOBITS
)
10144 /* There is no point in dumping the contents of a debugging section
10145 which has the NOBITS type - the bits in the file will be random.
10146 This can happen when a file containing a .eh_frame section is
10147 stripped with the --only-keep-debug command line option. */
10148 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name
);
10152 if (const_strneq (name
, ".gnu.linkonce.wi."))
10153 name
= ".debug_info";
10155 /* See if we know how to display the contents of this section. */
10156 for (i
= 0; i
< max
; i
++)
10157 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
10158 || streq (debug_displays
[i
].section
.compressed_name
, name
))
10160 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
10161 int secondary
= (section
!= find_section (name
));
10164 free_debug_section ((enum dwarf_section_display_enum
) i
);
10166 if (streq (sec
->uncompressed_name
, name
))
10167 sec
->name
= sec
->uncompressed_name
;
10169 sec
->name
= sec
->compressed_name
;
10170 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
10173 result
&= debug_displays
[i
].display (sec
, file
);
10175 if (secondary
|| (i
!= info
&& i
!= abbrev
))
10176 free_debug_section ((enum dwarf_section_display_enum
) i
);
10184 printf (_("Unrecognized debug section: %s\n"), name
);
10191 /* Set DUMP_SECTS for all sections where dumps were requested
10192 based on section name. */
10195 initialise_dumps_byname (void)
10197 struct dump_list_entry
* cur
;
10199 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
10204 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
10205 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
10207 request_dump_bynumber (i
, cur
->type
);
10212 warn (_("Section '%s' was not dumped because it does not exist!\n"),
10218 process_section_contents (FILE * file
)
10220 Elf_Internal_Shdr
* section
;
10226 initialise_dumps_byname ();
10228 for (i
= 0, section
= section_headers
;
10229 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
10232 #ifdef SUPPORT_DISASSEMBLY
10233 if (dump_sects
[i
] & DISASS_DUMP
)
10234 disassemble_section (section
, file
);
10236 if (dump_sects
[i
] & HEX_DUMP
)
10237 dump_section_as_bytes (section
, file
, FALSE
);
10239 if (dump_sects
[i
] & RELOC_DUMP
)
10240 dump_section_as_bytes (section
, file
, TRUE
);
10242 if (dump_sects
[i
] & STRING_DUMP
)
10243 dump_section_as_strings (section
, file
);
10245 if (dump_sects
[i
] & DEBUG_DUMP
)
10246 display_debug_section (section
, file
);
10249 /* Check to see if the user requested a
10250 dump of a section that does not exist. */
10251 while (i
++ < num_dump_sects
)
10253 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
10257 process_mips_fpe_exception (int mask
)
10262 if (mask
& OEX_FPU_INEX
)
10263 fputs ("INEX", stdout
), first
= 0;
10264 if (mask
& OEX_FPU_UFLO
)
10265 printf ("%sUFLO", first
? "" : "|"), first
= 0;
10266 if (mask
& OEX_FPU_OFLO
)
10267 printf ("%sOFLO", first
? "" : "|"), first
= 0;
10268 if (mask
& OEX_FPU_DIV0
)
10269 printf ("%sDIV0", first
? "" : "|"), first
= 0;
10270 if (mask
& OEX_FPU_INVAL
)
10271 printf ("%sINVAL", first
? "" : "|");
10274 fputs ("0", stdout
);
10277 /* ARM EABI attributes section. */
10282 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
10284 const char ** table
;
10285 } arm_attr_public_tag
;
10287 static const char * arm_attr_tag_CPU_arch
[] =
10288 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
10289 "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
10290 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
10291 static const char * arm_attr_tag_THUMB_ISA_use
[] =
10292 {"No", "Thumb-1", "Thumb-2"};
10293 static const char * arm_attr_tag_FP_arch
[] =
10294 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
10295 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
10296 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
10297 {"No", "NEONv1", "NEONv1 with Fused-MAC"};
10298 static const char * arm_attr_tag_PCS_config
[] =
10299 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
10300 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
10301 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
10302 {"V6", "SB", "TLS", "Unused"};
10303 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
10304 {"Absolute", "PC-relative", "SB-relative", "None"};
10305 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
10306 {"Absolute", "PC-relative", "None"};
10307 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
10308 {"None", "direct", "GOT-indirect"};
10309 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
10310 {"None", "??? 1", "2", "??? 3", "4"};
10311 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
10312 static const char * arm_attr_tag_ABI_FP_denormal
[] =
10313 {"Unused", "Needed", "Sign only"};
10314 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
10315 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
10316 static const char * arm_attr_tag_ABI_FP_number_model
[] =
10317 {"Unused", "Finite", "RTABI", "IEEE 754"};
10318 static const char * arm_attr_tag_ABI_enum_size
[] =
10319 {"Unused", "small", "int", "forced to int"};
10320 static const char * arm_attr_tag_ABI_HardFP_use
[] =
10321 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
10322 static const char * arm_attr_tag_ABI_VFP_args
[] =
10323 {"AAPCS", "VFP registers", "custom"};
10324 static const char * arm_attr_tag_ABI_WMMX_args
[] =
10325 {"AAPCS", "WMMX registers", "custom"};
10326 static const char * arm_attr_tag_ABI_optimization_goals
[] =
10327 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10328 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
10329 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
10330 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10331 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
10332 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
10333 static const char * arm_attr_tag_FP_HP_extension
[] =
10334 {"Not Allowed", "Allowed"};
10335 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
10336 {"None", "IEEE 754", "Alternative Format"};
10337 static const char * arm_attr_tag_MPextension_use
[] =
10338 {"Not Allowed", "Allowed"};
10339 static const char * arm_attr_tag_DIV_use
[] =
10340 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
10341 "Allowed in v7-A with integer division extension"};
10342 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
10343 static const char * arm_attr_tag_Virtualization_use
[] =
10344 {"Not Allowed", "TrustZone", "Virtualization Extensions",
10345 "TrustZone and Virtualization Extensions"};
10346 static const char * arm_attr_tag_MPextension_use_legacy
[] =
10347 {"Not Allowed", "Allowed"};
10349 #define LOOKUP(id, name) \
10350 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
10351 static arm_attr_public_tag arm_attr_public_tags
[] =
10353 {4, "CPU_raw_name", 1, NULL
},
10354 {5, "CPU_name", 1, NULL
},
10355 LOOKUP(6, CPU_arch
),
10356 {7, "CPU_arch_profile", 0, NULL
},
10357 LOOKUP(8, ARM_ISA_use
),
10358 LOOKUP(9, THUMB_ISA_use
),
10359 LOOKUP(10, FP_arch
),
10360 LOOKUP(11, WMMX_arch
),
10361 LOOKUP(12, Advanced_SIMD_arch
),
10362 LOOKUP(13, PCS_config
),
10363 LOOKUP(14, ABI_PCS_R9_use
),
10364 LOOKUP(15, ABI_PCS_RW_data
),
10365 LOOKUP(16, ABI_PCS_RO_data
),
10366 LOOKUP(17, ABI_PCS_GOT_use
),
10367 LOOKUP(18, ABI_PCS_wchar_t
),
10368 LOOKUP(19, ABI_FP_rounding
),
10369 LOOKUP(20, ABI_FP_denormal
),
10370 LOOKUP(21, ABI_FP_exceptions
),
10371 LOOKUP(22, ABI_FP_user_exceptions
),
10372 LOOKUP(23, ABI_FP_number_model
),
10373 {24, "ABI_align_needed", 0, NULL
},
10374 {25, "ABI_align_preserved", 0, NULL
},
10375 LOOKUP(26, ABI_enum_size
),
10376 LOOKUP(27, ABI_HardFP_use
),
10377 LOOKUP(28, ABI_VFP_args
),
10378 LOOKUP(29, ABI_WMMX_args
),
10379 LOOKUP(30, ABI_optimization_goals
),
10380 LOOKUP(31, ABI_FP_optimization_goals
),
10381 {32, "compatibility", 0, NULL
},
10382 LOOKUP(34, CPU_unaligned_access
),
10383 LOOKUP(36, FP_HP_extension
),
10384 LOOKUP(38, ABI_FP_16bit_format
),
10385 LOOKUP(42, MPextension_use
),
10386 LOOKUP(44, DIV_use
),
10387 {64, "nodefaults", 0, NULL
},
10388 {65, "also_compatible_with", 0, NULL
},
10389 LOOKUP(66, T2EE_use
),
10390 {67, "conformance", 1, NULL
},
10391 LOOKUP(68, Virtualization_use
),
10392 LOOKUP(70, MPextension_use_legacy
)
10396 static unsigned char *
10397 display_arm_attribute (unsigned char * p
)
10402 arm_attr_public_tag
* attr
;
10406 tag
= read_uleb128 (p
, &len
);
10409 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
10411 if (arm_attr_public_tags
[i
].tag
== tag
)
10413 attr
= &arm_attr_public_tags
[i
];
10420 printf (" Tag_%s: ", attr
->name
);
10421 switch (attr
->type
)
10426 case 7: /* Tag_CPU_arch_profile. */
10427 val
= read_uleb128 (p
, &len
);
10431 case 0: printf (_("None\n")); break;
10432 case 'A': printf (_("Application\n")); break;
10433 case 'R': printf (_("Realtime\n")); break;
10434 case 'M': printf (_("Microcontroller\n")); break;
10435 case 'S': printf (_("Application or Realtime\n")); break;
10436 default: printf ("??? (%d)\n", val
); break;
10440 case 24: /* Tag_align_needed. */
10441 val
= read_uleb128 (p
, &len
);
10445 case 0: printf (_("None\n")); break;
10446 case 1: printf (_("8-byte\n")); break;
10447 case 2: printf (_("4-byte\n")); break;
10448 case 3: printf ("??? 3\n"); break;
10451 printf (_("8-byte and up to %d-byte extended\n"),
10454 printf ("??? (%d)\n", val
);
10459 case 25: /* Tag_align_preserved. */
10460 val
= read_uleb128 (p
, &len
);
10464 case 0: printf (_("None\n")); break;
10465 case 1: printf (_("8-byte, except leaf SP\n")); break;
10466 case 2: printf (_("8-byte\n")); break;
10467 case 3: printf ("??? 3\n"); break;
10470 printf (_("8-byte and up to %d-byte extended\n"),
10473 printf ("??? (%d)\n", val
);
10478 case 32: /* Tag_compatibility. */
10479 val
= read_uleb128 (p
, &len
);
10481 printf (_("flag = %d, vendor = %s\n"), val
, p
);
10482 p
+= strlen ((char *) p
) + 1;
10485 case 64: /* Tag_nodefaults. */
10487 printf (_("True\n"));
10490 case 65: /* Tag_also_compatible_with. */
10491 val
= read_uleb128 (p
, &len
);
10493 if (val
== 6 /* Tag_CPU_arch. */)
10495 val
= read_uleb128 (p
, &len
);
10497 if ((unsigned int)val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
10498 printf ("??? (%d)\n", val
);
10500 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
10504 while (*(p
++) != '\0' /* NUL terminator. */);
10518 assert (attr
->type
& 0x80);
10519 val
= read_uleb128 (p
, &len
);
10521 type
= attr
->type
& 0x7f;
10523 printf ("??? (%d)\n", val
);
10525 printf ("%s\n", attr
->table
[val
]);
10532 type
= 1; /* String. */
10534 type
= 2; /* uleb128. */
10535 printf (" Tag_unknown_%d: ", tag
);
10540 printf ("\"%s\"\n", p
);
10541 p
+= strlen ((char *) p
) + 1;
10545 val
= read_uleb128 (p
, &len
);
10547 printf ("%d (0x%x)\n", val
, val
);
10553 static unsigned char *
10554 display_gnu_attribute (unsigned char * p
,
10555 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
10562 tag
= read_uleb128 (p
, &len
);
10565 /* Tag_compatibility is the only generic GNU attribute defined at
10569 val
= read_uleb128 (p
, &len
);
10571 printf (_("flag = %d, vendor = %s\n"), val
, p
);
10572 p
+= strlen ((char *) p
) + 1;
10576 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
10577 return display_proc_gnu_attribute (p
, tag
);
10580 type
= 1; /* String. */
10582 type
= 2; /* uleb128. */
10583 printf (" Tag_unknown_%d: ", tag
);
10587 printf ("\"%s\"\n", p
);
10588 p
+= strlen ((char *) p
) + 1;
10592 val
= read_uleb128 (p
, &len
);
10594 printf ("%d (0x%x)\n", val
, val
);
10600 static unsigned char *
10601 display_power_gnu_attribute (unsigned char * p
, int tag
)
10607 if (tag
== Tag_GNU_Power_ABI_FP
)
10609 val
= read_uleb128 (p
, &len
);
10611 printf (" Tag_GNU_Power_ABI_FP: ");
10616 printf (_("Hard or soft float\n"));
10619 printf (_("Hard float\n"));
10622 printf (_("Soft float\n"));
10625 printf (_("Single-precision hard float\n"));
10628 printf ("??? (%d)\n", val
);
10634 if (tag
== Tag_GNU_Power_ABI_Vector
)
10636 val
= read_uleb128 (p
, &len
);
10638 printf (" Tag_GNU_Power_ABI_Vector: ");
10642 printf (_("Any\n"));
10645 printf (_("Generic\n"));
10648 printf ("AltiVec\n");
10654 printf ("??? (%d)\n", val
);
10660 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
10662 val
= read_uleb128 (p
, &len
);
10664 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
10668 printf (_("Any\n"));
10671 printf ("r3/r4\n");
10674 printf (_("Memory\n"));
10677 printf ("??? (%d)\n", val
);
10684 type
= 1; /* String. */
10686 type
= 2; /* uleb128. */
10687 printf (" Tag_unknown_%d: ", tag
);
10691 printf ("\"%s\"\n", p
);
10692 p
+= strlen ((char *) p
) + 1;
10696 val
= read_uleb128 (p
, &len
);
10698 printf ("%d (0x%x)\n", val
, val
);
10704 static unsigned char *
10705 display_mips_gnu_attribute (unsigned char * p
, int tag
)
10711 if (tag
== Tag_GNU_MIPS_ABI_FP
)
10713 val
= read_uleb128 (p
, &len
);
10715 printf (" Tag_GNU_MIPS_ABI_FP: ");
10720 printf (_("Hard or soft float\n"));
10723 printf (_("Hard float (double precision)\n"));
10726 printf (_("Hard float (single precision)\n"));
10729 printf (_("Soft float\n"));
10732 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
10735 printf ("??? (%d)\n", val
);
10742 type
= 1; /* String. */
10744 type
= 2; /* uleb128. */
10745 printf (" Tag_unknown_%d: ", tag
);
10749 printf ("\"%s\"\n", p
);
10750 p
+= strlen ((char *) p
) + 1;
10754 val
= read_uleb128 (p
, &len
);
10756 printf ("%d (0x%x)\n", val
, val
);
10762 static unsigned char *
10763 display_tic6x_attribute (unsigned char * p
)
10769 tag
= read_uleb128 (p
, &len
);
10775 val
= read_uleb128 (p
, &len
);
10777 printf (" Tag_ISA: ");
10781 case C6XABI_Tag_ISA_none
:
10782 printf (_("None\n"));
10784 case C6XABI_Tag_ISA_C62X
:
10787 case C6XABI_Tag_ISA_C67X
:
10790 case C6XABI_Tag_ISA_C67XP
:
10791 printf ("C67x+\n");
10793 case C6XABI_Tag_ISA_C64X
:
10796 case C6XABI_Tag_ISA_C64XP
:
10797 printf ("C64x+\n");
10799 case C6XABI_Tag_ISA_C674X
:
10800 printf ("C674x\n");
10803 printf ("??? (%d)\n", val
);
10808 case Tag_ABI_wchar_t
:
10809 val
= read_uleb128 (p
, &len
);
10811 printf (" Tag_ABI_wchar_t: ");
10815 printf (_("Not used\n"));
10818 printf (_("2 bytes\n"));
10821 printf (_("4 bytes\n"));
10824 printf ("??? (%d)\n", val
);
10829 case Tag_ABI_stack_align_needed
:
10830 val
= read_uleb128 (p
, &len
);
10832 printf (" Tag_ABI_stack_align_needed: ");
10836 printf (_("8-byte\n"));
10839 printf (_("16-byte\n"));
10842 printf ("??? (%d)\n", val
);
10847 case Tag_ABI_stack_align_preserved
:
10848 val
= read_uleb128 (p
, &len
);
10850 printf (" Tag_ABI_stack_align_preserved: ");
10854 printf (_("8-byte\n"));
10857 printf (_("16-byte\n"));
10860 printf ("??? (%d)\n", val
);
10866 val
= read_uleb128 (p
, &len
);
10868 printf (" Tag_ABI_DSBT: ");
10872 printf (_("DSBT addressing not used\n"));
10875 printf (_("DSBT addressing used\n"));
10878 printf ("??? (%d)\n", val
);
10884 val
= read_uleb128 (p
, &len
);
10886 printf (" Tag_ABI_PID: ");
10890 printf (_("Data addressing position-dependent\n"));
10893 printf (_("Data addressing position-independent, GOT near DP\n"));
10896 printf (_("Data addressing position-independent, GOT far from DP\n"));
10899 printf ("??? (%d)\n", val
);
10905 val
= read_uleb128 (p
, &len
);
10907 printf (" Tag_ABI_PIC: ");
10911 printf (_("Code addressing position-dependent\n"));
10914 printf (_("Code addressing position-independent\n"));
10917 printf ("??? (%d)\n", val
);
10922 case Tag_ABI_array_object_alignment
:
10923 val
= read_uleb128 (p
, &len
);
10925 printf (" Tag_ABI_array_object_alignment: ");
10929 printf (_("8-byte\n"));
10932 printf (_("4-byte\n"));
10935 printf (_("16-byte\n"));
10938 printf ("??? (%d)\n", val
);
10943 case Tag_ABI_array_object_align_expected
:
10944 val
= read_uleb128 (p
, &len
);
10946 printf (" Tag_ABI_array_object_align_expected: ");
10950 printf (_("8-byte\n"));
10953 printf (_("4-byte\n"));
10956 printf (_("16-byte\n"));
10959 printf ("??? (%d)\n", val
);
10964 case Tag_ABI_compatibility
:
10965 val
= read_uleb128 (p
, &len
);
10967 printf (" Tag_ABI_compatibility: ");
10968 printf (_("flag = %d, vendor = %s\n"), val
, p
);
10969 p
+= strlen ((char *) p
) + 1;
10972 case Tag_ABI_conformance
:
10973 printf (" Tag_ABI_conformance: ");
10974 printf ("\"%s\"\n", p
);
10975 p
+= strlen ((char *) p
) + 1;
10979 printf (" Tag_unknown_%d: ", tag
);
10983 printf ("\"%s\"\n", p
);
10984 p
+= strlen ((char *) p
) + 1;
10988 val
= read_uleb128 (p
, &len
);
10990 printf ("%d (0x%x)\n", val
, val
);
10997 process_attributes (FILE * file
,
10998 const char * public_name
,
10999 unsigned int proc_type
,
11000 unsigned char * (* display_pub_attribute
) (unsigned char *),
11001 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
11003 Elf_Internal_Shdr
* sect
;
11004 unsigned char * contents
;
11006 unsigned char * end
;
11007 bfd_vma section_len
;
11011 /* Find the section header so that we get the size. */
11012 for (i
= 0, sect
= section_headers
;
11013 i
< elf_header
.e_shnum
;
11016 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
11019 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
11020 sect
->sh_size
, _("attributes"));
11021 if (contents
== NULL
)
11027 len
= sect
->sh_size
- 1;
11033 bfd_boolean public_section
;
11034 bfd_boolean gnu_section
;
11036 section_len
= byte_get (p
, 4);
11039 if (section_len
> len
)
11041 printf (_("ERROR: Bad section length (%d > %d)\n"),
11042 (int) section_len
, (int) len
);
11046 len
-= section_len
;
11047 printf (_("Attribute Section: %s\n"), p
);
11049 if (public_name
&& streq ((char *) p
, public_name
))
11050 public_section
= TRUE
;
11052 public_section
= FALSE
;
11054 if (streq ((char *) p
, "gnu"))
11055 gnu_section
= TRUE
;
11057 gnu_section
= FALSE
;
11059 namelen
= strlen ((char *) p
) + 1;
11061 section_len
-= namelen
+ 4;
11063 while (section_len
> 0)
11069 size
= byte_get (p
, 4);
11070 if (size
> section_len
)
11072 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
11073 (int) size
, (int) section_len
);
11074 size
= section_len
;
11077 section_len
-= size
;
11078 end
= p
+ size
- 1;
11084 printf (_("File Attributes\n"));
11087 printf (_("Section Attributes:"));
11090 printf (_("Symbol Attributes:"));
11096 val
= read_uleb128 (p
, &j
);
11100 printf (" %d", val
);
11105 printf (_("Unknown tag: %d\n"), tag
);
11106 public_section
= FALSE
;
11110 if (public_section
)
11113 p
= display_pub_attribute (p
);
11115 else if (gnu_section
)
11118 p
= display_gnu_attribute (p
,
11119 display_proc_gnu_attribute
);
11123 /* ??? Do something sensible, like dump hex. */
11124 printf (_(" Unknown section contexts\n"));
11131 printf (_("Unknown format '%c'\n"), *p
);
11139 process_arm_specific (FILE * file
)
11141 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
11142 display_arm_attribute
, NULL
);
11146 process_power_specific (FILE * file
)
11148 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
11149 display_power_gnu_attribute
);
11153 process_tic6x_specific (FILE * file
)
11155 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
11156 display_tic6x_attribute
, NULL
);
11159 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
11160 Print the Address, Access and Initial fields of an entry at VMA ADDR
11161 and return the VMA of the next entry. */
11164 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
11167 print_vma (addr
, LONG_HEX
);
11169 if (addr
< pltgot
+ 0xfff0)
11170 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
11172 printf ("%10s", "");
11175 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
11180 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
11181 print_vma (entry
, LONG_HEX
);
11183 return addr
+ (is_32bit_elf
? 4 : 8);
11186 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
11187 PLTGOT. Print the Address and Initial fields of an entry at VMA
11188 ADDR and return the VMA of the next entry. */
11191 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
11194 print_vma (addr
, LONG_HEX
);
11197 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
11202 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
11203 print_vma (entry
, LONG_HEX
);
11205 return addr
+ (is_32bit_elf
? 4 : 8);
11209 process_mips_specific (FILE * file
)
11211 Elf_Internal_Dyn
* entry
;
11212 size_t liblist_offset
= 0;
11213 size_t liblistno
= 0;
11214 size_t conflictsno
= 0;
11215 size_t options_offset
= 0;
11216 size_t conflicts_offset
= 0;
11217 size_t pltrelsz
= 0;
11219 bfd_vma pltgot
= 0;
11220 bfd_vma mips_pltgot
= 0;
11221 bfd_vma jmprel
= 0;
11222 bfd_vma local_gotno
= 0;
11223 bfd_vma gotsym
= 0;
11224 bfd_vma symtabno
= 0;
11226 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
11227 display_mips_gnu_attribute
);
11229 /* We have a lot of special sections. Thanks SGI! */
11230 if (dynamic_section
== NULL
)
11231 /* No information available. */
11234 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
11235 switch (entry
->d_tag
)
11237 case DT_MIPS_LIBLIST
:
11239 = offset_from_vma (file
, entry
->d_un
.d_val
,
11240 liblistno
* sizeof (Elf32_External_Lib
));
11242 case DT_MIPS_LIBLISTNO
:
11243 liblistno
= entry
->d_un
.d_val
;
11245 case DT_MIPS_OPTIONS
:
11246 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
11248 case DT_MIPS_CONFLICT
:
11250 = offset_from_vma (file
, entry
->d_un
.d_val
,
11251 conflictsno
* sizeof (Elf32_External_Conflict
));
11253 case DT_MIPS_CONFLICTNO
:
11254 conflictsno
= entry
->d_un
.d_val
;
11257 pltgot
= entry
->d_un
.d_ptr
;
11259 case DT_MIPS_LOCAL_GOTNO
:
11260 local_gotno
= entry
->d_un
.d_val
;
11262 case DT_MIPS_GOTSYM
:
11263 gotsym
= entry
->d_un
.d_val
;
11265 case DT_MIPS_SYMTABNO
:
11266 symtabno
= entry
->d_un
.d_val
;
11268 case DT_MIPS_PLTGOT
:
11269 mips_pltgot
= entry
->d_un
.d_ptr
;
11272 pltrel
= entry
->d_un
.d_val
;
11275 pltrelsz
= entry
->d_un
.d_val
;
11278 jmprel
= entry
->d_un
.d_ptr
;
11284 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
11286 Elf32_External_Lib
* elib
;
11289 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
11291 sizeof (Elf32_External_Lib
),
11295 printf (_("\nSection '.liblist' contains %lu entries:\n"),
11296 (unsigned long) liblistno
);
11297 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
11300 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
11307 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11308 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11309 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11310 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11311 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11313 tmp
= gmtime (&atime
);
11314 snprintf (timebuf
, sizeof (timebuf
),
11315 "%04u-%02u-%02uT%02u:%02u:%02u",
11316 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11317 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11319 printf ("%3lu: ", (unsigned long) cnt
);
11320 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
11321 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
11323 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
11324 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
11325 liblist
.l_version
);
11327 if (liblist
.l_flags
== 0)
11331 static const struct
11338 { " EXACT_MATCH", LL_EXACT_MATCH
},
11339 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
11340 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
11341 { " EXPORTS", LL_EXPORTS
},
11342 { " DELAY_LOAD", LL_DELAY_LOAD
},
11343 { " DELTA", LL_DELTA
}
11345 int flags
= liblist
.l_flags
;
11348 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
11349 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
11351 fputs (l_flags_vals
[fcnt
].name
, stdout
);
11352 flags
^= l_flags_vals
[fcnt
].bit
;
11355 printf (" %#x", (unsigned int) flags
);
11365 if (options_offset
!= 0)
11367 Elf_External_Options
* eopt
;
11368 Elf_Internal_Shdr
* sect
= section_headers
;
11369 Elf_Internal_Options
* iopt
;
11370 Elf_Internal_Options
* option
;
11374 /* Find the section header so that we get the size. */
11375 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
11378 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
11379 sect
->sh_size
, _("options"));
11382 iopt
= (Elf_Internal_Options
*)
11383 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
11386 error (_("Out of memory\n"));
11393 while (offset
< sect
->sh_size
)
11395 Elf_External_Options
* eoption
;
11397 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
11399 option
->kind
= BYTE_GET (eoption
->kind
);
11400 option
->size
= BYTE_GET (eoption
->size
);
11401 option
->section
= BYTE_GET (eoption
->section
);
11402 option
->info
= BYTE_GET (eoption
->info
);
11404 offset
+= option
->size
;
11410 printf (_("\nSection '%s' contains %d entries:\n"),
11411 SECTION_NAME (sect
), cnt
);
11419 switch (option
->kind
)
11422 /* This shouldn't happen. */
11423 printf (" NULL %d %lx", option
->section
, option
->info
);
11426 printf (" REGINFO ");
11427 if (elf_header
.e_machine
== EM_MIPS
)
11430 Elf32_External_RegInfo
* ereg
;
11431 Elf32_RegInfo reginfo
;
11433 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
11434 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11435 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11436 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11437 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11438 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11439 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11441 printf ("GPR %08lx GP 0x%lx\n",
11442 reginfo
.ri_gprmask
,
11443 (unsigned long) reginfo
.ri_gp_value
);
11444 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11445 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11446 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11451 Elf64_External_RegInfo
* ereg
;
11452 Elf64_Internal_RegInfo reginfo
;
11454 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
11455 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11456 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11457 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11458 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11459 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11460 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11462 printf ("GPR %08lx GP 0x",
11463 reginfo
.ri_gprmask
);
11464 printf_vma (reginfo
.ri_gp_value
);
11467 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11468 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11469 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11473 case ODK_EXCEPTIONS
:
11474 fputs (" EXCEPTIONS fpe_min(", stdout
);
11475 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
11476 fputs (") fpe_max(", stdout
);
11477 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
11478 fputs (")", stdout
);
11480 if (option
->info
& OEX_PAGE0
)
11481 fputs (" PAGE0", stdout
);
11482 if (option
->info
& OEX_SMM
)
11483 fputs (" SMM", stdout
);
11484 if (option
->info
& OEX_FPDBUG
)
11485 fputs (" FPDBUG", stdout
);
11486 if (option
->info
& OEX_DISMISS
)
11487 fputs (" DISMISS", stdout
);
11490 fputs (" PAD ", stdout
);
11491 if (option
->info
& OPAD_PREFIX
)
11492 fputs (" PREFIX", stdout
);
11493 if (option
->info
& OPAD_POSTFIX
)
11494 fputs (" POSTFIX", stdout
);
11495 if (option
->info
& OPAD_SYMBOL
)
11496 fputs (" SYMBOL", stdout
);
11499 fputs (" HWPATCH ", stdout
);
11500 if (option
->info
& OHW_R4KEOP
)
11501 fputs (" R4KEOP", stdout
);
11502 if (option
->info
& OHW_R8KPFETCH
)
11503 fputs (" R8KPFETCH", stdout
);
11504 if (option
->info
& OHW_R5KEOP
)
11505 fputs (" R5KEOP", stdout
);
11506 if (option
->info
& OHW_R5KCVTL
)
11507 fputs (" R5KCVTL", stdout
);
11510 fputs (" FILL ", stdout
);
11511 /* XXX Print content of info word? */
11514 fputs (" TAGS ", stdout
);
11515 /* XXX Print content of info word? */
11518 fputs (" HWAND ", stdout
);
11519 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11520 fputs (" R4KEOP_CHECKED", stdout
);
11521 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11522 fputs (" R4KEOP_CLEAN", stdout
);
11525 fputs (" HWOR ", stdout
);
11526 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11527 fputs (" R4KEOP_CHECKED", stdout
);
11528 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11529 fputs (" R4KEOP_CLEAN", stdout
);
11532 printf (" GP_GROUP %#06lx self-contained %#06lx",
11533 option
->info
& OGP_GROUP
,
11534 (option
->info
& OGP_SELF
) >> 16);
11537 printf (" IDENT %#06lx self-contained %#06lx",
11538 option
->info
& OGP_GROUP
,
11539 (option
->info
& OGP_SELF
) >> 16);
11542 /* This shouldn't happen. */
11543 printf (" %3d ??? %d %lx",
11544 option
->kind
, option
->section
, option
->info
);
11548 len
= sizeof (* eopt
);
11549 while (len
< option
->size
)
11550 if (((char *) option
)[len
] >= ' '
11551 && ((char *) option
)[len
] < 0x7f)
11552 printf ("%c", ((char *) option
)[len
++]);
11554 printf ("\\%03o", ((char *) option
)[len
++]);
11556 fputs ("\n", stdout
);
11564 if (conflicts_offset
!= 0 && conflictsno
!= 0)
11566 Elf32_Conflict
* iconf
;
11569 if (dynamic_symbols
== NULL
)
11571 error (_("conflict list found without a dynamic symbol table\n"));
11575 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
11578 error (_("Out of memory\n"));
11584 Elf32_External_Conflict
* econf32
;
11586 econf32
= (Elf32_External_Conflict
*)
11587 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
11588 sizeof (* econf32
), _("conflict"));
11592 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11593 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
11599 Elf64_External_Conflict
* econf64
;
11601 econf64
= (Elf64_External_Conflict
*)
11602 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
11603 sizeof (* econf64
), _("conflict"));
11607 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11608 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
11613 printf (_("\nSection '.conflict' contains %lu entries:\n"),
11614 (unsigned long) conflictsno
);
11615 puts (_(" Num: Index Value Name"));
11617 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11619 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
11621 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
11622 print_vma (psym
->st_value
, FULL_HEX
);
11624 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11625 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11627 printf (_("<corrupt: %14ld>"), psym
->st_name
);
11634 if (pltgot
!= 0 && local_gotno
!= 0)
11636 bfd_vma ent
, local_end
, global_end
;
11638 unsigned char * data
;
11642 addr_size
= (is_32bit_elf
? 4 : 8);
11643 local_end
= pltgot
+ local_gotno
* addr_size
;
11644 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
11646 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
11647 data
= (unsigned char *) get_data (NULL
, file
, offset
,
11648 global_end
- pltgot
, 1, _("GOT"));
11649 printf (_("\nPrimary GOT:\n"));
11650 printf (_(" Canonical gp value: "));
11651 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
11654 printf (_(" Reserved entries:\n"));
11655 printf (_(" %*s %10s %*s Purpose\n"),
11656 addr_size
* 2, _("Address"), _("Access"),
11657 addr_size
* 2, _("Initial"));
11658 ent
= print_mips_got_entry (data
, pltgot
, ent
);
11659 printf (_(" Lazy resolver\n"));
11661 && (byte_get (data
+ ent
- pltgot
, addr_size
)
11662 >> (addr_size
* 8 - 1)) != 0)
11664 ent
= print_mips_got_entry (data
, pltgot
, ent
);
11665 printf (_(" Module pointer (GNU extension)\n"));
11669 if (ent
< local_end
)
11671 printf (_(" Local entries:\n"));
11672 printf (_(" %*s %10s %*s\n"),
11673 addr_size
* 2, _("Address"), _("Access"),
11674 addr_size
* 2, _("Initial"));
11675 while (ent
< local_end
)
11677 ent
= print_mips_got_entry (data
, pltgot
, ent
);
11683 if (gotsym
< symtabno
)
11687 printf (_(" Global entries:\n"));
11688 printf (_(" %*s %10s %*s %*s %-7s %3s %s\n"),
11689 addr_size
* 2, _("Address"), _("Access"),
11690 addr_size
* 2, _("Initial"),
11691 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
11692 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
11693 for (i
= gotsym
; i
< symtabno
; i
++)
11695 Elf_Internal_Sym
* psym
;
11697 psym
= dynamic_symbols
+ i
;
11698 ent
= print_mips_got_entry (data
, pltgot
, ent
);
11700 print_vma (psym
->st_value
, LONG_HEX
);
11701 printf (" %-7s %3s ",
11702 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
11703 get_symbol_index_type (psym
->st_shndx
));
11704 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11705 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
11707 printf (_("<corrupt: %14ld>"), psym
->st_name
);
11717 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
11720 size_t offset
, rel_offset
;
11721 unsigned long count
, i
;
11722 unsigned char * data
;
11723 int addr_size
, sym_width
;
11724 Elf_Internal_Rela
* rels
;
11726 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
11727 if (pltrel
== DT_RELA
)
11729 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
11734 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
11739 addr_size
= (is_32bit_elf
? 4 : 8);
11740 end
= mips_pltgot
+ (2 + count
) * addr_size
;
11742 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
11743 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
11745 printf (_("\nPLT GOT:\n\n"));
11746 printf (_(" Reserved entries:\n"));
11747 printf (_(" %*s %*s Purpose\n"),
11748 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
11749 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
11750 printf (_(" PLT lazy resolver\n"));
11751 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
11752 printf (_(" Module pointer\n"));
11755 printf (_(" Entries:\n"));
11756 printf (_(" %*s %*s %*s %-7s %3s %s\n"),
11757 addr_size
* 2, _("Address"),
11758 addr_size
* 2, _("Initial"),
11759 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
11760 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
11761 for (i
= 0; i
< count
; i
++)
11763 Elf_Internal_Sym
* psym
;
11765 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
11766 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
11768 print_vma (psym
->st_value
, LONG_HEX
);
11769 printf (" %-7s %3s ",
11770 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
11771 get_symbol_index_type (psym
->st_shndx
));
11772 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11773 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
11775 printf (_("<corrupt: %14ld>"), psym
->st_name
);
11789 process_gnu_liblist (FILE * file
)
11791 Elf_Internal_Shdr
* section
;
11792 Elf_Internal_Shdr
* string_sec
;
11793 Elf32_External_Lib
* elib
;
11795 size_t strtab_size
;
11802 for (i
= 0, section
= section_headers
;
11803 i
< elf_header
.e_shnum
;
11806 switch (section
->sh_type
)
11808 case SHT_GNU_LIBLIST
:
11809 if (section
->sh_link
>= elf_header
.e_shnum
)
11812 elib
= (Elf32_External_Lib
*)
11813 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
11818 string_sec
= section_headers
+ section
->sh_link
;
11820 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
11821 string_sec
->sh_size
,
11822 _("liblist string table"));
11823 strtab_size
= string_sec
->sh_size
;
11826 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
11832 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
11833 SECTION_NAME (section
),
11834 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
11836 puts (_(" Library Time Stamp Checksum Version Flags"));
11838 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
11846 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11847 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11848 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11849 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11850 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11852 tmp
= gmtime (&atime
);
11853 snprintf (timebuf
, sizeof (timebuf
),
11854 "%04u-%02u-%02uT%02u:%02u:%02u",
11855 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11856 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11858 printf ("%3lu: ", (unsigned long) cnt
);
11860 printf ("%-20s", liblist
.l_name
< strtab_size
11861 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
11863 printf ("%-20.20s", liblist
.l_name
< strtab_size
11864 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
11865 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
11866 liblist
.l_version
, liblist
.l_flags
);
11876 static const char *
11877 get_note_type (unsigned e_type
)
11879 static char buff
[64];
11881 if (elf_header
.e_type
== ET_CORE
)
11885 return _("NT_AUXV (auxiliary vector)");
11887 return _("NT_PRSTATUS (prstatus structure)");
11889 return _("NT_FPREGSET (floating point registers)");
11891 return _("NT_PRPSINFO (prpsinfo structure)");
11892 case NT_TASKSTRUCT
:
11893 return _("NT_TASKSTRUCT (task structure)");
11895 return _("NT_PRXFPREG (user_xfpregs structure)");
11897 return _("NT_PPC_VMX (ppc Altivec registers)");
11899 return _("NT_PPC_VSX (ppc VSX registers)");
11900 case NT_X86_XSTATE
:
11901 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
11902 case NT_S390_HIGH_GPRS
:
11903 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
11904 case NT_S390_TIMER
:
11905 return _("NT_S390_TIMER (s390 timer register)");
11906 case NT_S390_TODCMP
:
11907 return _("NT_S390_TODCMP (s390 TOD comparator register)");
11908 case NT_S390_TODPREG
:
11909 return _("NT_S390_TODPREG (s390 TOD programmable register)");
11911 return _("NT_S390_CTRS (s390 control registers)");
11912 case NT_S390_PREFIX
:
11913 return _("NT_S390_PREFIX (s390 prefix register)");
11915 return _("NT_PSTATUS (pstatus structure)");
11917 return _("NT_FPREGS (floating point registers)");
11919 return _("NT_PSINFO (psinfo structure)");
11921 return _("NT_LWPSTATUS (lwpstatus_t structure)");
11923 return _("NT_LWPSINFO (lwpsinfo_t structure)");
11924 case NT_WIN32PSTATUS
:
11925 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11933 return _("NT_VERSION (version)");
11935 return _("NT_ARCH (architecture)");
11940 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11944 static const char *
11945 get_gnu_elf_note_type (unsigned e_type
)
11947 static char buff
[64];
11951 case NT_GNU_ABI_TAG
:
11952 return _("NT_GNU_ABI_TAG (ABI version tag)");
11954 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
11955 case NT_GNU_BUILD_ID
:
11956 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
11957 case NT_GNU_GOLD_VERSION
:
11958 return _("NT_GNU_GOLD_VERSION (gold version)");
11963 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11967 static const char *
11968 get_netbsd_elfcore_note_type (unsigned e_type
)
11970 static char buff
[64];
11972 if (e_type
== NT_NETBSDCORE_PROCINFO
)
11974 /* NetBSD core "procinfo" structure. */
11975 return _("NetBSD procinfo structure");
11978 /* As of Jan 2002 there are no other machine-independent notes
11979 defined for NetBSD core files. If the note type is less
11980 than the start of the machine-dependent note types, we don't
11983 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
11985 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11989 switch (elf_header
.e_machine
)
11991 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
11992 and PT_GETFPREGS == mach+2. */
11997 case EM_SPARC32PLUS
:
12001 case NT_NETBSDCORE_FIRSTMACH
+ 0:
12002 return _("PT_GETREGS (reg structure)");
12003 case NT_NETBSDCORE_FIRSTMACH
+ 2:
12004 return _("PT_GETFPREGS (fpreg structure)");
12010 /* On all other arch's, PT_GETREGS == mach+1 and
12011 PT_GETFPREGS == mach+3. */
12015 case NT_NETBSDCORE_FIRSTMACH
+ 1:
12016 return _("PT_GETREGS (reg structure)");
12017 case NT_NETBSDCORE_FIRSTMACH
+ 3:
12018 return _("PT_GETFPREGS (fpreg structure)");
12024 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
12025 e_type
- NT_NETBSDCORE_FIRSTMACH
);
12029 /* Note that by the ELF standard, the name field is already null byte
12030 terminated, and namesz includes the terminating null byte.
12031 I.E. the value of namesz for the name "FSF" is 4.
12033 If the value of namesz is zero, there is no name present. */
12035 process_note (Elf_Internal_Note
* pnote
)
12037 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
12040 if (pnote
->namesz
== 0)
12041 /* If there is no note name, then use the default set of
12042 note type strings. */
12043 nt
= get_note_type (pnote
->type
);
12045 else if (const_strneq (pnote
->namedata
, "GNU"))
12046 /* GNU-specific object file notes. */
12047 nt
= get_gnu_elf_note_type (pnote
->type
);
12049 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
12050 /* NetBSD-specific core file notes. */
12051 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
12053 else if (strneq (pnote
->namedata
, "SPU/", 4))
12055 /* SPU-specific core file notes. */
12056 nt
= pnote
->namedata
+ 4;
12061 /* Don't recognize this note name; just use the default set of
12062 note type strings. */
12063 nt
= get_note_type (pnote
->type
);
12065 printf (" %s\t\t0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
12071 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
12073 Elf_External_Note
* pnotes
;
12074 Elf_External_Note
* external
;
12080 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
12082 if (pnotes
== NULL
)
12087 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
12088 (unsigned long) offset
, (unsigned long) length
);
12089 printf (_(" Owner\t\tData size\tDescription\n"));
12091 while (external
< (Elf_External_Note
*) ((char *) pnotes
+ length
))
12093 Elf_External_Note
* next
;
12094 Elf_Internal_Note inote
;
12095 char * temp
= NULL
;
12097 inote
.type
= BYTE_GET (external
->type
);
12098 inote
.namesz
= BYTE_GET (external
->namesz
);
12099 inote
.namedata
= external
->name
;
12100 inote
.descsz
= BYTE_GET (external
->descsz
);
12101 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
12102 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
12104 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
12106 if ( ((char *) next
> ((char *) pnotes
) + length
)
12107 || ((char *) next
< (char *) pnotes
))
12109 warn (_("corrupt note found at offset %lx into core notes\n"),
12110 (unsigned long) ((char *) external
- (char *) pnotes
));
12111 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
12112 inote
.type
, inote
.namesz
, inote
.descsz
);
12118 /* Prevent out-of-bounds indexing. */
12119 if (inote
.namedata
+ inote
.namesz
>= (char *) pnotes
+ length
12120 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
12122 warn (_("corrupt note found at offset %lx into core notes\n"),
12123 (unsigned long) ((char *) external
- (char *) pnotes
));
12124 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
12125 inote
.type
, inote
.namesz
, inote
.descsz
);
12129 /* Verify that name is null terminated. It appears that at least
12130 one version of Linux (RedHat 6.0) generates corefiles that don't
12131 comply with the ELF spec by failing to include the null byte in
12133 if (inote
.namedata
[inote
.namesz
] != '\0')
12135 temp
= (char *) malloc (inote
.namesz
+ 1);
12139 error (_("Out of memory\n"));
12144 strncpy (temp
, inote
.namedata
, inote
.namesz
);
12145 temp
[inote
.namesz
] = 0;
12147 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
12148 inote
.namedata
= temp
;
12151 res
&= process_note (& inote
);
12166 process_corefile_note_segments (FILE * file
)
12168 Elf_Internal_Phdr
* segment
;
12172 if (! get_program_headers (file
))
12175 for (i
= 0, segment
= program_headers
;
12176 i
< elf_header
.e_phnum
;
12179 if (segment
->p_type
== PT_NOTE
)
12180 res
&= process_corefile_note_segment (file
,
12181 (bfd_vma
) segment
->p_offset
,
12182 (bfd_vma
) segment
->p_filesz
);
12189 process_note_sections (FILE * file
)
12191 Elf_Internal_Shdr
* section
;
12195 for (i
= 0, section
= section_headers
;
12196 i
< elf_header
.e_shnum
;
12198 if (section
->sh_type
== SHT_NOTE
)
12199 res
&= process_corefile_note_segment (file
,
12200 (bfd_vma
) section
->sh_offset
,
12201 (bfd_vma
) section
->sh_size
);
12207 process_notes (FILE * file
)
12209 /* If we have not been asked to display the notes then do nothing. */
12213 if (elf_header
.e_type
!= ET_CORE
)
12214 return process_note_sections (file
);
12216 /* No program headers means no NOTE segment. */
12217 if (elf_header
.e_phnum
> 0)
12218 return process_corefile_note_segments (file
);
12220 printf (_("No note segments present in the core file.\n"));
12225 process_arch_specific (FILE * file
)
12230 switch (elf_header
.e_machine
)
12233 return process_arm_specific (file
);
12235 case EM_MIPS_RS3_LE
:
12236 return process_mips_specific (file
);
12239 return process_power_specific (file
);
12242 return process_tic6x_specific (file
);
12251 get_file_header (FILE * file
)
12253 /* Read in the identity array. */
12254 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
12257 /* Determine how to read the rest of the header. */
12258 switch (elf_header
.e_ident
[EI_DATA
])
12260 default: /* fall through */
12261 case ELFDATANONE
: /* fall through */
12263 byte_get
= byte_get_little_endian
;
12264 byte_put
= byte_put_little_endian
;
12267 byte_get
= byte_get_big_endian
;
12268 byte_put
= byte_put_big_endian
;
12272 /* For now we only support 32 bit and 64 bit ELF files. */
12273 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
12275 /* Read in the rest of the header. */
12278 Elf32_External_Ehdr ehdr32
;
12280 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
12283 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
12284 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
12285 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
12286 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
12287 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
12288 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
12289 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
12290 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
12291 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
12292 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
12293 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
12294 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
12295 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
12299 Elf64_External_Ehdr ehdr64
;
12301 /* If we have been compiled with sizeof (bfd_vma) == 4, then
12302 we will not be able to cope with the 64bit data found in
12303 64 ELF files. Detect this now and abort before we start
12304 overwriting things. */
12305 if (sizeof (bfd_vma
) < 8)
12307 error (_("This instance of readelf has been built without support for a\n\
12308 64 bit data type and so it cannot read 64 bit ELF files.\n"));
12312 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
12315 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
12316 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
12317 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
12318 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
12319 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
12320 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
12321 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
12322 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
12323 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
12324 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
12325 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
12326 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
12327 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
12330 if (elf_header
.e_shoff
)
12332 /* There may be some extensions in the first section header. Don't
12333 bomb if we can't read it. */
12335 get_32bit_section_headers (file
, 1);
12337 get_64bit_section_headers (file
, 1);
12343 /* Process one ELF object file according to the command line options.
12344 This file may actually be stored in an archive. The file is
12345 positioned at the start of the ELF object. */
12348 process_object (char * file_name
, FILE * file
)
12352 if (! get_file_header (file
))
12354 error (_("%s: Failed to read file header\n"), file_name
);
12358 /* Initialise per file variables. */
12359 for (i
= ARRAY_SIZE (version_info
); i
--;)
12360 version_info
[i
] = 0;
12362 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
12363 dynamic_info
[i
] = 0;
12365 /* Process the file. */
12367 printf (_("\nFile: %s\n"), file_name
);
12369 /* Initialise the dump_sects array from the cmdline_dump_sects array.
12370 Note we do this even if cmdline_dump_sects is empty because we
12371 must make sure that the dump_sets array is zeroed out before each
12372 object file is processed. */
12373 if (num_dump_sects
> num_cmdline_dump_sects
)
12374 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
12376 if (num_cmdline_dump_sects
> 0)
12378 if (num_dump_sects
== 0)
12379 /* A sneaky way of allocating the dump_sects array. */
12380 request_dump_bynumber (num_cmdline_dump_sects
, 0);
12382 assert (num_dump_sects
>= num_cmdline_dump_sects
);
12383 memcpy (dump_sects
, cmdline_dump_sects
,
12384 num_cmdline_dump_sects
* sizeof (* dump_sects
));
12387 if (! process_file_header ())
12390 if (! process_section_headers (file
))
12392 /* Without loaded section headers we cannot process lots of
12394 do_unwind
= do_version
= do_dump
= do_arch
= 0;
12396 if (! do_using_dynamic
)
12397 do_syms
= do_dyn_syms
= do_reloc
= 0;
12400 if (! process_section_groups (file
))
12402 /* Without loaded section groups we cannot process unwind. */
12406 if (process_program_headers (file
))
12407 process_dynamic_section (file
);
12409 process_relocs (file
);
12411 process_unwind (file
);
12413 process_symbol_table (file
);
12415 process_syminfo (file
);
12417 process_version_sections (file
);
12419 process_section_contents (file
);
12421 process_notes (file
);
12423 process_gnu_liblist (file
);
12425 process_arch_specific (file
);
12427 if (program_headers
)
12429 free (program_headers
);
12430 program_headers
= NULL
;
12433 if (section_headers
)
12435 free (section_headers
);
12436 section_headers
= NULL
;
12441 free (string_table
);
12442 string_table
= NULL
;
12443 string_table_length
= 0;
12446 if (dynamic_strings
)
12448 free (dynamic_strings
);
12449 dynamic_strings
= NULL
;
12450 dynamic_strings_length
= 0;
12453 if (dynamic_symbols
)
12455 free (dynamic_symbols
);
12456 dynamic_symbols
= NULL
;
12457 num_dynamic_syms
= 0;
12460 if (dynamic_syminfo
)
12462 free (dynamic_syminfo
);
12463 dynamic_syminfo
= NULL
;
12466 if (section_headers_groups
)
12468 free (section_headers_groups
);
12469 section_headers_groups
= NULL
;
12472 if (section_groups
)
12474 struct group_list
* g
;
12475 struct group_list
* next
;
12477 for (i
= 0; i
< group_count
; i
++)
12479 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
12486 free (section_groups
);
12487 section_groups
= NULL
;
12490 free_debug_memory ();
12495 /* Return the path name for a proxy entry in a thin archive, adjusted relative
12496 to the path name of the thin archive itself if necessary. Always returns
12497 a pointer to malloc'ed memory. */
12500 adjust_relative_path (char * file_name
, char * name
, int name_len
)
12502 char * member_file_name
;
12503 const char * base_name
= lbasename (file_name
);
12505 /* This is a proxy entry for a thin archive member.
12506 If the extended name table contains an absolute path
12507 name, or if the archive is in the current directory,
12508 use the path name as given. Otherwise, we need to
12509 find the member relative to the directory where the
12510 archive is located. */
12511 if (IS_ABSOLUTE_PATH (name
) || base_name
== file_name
)
12513 member_file_name
= (char *) malloc (name_len
+ 1);
12514 if (member_file_name
== NULL
)
12516 error (_("Out of memory\n"));
12519 memcpy (member_file_name
, name
, name_len
);
12520 member_file_name
[name_len
] = '\0';
12524 /* Concatenate the path components of the archive file name
12525 to the relative path name from the extended name table. */
12526 size_t prefix_len
= base_name
- file_name
;
12527 member_file_name
= (char *) malloc (prefix_len
+ name_len
+ 1);
12528 if (member_file_name
== NULL
)
12530 error (_("Out of memory\n"));
12533 memcpy (member_file_name
, file_name
, prefix_len
);
12534 memcpy (member_file_name
+ prefix_len
, name
, name_len
);
12535 member_file_name
[prefix_len
+ name_len
] = '\0';
12537 return member_file_name
;
12540 /* Structure to hold information about an archive file. */
12542 struct archive_info
12544 char * file_name
; /* Archive file name. */
12545 FILE * file
; /* Open file descriptor. */
12546 unsigned long index_num
; /* Number of symbols in table. */
12547 unsigned long * index_array
; /* The array of member offsets. */
12548 char * sym_table
; /* The symbol table. */
12549 unsigned long sym_size
; /* Size of the symbol table. */
12550 char * longnames
; /* The long file names table. */
12551 unsigned long longnames_size
; /* Size of the long file names table. */
12552 unsigned long nested_member_origin
; /* Origin in the nested archive of the current member. */
12553 unsigned long next_arhdr_offset
; /* Offset of the next archive header. */
12554 bfd_boolean is_thin_archive
; /* TRUE if this is a thin archive. */
12555 struct ar_hdr arhdr
; /* Current archive header. */
12558 /* Read the symbol table and long-name table from an archive. */
12561 setup_archive (struct archive_info
* arch
, char * file_name
, FILE * file
,
12562 bfd_boolean is_thin_archive
, bfd_boolean read_symbols
)
12565 unsigned long size
;
12567 arch
->file_name
= strdup (file_name
);
12569 arch
->index_num
= 0;
12570 arch
->index_array
= NULL
;
12571 arch
->sym_table
= NULL
;
12572 arch
->sym_size
= 0;
12573 arch
->longnames
= NULL
;
12574 arch
->longnames_size
= 0;
12575 arch
->nested_member_origin
= 0;
12576 arch
->is_thin_archive
= is_thin_archive
;
12577 arch
->next_arhdr_offset
= SARMAG
;
12579 /* Read the first archive member header. */
12580 if (fseek (file
, SARMAG
, SEEK_SET
) != 0)
12582 error (_("%s: failed to seek to first archive header\n"), file_name
);
12585 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
12586 if (got
!= sizeof arch
->arhdr
)
12591 error (_("%s: failed to read archive header\n"), file_name
);
12595 /* See if this is the archive symbol table. */
12596 if (const_strneq (arch
->arhdr
.ar_name
, "/ ")
12597 || const_strneq (arch
->arhdr
.ar_name
, "/SYM64/ "))
12599 size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
12600 size
= size
+ (size
& 1);
12602 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ size
;
12607 /* A buffer used to hold numbers read in from an archive index.
12608 These are always 4 bytes long and stored in big-endian format. */
12609 #define SIZEOF_AR_INDEX_NUMBERS 4
12610 unsigned char integer_buffer
[SIZEOF_AR_INDEX_NUMBERS
];
12611 unsigned char * index_buffer
;
12613 /* Check the size of the archive index. */
12614 if (size
< SIZEOF_AR_INDEX_NUMBERS
)
12616 error (_("%s: the archive index is empty\n"), file_name
);
12620 /* Read the numer of entries in the archive index. */
12621 got
= fread (integer_buffer
, 1, sizeof integer_buffer
, file
);
12622 if (got
!= sizeof (integer_buffer
))
12624 error (_("%s: failed to read archive index\n"), file_name
);
12627 arch
->index_num
= byte_get_big_endian (integer_buffer
, sizeof integer_buffer
);
12628 size
-= SIZEOF_AR_INDEX_NUMBERS
;
12630 /* Read in the archive index. */
12631 if (size
< arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
)
12633 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
12634 file_name
, arch
->index_num
);
12637 index_buffer
= (unsigned char *)
12638 malloc (arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
);
12639 if (index_buffer
== NULL
)
12641 error (_("Out of memory whilst trying to read archive symbol index\n"));
12644 got
= fread (index_buffer
, SIZEOF_AR_INDEX_NUMBERS
, arch
->index_num
, file
);
12645 if (got
!= arch
->index_num
)
12647 free (index_buffer
);
12648 error (_("%s: failed to read archive index\n"), file_name
);
12651 size
-= arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
;
12653 /* Convert the index numbers into the host's numeric format. */
12654 arch
->index_array
= (long unsigned int *)
12655 malloc (arch
->index_num
* sizeof (* arch
->index_array
));
12656 if (arch
->index_array
== NULL
)
12658 free (index_buffer
);
12659 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
12663 for (i
= 0; i
< arch
->index_num
; i
++)
12664 arch
->index_array
[i
] = byte_get_big_endian ((unsigned char *) (index_buffer
+ (i
* SIZEOF_AR_INDEX_NUMBERS
)),
12665 SIZEOF_AR_INDEX_NUMBERS
);
12666 free (index_buffer
);
12668 /* The remaining space in the header is taken up by the symbol table. */
12671 error (_("%s: the archive has an index but no symbols\n"), file_name
);
12674 arch
->sym_table
= (char *) malloc (size
);
12675 arch
->sym_size
= size
;
12676 if (arch
->sym_table
== NULL
)
12678 error (_("Out of memory whilst trying to read archive index symbol table\n"));
12681 got
= fread (arch
->sym_table
, 1, size
, file
);
12684 error (_("%s: failed to read archive index symbol table\n"), file_name
);
12690 if (fseek (file
, size
, SEEK_CUR
) != 0)
12692 error (_("%s: failed to skip archive symbol table\n"), file_name
);
12697 /* Read the next archive header. */
12698 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
12699 if (got
!= sizeof arch
->arhdr
)
12703 error (_("%s: failed to read archive header following archive index\n"), file_name
);
12707 else if (read_symbols
)
12708 printf (_("%s has no archive index\n"), file_name
);
12710 if (const_strneq (arch
->arhdr
.ar_name
, "// "))
12712 /* This is the archive string table holding long member names. */
12713 arch
->longnames_size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
12714 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ arch
->longnames_size
;
12716 arch
->longnames
= (char *) malloc (arch
->longnames_size
);
12717 if (arch
->longnames
== NULL
)
12719 error (_("Out of memory reading long symbol names in archive\n"));
12723 if (fread (arch
->longnames
, arch
->longnames_size
, 1, file
) != 1)
12725 free (arch
->longnames
);
12726 arch
->longnames
= NULL
;
12727 error (_("%s: failed to read long symbol name string table\n"), file_name
);
12731 if ((arch
->longnames_size
& 1) != 0)
12738 /* Release the memory used for the archive information. */
12741 release_archive (struct archive_info
* arch
)
12743 if (arch
->file_name
!= NULL
)
12744 free (arch
->file_name
);
12745 if (arch
->index_array
!= NULL
)
12746 free (arch
->index_array
);
12747 if (arch
->sym_table
!= NULL
)
12748 free (arch
->sym_table
);
12749 if (arch
->longnames
!= NULL
)
12750 free (arch
->longnames
);
12753 /* Open and setup a nested archive, if not already open. */
12756 setup_nested_archive (struct archive_info
* nested_arch
, char * member_file_name
)
12758 FILE * member_file
;
12760 /* Have we already setup this archive? */
12761 if (nested_arch
->file_name
!= NULL
12762 && streq (nested_arch
->file_name
, member_file_name
))
12765 /* Close previous file and discard cached information. */
12766 if (nested_arch
->file
!= NULL
)
12767 fclose (nested_arch
->file
);
12768 release_archive (nested_arch
);
12770 member_file
= fopen (member_file_name
, "rb");
12771 if (member_file
== NULL
)
12773 return setup_archive (nested_arch
, member_file_name
, member_file
, FALSE
, FALSE
);
12777 get_archive_member_name_at (struct archive_info
* arch
,
12778 unsigned long offset
,
12779 struct archive_info
* nested_arch
);
12781 /* Get the name of an archive member from the current archive header.
12782 For simple names, this will modify the ar_name field of the current
12783 archive header. For long names, it will return a pointer to the
12784 longnames table. For nested archives, it will open the nested archive
12785 and get the name recursively. NESTED_ARCH is a single-entry cache so
12786 we don't keep rereading the same information from a nested archive. */
12789 get_archive_member_name (struct archive_info
* arch
,
12790 struct archive_info
* nested_arch
)
12792 unsigned long j
, k
;
12794 if (arch
->arhdr
.ar_name
[0] == '/')
12796 /* We have a long name. */
12798 char * member_file_name
;
12799 char * member_name
;
12801 arch
->nested_member_origin
= 0;
12802 k
= j
= strtoul (arch
->arhdr
.ar_name
+ 1, &endp
, 10);
12803 if (arch
->is_thin_archive
&& endp
!= NULL
&& * endp
== ':')
12804 arch
->nested_member_origin
= strtoul (endp
+ 1, NULL
, 10);
12806 while ((j
< arch
->longnames_size
)
12807 && (arch
->longnames
[j
] != '\n')
12808 && (arch
->longnames
[j
] != '\0'))
12810 if (arch
->longnames
[j
-1] == '/')
12812 arch
->longnames
[j
] = '\0';
12814 if (!arch
->is_thin_archive
|| arch
->nested_member_origin
== 0)
12815 return arch
->longnames
+ k
;
12817 /* This is a proxy for a member of a nested archive.
12818 Find the name of the member in that archive. */
12819 member_file_name
= adjust_relative_path (arch
->file_name
, arch
->longnames
+ k
, j
- k
);
12820 if (member_file_name
!= NULL
12821 && setup_nested_archive (nested_arch
, member_file_name
) == 0
12822 && (member_name
= get_archive_member_name_at (nested_arch
, arch
->nested_member_origin
, NULL
)) != NULL
)
12824 free (member_file_name
);
12825 return member_name
;
12827 free (member_file_name
);
12829 /* Last resort: just return the name of the nested archive. */
12830 return arch
->longnames
+ k
;
12833 /* We have a normal (short) name. */
12835 while ((arch
->arhdr
.ar_name
[j
] != '/')
12836 && (j
< sizeof (arch
->arhdr
.ar_name
) - 1))
12838 arch
->arhdr
.ar_name
[j
] = '\0';
12839 return arch
->arhdr
.ar_name
;
12842 /* Get the name of an archive member at a given OFFSET within an archive ARCH. */
12845 get_archive_member_name_at (struct archive_info
* arch
,
12846 unsigned long offset
,
12847 struct archive_info
* nested_arch
)
12851 if (fseek (arch
->file
, offset
, SEEK_SET
) != 0)
12853 error (_("%s: failed to seek to next file name\n"), arch
->file_name
);
12856 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, arch
->file
);
12857 if (got
!= sizeof arch
->arhdr
)
12859 error (_("%s: failed to read archive header\n"), arch
->file_name
);
12862 if (memcmp (arch
->arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
12864 error (_("%s: did not find a valid archive header\n"), arch
->file_name
);
12868 return get_archive_member_name (arch
, nested_arch
);
12871 /* Construct a string showing the name of the archive member, qualified
12872 with the name of the containing archive file. For thin archives, we
12873 use square brackets to denote the indirection. For nested archives,
12874 we show the qualified name of the external member inside the square
12875 brackets (e.g., "thin.a[normal.a(foo.o)]"). */
12878 make_qualified_name (struct archive_info
* arch
,
12879 struct archive_info
* nested_arch
,
12880 char * member_name
)
12885 len
= strlen (arch
->file_name
) + strlen (member_name
) + 3;
12886 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
12887 len
+= strlen (nested_arch
->file_name
) + 2;
12889 name
= (char *) malloc (len
);
12892 error (_("Out of memory\n"));
12896 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
12897 snprintf (name
, len
, "%s[%s(%s)]", arch
->file_name
, nested_arch
->file_name
, member_name
);
12898 else if (arch
->is_thin_archive
)
12899 snprintf (name
, len
, "%s[%s]", arch
->file_name
, member_name
);
12901 snprintf (name
, len
, "%s(%s)", arch
->file_name
, member_name
);
12906 /* Process an ELF archive.
12907 On entry the file is positioned just after the ARMAG string. */
12910 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
12912 struct archive_info arch
;
12913 struct archive_info nested_arch
;
12919 /* The ARCH structure is used to hold information about this archive. */
12920 arch
.file_name
= NULL
;
12922 arch
.index_array
= NULL
;
12923 arch
.sym_table
= NULL
;
12924 arch
.longnames
= NULL
;
12926 /* The NESTED_ARCH structure is used as a single-item cache of information
12927 about a nested archive (when members of a thin archive reside within
12928 another regular archive file). */
12929 nested_arch
.file_name
= NULL
;
12930 nested_arch
.file
= NULL
;
12931 nested_arch
.index_array
= NULL
;
12932 nested_arch
.sym_table
= NULL
;
12933 nested_arch
.longnames
= NULL
;
12935 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
12941 if (do_archive_index
)
12943 if (arch
.sym_table
== NULL
)
12944 error (_("%s: unable to dump the index as none was found\n"), file_name
);
12948 unsigned long current_pos
;
12950 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
12951 file_name
, arch
.index_num
, arch
.sym_size
);
12952 current_pos
= ftell (file
);
12954 for (i
= l
= 0; i
< arch
.index_num
; i
++)
12956 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
12958 char * member_name
;
12960 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
12962 if (member_name
!= NULL
)
12964 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
12966 if (qualified_name
!= NULL
)
12968 printf (_("Binary %s contains:\n"), qualified_name
);
12969 free (qualified_name
);
12974 if (l
>= arch
.sym_size
)
12976 error (_("%s: end of the symbol table reached before the end of the index\n"),
12980 printf ("\t%s\n", arch
.sym_table
+ l
);
12981 l
+= strlen (arch
.sym_table
+ l
) + 1;
12986 if (l
< arch
.sym_size
)
12987 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
12990 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
12992 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
12998 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
12999 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
13000 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
13001 && !do_section_groups
&& !do_dyn_syms
)
13003 ret
= 0; /* Archive index only. */
13014 char * qualified_name
;
13016 /* Read the next archive header. */
13017 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
13019 error (_("%s: failed to seek to next archive header\n"), file_name
);
13022 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
13023 if (got
!= sizeof arch
.arhdr
)
13027 error (_("%s: failed to read archive header\n"), file_name
);
13031 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
13033 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
13038 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
13040 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
13041 if (archive_file_size
& 01)
13042 ++archive_file_size
;
13044 name
= get_archive_member_name (&arch
, &nested_arch
);
13047 error (_("%s: bad archive file name\n"), file_name
);
13051 namelen
= strlen (name
);
13053 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
13054 if (qualified_name
== NULL
)
13056 error (_("%s: bad archive file name\n"), file_name
);
13061 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
13063 /* This is a proxy for an external member of a thin archive. */
13064 FILE * member_file
;
13065 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
13066 if (member_file_name
== NULL
)
13072 member_file
= fopen (member_file_name
, "rb");
13073 if (member_file
== NULL
)
13075 error (_("Input file '%s' is not readable.\n"), member_file_name
);
13076 free (member_file_name
);
13081 archive_file_offset
= arch
.nested_member_origin
;
13083 ret
|= process_object (qualified_name
, member_file
);
13085 fclose (member_file
);
13086 free (member_file_name
);
13088 else if (is_thin_archive
)
13090 /* This is a proxy for a member of a nested archive. */
13091 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
13093 /* The nested archive file will have been opened and setup by
13094 get_archive_member_name. */
13095 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
13097 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
13102 ret
|= process_object (qualified_name
, nested_arch
.file
);
13106 archive_file_offset
= arch
.next_arhdr_offset
;
13107 arch
.next_arhdr_offset
+= archive_file_size
;
13109 ret
|= process_object (qualified_name
, file
);
13112 free (qualified_name
);
13116 if (nested_arch
.file
!= NULL
)
13117 fclose (nested_arch
.file
);
13118 release_archive (&nested_arch
);
13119 release_archive (&arch
);
13125 process_file (char * file_name
)
13128 struct stat statbuf
;
13129 char armag
[SARMAG
];
13132 if (stat (file_name
, &statbuf
) < 0)
13134 if (errno
== ENOENT
)
13135 error (_("'%s': No such file\n"), file_name
);
13137 error (_("Could not locate '%s'. System error message: %s\n"),
13138 file_name
, strerror (errno
));
13142 if (! S_ISREG (statbuf
.st_mode
))
13144 error (_("'%s' is not an ordinary file\n"), file_name
);
13148 file
= fopen (file_name
, "rb");
13151 error (_("Input file '%s' is not readable.\n"), file_name
);
13155 if (fread (armag
, SARMAG
, 1, file
) != 1)
13157 error (_("%s: Failed to read file's magic number\n"), file_name
);
13162 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
13163 ret
= process_archive (file_name
, file
, FALSE
);
13164 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
13165 ret
= process_archive (file_name
, file
, TRUE
);
13168 if (do_archive_index
)
13169 error (_("File %s is not an archive so its index cannot be displayed.\n"),
13173 archive_file_size
= archive_file_offset
= 0;
13174 ret
= process_object (file_name
, file
);
13182 #ifdef SUPPORT_DISASSEMBLY
13183 /* Needed by the i386 disassembler. For extra credit, someone could
13184 fix this so that we insert symbolic addresses here, esp for GOT/PLT
13188 print_address (unsigned int addr
, FILE * outfile
)
13190 fprintf (outfile
,"0x%8.8x", addr
);
13193 /* Needed by the i386 disassembler. */
13195 db_task_printsym (unsigned int addr
)
13197 print_address (addr
, stderr
);
13202 main (int argc
, char ** argv
)
13206 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
13207 setlocale (LC_MESSAGES
, "");
13209 #if defined (HAVE_SETLOCALE)
13210 setlocale (LC_CTYPE
, "");
13212 bindtextdomain (PACKAGE
, LOCALEDIR
);
13213 textdomain (PACKAGE
);
13215 expandargv (&argc
, &argv
);
13217 parse_args (argc
, argv
);
13219 if (num_dump_sects
> 0)
13221 /* Make a copy of the dump_sects array. */
13222 cmdline_dump_sects
= (dump_type
*)
13223 malloc (num_dump_sects
* sizeof (* dump_sects
));
13224 if (cmdline_dump_sects
== NULL
)
13225 error (_("Out of memory allocating dump request table.\n"));
13228 memcpy (cmdline_dump_sects
, dump_sects
,
13229 num_dump_sects
* sizeof (* dump_sects
));
13230 num_cmdline_dump_sects
= num_dump_sects
;
13234 if (optind
< (argc
- 1))
13238 while (optind
< argc
)
13239 err
|= process_file (argv
[optind
++]);
13241 if (dump_sects
!= NULL
)
13243 if (cmdline_dump_sects
!= NULL
)
13244 free (cmdline_dump_sects
);