1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3 2008, 2009 Free Software Foundation, Inc.
5 Originally developed by Eric Youngdale <eric@andante.jic.com>
6 Modifications by Nick Clifton <nickc@redhat.com>
8 This file is part of GNU Binutils.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
25 /* The difference between readelf and objdump:
27 Both programs are capable of displaying the contents of ELF format files,
28 so why does the binutils project have two file dumpers ?
30 The reason is that objdump sees an ELF file through a BFD filter of the
31 world; if BFD has a bug where, say, it disagrees about a machine constant
32 in e_flags, then the odds are good that it will remain internally
33 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
34 GAS sees it the BFD way. There was need for a tool to go find out what
35 the file actually says.
37 This is why the readelf program does not link against the BFD library - it
38 exists as an independent program to help verify the correct working of BFD.
40 There is also the case that readelf can provide more information about an
41 ELF file than is provided by objdump. In particular it can display DWARF
42 debugging information which (at the moment) objdump cannot. */
54 /* Define BFD64 here, even if our default architecture is 32 bit ELF
55 as this will allow us to read in and parse 64bit and 32bit ELF files.
56 Only do this if we believe that the compiler can support a 64 bit
57 data type. For now we only rely on GCC being able to do this. */
65 #include "elf/common.h"
66 #include "elf/external.h"
67 #include "elf/internal.h"
70 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
71 we can obtain the H8 reloc numbers. We need these for the
72 get_reloc_size() function. We include h8.h again after defining
73 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
78 /* Undo the effects of #including reloc-macros.h. */
80 #undef START_RELOC_NUMBERS
84 #undef END_RELOC_NUMBERS
85 #undef _RELOC_MACROS_H
87 /* The following headers use the elf/reloc-macros.h file to
88 automatically generate relocation recognition functions
89 such as elf_mips_reloc_type() */
91 #define RELOC_MACROS_GEN_FUNC
93 #include "elf/alpha.h"
101 #include "elf/d10v.h"
102 #include "elf/d30v.h"
104 #include "elf/fr30.h"
107 #include "elf/hppa.h"
108 #include "elf/i386.h"
109 #include "elf/i370.h"
110 #include "elf/i860.h"
111 #include "elf/i960.h"
112 #include "elf/ia64.h"
113 #include "elf/ip2k.h"
114 #include "elf/lm32.h"
115 #include "elf/iq2000.h"
116 #include "elf/m32c.h"
117 #include "elf/m32r.h"
118 #include "elf/m68k.h"
119 #include "elf/m68hc11.h"
120 #include "elf/mcore.h"
122 #include "elf/microblaze.h"
123 #include "elf/mips.h"
124 #include "elf/mmix.h"
125 #include "elf/mn10200.h"
126 #include "elf/mn10300.h"
128 #include "elf/msp430.h"
129 #include "elf/or32.h"
132 #include "elf/ppc64.h"
134 #include "elf/s390.h"
135 #include "elf/score.h"
137 #include "elf/sparc.h"
139 #include "elf/v850.h"
141 #include "elf/x86-64.h"
142 #include "elf/xc16x.h"
143 #include "elf/xstormy16.h"
144 #include "elf/xtensa.h"
149 #include "libiberty.h"
150 #include "safe-ctype.h"
151 #include "filenames.h"
153 char * program_name
= "readelf";
154 static long archive_file_offset
;
155 static unsigned long archive_file_size
;
156 static unsigned long dynamic_addr
;
157 static bfd_size_type dynamic_size
;
158 static unsigned int dynamic_nent
;
159 static char * dynamic_strings
;
160 static unsigned long dynamic_strings_length
;
161 static char * string_table
;
162 static unsigned long string_table_length
;
163 static unsigned long num_dynamic_syms
;
164 static Elf_Internal_Sym
* dynamic_symbols
;
165 static Elf_Internal_Syminfo
* dynamic_syminfo
;
166 static unsigned long dynamic_syminfo_offset
;
167 static unsigned int dynamic_syminfo_nent
;
168 static char program_interpreter
[PATH_MAX
];
169 static bfd_vma dynamic_info
[DT_ENCODING
];
170 static bfd_vma dynamic_info_DT_GNU_HASH
;
171 static bfd_vma version_info
[16];
172 static Elf_Internal_Ehdr elf_header
;
173 static Elf_Internal_Shdr
* section_headers
;
174 static Elf_Internal_Phdr
* program_headers
;
175 static Elf_Internal_Dyn
* dynamic_section
;
176 static Elf_Internal_Shdr
* symtab_shndx_hdr
;
177 static int show_name
;
178 static int do_dynamic
;
181 static int do_sections
;
182 static int do_section_groups
;
183 static int do_section_details
;
184 static int do_segments
;
185 static int do_unwind
;
186 static int do_using_dynamic
;
187 static int do_header
;
189 static int do_version
;
190 static int do_histogram
;
191 static int do_debugging
;
194 static int do_archive_index
;
195 static int is_32bit_elf
;
199 struct group_list
* next
;
200 unsigned int section_index
;
205 struct group_list
* root
;
206 unsigned int group_index
;
209 static size_t group_count
;
210 static struct group
* section_groups
;
211 static struct group
** section_headers_groups
;
214 /* Flag bits indicating particular types of dump. */
215 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
216 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
217 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
218 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
219 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
221 typedef unsigned char dump_type
;
223 /* A linked list of the section names for which dumps were requested. */
224 struct dump_list_entry
228 struct dump_list_entry
* next
;
230 static struct dump_list_entry
* dump_sects_byname
;
232 /* A dynamic array of flags indicating for which sections a dump
233 has been requested via command line switches. */
234 static dump_type
* cmdline_dump_sects
= NULL
;
235 static unsigned int num_cmdline_dump_sects
= 0;
237 /* A dynamic array of flags indicating for which sections a dump of
238 some kind has been requested. It is reset on a per-object file
239 basis and then initialised from the cmdline_dump_sects array,
240 the results of interpreting the -w switch, and the
241 dump_sects_byname list. */
242 static dump_type
* dump_sects
= NULL
;
243 static unsigned int num_dump_sects
= 0;
246 /* How to print a vma value. */
247 typedef enum print_mode
259 static void (* byte_put
) (unsigned char *, bfd_vma
, int);
263 #define SECTION_NAME(X) \
264 ((X) == NULL ? "<none>" \
265 : string_table == NULL ? "<no-name>" \
266 : ((X)->sh_name >= string_table_length ? "<corrupt>" \
267 : string_table + (X)->sh_name))
269 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
271 #define BYTE_GET(field) byte_get (field, sizeof (field))
273 #define GET_ELF_SYMBOLS(file, section) \
274 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
275 : get_64bit_elf_symbols (file, section))
277 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
278 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
279 already been called and verified that the string exists. */
280 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
282 /* This is just a bit of syntatic sugar. */
283 #define streq(a,b) (strcmp ((a), (b)) == 0)
284 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
285 #define const_strneq(a,b) (strncmp ((a), (b), sizeof (b) - 1) == 0)
288 get_data (void * var
, FILE * file
, long offset
, size_t size
, size_t nmemb
,
293 if (size
== 0 || nmemb
== 0)
296 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
298 error (_("Unable to seek to 0x%lx for %s\n"),
299 (unsigned long) archive_file_offset
+ offset
, reason
);
306 /* Check for overflow. */
307 if (nmemb
< (~(size_t) 0 - 1) / size
)
308 /* + 1 so that we can '\0' terminate invalid string table sections. */
309 mvar
= malloc (size
* nmemb
+ 1);
313 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
314 (unsigned long)(size
* nmemb
), reason
);
318 ((char *) mvar
)[size
* nmemb
] = '\0';
321 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
323 error (_("Unable to read in 0x%lx bytes of %s\n"),
324 (unsigned long)(size
* nmemb
), reason
);
334 byte_put_little_endian (unsigned char * field
, bfd_vma value
, int size
)
339 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
340 field
[6] = ((value
>> 24) >> 24) & 0xff;
341 field
[5] = ((value
>> 24) >> 16) & 0xff;
342 field
[4] = ((value
>> 24) >> 8) & 0xff;
345 field
[3] = (value
>> 24) & 0xff;
348 field
[2] = (value
>> 16) & 0xff;
351 field
[1] = (value
>> 8) & 0xff;
354 field
[0] = value
& 0xff;
358 error (_("Unhandled data length: %d\n"), size
);
363 /* Print a VMA value. */
366 print_vma (bfd_vma vma
, print_mode mode
)
379 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
386 return printf ("%5" BFD_VMA_FMT
"d", vma
);
394 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
397 return printf ("%" BFD_VMA_FMT
"d", vma
);
400 return printf ("%" BFD_VMA_FMT
"u", vma
);
405 /* Display a symbol on stdout. Handles the display of non-printing characters.
407 If DO_WIDE is not true then format the symbol to be at most WIDTH characters,
408 truncating as necessary. If WIDTH is negative then format the string to be
409 exactly - WIDTH characters, truncating or padding as necessary.
411 Returns the number of emitted characters. */
414 print_symbol (int width
, const char * symbol
)
417 bfd_boolean extra_padding
= FALSE
;
418 unsigned int num_printed
= 0;
422 /* Set the width to a very large value. This simplifies the code below. */
427 /* Keep the width positive. This also helps. */
429 extra_padding
= TRUE
;
438 /* Look for non-printing symbols inside the symbol's name.
439 This test is triggered in particular by the names generated
440 by the assembler for local labels. */
441 while (ISPRINT (* c
))
451 printf ("%.*s", len
, symbol
);
457 if (* c
== 0 || width
== 0)
460 /* Now display the non-printing character, if
461 there is room left in which to dipslay it. */
467 printf ("^%c", *c
+ 0x40);
477 printf ("<0x%.2x>", *c
);
486 if (extra_padding
&& width
> 0)
488 /* Fill in the remaining spaces. */
489 printf ("%-*s", width
, " ");
497 byte_put_big_endian (unsigned char * field
, bfd_vma value
, int size
)
502 field
[7] = value
& 0xff;
503 field
[6] = (value
>> 8) & 0xff;
504 field
[5] = (value
>> 16) & 0xff;
505 field
[4] = (value
>> 24) & 0xff;
510 field
[3] = value
& 0xff;
514 field
[2] = value
& 0xff;
518 field
[1] = value
& 0xff;
522 field
[0] = value
& 0xff;
526 error (_("Unhandled data length: %d\n"), size
);
531 /* Return a pointer to section NAME, or NULL if no such section exists. */
533 static Elf_Internal_Shdr
*
534 find_section (const char * name
)
538 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
539 if (streq (SECTION_NAME (section_headers
+ i
), name
))
540 return section_headers
+ i
;
545 /* Guess the relocation size commonly used by the specific machines. */
548 guess_is_rela (unsigned int e_machine
)
552 /* Targets that use REL relocations. */
568 /* Targets that use RELA relocations. */
572 case EM_ALTERA_NIOS2
:
592 case EM_LATTICEMICO32
:
600 case EM_CYGNUS_MN10200
:
602 case EM_CYGNUS_MN10300
:
626 case EM_MICROBLAZE_OLD
:
647 warn (_("Don't know about relocations on this machine architecture\n"));
653 slurp_rela_relocs (FILE * file
,
654 unsigned long rel_offset
,
655 unsigned long rel_size
,
656 Elf_Internal_Rela
** relasp
,
657 unsigned long * nrelasp
)
659 Elf_Internal_Rela
* relas
;
660 unsigned long nrelas
;
665 Elf32_External_Rela
* erelas
;
667 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
668 rel_size
, _("relocs"));
672 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
674 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
675 sizeof (Elf_Internal_Rela
));
680 error (_("out of memory parsing relocs\n"));
684 for (i
= 0; i
< nrelas
; i
++)
686 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
687 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
688 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
695 Elf64_External_Rela
* erelas
;
697 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
698 rel_size
, _("relocs"));
702 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
704 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
705 sizeof (Elf_Internal_Rela
));
710 error (_("out of memory parsing relocs\n"));
714 for (i
= 0; i
< nrelas
; i
++)
716 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
717 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
718 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
720 /* The #ifdef BFD64 below is to prevent a compile time
721 warning. We know that if we do not have a 64 bit data
722 type that we will never execute this code anyway. */
724 if (elf_header
.e_machine
== EM_MIPS
725 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
727 /* In little-endian objects, r_info isn't really a
728 64-bit little-endian value: it has a 32-bit
729 little-endian symbol index followed by four
730 individual byte fields. Reorder INFO
732 bfd_vma info
= relas
[i
].r_info
;
733 info
= (((info
& 0xffffffff) << 32)
734 | ((info
>> 56) & 0xff)
735 | ((info
>> 40) & 0xff00)
736 | ((info
>> 24) & 0xff0000)
737 | ((info
>> 8) & 0xff000000));
738 relas
[i
].r_info
= info
;
751 slurp_rel_relocs (FILE * file
,
752 unsigned long rel_offset
,
753 unsigned long rel_size
,
754 Elf_Internal_Rela
** relsp
,
755 unsigned long * nrelsp
)
757 Elf_Internal_Rela
* rels
;
763 Elf32_External_Rel
* erels
;
765 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
766 rel_size
, _("relocs"));
770 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
772 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
777 error (_("out of memory parsing relocs\n"));
781 for (i
= 0; i
< nrels
; i
++)
783 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
784 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
785 rels
[i
].r_addend
= 0;
792 Elf64_External_Rel
* erels
;
794 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
795 rel_size
, _("relocs"));
799 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
801 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
806 error (_("out of memory parsing relocs\n"));
810 for (i
= 0; i
< nrels
; i
++)
812 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
813 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
814 rels
[i
].r_addend
= 0;
816 /* The #ifdef BFD64 below is to prevent a compile time
817 warning. We know that if we do not have a 64 bit data
818 type that we will never execute this code anyway. */
820 if (elf_header
.e_machine
== EM_MIPS
821 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
823 /* In little-endian objects, r_info isn't really a
824 64-bit little-endian value: it has a 32-bit
825 little-endian symbol index followed by four
826 individual byte fields. Reorder INFO
828 bfd_vma info
= rels
[i
].r_info
;
829 info
= (((info
& 0xffffffff) << 32)
830 | ((info
>> 56) & 0xff)
831 | ((info
>> 40) & 0xff00)
832 | ((info
>> 24) & 0xff0000)
833 | ((info
>> 8) & 0xff000000));
834 rels
[i
].r_info
= info
;
846 /* Returns the reloc type extracted from the reloc info field. */
849 get_reloc_type (bfd_vma reloc_info
)
852 return ELF32_R_TYPE (reloc_info
);
854 switch (elf_header
.e_machine
)
857 /* Note: We assume that reloc_info has already been adjusted for us. */
858 return ELF64_MIPS_R_TYPE (reloc_info
);
861 return ELF64_R_TYPE_ID (reloc_info
);
864 return ELF64_R_TYPE (reloc_info
);
868 /* Return the symbol index extracted from the reloc info field. */
871 get_reloc_symindex (bfd_vma reloc_info
)
873 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
876 /* Display the contents of the relocation data found at the specified
880 dump_relocations (FILE * file
,
881 unsigned long rel_offset
,
882 unsigned long rel_size
,
883 Elf_Internal_Sym
* symtab
,
886 unsigned long strtablen
,
890 Elf_Internal_Rela
* rels
;
892 if (is_rela
== UNKNOWN
)
893 is_rela
= guess_is_rela (elf_header
.e_machine
);
897 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
902 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
911 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
913 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
918 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
920 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
928 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
930 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
935 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
937 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
941 for (i
= 0; i
< rel_size
; i
++)
946 bfd_vma symtab_index
;
949 offset
= rels
[i
].r_offset
;
950 info
= rels
[i
].r_info
;
952 type
= get_reloc_type (info
);
953 symtab_index
= get_reloc_symindex (info
);
957 printf ("%8.8lx %8.8lx ",
958 (unsigned long) offset
& 0xffffffff,
959 (unsigned long) info
& 0xffffffff);
963 #if BFD_HOST_64BIT_LONG
965 ? "%16.16lx %16.16lx "
966 : "%12.12lx %12.12lx ",
968 #elif BFD_HOST_64BIT_LONG_LONG
971 ? "%16.16llx %16.16llx "
972 : "%12.12llx %12.12llx ",
976 ? "%16.16I64x %16.16I64x "
977 : "%12.12I64x %12.12I64x ",
982 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
983 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
984 _bfd_int64_high (offset
),
985 _bfd_int64_low (offset
),
986 _bfd_int64_high (info
),
987 _bfd_int64_low (info
));
991 switch (elf_header
.e_machine
)
999 rtype
= elf_m32r_reloc_type (type
);
1004 rtype
= elf_i386_reloc_type (type
);
1009 rtype
= elf_m68hc11_reloc_type (type
);
1013 rtype
= elf_m68k_reloc_type (type
);
1017 rtype
= elf_i960_reloc_type (type
);
1022 rtype
= elf_avr_reloc_type (type
);
1025 case EM_OLD_SPARCV9
:
1026 case EM_SPARC32PLUS
:
1029 rtype
= elf_sparc_reloc_type (type
);
1033 rtype
= elf_spu_reloc_type (type
);
1037 case EM_CYGNUS_V850
:
1038 rtype
= v850_reloc_type (type
);
1042 case EM_CYGNUS_D10V
:
1043 rtype
= elf_d10v_reloc_type (type
);
1047 case EM_CYGNUS_D30V
:
1048 rtype
= elf_d30v_reloc_type (type
);
1052 rtype
= elf_dlx_reloc_type (type
);
1056 rtype
= elf_sh_reloc_type (type
);
1060 case EM_CYGNUS_MN10300
:
1061 rtype
= elf_mn10300_reloc_type (type
);
1065 case EM_CYGNUS_MN10200
:
1066 rtype
= elf_mn10200_reloc_type (type
);
1070 case EM_CYGNUS_FR30
:
1071 rtype
= elf_fr30_reloc_type (type
);
1075 rtype
= elf_frv_reloc_type (type
);
1079 rtype
= elf_mcore_reloc_type (type
);
1083 rtype
= elf_mmix_reloc_type (type
);
1088 rtype
= elf_msp430_reloc_type (type
);
1092 rtype
= elf_ppc_reloc_type (type
);
1096 rtype
= elf_ppc64_reloc_type (type
);
1100 case EM_MIPS_RS3_LE
:
1101 rtype
= elf_mips_reloc_type (type
);
1105 rtype
= elf_alpha_reloc_type (type
);
1109 rtype
= elf_arm_reloc_type (type
);
1113 rtype
= elf_arc_reloc_type (type
);
1117 rtype
= elf_hppa_reloc_type (type
);
1123 rtype
= elf_h8_reloc_type (type
);
1128 rtype
= elf_or32_reloc_type (type
);
1133 rtype
= elf_pj_reloc_type (type
);
1136 rtype
= elf_ia64_reloc_type (type
);
1140 rtype
= elf_cris_reloc_type (type
);
1144 rtype
= elf_i860_reloc_type (type
);
1149 rtype
= elf_x86_64_reloc_type (type
);
1153 rtype
= i370_reloc_type (type
);
1158 rtype
= elf_s390_reloc_type (type
);
1162 rtype
= elf_score_reloc_type (type
);
1166 rtype
= elf_xstormy16_reloc_type (type
);
1170 rtype
= elf_crx_reloc_type (type
);
1174 rtype
= elf_vax_reloc_type (type
);
1179 rtype
= elf_ip2k_reloc_type (type
);
1183 rtype
= elf_iq2000_reloc_type (type
);
1188 rtype
= elf_xtensa_reloc_type (type
);
1191 case EM_LATTICEMICO32
:
1192 rtype
= elf_lm32_reloc_type (type
);
1197 rtype
= elf_m32c_reloc_type (type
);
1201 rtype
= elf_mt_reloc_type (type
);
1205 rtype
= elf_bfin_reloc_type (type
);
1209 rtype
= elf_mep_reloc_type (type
);
1214 rtype
= elf_cr16_reloc_type (type
);
1218 case EM_MICROBLAZE_OLD
:
1219 rtype
= elf_microblaze_reloc_type (type
);
1223 rtype
= elf_rx_reloc_type (type
);
1228 rtype
= elf_xc16x_reloc_type (type
);
1233 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1235 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1237 if (elf_header
.e_machine
== EM_ALPHA
1239 && streq (rtype
, "R_ALPHA_LITUSE")
1242 switch (rels
[i
].r_addend
)
1244 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1245 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1246 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1247 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1248 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1249 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1250 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1251 default: rtype
= NULL
;
1254 printf (" (%s)", rtype
);
1258 printf (_("<unknown addend: %lx>"),
1259 (unsigned long) rels
[i
].r_addend
);
1262 else if (symtab_index
)
1264 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1265 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1268 Elf_Internal_Sym
* psym
;
1270 psym
= symtab
+ symtab_index
;
1274 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1278 unsigned int width
= is_32bit_elf
? 8 : 14;
1280 /* Relocations against GNU_IFUNC symbols do not use the value
1281 of the symbol as the address to relocate against. Instead
1282 they invoke the function named by the symbol and use its
1283 result as the address for relocation.
1285 To indicate this to the user, do not display the value of
1286 the symbol in the "Symbols's Value" field. Instead show
1287 its name followed by () as a hint that the symbol is
1291 || psym
->st_name
== 0
1292 || psym
->st_name
>= strtablen
)
1295 name
= strtab
+ psym
->st_name
;
1297 len
= print_symbol (width
, name
);
1298 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1302 print_vma (psym
->st_value
, LONG_HEX
);
1304 printf (is_32bit_elf
? " " : " ");
1307 if (psym
->st_name
== 0)
1309 const char * sec_name
= "<null>";
1312 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1314 if (psym
->st_shndx
< elf_header
.e_shnum
)
1316 = SECTION_NAME (section_headers
+ psym
->st_shndx
);
1317 else if (psym
->st_shndx
== SHN_ABS
)
1319 else if (psym
->st_shndx
== SHN_COMMON
)
1320 sec_name
= "COMMON";
1321 else if (elf_header
.e_machine
== EM_MIPS
1322 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1323 sec_name
= "SCOMMON";
1324 else if (elf_header
.e_machine
== EM_MIPS
1325 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1326 sec_name
= "SUNDEF";
1327 else if ((elf_header
.e_machine
== EM_X86_64
1328 || elf_header
.e_machine
== EM_L1OM
)
1329 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1330 sec_name
= "LARGE_COMMON";
1331 else if (elf_header
.e_machine
== EM_IA_64
1332 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1333 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1334 sec_name
= "ANSI_COM";
1335 else if (elf_header
.e_machine
== EM_IA_64
1336 && (elf_header
.e_ident
[EI_OSABI
]
1337 == ELFOSABI_OPENVMS
)
1338 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1339 sec_name
= "VMS_SYMVEC";
1342 sprintf (name_buf
, "<section 0x%x>",
1343 (unsigned int) psym
->st_shndx
);
1344 sec_name
= name_buf
;
1347 print_symbol (22, sec_name
);
1349 else if (strtab
== NULL
)
1350 printf (_("<string table index: %3ld>"), psym
->st_name
);
1351 else if (psym
->st_name
>= strtablen
)
1352 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1354 print_symbol (22, strtab
+ psym
->st_name
);
1358 long offset
= (long) (bfd_signed_vma
) rels
[i
].r_addend
;
1361 printf (" - %lx", - offset
);
1363 printf (" + %lx", offset
);
1369 printf ("%*c", is_32bit_elf
?
1370 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1371 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1374 if (elf_header
.e_machine
== EM_SPARCV9
1376 && streq (rtype
, "R_SPARC_OLO10"))
1377 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1382 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1384 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (info
);
1385 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (info
);
1386 const char * rtype2
= elf_mips_reloc_type (type2
);
1387 const char * rtype3
= elf_mips_reloc_type (type3
);
1389 printf (" Type2: ");
1392 printf (_("unrecognized: %-7lx"),
1393 (unsigned long) type2
& 0xffffffff);
1395 printf ("%-17.17s", rtype2
);
1397 printf ("\n Type3: ");
1400 printf (_("unrecognized: %-7lx"),
1401 (unsigned long) type3
& 0xffffffff);
1403 printf ("%-17.17s", rtype3
);
1414 get_mips_dynamic_type (unsigned long type
)
1418 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1419 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1420 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1421 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1422 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1423 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1424 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1425 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1426 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1427 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1428 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1429 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1430 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1431 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1432 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1433 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1434 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1435 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1436 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1437 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1438 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1439 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1440 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1441 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1442 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1443 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1444 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1445 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1446 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1447 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1448 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1449 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1450 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1451 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1452 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1453 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1454 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1455 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1456 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1457 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1458 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1459 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1460 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1461 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1462 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1469 get_sparc64_dynamic_type (unsigned long type
)
1473 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1480 get_ppc_dynamic_type (unsigned long type
)
1484 case DT_PPC_GOT
: return "PPC_GOT";
1485 case DT_PPC_TLSOPT
: return "PPC_TLSOPT";
1492 get_ppc64_dynamic_type (unsigned long type
)
1496 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1497 case DT_PPC64_OPD
: return "PPC64_OPD";
1498 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1499 case DT_PPC64_TLSOPT
: return "PPC64_TLSOPT";
1506 get_parisc_dynamic_type (unsigned long type
)
1510 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1511 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1512 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1513 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1514 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1515 case DT_HP_PREINIT
: return "HP_PREINIT";
1516 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1517 case DT_HP_NEEDED
: return "HP_NEEDED";
1518 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1519 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1520 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1521 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1522 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1523 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1524 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1525 case DT_HP_FILTERED
: return "HP_FILTERED";
1526 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1527 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1528 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1529 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1530 case DT_PLT
: return "PLT";
1531 case DT_PLT_SIZE
: return "PLT_SIZE";
1532 case DT_DLT
: return "DLT";
1533 case DT_DLT_SIZE
: return "DLT_SIZE";
1540 get_ia64_dynamic_type (unsigned long type
)
1544 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1545 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1546 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1547 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1548 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1549 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1550 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1551 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1552 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1553 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1554 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1555 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1556 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1557 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1558 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1559 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1560 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1561 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1562 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1563 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1564 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1565 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1566 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1567 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1568 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1569 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1570 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1571 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1572 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1573 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1574 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1581 get_alpha_dynamic_type (unsigned long type
)
1585 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1592 get_score_dynamic_type (unsigned long type
)
1596 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1597 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1598 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1599 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1600 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1601 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1609 get_dynamic_type (unsigned long type
)
1611 static char buff
[64];
1615 case DT_NULL
: return "NULL";
1616 case DT_NEEDED
: return "NEEDED";
1617 case DT_PLTRELSZ
: return "PLTRELSZ";
1618 case DT_PLTGOT
: return "PLTGOT";
1619 case DT_HASH
: return "HASH";
1620 case DT_STRTAB
: return "STRTAB";
1621 case DT_SYMTAB
: return "SYMTAB";
1622 case DT_RELA
: return "RELA";
1623 case DT_RELASZ
: return "RELASZ";
1624 case DT_RELAENT
: return "RELAENT";
1625 case DT_STRSZ
: return "STRSZ";
1626 case DT_SYMENT
: return "SYMENT";
1627 case DT_INIT
: return "INIT";
1628 case DT_FINI
: return "FINI";
1629 case DT_SONAME
: return "SONAME";
1630 case DT_RPATH
: return "RPATH";
1631 case DT_SYMBOLIC
: return "SYMBOLIC";
1632 case DT_REL
: return "REL";
1633 case DT_RELSZ
: return "RELSZ";
1634 case DT_RELENT
: return "RELENT";
1635 case DT_PLTREL
: return "PLTREL";
1636 case DT_DEBUG
: return "DEBUG";
1637 case DT_TEXTREL
: return "TEXTREL";
1638 case DT_JMPREL
: return "JMPREL";
1639 case DT_BIND_NOW
: return "BIND_NOW";
1640 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1641 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1642 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1643 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1644 case DT_RUNPATH
: return "RUNPATH";
1645 case DT_FLAGS
: return "FLAGS";
1647 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1648 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1650 case DT_CHECKSUM
: return "CHECKSUM";
1651 case DT_PLTPADSZ
: return "PLTPADSZ";
1652 case DT_MOVEENT
: return "MOVEENT";
1653 case DT_MOVESZ
: return "MOVESZ";
1654 case DT_FEATURE
: return "FEATURE";
1655 case DT_POSFLAG_1
: return "POSFLAG_1";
1656 case DT_SYMINSZ
: return "SYMINSZ";
1657 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1659 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1660 case DT_CONFIG
: return "CONFIG";
1661 case DT_DEPAUDIT
: return "DEPAUDIT";
1662 case DT_AUDIT
: return "AUDIT";
1663 case DT_PLTPAD
: return "PLTPAD";
1664 case DT_MOVETAB
: return "MOVETAB";
1665 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1667 case DT_VERSYM
: return "VERSYM";
1669 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1670 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1671 case DT_RELACOUNT
: return "RELACOUNT";
1672 case DT_RELCOUNT
: return "RELCOUNT";
1673 case DT_FLAGS_1
: return "FLAGS_1";
1674 case DT_VERDEF
: return "VERDEF";
1675 case DT_VERDEFNUM
: return "VERDEFNUM";
1676 case DT_VERNEED
: return "VERNEED";
1677 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1679 case DT_AUXILIARY
: return "AUXILIARY";
1680 case DT_USED
: return "USED";
1681 case DT_FILTER
: return "FILTER";
1683 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1684 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1685 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1686 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1687 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1688 case DT_GNU_HASH
: return "GNU_HASH";
1691 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1693 const char * result
;
1695 switch (elf_header
.e_machine
)
1698 case EM_MIPS_RS3_LE
:
1699 result
= get_mips_dynamic_type (type
);
1702 result
= get_sparc64_dynamic_type (type
);
1705 result
= get_ppc_dynamic_type (type
);
1708 result
= get_ppc64_dynamic_type (type
);
1711 result
= get_ia64_dynamic_type (type
);
1714 result
= get_alpha_dynamic_type (type
);
1717 result
= get_score_dynamic_type (type
);
1727 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1729 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1730 || (elf_header
.e_machine
== EM_PARISC
1731 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1733 const char * result
;
1735 switch (elf_header
.e_machine
)
1738 result
= get_parisc_dynamic_type (type
);
1741 result
= get_ia64_dynamic_type (type
);
1751 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1755 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1762 get_file_type (unsigned e_type
)
1764 static char buff
[32];
1768 case ET_NONE
: return _("NONE (None)");
1769 case ET_REL
: return _("REL (Relocatable file)");
1770 case ET_EXEC
: return _("EXEC (Executable file)");
1771 case ET_DYN
: return _("DYN (Shared object file)");
1772 case ET_CORE
: return _("CORE (Core file)");
1775 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1776 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1777 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1778 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1780 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1786 get_machine_name (unsigned e_machine
)
1788 static char buff
[64]; /* XXX */
1792 case EM_NONE
: return _("None");
1793 case EM_M32
: return "WE32100";
1794 case EM_SPARC
: return "Sparc";
1795 case EM_SPU
: return "SPU";
1796 case EM_386
: return "Intel 80386";
1797 case EM_68K
: return "MC68000";
1798 case EM_88K
: return "MC88000";
1799 case EM_486
: return "Intel 80486";
1800 case EM_860
: return "Intel 80860";
1801 case EM_MIPS
: return "MIPS R3000";
1802 case EM_S370
: return "IBM System/370";
1803 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1804 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1805 case EM_PARISC
: return "HPPA";
1806 case EM_PPC_OLD
: return "Power PC (old)";
1807 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1808 case EM_960
: return "Intel 90860";
1809 case EM_PPC
: return "PowerPC";
1810 case EM_PPC64
: return "PowerPC64";
1811 case EM_V800
: return "NEC V800";
1812 case EM_FR20
: return "Fujitsu FR20";
1813 case EM_RH32
: return "TRW RH32";
1814 case EM_MCORE
: return "MCORE";
1815 case EM_ARM
: return "ARM";
1816 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1817 case EM_SH
: return "Renesas / SuperH SH";
1818 case EM_SPARCV9
: return "Sparc v9";
1819 case EM_TRICORE
: return "Siemens Tricore";
1820 case EM_ARC
: return "ARC";
1821 case EM_H8_300
: return "Renesas H8/300";
1822 case EM_H8_300H
: return "Renesas H8/300H";
1823 case EM_H8S
: return "Renesas H8S";
1824 case EM_H8_500
: return "Renesas H8/500";
1825 case EM_IA_64
: return "Intel IA-64";
1826 case EM_MIPS_X
: return "Stanford MIPS-X";
1827 case EM_COLDFIRE
: return "Motorola Coldfire";
1828 case EM_68HC12
: return "Motorola M68HC12";
1829 case EM_ALPHA
: return "Alpha";
1830 case EM_CYGNUS_D10V
:
1831 case EM_D10V
: return "d10v";
1832 case EM_CYGNUS_D30V
:
1833 case EM_D30V
: return "d30v";
1834 case EM_CYGNUS_M32R
:
1835 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1836 case EM_CYGNUS_V850
:
1837 case EM_V850
: return "NEC v850";
1838 case EM_CYGNUS_MN10300
:
1839 case EM_MN10300
: return "mn10300";
1840 case EM_CYGNUS_MN10200
:
1841 case EM_MN10200
: return "mn10200";
1842 case EM_CYGNUS_FR30
:
1843 case EM_FR30
: return "Fujitsu FR30";
1844 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1846 case EM_PJ
: return "picoJava";
1847 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1848 case EM_PCP
: return "Siemens PCP";
1849 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1850 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1851 case EM_STARCORE
: return "Motorola Star*Core processor";
1852 case EM_ME16
: return "Toyota ME16 processor";
1853 case EM_ST100
: return "STMicroelectronics ST100 processor";
1854 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1855 case EM_PDSP
: return "Sony DSP processor";
1856 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
1857 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
1858 case EM_FX66
: return "Siemens FX66 microcontroller";
1859 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1860 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1861 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1862 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1863 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1864 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1865 case EM_SVX
: return "Silicon Graphics SVx";
1866 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1867 case EM_VAX
: return "Digital VAX";
1869 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1870 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1871 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1872 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1873 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1874 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1875 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1876 case EM_PRISM
: return "Vitesse Prism";
1877 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1878 case EM_L1OM
: return "Intel L1OM";
1880 case EM_S390
: return "IBM S/390";
1881 case EM_SCORE
: return "SUNPLUS S+Core";
1882 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1884 case EM_OR32
: return "OpenRISC";
1885 case EM_ARC_A5
: return "ARC International ARCompact processor";
1886 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1887 case EM_DLX
: return "OpenDLX";
1889 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1890 case EM_IQ2000
: return "Vitesse IQ2000";
1892 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1893 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
1894 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
1895 case EM_NS32K
: return "National Semiconductor 32000 series";
1896 case EM_TPC
: return "Tenor Network TPC processor";
1897 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
1898 case EM_MAX
: return "MAX Processor";
1899 case EM_CR
: return "National Semiconductor CompactRISC";
1900 case EM_F2MC16
: return "Fujitsu F2MC16";
1901 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
1902 case EM_LATTICEMICO32
: return "Lattice Mico32";
1904 case EM_M32C
: return "Renesas M32c";
1905 case EM_MT
: return "Morpho Techologies MT processor";
1906 case EM_BLACKFIN
: return "Analog Devices Blackfin";
1907 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
1908 case EM_SEP
: return "Sharp embedded microprocessor";
1909 case EM_ARCA
: return "Arca RISC microprocessor";
1910 case EM_UNICORE
: return "Unicore";
1911 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
1912 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
1913 case EM_NIOS32
: return "Altera Nios";
1914 case EM_ALTERA_NIOS2
: return "Altera Nios II";
1916 case EM_XC16X
: return "Infineon Technologies xc16x";
1917 case EM_M16C
: return "Renesas M16C series microprocessors";
1918 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
1919 case EM_CE
: return "Freescale Communication Engine RISC core";
1920 case EM_TSK3000
: return "Altium TSK3000 core";
1921 case EM_RS08
: return "Freescale RS08 embedded processor";
1922 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
1923 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
1924 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
1925 case EM_SE_C17
: return "Seiko Epson C17 family";
1926 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
1927 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
1928 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
1929 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
1930 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
1931 case EM_R32C
: return "Renesas R32C series microprocessors";
1932 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
1933 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
1934 case EM_8051
: return "Intel 8051 and variants";
1935 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
1936 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
1937 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
1938 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
1939 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
1940 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
1941 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
1942 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
1944 case EM_CR16_OLD
: return "National Semiconductor's CR16";
1945 case EM_MICROBLAZE
: return "Xilinx MicroBlaze";
1946 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
1947 case EM_RX
: return "Renesas RX";
1948 case EM_METAG
: return "Imagination Technologies META processor architecture";
1949 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
1950 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
1951 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
1952 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
1953 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
1954 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
1955 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
1956 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
1957 case EM_CUDA
: return "NVIDIA CUDA architecture";
1959 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
1965 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1970 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1971 e_flags
&= ~ EF_ARM_EABIMASK
;
1973 /* Handle "generic" ARM flags. */
1974 if (e_flags
& EF_ARM_RELEXEC
)
1976 strcat (buf
, ", relocatable executable");
1977 e_flags
&= ~ EF_ARM_RELEXEC
;
1980 if (e_flags
& EF_ARM_HASENTRY
)
1982 strcat (buf
, ", has entry point");
1983 e_flags
&= ~ EF_ARM_HASENTRY
;
1986 /* Now handle EABI specific flags. */
1990 strcat (buf
, ", <unrecognized EABI>");
1995 case EF_ARM_EABI_VER1
:
1996 strcat (buf
, ", Version1 EABI");
2001 /* Process flags one bit at a time. */
2002 flag
= e_flags
& - e_flags
;
2007 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2008 strcat (buf
, ", sorted symbol tables");
2018 case EF_ARM_EABI_VER2
:
2019 strcat (buf
, ", Version2 EABI");
2024 /* Process flags one bit at a time. */
2025 flag
= e_flags
& - e_flags
;
2030 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2031 strcat (buf
, ", sorted symbol tables");
2034 case EF_ARM_DYNSYMSUSESEGIDX
:
2035 strcat (buf
, ", dynamic symbols use segment index");
2038 case EF_ARM_MAPSYMSFIRST
:
2039 strcat (buf
, ", mapping symbols precede others");
2049 case EF_ARM_EABI_VER3
:
2050 strcat (buf
, ", Version3 EABI");
2053 case EF_ARM_EABI_VER4
:
2054 strcat (buf
, ", Version4 EABI");
2057 case EF_ARM_EABI_VER5
:
2058 strcat (buf
, ", Version5 EABI");
2064 /* Process flags one bit at a time. */
2065 flag
= e_flags
& - e_flags
;
2071 strcat (buf
, ", BE8");
2075 strcat (buf
, ", LE8");
2085 case EF_ARM_EABI_UNKNOWN
:
2086 strcat (buf
, ", GNU EABI");
2091 /* Process flags one bit at a time. */
2092 flag
= e_flags
& - e_flags
;
2097 case EF_ARM_INTERWORK
:
2098 strcat (buf
, ", interworking enabled");
2101 case EF_ARM_APCS_26
:
2102 strcat (buf
, ", uses APCS/26");
2105 case EF_ARM_APCS_FLOAT
:
2106 strcat (buf
, ", uses APCS/float");
2110 strcat (buf
, ", position independent");
2114 strcat (buf
, ", 8 bit structure alignment");
2117 case EF_ARM_NEW_ABI
:
2118 strcat (buf
, ", uses new ABI");
2121 case EF_ARM_OLD_ABI
:
2122 strcat (buf
, ", uses old ABI");
2125 case EF_ARM_SOFT_FLOAT
:
2126 strcat (buf
, ", software FP");
2129 case EF_ARM_VFP_FLOAT
:
2130 strcat (buf
, ", VFP");
2133 case EF_ARM_MAVERICK_FLOAT
:
2134 strcat (buf
, ", Maverick FP");
2145 strcat (buf
,", <unknown>");
2149 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2151 static char buf
[1024];
2163 decode_ARM_machine_flags (e_flags
, buf
);
2167 switch (e_flags
& EF_FRV_CPU_MASK
)
2169 case EF_FRV_CPU_GENERIC
:
2173 strcat (buf
, ", fr???");
2176 case EF_FRV_CPU_FR300
:
2177 strcat (buf
, ", fr300");
2180 case EF_FRV_CPU_FR400
:
2181 strcat (buf
, ", fr400");
2183 case EF_FRV_CPU_FR405
:
2184 strcat (buf
, ", fr405");
2187 case EF_FRV_CPU_FR450
:
2188 strcat (buf
, ", fr450");
2191 case EF_FRV_CPU_FR500
:
2192 strcat (buf
, ", fr500");
2194 case EF_FRV_CPU_FR550
:
2195 strcat (buf
, ", fr550");
2198 case EF_FRV_CPU_SIMPLE
:
2199 strcat (buf
, ", simple");
2201 case EF_FRV_CPU_TOMCAT
:
2202 strcat (buf
, ", tomcat");
2208 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2209 strcat (buf
, ", m68000");
2210 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2211 strcat (buf
, ", cpu32");
2212 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2213 strcat (buf
, ", fido_a");
2216 char const * isa
= _("unknown");
2217 char const * mac
= _("unknown mac");
2218 char const * additional
= NULL
;
2220 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2222 case EF_M68K_CF_ISA_A_NODIV
:
2224 additional
= ", nodiv";
2226 case EF_M68K_CF_ISA_A
:
2229 case EF_M68K_CF_ISA_A_PLUS
:
2232 case EF_M68K_CF_ISA_B_NOUSP
:
2234 additional
= ", nousp";
2236 case EF_M68K_CF_ISA_B
:
2240 strcat (buf
, ", cf, isa ");
2243 strcat (buf
, additional
);
2244 if (e_flags
& EF_M68K_CF_FLOAT
)
2245 strcat (buf
, ", float");
2246 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2251 case EF_M68K_CF_MAC
:
2254 case EF_M68K_CF_EMAC
:
2267 if (e_flags
& EF_PPC_EMB
)
2268 strcat (buf
, ", emb");
2270 if (e_flags
& EF_PPC_RELOCATABLE
)
2271 strcat (buf
, ", relocatable");
2273 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2274 strcat (buf
, ", relocatable-lib");
2278 case EM_CYGNUS_V850
:
2279 switch (e_flags
& EF_V850_ARCH
)
2282 strcat (buf
, ", v850e1");
2285 strcat (buf
, ", v850e");
2288 strcat (buf
, ", v850");
2291 strcat (buf
, ", unknown v850 architecture variant");
2297 case EM_CYGNUS_M32R
:
2298 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2299 strcat (buf
, ", m32r");
2303 case EM_MIPS_RS3_LE
:
2304 if (e_flags
& EF_MIPS_NOREORDER
)
2305 strcat (buf
, ", noreorder");
2307 if (e_flags
& EF_MIPS_PIC
)
2308 strcat (buf
, ", pic");
2310 if (e_flags
& EF_MIPS_CPIC
)
2311 strcat (buf
, ", cpic");
2313 if (e_flags
& EF_MIPS_UCODE
)
2314 strcat (buf
, ", ugen_reserved");
2316 if (e_flags
& EF_MIPS_ABI2
)
2317 strcat (buf
, ", abi2");
2319 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2320 strcat (buf
, ", odk first");
2322 if (e_flags
& EF_MIPS_32BITMODE
)
2323 strcat (buf
, ", 32bitmode");
2325 switch ((e_flags
& EF_MIPS_MACH
))
2327 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2328 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2329 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2330 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2331 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2332 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2333 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2334 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2335 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2336 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2337 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2338 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2339 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2340 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
2342 /* We simply ignore the field in this case to avoid confusion:
2343 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2346 default: strcat (buf
, ", unknown CPU"); break;
2349 switch ((e_flags
& EF_MIPS_ABI
))
2351 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2352 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2353 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2354 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2356 /* We simply ignore the field in this case to avoid confusion:
2357 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2358 This means it is likely to be an o32 file, but not for
2361 default: strcat (buf
, ", unknown ABI"); break;
2364 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2365 strcat (buf
, ", mdmx");
2367 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2368 strcat (buf
, ", mips16");
2370 switch ((e_flags
& EF_MIPS_ARCH
))
2372 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2373 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2374 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2375 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2376 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2377 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2378 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2379 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2380 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2381 default: strcat (buf
, ", unknown ISA"); break;
2387 switch ((e_flags
& EF_SH_MACH_MASK
))
2389 case EF_SH1
: strcat (buf
, ", sh1"); break;
2390 case EF_SH2
: strcat (buf
, ", sh2"); break;
2391 case EF_SH3
: strcat (buf
, ", sh3"); break;
2392 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2393 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2394 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2395 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2396 case EF_SH4
: strcat (buf
, ", sh4"); break;
2397 case EF_SH5
: strcat (buf
, ", sh5"); break;
2398 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2399 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2400 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2401 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2402 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2403 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2404 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2405 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2406 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2407 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2408 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2409 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2410 default: strcat (buf
, ", unknown ISA"); break;
2416 if (e_flags
& EF_SPARC_32PLUS
)
2417 strcat (buf
, ", v8+");
2419 if (e_flags
& EF_SPARC_SUN_US1
)
2420 strcat (buf
, ", ultrasparcI");
2422 if (e_flags
& EF_SPARC_SUN_US3
)
2423 strcat (buf
, ", ultrasparcIII");
2425 if (e_flags
& EF_SPARC_HAL_R1
)
2426 strcat (buf
, ", halr1");
2428 if (e_flags
& EF_SPARC_LEDATA
)
2429 strcat (buf
, ", ledata");
2431 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2432 strcat (buf
, ", tso");
2434 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2435 strcat (buf
, ", pso");
2437 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2438 strcat (buf
, ", rmo");
2442 switch (e_flags
& EF_PARISC_ARCH
)
2444 case EFA_PARISC_1_0
:
2445 strcpy (buf
, ", PA-RISC 1.0");
2447 case EFA_PARISC_1_1
:
2448 strcpy (buf
, ", PA-RISC 1.1");
2450 case EFA_PARISC_2_0
:
2451 strcpy (buf
, ", PA-RISC 2.0");
2456 if (e_flags
& EF_PARISC_TRAPNIL
)
2457 strcat (buf
, ", trapnil");
2458 if (e_flags
& EF_PARISC_EXT
)
2459 strcat (buf
, ", ext");
2460 if (e_flags
& EF_PARISC_LSB
)
2461 strcat (buf
, ", lsb");
2462 if (e_flags
& EF_PARISC_WIDE
)
2463 strcat (buf
, ", wide");
2464 if (e_flags
& EF_PARISC_NO_KABP
)
2465 strcat (buf
, ", no kabp");
2466 if (e_flags
& EF_PARISC_LAZYSWAP
)
2467 strcat (buf
, ", lazyswap");
2472 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2473 strcat (buf
, ", new calling convention");
2475 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2476 strcat (buf
, ", gnu calling convention");
2480 if ((e_flags
& EF_IA_64_ABI64
))
2481 strcat (buf
, ", 64-bit");
2483 strcat (buf
, ", 32-bit");
2484 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2485 strcat (buf
, ", reduced fp model");
2486 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2487 strcat (buf
, ", no function descriptors, constant gp");
2488 else if ((e_flags
& EF_IA_64_CONS_GP
))
2489 strcat (buf
, ", constant gp");
2490 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2491 strcat (buf
, ", absolute");
2495 if ((e_flags
& EF_VAX_NONPIC
))
2496 strcat (buf
, ", non-PIC");
2497 if ((e_flags
& EF_VAX_DFLOAT
))
2498 strcat (buf
, ", D-Float");
2499 if ((e_flags
& EF_VAX_GFLOAT
))
2500 strcat (buf
, ", G-Float");
2504 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
2505 strcat (buf
, ", 64-bit doubles");
2506 if (e_flags
& E_FLAG_RX_DSP
)
2507 strcat (buf
, ", dsp");
2515 get_osabi_name (unsigned int osabi
)
2517 static char buff
[32];
2521 case ELFOSABI_NONE
: return "UNIX - System V";
2522 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2523 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2524 case ELFOSABI_LINUX
: return "UNIX - Linux";
2525 case ELFOSABI_HURD
: return "GNU/Hurd";
2526 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2527 case ELFOSABI_AIX
: return "UNIX - AIX";
2528 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2529 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2530 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2531 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2532 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2533 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2534 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2535 case ELFOSABI_AROS
: return "AROS";
2536 case ELFOSABI_FENIXOS
: return "FenixOS";
2537 case ELFOSABI_STANDALONE
: return _("Standalone App");
2538 case ELFOSABI_ARM
: return "ARM";
2540 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2546 get_arm_segment_type (unsigned long type
)
2560 get_mips_segment_type (unsigned long type
)
2564 case PT_MIPS_REGINFO
:
2566 case PT_MIPS_RTPROC
:
2568 case PT_MIPS_OPTIONS
:
2578 get_parisc_segment_type (unsigned long type
)
2582 case PT_HP_TLS
: return "HP_TLS";
2583 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2584 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2585 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2586 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2587 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2588 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2589 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2590 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2591 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2592 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2593 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2594 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2595 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2596 case PT_HP_STACK
: return "HP_STACK";
2597 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2598 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2599 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2600 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2609 get_ia64_segment_type (unsigned long type
)
2613 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2614 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2615 case PT_HP_TLS
: return "HP_TLS";
2616 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2617 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2618 case PT_IA_64_HP_STACK
: return "HP_STACK";
2627 get_segment_type (unsigned long p_type
)
2629 static char buff
[32];
2633 case PT_NULL
: return "NULL";
2634 case PT_LOAD
: return "LOAD";
2635 case PT_DYNAMIC
: return "DYNAMIC";
2636 case PT_INTERP
: return "INTERP";
2637 case PT_NOTE
: return "NOTE";
2638 case PT_SHLIB
: return "SHLIB";
2639 case PT_PHDR
: return "PHDR";
2640 case PT_TLS
: return "TLS";
2642 case PT_GNU_EH_FRAME
:
2643 return "GNU_EH_FRAME";
2644 case PT_GNU_STACK
: return "GNU_STACK";
2645 case PT_GNU_RELRO
: return "GNU_RELRO";
2648 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2650 const char * result
;
2652 switch (elf_header
.e_machine
)
2655 result
= get_arm_segment_type (p_type
);
2658 case EM_MIPS_RS3_LE
:
2659 result
= get_mips_segment_type (p_type
);
2662 result
= get_parisc_segment_type (p_type
);
2665 result
= get_ia64_segment_type (p_type
);
2675 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2677 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2679 const char * result
;
2681 switch (elf_header
.e_machine
)
2684 result
= get_parisc_segment_type (p_type
);
2687 result
= get_ia64_segment_type (p_type
);
2697 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2700 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2707 get_mips_section_type_name (unsigned int sh_type
)
2711 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2712 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2713 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2714 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2715 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2716 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2717 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2718 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2719 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2720 case SHT_MIPS_RELD
: return "MIPS_RELD";
2721 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2722 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2723 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2724 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2725 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2726 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2727 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2728 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2729 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2730 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2731 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2732 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2733 case SHT_MIPS_LINE
: return "MIPS_LINE";
2734 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2735 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2736 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2737 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2738 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2739 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2740 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2741 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2742 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2743 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2744 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2745 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2746 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2747 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2748 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2749 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2757 get_parisc_section_type_name (unsigned int sh_type
)
2761 case SHT_PARISC_EXT
: return "PARISC_EXT";
2762 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2763 case SHT_PARISC_DOC
: return "PARISC_DOC";
2764 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2765 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2766 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2767 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2775 get_ia64_section_type_name (unsigned int sh_type
)
2777 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2778 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2779 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2783 case SHT_IA_64_EXT
: return "IA_64_EXT";
2784 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2785 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2786 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
2787 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
2788 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
2789 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
2790 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
2791 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
2792 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
2800 get_x86_64_section_type_name (unsigned int sh_type
)
2804 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2812 get_arm_section_type_name (unsigned int sh_type
)
2816 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
2817 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
2818 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
2819 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
2820 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
2828 get_section_type_name (unsigned int sh_type
)
2830 static char buff
[32];
2834 case SHT_NULL
: return "NULL";
2835 case SHT_PROGBITS
: return "PROGBITS";
2836 case SHT_SYMTAB
: return "SYMTAB";
2837 case SHT_STRTAB
: return "STRTAB";
2838 case SHT_RELA
: return "RELA";
2839 case SHT_HASH
: return "HASH";
2840 case SHT_DYNAMIC
: return "DYNAMIC";
2841 case SHT_NOTE
: return "NOTE";
2842 case SHT_NOBITS
: return "NOBITS";
2843 case SHT_REL
: return "REL";
2844 case SHT_SHLIB
: return "SHLIB";
2845 case SHT_DYNSYM
: return "DYNSYM";
2846 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2847 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2848 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2849 case SHT_GNU_HASH
: return "GNU_HASH";
2850 case SHT_GROUP
: return "GROUP";
2851 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2852 case SHT_GNU_verdef
: return "VERDEF";
2853 case SHT_GNU_verneed
: return "VERNEED";
2854 case SHT_GNU_versym
: return "VERSYM";
2855 case 0x6ffffff0: return "VERSYM";
2856 case 0x6ffffffc: return "VERDEF";
2857 case 0x7ffffffd: return "AUXILIARY";
2858 case 0x7fffffff: return "FILTER";
2859 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2862 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2864 const char * result
;
2866 switch (elf_header
.e_machine
)
2869 case EM_MIPS_RS3_LE
:
2870 result
= get_mips_section_type_name (sh_type
);
2873 result
= get_parisc_section_type_name (sh_type
);
2876 result
= get_ia64_section_type_name (sh_type
);
2880 result
= get_x86_64_section_type_name (sh_type
);
2883 result
= get_arm_section_type_name (sh_type
);
2893 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2895 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2897 const char * result
;
2899 switch (elf_header
.e_machine
)
2902 result
= get_ia64_section_type_name (sh_type
);
2912 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2914 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2915 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2917 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2923 #define OPTION_DEBUG_DUMP 512
2925 static struct option options
[] =
2927 {"all", no_argument
, 0, 'a'},
2928 {"file-header", no_argument
, 0, 'h'},
2929 {"program-headers", no_argument
, 0, 'l'},
2930 {"headers", no_argument
, 0, 'e'},
2931 {"histogram", no_argument
, 0, 'I'},
2932 {"segments", no_argument
, 0, 'l'},
2933 {"sections", no_argument
, 0, 'S'},
2934 {"section-headers", no_argument
, 0, 'S'},
2935 {"section-groups", no_argument
, 0, 'g'},
2936 {"section-details", no_argument
, 0, 't'},
2937 {"full-section-name",no_argument
, 0, 'N'},
2938 {"symbols", no_argument
, 0, 's'},
2939 {"syms", no_argument
, 0, 's'},
2940 {"relocs", no_argument
, 0, 'r'},
2941 {"notes", no_argument
, 0, 'n'},
2942 {"dynamic", no_argument
, 0, 'd'},
2943 {"arch-specific", no_argument
, 0, 'A'},
2944 {"version-info", no_argument
, 0, 'V'},
2945 {"use-dynamic", no_argument
, 0, 'D'},
2946 {"unwind", no_argument
, 0, 'u'},
2947 {"archive-index", no_argument
, 0, 'c'},
2948 {"hex-dump", required_argument
, 0, 'x'},
2949 {"relocated-dump", required_argument
, 0, 'R'},
2950 {"string-dump", required_argument
, 0, 'p'},
2951 #ifdef SUPPORT_DISASSEMBLY
2952 {"instruction-dump", required_argument
, 0, 'i'},
2954 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2956 {"version", no_argument
, 0, 'v'},
2957 {"wide", no_argument
, 0, 'W'},
2958 {"help", no_argument
, 0, 'H'},
2959 {0, no_argument
, 0, 0}
2963 usage (FILE * stream
)
2965 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2966 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
2967 fprintf (stream
, _(" Options are:\n\
2968 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2969 -h --file-header Display the ELF file header\n\
2970 -l --program-headers Display the program headers\n\
2971 --segments An alias for --program-headers\n\
2972 -S --section-headers Display the sections' header\n\
2973 --sections An alias for --section-headers\n\
2974 -g --section-groups Display the section groups\n\
2975 -t --section-details Display the section details\n\
2976 -e --headers Equivalent to: -h -l -S\n\
2977 -s --syms Display the symbol table\n\
2978 --symbols An alias for --syms\n\
2979 -n --notes Display the core notes (if present)\n\
2980 -r --relocs Display the relocations (if present)\n\
2981 -u --unwind Display the unwind info (if present)\n\
2982 -d --dynamic Display the dynamic section (if present)\n\
2983 -V --version-info Display the version sections (if present)\n\
2984 -A --arch-specific Display architecture specific information (if any).\n\
2985 -c --archive-index Display the symbol/file index in an archive\n\
2986 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2987 -x --hex-dump=<number|name>\n\
2988 Dump the contents of section <number|name> as bytes\n\
2989 -p --string-dump=<number|name>\n\
2990 Dump the contents of section <number|name> as strings\n\
2991 -R --relocated-dump=<number|name>\n\
2992 Dump the contents of section <number|name> as relocated bytes\n\
2993 -w[lLiaprmfFsoRt] or\n\
2994 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
2995 =frames-interp,=str,=loc,=Ranges,=pubtypes]\n\
2996 Display the contents of DWARF2 debug sections\n"));
2997 #ifdef SUPPORT_DISASSEMBLY
2998 fprintf (stream
, _("\
2999 -i --instruction-dump=<number|name>\n\
3000 Disassemble the contents of section <number|name>\n"));
3002 fprintf (stream
, _("\
3003 -I --histogram Display histogram of bucket list lengths\n\
3004 -W --wide Allow output width to exceed 80 characters\n\
3005 @<file> Read options from <file>\n\
3006 -H --help Display this information\n\
3007 -v --version Display the version number of readelf\n"));
3009 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3010 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
3012 exit (stream
== stdout
? 0 : 1);
3015 /* Record the fact that the user wants the contents of section number
3016 SECTION to be displayed using the method(s) encoded as flags bits
3017 in TYPE. Note, TYPE can be zero if we are creating the array for
3021 request_dump_bynumber (unsigned int section
, dump_type type
)
3023 if (section
>= num_dump_sects
)
3025 dump_type
* new_dump_sects
;
3027 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
3028 sizeof (* dump_sects
));
3030 if (new_dump_sects
== NULL
)
3031 error (_("Out of memory allocating dump request table.\n"));
3034 /* Copy current flag settings. */
3035 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
3039 dump_sects
= new_dump_sects
;
3040 num_dump_sects
= section
+ 1;
3045 dump_sects
[section
] |= type
;
3050 /* Request a dump by section name. */
3053 request_dump_byname (const char * section
, dump_type type
)
3055 struct dump_list_entry
* new_request
;
3057 new_request
= (struct dump_list_entry
*)
3058 malloc (sizeof (struct dump_list_entry
));
3060 error (_("Out of memory allocating dump request table.\n"));
3062 new_request
->name
= strdup (section
);
3063 if (!new_request
->name
)
3064 error (_("Out of memory allocating dump request table.\n"));
3066 new_request
->type
= type
;
3068 new_request
->next
= dump_sects_byname
;
3069 dump_sects_byname
= new_request
;
3073 request_dump (dump_type type
)
3079 section
= strtoul (optarg
, & cp
, 0);
3081 if (! *cp
&& section
>= 0)
3082 request_dump_bynumber (section
, type
);
3084 request_dump_byname (optarg
, type
);
3089 parse_args (int argc
, char ** argv
)
3096 while ((c
= getopt_long
3097 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
3115 do_section_groups
++;
3123 do_section_groups
++;
3128 do_section_details
++;
3172 request_dump (HEX_DUMP
);
3175 request_dump (STRING_DUMP
);
3178 request_dump (RELOC_DUMP
);
3185 dwarf_select_sections_all ();
3190 dwarf_select_sections_by_letters (optarg
);
3193 case OPTION_DEBUG_DUMP
:
3200 dwarf_select_sections_by_names (optarg
);
3203 #ifdef SUPPORT_DISASSEMBLY
3205 request_dump (DISASS_DUMP
);
3209 print_version (program_name
);
3218 /* xgettext:c-format */
3219 error (_("Invalid option '-%c'\n"), c
);
3226 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3227 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3228 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3229 && !do_section_groups
&& !do_archive_index
)
3233 warn (_("Nothing to do.\n"));
3239 get_elf_class (unsigned int elf_class
)
3241 static char buff
[32];
3245 case ELFCLASSNONE
: return _("none");
3246 case ELFCLASS32
: return "ELF32";
3247 case ELFCLASS64
: return "ELF64";
3249 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3255 get_data_encoding (unsigned int encoding
)
3257 static char buff
[32];
3261 case ELFDATANONE
: return _("none");
3262 case ELFDATA2LSB
: return _("2's complement, little endian");
3263 case ELFDATA2MSB
: return _("2's complement, big endian");
3265 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3270 /* Decode the data held in 'elf_header'. */
3273 process_file_header (void)
3275 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3276 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3277 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3278 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3281 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3285 init_dwarf_regnames (elf_header
.e_machine
);
3291 printf (_("ELF Header:\n"));
3292 printf (_(" Magic: "));
3293 for (i
= 0; i
< EI_NIDENT
; i
++)
3294 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3296 printf (_(" Class: %s\n"),
3297 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3298 printf (_(" Data: %s\n"),
3299 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3300 printf (_(" Version: %d %s\n"),
3301 elf_header
.e_ident
[EI_VERSION
],
3302 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3304 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3307 printf (_(" OS/ABI: %s\n"),
3308 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3309 printf (_(" ABI Version: %d\n"),
3310 elf_header
.e_ident
[EI_ABIVERSION
]);
3311 printf (_(" Type: %s\n"),
3312 get_file_type (elf_header
.e_type
));
3313 printf (_(" Machine: %s\n"),
3314 get_machine_name (elf_header
.e_machine
));
3315 printf (_(" Version: 0x%lx\n"),
3316 (unsigned long) elf_header
.e_version
);
3318 printf (_(" Entry point address: "));
3319 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3320 printf (_("\n Start of program headers: "));
3321 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3322 printf (_(" (bytes into file)\n Start of section headers: "));
3323 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3324 printf (_(" (bytes into file)\n"));
3326 printf (_(" Flags: 0x%lx%s\n"),
3327 (unsigned long) elf_header
.e_flags
,
3328 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3329 printf (_(" Size of this header: %ld (bytes)\n"),
3330 (long) elf_header
.e_ehsize
);
3331 printf (_(" Size of program headers: %ld (bytes)\n"),
3332 (long) elf_header
.e_phentsize
);
3333 printf (_(" Number of program headers: %ld\n"),
3334 (long) elf_header
.e_phnum
);
3335 printf (_(" Size of section headers: %ld (bytes)\n"),
3336 (long) elf_header
.e_shentsize
);
3337 printf (_(" Number of section headers: %ld"),
3338 (long) elf_header
.e_shnum
);
3339 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
3340 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3341 putc ('\n', stdout
);
3342 printf (_(" Section header string table index: %ld"),
3343 (long) elf_header
.e_shstrndx
);
3344 if (section_headers
!= NULL
3345 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3346 printf (" (%u)", section_headers
[0].sh_link
);
3347 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3348 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3349 printf (" <corrupt: out of range>");
3350 putc ('\n', stdout
);
3353 if (section_headers
!= NULL
)
3355 if (elf_header
.e_shnum
== SHN_UNDEF
)
3356 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3357 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3358 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3359 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3360 elf_header
.e_shstrndx
= SHN_UNDEF
;
3361 free (section_headers
);
3362 section_headers
= NULL
;
3370 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* program_headers
)
3372 Elf32_External_Phdr
* phdrs
;
3373 Elf32_External_Phdr
* external
;
3374 Elf_Internal_Phdr
* internal
;
3377 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3378 elf_header
.e_phentsize
,
3380 _("program headers"));
3384 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3385 i
< elf_header
.e_phnum
;
3386 i
++, internal
++, external
++)
3388 internal
->p_type
= BYTE_GET (external
->p_type
);
3389 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3390 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3391 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3392 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3393 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3394 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3395 internal
->p_align
= BYTE_GET (external
->p_align
);
3404 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* program_headers
)
3406 Elf64_External_Phdr
* phdrs
;
3407 Elf64_External_Phdr
* external
;
3408 Elf_Internal_Phdr
* internal
;
3411 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3412 elf_header
.e_phentsize
,
3414 _("program headers"));
3418 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3419 i
< elf_header
.e_phnum
;
3420 i
++, internal
++, external
++)
3422 internal
->p_type
= BYTE_GET (external
->p_type
);
3423 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3424 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3425 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3426 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3427 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3428 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3429 internal
->p_align
= BYTE_GET (external
->p_align
);
3437 /* Returns 1 if the program headers were read into `program_headers'. */
3440 get_program_headers (FILE * file
)
3442 Elf_Internal_Phdr
* phdrs
;
3444 /* Check cache of prior read. */
3445 if (program_headers
!= NULL
)
3448 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
3449 sizeof (Elf_Internal_Phdr
));
3453 error (_("Out of memory\n"));
3458 ? get_32bit_program_headers (file
, phdrs
)
3459 : get_64bit_program_headers (file
, phdrs
))
3461 program_headers
= phdrs
;
3469 /* Returns 1 if the program headers were loaded. */
3472 process_program_headers (FILE * file
)
3474 Elf_Internal_Phdr
* segment
;
3477 if (elf_header
.e_phnum
== 0)
3480 printf (_("\nThere are no program headers in this file.\n"));
3484 if (do_segments
&& !do_header
)
3486 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3487 printf (_("Entry point "));
3488 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3489 printf (_("\nThere are %d program headers, starting at offset "),
3490 elf_header
.e_phnum
);
3491 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3495 if (! get_program_headers (file
))
3500 if (elf_header
.e_phnum
> 1)
3501 printf (_("\nProgram Headers:\n"));
3503 printf (_("\nProgram Headers:\n"));
3507 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3510 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3514 (_(" Type Offset VirtAddr PhysAddr\n"));
3516 (_(" FileSiz MemSiz Flags Align\n"));
3523 for (i
= 0, segment
= program_headers
;
3524 i
< elf_header
.e_phnum
;
3529 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3533 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3534 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3535 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3536 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3537 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3539 (segment
->p_flags
& PF_R
? 'R' : ' '),
3540 (segment
->p_flags
& PF_W
? 'W' : ' '),
3541 (segment
->p_flags
& PF_X
? 'E' : ' '));
3542 printf ("%#lx", (unsigned long) segment
->p_align
);
3546 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3547 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3550 print_vma (segment
->p_offset
, FULL_HEX
);
3554 print_vma (segment
->p_vaddr
, FULL_HEX
);
3556 print_vma (segment
->p_paddr
, FULL_HEX
);
3559 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3560 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3563 print_vma (segment
->p_filesz
, FULL_HEX
);
3567 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3568 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3571 print_vma (segment
->p_offset
, FULL_HEX
);
3575 (segment
->p_flags
& PF_R
? 'R' : ' '),
3576 (segment
->p_flags
& PF_W
? 'W' : ' '),
3577 (segment
->p_flags
& PF_X
? 'E' : ' '));
3579 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3580 printf ("%#lx", (unsigned long) segment
->p_align
);
3583 print_vma (segment
->p_align
, PREFIX_HEX
);
3588 print_vma (segment
->p_offset
, FULL_HEX
);
3590 print_vma (segment
->p_vaddr
, FULL_HEX
);
3592 print_vma (segment
->p_paddr
, FULL_HEX
);
3594 print_vma (segment
->p_filesz
, FULL_HEX
);
3596 print_vma (segment
->p_memsz
, FULL_HEX
);
3598 (segment
->p_flags
& PF_R
? 'R' : ' '),
3599 (segment
->p_flags
& PF_W
? 'W' : ' '),
3600 (segment
->p_flags
& PF_X
? 'E' : ' '));
3601 print_vma (segment
->p_align
, HEX
);
3605 switch (segment
->p_type
)
3609 error (_("more than one dynamic segment\n"));
3611 /* By default, assume that the .dynamic section is the first
3612 section in the DYNAMIC segment. */
3613 dynamic_addr
= segment
->p_offset
;
3614 dynamic_size
= segment
->p_filesz
;
3616 /* Try to locate the .dynamic section. If there is
3617 a section header table, we can easily locate it. */
3618 if (section_headers
!= NULL
)
3620 Elf_Internal_Shdr
* sec
;
3622 sec
= find_section (".dynamic");
3623 if (sec
== NULL
|| sec
->sh_size
== 0)
3625 error (_("no .dynamic section in the dynamic segment\n"));
3629 if (sec
->sh_type
== SHT_NOBITS
)
3635 dynamic_addr
= sec
->sh_offset
;
3636 dynamic_size
= sec
->sh_size
;
3638 if (dynamic_addr
< segment
->p_offset
3639 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3640 warn (_("the .dynamic section is not contained"
3641 " within the dynamic segment\n"));
3642 else if (dynamic_addr
> segment
->p_offset
)
3643 warn (_("the .dynamic section is not the first section"
3644 " in the dynamic segment.\n"));
3649 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3651 error (_("Unable to find program interpreter name\n"));
3655 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
3657 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
3658 error (_("Internal error: failed to create format string to display program interpreter\n"));
3660 program_interpreter
[0] = 0;
3661 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
3662 error (_("Unable to read program interpreter name\n"));
3665 printf (_("\n [Requesting program interpreter: %s]"),
3666 program_interpreter
);
3672 putc ('\n', stdout
);
3675 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3677 printf (_("\n Section to Segment mapping:\n"));
3678 printf (_(" Segment Sections...\n"));
3680 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3683 Elf_Internal_Shdr
* section
;
3685 segment
= program_headers
+ i
;
3686 section
= section_headers
+ 1;
3688 printf (" %2.2d ", i
);
3690 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3692 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY (section
, segment
))
3693 printf ("%s ", SECTION_NAME (section
));
3704 /* Find the file offset corresponding to VMA by using the program headers. */
3707 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
3709 Elf_Internal_Phdr
* seg
;
3711 if (! get_program_headers (file
))
3713 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3717 for (seg
= program_headers
;
3718 seg
< program_headers
+ elf_header
.e_phnum
;
3721 if (seg
->p_type
!= PT_LOAD
)
3724 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3725 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3726 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3729 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3730 (unsigned long) vma
);
3736 get_32bit_section_headers (FILE * file
, unsigned int num
)
3738 Elf32_External_Shdr
* shdrs
;
3739 Elf_Internal_Shdr
* internal
;
3742 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
3743 elf_header
.e_shentsize
, num
,
3744 _("section headers"));
3748 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
3749 sizeof (Elf_Internal_Shdr
));
3751 if (section_headers
== NULL
)
3753 error (_("Out of memory\n"));
3757 for (i
= 0, internal
= section_headers
;
3761 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3762 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3763 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3764 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3765 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3766 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3767 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3768 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3769 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3770 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3779 get_64bit_section_headers (FILE * file
, unsigned int num
)
3781 Elf64_External_Shdr
* shdrs
;
3782 Elf_Internal_Shdr
* internal
;
3785 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
3786 elf_header
.e_shentsize
, num
,
3787 _("section headers"));
3791 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
3792 sizeof (Elf_Internal_Shdr
));
3794 if (section_headers
== NULL
)
3796 error (_("Out of memory\n"));
3800 for (i
= 0, internal
= section_headers
;
3804 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3805 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3806 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3807 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3808 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3809 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3810 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3811 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3812 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3813 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3821 static Elf_Internal_Sym
*
3822 get_32bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
3824 unsigned long number
;
3825 Elf32_External_Sym
* esyms
;
3826 Elf_External_Sym_Shndx
* shndx
;
3827 Elf_Internal_Sym
* isyms
;
3828 Elf_Internal_Sym
* psym
;
3831 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
3832 section
->sh_size
, _("symbols"));
3837 if (symtab_shndx_hdr
!= NULL
3838 && (symtab_shndx_hdr
->sh_link
3839 == (unsigned long) (section
- section_headers
)))
3841 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
3842 symtab_shndx_hdr
->sh_offset
,
3843 1, symtab_shndx_hdr
->sh_size
,
3852 number
= section
->sh_size
/ section
->sh_entsize
;
3853 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
3857 error (_("Out of memory\n"));
3864 for (j
= 0, psym
= isyms
;
3868 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3869 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3870 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3871 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3872 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3874 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3875 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3876 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3877 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3878 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3888 static Elf_Internal_Sym
*
3889 get_64bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
3891 unsigned long number
;
3892 Elf64_External_Sym
* esyms
;
3893 Elf_External_Sym_Shndx
* shndx
;
3894 Elf_Internal_Sym
* isyms
;
3895 Elf_Internal_Sym
* psym
;
3898 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
3899 section
->sh_size
, _("symbols"));
3904 if (symtab_shndx_hdr
!= NULL
3905 && (symtab_shndx_hdr
->sh_link
3906 == (unsigned long) (section
- section_headers
)))
3908 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
3909 symtab_shndx_hdr
->sh_offset
,
3910 1, symtab_shndx_hdr
->sh_size
,
3919 number
= section
->sh_size
/ section
->sh_entsize
;
3920 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
3924 error (_("Out of memory\n"));
3931 for (j
= 0, psym
= isyms
;
3935 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3936 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3937 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3938 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3939 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3941 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3942 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3943 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3944 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3945 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3956 get_elf_section_flags (bfd_vma sh_flags
)
3958 static char buff
[1024];
3960 int field_size
= is_32bit_elf
? 8 : 16;
3961 int index
, size
= sizeof (buff
) - (field_size
+ 4 + 1);
3962 bfd_vma os_flags
= 0;
3963 bfd_vma proc_flags
= 0;
3964 bfd_vma unknown_flags
= 0;
3972 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
3973 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
3974 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
3975 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
3976 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
3977 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
3978 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
3979 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
3980 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
3981 /* 9 */ { STRING_COMMA_LEN ("TLS") },
3982 /* IA-64 specific. */
3983 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
3984 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
3985 /* IA-64 OpenVMS specific. */
3986 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
3987 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
3988 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
3989 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
3990 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
3991 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
3992 /* SPARC specific. */
3993 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
3994 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
3997 if (do_section_details
)
3999 sprintf (buff
, "[%*.*lx]: ",
4000 field_size
, field_size
, (unsigned long) sh_flags
);
4001 p
+= field_size
+ 4;
4008 flag
= sh_flags
& - sh_flags
;
4011 if (do_section_details
)
4015 case SHF_WRITE
: index
= 0; break;
4016 case SHF_ALLOC
: index
= 1; break;
4017 case SHF_EXECINSTR
: index
= 2; break;
4018 case SHF_MERGE
: index
= 3; break;
4019 case SHF_STRINGS
: index
= 4; break;
4020 case SHF_INFO_LINK
: index
= 5; break;
4021 case SHF_LINK_ORDER
: index
= 6; break;
4022 case SHF_OS_NONCONFORMING
: index
= 7; break;
4023 case SHF_GROUP
: index
= 8; break;
4024 case SHF_TLS
: index
= 9; break;
4028 switch (elf_header
.e_machine
)
4031 if (flag
== SHF_IA_64_SHORT
)
4033 else if (flag
== SHF_IA_64_NORECOV
)
4036 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
4039 case SHF_IA_64_VMS_GLOBAL
: index
= 12; break;
4040 case SHF_IA_64_VMS_OVERLAID
: index
= 13; break;
4041 case SHF_IA_64_VMS_SHARED
: index
= 14; break;
4042 case SHF_IA_64_VMS_VECTOR
: index
= 15; break;
4043 case SHF_IA_64_VMS_ALLOC_64BIT
: index
= 16; break;
4044 case SHF_IA_64_VMS_PROTECTED
: index
= 17; break;
4053 case EM_OLD_SPARCV9
:
4054 case EM_SPARC32PLUS
:
4057 if (flag
== SHF_EXCLUDE
)
4059 else if (flag
== SHF_ORDERED
)
4069 if (p
!= buff
+ field_size
+ 4)
4071 if (size
< (10 + 2))
4078 size
-= flags
[index
].len
;
4079 p
= stpcpy (p
, flags
[index
].str
);
4081 else if (flag
& SHF_MASKOS
)
4083 else if (flag
& SHF_MASKPROC
)
4086 unknown_flags
|= flag
;
4092 case SHF_WRITE
: *p
= 'W'; break;
4093 case SHF_ALLOC
: *p
= 'A'; break;
4094 case SHF_EXECINSTR
: *p
= 'X'; break;
4095 case SHF_MERGE
: *p
= 'M'; break;
4096 case SHF_STRINGS
: *p
= 'S'; break;
4097 case SHF_INFO_LINK
: *p
= 'I'; break;
4098 case SHF_LINK_ORDER
: *p
= 'L'; break;
4099 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
4100 case SHF_GROUP
: *p
= 'G'; break;
4101 case SHF_TLS
: *p
= 'T'; break;
4104 if ((elf_header
.e_machine
== EM_X86_64
4105 || elf_header
.e_machine
== EM_L1OM
)
4106 && flag
== SHF_X86_64_LARGE
)
4108 else if (flag
& SHF_MASKOS
)
4111 sh_flags
&= ~ SHF_MASKOS
;
4113 else if (flag
& SHF_MASKPROC
)
4116 sh_flags
&= ~ SHF_MASKPROC
;
4126 if (do_section_details
)
4130 size
-= 5 + field_size
;
4131 if (p
!= buff
+ field_size
+ 4)
4139 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4140 (unsigned long) os_flags
);
4141 p
+= 5 + field_size
;
4145 size
-= 7 + field_size
;
4146 if (p
!= buff
+ field_size
+ 4)
4154 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4155 (unsigned long) proc_flags
);
4156 p
+= 7 + field_size
;
4160 size
-= 10 + field_size
;
4161 if (p
!= buff
+ field_size
+ 4)
4169 sprintf (p
, "UNKNOWN (%*.*lx)", field_size
, field_size
,
4170 (unsigned long) unknown_flags
);
4171 p
+= 10 + field_size
;
4180 process_section_headers (FILE * file
)
4182 Elf_Internal_Shdr
* section
;
4185 section_headers
= NULL
;
4187 if (elf_header
.e_shnum
== 0)
4190 printf (_("\nThere are no sections in this file.\n"));
4195 if (do_sections
&& !do_header
)
4196 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4197 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4201 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4204 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4207 /* Read in the string table, so that we have names to display. */
4208 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4209 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4211 section
= section_headers
+ elf_header
.e_shstrndx
;
4213 if (section
->sh_size
!= 0)
4215 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4216 1, section
->sh_size
,
4219 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4223 /* Scan the sections for the dynamic symbol table
4224 and dynamic string table and debug sections. */
4225 dynamic_symbols
= NULL
;
4226 dynamic_strings
= NULL
;
4227 dynamic_syminfo
= NULL
;
4228 symtab_shndx_hdr
= NULL
;
4230 eh_addr_size
= is_32bit_elf
? 4 : 8;
4231 switch (elf_header
.e_machine
)
4234 case EM_MIPS_RS3_LE
:
4235 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4236 FDE addresses. However, the ABI also has a semi-official ILP32
4237 variant for which the normal FDE address size rules apply.
4239 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4240 section, where XX is the size of longs in bits. Unfortunately,
4241 earlier compilers provided no way of distinguishing ILP32 objects
4242 from LP64 objects, so if there's any doubt, we should assume that
4243 the official LP64 form is being used. */
4244 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4245 && find_section (".gcc_compiled_long32") == NULL
)
4251 switch (elf_header
.e_flags
& EF_H8_MACH
)
4253 case E_H8_MACH_H8300
:
4254 case E_H8_MACH_H8300HN
:
4255 case E_H8_MACH_H8300SN
:
4256 case E_H8_MACH_H8300SXN
:
4259 case E_H8_MACH_H8300H
:
4260 case E_H8_MACH_H8300S
:
4261 case E_H8_MACH_H8300SX
:
4269 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
4271 case EF_M32C_CPU_M16C
:
4278 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4281 size_t expected_entsize \
4282 = is_32bit_elf ? size32 : size64; \
4283 if (section->sh_entsize != expected_entsize) \
4284 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4285 i, (unsigned long int) section->sh_entsize, \
4286 (unsigned long int) expected_entsize); \
4287 section->sh_entsize = expected_entsize; \
4290 #define CHECK_ENTSIZE(section, i, type) \
4291 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4292 sizeof (Elf64_External_##type))
4294 for (i
= 0, section
= section_headers
;
4295 i
< elf_header
.e_shnum
;
4298 char * name
= SECTION_NAME (section
);
4300 if (section
->sh_type
== SHT_DYNSYM
)
4302 if (dynamic_symbols
!= NULL
)
4304 error (_("File contains multiple dynamic symbol tables\n"));
4308 CHECK_ENTSIZE (section
, i
, Sym
);
4309 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4310 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4312 else if (section
->sh_type
== SHT_STRTAB
4313 && streq (name
, ".dynstr"))
4315 if (dynamic_strings
!= NULL
)
4317 error (_("File contains multiple dynamic string tables\n"));
4321 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4322 1, section
->sh_size
,
4323 _("dynamic strings"));
4324 dynamic_strings_length
= section
->sh_size
;
4326 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4328 if (symtab_shndx_hdr
!= NULL
)
4330 error (_("File contains multiple symtab shndx tables\n"));
4333 symtab_shndx_hdr
= section
;
4335 else if (section
->sh_type
== SHT_SYMTAB
)
4336 CHECK_ENTSIZE (section
, i
, Sym
);
4337 else if (section
->sh_type
== SHT_GROUP
)
4338 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4339 else if (section
->sh_type
== SHT_REL
)
4340 CHECK_ENTSIZE (section
, i
, Rel
);
4341 else if (section
->sh_type
== SHT_RELA
)
4342 CHECK_ENTSIZE (section
, i
, Rela
);
4343 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4344 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
4345 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
4346 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
)
4347 && (const_strneq (name
, ".debug_")
4348 || const_strneq (name
, ".zdebug_")))
4351 name
+= sizeof (".zdebug_") - 1;
4353 name
+= sizeof (".debug_") - 1;
4356 || (do_debug_info
&& streq (name
, "info"))
4357 || (do_debug_info
&& streq (name
, "types"))
4358 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4359 || (do_debug_lines
&& streq (name
, "line"))
4360 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4361 || (do_debug_pubtypes
&& streq (name
, "pubtypes"))
4362 || (do_debug_aranges
&& streq (name
, "aranges"))
4363 || (do_debug_ranges
&& streq (name
, "ranges"))
4364 || (do_debug_frames
&& streq (name
, "frame"))
4365 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4366 || (do_debug_str
&& streq (name
, "str"))
4367 || (do_debug_loc
&& streq (name
, "loc"))
4369 request_dump_bynumber (i
, DEBUG_DUMP
);
4371 /* Linkonce section to be combined with .debug_info at link time. */
4372 else if ((do_debugging
|| do_debug_info
)
4373 && const_strneq (name
, ".gnu.linkonce.wi."))
4374 request_dump_bynumber (i
, DEBUG_DUMP
);
4375 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4376 request_dump_bynumber (i
, DEBUG_DUMP
);
4382 if (elf_header
.e_shnum
> 1)
4383 printf (_("\nSection Headers:\n"));
4385 printf (_("\nSection Header:\n"));
4389 if (do_section_details
)
4391 printf (_(" [Nr] Name\n"));
4392 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4396 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4400 if (do_section_details
)
4402 printf (_(" [Nr] Name\n"));
4403 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4407 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4411 if (do_section_details
)
4413 printf (_(" [Nr] Name\n"));
4414 printf (_(" Type Address Offset Link\n"));
4415 printf (_(" Size EntSize Info Align\n"));
4419 printf (_(" [Nr] Name Type Address Offset\n"));
4420 printf (_(" Size EntSize Flags Link Info Align\n"));
4424 if (do_section_details
)
4425 printf (_(" Flags\n"));
4427 for (i
= 0, section
= section_headers
;
4428 i
< elf_header
.e_shnum
;
4431 if (do_section_details
)
4433 printf (" [%2u] %s\n",
4435 SECTION_NAME (section
));
4436 if (is_32bit_elf
|| do_wide
)
4437 printf (" %-15.15s ",
4438 get_section_type_name (section
->sh_type
));
4441 printf ((do_wide
? " [%2u] %-17s %-15s "
4442 : " [%2u] %-17.17s %-15.15s "),
4444 SECTION_NAME (section
),
4445 get_section_type_name (section
->sh_type
));
4449 const char * link_too_big
= NULL
;
4451 print_vma (section
->sh_addr
, LONG_HEX
);
4453 printf ( " %6.6lx %6.6lx %2.2lx",
4454 (unsigned long) section
->sh_offset
,
4455 (unsigned long) section
->sh_size
,
4456 (unsigned long) section
->sh_entsize
);
4458 if (do_section_details
)
4459 fputs (" ", stdout
);
4461 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4463 if (section
->sh_link
>= elf_header
.e_shnum
)
4466 /* The sh_link value is out of range. Normally this indicates
4467 an error but it can have special values in Solaris binaries. */
4468 switch (elf_header
.e_machine
)
4473 case EM_OLD_SPARCV9
:
4474 case EM_SPARC32PLUS
:
4477 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
4478 link_too_big
= "BEFORE";
4479 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
4480 link_too_big
= "AFTER";
4487 if (do_section_details
)
4489 if (link_too_big
!= NULL
&& * link_too_big
)
4490 printf ("<%s> ", link_too_big
);
4492 printf ("%2u ", section
->sh_link
);
4493 printf ("%3u %2lu\n", section
->sh_info
,
4494 (unsigned long) section
->sh_addralign
);
4497 printf ("%2u %3u %2lu\n",
4500 (unsigned long) section
->sh_addralign
);
4502 if (link_too_big
&& ! * link_too_big
)
4503 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4504 i
, section
->sh_link
);
4508 print_vma (section
->sh_addr
, LONG_HEX
);
4510 if ((long) section
->sh_offset
== section
->sh_offset
)
4511 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4515 print_vma (section
->sh_offset
, LONG_HEX
);
4518 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4519 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4523 print_vma (section
->sh_size
, LONG_HEX
);
4526 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4527 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4531 print_vma (section
->sh_entsize
, LONG_HEX
);
4534 if (do_section_details
)
4535 fputs (" ", stdout
);
4537 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4539 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
4541 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4542 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
4545 print_vma (section
->sh_addralign
, DEC
);
4549 else if (do_section_details
)
4551 printf (" %-15.15s ",
4552 get_section_type_name (section
->sh_type
));
4553 print_vma (section
->sh_addr
, LONG_HEX
);
4554 if ((long) section
->sh_offset
== section
->sh_offset
)
4555 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4559 print_vma (section
->sh_offset
, LONG_HEX
);
4561 printf (" %u\n ", section
->sh_link
);
4562 print_vma (section
->sh_size
, LONG_HEX
);
4564 print_vma (section
->sh_entsize
, LONG_HEX
);
4566 printf (" %-16u %lu\n",
4568 (unsigned long) section
->sh_addralign
);
4573 print_vma (section
->sh_addr
, LONG_HEX
);
4574 if ((long) section
->sh_offset
== section
->sh_offset
)
4575 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4579 print_vma (section
->sh_offset
, LONG_HEX
);
4582 print_vma (section
->sh_size
, LONG_HEX
);
4584 print_vma (section
->sh_entsize
, LONG_HEX
);
4586 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4588 printf (" %2u %3u %lu\n",
4591 (unsigned long) section
->sh_addralign
);
4594 if (do_section_details
)
4595 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4598 if (!do_section_details
)
4599 printf (_("Key to Flags:\n\
4600 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4601 I (info), L (link order), G (group), x (unknown)\n\
4602 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4608 get_group_flags (unsigned int flags
)
4610 static char buff
[32];
4617 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4624 process_section_groups (FILE * file
)
4626 Elf_Internal_Shdr
* section
;
4628 struct group
* group
;
4629 Elf_Internal_Shdr
* symtab_sec
;
4630 Elf_Internal_Shdr
* strtab_sec
;
4631 Elf_Internal_Sym
* symtab
;
4635 /* Don't process section groups unless needed. */
4636 if (!do_unwind
&& !do_section_groups
)
4639 if (elf_header
.e_shnum
== 0)
4641 if (do_section_groups
)
4642 printf (_("\nThere are no sections in this file.\n"));
4647 if (section_headers
== NULL
)
4649 error (_("Section headers are not available!\n"));
4653 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
4654 sizeof (struct group
*));
4656 if (section_headers_groups
== NULL
)
4658 error (_("Out of memory\n"));
4662 /* Scan the sections for the group section. */
4664 for (i
= 0, section
= section_headers
;
4665 i
< elf_header
.e_shnum
;
4667 if (section
->sh_type
== SHT_GROUP
)
4670 if (group_count
== 0)
4672 if (do_section_groups
)
4673 printf (_("\nThere are no section groups in this file.\n"));
4678 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
4680 if (section_groups
== NULL
)
4682 error (_("Out of memory\n"));
4691 for (i
= 0, section
= section_headers
, group
= section_groups
;
4692 i
< elf_header
.e_shnum
;
4695 if (section
->sh_type
== SHT_GROUP
)
4697 char * name
= SECTION_NAME (section
);
4699 unsigned char * start
;
4700 unsigned char * indices
;
4701 unsigned int entry
, j
, size
;
4702 Elf_Internal_Shdr
* sec
;
4703 Elf_Internal_Sym
* sym
;
4705 /* Get the symbol table. */
4706 if (section
->sh_link
>= elf_header
.e_shnum
4707 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
4710 error (_("Bad sh_link in group section `%s'\n"), name
);
4714 if (symtab_sec
!= sec
)
4719 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4722 sym
= symtab
+ section
->sh_info
;
4724 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4726 if (sym
->st_shndx
== 0
4727 || sym
->st_shndx
>= elf_header
.e_shnum
)
4729 error (_("Bad sh_info in group section `%s'\n"), name
);
4733 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
4742 /* Get the string table. */
4743 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
4752 != (sec
= section_headers
+ symtab_sec
->sh_link
))
4757 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
4758 1, strtab_sec
->sh_size
,
4760 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4762 group_name
= sym
->st_name
< strtab_size
4763 ? strtab
+ sym
->st_name
: "<corrupt>";
4766 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
4767 1, section
->sh_size
,
4771 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4772 entry
= byte_get (indices
, 4);
4775 if (do_section_groups
)
4777 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4778 get_group_flags (entry
), i
, name
, group_name
, size
);
4780 printf (_(" [Index] Name\n"));
4783 group
->group_index
= i
;
4785 for (j
= 0; j
< size
; j
++)
4787 struct group_list
* g
;
4789 entry
= byte_get (indices
, 4);
4792 if (entry
>= elf_header
.e_shnum
)
4794 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4795 entry
, i
, elf_header
.e_shnum
- 1);
4799 if (section_headers_groups
[entry
] != NULL
)
4803 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4805 section_headers_groups
[entry
]->group_index
);
4810 /* Intel C/C++ compiler may put section 0 in a
4811 section group. We just warn it the first time
4812 and ignore it afterwards. */
4813 static int warned
= 0;
4816 error (_("section 0 in group section [%5u]\n"),
4817 section_headers_groups
[entry
]->group_index
);
4823 section_headers_groups
[entry
] = group
;
4825 if (do_section_groups
)
4827 sec
= section_headers
+ entry
;
4828 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4831 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
4832 g
->section_index
= entry
;
4833 g
->next
= group
->root
;
4857 } dynamic_relocations
[] =
4859 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4860 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4861 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4864 /* Process the reloc section. */
4867 process_relocs (FILE * file
)
4869 unsigned long rel_size
;
4870 unsigned long rel_offset
;
4876 if (do_using_dynamic
)
4880 int has_dynamic_reloc
;
4883 has_dynamic_reloc
= 0;
4885 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4887 is_rela
= dynamic_relocations
[i
].rela
;
4888 name
= dynamic_relocations
[i
].name
;
4889 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4890 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4892 has_dynamic_reloc
|= rel_size
;
4894 if (is_rela
== UNKNOWN
)
4896 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4897 switch (dynamic_info
[DT_PLTREL
])
4911 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4912 name
, rel_offset
, rel_size
);
4914 dump_relocations (file
,
4915 offset_from_vma (file
, rel_offset
, rel_size
),
4917 dynamic_symbols
, num_dynamic_syms
,
4918 dynamic_strings
, dynamic_strings_length
, is_rela
);
4922 if (! has_dynamic_reloc
)
4923 printf (_("\nThere are no dynamic relocations in this file.\n"));
4927 Elf_Internal_Shdr
* section
;
4931 for (i
= 0, section
= section_headers
;
4932 i
< elf_header
.e_shnum
;
4935 if ( section
->sh_type
!= SHT_RELA
4936 && section
->sh_type
!= SHT_REL
)
4939 rel_offset
= section
->sh_offset
;
4940 rel_size
= section
->sh_size
;
4944 Elf_Internal_Shdr
* strsec
;
4947 printf (_("\nRelocation section "));
4949 if (string_table
== NULL
)
4950 printf ("%d", section
->sh_name
);
4952 printf (_("'%s'"), SECTION_NAME (section
));
4954 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4955 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4957 is_rela
= section
->sh_type
== SHT_RELA
;
4959 if (section
->sh_link
!= 0
4960 && section
->sh_link
< elf_header
.e_shnum
)
4962 Elf_Internal_Shdr
* symsec
;
4963 Elf_Internal_Sym
* symtab
;
4964 unsigned long nsyms
;
4965 unsigned long strtablen
= 0;
4966 char * strtab
= NULL
;
4968 symsec
= section_headers
+ section
->sh_link
;
4969 if (symsec
->sh_type
!= SHT_SYMTAB
4970 && symsec
->sh_type
!= SHT_DYNSYM
)
4973 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4974 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4979 if (symsec
->sh_link
!= 0
4980 && symsec
->sh_link
< elf_header
.e_shnum
)
4982 strsec
= section_headers
+ symsec
->sh_link
;
4984 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
4987 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4990 dump_relocations (file
, rel_offset
, rel_size
,
4991 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4997 dump_relocations (file
, rel_offset
, rel_size
,
4998 NULL
, 0, NULL
, 0, is_rela
);
5005 printf (_("\nThere are no relocations in this file.\n"));
5011 /* Process the unwind section. */
5013 #include "unwind-ia64.h"
5015 /* An absolute address consists of a section and an offset. If the
5016 section is NULL, the offset itself is the address, otherwise, the
5017 address equals to LOAD_ADDRESS(section) + offset. */
5021 unsigned short section
;
5025 #define ABSADDR(a) \
5027 ? section_headers [(a).section].sh_addr + (a).offset \
5030 struct ia64_unw_table_entry
5032 struct absaddr start
;
5034 struct absaddr info
;
5037 struct ia64_unw_aux_info
5040 struct ia64_unw_table_entry
*table
; /* Unwind table. */
5041 unsigned long table_len
; /* Length of unwind table. */
5042 unsigned char * info
; /* Unwind info. */
5043 unsigned long info_size
; /* Size of unwind info. */
5044 bfd_vma info_addr
; /* starting address of unwind info. */
5045 bfd_vma seg_base
; /* Starting address of segment. */
5046 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5047 unsigned long nsyms
; /* Number of symbols. */
5048 char * strtab
; /* The string table. */
5049 unsigned long strtab_size
; /* Size of string table. */
5053 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
5054 unsigned long nsyms
,
5055 const char * strtab
,
5056 unsigned long strtab_size
,
5057 struct absaddr addr
,
5058 const char ** symname
,
5061 bfd_vma dist
= 0x100000;
5062 Elf_Internal_Sym
* sym
;
5063 Elf_Internal_Sym
* best
= NULL
;
5066 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
5068 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
5069 && sym
->st_name
!= 0
5070 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
5071 && addr
.offset
>= sym
->st_value
5072 && addr
.offset
- sym
->st_value
< dist
)
5075 dist
= addr
.offset
- sym
->st_value
;
5082 *symname
= (best
->st_name
>= strtab_size
5083 ? "<corrupt>" : strtab
+ best
->st_name
);
5088 *offset
= addr
.offset
;
5092 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
5094 struct ia64_unw_table_entry
* tp
;
5097 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5101 const unsigned char * dp
;
5102 const unsigned char * head
;
5103 const char * procname
;
5105 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5106 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
5108 fputs ("\n<", stdout
);
5112 fputs (procname
, stdout
);
5115 printf ("+%lx", (unsigned long) offset
);
5118 fputs (">: [", stdout
);
5119 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5120 fputc ('-', stdout
);
5121 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5122 printf ("], info at +0x%lx\n",
5123 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
5125 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
5126 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
5128 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5129 (unsigned) UNW_VER (stamp
),
5130 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
5131 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
5132 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
5133 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
5135 if (UNW_VER (stamp
) != 1)
5137 printf ("\tUnknown version.\n");
5142 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
5143 dp
= unw_decode (dp
, in_body
, & in_body
);
5148 slurp_ia64_unwind_table (FILE * file
,
5149 struct ia64_unw_aux_info
* aux
,
5150 Elf_Internal_Shdr
* sec
)
5152 unsigned long size
, nrelas
, i
;
5153 Elf_Internal_Phdr
* seg
;
5154 struct ia64_unw_table_entry
* tep
;
5155 Elf_Internal_Shdr
* relsec
;
5156 Elf_Internal_Rela
* rela
;
5157 Elf_Internal_Rela
* rp
;
5158 unsigned char * table
;
5160 Elf_Internal_Sym
* sym
;
5161 const char * relname
;
5163 /* First, find the starting address of the segment that includes
5166 if (elf_header
.e_phnum
)
5168 if (! get_program_headers (file
))
5171 for (seg
= program_headers
;
5172 seg
< program_headers
+ elf_header
.e_phnum
;
5175 if (seg
->p_type
!= PT_LOAD
)
5178 if (sec
->sh_addr
>= seg
->p_vaddr
5179 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5181 aux
->seg_base
= seg
->p_vaddr
;
5187 /* Second, build the unwind table from the contents of the unwind section: */
5188 size
= sec
->sh_size
;
5189 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
5194 aux
->table
= (struct ia64_unw_table_entry
*)
5195 xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
5197 for (tp
= table
; tp
< table
+ size
; ++tep
)
5199 tep
->start
.section
= SHN_UNDEF
;
5200 tep
->end
.section
= SHN_UNDEF
;
5201 tep
->info
.section
= SHN_UNDEF
;
5202 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5203 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5204 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5205 tep
->start
.offset
+= aux
->seg_base
;
5206 tep
->end
.offset
+= aux
->seg_base
;
5207 tep
->info
.offset
+= aux
->seg_base
;
5211 /* Third, apply any relocations to the unwind table: */
5212 for (relsec
= section_headers
;
5213 relsec
< section_headers
+ elf_header
.e_shnum
;
5216 if (relsec
->sh_type
!= SHT_RELA
5217 || relsec
->sh_info
>= elf_header
.e_shnum
5218 || section_headers
+ relsec
->sh_info
!= sec
)
5221 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5225 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5227 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5228 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5230 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5232 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5236 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5238 switch (rp
->r_offset
/eh_addr_size
% 3)
5241 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5242 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
5245 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5246 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
5249 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5250 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
5260 aux
->table_len
= size
/ (3 * eh_addr_size
);
5265 ia64_process_unwind (FILE * file
)
5267 Elf_Internal_Shdr
* sec
;
5268 Elf_Internal_Shdr
* unwsec
= NULL
;
5269 Elf_Internal_Shdr
* strsec
;
5270 unsigned long i
, unwcount
= 0, unwstart
= 0;
5271 struct ia64_unw_aux_info aux
;
5273 memset (& aux
, 0, sizeof (aux
));
5275 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5277 if (sec
->sh_type
== SHT_SYMTAB
5278 && sec
->sh_link
< elf_header
.e_shnum
)
5280 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5281 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5283 strsec
= section_headers
+ sec
->sh_link
;
5284 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5287 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5289 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5294 printf (_("\nThere are no unwind sections in this file.\n"));
5296 while (unwcount
-- > 0)
5301 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5302 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5303 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5310 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5312 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5314 /* We need to find which section group it is in. */
5315 struct group_list
* g
= section_headers_groups
[i
]->root
;
5317 for (; g
!= NULL
; g
= g
->next
)
5319 sec
= section_headers
+ g
->section_index
;
5321 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5326 i
= elf_header
.e_shnum
;
5328 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5330 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5331 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5332 suffix
= SECTION_NAME (unwsec
) + len
;
5333 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5335 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5336 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5341 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5342 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5343 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5344 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5346 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5347 suffix
= SECTION_NAME (unwsec
) + len
;
5348 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5350 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5351 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5355 if (i
== elf_header
.e_shnum
)
5357 printf (_("\nCould not find unwind info section for "));
5359 if (string_table
== NULL
)
5360 printf ("%d", unwsec
->sh_name
);
5362 printf (_("'%s'"), SECTION_NAME (unwsec
));
5366 aux
.info_size
= sec
->sh_size
;
5367 aux
.info_addr
= sec
->sh_addr
;
5368 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
5372 printf (_("\nUnwind section "));
5374 if (string_table
== NULL
)
5375 printf ("%d", unwsec
->sh_name
);
5377 printf (_("'%s'"), SECTION_NAME (unwsec
));
5379 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5380 (unsigned long) unwsec
->sh_offset
,
5381 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5383 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5385 if (aux
.table_len
> 0)
5386 dump_ia64_unwind (& aux
);
5389 free ((char *) aux
.table
);
5391 free ((char *) aux
.info
);
5400 free ((char *) aux
.strtab
);
5405 struct hppa_unw_table_entry
5407 struct absaddr start
;
5409 unsigned int Cannot_unwind
:1; /* 0 */
5410 unsigned int Millicode
:1; /* 1 */
5411 unsigned int Millicode_save_sr0
:1; /* 2 */
5412 unsigned int Region_description
:2; /* 3..4 */
5413 unsigned int reserved1
:1; /* 5 */
5414 unsigned int Entry_SR
:1; /* 6 */
5415 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5416 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5417 unsigned int Args_stored
:1; /* 16 */
5418 unsigned int Variable_Frame
:1; /* 17 */
5419 unsigned int Separate_Package_Body
:1; /* 18 */
5420 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5421 unsigned int Stack_Overflow_Check
:1; /* 20 */
5422 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5423 unsigned int Ada_Region
:1; /* 22 */
5424 unsigned int cxx_info
:1; /* 23 */
5425 unsigned int cxx_try_catch
:1; /* 24 */
5426 unsigned int sched_entry_seq
:1; /* 25 */
5427 unsigned int reserved2
:1; /* 26 */
5428 unsigned int Save_SP
:1; /* 27 */
5429 unsigned int Save_RP
:1; /* 28 */
5430 unsigned int Save_MRP_in_frame
:1; /* 29 */
5431 unsigned int extn_ptr_defined
:1; /* 30 */
5432 unsigned int Cleanup_defined
:1; /* 31 */
5434 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5435 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5436 unsigned int Large_frame
:1; /* 2 */
5437 unsigned int Pseudo_SP_Set
:1; /* 3 */
5438 unsigned int reserved4
:1; /* 4 */
5439 unsigned int Total_frame_size
:27; /* 5..31 */
5442 struct hppa_unw_aux_info
5444 struct hppa_unw_table_entry
*table
; /* Unwind table. */
5445 unsigned long table_len
; /* Length of unwind table. */
5446 bfd_vma seg_base
; /* Starting address of segment. */
5447 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5448 unsigned long nsyms
; /* Number of symbols. */
5449 char * strtab
; /* The string table. */
5450 unsigned long strtab_size
; /* Size of string table. */
5454 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
5456 struct hppa_unw_table_entry
* tp
;
5458 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5461 const char * procname
;
5463 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5464 aux
->strtab_size
, tp
->start
, &procname
,
5467 fputs ("\n<", stdout
);
5471 fputs (procname
, stdout
);
5474 printf ("+%lx", (unsigned long) offset
);
5477 fputs (">: [", stdout
);
5478 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5479 fputc ('-', stdout
);
5480 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5483 #define PF(_m) if (tp->_m) printf (#_m " ");
5484 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5487 PF(Millicode_save_sr0
);
5488 /* PV(Region_description); */
5494 PF(Separate_Package_Body
);
5495 PF(Frame_Extension_Millicode
);
5496 PF(Stack_Overflow_Check
);
5497 PF(Two_Instruction_SP_Increment
);
5501 PF(sched_entry_seq
);
5504 PF(Save_MRP_in_frame
);
5505 PF(extn_ptr_defined
);
5506 PF(Cleanup_defined
);
5507 PF(MPE_XL_interrupt_marker
);
5508 PF(HP_UX_interrupt_marker
);
5511 PV(Total_frame_size
);
5520 slurp_hppa_unwind_table (FILE * file
,
5521 struct hppa_unw_aux_info
* aux
,
5522 Elf_Internal_Shdr
* sec
)
5524 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5525 Elf_Internal_Phdr
* seg
;
5526 struct hppa_unw_table_entry
* tep
;
5527 Elf_Internal_Shdr
* relsec
;
5528 Elf_Internal_Rela
* rela
;
5529 Elf_Internal_Rela
* rp
;
5530 unsigned char * table
;
5532 Elf_Internal_Sym
* sym
;
5533 const char * relname
;
5535 /* First, find the starting address of the segment that includes
5538 if (elf_header
.e_phnum
)
5540 if (! get_program_headers (file
))
5543 for (seg
= program_headers
;
5544 seg
< program_headers
+ elf_header
.e_phnum
;
5547 if (seg
->p_type
!= PT_LOAD
)
5550 if (sec
->sh_addr
>= seg
->p_vaddr
5551 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5553 aux
->seg_base
= seg
->p_vaddr
;
5559 /* Second, build the unwind table from the contents of the unwind
5561 size
= sec
->sh_size
;
5562 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
5568 nentries
= size
/ unw_ent_size
;
5569 size
= unw_ent_size
* nentries
;
5571 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
5572 xcmalloc (nentries
, sizeof (aux
->table
[0]));
5574 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5576 unsigned int tmp1
, tmp2
;
5578 tep
->start
.section
= SHN_UNDEF
;
5579 tep
->end
.section
= SHN_UNDEF
;
5581 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5582 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5583 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5584 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5586 tep
->start
.offset
+= aux
->seg_base
;
5587 tep
->end
.offset
+= aux
->seg_base
;
5589 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5590 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5591 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5592 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5593 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5594 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5595 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5596 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5597 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5598 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5599 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5600 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5601 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5602 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5603 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5604 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5605 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5606 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5607 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5608 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5609 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5610 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5611 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5612 tep
->Cleanup_defined
= tmp1
& 0x1;
5614 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5615 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5616 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5617 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5618 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5619 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5623 /* Third, apply any relocations to the unwind table. */
5624 for (relsec
= section_headers
;
5625 relsec
< section_headers
+ elf_header
.e_shnum
;
5628 if (relsec
->sh_type
!= SHT_RELA
5629 || relsec
->sh_info
>= elf_header
.e_shnum
5630 || section_headers
+ relsec
->sh_info
!= sec
)
5633 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5637 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5639 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
5640 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5642 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5643 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
5645 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5649 i
= rp
->r_offset
/ unw_ent_size
;
5651 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5654 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5655 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
5658 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5659 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
5669 aux
->table_len
= nentries
;
5675 hppa_process_unwind (FILE * file
)
5677 struct hppa_unw_aux_info aux
;
5678 Elf_Internal_Shdr
* unwsec
= NULL
;
5679 Elf_Internal_Shdr
* strsec
;
5680 Elf_Internal_Shdr
* sec
;
5683 memset (& aux
, 0, sizeof (aux
));
5685 if (string_table
== NULL
)
5688 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5690 if (sec
->sh_type
== SHT_SYMTAB
5691 && sec
->sh_link
< elf_header
.e_shnum
)
5693 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5694 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5696 strsec
= section_headers
+ sec
->sh_link
;
5697 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5700 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5702 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5707 printf (_("\nThere are no unwind sections in this file.\n"));
5709 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5711 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5713 printf (_("\nUnwind section "));
5714 printf (_("'%s'"), SECTION_NAME (sec
));
5716 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5717 (unsigned long) sec
->sh_offset
,
5718 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5720 slurp_hppa_unwind_table (file
, &aux
, sec
);
5721 if (aux
.table_len
> 0)
5722 dump_hppa_unwind (&aux
);
5725 free ((char *) aux
.table
);
5733 free ((char *) aux
.strtab
);
5739 process_unwind (FILE * file
)
5741 struct unwind_handler
5744 int (* handler
)(FILE *);
5747 { EM_IA_64
, ia64_process_unwind
},
5748 { EM_PARISC
, hppa_process_unwind
},
5756 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5757 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5758 return handlers
[i
].handler (file
);
5760 printf (_("\nThere are no unwind sections in this file.\n"));
5765 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
5767 switch (entry
->d_tag
)
5770 if (entry
->d_un
.d_val
== 0)
5774 static const char * opts
[] =
5776 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5777 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5778 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5779 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5784 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
5785 if (entry
->d_un
.d_val
& (1 << cnt
))
5787 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5794 case DT_MIPS_IVERSION
:
5795 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5796 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5798 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5801 case DT_MIPS_TIME_STAMP
:
5806 time_t time
= entry
->d_un
.d_val
;
5807 tmp
= gmtime (&time
);
5808 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5809 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5810 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5811 printf ("Time Stamp: %s\n", timebuf
);
5815 case DT_MIPS_RLD_VERSION
:
5816 case DT_MIPS_LOCAL_GOTNO
:
5817 case DT_MIPS_CONFLICTNO
:
5818 case DT_MIPS_LIBLISTNO
:
5819 case DT_MIPS_SYMTABNO
:
5820 case DT_MIPS_UNREFEXTNO
:
5821 case DT_MIPS_HIPAGENO
:
5822 case DT_MIPS_DELTA_CLASS_NO
:
5823 case DT_MIPS_DELTA_INSTANCE_NO
:
5824 case DT_MIPS_DELTA_RELOC_NO
:
5825 case DT_MIPS_DELTA_SYM_NO
:
5826 case DT_MIPS_DELTA_CLASSSYM_NO
:
5827 case DT_MIPS_COMPACT_SIZE
:
5828 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5832 printf ("%#lx\n", (unsigned long) entry
->d_un
.d_ptr
);
5838 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
5840 switch (entry
->d_tag
)
5842 case DT_HP_DLD_FLAGS
:
5851 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5852 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5853 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5854 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5855 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5856 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5857 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5858 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5859 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5860 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5861 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
5862 { DT_HP_GST
, "HP_GST" },
5863 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
5864 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
5865 { DT_HP_NODELETE
, "HP_NODELETE" },
5866 { DT_HP_GROUP
, "HP_GROUP" },
5867 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
5871 bfd_vma val
= entry
->d_un
.d_val
;
5873 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
5874 if (val
& flags
[cnt
].bit
)
5878 fputs (flags
[cnt
].str
, stdout
);
5880 val
^= flags
[cnt
].bit
;
5883 if (val
!= 0 || first
)
5887 print_vma (val
, HEX
);
5893 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5900 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
5902 switch (entry
->d_tag
)
5904 case DT_IA_64_PLT_RESERVE
:
5905 /* First 3 slots reserved. */
5906 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5908 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5912 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5919 get_32bit_dynamic_section (FILE * file
)
5921 Elf32_External_Dyn
* edyn
;
5922 Elf32_External_Dyn
* ext
;
5923 Elf_Internal_Dyn
* entry
;
5925 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
5926 dynamic_size
, _("dynamic section"));
5930 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5931 might not have the luxury of section headers. Look for the DT_NULL
5932 terminator to determine the number of entries. */
5933 for (ext
= edyn
, dynamic_nent
= 0;
5934 (char *) ext
< (char *) edyn
+ dynamic_size
;
5938 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5942 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
5944 if (dynamic_section
== NULL
)
5946 error (_("Out of memory\n"));
5951 for (ext
= edyn
, entry
= dynamic_section
;
5952 entry
< dynamic_section
+ dynamic_nent
;
5955 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5956 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5965 get_64bit_dynamic_section (FILE * file
)
5967 Elf64_External_Dyn
* edyn
;
5968 Elf64_External_Dyn
* ext
;
5969 Elf_Internal_Dyn
* entry
;
5971 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
5972 dynamic_size
, _("dynamic section"));
5976 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5977 might not have the luxury of section headers. Look for the DT_NULL
5978 terminator to determine the number of entries. */
5979 for (ext
= edyn
, dynamic_nent
= 0;
5980 (char *) ext
< (char *) edyn
+ dynamic_size
;
5984 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5988 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
5990 if (dynamic_section
== NULL
)
5992 error (_("Out of memory\n"));
5997 for (ext
= edyn
, entry
= dynamic_section
;
5998 entry
< dynamic_section
+ dynamic_nent
;
6001 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
6002 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
6011 print_dynamic_flags (bfd_vma flags
)
6019 flag
= flags
& - flags
;
6029 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
6030 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
6031 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
6032 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
6033 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
6034 default: fputs ("unknown", stdout
); break;
6040 /* Parse and display the contents of the dynamic section. */
6043 process_dynamic_section (FILE * file
)
6045 Elf_Internal_Dyn
* entry
;
6047 if (dynamic_size
== 0)
6050 printf (_("\nThere is no dynamic section in this file.\n"));
6057 if (! get_32bit_dynamic_section (file
))
6060 else if (! get_64bit_dynamic_section (file
))
6063 /* Find the appropriate symbol table. */
6064 if (dynamic_symbols
== NULL
)
6066 for (entry
= dynamic_section
;
6067 entry
< dynamic_section
+ dynamic_nent
;
6070 Elf_Internal_Shdr section
;
6072 if (entry
->d_tag
!= DT_SYMTAB
)
6075 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
6077 /* Since we do not know how big the symbol table is,
6078 we default to reading in the entire file (!) and
6079 processing that. This is overkill, I know, but it
6081 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
6083 if (archive_file_offset
!= 0)
6084 section
.sh_size
= archive_file_size
- section
.sh_offset
;
6087 if (fseek (file
, 0, SEEK_END
))
6088 error (_("Unable to seek to end of file!\n"));
6090 section
.sh_size
= ftell (file
) - section
.sh_offset
;
6094 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
6096 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
6098 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
6099 if (num_dynamic_syms
< 1)
6101 error (_("Unable to determine the number of symbols to load\n"));
6105 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
6109 /* Similarly find a string table. */
6110 if (dynamic_strings
== NULL
)
6112 for (entry
= dynamic_section
;
6113 entry
< dynamic_section
+ dynamic_nent
;
6116 unsigned long offset
;
6119 if (entry
->d_tag
!= DT_STRTAB
)
6122 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
6124 /* Since we do not know how big the string table is,
6125 we default to reading in the entire file (!) and
6126 processing that. This is overkill, I know, but it
6129 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
6131 if (archive_file_offset
!= 0)
6132 str_tab_len
= archive_file_size
- offset
;
6135 if (fseek (file
, 0, SEEK_END
))
6136 error (_("Unable to seek to end of file\n"));
6137 str_tab_len
= ftell (file
) - offset
;
6140 if (str_tab_len
< 1)
6143 (_("Unable to determine the length of the dynamic string table\n"));
6147 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
6149 _("dynamic string table"));
6150 dynamic_strings_length
= str_tab_len
;
6155 /* And find the syminfo section if available. */
6156 if (dynamic_syminfo
== NULL
)
6158 unsigned long syminsz
= 0;
6160 for (entry
= dynamic_section
;
6161 entry
< dynamic_section
+ dynamic_nent
;
6164 if (entry
->d_tag
== DT_SYMINENT
)
6166 /* Note: these braces are necessary to avoid a syntax
6167 error from the SunOS4 C compiler. */
6168 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
6170 else if (entry
->d_tag
== DT_SYMINSZ
)
6171 syminsz
= entry
->d_un
.d_val
;
6172 else if (entry
->d_tag
== DT_SYMINFO
)
6173 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
6177 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
6179 Elf_External_Syminfo
* extsyminfo
;
6180 Elf_External_Syminfo
* extsym
;
6181 Elf_Internal_Syminfo
* syminfo
;
6183 /* There is a syminfo section. Read the data. */
6184 extsyminfo
= (Elf_External_Syminfo
*)
6185 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
6186 _("symbol information"));
6190 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
6191 if (dynamic_syminfo
== NULL
)
6193 error (_("Out of memory\n"));
6197 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
6198 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
6199 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
6200 ++syminfo
, ++extsym
)
6202 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
6203 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
6210 if (do_dynamic
&& dynamic_addr
)
6211 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
6212 dynamic_addr
, dynamic_nent
);
6214 printf (_(" Tag Type Name/Value\n"));
6216 for (entry
= dynamic_section
;
6217 entry
< dynamic_section
+ dynamic_nent
;
6225 print_vma (entry
->d_tag
, FULL_HEX
);
6226 dtype
= get_dynamic_type (entry
->d_tag
);
6227 printf (" (%s)%*s", dtype
,
6228 ((is_32bit_elf
? 27 : 19)
6229 - (int) strlen (dtype
)),
6233 switch (entry
->d_tag
)
6237 print_dynamic_flags (entry
->d_un
.d_val
);
6247 switch (entry
->d_tag
)
6250 printf (_("Auxiliary library"));
6254 printf (_("Filter library"));
6258 printf (_("Configuration file"));
6262 printf (_("Dependency audit library"));
6266 printf (_("Audit library"));
6270 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6271 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
6275 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6284 printf (_("Flags:"));
6286 if (entry
->d_un
.d_val
== 0)
6287 printf (_(" None\n"));
6290 unsigned long int val
= entry
->d_un
.d_val
;
6292 if (val
& DTF_1_PARINIT
)
6294 printf (" PARINIT");
6295 val
^= DTF_1_PARINIT
;
6297 if (val
& DTF_1_CONFEXP
)
6299 printf (" CONFEXP");
6300 val
^= DTF_1_CONFEXP
;
6303 printf (" %lx", val
);
6312 printf (_("Flags:"));
6314 if (entry
->d_un
.d_val
== 0)
6315 printf (_(" None\n"));
6318 unsigned long int val
= entry
->d_un
.d_val
;
6320 if (val
& DF_P1_LAZYLOAD
)
6322 printf (" LAZYLOAD");
6323 val
^= DF_P1_LAZYLOAD
;
6325 if (val
& DF_P1_GROUPPERM
)
6327 printf (" GROUPPERM");
6328 val
^= DF_P1_GROUPPERM
;
6331 printf (" %lx", val
);
6340 printf (_("Flags:"));
6341 if (entry
->d_un
.d_val
== 0)
6342 printf (_(" None\n"));
6345 unsigned long int val
= entry
->d_un
.d_val
;
6352 if (val
& DF_1_GLOBAL
)
6357 if (val
& DF_1_GROUP
)
6362 if (val
& DF_1_NODELETE
)
6364 printf (" NODELETE");
6365 val
^= DF_1_NODELETE
;
6367 if (val
& DF_1_LOADFLTR
)
6369 printf (" LOADFLTR");
6370 val
^= DF_1_LOADFLTR
;
6372 if (val
& DF_1_INITFIRST
)
6374 printf (" INITFIRST");
6375 val
^= DF_1_INITFIRST
;
6377 if (val
& DF_1_NOOPEN
)
6382 if (val
& DF_1_ORIGIN
)
6387 if (val
& DF_1_DIRECT
)
6392 if (val
& DF_1_TRANS
)
6397 if (val
& DF_1_INTERPOSE
)
6399 printf (" INTERPOSE");
6400 val
^= DF_1_INTERPOSE
;
6402 if (val
& DF_1_NODEFLIB
)
6404 printf (" NODEFLIB");
6405 val
^= DF_1_NODEFLIB
;
6407 if (val
& DF_1_NODUMP
)
6412 if (val
& DF_1_CONLFAT
)
6414 printf (" CONLFAT");
6415 val
^= DF_1_CONLFAT
;
6418 printf (" %lx", val
);
6425 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6427 puts (get_dynamic_type (entry
->d_un
.d_val
));
6447 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6453 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6454 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6460 switch (entry
->d_tag
)
6463 printf (_("Shared library: [%s]"), name
);
6465 if (streq (name
, program_interpreter
))
6466 printf (_(" program interpreter"));
6470 printf (_("Library soname: [%s]"), name
);
6474 printf (_("Library rpath: [%s]"), name
);
6478 printf (_("Library runpath: [%s]"), name
);
6482 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6487 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6500 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6504 case DT_INIT_ARRAYSZ
:
6505 case DT_FINI_ARRAYSZ
:
6506 case DT_GNU_CONFLICTSZ
:
6507 case DT_GNU_LIBLISTSZ
:
6510 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6511 printf (" (bytes)\n");
6521 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6534 if (entry
->d_tag
== DT_USED
6535 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6537 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6541 printf (_("Not needed object: [%s]\n"), name
);
6546 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6552 /* The value of this entry is ignored. */
6557 case DT_GNU_PRELINKED
:
6561 time_t time
= entry
->d_un
.d_val
;
6563 tmp
= gmtime (&time
);
6564 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6565 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6566 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6572 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
6575 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6581 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6582 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6587 switch (elf_header
.e_machine
)
6590 case EM_MIPS_RS3_LE
:
6591 dynamic_section_mips_val (entry
);
6594 dynamic_section_parisc_val (entry
);
6597 dynamic_section_ia64_val (entry
);
6600 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6612 get_ver_flags (unsigned int flags
)
6614 static char buff
[32];
6621 if (flags
& VER_FLG_BASE
)
6622 strcat (buff
, "BASE ");
6624 if (flags
& VER_FLG_WEAK
)
6626 if (flags
& VER_FLG_BASE
)
6627 strcat (buff
, "| ");
6629 strcat (buff
, "WEAK ");
6632 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6633 strcat (buff
, "| <unknown>");
6638 /* Display the contents of the version sections. */
6641 process_version_sections (FILE * file
)
6643 Elf_Internal_Shdr
* section
;
6650 for (i
= 0, section
= section_headers
;
6651 i
< elf_header
.e_shnum
;
6654 switch (section
->sh_type
)
6656 case SHT_GNU_verdef
:
6658 Elf_External_Verdef
* edefs
;
6666 (_("\nVersion definition section '%s' contains %u entries:\n"),
6667 SECTION_NAME (section
), section
->sh_info
);
6669 printf (_(" Addr: 0x"));
6670 printf_vma (section
->sh_addr
);
6671 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6672 (unsigned long) section
->sh_offset
, section
->sh_link
,
6673 section
->sh_link
< elf_header
.e_shnum
6674 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6677 edefs
= (Elf_External_Verdef
*)
6678 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
6679 _("version definition section"));
6680 endbuf
= (char *) edefs
+ section
->sh_size
;
6684 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6687 Elf_External_Verdef
* edef
;
6688 Elf_Internal_Verdef ent
;
6689 Elf_External_Verdaux
* eaux
;
6690 Elf_Internal_Verdaux aux
;
6694 vstart
= ((char *) edefs
) + idx
;
6695 if (vstart
+ sizeof (*edef
) > endbuf
)
6698 edef
= (Elf_External_Verdef
*) vstart
;
6700 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6701 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6702 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6703 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6704 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6705 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6706 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6708 printf (_(" %#06x: Rev: %d Flags: %s"),
6709 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6711 printf (_(" Index: %d Cnt: %d "),
6712 ent
.vd_ndx
, ent
.vd_cnt
);
6714 vstart
+= ent
.vd_aux
;
6716 eaux
= (Elf_External_Verdaux
*) vstart
;
6718 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6719 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6721 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6722 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6724 printf (_("Name index: %ld\n"), aux
.vda_name
);
6726 isum
= idx
+ ent
.vd_aux
;
6728 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6730 isum
+= aux
.vda_next
;
6731 vstart
+= aux
.vda_next
;
6733 eaux
= (Elf_External_Verdaux
*) vstart
;
6734 if (vstart
+ sizeof (*eaux
) > endbuf
)
6737 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6738 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6740 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6741 printf (_(" %#06x: Parent %d: %s\n"),
6742 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6744 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6745 isum
, j
, aux
.vda_name
);
6748 printf (_(" Version def aux past end of section\n"));
6752 if (cnt
< section
->sh_info
)
6753 printf (_(" Version definition past end of section\n"));
6759 case SHT_GNU_verneed
:
6761 Elf_External_Verneed
* eneed
;
6768 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
6769 SECTION_NAME (section
), section
->sh_info
);
6771 printf (_(" Addr: 0x"));
6772 printf_vma (section
->sh_addr
);
6773 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6774 (unsigned long) section
->sh_offset
, section
->sh_link
,
6775 section
->sh_link
< elf_header
.e_shnum
6776 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6779 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
6780 section
->sh_offset
, 1,
6782 _("version need section"));
6783 endbuf
= (char *) eneed
+ section
->sh_size
;
6787 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6789 Elf_External_Verneed
* entry
;
6790 Elf_Internal_Verneed ent
;
6795 vstart
= ((char *) eneed
) + idx
;
6796 if (vstart
+ sizeof (*entry
) > endbuf
)
6799 entry
= (Elf_External_Verneed
*) vstart
;
6801 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6802 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6803 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6804 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6805 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6807 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6809 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6810 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6812 printf (_(" File: %lx"), ent
.vn_file
);
6814 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6816 vstart
+= ent
.vn_aux
;
6818 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6820 Elf_External_Vernaux
* eaux
;
6821 Elf_Internal_Vernaux aux
;
6823 if (vstart
+ sizeof (*eaux
) > endbuf
)
6825 eaux
= (Elf_External_Vernaux
*) vstart
;
6827 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6828 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6829 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6830 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6831 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6833 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6834 printf (_(" %#06x: Name: %s"),
6835 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6837 printf (_(" %#06x: Name index: %lx"),
6838 isum
, aux
.vna_name
);
6840 printf (_(" Flags: %s Version: %d\n"),
6841 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6843 isum
+= aux
.vna_next
;
6844 vstart
+= aux
.vna_next
;
6847 printf (_(" Version need aux past end of section\n"));
6851 if (cnt
< section
->sh_info
)
6852 printf (_(" Version need past end of section\n"));
6858 case SHT_GNU_versym
:
6860 Elf_Internal_Shdr
* link_section
;
6863 unsigned char * edata
;
6864 unsigned short * data
;
6866 Elf_Internal_Sym
* symbols
;
6867 Elf_Internal_Shdr
* string_sec
;
6870 if (section
->sh_link
>= elf_header
.e_shnum
)
6873 link_section
= section_headers
+ section
->sh_link
;
6874 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6876 if (link_section
->sh_link
>= elf_header
.e_shnum
)
6881 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6883 string_sec
= section_headers
+ link_section
->sh_link
;
6885 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6886 string_sec
->sh_size
,
6887 _("version string table"));
6891 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6892 SECTION_NAME (section
), total
);
6894 printf (_(" Addr: "));
6895 printf_vma (section
->sh_addr
);
6896 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6897 (unsigned long) section
->sh_offset
, section
->sh_link
,
6898 SECTION_NAME (link_section
));
6900 off
= offset_from_vma (file
,
6901 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6902 total
* sizeof (short));
6903 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
6905 _("version symbol data"));
6912 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
6914 for (cnt
= total
; cnt
--;)
6915 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6920 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6923 int check_def
, check_need
;
6926 printf (" %03x:", cnt
);
6928 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6929 switch (data
[cnt
+ j
])
6932 fputs (_(" 0 (*local*) "), stdout
);
6936 fputs (_(" 1 (*global*) "), stdout
);
6940 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
6941 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
6945 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
6946 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
6949 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6956 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6958 Elf_Internal_Verneed ivn
;
6959 unsigned long offset
;
6961 offset
= offset_from_vma
6962 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6963 sizeof (Elf_External_Verneed
));
6967 Elf_Internal_Vernaux ivna
;
6968 Elf_External_Verneed evn
;
6969 Elf_External_Vernaux evna
;
6970 unsigned long a_off
;
6972 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6975 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6976 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6978 a_off
= offset
+ ivn
.vn_aux
;
6982 get_data (&evna
, file
, a_off
, sizeof (evna
),
6983 1, _("version need aux (2)"));
6985 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6986 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6988 a_off
+= ivna
.vna_next
;
6990 while (ivna
.vna_other
!= data
[cnt
+ j
]
6991 && ivna
.vna_next
!= 0);
6993 if (ivna
.vna_other
== data
[cnt
+ j
])
6995 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6997 if (ivna
.vna_name
>= string_sec
->sh_size
)
6998 name
= _("*invalid*");
7000 name
= strtab
+ ivna
.vna_name
;
7001 nn
+= printf ("(%s%-*s",
7003 12 - (int) strlen (name
),
7009 offset
+= ivn
.vn_next
;
7011 while (ivn
.vn_next
);
7014 if (check_def
&& data
[cnt
+ j
] != 0x8001
7015 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7017 Elf_Internal_Verdef ivd
;
7018 Elf_External_Verdef evd
;
7019 unsigned long offset
;
7021 offset
= offset_from_vma
7022 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7027 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
7030 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7031 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7033 offset
+= ivd
.vd_next
;
7035 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
7036 && ivd
.vd_next
!= 0);
7038 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
7040 Elf_External_Verdaux evda
;
7041 Elf_Internal_Verdaux ivda
;
7043 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7045 get_data (&evda
, file
,
7046 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
7048 _("version def aux"));
7050 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7052 if (ivda
.vda_name
>= string_sec
->sh_size
)
7053 name
= _("*invalid*");
7055 name
= strtab
+ ivda
.vda_name
;
7056 nn
+= printf ("(%s%-*s",
7058 12 - (int) strlen (name
),
7064 printf ("%*c", 18 - nn
, ' ');
7082 printf (_("\nNo version information found in this file.\n"));
7088 get_symbol_binding (unsigned int binding
)
7090 static char buff
[32];
7094 case STB_LOCAL
: return "LOCAL";
7095 case STB_GLOBAL
: return "GLOBAL";
7096 case STB_WEAK
: return "WEAK";
7098 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
7099 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
7101 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
7103 if (binding
== STB_GNU_UNIQUE
7104 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
7105 /* GNU/Linux is still using the default value 0. */
7106 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
7108 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
7111 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
7117 get_symbol_type (unsigned int type
)
7119 static char buff
[32];
7123 case STT_NOTYPE
: return "NOTYPE";
7124 case STT_OBJECT
: return "OBJECT";
7125 case STT_FUNC
: return "FUNC";
7126 case STT_SECTION
: return "SECTION";
7127 case STT_FILE
: return "FILE";
7128 case STT_COMMON
: return "COMMON";
7129 case STT_TLS
: return "TLS";
7130 case STT_RELC
: return "RELC";
7131 case STT_SRELC
: return "SRELC";
7133 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
7135 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
7136 return "THUMB_FUNC";
7138 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
7141 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
7142 return "PARISC_MILLI";
7144 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
7146 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
7148 if (elf_header
.e_machine
== EM_PARISC
)
7150 if (type
== STT_HP_OPAQUE
)
7152 if (type
== STT_HP_STUB
)
7156 if (type
== STT_GNU_IFUNC
7157 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
7158 /* GNU/Linux is still using the default value 0. */
7159 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
7162 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
7165 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
7171 get_symbol_visibility (unsigned int visibility
)
7175 case STV_DEFAULT
: return "DEFAULT";
7176 case STV_INTERNAL
: return "INTERNAL";
7177 case STV_HIDDEN
: return "HIDDEN";
7178 case STV_PROTECTED
: return "PROTECTED";
7184 get_mips_symbol_other (unsigned int other
)
7188 case STO_OPTIONAL
: return "OPTIONAL";
7189 case STO_MIPS16
: return "MIPS16";
7190 case STO_MIPS_PLT
: return "MIPS PLT";
7191 case STO_MIPS_PIC
: return "MIPS PIC";
7192 default: return NULL
;
7197 get_symbol_other (unsigned int other
)
7199 const char * result
= NULL
;
7200 static char buff
[32];
7205 switch (elf_header
.e_machine
)
7208 result
= get_mips_symbol_other (other
);
7216 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
7221 get_symbol_index_type (unsigned int type
)
7223 static char buff
[32];
7227 case SHN_UNDEF
: return "UND";
7228 case SHN_ABS
: return "ABS";
7229 case SHN_COMMON
: return "COM";
7231 if (type
== SHN_IA_64_ANSI_COMMON
7232 && elf_header
.e_machine
== EM_IA_64
7233 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
7235 else if ((elf_header
.e_machine
== EM_X86_64
7236 || elf_header
.e_machine
== EM_L1OM
)
7237 && type
== SHN_X86_64_LCOMMON
)
7239 else if (type
== SHN_MIPS_SCOMMON
7240 && elf_header
.e_machine
== EM_MIPS
)
7242 else if (type
== SHN_MIPS_SUNDEFINED
7243 && elf_header
.e_machine
== EM_MIPS
)
7245 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
7246 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
7247 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
7248 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
7249 else if (type
>= SHN_LORESERVE
)
7250 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
7252 sprintf (buff
, "%3d", type
);
7260 get_dynamic_data (FILE * file
, unsigned int number
, unsigned int ent_size
)
7262 unsigned char * e_data
;
7265 e_data
= (unsigned char *) cmalloc (number
, ent_size
);
7269 error (_("Out of memory\n"));
7273 if (fread (e_data
, ent_size
, number
, file
) != number
)
7275 error (_("Unable to read in dynamic data\n"));
7279 i_data
= (bfd_vma
*) cmalloc (number
, sizeof (*i_data
));
7283 error (_("Out of memory\n"));
7289 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
7297 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
7299 Elf_Internal_Sym
* psym
;
7302 psym
= dynamic_symbols
+ si
;
7304 n
= print_vma (si
, DEC_5
);
7306 fputs (" " + n
, stdout
);
7307 printf (" %3lu: ", hn
);
7308 print_vma (psym
->st_value
, LONG_HEX
);
7310 print_vma (psym
->st_size
, DEC_5
);
7312 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7313 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7314 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7315 /* Check to see if any other bits in the st_other field are set.
7316 Note - displaying this information disrupts the layout of the
7317 table being generated, but for the moment this case is very
7319 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7320 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7321 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
7322 if (VALID_DYNAMIC_NAME (psym
->st_name
))
7323 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
7325 printf (" <corrupt: %14ld>", psym
->st_name
);
7329 /* Dump the symbol table. */
7331 process_symbol_table (FILE * file
)
7333 Elf_Internal_Shdr
* section
;
7334 bfd_vma nbuckets
= 0;
7335 bfd_vma nchains
= 0;
7336 bfd_vma
* buckets
= NULL
;
7337 bfd_vma
* chains
= NULL
;
7338 bfd_vma ngnubuckets
= 0;
7339 bfd_vma
* gnubuckets
= NULL
;
7340 bfd_vma
* gnuchains
= NULL
;
7341 bfd_vma gnusymidx
= 0;
7343 if (! do_syms
&& !do_histogram
)
7346 if (dynamic_info
[DT_HASH
]
7348 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7350 unsigned char nb
[8];
7351 unsigned char nc
[8];
7352 int hash_ent_size
= 4;
7354 if ((elf_header
.e_machine
== EM_ALPHA
7355 || elf_header
.e_machine
== EM_S390
7356 || elf_header
.e_machine
== EM_S390_OLD
)
7357 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
7361 (archive_file_offset
7362 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
7363 sizeof nb
+ sizeof nc
)),
7366 error (_("Unable to seek to start of dynamic information\n"));
7370 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
7372 error (_("Failed to read in number of buckets\n"));
7376 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
7378 error (_("Failed to read in number of chains\n"));
7382 nbuckets
= byte_get (nb
, hash_ent_size
);
7383 nchains
= byte_get (nc
, hash_ent_size
);
7385 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
7386 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
7389 if (buckets
== NULL
|| chains
== NULL
)
7391 if (do_using_dynamic
)
7402 if (dynamic_info_DT_GNU_HASH
7404 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7406 unsigned char nb
[16];
7407 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
7408 bfd_vma buckets_vma
;
7411 (archive_file_offset
7412 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
7416 error (_("Unable to seek to start of dynamic information\n"));
7420 if (fread (nb
, 16, 1, file
) != 1)
7422 error (_("Failed to read in number of buckets\n"));
7426 ngnubuckets
= byte_get (nb
, 4);
7427 gnusymidx
= byte_get (nb
+ 4, 4);
7428 bitmaskwords
= byte_get (nb
+ 8, 4);
7429 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
7431 buckets_vma
+= bitmaskwords
* 4;
7433 buckets_vma
+= bitmaskwords
* 8;
7436 (archive_file_offset
7437 + offset_from_vma (file
, buckets_vma
, 4)),
7440 error (_("Unable to seek to start of dynamic information\n"));
7444 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
7446 if (gnubuckets
== NULL
)
7449 for (i
= 0; i
< ngnubuckets
; i
++)
7450 if (gnubuckets
[i
] != 0)
7452 if (gnubuckets
[i
] < gnusymidx
)
7455 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
7456 maxchain
= gnubuckets
[i
];
7459 if (maxchain
== 0xffffffff)
7462 maxchain
-= gnusymidx
;
7465 (archive_file_offset
7466 + offset_from_vma (file
, buckets_vma
7467 + 4 * (ngnubuckets
+ maxchain
), 4)),
7470 error (_("Unable to seek to start of dynamic information\n"));
7476 if (fread (nb
, 4, 1, file
) != 1)
7478 error (_("Failed to determine last chain length\n"));
7482 if (maxchain
+ 1 == 0)
7487 while ((byte_get (nb
, 4) & 1) == 0);
7490 (archive_file_offset
7491 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
7494 error (_("Unable to seek to start of dynamic information\n"));
7498 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
7501 if (gnuchains
== NULL
)
7506 if (do_using_dynamic
)
7511 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
7514 && dynamic_strings
!= NULL
)
7518 if (dynamic_info
[DT_HASH
])
7522 printf (_("\nSymbol table for image:\n"));
7524 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7526 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7528 for (hn
= 0; hn
< nbuckets
; hn
++)
7533 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
7534 print_dynamic_symbol (si
, hn
);
7538 if (dynamic_info_DT_GNU_HASH
)
7540 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
7542 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7544 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7546 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7547 if (gnubuckets
[hn
] != 0)
7549 bfd_vma si
= gnubuckets
[hn
];
7550 bfd_vma off
= si
- gnusymidx
;
7554 print_dynamic_symbol (si
, hn
);
7557 while ((gnuchains
[off
++] & 1) == 0);
7561 else if (do_syms
&& !do_using_dynamic
)
7565 for (i
= 0, section
= section_headers
;
7566 i
< elf_header
.e_shnum
;
7570 char * strtab
= NULL
;
7571 unsigned long int strtab_size
= 0;
7572 Elf_Internal_Sym
* symtab
;
7573 Elf_Internal_Sym
* psym
;
7575 if ( section
->sh_type
!= SHT_SYMTAB
7576 && section
->sh_type
!= SHT_DYNSYM
)
7579 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7580 SECTION_NAME (section
),
7581 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
7583 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7585 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7587 symtab
= GET_ELF_SYMBOLS (file
, section
);
7591 if (section
->sh_link
== elf_header
.e_shstrndx
)
7593 strtab
= string_table
;
7594 strtab_size
= string_table_length
;
7596 else if (section
->sh_link
< elf_header
.e_shnum
)
7598 Elf_Internal_Shdr
* string_sec
;
7600 string_sec
= section_headers
+ section
->sh_link
;
7602 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
7603 1, string_sec
->sh_size
,
7605 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
7608 for (si
= 0, psym
= symtab
;
7609 si
< section
->sh_size
/ section
->sh_entsize
;
7612 printf ("%6d: ", si
);
7613 print_vma (psym
->st_value
, LONG_HEX
);
7615 print_vma (psym
->st_size
, DEC_5
);
7616 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7617 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7618 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7619 /* Check to see if any other bits in the st_other field are set.
7620 Note - displaying this information disrupts the layout of the
7621 table being generated, but for the moment this case is very rare. */
7622 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7623 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7624 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
7625 print_symbol (25, psym
->st_name
< strtab_size
7626 ? strtab
+ psym
->st_name
: "<corrupt>");
7628 if (section
->sh_type
== SHT_DYNSYM
&&
7629 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
7631 unsigned char data
[2];
7632 unsigned short vers_data
;
7633 unsigned long offset
;
7637 offset
= offset_from_vma
7638 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7639 sizeof data
+ si
* sizeof (vers_data
));
7641 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
7642 sizeof (data
), 1, _("version data"));
7644 vers_data
= byte_get (data
, 2);
7646 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
7647 && section_headers
[psym
->st_shndx
].sh_type
7650 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
7652 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
7654 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
7655 && (is_nobits
|| ! check_def
))
7657 Elf_External_Verneed evn
;
7658 Elf_Internal_Verneed ivn
;
7659 Elf_Internal_Vernaux ivna
;
7661 /* We must test both. */
7662 offset
= offset_from_vma
7663 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7668 unsigned long vna_off
;
7670 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7673 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7674 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7676 vna_off
= offset
+ ivn
.vn_aux
;
7680 Elf_External_Vernaux evna
;
7682 get_data (&evna
, file
, vna_off
,
7684 _("version need aux (3)"));
7686 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7687 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7688 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7690 vna_off
+= ivna
.vna_next
;
7692 while (ivna
.vna_other
!= vers_data
7693 && ivna
.vna_next
!= 0);
7695 if (ivna
.vna_other
== vers_data
)
7698 offset
+= ivn
.vn_next
;
7700 while (ivn
.vn_next
!= 0);
7702 if (ivna
.vna_other
== vers_data
)
7705 ivna
.vna_name
< strtab_size
7706 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7710 else if (! is_nobits
)
7711 error (_("bad dynamic symbol\n"));
7718 if (vers_data
!= 0x8001
7719 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7721 Elf_Internal_Verdef ivd
;
7722 Elf_Internal_Verdaux ivda
;
7723 Elf_External_Verdaux evda
;
7724 unsigned long offset
;
7726 offset
= offset_from_vma
7728 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7729 sizeof (Elf_External_Verdef
));
7733 Elf_External_Verdef evd
;
7735 get_data (&evd
, file
, offset
, sizeof (evd
),
7736 1, _("version def"));
7738 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7739 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7740 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7742 offset
+= ivd
.vd_next
;
7744 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
7745 && ivd
.vd_next
!= 0);
7747 offset
-= ivd
.vd_next
;
7748 offset
+= ivd
.vd_aux
;
7750 get_data (&evda
, file
, offset
, sizeof (evda
),
7751 1, _("version def aux"));
7753 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7755 if (psym
->st_name
!= ivda
.vda_name
)
7756 printf ((vers_data
& VERSYM_HIDDEN
)
7758 ivda
.vda_name
< strtab_size
7759 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7769 if (strtab
!= string_table
)
7775 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7777 if (do_histogram
&& buckets
!= NULL
)
7779 unsigned long * lengths
;
7780 unsigned long * counts
;
7783 unsigned long maxlength
= 0;
7784 unsigned long nzero_counts
= 0;
7785 unsigned long nsyms
= 0;
7787 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7788 (unsigned long) nbuckets
);
7789 printf (_(" Length Number %% of total Coverage\n"));
7791 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
7792 if (lengths
== NULL
)
7794 error (_("Out of memory\n"));
7797 for (hn
= 0; hn
< nbuckets
; ++hn
)
7799 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7802 if (maxlength
< ++lengths
[hn
])
7807 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
7810 error (_("Out of memory\n"));
7814 for (hn
= 0; hn
< nbuckets
; ++hn
)
7815 ++counts
[lengths
[hn
]];
7820 printf (" 0 %-10lu (%5.1f%%)\n",
7821 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7822 for (i
= 1; i
<= maxlength
; ++i
)
7824 nzero_counts
+= counts
[i
] * i
;
7825 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7826 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7827 (nzero_counts
* 100.0) / nsyms
);
7835 if (buckets
!= NULL
)
7841 if (do_histogram
&& gnubuckets
!= NULL
)
7843 unsigned long * lengths
;
7844 unsigned long * counts
;
7846 unsigned long maxlength
= 0;
7847 unsigned long nzero_counts
= 0;
7848 unsigned long nsyms
= 0;
7850 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
7851 if (lengths
== NULL
)
7853 error (_("Out of memory\n"));
7857 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7858 (unsigned long) ngnubuckets
);
7859 printf (_(" Length Number %% of total Coverage\n"));
7861 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7862 if (gnubuckets
[hn
] != 0)
7864 bfd_vma off
, length
= 1;
7866 for (off
= gnubuckets
[hn
] - gnusymidx
;
7867 (gnuchains
[off
] & 1) == 0; ++off
)
7869 lengths
[hn
] = length
;
7870 if (length
> maxlength
)
7875 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
7878 error (_("Out of memory\n"));
7882 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7883 ++counts
[lengths
[hn
]];
7885 if (ngnubuckets
> 0)
7888 printf (" 0 %-10lu (%5.1f%%)\n",
7889 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
7890 for (j
= 1; j
<= maxlength
; ++j
)
7892 nzero_counts
+= counts
[j
] * j
;
7893 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7894 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
7895 (nzero_counts
* 100.0) / nsyms
);
7909 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
7913 if (dynamic_syminfo
== NULL
7915 /* No syminfo, this is ok. */
7918 /* There better should be a dynamic symbol section. */
7919 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7923 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7924 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7926 printf (_(" Num: Name BoundTo Flags\n"));
7927 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7929 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7931 printf ("%4d: ", i
);
7932 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7933 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7935 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7938 switch (dynamic_syminfo
[i
].si_boundto
)
7940 case SYMINFO_BT_SELF
:
7941 fputs ("SELF ", stdout
);
7943 case SYMINFO_BT_PARENT
:
7944 fputs ("PARENT ", stdout
);
7947 if (dynamic_syminfo
[i
].si_boundto
> 0
7948 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7949 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7951 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7955 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7959 if (flags
& SYMINFO_FLG_DIRECT
)
7961 if (flags
& SYMINFO_FLG_PASSTHRU
)
7962 printf (" PASSTHRU");
7963 if (flags
& SYMINFO_FLG_COPY
)
7965 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7966 printf (" LAZYLOAD");
7974 /* Check to see if the given reloc needs to be handled in a target specific
7975 manner. If so then process the reloc and return TRUE otherwise return
7979 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
7980 unsigned char * start
,
7981 Elf_Internal_Sym
* symtab
)
7983 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
7985 switch (elf_header
.e_machine
)
7988 case EM_CYGNUS_MN10300
:
7990 static Elf_Internal_Sym
* saved_sym
= NULL
;
7994 case 34: /* R_MN10300_ALIGN */
7996 case 33: /* R_MN10300_SYM_DIFF */
7997 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
7999 case 1: /* R_MN10300_32 */
8000 case 2: /* R_MN10300_16 */
8001 if (saved_sym
!= NULL
)
8005 value
= reloc
->r_addend
8006 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
8007 - saved_sym
->st_value
);
8009 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
8016 if (saved_sym
!= NULL
)
8017 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
8027 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
8028 DWARF debug sections. This is a target specific test. Note - we do not
8029 go through the whole including-target-headers-multiple-times route, (as
8030 we have already done with <elf/h8.h>) because this would become very
8031 messy and even then this function would have to contain target specific
8032 information (the names of the relocs instead of their numeric values).
8033 FIXME: This is not the correct way to solve this problem. The proper way
8034 is to have target specific reloc sizing and typing functions created by
8035 the reloc-macros.h header, in the same way that it already creates the
8036 reloc naming functions. */
8039 is_32bit_abs_reloc (unsigned int reloc_type
)
8041 switch (elf_header
.e_machine
)
8045 return reloc_type
== 1; /* R_386_32. */
8047 return reloc_type
== 1; /* R_68K_32. */
8049 return reloc_type
== 1; /* R_860_32. */
8051 return reloc_type
== 1; /* XXX Is this right ? */
8053 return reloc_type
== 1; /* R_ARC_32. */
8055 return reloc_type
== 2; /* R_ARM_ABS32 */
8058 return reloc_type
== 1;
8060 return reloc_type
== 0x12; /* R_byte4_data. */
8062 return reloc_type
== 3; /* R_CRIS_32. */
8065 return reloc_type
== 3; /* R_CR16_NUM32. */
8067 return reloc_type
== 15; /* R_CRX_NUM32. */
8069 return reloc_type
== 1;
8070 case EM_CYGNUS_D10V
:
8072 return reloc_type
== 6; /* R_D10V_32. */
8073 case EM_CYGNUS_D30V
:
8075 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
8077 return reloc_type
== 3; /* R_DLX_RELOC_32. */
8078 case EM_CYGNUS_FR30
:
8080 return reloc_type
== 3; /* R_FR30_32. */
8084 return reloc_type
== 1; /* R_H8_DIR32. */
8086 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
8089 return reloc_type
== 2; /* R_IP2K_32. */
8091 return reloc_type
== 2; /* R_IQ2000_32. */
8092 case EM_LATTICEMICO32
:
8093 return reloc_type
== 3; /* R_LM32_32. */
8096 return reloc_type
== 3; /* R_M32C_32. */
8098 return reloc_type
== 34; /* R_M32R_32_RELA. */
8100 return reloc_type
== 1; /* R_MCORE_ADDR32. */
8102 return reloc_type
== 4; /* R_MEP_32. */
8104 return reloc_type
== 2; /* R_MIPS_32. */
8106 return reloc_type
== 4; /* R_MMIX_32. */
8107 case EM_CYGNUS_MN10200
:
8109 return reloc_type
== 1; /* R_MN10200_32. */
8110 case EM_CYGNUS_MN10300
:
8112 return reloc_type
== 1; /* R_MN10300_32. */
8115 return reloc_type
== 1; /* R_MSP43_32. */
8117 return reloc_type
== 2; /* R_MT_32. */
8118 case EM_ALTERA_NIOS2
:
8120 return reloc_type
== 1; /* R_NIOS_32. */
8123 return reloc_type
== 1; /* R_OR32_32. */
8125 return (reloc_type
== 1 /* R_PARISC_DIR32. */
8126 || reloc_type
== 41); /* R_PARISC_SECREL32. */
8129 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
8131 return reloc_type
== 1; /* R_PPC64_ADDR32. */
8133 return reloc_type
== 1; /* R_PPC_ADDR32. */
8135 return reloc_type
== 1; /* R_RX_DIR32. */
8137 return reloc_type
== 1; /* R_I370_ADDR31. */
8140 return reloc_type
== 4; /* R_S390_32. */
8142 return reloc_type
== 8; /* R_SCORE_ABS32. */
8144 return reloc_type
== 1; /* R_SH_DIR32. */
8145 case EM_SPARC32PLUS
:
8148 return reloc_type
== 3 /* R_SPARC_32. */
8149 || reloc_type
== 23; /* R_SPARC_UA32. */
8151 return reloc_type
== 6; /* R_SPU_ADDR32 */
8152 case EM_CYGNUS_V850
:
8154 return reloc_type
== 6; /* R_V850_ABS32. */
8156 return reloc_type
== 1; /* R_VAX_32. */
8159 return reloc_type
== 10; /* R_X86_64_32. */
8162 return reloc_type
== 3; /* R_XC16C_ABS_32. */
8164 return reloc_type
== 1; /* R_XSTROMY16_32. */
8167 return reloc_type
== 1; /* R_XTENSA_32. */
8169 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
8170 elf_header
.e_machine
);
8175 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8176 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
8179 is_32bit_pcrel_reloc (unsigned int reloc_type
)
8181 switch (elf_header
.e_machine
)
8185 return reloc_type
== 2; /* R_386_PC32. */
8187 return reloc_type
== 4; /* R_68K_PC32. */
8189 return reloc_type
== 10; /* R_ALPHA_SREL32. */
8191 return reloc_type
== 3; /* R_ARM_REL32 */
8193 return reloc_type
== 9; /* R_PARISC_PCREL32. */
8195 return reloc_type
== 26; /* R_PPC_REL32. */
8197 return reloc_type
== 26; /* R_PPC64_REL32. */
8200 return reloc_type
== 5; /* R_390_PC32. */
8202 return reloc_type
== 2; /* R_SH_REL32. */
8203 case EM_SPARC32PLUS
:
8206 return reloc_type
== 6; /* R_SPARC_DISP32. */
8208 return reloc_type
== 13; /* R_SPU_REL32. */
8211 return reloc_type
== 2; /* R_X86_64_PC32. */
8214 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
8216 /* Do not abort or issue an error message here. Not all targets use
8217 pc-relative 32-bit relocs in their DWARF debug information and we
8218 have already tested for target coverage in is_32bit_abs_reloc. A
8219 more helpful warning message will be generated by apply_relocations
8220 anyway, so just return. */
8225 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8226 a 64-bit absolute RELA relocation used in DWARF debug sections. */
8229 is_64bit_abs_reloc (unsigned int reloc_type
)
8231 switch (elf_header
.e_machine
)
8234 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
8236 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
8238 return reloc_type
== 80; /* R_PARISC_DIR64. */
8240 return reloc_type
== 38; /* R_PPC64_ADDR64. */
8241 case EM_SPARC32PLUS
:
8244 return reloc_type
== 54; /* R_SPARC_UA64. */
8247 return reloc_type
== 1; /* R_X86_64_64. */
8250 return reloc_type
== 22; /* R_S390_64 */
8252 return reloc_type
== 18; /* R_MIPS_64 */
8258 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
8259 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
8262 is_64bit_pcrel_reloc (unsigned int reloc_type
)
8264 switch (elf_header
.e_machine
)
8267 return reloc_type
== 11; /* R_ALPHA_SREL64 */
8269 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB */
8271 return reloc_type
== 72; /* R_PARISC_PCREL64 */
8273 return reloc_type
== 44; /* R_PPC64_REL64 */
8274 case EM_SPARC32PLUS
:
8277 return reloc_type
== 46; /* R_SPARC_DISP64 */
8280 return reloc_type
== 24; /* R_X86_64_PC64 */
8283 return reloc_type
== 23; /* R_S390_PC64 */
8289 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8290 a 24-bit absolute RELA relocation used in DWARF debug sections. */
8293 is_24bit_abs_reloc (unsigned int reloc_type
)
8295 switch (elf_header
.e_machine
)
8297 case EM_CYGNUS_MN10200
:
8299 return reloc_type
== 4; /* R_MN10200_24. */
8305 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8306 a 16-bit absolute RELA relocation used in DWARF debug sections. */
8309 is_16bit_abs_reloc (unsigned int reloc_type
)
8311 switch (elf_header
.e_machine
)
8315 return reloc_type
== 4; /* R_AVR_16. */
8316 case EM_CYGNUS_D10V
:
8318 return reloc_type
== 3; /* R_D10V_16. */
8322 return reloc_type
== R_H8_DIR16
;
8325 return reloc_type
== 1; /* R_IP2K_16. */
8328 return reloc_type
== 1; /* R_M32C_16 */
8331 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
8332 case EM_ALTERA_NIOS2
:
8334 return reloc_type
== 9; /* R_NIOS_16. */
8337 return reloc_type
== 2; /* R_XC16C_ABS_16. */
8343 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
8344 relocation entries (possibly formerly used for SHT_GROUP sections). */
8347 is_none_reloc (unsigned int reloc_type
)
8349 switch (elf_header
.e_machine
)
8351 case EM_68K
: /* R_68K_NONE. */
8352 case EM_386
: /* R_386_NONE. */
8353 case EM_SPARC32PLUS
:
8355 case EM_SPARC
: /* R_SPARC_NONE. */
8356 case EM_MIPS
: /* R_MIPS_NONE. */
8357 case EM_PARISC
: /* R_PARISC_NONE. */
8358 case EM_ALPHA
: /* R_ALPHA_NONE. */
8359 case EM_PPC
: /* R_PPC_NONE. */
8360 case EM_PPC64
: /* R_PPC64_NONE. */
8361 case EM_ARM
: /* R_ARM_NONE. */
8362 case EM_IA_64
: /* R_IA64_NONE. */
8363 case EM_SH
: /* R_SH_NONE. */
8365 case EM_S390
: /* R_390_NONE. */
8366 case EM_CRIS
: /* R_CRIS_NONE. */
8367 case EM_X86_64
: /* R_X86_64_NONE. */
8368 case EM_L1OM
: /* R_X86_64_NONE. */
8369 case EM_MN10300
: /* R_MN10300_NONE. */
8370 case EM_M32R
: /* R_M32R_NONE. */
8372 case EM_C166
: /* R_XC16X_NONE. */
8373 return reloc_type
== 0;
8376 return (reloc_type
== 0 /* R_XTENSA_NONE. */
8377 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
8378 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
8379 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
8384 /* Apply relocations to a section.
8385 Note: So far support has been added only for those relocations
8386 which can be found in debug sections.
8387 FIXME: Add support for more relocations ? */
8390 apply_relocations (void * file
,
8391 Elf_Internal_Shdr
* section
,
8392 unsigned char * start
)
8394 Elf_Internal_Shdr
* relsec
;
8395 unsigned char * end
= start
+ section
->sh_size
;
8397 if (elf_header
.e_type
!= ET_REL
)
8400 /* Find the reloc section associated with the section. */
8401 for (relsec
= section_headers
;
8402 relsec
< section_headers
+ elf_header
.e_shnum
;
8405 bfd_boolean is_rela
;
8406 unsigned long num_relocs
;
8407 Elf_Internal_Rela
* relocs
;
8408 Elf_Internal_Rela
* rp
;
8409 Elf_Internal_Shdr
* symsec
;
8410 Elf_Internal_Sym
* symtab
;
8411 Elf_Internal_Sym
* sym
;
8413 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8414 || relsec
->sh_info
>= elf_header
.e_shnum
8415 || section_headers
+ relsec
->sh_info
!= section
8416 || relsec
->sh_size
== 0
8417 || relsec
->sh_link
>= elf_header
.e_shnum
)
8420 is_rela
= relsec
->sh_type
== SHT_RELA
;
8424 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
8425 relsec
->sh_size
, & relocs
, & num_relocs
))
8430 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
8431 relsec
->sh_size
, & relocs
, & num_relocs
))
8435 /* SH uses RELA but uses in place value instead of the addend field. */
8436 if (elf_header
.e_machine
== EM_SH
)
8439 symsec
= section_headers
+ relsec
->sh_link
;
8440 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
);
8442 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
8445 unsigned int reloc_type
;
8446 unsigned int reloc_size
;
8447 unsigned char * loc
;
8449 reloc_type
= get_reloc_type (rp
->r_info
);
8451 if (target_specific_reloc_handling (rp
, start
, symtab
))
8453 else if (is_none_reloc (reloc_type
))
8455 else if (is_32bit_abs_reloc (reloc_type
)
8456 || is_32bit_pcrel_reloc (reloc_type
))
8458 else if (is_64bit_abs_reloc (reloc_type
)
8459 || is_64bit_pcrel_reloc (reloc_type
))
8461 else if (is_24bit_abs_reloc (reloc_type
))
8463 else if (is_16bit_abs_reloc (reloc_type
))
8467 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
8468 reloc_type
, SECTION_NAME (section
));
8472 loc
= start
+ rp
->r_offset
;
8473 if ((loc
+ reloc_size
) > end
)
8475 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
8476 (unsigned long) rp
->r_offset
,
8477 SECTION_NAME (section
));
8481 sym
= symtab
+ get_reloc_symindex (rp
->r_info
);
8483 /* If the reloc has a symbol associated with it,
8484 make sure that it is of an appropriate type.
8486 Relocations against symbols without type can happen.
8487 Gcc -feliminate-dwarf2-dups may generate symbols
8488 without type for debug info.
8490 Icc generates relocations against function symbols
8491 instead of local labels.
8493 Relocations against object symbols can happen, eg when
8494 referencing a global array. For an example of this see
8495 the _clz.o binary in libgcc.a. */
8497 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
8499 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
8500 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
8501 (long int)(rp
- relocs
),
8502 SECTION_NAME (relsec
));
8508 addend
+= rp
->r_addend
;
8509 /* R_XTENSA_32 and R_PJ_DATA_DIR32 are partial_inplace. */
8511 || (elf_header
.e_machine
== EM_XTENSA
8513 || ((elf_header
.e_machine
== EM_PJ
8514 || elf_header
.e_machine
== EM_PJ_OLD
)
8515 && reloc_type
== 1))
8516 addend
+= byte_get (loc
, reloc_size
);
8518 if (is_32bit_pcrel_reloc (reloc_type
)
8519 || is_64bit_pcrel_reloc (reloc_type
))
8521 /* On HPPA, all pc-relative relocations are biased by 8. */
8522 if (elf_header
.e_machine
== EM_PARISC
)
8524 byte_put (loc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
8528 byte_put (loc
, addend
+ sym
->st_value
, reloc_size
);
8537 #ifdef SUPPORT_DISASSEMBLY
8539 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
8541 printf (_("\nAssembly dump of section %s\n"),
8542 SECTION_NAME (section
));
8544 /* XXX -- to be done --- XXX */
8550 /* Reads in the contents of SECTION from FILE, returning a pointer
8551 to a malloc'ed buffer or NULL if something went wrong. */
8554 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
8556 bfd_size_type num_bytes
;
8558 num_bytes
= section
->sh_size
;
8560 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
8562 printf (_("\nSection '%s' has no data to dump.\n"),
8563 SECTION_NAME (section
));
8567 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
8568 _("section contents"));
8573 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
8575 Elf_Internal_Shdr
* relsec
;
8576 bfd_size_type num_bytes
;
8581 char * name
= SECTION_NAME (section
);
8582 bfd_boolean some_strings_shown
;
8584 start
= get_section_contents (section
, file
);
8588 printf (_("\nString dump of section '%s':\n"), name
);
8590 /* If the section being dumped has relocations against it the user might
8591 be expecting these relocations to have been applied. Check for this
8592 case and issue a warning message in order to avoid confusion.
8593 FIXME: Maybe we ought to have an option that dumps a section with
8595 for (relsec
= section_headers
;
8596 relsec
< section_headers
+ elf_header
.e_shnum
;
8599 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8600 || relsec
->sh_info
>= elf_header
.e_shnum
8601 || section_headers
+ relsec
->sh_info
!= section
8602 || relsec
->sh_size
== 0
8603 || relsec
->sh_link
>= elf_header
.e_shnum
)
8606 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
8610 num_bytes
= section
->sh_size
;
8611 addr
= section
->sh_addr
;
8613 end
= start
+ num_bytes
;
8614 some_strings_shown
= FALSE
;
8618 while (!ISPRINT (* data
))
8625 printf (" [%6tx] %s\n", data
- start
, data
);
8627 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
8629 data
+= strlen (data
);
8630 some_strings_shown
= TRUE
;
8634 if (! some_strings_shown
)
8635 printf (_(" No strings found in this section."));
8643 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
8645 bfd_boolean relocate
)
8647 Elf_Internal_Shdr
* relsec
;
8648 bfd_size_type bytes
;
8650 unsigned char * data
;
8651 unsigned char * start
;
8653 start
= (unsigned char *) get_section_contents (section
, file
);
8657 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
8661 apply_relocations (file
, section
, start
);
8665 /* If the section being dumped has relocations against it the user might
8666 be expecting these relocations to have been applied. Check for this
8667 case and issue a warning message in order to avoid confusion.
8668 FIXME: Maybe we ought to have an option that dumps a section with
8670 for (relsec
= section_headers
;
8671 relsec
< section_headers
+ elf_header
.e_shnum
;
8674 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8675 || relsec
->sh_info
>= elf_header
.e_shnum
8676 || section_headers
+ relsec
->sh_info
!= section
8677 || relsec
->sh_size
== 0
8678 || relsec
->sh_link
>= elf_header
.e_shnum
)
8681 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
8686 addr
= section
->sh_addr
;
8687 bytes
= section
->sh_size
;
8696 lbytes
= (bytes
> 16 ? 16 : bytes
);
8698 printf (" 0x%8.8lx ", (unsigned long) addr
);
8700 for (j
= 0; j
< 16; j
++)
8703 printf ("%2.2x", data
[j
]);
8711 for (j
= 0; j
< lbytes
; j
++)
8714 if (k
>= ' ' && k
< 0x7f)
8732 /* Uncompresses a section that was compressed using zlib, in place.
8733 This is a copy of bfd_uncompress_section_contents, in bfd/compress.c */
8736 uncompress_section_contents (unsigned char ** buffer
, dwarf_size_type
* size
)
8739 /* These are just to quiet gcc. */
8744 dwarf_size_type compressed_size
= *size
;
8745 unsigned char * compressed_buffer
= *buffer
;
8746 dwarf_size_type uncompressed_size
;
8747 unsigned char * uncompressed_buffer
;
8750 dwarf_size_type header_size
= 12;
8752 /* Read the zlib header. In this case, it should be "ZLIB" followed
8753 by the uncompressed section size, 8 bytes in big-endian order. */
8754 if (compressed_size
< header_size
8755 || ! streq ((char *) compressed_buffer
, "ZLIB"))
8758 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
8759 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
8760 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
8761 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
8762 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
8763 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
8764 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
8765 uncompressed_size
+= compressed_buffer
[11];
8767 /* It is possible the section consists of several compressed
8768 buffers concatenated together, so we uncompress in a loop. */
8772 strm
.avail_in
= compressed_size
- header_size
;
8773 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
8774 strm
.avail_out
= uncompressed_size
;
8775 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
8777 rc
= inflateInit (& strm
);
8778 while (strm
.avail_in
> 0)
8782 strm
.next_out
= ((Bytef
*) uncompressed_buffer
8783 + (uncompressed_size
- strm
.avail_out
));
8784 rc
= inflate (&strm
, Z_FINISH
);
8785 if (rc
!= Z_STREAM_END
)
8787 rc
= inflateReset (& strm
);
8789 rc
= inflateEnd (& strm
);
8791 || strm
.avail_out
!= 0)
8794 free (compressed_buffer
);
8795 *buffer
= uncompressed_buffer
;
8796 *size
= uncompressed_size
;
8800 free (uncompressed_buffer
);
8802 #endif /* HAVE_ZLIB_H */
8806 load_specific_debug_section (enum dwarf_section_display_enum debug
,
8807 Elf_Internal_Shdr
* sec
, void * file
)
8809 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8811 int section_is_compressed
;
8813 /* If it is already loaded, do nothing. */
8814 if (section
->start
!= NULL
)
8817 section_is_compressed
= section
->name
== section
->compressed_name
;
8819 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
8820 section
->address
= sec
->sh_addr
;
8821 section
->size
= sec
->sh_size
;
8822 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
8825 if (section
->start
== NULL
)
8828 if (section_is_compressed
)
8829 if (! uncompress_section_contents (§ion
->start
, §ion
->size
))
8832 if (debug_displays
[debug
].relocate
)
8833 apply_relocations ((FILE *) file
, sec
, section
->start
);
8839 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
8841 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8842 Elf_Internal_Shdr
* sec
;
8844 /* Locate the debug section. */
8845 sec
= find_section (section
->uncompressed_name
);
8847 section
->name
= section
->uncompressed_name
;
8850 sec
= find_section (section
->compressed_name
);
8852 section
->name
= section
->compressed_name
;
8857 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
8861 free_debug_section (enum dwarf_section_display_enum debug
)
8863 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
8865 if (section
->start
== NULL
)
8868 free ((char *) section
->start
);
8869 section
->start
= NULL
;
8870 section
->address
= 0;
8875 display_debug_section (Elf_Internal_Shdr
* section
, FILE * file
)
8877 char * name
= SECTION_NAME (section
);
8878 bfd_size_type length
;
8882 length
= section
->sh_size
;
8885 printf (_("\nSection '%s' has no debugging data.\n"), name
);
8888 if (section
->sh_type
== SHT_NOBITS
)
8890 /* There is no point in dumping the contents of a debugging section
8891 which has the NOBITS type - the bits in the file will be random.
8892 This can happen when a file containing a .eh_frame section is
8893 stripped with the --only-keep-debug command line option. */
8894 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name
);
8898 if (const_strneq (name
, ".gnu.linkonce.wi."))
8899 name
= ".debug_info";
8901 /* See if we know how to display the contents of this section. */
8902 for (i
= 0; i
< max
; i
++)
8903 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
8904 || streq (debug_displays
[i
].section
.compressed_name
, name
))
8906 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
8907 int secondary
= (section
!= find_section (name
));
8910 free_debug_section ((enum dwarf_section_display_enum
) i
);
8912 if (streq (sec
->uncompressed_name
, name
))
8913 sec
->name
= sec
->uncompressed_name
;
8915 sec
->name
= sec
->compressed_name
;
8916 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
8919 result
&= debug_displays
[i
].display (sec
, file
);
8921 if (secondary
|| (i
!= info
&& i
!= abbrev
))
8922 free_debug_section ((enum dwarf_section_display_enum
) i
);
8930 printf (_("Unrecognized debug section: %s\n"), name
);
8937 /* Set DUMP_SECTS for all sections where dumps were requested
8938 based on section name. */
8941 initialise_dumps_byname (void)
8943 struct dump_list_entry
* cur
;
8945 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
8950 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
8951 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
8953 request_dump_bynumber (i
, cur
->type
);
8958 warn (_("Section '%s' was not dumped because it does not exist!\n"),
8964 process_section_contents (FILE * file
)
8966 Elf_Internal_Shdr
* section
;
8972 initialise_dumps_byname ();
8974 for (i
= 0, section
= section_headers
;
8975 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
8978 #ifdef SUPPORT_DISASSEMBLY
8979 if (dump_sects
[i
] & DISASS_DUMP
)
8980 disassemble_section (section
, file
);
8982 if (dump_sects
[i
] & HEX_DUMP
)
8983 dump_section_as_bytes (section
, file
, FALSE
);
8985 if (dump_sects
[i
] & RELOC_DUMP
)
8986 dump_section_as_bytes (section
, file
, TRUE
);
8988 if (dump_sects
[i
] & STRING_DUMP
)
8989 dump_section_as_strings (section
, file
);
8991 if (dump_sects
[i
] & DEBUG_DUMP
)
8992 display_debug_section (section
, file
);
8995 /* Check to see if the user requested a
8996 dump of a section that does not exist. */
8997 while (i
++ < num_dump_sects
)
8999 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
9003 process_mips_fpe_exception (int mask
)
9008 if (mask
& OEX_FPU_INEX
)
9009 fputs ("INEX", stdout
), first
= 0;
9010 if (mask
& OEX_FPU_UFLO
)
9011 printf ("%sUFLO", first
? "" : "|"), first
= 0;
9012 if (mask
& OEX_FPU_OFLO
)
9013 printf ("%sOFLO", first
? "" : "|"), first
= 0;
9014 if (mask
& OEX_FPU_DIV0
)
9015 printf ("%sDIV0", first
? "" : "|"), first
= 0;
9016 if (mask
& OEX_FPU_INVAL
)
9017 printf ("%sINVAL", first
? "" : "|");
9020 fputs ("0", stdout
);
9023 /* ARM EABI attributes section. */
9028 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
9030 const char ** table
;
9031 } arm_attr_public_tag
;
9033 static const char * arm_attr_tag_CPU_arch
[] =
9034 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
9035 "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
9036 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
9037 static const char * arm_attr_tag_THUMB_ISA_use
[] =
9038 {"No", "Thumb-1", "Thumb-2"};
9039 static const char * arm_attr_tag_VFP_arch
[] =
9040 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
9041 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
9042 static const char * arm_attr_tag_Advanced_SIMD_arch
[] = {"No", "NEONv1"};
9043 static const char * arm_attr_tag_PCS_config
[] =
9044 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
9045 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
9046 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
9047 {"V6", "SB", "TLS", "Unused"};
9048 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
9049 {"Absolute", "PC-relative", "SB-relative", "None"};
9050 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
9051 {"Absolute", "PC-relative", "None"};
9052 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
9053 {"None", "direct", "GOT-indirect"};
9054 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
9055 {"None", "??? 1", "2", "??? 3", "4"};
9056 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
9057 static const char * arm_attr_tag_ABI_FP_denormal
[] =
9058 {"Unused", "Needed", "Sign only"};
9059 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
9060 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
9061 static const char * arm_attr_tag_ABI_FP_number_model
[] =
9062 {"Unused", "Finite", "RTABI", "IEEE 754"};
9063 static const char * arm_attr_tag_ABI_align8_needed
[] = {"No", "Yes", "4-byte"};
9064 static const char * arm_attr_tag_ABI_align8_preserved
[] =
9065 {"No", "Yes, except leaf SP", "Yes"};
9066 static const char * arm_attr_tag_ABI_enum_size
[] =
9067 {"Unused", "small", "int", "forced to int"};
9068 static const char * arm_attr_tag_ABI_HardFP_use
[] =
9069 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
9070 static const char * arm_attr_tag_ABI_VFP_args
[] =
9071 {"AAPCS", "VFP registers", "custom"};
9072 static const char * arm_attr_tag_ABI_WMMX_args
[] =
9073 {"AAPCS", "WMMX registers", "custom"};
9074 static const char * arm_attr_tag_ABI_optimization_goals
[] =
9075 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
9076 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
9077 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
9078 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
9079 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
9080 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
9081 static const char * arm_attr_tag_VFP_HP_extension
[] =
9082 {"Not Allowed", "Allowed"};
9083 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
9084 {"None", "IEEE 754", "Alternative Format"};
9085 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
9086 static const char * arm_attr_tag_Virtualization_use
[] =
9087 {"Not Allowed", "Allowed"};
9088 static const char * arm_attr_tag_MPextension_use
[] = {"Not Allowed", "Allowed"};
9090 #define LOOKUP(id, name) \
9091 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
9092 static arm_attr_public_tag arm_attr_public_tags
[] =
9094 {4, "CPU_raw_name", 1, NULL
},
9095 {5, "CPU_name", 1, NULL
},
9096 LOOKUP(6, CPU_arch
),
9097 {7, "CPU_arch_profile", 0, NULL
},
9098 LOOKUP(8, ARM_ISA_use
),
9099 LOOKUP(9, THUMB_ISA_use
),
9100 LOOKUP(10, VFP_arch
),
9101 LOOKUP(11, WMMX_arch
),
9102 LOOKUP(12, Advanced_SIMD_arch
),
9103 LOOKUP(13, PCS_config
),
9104 LOOKUP(14, ABI_PCS_R9_use
),
9105 LOOKUP(15, ABI_PCS_RW_data
),
9106 LOOKUP(16, ABI_PCS_RO_data
),
9107 LOOKUP(17, ABI_PCS_GOT_use
),
9108 LOOKUP(18, ABI_PCS_wchar_t
),
9109 LOOKUP(19, ABI_FP_rounding
),
9110 LOOKUP(20, ABI_FP_denormal
),
9111 LOOKUP(21, ABI_FP_exceptions
),
9112 LOOKUP(22, ABI_FP_user_exceptions
),
9113 LOOKUP(23, ABI_FP_number_model
),
9114 LOOKUP(24, ABI_align8_needed
),
9115 LOOKUP(25, ABI_align8_preserved
),
9116 LOOKUP(26, ABI_enum_size
),
9117 LOOKUP(27, ABI_HardFP_use
),
9118 LOOKUP(28, ABI_VFP_args
),
9119 LOOKUP(29, ABI_WMMX_args
),
9120 LOOKUP(30, ABI_optimization_goals
),
9121 LOOKUP(31, ABI_FP_optimization_goals
),
9122 {32, "compatibility", 0, NULL
},
9123 LOOKUP(34, CPU_unaligned_access
),
9124 LOOKUP(36, VFP_HP_extension
),
9125 LOOKUP(38, ABI_FP_16bit_format
),
9126 {64, "nodefaults", 0, NULL
},
9127 {65, "also_compatible_with", 0, NULL
},
9128 LOOKUP(66, T2EE_use
),
9129 {67, "conformance", 1, NULL
},
9130 LOOKUP(68, Virtualization_use
),
9131 LOOKUP(70, MPextension_use
)
9135 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
9139 read_uleb128 (unsigned char * p
, unsigned int * plen
)
9153 val
|= ((unsigned int)c
& 0x7f) << shift
;
9162 static unsigned char *
9163 display_arm_attribute (unsigned char * p
)
9168 arm_attr_public_tag
* attr
;
9172 tag
= read_uleb128 (p
, &len
);
9175 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
9177 if (arm_attr_public_tags
[i
].tag
== tag
)
9179 attr
= &arm_attr_public_tags
[i
];
9186 printf (" Tag_%s: ", attr
->name
);
9192 case 7: /* Tag_CPU_arch_profile. */
9193 val
= read_uleb128 (p
, &len
);
9197 case 0: printf ("None\n"); break;
9198 case 'A': printf ("Application\n"); break;
9199 case 'R': printf ("Realtime\n"); break;
9200 case 'M': printf ("Microcontroller\n"); break;
9201 default: printf ("??? (%d)\n", val
); break;
9205 case 32: /* Tag_compatibility. */
9206 val
= read_uleb128 (p
, &len
);
9208 printf ("flag = %d, vendor = %s\n", val
, p
);
9209 p
+= strlen ((char *) p
) + 1;
9212 case 64: /* Tag_nodefaults. */
9217 case 65: /* Tag_also_compatible_with. */
9218 val
= read_uleb128 (p
, &len
);
9220 if (val
== 6 /* Tag_CPU_arch. */)
9222 val
= read_uleb128 (p
, &len
);
9224 if ((unsigned int)val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
9225 printf ("??? (%d)\n", val
);
9227 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
9231 while (*(p
++) != '\0' /* NUL terminator. */);
9245 assert (attr
->type
& 0x80);
9246 val
= read_uleb128 (p
, &len
);
9248 type
= attr
->type
& 0x7f;
9250 printf ("??? (%d)\n", val
);
9252 printf ("%s\n", attr
->table
[val
]);
9259 type
= 1; /* String. */
9261 type
= 2; /* uleb128. */
9262 printf (" Tag_unknown_%d: ", tag
);
9267 printf ("\"%s\"\n", p
);
9268 p
+= strlen ((char *) p
) + 1;
9272 val
= read_uleb128 (p
, &len
);
9274 printf ("%d (0x%x)\n", val
, val
);
9280 static unsigned char *
9281 display_gnu_attribute (unsigned char * p
,
9282 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
9289 tag
= read_uleb128 (p
, &len
);
9292 /* Tag_compatibility is the only generic GNU attribute defined at
9296 val
= read_uleb128 (p
, &len
);
9298 printf ("flag = %d, vendor = %s\n", val
, p
);
9299 p
+= strlen ((char *) p
) + 1;
9303 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
9304 return display_proc_gnu_attribute (p
, tag
);
9307 type
= 1; /* String. */
9309 type
= 2; /* uleb128. */
9310 printf (" Tag_unknown_%d: ", tag
);
9314 printf ("\"%s\"\n", p
);
9315 p
+= strlen ((char *) p
) + 1;
9319 val
= read_uleb128 (p
, &len
);
9321 printf ("%d (0x%x)\n", val
, val
);
9327 static unsigned char *
9328 display_power_gnu_attribute (unsigned char * p
, int tag
)
9334 if (tag
== Tag_GNU_Power_ABI_FP
)
9336 val
= read_uleb128 (p
, &len
);
9338 printf (" Tag_GNU_Power_ABI_FP: ");
9343 printf ("Hard or soft float\n");
9346 printf ("Hard float\n");
9349 printf ("Soft float\n");
9352 printf ("Single-precision hard float\n");
9355 printf ("??? (%d)\n", val
);
9361 if (tag
== Tag_GNU_Power_ABI_Vector
)
9363 val
= read_uleb128 (p
, &len
);
9365 printf (" Tag_GNU_Power_ABI_Vector: ");
9372 printf ("Generic\n");
9375 printf ("AltiVec\n");
9381 printf ("??? (%d)\n", val
);
9387 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
9389 val
= read_uleb128 (p
, &len
);
9391 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
9401 printf ("Memory\n");
9404 printf ("??? (%d)\n", val
);
9411 type
= 1; /* String. */
9413 type
= 2; /* uleb128. */
9414 printf (" Tag_unknown_%d: ", tag
);
9418 printf ("\"%s\"\n", p
);
9419 p
+= strlen ((char *) p
) + 1;
9423 val
= read_uleb128 (p
, &len
);
9425 printf ("%d (0x%x)\n", val
, val
);
9431 static unsigned char *
9432 display_mips_gnu_attribute (unsigned char * p
, int tag
)
9438 if (tag
== Tag_GNU_MIPS_ABI_FP
)
9440 val
= read_uleb128 (p
, &len
);
9442 printf (" Tag_GNU_MIPS_ABI_FP: ");
9447 printf ("Hard or soft float\n");
9450 printf ("Hard float (-mdouble-float)\n");
9453 printf ("Hard float (-msingle-float)\n");
9456 printf ("Soft float\n");
9459 printf ("64-bit float (-mips32r2 -mfp64)\n");
9462 printf ("??? (%d)\n", val
);
9469 type
= 1; /* String. */
9471 type
= 2; /* uleb128. */
9472 printf (" Tag_unknown_%d: ", tag
);
9476 printf ("\"%s\"\n", p
);
9477 p
+= strlen ((char *) p
) + 1;
9481 val
= read_uleb128 (p
, &len
);
9483 printf ("%d (0x%x)\n", val
, val
);
9490 process_attributes (FILE * file
,
9491 const char * public_name
,
9492 unsigned int proc_type
,
9493 unsigned char * (* display_pub_attribute
) (unsigned char *),
9494 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
9496 Elf_Internal_Shdr
* sect
;
9497 unsigned char * contents
;
9499 unsigned char * end
;
9500 bfd_vma section_len
;
9504 /* Find the section header so that we get the size. */
9505 for (i
= 0, sect
= section_headers
;
9506 i
< elf_header
.e_shnum
;
9509 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
9512 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
9513 sect
->sh_size
, _("attributes"));
9514 if (contents
== NULL
)
9520 len
= sect
->sh_size
- 1;
9526 bfd_boolean public_section
;
9527 bfd_boolean gnu_section
;
9529 section_len
= byte_get (p
, 4);
9532 if (section_len
> len
)
9534 printf (_("ERROR: Bad section length (%d > %d)\n"),
9535 (int) section_len
, (int) len
);
9540 printf ("Attribute Section: %s\n", p
);
9542 if (public_name
&& streq ((char *) p
, public_name
))
9543 public_section
= TRUE
;
9545 public_section
= FALSE
;
9547 if (streq ((char *) p
, "gnu"))
9550 gnu_section
= FALSE
;
9552 namelen
= strlen ((char *) p
) + 1;
9554 section_len
-= namelen
+ 4;
9556 while (section_len
> 0)
9562 size
= byte_get (p
, 4);
9563 if (size
> section_len
)
9565 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
9566 (int) size
, (int) section_len
);
9570 section_len
-= size
;
9577 printf ("File Attributes\n");
9580 printf ("Section Attributes:");
9583 printf ("Symbol Attributes:");
9589 val
= read_uleb128 (p
, &i
);
9593 printf (" %d", val
);
9598 printf ("Unknown tag: %d\n", tag
);
9599 public_section
= FALSE
;
9606 p
= display_pub_attribute (p
);
9608 else if (gnu_section
)
9611 p
= display_gnu_attribute (p
,
9612 display_proc_gnu_attribute
);
9616 /* ??? Do something sensible, like dump hex. */
9617 printf (" Unknown section contexts\n");
9624 printf (_("Unknown format '%c'\n"), *p
);
9632 process_arm_specific (FILE * file
)
9634 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
9635 display_arm_attribute
, NULL
);
9639 process_power_specific (FILE * file
)
9641 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9642 display_power_gnu_attribute
);
9645 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
9646 Print the Address, Access and Initial fields of an entry at VMA ADDR
9647 and return the VMA of the next entry. */
9650 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
9653 print_vma (addr
, LONG_HEX
);
9655 if (addr
< pltgot
+ 0xfff0)
9656 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
9658 printf ("%10s", "");
9661 printf ("%*s", is_32bit_elf
? 8 : 16, "<unknown>");
9666 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
9667 print_vma (entry
, LONG_HEX
);
9669 return addr
+ (is_32bit_elf
? 4 : 8);
9672 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
9673 PLTGOT. Print the Address and Initial fields of an entry at VMA
9674 ADDR and return the VMA of the next entry. */
9677 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
9680 print_vma (addr
, LONG_HEX
);
9683 printf ("%*s", is_32bit_elf
? 8 : 16, "<unknown>");
9688 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
9689 print_vma (entry
, LONG_HEX
);
9691 return addr
+ (is_32bit_elf
? 4 : 8);
9695 process_mips_specific (FILE * file
)
9697 Elf_Internal_Dyn
* entry
;
9698 size_t liblist_offset
= 0;
9699 size_t liblistno
= 0;
9700 size_t conflictsno
= 0;
9701 size_t options_offset
= 0;
9702 size_t conflicts_offset
= 0;
9703 size_t pltrelsz
= 0;
9706 bfd_vma mips_pltgot
= 0;
9708 bfd_vma local_gotno
= 0;
9710 bfd_vma symtabno
= 0;
9712 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9713 display_mips_gnu_attribute
);
9715 /* We have a lot of special sections. Thanks SGI! */
9716 if (dynamic_section
== NULL
)
9717 /* No information available. */
9720 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
9721 switch (entry
->d_tag
)
9723 case DT_MIPS_LIBLIST
:
9725 = offset_from_vma (file
, entry
->d_un
.d_val
,
9726 liblistno
* sizeof (Elf32_External_Lib
));
9728 case DT_MIPS_LIBLISTNO
:
9729 liblistno
= entry
->d_un
.d_val
;
9731 case DT_MIPS_OPTIONS
:
9732 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9734 case DT_MIPS_CONFLICT
:
9736 = offset_from_vma (file
, entry
->d_un
.d_val
,
9737 conflictsno
* sizeof (Elf32_External_Conflict
));
9739 case DT_MIPS_CONFLICTNO
:
9740 conflictsno
= entry
->d_un
.d_val
;
9743 pltgot
= entry
->d_un
.d_ptr
;
9745 case DT_MIPS_LOCAL_GOTNO
:
9746 local_gotno
= entry
->d_un
.d_val
;
9748 case DT_MIPS_GOTSYM
:
9749 gotsym
= entry
->d_un
.d_val
;
9751 case DT_MIPS_SYMTABNO
:
9752 symtabno
= entry
->d_un
.d_val
;
9754 case DT_MIPS_PLTGOT
:
9755 mips_pltgot
= entry
->d_un
.d_ptr
;
9758 pltrel
= entry
->d_un
.d_val
;
9761 pltrelsz
= entry
->d_un
.d_val
;
9764 jmprel
= entry
->d_un
.d_ptr
;
9770 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9772 Elf32_External_Lib
* elib
;
9775 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
9777 sizeof (Elf32_External_Lib
),
9781 printf ("\nSection '.liblist' contains %lu entries:\n",
9782 (unsigned long) liblistno
);
9783 fputs (" Library Time Stamp Checksum Version Flags\n",
9786 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9793 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9794 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9795 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9796 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9797 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9799 tmp
= gmtime (&time
);
9800 snprintf (timebuf
, sizeof (timebuf
),
9801 "%04u-%02u-%02uT%02u:%02u:%02u",
9802 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9803 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9805 printf ("%3lu: ", (unsigned long) cnt
);
9806 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
9807 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
9809 printf ("<corrupt: %9ld>", liblist
.l_name
);
9810 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9813 if (liblist
.l_flags
== 0)
9824 { " EXACT_MATCH", LL_EXACT_MATCH
},
9825 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9826 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9827 { " EXPORTS", LL_EXPORTS
},
9828 { " DELAY_LOAD", LL_DELAY_LOAD
},
9829 { " DELTA", LL_DELTA
}
9831 int flags
= liblist
.l_flags
;
9834 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
9835 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9837 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9838 flags
^= l_flags_vals
[fcnt
].bit
;
9841 printf (" %#x", (unsigned int) flags
);
9851 if (options_offset
!= 0)
9853 Elf_External_Options
* eopt
;
9854 Elf_Internal_Shdr
* sect
= section_headers
;
9855 Elf_Internal_Options
* iopt
;
9856 Elf_Internal_Options
* option
;
9860 /* Find the section header so that we get the size. */
9861 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9864 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
9865 sect
->sh_size
, _("options"));
9868 iopt
= (Elf_Internal_Options
*)
9869 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
9872 error (_("Out of memory\n"));
9879 while (offset
< sect
->sh_size
)
9881 Elf_External_Options
* eoption
;
9883 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9885 option
->kind
= BYTE_GET (eoption
->kind
);
9886 option
->size
= BYTE_GET (eoption
->size
);
9887 option
->section
= BYTE_GET (eoption
->section
);
9888 option
->info
= BYTE_GET (eoption
->info
);
9890 offset
+= option
->size
;
9896 printf (_("\nSection '%s' contains %d entries:\n"),
9897 SECTION_NAME (sect
), cnt
);
9905 switch (option
->kind
)
9908 /* This shouldn't happen. */
9909 printf (" NULL %d %lx", option
->section
, option
->info
);
9912 printf (" REGINFO ");
9913 if (elf_header
.e_machine
== EM_MIPS
)
9916 Elf32_External_RegInfo
* ereg
;
9917 Elf32_RegInfo reginfo
;
9919 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9920 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9921 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9922 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9923 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9924 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9925 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9927 printf ("GPR %08lx GP 0x%lx\n",
9929 (unsigned long) reginfo
.ri_gp_value
);
9930 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9931 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9932 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9937 Elf64_External_RegInfo
* ereg
;
9938 Elf64_Internal_RegInfo reginfo
;
9940 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9941 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9942 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9943 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9944 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9945 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9946 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9948 printf ("GPR %08lx GP 0x",
9949 reginfo
.ri_gprmask
);
9950 printf_vma (reginfo
.ri_gp_value
);
9953 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9954 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9955 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9959 case ODK_EXCEPTIONS
:
9960 fputs (" EXCEPTIONS fpe_min(", stdout
);
9961 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9962 fputs (") fpe_max(", stdout
);
9963 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9964 fputs (")", stdout
);
9966 if (option
->info
& OEX_PAGE0
)
9967 fputs (" PAGE0", stdout
);
9968 if (option
->info
& OEX_SMM
)
9969 fputs (" SMM", stdout
);
9970 if (option
->info
& OEX_FPDBUG
)
9971 fputs (" FPDBUG", stdout
);
9972 if (option
->info
& OEX_DISMISS
)
9973 fputs (" DISMISS", stdout
);
9976 fputs (" PAD ", stdout
);
9977 if (option
->info
& OPAD_PREFIX
)
9978 fputs (" PREFIX", stdout
);
9979 if (option
->info
& OPAD_POSTFIX
)
9980 fputs (" POSTFIX", stdout
);
9981 if (option
->info
& OPAD_SYMBOL
)
9982 fputs (" SYMBOL", stdout
);
9985 fputs (" HWPATCH ", stdout
);
9986 if (option
->info
& OHW_R4KEOP
)
9987 fputs (" R4KEOP", stdout
);
9988 if (option
->info
& OHW_R8KPFETCH
)
9989 fputs (" R8KPFETCH", stdout
);
9990 if (option
->info
& OHW_R5KEOP
)
9991 fputs (" R5KEOP", stdout
);
9992 if (option
->info
& OHW_R5KCVTL
)
9993 fputs (" R5KCVTL", stdout
);
9996 fputs (" FILL ", stdout
);
9997 /* XXX Print content of info word? */
10000 fputs (" TAGS ", stdout
);
10001 /* XXX Print content of info word? */
10004 fputs (" HWAND ", stdout
);
10005 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
10006 fputs (" R4KEOP_CHECKED", stdout
);
10007 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
10008 fputs (" R4KEOP_CLEAN", stdout
);
10011 fputs (" HWOR ", stdout
);
10012 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
10013 fputs (" R4KEOP_CHECKED", stdout
);
10014 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
10015 fputs (" R4KEOP_CLEAN", stdout
);
10018 printf (" GP_GROUP %#06lx self-contained %#06lx",
10019 option
->info
& OGP_GROUP
,
10020 (option
->info
& OGP_SELF
) >> 16);
10023 printf (" IDENT %#06lx self-contained %#06lx",
10024 option
->info
& OGP_GROUP
,
10025 (option
->info
& OGP_SELF
) >> 16);
10028 /* This shouldn't happen. */
10029 printf (" %3d ??? %d %lx",
10030 option
->kind
, option
->section
, option
->info
);
10034 len
= sizeof (* eopt
);
10035 while (len
< option
->size
)
10036 if (((char *) option
)[len
] >= ' '
10037 && ((char *) option
)[len
] < 0x7f)
10038 printf ("%c", ((char *) option
)[len
++]);
10040 printf ("\\%03o", ((char *) option
)[len
++]);
10042 fputs ("\n", stdout
);
10050 if (conflicts_offset
!= 0 && conflictsno
!= 0)
10052 Elf32_Conflict
* iconf
;
10055 if (dynamic_symbols
== NULL
)
10057 error (_("conflict list found without a dynamic symbol table\n"));
10061 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
10064 error (_("Out of memory\n"));
10070 Elf32_External_Conflict
* econf32
;
10072 econf32
= (Elf32_External_Conflict
*)
10073 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
10074 sizeof (* econf32
), _("conflict"));
10078 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10079 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
10085 Elf64_External_Conflict
* econf64
;
10087 econf64
= (Elf64_External_Conflict
*)
10088 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
10089 sizeof (* econf64
), _("conflict"));
10093 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10094 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
10099 printf (_("\nSection '.conflict' contains %lu entries:\n"),
10100 (unsigned long) conflictsno
);
10101 puts (_(" Num: Index Value Name"));
10103 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10105 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
10107 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
10108 print_vma (psym
->st_value
, FULL_HEX
);
10110 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10111 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10113 printf ("<corrupt: %14ld>", psym
->st_name
);
10120 if (pltgot
!= 0 && local_gotno
!= 0)
10122 bfd_vma entry
, local_end
, global_end
;
10124 unsigned char * data
;
10128 addr_size
= (is_32bit_elf
? 4 : 8);
10129 local_end
= pltgot
+ local_gotno
* addr_size
;
10130 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
10132 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
10133 data
= (unsigned char *) get_data (NULL
, file
, offset
,
10134 global_end
- pltgot
, 1, _("GOT"));
10135 printf (_("\nPrimary GOT:\n"));
10136 printf (_(" Canonical gp value: "));
10137 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
10140 printf (_(" Reserved entries:\n"));
10141 printf (_(" %*s %10s %*s Purpose\n"),
10142 addr_size
* 2, "Address", "Access",
10143 addr_size
* 2, "Initial");
10144 entry
= print_mips_got_entry (data
, pltgot
, entry
);
10145 printf (" Lazy resolver\n");
10147 && (byte_get (data
+ entry
- pltgot
, addr_size
)
10148 >> (addr_size
* 8 - 1)) != 0)
10150 entry
= print_mips_got_entry (data
, pltgot
, entry
);
10151 printf (" Module pointer (GNU extension)\n");
10155 if (entry
< local_end
)
10157 printf (_(" Local entries:\n"));
10158 printf (_(" %*s %10s %*s\n"),
10159 addr_size
* 2, "Address", "Access",
10160 addr_size
* 2, "Initial");
10161 while (entry
< local_end
)
10163 entry
= print_mips_got_entry (data
, pltgot
, entry
);
10169 if (gotsym
< symtabno
)
10173 printf (_(" Global entries:\n"));
10174 printf (_(" %*s %10s %*s %*s %-7s %3s %s\n"),
10175 addr_size
* 2, "Address", "Access",
10176 addr_size
* 2, "Initial",
10177 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
10178 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
10179 for (i
= gotsym
; i
< symtabno
; i
++)
10181 Elf_Internal_Sym
* psym
;
10183 psym
= dynamic_symbols
+ i
;
10184 entry
= print_mips_got_entry (data
, pltgot
, entry
);
10186 print_vma (psym
->st_value
, LONG_HEX
);
10187 printf (" %-7s %3s ",
10188 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
10189 get_symbol_index_type (psym
->st_shndx
));
10190 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10191 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
10193 printf ("<corrupt: %14ld>", psym
->st_name
);
10203 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
10205 bfd_vma entry
, end
;
10206 size_t offset
, rel_offset
;
10207 unsigned long count
, i
;
10208 unsigned char * data
;
10209 int addr_size
, sym_width
;
10210 Elf_Internal_Rela
* rels
;
10212 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
10213 if (pltrel
== DT_RELA
)
10215 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
10220 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
10224 entry
= mips_pltgot
;
10225 addr_size
= (is_32bit_elf
? 4 : 8);
10226 end
= mips_pltgot
+ (2 + count
) * addr_size
;
10228 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
10229 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
10231 printf (_("\nPLT GOT:\n\n"));
10232 printf (_(" Reserved entries:\n"));
10233 printf (_(" %*s %*s Purpose\n"),
10234 addr_size
* 2, "Address", addr_size
* 2, "Initial");
10235 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
10236 printf (" PLT lazy resolver\n");
10237 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
10238 printf (" Module pointer\n");
10241 printf (_(" Entries:\n"));
10242 printf (_(" %*s %*s %*s %-7s %3s %s\n"),
10243 addr_size
* 2, "Address",
10244 addr_size
* 2, "Initial",
10245 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
10246 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
10247 for (i
= 0; i
< count
; i
++)
10249 Elf_Internal_Sym
* psym
;
10251 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
10252 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
10254 print_vma (psym
->st_value
, LONG_HEX
);
10255 printf (" %-7s %3s ",
10256 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
10257 get_symbol_index_type (psym
->st_shndx
));
10258 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10259 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
10261 printf ("<corrupt: %14ld>", psym
->st_name
);
10275 process_gnu_liblist (FILE * file
)
10277 Elf_Internal_Shdr
* section
;
10278 Elf_Internal_Shdr
* string_sec
;
10279 Elf32_External_Lib
* elib
;
10281 size_t strtab_size
;
10288 for (i
= 0, section
= section_headers
;
10289 i
< elf_header
.e_shnum
;
10292 switch (section
->sh_type
)
10294 case SHT_GNU_LIBLIST
:
10295 if (section
->sh_link
>= elf_header
.e_shnum
)
10298 elib
= (Elf32_External_Lib
*)
10299 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
10304 string_sec
= section_headers
+ section
->sh_link
;
10306 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
10307 string_sec
->sh_size
,
10308 _("liblist string table"));
10309 strtab_size
= string_sec
->sh_size
;
10312 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
10318 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
10319 SECTION_NAME (section
),
10320 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
10322 puts (" Library Time Stamp Checksum Version Flags");
10324 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
10332 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
10333 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
10334 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
10335 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
10336 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
10338 tmp
= gmtime (&time
);
10339 snprintf (timebuf
, sizeof (timebuf
),
10340 "%04u-%02u-%02uT%02u:%02u:%02u",
10341 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10342 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10344 printf ("%3lu: ", (unsigned long) cnt
);
10346 printf ("%-20s", liblist
.l_name
< strtab_size
10347 ? strtab
+ liblist
.l_name
: "<corrupt>");
10349 printf ("%-20.20s", liblist
.l_name
< strtab_size
10350 ? strtab
+ liblist
.l_name
: "<corrupt>");
10351 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
10352 liblist
.l_version
, liblist
.l_flags
);
10362 static const char *
10363 get_note_type (unsigned e_type
)
10365 static char buff
[64];
10367 if (elf_header
.e_type
== ET_CORE
)
10371 return _("NT_AUXV (auxiliary vector)");
10373 return _("NT_PRSTATUS (prstatus structure)");
10375 return _("NT_FPREGSET (floating point registers)");
10377 return _("NT_PRPSINFO (prpsinfo structure)");
10378 case NT_TASKSTRUCT
:
10379 return _("NT_TASKSTRUCT (task structure)");
10381 return _("NT_PRXFPREG (user_xfpregs structure)");
10383 return _("NT_PPC_VMX (ppc Altivec registers)");
10385 return _("NT_PPC_VSX (ppc VSX registers)");
10387 return _("NT_PSTATUS (pstatus structure)");
10389 return _("NT_FPREGS (floating point registers)");
10391 return _("NT_PSINFO (psinfo structure)");
10393 return _("NT_LWPSTATUS (lwpstatus_t structure)");
10395 return _("NT_LWPSINFO (lwpsinfo_t structure)");
10396 case NT_WIN32PSTATUS
:
10397 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
10405 return _("NT_VERSION (version)");
10407 return _("NT_ARCH (architecture)");
10412 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10416 static const char *
10417 get_gnu_elf_note_type (unsigned e_type
)
10419 static char buff
[64];
10423 case NT_GNU_ABI_TAG
:
10424 return _("NT_GNU_ABI_TAG (ABI version tag)");
10426 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
10427 case NT_GNU_BUILD_ID
:
10428 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
10429 case NT_GNU_GOLD_VERSION
:
10430 return _("NT_GNU_GOLD_VERSION (gold version)");
10435 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10439 static const char *
10440 get_netbsd_elfcore_note_type (unsigned e_type
)
10442 static char buff
[64];
10444 if (e_type
== NT_NETBSDCORE_PROCINFO
)
10446 /* NetBSD core "procinfo" structure. */
10447 return _("NetBSD procinfo structure");
10450 /* As of Jan 2002 there are no other machine-independent notes
10451 defined for NetBSD core files. If the note type is less
10452 than the start of the machine-dependent note types, we don't
10455 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
10457 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10461 switch (elf_header
.e_machine
)
10463 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
10464 and PT_GETFPREGS == mach+2. */
10469 case EM_SPARC32PLUS
:
10473 case NT_NETBSDCORE_FIRSTMACH
+0:
10474 return _("PT_GETREGS (reg structure)");
10475 case NT_NETBSDCORE_FIRSTMACH
+2:
10476 return _("PT_GETFPREGS (fpreg structure)");
10482 /* On all other arch's, PT_GETREGS == mach+1 and
10483 PT_GETFPREGS == mach+3. */
10487 case NT_NETBSDCORE_FIRSTMACH
+1:
10488 return _("PT_GETREGS (reg structure)");
10489 case NT_NETBSDCORE_FIRSTMACH
+3:
10490 return _("PT_GETFPREGS (fpreg structure)");
10496 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
10497 e_type
- NT_NETBSDCORE_FIRSTMACH
);
10501 /* Note that by the ELF standard, the name field is already null byte
10502 terminated, and namesz includes the terminating null byte.
10503 I.E. the value of namesz for the name "FSF" is 4.
10505 If the value of namesz is zero, there is no name present. */
10507 process_note (Elf_Internal_Note
* pnote
)
10509 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
10512 if (pnote
->namesz
== 0)
10513 /* If there is no note name, then use the default set of
10514 note type strings. */
10515 nt
= get_note_type (pnote
->type
);
10517 else if (const_strneq (pnote
->namedata
, "GNU"))
10518 /* GNU-specific object file notes. */
10519 nt
= get_gnu_elf_note_type (pnote
->type
);
10521 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
10522 /* NetBSD-specific core file notes. */
10523 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
10525 else if (strneq (pnote
->namedata
, "SPU/", 4))
10527 /* SPU-specific core file notes. */
10528 nt
= pnote
->namedata
+ 4;
10533 /* Don't recognize this note name; just use the default set of
10534 note type strings. */
10535 nt
= get_note_type (pnote
->type
);
10537 printf (" %s\t\t0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
10543 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
10545 Elf_External_Note
* pnotes
;
10546 Elf_External_Note
* external
;
10552 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
10559 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
10560 (unsigned long) offset
, (unsigned long) length
);
10561 printf (_(" Owner\t\tData size\tDescription\n"));
10563 while (external
< (Elf_External_Note
*) ((char *) pnotes
+ length
))
10565 Elf_External_Note
* next
;
10566 Elf_Internal_Note inote
;
10567 char * temp
= NULL
;
10569 inote
.type
= BYTE_GET (external
->type
);
10570 inote
.namesz
= BYTE_GET (external
->namesz
);
10571 inote
.namedata
= external
->name
;
10572 inote
.descsz
= BYTE_GET (external
->descsz
);
10573 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
10574 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
10576 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
10578 if (((char *) next
) > (((char *) pnotes
) + length
))
10580 warn (_("corrupt note found at offset %lx into core notes\n"),
10581 (unsigned long) ((char *) external
- (char *) pnotes
));
10582 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
10583 inote
.type
, inote
.namesz
, inote
.descsz
);
10589 /* Verify that name is null terminated. It appears that at least
10590 one version of Linux (RedHat 6.0) generates corefiles that don't
10591 comply with the ELF spec by failing to include the null byte in
10593 if (inote
.namedata
[inote
.namesz
] != '\0')
10595 temp
= (char *) malloc (inote
.namesz
+ 1);
10599 error (_("Out of memory\n"));
10604 strncpy (temp
, inote
.namedata
, inote
.namesz
);
10605 temp
[inote
.namesz
] = 0;
10607 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
10608 inote
.namedata
= temp
;
10611 res
&= process_note (& inote
);
10626 process_corefile_note_segments (FILE * file
)
10628 Elf_Internal_Phdr
* segment
;
10632 if (! get_program_headers (file
))
10635 for (i
= 0, segment
= program_headers
;
10636 i
< elf_header
.e_phnum
;
10639 if (segment
->p_type
== PT_NOTE
)
10640 res
&= process_corefile_note_segment (file
,
10641 (bfd_vma
) segment
->p_offset
,
10642 (bfd_vma
) segment
->p_filesz
);
10649 process_note_sections (FILE * file
)
10651 Elf_Internal_Shdr
* section
;
10655 for (i
= 0, section
= section_headers
;
10656 i
< elf_header
.e_shnum
;
10658 if (section
->sh_type
== SHT_NOTE
)
10659 res
&= process_corefile_note_segment (file
,
10660 (bfd_vma
) section
->sh_offset
,
10661 (bfd_vma
) section
->sh_size
);
10667 process_notes (FILE * file
)
10669 /* If we have not been asked to display the notes then do nothing. */
10673 if (elf_header
.e_type
!= ET_CORE
)
10674 return process_note_sections (file
);
10676 /* No program headers means no NOTE segment. */
10677 if (elf_header
.e_phnum
> 0)
10678 return process_corefile_note_segments (file
);
10680 printf (_("No note segments present in the core file.\n"));
10685 process_arch_specific (FILE * file
)
10690 switch (elf_header
.e_machine
)
10693 return process_arm_specific (file
);
10695 case EM_MIPS_RS3_LE
:
10696 return process_mips_specific (file
);
10699 return process_power_specific (file
);
10708 get_file_header (FILE * file
)
10710 /* Read in the identity array. */
10711 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
10714 /* Determine how to read the rest of the header. */
10715 switch (elf_header
.e_ident
[EI_DATA
])
10717 default: /* fall through */
10718 case ELFDATANONE
: /* fall through */
10720 byte_get
= byte_get_little_endian
;
10721 byte_put
= byte_put_little_endian
;
10724 byte_get
= byte_get_big_endian
;
10725 byte_put
= byte_put_big_endian
;
10729 /* For now we only support 32 bit and 64 bit ELF files. */
10730 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
10732 /* Read in the rest of the header. */
10735 Elf32_External_Ehdr ehdr32
;
10737 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
10740 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
10741 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
10742 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
10743 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
10744 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
10745 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
10746 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
10747 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
10748 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
10749 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
10750 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
10751 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
10752 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
10756 Elf64_External_Ehdr ehdr64
;
10758 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10759 we will not be able to cope with the 64bit data found in
10760 64 ELF files. Detect this now and abort before we start
10761 overwriting things. */
10762 if (sizeof (bfd_vma
) < 8)
10764 error (_("This instance of readelf has been built without support for a\n\
10765 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10769 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
10772 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
10773 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
10774 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
10775 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
10776 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
10777 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
10778 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
10779 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
10780 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
10781 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
10782 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
10783 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
10784 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
10787 if (elf_header
.e_shoff
)
10789 /* There may be some extensions in the first section header. Don't
10790 bomb if we can't read it. */
10792 get_32bit_section_headers (file
, 1);
10794 get_64bit_section_headers (file
, 1);
10800 /* Process one ELF object file according to the command line options.
10801 This file may actually be stored in an archive. The file is
10802 positioned at the start of the ELF object. */
10805 process_object (char * file_name
, FILE * file
)
10809 if (! get_file_header (file
))
10811 error (_("%s: Failed to read file header\n"), file_name
);
10815 /* Initialise per file variables. */
10816 for (i
= ARRAY_SIZE (version_info
); i
--;)
10817 version_info
[i
] = 0;
10819 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
10820 dynamic_info
[i
] = 0;
10822 /* Process the file. */
10824 printf (_("\nFile: %s\n"), file_name
);
10826 /* Initialise the dump_sects array from the cmdline_dump_sects array.
10827 Note we do this even if cmdline_dump_sects is empty because we
10828 must make sure that the dump_sets array is zeroed out before each
10829 object file is processed. */
10830 if (num_dump_sects
> num_cmdline_dump_sects
)
10831 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
10833 if (num_cmdline_dump_sects
> 0)
10835 if (num_dump_sects
== 0)
10836 /* A sneaky way of allocating the dump_sects array. */
10837 request_dump_bynumber (num_cmdline_dump_sects
, 0);
10839 assert (num_dump_sects
>= num_cmdline_dump_sects
);
10840 memcpy (dump_sects
, cmdline_dump_sects
,
10841 num_cmdline_dump_sects
* sizeof (* dump_sects
));
10844 if (! process_file_header ())
10847 if (! process_section_headers (file
))
10849 /* Without loaded section headers we cannot process lots of
10851 do_unwind
= do_version
= do_dump
= do_arch
= 0;
10853 if (! do_using_dynamic
)
10854 do_syms
= do_reloc
= 0;
10857 if (! process_section_groups (file
))
10859 /* Without loaded section groups we cannot process unwind. */
10863 if (process_program_headers (file
))
10864 process_dynamic_section (file
);
10866 process_relocs (file
);
10868 process_unwind (file
);
10870 process_symbol_table (file
);
10872 process_syminfo (file
);
10874 process_version_sections (file
);
10876 process_section_contents (file
);
10878 process_notes (file
);
10880 process_gnu_liblist (file
);
10882 process_arch_specific (file
);
10884 if (program_headers
)
10886 free (program_headers
);
10887 program_headers
= NULL
;
10890 if (section_headers
)
10892 free (section_headers
);
10893 section_headers
= NULL
;
10898 free (string_table
);
10899 string_table
= NULL
;
10900 string_table_length
= 0;
10903 if (dynamic_strings
)
10905 free (dynamic_strings
);
10906 dynamic_strings
= NULL
;
10907 dynamic_strings_length
= 0;
10910 if (dynamic_symbols
)
10912 free (dynamic_symbols
);
10913 dynamic_symbols
= NULL
;
10914 num_dynamic_syms
= 0;
10917 if (dynamic_syminfo
)
10919 free (dynamic_syminfo
);
10920 dynamic_syminfo
= NULL
;
10923 if (section_headers_groups
)
10925 free (section_headers_groups
);
10926 section_headers_groups
= NULL
;
10929 if (section_groups
)
10931 struct group_list
* g
;
10932 struct group_list
* next
;
10934 for (i
= 0; i
< group_count
; i
++)
10936 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
10943 free (section_groups
);
10944 section_groups
= NULL
;
10947 free_debug_memory ();
10952 /* Return the path name for a proxy entry in a thin archive, adjusted relative
10953 to the path name of the thin archive itself if necessary. Always returns
10954 a pointer to malloc'ed memory. */
10957 adjust_relative_path (char * file_name
, char * name
, int name_len
)
10959 char * member_file_name
;
10960 const char * base_name
= lbasename (file_name
);
10962 /* This is a proxy entry for a thin archive member.
10963 If the extended name table contains an absolute path
10964 name, or if the archive is in the current directory,
10965 use the path name as given. Otherwise, we need to
10966 find the member relative to the directory where the
10967 archive is located. */
10968 if (IS_ABSOLUTE_PATH (name
) || base_name
== file_name
)
10970 member_file_name
= (char *) malloc (name_len
+ 1);
10971 if (member_file_name
== NULL
)
10973 error (_("Out of memory\n"));
10976 memcpy (member_file_name
, name
, name_len
);
10977 member_file_name
[name_len
] = '\0';
10981 /* Concatenate the path components of the archive file name
10982 to the relative path name from the extended name table. */
10983 size_t prefix_len
= base_name
- file_name
;
10984 member_file_name
= (char *) malloc (prefix_len
+ name_len
+ 1);
10985 if (member_file_name
== NULL
)
10987 error (_("Out of memory\n"));
10990 memcpy (member_file_name
, file_name
, prefix_len
);
10991 memcpy (member_file_name
+ prefix_len
, name
, name_len
);
10992 member_file_name
[prefix_len
+ name_len
] = '\0';
10994 return member_file_name
;
10997 /* Structure to hold information about an archive file. */
10999 struct archive_info
11001 char * file_name
; /* Archive file name. */
11002 FILE * file
; /* Open file descriptor. */
11003 unsigned long index_num
; /* Number of symbols in table. */
11004 unsigned long * index_array
; /* The array of member offsets. */
11005 char * sym_table
; /* The symbol table. */
11006 unsigned long sym_size
; /* Size of the symbol table. */
11007 char * longnames
; /* The long file names table. */
11008 unsigned long longnames_size
; /* Size of the long file names table. */
11009 unsigned long nested_member_origin
; /* Origin in the nested archive of the current member. */
11010 unsigned long next_arhdr_offset
; /* Offset of the next archive header. */
11011 bfd_boolean is_thin_archive
; /* TRUE if this is a thin archive. */
11012 struct ar_hdr arhdr
; /* Current archive header. */
11015 /* Read the symbol table and long-name table from an archive. */
11018 setup_archive (struct archive_info
* arch
, char * file_name
, FILE * file
,
11019 bfd_boolean is_thin_archive
, bfd_boolean read_symbols
)
11022 unsigned long size
;
11024 arch
->file_name
= strdup (file_name
);
11026 arch
->index_num
= 0;
11027 arch
->index_array
= NULL
;
11028 arch
->sym_table
= NULL
;
11029 arch
->sym_size
= 0;
11030 arch
->longnames
= NULL
;
11031 arch
->longnames_size
= 0;
11032 arch
->nested_member_origin
= 0;
11033 arch
->is_thin_archive
= is_thin_archive
;
11034 arch
->next_arhdr_offset
= SARMAG
;
11036 /* Read the first archive member header. */
11037 if (fseek (file
, SARMAG
, SEEK_SET
) != 0)
11039 error (_("%s: failed to seek to first archive header\n"), file_name
);
11042 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
11043 if (got
!= sizeof arch
->arhdr
)
11048 error (_("%s: failed to read archive header\n"), file_name
);
11052 /* See if this is the archive symbol table. */
11053 if (const_strneq (arch
->arhdr
.ar_name
, "/ ")
11054 || const_strneq (arch
->arhdr
.ar_name
, "/SYM64/ "))
11056 size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
11057 size
= size
+ (size
& 1);
11059 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ size
;
11064 /* A buffer used to hold numbers read in from an archive index.
11065 These are always 4 bytes long and stored in big-endian format. */
11066 #define SIZEOF_AR_INDEX_NUMBERS 4
11067 unsigned char integer_buffer
[SIZEOF_AR_INDEX_NUMBERS
];
11068 unsigned char * index_buffer
;
11070 /* Check the size of the archive index. */
11071 if (size
< SIZEOF_AR_INDEX_NUMBERS
)
11073 error (_("%s: the archive index is empty\n"), file_name
);
11077 /* Read the numer of entries in the archive index. */
11078 got
= fread (integer_buffer
, 1, sizeof integer_buffer
, file
);
11079 if (got
!= sizeof (integer_buffer
))
11081 error (_("%s: failed to read archive index\n"), file_name
);
11084 arch
->index_num
= byte_get_big_endian (integer_buffer
, sizeof integer_buffer
);
11085 size
-= SIZEOF_AR_INDEX_NUMBERS
;
11087 /* Read in the archive index. */
11088 if (size
< arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
)
11090 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
11091 file_name
, arch
->index_num
);
11094 index_buffer
= (unsigned char *)
11095 malloc (arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
);
11096 if (index_buffer
== NULL
)
11098 error (_("Out of memory whilst trying to read archive symbol index\n"));
11101 got
= fread (index_buffer
, SIZEOF_AR_INDEX_NUMBERS
, arch
->index_num
, file
);
11102 if (got
!= arch
->index_num
)
11104 free (index_buffer
);
11105 error (_("%s: failed to read archive index\n"), file_name
);
11108 size
-= arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
;
11110 /* Convert the index numbers into the host's numeric format. */
11111 arch
->index_array
= (long unsigned int *)
11112 malloc (arch
->index_num
* sizeof (* arch
->index_array
));
11113 if (arch
->index_array
== NULL
)
11115 free (index_buffer
);
11116 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
11120 for (i
= 0; i
< arch
->index_num
; i
++)
11121 arch
->index_array
[i
] = byte_get_big_endian ((unsigned char *) (index_buffer
+ (i
* SIZEOF_AR_INDEX_NUMBERS
)),
11122 SIZEOF_AR_INDEX_NUMBERS
);
11123 free (index_buffer
);
11125 /* The remaining space in the header is taken up by the symbol table. */
11128 error (_("%s: the archive has an index but no symbols\n"), file_name
);
11131 arch
->sym_table
= (char *) malloc (size
);
11132 arch
->sym_size
= size
;
11133 if (arch
->sym_table
== NULL
)
11135 error (_("Out of memory whilst trying to read archive index symbol table\n"));
11138 got
= fread (arch
->sym_table
, 1, size
, file
);
11141 error (_("%s: failed to read archive index symbol table\n"), file_name
);
11147 if (fseek (file
, size
, SEEK_CUR
) != 0)
11149 error (_("%s: failed to skip archive symbol table\n"), file_name
);
11154 /* Read the next archive header. */
11155 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
11156 if (got
!= sizeof arch
->arhdr
)
11160 error (_("%s: failed to read archive header following archive index\n"), file_name
);
11164 else if (read_symbols
)
11165 printf (_("%s has no archive index\n"), file_name
);
11167 if (const_strneq (arch
->arhdr
.ar_name
, "// "))
11169 /* This is the archive string table holding long member names. */
11170 arch
->longnames_size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
11171 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ arch
->longnames_size
;
11173 arch
->longnames
= (char *) malloc (arch
->longnames_size
);
11174 if (arch
->longnames
== NULL
)
11176 error (_("Out of memory reading long symbol names in archive\n"));
11180 if (fread (arch
->longnames
, arch
->longnames_size
, 1, file
) != 1)
11182 free (arch
->longnames
);
11183 arch
->longnames
= NULL
;
11184 error (_("%s: failed to read long symbol name string table\n"), file_name
);
11188 if ((arch
->longnames_size
& 1) != 0)
11195 /* Release the memory used for the archive information. */
11198 release_archive (struct archive_info
* arch
)
11200 if (arch
->file_name
!= NULL
)
11201 free (arch
->file_name
);
11202 if (arch
->index_array
!= NULL
)
11203 free (arch
->index_array
);
11204 if (arch
->sym_table
!= NULL
)
11205 free (arch
->sym_table
);
11206 if (arch
->longnames
!= NULL
)
11207 free (arch
->longnames
);
11210 /* Open and setup a nested archive, if not already open. */
11213 setup_nested_archive (struct archive_info
* nested_arch
, char * member_file_name
)
11215 FILE * member_file
;
11217 /* Have we already setup this archive? */
11218 if (nested_arch
->file_name
!= NULL
11219 && streq (nested_arch
->file_name
, member_file_name
))
11222 /* Close previous file and discard cached information. */
11223 if (nested_arch
->file
!= NULL
)
11224 fclose (nested_arch
->file
);
11225 release_archive (nested_arch
);
11227 member_file
= fopen (member_file_name
, "rb");
11228 if (member_file
== NULL
)
11230 return setup_archive (nested_arch
, member_file_name
, member_file
, FALSE
, FALSE
);
11234 get_archive_member_name_at (struct archive_info
* arch
,
11235 unsigned long offset
,
11236 struct archive_info
* nested_arch
);
11238 /* Get the name of an archive member from the current archive header.
11239 For simple names, this will modify the ar_name field of the current
11240 archive header. For long names, it will return a pointer to the
11241 longnames table. For nested archives, it will open the nested archive
11242 and get the name recursively. NESTED_ARCH is a single-entry cache so
11243 we don't keep rereading the same information from a nested archive. */
11246 get_archive_member_name (struct archive_info
* arch
,
11247 struct archive_info
* nested_arch
)
11249 unsigned long j
, k
;
11251 if (arch
->arhdr
.ar_name
[0] == '/')
11253 /* We have a long name. */
11255 char * member_file_name
;
11256 char * member_name
;
11258 arch
->nested_member_origin
= 0;
11259 k
= j
= strtoul (arch
->arhdr
.ar_name
+ 1, &endp
, 10);
11260 if (arch
->is_thin_archive
&& endp
!= NULL
&& * endp
== ':')
11261 arch
->nested_member_origin
= strtoul (endp
+ 1, NULL
, 10);
11263 while ((j
< arch
->longnames_size
)
11264 && (arch
->longnames
[j
] != '\n')
11265 && (arch
->longnames
[j
] != '\0'))
11267 if (arch
->longnames
[j
-1] == '/')
11269 arch
->longnames
[j
] = '\0';
11271 if (!arch
->is_thin_archive
|| arch
->nested_member_origin
== 0)
11272 return arch
->longnames
+ k
;
11274 /* This is a proxy for a member of a nested archive.
11275 Find the name of the member in that archive. */
11276 member_file_name
= adjust_relative_path (arch
->file_name
, arch
->longnames
+ k
, j
- k
);
11277 if (member_file_name
!= NULL
11278 && setup_nested_archive (nested_arch
, member_file_name
) == 0
11279 && (member_name
= get_archive_member_name_at (nested_arch
, arch
->nested_member_origin
, NULL
)) != NULL
)
11281 free (member_file_name
);
11282 return member_name
;
11284 free (member_file_name
);
11286 /* Last resort: just return the name of the nested archive. */
11287 return arch
->longnames
+ k
;
11290 /* We have a normal (short) name. */
11292 while ((arch
->arhdr
.ar_name
[j
] != '/') && (j
< 16))
11294 arch
->arhdr
.ar_name
[j
] = '\0';
11295 return arch
->arhdr
.ar_name
;
11298 /* Get the name of an archive member at a given OFFSET within an archive ARCH. */
11301 get_archive_member_name_at (struct archive_info
* arch
,
11302 unsigned long offset
,
11303 struct archive_info
* nested_arch
)
11307 if (fseek (arch
->file
, offset
, SEEK_SET
) != 0)
11309 error (_("%s: failed to seek to next file name\n"), arch
->file_name
);
11312 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, arch
->file
);
11313 if (got
!= sizeof arch
->arhdr
)
11315 error (_("%s: failed to read archive header\n"), arch
->file_name
);
11318 if (memcmp (arch
->arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
11320 error (_("%s: did not find a valid archive header\n"), arch
->file_name
);
11324 return get_archive_member_name (arch
, nested_arch
);
11327 /* Construct a string showing the name of the archive member, qualified
11328 with the name of the containing archive file. For thin archives, we
11329 use square brackets to denote the indirection. For nested archives,
11330 we show the qualified name of the external member inside the square
11331 brackets (e.g., "thin.a[normal.a(foo.o)]"). */
11334 make_qualified_name (struct archive_info
* arch
,
11335 struct archive_info
* nested_arch
,
11336 char * member_name
)
11341 len
= strlen (arch
->file_name
) + strlen (member_name
) + 3;
11342 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
11343 len
+= strlen (nested_arch
->file_name
) + 2;
11345 name
= (char *) malloc (len
);
11348 error (_("Out of memory\n"));
11352 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
11353 snprintf (name
, len
, "%s[%s(%s)]", arch
->file_name
, nested_arch
->file_name
, member_name
);
11354 else if (arch
->is_thin_archive
)
11355 snprintf (name
, len
, "%s[%s]", arch
->file_name
, member_name
);
11357 snprintf (name
, len
, "%s(%s)", arch
->file_name
, member_name
);
11362 /* Process an ELF archive.
11363 On entry the file is positioned just after the ARMAG string. */
11366 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
11368 struct archive_info arch
;
11369 struct archive_info nested_arch
;
11371 size_t file_name_size
;
11376 /* The ARCH structure is used to hold information about this archive. */
11377 arch
.file_name
= NULL
;
11379 arch
.index_array
= NULL
;
11380 arch
.sym_table
= NULL
;
11381 arch
.longnames
= NULL
;
11383 /* The NESTED_ARCH structure is used as a single-item cache of information
11384 about a nested archive (when members of a thin archive reside within
11385 another regular archive file). */
11386 nested_arch
.file_name
= NULL
;
11387 nested_arch
.file
= NULL
;
11388 nested_arch
.index_array
= NULL
;
11389 nested_arch
.sym_table
= NULL
;
11390 nested_arch
.longnames
= NULL
;
11392 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
11398 if (do_archive_index
)
11400 if (arch
.sym_table
== NULL
)
11401 error (_("%s: unable to dump the index as none was found\n"), file_name
);
11405 unsigned long current_pos
;
11407 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
11408 file_name
, arch
.index_num
, arch
.sym_size
);
11409 current_pos
= ftell (file
);
11411 for (i
= l
= 0; i
< arch
.index_num
; i
++)
11413 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
11415 char * member_name
;
11417 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
11419 if (member_name
!= NULL
)
11421 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
11423 if (qualified_name
!= NULL
)
11425 printf (_("Binary %s contains:\n"), qualified_name
);
11426 free (qualified_name
);
11431 if (l
>= arch
.sym_size
)
11433 error (_("%s: end of the symbol table reached before the end of the index\n"),
11437 printf ("\t%s\n", arch
.sym_table
+ l
);
11438 l
+= strlen (arch
.sym_table
+ l
) + 1;
11443 if (l
< arch
.sym_size
)
11444 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
11447 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
11449 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
11455 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
11456 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
11457 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
11458 && !do_section_groups
)
11460 ret
= 0; /* Archive index only. */
11465 file_name_size
= strlen (file_name
);
11472 char * qualified_name
;
11474 /* Read the next archive header. */
11475 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
11477 error (_("%s: failed to seek to next archive header\n"), file_name
);
11480 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
11481 if (got
!= sizeof arch
.arhdr
)
11485 error (_("%s: failed to read archive header\n"), file_name
);
11489 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
11491 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
11496 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
11498 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
11499 if (archive_file_size
& 01)
11500 ++archive_file_size
;
11502 name
= get_archive_member_name (&arch
, &nested_arch
);
11505 error (_("%s: bad archive file name\n"), file_name
);
11509 namelen
= strlen (name
);
11511 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
11512 if (qualified_name
== NULL
)
11514 error (_("%s: bad archive file name\n"), file_name
);
11519 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
11521 /* This is a proxy for an external member of a thin archive. */
11522 FILE * member_file
;
11523 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
11524 if (member_file_name
== NULL
)
11530 member_file
= fopen (member_file_name
, "rb");
11531 if (member_file
== NULL
)
11533 error (_("Input file '%s' is not readable.\n"), member_file_name
);
11534 free (member_file_name
);
11539 archive_file_offset
= arch
.nested_member_origin
;
11541 ret
|= process_object (qualified_name
, member_file
);
11543 fclose (member_file
);
11544 free (member_file_name
);
11546 else if (is_thin_archive
)
11548 /* This is a proxy for a member of a nested archive. */
11549 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
11551 /* The nested archive file will have been opened and setup by
11552 get_archive_member_name. */
11553 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
11555 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
11560 ret
|= process_object (qualified_name
, nested_arch
.file
);
11564 archive_file_offset
= arch
.next_arhdr_offset
;
11565 arch
.next_arhdr_offset
+= archive_file_size
;
11567 ret
|= process_object (qualified_name
, file
);
11570 free (qualified_name
);
11574 if (nested_arch
.file
!= NULL
)
11575 fclose (nested_arch
.file
);
11576 release_archive (&nested_arch
);
11577 release_archive (&arch
);
11583 process_file (char * file_name
)
11586 struct stat statbuf
;
11587 char armag
[SARMAG
];
11590 if (stat (file_name
, &statbuf
) < 0)
11592 if (errno
== ENOENT
)
11593 error (_("'%s': No such file\n"), file_name
);
11595 error (_("Could not locate '%s'. System error message: %s\n"),
11596 file_name
, strerror (errno
));
11600 if (! S_ISREG (statbuf
.st_mode
))
11602 error (_("'%s' is not an ordinary file\n"), file_name
);
11606 file
= fopen (file_name
, "rb");
11609 error (_("Input file '%s' is not readable.\n"), file_name
);
11613 if (fread (armag
, SARMAG
, 1, file
) != 1)
11615 error (_("%s: Failed to read file's magic number\n"), file_name
);
11620 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
11621 ret
= process_archive (file_name
, file
, FALSE
);
11622 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
11623 ret
= process_archive (file_name
, file
, TRUE
);
11626 if (do_archive_index
)
11627 error (_("File %s is not an archive so its index cannot be displayed.\n"),
11631 archive_file_size
= archive_file_offset
= 0;
11632 ret
= process_object (file_name
, file
);
11640 #ifdef SUPPORT_DISASSEMBLY
11641 /* Needed by the i386 disassembler. For extra credit, someone could
11642 fix this so that we insert symbolic addresses here, esp for GOT/PLT
11646 print_address (unsigned int addr
, FILE * outfile
)
11648 fprintf (outfile
,"0x%8.8x", addr
);
11651 /* Needed by the i386 disassembler. */
11653 db_task_printsym (unsigned int addr
)
11655 print_address (addr
, stderr
);
11660 main (int argc
, char ** argv
)
11664 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
11665 setlocale (LC_MESSAGES
, "");
11667 #if defined (HAVE_SETLOCALE)
11668 setlocale (LC_CTYPE
, "");
11670 bindtextdomain (PACKAGE
, LOCALEDIR
);
11671 textdomain (PACKAGE
);
11673 expandargv (&argc
, &argv
);
11675 parse_args (argc
, argv
);
11677 if (num_dump_sects
> 0)
11679 /* Make a copy of the dump_sects array. */
11680 cmdline_dump_sects
= (dump_type
*)
11681 malloc (num_dump_sects
* sizeof (* dump_sects
));
11682 if (cmdline_dump_sects
== NULL
)
11683 error (_("Out of memory allocating dump request table.\n"));
11686 memcpy (cmdline_dump_sects
, dump_sects
,
11687 num_dump_sects
* sizeof (* dump_sects
));
11688 num_cmdline_dump_sects
= num_dump_sects
;
11692 if (optind
< (argc
- 1))
11696 while (optind
< argc
)
11697 err
|= process_file (argv
[optind
++]);
11699 if (dump_sects
!= NULL
)
11701 if (cmdline_dump_sects
!= NULL
)
11702 free (cmdline_dump_sects
);