1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3 2008 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/mips.h"
123 #include "elf/mmix.h"
124 #include "elf/mn10200.h"
125 #include "elf/mn10300.h"
127 #include "elf/msp430.h"
128 #include "elf/or32.h"
131 #include "elf/ppc64.h"
132 #include "elf/s390.h"
133 #include "elf/score.h"
135 #include "elf/sparc.h"
137 #include "elf/v850.h"
139 #include "elf/x86-64.h"
140 #include "elf/xstormy16.h"
141 #include "elf/xtensa.h"
146 #include "libiberty.h"
147 #include "safe-ctype.h"
149 char *program_name
= "readelf";
151 static long archive_file_offset
;
152 static unsigned long archive_file_size
;
153 static unsigned long dynamic_addr
;
154 static bfd_size_type dynamic_size
;
155 static unsigned int dynamic_nent
;
156 static char *dynamic_strings
;
157 static unsigned long dynamic_strings_length
;
158 static char *string_table
;
159 static unsigned long string_table_length
;
160 static unsigned long num_dynamic_syms
;
161 static Elf_Internal_Sym
*dynamic_symbols
;
162 static Elf_Internal_Syminfo
*dynamic_syminfo
;
163 static unsigned long dynamic_syminfo_offset
;
164 static unsigned int dynamic_syminfo_nent
;
165 static char program_interpreter
[PATH_MAX
];
166 static bfd_vma dynamic_info
[DT_JMPREL
+ 1];
167 static bfd_vma dynamic_info_DT_GNU_HASH
;
168 static bfd_vma version_info
[16];
169 static Elf_Internal_Ehdr elf_header
;
170 static Elf_Internal_Shdr
*section_headers
;
171 static Elf_Internal_Phdr
*program_headers
;
172 static Elf_Internal_Dyn
*dynamic_section
;
173 static Elf_Internal_Shdr
*symtab_shndx_hdr
;
174 static int show_name
;
175 static int do_dynamic
;
178 static int do_sections
;
179 static int do_section_groups
;
180 static int do_section_details
;
181 static int do_segments
;
182 static int do_unwind
;
183 static int do_using_dynamic
;
184 static int do_header
;
186 static int do_version
;
187 static int do_histogram
;
188 static int do_debugging
;
191 static int do_archive_index
;
192 static int is_32bit_elf
;
196 struct group_list
*next
;
197 unsigned int section_index
;
202 struct group_list
*root
;
203 unsigned int group_index
;
206 static size_t group_count
;
207 static struct group
*section_groups
;
208 static struct group
**section_headers_groups
;
211 /* Flag bits indicating particular types of dump. */
212 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
213 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
214 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
215 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
217 typedef unsigned char dump_type
;
219 /* A linked list of the section names for which dumps were requested. */
220 struct dump_list_entry
224 struct dump_list_entry
*next
;
226 static struct dump_list_entry
*dump_sects_byname
;
228 /* A dynamic array of flags indicating for which sections a dump
229 has been requested via command line switches. */
230 static dump_type
* cmdline_dump_sects
= NULL
;
231 static unsigned int num_cmdline_dump_sects
= 0;
233 /* A dynamic array of flags indicating for which sections a dump of
234 some kind has been requested. It is reset on a per-object file
235 basis and then initialised from the cmdline_dump_sects array,
236 the results of interpreting the -w switch, and the
237 dump_sects_byname list. */
238 static dump_type
* dump_sects
= NULL
;
239 static unsigned int num_dump_sects
= 0;
242 /* How to print a vma value. */
243 typedef enum print_mode
255 static void (*byte_put
) (unsigned char *, bfd_vma
, int);
259 #define SECTION_NAME(X) \
260 ((X) == NULL ? "<none>" \
261 : string_table == NULL ? "<no-name>" \
262 : ((X)->sh_name >= string_table_length ? "<corrupt>" \
263 : string_table + (X)->sh_name))
265 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
267 #define BYTE_GET(field) byte_get (field, sizeof (field))
269 #define GET_ELF_SYMBOLS(file, section) \
270 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
271 : get_64bit_elf_symbols (file, section))
273 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
274 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
275 already been called and verified that the string exists. */
276 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
278 /* This is just a bit of syntatic sugar. */
279 #define streq(a,b) (strcmp ((a), (b)) == 0)
280 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
281 #define const_strneq(a,b) (strncmp ((a), (b), sizeof (b) - 1) == 0)
284 get_data (void *var
, FILE *file
, long offset
, size_t size
, size_t nmemb
,
289 if (size
== 0 || nmemb
== 0)
292 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
294 error (_("Unable to seek to 0x%lx for %s\n"),
295 (unsigned long) archive_file_offset
+ offset
, reason
);
302 /* Check for overflow. */
303 if (nmemb
< (~(size_t) 0 - 1) / size
)
304 /* + 1 so that we can '\0' terminate invalid string table sections. */
305 mvar
= malloc (size
* nmemb
+ 1);
309 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
310 (unsigned long)(size
* nmemb
), reason
);
314 ((char *) mvar
)[size
* nmemb
] = '\0';
317 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
319 error (_("Unable to read in 0x%lx bytes of %s\n"),
320 (unsigned long)(size
* nmemb
), reason
);
330 byte_put_little_endian (unsigned char *field
, bfd_vma value
, int size
)
335 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
336 field
[6] = ((value
>> 24) >> 24) & 0xff;
337 field
[5] = ((value
>> 24) >> 16) & 0xff;
338 field
[4] = ((value
>> 24) >> 8) & 0xff;
341 field
[3] = (value
>> 24) & 0xff;
342 field
[2] = (value
>> 16) & 0xff;
345 field
[1] = (value
>> 8) & 0xff;
348 field
[0] = value
& 0xff;
352 error (_("Unhandled data length: %d\n"), size
);
357 /* Print a VMA value. */
360 print_vma (bfd_vma vma
, print_mode mode
)
373 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
380 return printf ("%5" BFD_VMA_FMT
"d", vma
);
388 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
391 return printf ("%" BFD_VMA_FMT
"d", vma
);
394 return printf ("%" BFD_VMA_FMT
"u", vma
);
399 /* Display a symbol on stdout. Handles the display of non-printing characters.
401 If DO_WIDE is not true then format the symbol to be at most WIDTH characters,
402 truncating as necessary. If WIDTH is negative then format the string to be
403 exactly - WIDTH characters, truncating or padding as necessary.
405 Returns the number of emitted characters. */
408 print_symbol (int width
, const char *symbol
)
411 bfd_boolean extra_padding
= FALSE
;
412 unsigned int num_printed
= 0;
416 /* Set the width to a very large value. This simplifies the code below. */
421 /* Keep the width positive. This also helps. */
423 extra_padding
= TRUE
;
432 /* Look for non-printing symbols inside the symbol's name.
433 This test is triggered in particular by the names generated
434 by the assembler for local labels. */
435 while (ISPRINT (* c
))
445 printf ("%.*s", len
, symbol
);
451 if (* c
== 0 || width
== 0)
454 /* Now display the non-printing character, if
455 there is room left in which to dipslay it. */
461 printf ("^%c", *c
+ 0x40);
471 printf ("<0x%.2x>", *c
);
480 if (extra_padding
&& width
> 0)
482 /* Fill in the remaining spaces. */
483 printf ("%-*s", width
, " ");
491 byte_put_big_endian (unsigned char *field
, bfd_vma value
, int size
)
496 field
[7] = value
& 0xff;
497 field
[6] = (value
>> 8) & 0xff;
498 field
[5] = (value
>> 16) & 0xff;
499 field
[4] = (value
>> 24) & 0xff;
504 field
[3] = value
& 0xff;
505 field
[2] = (value
>> 8) & 0xff;
509 field
[1] = value
& 0xff;
513 field
[0] = value
& 0xff;
517 error (_("Unhandled data length: %d\n"), size
);
522 /* Return a pointer to section NAME, or NULL if no such section exists. */
524 static Elf_Internal_Shdr
*
525 find_section (const char *name
)
529 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
530 if (streq (SECTION_NAME (section_headers
+ i
), name
))
531 return section_headers
+ i
;
536 /* Guess the relocation size commonly used by the specific machines. */
539 guess_is_rela (unsigned int e_machine
)
543 /* Targets that use REL relocations. */
559 /* Targets that use RELA relocations. */
563 case EM_ALTERA_NIOS2
:
583 case EM_LATTICEMICO32
:
591 case EM_CYGNUS_MN10200
:
593 case EM_CYGNUS_MN10300
:
634 warn (_("Don't know about relocations on this machine architecture\n"));
640 slurp_rela_relocs (FILE *file
,
641 unsigned long rel_offset
,
642 unsigned long rel_size
,
643 Elf_Internal_Rela
**relasp
,
644 unsigned long *nrelasp
)
646 Elf_Internal_Rela
*relas
;
647 unsigned long nrelas
;
652 Elf32_External_Rela
*erelas
;
654 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
658 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
660 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
665 error (_("out of memory parsing relocs\n"));
669 for (i
= 0; i
< nrelas
; i
++)
671 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
672 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
673 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
680 Elf64_External_Rela
*erelas
;
682 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
686 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
688 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
693 error (_("out of memory parsing relocs\n"));
697 for (i
= 0; i
< nrelas
; i
++)
699 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
700 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
701 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
703 /* The #ifdef BFD64 below is to prevent a compile time
704 warning. We know that if we do not have a 64 bit data
705 type that we will never execute this code anyway. */
707 if (elf_header
.e_machine
== EM_MIPS
708 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
710 /* In little-endian objects, r_info isn't really a
711 64-bit little-endian value: it has a 32-bit
712 little-endian symbol index followed by four
713 individual byte fields. Reorder INFO
715 bfd_vma info
= relas
[i
].r_info
;
716 info
= (((info
& 0xffffffff) << 32)
717 | ((info
>> 56) & 0xff)
718 | ((info
>> 40) & 0xff00)
719 | ((info
>> 24) & 0xff0000)
720 | ((info
>> 8) & 0xff000000));
721 relas
[i
].r_info
= info
;
734 slurp_rel_relocs (FILE *file
,
735 unsigned long rel_offset
,
736 unsigned long rel_size
,
737 Elf_Internal_Rela
**relsp
,
738 unsigned long *nrelsp
)
740 Elf_Internal_Rela
*rels
;
746 Elf32_External_Rel
*erels
;
748 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
752 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
754 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
759 error (_("out of memory parsing relocs\n"));
763 for (i
= 0; i
< nrels
; i
++)
765 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
766 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
767 rels
[i
].r_addend
= 0;
774 Elf64_External_Rel
*erels
;
776 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
780 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
782 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
787 error (_("out of memory parsing relocs\n"));
791 for (i
= 0; i
< nrels
; i
++)
793 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
794 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
795 rels
[i
].r_addend
= 0;
797 /* The #ifdef BFD64 below is to prevent a compile time
798 warning. We know that if we do not have a 64 bit data
799 type that we will never execute this code anyway. */
801 if (elf_header
.e_machine
== EM_MIPS
802 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
804 /* In little-endian objects, r_info isn't really a
805 64-bit little-endian value: it has a 32-bit
806 little-endian symbol index followed by four
807 individual byte fields. Reorder INFO
809 bfd_vma info
= rels
[i
].r_info
;
810 info
= (((info
& 0xffffffff) << 32)
811 | ((info
>> 56) & 0xff)
812 | ((info
>> 40) & 0xff00)
813 | ((info
>> 24) & 0xff0000)
814 | ((info
>> 8) & 0xff000000));
815 rels
[i
].r_info
= info
;
827 /* Returns the reloc type extracted from the reloc info field. */
830 get_reloc_type (bfd_vma reloc_info
)
833 return ELF32_R_TYPE (reloc_info
);
835 switch (elf_header
.e_machine
)
838 /* Note: We assume that reloc_info has already been adjusted for us. */
839 return ELF64_MIPS_R_TYPE (reloc_info
);
842 return ELF64_R_TYPE_ID (reloc_info
);
845 return ELF64_R_TYPE (reloc_info
);
849 /* Return the symbol index extracted from the reloc info field. */
852 get_reloc_symindex (bfd_vma reloc_info
)
854 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
857 /* Display the contents of the relocation data found at the specified
861 dump_relocations (FILE *file
,
862 unsigned long rel_offset
,
863 unsigned long rel_size
,
864 Elf_Internal_Sym
*symtab
,
867 unsigned long strtablen
,
871 Elf_Internal_Rela
*rels
;
874 if (is_rela
== UNKNOWN
)
875 is_rela
= guess_is_rela (elf_header
.e_machine
);
879 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
884 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
893 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
895 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
900 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
902 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
910 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
912 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
917 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
919 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
923 for (i
= 0; i
< rel_size
; i
++)
928 bfd_vma symtab_index
;
931 offset
= rels
[i
].r_offset
;
932 info
= rels
[i
].r_info
;
934 type
= get_reloc_type (info
);
935 symtab_index
= get_reloc_symindex (info
);
939 printf ("%8.8lx %8.8lx ",
940 (unsigned long) offset
& 0xffffffff,
941 (unsigned long) info
& 0xffffffff);
945 #if BFD_HOST_64BIT_LONG
947 ? "%16.16lx %16.16lx "
948 : "%12.12lx %12.12lx ",
950 #elif BFD_HOST_64BIT_LONG_LONG
953 ? "%16.16llx %16.16llx "
954 : "%12.12llx %12.12llx ",
958 ? "%16.16I64x %16.16I64x "
959 : "%12.12I64x %12.12I64x ",
964 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
965 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
966 _bfd_int64_high (offset
),
967 _bfd_int64_low (offset
),
968 _bfd_int64_high (info
),
969 _bfd_int64_low (info
));
973 switch (elf_header
.e_machine
)
981 rtype
= elf_m32r_reloc_type (type
);
986 rtype
= elf_i386_reloc_type (type
);
991 rtype
= elf_m68hc11_reloc_type (type
);
995 rtype
= elf_m68k_reloc_type (type
);
999 rtype
= elf_i960_reloc_type (type
);
1004 rtype
= elf_avr_reloc_type (type
);
1007 case EM_OLD_SPARCV9
:
1008 case EM_SPARC32PLUS
:
1011 rtype
= elf_sparc_reloc_type (type
);
1015 rtype
= elf_spu_reloc_type (type
);
1019 case EM_CYGNUS_V850
:
1020 rtype
= v850_reloc_type (type
);
1024 case EM_CYGNUS_D10V
:
1025 rtype
= elf_d10v_reloc_type (type
);
1029 case EM_CYGNUS_D30V
:
1030 rtype
= elf_d30v_reloc_type (type
);
1034 rtype
= elf_dlx_reloc_type (type
);
1038 rtype
= elf_sh_reloc_type (type
);
1042 case EM_CYGNUS_MN10300
:
1043 rtype
= elf_mn10300_reloc_type (type
);
1047 case EM_CYGNUS_MN10200
:
1048 rtype
= elf_mn10200_reloc_type (type
);
1052 case EM_CYGNUS_FR30
:
1053 rtype
= elf_fr30_reloc_type (type
);
1057 rtype
= elf_frv_reloc_type (type
);
1061 rtype
= elf_mcore_reloc_type (type
);
1065 rtype
= elf_mmix_reloc_type (type
);
1070 rtype
= elf_msp430_reloc_type (type
);
1074 rtype
= elf_ppc_reloc_type (type
);
1078 rtype
= elf_ppc64_reloc_type (type
);
1082 case EM_MIPS_RS3_LE
:
1083 rtype
= elf_mips_reloc_type (type
);
1087 rtype
= elf_alpha_reloc_type (type
);
1091 rtype
= elf_arm_reloc_type (type
);
1095 rtype
= elf_arc_reloc_type (type
);
1099 rtype
= elf_hppa_reloc_type (type
);
1105 rtype
= elf_h8_reloc_type (type
);
1110 rtype
= elf_or32_reloc_type (type
);
1115 rtype
= elf_pj_reloc_type (type
);
1118 rtype
= elf_ia64_reloc_type (type
);
1122 rtype
= elf_cris_reloc_type (type
);
1126 rtype
= elf_i860_reloc_type (type
);
1130 rtype
= elf_x86_64_reloc_type (type
);
1134 rtype
= i370_reloc_type (type
);
1139 rtype
= elf_s390_reloc_type (type
);
1143 rtype
= elf_score_reloc_type (type
);
1147 rtype
= elf_xstormy16_reloc_type (type
);
1151 rtype
= elf_crx_reloc_type (type
);
1155 rtype
= elf_vax_reloc_type (type
);
1160 rtype
= elf_ip2k_reloc_type (type
);
1164 rtype
= elf_iq2000_reloc_type (type
);
1169 rtype
= elf_xtensa_reloc_type (type
);
1172 case EM_LATTICEMICO32
:
1173 rtype
= elf_lm32_reloc_type (type
);
1178 rtype
= elf_m32c_reloc_type (type
);
1182 rtype
= elf_mt_reloc_type (type
);
1186 rtype
= elf_bfin_reloc_type (type
);
1190 rtype
= elf_mep_reloc_type (type
);
1195 rtype
= elf_cr16_reloc_type (type
);
1200 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1202 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1204 if (elf_header
.e_machine
== EM_ALPHA
1206 && streq (rtype
, "R_ALPHA_LITUSE")
1209 switch (rels
[i
].r_addend
)
1211 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1212 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1213 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1214 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1215 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1216 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1217 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1218 default: rtype
= NULL
;
1221 printf (" (%s)", rtype
);
1225 printf (_("<unknown addend: %lx>"),
1226 (unsigned long) rels
[i
].r_addend
);
1229 else if (symtab_index
)
1231 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1232 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1235 Elf_Internal_Sym
*psym
;
1237 psym
= symtab
+ symtab_index
;
1241 print_vma (psym
->st_value
, LONG_HEX
);
1243 printf (is_32bit_elf
? " " : " ");
1245 if (psym
->st_name
== 0)
1247 const char *sec_name
= "<null>";
1250 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1252 if (psym
->st_shndx
< elf_header
.e_shnum
)
1254 = SECTION_NAME (section_headers
+ psym
->st_shndx
);
1255 else if (psym
->st_shndx
== SHN_ABS
)
1257 else if (psym
->st_shndx
== SHN_COMMON
)
1258 sec_name
= "COMMON";
1259 else if (elf_header
.e_machine
== EM_MIPS
1260 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1261 sec_name
= "SCOMMON";
1262 else if (elf_header
.e_machine
== EM_MIPS
1263 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1264 sec_name
= "SUNDEF";
1265 else if (elf_header
.e_machine
== EM_X86_64
1266 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1267 sec_name
= "LARGE_COMMON";
1268 else if (elf_header
.e_machine
== EM_IA_64
1269 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1270 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1271 sec_name
= "ANSI_COM";
1272 else if (elf_header
.e_machine
== EM_IA_64
1273 && (elf_header
.e_ident
[EI_OSABI
]
1274 == ELFOSABI_OPENVMS
)
1275 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1276 sec_name
= "VMS_SYMVEC";
1279 sprintf (name_buf
, "<section 0x%x>",
1280 (unsigned int) psym
->st_shndx
);
1281 sec_name
= name_buf
;
1284 print_symbol (22, sec_name
);
1286 else if (strtab
== NULL
)
1287 printf (_("<string table index: %3ld>"), psym
->st_name
);
1288 else if (psym
->st_name
>= strtablen
)
1289 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1291 print_symbol (22, strtab
+ psym
->st_name
);
1295 long offset
= (long) (bfd_signed_vma
) rels
[i
].r_addend
;
1298 printf (" - %lx", - offset
);
1300 printf (" + %lx", offset
);
1306 printf ("%*c", is_32bit_elf
?
1307 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1308 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1311 if (elf_header
.e_machine
== EM_SPARCV9
1313 && streq (rtype
, "R_SPARC_OLO10"))
1314 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1319 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1321 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (info
);
1322 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (info
);
1323 const char *rtype2
= elf_mips_reloc_type (type2
);
1324 const char *rtype3
= elf_mips_reloc_type (type3
);
1326 printf (" Type2: ");
1329 printf (_("unrecognized: %-7lx"),
1330 (unsigned long) type2
& 0xffffffff);
1332 printf ("%-17.17s", rtype2
);
1334 printf ("\n Type3: ");
1337 printf (_("unrecognized: %-7lx"),
1338 (unsigned long) type3
& 0xffffffff);
1340 printf ("%-17.17s", rtype3
);
1351 get_mips_dynamic_type (unsigned long type
)
1355 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1356 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1357 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1358 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1359 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1360 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1361 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1362 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1363 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1364 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1365 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1366 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1367 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1368 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1369 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1370 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1371 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1372 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1373 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1374 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1375 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1376 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1377 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1378 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1379 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1380 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1381 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1382 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1383 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1384 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1385 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1386 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1387 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1388 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1389 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1390 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1391 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1392 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1393 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1394 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1395 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1396 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1397 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1398 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1399 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1406 get_sparc64_dynamic_type (unsigned long type
)
1410 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1417 get_ppc_dynamic_type (unsigned long type
)
1421 case DT_PPC_GOT
: return "PPC_GOT";
1428 get_ppc64_dynamic_type (unsigned long type
)
1432 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1433 case DT_PPC64_OPD
: return "PPC64_OPD";
1434 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1441 get_parisc_dynamic_type (unsigned long type
)
1445 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1446 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1447 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1448 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1449 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1450 case DT_HP_PREINIT
: return "HP_PREINIT";
1451 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1452 case DT_HP_NEEDED
: return "HP_NEEDED";
1453 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1454 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1455 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1456 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1457 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1458 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1459 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1460 case DT_HP_FILTERED
: return "HP_FILTERED";
1461 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1462 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1463 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1464 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1465 case DT_PLT
: return "PLT";
1466 case DT_PLT_SIZE
: return "PLT_SIZE";
1467 case DT_DLT
: return "DLT";
1468 case DT_DLT_SIZE
: return "DLT_SIZE";
1475 get_ia64_dynamic_type (unsigned long type
)
1479 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1480 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1481 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1482 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1483 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1484 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1485 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1486 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1487 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1488 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1489 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1490 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1491 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1492 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1493 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1494 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1495 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1496 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1497 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1498 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1499 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1500 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1501 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1502 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1503 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1504 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1505 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1506 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1507 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1508 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1509 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1516 get_alpha_dynamic_type (unsigned long type
)
1520 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1527 get_score_dynamic_type (unsigned long type
)
1531 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1532 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1533 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1534 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1535 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1536 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1544 get_dynamic_type (unsigned long type
)
1546 static char buff
[64];
1550 case DT_NULL
: return "NULL";
1551 case DT_NEEDED
: return "NEEDED";
1552 case DT_PLTRELSZ
: return "PLTRELSZ";
1553 case DT_PLTGOT
: return "PLTGOT";
1554 case DT_HASH
: return "HASH";
1555 case DT_STRTAB
: return "STRTAB";
1556 case DT_SYMTAB
: return "SYMTAB";
1557 case DT_RELA
: return "RELA";
1558 case DT_RELASZ
: return "RELASZ";
1559 case DT_RELAENT
: return "RELAENT";
1560 case DT_STRSZ
: return "STRSZ";
1561 case DT_SYMENT
: return "SYMENT";
1562 case DT_INIT
: return "INIT";
1563 case DT_FINI
: return "FINI";
1564 case DT_SONAME
: return "SONAME";
1565 case DT_RPATH
: return "RPATH";
1566 case DT_SYMBOLIC
: return "SYMBOLIC";
1567 case DT_REL
: return "REL";
1568 case DT_RELSZ
: return "RELSZ";
1569 case DT_RELENT
: return "RELENT";
1570 case DT_PLTREL
: return "PLTREL";
1571 case DT_DEBUG
: return "DEBUG";
1572 case DT_TEXTREL
: return "TEXTREL";
1573 case DT_JMPREL
: return "JMPREL";
1574 case DT_BIND_NOW
: return "BIND_NOW";
1575 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1576 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1577 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1578 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1579 case DT_RUNPATH
: return "RUNPATH";
1580 case DT_FLAGS
: return "FLAGS";
1582 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1583 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1585 case DT_CHECKSUM
: return "CHECKSUM";
1586 case DT_PLTPADSZ
: return "PLTPADSZ";
1587 case DT_MOVEENT
: return "MOVEENT";
1588 case DT_MOVESZ
: return "MOVESZ";
1589 case DT_FEATURE
: return "FEATURE";
1590 case DT_POSFLAG_1
: return "POSFLAG_1";
1591 case DT_SYMINSZ
: return "SYMINSZ";
1592 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1594 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1595 case DT_CONFIG
: return "CONFIG";
1596 case DT_DEPAUDIT
: return "DEPAUDIT";
1597 case DT_AUDIT
: return "AUDIT";
1598 case DT_PLTPAD
: return "PLTPAD";
1599 case DT_MOVETAB
: return "MOVETAB";
1600 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1602 case DT_VERSYM
: return "VERSYM";
1604 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1605 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1606 case DT_RELACOUNT
: return "RELACOUNT";
1607 case DT_RELCOUNT
: return "RELCOUNT";
1608 case DT_FLAGS_1
: return "FLAGS_1";
1609 case DT_VERDEF
: return "VERDEF";
1610 case DT_VERDEFNUM
: return "VERDEFNUM";
1611 case DT_VERNEED
: return "VERNEED";
1612 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1614 case DT_AUXILIARY
: return "AUXILIARY";
1615 case DT_USED
: return "USED";
1616 case DT_FILTER
: return "FILTER";
1618 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1619 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1620 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1621 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1622 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1623 case DT_GNU_HASH
: return "GNU_HASH";
1626 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1630 switch (elf_header
.e_machine
)
1633 case EM_MIPS_RS3_LE
:
1634 result
= get_mips_dynamic_type (type
);
1637 result
= get_sparc64_dynamic_type (type
);
1640 result
= get_ppc_dynamic_type (type
);
1643 result
= get_ppc64_dynamic_type (type
);
1646 result
= get_ia64_dynamic_type (type
);
1649 result
= get_alpha_dynamic_type (type
);
1652 result
= get_score_dynamic_type (type
);
1662 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1664 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1665 || (elf_header
.e_machine
== EM_PARISC
1666 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1670 switch (elf_header
.e_machine
)
1673 result
= get_parisc_dynamic_type (type
);
1676 result
= get_ia64_dynamic_type (type
);
1686 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1690 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1697 get_file_type (unsigned e_type
)
1699 static char buff
[32];
1703 case ET_NONE
: return _("NONE (None)");
1704 case ET_REL
: return _("REL (Relocatable file)");
1705 case ET_EXEC
: return _("EXEC (Executable file)");
1706 case ET_DYN
: return _("DYN (Shared object file)");
1707 case ET_CORE
: return _("CORE (Core file)");
1710 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1711 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1712 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1713 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1715 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1721 get_machine_name (unsigned e_machine
)
1723 static char buff
[64]; /* XXX */
1727 case EM_NONE
: return _("None");
1728 case EM_M32
: return "WE32100";
1729 case EM_SPARC
: return "Sparc";
1730 case EM_SPU
: return "SPU";
1731 case EM_386
: return "Intel 80386";
1732 case EM_68K
: return "MC68000";
1733 case EM_88K
: return "MC88000";
1734 case EM_486
: return "Intel 80486";
1735 case EM_860
: return "Intel 80860";
1736 case EM_MIPS
: return "MIPS R3000";
1737 case EM_S370
: return "IBM System/370";
1738 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1739 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1740 case EM_PARISC
: return "HPPA";
1741 case EM_PPC_OLD
: return "Power PC (old)";
1742 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1743 case EM_960
: return "Intel 90860";
1744 case EM_PPC
: return "PowerPC";
1745 case EM_PPC64
: return "PowerPC64";
1746 case EM_V800
: return "NEC V800";
1747 case EM_FR20
: return "Fujitsu FR20";
1748 case EM_RH32
: return "TRW RH32";
1749 case EM_MCORE
: return "MCORE";
1750 case EM_ARM
: return "ARM";
1751 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1752 case EM_SH
: return "Renesas / SuperH SH";
1753 case EM_SPARCV9
: return "Sparc v9";
1754 case EM_TRICORE
: return "Siemens Tricore";
1755 case EM_ARC
: return "ARC";
1756 case EM_H8_300
: return "Renesas H8/300";
1757 case EM_H8_300H
: return "Renesas H8/300H";
1758 case EM_H8S
: return "Renesas H8S";
1759 case EM_H8_500
: return "Renesas H8/500";
1760 case EM_IA_64
: return "Intel IA-64";
1761 case EM_MIPS_X
: return "Stanford MIPS-X";
1762 case EM_COLDFIRE
: return "Motorola Coldfire";
1763 case EM_68HC12
: return "Motorola M68HC12";
1764 case EM_ALPHA
: return "Alpha";
1765 case EM_CYGNUS_D10V
:
1766 case EM_D10V
: return "d10v";
1767 case EM_CYGNUS_D30V
:
1768 case EM_D30V
: return "d30v";
1769 case EM_CYGNUS_M32R
:
1770 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1771 case EM_CYGNUS_V850
:
1772 case EM_V850
: return "NEC v850";
1773 case EM_CYGNUS_MN10300
:
1774 case EM_MN10300
: return "mn10300";
1775 case EM_CYGNUS_MN10200
:
1776 case EM_MN10200
: return "mn10200";
1777 case EM_CYGNUS_FR30
:
1778 case EM_FR30
: return "Fujitsu FR30";
1779 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1781 case EM_PJ
: return "picoJava";
1782 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1783 case EM_PCP
: return "Siemens PCP";
1784 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1785 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1786 case EM_STARCORE
: return "Motorola Star*Core processor";
1787 case EM_ME16
: return "Toyota ME16 processor";
1788 case EM_ST100
: return "STMicroelectronics ST100 processor";
1789 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1790 case EM_FX66
: return "Siemens FX66 microcontroller";
1791 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1792 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1793 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1794 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1795 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1796 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1797 case EM_SVX
: return "Silicon Graphics SVx";
1798 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1799 case EM_VAX
: return "Digital VAX";
1801 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1802 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1803 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1804 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1805 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1806 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1807 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1808 case EM_PRISM
: return "Vitesse Prism";
1809 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1811 case EM_S390
: return "IBM S/390";
1812 case EM_SCORE
: return "SUNPLUS S+Core";
1813 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1815 case EM_OR32
: return "OpenRISC";
1816 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1817 case EM_DLX
: return "OpenDLX";
1819 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1820 case EM_IQ2000
: return "Vitesse IQ2000";
1822 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1823 case EM_LATTICEMICO32
: return "Lattice Mico32";
1825 case EM_M32C
: return "Renesas M32c";
1826 case EM_MT
: return "Morpho Techologies MT processor";
1827 case EM_BLACKFIN
: return "Analog Devices Blackfin";
1828 case EM_NIOS32
: return "Altera Nios";
1829 case EM_ALTERA_NIOS2
: return "Altera Nios II";
1830 case EM_XC16X
: return "Infineon Technologies xc16x";
1831 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
1833 case EM_CR16_OLD
: return "National Semiconductor's CR16";
1835 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
1841 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1846 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1847 e_flags
&= ~ EF_ARM_EABIMASK
;
1849 /* Handle "generic" ARM flags. */
1850 if (e_flags
& EF_ARM_RELEXEC
)
1852 strcat (buf
, ", relocatable executable");
1853 e_flags
&= ~ EF_ARM_RELEXEC
;
1856 if (e_flags
& EF_ARM_HASENTRY
)
1858 strcat (buf
, ", has entry point");
1859 e_flags
&= ~ EF_ARM_HASENTRY
;
1862 /* Now handle EABI specific flags. */
1866 strcat (buf
, ", <unrecognized EABI>");
1871 case EF_ARM_EABI_VER1
:
1872 strcat (buf
, ", Version1 EABI");
1877 /* Process flags one bit at a time. */
1878 flag
= e_flags
& - e_flags
;
1883 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1884 strcat (buf
, ", sorted symbol tables");
1894 case EF_ARM_EABI_VER2
:
1895 strcat (buf
, ", Version2 EABI");
1900 /* Process flags one bit at a time. */
1901 flag
= e_flags
& - e_flags
;
1906 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1907 strcat (buf
, ", sorted symbol tables");
1910 case EF_ARM_DYNSYMSUSESEGIDX
:
1911 strcat (buf
, ", dynamic symbols use segment index");
1914 case EF_ARM_MAPSYMSFIRST
:
1915 strcat (buf
, ", mapping symbols precede others");
1925 case EF_ARM_EABI_VER3
:
1926 strcat (buf
, ", Version3 EABI");
1929 case EF_ARM_EABI_VER4
:
1930 strcat (buf
, ", Version4 EABI");
1933 case EF_ARM_EABI_VER5
:
1934 strcat (buf
, ", Version5 EABI");
1940 /* Process flags one bit at a time. */
1941 flag
= e_flags
& - e_flags
;
1947 strcat (buf
, ", BE8");
1951 strcat (buf
, ", LE8");
1961 case EF_ARM_EABI_UNKNOWN
:
1962 strcat (buf
, ", GNU EABI");
1967 /* Process flags one bit at a time. */
1968 flag
= e_flags
& - e_flags
;
1973 case EF_ARM_INTERWORK
:
1974 strcat (buf
, ", interworking enabled");
1977 case EF_ARM_APCS_26
:
1978 strcat (buf
, ", uses APCS/26");
1981 case EF_ARM_APCS_FLOAT
:
1982 strcat (buf
, ", uses APCS/float");
1986 strcat (buf
, ", position independent");
1990 strcat (buf
, ", 8 bit structure alignment");
1993 case EF_ARM_NEW_ABI
:
1994 strcat (buf
, ", uses new ABI");
1997 case EF_ARM_OLD_ABI
:
1998 strcat (buf
, ", uses old ABI");
2001 case EF_ARM_SOFT_FLOAT
:
2002 strcat (buf
, ", software FP");
2005 case EF_ARM_VFP_FLOAT
:
2006 strcat (buf
, ", VFP");
2009 case EF_ARM_MAVERICK_FLOAT
:
2010 strcat (buf
, ", Maverick FP");
2021 strcat (buf
,", <unknown>");
2025 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2027 static char buf
[1024];
2039 decode_ARM_machine_flags (e_flags
, buf
);
2043 switch (e_flags
& EF_FRV_CPU_MASK
)
2045 case EF_FRV_CPU_GENERIC
:
2049 strcat (buf
, ", fr???");
2052 case EF_FRV_CPU_FR300
:
2053 strcat (buf
, ", fr300");
2056 case EF_FRV_CPU_FR400
:
2057 strcat (buf
, ", fr400");
2059 case EF_FRV_CPU_FR405
:
2060 strcat (buf
, ", fr405");
2063 case EF_FRV_CPU_FR450
:
2064 strcat (buf
, ", fr450");
2067 case EF_FRV_CPU_FR500
:
2068 strcat (buf
, ", fr500");
2070 case EF_FRV_CPU_FR550
:
2071 strcat (buf
, ", fr550");
2074 case EF_FRV_CPU_SIMPLE
:
2075 strcat (buf
, ", simple");
2077 case EF_FRV_CPU_TOMCAT
:
2078 strcat (buf
, ", tomcat");
2084 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2085 strcat (buf
, ", m68000");
2086 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2087 strcat (buf
, ", cpu32");
2088 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2089 strcat (buf
, ", fido_a");
2092 char const *isa
= _("unknown");
2093 char const *mac
= _("unknown mac");
2094 char const *additional
= NULL
;
2096 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2098 case EF_M68K_CF_ISA_A_NODIV
:
2100 additional
= ", nodiv";
2102 case EF_M68K_CF_ISA_A
:
2105 case EF_M68K_CF_ISA_A_PLUS
:
2108 case EF_M68K_CF_ISA_B_NOUSP
:
2110 additional
= ", nousp";
2112 case EF_M68K_CF_ISA_B
:
2116 strcat (buf
, ", cf, isa ");
2119 strcat (buf
, additional
);
2120 if (e_flags
& EF_M68K_CF_FLOAT
)
2121 strcat (buf
, ", float");
2122 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2127 case EF_M68K_CF_MAC
:
2130 case EF_M68K_CF_EMAC
:
2143 if (e_flags
& EF_PPC_EMB
)
2144 strcat (buf
, ", emb");
2146 if (e_flags
& EF_PPC_RELOCATABLE
)
2147 strcat (buf
, ", relocatable");
2149 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2150 strcat (buf
, ", relocatable-lib");
2154 case EM_CYGNUS_V850
:
2155 switch (e_flags
& EF_V850_ARCH
)
2158 strcat (buf
, ", v850e1");
2161 strcat (buf
, ", v850e");
2164 strcat (buf
, ", v850");
2167 strcat (buf
, ", unknown v850 architecture variant");
2173 case EM_CYGNUS_M32R
:
2174 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2175 strcat (buf
, ", m32r");
2179 case EM_MIPS_RS3_LE
:
2180 if (e_flags
& EF_MIPS_NOREORDER
)
2181 strcat (buf
, ", noreorder");
2183 if (e_flags
& EF_MIPS_PIC
)
2184 strcat (buf
, ", pic");
2186 if (e_flags
& EF_MIPS_CPIC
)
2187 strcat (buf
, ", cpic");
2189 if (e_flags
& EF_MIPS_UCODE
)
2190 strcat (buf
, ", ugen_reserved");
2192 if (e_flags
& EF_MIPS_ABI2
)
2193 strcat (buf
, ", abi2");
2195 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2196 strcat (buf
, ", odk first");
2198 if (e_flags
& EF_MIPS_32BITMODE
)
2199 strcat (buf
, ", 32bitmode");
2201 switch ((e_flags
& EF_MIPS_MACH
))
2203 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2204 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2205 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2206 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2207 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2208 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2209 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2210 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2211 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2212 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2213 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2214 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2215 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2216 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
2218 /* We simply ignore the field in this case to avoid confusion:
2219 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2222 default: strcat (buf
, ", unknown CPU"); break;
2225 switch ((e_flags
& EF_MIPS_ABI
))
2227 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2228 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2229 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2230 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2232 /* We simply ignore the field in this case to avoid confusion:
2233 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2234 This means it is likely to be an o32 file, but not for
2237 default: strcat (buf
, ", unknown ABI"); break;
2240 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2241 strcat (buf
, ", mdmx");
2243 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2244 strcat (buf
, ", mips16");
2246 switch ((e_flags
& EF_MIPS_ARCH
))
2248 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2249 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2250 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2251 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2252 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2253 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2254 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2255 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2256 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2257 default: strcat (buf
, ", unknown ISA"); break;
2263 switch ((e_flags
& EF_SH_MACH_MASK
))
2265 case EF_SH1
: strcat (buf
, ", sh1"); break;
2266 case EF_SH2
: strcat (buf
, ", sh2"); break;
2267 case EF_SH3
: strcat (buf
, ", sh3"); break;
2268 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2269 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2270 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2271 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2272 case EF_SH4
: strcat (buf
, ", sh4"); break;
2273 case EF_SH5
: strcat (buf
, ", sh5"); break;
2274 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2275 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2276 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2277 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2278 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2279 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2280 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2281 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2282 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2283 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2284 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2285 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2286 default: strcat (buf
, ", unknown ISA"); break;
2292 if (e_flags
& EF_SPARC_32PLUS
)
2293 strcat (buf
, ", v8+");
2295 if (e_flags
& EF_SPARC_SUN_US1
)
2296 strcat (buf
, ", ultrasparcI");
2298 if (e_flags
& EF_SPARC_SUN_US3
)
2299 strcat (buf
, ", ultrasparcIII");
2301 if (e_flags
& EF_SPARC_HAL_R1
)
2302 strcat (buf
, ", halr1");
2304 if (e_flags
& EF_SPARC_LEDATA
)
2305 strcat (buf
, ", ledata");
2307 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2308 strcat (buf
, ", tso");
2310 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2311 strcat (buf
, ", pso");
2313 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2314 strcat (buf
, ", rmo");
2318 switch (e_flags
& EF_PARISC_ARCH
)
2320 case EFA_PARISC_1_0
:
2321 strcpy (buf
, ", PA-RISC 1.0");
2323 case EFA_PARISC_1_1
:
2324 strcpy (buf
, ", PA-RISC 1.1");
2326 case EFA_PARISC_2_0
:
2327 strcpy (buf
, ", PA-RISC 2.0");
2332 if (e_flags
& EF_PARISC_TRAPNIL
)
2333 strcat (buf
, ", trapnil");
2334 if (e_flags
& EF_PARISC_EXT
)
2335 strcat (buf
, ", ext");
2336 if (e_flags
& EF_PARISC_LSB
)
2337 strcat (buf
, ", lsb");
2338 if (e_flags
& EF_PARISC_WIDE
)
2339 strcat (buf
, ", wide");
2340 if (e_flags
& EF_PARISC_NO_KABP
)
2341 strcat (buf
, ", no kabp");
2342 if (e_flags
& EF_PARISC_LAZYSWAP
)
2343 strcat (buf
, ", lazyswap");
2348 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2349 strcat (buf
, ", new calling convention");
2351 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2352 strcat (buf
, ", gnu calling convention");
2356 if ((e_flags
& EF_IA_64_ABI64
))
2357 strcat (buf
, ", 64-bit");
2359 strcat (buf
, ", 32-bit");
2360 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2361 strcat (buf
, ", reduced fp model");
2362 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2363 strcat (buf
, ", no function descriptors, constant gp");
2364 else if ((e_flags
& EF_IA_64_CONS_GP
))
2365 strcat (buf
, ", constant gp");
2366 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2367 strcat (buf
, ", absolute");
2371 if ((e_flags
& EF_VAX_NONPIC
))
2372 strcat (buf
, ", non-PIC");
2373 if ((e_flags
& EF_VAX_DFLOAT
))
2374 strcat (buf
, ", D-Float");
2375 if ((e_flags
& EF_VAX_GFLOAT
))
2376 strcat (buf
, ", G-Float");
2385 get_osabi_name (unsigned int osabi
)
2387 static char buff
[32];
2391 case ELFOSABI_NONE
: return "UNIX - System V";
2392 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2393 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2394 case ELFOSABI_LINUX
: return "UNIX - Linux";
2395 case ELFOSABI_HURD
: return "GNU/Hurd";
2396 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2397 case ELFOSABI_AIX
: return "UNIX - AIX";
2398 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2399 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2400 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2401 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2402 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2403 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2404 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2405 case ELFOSABI_AROS
: return "AROS";
2406 case ELFOSABI_STANDALONE
: return _("Standalone App");
2407 case ELFOSABI_ARM
: return "ARM";
2409 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2415 get_arm_segment_type (unsigned long type
)
2429 get_mips_segment_type (unsigned long type
)
2433 case PT_MIPS_REGINFO
:
2435 case PT_MIPS_RTPROC
:
2437 case PT_MIPS_OPTIONS
:
2447 get_parisc_segment_type (unsigned long type
)
2451 case PT_HP_TLS
: return "HP_TLS";
2452 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2453 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2454 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2455 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2456 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2457 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2458 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2459 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2460 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2461 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2462 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2463 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2464 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2465 case PT_HP_STACK
: return "HP_STACK";
2466 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2467 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2468 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2469 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2478 get_ia64_segment_type (unsigned long type
)
2482 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2483 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2484 case PT_HP_TLS
: return "HP_TLS";
2485 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2486 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2487 case PT_IA_64_HP_STACK
: return "HP_STACK";
2496 get_segment_type (unsigned long p_type
)
2498 static char buff
[32];
2502 case PT_NULL
: return "NULL";
2503 case PT_LOAD
: return "LOAD";
2504 case PT_DYNAMIC
: return "DYNAMIC";
2505 case PT_INTERP
: return "INTERP";
2506 case PT_NOTE
: return "NOTE";
2507 case PT_SHLIB
: return "SHLIB";
2508 case PT_PHDR
: return "PHDR";
2509 case PT_TLS
: return "TLS";
2511 case PT_GNU_EH_FRAME
:
2512 return "GNU_EH_FRAME";
2513 case PT_GNU_STACK
: return "GNU_STACK";
2514 case PT_GNU_RELRO
: return "GNU_RELRO";
2517 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2521 switch (elf_header
.e_machine
)
2524 result
= get_arm_segment_type (p_type
);
2527 case EM_MIPS_RS3_LE
:
2528 result
= get_mips_segment_type (p_type
);
2531 result
= get_parisc_segment_type (p_type
);
2534 result
= get_ia64_segment_type (p_type
);
2544 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2546 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2550 switch (elf_header
.e_machine
)
2553 result
= get_parisc_segment_type (p_type
);
2556 result
= get_ia64_segment_type (p_type
);
2566 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2569 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2576 get_mips_section_type_name (unsigned int sh_type
)
2580 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2581 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2582 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2583 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2584 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2585 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2586 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2587 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2588 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2589 case SHT_MIPS_RELD
: return "MIPS_RELD";
2590 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2591 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2592 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2593 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2594 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2595 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2596 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2597 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2598 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2599 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2600 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2601 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2602 case SHT_MIPS_LINE
: return "MIPS_LINE";
2603 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2604 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2605 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2606 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2607 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2608 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2609 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2610 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2611 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2612 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2613 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2614 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2615 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2616 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2617 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2618 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2626 get_parisc_section_type_name (unsigned int sh_type
)
2630 case SHT_PARISC_EXT
: return "PARISC_EXT";
2631 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2632 case SHT_PARISC_DOC
: return "PARISC_DOC";
2633 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2634 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2635 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2636 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2644 get_ia64_section_type_name (unsigned int sh_type
)
2646 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2647 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2648 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2652 case SHT_IA_64_EXT
: return "IA_64_EXT";
2653 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2654 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2655 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
2656 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
2657 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
2658 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
2659 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
2660 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
2661 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
2669 get_x86_64_section_type_name (unsigned int sh_type
)
2673 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2681 get_arm_section_type_name (unsigned int sh_type
)
2687 case SHT_ARM_PREEMPTMAP
:
2688 return "ARM_PREEMPTMAP";
2689 case SHT_ARM_ATTRIBUTES
:
2690 return "ARM_ATTRIBUTES";
2698 get_section_type_name (unsigned int sh_type
)
2700 static char buff
[32];
2704 case SHT_NULL
: return "NULL";
2705 case SHT_PROGBITS
: return "PROGBITS";
2706 case SHT_SYMTAB
: return "SYMTAB";
2707 case SHT_STRTAB
: return "STRTAB";
2708 case SHT_RELA
: return "RELA";
2709 case SHT_HASH
: return "HASH";
2710 case SHT_DYNAMIC
: return "DYNAMIC";
2711 case SHT_NOTE
: return "NOTE";
2712 case SHT_NOBITS
: return "NOBITS";
2713 case SHT_REL
: return "REL";
2714 case SHT_SHLIB
: return "SHLIB";
2715 case SHT_DYNSYM
: return "DYNSYM";
2716 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2717 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2718 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2719 case SHT_GNU_HASH
: return "GNU_HASH";
2720 case SHT_GROUP
: return "GROUP";
2721 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2722 case SHT_GNU_verdef
: return "VERDEF";
2723 case SHT_GNU_verneed
: return "VERNEED";
2724 case SHT_GNU_versym
: return "VERSYM";
2725 case 0x6ffffff0: return "VERSYM";
2726 case 0x6ffffffc: return "VERDEF";
2727 case 0x7ffffffd: return "AUXILIARY";
2728 case 0x7fffffff: return "FILTER";
2729 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2732 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2736 switch (elf_header
.e_machine
)
2739 case EM_MIPS_RS3_LE
:
2740 result
= get_mips_section_type_name (sh_type
);
2743 result
= get_parisc_section_type_name (sh_type
);
2746 result
= get_ia64_section_type_name (sh_type
);
2749 result
= get_x86_64_section_type_name (sh_type
);
2752 result
= get_arm_section_type_name (sh_type
);
2762 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2764 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2768 switch (elf_header
.e_machine
)
2771 result
= get_ia64_section_type_name (sh_type
);
2781 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2783 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2784 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2786 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2792 #define OPTION_DEBUG_DUMP 512
2794 static struct option options
[] =
2796 {"all", no_argument
, 0, 'a'},
2797 {"file-header", no_argument
, 0, 'h'},
2798 {"program-headers", no_argument
, 0, 'l'},
2799 {"headers", no_argument
, 0, 'e'},
2800 {"histogram", no_argument
, 0, 'I'},
2801 {"segments", no_argument
, 0, 'l'},
2802 {"sections", no_argument
, 0, 'S'},
2803 {"section-headers", no_argument
, 0, 'S'},
2804 {"section-groups", no_argument
, 0, 'g'},
2805 {"section-details", no_argument
, 0, 't'},
2806 {"full-section-name",no_argument
, 0, 'N'},
2807 {"symbols", no_argument
, 0, 's'},
2808 {"syms", no_argument
, 0, 's'},
2809 {"relocs", no_argument
, 0, 'r'},
2810 {"notes", no_argument
, 0, 'n'},
2811 {"dynamic", no_argument
, 0, 'd'},
2812 {"arch-specific", no_argument
, 0, 'A'},
2813 {"version-info", no_argument
, 0, 'V'},
2814 {"use-dynamic", no_argument
, 0, 'D'},
2815 {"unwind", no_argument
, 0, 'u'},
2816 {"archive-index", no_argument
, 0, 'c'},
2817 {"hex-dump", required_argument
, 0, 'x'},
2818 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2819 {"string-dump", required_argument
, 0, 'p'},
2820 #ifdef SUPPORT_DISASSEMBLY
2821 {"instruction-dump", required_argument
, 0, 'i'},
2824 {"version", no_argument
, 0, 'v'},
2825 {"wide", no_argument
, 0, 'W'},
2826 {"help", no_argument
, 0, 'H'},
2827 {0, no_argument
, 0, 0}
2831 usage (FILE *stream
)
2833 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2834 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
2835 fprintf (stream
, _(" Options are:\n\
2836 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2837 -h --file-header Display the ELF file header\n\
2838 -l --program-headers Display the program headers\n\
2839 --segments An alias for --program-headers\n\
2840 -S --section-headers Display the sections' header\n\
2841 --sections An alias for --section-headers\n\
2842 -g --section-groups Display the section groups\n\
2843 -t --section-details Display the section details\n\
2844 -e --headers Equivalent to: -h -l -S\n\
2845 -s --syms Display the symbol table\n\
2846 --symbols An alias for --syms\n\
2847 -n --notes Display the core notes (if present)\n\
2848 -r --relocs Display the relocations (if present)\n\
2849 -u --unwind Display the unwind info (if present)\n\
2850 -d --dynamic Display the dynamic section (if present)\n\
2851 -V --version-info Display the version sections (if present)\n\
2852 -A --arch-specific Display architecture specific information (if any).\n\
2853 -c --archive-index Display the symbol/file index in an archive\n\
2854 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2855 -x --hex-dump=<number|name>\n\
2856 Dump the contents of section <number|name> as bytes\n\
2857 -p --string-dump=<number|name>\n\
2858 Dump the contents of section <number|name> as strings\n\
2859 -w[lLiaprmfFsoR] or\n\
2860 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2861 Display the contents of DWARF2 debug sections\n"));
2862 #ifdef SUPPORT_DISASSEMBLY
2863 fprintf (stream
, _("\
2864 -i --instruction-dump=<number|name>\n\
2865 Disassemble the contents of section <number|name>\n"));
2867 fprintf (stream
, _("\
2868 -I --histogram Display histogram of bucket list lengths\n\
2869 -W --wide Allow output width to exceed 80 characters\n\
2870 @<file> Read options from <file>\n\
2871 -H --help Display this information\n\
2872 -v --version Display the version number of readelf\n"));
2874 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
2875 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2877 exit (stream
== stdout
? 0 : 1);
2880 /* Record the fact that the user wants the contents of section number
2881 SECTION to be displayed using the method(s) encoded as flags bits
2882 in TYPE. Note, TYPE can be zero if we are creating the array for
2886 request_dump_bynumber (unsigned int section
, dump_type type
)
2888 if (section
>= num_dump_sects
)
2890 dump_type
*new_dump_sects
;
2892 new_dump_sects
= calloc (section
+ 1, sizeof (* dump_sects
));
2894 if (new_dump_sects
== NULL
)
2895 error (_("Out of memory allocating dump request table.\n"));
2898 /* Copy current flag settings. */
2899 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
2903 dump_sects
= new_dump_sects
;
2904 num_dump_sects
= section
+ 1;
2909 dump_sects
[section
] |= type
;
2914 /* Request a dump by section name. */
2917 request_dump_byname (const char *section
, dump_type type
)
2919 struct dump_list_entry
*new_request
;
2921 new_request
= malloc (sizeof (struct dump_list_entry
));
2923 error (_("Out of memory allocating dump request table.\n"));
2925 new_request
->name
= strdup (section
);
2926 if (!new_request
->name
)
2927 error (_("Out of memory allocating dump request table.\n"));
2929 new_request
->type
= type
;
2931 new_request
->next
= dump_sects_byname
;
2932 dump_sects_byname
= new_request
;
2936 parse_args (int argc
, char **argv
)
2943 while ((c
= getopt_long
2944 (argc
, argv
, "ADHINSVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
2965 do_section_groups
++;
2973 do_section_groups
++;
2978 do_section_details
++;
3023 section
= strtoul (optarg
, & cp
, 0);
3024 if (! *cp
&& section
>= 0)
3025 request_dump_bynumber (section
, HEX_DUMP
);
3027 request_dump_byname (optarg
, HEX_DUMP
);
3031 section
= strtoul (optarg
, & cp
, 0);
3032 if (! *cp
&& section
>= 0)
3033 request_dump_bynumber (section
, STRING_DUMP
);
3035 request_dump_byname (optarg
, STRING_DUMP
);
3043 unsigned int index
= 0;
3047 while (optarg
[index
])
3048 switch (optarg
[index
++])
3055 do_debug_abbrevs
= 1;
3063 do_debug_lines_decoded
= 1;
3067 do_debug_pubnames
= 1;
3071 do_debug_aranges
= 1;
3075 do_debug_ranges
= 1;
3079 do_debug_frames_interp
= 1;
3081 do_debug_frames
= 1;
3085 do_debug_macinfo
= 1;
3097 warn (_("Unrecognized debug option '%s'\n"), optarg
);
3102 case OPTION_DEBUG_DUMP
:
3110 const char * option
;
3113 debug_dump_long_opts
;
3115 debug_dump_long_opts opts_table
[] =
3117 /* Please keep this table alpha- sorted. */
3118 { "Ranges", & do_debug_ranges
},
3119 { "abbrev", & do_debug_abbrevs
},
3120 { "aranges", & do_debug_aranges
},
3121 { "frames", & do_debug_frames
},
3122 { "frames-interp", & do_debug_frames_interp
},
3123 { "info", & do_debug_info
},
3124 { "line", & do_debug_lines
}, /* For backwards compatibility. */
3125 { "rawline", & do_debug_lines
},
3126 { "decodedline", & do_debug_lines_decoded
},
3127 { "loc", & do_debug_loc
},
3128 { "macro", & do_debug_macinfo
},
3129 { "pubnames", & do_debug_pubnames
},
3130 /* This entry is for compatability
3131 with earlier versions of readelf. */
3132 { "ranges", & do_debug_aranges
},
3133 { "str", & do_debug_str
},
3144 debug_dump_long_opts
* entry
;
3146 for (entry
= opts_table
; entry
->option
; entry
++)
3148 size_t len
= strlen (entry
->option
);
3150 if (strneq (p
, entry
->option
, len
)
3151 && (p
[len
] == ',' || p
[len
] == '\0'))
3153 * entry
->variable
= 1;
3155 /* The --debug-dump=frames-interp option also
3156 enables the --debug-dump=frames option. */
3157 if (do_debug_frames_interp
)
3158 do_debug_frames
= 1;
3165 if (entry
->option
== NULL
)
3167 warn (_("Unrecognized debug option '%s'\n"), p
);
3168 p
= strchr (p
, ',');
3178 #ifdef SUPPORT_DISASSEMBLY
3181 section
= strtoul (optarg
, & cp
, 0);
3182 if (! *cp
&& section
>= 0)
3183 request_dump_bynumber (section
, DISASS_DUMP
);
3185 request_dump_byname (optarg
, DISASS_DUMP
);
3188 print_version (program_name
);
3197 /* xgettext:c-format */
3198 error (_("Invalid option '-%c'\n"), c
);
3205 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3206 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3207 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3208 && !do_section_groups
&& !do_archive_index
)
3212 warn (_("Nothing to do.\n"));
3218 get_elf_class (unsigned int elf_class
)
3220 static char buff
[32];
3224 case ELFCLASSNONE
: return _("none");
3225 case ELFCLASS32
: return "ELF32";
3226 case ELFCLASS64
: return "ELF64";
3228 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3234 get_data_encoding (unsigned int encoding
)
3236 static char buff
[32];
3240 case ELFDATANONE
: return _("none");
3241 case ELFDATA2LSB
: return _("2's complement, little endian");
3242 case ELFDATA2MSB
: return _("2's complement, big endian");
3244 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3249 /* Decode the data held in 'elf_header'. */
3252 process_file_header (void)
3254 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3255 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3256 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3257 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3260 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3264 init_dwarf_regnames (elf_header
.e_machine
);
3270 printf (_("ELF Header:\n"));
3271 printf (_(" Magic: "));
3272 for (i
= 0; i
< EI_NIDENT
; i
++)
3273 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3275 printf (_(" Class: %s\n"),
3276 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3277 printf (_(" Data: %s\n"),
3278 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3279 printf (_(" Version: %d %s\n"),
3280 elf_header
.e_ident
[EI_VERSION
],
3281 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3283 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3286 printf (_(" OS/ABI: %s\n"),
3287 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3288 printf (_(" ABI Version: %d\n"),
3289 elf_header
.e_ident
[EI_ABIVERSION
]);
3290 printf (_(" Type: %s\n"),
3291 get_file_type (elf_header
.e_type
));
3292 printf (_(" Machine: %s\n"),
3293 get_machine_name (elf_header
.e_machine
));
3294 printf (_(" Version: 0x%lx\n"),
3295 (unsigned long) elf_header
.e_version
);
3297 printf (_(" Entry point address: "));
3298 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3299 printf (_("\n Start of program headers: "));
3300 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3301 printf (_(" (bytes into file)\n Start of section headers: "));
3302 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3303 printf (_(" (bytes into file)\n"));
3305 printf (_(" Flags: 0x%lx%s\n"),
3306 (unsigned long) elf_header
.e_flags
,
3307 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3308 printf (_(" Size of this header: %ld (bytes)\n"),
3309 (long) elf_header
.e_ehsize
);
3310 printf (_(" Size of program headers: %ld (bytes)\n"),
3311 (long) elf_header
.e_phentsize
);
3312 printf (_(" Number of program headers: %ld\n"),
3313 (long) elf_header
.e_phnum
);
3314 printf (_(" Size of section headers: %ld (bytes)\n"),
3315 (long) elf_header
.e_shentsize
);
3316 printf (_(" Number of section headers: %ld"),
3317 (long) elf_header
.e_shnum
);
3318 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
3319 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3320 putc ('\n', stdout
);
3321 printf (_(" Section header string table index: %ld"),
3322 (long) elf_header
.e_shstrndx
);
3323 if (section_headers
!= NULL
3324 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3325 printf (" (%u)", section_headers
[0].sh_link
);
3326 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3327 printf (" <corrupt: out of range>");
3328 putc ('\n', stdout
);
3331 if (section_headers
!= NULL
)
3333 if (elf_header
.e_shnum
== SHN_UNDEF
)
3334 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3335 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3336 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3337 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3338 elf_header
.e_shstrndx
= SHN_UNDEF
;
3339 free (section_headers
);
3340 section_headers
= NULL
;
3348 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3350 Elf32_External_Phdr
*phdrs
;
3351 Elf32_External_Phdr
*external
;
3352 Elf_Internal_Phdr
*internal
;
3355 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3356 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3357 _("program headers"));
3361 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3362 i
< elf_header
.e_phnum
;
3363 i
++, internal
++, external
++)
3365 internal
->p_type
= BYTE_GET (external
->p_type
);
3366 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3367 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3368 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3369 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3370 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3371 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3372 internal
->p_align
= BYTE_GET (external
->p_align
);
3381 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3383 Elf64_External_Phdr
*phdrs
;
3384 Elf64_External_Phdr
*external
;
3385 Elf_Internal_Phdr
*internal
;
3388 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3389 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3390 _("program headers"));
3394 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3395 i
< elf_header
.e_phnum
;
3396 i
++, internal
++, external
++)
3398 internal
->p_type
= BYTE_GET (external
->p_type
);
3399 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3400 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3401 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3402 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3403 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3404 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3405 internal
->p_align
= BYTE_GET (external
->p_align
);
3413 /* Returns 1 if the program headers were read into `program_headers'. */
3416 get_program_headers (FILE *file
)
3418 Elf_Internal_Phdr
*phdrs
;
3420 /* Check cache of prior read. */
3421 if (program_headers
!= NULL
)
3424 phdrs
= cmalloc (elf_header
.e_phnum
, sizeof (Elf_Internal_Phdr
));
3428 error (_("Out of memory\n"));
3433 ? get_32bit_program_headers (file
, phdrs
)
3434 : get_64bit_program_headers (file
, phdrs
))
3436 program_headers
= phdrs
;
3444 /* Returns 1 if the program headers were loaded. */
3447 process_program_headers (FILE *file
)
3449 Elf_Internal_Phdr
*segment
;
3452 if (elf_header
.e_phnum
== 0)
3455 printf (_("\nThere are no program headers in this file.\n"));
3459 if (do_segments
&& !do_header
)
3461 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3462 printf (_("Entry point "));
3463 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3464 printf (_("\nThere are %d program headers, starting at offset "),
3465 elf_header
.e_phnum
);
3466 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3470 if (! get_program_headers (file
))
3475 if (elf_header
.e_phnum
> 1)
3476 printf (_("\nProgram Headers:\n"));
3478 printf (_("\nProgram Headers:\n"));
3482 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3485 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3489 (_(" Type Offset VirtAddr PhysAddr\n"));
3491 (_(" FileSiz MemSiz Flags Align\n"));
3498 for (i
= 0, segment
= program_headers
;
3499 i
< elf_header
.e_phnum
;
3504 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3508 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3509 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3510 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3511 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3512 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3514 (segment
->p_flags
& PF_R
? 'R' : ' '),
3515 (segment
->p_flags
& PF_W
? 'W' : ' '),
3516 (segment
->p_flags
& PF_X
? 'E' : ' '));
3517 printf ("%#lx", (unsigned long) segment
->p_align
);
3521 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3522 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3525 print_vma (segment
->p_offset
, FULL_HEX
);
3529 print_vma (segment
->p_vaddr
, FULL_HEX
);
3531 print_vma (segment
->p_paddr
, FULL_HEX
);
3534 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3535 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3538 print_vma (segment
->p_filesz
, FULL_HEX
);
3542 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3543 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3546 print_vma (segment
->p_offset
, FULL_HEX
);
3550 (segment
->p_flags
& PF_R
? 'R' : ' '),
3551 (segment
->p_flags
& PF_W
? 'W' : ' '),
3552 (segment
->p_flags
& PF_X
? 'E' : ' '));
3554 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3555 printf ("%#lx", (unsigned long) segment
->p_align
);
3558 print_vma (segment
->p_align
, PREFIX_HEX
);
3563 print_vma (segment
->p_offset
, FULL_HEX
);
3565 print_vma (segment
->p_vaddr
, FULL_HEX
);
3567 print_vma (segment
->p_paddr
, FULL_HEX
);
3569 print_vma (segment
->p_filesz
, FULL_HEX
);
3571 print_vma (segment
->p_memsz
, FULL_HEX
);
3573 (segment
->p_flags
& PF_R
? 'R' : ' '),
3574 (segment
->p_flags
& PF_W
? 'W' : ' '),
3575 (segment
->p_flags
& PF_X
? 'E' : ' '));
3576 print_vma (segment
->p_align
, HEX
);
3580 switch (segment
->p_type
)
3584 error (_("more than one dynamic segment\n"));
3586 /* By default, assume that the .dynamic section is the first
3587 section in the DYNAMIC segment. */
3588 dynamic_addr
= segment
->p_offset
;
3589 dynamic_size
= segment
->p_filesz
;
3591 /* Try to locate the .dynamic section. If there is
3592 a section header table, we can easily locate it. */
3593 if (section_headers
!= NULL
)
3595 Elf_Internal_Shdr
*sec
;
3597 sec
= find_section (".dynamic");
3598 if (sec
== NULL
|| sec
->sh_size
== 0)
3600 error (_("no .dynamic section in the dynamic segment\n"));
3604 if (sec
->sh_type
== SHT_NOBITS
)
3610 dynamic_addr
= sec
->sh_offset
;
3611 dynamic_size
= sec
->sh_size
;
3613 if (dynamic_addr
< segment
->p_offset
3614 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3615 warn (_("the .dynamic section is not contained"
3616 " within the dynamic segment\n"));
3617 else if (dynamic_addr
> segment
->p_offset
)
3618 warn (_("the .dynamic section is not the first section"
3619 " in the dynamic segment.\n"));
3624 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3626 error (_("Unable to find program interpreter name\n"));
3630 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
3632 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
3633 error (_("Internal error: failed to create format string to display program interpreter\n"));
3635 program_interpreter
[0] = 0;
3636 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
3637 error (_("Unable to read program interpreter name\n"));
3640 printf (_("\n [Requesting program interpreter: %s]"),
3641 program_interpreter
);
3647 putc ('\n', stdout
);
3650 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3652 printf (_("\n Section to Segment mapping:\n"));
3653 printf (_(" Segment Sections...\n"));
3655 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3658 Elf_Internal_Shdr
*section
;
3660 segment
= program_headers
+ i
;
3661 section
= section_headers
+ 1;
3663 printf (" %2.2d ", i
);
3665 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3667 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY(section
, segment
))
3668 printf ("%s ", SECTION_NAME (section
));
3679 /* Find the file offset corresponding to VMA by using the program headers. */
3682 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3684 Elf_Internal_Phdr
*seg
;
3686 if (! get_program_headers (file
))
3688 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3692 for (seg
= program_headers
;
3693 seg
< program_headers
+ elf_header
.e_phnum
;
3696 if (seg
->p_type
!= PT_LOAD
)
3699 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3700 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3701 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3704 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3705 (unsigned long) vma
);
3711 get_32bit_section_headers (FILE *file
, unsigned int num
)
3713 Elf32_External_Shdr
*shdrs
;
3714 Elf_Internal_Shdr
*internal
;
3717 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3718 elf_header
.e_shentsize
, num
, _("section headers"));
3722 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3724 if (section_headers
== NULL
)
3726 error (_("Out of memory\n"));
3730 for (i
= 0, internal
= section_headers
;
3734 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3735 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3736 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3737 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3738 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3739 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3740 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3741 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3742 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3743 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3752 get_64bit_section_headers (FILE *file
, unsigned int num
)
3754 Elf64_External_Shdr
*shdrs
;
3755 Elf_Internal_Shdr
*internal
;
3758 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3759 elf_header
.e_shentsize
, num
, _("section headers"));
3763 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3765 if (section_headers
== NULL
)
3767 error (_("Out of memory\n"));
3771 for (i
= 0, internal
= section_headers
;
3775 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3776 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3777 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3778 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3779 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3780 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3781 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3782 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3783 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3784 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3792 static Elf_Internal_Sym
*
3793 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3795 unsigned long number
;
3796 Elf32_External_Sym
*esyms
;
3797 Elf_External_Sym_Shndx
*shndx
;
3798 Elf_Internal_Sym
*isyms
;
3799 Elf_Internal_Sym
*psym
;
3802 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3808 if (symtab_shndx_hdr
!= NULL
3809 && (symtab_shndx_hdr
->sh_link
3810 == (unsigned long) (section
- section_headers
)))
3812 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3813 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3821 number
= section
->sh_size
/ section
->sh_entsize
;
3822 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3826 error (_("Out of memory\n"));
3833 for (j
= 0, psym
= isyms
;
3837 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3838 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3839 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3840 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3841 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3843 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3844 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3845 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3846 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3847 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3857 static Elf_Internal_Sym
*
3858 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3860 unsigned long number
;
3861 Elf64_External_Sym
*esyms
;
3862 Elf_External_Sym_Shndx
*shndx
;
3863 Elf_Internal_Sym
*isyms
;
3864 Elf_Internal_Sym
*psym
;
3867 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3873 if (symtab_shndx_hdr
!= NULL
3874 && (symtab_shndx_hdr
->sh_link
3875 == (unsigned long) (section
- section_headers
)))
3877 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3878 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3886 number
= section
->sh_size
/ section
->sh_entsize
;
3887 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3891 error (_("Out of memory\n"));
3898 for (j
= 0, psym
= isyms
;
3902 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3903 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3904 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3905 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3906 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3908 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3909 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3910 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3911 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3912 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3923 get_elf_section_flags (bfd_vma sh_flags
)
3925 static char buff
[1024];
3927 int field_size
= is_32bit_elf
? 8 : 16;
3928 int index
, size
= sizeof (buff
) - (field_size
+ 4 + 1);
3929 bfd_vma os_flags
= 0;
3930 bfd_vma proc_flags
= 0;
3931 bfd_vma unknown_flags
= 0;
3945 { "LINK ORDER", 10 },
3946 { "OS NONCONF", 10 },
3949 /* IA-64 specific. */
3952 /* IA-64 OpenVMS specific. */
3953 { "VMS_GLOBAL", 10 },
3954 { "VMS_OVERLAID", 12 },
3955 { "VMS_SHARED", 10 },
3956 { "VMS_VECTOR", 10 },
3957 { "VMS_ALLOC_64BIT", 15 },
3958 { "VMS_PROTECTED", 13}
3961 if (do_section_details
)
3963 sprintf (buff
, "[%*.*lx]: ",
3964 field_size
, field_size
, (unsigned long) sh_flags
);
3965 p
+= field_size
+ 4;
3972 flag
= sh_flags
& - sh_flags
;
3975 if (do_section_details
)
3979 case SHF_WRITE
: index
= 0; break;
3980 case SHF_ALLOC
: index
= 1; break;
3981 case SHF_EXECINSTR
: index
= 2; break;
3982 case SHF_MERGE
: index
= 3; break;
3983 case SHF_STRINGS
: index
= 4; break;
3984 case SHF_INFO_LINK
: index
= 5; break;
3985 case SHF_LINK_ORDER
: index
= 6; break;
3986 case SHF_OS_NONCONFORMING
: index
= 7; break;
3987 case SHF_GROUP
: index
= 8; break;
3988 case SHF_TLS
: index
= 9; break;
3992 if (elf_header
.e_machine
== EM_IA_64
)
3994 if (flag
== SHF_IA_64_SHORT
)
3996 else if (flag
== SHF_IA_64_NORECOV
)
3999 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
4002 case SHF_IA_64_VMS_GLOBAL
: index
= 12; break;
4003 case SHF_IA_64_VMS_OVERLAID
: index
= 13; break;
4004 case SHF_IA_64_VMS_SHARED
: index
= 14; break;
4005 case SHF_IA_64_VMS_VECTOR
: index
= 15; break;
4006 case SHF_IA_64_VMS_ALLOC_64BIT
: index
= 16; break;
4007 case SHF_IA_64_VMS_PROTECTED
: index
= 17; break;
4017 if (p
!= buff
+ field_size
+ 4)
4019 if (size
< (10 + 2))
4026 size
-= flags
[index
].len
;
4027 p
= stpcpy (p
, flags
[index
].str
);
4029 else if (flag
& SHF_MASKOS
)
4031 else if (flag
& SHF_MASKPROC
)
4034 unknown_flags
|= flag
;
4040 case SHF_WRITE
: *p
= 'W'; break;
4041 case SHF_ALLOC
: *p
= 'A'; break;
4042 case SHF_EXECINSTR
: *p
= 'X'; break;
4043 case SHF_MERGE
: *p
= 'M'; break;
4044 case SHF_STRINGS
: *p
= 'S'; break;
4045 case SHF_INFO_LINK
: *p
= 'I'; break;
4046 case SHF_LINK_ORDER
: *p
= 'L'; break;
4047 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
4048 case SHF_GROUP
: *p
= 'G'; break;
4049 case SHF_TLS
: *p
= 'T'; break;
4052 if (elf_header
.e_machine
== EM_X86_64
4053 && flag
== SHF_X86_64_LARGE
)
4055 else if (flag
& SHF_MASKOS
)
4058 sh_flags
&= ~ SHF_MASKOS
;
4060 else if (flag
& SHF_MASKPROC
)
4063 sh_flags
&= ~ SHF_MASKPROC
;
4073 if (do_section_details
)
4077 size
-= 5 + field_size
;
4078 if (p
!= buff
+ field_size
+ 4)
4086 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4087 (unsigned long) os_flags
);
4088 p
+= 5 + field_size
;
4092 size
-= 7 + field_size
;
4093 if (p
!= buff
+ field_size
+ 4)
4101 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4102 (unsigned long) proc_flags
);
4103 p
+= 7 + field_size
;
4107 size
-= 10 + field_size
;
4108 if (p
!= buff
+ field_size
+ 4)
4116 sprintf (p
, "UNKNOWN (%*.*lx)", field_size
, field_size
,
4117 (unsigned long) unknown_flags
);
4118 p
+= 10 + field_size
;
4127 process_section_headers (FILE *file
)
4129 Elf_Internal_Shdr
*section
;
4132 section_headers
= NULL
;
4134 if (elf_header
.e_shnum
== 0)
4137 printf (_("\nThere are no sections in this file.\n"));
4142 if (do_sections
&& !do_header
)
4143 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4144 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4148 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4151 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4154 /* Read in the string table, so that we have names to display. */
4155 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4156 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4158 section
= section_headers
+ elf_header
.e_shstrndx
;
4160 if (section
->sh_size
!= 0)
4162 string_table
= get_data (NULL
, file
, section
->sh_offset
,
4163 1, section
->sh_size
, _("string table"));
4165 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4169 /* Scan the sections for the dynamic symbol table
4170 and dynamic string table and debug sections. */
4171 dynamic_symbols
= NULL
;
4172 dynamic_strings
= NULL
;
4173 dynamic_syminfo
= NULL
;
4174 symtab_shndx_hdr
= NULL
;
4176 eh_addr_size
= is_32bit_elf
? 4 : 8;
4177 switch (elf_header
.e_machine
)
4180 case EM_MIPS_RS3_LE
:
4181 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4182 FDE addresses. However, the ABI also has a semi-official ILP32
4183 variant for which the normal FDE address size rules apply.
4185 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4186 section, where XX is the size of longs in bits. Unfortunately,
4187 earlier compilers provided no way of distinguishing ILP32 objects
4188 from LP64 objects, so if there's any doubt, we should assume that
4189 the official LP64 form is being used. */
4190 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4191 && find_section (".gcc_compiled_long32") == NULL
)
4197 switch (elf_header
.e_flags
& EF_H8_MACH
)
4199 case E_H8_MACH_H8300
:
4200 case E_H8_MACH_H8300HN
:
4201 case E_H8_MACH_H8300SN
:
4202 case E_H8_MACH_H8300SXN
:
4205 case E_H8_MACH_H8300H
:
4206 case E_H8_MACH_H8300S
:
4207 case E_H8_MACH_H8300SX
:
4215 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
4217 case EF_M32C_CPU_M16C
:
4224 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4227 size_t expected_entsize \
4228 = is_32bit_elf ? size32 : size64; \
4229 if (section->sh_entsize != expected_entsize) \
4230 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4231 i, (unsigned long int) section->sh_entsize, \
4232 (unsigned long int) expected_entsize); \
4233 section->sh_entsize = expected_entsize; \
4236 #define CHECK_ENTSIZE(section, i, type) \
4237 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4238 sizeof (Elf64_External_##type))
4240 for (i
= 0, section
= section_headers
;
4241 i
< elf_header
.e_shnum
;
4244 char *name
= SECTION_NAME (section
);
4246 if (section
->sh_type
== SHT_DYNSYM
)
4248 if (dynamic_symbols
!= NULL
)
4250 error (_("File contains multiple dynamic symbol tables\n"));
4254 CHECK_ENTSIZE (section
, i
, Sym
);
4255 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4256 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4258 else if (section
->sh_type
== SHT_STRTAB
4259 && streq (name
, ".dynstr"))
4261 if (dynamic_strings
!= NULL
)
4263 error (_("File contains multiple dynamic string tables\n"));
4267 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
4268 1, section
->sh_size
, _("dynamic strings"));
4269 dynamic_strings_length
= section
->sh_size
;
4271 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4273 if (symtab_shndx_hdr
!= NULL
)
4275 error (_("File contains multiple symtab shndx tables\n"));
4278 symtab_shndx_hdr
= section
;
4280 else if (section
->sh_type
== SHT_SYMTAB
)
4281 CHECK_ENTSIZE (section
, i
, Sym
);
4282 else if (section
->sh_type
== SHT_GROUP
)
4283 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4284 else if (section
->sh_type
== SHT_REL
)
4285 CHECK_ENTSIZE (section
, i
, Rel
);
4286 else if (section
->sh_type
== SHT_RELA
)
4287 CHECK_ENTSIZE (section
, i
, Rela
);
4288 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4289 || do_debug_lines
|| do_debug_lines_decoded
|| do_debug_pubnames
4290 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
4291 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
)
4292 && (const_strneq (name
, ".debug_")
4293 || const_strneq (name
, ".zdebug_")))
4296 name
+= sizeof (".zdebug_") - 1;
4298 name
+= sizeof (".debug_") - 1;
4301 || (do_debug_info
&& streq (name
, "info"))
4302 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4303 || ((do_debug_lines
|| do_debug_lines_decoded
)
4304 && streq (name
, "line"))
4305 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4306 || (do_debug_aranges
&& streq (name
, "aranges"))
4307 || (do_debug_ranges
&& streq (name
, "ranges"))
4308 || (do_debug_frames
&& streq (name
, "frame"))
4309 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4310 || (do_debug_str
&& streq (name
, "str"))
4311 || (do_debug_loc
&& streq (name
, "loc"))
4313 request_dump_bynumber (i
, DEBUG_DUMP
);
4315 /* Linkonce section to be combined with .debug_info at link time. */
4316 else if ((do_debugging
|| do_debug_info
)
4317 && const_strneq (name
, ".gnu.linkonce.wi."))
4318 request_dump_bynumber (i
, DEBUG_DUMP
);
4319 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4320 request_dump_bynumber (i
, DEBUG_DUMP
);
4326 if (elf_header
.e_shnum
> 1)
4327 printf (_("\nSection Headers:\n"));
4329 printf (_("\nSection Header:\n"));
4333 if (do_section_details
)
4335 printf (_(" [Nr] Name\n"));
4336 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4340 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4344 if (do_section_details
)
4346 printf (_(" [Nr] Name\n"));
4347 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4351 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4355 if (do_section_details
)
4357 printf (_(" [Nr] Name\n"));
4358 printf (_(" Type Address Offset Link\n"));
4359 printf (_(" Size EntSize Info Align\n"));
4363 printf (_(" [Nr] Name Type Address Offset\n"));
4364 printf (_(" Size EntSize Flags Link Info Align\n"));
4368 if (do_section_details
)
4369 printf (_(" Flags\n"));
4371 for (i
= 0, section
= section_headers
;
4372 i
< elf_header
.e_shnum
;
4375 if (do_section_details
)
4377 printf (" [%2u] %s\n",
4379 SECTION_NAME (section
));
4380 if (is_32bit_elf
|| do_wide
)
4381 printf (" %-15.15s ",
4382 get_section_type_name (section
->sh_type
));
4385 printf ((do_wide
? " [%2u] %-17s %-15s "
4386 : " [%2u] %-17.17s %-15.15s "),
4388 SECTION_NAME (section
),
4389 get_section_type_name (section
->sh_type
));
4393 print_vma (section
->sh_addr
, LONG_HEX
);
4395 printf ( " %6.6lx %6.6lx %2.2lx",
4396 (unsigned long) section
->sh_offset
,
4397 (unsigned long) section
->sh_size
,
4398 (unsigned long) section
->sh_entsize
);
4400 if (do_section_details
)
4401 fputs (" ", stdout
);
4403 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4405 printf ("%2u %3u %2lu\n",
4408 (unsigned long) section
->sh_addralign
);
4412 print_vma (section
->sh_addr
, LONG_HEX
);
4414 if ((long) section
->sh_offset
== section
->sh_offset
)
4415 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4419 print_vma (section
->sh_offset
, LONG_HEX
);
4422 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4423 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4427 print_vma (section
->sh_size
, LONG_HEX
);
4430 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4431 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4435 print_vma (section
->sh_entsize
, LONG_HEX
);
4438 if (do_section_details
)
4439 fputs (" ", stdout
);
4441 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4443 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
4445 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4446 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
4449 print_vma (section
->sh_addralign
, DEC
);
4453 else if (do_section_details
)
4455 printf (" %-15.15s ",
4456 get_section_type_name (section
->sh_type
));
4457 print_vma (section
->sh_addr
, LONG_HEX
);
4458 if ((long) section
->sh_offset
== section
->sh_offset
)
4459 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4463 print_vma (section
->sh_offset
, LONG_HEX
);
4465 printf (" %u\n ", section
->sh_link
);
4466 print_vma (section
->sh_size
, LONG_HEX
);
4468 print_vma (section
->sh_entsize
, LONG_HEX
);
4470 printf (" %-16u %lu\n",
4472 (unsigned long) section
->sh_addralign
);
4477 print_vma (section
->sh_addr
, LONG_HEX
);
4478 if ((long) section
->sh_offset
== section
->sh_offset
)
4479 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4483 print_vma (section
->sh_offset
, LONG_HEX
);
4486 print_vma (section
->sh_size
, LONG_HEX
);
4488 print_vma (section
->sh_entsize
, LONG_HEX
);
4490 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4492 printf (" %2u %3u %lu\n",
4495 (unsigned long) section
->sh_addralign
);
4498 if (do_section_details
)
4499 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4502 if (!do_section_details
)
4503 printf (_("Key to Flags:\n\
4504 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4505 I (info), L (link order), G (group), x (unknown)\n\
4506 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4512 get_group_flags (unsigned int flags
)
4514 static char buff
[32];
4521 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4528 process_section_groups (FILE *file
)
4530 Elf_Internal_Shdr
*section
;
4532 struct group
*group
;
4533 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
;
4534 Elf_Internal_Sym
*symtab
;
4538 /* Don't process section groups unless needed. */
4539 if (!do_unwind
&& !do_section_groups
)
4542 if (elf_header
.e_shnum
== 0)
4544 if (do_section_groups
)
4545 printf (_("\nThere are no sections in this file.\n"));
4550 if (section_headers
== NULL
)
4552 error (_("Section headers are not available!\n"));
4556 section_headers_groups
= calloc (elf_header
.e_shnum
,
4557 sizeof (struct group
*));
4559 if (section_headers_groups
== NULL
)
4561 error (_("Out of memory\n"));
4565 /* Scan the sections for the group section. */
4567 for (i
= 0, section
= section_headers
;
4568 i
< elf_header
.e_shnum
;
4570 if (section
->sh_type
== SHT_GROUP
)
4573 if (group_count
== 0)
4575 if (do_section_groups
)
4576 printf (_("\nThere are no section groups in this file.\n"));
4581 section_groups
= calloc (group_count
, sizeof (struct group
));
4583 if (section_groups
== NULL
)
4585 error (_("Out of memory\n"));
4594 for (i
= 0, section
= section_headers
, group
= section_groups
;
4595 i
< elf_header
.e_shnum
;
4598 if (section
->sh_type
== SHT_GROUP
)
4600 char *name
= SECTION_NAME (section
);
4602 unsigned char *start
, *indices
;
4603 unsigned int entry
, j
, size
;
4604 Elf_Internal_Shdr
*sec
;
4605 Elf_Internal_Sym
*sym
;
4607 /* Get the symbol table. */
4608 if (section
->sh_link
>= elf_header
.e_shnum
4609 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
4612 error (_("Bad sh_link in group section `%s'\n"), name
);
4616 if (symtab_sec
!= sec
)
4621 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4624 sym
= symtab
+ section
->sh_info
;
4626 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4628 if (sym
->st_shndx
== 0
4629 || sym
->st_shndx
>= elf_header
.e_shnum
)
4631 error (_("Bad sh_info in group section `%s'\n"), name
);
4635 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
4644 /* Get the string table. */
4645 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
4654 != (sec
= section_headers
+ symtab_sec
->sh_link
))
4659 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4660 1, strtab_sec
->sh_size
,
4662 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4664 group_name
= sym
->st_name
< strtab_size
4665 ? strtab
+ sym
->st_name
: "<corrupt>";
4668 start
= get_data (NULL
, file
, section
->sh_offset
,
4669 1, section
->sh_size
, _("section data"));
4672 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4673 entry
= byte_get (indices
, 4);
4676 if (do_section_groups
)
4678 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4679 get_group_flags (entry
), i
, name
, group_name
, size
);
4681 printf (_(" [Index] Name\n"));
4684 group
->group_index
= i
;
4686 for (j
= 0; j
< size
; j
++)
4688 struct group_list
*g
;
4690 entry
= byte_get (indices
, 4);
4693 if (entry
>= elf_header
.e_shnum
)
4695 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4696 entry
, i
, elf_header
.e_shnum
- 1);
4700 if (section_headers_groups
[entry
] != NULL
)
4704 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4706 section_headers_groups
[entry
]->group_index
);
4711 /* Intel C/C++ compiler may put section 0 in a
4712 section group. We just warn it the first time
4713 and ignore it afterwards. */
4714 static int warned
= 0;
4717 error (_("section 0 in group section [%5u]\n"),
4718 section_headers_groups
[entry
]->group_index
);
4724 section_headers_groups
[entry
] = group
;
4726 if (do_section_groups
)
4728 sec
= section_headers
+ entry
;
4729 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4732 g
= xmalloc (sizeof (struct group_list
));
4733 g
->section_index
= entry
;
4734 g
->next
= group
->root
;
4758 } dynamic_relocations
[] =
4760 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4761 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4762 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4765 /* Process the reloc section. */
4768 process_relocs (FILE *file
)
4770 unsigned long rel_size
;
4771 unsigned long rel_offset
;
4777 if (do_using_dynamic
)
4781 int has_dynamic_reloc
;
4784 has_dynamic_reloc
= 0;
4786 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4788 is_rela
= dynamic_relocations
[i
].rela
;
4789 name
= dynamic_relocations
[i
].name
;
4790 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4791 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4793 has_dynamic_reloc
|= rel_size
;
4795 if (is_rela
== UNKNOWN
)
4797 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4798 switch (dynamic_info
[DT_PLTREL
])
4812 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4813 name
, rel_offset
, rel_size
);
4815 dump_relocations (file
,
4816 offset_from_vma (file
, rel_offset
, rel_size
),
4818 dynamic_symbols
, num_dynamic_syms
,
4819 dynamic_strings
, dynamic_strings_length
, is_rela
);
4823 if (! has_dynamic_reloc
)
4824 printf (_("\nThere are no dynamic relocations in this file.\n"));
4828 Elf_Internal_Shdr
*section
;
4832 for (i
= 0, section
= section_headers
;
4833 i
< elf_header
.e_shnum
;
4836 if ( section
->sh_type
!= SHT_RELA
4837 && section
->sh_type
!= SHT_REL
)
4840 rel_offset
= section
->sh_offset
;
4841 rel_size
= section
->sh_size
;
4845 Elf_Internal_Shdr
*strsec
;
4848 printf (_("\nRelocation section "));
4850 if (string_table
== NULL
)
4851 printf ("%d", section
->sh_name
);
4853 printf (_("'%s'"), SECTION_NAME (section
));
4855 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4856 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4858 is_rela
= section
->sh_type
== SHT_RELA
;
4860 if (section
->sh_link
!= 0
4861 && section
->sh_link
< elf_header
.e_shnum
)
4863 Elf_Internal_Shdr
*symsec
;
4864 Elf_Internal_Sym
*symtab
;
4865 unsigned long nsyms
;
4866 unsigned long strtablen
= 0;
4867 char *strtab
= NULL
;
4869 symsec
= section_headers
+ section
->sh_link
;
4870 if (symsec
->sh_type
!= SHT_SYMTAB
4871 && symsec
->sh_type
!= SHT_DYNSYM
)
4874 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4875 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4880 if (symsec
->sh_link
!= 0
4881 && symsec
->sh_link
< elf_header
.e_shnum
)
4883 strsec
= section_headers
+ symsec
->sh_link
;
4885 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4888 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4891 dump_relocations (file
, rel_offset
, rel_size
,
4892 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4898 dump_relocations (file
, rel_offset
, rel_size
,
4899 NULL
, 0, NULL
, 0, is_rela
);
4906 printf (_("\nThere are no relocations in this file.\n"));
4912 /* Process the unwind section. */
4914 #include "unwind-ia64.h"
4916 /* An absolute address consists of a section and an offset. If the
4917 section is NULL, the offset itself is the address, otherwise, the
4918 address equals to LOAD_ADDRESS(section) + offset. */
4922 unsigned short section
;
4926 #define ABSADDR(a) \
4928 ? section_headers [(a).section].sh_addr + (a).offset \
4931 struct ia64_unw_aux_info
4933 struct ia64_unw_table_entry
4935 struct absaddr start
;
4937 struct absaddr info
;
4939 *table
; /* Unwind table. */
4940 unsigned long table_len
; /* Length of unwind table. */
4941 unsigned char *info
; /* Unwind info. */
4942 unsigned long info_size
; /* Size of unwind info. */
4943 bfd_vma info_addr
; /* starting address of unwind info. */
4944 bfd_vma seg_base
; /* Starting address of segment. */
4945 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4946 unsigned long nsyms
; /* Number of symbols. */
4947 char *strtab
; /* The string table. */
4948 unsigned long strtab_size
; /* Size of string table. */
4952 find_symbol_for_address (Elf_Internal_Sym
*symtab
,
4953 unsigned long nsyms
,
4955 unsigned long strtab_size
,
4956 struct absaddr addr
,
4957 const char **symname
,
4960 bfd_vma dist
= 0x100000;
4961 Elf_Internal_Sym
*sym
, *best
= NULL
;
4964 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4966 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4967 && sym
->st_name
!= 0
4968 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4969 && addr
.offset
>= sym
->st_value
4970 && addr
.offset
- sym
->st_value
< dist
)
4973 dist
= addr
.offset
- sym
->st_value
;
4980 *symname
= (best
->st_name
>= strtab_size
4981 ? "<corrupt>" : strtab
+ best
->st_name
);
4986 *offset
= addr
.offset
;
4990 dump_ia64_unwind (struct ia64_unw_aux_info
*aux
)
4992 struct ia64_unw_table_entry
*tp
;
4995 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4999 const unsigned char *dp
;
5000 const unsigned char *head
;
5001 const char *procname
;
5003 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5004 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
5006 fputs ("\n<", stdout
);
5010 fputs (procname
, stdout
);
5013 printf ("+%lx", (unsigned long) offset
);
5016 fputs (">: [", stdout
);
5017 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5018 fputc ('-', stdout
);
5019 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5020 printf ("], info at +0x%lx\n",
5021 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
5023 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
5024 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
5026 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5027 (unsigned) UNW_VER (stamp
),
5028 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
5029 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
5030 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
5031 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
5033 if (UNW_VER (stamp
) != 1)
5035 printf ("\tUnknown version.\n");
5040 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
5041 dp
= unw_decode (dp
, in_body
, & in_body
);
5046 slurp_ia64_unwind_table (FILE *file
,
5047 struct ia64_unw_aux_info
*aux
,
5048 Elf_Internal_Shdr
*sec
)
5050 unsigned long size
, nrelas
, i
;
5051 Elf_Internal_Phdr
*seg
;
5052 struct ia64_unw_table_entry
*tep
;
5053 Elf_Internal_Shdr
*relsec
;
5054 Elf_Internal_Rela
*rela
, *rp
;
5055 unsigned char *table
, *tp
;
5056 Elf_Internal_Sym
*sym
;
5057 const char *relname
;
5059 /* First, find the starting address of the segment that includes
5062 if (elf_header
.e_phnum
)
5064 if (! get_program_headers (file
))
5067 for (seg
= program_headers
;
5068 seg
< program_headers
+ elf_header
.e_phnum
;
5071 if (seg
->p_type
!= PT_LOAD
)
5074 if (sec
->sh_addr
>= seg
->p_vaddr
5075 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5077 aux
->seg_base
= seg
->p_vaddr
;
5083 /* Second, build the unwind table from the contents of the unwind section: */
5084 size
= sec
->sh_size
;
5085 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5089 aux
->table
= xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
5091 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * eh_addr_size
, ++tep
)
5093 tep
->start
.section
= SHN_UNDEF
;
5094 tep
->end
.section
= SHN_UNDEF
;
5095 tep
->info
.section
= SHN_UNDEF
;
5098 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5099 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5100 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
5104 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
5105 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
5106 tep
->info
.offset
= BYTE_GET ((unsigned char *) tp
+ 16);
5108 tep
->start
.offset
+= aux
->seg_base
;
5109 tep
->end
.offset
+= aux
->seg_base
;
5110 tep
->info
.offset
+= aux
->seg_base
;
5114 /* Third, apply any relocations to the unwind table: */
5115 for (relsec
= section_headers
;
5116 relsec
< section_headers
+ elf_header
.e_shnum
;
5119 if (relsec
->sh_type
!= SHT_RELA
5120 || relsec
->sh_info
>= elf_header
.e_shnum
5121 || section_headers
+ relsec
->sh_info
!= sec
)
5124 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5128 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5130 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5131 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5133 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5135 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5139 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5141 switch (rp
->r_offset
/eh_addr_size
% 3)
5144 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5145 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
5148 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5149 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
5152 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5153 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
5163 aux
->table_len
= size
/ (3 * eh_addr_size
);
5168 ia64_process_unwind (FILE *file
)
5170 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
5171 unsigned long i
, unwcount
= 0, unwstart
= 0;
5172 struct ia64_unw_aux_info aux
;
5174 memset (& aux
, 0, sizeof (aux
));
5176 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5178 if (sec
->sh_type
== SHT_SYMTAB
5179 && sec
->sh_link
< elf_header
.e_shnum
)
5181 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5182 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5184 strsec
= section_headers
+ sec
->sh_link
;
5185 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5186 1, strsec
->sh_size
, _("string table"));
5187 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5189 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5194 printf (_("\nThere are no unwind sections in this file.\n"));
5196 while (unwcount
-- > 0)
5201 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5202 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5203 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5210 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5212 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5214 /* We need to find which section group it is in. */
5215 struct group_list
*g
= section_headers_groups
[i
]->root
;
5217 for (; g
!= NULL
; g
= g
->next
)
5219 sec
= section_headers
+ g
->section_index
;
5221 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5226 i
= elf_header
.e_shnum
;
5228 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5230 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5231 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5232 suffix
= SECTION_NAME (unwsec
) + len
;
5233 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5235 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5236 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5241 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5242 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5243 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5244 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5246 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5247 suffix
= SECTION_NAME (unwsec
) + len
;
5248 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5250 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5251 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5255 if (i
== elf_header
.e_shnum
)
5257 printf (_("\nCould not find unwind info section for "));
5259 if (string_table
== NULL
)
5260 printf ("%d", unwsec
->sh_name
);
5262 printf (_("'%s'"), SECTION_NAME (unwsec
));
5266 aux
.info_size
= sec
->sh_size
;
5267 aux
.info_addr
= sec
->sh_addr
;
5268 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, 1, aux
.info_size
,
5271 printf (_("\nUnwind section "));
5273 if (string_table
== NULL
)
5274 printf ("%d", unwsec
->sh_name
);
5276 printf (_("'%s'"), SECTION_NAME (unwsec
));
5278 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5279 (unsigned long) unwsec
->sh_offset
,
5280 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5282 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5284 if (aux
.table_len
> 0)
5285 dump_ia64_unwind (& aux
);
5288 free ((char *) aux
.table
);
5290 free ((char *) aux
.info
);
5299 free ((char *) aux
.strtab
);
5304 struct hppa_unw_aux_info
5306 struct hppa_unw_table_entry
5308 struct absaddr start
;
5310 unsigned int Cannot_unwind
:1; /* 0 */
5311 unsigned int Millicode
:1; /* 1 */
5312 unsigned int Millicode_save_sr0
:1; /* 2 */
5313 unsigned int Region_description
:2; /* 3..4 */
5314 unsigned int reserved1
:1; /* 5 */
5315 unsigned int Entry_SR
:1; /* 6 */
5316 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5317 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5318 unsigned int Args_stored
:1; /* 16 */
5319 unsigned int Variable_Frame
:1; /* 17 */
5320 unsigned int Separate_Package_Body
:1; /* 18 */
5321 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5322 unsigned int Stack_Overflow_Check
:1; /* 20 */
5323 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5324 unsigned int Ada_Region
:1; /* 22 */
5325 unsigned int cxx_info
:1; /* 23 */
5326 unsigned int cxx_try_catch
:1; /* 24 */
5327 unsigned int sched_entry_seq
:1; /* 25 */
5328 unsigned int reserved2
:1; /* 26 */
5329 unsigned int Save_SP
:1; /* 27 */
5330 unsigned int Save_RP
:1; /* 28 */
5331 unsigned int Save_MRP_in_frame
:1; /* 29 */
5332 unsigned int extn_ptr_defined
:1; /* 30 */
5333 unsigned int Cleanup_defined
:1; /* 31 */
5335 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5336 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5337 unsigned int Large_frame
:1; /* 2 */
5338 unsigned int Pseudo_SP_Set
:1; /* 3 */
5339 unsigned int reserved4
:1; /* 4 */
5340 unsigned int Total_frame_size
:27; /* 5..31 */
5342 *table
; /* Unwind table. */
5343 unsigned long table_len
; /* Length of unwind table. */
5344 bfd_vma seg_base
; /* Starting address of segment. */
5345 Elf_Internal_Sym
*symtab
; /* The symbol table. */
5346 unsigned long nsyms
; /* Number of symbols. */
5347 char *strtab
; /* The string table. */
5348 unsigned long strtab_size
; /* Size of string table. */
5352 dump_hppa_unwind (struct hppa_unw_aux_info
*aux
)
5354 struct hppa_unw_table_entry
*tp
;
5356 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5359 const char *procname
;
5361 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5362 aux
->strtab_size
, tp
->start
, &procname
,
5365 fputs ("\n<", stdout
);
5369 fputs (procname
, stdout
);
5372 printf ("+%lx", (unsigned long) offset
);
5375 fputs (">: [", stdout
);
5376 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5377 fputc ('-', stdout
);
5378 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5381 #define PF(_m) if (tp->_m) printf (#_m " ");
5382 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5385 PF(Millicode_save_sr0
);
5386 /* PV(Region_description); */
5392 PF(Separate_Package_Body
);
5393 PF(Frame_Extension_Millicode
);
5394 PF(Stack_Overflow_Check
);
5395 PF(Two_Instruction_SP_Increment
);
5399 PF(sched_entry_seq
);
5402 PF(Save_MRP_in_frame
);
5403 PF(extn_ptr_defined
);
5404 PF(Cleanup_defined
);
5405 PF(MPE_XL_interrupt_marker
);
5406 PF(HP_UX_interrupt_marker
);
5409 PV(Total_frame_size
);
5418 slurp_hppa_unwind_table (FILE *file
,
5419 struct hppa_unw_aux_info
*aux
,
5420 Elf_Internal_Shdr
*sec
)
5422 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5423 Elf_Internal_Phdr
*seg
;
5424 struct hppa_unw_table_entry
*tep
;
5425 Elf_Internal_Shdr
*relsec
;
5426 Elf_Internal_Rela
*rela
, *rp
;
5427 unsigned char *table
, *tp
;
5428 Elf_Internal_Sym
*sym
;
5429 const char *relname
;
5431 /* First, find the starting address of the segment that includes
5434 if (elf_header
.e_phnum
)
5436 if (! get_program_headers (file
))
5439 for (seg
= program_headers
;
5440 seg
< program_headers
+ elf_header
.e_phnum
;
5443 if (seg
->p_type
!= PT_LOAD
)
5446 if (sec
->sh_addr
>= seg
->p_vaddr
5447 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5449 aux
->seg_base
= seg
->p_vaddr
;
5455 /* Second, build the unwind table from the contents of the unwind
5457 size
= sec
->sh_size
;
5458 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5463 nentries
= size
/ unw_ent_size
;
5464 size
= unw_ent_size
* nentries
;
5466 tep
= aux
->table
= xcmalloc (nentries
, sizeof (aux
->table
[0]));
5468 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5470 unsigned int tmp1
, tmp2
;
5472 tep
->start
.section
= SHN_UNDEF
;
5473 tep
->end
.section
= SHN_UNDEF
;
5475 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5476 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5477 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5478 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5480 tep
->start
.offset
+= aux
->seg_base
;
5481 tep
->end
.offset
+= aux
->seg_base
;
5483 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5484 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5485 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5486 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5487 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5488 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5489 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5490 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5491 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5492 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5493 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5494 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5495 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5496 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5497 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5498 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5499 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5500 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5501 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5502 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5503 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5504 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5505 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5506 tep
->Cleanup_defined
= tmp1
& 0x1;
5508 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5509 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5510 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5511 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5512 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5513 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5517 /* Third, apply any relocations to the unwind table. */
5518 for (relsec
= section_headers
;
5519 relsec
< section_headers
+ elf_header
.e_shnum
;
5522 if (relsec
->sh_type
!= SHT_RELA
5523 || relsec
->sh_info
>= elf_header
.e_shnum
5524 || section_headers
+ relsec
->sh_info
!= sec
)
5527 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5531 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5533 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
5534 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5536 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5537 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
5539 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5543 i
= rp
->r_offset
/ unw_ent_size
;
5545 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5548 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5549 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
5552 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5553 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5563 aux
->table_len
= nentries
;
5569 hppa_process_unwind (FILE *file
)
5571 struct hppa_unw_aux_info aux
;
5572 Elf_Internal_Shdr
*unwsec
= NULL
;
5573 Elf_Internal_Shdr
*strsec
;
5574 Elf_Internal_Shdr
*sec
;
5577 memset (& aux
, 0, sizeof (aux
));
5579 if (string_table
== NULL
)
5582 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5584 if (sec
->sh_type
== SHT_SYMTAB
5585 && sec
->sh_link
< elf_header
.e_shnum
)
5587 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5588 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5590 strsec
= section_headers
+ sec
->sh_link
;
5591 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5592 1, strsec
->sh_size
, _("string table"));
5593 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5595 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5600 printf (_("\nThere are no unwind sections in this file.\n"));
5602 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5604 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5606 printf (_("\nUnwind section "));
5607 printf (_("'%s'"), SECTION_NAME (sec
));
5609 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5610 (unsigned long) sec
->sh_offset
,
5611 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5613 slurp_hppa_unwind_table (file
, &aux
, sec
);
5614 if (aux
.table_len
> 0)
5615 dump_hppa_unwind (&aux
);
5618 free ((char *) aux
.table
);
5626 free ((char *) aux
.strtab
);
5632 process_unwind (FILE *file
)
5634 struct unwind_handler
{
5636 int (*handler
)(FILE *file
);
5638 { EM_IA_64
, ia64_process_unwind
},
5639 { EM_PARISC
, hppa_process_unwind
},
5647 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5648 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5649 return handlers
[i
].handler (file
);
5651 printf (_("\nThere are no unwind sections in this file.\n"));
5656 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
5658 switch (entry
->d_tag
)
5661 if (entry
->d_un
.d_val
== 0)
5665 static const char * opts
[] =
5667 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5668 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5669 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5670 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5675 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
5676 if (entry
->d_un
.d_val
& (1 << cnt
))
5678 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5685 case DT_MIPS_IVERSION
:
5686 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5687 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5689 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5692 case DT_MIPS_TIME_STAMP
:
5697 time_t time
= entry
->d_un
.d_val
;
5698 tmp
= gmtime (&time
);
5699 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5700 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5701 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5702 printf ("Time Stamp: %s\n", timebuf
);
5706 case DT_MIPS_RLD_VERSION
:
5707 case DT_MIPS_LOCAL_GOTNO
:
5708 case DT_MIPS_CONFLICTNO
:
5709 case DT_MIPS_LIBLISTNO
:
5710 case DT_MIPS_SYMTABNO
:
5711 case DT_MIPS_UNREFEXTNO
:
5712 case DT_MIPS_HIPAGENO
:
5713 case DT_MIPS_DELTA_CLASS_NO
:
5714 case DT_MIPS_DELTA_INSTANCE_NO
:
5715 case DT_MIPS_DELTA_RELOC_NO
:
5716 case DT_MIPS_DELTA_SYM_NO
:
5717 case DT_MIPS_DELTA_CLASSSYM_NO
:
5718 case DT_MIPS_COMPACT_SIZE
:
5719 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5723 printf ("%#lx\n", (unsigned long) entry
->d_un
.d_ptr
);
5729 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
5731 switch (entry
->d_tag
)
5733 case DT_HP_DLD_FLAGS
:
5742 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5743 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5744 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5745 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5746 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5747 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5748 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5749 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5750 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5751 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5752 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
5753 { DT_HP_GST
, "HP_GST" },
5754 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
5755 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
5756 { DT_HP_NODELETE
, "HP_NODELETE" },
5757 { DT_HP_GROUP
, "HP_GROUP" },
5758 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
5762 bfd_vma val
= entry
->d_un
.d_val
;
5764 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
5765 if (val
& flags
[cnt
].bit
)
5769 fputs (flags
[cnt
].str
, stdout
);
5771 val
^= flags
[cnt
].bit
;
5774 if (val
!= 0 || first
)
5778 print_vma (val
, HEX
);
5784 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5791 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
5793 switch (entry
->d_tag
)
5795 case DT_IA_64_PLT_RESERVE
:
5796 /* First 3 slots reserved. */
5797 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5799 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5803 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5810 get_32bit_dynamic_section (FILE *file
)
5812 Elf32_External_Dyn
*edyn
, *ext
;
5813 Elf_Internal_Dyn
*entry
;
5815 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5816 _("dynamic section"));
5820 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5821 might not have the luxury of section headers. Look for the DT_NULL
5822 terminator to determine the number of entries. */
5823 for (ext
= edyn
, dynamic_nent
= 0;
5824 (char *) ext
< (char *) edyn
+ dynamic_size
;
5828 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5832 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5833 if (dynamic_section
== NULL
)
5835 error (_("Out of memory\n"));
5840 for (ext
= edyn
, entry
= dynamic_section
;
5841 entry
< dynamic_section
+ dynamic_nent
;
5844 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5845 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5854 get_64bit_dynamic_section (FILE *file
)
5856 Elf64_External_Dyn
*edyn
, *ext
;
5857 Elf_Internal_Dyn
*entry
;
5859 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5860 _("dynamic section"));
5864 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5865 might not have the luxury of section headers. Look for the DT_NULL
5866 terminator to determine the number of entries. */
5867 for (ext
= edyn
, dynamic_nent
= 0;
5868 (char *) ext
< (char *) edyn
+ dynamic_size
;
5872 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5876 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5877 if (dynamic_section
== NULL
)
5879 error (_("Out of memory\n"));
5884 for (ext
= edyn
, entry
= dynamic_section
;
5885 entry
< dynamic_section
+ dynamic_nent
;
5888 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5889 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5898 print_dynamic_flags (bfd_vma flags
)
5906 flag
= flags
& - flags
;
5916 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
5917 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
5918 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
5919 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
5920 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
5921 default: fputs ("unknown", stdout
); break;
5927 /* Parse and display the contents of the dynamic section. */
5930 process_dynamic_section (FILE *file
)
5932 Elf_Internal_Dyn
*entry
;
5934 if (dynamic_size
== 0)
5937 printf (_("\nThere is no dynamic section in this file.\n"));
5944 if (! get_32bit_dynamic_section (file
))
5947 else if (! get_64bit_dynamic_section (file
))
5950 /* Find the appropriate symbol table. */
5951 if (dynamic_symbols
== NULL
)
5953 for (entry
= dynamic_section
;
5954 entry
< dynamic_section
+ dynamic_nent
;
5957 Elf_Internal_Shdr section
;
5959 if (entry
->d_tag
!= DT_SYMTAB
)
5962 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5964 /* Since we do not know how big the symbol table is,
5965 we default to reading in the entire file (!) and
5966 processing that. This is overkill, I know, but it
5968 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5970 if (archive_file_offset
!= 0)
5971 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5974 if (fseek (file
, 0, SEEK_END
))
5975 error (_("Unable to seek to end of file!\n"));
5977 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5981 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5983 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5985 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5986 if (num_dynamic_syms
< 1)
5988 error (_("Unable to determine the number of symbols to load\n"));
5992 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5996 /* Similarly find a string table. */
5997 if (dynamic_strings
== NULL
)
5999 for (entry
= dynamic_section
;
6000 entry
< dynamic_section
+ dynamic_nent
;
6003 unsigned long offset
;
6006 if (entry
->d_tag
!= DT_STRTAB
)
6009 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
6011 /* Since we do not know how big the string table is,
6012 we default to reading in the entire file (!) and
6013 processing that. This is overkill, I know, but it
6016 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
6018 if (archive_file_offset
!= 0)
6019 str_tab_len
= archive_file_size
- offset
;
6022 if (fseek (file
, 0, SEEK_END
))
6023 error (_("Unable to seek to end of file\n"));
6024 str_tab_len
= ftell (file
) - offset
;
6027 if (str_tab_len
< 1)
6030 (_("Unable to determine the length of the dynamic string table\n"));
6034 dynamic_strings
= get_data (NULL
, file
, offset
, 1, str_tab_len
,
6035 _("dynamic string table"));
6036 dynamic_strings_length
= str_tab_len
;
6041 /* And find the syminfo section if available. */
6042 if (dynamic_syminfo
== NULL
)
6044 unsigned long syminsz
= 0;
6046 for (entry
= dynamic_section
;
6047 entry
< dynamic_section
+ dynamic_nent
;
6050 if (entry
->d_tag
== DT_SYMINENT
)
6052 /* Note: these braces are necessary to avoid a syntax
6053 error from the SunOS4 C compiler. */
6054 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
6056 else if (entry
->d_tag
== DT_SYMINSZ
)
6057 syminsz
= entry
->d_un
.d_val
;
6058 else if (entry
->d_tag
== DT_SYMINFO
)
6059 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
6063 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
6065 Elf_External_Syminfo
*extsyminfo
, *extsym
;
6066 Elf_Internal_Syminfo
*syminfo
;
6068 /* There is a syminfo section. Read the data. */
6069 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, 1,
6070 syminsz
, _("symbol information"));
6074 dynamic_syminfo
= malloc (syminsz
);
6075 if (dynamic_syminfo
== NULL
)
6077 error (_("Out of memory\n"));
6081 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
6082 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
6083 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
6084 ++syminfo
, ++extsym
)
6086 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
6087 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
6094 if (do_dynamic
&& dynamic_addr
)
6095 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
6096 dynamic_addr
, dynamic_nent
);
6098 printf (_(" Tag Type Name/Value\n"));
6100 for (entry
= dynamic_section
;
6101 entry
< dynamic_section
+ dynamic_nent
;
6109 print_vma (entry
->d_tag
, FULL_HEX
);
6110 dtype
= get_dynamic_type (entry
->d_tag
);
6111 printf (" (%s)%*s", dtype
,
6112 ((is_32bit_elf
? 27 : 19)
6113 - (int) strlen (dtype
)),
6117 switch (entry
->d_tag
)
6121 print_dynamic_flags (entry
->d_un
.d_val
);
6131 switch (entry
->d_tag
)
6134 printf (_("Auxiliary library"));
6138 printf (_("Filter library"));
6142 printf (_("Configuration file"));
6146 printf (_("Dependency audit library"));
6150 printf (_("Audit library"));
6154 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6155 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
6159 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6168 printf (_("Flags:"));
6170 if (entry
->d_un
.d_val
== 0)
6171 printf (_(" None\n"));
6174 unsigned long int val
= entry
->d_un
.d_val
;
6176 if (val
& DTF_1_PARINIT
)
6178 printf (" PARINIT");
6179 val
^= DTF_1_PARINIT
;
6181 if (val
& DTF_1_CONFEXP
)
6183 printf (" CONFEXP");
6184 val
^= DTF_1_CONFEXP
;
6187 printf (" %lx", val
);
6196 printf (_("Flags:"));
6198 if (entry
->d_un
.d_val
== 0)
6199 printf (_(" None\n"));
6202 unsigned long int val
= entry
->d_un
.d_val
;
6204 if (val
& DF_P1_LAZYLOAD
)
6206 printf (" LAZYLOAD");
6207 val
^= DF_P1_LAZYLOAD
;
6209 if (val
& DF_P1_GROUPPERM
)
6211 printf (" GROUPPERM");
6212 val
^= DF_P1_GROUPPERM
;
6215 printf (" %lx", val
);
6224 printf (_("Flags:"));
6225 if (entry
->d_un
.d_val
== 0)
6226 printf (_(" None\n"));
6229 unsigned long int val
= entry
->d_un
.d_val
;
6236 if (val
& DF_1_GLOBAL
)
6241 if (val
& DF_1_GROUP
)
6246 if (val
& DF_1_NODELETE
)
6248 printf (" NODELETE");
6249 val
^= DF_1_NODELETE
;
6251 if (val
& DF_1_LOADFLTR
)
6253 printf (" LOADFLTR");
6254 val
^= DF_1_LOADFLTR
;
6256 if (val
& DF_1_INITFIRST
)
6258 printf (" INITFIRST");
6259 val
^= DF_1_INITFIRST
;
6261 if (val
& DF_1_NOOPEN
)
6266 if (val
& DF_1_ORIGIN
)
6271 if (val
& DF_1_DIRECT
)
6276 if (val
& DF_1_TRANS
)
6281 if (val
& DF_1_INTERPOSE
)
6283 printf (" INTERPOSE");
6284 val
^= DF_1_INTERPOSE
;
6286 if (val
& DF_1_NODEFLIB
)
6288 printf (" NODEFLIB");
6289 val
^= DF_1_NODEFLIB
;
6291 if (val
& DF_1_NODUMP
)
6296 if (val
& DF_1_CONLFAT
)
6298 printf (" CONLFAT");
6299 val
^= DF_1_CONLFAT
;
6302 printf (" %lx", val
);
6309 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6311 puts (get_dynamic_type (entry
->d_un
.d_val
));
6331 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6337 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6338 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6344 switch (entry
->d_tag
)
6347 printf (_("Shared library: [%s]"), name
);
6349 if (streq (name
, program_interpreter
))
6350 printf (_(" program interpreter"));
6354 printf (_("Library soname: [%s]"), name
);
6358 printf (_("Library rpath: [%s]"), name
);
6362 printf (_("Library runpath: [%s]"), name
);
6366 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6371 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6384 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6388 case DT_INIT_ARRAYSZ
:
6389 case DT_FINI_ARRAYSZ
:
6390 case DT_GNU_CONFLICTSZ
:
6391 case DT_GNU_LIBLISTSZ
:
6394 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6395 printf (" (bytes)\n");
6405 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6418 if (entry
->d_tag
== DT_USED
6419 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6421 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6425 printf (_("Not needed object: [%s]\n"), name
);
6430 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6436 /* The value of this entry is ignored. */
6441 case DT_GNU_PRELINKED
:
6445 time_t time
= entry
->d_un
.d_val
;
6447 tmp
= gmtime (&time
);
6448 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6449 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6450 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6456 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
6459 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6465 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6466 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6471 switch (elf_header
.e_machine
)
6474 case EM_MIPS_RS3_LE
:
6475 dynamic_section_mips_val (entry
);
6478 dynamic_section_parisc_val (entry
);
6481 dynamic_section_ia64_val (entry
);
6484 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6496 get_ver_flags (unsigned int flags
)
6498 static char buff
[32];
6505 if (flags
& VER_FLG_BASE
)
6506 strcat (buff
, "BASE ");
6508 if (flags
& VER_FLG_WEAK
)
6510 if (flags
& VER_FLG_BASE
)
6511 strcat (buff
, "| ");
6513 strcat (buff
, "WEAK ");
6516 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6517 strcat (buff
, "| <unknown>");
6522 /* Display the contents of the version sections. */
6524 process_version_sections (FILE *file
)
6526 Elf_Internal_Shdr
*section
;
6533 for (i
= 0, section
= section_headers
;
6534 i
< elf_header
.e_shnum
;
6537 switch (section
->sh_type
)
6539 case SHT_GNU_verdef
:
6541 Elf_External_Verdef
*edefs
;
6549 (_("\nVersion definition section '%s' contains %u entries:\n"),
6550 SECTION_NAME (section
), section
->sh_info
);
6552 printf (_(" Addr: 0x"));
6553 printf_vma (section
->sh_addr
);
6554 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6555 (unsigned long) section
->sh_offset
, section
->sh_link
,
6556 section
->sh_link
< elf_header
.e_shnum
6557 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6560 edefs
= get_data (NULL
, file
, section
->sh_offset
, 1,
6562 _("version definition section"));
6563 endbuf
= (char *) edefs
+ section
->sh_size
;
6567 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6570 Elf_External_Verdef
*edef
;
6571 Elf_Internal_Verdef ent
;
6572 Elf_External_Verdaux
*eaux
;
6573 Elf_Internal_Verdaux aux
;
6577 vstart
= ((char *) edefs
) + idx
;
6578 if (vstart
+ sizeof (*edef
) > endbuf
)
6581 edef
= (Elf_External_Verdef
*) vstart
;
6583 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6584 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6585 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6586 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6587 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6588 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6589 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6591 printf (_(" %#06x: Rev: %d Flags: %s"),
6592 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6594 printf (_(" Index: %d Cnt: %d "),
6595 ent
.vd_ndx
, ent
.vd_cnt
);
6597 vstart
+= ent
.vd_aux
;
6599 eaux
= (Elf_External_Verdaux
*) vstart
;
6601 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6602 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6604 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6605 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6607 printf (_("Name index: %ld\n"), aux
.vda_name
);
6609 isum
= idx
+ ent
.vd_aux
;
6611 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6613 isum
+= aux
.vda_next
;
6614 vstart
+= aux
.vda_next
;
6616 eaux
= (Elf_External_Verdaux
*) vstart
;
6617 if (vstart
+ sizeof (*eaux
) > endbuf
)
6620 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6621 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6623 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6624 printf (_(" %#06x: Parent %d: %s\n"),
6625 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6627 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6628 isum
, j
, aux
.vda_name
);
6631 printf (_(" Version def aux past end of section\n"));
6635 if (cnt
< section
->sh_info
)
6636 printf (_(" Version definition past end of section\n"));
6642 case SHT_GNU_verneed
:
6644 Elf_External_Verneed
*eneed
;
6651 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
6652 SECTION_NAME (section
), section
->sh_info
);
6654 printf (_(" Addr: 0x"));
6655 printf_vma (section
->sh_addr
);
6656 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6657 (unsigned long) section
->sh_offset
, section
->sh_link
,
6658 section
->sh_link
< elf_header
.e_shnum
6659 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6662 eneed
= get_data (NULL
, file
, section
->sh_offset
, 1,
6664 _("version need section"));
6665 endbuf
= (char *) eneed
+ section
->sh_size
;
6669 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6671 Elf_External_Verneed
*entry
;
6672 Elf_Internal_Verneed ent
;
6677 vstart
= ((char *) eneed
) + idx
;
6678 if (vstart
+ sizeof (*entry
) > endbuf
)
6681 entry
= (Elf_External_Verneed
*) vstart
;
6683 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6684 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6685 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6686 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6687 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6689 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6691 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6692 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6694 printf (_(" File: %lx"), ent
.vn_file
);
6696 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6698 vstart
+= ent
.vn_aux
;
6700 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6702 Elf_External_Vernaux
*eaux
;
6703 Elf_Internal_Vernaux aux
;
6705 if (vstart
+ sizeof (*eaux
) > endbuf
)
6707 eaux
= (Elf_External_Vernaux
*) vstart
;
6709 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6710 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6711 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6712 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6713 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6715 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6716 printf (_(" %#06x: Name: %s"),
6717 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6719 printf (_(" %#06x: Name index: %lx"),
6720 isum
, aux
.vna_name
);
6722 printf (_(" Flags: %s Version: %d\n"),
6723 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6725 isum
+= aux
.vna_next
;
6726 vstart
+= aux
.vna_next
;
6729 printf (_(" Version need aux past end of section\n"));
6733 if (cnt
< section
->sh_info
)
6734 printf (_(" Version need past end of section\n"));
6740 case SHT_GNU_versym
:
6742 Elf_Internal_Shdr
*link_section
;
6745 unsigned char *edata
;
6746 unsigned short *data
;
6748 Elf_Internal_Sym
*symbols
;
6749 Elf_Internal_Shdr
*string_sec
;
6752 if (section
->sh_link
>= elf_header
.e_shnum
)
6755 link_section
= section_headers
+ section
->sh_link
;
6756 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6758 if (link_section
->sh_link
>= elf_header
.e_shnum
)
6763 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6765 string_sec
= section_headers
+ link_section
->sh_link
;
6767 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6768 string_sec
->sh_size
, _("version string table"));
6772 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6773 SECTION_NAME (section
), total
);
6775 printf (_(" Addr: "));
6776 printf_vma (section
->sh_addr
);
6777 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6778 (unsigned long) section
->sh_offset
, section
->sh_link
,
6779 SECTION_NAME (link_section
));
6781 off
= offset_from_vma (file
,
6782 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6783 total
* sizeof (short));
6784 edata
= get_data (NULL
, file
, off
, total
, sizeof (short),
6785 _("version symbol data"));
6792 data
= cmalloc (total
, sizeof (short));
6794 for (cnt
= total
; cnt
--;)
6795 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6800 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6803 int check_def
, check_need
;
6806 printf (" %03x:", cnt
);
6808 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6809 switch (data
[cnt
+ j
])
6812 fputs (_(" 0 (*local*) "), stdout
);
6816 fputs (_(" 1 (*global*) "), stdout
);
6820 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6821 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6825 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
6826 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
6829 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6836 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6838 Elf_Internal_Verneed ivn
;
6839 unsigned long offset
;
6841 offset
= offset_from_vma
6842 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6843 sizeof (Elf_External_Verneed
));
6847 Elf_Internal_Vernaux ivna
;
6848 Elf_External_Verneed evn
;
6849 Elf_External_Vernaux evna
;
6850 unsigned long a_off
;
6852 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6855 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6856 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6858 a_off
= offset
+ ivn
.vn_aux
;
6862 get_data (&evna
, file
, a_off
, sizeof (evna
),
6863 1, _("version need aux (2)"));
6865 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6866 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6868 a_off
+= ivna
.vna_next
;
6870 while (ivna
.vna_other
!= data
[cnt
+ j
]
6871 && ivna
.vna_next
!= 0);
6873 if (ivna
.vna_other
== data
[cnt
+ j
])
6875 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6877 if (ivna
.vna_name
>= string_sec
->sh_size
)
6878 name
= _("*invalid*");
6880 name
= strtab
+ ivna
.vna_name
;
6881 nn
+= printf ("(%s%-*s",
6883 12 - (int) strlen (name
),
6889 offset
+= ivn
.vn_next
;
6891 while (ivn
.vn_next
);
6894 if (check_def
&& data
[cnt
+ j
] != 0x8001
6895 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6897 Elf_Internal_Verdef ivd
;
6898 Elf_External_Verdef evd
;
6899 unsigned long offset
;
6901 offset
= offset_from_vma
6902 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6907 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
6910 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6911 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6913 offset
+= ivd
.vd_next
;
6915 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6916 && ivd
.vd_next
!= 0);
6918 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6920 Elf_External_Verdaux evda
;
6921 Elf_Internal_Verdaux ivda
;
6923 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6925 get_data (&evda
, file
,
6926 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6928 _("version def aux"));
6930 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6932 if (ivda
.vda_name
>= string_sec
->sh_size
)
6933 name
= _("*invalid*");
6935 name
= strtab
+ ivda
.vda_name
;
6936 nn
+= printf ("(%s%-*s",
6938 12 - (int) strlen (name
),
6944 printf ("%*c", 18 - nn
, ' ');
6962 printf (_("\nNo version information found in this file.\n"));
6968 get_symbol_binding (unsigned int binding
)
6970 static char buff
[32];
6974 case STB_LOCAL
: return "LOCAL";
6975 case STB_GLOBAL
: return "GLOBAL";
6976 case STB_WEAK
: return "WEAK";
6978 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6979 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
6981 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6982 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
6984 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
6990 get_symbol_type (unsigned int type
)
6992 static char buff
[32];
6996 case STT_NOTYPE
: return "NOTYPE";
6997 case STT_OBJECT
: return "OBJECT";
6998 case STT_FUNC
: return "FUNC";
6999 case STT_SECTION
: return "SECTION";
7000 case STT_FILE
: return "FILE";
7001 case STT_COMMON
: return "COMMON";
7002 case STT_TLS
: return "TLS";
7003 case STT_RELC
: return "RELC";
7004 case STT_SRELC
: return "SRELC";
7006 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
7008 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
7009 return "THUMB_FUNC";
7011 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
7014 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
7015 return "PARISC_MILLI";
7017 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
7019 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
7021 if (elf_header
.e_machine
== EM_PARISC
)
7023 if (type
== STT_HP_OPAQUE
)
7025 if (type
== STT_HP_STUB
)
7029 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
7032 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
7038 get_symbol_visibility (unsigned int visibility
)
7042 case STV_DEFAULT
: return "DEFAULT";
7043 case STV_INTERNAL
: return "INTERNAL";
7044 case STV_HIDDEN
: return "HIDDEN";
7045 case STV_PROTECTED
: return "PROTECTED";
7051 get_mips_symbol_other (unsigned int other
)
7055 case STO_OPTIONAL
: return "OPTIONAL";
7056 case STO_MIPS16
: return "MIPS16";
7057 case STO_MIPS_PLT
: return "MIPS PLT";
7058 case STO_MIPS_PIC
: return "MIPS PIC";
7059 default: return NULL
;
7064 get_symbol_other (unsigned int other
)
7066 const char * result
= NULL
;
7067 static char buff
[32];
7072 switch (elf_header
.e_machine
)
7075 result
= get_mips_symbol_other (other
);
7083 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
7088 get_symbol_index_type (unsigned int type
)
7090 static char buff
[32];
7094 case SHN_UNDEF
: return "UND";
7095 case SHN_ABS
: return "ABS";
7096 case SHN_COMMON
: return "COM";
7098 if (type
== SHN_IA_64_ANSI_COMMON
7099 && elf_header
.e_machine
== EM_IA_64
7100 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
7102 else if (elf_header
.e_machine
== EM_X86_64
7103 && type
== SHN_X86_64_LCOMMON
)
7105 else if (type
== SHN_MIPS_SCOMMON
7106 && elf_header
.e_machine
== EM_MIPS
)
7108 else if (type
== SHN_MIPS_SUNDEFINED
7109 && elf_header
.e_machine
== EM_MIPS
)
7111 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
7112 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
7113 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
7114 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
7115 else if (type
>= SHN_LORESERVE
)
7116 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
7118 sprintf (buff
, "%3d", type
);
7126 get_dynamic_data (FILE *file
, unsigned int number
, unsigned int ent_size
)
7128 unsigned char *e_data
;
7131 e_data
= cmalloc (number
, ent_size
);
7135 error (_("Out of memory\n"));
7139 if (fread (e_data
, ent_size
, number
, file
) != number
)
7141 error (_("Unable to read in dynamic data\n"));
7145 i_data
= cmalloc (number
, sizeof (*i_data
));
7149 error (_("Out of memory\n"));
7155 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
7163 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
7165 Elf_Internal_Sym
*psym
;
7168 psym
= dynamic_symbols
+ si
;
7170 n
= print_vma (si
, DEC_5
);
7172 fputs (" " + n
, stdout
);
7173 printf (" %3lu: ", hn
);
7174 print_vma (psym
->st_value
, LONG_HEX
);
7176 print_vma (psym
->st_size
, DEC_5
);
7178 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7179 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7180 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7181 /* Check to see if any other bits in the st_other field are set.
7182 Note - displaying this information disrupts the layout of the
7183 table being generated, but for the moment this case is very
7185 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7186 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7187 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
7188 if (VALID_DYNAMIC_NAME (psym
->st_name
))
7189 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
7191 printf (" <corrupt: %14ld>", psym
->st_name
);
7195 /* Dump the symbol table. */
7197 process_symbol_table (FILE *file
)
7199 Elf_Internal_Shdr
*section
;
7200 bfd_vma nbuckets
= 0;
7201 bfd_vma nchains
= 0;
7202 bfd_vma
*buckets
= NULL
;
7203 bfd_vma
*chains
= NULL
;
7204 bfd_vma ngnubuckets
= 0;
7205 bfd_vma
*gnubuckets
= NULL
;
7206 bfd_vma
*gnuchains
= NULL
;
7207 bfd_vma gnusymidx
= 0;
7209 if (! do_syms
&& !do_histogram
)
7212 if (dynamic_info
[DT_HASH
]
7214 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7216 unsigned char nb
[8];
7217 unsigned char nc
[8];
7218 int hash_ent_size
= 4;
7220 if ((elf_header
.e_machine
== EM_ALPHA
7221 || elf_header
.e_machine
== EM_S390
7222 || elf_header
.e_machine
== EM_S390_OLD
)
7223 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
7227 (archive_file_offset
7228 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
7229 sizeof nb
+ sizeof nc
)),
7232 error (_("Unable to seek to start of dynamic information\n"));
7236 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
7238 error (_("Failed to read in number of buckets\n"));
7242 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
7244 error (_("Failed to read in number of chains\n"));
7248 nbuckets
= byte_get (nb
, hash_ent_size
);
7249 nchains
= byte_get (nc
, hash_ent_size
);
7251 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
7252 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
7254 if (buckets
== NULL
|| chains
== NULL
)
7258 if (dynamic_info_DT_GNU_HASH
7260 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7262 unsigned char nb
[16];
7263 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
7264 bfd_vma buckets_vma
;
7267 (archive_file_offset
7268 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
7272 error (_("Unable to seek to start of dynamic information\n"));
7276 if (fread (nb
, 16, 1, file
) != 1)
7278 error (_("Failed to read in number of buckets\n"));
7282 ngnubuckets
= byte_get (nb
, 4);
7283 gnusymidx
= byte_get (nb
+ 4, 4);
7284 bitmaskwords
= byte_get (nb
+ 8, 4);
7285 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
7287 buckets_vma
+= bitmaskwords
* 4;
7289 buckets_vma
+= bitmaskwords
* 8;
7292 (archive_file_offset
7293 + offset_from_vma (file
, buckets_vma
, 4)),
7296 error (_("Unable to seek to start of dynamic information\n"));
7300 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
7302 if (gnubuckets
== NULL
)
7305 for (i
= 0; i
< ngnubuckets
; i
++)
7306 if (gnubuckets
[i
] != 0)
7308 if (gnubuckets
[i
] < gnusymidx
)
7311 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
7312 maxchain
= gnubuckets
[i
];
7315 if (maxchain
== 0xffffffff)
7318 maxchain
-= gnusymidx
;
7321 (archive_file_offset
7322 + offset_from_vma (file
, buckets_vma
7323 + 4 * (ngnubuckets
+ maxchain
), 4)),
7326 error (_("Unable to seek to start of dynamic information\n"));
7332 if (fread (nb
, 4, 1, file
) != 1)
7334 error (_("Failed to determine last chain length\n"));
7338 if (maxchain
+ 1 == 0)
7343 while ((byte_get (nb
, 4) & 1) == 0);
7346 (archive_file_offset
7347 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
7350 error (_("Unable to seek to start of dynamic information\n"));
7354 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
7356 if (gnuchains
== NULL
)
7360 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
7363 && dynamic_strings
!= NULL
)
7367 if (dynamic_info
[DT_HASH
])
7371 printf (_("\nSymbol table for image:\n"));
7373 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7375 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7377 for (hn
= 0; hn
< nbuckets
; hn
++)
7382 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
7383 print_dynamic_symbol (si
, hn
);
7387 if (dynamic_info_DT_GNU_HASH
)
7389 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
7391 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7393 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7395 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7396 if (gnubuckets
[hn
] != 0)
7398 bfd_vma si
= gnubuckets
[hn
];
7399 bfd_vma off
= si
- gnusymidx
;
7403 print_dynamic_symbol (si
, hn
);
7406 while ((gnuchains
[off
++] & 1) == 0);
7410 else if (do_syms
&& !do_using_dynamic
)
7414 for (i
= 0, section
= section_headers
;
7415 i
< elf_header
.e_shnum
;
7419 char *strtab
= NULL
;
7420 unsigned long int strtab_size
= 0;
7421 Elf_Internal_Sym
*symtab
;
7422 Elf_Internal_Sym
*psym
;
7425 if ( section
->sh_type
!= SHT_SYMTAB
7426 && section
->sh_type
!= SHT_DYNSYM
)
7429 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7430 SECTION_NAME (section
),
7431 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
7433 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7435 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7437 symtab
= GET_ELF_SYMBOLS (file
, section
);
7441 if (section
->sh_link
== elf_header
.e_shstrndx
)
7443 strtab
= string_table
;
7444 strtab_size
= string_table_length
;
7446 else if (section
->sh_link
< elf_header
.e_shnum
)
7448 Elf_Internal_Shdr
*string_sec
;
7450 string_sec
= section_headers
+ section
->sh_link
;
7452 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
7453 1, string_sec
->sh_size
, _("string table"));
7454 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
7457 for (si
= 0, psym
= symtab
;
7458 si
< section
->sh_size
/ section
->sh_entsize
;
7461 printf ("%6d: ", si
);
7462 print_vma (psym
->st_value
, LONG_HEX
);
7464 print_vma (psym
->st_size
, DEC_5
);
7465 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7466 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7467 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7468 /* Check to see if any other bits in the st_other field are set.
7469 Note - displaying this information disrupts the layout of the
7470 table being generated, but for the moment this case is very rare. */
7471 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7472 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7473 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
7474 print_symbol (25, psym
->st_name
< strtab_size
7475 ? strtab
+ psym
->st_name
: "<corrupt>");
7477 if (section
->sh_type
== SHT_DYNSYM
&&
7478 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
7480 unsigned char data
[2];
7481 unsigned short vers_data
;
7482 unsigned long offset
;
7486 offset
= offset_from_vma
7487 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7488 sizeof data
+ si
* sizeof (vers_data
));
7490 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
7491 sizeof (data
), 1, _("version data"));
7493 vers_data
= byte_get (data
, 2);
7495 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
7496 && section_headers
[psym
->st_shndx
].sh_type
7499 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
7501 if ((vers_data
& 0x8000) || vers_data
> 1)
7503 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
7504 && (is_nobits
|| ! check_def
))
7506 Elf_External_Verneed evn
;
7507 Elf_Internal_Verneed ivn
;
7508 Elf_Internal_Vernaux ivna
;
7510 /* We must test both. */
7511 offset
= offset_from_vma
7512 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7517 unsigned long vna_off
;
7519 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7522 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7523 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7525 vna_off
= offset
+ ivn
.vn_aux
;
7529 Elf_External_Vernaux evna
;
7531 get_data (&evna
, file
, vna_off
,
7533 _("version need aux (3)"));
7535 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7536 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7537 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7539 vna_off
+= ivna
.vna_next
;
7541 while (ivna
.vna_other
!= vers_data
7542 && ivna
.vna_next
!= 0);
7544 if (ivna
.vna_other
== vers_data
)
7547 offset
+= ivn
.vn_next
;
7549 while (ivn
.vn_next
!= 0);
7551 if (ivna
.vna_other
== vers_data
)
7554 ivna
.vna_name
< strtab_size
7555 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7559 else if (! is_nobits
)
7560 error (_("bad dynamic symbol\n"));
7567 if (vers_data
!= 0x8001
7568 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7570 Elf_Internal_Verdef ivd
;
7571 Elf_Internal_Verdaux ivda
;
7572 Elf_External_Verdaux evda
;
7573 unsigned long offset
;
7575 offset
= offset_from_vma
7577 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7578 sizeof (Elf_External_Verdef
));
7582 Elf_External_Verdef evd
;
7584 get_data (&evd
, file
, offset
, sizeof (evd
),
7585 1, _("version def"));
7587 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7588 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7589 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7591 offset
+= ivd
.vd_next
;
7593 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
7594 && ivd
.vd_next
!= 0);
7596 offset
-= ivd
.vd_next
;
7597 offset
+= ivd
.vd_aux
;
7599 get_data (&evda
, file
, offset
, sizeof (evda
),
7600 1, _("version def aux"));
7602 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7604 if (psym
->st_name
!= ivda
.vda_name
)
7605 printf ((vers_data
& 0x8000)
7607 ivda
.vda_name
< strtab_size
7608 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7618 if (strtab
!= string_table
)
7624 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7626 if (do_histogram
&& buckets
!= NULL
)
7628 unsigned long *lengths
;
7629 unsigned long *counts
;
7632 unsigned long maxlength
= 0;
7633 unsigned long nzero_counts
= 0;
7634 unsigned long nsyms
= 0;
7636 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7637 (unsigned long) nbuckets
);
7638 printf (_(" Length Number %% of total Coverage\n"));
7640 lengths
= calloc (nbuckets
, sizeof (*lengths
));
7641 if (lengths
== NULL
)
7643 error (_("Out of memory\n"));
7646 for (hn
= 0; hn
< nbuckets
; ++hn
)
7648 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7651 if (maxlength
< ++lengths
[hn
])
7656 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7659 error (_("Out of memory\n"));
7663 for (hn
= 0; hn
< nbuckets
; ++hn
)
7664 ++counts
[lengths
[hn
]];
7669 printf (" 0 %-10lu (%5.1f%%)\n",
7670 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7671 for (i
= 1; i
<= maxlength
; ++i
)
7673 nzero_counts
+= counts
[i
] * i
;
7674 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7675 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7676 (nzero_counts
* 100.0) / nsyms
);
7684 if (buckets
!= NULL
)
7690 if (do_histogram
&& dynamic_info_DT_GNU_HASH
)
7692 unsigned long *lengths
;
7693 unsigned long *counts
;
7695 unsigned long maxlength
= 0;
7696 unsigned long nzero_counts
= 0;
7697 unsigned long nsyms
= 0;
7699 lengths
= calloc (ngnubuckets
, sizeof (*lengths
));
7700 if (lengths
== NULL
)
7702 error (_("Out of memory\n"));
7706 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7707 (unsigned long) ngnubuckets
);
7708 printf (_(" Length Number %% of total Coverage\n"));
7710 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7711 if (gnubuckets
[hn
] != 0)
7713 bfd_vma off
, length
= 1;
7715 for (off
= gnubuckets
[hn
] - gnusymidx
;
7716 (gnuchains
[off
] & 1) == 0; ++off
)
7718 lengths
[hn
] = length
;
7719 if (length
> maxlength
)
7724 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7727 error (_("Out of memory\n"));
7731 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7732 ++counts
[lengths
[hn
]];
7734 if (ngnubuckets
> 0)
7737 printf (" 0 %-10lu (%5.1f%%)\n",
7738 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
7739 for (j
= 1; j
<= maxlength
; ++j
)
7741 nzero_counts
+= counts
[j
] * j
;
7742 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7743 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
7744 (nzero_counts
* 100.0) / nsyms
);
7758 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
7762 if (dynamic_syminfo
== NULL
7764 /* No syminfo, this is ok. */
7767 /* There better should be a dynamic symbol section. */
7768 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7772 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7773 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7775 printf (_(" Num: Name BoundTo Flags\n"));
7776 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7778 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7780 printf ("%4d: ", i
);
7781 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7782 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7784 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7787 switch (dynamic_syminfo
[i
].si_boundto
)
7789 case SYMINFO_BT_SELF
:
7790 fputs ("SELF ", stdout
);
7792 case SYMINFO_BT_PARENT
:
7793 fputs ("PARENT ", stdout
);
7796 if (dynamic_syminfo
[i
].si_boundto
> 0
7797 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7798 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7800 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7804 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7808 if (flags
& SYMINFO_FLG_DIRECT
)
7810 if (flags
& SYMINFO_FLG_PASSTHRU
)
7811 printf (" PASSTHRU");
7812 if (flags
& SYMINFO_FLG_COPY
)
7814 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7815 printf (" LAZYLOAD");
7823 #ifdef SUPPORT_DISASSEMBLY
7825 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
7827 printf (_("\nAssembly dump of section %s\n"),
7828 SECTION_NAME (section
));
7830 /* XXX -- to be done --- XXX */
7837 dump_section_as_strings (Elf_Internal_Shdr
*section
, FILE *file
)
7839 Elf_Internal_Shdr
*relsec
;
7840 bfd_size_type num_bytes
;
7845 char *name
= SECTION_NAME (section
);
7846 bfd_boolean some_strings_shown
;
7848 num_bytes
= section
->sh_size
;
7850 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7852 printf (_("\nSection '%s' has no data to dump.\n"), name
);
7856 addr
= section
->sh_addr
;
7858 start
= get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
7863 printf (_("\nString dump of section '%s':\n"), name
);
7865 /* If the section being dumped has relocations against it the user might
7866 be expecting these relocations to have been applied. Check for this
7867 case and issue a warning message in order to avoid confusion.
7868 FIXME: Maybe we ought to have an option that dumps a section with
7870 for (relsec
= section_headers
;
7871 relsec
< section_headers
+ elf_header
.e_shnum
;
7874 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
7875 || relsec
->sh_info
>= elf_header
.e_shnum
7876 || section_headers
+ relsec
->sh_info
!= section
7877 || relsec
->sh_size
== 0
7878 || relsec
->sh_link
>= elf_header
.e_shnum
)
7881 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7886 end
= start
+ num_bytes
;
7887 some_strings_shown
= FALSE
;
7891 while (!ISPRINT (* data
))
7898 printf (" [%6tx] %s\n", data
- start
, data
);
7900 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
7902 data
+= strlen (data
);
7903 some_strings_shown
= TRUE
;
7907 if (! some_strings_shown
)
7908 printf (_(" No strings found in this section."));
7918 dump_section_as_bytes (Elf_Internal_Shdr
*section
, FILE *file
)
7920 Elf_Internal_Shdr
*relsec
;
7921 bfd_size_type bytes
;
7923 unsigned char *data
;
7924 unsigned char *start
;
7926 bytes
= section
->sh_size
;
7928 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7930 printf (_("\nSection '%s' has no data to dump.\n"),
7931 SECTION_NAME (section
));
7935 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
7937 addr
= section
->sh_addr
;
7939 start
= get_data (NULL
, file
, section
->sh_offset
, 1, bytes
,
7944 /* If the section being dumped has relocations against it the user might
7945 be expecting these relocations to have been applied. Check for this
7946 case and issue a warning message in order to avoid confusion.
7947 FIXME: Maybe we ought to have an option that dumps a section with
7949 for (relsec
= section_headers
;
7950 relsec
< section_headers
+ elf_header
.e_shnum
;
7953 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
7954 || relsec
->sh_info
>= elf_header
.e_shnum
7955 || section_headers
+ relsec
->sh_info
!= section
7956 || relsec
->sh_size
== 0
7957 || relsec
->sh_link
>= elf_header
.e_shnum
)
7960 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7972 lbytes
= (bytes
> 16 ? 16 : bytes
);
7974 printf (" 0x%8.8lx ", (unsigned long) addr
);
7976 for (j
= 0; j
< 16; j
++)
7979 printf ("%2.2x", data
[j
]);
7987 for (j
= 0; j
< lbytes
; j
++)
7990 if (k
>= ' ' && k
< 0x7f)
8009 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
8010 DWARF debug sections. This is a target specific test. Note - we do not
8011 go through the whole including-target-headers-multiple-times route, (as
8012 we have already done with <elf/h8.h>) because this would become very
8013 messy and even then this function would have to contain target specific
8014 information (the names of the relocs instead of their numeric values).
8015 FIXME: This is not the correct way to solve this problem. The proper way
8016 is to have target specific reloc sizing and typing functions created by
8017 the reloc-macros.h header, in the same way that it already creates the
8018 reloc naming functions. */
8021 is_32bit_abs_reloc (unsigned int reloc_type
)
8023 switch (elf_header
.e_machine
)
8027 return reloc_type
== 1; /* R_386_32. */
8029 return reloc_type
== 1; /* R_68K_32. */
8031 return reloc_type
== 1; /* R_860_32. */
8033 return reloc_type
== 1; /* XXX Is this right ? */
8035 return reloc_type
== 1; /* R_ARC_32. */
8037 return reloc_type
== 2; /* R_ARM_ABS32 */
8040 return reloc_type
== 1;
8042 return reloc_type
== 0x12; /* R_byte4_data. */
8044 return reloc_type
== 3; /* R_CRIS_32. */
8047 return reloc_type
== 3; /* R_CR16_NUM32. */
8049 return reloc_type
== 15; /* R_CRX_NUM32. */
8051 return reloc_type
== 1;
8052 case EM_CYGNUS_D10V
:
8054 return reloc_type
== 6; /* R_D10V_32. */
8055 case EM_CYGNUS_D30V
:
8057 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
8059 return reloc_type
== 3; /* R_DLX_RELOC_32. */
8060 case EM_CYGNUS_FR30
:
8062 return reloc_type
== 3; /* R_FR30_32. */
8066 return reloc_type
== 1; /* R_H8_DIR32. */
8068 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
8071 return reloc_type
== 2; /* R_IP2K_32. */
8073 return reloc_type
== 2; /* R_IQ2000_32. */
8074 case EM_LATTICEMICO32
:
8075 return reloc_type
== 3; /* R_LM32_32. */
8078 return reloc_type
== 3; /* R_M32C_32. */
8080 return reloc_type
== 34; /* R_M32R_32_RELA. */
8082 return reloc_type
== 1; /* R_MCORE_ADDR32. */
8084 return reloc_type
== 4; /* R_MEP_32. */
8086 return reloc_type
== 2; /* R_MIPS_32. */
8088 return reloc_type
== 4; /* R_MMIX_32. */
8089 case EM_CYGNUS_MN10200
:
8091 return reloc_type
== 1; /* R_MN10200_32. */
8092 case EM_CYGNUS_MN10300
:
8094 return reloc_type
== 1; /* R_MN10300_32. */
8097 return reloc_type
== 1; /* R_MSP43_32. */
8099 return reloc_type
== 2; /* R_MT_32. */
8100 case EM_ALTERA_NIOS2
:
8102 return reloc_type
== 1; /* R_NIOS_32. */
8105 return reloc_type
== 1; /* R_OR32_32. */
8107 return reloc_type
== 1; /* R_PARISC_DIR32. */
8110 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
8112 return reloc_type
== 1; /* R_PPC64_ADDR32. */
8114 return reloc_type
== 1; /* R_PPC_ADDR32. */
8116 return reloc_type
== 1; /* R_I370_ADDR31. */
8119 return reloc_type
== 4; /* R_S390_32. */
8121 return reloc_type
== 8; /* R_SCORE_ABS32. */
8123 return reloc_type
== 1; /* R_SH_DIR32. */
8124 case EM_SPARC32PLUS
:
8127 return reloc_type
== 3 /* R_SPARC_32. */
8128 || reloc_type
== 23; /* R_SPARC_UA32. */
8130 return reloc_type
== 6; /* R_SPU_ADDR32 */
8131 case EM_CYGNUS_V850
:
8133 return reloc_type
== 6; /* R_V850_ABS32. */
8135 return reloc_type
== 1; /* R_VAX_32. */
8137 return reloc_type
== 10; /* R_X86_64_32. */
8139 return reloc_type
== 1; /* R_XSTROMY16_32. */
8142 return reloc_type
== 1; /* R_XTENSA_32. */
8145 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
8146 elf_header
.e_machine
);
8151 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8152 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
8155 is_32bit_pcrel_reloc (unsigned int reloc_type
)
8157 switch (elf_header
.e_machine
)
8161 return reloc_type
== 2; /* R_386_PC32. */
8163 return reloc_type
== 4; /* R_68K_PC32. */
8165 return reloc_type
== 10; /* R_ALPHA_SREL32. */
8167 return reloc_type
== 3; /* R_ARM_REL32 */
8169 return reloc_type
== 9; /* R_PARISC_PCREL32. */
8171 return reloc_type
== 26; /* R_PPC_REL32. */
8173 return reloc_type
== 26; /* R_PPC64_REL32. */
8176 return reloc_type
== 5; /* R_390_PC32. */
8178 return reloc_type
== 2; /* R_SH_REL32. */
8179 case EM_SPARC32PLUS
:
8182 return reloc_type
== 6; /* R_SPARC_DISP32. */
8184 return reloc_type
== 13; /* R_SPU_REL32. */
8186 return reloc_type
== 2; /* R_X86_64_PC32. */
8189 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
8191 /* Do not abort or issue an error message here. Not all targets use
8192 pc-relative 32-bit relocs in their DWARF debug information and we
8193 have already tested for target coverage in is_32bit_abs_reloc. A
8194 more helpful warning message will be generated by
8195 debug_apply_relocations anyway, so just return. */
8200 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8201 a 64-bit absolute RELA relocation used in DWARF debug sections. */
8204 is_64bit_abs_reloc (unsigned int reloc_type
)
8206 switch (elf_header
.e_machine
)
8209 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
8211 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
8213 return reloc_type
== 80; /* R_PARISC_DIR64. */
8215 return reloc_type
== 38; /* R_PPC64_ADDR64. */
8216 case EM_SPARC32PLUS
:
8219 return reloc_type
== 54; /* R_SPARC_UA64. */
8221 return reloc_type
== 1; /* R_X86_64_64. */
8224 return reloc_type
== 22; /* R_S390_64 */
8226 return reloc_type
== 18; /* R_MIPS_64 */
8232 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
8233 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
8236 is_64bit_pcrel_reloc (unsigned int reloc_type
)
8238 switch (elf_header
.e_machine
)
8241 return reloc_type
== 11; /* R_ALPHA_SREL64 */
8243 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB */
8245 return reloc_type
== 72; /* R_PARISC_PCREL64 */
8247 return reloc_type
== 44; /* R_PPC64_REL64 */
8248 case EM_SPARC32PLUS
:
8251 return reloc_type
== 46; /* R_SPARC_DISP64 */
8253 return reloc_type
== 24; /* R_X86_64_PC64 */
8256 return reloc_type
== 23; /* R_S390_PC64 */
8262 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8263 a 16-bit absolute RELA relocation used in DWARF debug sections. */
8266 is_16bit_abs_reloc (unsigned int reloc_type
)
8268 switch (elf_header
.e_machine
)
8272 return reloc_type
== 4; /* R_AVR_16. */
8273 case EM_CYGNUS_D10V
:
8275 return reloc_type
== 3; /* R_D10V_16. */
8279 return reloc_type
== R_H8_DIR16
;
8282 return reloc_type
== 1; /* R_IP2K_16. */
8285 return reloc_type
== 1; /* R_M32C_16 */
8288 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
8289 case EM_ALTERA_NIOS2
:
8291 return reloc_type
== 9; /* R_NIOS_16. */
8297 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
8298 relocation entries (possibly formerly used for SHT_GROUP sections). */
8301 is_none_reloc (unsigned int reloc_type
)
8303 switch (elf_header
.e_machine
)
8305 case EM_68K
: /* R_68K_NONE. */
8306 case EM_386
: /* R_386_NONE. */
8307 case EM_SPARC32PLUS
:
8309 case EM_SPARC
: /* R_SPARC_NONE. */
8310 case EM_MIPS
: /* R_MIPS_NONE. */
8311 case EM_PARISC
: /* R_PARISC_NONE. */
8312 case EM_ALPHA
: /* R_ALPHA_NONE. */
8313 case EM_PPC
: /* R_PPC_NONE. */
8314 case EM_PPC64
: /* R_PPC64_NONE. */
8315 case EM_ARM
: /* R_ARM_NONE. */
8316 case EM_IA_64
: /* R_IA64_NONE. */
8317 case EM_SH
: /* R_SH_NONE. */
8319 case EM_S390
: /* R_390_NONE. */
8320 case EM_CRIS
: /* R_CRIS_NONE. */
8321 case EM_X86_64
: /* R_X86_64_NONE. */
8322 case EM_MN10300
: /* R_MN10300_NONE. */
8323 case EM_M32R
: /* R_M32R_NONE. */
8324 return reloc_type
== 0;
8329 /* Uncompresses a section that was compressed using zlib, in place.
8330 This is a copy of bfd_uncompress_section_contents, in bfd/compress.c */
8333 uncompress_section_contents (unsigned char **buffer
, dwarf_size_type
*size
)
8336 /* These are just to quiet gcc. */
8341 dwarf_size_type compressed_size
= *size
;
8342 unsigned char * compressed_buffer
= *buffer
;
8343 dwarf_size_type uncompressed_size
;
8344 unsigned char * uncompressed_buffer
;
8347 dwarf_size_type header_size
= 12;
8349 /* Read the zlib header. In this case, it should be "ZLIB" followed
8350 by the uncompressed section size, 8 bytes in big-endian order. */
8351 if (compressed_size
< header_size
8352 || ! streq ((char *) compressed_buffer
, "ZLIB"))
8355 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
8356 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
8357 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
8358 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
8359 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
8360 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
8361 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
8362 uncompressed_size
+= compressed_buffer
[11];
8364 /* It is possible the section consists of several compressed
8365 buffers concatenated together, so we uncompress in a loop. */
8369 strm
.avail_in
= compressed_size
- header_size
;
8370 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
8371 strm
.avail_out
= uncompressed_size
;
8372 uncompressed_buffer
= xmalloc (uncompressed_size
);
8374 rc
= inflateInit (& strm
);
8375 while (strm
.avail_in
> 0)
8379 strm
.next_out
= ((Bytef
*) uncompressed_buffer
8380 + (uncompressed_size
- strm
.avail_out
));
8381 rc
= inflate (&strm
, Z_FINISH
);
8382 if (rc
!= Z_STREAM_END
)
8384 rc
= inflateReset (& strm
);
8386 rc
= inflateEnd (& strm
);
8388 || strm
.avail_out
!= 0)
8391 free (compressed_buffer
);
8392 *buffer
= uncompressed_buffer
;
8393 *size
= uncompressed_size
;
8397 free (uncompressed_buffer
);
8399 #endif /* HAVE_ZLIB_H */
8402 /* Apply relocations to a debug section. */
8405 debug_apply_relocations (void *file
,
8406 Elf_Internal_Shdr
*section
,
8407 unsigned char *start
)
8409 Elf_Internal_Shdr
*relsec
;
8410 unsigned char *end
= start
+ section
->sh_size
;
8412 if (elf_header
.e_type
!= ET_REL
)
8415 /* Find the reloc section associated with the debug section. */
8416 for (relsec
= section_headers
;
8417 relsec
< section_headers
+ elf_header
.e_shnum
;
8420 bfd_boolean is_rela
;
8421 unsigned long num_relocs
;
8422 Elf_Internal_Rela
*relocs
, *rp
;
8423 Elf_Internal_Shdr
*symsec
;
8424 Elf_Internal_Sym
*symtab
;
8425 Elf_Internal_Sym
*sym
;
8427 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8428 || relsec
->sh_info
>= elf_header
.e_shnum
8429 || section_headers
+ relsec
->sh_info
!= section
8430 || relsec
->sh_size
== 0
8431 || relsec
->sh_link
>= elf_header
.e_shnum
)
8434 is_rela
= relsec
->sh_type
== SHT_RELA
;
8438 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8439 & relocs
, & num_relocs
))
8444 if (!slurp_rel_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8445 & relocs
, & num_relocs
))
8449 /* SH uses RELA but uses in place value instead of the addend field. */
8450 if (elf_header
.e_machine
== EM_SH
)
8453 symsec
= section_headers
+ relsec
->sh_link
;
8454 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
8456 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
8459 unsigned int reloc_type
;
8460 unsigned int reloc_size
;
8461 unsigned char * loc
;
8463 reloc_type
= get_reloc_type (rp
->r_info
);
8465 if (is_none_reloc (reloc_type
))
8468 if (is_32bit_abs_reloc (reloc_type
)
8469 || is_32bit_pcrel_reloc (reloc_type
))
8471 else if (is_64bit_abs_reloc (reloc_type
)
8472 || is_64bit_pcrel_reloc (reloc_type
))
8474 else if (is_16bit_abs_reloc (reloc_type
))
8478 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
8479 reloc_type
, SECTION_NAME (section
));
8483 loc
= start
+ rp
->r_offset
;
8484 if ((loc
+ reloc_size
) > end
)
8486 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
8487 (unsigned long) rp
->r_offset
,
8488 SECTION_NAME (section
));
8492 sym
= symtab
+ get_reloc_symindex (rp
->r_info
);
8494 /* If the reloc has a symbol associated with it,
8495 make sure that it is of an appropriate type. */
8497 && ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
8498 /* Relocations against symbols without type can happen.
8499 Gcc -feliminate-dwarf2-dups may generate symbols
8500 without type for debug info. */
8501 && ELF_ST_TYPE (sym
->st_info
) != STT_NOTYPE
8502 /* Relocations against object symbols can happen,
8503 eg when referencing a global array. For an
8504 example of this see the _clz.o binary in libgcc.a. */
8505 && ELF_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
8507 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
8508 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
8509 (long int)(rp
- relocs
),
8510 SECTION_NAME (relsec
));
8514 addend
= is_rela
? rp
->r_addend
: byte_get (loc
, reloc_size
);
8516 if (is_32bit_pcrel_reloc (reloc_type
)
8517 || is_64bit_pcrel_reloc (reloc_type
))
8519 /* On HPPA, all pc-relative relocations are biased by 8. */
8520 if (elf_header
.e_machine
== EM_PARISC
)
8522 byte_put (loc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
8526 byte_put (loc
, addend
+ sym
->st_value
, reloc_size
);
8536 load_specific_debug_section (enum dwarf_section_display_enum debug
,
8537 Elf_Internal_Shdr
*sec
, void *file
)
8539 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
8541 int section_is_compressed
;
8543 /* If it is already loaded, do nothing. */
8544 if (section
->start
!= NULL
)
8547 section_is_compressed
= section
->name
== section
->compressed_name
;
8549 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
8550 section
->address
= sec
->sh_addr
;
8551 section
->size
= sec
->sh_size
;
8552 section
->start
= get_data (NULL
, file
, sec
->sh_offset
, 1,
8554 if (section
->start
== NULL
)
8557 if (section_is_compressed
)
8558 if (! uncompress_section_contents (§ion
->start
, §ion
->size
))
8561 if (debug_displays
[debug
].relocate
)
8562 debug_apply_relocations (file
, sec
, section
->start
);
8568 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
8570 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
8571 Elf_Internal_Shdr
*sec
;
8573 /* Locate the debug section. */
8574 sec
= find_section (section
->uncompressed_name
);
8576 section
->name
= section
->uncompressed_name
;
8579 sec
= find_section (section
->compressed_name
);
8581 section
->name
= section
->compressed_name
;
8586 return load_specific_debug_section (debug
, sec
, file
);
8590 free_debug_section (enum dwarf_section_display_enum debug
)
8592 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
8594 if (section
->start
== NULL
)
8597 free ((char *) section
->start
);
8598 section
->start
= NULL
;
8599 section
->address
= 0;
8604 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
8606 char *name
= SECTION_NAME (section
);
8607 bfd_size_type length
;
8609 enum dwarf_section_display_enum i
;
8611 length
= section
->sh_size
;
8614 printf (_("\nSection '%s' has no debugging data.\n"), name
);
8618 if (const_strneq (name
, ".gnu.linkonce.wi."))
8619 name
= ".debug_info";
8621 /* See if we know how to display the contents of this section. */
8622 for (i
= 0; i
< max
; i
++)
8623 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
8624 || streq (debug_displays
[i
].section
.compressed_name
, name
))
8626 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
8627 int secondary
= (section
!= find_section (name
));
8630 free_debug_section (i
);
8632 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
))
8633 sec
->name
= sec
->uncompressed_name
;
8635 sec
->name
= sec
->compressed_name
;
8636 if (load_specific_debug_section (i
, section
, file
))
8638 result
&= debug_displays
[i
].display (sec
, file
);
8640 if (secondary
|| (i
!= info
&& i
!= abbrev
))
8641 free_debug_section (i
);
8649 printf (_("Unrecognized debug section: %s\n"), name
);
8656 /* Set DUMP_SECTS for all sections where dumps were requested
8657 based on section name. */
8660 initialise_dumps_byname (void)
8662 struct dump_list_entry
*cur
;
8664 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
8669 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
8670 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
8672 request_dump_bynumber (i
, cur
->type
);
8677 warn (_("Section '%s' was not dumped because it does not exist!\n"),
8683 process_section_contents (FILE *file
)
8685 Elf_Internal_Shdr
*section
;
8691 initialise_dumps_byname ();
8693 for (i
= 0, section
= section_headers
;
8694 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
8697 #ifdef SUPPORT_DISASSEMBLY
8698 if (dump_sects
[i
] & DISASS_DUMP
)
8699 disassemble_section (section
, file
);
8701 if (dump_sects
[i
] & HEX_DUMP
)
8702 dump_section_as_bytes (section
, file
);
8704 if (dump_sects
[i
] & DEBUG_DUMP
)
8705 display_debug_section (section
, file
);
8707 if (dump_sects
[i
] & STRING_DUMP
)
8708 dump_section_as_strings (section
, file
);
8711 /* Check to see if the user requested a
8712 dump of a section that does not exist. */
8713 while (i
++ < num_dump_sects
)
8715 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
8719 process_mips_fpe_exception (int mask
)
8724 if (mask
& OEX_FPU_INEX
)
8725 fputs ("INEX", stdout
), first
= 0;
8726 if (mask
& OEX_FPU_UFLO
)
8727 printf ("%sUFLO", first
? "" : "|"), first
= 0;
8728 if (mask
& OEX_FPU_OFLO
)
8729 printf ("%sOFLO", first
? "" : "|"), first
= 0;
8730 if (mask
& OEX_FPU_DIV0
)
8731 printf ("%sDIV0", first
? "" : "|"), first
= 0;
8732 if (mask
& OEX_FPU_INVAL
)
8733 printf ("%sINVAL", first
? "" : "|");
8736 fputs ("0", stdout
);
8739 /* ARM EABI attributes section. */
8744 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
8747 } arm_attr_public_tag
;
8749 static const char *arm_attr_tag_CPU_arch
[] =
8750 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
8751 "v6K", "v7", "v6-M", "v6S-M"};
8752 static const char *arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
8753 static const char *arm_attr_tag_THUMB_ISA_use
[] =
8754 {"No", "Thumb-1", "Thumb-2"};
8755 static const char *arm_attr_tag_VFP_arch
[] =
8756 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16"};
8757 static const char *arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
8758 static const char *arm_attr_tag_Advanced_SIMD_arch
[] = {"No", "NEONv1"};
8759 static const char *arm_attr_tag_PCS_config
[] =
8760 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
8761 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
8762 static const char *arm_attr_tag_ABI_PCS_R9_use
[] =
8763 {"V6", "SB", "TLS", "Unused"};
8764 static const char *arm_attr_tag_ABI_PCS_RW_data
[] =
8765 {"Absolute", "PC-relative", "SB-relative", "None"};
8766 static const char *arm_attr_tag_ABI_PCS_RO_data
[] =
8767 {"Absolute", "PC-relative", "None"};
8768 static const char *arm_attr_tag_ABI_PCS_GOT_use
[] =
8769 {"None", "direct", "GOT-indirect"};
8770 static const char *arm_attr_tag_ABI_PCS_wchar_t
[] =
8771 {"None", "??? 1", "2", "??? 3", "4"};
8772 static const char *arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
8773 static const char *arm_attr_tag_ABI_FP_denormal
[] =
8774 {"Unused", "Needed", "Sign only"};
8775 static const char *arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
8776 static const char *arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
8777 static const char *arm_attr_tag_ABI_FP_number_model
[] =
8778 {"Unused", "Finite", "RTABI", "IEEE 754"};
8779 static const char *arm_attr_tag_ABI_align8_needed
[] = {"No", "Yes", "4-byte"};
8780 static const char *arm_attr_tag_ABI_align8_preserved
[] =
8781 {"No", "Yes, except leaf SP", "Yes"};
8782 static const char *arm_attr_tag_ABI_enum_size
[] =
8783 {"Unused", "small", "int", "forced to int"};
8784 static const char *arm_attr_tag_ABI_HardFP_use
[] =
8785 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
8786 static const char *arm_attr_tag_ABI_VFP_args
[] =
8787 {"AAPCS", "VFP registers", "custom"};
8788 static const char *arm_attr_tag_ABI_WMMX_args
[] =
8789 {"AAPCS", "WMMX registers", "custom"};
8790 static const char *arm_attr_tag_ABI_optimization_goals
[] =
8791 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8792 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
8793 static const char *arm_attr_tag_ABI_FP_optimization_goals
[] =
8794 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8795 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
8796 static const char *arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
8797 static const char *arm_attr_tag_VFP_HP_extension
[] =
8798 {"Not Allowed", "Allowed"};
8799 static const char *arm_attr_tag_ABI_FP_16bit_format
[] =
8800 {"None", "IEEE 754", "Alternative Format"};
8801 static const char *arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
8802 static const char *arm_attr_tag_Virtualization_use
[] =
8803 {"Not Allowed", "Allowed"};
8804 static const char *arm_attr_tag_MPextension_use
[] = {"Not Allowed", "Allowed"};
8806 #define LOOKUP(id, name) \
8807 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
8808 static arm_attr_public_tag arm_attr_public_tags
[] =
8810 {4, "CPU_raw_name", 1, NULL
},
8811 {5, "CPU_name", 1, NULL
},
8812 LOOKUP(6, CPU_arch
),
8813 {7, "CPU_arch_profile", 0, NULL
},
8814 LOOKUP(8, ARM_ISA_use
),
8815 LOOKUP(9, THUMB_ISA_use
),
8816 LOOKUP(10, VFP_arch
),
8817 LOOKUP(11, WMMX_arch
),
8818 LOOKUP(12, Advanced_SIMD_arch
),
8819 LOOKUP(13, PCS_config
),
8820 LOOKUP(14, ABI_PCS_R9_use
),
8821 LOOKUP(15, ABI_PCS_RW_data
),
8822 LOOKUP(16, ABI_PCS_RO_data
),
8823 LOOKUP(17, ABI_PCS_GOT_use
),
8824 LOOKUP(18, ABI_PCS_wchar_t
),
8825 LOOKUP(19, ABI_FP_rounding
),
8826 LOOKUP(20, ABI_FP_denormal
),
8827 LOOKUP(21, ABI_FP_exceptions
),
8828 LOOKUP(22, ABI_FP_user_exceptions
),
8829 LOOKUP(23, ABI_FP_number_model
),
8830 LOOKUP(24, ABI_align8_needed
),
8831 LOOKUP(25, ABI_align8_preserved
),
8832 LOOKUP(26, ABI_enum_size
),
8833 LOOKUP(27, ABI_HardFP_use
),
8834 LOOKUP(28, ABI_VFP_args
),
8835 LOOKUP(29, ABI_WMMX_args
),
8836 LOOKUP(30, ABI_optimization_goals
),
8837 LOOKUP(31, ABI_FP_optimization_goals
),
8838 {32, "compatibility", 0, NULL
},
8839 LOOKUP(34, CPU_unaligned_access
),
8840 LOOKUP(36, VFP_HP_extension
),
8841 LOOKUP(38, ABI_FP_16bit_format
),
8842 {64, "nodefaults", 0, NULL
},
8843 {65, "also_compatible_with", 0, NULL
},
8844 LOOKUP(66, T2EE_use
),
8845 {67, "conformance", 1, NULL
},
8846 LOOKUP(68, Virtualization_use
),
8847 LOOKUP(70, MPextension_use
)
8851 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
8854 read_uleb128 (unsigned char *p
, unsigned int *plen
)
8868 val
|= ((unsigned int)c
& 0x7f) << shift
;
8877 static unsigned char *
8878 display_arm_attribute (unsigned char *p
)
8883 arm_attr_public_tag
*attr
;
8887 tag
= read_uleb128 (p
, &len
);
8890 for (i
= 0; i
< ARRAY_SIZE(arm_attr_public_tags
); i
++)
8892 if (arm_attr_public_tags
[i
].tag
== tag
)
8894 attr
= &arm_attr_public_tags
[i
];
8901 printf (" Tag_%s: ", attr
->name
);
8907 case 7: /* Tag_CPU_arch_profile. */
8908 val
= read_uleb128 (p
, &len
);
8912 case 0: printf ("None\n"); break;
8913 case 'A': printf ("Application\n"); break;
8914 case 'R': printf ("Realtime\n"); break;
8915 case 'M': printf ("Microcontroller\n"); break;
8916 default: printf ("??? (%d)\n", val
); break;
8920 case 32: /* Tag_compatibility. */
8921 val
= read_uleb128 (p
, &len
);
8923 printf ("flag = %d, vendor = %s\n", val
, p
);
8924 p
+= strlen((char *)p
) + 1;
8927 case 64: /* Tag_nodefaults. */
8932 case 65: /* Tag_also_compatible_with. */
8933 val
= read_uleb128 (p
, &len
);
8935 if (val
== 6 /* Tag_CPU_arch. */)
8937 val
= read_uleb128 (p
, &len
);
8939 if ((unsigned int)val
>= ARRAY_SIZE(arm_attr_tag_CPU_arch
))
8940 printf ("??? (%d)\n", val
);
8942 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
8946 while (*(p
++) != '\0' /* NUL terminator. */);
8960 assert (attr
->type
& 0x80);
8961 val
= read_uleb128 (p
, &len
);
8963 type
= attr
->type
& 0x7f;
8965 printf ("??? (%d)\n", val
);
8967 printf ("%s\n", attr
->table
[val
]);
8974 type
= 1; /* String. */
8976 type
= 2; /* uleb128. */
8977 printf (" Tag_unknown_%d: ", tag
);
8982 printf ("\"%s\"\n", p
);
8983 p
+= strlen((char *)p
) + 1;
8987 val
= read_uleb128 (p
, &len
);
8989 printf ("%d (0x%x)\n", val
, val
);
8995 static unsigned char *
8996 display_gnu_attribute (unsigned char * p
,
8997 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
9004 tag
= read_uleb128 (p
, &len
);
9007 /* Tag_compatibility is the only generic GNU attribute defined at
9011 val
= read_uleb128 (p
, &len
);
9013 printf ("flag = %d, vendor = %s\n", val
, p
);
9014 p
+= strlen ((char *) p
) + 1;
9018 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
9019 return display_proc_gnu_attribute (p
, tag
);
9022 type
= 1; /* String. */
9024 type
= 2; /* uleb128. */
9025 printf (" Tag_unknown_%d: ", tag
);
9029 printf ("\"%s\"\n", p
);
9030 p
+= strlen ((char *) p
) + 1;
9034 val
= read_uleb128 (p
, &len
);
9036 printf ("%d (0x%x)\n", val
, val
);
9042 static unsigned char *
9043 display_power_gnu_attribute (unsigned char *p
, int tag
)
9049 if (tag
== Tag_GNU_Power_ABI_FP
)
9051 val
= read_uleb128 (p
, &len
);
9053 printf (" Tag_GNU_Power_ABI_FP: ");
9058 printf ("Hard or soft float\n");
9061 printf ("Hard float\n");
9064 printf ("Soft float\n");
9067 printf ("Single-precision hard float\n");
9070 printf ("??? (%d)\n", val
);
9076 if (tag
== Tag_GNU_Power_ABI_Vector
)
9078 val
= read_uleb128 (p
, &len
);
9080 printf (" Tag_GNU_Power_ABI_Vector: ");
9087 printf ("Generic\n");
9090 printf ("AltiVec\n");
9096 printf ("??? (%d)\n", val
);
9102 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
9104 val
= read_uleb128 (p
, &len
);
9106 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
9116 printf ("Memory\n");
9119 printf ("??? (%d)\n", val
);
9126 type
= 1; /* String. */
9128 type
= 2; /* uleb128. */
9129 printf (" Tag_unknown_%d: ", tag
);
9133 printf ("\"%s\"\n", p
);
9134 p
+= strlen ((char *) p
) + 1;
9138 val
= read_uleb128 (p
, &len
);
9140 printf ("%d (0x%x)\n", val
, val
);
9146 static unsigned char *
9147 display_mips_gnu_attribute (unsigned char *p
, int tag
)
9153 if (tag
== Tag_GNU_MIPS_ABI_FP
)
9155 val
= read_uleb128 (p
, &len
);
9157 printf (" Tag_GNU_MIPS_ABI_FP: ");
9162 printf ("Hard or soft float\n");
9165 printf ("Hard float (-mdouble-float)\n");
9168 printf ("Hard float (-msingle-float)\n");
9171 printf ("Soft float\n");
9174 printf ("64-bit float (-mips32r2 -mfp64)\n");
9177 printf ("??? (%d)\n", val
);
9184 type
= 1; /* String. */
9186 type
= 2; /* uleb128. */
9187 printf (" Tag_unknown_%d: ", tag
);
9191 printf ("\"%s\"\n", p
);
9192 p
+= strlen ((char *) p
) + 1;
9196 val
= read_uleb128 (p
, &len
);
9198 printf ("%d (0x%x)\n", val
, val
);
9205 process_attributes (FILE * file
,
9206 const char * public_name
,
9207 unsigned int proc_type
,
9208 unsigned char * (* display_pub_attribute
) (unsigned char *),
9209 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
9211 Elf_Internal_Shdr
*sect
;
9212 unsigned char *contents
;
9215 bfd_vma section_len
;
9219 /* Find the section header so that we get the size. */
9220 for (i
= 0, sect
= section_headers
;
9221 i
< elf_header
.e_shnum
;
9224 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
9227 contents
= get_data (NULL
, file
, sect
->sh_offset
, 1, sect
->sh_size
,
9229 if (contents
== NULL
)
9235 len
= sect
->sh_size
- 1;
9241 bfd_boolean public_section
;
9242 bfd_boolean gnu_section
;
9244 section_len
= byte_get (p
, 4);
9247 if (section_len
> len
)
9249 printf (_("ERROR: Bad section length (%d > %d)\n"),
9250 (int) section_len
, (int) len
);
9255 printf ("Attribute Section: %s\n", p
);
9257 if (public_name
&& streq ((char *) p
, public_name
))
9258 public_section
= TRUE
;
9260 public_section
= FALSE
;
9262 if (streq ((char *) p
, "gnu"))
9265 gnu_section
= FALSE
;
9267 namelen
= strlen ((char *) p
) + 1;
9269 section_len
-= namelen
+ 4;
9271 while (section_len
> 0)
9277 size
= byte_get (p
, 4);
9278 if (size
> section_len
)
9280 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
9281 (int) size
, (int) section_len
);
9285 section_len
-= size
;
9292 printf ("File Attributes\n");
9295 printf ("Section Attributes:");
9298 printf ("Symbol Attributes:");
9304 val
= read_uleb128 (p
, &i
);
9308 printf (" %d", val
);
9313 printf ("Unknown tag: %d\n", tag
);
9314 public_section
= FALSE
;
9321 p
= display_pub_attribute (p
);
9323 else if (gnu_section
)
9326 p
= display_gnu_attribute (p
,
9327 display_proc_gnu_attribute
);
9331 /* ??? Do something sensible, like dump hex. */
9332 printf (" Unknown section contexts\n");
9339 printf (_("Unknown format '%c'\n"), *p
);
9347 process_arm_specific (FILE *file
)
9349 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
9350 display_arm_attribute
, NULL
);
9354 process_power_specific (FILE *file
)
9356 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9357 display_power_gnu_attribute
);
9360 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
9361 Print the Address, Access and Initial fields of an entry at VMA ADDR
9362 and return the VMA of the next entry. */
9365 print_mips_got_entry (unsigned char *data
, bfd_vma pltgot
, bfd_vma addr
)
9368 print_vma (addr
, LONG_HEX
);
9370 if (addr
< pltgot
+ 0xfff0)
9371 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
9373 printf ("%10s", "");
9376 printf ("%*s", is_32bit_elf
? 8 : 16, "<unknown>");
9381 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
9382 print_vma (entry
, LONG_HEX
);
9384 return addr
+ (is_32bit_elf
? 4 : 8);
9387 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
9388 PLTGOT. Print the Address and Initial fields of an entry at VMA
9389 ADDR and return the VMA of the next entry. */
9392 print_mips_pltgot_entry (unsigned char *data
, bfd_vma pltgot
, bfd_vma addr
)
9395 print_vma (addr
, LONG_HEX
);
9398 printf ("%*s", is_32bit_elf
? 8 : 16, "<unknown>");
9403 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
9404 print_vma (entry
, LONG_HEX
);
9406 return addr
+ (is_32bit_elf
? 4 : 8);
9410 process_mips_specific (FILE *file
)
9412 Elf_Internal_Dyn
*entry
;
9413 size_t liblist_offset
= 0;
9414 size_t liblistno
= 0;
9415 size_t conflictsno
= 0;
9416 size_t options_offset
= 0;
9417 size_t conflicts_offset
= 0;
9418 size_t pltrelsz
= 0;
9421 bfd_vma mips_pltgot
= 0;
9423 bfd_vma local_gotno
= 0;
9425 bfd_vma symtabno
= 0;
9427 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9428 display_mips_gnu_attribute
);
9430 /* We have a lot of special sections. Thanks SGI! */
9431 if (dynamic_section
== NULL
)
9432 /* No information available. */
9435 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
9436 switch (entry
->d_tag
)
9438 case DT_MIPS_LIBLIST
:
9440 = offset_from_vma (file
, entry
->d_un
.d_val
,
9441 liblistno
* sizeof (Elf32_External_Lib
));
9443 case DT_MIPS_LIBLISTNO
:
9444 liblistno
= entry
->d_un
.d_val
;
9446 case DT_MIPS_OPTIONS
:
9447 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9449 case DT_MIPS_CONFLICT
:
9451 = offset_from_vma (file
, entry
->d_un
.d_val
,
9452 conflictsno
* sizeof (Elf32_External_Conflict
));
9454 case DT_MIPS_CONFLICTNO
:
9455 conflictsno
= entry
->d_un
.d_val
;
9458 pltgot
= entry
->d_un
.d_ptr
;
9460 case DT_MIPS_LOCAL_GOTNO
:
9461 local_gotno
= entry
->d_un
.d_val
;
9463 case DT_MIPS_GOTSYM
:
9464 gotsym
= entry
->d_un
.d_val
;
9466 case DT_MIPS_SYMTABNO
:
9467 symtabno
= entry
->d_un
.d_val
;
9469 case DT_MIPS_PLTGOT
:
9470 mips_pltgot
= entry
->d_un
.d_ptr
;
9473 pltrel
= entry
->d_un
.d_val
;
9476 pltrelsz
= entry
->d_un
.d_val
;
9479 jmprel
= entry
->d_un
.d_ptr
;
9485 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9487 Elf32_External_Lib
*elib
;
9490 elib
= get_data (NULL
, file
, liblist_offset
,
9491 liblistno
, sizeof (Elf32_External_Lib
),
9495 printf ("\nSection '.liblist' contains %lu entries:\n",
9496 (unsigned long) liblistno
);
9497 fputs (" Library Time Stamp Checksum Version Flags\n",
9500 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9507 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9508 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9509 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9510 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9511 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9513 tmp
= gmtime (&time
);
9514 snprintf (timebuf
, sizeof (timebuf
),
9515 "%04u-%02u-%02uT%02u:%02u:%02u",
9516 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9517 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9519 printf ("%3lu: ", (unsigned long) cnt
);
9520 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
9521 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
9523 printf ("<corrupt: %9ld>", liblist
.l_name
);
9524 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9527 if (liblist
.l_flags
== 0)
9538 { " EXACT_MATCH", LL_EXACT_MATCH
},
9539 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9540 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9541 { " EXPORTS", LL_EXPORTS
},
9542 { " DELAY_LOAD", LL_DELAY_LOAD
},
9543 { " DELTA", LL_DELTA
}
9545 int flags
= liblist
.l_flags
;
9548 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
9549 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9551 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9552 flags
^= l_flags_vals
[fcnt
].bit
;
9555 printf (" %#x", (unsigned int) flags
);
9565 if (options_offset
!= 0)
9567 Elf_External_Options
*eopt
;
9568 Elf_Internal_Shdr
*sect
= section_headers
;
9569 Elf_Internal_Options
*iopt
;
9570 Elf_Internal_Options
*option
;
9574 /* Find the section header so that we get the size. */
9575 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9578 eopt
= get_data (NULL
, file
, options_offset
, 1, sect
->sh_size
,
9582 iopt
= cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (*iopt
));
9585 error (_("Out of memory\n"));
9592 while (offset
< sect
->sh_size
)
9594 Elf_External_Options
*eoption
;
9596 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9598 option
->kind
= BYTE_GET (eoption
->kind
);
9599 option
->size
= BYTE_GET (eoption
->size
);
9600 option
->section
= BYTE_GET (eoption
->section
);
9601 option
->info
= BYTE_GET (eoption
->info
);
9603 offset
+= option
->size
;
9609 printf (_("\nSection '%s' contains %d entries:\n"),
9610 SECTION_NAME (sect
), cnt
);
9618 switch (option
->kind
)
9621 /* This shouldn't happen. */
9622 printf (" NULL %d %lx", option
->section
, option
->info
);
9625 printf (" REGINFO ");
9626 if (elf_header
.e_machine
== EM_MIPS
)
9629 Elf32_External_RegInfo
*ereg
;
9630 Elf32_RegInfo reginfo
;
9632 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9633 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9634 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9635 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9636 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9637 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9638 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9640 printf ("GPR %08lx GP 0x%lx\n",
9642 (unsigned long) reginfo
.ri_gp_value
);
9643 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9644 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9645 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9650 Elf64_External_RegInfo
*ereg
;
9651 Elf64_Internal_RegInfo reginfo
;
9653 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9654 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9655 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9656 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9657 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9658 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9659 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9661 printf ("GPR %08lx GP 0x",
9662 reginfo
.ri_gprmask
);
9663 printf_vma (reginfo
.ri_gp_value
);
9666 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9667 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9668 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9672 case ODK_EXCEPTIONS
:
9673 fputs (" EXCEPTIONS fpe_min(", stdout
);
9674 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9675 fputs (") fpe_max(", stdout
);
9676 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9677 fputs (")", stdout
);
9679 if (option
->info
& OEX_PAGE0
)
9680 fputs (" PAGE0", stdout
);
9681 if (option
->info
& OEX_SMM
)
9682 fputs (" SMM", stdout
);
9683 if (option
->info
& OEX_FPDBUG
)
9684 fputs (" FPDBUG", stdout
);
9685 if (option
->info
& OEX_DISMISS
)
9686 fputs (" DISMISS", stdout
);
9689 fputs (" PAD ", stdout
);
9690 if (option
->info
& OPAD_PREFIX
)
9691 fputs (" PREFIX", stdout
);
9692 if (option
->info
& OPAD_POSTFIX
)
9693 fputs (" POSTFIX", stdout
);
9694 if (option
->info
& OPAD_SYMBOL
)
9695 fputs (" SYMBOL", stdout
);
9698 fputs (" HWPATCH ", stdout
);
9699 if (option
->info
& OHW_R4KEOP
)
9700 fputs (" R4KEOP", stdout
);
9701 if (option
->info
& OHW_R8KPFETCH
)
9702 fputs (" R8KPFETCH", stdout
);
9703 if (option
->info
& OHW_R5KEOP
)
9704 fputs (" R5KEOP", stdout
);
9705 if (option
->info
& OHW_R5KCVTL
)
9706 fputs (" R5KCVTL", stdout
);
9709 fputs (" FILL ", stdout
);
9710 /* XXX Print content of info word? */
9713 fputs (" TAGS ", stdout
);
9714 /* XXX Print content of info word? */
9717 fputs (" HWAND ", stdout
);
9718 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9719 fputs (" R4KEOP_CHECKED", stdout
);
9720 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9721 fputs (" R4KEOP_CLEAN", stdout
);
9724 fputs (" HWOR ", stdout
);
9725 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9726 fputs (" R4KEOP_CHECKED", stdout
);
9727 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9728 fputs (" R4KEOP_CLEAN", stdout
);
9731 printf (" GP_GROUP %#06lx self-contained %#06lx",
9732 option
->info
& OGP_GROUP
,
9733 (option
->info
& OGP_SELF
) >> 16);
9736 printf (" IDENT %#06lx self-contained %#06lx",
9737 option
->info
& OGP_GROUP
,
9738 (option
->info
& OGP_SELF
) >> 16);
9741 /* This shouldn't happen. */
9742 printf (" %3d ??? %d %lx",
9743 option
->kind
, option
->section
, option
->info
);
9747 len
= sizeof (*eopt
);
9748 while (len
< option
->size
)
9749 if (((char *) option
)[len
] >= ' '
9750 && ((char *) option
)[len
] < 0x7f)
9751 printf ("%c", ((char *) option
)[len
++]);
9753 printf ("\\%03o", ((char *) option
)[len
++]);
9755 fputs ("\n", stdout
);
9763 if (conflicts_offset
!= 0 && conflictsno
!= 0)
9765 Elf32_Conflict
*iconf
;
9768 if (dynamic_symbols
== NULL
)
9770 error (_("conflict list found without a dynamic symbol table\n"));
9774 iconf
= cmalloc (conflictsno
, sizeof (*iconf
));
9777 error (_("Out of memory\n"));
9783 Elf32_External_Conflict
*econf32
;
9785 econf32
= get_data (NULL
, file
, conflicts_offset
,
9786 conflictsno
, sizeof (*econf32
), _("conflict"));
9790 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9791 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
9797 Elf64_External_Conflict
*econf64
;
9799 econf64
= get_data (NULL
, file
, conflicts_offset
,
9800 conflictsno
, sizeof (*econf64
), _("conflict"));
9804 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9805 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
9810 printf (_("\nSection '.conflict' contains %lu entries:\n"),
9811 (unsigned long) conflictsno
);
9812 puts (_(" Num: Index Value Name"));
9814 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9816 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
9818 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
9819 print_vma (psym
->st_value
, FULL_HEX
);
9821 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9822 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
9824 printf ("<corrupt: %14ld>", psym
->st_name
);
9831 if (pltgot
!= 0 && local_gotno
!= 0)
9833 bfd_vma entry
, local_end
, global_end
;
9835 unsigned char *data
;
9839 addr_size
= (is_32bit_elf
? 4 : 8);
9840 local_end
= pltgot
+ local_gotno
* addr_size
;
9841 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
9843 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
9844 data
= get_data (NULL
, file
, offset
, global_end
- pltgot
, 1, _("GOT"));
9845 printf (_("\nPrimary GOT:\n"));
9846 printf (_(" Canonical gp value: "));
9847 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
9850 printf (_(" Reserved entries:\n"));
9851 printf (_(" %*s %10s %*s Purpose\n"),
9852 addr_size
* 2, "Address", "Access",
9853 addr_size
* 2, "Initial");
9854 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9855 printf (" Lazy resolver\n");
9857 && (byte_get (data
+ entry
- pltgot
, addr_size
)
9858 >> (addr_size
* 8 - 1)) != 0)
9860 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9861 printf (" Module pointer (GNU extension)\n");
9865 if (entry
< local_end
)
9867 printf (_(" Local entries:\n"));
9868 printf (_(" %*s %10s %*s\n"),
9869 addr_size
* 2, "Address", "Access",
9870 addr_size
* 2, "Initial");
9871 while (entry
< local_end
)
9873 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9879 if (gotsym
< symtabno
)
9883 printf (_(" Global entries:\n"));
9884 printf (_(" %*s %10s %*s %*s %-7s %3s %s\n"),
9885 addr_size
* 2, "Address", "Access",
9886 addr_size
* 2, "Initial",
9887 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
9888 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
9889 for (i
= gotsym
; i
< symtabno
; i
++)
9891 Elf_Internal_Sym
*psym
;
9893 psym
= dynamic_symbols
+ i
;
9894 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9896 print_vma (psym
->st_value
, LONG_HEX
);
9897 printf (" %-7s %3s ",
9898 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
9899 get_symbol_index_type (psym
->st_shndx
));
9900 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9901 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
9903 printf ("<corrupt: %14ld>", psym
->st_name
);
9913 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
9916 size_t offset
, rel_offset
;
9917 unsigned long count
, i
;
9918 unsigned char *data
;
9919 int addr_size
, sym_width
;
9920 Elf_Internal_Rela
*rels
;
9922 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
9923 if (pltrel
== DT_RELA
)
9925 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
9930 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
9934 entry
= mips_pltgot
;
9935 addr_size
= (is_32bit_elf
? 4 : 8);
9936 end
= mips_pltgot
+ (2 + count
) * addr_size
;
9938 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
9939 data
= get_data (NULL
, file
, offset
, end
- mips_pltgot
, 1, _("PLT GOT"));
9940 printf (_("\nPLT GOT:\n\n"));
9941 printf (_(" Reserved entries:\n"));
9942 printf (_(" %*s %*s Purpose\n"),
9943 addr_size
* 2, "Address", addr_size
* 2, "Initial");
9944 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
9945 printf (" PLT lazy resolver\n");
9946 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
9947 printf (" Module pointer\n");
9950 printf (_(" Entries:\n"));
9951 printf (_(" %*s %*s %*s %-7s %3s %s\n"),
9952 addr_size
* 2, "Address",
9953 addr_size
* 2, "Initial",
9954 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
9955 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
9956 for (i
= 0; i
< count
; i
++)
9958 Elf_Internal_Sym
*psym
;
9960 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
9961 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
9963 print_vma (psym
->st_value
, LONG_HEX
);
9964 printf (" %-7s %3s ",
9965 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
9966 get_symbol_index_type (psym
->st_shndx
));
9967 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9968 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
9970 printf ("<corrupt: %14ld>", psym
->st_name
);
9984 process_gnu_liblist (FILE *file
)
9986 Elf_Internal_Shdr
*section
, *string_sec
;
9987 Elf32_External_Lib
*elib
;
9996 for (i
= 0, section
= section_headers
;
9997 i
< elf_header
.e_shnum
;
10000 switch (section
->sh_type
)
10002 case SHT_GNU_LIBLIST
:
10003 if (section
->sh_link
>= elf_header
.e_shnum
)
10006 elib
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
10011 string_sec
= section_headers
+ section
->sh_link
;
10013 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
10014 string_sec
->sh_size
, _("liblist string table"));
10015 strtab_size
= string_sec
->sh_size
;
10018 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
10024 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
10025 SECTION_NAME (section
),
10026 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
10028 puts (" Library Time Stamp Checksum Version Flags");
10030 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
10038 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
10039 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
10040 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
10041 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
10042 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
10044 tmp
= gmtime (&time
);
10045 snprintf (timebuf
, sizeof (timebuf
),
10046 "%04u-%02u-%02uT%02u:%02u:%02u",
10047 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10048 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10050 printf ("%3lu: ", (unsigned long) cnt
);
10052 printf ("%-20s", liblist
.l_name
< strtab_size
10053 ? strtab
+ liblist
.l_name
: "<corrupt>");
10055 printf ("%-20.20s", liblist
.l_name
< strtab_size
10056 ? strtab
+ liblist
.l_name
: "<corrupt>");
10057 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
10058 liblist
.l_version
, liblist
.l_flags
);
10068 static const char *
10069 get_note_type (unsigned e_type
)
10071 static char buff
[64];
10073 if (elf_header
.e_type
== ET_CORE
)
10077 return _("NT_AUXV (auxiliary vector)");
10079 return _("NT_PRSTATUS (prstatus structure)");
10081 return _("NT_FPREGSET (floating point registers)");
10083 return _("NT_PRPSINFO (prpsinfo structure)");
10084 case NT_TASKSTRUCT
:
10085 return _("NT_TASKSTRUCT (task structure)");
10087 return _("NT_PRXFPREG (user_xfpregs structure)");
10089 return _("NT_PPC_VMX (ppc Altivec registers)");
10091 return _("NT_PPC_VSX (ppc VSX registers)");
10093 return _("NT_PSTATUS (pstatus structure)");
10095 return _("NT_FPREGS (floating point registers)");
10097 return _("NT_PSINFO (psinfo structure)");
10099 return _("NT_LWPSTATUS (lwpstatus_t structure)");
10101 return _("NT_LWPSINFO (lwpsinfo_t structure)");
10102 case NT_WIN32PSTATUS
:
10103 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
10111 return _("NT_VERSION (version)");
10113 return _("NT_ARCH (architecture)");
10118 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10122 static const char *
10123 get_gnu_elf_note_type (unsigned e_type
)
10125 static char buff
[64];
10129 case NT_GNU_ABI_TAG
:
10130 return _("NT_GNU_ABI_TAG (ABI version tag)");
10132 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
10133 case NT_GNU_BUILD_ID
:
10134 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
10135 case NT_GNU_GOLD_VERSION
:
10136 return _("NT_GNU_GOLD_VERSION (gold version)");
10141 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10145 static const char *
10146 get_netbsd_elfcore_note_type (unsigned e_type
)
10148 static char buff
[64];
10150 if (e_type
== NT_NETBSDCORE_PROCINFO
)
10152 /* NetBSD core "procinfo" structure. */
10153 return _("NetBSD procinfo structure");
10156 /* As of Jan 2002 there are no other machine-independent notes
10157 defined for NetBSD core files. If the note type is less
10158 than the start of the machine-dependent note types, we don't
10161 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
10163 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10167 switch (elf_header
.e_machine
)
10169 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
10170 and PT_GETFPREGS == mach+2. */
10175 case EM_SPARC32PLUS
:
10179 case NT_NETBSDCORE_FIRSTMACH
+0:
10180 return _("PT_GETREGS (reg structure)");
10181 case NT_NETBSDCORE_FIRSTMACH
+2:
10182 return _("PT_GETFPREGS (fpreg structure)");
10188 /* On all other arch's, PT_GETREGS == mach+1 and
10189 PT_GETFPREGS == mach+3. */
10193 case NT_NETBSDCORE_FIRSTMACH
+1:
10194 return _("PT_GETREGS (reg structure)");
10195 case NT_NETBSDCORE_FIRSTMACH
+3:
10196 return _("PT_GETFPREGS (fpreg structure)");
10202 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
10203 e_type
- NT_NETBSDCORE_FIRSTMACH
);
10207 /* Note that by the ELF standard, the name field is already null byte
10208 terminated, and namesz includes the terminating null byte.
10209 I.E. the value of namesz for the name "FSF" is 4.
10211 If the value of namesz is zero, there is no name present. */
10213 process_note (Elf_Internal_Note
*pnote
)
10215 const char *name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
10218 if (pnote
->namesz
== 0)
10219 /* If there is no note name, then use the default set of
10220 note type strings. */
10221 nt
= get_note_type (pnote
->type
);
10223 else if (const_strneq (pnote
->namedata
, "GNU"))
10224 /* GNU-specific object file notes. */
10225 nt
= get_gnu_elf_note_type (pnote
->type
);
10227 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
10228 /* NetBSD-specific core file notes. */
10229 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
10231 else if (strneq (pnote
->namedata
, "SPU/", 4))
10233 /* SPU-specific core file notes. */
10234 nt
= pnote
->namedata
+ 4;
10239 /* Don't recognize this note name; just use the default set of
10240 note type strings. */
10241 nt
= get_note_type (pnote
->type
);
10243 printf (" %s\t\t0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
10249 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
10251 Elf_External_Note
*pnotes
;
10252 Elf_External_Note
*external
;
10258 pnotes
= get_data (NULL
, file
, offset
, 1, length
, _("notes"));
10264 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
10265 (unsigned long) offset
, (unsigned long) length
);
10266 printf (_(" Owner\t\tData size\tDescription\n"));
10268 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
10270 Elf_External_Note
*next
;
10271 Elf_Internal_Note inote
;
10274 inote
.type
= BYTE_GET (external
->type
);
10275 inote
.namesz
= BYTE_GET (external
->namesz
);
10276 inote
.namedata
= external
->name
;
10277 inote
.descsz
= BYTE_GET (external
->descsz
);
10278 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
10279 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
10281 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
10283 if (((char *) next
) > (((char *) pnotes
) + length
))
10285 warn (_("corrupt note found at offset %lx into core notes\n"),
10286 (unsigned long) ((char *) external
- (char *) pnotes
));
10287 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
10288 inote
.type
, inote
.namesz
, inote
.descsz
);
10294 /* Verify that name is null terminated. It appears that at least
10295 one version of Linux (RedHat 6.0) generates corefiles that don't
10296 comply with the ELF spec by failing to include the null byte in
10298 if (inote
.namedata
[inote
.namesz
] != '\0')
10300 temp
= malloc (inote
.namesz
+ 1);
10304 error (_("Out of memory\n"));
10309 strncpy (temp
, inote
.namedata
, inote
.namesz
);
10310 temp
[inote
.namesz
] = 0;
10312 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
10313 inote
.namedata
= temp
;
10316 res
&= process_note (& inote
);
10331 process_corefile_note_segments (FILE *file
)
10333 Elf_Internal_Phdr
*segment
;
10337 if (! get_program_headers (file
))
10340 for (i
= 0, segment
= program_headers
;
10341 i
< elf_header
.e_phnum
;
10344 if (segment
->p_type
== PT_NOTE
)
10345 res
&= process_corefile_note_segment (file
,
10346 (bfd_vma
) segment
->p_offset
,
10347 (bfd_vma
) segment
->p_filesz
);
10354 process_note_sections (FILE *file
)
10356 Elf_Internal_Shdr
*section
;
10360 for (i
= 0, section
= section_headers
;
10361 i
< elf_header
.e_shnum
;
10363 if (section
->sh_type
== SHT_NOTE
)
10364 res
&= process_corefile_note_segment (file
,
10365 (bfd_vma
) section
->sh_offset
,
10366 (bfd_vma
) section
->sh_size
);
10372 process_notes (FILE *file
)
10374 /* If we have not been asked to display the notes then do nothing. */
10378 if (elf_header
.e_type
!= ET_CORE
)
10379 return process_note_sections (file
);
10381 /* No program headers means no NOTE segment. */
10382 if (elf_header
.e_phnum
> 0)
10383 return process_corefile_note_segments (file
);
10385 printf (_("No note segments present in the core file.\n"));
10390 process_arch_specific (FILE *file
)
10395 switch (elf_header
.e_machine
)
10398 return process_arm_specific (file
);
10400 case EM_MIPS_RS3_LE
:
10401 return process_mips_specific (file
);
10404 return process_power_specific (file
);
10413 get_file_header (FILE *file
)
10415 /* Read in the identity array. */
10416 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
10419 /* Determine how to read the rest of the header. */
10420 switch (elf_header
.e_ident
[EI_DATA
])
10422 default: /* fall through */
10423 case ELFDATANONE
: /* fall through */
10425 byte_get
= byte_get_little_endian
;
10426 byte_put
= byte_put_little_endian
;
10429 byte_get
= byte_get_big_endian
;
10430 byte_put
= byte_put_big_endian
;
10434 /* For now we only support 32 bit and 64 bit ELF files. */
10435 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
10437 /* Read in the rest of the header. */
10440 Elf32_External_Ehdr ehdr32
;
10442 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
10445 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
10446 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
10447 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
10448 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
10449 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
10450 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
10451 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
10452 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
10453 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
10454 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
10455 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
10456 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
10457 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
10461 Elf64_External_Ehdr ehdr64
;
10463 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10464 we will not be able to cope with the 64bit data found in
10465 64 ELF files. Detect this now and abort before we start
10466 overwriting things. */
10467 if (sizeof (bfd_vma
) < 8)
10469 error (_("This instance of readelf has been built without support for a\n\
10470 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10474 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
10477 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
10478 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
10479 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
10480 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
10481 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
10482 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
10483 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
10484 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
10485 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
10486 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
10487 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
10488 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
10489 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
10492 if (elf_header
.e_shoff
)
10494 /* There may be some extensions in the first section header. Don't
10495 bomb if we can't read it. */
10497 get_32bit_section_headers (file
, 1);
10499 get_64bit_section_headers (file
, 1);
10505 /* Process one ELF object file according to the command line options.
10506 This file may actually be stored in an archive. The file is
10507 positioned at the start of the ELF object. */
10510 process_object (char *file_name
, FILE *file
)
10514 if (! get_file_header (file
))
10516 error (_("%s: Failed to read file header\n"), file_name
);
10520 /* Initialise per file variables. */
10521 for (i
= ARRAY_SIZE (version_info
); i
--;)
10522 version_info
[i
] = 0;
10524 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
10525 dynamic_info
[i
] = 0;
10527 /* Process the file. */
10529 printf (_("\nFile: %s\n"), file_name
);
10531 /* Initialise the dump_sects array from the cmdline_dump_sects array.
10532 Note we do this even if cmdline_dump_sects is empty because we
10533 must make sure that the dump_sets array is zeroed out before each
10534 object file is processed. */
10535 if (num_dump_sects
> num_cmdline_dump_sects
)
10536 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
10538 if (num_cmdline_dump_sects
> 0)
10540 if (num_dump_sects
== 0)
10541 /* A sneaky way of allocating the dump_sects array. */
10542 request_dump_bynumber (num_cmdline_dump_sects
, 0);
10544 assert (num_dump_sects
>= num_cmdline_dump_sects
);
10545 memcpy (dump_sects
, cmdline_dump_sects
,
10546 num_cmdline_dump_sects
* sizeof (* dump_sects
));
10549 if (! process_file_header ())
10552 if (! process_section_headers (file
))
10554 /* Without loaded section headers we cannot process lots of
10556 do_unwind
= do_version
= do_dump
= do_arch
= 0;
10558 if (! do_using_dynamic
)
10559 do_syms
= do_reloc
= 0;
10562 if (! process_section_groups (file
))
10564 /* Without loaded section groups we cannot process unwind. */
10568 if (process_program_headers (file
))
10569 process_dynamic_section (file
);
10571 process_relocs (file
);
10573 process_unwind (file
);
10575 process_symbol_table (file
);
10577 process_syminfo (file
);
10579 process_version_sections (file
);
10581 process_section_contents (file
);
10583 process_notes (file
);
10585 process_gnu_liblist (file
);
10587 process_arch_specific (file
);
10589 if (program_headers
)
10591 free (program_headers
);
10592 program_headers
= NULL
;
10595 if (section_headers
)
10597 free (section_headers
);
10598 section_headers
= NULL
;
10603 free (string_table
);
10604 string_table
= NULL
;
10605 string_table_length
= 0;
10608 if (dynamic_strings
)
10610 free (dynamic_strings
);
10611 dynamic_strings
= NULL
;
10612 dynamic_strings_length
= 0;
10615 if (dynamic_symbols
)
10617 free (dynamic_symbols
);
10618 dynamic_symbols
= NULL
;
10619 num_dynamic_syms
= 0;
10622 if (dynamic_syminfo
)
10624 free (dynamic_syminfo
);
10625 dynamic_syminfo
= NULL
;
10628 if (section_headers_groups
)
10630 free (section_headers_groups
);
10631 section_headers_groups
= NULL
;
10634 if (section_groups
)
10636 struct group_list
*g
, *next
;
10638 for (i
= 0; i
< group_count
; i
++)
10640 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
10647 free (section_groups
);
10648 section_groups
= NULL
;
10651 free_debug_memory ();
10656 /* Process an ELF archive.
10657 On entry the file is positioned just after the ARMAG string. */
10660 process_archive (char *file_name
, FILE *file
)
10662 struct ar_hdr arhdr
;
10664 unsigned long size
;
10665 unsigned long index_num
= 0;
10666 unsigned long *index_array
= NULL
;
10667 char *sym_table
= NULL
;
10668 unsigned long sym_size
= 0;
10669 char *longnames
= NULL
;
10670 unsigned long longnames_size
= 0;
10671 size_t file_name_size
;
10676 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10677 if (got
!= sizeof arhdr
)
10682 error (_("%s: failed to read archive header\n"), file_name
);
10686 /* See if this is the archive symbol table. */
10687 if (const_strneq (arhdr
.ar_name
, "/ ")
10688 || const_strneq (arhdr
.ar_name
, "/SYM64/ "))
10690 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10691 size
= size
+ (size
& 1);
10693 if (do_archive_index
)
10696 /* A buffer used to hold numbers read in from an archive index.
10697 These are always 4 bytes long and stored in big-endian format. */
10698 #define SIZEOF_AR_INDEX_NUMBERS 4
10699 unsigned char integer_buffer
[SIZEOF_AR_INDEX_NUMBERS
];
10700 unsigned char * index_buffer
;
10702 /* Check the size of the archive index. */
10703 if (size
< SIZEOF_AR_INDEX_NUMBERS
)
10705 error (_("%s: the archive index is empty\n"), file_name
);
10709 /* Read the numer of entries in the archive index. */
10710 got
= fread (integer_buffer
, 1, sizeof integer_buffer
, file
);
10711 if (got
!= sizeof (integer_buffer
))
10713 error (_("%s: failed to read archive index\n"), file_name
);
10716 index_num
= byte_get_big_endian (integer_buffer
, sizeof integer_buffer
);
10717 size
-= SIZEOF_AR_INDEX_NUMBERS
;
10719 /* Read in the archive index. */
10720 if (size
< index_num
* SIZEOF_AR_INDEX_NUMBERS
)
10722 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
10723 file_name
, index_num
);
10726 index_buffer
= malloc (index_num
* SIZEOF_AR_INDEX_NUMBERS
);
10727 if (index_buffer
== NULL
)
10729 error (_("Out of memory whilst trying to read archive symbol index\n"));
10732 got
= fread (index_buffer
, SIZEOF_AR_INDEX_NUMBERS
, index_num
, file
);
10733 if (got
!= index_num
)
10735 free (index_buffer
);
10736 error (_("%s: failed to read archive index\n"), file_name
);
10740 size
-= index_num
* SIZEOF_AR_INDEX_NUMBERS
;
10742 /* Convert the index numbers into the host's numeric format. */
10743 index_array
= malloc (index_num
* sizeof (* index_array
));
10744 if (index_array
== NULL
)
10746 free (index_buffer
);
10747 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
10751 for (i
= 0; i
< index_num
; i
++)
10752 index_array
[i
] = byte_get_big_endian ((unsigned char *)(index_buffer
+ (i
* SIZEOF_AR_INDEX_NUMBERS
)),
10753 SIZEOF_AR_INDEX_NUMBERS
);
10754 free (index_buffer
);
10756 /* The remaining space in the header is taken up by the symbol table. */
10759 error (_("%s: the archive has an index but no symbols\n"), file_name
);
10763 sym_table
= malloc (size
);
10765 if (sym_table
== NULL
)
10767 error (_("Out of memory whilst trying to read archive index symbol table\n"));
10771 got
= fread (sym_table
, 1, size
, file
);
10774 error (_("%s: failed to read archive index symbol table\n"), file_name
);
10781 if (fseek (file
, size
, SEEK_CUR
) != 0)
10783 error (_("%s: failed to skip archive symbol table\n"), file_name
);
10788 got
= fread (& arhdr
, 1, sizeof arhdr
, file
);
10789 if (got
!= sizeof arhdr
)
10797 error (_("%s: failed to read archive header following archive index\n"), file_name
);
10802 else if (do_archive_index
)
10803 printf (_("%s has no archive index\n"), file_name
);
10805 if (const_strneq (arhdr
.ar_name
, "// "))
10807 /* This is the archive string table holding long member
10810 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10811 longnames
= malloc (longnames_size
);
10812 if (longnames
== NULL
)
10814 error (_("Out of memory reading long symbol names in archive\n"));
10819 if (fread (longnames
, longnames_size
, 1, file
) != 1)
10822 error (_("%s: failed to read long symbol name string table\n"), file_name
);
10827 if ((longnames_size
& 1) != 0)
10830 got
= fread (& arhdr
, 1, sizeof arhdr
, file
);
10831 if (got
!= sizeof arhdr
)
10837 error (_("%s: failed to read archive header following long symbol names\n"), file_name
);
10844 if (do_archive_index
)
10846 if (sym_table
== NULL
)
10847 error (_("%s: unable to dump the index as none was found\n"), file_name
);
10850 unsigned int i
, j
, k
, l
;
10852 unsigned long current_pos
;
10854 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
10855 file_name
, index_num
, sym_size
);
10856 current_pos
= ftell (file
);
10858 for (i
= l
= 0; i
< index_num
; i
++)
10860 if ((i
== 0) || ((i
> 0) && (index_array
[i
] != index_array
[i
- 1])))
10862 if (fseek (file
, index_array
[i
], SEEK_SET
) != 0)
10864 error (_("%s: failed to seek to next file name\n"), file_name
);
10868 got
= fread (elf_name
, 1, 16, file
);
10871 error (_("%s: failed to read file name\n"), file_name
);
10876 if (elf_name
[0] == '/')
10878 /* We have a long name. */
10879 k
= j
= strtoul (elf_name
+ 1, NULL
, 10);
10880 while ((j
< longnames_size
) && (longnames
[j
] != '/'))
10882 longnames
[j
] = '\0';
10883 printf (_("Binary %s contains:\n"), longnames
+ k
);
10884 longnames
[j
] = '/';
10889 while ((elf_name
[j
] != '/') && (j
< 16))
10891 elf_name
[j
] = '\0';
10892 printf(_("Binary %s contains:\n"), elf_name
);
10897 error (_("%s: end of the symbol table reached before the end of the index\n"),
10901 printf ("\t%s\n", sym_table
+ l
);
10902 l
+= strlen (sym_table
+ l
) + 1;
10906 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
10909 free (index_array
);
10910 index_array
= NULL
;
10913 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
10915 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
10920 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
10921 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
10922 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
10923 && !do_section_groups
)
10924 return 0; /* Archive index only. */
10927 file_name_size
= strlen (file_name
);
10936 if (arhdr
.ar_name
[0] == '/')
10940 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
10941 if (off
>= longnames_size
)
10943 error (_("%s: invalid archive string table offset %lu\n"), file_name
, off
);
10948 name
= longnames
+ off
;
10949 nameend
= memchr (name
, '/', longnames_size
- off
);
10953 name
= arhdr
.ar_name
;
10954 nameend
= memchr (name
, '/', 16);
10957 if (nameend
== NULL
)
10959 error (_("%s: bad archive file name\n"), file_name
);
10964 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
10965 if (namealc
== NULL
)
10967 error (_("Out of memory\n"));
10972 memcpy (namealc
, file_name
, file_name_size
);
10973 namealc
[file_name_size
] = '(';
10974 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
10975 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
10976 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
10978 archive_file_offset
= ftell (file
);
10979 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10981 ret
|= process_object (namealc
, file
);
10986 (archive_file_offset
10987 + archive_file_size
10988 + (archive_file_size
& 1)),
10991 error (_("%s: failed to seek to next archive header\n"), file_name
);
10996 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10997 if (got
!= sizeof arhdr
)
11002 error (_("%s: failed to read archive header\n"), file_name
);
11009 if (index_array
!= NULL
)
11010 free (index_array
);
11011 if (sym_table
!= NULL
)
11013 if (longnames
!= NULL
)
11020 process_file (char *file_name
)
11023 struct stat statbuf
;
11024 char armag
[SARMAG
];
11027 if (stat (file_name
, &statbuf
) < 0)
11029 if (errno
== ENOENT
)
11030 error (_("'%s': No such file\n"), file_name
);
11032 error (_("Could not locate '%s'. System error message: %s\n"),
11033 file_name
, strerror (errno
));
11037 if (! S_ISREG (statbuf
.st_mode
))
11039 error (_("'%s' is not an ordinary file\n"), file_name
);
11043 file
= fopen (file_name
, "rb");
11046 error (_("Input file '%s' is not readable.\n"), file_name
);
11050 if (fread (armag
, SARMAG
, 1, file
) != 1)
11052 error (_("%s: Failed to read file's magic number\n"), file_name
);
11057 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
11058 ret
= process_archive (file_name
, file
);
11061 if (do_archive_index
)
11062 error (_("File %s is not an archive so its index cannot be displayed.\n"),
11066 archive_file_size
= archive_file_offset
= 0;
11067 ret
= process_object (file_name
, file
);
11075 #ifdef SUPPORT_DISASSEMBLY
11076 /* Needed by the i386 disassembler. For extra credit, someone could
11077 fix this so that we insert symbolic addresses here, esp for GOT/PLT
11081 print_address (unsigned int addr
, FILE *outfile
)
11083 fprintf (outfile
,"0x%8.8x", addr
);
11086 /* Needed by the i386 disassembler. */
11088 db_task_printsym (unsigned int addr
)
11090 print_address (addr
, stderr
);
11095 main (int argc
, char **argv
)
11099 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
11100 setlocale (LC_MESSAGES
, "");
11102 #if defined (HAVE_SETLOCALE)
11103 setlocale (LC_CTYPE
, "");
11105 bindtextdomain (PACKAGE
, LOCALEDIR
);
11106 textdomain (PACKAGE
);
11108 expandargv (&argc
, &argv
);
11110 parse_args (argc
, argv
);
11112 if (num_dump_sects
> 0)
11114 /* Make a copy of the dump_sects array. */
11115 cmdline_dump_sects
= malloc (num_dump_sects
* sizeof (* dump_sects
));
11116 if (cmdline_dump_sects
== NULL
)
11117 error (_("Out of memory allocating dump request table.\n"));
11120 memcpy (cmdline_dump_sects
, dump_sects
,
11121 num_dump_sects
* sizeof (* dump_sects
));
11122 num_cmdline_dump_sects
= num_dump_sects
;
11126 if (optind
< (argc
- 1))
11130 while (optind
< argc
)
11131 err
|= process_file (argv
[optind
++]);
11133 if (dump_sects
!= NULL
)
11135 if (cmdline_dump_sects
!= NULL
)
11136 free (cmdline_dump_sects
);