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
)
2356 strcat (buf
, ", v850e1");
2359 strcat (buf
, ", v850e");
2362 strcat (buf
, ", v850");
2365 strcat (buf
, _(", unknown v850 architecture variant"));
2371 case EM_CYGNUS_M32R
:
2372 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2373 strcat (buf
, ", m32r");
2377 case EM_MIPS_RS3_LE
:
2378 if (e_flags
& EF_MIPS_NOREORDER
)
2379 strcat (buf
, ", noreorder");
2381 if (e_flags
& EF_MIPS_PIC
)
2382 strcat (buf
, ", pic");
2384 if (e_flags
& EF_MIPS_CPIC
)
2385 strcat (buf
, ", cpic");
2387 if (e_flags
& EF_MIPS_UCODE
)
2388 strcat (buf
, ", ugen_reserved");
2390 if (e_flags
& EF_MIPS_ABI2
)
2391 strcat (buf
, ", abi2");
2393 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2394 strcat (buf
, ", odk first");
2396 if (e_flags
& EF_MIPS_32BITMODE
)
2397 strcat (buf
, ", 32bitmode");
2399 switch ((e_flags
& EF_MIPS_MACH
))
2401 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2402 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2403 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2404 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2405 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2406 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2407 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2408 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2409 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2410 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2411 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2412 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2413 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2414 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
2415 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
2417 /* We simply ignore the field in this case to avoid confusion:
2418 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2421 default: strcat (buf
, _(", unknown CPU")); break;
2424 switch ((e_flags
& EF_MIPS_ABI
))
2426 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2427 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2428 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2429 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2431 /* We simply ignore the field in this case to avoid confusion:
2432 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2433 This means it is likely to be an o32 file, but not for
2436 default: strcat (buf
, _(", unknown ABI")); break;
2439 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2440 strcat (buf
, ", mdmx");
2442 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2443 strcat (buf
, ", mips16");
2445 switch ((e_flags
& EF_MIPS_ARCH
))
2447 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2448 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2449 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2450 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2451 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2452 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2453 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2454 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2455 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2456 default: strcat (buf
, _(", unknown ISA")); break;
2459 if (e_flags
& EF_SH_PIC
)
2460 strcat (buf
, ", pic");
2462 if (e_flags
& EF_SH_FDPIC
)
2463 strcat (buf
, ", fdpic");
2467 switch ((e_flags
& EF_SH_MACH_MASK
))
2469 case EF_SH1
: strcat (buf
, ", sh1"); break;
2470 case EF_SH2
: strcat (buf
, ", sh2"); break;
2471 case EF_SH3
: strcat (buf
, ", sh3"); break;
2472 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2473 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2474 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2475 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2476 case EF_SH4
: strcat (buf
, ", sh4"); break;
2477 case EF_SH5
: strcat (buf
, ", sh5"); break;
2478 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2479 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2480 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2481 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2482 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2483 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2484 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2485 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2486 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2487 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2488 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2489 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2490 default: strcat (buf
, _(", unknown ISA")); break;
2496 if (e_flags
& EF_SPARC_32PLUS
)
2497 strcat (buf
, ", v8+");
2499 if (e_flags
& EF_SPARC_SUN_US1
)
2500 strcat (buf
, ", ultrasparcI");
2502 if (e_flags
& EF_SPARC_SUN_US3
)
2503 strcat (buf
, ", ultrasparcIII");
2505 if (e_flags
& EF_SPARC_HAL_R1
)
2506 strcat (buf
, ", halr1");
2508 if (e_flags
& EF_SPARC_LEDATA
)
2509 strcat (buf
, ", ledata");
2511 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2512 strcat (buf
, ", tso");
2514 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2515 strcat (buf
, ", pso");
2517 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2518 strcat (buf
, ", rmo");
2522 switch (e_flags
& EF_PARISC_ARCH
)
2524 case EFA_PARISC_1_0
:
2525 strcpy (buf
, ", PA-RISC 1.0");
2527 case EFA_PARISC_1_1
:
2528 strcpy (buf
, ", PA-RISC 1.1");
2530 case EFA_PARISC_2_0
:
2531 strcpy (buf
, ", PA-RISC 2.0");
2536 if (e_flags
& EF_PARISC_TRAPNIL
)
2537 strcat (buf
, ", trapnil");
2538 if (e_flags
& EF_PARISC_EXT
)
2539 strcat (buf
, ", ext");
2540 if (e_flags
& EF_PARISC_LSB
)
2541 strcat (buf
, ", lsb");
2542 if (e_flags
& EF_PARISC_WIDE
)
2543 strcat (buf
, ", wide");
2544 if (e_flags
& EF_PARISC_NO_KABP
)
2545 strcat (buf
, ", no kabp");
2546 if (e_flags
& EF_PARISC_LAZYSWAP
)
2547 strcat (buf
, ", lazyswap");
2552 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2553 strcat (buf
, ", new calling convention");
2555 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2556 strcat (buf
, ", gnu calling convention");
2560 if ((e_flags
& EF_IA_64_ABI64
))
2561 strcat (buf
, ", 64-bit");
2563 strcat (buf
, ", 32-bit");
2564 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2565 strcat (buf
, ", reduced fp model");
2566 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2567 strcat (buf
, ", no function descriptors, constant gp");
2568 else if ((e_flags
& EF_IA_64_CONS_GP
))
2569 strcat (buf
, ", constant gp");
2570 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2571 strcat (buf
, ", absolute");
2572 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
2574 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
2575 strcat (buf
, ", vms_linkages");
2576 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
2578 case EF_IA_64_VMS_COMCOD_SUCCESS
:
2580 case EF_IA_64_VMS_COMCOD_WARNING
:
2581 strcat (buf
, ", warning");
2583 case EF_IA_64_VMS_COMCOD_ERROR
:
2584 strcat (buf
, ", error");
2586 case EF_IA_64_VMS_COMCOD_ABORT
:
2587 strcat (buf
, ", abort");
2596 if ((e_flags
& EF_VAX_NONPIC
))
2597 strcat (buf
, ", non-PIC");
2598 if ((e_flags
& EF_VAX_DFLOAT
))
2599 strcat (buf
, ", D-Float");
2600 if ((e_flags
& EF_VAX_GFLOAT
))
2601 strcat (buf
, ", G-Float");
2605 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
2606 strcat (buf
, ", 64-bit doubles");
2607 if (e_flags
& E_FLAG_RX_DSP
)
2608 strcat (buf
, ", dsp");
2611 if (e_flags
& EF_S390_HIGH_GPRS
)
2612 strcat (buf
, ", highgprs");
2615 if ((e_flags
& EF_C6000_REL
))
2616 strcat (buf
, ", relocatable module");
2624 get_osabi_name (unsigned int osabi
)
2626 static char buff
[32];
2630 case ELFOSABI_NONE
: return "UNIX - System V";
2631 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2632 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2633 case ELFOSABI_LINUX
: return "UNIX - Linux";
2634 case ELFOSABI_HURD
: return "GNU/Hurd";
2635 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2636 case ELFOSABI_AIX
: return "UNIX - AIX";
2637 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2638 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2639 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2640 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2641 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2642 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2643 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2644 case ELFOSABI_AROS
: return "AROS";
2645 case ELFOSABI_FENIXOS
: return "FenixOS";
2648 switch (elf_header
.e_machine
)
2653 case ELFOSABI_ARM
: return "ARM";
2663 case ELFOSABI_STANDALONE
: return _("Standalone App");
2672 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
2673 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
2682 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2688 get_arm_segment_type (unsigned long type
)
2702 get_mips_segment_type (unsigned long type
)
2706 case PT_MIPS_REGINFO
:
2708 case PT_MIPS_RTPROC
:
2710 case PT_MIPS_OPTIONS
:
2720 get_parisc_segment_type (unsigned long type
)
2724 case PT_HP_TLS
: return "HP_TLS";
2725 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2726 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2727 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2728 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2729 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2730 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2731 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2732 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2733 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2734 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2735 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2736 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2737 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2738 case PT_HP_STACK
: return "HP_STACK";
2739 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2740 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2741 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2742 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2751 get_ia64_segment_type (unsigned long type
)
2755 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2756 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2757 case PT_HP_TLS
: return "HP_TLS";
2758 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2759 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2760 case PT_IA_64_HP_STACK
: return "HP_STACK";
2769 get_tic6x_segment_type (unsigned long type
)
2773 case PT_C6000_PHATTR
: return "C6000_PHATTR";
2782 get_segment_type (unsigned long p_type
)
2784 static char buff
[32];
2788 case PT_NULL
: return "NULL";
2789 case PT_LOAD
: return "LOAD";
2790 case PT_DYNAMIC
: return "DYNAMIC";
2791 case PT_INTERP
: return "INTERP";
2792 case PT_NOTE
: return "NOTE";
2793 case PT_SHLIB
: return "SHLIB";
2794 case PT_PHDR
: return "PHDR";
2795 case PT_TLS
: return "TLS";
2797 case PT_GNU_EH_FRAME
:
2798 return "GNU_EH_FRAME";
2799 case PT_GNU_STACK
: return "GNU_STACK";
2800 case PT_GNU_RELRO
: return "GNU_RELRO";
2803 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2805 const char * result
;
2807 switch (elf_header
.e_machine
)
2810 result
= get_arm_segment_type (p_type
);
2813 case EM_MIPS_RS3_LE
:
2814 result
= get_mips_segment_type (p_type
);
2817 result
= get_parisc_segment_type (p_type
);
2820 result
= get_ia64_segment_type (p_type
);
2823 result
= get_tic6x_segment_type (p_type
);
2833 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2835 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2837 const char * result
;
2839 switch (elf_header
.e_machine
)
2842 result
= get_parisc_segment_type (p_type
);
2845 result
= get_ia64_segment_type (p_type
);
2855 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2858 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2865 get_mips_section_type_name (unsigned int sh_type
)
2869 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2870 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2871 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2872 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2873 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2874 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2875 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2876 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2877 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2878 case SHT_MIPS_RELD
: return "MIPS_RELD";
2879 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2880 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2881 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2882 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2883 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2884 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2885 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2886 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2887 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2888 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2889 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2890 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2891 case SHT_MIPS_LINE
: return "MIPS_LINE";
2892 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2893 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2894 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2895 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2896 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2897 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2898 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2899 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2900 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2901 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2902 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2903 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2904 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2905 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2906 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2907 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2915 get_parisc_section_type_name (unsigned int sh_type
)
2919 case SHT_PARISC_EXT
: return "PARISC_EXT";
2920 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2921 case SHT_PARISC_DOC
: return "PARISC_DOC";
2922 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2923 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2924 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2925 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2933 get_ia64_section_type_name (unsigned int sh_type
)
2935 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2936 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2937 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2941 case SHT_IA_64_EXT
: return "IA_64_EXT";
2942 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2943 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2944 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
2945 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
2946 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
2947 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
2948 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
2949 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
2950 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
2958 get_x86_64_section_type_name (unsigned int sh_type
)
2962 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2970 get_arm_section_type_name (unsigned int sh_type
)
2974 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
2975 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
2976 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
2977 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
2978 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
2986 get_tic6x_section_type_name (unsigned int sh_type
)
2990 case SHT_C6000_UNWIND
:
2991 return "C6000_UNWIND";
2992 case SHT_C6000_PREEMPTMAP
:
2993 return "C6000_PREEMPTMAP";
2994 case SHT_C6000_ATTRIBUTES
:
2995 return "C6000_ATTRIBUTES";
3000 case SHT_TI_HANDLER
:
3001 return "TI_HANDLER";
3002 case SHT_TI_INITINFO
:
3003 return "TI_INITINFO";
3004 case SHT_TI_PHATTRS
:
3005 return "TI_PHATTRS";
3013 get_section_type_name (unsigned int sh_type
)
3015 static char buff
[32];
3019 case SHT_NULL
: return "NULL";
3020 case SHT_PROGBITS
: return "PROGBITS";
3021 case SHT_SYMTAB
: return "SYMTAB";
3022 case SHT_STRTAB
: return "STRTAB";
3023 case SHT_RELA
: return "RELA";
3024 case SHT_HASH
: return "HASH";
3025 case SHT_DYNAMIC
: return "DYNAMIC";
3026 case SHT_NOTE
: return "NOTE";
3027 case SHT_NOBITS
: return "NOBITS";
3028 case SHT_REL
: return "REL";
3029 case SHT_SHLIB
: return "SHLIB";
3030 case SHT_DYNSYM
: return "DYNSYM";
3031 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
3032 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
3033 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
3034 case SHT_GNU_HASH
: return "GNU_HASH";
3035 case SHT_GROUP
: return "GROUP";
3036 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
3037 case SHT_GNU_verdef
: return "VERDEF";
3038 case SHT_GNU_verneed
: return "VERNEED";
3039 case SHT_GNU_versym
: return "VERSYM";
3040 case 0x6ffffff0: return "VERSYM";
3041 case 0x6ffffffc: return "VERDEF";
3042 case 0x7ffffffd: return "AUXILIARY";
3043 case 0x7fffffff: return "FILTER";
3044 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
3047 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
3049 const char * result
;
3051 switch (elf_header
.e_machine
)
3054 case EM_MIPS_RS3_LE
:
3055 result
= get_mips_section_type_name (sh_type
);
3058 result
= get_parisc_section_type_name (sh_type
);
3061 result
= get_ia64_section_type_name (sh_type
);
3065 result
= get_x86_64_section_type_name (sh_type
);
3068 result
= get_arm_section_type_name (sh_type
);
3071 result
= get_tic6x_section_type_name (sh_type
);
3081 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
3083 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
3085 const char * result
;
3087 switch (elf_header
.e_machine
)
3090 result
= get_ia64_section_type_name (sh_type
);
3100 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
3102 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
3103 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
3105 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
3111 #define OPTION_DEBUG_DUMP 512
3112 #define OPTION_DYN_SYMS 513
3114 static struct option options
[] =
3116 {"all", no_argument
, 0, 'a'},
3117 {"file-header", no_argument
, 0, 'h'},
3118 {"program-headers", no_argument
, 0, 'l'},
3119 {"headers", no_argument
, 0, 'e'},
3120 {"histogram", no_argument
, 0, 'I'},
3121 {"segments", no_argument
, 0, 'l'},
3122 {"sections", no_argument
, 0, 'S'},
3123 {"section-headers", no_argument
, 0, 'S'},
3124 {"section-groups", no_argument
, 0, 'g'},
3125 {"section-details", no_argument
, 0, 't'},
3126 {"full-section-name",no_argument
, 0, 'N'},
3127 {"symbols", no_argument
, 0, 's'},
3128 {"syms", no_argument
, 0, 's'},
3129 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
3130 {"relocs", no_argument
, 0, 'r'},
3131 {"notes", no_argument
, 0, 'n'},
3132 {"dynamic", no_argument
, 0, 'd'},
3133 {"arch-specific", no_argument
, 0, 'A'},
3134 {"version-info", no_argument
, 0, 'V'},
3135 {"use-dynamic", no_argument
, 0, 'D'},
3136 {"unwind", no_argument
, 0, 'u'},
3137 {"archive-index", no_argument
, 0, 'c'},
3138 {"hex-dump", required_argument
, 0, 'x'},
3139 {"relocated-dump", required_argument
, 0, 'R'},
3140 {"string-dump", required_argument
, 0, 'p'},
3141 #ifdef SUPPORT_DISASSEMBLY
3142 {"instruction-dump", required_argument
, 0, 'i'},
3144 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
3146 {"version", no_argument
, 0, 'v'},
3147 {"wide", no_argument
, 0, 'W'},
3148 {"help", no_argument
, 0, 'H'},
3149 {0, no_argument
, 0, 0}
3153 usage (FILE * stream
)
3155 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
3156 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
3157 fprintf (stream
, _(" Options are:\n\
3158 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3159 -h --file-header Display the ELF file header\n\
3160 -l --program-headers Display the program headers\n\
3161 --segments An alias for --program-headers\n\
3162 -S --section-headers Display the sections' header\n\
3163 --sections An alias for --section-headers\n\
3164 -g --section-groups Display the section groups\n\
3165 -t --section-details Display the section details\n\
3166 -e --headers Equivalent to: -h -l -S\n\
3167 -s --syms Display the symbol table\n\
3168 --symbols An alias for --syms\n\
3169 --dyn-syms Display the dynamic symbol table\n\
3170 -n --notes Display the core notes (if present)\n\
3171 -r --relocs Display the relocations (if present)\n\
3172 -u --unwind Display the unwind info (if present)\n\
3173 -d --dynamic Display the dynamic section (if present)\n\
3174 -V --version-info Display the version sections (if present)\n\
3175 -A --arch-specific Display architecture specific information (if any).\n\
3176 -c --archive-index Display the symbol/file index in an archive\n\
3177 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3178 -x --hex-dump=<number|name>\n\
3179 Dump the contents of section <number|name> as bytes\n\
3180 -p --string-dump=<number|name>\n\
3181 Dump the contents of section <number|name> as strings\n\
3182 -R --relocated-dump=<number|name>\n\
3183 Dump the contents of section <number|name> as relocated bytes\n\
3184 -w[lLiaprmfFsoRt] or\n\
3185 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3186 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3187 =trace_info,=trace_abbrev,=trace_aranges]\n\
3188 Display the contents of DWARF2 debug sections\n"));
3189 #ifdef SUPPORT_DISASSEMBLY
3190 fprintf (stream
, _("\
3191 -i --instruction-dump=<number|name>\n\
3192 Disassemble the contents of section <number|name>\n"));
3194 fprintf (stream
, _("\
3195 -I --histogram Display histogram of bucket list lengths\n\
3196 -W --wide Allow output width to exceed 80 characters\n\
3197 @<file> Read options from <file>\n\
3198 -H --help Display this information\n\
3199 -v --version Display the version number of readelf\n"));
3201 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3202 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
3204 exit (stream
== stdout
? 0 : 1);
3207 /* Record the fact that the user wants the contents of section number
3208 SECTION to be displayed using the method(s) encoded as flags bits
3209 in TYPE. Note, TYPE can be zero if we are creating the array for
3213 request_dump_bynumber (unsigned int section
, dump_type type
)
3215 if (section
>= num_dump_sects
)
3217 dump_type
* new_dump_sects
;
3219 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
3220 sizeof (* dump_sects
));
3222 if (new_dump_sects
== NULL
)
3223 error (_("Out of memory allocating dump request table.\n"));
3226 /* Copy current flag settings. */
3227 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
3231 dump_sects
= new_dump_sects
;
3232 num_dump_sects
= section
+ 1;
3237 dump_sects
[section
] |= type
;
3242 /* Request a dump by section name. */
3245 request_dump_byname (const char * section
, dump_type type
)
3247 struct dump_list_entry
* new_request
;
3249 new_request
= (struct dump_list_entry
*)
3250 malloc (sizeof (struct dump_list_entry
));
3252 error (_("Out of memory allocating dump request table.\n"));
3254 new_request
->name
= strdup (section
);
3255 if (!new_request
->name
)
3256 error (_("Out of memory allocating dump request table.\n"));
3258 new_request
->type
= type
;
3260 new_request
->next
= dump_sects_byname
;
3261 dump_sects_byname
= new_request
;
3265 request_dump (dump_type type
)
3271 section
= strtoul (optarg
, & cp
, 0);
3273 if (! *cp
&& section
>= 0)
3274 request_dump_bynumber (section
, type
);
3276 request_dump_byname (optarg
, type
);
3281 parse_args (int argc
, char ** argv
)
3288 while ((c
= getopt_long
3289 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
3307 do_section_groups
++;
3315 do_section_groups
++;
3320 do_section_details
++;
3364 request_dump (HEX_DUMP
);
3367 request_dump (STRING_DUMP
);
3370 request_dump (RELOC_DUMP
);
3377 dwarf_select_sections_all ();
3382 dwarf_select_sections_by_letters (optarg
);
3385 case OPTION_DEBUG_DUMP
:
3392 dwarf_select_sections_by_names (optarg
);
3395 case OPTION_DYN_SYMS
:
3398 #ifdef SUPPORT_DISASSEMBLY
3400 request_dump (DISASS_DUMP
);
3404 print_version (program_name
);
3413 /* xgettext:c-format */
3414 error (_("Invalid option '-%c'\n"), c
);
3421 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3422 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3423 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3424 && !do_section_groups
&& !do_archive_index
3429 warn (_("Nothing to do.\n"));
3435 get_elf_class (unsigned int elf_class
)
3437 static char buff
[32];
3441 case ELFCLASSNONE
: return _("none");
3442 case ELFCLASS32
: return "ELF32";
3443 case ELFCLASS64
: return "ELF64";
3445 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3451 get_data_encoding (unsigned int encoding
)
3453 static char buff
[32];
3457 case ELFDATANONE
: return _("none");
3458 case ELFDATA2LSB
: return _("2's complement, little endian");
3459 case ELFDATA2MSB
: return _("2's complement, big endian");
3461 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3466 /* Decode the data held in 'elf_header'. */
3469 process_file_header (void)
3471 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3472 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3473 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3474 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3477 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3481 init_dwarf_regnames (elf_header
.e_machine
);
3487 printf (_("ELF Header:\n"));
3488 printf (_(" Magic: "));
3489 for (i
= 0; i
< EI_NIDENT
; i
++)
3490 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3492 printf (_(" Class: %s\n"),
3493 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3494 printf (_(" Data: %s\n"),
3495 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3496 printf (_(" Version: %d %s\n"),
3497 elf_header
.e_ident
[EI_VERSION
],
3498 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3500 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3501 ? _("<unknown: %lx>")
3503 printf (_(" OS/ABI: %s\n"),
3504 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3505 printf (_(" ABI Version: %d\n"),
3506 elf_header
.e_ident
[EI_ABIVERSION
]);
3507 printf (_(" Type: %s\n"),
3508 get_file_type (elf_header
.e_type
));
3509 printf (_(" Machine: %s\n"),
3510 get_machine_name (elf_header
.e_machine
));
3511 printf (_(" Version: 0x%lx\n"),
3512 (unsigned long) elf_header
.e_version
);
3514 printf (_(" Entry point address: "));
3515 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3516 printf (_("\n Start of program headers: "));
3517 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3518 printf (_(" (bytes into file)\n Start of section headers: "));
3519 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3520 printf (_(" (bytes into file)\n"));
3522 printf (_(" Flags: 0x%lx%s\n"),
3523 (unsigned long) elf_header
.e_flags
,
3524 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3525 printf (_(" Size of this header: %ld (bytes)\n"),
3526 (long) elf_header
.e_ehsize
);
3527 printf (_(" Size of program headers: %ld (bytes)\n"),
3528 (long) elf_header
.e_phentsize
);
3529 printf (_(" Number of program headers: %ld"),
3530 (long) elf_header
.e_phnum
);
3531 if (section_headers
!= NULL
3532 && elf_header
.e_phnum
== PN_XNUM
3533 && section_headers
[0].sh_info
!= 0)
3534 printf (_(" (%ld)"), (long) section_headers
[0].sh_info
);
3535 putc ('\n', stdout
);
3536 printf (_(" Size of section headers: %ld (bytes)\n"),
3537 (long) elf_header
.e_shentsize
);
3538 printf (_(" Number of section headers: %ld"),
3539 (long) elf_header
.e_shnum
);
3540 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
3541 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3542 putc ('\n', stdout
);
3543 printf (_(" Section header string table index: %ld"),
3544 (long) elf_header
.e_shstrndx
);
3545 if (section_headers
!= NULL
3546 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3547 printf (" (%u)", section_headers
[0].sh_link
);
3548 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3549 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3550 printf (_(" <corrupt: out of range>"));
3551 putc ('\n', stdout
);
3554 if (section_headers
!= NULL
)
3556 if (elf_header
.e_phnum
== PN_XNUM
3557 && section_headers
[0].sh_info
!= 0)
3558 elf_header
.e_phnum
= section_headers
[0].sh_info
;
3559 if (elf_header
.e_shnum
== SHN_UNDEF
)
3560 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3561 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3562 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3563 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3564 elf_header
.e_shstrndx
= SHN_UNDEF
;
3565 free (section_headers
);
3566 section_headers
= NULL
;
3574 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3576 Elf32_External_Phdr
* phdrs
;
3577 Elf32_External_Phdr
* external
;
3578 Elf_Internal_Phdr
* internal
;
3581 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3582 elf_header
.e_phentsize
,
3584 _("program headers"));
3588 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3589 i
< elf_header
.e_phnum
;
3590 i
++, internal
++, external
++)
3592 internal
->p_type
= BYTE_GET (external
->p_type
);
3593 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3594 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3595 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3596 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3597 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3598 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3599 internal
->p_align
= BYTE_GET (external
->p_align
);
3608 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3610 Elf64_External_Phdr
* phdrs
;
3611 Elf64_External_Phdr
* external
;
3612 Elf_Internal_Phdr
* internal
;
3615 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3616 elf_header
.e_phentsize
,
3618 _("program headers"));
3622 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3623 i
< elf_header
.e_phnum
;
3624 i
++, internal
++, external
++)
3626 internal
->p_type
= BYTE_GET (external
->p_type
);
3627 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3628 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3629 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3630 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3631 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3632 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3633 internal
->p_align
= BYTE_GET (external
->p_align
);
3641 /* Returns 1 if the program headers were read into `program_headers'. */
3644 get_program_headers (FILE * file
)
3646 Elf_Internal_Phdr
* phdrs
;
3648 /* Check cache of prior read. */
3649 if (program_headers
!= NULL
)
3652 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
3653 sizeof (Elf_Internal_Phdr
));
3657 error (_("Out of memory\n"));
3662 ? get_32bit_program_headers (file
, phdrs
)
3663 : get_64bit_program_headers (file
, phdrs
))
3665 program_headers
= phdrs
;
3673 /* Returns 1 if the program headers were loaded. */
3676 process_program_headers (FILE * file
)
3678 Elf_Internal_Phdr
* segment
;
3681 if (elf_header
.e_phnum
== 0)
3684 printf (_("\nThere are no program headers in this file.\n"));
3688 if (do_segments
&& !do_header
)
3690 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3691 printf (_("Entry point "));
3692 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3693 printf (_("\nThere are %d program headers, starting at offset "),
3694 elf_header
.e_phnum
);
3695 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3699 if (! get_program_headers (file
))
3704 if (elf_header
.e_phnum
> 1)
3705 printf (_("\nProgram Headers:\n"));
3707 printf (_("\nProgram Headers:\n"));
3711 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3714 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3718 (_(" Type Offset VirtAddr PhysAddr\n"));
3720 (_(" FileSiz MemSiz Flags Align\n"));
3727 for (i
= 0, segment
= program_headers
;
3728 i
< elf_header
.e_phnum
;
3733 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3737 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3738 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3739 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3740 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3741 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3743 (segment
->p_flags
& PF_R
? 'R' : ' '),
3744 (segment
->p_flags
& PF_W
? 'W' : ' '),
3745 (segment
->p_flags
& PF_X
? 'E' : ' '));
3746 printf ("%#lx", (unsigned long) segment
->p_align
);
3750 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3751 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3754 print_vma (segment
->p_offset
, FULL_HEX
);
3758 print_vma (segment
->p_vaddr
, FULL_HEX
);
3760 print_vma (segment
->p_paddr
, FULL_HEX
);
3763 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3764 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3767 print_vma (segment
->p_filesz
, FULL_HEX
);
3771 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3772 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3775 print_vma (segment
->p_offset
, FULL_HEX
);
3779 (segment
->p_flags
& PF_R
? 'R' : ' '),
3780 (segment
->p_flags
& PF_W
? 'W' : ' '),
3781 (segment
->p_flags
& PF_X
? 'E' : ' '));
3783 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3784 printf ("%#lx", (unsigned long) segment
->p_align
);
3787 print_vma (segment
->p_align
, PREFIX_HEX
);
3792 print_vma (segment
->p_offset
, FULL_HEX
);
3794 print_vma (segment
->p_vaddr
, FULL_HEX
);
3796 print_vma (segment
->p_paddr
, FULL_HEX
);
3798 print_vma (segment
->p_filesz
, FULL_HEX
);
3800 print_vma (segment
->p_memsz
, FULL_HEX
);
3802 (segment
->p_flags
& PF_R
? 'R' : ' '),
3803 (segment
->p_flags
& PF_W
? 'W' : ' '),
3804 (segment
->p_flags
& PF_X
? 'E' : ' '));
3805 print_vma (segment
->p_align
, HEX
);
3809 switch (segment
->p_type
)
3813 error (_("more than one dynamic segment\n"));
3815 /* By default, assume that the .dynamic section is the first
3816 section in the DYNAMIC segment. */
3817 dynamic_addr
= segment
->p_offset
;
3818 dynamic_size
= segment
->p_filesz
;
3820 /* Try to locate the .dynamic section. If there is
3821 a section header table, we can easily locate it. */
3822 if (section_headers
!= NULL
)
3824 Elf_Internal_Shdr
* sec
;
3826 sec
= find_section (".dynamic");
3827 if (sec
== NULL
|| sec
->sh_size
== 0)
3829 /* A corresponding .dynamic section is expected, but on
3830 IA-64/OpenVMS it is OK for it to be missing. */
3831 if (!is_ia64_vms ())
3832 error (_("no .dynamic section in the dynamic segment\n"));
3836 if (sec
->sh_type
== SHT_NOBITS
)
3842 dynamic_addr
= sec
->sh_offset
;
3843 dynamic_size
= sec
->sh_size
;
3845 if (dynamic_addr
< segment
->p_offset
3846 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3847 warn (_("the .dynamic section is not contained"
3848 " within the dynamic segment\n"));
3849 else if (dynamic_addr
> segment
->p_offset
)
3850 warn (_("the .dynamic section is not the first section"
3851 " in the dynamic segment.\n"));
3856 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3858 error (_("Unable to find program interpreter name\n"));
3862 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
3864 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
3865 error (_("Internal error: failed to create format string to display program interpreter\n"));
3867 program_interpreter
[0] = 0;
3868 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
3869 error (_("Unable to read program interpreter name\n"));
3872 printf (_("\n [Requesting program interpreter: %s]"),
3873 program_interpreter
);
3879 putc ('\n', stdout
);
3882 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3884 printf (_("\n Section to Segment mapping:\n"));
3885 printf (_(" Segment Sections...\n"));
3887 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3890 Elf_Internal_Shdr
* section
;
3892 segment
= program_headers
+ i
;
3893 section
= section_headers
+ 1;
3895 printf (" %2.2d ", i
);
3897 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3899 if (!ELF_TBSS_SPECIAL (section
, segment
)
3900 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
3901 printf ("%s ", SECTION_NAME (section
));
3912 /* Find the file offset corresponding to VMA by using the program headers. */
3915 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
3917 Elf_Internal_Phdr
* seg
;
3919 if (! get_program_headers (file
))
3921 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3925 for (seg
= program_headers
;
3926 seg
< program_headers
+ elf_header
.e_phnum
;
3929 if (seg
->p_type
!= PT_LOAD
)
3932 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3933 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3934 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3937 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3938 (unsigned long) vma
);
3944 get_32bit_section_headers (FILE * file
, unsigned int num
)
3946 Elf32_External_Shdr
* shdrs
;
3947 Elf_Internal_Shdr
* internal
;
3950 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
3951 elf_header
.e_shentsize
, num
,
3952 _("section headers"));
3956 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
3957 sizeof (Elf_Internal_Shdr
));
3959 if (section_headers
== NULL
)
3961 error (_("Out of memory\n"));
3965 for (i
= 0, internal
= section_headers
;
3969 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3970 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3971 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3972 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3973 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3974 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3975 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3976 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3977 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3978 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3987 get_64bit_section_headers (FILE * file
, unsigned int num
)
3989 Elf64_External_Shdr
* shdrs
;
3990 Elf_Internal_Shdr
* internal
;
3993 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
3994 elf_header
.e_shentsize
, num
,
3995 _("section headers"));
3999 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4000 sizeof (Elf_Internal_Shdr
));
4002 if (section_headers
== NULL
)
4004 error (_("Out of memory\n"));
4008 for (i
= 0, internal
= section_headers
;
4012 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4013 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4014 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4015 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4016 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4017 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4018 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4019 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4020 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4021 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4029 static Elf_Internal_Sym
*
4030 get_32bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
4032 unsigned long number
;
4033 Elf32_External_Sym
* esyms
;
4034 Elf_External_Sym_Shndx
* shndx
;
4035 Elf_Internal_Sym
* isyms
;
4036 Elf_Internal_Sym
* psym
;
4039 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4040 section
->sh_size
, _("symbols"));
4045 if (symtab_shndx_hdr
!= NULL
4046 && (symtab_shndx_hdr
->sh_link
4047 == (unsigned long) (section
- section_headers
)))
4049 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4050 symtab_shndx_hdr
->sh_offset
,
4051 1, symtab_shndx_hdr
->sh_size
,
4060 number
= section
->sh_size
/ section
->sh_entsize
;
4061 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4065 error (_("Out of memory\n"));
4072 for (j
= 0, psym
= isyms
;
4076 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4077 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4078 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4079 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4080 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4082 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4083 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4084 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4085 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4086 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4096 static Elf_Internal_Sym
*
4097 get_64bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
4099 unsigned long number
;
4100 Elf64_External_Sym
* esyms
;
4101 Elf_External_Sym_Shndx
* shndx
;
4102 Elf_Internal_Sym
* isyms
;
4103 Elf_Internal_Sym
* psym
;
4106 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4107 section
->sh_size
, _("symbols"));
4112 if (symtab_shndx_hdr
!= NULL
4113 && (symtab_shndx_hdr
->sh_link
4114 == (unsigned long) (section
- section_headers
)))
4116 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4117 symtab_shndx_hdr
->sh_offset
,
4118 1, symtab_shndx_hdr
->sh_size
,
4127 number
= section
->sh_size
/ section
->sh_entsize
;
4128 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4132 error (_("Out of memory\n"));
4139 for (j
= 0, psym
= isyms
;
4143 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4144 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4145 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4146 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4147 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4149 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4150 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4151 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4152 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4153 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4164 get_elf_section_flags (bfd_vma sh_flags
)
4166 static char buff
[1024];
4168 int field_size
= is_32bit_elf
? 8 : 16;
4170 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
4171 bfd_vma os_flags
= 0;
4172 bfd_vma proc_flags
= 0;
4173 bfd_vma unknown_flags
= 0;
4181 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4182 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4183 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4184 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4185 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4186 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4187 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4188 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4189 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4190 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4191 /* IA-64 specific. */
4192 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4193 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4194 /* IA-64 OpenVMS specific. */
4195 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4196 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4197 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4198 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4199 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4200 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4202 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4203 /* SPARC specific. */
4204 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4207 if (do_section_details
)
4209 sprintf (buff
, "[%*.*lx]: ",
4210 field_size
, field_size
, (unsigned long) sh_flags
);
4211 p
+= field_size
+ 4;
4218 flag
= sh_flags
& - sh_flags
;
4221 if (do_section_details
)
4225 case SHF_WRITE
: sindex
= 0; break;
4226 case SHF_ALLOC
: sindex
= 1; break;
4227 case SHF_EXECINSTR
: sindex
= 2; break;
4228 case SHF_MERGE
: sindex
= 3; break;
4229 case SHF_STRINGS
: sindex
= 4; break;
4230 case SHF_INFO_LINK
: sindex
= 5; break;
4231 case SHF_LINK_ORDER
: sindex
= 6; break;
4232 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
4233 case SHF_GROUP
: sindex
= 8; break;
4234 case SHF_TLS
: sindex
= 9; break;
4235 case SHF_EXCLUDE
: sindex
= 18; break;
4239 switch (elf_header
.e_machine
)
4242 if (flag
== SHF_IA_64_SHORT
)
4244 else if (flag
== SHF_IA_64_NORECOV
)
4247 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
4250 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
4251 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
4252 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
4253 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
4254 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
4255 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
4265 case EM_OLD_SPARCV9
:
4266 case EM_SPARC32PLUS
:
4269 if (flag
== SHF_ORDERED
)
4279 if (p
!= buff
+ field_size
+ 4)
4281 if (size
< (10 + 2))
4288 size
-= flags
[sindex
].len
;
4289 p
= stpcpy (p
, flags
[sindex
].str
);
4291 else if (flag
& SHF_MASKOS
)
4293 else if (flag
& SHF_MASKPROC
)
4296 unknown_flags
|= flag
;
4302 case SHF_WRITE
: *p
= 'W'; break;
4303 case SHF_ALLOC
: *p
= 'A'; break;
4304 case SHF_EXECINSTR
: *p
= 'X'; break;
4305 case SHF_MERGE
: *p
= 'M'; break;
4306 case SHF_STRINGS
: *p
= 'S'; break;
4307 case SHF_INFO_LINK
: *p
= 'I'; break;
4308 case SHF_LINK_ORDER
: *p
= 'L'; break;
4309 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
4310 case SHF_GROUP
: *p
= 'G'; break;
4311 case SHF_TLS
: *p
= 'T'; break;
4312 case SHF_EXCLUDE
: *p
= 'E'; break;
4315 if ((elf_header
.e_machine
== EM_X86_64
4316 || elf_header
.e_machine
== EM_L1OM
)
4317 && flag
== SHF_X86_64_LARGE
)
4319 else if (flag
& SHF_MASKOS
)
4322 sh_flags
&= ~ SHF_MASKOS
;
4324 else if (flag
& SHF_MASKPROC
)
4327 sh_flags
&= ~ SHF_MASKPROC
;
4337 if (do_section_details
)
4341 size
-= 5 + field_size
;
4342 if (p
!= buff
+ field_size
+ 4)
4350 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4351 (unsigned long) os_flags
);
4352 p
+= 5 + field_size
;
4356 size
-= 7 + field_size
;
4357 if (p
!= buff
+ field_size
+ 4)
4365 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4366 (unsigned long) proc_flags
);
4367 p
+= 7 + field_size
;
4371 size
-= 10 + field_size
;
4372 if (p
!= buff
+ field_size
+ 4)
4380 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
4381 (unsigned long) unknown_flags
);
4382 p
+= 10 + field_size
;
4391 process_section_headers (FILE * file
)
4393 Elf_Internal_Shdr
* section
;
4396 section_headers
= NULL
;
4398 if (elf_header
.e_shnum
== 0)
4401 printf (_("\nThere are no sections in this file.\n"));
4406 if (do_sections
&& !do_header
)
4407 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4408 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4412 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4415 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4418 /* Read in the string table, so that we have names to display. */
4419 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4420 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4422 section
= section_headers
+ elf_header
.e_shstrndx
;
4424 if (section
->sh_size
!= 0)
4426 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4427 1, section
->sh_size
,
4430 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4434 /* Scan the sections for the dynamic symbol table
4435 and dynamic string table and debug sections. */
4436 dynamic_symbols
= NULL
;
4437 dynamic_strings
= NULL
;
4438 dynamic_syminfo
= NULL
;
4439 symtab_shndx_hdr
= NULL
;
4441 eh_addr_size
= is_32bit_elf
? 4 : 8;
4442 switch (elf_header
.e_machine
)
4445 case EM_MIPS_RS3_LE
:
4446 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4447 FDE addresses. However, the ABI also has a semi-official ILP32
4448 variant for which the normal FDE address size rules apply.
4450 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4451 section, where XX is the size of longs in bits. Unfortunately,
4452 earlier compilers provided no way of distinguishing ILP32 objects
4453 from LP64 objects, so if there's any doubt, we should assume that
4454 the official LP64 form is being used. */
4455 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4456 && find_section (".gcc_compiled_long32") == NULL
)
4462 switch (elf_header
.e_flags
& EF_H8_MACH
)
4464 case E_H8_MACH_H8300
:
4465 case E_H8_MACH_H8300HN
:
4466 case E_H8_MACH_H8300SN
:
4467 case E_H8_MACH_H8300SXN
:
4470 case E_H8_MACH_H8300H
:
4471 case E_H8_MACH_H8300S
:
4472 case E_H8_MACH_H8300SX
:
4480 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
4482 case EF_M32C_CPU_M16C
:
4489 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4492 size_t expected_entsize \
4493 = is_32bit_elf ? size32 : size64; \
4494 if (section->sh_entsize != expected_entsize) \
4495 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4496 i, (unsigned long int) section->sh_entsize, \
4497 (unsigned long int) expected_entsize); \
4498 section->sh_entsize = expected_entsize; \
4501 #define CHECK_ENTSIZE(section, i, type) \
4502 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4503 sizeof (Elf64_External_##type))
4505 for (i
= 0, section
= section_headers
;
4506 i
< elf_header
.e_shnum
;
4509 char * name
= SECTION_NAME (section
);
4511 if (section
->sh_type
== SHT_DYNSYM
)
4513 if (dynamic_symbols
!= NULL
)
4515 error (_("File contains multiple dynamic symbol tables\n"));
4519 CHECK_ENTSIZE (section
, i
, Sym
);
4520 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4521 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4523 else if (section
->sh_type
== SHT_STRTAB
4524 && streq (name
, ".dynstr"))
4526 if (dynamic_strings
!= NULL
)
4528 error (_("File contains multiple dynamic string tables\n"));
4532 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4533 1, section
->sh_size
,
4534 _("dynamic strings"));
4535 dynamic_strings_length
= section
->sh_size
;
4537 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4539 if (symtab_shndx_hdr
!= NULL
)
4541 error (_("File contains multiple symtab shndx tables\n"));
4544 symtab_shndx_hdr
= section
;
4546 else if (section
->sh_type
== SHT_SYMTAB
)
4547 CHECK_ENTSIZE (section
, i
, Sym
);
4548 else if (section
->sh_type
== SHT_GROUP
)
4549 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4550 else if (section
->sh_type
== SHT_REL
)
4551 CHECK_ENTSIZE (section
, i
, Rel
);
4552 else if (section
->sh_type
== SHT_RELA
)
4553 CHECK_ENTSIZE (section
, i
, Rela
);
4554 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4555 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
4556 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
4557 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
)
4558 && (const_strneq (name
, ".debug_")
4559 || const_strneq (name
, ".zdebug_")))
4562 name
+= sizeof (".zdebug_") - 1;
4564 name
+= sizeof (".debug_") - 1;
4567 || (do_debug_info
&& streq (name
, "info"))
4568 || (do_debug_info
&& streq (name
, "types"))
4569 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4570 || (do_debug_lines
&& streq (name
, "line"))
4571 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4572 || (do_debug_pubtypes
&& streq (name
, "pubtypes"))
4573 || (do_debug_aranges
&& streq (name
, "aranges"))
4574 || (do_debug_ranges
&& streq (name
, "ranges"))
4575 || (do_debug_frames
&& streq (name
, "frame"))
4576 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4577 || (do_debug_str
&& streq (name
, "str"))
4578 || (do_debug_loc
&& streq (name
, "loc"))
4580 request_dump_bynumber (i
, DEBUG_DUMP
);
4582 /* Linkonce section to be combined with .debug_info at link time. */
4583 else if ((do_debugging
|| do_debug_info
)
4584 && const_strneq (name
, ".gnu.linkonce.wi."))
4585 request_dump_bynumber (i
, DEBUG_DUMP
);
4586 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4587 request_dump_bynumber (i
, DEBUG_DUMP
);
4588 /* Trace sections for Itanium VMS. */
4589 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
4590 || do_trace_aranges
)
4591 && const_strneq (name
, ".trace_"))
4593 name
+= sizeof (".trace_") - 1;
4596 || (do_trace_info
&& streq (name
, "info"))
4597 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
4598 || (do_trace_aranges
&& streq (name
, "aranges"))
4600 request_dump_bynumber (i
, DEBUG_DUMP
);
4608 if (elf_header
.e_shnum
> 1)
4609 printf (_("\nSection Headers:\n"));
4611 printf (_("\nSection Header:\n"));
4615 if (do_section_details
)
4617 printf (_(" [Nr] Name\n"));
4618 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4622 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4626 if (do_section_details
)
4628 printf (_(" [Nr] Name\n"));
4629 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4633 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4637 if (do_section_details
)
4639 printf (_(" [Nr] Name\n"));
4640 printf (_(" Type Address Offset Link\n"));
4641 printf (_(" Size EntSize Info Align\n"));
4645 printf (_(" [Nr] Name Type Address Offset\n"));
4646 printf (_(" Size EntSize Flags Link Info Align\n"));
4650 if (do_section_details
)
4651 printf (_(" Flags\n"));
4653 for (i
= 0, section
= section_headers
;
4654 i
< elf_header
.e_shnum
;
4657 if (do_section_details
)
4659 printf (" [%2u] %s\n",
4661 SECTION_NAME (section
));
4662 if (is_32bit_elf
|| do_wide
)
4663 printf (" %-15.15s ",
4664 get_section_type_name (section
->sh_type
));
4667 printf ((do_wide
? " [%2u] %-17s %-15s "
4668 : " [%2u] %-17.17s %-15.15s "),
4670 SECTION_NAME (section
),
4671 get_section_type_name (section
->sh_type
));
4675 const char * link_too_big
= NULL
;
4677 print_vma (section
->sh_addr
, LONG_HEX
);
4679 printf ( " %6.6lx %6.6lx %2.2lx",
4680 (unsigned long) section
->sh_offset
,
4681 (unsigned long) section
->sh_size
,
4682 (unsigned long) section
->sh_entsize
);
4684 if (do_section_details
)
4685 fputs (" ", stdout
);
4687 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4689 if (section
->sh_link
>= elf_header
.e_shnum
)
4692 /* The sh_link value is out of range. Normally this indicates
4693 an error but it can have special values in Solaris binaries. */
4694 switch (elf_header
.e_machine
)
4700 case EM_OLD_SPARCV9
:
4701 case EM_SPARC32PLUS
:
4704 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
4705 link_too_big
= "BEFORE";
4706 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
4707 link_too_big
= "AFTER";
4714 if (do_section_details
)
4716 if (link_too_big
!= NULL
&& * link_too_big
)
4717 printf ("<%s> ", link_too_big
);
4719 printf ("%2u ", section
->sh_link
);
4720 printf ("%3u %2lu\n", section
->sh_info
,
4721 (unsigned long) section
->sh_addralign
);
4724 printf ("%2u %3u %2lu\n",
4727 (unsigned long) section
->sh_addralign
);
4729 if (link_too_big
&& ! * link_too_big
)
4730 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4731 i
, section
->sh_link
);
4735 print_vma (section
->sh_addr
, LONG_HEX
);
4737 if ((long) section
->sh_offset
== section
->sh_offset
)
4738 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4742 print_vma (section
->sh_offset
, LONG_HEX
);
4745 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4746 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4750 print_vma (section
->sh_size
, LONG_HEX
);
4753 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4754 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4758 print_vma (section
->sh_entsize
, LONG_HEX
);
4761 if (do_section_details
)
4762 fputs (" ", stdout
);
4764 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4766 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
4768 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4769 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
4772 print_vma (section
->sh_addralign
, DEC
);
4776 else if (do_section_details
)
4778 printf (" %-15.15s ",
4779 get_section_type_name (section
->sh_type
));
4780 print_vma (section
->sh_addr
, LONG_HEX
);
4781 if ((long) section
->sh_offset
== section
->sh_offset
)
4782 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4786 print_vma (section
->sh_offset
, LONG_HEX
);
4788 printf (" %u\n ", section
->sh_link
);
4789 print_vma (section
->sh_size
, LONG_HEX
);
4791 print_vma (section
->sh_entsize
, LONG_HEX
);
4793 printf (" %-16u %lu\n",
4795 (unsigned long) section
->sh_addralign
);
4800 print_vma (section
->sh_addr
, LONG_HEX
);
4801 if ((long) section
->sh_offset
== section
->sh_offset
)
4802 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4806 print_vma (section
->sh_offset
, LONG_HEX
);
4809 print_vma (section
->sh_size
, LONG_HEX
);
4811 print_vma (section
->sh_entsize
, LONG_HEX
);
4813 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4815 printf (" %2u %3u %lu\n",
4818 (unsigned long) section
->sh_addralign
);
4821 if (do_section_details
)
4822 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4825 if (!do_section_details
)
4826 printf (_("Key to Flags:\n\
4827 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4828 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
4829 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4835 get_group_flags (unsigned int flags
)
4837 static char buff
[32];
4847 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
4854 process_section_groups (FILE * file
)
4856 Elf_Internal_Shdr
* section
;
4858 struct group
* group
;
4859 Elf_Internal_Shdr
* symtab_sec
;
4860 Elf_Internal_Shdr
* strtab_sec
;
4861 Elf_Internal_Sym
* symtab
;
4865 /* Don't process section groups unless needed. */
4866 if (!do_unwind
&& !do_section_groups
)
4869 if (elf_header
.e_shnum
== 0)
4871 if (do_section_groups
)
4872 printf (_("\nThere are no sections in this file.\n"));
4877 if (section_headers
== NULL
)
4879 error (_("Section headers are not available!\n"));
4883 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
4884 sizeof (struct group
*));
4886 if (section_headers_groups
== NULL
)
4888 error (_("Out of memory\n"));
4892 /* Scan the sections for the group section. */
4894 for (i
= 0, section
= section_headers
;
4895 i
< elf_header
.e_shnum
;
4897 if (section
->sh_type
== SHT_GROUP
)
4900 if (group_count
== 0)
4902 if (do_section_groups
)
4903 printf (_("\nThere are no section groups in this file.\n"));
4908 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
4910 if (section_groups
== NULL
)
4912 error (_("Out of memory\n"));
4921 for (i
= 0, section
= section_headers
, group
= section_groups
;
4922 i
< elf_header
.e_shnum
;
4925 if (section
->sh_type
== SHT_GROUP
)
4927 char * name
= SECTION_NAME (section
);
4929 unsigned char * start
;
4930 unsigned char * indices
;
4931 unsigned int entry
, j
, size
;
4932 Elf_Internal_Shdr
* sec
;
4933 Elf_Internal_Sym
* sym
;
4935 /* Get the symbol table. */
4936 if (section
->sh_link
>= elf_header
.e_shnum
4937 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
4940 error (_("Bad sh_link in group section `%s'\n"), name
);
4944 if (symtab_sec
!= sec
)
4949 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4952 sym
= symtab
+ section
->sh_info
;
4954 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4956 if (sym
->st_shndx
== 0
4957 || sym
->st_shndx
>= elf_header
.e_shnum
)
4959 error (_("Bad sh_info in group section `%s'\n"), name
);
4963 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
4972 /* Get the string table. */
4973 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
4982 != (sec
= section_headers
+ symtab_sec
->sh_link
))
4987 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
4988 1, strtab_sec
->sh_size
,
4990 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4992 group_name
= sym
->st_name
< strtab_size
4993 ? strtab
+ sym
->st_name
: _("<corrupt>");
4996 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
4997 1, section
->sh_size
,
5001 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
5002 entry
= byte_get (indices
, 4);
5005 if (do_section_groups
)
5007 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5008 get_group_flags (entry
), i
, name
, group_name
, size
);
5010 printf (_(" [Index] Name\n"));
5013 group
->group_index
= i
;
5015 for (j
= 0; j
< size
; j
++)
5017 struct group_list
* g
;
5019 entry
= byte_get (indices
, 4);
5022 if (entry
>= elf_header
.e_shnum
)
5024 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5025 entry
, i
, elf_header
.e_shnum
- 1);
5029 if (section_headers_groups
[entry
] != NULL
)
5033 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5035 section_headers_groups
[entry
]->group_index
);
5040 /* Intel C/C++ compiler may put section 0 in a
5041 section group. We just warn it the first time
5042 and ignore it afterwards. */
5043 static int warned
= 0;
5046 error (_("section 0 in group section [%5u]\n"),
5047 section_headers_groups
[entry
]->group_index
);
5053 section_headers_groups
[entry
] = group
;
5055 if (do_section_groups
)
5057 sec
= section_headers
+ entry
;
5058 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
5061 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
5062 g
->section_index
= entry
;
5063 g
->next
= group
->root
;
5081 /* Data used to display dynamic fixups. */
5083 struct ia64_vms_dynfixup
5085 bfd_vma needed_ident
; /* Library ident number. */
5086 bfd_vma needed
; /* Index in the dstrtab of the library name. */
5087 bfd_vma fixup_needed
; /* Index of the library. */
5088 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
5089 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
5092 /* Data used to display dynamic relocations. */
5094 struct ia64_vms_dynimgrela
5096 bfd_vma img_rela_cnt
; /* Number of relocations. */
5097 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
5100 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5104 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
5105 const char *strtab
, unsigned int strtab_sz
)
5107 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
5109 const char *lib_name
;
5111 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
5112 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
5113 _("dynamic section image fixups"));
5117 if (fixup
->needed
< strtab_sz
)
5118 lib_name
= strtab
+ fixup
->needed
;
5121 warn ("corrupt library name index of 0x%lx found in dynamic entry",
5122 (unsigned long) fixup
->needed
);
5125 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5126 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
5128 (_("Seg Offset Type SymVec DataType\n"));
5130 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
5135 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
5136 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
5137 type
= BYTE_GET (imfs
[i
].type
);
5138 rtype
= elf_ia64_reloc_type (type
);
5140 printf (" 0x%08x ", type
);
5142 printf (" %-32s ", rtype
);
5143 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
5144 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
5150 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5153 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
5155 Elf64_External_VMS_IMAGE_RELA
*imrs
;
5158 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
5159 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
5160 _("dynamic section image relas"));
5164 printf (_("\nImage relocs\n"));
5166 (_("Seg Offset Type Addend Seg Sym Off\n"));
5168 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
5173 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
5174 printf ("%08" BFD_VMA_FMT
"x ",
5175 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
5176 type
= BYTE_GET (imrs
[i
].type
);
5177 rtype
= elf_ia64_reloc_type (type
);
5179 printf ("0x%08x ", type
);
5181 printf ("%-31s ", rtype
);
5182 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
5183 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
5184 printf ("%08" BFD_VMA_FMT
"x\n",
5185 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
5191 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
5194 process_ia64_vms_dynamic_relocs (FILE *file
)
5196 struct ia64_vms_dynfixup fixup
;
5197 struct ia64_vms_dynimgrela imgrela
;
5198 Elf_Internal_Dyn
*entry
;
5200 bfd_vma strtab_off
= 0;
5201 bfd_vma strtab_sz
= 0;
5202 char *strtab
= NULL
;
5204 memset (&fixup
, 0, sizeof (fixup
));
5205 memset (&imgrela
, 0, sizeof (imgrela
));
5207 /* Note: the order of the entries is specified by the OpenVMS specs. */
5208 for (entry
= dynamic_section
;
5209 entry
< dynamic_section
+ dynamic_nent
;
5212 switch (entry
->d_tag
)
5214 case DT_IA_64_VMS_STRTAB_OFFSET
:
5215 strtab_off
= entry
->d_un
.d_val
;
5218 strtab_sz
= entry
->d_un
.d_val
;
5220 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
5221 1, strtab_sz
, _("dynamic string section"));
5224 case DT_IA_64_VMS_NEEDED_IDENT
:
5225 fixup
.needed_ident
= entry
->d_un
.d_val
;
5228 fixup
.needed
= entry
->d_un
.d_val
;
5230 case DT_IA_64_VMS_FIXUP_NEEDED
:
5231 fixup
.fixup_needed
= entry
->d_un
.d_val
;
5233 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
5234 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
5236 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
5237 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
5239 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
5242 case DT_IA_64_VMS_IMG_RELA_CNT
:
5243 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
5245 case DT_IA_64_VMS_IMG_RELA_OFF
:
5246 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
5248 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
5268 } dynamic_relocations
[] =
5270 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
5271 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
5272 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
5275 /* Process the reloc section. */
5278 process_relocs (FILE * file
)
5280 unsigned long rel_size
;
5281 unsigned long rel_offset
;
5287 if (do_using_dynamic
)
5291 int has_dynamic_reloc
;
5294 has_dynamic_reloc
= 0;
5296 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
5298 is_rela
= dynamic_relocations
[i
].rela
;
5299 name
= dynamic_relocations
[i
].name
;
5300 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
5301 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
5303 has_dynamic_reloc
|= rel_size
;
5305 if (is_rela
== UNKNOWN
)
5307 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
5308 switch (dynamic_info
[DT_PLTREL
])
5322 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5323 name
, rel_offset
, rel_size
);
5325 dump_relocations (file
,
5326 offset_from_vma (file
, rel_offset
, rel_size
),
5328 dynamic_symbols
, num_dynamic_syms
,
5329 dynamic_strings
, dynamic_strings_length
, is_rela
);
5334 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
5336 if (! has_dynamic_reloc
)
5337 printf (_("\nThere are no dynamic relocations in this file.\n"));
5341 Elf_Internal_Shdr
* section
;
5345 for (i
= 0, section
= section_headers
;
5346 i
< elf_header
.e_shnum
;
5349 if ( section
->sh_type
!= SHT_RELA
5350 && section
->sh_type
!= SHT_REL
)
5353 rel_offset
= section
->sh_offset
;
5354 rel_size
= section
->sh_size
;
5358 Elf_Internal_Shdr
* strsec
;
5361 printf (_("\nRelocation section "));
5363 if (string_table
== NULL
)
5364 printf ("%d", section
->sh_name
);
5366 printf (_("'%s'"), SECTION_NAME (section
));
5368 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5369 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
5371 is_rela
= section
->sh_type
== SHT_RELA
;
5373 if (section
->sh_link
!= 0
5374 && section
->sh_link
< elf_header
.e_shnum
)
5376 Elf_Internal_Shdr
* symsec
;
5377 Elf_Internal_Sym
* symtab
;
5378 unsigned long nsyms
;
5379 unsigned long strtablen
= 0;
5380 char * strtab
= NULL
;
5382 symsec
= section_headers
+ section
->sh_link
;
5383 if (symsec
->sh_type
!= SHT_SYMTAB
5384 && symsec
->sh_type
!= SHT_DYNSYM
)
5387 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
5388 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
5393 if (symsec
->sh_link
!= 0
5394 && symsec
->sh_link
< elf_header
.e_shnum
)
5396 strsec
= section_headers
+ symsec
->sh_link
;
5398 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5401 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
5404 dump_relocations (file
, rel_offset
, rel_size
,
5405 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
5411 dump_relocations (file
, rel_offset
, rel_size
,
5412 NULL
, 0, NULL
, 0, is_rela
);
5419 printf (_("\nThere are no relocations in this file.\n"));
5425 /* Process the unwind section. */
5427 #include "unwind-ia64.h"
5429 /* An absolute address consists of a section and an offset. If the
5430 section is NULL, the offset itself is the address, otherwise, the
5431 address equals to LOAD_ADDRESS(section) + offset. */
5435 unsigned short section
;
5439 #define ABSADDR(a) \
5441 ? section_headers [(a).section].sh_addr + (a).offset \
5444 struct ia64_unw_table_entry
5446 struct absaddr start
;
5448 struct absaddr info
;
5451 struct ia64_unw_aux_info
5454 struct ia64_unw_table_entry
*table
; /* Unwind table. */
5455 unsigned long table_len
; /* Length of unwind table. */
5456 unsigned char * info
; /* Unwind info. */
5457 unsigned long info_size
; /* Size of unwind info. */
5458 bfd_vma info_addr
; /* starting address of unwind info. */
5459 bfd_vma seg_base
; /* Starting address of segment. */
5460 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5461 unsigned long nsyms
; /* Number of symbols. */
5462 char * strtab
; /* The string table. */
5463 unsigned long strtab_size
; /* Size of string table. */
5467 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
5468 unsigned long nsyms
,
5469 const char * strtab
,
5470 unsigned long strtab_size
,
5471 struct absaddr addr
,
5472 const char ** symname
,
5475 bfd_vma dist
= 0x100000;
5476 Elf_Internal_Sym
* sym
;
5477 Elf_Internal_Sym
* best
= NULL
;
5480 REMOVE_ARCH_BITS (addr
.offset
);
5482 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
5484 bfd_vma value
= sym
->st_value
;
5486 REMOVE_ARCH_BITS (value
);
5488 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
5489 && sym
->st_name
!= 0
5490 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
5491 && addr
.offset
>= value
5492 && addr
.offset
- value
< dist
)
5495 dist
= addr
.offset
- value
;
5502 *symname
= (best
->st_name
>= strtab_size
5503 ? _("<corrupt>") : strtab
+ best
->st_name
);
5508 *offset
= addr
.offset
;
5512 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
5514 struct ia64_unw_table_entry
* tp
;
5517 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5521 const unsigned char * dp
;
5522 const unsigned char * head
;
5523 const char * procname
;
5525 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5526 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
5528 fputs ("\n<", stdout
);
5532 fputs (procname
, stdout
);
5535 printf ("+%lx", (unsigned long) offset
);
5538 fputs (">: [", stdout
);
5539 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5540 fputc ('-', stdout
);
5541 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5542 printf ("], info at +0x%lx\n",
5543 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
5545 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
5546 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
5548 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5549 (unsigned) UNW_VER (stamp
),
5550 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
5551 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
5552 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
5553 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
5555 if (UNW_VER (stamp
) != 1)
5557 printf (_("\tUnknown version.\n"));
5562 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
5563 dp
= unw_decode (dp
, in_body
, & in_body
);
5568 slurp_ia64_unwind_table (FILE * file
,
5569 struct ia64_unw_aux_info
* aux
,
5570 Elf_Internal_Shdr
* sec
)
5572 unsigned long size
, nrelas
, i
;
5573 Elf_Internal_Phdr
* seg
;
5574 struct ia64_unw_table_entry
* tep
;
5575 Elf_Internal_Shdr
* relsec
;
5576 Elf_Internal_Rela
* rela
;
5577 Elf_Internal_Rela
* rp
;
5578 unsigned char * table
;
5580 Elf_Internal_Sym
* sym
;
5581 const char * relname
;
5583 /* First, find the starting address of the segment that includes
5586 if (elf_header
.e_phnum
)
5588 if (! get_program_headers (file
))
5591 for (seg
= program_headers
;
5592 seg
< program_headers
+ elf_header
.e_phnum
;
5595 if (seg
->p_type
!= PT_LOAD
)
5598 if (sec
->sh_addr
>= seg
->p_vaddr
5599 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5601 aux
->seg_base
= seg
->p_vaddr
;
5607 /* Second, build the unwind table from the contents of the unwind section: */
5608 size
= sec
->sh_size
;
5609 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
5614 aux
->table
= (struct ia64_unw_table_entry
*)
5615 xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
5617 for (tp
= table
; tp
< table
+ size
; ++tep
)
5619 tep
->start
.section
= SHN_UNDEF
;
5620 tep
->end
.section
= SHN_UNDEF
;
5621 tep
->info
.section
= SHN_UNDEF
;
5622 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5623 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5624 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5625 tep
->start
.offset
+= aux
->seg_base
;
5626 tep
->end
.offset
+= aux
->seg_base
;
5627 tep
->info
.offset
+= aux
->seg_base
;
5631 /* Third, apply any relocations to the unwind table: */
5632 for (relsec
= section_headers
;
5633 relsec
< section_headers
+ elf_header
.e_shnum
;
5636 if (relsec
->sh_type
!= SHT_RELA
5637 || relsec
->sh_info
>= elf_header
.e_shnum
5638 || section_headers
+ relsec
->sh_info
!= sec
)
5641 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5645 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5647 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5648 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5650 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5652 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5656 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5658 switch (rp
->r_offset
/eh_addr_size
% 3)
5661 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5662 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
5665 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5666 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
5669 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5670 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
5680 aux
->table_len
= size
/ (3 * eh_addr_size
);
5685 ia64_process_unwind (FILE * file
)
5687 Elf_Internal_Shdr
* sec
;
5688 Elf_Internal_Shdr
* unwsec
= NULL
;
5689 Elf_Internal_Shdr
* strsec
;
5690 unsigned long i
, unwcount
= 0, unwstart
= 0;
5691 struct ia64_unw_aux_info aux
;
5693 memset (& aux
, 0, sizeof (aux
));
5695 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5697 if (sec
->sh_type
== SHT_SYMTAB
5698 && sec
->sh_link
< elf_header
.e_shnum
)
5700 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5701 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5703 strsec
= section_headers
+ sec
->sh_link
;
5704 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5707 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5709 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5714 printf (_("\nThere are no unwind sections in this file.\n"));
5716 while (unwcount
-- > 0)
5721 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5722 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5723 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5730 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5732 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5734 /* We need to find which section group it is in. */
5735 struct group_list
* g
= section_headers_groups
[i
]->root
;
5737 for (; g
!= NULL
; g
= g
->next
)
5739 sec
= section_headers
+ g
->section_index
;
5741 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5746 i
= elf_header
.e_shnum
;
5748 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5750 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5751 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5752 suffix
= SECTION_NAME (unwsec
) + len
;
5753 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5755 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5756 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5761 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5762 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5763 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5764 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5766 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5767 suffix
= SECTION_NAME (unwsec
) + len
;
5768 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5770 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5771 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5775 if (i
== elf_header
.e_shnum
)
5777 printf (_("\nCould not find unwind info section for "));
5779 if (string_table
== NULL
)
5780 printf ("%d", unwsec
->sh_name
);
5782 printf (_("'%s'"), SECTION_NAME (unwsec
));
5786 aux
.info_size
= sec
->sh_size
;
5787 aux
.info_addr
= sec
->sh_addr
;
5788 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
5792 printf (_("\nUnwind section "));
5794 if (string_table
== NULL
)
5795 printf ("%d", unwsec
->sh_name
);
5797 printf (_("'%s'"), SECTION_NAME (unwsec
));
5799 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5800 (unsigned long) unwsec
->sh_offset
,
5801 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5803 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5805 if (aux
.table_len
> 0)
5806 dump_ia64_unwind (& aux
);
5809 free ((char *) aux
.table
);
5811 free ((char *) aux
.info
);
5820 free ((char *) aux
.strtab
);
5825 struct hppa_unw_table_entry
5827 struct absaddr start
;
5829 unsigned int Cannot_unwind
:1; /* 0 */
5830 unsigned int Millicode
:1; /* 1 */
5831 unsigned int Millicode_save_sr0
:1; /* 2 */
5832 unsigned int Region_description
:2; /* 3..4 */
5833 unsigned int reserved1
:1; /* 5 */
5834 unsigned int Entry_SR
:1; /* 6 */
5835 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5836 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5837 unsigned int Args_stored
:1; /* 16 */
5838 unsigned int Variable_Frame
:1; /* 17 */
5839 unsigned int Separate_Package_Body
:1; /* 18 */
5840 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5841 unsigned int Stack_Overflow_Check
:1; /* 20 */
5842 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5843 unsigned int Ada_Region
:1; /* 22 */
5844 unsigned int cxx_info
:1; /* 23 */
5845 unsigned int cxx_try_catch
:1; /* 24 */
5846 unsigned int sched_entry_seq
:1; /* 25 */
5847 unsigned int reserved2
:1; /* 26 */
5848 unsigned int Save_SP
:1; /* 27 */
5849 unsigned int Save_RP
:1; /* 28 */
5850 unsigned int Save_MRP_in_frame
:1; /* 29 */
5851 unsigned int extn_ptr_defined
:1; /* 30 */
5852 unsigned int Cleanup_defined
:1; /* 31 */
5854 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5855 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5856 unsigned int Large_frame
:1; /* 2 */
5857 unsigned int Pseudo_SP_Set
:1; /* 3 */
5858 unsigned int reserved4
:1; /* 4 */
5859 unsigned int Total_frame_size
:27; /* 5..31 */
5862 struct hppa_unw_aux_info
5864 struct hppa_unw_table_entry
*table
; /* Unwind table. */
5865 unsigned long table_len
; /* Length of unwind table. */
5866 bfd_vma seg_base
; /* Starting address of segment. */
5867 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5868 unsigned long nsyms
; /* Number of symbols. */
5869 char * strtab
; /* The string table. */
5870 unsigned long strtab_size
; /* Size of string table. */
5874 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
5876 struct hppa_unw_table_entry
* tp
;
5878 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5881 const char * procname
;
5883 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5884 aux
->strtab_size
, tp
->start
, &procname
,
5887 fputs ("\n<", stdout
);
5891 fputs (procname
, stdout
);
5894 printf ("+%lx", (unsigned long) offset
);
5897 fputs (">: [", stdout
);
5898 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5899 fputc ('-', stdout
);
5900 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5903 #define PF(_m) if (tp->_m) printf (#_m " ");
5904 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5907 PF(Millicode_save_sr0
);
5908 /* PV(Region_description); */
5914 PF(Separate_Package_Body
);
5915 PF(Frame_Extension_Millicode
);
5916 PF(Stack_Overflow_Check
);
5917 PF(Two_Instruction_SP_Increment
);
5921 PF(sched_entry_seq
);
5924 PF(Save_MRP_in_frame
);
5925 PF(extn_ptr_defined
);
5926 PF(Cleanup_defined
);
5927 PF(MPE_XL_interrupt_marker
);
5928 PF(HP_UX_interrupt_marker
);
5931 PV(Total_frame_size
);
5940 slurp_hppa_unwind_table (FILE * file
,
5941 struct hppa_unw_aux_info
* aux
,
5942 Elf_Internal_Shdr
* sec
)
5944 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5945 Elf_Internal_Phdr
* seg
;
5946 struct hppa_unw_table_entry
* tep
;
5947 Elf_Internal_Shdr
* relsec
;
5948 Elf_Internal_Rela
* rela
;
5949 Elf_Internal_Rela
* rp
;
5950 unsigned char * table
;
5952 Elf_Internal_Sym
* sym
;
5953 const char * relname
;
5955 /* First, find the starting address of the segment that includes
5958 if (elf_header
.e_phnum
)
5960 if (! get_program_headers (file
))
5963 for (seg
= program_headers
;
5964 seg
< program_headers
+ elf_header
.e_phnum
;
5967 if (seg
->p_type
!= PT_LOAD
)
5970 if (sec
->sh_addr
>= seg
->p_vaddr
5971 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5973 aux
->seg_base
= seg
->p_vaddr
;
5979 /* Second, build the unwind table from the contents of the unwind
5981 size
= sec
->sh_size
;
5982 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
5988 nentries
= size
/ unw_ent_size
;
5989 size
= unw_ent_size
* nentries
;
5991 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
5992 xcmalloc (nentries
, sizeof (aux
->table
[0]));
5994 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5996 unsigned int tmp1
, tmp2
;
5998 tep
->start
.section
= SHN_UNDEF
;
5999 tep
->end
.section
= SHN_UNDEF
;
6001 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
6002 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
6003 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
6004 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
6006 tep
->start
.offset
+= aux
->seg_base
;
6007 tep
->end
.offset
+= aux
->seg_base
;
6009 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
6010 tep
->Millicode
= (tmp1
>> 30) & 0x1;
6011 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
6012 tep
->Region_description
= (tmp1
>> 27) & 0x3;
6013 tep
->reserved1
= (tmp1
>> 26) & 0x1;
6014 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
6015 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
6016 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
6017 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
6018 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
6019 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
6020 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
6021 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
6022 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
6023 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
6024 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
6025 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
6026 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
6027 tep
->reserved2
= (tmp1
>> 5) & 0x1;
6028 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
6029 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
6030 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
6031 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
6032 tep
->Cleanup_defined
= tmp1
& 0x1;
6034 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
6035 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
6036 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
6037 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
6038 tep
->reserved4
= (tmp2
>> 27) & 0x1;
6039 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
6043 /* Third, apply any relocations to the unwind table. */
6044 for (relsec
= section_headers
;
6045 relsec
< section_headers
+ elf_header
.e_shnum
;
6048 if (relsec
->sh_type
!= SHT_RELA
6049 || relsec
->sh_info
>= elf_header
.e_shnum
6050 || section_headers
+ relsec
->sh_info
!= sec
)
6053 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6057 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6059 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
6060 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6062 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
6063 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
6065 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6069 i
= rp
->r_offset
/ unw_ent_size
;
6071 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
6074 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6075 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
6078 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6079 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
6089 aux
->table_len
= nentries
;
6095 hppa_process_unwind (FILE * file
)
6097 struct hppa_unw_aux_info aux
;
6098 Elf_Internal_Shdr
* unwsec
= NULL
;
6099 Elf_Internal_Shdr
* strsec
;
6100 Elf_Internal_Shdr
* sec
;
6103 memset (& aux
, 0, sizeof (aux
));
6105 if (string_table
== NULL
)
6108 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6110 if (sec
->sh_type
== SHT_SYMTAB
6111 && sec
->sh_link
< elf_header
.e_shnum
)
6113 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
6114 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
6116 strsec
= section_headers
+ sec
->sh_link
;
6117 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6120 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6122 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6127 printf (_("\nThere are no unwind sections in this file.\n"));
6129 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6131 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6133 printf (_("\nUnwind section "));
6134 printf (_("'%s'"), SECTION_NAME (sec
));
6136 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6137 (unsigned long) sec
->sh_offset
,
6138 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
6140 slurp_hppa_unwind_table (file
, &aux
, sec
);
6141 if (aux
.table_len
> 0)
6142 dump_hppa_unwind (&aux
);
6145 free ((char *) aux
.table
);
6153 free ((char *) aux
.strtab
);
6160 unsigned char *data
;
6162 Elf_Internal_Shdr
*sec
;
6163 Elf_Internal_Rela
*rela
;
6164 unsigned long nrelas
;
6165 unsigned int rel_type
;
6167 Elf_Internal_Rela
*next_rela
;
6170 struct arm_unw_aux_info
6174 Elf_Internal_Sym
*symtab
; /* The symbol table. */
6175 unsigned long nsyms
; /* Number of symbols. */
6176 char *strtab
; /* The string table. */
6177 unsigned long strtab_size
; /* Size of string table. */
6181 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
6182 bfd_vma fn
, struct absaddr addr
)
6184 const char *procname
;
6187 if (addr
.section
== SHN_UNDEF
)
6190 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6191 aux
->strtab_size
, addr
, &procname
,
6194 print_vma (fn
, PREFIX_HEX
);
6198 fputs (" <", stdout
);
6199 fputs (procname
, stdout
);
6202 printf ("+0x%lx", (unsigned long) sym_offset
);
6203 fputc ('>', stdout
);
6210 arm_free_section (struct arm_section
*arm_sec
)
6212 if (arm_sec
->data
!= NULL
)
6213 free (arm_sec
->data
);
6215 if (arm_sec
->rela
!= NULL
)
6216 free (arm_sec
->rela
);
6220 arm_section_get_word (struct arm_unw_aux_info
*aux
,
6221 struct arm_section
*arm_sec
,
6222 Elf_Internal_Shdr
*sec
, bfd_vma word_offset
,
6223 unsigned int *wordp
, struct absaddr
*addr
)
6225 Elf_Internal_Rela
*rp
;
6226 Elf_Internal_Sym
*sym
;
6227 const char * relname
;
6229 bfd_boolean wrapped
;
6231 addr
->section
= SHN_UNDEF
;
6234 if (sec
!= arm_sec
->sec
)
6236 Elf_Internal_Shdr
*relsec
;
6238 arm_free_section (arm_sec
);
6241 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
6242 sec
->sh_size
, _("unwind data"));
6244 arm_sec
->rela
= NULL
;
6245 arm_sec
->nrelas
= 0;
6247 for (relsec
= section_headers
;
6248 relsec
< section_headers
+ elf_header
.e_shnum
;
6251 if (relsec
->sh_info
>= elf_header
.e_shnum
6252 || section_headers
+ relsec
->sh_info
!= sec
)
6255 if (relsec
->sh_type
== SHT_REL
)
6257 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
6259 & arm_sec
->rela
, & arm_sec
->nrelas
))
6263 else if (relsec
->sh_type
== SHT_RELA
)
6265 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
6267 & arm_sec
->rela
, & arm_sec
->nrelas
))
6273 arm_sec
->next_rela
= arm_sec
->rela
;
6276 if (arm_sec
->data
== NULL
)
6279 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
6282 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
6284 bfd_vma prelval
, offset
;
6286 if (rp
->r_offset
> word_offset
&& !wrapped
)
6291 if (rp
->r_offset
> word_offset
)
6294 if (rp
->r_offset
& 3)
6296 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6297 (unsigned long) rp
->r_offset
);
6301 if (rp
->r_offset
< word_offset
)
6304 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
6306 if (streq (relname
, "R_ARM_NONE"))
6309 if (! streq (relname
, "R_ARM_PREL31"))
6311 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6315 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
6317 if (arm_sec
->rel_type
== SHT_REL
)
6319 offset
= word
& 0x7fffffff;
6320 if (offset
& 0x40000000)
6321 offset
|= ~ (bfd_vma
) 0x7fffffff;
6324 offset
= rp
->r_addend
;
6326 offset
+= sym
->st_value
;
6327 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
6329 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
6330 addr
->section
= sym
->st_shndx
;
6331 addr
->offset
= offset
;
6336 arm_sec
->next_rela
= rp
;
6342 decode_arm_unwind (struct arm_unw_aux_info
*aux
,
6343 unsigned int word
, unsigned int remaining
,
6344 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
6345 struct arm_section
*data_arm_sec
)
6348 unsigned int more_words
;
6349 struct absaddr addr
;
6352 if (remaining == 0 && more_words) \
6355 if (!arm_section_get_word (aux, data_arm_sec, data_sec, \
6356 data_offset, &word, &addr)) \
6362 #define GET_OP(OP) \
6367 (OP) = word >> 24; \
6372 printf (_("[Truncated opcode]\n")); \
6375 printf (_("0x%02x "), OP)
6379 /* Fetch the first word. */
6380 if (!arm_section_get_word (aux
, data_arm_sec
, data_sec
, data_offset
,
6386 if ((word
& 0x80000000) == 0)
6388 /* Expand prel31 for personality routine. */
6390 const char *procname
;
6393 if (fn
& 0x40000000)
6394 fn
|= ~ (bfd_vma
) 0x7fffffff;
6395 fn
= fn
+ data_sec
->sh_addr
+ data_offset
;
6397 printf (_(" Personality routine: "));
6398 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
6399 fputc ('\n', stdout
);
6401 /* The GCC personality routines use the standard compact
6402 encoding, starting with one byte giving the number of
6404 if (procname
!= NULL
6405 && (const_strneq (procname
, "__gcc_personality_v0")
6406 || const_strneq (procname
, "__gxx_personality_v0")
6407 || const_strneq (procname
, "__gcj_personality_v0")
6408 || const_strneq (procname
, "__gnu_objc_personality_v0")))
6415 printf (_(" [Truncated data]\n"));
6418 more_words
= word
>> 24;
6428 per_index
= (word
>> 24) & 0x7f;
6429 if (per_index
!= 0 && per_index
!= 1 && per_index
!= 2)
6431 printf (_(" [reserved compact index %d]\n"), per_index
);
6435 printf (_(" Compact model %d\n"), per_index
);
6444 more_words
= (word
>> 16) & 0xff;
6450 /* Decode the unwinding instructions. */
6453 unsigned int op
, op2
;
6462 printf (_(" 0x%02x "), op
);
6464 if ((op
& 0xc0) == 0x00)
6466 int offset
= ((op
& 0x3f) << 2) + 4;
6467 printf (_(" vsp = vsp + %d"), offset
);
6469 else if ((op
& 0xc0) == 0x40)
6471 int offset
= ((op
& 0x3f) << 2) + 4;
6472 printf (_(" vsp = vsp - %d"), offset
);
6474 else if ((op
& 0xf0) == 0x80)
6477 if (op
== 0x80 && op2
== 0)
6478 printf (_("Refuse to unwind"));
6481 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
6486 for (i
= 0; i
< 12; i
++)
6487 if (mask
& (1 << i
))
6493 printf ("r%d", 4 + i
);
6498 else if ((op
& 0xf0) == 0x90)
6500 if (op
== 0x9d || op
== 0x9f)
6501 printf (_(" [Reserved]"));
6503 printf (_(" vsp = r%d"), op
& 0x0f);
6505 else if ((op
& 0xf0) == 0xa0)
6507 int end
= 4 + (op
& 0x07);
6511 for (i
= 4; i
<= end
; i
++)
6527 else if (op
== 0xb0)
6528 printf (_(" finish"));
6529 else if (op
== 0xb1)
6532 if (op2
== 0 || (op2
& 0xf0) != 0)
6533 printf (_("[Spare]"));
6536 unsigned int mask
= op2
& 0x0f;
6540 for (i
= 0; i
< 12; i
++)
6541 if (mask
& (1 << i
))
6552 else if (op
== 0xb2)
6554 unsigned char buf
[9];
6555 unsigned int i
, len
;
6556 unsigned long offset
;
6557 for (i
= 0; i
< sizeof (buf
); i
++)
6560 if ((buf
[i
] & 0x80) == 0)
6563 assert (i
< sizeof (buf
));
6564 offset
= read_uleb128 (buf
, &len
);
6565 assert (len
== i
+ 1);
6566 offset
= offset
* 4 + 0x204;
6567 printf (_("vsp = vsp + %ld"), offset
);
6571 if (op
== 0xb3 || op
== 0xc6 || op
== 0xc7 || op
== 0xc8 || op
== 0xc9)
6574 printf (_("[unsupported two-byte opcode]"));
6578 printf (_(" [unsupported opcode]"));
6584 /* Decode the descriptors. Not implemented. */
6588 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
6590 struct arm_section exidx_arm_sec
, extab_arm_sec
;
6591 unsigned int i
, exidx_len
;
6593 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
6594 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
6595 exidx_len
= exidx_sec
->sh_size
/ 8;
6597 for (i
= 0; i
< exidx_len
; i
++)
6599 unsigned int exidx_fn
, exidx_entry
;
6600 struct absaddr fn_addr
, entry_addr
;
6603 fputc ('\n', stdout
);
6605 if (!arm_section_get_word (aux
, &exidx_arm_sec
, exidx_sec
,
6606 8 * i
, &exidx_fn
, &fn_addr
)
6607 || !arm_section_get_word (aux
, &exidx_arm_sec
, exidx_sec
,
6608 8 * i
+ 4, &exidx_entry
, &entry_addr
))
6610 arm_free_section (&exidx_arm_sec
);
6611 arm_free_section (&extab_arm_sec
);
6615 fn
= exidx_fn
& 0x7fffffff;
6616 if (fn
& 0x40000000)
6617 fn
|= ~ (bfd_vma
) 0x7fffffff;
6618 fn
= fn
+ exidx_sec
->sh_addr
+ 8 * i
;
6620 arm_print_vma_and_name (aux
, fn
, entry_addr
);
6621 fputs (": ", stdout
);
6623 if (exidx_entry
== 1)
6625 print_vma (exidx_entry
, PREFIX_HEX
);
6626 fputs (" [cantunwind]\n", stdout
);
6628 else if (exidx_entry
& 0x80000000)
6630 print_vma (exidx_entry
, PREFIX_HEX
);
6631 fputc ('\n', stdout
);
6632 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
6636 bfd_vma table
, table_offset
= 0;
6637 Elf_Internal_Shdr
*table_sec
;
6639 fputs ("@", stdout
);
6640 table
= exidx_entry
;
6641 if (table
& 0x40000000)
6642 table
|= ~ (bfd_vma
) 0x7fffffff;
6643 table
= table
+ exidx_sec
->sh_addr
+ 8 * i
+ 4;
6644 print_vma (table
, PREFIX_HEX
);
6647 /* Locate the matching .ARM.extab. */
6648 if (entry_addr
.section
!= SHN_UNDEF
6649 && entry_addr
.section
< elf_header
.e_shnum
)
6651 table_sec
= section_headers
+ entry_addr
.section
;
6652 table_offset
= entry_addr
.offset
;
6656 table_sec
= find_section_by_address (table
);
6657 if (table_sec
!= NULL
)
6658 table_offset
= table
- table_sec
->sh_addr
;
6660 if (table_sec
== NULL
)
6662 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
6663 (unsigned long) table
);
6666 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
6673 arm_free_section (&exidx_arm_sec
);
6674 arm_free_section (&extab_arm_sec
);
6678 arm_process_unwind (FILE *file
)
6680 struct arm_unw_aux_info aux
;
6681 Elf_Internal_Shdr
*unwsec
= NULL
;
6682 Elf_Internal_Shdr
*strsec
;
6683 Elf_Internal_Shdr
*sec
;
6686 memset (& aux
, 0, sizeof (aux
));
6689 if (string_table
== NULL
)
6692 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6694 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
6696 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
6697 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
6699 strsec
= section_headers
+ sec
->sh_link
;
6700 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
6701 1, strsec
->sh_size
, _("string table"));
6702 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6704 else if (sec
->sh_type
== SHT_ARM_EXIDX
)
6709 printf (_("\nThere are no unwind sections in this file.\n"));
6711 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6713 if (sec
->sh_type
== SHT_ARM_EXIDX
)
6715 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
6717 (unsigned long) sec
->sh_offset
,
6718 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
6720 dump_arm_unwind (&aux
, sec
);
6727 free ((char *) aux
.strtab
);
6733 process_unwind (FILE * file
)
6735 struct unwind_handler
6738 int (* handler
)(FILE *);
6741 { EM_ARM
, arm_process_unwind
},
6742 { EM_IA_64
, ia64_process_unwind
},
6743 { EM_PARISC
, hppa_process_unwind
},
6751 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
6752 if (elf_header
.e_machine
== handlers
[i
].machtype
)
6753 return handlers
[i
].handler (file
);
6755 printf (_("\nThere are no unwind sections in this file.\n"));
6760 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
6762 switch (entry
->d_tag
)
6765 if (entry
->d_un
.d_val
== 0)
6766 printf (_("NONE\n"));
6769 static const char * opts
[] =
6771 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
6772 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
6773 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
6774 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
6780 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
6781 if (entry
->d_un
.d_val
& (1 << cnt
))
6783 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
6790 case DT_MIPS_IVERSION
:
6791 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6792 printf (_("Interface Version: %s\n"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
6794 printf (_("<corrupt: %ld>\n"), (long) entry
->d_un
.d_ptr
);
6797 case DT_MIPS_TIME_STAMP
:
6802 time_t atime
= entry
->d_un
.d_val
;
6803 tmp
= gmtime (&atime
);
6804 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
6805 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6806 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6807 printf (_("Time Stamp: %s\n"), timebuf
);
6811 case DT_MIPS_RLD_VERSION
:
6812 case DT_MIPS_LOCAL_GOTNO
:
6813 case DT_MIPS_CONFLICTNO
:
6814 case DT_MIPS_LIBLISTNO
:
6815 case DT_MIPS_SYMTABNO
:
6816 case DT_MIPS_UNREFEXTNO
:
6817 case DT_MIPS_HIPAGENO
:
6818 case DT_MIPS_DELTA_CLASS_NO
:
6819 case DT_MIPS_DELTA_INSTANCE_NO
:
6820 case DT_MIPS_DELTA_RELOC_NO
:
6821 case DT_MIPS_DELTA_SYM_NO
:
6822 case DT_MIPS_DELTA_CLASSSYM_NO
:
6823 case DT_MIPS_COMPACT_SIZE
:
6824 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
6828 printf ("%#lx\n", (unsigned long) entry
->d_un
.d_ptr
);
6833 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
6835 switch (entry
->d_tag
)
6837 case DT_HP_DLD_FLAGS
:
6846 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
6847 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
6848 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
6849 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
6850 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
6851 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
6852 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
6853 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
6854 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
6855 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
6856 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
6857 { DT_HP_GST
, "HP_GST" },
6858 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
6859 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
6860 { DT_HP_NODELETE
, "HP_NODELETE" },
6861 { DT_HP_GROUP
, "HP_GROUP" },
6862 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
6866 bfd_vma val
= entry
->d_un
.d_val
;
6868 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
6869 if (val
& flags
[cnt
].bit
)
6873 fputs (flags
[cnt
].str
, stdout
);
6875 val
^= flags
[cnt
].bit
;
6878 if (val
!= 0 || first
)
6882 print_vma (val
, HEX
);
6888 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
6896 /* VMS vs Unix time offset and factor. */
6898 #define VMS_EPOCH_OFFSET 35067168000000000LL
6899 #define VMS_GRANULARITY_FACTOR 10000000
6901 /* Display a VMS time in a human readable format. */
6904 print_vms_time (bfd_int64_t vmstime
)
6909 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
6910 tm
= gmtime (&unxtime
);
6911 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
6912 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
6913 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
6918 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
6920 switch (entry
->d_tag
)
6922 case DT_IA_64_PLT_RESERVE
:
6923 /* First 3 slots reserved. */
6924 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
6926 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
6929 case DT_IA_64_VMS_LINKTIME
:
6931 print_vms_time (entry
->d_un
.d_val
);
6935 case DT_IA_64_VMS_LNKFLAGS
:
6936 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
6937 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
6938 printf (" CALL_DEBUG");
6939 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
6940 printf (" NOP0BUFS");
6941 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
6942 printf (" P0IMAGE");
6943 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
6944 printf (" MKTHREADS");
6945 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
6946 printf (" UPCALLS");
6947 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
6949 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
6950 printf (" INITIALIZE");
6951 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
6953 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
6954 printf (" EXE_INIT");
6955 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
6956 printf (" TBK_IN_IMG");
6957 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
6958 printf (" DBG_IN_IMG");
6959 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
6960 printf (" TBK_IN_DSF");
6961 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
6962 printf (" DBG_IN_DSF");
6963 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
6964 printf (" SIGNATURES");
6965 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
6966 printf (" REL_SEG_OFF");
6970 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
6977 get_32bit_dynamic_section (FILE * file
)
6979 Elf32_External_Dyn
* edyn
;
6980 Elf32_External_Dyn
* ext
;
6981 Elf_Internal_Dyn
* entry
;
6983 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
6984 dynamic_size
, _("dynamic section"));
6988 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
6989 might not have the luxury of section headers. Look for the DT_NULL
6990 terminator to determine the number of entries. */
6991 for (ext
= edyn
, dynamic_nent
= 0;
6992 (char *) ext
< (char *) edyn
+ dynamic_size
;
6996 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
7000 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
7002 if (dynamic_section
== NULL
)
7004 error (_("Out of memory\n"));
7009 for (ext
= edyn
, entry
= dynamic_section
;
7010 entry
< dynamic_section
+ dynamic_nent
;
7013 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
7014 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
7023 get_64bit_dynamic_section (FILE * file
)
7025 Elf64_External_Dyn
* edyn
;
7026 Elf64_External_Dyn
* ext
;
7027 Elf_Internal_Dyn
* entry
;
7029 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
7030 dynamic_size
, _("dynamic section"));
7034 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7035 might not have the luxury of section headers. Look for the DT_NULL
7036 terminator to determine the number of entries. */
7037 for (ext
= edyn
, dynamic_nent
= 0;
7038 (char *) ext
< (char *) edyn
+ dynamic_size
;
7042 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
7046 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
7048 if (dynamic_section
== NULL
)
7050 error (_("Out of memory\n"));
7055 for (ext
= edyn
, entry
= dynamic_section
;
7056 entry
< dynamic_section
+ dynamic_nent
;
7059 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
7060 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
7069 print_dynamic_flags (bfd_vma flags
)
7077 flag
= flags
& - flags
;
7087 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
7088 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
7089 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
7090 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
7091 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
7092 default: fputs (_("unknown"), stdout
); break;
7098 /* Parse and display the contents of the dynamic section. */
7101 process_dynamic_section (FILE * file
)
7103 Elf_Internal_Dyn
* entry
;
7105 if (dynamic_size
== 0)
7108 printf (_("\nThere is no dynamic section in this file.\n"));
7115 if (! get_32bit_dynamic_section (file
))
7118 else if (! get_64bit_dynamic_section (file
))
7121 /* Find the appropriate symbol table. */
7122 if (dynamic_symbols
== NULL
)
7124 for (entry
= dynamic_section
;
7125 entry
< dynamic_section
+ dynamic_nent
;
7128 Elf_Internal_Shdr section
;
7130 if (entry
->d_tag
!= DT_SYMTAB
)
7133 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
7135 /* Since we do not know how big the symbol table is,
7136 we default to reading in the entire file (!) and
7137 processing that. This is overkill, I know, but it
7139 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
7141 if (archive_file_offset
!= 0)
7142 section
.sh_size
= archive_file_size
- section
.sh_offset
;
7145 if (fseek (file
, 0, SEEK_END
))
7146 error (_("Unable to seek to end of file!\n"));
7148 section
.sh_size
= ftell (file
) - section
.sh_offset
;
7152 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
7154 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
7156 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
7157 if (num_dynamic_syms
< 1)
7159 error (_("Unable to determine the number of symbols to load\n"));
7163 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
7167 /* Similarly find a string table. */
7168 if (dynamic_strings
== NULL
)
7170 for (entry
= dynamic_section
;
7171 entry
< dynamic_section
+ dynamic_nent
;
7174 unsigned long offset
;
7177 if (entry
->d_tag
!= DT_STRTAB
)
7180 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
7182 /* Since we do not know how big the string table is,
7183 we default to reading in the entire file (!) and
7184 processing that. This is overkill, I know, but it
7187 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
7189 if (archive_file_offset
!= 0)
7190 str_tab_len
= archive_file_size
- offset
;
7193 if (fseek (file
, 0, SEEK_END
))
7194 error (_("Unable to seek to end of file\n"));
7195 str_tab_len
= ftell (file
) - offset
;
7198 if (str_tab_len
< 1)
7201 (_("Unable to determine the length of the dynamic string table\n"));
7205 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
7207 _("dynamic string table"));
7208 dynamic_strings_length
= str_tab_len
;
7213 /* And find the syminfo section if available. */
7214 if (dynamic_syminfo
== NULL
)
7216 unsigned long syminsz
= 0;
7218 for (entry
= dynamic_section
;
7219 entry
< dynamic_section
+ dynamic_nent
;
7222 if (entry
->d_tag
== DT_SYMINENT
)
7224 /* Note: these braces are necessary to avoid a syntax
7225 error from the SunOS4 C compiler. */
7226 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
7228 else if (entry
->d_tag
== DT_SYMINSZ
)
7229 syminsz
= entry
->d_un
.d_val
;
7230 else if (entry
->d_tag
== DT_SYMINFO
)
7231 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
7235 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
7237 Elf_External_Syminfo
* extsyminfo
;
7238 Elf_External_Syminfo
* extsym
;
7239 Elf_Internal_Syminfo
* syminfo
;
7241 /* There is a syminfo section. Read the data. */
7242 extsyminfo
= (Elf_External_Syminfo
*)
7243 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
7244 _("symbol information"));
7248 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
7249 if (dynamic_syminfo
== NULL
)
7251 error (_("Out of memory\n"));
7255 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
7256 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
7257 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
7258 ++syminfo
, ++extsym
)
7260 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
7261 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
7268 if (do_dynamic
&& dynamic_addr
)
7269 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7270 dynamic_addr
, dynamic_nent
);
7272 printf (_(" Tag Type Name/Value\n"));
7274 for (entry
= dynamic_section
;
7275 entry
< dynamic_section
+ dynamic_nent
;
7283 print_vma (entry
->d_tag
, FULL_HEX
);
7284 dtype
= get_dynamic_type (entry
->d_tag
);
7285 printf (" (%s)%*s", dtype
,
7286 ((is_32bit_elf
? 27 : 19)
7287 - (int) strlen (dtype
)),
7291 switch (entry
->d_tag
)
7295 print_dynamic_flags (entry
->d_un
.d_val
);
7305 switch (entry
->d_tag
)
7308 printf (_("Auxiliary library"));
7312 printf (_("Filter library"));
7316 printf (_("Configuration file"));
7320 printf (_("Dependency audit library"));
7324 printf (_("Audit library"));
7328 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7329 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
7333 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7342 printf (_("Flags:"));
7344 if (entry
->d_un
.d_val
== 0)
7345 printf (_(" None\n"));
7348 unsigned long int val
= entry
->d_un
.d_val
;
7350 if (val
& DTF_1_PARINIT
)
7352 printf (" PARINIT");
7353 val
^= DTF_1_PARINIT
;
7355 if (val
& DTF_1_CONFEXP
)
7357 printf (" CONFEXP");
7358 val
^= DTF_1_CONFEXP
;
7361 printf (" %lx", val
);
7370 printf (_("Flags:"));
7372 if (entry
->d_un
.d_val
== 0)
7373 printf (_(" None\n"));
7376 unsigned long int val
= entry
->d_un
.d_val
;
7378 if (val
& DF_P1_LAZYLOAD
)
7380 printf (" LAZYLOAD");
7381 val
^= DF_P1_LAZYLOAD
;
7383 if (val
& DF_P1_GROUPPERM
)
7385 printf (" GROUPPERM");
7386 val
^= DF_P1_GROUPPERM
;
7389 printf (" %lx", val
);
7398 printf (_("Flags:"));
7399 if (entry
->d_un
.d_val
== 0)
7400 printf (_(" None\n"));
7403 unsigned long int val
= entry
->d_un
.d_val
;
7410 if (val
& DF_1_GLOBAL
)
7415 if (val
& DF_1_GROUP
)
7420 if (val
& DF_1_NODELETE
)
7422 printf (" NODELETE");
7423 val
^= DF_1_NODELETE
;
7425 if (val
& DF_1_LOADFLTR
)
7427 printf (" LOADFLTR");
7428 val
^= DF_1_LOADFLTR
;
7430 if (val
& DF_1_INITFIRST
)
7432 printf (" INITFIRST");
7433 val
^= DF_1_INITFIRST
;
7435 if (val
& DF_1_NOOPEN
)
7440 if (val
& DF_1_ORIGIN
)
7445 if (val
& DF_1_DIRECT
)
7450 if (val
& DF_1_TRANS
)
7455 if (val
& DF_1_INTERPOSE
)
7457 printf (" INTERPOSE");
7458 val
^= DF_1_INTERPOSE
;
7460 if (val
& DF_1_NODEFLIB
)
7462 printf (" NODEFLIB");
7463 val
^= DF_1_NODEFLIB
;
7465 if (val
& DF_1_NODUMP
)
7470 if (val
& DF_1_CONLFAT
)
7472 printf (" CONLFAT");
7473 val
^= DF_1_CONLFAT
;
7476 printf (" %lx", val
);
7483 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
7485 puts (get_dynamic_type (entry
->d_un
.d_val
));
7505 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
7511 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7512 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
7518 switch (entry
->d_tag
)
7521 printf (_("Shared library: [%s]"), name
);
7523 if (streq (name
, program_interpreter
))
7524 printf (_(" program interpreter"));
7528 printf (_("Library soname: [%s]"), name
);
7532 printf (_("Library rpath: [%s]"), name
);
7536 printf (_("Library runpath: [%s]"), name
);
7540 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7545 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7558 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
7562 case DT_INIT_ARRAYSZ
:
7563 case DT_FINI_ARRAYSZ
:
7564 case DT_GNU_CONFLICTSZ
:
7565 case DT_GNU_LIBLISTSZ
:
7568 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
7569 printf (_(" (bytes)\n"));
7579 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
7592 if (entry
->d_tag
== DT_USED
7593 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7595 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
7599 printf (_("Not needed object: [%s]\n"), name
);
7604 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7610 /* The value of this entry is ignored. */
7615 case DT_GNU_PRELINKED
:
7619 time_t atime
= entry
->d_un
.d_val
;
7621 tmp
= gmtime (&atime
);
7622 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
7623 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
7624 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
7630 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
7633 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7639 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
7640 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
7645 switch (elf_header
.e_machine
)
7648 case EM_MIPS_RS3_LE
:
7649 dynamic_section_mips_val (entry
);
7652 dynamic_section_parisc_val (entry
);
7655 dynamic_section_ia64_val (entry
);
7658 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7670 get_ver_flags (unsigned int flags
)
7672 static char buff
[32];
7679 if (flags
& VER_FLG_BASE
)
7680 strcat (buff
, "BASE ");
7682 if (flags
& VER_FLG_WEAK
)
7684 if (flags
& VER_FLG_BASE
)
7685 strcat (buff
, "| ");
7687 strcat (buff
, "WEAK ");
7690 if (flags
& VER_FLG_INFO
)
7692 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
7693 strcat (buff
, "| ");
7695 strcat (buff
, "INFO ");
7698 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
7699 strcat (buff
, _("| <unknown>"));
7704 /* Display the contents of the version sections. */
7707 process_version_sections (FILE * file
)
7709 Elf_Internal_Shdr
* section
;
7716 for (i
= 0, section
= section_headers
;
7717 i
< elf_header
.e_shnum
;
7720 switch (section
->sh_type
)
7722 case SHT_GNU_verdef
:
7724 Elf_External_Verdef
* edefs
;
7732 (_("\nVersion definition section '%s' contains %u entries:\n"),
7733 SECTION_NAME (section
), section
->sh_info
);
7735 printf (_(" Addr: 0x"));
7736 printf_vma (section
->sh_addr
);
7737 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
7738 (unsigned long) section
->sh_offset
, section
->sh_link
,
7739 section
->sh_link
< elf_header
.e_shnum
7740 ? SECTION_NAME (section_headers
+ section
->sh_link
)
7743 edefs
= (Elf_External_Verdef
*)
7744 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
7745 _("version definition section"));
7746 endbuf
= (char *) edefs
+ section
->sh_size
;
7750 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
7753 Elf_External_Verdef
* edef
;
7754 Elf_Internal_Verdef ent
;
7755 Elf_External_Verdaux
* eaux
;
7756 Elf_Internal_Verdaux aux
;
7760 vstart
= ((char *) edefs
) + idx
;
7761 if (vstart
+ sizeof (*edef
) > endbuf
)
7764 edef
= (Elf_External_Verdef
*) vstart
;
7766 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
7767 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
7768 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
7769 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
7770 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
7771 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
7772 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
7774 printf (_(" %#06x: Rev: %d Flags: %s"),
7775 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
7777 printf (_(" Index: %d Cnt: %d "),
7778 ent
.vd_ndx
, ent
.vd_cnt
);
7780 vstart
+= ent
.vd_aux
;
7782 eaux
= (Elf_External_Verdaux
*) vstart
;
7784 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
7785 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
7787 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
7788 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
7790 printf (_("Name index: %ld\n"), aux
.vda_name
);
7792 isum
= idx
+ ent
.vd_aux
;
7794 for (j
= 1; j
< ent
.vd_cnt
; j
++)
7796 isum
+= aux
.vda_next
;
7797 vstart
+= aux
.vda_next
;
7799 eaux
= (Elf_External_Verdaux
*) vstart
;
7800 if (vstart
+ sizeof (*eaux
) > endbuf
)
7803 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
7804 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
7806 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
7807 printf (_(" %#06x: Parent %d: %s\n"),
7808 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
7810 printf (_(" %#06x: Parent %d, name index: %ld\n"),
7811 isum
, j
, aux
.vda_name
);
7814 printf (_(" Version def aux past end of section\n"));
7818 if (cnt
< section
->sh_info
)
7819 printf (_(" Version definition past end of section\n"));
7825 case SHT_GNU_verneed
:
7827 Elf_External_Verneed
* eneed
;
7834 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
7835 SECTION_NAME (section
), section
->sh_info
);
7837 printf (_(" Addr: 0x"));
7838 printf_vma (section
->sh_addr
);
7839 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
7840 (unsigned long) section
->sh_offset
, section
->sh_link
,
7841 section
->sh_link
< elf_header
.e_shnum
7842 ? SECTION_NAME (section_headers
+ section
->sh_link
)
7845 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
7846 section
->sh_offset
, 1,
7848 _("version need section"));
7849 endbuf
= (char *) eneed
+ section
->sh_size
;
7853 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
7855 Elf_External_Verneed
* entry
;
7856 Elf_Internal_Verneed ent
;
7861 vstart
= ((char *) eneed
) + idx
;
7862 if (vstart
+ sizeof (*entry
) > endbuf
)
7865 entry
= (Elf_External_Verneed
*) vstart
;
7867 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
7868 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
7869 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
7870 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
7871 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
7873 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
7875 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
7876 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
7878 printf (_(" File: %lx"), ent
.vn_file
);
7880 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
7882 vstart
+= ent
.vn_aux
;
7884 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
7886 Elf_External_Vernaux
* eaux
;
7887 Elf_Internal_Vernaux aux
;
7889 if (vstart
+ sizeof (*eaux
) > endbuf
)
7891 eaux
= (Elf_External_Vernaux
*) vstart
;
7893 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
7894 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
7895 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
7896 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
7897 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
7899 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
7900 printf (_(" %#06x: Name: %s"),
7901 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
7903 printf (_(" %#06x: Name index: %lx"),
7904 isum
, aux
.vna_name
);
7906 printf (_(" Flags: %s Version: %d\n"),
7907 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
7909 isum
+= aux
.vna_next
;
7910 vstart
+= aux
.vna_next
;
7913 printf (_(" Version need aux past end of section\n"));
7917 if (cnt
< section
->sh_info
)
7918 printf (_(" Version need past end of section\n"));
7924 case SHT_GNU_versym
:
7926 Elf_Internal_Shdr
* link_section
;
7929 unsigned char * edata
;
7930 unsigned short * data
;
7932 Elf_Internal_Sym
* symbols
;
7933 Elf_Internal_Shdr
* string_sec
;
7936 if (section
->sh_link
>= elf_header
.e_shnum
)
7939 link_section
= section_headers
+ section
->sh_link
;
7940 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
7942 if (link_section
->sh_link
>= elf_header
.e_shnum
)
7947 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
7949 string_sec
= section_headers
+ link_section
->sh_link
;
7951 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
7952 string_sec
->sh_size
,
7953 _("version string table"));
7957 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
7958 SECTION_NAME (section
), total
);
7960 printf (_(" Addr: "));
7961 printf_vma (section
->sh_addr
);
7962 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
7963 (unsigned long) section
->sh_offset
, section
->sh_link
,
7964 SECTION_NAME (link_section
));
7966 off
= offset_from_vma (file
,
7967 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7968 total
* sizeof (short));
7969 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
7971 _("version symbol data"));
7978 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
7980 for (cnt
= total
; cnt
--;)
7981 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
7986 for (cnt
= 0; cnt
< total
; cnt
+= 4)
7989 int check_def
, check_need
;
7992 printf (" %03x:", cnt
);
7994 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
7995 switch (data
[cnt
+ j
])
7998 fputs (_(" 0 (*local*) "), stdout
);
8002 fputs (_(" 1 (*global*) "), stdout
);
8006 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
8007 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
8011 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
8012 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
8015 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
8022 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
8024 Elf_Internal_Verneed ivn
;
8025 unsigned long offset
;
8027 offset
= offset_from_vma
8028 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
8029 sizeof (Elf_External_Verneed
));
8033 Elf_Internal_Vernaux ivna
;
8034 Elf_External_Verneed evn
;
8035 Elf_External_Vernaux evna
;
8036 unsigned long a_off
;
8038 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
8041 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
8042 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
8044 a_off
= offset
+ ivn
.vn_aux
;
8048 get_data (&evna
, file
, a_off
, sizeof (evna
),
8049 1, _("version need aux (2)"));
8051 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
8052 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
8054 a_off
+= ivna
.vna_next
;
8056 while (ivna
.vna_other
!= data
[cnt
+ j
]
8057 && ivna
.vna_next
!= 0);
8059 if (ivna
.vna_other
== data
[cnt
+ j
])
8061 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
8063 if (ivna
.vna_name
>= string_sec
->sh_size
)
8064 name
= _("*invalid*");
8066 name
= strtab
+ ivna
.vna_name
;
8067 nn
+= printf ("(%s%-*s",
8069 12 - (int) strlen (name
),
8075 offset
+= ivn
.vn_next
;
8077 while (ivn
.vn_next
);
8080 if (check_def
&& data
[cnt
+ j
] != 0x8001
8081 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
8083 Elf_Internal_Verdef ivd
;
8084 Elf_External_Verdef evd
;
8085 unsigned long offset
;
8087 offset
= offset_from_vma
8088 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
8093 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
8096 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
8097 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
8099 offset
+= ivd
.vd_next
;
8101 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
8102 && ivd
.vd_next
!= 0);
8104 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
8106 Elf_External_Verdaux evda
;
8107 Elf_Internal_Verdaux ivda
;
8109 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
8111 get_data (&evda
, file
,
8112 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
8114 _("version def aux"));
8116 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
8118 if (ivda
.vda_name
>= string_sec
->sh_size
)
8119 name
= _("*invalid*");
8121 name
= strtab
+ ivda
.vda_name
;
8122 nn
+= printf ("(%s%-*s",
8124 12 - (int) strlen (name
),
8130 printf ("%*c", 18 - nn
, ' ');
8148 printf (_("\nNo version information found in this file.\n"));
8154 get_symbol_binding (unsigned int binding
)
8156 static char buff
[32];
8160 case STB_LOCAL
: return "LOCAL";
8161 case STB_GLOBAL
: return "GLOBAL";
8162 case STB_WEAK
: return "WEAK";
8164 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
8165 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
8167 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
8169 if (binding
== STB_GNU_UNIQUE
8170 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
8171 /* GNU/Linux is still using the default value 0. */
8172 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
8174 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
8177 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
8183 get_symbol_type (unsigned int type
)
8185 static char buff
[32];
8189 case STT_NOTYPE
: return "NOTYPE";
8190 case STT_OBJECT
: return "OBJECT";
8191 case STT_FUNC
: return "FUNC";
8192 case STT_SECTION
: return "SECTION";
8193 case STT_FILE
: return "FILE";
8194 case STT_COMMON
: return "COMMON";
8195 case STT_TLS
: return "TLS";
8196 case STT_RELC
: return "RELC";
8197 case STT_SRELC
: return "SRELC";
8199 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
8201 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
8202 return "THUMB_FUNC";
8204 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
8207 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
8208 return "PARISC_MILLI";
8210 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
8212 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
8214 if (elf_header
.e_machine
== EM_PARISC
)
8216 if (type
== STT_HP_OPAQUE
)
8218 if (type
== STT_HP_STUB
)
8222 if (type
== STT_GNU_IFUNC
8223 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
8224 /* GNU/Linux is still using the default value 0. */
8225 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
8228 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
8231 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
8237 get_symbol_visibility (unsigned int visibility
)
8241 case STV_DEFAULT
: return "DEFAULT";
8242 case STV_INTERNAL
: return "INTERNAL";
8243 case STV_HIDDEN
: return "HIDDEN";
8244 case STV_PROTECTED
: return "PROTECTED";
8250 get_mips_symbol_other (unsigned int other
)
8254 case STO_OPTIONAL
: return "OPTIONAL";
8255 case STO_MIPS16
: return "MIPS16";
8256 case STO_MIPS_PLT
: return "MIPS PLT";
8257 case STO_MIPS_PIC
: return "MIPS PIC";
8258 default: return NULL
;
8263 get_ia64_symbol_other (unsigned int other
)
8267 static char res
[32];
8271 /* Function types is for images and .STB files only. */
8272 switch (elf_header
.e_type
)
8276 switch (VMS_ST_FUNC_TYPE (other
))
8278 case VMS_SFT_CODE_ADDR
:
8279 strcat (res
, " CA");
8281 case VMS_SFT_SYMV_IDX
:
8282 strcat (res
, " VEC");
8285 strcat (res
, " FD");
8287 case VMS_SFT_RESERVE
:
8288 strcat (res
, " RSV");
8297 switch (VMS_ST_LINKAGE (other
))
8299 case VMS_STL_IGNORE
:
8300 strcat (res
, " IGN");
8302 case VMS_STL_RESERVE
:
8303 strcat (res
, " RSV");
8306 strcat (res
, " STD");
8309 strcat (res
, " LNK");
8324 get_symbol_other (unsigned int other
)
8326 const char * result
= NULL
;
8327 static char buff
[32];
8332 switch (elf_header
.e_machine
)
8335 result
= get_mips_symbol_other (other
);
8338 result
= get_ia64_symbol_other (other
);
8347 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
8352 get_symbol_index_type (unsigned int type
)
8354 static char buff
[32];
8358 case SHN_UNDEF
: return "UND";
8359 case SHN_ABS
: return "ABS";
8360 case SHN_COMMON
: return "COM";
8362 if (type
== SHN_IA_64_ANSI_COMMON
8363 && elf_header
.e_machine
== EM_IA_64
8364 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
8366 else if ((elf_header
.e_machine
== EM_X86_64
8367 || elf_header
.e_machine
== EM_L1OM
)
8368 && type
== SHN_X86_64_LCOMMON
)
8370 else if (type
== SHN_MIPS_SCOMMON
8371 && elf_header
.e_machine
== EM_MIPS
)
8373 else if (type
== SHN_MIPS_SUNDEFINED
8374 && elf_header
.e_machine
== EM_MIPS
)
8376 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
8377 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
8378 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
8379 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
8380 else if (type
>= SHN_LORESERVE
)
8381 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
8383 sprintf (buff
, "%3d", type
);
8391 get_dynamic_data (FILE * file
, unsigned int number
, unsigned int ent_size
)
8393 unsigned char * e_data
;
8396 e_data
= (unsigned char *) cmalloc (number
, ent_size
);
8400 error (_("Out of memory\n"));
8404 if (fread (e_data
, ent_size
, number
, file
) != number
)
8406 error (_("Unable to read in dynamic data\n"));
8410 i_data
= (bfd_vma
*) cmalloc (number
, sizeof (*i_data
));
8414 error (_("Out of memory\n"));
8420 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
8428 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
8430 Elf_Internal_Sym
* psym
;
8433 psym
= dynamic_symbols
+ si
;
8435 n
= print_vma (si
, DEC_5
);
8437 fputs (" " + n
, stdout
);
8438 printf (" %3lu: ", hn
);
8439 print_vma (psym
->st_value
, LONG_HEX
);
8441 print_vma (psym
->st_size
, DEC_5
);
8443 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
8444 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
8445 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
8446 /* Check to see if any other bits in the st_other field are set.
8447 Note - displaying this information disrupts the layout of the
8448 table being generated, but for the moment this case is very
8450 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
8451 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
8452 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
8453 if (VALID_DYNAMIC_NAME (psym
->st_name
))
8454 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
8456 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
8460 /* Dump the symbol table. */
8462 process_symbol_table (FILE * file
)
8464 Elf_Internal_Shdr
* section
;
8465 bfd_vma nbuckets
= 0;
8466 bfd_vma nchains
= 0;
8467 bfd_vma
* buckets
= NULL
;
8468 bfd_vma
* chains
= NULL
;
8469 bfd_vma ngnubuckets
= 0;
8470 bfd_vma
* gnubuckets
= NULL
;
8471 bfd_vma
* gnuchains
= NULL
;
8472 bfd_vma gnusymidx
= 0;
8474 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
8477 if (dynamic_info
[DT_HASH
]
8479 || (do_using_dynamic
8481 && dynamic_strings
!= NULL
)))
8483 unsigned char nb
[8];
8484 unsigned char nc
[8];
8485 int hash_ent_size
= 4;
8487 if ((elf_header
.e_machine
== EM_ALPHA
8488 || elf_header
.e_machine
== EM_S390
8489 || elf_header
.e_machine
== EM_S390_OLD
)
8490 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
8494 (archive_file_offset
8495 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
8496 sizeof nb
+ sizeof nc
)),
8499 error (_("Unable to seek to start of dynamic information\n"));
8503 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
8505 error (_("Failed to read in number of buckets\n"));
8509 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
8511 error (_("Failed to read in number of chains\n"));
8515 nbuckets
= byte_get (nb
, hash_ent_size
);
8516 nchains
= byte_get (nc
, hash_ent_size
);
8518 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
8519 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
8522 if (buckets
== NULL
|| chains
== NULL
)
8524 if (do_using_dynamic
)
8535 if (dynamic_info_DT_GNU_HASH
8537 || (do_using_dynamic
8539 && dynamic_strings
!= NULL
)))
8541 unsigned char nb
[16];
8542 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
8543 bfd_vma buckets_vma
;
8546 (archive_file_offset
8547 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
8551 error (_("Unable to seek to start of dynamic information\n"));
8555 if (fread (nb
, 16, 1, file
) != 1)
8557 error (_("Failed to read in number of buckets\n"));
8561 ngnubuckets
= byte_get (nb
, 4);
8562 gnusymidx
= byte_get (nb
+ 4, 4);
8563 bitmaskwords
= byte_get (nb
+ 8, 4);
8564 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
8566 buckets_vma
+= bitmaskwords
* 4;
8568 buckets_vma
+= bitmaskwords
* 8;
8571 (archive_file_offset
8572 + offset_from_vma (file
, buckets_vma
, 4)),
8575 error (_("Unable to seek to start of dynamic information\n"));
8579 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
8581 if (gnubuckets
== NULL
)
8584 for (i
= 0; i
< ngnubuckets
; i
++)
8585 if (gnubuckets
[i
] != 0)
8587 if (gnubuckets
[i
] < gnusymidx
)
8590 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
8591 maxchain
= gnubuckets
[i
];
8594 if (maxchain
== 0xffffffff)
8597 maxchain
-= gnusymidx
;
8600 (archive_file_offset
8601 + offset_from_vma (file
, buckets_vma
8602 + 4 * (ngnubuckets
+ maxchain
), 4)),
8605 error (_("Unable to seek to start of dynamic information\n"));
8611 if (fread (nb
, 4, 1, file
) != 1)
8613 error (_("Failed to determine last chain length\n"));
8617 if (maxchain
+ 1 == 0)
8622 while ((byte_get (nb
, 4) & 1) == 0);
8625 (archive_file_offset
8626 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
8629 error (_("Unable to seek to start of dynamic information\n"));
8633 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
8636 if (gnuchains
== NULL
)
8641 if (do_using_dynamic
)
8646 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
8649 && dynamic_strings
!= NULL
)
8653 if (dynamic_info
[DT_HASH
])
8657 printf (_("\nSymbol table for image:\n"));
8659 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8661 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8663 for (hn
= 0; hn
< nbuckets
; hn
++)
8668 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
8669 print_dynamic_symbol (si
, hn
);
8673 if (dynamic_info_DT_GNU_HASH
)
8675 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
8677 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8679 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8681 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
8682 if (gnubuckets
[hn
] != 0)
8684 bfd_vma si
= gnubuckets
[hn
];
8685 bfd_vma off
= si
- gnusymidx
;
8689 print_dynamic_symbol (si
, hn
);
8692 while ((gnuchains
[off
++] & 1) == 0);
8696 else if (do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
8700 for (i
= 0, section
= section_headers
;
8701 i
< elf_header
.e_shnum
;
8705 char * strtab
= NULL
;
8706 unsigned long int strtab_size
= 0;
8707 Elf_Internal_Sym
* symtab
;
8708 Elf_Internal_Sym
* psym
;
8710 if ((section
->sh_type
!= SHT_SYMTAB
8711 && section
->sh_type
!= SHT_DYNSYM
)
8713 && section
->sh_type
== SHT_SYMTAB
))
8716 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
8717 SECTION_NAME (section
),
8718 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
8720 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
8722 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
8724 symtab
= GET_ELF_SYMBOLS (file
, section
);
8728 if (section
->sh_link
== elf_header
.e_shstrndx
)
8730 strtab
= string_table
;
8731 strtab_size
= string_table_length
;
8733 else if (section
->sh_link
< elf_header
.e_shnum
)
8735 Elf_Internal_Shdr
* string_sec
;
8737 string_sec
= section_headers
+ section
->sh_link
;
8739 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
8740 1, string_sec
->sh_size
,
8742 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
8745 for (si
= 0, psym
= symtab
;
8746 si
< section
->sh_size
/ section
->sh_entsize
;
8749 printf ("%6d: ", si
);
8750 print_vma (psym
->st_value
, LONG_HEX
);
8752 print_vma (psym
->st_size
, DEC_5
);
8753 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
8754 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
8755 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
8756 /* Check to see if any other bits in the st_other field are set.
8757 Note - displaying this information disrupts the layout of the
8758 table being generated, but for the moment this case is very rare. */
8759 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
8760 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
8761 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
8762 print_symbol (25, psym
->st_name
< strtab_size
8763 ? strtab
+ psym
->st_name
: _("<corrupt>"));
8765 if (section
->sh_type
== SHT_DYNSYM
&&
8766 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
8768 unsigned char data
[2];
8769 unsigned short vers_data
;
8770 unsigned long offset
;
8774 offset
= offset_from_vma
8775 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
8776 sizeof data
+ si
* sizeof (vers_data
));
8778 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
8779 sizeof (data
), 1, _("version data"));
8781 vers_data
= byte_get (data
, 2);
8783 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
8784 && section_headers
[psym
->st_shndx
].sh_type
8787 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
8789 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
8791 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
8792 && (is_nobits
|| ! check_def
))
8794 Elf_External_Verneed evn
;
8795 Elf_Internal_Verneed ivn
;
8796 Elf_Internal_Vernaux ivna
;
8798 /* We must test both. */
8799 offset
= offset_from_vma
8800 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
8805 unsigned long vna_off
;
8807 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
8810 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
8811 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
8813 vna_off
= offset
+ ivn
.vn_aux
;
8817 Elf_External_Vernaux evna
;
8819 get_data (&evna
, file
, vna_off
,
8821 _("version need aux (3)"));
8823 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
8824 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
8825 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
8827 vna_off
+= ivna
.vna_next
;
8829 while (ivna
.vna_other
!= vers_data
8830 && ivna
.vna_next
!= 0);
8832 if (ivna
.vna_other
== vers_data
)
8835 offset
+= ivn
.vn_next
;
8837 while (ivn
.vn_next
!= 0);
8839 if (ivna
.vna_other
== vers_data
)
8842 ivna
.vna_name
< strtab_size
8843 ? strtab
+ ivna
.vna_name
: _("<corrupt>"),
8847 else if (! is_nobits
)
8848 error (_("bad dynamic symbol\n"));
8855 if (vers_data
!= 0x8001
8856 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
8858 Elf_Internal_Verdef ivd
;
8859 Elf_Internal_Verdaux ivda
;
8860 Elf_External_Verdaux evda
;
8863 off
= offset_from_vma
8865 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
8866 sizeof (Elf_External_Verdef
));
8870 Elf_External_Verdef evd
;
8872 get_data (&evd
, file
, off
, sizeof (evd
),
8873 1, _("version def"));
8875 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
8876 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
8877 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
8881 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
8882 && ivd
.vd_next
!= 0);
8887 get_data (&evda
, file
, off
, sizeof (evda
),
8888 1, _("version def aux"));
8890 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
8892 if (psym
->st_name
!= ivda
.vda_name
)
8893 printf ((vers_data
& VERSYM_HIDDEN
)
8895 ivda
.vda_name
< strtab_size
8896 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
8906 if (strtab
!= string_table
)
8912 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
8914 if (do_histogram
&& buckets
!= NULL
)
8916 unsigned long * lengths
;
8917 unsigned long * counts
;
8920 unsigned long maxlength
= 0;
8921 unsigned long nzero_counts
= 0;
8922 unsigned long nsyms
= 0;
8924 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
8925 (unsigned long) nbuckets
);
8926 printf (_(" Length Number %% of total Coverage\n"));
8928 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
8929 if (lengths
== NULL
)
8931 error (_("Out of memory\n"));
8934 for (hn
= 0; hn
< nbuckets
; ++hn
)
8936 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
8939 if (maxlength
< ++lengths
[hn
])
8944 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
8947 error (_("Out of memory\n"));
8951 for (hn
= 0; hn
< nbuckets
; ++hn
)
8952 ++counts
[lengths
[hn
]];
8957 printf (" 0 %-10lu (%5.1f%%)\n",
8958 counts
[0], (counts
[0] * 100.0) / nbuckets
);
8959 for (i
= 1; i
<= maxlength
; ++i
)
8961 nzero_counts
+= counts
[i
] * i
;
8962 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
8963 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
8964 (nzero_counts
* 100.0) / nsyms
);
8972 if (buckets
!= NULL
)
8978 if (do_histogram
&& gnubuckets
!= NULL
)
8980 unsigned long * lengths
;
8981 unsigned long * counts
;
8983 unsigned long maxlength
= 0;
8984 unsigned long nzero_counts
= 0;
8985 unsigned long nsyms
= 0;
8987 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
8988 if (lengths
== NULL
)
8990 error (_("Out of memory\n"));
8994 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
8995 (unsigned long) ngnubuckets
);
8996 printf (_(" Length Number %% of total Coverage\n"));
8998 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
8999 if (gnubuckets
[hn
] != 0)
9001 bfd_vma off
, length
= 1;
9003 for (off
= gnubuckets
[hn
] - gnusymidx
;
9004 (gnuchains
[off
] & 1) == 0; ++off
)
9006 lengths
[hn
] = length
;
9007 if (length
> maxlength
)
9012 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
9015 error (_("Out of memory\n"));
9019 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9020 ++counts
[lengths
[hn
]];
9022 if (ngnubuckets
> 0)
9025 printf (" 0 %-10lu (%5.1f%%)\n",
9026 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
9027 for (j
= 1; j
<= maxlength
; ++j
)
9029 nzero_counts
+= counts
[j
] * j
;
9030 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9031 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
9032 (nzero_counts
* 100.0) / nsyms
);
9046 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
9050 if (dynamic_syminfo
== NULL
9052 /* No syminfo, this is ok. */
9055 /* There better should be a dynamic symbol section. */
9056 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
9060 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9061 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
9063 printf (_(" Num: Name BoundTo Flags\n"));
9064 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
9066 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
9068 printf ("%4d: ", i
);
9069 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
9070 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
9072 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
9075 switch (dynamic_syminfo
[i
].si_boundto
)
9077 case SYMINFO_BT_SELF
:
9078 fputs ("SELF ", stdout
);
9080 case SYMINFO_BT_PARENT
:
9081 fputs ("PARENT ", stdout
);
9084 if (dynamic_syminfo
[i
].si_boundto
> 0
9085 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
9086 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
9088 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
9092 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
9096 if (flags
& SYMINFO_FLG_DIRECT
)
9098 if (flags
& SYMINFO_FLG_PASSTHRU
)
9099 printf (" PASSTHRU");
9100 if (flags
& SYMINFO_FLG_COPY
)
9102 if (flags
& SYMINFO_FLG_LAZYLOAD
)
9103 printf (" LAZYLOAD");
9111 /* Check to see if the given reloc needs to be handled in a target specific
9112 manner. If so then process the reloc and return TRUE otherwise return
9116 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
9117 unsigned char * start
,
9118 Elf_Internal_Sym
* symtab
)
9120 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
9122 switch (elf_header
.e_machine
)
9125 case EM_CYGNUS_MN10300
:
9127 static Elf_Internal_Sym
* saved_sym
= NULL
;
9131 case 34: /* R_MN10300_ALIGN */
9133 case 33: /* R_MN10300_SYM_DIFF */
9134 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
9136 case 1: /* R_MN10300_32 */
9137 case 2: /* R_MN10300_16 */
9138 if (saved_sym
!= NULL
)
9142 value
= reloc
->r_addend
9143 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
9144 - saved_sym
->st_value
);
9146 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
9153 if (saved_sym
!= NULL
)
9154 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9164 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9165 DWARF debug sections. This is a target specific test. Note - we do not
9166 go through the whole including-target-headers-multiple-times route, (as
9167 we have already done with <elf/h8.h>) because this would become very
9168 messy and even then this function would have to contain target specific
9169 information (the names of the relocs instead of their numeric values).
9170 FIXME: This is not the correct way to solve this problem. The proper way
9171 is to have target specific reloc sizing and typing functions created by
9172 the reloc-macros.h header, in the same way that it already creates the
9173 reloc naming functions. */
9176 is_32bit_abs_reloc (unsigned int reloc_type
)
9178 switch (elf_header
.e_machine
)
9182 return reloc_type
== 1; /* R_386_32. */
9184 return reloc_type
== 1; /* R_68K_32. */
9186 return reloc_type
== 1; /* R_860_32. */
9188 return reloc_type
== 1; /* XXX Is this right ? */
9190 return reloc_type
== 1; /* R_ARC_32. */
9192 return reloc_type
== 2; /* R_ARM_ABS32 */
9195 return reloc_type
== 1;
9197 return reloc_type
== 0x12; /* R_byte4_data. */
9199 return reloc_type
== 3; /* R_CRIS_32. */
9202 return reloc_type
== 3; /* R_CR16_NUM32. */
9204 return reloc_type
== 15; /* R_CRX_NUM32. */
9206 return reloc_type
== 1;
9207 case EM_CYGNUS_D10V
:
9209 return reloc_type
== 6; /* R_D10V_32. */
9210 case EM_CYGNUS_D30V
:
9212 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
9214 return reloc_type
== 3; /* R_DLX_RELOC_32. */
9215 case EM_CYGNUS_FR30
:
9217 return reloc_type
== 3; /* R_FR30_32. */
9221 return reloc_type
== 1; /* R_H8_DIR32. */
9223 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
9226 return reloc_type
== 2; /* R_IP2K_32. */
9228 return reloc_type
== 2; /* R_IQ2000_32. */
9229 case EM_LATTICEMICO32
:
9230 return reloc_type
== 3; /* R_LM32_32. */
9233 return reloc_type
== 3; /* R_M32C_32. */
9235 return reloc_type
== 34; /* R_M32R_32_RELA. */
9237 return reloc_type
== 1; /* R_MCORE_ADDR32. */
9239 return reloc_type
== 4; /* R_MEP_32. */
9241 return reloc_type
== 2; /* R_MIPS_32. */
9243 return reloc_type
== 4; /* R_MMIX_32. */
9244 case EM_CYGNUS_MN10200
:
9246 return reloc_type
== 1; /* R_MN10200_32. */
9247 case EM_CYGNUS_MN10300
:
9249 return reloc_type
== 1; /* R_MN10300_32. */
9251 return reloc_type
== 1; /* R_MOXIE_32. */
9254 return reloc_type
== 1; /* R_MSP43_32. */
9256 return reloc_type
== 2; /* R_MT_32. */
9257 case EM_ALTERA_NIOS2
:
9259 return reloc_type
== 1; /* R_NIOS_32. */
9262 return reloc_type
== 1; /* R_OR32_32. */
9264 return (reloc_type
== 1 /* R_PARISC_DIR32. */
9265 || reloc_type
== 41); /* R_PARISC_SECREL32. */
9268 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
9270 return reloc_type
== 1; /* R_PPC64_ADDR32. */
9272 return reloc_type
== 1; /* R_PPC_ADDR32. */
9274 return reloc_type
== 1; /* R_RX_DIR32. */
9276 return reloc_type
== 1; /* R_I370_ADDR31. */
9279 return reloc_type
== 4; /* R_S390_32. */
9281 return reloc_type
== 8; /* R_SCORE_ABS32. */
9283 return reloc_type
== 1; /* R_SH_DIR32. */
9284 case EM_SPARC32PLUS
:
9287 return reloc_type
== 3 /* R_SPARC_32. */
9288 || reloc_type
== 23; /* R_SPARC_UA32. */
9290 return reloc_type
== 6; /* R_SPU_ADDR32 */
9292 return reloc_type
== 1; /* R_C6000_ABS32. */
9293 case EM_CYGNUS_V850
:
9295 return reloc_type
== 6; /* R_V850_ABS32. */
9297 return reloc_type
== 1; /* R_VAX_32. */
9300 return reloc_type
== 10; /* R_X86_64_32. */
9303 return reloc_type
== 3; /* R_XC16C_ABS_32. */
9305 return reloc_type
== 1; /* R_XSTROMY16_32. */
9308 return reloc_type
== 1; /* R_XTENSA_32. */
9310 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
9311 elf_header
.e_machine
);
9316 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9317 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
9320 is_32bit_pcrel_reloc (unsigned int reloc_type
)
9322 switch (elf_header
.e_machine
)
9326 return reloc_type
== 2; /* R_386_PC32. */
9328 return reloc_type
== 4; /* R_68K_PC32. */
9330 return reloc_type
== 10; /* R_ALPHA_SREL32. */
9332 return reloc_type
== 3; /* R_ARM_REL32 */
9334 return reloc_type
== 9; /* R_PARISC_PCREL32. */
9336 return reloc_type
== 26; /* R_PPC_REL32. */
9338 return reloc_type
== 26; /* R_PPC64_REL32. */
9341 return reloc_type
== 5; /* R_390_PC32. */
9343 return reloc_type
== 2; /* R_SH_REL32. */
9344 case EM_SPARC32PLUS
:
9347 return reloc_type
== 6; /* R_SPARC_DISP32. */
9349 return reloc_type
== 13; /* R_SPU_REL32. */
9352 return reloc_type
== 2; /* R_X86_64_PC32. */
9355 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
9357 /* Do not abort or issue an error message here. Not all targets use
9358 pc-relative 32-bit relocs in their DWARF debug information and we
9359 have already tested for target coverage in is_32bit_abs_reloc. A
9360 more helpful warning message will be generated by apply_relocations
9361 anyway, so just return. */
9366 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9367 a 64-bit absolute RELA relocation used in DWARF debug sections. */
9370 is_64bit_abs_reloc (unsigned int reloc_type
)
9372 switch (elf_header
.e_machine
)
9375 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
9377 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
9379 return reloc_type
== 80; /* R_PARISC_DIR64. */
9381 return reloc_type
== 38; /* R_PPC64_ADDR64. */
9382 case EM_SPARC32PLUS
:
9385 return reloc_type
== 54; /* R_SPARC_UA64. */
9388 return reloc_type
== 1; /* R_X86_64_64. */
9391 return reloc_type
== 22; /* R_S390_64 */
9393 return reloc_type
== 18; /* R_MIPS_64 */
9399 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
9400 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
9403 is_64bit_pcrel_reloc (unsigned int reloc_type
)
9405 switch (elf_header
.e_machine
)
9408 return reloc_type
== 11; /* R_ALPHA_SREL64 */
9410 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB */
9412 return reloc_type
== 72; /* R_PARISC_PCREL64 */
9414 return reloc_type
== 44; /* R_PPC64_REL64 */
9415 case EM_SPARC32PLUS
:
9418 return reloc_type
== 46; /* R_SPARC_DISP64 */
9421 return reloc_type
== 24; /* R_X86_64_PC64 */
9424 return reloc_type
== 23; /* R_S390_PC64 */
9430 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9431 a 24-bit absolute RELA relocation used in DWARF debug sections. */
9434 is_24bit_abs_reloc (unsigned int reloc_type
)
9436 switch (elf_header
.e_machine
)
9438 case EM_CYGNUS_MN10200
:
9440 return reloc_type
== 4; /* R_MN10200_24. */
9446 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9447 a 16-bit absolute RELA relocation used in DWARF debug sections. */
9450 is_16bit_abs_reloc (unsigned int reloc_type
)
9452 switch (elf_header
.e_machine
)
9456 return reloc_type
== 4; /* R_AVR_16. */
9457 case EM_CYGNUS_D10V
:
9459 return reloc_type
== 3; /* R_D10V_16. */
9463 return reloc_type
== R_H8_DIR16
;
9466 return reloc_type
== 1; /* R_IP2K_16. */
9469 return reloc_type
== 1; /* R_M32C_16 */
9472 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
9473 case EM_ALTERA_NIOS2
:
9475 return reloc_type
== 9; /* R_NIOS_16. */
9477 return reloc_type
== 2; /* R_C6000_ABS16. */
9480 return reloc_type
== 2; /* R_XC16C_ABS_16. */
9486 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
9487 relocation entries (possibly formerly used for SHT_GROUP sections). */
9490 is_none_reloc (unsigned int reloc_type
)
9492 switch (elf_header
.e_machine
)
9494 case EM_68K
: /* R_68K_NONE. */
9495 case EM_386
: /* R_386_NONE. */
9496 case EM_SPARC32PLUS
:
9498 case EM_SPARC
: /* R_SPARC_NONE. */
9499 case EM_MIPS
: /* R_MIPS_NONE. */
9500 case EM_PARISC
: /* R_PARISC_NONE. */
9501 case EM_ALPHA
: /* R_ALPHA_NONE. */
9502 case EM_PPC
: /* R_PPC_NONE. */
9503 case EM_PPC64
: /* R_PPC64_NONE. */
9504 case EM_ARM
: /* R_ARM_NONE. */
9505 case EM_IA_64
: /* R_IA64_NONE. */
9506 case EM_SH
: /* R_SH_NONE. */
9508 case EM_S390
: /* R_390_NONE. */
9509 case EM_CRIS
: /* R_CRIS_NONE. */
9510 case EM_X86_64
: /* R_X86_64_NONE. */
9511 case EM_L1OM
: /* R_X86_64_NONE. */
9512 case EM_MN10300
: /* R_MN10300_NONE. */
9513 case EM_MOXIE
: /* R_MOXIE_NONE. */
9514 case EM_M32R
: /* R_M32R_NONE. */
9515 case EM_TI_C6000
:/* R_C6000_NONE. */
9517 case EM_C166
: /* R_XC16X_NONE. */
9518 return reloc_type
== 0;
9521 return (reloc_type
== 0 /* R_XTENSA_NONE. */
9522 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
9523 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
9524 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
9529 /* Apply relocations to a section.
9530 Note: So far support has been added only for those relocations
9531 which can be found in debug sections.
9532 FIXME: Add support for more relocations ? */
9535 apply_relocations (void * file
,
9536 Elf_Internal_Shdr
* section
,
9537 unsigned char * start
)
9539 Elf_Internal_Shdr
* relsec
;
9540 unsigned char * end
= start
+ section
->sh_size
;
9542 if (elf_header
.e_type
!= ET_REL
)
9545 /* Find the reloc section associated with the section. */
9546 for (relsec
= section_headers
;
9547 relsec
< section_headers
+ elf_header
.e_shnum
;
9550 bfd_boolean is_rela
;
9551 unsigned long num_relocs
;
9552 Elf_Internal_Rela
* relocs
;
9553 Elf_Internal_Rela
* rp
;
9554 Elf_Internal_Shdr
* symsec
;
9555 Elf_Internal_Sym
* symtab
;
9556 Elf_Internal_Sym
* sym
;
9558 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
9559 || relsec
->sh_info
>= elf_header
.e_shnum
9560 || section_headers
+ relsec
->sh_info
!= section
9561 || relsec
->sh_size
== 0
9562 || relsec
->sh_link
>= elf_header
.e_shnum
)
9565 is_rela
= relsec
->sh_type
== SHT_RELA
;
9569 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
9570 relsec
->sh_size
, & relocs
, & num_relocs
))
9575 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
9576 relsec
->sh_size
, & relocs
, & num_relocs
))
9580 /* SH uses RELA but uses in place value instead of the addend field. */
9581 if (elf_header
.e_machine
== EM_SH
)
9584 symsec
= section_headers
+ relsec
->sh_link
;
9585 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
);
9587 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
9590 unsigned int reloc_type
;
9591 unsigned int reloc_size
;
9592 unsigned char * rloc
;
9594 reloc_type
= get_reloc_type (rp
->r_info
);
9596 if (target_specific_reloc_handling (rp
, start
, symtab
))
9598 else if (is_none_reloc (reloc_type
))
9600 else if (is_32bit_abs_reloc (reloc_type
)
9601 || is_32bit_pcrel_reloc (reloc_type
))
9603 else if (is_64bit_abs_reloc (reloc_type
)
9604 || is_64bit_pcrel_reloc (reloc_type
))
9606 else if (is_24bit_abs_reloc (reloc_type
))
9608 else if (is_16bit_abs_reloc (reloc_type
))
9612 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
9613 reloc_type
, SECTION_NAME (section
));
9617 rloc
= start
+ rp
->r_offset
;
9618 if ((rloc
+ reloc_size
) > end
)
9620 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
9621 (unsigned long) rp
->r_offset
,
9622 SECTION_NAME (section
));
9626 sym
= symtab
+ get_reloc_symindex (rp
->r_info
);
9628 /* If the reloc has a symbol associated with it,
9629 make sure that it is of an appropriate type.
9631 Relocations against symbols without type can happen.
9632 Gcc -feliminate-dwarf2-dups may generate symbols
9633 without type for debug info.
9635 Icc generates relocations against function symbols
9636 instead of local labels.
9638 Relocations against object symbols can happen, eg when
9639 referencing a global array. For an example of this see
9640 the _clz.o binary in libgcc.a. */
9642 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
9644 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
9645 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
9646 (long int)(rp
- relocs
),
9647 SECTION_NAME (relsec
));
9653 addend
+= rp
->r_addend
;
9654 /* R_XTENSA_32 and R_PJ_DATA_DIR32 are partial_inplace. */
9656 || (elf_header
.e_machine
== EM_XTENSA
9658 || ((elf_header
.e_machine
== EM_PJ
9659 || elf_header
.e_machine
== EM_PJ_OLD
)
9660 && reloc_type
== 1))
9661 addend
+= byte_get (rloc
, reloc_size
);
9663 if (is_32bit_pcrel_reloc (reloc_type
)
9664 || is_64bit_pcrel_reloc (reloc_type
))
9666 /* On HPPA, all pc-relative relocations are biased by 8. */
9667 if (elf_header
.e_machine
== EM_PARISC
)
9669 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
9673 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
9682 #ifdef SUPPORT_DISASSEMBLY
9684 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
9686 printf (_("\nAssembly dump of section %s\n"),
9687 SECTION_NAME (section
));
9689 /* XXX -- to be done --- XXX */
9695 /* Reads in the contents of SECTION from FILE, returning a pointer
9696 to a malloc'ed buffer or NULL if something went wrong. */
9699 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
9701 bfd_size_type num_bytes
;
9703 num_bytes
= section
->sh_size
;
9705 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
9707 printf (_("\nSection '%s' has no data to dump.\n"),
9708 SECTION_NAME (section
));
9712 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
9713 _("section contents"));
9718 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
9720 Elf_Internal_Shdr
* relsec
;
9721 bfd_size_type num_bytes
;
9725 char * name
= SECTION_NAME (section
);
9726 bfd_boolean some_strings_shown
;
9728 start
= get_section_contents (section
, file
);
9732 printf (_("\nString dump of section '%s':\n"), name
);
9734 /* If the section being dumped has relocations against it the user might
9735 be expecting these relocations to have been applied. Check for this
9736 case and issue a warning message in order to avoid confusion.
9737 FIXME: Maybe we ought to have an option that dumps a section with
9739 for (relsec
= section_headers
;
9740 relsec
< section_headers
+ elf_header
.e_shnum
;
9743 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
9744 || relsec
->sh_info
>= elf_header
.e_shnum
9745 || section_headers
+ relsec
->sh_info
!= section
9746 || relsec
->sh_size
== 0
9747 || relsec
->sh_link
>= elf_header
.e_shnum
)
9750 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
9754 num_bytes
= section
->sh_size
;
9756 end
= start
+ num_bytes
;
9757 some_strings_shown
= FALSE
;
9761 while (!ISPRINT (* data
))
9768 /* PR 11128: Use two separate invocations in order to work
9769 around bugs in the Solaris 8 implementation of printf. */
9770 printf (" [%6tx] ", data
- start
);
9771 printf ("%s\n", data
);
9773 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
9775 data
+= strlen (data
);
9776 some_strings_shown
= TRUE
;
9780 if (! some_strings_shown
)
9781 printf (_(" No strings found in this section."));
9789 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
9791 bfd_boolean relocate
)
9793 Elf_Internal_Shdr
* relsec
;
9794 bfd_size_type bytes
;
9796 unsigned char * data
;
9797 unsigned char * start
;
9799 start
= (unsigned char *) get_section_contents (section
, file
);
9803 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
9807 apply_relocations (file
, section
, start
);
9811 /* If the section being dumped has relocations against it the user might
9812 be expecting these relocations to have been applied. Check for this
9813 case and issue a warning message in order to avoid confusion.
9814 FIXME: Maybe we ought to have an option that dumps a section with
9816 for (relsec
= section_headers
;
9817 relsec
< section_headers
+ elf_header
.e_shnum
;
9820 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
9821 || relsec
->sh_info
>= elf_header
.e_shnum
9822 || section_headers
+ relsec
->sh_info
!= section
9823 || relsec
->sh_size
== 0
9824 || relsec
->sh_link
>= elf_header
.e_shnum
)
9827 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
9832 addr
= section
->sh_addr
;
9833 bytes
= section
->sh_size
;
9842 lbytes
= (bytes
> 16 ? 16 : bytes
);
9844 printf (" 0x%8.8lx ", (unsigned long) addr
);
9846 for (j
= 0; j
< 16; j
++)
9849 printf ("%2.2x", data
[j
]);
9857 for (j
= 0; j
< lbytes
; j
++)
9860 if (k
>= ' ' && k
< 0x7f)
9878 /* Uncompresses a section that was compressed using zlib, in place.
9879 This is a copy of bfd_uncompress_section_contents, in bfd/compress.c */
9882 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED
,
9883 dwarf_size_type
*size ATTRIBUTE_UNUSED
)
9888 dwarf_size_type compressed_size
= *size
;
9889 unsigned char * compressed_buffer
= *buffer
;
9890 dwarf_size_type uncompressed_size
;
9891 unsigned char * uncompressed_buffer
;
9894 dwarf_size_type header_size
= 12;
9896 /* Read the zlib header. In this case, it should be "ZLIB" followed
9897 by the uncompressed section size, 8 bytes in big-endian order. */
9898 if (compressed_size
< header_size
9899 || ! streq ((char *) compressed_buffer
, "ZLIB"))
9902 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
9903 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
9904 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
9905 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
9906 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
9907 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
9908 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
9909 uncompressed_size
+= compressed_buffer
[11];
9911 /* It is possible the section consists of several compressed
9912 buffers concatenated together, so we uncompress in a loop. */
9916 strm
.avail_in
= compressed_size
- header_size
;
9917 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
9918 strm
.avail_out
= uncompressed_size
;
9919 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
9921 rc
= inflateInit (& strm
);
9922 while (strm
.avail_in
> 0)
9926 strm
.next_out
= ((Bytef
*) uncompressed_buffer
9927 + (uncompressed_size
- strm
.avail_out
));
9928 rc
= inflate (&strm
, Z_FINISH
);
9929 if (rc
!= Z_STREAM_END
)
9931 rc
= inflateReset (& strm
);
9933 rc
= inflateEnd (& strm
);
9935 || strm
.avail_out
!= 0)
9938 free (compressed_buffer
);
9939 *buffer
= uncompressed_buffer
;
9940 *size
= uncompressed_size
;
9944 free (uncompressed_buffer
);
9946 #endif /* HAVE_ZLIB_H */
9950 load_specific_debug_section (enum dwarf_section_display_enum debug
,
9951 Elf_Internal_Shdr
* sec
, void * file
)
9953 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
9955 int section_is_compressed
;
9957 /* If it is already loaded, do nothing. */
9958 if (section
->start
!= NULL
)
9961 section_is_compressed
= section
->name
== section
->compressed_name
;
9963 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
9964 section
->address
= sec
->sh_addr
;
9965 section
->size
= sec
->sh_size
;
9966 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
9969 if (section
->start
== NULL
)
9972 if (section_is_compressed
)
9974 if (! uncompress_section_contents (§ion
->start
, §ion
->size
))
9976 sec
->sh_size
= section
->size
;
9979 if (debug_displays
[debug
].relocate
)
9980 apply_relocations ((FILE *) file
, sec
, section
->start
);
9986 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
9988 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
9989 Elf_Internal_Shdr
* sec
;
9991 /* Locate the debug section. */
9992 sec
= find_section (section
->uncompressed_name
);
9994 section
->name
= section
->uncompressed_name
;
9997 sec
= find_section (section
->compressed_name
);
9999 section
->name
= section
->compressed_name
;
10004 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
10008 free_debug_section (enum dwarf_section_display_enum debug
)
10010 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
10012 if (section
->start
== NULL
)
10015 free ((char *) section
->start
);
10016 section
->start
= NULL
;
10017 section
->address
= 0;
10022 display_debug_section (Elf_Internal_Shdr
* section
, FILE * file
)
10024 char * name
= SECTION_NAME (section
);
10025 bfd_size_type length
;
10029 length
= section
->sh_size
;
10032 printf (_("\nSection '%s' has no debugging data.\n"), name
);
10035 if (section
->sh_type
== SHT_NOBITS
)
10037 /* There is no point in dumping the contents of a debugging section
10038 which has the NOBITS type - the bits in the file will be random.
10039 This can happen when a file containing a .eh_frame section is
10040 stripped with the --only-keep-debug command line option. */
10041 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name
);
10045 if (const_strneq (name
, ".gnu.linkonce.wi."))
10046 name
= ".debug_info";
10048 /* See if we know how to display the contents of this section. */
10049 for (i
= 0; i
< max
; i
++)
10050 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
10051 || streq (debug_displays
[i
].section
.compressed_name
, name
))
10053 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
10054 int secondary
= (section
!= find_section (name
));
10057 free_debug_section ((enum dwarf_section_display_enum
) i
);
10059 if (streq (sec
->uncompressed_name
, name
))
10060 sec
->name
= sec
->uncompressed_name
;
10062 sec
->name
= sec
->compressed_name
;
10063 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
10066 result
&= debug_displays
[i
].display (sec
, file
);
10068 if (secondary
|| (i
!= info
&& i
!= abbrev
))
10069 free_debug_section ((enum dwarf_section_display_enum
) i
);
10077 printf (_("Unrecognized debug section: %s\n"), name
);
10084 /* Set DUMP_SECTS for all sections where dumps were requested
10085 based on section name. */
10088 initialise_dumps_byname (void)
10090 struct dump_list_entry
* cur
;
10092 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
10097 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
10098 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
10100 request_dump_bynumber (i
, cur
->type
);
10105 warn (_("Section '%s' was not dumped because it does not exist!\n"),
10111 process_section_contents (FILE * file
)
10113 Elf_Internal_Shdr
* section
;
10119 initialise_dumps_byname ();
10121 for (i
= 0, section
= section_headers
;
10122 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
10125 #ifdef SUPPORT_DISASSEMBLY
10126 if (dump_sects
[i
] & DISASS_DUMP
)
10127 disassemble_section (section
, file
);
10129 if (dump_sects
[i
] & HEX_DUMP
)
10130 dump_section_as_bytes (section
, file
, FALSE
);
10132 if (dump_sects
[i
] & RELOC_DUMP
)
10133 dump_section_as_bytes (section
, file
, TRUE
);
10135 if (dump_sects
[i
] & STRING_DUMP
)
10136 dump_section_as_strings (section
, file
);
10138 if (dump_sects
[i
] & DEBUG_DUMP
)
10139 display_debug_section (section
, file
);
10142 /* Check to see if the user requested a
10143 dump of a section that does not exist. */
10144 while (i
++ < num_dump_sects
)
10146 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
10150 process_mips_fpe_exception (int mask
)
10155 if (mask
& OEX_FPU_INEX
)
10156 fputs ("INEX", stdout
), first
= 0;
10157 if (mask
& OEX_FPU_UFLO
)
10158 printf ("%sUFLO", first
? "" : "|"), first
= 0;
10159 if (mask
& OEX_FPU_OFLO
)
10160 printf ("%sOFLO", first
? "" : "|"), first
= 0;
10161 if (mask
& OEX_FPU_DIV0
)
10162 printf ("%sDIV0", first
? "" : "|"), first
= 0;
10163 if (mask
& OEX_FPU_INVAL
)
10164 printf ("%sINVAL", first
? "" : "|");
10167 fputs ("0", stdout
);
10170 /* ARM EABI attributes section. */
10175 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
10177 const char ** table
;
10178 } arm_attr_public_tag
;
10180 static const char * arm_attr_tag_CPU_arch
[] =
10181 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
10182 "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
10183 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
10184 static const char * arm_attr_tag_THUMB_ISA_use
[] =
10185 {"No", "Thumb-1", "Thumb-2"};
10186 static const char * arm_attr_tag_FP_arch
[] =
10187 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
10188 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
10189 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
10190 {"No", "NEONv1", "NEONv1 with Fused-MAC"};
10191 static const char * arm_attr_tag_PCS_config
[] =
10192 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
10193 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
10194 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
10195 {"V6", "SB", "TLS", "Unused"};
10196 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
10197 {"Absolute", "PC-relative", "SB-relative", "None"};
10198 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
10199 {"Absolute", "PC-relative", "None"};
10200 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
10201 {"None", "direct", "GOT-indirect"};
10202 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
10203 {"None", "??? 1", "2", "??? 3", "4"};
10204 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
10205 static const char * arm_attr_tag_ABI_FP_denormal
[] =
10206 {"Unused", "Needed", "Sign only"};
10207 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
10208 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
10209 static const char * arm_attr_tag_ABI_FP_number_model
[] =
10210 {"Unused", "Finite", "RTABI", "IEEE 754"};
10211 static const char * arm_attr_tag_ABI_enum_size
[] =
10212 {"Unused", "small", "int", "forced to int"};
10213 static const char * arm_attr_tag_ABI_HardFP_use
[] =
10214 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
10215 static const char * arm_attr_tag_ABI_VFP_args
[] =
10216 {"AAPCS", "VFP registers", "custom"};
10217 static const char * arm_attr_tag_ABI_WMMX_args
[] =
10218 {"AAPCS", "WMMX registers", "custom"};
10219 static const char * arm_attr_tag_ABI_optimization_goals
[] =
10220 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10221 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
10222 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
10223 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10224 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
10225 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
10226 static const char * arm_attr_tag_FP_HP_extension
[] =
10227 {"Not Allowed", "Allowed"};
10228 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
10229 {"None", "IEEE 754", "Alternative Format"};
10230 static const char * arm_attr_tag_MPextension_use
[] =
10231 {"Not Allowed", "Allowed"};
10232 static const char * arm_attr_tag_DIV_use
[] =
10233 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
10234 "Allowed in v7-A with integer division extension"};
10235 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
10236 static const char * arm_attr_tag_Virtualization_use
[] =
10237 {"Not Allowed", "TrustZone", "Virtualization Extensions",
10238 "TrustZone and Virtualization Extensions"};
10239 static const char * arm_attr_tag_MPextension_use_legacy
[] =
10240 {"Not Allowed", "Allowed"};
10242 #define LOOKUP(id, name) \
10243 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
10244 static arm_attr_public_tag arm_attr_public_tags
[] =
10246 {4, "CPU_raw_name", 1, NULL
},
10247 {5, "CPU_name", 1, NULL
},
10248 LOOKUP(6, CPU_arch
),
10249 {7, "CPU_arch_profile", 0, NULL
},
10250 LOOKUP(8, ARM_ISA_use
),
10251 LOOKUP(9, THUMB_ISA_use
),
10252 LOOKUP(10, FP_arch
),
10253 LOOKUP(11, WMMX_arch
),
10254 LOOKUP(12, Advanced_SIMD_arch
),
10255 LOOKUP(13, PCS_config
),
10256 LOOKUP(14, ABI_PCS_R9_use
),
10257 LOOKUP(15, ABI_PCS_RW_data
),
10258 LOOKUP(16, ABI_PCS_RO_data
),
10259 LOOKUP(17, ABI_PCS_GOT_use
),
10260 LOOKUP(18, ABI_PCS_wchar_t
),
10261 LOOKUP(19, ABI_FP_rounding
),
10262 LOOKUP(20, ABI_FP_denormal
),
10263 LOOKUP(21, ABI_FP_exceptions
),
10264 LOOKUP(22, ABI_FP_user_exceptions
),
10265 LOOKUP(23, ABI_FP_number_model
),
10266 {24, "ABI_align_needed", 0, NULL
},
10267 {25, "ABI_align_preserved", 0, NULL
},
10268 LOOKUP(26, ABI_enum_size
),
10269 LOOKUP(27, ABI_HardFP_use
),
10270 LOOKUP(28, ABI_VFP_args
),
10271 LOOKUP(29, ABI_WMMX_args
),
10272 LOOKUP(30, ABI_optimization_goals
),
10273 LOOKUP(31, ABI_FP_optimization_goals
),
10274 {32, "compatibility", 0, NULL
},
10275 LOOKUP(34, CPU_unaligned_access
),
10276 LOOKUP(36, FP_HP_extension
),
10277 LOOKUP(38, ABI_FP_16bit_format
),
10278 LOOKUP(42, MPextension_use
),
10279 LOOKUP(44, DIV_use
),
10280 {64, "nodefaults", 0, NULL
},
10281 {65, "also_compatible_with", 0, NULL
},
10282 LOOKUP(66, T2EE_use
),
10283 {67, "conformance", 1, NULL
},
10284 LOOKUP(68, Virtualization_use
),
10285 LOOKUP(70, MPextension_use_legacy
)
10289 static unsigned char *
10290 display_arm_attribute (unsigned char * p
)
10295 arm_attr_public_tag
* attr
;
10299 tag
= read_uleb128 (p
, &len
);
10302 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
10304 if (arm_attr_public_tags
[i
].tag
== tag
)
10306 attr
= &arm_attr_public_tags
[i
];
10313 printf (" Tag_%s: ", attr
->name
);
10314 switch (attr
->type
)
10319 case 7: /* Tag_CPU_arch_profile. */
10320 val
= read_uleb128 (p
, &len
);
10324 case 0: printf (_("None\n")); break;
10325 case 'A': printf (_("Application\n")); break;
10326 case 'R': printf (_("Realtime\n")); break;
10327 case 'M': printf (_("Microcontroller\n")); break;
10328 case 'S': printf (_("Application or Realtime\n")); break;
10329 default: printf ("??? (%d)\n", val
); break;
10333 case 24: /* Tag_align_needed. */
10334 val
= read_uleb128 (p
, &len
);
10338 case 0: printf (_("None\n")); break;
10339 case 1: printf (_("8-byte\n")); break;
10340 case 2: printf (_("4-byte\n")); break;
10341 case 3: printf ("??? 3\n"); break;
10344 printf (_("8-byte and up to %d-byte extended\n"),
10347 printf ("??? (%d)\n", val
);
10352 case 25: /* Tag_align_preserved. */
10353 val
= read_uleb128 (p
, &len
);
10357 case 0: printf (_("None\n")); break;
10358 case 1: printf (_("8-byte, except leaf SP\n")); break;
10359 case 2: printf (_("8-byte\n")); break;
10360 case 3: printf ("??? 3\n"); break;
10363 printf (_("8-byte and up to %d-byte extended\n"),
10366 printf ("??? (%d)\n", val
);
10371 case 32: /* Tag_compatibility. */
10372 val
= read_uleb128 (p
, &len
);
10374 printf (_("flag = %d, vendor = %s\n"), val
, p
);
10375 p
+= strlen ((char *) p
) + 1;
10378 case 64: /* Tag_nodefaults. */
10380 printf (_("True\n"));
10383 case 65: /* Tag_also_compatible_with. */
10384 val
= read_uleb128 (p
, &len
);
10386 if (val
== 6 /* Tag_CPU_arch. */)
10388 val
= read_uleb128 (p
, &len
);
10390 if ((unsigned int)val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
10391 printf ("??? (%d)\n", val
);
10393 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
10397 while (*(p
++) != '\0' /* NUL terminator. */);
10411 assert (attr
->type
& 0x80);
10412 val
= read_uleb128 (p
, &len
);
10414 type
= attr
->type
& 0x7f;
10416 printf ("??? (%d)\n", val
);
10418 printf ("%s\n", attr
->table
[val
]);
10425 type
= 1; /* String. */
10427 type
= 2; /* uleb128. */
10428 printf (" Tag_unknown_%d: ", tag
);
10433 printf ("\"%s\"\n", p
);
10434 p
+= strlen ((char *) p
) + 1;
10438 val
= read_uleb128 (p
, &len
);
10440 printf ("%d (0x%x)\n", val
, val
);
10446 static unsigned char *
10447 display_gnu_attribute (unsigned char * p
,
10448 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
10455 tag
= read_uleb128 (p
, &len
);
10458 /* Tag_compatibility is the only generic GNU attribute defined at
10462 val
= read_uleb128 (p
, &len
);
10464 printf (_("flag = %d, vendor = %s\n"), val
, p
);
10465 p
+= strlen ((char *) p
) + 1;
10469 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
10470 return display_proc_gnu_attribute (p
, tag
);
10473 type
= 1; /* String. */
10475 type
= 2; /* uleb128. */
10476 printf (" Tag_unknown_%d: ", tag
);
10480 printf ("\"%s\"\n", p
);
10481 p
+= strlen ((char *) p
) + 1;
10485 val
= read_uleb128 (p
, &len
);
10487 printf ("%d (0x%x)\n", val
, val
);
10493 static unsigned char *
10494 display_power_gnu_attribute (unsigned char * p
, int tag
)
10500 if (tag
== Tag_GNU_Power_ABI_FP
)
10502 val
= read_uleb128 (p
, &len
);
10504 printf (" Tag_GNU_Power_ABI_FP: ");
10509 printf (_("Hard or soft float\n"));
10512 printf (_("Hard float\n"));
10515 printf (_("Soft float\n"));
10518 printf (_("Single-precision hard float\n"));
10521 printf ("??? (%d)\n", val
);
10527 if (tag
== Tag_GNU_Power_ABI_Vector
)
10529 val
= read_uleb128 (p
, &len
);
10531 printf (" Tag_GNU_Power_ABI_Vector: ");
10535 printf (_("Any\n"));
10538 printf (_("Generic\n"));
10541 printf ("AltiVec\n");
10547 printf ("??? (%d)\n", val
);
10553 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
10555 val
= read_uleb128 (p
, &len
);
10557 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
10561 printf (_("Any\n"));
10564 printf ("r3/r4\n");
10567 printf (_("Memory\n"));
10570 printf ("??? (%d)\n", val
);
10577 type
= 1; /* String. */
10579 type
= 2; /* uleb128. */
10580 printf (" Tag_unknown_%d: ", tag
);
10584 printf ("\"%s\"\n", p
);
10585 p
+= strlen ((char *) p
) + 1;
10589 val
= read_uleb128 (p
, &len
);
10591 printf ("%d (0x%x)\n", val
, val
);
10597 static unsigned char *
10598 display_mips_gnu_attribute (unsigned char * p
, int tag
)
10604 if (tag
== Tag_GNU_MIPS_ABI_FP
)
10606 val
= read_uleb128 (p
, &len
);
10608 printf (" Tag_GNU_MIPS_ABI_FP: ");
10613 printf (_("Hard or soft float\n"));
10616 printf (_("Hard float (double precision)\n"));
10619 printf (_("Hard float (single precision)\n"));
10622 printf (_("Soft float\n"));
10625 printf (_("64-bit float (-mips32r2 -mfp64)\n"));
10628 printf ("??? (%d)\n", val
);
10635 type
= 1; /* String. */
10637 type
= 2; /* uleb128. */
10638 printf (" Tag_unknown_%d: ", tag
);
10642 printf ("\"%s\"\n", p
);
10643 p
+= strlen ((char *) p
) + 1;
10647 val
= read_uleb128 (p
, &len
);
10649 printf ("%d (0x%x)\n", val
, val
);
10655 static unsigned char *
10656 display_tic6x_attribute (unsigned char * p
)
10662 tag
= read_uleb128 (p
, &len
);
10667 case Tag_C6XABI_Tag_CPU_arch
:
10668 val
= read_uleb128 (p
, &len
);
10670 printf (" Tag_C6XABI_Tag_CPU_arch: ");
10674 case C6XABI_Tag_CPU_arch_none
:
10675 printf (_("None\n"));
10677 case C6XABI_Tag_CPU_arch_C62X
:
10680 case C6XABI_Tag_CPU_arch_C67X
:
10683 case C6XABI_Tag_CPU_arch_C67XP
:
10684 printf ("C67x+\n");
10686 case C6XABI_Tag_CPU_arch_C64X
:
10689 case C6XABI_Tag_CPU_arch_C64XP
:
10690 printf ("C64x+\n");
10692 case C6XABI_Tag_CPU_arch_C674X
:
10693 printf ("C674x\n");
10696 printf ("??? (%d)\n", val
);
10702 /* Tag_compatibility - treated as generic by binutils for now
10703 although not currently specified for C6X. */
10704 val
= read_uleb128 (p
, &len
);
10706 printf (_("flag = %d, vendor = %s\n"), val
, p
);
10707 p
+= strlen ((char *) p
) + 1;
10711 printf (" Tag_unknown_%d: ", tag
);
10713 /* No general documentation of handling unknown attributes, treat as
10714 ULEB128 for now. */
10715 val
= read_uleb128 (p
, &len
);
10717 printf ("%d (0x%x)\n", val
, val
);
10723 process_attributes (FILE * file
,
10724 const char * public_name
,
10725 unsigned int proc_type
,
10726 unsigned char * (* display_pub_attribute
) (unsigned char *),
10727 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
10729 Elf_Internal_Shdr
* sect
;
10730 unsigned char * contents
;
10732 unsigned char * end
;
10733 bfd_vma section_len
;
10737 /* Find the section header so that we get the size. */
10738 for (i
= 0, sect
= section_headers
;
10739 i
< elf_header
.e_shnum
;
10742 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
10745 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
10746 sect
->sh_size
, _("attributes"));
10747 if (contents
== NULL
)
10753 len
= sect
->sh_size
- 1;
10759 bfd_boolean public_section
;
10760 bfd_boolean gnu_section
;
10762 section_len
= byte_get (p
, 4);
10765 if (section_len
> len
)
10767 printf (_("ERROR: Bad section length (%d > %d)\n"),
10768 (int) section_len
, (int) len
);
10772 len
-= section_len
;
10773 printf (_("Attribute Section: %s\n"), p
);
10775 if (public_name
&& streq ((char *) p
, public_name
))
10776 public_section
= TRUE
;
10778 public_section
= FALSE
;
10780 if (streq ((char *) p
, "gnu"))
10781 gnu_section
= TRUE
;
10783 gnu_section
= FALSE
;
10785 namelen
= strlen ((char *) p
) + 1;
10787 section_len
-= namelen
+ 4;
10789 while (section_len
> 0)
10795 size
= byte_get (p
, 4);
10796 if (size
> section_len
)
10798 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
10799 (int) size
, (int) section_len
);
10800 size
= section_len
;
10803 section_len
-= size
;
10804 end
= p
+ size
- 1;
10810 printf (_("File Attributes\n"));
10813 printf (_("Section Attributes:"));
10816 printf (_("Symbol Attributes:"));
10822 val
= read_uleb128 (p
, &j
);
10826 printf (" %d", val
);
10831 printf (_("Unknown tag: %d\n"), tag
);
10832 public_section
= FALSE
;
10836 if (public_section
)
10839 p
= display_pub_attribute (p
);
10841 else if (gnu_section
)
10844 p
= display_gnu_attribute (p
,
10845 display_proc_gnu_attribute
);
10849 /* ??? Do something sensible, like dump hex. */
10850 printf (_(" Unknown section contexts\n"));
10857 printf (_("Unknown format '%c'\n"), *p
);
10865 process_arm_specific (FILE * file
)
10867 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
10868 display_arm_attribute
, NULL
);
10872 process_power_specific (FILE * file
)
10874 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
10875 display_power_gnu_attribute
);
10879 process_tic6x_specific (FILE * file
)
10881 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
10882 display_tic6x_attribute
, NULL
);
10885 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
10886 Print the Address, Access and Initial fields of an entry at VMA ADDR
10887 and return the VMA of the next entry. */
10890 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
10893 print_vma (addr
, LONG_HEX
);
10895 if (addr
< pltgot
+ 0xfff0)
10896 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
10898 printf ("%10s", "");
10901 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
10906 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
10907 print_vma (entry
, LONG_HEX
);
10909 return addr
+ (is_32bit_elf
? 4 : 8);
10912 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
10913 PLTGOT. Print the Address and Initial fields of an entry at VMA
10914 ADDR and return the VMA of the next entry. */
10917 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
10920 print_vma (addr
, LONG_HEX
);
10923 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
10928 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
10929 print_vma (entry
, LONG_HEX
);
10931 return addr
+ (is_32bit_elf
? 4 : 8);
10935 process_mips_specific (FILE * file
)
10937 Elf_Internal_Dyn
* entry
;
10938 size_t liblist_offset
= 0;
10939 size_t liblistno
= 0;
10940 size_t conflictsno
= 0;
10941 size_t options_offset
= 0;
10942 size_t conflicts_offset
= 0;
10943 size_t pltrelsz
= 0;
10945 bfd_vma pltgot
= 0;
10946 bfd_vma mips_pltgot
= 0;
10947 bfd_vma jmprel
= 0;
10948 bfd_vma local_gotno
= 0;
10949 bfd_vma gotsym
= 0;
10950 bfd_vma symtabno
= 0;
10952 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
10953 display_mips_gnu_attribute
);
10955 /* We have a lot of special sections. Thanks SGI! */
10956 if (dynamic_section
== NULL
)
10957 /* No information available. */
10960 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
10961 switch (entry
->d_tag
)
10963 case DT_MIPS_LIBLIST
:
10965 = offset_from_vma (file
, entry
->d_un
.d_val
,
10966 liblistno
* sizeof (Elf32_External_Lib
));
10968 case DT_MIPS_LIBLISTNO
:
10969 liblistno
= entry
->d_un
.d_val
;
10971 case DT_MIPS_OPTIONS
:
10972 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
10974 case DT_MIPS_CONFLICT
:
10976 = offset_from_vma (file
, entry
->d_un
.d_val
,
10977 conflictsno
* sizeof (Elf32_External_Conflict
));
10979 case DT_MIPS_CONFLICTNO
:
10980 conflictsno
= entry
->d_un
.d_val
;
10983 pltgot
= entry
->d_un
.d_ptr
;
10985 case DT_MIPS_LOCAL_GOTNO
:
10986 local_gotno
= entry
->d_un
.d_val
;
10988 case DT_MIPS_GOTSYM
:
10989 gotsym
= entry
->d_un
.d_val
;
10991 case DT_MIPS_SYMTABNO
:
10992 symtabno
= entry
->d_un
.d_val
;
10994 case DT_MIPS_PLTGOT
:
10995 mips_pltgot
= entry
->d_un
.d_ptr
;
10998 pltrel
= entry
->d_un
.d_val
;
11001 pltrelsz
= entry
->d_un
.d_val
;
11004 jmprel
= entry
->d_un
.d_ptr
;
11010 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
11012 Elf32_External_Lib
* elib
;
11015 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
11017 sizeof (Elf32_External_Lib
),
11021 printf (_("\nSection '.liblist' contains %lu entries:\n"),
11022 (unsigned long) liblistno
);
11023 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
11026 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
11033 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11034 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11035 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11036 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11037 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11039 tmp
= gmtime (&atime
);
11040 snprintf (timebuf
, sizeof (timebuf
),
11041 "%04u-%02u-%02uT%02u:%02u:%02u",
11042 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11043 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11045 printf ("%3lu: ", (unsigned long) cnt
);
11046 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
11047 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
11049 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
11050 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
11051 liblist
.l_version
);
11053 if (liblist
.l_flags
== 0)
11057 static const struct
11064 { " EXACT_MATCH", LL_EXACT_MATCH
},
11065 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
11066 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
11067 { " EXPORTS", LL_EXPORTS
},
11068 { " DELAY_LOAD", LL_DELAY_LOAD
},
11069 { " DELTA", LL_DELTA
}
11071 int flags
= liblist
.l_flags
;
11074 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
11075 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
11077 fputs (l_flags_vals
[fcnt
].name
, stdout
);
11078 flags
^= l_flags_vals
[fcnt
].bit
;
11081 printf (" %#x", (unsigned int) flags
);
11091 if (options_offset
!= 0)
11093 Elf_External_Options
* eopt
;
11094 Elf_Internal_Shdr
* sect
= section_headers
;
11095 Elf_Internal_Options
* iopt
;
11096 Elf_Internal_Options
* option
;
11100 /* Find the section header so that we get the size. */
11101 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
11104 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
11105 sect
->sh_size
, _("options"));
11108 iopt
= (Elf_Internal_Options
*)
11109 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
11112 error (_("Out of memory\n"));
11119 while (offset
< sect
->sh_size
)
11121 Elf_External_Options
* eoption
;
11123 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
11125 option
->kind
= BYTE_GET (eoption
->kind
);
11126 option
->size
= BYTE_GET (eoption
->size
);
11127 option
->section
= BYTE_GET (eoption
->section
);
11128 option
->info
= BYTE_GET (eoption
->info
);
11130 offset
+= option
->size
;
11136 printf (_("\nSection '%s' contains %d entries:\n"),
11137 SECTION_NAME (sect
), cnt
);
11145 switch (option
->kind
)
11148 /* This shouldn't happen. */
11149 printf (" NULL %d %lx", option
->section
, option
->info
);
11152 printf (" REGINFO ");
11153 if (elf_header
.e_machine
== EM_MIPS
)
11156 Elf32_External_RegInfo
* ereg
;
11157 Elf32_RegInfo reginfo
;
11159 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
11160 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11161 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11162 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11163 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11164 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11165 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11167 printf ("GPR %08lx GP 0x%lx\n",
11168 reginfo
.ri_gprmask
,
11169 (unsigned long) reginfo
.ri_gp_value
);
11170 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11171 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11172 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11177 Elf64_External_RegInfo
* ereg
;
11178 Elf64_Internal_RegInfo reginfo
;
11180 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
11181 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11182 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11183 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11184 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11185 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11186 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11188 printf ("GPR %08lx GP 0x",
11189 reginfo
.ri_gprmask
);
11190 printf_vma (reginfo
.ri_gp_value
);
11193 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11194 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11195 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11199 case ODK_EXCEPTIONS
:
11200 fputs (" EXCEPTIONS fpe_min(", stdout
);
11201 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
11202 fputs (") fpe_max(", stdout
);
11203 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
11204 fputs (")", stdout
);
11206 if (option
->info
& OEX_PAGE0
)
11207 fputs (" PAGE0", stdout
);
11208 if (option
->info
& OEX_SMM
)
11209 fputs (" SMM", stdout
);
11210 if (option
->info
& OEX_FPDBUG
)
11211 fputs (" FPDBUG", stdout
);
11212 if (option
->info
& OEX_DISMISS
)
11213 fputs (" DISMISS", stdout
);
11216 fputs (" PAD ", stdout
);
11217 if (option
->info
& OPAD_PREFIX
)
11218 fputs (" PREFIX", stdout
);
11219 if (option
->info
& OPAD_POSTFIX
)
11220 fputs (" POSTFIX", stdout
);
11221 if (option
->info
& OPAD_SYMBOL
)
11222 fputs (" SYMBOL", stdout
);
11225 fputs (" HWPATCH ", stdout
);
11226 if (option
->info
& OHW_R4KEOP
)
11227 fputs (" R4KEOP", stdout
);
11228 if (option
->info
& OHW_R8KPFETCH
)
11229 fputs (" R8KPFETCH", stdout
);
11230 if (option
->info
& OHW_R5KEOP
)
11231 fputs (" R5KEOP", stdout
);
11232 if (option
->info
& OHW_R5KCVTL
)
11233 fputs (" R5KCVTL", stdout
);
11236 fputs (" FILL ", stdout
);
11237 /* XXX Print content of info word? */
11240 fputs (" TAGS ", stdout
);
11241 /* XXX Print content of info word? */
11244 fputs (" HWAND ", stdout
);
11245 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11246 fputs (" R4KEOP_CHECKED", stdout
);
11247 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11248 fputs (" R4KEOP_CLEAN", stdout
);
11251 fputs (" HWOR ", stdout
);
11252 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11253 fputs (" R4KEOP_CHECKED", stdout
);
11254 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11255 fputs (" R4KEOP_CLEAN", stdout
);
11258 printf (" GP_GROUP %#06lx self-contained %#06lx",
11259 option
->info
& OGP_GROUP
,
11260 (option
->info
& OGP_SELF
) >> 16);
11263 printf (" IDENT %#06lx self-contained %#06lx",
11264 option
->info
& OGP_GROUP
,
11265 (option
->info
& OGP_SELF
) >> 16);
11268 /* This shouldn't happen. */
11269 printf (" %3d ??? %d %lx",
11270 option
->kind
, option
->section
, option
->info
);
11274 len
= sizeof (* eopt
);
11275 while (len
< option
->size
)
11276 if (((char *) option
)[len
] >= ' '
11277 && ((char *) option
)[len
] < 0x7f)
11278 printf ("%c", ((char *) option
)[len
++]);
11280 printf ("\\%03o", ((char *) option
)[len
++]);
11282 fputs ("\n", stdout
);
11290 if (conflicts_offset
!= 0 && conflictsno
!= 0)
11292 Elf32_Conflict
* iconf
;
11295 if (dynamic_symbols
== NULL
)
11297 error (_("conflict list found without a dynamic symbol table\n"));
11301 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
11304 error (_("Out of memory\n"));
11310 Elf32_External_Conflict
* econf32
;
11312 econf32
= (Elf32_External_Conflict
*)
11313 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
11314 sizeof (* econf32
), _("conflict"));
11318 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11319 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
11325 Elf64_External_Conflict
* econf64
;
11327 econf64
= (Elf64_External_Conflict
*)
11328 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
11329 sizeof (* econf64
), _("conflict"));
11333 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11334 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
11339 printf (_("\nSection '.conflict' contains %lu entries:\n"),
11340 (unsigned long) conflictsno
);
11341 puts (_(" Num: Index Value Name"));
11343 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11345 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
11347 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
11348 print_vma (psym
->st_value
, FULL_HEX
);
11350 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11351 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11353 printf (_("<corrupt: %14ld>"), psym
->st_name
);
11360 if (pltgot
!= 0 && local_gotno
!= 0)
11362 bfd_vma ent
, local_end
, global_end
;
11364 unsigned char * data
;
11368 addr_size
= (is_32bit_elf
? 4 : 8);
11369 local_end
= pltgot
+ local_gotno
* addr_size
;
11370 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
11372 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
11373 data
= (unsigned char *) get_data (NULL
, file
, offset
,
11374 global_end
- pltgot
, 1, _("GOT"));
11375 printf (_("\nPrimary GOT:\n"));
11376 printf (_(" Canonical gp value: "));
11377 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
11380 printf (_(" Reserved entries:\n"));
11381 printf (_(" %*s %10s %*s Purpose\n"),
11382 addr_size
* 2, _("Address"), _("Access"),
11383 addr_size
* 2, _("Initial"));
11384 ent
= print_mips_got_entry (data
, pltgot
, ent
);
11385 printf (_(" Lazy resolver\n"));
11387 && (byte_get (data
+ ent
- pltgot
, addr_size
)
11388 >> (addr_size
* 8 - 1)) != 0)
11390 ent
= print_mips_got_entry (data
, pltgot
, ent
);
11391 printf (_(" Module pointer (GNU extension)\n"));
11395 if (ent
< local_end
)
11397 printf (_(" Local entries:\n"));
11398 printf (_(" %*s %10s %*s\n"),
11399 addr_size
* 2, _("Address"), _("Access"),
11400 addr_size
* 2, _("Initial"));
11401 while (ent
< local_end
)
11403 ent
= print_mips_got_entry (data
, pltgot
, ent
);
11409 if (gotsym
< symtabno
)
11413 printf (_(" Global entries:\n"));
11414 printf (_(" %*s %10s %*s %*s %-7s %3s %s\n"),
11415 addr_size
* 2, _("Address"), _("Access"),
11416 addr_size
* 2, _("Initial"),
11417 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
11418 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
11419 for (i
= gotsym
; i
< symtabno
; i
++)
11421 Elf_Internal_Sym
* psym
;
11423 psym
= dynamic_symbols
+ i
;
11424 ent
= print_mips_got_entry (data
, pltgot
, ent
);
11426 print_vma (psym
->st_value
, LONG_HEX
);
11427 printf (" %-7s %3s ",
11428 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
11429 get_symbol_index_type (psym
->st_shndx
));
11430 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11431 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
11433 printf (_("<corrupt: %14ld>"), psym
->st_name
);
11443 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
11446 size_t offset
, rel_offset
;
11447 unsigned long count
, i
;
11448 unsigned char * data
;
11449 int addr_size
, sym_width
;
11450 Elf_Internal_Rela
* rels
;
11452 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
11453 if (pltrel
== DT_RELA
)
11455 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
11460 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
11465 addr_size
= (is_32bit_elf
? 4 : 8);
11466 end
= mips_pltgot
+ (2 + count
) * addr_size
;
11468 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
11469 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
11471 printf (_("\nPLT GOT:\n\n"));
11472 printf (_(" Reserved entries:\n"));
11473 printf (_(" %*s %*s Purpose\n"),
11474 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
11475 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
11476 printf (_(" PLT lazy resolver\n"));
11477 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
11478 printf (_(" Module pointer\n"));
11481 printf (_(" Entries:\n"));
11482 printf (_(" %*s %*s %*s %-7s %3s %s\n"),
11483 addr_size
* 2, _("Address"),
11484 addr_size
* 2, _("Initial"),
11485 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
11486 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
11487 for (i
= 0; i
< count
; i
++)
11489 Elf_Internal_Sym
* psym
;
11491 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
11492 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
11494 print_vma (psym
->st_value
, LONG_HEX
);
11495 printf (" %-7s %3s ",
11496 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
11497 get_symbol_index_type (psym
->st_shndx
));
11498 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11499 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
11501 printf (_("<corrupt: %14ld>"), psym
->st_name
);
11515 process_gnu_liblist (FILE * file
)
11517 Elf_Internal_Shdr
* section
;
11518 Elf_Internal_Shdr
* string_sec
;
11519 Elf32_External_Lib
* elib
;
11521 size_t strtab_size
;
11528 for (i
= 0, section
= section_headers
;
11529 i
< elf_header
.e_shnum
;
11532 switch (section
->sh_type
)
11534 case SHT_GNU_LIBLIST
:
11535 if (section
->sh_link
>= elf_header
.e_shnum
)
11538 elib
= (Elf32_External_Lib
*)
11539 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
11544 string_sec
= section_headers
+ section
->sh_link
;
11546 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
11547 string_sec
->sh_size
,
11548 _("liblist string table"));
11549 strtab_size
= string_sec
->sh_size
;
11552 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
11558 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
11559 SECTION_NAME (section
),
11560 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
11562 puts (_(" Library Time Stamp Checksum Version Flags"));
11564 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
11572 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11573 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11574 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11575 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11576 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11578 tmp
= gmtime (&atime
);
11579 snprintf (timebuf
, sizeof (timebuf
),
11580 "%04u-%02u-%02uT%02u:%02u:%02u",
11581 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11582 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11584 printf ("%3lu: ", (unsigned long) cnt
);
11586 printf ("%-20s", liblist
.l_name
< strtab_size
11587 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
11589 printf ("%-20.20s", liblist
.l_name
< strtab_size
11590 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
11591 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
11592 liblist
.l_version
, liblist
.l_flags
);
11602 static const char *
11603 get_note_type (unsigned e_type
)
11605 static char buff
[64];
11607 if (elf_header
.e_type
== ET_CORE
)
11611 return _("NT_AUXV (auxiliary vector)");
11613 return _("NT_PRSTATUS (prstatus structure)");
11615 return _("NT_FPREGSET (floating point registers)");
11617 return _("NT_PRPSINFO (prpsinfo structure)");
11618 case NT_TASKSTRUCT
:
11619 return _("NT_TASKSTRUCT (task structure)");
11621 return _("NT_PRXFPREG (user_xfpregs structure)");
11623 return _("NT_PPC_VMX (ppc Altivec registers)");
11625 return _("NT_PPC_VSX (ppc VSX registers)");
11626 case NT_X86_XSTATE
:
11627 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
11628 case NT_S390_HIGH_GPRS
:
11629 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
11630 case NT_S390_TIMER
:
11631 return _("NT_S390_TIMER (s390 timer register)");
11632 case NT_S390_TODCMP
:
11633 return _("NT_S390_TODCMP (s390 TOD comparator register)");
11634 case NT_S390_TODPREG
:
11635 return _("NT_S390_TODPREG (s390 TOD programmable register)");
11637 return _("NT_S390_CTRS (s390 control registers)");
11638 case NT_S390_PREFIX
:
11639 return _("NT_S390_PREFIX (s390 prefix register)");
11641 return _("NT_PSTATUS (pstatus structure)");
11643 return _("NT_FPREGS (floating point registers)");
11645 return _("NT_PSINFO (psinfo structure)");
11647 return _("NT_LWPSTATUS (lwpstatus_t structure)");
11649 return _("NT_LWPSINFO (lwpsinfo_t structure)");
11650 case NT_WIN32PSTATUS
:
11651 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11659 return _("NT_VERSION (version)");
11661 return _("NT_ARCH (architecture)");
11666 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11670 static const char *
11671 get_gnu_elf_note_type (unsigned e_type
)
11673 static char buff
[64];
11677 case NT_GNU_ABI_TAG
:
11678 return _("NT_GNU_ABI_TAG (ABI version tag)");
11680 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
11681 case NT_GNU_BUILD_ID
:
11682 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
11683 case NT_GNU_GOLD_VERSION
:
11684 return _("NT_GNU_GOLD_VERSION (gold version)");
11689 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11693 static const char *
11694 get_netbsd_elfcore_note_type (unsigned e_type
)
11696 static char buff
[64];
11698 if (e_type
== NT_NETBSDCORE_PROCINFO
)
11700 /* NetBSD core "procinfo" structure. */
11701 return _("NetBSD procinfo structure");
11704 /* As of Jan 2002 there are no other machine-independent notes
11705 defined for NetBSD core files. If the note type is less
11706 than the start of the machine-dependent note types, we don't
11709 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
11711 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11715 switch (elf_header
.e_machine
)
11717 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
11718 and PT_GETFPREGS == mach+2. */
11723 case EM_SPARC32PLUS
:
11727 case NT_NETBSDCORE_FIRSTMACH
+ 0:
11728 return _("PT_GETREGS (reg structure)");
11729 case NT_NETBSDCORE_FIRSTMACH
+ 2:
11730 return _("PT_GETFPREGS (fpreg structure)");
11736 /* On all other arch's, PT_GETREGS == mach+1 and
11737 PT_GETFPREGS == mach+3. */
11741 case NT_NETBSDCORE_FIRSTMACH
+ 1:
11742 return _("PT_GETREGS (reg structure)");
11743 case NT_NETBSDCORE_FIRSTMACH
+ 3:
11744 return _("PT_GETFPREGS (fpreg structure)");
11750 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
11751 e_type
- NT_NETBSDCORE_FIRSTMACH
);
11755 /* Note that by the ELF standard, the name field is already null byte
11756 terminated, and namesz includes the terminating null byte.
11757 I.E. the value of namesz for the name "FSF" is 4.
11759 If the value of namesz is zero, there is no name present. */
11761 process_note (Elf_Internal_Note
* pnote
)
11763 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
11766 if (pnote
->namesz
== 0)
11767 /* If there is no note name, then use the default set of
11768 note type strings. */
11769 nt
= get_note_type (pnote
->type
);
11771 else if (const_strneq (pnote
->namedata
, "GNU"))
11772 /* GNU-specific object file notes. */
11773 nt
= get_gnu_elf_note_type (pnote
->type
);
11775 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
11776 /* NetBSD-specific core file notes. */
11777 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
11779 else if (strneq (pnote
->namedata
, "SPU/", 4))
11781 /* SPU-specific core file notes. */
11782 nt
= pnote
->namedata
+ 4;
11787 /* Don't recognize this note name; just use the default set of
11788 note type strings. */
11789 nt
= get_note_type (pnote
->type
);
11791 printf (" %s\t\t0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
11797 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
11799 Elf_External_Note
* pnotes
;
11800 Elf_External_Note
* external
;
11806 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
11813 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
11814 (unsigned long) offset
, (unsigned long) length
);
11815 printf (_(" Owner\t\tData size\tDescription\n"));
11817 while (external
< (Elf_External_Note
*) ((char *) pnotes
+ length
))
11819 Elf_External_Note
* next
;
11820 Elf_Internal_Note inote
;
11821 char * temp
= NULL
;
11823 inote
.type
= BYTE_GET (external
->type
);
11824 inote
.namesz
= BYTE_GET (external
->namesz
);
11825 inote
.namedata
= external
->name
;
11826 inote
.descsz
= BYTE_GET (external
->descsz
);
11827 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
11828 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
11830 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
11832 if (((char *) next
) > (((char *) pnotes
) + length
))
11834 warn (_("corrupt note found at offset %lx into core notes\n"),
11835 (unsigned long) ((char *) external
- (char *) pnotes
));
11836 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
11837 inote
.type
, inote
.namesz
, inote
.descsz
);
11843 /* Verify that name is null terminated. It appears that at least
11844 one version of Linux (RedHat 6.0) generates corefiles that don't
11845 comply with the ELF spec by failing to include the null byte in
11847 if (inote
.namedata
[inote
.namesz
] != '\0')
11849 temp
= (char *) malloc (inote
.namesz
+ 1);
11853 error (_("Out of memory\n"));
11858 strncpy (temp
, inote
.namedata
, inote
.namesz
);
11859 temp
[inote
.namesz
] = 0;
11861 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
11862 inote
.namedata
= temp
;
11865 res
&= process_note (& inote
);
11880 process_corefile_note_segments (FILE * file
)
11882 Elf_Internal_Phdr
* segment
;
11886 if (! get_program_headers (file
))
11889 for (i
= 0, segment
= program_headers
;
11890 i
< elf_header
.e_phnum
;
11893 if (segment
->p_type
== PT_NOTE
)
11894 res
&= process_corefile_note_segment (file
,
11895 (bfd_vma
) segment
->p_offset
,
11896 (bfd_vma
) segment
->p_filesz
);
11903 process_note_sections (FILE * file
)
11905 Elf_Internal_Shdr
* section
;
11909 for (i
= 0, section
= section_headers
;
11910 i
< elf_header
.e_shnum
;
11912 if (section
->sh_type
== SHT_NOTE
)
11913 res
&= process_corefile_note_segment (file
,
11914 (bfd_vma
) section
->sh_offset
,
11915 (bfd_vma
) section
->sh_size
);
11921 process_notes (FILE * file
)
11923 /* If we have not been asked to display the notes then do nothing. */
11927 if (elf_header
.e_type
!= ET_CORE
)
11928 return process_note_sections (file
);
11930 /* No program headers means no NOTE segment. */
11931 if (elf_header
.e_phnum
> 0)
11932 return process_corefile_note_segments (file
);
11934 printf (_("No note segments present in the core file.\n"));
11939 process_arch_specific (FILE * file
)
11944 switch (elf_header
.e_machine
)
11947 return process_arm_specific (file
);
11949 case EM_MIPS_RS3_LE
:
11950 return process_mips_specific (file
);
11953 return process_power_specific (file
);
11956 return process_tic6x_specific (file
);
11965 get_file_header (FILE * file
)
11967 /* Read in the identity array. */
11968 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
11971 /* Determine how to read the rest of the header. */
11972 switch (elf_header
.e_ident
[EI_DATA
])
11974 default: /* fall through */
11975 case ELFDATANONE
: /* fall through */
11977 byte_get
= byte_get_little_endian
;
11978 byte_put
= byte_put_little_endian
;
11981 byte_get
= byte_get_big_endian
;
11982 byte_put
= byte_put_big_endian
;
11986 /* For now we only support 32 bit and 64 bit ELF files. */
11987 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
11989 /* Read in the rest of the header. */
11992 Elf32_External_Ehdr ehdr32
;
11994 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
11997 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
11998 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
11999 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
12000 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
12001 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
12002 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
12003 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
12004 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
12005 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
12006 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
12007 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
12008 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
12009 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
12013 Elf64_External_Ehdr ehdr64
;
12015 /* If we have been compiled with sizeof (bfd_vma) == 4, then
12016 we will not be able to cope with the 64bit data found in
12017 64 ELF files. Detect this now and abort before we start
12018 overwriting things. */
12019 if (sizeof (bfd_vma
) < 8)
12021 error (_("This instance of readelf has been built without support for a\n\
12022 64 bit data type and so it cannot read 64 bit ELF files.\n"));
12026 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
12029 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
12030 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
12031 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
12032 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
12033 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
12034 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
12035 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
12036 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
12037 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
12038 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
12039 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
12040 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
12041 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
12044 if (elf_header
.e_shoff
)
12046 /* There may be some extensions in the first section header. Don't
12047 bomb if we can't read it. */
12049 get_32bit_section_headers (file
, 1);
12051 get_64bit_section_headers (file
, 1);
12057 /* Process one ELF object file according to the command line options.
12058 This file may actually be stored in an archive. The file is
12059 positioned at the start of the ELF object. */
12062 process_object (char * file_name
, FILE * file
)
12066 if (! get_file_header (file
))
12068 error (_("%s: Failed to read file header\n"), file_name
);
12072 /* Initialise per file variables. */
12073 for (i
= ARRAY_SIZE (version_info
); i
--;)
12074 version_info
[i
] = 0;
12076 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
12077 dynamic_info
[i
] = 0;
12079 /* Process the file. */
12081 printf (_("\nFile: %s\n"), file_name
);
12083 /* Initialise the dump_sects array from the cmdline_dump_sects array.
12084 Note we do this even if cmdline_dump_sects is empty because we
12085 must make sure that the dump_sets array is zeroed out before each
12086 object file is processed. */
12087 if (num_dump_sects
> num_cmdline_dump_sects
)
12088 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
12090 if (num_cmdline_dump_sects
> 0)
12092 if (num_dump_sects
== 0)
12093 /* A sneaky way of allocating the dump_sects array. */
12094 request_dump_bynumber (num_cmdline_dump_sects
, 0);
12096 assert (num_dump_sects
>= num_cmdline_dump_sects
);
12097 memcpy (dump_sects
, cmdline_dump_sects
,
12098 num_cmdline_dump_sects
* sizeof (* dump_sects
));
12101 if (! process_file_header ())
12104 if (! process_section_headers (file
))
12106 /* Without loaded section headers we cannot process lots of
12108 do_unwind
= do_version
= do_dump
= do_arch
= 0;
12110 if (! do_using_dynamic
)
12111 do_syms
= do_dyn_syms
= do_reloc
= 0;
12114 if (! process_section_groups (file
))
12116 /* Without loaded section groups we cannot process unwind. */
12120 if (process_program_headers (file
))
12121 process_dynamic_section (file
);
12123 process_relocs (file
);
12125 process_unwind (file
);
12127 process_symbol_table (file
);
12129 process_syminfo (file
);
12131 process_version_sections (file
);
12133 process_section_contents (file
);
12135 process_notes (file
);
12137 process_gnu_liblist (file
);
12139 process_arch_specific (file
);
12141 if (program_headers
)
12143 free (program_headers
);
12144 program_headers
= NULL
;
12147 if (section_headers
)
12149 free (section_headers
);
12150 section_headers
= NULL
;
12155 free (string_table
);
12156 string_table
= NULL
;
12157 string_table_length
= 0;
12160 if (dynamic_strings
)
12162 free (dynamic_strings
);
12163 dynamic_strings
= NULL
;
12164 dynamic_strings_length
= 0;
12167 if (dynamic_symbols
)
12169 free (dynamic_symbols
);
12170 dynamic_symbols
= NULL
;
12171 num_dynamic_syms
= 0;
12174 if (dynamic_syminfo
)
12176 free (dynamic_syminfo
);
12177 dynamic_syminfo
= NULL
;
12180 if (section_headers_groups
)
12182 free (section_headers_groups
);
12183 section_headers_groups
= NULL
;
12186 if (section_groups
)
12188 struct group_list
* g
;
12189 struct group_list
* next
;
12191 for (i
= 0; i
< group_count
; i
++)
12193 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
12200 free (section_groups
);
12201 section_groups
= NULL
;
12204 free_debug_memory ();
12209 /* Return the path name for a proxy entry in a thin archive, adjusted relative
12210 to the path name of the thin archive itself if necessary. Always returns
12211 a pointer to malloc'ed memory. */
12214 adjust_relative_path (char * file_name
, char * name
, int name_len
)
12216 char * member_file_name
;
12217 const char * base_name
= lbasename (file_name
);
12219 /* This is a proxy entry for a thin archive member.
12220 If the extended name table contains an absolute path
12221 name, or if the archive is in the current directory,
12222 use the path name as given. Otherwise, we need to
12223 find the member relative to the directory where the
12224 archive is located. */
12225 if (IS_ABSOLUTE_PATH (name
) || base_name
== file_name
)
12227 member_file_name
= (char *) malloc (name_len
+ 1);
12228 if (member_file_name
== NULL
)
12230 error (_("Out of memory\n"));
12233 memcpy (member_file_name
, name
, name_len
);
12234 member_file_name
[name_len
] = '\0';
12238 /* Concatenate the path components of the archive file name
12239 to the relative path name from the extended name table. */
12240 size_t prefix_len
= base_name
- file_name
;
12241 member_file_name
= (char *) malloc (prefix_len
+ name_len
+ 1);
12242 if (member_file_name
== NULL
)
12244 error (_("Out of memory\n"));
12247 memcpy (member_file_name
, file_name
, prefix_len
);
12248 memcpy (member_file_name
+ prefix_len
, name
, name_len
);
12249 member_file_name
[prefix_len
+ name_len
] = '\0';
12251 return member_file_name
;
12254 /* Structure to hold information about an archive file. */
12256 struct archive_info
12258 char * file_name
; /* Archive file name. */
12259 FILE * file
; /* Open file descriptor. */
12260 unsigned long index_num
; /* Number of symbols in table. */
12261 unsigned long * index_array
; /* The array of member offsets. */
12262 char * sym_table
; /* The symbol table. */
12263 unsigned long sym_size
; /* Size of the symbol table. */
12264 char * longnames
; /* The long file names table. */
12265 unsigned long longnames_size
; /* Size of the long file names table. */
12266 unsigned long nested_member_origin
; /* Origin in the nested archive of the current member. */
12267 unsigned long next_arhdr_offset
; /* Offset of the next archive header. */
12268 bfd_boolean is_thin_archive
; /* TRUE if this is a thin archive. */
12269 struct ar_hdr arhdr
; /* Current archive header. */
12272 /* Read the symbol table and long-name table from an archive. */
12275 setup_archive (struct archive_info
* arch
, char * file_name
, FILE * file
,
12276 bfd_boolean is_thin_archive
, bfd_boolean read_symbols
)
12279 unsigned long size
;
12281 arch
->file_name
= strdup (file_name
);
12283 arch
->index_num
= 0;
12284 arch
->index_array
= NULL
;
12285 arch
->sym_table
= NULL
;
12286 arch
->sym_size
= 0;
12287 arch
->longnames
= NULL
;
12288 arch
->longnames_size
= 0;
12289 arch
->nested_member_origin
= 0;
12290 arch
->is_thin_archive
= is_thin_archive
;
12291 arch
->next_arhdr_offset
= SARMAG
;
12293 /* Read the first archive member header. */
12294 if (fseek (file
, SARMAG
, SEEK_SET
) != 0)
12296 error (_("%s: failed to seek to first archive header\n"), file_name
);
12299 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
12300 if (got
!= sizeof arch
->arhdr
)
12305 error (_("%s: failed to read archive header\n"), file_name
);
12309 /* See if this is the archive symbol table. */
12310 if (const_strneq (arch
->arhdr
.ar_name
, "/ ")
12311 || const_strneq (arch
->arhdr
.ar_name
, "/SYM64/ "))
12313 size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
12314 size
= size
+ (size
& 1);
12316 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ size
;
12321 /* A buffer used to hold numbers read in from an archive index.
12322 These are always 4 bytes long and stored in big-endian format. */
12323 #define SIZEOF_AR_INDEX_NUMBERS 4
12324 unsigned char integer_buffer
[SIZEOF_AR_INDEX_NUMBERS
];
12325 unsigned char * index_buffer
;
12327 /* Check the size of the archive index. */
12328 if (size
< SIZEOF_AR_INDEX_NUMBERS
)
12330 error (_("%s: the archive index is empty\n"), file_name
);
12334 /* Read the numer of entries in the archive index. */
12335 got
= fread (integer_buffer
, 1, sizeof integer_buffer
, file
);
12336 if (got
!= sizeof (integer_buffer
))
12338 error (_("%s: failed to read archive index\n"), file_name
);
12341 arch
->index_num
= byte_get_big_endian (integer_buffer
, sizeof integer_buffer
);
12342 size
-= SIZEOF_AR_INDEX_NUMBERS
;
12344 /* Read in the archive index. */
12345 if (size
< arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
)
12347 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
12348 file_name
, arch
->index_num
);
12351 index_buffer
= (unsigned char *)
12352 malloc (arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
);
12353 if (index_buffer
== NULL
)
12355 error (_("Out of memory whilst trying to read archive symbol index\n"));
12358 got
= fread (index_buffer
, SIZEOF_AR_INDEX_NUMBERS
, arch
->index_num
, file
);
12359 if (got
!= arch
->index_num
)
12361 free (index_buffer
);
12362 error (_("%s: failed to read archive index\n"), file_name
);
12365 size
-= arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
;
12367 /* Convert the index numbers into the host's numeric format. */
12368 arch
->index_array
= (long unsigned int *)
12369 malloc (arch
->index_num
* sizeof (* arch
->index_array
));
12370 if (arch
->index_array
== NULL
)
12372 free (index_buffer
);
12373 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
12377 for (i
= 0; i
< arch
->index_num
; i
++)
12378 arch
->index_array
[i
] = byte_get_big_endian ((unsigned char *) (index_buffer
+ (i
* SIZEOF_AR_INDEX_NUMBERS
)),
12379 SIZEOF_AR_INDEX_NUMBERS
);
12380 free (index_buffer
);
12382 /* The remaining space in the header is taken up by the symbol table. */
12385 error (_("%s: the archive has an index but no symbols\n"), file_name
);
12388 arch
->sym_table
= (char *) malloc (size
);
12389 arch
->sym_size
= size
;
12390 if (arch
->sym_table
== NULL
)
12392 error (_("Out of memory whilst trying to read archive index symbol table\n"));
12395 got
= fread (arch
->sym_table
, 1, size
, file
);
12398 error (_("%s: failed to read archive index symbol table\n"), file_name
);
12404 if (fseek (file
, size
, SEEK_CUR
) != 0)
12406 error (_("%s: failed to skip archive symbol table\n"), file_name
);
12411 /* Read the next archive header. */
12412 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
12413 if (got
!= sizeof arch
->arhdr
)
12417 error (_("%s: failed to read archive header following archive index\n"), file_name
);
12421 else if (read_symbols
)
12422 printf (_("%s has no archive index\n"), file_name
);
12424 if (const_strneq (arch
->arhdr
.ar_name
, "// "))
12426 /* This is the archive string table holding long member names. */
12427 arch
->longnames_size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
12428 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ arch
->longnames_size
;
12430 arch
->longnames
= (char *) malloc (arch
->longnames_size
);
12431 if (arch
->longnames
== NULL
)
12433 error (_("Out of memory reading long symbol names in archive\n"));
12437 if (fread (arch
->longnames
, arch
->longnames_size
, 1, file
) != 1)
12439 free (arch
->longnames
);
12440 arch
->longnames
= NULL
;
12441 error (_("%s: failed to read long symbol name string table\n"), file_name
);
12445 if ((arch
->longnames_size
& 1) != 0)
12452 /* Release the memory used for the archive information. */
12455 release_archive (struct archive_info
* arch
)
12457 if (arch
->file_name
!= NULL
)
12458 free (arch
->file_name
);
12459 if (arch
->index_array
!= NULL
)
12460 free (arch
->index_array
);
12461 if (arch
->sym_table
!= NULL
)
12462 free (arch
->sym_table
);
12463 if (arch
->longnames
!= NULL
)
12464 free (arch
->longnames
);
12467 /* Open and setup a nested archive, if not already open. */
12470 setup_nested_archive (struct archive_info
* nested_arch
, char * member_file_name
)
12472 FILE * member_file
;
12474 /* Have we already setup this archive? */
12475 if (nested_arch
->file_name
!= NULL
12476 && streq (nested_arch
->file_name
, member_file_name
))
12479 /* Close previous file and discard cached information. */
12480 if (nested_arch
->file
!= NULL
)
12481 fclose (nested_arch
->file
);
12482 release_archive (nested_arch
);
12484 member_file
= fopen (member_file_name
, "rb");
12485 if (member_file
== NULL
)
12487 return setup_archive (nested_arch
, member_file_name
, member_file
, FALSE
, FALSE
);
12491 get_archive_member_name_at (struct archive_info
* arch
,
12492 unsigned long offset
,
12493 struct archive_info
* nested_arch
);
12495 /* Get the name of an archive member from the current archive header.
12496 For simple names, this will modify the ar_name field of the current
12497 archive header. For long names, it will return a pointer to the
12498 longnames table. For nested archives, it will open the nested archive
12499 and get the name recursively. NESTED_ARCH is a single-entry cache so
12500 we don't keep rereading the same information from a nested archive. */
12503 get_archive_member_name (struct archive_info
* arch
,
12504 struct archive_info
* nested_arch
)
12506 unsigned long j
, k
;
12508 if (arch
->arhdr
.ar_name
[0] == '/')
12510 /* We have a long name. */
12512 char * member_file_name
;
12513 char * member_name
;
12515 arch
->nested_member_origin
= 0;
12516 k
= j
= strtoul (arch
->arhdr
.ar_name
+ 1, &endp
, 10);
12517 if (arch
->is_thin_archive
&& endp
!= NULL
&& * endp
== ':')
12518 arch
->nested_member_origin
= strtoul (endp
+ 1, NULL
, 10);
12520 while ((j
< arch
->longnames_size
)
12521 && (arch
->longnames
[j
] != '\n')
12522 && (arch
->longnames
[j
] != '\0'))
12524 if (arch
->longnames
[j
-1] == '/')
12526 arch
->longnames
[j
] = '\0';
12528 if (!arch
->is_thin_archive
|| arch
->nested_member_origin
== 0)
12529 return arch
->longnames
+ k
;
12531 /* This is a proxy for a member of a nested archive.
12532 Find the name of the member in that archive. */
12533 member_file_name
= adjust_relative_path (arch
->file_name
, arch
->longnames
+ k
, j
- k
);
12534 if (member_file_name
!= NULL
12535 && setup_nested_archive (nested_arch
, member_file_name
) == 0
12536 && (member_name
= get_archive_member_name_at (nested_arch
, arch
->nested_member_origin
, NULL
)) != NULL
)
12538 free (member_file_name
);
12539 return member_name
;
12541 free (member_file_name
);
12543 /* Last resort: just return the name of the nested archive. */
12544 return arch
->longnames
+ k
;
12547 /* We have a normal (short) name. */
12549 while ((arch
->arhdr
.ar_name
[j
] != '/') && (j
< 16))
12551 arch
->arhdr
.ar_name
[j
] = '\0';
12552 return arch
->arhdr
.ar_name
;
12555 /* Get the name of an archive member at a given OFFSET within an archive ARCH. */
12558 get_archive_member_name_at (struct archive_info
* arch
,
12559 unsigned long offset
,
12560 struct archive_info
* nested_arch
)
12564 if (fseek (arch
->file
, offset
, SEEK_SET
) != 0)
12566 error (_("%s: failed to seek to next file name\n"), arch
->file_name
);
12569 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, arch
->file
);
12570 if (got
!= sizeof arch
->arhdr
)
12572 error (_("%s: failed to read archive header\n"), arch
->file_name
);
12575 if (memcmp (arch
->arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
12577 error (_("%s: did not find a valid archive header\n"), arch
->file_name
);
12581 return get_archive_member_name (arch
, nested_arch
);
12584 /* Construct a string showing the name of the archive member, qualified
12585 with the name of the containing archive file. For thin archives, we
12586 use square brackets to denote the indirection. For nested archives,
12587 we show the qualified name of the external member inside the square
12588 brackets (e.g., "thin.a[normal.a(foo.o)]"). */
12591 make_qualified_name (struct archive_info
* arch
,
12592 struct archive_info
* nested_arch
,
12593 char * member_name
)
12598 len
= strlen (arch
->file_name
) + strlen (member_name
) + 3;
12599 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
12600 len
+= strlen (nested_arch
->file_name
) + 2;
12602 name
= (char *) malloc (len
);
12605 error (_("Out of memory\n"));
12609 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
12610 snprintf (name
, len
, "%s[%s(%s)]", arch
->file_name
, nested_arch
->file_name
, member_name
);
12611 else if (arch
->is_thin_archive
)
12612 snprintf (name
, len
, "%s[%s]", arch
->file_name
, member_name
);
12614 snprintf (name
, len
, "%s(%s)", arch
->file_name
, member_name
);
12619 /* Process an ELF archive.
12620 On entry the file is positioned just after the ARMAG string. */
12623 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
12625 struct archive_info arch
;
12626 struct archive_info nested_arch
;
12632 /* The ARCH structure is used to hold information about this archive. */
12633 arch
.file_name
= NULL
;
12635 arch
.index_array
= NULL
;
12636 arch
.sym_table
= NULL
;
12637 arch
.longnames
= NULL
;
12639 /* The NESTED_ARCH structure is used as a single-item cache of information
12640 about a nested archive (when members of a thin archive reside within
12641 another regular archive file). */
12642 nested_arch
.file_name
= NULL
;
12643 nested_arch
.file
= NULL
;
12644 nested_arch
.index_array
= NULL
;
12645 nested_arch
.sym_table
= NULL
;
12646 nested_arch
.longnames
= NULL
;
12648 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
12654 if (do_archive_index
)
12656 if (arch
.sym_table
== NULL
)
12657 error (_("%s: unable to dump the index as none was found\n"), file_name
);
12661 unsigned long current_pos
;
12663 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
12664 file_name
, arch
.index_num
, arch
.sym_size
);
12665 current_pos
= ftell (file
);
12667 for (i
= l
= 0; i
< arch
.index_num
; i
++)
12669 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
12671 char * member_name
;
12673 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
12675 if (member_name
!= NULL
)
12677 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
12679 if (qualified_name
!= NULL
)
12681 printf (_("Binary %s contains:\n"), qualified_name
);
12682 free (qualified_name
);
12687 if (l
>= arch
.sym_size
)
12689 error (_("%s: end of the symbol table reached before the end of the index\n"),
12693 printf ("\t%s\n", arch
.sym_table
+ l
);
12694 l
+= strlen (arch
.sym_table
+ l
) + 1;
12699 if (l
< arch
.sym_size
)
12700 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
12703 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
12705 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
12711 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
12712 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
12713 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
12714 && !do_section_groups
&& !do_dyn_syms
)
12716 ret
= 0; /* Archive index only. */
12727 char * qualified_name
;
12729 /* Read the next archive header. */
12730 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
12732 error (_("%s: failed to seek to next archive header\n"), file_name
);
12735 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
12736 if (got
!= sizeof arch
.arhdr
)
12740 error (_("%s: failed to read archive header\n"), file_name
);
12744 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
12746 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
12751 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
12753 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
12754 if (archive_file_size
& 01)
12755 ++archive_file_size
;
12757 name
= get_archive_member_name (&arch
, &nested_arch
);
12760 error (_("%s: bad archive file name\n"), file_name
);
12764 namelen
= strlen (name
);
12766 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
12767 if (qualified_name
== NULL
)
12769 error (_("%s: bad archive file name\n"), file_name
);
12774 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
12776 /* This is a proxy for an external member of a thin archive. */
12777 FILE * member_file
;
12778 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
12779 if (member_file_name
== NULL
)
12785 member_file
= fopen (member_file_name
, "rb");
12786 if (member_file
== NULL
)
12788 error (_("Input file '%s' is not readable.\n"), member_file_name
);
12789 free (member_file_name
);
12794 archive_file_offset
= arch
.nested_member_origin
;
12796 ret
|= process_object (qualified_name
, member_file
);
12798 fclose (member_file
);
12799 free (member_file_name
);
12801 else if (is_thin_archive
)
12803 /* This is a proxy for a member of a nested archive. */
12804 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
12806 /* The nested archive file will have been opened and setup by
12807 get_archive_member_name. */
12808 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
12810 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
12815 ret
|= process_object (qualified_name
, nested_arch
.file
);
12819 archive_file_offset
= arch
.next_arhdr_offset
;
12820 arch
.next_arhdr_offset
+= archive_file_size
;
12822 ret
|= process_object (qualified_name
, file
);
12825 free (qualified_name
);
12829 if (nested_arch
.file
!= NULL
)
12830 fclose (nested_arch
.file
);
12831 release_archive (&nested_arch
);
12832 release_archive (&arch
);
12838 process_file (char * file_name
)
12841 struct stat statbuf
;
12842 char armag
[SARMAG
];
12845 if (stat (file_name
, &statbuf
) < 0)
12847 if (errno
== ENOENT
)
12848 error (_("'%s': No such file\n"), file_name
);
12850 error (_("Could not locate '%s'. System error message: %s\n"),
12851 file_name
, strerror (errno
));
12855 if (! S_ISREG (statbuf
.st_mode
))
12857 error (_("'%s' is not an ordinary file\n"), file_name
);
12861 file
= fopen (file_name
, "rb");
12864 error (_("Input file '%s' is not readable.\n"), file_name
);
12868 if (fread (armag
, SARMAG
, 1, file
) != 1)
12870 error (_("%s: Failed to read file's magic number\n"), file_name
);
12875 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
12876 ret
= process_archive (file_name
, file
, FALSE
);
12877 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
12878 ret
= process_archive (file_name
, file
, TRUE
);
12881 if (do_archive_index
)
12882 error (_("File %s is not an archive so its index cannot be displayed.\n"),
12886 archive_file_size
= archive_file_offset
= 0;
12887 ret
= process_object (file_name
, file
);
12895 #ifdef SUPPORT_DISASSEMBLY
12896 /* Needed by the i386 disassembler. For extra credit, someone could
12897 fix this so that we insert symbolic addresses here, esp for GOT/PLT
12901 print_address (unsigned int addr
, FILE * outfile
)
12903 fprintf (outfile
,"0x%8.8x", addr
);
12906 /* Needed by the i386 disassembler. */
12908 db_task_printsym (unsigned int addr
)
12910 print_address (addr
, stderr
);
12915 main (int argc
, char ** argv
)
12919 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
12920 setlocale (LC_MESSAGES
, "");
12922 #if defined (HAVE_SETLOCALE)
12923 setlocale (LC_CTYPE
, "");
12925 bindtextdomain (PACKAGE
, LOCALEDIR
);
12926 textdomain (PACKAGE
);
12928 expandargv (&argc
, &argv
);
12930 parse_args (argc
, argv
);
12932 if (num_dump_sects
> 0)
12934 /* Make a copy of the dump_sects array. */
12935 cmdline_dump_sects
= (dump_type
*)
12936 malloc (num_dump_sects
* sizeof (* dump_sects
));
12937 if (cmdline_dump_sects
== NULL
)
12938 error (_("Out of memory allocating dump request table.\n"));
12941 memcpy (cmdline_dump_sects
, dump_sects
,
12942 num_dump_sects
* sizeof (* dump_sects
));
12943 num_cmdline_dump_sects
= num_dump_sects
;
12947 if (optind
< (argc
- 1))
12951 while (optind
< argc
)
12952 err
|= process_file (argv
[optind
++]);
12954 if (dump_sects
!= NULL
)
12956 if (cmdline_dump_sects
!= NULL
)
12957 free (cmdline_dump_sects
);