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))
277 #define GET_ELF_SYMBOLS(file, section) \
278 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
279 : get_64bit_elf_symbols (file, section))
281 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
282 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
283 already been called and verified that the string exists. */
284 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
286 /* This is just a bit of syntatic sugar. */
287 #define streq(a,b) (strcmp ((a), (b)) == 0)
288 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
289 #define const_strneq(a,b) (strncmp ((a), (b), sizeof (b) - 1) == 0)
291 #define REMOVE_ARCH_BITS(ADDR) do { \
292 if (elf_header.e_machine == EM_ARM) \
297 get_data (void * var
, FILE * file
, long offset
, size_t size
, size_t nmemb
,
302 if (size
== 0 || nmemb
== 0)
305 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
307 error (_("Unable to seek to 0x%lx for %s\n"),
308 (unsigned long) archive_file_offset
+ offset
, reason
);
315 /* Check for overflow. */
316 if (nmemb
< (~(size_t) 0 - 1) / size
)
317 /* + 1 so that we can '\0' terminate invalid string table sections. */
318 mvar
= malloc (size
* nmemb
+ 1);
322 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
323 (unsigned long)(size
* nmemb
), reason
);
327 ((char *) mvar
)[size
* nmemb
] = '\0';
330 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
332 error (_("Unable to read in 0x%lx bytes of %s\n"),
333 (unsigned long)(size
* nmemb
), reason
);
343 byte_put_little_endian (unsigned char * field
, bfd_vma value
, int size
)
348 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
349 field
[6] = ((value
>> 24) >> 24) & 0xff;
350 field
[5] = ((value
>> 24) >> 16) & 0xff;
351 field
[4] = ((value
>> 24) >> 8) & 0xff;
354 field
[3] = (value
>> 24) & 0xff;
357 field
[2] = (value
>> 16) & 0xff;
360 field
[1] = (value
>> 8) & 0xff;
363 field
[0] = value
& 0xff;
367 error (_("Unhandled data length: %d\n"), size
);
372 /* Print a VMA value. */
375 print_vma (bfd_vma vma
, print_mode mode
)
388 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
395 return printf ("%5" BFD_VMA_FMT
"d", vma
);
403 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
406 return printf ("%" BFD_VMA_FMT
"d", vma
);
409 return printf ("%" BFD_VMA_FMT
"u", vma
);
414 /* Display a symbol on stdout. Handles the display of non-printing characters.
416 If DO_WIDE is not true then format the symbol to be at most WIDTH characters,
417 truncating as necessary. If WIDTH is negative then format the string to be
418 exactly - WIDTH characters, truncating or padding as necessary.
420 Returns the number of emitted characters. */
423 print_symbol (int width
, const char * symbol
)
426 bfd_boolean extra_padding
= FALSE
;
427 unsigned int num_printed
= 0;
431 /* Set the width to a very large value. This simplifies the code below. */
436 /* Keep the width positive. This also helps. */
438 extra_padding
= TRUE
;
447 /* Look for non-printing symbols inside the symbol's name.
448 This test is triggered in particular by the names generated
449 by the assembler for local labels. */
450 while (ISPRINT (* c
))
460 printf ("%.*s", len
, symbol
);
466 if (* c
== 0 || width
== 0)
469 /* Now display the non-printing character, if
470 there is room left in which to dipslay it. */
476 printf ("^%c", *c
+ 0x40);
486 printf ("<0x%.2x>", *c
);
495 if (extra_padding
&& width
> 0)
497 /* Fill in the remaining spaces. */
498 printf ("%-*s", width
, " ");
506 byte_put_big_endian (unsigned char * field
, bfd_vma value
, int size
)
511 field
[7] = value
& 0xff;
512 field
[6] = (value
>> 8) & 0xff;
513 field
[5] = (value
>> 16) & 0xff;
514 field
[4] = (value
>> 24) & 0xff;
519 field
[3] = value
& 0xff;
523 field
[2] = value
& 0xff;
527 field
[1] = value
& 0xff;
531 field
[0] = value
& 0xff;
535 error (_("Unhandled data length: %d\n"), size
);
540 /* Return a pointer to section NAME, or NULL if no such section exists. */
542 static Elf_Internal_Shdr
*
543 find_section (const char * name
)
547 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
548 if (streq (SECTION_NAME (section_headers
+ i
), name
))
549 return section_headers
+ i
;
554 /* Return a pointer to a section containing ADDR, or NULL if no such
557 static Elf_Internal_Shdr
*
558 find_section_by_address (bfd_vma addr
)
562 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
564 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
565 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
572 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
576 read_uleb128 (unsigned char *data
, unsigned int *length_return
)
578 return read_leb128 (data
, length_return
, 0);
581 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
582 This OS has so many departures from the ELF standard that we test it at
588 return elf_header
.e_machine
== EM_IA_64
589 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
592 /* Guess the relocation size commonly used by the specific machines. */
595 guess_is_rela (unsigned int e_machine
)
599 /* Targets that use REL relocations. */
615 /* Targets that use RELA relocations. */
619 case EM_ALTERA_NIOS2
:
639 case EM_LATTICEMICO32
:
647 case EM_CYGNUS_MN10200
:
649 case EM_CYGNUS_MN10300
:
675 case EM_MICROBLAZE_OLD
:
696 warn (_("Don't know about relocations on this machine architecture\n"));
702 slurp_rela_relocs (FILE * file
,
703 unsigned long rel_offset
,
704 unsigned long rel_size
,
705 Elf_Internal_Rela
** relasp
,
706 unsigned long * nrelasp
)
708 Elf_Internal_Rela
* relas
;
709 unsigned long nrelas
;
714 Elf32_External_Rela
* erelas
;
716 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
717 rel_size
, _("relocs"));
721 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
723 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
724 sizeof (Elf_Internal_Rela
));
729 error (_("out of memory parsing relocs\n"));
733 for (i
= 0; i
< nrelas
; i
++)
735 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
736 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
737 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
744 Elf64_External_Rela
* erelas
;
746 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
747 rel_size
, _("relocs"));
751 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
753 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
754 sizeof (Elf_Internal_Rela
));
759 error (_("out of memory parsing relocs\n"));
763 for (i
= 0; i
< nrelas
; i
++)
765 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
766 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
767 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
769 /* The #ifdef BFD64 below is to prevent a compile time
770 warning. We know that if we do not have a 64 bit data
771 type that we will never execute this code anyway. */
773 if (elf_header
.e_machine
== EM_MIPS
774 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
776 /* In little-endian objects, r_info isn't really a
777 64-bit little-endian value: it has a 32-bit
778 little-endian symbol index followed by four
779 individual byte fields. Reorder INFO
781 bfd_vma inf
= relas
[i
].r_info
;
782 inf
= (((inf
& 0xffffffff) << 32)
783 | ((inf
>> 56) & 0xff)
784 | ((inf
>> 40) & 0xff00)
785 | ((inf
>> 24) & 0xff0000)
786 | ((inf
>> 8) & 0xff000000));
787 relas
[i
].r_info
= inf
;
800 slurp_rel_relocs (FILE * file
,
801 unsigned long rel_offset
,
802 unsigned long rel_size
,
803 Elf_Internal_Rela
** relsp
,
804 unsigned long * nrelsp
)
806 Elf_Internal_Rela
* rels
;
812 Elf32_External_Rel
* erels
;
814 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
815 rel_size
, _("relocs"));
819 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
821 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
826 error (_("out of memory parsing relocs\n"));
830 for (i
= 0; i
< nrels
; i
++)
832 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
833 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
834 rels
[i
].r_addend
= 0;
841 Elf64_External_Rel
* erels
;
843 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
844 rel_size
, _("relocs"));
848 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
850 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
855 error (_("out of memory parsing relocs\n"));
859 for (i
= 0; i
< nrels
; i
++)
861 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
862 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
863 rels
[i
].r_addend
= 0;
865 /* The #ifdef BFD64 below is to prevent a compile time
866 warning. We know that if we do not have a 64 bit data
867 type that we will never execute this code anyway. */
869 if (elf_header
.e_machine
== EM_MIPS
870 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
872 /* In little-endian objects, r_info isn't really a
873 64-bit little-endian value: it has a 32-bit
874 little-endian symbol index followed by four
875 individual byte fields. Reorder INFO
877 bfd_vma inf
= rels
[i
].r_info
;
878 inf
= (((inf
& 0xffffffff) << 32)
879 | ((inf
>> 56) & 0xff)
880 | ((inf
>> 40) & 0xff00)
881 | ((inf
>> 24) & 0xff0000)
882 | ((inf
>> 8) & 0xff000000));
883 rels
[i
].r_info
= inf
;
895 /* Returns the reloc type extracted from the reloc info field. */
898 get_reloc_type (bfd_vma reloc_info
)
901 return ELF32_R_TYPE (reloc_info
);
903 switch (elf_header
.e_machine
)
906 /* Note: We assume that reloc_info has already been adjusted for us. */
907 return ELF64_MIPS_R_TYPE (reloc_info
);
910 return ELF64_R_TYPE_ID (reloc_info
);
913 return ELF64_R_TYPE (reloc_info
);
917 /* Return the symbol index extracted from the reloc info field. */
920 get_reloc_symindex (bfd_vma reloc_info
)
922 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
925 /* Display the contents of the relocation data found at the specified
929 dump_relocations (FILE * file
,
930 unsigned long rel_offset
,
931 unsigned long rel_size
,
932 Elf_Internal_Sym
* symtab
,
935 unsigned long strtablen
,
939 Elf_Internal_Rela
* rels
;
941 if (is_rela
== UNKNOWN
)
942 is_rela
= guess_is_rela (elf_header
.e_machine
);
946 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
951 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
960 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
962 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
967 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
969 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
977 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
979 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
984 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
986 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
990 for (i
= 0; i
< rel_size
; i
++)
995 bfd_vma symtab_index
;
998 offset
= rels
[i
].r_offset
;
999 inf
= rels
[i
].r_info
;
1001 type
= get_reloc_type (inf
);
1002 symtab_index
= get_reloc_symindex (inf
);
1006 printf ("%8.8lx %8.8lx ",
1007 (unsigned long) offset
& 0xffffffff,
1008 (unsigned long) inf
& 0xffffffff);
1012 #if BFD_HOST_64BIT_LONG
1014 ? "%16.16lx %16.16lx "
1015 : "%12.12lx %12.12lx ",
1017 #elif BFD_HOST_64BIT_LONG_LONG
1020 ? "%16.16llx %16.16llx "
1021 : "%12.12llx %12.12llx ",
1025 ? "%16.16I64x %16.16I64x "
1026 : "%12.12I64x %12.12I64x ",
1031 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1032 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1033 _bfd_int64_high (offset
),
1034 _bfd_int64_low (offset
),
1035 _bfd_int64_high (inf
),
1036 _bfd_int64_low (inf
));
1040 switch (elf_header
.e_machine
)
1047 case EM_CYGNUS_M32R
:
1048 rtype
= elf_m32r_reloc_type (type
);
1053 rtype
= elf_i386_reloc_type (type
);
1058 rtype
= elf_m68hc11_reloc_type (type
);
1062 rtype
= elf_m68k_reloc_type (type
);
1066 rtype
= elf_i960_reloc_type (type
);
1071 rtype
= elf_avr_reloc_type (type
);
1074 case EM_OLD_SPARCV9
:
1075 case EM_SPARC32PLUS
:
1078 rtype
= elf_sparc_reloc_type (type
);
1082 rtype
= elf_spu_reloc_type (type
);
1086 case EM_CYGNUS_V850
:
1087 rtype
= v850_reloc_type (type
);
1091 case EM_CYGNUS_D10V
:
1092 rtype
= elf_d10v_reloc_type (type
);
1096 case EM_CYGNUS_D30V
:
1097 rtype
= elf_d30v_reloc_type (type
);
1101 rtype
= elf_dlx_reloc_type (type
);
1105 rtype
= elf_sh_reloc_type (type
);
1109 case EM_CYGNUS_MN10300
:
1110 rtype
= elf_mn10300_reloc_type (type
);
1114 case EM_CYGNUS_MN10200
:
1115 rtype
= elf_mn10200_reloc_type (type
);
1119 case EM_CYGNUS_FR30
:
1120 rtype
= elf_fr30_reloc_type (type
);
1124 rtype
= elf_frv_reloc_type (type
);
1128 rtype
= elf_mcore_reloc_type (type
);
1132 rtype
= elf_mmix_reloc_type (type
);
1136 rtype
= elf_moxie_reloc_type (type
);
1141 rtype
= elf_msp430_reloc_type (type
);
1145 rtype
= elf_ppc_reloc_type (type
);
1149 rtype
= elf_ppc64_reloc_type (type
);
1153 case EM_MIPS_RS3_LE
:
1154 rtype
= elf_mips_reloc_type (type
);
1158 rtype
= elf_alpha_reloc_type (type
);
1162 rtype
= elf_arm_reloc_type (type
);
1166 rtype
= elf_arc_reloc_type (type
);
1170 rtype
= elf_hppa_reloc_type (type
);
1176 rtype
= elf_h8_reloc_type (type
);
1181 rtype
= elf_or32_reloc_type (type
);
1186 rtype
= elf_pj_reloc_type (type
);
1189 rtype
= elf_ia64_reloc_type (type
);
1193 rtype
= elf_cris_reloc_type (type
);
1197 rtype
= elf_i860_reloc_type (type
);
1202 rtype
= elf_x86_64_reloc_type (type
);
1206 rtype
= i370_reloc_type (type
);
1211 rtype
= elf_s390_reloc_type (type
);
1215 rtype
= elf_score_reloc_type (type
);
1219 rtype
= elf_xstormy16_reloc_type (type
);
1223 rtype
= elf_crx_reloc_type (type
);
1227 rtype
= elf_vax_reloc_type (type
);
1232 rtype
= elf_ip2k_reloc_type (type
);
1236 rtype
= elf_iq2000_reloc_type (type
);
1241 rtype
= elf_xtensa_reloc_type (type
);
1244 case EM_LATTICEMICO32
:
1245 rtype
= elf_lm32_reloc_type (type
);
1250 rtype
= elf_m32c_reloc_type (type
);
1254 rtype
= elf_mt_reloc_type (type
);
1258 rtype
= elf_bfin_reloc_type (type
);
1262 rtype
= elf_mep_reloc_type (type
);
1267 rtype
= elf_cr16_reloc_type (type
);
1271 case EM_MICROBLAZE_OLD
:
1272 rtype
= elf_microblaze_reloc_type (type
);
1276 rtype
= elf_rx_reloc_type (type
);
1281 rtype
= elf_xc16x_reloc_type (type
);
1285 rtype
= elf_tic6x_reloc_type (type
);
1290 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1292 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1294 if (elf_header
.e_machine
== EM_ALPHA
1296 && streq (rtype
, "R_ALPHA_LITUSE")
1299 switch (rels
[i
].r_addend
)
1301 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1302 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1303 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1304 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1305 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1306 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1307 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1308 default: rtype
= NULL
;
1311 printf (" (%s)", rtype
);
1315 printf (_("<unknown addend: %lx>"),
1316 (unsigned long) rels
[i
].r_addend
);
1319 else if (symtab_index
)
1321 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1322 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index
);
1325 Elf_Internal_Sym
* psym
;
1327 psym
= symtab
+ symtab_index
;
1331 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1335 unsigned int width
= is_32bit_elf
? 8 : 14;
1337 /* Relocations against GNU_IFUNC symbols do not use the value
1338 of the symbol as the address to relocate against. Instead
1339 they invoke the function named by the symbol and use its
1340 result as the address for relocation.
1342 To indicate this to the user, do not display the value of
1343 the symbol in the "Symbols's Value" field. Instead show
1344 its name followed by () as a hint that the symbol is
1348 || psym
->st_name
== 0
1349 || psym
->st_name
>= strtablen
)
1352 name
= strtab
+ psym
->st_name
;
1354 len
= print_symbol (width
, name
);
1355 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1359 print_vma (psym
->st_value
, LONG_HEX
);
1361 printf (is_32bit_elf
? " " : " ");
1364 if (psym
->st_name
== 0)
1366 const char * sec_name
= "<null>";
1369 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1371 if (psym
->st_shndx
< elf_header
.e_shnum
)
1373 = SECTION_NAME (section_headers
+ psym
->st_shndx
);
1374 else if (psym
->st_shndx
== SHN_ABS
)
1376 else if (psym
->st_shndx
== SHN_COMMON
)
1377 sec_name
= "COMMON";
1378 else if (elf_header
.e_machine
== EM_MIPS
1379 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1380 sec_name
= "SCOMMON";
1381 else if (elf_header
.e_machine
== EM_MIPS
1382 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1383 sec_name
= "SUNDEF";
1384 else if ((elf_header
.e_machine
== EM_X86_64
1385 || elf_header
.e_machine
== EM_L1OM
)
1386 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1387 sec_name
= "LARGE_COMMON";
1388 else if (elf_header
.e_machine
== EM_IA_64
1389 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1390 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1391 sec_name
= "ANSI_COM";
1392 else if (is_ia64_vms ()
1393 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1394 sec_name
= "VMS_SYMVEC";
1397 sprintf (name_buf
, "<section 0x%x>",
1398 (unsigned int) psym
->st_shndx
);
1399 sec_name
= name_buf
;
1402 print_symbol (22, sec_name
);
1404 else if (strtab
== NULL
)
1405 printf (_("<string table index: %3ld>"), psym
->st_name
);
1406 else if (psym
->st_name
>= strtablen
)
1407 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1409 print_symbol (22, strtab
+ psym
->st_name
);
1413 long off
= (long) (bfd_signed_vma
) rels
[i
].r_addend
;
1416 printf (" - %lx", - off
);
1418 printf (" + %lx", off
);
1424 printf ("%*c", is_32bit_elf
?
1425 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1426 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1429 if (elf_header
.e_machine
== EM_SPARCV9
1431 && streq (rtype
, "R_SPARC_OLO10"))
1432 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1437 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1439 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1440 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1441 const char * rtype2
= elf_mips_reloc_type (type2
);
1442 const char * rtype3
= elf_mips_reloc_type (type3
);
1444 printf (" Type2: ");
1447 printf (_("unrecognized: %-7lx"),
1448 (unsigned long) type2
& 0xffffffff);
1450 printf ("%-17.17s", rtype2
);
1452 printf ("\n Type3: ");
1455 printf (_("unrecognized: %-7lx"),
1456 (unsigned long) type3
& 0xffffffff);
1458 printf ("%-17.17s", rtype3
);
1469 get_mips_dynamic_type (unsigned long type
)
1473 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1474 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1475 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1476 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1477 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1478 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1479 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1480 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1481 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1482 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1483 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1484 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1485 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1486 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1487 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1488 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1489 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1490 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1491 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1492 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1493 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1494 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1495 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1496 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1497 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1498 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1499 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1500 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1501 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1502 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1503 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1504 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1505 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1506 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1507 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1508 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1509 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1510 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1511 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1512 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1513 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1514 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1515 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1516 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1517 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1524 get_sparc64_dynamic_type (unsigned long type
)
1528 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1535 get_ppc_dynamic_type (unsigned long type
)
1539 case DT_PPC_GOT
: return "PPC_GOT";
1540 case DT_PPC_TLSOPT
: return "PPC_TLSOPT";
1547 get_ppc64_dynamic_type (unsigned long type
)
1551 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1552 case DT_PPC64_OPD
: return "PPC64_OPD";
1553 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1554 case DT_PPC64_TLSOPT
: return "PPC64_TLSOPT";
1561 get_parisc_dynamic_type (unsigned long type
)
1565 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1566 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1567 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1568 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1569 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1570 case DT_HP_PREINIT
: return "HP_PREINIT";
1571 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1572 case DT_HP_NEEDED
: return "HP_NEEDED";
1573 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1574 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1575 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1576 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1577 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1578 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1579 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1580 case DT_HP_FILTERED
: return "HP_FILTERED";
1581 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1582 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1583 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1584 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1585 case DT_PLT
: return "PLT";
1586 case DT_PLT_SIZE
: return "PLT_SIZE";
1587 case DT_DLT
: return "DLT";
1588 case DT_DLT_SIZE
: return "DLT_SIZE";
1595 get_ia64_dynamic_type (unsigned long type
)
1599 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1600 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1601 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1602 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1603 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1604 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1605 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1606 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1607 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1608 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1609 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1610 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1611 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1612 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1613 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1614 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1615 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1616 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1617 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1618 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1619 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1620 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1621 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1622 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1623 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1624 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1625 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1626 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1627 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1628 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1629 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1636 get_alpha_dynamic_type (unsigned long type
)
1640 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1647 get_score_dynamic_type (unsigned long type
)
1651 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1652 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1653 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1654 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1655 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1656 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1663 get_tic6x_dynamic_type (unsigned long type
)
1667 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1668 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1669 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1670 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1671 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1672 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1679 get_dynamic_type (unsigned long type
)
1681 static char buff
[64];
1685 case DT_NULL
: return "NULL";
1686 case DT_NEEDED
: return "NEEDED";
1687 case DT_PLTRELSZ
: return "PLTRELSZ";
1688 case DT_PLTGOT
: return "PLTGOT";
1689 case DT_HASH
: return "HASH";
1690 case DT_STRTAB
: return "STRTAB";
1691 case DT_SYMTAB
: return "SYMTAB";
1692 case DT_RELA
: return "RELA";
1693 case DT_RELASZ
: return "RELASZ";
1694 case DT_RELAENT
: return "RELAENT";
1695 case DT_STRSZ
: return "STRSZ";
1696 case DT_SYMENT
: return "SYMENT";
1697 case DT_INIT
: return "INIT";
1698 case DT_FINI
: return "FINI";
1699 case DT_SONAME
: return "SONAME";
1700 case DT_RPATH
: return "RPATH";
1701 case DT_SYMBOLIC
: return "SYMBOLIC";
1702 case DT_REL
: return "REL";
1703 case DT_RELSZ
: return "RELSZ";
1704 case DT_RELENT
: return "RELENT";
1705 case DT_PLTREL
: return "PLTREL";
1706 case DT_DEBUG
: return "DEBUG";
1707 case DT_TEXTREL
: return "TEXTREL";
1708 case DT_JMPREL
: return "JMPREL";
1709 case DT_BIND_NOW
: return "BIND_NOW";
1710 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1711 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1712 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1713 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1714 case DT_RUNPATH
: return "RUNPATH";
1715 case DT_FLAGS
: return "FLAGS";
1717 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1718 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1720 case DT_CHECKSUM
: return "CHECKSUM";
1721 case DT_PLTPADSZ
: return "PLTPADSZ";
1722 case DT_MOVEENT
: return "MOVEENT";
1723 case DT_MOVESZ
: return "MOVESZ";
1724 case DT_FEATURE
: return "FEATURE";
1725 case DT_POSFLAG_1
: return "POSFLAG_1";
1726 case DT_SYMINSZ
: return "SYMINSZ";
1727 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1729 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1730 case DT_CONFIG
: return "CONFIG";
1731 case DT_DEPAUDIT
: return "DEPAUDIT";
1732 case DT_AUDIT
: return "AUDIT";
1733 case DT_PLTPAD
: return "PLTPAD";
1734 case DT_MOVETAB
: return "MOVETAB";
1735 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1737 case DT_VERSYM
: return "VERSYM";
1739 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1740 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1741 case DT_RELACOUNT
: return "RELACOUNT";
1742 case DT_RELCOUNT
: return "RELCOUNT";
1743 case DT_FLAGS_1
: return "FLAGS_1";
1744 case DT_VERDEF
: return "VERDEF";
1745 case DT_VERDEFNUM
: return "VERDEFNUM";
1746 case DT_VERNEED
: return "VERNEED";
1747 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1749 case DT_AUXILIARY
: return "AUXILIARY";
1750 case DT_USED
: return "USED";
1751 case DT_FILTER
: return "FILTER";
1753 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1754 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1755 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1756 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1757 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1758 case DT_GNU_HASH
: return "GNU_HASH";
1761 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1763 const char * result
;
1765 switch (elf_header
.e_machine
)
1768 case EM_MIPS_RS3_LE
:
1769 result
= get_mips_dynamic_type (type
);
1772 result
= get_sparc64_dynamic_type (type
);
1775 result
= get_ppc_dynamic_type (type
);
1778 result
= get_ppc64_dynamic_type (type
);
1781 result
= get_ia64_dynamic_type (type
);
1784 result
= get_alpha_dynamic_type (type
);
1787 result
= get_score_dynamic_type (type
);
1790 result
= get_tic6x_dynamic_type (type
);
1800 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1802 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1803 || (elf_header
.e_machine
== EM_PARISC
1804 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1806 const char * result
;
1808 switch (elf_header
.e_machine
)
1811 result
= get_parisc_dynamic_type (type
);
1814 result
= get_ia64_dynamic_type (type
);
1824 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1828 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1835 get_file_type (unsigned e_type
)
1837 static char buff
[32];
1841 case ET_NONE
: return _("NONE (None)");
1842 case ET_REL
: return _("REL (Relocatable file)");
1843 case ET_EXEC
: return _("EXEC (Executable file)");
1844 case ET_DYN
: return _("DYN (Shared object file)");
1845 case ET_CORE
: return _("CORE (Core file)");
1848 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1849 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1850 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1851 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1853 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1859 get_machine_name (unsigned e_machine
)
1861 static char buff
[64]; /* XXX */
1865 case EM_NONE
: return _("None");
1866 case EM_M32
: return "WE32100";
1867 case EM_SPARC
: return "Sparc";
1868 case EM_SPU
: return "SPU";
1869 case EM_386
: return "Intel 80386";
1870 case EM_68K
: return "MC68000";
1871 case EM_88K
: return "MC88000";
1872 case EM_486
: return "Intel 80486";
1873 case EM_860
: return "Intel 80860";
1874 case EM_MIPS
: return "MIPS R3000";
1875 case EM_S370
: return "IBM System/370";
1876 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1877 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1878 case EM_PARISC
: return "HPPA";
1879 case EM_PPC_OLD
: return "Power PC (old)";
1880 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1881 case EM_960
: return "Intel 90860";
1882 case EM_PPC
: return "PowerPC";
1883 case EM_PPC64
: return "PowerPC64";
1884 case EM_V800
: return "NEC V800";
1885 case EM_FR20
: return "Fujitsu FR20";
1886 case EM_RH32
: return "TRW RH32";
1887 case EM_MCORE
: return "MCORE";
1888 case EM_ARM
: return "ARM";
1889 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1890 case EM_SH
: return "Renesas / SuperH SH";
1891 case EM_SPARCV9
: return "Sparc v9";
1892 case EM_TRICORE
: return "Siemens Tricore";
1893 case EM_ARC
: return "ARC";
1894 case EM_H8_300
: return "Renesas H8/300";
1895 case EM_H8_300H
: return "Renesas H8/300H";
1896 case EM_H8S
: return "Renesas H8S";
1897 case EM_H8_500
: return "Renesas H8/500";
1898 case EM_IA_64
: return "Intel IA-64";
1899 case EM_MIPS_X
: return "Stanford MIPS-X";
1900 case EM_COLDFIRE
: return "Motorola Coldfire";
1901 case EM_68HC12
: return "Motorola M68HC12";
1902 case EM_ALPHA
: return "Alpha";
1903 case EM_CYGNUS_D10V
:
1904 case EM_D10V
: return "d10v";
1905 case EM_CYGNUS_D30V
:
1906 case EM_D30V
: return "d30v";
1907 case EM_CYGNUS_M32R
:
1908 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1909 case EM_CYGNUS_V850
:
1910 case EM_V850
: return "NEC v850";
1911 case EM_CYGNUS_MN10300
:
1912 case EM_MN10300
: return "mn10300";
1913 case EM_CYGNUS_MN10200
:
1914 case EM_MN10200
: return "mn10200";
1915 case EM_MOXIE
: return "Moxie";
1916 case EM_CYGNUS_FR30
:
1917 case EM_FR30
: return "Fujitsu FR30";
1918 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1920 case EM_PJ
: return "picoJava";
1921 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1922 case EM_PCP
: return "Siemens PCP";
1923 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1924 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1925 case EM_STARCORE
: return "Motorola Star*Core processor";
1926 case EM_ME16
: return "Toyota ME16 processor";
1927 case EM_ST100
: return "STMicroelectronics ST100 processor";
1928 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1929 case EM_PDSP
: return "Sony DSP processor";
1930 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
1931 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
1932 case EM_FX66
: return "Siemens FX66 microcontroller";
1933 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1934 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1935 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1936 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1937 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1938 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1939 case EM_SVX
: return "Silicon Graphics SVx";
1940 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1941 case EM_VAX
: return "Digital VAX";
1943 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1944 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1945 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1946 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1947 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1948 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1949 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1950 case EM_PRISM
: return "Vitesse Prism";
1951 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1952 case EM_L1OM
: return "Intel L1OM";
1954 case EM_S390
: return "IBM S/390";
1955 case EM_SCORE
: return "SUNPLUS S+Core";
1956 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1958 case EM_OR32
: return "OpenRISC";
1959 case EM_ARC_A5
: return "ARC International ARCompact processor";
1960 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1961 case EM_DLX
: return "OpenDLX";
1963 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1964 case EM_IQ2000
: return "Vitesse IQ2000";
1966 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1967 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
1968 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
1969 case EM_NS32K
: return "National Semiconductor 32000 series";
1970 case EM_TPC
: return "Tenor Network TPC processor";
1971 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
1972 case EM_MAX
: return "MAX Processor";
1973 case EM_CR
: return "National Semiconductor CompactRISC";
1974 case EM_F2MC16
: return "Fujitsu F2MC16";
1975 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
1976 case EM_LATTICEMICO32
: return "Lattice Mico32";
1978 case EM_M32C
: return "Renesas M32c";
1979 case EM_MT
: return "Morpho Techologies MT processor";
1980 case EM_BLACKFIN
: return "Analog Devices Blackfin";
1981 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
1982 case EM_SEP
: return "Sharp embedded microprocessor";
1983 case EM_ARCA
: return "Arca RISC microprocessor";
1984 case EM_UNICORE
: return "Unicore";
1985 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
1986 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
1987 case EM_NIOS32
: return "Altera Nios";
1988 case EM_ALTERA_NIOS2
: return "Altera Nios II";
1990 case EM_XC16X
: return "Infineon Technologies xc16x";
1991 case EM_M16C
: return "Renesas M16C series microprocessors";
1992 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
1993 case EM_CE
: return "Freescale Communication Engine RISC core";
1994 case EM_TSK3000
: return "Altium TSK3000 core";
1995 case EM_RS08
: return "Freescale RS08 embedded processor";
1996 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
1997 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
1998 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
1999 case EM_SE_C17
: return "Seiko Epson C17 family";
2000 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2001 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2002 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2003 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2004 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2005 case EM_R32C
: return "Renesas R32C series microprocessors";
2006 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2007 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2008 case EM_8051
: return "Intel 8051 and variants";
2009 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2010 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2011 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2012 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2013 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2014 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2015 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2016 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2018 case EM_CR16_OLD
: return "National Semiconductor's CR16";
2019 case EM_MICROBLAZE
: return "Xilinx MicroBlaze";
2020 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2021 case EM_RX
: return "Renesas RX";
2022 case EM_METAG
: return "Imagination Technologies META processor architecture";
2023 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2024 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2025 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2026 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2027 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
2028 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2029 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2030 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2031 case EM_CUDA
: return "NVIDIA CUDA architecture";
2033 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2039 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2044 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2045 e_flags
&= ~ EF_ARM_EABIMASK
;
2047 /* Handle "generic" ARM flags. */
2048 if (e_flags
& EF_ARM_RELEXEC
)
2050 strcat (buf
, ", relocatable executable");
2051 e_flags
&= ~ EF_ARM_RELEXEC
;
2054 if (e_flags
& EF_ARM_HASENTRY
)
2056 strcat (buf
, ", has entry point");
2057 e_flags
&= ~ EF_ARM_HASENTRY
;
2060 /* Now handle EABI specific flags. */
2064 strcat (buf
, ", <unrecognized EABI>");
2069 case EF_ARM_EABI_VER1
:
2070 strcat (buf
, ", Version1 EABI");
2075 /* Process flags one bit at a time. */
2076 flag
= e_flags
& - e_flags
;
2081 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2082 strcat (buf
, ", sorted symbol tables");
2092 case EF_ARM_EABI_VER2
:
2093 strcat (buf
, ", Version2 EABI");
2098 /* Process flags one bit at a time. */
2099 flag
= e_flags
& - e_flags
;
2104 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2105 strcat (buf
, ", sorted symbol tables");
2108 case EF_ARM_DYNSYMSUSESEGIDX
:
2109 strcat (buf
, ", dynamic symbols use segment index");
2112 case EF_ARM_MAPSYMSFIRST
:
2113 strcat (buf
, ", mapping symbols precede others");
2123 case EF_ARM_EABI_VER3
:
2124 strcat (buf
, ", Version3 EABI");
2127 case EF_ARM_EABI_VER4
:
2128 strcat (buf
, ", Version4 EABI");
2131 case EF_ARM_EABI_VER5
:
2132 strcat (buf
, ", Version5 EABI");
2138 /* Process flags one bit at a time. */
2139 flag
= e_flags
& - e_flags
;
2145 strcat (buf
, ", BE8");
2149 strcat (buf
, ", LE8");
2159 case EF_ARM_EABI_UNKNOWN
:
2160 strcat (buf
, ", GNU EABI");
2165 /* Process flags one bit at a time. */
2166 flag
= e_flags
& - e_flags
;
2171 case EF_ARM_INTERWORK
:
2172 strcat (buf
, ", interworking enabled");
2175 case EF_ARM_APCS_26
:
2176 strcat (buf
, ", uses APCS/26");
2179 case EF_ARM_APCS_FLOAT
:
2180 strcat (buf
, ", uses APCS/float");
2184 strcat (buf
, ", position independent");
2188 strcat (buf
, ", 8 bit structure alignment");
2191 case EF_ARM_NEW_ABI
:
2192 strcat (buf
, ", uses new ABI");
2195 case EF_ARM_OLD_ABI
:
2196 strcat (buf
, ", uses old ABI");
2199 case EF_ARM_SOFT_FLOAT
:
2200 strcat (buf
, ", software FP");
2203 case EF_ARM_VFP_FLOAT
:
2204 strcat (buf
, ", VFP");
2207 case EF_ARM_MAVERICK_FLOAT
:
2208 strcat (buf
, ", Maverick FP");
2219 strcat (buf
,_(", <unknown>"));
2223 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2225 static char buf
[1024];
2237 decode_ARM_machine_flags (e_flags
, buf
);
2241 switch (e_flags
& EF_FRV_CPU_MASK
)
2243 case EF_FRV_CPU_GENERIC
:
2247 strcat (buf
, ", fr???");
2250 case EF_FRV_CPU_FR300
:
2251 strcat (buf
, ", fr300");
2254 case EF_FRV_CPU_FR400
:
2255 strcat (buf
, ", fr400");
2257 case EF_FRV_CPU_FR405
:
2258 strcat (buf
, ", fr405");
2261 case EF_FRV_CPU_FR450
:
2262 strcat (buf
, ", fr450");
2265 case EF_FRV_CPU_FR500
:
2266 strcat (buf
, ", fr500");
2268 case EF_FRV_CPU_FR550
:
2269 strcat (buf
, ", fr550");
2272 case EF_FRV_CPU_SIMPLE
:
2273 strcat (buf
, ", simple");
2275 case EF_FRV_CPU_TOMCAT
:
2276 strcat (buf
, ", tomcat");
2282 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2283 strcat (buf
, ", m68000");
2284 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2285 strcat (buf
, ", cpu32");
2286 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2287 strcat (buf
, ", fido_a");
2290 char const * isa
= _("unknown");
2291 char const * mac
= _("unknown mac");
2292 char const * additional
= NULL
;
2294 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2296 case EF_M68K_CF_ISA_A_NODIV
:
2298 additional
= ", nodiv";
2300 case EF_M68K_CF_ISA_A
:
2303 case EF_M68K_CF_ISA_A_PLUS
:
2306 case EF_M68K_CF_ISA_B_NOUSP
:
2308 additional
= ", nousp";
2310 case EF_M68K_CF_ISA_B
:
2314 strcat (buf
, ", cf, isa ");
2317 strcat (buf
, additional
);
2318 if (e_flags
& EF_M68K_CF_FLOAT
)
2319 strcat (buf
, ", float");
2320 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2325 case EF_M68K_CF_MAC
:
2328 case EF_M68K_CF_EMAC
:
2341 if (e_flags
& EF_PPC_EMB
)
2342 strcat (buf
, ", emb");
2344 if (e_flags
& EF_PPC_RELOCATABLE
)
2345 strcat (buf
, _(", relocatable"));
2347 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2348 strcat (buf
, _(", relocatable-lib"));
2352 case EM_CYGNUS_V850
:
2353 switch (e_flags
& EF_V850_ARCH
)
2355 case E_V850E2V3_ARCH
:
2356 strcat (buf
, ", v850e2v3");
2359 strcat (buf
, ", v850e2");
2362 strcat (buf
, ", v850e1");
2365 strcat (buf
, ", v850e");
2368 strcat (buf
, ", v850");
2371 strcat (buf
, _(", unknown v850 architecture variant"));
2377 case EM_CYGNUS_M32R
:
2378 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2379 strcat (buf
, ", m32r");
2383 case EM_MIPS_RS3_LE
:
2384 if (e_flags
& EF_MIPS_NOREORDER
)
2385 strcat (buf
, ", noreorder");
2387 if (e_flags
& EF_MIPS_PIC
)
2388 strcat (buf
, ", pic");
2390 if (e_flags
& EF_MIPS_CPIC
)
2391 strcat (buf
, ", cpic");
2393 if (e_flags
& EF_MIPS_UCODE
)
2394 strcat (buf
, ", ugen_reserved");
2396 if (e_flags
& EF_MIPS_ABI2
)
2397 strcat (buf
, ", abi2");
2399 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2400 strcat (buf
, ", odk first");
2402 if (e_flags
& EF_MIPS_32BITMODE
)
2403 strcat (buf
, ", 32bitmode");
2405 switch ((e_flags
& EF_MIPS_MACH
))
2407 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2408 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2409 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2410 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2411 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2412 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2413 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2414 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2415 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2416 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2417 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2418 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2419 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2420 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
2421 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
2423 /* We simply ignore the field in this case to avoid confusion:
2424 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2427 default: strcat (buf
, _(", unknown CPU")); break;
2430 switch ((e_flags
& EF_MIPS_ABI
))
2432 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2433 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2434 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2435 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2437 /* We simply ignore the field in this case to avoid confusion:
2438 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2439 This means it is likely to be an o32 file, but not for
2442 default: strcat (buf
, _(", unknown ABI")); break;
2445 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2446 strcat (buf
, ", mdmx");
2448 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2449 strcat (buf
, ", mips16");
2451 switch ((e_flags
& EF_MIPS_ARCH
))
2453 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2454 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2455 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2456 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2457 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2458 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2459 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2460 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2461 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2462 default: strcat (buf
, _(", unknown ISA")); break;
2465 if (e_flags
& EF_SH_PIC
)
2466 strcat (buf
, ", pic");
2468 if (e_flags
& EF_SH_FDPIC
)
2469 strcat (buf
, ", fdpic");
2473 switch ((e_flags
& EF_SH_MACH_MASK
))
2475 case EF_SH1
: strcat (buf
, ", sh1"); break;
2476 case EF_SH2
: strcat (buf
, ", sh2"); break;
2477 case EF_SH3
: strcat (buf
, ", sh3"); break;
2478 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2479 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2480 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2481 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2482 case EF_SH4
: strcat (buf
, ", sh4"); break;
2483 case EF_SH5
: strcat (buf
, ", sh5"); break;
2484 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2485 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2486 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2487 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2488 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2489 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2490 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2491 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2492 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2493 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2494 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2495 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2496 default: strcat (buf
, _(", unknown ISA")); break;
2502 if (e_flags
& EF_SPARC_32PLUS
)
2503 strcat (buf
, ", v8+");
2505 if (e_flags
& EF_SPARC_SUN_US1
)
2506 strcat (buf
, ", ultrasparcI");
2508 if (e_flags
& EF_SPARC_SUN_US3
)
2509 strcat (buf
, ", ultrasparcIII");
2511 if (e_flags
& EF_SPARC_HAL_R1
)
2512 strcat (buf
, ", halr1");
2514 if (e_flags
& EF_SPARC_LEDATA
)
2515 strcat (buf
, ", ledata");
2517 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2518 strcat (buf
, ", tso");
2520 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2521 strcat (buf
, ", pso");
2523 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2524 strcat (buf
, ", rmo");
2528 switch (e_flags
& EF_PARISC_ARCH
)
2530 case EFA_PARISC_1_0
:
2531 strcpy (buf
, ", PA-RISC 1.0");
2533 case EFA_PARISC_1_1
:
2534 strcpy (buf
, ", PA-RISC 1.1");
2536 case EFA_PARISC_2_0
:
2537 strcpy (buf
, ", PA-RISC 2.0");
2542 if (e_flags
& EF_PARISC_TRAPNIL
)
2543 strcat (buf
, ", trapnil");
2544 if (e_flags
& EF_PARISC_EXT
)
2545 strcat (buf
, ", ext");
2546 if (e_flags
& EF_PARISC_LSB
)
2547 strcat (buf
, ", lsb");
2548 if (e_flags
& EF_PARISC_WIDE
)
2549 strcat (buf
, ", wide");
2550 if (e_flags
& EF_PARISC_NO_KABP
)
2551 strcat (buf
, ", no kabp");
2552 if (e_flags
& EF_PARISC_LAZYSWAP
)
2553 strcat (buf
, ", lazyswap");
2558 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2559 strcat (buf
, ", new calling convention");
2561 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2562 strcat (buf
, ", gnu calling convention");
2566 if ((e_flags
& EF_IA_64_ABI64
))
2567 strcat (buf
, ", 64-bit");
2569 strcat (buf
, ", 32-bit");
2570 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2571 strcat (buf
, ", reduced fp model");
2572 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2573 strcat (buf
, ", no function descriptors, constant gp");
2574 else if ((e_flags
& EF_IA_64_CONS_GP
))
2575 strcat (buf
, ", constant gp");
2576 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2577 strcat (buf
, ", absolute");
2578 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
2580 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
2581 strcat (buf
, ", vms_linkages");
2582 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
2584 case EF_IA_64_VMS_COMCOD_SUCCESS
:
2586 case EF_IA_64_VMS_COMCOD_WARNING
:
2587 strcat (buf
, ", warning");
2589 case EF_IA_64_VMS_COMCOD_ERROR
:
2590 strcat (buf
, ", error");
2592 case EF_IA_64_VMS_COMCOD_ABORT
:
2593 strcat (buf
, ", abort");
2602 if ((e_flags
& EF_VAX_NONPIC
))
2603 strcat (buf
, ", non-PIC");
2604 if ((e_flags
& EF_VAX_DFLOAT
))
2605 strcat (buf
, ", D-Float");
2606 if ((e_flags
& EF_VAX_GFLOAT
))
2607 strcat (buf
, ", G-Float");
2611 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
2612 strcat (buf
, ", 64-bit doubles");
2613 if (e_flags
& E_FLAG_RX_DSP
)
2614 strcat (buf
, ", dsp");
2617 if (e_flags
& EF_S390_HIGH_GPRS
)
2618 strcat (buf
, ", highgprs");
2621 if ((e_flags
& EF_C6000_REL
))
2622 strcat (buf
, ", relocatable module");
2630 get_osabi_name (unsigned int osabi
)
2632 static char buff
[32];
2636 case ELFOSABI_NONE
: return "UNIX - System V";
2637 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2638 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2639 case ELFOSABI_LINUX
: return "UNIX - Linux";
2640 case ELFOSABI_HURD
: return "GNU/Hurd";
2641 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2642 case ELFOSABI_AIX
: return "UNIX - AIX";
2643 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2644 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2645 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2646 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2647 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2648 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2649 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2650 case ELFOSABI_AROS
: return "AROS";
2651 case ELFOSABI_FENIXOS
: return "FenixOS";
2654 switch (elf_header
.e_machine
)
2659 case ELFOSABI_ARM
: return "ARM";
2669 case ELFOSABI_STANDALONE
: return _("Standalone App");
2678 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
2679 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
2688 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2694 get_arm_segment_type (unsigned long type
)
2708 get_mips_segment_type (unsigned long type
)
2712 case PT_MIPS_REGINFO
:
2714 case PT_MIPS_RTPROC
:
2716 case PT_MIPS_OPTIONS
:
2726 get_parisc_segment_type (unsigned long type
)
2730 case PT_HP_TLS
: return "HP_TLS";
2731 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2732 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2733 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2734 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2735 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2736 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2737 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2738 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2739 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2740 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2741 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2742 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2743 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2744 case PT_HP_STACK
: return "HP_STACK";
2745 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2746 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2747 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2748 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2757 get_ia64_segment_type (unsigned long type
)
2761 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2762 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2763 case PT_HP_TLS
: return "HP_TLS";
2764 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2765 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2766 case PT_IA_64_HP_STACK
: return "HP_STACK";
2775 get_tic6x_segment_type (unsigned long type
)
2779 case PT_C6000_PHATTR
: return "C6000_PHATTR";
2788 get_segment_type (unsigned long p_type
)
2790 static char buff
[32];
2794 case PT_NULL
: return "NULL";
2795 case PT_LOAD
: return "LOAD";
2796 case PT_DYNAMIC
: return "DYNAMIC";
2797 case PT_INTERP
: return "INTERP";
2798 case PT_NOTE
: return "NOTE";
2799 case PT_SHLIB
: return "SHLIB";
2800 case PT_PHDR
: return "PHDR";
2801 case PT_TLS
: return "TLS";
2803 case PT_GNU_EH_FRAME
:
2804 return "GNU_EH_FRAME";
2805 case PT_GNU_STACK
: return "GNU_STACK";
2806 case PT_GNU_RELRO
: return "GNU_RELRO";
2809 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2811 const char * result
;
2813 switch (elf_header
.e_machine
)
2816 result
= get_arm_segment_type (p_type
);
2819 case EM_MIPS_RS3_LE
:
2820 result
= get_mips_segment_type (p_type
);
2823 result
= get_parisc_segment_type (p_type
);
2826 result
= get_ia64_segment_type (p_type
);
2829 result
= get_tic6x_segment_type (p_type
);
2839 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2841 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2843 const char * result
;
2845 switch (elf_header
.e_machine
)
2848 result
= get_parisc_segment_type (p_type
);
2851 result
= get_ia64_segment_type (p_type
);
2861 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2864 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2871 get_mips_section_type_name (unsigned int sh_type
)
2875 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2876 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2877 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2878 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2879 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2880 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2881 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2882 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2883 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2884 case SHT_MIPS_RELD
: return "MIPS_RELD";
2885 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2886 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2887 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2888 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2889 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2890 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2891 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2892 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2893 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2894 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2895 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2896 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2897 case SHT_MIPS_LINE
: return "MIPS_LINE";
2898 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2899 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2900 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2901 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2902 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2903 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2904 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2905 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2906 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2907 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2908 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2909 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2910 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2911 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2912 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2913 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2921 get_parisc_section_type_name (unsigned int sh_type
)
2925 case SHT_PARISC_EXT
: return "PARISC_EXT";
2926 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2927 case SHT_PARISC_DOC
: return "PARISC_DOC";
2928 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2929 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2930 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2931 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2939 get_ia64_section_type_name (unsigned int sh_type
)
2941 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2942 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2943 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2947 case SHT_IA_64_EXT
: return "IA_64_EXT";
2948 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2949 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2950 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
2951 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
2952 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
2953 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
2954 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
2955 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
2956 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
2964 get_x86_64_section_type_name (unsigned int sh_type
)
2968 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2976 get_arm_section_type_name (unsigned int sh_type
)
2980 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
2981 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
2982 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
2983 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
2984 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
2992 get_tic6x_section_type_name (unsigned int sh_type
)
2996 case SHT_C6000_UNWIND
:
2997 return "C6000_UNWIND";
2998 case SHT_C6000_PREEMPTMAP
:
2999 return "C6000_PREEMPTMAP";
3000 case SHT_C6000_ATTRIBUTES
:
3001 return "C6000_ATTRIBUTES";
3006 case SHT_TI_HANDLER
:
3007 return "TI_HANDLER";
3008 case SHT_TI_INITINFO
:
3009 return "TI_INITINFO";
3010 case SHT_TI_PHATTRS
:
3011 return "TI_PHATTRS";
3019 get_section_type_name (unsigned int sh_type
)
3021 static char buff
[32];
3025 case SHT_NULL
: return "NULL";
3026 case SHT_PROGBITS
: return "PROGBITS";
3027 case SHT_SYMTAB
: return "SYMTAB";
3028 case SHT_STRTAB
: return "STRTAB";
3029 case SHT_RELA
: return "RELA";
3030 case SHT_HASH
: return "HASH";
3031 case SHT_DYNAMIC
: return "DYNAMIC";
3032 case SHT_NOTE
: return "NOTE";
3033 case SHT_NOBITS
: return "NOBITS";
3034 case SHT_REL
: return "REL";
3035 case SHT_SHLIB
: return "SHLIB";
3036 case SHT_DYNSYM
: return "DYNSYM";
3037 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
3038 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
3039 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
3040 case SHT_GNU_HASH
: return "GNU_HASH";
3041 case SHT_GROUP
: return "GROUP";
3042 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
3043 case SHT_GNU_verdef
: return "VERDEF";
3044 case SHT_GNU_verneed
: return "VERNEED";
3045 case SHT_GNU_versym
: return "VERSYM";
3046 case 0x6ffffff0: return "VERSYM";
3047 case 0x6ffffffc: return "VERDEF";
3048 case 0x7ffffffd: return "AUXILIARY";
3049 case 0x7fffffff: return "FILTER";
3050 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
3053 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
3055 const char * result
;
3057 switch (elf_header
.e_machine
)
3060 case EM_MIPS_RS3_LE
:
3061 result
= get_mips_section_type_name (sh_type
);
3064 result
= get_parisc_section_type_name (sh_type
);
3067 result
= get_ia64_section_type_name (sh_type
);
3071 result
= get_x86_64_section_type_name (sh_type
);
3074 result
= get_arm_section_type_name (sh_type
);
3077 result
= get_tic6x_section_type_name (sh_type
);
3087 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
3089 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
3091 const char * result
;
3093 switch (elf_header
.e_machine
)
3096 result
= get_ia64_section_type_name (sh_type
);
3106 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
3108 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
3109 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
3111 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
3117 #define OPTION_DEBUG_DUMP 512
3118 #define OPTION_DYN_SYMS 513
3120 static struct option options
[] =
3122 {"all", no_argument
, 0, 'a'},
3123 {"file-header", no_argument
, 0, 'h'},
3124 {"program-headers", no_argument
, 0, 'l'},
3125 {"headers", no_argument
, 0, 'e'},
3126 {"histogram", no_argument
, 0, 'I'},
3127 {"segments", no_argument
, 0, 'l'},
3128 {"sections", no_argument
, 0, 'S'},
3129 {"section-headers", no_argument
, 0, 'S'},
3130 {"section-groups", no_argument
, 0, 'g'},
3131 {"section-details", no_argument
, 0, 't'},
3132 {"full-section-name",no_argument
, 0, 'N'},
3133 {"symbols", no_argument
, 0, 's'},
3134 {"syms", no_argument
, 0, 's'},
3135 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
3136 {"relocs", no_argument
, 0, 'r'},
3137 {"notes", no_argument
, 0, 'n'},
3138 {"dynamic", no_argument
, 0, 'd'},
3139 {"arch-specific", no_argument
, 0, 'A'},
3140 {"version-info", no_argument
, 0, 'V'},
3141 {"use-dynamic", no_argument
, 0, 'D'},
3142 {"unwind", no_argument
, 0, 'u'},
3143 {"archive-index", no_argument
, 0, 'c'},
3144 {"hex-dump", required_argument
, 0, 'x'},
3145 {"relocated-dump", required_argument
, 0, 'R'},
3146 {"string-dump", required_argument
, 0, 'p'},
3147 #ifdef SUPPORT_DISASSEMBLY
3148 {"instruction-dump", required_argument
, 0, 'i'},
3150 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
3152 {"version", no_argument
, 0, 'v'},
3153 {"wide", no_argument
, 0, 'W'},
3154 {"help", no_argument
, 0, 'H'},
3155 {0, no_argument
, 0, 0}
3159 usage (FILE * stream
)
3161 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
3162 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
3163 fprintf (stream
, _(" Options are:\n\
3164 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3165 -h --file-header Display the ELF file header\n\
3166 -l --program-headers Display the program headers\n\
3167 --segments An alias for --program-headers\n\
3168 -S --section-headers Display the sections' header\n\
3169 --sections An alias for --section-headers\n\
3170 -g --section-groups Display the section groups\n\
3171 -t --section-details Display the section details\n\
3172 -e --headers Equivalent to: -h -l -S\n\
3173 -s --syms Display the symbol table\n\
3174 --symbols An alias for --syms\n\
3175 --dyn-syms Display the dynamic symbol table\n\
3176 -n --notes Display the core notes (if present)\n\
3177 -r --relocs Display the relocations (if present)\n\
3178 -u --unwind Display the unwind info (if present)\n\
3179 -d --dynamic Display the dynamic section (if present)\n\
3180 -V --version-info Display the version sections (if present)\n\
3181 -A --arch-specific Display architecture specific information (if any).\n\
3182 -c --archive-index Display the symbol/file index in an archive\n\
3183 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3184 -x --hex-dump=<number|name>\n\
3185 Dump the contents of section <number|name> as bytes\n\
3186 -p --string-dump=<number|name>\n\
3187 Dump the contents of section <number|name> as strings\n\
3188 -R --relocated-dump=<number|name>\n\
3189 Dump the contents of section <number|name> as relocated bytes\n\
3190 -w[lLiaprmfFsoRt] or\n\
3191 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3192 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3193 =trace_info,=trace_abbrev,=trace_aranges]\n\
3194 Display the contents of DWARF2 debug sections\n"));
3195 #ifdef SUPPORT_DISASSEMBLY
3196 fprintf (stream
, _("\
3197 -i --instruction-dump=<number|name>\n\
3198 Disassemble the contents of section <number|name>\n"));
3200 fprintf (stream
, _("\
3201 -I --histogram Display histogram of bucket list lengths\n\
3202 -W --wide Allow output width to exceed 80 characters\n\
3203 @<file> Read options from <file>\n\
3204 -H --help Display this information\n\
3205 -v --version Display the version number of readelf\n"));
3207 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3208 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
3210 exit (stream
== stdout
? 0 : 1);
3213 /* Record the fact that the user wants the contents of section number
3214 SECTION to be displayed using the method(s) encoded as flags bits
3215 in TYPE. Note, TYPE can be zero if we are creating the array for
3219 request_dump_bynumber (unsigned int section
, dump_type type
)
3221 if (section
>= num_dump_sects
)
3223 dump_type
* new_dump_sects
;
3225 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
3226 sizeof (* dump_sects
));
3228 if (new_dump_sects
== NULL
)
3229 error (_("Out of memory allocating dump request table.\n"));
3232 /* Copy current flag settings. */
3233 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
3237 dump_sects
= new_dump_sects
;
3238 num_dump_sects
= section
+ 1;
3243 dump_sects
[section
] |= type
;
3248 /* Request a dump by section name. */
3251 request_dump_byname (const char * section
, dump_type type
)
3253 struct dump_list_entry
* new_request
;
3255 new_request
= (struct dump_list_entry
*)
3256 malloc (sizeof (struct dump_list_entry
));
3258 error (_("Out of memory allocating dump request table.\n"));
3260 new_request
->name
= strdup (section
);
3261 if (!new_request
->name
)
3262 error (_("Out of memory allocating dump request table.\n"));
3264 new_request
->type
= type
;
3266 new_request
->next
= dump_sects_byname
;
3267 dump_sects_byname
= new_request
;
3271 request_dump (dump_type type
)
3277 section
= strtoul (optarg
, & cp
, 0);
3279 if (! *cp
&& section
>= 0)
3280 request_dump_bynumber (section
, type
);
3282 request_dump_byname (optarg
, type
);
3287 parse_args (int argc
, char ** argv
)
3294 while ((c
= getopt_long
3295 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
3313 do_section_groups
++;
3321 do_section_groups
++;
3326 do_section_details
++;
3370 request_dump (HEX_DUMP
);
3373 request_dump (STRING_DUMP
);
3376 request_dump (RELOC_DUMP
);
3383 dwarf_select_sections_all ();
3388 dwarf_select_sections_by_letters (optarg
);
3391 case OPTION_DEBUG_DUMP
:
3398 dwarf_select_sections_by_names (optarg
);
3401 case OPTION_DYN_SYMS
:
3404 #ifdef SUPPORT_DISASSEMBLY
3406 request_dump (DISASS_DUMP
);
3410 print_version (program_name
);
3419 /* xgettext:c-format */
3420 error (_("Invalid option '-%c'\n"), c
);
3427 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3428 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3429 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3430 && !do_section_groups
&& !do_archive_index
3435 warn (_("Nothing to do.\n"));
3441 get_elf_class (unsigned int elf_class
)
3443 static char buff
[32];
3447 case ELFCLASSNONE
: return _("none");
3448 case ELFCLASS32
: return "ELF32";
3449 case ELFCLASS64
: return "ELF64";
3451 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3457 get_data_encoding (unsigned int encoding
)
3459 static char buff
[32];
3463 case ELFDATANONE
: return _("none");
3464 case ELFDATA2LSB
: return _("2's complement, little endian");
3465 case ELFDATA2MSB
: return _("2's complement, big endian");
3467 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3472 /* Decode the data held in 'elf_header'. */
3475 process_file_header (void)
3477 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3478 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3479 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3480 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3483 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3487 init_dwarf_regnames (elf_header
.e_machine
);
3493 printf (_("ELF Header:\n"));
3494 printf (_(" Magic: "));
3495 for (i
= 0; i
< EI_NIDENT
; i
++)
3496 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3498 printf (_(" Class: %s\n"),
3499 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3500 printf (_(" Data: %s\n"),
3501 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3502 printf (_(" Version: %d %s\n"),
3503 elf_header
.e_ident
[EI_VERSION
],
3504 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3506 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3507 ? _("<unknown: %lx>")
3509 printf (_(" OS/ABI: %s\n"),
3510 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3511 printf (_(" ABI Version: %d\n"),
3512 elf_header
.e_ident
[EI_ABIVERSION
]);
3513 printf (_(" Type: %s\n"),
3514 get_file_type (elf_header
.e_type
));
3515 printf (_(" Machine: %s\n"),
3516 get_machine_name (elf_header
.e_machine
));
3517 printf (_(" Version: 0x%lx\n"),
3518 (unsigned long) elf_header
.e_version
);
3520 printf (_(" Entry point address: "));
3521 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3522 printf (_("\n Start of program headers: "));
3523 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3524 printf (_(" (bytes into file)\n Start of section headers: "));
3525 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3526 printf (_(" (bytes into file)\n"));
3528 printf (_(" Flags: 0x%lx%s\n"),
3529 (unsigned long) elf_header
.e_flags
,
3530 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3531 printf (_(" Size of this header: %ld (bytes)\n"),
3532 (long) elf_header
.e_ehsize
);
3533 printf (_(" Size of program headers: %ld (bytes)\n"),
3534 (long) elf_header
.e_phentsize
);
3535 printf (_(" Number of program headers: %ld"),
3536 (long) elf_header
.e_phnum
);
3537 if (section_headers
!= NULL
3538 && elf_header
.e_phnum
== PN_XNUM
3539 && section_headers
[0].sh_info
!= 0)
3540 printf (_(" (%ld)"), (long) section_headers
[0].sh_info
);
3541 putc ('\n', stdout
);
3542 printf (_(" Size of section headers: %ld (bytes)\n"),
3543 (long) elf_header
.e_shentsize
);
3544 printf (_(" Number of section headers: %ld"),
3545 (long) elf_header
.e_shnum
);
3546 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
3547 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3548 putc ('\n', stdout
);
3549 printf (_(" Section header string table index: %ld"),
3550 (long) elf_header
.e_shstrndx
);
3551 if (section_headers
!= NULL
3552 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3553 printf (" (%u)", section_headers
[0].sh_link
);
3554 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3555 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3556 printf (_(" <corrupt: out of range>"));
3557 putc ('\n', stdout
);
3560 if (section_headers
!= NULL
)
3562 if (elf_header
.e_phnum
== PN_XNUM
3563 && section_headers
[0].sh_info
!= 0)
3564 elf_header
.e_phnum
= section_headers
[0].sh_info
;
3565 if (elf_header
.e_shnum
== SHN_UNDEF
)
3566 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3567 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3568 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3569 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3570 elf_header
.e_shstrndx
= SHN_UNDEF
;
3571 free (section_headers
);
3572 section_headers
= NULL
;
3580 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3582 Elf32_External_Phdr
* phdrs
;
3583 Elf32_External_Phdr
* external
;
3584 Elf_Internal_Phdr
* internal
;
3587 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3588 elf_header
.e_phentsize
,
3590 _("program headers"));
3594 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3595 i
< elf_header
.e_phnum
;
3596 i
++, internal
++, external
++)
3598 internal
->p_type
= BYTE_GET (external
->p_type
);
3599 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3600 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3601 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3602 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3603 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3604 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3605 internal
->p_align
= BYTE_GET (external
->p_align
);
3614 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3616 Elf64_External_Phdr
* phdrs
;
3617 Elf64_External_Phdr
* external
;
3618 Elf_Internal_Phdr
* internal
;
3621 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3622 elf_header
.e_phentsize
,
3624 _("program headers"));
3628 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3629 i
< elf_header
.e_phnum
;
3630 i
++, internal
++, external
++)
3632 internal
->p_type
= BYTE_GET (external
->p_type
);
3633 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3634 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3635 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3636 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3637 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3638 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3639 internal
->p_align
= BYTE_GET (external
->p_align
);
3647 /* Returns 1 if the program headers were read into `program_headers'. */
3650 get_program_headers (FILE * file
)
3652 Elf_Internal_Phdr
* phdrs
;
3654 /* Check cache of prior read. */
3655 if (program_headers
!= NULL
)
3658 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
3659 sizeof (Elf_Internal_Phdr
));
3663 error (_("Out of memory\n"));
3668 ? get_32bit_program_headers (file
, phdrs
)
3669 : get_64bit_program_headers (file
, phdrs
))
3671 program_headers
= phdrs
;
3679 /* Returns 1 if the program headers were loaded. */
3682 process_program_headers (FILE * file
)
3684 Elf_Internal_Phdr
* segment
;
3687 if (elf_header
.e_phnum
== 0)
3690 printf (_("\nThere are no program headers in this file.\n"));
3694 if (do_segments
&& !do_header
)
3696 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3697 printf (_("Entry point "));
3698 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3699 printf (_("\nThere are %d program headers, starting at offset "),
3700 elf_header
.e_phnum
);
3701 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3705 if (! get_program_headers (file
))
3710 if (elf_header
.e_phnum
> 1)
3711 printf (_("\nProgram Headers:\n"));
3713 printf (_("\nProgram Headers:\n"));
3717 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3720 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3724 (_(" Type Offset VirtAddr PhysAddr\n"));
3726 (_(" FileSiz MemSiz Flags Align\n"));
3733 for (i
= 0, segment
= program_headers
;
3734 i
< elf_header
.e_phnum
;
3739 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3743 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3744 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3745 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3746 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3747 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3749 (segment
->p_flags
& PF_R
? 'R' : ' '),
3750 (segment
->p_flags
& PF_W
? 'W' : ' '),
3751 (segment
->p_flags
& PF_X
? 'E' : ' '));
3752 printf ("%#lx", (unsigned long) segment
->p_align
);
3756 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3757 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3760 print_vma (segment
->p_offset
, FULL_HEX
);
3764 print_vma (segment
->p_vaddr
, FULL_HEX
);
3766 print_vma (segment
->p_paddr
, FULL_HEX
);
3769 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3770 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3773 print_vma (segment
->p_filesz
, FULL_HEX
);
3777 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3778 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3781 print_vma (segment
->p_offset
, FULL_HEX
);
3785 (segment
->p_flags
& PF_R
? 'R' : ' '),
3786 (segment
->p_flags
& PF_W
? 'W' : ' '),
3787 (segment
->p_flags
& PF_X
? 'E' : ' '));
3789 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3790 printf ("%#lx", (unsigned long) segment
->p_align
);
3793 print_vma (segment
->p_align
, PREFIX_HEX
);
3798 print_vma (segment
->p_offset
, FULL_HEX
);
3800 print_vma (segment
->p_vaddr
, FULL_HEX
);
3802 print_vma (segment
->p_paddr
, FULL_HEX
);
3804 print_vma (segment
->p_filesz
, FULL_HEX
);
3806 print_vma (segment
->p_memsz
, FULL_HEX
);
3808 (segment
->p_flags
& PF_R
? 'R' : ' '),
3809 (segment
->p_flags
& PF_W
? 'W' : ' '),
3810 (segment
->p_flags
& PF_X
? 'E' : ' '));
3811 print_vma (segment
->p_align
, HEX
);
3815 switch (segment
->p_type
)
3819 error (_("more than one dynamic segment\n"));
3821 /* By default, assume that the .dynamic section is the first
3822 section in the DYNAMIC segment. */
3823 dynamic_addr
= segment
->p_offset
;
3824 dynamic_size
= segment
->p_filesz
;
3826 /* Try to locate the .dynamic section. If there is
3827 a section header table, we can easily locate it. */
3828 if (section_headers
!= NULL
)
3830 Elf_Internal_Shdr
* sec
;
3832 sec
= find_section (".dynamic");
3833 if (sec
== NULL
|| sec
->sh_size
== 0)
3835 /* A corresponding .dynamic section is expected, but on
3836 IA-64/OpenVMS it is OK for it to be missing. */
3837 if (!is_ia64_vms ())
3838 error (_("no .dynamic section in the dynamic segment\n"));
3842 if (sec
->sh_type
== SHT_NOBITS
)
3848 dynamic_addr
= sec
->sh_offset
;
3849 dynamic_size
= sec
->sh_size
;
3851 if (dynamic_addr
< segment
->p_offset
3852 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3853 warn (_("the .dynamic section is not contained"
3854 " within the dynamic segment\n"));
3855 else if (dynamic_addr
> segment
->p_offset
)
3856 warn (_("the .dynamic section is not the first section"
3857 " in the dynamic segment.\n"));
3862 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3864 error (_("Unable to find program interpreter name\n"));
3868 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
3870 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
3871 error (_("Internal error: failed to create format string to display program interpreter\n"));
3873 program_interpreter
[0] = 0;
3874 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
3875 error (_("Unable to read program interpreter name\n"));
3878 printf (_("\n [Requesting program interpreter: %s]"),
3879 program_interpreter
);
3885 putc ('\n', stdout
);
3888 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3890 printf (_("\n Section to Segment mapping:\n"));
3891 printf (_(" Segment Sections...\n"));
3893 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3896 Elf_Internal_Shdr
* section
;
3898 segment
= program_headers
+ i
;
3899 section
= section_headers
+ 1;
3901 printf (" %2.2d ", i
);
3903 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3905 if (!ELF_TBSS_SPECIAL (section
, segment
)
3906 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
3907 printf ("%s ", SECTION_NAME (section
));
3918 /* Find the file offset corresponding to VMA by using the program headers. */
3921 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
3923 Elf_Internal_Phdr
* seg
;
3925 if (! get_program_headers (file
))
3927 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3931 for (seg
= program_headers
;
3932 seg
< program_headers
+ elf_header
.e_phnum
;
3935 if (seg
->p_type
!= PT_LOAD
)
3938 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3939 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3940 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3943 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3944 (unsigned long) vma
);
3950 get_32bit_section_headers (FILE * file
, unsigned int num
)
3952 Elf32_External_Shdr
* shdrs
;
3953 Elf_Internal_Shdr
* internal
;
3956 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
3957 elf_header
.e_shentsize
, num
,
3958 _("section headers"));
3962 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
3963 sizeof (Elf_Internal_Shdr
));
3965 if (section_headers
== NULL
)
3967 error (_("Out of memory\n"));
3971 for (i
= 0, internal
= section_headers
;
3975 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3976 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3977 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3978 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3979 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3980 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3981 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3982 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3983 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3984 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3993 get_64bit_section_headers (FILE * file
, unsigned int num
)
3995 Elf64_External_Shdr
* shdrs
;
3996 Elf_Internal_Shdr
* internal
;
3999 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4000 elf_header
.e_shentsize
, num
,
4001 _("section headers"));
4005 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4006 sizeof (Elf_Internal_Shdr
));
4008 if (section_headers
== NULL
)
4010 error (_("Out of memory\n"));
4014 for (i
= 0, internal
= section_headers
;
4018 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4019 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4020 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4021 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4022 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4023 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4024 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4025 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4026 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4027 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4035 static Elf_Internal_Sym
*
4036 get_32bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
4038 unsigned long number
;
4039 Elf32_External_Sym
* esyms
;
4040 Elf_External_Sym_Shndx
* shndx
;
4041 Elf_Internal_Sym
* isyms
;
4042 Elf_Internal_Sym
* psym
;
4045 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4046 section
->sh_size
, _("symbols"));
4051 if (symtab_shndx_hdr
!= NULL
4052 && (symtab_shndx_hdr
->sh_link
4053 == (unsigned long) (section
- section_headers
)))
4055 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4056 symtab_shndx_hdr
->sh_offset
,
4057 1, symtab_shndx_hdr
->sh_size
,
4066 number
= section
->sh_size
/ section
->sh_entsize
;
4067 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4071 error (_("Out of memory\n"));
4078 for (j
= 0, psym
= isyms
;
4082 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4083 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4084 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4085 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4086 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4088 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4089 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4090 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4091 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4092 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4102 static Elf_Internal_Sym
*
4103 get_64bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
4105 unsigned long number
;
4106 Elf64_External_Sym
* esyms
;
4107 Elf_External_Sym_Shndx
* shndx
;
4108 Elf_Internal_Sym
* isyms
;
4109 Elf_Internal_Sym
* psym
;
4112 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4113 section
->sh_size
, _("symbols"));
4118 if (symtab_shndx_hdr
!= NULL
4119 && (symtab_shndx_hdr
->sh_link
4120 == (unsigned long) (section
- section_headers
)))
4122 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4123 symtab_shndx_hdr
->sh_offset
,
4124 1, symtab_shndx_hdr
->sh_size
,
4133 number
= section
->sh_size
/ section
->sh_entsize
;
4134 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4138 error (_("Out of memory\n"));
4145 for (j
= 0, psym
= isyms
;
4149 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4150 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4151 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4152 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4153 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4155 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4156 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4157 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4158 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4159 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4170 get_elf_section_flags (bfd_vma sh_flags
)
4172 static char buff
[1024];
4174 int field_size
= is_32bit_elf
? 8 : 16;
4176 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
4177 bfd_vma os_flags
= 0;
4178 bfd_vma proc_flags
= 0;
4179 bfd_vma unknown_flags
= 0;
4187 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4188 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4189 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4190 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4191 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4192 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4193 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4194 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4195 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4196 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4197 /* IA-64 specific. */
4198 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4199 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4200 /* IA-64 OpenVMS specific. */
4201 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4202 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4203 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4204 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4205 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4206 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4208 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4209 /* SPARC specific. */
4210 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4213 if (do_section_details
)
4215 sprintf (buff
, "[%*.*lx]: ",
4216 field_size
, field_size
, (unsigned long) sh_flags
);
4217 p
+= field_size
+ 4;
4224 flag
= sh_flags
& - sh_flags
;
4227 if (do_section_details
)
4231 case SHF_WRITE
: sindex
= 0; break;
4232 case SHF_ALLOC
: sindex
= 1; break;
4233 case SHF_EXECINSTR
: sindex
= 2; break;
4234 case SHF_MERGE
: sindex
= 3; break;
4235 case SHF_STRINGS
: sindex
= 4; break;
4236 case SHF_INFO_LINK
: sindex
= 5; break;
4237 case SHF_LINK_ORDER
: sindex
= 6; break;
4238 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
4239 case SHF_GROUP
: sindex
= 8; break;
4240 case SHF_TLS
: sindex
= 9; break;
4241 case SHF_EXCLUDE
: sindex
= 18; break;
4245 switch (elf_header
.e_machine
)
4248 if (flag
== SHF_IA_64_SHORT
)
4250 else if (flag
== SHF_IA_64_NORECOV
)
4253 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
4256 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
4257 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
4258 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
4259 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
4260 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
4261 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
4271 case EM_OLD_SPARCV9
:
4272 case EM_SPARC32PLUS
:
4275 if (flag
== SHF_ORDERED
)
4285 if (p
!= buff
+ field_size
+ 4)
4287 if (size
< (10 + 2))
4294 size
-= flags
[sindex
].len
;
4295 p
= stpcpy (p
, flags
[sindex
].str
);
4297 else if (flag
& SHF_MASKOS
)
4299 else if (flag
& SHF_MASKPROC
)
4302 unknown_flags
|= flag
;
4308 case SHF_WRITE
: *p
= 'W'; break;
4309 case SHF_ALLOC
: *p
= 'A'; break;
4310 case SHF_EXECINSTR
: *p
= 'X'; break;
4311 case SHF_MERGE
: *p
= 'M'; break;
4312 case SHF_STRINGS
: *p
= 'S'; break;
4313 case SHF_INFO_LINK
: *p
= 'I'; break;
4314 case SHF_LINK_ORDER
: *p
= 'L'; break;
4315 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
4316 case SHF_GROUP
: *p
= 'G'; break;
4317 case SHF_TLS
: *p
= 'T'; break;
4318 case SHF_EXCLUDE
: *p
= 'E'; break;
4321 if ((elf_header
.e_machine
== EM_X86_64
4322 || elf_header
.e_machine
== EM_L1OM
)
4323 && flag
== SHF_X86_64_LARGE
)
4325 else if (flag
& SHF_MASKOS
)
4328 sh_flags
&= ~ SHF_MASKOS
;
4330 else if (flag
& SHF_MASKPROC
)
4333 sh_flags
&= ~ SHF_MASKPROC
;
4343 if (do_section_details
)
4347 size
-= 5 + field_size
;
4348 if (p
!= buff
+ field_size
+ 4)
4356 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4357 (unsigned long) os_flags
);
4358 p
+= 5 + field_size
;
4362 size
-= 7 + field_size
;
4363 if (p
!= buff
+ field_size
+ 4)
4371 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4372 (unsigned long) proc_flags
);
4373 p
+= 7 + field_size
;
4377 size
-= 10 + field_size
;
4378 if (p
!= buff
+ field_size
+ 4)
4386 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
4387 (unsigned long) unknown_flags
);
4388 p
+= 10 + field_size
;
4397 process_section_headers (FILE * file
)
4399 Elf_Internal_Shdr
* section
;
4402 section_headers
= NULL
;
4404 if (elf_header
.e_shnum
== 0)
4407 printf (_("\nThere are no sections in this file.\n"));
4412 if (do_sections
&& !do_header
)
4413 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4414 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4418 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4421 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4424 /* Read in the string table, so that we have names to display. */
4425 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4426 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4428 section
= section_headers
+ elf_header
.e_shstrndx
;
4430 if (section
->sh_size
!= 0)
4432 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4433 1, section
->sh_size
,
4436 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4440 /* Scan the sections for the dynamic symbol table
4441 and dynamic string table and debug sections. */
4442 dynamic_symbols
= NULL
;
4443 dynamic_strings
= NULL
;
4444 dynamic_syminfo
= NULL
;
4445 symtab_shndx_hdr
= NULL
;
4447 eh_addr_size
= is_32bit_elf
? 4 : 8;
4448 switch (elf_header
.e_machine
)
4451 case EM_MIPS_RS3_LE
:
4452 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4453 FDE addresses. However, the ABI also has a semi-official ILP32
4454 variant for which the normal FDE address size rules apply.
4456 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4457 section, where XX is the size of longs in bits. Unfortunately,
4458 earlier compilers provided no way of distinguishing ILP32 objects
4459 from LP64 objects, so if there's any doubt, we should assume that
4460 the official LP64 form is being used. */
4461 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4462 && find_section (".gcc_compiled_long32") == NULL
)
4468 switch (elf_header
.e_flags
& EF_H8_MACH
)
4470 case E_H8_MACH_H8300
:
4471 case E_H8_MACH_H8300HN
:
4472 case E_H8_MACH_H8300SN
:
4473 case E_H8_MACH_H8300SXN
:
4476 case E_H8_MACH_H8300H
:
4477 case E_H8_MACH_H8300S
:
4478 case E_H8_MACH_H8300SX
:
4486 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
4488 case EF_M32C_CPU_M16C
:
4495 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4498 size_t expected_entsize \
4499 = is_32bit_elf ? size32 : size64; \
4500 if (section->sh_entsize != expected_entsize) \
4501 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4502 i, (unsigned long int) section->sh_entsize, \
4503 (unsigned long int) expected_entsize); \
4504 section->sh_entsize = expected_entsize; \
4507 #define CHECK_ENTSIZE(section, i, type) \
4508 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4509 sizeof (Elf64_External_##type))
4511 for (i
= 0, section
= section_headers
;
4512 i
< elf_header
.e_shnum
;
4515 char * name
= SECTION_NAME (section
);
4517 if (section
->sh_type
== SHT_DYNSYM
)
4519 if (dynamic_symbols
!= NULL
)
4521 error (_("File contains multiple dynamic symbol tables\n"));
4525 CHECK_ENTSIZE (section
, i
, Sym
);
4526 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4527 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4529 else if (section
->sh_type
== SHT_STRTAB
4530 && streq (name
, ".dynstr"))
4532 if (dynamic_strings
!= NULL
)
4534 error (_("File contains multiple dynamic string tables\n"));
4538 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4539 1, section
->sh_size
,
4540 _("dynamic strings"));
4541 dynamic_strings_length
= section
->sh_size
;
4543 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4545 if (symtab_shndx_hdr
!= NULL
)
4547 error (_("File contains multiple symtab shndx tables\n"));
4550 symtab_shndx_hdr
= section
;
4552 else if (section
->sh_type
== SHT_SYMTAB
)
4553 CHECK_ENTSIZE (section
, i
, Sym
);
4554 else if (section
->sh_type
== SHT_GROUP
)
4555 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4556 else if (section
->sh_type
== SHT_REL
)
4557 CHECK_ENTSIZE (section
, i
, Rel
);
4558 else if (section
->sh_type
== SHT_RELA
)
4559 CHECK_ENTSIZE (section
, i
, Rela
);
4560 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4561 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
4562 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
4563 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
)
4564 && (const_strneq (name
, ".debug_")
4565 || const_strneq (name
, ".zdebug_")))
4568 name
+= sizeof (".zdebug_") - 1;
4570 name
+= sizeof (".debug_") - 1;
4573 || (do_debug_info
&& streq (name
, "info"))
4574 || (do_debug_info
&& streq (name
, "types"))
4575 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4576 || (do_debug_lines
&& streq (name
, "line"))
4577 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4578 || (do_debug_pubtypes
&& streq (name
, "pubtypes"))
4579 || (do_debug_aranges
&& streq (name
, "aranges"))
4580 || (do_debug_ranges
&& streq (name
, "ranges"))
4581 || (do_debug_frames
&& streq (name
, "frame"))
4582 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4583 || (do_debug_str
&& streq (name
, "str"))
4584 || (do_debug_loc
&& streq (name
, "loc"))
4586 request_dump_bynumber (i
, DEBUG_DUMP
);
4588 /* Linkonce section to be combined with .debug_info at link time. */
4589 else if ((do_debugging
|| do_debug_info
)
4590 && const_strneq (name
, ".gnu.linkonce.wi."))
4591 request_dump_bynumber (i
, DEBUG_DUMP
);
4592 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4593 request_dump_bynumber (i
, DEBUG_DUMP
);
4594 /* Trace sections for Itanium VMS. */
4595 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
4596 || do_trace_aranges
)
4597 && const_strneq (name
, ".trace_"))
4599 name
+= sizeof (".trace_") - 1;
4602 || (do_trace_info
&& streq (name
, "info"))
4603 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
4604 || (do_trace_aranges
&& streq (name
, "aranges"))
4606 request_dump_bynumber (i
, DEBUG_DUMP
);
4614 if (elf_header
.e_shnum
> 1)
4615 printf (_("\nSection Headers:\n"));
4617 printf (_("\nSection Header:\n"));
4621 if (do_section_details
)
4623 printf (_(" [Nr] Name\n"));
4624 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4628 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4632 if (do_section_details
)
4634 printf (_(" [Nr] Name\n"));
4635 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4639 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4643 if (do_section_details
)
4645 printf (_(" [Nr] Name\n"));
4646 printf (_(" Type Address Offset Link\n"));
4647 printf (_(" Size EntSize Info Align\n"));
4651 printf (_(" [Nr] Name Type Address Offset\n"));
4652 printf (_(" Size EntSize Flags Link Info Align\n"));
4656 if (do_section_details
)
4657 printf (_(" Flags\n"));
4659 for (i
= 0, section
= section_headers
;
4660 i
< elf_header
.e_shnum
;
4663 if (do_section_details
)
4665 printf (" [%2u] %s\n",
4667 SECTION_NAME (section
));
4668 if (is_32bit_elf
|| do_wide
)
4669 printf (" %-15.15s ",
4670 get_section_type_name (section
->sh_type
));
4673 printf ((do_wide
? " [%2u] %-17s %-15s "
4674 : " [%2u] %-17.17s %-15.15s "),
4676 SECTION_NAME (section
),
4677 get_section_type_name (section
->sh_type
));
4681 const char * link_too_big
= NULL
;
4683 print_vma (section
->sh_addr
, LONG_HEX
);
4685 printf ( " %6.6lx %6.6lx %2.2lx",
4686 (unsigned long) section
->sh_offset
,
4687 (unsigned long) section
->sh_size
,
4688 (unsigned long) section
->sh_entsize
);
4690 if (do_section_details
)
4691 fputs (" ", stdout
);
4693 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4695 if (section
->sh_link
>= elf_header
.e_shnum
)
4698 /* The sh_link value is out of range. Normally this indicates
4699 an error but it can have special values in Solaris binaries. */
4700 switch (elf_header
.e_machine
)
4706 case EM_OLD_SPARCV9
:
4707 case EM_SPARC32PLUS
:
4710 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
4711 link_too_big
= "BEFORE";
4712 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
4713 link_too_big
= "AFTER";
4720 if (do_section_details
)
4722 if (link_too_big
!= NULL
&& * link_too_big
)
4723 printf ("<%s> ", link_too_big
);
4725 printf ("%2u ", section
->sh_link
);
4726 printf ("%3u %2lu\n", section
->sh_info
,
4727 (unsigned long) section
->sh_addralign
);
4730 printf ("%2u %3u %2lu\n",
4733 (unsigned long) section
->sh_addralign
);
4735 if (link_too_big
&& ! * link_too_big
)
4736 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4737 i
, section
->sh_link
);
4741 print_vma (section
->sh_addr
, LONG_HEX
);
4743 if ((long) section
->sh_offset
== section
->sh_offset
)
4744 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4748 print_vma (section
->sh_offset
, LONG_HEX
);
4751 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4752 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4756 print_vma (section
->sh_size
, LONG_HEX
);
4759 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4760 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4764 print_vma (section
->sh_entsize
, LONG_HEX
);
4767 if (do_section_details
)
4768 fputs (" ", stdout
);
4770 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4772 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
4774 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4775 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
4778 print_vma (section
->sh_addralign
, DEC
);
4782 else if (do_section_details
)
4784 printf (" %-15.15s ",
4785 get_section_type_name (section
->sh_type
));
4786 print_vma (section
->sh_addr
, LONG_HEX
);
4787 if ((long) section
->sh_offset
== section
->sh_offset
)
4788 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4792 print_vma (section
->sh_offset
, LONG_HEX
);
4794 printf (" %u\n ", section
->sh_link
);
4795 print_vma (section
->sh_size
, LONG_HEX
);
4797 print_vma (section
->sh_entsize
, LONG_HEX
);
4799 printf (" %-16u %lu\n",
4801 (unsigned long) section
->sh_addralign
);
4806 print_vma (section
->sh_addr
, LONG_HEX
);
4807 if ((long) section
->sh_offset
== section
->sh_offset
)
4808 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4812 print_vma (section
->sh_offset
, LONG_HEX
);
4815 print_vma (section
->sh_size
, LONG_HEX
);
4817 print_vma (section
->sh_entsize
, LONG_HEX
);
4819 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4821 printf (" %2u %3u %lu\n",
4824 (unsigned long) section
->sh_addralign
);
4827 if (do_section_details
)
4828 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4831 if (!do_section_details
)
4832 printf (_("Key to Flags:\n\
4833 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4834 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
4835 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4841 get_group_flags (unsigned int flags
)
4843 static char buff
[32];
4853 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
4860 process_section_groups (FILE * file
)
4862 Elf_Internal_Shdr
* section
;
4864 struct group
* group
;
4865 Elf_Internal_Shdr
* symtab_sec
;
4866 Elf_Internal_Shdr
* strtab_sec
;
4867 Elf_Internal_Sym
* symtab
;
4871 /* Don't process section groups unless needed. */
4872 if (!do_unwind
&& !do_section_groups
)
4875 if (elf_header
.e_shnum
== 0)
4877 if (do_section_groups
)
4878 printf (_("\nThere are no sections in this file.\n"));
4883 if (section_headers
== NULL
)
4885 error (_("Section headers are not available!\n"));
4889 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
4890 sizeof (struct group
*));
4892 if (section_headers_groups
== NULL
)
4894 error (_("Out of memory\n"));
4898 /* Scan the sections for the group section. */
4900 for (i
= 0, section
= section_headers
;
4901 i
< elf_header
.e_shnum
;
4903 if (section
->sh_type
== SHT_GROUP
)
4906 if (group_count
== 0)
4908 if (do_section_groups
)
4909 printf (_("\nThere are no section groups in this file.\n"));
4914 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
4916 if (section_groups
== NULL
)
4918 error (_("Out of memory\n"));
4927 for (i
= 0, section
= section_headers
, group
= section_groups
;
4928 i
< elf_header
.e_shnum
;
4931 if (section
->sh_type
== SHT_GROUP
)
4933 char * name
= SECTION_NAME (section
);
4935 unsigned char * start
;
4936 unsigned char * indices
;
4937 unsigned int entry
, j
, size
;
4938 Elf_Internal_Shdr
* sec
;
4939 Elf_Internal_Sym
* sym
;
4941 /* Get the symbol table. */
4942 if (section
->sh_link
>= elf_header
.e_shnum
4943 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
4946 error (_("Bad sh_link in group section `%s'\n"), name
);
4950 if (symtab_sec
!= sec
)
4955 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4958 sym
= symtab
+ section
->sh_info
;
4960 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4962 if (sym
->st_shndx
== 0
4963 || sym
->st_shndx
>= elf_header
.e_shnum
)
4965 error (_("Bad sh_info in group section `%s'\n"), name
);
4969 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
4978 /* Get the string table. */
4979 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
4988 != (sec
= section_headers
+ symtab_sec
->sh_link
))
4993 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
4994 1, strtab_sec
->sh_size
,
4996 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4998 group_name
= sym
->st_name
< strtab_size
4999 ? strtab
+ sym
->st_name
: _("<corrupt>");
5002 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
5003 1, section
->sh_size
,
5007 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
5008 entry
= byte_get (indices
, 4);
5011 if (do_section_groups
)
5013 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5014 get_group_flags (entry
), i
, name
, group_name
, size
);
5016 printf (_(" [Index] Name\n"));
5019 group
->group_index
= i
;
5021 for (j
= 0; j
< size
; j
++)
5023 struct group_list
* g
;
5025 entry
= byte_get (indices
, 4);
5028 if (entry
>= elf_header
.e_shnum
)
5030 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5031 entry
, i
, elf_header
.e_shnum
- 1);
5035 if (section_headers_groups
[entry
] != NULL
)
5039 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5041 section_headers_groups
[entry
]->group_index
);
5046 /* Intel C/C++ compiler may put section 0 in a
5047 section group. We just warn it the first time
5048 and ignore it afterwards. */
5049 static int warned
= 0;
5052 error (_("section 0 in group section [%5u]\n"),
5053 section_headers_groups
[entry
]->group_index
);
5059 section_headers_groups
[entry
] = group
;
5061 if (do_section_groups
)
5063 sec
= section_headers
+ entry
;
5064 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
5067 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
5068 g
->section_index
= entry
;
5069 g
->next
= group
->root
;
5087 /* Data used to display dynamic fixups. */
5089 struct ia64_vms_dynfixup
5091 bfd_vma needed_ident
; /* Library ident number. */
5092 bfd_vma needed
; /* Index in the dstrtab of the library name. */
5093 bfd_vma fixup_needed
; /* Index of the library. */
5094 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
5095 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
5098 /* Data used to display dynamic relocations. */
5100 struct ia64_vms_dynimgrela
5102 bfd_vma img_rela_cnt
; /* Number of relocations. */
5103 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
5106 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5110 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
5111 const char *strtab
, unsigned int strtab_sz
)
5113 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
5115 const char *lib_name
;
5117 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
5118 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
5119 _("dynamic section image fixups"));
5123 if (fixup
->needed
< strtab_sz
)
5124 lib_name
= strtab
+ fixup
->needed
;
5127 warn ("corrupt library name index of 0x%lx found in dynamic entry",
5128 (unsigned long) fixup
->needed
);
5131 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5132 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
5134 (_("Seg Offset Type SymVec DataType\n"));
5136 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
5141 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
5142 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
5143 type
= BYTE_GET (imfs
[i
].type
);
5144 rtype
= elf_ia64_reloc_type (type
);
5146 printf (" 0x%08x ", type
);
5148 printf (" %-32s ", rtype
);
5149 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
5150 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
5156 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5159 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
5161 Elf64_External_VMS_IMAGE_RELA
*imrs
;
5164 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
5165 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
5166 _("dynamic section image relas"));
5170 printf (_("\nImage relocs\n"));
5172 (_("Seg Offset Type Addend Seg Sym Off\n"));
5174 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
5179 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
5180 printf ("%08" BFD_VMA_FMT
"x ",
5181 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
5182 type
= BYTE_GET (imrs
[i
].type
);
5183 rtype
= elf_ia64_reloc_type (type
);
5185 printf ("0x%08x ", type
);
5187 printf ("%-31s ", rtype
);
5188 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
5189 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
5190 printf ("%08" BFD_VMA_FMT
"x\n",
5191 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
5197 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
5200 process_ia64_vms_dynamic_relocs (FILE *file
)
5202 struct ia64_vms_dynfixup fixup
;
5203 struct ia64_vms_dynimgrela imgrela
;
5204 Elf_Internal_Dyn
*entry
;
5206 bfd_vma strtab_off
= 0;
5207 bfd_vma strtab_sz
= 0;
5208 char *strtab
= NULL
;
5210 memset (&fixup
, 0, sizeof (fixup
));
5211 memset (&imgrela
, 0, sizeof (imgrela
));
5213 /* Note: the order of the entries is specified by the OpenVMS specs. */
5214 for (entry
= dynamic_section
;
5215 entry
< dynamic_section
+ dynamic_nent
;
5218 switch (entry
->d_tag
)
5220 case DT_IA_64_VMS_STRTAB_OFFSET
:
5221 strtab_off
= entry
->d_un
.d_val
;
5224 strtab_sz
= entry
->d_un
.d_val
;
5226 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
5227 1, strtab_sz
, _("dynamic string section"));
5230 case DT_IA_64_VMS_NEEDED_IDENT
:
5231 fixup
.needed_ident
= entry
->d_un
.d_val
;
5234 fixup
.needed
= entry
->d_un
.d_val
;
5236 case DT_IA_64_VMS_FIXUP_NEEDED
:
5237 fixup
.fixup_needed
= entry
->d_un
.d_val
;
5239 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
5240 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
5242 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
5243 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
5245 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
5248 case DT_IA_64_VMS_IMG_RELA_CNT
:
5249 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
5251 case DT_IA_64_VMS_IMG_RELA_OFF
:
5252 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
5254 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
5274 } dynamic_relocations
[] =
5276 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
5277 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
5278 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
5281 /* Process the reloc section. */
5284 process_relocs (FILE * file
)
5286 unsigned long rel_size
;
5287 unsigned long rel_offset
;
5293 if (do_using_dynamic
)
5297 int has_dynamic_reloc
;
5300 has_dynamic_reloc
= 0;
5302 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
5304 is_rela
= dynamic_relocations
[i
].rela
;
5305 name
= dynamic_relocations
[i
].name
;
5306 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
5307 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
5309 has_dynamic_reloc
|= rel_size
;
5311 if (is_rela
== UNKNOWN
)
5313 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
5314 switch (dynamic_info
[DT_PLTREL
])
5328 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5329 name
, rel_offset
, rel_size
);
5331 dump_relocations (file
,
5332 offset_from_vma (file
, rel_offset
, rel_size
),
5334 dynamic_symbols
, num_dynamic_syms
,
5335 dynamic_strings
, dynamic_strings_length
, is_rela
);
5340 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
5342 if (! has_dynamic_reloc
)
5343 printf (_("\nThere are no dynamic relocations in this file.\n"));
5347 Elf_Internal_Shdr
* section
;
5351 for (i
= 0, section
= section_headers
;
5352 i
< elf_header
.e_shnum
;
5355 if ( section
->sh_type
!= SHT_RELA
5356 && section
->sh_type
!= SHT_REL
)
5359 rel_offset
= section
->sh_offset
;
5360 rel_size
= section
->sh_size
;
5364 Elf_Internal_Shdr
* strsec
;
5367 printf (_("\nRelocation section "));
5369 if (string_table
== NULL
)
5370 printf ("%d", section
->sh_name
);
5372 printf (_("'%s'"), SECTION_NAME (section
));
5374 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5375 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
5377 is_rela
= section
->sh_type
== SHT_RELA
;
5379 if (section
->sh_link
!= 0
5380 && section
->sh_link
< elf_header
.e_shnum
)
5382 Elf_Internal_Shdr
* symsec
;
5383 Elf_Internal_Sym
* symtab
;
5384 unsigned long nsyms
;
5385 unsigned long strtablen
= 0;
5386 char * strtab
= NULL
;
5388 symsec
= section_headers
+ section
->sh_link
;
5389 if (symsec
->sh_type
!= SHT_SYMTAB
5390 && symsec
->sh_type
!= SHT_DYNSYM
)
5393 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
5394 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
5399 if (symsec
->sh_link
!= 0
5400 && symsec
->sh_link
< elf_header
.e_shnum
)
5402 strsec
= section_headers
+ symsec
->sh_link
;
5404 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5407 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
5410 dump_relocations (file
, rel_offset
, rel_size
,
5411 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
5417 dump_relocations (file
, rel_offset
, rel_size
,
5418 NULL
, 0, NULL
, 0, is_rela
);
5425 printf (_("\nThere are no relocations in this file.\n"));
5431 /* Process the unwind section. */
5433 #include "unwind-ia64.h"
5435 /* An absolute address consists of a section and an offset. If the
5436 section is NULL, the offset itself is the address, otherwise, the
5437 address equals to LOAD_ADDRESS(section) + offset. */
5441 unsigned short section
;
5445 #define ABSADDR(a) \
5447 ? section_headers [(a).section].sh_addr + (a).offset \
5450 struct ia64_unw_table_entry
5452 struct absaddr start
;
5454 struct absaddr info
;
5457 struct ia64_unw_aux_info
5460 struct ia64_unw_table_entry
*table
; /* Unwind table. */
5461 unsigned long table_len
; /* Length of unwind table. */
5462 unsigned char * info
; /* Unwind info. */
5463 unsigned long info_size
; /* Size of unwind info. */
5464 bfd_vma info_addr
; /* starting address of unwind info. */
5465 bfd_vma seg_base
; /* Starting address of segment. */
5466 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5467 unsigned long nsyms
; /* Number of symbols. */
5468 char * strtab
; /* The string table. */
5469 unsigned long strtab_size
; /* Size of string table. */
5473 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
5474 unsigned long nsyms
,
5475 const char * strtab
,
5476 unsigned long strtab_size
,
5477 struct absaddr addr
,
5478 const char ** symname
,
5481 bfd_vma dist
= 0x100000;
5482 Elf_Internal_Sym
* sym
;
5483 Elf_Internal_Sym
* best
= NULL
;
5486 REMOVE_ARCH_BITS (addr
.offset
);
5488 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
5490 bfd_vma value
= sym
->st_value
;
5492 REMOVE_ARCH_BITS (value
);
5494 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
5495 && sym
->st_name
!= 0
5496 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
5497 && addr
.offset
>= value
5498 && addr
.offset
- value
< dist
)
5501 dist
= addr
.offset
- value
;
5508 *symname
= (best
->st_name
>= strtab_size
5509 ? _("<corrupt>") : strtab
+ best
->st_name
);
5514 *offset
= addr
.offset
;
5518 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
5520 struct ia64_unw_table_entry
* tp
;
5523 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5527 const unsigned char * dp
;
5528 const unsigned char * head
;
5529 const char * procname
;
5531 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5532 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
5534 fputs ("\n<", stdout
);
5538 fputs (procname
, stdout
);
5541 printf ("+%lx", (unsigned long) offset
);
5544 fputs (">: [", stdout
);
5545 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5546 fputc ('-', stdout
);
5547 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5548 printf ("], info at +0x%lx\n",
5549 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
5551 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
5552 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
5554 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5555 (unsigned) UNW_VER (stamp
),
5556 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
5557 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
5558 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
5559 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
5561 if (UNW_VER (stamp
) != 1)
5563 printf (_("\tUnknown version.\n"));
5568 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
5569 dp
= unw_decode (dp
, in_body
, & in_body
);
5574 slurp_ia64_unwind_table (FILE * file
,
5575 struct ia64_unw_aux_info
* aux
,
5576 Elf_Internal_Shdr
* sec
)
5578 unsigned long size
, nrelas
, i
;
5579 Elf_Internal_Phdr
* seg
;
5580 struct ia64_unw_table_entry
* tep
;
5581 Elf_Internal_Shdr
* relsec
;
5582 Elf_Internal_Rela
* rela
;
5583 Elf_Internal_Rela
* rp
;
5584 unsigned char * table
;
5586 Elf_Internal_Sym
* sym
;
5587 const char * relname
;
5589 /* First, find the starting address of the segment that includes
5592 if (elf_header
.e_phnum
)
5594 if (! get_program_headers (file
))
5597 for (seg
= program_headers
;
5598 seg
< program_headers
+ elf_header
.e_phnum
;
5601 if (seg
->p_type
!= PT_LOAD
)
5604 if (sec
->sh_addr
>= seg
->p_vaddr
5605 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5607 aux
->seg_base
= seg
->p_vaddr
;
5613 /* Second, build the unwind table from the contents of the unwind section: */
5614 size
= sec
->sh_size
;
5615 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
5620 aux
->table
= (struct ia64_unw_table_entry
*)
5621 xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
5623 for (tp
= table
; tp
< table
+ size
; ++tep
)
5625 tep
->start
.section
= SHN_UNDEF
;
5626 tep
->end
.section
= SHN_UNDEF
;
5627 tep
->info
.section
= SHN_UNDEF
;
5628 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5629 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5630 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5631 tep
->start
.offset
+= aux
->seg_base
;
5632 tep
->end
.offset
+= aux
->seg_base
;
5633 tep
->info
.offset
+= aux
->seg_base
;
5637 /* Third, apply any relocations to the unwind table: */
5638 for (relsec
= section_headers
;
5639 relsec
< section_headers
+ elf_header
.e_shnum
;
5642 if (relsec
->sh_type
!= SHT_RELA
5643 || relsec
->sh_info
>= elf_header
.e_shnum
5644 || section_headers
+ relsec
->sh_info
!= sec
)
5647 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5651 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5653 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5654 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5656 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5658 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5662 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5664 switch (rp
->r_offset
/eh_addr_size
% 3)
5667 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5668 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
5671 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5672 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
5675 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5676 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
5686 aux
->table_len
= size
/ (3 * eh_addr_size
);
5691 ia64_process_unwind (FILE * file
)
5693 Elf_Internal_Shdr
* sec
;
5694 Elf_Internal_Shdr
* unwsec
= NULL
;
5695 Elf_Internal_Shdr
* strsec
;
5696 unsigned long i
, unwcount
= 0, unwstart
= 0;
5697 struct ia64_unw_aux_info aux
;
5699 memset (& aux
, 0, sizeof (aux
));
5701 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5703 if (sec
->sh_type
== SHT_SYMTAB
5704 && sec
->sh_link
< elf_header
.e_shnum
)
5706 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5707 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5709 strsec
= section_headers
+ sec
->sh_link
;
5710 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5713 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5715 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5720 printf (_("\nThere are no unwind sections in this file.\n"));
5722 while (unwcount
-- > 0)
5727 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5728 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5729 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5736 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5738 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5740 /* We need to find which section group it is in. */
5741 struct group_list
* g
= section_headers_groups
[i
]->root
;
5743 for (; g
!= NULL
; g
= g
->next
)
5745 sec
= section_headers
+ g
->section_index
;
5747 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5752 i
= elf_header
.e_shnum
;
5754 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5756 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5757 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5758 suffix
= SECTION_NAME (unwsec
) + len
;
5759 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5761 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5762 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5767 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5768 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5769 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5770 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5772 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5773 suffix
= SECTION_NAME (unwsec
) + len
;
5774 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5776 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5777 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5781 if (i
== elf_header
.e_shnum
)
5783 printf (_("\nCould not find unwind info section for "));
5785 if (string_table
== NULL
)
5786 printf ("%d", unwsec
->sh_name
);
5788 printf (_("'%s'"), SECTION_NAME (unwsec
));
5792 aux
.info_size
= sec
->sh_size
;
5793 aux
.info_addr
= sec
->sh_addr
;
5794 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
5798 printf (_("\nUnwind section "));
5800 if (string_table
== NULL
)
5801 printf ("%d", unwsec
->sh_name
);
5803 printf (_("'%s'"), SECTION_NAME (unwsec
));
5805 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5806 (unsigned long) unwsec
->sh_offset
,
5807 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5809 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5811 if (aux
.table_len
> 0)
5812 dump_ia64_unwind (& aux
);
5815 free ((char *) aux
.table
);
5817 free ((char *) aux
.info
);
5826 free ((char *) aux
.strtab
);
5831 struct hppa_unw_table_entry
5833 struct absaddr start
;
5835 unsigned int Cannot_unwind
:1; /* 0 */
5836 unsigned int Millicode
:1; /* 1 */
5837 unsigned int Millicode_save_sr0
:1; /* 2 */
5838 unsigned int Region_description
:2; /* 3..4 */
5839 unsigned int reserved1
:1; /* 5 */
5840 unsigned int Entry_SR
:1; /* 6 */
5841 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5842 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5843 unsigned int Args_stored
:1; /* 16 */
5844 unsigned int Variable_Frame
:1; /* 17 */
5845 unsigned int Separate_Package_Body
:1; /* 18 */
5846 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5847 unsigned int Stack_Overflow_Check
:1; /* 20 */
5848 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5849 unsigned int Ada_Region
:1; /* 22 */
5850 unsigned int cxx_info
:1; /* 23 */
5851 unsigned int cxx_try_catch
:1; /* 24 */
5852 unsigned int sched_entry_seq
:1; /* 25 */
5853 unsigned int reserved2
:1; /* 26 */
5854 unsigned int Save_SP
:1; /* 27 */
5855 unsigned int Save_RP
:1; /* 28 */
5856 unsigned int Save_MRP_in_frame
:1; /* 29 */
5857 unsigned int extn_ptr_defined
:1; /* 30 */
5858 unsigned int Cleanup_defined
:1; /* 31 */
5860 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5861 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5862 unsigned int Large_frame
:1; /* 2 */
5863 unsigned int Pseudo_SP_Set
:1; /* 3 */
5864 unsigned int reserved4
:1; /* 4 */
5865 unsigned int Total_frame_size
:27; /* 5..31 */
5868 struct hppa_unw_aux_info
5870 struct hppa_unw_table_entry
*table
; /* Unwind table. */
5871 unsigned long table_len
; /* Length of unwind table. */
5872 bfd_vma seg_base
; /* Starting address of segment. */
5873 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5874 unsigned long nsyms
; /* Number of symbols. */
5875 char * strtab
; /* The string table. */
5876 unsigned long strtab_size
; /* Size of string table. */
5880 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
5882 struct hppa_unw_table_entry
* tp
;
5884 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5887 const char * procname
;
5889 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5890 aux
->strtab_size
, tp
->start
, &procname
,
5893 fputs ("\n<", stdout
);
5897 fputs (procname
, stdout
);
5900 printf ("+%lx", (unsigned long) offset
);
5903 fputs (">: [", stdout
);
5904 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5905 fputc ('-', stdout
);
5906 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5909 #define PF(_m) if (tp->_m) printf (#_m " ");
5910 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5913 PF(Millicode_save_sr0
);
5914 /* PV(Region_description); */
5920 PF(Separate_Package_Body
);
5921 PF(Frame_Extension_Millicode
);
5922 PF(Stack_Overflow_Check
);
5923 PF(Two_Instruction_SP_Increment
);
5927 PF(sched_entry_seq
);
5930 PF(Save_MRP_in_frame
);
5931 PF(extn_ptr_defined
);
5932 PF(Cleanup_defined
);
5933 PF(MPE_XL_interrupt_marker
);
5934 PF(HP_UX_interrupt_marker
);
5937 PV(Total_frame_size
);
5946 slurp_hppa_unwind_table (FILE * file
,
5947 struct hppa_unw_aux_info
* aux
,
5948 Elf_Internal_Shdr
* sec
)
5950 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5951 Elf_Internal_Phdr
* seg
;
5952 struct hppa_unw_table_entry
* tep
;
5953 Elf_Internal_Shdr
* relsec
;
5954 Elf_Internal_Rela
* rela
;
5955 Elf_Internal_Rela
* rp
;
5956 unsigned char * table
;
5958 Elf_Internal_Sym
* sym
;
5959 const char * relname
;
5961 /* First, find the starting address of the segment that includes
5964 if (elf_header
.e_phnum
)
5966 if (! get_program_headers (file
))
5969 for (seg
= program_headers
;
5970 seg
< program_headers
+ elf_header
.e_phnum
;
5973 if (seg
->p_type
!= PT_LOAD
)
5976 if (sec
->sh_addr
>= seg
->p_vaddr
5977 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5979 aux
->seg_base
= seg
->p_vaddr
;
5985 /* Second, build the unwind table from the contents of the unwind
5987 size
= sec
->sh_size
;
5988 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
5994 nentries
= size
/ unw_ent_size
;
5995 size
= unw_ent_size
* nentries
;
5997 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
5998 xcmalloc (nentries
, sizeof (aux
->table
[0]));
6000 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
6002 unsigned int tmp1
, tmp2
;
6004 tep
->start
.section
= SHN_UNDEF
;
6005 tep
->end
.section
= SHN_UNDEF
;
6007 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
6008 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
6009 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
6010 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
6012 tep
->start
.offset
+= aux
->seg_base
;
6013 tep
->end
.offset
+= aux
->seg_base
;
6015 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
6016 tep
->Millicode
= (tmp1
>> 30) & 0x1;
6017 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
6018 tep
->Region_description
= (tmp1
>> 27) & 0x3;
6019 tep
->reserved1
= (tmp1
>> 26) & 0x1;
6020 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
6021 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
6022 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
6023 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
6024 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
6025 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
6026 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
6027 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
6028 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
6029 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
6030 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
6031 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
6032 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
6033 tep
->reserved2
= (tmp1
>> 5) & 0x1;
6034 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
6035 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
6036 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
6037 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
6038 tep
->Cleanup_defined
= tmp1
& 0x1;
6040 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
6041 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
6042 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
6043 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
6044 tep
->reserved4
= (tmp2
>> 27) & 0x1;
6045 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
6049 /* Third, apply any relocations to the unwind table. */
6050 for (relsec
= section_headers
;
6051 relsec
< section_headers
+ elf_header
.e_shnum
;
6054 if (relsec
->sh_type
!= SHT_RELA
6055 || relsec
->sh_info
>= elf_header
.e_shnum
6056 || section_headers
+ relsec
->sh_info
!= sec
)
6059 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6063 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6065 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
6066 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6068 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
6069 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
6071 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6075 i
= rp
->r_offset
/ unw_ent_size
;
6077 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
6080 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6081 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
6084 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6085 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
6095 aux
->table_len
= nentries
;
6101 hppa_process_unwind (FILE * file
)
6103 struct hppa_unw_aux_info aux
;
6104 Elf_Internal_Shdr
* unwsec
= NULL
;
6105 Elf_Internal_Shdr
* strsec
;
6106 Elf_Internal_Shdr
* sec
;
6109 memset (& aux
, 0, sizeof (aux
));
6111 if (string_table
== NULL
)
6114 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6116 if (sec
->sh_type
== SHT_SYMTAB
6117 && sec
->sh_link
< elf_header
.e_shnum
)
6119 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
6120 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
6122 strsec
= section_headers
+ sec
->sh_link
;
6123 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6126 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6128 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6133 printf (_("\nThere are no unwind sections in this file.\n"));
6135 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6137 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6139 printf (_("\nUnwind section "));
6140 printf (_("'%s'"), SECTION_NAME (sec
));
6142 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6143 (unsigned long) sec
->sh_offset
,
6144 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
6146 slurp_hppa_unwind_table (file
, &aux
, sec
);
6147 if (aux
.table_len
> 0)
6148 dump_hppa_unwind (&aux
);
6151 free ((char *) aux
.table
);
6159 free ((char *) aux
.strtab
);
6166 unsigned char *data
;
6168 Elf_Internal_Shdr
*sec
;
6169 Elf_Internal_Rela
*rela
;
6170 unsigned long nrelas
;
6171 unsigned int rel_type
;
6173 Elf_Internal_Rela
*next_rela
;
6176 struct arm_unw_aux_info
6180 Elf_Internal_Sym
*symtab
; /* The symbol table. */
6181 unsigned long nsyms
; /* Number of symbols. */
6182 char *strtab
; /* The string table. */
6183 unsigned long strtab_size
; /* Size of string table. */
6187 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
6188 bfd_vma fn
, struct absaddr addr
)
6190 const char *procname
;
6193 if (addr
.section
== SHN_UNDEF
)
6196 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6197 aux
->strtab_size
, addr
, &procname
,
6200 print_vma (fn
, PREFIX_HEX
);
6204 fputs (" <", stdout
);
6205 fputs (procname
, stdout
);
6208 printf ("+0x%lx", (unsigned long) sym_offset
);
6209 fputc ('>', stdout
);
6216 arm_free_section (struct arm_section
*arm_sec
)
6218 if (arm_sec
->data
!= NULL
)
6219 free (arm_sec
->data
);
6221 if (arm_sec
->rela
!= NULL
)
6222 free (arm_sec
->rela
);
6226 arm_section_get_word (struct arm_unw_aux_info
*aux
,
6227 struct arm_section
*arm_sec
,
6228 Elf_Internal_Shdr
*sec
, bfd_vma word_offset
,
6229 unsigned int *wordp
, struct absaddr
*addr
)
6231 Elf_Internal_Rela
*rp
;
6232 Elf_Internal_Sym
*sym
;
6233 const char * relname
;
6235 bfd_boolean wrapped
;
6237 addr
->section
= SHN_UNDEF
;
6240 if (sec
!= arm_sec
->sec
)
6242 Elf_Internal_Shdr
*relsec
;
6244 arm_free_section (arm_sec
);
6247 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
6248 sec
->sh_size
, _("unwind data"));
6250 arm_sec
->rela
= NULL
;
6251 arm_sec
->nrelas
= 0;
6253 for (relsec
= section_headers
;
6254 relsec
< section_headers
+ elf_header
.e_shnum
;
6257 if (relsec
->sh_info
>= elf_header
.e_shnum
6258 || section_headers
+ relsec
->sh_info
!= sec
)
6261 if (relsec
->sh_type
== SHT_REL
)
6263 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
6265 & arm_sec
->rela
, & arm_sec
->nrelas
))
6269 else if (relsec
->sh_type
== SHT_RELA
)
6271 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
6273 & arm_sec
->rela
, & arm_sec
->nrelas
))
6279 arm_sec
->next_rela
= arm_sec
->rela
;
6282 if (arm_sec
->data
== NULL
)
6285 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
6288 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
6290 bfd_vma prelval
, offset
;
6292 if (rp
->r_offset
> word_offset
&& !wrapped
)
6297 if (rp
->r_offset
> word_offset
)
6300 if (rp
->r_offset
& 3)
6302 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6303 (unsigned long) rp
->r_offset
);
6307 if (rp
->r_offset
< word_offset
)
6310 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
6312 if (streq (relname
, "R_ARM_NONE"))
6315 if (! streq (relname
, "R_ARM_PREL31"))
6317 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6321 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
6323 if (arm_sec
->rel_type
== SHT_REL
)
6325 offset
= word
& 0x7fffffff;
6326 if (offset
& 0x40000000)
6327 offset
|= ~ (bfd_vma
) 0x7fffffff;
6330 offset
= rp
->r_addend
;
6332 offset
+= sym
->st_value
;
6333 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
6335 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
6336 addr
->section
= sym
->st_shndx
;
6337 addr
->offset
= offset
;
6342 arm_sec
->next_rela
= rp
;
6348 decode_arm_unwind (struct arm_unw_aux_info
*aux
,
6349 unsigned int word
, unsigned int remaining
,
6350 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
6351 struct arm_section
*data_arm_sec
)
6354 unsigned int more_words
;
6355 struct absaddr addr
;
6358 if (remaining == 0 && more_words) \
6361 if (!arm_section_get_word (aux, data_arm_sec, data_sec, \
6362 data_offset, &word, &addr)) \
6368 #define GET_OP(OP) \
6373 (OP) = word >> 24; \
6378 printf (_("[Truncated opcode]\n")); \
6381 printf (_("0x%02x "), OP)
6385 /* Fetch the first word. */
6386 if (!arm_section_get_word (aux
, data_arm_sec
, data_sec
, data_offset
,
6392 if ((word
& 0x80000000) == 0)
6394 /* Expand prel31 for personality routine. */
6396 const char *procname
;
6399 if (fn
& 0x40000000)
6400 fn
|= ~ (bfd_vma
) 0x7fffffff;
6401 fn
= fn
+ data_sec
->sh_addr
+ data_offset
;
6403 printf (_(" Personality routine: "));
6404 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
6405 fputc ('\n', stdout
);
6407 /* The GCC personality routines use the standard compact
6408 encoding, starting with one byte giving the number of
6410 if (procname
!= NULL
6411 && (const_strneq (procname
, "__gcc_personality_v0")
6412 || const_strneq (procname
, "__gxx_personality_v0")
6413 || const_strneq (procname
, "__gcj_personality_v0")
6414 || const_strneq (procname
, "__gnu_objc_personality_v0")))
6421 printf (_(" [Truncated data]\n"));
6424 more_words
= word
>> 24;
6434 per_index
= (word
>> 24) & 0x7f;
6435 if (per_index
!= 0 && per_index
!= 1 && per_index
!= 2)
6437 printf (_(" [reserved compact index %d]\n"), per_index
);
6441 printf (_(" Compact model %d\n"), per_index
);
6450 more_words
= (word
>> 16) & 0xff;
6456 /* Decode the unwinding instructions. */
6459 unsigned int op
, op2
;
6468 printf (_(" 0x%02x "), op
);
6470 if ((op
& 0xc0) == 0x00)
6472 int offset
= ((op
& 0x3f) << 2) + 4;
6473 printf (_(" vsp = vsp + %d"), offset
);
6475 else if ((op
& 0xc0) == 0x40)
6477 int offset
= ((op
& 0x3f) << 2) + 4;
6478 printf (_(" vsp = vsp - %d"), offset
);
6480 else if ((op
& 0xf0) == 0x80)
6483 if (op
== 0x80 && op2
== 0)
6484 printf (_("Refuse to unwind"));
6487 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
6492 for (i
= 0; i
< 12; i
++)
6493 if (mask
& (1 << i
))
6499 printf ("r%d", 4 + i
);
6504 else if ((op
& 0xf0) == 0x90)
6506 if (op
== 0x9d || op
== 0x9f)
6507 printf (_(" [Reserved]"));
6509 printf (_(" vsp = r%d"), op
& 0x0f);
6511 else if ((op
& 0xf0) == 0xa0)
6513 int end
= 4 + (op
& 0x07);
6517 for (i
= 4; i
<= end
; i
++)
6533 else if (op
== 0xb0)
6534 printf (_(" finish"));
6535 else if (op
== 0xb1)
6538 if (op2
== 0 || (op2
& 0xf0) != 0)
6539 printf (_("[Spare]"));
6542 unsigned int mask
= op2
& 0x0f;
6546 for (i
= 0; i
< 12; i
++)
6547 if (mask
& (1 << i
))
6558 else if (op
== 0xb2)
6560 unsigned char buf
[9];
6561 unsigned int i
, len
;
6562 unsigned long offset
;
6563 for (i
= 0; i
< sizeof (buf
); i
++)
6566 if ((buf
[i
] & 0x80) == 0)
6569 assert (i
< sizeof (buf
));
6570 offset
= read_uleb128 (buf
, &len
);
6571 assert (len
== i
+ 1);
6572 offset
= offset
* 4 + 0x204;
6573 printf (_("vsp = vsp + %ld"), offset
);
6577 if (op
== 0xb3 || op
== 0xc6 || op
== 0xc7 || op
== 0xc8 || op
== 0xc9)
6580 printf (_("[unsupported two-byte opcode]"));
6584 printf (_(" [unsupported opcode]"));
6590 /* Decode the descriptors. Not implemented. */
6594 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
6596 struct arm_section exidx_arm_sec
, extab_arm_sec
;
6597 unsigned int i
, exidx_len
;
6599 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
6600 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
6601 exidx_len
= exidx_sec
->sh_size
/ 8;
6603 for (i
= 0; i
< exidx_len
; i
++)
6605 unsigned int exidx_fn
, exidx_entry
;
6606 struct absaddr fn_addr
, entry_addr
;
6609 fputc ('\n', stdout
);
6611 if (!arm_section_get_word (aux
, &exidx_arm_sec
, exidx_sec
,
6612 8 * i
, &exidx_fn
, &fn_addr
)
6613 || !arm_section_get_word (aux
, &exidx_arm_sec
, exidx_sec
,
6614 8 * i
+ 4, &exidx_entry
, &entry_addr
))
6616 arm_free_section (&exidx_arm_sec
);
6617 arm_free_section (&extab_arm_sec
);
6621 fn
= exidx_fn
& 0x7fffffff;
6622 if (fn
& 0x40000000)
6623 fn
|= ~ (bfd_vma
) 0x7fffffff;
6624 fn
= fn
+ exidx_sec
->sh_addr
+ 8 * i
;
6626 arm_print_vma_and_name (aux
, fn
, entry_addr
);
6627 fputs (": ", stdout
);
6629 if (exidx_entry
== 1)
6631 print_vma (exidx_entry
, PREFIX_HEX
);
6632 fputs (" [cantunwind]\n", stdout
);
6634 else if (exidx_entry
& 0x80000000)
6636 print_vma (exidx_entry
, PREFIX_HEX
);
6637 fputc ('\n', stdout
);
6638 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
6642 bfd_vma table
, table_offset
= 0;
6643 Elf_Internal_Shdr
*table_sec
;
6645 fputs ("@", stdout
);
6646 table
= exidx_entry
;
6647 if (table
& 0x40000000)
6648 table
|= ~ (bfd_vma
) 0x7fffffff;
6649 table
= table
+ exidx_sec
->sh_addr
+ 8 * i
+ 4;
6650 print_vma (table
, PREFIX_HEX
);
6653 /* Locate the matching .ARM.extab. */
6654 if (entry_addr
.section
!= SHN_UNDEF
6655 && entry_addr
.section
< elf_header
.e_shnum
)
6657 table_sec
= section_headers
+ entry_addr
.section
;
6658 table_offset
= entry_addr
.offset
;
6662 table_sec
= find_section_by_address (table
);
6663 if (table_sec
!= NULL
)
6664 table_offset
= table
- table_sec
->sh_addr
;
6666 if (table_sec
== NULL
)
6668 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
6669 (unsigned long) table
);
6672 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
6679 arm_free_section (&exidx_arm_sec
);
6680 arm_free_section (&extab_arm_sec
);
6684 arm_process_unwind (FILE *file
)
6686 struct arm_unw_aux_info aux
;
6687 Elf_Internal_Shdr
*unwsec
= NULL
;
6688 Elf_Internal_Shdr
*strsec
;
6689 Elf_Internal_Shdr
*sec
;
6692 memset (& aux
, 0, sizeof (aux
));
6695 if (string_table
== NULL
)
6698 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6700 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
6702 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
6703 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
6705 strsec
= section_headers
+ sec
->sh_link
;
6706 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
6707 1, strsec
->sh_size
, _("string table"));
6708 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6710 else if (sec
->sh_type
== SHT_ARM_EXIDX
)
6715 printf (_("\nThere are no unwind sections in this file.\n"));
6717 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6719 if (sec
->sh_type
== SHT_ARM_EXIDX
)
6721 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
6723 (unsigned long) sec
->sh_offset
,
6724 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
6726 dump_arm_unwind (&aux
, sec
);
6733 free ((char *) aux
.strtab
);
6739 process_unwind (FILE * file
)
6741 struct unwind_handler
6744 int (* handler
)(FILE *);
6747 { EM_ARM
, arm_process_unwind
},
6748 { EM_IA_64
, ia64_process_unwind
},
6749 { EM_PARISC
, hppa_process_unwind
},
6757 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
6758 if (elf_header
.e_machine
== handlers
[i
].machtype
)
6759 return handlers
[i
].handler (file
);
6761 printf (_("\nThere are no unwind sections in this file.\n"));
6766 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
6768 switch (entry
->d_tag
)
6771 if (entry
->d_un
.d_val
== 0)
6772 printf (_("NONE\n"));
6775 static const char * opts
[] =
6777 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
6778 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
6779 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
6780 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
6786 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
6787 if (entry
->d_un
.d_val
& (1 << cnt
))
6789 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
6796 case DT_MIPS_IVERSION
:
6797 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6798 printf (_("Interface Version: %s\n"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
6800 printf (_("<corrupt: %ld>\n"), (long) entry
->d_un
.d_ptr
);
6803 case DT_MIPS_TIME_STAMP
:
6808 time_t atime
= entry
->d_un
.d_val
;
6809 tmp
= gmtime (&atime
);
6810 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
6811 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6812 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6813 printf (_("Time Stamp: %s\n"), timebuf
);
6817 case DT_MIPS_RLD_VERSION
:
6818 case DT_MIPS_LOCAL_GOTNO
:
6819 case DT_MIPS_CONFLICTNO
:
6820 case DT_MIPS_LIBLISTNO
:
6821 case DT_MIPS_SYMTABNO
:
6822 case DT_MIPS_UNREFEXTNO
:
6823 case DT_MIPS_HIPAGENO
:
6824 case DT_MIPS_DELTA_CLASS_NO
:
6825 case DT_MIPS_DELTA_INSTANCE_NO
:
6826 case DT_MIPS_DELTA_RELOC_NO
:
6827 case DT_MIPS_DELTA_SYM_NO
:
6828 case DT_MIPS_DELTA_CLASSSYM_NO
:
6829 case DT_MIPS_COMPACT_SIZE
:
6830 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
6834 printf ("%#lx\n", (unsigned long) entry
->d_un
.d_ptr
);
6839 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
6841 switch (entry
->d_tag
)
6843 case DT_HP_DLD_FLAGS
:
6852 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
6853 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
6854 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
6855 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
6856 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
6857 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
6858 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
6859 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
6860 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
6861 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
6862 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
6863 { DT_HP_GST
, "HP_GST" },
6864 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
6865 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
6866 { DT_HP_NODELETE
, "HP_NODELETE" },
6867 { DT_HP_GROUP
, "HP_GROUP" },
6868 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
6872 bfd_vma val
= entry
->d_un
.d_val
;
6874 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
6875 if (val
& flags
[cnt
].bit
)
6879 fputs (flags
[cnt
].str
, stdout
);
6881 val
^= flags
[cnt
].bit
;
6884 if (val
!= 0 || first
)
6888 print_vma (val
, HEX
);
6894 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
6902 /* VMS vs Unix time offset and factor. */
6904 #define VMS_EPOCH_OFFSET 35067168000000000LL
6905 #define VMS_GRANULARITY_FACTOR 10000000
6907 /* Display a VMS time in a human readable format. */
6910 print_vms_time (bfd_int64_t vmstime
)
6915 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
6916 tm
= gmtime (&unxtime
);
6917 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
6918 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
6919 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
6924 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
6926 switch (entry
->d_tag
)
6928 case DT_IA_64_PLT_RESERVE
:
6929 /* First 3 slots reserved. */
6930 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
6932 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
6935 case DT_IA_64_VMS_LINKTIME
:
6937 print_vms_time (entry
->d_un
.d_val
);
6941 case DT_IA_64_VMS_LNKFLAGS
:
6942 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
6943 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
6944 printf (" CALL_DEBUG");
6945 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
6946 printf (" NOP0BUFS");
6947 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
6948 printf (" P0IMAGE");
6949 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
6950 printf (" MKTHREADS");
6951 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
6952 printf (" UPCALLS");
6953 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
6955 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
6956 printf (" INITIALIZE");
6957 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
6959 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
6960 printf (" EXE_INIT");
6961 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
6962 printf (" TBK_IN_IMG");
6963 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
6964 printf (" DBG_IN_IMG");
6965 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
6966 printf (" TBK_IN_DSF");
6967 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
6968 printf (" DBG_IN_DSF");
6969 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
6970 printf (" SIGNATURES");
6971 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
6972 printf (" REL_SEG_OFF");
6976 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
6983 get_32bit_dynamic_section (FILE * file
)
6985 Elf32_External_Dyn
* edyn
;
6986 Elf32_External_Dyn
* ext
;
6987 Elf_Internal_Dyn
* entry
;
6989 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
6990 dynamic_size
, _("dynamic section"));
6994 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
6995 might not have the luxury of section headers. Look for the DT_NULL
6996 terminator to determine the number of entries. */
6997 for (ext
= edyn
, dynamic_nent
= 0;
6998 (char *) ext
< (char *) edyn
+ dynamic_size
;
7002 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
7006 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
7008 if (dynamic_section
== NULL
)
7010 error (_("Out of memory\n"));
7015 for (ext
= edyn
, entry
= dynamic_section
;
7016 entry
< dynamic_section
+ dynamic_nent
;
7019 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
7020 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
7029 get_64bit_dynamic_section (FILE * file
)
7031 Elf64_External_Dyn
* edyn
;
7032 Elf64_External_Dyn
* ext
;
7033 Elf_Internal_Dyn
* entry
;
7035 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
7036 dynamic_size
, _("dynamic section"));
7040 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7041 might not have the luxury of section headers. Look for the DT_NULL
7042 terminator to determine the number of entries. */
7043 for (ext
= edyn
, dynamic_nent
= 0;
7044 (char *) ext
< (char *) edyn
+ dynamic_size
;
7048 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
7052 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
7054 if (dynamic_section
== NULL
)
7056 error (_("Out of memory\n"));
7061 for (ext
= edyn
, entry
= dynamic_section
;
7062 entry
< dynamic_section
+ dynamic_nent
;
7065 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
7066 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
7075 print_dynamic_flags (bfd_vma flags
)
7083 flag
= flags
& - flags
;
7093 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
7094 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
7095 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
7096 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
7097 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
7098 default: fputs (_("unknown"), stdout
); break;
7104 /* Parse and display the contents of the dynamic section. */
7107 process_dynamic_section (FILE * file
)
7109 Elf_Internal_Dyn
* entry
;
7111 if (dynamic_size
== 0)
7114 printf (_("\nThere is no dynamic section in this file.\n"));
7121 if (! get_32bit_dynamic_section (file
))
7124 else if (! get_64bit_dynamic_section (file
))
7127 /* Find the appropriate symbol table. */
7128 if (dynamic_symbols
== NULL
)
7130 for (entry
= dynamic_section
;
7131 entry
< dynamic_section
+ dynamic_nent
;
7134 Elf_Internal_Shdr section
;
7136 if (entry
->d_tag
!= DT_SYMTAB
)
7139 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
7141 /* Since we do not know how big the symbol table is,
7142 we default to reading in the entire file (!) and
7143 processing that. This is overkill, I know, but it
7145 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
7147 if (archive_file_offset
!= 0)
7148 section
.sh_size
= archive_file_size
- section
.sh_offset
;
7151 if (fseek (file
, 0, SEEK_END
))
7152 error (_("Unable to seek to end of file!\n"));
7154 section
.sh_size
= ftell (file
) - section
.sh_offset
;
7158 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
7160 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
7162 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
7163 if (num_dynamic_syms
< 1)
7165 error (_("Unable to determine the number of symbols to load\n"));
7169 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
7173 /* Similarly find a string table. */
7174 if (dynamic_strings
== NULL
)
7176 for (entry
= dynamic_section
;
7177 entry
< dynamic_section
+ dynamic_nent
;
7180 unsigned long offset
;
7183 if (entry
->d_tag
!= DT_STRTAB
)
7186 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
7188 /* Since we do not know how big the string table is,
7189 we default to reading in the entire file (!) and
7190 processing that. This is overkill, I know, but it
7193 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
7195 if (archive_file_offset
!= 0)
7196 str_tab_len
= archive_file_size
- offset
;
7199 if (fseek (file
, 0, SEEK_END
))
7200 error (_("Unable to seek to end of file\n"));
7201 str_tab_len
= ftell (file
) - offset
;
7204 if (str_tab_len
< 1)
7207 (_("Unable to determine the length of the dynamic string table\n"));
7211 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
7213 _("dynamic string table"));
7214 dynamic_strings_length
= str_tab_len
;
7219 /* And find the syminfo section if available. */
7220 if (dynamic_syminfo
== NULL
)
7222 unsigned long syminsz
= 0;
7224 for (entry
= dynamic_section
;
7225 entry
< dynamic_section
+ dynamic_nent
;
7228 if (entry
->d_tag
== DT_SYMINENT
)
7230 /* Note: these braces are necessary to avoid a syntax
7231 error from the SunOS4 C compiler. */
7232 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
7234 else if (entry
->d_tag
== DT_SYMINSZ
)
7235 syminsz
= entry
->d_un
.d_val
;
7236 else if (entry
->d_tag
== DT_SYMINFO
)
7237 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
7241 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
7243 Elf_External_Syminfo
* extsyminfo
;
7244 Elf_External_Syminfo
* extsym
;
7245 Elf_Internal_Syminfo
* syminfo
;
7247 /* There is a syminfo section. Read the data. */
7248 extsyminfo
= (Elf_External_Syminfo
*)
7249 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
7250 _("symbol information"));
7254 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
7255 if (dynamic_syminfo
== NULL
)
7257 error (_("Out of memory\n"));
7261 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
7262 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
7263 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
7264 ++syminfo
, ++extsym
)
7266 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
7267 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
7274 if (do_dynamic
&& dynamic_addr
)
7275 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7276 dynamic_addr
, dynamic_nent
);
7278 printf (_(" Tag Type Name/Value\n"));
7280 for (entry
= dynamic_section
;
7281 entry
< dynamic_section
+ dynamic_nent
;
7289 print_vma (entry
->d_tag
, FULL_HEX
);
7290 dtype
= get_dynamic_type (entry
->d_tag
);
7291 printf (" (%s)%*s", dtype
,
7292 ((is_32bit_elf
? 27 : 19)
7293 - (int) strlen (dtype
)),
7297 switch (entry
->d_tag
)
7301 print_dynamic_flags (entry
->d_un
.d_val
);
7311 switch (entry
->d_tag
)
7314 printf (_("Auxiliary library"));
7318 printf (_("Filter library"));
7322 printf (_("Configuration file"));
7326 printf (_("Dependency audit library"));
7330 printf (_("Audit library"));
7334 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7335 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
7339 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7348 printf (_("Flags:"));
7350 if (entry
->d_un
.d_val
== 0)
7351 printf (_(" None\n"));
7354 unsigned long int val
= entry
->d_un
.d_val
;
7356 if (val
& DTF_1_PARINIT
)
7358 printf (" PARINIT");
7359 val
^= DTF_1_PARINIT
;
7361 if (val
& DTF_1_CONFEXP
)
7363 printf (" CONFEXP");
7364 val
^= DTF_1_CONFEXP
;
7367 printf (" %lx", val
);
7376 printf (_("Flags:"));
7378 if (entry
->d_un
.d_val
== 0)
7379 printf (_(" None\n"));
7382 unsigned long int val
= entry
->d_un
.d_val
;
7384 if (val
& DF_P1_LAZYLOAD
)
7386 printf (" LAZYLOAD");
7387 val
^= DF_P1_LAZYLOAD
;
7389 if (val
& DF_P1_GROUPPERM
)
7391 printf (" GROUPPERM");
7392 val
^= DF_P1_GROUPPERM
;
7395 printf (" %lx", val
);
7404 printf (_("Flags:"));
7405 if (entry
->d_un
.d_val
== 0)
7406 printf (_(" None\n"));
7409 unsigned long int val
= entry
->d_un
.d_val
;
7416 if (val
& DF_1_GLOBAL
)
7421 if (val
& DF_1_GROUP
)
7426 if (val
& DF_1_NODELETE
)
7428 printf (" NODELETE");
7429 val
^= DF_1_NODELETE
;
7431 if (val
& DF_1_LOADFLTR
)
7433 printf (" LOADFLTR");
7434 val
^= DF_1_LOADFLTR
;
7436 if (val
& DF_1_INITFIRST
)
7438 printf (" INITFIRST");
7439 val
^= DF_1_INITFIRST
;
7441 if (val
& DF_1_NOOPEN
)
7446 if (val
& DF_1_ORIGIN
)
7451 if (val
& DF_1_DIRECT
)
7456 if (val
& DF_1_TRANS
)
7461 if (val
& DF_1_INTERPOSE
)
7463 printf (" INTERPOSE");
7464 val
^= DF_1_INTERPOSE
;
7466 if (val
& DF_1_NODEFLIB
)
7468 printf (" NODEFLIB");
7469 val
^= DF_1_NODEFLIB
;
7471 if (val
& DF_1_NODUMP
)
7476 if (val
& DF_1_CONLFAT
)
7478 printf (" CONLFAT");
7479 val
^= DF_1_CONLFAT
;
7482 printf (" %lx", val
);
7489 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
7491 puts (get_dynamic_type (entry
->d_un
.d_val
));
7511 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
7517 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7518 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
7524 switch (entry
->d_tag
)
7527 printf (_("Shared library: [%s]"), name
);
7529 if (streq (name
, program_interpreter
))
7530 printf (_(" program interpreter"));
7534 printf (_("Library soname: [%s]"), name
);
7538 printf (_("Library rpath: [%s]"), name
);
7542 printf (_("Library runpath: [%s]"), name
);
7546 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7551 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7564 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
7568 case DT_INIT_ARRAYSZ
:
7569 case DT_FINI_ARRAYSZ
:
7570 case DT_GNU_CONFLICTSZ
:
7571 case DT_GNU_LIBLISTSZ
:
7574 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
7575 printf (_(" (bytes)\n"));
7585 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
7598 if (entry
->d_tag
== DT_USED
7599 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7601 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
7605 printf (_("Not needed object: [%s]\n"), name
);
7610 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7616 /* The value of this entry is ignored. */
7621 case DT_GNU_PRELINKED
:
7625 time_t atime
= entry
->d_un
.d_val
;
7627 tmp
= gmtime (&atime
);
7628 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
7629 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
7630 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
7636 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
7639 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7645 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
7646 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
7651 switch (elf_header
.e_machine
)
7654 case EM_MIPS_RS3_LE
:
7655 dynamic_section_mips_val (entry
);
7658 dynamic_section_parisc_val (entry
);
7661 dynamic_section_ia64_val (entry
);
7664 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7676 get_ver_flags (unsigned int flags
)
7678 static char buff
[32];
7685 if (flags
& VER_FLG_BASE
)
7686 strcat (buff
, "BASE ");
7688 if (flags
& VER_FLG_WEAK
)
7690 if (flags
& VER_FLG_BASE
)
7691 strcat (buff
, "| ");
7693 strcat (buff
, "WEAK ");
7696 if (flags
& VER_FLG_INFO
)
7698 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
7699 strcat (buff
, "| ");
7701 strcat (buff
, "INFO ");
7704 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
7705 strcat (buff
, _("| <unknown>"));
7710 /* Display the contents of the version sections. */
7713 process_version_sections (FILE * file
)
7715 Elf_Internal_Shdr
* section
;
7722 for (i
= 0, section
= section_headers
;
7723 i
< elf_header
.e_shnum
;
7726 switch (section
->sh_type
)
7728 case SHT_GNU_verdef
:
7730 Elf_External_Verdef
* edefs
;
7738 (_("\nVersion definition section '%s' contains %u entries:\n"),
7739 SECTION_NAME (section
), section
->sh_info
);
7741 printf (_(" Addr: 0x"));
7742 printf_vma (section
->sh_addr
);
7743 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
7744 (unsigned long) section
->sh_offset
, section
->sh_link
,
7745 section
->sh_link
< elf_header
.e_shnum
7746 ? SECTION_NAME (section_headers
+ section
->sh_link
)
7749 edefs
= (Elf_External_Verdef
*)
7750 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
7751 _("version definition section"));
7752 endbuf
= (char *) edefs
+ section
->sh_size
;
7756 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
7759 Elf_External_Verdef
* edef
;
7760 Elf_Internal_Verdef ent
;
7761 Elf_External_Verdaux
* eaux
;
7762 Elf_Internal_Verdaux aux
;
7766 vstart
= ((char *) edefs
) + idx
;
7767 if (vstart
+ sizeof (*edef
) > endbuf
)
7770 edef
= (Elf_External_Verdef
*) vstart
;
7772 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
7773 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
7774 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
7775 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
7776 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
7777 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
7778 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
7780 printf (_(" %#06x: Rev: %d Flags: %s"),
7781 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
7783 printf (_(" Index: %d Cnt: %d "),
7784 ent
.vd_ndx
, ent
.vd_cnt
);
7786 vstart
+= ent
.vd_aux
;
7788 eaux
= (Elf_External_Verdaux
*) vstart
;
7790 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
7791 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
7793 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
7794 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
7796 printf (_("Name index: %ld\n"), aux
.vda_name
);
7798 isum
= idx
+ ent
.vd_aux
;
7800 for (j
= 1; j
< ent
.vd_cnt
; j
++)
7802 isum
+= aux
.vda_next
;
7803 vstart
+= aux
.vda_next
;
7805 eaux
= (Elf_External_Verdaux
*) vstart
;
7806 if (vstart
+ sizeof (*eaux
) > endbuf
)
7809 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
7810 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
7812 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
7813 printf (_(" %#06x: Parent %d: %s\n"),
7814 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
7816 printf (_(" %#06x: Parent %d, name index: %ld\n"),
7817 isum
, j
, aux
.vda_name
);
7820 printf (_(" Version def aux past end of section\n"));
7824 if (cnt
< section
->sh_info
)
7825 printf (_(" Version definition past end of section\n"));
7831 case SHT_GNU_verneed
:
7833 Elf_External_Verneed
* eneed
;
7840 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
7841 SECTION_NAME (section
), section
->sh_info
);
7843 printf (_(" Addr: 0x"));
7844 printf_vma (section
->sh_addr
);
7845 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
7846 (unsigned long) section
->sh_offset
, section
->sh_link
,
7847 section
->sh_link
< elf_header
.e_shnum
7848 ? SECTION_NAME (section_headers
+ section
->sh_link
)
7851 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
7852 section
->sh_offset
, 1,
7854 _("version need section"));
7855 endbuf
= (char *) eneed
+ section
->sh_size
;
7859 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
7861 Elf_External_Verneed
* entry
;
7862 Elf_Internal_Verneed ent
;
7867 vstart
= ((char *) eneed
) + idx
;
7868 if (vstart
+ sizeof (*entry
) > endbuf
)
7871 entry
= (Elf_External_Verneed
*) vstart
;
7873 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
7874 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
7875 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
7876 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
7877 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
7879 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
7881 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
7882 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
7884 printf (_(" File: %lx"), ent
.vn_file
);
7886 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
7888 vstart
+= ent
.vn_aux
;
7890 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
7892 Elf_External_Vernaux
* eaux
;
7893 Elf_Internal_Vernaux aux
;
7895 if (vstart
+ sizeof (*eaux
) > endbuf
)
7897 eaux
= (Elf_External_Vernaux
*) vstart
;
7899 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
7900 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
7901 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
7902 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
7903 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
7905 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
7906 printf (_(" %#06x: Name: %s"),
7907 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
7909 printf (_(" %#06x: Name index: %lx"),
7910 isum
, aux
.vna_name
);
7912 printf (_(" Flags: %s Version: %d\n"),
7913 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
7915 isum
+= aux
.vna_next
;
7916 vstart
+= aux
.vna_next
;
7919 printf (_(" Version need aux past end of section\n"));
7923 if (cnt
< section
->sh_info
)
7924 printf (_(" Version need past end of section\n"));
7930 case SHT_GNU_versym
:
7932 Elf_Internal_Shdr
* link_section
;
7935 unsigned char * edata
;
7936 unsigned short * data
;
7938 Elf_Internal_Sym
* symbols
;
7939 Elf_Internal_Shdr
* string_sec
;
7942 if (section
->sh_link
>= elf_header
.e_shnum
)
7945 link_section
= section_headers
+ section
->sh_link
;
7946 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
7948 if (link_section
->sh_link
>= elf_header
.e_shnum
)
7953 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
7955 string_sec
= section_headers
+ link_section
->sh_link
;
7957 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
7958 string_sec
->sh_size
,
7959 _("version string table"));
7963 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
7964 SECTION_NAME (section
), total
);
7966 printf (_(" Addr: "));
7967 printf_vma (section
->sh_addr
);
7968 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
7969 (unsigned long) section
->sh_offset
, section
->sh_link
,
7970 SECTION_NAME (link_section
));
7972 off
= offset_from_vma (file
,
7973 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7974 total
* sizeof (short));
7975 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
7977 _("version symbol data"));
7984 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
7986 for (cnt
= total
; cnt
--;)
7987 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
7992 for (cnt
= 0; cnt
< total
; cnt
+= 4)
7995 int check_def
, check_need
;
7998 printf (" %03x:", cnt
);
8000 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
8001 switch (data
[cnt
+ j
])
8004 fputs (_(" 0 (*local*) "), stdout
);
8008 fputs (_(" 1 (*global*) "), stdout
);
8012 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
8013 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
8017 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
8018 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
8021 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
8028 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
8030 Elf_Internal_Verneed ivn
;
8031 unsigned long offset
;
8033 offset
= offset_from_vma
8034 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
8035 sizeof (Elf_External_Verneed
));
8039 Elf_Internal_Vernaux ivna
;
8040 Elf_External_Verneed evn
;
8041 Elf_External_Vernaux evna
;
8042 unsigned long a_off
;
8044 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
8047 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
8048 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
8050 a_off
= offset
+ ivn
.vn_aux
;
8054 get_data (&evna
, file
, a_off
, sizeof (evna
),
8055 1, _("version need aux (2)"));
8057 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
8058 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
8060 a_off
+= ivna
.vna_next
;
8062 while (ivna
.vna_other
!= data
[cnt
+ j
]
8063 && ivna
.vna_next
!= 0);
8065 if (ivna
.vna_other
== data
[cnt
+ j
])
8067 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
8069 if (ivna
.vna_name
>= string_sec
->sh_size
)
8070 name
= _("*invalid*");
8072 name
= strtab
+ ivna
.vna_name
;
8073 nn
+= printf ("(%s%-*s",
8075 12 - (int) strlen (name
),
8081 offset
+= ivn
.vn_next
;
8083 while (ivn
.vn_next
);
8086 if (check_def
&& data
[cnt
+ j
] != 0x8001
8087 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
8089 Elf_Internal_Verdef ivd
;
8090 Elf_External_Verdef evd
;
8091 unsigned long offset
;
8093 offset
= offset_from_vma
8094 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
8099 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
8102 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
8103 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
8105 offset
+= ivd
.vd_next
;
8107 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
8108 && ivd
.vd_next
!= 0);
8110 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
8112 Elf_External_Verdaux evda
;
8113 Elf_Internal_Verdaux ivda
;
8115 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
8117 get_data (&evda
, file
,
8118 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
8120 _("version def aux"));
8122 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
8124 if (ivda
.vda_name
>= string_sec
->sh_size
)
8125 name
= _("*invalid*");
8127 name
= strtab
+ ivda
.vda_name
;
8128 nn
+= printf ("(%s%-*s",
8130 12 - (int) strlen (name
),
8136 printf ("%*c", 18 - nn
, ' ');
8154 printf (_("\nNo version information found in this file.\n"));
8160 get_symbol_binding (unsigned int binding
)
8162 static char buff
[32];
8166 case STB_LOCAL
: return "LOCAL";
8167 case STB_GLOBAL
: return "GLOBAL";
8168 case STB_WEAK
: return "WEAK";
8170 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
8171 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
8173 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
8175 if (binding
== STB_GNU_UNIQUE
8176 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
8177 /* GNU/Linux is still using the default value 0. */
8178 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
8180 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
8183 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
8189 get_symbol_type (unsigned int type
)
8191 static char buff
[32];
8195 case STT_NOTYPE
: return "NOTYPE";
8196 case STT_OBJECT
: return "OBJECT";
8197 case STT_FUNC
: return "FUNC";
8198 case STT_SECTION
: return "SECTION";
8199 case STT_FILE
: return "FILE";
8200 case STT_COMMON
: return "COMMON";
8201 case STT_TLS
: return "TLS";
8202 case STT_RELC
: return "RELC";
8203 case STT_SRELC
: return "SRELC";
8205 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
8207 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
8208 return "THUMB_FUNC";
8210 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
8213 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
8214 return "PARISC_MILLI";
8216 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
8218 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
8220 if (elf_header
.e_machine
== EM_PARISC
)
8222 if (type
== STT_HP_OPAQUE
)
8224 if (type
== STT_HP_STUB
)
8228 if (type
== STT_GNU_IFUNC
8229 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
8230 /* GNU/Linux is still using the default value 0. */
8231 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
8234 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
8237 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
8243 get_symbol_visibility (unsigned int visibility
)
8247 case STV_DEFAULT
: return "DEFAULT";
8248 case STV_INTERNAL
: return "INTERNAL";
8249 case STV_HIDDEN
: return "HIDDEN";
8250 case STV_PROTECTED
: return "PROTECTED";
8256 get_mips_symbol_other (unsigned int other
)
8260 case STO_OPTIONAL
: return "OPTIONAL";
8261 case STO_MIPS16
: return "MIPS16";
8262 case STO_MIPS_PLT
: return "MIPS PLT";
8263 case STO_MIPS_PIC
: return "MIPS PIC";
8264 default: return NULL
;
8269 get_ia64_symbol_other (unsigned int other
)
8273 static char res
[32];
8277 /* Function types is for images and .STB files only. */
8278 switch (elf_header
.e_type
)
8282 switch (VMS_ST_FUNC_TYPE (other
))
8284 case VMS_SFT_CODE_ADDR
:
8285 strcat (res
, " CA");
8287 case VMS_SFT_SYMV_IDX
:
8288 strcat (res
, " VEC");
8291 strcat (res
, " FD");
8293 case VMS_SFT_RESERVE
:
8294 strcat (res
, " RSV");
8303 switch (VMS_ST_LINKAGE (other
))
8305 case VMS_STL_IGNORE
:
8306 strcat (res
, " IGN");
8308 case VMS_STL_RESERVE
:
8309 strcat (res
, " RSV");
8312 strcat (res
, " STD");
8315 strcat (res
, " LNK");
8330 get_symbol_other (unsigned int other
)
8332 const char * result
= NULL
;
8333 static char buff
[32];
8338 switch (elf_header
.e_machine
)
8341 result
= get_mips_symbol_other (other
);
8344 result
= get_ia64_symbol_other (other
);
8353 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
8358 get_symbol_index_type (unsigned int type
)
8360 static char buff
[32];
8364 case SHN_UNDEF
: return "UND";
8365 case SHN_ABS
: return "ABS";
8366 case SHN_COMMON
: return "COM";
8368 if (type
== SHN_IA_64_ANSI_COMMON
8369 && elf_header
.e_machine
== EM_IA_64
8370 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
8372 else if ((elf_header
.e_machine
== EM_X86_64
8373 || elf_header
.e_machine
== EM_L1OM
)
8374 && type
== SHN_X86_64_LCOMMON
)
8376 else if (type
== SHN_MIPS_SCOMMON
8377 && elf_header
.e_machine
== EM_MIPS
)
8379 else if (type
== SHN_MIPS_SUNDEFINED
8380 && elf_header
.e_machine
== EM_MIPS
)
8382 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
8383 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
8384 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
8385 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
8386 else if (type
>= SHN_LORESERVE
)
8387 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
8389 sprintf (buff
, "%3d", type
);
8397 get_dynamic_data (FILE * file
, unsigned int number
, unsigned int ent_size
)
8399 unsigned char * e_data
;
8402 e_data
= (unsigned char *) cmalloc (number
, ent_size
);
8406 error (_("Out of memory\n"));
8410 if (fread (e_data
, ent_size
, number
, file
) != number
)
8412 error (_("Unable to read in dynamic data\n"));
8416 i_data
= (bfd_vma
*) cmalloc (number
, sizeof (*i_data
));
8420 error (_("Out of memory\n"));
8426 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
8434 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
8436 Elf_Internal_Sym
* psym
;
8439 psym
= dynamic_symbols
+ si
;
8441 n
= print_vma (si
, DEC_5
);
8443 fputs (" " + n
, stdout
);
8444 printf (" %3lu: ", hn
);
8445 print_vma (psym
->st_value
, LONG_HEX
);
8447 print_vma (psym
->st_size
, DEC_5
);
8449 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
8450 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
8451 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
8452 /* Check to see if any other bits in the st_other field are set.
8453 Note - displaying this information disrupts the layout of the
8454 table being generated, but for the moment this case is very
8456 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
8457 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
8458 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
8459 if (VALID_DYNAMIC_NAME (psym
->st_name
))
8460 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
8462 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
8466 /* Dump the symbol table. */
8468 process_symbol_table (FILE * file
)
8470 Elf_Internal_Shdr
* section
;
8471 bfd_vma nbuckets
= 0;
8472 bfd_vma nchains
= 0;
8473 bfd_vma
* buckets
= NULL
;
8474 bfd_vma
* chains
= NULL
;
8475 bfd_vma ngnubuckets
= 0;
8476 bfd_vma
* gnubuckets
= NULL
;
8477 bfd_vma
* gnuchains
= NULL
;
8478 bfd_vma gnusymidx
= 0;
8480 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
8483 if (dynamic_info
[DT_HASH
]
8485 || (do_using_dynamic
8487 && dynamic_strings
!= NULL
)))
8489 unsigned char nb
[8];
8490 unsigned char nc
[8];
8491 int hash_ent_size
= 4;
8493 if ((elf_header
.e_machine
== EM_ALPHA
8494 || elf_header
.e_machine
== EM_S390
8495 || elf_header
.e_machine
== EM_S390_OLD
)
8496 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
8500 (archive_file_offset
8501 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
8502 sizeof nb
+ sizeof nc
)),
8505 error (_("Unable to seek to start of dynamic information\n"));
8509 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
8511 error (_("Failed to read in number of buckets\n"));
8515 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
8517 error (_("Failed to read in number of chains\n"));
8521 nbuckets
= byte_get (nb
, hash_ent_size
);
8522 nchains
= byte_get (nc
, hash_ent_size
);
8524 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
8525 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
8528 if (buckets
== NULL
|| chains
== NULL
)
8530 if (do_using_dynamic
)
8541 if (dynamic_info_DT_GNU_HASH
8543 || (do_using_dynamic
8545 && dynamic_strings
!= NULL
)))
8547 unsigned char nb
[16];
8548 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
8549 bfd_vma buckets_vma
;
8552 (archive_file_offset
8553 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
8557 error (_("Unable to seek to start of dynamic information\n"));
8561 if (fread (nb
, 16, 1, file
) != 1)
8563 error (_("Failed to read in number of buckets\n"));
8567 ngnubuckets
= byte_get (nb
, 4);
8568 gnusymidx
= byte_get (nb
+ 4, 4);
8569 bitmaskwords
= byte_get (nb
+ 8, 4);
8570 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
8572 buckets_vma
+= bitmaskwords
* 4;
8574 buckets_vma
+= bitmaskwords
* 8;
8577 (archive_file_offset
8578 + offset_from_vma (file
, buckets_vma
, 4)),
8581 error (_("Unable to seek to start of dynamic information\n"));
8585 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
8587 if (gnubuckets
== NULL
)
8590 for (i
= 0; i
< ngnubuckets
; i
++)
8591 if (gnubuckets
[i
] != 0)
8593 if (gnubuckets
[i
] < gnusymidx
)
8596 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
8597 maxchain
= gnubuckets
[i
];
8600 if (maxchain
== 0xffffffff)
8603 maxchain
-= gnusymidx
;
8606 (archive_file_offset
8607 + offset_from_vma (file
, buckets_vma
8608 + 4 * (ngnubuckets
+ maxchain
), 4)),
8611 error (_("Unable to seek to start of dynamic information\n"));
8617 if (fread (nb
, 4, 1, file
) != 1)
8619 error (_("Failed to determine last chain length\n"));
8623 if (maxchain
+ 1 == 0)
8628 while ((byte_get (nb
, 4) & 1) == 0);
8631 (archive_file_offset
8632 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
8635 error (_("Unable to seek to start of dynamic information\n"));
8639 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
8642 if (gnuchains
== NULL
)
8647 if (do_using_dynamic
)
8652 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
8655 && dynamic_strings
!= NULL
)
8659 if (dynamic_info
[DT_HASH
])
8663 printf (_("\nSymbol table for image:\n"));
8665 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8667 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8669 for (hn
= 0; hn
< nbuckets
; hn
++)
8674 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
8675 print_dynamic_symbol (si
, hn
);
8679 if (dynamic_info_DT_GNU_HASH
)
8681 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
8683 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8685 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8687 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
8688 if (gnubuckets
[hn
] != 0)
8690 bfd_vma si
= gnubuckets
[hn
];
8691 bfd_vma off
= si
- gnusymidx
;
8695 print_dynamic_symbol (si
, hn
);
8698 while ((gnuchains
[off
++] & 1) == 0);
8702 else if (do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
8706 for (i
= 0, section
= section_headers
;
8707 i
< elf_header
.e_shnum
;
8711 char * strtab
= NULL
;
8712 unsigned long int strtab_size
= 0;
8713 Elf_Internal_Sym
* symtab
;
8714 Elf_Internal_Sym
* psym
;
8716 if ((section
->sh_type
!= SHT_SYMTAB
8717 && section
->sh_type
!= SHT_DYNSYM
)
8719 && section
->sh_type
== SHT_SYMTAB
))
8722 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
8723 SECTION_NAME (section
),
8724 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
8726 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
8728 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
8730 symtab
= GET_ELF_SYMBOLS (file
, section
);
8734 if (section
->sh_link
== elf_header
.e_shstrndx
)
8736 strtab
= string_table
;
8737 strtab_size
= string_table_length
;
8739 else if (section
->sh_link
< elf_header
.e_shnum
)
8741 Elf_Internal_Shdr
* string_sec
;
8743 string_sec
= section_headers
+ section
->sh_link
;
8745 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
8746 1, string_sec
->sh_size
,
8748 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
8751 for (si
= 0, psym
= symtab
;
8752 si
< section
->sh_size
/ section
->sh_entsize
;
8755 printf ("%6d: ", si
);
8756 print_vma (psym
->st_value
, LONG_HEX
);
8758 print_vma (psym
->st_size
, DEC_5
);
8759 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
8760 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
8761 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
8762 /* Check to see if any other bits in the st_other field are set.
8763 Note - displaying this information disrupts the layout of the
8764 table being generated, but for the moment this case is very rare. */
8765 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
8766 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
8767 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
8768 print_symbol (25, psym
->st_name
< strtab_size
8769 ? strtab
+ psym
->st_name
: _("<corrupt>"));
8771 if (section
->sh_type
== SHT_DYNSYM
&&
8772 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
8774 unsigned char data
[2];
8775 unsigned short vers_data
;
8776 unsigned long offset
;
8780 offset
= offset_from_vma
8781 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
8782 sizeof data
+ si
* sizeof (vers_data
));
8784 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
8785 sizeof (data
), 1, _("version data"));
8787 vers_data
= byte_get (data
, 2);
8789 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
8790 && section_headers
[psym
->st_shndx
].sh_type
8793 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
8795 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
8797 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
8798 && (is_nobits
|| ! check_def
))
8800 Elf_External_Verneed evn
;
8801 Elf_Internal_Verneed ivn
;
8802 Elf_Internal_Vernaux ivna
;
8804 /* We must test both. */
8805 offset
= offset_from_vma
8806 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
8811 unsigned long vna_off
;
8813 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
8816 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
8817 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
8819 vna_off
= offset
+ ivn
.vn_aux
;
8823 Elf_External_Vernaux evna
;
8825 get_data (&evna
, file
, vna_off
,
8827 _("version need aux (3)"));
8829 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
8830 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
8831 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
8833 vna_off
+= ivna
.vna_next
;
8835 while (ivna
.vna_other
!= vers_data
8836 && ivna
.vna_next
!= 0);
8838 if (ivna
.vna_other
== vers_data
)
8841 offset
+= ivn
.vn_next
;
8843 while (ivn
.vn_next
!= 0);
8845 if (ivna
.vna_other
== vers_data
)
8848 ivna
.vna_name
< strtab_size
8849 ? strtab
+ ivna
.vna_name
: _("<corrupt>"),
8853 else if (! is_nobits
)
8854 error (_("bad dynamic symbol\n"));
8861 if (vers_data
!= 0x8001
8862 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
8864 Elf_Internal_Verdef ivd
;
8865 Elf_Internal_Verdaux ivda
;
8866 Elf_External_Verdaux evda
;
8869 off
= offset_from_vma
8871 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
8872 sizeof (Elf_External_Verdef
));
8876 Elf_External_Verdef evd
;
8878 get_data (&evd
, file
, off
, sizeof (evd
),
8879 1, _("version def"));
8881 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
8882 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
8883 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
8887 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
8888 && ivd
.vd_next
!= 0);
8893 get_data (&evda
, file
, off
, sizeof (evda
),
8894 1, _("version def aux"));
8896 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
8898 if (psym
->st_name
!= ivda
.vda_name
)
8899 printf ((vers_data
& VERSYM_HIDDEN
)
8901 ivda
.vda_name
< strtab_size
8902 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
8912 if (strtab
!= string_table
)
8918 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
8920 if (do_histogram
&& buckets
!= NULL
)
8922 unsigned long * lengths
;
8923 unsigned long * counts
;
8926 unsigned long maxlength
= 0;
8927 unsigned long nzero_counts
= 0;
8928 unsigned long nsyms
= 0;
8930 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
8931 (unsigned long) nbuckets
);
8932 printf (_(" Length Number %% of total Coverage\n"));
8934 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
8935 if (lengths
== NULL
)
8937 error (_("Out of memory\n"));
8940 for (hn
= 0; hn
< nbuckets
; ++hn
)
8942 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
8945 if (maxlength
< ++lengths
[hn
])
8950 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
8953 error (_("Out of memory\n"));
8957 for (hn
= 0; hn
< nbuckets
; ++hn
)
8958 ++counts
[lengths
[hn
]];
8963 printf (" 0 %-10lu (%5.1f%%)\n",
8964 counts
[0], (counts
[0] * 100.0) / nbuckets
);
8965 for (i
= 1; i
<= maxlength
; ++i
)
8967 nzero_counts
+= counts
[i
] * i
;
8968 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
8969 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
8970 (nzero_counts
* 100.0) / nsyms
);
8978 if (buckets
!= NULL
)
8984 if (do_histogram
&& gnubuckets
!= NULL
)
8986 unsigned long * lengths
;
8987 unsigned long * counts
;
8989 unsigned long maxlength
= 0;
8990 unsigned long nzero_counts
= 0;
8991 unsigned long nsyms
= 0;
8993 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
8994 if (lengths
== NULL
)
8996 error (_("Out of memory\n"));
9000 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9001 (unsigned long) ngnubuckets
);
9002 printf (_(" Length Number %% of total Coverage\n"));
9004 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9005 if (gnubuckets
[hn
] != 0)
9007 bfd_vma off
, length
= 1;
9009 for (off
= gnubuckets
[hn
] - gnusymidx
;
9010 (gnuchains
[off
] & 1) == 0; ++off
)
9012 lengths
[hn
] = length
;
9013 if (length
> maxlength
)
9018 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
9021 error (_("Out of memory\n"));
9025 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9026 ++counts
[lengths
[hn
]];
9028 if (ngnubuckets
> 0)
9031 printf (" 0 %-10lu (%5.1f%%)\n",
9032 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
9033 for (j
= 1; j
<= maxlength
; ++j
)
9035 nzero_counts
+= counts
[j
] * j
;
9036 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9037 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
9038 (nzero_counts
* 100.0) / nsyms
);
9052 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
9056 if (dynamic_syminfo
== NULL
9058 /* No syminfo, this is ok. */
9061 /* There better should be a dynamic symbol section. */
9062 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
9066 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9067 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
9069 printf (_(" Num: Name BoundTo Flags\n"));
9070 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
9072 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
9074 printf ("%4d: ", i
);
9075 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
9076 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
9078 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
9081 switch (dynamic_syminfo
[i
].si_boundto
)
9083 case SYMINFO_BT_SELF
:
9084 fputs ("SELF ", stdout
);
9086 case SYMINFO_BT_PARENT
:
9087 fputs ("PARENT ", stdout
);
9090 if (dynamic_syminfo
[i
].si_boundto
> 0
9091 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
9092 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
9094 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
9098 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
9102 if (flags
& SYMINFO_FLG_DIRECT
)
9104 if (flags
& SYMINFO_FLG_PASSTHRU
)
9105 printf (" PASSTHRU");
9106 if (flags
& SYMINFO_FLG_COPY
)
9108 if (flags
& SYMINFO_FLG_LAZYLOAD
)
9109 printf (" LAZYLOAD");
9117 /* Check to see if the given reloc needs to be handled in a target specific
9118 manner. If so then process the reloc and return TRUE otherwise return
9122 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
9123 unsigned char * start
,
9124 Elf_Internal_Sym
* symtab
)
9126 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
9128 switch (elf_header
.e_machine
)
9131 case EM_CYGNUS_MN10300
:
9133 static Elf_Internal_Sym
* saved_sym
= NULL
;
9137 case 34: /* R_MN10300_ALIGN */
9139 case 33: /* R_MN10300_SYM_DIFF */
9140 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
9142 case 1: /* R_MN10300_32 */
9143 case 2: /* R_MN10300_16 */
9144 if (saved_sym
!= NULL
)
9148 value
= reloc
->r_addend
9149 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
9150 - saved_sym
->st_value
);
9152 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
9159 if (saved_sym
!= NULL
)
9160 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9170 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9171 DWARF debug sections. This is a target specific test. Note - we do not
9172 go through the whole including-target-headers-multiple-times route, (as
9173 we have already done with <elf/h8.h>) because this would become very
9174 messy and even then this function would have to contain target specific
9175 information (the names of the relocs instead of their numeric values).
9176 FIXME: This is not the correct way to solve this problem. The proper way
9177 is to have target specific reloc sizing and typing functions created by
9178 the reloc-macros.h header, in the same way that it already creates the
9179 reloc naming functions. */
9182 is_32bit_abs_reloc (unsigned int reloc_type
)
9184 switch (elf_header
.e_machine
)
9188 return reloc_type
== 1; /* R_386_32. */
9190 return reloc_type
== 1; /* R_68K_32. */
9192 return reloc_type
== 1; /* R_860_32. */
9194 return reloc_type
== 1; /* XXX Is this right ? */
9196 return reloc_type
== 1; /* R_ARC_32. */
9198 return reloc_type
== 2; /* R_ARM_ABS32 */
9201 return reloc_type
== 1;
9203 return reloc_type
== 0x12; /* R_byte4_data. */
9205 return reloc_type
== 3; /* R_CRIS_32. */
9208 return reloc_type
== 3; /* R_CR16_NUM32. */
9210 return reloc_type
== 15; /* R_CRX_NUM32. */
9212 return reloc_type
== 1;
9213 case EM_CYGNUS_D10V
:
9215 return reloc_type
== 6; /* R_D10V_32. */
9216 case EM_CYGNUS_D30V
:
9218 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
9220 return reloc_type
== 3; /* R_DLX_RELOC_32. */
9221 case EM_CYGNUS_FR30
:
9223 return reloc_type
== 3; /* R_FR30_32. */
9227 return reloc_type
== 1; /* R_H8_DIR32. */
9229 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
9232 return reloc_type
== 2; /* R_IP2K_32. */
9234 return reloc_type
== 2; /* R_IQ2000_32. */
9235 case EM_LATTICEMICO32
:
9236 return reloc_type
== 3; /* R_LM32_32. */
9239 return reloc_type
== 3; /* R_M32C_32. */
9241 return reloc_type
== 34; /* R_M32R_32_RELA. */
9243 return reloc_type
== 1; /* R_MCORE_ADDR32. */
9245 return reloc_type
== 4; /* R_MEP_32. */
9247 return reloc_type
== 2; /* R_MIPS_32. */
9249 return reloc_type
== 4; /* R_MMIX_32. */
9250 case EM_CYGNUS_MN10200
:
9252 return reloc_type
== 1; /* R_MN10200_32. */
9253 case EM_CYGNUS_MN10300
:
9255 return reloc_type
== 1; /* R_MN10300_32. */
9257 return reloc_type
== 1; /* R_MOXIE_32. */
9260 return reloc_type
== 1; /* R_MSP43_32. */
9262 return reloc_type
== 2; /* R_MT_32. */
9263 case EM_ALTERA_NIOS2
:
9265 return reloc_type
== 1; /* R_NIOS_32. */
9268 return reloc_type
== 1; /* R_OR32_32. */
9270 return (reloc_type
== 1 /* R_PARISC_DIR32. */
9271 || reloc_type
== 41); /* R_PARISC_SECREL32. */
9274 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
9276 return reloc_type
== 1; /* R_PPC64_ADDR32. */
9278 return reloc_type
== 1; /* R_PPC_ADDR32. */
9280 return reloc_type
== 1; /* R_RX_DIR32. */
9282 return reloc_type
== 1; /* R_I370_ADDR31. */
9285 return reloc_type
== 4; /* R_S390_32. */
9287 return reloc_type
== 8; /* R_SCORE_ABS32. */
9289 return reloc_type
== 1; /* R_SH_DIR32. */
9290 case EM_SPARC32PLUS
:
9293 return reloc_type
== 3 /* R_SPARC_32. */
9294 || reloc_type
== 23; /* R_SPARC_UA32. */
9296 return reloc_type
== 6; /* R_SPU_ADDR32 */
9298 return reloc_type
== 1; /* R_C6000_ABS32. */
9299 case EM_CYGNUS_V850
:
9301 return reloc_type
== 6; /* R_V850_ABS32. */
9303 return reloc_type
== 1; /* R_VAX_32. */
9306 return reloc_type
== 10; /* R_X86_64_32. */
9309 return reloc_type
== 3; /* R_XC16C_ABS_32. */
9311 return reloc_type
== 1; /* R_XSTROMY16_32. */
9314 return reloc_type
== 1; /* R_XTENSA_32. */
9316 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
9317 elf_header
.e_machine
);
9322 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9323 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
9326 is_32bit_pcrel_reloc (unsigned int reloc_type
)
9328 switch (elf_header
.e_machine
)
9332 return reloc_type
== 2; /* R_386_PC32. */
9334 return reloc_type
== 4; /* R_68K_PC32. */
9336 return reloc_type
== 10; /* R_ALPHA_SREL32. */
9338 return reloc_type
== 3; /* R_ARM_REL32 */
9340 return reloc_type
== 9; /* R_PARISC_PCREL32. */
9342 return reloc_type
== 26; /* R_PPC_REL32. */
9344 return reloc_type
== 26; /* R_PPC64_REL32. */
9347 return reloc_type
== 5; /* R_390_PC32. */
9349 return reloc_type
== 2; /* R_SH_REL32. */
9350 case EM_SPARC32PLUS
:
9353 return reloc_type
== 6; /* R_SPARC_DISP32. */
9355 return reloc_type
== 13; /* R_SPU_REL32. */
9358 return reloc_type
== 2; /* R_X86_64_PC32. */
9361 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
9363 /* Do not abort or issue an error message here. Not all targets use
9364 pc-relative 32-bit relocs in their DWARF debug information and we
9365 have already tested for target coverage in is_32bit_abs_reloc. A
9366 more helpful warning message will be generated by apply_relocations
9367 anyway, so just return. */
9372 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9373 a 64-bit absolute RELA relocation used in DWARF debug sections. */
9376 is_64bit_abs_reloc (unsigned int reloc_type
)
9378 switch (elf_header
.e_machine
)
9381 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
9383 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
9385 return reloc_type
== 80; /* R_PARISC_DIR64. */
9387 return reloc_type
== 38; /* R_PPC64_ADDR64. */
9388 case EM_SPARC32PLUS
:
9391 return reloc_type
== 54; /* R_SPARC_UA64. */
9394 return reloc_type
== 1; /* R_X86_64_64. */
9397 return reloc_type
== 22; /* R_S390_64 */
9399 return reloc_type
== 18; /* R_MIPS_64 */
9405 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
9406 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
9409 is_64bit_pcrel_reloc (unsigned int reloc_type
)
9411 switch (elf_header
.e_machine
)
9414 return reloc_type
== 11; /* R_ALPHA_SREL64 */
9416 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB */
9418 return reloc_type
== 72; /* R_PARISC_PCREL64 */
9420 return reloc_type
== 44; /* R_PPC64_REL64 */
9421 case EM_SPARC32PLUS
:
9424 return reloc_type
== 46; /* R_SPARC_DISP64 */
9427 return reloc_type
== 24; /* R_X86_64_PC64 */
9430 return reloc_type
== 23; /* R_S390_PC64 */
9436 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9437 a 24-bit absolute RELA relocation used in DWARF debug sections. */
9440 is_24bit_abs_reloc (unsigned int reloc_type
)
9442 switch (elf_header
.e_machine
)
9444 case EM_CYGNUS_MN10200
:
9446 return reloc_type
== 4; /* R_MN10200_24. */
9452 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9453 a 16-bit absolute RELA relocation used in DWARF debug sections. */
9456 is_16bit_abs_reloc (unsigned int reloc_type
)
9458 switch (elf_header
.e_machine
)
9462 return reloc_type
== 4; /* R_AVR_16. */
9463 case EM_CYGNUS_D10V
:
9465 return reloc_type
== 3; /* R_D10V_16. */
9469 return reloc_type
== R_H8_DIR16
;
9472 return reloc_type
== 1; /* R_IP2K_16. */
9475 return reloc_type
== 1; /* R_M32C_16 */
9478 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
9479 case EM_ALTERA_NIOS2
:
9481 return reloc_type
== 9; /* R_NIOS_16. */
9483 return reloc_type
== 2; /* R_C6000_ABS16. */
9486 return reloc_type
== 2; /* R_XC16C_ABS_16. */
9492 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
9493 relocation entries (possibly formerly used for SHT_GROUP sections). */
9496 is_none_reloc (unsigned int reloc_type
)
9498 switch (elf_header
.e_machine
)
9500 case EM_68K
: /* R_68K_NONE. */
9501 case EM_386
: /* R_386_NONE. */
9502 case EM_SPARC32PLUS
:
9504 case EM_SPARC
: /* R_SPARC_NONE. */
9505 case EM_MIPS
: /* R_MIPS_NONE. */
9506 case EM_PARISC
: /* R_PARISC_NONE. */
9507 case EM_ALPHA
: /* R_ALPHA_NONE. */
9508 case EM_PPC
: /* R_PPC_NONE. */
9509 case EM_PPC64
: /* R_PPC64_NONE. */
9510 case EM_ARM
: /* R_ARM_NONE. */
9511 case EM_IA_64
: /* R_IA64_NONE. */
9512 case EM_SH
: /* R_SH_NONE. */
9514 case EM_S390
: /* R_390_NONE. */
9515 case EM_CRIS
: /* R_CRIS_NONE. */
9516 case EM_X86_64
: /* R_X86_64_NONE. */
9517 case EM_L1OM
: /* R_X86_64_NONE. */
9518 case EM_MN10300
: /* R_MN10300_NONE. */
9519 case EM_MOXIE
: /* R_MOXIE_NONE. */
9520 case EM_M32R
: /* R_M32R_NONE. */
9521 case EM_TI_C6000
:/* R_C6000_NONE. */
9523 case EM_C166
: /* R_XC16X_NONE. */
9524 return reloc_type
== 0;
9527 return (reloc_type
== 0 /* R_XTENSA_NONE. */
9528 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
9529 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
9530 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
9535 /* Apply relocations to a section.
9536 Note: So far support has been added only for those relocations
9537 which can be found in debug sections.
9538 FIXME: Add support for more relocations ? */
9541 apply_relocations (void * file
,
9542 Elf_Internal_Shdr
* section
,
9543 unsigned char * start
)
9545 Elf_Internal_Shdr
* relsec
;
9546 unsigned char * end
= start
+ section
->sh_size
;
9548 if (elf_header
.e_type
!= ET_REL
)
9551 /* Find the reloc section associated with the section. */
9552 for (relsec
= section_headers
;
9553 relsec
< section_headers
+ elf_header
.e_shnum
;
9556 bfd_boolean is_rela
;
9557 unsigned long num_relocs
;
9558 Elf_Internal_Rela
* relocs
;
9559 Elf_Internal_Rela
* rp
;
9560 Elf_Internal_Shdr
* symsec
;
9561 Elf_Internal_Sym
* symtab
;
9562 Elf_Internal_Sym
* sym
;
9564 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
9565 || relsec
->sh_info
>= elf_header
.e_shnum
9566 || section_headers
+ relsec
->sh_info
!= section
9567 || relsec
->sh_size
== 0
9568 || relsec
->sh_link
>= elf_header
.e_shnum
)
9571 is_rela
= relsec
->sh_type
== SHT_RELA
;
9575 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
9576 relsec
->sh_size
, & relocs
, & num_relocs
))
9581 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
9582 relsec
->sh_size
, & relocs
, & num_relocs
))
9586 /* SH uses RELA but uses in place value instead of the addend field. */
9587 if (elf_header
.e_machine
== EM_SH
)
9590 symsec
= section_headers
+ relsec
->sh_link
;
9591 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
);
9593 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
9596 unsigned int reloc_type
;
9597 unsigned int reloc_size
;
9598 unsigned char * rloc
;
9600 reloc_type
= get_reloc_type (rp
->r_info
);
9602 if (target_specific_reloc_handling (rp
, start
, symtab
))
9604 else if (is_none_reloc (reloc_type
))
9606 else if (is_32bit_abs_reloc (reloc_type
)
9607 || is_32bit_pcrel_reloc (reloc_type
))
9609 else if (is_64bit_abs_reloc (reloc_type
)
9610 || is_64bit_pcrel_reloc (reloc_type
))
9612 else if (is_24bit_abs_reloc (reloc_type
))
9614 else if (is_16bit_abs_reloc (reloc_type
))
9618 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
9619 reloc_type
, SECTION_NAME (section
));
9623 rloc
= start
+ rp
->r_offset
;
9624 if ((rloc
+ reloc_size
) > end
)
9626 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
9627 (unsigned long) rp
->r_offset
,
9628 SECTION_NAME (section
));
9632 sym
= symtab
+ get_reloc_symindex (rp
->r_info
);
9634 /* If the reloc has a symbol associated with it,
9635 make sure that it is of an appropriate type.
9637 Relocations against symbols without type can happen.
9638 Gcc -feliminate-dwarf2-dups may generate symbols
9639 without type for debug info.
9641 Icc generates relocations against function symbols
9642 instead of local labels.
9644 Relocations against object symbols can happen, eg when
9645 referencing a global array. For an example of this see
9646 the _clz.o binary in libgcc.a. */
9648 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
9650 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
9651 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
9652 (long int)(rp
- relocs
),
9653 SECTION_NAME (relsec
));
9659 addend
+= rp
->r_addend
;
9660 /* R_XTENSA_32 and R_PJ_DATA_DIR32 are partial_inplace. */
9662 || (elf_header
.e_machine
== EM_XTENSA
9664 || ((elf_header
.e_machine
== EM_PJ
9665 || elf_header
.e_machine
== EM_PJ_OLD
)
9666 && reloc_type
== 1))
9667 addend
+= byte_get (rloc
, reloc_size
);
9669 if (is_32bit_pcrel_reloc (reloc_type
)
9670 || is_64bit_pcrel_reloc (reloc_type
))
9672 /* On HPPA, all pc-relative relocations are biased by 8. */
9673 if (elf_header
.e_machine
== EM_PARISC
)
9675 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
9679 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
9688 #ifdef SUPPORT_DISASSEMBLY
9690 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
9692 printf (_("\nAssembly dump of section %s\n"),
9693 SECTION_NAME (section
));
9695 /* XXX -- to be done --- XXX */
9701 /* Reads in the contents of SECTION from FILE, returning a pointer
9702 to a malloc'ed buffer or NULL if something went wrong. */
9705 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
9707 bfd_size_type num_bytes
;
9709 num_bytes
= section
->sh_size
;
9711 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
9713 printf (_("\nSection '%s' has no data to dump.\n"),
9714 SECTION_NAME (section
));
9718 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
9719 _("section contents"));
9724 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
9726 Elf_Internal_Shdr
* relsec
;
9727 bfd_size_type num_bytes
;
9731 char * name
= SECTION_NAME (section
);
9732 bfd_boolean some_strings_shown
;
9734 start
= get_section_contents (section
, file
);
9738 printf (_("\nString dump of section '%s':\n"), name
);
9740 /* If the section being dumped has relocations against it the user might
9741 be expecting these relocations to have been applied. Check for this
9742 case and issue a warning message in order to avoid confusion.
9743 FIXME: Maybe we ought to have an option that dumps a section with
9745 for (relsec
= section_headers
;
9746 relsec
< section_headers
+ elf_header
.e_shnum
;
9749 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
9750 || relsec
->sh_info
>= elf_header
.e_shnum
9751 || section_headers
+ relsec
->sh_info
!= section
9752 || relsec
->sh_size
== 0
9753 || relsec
->sh_link
>= elf_header
.e_shnum
)
9756 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
9760 num_bytes
= section
->sh_size
;
9762 end
= start
+ num_bytes
;
9763 some_strings_shown
= FALSE
;
9767 while (!ISPRINT (* data
))
9774 /* PR 11128: Use two separate invocations in order to work
9775 around bugs in the Solaris 8 implementation of printf. */
9776 printf (" [%6tx] ", data
- start
);
9777 printf ("%s\n", data
);
9779 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
9781 data
+= strlen (data
);
9782 some_strings_shown
= TRUE
;
9786 if (! some_strings_shown
)
9787 printf (_(" No strings found in this section."));
9795 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
9797 bfd_boolean relocate
)
9799 Elf_Internal_Shdr
* relsec
;
9800 bfd_size_type bytes
;
9802 unsigned char * data
;
9803 unsigned char * start
;
9805 start
= (unsigned char *) get_section_contents (section
, file
);
9809 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
9813 apply_relocations (file
, section
, start
);
9817 /* If the section being dumped has relocations against it the user might
9818 be expecting these relocations to have been applied. Check for this
9819 case and issue a warning message in order to avoid confusion.
9820 FIXME: Maybe we ought to have an option that dumps a section with
9822 for (relsec
= section_headers
;
9823 relsec
< section_headers
+ elf_header
.e_shnum
;
9826 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
9827 || relsec
->sh_info
>= elf_header
.e_shnum
9828 || section_headers
+ relsec
->sh_info
!= section
9829 || relsec
->sh_size
== 0
9830 || relsec
->sh_link
>= elf_header
.e_shnum
)
9833 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
9838 addr
= section
->sh_addr
;
9839 bytes
= section
->sh_size
;
9848 lbytes
= (bytes
> 16 ? 16 : bytes
);
9850 printf (" 0x%8.8lx ", (unsigned long) addr
);
9852 for (j
= 0; j
< 16; j
++)
9855 printf ("%2.2x", data
[j
]);
9863 for (j
= 0; j
< lbytes
; j
++)
9866 if (k
>= ' ' && k
< 0x7f)
9884 /* Uncompresses a section that was compressed using zlib, in place.
9885 This is a copy of bfd_uncompress_section_contents, in bfd/compress.c */
9888 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED
,
9889 dwarf_size_type
*size ATTRIBUTE_UNUSED
)
9894 dwarf_size_type compressed_size
= *size
;
9895 unsigned char * compressed_buffer
= *buffer
;
9896 dwarf_size_type uncompressed_size
;
9897 unsigned char * uncompressed_buffer
;
9900 dwarf_size_type header_size
= 12;
9902 /* Read the zlib header. In this case, it should be "ZLIB" followed
9903 by the uncompressed section size, 8 bytes in big-endian order. */
9904 if (compressed_size
< header_size
9905 || ! streq ((char *) compressed_buffer
, "ZLIB"))
9908 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
9909 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
9910 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
9911 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
9912 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
9913 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
9914 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
9915 uncompressed_size
+= compressed_buffer
[11];
9917 /* It is possible the section consists of several compressed
9918 buffers concatenated together, so we uncompress in a loop. */
9922 strm
.avail_in
= compressed_size
- header_size
;
9923 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
9924 strm
.avail_out
= uncompressed_size
;
9925 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
9927 rc
= inflateInit (& strm
);
9928 while (strm
.avail_in
> 0)
9932 strm
.next_out
= ((Bytef
*) uncompressed_buffer
9933 + (uncompressed_size
- strm
.avail_out
));
9934 rc
= inflate (&strm
, Z_FINISH
);
9935 if (rc
!= Z_STREAM_END
)
9937 rc
= inflateReset (& strm
);
9939 rc
= inflateEnd (& strm
);
9941 || strm
.avail_out
!= 0)
9944 free (compressed_buffer
);
9945 *buffer
= uncompressed_buffer
;
9946 *size
= uncompressed_size
;
9950 free (uncompressed_buffer
);
9952 #endif /* HAVE_ZLIB_H */
9956 load_specific_debug_section (enum dwarf_section_display_enum debug
,
9957 Elf_Internal_Shdr
* sec
, void * file
)
9959 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
9961 int section_is_compressed
;
9963 /* If it is already loaded, do nothing. */
9964 if (section
->start
!= NULL
)
9967 section_is_compressed
= section
->name
== section
->compressed_name
;
9969 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
9970 section
->address
= sec
->sh_addr
;
9971 section
->size
= sec
->sh_size
;
9972 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
9975 if (section
->start
== NULL
)
9978 if (section_is_compressed
)
9980 if (! uncompress_section_contents (§ion
->start
, §ion
->size
))
9982 sec
->sh_size
= section
->size
;
9985 if (debug_displays
[debug
].relocate
)
9986 apply_relocations ((FILE *) file
, sec
, section
->start
);
9992 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
9994 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
9995 Elf_Internal_Shdr
* sec
;
9997 /* Locate the debug section. */
9998 sec
= find_section (section
->uncompressed_name
);
10000 section
->name
= section
->uncompressed_name
;
10003 sec
= find_section (section
->compressed_name
);
10005 section
->name
= section
->compressed_name
;
10010 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
10014 free_debug_section (enum dwarf_section_display_enum debug
)
10016 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
10018 if (section
->start
== NULL
)
10021 free ((char *) section
->start
);
10022 section
->start
= NULL
;
10023 section
->address
= 0;
10028 display_debug_section (Elf_Internal_Shdr
* section
, FILE * file
)
10030 char * name
= SECTION_NAME (section
);
10031 bfd_size_type length
;
10035 length
= section
->sh_size
;
10038 printf (_("\nSection '%s' has no debugging data.\n"), name
);
10041 if (section
->sh_type
== SHT_NOBITS
)
10043 /* There is no point in dumping the contents of a debugging section
10044 which has the NOBITS type - the bits in the file will be random.
10045 This can happen when a file containing a .eh_frame section is
10046 stripped with the --only-keep-debug command line option. */
10047 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name
);
10051 if (const_strneq (name
, ".gnu.linkonce.wi."))
10052 name
= ".debug_info";
10054 /* See if we know how to display the contents of this section. */
10055 for (i
= 0; i
< max
; i
++)
10056 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
10057 || streq (debug_displays
[i
].section
.compressed_name
, name
))
10059 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
10060 int secondary
= (section
!= find_section (name
));
10063 free_debug_section ((enum dwarf_section_display_enum
) i
);
10065 if (streq (sec
->uncompressed_name
, name
))
10066 sec
->name
= sec
->uncompressed_name
;
10068 sec
->name
= sec
->compressed_name
;
10069 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
10072 result
&= debug_displays
[i
].display (sec
, file
);
10074 if (secondary
|| (i
!= info
&& i
!= abbrev
))
10075 free_debug_section ((enum dwarf_section_display_enum
) i
);
10083 printf (_("Unrecognized debug section: %s\n"), name
);
10090 /* Set DUMP_SECTS for all sections where dumps were requested
10091 based on section name. */
10094 initialise_dumps_byname (void)
10096 struct dump_list_entry
* cur
;
10098 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
10103 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
10104 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
10106 request_dump_bynumber (i
, cur
->type
);
10111 warn (_("Section '%s' was not dumped because it does not exist!\n"),
10117 process_section_contents (FILE * file
)
10119 Elf_Internal_Shdr
* section
;
10125 initialise_dumps_byname ();
10127 for (i
= 0, section
= section_headers
;
10128 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
10131 #ifdef SUPPORT_DISASSEMBLY
10132 if (dump_sects
[i
] & DISASS_DUMP
)
10133 disassemble_section (section
, file
);
10135 if (dump_sects
[i
] & HEX_DUMP
)
10136 dump_section_as_bytes (section
, file
, FALSE
);
10138 if (dump_sects
[i
] & RELOC_DUMP
)
10139 dump_section_as_bytes (section
, file
, TRUE
);
10141 if (dump_sects
[i
] & STRING_DUMP
)
10142 dump_section_as_strings (section
, file
);
10144 if (dump_sects
[i
] & DEBUG_DUMP
)
10145 display_debug_section (section
, file
);
10148 /* Check to see if the user requested a
10149 dump of a section that does not exist. */
10150 while (i
++ < num_dump_sects
)
10152 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
10156 process_mips_fpe_exception (int mask
)
10161 if (mask
& OEX_FPU_INEX
)
10162 fputs ("INEX", stdout
), first
= 0;
10163 if (mask
& OEX_FPU_UFLO
)
10164 printf ("%sUFLO", first
? "" : "|"), first
= 0;
10165 if (mask
& OEX_FPU_OFLO
)
10166 printf ("%sOFLO", first
? "" : "|"), first
= 0;
10167 if (mask
& OEX_FPU_DIV0
)
10168 printf ("%sDIV0", first
? "" : "|"), first
= 0;
10169 if (mask
& OEX_FPU_INVAL
)
10170 printf ("%sINVAL", first
? "" : "|");
10173 fputs ("0", stdout
);
10176 /* ARM EABI attributes section. */
10181 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
10183 const char ** table
;
10184 } arm_attr_public_tag
;
10186 static const char * arm_attr_tag_CPU_arch
[] =
10187 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
10188 "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
10189 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
10190 static const char * arm_attr_tag_THUMB_ISA_use
[] =
10191 {"No", "Thumb-1", "Thumb-2"};
10192 static const char * arm_attr_tag_FP_arch
[] =
10193 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
10194 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
10195 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
10196 {"No", "NEONv1", "NEONv1 with Fused-MAC"};
10197 static const char * arm_attr_tag_PCS_config
[] =
10198 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
10199 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
10200 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
10201 {"V6", "SB", "TLS", "Unused"};
10202 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
10203 {"Absolute", "PC-relative", "SB-relative", "None"};
10204 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
10205 {"Absolute", "PC-relative", "None"};
10206 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
10207 {"None", "direct", "GOT-indirect"};
10208 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
10209 {"None", "??? 1", "2", "??? 3", "4"};
10210 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
10211 static const char * arm_attr_tag_ABI_FP_denormal
[] =
10212 {"Unused", "Needed", "Sign only"};
10213 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
10214 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
10215 static const char * arm_attr_tag_ABI_FP_number_model
[] =
10216 {"Unused", "Finite", "RTABI", "IEEE 754"};
10217 static const char * arm_attr_tag_ABI_enum_size
[] =
10218 {"Unused", "small", "int", "forced to int"};
10219 static const char * arm_attr_tag_ABI_HardFP_use
[] =
10220 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
10221 static const char * arm_attr_tag_ABI_VFP_args
[] =
10222 {"AAPCS", "VFP registers", "custom"};
10223 static const char * arm_attr_tag_ABI_WMMX_args
[] =
10224 {"AAPCS", "WMMX registers", "custom"};
10225 static const char * arm_attr_tag_ABI_optimization_goals
[] =
10226 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10227 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
10228 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
10229 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10230 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
10231 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
10232 static const char * arm_attr_tag_FP_HP_extension
[] =
10233 {"Not Allowed", "Allowed"};
10234 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
10235 {"None", "IEEE 754", "Alternative Format"};
10236 static const char * arm_attr_tag_MPextension_use
[] =
10237 {"Not Allowed", "Allowed"};
10238 static const char * arm_attr_tag_DIV_use
[] =
10239 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
10240 "Allowed in v7-A with integer division extension"};
10241 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
10242 static const char * arm_attr_tag_Virtualization_use
[] =
10243 {"Not Allowed", "TrustZone", "Virtualization Extensions",
10244 "TrustZone and Virtualization Extensions"};
10245 static const char * arm_attr_tag_MPextension_use_legacy
[] =
10246 {"Not Allowed", "Allowed"};
10248 #define LOOKUP(id, name) \
10249 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
10250 static arm_attr_public_tag arm_attr_public_tags
[] =
10252 {4, "CPU_raw_name", 1, NULL
},
10253 {5, "CPU_name", 1, NULL
},
10254 LOOKUP(6, CPU_arch
),
10255 {7, "CPU_arch_profile", 0, NULL
},
10256 LOOKUP(8, ARM_ISA_use
),
10257 LOOKUP(9, THUMB_ISA_use
),
10258 LOOKUP(10, FP_arch
),
10259 LOOKUP(11, WMMX_arch
),
10260 LOOKUP(12, Advanced_SIMD_arch
),
10261 LOOKUP(13, PCS_config
),
10262 LOOKUP(14, ABI_PCS_R9_use
),
10263 LOOKUP(15, ABI_PCS_RW_data
),
10264 LOOKUP(16, ABI_PCS_RO_data
),
10265 LOOKUP(17, ABI_PCS_GOT_use
),
10266 LOOKUP(18, ABI_PCS_wchar_t
),
10267 LOOKUP(19, ABI_FP_rounding
),
10268 LOOKUP(20, ABI_FP_denormal
),
10269 LOOKUP(21, ABI_FP_exceptions
),
10270 LOOKUP(22, ABI_FP_user_exceptions
),
10271 LOOKUP(23, ABI_FP_number_model
),
10272 {24, "ABI_align_needed", 0, NULL
},
10273 {25, "ABI_align_preserved", 0, NULL
},
10274 LOOKUP(26, ABI_enum_size
),
10275 LOOKUP(27, ABI_HardFP_use
),
10276 LOOKUP(28, ABI_VFP_args
),
10277 LOOKUP(29, ABI_WMMX_args
),
10278 LOOKUP(30, ABI_optimization_goals
),
10279 LOOKUP(31, ABI_FP_optimization_goals
),
10280 {32, "compatibility", 0, NULL
},
10281 LOOKUP(34, CPU_unaligned_access
),
10282 LOOKUP(36, FP_HP_extension
),
10283 LOOKUP(38, ABI_FP_16bit_format
),
10284 LOOKUP(42, MPextension_use
),
10285 LOOKUP(44, DIV_use
),
10286 {64, "nodefaults", 0, NULL
},
10287 {65, "also_compatible_with", 0, NULL
},
10288 LOOKUP(66, T2EE_use
),
10289 {67, "conformance", 1, NULL
},
10290 LOOKUP(68, Virtualization_use
),
10291 LOOKUP(70, MPextension_use_legacy
)
10295 static unsigned char *
10296 display_arm_attribute (unsigned char * p
)
10301 arm_attr_public_tag
* attr
;
10305 tag
= read_uleb128 (p
, &len
);
10308 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
10310 if (arm_attr_public_tags
[i
].tag
== tag
)
10312 attr
= &arm_attr_public_tags
[i
];
10319 printf (" Tag_%s: ", attr
->name
);
10320 switch (attr
->type
)
10325 case 7: /* Tag_CPU_arch_profile. */
10326 val
= read_uleb128 (p
, &len
);
10330 case 0: printf (_("None\n")); break;
10331 case 'A': printf (_("Application\n")); break;
10332 case 'R': printf (_("Realtime\n")); break;
10333 case 'M': printf (_("Microcontroller\n")); break;
10334 case 'S': printf (_("Application or Realtime\n")); break;
10335 default: printf ("??? (%d)\n", val
); break;
10339 case 24: /* Tag_align_needed. */
10340 val
= read_uleb128 (p
, &len
);
10344 case 0: printf (_("None\n")); break;
10345 case 1: printf (_("8-byte\n")); break;
10346 case 2: printf (_("4-byte\n")); break;
10347 case 3: printf ("??? 3\n"); break;
10350 printf (_("8-byte and up to %d-byte extended\n"),
10353 printf ("??? (%d)\n", val
);
10358 case 25: /* Tag_align_preserved. */
10359 val
= read_uleb128 (p
, &len
);
10363 case 0: printf (_("None\n")); break;
10364 case 1: printf (_("8-byte, except leaf SP\n")); break;
10365 case 2: printf (_("8-byte\n")); break;
10366 case 3: printf ("??? 3\n"); break;
10369 printf (_("8-byte and up to %d-byte extended\n"),
10372 printf ("??? (%d)\n", val
);
10377 case 32: /* Tag_compatibility. */
10378 val
= read_uleb128 (p
, &len
);
10380 printf (_("flag = %d, vendor = %s\n"), val
, p
);
10381 p
+= strlen ((char *) p
) + 1;
10384 case 64: /* Tag_nodefaults. */
10386 printf (_("True\n"));
10389 case 65: /* Tag_also_compatible_with. */
10390 val
= read_uleb128 (p
, &len
);
10392 if (val
== 6 /* Tag_CPU_arch. */)
10394 val
= read_uleb128 (p
, &len
);
10396 if ((unsigned int)val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
10397 printf ("??? (%d)\n", val
);
10399 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
10403 while (*(p
++) != '\0' /* NUL terminator. */);
10417 assert (attr
->type
& 0x80);
10418 val
= read_uleb128 (p
, &len
);
10420 type
= attr
->type
& 0x7f;
10422 printf ("??? (%d)\n", val
);
10424 printf ("%s\n", attr
->table
[val
]);
10431 type
= 1; /* String. */
10433 type
= 2; /* uleb128. */
10434 printf (" Tag_unknown_%d: ", tag
);
10439 printf ("\"%s\"\n", p
);
10440 p
+= strlen ((char *) p
) + 1;
10444 val
= read_uleb128 (p
, &len
);
10446 printf ("%d (0x%x)\n", val
, val
);
10452 static unsigned char *
10453 display_gnu_attribute (unsigned char * p
,
10454 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
10461 tag
= read_uleb128 (p
, &len
);
10464 /* Tag_compatibility is the only generic GNU attribute defined at
10468 val
= read_uleb128 (p
, &len
);
10470 printf (_("flag = %d, vendor = %s\n"), val
, p
);
10471 p
+= strlen ((char *) p
) + 1;
10475 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
10476 return display_proc_gnu_attribute (p
, tag
);
10479 type
= 1; /* String. */
10481 type
= 2; /* uleb128. */
10482 printf (" Tag_unknown_%d: ", tag
);
10486 printf ("\"%s\"\n", p
);
10487 p
+= strlen ((char *) p
) + 1;
10491 val
= read_uleb128 (p
, &len
);
10493 printf ("%d (0x%x)\n", val
, val
);
10499 static unsigned char *
10500 display_power_gnu_attribute (unsigned char * p
, int tag
)
10506 if (tag
== Tag_GNU_Power_ABI_FP
)
10508 val
= read_uleb128 (p
, &len
);
10510 printf (" Tag_GNU_Power_ABI_FP: ");
10515 printf (_("Hard or soft float\n"));
10518 printf (_("Hard float\n"));
10521 printf (_("Soft float\n"));
10524 printf (_("Single-precision hard float\n"));
10527 printf ("??? (%d)\n", val
);
10533 if (tag
== Tag_GNU_Power_ABI_Vector
)
10535 val
= read_uleb128 (p
, &len
);
10537 printf (" Tag_GNU_Power_ABI_Vector: ");
10541 printf (_("Any\n"));
10544 printf (_("Generic\n"));
10547 printf ("AltiVec\n");
10553 printf ("??? (%d)\n", val
);
10559 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
10561 val
= read_uleb128 (p
, &len
);
10563 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
10567 printf (_("Any\n"));
10570 printf ("r3/r4\n");
10573 printf (_("Memory\n"));
10576 printf ("??? (%d)\n", val
);
10583 type
= 1; /* String. */
10585 type
= 2; /* uleb128. */
10586 printf (" Tag_unknown_%d: ", tag
);
10590 printf ("\"%s\"\n", p
);
10591 p
+= strlen ((char *) p
) + 1;
10595 val
= read_uleb128 (p
, &len
);
10597 printf ("%d (0x%x)\n", val
, val
);
10603 static unsigned char *
10604 display_mips_gnu_attribute (unsigned char * p
, int tag
)
10610 if (tag
== Tag_GNU_MIPS_ABI_FP
)
10612 val
= read_uleb128 (p
, &len
);
10614 printf (" Tag_GNU_MIPS_ABI_FP: ");
10619 printf (_("Hard or soft float\n"));
10622 printf (_("Hard float (double precision)\n"));
10625 printf (_("Hard float (single precision)\n"));
10628 printf (_("Soft float\n"));
10631 printf (_("64-bit float (-mips32r2 -mfp64)\n"));
10634 printf ("??? (%d)\n", val
);
10641 type
= 1; /* String. */
10643 type
= 2; /* uleb128. */
10644 printf (" Tag_unknown_%d: ", tag
);
10648 printf ("\"%s\"\n", p
);
10649 p
+= strlen ((char *) p
) + 1;
10653 val
= read_uleb128 (p
, &len
);
10655 printf ("%d (0x%x)\n", val
, val
);
10661 static unsigned char *
10662 display_tic6x_attribute (unsigned char * p
)
10668 tag
= read_uleb128 (p
, &len
);
10673 case Tag_C6XABI_Tag_CPU_arch
:
10674 val
= read_uleb128 (p
, &len
);
10676 printf (" Tag_C6XABI_Tag_CPU_arch: ");
10680 case C6XABI_Tag_CPU_arch_none
:
10681 printf (_("None\n"));
10683 case C6XABI_Tag_CPU_arch_C62X
:
10686 case C6XABI_Tag_CPU_arch_C67X
:
10689 case C6XABI_Tag_CPU_arch_C67XP
:
10690 printf ("C67x+\n");
10692 case C6XABI_Tag_CPU_arch_C64X
:
10695 case C6XABI_Tag_CPU_arch_C64XP
:
10696 printf ("C64x+\n");
10698 case C6XABI_Tag_CPU_arch_C674X
:
10699 printf ("C674x\n");
10702 printf ("??? (%d)\n", val
);
10708 /* Tag_compatibility - treated as generic by binutils for now
10709 although not currently specified for C6X. */
10710 val
= read_uleb128 (p
, &len
);
10712 printf (_("flag = %d, vendor = %s\n"), val
, p
);
10713 p
+= strlen ((char *) p
) + 1;
10717 printf (" Tag_unknown_%d: ", tag
);
10719 /* No general documentation of handling unknown attributes, treat as
10720 ULEB128 for now. */
10721 val
= read_uleb128 (p
, &len
);
10723 printf ("%d (0x%x)\n", val
, val
);
10729 process_attributes (FILE * file
,
10730 const char * public_name
,
10731 unsigned int proc_type
,
10732 unsigned char * (* display_pub_attribute
) (unsigned char *),
10733 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
10735 Elf_Internal_Shdr
* sect
;
10736 unsigned char * contents
;
10738 unsigned char * end
;
10739 bfd_vma section_len
;
10743 /* Find the section header so that we get the size. */
10744 for (i
= 0, sect
= section_headers
;
10745 i
< elf_header
.e_shnum
;
10748 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
10751 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
10752 sect
->sh_size
, _("attributes"));
10753 if (contents
== NULL
)
10759 len
= sect
->sh_size
- 1;
10765 bfd_boolean public_section
;
10766 bfd_boolean gnu_section
;
10768 section_len
= byte_get (p
, 4);
10771 if (section_len
> len
)
10773 printf (_("ERROR: Bad section length (%d > %d)\n"),
10774 (int) section_len
, (int) len
);
10778 len
-= section_len
;
10779 printf (_("Attribute Section: %s\n"), p
);
10781 if (public_name
&& streq ((char *) p
, public_name
))
10782 public_section
= TRUE
;
10784 public_section
= FALSE
;
10786 if (streq ((char *) p
, "gnu"))
10787 gnu_section
= TRUE
;
10789 gnu_section
= FALSE
;
10791 namelen
= strlen ((char *) p
) + 1;
10793 section_len
-= namelen
+ 4;
10795 while (section_len
> 0)
10801 size
= byte_get (p
, 4);
10802 if (size
> section_len
)
10804 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
10805 (int) size
, (int) section_len
);
10806 size
= section_len
;
10809 section_len
-= size
;
10810 end
= p
+ size
- 1;
10816 printf (_("File Attributes\n"));
10819 printf (_("Section Attributes:"));
10822 printf (_("Symbol Attributes:"));
10828 val
= read_uleb128 (p
, &j
);
10832 printf (" %d", val
);
10837 printf (_("Unknown tag: %d\n"), tag
);
10838 public_section
= FALSE
;
10842 if (public_section
)
10845 p
= display_pub_attribute (p
);
10847 else if (gnu_section
)
10850 p
= display_gnu_attribute (p
,
10851 display_proc_gnu_attribute
);
10855 /* ??? Do something sensible, like dump hex. */
10856 printf (_(" Unknown section contexts\n"));
10863 printf (_("Unknown format '%c'\n"), *p
);
10871 process_arm_specific (FILE * file
)
10873 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
10874 display_arm_attribute
, NULL
);
10878 process_power_specific (FILE * file
)
10880 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
10881 display_power_gnu_attribute
);
10885 process_tic6x_specific (FILE * file
)
10887 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
10888 display_tic6x_attribute
, NULL
);
10891 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
10892 Print the Address, Access and Initial fields of an entry at VMA ADDR
10893 and return the VMA of the next entry. */
10896 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
10899 print_vma (addr
, LONG_HEX
);
10901 if (addr
< pltgot
+ 0xfff0)
10902 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
10904 printf ("%10s", "");
10907 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
10912 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
10913 print_vma (entry
, LONG_HEX
);
10915 return addr
+ (is_32bit_elf
? 4 : 8);
10918 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
10919 PLTGOT. Print the Address and Initial fields of an entry at VMA
10920 ADDR and return the VMA of the next entry. */
10923 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
10926 print_vma (addr
, LONG_HEX
);
10929 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
10934 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
10935 print_vma (entry
, LONG_HEX
);
10937 return addr
+ (is_32bit_elf
? 4 : 8);
10941 process_mips_specific (FILE * file
)
10943 Elf_Internal_Dyn
* entry
;
10944 size_t liblist_offset
= 0;
10945 size_t liblistno
= 0;
10946 size_t conflictsno
= 0;
10947 size_t options_offset
= 0;
10948 size_t conflicts_offset
= 0;
10949 size_t pltrelsz
= 0;
10951 bfd_vma pltgot
= 0;
10952 bfd_vma mips_pltgot
= 0;
10953 bfd_vma jmprel
= 0;
10954 bfd_vma local_gotno
= 0;
10955 bfd_vma gotsym
= 0;
10956 bfd_vma symtabno
= 0;
10958 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
10959 display_mips_gnu_attribute
);
10961 /* We have a lot of special sections. Thanks SGI! */
10962 if (dynamic_section
== NULL
)
10963 /* No information available. */
10966 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
10967 switch (entry
->d_tag
)
10969 case DT_MIPS_LIBLIST
:
10971 = offset_from_vma (file
, entry
->d_un
.d_val
,
10972 liblistno
* sizeof (Elf32_External_Lib
));
10974 case DT_MIPS_LIBLISTNO
:
10975 liblistno
= entry
->d_un
.d_val
;
10977 case DT_MIPS_OPTIONS
:
10978 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
10980 case DT_MIPS_CONFLICT
:
10982 = offset_from_vma (file
, entry
->d_un
.d_val
,
10983 conflictsno
* sizeof (Elf32_External_Conflict
));
10985 case DT_MIPS_CONFLICTNO
:
10986 conflictsno
= entry
->d_un
.d_val
;
10989 pltgot
= entry
->d_un
.d_ptr
;
10991 case DT_MIPS_LOCAL_GOTNO
:
10992 local_gotno
= entry
->d_un
.d_val
;
10994 case DT_MIPS_GOTSYM
:
10995 gotsym
= entry
->d_un
.d_val
;
10997 case DT_MIPS_SYMTABNO
:
10998 symtabno
= entry
->d_un
.d_val
;
11000 case DT_MIPS_PLTGOT
:
11001 mips_pltgot
= entry
->d_un
.d_ptr
;
11004 pltrel
= entry
->d_un
.d_val
;
11007 pltrelsz
= entry
->d_un
.d_val
;
11010 jmprel
= entry
->d_un
.d_ptr
;
11016 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
11018 Elf32_External_Lib
* elib
;
11021 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
11023 sizeof (Elf32_External_Lib
),
11027 printf (_("\nSection '.liblist' contains %lu entries:\n"),
11028 (unsigned long) liblistno
);
11029 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
11032 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
11039 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11040 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11041 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11042 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11043 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11045 tmp
= gmtime (&atime
);
11046 snprintf (timebuf
, sizeof (timebuf
),
11047 "%04u-%02u-%02uT%02u:%02u:%02u",
11048 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11049 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11051 printf ("%3lu: ", (unsigned long) cnt
);
11052 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
11053 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
11055 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
11056 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
11057 liblist
.l_version
);
11059 if (liblist
.l_flags
== 0)
11063 static const struct
11070 { " EXACT_MATCH", LL_EXACT_MATCH
},
11071 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
11072 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
11073 { " EXPORTS", LL_EXPORTS
},
11074 { " DELAY_LOAD", LL_DELAY_LOAD
},
11075 { " DELTA", LL_DELTA
}
11077 int flags
= liblist
.l_flags
;
11080 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
11081 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
11083 fputs (l_flags_vals
[fcnt
].name
, stdout
);
11084 flags
^= l_flags_vals
[fcnt
].bit
;
11087 printf (" %#x", (unsigned int) flags
);
11097 if (options_offset
!= 0)
11099 Elf_External_Options
* eopt
;
11100 Elf_Internal_Shdr
* sect
= section_headers
;
11101 Elf_Internal_Options
* iopt
;
11102 Elf_Internal_Options
* option
;
11106 /* Find the section header so that we get the size. */
11107 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
11110 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
11111 sect
->sh_size
, _("options"));
11114 iopt
= (Elf_Internal_Options
*)
11115 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
11118 error (_("Out of memory\n"));
11125 while (offset
< sect
->sh_size
)
11127 Elf_External_Options
* eoption
;
11129 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
11131 option
->kind
= BYTE_GET (eoption
->kind
);
11132 option
->size
= BYTE_GET (eoption
->size
);
11133 option
->section
= BYTE_GET (eoption
->section
);
11134 option
->info
= BYTE_GET (eoption
->info
);
11136 offset
+= option
->size
;
11142 printf (_("\nSection '%s' contains %d entries:\n"),
11143 SECTION_NAME (sect
), cnt
);
11151 switch (option
->kind
)
11154 /* This shouldn't happen. */
11155 printf (" NULL %d %lx", option
->section
, option
->info
);
11158 printf (" REGINFO ");
11159 if (elf_header
.e_machine
== EM_MIPS
)
11162 Elf32_External_RegInfo
* ereg
;
11163 Elf32_RegInfo reginfo
;
11165 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
11166 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11167 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11168 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11169 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11170 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11171 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11173 printf ("GPR %08lx GP 0x%lx\n",
11174 reginfo
.ri_gprmask
,
11175 (unsigned long) reginfo
.ri_gp_value
);
11176 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11177 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11178 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11183 Elf64_External_RegInfo
* ereg
;
11184 Elf64_Internal_RegInfo reginfo
;
11186 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
11187 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11188 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11189 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11190 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11191 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11192 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11194 printf ("GPR %08lx GP 0x",
11195 reginfo
.ri_gprmask
);
11196 printf_vma (reginfo
.ri_gp_value
);
11199 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11200 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11201 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11205 case ODK_EXCEPTIONS
:
11206 fputs (" EXCEPTIONS fpe_min(", stdout
);
11207 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
11208 fputs (") fpe_max(", stdout
);
11209 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
11210 fputs (")", stdout
);
11212 if (option
->info
& OEX_PAGE0
)
11213 fputs (" PAGE0", stdout
);
11214 if (option
->info
& OEX_SMM
)
11215 fputs (" SMM", stdout
);
11216 if (option
->info
& OEX_FPDBUG
)
11217 fputs (" FPDBUG", stdout
);
11218 if (option
->info
& OEX_DISMISS
)
11219 fputs (" DISMISS", stdout
);
11222 fputs (" PAD ", stdout
);
11223 if (option
->info
& OPAD_PREFIX
)
11224 fputs (" PREFIX", stdout
);
11225 if (option
->info
& OPAD_POSTFIX
)
11226 fputs (" POSTFIX", stdout
);
11227 if (option
->info
& OPAD_SYMBOL
)
11228 fputs (" SYMBOL", stdout
);
11231 fputs (" HWPATCH ", stdout
);
11232 if (option
->info
& OHW_R4KEOP
)
11233 fputs (" R4KEOP", stdout
);
11234 if (option
->info
& OHW_R8KPFETCH
)
11235 fputs (" R8KPFETCH", stdout
);
11236 if (option
->info
& OHW_R5KEOP
)
11237 fputs (" R5KEOP", stdout
);
11238 if (option
->info
& OHW_R5KCVTL
)
11239 fputs (" R5KCVTL", stdout
);
11242 fputs (" FILL ", stdout
);
11243 /* XXX Print content of info word? */
11246 fputs (" TAGS ", stdout
);
11247 /* XXX Print content of info word? */
11250 fputs (" HWAND ", stdout
);
11251 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11252 fputs (" R4KEOP_CHECKED", stdout
);
11253 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11254 fputs (" R4KEOP_CLEAN", stdout
);
11257 fputs (" HWOR ", stdout
);
11258 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11259 fputs (" R4KEOP_CHECKED", stdout
);
11260 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11261 fputs (" R4KEOP_CLEAN", stdout
);
11264 printf (" GP_GROUP %#06lx self-contained %#06lx",
11265 option
->info
& OGP_GROUP
,
11266 (option
->info
& OGP_SELF
) >> 16);
11269 printf (" IDENT %#06lx self-contained %#06lx",
11270 option
->info
& OGP_GROUP
,
11271 (option
->info
& OGP_SELF
) >> 16);
11274 /* This shouldn't happen. */
11275 printf (" %3d ??? %d %lx",
11276 option
->kind
, option
->section
, option
->info
);
11280 len
= sizeof (* eopt
);
11281 while (len
< option
->size
)
11282 if (((char *) option
)[len
] >= ' '
11283 && ((char *) option
)[len
] < 0x7f)
11284 printf ("%c", ((char *) option
)[len
++]);
11286 printf ("\\%03o", ((char *) option
)[len
++]);
11288 fputs ("\n", stdout
);
11296 if (conflicts_offset
!= 0 && conflictsno
!= 0)
11298 Elf32_Conflict
* iconf
;
11301 if (dynamic_symbols
== NULL
)
11303 error (_("conflict list found without a dynamic symbol table\n"));
11307 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
11310 error (_("Out of memory\n"));
11316 Elf32_External_Conflict
* econf32
;
11318 econf32
= (Elf32_External_Conflict
*)
11319 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
11320 sizeof (* econf32
), _("conflict"));
11324 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11325 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
11331 Elf64_External_Conflict
* econf64
;
11333 econf64
= (Elf64_External_Conflict
*)
11334 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
11335 sizeof (* econf64
), _("conflict"));
11339 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11340 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
11345 printf (_("\nSection '.conflict' contains %lu entries:\n"),
11346 (unsigned long) conflictsno
);
11347 puts (_(" Num: Index Value Name"));
11349 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11351 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
11353 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
11354 print_vma (psym
->st_value
, FULL_HEX
);
11356 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11357 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11359 printf (_("<corrupt: %14ld>"), psym
->st_name
);
11366 if (pltgot
!= 0 && local_gotno
!= 0)
11368 bfd_vma ent
, local_end
, global_end
;
11370 unsigned char * data
;
11374 addr_size
= (is_32bit_elf
? 4 : 8);
11375 local_end
= pltgot
+ local_gotno
* addr_size
;
11376 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
11378 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
11379 data
= (unsigned char *) get_data (NULL
, file
, offset
,
11380 global_end
- pltgot
, 1, _("GOT"));
11381 printf (_("\nPrimary GOT:\n"));
11382 printf (_(" Canonical gp value: "));
11383 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
11386 printf (_(" Reserved entries:\n"));
11387 printf (_(" %*s %10s %*s Purpose\n"),
11388 addr_size
* 2, _("Address"), _("Access"),
11389 addr_size
* 2, _("Initial"));
11390 ent
= print_mips_got_entry (data
, pltgot
, ent
);
11391 printf (_(" Lazy resolver\n"));
11393 && (byte_get (data
+ ent
- pltgot
, addr_size
)
11394 >> (addr_size
* 8 - 1)) != 0)
11396 ent
= print_mips_got_entry (data
, pltgot
, ent
);
11397 printf (_(" Module pointer (GNU extension)\n"));
11401 if (ent
< local_end
)
11403 printf (_(" Local entries:\n"));
11404 printf (_(" %*s %10s %*s\n"),
11405 addr_size
* 2, _("Address"), _("Access"),
11406 addr_size
* 2, _("Initial"));
11407 while (ent
< local_end
)
11409 ent
= print_mips_got_entry (data
, pltgot
, ent
);
11415 if (gotsym
< symtabno
)
11419 printf (_(" Global entries:\n"));
11420 printf (_(" %*s %10s %*s %*s %-7s %3s %s\n"),
11421 addr_size
* 2, _("Address"), _("Access"),
11422 addr_size
* 2, _("Initial"),
11423 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
11424 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
11425 for (i
= gotsym
; i
< symtabno
; i
++)
11427 Elf_Internal_Sym
* psym
;
11429 psym
= dynamic_symbols
+ i
;
11430 ent
= print_mips_got_entry (data
, pltgot
, ent
);
11432 print_vma (psym
->st_value
, LONG_HEX
);
11433 printf (" %-7s %3s ",
11434 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
11435 get_symbol_index_type (psym
->st_shndx
));
11436 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11437 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
11439 printf (_("<corrupt: %14ld>"), psym
->st_name
);
11449 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
11452 size_t offset
, rel_offset
;
11453 unsigned long count
, i
;
11454 unsigned char * data
;
11455 int addr_size
, sym_width
;
11456 Elf_Internal_Rela
* rels
;
11458 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
11459 if (pltrel
== DT_RELA
)
11461 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
11466 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
11471 addr_size
= (is_32bit_elf
? 4 : 8);
11472 end
= mips_pltgot
+ (2 + count
) * addr_size
;
11474 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
11475 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
11477 printf (_("\nPLT GOT:\n\n"));
11478 printf (_(" Reserved entries:\n"));
11479 printf (_(" %*s %*s Purpose\n"),
11480 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
11481 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
11482 printf (_(" PLT lazy resolver\n"));
11483 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
11484 printf (_(" Module pointer\n"));
11487 printf (_(" Entries:\n"));
11488 printf (_(" %*s %*s %*s %-7s %3s %s\n"),
11489 addr_size
* 2, _("Address"),
11490 addr_size
* 2, _("Initial"),
11491 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
11492 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
11493 for (i
= 0; i
< count
; i
++)
11495 Elf_Internal_Sym
* psym
;
11497 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
11498 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
11500 print_vma (psym
->st_value
, LONG_HEX
);
11501 printf (" %-7s %3s ",
11502 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
11503 get_symbol_index_type (psym
->st_shndx
));
11504 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11505 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
11507 printf (_("<corrupt: %14ld>"), psym
->st_name
);
11521 process_gnu_liblist (FILE * file
)
11523 Elf_Internal_Shdr
* section
;
11524 Elf_Internal_Shdr
* string_sec
;
11525 Elf32_External_Lib
* elib
;
11527 size_t strtab_size
;
11534 for (i
= 0, section
= section_headers
;
11535 i
< elf_header
.e_shnum
;
11538 switch (section
->sh_type
)
11540 case SHT_GNU_LIBLIST
:
11541 if (section
->sh_link
>= elf_header
.e_shnum
)
11544 elib
= (Elf32_External_Lib
*)
11545 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
11550 string_sec
= section_headers
+ section
->sh_link
;
11552 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
11553 string_sec
->sh_size
,
11554 _("liblist string table"));
11555 strtab_size
= string_sec
->sh_size
;
11558 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
11564 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
11565 SECTION_NAME (section
),
11566 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
11568 puts (_(" Library Time Stamp Checksum Version Flags"));
11570 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
11578 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11579 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11580 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11581 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11582 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11584 tmp
= gmtime (&atime
);
11585 snprintf (timebuf
, sizeof (timebuf
),
11586 "%04u-%02u-%02uT%02u:%02u:%02u",
11587 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11588 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11590 printf ("%3lu: ", (unsigned long) cnt
);
11592 printf ("%-20s", liblist
.l_name
< strtab_size
11593 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
11595 printf ("%-20.20s", liblist
.l_name
< strtab_size
11596 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
11597 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
11598 liblist
.l_version
, liblist
.l_flags
);
11608 static const char *
11609 get_note_type (unsigned e_type
)
11611 static char buff
[64];
11613 if (elf_header
.e_type
== ET_CORE
)
11617 return _("NT_AUXV (auxiliary vector)");
11619 return _("NT_PRSTATUS (prstatus structure)");
11621 return _("NT_FPREGSET (floating point registers)");
11623 return _("NT_PRPSINFO (prpsinfo structure)");
11624 case NT_TASKSTRUCT
:
11625 return _("NT_TASKSTRUCT (task structure)");
11627 return _("NT_PRXFPREG (user_xfpregs structure)");
11629 return _("NT_PPC_VMX (ppc Altivec registers)");
11631 return _("NT_PPC_VSX (ppc VSX registers)");
11632 case NT_X86_XSTATE
:
11633 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
11634 case NT_S390_HIGH_GPRS
:
11635 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
11636 case NT_S390_TIMER
:
11637 return _("NT_S390_TIMER (s390 timer register)");
11638 case NT_S390_TODCMP
:
11639 return _("NT_S390_TODCMP (s390 TOD comparator register)");
11640 case NT_S390_TODPREG
:
11641 return _("NT_S390_TODPREG (s390 TOD programmable register)");
11643 return _("NT_S390_CTRS (s390 control registers)");
11644 case NT_S390_PREFIX
:
11645 return _("NT_S390_PREFIX (s390 prefix register)");
11647 return _("NT_PSTATUS (pstatus structure)");
11649 return _("NT_FPREGS (floating point registers)");
11651 return _("NT_PSINFO (psinfo structure)");
11653 return _("NT_LWPSTATUS (lwpstatus_t structure)");
11655 return _("NT_LWPSINFO (lwpsinfo_t structure)");
11656 case NT_WIN32PSTATUS
:
11657 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11665 return _("NT_VERSION (version)");
11667 return _("NT_ARCH (architecture)");
11672 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11676 static const char *
11677 get_gnu_elf_note_type (unsigned e_type
)
11679 static char buff
[64];
11683 case NT_GNU_ABI_TAG
:
11684 return _("NT_GNU_ABI_TAG (ABI version tag)");
11686 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
11687 case NT_GNU_BUILD_ID
:
11688 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
11689 case NT_GNU_GOLD_VERSION
:
11690 return _("NT_GNU_GOLD_VERSION (gold version)");
11695 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11699 static const char *
11700 get_netbsd_elfcore_note_type (unsigned e_type
)
11702 static char buff
[64];
11704 if (e_type
== NT_NETBSDCORE_PROCINFO
)
11706 /* NetBSD core "procinfo" structure. */
11707 return _("NetBSD procinfo structure");
11710 /* As of Jan 2002 there are no other machine-independent notes
11711 defined for NetBSD core files. If the note type is less
11712 than the start of the machine-dependent note types, we don't
11715 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
11717 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11721 switch (elf_header
.e_machine
)
11723 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
11724 and PT_GETFPREGS == mach+2. */
11729 case EM_SPARC32PLUS
:
11733 case NT_NETBSDCORE_FIRSTMACH
+ 0:
11734 return _("PT_GETREGS (reg structure)");
11735 case NT_NETBSDCORE_FIRSTMACH
+ 2:
11736 return _("PT_GETFPREGS (fpreg structure)");
11742 /* On all other arch's, PT_GETREGS == mach+1 and
11743 PT_GETFPREGS == mach+3. */
11747 case NT_NETBSDCORE_FIRSTMACH
+ 1:
11748 return _("PT_GETREGS (reg structure)");
11749 case NT_NETBSDCORE_FIRSTMACH
+ 3:
11750 return _("PT_GETFPREGS (fpreg structure)");
11756 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
11757 e_type
- NT_NETBSDCORE_FIRSTMACH
);
11761 /* Note that by the ELF standard, the name field is already null byte
11762 terminated, and namesz includes the terminating null byte.
11763 I.E. the value of namesz for the name "FSF" is 4.
11765 If the value of namesz is zero, there is no name present. */
11767 process_note (Elf_Internal_Note
* pnote
)
11769 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
11772 if (pnote
->namesz
== 0)
11773 /* If there is no note name, then use the default set of
11774 note type strings. */
11775 nt
= get_note_type (pnote
->type
);
11777 else if (const_strneq (pnote
->namedata
, "GNU"))
11778 /* GNU-specific object file notes. */
11779 nt
= get_gnu_elf_note_type (pnote
->type
);
11781 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
11782 /* NetBSD-specific core file notes. */
11783 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
11785 else if (strneq (pnote
->namedata
, "SPU/", 4))
11787 /* SPU-specific core file notes. */
11788 nt
= pnote
->namedata
+ 4;
11793 /* Don't recognize this note name; just use the default set of
11794 note type strings. */
11795 nt
= get_note_type (pnote
->type
);
11797 printf (" %s\t\t0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
11803 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
11805 Elf_External_Note
* pnotes
;
11806 Elf_External_Note
* external
;
11812 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
11819 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
11820 (unsigned long) offset
, (unsigned long) length
);
11821 printf (_(" Owner\t\tData size\tDescription\n"));
11823 while (external
< (Elf_External_Note
*) ((char *) pnotes
+ length
))
11825 Elf_External_Note
* next
;
11826 Elf_Internal_Note inote
;
11827 char * temp
= NULL
;
11829 inote
.type
= BYTE_GET (external
->type
);
11830 inote
.namesz
= BYTE_GET (external
->namesz
);
11831 inote
.namedata
= external
->name
;
11832 inote
.descsz
= BYTE_GET (external
->descsz
);
11833 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
11834 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
11836 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
11838 if (((char *) next
) > (((char *) pnotes
) + length
))
11840 warn (_("corrupt note found at offset %lx into core notes\n"),
11841 (unsigned long) ((char *) external
- (char *) pnotes
));
11842 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
11843 inote
.type
, inote
.namesz
, inote
.descsz
);
11849 /* Verify that name is null terminated. It appears that at least
11850 one version of Linux (RedHat 6.0) generates corefiles that don't
11851 comply with the ELF spec by failing to include the null byte in
11853 if (inote
.namedata
[inote
.namesz
] != '\0')
11855 temp
= (char *) malloc (inote
.namesz
+ 1);
11859 error (_("Out of memory\n"));
11864 strncpy (temp
, inote
.namedata
, inote
.namesz
);
11865 temp
[inote
.namesz
] = 0;
11867 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
11868 inote
.namedata
= temp
;
11871 res
&= process_note (& inote
);
11886 process_corefile_note_segments (FILE * file
)
11888 Elf_Internal_Phdr
* segment
;
11892 if (! get_program_headers (file
))
11895 for (i
= 0, segment
= program_headers
;
11896 i
< elf_header
.e_phnum
;
11899 if (segment
->p_type
== PT_NOTE
)
11900 res
&= process_corefile_note_segment (file
,
11901 (bfd_vma
) segment
->p_offset
,
11902 (bfd_vma
) segment
->p_filesz
);
11909 process_note_sections (FILE * file
)
11911 Elf_Internal_Shdr
* section
;
11915 for (i
= 0, section
= section_headers
;
11916 i
< elf_header
.e_shnum
;
11918 if (section
->sh_type
== SHT_NOTE
)
11919 res
&= process_corefile_note_segment (file
,
11920 (bfd_vma
) section
->sh_offset
,
11921 (bfd_vma
) section
->sh_size
);
11927 process_notes (FILE * file
)
11929 /* If we have not been asked to display the notes then do nothing. */
11933 if (elf_header
.e_type
!= ET_CORE
)
11934 return process_note_sections (file
);
11936 /* No program headers means no NOTE segment. */
11937 if (elf_header
.e_phnum
> 0)
11938 return process_corefile_note_segments (file
);
11940 printf (_("No note segments present in the core file.\n"));
11945 process_arch_specific (FILE * file
)
11950 switch (elf_header
.e_machine
)
11953 return process_arm_specific (file
);
11955 case EM_MIPS_RS3_LE
:
11956 return process_mips_specific (file
);
11959 return process_power_specific (file
);
11962 return process_tic6x_specific (file
);
11971 get_file_header (FILE * file
)
11973 /* Read in the identity array. */
11974 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
11977 /* Determine how to read the rest of the header. */
11978 switch (elf_header
.e_ident
[EI_DATA
])
11980 default: /* fall through */
11981 case ELFDATANONE
: /* fall through */
11983 byte_get
= byte_get_little_endian
;
11984 byte_put
= byte_put_little_endian
;
11987 byte_get
= byte_get_big_endian
;
11988 byte_put
= byte_put_big_endian
;
11992 /* For now we only support 32 bit and 64 bit ELF files. */
11993 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
11995 /* Read in the rest of the header. */
11998 Elf32_External_Ehdr ehdr32
;
12000 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
12003 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
12004 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
12005 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
12006 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
12007 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
12008 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
12009 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
12010 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
12011 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
12012 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
12013 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
12014 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
12015 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
12019 Elf64_External_Ehdr ehdr64
;
12021 /* If we have been compiled with sizeof (bfd_vma) == 4, then
12022 we will not be able to cope with the 64bit data found in
12023 64 ELF files. Detect this now and abort before we start
12024 overwriting things. */
12025 if (sizeof (bfd_vma
) < 8)
12027 error (_("This instance of readelf has been built without support for a\n\
12028 64 bit data type and so it cannot read 64 bit ELF files.\n"));
12032 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
12035 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
12036 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
12037 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
12038 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
12039 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
12040 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
12041 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
12042 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
12043 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
12044 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
12045 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
12046 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
12047 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
12050 if (elf_header
.e_shoff
)
12052 /* There may be some extensions in the first section header. Don't
12053 bomb if we can't read it. */
12055 get_32bit_section_headers (file
, 1);
12057 get_64bit_section_headers (file
, 1);
12063 /* Process one ELF object file according to the command line options.
12064 This file may actually be stored in an archive. The file is
12065 positioned at the start of the ELF object. */
12068 process_object (char * file_name
, FILE * file
)
12072 if (! get_file_header (file
))
12074 error (_("%s: Failed to read file header\n"), file_name
);
12078 /* Initialise per file variables. */
12079 for (i
= ARRAY_SIZE (version_info
); i
--;)
12080 version_info
[i
] = 0;
12082 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
12083 dynamic_info
[i
] = 0;
12085 /* Process the file. */
12087 printf (_("\nFile: %s\n"), file_name
);
12089 /* Initialise the dump_sects array from the cmdline_dump_sects array.
12090 Note we do this even if cmdline_dump_sects is empty because we
12091 must make sure that the dump_sets array is zeroed out before each
12092 object file is processed. */
12093 if (num_dump_sects
> num_cmdline_dump_sects
)
12094 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
12096 if (num_cmdline_dump_sects
> 0)
12098 if (num_dump_sects
== 0)
12099 /* A sneaky way of allocating the dump_sects array. */
12100 request_dump_bynumber (num_cmdline_dump_sects
, 0);
12102 assert (num_dump_sects
>= num_cmdline_dump_sects
);
12103 memcpy (dump_sects
, cmdline_dump_sects
,
12104 num_cmdline_dump_sects
* sizeof (* dump_sects
));
12107 if (! process_file_header ())
12110 if (! process_section_headers (file
))
12112 /* Without loaded section headers we cannot process lots of
12114 do_unwind
= do_version
= do_dump
= do_arch
= 0;
12116 if (! do_using_dynamic
)
12117 do_syms
= do_dyn_syms
= do_reloc
= 0;
12120 if (! process_section_groups (file
))
12122 /* Without loaded section groups we cannot process unwind. */
12126 if (process_program_headers (file
))
12127 process_dynamic_section (file
);
12129 process_relocs (file
);
12131 process_unwind (file
);
12133 process_symbol_table (file
);
12135 process_syminfo (file
);
12137 process_version_sections (file
);
12139 process_section_contents (file
);
12141 process_notes (file
);
12143 process_gnu_liblist (file
);
12145 process_arch_specific (file
);
12147 if (program_headers
)
12149 free (program_headers
);
12150 program_headers
= NULL
;
12153 if (section_headers
)
12155 free (section_headers
);
12156 section_headers
= NULL
;
12161 free (string_table
);
12162 string_table
= NULL
;
12163 string_table_length
= 0;
12166 if (dynamic_strings
)
12168 free (dynamic_strings
);
12169 dynamic_strings
= NULL
;
12170 dynamic_strings_length
= 0;
12173 if (dynamic_symbols
)
12175 free (dynamic_symbols
);
12176 dynamic_symbols
= NULL
;
12177 num_dynamic_syms
= 0;
12180 if (dynamic_syminfo
)
12182 free (dynamic_syminfo
);
12183 dynamic_syminfo
= NULL
;
12186 if (section_headers_groups
)
12188 free (section_headers_groups
);
12189 section_headers_groups
= NULL
;
12192 if (section_groups
)
12194 struct group_list
* g
;
12195 struct group_list
* next
;
12197 for (i
= 0; i
< group_count
; i
++)
12199 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
12206 free (section_groups
);
12207 section_groups
= NULL
;
12210 free_debug_memory ();
12215 /* Return the path name for a proxy entry in a thin archive, adjusted relative
12216 to the path name of the thin archive itself if necessary. Always returns
12217 a pointer to malloc'ed memory. */
12220 adjust_relative_path (char * file_name
, char * name
, int name_len
)
12222 char * member_file_name
;
12223 const char * base_name
= lbasename (file_name
);
12225 /* This is a proxy entry for a thin archive member.
12226 If the extended name table contains an absolute path
12227 name, or if the archive is in the current directory,
12228 use the path name as given. Otherwise, we need to
12229 find the member relative to the directory where the
12230 archive is located. */
12231 if (IS_ABSOLUTE_PATH (name
) || base_name
== file_name
)
12233 member_file_name
= (char *) malloc (name_len
+ 1);
12234 if (member_file_name
== NULL
)
12236 error (_("Out of memory\n"));
12239 memcpy (member_file_name
, name
, name_len
);
12240 member_file_name
[name_len
] = '\0';
12244 /* Concatenate the path components of the archive file name
12245 to the relative path name from the extended name table. */
12246 size_t prefix_len
= base_name
- file_name
;
12247 member_file_name
= (char *) malloc (prefix_len
+ name_len
+ 1);
12248 if (member_file_name
== NULL
)
12250 error (_("Out of memory\n"));
12253 memcpy (member_file_name
, file_name
, prefix_len
);
12254 memcpy (member_file_name
+ prefix_len
, name
, name_len
);
12255 member_file_name
[prefix_len
+ name_len
] = '\0';
12257 return member_file_name
;
12260 /* Structure to hold information about an archive file. */
12262 struct archive_info
12264 char * file_name
; /* Archive file name. */
12265 FILE * file
; /* Open file descriptor. */
12266 unsigned long index_num
; /* Number of symbols in table. */
12267 unsigned long * index_array
; /* The array of member offsets. */
12268 char * sym_table
; /* The symbol table. */
12269 unsigned long sym_size
; /* Size of the symbol table. */
12270 char * longnames
; /* The long file names table. */
12271 unsigned long longnames_size
; /* Size of the long file names table. */
12272 unsigned long nested_member_origin
; /* Origin in the nested archive of the current member. */
12273 unsigned long next_arhdr_offset
; /* Offset of the next archive header. */
12274 bfd_boolean is_thin_archive
; /* TRUE if this is a thin archive. */
12275 struct ar_hdr arhdr
; /* Current archive header. */
12278 /* Read the symbol table and long-name table from an archive. */
12281 setup_archive (struct archive_info
* arch
, char * file_name
, FILE * file
,
12282 bfd_boolean is_thin_archive
, bfd_boolean read_symbols
)
12285 unsigned long size
;
12287 arch
->file_name
= strdup (file_name
);
12289 arch
->index_num
= 0;
12290 arch
->index_array
= NULL
;
12291 arch
->sym_table
= NULL
;
12292 arch
->sym_size
= 0;
12293 arch
->longnames
= NULL
;
12294 arch
->longnames_size
= 0;
12295 arch
->nested_member_origin
= 0;
12296 arch
->is_thin_archive
= is_thin_archive
;
12297 arch
->next_arhdr_offset
= SARMAG
;
12299 /* Read the first archive member header. */
12300 if (fseek (file
, SARMAG
, SEEK_SET
) != 0)
12302 error (_("%s: failed to seek to first archive header\n"), file_name
);
12305 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
12306 if (got
!= sizeof arch
->arhdr
)
12311 error (_("%s: failed to read archive header\n"), file_name
);
12315 /* See if this is the archive symbol table. */
12316 if (const_strneq (arch
->arhdr
.ar_name
, "/ ")
12317 || const_strneq (arch
->arhdr
.ar_name
, "/SYM64/ "))
12319 size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
12320 size
= size
+ (size
& 1);
12322 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ size
;
12327 /* A buffer used to hold numbers read in from an archive index.
12328 These are always 4 bytes long and stored in big-endian format. */
12329 #define SIZEOF_AR_INDEX_NUMBERS 4
12330 unsigned char integer_buffer
[SIZEOF_AR_INDEX_NUMBERS
];
12331 unsigned char * index_buffer
;
12333 /* Check the size of the archive index. */
12334 if (size
< SIZEOF_AR_INDEX_NUMBERS
)
12336 error (_("%s: the archive index is empty\n"), file_name
);
12340 /* Read the numer of entries in the archive index. */
12341 got
= fread (integer_buffer
, 1, sizeof integer_buffer
, file
);
12342 if (got
!= sizeof (integer_buffer
))
12344 error (_("%s: failed to read archive index\n"), file_name
);
12347 arch
->index_num
= byte_get_big_endian (integer_buffer
, sizeof integer_buffer
);
12348 size
-= SIZEOF_AR_INDEX_NUMBERS
;
12350 /* Read in the archive index. */
12351 if (size
< arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
)
12353 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
12354 file_name
, arch
->index_num
);
12357 index_buffer
= (unsigned char *)
12358 malloc (arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
);
12359 if (index_buffer
== NULL
)
12361 error (_("Out of memory whilst trying to read archive symbol index\n"));
12364 got
= fread (index_buffer
, SIZEOF_AR_INDEX_NUMBERS
, arch
->index_num
, file
);
12365 if (got
!= arch
->index_num
)
12367 free (index_buffer
);
12368 error (_("%s: failed to read archive index\n"), file_name
);
12371 size
-= arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
;
12373 /* Convert the index numbers into the host's numeric format. */
12374 arch
->index_array
= (long unsigned int *)
12375 malloc (arch
->index_num
* sizeof (* arch
->index_array
));
12376 if (arch
->index_array
== NULL
)
12378 free (index_buffer
);
12379 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
12383 for (i
= 0; i
< arch
->index_num
; i
++)
12384 arch
->index_array
[i
] = byte_get_big_endian ((unsigned char *) (index_buffer
+ (i
* SIZEOF_AR_INDEX_NUMBERS
)),
12385 SIZEOF_AR_INDEX_NUMBERS
);
12386 free (index_buffer
);
12388 /* The remaining space in the header is taken up by the symbol table. */
12391 error (_("%s: the archive has an index but no symbols\n"), file_name
);
12394 arch
->sym_table
= (char *) malloc (size
);
12395 arch
->sym_size
= size
;
12396 if (arch
->sym_table
== NULL
)
12398 error (_("Out of memory whilst trying to read archive index symbol table\n"));
12401 got
= fread (arch
->sym_table
, 1, size
, file
);
12404 error (_("%s: failed to read archive index symbol table\n"), file_name
);
12410 if (fseek (file
, size
, SEEK_CUR
) != 0)
12412 error (_("%s: failed to skip archive symbol table\n"), file_name
);
12417 /* Read the next archive header. */
12418 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
12419 if (got
!= sizeof arch
->arhdr
)
12423 error (_("%s: failed to read archive header following archive index\n"), file_name
);
12427 else if (read_symbols
)
12428 printf (_("%s has no archive index\n"), file_name
);
12430 if (const_strneq (arch
->arhdr
.ar_name
, "// "))
12432 /* This is the archive string table holding long member names. */
12433 arch
->longnames_size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
12434 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ arch
->longnames_size
;
12436 arch
->longnames
= (char *) malloc (arch
->longnames_size
);
12437 if (arch
->longnames
== NULL
)
12439 error (_("Out of memory reading long symbol names in archive\n"));
12443 if (fread (arch
->longnames
, arch
->longnames_size
, 1, file
) != 1)
12445 free (arch
->longnames
);
12446 arch
->longnames
= NULL
;
12447 error (_("%s: failed to read long symbol name string table\n"), file_name
);
12451 if ((arch
->longnames_size
& 1) != 0)
12458 /* Release the memory used for the archive information. */
12461 release_archive (struct archive_info
* arch
)
12463 if (arch
->file_name
!= NULL
)
12464 free (arch
->file_name
);
12465 if (arch
->index_array
!= NULL
)
12466 free (arch
->index_array
);
12467 if (arch
->sym_table
!= NULL
)
12468 free (arch
->sym_table
);
12469 if (arch
->longnames
!= NULL
)
12470 free (arch
->longnames
);
12473 /* Open and setup a nested archive, if not already open. */
12476 setup_nested_archive (struct archive_info
* nested_arch
, char * member_file_name
)
12478 FILE * member_file
;
12480 /* Have we already setup this archive? */
12481 if (nested_arch
->file_name
!= NULL
12482 && streq (nested_arch
->file_name
, member_file_name
))
12485 /* Close previous file and discard cached information. */
12486 if (nested_arch
->file
!= NULL
)
12487 fclose (nested_arch
->file
);
12488 release_archive (nested_arch
);
12490 member_file
= fopen (member_file_name
, "rb");
12491 if (member_file
== NULL
)
12493 return setup_archive (nested_arch
, member_file_name
, member_file
, FALSE
, FALSE
);
12497 get_archive_member_name_at (struct archive_info
* arch
,
12498 unsigned long offset
,
12499 struct archive_info
* nested_arch
);
12501 /* Get the name of an archive member from the current archive header.
12502 For simple names, this will modify the ar_name field of the current
12503 archive header. For long names, it will return a pointer to the
12504 longnames table. For nested archives, it will open the nested archive
12505 and get the name recursively. NESTED_ARCH is a single-entry cache so
12506 we don't keep rereading the same information from a nested archive. */
12509 get_archive_member_name (struct archive_info
* arch
,
12510 struct archive_info
* nested_arch
)
12512 unsigned long j
, k
;
12514 if (arch
->arhdr
.ar_name
[0] == '/')
12516 /* We have a long name. */
12518 char * member_file_name
;
12519 char * member_name
;
12521 arch
->nested_member_origin
= 0;
12522 k
= j
= strtoul (arch
->arhdr
.ar_name
+ 1, &endp
, 10);
12523 if (arch
->is_thin_archive
&& endp
!= NULL
&& * endp
== ':')
12524 arch
->nested_member_origin
= strtoul (endp
+ 1, NULL
, 10);
12526 while ((j
< arch
->longnames_size
)
12527 && (arch
->longnames
[j
] != '\n')
12528 && (arch
->longnames
[j
] != '\0'))
12530 if (arch
->longnames
[j
-1] == '/')
12532 arch
->longnames
[j
] = '\0';
12534 if (!arch
->is_thin_archive
|| arch
->nested_member_origin
== 0)
12535 return arch
->longnames
+ k
;
12537 /* This is a proxy for a member of a nested archive.
12538 Find the name of the member in that archive. */
12539 member_file_name
= adjust_relative_path (arch
->file_name
, arch
->longnames
+ k
, j
- k
);
12540 if (member_file_name
!= NULL
12541 && setup_nested_archive (nested_arch
, member_file_name
) == 0
12542 && (member_name
= get_archive_member_name_at (nested_arch
, arch
->nested_member_origin
, NULL
)) != NULL
)
12544 free (member_file_name
);
12545 return member_name
;
12547 free (member_file_name
);
12549 /* Last resort: just return the name of the nested archive. */
12550 return arch
->longnames
+ k
;
12553 /* We have a normal (short) name. */
12555 while ((arch
->arhdr
.ar_name
[j
] != '/') && (j
< 16))
12557 arch
->arhdr
.ar_name
[j
] = '\0';
12558 return arch
->arhdr
.ar_name
;
12561 /* Get the name of an archive member at a given OFFSET within an archive ARCH. */
12564 get_archive_member_name_at (struct archive_info
* arch
,
12565 unsigned long offset
,
12566 struct archive_info
* nested_arch
)
12570 if (fseek (arch
->file
, offset
, SEEK_SET
) != 0)
12572 error (_("%s: failed to seek to next file name\n"), arch
->file_name
);
12575 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, arch
->file
);
12576 if (got
!= sizeof arch
->arhdr
)
12578 error (_("%s: failed to read archive header\n"), arch
->file_name
);
12581 if (memcmp (arch
->arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
12583 error (_("%s: did not find a valid archive header\n"), arch
->file_name
);
12587 return get_archive_member_name (arch
, nested_arch
);
12590 /* Construct a string showing the name of the archive member, qualified
12591 with the name of the containing archive file. For thin archives, we
12592 use square brackets to denote the indirection. For nested archives,
12593 we show the qualified name of the external member inside the square
12594 brackets (e.g., "thin.a[normal.a(foo.o)]"). */
12597 make_qualified_name (struct archive_info
* arch
,
12598 struct archive_info
* nested_arch
,
12599 char * member_name
)
12604 len
= strlen (arch
->file_name
) + strlen (member_name
) + 3;
12605 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
12606 len
+= strlen (nested_arch
->file_name
) + 2;
12608 name
= (char *) malloc (len
);
12611 error (_("Out of memory\n"));
12615 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
12616 snprintf (name
, len
, "%s[%s(%s)]", arch
->file_name
, nested_arch
->file_name
, member_name
);
12617 else if (arch
->is_thin_archive
)
12618 snprintf (name
, len
, "%s[%s]", arch
->file_name
, member_name
);
12620 snprintf (name
, len
, "%s(%s)", arch
->file_name
, member_name
);
12625 /* Process an ELF archive.
12626 On entry the file is positioned just after the ARMAG string. */
12629 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
12631 struct archive_info arch
;
12632 struct archive_info nested_arch
;
12638 /* The ARCH structure is used to hold information about this archive. */
12639 arch
.file_name
= NULL
;
12641 arch
.index_array
= NULL
;
12642 arch
.sym_table
= NULL
;
12643 arch
.longnames
= NULL
;
12645 /* The NESTED_ARCH structure is used as a single-item cache of information
12646 about a nested archive (when members of a thin archive reside within
12647 another regular archive file). */
12648 nested_arch
.file_name
= NULL
;
12649 nested_arch
.file
= NULL
;
12650 nested_arch
.index_array
= NULL
;
12651 nested_arch
.sym_table
= NULL
;
12652 nested_arch
.longnames
= NULL
;
12654 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
12660 if (do_archive_index
)
12662 if (arch
.sym_table
== NULL
)
12663 error (_("%s: unable to dump the index as none was found\n"), file_name
);
12667 unsigned long current_pos
;
12669 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
12670 file_name
, arch
.index_num
, arch
.sym_size
);
12671 current_pos
= ftell (file
);
12673 for (i
= l
= 0; i
< arch
.index_num
; i
++)
12675 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
12677 char * member_name
;
12679 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
12681 if (member_name
!= NULL
)
12683 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
12685 if (qualified_name
!= NULL
)
12687 printf (_("Binary %s contains:\n"), qualified_name
);
12688 free (qualified_name
);
12693 if (l
>= arch
.sym_size
)
12695 error (_("%s: end of the symbol table reached before the end of the index\n"),
12699 printf ("\t%s\n", arch
.sym_table
+ l
);
12700 l
+= strlen (arch
.sym_table
+ l
) + 1;
12705 if (l
< arch
.sym_size
)
12706 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
12709 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
12711 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
12717 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
12718 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
12719 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
12720 && !do_section_groups
&& !do_dyn_syms
)
12722 ret
= 0; /* Archive index only. */
12733 char * qualified_name
;
12735 /* Read the next archive header. */
12736 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
12738 error (_("%s: failed to seek to next archive header\n"), file_name
);
12741 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
12742 if (got
!= sizeof arch
.arhdr
)
12746 error (_("%s: failed to read archive header\n"), file_name
);
12750 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
12752 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
12757 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
12759 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
12760 if (archive_file_size
& 01)
12761 ++archive_file_size
;
12763 name
= get_archive_member_name (&arch
, &nested_arch
);
12766 error (_("%s: bad archive file name\n"), file_name
);
12770 namelen
= strlen (name
);
12772 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
12773 if (qualified_name
== NULL
)
12775 error (_("%s: bad archive file name\n"), file_name
);
12780 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
12782 /* This is a proxy for an external member of a thin archive. */
12783 FILE * member_file
;
12784 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
12785 if (member_file_name
== NULL
)
12791 member_file
= fopen (member_file_name
, "rb");
12792 if (member_file
== NULL
)
12794 error (_("Input file '%s' is not readable.\n"), member_file_name
);
12795 free (member_file_name
);
12800 archive_file_offset
= arch
.nested_member_origin
;
12802 ret
|= process_object (qualified_name
, member_file
);
12804 fclose (member_file
);
12805 free (member_file_name
);
12807 else if (is_thin_archive
)
12809 /* This is a proxy for a member of a nested archive. */
12810 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
12812 /* The nested archive file will have been opened and setup by
12813 get_archive_member_name. */
12814 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
12816 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
12821 ret
|= process_object (qualified_name
, nested_arch
.file
);
12825 archive_file_offset
= arch
.next_arhdr_offset
;
12826 arch
.next_arhdr_offset
+= archive_file_size
;
12828 ret
|= process_object (qualified_name
, file
);
12831 free (qualified_name
);
12835 if (nested_arch
.file
!= NULL
)
12836 fclose (nested_arch
.file
);
12837 release_archive (&nested_arch
);
12838 release_archive (&arch
);
12844 process_file (char * file_name
)
12847 struct stat statbuf
;
12848 char armag
[SARMAG
];
12851 if (stat (file_name
, &statbuf
) < 0)
12853 if (errno
== ENOENT
)
12854 error (_("'%s': No such file\n"), file_name
);
12856 error (_("Could not locate '%s'. System error message: %s\n"),
12857 file_name
, strerror (errno
));
12861 if (! S_ISREG (statbuf
.st_mode
))
12863 error (_("'%s' is not an ordinary file\n"), file_name
);
12867 file
= fopen (file_name
, "rb");
12870 error (_("Input file '%s' is not readable.\n"), file_name
);
12874 if (fread (armag
, SARMAG
, 1, file
) != 1)
12876 error (_("%s: Failed to read file's magic number\n"), file_name
);
12881 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
12882 ret
= process_archive (file_name
, file
, FALSE
);
12883 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
12884 ret
= process_archive (file_name
, file
, TRUE
);
12887 if (do_archive_index
)
12888 error (_("File %s is not an archive so its index cannot be displayed.\n"),
12892 archive_file_size
= archive_file_offset
= 0;
12893 ret
= process_object (file_name
, file
);
12901 #ifdef SUPPORT_DISASSEMBLY
12902 /* Needed by the i386 disassembler. For extra credit, someone could
12903 fix this so that we insert symbolic addresses here, esp for GOT/PLT
12907 print_address (unsigned int addr
, FILE * outfile
)
12909 fprintf (outfile
,"0x%8.8x", addr
);
12912 /* Needed by the i386 disassembler. */
12914 db_task_printsym (unsigned int addr
)
12916 print_address (addr
, stderr
);
12921 main (int argc
, char ** argv
)
12925 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
12926 setlocale (LC_MESSAGES
, "");
12928 #if defined (HAVE_SETLOCALE)
12929 setlocale (LC_CTYPE
, "");
12931 bindtextdomain (PACKAGE
, LOCALEDIR
);
12932 textdomain (PACKAGE
);
12934 expandargv (&argc
, &argv
);
12936 parse_args (argc
, argv
);
12938 if (num_dump_sects
> 0)
12940 /* Make a copy of the dump_sects array. */
12941 cmdline_dump_sects
= (dump_type
*)
12942 malloc (num_dump_sects
* sizeof (* dump_sects
));
12943 if (cmdline_dump_sects
== NULL
)
12944 error (_("Out of memory allocating dump request table.\n"));
12947 memcpy (cmdline_dump_sects
, dump_sects
,
12948 num_dump_sects
* sizeof (* dump_sects
));
12949 num_cmdline_dump_sects
= num_dump_sects
;
12953 if (optind
< (argc
- 1))
12957 while (optind
< argc
)
12958 err
|= process_file (argv
[optind
++]);
12960 if (dump_sects
!= NULL
)
12962 if (cmdline_dump_sects
!= NULL
)
12963 free (cmdline_dump_sects
);