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
);
3044 dwarf_select_sections_by_letters (optarg
);
3047 case OPTION_DEBUG_DUMP
:
3054 dwarf_select_sections_by_names (optarg
);
3057 #ifdef SUPPORT_DISASSEMBLY
3060 section
= strtoul (optarg
, & cp
, 0);
3061 if (! *cp
&& section
>= 0)
3062 request_dump_bynumber (section
, DISASS_DUMP
);
3064 request_dump_byname (optarg
, DISASS_DUMP
);
3067 print_version (program_name
);
3076 /* xgettext:c-format */
3077 error (_("Invalid option '-%c'\n"), c
);
3084 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3085 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3086 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3087 && !do_section_groups
&& !do_archive_index
)
3091 warn (_("Nothing to do.\n"));
3097 get_elf_class (unsigned int elf_class
)
3099 static char buff
[32];
3103 case ELFCLASSNONE
: return _("none");
3104 case ELFCLASS32
: return "ELF32";
3105 case ELFCLASS64
: return "ELF64";
3107 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3113 get_data_encoding (unsigned int encoding
)
3115 static char buff
[32];
3119 case ELFDATANONE
: return _("none");
3120 case ELFDATA2LSB
: return _("2's complement, little endian");
3121 case ELFDATA2MSB
: return _("2's complement, big endian");
3123 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3128 /* Decode the data held in 'elf_header'. */
3131 process_file_header (void)
3133 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3134 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3135 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3136 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3139 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3143 init_dwarf_regnames (elf_header
.e_machine
);
3149 printf (_("ELF Header:\n"));
3150 printf (_(" Magic: "));
3151 for (i
= 0; i
< EI_NIDENT
; i
++)
3152 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3154 printf (_(" Class: %s\n"),
3155 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3156 printf (_(" Data: %s\n"),
3157 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3158 printf (_(" Version: %d %s\n"),
3159 elf_header
.e_ident
[EI_VERSION
],
3160 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3162 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3165 printf (_(" OS/ABI: %s\n"),
3166 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3167 printf (_(" ABI Version: %d\n"),
3168 elf_header
.e_ident
[EI_ABIVERSION
]);
3169 printf (_(" Type: %s\n"),
3170 get_file_type (elf_header
.e_type
));
3171 printf (_(" Machine: %s\n"),
3172 get_machine_name (elf_header
.e_machine
));
3173 printf (_(" Version: 0x%lx\n"),
3174 (unsigned long) elf_header
.e_version
);
3176 printf (_(" Entry point address: "));
3177 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3178 printf (_("\n Start of program headers: "));
3179 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3180 printf (_(" (bytes into file)\n Start of section headers: "));
3181 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3182 printf (_(" (bytes into file)\n"));
3184 printf (_(" Flags: 0x%lx%s\n"),
3185 (unsigned long) elf_header
.e_flags
,
3186 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3187 printf (_(" Size of this header: %ld (bytes)\n"),
3188 (long) elf_header
.e_ehsize
);
3189 printf (_(" Size of program headers: %ld (bytes)\n"),
3190 (long) elf_header
.e_phentsize
);
3191 printf (_(" Number of program headers: %ld\n"),
3192 (long) elf_header
.e_phnum
);
3193 printf (_(" Size of section headers: %ld (bytes)\n"),
3194 (long) elf_header
.e_shentsize
);
3195 printf (_(" Number of section headers: %ld"),
3196 (long) elf_header
.e_shnum
);
3197 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
3198 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3199 putc ('\n', stdout
);
3200 printf (_(" Section header string table index: %ld"),
3201 (long) elf_header
.e_shstrndx
);
3202 if (section_headers
!= NULL
3203 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3204 printf (" (%u)", section_headers
[0].sh_link
);
3205 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3206 printf (" <corrupt: out of range>");
3207 putc ('\n', stdout
);
3210 if (section_headers
!= NULL
)
3212 if (elf_header
.e_shnum
== SHN_UNDEF
)
3213 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3214 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3215 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3216 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3217 elf_header
.e_shstrndx
= SHN_UNDEF
;
3218 free (section_headers
);
3219 section_headers
= NULL
;
3227 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3229 Elf32_External_Phdr
*phdrs
;
3230 Elf32_External_Phdr
*external
;
3231 Elf_Internal_Phdr
*internal
;
3234 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3235 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3236 _("program headers"));
3240 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3241 i
< elf_header
.e_phnum
;
3242 i
++, internal
++, external
++)
3244 internal
->p_type
= BYTE_GET (external
->p_type
);
3245 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3246 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3247 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3248 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3249 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3250 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3251 internal
->p_align
= BYTE_GET (external
->p_align
);
3260 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3262 Elf64_External_Phdr
*phdrs
;
3263 Elf64_External_Phdr
*external
;
3264 Elf_Internal_Phdr
*internal
;
3267 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3268 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3269 _("program headers"));
3273 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3274 i
< elf_header
.e_phnum
;
3275 i
++, internal
++, external
++)
3277 internal
->p_type
= BYTE_GET (external
->p_type
);
3278 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3279 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3280 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3281 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3282 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3283 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3284 internal
->p_align
= BYTE_GET (external
->p_align
);
3292 /* Returns 1 if the program headers were read into `program_headers'. */
3295 get_program_headers (FILE *file
)
3297 Elf_Internal_Phdr
*phdrs
;
3299 /* Check cache of prior read. */
3300 if (program_headers
!= NULL
)
3303 phdrs
= cmalloc (elf_header
.e_phnum
, sizeof (Elf_Internal_Phdr
));
3307 error (_("Out of memory\n"));
3312 ? get_32bit_program_headers (file
, phdrs
)
3313 : get_64bit_program_headers (file
, phdrs
))
3315 program_headers
= phdrs
;
3323 /* Returns 1 if the program headers were loaded. */
3326 process_program_headers (FILE *file
)
3328 Elf_Internal_Phdr
*segment
;
3331 if (elf_header
.e_phnum
== 0)
3334 printf (_("\nThere are no program headers in this file.\n"));
3338 if (do_segments
&& !do_header
)
3340 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3341 printf (_("Entry point "));
3342 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3343 printf (_("\nThere are %d program headers, starting at offset "),
3344 elf_header
.e_phnum
);
3345 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3349 if (! get_program_headers (file
))
3354 if (elf_header
.e_phnum
> 1)
3355 printf (_("\nProgram Headers:\n"));
3357 printf (_("\nProgram Headers:\n"));
3361 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3364 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3368 (_(" Type Offset VirtAddr PhysAddr\n"));
3370 (_(" FileSiz MemSiz Flags Align\n"));
3377 for (i
= 0, segment
= program_headers
;
3378 i
< elf_header
.e_phnum
;
3383 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3387 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3388 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3389 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3390 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3391 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3393 (segment
->p_flags
& PF_R
? 'R' : ' '),
3394 (segment
->p_flags
& PF_W
? 'W' : ' '),
3395 (segment
->p_flags
& PF_X
? 'E' : ' '));
3396 printf ("%#lx", (unsigned long) segment
->p_align
);
3400 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3401 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3404 print_vma (segment
->p_offset
, FULL_HEX
);
3408 print_vma (segment
->p_vaddr
, FULL_HEX
);
3410 print_vma (segment
->p_paddr
, FULL_HEX
);
3413 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3414 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3417 print_vma (segment
->p_filesz
, FULL_HEX
);
3421 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3422 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3425 print_vma (segment
->p_offset
, FULL_HEX
);
3429 (segment
->p_flags
& PF_R
? 'R' : ' '),
3430 (segment
->p_flags
& PF_W
? 'W' : ' '),
3431 (segment
->p_flags
& PF_X
? 'E' : ' '));
3433 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3434 printf ("%#lx", (unsigned long) segment
->p_align
);
3437 print_vma (segment
->p_align
, PREFIX_HEX
);
3442 print_vma (segment
->p_offset
, FULL_HEX
);
3444 print_vma (segment
->p_vaddr
, FULL_HEX
);
3446 print_vma (segment
->p_paddr
, FULL_HEX
);
3448 print_vma (segment
->p_filesz
, FULL_HEX
);
3450 print_vma (segment
->p_memsz
, FULL_HEX
);
3452 (segment
->p_flags
& PF_R
? 'R' : ' '),
3453 (segment
->p_flags
& PF_W
? 'W' : ' '),
3454 (segment
->p_flags
& PF_X
? 'E' : ' '));
3455 print_vma (segment
->p_align
, HEX
);
3459 switch (segment
->p_type
)
3463 error (_("more than one dynamic segment\n"));
3465 /* By default, assume that the .dynamic section is the first
3466 section in the DYNAMIC segment. */
3467 dynamic_addr
= segment
->p_offset
;
3468 dynamic_size
= segment
->p_filesz
;
3470 /* Try to locate the .dynamic section. If there is
3471 a section header table, we can easily locate it. */
3472 if (section_headers
!= NULL
)
3474 Elf_Internal_Shdr
*sec
;
3476 sec
= find_section (".dynamic");
3477 if (sec
== NULL
|| sec
->sh_size
== 0)
3479 error (_("no .dynamic section in the dynamic segment\n"));
3483 if (sec
->sh_type
== SHT_NOBITS
)
3489 dynamic_addr
= sec
->sh_offset
;
3490 dynamic_size
= sec
->sh_size
;
3492 if (dynamic_addr
< segment
->p_offset
3493 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3494 warn (_("the .dynamic section is not contained"
3495 " within the dynamic segment\n"));
3496 else if (dynamic_addr
> segment
->p_offset
)
3497 warn (_("the .dynamic section is not the first section"
3498 " in the dynamic segment.\n"));
3503 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3505 error (_("Unable to find program interpreter name\n"));
3509 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
3511 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
3512 error (_("Internal error: failed to create format string to display program interpreter\n"));
3514 program_interpreter
[0] = 0;
3515 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
3516 error (_("Unable to read program interpreter name\n"));
3519 printf (_("\n [Requesting program interpreter: %s]"),
3520 program_interpreter
);
3526 putc ('\n', stdout
);
3529 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3531 printf (_("\n Section to Segment mapping:\n"));
3532 printf (_(" Segment Sections...\n"));
3534 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3537 Elf_Internal_Shdr
*section
;
3539 segment
= program_headers
+ i
;
3540 section
= section_headers
+ 1;
3542 printf (" %2.2d ", i
);
3544 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3546 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY(section
, segment
))
3547 printf ("%s ", SECTION_NAME (section
));
3558 /* Find the file offset corresponding to VMA by using the program headers. */
3561 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3563 Elf_Internal_Phdr
*seg
;
3565 if (! get_program_headers (file
))
3567 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3571 for (seg
= program_headers
;
3572 seg
< program_headers
+ elf_header
.e_phnum
;
3575 if (seg
->p_type
!= PT_LOAD
)
3578 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3579 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3580 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3583 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3584 (unsigned long) vma
);
3590 get_32bit_section_headers (FILE *file
, unsigned int num
)
3592 Elf32_External_Shdr
*shdrs
;
3593 Elf_Internal_Shdr
*internal
;
3596 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3597 elf_header
.e_shentsize
, num
, _("section headers"));
3601 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3603 if (section_headers
== NULL
)
3605 error (_("Out of memory\n"));
3609 for (i
= 0, internal
= section_headers
;
3613 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3614 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3615 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3616 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3617 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3618 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3619 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3620 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3621 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3622 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3631 get_64bit_section_headers (FILE *file
, unsigned int num
)
3633 Elf64_External_Shdr
*shdrs
;
3634 Elf_Internal_Shdr
*internal
;
3637 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3638 elf_header
.e_shentsize
, num
, _("section headers"));
3642 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3644 if (section_headers
== NULL
)
3646 error (_("Out of memory\n"));
3650 for (i
= 0, internal
= section_headers
;
3654 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3655 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3656 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3657 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3658 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3659 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3660 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3661 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3662 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3663 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3671 static Elf_Internal_Sym
*
3672 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3674 unsigned long number
;
3675 Elf32_External_Sym
*esyms
;
3676 Elf_External_Sym_Shndx
*shndx
;
3677 Elf_Internal_Sym
*isyms
;
3678 Elf_Internal_Sym
*psym
;
3681 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3687 if (symtab_shndx_hdr
!= NULL
3688 && (symtab_shndx_hdr
->sh_link
3689 == (unsigned long) (section
- section_headers
)))
3691 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3692 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3700 number
= section
->sh_size
/ section
->sh_entsize
;
3701 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3705 error (_("Out of memory\n"));
3712 for (j
= 0, psym
= isyms
;
3716 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3717 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3718 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3719 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3720 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3722 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3723 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3724 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3725 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3726 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3736 static Elf_Internal_Sym
*
3737 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3739 unsigned long number
;
3740 Elf64_External_Sym
*esyms
;
3741 Elf_External_Sym_Shndx
*shndx
;
3742 Elf_Internal_Sym
*isyms
;
3743 Elf_Internal_Sym
*psym
;
3746 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3752 if (symtab_shndx_hdr
!= NULL
3753 && (symtab_shndx_hdr
->sh_link
3754 == (unsigned long) (section
- section_headers
)))
3756 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3757 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3765 number
= section
->sh_size
/ section
->sh_entsize
;
3766 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3770 error (_("Out of memory\n"));
3777 for (j
= 0, psym
= isyms
;
3781 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3782 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3783 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3784 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3785 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
3787 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3788 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
3789 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
3790 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3791 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3802 get_elf_section_flags (bfd_vma sh_flags
)
3804 static char buff
[1024];
3806 int field_size
= is_32bit_elf
? 8 : 16;
3807 int index
, size
= sizeof (buff
) - (field_size
+ 4 + 1);
3808 bfd_vma os_flags
= 0;
3809 bfd_vma proc_flags
= 0;
3810 bfd_vma unknown_flags
= 0;
3824 { "LINK ORDER", 10 },
3825 { "OS NONCONF", 10 },
3828 /* IA-64 specific. */
3831 /* IA-64 OpenVMS specific. */
3832 { "VMS_GLOBAL", 10 },
3833 { "VMS_OVERLAID", 12 },
3834 { "VMS_SHARED", 10 },
3835 { "VMS_VECTOR", 10 },
3836 { "VMS_ALLOC_64BIT", 15 },
3837 { "VMS_PROTECTED", 13}
3840 if (do_section_details
)
3842 sprintf (buff
, "[%*.*lx]: ",
3843 field_size
, field_size
, (unsigned long) sh_flags
);
3844 p
+= field_size
+ 4;
3851 flag
= sh_flags
& - sh_flags
;
3854 if (do_section_details
)
3858 case SHF_WRITE
: index
= 0; break;
3859 case SHF_ALLOC
: index
= 1; break;
3860 case SHF_EXECINSTR
: index
= 2; break;
3861 case SHF_MERGE
: index
= 3; break;
3862 case SHF_STRINGS
: index
= 4; break;
3863 case SHF_INFO_LINK
: index
= 5; break;
3864 case SHF_LINK_ORDER
: index
= 6; break;
3865 case SHF_OS_NONCONFORMING
: index
= 7; break;
3866 case SHF_GROUP
: index
= 8; break;
3867 case SHF_TLS
: index
= 9; break;
3871 if (elf_header
.e_machine
== EM_IA_64
)
3873 if (flag
== SHF_IA_64_SHORT
)
3875 else if (flag
== SHF_IA_64_NORECOV
)
3878 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3881 case SHF_IA_64_VMS_GLOBAL
: index
= 12; break;
3882 case SHF_IA_64_VMS_OVERLAID
: index
= 13; break;
3883 case SHF_IA_64_VMS_SHARED
: index
= 14; break;
3884 case SHF_IA_64_VMS_VECTOR
: index
= 15; break;
3885 case SHF_IA_64_VMS_ALLOC_64BIT
: index
= 16; break;
3886 case SHF_IA_64_VMS_PROTECTED
: index
= 17; break;
3896 if (p
!= buff
+ field_size
+ 4)
3898 if (size
< (10 + 2))
3905 size
-= flags
[index
].len
;
3906 p
= stpcpy (p
, flags
[index
].str
);
3908 else if (flag
& SHF_MASKOS
)
3910 else if (flag
& SHF_MASKPROC
)
3913 unknown_flags
|= flag
;
3919 case SHF_WRITE
: *p
= 'W'; break;
3920 case SHF_ALLOC
: *p
= 'A'; break;
3921 case SHF_EXECINSTR
: *p
= 'X'; break;
3922 case SHF_MERGE
: *p
= 'M'; break;
3923 case SHF_STRINGS
: *p
= 'S'; break;
3924 case SHF_INFO_LINK
: *p
= 'I'; break;
3925 case SHF_LINK_ORDER
: *p
= 'L'; break;
3926 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
3927 case SHF_GROUP
: *p
= 'G'; break;
3928 case SHF_TLS
: *p
= 'T'; break;
3931 if (elf_header
.e_machine
== EM_X86_64
3932 && flag
== SHF_X86_64_LARGE
)
3934 else if (flag
& SHF_MASKOS
)
3937 sh_flags
&= ~ SHF_MASKOS
;
3939 else if (flag
& SHF_MASKPROC
)
3942 sh_flags
&= ~ SHF_MASKPROC
;
3952 if (do_section_details
)
3956 size
-= 5 + field_size
;
3957 if (p
!= buff
+ field_size
+ 4)
3965 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
3966 (unsigned long) os_flags
);
3967 p
+= 5 + field_size
;
3971 size
-= 7 + field_size
;
3972 if (p
!= buff
+ field_size
+ 4)
3980 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
3981 (unsigned long) proc_flags
);
3982 p
+= 7 + field_size
;
3986 size
-= 10 + field_size
;
3987 if (p
!= buff
+ field_size
+ 4)
3995 sprintf (p
, "UNKNOWN (%*.*lx)", field_size
, field_size
,
3996 (unsigned long) unknown_flags
);
3997 p
+= 10 + field_size
;
4006 process_section_headers (FILE *file
)
4008 Elf_Internal_Shdr
*section
;
4011 section_headers
= NULL
;
4013 if (elf_header
.e_shnum
== 0)
4016 printf (_("\nThere are no sections in this file.\n"));
4021 if (do_sections
&& !do_header
)
4022 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4023 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4027 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4030 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4033 /* Read in the string table, so that we have names to display. */
4034 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4035 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4037 section
= section_headers
+ elf_header
.e_shstrndx
;
4039 if (section
->sh_size
!= 0)
4041 string_table
= get_data (NULL
, file
, section
->sh_offset
,
4042 1, section
->sh_size
, _("string table"));
4044 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4048 /* Scan the sections for the dynamic symbol table
4049 and dynamic string table and debug sections. */
4050 dynamic_symbols
= NULL
;
4051 dynamic_strings
= NULL
;
4052 dynamic_syminfo
= NULL
;
4053 symtab_shndx_hdr
= NULL
;
4055 eh_addr_size
= is_32bit_elf
? 4 : 8;
4056 switch (elf_header
.e_machine
)
4059 case EM_MIPS_RS3_LE
:
4060 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4061 FDE addresses. However, the ABI also has a semi-official ILP32
4062 variant for which the normal FDE address size rules apply.
4064 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4065 section, where XX is the size of longs in bits. Unfortunately,
4066 earlier compilers provided no way of distinguishing ILP32 objects
4067 from LP64 objects, so if there's any doubt, we should assume that
4068 the official LP64 form is being used. */
4069 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4070 && find_section (".gcc_compiled_long32") == NULL
)
4076 switch (elf_header
.e_flags
& EF_H8_MACH
)
4078 case E_H8_MACH_H8300
:
4079 case E_H8_MACH_H8300HN
:
4080 case E_H8_MACH_H8300SN
:
4081 case E_H8_MACH_H8300SXN
:
4084 case E_H8_MACH_H8300H
:
4085 case E_H8_MACH_H8300S
:
4086 case E_H8_MACH_H8300SX
:
4094 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
4096 case EF_M32C_CPU_M16C
:
4103 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4106 size_t expected_entsize \
4107 = is_32bit_elf ? size32 : size64; \
4108 if (section->sh_entsize != expected_entsize) \
4109 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4110 i, (unsigned long int) section->sh_entsize, \
4111 (unsigned long int) expected_entsize); \
4112 section->sh_entsize = expected_entsize; \
4115 #define CHECK_ENTSIZE(section, i, type) \
4116 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4117 sizeof (Elf64_External_##type))
4119 for (i
= 0, section
= section_headers
;
4120 i
< elf_header
.e_shnum
;
4123 char *name
= SECTION_NAME (section
);
4125 if (section
->sh_type
== SHT_DYNSYM
)
4127 if (dynamic_symbols
!= NULL
)
4129 error (_("File contains multiple dynamic symbol tables\n"));
4133 CHECK_ENTSIZE (section
, i
, Sym
);
4134 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4135 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4137 else if (section
->sh_type
== SHT_STRTAB
4138 && streq (name
, ".dynstr"))
4140 if (dynamic_strings
!= NULL
)
4142 error (_("File contains multiple dynamic string tables\n"));
4146 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
4147 1, section
->sh_size
, _("dynamic strings"));
4148 dynamic_strings_length
= section
->sh_size
;
4150 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4152 if (symtab_shndx_hdr
!= NULL
)
4154 error (_("File contains multiple symtab shndx tables\n"));
4157 symtab_shndx_hdr
= section
;
4159 else if (section
->sh_type
== SHT_SYMTAB
)
4160 CHECK_ENTSIZE (section
, i
, Sym
);
4161 else if (section
->sh_type
== SHT_GROUP
)
4162 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4163 else if (section
->sh_type
== SHT_REL
)
4164 CHECK_ENTSIZE (section
, i
, Rel
);
4165 else if (section
->sh_type
== SHT_RELA
)
4166 CHECK_ENTSIZE (section
, i
, Rela
);
4167 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4168 || do_debug_lines
|| do_debug_pubnames
4169 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
4170 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
)
4171 && (const_strneq (name
, ".debug_")
4172 || const_strneq (name
, ".zdebug_")))
4175 name
+= sizeof (".zdebug_") - 1;
4177 name
+= sizeof (".debug_") - 1;
4180 || (do_debug_info
&& streq (name
, "info"))
4181 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4182 || (do_debug_lines
&& streq (name
, "line"))
4183 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4184 || (do_debug_aranges
&& streq (name
, "aranges"))
4185 || (do_debug_ranges
&& streq (name
, "ranges"))
4186 || (do_debug_frames
&& streq (name
, "frame"))
4187 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4188 || (do_debug_str
&& streq (name
, "str"))
4189 || (do_debug_loc
&& streq (name
, "loc"))
4191 request_dump_bynumber (i
, DEBUG_DUMP
);
4193 /* Linkonce section to be combined with .debug_info at link time. */
4194 else if ((do_debugging
|| do_debug_info
)
4195 && const_strneq (name
, ".gnu.linkonce.wi."))
4196 request_dump_bynumber (i
, DEBUG_DUMP
);
4197 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4198 request_dump_bynumber (i
, DEBUG_DUMP
);
4204 if (elf_header
.e_shnum
> 1)
4205 printf (_("\nSection Headers:\n"));
4207 printf (_("\nSection Header:\n"));
4211 if (do_section_details
)
4213 printf (_(" [Nr] Name\n"));
4214 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4218 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4222 if (do_section_details
)
4224 printf (_(" [Nr] Name\n"));
4225 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4229 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4233 if (do_section_details
)
4235 printf (_(" [Nr] Name\n"));
4236 printf (_(" Type Address Offset Link\n"));
4237 printf (_(" Size EntSize Info Align\n"));
4241 printf (_(" [Nr] Name Type Address Offset\n"));
4242 printf (_(" Size EntSize Flags Link Info Align\n"));
4246 if (do_section_details
)
4247 printf (_(" Flags\n"));
4249 for (i
= 0, section
= section_headers
;
4250 i
< elf_header
.e_shnum
;
4253 if (do_section_details
)
4255 printf (" [%2u] %s\n",
4257 SECTION_NAME (section
));
4258 if (is_32bit_elf
|| do_wide
)
4259 printf (" %-15.15s ",
4260 get_section_type_name (section
->sh_type
));
4263 printf ((do_wide
? " [%2u] %-17s %-15s "
4264 : " [%2u] %-17.17s %-15.15s "),
4266 SECTION_NAME (section
),
4267 get_section_type_name (section
->sh_type
));
4271 print_vma (section
->sh_addr
, LONG_HEX
);
4273 printf ( " %6.6lx %6.6lx %2.2lx",
4274 (unsigned long) section
->sh_offset
,
4275 (unsigned long) section
->sh_size
,
4276 (unsigned long) section
->sh_entsize
);
4278 if (do_section_details
)
4279 fputs (" ", stdout
);
4281 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4283 printf ("%2u %3u %2lu\n",
4286 (unsigned long) section
->sh_addralign
);
4290 print_vma (section
->sh_addr
, LONG_HEX
);
4292 if ((long) section
->sh_offset
== section
->sh_offset
)
4293 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4297 print_vma (section
->sh_offset
, LONG_HEX
);
4300 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4301 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4305 print_vma (section
->sh_size
, LONG_HEX
);
4308 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4309 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4313 print_vma (section
->sh_entsize
, LONG_HEX
);
4316 if (do_section_details
)
4317 fputs (" ", stdout
);
4319 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4321 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
4323 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4324 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
4327 print_vma (section
->sh_addralign
, DEC
);
4331 else if (do_section_details
)
4333 printf (" %-15.15s ",
4334 get_section_type_name (section
->sh_type
));
4335 print_vma (section
->sh_addr
, LONG_HEX
);
4336 if ((long) section
->sh_offset
== section
->sh_offset
)
4337 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4341 print_vma (section
->sh_offset
, LONG_HEX
);
4343 printf (" %u\n ", section
->sh_link
);
4344 print_vma (section
->sh_size
, LONG_HEX
);
4346 print_vma (section
->sh_entsize
, LONG_HEX
);
4348 printf (" %-16u %lu\n",
4350 (unsigned long) section
->sh_addralign
);
4355 print_vma (section
->sh_addr
, LONG_HEX
);
4356 if ((long) section
->sh_offset
== section
->sh_offset
)
4357 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4361 print_vma (section
->sh_offset
, LONG_HEX
);
4364 print_vma (section
->sh_size
, LONG_HEX
);
4366 print_vma (section
->sh_entsize
, LONG_HEX
);
4368 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4370 printf (" %2u %3u %lu\n",
4373 (unsigned long) section
->sh_addralign
);
4376 if (do_section_details
)
4377 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4380 if (!do_section_details
)
4381 printf (_("Key to Flags:\n\
4382 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4383 I (info), L (link order), G (group), x (unknown)\n\
4384 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4390 get_group_flags (unsigned int flags
)
4392 static char buff
[32];
4399 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4406 process_section_groups (FILE *file
)
4408 Elf_Internal_Shdr
*section
;
4410 struct group
*group
;
4411 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
;
4412 Elf_Internal_Sym
*symtab
;
4416 /* Don't process section groups unless needed. */
4417 if (!do_unwind
&& !do_section_groups
)
4420 if (elf_header
.e_shnum
== 0)
4422 if (do_section_groups
)
4423 printf (_("\nThere are no sections in this file.\n"));
4428 if (section_headers
== NULL
)
4430 error (_("Section headers are not available!\n"));
4434 section_headers_groups
= calloc (elf_header
.e_shnum
,
4435 sizeof (struct group
*));
4437 if (section_headers_groups
== NULL
)
4439 error (_("Out of memory\n"));
4443 /* Scan the sections for the group section. */
4445 for (i
= 0, section
= section_headers
;
4446 i
< elf_header
.e_shnum
;
4448 if (section
->sh_type
== SHT_GROUP
)
4451 if (group_count
== 0)
4453 if (do_section_groups
)
4454 printf (_("\nThere are no section groups in this file.\n"));
4459 section_groups
= calloc (group_count
, sizeof (struct group
));
4461 if (section_groups
== NULL
)
4463 error (_("Out of memory\n"));
4472 for (i
= 0, section
= section_headers
, group
= section_groups
;
4473 i
< elf_header
.e_shnum
;
4476 if (section
->sh_type
== SHT_GROUP
)
4478 char *name
= SECTION_NAME (section
);
4480 unsigned char *start
, *indices
;
4481 unsigned int entry
, j
, size
;
4482 Elf_Internal_Shdr
*sec
;
4483 Elf_Internal_Sym
*sym
;
4485 /* Get the symbol table. */
4486 if (section
->sh_link
>= elf_header
.e_shnum
4487 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
4490 error (_("Bad sh_link in group section `%s'\n"), name
);
4494 if (symtab_sec
!= sec
)
4499 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4502 sym
= symtab
+ section
->sh_info
;
4504 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4506 if (sym
->st_shndx
== 0
4507 || sym
->st_shndx
>= elf_header
.e_shnum
)
4509 error (_("Bad sh_info in group section `%s'\n"), name
);
4513 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
4522 /* Get the string table. */
4523 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
4532 != (sec
= section_headers
+ symtab_sec
->sh_link
))
4537 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4538 1, strtab_sec
->sh_size
,
4540 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4542 group_name
= sym
->st_name
< strtab_size
4543 ? strtab
+ sym
->st_name
: "<corrupt>";
4546 start
= get_data (NULL
, file
, section
->sh_offset
,
4547 1, section
->sh_size
, _("section data"));
4550 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4551 entry
= byte_get (indices
, 4);
4554 if (do_section_groups
)
4556 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4557 get_group_flags (entry
), i
, name
, group_name
, size
);
4559 printf (_(" [Index] Name\n"));
4562 group
->group_index
= i
;
4564 for (j
= 0; j
< size
; j
++)
4566 struct group_list
*g
;
4568 entry
= byte_get (indices
, 4);
4571 if (entry
>= elf_header
.e_shnum
)
4573 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4574 entry
, i
, elf_header
.e_shnum
- 1);
4578 if (section_headers_groups
[entry
] != NULL
)
4582 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4584 section_headers_groups
[entry
]->group_index
);
4589 /* Intel C/C++ compiler may put section 0 in a
4590 section group. We just warn it the first time
4591 and ignore it afterwards. */
4592 static int warned
= 0;
4595 error (_("section 0 in group section [%5u]\n"),
4596 section_headers_groups
[entry
]->group_index
);
4602 section_headers_groups
[entry
] = group
;
4604 if (do_section_groups
)
4606 sec
= section_headers
+ entry
;
4607 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4610 g
= xmalloc (sizeof (struct group_list
));
4611 g
->section_index
= entry
;
4612 g
->next
= group
->root
;
4636 } dynamic_relocations
[] =
4638 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4639 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4640 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4643 /* Process the reloc section. */
4646 process_relocs (FILE *file
)
4648 unsigned long rel_size
;
4649 unsigned long rel_offset
;
4655 if (do_using_dynamic
)
4659 int has_dynamic_reloc
;
4662 has_dynamic_reloc
= 0;
4664 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4666 is_rela
= dynamic_relocations
[i
].rela
;
4667 name
= dynamic_relocations
[i
].name
;
4668 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4669 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4671 has_dynamic_reloc
|= rel_size
;
4673 if (is_rela
== UNKNOWN
)
4675 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4676 switch (dynamic_info
[DT_PLTREL
])
4690 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4691 name
, rel_offset
, rel_size
);
4693 dump_relocations (file
,
4694 offset_from_vma (file
, rel_offset
, rel_size
),
4696 dynamic_symbols
, num_dynamic_syms
,
4697 dynamic_strings
, dynamic_strings_length
, is_rela
);
4701 if (! has_dynamic_reloc
)
4702 printf (_("\nThere are no dynamic relocations in this file.\n"));
4706 Elf_Internal_Shdr
*section
;
4710 for (i
= 0, section
= section_headers
;
4711 i
< elf_header
.e_shnum
;
4714 if ( section
->sh_type
!= SHT_RELA
4715 && section
->sh_type
!= SHT_REL
)
4718 rel_offset
= section
->sh_offset
;
4719 rel_size
= section
->sh_size
;
4723 Elf_Internal_Shdr
*strsec
;
4726 printf (_("\nRelocation section "));
4728 if (string_table
== NULL
)
4729 printf ("%d", section
->sh_name
);
4731 printf (_("'%s'"), SECTION_NAME (section
));
4733 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4734 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4736 is_rela
= section
->sh_type
== SHT_RELA
;
4738 if (section
->sh_link
!= 0
4739 && section
->sh_link
< elf_header
.e_shnum
)
4741 Elf_Internal_Shdr
*symsec
;
4742 Elf_Internal_Sym
*symtab
;
4743 unsigned long nsyms
;
4744 unsigned long strtablen
= 0;
4745 char *strtab
= NULL
;
4747 symsec
= section_headers
+ section
->sh_link
;
4748 if (symsec
->sh_type
!= SHT_SYMTAB
4749 && symsec
->sh_type
!= SHT_DYNSYM
)
4752 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4753 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4758 if (symsec
->sh_link
!= 0
4759 && symsec
->sh_link
< elf_header
.e_shnum
)
4761 strsec
= section_headers
+ symsec
->sh_link
;
4763 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4766 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4769 dump_relocations (file
, rel_offset
, rel_size
,
4770 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4776 dump_relocations (file
, rel_offset
, rel_size
,
4777 NULL
, 0, NULL
, 0, is_rela
);
4784 printf (_("\nThere are no relocations in this file.\n"));
4790 /* Process the unwind section. */
4792 #include "unwind-ia64.h"
4794 /* An absolute address consists of a section and an offset. If the
4795 section is NULL, the offset itself is the address, otherwise, the
4796 address equals to LOAD_ADDRESS(section) + offset. */
4800 unsigned short section
;
4804 #define ABSADDR(a) \
4806 ? section_headers [(a).section].sh_addr + (a).offset \
4809 struct ia64_unw_aux_info
4811 struct ia64_unw_table_entry
4813 struct absaddr start
;
4815 struct absaddr info
;
4817 *table
; /* Unwind table. */
4818 unsigned long table_len
; /* Length of unwind table. */
4819 unsigned char *info
; /* Unwind info. */
4820 unsigned long info_size
; /* Size of unwind info. */
4821 bfd_vma info_addr
; /* starting address of unwind info. */
4822 bfd_vma seg_base
; /* Starting address of segment. */
4823 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4824 unsigned long nsyms
; /* Number of symbols. */
4825 char *strtab
; /* The string table. */
4826 unsigned long strtab_size
; /* Size of string table. */
4830 find_symbol_for_address (Elf_Internal_Sym
*symtab
,
4831 unsigned long nsyms
,
4833 unsigned long strtab_size
,
4834 struct absaddr addr
,
4835 const char **symname
,
4838 bfd_vma dist
= 0x100000;
4839 Elf_Internal_Sym
*sym
, *best
= NULL
;
4842 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4844 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4845 && sym
->st_name
!= 0
4846 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4847 && addr
.offset
>= sym
->st_value
4848 && addr
.offset
- sym
->st_value
< dist
)
4851 dist
= addr
.offset
- sym
->st_value
;
4858 *symname
= (best
->st_name
>= strtab_size
4859 ? "<corrupt>" : strtab
+ best
->st_name
);
4864 *offset
= addr
.offset
;
4868 dump_ia64_unwind (struct ia64_unw_aux_info
*aux
)
4870 struct ia64_unw_table_entry
*tp
;
4873 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4877 const unsigned char *dp
;
4878 const unsigned char *head
;
4879 const char *procname
;
4881 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4882 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4884 fputs ("\n<", stdout
);
4888 fputs (procname
, stdout
);
4891 printf ("+%lx", (unsigned long) offset
);
4894 fputs (">: [", stdout
);
4895 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4896 fputc ('-', stdout
);
4897 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4898 printf ("], info at +0x%lx\n",
4899 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4901 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
4902 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
4904 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4905 (unsigned) UNW_VER (stamp
),
4906 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4907 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4908 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4909 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
4911 if (UNW_VER (stamp
) != 1)
4913 printf ("\tUnknown version.\n");
4918 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
4919 dp
= unw_decode (dp
, in_body
, & in_body
);
4924 slurp_ia64_unwind_table (FILE *file
,
4925 struct ia64_unw_aux_info
*aux
,
4926 Elf_Internal_Shdr
*sec
)
4928 unsigned long size
, nrelas
, i
;
4929 Elf_Internal_Phdr
*seg
;
4930 struct ia64_unw_table_entry
*tep
;
4931 Elf_Internal_Shdr
*relsec
;
4932 Elf_Internal_Rela
*rela
, *rp
;
4933 unsigned char *table
, *tp
;
4934 Elf_Internal_Sym
*sym
;
4935 const char *relname
;
4937 /* First, find the starting address of the segment that includes
4940 if (elf_header
.e_phnum
)
4942 if (! get_program_headers (file
))
4945 for (seg
= program_headers
;
4946 seg
< program_headers
+ elf_header
.e_phnum
;
4949 if (seg
->p_type
!= PT_LOAD
)
4952 if (sec
->sh_addr
>= seg
->p_vaddr
4953 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4955 aux
->seg_base
= seg
->p_vaddr
;
4961 /* Second, build the unwind table from the contents of the unwind section: */
4962 size
= sec
->sh_size
;
4963 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
4967 aux
->table
= xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
4969 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * eh_addr_size
, ++tep
)
4971 tep
->start
.section
= SHN_UNDEF
;
4972 tep
->end
.section
= SHN_UNDEF
;
4973 tep
->info
.section
= SHN_UNDEF
;
4976 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4977 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4978 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4982 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
4983 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
4984 tep
->info
.offset
= BYTE_GET ((unsigned char *) tp
+ 16);
4986 tep
->start
.offset
+= aux
->seg_base
;
4987 tep
->end
.offset
+= aux
->seg_base
;
4988 tep
->info
.offset
+= aux
->seg_base
;
4992 /* Third, apply any relocations to the unwind table: */
4993 for (relsec
= section_headers
;
4994 relsec
< section_headers
+ elf_header
.e_shnum
;
4997 if (relsec
->sh_type
!= SHT_RELA
4998 || relsec
->sh_info
>= elf_header
.e_shnum
4999 || section_headers
+ relsec
->sh_info
!= sec
)
5002 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5006 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5008 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5009 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5011 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5013 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5017 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5019 switch (rp
->r_offset
/eh_addr_size
% 3)
5022 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5023 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
5026 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5027 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
5030 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5031 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
5041 aux
->table_len
= size
/ (3 * eh_addr_size
);
5046 ia64_process_unwind (FILE *file
)
5048 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
5049 unsigned long i
, unwcount
= 0, unwstart
= 0;
5050 struct ia64_unw_aux_info aux
;
5052 memset (& aux
, 0, sizeof (aux
));
5054 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5056 if (sec
->sh_type
== SHT_SYMTAB
5057 && sec
->sh_link
< elf_header
.e_shnum
)
5059 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5060 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5062 strsec
= section_headers
+ sec
->sh_link
;
5063 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5064 1, strsec
->sh_size
, _("string table"));
5065 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5067 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5072 printf (_("\nThere are no unwind sections in this file.\n"));
5074 while (unwcount
-- > 0)
5079 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5080 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5081 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5088 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5090 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5092 /* We need to find which section group it is in. */
5093 struct group_list
*g
= section_headers_groups
[i
]->root
;
5095 for (; g
!= NULL
; g
= g
->next
)
5097 sec
= section_headers
+ g
->section_index
;
5099 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5104 i
= elf_header
.e_shnum
;
5106 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5108 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5109 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5110 suffix
= SECTION_NAME (unwsec
) + len
;
5111 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5113 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5114 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5119 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5120 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5121 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5122 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5124 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5125 suffix
= SECTION_NAME (unwsec
) + len
;
5126 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5128 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5129 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5133 if (i
== elf_header
.e_shnum
)
5135 printf (_("\nCould not find unwind info section for "));
5137 if (string_table
== NULL
)
5138 printf ("%d", unwsec
->sh_name
);
5140 printf (_("'%s'"), SECTION_NAME (unwsec
));
5144 aux
.info_size
= sec
->sh_size
;
5145 aux
.info_addr
= sec
->sh_addr
;
5146 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, 1, aux
.info_size
,
5149 printf (_("\nUnwind section "));
5151 if (string_table
== NULL
)
5152 printf ("%d", unwsec
->sh_name
);
5154 printf (_("'%s'"), SECTION_NAME (unwsec
));
5156 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5157 (unsigned long) unwsec
->sh_offset
,
5158 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5160 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5162 if (aux
.table_len
> 0)
5163 dump_ia64_unwind (& aux
);
5166 free ((char *) aux
.table
);
5168 free ((char *) aux
.info
);
5177 free ((char *) aux
.strtab
);
5182 struct hppa_unw_aux_info
5184 struct hppa_unw_table_entry
5186 struct absaddr start
;
5188 unsigned int Cannot_unwind
:1; /* 0 */
5189 unsigned int Millicode
:1; /* 1 */
5190 unsigned int Millicode_save_sr0
:1; /* 2 */
5191 unsigned int Region_description
:2; /* 3..4 */
5192 unsigned int reserved1
:1; /* 5 */
5193 unsigned int Entry_SR
:1; /* 6 */
5194 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5195 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5196 unsigned int Args_stored
:1; /* 16 */
5197 unsigned int Variable_Frame
:1; /* 17 */
5198 unsigned int Separate_Package_Body
:1; /* 18 */
5199 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5200 unsigned int Stack_Overflow_Check
:1; /* 20 */
5201 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5202 unsigned int Ada_Region
:1; /* 22 */
5203 unsigned int cxx_info
:1; /* 23 */
5204 unsigned int cxx_try_catch
:1; /* 24 */
5205 unsigned int sched_entry_seq
:1; /* 25 */
5206 unsigned int reserved2
:1; /* 26 */
5207 unsigned int Save_SP
:1; /* 27 */
5208 unsigned int Save_RP
:1; /* 28 */
5209 unsigned int Save_MRP_in_frame
:1; /* 29 */
5210 unsigned int extn_ptr_defined
:1; /* 30 */
5211 unsigned int Cleanup_defined
:1; /* 31 */
5213 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5214 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5215 unsigned int Large_frame
:1; /* 2 */
5216 unsigned int Pseudo_SP_Set
:1; /* 3 */
5217 unsigned int reserved4
:1; /* 4 */
5218 unsigned int Total_frame_size
:27; /* 5..31 */
5220 *table
; /* Unwind table. */
5221 unsigned long table_len
; /* Length of unwind table. */
5222 bfd_vma seg_base
; /* Starting address of segment. */
5223 Elf_Internal_Sym
*symtab
; /* The symbol table. */
5224 unsigned long nsyms
; /* Number of symbols. */
5225 char *strtab
; /* The string table. */
5226 unsigned long strtab_size
; /* Size of string table. */
5230 dump_hppa_unwind (struct hppa_unw_aux_info
*aux
)
5232 struct hppa_unw_table_entry
*tp
;
5234 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5237 const char *procname
;
5239 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5240 aux
->strtab_size
, tp
->start
, &procname
,
5243 fputs ("\n<", stdout
);
5247 fputs (procname
, stdout
);
5250 printf ("+%lx", (unsigned long) offset
);
5253 fputs (">: [", stdout
);
5254 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5255 fputc ('-', stdout
);
5256 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5259 #define PF(_m) if (tp->_m) printf (#_m " ");
5260 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5263 PF(Millicode_save_sr0
);
5264 /* PV(Region_description); */
5270 PF(Separate_Package_Body
);
5271 PF(Frame_Extension_Millicode
);
5272 PF(Stack_Overflow_Check
);
5273 PF(Two_Instruction_SP_Increment
);
5277 PF(sched_entry_seq
);
5280 PF(Save_MRP_in_frame
);
5281 PF(extn_ptr_defined
);
5282 PF(Cleanup_defined
);
5283 PF(MPE_XL_interrupt_marker
);
5284 PF(HP_UX_interrupt_marker
);
5287 PV(Total_frame_size
);
5296 slurp_hppa_unwind_table (FILE *file
,
5297 struct hppa_unw_aux_info
*aux
,
5298 Elf_Internal_Shdr
*sec
)
5300 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5301 Elf_Internal_Phdr
*seg
;
5302 struct hppa_unw_table_entry
*tep
;
5303 Elf_Internal_Shdr
*relsec
;
5304 Elf_Internal_Rela
*rela
, *rp
;
5305 unsigned char *table
, *tp
;
5306 Elf_Internal_Sym
*sym
;
5307 const char *relname
;
5309 /* First, find the starting address of the segment that includes
5312 if (elf_header
.e_phnum
)
5314 if (! get_program_headers (file
))
5317 for (seg
= program_headers
;
5318 seg
< program_headers
+ elf_header
.e_phnum
;
5321 if (seg
->p_type
!= PT_LOAD
)
5324 if (sec
->sh_addr
>= seg
->p_vaddr
5325 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5327 aux
->seg_base
= seg
->p_vaddr
;
5333 /* Second, build the unwind table from the contents of the unwind
5335 size
= sec
->sh_size
;
5336 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5341 nentries
= size
/ unw_ent_size
;
5342 size
= unw_ent_size
* nentries
;
5344 tep
= aux
->table
= xcmalloc (nentries
, sizeof (aux
->table
[0]));
5346 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5348 unsigned int tmp1
, tmp2
;
5350 tep
->start
.section
= SHN_UNDEF
;
5351 tep
->end
.section
= SHN_UNDEF
;
5353 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5354 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5355 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5356 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5358 tep
->start
.offset
+= aux
->seg_base
;
5359 tep
->end
.offset
+= aux
->seg_base
;
5361 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5362 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5363 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5364 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5365 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5366 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5367 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5368 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5369 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5370 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5371 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5372 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5373 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5374 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5375 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5376 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5377 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5378 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5379 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5380 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5381 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5382 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5383 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5384 tep
->Cleanup_defined
= tmp1
& 0x1;
5386 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5387 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5388 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5389 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5390 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5391 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5395 /* Third, apply any relocations to the unwind table. */
5396 for (relsec
= section_headers
;
5397 relsec
< section_headers
+ elf_header
.e_shnum
;
5400 if (relsec
->sh_type
!= SHT_RELA
5401 || relsec
->sh_info
>= elf_header
.e_shnum
5402 || section_headers
+ relsec
->sh_info
!= sec
)
5405 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5409 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5411 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
5412 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5414 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5415 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
5417 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5421 i
= rp
->r_offset
/ unw_ent_size
;
5423 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5426 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5427 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
5430 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5431 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5441 aux
->table_len
= nentries
;
5447 hppa_process_unwind (FILE *file
)
5449 struct hppa_unw_aux_info aux
;
5450 Elf_Internal_Shdr
*unwsec
= NULL
;
5451 Elf_Internal_Shdr
*strsec
;
5452 Elf_Internal_Shdr
*sec
;
5455 memset (& aux
, 0, sizeof (aux
));
5457 if (string_table
== NULL
)
5460 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5462 if (sec
->sh_type
== SHT_SYMTAB
5463 && sec
->sh_link
< elf_header
.e_shnum
)
5465 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5466 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5468 strsec
= section_headers
+ sec
->sh_link
;
5469 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5470 1, strsec
->sh_size
, _("string table"));
5471 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5473 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5478 printf (_("\nThere are no unwind sections in this file.\n"));
5480 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5482 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5484 printf (_("\nUnwind section "));
5485 printf (_("'%s'"), SECTION_NAME (sec
));
5487 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5488 (unsigned long) sec
->sh_offset
,
5489 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5491 slurp_hppa_unwind_table (file
, &aux
, sec
);
5492 if (aux
.table_len
> 0)
5493 dump_hppa_unwind (&aux
);
5496 free ((char *) aux
.table
);
5504 free ((char *) aux
.strtab
);
5510 process_unwind (FILE *file
)
5512 struct unwind_handler
{
5514 int (*handler
)(FILE *file
);
5516 { EM_IA_64
, ia64_process_unwind
},
5517 { EM_PARISC
, hppa_process_unwind
},
5525 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5526 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5527 return handlers
[i
].handler (file
);
5529 printf (_("\nThere are no unwind sections in this file.\n"));
5534 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
5536 switch (entry
->d_tag
)
5539 if (entry
->d_un
.d_val
== 0)
5543 static const char * opts
[] =
5545 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5546 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5547 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5548 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5553 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
5554 if (entry
->d_un
.d_val
& (1 << cnt
))
5556 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5563 case DT_MIPS_IVERSION
:
5564 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5565 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5567 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5570 case DT_MIPS_TIME_STAMP
:
5575 time_t time
= entry
->d_un
.d_val
;
5576 tmp
= gmtime (&time
);
5577 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5578 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5579 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5580 printf ("Time Stamp: %s\n", timebuf
);
5584 case DT_MIPS_RLD_VERSION
:
5585 case DT_MIPS_LOCAL_GOTNO
:
5586 case DT_MIPS_CONFLICTNO
:
5587 case DT_MIPS_LIBLISTNO
:
5588 case DT_MIPS_SYMTABNO
:
5589 case DT_MIPS_UNREFEXTNO
:
5590 case DT_MIPS_HIPAGENO
:
5591 case DT_MIPS_DELTA_CLASS_NO
:
5592 case DT_MIPS_DELTA_INSTANCE_NO
:
5593 case DT_MIPS_DELTA_RELOC_NO
:
5594 case DT_MIPS_DELTA_SYM_NO
:
5595 case DT_MIPS_DELTA_CLASSSYM_NO
:
5596 case DT_MIPS_COMPACT_SIZE
:
5597 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5601 printf ("%#lx\n", (unsigned long) entry
->d_un
.d_ptr
);
5607 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
5609 switch (entry
->d_tag
)
5611 case DT_HP_DLD_FLAGS
:
5620 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5621 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5622 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5623 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5624 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5625 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5626 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5627 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5628 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5629 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5630 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
5631 { DT_HP_GST
, "HP_GST" },
5632 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
5633 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
5634 { DT_HP_NODELETE
, "HP_NODELETE" },
5635 { DT_HP_GROUP
, "HP_GROUP" },
5636 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
5640 bfd_vma val
= entry
->d_un
.d_val
;
5642 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
5643 if (val
& flags
[cnt
].bit
)
5647 fputs (flags
[cnt
].str
, stdout
);
5649 val
^= flags
[cnt
].bit
;
5652 if (val
!= 0 || first
)
5656 print_vma (val
, HEX
);
5662 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5669 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
5671 switch (entry
->d_tag
)
5673 case DT_IA_64_PLT_RESERVE
:
5674 /* First 3 slots reserved. */
5675 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5677 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5681 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5688 get_32bit_dynamic_section (FILE *file
)
5690 Elf32_External_Dyn
*edyn
, *ext
;
5691 Elf_Internal_Dyn
*entry
;
5693 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5694 _("dynamic section"));
5698 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5699 might not have the luxury of section headers. Look for the DT_NULL
5700 terminator to determine the number of entries. */
5701 for (ext
= edyn
, dynamic_nent
= 0;
5702 (char *) ext
< (char *) edyn
+ dynamic_size
;
5706 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5710 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5711 if (dynamic_section
== NULL
)
5713 error (_("Out of memory\n"));
5718 for (ext
= edyn
, entry
= dynamic_section
;
5719 entry
< dynamic_section
+ dynamic_nent
;
5722 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5723 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5732 get_64bit_dynamic_section (FILE *file
)
5734 Elf64_External_Dyn
*edyn
, *ext
;
5735 Elf_Internal_Dyn
*entry
;
5737 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5738 _("dynamic section"));
5742 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5743 might not have the luxury of section headers. Look for the DT_NULL
5744 terminator to determine the number of entries. */
5745 for (ext
= edyn
, dynamic_nent
= 0;
5746 (char *) ext
< (char *) edyn
+ dynamic_size
;
5750 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5754 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5755 if (dynamic_section
== NULL
)
5757 error (_("Out of memory\n"));
5762 for (ext
= edyn
, entry
= dynamic_section
;
5763 entry
< dynamic_section
+ dynamic_nent
;
5766 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5767 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5776 print_dynamic_flags (bfd_vma flags
)
5784 flag
= flags
& - flags
;
5794 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
5795 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
5796 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
5797 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
5798 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
5799 default: fputs ("unknown", stdout
); break;
5805 /* Parse and display the contents of the dynamic section. */
5808 process_dynamic_section (FILE *file
)
5810 Elf_Internal_Dyn
*entry
;
5812 if (dynamic_size
== 0)
5815 printf (_("\nThere is no dynamic section in this file.\n"));
5822 if (! get_32bit_dynamic_section (file
))
5825 else if (! get_64bit_dynamic_section (file
))
5828 /* Find the appropriate symbol table. */
5829 if (dynamic_symbols
== NULL
)
5831 for (entry
= dynamic_section
;
5832 entry
< dynamic_section
+ dynamic_nent
;
5835 Elf_Internal_Shdr section
;
5837 if (entry
->d_tag
!= DT_SYMTAB
)
5840 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5842 /* Since we do not know how big the symbol table is,
5843 we default to reading in the entire file (!) and
5844 processing that. This is overkill, I know, but it
5846 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5848 if (archive_file_offset
!= 0)
5849 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5852 if (fseek (file
, 0, SEEK_END
))
5853 error (_("Unable to seek to end of file!\n"));
5855 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5859 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5861 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5863 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5864 if (num_dynamic_syms
< 1)
5866 error (_("Unable to determine the number of symbols to load\n"));
5870 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5874 /* Similarly find a string table. */
5875 if (dynamic_strings
== NULL
)
5877 for (entry
= dynamic_section
;
5878 entry
< dynamic_section
+ dynamic_nent
;
5881 unsigned long offset
;
5884 if (entry
->d_tag
!= DT_STRTAB
)
5887 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5889 /* Since we do not know how big the string table is,
5890 we default to reading in the entire file (!) and
5891 processing that. This is overkill, I know, but it
5894 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5896 if (archive_file_offset
!= 0)
5897 str_tab_len
= archive_file_size
- offset
;
5900 if (fseek (file
, 0, SEEK_END
))
5901 error (_("Unable to seek to end of file\n"));
5902 str_tab_len
= ftell (file
) - offset
;
5905 if (str_tab_len
< 1)
5908 (_("Unable to determine the length of the dynamic string table\n"));
5912 dynamic_strings
= get_data (NULL
, file
, offset
, 1, str_tab_len
,
5913 _("dynamic string table"));
5914 dynamic_strings_length
= str_tab_len
;
5919 /* And find the syminfo section if available. */
5920 if (dynamic_syminfo
== NULL
)
5922 unsigned long syminsz
= 0;
5924 for (entry
= dynamic_section
;
5925 entry
< dynamic_section
+ dynamic_nent
;
5928 if (entry
->d_tag
== DT_SYMINENT
)
5930 /* Note: these braces are necessary to avoid a syntax
5931 error from the SunOS4 C compiler. */
5932 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5934 else if (entry
->d_tag
== DT_SYMINSZ
)
5935 syminsz
= entry
->d_un
.d_val
;
5936 else if (entry
->d_tag
== DT_SYMINFO
)
5937 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5941 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5943 Elf_External_Syminfo
*extsyminfo
, *extsym
;
5944 Elf_Internal_Syminfo
*syminfo
;
5946 /* There is a syminfo section. Read the data. */
5947 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, 1,
5948 syminsz
, _("symbol information"));
5952 dynamic_syminfo
= malloc (syminsz
);
5953 if (dynamic_syminfo
== NULL
)
5955 error (_("Out of memory\n"));
5959 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
5960 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
5961 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
5962 ++syminfo
, ++extsym
)
5964 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
5965 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
5972 if (do_dynamic
&& dynamic_addr
)
5973 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5974 dynamic_addr
, dynamic_nent
);
5976 printf (_(" Tag Type Name/Value\n"));
5978 for (entry
= dynamic_section
;
5979 entry
< dynamic_section
+ dynamic_nent
;
5987 print_vma (entry
->d_tag
, FULL_HEX
);
5988 dtype
= get_dynamic_type (entry
->d_tag
);
5989 printf (" (%s)%*s", dtype
,
5990 ((is_32bit_elf
? 27 : 19)
5991 - (int) strlen (dtype
)),
5995 switch (entry
->d_tag
)
5999 print_dynamic_flags (entry
->d_un
.d_val
);
6009 switch (entry
->d_tag
)
6012 printf (_("Auxiliary library"));
6016 printf (_("Filter library"));
6020 printf (_("Configuration file"));
6024 printf (_("Dependency audit library"));
6028 printf (_("Audit library"));
6032 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6033 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
6037 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6046 printf (_("Flags:"));
6048 if (entry
->d_un
.d_val
== 0)
6049 printf (_(" None\n"));
6052 unsigned long int val
= entry
->d_un
.d_val
;
6054 if (val
& DTF_1_PARINIT
)
6056 printf (" PARINIT");
6057 val
^= DTF_1_PARINIT
;
6059 if (val
& DTF_1_CONFEXP
)
6061 printf (" CONFEXP");
6062 val
^= DTF_1_CONFEXP
;
6065 printf (" %lx", val
);
6074 printf (_("Flags:"));
6076 if (entry
->d_un
.d_val
== 0)
6077 printf (_(" None\n"));
6080 unsigned long int val
= entry
->d_un
.d_val
;
6082 if (val
& DF_P1_LAZYLOAD
)
6084 printf (" LAZYLOAD");
6085 val
^= DF_P1_LAZYLOAD
;
6087 if (val
& DF_P1_GROUPPERM
)
6089 printf (" GROUPPERM");
6090 val
^= DF_P1_GROUPPERM
;
6093 printf (" %lx", val
);
6102 printf (_("Flags:"));
6103 if (entry
->d_un
.d_val
== 0)
6104 printf (_(" None\n"));
6107 unsigned long int val
= entry
->d_un
.d_val
;
6114 if (val
& DF_1_GLOBAL
)
6119 if (val
& DF_1_GROUP
)
6124 if (val
& DF_1_NODELETE
)
6126 printf (" NODELETE");
6127 val
^= DF_1_NODELETE
;
6129 if (val
& DF_1_LOADFLTR
)
6131 printf (" LOADFLTR");
6132 val
^= DF_1_LOADFLTR
;
6134 if (val
& DF_1_INITFIRST
)
6136 printf (" INITFIRST");
6137 val
^= DF_1_INITFIRST
;
6139 if (val
& DF_1_NOOPEN
)
6144 if (val
& DF_1_ORIGIN
)
6149 if (val
& DF_1_DIRECT
)
6154 if (val
& DF_1_TRANS
)
6159 if (val
& DF_1_INTERPOSE
)
6161 printf (" INTERPOSE");
6162 val
^= DF_1_INTERPOSE
;
6164 if (val
& DF_1_NODEFLIB
)
6166 printf (" NODEFLIB");
6167 val
^= DF_1_NODEFLIB
;
6169 if (val
& DF_1_NODUMP
)
6174 if (val
& DF_1_CONLFAT
)
6176 printf (" CONLFAT");
6177 val
^= DF_1_CONLFAT
;
6180 printf (" %lx", val
);
6187 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6189 puts (get_dynamic_type (entry
->d_un
.d_val
));
6209 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6215 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6216 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6222 switch (entry
->d_tag
)
6225 printf (_("Shared library: [%s]"), name
);
6227 if (streq (name
, program_interpreter
))
6228 printf (_(" program interpreter"));
6232 printf (_("Library soname: [%s]"), name
);
6236 printf (_("Library rpath: [%s]"), name
);
6240 printf (_("Library runpath: [%s]"), name
);
6244 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6249 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6262 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6266 case DT_INIT_ARRAYSZ
:
6267 case DT_FINI_ARRAYSZ
:
6268 case DT_GNU_CONFLICTSZ
:
6269 case DT_GNU_LIBLISTSZ
:
6272 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6273 printf (" (bytes)\n");
6283 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6296 if (entry
->d_tag
== DT_USED
6297 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6299 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6303 printf (_("Not needed object: [%s]\n"), name
);
6308 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6314 /* The value of this entry is ignored. */
6319 case DT_GNU_PRELINKED
:
6323 time_t time
= entry
->d_un
.d_val
;
6325 tmp
= gmtime (&time
);
6326 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6327 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6328 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6334 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
6337 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6343 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6344 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6349 switch (elf_header
.e_machine
)
6352 case EM_MIPS_RS3_LE
:
6353 dynamic_section_mips_val (entry
);
6356 dynamic_section_parisc_val (entry
);
6359 dynamic_section_ia64_val (entry
);
6362 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6374 get_ver_flags (unsigned int flags
)
6376 static char buff
[32];
6383 if (flags
& VER_FLG_BASE
)
6384 strcat (buff
, "BASE ");
6386 if (flags
& VER_FLG_WEAK
)
6388 if (flags
& VER_FLG_BASE
)
6389 strcat (buff
, "| ");
6391 strcat (buff
, "WEAK ");
6394 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6395 strcat (buff
, "| <unknown>");
6400 /* Display the contents of the version sections. */
6402 process_version_sections (FILE *file
)
6404 Elf_Internal_Shdr
*section
;
6411 for (i
= 0, section
= section_headers
;
6412 i
< elf_header
.e_shnum
;
6415 switch (section
->sh_type
)
6417 case SHT_GNU_verdef
:
6419 Elf_External_Verdef
*edefs
;
6427 (_("\nVersion definition section '%s' contains %u entries:\n"),
6428 SECTION_NAME (section
), section
->sh_info
);
6430 printf (_(" Addr: 0x"));
6431 printf_vma (section
->sh_addr
);
6432 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6433 (unsigned long) section
->sh_offset
, section
->sh_link
,
6434 section
->sh_link
< elf_header
.e_shnum
6435 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6438 edefs
= get_data (NULL
, file
, section
->sh_offset
, 1,
6440 _("version definition section"));
6441 endbuf
= (char *) edefs
+ section
->sh_size
;
6445 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6448 Elf_External_Verdef
*edef
;
6449 Elf_Internal_Verdef ent
;
6450 Elf_External_Verdaux
*eaux
;
6451 Elf_Internal_Verdaux aux
;
6455 vstart
= ((char *) edefs
) + idx
;
6456 if (vstart
+ sizeof (*edef
) > endbuf
)
6459 edef
= (Elf_External_Verdef
*) vstart
;
6461 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6462 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6463 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6464 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6465 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6466 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6467 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6469 printf (_(" %#06x: Rev: %d Flags: %s"),
6470 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6472 printf (_(" Index: %d Cnt: %d "),
6473 ent
.vd_ndx
, ent
.vd_cnt
);
6475 vstart
+= ent
.vd_aux
;
6477 eaux
= (Elf_External_Verdaux
*) vstart
;
6479 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6480 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6482 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6483 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6485 printf (_("Name index: %ld\n"), aux
.vda_name
);
6487 isum
= idx
+ ent
.vd_aux
;
6489 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6491 isum
+= aux
.vda_next
;
6492 vstart
+= aux
.vda_next
;
6494 eaux
= (Elf_External_Verdaux
*) vstart
;
6495 if (vstart
+ sizeof (*eaux
) > endbuf
)
6498 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6499 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6501 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6502 printf (_(" %#06x: Parent %d: %s\n"),
6503 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6505 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6506 isum
, j
, aux
.vda_name
);
6509 printf (_(" Version def aux past end of section\n"));
6513 if (cnt
< section
->sh_info
)
6514 printf (_(" Version definition past end of section\n"));
6520 case SHT_GNU_verneed
:
6522 Elf_External_Verneed
*eneed
;
6529 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
6530 SECTION_NAME (section
), section
->sh_info
);
6532 printf (_(" Addr: 0x"));
6533 printf_vma (section
->sh_addr
);
6534 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6535 (unsigned long) section
->sh_offset
, section
->sh_link
,
6536 section
->sh_link
< elf_header
.e_shnum
6537 ? SECTION_NAME (section_headers
+ section
->sh_link
)
6540 eneed
= get_data (NULL
, file
, section
->sh_offset
, 1,
6542 _("version need section"));
6543 endbuf
= (char *) eneed
+ section
->sh_size
;
6547 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6549 Elf_External_Verneed
*entry
;
6550 Elf_Internal_Verneed ent
;
6555 vstart
= ((char *) eneed
) + idx
;
6556 if (vstart
+ sizeof (*entry
) > endbuf
)
6559 entry
= (Elf_External_Verneed
*) vstart
;
6561 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6562 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6563 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6564 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6565 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6567 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6569 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6570 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6572 printf (_(" File: %lx"), ent
.vn_file
);
6574 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6576 vstart
+= ent
.vn_aux
;
6578 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6580 Elf_External_Vernaux
*eaux
;
6581 Elf_Internal_Vernaux aux
;
6583 if (vstart
+ sizeof (*eaux
) > endbuf
)
6585 eaux
= (Elf_External_Vernaux
*) vstart
;
6587 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6588 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6589 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6590 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6591 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6593 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6594 printf (_(" %#06x: Name: %s"),
6595 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6597 printf (_(" %#06x: Name index: %lx"),
6598 isum
, aux
.vna_name
);
6600 printf (_(" Flags: %s Version: %d\n"),
6601 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6603 isum
+= aux
.vna_next
;
6604 vstart
+= aux
.vna_next
;
6607 printf (_(" Version need aux past end of section\n"));
6611 if (cnt
< section
->sh_info
)
6612 printf (_(" Version need past end of section\n"));
6618 case SHT_GNU_versym
:
6620 Elf_Internal_Shdr
*link_section
;
6623 unsigned char *edata
;
6624 unsigned short *data
;
6626 Elf_Internal_Sym
*symbols
;
6627 Elf_Internal_Shdr
*string_sec
;
6630 if (section
->sh_link
>= elf_header
.e_shnum
)
6633 link_section
= section_headers
+ section
->sh_link
;
6634 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6636 if (link_section
->sh_link
>= elf_header
.e_shnum
)
6641 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6643 string_sec
= section_headers
+ link_section
->sh_link
;
6645 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6646 string_sec
->sh_size
, _("version string table"));
6650 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6651 SECTION_NAME (section
), total
);
6653 printf (_(" Addr: "));
6654 printf_vma (section
->sh_addr
);
6655 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6656 (unsigned long) section
->sh_offset
, section
->sh_link
,
6657 SECTION_NAME (link_section
));
6659 off
= offset_from_vma (file
,
6660 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6661 total
* sizeof (short));
6662 edata
= get_data (NULL
, file
, off
, total
, sizeof (short),
6663 _("version symbol data"));
6670 data
= cmalloc (total
, sizeof (short));
6672 for (cnt
= total
; cnt
--;)
6673 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6678 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6681 int check_def
, check_need
;
6684 printf (" %03x:", cnt
);
6686 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6687 switch (data
[cnt
+ j
])
6690 fputs (_(" 0 (*local*) "), stdout
);
6694 fputs (_(" 1 (*global*) "), stdout
);
6698 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6699 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6703 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
6704 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
6707 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6714 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6716 Elf_Internal_Verneed ivn
;
6717 unsigned long offset
;
6719 offset
= offset_from_vma
6720 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6721 sizeof (Elf_External_Verneed
));
6725 Elf_Internal_Vernaux ivna
;
6726 Elf_External_Verneed evn
;
6727 Elf_External_Vernaux evna
;
6728 unsigned long a_off
;
6730 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6733 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6734 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6736 a_off
= offset
+ ivn
.vn_aux
;
6740 get_data (&evna
, file
, a_off
, sizeof (evna
),
6741 1, _("version need aux (2)"));
6743 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6744 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6746 a_off
+= ivna
.vna_next
;
6748 while (ivna
.vna_other
!= data
[cnt
+ j
]
6749 && ivna
.vna_next
!= 0);
6751 if (ivna
.vna_other
== data
[cnt
+ j
])
6753 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6755 if (ivna
.vna_name
>= string_sec
->sh_size
)
6756 name
= _("*invalid*");
6758 name
= strtab
+ ivna
.vna_name
;
6759 nn
+= printf ("(%s%-*s",
6761 12 - (int) strlen (name
),
6767 offset
+= ivn
.vn_next
;
6769 while (ivn
.vn_next
);
6772 if (check_def
&& data
[cnt
+ j
] != 0x8001
6773 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6775 Elf_Internal_Verdef ivd
;
6776 Elf_External_Verdef evd
;
6777 unsigned long offset
;
6779 offset
= offset_from_vma
6780 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6785 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
6788 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6789 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6791 offset
+= ivd
.vd_next
;
6793 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6794 && ivd
.vd_next
!= 0);
6796 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6798 Elf_External_Verdaux evda
;
6799 Elf_Internal_Verdaux ivda
;
6801 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6803 get_data (&evda
, file
,
6804 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6806 _("version def aux"));
6808 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6810 if (ivda
.vda_name
>= string_sec
->sh_size
)
6811 name
= _("*invalid*");
6813 name
= strtab
+ ivda
.vda_name
;
6814 nn
+= printf ("(%s%-*s",
6816 12 - (int) strlen (name
),
6822 printf ("%*c", 18 - nn
, ' ');
6840 printf (_("\nNo version information found in this file.\n"));
6846 get_symbol_binding (unsigned int binding
)
6848 static char buff
[32];
6852 case STB_LOCAL
: return "LOCAL";
6853 case STB_GLOBAL
: return "GLOBAL";
6854 case STB_WEAK
: return "WEAK";
6856 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6857 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
6859 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6860 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
6862 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
6868 get_symbol_type (unsigned int type
)
6870 static char buff
[32];
6874 case STT_NOTYPE
: return "NOTYPE";
6875 case STT_OBJECT
: return "OBJECT";
6876 case STT_FUNC
: return "FUNC";
6877 case STT_SECTION
: return "SECTION";
6878 case STT_FILE
: return "FILE";
6879 case STT_COMMON
: return "COMMON";
6880 case STT_TLS
: return "TLS";
6881 case STT_RELC
: return "RELC";
6882 case STT_SRELC
: return "SRELC";
6884 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6886 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6887 return "THUMB_FUNC";
6889 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6892 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6893 return "PARISC_MILLI";
6895 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
6897 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6899 if (elf_header
.e_machine
== EM_PARISC
)
6901 if (type
== STT_HP_OPAQUE
)
6903 if (type
== STT_HP_STUB
)
6907 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
6910 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
6916 get_symbol_visibility (unsigned int visibility
)
6920 case STV_DEFAULT
: return "DEFAULT";
6921 case STV_INTERNAL
: return "INTERNAL";
6922 case STV_HIDDEN
: return "HIDDEN";
6923 case STV_PROTECTED
: return "PROTECTED";
6929 get_mips_symbol_other (unsigned int other
)
6933 case STO_OPTIONAL
: return "OPTIONAL";
6934 case STO_MIPS16
: return "MIPS16";
6935 case STO_MIPS_PLT
: return "MIPS PLT";
6936 case STO_MIPS_PIC
: return "MIPS PIC";
6937 default: return NULL
;
6942 get_symbol_other (unsigned int other
)
6944 const char * result
= NULL
;
6945 static char buff
[32];
6950 switch (elf_header
.e_machine
)
6953 result
= get_mips_symbol_other (other
);
6961 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
6966 get_symbol_index_type (unsigned int type
)
6968 static char buff
[32];
6972 case SHN_UNDEF
: return "UND";
6973 case SHN_ABS
: return "ABS";
6974 case SHN_COMMON
: return "COM";
6976 if (type
== SHN_IA_64_ANSI_COMMON
6977 && elf_header
.e_machine
== EM_IA_64
6978 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
6980 else if (elf_header
.e_machine
== EM_X86_64
6981 && type
== SHN_X86_64_LCOMMON
)
6983 else if (type
== SHN_MIPS_SCOMMON
6984 && elf_header
.e_machine
== EM_MIPS
)
6986 else if (type
== SHN_MIPS_SUNDEFINED
6987 && elf_header
.e_machine
== EM_MIPS
)
6989 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
6990 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
6991 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
6992 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
6993 else if (type
>= SHN_LORESERVE
)
6994 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
6996 sprintf (buff
, "%3d", type
);
7004 get_dynamic_data (FILE *file
, unsigned int number
, unsigned int ent_size
)
7006 unsigned char *e_data
;
7009 e_data
= cmalloc (number
, ent_size
);
7013 error (_("Out of memory\n"));
7017 if (fread (e_data
, ent_size
, number
, file
) != number
)
7019 error (_("Unable to read in dynamic data\n"));
7023 i_data
= cmalloc (number
, sizeof (*i_data
));
7027 error (_("Out of memory\n"));
7033 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
7041 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
7043 Elf_Internal_Sym
*psym
;
7046 psym
= dynamic_symbols
+ si
;
7048 n
= print_vma (si
, DEC_5
);
7050 fputs (" " + n
, stdout
);
7051 printf (" %3lu: ", hn
);
7052 print_vma (psym
->st_value
, LONG_HEX
);
7054 print_vma (psym
->st_size
, DEC_5
);
7056 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7057 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7058 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7059 /* Check to see if any other bits in the st_other field are set.
7060 Note - displaying this information disrupts the layout of the
7061 table being generated, but for the moment this case is very
7063 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7064 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7065 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
7066 if (VALID_DYNAMIC_NAME (psym
->st_name
))
7067 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
7069 printf (" <corrupt: %14ld>", psym
->st_name
);
7073 /* Dump the symbol table. */
7075 process_symbol_table (FILE *file
)
7077 Elf_Internal_Shdr
*section
;
7078 bfd_vma nbuckets
= 0;
7079 bfd_vma nchains
= 0;
7080 bfd_vma
*buckets
= NULL
;
7081 bfd_vma
*chains
= NULL
;
7082 bfd_vma ngnubuckets
= 0;
7083 bfd_vma
*gnubuckets
= NULL
;
7084 bfd_vma
*gnuchains
= NULL
;
7085 bfd_vma gnusymidx
= 0;
7087 if (! do_syms
&& !do_histogram
)
7090 if (dynamic_info
[DT_HASH
]
7092 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7094 unsigned char nb
[8];
7095 unsigned char nc
[8];
7096 int hash_ent_size
= 4;
7098 if ((elf_header
.e_machine
== EM_ALPHA
7099 || elf_header
.e_machine
== EM_S390
7100 || elf_header
.e_machine
== EM_S390_OLD
)
7101 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
7105 (archive_file_offset
7106 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
7107 sizeof nb
+ sizeof nc
)),
7110 error (_("Unable to seek to start of dynamic information\n"));
7114 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
7116 error (_("Failed to read in number of buckets\n"));
7120 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
7122 error (_("Failed to read in number of chains\n"));
7126 nbuckets
= byte_get (nb
, hash_ent_size
);
7127 nchains
= byte_get (nc
, hash_ent_size
);
7129 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
7130 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
7132 if (buckets
== NULL
|| chains
== NULL
)
7136 if (dynamic_info_DT_GNU_HASH
7138 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7140 unsigned char nb
[16];
7141 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
7142 bfd_vma buckets_vma
;
7145 (archive_file_offset
7146 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
7150 error (_("Unable to seek to start of dynamic information\n"));
7154 if (fread (nb
, 16, 1, file
) != 1)
7156 error (_("Failed to read in number of buckets\n"));
7160 ngnubuckets
= byte_get (nb
, 4);
7161 gnusymidx
= byte_get (nb
+ 4, 4);
7162 bitmaskwords
= byte_get (nb
+ 8, 4);
7163 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
7165 buckets_vma
+= bitmaskwords
* 4;
7167 buckets_vma
+= bitmaskwords
* 8;
7170 (archive_file_offset
7171 + offset_from_vma (file
, buckets_vma
, 4)),
7174 error (_("Unable to seek to start of dynamic information\n"));
7178 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
7180 if (gnubuckets
== NULL
)
7183 for (i
= 0; i
< ngnubuckets
; i
++)
7184 if (gnubuckets
[i
] != 0)
7186 if (gnubuckets
[i
] < gnusymidx
)
7189 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
7190 maxchain
= gnubuckets
[i
];
7193 if (maxchain
== 0xffffffff)
7196 maxchain
-= gnusymidx
;
7199 (archive_file_offset
7200 + offset_from_vma (file
, buckets_vma
7201 + 4 * (ngnubuckets
+ maxchain
), 4)),
7204 error (_("Unable to seek to start of dynamic information\n"));
7210 if (fread (nb
, 4, 1, file
) != 1)
7212 error (_("Failed to determine last chain length\n"));
7216 if (maxchain
+ 1 == 0)
7221 while ((byte_get (nb
, 4) & 1) == 0);
7224 (archive_file_offset
7225 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
7228 error (_("Unable to seek to start of dynamic information\n"));
7232 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
7234 if (gnuchains
== NULL
)
7238 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
7241 && dynamic_strings
!= NULL
)
7245 if (dynamic_info
[DT_HASH
])
7249 printf (_("\nSymbol table for image:\n"));
7251 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7253 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7255 for (hn
= 0; hn
< nbuckets
; hn
++)
7260 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
7261 print_dynamic_symbol (si
, hn
);
7265 if (dynamic_info_DT_GNU_HASH
)
7267 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
7269 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7271 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7273 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7274 if (gnubuckets
[hn
] != 0)
7276 bfd_vma si
= gnubuckets
[hn
];
7277 bfd_vma off
= si
- gnusymidx
;
7281 print_dynamic_symbol (si
, hn
);
7284 while ((gnuchains
[off
++] & 1) == 0);
7288 else if (do_syms
&& !do_using_dynamic
)
7292 for (i
= 0, section
= section_headers
;
7293 i
< elf_header
.e_shnum
;
7297 char *strtab
= NULL
;
7298 unsigned long int strtab_size
= 0;
7299 Elf_Internal_Sym
*symtab
;
7300 Elf_Internal_Sym
*psym
;
7303 if ( section
->sh_type
!= SHT_SYMTAB
7304 && section
->sh_type
!= SHT_DYNSYM
)
7307 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7308 SECTION_NAME (section
),
7309 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
7311 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7313 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7315 symtab
= GET_ELF_SYMBOLS (file
, section
);
7319 if (section
->sh_link
== elf_header
.e_shstrndx
)
7321 strtab
= string_table
;
7322 strtab_size
= string_table_length
;
7324 else if (section
->sh_link
< elf_header
.e_shnum
)
7326 Elf_Internal_Shdr
*string_sec
;
7328 string_sec
= section_headers
+ section
->sh_link
;
7330 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
7331 1, string_sec
->sh_size
, _("string table"));
7332 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
7335 for (si
= 0, psym
= symtab
;
7336 si
< section
->sh_size
/ section
->sh_entsize
;
7339 printf ("%6d: ", si
);
7340 print_vma (psym
->st_value
, LONG_HEX
);
7342 print_vma (psym
->st_size
, DEC_5
);
7343 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7344 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7345 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7346 /* Check to see if any other bits in the st_other field are set.
7347 Note - displaying this information disrupts the layout of the
7348 table being generated, but for the moment this case is very rare. */
7349 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7350 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7351 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
7352 print_symbol (25, psym
->st_name
< strtab_size
7353 ? strtab
+ psym
->st_name
: "<corrupt>");
7355 if (section
->sh_type
== SHT_DYNSYM
&&
7356 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
7358 unsigned char data
[2];
7359 unsigned short vers_data
;
7360 unsigned long offset
;
7364 offset
= offset_from_vma
7365 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7366 sizeof data
+ si
* sizeof (vers_data
));
7368 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
7369 sizeof (data
), 1, _("version data"));
7371 vers_data
= byte_get (data
, 2);
7373 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
7374 && section_headers
[psym
->st_shndx
].sh_type
7377 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
7379 if ((vers_data
& 0x8000) || vers_data
> 1)
7381 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
7382 && (is_nobits
|| ! check_def
))
7384 Elf_External_Verneed evn
;
7385 Elf_Internal_Verneed ivn
;
7386 Elf_Internal_Vernaux ivna
;
7388 /* We must test both. */
7389 offset
= offset_from_vma
7390 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7395 unsigned long vna_off
;
7397 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7400 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7401 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7403 vna_off
= offset
+ ivn
.vn_aux
;
7407 Elf_External_Vernaux evna
;
7409 get_data (&evna
, file
, vna_off
,
7411 _("version need aux (3)"));
7413 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7414 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7415 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7417 vna_off
+= ivna
.vna_next
;
7419 while (ivna
.vna_other
!= vers_data
7420 && ivna
.vna_next
!= 0);
7422 if (ivna
.vna_other
== vers_data
)
7425 offset
+= ivn
.vn_next
;
7427 while (ivn
.vn_next
!= 0);
7429 if (ivna
.vna_other
== vers_data
)
7432 ivna
.vna_name
< strtab_size
7433 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7437 else if (! is_nobits
)
7438 error (_("bad dynamic symbol\n"));
7445 if (vers_data
!= 0x8001
7446 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7448 Elf_Internal_Verdef ivd
;
7449 Elf_Internal_Verdaux ivda
;
7450 Elf_External_Verdaux evda
;
7451 unsigned long offset
;
7453 offset
= offset_from_vma
7455 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7456 sizeof (Elf_External_Verdef
));
7460 Elf_External_Verdef evd
;
7462 get_data (&evd
, file
, offset
, sizeof (evd
),
7463 1, _("version def"));
7465 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7466 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7467 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7469 offset
+= ivd
.vd_next
;
7471 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
7472 && ivd
.vd_next
!= 0);
7474 offset
-= ivd
.vd_next
;
7475 offset
+= ivd
.vd_aux
;
7477 get_data (&evda
, file
, offset
, sizeof (evda
),
7478 1, _("version def aux"));
7480 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7482 if (psym
->st_name
!= ivda
.vda_name
)
7483 printf ((vers_data
& 0x8000)
7485 ivda
.vda_name
< strtab_size
7486 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7496 if (strtab
!= string_table
)
7502 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7504 if (do_histogram
&& buckets
!= NULL
)
7506 unsigned long *lengths
;
7507 unsigned long *counts
;
7510 unsigned long maxlength
= 0;
7511 unsigned long nzero_counts
= 0;
7512 unsigned long nsyms
= 0;
7514 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7515 (unsigned long) nbuckets
);
7516 printf (_(" Length Number %% of total Coverage\n"));
7518 lengths
= calloc (nbuckets
, sizeof (*lengths
));
7519 if (lengths
== NULL
)
7521 error (_("Out of memory\n"));
7524 for (hn
= 0; hn
< nbuckets
; ++hn
)
7526 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7529 if (maxlength
< ++lengths
[hn
])
7534 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7537 error (_("Out of memory\n"));
7541 for (hn
= 0; hn
< nbuckets
; ++hn
)
7542 ++counts
[lengths
[hn
]];
7547 printf (" 0 %-10lu (%5.1f%%)\n",
7548 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7549 for (i
= 1; i
<= maxlength
; ++i
)
7551 nzero_counts
+= counts
[i
] * i
;
7552 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7553 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7554 (nzero_counts
* 100.0) / nsyms
);
7562 if (buckets
!= NULL
)
7568 if (do_histogram
&& dynamic_info_DT_GNU_HASH
)
7570 unsigned long *lengths
;
7571 unsigned long *counts
;
7573 unsigned long maxlength
= 0;
7574 unsigned long nzero_counts
= 0;
7575 unsigned long nsyms
= 0;
7577 lengths
= calloc (ngnubuckets
, sizeof (*lengths
));
7578 if (lengths
== NULL
)
7580 error (_("Out of memory\n"));
7584 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7585 (unsigned long) ngnubuckets
);
7586 printf (_(" Length Number %% of total Coverage\n"));
7588 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7589 if (gnubuckets
[hn
] != 0)
7591 bfd_vma off
, length
= 1;
7593 for (off
= gnubuckets
[hn
] - gnusymidx
;
7594 (gnuchains
[off
] & 1) == 0; ++off
)
7596 lengths
[hn
] = length
;
7597 if (length
> maxlength
)
7602 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7605 error (_("Out of memory\n"));
7609 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7610 ++counts
[lengths
[hn
]];
7612 if (ngnubuckets
> 0)
7615 printf (" 0 %-10lu (%5.1f%%)\n",
7616 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
7617 for (j
= 1; j
<= maxlength
; ++j
)
7619 nzero_counts
+= counts
[j
] * j
;
7620 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7621 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
7622 (nzero_counts
* 100.0) / nsyms
);
7636 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
7640 if (dynamic_syminfo
== NULL
7642 /* No syminfo, this is ok. */
7645 /* There better should be a dynamic symbol section. */
7646 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7650 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7651 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7653 printf (_(" Num: Name BoundTo Flags\n"));
7654 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7656 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7658 printf ("%4d: ", i
);
7659 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7660 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7662 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7665 switch (dynamic_syminfo
[i
].si_boundto
)
7667 case SYMINFO_BT_SELF
:
7668 fputs ("SELF ", stdout
);
7670 case SYMINFO_BT_PARENT
:
7671 fputs ("PARENT ", stdout
);
7674 if (dynamic_syminfo
[i
].si_boundto
> 0
7675 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7676 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7678 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7682 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7686 if (flags
& SYMINFO_FLG_DIRECT
)
7688 if (flags
& SYMINFO_FLG_PASSTHRU
)
7689 printf (" PASSTHRU");
7690 if (flags
& SYMINFO_FLG_COPY
)
7692 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7693 printf (" LAZYLOAD");
7701 #ifdef SUPPORT_DISASSEMBLY
7703 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
7705 printf (_("\nAssembly dump of section %s\n"),
7706 SECTION_NAME (section
));
7708 /* XXX -- to be done --- XXX */
7715 dump_section_as_strings (Elf_Internal_Shdr
*section
, FILE *file
)
7717 Elf_Internal_Shdr
*relsec
;
7718 bfd_size_type num_bytes
;
7723 char *name
= SECTION_NAME (section
);
7724 bfd_boolean some_strings_shown
;
7726 num_bytes
= section
->sh_size
;
7728 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7730 printf (_("\nSection '%s' has no data to dump.\n"), name
);
7734 addr
= section
->sh_addr
;
7736 start
= get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
7741 printf (_("\nString dump of section '%s':\n"), name
);
7743 /* If the section being dumped has relocations against it the user might
7744 be expecting these relocations to have been applied. Check for this
7745 case and issue a warning message in order to avoid confusion.
7746 FIXME: Maybe we ought to have an option that dumps a section with
7748 for (relsec
= section_headers
;
7749 relsec
< section_headers
+ elf_header
.e_shnum
;
7752 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
7753 || relsec
->sh_info
>= elf_header
.e_shnum
7754 || section_headers
+ relsec
->sh_info
!= section
7755 || relsec
->sh_size
== 0
7756 || relsec
->sh_link
>= elf_header
.e_shnum
)
7759 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7764 end
= start
+ num_bytes
;
7765 some_strings_shown
= FALSE
;
7769 while (!ISPRINT (* data
))
7776 printf (" [%6tx] %s\n", data
- start
, data
);
7778 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
7780 data
+= strlen (data
);
7781 some_strings_shown
= TRUE
;
7785 if (! some_strings_shown
)
7786 printf (_(" No strings found in this section."));
7796 dump_section_as_bytes (Elf_Internal_Shdr
*section
, FILE *file
)
7798 Elf_Internal_Shdr
*relsec
;
7799 bfd_size_type bytes
;
7801 unsigned char *data
;
7802 unsigned char *start
;
7804 bytes
= section
->sh_size
;
7806 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7808 printf (_("\nSection '%s' has no data to dump.\n"),
7809 SECTION_NAME (section
));
7813 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
7815 addr
= section
->sh_addr
;
7817 start
= get_data (NULL
, file
, section
->sh_offset
, 1, bytes
,
7822 /* If the section being dumped has relocations against it the user might
7823 be expecting these relocations to have been applied. Check for this
7824 case and issue a warning message in order to avoid confusion.
7825 FIXME: Maybe we ought to have an option that dumps a section with
7827 for (relsec
= section_headers
;
7828 relsec
< section_headers
+ elf_header
.e_shnum
;
7831 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
7832 || relsec
->sh_info
>= elf_header
.e_shnum
7833 || section_headers
+ relsec
->sh_info
!= section
7834 || relsec
->sh_size
== 0
7835 || relsec
->sh_link
>= elf_header
.e_shnum
)
7838 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7850 lbytes
= (bytes
> 16 ? 16 : bytes
);
7852 printf (" 0x%8.8lx ", (unsigned long) addr
);
7854 for (j
= 0; j
< 16; j
++)
7857 printf ("%2.2x", data
[j
]);
7865 for (j
= 0; j
< lbytes
; j
++)
7868 if (k
>= ' ' && k
< 0x7f)
7887 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
7888 DWARF debug sections. This is a target specific test. Note - we do not
7889 go through the whole including-target-headers-multiple-times route, (as
7890 we have already done with <elf/h8.h>) because this would become very
7891 messy and even then this function would have to contain target specific
7892 information (the names of the relocs instead of their numeric values).
7893 FIXME: This is not the correct way to solve this problem. The proper way
7894 is to have target specific reloc sizing and typing functions created by
7895 the reloc-macros.h header, in the same way that it already creates the
7896 reloc naming functions. */
7899 is_32bit_abs_reloc (unsigned int reloc_type
)
7901 switch (elf_header
.e_machine
)
7905 return reloc_type
== 1; /* R_386_32. */
7907 return reloc_type
== 1; /* R_68K_32. */
7909 return reloc_type
== 1; /* R_860_32. */
7911 return reloc_type
== 1; /* XXX Is this right ? */
7913 return reloc_type
== 1; /* R_ARC_32. */
7915 return reloc_type
== 2; /* R_ARM_ABS32 */
7918 return reloc_type
== 1;
7920 return reloc_type
== 0x12; /* R_byte4_data. */
7922 return reloc_type
== 3; /* R_CRIS_32. */
7925 return reloc_type
== 3; /* R_CR16_NUM32. */
7927 return reloc_type
== 15; /* R_CRX_NUM32. */
7929 return reloc_type
== 1;
7930 case EM_CYGNUS_D10V
:
7932 return reloc_type
== 6; /* R_D10V_32. */
7933 case EM_CYGNUS_D30V
:
7935 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
7937 return reloc_type
== 3; /* R_DLX_RELOC_32. */
7938 case EM_CYGNUS_FR30
:
7940 return reloc_type
== 3; /* R_FR30_32. */
7944 return reloc_type
== 1; /* R_H8_DIR32. */
7946 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
7949 return reloc_type
== 2; /* R_IP2K_32. */
7951 return reloc_type
== 2; /* R_IQ2000_32. */
7952 case EM_LATTICEMICO32
:
7953 return reloc_type
== 3; /* R_LM32_32. */
7956 return reloc_type
== 3; /* R_M32C_32. */
7958 return reloc_type
== 34; /* R_M32R_32_RELA. */
7960 return reloc_type
== 1; /* R_MCORE_ADDR32. */
7962 return reloc_type
== 4; /* R_MEP_32. */
7964 return reloc_type
== 2; /* R_MIPS_32. */
7966 return reloc_type
== 4; /* R_MMIX_32. */
7967 case EM_CYGNUS_MN10200
:
7969 return reloc_type
== 1; /* R_MN10200_32. */
7970 case EM_CYGNUS_MN10300
:
7972 return reloc_type
== 1; /* R_MN10300_32. */
7975 return reloc_type
== 1; /* R_MSP43_32. */
7977 return reloc_type
== 2; /* R_MT_32. */
7978 case EM_ALTERA_NIOS2
:
7980 return reloc_type
== 1; /* R_NIOS_32. */
7983 return reloc_type
== 1; /* R_OR32_32. */
7985 return reloc_type
== 1; /* R_PARISC_DIR32. */
7988 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
7990 return reloc_type
== 1; /* R_PPC64_ADDR32. */
7992 return reloc_type
== 1; /* R_PPC_ADDR32. */
7994 return reloc_type
== 1; /* R_I370_ADDR31. */
7997 return reloc_type
== 4; /* R_S390_32. */
7999 return reloc_type
== 8; /* R_SCORE_ABS32. */
8001 return reloc_type
== 1; /* R_SH_DIR32. */
8002 case EM_SPARC32PLUS
:
8005 return reloc_type
== 3 /* R_SPARC_32. */
8006 || reloc_type
== 23; /* R_SPARC_UA32. */
8008 return reloc_type
== 6; /* R_SPU_ADDR32 */
8009 case EM_CYGNUS_V850
:
8011 return reloc_type
== 6; /* R_V850_ABS32. */
8013 return reloc_type
== 1; /* R_VAX_32. */
8015 return reloc_type
== 10; /* R_X86_64_32. */
8017 return reloc_type
== 1; /* R_XSTROMY16_32. */
8020 return reloc_type
== 1; /* R_XTENSA_32. */
8023 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
8024 elf_header
.e_machine
);
8029 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8030 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
8033 is_32bit_pcrel_reloc (unsigned int reloc_type
)
8035 switch (elf_header
.e_machine
)
8039 return reloc_type
== 2; /* R_386_PC32. */
8041 return reloc_type
== 4; /* R_68K_PC32. */
8043 return reloc_type
== 10; /* R_ALPHA_SREL32. */
8045 return reloc_type
== 3; /* R_ARM_REL32 */
8047 return reloc_type
== 9; /* R_PARISC_PCREL32. */
8049 return reloc_type
== 26; /* R_PPC_REL32. */
8051 return reloc_type
== 26; /* R_PPC64_REL32. */
8054 return reloc_type
== 5; /* R_390_PC32. */
8056 return reloc_type
== 2; /* R_SH_REL32. */
8057 case EM_SPARC32PLUS
:
8060 return reloc_type
== 6; /* R_SPARC_DISP32. */
8062 return reloc_type
== 13; /* R_SPU_REL32. */
8064 return reloc_type
== 2; /* R_X86_64_PC32. */
8067 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
8069 /* Do not abort or issue an error message here. Not all targets use
8070 pc-relative 32-bit relocs in their DWARF debug information and we
8071 have already tested for target coverage in is_32bit_abs_reloc. A
8072 more helpful warning message will be generated by
8073 debug_apply_relocations anyway, so just return. */
8078 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8079 a 64-bit absolute RELA relocation used in DWARF debug sections. */
8082 is_64bit_abs_reloc (unsigned int reloc_type
)
8084 switch (elf_header
.e_machine
)
8087 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
8089 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
8091 return reloc_type
== 80; /* R_PARISC_DIR64. */
8093 return reloc_type
== 38; /* R_PPC64_ADDR64. */
8094 case EM_SPARC32PLUS
:
8097 return reloc_type
== 54; /* R_SPARC_UA64. */
8099 return reloc_type
== 1; /* R_X86_64_64. */
8102 return reloc_type
== 22; /* R_S390_64 */
8104 return reloc_type
== 18; /* R_MIPS_64 */
8110 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
8111 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
8114 is_64bit_pcrel_reloc (unsigned int reloc_type
)
8116 switch (elf_header
.e_machine
)
8119 return reloc_type
== 11; /* R_ALPHA_SREL64 */
8121 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB */
8123 return reloc_type
== 72; /* R_PARISC_PCREL64 */
8125 return reloc_type
== 44; /* R_PPC64_REL64 */
8126 case EM_SPARC32PLUS
:
8129 return reloc_type
== 46; /* R_SPARC_DISP64 */
8131 return reloc_type
== 24; /* R_X86_64_PC64 */
8134 return reloc_type
== 23; /* R_S390_PC64 */
8140 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8141 a 16-bit absolute RELA relocation used in DWARF debug sections. */
8144 is_16bit_abs_reloc (unsigned int reloc_type
)
8146 switch (elf_header
.e_machine
)
8150 return reloc_type
== 4; /* R_AVR_16. */
8151 case EM_CYGNUS_D10V
:
8153 return reloc_type
== 3; /* R_D10V_16. */
8157 return reloc_type
== R_H8_DIR16
;
8160 return reloc_type
== 1; /* R_IP2K_16. */
8163 return reloc_type
== 1; /* R_M32C_16 */
8166 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
8167 case EM_ALTERA_NIOS2
:
8169 return reloc_type
== 9; /* R_NIOS_16. */
8175 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
8176 relocation entries (possibly formerly used for SHT_GROUP sections). */
8179 is_none_reloc (unsigned int reloc_type
)
8181 switch (elf_header
.e_machine
)
8183 case EM_68K
: /* R_68K_NONE. */
8184 case EM_386
: /* R_386_NONE. */
8185 case EM_SPARC32PLUS
:
8187 case EM_SPARC
: /* R_SPARC_NONE. */
8188 case EM_MIPS
: /* R_MIPS_NONE. */
8189 case EM_PARISC
: /* R_PARISC_NONE. */
8190 case EM_ALPHA
: /* R_ALPHA_NONE. */
8191 case EM_PPC
: /* R_PPC_NONE. */
8192 case EM_PPC64
: /* R_PPC64_NONE. */
8193 case EM_ARM
: /* R_ARM_NONE. */
8194 case EM_IA_64
: /* R_IA64_NONE. */
8195 case EM_SH
: /* R_SH_NONE. */
8197 case EM_S390
: /* R_390_NONE. */
8198 case EM_CRIS
: /* R_CRIS_NONE. */
8199 case EM_X86_64
: /* R_X86_64_NONE. */
8200 case EM_MN10300
: /* R_MN10300_NONE. */
8201 case EM_M32R
: /* R_M32R_NONE. */
8202 return reloc_type
== 0;
8207 /* Uncompresses a section that was compressed using zlib, in place.
8208 This is a copy of bfd_uncompress_section_contents, in bfd/compress.c */
8211 uncompress_section_contents (unsigned char **buffer
, dwarf_size_type
*size
)
8214 /* These are just to quiet gcc. */
8219 dwarf_size_type compressed_size
= *size
;
8220 unsigned char * compressed_buffer
= *buffer
;
8221 dwarf_size_type uncompressed_size
;
8222 unsigned char * uncompressed_buffer
;
8225 dwarf_size_type header_size
= 12;
8227 /* Read the zlib header. In this case, it should be "ZLIB" followed
8228 by the uncompressed section size, 8 bytes in big-endian order. */
8229 if (compressed_size
< header_size
8230 || ! streq ((char *) compressed_buffer
, "ZLIB"))
8233 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
8234 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
8235 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
8236 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
8237 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
8238 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
8239 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
8240 uncompressed_size
+= compressed_buffer
[11];
8242 /* It is possible the section consists of several compressed
8243 buffers concatenated together, so we uncompress in a loop. */
8247 strm
.avail_in
= compressed_size
- header_size
;
8248 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
8249 strm
.avail_out
= uncompressed_size
;
8250 uncompressed_buffer
= xmalloc (uncompressed_size
);
8252 rc
= inflateInit (& strm
);
8253 while (strm
.avail_in
> 0)
8257 strm
.next_out
= ((Bytef
*) uncompressed_buffer
8258 + (uncompressed_size
- strm
.avail_out
));
8259 rc
= inflate (&strm
, Z_FINISH
);
8260 if (rc
!= Z_STREAM_END
)
8262 rc
= inflateReset (& strm
);
8264 rc
= inflateEnd (& strm
);
8266 || strm
.avail_out
!= 0)
8269 free (compressed_buffer
);
8270 *buffer
= uncompressed_buffer
;
8271 *size
= uncompressed_size
;
8275 free (uncompressed_buffer
);
8277 #endif /* HAVE_ZLIB_H */
8280 /* Apply relocations to a debug section. */
8283 debug_apply_relocations (void *file
,
8284 Elf_Internal_Shdr
*section
,
8285 unsigned char *start
)
8287 Elf_Internal_Shdr
*relsec
;
8288 unsigned char *end
= start
+ section
->sh_size
;
8290 if (elf_header
.e_type
!= ET_REL
)
8293 /* Find the reloc section associated with the debug section. */
8294 for (relsec
= section_headers
;
8295 relsec
< section_headers
+ elf_header
.e_shnum
;
8298 bfd_boolean is_rela
;
8299 unsigned long num_relocs
;
8300 Elf_Internal_Rela
*relocs
, *rp
;
8301 Elf_Internal_Shdr
*symsec
;
8302 Elf_Internal_Sym
*symtab
;
8303 Elf_Internal_Sym
*sym
;
8305 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8306 || relsec
->sh_info
>= elf_header
.e_shnum
8307 || section_headers
+ relsec
->sh_info
!= section
8308 || relsec
->sh_size
== 0
8309 || relsec
->sh_link
>= elf_header
.e_shnum
)
8312 is_rela
= relsec
->sh_type
== SHT_RELA
;
8316 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8317 & relocs
, & num_relocs
))
8322 if (!slurp_rel_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8323 & relocs
, & num_relocs
))
8327 /* SH uses RELA but uses in place value instead of the addend field. */
8328 if (elf_header
.e_machine
== EM_SH
)
8331 symsec
= section_headers
+ relsec
->sh_link
;
8332 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
8334 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
8337 unsigned int reloc_type
;
8338 unsigned int reloc_size
;
8339 unsigned char * loc
;
8341 reloc_type
= get_reloc_type (rp
->r_info
);
8343 if (is_none_reloc (reloc_type
))
8346 if (is_32bit_abs_reloc (reloc_type
)
8347 || is_32bit_pcrel_reloc (reloc_type
))
8349 else if (is_64bit_abs_reloc (reloc_type
)
8350 || is_64bit_pcrel_reloc (reloc_type
))
8352 else if (is_16bit_abs_reloc (reloc_type
))
8356 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
8357 reloc_type
, SECTION_NAME (section
));
8361 loc
= start
+ rp
->r_offset
;
8362 if ((loc
+ reloc_size
) > end
)
8364 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
8365 (unsigned long) rp
->r_offset
,
8366 SECTION_NAME (section
));
8370 sym
= symtab
+ get_reloc_symindex (rp
->r_info
);
8372 /* If the reloc has a symbol associated with it,
8373 make sure that it is of an appropriate type. */
8375 && ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
8376 /* Relocations against symbols without type can happen.
8377 Gcc -feliminate-dwarf2-dups may generate symbols
8378 without type for debug info. */
8379 && ELF_ST_TYPE (sym
->st_info
) != STT_NOTYPE
8380 /* Relocations against object symbols can happen,
8381 eg when referencing a global array. For an
8382 example of this see the _clz.o binary in libgcc.a. */
8383 && ELF_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
8385 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
8386 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
8387 (long int)(rp
- relocs
),
8388 SECTION_NAME (relsec
));
8392 addend
= is_rela
? rp
->r_addend
: byte_get (loc
, reloc_size
);
8394 if (is_32bit_pcrel_reloc (reloc_type
)
8395 || is_64bit_pcrel_reloc (reloc_type
))
8397 /* On HPPA, all pc-relative relocations are biased by 8. */
8398 if (elf_header
.e_machine
== EM_PARISC
)
8400 byte_put (loc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
8404 byte_put (loc
, addend
+ sym
->st_value
, reloc_size
);
8414 load_specific_debug_section (enum dwarf_section_display_enum debug
,
8415 Elf_Internal_Shdr
*sec
, void *file
)
8417 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
8419 int section_is_compressed
;
8421 /* If it is already loaded, do nothing. */
8422 if (section
->start
!= NULL
)
8425 section_is_compressed
= section
->name
== section
->compressed_name
;
8427 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
8428 section
->address
= sec
->sh_addr
;
8429 section
->size
= sec
->sh_size
;
8430 section
->start
= get_data (NULL
, file
, sec
->sh_offset
, 1,
8432 if (section
->start
== NULL
)
8435 if (section_is_compressed
)
8436 if (! uncompress_section_contents (§ion
->start
, §ion
->size
))
8439 if (debug_displays
[debug
].relocate
)
8440 debug_apply_relocations (file
, sec
, section
->start
);
8446 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
8448 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
8449 Elf_Internal_Shdr
*sec
;
8451 /* Locate the debug section. */
8452 sec
= find_section (section
->uncompressed_name
);
8454 section
->name
= section
->uncompressed_name
;
8457 sec
= find_section (section
->compressed_name
);
8459 section
->name
= section
->compressed_name
;
8464 return load_specific_debug_section (debug
, sec
, file
);
8468 free_debug_section (enum dwarf_section_display_enum debug
)
8470 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
8472 if (section
->start
== NULL
)
8475 free ((char *) section
->start
);
8476 section
->start
= NULL
;
8477 section
->address
= 0;
8482 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
8484 char *name
= SECTION_NAME (section
);
8485 bfd_size_type length
;
8487 enum dwarf_section_display_enum i
;
8489 length
= section
->sh_size
;
8492 printf (_("\nSection '%s' has no debugging data.\n"), name
);
8496 if (const_strneq (name
, ".gnu.linkonce.wi."))
8497 name
= ".debug_info";
8499 /* See if we know how to display the contents of this section. */
8500 for (i
= 0; i
< max
; i
++)
8501 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
8502 || streq (debug_displays
[i
].section
.compressed_name
, name
))
8504 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
8505 int secondary
= (section
!= find_section (name
));
8508 free_debug_section (i
);
8510 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
))
8511 sec
->name
= sec
->uncompressed_name
;
8513 sec
->name
= sec
->compressed_name
;
8514 if (load_specific_debug_section (i
, section
, file
))
8516 result
&= debug_displays
[i
].display (sec
, file
);
8518 if (secondary
|| (i
!= info
&& i
!= abbrev
))
8519 free_debug_section (i
);
8527 printf (_("Unrecognized debug section: %s\n"), name
);
8534 /* Set DUMP_SECTS for all sections where dumps were requested
8535 based on section name. */
8538 initialise_dumps_byname (void)
8540 struct dump_list_entry
*cur
;
8542 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
8547 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
8548 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
8550 request_dump_bynumber (i
, cur
->type
);
8555 warn (_("Section '%s' was not dumped because it does not exist!\n"),
8561 process_section_contents (FILE *file
)
8563 Elf_Internal_Shdr
*section
;
8569 initialise_dumps_byname ();
8571 for (i
= 0, section
= section_headers
;
8572 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
8575 #ifdef SUPPORT_DISASSEMBLY
8576 if (dump_sects
[i
] & DISASS_DUMP
)
8577 disassemble_section (section
, file
);
8579 if (dump_sects
[i
] & HEX_DUMP
)
8580 dump_section_as_bytes (section
, file
);
8582 if (dump_sects
[i
] & DEBUG_DUMP
)
8583 display_debug_section (section
, file
);
8585 if (dump_sects
[i
] & STRING_DUMP
)
8586 dump_section_as_strings (section
, file
);
8589 /* Check to see if the user requested a
8590 dump of a section that does not exist. */
8591 while (i
++ < num_dump_sects
)
8593 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
8597 process_mips_fpe_exception (int mask
)
8602 if (mask
& OEX_FPU_INEX
)
8603 fputs ("INEX", stdout
), first
= 0;
8604 if (mask
& OEX_FPU_UFLO
)
8605 printf ("%sUFLO", first
? "" : "|"), first
= 0;
8606 if (mask
& OEX_FPU_OFLO
)
8607 printf ("%sOFLO", first
? "" : "|"), first
= 0;
8608 if (mask
& OEX_FPU_DIV0
)
8609 printf ("%sDIV0", first
? "" : "|"), first
= 0;
8610 if (mask
& OEX_FPU_INVAL
)
8611 printf ("%sINVAL", first
? "" : "|");
8614 fputs ("0", stdout
);
8617 /* ARM EABI attributes section. */
8622 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
8625 } arm_attr_public_tag
;
8627 static const char *arm_attr_tag_CPU_arch
[] =
8628 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
8629 "v6K", "v7", "v6-M", "v6S-M"};
8630 static const char *arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
8631 static const char *arm_attr_tag_THUMB_ISA_use
[] =
8632 {"No", "Thumb-1", "Thumb-2"};
8633 static const char *arm_attr_tag_VFP_arch
[] =
8634 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16"};
8635 static const char *arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
8636 static const char *arm_attr_tag_Advanced_SIMD_arch
[] = {"No", "NEONv1"};
8637 static const char *arm_attr_tag_PCS_config
[] =
8638 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
8639 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
8640 static const char *arm_attr_tag_ABI_PCS_R9_use
[] =
8641 {"V6", "SB", "TLS", "Unused"};
8642 static const char *arm_attr_tag_ABI_PCS_RW_data
[] =
8643 {"Absolute", "PC-relative", "SB-relative", "None"};
8644 static const char *arm_attr_tag_ABI_PCS_RO_data
[] =
8645 {"Absolute", "PC-relative", "None"};
8646 static const char *arm_attr_tag_ABI_PCS_GOT_use
[] =
8647 {"None", "direct", "GOT-indirect"};
8648 static const char *arm_attr_tag_ABI_PCS_wchar_t
[] =
8649 {"None", "??? 1", "2", "??? 3", "4"};
8650 static const char *arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
8651 static const char *arm_attr_tag_ABI_FP_denormal
[] =
8652 {"Unused", "Needed", "Sign only"};
8653 static const char *arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
8654 static const char *arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
8655 static const char *arm_attr_tag_ABI_FP_number_model
[] =
8656 {"Unused", "Finite", "RTABI", "IEEE 754"};
8657 static const char *arm_attr_tag_ABI_align8_needed
[] = {"No", "Yes", "4-byte"};
8658 static const char *arm_attr_tag_ABI_align8_preserved
[] =
8659 {"No", "Yes, except leaf SP", "Yes"};
8660 static const char *arm_attr_tag_ABI_enum_size
[] =
8661 {"Unused", "small", "int", "forced to int"};
8662 static const char *arm_attr_tag_ABI_HardFP_use
[] =
8663 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
8664 static const char *arm_attr_tag_ABI_VFP_args
[] =
8665 {"AAPCS", "VFP registers", "custom"};
8666 static const char *arm_attr_tag_ABI_WMMX_args
[] =
8667 {"AAPCS", "WMMX registers", "custom"};
8668 static const char *arm_attr_tag_ABI_optimization_goals
[] =
8669 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8670 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
8671 static const char *arm_attr_tag_ABI_FP_optimization_goals
[] =
8672 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8673 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
8674 static const char *arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
8675 static const char *arm_attr_tag_VFP_HP_extension
[] =
8676 {"Not Allowed", "Allowed"};
8677 static const char *arm_attr_tag_ABI_FP_16bit_format
[] =
8678 {"None", "IEEE 754", "Alternative Format"};
8679 static const char *arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
8680 static const char *arm_attr_tag_Virtualization_use
[] =
8681 {"Not Allowed", "Allowed"};
8682 static const char *arm_attr_tag_MPextension_use
[] = {"Not Allowed", "Allowed"};
8684 #define LOOKUP(id, name) \
8685 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
8686 static arm_attr_public_tag arm_attr_public_tags
[] =
8688 {4, "CPU_raw_name", 1, NULL
},
8689 {5, "CPU_name", 1, NULL
},
8690 LOOKUP(6, CPU_arch
),
8691 {7, "CPU_arch_profile", 0, NULL
},
8692 LOOKUP(8, ARM_ISA_use
),
8693 LOOKUP(9, THUMB_ISA_use
),
8694 LOOKUP(10, VFP_arch
),
8695 LOOKUP(11, WMMX_arch
),
8696 LOOKUP(12, Advanced_SIMD_arch
),
8697 LOOKUP(13, PCS_config
),
8698 LOOKUP(14, ABI_PCS_R9_use
),
8699 LOOKUP(15, ABI_PCS_RW_data
),
8700 LOOKUP(16, ABI_PCS_RO_data
),
8701 LOOKUP(17, ABI_PCS_GOT_use
),
8702 LOOKUP(18, ABI_PCS_wchar_t
),
8703 LOOKUP(19, ABI_FP_rounding
),
8704 LOOKUP(20, ABI_FP_denormal
),
8705 LOOKUP(21, ABI_FP_exceptions
),
8706 LOOKUP(22, ABI_FP_user_exceptions
),
8707 LOOKUP(23, ABI_FP_number_model
),
8708 LOOKUP(24, ABI_align8_needed
),
8709 LOOKUP(25, ABI_align8_preserved
),
8710 LOOKUP(26, ABI_enum_size
),
8711 LOOKUP(27, ABI_HardFP_use
),
8712 LOOKUP(28, ABI_VFP_args
),
8713 LOOKUP(29, ABI_WMMX_args
),
8714 LOOKUP(30, ABI_optimization_goals
),
8715 LOOKUP(31, ABI_FP_optimization_goals
),
8716 {32, "compatibility", 0, NULL
},
8717 LOOKUP(34, CPU_unaligned_access
),
8718 LOOKUP(36, VFP_HP_extension
),
8719 LOOKUP(38, ABI_FP_16bit_format
),
8720 {64, "nodefaults", 0, NULL
},
8721 {65, "also_compatible_with", 0, NULL
},
8722 LOOKUP(66, T2EE_use
),
8723 {67, "conformance", 1, NULL
},
8724 LOOKUP(68, Virtualization_use
),
8725 LOOKUP(70, MPextension_use
)
8729 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
8732 read_uleb128 (unsigned char *p
, unsigned int *plen
)
8746 val
|= ((unsigned int)c
& 0x7f) << shift
;
8755 static unsigned char *
8756 display_arm_attribute (unsigned char *p
)
8761 arm_attr_public_tag
*attr
;
8765 tag
= read_uleb128 (p
, &len
);
8768 for (i
= 0; i
< ARRAY_SIZE(arm_attr_public_tags
); i
++)
8770 if (arm_attr_public_tags
[i
].tag
== tag
)
8772 attr
= &arm_attr_public_tags
[i
];
8779 printf (" Tag_%s: ", attr
->name
);
8785 case 7: /* Tag_CPU_arch_profile. */
8786 val
= read_uleb128 (p
, &len
);
8790 case 0: printf ("None\n"); break;
8791 case 'A': printf ("Application\n"); break;
8792 case 'R': printf ("Realtime\n"); break;
8793 case 'M': printf ("Microcontroller\n"); break;
8794 default: printf ("??? (%d)\n", val
); break;
8798 case 32: /* Tag_compatibility. */
8799 val
= read_uleb128 (p
, &len
);
8801 printf ("flag = %d, vendor = %s\n", val
, p
);
8802 p
+= strlen((char *)p
) + 1;
8805 case 64: /* Tag_nodefaults. */
8810 case 65: /* Tag_also_compatible_with. */
8811 val
= read_uleb128 (p
, &len
);
8813 if (val
== 6 /* Tag_CPU_arch. */)
8815 val
= read_uleb128 (p
, &len
);
8817 if ((unsigned int)val
>= ARRAY_SIZE(arm_attr_tag_CPU_arch
))
8818 printf ("??? (%d)\n", val
);
8820 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
8824 while (*(p
++) != '\0' /* NUL terminator. */);
8838 assert (attr
->type
& 0x80);
8839 val
= read_uleb128 (p
, &len
);
8841 type
= attr
->type
& 0x7f;
8843 printf ("??? (%d)\n", val
);
8845 printf ("%s\n", attr
->table
[val
]);
8852 type
= 1; /* String. */
8854 type
= 2; /* uleb128. */
8855 printf (" Tag_unknown_%d: ", tag
);
8860 printf ("\"%s\"\n", p
);
8861 p
+= strlen((char *)p
) + 1;
8865 val
= read_uleb128 (p
, &len
);
8867 printf ("%d (0x%x)\n", val
, val
);
8873 static unsigned char *
8874 display_gnu_attribute (unsigned char * p
,
8875 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
8882 tag
= read_uleb128 (p
, &len
);
8885 /* Tag_compatibility is the only generic GNU attribute defined at
8889 val
= read_uleb128 (p
, &len
);
8891 printf ("flag = %d, vendor = %s\n", val
, p
);
8892 p
+= strlen ((char *) p
) + 1;
8896 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
8897 return display_proc_gnu_attribute (p
, tag
);
8900 type
= 1; /* String. */
8902 type
= 2; /* uleb128. */
8903 printf (" Tag_unknown_%d: ", tag
);
8907 printf ("\"%s\"\n", p
);
8908 p
+= strlen ((char *) p
) + 1;
8912 val
= read_uleb128 (p
, &len
);
8914 printf ("%d (0x%x)\n", val
, val
);
8920 static unsigned char *
8921 display_power_gnu_attribute (unsigned char *p
, int tag
)
8927 if (tag
== Tag_GNU_Power_ABI_FP
)
8929 val
= read_uleb128 (p
, &len
);
8931 printf (" Tag_GNU_Power_ABI_FP: ");
8936 printf ("Hard or soft float\n");
8939 printf ("Hard float\n");
8942 printf ("Soft float\n");
8945 printf ("Single-precision hard float\n");
8948 printf ("??? (%d)\n", val
);
8954 if (tag
== Tag_GNU_Power_ABI_Vector
)
8956 val
= read_uleb128 (p
, &len
);
8958 printf (" Tag_GNU_Power_ABI_Vector: ");
8965 printf ("Generic\n");
8968 printf ("AltiVec\n");
8974 printf ("??? (%d)\n", val
);
8980 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
8982 val
= read_uleb128 (p
, &len
);
8984 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
8994 printf ("Memory\n");
8997 printf ("??? (%d)\n", val
);
9004 type
= 1; /* String. */
9006 type
= 2; /* uleb128. */
9007 printf (" Tag_unknown_%d: ", tag
);
9011 printf ("\"%s\"\n", p
);
9012 p
+= strlen ((char *) p
) + 1;
9016 val
= read_uleb128 (p
, &len
);
9018 printf ("%d (0x%x)\n", val
, val
);
9024 static unsigned char *
9025 display_mips_gnu_attribute (unsigned char *p
, int tag
)
9031 if (tag
== Tag_GNU_MIPS_ABI_FP
)
9033 val
= read_uleb128 (p
, &len
);
9035 printf (" Tag_GNU_MIPS_ABI_FP: ");
9040 printf ("Hard or soft float\n");
9043 printf ("Hard float (-mdouble-float)\n");
9046 printf ("Hard float (-msingle-float)\n");
9049 printf ("Soft float\n");
9052 printf ("64-bit float (-mips32r2 -mfp64)\n");
9055 printf ("??? (%d)\n", val
);
9062 type
= 1; /* String. */
9064 type
= 2; /* uleb128. */
9065 printf (" Tag_unknown_%d: ", tag
);
9069 printf ("\"%s\"\n", p
);
9070 p
+= strlen ((char *) p
) + 1;
9074 val
= read_uleb128 (p
, &len
);
9076 printf ("%d (0x%x)\n", val
, val
);
9083 process_attributes (FILE * file
,
9084 const char * public_name
,
9085 unsigned int proc_type
,
9086 unsigned char * (* display_pub_attribute
) (unsigned char *),
9087 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
9089 Elf_Internal_Shdr
*sect
;
9090 unsigned char *contents
;
9093 bfd_vma section_len
;
9097 /* Find the section header so that we get the size. */
9098 for (i
= 0, sect
= section_headers
;
9099 i
< elf_header
.e_shnum
;
9102 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
9105 contents
= get_data (NULL
, file
, sect
->sh_offset
, 1, sect
->sh_size
,
9107 if (contents
== NULL
)
9113 len
= sect
->sh_size
- 1;
9119 bfd_boolean public_section
;
9120 bfd_boolean gnu_section
;
9122 section_len
= byte_get (p
, 4);
9125 if (section_len
> len
)
9127 printf (_("ERROR: Bad section length (%d > %d)\n"),
9128 (int) section_len
, (int) len
);
9133 printf ("Attribute Section: %s\n", p
);
9135 if (public_name
&& streq ((char *) p
, public_name
))
9136 public_section
= TRUE
;
9138 public_section
= FALSE
;
9140 if (streq ((char *) p
, "gnu"))
9143 gnu_section
= FALSE
;
9145 namelen
= strlen ((char *) p
) + 1;
9147 section_len
-= namelen
+ 4;
9149 while (section_len
> 0)
9155 size
= byte_get (p
, 4);
9156 if (size
> section_len
)
9158 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
9159 (int) size
, (int) section_len
);
9163 section_len
-= size
;
9170 printf ("File Attributes\n");
9173 printf ("Section Attributes:");
9176 printf ("Symbol Attributes:");
9182 val
= read_uleb128 (p
, &i
);
9186 printf (" %d", val
);
9191 printf ("Unknown tag: %d\n", tag
);
9192 public_section
= FALSE
;
9199 p
= display_pub_attribute (p
);
9201 else if (gnu_section
)
9204 p
= display_gnu_attribute (p
,
9205 display_proc_gnu_attribute
);
9209 /* ??? Do something sensible, like dump hex. */
9210 printf (" Unknown section contexts\n");
9217 printf (_("Unknown format '%c'\n"), *p
);
9225 process_arm_specific (FILE *file
)
9227 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
9228 display_arm_attribute
, NULL
);
9232 process_power_specific (FILE *file
)
9234 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9235 display_power_gnu_attribute
);
9238 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
9239 Print the Address, Access and Initial fields of an entry at VMA ADDR
9240 and return the VMA of the next entry. */
9243 print_mips_got_entry (unsigned char *data
, bfd_vma pltgot
, bfd_vma addr
)
9246 print_vma (addr
, LONG_HEX
);
9248 if (addr
< pltgot
+ 0xfff0)
9249 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
9251 printf ("%10s", "");
9254 printf ("%*s", is_32bit_elf
? 8 : 16, "<unknown>");
9259 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
9260 print_vma (entry
, LONG_HEX
);
9262 return addr
+ (is_32bit_elf
? 4 : 8);
9265 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
9266 PLTGOT. Print the Address and Initial fields of an entry at VMA
9267 ADDR and return the VMA of the next entry. */
9270 print_mips_pltgot_entry (unsigned char *data
, bfd_vma pltgot
, bfd_vma addr
)
9273 print_vma (addr
, LONG_HEX
);
9276 printf ("%*s", is_32bit_elf
? 8 : 16, "<unknown>");
9281 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
9282 print_vma (entry
, LONG_HEX
);
9284 return addr
+ (is_32bit_elf
? 4 : 8);
9288 process_mips_specific (FILE *file
)
9290 Elf_Internal_Dyn
*entry
;
9291 size_t liblist_offset
= 0;
9292 size_t liblistno
= 0;
9293 size_t conflictsno
= 0;
9294 size_t options_offset
= 0;
9295 size_t conflicts_offset
= 0;
9296 size_t pltrelsz
= 0;
9299 bfd_vma mips_pltgot
= 0;
9301 bfd_vma local_gotno
= 0;
9303 bfd_vma symtabno
= 0;
9305 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9306 display_mips_gnu_attribute
);
9308 /* We have a lot of special sections. Thanks SGI! */
9309 if (dynamic_section
== NULL
)
9310 /* No information available. */
9313 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
9314 switch (entry
->d_tag
)
9316 case DT_MIPS_LIBLIST
:
9318 = offset_from_vma (file
, entry
->d_un
.d_val
,
9319 liblistno
* sizeof (Elf32_External_Lib
));
9321 case DT_MIPS_LIBLISTNO
:
9322 liblistno
= entry
->d_un
.d_val
;
9324 case DT_MIPS_OPTIONS
:
9325 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9327 case DT_MIPS_CONFLICT
:
9329 = offset_from_vma (file
, entry
->d_un
.d_val
,
9330 conflictsno
* sizeof (Elf32_External_Conflict
));
9332 case DT_MIPS_CONFLICTNO
:
9333 conflictsno
= entry
->d_un
.d_val
;
9336 pltgot
= entry
->d_un
.d_ptr
;
9338 case DT_MIPS_LOCAL_GOTNO
:
9339 local_gotno
= entry
->d_un
.d_val
;
9341 case DT_MIPS_GOTSYM
:
9342 gotsym
= entry
->d_un
.d_val
;
9344 case DT_MIPS_SYMTABNO
:
9345 symtabno
= entry
->d_un
.d_val
;
9347 case DT_MIPS_PLTGOT
:
9348 mips_pltgot
= entry
->d_un
.d_ptr
;
9351 pltrel
= entry
->d_un
.d_val
;
9354 pltrelsz
= entry
->d_un
.d_val
;
9357 jmprel
= entry
->d_un
.d_ptr
;
9363 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9365 Elf32_External_Lib
*elib
;
9368 elib
= get_data (NULL
, file
, liblist_offset
,
9369 liblistno
, sizeof (Elf32_External_Lib
),
9373 printf ("\nSection '.liblist' contains %lu entries:\n",
9374 (unsigned long) liblistno
);
9375 fputs (" Library Time Stamp Checksum Version Flags\n",
9378 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9385 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9386 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9387 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9388 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9389 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9391 tmp
= gmtime (&time
);
9392 snprintf (timebuf
, sizeof (timebuf
),
9393 "%04u-%02u-%02uT%02u:%02u:%02u",
9394 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9395 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9397 printf ("%3lu: ", (unsigned long) cnt
);
9398 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
9399 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
9401 printf ("<corrupt: %9ld>", liblist
.l_name
);
9402 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9405 if (liblist
.l_flags
== 0)
9416 { " EXACT_MATCH", LL_EXACT_MATCH
},
9417 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9418 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9419 { " EXPORTS", LL_EXPORTS
},
9420 { " DELAY_LOAD", LL_DELAY_LOAD
},
9421 { " DELTA", LL_DELTA
}
9423 int flags
= liblist
.l_flags
;
9426 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
9427 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9429 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9430 flags
^= l_flags_vals
[fcnt
].bit
;
9433 printf (" %#x", (unsigned int) flags
);
9443 if (options_offset
!= 0)
9445 Elf_External_Options
*eopt
;
9446 Elf_Internal_Shdr
*sect
= section_headers
;
9447 Elf_Internal_Options
*iopt
;
9448 Elf_Internal_Options
*option
;
9452 /* Find the section header so that we get the size. */
9453 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9456 eopt
= get_data (NULL
, file
, options_offset
, 1, sect
->sh_size
,
9460 iopt
= cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (*iopt
));
9463 error (_("Out of memory\n"));
9470 while (offset
< sect
->sh_size
)
9472 Elf_External_Options
*eoption
;
9474 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9476 option
->kind
= BYTE_GET (eoption
->kind
);
9477 option
->size
= BYTE_GET (eoption
->size
);
9478 option
->section
= BYTE_GET (eoption
->section
);
9479 option
->info
= BYTE_GET (eoption
->info
);
9481 offset
+= option
->size
;
9487 printf (_("\nSection '%s' contains %d entries:\n"),
9488 SECTION_NAME (sect
), cnt
);
9496 switch (option
->kind
)
9499 /* This shouldn't happen. */
9500 printf (" NULL %d %lx", option
->section
, option
->info
);
9503 printf (" REGINFO ");
9504 if (elf_header
.e_machine
== EM_MIPS
)
9507 Elf32_External_RegInfo
*ereg
;
9508 Elf32_RegInfo reginfo
;
9510 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9511 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9512 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9513 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9514 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9515 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9516 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9518 printf ("GPR %08lx GP 0x%lx\n",
9520 (unsigned long) reginfo
.ri_gp_value
);
9521 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9522 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9523 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9528 Elf64_External_RegInfo
*ereg
;
9529 Elf64_Internal_RegInfo reginfo
;
9531 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9532 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9533 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9534 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9535 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9536 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9537 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9539 printf ("GPR %08lx GP 0x",
9540 reginfo
.ri_gprmask
);
9541 printf_vma (reginfo
.ri_gp_value
);
9544 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9545 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9546 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9550 case ODK_EXCEPTIONS
:
9551 fputs (" EXCEPTIONS fpe_min(", stdout
);
9552 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9553 fputs (") fpe_max(", stdout
);
9554 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9555 fputs (")", stdout
);
9557 if (option
->info
& OEX_PAGE0
)
9558 fputs (" PAGE0", stdout
);
9559 if (option
->info
& OEX_SMM
)
9560 fputs (" SMM", stdout
);
9561 if (option
->info
& OEX_FPDBUG
)
9562 fputs (" FPDBUG", stdout
);
9563 if (option
->info
& OEX_DISMISS
)
9564 fputs (" DISMISS", stdout
);
9567 fputs (" PAD ", stdout
);
9568 if (option
->info
& OPAD_PREFIX
)
9569 fputs (" PREFIX", stdout
);
9570 if (option
->info
& OPAD_POSTFIX
)
9571 fputs (" POSTFIX", stdout
);
9572 if (option
->info
& OPAD_SYMBOL
)
9573 fputs (" SYMBOL", stdout
);
9576 fputs (" HWPATCH ", stdout
);
9577 if (option
->info
& OHW_R4KEOP
)
9578 fputs (" R4KEOP", stdout
);
9579 if (option
->info
& OHW_R8KPFETCH
)
9580 fputs (" R8KPFETCH", stdout
);
9581 if (option
->info
& OHW_R5KEOP
)
9582 fputs (" R5KEOP", stdout
);
9583 if (option
->info
& OHW_R5KCVTL
)
9584 fputs (" R5KCVTL", stdout
);
9587 fputs (" FILL ", stdout
);
9588 /* XXX Print content of info word? */
9591 fputs (" TAGS ", stdout
);
9592 /* XXX Print content of info word? */
9595 fputs (" HWAND ", stdout
);
9596 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9597 fputs (" R4KEOP_CHECKED", stdout
);
9598 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9599 fputs (" R4KEOP_CLEAN", stdout
);
9602 fputs (" HWOR ", stdout
);
9603 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9604 fputs (" R4KEOP_CHECKED", stdout
);
9605 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9606 fputs (" R4KEOP_CLEAN", stdout
);
9609 printf (" GP_GROUP %#06lx self-contained %#06lx",
9610 option
->info
& OGP_GROUP
,
9611 (option
->info
& OGP_SELF
) >> 16);
9614 printf (" IDENT %#06lx self-contained %#06lx",
9615 option
->info
& OGP_GROUP
,
9616 (option
->info
& OGP_SELF
) >> 16);
9619 /* This shouldn't happen. */
9620 printf (" %3d ??? %d %lx",
9621 option
->kind
, option
->section
, option
->info
);
9625 len
= sizeof (*eopt
);
9626 while (len
< option
->size
)
9627 if (((char *) option
)[len
] >= ' '
9628 && ((char *) option
)[len
] < 0x7f)
9629 printf ("%c", ((char *) option
)[len
++]);
9631 printf ("\\%03o", ((char *) option
)[len
++]);
9633 fputs ("\n", stdout
);
9641 if (conflicts_offset
!= 0 && conflictsno
!= 0)
9643 Elf32_Conflict
*iconf
;
9646 if (dynamic_symbols
== NULL
)
9648 error (_("conflict list found without a dynamic symbol table\n"));
9652 iconf
= cmalloc (conflictsno
, sizeof (*iconf
));
9655 error (_("Out of memory\n"));
9661 Elf32_External_Conflict
*econf32
;
9663 econf32
= get_data (NULL
, file
, conflicts_offset
,
9664 conflictsno
, sizeof (*econf32
), _("conflict"));
9668 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9669 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
9675 Elf64_External_Conflict
*econf64
;
9677 econf64
= get_data (NULL
, file
, conflicts_offset
,
9678 conflictsno
, sizeof (*econf64
), _("conflict"));
9682 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9683 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
9688 printf (_("\nSection '.conflict' contains %lu entries:\n"),
9689 (unsigned long) conflictsno
);
9690 puts (_(" Num: Index Value Name"));
9692 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9694 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
9696 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
9697 print_vma (psym
->st_value
, FULL_HEX
);
9699 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9700 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
9702 printf ("<corrupt: %14ld>", psym
->st_name
);
9709 if (pltgot
!= 0 && local_gotno
!= 0)
9711 bfd_vma entry
, local_end
, global_end
;
9713 unsigned char *data
;
9717 addr_size
= (is_32bit_elf
? 4 : 8);
9718 local_end
= pltgot
+ local_gotno
* addr_size
;
9719 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
9721 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
9722 data
= get_data (NULL
, file
, offset
, global_end
- pltgot
, 1, _("GOT"));
9723 printf (_("\nPrimary GOT:\n"));
9724 printf (_(" Canonical gp value: "));
9725 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
9728 printf (_(" Reserved entries:\n"));
9729 printf (_(" %*s %10s %*s Purpose\n"),
9730 addr_size
* 2, "Address", "Access",
9731 addr_size
* 2, "Initial");
9732 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9733 printf (" Lazy resolver\n");
9735 && (byte_get (data
+ entry
- pltgot
, addr_size
)
9736 >> (addr_size
* 8 - 1)) != 0)
9738 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9739 printf (" Module pointer (GNU extension)\n");
9743 if (entry
< local_end
)
9745 printf (_(" Local entries:\n"));
9746 printf (_(" %*s %10s %*s\n"),
9747 addr_size
* 2, "Address", "Access",
9748 addr_size
* 2, "Initial");
9749 while (entry
< local_end
)
9751 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9757 if (gotsym
< symtabno
)
9761 printf (_(" Global entries:\n"));
9762 printf (_(" %*s %10s %*s %*s %-7s %3s %s\n"),
9763 addr_size
* 2, "Address", "Access",
9764 addr_size
* 2, "Initial",
9765 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
9766 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
9767 for (i
= gotsym
; i
< symtabno
; i
++)
9769 Elf_Internal_Sym
*psym
;
9771 psym
= dynamic_symbols
+ i
;
9772 entry
= print_mips_got_entry (data
, pltgot
, entry
);
9774 print_vma (psym
->st_value
, LONG_HEX
);
9775 printf (" %-7s %3s ",
9776 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
9777 get_symbol_index_type (psym
->st_shndx
));
9778 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9779 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
9781 printf ("<corrupt: %14ld>", psym
->st_name
);
9791 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
9794 size_t offset
, rel_offset
;
9795 unsigned long count
, i
;
9796 unsigned char *data
;
9797 int addr_size
, sym_width
;
9798 Elf_Internal_Rela
*rels
;
9800 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
9801 if (pltrel
== DT_RELA
)
9803 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
9808 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
9812 entry
= mips_pltgot
;
9813 addr_size
= (is_32bit_elf
? 4 : 8);
9814 end
= mips_pltgot
+ (2 + count
) * addr_size
;
9816 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
9817 data
= get_data (NULL
, file
, offset
, end
- mips_pltgot
, 1, _("PLT GOT"));
9818 printf (_("\nPLT GOT:\n\n"));
9819 printf (_(" Reserved entries:\n"));
9820 printf (_(" %*s %*s Purpose\n"),
9821 addr_size
* 2, "Address", addr_size
* 2, "Initial");
9822 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
9823 printf (" PLT lazy resolver\n");
9824 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
9825 printf (" Module pointer\n");
9828 printf (_(" Entries:\n"));
9829 printf (_(" %*s %*s %*s %-7s %3s %s\n"),
9830 addr_size
* 2, "Address",
9831 addr_size
* 2, "Initial",
9832 addr_size
* 2, "Sym.Val.", "Type", "Ndx", "Name");
9833 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
9834 for (i
= 0; i
< count
; i
++)
9836 Elf_Internal_Sym
*psym
;
9838 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
9839 entry
= print_mips_pltgot_entry (data
, mips_pltgot
, entry
);
9841 print_vma (psym
->st_value
, LONG_HEX
);
9842 printf (" %-7s %3s ",
9843 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
9844 get_symbol_index_type (psym
->st_shndx
));
9845 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9846 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
9848 printf ("<corrupt: %14ld>", psym
->st_name
);
9862 process_gnu_liblist (FILE *file
)
9864 Elf_Internal_Shdr
*section
, *string_sec
;
9865 Elf32_External_Lib
*elib
;
9874 for (i
= 0, section
= section_headers
;
9875 i
< elf_header
.e_shnum
;
9878 switch (section
->sh_type
)
9880 case SHT_GNU_LIBLIST
:
9881 if (section
->sh_link
>= elf_header
.e_shnum
)
9884 elib
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
9889 string_sec
= section_headers
+ section
->sh_link
;
9891 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
9892 string_sec
->sh_size
, _("liblist string table"));
9893 strtab_size
= string_sec
->sh_size
;
9896 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
9902 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
9903 SECTION_NAME (section
),
9904 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
9906 puts (" Library Time Stamp Checksum Version Flags");
9908 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
9916 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9917 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9918 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9919 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9920 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9922 tmp
= gmtime (&time
);
9923 snprintf (timebuf
, sizeof (timebuf
),
9924 "%04u-%02u-%02uT%02u:%02u:%02u",
9925 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9926 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9928 printf ("%3lu: ", (unsigned long) cnt
);
9930 printf ("%-20s", liblist
.l_name
< strtab_size
9931 ? strtab
+ liblist
.l_name
: "<corrupt>");
9933 printf ("%-20.20s", liblist
.l_name
< strtab_size
9934 ? strtab
+ liblist
.l_name
: "<corrupt>");
9935 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
9936 liblist
.l_version
, liblist
.l_flags
);
9947 get_note_type (unsigned e_type
)
9949 static char buff
[64];
9951 if (elf_header
.e_type
== ET_CORE
)
9955 return _("NT_AUXV (auxiliary vector)");
9957 return _("NT_PRSTATUS (prstatus structure)");
9959 return _("NT_FPREGSET (floating point registers)");
9961 return _("NT_PRPSINFO (prpsinfo structure)");
9963 return _("NT_TASKSTRUCT (task structure)");
9965 return _("NT_PRXFPREG (user_xfpregs structure)");
9967 return _("NT_PPC_VMX (ppc Altivec registers)");
9969 return _("NT_PPC_VSX (ppc VSX registers)");
9971 return _("NT_PSTATUS (pstatus structure)");
9973 return _("NT_FPREGS (floating point registers)");
9975 return _("NT_PSINFO (psinfo structure)");
9977 return _("NT_LWPSTATUS (lwpstatus_t structure)");
9979 return _("NT_LWPSINFO (lwpsinfo_t structure)");
9980 case NT_WIN32PSTATUS
:
9981 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9989 return _("NT_VERSION (version)");
9991 return _("NT_ARCH (architecture)");
9996 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10000 static const char *
10001 get_gnu_elf_note_type (unsigned e_type
)
10003 static char buff
[64];
10007 case NT_GNU_ABI_TAG
:
10008 return _("NT_GNU_ABI_TAG (ABI version tag)");
10010 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
10011 case NT_GNU_BUILD_ID
:
10012 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
10013 case NT_GNU_GOLD_VERSION
:
10014 return _("NT_GNU_GOLD_VERSION (gold version)");
10019 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10023 static const char *
10024 get_netbsd_elfcore_note_type (unsigned e_type
)
10026 static char buff
[64];
10028 if (e_type
== NT_NETBSDCORE_PROCINFO
)
10030 /* NetBSD core "procinfo" structure. */
10031 return _("NetBSD procinfo structure");
10034 /* As of Jan 2002 there are no other machine-independent notes
10035 defined for NetBSD core files. If the note type is less
10036 than the start of the machine-dependent note types, we don't
10039 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
10041 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
10045 switch (elf_header
.e_machine
)
10047 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
10048 and PT_GETFPREGS == mach+2. */
10053 case EM_SPARC32PLUS
:
10057 case NT_NETBSDCORE_FIRSTMACH
+0:
10058 return _("PT_GETREGS (reg structure)");
10059 case NT_NETBSDCORE_FIRSTMACH
+2:
10060 return _("PT_GETFPREGS (fpreg structure)");
10066 /* On all other arch's, PT_GETREGS == mach+1 and
10067 PT_GETFPREGS == mach+3. */
10071 case NT_NETBSDCORE_FIRSTMACH
+1:
10072 return _("PT_GETREGS (reg structure)");
10073 case NT_NETBSDCORE_FIRSTMACH
+3:
10074 return _("PT_GETFPREGS (fpreg structure)");
10080 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
10081 e_type
- NT_NETBSDCORE_FIRSTMACH
);
10085 /* Note that by the ELF standard, the name field is already null byte
10086 terminated, and namesz includes the terminating null byte.
10087 I.E. the value of namesz for the name "FSF" is 4.
10089 If the value of namesz is zero, there is no name present. */
10091 process_note (Elf_Internal_Note
*pnote
)
10093 const char *name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
10096 if (pnote
->namesz
== 0)
10097 /* If there is no note name, then use the default set of
10098 note type strings. */
10099 nt
= get_note_type (pnote
->type
);
10101 else if (const_strneq (pnote
->namedata
, "GNU"))
10102 /* GNU-specific object file notes. */
10103 nt
= get_gnu_elf_note_type (pnote
->type
);
10105 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
10106 /* NetBSD-specific core file notes. */
10107 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
10109 else if (strneq (pnote
->namedata
, "SPU/", 4))
10111 /* SPU-specific core file notes. */
10112 nt
= pnote
->namedata
+ 4;
10117 /* Don't recognize this note name; just use the default set of
10118 note type strings. */
10119 nt
= get_note_type (pnote
->type
);
10121 printf (" %s\t\t0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
10127 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
10129 Elf_External_Note
*pnotes
;
10130 Elf_External_Note
*external
;
10136 pnotes
= get_data (NULL
, file
, offset
, 1, length
, _("notes"));
10142 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
10143 (unsigned long) offset
, (unsigned long) length
);
10144 printf (_(" Owner\t\tData size\tDescription\n"));
10146 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
10148 Elf_External_Note
*next
;
10149 Elf_Internal_Note inote
;
10152 inote
.type
= BYTE_GET (external
->type
);
10153 inote
.namesz
= BYTE_GET (external
->namesz
);
10154 inote
.namedata
= external
->name
;
10155 inote
.descsz
= BYTE_GET (external
->descsz
);
10156 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
10157 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
10159 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
10161 if (((char *) next
) > (((char *) pnotes
) + length
))
10163 warn (_("corrupt note found at offset %lx into core notes\n"),
10164 (unsigned long) ((char *) external
- (char *) pnotes
));
10165 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
10166 inote
.type
, inote
.namesz
, inote
.descsz
);
10172 /* Verify that name is null terminated. It appears that at least
10173 one version of Linux (RedHat 6.0) generates corefiles that don't
10174 comply with the ELF spec by failing to include the null byte in
10176 if (inote
.namedata
[inote
.namesz
] != '\0')
10178 temp
= malloc (inote
.namesz
+ 1);
10182 error (_("Out of memory\n"));
10187 strncpy (temp
, inote
.namedata
, inote
.namesz
);
10188 temp
[inote
.namesz
] = 0;
10190 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
10191 inote
.namedata
= temp
;
10194 res
&= process_note (& inote
);
10209 process_corefile_note_segments (FILE *file
)
10211 Elf_Internal_Phdr
*segment
;
10215 if (! get_program_headers (file
))
10218 for (i
= 0, segment
= program_headers
;
10219 i
< elf_header
.e_phnum
;
10222 if (segment
->p_type
== PT_NOTE
)
10223 res
&= process_corefile_note_segment (file
,
10224 (bfd_vma
) segment
->p_offset
,
10225 (bfd_vma
) segment
->p_filesz
);
10232 process_note_sections (FILE *file
)
10234 Elf_Internal_Shdr
*section
;
10238 for (i
= 0, section
= section_headers
;
10239 i
< elf_header
.e_shnum
;
10241 if (section
->sh_type
== SHT_NOTE
)
10242 res
&= process_corefile_note_segment (file
,
10243 (bfd_vma
) section
->sh_offset
,
10244 (bfd_vma
) section
->sh_size
);
10250 process_notes (FILE *file
)
10252 /* If we have not been asked to display the notes then do nothing. */
10256 if (elf_header
.e_type
!= ET_CORE
)
10257 return process_note_sections (file
);
10259 /* No program headers means no NOTE segment. */
10260 if (elf_header
.e_phnum
> 0)
10261 return process_corefile_note_segments (file
);
10263 printf (_("No note segments present in the core file.\n"));
10268 process_arch_specific (FILE *file
)
10273 switch (elf_header
.e_machine
)
10276 return process_arm_specific (file
);
10278 case EM_MIPS_RS3_LE
:
10279 return process_mips_specific (file
);
10282 return process_power_specific (file
);
10291 get_file_header (FILE *file
)
10293 /* Read in the identity array. */
10294 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
10297 /* Determine how to read the rest of the header. */
10298 switch (elf_header
.e_ident
[EI_DATA
])
10300 default: /* fall through */
10301 case ELFDATANONE
: /* fall through */
10303 byte_get
= byte_get_little_endian
;
10304 byte_put
= byte_put_little_endian
;
10307 byte_get
= byte_get_big_endian
;
10308 byte_put
= byte_put_big_endian
;
10312 /* For now we only support 32 bit and 64 bit ELF files. */
10313 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
10315 /* Read in the rest of the header. */
10318 Elf32_External_Ehdr ehdr32
;
10320 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
10323 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
10324 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
10325 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
10326 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
10327 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
10328 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
10329 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
10330 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
10331 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
10332 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
10333 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
10334 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
10335 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
10339 Elf64_External_Ehdr ehdr64
;
10341 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10342 we will not be able to cope with the 64bit data found in
10343 64 ELF files. Detect this now and abort before we start
10344 overwriting things. */
10345 if (sizeof (bfd_vma
) < 8)
10347 error (_("This instance of readelf has been built without support for a\n\
10348 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10352 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
10355 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
10356 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
10357 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
10358 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
10359 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
10360 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
10361 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
10362 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
10363 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
10364 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
10365 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
10366 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
10367 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
10370 if (elf_header
.e_shoff
)
10372 /* There may be some extensions in the first section header. Don't
10373 bomb if we can't read it. */
10375 get_32bit_section_headers (file
, 1);
10377 get_64bit_section_headers (file
, 1);
10383 /* Process one ELF object file according to the command line options.
10384 This file may actually be stored in an archive. The file is
10385 positioned at the start of the ELF object. */
10388 process_object (char *file_name
, FILE *file
)
10392 if (! get_file_header (file
))
10394 error (_("%s: Failed to read file header\n"), file_name
);
10398 /* Initialise per file variables. */
10399 for (i
= ARRAY_SIZE (version_info
); i
--;)
10400 version_info
[i
] = 0;
10402 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
10403 dynamic_info
[i
] = 0;
10405 /* Process the file. */
10407 printf (_("\nFile: %s\n"), file_name
);
10409 /* Initialise the dump_sects array from the cmdline_dump_sects array.
10410 Note we do this even if cmdline_dump_sects is empty because we
10411 must make sure that the dump_sets array is zeroed out before each
10412 object file is processed. */
10413 if (num_dump_sects
> num_cmdline_dump_sects
)
10414 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
10416 if (num_cmdline_dump_sects
> 0)
10418 if (num_dump_sects
== 0)
10419 /* A sneaky way of allocating the dump_sects array. */
10420 request_dump_bynumber (num_cmdline_dump_sects
, 0);
10422 assert (num_dump_sects
>= num_cmdline_dump_sects
);
10423 memcpy (dump_sects
, cmdline_dump_sects
,
10424 num_cmdline_dump_sects
* sizeof (* dump_sects
));
10427 if (! process_file_header ())
10430 if (! process_section_headers (file
))
10432 /* Without loaded section headers we cannot process lots of
10434 do_unwind
= do_version
= do_dump
= do_arch
= 0;
10436 if (! do_using_dynamic
)
10437 do_syms
= do_reloc
= 0;
10440 if (! process_section_groups (file
))
10442 /* Without loaded section groups we cannot process unwind. */
10446 if (process_program_headers (file
))
10447 process_dynamic_section (file
);
10449 process_relocs (file
);
10451 process_unwind (file
);
10453 process_symbol_table (file
);
10455 process_syminfo (file
);
10457 process_version_sections (file
);
10459 process_section_contents (file
);
10461 process_notes (file
);
10463 process_gnu_liblist (file
);
10465 process_arch_specific (file
);
10467 if (program_headers
)
10469 free (program_headers
);
10470 program_headers
= NULL
;
10473 if (section_headers
)
10475 free (section_headers
);
10476 section_headers
= NULL
;
10481 free (string_table
);
10482 string_table
= NULL
;
10483 string_table_length
= 0;
10486 if (dynamic_strings
)
10488 free (dynamic_strings
);
10489 dynamic_strings
= NULL
;
10490 dynamic_strings_length
= 0;
10493 if (dynamic_symbols
)
10495 free (dynamic_symbols
);
10496 dynamic_symbols
= NULL
;
10497 num_dynamic_syms
= 0;
10500 if (dynamic_syminfo
)
10502 free (dynamic_syminfo
);
10503 dynamic_syminfo
= NULL
;
10506 if (section_headers_groups
)
10508 free (section_headers_groups
);
10509 section_headers_groups
= NULL
;
10512 if (section_groups
)
10514 struct group_list
*g
, *next
;
10516 for (i
= 0; i
< group_count
; i
++)
10518 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
10525 free (section_groups
);
10526 section_groups
= NULL
;
10529 free_debug_memory ();
10534 /* Process an ELF archive.
10535 On entry the file is positioned just after the ARMAG string. */
10538 process_archive (char *file_name
, FILE *file
)
10540 struct ar_hdr arhdr
;
10542 unsigned long size
;
10543 unsigned long index_num
= 0;
10544 unsigned long *index_array
= NULL
;
10545 char *sym_table
= NULL
;
10546 unsigned long sym_size
= 0;
10547 char *longnames
= NULL
;
10548 unsigned long longnames_size
= 0;
10549 size_t file_name_size
;
10554 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10555 if (got
!= sizeof arhdr
)
10560 error (_("%s: failed to read archive header\n"), file_name
);
10564 /* See if this is the archive symbol table. */
10565 if (const_strneq (arhdr
.ar_name
, "/ ")
10566 || const_strneq (arhdr
.ar_name
, "/SYM64/ "))
10568 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10569 size
= size
+ (size
& 1);
10571 if (do_archive_index
)
10574 /* A buffer used to hold numbers read in from an archive index.
10575 These are always 4 bytes long and stored in big-endian format. */
10576 #define SIZEOF_AR_INDEX_NUMBERS 4
10577 unsigned char integer_buffer
[SIZEOF_AR_INDEX_NUMBERS
];
10578 unsigned char * index_buffer
;
10580 /* Check the size of the archive index. */
10581 if (size
< SIZEOF_AR_INDEX_NUMBERS
)
10583 error (_("%s: the archive index is empty\n"), file_name
);
10587 /* Read the numer of entries in the archive index. */
10588 got
= fread (integer_buffer
, 1, sizeof integer_buffer
, file
);
10589 if (got
!= sizeof (integer_buffer
))
10591 error (_("%s: failed to read archive index\n"), file_name
);
10594 index_num
= byte_get_big_endian (integer_buffer
, sizeof integer_buffer
);
10595 size
-= SIZEOF_AR_INDEX_NUMBERS
;
10597 /* Read in the archive index. */
10598 if (size
< index_num
* SIZEOF_AR_INDEX_NUMBERS
)
10600 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
10601 file_name
, index_num
);
10604 index_buffer
= malloc (index_num
* SIZEOF_AR_INDEX_NUMBERS
);
10605 if (index_buffer
== NULL
)
10607 error (_("Out of memory whilst trying to read archive symbol index\n"));
10610 got
= fread (index_buffer
, SIZEOF_AR_INDEX_NUMBERS
, index_num
, file
);
10611 if (got
!= index_num
)
10613 free (index_buffer
);
10614 error (_("%s: failed to read archive index\n"), file_name
);
10618 size
-= index_num
* SIZEOF_AR_INDEX_NUMBERS
;
10620 /* Convert the index numbers into the host's numeric format. */
10621 index_array
= malloc (index_num
* sizeof (* index_array
));
10622 if (index_array
== NULL
)
10624 free (index_buffer
);
10625 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
10629 for (i
= 0; i
< index_num
; i
++)
10630 index_array
[i
] = byte_get_big_endian ((unsigned char *)(index_buffer
+ (i
* SIZEOF_AR_INDEX_NUMBERS
)),
10631 SIZEOF_AR_INDEX_NUMBERS
);
10632 free (index_buffer
);
10634 /* The remaining space in the header is taken up by the symbol table. */
10637 error (_("%s: the archive has an index but no symbols\n"), file_name
);
10641 sym_table
= malloc (size
);
10643 if (sym_table
== NULL
)
10645 error (_("Out of memory whilst trying to read archive index symbol table\n"));
10649 got
= fread (sym_table
, 1, size
, file
);
10652 error (_("%s: failed to read archive index symbol table\n"), file_name
);
10659 if (fseek (file
, size
, SEEK_CUR
) != 0)
10661 error (_("%s: failed to skip archive symbol table\n"), file_name
);
10666 got
= fread (& arhdr
, 1, sizeof arhdr
, file
);
10667 if (got
!= sizeof arhdr
)
10675 error (_("%s: failed to read archive header following archive index\n"), file_name
);
10680 else if (do_archive_index
)
10681 printf (_("%s has no archive index\n"), file_name
);
10683 if (const_strneq (arhdr
.ar_name
, "// "))
10685 /* This is the archive string table holding long member
10688 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10689 longnames
= malloc (longnames_size
);
10690 if (longnames
== NULL
)
10692 error (_("Out of memory reading long symbol names in archive\n"));
10697 if (fread (longnames
, longnames_size
, 1, file
) != 1)
10700 error (_("%s: failed to read long symbol name string table\n"), file_name
);
10705 if ((longnames_size
& 1) != 0)
10708 got
= fread (& arhdr
, 1, sizeof arhdr
, file
);
10709 if (got
!= sizeof arhdr
)
10715 error (_("%s: failed to read archive header following long symbol names\n"), file_name
);
10722 if (do_archive_index
)
10724 if (sym_table
== NULL
)
10725 error (_("%s: unable to dump the index as none was found\n"), file_name
);
10728 unsigned int i
, j
, k
, l
;
10730 unsigned long current_pos
;
10732 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
10733 file_name
, index_num
, sym_size
);
10734 current_pos
= ftell (file
);
10736 for (i
= l
= 0; i
< index_num
; i
++)
10738 if ((i
== 0) || ((i
> 0) && (index_array
[i
] != index_array
[i
- 1])))
10740 if (fseek (file
, index_array
[i
], SEEK_SET
) != 0)
10742 error (_("%s: failed to seek to next file name\n"), file_name
);
10746 got
= fread (elf_name
, 1, 16, file
);
10749 error (_("%s: failed to read file name\n"), file_name
);
10754 if (elf_name
[0] == '/')
10756 /* We have a long name. */
10757 k
= j
= strtoul (elf_name
+ 1, NULL
, 10);
10758 while ((j
< longnames_size
) && (longnames
[j
] != '/'))
10760 longnames
[j
] = '\0';
10761 printf (_("Binary %s contains:\n"), longnames
+ k
);
10762 longnames
[j
] = '/';
10767 while ((elf_name
[j
] != '/') && (j
< 16))
10769 elf_name
[j
] = '\0';
10770 printf(_("Binary %s contains:\n"), elf_name
);
10775 error (_("%s: end of the symbol table reached before the end of the index\n"),
10779 printf ("\t%s\n", sym_table
+ l
);
10780 l
+= strlen (sym_table
+ l
) + 1;
10784 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
10787 free (index_array
);
10788 index_array
= NULL
;
10791 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
10793 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
10798 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
10799 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
10800 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
10801 && !do_section_groups
)
10802 return 0; /* Archive index only. */
10805 file_name_size
= strlen (file_name
);
10814 if (arhdr
.ar_name
[0] == '/')
10818 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
10819 if (off
>= longnames_size
)
10821 error (_("%s: invalid archive string table offset %lu\n"), file_name
, off
);
10826 name
= longnames
+ off
;
10827 nameend
= memchr (name
, '/', longnames_size
- off
);
10831 name
= arhdr
.ar_name
;
10832 nameend
= memchr (name
, '/', 16);
10835 if (nameend
== NULL
)
10837 error (_("%s: bad archive file name\n"), file_name
);
10842 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
10843 if (namealc
== NULL
)
10845 error (_("Out of memory\n"));
10850 memcpy (namealc
, file_name
, file_name_size
);
10851 namealc
[file_name_size
] = '(';
10852 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
10853 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
10854 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
10856 archive_file_offset
= ftell (file
);
10857 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10859 ret
|= process_object (namealc
, file
);
10864 (archive_file_offset
10865 + archive_file_size
10866 + (archive_file_size
& 1)),
10869 error (_("%s: failed to seek to next archive header\n"), file_name
);
10874 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10875 if (got
!= sizeof arhdr
)
10880 error (_("%s: failed to read archive header\n"), file_name
);
10887 if (index_array
!= NULL
)
10888 free (index_array
);
10889 if (sym_table
!= NULL
)
10891 if (longnames
!= NULL
)
10898 process_file (char *file_name
)
10901 struct stat statbuf
;
10902 char armag
[SARMAG
];
10905 if (stat (file_name
, &statbuf
) < 0)
10907 if (errno
== ENOENT
)
10908 error (_("'%s': No such file\n"), file_name
);
10910 error (_("Could not locate '%s'. System error message: %s\n"),
10911 file_name
, strerror (errno
));
10915 if (! S_ISREG (statbuf
.st_mode
))
10917 error (_("'%s' is not an ordinary file\n"), file_name
);
10921 file
= fopen (file_name
, "rb");
10924 error (_("Input file '%s' is not readable.\n"), file_name
);
10928 if (fread (armag
, SARMAG
, 1, file
) != 1)
10930 error (_("%s: Failed to read file's magic number\n"), file_name
);
10935 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
10936 ret
= process_archive (file_name
, file
);
10939 if (do_archive_index
)
10940 error (_("File %s is not an archive so its index cannot be displayed.\n"),
10944 archive_file_size
= archive_file_offset
= 0;
10945 ret
= process_object (file_name
, file
);
10953 #ifdef SUPPORT_DISASSEMBLY
10954 /* Needed by the i386 disassembler. For extra credit, someone could
10955 fix this so that we insert symbolic addresses here, esp for GOT/PLT
10959 print_address (unsigned int addr
, FILE *outfile
)
10961 fprintf (outfile
,"0x%8.8x", addr
);
10964 /* Needed by the i386 disassembler. */
10966 db_task_printsym (unsigned int addr
)
10968 print_address (addr
, stderr
);
10973 main (int argc
, char **argv
)
10977 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
10978 setlocale (LC_MESSAGES
, "");
10980 #if defined (HAVE_SETLOCALE)
10981 setlocale (LC_CTYPE
, "");
10983 bindtextdomain (PACKAGE
, LOCALEDIR
);
10984 textdomain (PACKAGE
);
10986 expandargv (&argc
, &argv
);
10988 parse_args (argc
, argv
);
10990 if (num_dump_sects
> 0)
10992 /* Make a copy of the dump_sects array. */
10993 cmdline_dump_sects
= malloc (num_dump_sects
* sizeof (* dump_sects
));
10994 if (cmdline_dump_sects
== NULL
)
10995 error (_("Out of memory allocating dump request table.\n"));
10998 memcpy (cmdline_dump_sects
, dump_sects
,
10999 num_dump_sects
* sizeof (* dump_sects
));
11000 num_cmdline_dump_sects
= num_dump_sects
;
11004 if (optind
< (argc
- 1))
11008 while (optind
< argc
)
11009 err
|= process_file (argv
[optind
++]);
11011 if (dump_sects
!= NULL
)
11013 if (cmdline_dump_sects
!= NULL
)
11014 free (cmdline_dump_sects
);