1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004
3 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 2 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., 59 Temple Place - Suite 330, 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. */
45 #include <sys/types.h>
51 /* Define BFD64 here, even if our default architecture is 32 bit ELF
52 as this will allow us to read in and parse 64bit and 32bit ELF files.
53 Only do this if we believe that the compiler can support a 64 bit
54 data type. For now we only rely on GCC being able to do this. */
60 #include "elf/common.h"
61 #include "elf/external.h"
62 #include "elf/internal.h"
63 #include "elf/dwarf2.h"
65 /* The following headers use the elf/reloc-macros.h file to
66 automatically generate relocation recognition functions
67 such as elf_mips_reloc_type() */
69 #define RELOC_MACROS_GEN_FUNC
71 #include "elf/alpha.h"
91 #include "elf/m68hc11.h"
92 #include "elf/mcore.h"
95 #include "elf/mn10200.h"
96 #include "elf/mn10300.h"
97 #include "elf/msp430.h"
101 #include "elf/ppc64.h"
102 #include "elf/s390.h"
104 #include "elf/sparc.h"
105 #include "elf/v850.h"
107 #include "elf/x86-64.h"
108 #include "elf/xstormy16.h"
110 #include "elf/iq2000.h"
111 #include "elf/xtensa.h"
117 #include "libiberty.h"
119 char *program_name
= "readelf";
120 long archive_file_offset
;
121 unsigned long archive_file_size
;
122 unsigned long dynamic_addr
;
123 bfd_size_type dynamic_size
;
124 unsigned int dynamic_nent
;
125 char *dynamic_strings
;
126 unsigned long dynamic_strings_length
;
128 unsigned long string_table_length
;
129 unsigned long num_dynamic_syms
;
130 Elf_Internal_Sym
*dynamic_symbols
;
131 Elf_Internal_Syminfo
*dynamic_syminfo
;
132 unsigned long dynamic_syminfo_offset
;
133 unsigned int dynamic_syminfo_nent
;
134 char program_interpreter
[64];
135 bfd_vma dynamic_info
[DT_JMPREL
+ 1];
136 bfd_vma version_info
[16];
137 Elf_Internal_Ehdr elf_header
;
138 Elf_Internal_Shdr
*section_headers
;
139 Elf_Internal_Phdr
*program_headers
;
140 Elf_Internal_Dyn
*dynamic_section
;
141 Elf_Internal_Shdr
*symtab_shndx_hdr
;
147 int do_section_groups
;
150 int do_using_dynamic
;
158 int do_debug_abbrevs
;
160 int do_debug_pubnames
;
161 int do_debug_aranges
;
164 int do_debug_frames_interp
;
165 int do_debug_macinfo
;
174 struct group_list
*next
;
175 unsigned int section_index
;
180 struct group_list
*root
;
181 unsigned int group_index
;
184 struct group
*section_groups
;
185 size_t group_count
= 0;
187 struct group
**section_headers_groups
;
189 /* A dynamic array of flags indicating for which sections a hex dump
190 has been requested (via the -x switch) and/or a disassembly dump
191 (via the -i switch). */
192 char *cmdline_dump_sects
= NULL
;
193 unsigned num_cmdline_dump_sects
= 0;
195 /* A dynamic array of flags indicating for which sections a dump of
196 some kind has been requested. It is reset on a per-object file
197 basis and then initialised from the cmdline_dump_sects array and
198 the results of interpreting the -w switch. */
199 char *dump_sects
= NULL
;
200 unsigned int num_dump_sects
= 0;
202 #define HEX_DUMP (1 << 0)
203 #define DISASS_DUMP (1 << 1)
204 #define DEBUG_DUMP (1 << 2)
206 /* How to rpint a vma value. */
207 typedef enum print_mode
219 static bfd_vma (*byte_get
) (unsigned char *, int);
220 static void (*byte_put
) (unsigned char *, bfd_vma
, int);
224 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
225 ((X)->sh_name >= string_table_length \
226 ? "<corrupt>" : string_table + (X)->sh_name))
228 /* Given st_shndx I, map to section_headers index. */
229 #define SECTION_HEADER_INDEX(I) \
230 ((I) < SHN_LORESERVE \
232 : ((I) <= SHN_HIRESERVE \
234 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
236 /* Reverse of the above. */
237 #define SECTION_HEADER_NUM(N) \
238 ((N) < SHN_LORESERVE \
240 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
242 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
244 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
246 #define BYTE_GET(field) byte_get (field, sizeof (field))
248 /* If we can support a 64 bit data type then BFD64 should be defined
249 and sizeof (bfd_vma) == 8. In this case when translating from an
250 external 8 byte field to an internal field, we can assume that the
251 internal field is also 8 bytes wide and so we can extract all the data.
252 If, however, BFD64 is not defined, then we must assume that the
253 internal data structure only has 4 byte wide fields that are the
254 equivalent of the 8 byte wide external counterparts, and so we must
255 truncate the data. */
257 #define BYTE_GET8(field) byte_get (field, -8)
259 #define BYTE_GET8(field) byte_get (field, 8)
262 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
264 #define GET_ELF_SYMBOLS(file, section) \
265 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
266 : get_64bit_elf_symbols (file, section))
268 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
269 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
270 already been called and verified that the string exists. */
271 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
273 /* This is just a bit of syntatic sugar. */
274 #define streq(a,b) (strcmp ((a), (b)) == 0)
275 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
278 error (const char *message
, ...)
282 va_start (args
, message
);
283 fprintf (stderr
, _("%s: Error: "), program_name
);
284 vfprintf (stderr
, message
, args
);
289 warn (const char *message
, ...)
293 va_start (args
, message
);
294 fprintf (stderr
, _("%s: Warning: "), program_name
);
295 vfprintf (stderr
, message
, args
);
300 get_data (void *var
, FILE *file
, long offset
, size_t size
, const char *reason
)
307 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
309 error (_("Unable to seek to 0x%x for %s\n"),
310 archive_file_offset
+ offset
, reason
);
317 mvar
= malloc (size
);
321 error (_("Out of memory allocating 0x%x bytes for %s\n"),
327 if (fread (mvar
, size
, 1, file
) != 1)
329 error (_("Unable to read in 0x%x bytes of %s\n"), size
, reason
);
339 byte_get_little_endian (unsigned char *field
, int size
)
347 return ((unsigned int) (field
[0]))
348 | (((unsigned int) (field
[1])) << 8);
352 /* We want to extract data from an 8 byte wide field and
353 place it into a 4 byte wide field. Since this is a little
354 endian source we can just use the 4 byte extraction code. */
358 return ((unsigned long) (field
[0]))
359 | (((unsigned long) (field
[1])) << 8)
360 | (((unsigned long) (field
[2])) << 16)
361 | (((unsigned long) (field
[3])) << 24);
366 /* This is a special case, generated by the BYTE_GET8 macro.
367 It means that we are loading an 8 byte value from a field
368 in an external structure into an 8 byte value in a field
369 in an internal structure. */
370 return ((bfd_vma
) (field
[0]))
371 | (((bfd_vma
) (field
[1])) << 8)
372 | (((bfd_vma
) (field
[2])) << 16)
373 | (((bfd_vma
) (field
[3])) << 24)
374 | (((bfd_vma
) (field
[4])) << 32)
375 | (((bfd_vma
) (field
[5])) << 40)
376 | (((bfd_vma
) (field
[6])) << 48)
377 | (((bfd_vma
) (field
[7])) << 56);
380 error (_("Unhandled data length: %d\n"), size
);
386 byte_get_signed (unsigned char *field
, int size
)
388 bfd_vma x
= byte_get (field
, size
);
393 return (x
^ 0x80) - 0x80;
395 return (x
^ 0x8000) - 0x8000;
397 return (x
^ 0x80000000) - 0x80000000;
407 byte_put_little_endian (unsigned char *field
, bfd_vma value
, int size
)
412 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
413 field
[6] = ((value
>> 24) >> 24) & 0xff;
414 field
[5] = ((value
>> 24) >> 16) & 0xff;
415 field
[4] = ((value
>> 24) >> 8) & 0xff;
418 field
[3] = (value
>> 24) & 0xff;
419 field
[2] = (value
>> 16) & 0xff;
422 field
[1] = (value
>> 8) & 0xff;
425 field
[0] = value
& 0xff;
429 error (_("Unhandled data length: %d\n"), size
);
434 /* Print a VMA value. */
436 print_vma (bfd_vma vma
, print_mode mode
)
448 printf ("%8.8lx", (unsigned long) vma
);
454 printf ("%5ld", (long) vma
);
462 printf ("%lx", (unsigned long) vma
);
466 printf ("%ld", (unsigned long) vma
);
470 printf ("%lu", (unsigned long) vma
);
492 #if BFD_HOST_64BIT_LONG
495 if (_bfd_int64_high (vma
))
496 printf ("%lx%8.8lx", _bfd_int64_high (vma
), _bfd_int64_low (vma
));
498 printf ("%lx", _bfd_int64_low (vma
));
503 #if BFD_HOST_64BIT_LONG
506 if (_bfd_int64_high (vma
))
508 printf ("++%ld", _bfd_int64_low (vma
));
510 printf ("%ld", _bfd_int64_low (vma
));
515 #if BFD_HOST_64BIT_LONG
517 printf ("%5ld", vma
);
519 printf ("%#lx", vma
);
521 if (_bfd_int64_high (vma
))
523 printf ("++%ld", _bfd_int64_low (vma
));
524 else if (vma
<= 99999)
525 printf ("%5ld", _bfd_int64_low (vma
));
527 printf ("%#lx", _bfd_int64_low (vma
));
532 #if BFD_HOST_64BIT_LONG
535 if (_bfd_int64_high (vma
))
537 printf ("++%lu", _bfd_int64_low (vma
));
539 printf ("%lu", _bfd_int64_low (vma
));
547 /* Display a symbol on stdout. If do_wide is not true then
548 format the symbol to be at most WIDTH characters,
549 truncating as necessary. If WIDTH is negative then
550 format the string to be exactly - WIDTH characters,
551 truncating or padding as necessary. */
554 print_symbol (int width
, const char *symbol
)
557 printf ("%s", symbol
);
559 printf ("%-*.*s", width
, width
, symbol
);
561 printf ("%-.*s", width
, symbol
);
565 byte_get_big_endian (unsigned char *field
, int size
)
573 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
576 return ((unsigned long) (field
[3]))
577 | (((unsigned long) (field
[2])) << 8)
578 | (((unsigned long) (field
[1])) << 16)
579 | (((unsigned long) (field
[0])) << 24);
583 /* Although we are extracing data from an 8 byte wide field,
584 we are returning only 4 bytes of data. */
585 return ((unsigned long) (field
[7]))
586 | (((unsigned long) (field
[6])) << 8)
587 | (((unsigned long) (field
[5])) << 16)
588 | (((unsigned long) (field
[4])) << 24);
592 /* This is a special case, generated by the BYTE_GET8 macro.
593 It means that we are loading an 8 byte value from a field
594 in an external structure into an 8 byte value in a field
595 in an internal structure. */
596 return ((bfd_vma
) (field
[7]))
597 | (((bfd_vma
) (field
[6])) << 8)
598 | (((bfd_vma
) (field
[5])) << 16)
599 | (((bfd_vma
) (field
[4])) << 24)
600 | (((bfd_vma
) (field
[3])) << 32)
601 | (((bfd_vma
) (field
[2])) << 40)
602 | (((bfd_vma
) (field
[1])) << 48)
603 | (((bfd_vma
) (field
[0])) << 56);
607 error (_("Unhandled data length: %d\n"), size
);
613 byte_put_big_endian (unsigned char *field
, bfd_vma value
, int size
)
618 field
[7] = value
& 0xff;
619 field
[6] = (value
>> 8) & 0xff;
620 field
[5] = (value
>> 16) & 0xff;
621 field
[4] = (value
>> 24) & 0xff;
626 field
[3] = value
& 0xff;
627 field
[2] = (value
>> 8) & 0xff;
631 field
[1] = value
& 0xff;
635 field
[0] = value
& 0xff;
639 error (_("Unhandled data length: %d\n"), size
);
644 /* Guess the relocation size commonly used by the specific machines. */
647 guess_is_rela (unsigned long e_machine
)
651 /* Targets that use REL relocations. */
666 /* Targets that use RELA relocations. */
681 case EM_CYGNUS_MN10200
:
683 case EM_CYGNUS_MN10300
:
730 warn (_("Don't know about relocations on this machine architecture\n"));
736 slurp_rela_relocs (FILE *file
,
737 unsigned long rel_offset
,
738 unsigned long rel_size
,
739 Elf_Internal_Rela
**relasp
,
740 unsigned long *nrelasp
)
742 Elf_Internal_Rela
*relas
;
743 unsigned long nrelas
;
748 Elf32_External_Rela
*erelas
;
750 erelas
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
754 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
756 relas
= malloc (nrelas
* sizeof (Elf_Internal_Rela
));
760 error (_("out of memory parsing relocs"));
764 for (i
= 0; i
< nrelas
; i
++)
766 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
767 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
768 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
775 Elf64_External_Rela
*erelas
;
777 erelas
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
781 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
783 relas
= malloc (nrelas
* sizeof (Elf_Internal_Rela
));
787 error (_("out of memory parsing relocs"));
791 for (i
= 0; i
< nrelas
; i
++)
793 relas
[i
].r_offset
= BYTE_GET8 (erelas
[i
].r_offset
);
794 relas
[i
].r_info
= BYTE_GET8 (erelas
[i
].r_info
);
795 relas
[i
].r_addend
= BYTE_GET8 (erelas
[i
].r_addend
);
806 slurp_rel_relocs (FILE *file
,
807 unsigned long rel_offset
,
808 unsigned long rel_size
,
809 Elf_Internal_Rela
**relsp
,
810 unsigned long *nrelsp
)
812 Elf_Internal_Rela
*rels
;
818 Elf32_External_Rel
*erels
;
820 erels
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
824 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
826 rels
= malloc (nrels
* sizeof (Elf_Internal_Rela
));
830 error (_("out of memory parsing relocs"));
834 for (i
= 0; i
< nrels
; i
++)
836 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
837 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
838 rels
[i
].r_addend
= 0;
845 Elf64_External_Rel
*erels
;
847 erels
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
851 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
853 rels
= malloc (nrels
* sizeof (Elf_Internal_Rela
));
857 error (_("out of memory parsing relocs"));
861 for (i
= 0; i
< nrels
; i
++)
863 rels
[i
].r_offset
= BYTE_GET8 (erels
[i
].r_offset
);
864 rels
[i
].r_info
= BYTE_GET8 (erels
[i
].r_info
);
865 rels
[i
].r_addend
= 0;
875 /* Display the contents of the relocation data found at the specified
879 dump_relocations (FILE *file
,
880 unsigned long rel_offset
,
881 unsigned long rel_size
,
882 Elf_Internal_Sym
*symtab
,
885 unsigned long strtablen
,
889 Elf_Internal_Rela
*rels
;
892 if (is_rela
== UNKNOWN
)
893 is_rela
= guess_is_rela (elf_header
.e_machine
);
897 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
902 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
911 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
913 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
918 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
920 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
928 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
930 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
935 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
937 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
941 for (i
= 0; i
< rel_size
; i
++)
944 const char *rtype2
= NULL
;
945 const char *rtype3
= NULL
;
948 bfd_vma symtab_index
;
953 offset
= rels
[i
].r_offset
;
954 info
= rels
[i
].r_info
;
958 type
= ELF32_R_TYPE (info
);
959 symtab_index
= ELF32_R_SYM (info
);
963 /* The #ifdef BFD64 below is to prevent a compile time warning.
964 We know that if we do not have a 64 bit data type that we
965 will never execute this code anyway. */
967 if (elf_header
.e_machine
== EM_MIPS
)
969 /* In little-endian objects, r_info isn't really a 64-bit
970 little-endian value: it has a 32-bit little-endian
971 symbol index followed by four individual byte fields.
972 Reorder INFO accordingly. */
973 if (elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
974 info
= (((info
& 0xffffffff) << 32)
975 | ((info
>> 56) & 0xff)
976 | ((info
>> 40) & 0xff00)
977 | ((info
>> 24) & 0xff0000)
978 | ((info
>> 8) & 0xff000000));
979 type
= ELF64_MIPS_R_TYPE (info
);
980 type2
= ELF64_MIPS_R_TYPE2 (info
);
981 type3
= ELF64_MIPS_R_TYPE3 (info
);
983 else if (elf_header
.e_machine
== EM_SPARCV9
)
984 type
= ELF64_R_TYPE_ID (info
);
986 type
= ELF64_R_TYPE (info
);
988 symtab_index
= ELF64_R_SYM (info
);
994 #ifdef _bfd_int64_low
995 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
997 printf ("%8.8lx %8.8lx ", offset
, info
);
1002 #ifdef _bfd_int64_low
1004 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1005 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1006 _bfd_int64_high (offset
),
1007 _bfd_int64_low (offset
),
1008 _bfd_int64_high (info
),
1009 _bfd_int64_low (info
));
1012 ? "%16.16lx %16.16lx "
1013 : "%12.12lx %12.12lx ",
1018 switch (elf_header
.e_machine
)
1025 case EM_CYGNUS_M32R
:
1026 rtype
= elf_m32r_reloc_type (type
);
1031 rtype
= elf_i386_reloc_type (type
);
1036 rtype
= elf_m68hc11_reloc_type (type
);
1040 rtype
= elf_m68k_reloc_type (type
);
1044 rtype
= elf_i960_reloc_type (type
);
1049 rtype
= elf_avr_reloc_type (type
);
1052 case EM_OLD_SPARCV9
:
1053 case EM_SPARC32PLUS
:
1056 rtype
= elf_sparc_reloc_type (type
);
1060 case EM_CYGNUS_V850
:
1061 rtype
= v850_reloc_type (type
);
1065 case EM_CYGNUS_D10V
:
1066 rtype
= elf_d10v_reloc_type (type
);
1070 case EM_CYGNUS_D30V
:
1071 rtype
= elf_d30v_reloc_type (type
);
1075 rtype
= elf_dlx_reloc_type (type
);
1079 rtype
= elf_sh_reloc_type (type
);
1083 case EM_CYGNUS_MN10300
:
1084 rtype
= elf_mn10300_reloc_type (type
);
1088 case EM_CYGNUS_MN10200
:
1089 rtype
= elf_mn10200_reloc_type (type
);
1093 case EM_CYGNUS_FR30
:
1094 rtype
= elf_fr30_reloc_type (type
);
1098 rtype
= elf_frv_reloc_type (type
);
1102 rtype
= elf_mcore_reloc_type (type
);
1106 rtype
= elf_mmix_reloc_type (type
);
1111 rtype
= elf_msp430_reloc_type (type
);
1115 rtype
= elf_ppc_reloc_type (type
);
1119 rtype
= elf_ppc64_reloc_type (type
);
1123 case EM_MIPS_RS3_LE
:
1124 rtype
= elf_mips_reloc_type (type
);
1127 rtype2
= elf_mips_reloc_type (type2
);
1128 rtype3
= elf_mips_reloc_type (type3
);
1133 rtype
= elf_alpha_reloc_type (type
);
1137 rtype
= elf_arm_reloc_type (type
);
1141 rtype
= elf_arc_reloc_type (type
);
1145 rtype
= elf_hppa_reloc_type (type
);
1151 rtype
= elf_h8_reloc_type (type
);
1156 rtype
= elf_or32_reloc_type (type
);
1161 rtype
= elf_pj_reloc_type (type
);
1164 rtype
= elf_ia64_reloc_type (type
);
1168 rtype
= elf_cris_reloc_type (type
);
1172 rtype
= elf_i860_reloc_type (type
);
1176 rtype
= elf_x86_64_reloc_type (type
);
1180 rtype
= i370_reloc_type (type
);
1185 rtype
= elf_s390_reloc_type (type
);
1189 rtype
= elf_xstormy16_reloc_type (type
);
1193 rtype
= elf_crx_reloc_type (type
);
1197 rtype
= elf_vax_reloc_type (type
);
1202 rtype
= elf_ip2k_reloc_type (type
);
1206 rtype
= elf_iq2000_reloc_type (type
);
1211 rtype
= elf_xtensa_reloc_type (type
);
1216 #ifdef _bfd_int64_low
1217 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type
));
1219 printf (_("unrecognized: %-7lx"), type
);
1222 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1226 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1227 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1230 Elf_Internal_Sym
*psym
;
1232 psym
= symtab
+ symtab_index
;
1235 print_vma (psym
->st_value
, LONG_HEX
);
1236 printf (is_32bit_elf
? " " : " ");
1238 if (psym
->st_name
== 0)
1240 const char *sec_name
= "<null>";
1243 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1245 bfd_vma sec_index
= (bfd_vma
) -1;
1247 if (psym
->st_shndx
< SHN_LORESERVE
)
1248 sec_index
= psym
->st_shndx
;
1249 else if (psym
->st_shndx
> SHN_HIRESERVE
)
1250 sec_index
= psym
->st_shndx
- (SHN_HIRESERVE
+ 1
1253 if (sec_index
!= (bfd_vma
) -1)
1254 sec_name
= SECTION_NAME (section_headers
+ sec_index
);
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_IA_64
1260 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1261 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1262 sec_name
= "ANSI_COM";
1265 sprintf (name_buf
, "<section 0x%x>",
1266 (unsigned int) psym
->st_shndx
);
1267 sec_name
= name_buf
;
1270 print_symbol (22, sec_name
);
1272 else if (strtab
== NULL
)
1273 printf (_("<string table index: %3ld>"), psym
->st_name
);
1274 else if (psym
->st_name
> strtablen
)
1275 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1277 print_symbol (22, strtab
+ psym
->st_name
);
1280 printf (" + %lx", (unsigned long) rels
[i
].r_addend
);
1285 printf ("%*c", is_32bit_elf
?
1286 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1287 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1290 if (elf_header
.e_machine
== EM_SPARCV9
1291 && streq (rtype
, "R_SPARC_OLO10"))
1292 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1296 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1298 printf (" Type2: ");
1301 #ifdef _bfd_int64_low
1302 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2
));
1304 printf (_("unrecognized: %-7lx"), type2
);
1307 printf ("%-17.17s", rtype2
);
1309 printf ("\n Type3: ");
1312 #ifdef _bfd_int64_low
1313 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3
));
1315 printf (_("unrecognized: %-7lx"), type3
);
1318 printf ("%-17.17s", rtype3
);
1330 get_mips_dynamic_type (unsigned long type
)
1334 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1335 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1336 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1337 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1338 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1339 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1340 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1341 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1342 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1343 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1344 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1345 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1346 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1347 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1348 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1349 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1350 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1351 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1352 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1353 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1354 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1355 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1356 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1357 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1358 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1359 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1360 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1361 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1362 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1363 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1364 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1365 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1366 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1367 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1368 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1369 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1370 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1371 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1372 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1373 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1374 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1375 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1376 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1383 get_sparc64_dynamic_type (unsigned long type
)
1387 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1394 get_ppc64_dynamic_type (unsigned long type
)
1398 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1399 case DT_PPC64_OPD
: return "PPC64_OPD";
1400 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1407 get_parisc_dynamic_type (unsigned long type
)
1411 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1412 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1413 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1414 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1415 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1416 case DT_HP_PREINIT
: return "HP_PREINIT";
1417 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1418 case DT_HP_NEEDED
: return "HP_NEEDED";
1419 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1420 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1421 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1422 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1423 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1430 get_ia64_dynamic_type (unsigned long type
)
1434 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1441 get_dynamic_type (unsigned long type
)
1443 static char buff
[32];
1447 case DT_NULL
: return "NULL";
1448 case DT_NEEDED
: return "NEEDED";
1449 case DT_PLTRELSZ
: return "PLTRELSZ";
1450 case DT_PLTGOT
: return "PLTGOT";
1451 case DT_HASH
: return "HASH";
1452 case DT_STRTAB
: return "STRTAB";
1453 case DT_SYMTAB
: return "SYMTAB";
1454 case DT_RELA
: return "RELA";
1455 case DT_RELASZ
: return "RELASZ";
1456 case DT_RELAENT
: return "RELAENT";
1457 case DT_STRSZ
: return "STRSZ";
1458 case DT_SYMENT
: return "SYMENT";
1459 case DT_INIT
: return "INIT";
1460 case DT_FINI
: return "FINI";
1461 case DT_SONAME
: return "SONAME";
1462 case DT_RPATH
: return "RPATH";
1463 case DT_SYMBOLIC
: return "SYMBOLIC";
1464 case DT_REL
: return "REL";
1465 case DT_RELSZ
: return "RELSZ";
1466 case DT_RELENT
: return "RELENT";
1467 case DT_PLTREL
: return "PLTREL";
1468 case DT_DEBUG
: return "DEBUG";
1469 case DT_TEXTREL
: return "TEXTREL";
1470 case DT_JMPREL
: return "JMPREL";
1471 case DT_BIND_NOW
: return "BIND_NOW";
1472 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1473 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1474 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1475 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1476 case DT_RUNPATH
: return "RUNPATH";
1477 case DT_FLAGS
: return "FLAGS";
1479 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1480 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1482 case DT_CHECKSUM
: return "CHECKSUM";
1483 case DT_PLTPADSZ
: return "PLTPADSZ";
1484 case DT_MOVEENT
: return "MOVEENT";
1485 case DT_MOVESZ
: return "MOVESZ";
1486 case DT_FEATURE
: return "FEATURE";
1487 case DT_POSFLAG_1
: return "POSFLAG_1";
1488 case DT_SYMINSZ
: return "SYMINSZ";
1489 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1491 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1492 case DT_CONFIG
: return "CONFIG";
1493 case DT_DEPAUDIT
: return "DEPAUDIT";
1494 case DT_AUDIT
: return "AUDIT";
1495 case DT_PLTPAD
: return "PLTPAD";
1496 case DT_MOVETAB
: return "MOVETAB";
1497 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1499 case DT_VERSYM
: return "VERSYM";
1501 case DT_RELACOUNT
: return "RELACOUNT";
1502 case DT_RELCOUNT
: return "RELCOUNT";
1503 case DT_FLAGS_1
: return "FLAGS_1";
1504 case DT_VERDEF
: return "VERDEF";
1505 case DT_VERDEFNUM
: return "VERDEFNUM";
1506 case DT_VERNEED
: return "VERNEED";
1507 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1509 case DT_AUXILIARY
: return "AUXILIARY";
1510 case DT_USED
: return "USED";
1511 case DT_FILTER
: return "FILTER";
1513 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1514 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1515 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1516 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1517 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1520 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1524 switch (elf_header
.e_machine
)
1527 case EM_MIPS_RS3_LE
:
1528 result
= get_mips_dynamic_type (type
);
1531 result
= get_sparc64_dynamic_type (type
);
1534 result
= get_ppc64_dynamic_type (type
);
1537 result
= get_ia64_dynamic_type (type
);
1547 sprintf (buff
, _("Processor Specific: %lx"), type
);
1549 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1553 switch (elf_header
.e_machine
)
1556 result
= get_parisc_dynamic_type (type
);
1566 sprintf (buff
, _("Operating System specific: %lx"), type
);
1569 sprintf (buff
, _("<unknown>: %lx"), type
);
1576 get_file_type (unsigned e_type
)
1578 static char buff
[32];
1582 case ET_NONE
: return _("NONE (None)");
1583 case ET_REL
: return _("REL (Relocatable file)");
1584 case ET_EXEC
: return _("EXEC (Executable file)");
1585 case ET_DYN
: return _("DYN (Shared object file)");
1586 case ET_CORE
: return _("CORE (Core file)");
1589 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1590 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
1591 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1592 sprintf (buff
, _("OS Specific: (%x)"), e_type
);
1594 sprintf (buff
, _("<unknown>: %x"), e_type
);
1600 get_machine_name (unsigned e_machine
)
1602 static char buff
[64]; /* XXX */
1606 case EM_NONE
: return _("None");
1607 case EM_M32
: return "WE32100";
1608 case EM_SPARC
: return "Sparc";
1609 case EM_386
: return "Intel 80386";
1610 case EM_68K
: return "MC68000";
1611 case EM_88K
: return "MC88000";
1612 case EM_486
: return "Intel 80486";
1613 case EM_860
: return "Intel 80860";
1614 case EM_MIPS
: return "MIPS R3000";
1615 case EM_S370
: return "IBM System/370";
1616 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1617 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1618 case EM_PARISC
: return "HPPA";
1619 case EM_PPC_OLD
: return "Power PC (old)";
1620 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1621 case EM_960
: return "Intel 90860";
1622 case EM_PPC
: return "PowerPC";
1623 case EM_PPC64
: return "PowerPC64";
1624 case EM_V800
: return "NEC V800";
1625 case EM_FR20
: return "Fujitsu FR20";
1626 case EM_RH32
: return "TRW RH32";
1627 case EM_MCORE
: return "MCORE";
1628 case EM_ARM
: return "ARM";
1629 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1630 case EM_SH
: return "Renesas / SuperH SH";
1631 case EM_SPARCV9
: return "Sparc v9";
1632 case EM_TRICORE
: return "Siemens Tricore";
1633 case EM_ARC
: return "ARC";
1634 case EM_H8_300
: return "Renesas H8/300";
1635 case EM_H8_300H
: return "Renesas H8/300H";
1636 case EM_H8S
: return "Renesas H8S";
1637 case EM_H8_500
: return "Renesas H8/500";
1638 case EM_IA_64
: return "Intel IA-64";
1639 case EM_MIPS_X
: return "Stanford MIPS-X";
1640 case EM_COLDFIRE
: return "Motorola Coldfire";
1641 case EM_68HC12
: return "Motorola M68HC12";
1642 case EM_ALPHA
: return "Alpha";
1643 case EM_CYGNUS_D10V
:
1644 case EM_D10V
: return "d10v";
1645 case EM_CYGNUS_D30V
:
1646 case EM_D30V
: return "d30v";
1647 case EM_CYGNUS_M32R
:
1648 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1649 case EM_CYGNUS_V850
:
1650 case EM_V850
: return "NEC v850";
1651 case EM_CYGNUS_MN10300
:
1652 case EM_MN10300
: return "mn10300";
1653 case EM_CYGNUS_MN10200
:
1654 case EM_MN10200
: return "mn10200";
1655 case EM_CYGNUS_FR30
:
1656 case EM_FR30
: return "Fujitsu FR30";
1657 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1659 case EM_PJ
: return "picoJava";
1660 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1661 case EM_PCP
: return "Siemens PCP";
1662 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1663 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1664 case EM_STARCORE
: return "Motorola Star*Core processor";
1665 case EM_ME16
: return "Toyota ME16 processor";
1666 case EM_ST100
: return "STMicroelectronics ST100 processor";
1667 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1668 case EM_FX66
: return "Siemens FX66 microcontroller";
1669 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1670 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1671 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1672 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1673 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1674 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1675 case EM_SVX
: return "Silicon Graphics SVx";
1676 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1677 case EM_VAX
: return "Digital VAX";
1679 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1680 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1681 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1682 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1683 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1684 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1685 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1686 case EM_PRISM
: return "Vitesse Prism";
1687 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1689 case EM_S390
: return "IBM S/390";
1690 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1692 case EM_OR32
: return "OpenRISC";
1693 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1694 case EM_DLX
: return "OpenDLX";
1696 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1697 case EM_IQ2000
: return "Vitesse IQ2000";
1699 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1701 sprintf (buff
, _("<unknown>: %x"), e_machine
);
1707 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1712 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1713 e_flags
&= ~ EF_ARM_EABIMASK
;
1715 /* Handle "generic" ARM flags. */
1716 if (e_flags
& EF_ARM_RELEXEC
)
1718 strcat (buf
, ", relocatable executable");
1719 e_flags
&= ~ EF_ARM_RELEXEC
;
1722 if (e_flags
& EF_ARM_HASENTRY
)
1724 strcat (buf
, ", has entry point");
1725 e_flags
&= ~ EF_ARM_HASENTRY
;
1728 /* Now handle EABI specific flags. */
1732 strcat (buf
, ", <unrecognized EABI>");
1737 case EF_ARM_EABI_VER1
:
1738 strcat (buf
, ", Version1 EABI");
1743 /* Process flags one bit at a time. */
1744 flag
= e_flags
& - e_flags
;
1749 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1750 strcat (buf
, ", sorted symbol tables");
1760 case EF_ARM_EABI_VER2
:
1761 strcat (buf
, ", Version2 EABI");
1766 /* Process flags one bit at a time. */
1767 flag
= e_flags
& - e_flags
;
1772 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1773 strcat (buf
, ", sorted symbol tables");
1776 case EF_ARM_DYNSYMSUSESEGIDX
:
1777 strcat (buf
, ", dynamic symbols use segment index");
1780 case EF_ARM_MAPSYMSFIRST
:
1781 strcat (buf
, ", mapping symbols precede others");
1791 case EF_ARM_EABI_VER3
:
1792 strcat (buf
, ", Version3 EABI");
1795 case EF_ARM_EABI_VER4
:
1796 strcat (buf
, ", Version4 EABI");
1801 /* Process flags one bit at a time. */
1802 flag
= e_flags
& - e_flags
;
1808 strcat (buf
, ", BE8");
1812 strcat (buf
, ", LE8");
1822 case EF_ARM_EABI_UNKNOWN
:
1823 strcat (buf
, ", GNU EABI");
1828 /* Process flags one bit at a time. */
1829 flag
= e_flags
& - e_flags
;
1834 case EF_ARM_INTERWORK
:
1835 strcat (buf
, ", interworking enabled");
1838 case EF_ARM_APCS_26
:
1839 strcat (buf
, ", uses APCS/26");
1842 case EF_ARM_APCS_FLOAT
:
1843 strcat (buf
, ", uses APCS/float");
1847 strcat (buf
, ", position independent");
1851 strcat (buf
, ", 8 bit structure alignment");
1854 case EF_ARM_NEW_ABI
:
1855 strcat (buf
, ", uses new ABI");
1858 case EF_ARM_OLD_ABI
:
1859 strcat (buf
, ", uses old ABI");
1862 case EF_ARM_SOFT_FLOAT
:
1863 strcat (buf
, ", software FP");
1866 case EF_ARM_VFP_FLOAT
:
1867 strcat (buf
, ", VFP");
1870 case EF_ARM_MAVERICK_FLOAT
:
1871 strcat (buf
, ", Maverick FP");
1882 strcat (buf
,", <unknown>");
1886 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
1888 static char buf
[1024];
1900 decode_ARM_machine_flags (e_flags
, buf
);
1904 switch (e_flags
& EF_FRV_CPU_MASK
)
1906 case EF_FRV_CPU_GENERIC
:
1910 strcat (buf
, ", fr???");
1913 case EF_FRV_CPU_FR300
:
1914 strcat (buf
, ", fr300");
1917 case EF_FRV_CPU_FR400
:
1918 strcat (buf
, ", fr400");
1920 case EF_FRV_CPU_FR405
:
1921 strcat (buf
, ", fr405");
1924 case EF_FRV_CPU_FR450
:
1925 strcat (buf
, ", fr450");
1928 case EF_FRV_CPU_FR500
:
1929 strcat (buf
, ", fr500");
1931 case EF_FRV_CPU_FR550
:
1932 strcat (buf
, ", fr550");
1935 case EF_FRV_CPU_SIMPLE
:
1936 strcat (buf
, ", simple");
1938 case EF_FRV_CPU_TOMCAT
:
1939 strcat (buf
, ", tomcat");
1945 if (e_flags
& EF_CPU32
)
1946 strcat (buf
, ", cpu32");
1947 if (e_flags
& EF_M68000
)
1948 strcat (buf
, ", m68000");
1952 if (e_flags
& EF_PPC_EMB
)
1953 strcat (buf
, ", emb");
1955 if (e_flags
& EF_PPC_RELOCATABLE
)
1956 strcat (buf
, ", relocatable");
1958 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1959 strcat (buf
, ", relocatable-lib");
1963 case EM_CYGNUS_V850
:
1964 switch (e_flags
& EF_V850_ARCH
)
1967 strcat (buf
, ", v850e1");
1970 strcat (buf
, ", v850e");
1973 strcat (buf
, ", v850");
1976 strcat (buf
, ", unknown v850 architecture variant");
1982 case EM_CYGNUS_M32R
:
1983 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1984 strcat (buf
, ", m32r");
1989 case EM_MIPS_RS3_LE
:
1990 if (e_flags
& EF_MIPS_NOREORDER
)
1991 strcat (buf
, ", noreorder");
1993 if (e_flags
& EF_MIPS_PIC
)
1994 strcat (buf
, ", pic");
1996 if (e_flags
& EF_MIPS_CPIC
)
1997 strcat (buf
, ", cpic");
1999 if (e_flags
& EF_MIPS_UCODE
)
2000 strcat (buf
, ", ugen_reserved");
2002 if (e_flags
& EF_MIPS_ABI2
)
2003 strcat (buf
, ", abi2");
2005 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2006 strcat (buf
, ", odk first");
2008 if (e_flags
& EF_MIPS_32BITMODE
)
2009 strcat (buf
, ", 32bitmode");
2011 switch ((e_flags
& EF_MIPS_MACH
))
2013 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2014 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2015 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2016 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2017 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2018 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2019 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2020 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2021 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2022 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2024 /* We simply ignore the field in this case to avoid confusion:
2025 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2028 default: strcat (buf
, ", unknown CPU"); break;
2031 switch ((e_flags
& EF_MIPS_ABI
))
2033 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2034 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2035 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2036 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2038 /* We simply ignore the field in this case to avoid confusion:
2039 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2040 This means it is likely to be an o32 file, but not for
2043 default: strcat (buf
, ", unknown ABI"); break;
2046 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2047 strcat (buf
, ", mdmx");
2049 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2050 strcat (buf
, ", mips16");
2052 switch ((e_flags
& EF_MIPS_ARCH
))
2054 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2055 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2056 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2057 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2058 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2059 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2060 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2061 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2062 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2063 default: strcat (buf
, ", unknown ISA"); break;
2069 switch ((e_flags
& EF_SH_MACH_MASK
))
2071 case EF_SH1
: strcat (buf
, ", sh1"); break;
2072 case EF_SH2
: strcat (buf
, ", sh2"); break;
2073 case EF_SH3
: strcat (buf
, ", sh3"); break;
2074 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2075 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2076 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2077 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2078 case EF_SH4
: strcat (buf
, ", sh4"); break;
2079 case EF_SH5
: strcat (buf
, ", sh5"); break;
2080 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2081 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2082 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2083 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2084 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2085 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2086 default: strcat (buf
, ", unknown ISA"); break;
2092 if (e_flags
& EF_SPARC_32PLUS
)
2093 strcat (buf
, ", v8+");
2095 if (e_flags
& EF_SPARC_SUN_US1
)
2096 strcat (buf
, ", ultrasparcI");
2098 if (e_flags
& EF_SPARC_SUN_US3
)
2099 strcat (buf
, ", ultrasparcIII");
2101 if (e_flags
& EF_SPARC_HAL_R1
)
2102 strcat (buf
, ", halr1");
2104 if (e_flags
& EF_SPARC_LEDATA
)
2105 strcat (buf
, ", ledata");
2107 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2108 strcat (buf
, ", tso");
2110 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2111 strcat (buf
, ", pso");
2113 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2114 strcat (buf
, ", rmo");
2118 switch (e_flags
& EF_PARISC_ARCH
)
2120 case EFA_PARISC_1_0
:
2121 strcpy (buf
, ", PA-RISC 1.0");
2123 case EFA_PARISC_1_1
:
2124 strcpy (buf
, ", PA-RISC 1.1");
2126 case EFA_PARISC_2_0
:
2127 strcpy (buf
, ", PA-RISC 2.0");
2132 if (e_flags
& EF_PARISC_TRAPNIL
)
2133 strcat (buf
, ", trapnil");
2134 if (e_flags
& EF_PARISC_EXT
)
2135 strcat (buf
, ", ext");
2136 if (e_flags
& EF_PARISC_LSB
)
2137 strcat (buf
, ", lsb");
2138 if (e_flags
& EF_PARISC_WIDE
)
2139 strcat (buf
, ", wide");
2140 if (e_flags
& EF_PARISC_NO_KABP
)
2141 strcat (buf
, ", no kabp");
2142 if (e_flags
& EF_PARISC_LAZYSWAP
)
2143 strcat (buf
, ", lazyswap");
2148 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2149 strcat (buf
, ", new calling convention");
2151 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2152 strcat (buf
, ", gnu calling convention");
2156 if ((e_flags
& EF_IA_64_ABI64
))
2157 strcat (buf
, ", 64-bit");
2159 strcat (buf
, ", 32-bit");
2160 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2161 strcat (buf
, ", reduced fp model");
2162 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2163 strcat (buf
, ", no function descriptors, constant gp");
2164 else if ((e_flags
& EF_IA_64_CONS_GP
))
2165 strcat (buf
, ", constant gp");
2166 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2167 strcat (buf
, ", absolute");
2171 if ((e_flags
& EF_VAX_NONPIC
))
2172 strcat (buf
, ", non-PIC");
2173 if ((e_flags
& EF_VAX_DFLOAT
))
2174 strcat (buf
, ", D-Float");
2175 if ((e_flags
& EF_VAX_GFLOAT
))
2176 strcat (buf
, ", G-Float");
2185 get_osabi_name (unsigned int osabi
)
2187 static char buff
[32];
2191 case ELFOSABI_NONE
: return "UNIX - System V";
2192 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2193 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2194 case ELFOSABI_LINUX
: return "UNIX - Linux";
2195 case ELFOSABI_HURD
: return "GNU/Hurd";
2196 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2197 case ELFOSABI_AIX
: return "UNIX - AIX";
2198 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2199 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2200 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2201 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2202 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2203 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2204 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2205 case ELFOSABI_AROS
: return "Amiga Research OS";
2206 case ELFOSABI_STANDALONE
: return _("Standalone App");
2207 case ELFOSABI_ARM
: return "ARM";
2209 sprintf (buff
, _("<unknown: %x>"), osabi
);
2215 get_mips_segment_type (unsigned long type
)
2219 case PT_MIPS_REGINFO
:
2221 case PT_MIPS_RTPROC
:
2223 case PT_MIPS_OPTIONS
:
2233 get_parisc_segment_type (unsigned long type
)
2237 case PT_HP_TLS
: return "HP_TLS";
2238 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2239 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2240 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2241 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2242 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2243 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2244 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2245 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2246 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2247 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2248 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2249 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2250 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2259 get_ia64_segment_type (unsigned long type
)
2263 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2264 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2265 case PT_HP_TLS
: return "HP_TLS";
2266 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2267 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2268 case PT_IA_64_HP_STACK
: return "HP_STACK";
2277 get_segment_type (unsigned long p_type
)
2279 static char buff
[32];
2283 case PT_NULL
: return "NULL";
2284 case PT_LOAD
: return "LOAD";
2285 case PT_DYNAMIC
: return "DYNAMIC";
2286 case PT_INTERP
: return "INTERP";
2287 case PT_NOTE
: return "NOTE";
2288 case PT_SHLIB
: return "SHLIB";
2289 case PT_PHDR
: return "PHDR";
2290 case PT_TLS
: return "TLS";
2292 case PT_GNU_EH_FRAME
:
2293 return "GNU_EH_FRAME";
2294 case PT_GNU_STACK
: return "GNU_STACK";
2295 case PT_GNU_RELRO
: return "GNU_RELRO";
2298 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2302 switch (elf_header
.e_machine
)
2305 case EM_MIPS_RS3_LE
:
2306 result
= get_mips_segment_type (p_type
);
2309 result
= get_parisc_segment_type (p_type
);
2312 result
= get_ia64_segment_type (p_type
);
2322 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2324 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2328 switch (elf_header
.e_machine
)
2331 result
= get_parisc_segment_type (p_type
);
2334 result
= get_ia64_segment_type (p_type
);
2344 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2347 sprintf (buff
, _("<unknown>: %lx"), p_type
);
2354 get_mips_section_type_name (unsigned int sh_type
)
2358 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2359 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2360 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2361 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2362 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2363 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2364 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2365 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2366 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2367 case SHT_MIPS_RELD
: return "MIPS_RELD";
2368 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2369 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2370 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2371 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2372 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2373 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2374 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2375 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2376 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2377 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2378 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2379 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2380 case SHT_MIPS_LINE
: return "MIPS_LINE";
2381 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2382 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2383 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2384 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2385 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2386 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2387 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2388 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2389 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2390 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2391 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2392 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2393 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2394 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2395 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2396 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2404 get_parisc_section_type_name (unsigned int sh_type
)
2408 case SHT_PARISC_EXT
: return "PARISC_EXT";
2409 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2410 case SHT_PARISC_DOC
: return "PARISC_DOC";
2418 get_ia64_section_type_name (unsigned int sh_type
)
2420 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2421 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2422 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2426 case SHT_IA_64_EXT
: return "IA_64_EXT";
2427 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2428 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2436 get_x86_64_section_type_name (unsigned int sh_type
)
2440 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2448 get_arm_section_type_name (unsigned int sh_type
)
2461 get_section_type_name (unsigned int sh_type
)
2463 static char buff
[32];
2467 case SHT_NULL
: return "NULL";
2468 case SHT_PROGBITS
: return "PROGBITS";
2469 case SHT_SYMTAB
: return "SYMTAB";
2470 case SHT_STRTAB
: return "STRTAB";
2471 case SHT_RELA
: return "RELA";
2472 case SHT_HASH
: return "HASH";
2473 case SHT_DYNAMIC
: return "DYNAMIC";
2474 case SHT_NOTE
: return "NOTE";
2475 case SHT_NOBITS
: return "NOBITS";
2476 case SHT_REL
: return "REL";
2477 case SHT_SHLIB
: return "SHLIB";
2478 case SHT_DYNSYM
: return "DYNSYM";
2479 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2480 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2481 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2482 case SHT_GROUP
: return "GROUP";
2483 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2484 case SHT_GNU_verdef
: return "VERDEF";
2485 case SHT_GNU_verneed
: return "VERNEED";
2486 case SHT_GNU_versym
: return "VERSYM";
2487 case 0x6ffffff0: return "VERSYM";
2488 case 0x6ffffffc: return "VERDEF";
2489 case 0x7ffffffd: return "AUXILIARY";
2490 case 0x7fffffff: return "FILTER";
2491 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2494 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2498 switch (elf_header
.e_machine
)
2501 case EM_MIPS_RS3_LE
:
2502 result
= get_mips_section_type_name (sh_type
);
2505 result
= get_parisc_section_type_name (sh_type
);
2508 result
= get_ia64_section_type_name (sh_type
);
2511 result
= get_x86_64_section_type_name (sh_type
);
2514 result
= get_arm_section_type_name (sh_type
);
2524 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2526 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2527 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2528 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2529 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2531 sprintf (buff
, _("<unknown>: %x"), sh_type
);
2537 #define OPTION_DEBUG_DUMP 512
2539 struct option options
[] =
2541 {"all", no_argument
, 0, 'a'},
2542 {"file-header", no_argument
, 0, 'h'},
2543 {"program-headers", no_argument
, 0, 'l'},
2544 {"headers", no_argument
, 0, 'e'},
2545 {"histogram", no_argument
, 0, 'I'},
2546 {"segments", no_argument
, 0, 'l'},
2547 {"sections", no_argument
, 0, 'S'},
2548 {"section-headers", no_argument
, 0, 'S'},
2549 {"section-groups", no_argument
, 0, 'g'},
2550 {"symbols", no_argument
, 0, 's'},
2551 {"syms", no_argument
, 0, 's'},
2552 {"relocs", no_argument
, 0, 'r'},
2553 {"notes", no_argument
, 0, 'n'},
2554 {"dynamic", no_argument
, 0, 'd'},
2555 {"arch-specific", no_argument
, 0, 'A'},
2556 {"version-info", no_argument
, 0, 'V'},
2557 {"use-dynamic", no_argument
, 0, 'D'},
2558 {"hex-dump", required_argument
, 0, 'x'},
2559 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2560 {"unwind", no_argument
, 0, 'u'},
2561 #ifdef SUPPORT_DISASSEMBLY
2562 {"instruction-dump", required_argument
, 0, 'i'},
2565 {"version", no_argument
, 0, 'v'},
2566 {"wide", no_argument
, 0, 'W'},
2567 {"help", no_argument
, 0, 'H'},
2568 {0, no_argument
, 0, 0}
2574 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2575 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2576 fprintf (stdout
, _(" Options are:\n\
2577 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2578 -h --file-header Display the ELF file header\n\
2579 -l --program-headers Display the program headers\n\
2580 --segments An alias for --program-headers\n\
2581 -S --section-headers Display the sections' header\n\
2582 --sections An alias for --section-headers\n\
2583 -g --section-groups Display the section groups\n\
2584 -e --headers Equivalent to: -h -l -S\n\
2585 -s --syms Display the symbol table\n\
2586 --symbols An alias for --syms\n\
2587 -n --notes Display the core notes (if present)\n\
2588 -r --relocs Display the relocations (if present)\n\
2589 -u --unwind Display the unwind info (if present)\n\
2590 -d --dynamic Display the dynamic section (if present)\n\
2591 -V --version-info Display the version sections (if present)\n\
2592 -A --arch-specific Display architecture specific information (if any).\n\
2593 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2594 -x --hex-dump=<number> Dump the contents of section <number>\n\
2595 -w[liaprmfFsoR] or\n\
2596 --debug-dump[=line,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2597 Display the contents of DWARF2 debug sections\n"));
2598 #ifdef SUPPORT_DISASSEMBLY
2599 fprintf (stdout
, _("\
2600 -i --instruction-dump=<number>\n\
2601 Disassemble the contents of section <number>\n"));
2603 fprintf (stdout
, _("\
2604 -I --histogram Display histogram of bucket list lengths\n\
2605 -W --wide Allow output width to exceed 80 characters\n\
2606 -H --help Display this information\n\
2607 -v --version Display the version number of readelf\n"));
2608 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2613 /* Record the fact that the user wants the contents of section number
2614 SECTION to be displayed using the method(s) encoded as flags bits
2615 in TYPE. Note, TYPE can be zero if we are creating the array for
2619 request_dump (unsigned int section
, int type
)
2621 if (section
>= num_dump_sects
)
2623 char *new_dump_sects
;
2625 new_dump_sects
= calloc (section
+ 1, 1);
2627 if (new_dump_sects
== NULL
)
2628 error (_("Out of memory allocating dump request table."));
2631 /* Copy current flag settings. */
2632 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2636 dump_sects
= new_dump_sects
;
2637 num_dump_sects
= section
+ 1;
2642 dump_sects
[section
] |= type
;
2648 parse_args (int argc
, char **argv
)
2655 while ((c
= getopt_long
2656 (argc
, argv
, "ersuahnldSDAIgw::x:i:vVWH", options
, NULL
)) != EOF
)
2677 do_section_groups
++;
2685 do_section_groups
++;
2727 section
= strtoul (optarg
, & cp
, 0);
2728 if (! *cp
&& section
>= 0)
2730 request_dump (section
, HEX_DUMP
);
2740 unsigned int index
= 0;
2744 while (optarg
[index
])
2745 switch (optarg
[index
++])
2754 do_debug_abbrevs
= 1;
2764 do_debug_pubnames
= 1;
2768 do_debug_aranges
= 1;
2772 do_debug_ranges
= 1;
2776 do_debug_frames_interp
= 1;
2778 do_debug_frames
= 1;
2783 do_debug_macinfo
= 1;
2797 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2802 case OPTION_DEBUG_DUMP
:
2810 const char * option
;
2813 debug_dump_long_opts
;
2815 debug_dump_long_opts opts_table
[] =
2817 /* Please keep this table alpha- sorted. */
2818 { "Ranges", & do_debug_ranges
},
2819 { "abbrev", & do_debug_abbrevs
},
2820 { "aranges", & do_debug_aranges
},
2821 { "frames", & do_debug_frames
},
2822 { "frames-interp", & do_debug_frames_interp
},
2823 { "info", & do_debug_info
},
2824 { "line", & do_debug_lines
},
2825 { "loc", & do_debug_loc
},
2826 { "macro", & do_debug_macinfo
},
2827 { "pubnames", & do_debug_pubnames
},
2828 /* This entry is for compatability
2829 with earlier versions of readelf. */
2830 { "ranges", & do_debug_aranges
},
2831 { "str", & do_debug_str
},
2842 debug_dump_long_opts
* entry
;
2844 for (entry
= opts_table
; entry
->option
; entry
++)
2846 size_t len
= strlen (entry
->option
);
2848 if (strneq (p
, entry
->option
, len
)
2849 && (p
[len
] == ',' || p
[len
] == '\0'))
2851 * entry
->variable
= 1;
2853 /* The --debug-dump=frames-interp option also
2854 enables the --debug-dump=frames option. */
2855 if (do_debug_frames_interp
)
2856 do_debug_frames
= 1;
2863 if (entry
->option
== NULL
)
2865 warn (_("Unrecognized debug option '%s'\n"), p
);
2866 p
= strchr (p
, ',');
2876 #ifdef SUPPORT_DISASSEMBLY
2879 section
= strtoul (optarg
, & cp
, 0);
2880 if (! *cp
&& section
>= 0)
2882 request_dump (section
, DISASS_DUMP
);
2888 print_version (program_name
);
2898 /* xgettext:c-format */
2899 error (_("Invalid option '-%c'\n"), c
);
2906 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
2907 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2908 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
2909 && !do_section_groups
)
2913 warn (_("Nothing to do.\n"));
2919 get_elf_class (unsigned int elf_class
)
2921 static char buff
[32];
2925 case ELFCLASSNONE
: return _("none");
2926 case ELFCLASS32
: return "ELF32";
2927 case ELFCLASS64
: return "ELF64";
2929 sprintf (buff
, _("<unknown: %x>"), elf_class
);
2935 get_data_encoding (unsigned int encoding
)
2937 static char buff
[32];
2941 case ELFDATANONE
: return _("none");
2942 case ELFDATA2LSB
: return _("2's complement, little endian");
2943 case ELFDATA2MSB
: return _("2's complement, big endian");
2945 sprintf (buff
, _("<unknown: %x>"), encoding
);
2950 /* Decode the data held in 'elf_header'. */
2953 process_file_header (void)
2955 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
2956 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
2957 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
2958 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
2961 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2969 printf (_("ELF Header:\n"));
2970 printf (_(" Magic: "));
2971 for (i
= 0; i
< EI_NIDENT
; i
++)
2972 printf ("%2.2x ", elf_header
.e_ident
[i
]);
2974 printf (_(" Class: %s\n"),
2975 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
2976 printf (_(" Data: %s\n"),
2977 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
2978 printf (_(" Version: %d %s\n"),
2979 elf_header
.e_ident
[EI_VERSION
],
2980 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
2982 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
2985 printf (_(" OS/ABI: %s\n"),
2986 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
2987 printf (_(" ABI Version: %d\n"),
2988 elf_header
.e_ident
[EI_ABIVERSION
]);
2989 printf (_(" Type: %s\n"),
2990 get_file_type (elf_header
.e_type
));
2991 printf (_(" Machine: %s\n"),
2992 get_machine_name (elf_header
.e_machine
));
2993 printf (_(" Version: 0x%lx\n"),
2994 (unsigned long) elf_header
.e_version
);
2996 printf (_(" Entry point address: "));
2997 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2998 printf (_("\n Start of program headers: "));
2999 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3000 printf (_(" (bytes into file)\n Start of section headers: "));
3001 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3002 printf (_(" (bytes into file)\n"));
3004 printf (_(" Flags: 0x%lx%s\n"),
3005 (unsigned long) elf_header
.e_flags
,
3006 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3007 printf (_(" Size of this header: %ld (bytes)\n"),
3008 (long) elf_header
.e_ehsize
);
3009 printf (_(" Size of program headers: %ld (bytes)\n"),
3010 (long) elf_header
.e_phentsize
);
3011 printf (_(" Number of program headers: %ld\n"),
3012 (long) elf_header
.e_phnum
);
3013 printf (_(" Size of section headers: %ld (bytes)\n"),
3014 (long) elf_header
.e_shentsize
);
3015 printf (_(" Number of section headers: %ld"),
3016 (long) elf_header
.e_shnum
);
3017 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
3018 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3019 putc ('\n', stdout
);
3020 printf (_(" Section header string table index: %ld"),
3021 (long) elf_header
.e_shstrndx
);
3022 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
3023 printf (" (%ld)", (long) section_headers
[0].sh_link
);
3024 putc ('\n', stdout
);
3027 if (section_headers
!= NULL
)
3029 if (elf_header
.e_shnum
== 0)
3030 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3031 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
3032 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3033 free (section_headers
);
3034 section_headers
= NULL
;
3042 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3044 Elf32_External_Phdr
*phdrs
;
3045 Elf32_External_Phdr
*external
;
3046 Elf_Internal_Phdr
*internal
;
3049 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3050 elf_header
.e_phentsize
* elf_header
.e_phnum
,
3051 _("program headers"));
3055 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3056 i
< elf_header
.e_phnum
;
3057 i
++, internal
++, external
++)
3059 internal
->p_type
= BYTE_GET (external
->p_type
);
3060 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3061 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3062 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3063 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3064 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3065 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3066 internal
->p_align
= BYTE_GET (external
->p_align
);
3075 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3077 Elf64_External_Phdr
*phdrs
;
3078 Elf64_External_Phdr
*external
;
3079 Elf_Internal_Phdr
*internal
;
3082 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3083 elf_header
.e_phentsize
* elf_header
.e_phnum
,
3084 _("program headers"));
3088 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3089 i
< elf_header
.e_phnum
;
3090 i
++, internal
++, external
++)
3092 internal
->p_type
= BYTE_GET (external
->p_type
);
3093 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3094 internal
->p_offset
= BYTE_GET8 (external
->p_offset
);
3095 internal
->p_vaddr
= BYTE_GET8 (external
->p_vaddr
);
3096 internal
->p_paddr
= BYTE_GET8 (external
->p_paddr
);
3097 internal
->p_filesz
= BYTE_GET8 (external
->p_filesz
);
3098 internal
->p_memsz
= BYTE_GET8 (external
->p_memsz
);
3099 internal
->p_align
= BYTE_GET8 (external
->p_align
);
3107 /* Returns 1 if the program headers were read into `program_headers'. */
3110 get_program_headers (FILE *file
)
3112 Elf_Internal_Phdr
*phdrs
;
3114 /* Check cache of prior read. */
3115 if (program_headers
!= NULL
)
3118 phdrs
= malloc (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
3122 error (_("Out of memory\n"));
3127 ? get_32bit_program_headers (file
, phdrs
)
3128 : get_64bit_program_headers (file
, phdrs
))
3130 program_headers
= phdrs
;
3138 /* Returns 1 if the program headers were loaded. */
3141 process_program_headers (FILE *file
)
3143 Elf_Internal_Phdr
*segment
;
3146 if (elf_header
.e_phnum
== 0)
3149 printf (_("\nThere are no program headers in this file.\n"));
3153 if (do_segments
&& !do_header
)
3155 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3156 printf (_("Entry point "));
3157 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3158 printf (_("\nThere are %d program headers, starting at offset "),
3159 elf_header
.e_phnum
);
3160 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3164 if (! get_program_headers (file
))
3169 if (elf_header
.e_phnum
> 1)
3170 printf (_("\nProgram Headers:\n"));
3172 printf (_("\nProgram Headers:\n"));
3176 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3179 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3183 (_(" Type Offset VirtAddr PhysAddr\n"));
3185 (_(" FileSiz MemSiz Flags Align\n"));
3192 for (i
= 0, segment
= program_headers
;
3193 i
< elf_header
.e_phnum
;
3198 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3202 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3203 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3204 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3205 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3206 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3208 (segment
->p_flags
& PF_R
? 'R' : ' '),
3209 (segment
->p_flags
& PF_W
? 'W' : ' '),
3210 (segment
->p_flags
& PF_X
? 'E' : ' '));
3211 printf ("%#lx", (unsigned long) segment
->p_align
);
3215 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3216 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3219 print_vma (segment
->p_offset
, FULL_HEX
);
3223 print_vma (segment
->p_vaddr
, FULL_HEX
);
3225 print_vma (segment
->p_paddr
, FULL_HEX
);
3228 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3229 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3232 print_vma (segment
->p_filesz
, FULL_HEX
);
3236 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3237 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3240 print_vma (segment
->p_offset
, FULL_HEX
);
3244 (segment
->p_flags
& PF_R
? 'R' : ' '),
3245 (segment
->p_flags
& PF_W
? 'W' : ' '),
3246 (segment
->p_flags
& PF_X
? 'E' : ' '));
3248 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3249 printf ("%#lx", (unsigned long) segment
->p_align
);
3252 print_vma (segment
->p_align
, PREFIX_HEX
);
3257 print_vma (segment
->p_offset
, FULL_HEX
);
3259 print_vma (segment
->p_vaddr
, FULL_HEX
);
3261 print_vma (segment
->p_paddr
, FULL_HEX
);
3263 print_vma (segment
->p_filesz
, FULL_HEX
);
3265 print_vma (segment
->p_memsz
, FULL_HEX
);
3267 (segment
->p_flags
& PF_R
? 'R' : ' '),
3268 (segment
->p_flags
& PF_W
? 'W' : ' '),
3269 (segment
->p_flags
& PF_X
? 'E' : ' '));
3270 print_vma (segment
->p_align
, HEX
);
3274 switch (segment
->p_type
)
3278 error (_("more than one dynamic segment\n"));
3280 /* Try to locate the .dynamic section. If there is
3281 a section header table, we can easily locate it. */
3282 if (section_headers
!= NULL
)
3284 Elf_Internal_Shdr
*sec
;
3287 for (j
= 0, sec
= section_headers
;
3288 j
< elf_header
.e_shnum
;
3290 if (streq (SECTION_NAME (sec
), ".dynamic"))
3293 if (j
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
3295 error (_("no .dynamic section in the dynamic segment"));
3299 dynamic_addr
= sec
->sh_offset
;
3300 dynamic_size
= sec
->sh_size
;
3302 if (dynamic_addr
< segment
->p_offset
3303 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3304 warn (_("the .dynamic section is not contained within the dynamic segment"));
3305 else if (dynamic_addr
> segment
->p_offset
)
3306 warn (_("the .dynamic section is not the first section in the dynamic segment."));
3310 /* Otherwise, we can only assume that the .dynamic
3311 section is the first section in the DYNAMIC segment. */
3312 dynamic_addr
= segment
->p_offset
;
3313 dynamic_size
= segment
->p_filesz
;
3318 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3320 error (_("Unable to find program interpreter name\n"));
3323 program_interpreter
[0] = 0;
3324 fscanf (file
, "%63s", program_interpreter
);
3327 printf (_("\n [Requesting program interpreter: %s]"),
3328 program_interpreter
);
3334 putc ('\n', stdout
);
3337 if (do_segments
&& section_headers
!= NULL
)
3339 printf (_("\n Section to Segment mapping:\n"));
3340 printf (_(" Segment Sections...\n"));
3342 assert (string_table
!= NULL
);
3344 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3347 Elf_Internal_Shdr
*section
;
3349 segment
= program_headers
+ i
;
3350 section
= section_headers
;
3352 printf (" %2.2d ", i
);
3354 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3356 if (section
->sh_size
> 0
3357 /* Compare allocated sections by VMA, unallocated
3358 sections by file offset. */
3359 && (section
->sh_flags
& SHF_ALLOC
3360 ? (section
->sh_addr
>= segment
->p_vaddr
3361 && section
->sh_addr
+ section
->sh_size
3362 <= segment
->p_vaddr
+ segment
->p_memsz
)
3363 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
3364 && (section
->sh_offset
+ section
->sh_size
3365 <= segment
->p_offset
+ segment
->p_filesz
)))
3366 /* .tbss is special. It doesn't contribute memory space
3367 to normal segments. */
3368 && (!((section
->sh_flags
& SHF_TLS
) != 0
3369 && section
->sh_type
== SHT_NOBITS
)
3370 || segment
->p_type
== PT_TLS
))
3371 printf ("%s ", SECTION_NAME (section
));
3382 /* Find the file offset corresponding to VMA by using the program headers. */
3385 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3387 Elf_Internal_Phdr
*seg
;
3389 if (! get_program_headers (file
))
3391 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3395 for (seg
= program_headers
;
3396 seg
< program_headers
+ elf_header
.e_phnum
;
3399 if (seg
->p_type
!= PT_LOAD
)
3402 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3403 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3404 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3407 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3414 get_32bit_section_headers (FILE *file
, unsigned int num
)
3416 Elf32_External_Shdr
*shdrs
;
3417 Elf_Internal_Shdr
*internal
;
3420 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3421 elf_header
.e_shentsize
* num
, _("section headers"));
3425 section_headers
= malloc (num
* sizeof (Elf_Internal_Shdr
));
3427 if (section_headers
== NULL
)
3429 error (_("Out of memory\n"));
3433 for (i
= 0, internal
= section_headers
;
3437 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3438 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3439 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3440 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3441 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3442 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3443 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3444 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3445 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3446 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3455 get_64bit_section_headers (FILE *file
, unsigned int num
)
3457 Elf64_External_Shdr
*shdrs
;
3458 Elf_Internal_Shdr
*internal
;
3461 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3462 elf_header
.e_shentsize
* num
, _("section headers"));
3466 section_headers
= malloc (num
* sizeof (Elf_Internal_Shdr
));
3468 if (section_headers
== NULL
)
3470 error (_("Out of memory\n"));
3474 for (i
= 0, internal
= section_headers
;
3478 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3479 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3480 internal
->sh_flags
= BYTE_GET8 (shdrs
[i
].sh_flags
);
3481 internal
->sh_addr
= BYTE_GET8 (shdrs
[i
].sh_addr
);
3482 internal
->sh_size
= BYTE_GET8 (shdrs
[i
].sh_size
);
3483 internal
->sh_entsize
= BYTE_GET8 (shdrs
[i
].sh_entsize
);
3484 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3485 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3486 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3487 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3495 static Elf_Internal_Sym
*
3496 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3498 unsigned long number
;
3499 Elf32_External_Sym
*esyms
;
3500 Elf_External_Sym_Shndx
*shndx
;
3501 Elf_Internal_Sym
*isyms
;
3502 Elf_Internal_Sym
*psym
;
3505 esyms
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
3511 if (symtab_shndx_hdr
!= NULL
3512 && (symtab_shndx_hdr
->sh_link
3513 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3515 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3516 symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3524 number
= section
->sh_size
/ section
->sh_entsize
;
3525 isyms
= malloc (number
* sizeof (Elf_Internal_Sym
));
3529 error (_("Out of memory\n"));
3536 for (j
= 0, psym
= isyms
;
3540 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3541 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3542 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3543 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3544 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3546 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3547 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3548 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3558 static Elf_Internal_Sym
*
3559 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3561 unsigned long number
;
3562 Elf64_External_Sym
*esyms
;
3563 Elf_External_Sym_Shndx
*shndx
;
3564 Elf_Internal_Sym
*isyms
;
3565 Elf_Internal_Sym
*psym
;
3568 esyms
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
3574 if (symtab_shndx_hdr
!= NULL
3575 && (symtab_shndx_hdr
->sh_link
3576 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3578 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3579 symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3587 number
= section
->sh_size
/ section
->sh_entsize
;
3588 isyms
= malloc (number
* sizeof (Elf_Internal_Sym
));
3592 error (_("Out of memory\n"));
3599 for (j
= 0, psym
= isyms
;
3603 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3604 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3605 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3606 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3607 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3609 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3610 psym
->st_value
= BYTE_GET8 (esyms
[j
].st_value
);
3611 psym
->st_size
= BYTE_GET8 (esyms
[j
].st_size
);
3622 get_elf_section_flags (bfd_vma sh_flags
)
3624 static char buff
[32];
3632 flag
= sh_flags
& - sh_flags
;
3637 case SHF_WRITE
: strcat (buff
, "W"); break;
3638 case SHF_ALLOC
: strcat (buff
, "A"); break;
3639 case SHF_EXECINSTR
: strcat (buff
, "X"); break;
3640 case SHF_MERGE
: strcat (buff
, "M"); break;
3641 case SHF_STRINGS
: strcat (buff
, "S"); break;
3642 case SHF_INFO_LINK
: strcat (buff
, "I"); break;
3643 case SHF_LINK_ORDER
: strcat (buff
, "L"); break;
3644 case SHF_OS_NONCONFORMING
: strcat (buff
, "O"); break;
3645 case SHF_GROUP
: strcat (buff
, "G"); break;
3646 case SHF_TLS
: strcat (buff
, "T"); break;
3649 if (flag
& SHF_MASKOS
)
3652 sh_flags
&= ~ SHF_MASKOS
;
3654 else if (flag
& SHF_MASKPROC
)
3657 sh_flags
&= ~ SHF_MASKPROC
;
3669 process_section_headers (FILE *file
)
3671 Elf_Internal_Shdr
*section
;
3674 section_headers
= NULL
;
3676 if (elf_header
.e_shnum
== 0)
3679 printf (_("\nThere are no sections in this file.\n"));
3684 if (do_sections
&& !do_header
)
3685 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3686 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3690 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3693 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3696 /* Read in the string table, so that we have names to display. */
3697 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3699 if (section
->sh_size
!= 0)
3701 string_table
= get_data (NULL
, file
, section
->sh_offset
,
3702 section
->sh_size
, _("string table"));
3704 if (string_table
== NULL
)
3707 string_table_length
= section
->sh_size
;
3710 /* Scan the sections for the dynamic symbol table
3711 and dynamic string table and debug sections. */
3712 dynamic_symbols
= NULL
;
3713 dynamic_strings
= NULL
;
3714 dynamic_syminfo
= NULL
;
3715 symtab_shndx_hdr
= NULL
;
3717 for (i
= 0, section
= section_headers
;
3718 i
< elf_header
.e_shnum
;
3721 char *name
= SECTION_NAME (section
);
3723 if (section
->sh_type
== SHT_DYNSYM
)
3725 if (dynamic_symbols
!= NULL
)
3727 error (_("File contains multiple dynamic symbol tables\n"));
3731 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
3732 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
3734 else if (section
->sh_type
== SHT_STRTAB
3735 && streq (name
, ".dynstr"))
3737 if (dynamic_strings
!= NULL
)
3739 error (_("File contains multiple dynamic string tables\n"));
3743 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
3744 section
->sh_size
, _("dynamic strings"));
3745 dynamic_strings_length
= section
->sh_size
;
3747 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
3749 if (symtab_shndx_hdr
!= NULL
)
3751 error (_("File contains multiple symtab shndx tables\n"));
3754 symtab_shndx_hdr
= section
;
3756 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
3757 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
3758 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
3759 || do_debug_loc
|| do_debug_ranges
)
3760 && strneq (name
, ".debug_", 7))
3765 || (do_debug_info
&& streq (name
, "info"))
3766 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
3767 || (do_debug_lines
&& streq (name
, "line"))
3768 || (do_debug_pubnames
&& streq (name
, "pubnames"))
3769 || (do_debug_aranges
&& streq (name
, "aranges"))
3770 || (do_debug_ranges
&& streq (name
, "ranges"))
3771 || (do_debug_frames
&& streq (name
, "frame"))
3772 || (do_debug_macinfo
&& streq (name
, "macinfo"))
3773 || (do_debug_str
&& streq (name
, "str"))
3774 || (do_debug_loc
&& streq (name
, "loc"))
3776 request_dump (i
, DEBUG_DUMP
);
3778 /* linkonce section to be combined with .debug_info at link time. */
3779 else if ((do_debugging
|| do_debug_info
)
3780 && strneq (name
, ".gnu.linkonce.wi.", 17))
3781 request_dump (i
, DEBUG_DUMP
);
3782 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
3783 request_dump (i
, DEBUG_DUMP
);
3789 if (elf_header
.e_shnum
> 1)
3790 printf (_("\nSection Headers:\n"));
3792 printf (_("\nSection Header:\n"));
3796 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3799 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3802 printf (_(" [Nr] Name Type Address Offset\n"));
3803 printf (_(" Size EntSize Flags Link Info Align\n"));
3806 for (i
= 0, section
= section_headers
;
3807 i
< elf_header
.e_shnum
;
3810 printf (" [%2u] %-17.17s %-15.15s ",
3811 SECTION_HEADER_NUM (i
),
3812 SECTION_NAME (section
),
3813 get_section_type_name (section
->sh_type
));
3817 print_vma (section
->sh_addr
, LONG_HEX
);
3819 printf ( " %6.6lx %6.6lx %2.2lx",
3820 (unsigned long) section
->sh_offset
,
3821 (unsigned long) section
->sh_size
,
3822 (unsigned long) section
->sh_entsize
);
3824 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3826 printf ("%2ld %3lu %2ld\n",
3827 (unsigned long) section
->sh_link
,
3828 (unsigned long) section
->sh_info
,
3829 (unsigned long) section
->sh_addralign
);
3833 print_vma (section
->sh_addr
, LONG_HEX
);
3835 if ((long) section
->sh_offset
== section
->sh_offset
)
3836 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
3840 print_vma (section
->sh_offset
, LONG_HEX
);
3843 if ((unsigned long) section
->sh_size
== section
->sh_size
)
3844 printf (" %6.6lx", (unsigned long) section
->sh_size
);
3848 print_vma (section
->sh_size
, LONG_HEX
);
3851 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
3852 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
3856 print_vma (section
->sh_entsize
, LONG_HEX
);
3859 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3861 printf ("%2ld %3lu ",
3862 (unsigned long) section
->sh_link
,
3863 (unsigned long) section
->sh_info
);
3865 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
3866 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
3869 print_vma (section
->sh_addralign
, DEC
);
3876 print_vma (section
->sh_addr
, LONG_HEX
);
3877 if ((long) section
->sh_offset
== section
->sh_offset
)
3878 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
3882 print_vma (section
->sh_offset
, LONG_HEX
);
3885 print_vma (section
->sh_size
, LONG_HEX
);
3887 print_vma (section
->sh_entsize
, LONG_HEX
);
3889 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3891 printf (" %2ld %3lu %ld\n",
3892 (unsigned long) section
->sh_link
,
3893 (unsigned long) section
->sh_info
,
3894 (unsigned long) section
->sh_addralign
);
3898 printf (_("Key to Flags:\n\
3899 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
3900 I (info), L (link order), G (group), x (unknown)\n\
3901 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3907 get_group_flags (unsigned int flags
)
3909 static char buff
[32];
3916 sprintf (buff
, _("[<unknown>: 0x%x]"), flags
);
3923 process_section_groups (FILE *file
)
3925 Elf_Internal_Shdr
*section
;
3927 struct group
*group
;
3929 if (elf_header
.e_shnum
== 0)
3931 if (do_section_groups
)
3932 printf (_("\nThere are no section groups in this file.\n"));
3937 if (section_headers
== NULL
)
3939 error (_("Section headers are not available!\n"));
3943 section_headers_groups
= calloc (elf_header
.e_shnum
,
3944 sizeof (struct group
*));
3946 if (section_headers_groups
== NULL
)
3948 error (_("Out of memory\n"));
3952 /* Scan the sections for the group section. */
3953 for (i
= 0, section
= section_headers
;
3954 i
< elf_header
.e_shnum
;
3956 if (section
->sh_type
== SHT_GROUP
)
3959 section_groups
= calloc (group_count
, sizeof (struct group
));
3961 if (section_groups
== NULL
)
3963 error (_("Out of memory\n"));
3967 for (i
= 0, section
= section_headers
, group
= section_groups
;
3968 i
< elf_header
.e_shnum
;
3971 if (section
->sh_type
== SHT_GROUP
)
3973 char *name
= SECTION_NAME (section
);
3974 char *group_name
, *strtab
, *start
, *indices
;
3975 unsigned int entry
, j
, size
;
3976 Elf_Internal_Sym
*sym
;
3977 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
, *sec
;
3978 Elf_Internal_Sym
*symtab
;
3980 /* Get the symbol table. */
3981 symtab_sec
= SECTION_HEADER (section
->sh_link
);
3982 if (symtab_sec
->sh_type
!= SHT_SYMTAB
)
3984 error (_("Bad sh_link in group section `%s'\n"), name
);
3987 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
3989 sym
= symtab
+ section
->sh_info
;
3991 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
3993 bfd_vma sec_index
= SECTION_HEADER_INDEX (sym
->st_shndx
);
3996 error (_("Bad sh_info in group section `%s'\n"), name
);
4000 group_name
= SECTION_NAME (section_headers
+ sec_index
);
4005 /* Get the string table. */
4006 strtab_sec
= SECTION_HEADER (symtab_sec
->sh_link
);
4007 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4008 strtab_sec
->sh_size
,
4011 group_name
= strtab
+ sym
->st_name
;
4014 start
= get_data (NULL
, file
, section
->sh_offset
,
4015 section
->sh_size
, _("section data"));
4018 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4019 entry
= byte_get (indices
, 4);
4022 if (do_section_groups
)
4024 printf ("\n%s group section `%s' [%s] contains %u sections:\n",
4025 get_group_flags (entry
), name
, group_name
, size
);
4027 printf (_(" [Index] Name\n"));
4030 group
->group_index
= i
;
4032 for (j
= 0; j
< size
; j
++)
4034 struct group_list
*g
;
4036 entry
= byte_get (indices
, 4);
4039 if (section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4042 error (_("section [%5u] already in group section [%5u]\n"),
4043 entry
, section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4047 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4050 if (do_section_groups
)
4052 sec
= SECTION_HEADER (entry
);
4053 printf (" [%5u] %s\n",
4054 entry
, SECTION_NAME (sec
));
4057 g
= xmalloc (sizeof (struct group_list
));
4058 g
->section_index
= entry
;
4059 g
->next
= group
->root
;
4083 } dynamic_relocations
[] =
4085 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4086 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4087 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4090 /* Process the reloc section. */
4093 process_relocs (FILE *file
)
4095 unsigned long rel_size
;
4096 unsigned long rel_offset
;
4102 if (do_using_dynamic
)
4106 int has_dynamic_reloc
;
4109 has_dynamic_reloc
= 0;
4111 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4113 is_rela
= dynamic_relocations
[i
].rela
;
4114 name
= dynamic_relocations
[i
].name
;
4115 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4116 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4118 has_dynamic_reloc
|= rel_size
;
4120 if (is_rela
== UNKNOWN
)
4122 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4123 switch (dynamic_info
[DT_PLTREL
])
4137 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4138 name
, rel_offset
, rel_size
);
4140 dump_relocations (file
,
4141 offset_from_vma (file
, rel_offset
, rel_size
),
4143 dynamic_symbols
, num_dynamic_syms
,
4144 dynamic_strings
, dynamic_strings_length
, is_rela
);
4148 if (! has_dynamic_reloc
)
4149 printf (_("\nThere are no dynamic relocations in this file.\n"));
4153 Elf_Internal_Shdr
*section
;
4157 for (i
= 0, section
= section_headers
;
4158 i
< elf_header
.e_shnum
;
4161 if ( section
->sh_type
!= SHT_RELA
4162 && section
->sh_type
!= SHT_REL
)
4165 rel_offset
= section
->sh_offset
;
4166 rel_size
= section
->sh_size
;
4170 Elf_Internal_Shdr
*strsec
;
4173 printf (_("\nRelocation section "));
4175 if (string_table
== NULL
)
4176 printf ("%d", section
->sh_name
);
4178 printf (_("'%s'"), SECTION_NAME (section
));
4180 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4181 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4183 is_rela
= section
->sh_type
== SHT_RELA
;
4185 if (section
->sh_link
)
4187 Elf_Internal_Shdr
*symsec
;
4188 Elf_Internal_Sym
*symtab
;
4189 unsigned long nsyms
;
4190 unsigned long strtablen
;
4191 char *strtab
= NULL
;
4193 symsec
= SECTION_HEADER (section
->sh_link
);
4194 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4195 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4200 strsec
= SECTION_HEADER (symsec
->sh_link
);
4202 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4203 strsec
->sh_size
, _("string table"));
4204 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4206 dump_relocations (file
, rel_offset
, rel_size
,
4207 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4213 dump_relocations (file
, rel_offset
, rel_size
,
4214 NULL
, 0, NULL
, 0, is_rela
);
4221 printf (_("\nThere are no relocations in this file.\n"));
4227 /* Process the unwind section. */
4229 #include "unwind-ia64.h"
4231 /* An absolute address consists of a section and an offset. If the
4232 section is NULL, the offset itself is the address, otherwise, the
4233 address equals to LOAD_ADDRESS(section) + offset. */
4237 unsigned short section
;
4241 struct ia64_unw_aux_info
4243 struct ia64_unw_table_entry
4245 struct absaddr start
;
4247 struct absaddr info
;
4249 *table
; /* Unwind table. */
4250 unsigned long table_len
; /* Length of unwind table. */
4251 unsigned char *info
; /* Unwind info. */
4252 unsigned long info_size
; /* Size of unwind info. */
4253 bfd_vma info_addr
; /* starting address of unwind info. */
4254 bfd_vma seg_base
; /* Starting address of segment. */
4255 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4256 unsigned long nsyms
; /* Number of symbols. */
4257 char *strtab
; /* The string table. */
4258 unsigned long strtab_size
; /* Size of string table. */
4262 find_symbol_for_address (Elf_Internal_Sym
*symtab
,
4263 unsigned long nsyms
,
4265 unsigned long strtab_size
,
4266 struct absaddr addr
,
4267 const char **symname
,
4270 bfd_vma dist
= 0x100000;
4271 Elf_Internal_Sym
*sym
, *best
= NULL
;
4274 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4276 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4277 && sym
->st_name
!= 0
4278 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4279 && addr
.offset
>= sym
->st_value
4280 && addr
.offset
- sym
->st_value
< dist
)
4283 dist
= addr
.offset
- sym
->st_value
;
4290 *symname
= (best
->st_name
>= strtab_size
4291 ? "<corrupt>" : strtab
+ best
->st_name
);
4296 *offset
= addr
.offset
;
4300 dump_ia64_unwind (struct ia64_unw_aux_info
*aux
)
4303 struct ia64_unw_table_entry
*tp
;
4306 addr_size
= is_32bit_elf
? 4 : 8;
4308 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4312 const unsigned char *dp
;
4313 const unsigned char *head
;
4314 const char *procname
;
4316 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4317 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4319 fputs ("\n<", stdout
);
4323 fputs (procname
, stdout
);
4326 printf ("+%lx", (unsigned long) offset
);
4329 fputs (">: [", stdout
);
4330 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4331 fputc ('-', stdout
);
4332 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4333 printf ("], info at +0x%lx\n",
4334 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4336 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
4337 stamp
= BYTE_GET8 ((unsigned char *) head
);
4339 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4340 (unsigned) UNW_VER (stamp
),
4341 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4342 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4343 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4344 (unsigned long) (addr_size
* UNW_LENGTH (stamp
)));
4346 if (UNW_VER (stamp
) != 1)
4348 printf ("\tUnknown version.\n");
4353 for (dp
= head
+ 8; dp
< head
+ 8 + addr_size
* UNW_LENGTH (stamp
);)
4354 dp
= unw_decode (dp
, in_body
, & in_body
);
4359 slurp_ia64_unwind_table (FILE *file
,
4360 struct ia64_unw_aux_info
*aux
,
4361 Elf_Internal_Shdr
*sec
)
4363 unsigned long size
, addr_size
, nrelas
, i
;
4364 Elf_Internal_Phdr
*seg
;
4365 struct ia64_unw_table_entry
*tep
;
4366 Elf_Internal_Shdr
*relsec
;
4367 Elf_Internal_Rela
*rela
, *rp
;
4368 unsigned char *table
, *tp
;
4369 Elf_Internal_Sym
*sym
;
4370 const char *relname
;
4372 addr_size
= is_32bit_elf
? 4 : 8;
4374 /* First, find the starting address of the segment that includes
4377 if (elf_header
.e_phnum
)
4379 if (! get_program_headers (file
))
4382 for (seg
= program_headers
;
4383 seg
< program_headers
+ elf_header
.e_phnum
;
4386 if (seg
->p_type
!= PT_LOAD
)
4389 if (sec
->sh_addr
>= seg
->p_vaddr
4390 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4392 aux
->seg_base
= seg
->p_vaddr
;
4398 /* Second, build the unwind table from the contents of the unwind section: */
4399 size
= sec
->sh_size
;
4400 table
= get_data (NULL
, file
, sec
->sh_offset
, size
, _("unwind table"));
4404 tep
= aux
->table
= xmalloc (size
/ (3 * addr_size
) * sizeof (aux
->table
[0]));
4405 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * addr_size
, ++tep
)
4407 tep
->start
.section
= SHN_UNDEF
;
4408 tep
->end
.section
= SHN_UNDEF
;
4409 tep
->info
.section
= SHN_UNDEF
;
4412 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4413 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4414 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4418 tep
->start
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 0);
4419 tep
->end
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 8);
4420 tep
->info
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 16);
4422 tep
->start
.offset
+= aux
->seg_base
;
4423 tep
->end
.offset
+= aux
->seg_base
;
4424 tep
->info
.offset
+= aux
->seg_base
;
4428 /* Third, apply any relocations to the unwind table: */
4430 for (relsec
= section_headers
;
4431 relsec
< section_headers
+ elf_header
.e_shnum
;
4434 if (relsec
->sh_type
!= SHT_RELA
4435 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4438 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4442 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4446 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4447 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4451 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4452 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4455 if (! strneq (relname
, "R_IA64_SEGREL", 13))
4457 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4461 i
= rp
->r_offset
/ (3 * addr_size
);
4463 switch (rp
->r_offset
/addr_size
% 3)
4466 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4467 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
4470 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4471 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
4474 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4475 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
4485 aux
->table_len
= size
/ (3 * addr_size
);
4490 ia64_process_unwind (FILE *file
)
4492 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4493 unsigned long i
, addr_size
, unwcount
= 0, unwstart
= 0;
4494 struct ia64_unw_aux_info aux
;
4496 memset (& aux
, 0, sizeof (aux
));
4498 addr_size
= is_32bit_elf
? 4 : 8;
4500 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4502 if (sec
->sh_type
== SHT_SYMTAB
)
4504 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4505 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4507 strsec
= SECTION_HEADER (sec
->sh_link
);
4508 aux
.strtab_size
= strsec
->sh_size
;
4509 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4510 aux
.strtab_size
, _("string table"));
4512 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4517 printf (_("\nThere are no unwind sections in this file.\n"));
4519 while (unwcount
-- > 0)
4524 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
4525 i
< elf_header
.e_shnum
; ++i
, ++sec
)
4526 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4533 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
4535 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
4537 /* We need to find which section group it is in. */
4538 struct group_list
*g
= section_headers_groups
[i
]->root
;
4540 for (; g
!= NULL
; g
= g
->next
)
4542 sec
= SECTION_HEADER (g
->section_index
);
4544 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
4549 i
= elf_header
.e_shnum
;
4551 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
4553 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
4554 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
4555 suffix
= SECTION_NAME (unwsec
) + len
;
4556 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4558 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
4559 && streq (SECTION_NAME (sec
) + len2
, suffix
))
4564 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4565 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
4566 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
4567 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
4569 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
4570 suffix
= SECTION_NAME (unwsec
) + len
;
4571 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4573 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
4574 && streq (SECTION_NAME (sec
) + len2
, suffix
))
4578 if (i
== elf_header
.e_shnum
)
4580 printf (_("\nCould not find unwind info section for "));
4582 if (string_table
== NULL
)
4583 printf ("%d", unwsec
->sh_name
);
4585 printf (_("'%s'"), SECTION_NAME (unwsec
));
4589 aux
.info_size
= sec
->sh_size
;
4590 aux
.info_addr
= sec
->sh_addr
;
4591 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, aux
.info_size
,
4594 printf (_("\nUnwind section "));
4596 if (string_table
== NULL
)
4597 printf ("%d", unwsec
->sh_name
);
4599 printf (_("'%s'"), SECTION_NAME (unwsec
));
4601 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4602 (unsigned long) unwsec
->sh_offset
,
4603 (unsigned long) (unwsec
->sh_size
/ (3 * addr_size
)));
4605 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
4607 if (aux
.table_len
> 0)
4608 dump_ia64_unwind (& aux
);
4611 free ((char *) aux
.table
);
4613 free ((char *) aux
.info
);
4622 free ((char *) aux
.strtab
);
4627 struct hppa_unw_aux_info
4629 struct hppa_unw_table_entry
4631 struct absaddr start
;
4633 unsigned int Cannot_unwind
:1; /* 0 */
4634 unsigned int Millicode
:1; /* 1 */
4635 unsigned int Millicode_save_sr0
:1; /* 2 */
4636 unsigned int Region_description
:2; /* 3..4 */
4637 unsigned int reserved1
:1; /* 5 */
4638 unsigned int Entry_SR
:1; /* 6 */
4639 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
4640 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
4641 unsigned int Args_stored
:1; /* 16 */
4642 unsigned int Variable_Frame
:1; /* 17 */
4643 unsigned int Separate_Package_Body
:1; /* 18 */
4644 unsigned int Frame_Extension_Millicode
:1; /* 19 */
4645 unsigned int Stack_Overflow_Check
:1; /* 20 */
4646 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
4647 unsigned int Ada_Region
:1; /* 22 */
4648 unsigned int cxx_info
:1; /* 23 */
4649 unsigned int cxx_try_catch
:1; /* 24 */
4650 unsigned int sched_entry_seq
:1; /* 25 */
4651 unsigned int reserved2
:1; /* 26 */
4652 unsigned int Save_SP
:1; /* 27 */
4653 unsigned int Save_RP
:1; /* 28 */
4654 unsigned int Save_MRP_in_frame
:1; /* 29 */
4655 unsigned int extn_ptr_defined
:1; /* 30 */
4656 unsigned int Cleanup_defined
:1; /* 31 */
4658 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
4659 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
4660 unsigned int Large_frame
:1; /* 2 */
4661 unsigned int Pseudo_SP_Set
:1; /* 3 */
4662 unsigned int reserved4
:1; /* 4 */
4663 unsigned int Total_frame_size
:27; /* 5..31 */
4665 *table
; /* Unwind table. */
4666 unsigned long table_len
; /* Length of unwind table. */
4667 bfd_vma seg_base
; /* Starting address of segment. */
4668 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4669 unsigned long nsyms
; /* Number of symbols. */
4670 char *strtab
; /* The string table. */
4671 unsigned long strtab_size
; /* Size of string table. */
4675 dump_hppa_unwind (struct hppa_unw_aux_info
*aux
)
4678 struct hppa_unw_table_entry
*tp
;
4680 addr_size
= is_32bit_elf
? 4 : 8;
4681 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4684 const char *procname
;
4686 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4687 aux
->strtab_size
, tp
->start
, &procname
,
4690 fputs ("\n<", stdout
);
4694 fputs (procname
, stdout
);
4697 printf ("+%lx", (unsigned long) offset
);
4700 fputs (">: [", stdout
);
4701 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4702 fputc ('-', stdout
);
4703 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4706 #define PF(_m) if (tp->_m) printf (#_m " ");
4707 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
4710 PF(Millicode_save_sr0
);
4711 /* PV(Region_description); */
4717 PF(Separate_Package_Body
);
4718 PF(Frame_Extension_Millicode
);
4719 PF(Stack_Overflow_Check
);
4720 PF(Two_Instruction_SP_Increment
);
4724 PF(sched_entry_seq
);
4727 PF(Save_MRP_in_frame
);
4728 PF(extn_ptr_defined
);
4729 PF(Cleanup_defined
);
4730 PF(MPE_XL_interrupt_marker
);
4731 PF(HP_UX_interrupt_marker
);
4734 PV(Total_frame_size
);
4743 slurp_hppa_unwind_table (FILE *file
,
4744 struct hppa_unw_aux_info
*aux
,
4745 Elf_Internal_Shdr
*sec
)
4747 unsigned long size
, unw_ent_size
, addr_size
, nrelas
, i
;
4748 Elf_Internal_Phdr
*seg
;
4749 struct hppa_unw_table_entry
*tep
;
4750 Elf_Internal_Shdr
*relsec
;
4751 Elf_Internal_Rela
*rela
, *rp
;
4752 unsigned char *table
, *tp
;
4753 Elf_Internal_Sym
*sym
;
4754 const char *relname
;
4756 addr_size
= is_32bit_elf
? 4 : 8;
4758 /* First, find the starting address of the segment that includes
4761 if (elf_header
.e_phnum
)
4763 if (! get_program_headers (file
))
4766 for (seg
= program_headers
;
4767 seg
< program_headers
+ elf_header
.e_phnum
;
4770 if (seg
->p_type
!= PT_LOAD
)
4773 if (sec
->sh_addr
>= seg
->p_vaddr
4774 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4776 aux
->seg_base
= seg
->p_vaddr
;
4782 /* Second, build the unwind table from the contents of the unwind
4784 size
= sec
->sh_size
;
4785 table
= get_data (NULL
, file
, sec
->sh_offset
, size
, _("unwind table"));
4789 unw_ent_size
= 2 * addr_size
+ 8;
4791 tep
= aux
->table
= xmalloc (size
/ unw_ent_size
* sizeof (aux
->table
[0]));
4793 for (tp
= table
; tp
< table
+ size
; tp
+= (2 * addr_size
+ 8), ++tep
)
4795 unsigned int tmp1
, tmp2
;
4797 tep
->start
.section
= SHN_UNDEF
;
4798 tep
->end
.section
= SHN_UNDEF
;
4802 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4803 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4804 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
4805 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
4809 tep
->start
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 0);
4810 tep
->end
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 8);
4811 tmp1
= byte_get ((unsigned char *) tp
+ 16, 4);
4812 tmp2
= byte_get ((unsigned char *) tp
+ 20, 4);
4815 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
4816 tep
->Millicode
= (tmp1
>> 30) & 0x1;
4817 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
4818 tep
->Region_description
= (tmp1
>> 27) & 0x3;
4819 tep
->reserved1
= (tmp1
>> 26) & 0x1;
4820 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
4821 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
4822 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
4823 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
4824 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
4825 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
4826 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
4827 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
4828 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
4829 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
4830 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
4831 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
4832 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
4833 tep
->reserved2
= (tmp1
>> 5) & 0x1;
4834 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
4835 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
4836 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
4837 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
4838 tep
->Cleanup_defined
= tmp1
& 0x1;
4840 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
4841 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
4842 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
4843 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
4844 tep
->reserved4
= (tmp2
>> 27) & 0x1;
4845 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
4847 tep
->start
.offset
+= aux
->seg_base
;
4848 tep
->end
.offset
+= aux
->seg_base
;
4852 /* Third, apply any relocations to the unwind table. */
4854 for (relsec
= section_headers
;
4855 relsec
< section_headers
+ elf_header
.e_shnum
;
4858 if (relsec
->sh_type
!= SHT_RELA
4859 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4862 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4866 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4870 relname
= elf_hppa_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4871 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4875 relname
= elf_hppa_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4876 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4879 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
4880 if (strncmp (relname
, "R_PARISC_SEGREL", 15) != 0)
4882 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4886 i
= rp
->r_offset
/ unw_ent_size
;
4888 switch ((rp
->r_offset
% unw_ent_size
) / addr_size
)
4891 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4892 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
4895 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4896 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
4906 aux
->table_len
= size
/ unw_ent_size
;
4912 hppa_process_unwind (FILE *file
)
4914 struct hppa_unw_aux_info aux
;
4915 Elf_Internal_Shdr
*unwsec
= NULL
;
4916 Elf_Internal_Shdr
*strsec
;
4917 Elf_Internal_Shdr
*sec
;
4918 unsigned long addr_size
;
4921 memset (& aux
, 0, sizeof (aux
));
4923 assert (string_table
!= NULL
);
4924 addr_size
= is_32bit_elf
? 4 : 8;
4926 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4928 if (sec
->sh_type
== SHT_SYMTAB
)
4930 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4931 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4933 strsec
= SECTION_HEADER (sec
->sh_link
);
4934 aux
.strtab_size
= strsec
->sh_size
;
4935 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4936 aux
.strtab_size
, _("string table"));
4938 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
4943 printf (_("\nThere are no unwind sections in this file.\n"));
4945 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4947 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
4949 printf (_("\nUnwind section "));
4950 printf (_("'%s'"), SECTION_NAME (sec
));
4952 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4953 (unsigned long) sec
->sh_offset
,
4954 (unsigned long) (sec
->sh_size
/ (2 * addr_size
+ 8)));
4956 slurp_hppa_unwind_table (file
, &aux
, sec
);
4957 if (aux
.table_len
> 0)
4958 dump_hppa_unwind (&aux
);
4961 free ((char *) aux
.table
);
4969 free ((char *) aux
.strtab
);
4975 process_unwind (FILE *file
)
4977 struct unwind_handler
{
4979 int (*handler
)(FILE *file
);
4981 { EM_IA_64
, ia64_process_unwind
},
4982 { EM_PARISC
, hppa_process_unwind
},
4990 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
4991 if (elf_header
.e_machine
== handlers
[i
].machtype
)
4992 return handlers
[i
].handler (file
);
4994 printf (_("\nThere are no unwind sections in this file.\n"));
4999 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
5001 switch (entry
->d_tag
)
5004 if (entry
->d_un
.d_val
== 0)
5008 static const char * opts
[] =
5010 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5011 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5012 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5013 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5018 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
5019 if (entry
->d_un
.d_val
& (1 << cnt
))
5021 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5028 case DT_MIPS_IVERSION
:
5029 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5030 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5032 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5035 case DT_MIPS_TIME_STAMP
:
5040 time_t time
= entry
->d_un
.d_val
;
5041 tmp
= gmtime (&time
);
5042 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
5043 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5044 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5045 printf ("Time Stamp: %s\n", timebuf
);
5049 case DT_MIPS_RLD_VERSION
:
5050 case DT_MIPS_LOCAL_GOTNO
:
5051 case DT_MIPS_CONFLICTNO
:
5052 case DT_MIPS_LIBLISTNO
:
5053 case DT_MIPS_SYMTABNO
:
5054 case DT_MIPS_UNREFEXTNO
:
5055 case DT_MIPS_HIPAGENO
:
5056 case DT_MIPS_DELTA_CLASS_NO
:
5057 case DT_MIPS_DELTA_INSTANCE_NO
:
5058 case DT_MIPS_DELTA_RELOC_NO
:
5059 case DT_MIPS_DELTA_SYM_NO
:
5060 case DT_MIPS_DELTA_CLASSSYM_NO
:
5061 case DT_MIPS_COMPACT_SIZE
:
5062 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5066 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
5072 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
5074 switch (entry
->d_tag
)
5076 case DT_HP_DLD_FLAGS
:
5085 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5086 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5087 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5088 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5089 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5090 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5091 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5092 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5093 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5094 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5095 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
5099 bfd_vma val
= entry
->d_un
.d_val
;
5101 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
5102 if (val
& flags
[cnt
].bit
)
5106 fputs (flags
[cnt
].str
, stdout
);
5108 val
^= flags
[cnt
].bit
;
5111 if (val
!= 0 || first
)
5115 print_vma (val
, HEX
);
5121 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5128 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
5130 switch (entry
->d_tag
)
5132 case DT_IA_64_PLT_RESERVE
:
5133 /* First 3 slots reserved. */
5134 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5136 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5140 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5147 get_32bit_dynamic_section (FILE *file
)
5149 Elf32_External_Dyn
*edyn
, *ext
;
5150 Elf_Internal_Dyn
*entry
;
5152 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
5153 _("dynamic section"));
5157 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5158 might not have the luxury of section headers. Look for the DT_NULL
5159 terminator to determine the number of entries. */
5160 for (ext
= edyn
, dynamic_nent
= 0;
5161 (char *) ext
< (char *) edyn
+ dynamic_size
;
5165 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5169 dynamic_section
= malloc (dynamic_nent
* sizeof (*entry
));
5170 if (dynamic_section
== NULL
)
5172 error (_("Out of memory\n"));
5177 for (ext
= edyn
, entry
= dynamic_section
;
5178 entry
< dynamic_section
+ dynamic_nent
;
5181 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5182 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5191 get_64bit_dynamic_section (FILE *file
)
5193 Elf64_External_Dyn
*edyn
, *ext
;
5194 Elf_Internal_Dyn
*entry
;
5196 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
5197 _("dynamic section"));
5201 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5202 might not have the luxury of section headers. Look for the DT_NULL
5203 terminator to determine the number of entries. */
5204 for (ext
= edyn
, dynamic_nent
= 0;
5205 (char *) ext
< (char *) edyn
+ dynamic_size
;
5209 if (BYTE_GET8 (ext
->d_tag
) == DT_NULL
)
5213 dynamic_section
= malloc (dynamic_nent
* sizeof (*entry
));
5214 if (dynamic_section
== NULL
)
5216 error (_("Out of memory\n"));
5221 for (ext
= edyn
, entry
= dynamic_section
;
5222 entry
< dynamic_section
+ dynamic_nent
;
5225 entry
->d_tag
= BYTE_GET8 (ext
->d_tag
);
5226 entry
->d_un
.d_val
= BYTE_GET8 (ext
->d_un
.d_val
);
5235 get_dynamic_flags (bfd_vma flags
)
5237 static char buff
[128];
5245 flag
= flags
& - flags
;
5253 case DF_ORIGIN
: strcpy (p
, "ORIGIN"); break;
5254 case DF_SYMBOLIC
: strcpy (p
, "SYMBOLIC"); break;
5255 case DF_TEXTREL
: strcpy (p
, "TEXTREL"); break;
5256 case DF_BIND_NOW
: strcpy (p
, "BIND_NOW"); break;
5257 case DF_STATIC_TLS
: strcpy (p
, "STATIC_TLS"); break;
5258 default: strcpy (p
, "unknown"); break;
5261 p
= strchr (p
, '\0');
5266 /* Parse and display the contents of the dynamic section. */
5269 process_dynamic_section (FILE *file
)
5271 Elf_Internal_Dyn
*entry
;
5273 if (dynamic_size
== 0)
5276 printf (_("\nThere is no dynamic section in this file.\n"));
5283 if (! get_32bit_dynamic_section (file
))
5286 else if (! get_64bit_dynamic_section (file
))
5289 /* Find the appropriate symbol table. */
5290 if (dynamic_symbols
== NULL
)
5292 for (entry
= dynamic_section
;
5293 entry
< dynamic_section
+ dynamic_nent
;
5296 Elf_Internal_Shdr section
;
5298 if (entry
->d_tag
!= DT_SYMTAB
)
5301 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5303 /* Since we do not know how big the symbol table is,
5304 we default to reading in the entire file (!) and
5305 processing that. This is overkill, I know, but it
5307 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5309 if (archive_file_offset
!= 0)
5310 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5313 if (fseek (file
, 0, SEEK_END
))
5314 error (_("Unable to seek to end of file!"));
5316 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5320 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5322 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5324 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5325 if (num_dynamic_syms
< 1)
5327 error (_("Unable to determine the number of symbols to load\n"));
5331 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5335 /* Similarly find a string table. */
5336 if (dynamic_strings
== NULL
)
5338 for (entry
= dynamic_section
;
5339 entry
< dynamic_section
+ dynamic_nent
;
5342 unsigned long offset
;
5345 if (entry
->d_tag
!= DT_STRTAB
)
5348 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5350 /* Since we do not know how big the string table is,
5351 we default to reading in the entire file (!) and
5352 processing that. This is overkill, I know, but it
5355 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5357 if (archive_file_offset
!= 0)
5358 str_tab_len
= archive_file_size
- offset
;
5361 if (fseek (file
, 0, SEEK_END
))
5362 error (_("Unable to seek to end of file\n"));
5363 str_tab_len
= ftell (file
) - offset
;
5366 if (str_tab_len
< 1)
5369 (_("Unable to determine the length of the dynamic string table\n"));
5373 dynamic_strings
= get_data (NULL
, file
, offset
, str_tab_len
,
5374 _("dynamic string table"));
5375 dynamic_strings_length
= str_tab_len
;
5380 /* And find the syminfo section if available. */
5381 if (dynamic_syminfo
== NULL
)
5383 unsigned long syminsz
= 0;
5385 for (entry
= dynamic_section
;
5386 entry
< dynamic_section
+ dynamic_nent
;
5389 if (entry
->d_tag
== DT_SYMINENT
)
5391 /* Note: these braces are necessary to avoid a syntax
5392 error from the SunOS4 C compiler. */
5393 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5395 else if (entry
->d_tag
== DT_SYMINSZ
)
5396 syminsz
= entry
->d_un
.d_val
;
5397 else if (entry
->d_tag
== DT_SYMINFO
)
5398 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5402 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5404 Elf_External_Syminfo
*extsyminfo
, *extsym
;
5405 Elf_Internal_Syminfo
*syminfo
;
5407 /* There is a syminfo section. Read the data. */
5408 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, syminsz
,
5409 _("symbol information"));
5413 dynamic_syminfo
= malloc (syminsz
);
5414 if (dynamic_syminfo
== NULL
)
5416 error (_("Out of memory\n"));
5420 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
5421 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
5422 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
5423 ++syminfo
, ++extsym
)
5425 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
5426 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
5433 if (do_dynamic
&& dynamic_addr
)
5434 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5435 dynamic_addr
, dynamic_nent
);
5437 printf (_(" Tag Type Name/Value\n"));
5439 for (entry
= dynamic_section
;
5440 entry
< dynamic_section
+ dynamic_nent
;
5448 print_vma (entry
->d_tag
, FULL_HEX
);
5449 dtype
= get_dynamic_type (entry
->d_tag
);
5450 printf (" (%s)%*s", dtype
,
5451 ((is_32bit_elf
? 27 : 19)
5452 - (int) strlen (dtype
)),
5456 switch (entry
->d_tag
)
5460 puts (get_dynamic_flags (entry
->d_un
.d_val
));
5470 switch (entry
->d_tag
)
5473 printf (_("Auxiliary library"));
5477 printf (_("Filter library"));
5481 printf (_("Configuration file"));
5485 printf (_("Dependency audit library"));
5489 printf (_("Audit library"));
5493 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5494 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5498 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5507 printf (_("Flags:"));
5509 if (entry
->d_un
.d_val
== 0)
5510 printf (_(" None\n"));
5513 unsigned long int val
= entry
->d_un
.d_val
;
5515 if (val
& DTF_1_PARINIT
)
5517 printf (" PARINIT");
5518 val
^= DTF_1_PARINIT
;
5520 if (val
& DTF_1_CONFEXP
)
5522 printf (" CONFEXP");
5523 val
^= DTF_1_CONFEXP
;
5526 printf (" %lx", val
);
5535 printf (_("Flags:"));
5537 if (entry
->d_un
.d_val
== 0)
5538 printf (_(" None\n"));
5541 unsigned long int val
= entry
->d_un
.d_val
;
5543 if (val
& DF_P1_LAZYLOAD
)
5545 printf (" LAZYLOAD");
5546 val
^= DF_P1_LAZYLOAD
;
5548 if (val
& DF_P1_GROUPPERM
)
5550 printf (" GROUPPERM");
5551 val
^= DF_P1_GROUPPERM
;
5554 printf (" %lx", val
);
5563 printf (_("Flags:"));
5564 if (entry
->d_un
.d_val
== 0)
5565 printf (_(" None\n"));
5568 unsigned long int val
= entry
->d_un
.d_val
;
5575 if (val
& DF_1_GLOBAL
)
5580 if (val
& DF_1_GROUP
)
5585 if (val
& DF_1_NODELETE
)
5587 printf (" NODELETE");
5588 val
^= DF_1_NODELETE
;
5590 if (val
& DF_1_LOADFLTR
)
5592 printf (" LOADFLTR");
5593 val
^= DF_1_LOADFLTR
;
5595 if (val
& DF_1_INITFIRST
)
5597 printf (" INITFIRST");
5598 val
^= DF_1_INITFIRST
;
5600 if (val
& DF_1_NOOPEN
)
5605 if (val
& DF_1_ORIGIN
)
5610 if (val
& DF_1_DIRECT
)
5615 if (val
& DF_1_TRANS
)
5620 if (val
& DF_1_INTERPOSE
)
5622 printf (" INTERPOSE");
5623 val
^= DF_1_INTERPOSE
;
5625 if (val
& DF_1_NODEFLIB
)
5627 printf (" NODEFLIB");
5628 val
^= DF_1_NODEFLIB
;
5630 if (val
& DF_1_NODUMP
)
5635 if (val
& DF_1_CONLFAT
)
5637 printf (" CONLFAT");
5638 val
^= DF_1_CONLFAT
;
5641 printf (" %lx", val
);
5648 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5650 puts (get_dynamic_type (entry
->d_un
.d_val
));
5670 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5676 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5677 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
5683 switch (entry
->d_tag
)
5686 printf (_("Shared library: [%s]"), name
);
5688 if (streq (name
, program_interpreter
))
5689 printf (_(" program interpreter"));
5693 printf (_("Library soname: [%s]"), name
);
5697 printf (_("Library rpath: [%s]"), name
);
5701 printf (_("Library runpath: [%s]"), name
);
5705 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5710 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5723 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5727 case DT_INIT_ARRAYSZ
:
5728 case DT_FINI_ARRAYSZ
:
5729 case DT_GNU_CONFLICTSZ
:
5730 case DT_GNU_LIBLISTSZ
:
5733 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5734 printf (" (bytes)\n");
5744 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5757 if (entry
->d_tag
== DT_USED
5758 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5760 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
5764 printf (_("Not needed object: [%s]\n"), name
);
5769 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5775 /* The value of this entry is ignored. */
5780 case DT_GNU_PRELINKED
:
5784 time_t time
= entry
->d_un
.d_val
;
5786 tmp
= gmtime (&time
);
5787 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
5788 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5789 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5795 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
5796 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
5801 switch (elf_header
.e_machine
)
5804 case EM_MIPS_RS3_LE
:
5805 dynamic_section_mips_val (entry
);
5808 dynamic_section_parisc_val (entry
);
5811 dynamic_section_ia64_val (entry
);
5814 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5826 get_ver_flags (unsigned int flags
)
5828 static char buff
[32];
5835 if (flags
& VER_FLG_BASE
)
5836 strcat (buff
, "BASE ");
5838 if (flags
& VER_FLG_WEAK
)
5840 if (flags
& VER_FLG_BASE
)
5841 strcat (buff
, "| ");
5843 strcat (buff
, "WEAK ");
5846 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
5847 strcat (buff
, "| <unknown>");
5852 /* Display the contents of the version sections. */
5854 process_version_sections (FILE *file
)
5856 Elf_Internal_Shdr
*section
;
5863 for (i
= 0, section
= section_headers
;
5864 i
< elf_header
.e_shnum
;
5867 switch (section
->sh_type
)
5869 case SHT_GNU_verdef
:
5871 Elf_External_Verdef
*edefs
;
5878 (_("\nVersion definition section '%s' contains %ld entries:\n"),
5879 SECTION_NAME (section
), section
->sh_info
);
5881 printf (_(" Addr: 0x"));
5882 printf_vma (section
->sh_addr
);
5883 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5884 (unsigned long) section
->sh_offset
, section
->sh_link
,
5885 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5887 edefs
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
5888 _("version definition section"));
5892 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5895 Elf_External_Verdef
*edef
;
5896 Elf_Internal_Verdef ent
;
5897 Elf_External_Verdaux
*eaux
;
5898 Elf_Internal_Verdaux aux
;
5902 vstart
= ((char *) edefs
) + idx
;
5904 edef
= (Elf_External_Verdef
*) vstart
;
5906 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
5907 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
5908 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
5909 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
5910 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
5911 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
5912 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
5914 printf (_(" %#06x: Rev: %d Flags: %s"),
5915 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
5917 printf (_(" Index: %d Cnt: %d "),
5918 ent
.vd_ndx
, ent
.vd_cnt
);
5920 vstart
+= ent
.vd_aux
;
5922 eaux
= (Elf_External_Verdaux
*) vstart
;
5924 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5925 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5927 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
5928 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
5930 printf (_("Name index: %ld\n"), aux
.vda_name
);
5932 isum
= idx
+ ent
.vd_aux
;
5934 for (j
= 1; j
< ent
.vd_cnt
; j
++)
5936 isum
+= aux
.vda_next
;
5937 vstart
+= aux
.vda_next
;
5939 eaux
= (Elf_External_Verdaux
*) vstart
;
5941 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5942 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5944 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
5945 printf (_(" %#06x: Parent %d: %s\n"),
5946 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
5948 printf (_(" %#06x: Parent %d, name index: %ld\n"),
5949 isum
, j
, aux
.vda_name
);
5959 case SHT_GNU_verneed
:
5961 Elf_External_Verneed
*eneed
;
5967 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
5968 SECTION_NAME (section
), section
->sh_info
);
5970 printf (_(" Addr: 0x"));
5971 printf_vma (section
->sh_addr
);
5972 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
5973 (unsigned long) section
->sh_offset
, section
->sh_link
,
5974 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5976 eneed
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
5977 _("version need section"));
5981 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5983 Elf_External_Verneed
*entry
;
5984 Elf_Internal_Verneed ent
;
5989 vstart
= ((char *) eneed
) + idx
;
5991 entry
= (Elf_External_Verneed
*) vstart
;
5993 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
5994 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
5995 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
5996 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
5997 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
5999 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6001 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6002 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6004 printf (_(" File: %lx"), ent
.vn_file
);
6006 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6008 vstart
+= ent
.vn_aux
;
6010 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6012 Elf_External_Vernaux
*eaux
;
6013 Elf_Internal_Vernaux aux
;
6015 eaux
= (Elf_External_Vernaux
*) vstart
;
6017 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6018 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6019 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6020 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6021 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6023 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6024 printf (_(" %#06x: Name: %s"),
6025 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6027 printf (_(" %#06x: Name index: %lx"),
6028 isum
, aux
.vna_name
);
6030 printf (_(" Flags: %s Version: %d\n"),
6031 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6033 isum
+= aux
.vna_next
;
6034 vstart
+= aux
.vna_next
;
6044 case SHT_GNU_versym
:
6046 Elf_Internal_Shdr
*link_section
;
6049 unsigned char *edata
;
6050 unsigned short *data
;
6052 Elf_Internal_Sym
*symbols
;
6053 Elf_Internal_Shdr
*string_sec
;
6056 link_section
= SECTION_HEADER (section
->sh_link
);
6057 total
= section
->sh_size
/ section
->sh_entsize
;
6061 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6063 string_sec
= SECTION_HEADER (link_section
->sh_link
);
6065 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
6066 string_sec
->sh_size
, _("version string table"));
6070 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6071 SECTION_NAME (section
), total
);
6073 printf (_(" Addr: "));
6074 printf_vma (section
->sh_addr
);
6075 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6076 (unsigned long) section
->sh_offset
, section
->sh_link
,
6077 SECTION_NAME (link_section
));
6079 off
= offset_from_vma (file
,
6080 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6081 total
* sizeof (short));
6082 edata
= get_data (NULL
, file
, off
, total
* sizeof (short),
6083 _("version symbol data"));
6090 data
= malloc (total
* sizeof (short));
6092 for (cnt
= total
; cnt
--;)
6093 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6098 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6101 int check_def
, check_need
;
6104 printf (" %03x:", cnt
);
6106 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6107 switch (data
[cnt
+ j
])
6110 fputs (_(" 0 (*local*) "), stdout
);
6114 fputs (_(" 1 (*global*) "), stdout
);
6118 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6119 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6123 if (SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
6126 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6133 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6135 Elf_Internal_Verneed ivn
;
6136 unsigned long offset
;
6138 offset
= offset_from_vma
6139 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6140 sizeof (Elf_External_Verneed
));
6144 Elf_Internal_Vernaux ivna
;
6145 Elf_External_Verneed evn
;
6146 Elf_External_Vernaux evna
;
6147 unsigned long a_off
;
6149 get_data (&evn
, file
, offset
, sizeof (evn
),
6152 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6153 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6155 a_off
= offset
+ ivn
.vn_aux
;
6159 get_data (&evna
, file
, a_off
, sizeof (evna
),
6160 _("version need aux (2)"));
6162 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6163 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6165 a_off
+= ivna
.vna_next
;
6167 while (ivna
.vna_other
!= data
[cnt
+ j
]
6168 && ivna
.vna_next
!= 0);
6170 if (ivna
.vna_other
== data
[cnt
+ j
])
6172 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6174 name
= strtab
+ ivna
.vna_name
;
6175 nn
+= printf ("(%s%-*s",
6177 12 - (int) strlen (name
),
6183 offset
+= ivn
.vn_next
;
6185 while (ivn
.vn_next
);
6188 if (check_def
&& data
[cnt
+ j
] != 0x8001
6189 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6191 Elf_Internal_Verdef ivd
;
6192 Elf_External_Verdef evd
;
6193 unsigned long offset
;
6195 offset
= offset_from_vma
6196 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6201 get_data (&evd
, file
, offset
, sizeof (evd
),
6204 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6205 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6207 offset
+= ivd
.vd_next
;
6209 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6210 && ivd
.vd_next
!= 0);
6212 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6214 Elf_External_Verdaux evda
;
6215 Elf_Internal_Verdaux ivda
;
6217 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6219 get_data (&evda
, file
,
6220 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6221 sizeof (evda
), _("version def aux"));
6223 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6225 name
= strtab
+ ivda
.vda_name
;
6226 nn
+= printf ("(%s%-*s",
6228 12 - (int) strlen (name
),
6234 printf ("%*c", 18 - nn
, ' ');
6252 printf (_("\nNo version information found in this file.\n"));
6258 get_symbol_binding (unsigned int binding
)
6260 static char buff
[32];
6264 case STB_LOCAL
: return "LOCAL";
6265 case STB_GLOBAL
: return "GLOBAL";
6266 case STB_WEAK
: return "WEAK";
6268 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6269 sprintf (buff
, _("<processor specific>: %d"), binding
);
6270 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6271 sprintf (buff
, _("<OS specific>: %d"), binding
);
6273 sprintf (buff
, _("<unknown>: %d"), binding
);
6279 get_symbol_type (unsigned int type
)
6281 static char buff
[32];
6285 case STT_NOTYPE
: return "NOTYPE";
6286 case STT_OBJECT
: return "OBJECT";
6287 case STT_FUNC
: return "FUNC";
6288 case STT_SECTION
: return "SECTION";
6289 case STT_FILE
: return "FILE";
6290 case STT_COMMON
: return "COMMON";
6291 case STT_TLS
: return "TLS";
6293 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6295 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6296 return "THUMB_FUNC";
6298 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6301 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6302 return "PARISC_MILLI";
6304 sprintf (buff
, _("<processor specific>: %d"), type
);
6306 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6308 if (elf_header
.e_machine
== EM_PARISC
)
6310 if (type
== STT_HP_OPAQUE
)
6312 if (type
== STT_HP_STUB
)
6316 sprintf (buff
, _("<OS specific>: %d"), type
);
6319 sprintf (buff
, _("<unknown>: %d"), type
);
6325 get_symbol_visibility (unsigned int visibility
)
6329 case STV_DEFAULT
: return "DEFAULT";
6330 case STV_INTERNAL
: return "INTERNAL";
6331 case STV_HIDDEN
: return "HIDDEN";
6332 case STV_PROTECTED
: return "PROTECTED";
6338 get_symbol_index_type (unsigned int type
)
6340 static char buff
[32];
6344 case SHN_UNDEF
: return "UND";
6345 case SHN_ABS
: return "ABS";
6346 case SHN_COMMON
: return "COM";
6348 if (type
== SHN_IA_64_ANSI_COMMON
6349 && elf_header
.e_machine
== EM_IA_64
6350 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
6352 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
6353 sprintf (buff
, "PRC[0x%04x]", type
);
6354 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
6355 sprintf (buff
, "OS [0x%04x]", type
);
6356 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
6357 sprintf (buff
, "RSV[0x%04x]", type
);
6359 sprintf (buff
, "%3d", type
);
6367 get_dynamic_data (FILE *file
, unsigned int number
)
6369 unsigned char *e_data
;
6372 e_data
= malloc (number
* 4);
6376 error (_("Out of memory\n"));
6380 if (fread (e_data
, 4, number
, file
) != number
)
6382 error (_("Unable to read in dynamic data\n"));
6386 i_data
= malloc (number
* sizeof (*i_data
));
6390 error (_("Out of memory\n"));
6396 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
6403 /* Dump the symbol table. */
6405 process_symbol_table (FILE *file
)
6407 Elf_Internal_Shdr
*section
;
6408 unsigned char nb
[4];
6409 unsigned char nc
[4];
6412 int *buckets
= NULL
;
6415 if (! do_syms
&& !do_histogram
)
6418 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
6422 (archive_file_offset
6423 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
6424 sizeof nb
+ sizeof nc
)),
6427 error (_("Unable to seek to start of dynamic information"));
6431 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
6433 error (_("Failed to read in number of buckets\n"));
6437 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
6439 error (_("Failed to read in number of chains\n"));
6443 nbuckets
= byte_get (nb
, 4);
6444 nchains
= byte_get (nc
, 4);
6446 buckets
= get_dynamic_data (file
, nbuckets
);
6447 chains
= get_dynamic_data (file
, nchains
);
6449 if (buckets
== NULL
|| chains
== NULL
)
6454 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
6459 printf (_("\nSymbol table for image:\n"));
6461 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6463 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6465 for (hn
= 0; hn
< nbuckets
; hn
++)
6470 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
6472 Elf_Internal_Sym
*psym
;
6474 psym
= dynamic_symbols
+ si
;
6476 printf (" %3d %3d: ", si
, hn
);
6477 print_vma (psym
->st_value
, LONG_HEX
);
6479 print_vma (psym
->st_size
, DEC_5
);
6481 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6482 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6483 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6484 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
6485 if (VALID_DYNAMIC_NAME (psym
->st_name
))
6486 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
6488 printf (" <corrupt: %14ld>", psym
->st_name
);
6493 else if (do_syms
&& !do_using_dynamic
)
6497 for (i
= 0, section
= section_headers
;
6498 i
< elf_header
.e_shnum
;
6503 Elf_Internal_Sym
*symtab
;
6504 Elf_Internal_Sym
*psym
;
6507 if ( section
->sh_type
!= SHT_SYMTAB
6508 && section
->sh_type
!= SHT_DYNSYM
)
6511 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
6512 SECTION_NAME (section
),
6513 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
6515 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6517 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6519 symtab
= GET_ELF_SYMBOLS (file
, section
);
6523 if (section
->sh_link
== elf_header
.e_shstrndx
)
6524 strtab
= string_table
;
6527 Elf_Internal_Shdr
*string_sec
;
6529 string_sec
= SECTION_HEADER (section
->sh_link
);
6531 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
6532 string_sec
->sh_size
, _("string table"));
6535 for (si
= 0, psym
= symtab
;
6536 si
< section
->sh_size
/ section
->sh_entsize
;
6539 printf ("%6d: ", si
);
6540 print_vma (psym
->st_value
, LONG_HEX
);
6542 print_vma (psym
->st_size
, DEC_5
);
6543 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6544 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6545 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6546 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
6547 print_symbol (25, strtab
+ psym
->st_name
);
6549 if (section
->sh_type
== SHT_DYNSYM
&&
6550 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
6552 unsigned char data
[2];
6553 unsigned short vers_data
;
6554 unsigned long offset
;
6558 offset
= offset_from_vma
6559 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6560 sizeof data
+ si
* sizeof (vers_data
));
6562 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
6563 sizeof (data
), _("version data"));
6565 vers_data
= byte_get (data
, 2);
6567 is_nobits
= (SECTION_HEADER (psym
->st_shndx
)->sh_type
6570 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
6572 if ((vers_data
& 0x8000) || vers_data
> 1)
6574 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
6575 && (is_nobits
|| ! check_def
))
6577 Elf_External_Verneed evn
;
6578 Elf_Internal_Verneed ivn
;
6579 Elf_Internal_Vernaux ivna
;
6581 /* We must test both. */
6582 offset
= offset_from_vma
6583 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6588 unsigned long vna_off
;
6590 get_data (&evn
, file
, offset
, sizeof (evn
),
6593 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6594 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6596 vna_off
= offset
+ ivn
.vn_aux
;
6600 Elf_External_Vernaux evna
;
6602 get_data (&evna
, file
, vna_off
,
6604 _("version need aux (3)"));
6606 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6607 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6608 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6610 vna_off
+= ivna
.vna_next
;
6612 while (ivna
.vna_other
!= vers_data
6613 && ivna
.vna_next
!= 0);
6615 if (ivna
.vna_other
== vers_data
)
6618 offset
+= ivn
.vn_next
;
6620 while (ivn
.vn_next
!= 0);
6622 if (ivna
.vna_other
== vers_data
)
6625 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
6628 else if (! is_nobits
)
6629 error (_("bad dynamic symbol"));
6636 if (vers_data
!= 0x8001
6637 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6639 Elf_Internal_Verdef ivd
;
6640 Elf_Internal_Verdaux ivda
;
6641 Elf_External_Verdaux evda
;
6642 unsigned long offset
;
6644 offset
= offset_from_vma
6646 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6647 sizeof (Elf_External_Verdef
));
6651 Elf_External_Verdef evd
;
6653 get_data (&evd
, file
, offset
, sizeof (evd
),
6656 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6657 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6658 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6660 offset
+= ivd
.vd_next
;
6662 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
6663 && ivd
.vd_next
!= 0);
6665 offset
-= ivd
.vd_next
;
6666 offset
+= ivd
.vd_aux
;
6668 get_data (&evda
, file
, offset
, sizeof (evda
),
6669 _("version def aux"));
6671 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6673 if (psym
->st_name
!= ivda
.vda_name
)
6674 printf ((vers_data
& 0x8000)
6676 strtab
+ ivda
.vda_name
);
6686 if (strtab
!= string_table
)
6692 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
6694 if (do_histogram
&& buckets
!= NULL
)
6701 int nzero_counts
= 0;
6704 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
6706 printf (_(" Length Number %% of total Coverage\n"));
6708 lengths
= calloc (nbuckets
, sizeof (int));
6709 if (lengths
== NULL
)
6711 error (_("Out of memory"));
6714 for (hn
= 0; hn
< nbuckets
; ++hn
)
6719 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
6722 if (maxlength
< ++lengths
[hn
])
6727 counts
= calloc (maxlength
+ 1, sizeof (int));
6730 error (_("Out of memory"));
6734 for (hn
= 0; hn
< nbuckets
; ++hn
)
6735 ++counts
[lengths
[hn
]];
6739 printf (" 0 %-10d (%5.1f%%)\n",
6740 counts
[0], (counts
[0] * 100.0) / nbuckets
);
6741 for (si
= 1; si
<= maxlength
; ++si
)
6743 nzero_counts
+= counts
[si
] * si
;
6744 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
6745 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
6746 (nzero_counts
* 100.0) / nsyms
);
6754 if (buckets
!= NULL
)
6764 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
6768 if (dynamic_syminfo
== NULL
6770 /* No syminfo, this is ok. */
6773 /* There better should be a dynamic symbol section. */
6774 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
6778 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
6779 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
6781 printf (_(" Num: Name BoundTo Flags\n"));
6782 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
6784 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
6786 printf ("%4d: ", i
);
6787 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
6788 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
6790 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
6793 switch (dynamic_syminfo
[i
].si_boundto
)
6795 case SYMINFO_BT_SELF
:
6796 fputs ("SELF ", stdout
);
6798 case SYMINFO_BT_PARENT
:
6799 fputs ("PARENT ", stdout
);
6802 if (dynamic_syminfo
[i
].si_boundto
> 0
6803 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
6804 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
6806 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
6810 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
6814 if (flags
& SYMINFO_FLG_DIRECT
)
6816 if (flags
& SYMINFO_FLG_PASSTHRU
)
6817 printf (" PASSTHRU");
6818 if (flags
& SYMINFO_FLG_COPY
)
6820 if (flags
& SYMINFO_FLG_LAZYLOAD
)
6821 printf (" LAZYLOAD");
6829 #ifdef SUPPORT_DISASSEMBLY
6831 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
6833 printf (_("\nAssembly dump of section %s\n"),
6834 SECTION_NAME (section
));
6836 /* XXX -- to be done --- XXX */
6843 dump_section (Elf_Internal_Shdr
*section
, FILE *file
)
6845 bfd_size_type bytes
;
6847 unsigned char *data
;
6848 unsigned char *start
;
6850 bytes
= section
->sh_size
;
6852 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
6854 printf (_("\nSection '%s' has no data to dump.\n"),
6855 SECTION_NAME (section
));
6859 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
6861 addr
= section
->sh_addr
;
6863 start
= get_data (NULL
, file
, section
->sh_offset
, bytes
, _("section data"));
6875 lbytes
= (bytes
> 16 ? 16 : bytes
);
6877 printf (" 0x%8.8lx ", (unsigned long) addr
);
6879 switch (elf_header
.e_ident
[EI_DATA
])
6883 for (j
= 15; j
>= 0; j
--)
6886 printf ("%2.2x", data
[j
]);
6896 for (j
= 0; j
< 16; j
++)
6899 printf ("%2.2x", data
[j
]);
6909 for (j
= 0; j
< lbytes
; j
++)
6912 if (k
>= ' ' && k
< 0x7f)
6931 static unsigned long int
6932 read_leb128 (unsigned char *data
, int *length_return
, int sign
)
6934 unsigned long int result
= 0;
6935 unsigned int num_read
= 0;
6944 result
|= (byte
& 0x7f) << shift
;
6949 while (byte
& 0x80);
6951 if (length_return
!= NULL
)
6952 *length_return
= num_read
;
6954 if (sign
&& (shift
< 32) && (byte
& 0x40))
6955 result
|= -1 << shift
;
6960 typedef struct State_Machine_Registers
6962 unsigned long address
;
6965 unsigned int column
;
6969 /* This variable hold the number of the last entry seen
6970 in the File Table. */
6971 unsigned int last_file_entry
;
6974 static SMR state_machine_regs
;
6977 reset_state_machine (int is_stmt
)
6979 state_machine_regs
.address
= 0;
6980 state_machine_regs
.file
= 1;
6981 state_machine_regs
.line
= 1;
6982 state_machine_regs
.column
= 0;
6983 state_machine_regs
.is_stmt
= is_stmt
;
6984 state_machine_regs
.basic_block
= 0;
6985 state_machine_regs
.end_sequence
= 0;
6986 state_machine_regs
.last_file_entry
= 0;
6989 /* Handled an extend line op. Returns true if this is the end
6993 process_extended_line_op (unsigned char *data
, int is_stmt
, int pointer_size
)
6995 unsigned char op_code
;
6998 unsigned char *name
;
7001 len
= read_leb128 (data
, & bytes_read
, 0);
7006 warn (_("badly formed extended line op encountered!\n"));
7013 printf (_(" Extended opcode %d: "), op_code
);
7017 case DW_LNE_end_sequence
:
7018 printf (_("End of Sequence\n\n"));
7019 reset_state_machine (is_stmt
);
7022 case DW_LNE_set_address
:
7023 adr
= byte_get (data
, pointer_size
);
7024 printf (_("set Address to 0x%lx\n"), adr
);
7025 state_machine_regs
.address
= adr
;
7028 case DW_LNE_define_file
:
7029 printf (_(" define new File Table entry\n"));
7030 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
7032 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
7034 data
+= strlen ((char *) data
) + 1;
7035 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7037 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7039 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7040 printf (_("%s\n\n"), name
);
7044 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
7051 /* Finds section NAME inside FILE and returns a
7052 pointer to it, or NULL upon failure. */
7054 static Elf_Internal_Shdr
*
7055 find_section (const char * name
)
7057 Elf_Internal_Shdr
*sec
;
7060 for (i
= elf_header
.e_shnum
, sec
= section_headers
+ i
- 1;
7062 if (streq (SECTION_NAME (sec
), name
))
7065 if (i
&& sec
&& sec
->sh_size
!= 0)
7071 /* This could just be an array of unsigned integers, but I expect
7072 that we will want to extend the structure to contain other
7076 unsigned int pointer_size
;
7080 static debug_info
* debug_information
= NULL
;
7081 static unsigned int num_debug_info_entries
= 0;
7084 get_pointer_size_of_comp_unit (unsigned int comp_unit
)
7086 if (num_debug_info_entries
== 0
7087 || comp_unit
>= num_debug_info_entries
)
7090 return debug_information
[comp_unit
].pointer_size
;
7093 /* Locate and scan the .debug_info section in the file and record the pointer
7094 sizes for the compilation units in it. Usually an executable will have
7095 just one pointer size, but this is not guaranteed, and so we try not to
7096 make any assumptions. Returns zero upon failure, or the number of
7097 compilation units upon success. */
7100 get_debug_info (FILE * file
)
7102 Elf_Internal_Shdr
* section
;
7103 unsigned char * start
;
7104 unsigned char * end
;
7105 unsigned char * begin
;
7106 unsigned long length
;
7107 unsigned int num_units
;
7110 /* If we already have the information there is nothing else to do. */
7111 if (num_debug_info_entries
> 0)
7112 return num_debug_info_entries
;
7114 section
= find_section (".debug_info");
7115 if (section
== NULL
)
7118 length
= section
->sh_size
;
7119 start
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
7120 _("extracting information from .debug_info section"));
7124 end
= start
+ section
->sh_size
;
7125 /* First scan the section to get the number of comp units. */
7126 for (begin
= start
, num_units
= 0; begin
< end
; num_units
++)
7128 /* Read the first 4 bytes. For a 32-bit DWARF section, this will
7129 be the length. For a 64-bit DWARF section, it'll be the escape
7130 code 0xffffffff followed by an 8 byte length. */
7131 length
= byte_get (begin
, 4);
7133 if (length
== 0xffffffff)
7135 length
= byte_get (begin
+ 4, 8);
7136 begin
+= length
+ 12;
7139 begin
+= length
+ 4;
7144 error (_("No comp units in .debug_info section ?"));
7149 /* Then allocate an array to hold the information. */
7150 debug_information
= malloc (num_units
* sizeof * debug_information
);
7151 if (debug_information
== NULL
)
7153 error (_("Not enough memory for a debug info array of %u entries"),
7159 /* Populate the array. */
7160 for (begin
= start
, unit
= 0; begin
< end
; unit
++)
7162 length
= byte_get (begin
, 4);
7163 if (length
== 0xffffffff)
7165 /* For 64-bit DWARF, the 1-byte address_size field is 22 bytes
7166 from the start of the section. This is computed as follows:
7168 unit_length: 12 bytes
7170 debug_abbrev_offset: 8 bytes
7171 -----------------------------
7174 debug_information
[unit
].pointer_size
= byte_get (begin
+ 22, 1);
7175 length
= byte_get (begin
+ 4, 8);
7176 begin
+= length
+ 12;
7180 /* For 32-bit DWARF, the 1-byte address_size field is 10 bytes from
7181 the start of the section:
7183 unit_length: 4 bytes
7185 debug_abbrev_offset: 4 bytes
7186 -----------------------------
7189 debug_information
[unit
].pointer_size
= byte_get (begin
+ 10, 1);
7190 begin
+= length
+ 4;
7196 return num_debug_info_entries
= num_units
;
7200 display_debug_lines (Elf_Internal_Shdr
*section
,
7201 unsigned char *start
, FILE *file
)
7203 unsigned char *data
= start
;
7204 unsigned char *end
= start
+ section
->sh_size
;
7205 unsigned int comp_unit
= 0;
7207 printf (_("\nDump of debug contents of section %s:\n\n"),
7208 SECTION_NAME (section
));
7210 get_debug_info (file
);
7214 DWARF2_Internal_LineInfo info
;
7215 unsigned char *standard_opcodes
;
7216 unsigned char *end_of_sequence
;
7217 unsigned char *hdrptr
;
7218 unsigned int pointer_size
;
7219 int initial_length_size
;
7225 /* Check the length of the block. */
7226 info
.li_length
= byte_get (hdrptr
, 4);
7229 if (info
.li_length
== 0xffffffff)
7231 /* This section is 64-bit DWARF 3. */
7232 info
.li_length
= byte_get (hdrptr
, 8);
7235 initial_length_size
= 12;
7240 initial_length_size
= 4;
7243 if (info
.li_length
+ initial_length_size
> section
->sh_size
)
7246 (_("The line info appears to be corrupt - the section is too small\n"));
7250 /* Check its version number. */
7251 info
.li_version
= byte_get (hdrptr
, 2);
7253 if (info
.li_version
!= 2 && info
.li_version
!= 3)
7255 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
7259 info
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
7260 hdrptr
+= offset_size
;
7261 info
.li_min_insn_length
= byte_get (hdrptr
, 1);
7263 info
.li_default_is_stmt
= byte_get (hdrptr
, 1);
7265 info
.li_line_base
= byte_get (hdrptr
, 1);
7267 info
.li_line_range
= byte_get (hdrptr
, 1);
7269 info
.li_opcode_base
= byte_get (hdrptr
, 1);
7272 /* Sign extend the line base field. */
7273 info
.li_line_base
<<= 24;
7274 info
.li_line_base
>>= 24;
7276 /* Get the pointer size from the comp unit associated
7277 with this block of line number information. */
7278 pointer_size
= get_pointer_size_of_comp_unit (comp_unit
);
7279 if (pointer_size
== 0)
7281 error (_("Not enough comp units for .debug_line section\n"));
7286 printf (_(" Length: %ld\n"), info
.li_length
);
7287 printf (_(" DWARF Version: %d\n"), info
.li_version
);
7288 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
7289 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
7290 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
7291 printf (_(" Line Base: %d\n"), info
.li_line_base
);
7292 printf (_(" Line Range: %d\n"), info
.li_line_range
);
7293 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
7294 printf (_(" (Pointer size: %u)\n"), pointer_size
);
7296 end_of_sequence
= data
+ info
.li_length
+ initial_length_size
;
7298 reset_state_machine (info
.li_default_is_stmt
);
7300 /* Display the contents of the Opcodes table. */
7301 standard_opcodes
= hdrptr
;
7303 printf (_("\n Opcodes:\n"));
7305 for (i
= 1; i
< info
.li_opcode_base
; i
++)
7306 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
7308 /* Display the contents of the Directory table. */
7309 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
7312 printf (_("\n The Directory Table is empty.\n"));
7315 printf (_("\n The Directory Table:\n"));
7319 printf (_(" %s\n"), data
);
7321 data
+= strlen ((char *) data
) + 1;
7325 /* Skip the NUL at the end of the table. */
7328 /* Display the contents of the File Name table. */
7330 printf (_("\n The File Name Table is empty.\n"));
7333 printf (_("\n The File Name Table:\n"));
7334 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
7338 unsigned char *name
;
7341 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
7344 data
+= strlen ((char *) data
) + 1;
7346 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7348 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7350 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7352 printf (_("%s\n"), name
);
7356 /* Skip the NUL at the end of the table. */
7359 /* Now display the statements. */
7360 printf (_("\n Line Number Statements:\n"));
7362 while (data
< end_of_sequence
)
7364 unsigned char op_code
;
7370 if (op_code
>= info
.li_opcode_base
)
7372 op_code
-= info
.li_opcode_base
;
7373 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
7374 state_machine_regs
.address
+= adv
;
7375 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
7376 op_code
, adv
, state_machine_regs
.address
);
7377 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
7378 state_machine_regs
.line
+= adv
;
7379 printf (_(" and Line by %d to %d\n"),
7380 adv
, state_machine_regs
.line
);
7382 else switch (op_code
)
7384 case DW_LNS_extended_op
:
7385 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
7390 printf (_(" Copy\n"));
7393 case DW_LNS_advance_pc
:
7394 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
7396 state_machine_regs
.address
+= adv
;
7397 printf (_(" Advance PC by %d to %lx\n"), adv
,
7398 state_machine_regs
.address
);
7401 case DW_LNS_advance_line
:
7402 adv
= read_leb128 (data
, & bytes_read
, 1);
7404 state_machine_regs
.line
+= adv
;
7405 printf (_(" Advance Line by %d to %d\n"), adv
,
7406 state_machine_regs
.line
);
7409 case DW_LNS_set_file
:
7410 adv
= read_leb128 (data
, & bytes_read
, 0);
7412 printf (_(" Set File Name to entry %d in the File Name Table\n"),
7414 state_machine_regs
.file
= adv
;
7417 case DW_LNS_set_column
:
7418 adv
= read_leb128 (data
, & bytes_read
, 0);
7420 printf (_(" Set column to %d\n"), adv
);
7421 state_machine_regs
.column
= adv
;
7424 case DW_LNS_negate_stmt
:
7425 adv
= state_machine_regs
.is_stmt
;
7427 printf (_(" Set is_stmt to %d\n"), adv
);
7428 state_machine_regs
.is_stmt
= adv
;
7431 case DW_LNS_set_basic_block
:
7432 printf (_(" Set basic block\n"));
7433 state_machine_regs
.basic_block
= 1;
7436 case DW_LNS_const_add_pc
:
7437 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
7438 * info
.li_min_insn_length
);
7439 state_machine_regs
.address
+= adv
;
7440 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
7441 state_machine_regs
.address
);
7444 case DW_LNS_fixed_advance_pc
:
7445 adv
= byte_get (data
, 2);
7447 state_machine_regs
.address
+= adv
;
7448 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
7449 adv
, state_machine_regs
.address
);
7452 case DW_LNS_set_prologue_end
:
7453 printf (_(" Set prologue_end to true\n"));
7456 case DW_LNS_set_epilogue_begin
:
7457 printf (_(" Set epilogue_begin to true\n"));
7460 case DW_LNS_set_isa
:
7461 adv
= read_leb128 (data
, & bytes_read
, 0);
7463 printf (_(" Set ISA to %d\n"), adv
);
7467 printf (_(" Unknown opcode %d with operands: "), op_code
);
7469 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
7471 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
7472 i
== 1 ? "" : ", ");
7486 display_debug_pubnames (Elf_Internal_Shdr
*section
,
7487 unsigned char *start
,
7488 FILE *file ATTRIBUTE_UNUSED
)
7490 DWARF2_Internal_PubNames pubnames
;
7493 end
= start
+ section
->sh_size
;
7495 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
7499 unsigned char *data
;
7500 unsigned long offset
;
7501 int offset_size
, initial_length_size
;
7505 pubnames
.pn_length
= byte_get (data
, 4);
7507 if (pubnames
.pn_length
== 0xffffffff)
7509 pubnames
.pn_length
= byte_get (data
, 8);
7512 initial_length_size
= 12;
7517 initial_length_size
= 4;
7520 pubnames
.pn_version
= byte_get (data
, 2);
7522 pubnames
.pn_offset
= byte_get (data
, offset_size
);
7523 data
+= offset_size
;
7524 pubnames
.pn_size
= byte_get (data
, offset_size
);
7525 data
+= offset_size
;
7527 start
+= pubnames
.pn_length
+ initial_length_size
;
7529 if (pubnames
.pn_version
!= 2 && pubnames
.pn_version
!= 3)
7531 static int warned
= 0;
7535 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
7542 printf (_(" Length: %ld\n"),
7543 pubnames
.pn_length
);
7544 printf (_(" Version: %d\n"),
7545 pubnames
.pn_version
);
7546 printf (_(" Offset into .debug_info section: %ld\n"),
7547 pubnames
.pn_offset
);
7548 printf (_(" Size of area in .debug_info section: %ld\n"),
7551 printf (_("\n Offset\tName\n"));
7555 offset
= byte_get (data
, offset_size
);
7559 data
+= offset_size
;
7560 printf (" %-6ld\t\t%s\n", offset
, data
);
7561 data
+= strlen ((char *) data
) + 1;
7564 while (offset
!= 0);
7572 get_TAG_name (unsigned long tag
)
7576 case DW_TAG_padding
: return "DW_TAG_padding";
7577 case DW_TAG_array_type
: return "DW_TAG_array_type";
7578 case DW_TAG_class_type
: return "DW_TAG_class_type";
7579 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
7580 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
7581 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
7582 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
7583 case DW_TAG_label
: return "DW_TAG_label";
7584 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
7585 case DW_TAG_member
: return "DW_TAG_member";
7586 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
7587 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
7588 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
7589 case DW_TAG_string_type
: return "DW_TAG_string_type";
7590 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
7591 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
7592 case DW_TAG_typedef
: return "DW_TAG_typedef";
7593 case DW_TAG_union_type
: return "DW_TAG_union_type";
7594 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
7595 case DW_TAG_variant
: return "DW_TAG_variant";
7596 case DW_TAG_common_block
: return "DW_TAG_common_block";
7597 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
7598 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
7599 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
7600 case DW_TAG_module
: return "DW_TAG_module";
7601 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
7602 case DW_TAG_set_type
: return "DW_TAG_set_type";
7603 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
7604 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
7605 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
7606 case DW_TAG_base_type
: return "DW_TAG_base_type";
7607 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
7608 case DW_TAG_const_type
: return "DW_TAG_const_type";
7609 case DW_TAG_constant
: return "DW_TAG_constant";
7610 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
7611 case DW_TAG_file_type
: return "DW_TAG_file_type";
7612 case DW_TAG_friend
: return "DW_TAG_friend";
7613 case DW_TAG_namelist
: return "DW_TAG_namelist";
7614 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
7615 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
7616 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
7617 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
7618 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
7619 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
7620 case DW_TAG_try_block
: return "DW_TAG_try_block";
7621 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
7622 case DW_TAG_variable
: return "DW_TAG_variable";
7623 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
7624 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
7625 case DW_TAG_format_label
: return "DW_TAG_format_label";
7626 case DW_TAG_function_template
: return "DW_TAG_function_template";
7627 case DW_TAG_class_template
: return "DW_TAG_class_template";
7628 /* DWARF 2.1 values. */
7629 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
7630 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
7631 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
7632 case DW_TAG_namespace
: return "DW_TAG_namespace";
7633 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
7634 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
7635 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
7636 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
7638 case DW_TAG_upc_shared_type
: return "DW_TAG_upc_shared_type";
7639 case DW_TAG_upc_strict_type
: return "DW_TAG_upc_strict_type";
7640 case DW_TAG_upc_relaxed_type
: return "DW_TAG_upc_relaxed_type";
7643 static char buffer
[100];
7645 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
7652 get_AT_name (unsigned long attribute
)
7656 case DW_AT_sibling
: return "DW_AT_sibling";
7657 case DW_AT_location
: return "DW_AT_location";
7658 case DW_AT_name
: return "DW_AT_name";
7659 case DW_AT_ordering
: return "DW_AT_ordering";
7660 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
7661 case DW_AT_byte_size
: return "DW_AT_byte_size";
7662 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
7663 case DW_AT_bit_size
: return "DW_AT_bit_size";
7664 case DW_AT_element_list
: return "DW_AT_element_list";
7665 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
7666 case DW_AT_low_pc
: return "DW_AT_low_pc";
7667 case DW_AT_high_pc
: return "DW_AT_high_pc";
7668 case DW_AT_language
: return "DW_AT_language";
7669 case DW_AT_member
: return "DW_AT_member";
7670 case DW_AT_discr
: return "DW_AT_discr";
7671 case DW_AT_discr_value
: return "DW_AT_discr_value";
7672 case DW_AT_visibility
: return "DW_AT_visibility";
7673 case DW_AT_import
: return "DW_AT_import";
7674 case DW_AT_string_length
: return "DW_AT_string_length";
7675 case DW_AT_common_reference
: return "DW_AT_common_reference";
7676 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
7677 case DW_AT_const_value
: return "DW_AT_const_value";
7678 case DW_AT_containing_type
: return "DW_AT_containing_type";
7679 case DW_AT_default_value
: return "DW_AT_default_value";
7680 case DW_AT_inline
: return "DW_AT_inline";
7681 case DW_AT_is_optional
: return "DW_AT_is_optional";
7682 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
7683 case DW_AT_producer
: return "DW_AT_producer";
7684 case DW_AT_prototyped
: return "DW_AT_prototyped";
7685 case DW_AT_return_addr
: return "DW_AT_return_addr";
7686 case DW_AT_start_scope
: return "DW_AT_start_scope";
7687 case DW_AT_stride_size
: return "DW_AT_stride_size";
7688 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
7689 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
7690 case DW_AT_accessibility
: return "DW_AT_accessibility";
7691 case DW_AT_address_class
: return "DW_AT_address_class";
7692 case DW_AT_artificial
: return "DW_AT_artificial";
7693 case DW_AT_base_types
: return "DW_AT_base_types";
7694 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
7695 case DW_AT_count
: return "DW_AT_count";
7696 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
7697 case DW_AT_decl_column
: return "DW_AT_decl_column";
7698 case DW_AT_decl_file
: return "DW_AT_decl_file";
7699 case DW_AT_decl_line
: return "DW_AT_decl_line";
7700 case DW_AT_declaration
: return "DW_AT_declaration";
7701 case DW_AT_discr_list
: return "DW_AT_discr_list";
7702 case DW_AT_encoding
: return "DW_AT_encoding";
7703 case DW_AT_external
: return "DW_AT_external";
7704 case DW_AT_frame_base
: return "DW_AT_frame_base";
7705 case DW_AT_friend
: return "DW_AT_friend";
7706 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
7707 case DW_AT_macro_info
: return "DW_AT_macro_info";
7708 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
7709 case DW_AT_priority
: return "DW_AT_priority";
7710 case DW_AT_segment
: return "DW_AT_segment";
7711 case DW_AT_specification
: return "DW_AT_specification";
7712 case DW_AT_static_link
: return "DW_AT_static_link";
7713 case DW_AT_type
: return "DW_AT_type";
7714 case DW_AT_use_location
: return "DW_AT_use_location";
7715 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
7716 case DW_AT_virtuality
: return "DW_AT_virtuality";
7717 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
7718 /* DWARF 2.1 values. */
7719 case DW_AT_allocated
: return "DW_AT_allocated";
7720 case DW_AT_associated
: return "DW_AT_associated";
7721 case DW_AT_data_location
: return "DW_AT_data_location";
7722 case DW_AT_stride
: return "DW_AT_stride";
7723 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
7724 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
7725 case DW_AT_extension
: return "DW_AT_extension";
7726 case DW_AT_ranges
: return "DW_AT_ranges";
7727 case DW_AT_trampoline
: return "DW_AT_trampoline";
7728 case DW_AT_call_column
: return "DW_AT_call_column";
7729 case DW_AT_call_file
: return "DW_AT_call_file";
7730 case DW_AT_call_line
: return "DW_AT_call_line";
7731 /* SGI/MIPS extensions. */
7732 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
7733 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
7734 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
7735 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
7736 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
7737 case DW_AT_MIPS_software_pipeline_depth
:
7738 return "DW_AT_MIPS_software_pipeline_depth";
7739 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
7740 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
7741 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
7742 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
7743 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
7744 /* GNU extensions. */
7745 case DW_AT_sf_names
: return "DW_AT_sf_names";
7746 case DW_AT_src_info
: return "DW_AT_src_info";
7747 case DW_AT_mac_info
: return "DW_AT_mac_info";
7748 case DW_AT_src_coords
: return "DW_AT_src_coords";
7749 case DW_AT_body_begin
: return "DW_AT_body_begin";
7750 case DW_AT_body_end
: return "DW_AT_body_end";
7751 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
7752 /* UPC extension. */
7753 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
7756 static char buffer
[100];
7758 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
7765 get_FORM_name (unsigned long form
)
7769 case DW_FORM_addr
: return "DW_FORM_addr";
7770 case DW_FORM_block2
: return "DW_FORM_block2";
7771 case DW_FORM_block4
: return "DW_FORM_block4";
7772 case DW_FORM_data2
: return "DW_FORM_data2";
7773 case DW_FORM_data4
: return "DW_FORM_data4";
7774 case DW_FORM_data8
: return "DW_FORM_data8";
7775 case DW_FORM_string
: return "DW_FORM_string";
7776 case DW_FORM_block
: return "DW_FORM_block";
7777 case DW_FORM_block1
: return "DW_FORM_block1";
7778 case DW_FORM_data1
: return "DW_FORM_data1";
7779 case DW_FORM_flag
: return "DW_FORM_flag";
7780 case DW_FORM_sdata
: return "DW_FORM_sdata";
7781 case DW_FORM_strp
: return "DW_FORM_strp";
7782 case DW_FORM_udata
: return "DW_FORM_udata";
7783 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
7784 case DW_FORM_ref1
: return "DW_FORM_ref1";
7785 case DW_FORM_ref2
: return "DW_FORM_ref2";
7786 case DW_FORM_ref4
: return "DW_FORM_ref4";
7787 case DW_FORM_ref8
: return "DW_FORM_ref8";
7788 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
7789 case DW_FORM_indirect
: return "DW_FORM_indirect";
7792 static char buffer
[100];
7794 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
7800 /* FIXME: There are better and more efficient ways to handle
7801 these structures. For now though, I just want something that
7802 is simple to implement. */
7803 typedef struct abbrev_attr
7805 unsigned long attribute
;
7807 struct abbrev_attr
*next
;
7811 typedef struct abbrev_entry
7813 unsigned long entry
;
7816 struct abbrev_attr
*first_attr
;
7817 struct abbrev_attr
*last_attr
;
7818 struct abbrev_entry
*next
;
7822 static abbrev_entry
*first_abbrev
= NULL
;
7823 static abbrev_entry
*last_abbrev
= NULL
;
7828 abbrev_entry
*abbrev
;
7830 for (abbrev
= first_abbrev
; abbrev
;)
7832 abbrev_entry
*next
= abbrev
->next
;
7835 for (attr
= abbrev
->first_attr
; attr
;)
7837 abbrev_attr
*next
= attr
->next
;
7847 last_abbrev
= first_abbrev
= NULL
;
7851 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
7853 abbrev_entry
*entry
;
7855 entry
= malloc (sizeof (*entry
));
7861 entry
->entry
= number
;
7863 entry
->children
= children
;
7864 entry
->first_attr
= NULL
;
7865 entry
->last_attr
= NULL
;
7868 if (first_abbrev
== NULL
)
7869 first_abbrev
= entry
;
7871 last_abbrev
->next
= entry
;
7873 last_abbrev
= entry
;
7877 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
7881 attr
= malloc (sizeof (*attr
));
7887 attr
->attribute
= attribute
;
7891 if (last_abbrev
->first_attr
== NULL
)
7892 last_abbrev
->first_attr
= attr
;
7894 last_abbrev
->last_attr
->next
= attr
;
7896 last_abbrev
->last_attr
= attr
;
7899 /* Processes the (partial) contents of a .debug_abbrev section.
7900 Returns NULL if the end of the section was encountered.
7901 Returns the address after the last byte read if the end of
7902 an abbreviation set was found. */
7904 static unsigned char *
7905 process_abbrev_section (unsigned char *start
, unsigned char *end
)
7907 if (first_abbrev
!= NULL
)
7913 unsigned long entry
;
7915 unsigned long attribute
;
7918 entry
= read_leb128 (start
, & bytes_read
, 0);
7919 start
+= bytes_read
;
7921 /* A single zero is supposed to end the section according
7922 to the standard. If there's more, then signal that to
7925 return start
== end
? NULL
: start
;
7927 tag
= read_leb128 (start
, & bytes_read
, 0);
7928 start
+= bytes_read
;
7930 children
= *start
++;
7932 add_abbrev (entry
, tag
, children
);
7938 attribute
= read_leb128 (start
, & bytes_read
, 0);
7939 start
+= bytes_read
;
7941 form
= read_leb128 (start
, & bytes_read
, 0);
7942 start
+= bytes_read
;
7945 add_abbrev_attr (attribute
, form
);
7947 while (attribute
!= 0);
7955 display_debug_macinfo (Elf_Internal_Shdr
*section
,
7956 unsigned char *start
,
7957 FILE *file ATTRIBUTE_UNUSED
)
7959 unsigned char *end
= start
+ section
->sh_size
;
7960 unsigned char *curr
= start
;
7961 unsigned int bytes_read
;
7962 enum dwarf_macinfo_record_type op
;
7964 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
7968 unsigned int lineno
;
7976 case DW_MACINFO_start_file
:
7978 unsigned int filenum
;
7980 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7982 filenum
= read_leb128 (curr
, & bytes_read
, 0);
7985 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
7990 case DW_MACINFO_end_file
:
7991 printf (_(" DW_MACINFO_end_file\n"));
7994 case DW_MACINFO_define
:
7995 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7998 curr
+= strlen (string
) + 1;
7999 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
8003 case DW_MACINFO_undef
:
8004 lineno
= read_leb128 (curr
, & bytes_read
, 0);
8007 curr
+= strlen (string
) + 1;
8008 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
8012 case DW_MACINFO_vendor_ext
:
8014 unsigned int constant
;
8016 constant
= read_leb128 (curr
, & bytes_read
, 0);
8019 curr
+= strlen (string
) + 1;
8020 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
8032 display_debug_abbrev (Elf_Internal_Shdr
*section
,
8033 unsigned char *start
,
8034 FILE *file ATTRIBUTE_UNUSED
)
8036 abbrev_entry
*entry
;
8037 unsigned char *end
= start
+ section
->sh_size
;
8039 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
8043 start
= process_abbrev_section (start
, end
);
8045 if (first_abbrev
== NULL
)
8048 printf (_(" Number TAG\n"));
8050 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
8054 printf (_(" %ld %s [%s]\n"),
8056 get_TAG_name (entry
->tag
),
8057 entry
->children
? _("has children") : _("no children"));
8059 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
8060 printf (_(" %-18s %s\n"),
8061 get_AT_name (attr
->attribute
),
8062 get_FORM_name (attr
->form
));
8075 static unsigned char *
8076 display_block (unsigned char *data
, unsigned long length
)
8078 printf (_(" %lu byte block: "), length
);
8081 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
8087 decode_location_expression (unsigned char * data
,
8088 unsigned int pointer_size
,
8089 unsigned long length
)
8093 unsigned long uvalue
;
8094 unsigned char *end
= data
+ length
;
8103 printf ("DW_OP_addr: %lx",
8104 (unsigned long) byte_get (data
, pointer_size
));
8105 data
+= pointer_size
;
8108 printf ("DW_OP_deref");
8111 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
8114 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data
++, 1));
8117 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
8121 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data
, 2));
8125 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
8129 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data
, 4));
8133 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
8134 (unsigned long) byte_get (data
+ 4, 4));
8138 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
8139 (long) byte_get (data
+ 4, 4));
8143 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
8147 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
8151 printf ("DW_OP_dup");
8154 printf ("DW_OP_drop");
8157 printf ("DW_OP_over");
8160 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
8163 printf ("DW_OP_swap");
8166 printf ("DW_OP_rot");
8169 printf ("DW_OP_xderef");
8172 printf ("DW_OP_abs");
8175 printf ("DW_OP_and");
8178 printf ("DW_OP_div");
8181 printf ("DW_OP_minus");
8184 printf ("DW_OP_mod");
8187 printf ("DW_OP_mul");
8190 printf ("DW_OP_neg");
8193 printf ("DW_OP_not");
8196 printf ("DW_OP_or");
8199 printf ("DW_OP_plus");
8201 case DW_OP_plus_uconst
:
8202 printf ("DW_OP_plus_uconst: %lu",
8203 read_leb128 (data
, &bytes_read
, 0));
8207 printf ("DW_OP_shl");
8210 printf ("DW_OP_shr");
8213 printf ("DW_OP_shra");
8216 printf ("DW_OP_xor");
8219 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data
, 2));
8223 printf ("DW_OP_eq");
8226 printf ("DW_OP_ge");
8229 printf ("DW_OP_gt");
8232 printf ("DW_OP_le");
8235 printf ("DW_OP_lt");
8238 printf ("DW_OP_ne");
8241 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data
, 2));
8277 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
8312 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
8347 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
8348 read_leb128 (data
, &bytes_read
, 1));
8353 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
8357 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
8361 uvalue
= read_leb128 (data
, &bytes_read
, 0);
8363 printf ("DW_OP_bregx: %lu %ld", uvalue
,
8364 read_leb128 (data
, &bytes_read
, 1));
8368 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
8371 case DW_OP_deref_size
:
8372 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
8374 case DW_OP_xderef_size
:
8375 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
8378 printf ("DW_OP_nop");
8381 /* DWARF 3 extensions. */
8382 case DW_OP_push_object_address
:
8383 printf ("DW_OP_push_object_address");
8386 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2));
8390 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4));
8393 case DW_OP_call_ref
:
8394 printf ("DW_OP_call_ref");
8397 /* GNU extensions. */
8398 case DW_OP_GNU_push_tls_address
:
8399 printf ("DW_OP_GNU_push_tls_address");
8403 if (op
>= DW_OP_lo_user
8404 && op
<= DW_OP_hi_user
)
8405 printf (_("(User defined location op)"));
8407 printf (_("(Unknown location op)"));
8408 /* No way to tell where the next op is, so just bail. */
8412 /* Separate the ops. */
8418 static const char *debug_loc_contents
;
8419 static bfd_vma debug_loc_size
;
8422 load_debug_loc (FILE *file
)
8424 Elf_Internal_Shdr
*sec
;
8426 /* If it is already loaded, do nothing. */
8427 if (debug_loc_contents
!= NULL
)
8430 /* Locate the .debug_loc section. */
8431 sec
= find_section (".debug_loc");
8435 debug_loc_size
= sec
->sh_size
;
8437 debug_loc_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8438 _("debug_loc section data"));
8442 free_debug_loc (void)
8444 if (debug_loc_contents
== NULL
)
8447 free ((char *) debug_loc_contents
);
8448 debug_loc_contents
= NULL
;
8454 display_debug_loc (Elf_Internal_Shdr
*section
,
8455 unsigned char *start
, FILE *file
)
8457 unsigned char *section_end
;
8458 unsigned long bytes
;
8459 unsigned char *section_begin
= start
;
8461 unsigned int comp_unit
= 0;
8463 addr
= section
->sh_addr
;
8464 bytes
= section
->sh_size
;
8465 section_end
= start
+ bytes
;
8469 printf (_("\nThe .debug_loc section is empty.\n"));
8473 get_debug_info (file
);
8475 printf (_("Contents of the .debug_loc section:\n\n"));
8476 printf (_("\n Offset Begin End Expression\n"));
8478 while (start
< section_end
)
8480 unsigned long begin
;
8482 unsigned short length
;
8483 unsigned long offset
;
8484 unsigned int pointer_size
;
8486 offset
= start
- section_begin
;
8488 /* Get the pointer size from the comp unit associated
8489 with this block of location information. */
8490 pointer_size
= get_pointer_size_of_comp_unit (comp_unit
);
8491 if (pointer_size
== 0)
8493 error (_("Not enough comp units for .debug_loc section\n"));
8500 begin
= byte_get (start
, pointer_size
);
8501 start
+= pointer_size
;
8502 end
= byte_get (start
, pointer_size
);
8503 start
+= pointer_size
;
8505 if (begin
== 0 && end
== 0)
8508 /* For now, skip any base address specifiers. */
8509 if (begin
== 0xffffffff)
8515 length
= byte_get (start
, 2);
8518 printf (" %8.8lx %8.8lx %8.8lx (", offset
, begin
, end
);
8519 decode_location_expression (start
, pointer_size
, length
);
8529 static const char *debug_str_contents
;
8530 static bfd_vma debug_str_size
;
8533 load_debug_str (FILE *file
)
8535 Elf_Internal_Shdr
*sec
;
8537 /* If it is already loaded, do nothing. */
8538 if (debug_str_contents
!= NULL
)
8541 /* Locate the .debug_str section. */
8542 sec
= find_section (".debug_str");
8546 debug_str_size
= sec
->sh_size
;
8548 debug_str_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8549 _("debug_str section data"));
8553 free_debug_str (void)
8555 if (debug_str_contents
== NULL
)
8558 free ((char *) debug_str_contents
);
8559 debug_str_contents
= NULL
;
8564 fetch_indirect_string (unsigned long offset
)
8566 if (debug_str_contents
== NULL
)
8567 return _("<no .debug_str section>");
8569 if (offset
> debug_str_size
)
8570 return _("<offset is too big>");
8572 return debug_str_contents
+ offset
;
8576 display_debug_str (Elf_Internal_Shdr
*section
,
8577 unsigned char *start
,
8578 FILE *file ATTRIBUTE_UNUSED
)
8580 unsigned long bytes
;
8583 addr
= section
->sh_addr
;
8584 bytes
= section
->sh_size
;
8588 printf (_("\nThe .debug_str section is empty.\n"));
8592 printf (_("Contents of the .debug_str section:\n\n"));
8600 lbytes
= (bytes
> 16 ? 16 : bytes
);
8602 printf (" 0x%8.8lx ", (unsigned long) addr
);
8604 for (j
= 0; j
< 16; j
++)
8607 printf ("%2.2x", start
[j
]);
8615 for (j
= 0; j
< lbytes
; j
++)
8618 if (k
>= ' ' && k
< 0x80)
8634 static const char * debug_range_contents
;
8635 static unsigned long debug_range_size
;
8638 load_debug_range (FILE *file
)
8640 Elf_Internal_Shdr
*sec
;
8642 /* If it is already loaded, do nothing. */
8643 if (debug_range_contents
!= NULL
)
8646 /* Locate the .debug_str section. */
8647 sec
= find_section (".debug_ranges");
8651 debug_range_size
= sec
->sh_size
;
8653 debug_range_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8654 _("debug_range section data"));
8658 free_debug_range (void)
8660 if (debug_range_contents
== NULL
)
8663 free ((char *) debug_range_contents
);
8664 debug_range_contents
= NULL
;
8665 debug_range_size
= 0;
8669 /* Decode a DW_AT_ranges attribute for 64bit DWARF3 . */
8672 decode_64bit_range (unsigned long offset
, bfd_vma base_address
)
8674 const char * start
= debug_range_contents
+ offset
;
8675 const char * end
= debug_range_contents
+ debug_range_size
;
8682 a
= byte_get ((unsigned char *) start
, 8);
8683 b
= byte_get ((unsigned char *) start
+ 8, 8);
8685 if (a
== 0xffffffff)
8689 else if (a
== 0 && b
== 0)
8692 printf (_(" [corrupt: start > end]"));
8696 print_vma (base_address
+ a
, PREFIX_HEX
);
8698 print_vma (base_address
+ b
, PREFIX_HEX
);
8704 while (start
< end
);
8707 /* Decode a DW_AT_ranges attribute. */
8710 decode_range (unsigned long offset
, bfd_vma base_address
)
8715 if (offset
>= (debug_range_size
- 8))
8717 printf (_("[corrupt: offset is outside the .debug_ranges section]"));
8721 /* Since all entries in the .debug_ranges section are pairs of either
8722 4-byte integers (32-bit DWARF3) or 8-byte integers (64-bit DWARF3)
8723 the offset should always be a multiple of 8 bytes. */
8726 printf (_("[corrupt: offset is not a multiple of 8]"));
8730 start
= debug_range_contents
+ offset
;
8733 /* Be paranoid - check to see if the previous
8734 two words were and end-of-range marker. */
8735 && (byte_get ((unsigned char *) start
- 4, 4) != 0
8736 || byte_get ((unsigned char *) start
- 8, 4) != 0))
8738 printf (_("[corrupt: offset is not at the start of a range]"));
8742 end
= debug_range_contents
+ debug_range_size
;
8750 a
= byte_get ((unsigned char *) start
, 4);
8751 b
= byte_get ((unsigned char *) start
+ 4, 4);
8753 if (a
== 0xffffffff)
8755 if (b
== 0xffffffff)
8757 decode_64bit_range (offset
, base_address
);
8763 else if (a
== 0 && b
== 0)
8766 printf (_("[corrupt: start > end]"));
8769 if (start
> debug_range_contents
+ offset
)
8772 printf (_("0x%lx - 0x%lx"),
8773 (unsigned long) base_address
+ a
,
8774 (unsigned long) base_address
+ b
);
8779 while (start
< end
);
8784 static unsigned char *
8785 read_and_display_attr_value (unsigned long attribute
,
8787 unsigned char *data
,
8788 unsigned long cu_offset
,
8789 unsigned long pointer_size
,
8790 unsigned long offset_size
,
8793 static unsigned long saved_DW_AT_low_pc
= 0;
8794 unsigned long uvalue
= 0;
8795 unsigned char *block_start
= NULL
;
8803 case DW_FORM_ref_addr
:
8804 if (dwarf_version
== 2)
8806 uvalue
= byte_get (data
, pointer_size
);
8807 data
+= pointer_size
;
8809 else if (dwarf_version
== 3)
8811 uvalue
= byte_get (data
, offset_size
);
8812 data
+= offset_size
;
8816 error (_("Internal error: DWARF version is not 2 or 3.\n"));
8821 uvalue
= byte_get (data
, pointer_size
);
8822 data
+= pointer_size
;
8826 uvalue
= byte_get (data
, offset_size
);
8827 data
+= offset_size
;
8833 uvalue
= byte_get (data
++, 1);
8838 uvalue
= byte_get (data
, 2);
8844 uvalue
= byte_get (data
, 4);
8849 uvalue
= read_leb128 (data
, & bytes_read
, 1);
8853 case DW_FORM_ref_udata
:
8855 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8859 case DW_FORM_indirect
:
8860 form
= read_leb128 (data
, & bytes_read
, 0);
8862 printf (" %s", get_FORM_name (form
));
8863 return read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
8864 pointer_size
, offset_size
,
8870 case DW_FORM_ref_addr
:
8871 printf (" <#%lx>", uvalue
);
8877 case DW_FORM_ref_udata
:
8878 printf (" <%lx>", uvalue
+ cu_offset
);
8882 printf (" %#lx", uvalue
);
8891 printf (" %ld", uvalue
);
8896 uvalue
= byte_get (data
, 4);
8897 printf (" %lx", uvalue
);
8898 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
8902 case DW_FORM_string
:
8903 printf (" %s", data
);
8904 data
+= strlen ((char *) data
) + 1;
8908 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8909 block_start
= data
+ bytes_read
;
8910 data
= display_block (block_start
, uvalue
);
8913 case DW_FORM_block1
:
8914 uvalue
= byte_get (data
, 1);
8915 block_start
= data
+ 1;
8916 data
= display_block (block_start
, uvalue
);
8919 case DW_FORM_block2
:
8920 uvalue
= byte_get (data
, 2);
8921 block_start
= data
+ 2;
8922 data
= display_block (block_start
, uvalue
);
8925 case DW_FORM_block4
:
8926 uvalue
= byte_get (data
, 4);
8927 block_start
= data
+ 4;
8928 data
= display_block (block_start
, uvalue
);
8932 printf (_(" (indirect string, offset: 0x%lx): %s"),
8933 uvalue
, fetch_indirect_string (uvalue
));
8936 case DW_FORM_indirect
:
8937 /* Handled above. */
8941 warn (_("Unrecognized form: %d\n"), form
);
8945 /* For some attributes we can display further information. */
8954 case DW_INL_not_inlined
:
8955 printf (_("(not inlined)"));
8957 case DW_INL_inlined
:
8958 printf (_("(inlined)"));
8960 case DW_INL_declared_not_inlined
:
8961 printf (_("(declared as inline but ignored)"));
8963 case DW_INL_declared_inlined
:
8964 printf (_("(declared as inline and inlined)"));
8967 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
8972 case DW_AT_language
:
8975 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
8976 case DW_LANG_C89
: printf ("(ANSI C)"); break;
8977 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
8978 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
8979 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
8980 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
8981 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
8982 case DW_LANG_Ada83
: printf ("(Ada)"); break;
8983 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
8984 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
8985 /* DWARF 2.1 values. */
8986 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
8987 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
8988 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
8989 /* MIPS extension. */
8990 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
8991 /* UPC extension. */
8992 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
8994 printf ("(Unknown: %lx)", uvalue
);
8999 case DW_AT_encoding
:
9002 case DW_ATE_void
: printf ("(void)"); break;
9003 case DW_ATE_address
: printf ("(machine address)"); break;
9004 case DW_ATE_boolean
: printf ("(boolean)"); break;
9005 case DW_ATE_complex_float
: printf ("(complex float)"); break;
9006 case DW_ATE_float
: printf ("(float)"); break;
9007 case DW_ATE_signed
: printf ("(signed)"); break;
9008 case DW_ATE_signed_char
: printf ("(signed char)"); break;
9009 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
9010 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
9011 /* DWARF 2.1 value. */
9012 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
9014 if (uvalue
>= DW_ATE_lo_user
9015 && uvalue
<= DW_ATE_hi_user
)
9016 printf ("(user defined type)");
9018 printf ("(unknown type)");
9023 case DW_AT_accessibility
:
9026 case DW_ACCESS_public
: printf ("(public)"); break;
9027 case DW_ACCESS_protected
: printf ("(protected)"); break;
9028 case DW_ACCESS_private
: printf ("(private)"); break;
9030 printf ("(unknown accessibility)");
9035 case DW_AT_visibility
:
9038 case DW_VIS_local
: printf ("(local)"); break;
9039 case DW_VIS_exported
: printf ("(exported)"); break;
9040 case DW_VIS_qualified
: printf ("(qualified)"); break;
9041 default: printf ("(unknown visibility)"); break;
9045 case DW_AT_virtuality
:
9048 case DW_VIRTUALITY_none
: printf ("(none)"); break;
9049 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
9050 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
9051 default: printf ("(unknown virtuality)"); break;
9055 case DW_AT_identifier_case
:
9058 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
9059 case DW_ID_up_case
: printf ("(up_case)"); break;
9060 case DW_ID_down_case
: printf ("(down_case)"); break;
9061 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
9062 default: printf ("(unknown case)"); break;
9066 case DW_AT_calling_convention
:
9069 case DW_CC_normal
: printf ("(normal)"); break;
9070 case DW_CC_program
: printf ("(program)"); break;
9071 case DW_CC_nocall
: printf ("(nocall)"); break;
9073 if (uvalue
>= DW_CC_lo_user
9074 && uvalue
<= DW_CC_hi_user
)
9075 printf ("(user defined)");
9077 printf ("(unknown convention)");
9081 case DW_AT_ordering
:
9084 case -1: printf ("(undefined)"); break;
9085 case 0: printf ("(row major)"); break;
9086 case 1: printf ("(column major)"); break;
9090 case DW_AT_frame_base
:
9091 case DW_AT_location
:
9092 case DW_AT_data_member_location
:
9093 case DW_AT_vtable_elem_location
:
9094 case DW_AT_allocated
:
9095 case DW_AT_associated
:
9096 case DW_AT_data_location
:
9098 case DW_AT_upper_bound
:
9099 case DW_AT_lower_bound
:
9103 decode_location_expression (block_start
, pointer_size
, uvalue
);
9106 else if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
9107 printf (_("(location list)"));
9112 /* This is a hack. We keep track of the DW_AT_low_pc attributes
9113 and use them when decoding DW_AT_ranges attributes. The
9114 assumption here is that we are decoding the attributes in order
9115 and so the correct base address for the range is the low_pc. */
9116 saved_DW_AT_low_pc
= uvalue
;
9120 decode_range (uvalue
, saved_DW_AT_low_pc
);
9130 static unsigned char *
9131 read_and_display_attr (unsigned long attribute
,
9133 unsigned char *data
,
9134 unsigned long cu_offset
,
9135 unsigned long pointer_size
,
9136 unsigned long offset_size
,
9139 printf (" %-18s:", get_AT_name (attribute
));
9140 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
9141 pointer_size
, offset_size
, dwarf_version
);
9146 /* Apply addends of RELA relocations. */
9149 debug_apply_rela_addends (FILE *file
,
9150 Elf_Internal_Shdr
*section
,
9152 unsigned char *sec_data
,
9153 unsigned char *start
,
9156 Elf_Internal_Shdr
*relsec
;
9158 if (end
- start
< reloc_size
)
9161 for (relsec
= section_headers
;
9162 relsec
< section_headers
+ elf_header
.e_shnum
;
9165 unsigned long nrelas
;
9166 Elf_Internal_Rela
*rela
, *rp
;
9167 Elf_Internal_Shdr
*symsec
;
9168 Elf_Internal_Sym
*symtab
;
9169 Elf_Internal_Sym
*sym
;
9171 if (relsec
->sh_type
!= SHT_RELA
9172 || SECTION_HEADER (relsec
->sh_info
) != section
9173 || relsec
->sh_size
== 0)
9176 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
9180 symsec
= SECTION_HEADER (relsec
->sh_link
);
9181 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
9183 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
9187 if (rp
->r_offset
>= (bfd_vma
) (start
- sec_data
)
9188 && rp
->r_offset
< (bfd_vma
) (end
- sec_data
) - reloc_size
)
9189 loc
= sec_data
+ rp
->r_offset
;
9195 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
9197 if (ELF32_R_SYM (rp
->r_info
) != 0
9198 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
9199 /* Relocations against object symbols can happen,
9200 eg when referencing a global array. For an
9201 example of this see the _clz.o binary in libgcc.a. */
9202 && ELF32_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
9204 warn (_("%s: skipping unexpected symbol type %s in relocation in section .rela%s\n"),
9205 get_symbol_type (ELF32_ST_TYPE (sym
->st_info
)),
9206 SECTION_NAME (section
));
9212 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
9214 if (ELF64_R_SYM (rp
->r_info
) != 0
9215 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
9216 && ELF64_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
9218 warn (_("skipping unexpected symbol type %s in relocation in section .rela.%s\n"),
9219 get_symbol_type (ELF64_ST_TYPE (sym
->st_info
)),
9220 SECTION_NAME (section
));
9225 byte_put (loc
, rp
->r_addend
, reloc_size
);
9236 display_debug_info (Elf_Internal_Shdr
*section
,
9237 unsigned char *start
,
9240 unsigned char *end
= start
+ section
->sh_size
;
9241 unsigned char *section_begin
= start
;
9243 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
9245 load_debug_str (file
);
9246 load_debug_loc (file
);
9247 load_debug_range (file
);
9251 DWARF2_Internal_CompUnit compunit
;
9252 unsigned char *hdrptr
;
9253 unsigned char *cu_abbrev_offset_ptr
;
9254 unsigned char *tags
;
9256 unsigned long cu_offset
;
9258 int initial_length_size
;
9262 compunit
.cu_length
= byte_get (hdrptr
, 4);
9265 if (compunit
.cu_length
== 0xffffffff)
9267 compunit
.cu_length
= byte_get (hdrptr
, 8);
9270 initial_length_size
= 12;
9275 initial_length_size
= 4;
9278 compunit
.cu_version
= byte_get (hdrptr
, 2);
9281 cu_offset
= start
- section_begin
;
9282 start
+= compunit
.cu_length
+ initial_length_size
;
9284 if (elf_header
.e_type
== ET_REL
9285 && !debug_apply_rela_addends (file
, section
, offset_size
,
9286 section_begin
, hdrptr
, start
))
9289 cu_abbrev_offset_ptr
= hdrptr
;
9290 compunit
.cu_abbrev_offset
= byte_get (hdrptr
, offset_size
);
9291 hdrptr
+= offset_size
;
9293 compunit
.cu_pointer_size
= byte_get (hdrptr
, 1);
9298 printf (_(" Compilation Unit @ %lx:\n"), cu_offset
);
9299 printf (_(" Length: %ld\n"), compunit
.cu_length
);
9300 printf (_(" Version: %d\n"), compunit
.cu_version
);
9301 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
9302 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
9304 if (compunit
.cu_version
!= 2 && compunit
.cu_version
!= 3)
9306 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
9312 /* Read in the abbrevs used by this compilation unit. */
9314 Elf_Internal_Shdr
*sec
;
9315 unsigned char *begin
;
9317 /* Locate the .debug_abbrev section and process it. */
9318 sec
= find_section (".debug_abbrev");
9321 warn (_("Unable to locate .debug_abbrev section!\n"));
9325 begin
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
9326 _("debug_abbrev section data"));
9330 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
9331 begin
+ sec
->sh_size
);
9337 while (tags
< start
)
9340 unsigned long abbrev_number
;
9341 abbrev_entry
*entry
;
9344 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
9347 /* A null DIE marks the end of a list of children. */
9348 if (abbrev_number
== 0)
9354 /* Scan through the abbreviation list until we reach the
9356 for (entry
= first_abbrev
;
9357 entry
&& entry
->entry
!= abbrev_number
;
9358 entry
= entry
->next
)
9363 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
9368 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
9370 (unsigned long) (tags
- section_begin
- bytes_read
),
9372 get_TAG_name (entry
->tag
));
9374 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
9375 tags
= read_and_display_attr (attr
->attribute
,
9378 compunit
.cu_pointer_size
,
9380 compunit
.cu_version
);
9382 if (entry
->children
)
9387 free_debug_range ();
9397 display_debug_aranges (Elf_Internal_Shdr
*section
,
9398 unsigned char *start
,
9399 FILE *file ATTRIBUTE_UNUSED
)
9401 unsigned char *end
= start
+ section
->sh_size
;
9403 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
9407 unsigned char *hdrptr
;
9408 DWARF2_Internal_ARange arange
;
9409 unsigned char *ranges
;
9410 unsigned long length
;
9411 unsigned long address
;
9414 int initial_length_size
;
9418 arange
.ar_length
= byte_get (hdrptr
, 4);
9421 if (arange
.ar_length
== 0xffffffff)
9423 arange
.ar_length
= byte_get (hdrptr
, 8);
9426 initial_length_size
= 12;
9431 initial_length_size
= 4;
9434 arange
.ar_version
= byte_get (hdrptr
, 2);
9437 arange
.ar_info_offset
= byte_get (hdrptr
, offset_size
);
9438 hdrptr
+= offset_size
;
9440 arange
.ar_pointer_size
= byte_get (hdrptr
, 1);
9443 arange
.ar_segment_size
= byte_get (hdrptr
, 1);
9446 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
9448 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
9452 printf (_(" Length: %ld\n"), arange
.ar_length
);
9453 printf (_(" Version: %d\n"), arange
.ar_version
);
9454 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
9455 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
9456 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
9458 printf (_("\n Address Length\n"));
9462 /* Must pad to an alignment boundary that is twice the pointer size. */
9463 excess
= (hdrptr
- start
) % (2 * arange
.ar_pointer_size
);
9465 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
9469 address
= byte_get (ranges
, arange
.ar_pointer_size
);
9471 ranges
+= arange
.ar_pointer_size
;
9473 length
= byte_get (ranges
, arange
.ar_pointer_size
);
9475 ranges
+= arange
.ar_pointer_size
;
9477 /* A pair of zeros marks the end of the list. */
9478 if (address
== 0 && length
== 0)
9481 printf (" %8.8lx %lu\n", address
, length
);
9484 start
+= arange
.ar_length
+ initial_length_size
;
9493 display_64bit_debug_ranges (unsigned char * start
, unsigned char * end
)
9495 bfd_vma base_address
= 0;
9501 a
= byte_get (start
, 8);
9502 b
= byte_get (start
+ 8, 8);
9504 if (a
== 0xffffffffffffffffLL
)
9506 printf (_(" set base address to "));
9507 print_vma (b
, PREFIX_HEX
);
9510 else if (a
== 0 && b
== 0)
9511 printf ( _("end of range"));
9513 printf (_(" <corrupt range entry, start is greater than end>"));
9514 else if (base_address
== 0)
9516 printf ("range from base address + ");
9517 print_vma (a
, PREFIX_HEX
);
9518 printf (" to base address + ");
9519 print_vma (b
, PREFIX_HEX
);
9523 printf ("range from ");
9524 print_vma (base_address
+ a
, PREFIX_HEX
);
9526 print_vma (base_address
+ b
, PREFIX_HEX
);
9537 display_debug_ranges (Elf_Internal_Shdr
*section
,
9538 unsigned char *start
,
9539 FILE *file ATTRIBUTE_UNUSED
)
9541 unsigned long base_address
= 0;
9542 unsigned char *end
= start
+ section
->sh_size
;
9544 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
9551 a
= byte_get (start
, 4);
9552 b
= byte_get (start
+ 4, 4);
9554 if (a
== 0xffffffff)
9556 /* Attempt to handle 64-bit DWARF3 format. This assumes
9557 that in a 32-bit DWARF3 file the base address will
9558 never be 0xffffffff, and that the .debug_ranges section
9559 will never contain a mixture of 32-bit and 64-bit entries. */
9560 if (b
== 0xffffffff)
9561 return display_64bit_debug_ranges (start
, end
);
9563 printf (_(" set base address to 0x%lx\n"), b
);
9566 else if (a
== 0 && b
== 0)
9567 printf (_(" end of range\n"));
9569 printf (_(" <corrupt range entry, start is greater than end>\n"));
9570 else if (base_address
== 0)
9571 printf (_(" range from base address + 0x%lx to base address + 0x%lx\n"), a
, b
);
9573 printf (_(" range from 0x%lx to 0x%lx\n"), base_address
+ a
, base_address
+ b
);
9581 typedef struct Frame_Chunk
9583 struct Frame_Chunk
*next
;
9584 unsigned char *chunk_start
;
9586 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
9587 short int *col_type
;
9590 unsigned int code_factor
;
9592 unsigned long pc_begin
;
9593 unsigned long pc_range
;
9597 unsigned char fde_encoding
;
9598 unsigned char cfa_exp
;
9602 /* A marker for a col_type that means this column was never referenced
9603 in the frame info. */
9604 #define DW_CFA_unreferenced (-1)
9607 frame_need_space (Frame_Chunk
*fc
, int reg
)
9609 int prev
= fc
->ncols
;
9611 if (reg
< fc
->ncols
)
9614 fc
->ncols
= reg
+ 1;
9615 fc
->col_type
= xrealloc (fc
->col_type
, fc
->ncols
* sizeof (short int));
9616 fc
->col_offset
= xrealloc (fc
->col_offset
, fc
->ncols
* sizeof (int));
9618 while (prev
< fc
->ncols
)
9620 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
9621 fc
->col_offset
[prev
] = 0;
9627 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
9632 if (*max_regs
< fc
->ncols
)
9633 *max_regs
= fc
->ncols
;
9635 if (*need_col_headers
)
9637 *need_col_headers
= 0;
9639 printf (" LOC CFA ");
9641 for (r
= 0; r
< *max_regs
; r
++)
9642 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
9647 printf ("r%-4d", r
);
9653 printf ("%08lx ", fc
->pc_begin
);
9655 strcpy (tmp
, "exp");
9657 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
9658 printf ("%-8s ", tmp
);
9660 for (r
= 0; r
< fc
->ncols
; r
++)
9662 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
9664 switch (fc
->col_type
[r
])
9666 case DW_CFA_undefined
:
9669 case DW_CFA_same_value
:
9673 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
9675 case DW_CFA_register
:
9676 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
9678 case DW_CFA_expression
:
9679 strcpy (tmp
, "exp");
9682 strcpy (tmp
, "n/a");
9685 printf ("%-5s", tmp
);
9692 size_of_encoded_value (int encoding
)
9694 switch (encoding
& 0x7)
9697 case 0: return is_32bit_elf
? 4 : 8;
9705 get_encoded_value (unsigned char *data
, int encoding
)
9707 int size
= size_of_encoded_value (encoding
);
9708 if (encoding
& DW_EH_PE_signed
)
9709 return byte_get_signed (data
, size
);
9711 return byte_get (data
, size
);
9714 #define GET(N) byte_get (start, N); start += N
9715 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
9716 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
9719 display_debug_frames (Elf_Internal_Shdr
*section
,
9720 unsigned char *start
,
9721 FILE *file ATTRIBUTE_UNUSED
)
9723 unsigned char *end
= start
+ section
->sh_size
;
9724 unsigned char *section_start
= start
;
9725 Frame_Chunk
*chunks
= 0;
9726 Frame_Chunk
*remembered_state
= 0;
9728 int is_eh
= streq (SECTION_NAME (section
), ".eh_frame");
9731 int addr_size
= is_32bit_elf
? 4 : 8;
9733 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
9737 unsigned char *saved_start
;
9738 unsigned char *block_end
;
9739 unsigned long length
;
9740 unsigned long cie_id
;
9743 int need_col_headers
= 1;
9744 unsigned char *augmentation_data
= NULL
;
9745 unsigned long augmentation_data_len
= 0;
9746 int encoded_ptr_size
= addr_size
;
9748 int initial_length_size
;
9750 saved_start
= start
;
9751 length
= byte_get (start
, 4); start
+= 4;
9755 printf ("\n%08lx ZERO terminator\n\n",
9756 (unsigned long)(saved_start
- section_start
));
9760 if (length
== 0xffffffff)
9762 length
= byte_get (start
, 8);
9765 initial_length_size
= 12;
9770 initial_length_size
= 4;
9773 block_end
= saved_start
+ length
+ initial_length_size
;
9774 cie_id
= byte_get (start
, offset_size
); start
+= offset_size
;
9776 if (elf_header
.e_type
== ET_REL
9777 && !debug_apply_rela_addends (file
, section
, offset_size
,
9778 section_start
, start
, block_end
))
9781 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
9785 fc
= xmalloc (sizeof (Frame_Chunk
));
9786 memset (fc
, 0, sizeof (Frame_Chunk
));
9790 fc
->chunk_start
= saved_start
;
9792 fc
->col_type
= xmalloc (sizeof (short int));
9793 fc
->col_offset
= xmalloc (sizeof (int));
9794 frame_need_space (fc
, max_regs
-1);
9798 fc
->augmentation
= start
;
9799 start
= strchr (start
, '\0') + 1;
9801 if (fc
->augmentation
[0] == 'z')
9803 fc
->code_factor
= LEB ();
9804 fc
->data_factor
= SLEB ();
9813 augmentation_data_len
= LEB ();
9814 augmentation_data
= start
;
9815 start
+= augmentation_data_len
;
9817 else if (streq (fc
->augmentation
, "eh"))
9820 fc
->code_factor
= LEB ();
9821 fc
->data_factor
= SLEB ();
9833 fc
->code_factor
= LEB ();
9834 fc
->data_factor
= SLEB ();
9846 if (do_debug_frames_interp
)
9847 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
9848 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
9849 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
9853 printf ("\n%08lx %08lx %08lx CIE\n",
9854 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
9855 printf (" Version: %d\n", version
);
9856 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
9857 printf (" Code alignment factor: %u\n", fc
->code_factor
);
9858 printf (" Data alignment factor: %d\n", fc
->data_factor
);
9859 printf (" Return address column: %d\n", fc
->ra
);
9861 if (augmentation_data_len
)
9864 printf (" Augmentation data: ");
9865 for (i
= 0; i
< augmentation_data_len
; ++i
)
9866 printf (" %02x", augmentation_data
[i
]);
9872 if (augmentation_data_len
)
9874 unsigned char *p
, *q
;
9875 p
= fc
->augmentation
+ 1;
9876 q
= augmentation_data
;
9883 q
+= 1 + size_of_encoded_value (*q
);
9885 fc
->fde_encoding
= *q
++;
9891 if (fc
->fde_encoding
)
9892 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
9895 frame_need_space (fc
, fc
->ra
);
9899 unsigned char *look_for
;
9900 static Frame_Chunk fde_fc
;
9903 memset (fc
, 0, sizeof (Frame_Chunk
));
9905 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
9907 for (cie
= chunks
; cie
; cie
= cie
->next
)
9908 if (cie
->chunk_start
== look_for
)
9913 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
9914 cie_id
, saved_start
);
9917 fc
->col_type
= xmalloc (sizeof (short int));
9918 fc
->col_offset
= xmalloc (sizeof (int));
9919 frame_need_space (fc
, max_regs
- 1);
9921 fc
->augmentation
= "";
9922 fc
->fde_encoding
= 0;
9926 fc
->ncols
= cie
->ncols
;
9927 fc
->col_type
= xmalloc (fc
->ncols
* sizeof (short int));
9928 fc
->col_offset
= xmalloc (fc
->ncols
* sizeof (int));
9929 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
9930 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
9931 fc
->augmentation
= cie
->augmentation
;
9932 fc
->code_factor
= cie
->code_factor
;
9933 fc
->data_factor
= cie
->data_factor
;
9934 fc
->cfa_reg
= cie
->cfa_reg
;
9935 fc
->cfa_offset
= cie
->cfa_offset
;
9937 frame_need_space (fc
, max_regs
-1);
9938 fc
->fde_encoding
= cie
->fde_encoding
;
9941 if (fc
->fde_encoding
)
9942 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
9944 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
);
9945 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
9946 /* Don't adjust for ET_REL since there's invariably a pcrel
9947 reloc here, which we haven't applied. */
9948 && elf_header
.e_type
!= ET_REL
)
9949 fc
->pc_begin
+= section
->sh_addr
+ (start
- section_start
);
9950 start
+= encoded_ptr_size
;
9951 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
9952 start
+= encoded_ptr_size
;
9954 if (cie
->augmentation
[0] == 'z')
9956 augmentation_data_len
= LEB ();
9957 augmentation_data
= start
;
9958 start
+= augmentation_data_len
;
9961 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
9962 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
9963 (unsigned long)(cie
->chunk_start
- section_start
),
9964 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
9965 if (! do_debug_frames_interp
&& augmentation_data_len
)
9968 printf (" Augmentation data: ");
9969 for (i
= 0; i
< augmentation_data_len
; ++i
)
9970 printf (" %02x", augmentation_data
[i
]);
9976 /* At this point, fc is the current chunk, cie (if any) is set, and
9977 we're about to interpret instructions for the chunk. */
9978 /* ??? At present we need to do this always, since this sizes the
9979 fc->col_type and fc->col_offset arrays, which we write into always.
9980 We should probably split the interpreted and non-interpreted bits
9981 into two different routines, since there's so much that doesn't
9982 really overlap between them. */
9983 if (1 || do_debug_frames_interp
)
9985 /* Start by making a pass over the chunk, allocating storage
9986 and taking note of what registers are used. */
9987 unsigned char *tmp
= start
;
9989 while (start
< block_end
)
9992 unsigned long reg
, tmp
;
9999 /* Warning: if you add any more cases to this switch, be
10000 sure to add them to the corresponding switch below. */
10003 case DW_CFA_advance_loc
:
10005 case DW_CFA_offset
:
10007 frame_need_space (fc
, opa
);
10008 fc
->col_type
[opa
] = DW_CFA_undefined
;
10010 case DW_CFA_restore
:
10011 frame_need_space (fc
, opa
);
10012 fc
->col_type
[opa
] = DW_CFA_undefined
;
10014 case DW_CFA_set_loc
:
10015 start
+= encoded_ptr_size
;
10017 case DW_CFA_advance_loc1
:
10020 case DW_CFA_advance_loc2
:
10023 case DW_CFA_advance_loc4
:
10026 case DW_CFA_offset_extended
:
10027 reg
= LEB (); LEB ();
10028 frame_need_space (fc
, reg
);
10029 fc
->col_type
[reg
] = DW_CFA_undefined
;
10031 case DW_CFA_restore_extended
:
10033 frame_need_space (fc
, reg
);
10034 fc
->col_type
[reg
] = DW_CFA_undefined
;
10036 case DW_CFA_undefined
:
10038 frame_need_space (fc
, reg
);
10039 fc
->col_type
[reg
] = DW_CFA_undefined
;
10041 case DW_CFA_same_value
:
10043 frame_need_space (fc
, reg
);
10044 fc
->col_type
[reg
] = DW_CFA_undefined
;
10046 case DW_CFA_register
:
10047 reg
= LEB (); LEB ();
10048 frame_need_space (fc
, reg
);
10049 fc
->col_type
[reg
] = DW_CFA_undefined
;
10051 case DW_CFA_def_cfa
:
10054 case DW_CFA_def_cfa_register
:
10057 case DW_CFA_def_cfa_offset
:
10060 case DW_CFA_def_cfa_expression
:
10064 case DW_CFA_expression
:
10068 frame_need_space (fc
, reg
);
10069 fc
->col_type
[reg
] = DW_CFA_undefined
;
10071 case DW_CFA_offset_extended_sf
:
10072 reg
= LEB (); SLEB ();
10073 frame_need_space (fc
, reg
);
10074 fc
->col_type
[reg
] = DW_CFA_undefined
;
10076 case DW_CFA_def_cfa_sf
:
10079 case DW_CFA_def_cfa_offset_sf
:
10082 case DW_CFA_MIPS_advance_loc8
:
10085 case DW_CFA_GNU_args_size
:
10088 case DW_CFA_GNU_negative_offset_extended
:
10089 reg
= LEB (); LEB ();
10090 frame_need_space (fc
, reg
);
10091 fc
->col_type
[reg
] = DW_CFA_undefined
;
10100 /* Now we know what registers are used, make a second pass over
10101 the chunk, this time actually printing out the info. */
10103 while (start
< block_end
)
10106 unsigned long ul
, reg
, roffs
;
10115 /* Warning: if you add any more cases to this switch, be
10116 sure to add them to the corresponding switch above. */
10119 case DW_CFA_advance_loc
:
10120 if (do_debug_frames_interp
)
10121 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10123 printf (" DW_CFA_advance_loc: %d to %08lx\n",
10124 opa
* fc
->code_factor
,
10125 fc
->pc_begin
+ opa
* fc
->code_factor
);
10126 fc
->pc_begin
+= opa
* fc
->code_factor
;
10129 case DW_CFA_offset
:
10131 if (! do_debug_frames_interp
)
10132 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
10133 opa
, roffs
* fc
->data_factor
);
10134 fc
->col_type
[opa
] = DW_CFA_offset
;
10135 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
10138 case DW_CFA_restore
:
10139 if (! do_debug_frames_interp
)
10140 printf (" DW_CFA_restore: r%d\n", opa
);
10141 fc
->col_type
[opa
] = cie
->col_type
[opa
];
10142 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
10145 case DW_CFA_set_loc
:
10146 vma
= get_encoded_value (start
, fc
->fde_encoding
);
10147 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10148 && elf_header
.e_type
!= ET_REL
)
10149 vma
+= section
->sh_addr
+ (start
- section_start
);
10150 start
+= encoded_ptr_size
;
10151 if (do_debug_frames_interp
)
10152 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10154 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
10155 fc
->pc_begin
= vma
;
10158 case DW_CFA_advance_loc1
:
10159 ofs
= byte_get (start
, 1); start
+= 1;
10160 if (do_debug_frames_interp
)
10161 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10163 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
10164 ofs
* fc
->code_factor
,
10165 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10166 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10169 case DW_CFA_advance_loc2
:
10170 ofs
= byte_get (start
, 2); start
+= 2;
10171 if (do_debug_frames_interp
)
10172 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10174 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
10175 ofs
* fc
->code_factor
,
10176 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10177 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10180 case DW_CFA_advance_loc4
:
10181 ofs
= byte_get (start
, 4); start
+= 4;
10182 if (do_debug_frames_interp
)
10183 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10185 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
10186 ofs
* fc
->code_factor
,
10187 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10188 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10191 case DW_CFA_offset_extended
:
10194 if (! do_debug_frames_interp
)
10195 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
10196 reg
, roffs
* fc
->data_factor
);
10197 fc
->col_type
[reg
] = DW_CFA_offset
;
10198 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
10201 case DW_CFA_restore_extended
:
10203 if (! do_debug_frames_interp
)
10204 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
10205 fc
->col_type
[reg
] = cie
->col_type
[reg
];
10206 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
10209 case DW_CFA_undefined
:
10211 if (! do_debug_frames_interp
)
10212 printf (" DW_CFA_undefined: r%ld\n", reg
);
10213 fc
->col_type
[reg
] = DW_CFA_undefined
;
10214 fc
->col_offset
[reg
] = 0;
10217 case DW_CFA_same_value
:
10219 if (! do_debug_frames_interp
)
10220 printf (" DW_CFA_same_value: r%ld\n", reg
);
10221 fc
->col_type
[reg
] = DW_CFA_same_value
;
10222 fc
->col_offset
[reg
] = 0;
10225 case DW_CFA_register
:
10228 if (! do_debug_frames_interp
)
10229 printf (" DW_CFA_register: r%ld in r%ld\n", reg
, roffs
);
10230 fc
->col_type
[reg
] = DW_CFA_register
;
10231 fc
->col_offset
[reg
] = roffs
;
10234 case DW_CFA_remember_state
:
10235 if (! do_debug_frames_interp
)
10236 printf (" DW_CFA_remember_state\n");
10237 rs
= xmalloc (sizeof (Frame_Chunk
));
10238 rs
->ncols
= fc
->ncols
;
10239 rs
->col_type
= xmalloc (rs
->ncols
* sizeof (short int));
10240 rs
->col_offset
= xmalloc (rs
->ncols
* sizeof (int));
10241 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
10242 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
10243 rs
->next
= remembered_state
;
10244 remembered_state
= rs
;
10247 case DW_CFA_restore_state
:
10248 if (! do_debug_frames_interp
)
10249 printf (" DW_CFA_restore_state\n");
10250 rs
= remembered_state
;
10253 remembered_state
= rs
->next
;
10254 frame_need_space (fc
, rs
->ncols
-1);
10255 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
10256 memcpy (fc
->col_offset
, rs
->col_offset
,
10257 rs
->ncols
* sizeof (int));
10258 free (rs
->col_type
);
10259 free (rs
->col_offset
);
10262 else if (do_debug_frames_interp
)
10263 printf ("Mismatched DW_CFA_restore_state\n");
10266 case DW_CFA_def_cfa
:
10267 fc
->cfa_reg
= LEB ();
10268 fc
->cfa_offset
= LEB ();
10270 if (! do_debug_frames_interp
)
10271 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
10272 fc
->cfa_reg
, fc
->cfa_offset
);
10275 case DW_CFA_def_cfa_register
:
10276 fc
->cfa_reg
= LEB ();
10278 if (! do_debug_frames_interp
)
10279 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
10282 case DW_CFA_def_cfa_offset
:
10283 fc
->cfa_offset
= LEB ();
10284 if (! do_debug_frames_interp
)
10285 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
10289 if (! do_debug_frames_interp
)
10290 printf (" DW_CFA_nop\n");
10293 case DW_CFA_def_cfa_expression
:
10295 if (! do_debug_frames_interp
)
10297 printf (" DW_CFA_def_cfa_expression (");
10298 decode_location_expression (start
, addr_size
, ul
);
10305 case DW_CFA_expression
:
10308 if (! do_debug_frames_interp
)
10310 printf (" DW_CFA_expression: r%ld (", reg
);
10311 decode_location_expression (start
, addr_size
, ul
);
10314 fc
->col_type
[reg
] = DW_CFA_expression
;
10318 case DW_CFA_offset_extended_sf
:
10321 frame_need_space (fc
, reg
);
10322 if (! do_debug_frames_interp
)
10323 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
10324 reg
, l
* fc
->data_factor
);
10325 fc
->col_type
[reg
] = DW_CFA_offset
;
10326 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
10329 case DW_CFA_def_cfa_sf
:
10330 fc
->cfa_reg
= LEB ();
10331 fc
->cfa_offset
= SLEB ();
10333 if (! do_debug_frames_interp
)
10334 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
10335 fc
->cfa_reg
, fc
->cfa_offset
);
10338 case DW_CFA_def_cfa_offset_sf
:
10339 fc
->cfa_offset
= SLEB ();
10340 if (! do_debug_frames_interp
)
10341 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
10344 case DW_CFA_MIPS_advance_loc8
:
10345 ofs
= byte_get (start
, 8); start
+= 8;
10346 if (do_debug_frames_interp
)
10347 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10349 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
10350 ofs
* fc
->code_factor
,
10351 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10352 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10355 case DW_CFA_GNU_window_save
:
10356 if (! do_debug_frames_interp
)
10357 printf (" DW_CFA_GNU_window_save\n");
10360 case DW_CFA_GNU_args_size
:
10362 if (! do_debug_frames_interp
)
10363 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
10366 case DW_CFA_GNU_negative_offset_extended
:
10369 frame_need_space (fc
, reg
);
10370 if (! do_debug_frames_interp
)
10371 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
10372 reg
, l
* fc
->data_factor
);
10373 fc
->col_type
[reg
] = DW_CFA_offset
;
10374 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
10378 warn (_("unsupported or unknown DW_CFA_%d\n"), op
);
10383 if (do_debug_frames_interp
)
10384 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10399 display_debug_not_supported (Elf_Internal_Shdr
*section
,
10400 unsigned char *start ATTRIBUTE_UNUSED
,
10401 FILE *file ATTRIBUTE_UNUSED
)
10403 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
10404 SECTION_NAME (section
));
10409 /* A structure containing the name of a debug section
10410 and a pointer to a function that can decode it. */
10413 const char *const name
;
10414 int (*display
) (Elf_Internal_Shdr
*, unsigned char *, FILE *);
10418 { ".debug_abbrev", display_debug_abbrev
},
10419 { ".debug_aranges", display_debug_aranges
},
10420 { ".debug_frame", display_debug_frames
},
10421 { ".debug_info", display_debug_info
},
10422 { ".debug_line", display_debug_lines
},
10423 { ".debug_pubnames", display_debug_pubnames
},
10424 { ".eh_frame", display_debug_frames
},
10425 { ".debug_macinfo", display_debug_macinfo
},
10426 { ".debug_str", display_debug_str
},
10427 { ".debug_loc", display_debug_loc
},
10428 { ".debug_pubtypes", display_debug_pubnames
},
10429 { ".debug_ranges", display_debug_ranges
},
10430 { ".debug_static_func", display_debug_not_supported
},
10431 { ".debug_static_vars", display_debug_not_supported
},
10432 { ".debug_types", display_debug_not_supported
},
10433 { ".debug_weaknames", display_debug_not_supported
}
10437 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
10439 char *name
= SECTION_NAME (section
);
10440 bfd_size_type length
;
10444 length
= section
->sh_size
;
10447 printf (_("\nSection '%s' has no debugging data.\n"), name
);
10451 if (strneq (name
, ".gnu.linkonce.wi.", 17))
10452 name
= ".debug_info";
10454 /* See if we know how to display the contents of this section. */
10455 for (i
= NUM_ELEM (debug_displays
); i
--;)
10456 if (streq (debug_displays
[i
].name
, name
))
10458 unsigned char *start
;
10460 start
= get_data (NULL
, file
, section
->sh_offset
, length
,
10461 _("debug section data"));
10468 result
&= debug_displays
[i
].display (section
, start
, file
);
10471 /* If we loaded in the abbrev section
10472 at some point, we must release it here. */
10480 printf (_("Unrecognized debug section: %s\n"), name
);
10488 process_section_contents (FILE *file
)
10490 Elf_Internal_Shdr
*section
;
10496 for (i
= 0, section
= section_headers
;
10497 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
10500 #ifdef SUPPORT_DISASSEMBLY
10501 if (dump_sects
[i
] & DISASS_DUMP
)
10502 disassemble_section (section
, file
);
10504 if (dump_sects
[i
] & HEX_DUMP
)
10505 dump_section (section
, file
);
10507 if (dump_sects
[i
] & DEBUG_DUMP
)
10508 display_debug_section (section
, file
);
10511 /* Check to see if the user requested a
10512 dump of a section that does not exist. */
10513 while (i
++ < num_dump_sects
)
10515 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
10519 process_mips_fpe_exception (int mask
)
10524 if (mask
& OEX_FPU_INEX
)
10525 fputs ("INEX", stdout
), first
= 0;
10526 if (mask
& OEX_FPU_UFLO
)
10527 printf ("%sUFLO", first
? "" : "|"), first
= 0;
10528 if (mask
& OEX_FPU_OFLO
)
10529 printf ("%sOFLO", first
? "" : "|"), first
= 0;
10530 if (mask
& OEX_FPU_DIV0
)
10531 printf ("%sDIV0", first
? "" : "|"), first
= 0;
10532 if (mask
& OEX_FPU_INVAL
)
10533 printf ("%sINVAL", first
? "" : "|");
10536 fputs ("0", stdout
);
10540 process_mips_specific (FILE *file
)
10542 Elf_Internal_Dyn
*entry
;
10543 size_t liblist_offset
= 0;
10544 size_t liblistno
= 0;
10545 size_t conflictsno
= 0;
10546 size_t options_offset
= 0;
10547 size_t conflicts_offset
= 0;
10549 /* We have a lot of special sections. Thanks SGI! */
10550 if (dynamic_section
== NULL
)
10551 /* No information available. */
10554 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
10555 switch (entry
->d_tag
)
10557 case DT_MIPS_LIBLIST
:
10559 = offset_from_vma (file
, entry
->d_un
.d_val
,
10560 liblistno
* sizeof (Elf32_External_Lib
));
10562 case DT_MIPS_LIBLISTNO
:
10563 liblistno
= entry
->d_un
.d_val
;
10565 case DT_MIPS_OPTIONS
:
10566 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
10568 case DT_MIPS_CONFLICT
:
10570 = offset_from_vma (file
, entry
->d_un
.d_val
,
10571 conflictsno
* sizeof (Elf32_External_Conflict
));
10573 case DT_MIPS_CONFLICTNO
:
10574 conflictsno
= entry
->d_un
.d_val
;
10580 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
10582 Elf32_External_Lib
*elib
;
10585 elib
= get_data (NULL
, file
, liblist_offset
,
10586 liblistno
* sizeof (Elf32_External_Lib
),
10590 printf ("\nSection '.liblist' contains %lu entries:\n",
10591 (unsigned long) liblistno
);
10592 fputs (" Library Time Stamp Checksum Version Flags\n",
10595 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
10602 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
10603 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
10604 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
10605 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
10606 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
10608 tmp
= gmtime (&time
);
10609 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
10610 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10611 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10613 printf ("%3lu: ", (unsigned long) cnt
);
10614 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
10615 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
10617 printf ("<corrupt: %9ld>", liblist
.l_name
);
10618 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
10619 liblist
.l_version
);
10621 if (liblist
.l_flags
== 0)
10625 static const struct
10632 { " EXACT_MATCH", LL_EXACT_MATCH
},
10633 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
10634 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
10635 { " EXPORTS", LL_EXPORTS
},
10636 { " DELAY_LOAD", LL_DELAY_LOAD
},
10637 { " DELTA", LL_DELTA
}
10639 int flags
= liblist
.l_flags
;
10643 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
10645 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
10647 fputs (l_flags_vals
[fcnt
].name
, stdout
);
10648 flags
^= l_flags_vals
[fcnt
].bit
;
10651 printf (" %#x", (unsigned int) flags
);
10661 if (options_offset
!= 0)
10663 Elf_External_Options
*eopt
;
10664 Elf_Internal_Shdr
*sect
= section_headers
;
10665 Elf_Internal_Options
*iopt
;
10666 Elf_Internal_Options
*option
;
10670 /* Find the section header so that we get the size. */
10671 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
10674 eopt
= get_data (NULL
, file
, options_offset
, sect
->sh_size
,
10678 iopt
= malloc ((sect
->sh_size
/ sizeof (eopt
)) * sizeof (*iopt
));
10681 error (_("Out of memory"));
10688 while (offset
< sect
->sh_size
)
10690 Elf_External_Options
*eoption
;
10692 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
10694 option
->kind
= BYTE_GET (eoption
->kind
);
10695 option
->size
= BYTE_GET (eoption
->size
);
10696 option
->section
= BYTE_GET (eoption
->section
);
10697 option
->info
= BYTE_GET (eoption
->info
);
10699 offset
+= option
->size
;
10705 printf (_("\nSection '%s' contains %d entries:\n"),
10706 SECTION_NAME (sect
), cnt
);
10714 switch (option
->kind
)
10717 /* This shouldn't happen. */
10718 printf (" NULL %d %lx", option
->section
, option
->info
);
10721 printf (" REGINFO ");
10722 if (elf_header
.e_machine
== EM_MIPS
)
10725 Elf32_External_RegInfo
*ereg
;
10726 Elf32_RegInfo reginfo
;
10728 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
10729 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
10730 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
10731 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
10732 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
10733 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
10734 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
10736 printf ("GPR %08lx GP 0x%lx\n",
10737 reginfo
.ri_gprmask
,
10738 (unsigned long) reginfo
.ri_gp_value
);
10739 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
10740 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
10741 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
10746 Elf64_External_RegInfo
*ereg
;
10747 Elf64_Internal_RegInfo reginfo
;
10749 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
10750 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
10751 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
10752 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
10753 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
10754 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
10755 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
10757 printf ("GPR %08lx GP 0x",
10758 reginfo
.ri_gprmask
);
10759 printf_vma (reginfo
.ri_gp_value
);
10762 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
10763 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
10764 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
10768 case ODK_EXCEPTIONS
:
10769 fputs (" EXCEPTIONS fpe_min(", stdout
);
10770 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
10771 fputs (") fpe_max(", stdout
);
10772 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
10773 fputs (")", stdout
);
10775 if (option
->info
& OEX_PAGE0
)
10776 fputs (" PAGE0", stdout
);
10777 if (option
->info
& OEX_SMM
)
10778 fputs (" SMM", stdout
);
10779 if (option
->info
& OEX_FPDBUG
)
10780 fputs (" FPDBUG", stdout
);
10781 if (option
->info
& OEX_DISMISS
)
10782 fputs (" DISMISS", stdout
);
10785 fputs (" PAD ", stdout
);
10786 if (option
->info
& OPAD_PREFIX
)
10787 fputs (" PREFIX", stdout
);
10788 if (option
->info
& OPAD_POSTFIX
)
10789 fputs (" POSTFIX", stdout
);
10790 if (option
->info
& OPAD_SYMBOL
)
10791 fputs (" SYMBOL", stdout
);
10794 fputs (" HWPATCH ", stdout
);
10795 if (option
->info
& OHW_R4KEOP
)
10796 fputs (" R4KEOP", stdout
);
10797 if (option
->info
& OHW_R8KPFETCH
)
10798 fputs (" R8KPFETCH", stdout
);
10799 if (option
->info
& OHW_R5KEOP
)
10800 fputs (" R5KEOP", stdout
);
10801 if (option
->info
& OHW_R5KCVTL
)
10802 fputs (" R5KCVTL", stdout
);
10805 fputs (" FILL ", stdout
);
10806 /* XXX Print content of info word? */
10809 fputs (" TAGS ", stdout
);
10810 /* XXX Print content of info word? */
10813 fputs (" HWAND ", stdout
);
10814 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
10815 fputs (" R4KEOP_CHECKED", stdout
);
10816 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
10817 fputs (" R4KEOP_CLEAN", stdout
);
10820 fputs (" HWOR ", stdout
);
10821 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
10822 fputs (" R4KEOP_CHECKED", stdout
);
10823 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
10824 fputs (" R4KEOP_CLEAN", stdout
);
10827 printf (" GP_GROUP %#06lx self-contained %#06lx",
10828 option
->info
& OGP_GROUP
,
10829 (option
->info
& OGP_SELF
) >> 16);
10832 printf (" IDENT %#06lx self-contained %#06lx",
10833 option
->info
& OGP_GROUP
,
10834 (option
->info
& OGP_SELF
) >> 16);
10837 /* This shouldn't happen. */
10838 printf (" %3d ??? %d %lx",
10839 option
->kind
, option
->section
, option
->info
);
10843 len
= sizeof (*eopt
);
10844 while (len
< option
->size
)
10845 if (((char *) option
)[len
] >= ' '
10846 && ((char *) option
)[len
] < 0x7f)
10847 printf ("%c", ((char *) option
)[len
++]);
10849 printf ("\\%03o", ((char *) option
)[len
++]);
10851 fputs ("\n", stdout
);
10859 if (conflicts_offset
!= 0 && conflictsno
!= 0)
10861 Elf32_Conflict
*iconf
;
10864 if (dynamic_symbols
== NULL
)
10866 error (_("conflict list found without a dynamic symbol table"));
10870 iconf
= malloc (conflictsno
* sizeof (*iconf
));
10873 error (_("Out of memory"));
10879 Elf32_External_Conflict
*econf32
;
10881 econf32
= get_data (NULL
, file
, conflicts_offset
,
10882 conflictsno
* sizeof (*econf32
), _("conflict"));
10886 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10887 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
10893 Elf64_External_Conflict
*econf64
;
10895 econf64
= get_data (NULL
, file
, conflicts_offset
,
10896 conflictsno
* sizeof (*econf64
), _("conflict"));
10900 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10901 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
10906 printf (_("\nSection '.conflict' contains %lu entries:\n"),
10907 (unsigned long) conflictsno
);
10908 puts (_(" Num: Index Value Name"));
10910 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10912 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
10914 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
10915 print_vma (psym
->st_value
, FULL_HEX
);
10917 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10918 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10920 printf ("<corrupt: %14ld>", psym
->st_name
);
10931 process_gnu_liblist (FILE *file
)
10933 Elf_Internal_Shdr
*section
, *string_sec
;
10934 Elf32_External_Lib
*elib
;
10942 for (i
= 0, section
= section_headers
;
10943 i
< elf_header
.e_shnum
;
10946 switch (section
->sh_type
)
10948 case SHT_GNU_LIBLIST
:
10949 elib
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
10954 string_sec
= SECTION_HEADER (section
->sh_link
);
10956 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
10957 string_sec
->sh_size
, _("liblist string table"));
10960 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
10966 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
10967 SECTION_NAME (section
),
10968 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
10970 puts (" Library Time Stamp Checksum Version Flags");
10972 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
10980 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
10981 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
10982 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
10983 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
10984 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
10986 tmp
= gmtime (&time
);
10987 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
10988 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10989 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10991 printf ("%3lu: ", (unsigned long) cnt
);
10993 printf ("%-20s", strtab
+ liblist
.l_name
);
10995 printf ("%-20.20s", strtab
+ liblist
.l_name
);
10996 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
10997 liblist
.l_version
, liblist
.l_flags
);
11007 static const char *
11008 get_note_type (unsigned e_type
)
11010 static char buff
[64];
11012 if (elf_header
.e_type
== ET_CORE
)
11016 return _("NT_AUXV (auxiliary vector)");
11018 return _("NT_PRSTATUS (prstatus structure)");
11020 return _("NT_FPREGSET (floating point registers)");
11022 return _("NT_PRPSINFO (prpsinfo structure)");
11023 case NT_TASKSTRUCT
:
11024 return _("NT_TASKSTRUCT (task structure)");
11026 return _("NT_PRXFPREG (user_xfpregs structure)");
11028 return _("NT_PSTATUS (pstatus structure)");
11030 return _("NT_FPREGS (floating point registers)");
11032 return _("NT_PSINFO (psinfo structure)");
11034 return _("NT_LWPSTATUS (lwpstatus_t structure)");
11036 return _("NT_LWPSINFO (lwpsinfo_t structure)");
11037 case NT_WIN32PSTATUS
:
11038 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11046 return _("NT_VERSION (version)");
11048 return _("NT_ARCH (architecture)");
11053 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
11057 static const char *
11058 get_netbsd_elfcore_note_type (unsigned e_type
)
11060 static char buff
[64];
11062 if (e_type
== NT_NETBSDCORE_PROCINFO
)
11064 /* NetBSD core "procinfo" structure. */
11065 return _("NetBSD procinfo structure");
11068 /* As of Jan 2002 there are no other machine-independent notes
11069 defined for NetBSD core files. If the note type is less
11070 than the start of the machine-dependent note types, we don't
11073 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
11075 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
11079 switch (elf_header
.e_machine
)
11081 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
11082 and PT_GETFPREGS == mach+2. */
11087 case EM_SPARC32PLUS
:
11091 case NT_NETBSDCORE_FIRSTMACH
+0:
11092 return _("PT_GETREGS (reg structure)");
11093 case NT_NETBSDCORE_FIRSTMACH
+2:
11094 return _("PT_GETFPREGS (fpreg structure)");
11100 /* On all other arch's, PT_GETREGS == mach+1 and
11101 PT_GETFPREGS == mach+3. */
11105 case NT_NETBSDCORE_FIRSTMACH
+1:
11106 return _("PT_GETREGS (reg structure)");
11107 case NT_NETBSDCORE_FIRSTMACH
+3:
11108 return _("PT_GETFPREGS (fpreg structure)");
11114 sprintf (buff
, _("PT_FIRSTMACH+%d"), e_type
- NT_NETBSDCORE_FIRSTMACH
);
11118 /* Note that by the ELF standard, the name field is already null byte
11119 terminated, and namesz includes the terminating null byte.
11120 I.E. the value of namesz for the name "FSF" is 4.
11122 If the value of namesz is zero, there is no name present. */
11124 process_note (Elf_Internal_Note
*pnote
)
11128 if (pnote
->namesz
== 0)
11129 /* If there is no note name, then use the default set of
11130 note type strings. */
11131 nt
= get_note_type (pnote
->type
);
11133 else if (strneq (pnote
->namedata
, "NetBSD-CORE", 11))
11134 /* NetBSD-specific core file notes. */
11135 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
11138 /* Don't recognize this note name; just use the default set of
11139 note type strings. */
11140 nt
= get_note_type (pnote
->type
);
11142 printf (" %s\t\t0x%08lx\t%s\n",
11143 pnote
->namesz
? pnote
->namedata
: "(NONE)",
11144 pnote
->descsz
, nt
);
11150 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
11152 Elf_External_Note
*pnotes
;
11153 Elf_External_Note
*external
;
11159 pnotes
= get_data (NULL
, file
, offset
, length
, _("notes"));
11165 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
11166 (unsigned long) offset
, (unsigned long) length
);
11167 printf (_(" Owner\t\tData size\tDescription\n"));
11169 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
11171 Elf_External_Note
*next
;
11172 Elf_Internal_Note inote
;
11175 inote
.type
= BYTE_GET (external
->type
);
11176 inote
.namesz
= BYTE_GET (external
->namesz
);
11177 inote
.namedata
= external
->name
;
11178 inote
.descsz
= BYTE_GET (external
->descsz
);
11179 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
11180 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
11182 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
11184 if (((char *) next
) > (((char *) pnotes
) + length
))
11186 warn (_("corrupt note found at offset %x into core notes\n"),
11187 ((char *) external
) - ((char *) pnotes
));
11188 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
11189 inote
.type
, inote
.namesz
, inote
.descsz
);
11195 /* Verify that name is null terminated. It appears that at least
11196 one version of Linux (RedHat 6.0) generates corefiles that don't
11197 comply with the ELF spec by failing to include the null byte in
11199 if (inote
.namedata
[inote
.namesz
] != '\0')
11201 temp
= malloc (inote
.namesz
+ 1);
11205 error (_("Out of memory\n"));
11210 strncpy (temp
, inote
.namedata
, inote
.namesz
);
11211 temp
[inote
.namesz
] = 0;
11213 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
11214 inote
.namedata
= temp
;
11217 res
&= process_note (& inote
);
11232 process_corefile_note_segments (FILE *file
)
11234 Elf_Internal_Phdr
*segment
;
11238 if (! get_program_headers (file
))
11241 for (i
= 0, segment
= program_headers
;
11242 i
< elf_header
.e_phnum
;
11245 if (segment
->p_type
== PT_NOTE
)
11246 res
&= process_corefile_note_segment (file
,
11247 (bfd_vma
) segment
->p_offset
,
11248 (bfd_vma
) segment
->p_filesz
);
11255 process_note_sections (FILE *file
)
11257 Elf_Internal_Shdr
*section
;
11261 for (i
= 0, section
= section_headers
;
11262 i
< elf_header
.e_shnum
;
11264 if (section
->sh_type
== SHT_NOTE
)
11265 res
&= process_corefile_note_segment (file
,
11266 (bfd_vma
) section
->sh_offset
,
11267 (bfd_vma
) section
->sh_size
);
11273 process_notes (FILE *file
)
11275 /* If we have not been asked to display the notes then do nothing. */
11279 if (elf_header
.e_type
!= ET_CORE
)
11280 return process_note_sections (file
);
11282 /* No program headers means no NOTE segment. */
11283 if (elf_header
.e_phnum
> 0)
11284 return process_corefile_note_segments (file
);
11286 printf (_("No note segments present in the core file.\n"));
11291 process_arch_specific (FILE *file
)
11296 switch (elf_header
.e_machine
)
11299 case EM_MIPS_RS3_LE
:
11300 return process_mips_specific (file
);
11309 get_file_header (FILE *file
)
11311 /* Read in the identity array. */
11312 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
11315 /* Determine how to read the rest of the header. */
11316 switch (elf_header
.e_ident
[EI_DATA
])
11318 default: /* fall through */
11319 case ELFDATANONE
: /* fall through */
11321 byte_get
= byte_get_little_endian
;
11322 byte_put
= byte_put_little_endian
;
11325 byte_get
= byte_get_big_endian
;
11326 byte_put
= byte_put_big_endian
;
11330 /* For now we only support 32 bit and 64 bit ELF files. */
11331 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
11333 /* Read in the rest of the header. */
11336 Elf32_External_Ehdr ehdr32
;
11338 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
11341 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
11342 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
11343 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
11344 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
11345 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
11346 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
11347 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
11348 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
11349 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
11350 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
11351 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
11352 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
11353 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
11357 Elf64_External_Ehdr ehdr64
;
11359 /* If we have been compiled with sizeof (bfd_vma) == 4, then
11360 we will not be able to cope with the 64bit data found in
11361 64 ELF files. Detect this now and abort before we start
11362 overwriting things. */
11363 if (sizeof (bfd_vma
) < 8)
11365 error (_("This instance of readelf has been built without support for a\n\
11366 64 bit data type and so it cannot read 64 bit ELF files.\n"));
11370 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
11373 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
11374 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
11375 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
11376 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
11377 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
11378 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
11379 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
11380 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
11381 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
11382 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
11383 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
11384 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
11385 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
11388 if (elf_header
.e_shoff
)
11390 /* There may be some extensions in the first section header. Don't
11391 bomb if we can't read it. */
11393 get_32bit_section_headers (file
, 1);
11395 get_64bit_section_headers (file
, 1);
11401 /* Process one ELF object file according to the command line options.
11402 This file may actually be stored in an archive. The file is
11403 positioned at the start of the ELF object. */
11406 process_object (char *file_name
, FILE *file
)
11410 if (! get_file_header (file
))
11412 error (_("%s: Failed to read file header\n"), file_name
);
11416 /* Initialise per file variables. */
11417 for (i
= NUM_ELEM (version_info
); i
--;)
11418 version_info
[i
] = 0;
11420 for (i
= NUM_ELEM (dynamic_info
); i
--;)
11421 dynamic_info
[i
] = 0;
11423 /* Process the file. */
11425 printf (_("\nFile: %s\n"), file_name
);
11427 /* Initialise the dump_sects array from the cmdline_dump_sects array.
11428 Note we do this even if cmdline_dump_sects is empty because we
11429 must make sure that the dump_sets array is zeroed out before each
11430 object file is processed. */
11431 if (num_dump_sects
> num_cmdline_dump_sects
)
11432 memset (dump_sects
, 0, num_dump_sects
);
11434 if (num_cmdline_dump_sects
> 0)
11436 if (num_dump_sects
== 0)
11437 /* A sneaky way of allocating the dump_sects array. */
11438 request_dump (num_cmdline_dump_sects
, 0);
11440 assert (num_dump_sects
>= num_cmdline_dump_sects
);
11441 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
11444 if (! process_file_header ())
11447 if (! process_section_headers (file
)
11448 || ! process_section_groups (file
))
11450 /* Without loaded section headers and section groups we
11451 cannot process lots of things. */
11452 do_unwind
= do_version
= do_dump
= do_arch
= 0;
11454 if (! do_using_dynamic
)
11455 do_syms
= do_reloc
= 0;
11458 if (process_program_headers (file
))
11459 process_dynamic_section (file
);
11461 process_relocs (file
);
11463 process_unwind (file
);
11465 process_symbol_table (file
);
11467 process_syminfo (file
);
11469 process_version_sections (file
);
11471 process_section_contents (file
);
11473 process_notes (file
);
11475 process_gnu_liblist (file
);
11477 process_arch_specific (file
);
11479 if (program_headers
)
11481 free (program_headers
);
11482 program_headers
= NULL
;
11485 if (section_headers
)
11487 free (section_headers
);
11488 section_headers
= NULL
;
11493 free (string_table
);
11494 string_table
= NULL
;
11495 string_table_length
= 0;
11498 if (dynamic_strings
)
11500 free (dynamic_strings
);
11501 dynamic_strings
= NULL
;
11502 dynamic_strings_length
= 0;
11505 if (dynamic_symbols
)
11507 free (dynamic_symbols
);
11508 dynamic_symbols
= NULL
;
11509 num_dynamic_syms
= 0;
11512 if (dynamic_syminfo
)
11514 free (dynamic_syminfo
);
11515 dynamic_syminfo
= NULL
;
11518 if (section_headers_groups
)
11520 free (section_headers_groups
);
11521 section_headers_groups
= NULL
;
11524 if (section_groups
)
11526 struct group_list
*g
, *next
;
11528 for (i
= 0; i
< group_count
; i
++)
11530 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
11537 free (section_groups
);
11538 section_groups
= NULL
;
11541 if (debug_information
)
11543 free (debug_information
);
11544 debug_information
= NULL
;
11545 num_debug_info_entries
= 0;
11551 /* Process an ELF archive. The file is positioned just after the
11555 process_archive (char *file_name
, FILE *file
)
11557 struct ar_hdr arhdr
;
11559 unsigned long size
;
11560 char *longnames
= NULL
;
11561 unsigned long longnames_size
= 0;
11562 size_t file_name_size
;
11567 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
11568 if (got
!= sizeof arhdr
)
11573 error (_("%s: failed to read archive header\n"), file_name
);
11577 if (memcmp (arhdr
.ar_name
, "/ ", 16) == 0)
11579 /* This is the archive symbol table. Skip it.
11580 FIXME: We should have an option to dump it. */
11581 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
11582 if (fseek (file
, size
+ (size
& 1), SEEK_CUR
) != 0)
11584 error (_("%s: failed to skip archive symbol table\n"), file_name
);
11588 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
11589 if (got
!= sizeof arhdr
)
11594 error (_("%s: failed to read archive header\n"), file_name
);
11599 if (memcmp (arhdr
.ar_name
, "// ", 16) == 0)
11601 /* This is the archive string table holding long member
11604 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
11606 longnames
= malloc (longnames_size
);
11607 if (longnames
== NULL
)
11609 error (_("Out of memory\n"));
11613 if (fread (longnames
, longnames_size
, 1, file
) != 1)
11616 error (_("%s: failed to read string table\n"), file_name
);
11620 if ((longnames_size
& 1) != 0)
11623 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
11624 if (got
!= sizeof arhdr
)
11631 error (_("%s: failed to read archive header\n"), file_name
);
11636 file_name_size
= strlen (file_name
);
11645 if (arhdr
.ar_name
[0] == '/')
11649 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
11650 if (off
>= longnames_size
)
11652 error (_("%s: invalid archive string table offset %lu\n"), off
);
11657 name
= longnames
+ off
;
11658 nameend
= memchr (name
, '/', longnames_size
- off
);
11662 name
= arhdr
.ar_name
;
11663 nameend
= memchr (name
, '/', 16);
11666 if (nameend
== NULL
)
11668 error (_("%s: bad archive file name\n"));
11673 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
11674 if (namealc
== NULL
)
11676 error (_("Out of memory\n"));
11681 memcpy (namealc
, file_name
, file_name_size
);
11682 namealc
[file_name_size
] = '(';
11683 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
11684 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
11685 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
11687 archive_file_offset
= ftell (file
);
11688 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
11690 ret
|= process_object (namealc
, file
);
11695 (archive_file_offset
11696 + archive_file_size
11697 + (archive_file_size
& 1)),
11700 error (_("%s: failed to seek to next archive header\n"), file_name
);
11705 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
11706 if (got
!= sizeof arhdr
)
11711 error (_("%s: failed to read archive header\n"), file_name
);
11717 if (longnames
!= 0)
11724 process_file (char *file_name
)
11727 struct stat statbuf
;
11728 char armag
[SARMAG
];
11731 if (stat (file_name
, &statbuf
) < 0)
11733 if (errno
== ENOENT
)
11734 error (_("'%s': No such file\n"), file_name
);
11736 error (_("Could not locate '%s'. System error message: %s\n"),
11737 file_name
, strerror (errno
));
11741 if (! S_ISREG (statbuf
.st_mode
))
11743 error (_("'%s' is not an ordinary file\n"), file_name
);
11747 file
= fopen (file_name
, "rb");
11750 error (_("Input file '%s' is not readable.\n"), file_name
);
11754 if (fread (armag
, SARMAG
, 1, file
) != 1)
11756 error (_("%s: Failed to read file header\n"), file_name
);
11761 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
11762 ret
= process_archive (file_name
, file
);
11766 archive_file_size
= archive_file_offset
= 0;
11767 ret
= process_object (file_name
, file
);
11775 #ifdef SUPPORT_DISASSEMBLY
11776 /* Needed by the i386 disassembler. For extra credit, someone could
11777 fix this so that we insert symbolic addresses here, esp for GOT/PLT
11781 print_address (unsigned int addr
, FILE *outfile
)
11783 fprintf (outfile
,"0x%8.8x", addr
);
11786 /* Needed by the i386 disassembler. */
11788 db_task_printsym (unsigned int addr
)
11790 print_address (addr
, stderr
);
11795 main (int argc
, char **argv
)
11799 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
11800 setlocale (LC_MESSAGES
, "");
11802 #if defined (HAVE_SETLOCALE)
11803 setlocale (LC_CTYPE
, "");
11805 bindtextdomain (PACKAGE
, LOCALEDIR
);
11806 textdomain (PACKAGE
);
11808 parse_args (argc
, argv
);
11810 if (num_dump_sects
> 0)
11812 /* Make a copy of the dump_sects array. */
11813 cmdline_dump_sects
= malloc (num_dump_sects
);
11814 if (cmdline_dump_sects
== NULL
)
11815 error (_("Out of memory allocating dump request table."));
11818 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
11819 num_cmdline_dump_sects
= num_dump_sects
;
11823 if (optind
< (argc
- 1))
11827 while (optind
< argc
)
11828 err
|= process_file (argv
[optind
++]);
11830 if (dump_sects
!= NULL
)
11832 if (cmdline_dump_sects
!= NULL
)
11833 free (cmdline_dump_sects
);