1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
4 Free Software Foundation, Inc.
6 Originally developed by Eric Youngdale <eric@andante.jic.com>
7 Modifications by Nick Clifton <nickc@redhat.com>
9 This file is part of GNU Binutils.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
26 /* The difference between readelf and objdump:
28 Both programs are capable of displaying the contents of ELF format files,
29 so why does the binutils project have two file dumpers ?
31 The reason is that objdump sees an ELF file through a BFD filter of the
32 world; if BFD has a bug where, say, it disagrees about a machine constant
33 in e_flags, then the odds are good that it will remain internally
34 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
35 GAS sees it the BFD way. There was need for a tool to go find out what
36 the file actually says.
38 This is why the readelf program does not link against the BFD library - it
39 exists as an independent program to help verify the correct working of BFD.
41 There is also the case that readelf can provide more information about an
42 ELF file than is provided by objdump. In particular it can display DWARF
43 debugging information which (at the moment) objdump cannot. */
55 /* Define BFD64 here, even if our default architecture is 32 bit ELF
56 as this will allow us to read in and parse 64bit and 32bit ELF files.
57 Only do this if we believe that the compiler can support a 64 bit
58 data type. For now we only rely on GCC being able to do this. */
66 #include "elf/common.h"
67 #include "elf/external.h"
68 #include "elf/internal.h"
71 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
72 we can obtain the H8 reloc numbers. We need these for the
73 get_reloc_size() function. We include h8.h again after defining
74 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
79 /* Undo the effects of #including reloc-macros.h. */
81 #undef START_RELOC_NUMBERS
85 #undef END_RELOC_NUMBERS
86 #undef _RELOC_MACROS_H
88 /* The following headers use the elf/reloc-macros.h file to
89 automatically generate relocation recognition functions
90 such as elf_mips_reloc_type() */
92 #define RELOC_MACROS_GEN_FUNC
94 #include "elf/alpha.h"
100 #include "elf/cris.h"
102 #include "elf/d10v.h"
103 #include "elf/d30v.h"
105 #include "elf/fr30.h"
108 #include "elf/hppa.h"
109 #include "elf/i386.h"
110 #include "elf/i370.h"
111 #include "elf/i860.h"
112 #include "elf/i960.h"
113 #include "elf/ia64.h"
114 #include "elf/ip2k.h"
115 #include "elf/lm32.h"
116 #include "elf/iq2000.h"
117 #include "elf/m32c.h"
118 #include "elf/m32r.h"
119 #include "elf/m68k.h"
120 #include "elf/m68hc11.h"
121 #include "elf/mcore.h"
123 #include "elf/microblaze.h"
124 #include "elf/mips.h"
125 #include "elf/mmix.h"
126 #include "elf/mn10200.h"
127 #include "elf/mn10300.h"
129 #include "elf/msp430.h"
130 #include "elf/or32.h"
133 #include "elf/ppc64.h"
135 #include "elf/s390.h"
136 #include "elf/score.h"
138 #include "elf/sparc.h"
140 #include "elf/tic6x.h"
141 #include "elf/v850.h"
143 #include "elf/x86-64.h"
144 #include "elf/xc16x.h"
145 #include "elf/xstormy16.h"
146 #include "elf/xtensa.h"
151 #include "libiberty.h"
152 #include "safe-ctype.h"
153 #include "filenames.h"
155 char * program_name
= "readelf";
156 static long archive_file_offset
;
157 static unsigned long archive_file_size
;
158 static unsigned long dynamic_addr
;
159 static bfd_size_type dynamic_size
;
160 static unsigned int dynamic_nent
;
161 static char * dynamic_strings
;
162 static unsigned long dynamic_strings_length
;
163 static char * string_table
;
164 static unsigned long string_table_length
;
165 static unsigned long num_dynamic_syms
;
166 static Elf_Internal_Sym
* dynamic_symbols
;
167 static Elf_Internal_Syminfo
* dynamic_syminfo
;
168 static unsigned long dynamic_syminfo_offset
;
169 static unsigned int dynamic_syminfo_nent
;
170 static char program_interpreter
[PATH_MAX
];
171 static bfd_vma dynamic_info
[DT_ENCODING
];
172 static bfd_vma dynamic_info_DT_GNU_HASH
;
173 static bfd_vma version_info
[16];
174 static Elf_Internal_Ehdr elf_header
;
175 static Elf_Internal_Shdr
* section_headers
;
176 static Elf_Internal_Phdr
* program_headers
;
177 static Elf_Internal_Dyn
* dynamic_section
;
178 static Elf_Internal_Shdr
* symtab_shndx_hdr
;
179 static int show_name
;
180 static int do_dynamic
;
182 static int do_dyn_syms
;
184 static int do_sections
;
185 static int do_section_groups
;
186 static int do_section_details
;
187 static int do_segments
;
188 static int do_unwind
;
189 static int do_using_dynamic
;
190 static int do_header
;
192 static int do_version
;
193 static int do_histogram
;
194 static int do_debugging
;
197 static int do_archive_index
;
198 static int is_32bit_elf
;
202 struct group_list
* next
;
203 unsigned int section_index
;
208 struct group_list
* root
;
209 unsigned int group_index
;
212 static size_t group_count
;
213 static struct group
* section_groups
;
214 static struct group
** section_headers_groups
;
217 /* Flag bits indicating particular types of dump. */
218 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
219 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
220 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
221 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
222 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
224 typedef unsigned char dump_type
;
226 /* A linked list of the section names for which dumps were requested. */
227 struct dump_list_entry
231 struct dump_list_entry
* next
;
233 static struct dump_list_entry
* dump_sects_byname
;
235 /* A dynamic array of flags indicating for which sections a dump
236 has been requested via command line switches. */
237 static dump_type
* cmdline_dump_sects
= NULL
;
238 static unsigned int num_cmdline_dump_sects
= 0;
240 /* A dynamic array of flags indicating for which sections a dump of
241 some kind has been requested. It is reset on a per-object file
242 basis and then initialised from the cmdline_dump_sects array,
243 the results of interpreting the -w switch, and the
244 dump_sects_byname list. */
245 static dump_type
* dump_sects
= NULL
;
246 static unsigned int num_dump_sects
= 0;
249 /* How to print a vma value. */
250 typedef enum print_mode
262 static void (* byte_put
) (unsigned char *, bfd_vma
, int);
266 #define SECTION_NAME(X) \
267 ((X) == NULL ? _("<none>") \
268 : string_table == NULL ? _("<no-name>") \
269 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
270 : string_table + (X)->sh_name))
272 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
274 #define BYTE_GET(field) byte_get (field, sizeof (field))
276 #define GET_ELF_SYMBOLS(file, section) \
277 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
278 : get_64bit_elf_symbols (file, section))
280 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
281 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
282 already been called and verified that the string exists. */
283 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
285 /* This is just a bit of syntatic sugar. */
286 #define streq(a,b) (strcmp ((a), (b)) == 0)
287 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
288 #define const_strneq(a,b) (strncmp ((a), (b), sizeof (b) - 1) == 0)
290 #define REMOVE_ARCH_BITS(ADDR) do { \
291 if (elf_header.e_machine == EM_ARM) \
296 get_data (void * var
, FILE * file
, long offset
, size_t size
, size_t nmemb
,
301 if (size
== 0 || nmemb
== 0)
304 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
306 error (_("Unable to seek to 0x%lx for %s\n"),
307 (unsigned long) archive_file_offset
+ offset
, reason
);
314 /* Check for overflow. */
315 if (nmemb
< (~(size_t) 0 - 1) / size
)
316 /* + 1 so that we can '\0' terminate invalid string table sections. */
317 mvar
= malloc (size
* nmemb
+ 1);
321 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
322 (unsigned long)(size
* nmemb
), reason
);
326 ((char *) mvar
)[size
* nmemb
] = '\0';
329 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
331 error (_("Unable to read in 0x%lx bytes of %s\n"),
332 (unsigned long)(size
* nmemb
), reason
);
342 byte_put_little_endian (unsigned char * field
, bfd_vma value
, int size
)
347 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
348 field
[6] = ((value
>> 24) >> 24) & 0xff;
349 field
[5] = ((value
>> 24) >> 16) & 0xff;
350 field
[4] = ((value
>> 24) >> 8) & 0xff;
353 field
[3] = (value
>> 24) & 0xff;
356 field
[2] = (value
>> 16) & 0xff;
359 field
[1] = (value
>> 8) & 0xff;
362 field
[0] = value
& 0xff;
366 error (_("Unhandled data length: %d\n"), size
);
371 /* Print a VMA value. */
374 print_vma (bfd_vma vma
, print_mode mode
)
387 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
394 return printf ("%5" BFD_VMA_FMT
"d", vma
);
402 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
405 return printf ("%" BFD_VMA_FMT
"d", vma
);
408 return printf ("%" BFD_VMA_FMT
"u", vma
);
413 /* Display a symbol on stdout. Handles the display of non-printing characters.
415 If DO_WIDE is not true then format the symbol to be at most WIDTH characters,
416 truncating as necessary. If WIDTH is negative then format the string to be
417 exactly - WIDTH characters, truncating or padding as necessary.
419 Returns the number of emitted characters. */
422 print_symbol (int width
, const char * symbol
)
425 bfd_boolean extra_padding
= FALSE
;
426 unsigned int num_printed
= 0;
430 /* Set the width to a very large value. This simplifies the code below. */
435 /* Keep the width positive. This also helps. */
437 extra_padding
= TRUE
;
446 /* Look for non-printing symbols inside the symbol's name.
447 This test is triggered in particular by the names generated
448 by the assembler for local labels. */
449 while (ISPRINT (* c
))
459 printf ("%.*s", len
, symbol
);
465 if (* c
== 0 || width
== 0)
468 /* Now display the non-printing character, if
469 there is room left in which to dipslay it. */
475 printf ("^%c", *c
+ 0x40);
485 printf ("<0x%.2x>", *c
);
494 if (extra_padding
&& width
> 0)
496 /* Fill in the remaining spaces. */
497 printf ("%-*s", width
, " ");
505 byte_put_big_endian (unsigned char * field
, bfd_vma value
, int size
)
510 field
[7] = value
& 0xff;
511 field
[6] = (value
>> 8) & 0xff;
512 field
[5] = (value
>> 16) & 0xff;
513 field
[4] = (value
>> 24) & 0xff;
518 field
[3] = value
& 0xff;
522 field
[2] = value
& 0xff;
526 field
[1] = value
& 0xff;
530 field
[0] = value
& 0xff;
534 error (_("Unhandled data length: %d\n"), size
);
539 /* Return a pointer to section NAME, or NULL if no such section exists. */
541 static Elf_Internal_Shdr
*
542 find_section (const char * name
)
546 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
547 if (streq (SECTION_NAME (section_headers
+ i
), name
))
548 return section_headers
+ i
;
553 /* Return a pointer to a section containing ADDR, or NULL if no such
556 static Elf_Internal_Shdr
*
557 find_section_by_address (bfd_vma addr
)
561 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
563 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
564 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
571 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
575 read_uleb128 (unsigned char *data
, unsigned int *length_return
)
577 return read_leb128 (data
, length_return
, 0);
580 /* Guess the relocation size commonly used by the specific machines. */
583 guess_is_rela (unsigned int e_machine
)
587 /* Targets that use REL relocations. */
603 /* Targets that use RELA relocations. */
607 case EM_ALTERA_NIOS2
:
627 case EM_LATTICEMICO32
:
635 case EM_CYGNUS_MN10200
:
637 case EM_CYGNUS_MN10300
:
662 case EM_MICROBLAZE_OLD
:
683 warn (_("Don't know about relocations on this machine architecture\n"));
689 slurp_rela_relocs (FILE * file
,
690 unsigned long rel_offset
,
691 unsigned long rel_size
,
692 Elf_Internal_Rela
** relasp
,
693 unsigned long * nrelasp
)
695 Elf_Internal_Rela
* relas
;
696 unsigned long nrelas
;
701 Elf32_External_Rela
* erelas
;
703 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
704 rel_size
, _("relocs"));
708 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
710 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
711 sizeof (Elf_Internal_Rela
));
716 error (_("out of memory parsing relocs\n"));
720 for (i
= 0; i
< nrelas
; i
++)
722 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
723 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
724 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
731 Elf64_External_Rela
* erelas
;
733 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
734 rel_size
, _("relocs"));
738 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
740 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
741 sizeof (Elf_Internal_Rela
));
746 error (_("out of memory parsing relocs\n"));
750 for (i
= 0; i
< nrelas
; i
++)
752 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
753 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
754 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
756 /* The #ifdef BFD64 below is to prevent a compile time
757 warning. We know that if we do not have a 64 bit data
758 type that we will never execute this code anyway. */
760 if (elf_header
.e_machine
== EM_MIPS
761 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
763 /* In little-endian objects, r_info isn't really a
764 64-bit little-endian value: it has a 32-bit
765 little-endian symbol index followed by four
766 individual byte fields. Reorder INFO
768 bfd_vma inf
= relas
[i
].r_info
;
769 inf
= (((inf
& 0xffffffff) << 32)
770 | ((inf
>> 56) & 0xff)
771 | ((inf
>> 40) & 0xff00)
772 | ((inf
>> 24) & 0xff0000)
773 | ((inf
>> 8) & 0xff000000));
774 relas
[i
].r_info
= inf
;
787 slurp_rel_relocs (FILE * file
,
788 unsigned long rel_offset
,
789 unsigned long rel_size
,
790 Elf_Internal_Rela
** relsp
,
791 unsigned long * nrelsp
)
793 Elf_Internal_Rela
* rels
;
799 Elf32_External_Rel
* erels
;
801 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
802 rel_size
, _("relocs"));
806 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
808 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
813 error (_("out of memory parsing relocs\n"));
817 for (i
= 0; i
< nrels
; i
++)
819 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
820 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
821 rels
[i
].r_addend
= 0;
828 Elf64_External_Rel
* erels
;
830 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
831 rel_size
, _("relocs"));
835 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
837 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
842 error (_("out of memory parsing relocs\n"));
846 for (i
= 0; i
< nrels
; i
++)
848 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
849 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
850 rels
[i
].r_addend
= 0;
852 /* The #ifdef BFD64 below is to prevent a compile time
853 warning. We know that if we do not have a 64 bit data
854 type that we will never execute this code anyway. */
856 if (elf_header
.e_machine
== EM_MIPS
857 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
859 /* In little-endian objects, r_info isn't really a
860 64-bit little-endian value: it has a 32-bit
861 little-endian symbol index followed by four
862 individual byte fields. Reorder INFO
864 bfd_vma inf
= rels
[i
].r_info
;
865 inf
= (((inf
& 0xffffffff) << 32)
866 | ((inf
>> 56) & 0xff)
867 | ((inf
>> 40) & 0xff00)
868 | ((inf
>> 24) & 0xff0000)
869 | ((inf
>> 8) & 0xff000000));
870 rels
[i
].r_info
= inf
;
882 /* Returns the reloc type extracted from the reloc info field. */
885 get_reloc_type (bfd_vma reloc_info
)
888 return ELF32_R_TYPE (reloc_info
);
890 switch (elf_header
.e_machine
)
893 /* Note: We assume that reloc_info has already been adjusted for us. */
894 return ELF64_MIPS_R_TYPE (reloc_info
);
897 return ELF64_R_TYPE_ID (reloc_info
);
900 return ELF64_R_TYPE (reloc_info
);
904 /* Return the symbol index extracted from the reloc info field. */
907 get_reloc_symindex (bfd_vma reloc_info
)
909 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
912 /* Display the contents of the relocation data found at the specified
916 dump_relocations (FILE * file
,
917 unsigned long rel_offset
,
918 unsigned long rel_size
,
919 Elf_Internal_Sym
* symtab
,
922 unsigned long strtablen
,
926 Elf_Internal_Rela
* rels
;
928 if (is_rela
== UNKNOWN
)
929 is_rela
= guess_is_rela (elf_header
.e_machine
);
933 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
938 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
947 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
949 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
954 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
956 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
964 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
966 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
971 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
973 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
977 for (i
= 0; i
< rel_size
; i
++)
982 bfd_vma symtab_index
;
985 offset
= rels
[i
].r_offset
;
986 inf
= rels
[i
].r_info
;
988 type
= get_reloc_type (inf
);
989 symtab_index
= get_reloc_symindex (inf
);
993 printf ("%8.8lx %8.8lx ",
994 (unsigned long) offset
& 0xffffffff,
995 (unsigned long) inf
& 0xffffffff);
999 #if BFD_HOST_64BIT_LONG
1001 ? "%16.16lx %16.16lx "
1002 : "%12.12lx %12.12lx ",
1004 #elif BFD_HOST_64BIT_LONG_LONG
1007 ? "%16.16llx %16.16llx "
1008 : "%12.12llx %12.12llx ",
1012 ? "%16.16I64x %16.16I64x "
1013 : "%12.12I64x %12.12I64x ",
1018 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1019 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1020 _bfd_int64_high (offset
),
1021 _bfd_int64_low (offset
),
1022 _bfd_int64_high (inf
),
1023 _bfd_int64_low (inf
));
1027 switch (elf_header
.e_machine
)
1034 case EM_CYGNUS_M32R
:
1035 rtype
= elf_m32r_reloc_type (type
);
1040 rtype
= elf_i386_reloc_type (type
);
1045 rtype
= elf_m68hc11_reloc_type (type
);
1049 rtype
= elf_m68k_reloc_type (type
);
1053 rtype
= elf_i960_reloc_type (type
);
1058 rtype
= elf_avr_reloc_type (type
);
1061 case EM_OLD_SPARCV9
:
1062 case EM_SPARC32PLUS
:
1065 rtype
= elf_sparc_reloc_type (type
);
1069 rtype
= elf_spu_reloc_type (type
);
1073 case EM_CYGNUS_V850
:
1074 rtype
= v850_reloc_type (type
);
1078 case EM_CYGNUS_D10V
:
1079 rtype
= elf_d10v_reloc_type (type
);
1083 case EM_CYGNUS_D30V
:
1084 rtype
= elf_d30v_reloc_type (type
);
1088 rtype
= elf_dlx_reloc_type (type
);
1092 rtype
= elf_sh_reloc_type (type
);
1096 case EM_CYGNUS_MN10300
:
1097 rtype
= elf_mn10300_reloc_type (type
);
1101 case EM_CYGNUS_MN10200
:
1102 rtype
= elf_mn10200_reloc_type (type
);
1106 case EM_CYGNUS_FR30
:
1107 rtype
= elf_fr30_reloc_type (type
);
1111 rtype
= elf_frv_reloc_type (type
);
1115 rtype
= elf_mcore_reloc_type (type
);
1119 rtype
= elf_mmix_reloc_type (type
);
1124 rtype
= elf_msp430_reloc_type (type
);
1128 rtype
= elf_ppc_reloc_type (type
);
1132 rtype
= elf_ppc64_reloc_type (type
);
1136 case EM_MIPS_RS3_LE
:
1137 rtype
= elf_mips_reloc_type (type
);
1141 rtype
= elf_alpha_reloc_type (type
);
1145 rtype
= elf_arm_reloc_type (type
);
1149 rtype
= elf_arc_reloc_type (type
);
1153 rtype
= elf_hppa_reloc_type (type
);
1159 rtype
= elf_h8_reloc_type (type
);
1164 rtype
= elf_or32_reloc_type (type
);
1169 rtype
= elf_pj_reloc_type (type
);
1172 rtype
= elf_ia64_reloc_type (type
);
1176 rtype
= elf_cris_reloc_type (type
);
1180 rtype
= elf_i860_reloc_type (type
);
1185 rtype
= elf_x86_64_reloc_type (type
);
1189 rtype
= i370_reloc_type (type
);
1194 rtype
= elf_s390_reloc_type (type
);
1198 rtype
= elf_score_reloc_type (type
);
1202 rtype
= elf_xstormy16_reloc_type (type
);
1206 rtype
= elf_crx_reloc_type (type
);
1210 rtype
= elf_vax_reloc_type (type
);
1215 rtype
= elf_ip2k_reloc_type (type
);
1219 rtype
= elf_iq2000_reloc_type (type
);
1224 rtype
= elf_xtensa_reloc_type (type
);
1227 case EM_LATTICEMICO32
:
1228 rtype
= elf_lm32_reloc_type (type
);
1233 rtype
= elf_m32c_reloc_type (type
);
1237 rtype
= elf_mt_reloc_type (type
);
1241 rtype
= elf_bfin_reloc_type (type
);
1245 rtype
= elf_mep_reloc_type (type
);
1250 rtype
= elf_cr16_reloc_type (type
);
1254 case EM_MICROBLAZE_OLD
:
1255 rtype
= elf_microblaze_reloc_type (type
);
1259 rtype
= elf_rx_reloc_type (type
);
1264 rtype
= elf_xc16x_reloc_type (type
);
1268 rtype
= elf_tic6x_reloc_type (type
);
1273 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1275 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1277 if (elf_header
.e_machine
== EM_ALPHA
1279 && streq (rtype
, "R_ALPHA_LITUSE")
1282 switch (rels
[i
].r_addend
)
1284 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1285 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1286 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1287 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1288 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1289 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1290 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1291 default: rtype
= NULL
;
1294 printf (" (%s)", rtype
);
1298 printf (_("<unknown addend: %lx>"),
1299 (unsigned long) rels
[i
].r_addend
);
1302 else if (symtab_index
)
1304 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1305 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index
);
1308 Elf_Internal_Sym
* psym
;
1310 psym
= symtab
+ symtab_index
;
1314 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1318 unsigned int width
= is_32bit_elf
? 8 : 14;
1320 /* Relocations against GNU_IFUNC symbols do not use the value
1321 of the symbol as the address to relocate against. Instead
1322 they invoke the function named by the symbol and use its
1323 result as the address for relocation.
1325 To indicate this to the user, do not display the value of
1326 the symbol in the "Symbols's Value" field. Instead show
1327 its name followed by () as a hint that the symbol is
1331 || psym
->st_name
== 0
1332 || psym
->st_name
>= strtablen
)
1335 name
= strtab
+ psym
->st_name
;
1337 len
= print_symbol (width
, name
);
1338 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1342 print_vma (psym
->st_value
, LONG_HEX
);
1344 printf (is_32bit_elf
? " " : " ");
1347 if (psym
->st_name
== 0)
1349 const char * sec_name
= "<null>";
1352 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1354 if (psym
->st_shndx
< elf_header
.e_shnum
)
1356 = SECTION_NAME (section_headers
+ psym
->st_shndx
);
1357 else if (psym
->st_shndx
== SHN_ABS
)
1359 else if (psym
->st_shndx
== SHN_COMMON
)
1360 sec_name
= "COMMON";
1361 else if (elf_header
.e_machine
== EM_MIPS
1362 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1363 sec_name
= "SCOMMON";
1364 else if (elf_header
.e_machine
== EM_MIPS
1365 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1366 sec_name
= "SUNDEF";
1367 else if ((elf_header
.e_machine
== EM_X86_64
1368 || elf_header
.e_machine
== EM_L1OM
)
1369 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1370 sec_name
= "LARGE_COMMON";
1371 else if (elf_header
.e_machine
== EM_IA_64
1372 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1373 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1374 sec_name
= "ANSI_COM";
1375 else if (elf_header
.e_machine
== EM_IA_64
1376 && (elf_header
.e_ident
[EI_OSABI
]
1377 == ELFOSABI_OPENVMS
)
1378 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1379 sec_name
= "VMS_SYMVEC";
1382 sprintf (name_buf
, "<section 0x%x>",
1383 (unsigned int) psym
->st_shndx
);
1384 sec_name
= name_buf
;
1387 print_symbol (22, sec_name
);
1389 else if (strtab
== NULL
)
1390 printf (_("<string table index: %3ld>"), psym
->st_name
);
1391 else if (psym
->st_name
>= strtablen
)
1392 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1394 print_symbol (22, strtab
+ psym
->st_name
);
1398 long off
= (long) (bfd_signed_vma
) rels
[i
].r_addend
;
1401 printf (" - %lx", - off
);
1403 printf (" + %lx", off
);
1409 printf ("%*c", is_32bit_elf
?
1410 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1411 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1414 if (elf_header
.e_machine
== EM_SPARCV9
1416 && streq (rtype
, "R_SPARC_OLO10"))
1417 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1422 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1424 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1425 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1426 const char * rtype2
= elf_mips_reloc_type (type2
);
1427 const char * rtype3
= elf_mips_reloc_type (type3
);
1429 printf (" Type2: ");
1432 printf (_("unrecognized: %-7lx"),
1433 (unsigned long) type2
& 0xffffffff);
1435 printf ("%-17.17s", rtype2
);
1437 printf ("\n Type3: ");
1440 printf (_("unrecognized: %-7lx"),
1441 (unsigned long) type3
& 0xffffffff);
1443 printf ("%-17.17s", rtype3
);
1454 get_mips_dynamic_type (unsigned long type
)
1458 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1459 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1460 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1461 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1462 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1463 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1464 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1465 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1466 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1467 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1468 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1469 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1470 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1471 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1472 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1473 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1474 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1475 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1476 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1477 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1478 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1479 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1480 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1481 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1482 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1483 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1484 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1485 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1486 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1487 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1488 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1489 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1490 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1491 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1492 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1493 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1494 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1495 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1496 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1497 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1498 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1499 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1500 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1501 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1502 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1509 get_sparc64_dynamic_type (unsigned long type
)
1513 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1520 get_ppc_dynamic_type (unsigned long type
)
1524 case DT_PPC_GOT
: return "PPC_GOT";
1525 case DT_PPC_TLSOPT
: return "PPC_TLSOPT";
1532 get_ppc64_dynamic_type (unsigned long type
)
1536 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1537 case DT_PPC64_OPD
: return "PPC64_OPD";
1538 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1539 case DT_PPC64_TLSOPT
: return "PPC64_TLSOPT";
1546 get_parisc_dynamic_type (unsigned long type
)
1550 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1551 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1552 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1553 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1554 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1555 case DT_HP_PREINIT
: return "HP_PREINIT";
1556 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1557 case DT_HP_NEEDED
: return "HP_NEEDED";
1558 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1559 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1560 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1561 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1562 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1563 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1564 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1565 case DT_HP_FILTERED
: return "HP_FILTERED";
1566 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1567 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1568 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1569 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1570 case DT_PLT
: return "PLT";
1571 case DT_PLT_SIZE
: return "PLT_SIZE";
1572 case DT_DLT
: return "DLT";
1573 case DT_DLT_SIZE
: return "DLT_SIZE";
1580 get_ia64_dynamic_type (unsigned long type
)
1584 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1585 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1586 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1587 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1588 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1589 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1590 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1591 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1592 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1593 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1594 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1595 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1596 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1597 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1598 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1599 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1600 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1601 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1602 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1603 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1604 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1605 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1606 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1607 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1608 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1609 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1610 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1611 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1612 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1613 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1614 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1621 get_alpha_dynamic_type (unsigned long type
)
1625 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1632 get_score_dynamic_type (unsigned long type
)
1636 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1637 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1638 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1639 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1640 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1641 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1648 get_tic6x_dynamic_type (unsigned long type
)
1652 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1653 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1654 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1655 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1656 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1657 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1664 get_dynamic_type (unsigned long type
)
1666 static char buff
[64];
1670 case DT_NULL
: return "NULL";
1671 case DT_NEEDED
: return "NEEDED";
1672 case DT_PLTRELSZ
: return "PLTRELSZ";
1673 case DT_PLTGOT
: return "PLTGOT";
1674 case DT_HASH
: return "HASH";
1675 case DT_STRTAB
: return "STRTAB";
1676 case DT_SYMTAB
: return "SYMTAB";
1677 case DT_RELA
: return "RELA";
1678 case DT_RELASZ
: return "RELASZ";
1679 case DT_RELAENT
: return "RELAENT";
1680 case DT_STRSZ
: return "STRSZ";
1681 case DT_SYMENT
: return "SYMENT";
1682 case DT_INIT
: return "INIT";
1683 case DT_FINI
: return "FINI";
1684 case DT_SONAME
: return "SONAME";
1685 case DT_RPATH
: return "RPATH";
1686 case DT_SYMBOLIC
: return "SYMBOLIC";
1687 case DT_REL
: return "REL";
1688 case DT_RELSZ
: return "RELSZ";
1689 case DT_RELENT
: return "RELENT";
1690 case DT_PLTREL
: return "PLTREL";
1691 case DT_DEBUG
: return "DEBUG";
1692 case DT_TEXTREL
: return "TEXTREL";
1693 case DT_JMPREL
: return "JMPREL";
1694 case DT_BIND_NOW
: return "BIND_NOW";
1695 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1696 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1697 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1698 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1699 case DT_RUNPATH
: return "RUNPATH";
1700 case DT_FLAGS
: return "FLAGS";
1702 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1703 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1705 case DT_CHECKSUM
: return "CHECKSUM";
1706 case DT_PLTPADSZ
: return "PLTPADSZ";
1707 case DT_MOVEENT
: return "MOVEENT";
1708 case DT_MOVESZ
: return "MOVESZ";
1709 case DT_FEATURE
: return "FEATURE";
1710 case DT_POSFLAG_1
: return "POSFLAG_1";
1711 case DT_SYMINSZ
: return "SYMINSZ";
1712 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1714 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1715 case DT_CONFIG
: return "CONFIG";
1716 case DT_DEPAUDIT
: return "DEPAUDIT";
1717 case DT_AUDIT
: return "AUDIT";
1718 case DT_PLTPAD
: return "PLTPAD";
1719 case DT_MOVETAB
: return "MOVETAB";
1720 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1722 case DT_VERSYM
: return "VERSYM";
1724 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1725 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1726 case DT_RELACOUNT
: return "RELACOUNT";
1727 case DT_RELCOUNT
: return "RELCOUNT";
1728 case DT_FLAGS_1
: return "FLAGS_1";
1729 case DT_VERDEF
: return "VERDEF";
1730 case DT_VERDEFNUM
: return "VERDEFNUM";
1731 case DT_VERNEED
: return "VERNEED";
1732 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1734 case DT_AUXILIARY
: return "AUXILIARY";
1735 case DT_USED
: return "USED";
1736 case DT_FILTER
: return "FILTER";
1738 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1739 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1740 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1741 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1742 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1743 case DT_GNU_HASH
: return "GNU_HASH";
1746 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1748 const char * result
;
1750 switch (elf_header
.e_machine
)
1753 case EM_MIPS_RS3_LE
:
1754 result
= get_mips_dynamic_type (type
);
1757 result
= get_sparc64_dynamic_type (type
);
1760 result
= get_ppc_dynamic_type (type
);
1763 result
= get_ppc64_dynamic_type (type
);
1766 result
= get_ia64_dynamic_type (type
);
1769 result
= get_alpha_dynamic_type (type
);
1772 result
= get_score_dynamic_type (type
);
1775 result
= get_tic6x_dynamic_type (type
);
1785 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1787 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1788 || (elf_header
.e_machine
== EM_PARISC
1789 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1791 const char * result
;
1793 switch (elf_header
.e_machine
)
1796 result
= get_parisc_dynamic_type (type
);
1799 result
= get_ia64_dynamic_type (type
);
1809 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1813 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1820 get_file_type (unsigned e_type
)
1822 static char buff
[32];
1826 case ET_NONE
: return _("NONE (None)");
1827 case ET_REL
: return _("REL (Relocatable file)");
1828 case ET_EXEC
: return _("EXEC (Executable file)");
1829 case ET_DYN
: return _("DYN (Shared object file)");
1830 case ET_CORE
: return _("CORE (Core file)");
1833 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1834 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1835 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1836 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1838 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1844 get_machine_name (unsigned e_machine
)
1846 static char buff
[64]; /* XXX */
1850 case EM_NONE
: return _("None");
1851 case EM_M32
: return "WE32100";
1852 case EM_SPARC
: return "Sparc";
1853 case EM_SPU
: return "SPU";
1854 case EM_386
: return "Intel 80386";
1855 case EM_68K
: return "MC68000";
1856 case EM_88K
: return "MC88000";
1857 case EM_486
: return "Intel 80486";
1858 case EM_860
: return "Intel 80860";
1859 case EM_MIPS
: return "MIPS R3000";
1860 case EM_S370
: return "IBM System/370";
1861 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1862 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1863 case EM_PARISC
: return "HPPA";
1864 case EM_PPC_OLD
: return "Power PC (old)";
1865 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1866 case EM_960
: return "Intel 90860";
1867 case EM_PPC
: return "PowerPC";
1868 case EM_PPC64
: return "PowerPC64";
1869 case EM_V800
: return "NEC V800";
1870 case EM_FR20
: return "Fujitsu FR20";
1871 case EM_RH32
: return "TRW RH32";
1872 case EM_MCORE
: return "MCORE";
1873 case EM_ARM
: return "ARM";
1874 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1875 case EM_SH
: return "Renesas / SuperH SH";
1876 case EM_SPARCV9
: return "Sparc v9";
1877 case EM_TRICORE
: return "Siemens Tricore";
1878 case EM_ARC
: return "ARC";
1879 case EM_H8_300
: return "Renesas H8/300";
1880 case EM_H8_300H
: return "Renesas H8/300H";
1881 case EM_H8S
: return "Renesas H8S";
1882 case EM_H8_500
: return "Renesas H8/500";
1883 case EM_IA_64
: return "Intel IA-64";
1884 case EM_MIPS_X
: return "Stanford MIPS-X";
1885 case EM_COLDFIRE
: return "Motorola Coldfire";
1886 case EM_68HC12
: return "Motorola M68HC12";
1887 case EM_ALPHA
: return "Alpha";
1888 case EM_CYGNUS_D10V
:
1889 case EM_D10V
: return "d10v";
1890 case EM_CYGNUS_D30V
:
1891 case EM_D30V
: return "d30v";
1892 case EM_CYGNUS_M32R
:
1893 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1894 case EM_CYGNUS_V850
:
1895 case EM_V850
: return "NEC v850";
1896 case EM_CYGNUS_MN10300
:
1897 case EM_MN10300
: return "mn10300";
1898 case EM_CYGNUS_MN10200
:
1899 case EM_MN10200
: return "mn10200";
1900 case EM_CYGNUS_FR30
:
1901 case EM_FR30
: return "Fujitsu FR30";
1902 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1904 case EM_PJ
: return "picoJava";
1905 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1906 case EM_PCP
: return "Siemens PCP";
1907 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1908 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1909 case EM_STARCORE
: return "Motorola Star*Core processor";
1910 case EM_ME16
: return "Toyota ME16 processor";
1911 case EM_ST100
: return "STMicroelectronics ST100 processor";
1912 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1913 case EM_PDSP
: return "Sony DSP processor";
1914 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
1915 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
1916 case EM_FX66
: return "Siemens FX66 microcontroller";
1917 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1918 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1919 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1920 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1921 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1922 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1923 case EM_SVX
: return "Silicon Graphics SVx";
1924 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1925 case EM_VAX
: return "Digital VAX";
1927 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1928 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1929 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1930 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1931 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1932 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1933 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1934 case EM_PRISM
: return "Vitesse Prism";
1935 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1936 case EM_L1OM
: return "Intel L1OM";
1938 case EM_S390
: return "IBM S/390";
1939 case EM_SCORE
: return "SUNPLUS S+Core";
1940 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1942 case EM_OR32
: return "OpenRISC";
1943 case EM_ARC_A5
: return "ARC International ARCompact processor";
1944 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1945 case EM_DLX
: return "OpenDLX";
1947 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1948 case EM_IQ2000
: return "Vitesse IQ2000";
1950 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1951 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
1952 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
1953 case EM_NS32K
: return "National Semiconductor 32000 series";
1954 case EM_TPC
: return "Tenor Network TPC processor";
1955 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
1956 case EM_MAX
: return "MAX Processor";
1957 case EM_CR
: return "National Semiconductor CompactRISC";
1958 case EM_F2MC16
: return "Fujitsu F2MC16";
1959 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
1960 case EM_LATTICEMICO32
: return "Lattice Mico32";
1962 case EM_M32C
: return "Renesas M32c";
1963 case EM_MT
: return "Morpho Techologies MT processor";
1964 case EM_BLACKFIN
: return "Analog Devices Blackfin";
1965 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
1966 case EM_SEP
: return "Sharp embedded microprocessor";
1967 case EM_ARCA
: return "Arca RISC microprocessor";
1968 case EM_UNICORE
: return "Unicore";
1969 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
1970 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
1971 case EM_NIOS32
: return "Altera Nios";
1972 case EM_ALTERA_NIOS2
: return "Altera Nios II";
1974 case EM_XC16X
: return "Infineon Technologies xc16x";
1975 case EM_M16C
: return "Renesas M16C series microprocessors";
1976 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
1977 case EM_CE
: return "Freescale Communication Engine RISC core";
1978 case EM_TSK3000
: return "Altium TSK3000 core";
1979 case EM_RS08
: return "Freescale RS08 embedded processor";
1980 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
1981 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
1982 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
1983 case EM_SE_C17
: return "Seiko Epson C17 family";
1984 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
1985 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
1986 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
1987 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
1988 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
1989 case EM_R32C
: return "Renesas R32C series microprocessors";
1990 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
1991 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
1992 case EM_8051
: return "Intel 8051 and variants";
1993 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
1994 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
1995 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
1996 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
1997 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
1998 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
1999 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2000 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2002 case EM_CR16_OLD
: return "National Semiconductor's CR16";
2003 case EM_MICROBLAZE
: return "Xilinx MicroBlaze";
2004 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2005 case EM_RX
: return "Renesas RX";
2006 case EM_METAG
: return "Imagination Technologies META processor architecture";
2007 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2008 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2009 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2010 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2011 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
2012 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2013 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2014 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2015 case EM_CUDA
: return "NVIDIA CUDA architecture";
2017 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2023 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2028 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2029 e_flags
&= ~ EF_ARM_EABIMASK
;
2031 /* Handle "generic" ARM flags. */
2032 if (e_flags
& EF_ARM_RELEXEC
)
2034 strcat (buf
, ", relocatable executable");
2035 e_flags
&= ~ EF_ARM_RELEXEC
;
2038 if (e_flags
& EF_ARM_HASENTRY
)
2040 strcat (buf
, ", has entry point");
2041 e_flags
&= ~ EF_ARM_HASENTRY
;
2044 /* Now handle EABI specific flags. */
2048 strcat (buf
, ", <unrecognized EABI>");
2053 case EF_ARM_EABI_VER1
:
2054 strcat (buf
, ", Version1 EABI");
2059 /* Process flags one bit at a time. */
2060 flag
= e_flags
& - e_flags
;
2065 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2066 strcat (buf
, ", sorted symbol tables");
2076 case EF_ARM_EABI_VER2
:
2077 strcat (buf
, ", Version2 EABI");
2082 /* Process flags one bit at a time. */
2083 flag
= e_flags
& - e_flags
;
2088 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2089 strcat (buf
, ", sorted symbol tables");
2092 case EF_ARM_DYNSYMSUSESEGIDX
:
2093 strcat (buf
, ", dynamic symbols use segment index");
2096 case EF_ARM_MAPSYMSFIRST
:
2097 strcat (buf
, ", mapping symbols precede others");
2107 case EF_ARM_EABI_VER3
:
2108 strcat (buf
, ", Version3 EABI");
2111 case EF_ARM_EABI_VER4
:
2112 strcat (buf
, ", Version4 EABI");
2115 case EF_ARM_EABI_VER5
:
2116 strcat (buf
, ", Version5 EABI");
2122 /* Process flags one bit at a time. */
2123 flag
= e_flags
& - e_flags
;
2129 strcat (buf
, ", BE8");
2133 strcat (buf
, ", LE8");
2143 case EF_ARM_EABI_UNKNOWN
:
2144 strcat (buf
, ", GNU EABI");
2149 /* Process flags one bit at a time. */
2150 flag
= e_flags
& - e_flags
;
2155 case EF_ARM_INTERWORK
:
2156 strcat (buf
, ", interworking enabled");
2159 case EF_ARM_APCS_26
:
2160 strcat (buf
, ", uses APCS/26");
2163 case EF_ARM_APCS_FLOAT
:
2164 strcat (buf
, ", uses APCS/float");
2168 strcat (buf
, ", position independent");
2172 strcat (buf
, ", 8 bit structure alignment");
2175 case EF_ARM_NEW_ABI
:
2176 strcat (buf
, ", uses new ABI");
2179 case EF_ARM_OLD_ABI
:
2180 strcat (buf
, ", uses old ABI");
2183 case EF_ARM_SOFT_FLOAT
:
2184 strcat (buf
, ", software FP");
2187 case EF_ARM_VFP_FLOAT
:
2188 strcat (buf
, ", VFP");
2191 case EF_ARM_MAVERICK_FLOAT
:
2192 strcat (buf
, ", Maverick FP");
2203 strcat (buf
,_(", <unknown>"));
2207 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2209 static char buf
[1024];
2221 decode_ARM_machine_flags (e_flags
, buf
);
2225 switch (e_flags
& EF_FRV_CPU_MASK
)
2227 case EF_FRV_CPU_GENERIC
:
2231 strcat (buf
, ", fr???");
2234 case EF_FRV_CPU_FR300
:
2235 strcat (buf
, ", fr300");
2238 case EF_FRV_CPU_FR400
:
2239 strcat (buf
, ", fr400");
2241 case EF_FRV_CPU_FR405
:
2242 strcat (buf
, ", fr405");
2245 case EF_FRV_CPU_FR450
:
2246 strcat (buf
, ", fr450");
2249 case EF_FRV_CPU_FR500
:
2250 strcat (buf
, ", fr500");
2252 case EF_FRV_CPU_FR550
:
2253 strcat (buf
, ", fr550");
2256 case EF_FRV_CPU_SIMPLE
:
2257 strcat (buf
, ", simple");
2259 case EF_FRV_CPU_TOMCAT
:
2260 strcat (buf
, ", tomcat");
2266 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2267 strcat (buf
, ", m68000");
2268 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2269 strcat (buf
, ", cpu32");
2270 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2271 strcat (buf
, ", fido_a");
2274 char const * isa
= _("unknown");
2275 char const * mac
= _("unknown mac");
2276 char const * additional
= NULL
;
2278 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2280 case EF_M68K_CF_ISA_A_NODIV
:
2282 additional
= ", nodiv";
2284 case EF_M68K_CF_ISA_A
:
2287 case EF_M68K_CF_ISA_A_PLUS
:
2290 case EF_M68K_CF_ISA_B_NOUSP
:
2292 additional
= ", nousp";
2294 case EF_M68K_CF_ISA_B
:
2298 strcat (buf
, ", cf, isa ");
2301 strcat (buf
, additional
);
2302 if (e_flags
& EF_M68K_CF_FLOAT
)
2303 strcat (buf
, ", float");
2304 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2309 case EF_M68K_CF_MAC
:
2312 case EF_M68K_CF_EMAC
:
2325 if (e_flags
& EF_PPC_EMB
)
2326 strcat (buf
, ", emb");
2328 if (e_flags
& EF_PPC_RELOCATABLE
)
2329 strcat (buf
, _(", relocatable"));
2331 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2332 strcat (buf
, _(", relocatable-lib"));
2336 case EM_CYGNUS_V850
:
2337 switch (e_flags
& EF_V850_ARCH
)
2340 strcat (buf
, ", v850e1");
2343 strcat (buf
, ", v850e");
2346 strcat (buf
, ", v850");
2349 strcat (buf
, _(", unknown v850 architecture variant"));
2355 case EM_CYGNUS_M32R
:
2356 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2357 strcat (buf
, ", m32r");
2361 case EM_MIPS_RS3_LE
:
2362 if (e_flags
& EF_MIPS_NOREORDER
)
2363 strcat (buf
, ", noreorder");
2365 if (e_flags
& EF_MIPS_PIC
)
2366 strcat (buf
, ", pic");
2368 if (e_flags
& EF_MIPS_CPIC
)
2369 strcat (buf
, ", cpic");
2371 if (e_flags
& EF_MIPS_UCODE
)
2372 strcat (buf
, ", ugen_reserved");
2374 if (e_flags
& EF_MIPS_ABI2
)
2375 strcat (buf
, ", abi2");
2377 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2378 strcat (buf
, ", odk first");
2380 if (e_flags
& EF_MIPS_32BITMODE
)
2381 strcat (buf
, ", 32bitmode");
2383 switch ((e_flags
& EF_MIPS_MACH
))
2385 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2386 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2387 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2388 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2389 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2390 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2391 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2392 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2393 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2394 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2395 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2396 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2397 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2398 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
2399 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
2401 /* We simply ignore the field in this case to avoid confusion:
2402 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2405 default: strcat (buf
, _(", unknown CPU")); break;
2408 switch ((e_flags
& EF_MIPS_ABI
))
2410 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2411 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2412 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2413 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2415 /* We simply ignore the field in this case to avoid confusion:
2416 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2417 This means it is likely to be an o32 file, but not for
2420 default: strcat (buf
, _(", unknown ABI")); break;
2423 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2424 strcat (buf
, ", mdmx");
2426 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2427 strcat (buf
, ", mips16");
2429 switch ((e_flags
& EF_MIPS_ARCH
))
2431 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2432 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2433 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2434 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2435 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2436 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2437 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2438 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2439 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2440 default: strcat (buf
, _(", unknown ISA")); break;
2443 if (e_flags
& EF_SH_PIC
)
2444 strcat (buf
, ", pic");
2446 if (e_flags
& EF_SH_FDPIC
)
2447 strcat (buf
, ", fdpic");
2451 switch ((e_flags
& EF_SH_MACH_MASK
))
2453 case EF_SH1
: strcat (buf
, ", sh1"); break;
2454 case EF_SH2
: strcat (buf
, ", sh2"); break;
2455 case EF_SH3
: strcat (buf
, ", sh3"); break;
2456 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2457 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2458 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2459 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2460 case EF_SH4
: strcat (buf
, ", sh4"); break;
2461 case EF_SH5
: strcat (buf
, ", sh5"); break;
2462 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2463 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2464 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2465 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2466 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2467 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2468 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2469 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2470 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2471 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2472 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2473 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2474 default: strcat (buf
, _(", unknown ISA")); break;
2480 if (e_flags
& EF_SPARC_32PLUS
)
2481 strcat (buf
, ", v8+");
2483 if (e_flags
& EF_SPARC_SUN_US1
)
2484 strcat (buf
, ", ultrasparcI");
2486 if (e_flags
& EF_SPARC_SUN_US3
)
2487 strcat (buf
, ", ultrasparcIII");
2489 if (e_flags
& EF_SPARC_HAL_R1
)
2490 strcat (buf
, ", halr1");
2492 if (e_flags
& EF_SPARC_LEDATA
)
2493 strcat (buf
, ", ledata");
2495 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2496 strcat (buf
, ", tso");
2498 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2499 strcat (buf
, ", pso");
2501 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2502 strcat (buf
, ", rmo");
2506 switch (e_flags
& EF_PARISC_ARCH
)
2508 case EFA_PARISC_1_0
:
2509 strcpy (buf
, ", PA-RISC 1.0");
2511 case EFA_PARISC_1_1
:
2512 strcpy (buf
, ", PA-RISC 1.1");
2514 case EFA_PARISC_2_0
:
2515 strcpy (buf
, ", PA-RISC 2.0");
2520 if (e_flags
& EF_PARISC_TRAPNIL
)
2521 strcat (buf
, ", trapnil");
2522 if (e_flags
& EF_PARISC_EXT
)
2523 strcat (buf
, ", ext");
2524 if (e_flags
& EF_PARISC_LSB
)
2525 strcat (buf
, ", lsb");
2526 if (e_flags
& EF_PARISC_WIDE
)
2527 strcat (buf
, ", wide");
2528 if (e_flags
& EF_PARISC_NO_KABP
)
2529 strcat (buf
, ", no kabp");
2530 if (e_flags
& EF_PARISC_LAZYSWAP
)
2531 strcat (buf
, ", lazyswap");
2536 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2537 strcat (buf
, ", new calling convention");
2539 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2540 strcat (buf
, ", gnu calling convention");
2544 if ((e_flags
& EF_IA_64_ABI64
))
2545 strcat (buf
, ", 64-bit");
2547 strcat (buf
, ", 32-bit");
2548 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2549 strcat (buf
, ", reduced fp model");
2550 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2551 strcat (buf
, ", no function descriptors, constant gp");
2552 else if ((e_flags
& EF_IA_64_CONS_GP
))
2553 strcat (buf
, ", constant gp");
2554 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2555 strcat (buf
, ", absolute");
2559 if ((e_flags
& EF_VAX_NONPIC
))
2560 strcat (buf
, ", non-PIC");
2561 if ((e_flags
& EF_VAX_DFLOAT
))
2562 strcat (buf
, ", D-Float");
2563 if ((e_flags
& EF_VAX_GFLOAT
))
2564 strcat (buf
, ", G-Float");
2568 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
2569 strcat (buf
, ", 64-bit doubles");
2570 if (e_flags
& E_FLAG_RX_DSP
)
2571 strcat (buf
, ", dsp");
2574 if (e_flags
& EF_S390_HIGH_GPRS
)
2575 strcat (buf
, ", highgprs");
2578 if ((e_flags
& EF_C6000_REL
))
2579 strcat (buf
, ", relocatable module");
2587 get_osabi_name (unsigned int osabi
)
2589 static char buff
[32];
2593 case ELFOSABI_NONE
: return "UNIX - System V";
2594 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2595 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2596 case ELFOSABI_LINUX
: return "UNIX - Linux";
2597 case ELFOSABI_HURD
: return "GNU/Hurd";
2598 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2599 case ELFOSABI_AIX
: return "UNIX - AIX";
2600 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2601 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2602 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2603 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2604 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2605 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2606 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2607 case ELFOSABI_AROS
: return "AROS";
2608 case ELFOSABI_FENIXOS
: return "FenixOS";
2611 switch (elf_header
.e_machine
)
2616 case ELFOSABI_ARM
: return "ARM";
2626 case ELFOSABI_STANDALONE
: return _("Standalone App");
2635 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
2636 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
2645 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2651 get_arm_segment_type (unsigned long type
)
2665 get_mips_segment_type (unsigned long type
)
2669 case PT_MIPS_REGINFO
:
2671 case PT_MIPS_RTPROC
:
2673 case PT_MIPS_OPTIONS
:
2683 get_parisc_segment_type (unsigned long type
)
2687 case PT_HP_TLS
: return "HP_TLS";
2688 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2689 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2690 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2691 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2692 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2693 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2694 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2695 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2696 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2697 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2698 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2699 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2700 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2701 case PT_HP_STACK
: return "HP_STACK";
2702 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2703 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2704 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2705 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2714 get_ia64_segment_type (unsigned long type
)
2718 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2719 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2720 case PT_HP_TLS
: return "HP_TLS";
2721 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2722 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2723 case PT_IA_64_HP_STACK
: return "HP_STACK";
2732 get_tic6x_segment_type (unsigned long type
)
2736 case PT_C6000_PHATTR
: return "C6000_PHATTR";
2745 get_segment_type (unsigned long p_type
)
2747 static char buff
[32];
2751 case PT_NULL
: return "NULL";
2752 case PT_LOAD
: return "LOAD";
2753 case PT_DYNAMIC
: return "DYNAMIC";
2754 case PT_INTERP
: return "INTERP";
2755 case PT_NOTE
: return "NOTE";
2756 case PT_SHLIB
: return "SHLIB";
2757 case PT_PHDR
: return "PHDR";
2758 case PT_TLS
: return "TLS";
2760 case PT_GNU_EH_FRAME
:
2761 return "GNU_EH_FRAME";
2762 case PT_GNU_STACK
: return "GNU_STACK";
2763 case PT_GNU_RELRO
: return "GNU_RELRO";
2766 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2768 const char * result
;
2770 switch (elf_header
.e_machine
)
2773 result
= get_arm_segment_type (p_type
);
2776 case EM_MIPS_RS3_LE
:
2777 result
= get_mips_segment_type (p_type
);
2780 result
= get_parisc_segment_type (p_type
);
2783 result
= get_ia64_segment_type (p_type
);
2786 result
= get_tic6x_segment_type (p_type
);
2796 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2798 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2800 const char * result
;
2802 switch (elf_header
.e_machine
)
2805 result
= get_parisc_segment_type (p_type
);
2808 result
= get_ia64_segment_type (p_type
);
2818 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2821 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2828 get_mips_section_type_name (unsigned int sh_type
)
2832 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2833 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2834 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2835 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2836 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2837 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2838 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2839 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2840 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2841 case SHT_MIPS_RELD
: return "MIPS_RELD";
2842 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2843 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2844 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2845 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2846 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2847 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2848 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2849 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2850 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2851 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2852 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2853 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2854 case SHT_MIPS_LINE
: return "MIPS_LINE";
2855 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2856 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2857 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2858 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2859 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2860 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2861 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2862 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2863 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2864 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2865 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2866 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2867 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2868 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2869 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2870 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2878 get_parisc_section_type_name (unsigned int sh_type
)
2882 case SHT_PARISC_EXT
: return "PARISC_EXT";
2883 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2884 case SHT_PARISC_DOC
: return "PARISC_DOC";
2885 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2886 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2887 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2888 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2896 get_ia64_section_type_name (unsigned int sh_type
)
2898 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2899 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2900 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2904 case SHT_IA_64_EXT
: return "IA_64_EXT";
2905 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2906 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2907 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
2908 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
2909 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
2910 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
2911 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
2912 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
2913 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
2921 get_x86_64_section_type_name (unsigned int sh_type
)
2925 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2933 get_arm_section_type_name (unsigned int sh_type
)
2937 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
2938 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
2939 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
2940 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
2941 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
2949 get_tic6x_section_type_name (unsigned int sh_type
)
2953 case SHT_C6000_UNWIND
:
2954 return "C6000_UNWIND";
2955 case SHT_C6000_PREEMPTMAP
:
2956 return "C6000_PREEMPTMAP";
2957 case SHT_C6000_ATTRIBUTES
:
2958 return "C6000_ATTRIBUTES";
2963 case SHT_TI_HANDLER
:
2964 return "TI_HANDLER";
2965 case SHT_TI_INITINFO
:
2966 return "TI_INITINFO";
2967 case SHT_TI_PHATTRS
:
2968 return "TI_PHATTRS";
2976 get_section_type_name (unsigned int sh_type
)
2978 static char buff
[32];
2982 case SHT_NULL
: return "NULL";
2983 case SHT_PROGBITS
: return "PROGBITS";
2984 case SHT_SYMTAB
: return "SYMTAB";
2985 case SHT_STRTAB
: return "STRTAB";
2986 case SHT_RELA
: return "RELA";
2987 case SHT_HASH
: return "HASH";
2988 case SHT_DYNAMIC
: return "DYNAMIC";
2989 case SHT_NOTE
: return "NOTE";
2990 case SHT_NOBITS
: return "NOBITS";
2991 case SHT_REL
: return "REL";
2992 case SHT_SHLIB
: return "SHLIB";
2993 case SHT_DYNSYM
: return "DYNSYM";
2994 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2995 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2996 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2997 case SHT_GNU_HASH
: return "GNU_HASH";
2998 case SHT_GROUP
: return "GROUP";
2999 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
3000 case SHT_GNU_verdef
: return "VERDEF";
3001 case SHT_GNU_verneed
: return "VERNEED";
3002 case SHT_GNU_versym
: return "VERSYM";
3003 case 0x6ffffff0: return "VERSYM";
3004 case 0x6ffffffc: return "VERDEF";
3005 case 0x7ffffffd: return "AUXILIARY";
3006 case 0x7fffffff: return "FILTER";
3007 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
3010 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
3012 const char * result
;
3014 switch (elf_header
.e_machine
)
3017 case EM_MIPS_RS3_LE
:
3018 result
= get_mips_section_type_name (sh_type
);
3021 result
= get_parisc_section_type_name (sh_type
);
3024 result
= get_ia64_section_type_name (sh_type
);
3028 result
= get_x86_64_section_type_name (sh_type
);
3031 result
= get_arm_section_type_name (sh_type
);
3034 result
= get_tic6x_section_type_name (sh_type
);
3044 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
3046 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
3048 const char * result
;
3050 switch (elf_header
.e_machine
)
3053 result
= get_ia64_section_type_name (sh_type
);
3063 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
3065 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
3066 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
3068 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
3074 #define OPTION_DEBUG_DUMP 512
3075 #define OPTION_DYN_SYMS 513
3077 static struct option options
[] =
3079 {"all", no_argument
, 0, 'a'},
3080 {"file-header", no_argument
, 0, 'h'},
3081 {"program-headers", no_argument
, 0, 'l'},
3082 {"headers", no_argument
, 0, 'e'},
3083 {"histogram", no_argument
, 0, 'I'},
3084 {"segments", no_argument
, 0, 'l'},
3085 {"sections", no_argument
, 0, 'S'},
3086 {"section-headers", no_argument
, 0, 'S'},
3087 {"section-groups", no_argument
, 0, 'g'},
3088 {"section-details", no_argument
, 0, 't'},
3089 {"full-section-name",no_argument
, 0, 'N'},
3090 {"symbols", no_argument
, 0, 's'},
3091 {"syms", no_argument
, 0, 's'},
3092 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
3093 {"relocs", no_argument
, 0, 'r'},
3094 {"notes", no_argument
, 0, 'n'},
3095 {"dynamic", no_argument
, 0, 'd'},
3096 {"arch-specific", no_argument
, 0, 'A'},
3097 {"version-info", no_argument
, 0, 'V'},
3098 {"use-dynamic", no_argument
, 0, 'D'},
3099 {"unwind", no_argument
, 0, 'u'},
3100 {"archive-index", no_argument
, 0, 'c'},
3101 {"hex-dump", required_argument
, 0, 'x'},
3102 {"relocated-dump", required_argument
, 0, 'R'},
3103 {"string-dump", required_argument
, 0, 'p'},
3104 #ifdef SUPPORT_DISASSEMBLY
3105 {"instruction-dump", required_argument
, 0, 'i'},
3107 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
3109 {"version", no_argument
, 0, 'v'},
3110 {"wide", no_argument
, 0, 'W'},
3111 {"help", no_argument
, 0, 'H'},
3112 {0, no_argument
, 0, 0}
3116 usage (FILE * stream
)
3118 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
3119 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
3120 fprintf (stream
, _(" Options are:\n\
3121 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3122 -h --file-header Display the ELF file header\n\
3123 -l --program-headers Display the program headers\n\
3124 --segments An alias for --program-headers\n\
3125 -S --section-headers Display the sections' header\n\
3126 --sections An alias for --section-headers\n\
3127 -g --section-groups Display the section groups\n\
3128 -t --section-details Display the section details\n\
3129 -e --headers Equivalent to: -h -l -S\n\
3130 -s --syms Display the symbol table\n\
3131 --symbols An alias for --syms\n\
3132 --dyn-syms Display the dynamic symbol table\n\
3133 -n --notes Display the core notes (if present)\n\
3134 -r --relocs Display the relocations (if present)\n\
3135 -u --unwind Display the unwind info (if present)\n\
3136 -d --dynamic Display the dynamic section (if present)\n\
3137 -V --version-info Display the version sections (if present)\n\
3138 -A --arch-specific Display architecture specific information (if any).\n\
3139 -c --archive-index Display the symbol/file index in an archive\n\
3140 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3141 -x --hex-dump=<number|name>\n\
3142 Dump the contents of section <number|name> as bytes\n\
3143 -p --string-dump=<number|name>\n\
3144 Dump the contents of section <number|name> as strings\n\
3145 -R --relocated-dump=<number|name>\n\
3146 Dump the contents of section <number|name> as relocated bytes\n\
3147 -w[lLiaprmfFsoRt] or\n\
3148 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3149 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3150 =trace_info,=trace_abbrev,=trace_aranges]\n\
3151 Display the contents of DWARF2 debug sections\n"));
3152 #ifdef SUPPORT_DISASSEMBLY
3153 fprintf (stream
, _("\
3154 -i --instruction-dump=<number|name>\n\
3155 Disassemble the contents of section <number|name>\n"));
3157 fprintf (stream
, _("\
3158 -I --histogram Display histogram of bucket list lengths\n\
3159 -W --wide Allow output width to exceed 80 characters\n\
3160 @<file> Read options from <file>\n\
3161 -H --help Display this information\n\
3162 -v --version Display the version number of readelf\n"));
3164 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3165 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
3167 exit (stream
== stdout
? 0 : 1);
3170 /* Record the fact that the user wants the contents of section number
3171 SECTION to be displayed using the method(s) encoded as flags bits
3172 in TYPE. Note, TYPE can be zero if we are creating the array for
3176 request_dump_bynumber (unsigned int section
, dump_type type
)
3178 if (section
>= num_dump_sects
)
3180 dump_type
* new_dump_sects
;
3182 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
3183 sizeof (* dump_sects
));
3185 if (new_dump_sects
== NULL
)
3186 error (_("Out of memory allocating dump request table.\n"));
3189 /* Copy current flag settings. */
3190 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
3194 dump_sects
= new_dump_sects
;
3195 num_dump_sects
= section
+ 1;
3200 dump_sects
[section
] |= type
;
3205 /* Request a dump by section name. */
3208 request_dump_byname (const char * section
, dump_type type
)
3210 struct dump_list_entry
* new_request
;
3212 new_request
= (struct dump_list_entry
*)
3213 malloc (sizeof (struct dump_list_entry
));
3215 error (_("Out of memory allocating dump request table.\n"));
3217 new_request
->name
= strdup (section
);
3218 if (!new_request
->name
)
3219 error (_("Out of memory allocating dump request table.\n"));
3221 new_request
->type
= type
;
3223 new_request
->next
= dump_sects_byname
;
3224 dump_sects_byname
= new_request
;
3228 request_dump (dump_type type
)
3234 section
= strtoul (optarg
, & cp
, 0);
3236 if (! *cp
&& section
>= 0)
3237 request_dump_bynumber (section
, type
);
3239 request_dump_byname (optarg
, type
);
3244 parse_args (int argc
, char ** argv
)
3251 while ((c
= getopt_long
3252 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
3270 do_section_groups
++;
3278 do_section_groups
++;
3283 do_section_details
++;
3327 request_dump (HEX_DUMP
);
3330 request_dump (STRING_DUMP
);
3333 request_dump (RELOC_DUMP
);
3340 dwarf_select_sections_all ();
3345 dwarf_select_sections_by_letters (optarg
);
3348 case OPTION_DEBUG_DUMP
:
3355 dwarf_select_sections_by_names (optarg
);
3358 case OPTION_DYN_SYMS
:
3361 #ifdef SUPPORT_DISASSEMBLY
3363 request_dump (DISASS_DUMP
);
3367 print_version (program_name
);
3376 /* xgettext:c-format */
3377 error (_("Invalid option '-%c'\n"), c
);
3384 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3385 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3386 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3387 && !do_section_groups
&& !do_archive_index
3392 warn (_("Nothing to do.\n"));
3398 get_elf_class (unsigned int elf_class
)
3400 static char buff
[32];
3404 case ELFCLASSNONE
: return _("none");
3405 case ELFCLASS32
: return "ELF32";
3406 case ELFCLASS64
: return "ELF64";
3408 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3414 get_data_encoding (unsigned int encoding
)
3416 static char buff
[32];
3420 case ELFDATANONE
: return _("none");
3421 case ELFDATA2LSB
: return _("2's complement, little endian");
3422 case ELFDATA2MSB
: return _("2's complement, big endian");
3424 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3429 /* Decode the data held in 'elf_header'. */
3432 process_file_header (void)
3434 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3435 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3436 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3437 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3440 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3444 init_dwarf_regnames (elf_header
.e_machine
);
3450 printf (_("ELF Header:\n"));
3451 printf (_(" Magic: "));
3452 for (i
= 0; i
< EI_NIDENT
; i
++)
3453 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3455 printf (_(" Class: %s\n"),
3456 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3457 printf (_(" Data: %s\n"),
3458 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3459 printf (_(" Version: %d %s\n"),
3460 elf_header
.e_ident
[EI_VERSION
],
3461 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3463 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3464 ? _("<unknown: %lx>")
3466 printf (_(" OS/ABI: %s\n"),
3467 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3468 printf (_(" ABI Version: %d\n"),
3469 elf_header
.e_ident
[EI_ABIVERSION
]);
3470 printf (_(" Type: %s\n"),
3471 get_file_type (elf_header
.e_type
));
3472 printf (_(" Machine: %s\n"),
3473 get_machine_name (elf_header
.e_machine
));
3474 printf (_(" Version: 0x%lx\n"),
3475 (unsigned long) elf_header
.e_version
);
3477 printf (_(" Entry point address: "));
3478 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3479 printf (_("\n Start of program headers: "));
3480 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3481 printf (_(" (bytes into file)\n Start of section headers: "));
3482 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3483 printf (_(" (bytes into file)\n"));
3485 printf (_(" Flags: 0x%lx%s\n"),
3486 (unsigned long) elf_header
.e_flags
,
3487 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3488 printf (_(" Size of this header: %ld (bytes)\n"),
3489 (long) elf_header
.e_ehsize
);
3490 printf (_(" Size of program headers: %ld (bytes)\n"),
3491 (long) elf_header
.e_phentsize
);
3492 printf (_(" Number of program headers: %ld"),
3493 (long) elf_header
.e_phnum
);
3494 if (section_headers
!= NULL
3495 && elf_header
.e_phnum
== PN_XNUM
3496 && section_headers
[0].sh_info
!= 0)
3497 printf (_(" (%ld)"), (long) section_headers
[0].sh_info
);
3498 putc ('\n', stdout
);
3499 printf (_(" Size of section headers: %ld (bytes)\n"),
3500 (long) elf_header
.e_shentsize
);
3501 printf (_(" Number of section headers: %ld"),
3502 (long) elf_header
.e_shnum
);
3503 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
3504 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3505 putc ('\n', stdout
);
3506 printf (_(" Section header string table index: %ld"),
3507 (long) elf_header
.e_shstrndx
);
3508 if (section_headers
!= NULL
3509 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3510 printf (" (%u)", section_headers
[0].sh_link
);
3511 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3512 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3513 printf (_(" <corrupt: out of range>"));
3514 putc ('\n', stdout
);
3517 if (section_headers
!= NULL
)
3519 if (elf_header
.e_phnum
== PN_XNUM
3520 && section_headers
[0].sh_info
!= 0)
3521 elf_header
.e_phnum
= section_headers
[0].sh_info
;
3522 if (elf_header
.e_shnum
== SHN_UNDEF
)
3523 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3524 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3525 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3526 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3527 elf_header
.e_shstrndx
= SHN_UNDEF
;
3528 free (section_headers
);
3529 section_headers
= NULL
;
3537 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3539 Elf32_External_Phdr
* phdrs
;
3540 Elf32_External_Phdr
* external
;
3541 Elf_Internal_Phdr
* internal
;
3544 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3545 elf_header
.e_phentsize
,
3547 _("program headers"));
3551 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3552 i
< elf_header
.e_phnum
;
3553 i
++, internal
++, external
++)
3555 internal
->p_type
= BYTE_GET (external
->p_type
);
3556 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3557 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3558 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3559 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3560 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3561 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3562 internal
->p_align
= BYTE_GET (external
->p_align
);
3571 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3573 Elf64_External_Phdr
* phdrs
;
3574 Elf64_External_Phdr
* external
;
3575 Elf_Internal_Phdr
* internal
;
3578 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3579 elf_header
.e_phentsize
,
3581 _("program headers"));
3585 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3586 i
< elf_header
.e_phnum
;
3587 i
++, internal
++, external
++)
3589 internal
->p_type
= BYTE_GET (external
->p_type
);
3590 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3591 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3592 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3593 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3594 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3595 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3596 internal
->p_align
= BYTE_GET (external
->p_align
);
3604 /* Returns 1 if the program headers were read into `program_headers'. */
3607 get_program_headers (FILE * file
)
3609 Elf_Internal_Phdr
* phdrs
;
3611 /* Check cache of prior read. */
3612 if (program_headers
!= NULL
)
3615 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
3616 sizeof (Elf_Internal_Phdr
));
3620 error (_("Out of memory\n"));
3625 ? get_32bit_program_headers (file
, phdrs
)
3626 : get_64bit_program_headers (file
, phdrs
))
3628 program_headers
= phdrs
;
3636 /* Returns 1 if the program headers were loaded. */
3639 process_program_headers (FILE * file
)
3641 Elf_Internal_Phdr
* segment
;
3644 if (elf_header
.e_phnum
== 0)
3647 printf (_("\nThere are no program headers in this file.\n"));
3651 if (do_segments
&& !do_header
)
3653 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3654 printf (_("Entry point "));
3655 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3656 printf (_("\nThere are %d program headers, starting at offset "),
3657 elf_header
.e_phnum
);
3658 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3662 if (! get_program_headers (file
))
3667 if (elf_header
.e_phnum
> 1)
3668 printf (_("\nProgram Headers:\n"));
3670 printf (_("\nProgram Headers:\n"));
3674 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3677 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3681 (_(" Type Offset VirtAddr PhysAddr\n"));
3683 (_(" FileSiz MemSiz Flags Align\n"));
3690 for (i
= 0, segment
= program_headers
;
3691 i
< elf_header
.e_phnum
;
3696 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3700 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3701 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3702 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3703 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3704 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3706 (segment
->p_flags
& PF_R
? 'R' : ' '),
3707 (segment
->p_flags
& PF_W
? 'W' : ' '),
3708 (segment
->p_flags
& PF_X
? 'E' : ' '));
3709 printf ("%#lx", (unsigned long) segment
->p_align
);
3713 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3714 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3717 print_vma (segment
->p_offset
, FULL_HEX
);
3721 print_vma (segment
->p_vaddr
, FULL_HEX
);
3723 print_vma (segment
->p_paddr
, FULL_HEX
);
3726 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3727 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3730 print_vma (segment
->p_filesz
, FULL_HEX
);
3734 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3735 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3738 print_vma (segment
->p_offset
, FULL_HEX
);
3742 (segment
->p_flags
& PF_R
? 'R' : ' '),
3743 (segment
->p_flags
& PF_W
? 'W' : ' '),
3744 (segment
->p_flags
& PF_X
? 'E' : ' '));
3746 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3747 printf ("%#lx", (unsigned long) segment
->p_align
);
3750 print_vma (segment
->p_align
, PREFIX_HEX
);
3755 print_vma (segment
->p_offset
, FULL_HEX
);
3757 print_vma (segment
->p_vaddr
, FULL_HEX
);
3759 print_vma (segment
->p_paddr
, FULL_HEX
);
3761 print_vma (segment
->p_filesz
, FULL_HEX
);
3763 print_vma (segment
->p_memsz
, FULL_HEX
);
3765 (segment
->p_flags
& PF_R
? 'R' : ' '),
3766 (segment
->p_flags
& PF_W
? 'W' : ' '),
3767 (segment
->p_flags
& PF_X
? 'E' : ' '));
3768 print_vma (segment
->p_align
, HEX
);
3772 switch (segment
->p_type
)
3776 error (_("more than one dynamic segment\n"));
3778 /* By default, assume that the .dynamic section is the first
3779 section in the DYNAMIC segment. */
3780 dynamic_addr
= segment
->p_offset
;
3781 dynamic_size
= segment
->p_filesz
;
3783 /* Try to locate the .dynamic section. If there is
3784 a section header table, we can easily locate it. */
3785 if (section_headers
!= NULL
)
3787 Elf_Internal_Shdr
* sec
;
3789 sec
= find_section (".dynamic");
3790 if (sec
== NULL
|| sec
->sh_size
== 0)
3792 error (_("no .dynamic section in the dynamic segment\n"));
3796 if (sec
->sh_type
== SHT_NOBITS
)
3802 dynamic_addr
= sec
->sh_offset
;
3803 dynamic_size
= sec
->sh_size
;
3805 if (dynamic_addr
< segment
->p_offset
3806 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3807 warn (_("the .dynamic section is not contained"
3808 " within the dynamic segment\n"));
3809 else if (dynamic_addr
> segment
->p_offset
)
3810 warn (_("the .dynamic section is not the first section"
3811 " in the dynamic segment.\n"));
3816 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3818 error (_("Unable to find program interpreter name\n"));
3822 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
3824 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
3825 error (_("Internal error: failed to create format string to display program interpreter\n"));
3827 program_interpreter
[0] = 0;
3828 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
3829 error (_("Unable to read program interpreter name\n"));
3832 printf (_("\n [Requesting program interpreter: %s]"),
3833 program_interpreter
);
3839 putc ('\n', stdout
);
3842 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3844 printf (_("\n Section to Segment mapping:\n"));
3845 printf (_(" Segment Sections...\n"));
3847 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3850 Elf_Internal_Shdr
* section
;
3852 segment
= program_headers
+ i
;
3853 section
= section_headers
+ 1;
3855 printf (" %2.2d ", i
);
3857 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3859 if (ELF_SECTION_SIZE (section
, segment
) != 0
3860 && ELF_SECTION_IN_SEGMENT (section
, segment
))
3861 printf ("%s ", SECTION_NAME (section
));
3872 /* Find the file offset corresponding to VMA by using the program headers. */
3875 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
3877 Elf_Internal_Phdr
* seg
;
3879 if (! get_program_headers (file
))
3881 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3885 for (seg
= program_headers
;
3886 seg
< program_headers
+ elf_header
.e_phnum
;
3889 if (seg
->p_type
!= PT_LOAD
)
3892 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3893 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3894 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3897 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3898 (unsigned long) vma
);
3904 get_32bit_section_headers (FILE * file
, unsigned int num
)
3906 Elf32_External_Shdr
* shdrs
;
3907 Elf_Internal_Shdr
* internal
;
3910 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
3911 elf_header
.e_shentsize
, num
,
3912 _("section headers"));
3916 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
3917 sizeof (Elf_Internal_Shdr
));
3919 if (section_headers
== NULL
)
3921 error (_("Out of memory\n"));
3925 for (i
= 0, internal
= section_headers
;
3929 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3930 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3931 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3932 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3933 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3934 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3935 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3936 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3937 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3938 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3947 get_64bit_section_headers (FILE * file
, unsigned int num
)
3949 Elf64_External_Shdr
* shdrs
;
3950 Elf_Internal_Shdr
* internal
;
3953 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
3954 elf_header
.e_shentsize
, num
,
3955 _("section headers"));
3959 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
3960 sizeof (Elf_Internal_Shdr
));
3962 if (section_headers
== NULL
)
3964 error (_("Out of memory\n"));
3968 for (i
= 0, internal
= section_headers
;
3972 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3973 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3974 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3975 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3976 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3977 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3978 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3979 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3980 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3981 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3989 static Elf_Internal_Sym
*
3990 get_32bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
3992 unsigned long number
;
3993 Elf32_External_Sym
* esyms
;
3994 Elf_External_Sym_Shndx
* shndx
;
3995 Elf_Internal_Sym
* isyms
;
3996 Elf_Internal_Sym
* psym
;
3999 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4000 section
->sh_size
, _("symbols"));
4005 if (symtab_shndx_hdr
!= NULL
4006 && (symtab_shndx_hdr
->sh_link
4007 == (unsigned long) (section
- section_headers
)))
4009 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4010 symtab_shndx_hdr
->sh_offset
,
4011 1, symtab_shndx_hdr
->sh_size
,
4020 number
= section
->sh_size
/ section
->sh_entsize
;
4021 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4025 error (_("Out of memory\n"));
4032 for (j
= 0, psym
= isyms
;
4036 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4037 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4038 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4039 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4040 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4042 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4043 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4044 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4045 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4046 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4056 static Elf_Internal_Sym
*
4057 get_64bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
4059 unsigned long number
;
4060 Elf64_External_Sym
* esyms
;
4061 Elf_External_Sym_Shndx
* shndx
;
4062 Elf_Internal_Sym
* isyms
;
4063 Elf_Internal_Sym
* psym
;
4066 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4067 section
->sh_size
, _("symbols"));
4072 if (symtab_shndx_hdr
!= NULL
4073 && (symtab_shndx_hdr
->sh_link
4074 == (unsigned long) (section
- section_headers
)))
4076 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4077 symtab_shndx_hdr
->sh_offset
,
4078 1, symtab_shndx_hdr
->sh_size
,
4087 number
= section
->sh_size
/ section
->sh_entsize
;
4088 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4092 error (_("Out of memory\n"));
4099 for (j
= 0, psym
= isyms
;
4103 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4104 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4105 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4106 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4107 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4109 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4110 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4111 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4112 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4113 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4124 get_elf_section_flags (bfd_vma sh_flags
)
4126 static char buff
[1024];
4128 int field_size
= is_32bit_elf
? 8 : 16;
4130 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
4131 bfd_vma os_flags
= 0;
4132 bfd_vma proc_flags
= 0;
4133 bfd_vma unknown_flags
= 0;
4141 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4142 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4143 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4144 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4145 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4146 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4147 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4148 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4149 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4150 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4151 /* IA-64 specific. */
4152 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4153 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4154 /* IA-64 OpenVMS specific. */
4155 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4156 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4157 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4158 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4159 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4160 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4162 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4163 /* SPARC specific. */
4164 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4167 if (do_section_details
)
4169 sprintf (buff
, "[%*.*lx]: ",
4170 field_size
, field_size
, (unsigned long) sh_flags
);
4171 p
+= field_size
+ 4;
4178 flag
= sh_flags
& - sh_flags
;
4181 if (do_section_details
)
4185 case SHF_WRITE
: sindex
= 0; break;
4186 case SHF_ALLOC
: sindex
= 1; break;
4187 case SHF_EXECINSTR
: sindex
= 2; break;
4188 case SHF_MERGE
: sindex
= 3; break;
4189 case SHF_STRINGS
: sindex
= 4; break;
4190 case SHF_INFO_LINK
: sindex
= 5; break;
4191 case SHF_LINK_ORDER
: sindex
= 6; break;
4192 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
4193 case SHF_GROUP
: sindex
= 8; break;
4194 case SHF_TLS
: sindex
= 9; break;
4195 case SHF_EXCLUDE
: sindex
= 18; break;
4199 switch (elf_header
.e_machine
)
4202 if (flag
== SHF_IA_64_SHORT
)
4204 else if (flag
== SHF_IA_64_NORECOV
)
4207 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
4210 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
4211 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
4212 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
4213 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
4214 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
4215 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
4225 case EM_OLD_SPARCV9
:
4226 case EM_SPARC32PLUS
:
4229 if (flag
== SHF_ORDERED
)
4239 if (p
!= buff
+ field_size
+ 4)
4241 if (size
< (10 + 2))
4248 size
-= flags
[sindex
].len
;
4249 p
= stpcpy (p
, flags
[sindex
].str
);
4251 else if (flag
& SHF_MASKOS
)
4253 else if (flag
& SHF_MASKPROC
)
4256 unknown_flags
|= flag
;
4262 case SHF_WRITE
: *p
= 'W'; break;
4263 case SHF_ALLOC
: *p
= 'A'; break;
4264 case SHF_EXECINSTR
: *p
= 'X'; break;
4265 case SHF_MERGE
: *p
= 'M'; break;
4266 case SHF_STRINGS
: *p
= 'S'; break;
4267 case SHF_INFO_LINK
: *p
= 'I'; break;
4268 case SHF_LINK_ORDER
: *p
= 'L'; break;
4269 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
4270 case SHF_GROUP
: *p
= 'G'; break;
4271 case SHF_TLS
: *p
= 'T'; break;
4272 case SHF_EXCLUDE
: *p
= 'E'; break;
4275 if ((elf_header
.e_machine
== EM_X86_64
4276 || elf_header
.e_machine
== EM_L1OM
)
4277 && flag
== SHF_X86_64_LARGE
)
4279 else if (flag
& SHF_MASKOS
)
4282 sh_flags
&= ~ SHF_MASKOS
;
4284 else if (flag
& SHF_MASKPROC
)
4287 sh_flags
&= ~ SHF_MASKPROC
;
4297 if (do_section_details
)
4301 size
-= 5 + field_size
;
4302 if (p
!= buff
+ field_size
+ 4)
4310 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4311 (unsigned long) os_flags
);
4312 p
+= 5 + field_size
;
4316 size
-= 7 + field_size
;
4317 if (p
!= buff
+ field_size
+ 4)
4325 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4326 (unsigned long) proc_flags
);
4327 p
+= 7 + field_size
;
4331 size
-= 10 + field_size
;
4332 if (p
!= buff
+ field_size
+ 4)
4340 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
4341 (unsigned long) unknown_flags
);
4342 p
+= 10 + field_size
;
4351 process_section_headers (FILE * file
)
4353 Elf_Internal_Shdr
* section
;
4356 section_headers
= NULL
;
4358 if (elf_header
.e_shnum
== 0)
4361 printf (_("\nThere are no sections in this file.\n"));
4366 if (do_sections
&& !do_header
)
4367 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4368 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4372 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4375 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4378 /* Read in the string table, so that we have names to display. */
4379 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4380 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4382 section
= section_headers
+ elf_header
.e_shstrndx
;
4384 if (section
->sh_size
!= 0)
4386 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4387 1, section
->sh_size
,
4390 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4394 /* Scan the sections for the dynamic symbol table
4395 and dynamic string table and debug sections. */
4396 dynamic_symbols
= NULL
;
4397 dynamic_strings
= NULL
;
4398 dynamic_syminfo
= NULL
;
4399 symtab_shndx_hdr
= NULL
;
4401 eh_addr_size
= is_32bit_elf
? 4 : 8;
4402 switch (elf_header
.e_machine
)
4405 case EM_MIPS_RS3_LE
:
4406 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4407 FDE addresses. However, the ABI also has a semi-official ILP32
4408 variant for which the normal FDE address size rules apply.
4410 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4411 section, where XX is the size of longs in bits. Unfortunately,
4412 earlier compilers provided no way of distinguishing ILP32 objects
4413 from LP64 objects, so if there's any doubt, we should assume that
4414 the official LP64 form is being used. */
4415 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4416 && find_section (".gcc_compiled_long32") == NULL
)
4422 switch (elf_header
.e_flags
& EF_H8_MACH
)
4424 case E_H8_MACH_H8300
:
4425 case E_H8_MACH_H8300HN
:
4426 case E_H8_MACH_H8300SN
:
4427 case E_H8_MACH_H8300SXN
:
4430 case E_H8_MACH_H8300H
:
4431 case E_H8_MACH_H8300S
:
4432 case E_H8_MACH_H8300SX
:
4440 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
4442 case EF_M32C_CPU_M16C
:
4449 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4452 size_t expected_entsize \
4453 = is_32bit_elf ? size32 : size64; \
4454 if (section->sh_entsize != expected_entsize) \
4455 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4456 i, (unsigned long int) section->sh_entsize, \
4457 (unsigned long int) expected_entsize); \
4458 section->sh_entsize = expected_entsize; \
4461 #define CHECK_ENTSIZE(section, i, type) \
4462 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4463 sizeof (Elf64_External_##type))
4465 for (i
= 0, section
= section_headers
;
4466 i
< elf_header
.e_shnum
;
4469 char * name
= SECTION_NAME (section
);
4471 if (section
->sh_type
== SHT_DYNSYM
)
4473 if (dynamic_symbols
!= NULL
)
4475 error (_("File contains multiple dynamic symbol tables\n"));
4479 CHECK_ENTSIZE (section
, i
, Sym
);
4480 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4481 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4483 else if (section
->sh_type
== SHT_STRTAB
4484 && streq (name
, ".dynstr"))
4486 if (dynamic_strings
!= NULL
)
4488 error (_("File contains multiple dynamic string tables\n"));
4492 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4493 1, section
->sh_size
,
4494 _("dynamic strings"));
4495 dynamic_strings_length
= section
->sh_size
;
4497 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4499 if (symtab_shndx_hdr
!= NULL
)
4501 error (_("File contains multiple symtab shndx tables\n"));
4504 symtab_shndx_hdr
= section
;
4506 else if (section
->sh_type
== SHT_SYMTAB
)
4507 CHECK_ENTSIZE (section
, i
, Sym
);
4508 else if (section
->sh_type
== SHT_GROUP
)
4509 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4510 else if (section
->sh_type
== SHT_REL
)
4511 CHECK_ENTSIZE (section
, i
, Rel
);
4512 else if (section
->sh_type
== SHT_RELA
)
4513 CHECK_ENTSIZE (section
, i
, Rela
);
4514 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4515 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
4516 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
4517 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
)
4518 && (const_strneq (name
, ".debug_")
4519 || const_strneq (name
, ".zdebug_")))
4522 name
+= sizeof (".zdebug_") - 1;
4524 name
+= sizeof (".debug_") - 1;
4527 || (do_debug_info
&& streq (name
, "info"))
4528 || (do_debug_info
&& streq (name
, "types"))
4529 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4530 || (do_debug_lines
&& streq (name
, "line"))
4531 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4532 || (do_debug_pubtypes
&& streq (name
, "pubtypes"))
4533 || (do_debug_aranges
&& streq (name
, "aranges"))
4534 || (do_debug_ranges
&& streq (name
, "ranges"))
4535 || (do_debug_frames
&& streq (name
, "frame"))
4536 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4537 || (do_debug_str
&& streq (name
, "str"))
4538 || (do_debug_loc
&& streq (name
, "loc"))
4540 request_dump_bynumber (i
, DEBUG_DUMP
);
4542 /* Linkonce section to be combined with .debug_info at link time. */
4543 else if ((do_debugging
|| do_debug_info
)
4544 && const_strneq (name
, ".gnu.linkonce.wi."))
4545 request_dump_bynumber (i
, DEBUG_DUMP
);
4546 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4547 request_dump_bynumber (i
, DEBUG_DUMP
);
4548 /* Trace sections for Itanium VMS. */
4549 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
4550 || do_trace_aranges
)
4551 && const_strneq (name
, ".trace_"))
4553 name
+= sizeof (".trace_") - 1;
4556 || (do_trace_info
&& streq (name
, "info"))
4557 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
4558 || (do_trace_aranges
&& streq (name
, "aranges"))
4560 request_dump_bynumber (i
, DEBUG_DUMP
);
4568 if (elf_header
.e_shnum
> 1)
4569 printf (_("\nSection Headers:\n"));
4571 printf (_("\nSection Header:\n"));
4575 if (do_section_details
)
4577 printf (_(" [Nr] Name\n"));
4578 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4582 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4586 if (do_section_details
)
4588 printf (_(" [Nr] Name\n"));
4589 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4593 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4597 if (do_section_details
)
4599 printf (_(" [Nr] Name\n"));
4600 printf (_(" Type Address Offset Link\n"));
4601 printf (_(" Size EntSize Info Align\n"));
4605 printf (_(" [Nr] Name Type Address Offset\n"));
4606 printf (_(" Size EntSize Flags Link Info Align\n"));
4610 if (do_section_details
)
4611 printf (_(" Flags\n"));
4613 for (i
= 0, section
= section_headers
;
4614 i
< elf_header
.e_shnum
;
4617 if (do_section_details
)
4619 printf (" [%2u] %s\n",
4621 SECTION_NAME (section
));
4622 if (is_32bit_elf
|| do_wide
)
4623 printf (" %-15.15s ",
4624 get_section_type_name (section
->sh_type
));
4627 printf ((do_wide
? " [%2u] %-17s %-15s "
4628 : " [%2u] %-17.17s %-15.15s "),
4630 SECTION_NAME (section
),
4631 get_section_type_name (section
->sh_type
));
4635 const char * link_too_big
= NULL
;
4637 print_vma (section
->sh_addr
, LONG_HEX
);
4639 printf ( " %6.6lx %6.6lx %2.2lx",
4640 (unsigned long) section
->sh_offset
,
4641 (unsigned long) section
->sh_size
,
4642 (unsigned long) section
->sh_entsize
);
4644 if (do_section_details
)
4645 fputs (" ", stdout
);
4647 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4649 if (section
->sh_link
>= elf_header
.e_shnum
)
4652 /* The sh_link value is out of range. Normally this indicates
4653 an error but it can have special values in Solaris binaries. */
4654 switch (elf_header
.e_machine
)
4660 case EM_OLD_SPARCV9
:
4661 case EM_SPARC32PLUS
:
4664 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
4665 link_too_big
= "BEFORE";
4666 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
4667 link_too_big
= "AFTER";
4674 if (do_section_details
)
4676 if (link_too_big
!= NULL
&& * link_too_big
)
4677 printf ("<%s> ", link_too_big
);
4679 printf ("%2u ", section
->sh_link
);
4680 printf ("%3u %2lu\n", section
->sh_info
,
4681 (unsigned long) section
->sh_addralign
);
4684 printf ("%2u %3u %2lu\n",
4687 (unsigned long) section
->sh_addralign
);
4689 if (link_too_big
&& ! * link_too_big
)
4690 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4691 i
, section
->sh_link
);
4695 print_vma (section
->sh_addr
, LONG_HEX
);
4697 if ((long) section
->sh_offset
== section
->sh_offset
)
4698 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4702 print_vma (section
->sh_offset
, LONG_HEX
);
4705 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4706 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4710 print_vma (section
->sh_size
, LONG_HEX
);
4713 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4714 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4718 print_vma (section
->sh_entsize
, LONG_HEX
);
4721 if (do_section_details
)
4722 fputs (" ", stdout
);
4724 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4726 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
4728 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4729 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
4732 print_vma (section
->sh_addralign
, DEC
);
4736 else if (do_section_details
)
4738 printf (" %-15.15s ",
4739 get_section_type_name (section
->sh_type
));
4740 print_vma (section
->sh_addr
, LONG_HEX
);
4741 if ((long) section
->sh_offset
== section
->sh_offset
)
4742 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4746 print_vma (section
->sh_offset
, LONG_HEX
);
4748 printf (" %u\n ", section
->sh_link
);
4749 print_vma (section
->sh_size
, LONG_HEX
);
4751 print_vma (section
->sh_entsize
, LONG_HEX
);
4753 printf (" %-16u %lu\n",
4755 (unsigned long) section
->sh_addralign
);
4760 print_vma (section
->sh_addr
, LONG_HEX
);
4761 if ((long) section
->sh_offset
== section
->sh_offset
)
4762 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4766 print_vma (section
->sh_offset
, LONG_HEX
);
4769 print_vma (section
->sh_size
, LONG_HEX
);
4771 print_vma (section
->sh_entsize
, LONG_HEX
);
4773 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4775 printf (" %2u %3u %lu\n",
4778 (unsigned long) section
->sh_addralign
);
4781 if (do_section_details
)
4782 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4785 if (!do_section_details
)
4786 printf (_("Key to Flags:\n\
4787 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4788 I (info), L (link order), G (group), x (unknown)\n\
4789 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4795 get_group_flags (unsigned int flags
)
4797 static char buff
[32];
4807 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
4814 process_section_groups (FILE * file
)
4816 Elf_Internal_Shdr
* section
;
4818 struct group
* group
;
4819 Elf_Internal_Shdr
* symtab_sec
;
4820 Elf_Internal_Shdr
* strtab_sec
;
4821 Elf_Internal_Sym
* symtab
;
4825 /* Don't process section groups unless needed. */
4826 if (!do_unwind
&& !do_section_groups
)
4829 if (elf_header
.e_shnum
== 0)
4831 if (do_section_groups
)
4832 printf (_("\nThere are no sections in this file.\n"));
4837 if (section_headers
== NULL
)
4839 error (_("Section headers are not available!\n"));
4843 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
4844 sizeof (struct group
*));
4846 if (section_headers_groups
== NULL
)
4848 error (_("Out of memory\n"));
4852 /* Scan the sections for the group section. */
4854 for (i
= 0, section
= section_headers
;
4855 i
< elf_header
.e_shnum
;
4857 if (section
->sh_type
== SHT_GROUP
)
4860 if (group_count
== 0)
4862 if (do_section_groups
)
4863 printf (_("\nThere are no section groups in this file.\n"));
4868 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
4870 if (section_groups
== NULL
)
4872 error (_("Out of memory\n"));
4881 for (i
= 0, section
= section_headers
, group
= section_groups
;
4882 i
< elf_header
.e_shnum
;
4885 if (section
->sh_type
== SHT_GROUP
)
4887 char * name
= SECTION_NAME (section
);
4889 unsigned char * start
;
4890 unsigned char * indices
;
4891 unsigned int entry
, j
, size
;
4892 Elf_Internal_Shdr
* sec
;
4893 Elf_Internal_Sym
* sym
;
4895 /* Get the symbol table. */
4896 if (section
->sh_link
>= elf_header
.e_shnum
4897 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
4900 error (_("Bad sh_link in group section `%s'\n"), name
);
4904 if (symtab_sec
!= sec
)
4909 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4912 sym
= symtab
+ section
->sh_info
;
4914 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4916 if (sym
->st_shndx
== 0
4917 || sym
->st_shndx
>= elf_header
.e_shnum
)
4919 error (_("Bad sh_info in group section `%s'\n"), name
);
4923 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
4932 /* Get the string table. */
4933 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
4942 != (sec
= section_headers
+ symtab_sec
->sh_link
))
4947 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
4948 1, strtab_sec
->sh_size
,
4950 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4952 group_name
= sym
->st_name
< strtab_size
4953 ? strtab
+ sym
->st_name
: _("<corrupt>");
4956 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
4957 1, section
->sh_size
,
4961 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4962 entry
= byte_get (indices
, 4);
4965 if (do_section_groups
)
4967 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
4968 get_group_flags (entry
), i
, name
, group_name
, size
);
4970 printf (_(" [Index] Name\n"));
4973 group
->group_index
= i
;
4975 for (j
= 0; j
< size
; j
++)
4977 struct group_list
* g
;
4979 entry
= byte_get (indices
, 4);
4982 if (entry
>= elf_header
.e_shnum
)
4984 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4985 entry
, i
, elf_header
.e_shnum
- 1);
4989 if (section_headers_groups
[entry
] != NULL
)
4993 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4995 section_headers_groups
[entry
]->group_index
);
5000 /* Intel C/C++ compiler may put section 0 in a
5001 section group. We just warn it the first time
5002 and ignore it afterwards. */
5003 static int warned
= 0;
5006 error (_("section 0 in group section [%5u]\n"),
5007 section_headers_groups
[entry
]->group_index
);
5013 section_headers_groups
[entry
] = group
;
5015 if (do_section_groups
)
5017 sec
= section_headers
+ entry
;
5018 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
5021 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
5022 g
->section_index
= entry
;
5023 g
->next
= group
->root
;
5047 } dynamic_relocations
[] =
5049 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
5050 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
5051 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
5054 /* Process the reloc section. */
5057 process_relocs (FILE * file
)
5059 unsigned long rel_size
;
5060 unsigned long rel_offset
;
5066 if (do_using_dynamic
)
5070 int has_dynamic_reloc
;
5073 has_dynamic_reloc
= 0;
5075 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
5077 is_rela
= dynamic_relocations
[i
].rela
;
5078 name
= dynamic_relocations
[i
].name
;
5079 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
5080 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
5082 has_dynamic_reloc
|= rel_size
;
5084 if (is_rela
== UNKNOWN
)
5086 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
5087 switch (dynamic_info
[DT_PLTREL
])
5101 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5102 name
, rel_offset
, rel_size
);
5104 dump_relocations (file
,
5105 offset_from_vma (file
, rel_offset
, rel_size
),
5107 dynamic_symbols
, num_dynamic_syms
,
5108 dynamic_strings
, dynamic_strings_length
, is_rela
);
5112 if (! has_dynamic_reloc
)
5113 printf (_("\nThere are no dynamic relocations in this file.\n"));
5117 Elf_Internal_Shdr
* section
;
5121 for (i
= 0, section
= section_headers
;
5122 i
< elf_header
.e_shnum
;
5125 if ( section
->sh_type
!= SHT_RELA
5126 && section
->sh_type
!= SHT_REL
)
5129 rel_offset
= section
->sh_offset
;
5130 rel_size
= section
->sh_size
;
5134 Elf_Internal_Shdr
* strsec
;
5137 printf (_("\nRelocation section "));
5139 if (string_table
== NULL
)
5140 printf ("%d", section
->sh_name
);
5142 printf (_("'%s'"), SECTION_NAME (section
));
5144 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5145 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
5147 is_rela
= section
->sh_type
== SHT_RELA
;
5149 if (section
->sh_link
!= 0
5150 && section
->sh_link
< elf_header
.e_shnum
)
5152 Elf_Internal_Shdr
* symsec
;
5153 Elf_Internal_Sym
* symtab
;
5154 unsigned long nsyms
;
5155 unsigned long strtablen
= 0;
5156 char * strtab
= NULL
;
5158 symsec
= section_headers
+ section
->sh_link
;
5159 if (symsec
->sh_type
!= SHT_SYMTAB
5160 && symsec
->sh_type
!= SHT_DYNSYM
)
5163 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
5164 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
5169 if (symsec
->sh_link
!= 0
5170 && symsec
->sh_link
< elf_header
.e_shnum
)
5172 strsec
= section_headers
+ symsec
->sh_link
;
5174 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5177 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
5180 dump_relocations (file
, rel_offset
, rel_size
,
5181 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
5187 dump_relocations (file
, rel_offset
, rel_size
,
5188 NULL
, 0, NULL
, 0, is_rela
);
5195 printf (_("\nThere are no relocations in this file.\n"));
5201 /* Process the unwind section. */
5203 #include "unwind-ia64.h"
5205 /* An absolute address consists of a section and an offset. If the
5206 section is NULL, the offset itself is the address, otherwise, the
5207 address equals to LOAD_ADDRESS(section) + offset. */
5211 unsigned short section
;
5215 #define ABSADDR(a) \
5217 ? section_headers [(a).section].sh_addr + (a).offset \
5220 struct ia64_unw_table_entry
5222 struct absaddr start
;
5224 struct absaddr info
;
5227 struct ia64_unw_aux_info
5230 struct ia64_unw_table_entry
*table
; /* Unwind table. */
5231 unsigned long table_len
; /* Length of unwind table. */
5232 unsigned char * info
; /* Unwind info. */
5233 unsigned long info_size
; /* Size of unwind info. */
5234 bfd_vma info_addr
; /* starting address of unwind info. */
5235 bfd_vma seg_base
; /* Starting address of segment. */
5236 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5237 unsigned long nsyms
; /* Number of symbols. */
5238 char * strtab
; /* The string table. */
5239 unsigned long strtab_size
; /* Size of string table. */
5243 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
5244 unsigned long nsyms
,
5245 const char * strtab
,
5246 unsigned long strtab_size
,
5247 struct absaddr addr
,
5248 const char ** symname
,
5251 bfd_vma dist
= 0x100000;
5252 Elf_Internal_Sym
* sym
;
5253 Elf_Internal_Sym
* best
= NULL
;
5256 REMOVE_ARCH_BITS (addr
.offset
);
5258 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
5260 bfd_vma value
= sym
->st_value
;
5262 REMOVE_ARCH_BITS (value
);
5264 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
5265 && sym
->st_name
!= 0
5266 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
5267 && addr
.offset
>= value
5268 && addr
.offset
- value
< dist
)
5271 dist
= addr
.offset
- value
;
5278 *symname
= (best
->st_name
>= strtab_size
5279 ? _("<corrupt>") : strtab
+ best
->st_name
);
5284 *offset
= addr
.offset
;
5288 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
5290 struct ia64_unw_table_entry
* tp
;
5293 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5297 const unsigned char * dp
;
5298 const unsigned char * head
;
5299 const char * procname
;
5301 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5302 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
5304 fputs ("\n<", stdout
);
5308 fputs (procname
, stdout
);
5311 printf ("+%lx", (unsigned long) offset
);
5314 fputs (">: [", stdout
);
5315 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5316 fputc ('-', stdout
);
5317 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5318 printf ("], info at +0x%lx\n",
5319 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
5321 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
5322 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
5324 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5325 (unsigned) UNW_VER (stamp
),
5326 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
5327 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
5328 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
5329 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
5331 if (UNW_VER (stamp
) != 1)
5333 printf (_("\tUnknown version.\n"));
5338 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
5339 dp
= unw_decode (dp
, in_body
, & in_body
);
5344 slurp_ia64_unwind_table (FILE * file
,
5345 struct ia64_unw_aux_info
* aux
,
5346 Elf_Internal_Shdr
* sec
)
5348 unsigned long size
, nrelas
, i
;
5349 Elf_Internal_Phdr
* seg
;
5350 struct ia64_unw_table_entry
* tep
;
5351 Elf_Internal_Shdr
* relsec
;
5352 Elf_Internal_Rela
* rela
;
5353 Elf_Internal_Rela
* rp
;
5354 unsigned char * table
;
5356 Elf_Internal_Sym
* sym
;
5357 const char * relname
;
5359 /* First, find the starting address of the segment that includes
5362 if (elf_header
.e_phnum
)
5364 if (! get_program_headers (file
))
5367 for (seg
= program_headers
;
5368 seg
< program_headers
+ elf_header
.e_phnum
;
5371 if (seg
->p_type
!= PT_LOAD
)
5374 if (sec
->sh_addr
>= seg
->p_vaddr
5375 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5377 aux
->seg_base
= seg
->p_vaddr
;
5383 /* Second, build the unwind table from the contents of the unwind section: */
5384 size
= sec
->sh_size
;
5385 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
5390 aux
->table
= (struct ia64_unw_table_entry
*)
5391 xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
5393 for (tp
= table
; tp
< table
+ size
; ++tep
)
5395 tep
->start
.section
= SHN_UNDEF
;
5396 tep
->end
.section
= SHN_UNDEF
;
5397 tep
->info
.section
= SHN_UNDEF
;
5398 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5399 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5400 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5401 tep
->start
.offset
+= aux
->seg_base
;
5402 tep
->end
.offset
+= aux
->seg_base
;
5403 tep
->info
.offset
+= aux
->seg_base
;
5407 /* Third, apply any relocations to the unwind table: */
5408 for (relsec
= section_headers
;
5409 relsec
< section_headers
+ elf_header
.e_shnum
;
5412 if (relsec
->sh_type
!= SHT_RELA
5413 || relsec
->sh_info
>= elf_header
.e_shnum
5414 || section_headers
+ relsec
->sh_info
!= sec
)
5417 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5421 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5423 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5424 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5426 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5428 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5432 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5434 switch (rp
->r_offset
/eh_addr_size
% 3)
5437 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5438 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
5441 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5442 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
5445 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5446 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
5456 aux
->table_len
= size
/ (3 * eh_addr_size
);
5461 ia64_process_unwind (FILE * file
)
5463 Elf_Internal_Shdr
* sec
;
5464 Elf_Internal_Shdr
* unwsec
= NULL
;
5465 Elf_Internal_Shdr
* strsec
;
5466 unsigned long i
, unwcount
= 0, unwstart
= 0;
5467 struct ia64_unw_aux_info aux
;
5469 memset (& aux
, 0, sizeof (aux
));
5471 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5473 if (sec
->sh_type
== SHT_SYMTAB
5474 && sec
->sh_link
< elf_header
.e_shnum
)
5476 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5477 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5479 strsec
= section_headers
+ sec
->sh_link
;
5480 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5483 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5485 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5490 printf (_("\nThere are no unwind sections in this file.\n"));
5492 while (unwcount
-- > 0)
5497 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5498 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5499 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5506 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5508 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5510 /* We need to find which section group it is in. */
5511 struct group_list
* g
= section_headers_groups
[i
]->root
;
5513 for (; g
!= NULL
; g
= g
->next
)
5515 sec
= section_headers
+ g
->section_index
;
5517 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5522 i
= elf_header
.e_shnum
;
5524 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5526 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5527 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5528 suffix
= SECTION_NAME (unwsec
) + len
;
5529 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5531 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5532 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5537 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5538 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5539 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5540 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5542 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5543 suffix
= SECTION_NAME (unwsec
) + len
;
5544 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5546 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5547 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5551 if (i
== elf_header
.e_shnum
)
5553 printf (_("\nCould not find unwind info section for "));
5555 if (string_table
== NULL
)
5556 printf ("%d", unwsec
->sh_name
);
5558 printf (_("'%s'"), SECTION_NAME (unwsec
));
5562 aux
.info_size
= sec
->sh_size
;
5563 aux
.info_addr
= sec
->sh_addr
;
5564 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
5568 printf (_("\nUnwind section "));
5570 if (string_table
== NULL
)
5571 printf ("%d", unwsec
->sh_name
);
5573 printf (_("'%s'"), SECTION_NAME (unwsec
));
5575 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5576 (unsigned long) unwsec
->sh_offset
,
5577 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5579 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5581 if (aux
.table_len
> 0)
5582 dump_ia64_unwind (& aux
);
5585 free ((char *) aux
.table
);
5587 free ((char *) aux
.info
);
5596 free ((char *) aux
.strtab
);
5601 struct hppa_unw_table_entry
5603 struct absaddr start
;
5605 unsigned int Cannot_unwind
:1; /* 0 */
5606 unsigned int Millicode
:1; /* 1 */
5607 unsigned int Millicode_save_sr0
:1; /* 2 */
5608 unsigned int Region_description
:2; /* 3..4 */
5609 unsigned int reserved1
:1; /* 5 */
5610 unsigned int Entry_SR
:1; /* 6 */
5611 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5612 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5613 unsigned int Args_stored
:1; /* 16 */
5614 unsigned int Variable_Frame
:1; /* 17 */
5615 unsigned int Separate_Package_Body
:1; /* 18 */
5616 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5617 unsigned int Stack_Overflow_Check
:1; /* 20 */
5618 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5619 unsigned int Ada_Region
:1; /* 22 */
5620 unsigned int cxx_info
:1; /* 23 */
5621 unsigned int cxx_try_catch
:1; /* 24 */
5622 unsigned int sched_entry_seq
:1; /* 25 */
5623 unsigned int reserved2
:1; /* 26 */
5624 unsigned int Save_SP
:1; /* 27 */
5625 unsigned int Save_RP
:1; /* 28 */
5626 unsigned int Save_MRP_in_frame
:1; /* 29 */
5627 unsigned int extn_ptr_defined
:1; /* 30 */
5628 unsigned int Cleanup_defined
:1; /* 31 */
5630 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5631 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5632 unsigned int Large_frame
:1; /* 2 */
5633 unsigned int Pseudo_SP_Set
:1; /* 3 */
5634 unsigned int reserved4
:1; /* 4 */
5635 unsigned int Total_frame_size
:27; /* 5..31 */
5638 struct hppa_unw_aux_info
5640 struct hppa_unw_table_entry
*table
; /* Unwind table. */
5641 unsigned long table_len
; /* Length of unwind table. */
5642 bfd_vma seg_base
; /* Starting address of segment. */
5643 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5644 unsigned long nsyms
; /* Number of symbols. */
5645 char * strtab
; /* The string table. */
5646 unsigned long strtab_size
; /* Size of string table. */
5650 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
5652 struct hppa_unw_table_entry
* tp
;
5654 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5657 const char * procname
;
5659 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5660 aux
->strtab_size
, tp
->start
, &procname
,
5663 fputs ("\n<", stdout
);
5667 fputs (procname
, stdout
);
5670 printf ("+%lx", (unsigned long) offset
);
5673 fputs (">: [", stdout
);
5674 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5675 fputc ('-', stdout
);
5676 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5679 #define PF(_m) if (tp->_m) printf (#_m " ");
5680 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5683 PF(Millicode_save_sr0
);
5684 /* PV(Region_description); */
5690 PF(Separate_Package_Body
);
5691 PF(Frame_Extension_Millicode
);
5692 PF(Stack_Overflow_Check
);
5693 PF(Two_Instruction_SP_Increment
);
5697 PF(sched_entry_seq
);
5700 PF(Save_MRP_in_frame
);
5701 PF(extn_ptr_defined
);
5702 PF(Cleanup_defined
);
5703 PF(MPE_XL_interrupt_marker
);
5704 PF(HP_UX_interrupt_marker
);
5707 PV(Total_frame_size
);
5716 slurp_hppa_unwind_table (FILE * file
,
5717 struct hppa_unw_aux_info
* aux
,
5718 Elf_Internal_Shdr
* sec
)
5720 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5721 Elf_Internal_Phdr
* seg
;
5722 struct hppa_unw_table_entry
* tep
;
5723 Elf_Internal_Shdr
* relsec
;
5724 Elf_Internal_Rela
* rela
;
5725 Elf_Internal_Rela
* rp
;
5726 unsigned char * table
;
5728 Elf_Internal_Sym
* sym
;
5729 const char * relname
;
5731 /* First, find the starting address of the segment that includes
5734 if (elf_header
.e_phnum
)
5736 if (! get_program_headers (file
))
5739 for (seg
= program_headers
;
5740 seg
< program_headers
+ elf_header
.e_phnum
;
5743 if (seg
->p_type
!= PT_LOAD
)
5746 if (sec
->sh_addr
>= seg
->p_vaddr
5747 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5749 aux
->seg_base
= seg
->p_vaddr
;
5755 /* Second, build the unwind table from the contents of the unwind
5757 size
= sec
->sh_size
;
5758 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
5764 nentries
= size
/ unw_ent_size
;
5765 size
= unw_ent_size
* nentries
;
5767 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
5768 xcmalloc (nentries
, sizeof (aux
->table
[0]));
5770 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5772 unsigned int tmp1
, tmp2
;
5774 tep
->start
.section
= SHN_UNDEF
;
5775 tep
->end
.section
= SHN_UNDEF
;
5777 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5778 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5779 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5780 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5782 tep
->start
.offset
+= aux
->seg_base
;
5783 tep
->end
.offset
+= aux
->seg_base
;
5785 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5786 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5787 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5788 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5789 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5790 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5791 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5792 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5793 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5794 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5795 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5796 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5797 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5798 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5799 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5800 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5801 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5802 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5803 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5804 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5805 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5806 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5807 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5808 tep
->Cleanup_defined
= tmp1
& 0x1;
5810 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5811 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5812 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5813 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5814 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5815 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5819 /* Third, apply any relocations to the unwind table. */
5820 for (relsec
= section_headers
;
5821 relsec
< section_headers
+ elf_header
.e_shnum
;
5824 if (relsec
->sh_type
!= SHT_RELA
5825 || relsec
->sh_info
>= elf_header
.e_shnum
5826 || section_headers
+ relsec
->sh_info
!= sec
)
5829 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5833 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5835 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
5836 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5838 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5839 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
5841 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5845 i
= rp
->r_offset
/ unw_ent_size
;
5847 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5850 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5851 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
5854 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5855 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
5865 aux
->table_len
= nentries
;
5871 hppa_process_unwind (FILE * file
)
5873 struct hppa_unw_aux_info aux
;
5874 Elf_Internal_Shdr
* unwsec
= NULL
;
5875 Elf_Internal_Shdr
* strsec
;
5876 Elf_Internal_Shdr
* sec
;
5879 memset (& aux
, 0, sizeof (aux
));
5881 if (string_table
== NULL
)
5884 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5886 if (sec
->sh_type
== SHT_SYMTAB
5887 && sec
->sh_link
< elf_header
.e_shnum
)
5889 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5890 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5892 strsec
= section_headers
+ sec
->sh_link
;
5893 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5896 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5898 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5903 printf (_("\nThere are no unwind sections in this file.\n"));
5905 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5907 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5909 printf (_("\nUnwind section "));
5910 printf (_("'%s'"), SECTION_NAME (sec
));
5912 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5913 (unsigned long) sec
->sh_offset
,
5914 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5916 slurp_hppa_unwind_table (file
, &aux
, sec
);
5917 if (aux
.table_len
> 0)
5918 dump_hppa_unwind (&aux
);
5921 free ((char *) aux
.table
);
5929 free ((char *) aux
.strtab
);
5936 unsigned char *data
;
5938 Elf_Internal_Shdr
*sec
;
5939 Elf_Internal_Rela
*rela
;
5940 unsigned long nrelas
;
5941 unsigned int rel_type
;
5943 Elf_Internal_Rela
*next_rela
;
5946 struct arm_unw_aux_info
5950 Elf_Internal_Sym
*symtab
; /* The symbol table. */
5951 unsigned long nsyms
; /* Number of symbols. */
5952 char *strtab
; /* The string table. */
5953 unsigned long strtab_size
; /* Size of string table. */
5957 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
5958 bfd_vma fn
, struct absaddr addr
)
5960 const char *procname
;
5963 if (addr
.section
== SHN_UNDEF
)
5966 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5967 aux
->strtab_size
, addr
, &procname
,
5970 print_vma (fn
, PREFIX_HEX
);
5974 fputs (" <", stdout
);
5975 fputs (procname
, stdout
);
5978 printf ("+0x%lx", (unsigned long) sym_offset
);
5979 fputc ('>', stdout
);
5986 arm_free_section (struct arm_section
*arm_sec
)
5988 if (arm_sec
->data
!= NULL
)
5989 free (arm_sec
->data
);
5991 if (arm_sec
->rela
!= NULL
)
5992 free (arm_sec
->rela
);
5996 arm_section_get_word (struct arm_unw_aux_info
*aux
,
5997 struct arm_section
*arm_sec
,
5998 Elf_Internal_Shdr
*sec
, bfd_vma word_offset
,
5999 unsigned int *wordp
, struct absaddr
*addr
)
6001 Elf_Internal_Rela
*rp
;
6002 Elf_Internal_Sym
*sym
;
6003 const char * relname
;
6005 bfd_boolean wrapped
;
6007 addr
->section
= SHN_UNDEF
;
6010 if (sec
!= arm_sec
->sec
)
6012 Elf_Internal_Shdr
*relsec
;
6014 arm_free_section (arm_sec
);
6017 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
6018 sec
->sh_size
, _("unwind data"));
6020 arm_sec
->rela
= NULL
;
6021 arm_sec
->nrelas
= 0;
6023 for (relsec
= section_headers
;
6024 relsec
< section_headers
+ elf_header
.e_shnum
;
6027 if (relsec
->sh_info
>= elf_header
.e_shnum
6028 || section_headers
+ relsec
->sh_info
!= sec
)
6031 if (relsec
->sh_type
== SHT_REL
)
6033 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
6035 & arm_sec
->rela
, & arm_sec
->nrelas
))
6039 else if (relsec
->sh_type
== SHT_RELA
)
6041 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
6043 & arm_sec
->rela
, & arm_sec
->nrelas
))
6049 arm_sec
->next_rela
= arm_sec
->rela
;
6052 if (arm_sec
->data
== NULL
)
6055 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
6058 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
6060 bfd_vma prelval
, offset
;
6062 if (rp
->r_offset
> word_offset
&& !wrapped
)
6067 if (rp
->r_offset
> word_offset
)
6070 if (rp
->r_offset
& 3)
6072 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6073 (unsigned long) rp
->r_offset
);
6077 if (rp
->r_offset
< word_offset
)
6080 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
6082 if (streq (relname
, "R_ARM_NONE"))
6085 if (! streq (relname
, "R_ARM_PREL31"))
6087 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6091 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
6093 if (arm_sec
->rel_type
== SHT_REL
)
6095 offset
= word
& 0x7fffffff;
6096 if (offset
& 0x40000000)
6097 offset
|= ~ (bfd_vma
) 0x7fffffff;
6100 offset
= rp
->r_addend
;
6102 offset
+= sym
->st_value
;
6103 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
6105 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
6106 addr
->section
= sym
->st_shndx
;
6107 addr
->offset
= offset
;
6112 arm_sec
->next_rela
= rp
;
6118 decode_arm_unwind (struct arm_unw_aux_info
*aux
,
6119 unsigned int word
, unsigned int remaining
,
6120 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
6121 struct arm_section
*data_arm_sec
)
6124 unsigned int more_words
;
6125 struct absaddr addr
;
6128 if (remaining == 0 && more_words) \
6131 if (!arm_section_get_word (aux, data_arm_sec, data_sec, \
6132 data_offset, &word, &addr)) \
6138 #define GET_OP(OP) \
6143 (OP) = word >> 24; \
6148 printf (_("[Truncated opcode]\n")); \
6151 printf (_("0x%02x "), OP)
6155 /* Fetch the first word. */
6156 if (!arm_section_get_word (aux
, data_arm_sec
, data_sec
, data_offset
,
6162 if ((word
& 0x80000000) == 0)
6164 /* Expand prel31 for personality routine. */
6166 const char *procname
;
6169 if (fn
& 0x40000000)
6170 fn
|= ~ (bfd_vma
) 0x7fffffff;
6171 fn
= fn
+ data_sec
->sh_addr
+ data_offset
;
6173 printf (_(" Personality routine: "));
6174 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
6175 fputc ('\n', stdout
);
6177 /* The GCC personality routines use the standard compact
6178 encoding, starting with one byte giving the number of
6180 if (procname
!= NULL
6181 && (const_strneq (procname
, "__gcc_personality_v0")
6182 || const_strneq (procname
, "__gxx_personality_v0")
6183 || const_strneq (procname
, "__gcj_personality_v0")
6184 || const_strneq (procname
, "__gnu_objc_personality_v0")))
6191 printf (_(" [Truncated data]\n"));
6194 more_words
= word
>> 24;
6204 per_index
= (word
>> 24) & 0x7f;
6205 if (per_index
!= 0 && per_index
!= 1 && per_index
!= 2)
6207 printf (_(" [reserved compact index %d]\n"), per_index
);
6211 printf (_(" Compact model %d\n"), per_index
);
6220 more_words
= (word
>> 16) & 0xff;
6226 /* Decode the unwinding instructions. */
6229 unsigned int op
, op2
;
6238 printf (_(" 0x%02x "), op
);
6240 if ((op
& 0xc0) == 0x00)
6242 int offset
= ((op
& 0x3f) << 2) + 4;
6243 printf (_(" vsp = vsp + %d"), offset
);
6245 else if ((op
& 0xc0) == 0x40)
6247 int offset
= ((op
& 0x3f) << 2) + 4;
6248 printf (_(" vsp = vsp - %d"), offset
);
6250 else if ((op
& 0xf0) == 0x80)
6253 if (op
== 0x80 && op2
== 0)
6254 printf (_("Refuse to unwind"));
6257 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
6262 for (i
= 0; i
< 12; i
++)
6263 if (mask
& (1 << i
))
6269 printf ("r%d", 4 + i
);
6274 else if ((op
& 0xf0) == 0x90)
6276 if (op
== 0x9d || op
== 0x9f)
6277 printf (_(" [Reserved]"));
6279 printf (_(" vsp = r%d"), op
& 0x0f);
6281 else if ((op
& 0xf0) == 0xa0)
6283 int end
= 4 + (op
& 0x07);
6287 for (i
= 4; i
<= end
; i
++)
6303 else if (op
== 0xb0)
6304 printf (_(" finish"));
6305 else if (op
== 0xb1)
6308 if (op2
== 0 || (op2
& 0xf0) != 0)
6309 printf (_("[Spare]"));
6312 unsigned int mask
= op2
& 0x0f;
6316 for (i
= 0; i
< 12; i
++)
6317 if (mask
& (1 << i
))
6328 else if (op
== 0xb2)
6330 unsigned char buf
[9];
6331 unsigned int i
, len
;
6332 unsigned long offset
;
6333 for (i
= 0; i
< sizeof (buf
); i
++)
6336 if ((buf
[i
] & 0x80) == 0)
6339 assert (i
< sizeof (buf
));
6340 offset
= read_uleb128 (buf
, &len
);
6341 assert (len
== i
+ 1);
6342 offset
= offset
* 4 + 0x204;
6343 printf (_("vsp = vsp + %ld"), offset
);
6347 if (op
== 0xb3 || op
== 0xc6 || op
== 0xc7 || op
== 0xc8 || op
== 0xc9)
6350 printf (_("[unsupported two-byte opcode]"));
6354 printf (_(" [unsupported opcode]"));
6360 /* Decode the descriptors. Not implemented. */
6364 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
6366 struct arm_section exidx_arm_sec
, extab_arm_sec
;
6367 unsigned int i
, exidx_len
;
6369 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
6370 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
6371 exidx_len
= exidx_sec
->sh_size
/ 8;
6373 for (i
= 0; i
< exidx_len
; i
++)
6375 unsigned int exidx_fn
, exidx_entry
;
6376 struct absaddr fn_addr
, entry_addr
;
6379 fputc ('\n', stdout
);
6381 if (!arm_section_get_word (aux
, &exidx_arm_sec
, exidx_sec
,
6382 8 * i
, &exidx_fn
, &fn_addr
)
6383 || !arm_section_get_word (aux
, &exidx_arm_sec
, exidx_sec
,
6384 8 * i
+ 4, &exidx_entry
, &entry_addr
))
6386 arm_free_section (&exidx_arm_sec
);
6387 arm_free_section (&extab_arm_sec
);
6391 fn
= exidx_fn
& 0x7fffffff;
6392 if (fn
& 0x40000000)
6393 fn
|= ~ (bfd_vma
) 0x7fffffff;
6394 fn
= fn
+ exidx_sec
->sh_addr
+ 8 * i
;
6396 arm_print_vma_and_name (aux
, fn
, entry_addr
);
6397 fputs (": ", stdout
);
6399 if (exidx_entry
== 1)
6401 print_vma (exidx_entry
, PREFIX_HEX
);
6402 fputs (" [cantunwind]\n", stdout
);
6404 else if (exidx_entry
& 0x80000000)
6406 print_vma (exidx_entry
, PREFIX_HEX
);
6407 fputc ('\n', stdout
);
6408 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
6412 bfd_vma table
, table_offset
= 0;
6413 Elf_Internal_Shdr
*table_sec
;
6415 fputs ("@", stdout
);
6416 table
= exidx_entry
;
6417 if (table
& 0x40000000)
6418 table
|= ~ (bfd_vma
) 0x7fffffff;
6419 table
= table
+ exidx_sec
->sh_addr
+ 8 * i
+ 4;
6420 print_vma (table
, PREFIX_HEX
);
6423 /* Locate the matching .ARM.extab. */
6424 if (entry_addr
.section
!= SHN_UNDEF
6425 && entry_addr
.section
< elf_header
.e_shnum
)
6427 table_sec
= section_headers
+ entry_addr
.section
;
6428 table_offset
= entry_addr
.offset
;
6432 table_sec
= find_section_by_address (table
);
6433 if (table_sec
!= NULL
)
6434 table_offset
= table
- table_sec
->sh_addr
;
6436 if (table_sec
== NULL
)
6438 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
6439 (unsigned long) table
);
6442 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
6449 arm_free_section (&exidx_arm_sec
);
6450 arm_free_section (&extab_arm_sec
);
6454 arm_process_unwind (FILE *file
)
6456 struct arm_unw_aux_info aux
;
6457 Elf_Internal_Shdr
*unwsec
= NULL
;
6458 Elf_Internal_Shdr
*strsec
;
6459 Elf_Internal_Shdr
*sec
;
6462 memset (& aux
, 0, sizeof (aux
));
6465 if (string_table
== NULL
)
6468 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6470 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
6472 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
6473 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
6475 strsec
= section_headers
+ sec
->sh_link
;
6476 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
6477 1, strsec
->sh_size
, _("string table"));
6478 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6480 else if (sec
->sh_type
== SHT_ARM_EXIDX
)
6485 printf (_("\nThere are no unwind sections in this file.\n"));
6487 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6489 if (sec
->sh_type
== SHT_ARM_EXIDX
)
6491 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
6493 (unsigned long) sec
->sh_offset
,
6494 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
6496 dump_arm_unwind (&aux
, sec
);
6503 free ((char *) aux
.strtab
);
6509 process_unwind (FILE * file
)
6511 struct unwind_handler
6514 int (* handler
)(FILE *);
6517 { EM_ARM
, arm_process_unwind
},
6518 { EM_IA_64
, ia64_process_unwind
},
6519 { EM_PARISC
, hppa_process_unwind
},
6527 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
6528 if (elf_header
.e_machine
== handlers
[i
].machtype
)
6529 return handlers
[i
].handler (file
);
6531 printf (_("\nThere are no unwind sections in this file.\n"));
6536 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
6538 switch (entry
->d_tag
)
6541 if (entry
->d_un
.d_val
== 0)
6542 printf (_("NONE\n"));
6545 static const char * opts
[] =
6547 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
6548 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
6549 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
6550 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
6556 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
6557 if (entry
->d_un
.d_val
& (1 << cnt
))
6559 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
6566 case DT_MIPS_IVERSION
:
6567 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6568 printf (_("Interface Version: %s\n"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
6570 printf (_("<corrupt: %ld>\n"), (long) entry
->d_un
.d_ptr
);
6573 case DT_MIPS_TIME_STAMP
:
6578 time_t atime
= entry
->d_un
.d_val
;
6579 tmp
= gmtime (&atime
);
6580 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
6581 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6582 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6583 printf (_("Time Stamp: %s\n"), timebuf
);
6587 case DT_MIPS_RLD_VERSION
:
6588 case DT_MIPS_LOCAL_GOTNO
:
6589 case DT_MIPS_CONFLICTNO
:
6590 case DT_MIPS_LIBLISTNO
:
6591 case DT_MIPS_SYMTABNO
:
6592 case DT_MIPS_UNREFEXTNO
:
6593 case DT_MIPS_HIPAGENO
:
6594 case DT_MIPS_DELTA_CLASS_NO
:
6595 case DT_MIPS_DELTA_INSTANCE_NO
:
6596 case DT_MIPS_DELTA_RELOC_NO
:
6597 case DT_MIPS_DELTA_SYM_NO
:
6598 case DT_MIPS_DELTA_CLASSSYM_NO
:
6599 case DT_MIPS_COMPACT_SIZE
:
6600 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
6604 printf ("%#lx\n", (unsigned long) entry
->d_un
.d_ptr
);
6609 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
6611 switch (entry
->d_tag
)
6613 case DT_HP_DLD_FLAGS
:
6622 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
6623 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
6624 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
6625 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
6626 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
6627 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
6628 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
6629 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
6630 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
6631 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
6632 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
6633 { DT_HP_GST
, "HP_GST" },
6634 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
6635 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
6636 { DT_HP_NODELETE
, "HP_NODELETE" },
6637 { DT_HP_GROUP
, "HP_GROUP" },
6638 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
6642 bfd_vma val
= entry
->d_un
.d_val
;
6644 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
6645 if (val
& flags
[cnt
].bit
)
6649 fputs (flags
[cnt
].str
, stdout
);
6651 val
^= flags
[cnt
].bit
;
6654 if (val
!= 0 || first
)
6658 print_vma (val
, HEX
);
6664 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
6671 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
6673 switch (entry
->d_tag
)
6675 case DT_IA_64_PLT_RESERVE
:
6676 /* First 3 slots reserved. */
6677 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
6679 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
6683 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
6690 get_32bit_dynamic_section (FILE * file
)
6692 Elf32_External_Dyn
* edyn
;
6693 Elf32_External_Dyn
* ext
;
6694 Elf_Internal_Dyn
* entry
;
6696 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
6697 dynamic_size
, _("dynamic section"));
6701 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
6702 might not have the luxury of section headers. Look for the DT_NULL
6703 terminator to determine the number of entries. */
6704 for (ext
= edyn
, dynamic_nent
= 0;
6705 (char *) ext
< (char *) edyn
+ dynamic_size
;
6709 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
6713 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
6715 if (dynamic_section
== NULL
)
6717 error (_("Out of memory\n"));
6722 for (ext
= edyn
, entry
= dynamic_section
;
6723 entry
< dynamic_section
+ dynamic_nent
;
6726 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
6727 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
6736 get_64bit_dynamic_section (FILE * file
)
6738 Elf64_External_Dyn
* edyn
;
6739 Elf64_External_Dyn
* ext
;
6740 Elf_Internal_Dyn
* entry
;
6742 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
6743 dynamic_size
, _("dynamic section"));
6747 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
6748 might not have the luxury of section headers. Look for the DT_NULL
6749 terminator to determine the number of entries. */
6750 for (ext
= edyn
, dynamic_nent
= 0;
6751 (char *) ext
< (char *) edyn
+ dynamic_size
;
6755 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
6759 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
6761 if (dynamic_section
== NULL
)
6763 error (_("Out of memory\n"));
6768 for (ext
= edyn
, entry
= dynamic_section
;
6769 entry
< dynamic_section
+ dynamic_nent
;
6772 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
6773 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
6782 print_dynamic_flags (bfd_vma flags
)
6790 flag
= flags
& - flags
;
6800 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
6801 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
6802 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
6803 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
6804 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
6805 default: fputs (_("unknown"), stdout
); break;
6811 /* Parse and display the contents of the dynamic section. */
6814 process_dynamic_section (FILE * file
)
6816 Elf_Internal_Dyn
* entry
;
6818 if (dynamic_size
== 0)
6821 printf (_("\nThere is no dynamic section in this file.\n"));
6828 if (! get_32bit_dynamic_section (file
))
6831 else if (! get_64bit_dynamic_section (file
))
6834 /* Find the appropriate symbol table. */
6835 if (dynamic_symbols
== NULL
)
6837 for (entry
= dynamic_section
;
6838 entry
< dynamic_section
+ dynamic_nent
;
6841 Elf_Internal_Shdr section
;
6843 if (entry
->d_tag
!= DT_SYMTAB
)
6846 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
6848 /* Since we do not know how big the symbol table is,
6849 we default to reading in the entire file (!) and
6850 processing that. This is overkill, I know, but it
6852 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
6854 if (archive_file_offset
!= 0)
6855 section
.sh_size
= archive_file_size
- section
.sh_offset
;
6858 if (fseek (file
, 0, SEEK_END
))
6859 error (_("Unable to seek to end of file!\n"));
6861 section
.sh_size
= ftell (file
) - section
.sh_offset
;
6865 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
6867 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
6869 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
6870 if (num_dynamic_syms
< 1)
6872 error (_("Unable to determine the number of symbols to load\n"));
6876 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
6880 /* Similarly find a string table. */
6881 if (dynamic_strings
== NULL
)
6883 for (entry
= dynamic_section
;
6884 entry
< dynamic_section
+ dynamic_nent
;
6887 unsigned long offset
;
6890 if (entry
->d_tag
!= DT_STRTAB
)
6893 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
6895 /* Since we do not know how big the string table is,
6896 we default to reading in the entire file (!) and
6897 processing that. This is overkill, I know, but it
6900 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
6902 if (archive_file_offset
!= 0)
6903 str_tab_len
= archive_file_size
- offset
;
6906 if (fseek (file
, 0, SEEK_END
))
6907 error (_("Unable to seek to end of file\n"));
6908 str_tab_len
= ftell (file
) - offset
;
6911 if (str_tab_len
< 1)
6914 (_("Unable to determine the length of the dynamic string table\n"));
6918 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
6920 _("dynamic string table"));
6921 dynamic_strings_length
= str_tab_len
;
6926 /* And find the syminfo section if available. */
6927 if (dynamic_syminfo
== NULL
)
6929 unsigned long syminsz
= 0;
6931 for (entry
= dynamic_section
;
6932 entry
< dynamic_section
+ dynamic_nent
;
6935 if (entry
->d_tag
== DT_SYMINENT
)
6937 /* Note: these braces are necessary to avoid a syntax
6938 error from the SunOS4 C compiler. */
6939 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
6941 else if (entry
->d_tag
== DT_SYMINSZ
)
6942 syminsz
= entry
->d_un
.d_val
;
6943 else if (entry
->d_tag
== DT_SYMINFO
)
6944 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
6948 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
6950 Elf_External_Syminfo
* extsyminfo
;
6951 Elf_External_Syminfo
* extsym
;
6952 Elf_Internal_Syminfo
* syminfo
;
6954 /* There is a syminfo section. Read the data. */
6955 extsyminfo
= (Elf_External_Syminfo
*)
6956 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
6957 _("symbol information"));
6961 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
6962 if (dynamic_syminfo
== NULL
)
6964 error (_("Out of memory\n"));
6968 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
6969 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
6970 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
6971 ++syminfo
, ++extsym
)
6973 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
6974 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
6981 if (do_dynamic
&& dynamic_addr
)
6982 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
6983 dynamic_addr
, dynamic_nent
);
6985 printf (_(" Tag Type Name/Value\n"));
6987 for (entry
= dynamic_section
;
6988 entry
< dynamic_section
+ dynamic_nent
;
6996 print_vma (entry
->d_tag
, FULL_HEX
);
6997 dtype
= get_dynamic_type (entry
->d_tag
);
6998 printf (" (%s)%*s", dtype
,
6999 ((is_32bit_elf
? 27 : 19)
7000 - (int) strlen (dtype
)),
7004 switch (entry
->d_tag
)
7008 print_dynamic_flags (entry
->d_un
.d_val
);
7018 switch (entry
->d_tag
)
7021 printf (_("Auxiliary library"));
7025 printf (_("Filter library"));
7029 printf (_("Configuration file"));
7033 printf (_("Dependency audit library"));
7037 printf (_("Audit library"));
7041 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7042 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
7046 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7055 printf (_("Flags:"));
7057 if (entry
->d_un
.d_val
== 0)
7058 printf (_(" None\n"));
7061 unsigned long int val
= entry
->d_un
.d_val
;
7063 if (val
& DTF_1_PARINIT
)
7065 printf (" PARINIT");
7066 val
^= DTF_1_PARINIT
;
7068 if (val
& DTF_1_CONFEXP
)
7070 printf (" CONFEXP");
7071 val
^= DTF_1_CONFEXP
;
7074 printf (" %lx", val
);
7083 printf (_("Flags:"));
7085 if (entry
->d_un
.d_val
== 0)
7086 printf (_(" None\n"));
7089 unsigned long int val
= entry
->d_un
.d_val
;
7091 if (val
& DF_P1_LAZYLOAD
)
7093 printf (" LAZYLOAD");
7094 val
^= DF_P1_LAZYLOAD
;
7096 if (val
& DF_P1_GROUPPERM
)
7098 printf (" GROUPPERM");
7099 val
^= DF_P1_GROUPPERM
;
7102 printf (" %lx", val
);
7111 printf (_("Flags:"));
7112 if (entry
->d_un
.d_val
== 0)
7113 printf (_(" None\n"));
7116 unsigned long int val
= entry
->d_un
.d_val
;
7123 if (val
& DF_1_GLOBAL
)
7128 if (val
& DF_1_GROUP
)
7133 if (val
& DF_1_NODELETE
)
7135 printf (" NODELETE");
7136 val
^= DF_1_NODELETE
;
7138 if (val
& DF_1_LOADFLTR
)
7140 printf (" LOADFLTR");
7141 val
^= DF_1_LOADFLTR
;
7143 if (val
& DF_1_INITFIRST
)
7145 printf (" INITFIRST");
7146 val
^= DF_1_INITFIRST
;
7148 if (val
& DF_1_NOOPEN
)
7153 if (val
& DF_1_ORIGIN
)
7158 if (val
& DF_1_DIRECT
)
7163 if (val
& DF_1_TRANS
)
7168 if (val
& DF_1_INTERPOSE
)
7170 printf (" INTERPOSE");
7171 val
^= DF_1_INTERPOSE
;
7173 if (val
& DF_1_NODEFLIB
)
7175 printf (" NODEFLIB");
7176 val
^= DF_1_NODEFLIB
;
7178 if (val
& DF_1_NODUMP
)
7183 if (val
& DF_1_CONLFAT
)
7185 printf (" CONLFAT");
7186 val
^= DF_1_CONLFAT
;
7189 printf (" %lx", val
);
7196 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
7198 puts (get_dynamic_type (entry
->d_un
.d_val
));
7218 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
7224 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7225 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
7231 switch (entry
->d_tag
)
7234 printf (_("Shared library: [%s]"), name
);
7236 if (streq (name
, program_interpreter
))
7237 printf (_(" program interpreter"));
7241 printf (_("Library soname: [%s]"), name
);
7245 printf (_("Library rpath: [%s]"), name
);
7249 printf (_("Library runpath: [%s]"), name
);
7253 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7258 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7271 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
7275 case DT_INIT_ARRAYSZ
:
7276 case DT_FINI_ARRAYSZ
:
7277 case DT_GNU_CONFLICTSZ
:
7278 case DT_GNU_LIBLISTSZ
:
7281 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
7282 printf (_(" (bytes)\n"));
7292 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
7305 if (entry
->d_tag
== DT_USED
7306 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7308 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
7312 printf (_("Not needed object: [%s]\n"), name
);
7317 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7323 /* The value of this entry is ignored. */
7328 case DT_GNU_PRELINKED
:
7332 time_t atime
= entry
->d_un
.d_val
;
7334 tmp
= gmtime (&atime
);
7335 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
7336 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
7337 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
7343 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
7346 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7352 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
7353 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
7358 switch (elf_header
.e_machine
)
7361 case EM_MIPS_RS3_LE
:
7362 dynamic_section_mips_val (entry
);
7365 dynamic_section_parisc_val (entry
);
7368 dynamic_section_ia64_val (entry
);
7371 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7383 get_ver_flags (unsigned int flags
)
7385 static char buff
[32];
7392 if (flags
& VER_FLG_BASE
)
7393 strcat (buff
, "BASE ");
7395 if (flags
& VER_FLG_WEAK
)
7397 if (flags
& VER_FLG_BASE
)
7398 strcat (buff
, "| ");
7400 strcat (buff
, "WEAK ");
7403 if (flags
& VER_FLG_INFO
)
7405 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
7406 strcat (buff
, "| ");
7408 strcat (buff
, "INFO ");
7411 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
7412 strcat (buff
, _("| <unknown>"));
7417 /* Display the contents of the version sections. */
7420 process_version_sections (FILE * file
)
7422 Elf_Internal_Shdr
* section
;
7429 for (i
= 0, section
= section_headers
;
7430 i
< elf_header
.e_shnum
;
7433 switch (section
->sh_type
)
7435 case SHT_GNU_verdef
:
7437 Elf_External_Verdef
* edefs
;
7445 (_("\nVersion definition section '%s' contains %u entries:\n"),
7446 SECTION_NAME (section
), section
->sh_info
);
7448 printf (_(" Addr: 0x"));
7449 printf_vma (section
->sh_addr
);
7450 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
7451 (unsigned long) section
->sh_offset
, section
->sh_link
,
7452 section
->sh_link
< elf_header
.e_shnum
7453 ? SECTION_NAME (section_headers
+ section
->sh_link
)
7456 edefs
= (Elf_External_Verdef
*)
7457 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
7458 _("version definition section"));
7459 endbuf
= (char *) edefs
+ section
->sh_size
;
7463 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
7466 Elf_External_Verdef
* edef
;
7467 Elf_Internal_Verdef ent
;
7468 Elf_External_Verdaux
* eaux
;
7469 Elf_Internal_Verdaux aux
;
7473 vstart
= ((char *) edefs
) + idx
;
7474 if (vstart
+ sizeof (*edef
) > endbuf
)
7477 edef
= (Elf_External_Verdef
*) vstart
;
7479 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
7480 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
7481 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
7482 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
7483 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
7484 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
7485 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
7487 printf (_(" %#06x: Rev: %d Flags: %s"),
7488 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
7490 printf (_(" Index: %d Cnt: %d "),
7491 ent
.vd_ndx
, ent
.vd_cnt
);
7493 vstart
+= ent
.vd_aux
;
7495 eaux
= (Elf_External_Verdaux
*) vstart
;
7497 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
7498 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
7500 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
7501 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
7503 printf (_("Name index: %ld\n"), aux
.vda_name
);
7505 isum
= idx
+ ent
.vd_aux
;
7507 for (j
= 1; j
< ent
.vd_cnt
; j
++)
7509 isum
+= aux
.vda_next
;
7510 vstart
+= aux
.vda_next
;
7512 eaux
= (Elf_External_Verdaux
*) vstart
;
7513 if (vstart
+ sizeof (*eaux
) > endbuf
)
7516 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
7517 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
7519 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
7520 printf (_(" %#06x: Parent %d: %s\n"),
7521 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
7523 printf (_(" %#06x: Parent %d, name index: %ld\n"),
7524 isum
, j
, aux
.vda_name
);
7527 printf (_(" Version def aux past end of section\n"));
7531 if (cnt
< section
->sh_info
)
7532 printf (_(" Version definition past end of section\n"));
7538 case SHT_GNU_verneed
:
7540 Elf_External_Verneed
* eneed
;
7547 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
7548 SECTION_NAME (section
), section
->sh_info
);
7550 printf (_(" Addr: 0x"));
7551 printf_vma (section
->sh_addr
);
7552 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
7553 (unsigned long) section
->sh_offset
, section
->sh_link
,
7554 section
->sh_link
< elf_header
.e_shnum
7555 ? SECTION_NAME (section_headers
+ section
->sh_link
)
7558 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
7559 section
->sh_offset
, 1,
7561 _("version need section"));
7562 endbuf
= (char *) eneed
+ section
->sh_size
;
7566 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
7568 Elf_External_Verneed
* entry
;
7569 Elf_Internal_Verneed ent
;
7574 vstart
= ((char *) eneed
) + idx
;
7575 if (vstart
+ sizeof (*entry
) > endbuf
)
7578 entry
= (Elf_External_Verneed
*) vstart
;
7580 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
7581 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
7582 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
7583 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
7584 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
7586 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
7588 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
7589 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
7591 printf (_(" File: %lx"), ent
.vn_file
);
7593 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
7595 vstart
+= ent
.vn_aux
;
7597 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
7599 Elf_External_Vernaux
* eaux
;
7600 Elf_Internal_Vernaux aux
;
7602 if (vstart
+ sizeof (*eaux
) > endbuf
)
7604 eaux
= (Elf_External_Vernaux
*) vstart
;
7606 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
7607 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
7608 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
7609 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
7610 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
7612 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
7613 printf (_(" %#06x: Name: %s"),
7614 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
7616 printf (_(" %#06x: Name index: %lx"),
7617 isum
, aux
.vna_name
);
7619 printf (_(" Flags: %s Version: %d\n"),
7620 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
7622 isum
+= aux
.vna_next
;
7623 vstart
+= aux
.vna_next
;
7626 printf (_(" Version need aux past end of section\n"));
7630 if (cnt
< section
->sh_info
)
7631 printf (_(" Version need past end of section\n"));
7637 case SHT_GNU_versym
:
7639 Elf_Internal_Shdr
* link_section
;
7642 unsigned char * edata
;
7643 unsigned short * data
;
7645 Elf_Internal_Sym
* symbols
;
7646 Elf_Internal_Shdr
* string_sec
;
7649 if (section
->sh_link
>= elf_header
.e_shnum
)
7652 link_section
= section_headers
+ section
->sh_link
;
7653 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
7655 if (link_section
->sh_link
>= elf_header
.e_shnum
)
7660 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
7662 string_sec
= section_headers
+ link_section
->sh_link
;
7664 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
7665 string_sec
->sh_size
,
7666 _("version string table"));
7670 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
7671 SECTION_NAME (section
), total
);
7673 printf (_(" Addr: "));
7674 printf_vma (section
->sh_addr
);
7675 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
7676 (unsigned long) section
->sh_offset
, section
->sh_link
,
7677 SECTION_NAME (link_section
));
7679 off
= offset_from_vma (file
,
7680 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7681 total
* sizeof (short));
7682 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
7684 _("version symbol data"));
7691 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
7693 for (cnt
= total
; cnt
--;)
7694 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
7699 for (cnt
= 0; cnt
< total
; cnt
+= 4)
7702 int check_def
, check_need
;
7705 printf (" %03x:", cnt
);
7707 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
7708 switch (data
[cnt
+ j
])
7711 fputs (_(" 0 (*local*) "), stdout
);
7715 fputs (_(" 1 (*global*) "), stdout
);
7719 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
7720 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
7724 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
7725 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
7728 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
7735 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
7737 Elf_Internal_Verneed ivn
;
7738 unsigned long offset
;
7740 offset
= offset_from_vma
7741 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7742 sizeof (Elf_External_Verneed
));
7746 Elf_Internal_Vernaux ivna
;
7747 Elf_External_Verneed evn
;
7748 Elf_External_Vernaux evna
;
7749 unsigned long a_off
;
7751 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7754 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7755 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7757 a_off
= offset
+ ivn
.vn_aux
;
7761 get_data (&evna
, file
, a_off
, sizeof (evna
),
7762 1, _("version need aux (2)"));
7764 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7765 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7767 a_off
+= ivna
.vna_next
;
7769 while (ivna
.vna_other
!= data
[cnt
+ j
]
7770 && ivna
.vna_next
!= 0);
7772 if (ivna
.vna_other
== data
[cnt
+ j
])
7774 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7776 if (ivna
.vna_name
>= string_sec
->sh_size
)
7777 name
= _("*invalid*");
7779 name
= strtab
+ ivna
.vna_name
;
7780 nn
+= printf ("(%s%-*s",
7782 12 - (int) strlen (name
),
7788 offset
+= ivn
.vn_next
;
7790 while (ivn
.vn_next
);
7793 if (check_def
&& data
[cnt
+ j
] != 0x8001
7794 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7796 Elf_Internal_Verdef ivd
;
7797 Elf_External_Verdef evd
;
7798 unsigned long offset
;
7800 offset
= offset_from_vma
7801 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7806 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
7809 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7810 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7812 offset
+= ivd
.vd_next
;
7814 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
7815 && ivd
.vd_next
!= 0);
7817 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
7819 Elf_External_Verdaux evda
;
7820 Elf_Internal_Verdaux ivda
;
7822 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7824 get_data (&evda
, file
,
7825 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
7827 _("version def aux"));
7829 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7831 if (ivda
.vda_name
>= string_sec
->sh_size
)
7832 name
= _("*invalid*");
7834 name
= strtab
+ ivda
.vda_name
;
7835 nn
+= printf ("(%s%-*s",
7837 12 - (int) strlen (name
),
7843 printf ("%*c", 18 - nn
, ' ');
7861 printf (_("\nNo version information found in this file.\n"));
7867 get_symbol_binding (unsigned int binding
)
7869 static char buff
[32];
7873 case STB_LOCAL
: return "LOCAL";
7874 case STB_GLOBAL
: return "GLOBAL";
7875 case STB_WEAK
: return "WEAK";
7877 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
7878 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
7880 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
7882 if (binding
== STB_GNU_UNIQUE
7883 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
7884 /* GNU/Linux is still using the default value 0. */
7885 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
7887 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
7890 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
7896 get_symbol_type (unsigned int type
)
7898 static char buff
[32];
7902 case STT_NOTYPE
: return "NOTYPE";
7903 case STT_OBJECT
: return "OBJECT";
7904 case STT_FUNC
: return "FUNC";
7905 case STT_SECTION
: return "SECTION";
7906 case STT_FILE
: return "FILE";
7907 case STT_COMMON
: return "COMMON";
7908 case STT_TLS
: return "TLS";
7909 case STT_RELC
: return "RELC";
7910 case STT_SRELC
: return "SRELC";
7912 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
7914 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
7915 return "THUMB_FUNC";
7917 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
7920 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
7921 return "PARISC_MILLI";
7923 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
7925 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
7927 if (elf_header
.e_machine
== EM_PARISC
)
7929 if (type
== STT_HP_OPAQUE
)
7931 if (type
== STT_HP_STUB
)
7935 if (type
== STT_GNU_IFUNC
7936 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
7937 /* GNU/Linux is still using the default value 0. */
7938 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
7941 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
7944 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
7950 get_symbol_visibility (unsigned int visibility
)
7954 case STV_DEFAULT
: return "DEFAULT";
7955 case STV_INTERNAL
: return "INTERNAL";
7956 case STV_HIDDEN
: return "HIDDEN";
7957 case STV_PROTECTED
: return "PROTECTED";
7963 get_mips_symbol_other (unsigned int other
)
7967 case STO_OPTIONAL
: return "OPTIONAL";
7968 case STO_MIPS16
: return "MIPS16";
7969 case STO_MIPS_PLT
: return "MIPS PLT";
7970 case STO_MIPS_PIC
: return "MIPS PIC";
7971 default: return NULL
;
7976 get_symbol_other (unsigned int other
)
7978 const char * result
= NULL
;
7979 static char buff
[32];
7984 switch (elf_header
.e_machine
)
7987 result
= get_mips_symbol_other (other
);
7995 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
8000 get_symbol_index_type (unsigned int type
)
8002 static char buff
[32];
8006 case SHN_UNDEF
: return "UND";
8007 case SHN_ABS
: return "ABS";
8008 case SHN_COMMON
: return "COM";
8010 if (type
== SHN_IA_64_ANSI_COMMON
8011 && elf_header
.e_machine
== EM_IA_64
8012 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
8014 else if ((elf_header
.e_machine
== EM_X86_64
8015 || elf_header
.e_machine
== EM_L1OM
)
8016 && type
== SHN_X86_64_LCOMMON
)
8018 else if (type
== SHN_MIPS_SCOMMON
8019 && elf_header
.e_machine
== EM_MIPS
)
8021 else if (type
== SHN_MIPS_SUNDEFINED
8022 && elf_header
.e_machine
== EM_MIPS
)
8024 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
8025 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
8026 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
8027 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
8028 else if (type
>= SHN_LORESERVE
)
8029 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
8031 sprintf (buff
, "%3d", type
);
8039 get_dynamic_data (FILE * file
, unsigned int number
, unsigned int ent_size
)
8041 unsigned char * e_data
;
8044 e_data
= (unsigned char *) cmalloc (number
, ent_size
);
8048 error (_("Out of memory\n"));
8052 if (fread (e_data
, ent_size
, number
, file
) != number
)
8054 error (_("Unable to read in dynamic data\n"));
8058 i_data
= (bfd_vma
*) cmalloc (number
, sizeof (*i_data
));
8062 error (_("Out of memory\n"));
8068 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
8076 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
8078 Elf_Internal_Sym
* psym
;
8081 psym
= dynamic_symbols
+ si
;
8083 n
= print_vma (si
, DEC_5
);
8085 fputs (" " + n
, stdout
);
8086 printf (" %3lu: ", hn
);
8087 print_vma (psym
->st_value
, LONG_HEX
);
8089 print_vma (psym
->st_size
, DEC_5
);
8091 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
8092 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
8093 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
8094 /* Check to see if any other bits in the st_other field are set.
8095 Note - displaying this information disrupts the layout of the
8096 table being generated, but for the moment this case is very
8098 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
8099 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
8100 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
8101 if (VALID_DYNAMIC_NAME (psym
->st_name
))
8102 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
8104 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
8108 /* Dump the symbol table. */
8110 process_symbol_table (FILE * file
)
8112 Elf_Internal_Shdr
* section
;
8113 bfd_vma nbuckets
= 0;
8114 bfd_vma nchains
= 0;
8115 bfd_vma
* buckets
= NULL
;
8116 bfd_vma
* chains
= NULL
;
8117 bfd_vma ngnubuckets
= 0;
8118 bfd_vma
* gnubuckets
= NULL
;
8119 bfd_vma
* gnuchains
= NULL
;
8120 bfd_vma gnusymidx
= 0;
8122 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
8125 if (dynamic_info
[DT_HASH
]
8127 || (do_using_dynamic
8129 && dynamic_strings
!= NULL
)))
8131 unsigned char nb
[8];
8132 unsigned char nc
[8];
8133 int hash_ent_size
= 4;
8135 if ((elf_header
.e_machine
== EM_ALPHA
8136 || elf_header
.e_machine
== EM_S390
8137 || elf_header
.e_machine
== EM_S390_OLD
)
8138 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
8142 (archive_file_offset
8143 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
8144 sizeof nb
+ sizeof nc
)),
8147 error (_("Unable to seek to start of dynamic information\n"));
8151 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
8153 error (_("Failed to read in number of buckets\n"));
8157 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
8159 error (_("Failed to read in number of chains\n"));
8163 nbuckets
= byte_get (nb
, hash_ent_size
);
8164 nchains
= byte_get (nc
, hash_ent_size
);
8166 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
8167 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
8170 if (buckets
== NULL
|| chains
== NULL
)
8172 if (do_using_dynamic
)
8183 if (dynamic_info_DT_GNU_HASH
8185 || (do_using_dynamic
8187 && dynamic_strings
!= NULL
)))
8189 unsigned char nb
[16];
8190 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
8191 bfd_vma buckets_vma
;
8194 (archive_file_offset
8195 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
8199 error (_("Unable to seek to start of dynamic information\n"));
8203 if (fread (nb
, 16, 1, file
) != 1)
8205 error (_("Failed to read in number of buckets\n"));
8209 ngnubuckets
= byte_get (nb
, 4);
8210 gnusymidx
= byte_get (nb
+ 4, 4);
8211 bitmaskwords
= byte_get (nb
+ 8, 4);
8212 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
8214 buckets_vma
+= bitmaskwords
* 4;
8216 buckets_vma
+= bitmaskwords
* 8;
8219 (archive_file_offset
8220 + offset_from_vma (file
, buckets_vma
, 4)),
8223 error (_("Unable to seek to start of dynamic information\n"));
8227 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
8229 if (gnubuckets
== NULL
)
8232 for (i
= 0; i
< ngnubuckets
; i
++)
8233 if (gnubuckets
[i
] != 0)
8235 if (gnubuckets
[i
] < gnusymidx
)
8238 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
8239 maxchain
= gnubuckets
[i
];
8242 if (maxchain
== 0xffffffff)
8245 maxchain
-= gnusymidx
;
8248 (archive_file_offset
8249 + offset_from_vma (file
, buckets_vma
8250 + 4 * (ngnubuckets
+ maxchain
), 4)),
8253 error (_("Unable to seek to start of dynamic information\n"));
8259 if (fread (nb
, 4, 1, file
) != 1)
8261 error (_("Failed to determine last chain length\n"));
8265 if (maxchain
+ 1 == 0)
8270 while ((byte_get (nb
, 4) & 1) == 0);
8273 (archive_file_offset
8274 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
8277 error (_("Unable to seek to start of dynamic information\n"));
8281 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
8284 if (gnuchains
== NULL
)
8289 if (do_using_dynamic
)
8294 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
8297 && dynamic_strings
!= NULL
)
8301 if (dynamic_info
[DT_HASH
])
8305 printf (_("\nSymbol table for image:\n"));
8307 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8309 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8311 for (hn
= 0; hn
< nbuckets
; hn
++)
8316 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
8317 print_dynamic_symbol (si
, hn
);
8321 if (dynamic_info_DT_GNU_HASH
)
8323 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
8325 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8327 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8329 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
8330 if (gnubuckets
[hn
] != 0)
8332 bfd_vma si
= gnubuckets
[hn
];
8333 bfd_vma off
= si
- gnusymidx
;
8337 print_dynamic_symbol (si
, hn
);
8340 while ((gnuchains
[off
++] & 1) == 0);
8344 else if (do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
8348 for (i
= 0, section
= section_headers
;
8349 i
< elf_header
.e_shnum
;
8353 char * strtab
= NULL
;
8354 unsigned long int strtab_size
= 0;
8355 Elf_Internal_Sym
* symtab
;
8356 Elf_Internal_Sym
* psym
;
8358 if ((section
->sh_type
!= SHT_SYMTAB
8359 && section
->sh_type
!= SHT_DYNSYM
)
8361 && section
->sh_type
== SHT_SYMTAB
))
8364 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
8365 SECTION_NAME (section
),
8366 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
8368 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
8370 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
8372 symtab
= GET_ELF_SYMBOLS (file
, section
);
8376 if (section
->sh_link
== elf_header
.e_shstrndx
)
8378 strtab
= string_table
;
8379 strtab_size
= string_table_length
;
8381 else if (section
->sh_link
< elf_header
.e_shnum
)
8383 Elf_Internal_Shdr
* string_sec
;
8385 string_sec
= section_headers
+ section
->sh_link
;
8387 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
8388 1, string_sec
->sh_size
,
8390 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
8393 for (si
= 0, psym
= symtab
;
8394 si
< section
->sh_size
/ section
->sh_entsize
;
8397 printf ("%6d: ", si
);
8398 print_vma (psym
->st_value
, LONG_HEX
);
8400 print_vma (psym
->st_size
, DEC_5
);
8401 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
8402 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
8403 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
8404 /* Check to see if any other bits in the st_other field are set.
8405 Note - displaying this information disrupts the layout of the
8406 table being generated, but for the moment this case is very rare. */
8407 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
8408 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
8409 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
8410 print_symbol (25, psym
->st_name
< strtab_size
8411 ? strtab
+ psym
->st_name
: _("<corrupt>"));
8413 if (section
->sh_type
== SHT_DYNSYM
&&
8414 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
8416 unsigned char data
[2];
8417 unsigned short vers_data
;
8418 unsigned long offset
;
8422 offset
= offset_from_vma
8423 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
8424 sizeof data
+ si
* sizeof (vers_data
));
8426 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
8427 sizeof (data
), 1, _("version data"));
8429 vers_data
= byte_get (data
, 2);
8431 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
8432 && section_headers
[psym
->st_shndx
].sh_type
8435 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
8437 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
8439 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
8440 && (is_nobits
|| ! check_def
))
8442 Elf_External_Verneed evn
;
8443 Elf_Internal_Verneed ivn
;
8444 Elf_Internal_Vernaux ivna
;
8446 /* We must test both. */
8447 offset
= offset_from_vma
8448 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
8453 unsigned long vna_off
;
8455 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
8458 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
8459 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
8461 vna_off
= offset
+ ivn
.vn_aux
;
8465 Elf_External_Vernaux evna
;
8467 get_data (&evna
, file
, vna_off
,
8469 _("version need aux (3)"));
8471 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
8472 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
8473 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
8475 vna_off
+= ivna
.vna_next
;
8477 while (ivna
.vna_other
!= vers_data
8478 && ivna
.vna_next
!= 0);
8480 if (ivna
.vna_other
== vers_data
)
8483 offset
+= ivn
.vn_next
;
8485 while (ivn
.vn_next
!= 0);
8487 if (ivna
.vna_other
== vers_data
)
8490 ivna
.vna_name
< strtab_size
8491 ? strtab
+ ivna
.vna_name
: _("<corrupt>"),
8495 else if (! is_nobits
)
8496 error (_("bad dynamic symbol\n"));
8503 if (vers_data
!= 0x8001
8504 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
8506 Elf_Internal_Verdef ivd
;
8507 Elf_Internal_Verdaux ivda
;
8508 Elf_External_Verdaux evda
;
8511 off
= offset_from_vma
8513 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
8514 sizeof (Elf_External_Verdef
));
8518 Elf_External_Verdef evd
;
8520 get_data (&evd
, file
, off
, sizeof (evd
),
8521 1, _("version def"));
8523 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
8524 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
8525 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
8529 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
8530 && ivd
.vd_next
!= 0);
8535 get_data (&evda
, file
, off
, sizeof (evda
),
8536 1, _("version def aux"));
8538 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
8540 if (psym
->st_name
!= ivda
.vda_name
)
8541 printf ((vers_data
& VERSYM_HIDDEN
)
8543 ivda
.vda_name
< strtab_size
8544 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
8554 if (strtab
!= string_table
)
8560 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
8562 if (do_histogram
&& buckets
!= NULL
)
8564 unsigned long * lengths
;
8565 unsigned long * counts
;
8568 unsigned long maxlength
= 0;
8569 unsigned long nzero_counts
= 0;
8570 unsigned long nsyms
= 0;
8572 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
8573 (unsigned long) nbuckets
);
8574 printf (_(" Length Number %% of total Coverage\n"));
8576 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
8577 if (lengths
== NULL
)
8579 error (_("Out of memory\n"));
8582 for (hn
= 0; hn
< nbuckets
; ++hn
)
8584 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
8587 if (maxlength
< ++lengths
[hn
])
8592 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
8595 error (_("Out of memory\n"));
8599 for (hn
= 0; hn
< nbuckets
; ++hn
)
8600 ++counts
[lengths
[hn
]];
8605 printf (" 0 %-10lu (%5.1f%%)\n",
8606 counts
[0], (counts
[0] * 100.0) / nbuckets
);
8607 for (i
= 1; i
<= maxlength
; ++i
)
8609 nzero_counts
+= counts
[i
] * i
;
8610 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
8611 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
8612 (nzero_counts
* 100.0) / nsyms
);
8620 if (buckets
!= NULL
)
8626 if (do_histogram
&& gnubuckets
!= NULL
)
8628 unsigned long * lengths
;
8629 unsigned long * counts
;
8631 unsigned long maxlength
= 0;
8632 unsigned long nzero_counts
= 0;
8633 unsigned long nsyms
= 0;
8635 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
8636 if (lengths
== NULL
)
8638 error (_("Out of memory\n"));
8642 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
8643 (unsigned long) ngnubuckets
);
8644 printf (_(" Length Number %% of total Coverage\n"));
8646 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
8647 if (gnubuckets
[hn
] != 0)
8649 bfd_vma off
, length
= 1;
8651 for (off
= gnubuckets
[hn
] - gnusymidx
;
8652 (gnuchains
[off
] & 1) == 0; ++off
)
8654 lengths
[hn
] = length
;
8655 if (length
> maxlength
)
8660 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
8663 error (_("Out of memory\n"));
8667 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
8668 ++counts
[lengths
[hn
]];
8670 if (ngnubuckets
> 0)
8673 printf (" 0 %-10lu (%5.1f%%)\n",
8674 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
8675 for (j
= 1; j
<= maxlength
; ++j
)
8677 nzero_counts
+= counts
[j
] * j
;
8678 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
8679 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
8680 (nzero_counts
* 100.0) / nsyms
);
8694 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
8698 if (dynamic_syminfo
== NULL
8700 /* No syminfo, this is ok. */
8703 /* There better should be a dynamic symbol section. */
8704 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
8708 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
8709 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
8711 printf (_(" Num: Name BoundTo Flags\n"));
8712 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
8714 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
8716 printf ("%4d: ", i
);
8717 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
8718 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
8720 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
8723 switch (dynamic_syminfo
[i
].si_boundto
)
8725 case SYMINFO_BT_SELF
:
8726 fputs ("SELF ", stdout
);
8728 case SYMINFO_BT_PARENT
:
8729 fputs ("PARENT ", stdout
);
8732 if (dynamic_syminfo
[i
].si_boundto
> 0
8733 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
8734 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
8736 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
8740 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
8744 if (flags
& SYMINFO_FLG_DIRECT
)
8746 if (flags
& SYMINFO_FLG_PASSTHRU
)
8747 printf (" PASSTHRU");
8748 if (flags
& SYMINFO_FLG_COPY
)
8750 if (flags
& SYMINFO_FLG_LAZYLOAD
)
8751 printf (" LAZYLOAD");
8759 /* Check to see if the given reloc needs to be handled in a target specific
8760 manner. If so then process the reloc and return TRUE otherwise return
8764 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
8765 unsigned char * start
,
8766 Elf_Internal_Sym
* symtab
)
8768 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
8770 switch (elf_header
.e_machine
)
8773 case EM_CYGNUS_MN10300
:
8775 static Elf_Internal_Sym
* saved_sym
= NULL
;
8779 case 34: /* R_MN10300_ALIGN */
8781 case 33: /* R_MN10300_SYM_DIFF */
8782 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
8784 case 1: /* R_MN10300_32 */
8785 case 2: /* R_MN10300_16 */
8786 if (saved_sym
!= NULL
)
8790 value
= reloc
->r_addend
8791 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
8792 - saved_sym
->st_value
);
8794 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
8801 if (saved_sym
!= NULL
)
8802 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
8812 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
8813 DWARF debug sections. This is a target specific test. Note - we do not
8814 go through the whole including-target-headers-multiple-times route, (as
8815 we have already done with <elf/h8.h>) because this would become very
8816 messy and even then this function would have to contain target specific
8817 information (the names of the relocs instead of their numeric values).
8818 FIXME: This is not the correct way to solve this problem. The proper way
8819 is to have target specific reloc sizing and typing functions created by
8820 the reloc-macros.h header, in the same way that it already creates the
8821 reloc naming functions. */
8824 is_32bit_abs_reloc (unsigned int reloc_type
)
8826 switch (elf_header
.e_machine
)
8830 return reloc_type
== 1; /* R_386_32. */
8832 return reloc_type
== 1; /* R_68K_32. */
8834 return reloc_type
== 1; /* R_860_32. */
8836 return reloc_type
== 1; /* XXX Is this right ? */
8838 return reloc_type
== 1; /* R_ARC_32. */
8840 return reloc_type
== 2; /* R_ARM_ABS32 */
8843 return reloc_type
== 1;
8845 return reloc_type
== 0x12; /* R_byte4_data. */
8847 return reloc_type
== 3; /* R_CRIS_32. */
8850 return reloc_type
== 3; /* R_CR16_NUM32. */
8852 return reloc_type
== 15; /* R_CRX_NUM32. */
8854 return reloc_type
== 1;
8855 case EM_CYGNUS_D10V
:
8857 return reloc_type
== 6; /* R_D10V_32. */
8858 case EM_CYGNUS_D30V
:
8860 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
8862 return reloc_type
== 3; /* R_DLX_RELOC_32. */
8863 case EM_CYGNUS_FR30
:
8865 return reloc_type
== 3; /* R_FR30_32. */
8869 return reloc_type
== 1; /* R_H8_DIR32. */
8871 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
8874 return reloc_type
== 2; /* R_IP2K_32. */
8876 return reloc_type
== 2; /* R_IQ2000_32. */
8877 case EM_LATTICEMICO32
:
8878 return reloc_type
== 3; /* R_LM32_32. */
8881 return reloc_type
== 3; /* R_M32C_32. */
8883 return reloc_type
== 34; /* R_M32R_32_RELA. */
8885 return reloc_type
== 1; /* R_MCORE_ADDR32. */
8887 return reloc_type
== 4; /* R_MEP_32. */
8889 return reloc_type
== 2; /* R_MIPS_32. */
8891 return reloc_type
== 4; /* R_MMIX_32. */
8892 case EM_CYGNUS_MN10200
:
8894 return reloc_type
== 1; /* R_MN10200_32. */
8895 case EM_CYGNUS_MN10300
:
8897 return reloc_type
== 1; /* R_MN10300_32. */
8900 return reloc_type
== 1; /* R_MSP43_32. */
8902 return reloc_type
== 2; /* R_MT_32. */
8903 case EM_ALTERA_NIOS2
:
8905 return reloc_type
== 1; /* R_NIOS_32. */
8908 return reloc_type
== 1; /* R_OR32_32. */
8910 return (reloc_type
== 1 /* R_PARISC_DIR32. */
8911 || reloc_type
== 41); /* R_PARISC_SECREL32. */
8914 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
8916 return reloc_type
== 1; /* R_PPC64_ADDR32. */
8918 return reloc_type
== 1; /* R_PPC_ADDR32. */
8920 return reloc_type
== 1; /* R_RX_DIR32. */
8922 return reloc_type
== 1; /* R_I370_ADDR31. */
8925 return reloc_type
== 4; /* R_S390_32. */
8927 return reloc_type
== 8; /* R_SCORE_ABS32. */
8929 return reloc_type
== 1; /* R_SH_DIR32. */
8930 case EM_SPARC32PLUS
:
8933 return reloc_type
== 3 /* R_SPARC_32. */
8934 || reloc_type
== 23; /* R_SPARC_UA32. */
8936 return reloc_type
== 6; /* R_SPU_ADDR32 */
8938 return reloc_type
== 1; /* R_C6000_ABS32. */
8939 case EM_CYGNUS_V850
:
8941 return reloc_type
== 6; /* R_V850_ABS32. */
8943 return reloc_type
== 1; /* R_VAX_32. */
8946 return reloc_type
== 10; /* R_X86_64_32. */
8949 return reloc_type
== 3; /* R_XC16C_ABS_32. */
8951 return reloc_type
== 1; /* R_XSTROMY16_32. */
8954 return reloc_type
== 1; /* R_XTENSA_32. */
8956 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
8957 elf_header
.e_machine
);
8962 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8963 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
8966 is_32bit_pcrel_reloc (unsigned int reloc_type
)
8968 switch (elf_header
.e_machine
)
8972 return reloc_type
== 2; /* R_386_PC32. */
8974 return reloc_type
== 4; /* R_68K_PC32. */
8976 return reloc_type
== 10; /* R_ALPHA_SREL32. */
8978 return reloc_type
== 3; /* R_ARM_REL32 */
8980 return reloc_type
== 9; /* R_PARISC_PCREL32. */
8982 return reloc_type
== 26; /* R_PPC_REL32. */
8984 return reloc_type
== 26; /* R_PPC64_REL32. */
8987 return reloc_type
== 5; /* R_390_PC32. */
8989 return reloc_type
== 2; /* R_SH_REL32. */
8990 case EM_SPARC32PLUS
:
8993 return reloc_type
== 6; /* R_SPARC_DISP32. */
8995 return reloc_type
== 13; /* R_SPU_REL32. */
8998 return reloc_type
== 2; /* R_X86_64_PC32. */
9001 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
9003 /* Do not abort or issue an error message here. Not all targets use
9004 pc-relative 32-bit relocs in their DWARF debug information and we
9005 have already tested for target coverage in is_32bit_abs_reloc. A
9006 more helpful warning message will be generated by apply_relocations
9007 anyway, so just return. */
9012 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9013 a 64-bit absolute RELA relocation used in DWARF debug sections. */
9016 is_64bit_abs_reloc (unsigned int reloc_type
)
9018 switch (elf_header
.e_machine
)
9021 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
9023 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
9025 return reloc_type
== 80; /* R_PARISC_DIR64. */
9027 return reloc_type
== 38; /* R_PPC64_ADDR64. */
9028 case EM_SPARC32PLUS
:
9031 return reloc_type
== 54; /* R_SPARC_UA64. */
9034 return reloc_type
== 1; /* R_X86_64_64. */
9037 return reloc_type
== 22; /* R_S390_64 */
9039 return reloc_type
== 18; /* R_MIPS_64 */
9045 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
9046 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
9049 is_64bit_pcrel_reloc (unsigned int reloc_type
)
9051 switch (elf_header
.e_machine
)
9054 return reloc_type
== 11; /* R_ALPHA_SREL64 */
9056 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB */
9058 return reloc_type
== 72; /* R_PARISC_PCREL64 */
9060 return reloc_type
== 44; /* R_PPC64_REL64 */
9061 case EM_SPARC32PLUS
:
9064 return reloc_type
== 46; /* R_SPARC_DISP64 */
9067 return reloc_type
== 24; /* R_X86_64_PC64 */
9070 return reloc_type
== 23; /* R_S390_PC64 */
9076 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9077 a 24-bit absolute RELA relocation used in DWARF debug sections. */
9080 is_24bit_abs_reloc (unsigned int reloc_type
)
9082 switch (elf_header
.e_machine
)
9084 case EM_CYGNUS_MN10200
:
9086 return reloc_type
== 4; /* R_MN10200_24. */
9092 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9093 a 16-bit absolute RELA relocation used in DWARF debug sections. */
9096 is_16bit_abs_reloc (unsigned int reloc_type
)
9098 switch (elf_header
.e_machine
)
9102 return reloc_type
== 4; /* R_AVR_16. */
9103 case EM_CYGNUS_D10V
:
9105 return reloc_type
== 3; /* R_D10V_16. */
9109 return reloc_type
== R_H8_DIR16
;
9112 return reloc_type
== 1; /* R_IP2K_16. */
9115 return reloc_type
== 1; /* R_M32C_16 */
9118 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
9119 case EM_ALTERA_NIOS2
:
9121 return reloc_type
== 9; /* R_NIOS_16. */
9123 return reloc_type
== 2; /* R_C6000_ABS16. */
9126 return reloc_type
== 2; /* R_XC16C_ABS_16. */
9132 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
9133 relocation entries (possibly formerly used for SHT_GROUP sections). */
9136 is_none_reloc (unsigned int reloc_type
)
9138 switch (elf_header
.e_machine
)
9140 case EM_68K
: /* R_68K_NONE. */
9141 case EM_386
: /* R_386_NONE. */
9142 case EM_SPARC32PLUS
:
9144 case EM_SPARC
: /* R_SPARC_NONE. */
9145 case EM_MIPS
: /* R_MIPS_NONE. */
9146 case EM_PARISC
: /* R_PARISC_NONE. */
9147 case EM_ALPHA
: /* R_ALPHA_NONE. */
9148 case EM_PPC
: /* R_PPC_NONE. */
9149 case EM_PPC64
: /* R_PPC64_NONE. */
9150 case EM_ARM
: /* R_ARM_NONE. */
9151 case EM_IA_64
: /* R_IA64_NONE. */
9152 case EM_SH
: /* R_SH_NONE. */
9154 case EM_S390
: /* R_390_NONE. */
9155 case EM_CRIS
: /* R_CRIS_NONE. */
9156 case EM_X86_64
: /* R_X86_64_NONE. */
9157 case EM_L1OM
: /* R_X86_64_NONE. */
9158 case EM_MN10300
: /* R_MN10300_NONE. */
9159 case EM_M32R
: /* R_M32R_NONE. */
9160 case EM_TI_C6000
:/* R_C6000_NONE. */
9162 case EM_C166
: /* R_XC16X_NONE. */
9163 return reloc_type
== 0;
9166 return (reloc_type
== 0 /* R_XTENSA_NONE. */
9167 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
9168 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
9169 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
9174 /* Apply relocations to a section.
9175 Note: So far support has been added only for those relocations
9176 which can be found in debug sections.
9177 FIXME: Add support for more relocations ? */
9180 apply_relocations (void * file
,
9181 Elf_Internal_Shdr
* section
,
9182 unsigned char * start
)
9184 Elf_Internal_Shdr
* relsec
;
9185 unsigned char * end
= start
+ section
->sh_size
;
9187 if (elf_header
.e_type
!= ET_REL
)
9190 /* Find the reloc section associated with the section. */
9191 for (relsec
= section_headers
;
9192 relsec
< section_headers
+ elf_header
.e_shnum
;
9195 bfd_boolean is_rela
;
9196 unsigned long num_relocs
;
9197 Elf_Internal_Rela
* relocs
;
9198 Elf_Internal_Rela
* rp
;
9199 Elf_Internal_Shdr
* symsec
;
9200 Elf_Internal_Sym
* symtab
;
9201 Elf_Internal_Sym
* sym
;
9203 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
9204 || relsec
->sh_info
>= elf_header
.e_shnum
9205 || section_headers
+ relsec
->sh_info
!= section
9206 || relsec
->sh_size
== 0
9207 || relsec
->sh_link
>= elf_header
.e_shnum
)
9210 is_rela
= relsec
->sh_type
== SHT_RELA
;
9214 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
9215 relsec
->sh_size
, & relocs
, & num_relocs
))
9220 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
9221 relsec
->sh_size
, & relocs
, & num_relocs
))
9225 /* SH uses RELA but uses in place value instead of the addend field. */
9226 if (elf_header
.e_machine
== EM_SH
)
9229 symsec
= section_headers
+ relsec
->sh_link
;
9230 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
);
9232 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
9235 unsigned int reloc_type
;
9236 unsigned int reloc_size
;
9237 unsigned char * rloc
;
9239 reloc_type
= get_reloc_type (rp
->r_info
);
9241 if (target_specific_reloc_handling (rp
, start
, symtab
))
9243 else if (is_none_reloc (reloc_type
))
9245 else if (is_32bit_abs_reloc (reloc_type
)
9246 || is_32bit_pcrel_reloc (reloc_type
))
9248 else if (is_64bit_abs_reloc (reloc_type
)
9249 || is_64bit_pcrel_reloc (reloc_type
))
9251 else if (is_24bit_abs_reloc (reloc_type
))
9253 else if (is_16bit_abs_reloc (reloc_type
))
9257 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
9258 reloc_type
, SECTION_NAME (section
));
9262 rloc
= start
+ rp
->r_offset
;
9263 if ((rloc
+ reloc_size
) > end
)
9265 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
9266 (unsigned long) rp
->r_offset
,
9267 SECTION_NAME (section
));
9271 sym
= symtab
+ get_reloc_symindex (rp
->r_info
);
9273 /* If the reloc has a symbol associated with it,
9274 make sure that it is of an appropriate type.
9276 Relocations against symbols without type can happen.
9277 Gcc -feliminate-dwarf2-dups may generate symbols
9278 without type for debug info.
9280 Icc generates relocations against function symbols
9281 instead of local labels.
9283 Relocations against object symbols can happen, eg when
9284 referencing a global array. For an example of this see
9285 the _clz.o binary in libgcc.a. */
9287 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
9289 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
9290 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
9291 (long int)(rp
- relocs
),
9292 SECTION_NAME (relsec
));
9298 addend
+= rp
->r_addend
;
9299 /* R_XTENSA_32 and R_PJ_DATA_DIR32 are partial_inplace. */
9301 || (elf_header
.e_machine
== EM_XTENSA
9303 || ((elf_header
.e_machine
== EM_PJ
9304 || elf_header
.e_machine
== EM_PJ_OLD
)
9305 && reloc_type
== 1))
9306 addend
+= byte_get (rloc
, reloc_size
);
9308 if (is_32bit_pcrel_reloc (reloc_type
)
9309 || is_64bit_pcrel_reloc (reloc_type
))
9311 /* On HPPA, all pc-relative relocations are biased by 8. */
9312 if (elf_header
.e_machine
== EM_PARISC
)
9314 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
9318 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
9327 #ifdef SUPPORT_DISASSEMBLY
9329 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
9331 printf (_("\nAssembly dump of section %s\n"),
9332 SECTION_NAME (section
));
9334 /* XXX -- to be done --- XXX */
9340 /* Reads in the contents of SECTION from FILE, returning a pointer
9341 to a malloc'ed buffer or NULL if something went wrong. */
9344 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
9346 bfd_size_type num_bytes
;
9348 num_bytes
= section
->sh_size
;
9350 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
9352 printf (_("\nSection '%s' has no data to dump.\n"),
9353 SECTION_NAME (section
));
9357 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
9358 _("section contents"));
9363 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
9365 Elf_Internal_Shdr
* relsec
;
9366 bfd_size_type num_bytes
;
9370 char * name
= SECTION_NAME (section
);
9371 bfd_boolean some_strings_shown
;
9373 start
= get_section_contents (section
, file
);
9377 printf (_("\nString dump of section '%s':\n"), name
);
9379 /* If the section being dumped has relocations against it the user might
9380 be expecting these relocations to have been applied. Check for this
9381 case and issue a warning message in order to avoid confusion.
9382 FIXME: Maybe we ought to have an option that dumps a section with
9384 for (relsec
= section_headers
;
9385 relsec
< section_headers
+ elf_header
.e_shnum
;
9388 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
9389 || relsec
->sh_info
>= elf_header
.e_shnum
9390 || section_headers
+ relsec
->sh_info
!= section
9391 || relsec
->sh_size
== 0
9392 || relsec
->sh_link
>= elf_header
.e_shnum
)
9395 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
9399 num_bytes
= section
->sh_size
;
9401 end
= start
+ num_bytes
;
9402 some_strings_shown
= FALSE
;
9406 while (!ISPRINT (* data
))
9413 /* PR 11128: Use two separate invocations in order to work
9414 around bugs in the Solaris 8 implementation of printf. */
9415 printf (" [%6tx] ", data
- start
);
9416 printf ("%s\n", data
);
9418 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
9420 data
+= strlen (data
);
9421 some_strings_shown
= TRUE
;
9425 if (! some_strings_shown
)
9426 printf (_(" No strings found in this section."));
9434 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
9436 bfd_boolean relocate
)
9438 Elf_Internal_Shdr
* relsec
;
9439 bfd_size_type bytes
;
9441 unsigned char * data
;
9442 unsigned char * start
;
9444 start
= (unsigned char *) get_section_contents (section
, file
);
9448 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
9452 apply_relocations (file
, section
, start
);
9456 /* If the section being dumped has relocations against it the user might
9457 be expecting these relocations to have been applied. Check for this
9458 case and issue a warning message in order to avoid confusion.
9459 FIXME: Maybe we ought to have an option that dumps a section with
9461 for (relsec
= section_headers
;
9462 relsec
< section_headers
+ elf_header
.e_shnum
;
9465 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
9466 || relsec
->sh_info
>= elf_header
.e_shnum
9467 || section_headers
+ relsec
->sh_info
!= section
9468 || relsec
->sh_size
== 0
9469 || relsec
->sh_link
>= elf_header
.e_shnum
)
9472 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
9477 addr
= section
->sh_addr
;
9478 bytes
= section
->sh_size
;
9487 lbytes
= (bytes
> 16 ? 16 : bytes
);
9489 printf (" 0x%8.8lx ", (unsigned long) addr
);
9491 for (j
= 0; j
< 16; j
++)
9494 printf ("%2.2x", data
[j
]);
9502 for (j
= 0; j
< lbytes
; j
++)
9505 if (k
>= ' ' && k
< 0x7f)
9523 /* Uncompresses a section that was compressed using zlib, in place.
9524 This is a copy of bfd_uncompress_section_contents, in bfd/compress.c */
9527 uncompress_section_contents (unsigned char ** buffer
, dwarf_size_type
* size
)
9530 /* These are just to quiet gcc. */
9535 dwarf_size_type compressed_size
= *size
;
9536 unsigned char * compressed_buffer
= *buffer
;
9537 dwarf_size_type uncompressed_size
;
9538 unsigned char * uncompressed_buffer
;
9541 dwarf_size_type header_size
= 12;
9543 /* Read the zlib header. In this case, it should be "ZLIB" followed
9544 by the uncompressed section size, 8 bytes in big-endian order. */
9545 if (compressed_size
< header_size
9546 || ! streq ((char *) compressed_buffer
, "ZLIB"))
9549 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
9550 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
9551 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
9552 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
9553 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
9554 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
9555 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
9556 uncompressed_size
+= compressed_buffer
[11];
9558 /* It is possible the section consists of several compressed
9559 buffers concatenated together, so we uncompress in a loop. */
9563 strm
.avail_in
= compressed_size
- header_size
;
9564 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
9565 strm
.avail_out
= uncompressed_size
;
9566 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
9568 rc
= inflateInit (& strm
);
9569 while (strm
.avail_in
> 0)
9573 strm
.next_out
= ((Bytef
*) uncompressed_buffer
9574 + (uncompressed_size
- strm
.avail_out
));
9575 rc
= inflate (&strm
, Z_FINISH
);
9576 if (rc
!= Z_STREAM_END
)
9578 rc
= inflateReset (& strm
);
9580 rc
= inflateEnd (& strm
);
9582 || strm
.avail_out
!= 0)
9585 free (compressed_buffer
);
9586 *buffer
= uncompressed_buffer
;
9587 *size
= uncompressed_size
;
9591 free (uncompressed_buffer
);
9593 #endif /* HAVE_ZLIB_H */
9597 load_specific_debug_section (enum dwarf_section_display_enum debug
,
9598 Elf_Internal_Shdr
* sec
, void * file
)
9600 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
9602 int section_is_compressed
;
9604 /* If it is already loaded, do nothing. */
9605 if (section
->start
!= NULL
)
9608 section_is_compressed
= section
->name
== section
->compressed_name
;
9610 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
9611 section
->address
= sec
->sh_addr
;
9612 section
->size
= sec
->sh_size
;
9613 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
9616 if (section
->start
== NULL
)
9619 if (section_is_compressed
)
9620 if (! uncompress_section_contents (§ion
->start
, §ion
->size
))
9623 if (debug_displays
[debug
].relocate
)
9624 apply_relocations ((FILE *) file
, sec
, section
->start
);
9630 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
9632 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
9633 Elf_Internal_Shdr
* sec
;
9635 /* Locate the debug section. */
9636 sec
= find_section (section
->uncompressed_name
);
9638 section
->name
= section
->uncompressed_name
;
9641 sec
= find_section (section
->compressed_name
);
9643 section
->name
= section
->compressed_name
;
9648 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
9652 free_debug_section (enum dwarf_section_display_enum debug
)
9654 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
9656 if (section
->start
== NULL
)
9659 free ((char *) section
->start
);
9660 section
->start
= NULL
;
9661 section
->address
= 0;
9666 display_debug_section (Elf_Internal_Shdr
* section
, FILE * file
)
9668 char * name
= SECTION_NAME (section
);
9669 bfd_size_type length
;
9673 length
= section
->sh_size
;
9676 printf (_("\nSection '%s' has no debugging data.\n"), name
);
9679 if (section
->sh_type
== SHT_NOBITS
)
9681 /* There is no point in dumping the contents of a debugging section
9682 which has the NOBITS type - the bits in the file will be random.
9683 This can happen when a file containing a .eh_frame section is
9684 stripped with the --only-keep-debug command line option. */
9685 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name
);
9689 if (const_strneq (name
, ".gnu.linkonce.wi."))
9690 name
= ".debug_info";
9692 /* See if we know how to display the contents of this section. */
9693 for (i
= 0; i
< max
; i
++)
9694 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
9695 || streq (debug_displays
[i
].section
.compressed_name
, name
))
9697 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
9698 int secondary
= (section
!= find_section (name
));
9701 free_debug_section ((enum dwarf_section_display_enum
) i
);
9703 if (streq (sec
->uncompressed_name
, name
))
9704 sec
->name
= sec
->uncompressed_name
;
9706 sec
->name
= sec
->compressed_name
;
9707 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
9710 result
&= debug_displays
[i
].display (sec
, file
);
9712 if (secondary
|| (i
!= info
&& i
!= abbrev
))
9713 free_debug_section ((enum dwarf_section_display_enum
) i
);
9721 printf (_("Unrecognized debug section: %s\n"), name
);
9728 /* Set DUMP_SECTS for all sections where dumps were requested
9729 based on section name. */
9732 initialise_dumps_byname (void)
9734 struct dump_list_entry
* cur
;
9736 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
9741 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
9742 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
9744 request_dump_bynumber (i
, cur
->type
);
9749 warn (_("Section '%s' was not dumped because it does not exist!\n"),
9755 process_section_contents (FILE * file
)
9757 Elf_Internal_Shdr
* section
;
9763 initialise_dumps_byname ();
9765 for (i
= 0, section
= section_headers
;
9766 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
9769 #ifdef SUPPORT_DISASSEMBLY
9770 if (dump_sects
[i
] & DISASS_DUMP
)
9771 disassemble_section (section
, file
);
9773 if (dump_sects
[i
] & HEX_DUMP
)
9774 dump_section_as_bytes (section
, file
, FALSE
);
9776 if (dump_sects
[i
] & RELOC_DUMP
)
9777 dump_section_as_bytes (section
, file
, TRUE
);
9779 if (dump_sects
[i
] & STRING_DUMP
)
9780 dump_section_as_strings (section
, file
);
9782 if (dump_sects
[i
] & DEBUG_DUMP
)
9783 display_debug_section (section
, file
);
9786 /* Check to see if the user requested a
9787 dump of a section that does not exist. */
9788 while (i
++ < num_dump_sects
)
9790 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
9794 process_mips_fpe_exception (int mask
)
9799 if (mask
& OEX_FPU_INEX
)
9800 fputs ("INEX", stdout
), first
= 0;
9801 if (mask
& OEX_FPU_UFLO
)
9802 printf ("%sUFLO", first
? "" : "|"), first
= 0;
9803 if (mask
& OEX_FPU_OFLO
)
9804 printf ("%sOFLO", first
? "" : "|"), first
= 0;
9805 if (mask
& OEX_FPU_DIV0
)
9806 printf ("%sDIV0", first
? "" : "|"), first
= 0;
9807 if (mask
& OEX_FPU_INVAL
)
9808 printf ("%sINVAL", first
? "" : "|");
9811 fputs ("0", stdout
);
9814 /* ARM EABI attributes section. */
9819 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
9821 const char ** table
;
9822 } arm_attr_public_tag
;
9824 static const char * arm_attr_tag_CPU_arch
[] =
9825 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
9826 "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
9827 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
9828 static const char * arm_attr_tag_THUMB_ISA_use
[] =
9829 {"No", "Thumb-1", "Thumb-2"};
9830 static const char * arm_attr_tag_FP_arch
[] =
9831 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
9832 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
9833 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
9834 {"No", "NEONv1", "NEONv1 with Fused-MAC"};
9835 static const char * arm_attr_tag_PCS_config
[] =
9836 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
9837 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
9838 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
9839 {"V6", "SB", "TLS", "Unused"};
9840 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
9841 {"Absolute", "PC-relative", "SB-relative", "None"};
9842 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
9843 {"Absolute", "PC-relative", "None"};
9844 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
9845 {"None", "direct", "GOT-indirect"};
9846 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
9847 {"None", "??? 1", "2", "??? 3", "4"};
9848 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
9849 static const char * arm_attr_tag_ABI_FP_denormal
[] =
9850 {"Unused", "Needed", "Sign only"};
9851 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
9852 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
9853 static const char * arm_attr_tag_ABI_FP_number_model
[] =
9854 {"Unused", "Finite", "RTABI", "IEEE 754"};
9855 static const char * arm_attr_tag_ABI_enum_size
[] =
9856 {"Unused", "small", "int", "forced to int"};
9857 static const char * arm_attr_tag_ABI_HardFP_use
[] =
9858 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
9859 static const char * arm_attr_tag_ABI_VFP_args
[] =
9860 {"AAPCS", "VFP registers", "custom"};
9861 static const char * arm_attr_tag_ABI_WMMX_args
[] =
9862 {"AAPCS", "WMMX registers", "custom"};
9863 static const char * arm_attr_tag_ABI_optimization_goals
[] =
9864 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
9865 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
9866 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
9867 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
9868 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
9869 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
9870 static const char * arm_attr_tag_FP_HP_extension
[] =
9871 {"Not Allowed", "Allowed"};
9872 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
9873 {"None", "IEEE 754", "Alternative Format"};
9874 static const char * arm_attr_tag_MPextension_use
[] =
9875 {"Not Allowed", "Allowed"};
9876 static const char * arm_attr_tag_DIV_use
[] =
9877 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
9878 "Allowed in v7-A with integer division extension"};
9879 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
9880 static const char * arm_attr_tag_Virtualization_use
[] =
9881 {"Not Allowed", "TrustZone", "Virtualization Extensions",
9882 "TrustZone and Virtualization Extensions"};
9883 static const char * arm_attr_tag_MPextension_use_legacy
[] =
9884 {"Not Allowed", "Allowed"};
9886 #define LOOKUP(id, name) \
9887 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
9888 static arm_attr_public_tag arm_attr_public_tags
[] =
9890 {4, "CPU_raw_name", 1, NULL
},
9891 {5, "CPU_name", 1, NULL
},
9892 LOOKUP(6, CPU_arch
),
9893 {7, "CPU_arch_profile", 0, NULL
},
9894 LOOKUP(8, ARM_ISA_use
),
9895 LOOKUP(9, THUMB_ISA_use
),
9896 LOOKUP(10, FP_arch
),
9897 LOOKUP(11, WMMX_arch
),
9898 LOOKUP(12, Advanced_SIMD_arch
),
9899 LOOKUP(13, PCS_config
),
9900 LOOKUP(14, ABI_PCS_R9_use
),
9901 LOOKUP(15, ABI_PCS_RW_data
),
9902 LOOKUP(16, ABI_PCS_RO_data
),
9903 LOOKUP(17, ABI_PCS_GOT_use
),
9904 LOOKUP(18, ABI_PCS_wchar_t
),
9905 LOOKUP(19, ABI_FP_rounding
),
9906 LOOKUP(20, ABI_FP_denormal
),
9907 LOOKUP(21, ABI_FP_exceptions
),
9908 LOOKUP(22, ABI_FP_user_exceptions
),
9909 LOOKUP(23, ABI_FP_number_model
),
9910 {24, "ABI_align_needed", 0, NULL
},
9911 {25, "ABI_align_preserved", 0, NULL
},
9912 LOOKUP(26, ABI_enum_size
),
9913 LOOKUP(27, ABI_HardFP_use
),
9914 LOOKUP(28, ABI_VFP_args
),
9915 LOOKUP(29, ABI_WMMX_args
),
9916 LOOKUP(30, ABI_optimization_goals
),
9917 LOOKUP(31, ABI_FP_optimization_goals
),
9918 {32, "compatibility", 0, NULL
},
9919 LOOKUP(34, CPU_unaligned_access
),
9920 LOOKUP(36, FP_HP_extension
),
9921 LOOKUP(38, ABI_FP_16bit_format
),
9922 LOOKUP(42, MPextension_use
),
9923 LOOKUP(44, DIV_use
),
9924 {64, "nodefaults", 0, NULL
},
9925 {65, "also_compatible_with", 0, NULL
},
9926 LOOKUP(66, T2EE_use
),
9927 {67, "conformance", 1, NULL
},
9928 LOOKUP(68, Virtualization_use
),
9929 LOOKUP(70, MPextension_use_legacy
)
9933 static unsigned char *
9934 display_arm_attribute (unsigned char * p
)
9939 arm_attr_public_tag
* attr
;
9943 tag
= read_uleb128 (p
, &len
);
9946 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
9948 if (arm_attr_public_tags
[i
].tag
== tag
)
9950 attr
= &arm_attr_public_tags
[i
];
9957 printf (" Tag_%s: ", attr
->name
);
9963 case 7: /* Tag_CPU_arch_profile. */
9964 val
= read_uleb128 (p
, &len
);
9968 case 0: printf (_("None\n")); break;
9969 case 'A': printf (_("Application\n")); break;
9970 case 'R': printf (_("Realtime\n")); break;
9971 case 'M': printf (_("Microcontroller\n")); break;
9972 case 'S': printf (_("Application or Realtime\n")); break;
9973 default: printf ("??? (%d)\n", val
); break;
9977 case 24: /* Tag_align_needed. */
9978 val
= read_uleb128 (p
, &len
);
9982 case 0: printf (_("None\n")); break;
9983 case 1: printf (_("8-byte\n")); break;
9984 case 2: printf (_("4-byte\n")); break;
9985 case 3: printf ("??? 3\n"); break;
9988 printf (_("8-byte and up to %d-byte extended\n"),
9991 printf ("??? (%d)\n", val
);
9996 case 25: /* Tag_align_preserved. */
9997 val
= read_uleb128 (p
, &len
);
10001 case 0: printf (_("None\n")); break;
10002 case 1: printf (_("8-byte, except leaf SP\n")); break;
10003 case 2: printf (_("8-byte\n")); break;
10004 case 3: printf ("??? 3\n"); break;
10007 printf (_("8-byte and up to %d-byte extended\n"),
10010 printf ("??? (%d)\n", val
);
10015 case 32: /* Tag_compatibility. */
10016 val
= read_uleb128 (p
, &len
);
10018 printf (_("flag = %d, vendor = %s\n"), val
, p
);
10019 p
+= strlen ((char *) p
) + 1;
10022 case 64: /* Tag_nodefaults. */
10024 printf (_("True\n"));
10027 case 65: /* Tag_also_compatible_with. */
10028 val
= read_uleb128 (p
, &len
);
10030 if (val
== 6 /* Tag_CPU_arch. */)
10032 val
= read_uleb128 (p
, &len
);
10034 if ((unsigned int)val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
10035 printf ("??? (%d)\n", val
);
10037 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
10041 while (*(p
++) != '\0' /* NUL terminator. */);
10055 assert (attr
->type
& 0x80);
10056 val
= read_uleb128 (p
, &len
);
10058 type
= attr
->type
& 0x7f;
10060 printf ("??? (%d)\n", val
);
10062 printf ("%s\n", attr
->table
[val
]);
10069 type
= 1; /* String. */
10071 type
= 2; /* uleb128. */
10072 printf (" Tag_unknown_%d: ", tag
);
10077 printf ("\"%s\"\n", p
);
10078 p
+= strlen ((char *) p
) + 1;
10082 val
= read_uleb128 (p
, &len
);
10084 printf ("%d (0x%x)\n", val
, val
);
10090 static unsigned char *
10091 display_gnu_attribute (unsigned char * p
,
10092 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
10099 tag
= read_uleb128 (p
, &len
);
10102 /* Tag_compatibility is the only generic GNU attribute defined at
10106 val
= read_uleb128 (p
, &len
);
10108 printf (_("flag = %d, vendor = %s\n"), val
, p
);
10109 p
+= strlen ((char *) p
) + 1;
10113 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
10114 return display_proc_gnu_attribute (p
, tag
);
10117 type
= 1; /* String. */
10119 type
= 2; /* uleb128. */
10120 printf (" Tag_unknown_%d: ", tag
);
10124 printf ("\"%s\"\n", p
);
10125 p
+= strlen ((char *) p
) + 1;
10129 val
= read_uleb128 (p
, &len
);
10131 printf ("%d (0x%x)\n", val
, val
);
10137 static unsigned char *
10138 display_power_gnu_attribute (unsigned char * p
, int tag
)
10144 if (tag
== Tag_GNU_Power_ABI_FP
)
10146 val
= read_uleb128 (p
, &len
);
10148 printf (" Tag_GNU_Power_ABI_FP: ");
10153 printf (_("Hard or soft float\n"));
10156 printf (_("Hard float\n"));
10159 printf (_("Soft float\n"));
10162 printf (_("Single-precision hard float\n"));
10165 printf ("??? (%d)\n", val
);
10171 if (tag
== Tag_GNU_Power_ABI_Vector
)
10173 val
= read_uleb128 (p
, &len
);
10175 printf (" Tag_GNU_Power_ABI_Vector: ");
10179 printf (_("Any\n"));
10182 printf (_("Generic\n"));
10185 printf ("AltiVec\n");
10191 printf ("??? (%d)\n", val
);
10197 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
10199 val
= read_uleb128 (p
, &len
);
10201 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
10205 printf (_("Any\n"));
10208 printf ("r3/r4\n");
10211 printf (_("Memory\n"));
10214 printf ("??? (%d)\n", val
);
10221 type
= 1; /* String. */
10223 type
= 2; /* uleb128. */
10224 printf (" Tag_unknown_%d: ", tag
);
10228 printf ("\"%s\"\n", p
);
10229 p
+= strlen ((char *) p
) + 1;
10233 val
= read_uleb128 (p
, &len
);
10235 printf ("%d (0x%x)\n", val
, val
);
10241 static unsigned char *
10242 display_mips_gnu_attribute (unsigned char * p
, int tag
)
10248 if (tag
== Tag_GNU_MIPS_ABI_FP
)
10250 val
= read_uleb128 (p
, &len
);
10252 printf (" Tag_GNU_MIPS_ABI_FP: ");
10257 printf (_("Hard or soft float\n"));
10260 printf (_("Hard float (double precision)\n"));
10263 printf (_("Hard float (single precision)\n"));
10266 printf (_("Soft float\n"));
10269 printf (_("64-bit float (-mips32r2 -mfp64)\n"));
10272 printf ("??? (%d)\n", val
);
10279 type
= 1; /* String. */
10281 type
= 2; /* uleb128. */
10282 printf (" Tag_unknown_%d: ", tag
);
10286 printf ("\"%s\"\n", p
);
10287 p
+= strlen ((char *) p
) + 1;
10291 val
= read_uleb128 (p
, &len
);
10293 printf ("%d (0x%x)\n", val
, val
);
10300 process_attributes (FILE * file
,
10301 const char * public_name
,
10302 unsigned int proc_type
,
10303 unsigned char * (* display_pub_attribute
) (unsigned char *),
10304 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
10306 Elf_Internal_Shdr
* sect
;
10307 unsigned char * contents
;
10309 unsigned char * end
;
10310 bfd_vma section_len
;
10314 /* Find the section header so that we get the size. */
10315 for (i
= 0, sect
= section_headers
;
10316 i
< elf_header
.e_shnum
;
10319 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
10322 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
10323 sect
->sh_size
, _("attributes"));
10324 if (contents
== NULL
)
10330 len
= sect
->sh_size
- 1;
10336 bfd_boolean public_section
;
10337 bfd_boolean gnu_section
;
10339 section_len
= byte_get (p
, 4);
10342 if (section_len
> len
)
10344 printf (_("ERROR: Bad section length (%d > %d)\n"),
10345 (int) section_len
, (int) len
);
10349 len
-= section_len
;
10350 printf (_("Attribute Section: %s\n"), p
);
10352 if (public_name
&& streq ((char *) p
, public_name
))
10353 public_section
= TRUE
;
10355 public_section
= FALSE
;
10357 if (streq ((char *) p
, "gnu"))
10358 gnu_section
= TRUE
;
10360 gnu_section
= FALSE
;
10362 namelen
= strlen ((char *) p
) + 1;
10364 section_len
-= namelen
+ 4;
10366 while (section_len
> 0)
10372 size
= byte_get (p
, 4);
10373 if (size
> section_len
)
10375 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
10376 (int) size
, (int) section_len
);
10377 size
= section_len
;
10380 section_len
-= size
;
10381 end
= p
+ size
- 1;
10387 printf (_("File Attributes\n"));
10390 printf (_("Section Attributes:"));
10393 printf (_("Symbol Attributes:"));
10399 val
= read_uleb128 (p
, &j
);
10403 printf (" %d", val
);
10408 printf (_("Unknown tag: %d\n"), tag
);
10409 public_section
= FALSE
;
10413 if (public_section
)
10416 p
= display_pub_attribute (p
);
10418 else if (gnu_section
)
10421 p
= display_gnu_attribute (p
,
10422 display_proc_gnu_attribute
);
10426 /* ??? Do something sensible, like dump hex. */
10427 printf (_(" Unknown section contexts\n"));
10434 printf (_("Unknown format '%c'\n"), *p
);
10442 process_arm_specific (FILE * file
)
10444 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
10445 display_arm_attribute
, NULL
);
10449 process_power_specific (FILE * file
)
10451 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
10452 display_power_gnu_attribute
);
10455 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
10456 Print the Address, Access and Initial fields of an entry at VMA ADDR
10457 and return the VMA of the next entry. */
10460 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
10463 print_vma (addr
, LONG_HEX
);
10465 if (addr
< pltgot
+ 0xfff0)
10466 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
10468 printf ("%10s", "");
10471 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
10476 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
10477 print_vma (entry
, LONG_HEX
);
10479 return addr
+ (is_32bit_elf
? 4 : 8);
10482 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
10483 PLTGOT. Print the Address and Initial fields of an entry at VMA
10484 ADDR and return the VMA of the next entry. */
10487 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
10490 print_vma (addr
, LONG_HEX
);
10493 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
10498 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
10499 print_vma (entry
, LONG_HEX
);
10501 return addr
+ (is_32bit_elf
? 4 : 8);
10505 process_mips_specific (FILE * file
)
10507 Elf_Internal_Dyn
* entry
;
10508 size_t liblist_offset
= 0;
10509 size_t liblistno
= 0;
10510 size_t conflictsno
= 0;
10511 size_t options_offset
= 0;
10512 size_t conflicts_offset
= 0;
10513 size_t pltrelsz
= 0;
10515 bfd_vma pltgot
= 0;
10516 bfd_vma mips_pltgot
= 0;
10517 bfd_vma jmprel
= 0;
10518 bfd_vma local_gotno
= 0;
10519 bfd_vma gotsym
= 0;
10520 bfd_vma symtabno
= 0;
10522 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
10523 display_mips_gnu_attribute
);
10525 /* We have a lot of special sections. Thanks SGI! */
10526 if (dynamic_section
== NULL
)
10527 /* No information available. */
10530 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
10531 switch (entry
->d_tag
)
10533 case DT_MIPS_LIBLIST
:
10535 = offset_from_vma (file
, entry
->d_un
.d_val
,
10536 liblistno
* sizeof (Elf32_External_Lib
));
10538 case DT_MIPS_LIBLISTNO
:
10539 liblistno
= entry
->d_un
.d_val
;
10541 case DT_MIPS_OPTIONS
:
10542 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
10544 case DT_MIPS_CONFLICT
:
10546 = offset_from_vma (file
, entry
->d_un
.d_val
,
10547 conflictsno
* sizeof (Elf32_External_Conflict
));
10549 case DT_MIPS_CONFLICTNO
:
10550 conflictsno
= entry
->d_un
.d_val
;
10553 pltgot
= entry
->d_un
.d_ptr
;
10555 case DT_MIPS_LOCAL_GOTNO
:
10556 local_gotno
= entry
->d_un
.d_val
;
10558 case DT_MIPS_GOTSYM
:
10559 gotsym
= entry
->d_un
.d_val
;
10561 case DT_MIPS_SYMTABNO
:
10562 symtabno
= entry
->d_un
.d_val
;
10564 case DT_MIPS_PLTGOT
:
10565 mips_pltgot
= entry
->d_un
.d_ptr
;
10568 pltrel
= entry
->d_un
.d_val
;
10571 pltrelsz
= entry
->d_un
.d_val
;
10574 jmprel
= entry
->d_un
.d_ptr
;
10580 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
10582 Elf32_External_Lib
* elib
;
10585 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
10587 sizeof (Elf32_External_Lib
),
10591 printf (_("\nSection '.liblist' contains %lu entries:\n"),
10592 (unsigned long) liblistno
);
10593 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
10596 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
10603 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
10604 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
10605 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
10606 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
10607 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
10609 tmp
= gmtime (&atime
);
10610 snprintf (timebuf
, sizeof (timebuf
),
10611 "%04u-%02u-%02uT%02u:%02u:%02u",
10612 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10613 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10615 printf ("%3lu: ", (unsigned long) cnt
);
10616 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
10617 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
10619 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
10620 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
10621 liblist
.l_version
);
10623 if (liblist
.l_flags
== 0)
10627 static const struct
10634 { " EXACT_MATCH", LL_EXACT_MATCH
},
10635 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
10636 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
10637 { " EXPORTS", LL_EXPORTS
},
10638 { " DELAY_LOAD", LL_DELAY_LOAD
},
10639 { " DELTA", LL_DELTA
}
10641 int flags
= liblist
.l_flags
;
10644 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
10645 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
10647 fputs (l_flags_vals
[fcnt
].name
, stdout
);
10648 flags
^= l_flags_vals
[fcnt
].bit
;
10651 printf (" %#x", (unsigned int) flags
);
10661 if (options_offset
!= 0)
10663 Elf_External_Options
* eopt
;
10664 Elf_Internal_Shdr
* sect
= section_headers
;
10665 Elf_Internal_Options
* iopt
;
10666 Elf_Internal_Options
* option
;
10670 /* Find the section header so that we get the size. */
10671 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
10674 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
10675 sect
->sh_size
, _("options"));
10678 iopt
= (Elf_Internal_Options
*)
10679 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
10682 error (_("Out of memory\n"));
10689 while (offset
< sect
->sh_size
)
10691 Elf_External_Options
* eoption
;
10693 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
10695 option
->kind
= BYTE_GET (eoption
->kind
);
10696 option
->size
= BYTE_GET (eoption
->size
);
10697 option
->section
= BYTE_GET (eoption
->section
);
10698 option
->info
= BYTE_GET (eoption
->info
);
10700 offset
+= option
->size
;
10706 printf (_("\nSection '%s' contains %d entries:\n"),
10707 SECTION_NAME (sect
), cnt
);
10715 switch (option
->kind
)
10718 /* This shouldn't happen. */
10719 printf (" NULL %d %lx", option
->section
, option
->info
);
10722 printf (" REGINFO ");
10723 if (elf_header
.e_machine
== EM_MIPS
)
10726 Elf32_External_RegInfo
* ereg
;
10727 Elf32_RegInfo reginfo
;
10729 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
10730 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
10731 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
10732 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
10733 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
10734 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
10735 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
10737 printf ("GPR %08lx GP 0x%lx\n",
10738 reginfo
.ri_gprmask
,
10739 (unsigned long) reginfo
.ri_gp_value
);
10740 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
10741 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
10742 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
10747 Elf64_External_RegInfo
* ereg
;
10748 Elf64_Internal_RegInfo reginfo
;
10750 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
10751 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
10752 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
10753 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
10754 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
10755 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
10756 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
10758 printf ("GPR %08lx GP 0x",
10759 reginfo
.ri_gprmask
);
10760 printf_vma (reginfo
.ri_gp_value
);
10763 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
10764 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
10765 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
10769 case ODK_EXCEPTIONS
:
10770 fputs (" EXCEPTIONS fpe_min(", stdout
);
10771 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
10772 fputs (") fpe_max(", stdout
);
10773 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
10774 fputs (")", stdout
);
10776 if (option
->info
& OEX_PAGE0
)
10777 fputs (" PAGE0", stdout
);
10778 if (option
->info
& OEX_SMM
)
10779 fputs (" SMM", stdout
);
10780 if (option
->info
& OEX_FPDBUG
)
10781 fputs (" FPDBUG", stdout
);
10782 if (option
->info
& OEX_DISMISS
)
10783 fputs (" DISMISS", stdout
);
10786 fputs (" PAD ", stdout
);
10787 if (option
->info
& OPAD_PREFIX
)
10788 fputs (" PREFIX", stdout
);
10789 if (option
->info
& OPAD_POSTFIX
)
10790 fputs (" POSTFIX", stdout
);
10791 if (option
->info
& OPAD_SYMBOL
)
10792 fputs (" SYMBOL", stdout
);
10795 fputs (" HWPATCH ", stdout
);
10796 if (option
->info
& OHW_R4KEOP
)
10797 fputs (" R4KEOP", stdout
);
10798 if (option
->info
& OHW_R8KPFETCH
)
10799 fputs (" R8KPFETCH", stdout
);
10800 if (option
->info
& OHW_R5KEOP
)
10801 fputs (" R5KEOP", stdout
);
10802 if (option
->info
& OHW_R5KCVTL
)
10803 fputs (" R5KCVTL", stdout
);
10806 fputs (" FILL ", stdout
);
10807 /* XXX Print content of info word? */
10810 fputs (" TAGS ", stdout
);
10811 /* XXX Print content of info word? */
10814 fputs (" HWAND ", stdout
);
10815 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
10816 fputs (" R4KEOP_CHECKED", stdout
);
10817 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
10818 fputs (" R4KEOP_CLEAN", stdout
);
10821 fputs (" HWOR ", stdout
);
10822 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
10823 fputs (" R4KEOP_CHECKED", stdout
);
10824 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
10825 fputs (" R4KEOP_CLEAN", stdout
);
10828 printf (" GP_GROUP %#06lx self-contained %#06lx",
10829 option
->info
& OGP_GROUP
,
10830 (option
->info
& OGP_SELF
) >> 16);
10833 printf (" IDENT %#06lx self-contained %#06lx",
10834 option
->info
& OGP_GROUP
,
10835 (option
->info
& OGP_SELF
) >> 16);
10838 /* This shouldn't happen. */
10839 printf (" %3d ??? %d %lx",
10840 option
->kind
, option
->section
, option
->info
);
10844 len
= sizeof (* eopt
);
10845 while (len
< option
->size
)
10846 if (((char *) option
)[len
] >= ' '
10847 && ((char *) option
)[len
] < 0x7f)
10848 printf ("%c", ((char *) option
)[len
++]);
10850 printf ("\\%03o", ((char *) option
)[len
++]);
10852 fputs ("\n", stdout
);
10860 if (conflicts_offset
!= 0 && conflictsno
!= 0)
10862 Elf32_Conflict
* iconf
;
10865 if (dynamic_symbols
== NULL
)
10867 error (_("conflict list found without a dynamic symbol table\n"));
10871 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
10874 error (_("Out of memory\n"));
10880 Elf32_External_Conflict
* econf32
;
10882 econf32
= (Elf32_External_Conflict
*)
10883 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
10884 sizeof (* econf32
), _("conflict"));
10888 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10889 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
10895 Elf64_External_Conflict
* econf64
;
10897 econf64
= (Elf64_External_Conflict
*)
10898 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
10899 sizeof (* econf64
), _("conflict"));
10903 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10904 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
10909 printf (_("\nSection '.conflict' contains %lu entries:\n"),
10910 (unsigned long) conflictsno
);
10911 puts (_(" Num: Index Value Name"));
10913 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10915 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
10917 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
10918 print_vma (psym
->st_value
, FULL_HEX
);
10920 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10921 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10923 printf (_("<corrupt: %14ld>"), psym
->st_name
);
10930 if (pltgot
!= 0 && local_gotno
!= 0)
10932 bfd_vma ent
, local_end
, global_end
;
10934 unsigned char * data
;
10938 addr_size
= (is_32bit_elf
? 4 : 8);
10939 local_end
= pltgot
+ local_gotno
* addr_size
;
10940 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
10942 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
10943 data
= (unsigned char *) get_data (NULL
, file
, offset
,
10944 global_end
- pltgot
, 1, _("GOT"));
10945 printf (_("\nPrimary GOT:\n"));
10946 printf (_(" Canonical gp value: "));
10947 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
10950 printf (_(" Reserved entries:\n"));
10951 printf (_(" %*s %10s %*s Purpose\n"),
10952 addr_size
* 2, _("Address"), _("Access"),
10953 addr_size
* 2, _("Initial"));
10954 ent
= print_mips_got_entry (data
, pltgot
, ent
);
10955 printf (_(" Lazy resolver\n"));
10957 && (byte_get (data
+ ent
- pltgot
, addr_size
)
10958 >> (addr_size
* 8 - 1)) != 0)
10960 ent
= print_mips_got_entry (data
, pltgot
, ent
);
10961 printf (_(" Module pointer (GNU extension)\n"));
10965 if (ent
< local_end
)
10967 printf (_(" Local entries:\n"));
10968 printf (_(" %*s %10s %*s\n"),
10969 addr_size
* 2, _("Address"), _("Access"),
10970 addr_size
* 2, _("Initial"));
10971 while (ent
< local_end
)
10973 ent
= print_mips_got_entry (data
, pltgot
, ent
);
10979 if (gotsym
< symtabno
)
10983 printf (_(" Global entries:\n"));
10984 printf (_(" %*s %10s %*s %*s %-7s %3s %s\n"),
10985 addr_size
* 2, _("Address"), _("Access"),
10986 addr_size
* 2, _("Initial"),
10987 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
10988 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
10989 for (i
= gotsym
; i
< symtabno
; i
++)
10991 Elf_Internal_Sym
* psym
;
10993 psym
= dynamic_symbols
+ i
;
10994 ent
= print_mips_got_entry (data
, pltgot
, ent
);
10996 print_vma (psym
->st_value
, LONG_HEX
);
10997 printf (" %-7s %3s ",
10998 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
10999 get_symbol_index_type (psym
->st_shndx
));
11000 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11001 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
11003 printf (_("<corrupt: %14ld>"), psym
->st_name
);
11013 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
11016 size_t offset
, rel_offset
;
11017 unsigned long count
, i
;
11018 unsigned char * data
;
11019 int addr_size
, sym_width
;
11020 Elf_Internal_Rela
* rels
;
11022 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
11023 if (pltrel
== DT_RELA
)
11025 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
11030 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
11035 addr_size
= (is_32bit_elf
? 4 : 8);
11036 end
= mips_pltgot
+ (2 + count
) * addr_size
;
11038 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
11039 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
11041 printf (_("\nPLT GOT:\n\n"));
11042 printf (_(" Reserved entries:\n"));
11043 printf (_(" %*s %*s Purpose\n"),
11044 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
11045 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
11046 printf (_(" PLT lazy resolver\n"));
11047 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
11048 printf (_(" Module pointer\n"));
11051 printf (_(" Entries:\n"));
11052 printf (_(" %*s %*s %*s %-7s %3s %s\n"),
11053 addr_size
* 2, _("Address"),
11054 addr_size
* 2, _("Initial"),
11055 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
11056 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
11057 for (i
= 0; i
< count
; i
++)
11059 Elf_Internal_Sym
* psym
;
11061 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
11062 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
11064 print_vma (psym
->st_value
, LONG_HEX
);
11065 printf (" %-7s %3s ",
11066 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
11067 get_symbol_index_type (psym
->st_shndx
));
11068 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11069 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
11071 printf (_("<corrupt: %14ld>"), psym
->st_name
);
11085 process_gnu_liblist (FILE * file
)
11087 Elf_Internal_Shdr
* section
;
11088 Elf_Internal_Shdr
* string_sec
;
11089 Elf32_External_Lib
* elib
;
11091 size_t strtab_size
;
11098 for (i
= 0, section
= section_headers
;
11099 i
< elf_header
.e_shnum
;
11102 switch (section
->sh_type
)
11104 case SHT_GNU_LIBLIST
:
11105 if (section
->sh_link
>= elf_header
.e_shnum
)
11108 elib
= (Elf32_External_Lib
*)
11109 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
11114 string_sec
= section_headers
+ section
->sh_link
;
11116 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
11117 string_sec
->sh_size
,
11118 _("liblist string table"));
11119 strtab_size
= string_sec
->sh_size
;
11122 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
11128 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
11129 SECTION_NAME (section
),
11130 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
11132 puts (_(" Library Time Stamp Checksum Version Flags"));
11134 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
11142 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11143 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11144 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11145 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11146 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11148 tmp
= gmtime (&atime
);
11149 snprintf (timebuf
, sizeof (timebuf
),
11150 "%04u-%02u-%02uT%02u:%02u:%02u",
11151 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11152 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11154 printf ("%3lu: ", (unsigned long) cnt
);
11156 printf ("%-20s", liblist
.l_name
< strtab_size
11157 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
11159 printf ("%-20.20s", liblist
.l_name
< strtab_size
11160 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
11161 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
11162 liblist
.l_version
, liblist
.l_flags
);
11172 static const char *
11173 get_note_type (unsigned e_type
)
11175 static char buff
[64];
11177 if (elf_header
.e_type
== ET_CORE
)
11181 return _("NT_AUXV (auxiliary vector)");
11183 return _("NT_PRSTATUS (prstatus structure)");
11185 return _("NT_FPREGSET (floating point registers)");
11187 return _("NT_PRPSINFO (prpsinfo structure)");
11188 case NT_TASKSTRUCT
:
11189 return _("NT_TASKSTRUCT (task structure)");
11191 return _("NT_PRXFPREG (user_xfpregs structure)");
11193 return _("NT_PPC_VMX (ppc Altivec registers)");
11195 return _("NT_PPC_VSX (ppc VSX registers)");
11196 case NT_X86_XSTATE
:
11197 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
11198 case NT_S390_HIGH_GPRS
:
11199 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
11200 case NT_S390_TIMER
:
11201 return _("NT_S390_TIMER (s390 timer register)");
11202 case NT_S390_TODCMP
:
11203 return _("NT_S390_TODCMP (s390 TOD comparator register)");
11204 case NT_S390_TODPREG
:
11205 return _("NT_S390_TODPREG (s390 TOD programmable register)");
11207 return _("NT_S390_CTRS (s390 control registers)");
11208 case NT_S390_PREFIX
:
11209 return _("NT_S390_PREFIX (s390 prefix register)");
11211 return _("NT_PSTATUS (pstatus structure)");
11213 return _("NT_FPREGS (floating point registers)");
11215 return _("NT_PSINFO (psinfo structure)");
11217 return _("NT_LWPSTATUS (lwpstatus_t structure)");
11219 return _("NT_LWPSINFO (lwpsinfo_t structure)");
11220 case NT_WIN32PSTATUS
:
11221 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11229 return _("NT_VERSION (version)");
11231 return _("NT_ARCH (architecture)");
11236 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11240 static const char *
11241 get_gnu_elf_note_type (unsigned e_type
)
11243 static char buff
[64];
11247 case NT_GNU_ABI_TAG
:
11248 return _("NT_GNU_ABI_TAG (ABI version tag)");
11250 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
11251 case NT_GNU_BUILD_ID
:
11252 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
11253 case NT_GNU_GOLD_VERSION
:
11254 return _("NT_GNU_GOLD_VERSION (gold version)");
11259 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11263 static const char *
11264 get_netbsd_elfcore_note_type (unsigned e_type
)
11266 static char buff
[64];
11268 if (e_type
== NT_NETBSDCORE_PROCINFO
)
11270 /* NetBSD core "procinfo" structure. */
11271 return _("NetBSD procinfo structure");
11274 /* As of Jan 2002 there are no other machine-independent notes
11275 defined for NetBSD core files. If the note type is less
11276 than the start of the machine-dependent note types, we don't
11279 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
11281 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11285 switch (elf_header
.e_machine
)
11287 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
11288 and PT_GETFPREGS == mach+2. */
11293 case EM_SPARC32PLUS
:
11297 case NT_NETBSDCORE_FIRSTMACH
+ 0:
11298 return _("PT_GETREGS (reg structure)");
11299 case NT_NETBSDCORE_FIRSTMACH
+ 2:
11300 return _("PT_GETFPREGS (fpreg structure)");
11306 /* On all other arch's, PT_GETREGS == mach+1 and
11307 PT_GETFPREGS == mach+3. */
11311 case NT_NETBSDCORE_FIRSTMACH
+ 1:
11312 return _("PT_GETREGS (reg structure)");
11313 case NT_NETBSDCORE_FIRSTMACH
+ 3:
11314 return _("PT_GETFPREGS (fpreg structure)");
11320 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
11321 e_type
- NT_NETBSDCORE_FIRSTMACH
);
11325 /* Note that by the ELF standard, the name field is already null byte
11326 terminated, and namesz includes the terminating null byte.
11327 I.E. the value of namesz for the name "FSF" is 4.
11329 If the value of namesz is zero, there is no name present. */
11331 process_note (Elf_Internal_Note
* pnote
)
11333 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
11336 if (pnote
->namesz
== 0)
11337 /* If there is no note name, then use the default set of
11338 note type strings. */
11339 nt
= get_note_type (pnote
->type
);
11341 else if (const_strneq (pnote
->namedata
, "GNU"))
11342 /* GNU-specific object file notes. */
11343 nt
= get_gnu_elf_note_type (pnote
->type
);
11345 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
11346 /* NetBSD-specific core file notes. */
11347 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
11349 else if (strneq (pnote
->namedata
, "SPU/", 4))
11351 /* SPU-specific core file notes. */
11352 nt
= pnote
->namedata
+ 4;
11357 /* Don't recognize this note name; just use the default set of
11358 note type strings. */
11359 nt
= get_note_type (pnote
->type
);
11361 printf (" %s\t\t0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
11367 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
11369 Elf_External_Note
* pnotes
;
11370 Elf_External_Note
* external
;
11376 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
11383 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
11384 (unsigned long) offset
, (unsigned long) length
);
11385 printf (_(" Owner\t\tData size\tDescription\n"));
11387 while (external
< (Elf_External_Note
*) ((char *) pnotes
+ length
))
11389 Elf_External_Note
* next
;
11390 Elf_Internal_Note inote
;
11391 char * temp
= NULL
;
11393 inote
.type
= BYTE_GET (external
->type
);
11394 inote
.namesz
= BYTE_GET (external
->namesz
);
11395 inote
.namedata
= external
->name
;
11396 inote
.descsz
= BYTE_GET (external
->descsz
);
11397 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
11398 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
11400 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
11402 if (((char *) next
) > (((char *) pnotes
) + length
))
11404 warn (_("corrupt note found at offset %lx into core notes\n"),
11405 (unsigned long) ((char *) external
- (char *) pnotes
));
11406 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
11407 inote
.type
, inote
.namesz
, inote
.descsz
);
11413 /* Verify that name is null terminated. It appears that at least
11414 one version of Linux (RedHat 6.0) generates corefiles that don't
11415 comply with the ELF spec by failing to include the null byte in
11417 if (inote
.namedata
[inote
.namesz
] != '\0')
11419 temp
= (char *) malloc (inote
.namesz
+ 1);
11423 error (_("Out of memory\n"));
11428 strncpy (temp
, inote
.namedata
, inote
.namesz
);
11429 temp
[inote
.namesz
] = 0;
11431 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
11432 inote
.namedata
= temp
;
11435 res
&= process_note (& inote
);
11450 process_corefile_note_segments (FILE * file
)
11452 Elf_Internal_Phdr
* segment
;
11456 if (! get_program_headers (file
))
11459 for (i
= 0, segment
= program_headers
;
11460 i
< elf_header
.e_phnum
;
11463 if (segment
->p_type
== PT_NOTE
)
11464 res
&= process_corefile_note_segment (file
,
11465 (bfd_vma
) segment
->p_offset
,
11466 (bfd_vma
) segment
->p_filesz
);
11473 process_note_sections (FILE * file
)
11475 Elf_Internal_Shdr
* section
;
11479 for (i
= 0, section
= section_headers
;
11480 i
< elf_header
.e_shnum
;
11482 if (section
->sh_type
== SHT_NOTE
)
11483 res
&= process_corefile_note_segment (file
,
11484 (bfd_vma
) section
->sh_offset
,
11485 (bfd_vma
) section
->sh_size
);
11491 process_notes (FILE * file
)
11493 /* If we have not been asked to display the notes then do nothing. */
11497 if (elf_header
.e_type
!= ET_CORE
)
11498 return process_note_sections (file
);
11500 /* No program headers means no NOTE segment. */
11501 if (elf_header
.e_phnum
> 0)
11502 return process_corefile_note_segments (file
);
11504 printf (_("No note segments present in the core file.\n"));
11509 process_arch_specific (FILE * file
)
11514 switch (elf_header
.e_machine
)
11517 return process_arm_specific (file
);
11519 case EM_MIPS_RS3_LE
:
11520 return process_mips_specific (file
);
11523 return process_power_specific (file
);
11532 get_file_header (FILE * file
)
11534 /* Read in the identity array. */
11535 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
11538 /* Determine how to read the rest of the header. */
11539 switch (elf_header
.e_ident
[EI_DATA
])
11541 default: /* fall through */
11542 case ELFDATANONE
: /* fall through */
11544 byte_get
= byte_get_little_endian
;
11545 byte_put
= byte_put_little_endian
;
11548 byte_get
= byte_get_big_endian
;
11549 byte_put
= byte_put_big_endian
;
11553 /* For now we only support 32 bit and 64 bit ELF files. */
11554 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
11556 /* Read in the rest of the header. */
11559 Elf32_External_Ehdr ehdr32
;
11561 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
11564 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
11565 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
11566 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
11567 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
11568 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
11569 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
11570 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
11571 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
11572 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
11573 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
11574 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
11575 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
11576 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
11580 Elf64_External_Ehdr ehdr64
;
11582 /* If we have been compiled with sizeof (bfd_vma) == 4, then
11583 we will not be able to cope with the 64bit data found in
11584 64 ELF files. Detect this now and abort before we start
11585 overwriting things. */
11586 if (sizeof (bfd_vma
) < 8)
11588 error (_("This instance of readelf has been built without support for a\n\
11589 64 bit data type and so it cannot read 64 bit ELF files.\n"));
11593 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
11596 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
11597 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
11598 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
11599 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
11600 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
11601 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
11602 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
11603 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
11604 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
11605 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
11606 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
11607 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
11608 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
11611 if (elf_header
.e_shoff
)
11613 /* There may be some extensions in the first section header. Don't
11614 bomb if we can't read it. */
11616 get_32bit_section_headers (file
, 1);
11618 get_64bit_section_headers (file
, 1);
11624 /* Process one ELF object file according to the command line options.
11625 This file may actually be stored in an archive. The file is
11626 positioned at the start of the ELF object. */
11629 process_object (char * file_name
, FILE * file
)
11633 if (! get_file_header (file
))
11635 error (_("%s: Failed to read file header\n"), file_name
);
11639 /* Initialise per file variables. */
11640 for (i
= ARRAY_SIZE (version_info
); i
--;)
11641 version_info
[i
] = 0;
11643 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
11644 dynamic_info
[i
] = 0;
11646 /* Process the file. */
11648 printf (_("\nFile: %s\n"), file_name
);
11650 /* Initialise the dump_sects array from the cmdline_dump_sects array.
11651 Note we do this even if cmdline_dump_sects is empty because we
11652 must make sure that the dump_sets array is zeroed out before each
11653 object file is processed. */
11654 if (num_dump_sects
> num_cmdline_dump_sects
)
11655 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
11657 if (num_cmdline_dump_sects
> 0)
11659 if (num_dump_sects
== 0)
11660 /* A sneaky way of allocating the dump_sects array. */
11661 request_dump_bynumber (num_cmdline_dump_sects
, 0);
11663 assert (num_dump_sects
>= num_cmdline_dump_sects
);
11664 memcpy (dump_sects
, cmdline_dump_sects
,
11665 num_cmdline_dump_sects
* sizeof (* dump_sects
));
11668 if (! process_file_header ())
11671 if (! process_section_headers (file
))
11673 /* Without loaded section headers we cannot process lots of
11675 do_unwind
= do_version
= do_dump
= do_arch
= 0;
11677 if (! do_using_dynamic
)
11678 do_syms
= do_dyn_syms
= do_reloc
= 0;
11681 if (! process_section_groups (file
))
11683 /* Without loaded section groups we cannot process unwind. */
11687 if (process_program_headers (file
))
11688 process_dynamic_section (file
);
11690 process_relocs (file
);
11692 process_unwind (file
);
11694 process_symbol_table (file
);
11696 process_syminfo (file
);
11698 process_version_sections (file
);
11700 process_section_contents (file
);
11702 process_notes (file
);
11704 process_gnu_liblist (file
);
11706 process_arch_specific (file
);
11708 if (program_headers
)
11710 free (program_headers
);
11711 program_headers
= NULL
;
11714 if (section_headers
)
11716 free (section_headers
);
11717 section_headers
= NULL
;
11722 free (string_table
);
11723 string_table
= NULL
;
11724 string_table_length
= 0;
11727 if (dynamic_strings
)
11729 free (dynamic_strings
);
11730 dynamic_strings
= NULL
;
11731 dynamic_strings_length
= 0;
11734 if (dynamic_symbols
)
11736 free (dynamic_symbols
);
11737 dynamic_symbols
= NULL
;
11738 num_dynamic_syms
= 0;
11741 if (dynamic_syminfo
)
11743 free (dynamic_syminfo
);
11744 dynamic_syminfo
= NULL
;
11747 if (section_headers_groups
)
11749 free (section_headers_groups
);
11750 section_headers_groups
= NULL
;
11753 if (section_groups
)
11755 struct group_list
* g
;
11756 struct group_list
* next
;
11758 for (i
= 0; i
< group_count
; i
++)
11760 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
11767 free (section_groups
);
11768 section_groups
= NULL
;
11771 free_debug_memory ();
11776 /* Return the path name for a proxy entry in a thin archive, adjusted relative
11777 to the path name of the thin archive itself if necessary. Always returns
11778 a pointer to malloc'ed memory. */
11781 adjust_relative_path (char * file_name
, char * name
, int name_len
)
11783 char * member_file_name
;
11784 const char * base_name
= lbasename (file_name
);
11786 /* This is a proxy entry for a thin archive member.
11787 If the extended name table contains an absolute path
11788 name, or if the archive is in the current directory,
11789 use the path name as given. Otherwise, we need to
11790 find the member relative to the directory where the
11791 archive is located. */
11792 if (IS_ABSOLUTE_PATH (name
) || base_name
== file_name
)
11794 member_file_name
= (char *) malloc (name_len
+ 1);
11795 if (member_file_name
== NULL
)
11797 error (_("Out of memory\n"));
11800 memcpy (member_file_name
, name
, name_len
);
11801 member_file_name
[name_len
] = '\0';
11805 /* Concatenate the path components of the archive file name
11806 to the relative path name from the extended name table. */
11807 size_t prefix_len
= base_name
- file_name
;
11808 member_file_name
= (char *) malloc (prefix_len
+ name_len
+ 1);
11809 if (member_file_name
== NULL
)
11811 error (_("Out of memory\n"));
11814 memcpy (member_file_name
, file_name
, prefix_len
);
11815 memcpy (member_file_name
+ prefix_len
, name
, name_len
);
11816 member_file_name
[prefix_len
+ name_len
] = '\0';
11818 return member_file_name
;
11821 /* Structure to hold information about an archive file. */
11823 struct archive_info
11825 char * file_name
; /* Archive file name. */
11826 FILE * file
; /* Open file descriptor. */
11827 unsigned long index_num
; /* Number of symbols in table. */
11828 unsigned long * index_array
; /* The array of member offsets. */
11829 char * sym_table
; /* The symbol table. */
11830 unsigned long sym_size
; /* Size of the symbol table. */
11831 char * longnames
; /* The long file names table. */
11832 unsigned long longnames_size
; /* Size of the long file names table. */
11833 unsigned long nested_member_origin
; /* Origin in the nested archive of the current member. */
11834 unsigned long next_arhdr_offset
; /* Offset of the next archive header. */
11835 bfd_boolean is_thin_archive
; /* TRUE if this is a thin archive. */
11836 struct ar_hdr arhdr
; /* Current archive header. */
11839 /* Read the symbol table and long-name table from an archive. */
11842 setup_archive (struct archive_info
* arch
, char * file_name
, FILE * file
,
11843 bfd_boolean is_thin_archive
, bfd_boolean read_symbols
)
11846 unsigned long size
;
11848 arch
->file_name
= strdup (file_name
);
11850 arch
->index_num
= 0;
11851 arch
->index_array
= NULL
;
11852 arch
->sym_table
= NULL
;
11853 arch
->sym_size
= 0;
11854 arch
->longnames
= NULL
;
11855 arch
->longnames_size
= 0;
11856 arch
->nested_member_origin
= 0;
11857 arch
->is_thin_archive
= is_thin_archive
;
11858 arch
->next_arhdr_offset
= SARMAG
;
11860 /* Read the first archive member header. */
11861 if (fseek (file
, SARMAG
, SEEK_SET
) != 0)
11863 error (_("%s: failed to seek to first archive header\n"), file_name
);
11866 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
11867 if (got
!= sizeof arch
->arhdr
)
11872 error (_("%s: failed to read archive header\n"), file_name
);
11876 /* See if this is the archive symbol table. */
11877 if (const_strneq (arch
->arhdr
.ar_name
, "/ ")
11878 || const_strneq (arch
->arhdr
.ar_name
, "/SYM64/ "))
11880 size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
11881 size
= size
+ (size
& 1);
11883 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ size
;
11888 /* A buffer used to hold numbers read in from an archive index.
11889 These are always 4 bytes long and stored in big-endian format. */
11890 #define SIZEOF_AR_INDEX_NUMBERS 4
11891 unsigned char integer_buffer
[SIZEOF_AR_INDEX_NUMBERS
];
11892 unsigned char * index_buffer
;
11894 /* Check the size of the archive index. */
11895 if (size
< SIZEOF_AR_INDEX_NUMBERS
)
11897 error (_("%s: the archive index is empty\n"), file_name
);
11901 /* Read the numer of entries in the archive index. */
11902 got
= fread (integer_buffer
, 1, sizeof integer_buffer
, file
);
11903 if (got
!= sizeof (integer_buffer
))
11905 error (_("%s: failed to read archive index\n"), file_name
);
11908 arch
->index_num
= byte_get_big_endian (integer_buffer
, sizeof integer_buffer
);
11909 size
-= SIZEOF_AR_INDEX_NUMBERS
;
11911 /* Read in the archive index. */
11912 if (size
< arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
)
11914 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
11915 file_name
, arch
->index_num
);
11918 index_buffer
= (unsigned char *)
11919 malloc (arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
);
11920 if (index_buffer
== NULL
)
11922 error (_("Out of memory whilst trying to read archive symbol index\n"));
11925 got
= fread (index_buffer
, SIZEOF_AR_INDEX_NUMBERS
, arch
->index_num
, file
);
11926 if (got
!= arch
->index_num
)
11928 free (index_buffer
);
11929 error (_("%s: failed to read archive index\n"), file_name
);
11932 size
-= arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
;
11934 /* Convert the index numbers into the host's numeric format. */
11935 arch
->index_array
= (long unsigned int *)
11936 malloc (arch
->index_num
* sizeof (* arch
->index_array
));
11937 if (arch
->index_array
== NULL
)
11939 free (index_buffer
);
11940 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
11944 for (i
= 0; i
< arch
->index_num
; i
++)
11945 arch
->index_array
[i
] = byte_get_big_endian ((unsigned char *) (index_buffer
+ (i
* SIZEOF_AR_INDEX_NUMBERS
)),
11946 SIZEOF_AR_INDEX_NUMBERS
);
11947 free (index_buffer
);
11949 /* The remaining space in the header is taken up by the symbol table. */
11952 error (_("%s: the archive has an index but no symbols\n"), file_name
);
11955 arch
->sym_table
= (char *) malloc (size
);
11956 arch
->sym_size
= size
;
11957 if (arch
->sym_table
== NULL
)
11959 error (_("Out of memory whilst trying to read archive index symbol table\n"));
11962 got
= fread (arch
->sym_table
, 1, size
, file
);
11965 error (_("%s: failed to read archive index symbol table\n"), file_name
);
11971 if (fseek (file
, size
, SEEK_CUR
) != 0)
11973 error (_("%s: failed to skip archive symbol table\n"), file_name
);
11978 /* Read the next archive header. */
11979 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
11980 if (got
!= sizeof arch
->arhdr
)
11984 error (_("%s: failed to read archive header following archive index\n"), file_name
);
11988 else if (read_symbols
)
11989 printf (_("%s has no archive index\n"), file_name
);
11991 if (const_strneq (arch
->arhdr
.ar_name
, "// "))
11993 /* This is the archive string table holding long member names. */
11994 arch
->longnames_size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
11995 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ arch
->longnames_size
;
11997 arch
->longnames
= (char *) malloc (arch
->longnames_size
);
11998 if (arch
->longnames
== NULL
)
12000 error (_("Out of memory reading long symbol names in archive\n"));
12004 if (fread (arch
->longnames
, arch
->longnames_size
, 1, file
) != 1)
12006 free (arch
->longnames
);
12007 arch
->longnames
= NULL
;
12008 error (_("%s: failed to read long symbol name string table\n"), file_name
);
12012 if ((arch
->longnames_size
& 1) != 0)
12019 /* Release the memory used for the archive information. */
12022 release_archive (struct archive_info
* arch
)
12024 if (arch
->file_name
!= NULL
)
12025 free (arch
->file_name
);
12026 if (arch
->index_array
!= NULL
)
12027 free (arch
->index_array
);
12028 if (arch
->sym_table
!= NULL
)
12029 free (arch
->sym_table
);
12030 if (arch
->longnames
!= NULL
)
12031 free (arch
->longnames
);
12034 /* Open and setup a nested archive, if not already open. */
12037 setup_nested_archive (struct archive_info
* nested_arch
, char * member_file_name
)
12039 FILE * member_file
;
12041 /* Have we already setup this archive? */
12042 if (nested_arch
->file_name
!= NULL
12043 && streq (nested_arch
->file_name
, member_file_name
))
12046 /* Close previous file and discard cached information. */
12047 if (nested_arch
->file
!= NULL
)
12048 fclose (nested_arch
->file
);
12049 release_archive (nested_arch
);
12051 member_file
= fopen (member_file_name
, "rb");
12052 if (member_file
== NULL
)
12054 return setup_archive (nested_arch
, member_file_name
, member_file
, FALSE
, FALSE
);
12058 get_archive_member_name_at (struct archive_info
* arch
,
12059 unsigned long offset
,
12060 struct archive_info
* nested_arch
);
12062 /* Get the name of an archive member from the current archive header.
12063 For simple names, this will modify the ar_name field of the current
12064 archive header. For long names, it will return a pointer to the
12065 longnames table. For nested archives, it will open the nested archive
12066 and get the name recursively. NESTED_ARCH is a single-entry cache so
12067 we don't keep rereading the same information from a nested archive. */
12070 get_archive_member_name (struct archive_info
* arch
,
12071 struct archive_info
* nested_arch
)
12073 unsigned long j
, k
;
12075 if (arch
->arhdr
.ar_name
[0] == '/')
12077 /* We have a long name. */
12079 char * member_file_name
;
12080 char * member_name
;
12082 arch
->nested_member_origin
= 0;
12083 k
= j
= strtoul (arch
->arhdr
.ar_name
+ 1, &endp
, 10);
12084 if (arch
->is_thin_archive
&& endp
!= NULL
&& * endp
== ':')
12085 arch
->nested_member_origin
= strtoul (endp
+ 1, NULL
, 10);
12087 while ((j
< arch
->longnames_size
)
12088 && (arch
->longnames
[j
] != '\n')
12089 && (arch
->longnames
[j
] != '\0'))
12091 if (arch
->longnames
[j
-1] == '/')
12093 arch
->longnames
[j
] = '\0';
12095 if (!arch
->is_thin_archive
|| arch
->nested_member_origin
== 0)
12096 return arch
->longnames
+ k
;
12098 /* This is a proxy for a member of a nested archive.
12099 Find the name of the member in that archive. */
12100 member_file_name
= adjust_relative_path (arch
->file_name
, arch
->longnames
+ k
, j
- k
);
12101 if (member_file_name
!= NULL
12102 && setup_nested_archive (nested_arch
, member_file_name
) == 0
12103 && (member_name
= get_archive_member_name_at (nested_arch
, arch
->nested_member_origin
, NULL
)) != NULL
)
12105 free (member_file_name
);
12106 return member_name
;
12108 free (member_file_name
);
12110 /* Last resort: just return the name of the nested archive. */
12111 return arch
->longnames
+ k
;
12114 /* We have a normal (short) name. */
12116 while ((arch
->arhdr
.ar_name
[j
] != '/') && (j
< 16))
12118 arch
->arhdr
.ar_name
[j
] = '\0';
12119 return arch
->arhdr
.ar_name
;
12122 /* Get the name of an archive member at a given OFFSET within an archive ARCH. */
12125 get_archive_member_name_at (struct archive_info
* arch
,
12126 unsigned long offset
,
12127 struct archive_info
* nested_arch
)
12131 if (fseek (arch
->file
, offset
, SEEK_SET
) != 0)
12133 error (_("%s: failed to seek to next file name\n"), arch
->file_name
);
12136 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, arch
->file
);
12137 if (got
!= sizeof arch
->arhdr
)
12139 error (_("%s: failed to read archive header\n"), arch
->file_name
);
12142 if (memcmp (arch
->arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
12144 error (_("%s: did not find a valid archive header\n"), arch
->file_name
);
12148 return get_archive_member_name (arch
, nested_arch
);
12151 /* Construct a string showing the name of the archive member, qualified
12152 with the name of the containing archive file. For thin archives, we
12153 use square brackets to denote the indirection. For nested archives,
12154 we show the qualified name of the external member inside the square
12155 brackets (e.g., "thin.a[normal.a(foo.o)]"). */
12158 make_qualified_name (struct archive_info
* arch
,
12159 struct archive_info
* nested_arch
,
12160 char * member_name
)
12165 len
= strlen (arch
->file_name
) + strlen (member_name
) + 3;
12166 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
12167 len
+= strlen (nested_arch
->file_name
) + 2;
12169 name
= (char *) malloc (len
);
12172 error (_("Out of memory\n"));
12176 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
12177 snprintf (name
, len
, "%s[%s(%s)]", arch
->file_name
, nested_arch
->file_name
, member_name
);
12178 else if (arch
->is_thin_archive
)
12179 snprintf (name
, len
, "%s[%s]", arch
->file_name
, member_name
);
12181 snprintf (name
, len
, "%s(%s)", arch
->file_name
, member_name
);
12186 /* Process an ELF archive.
12187 On entry the file is positioned just after the ARMAG string. */
12190 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
12192 struct archive_info arch
;
12193 struct archive_info nested_arch
;
12199 /* The ARCH structure is used to hold information about this archive. */
12200 arch
.file_name
= NULL
;
12202 arch
.index_array
= NULL
;
12203 arch
.sym_table
= NULL
;
12204 arch
.longnames
= NULL
;
12206 /* The NESTED_ARCH structure is used as a single-item cache of information
12207 about a nested archive (when members of a thin archive reside within
12208 another regular archive file). */
12209 nested_arch
.file_name
= NULL
;
12210 nested_arch
.file
= NULL
;
12211 nested_arch
.index_array
= NULL
;
12212 nested_arch
.sym_table
= NULL
;
12213 nested_arch
.longnames
= NULL
;
12215 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
12221 if (do_archive_index
)
12223 if (arch
.sym_table
== NULL
)
12224 error (_("%s: unable to dump the index as none was found\n"), file_name
);
12228 unsigned long current_pos
;
12230 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
12231 file_name
, arch
.index_num
, arch
.sym_size
);
12232 current_pos
= ftell (file
);
12234 for (i
= l
= 0; i
< arch
.index_num
; i
++)
12236 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
12238 char * member_name
;
12240 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
12242 if (member_name
!= NULL
)
12244 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
12246 if (qualified_name
!= NULL
)
12248 printf (_("Binary %s contains:\n"), qualified_name
);
12249 free (qualified_name
);
12254 if (l
>= arch
.sym_size
)
12256 error (_("%s: end of the symbol table reached before the end of the index\n"),
12260 printf ("\t%s\n", arch
.sym_table
+ l
);
12261 l
+= strlen (arch
.sym_table
+ l
) + 1;
12266 if (l
< arch
.sym_size
)
12267 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
12270 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
12272 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
12278 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
12279 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
12280 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
12281 && !do_section_groups
&& !do_dyn_syms
)
12283 ret
= 0; /* Archive index only. */
12294 char * qualified_name
;
12296 /* Read the next archive header. */
12297 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
12299 error (_("%s: failed to seek to next archive header\n"), file_name
);
12302 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
12303 if (got
!= sizeof arch
.arhdr
)
12307 error (_("%s: failed to read archive header\n"), file_name
);
12311 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
12313 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
12318 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
12320 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
12321 if (archive_file_size
& 01)
12322 ++archive_file_size
;
12324 name
= get_archive_member_name (&arch
, &nested_arch
);
12327 error (_("%s: bad archive file name\n"), file_name
);
12331 namelen
= strlen (name
);
12333 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
12334 if (qualified_name
== NULL
)
12336 error (_("%s: bad archive file name\n"), file_name
);
12341 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
12343 /* This is a proxy for an external member of a thin archive. */
12344 FILE * member_file
;
12345 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
12346 if (member_file_name
== NULL
)
12352 member_file
= fopen (member_file_name
, "rb");
12353 if (member_file
== NULL
)
12355 error (_("Input file '%s' is not readable.\n"), member_file_name
);
12356 free (member_file_name
);
12361 archive_file_offset
= arch
.nested_member_origin
;
12363 ret
|= process_object (qualified_name
, member_file
);
12365 fclose (member_file
);
12366 free (member_file_name
);
12368 else if (is_thin_archive
)
12370 /* This is a proxy for a member of a nested archive. */
12371 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
12373 /* The nested archive file will have been opened and setup by
12374 get_archive_member_name. */
12375 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
12377 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
12382 ret
|= process_object (qualified_name
, nested_arch
.file
);
12386 archive_file_offset
= arch
.next_arhdr_offset
;
12387 arch
.next_arhdr_offset
+= archive_file_size
;
12389 ret
|= process_object (qualified_name
, file
);
12392 free (qualified_name
);
12396 if (nested_arch
.file
!= NULL
)
12397 fclose (nested_arch
.file
);
12398 release_archive (&nested_arch
);
12399 release_archive (&arch
);
12405 process_file (char * file_name
)
12408 struct stat statbuf
;
12409 char armag
[SARMAG
];
12412 if (stat (file_name
, &statbuf
) < 0)
12414 if (errno
== ENOENT
)
12415 error (_("'%s': No such file\n"), file_name
);
12417 error (_("Could not locate '%s'. System error message: %s\n"),
12418 file_name
, strerror (errno
));
12422 if (! S_ISREG (statbuf
.st_mode
))
12424 error (_("'%s' is not an ordinary file\n"), file_name
);
12428 file
= fopen (file_name
, "rb");
12431 error (_("Input file '%s' is not readable.\n"), file_name
);
12435 if (fread (armag
, SARMAG
, 1, file
) != 1)
12437 error (_("%s: Failed to read file's magic number\n"), file_name
);
12442 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
12443 ret
= process_archive (file_name
, file
, FALSE
);
12444 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
12445 ret
= process_archive (file_name
, file
, TRUE
);
12448 if (do_archive_index
)
12449 error (_("File %s is not an archive so its index cannot be displayed.\n"),
12453 archive_file_size
= archive_file_offset
= 0;
12454 ret
= process_object (file_name
, file
);
12462 #ifdef SUPPORT_DISASSEMBLY
12463 /* Needed by the i386 disassembler. For extra credit, someone could
12464 fix this so that we insert symbolic addresses here, esp for GOT/PLT
12468 print_address (unsigned int addr
, FILE * outfile
)
12470 fprintf (outfile
,"0x%8.8x", addr
);
12473 /* Needed by the i386 disassembler. */
12475 db_task_printsym (unsigned int addr
)
12477 print_address (addr
, stderr
);
12482 main (int argc
, char ** argv
)
12486 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
12487 setlocale (LC_MESSAGES
, "");
12489 #if defined (HAVE_SETLOCALE)
12490 setlocale (LC_CTYPE
, "");
12492 bindtextdomain (PACKAGE
, LOCALEDIR
);
12493 textdomain (PACKAGE
);
12495 expandargv (&argc
, &argv
);
12497 parse_args (argc
, argv
);
12499 if (num_dump_sects
> 0)
12501 /* Make a copy of the dump_sects array. */
12502 cmdline_dump_sects
= (dump_type
*)
12503 malloc (num_dump_sects
* sizeof (* dump_sects
));
12504 if (cmdline_dump_sects
== NULL
)
12505 error (_("Out of memory allocating dump request table.\n"));
12508 memcpy (cmdline_dump_sects
, dump_sects
,
12509 num_dump_sects
* sizeof (* dump_sects
));
12510 num_cmdline_dump_sects
= num_dump_sects
;
12514 if (optind
< (argc
- 1))
12518 while (optind
< argc
)
12519 err
|= process_file (argv
[optind
++]);
12521 if (dump_sects
!= NULL
)
12523 if (cmdline_dump_sects
!= NULL
)
12524 free (cmdline_dump_sects
);