1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2017 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
53 as this will allow us to read in and parse 64bit and 32bit ELF files.
54 Only do this if we believe that the compiler can support a 64 bit
55 data type. For now we only rely on GCC being able to do this. */
64 #include "elf/common.h"
65 #include "elf/external.h"
66 #include "elf/internal.h"
69 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
70 we can obtain the H8 reloc numbers. We need these for the
71 get_reloc_size() function. We include h8.h again after defining
72 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
77 /* Undo the effects of #including reloc-macros.h. */
79 #undef START_RELOC_NUMBERS
83 #undef END_RELOC_NUMBERS
84 #undef _RELOC_MACROS_H
86 /* The following headers use the elf/reloc-macros.h file to
87 automatically generate relocation recognition functions
88 such as elf_mips_reloc_type() */
90 #define RELOC_MACROS_GEN_FUNC
92 #include "elf/aarch64.h"
93 #include "elf/alpha.h"
101 #include "elf/d10v.h"
102 #include "elf/d30v.h"
104 #include "elf/epiphany.h"
105 #include "elf/fr30.h"
107 #include "elf/ft32.h"
109 #include "elf/hppa.h"
110 #include "elf/i386.h"
111 #include "elf/i370.h"
112 #include "elf/i860.h"
113 #include "elf/i960.h"
114 #include "elf/ia64.h"
115 #include "elf/ip2k.h"
116 #include "elf/lm32.h"
117 #include "elf/iq2000.h"
118 #include "elf/m32c.h"
119 #include "elf/m32r.h"
120 #include "elf/m68k.h"
121 #include "elf/m68hc11.h"
122 #include "elf/mcore.h"
124 #include "elf/metag.h"
125 #include "elf/microblaze.h"
126 #include "elf/mips.h"
127 #include "elf/riscv.h"
128 #include "elf/mmix.h"
129 #include "elf/mn10200.h"
130 #include "elf/mn10300.h"
131 #include "elf/moxie.h"
133 #include "elf/msp430.h"
134 #include "elf/nds32.h"
135 #include "elf/nios2.h"
136 #include "elf/or1k.h"
139 #include "elf/ppc64.h"
141 #include "elf/rl78.h"
143 #include "elf/s390.h"
144 #include "elf/score.h"
146 #include "elf/sparc.h"
148 #include "elf/tic6x.h"
149 #include "elf/tilegx.h"
150 #include "elf/tilepro.h"
151 #include "elf/v850.h"
153 #include "elf/visium.h"
154 #include "elf/wasm32.h"
155 #include "elf/x86-64.h"
156 #include "elf/xc16x.h"
157 #include "elf/xgate.h"
158 #include "elf/xstormy16.h"
159 #include "elf/xtensa.h"
162 #include "libiberty.h"
163 #include "safe-ctype.h"
164 #include "filenames.h"
167 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
170 typedef struct elf_section_list
172 Elf_Internal_Shdr
* hdr
;
173 struct elf_section_list
* next
;
176 char * program_name
= "readelf";
177 static unsigned long archive_file_offset
;
178 static unsigned long archive_file_size
;
179 static bfd_size_type current_file_size
;
180 static unsigned long dynamic_addr
;
181 static bfd_size_type dynamic_size
;
182 static size_t dynamic_nent
;
183 static char * dynamic_strings
;
184 static unsigned long dynamic_strings_length
;
185 static char * string_table
;
186 static unsigned long string_table_length
;
187 static unsigned long num_dynamic_syms
;
188 static Elf_Internal_Sym
* dynamic_symbols
;
189 static Elf_Internal_Syminfo
* dynamic_syminfo
;
190 static unsigned long dynamic_syminfo_offset
;
191 static unsigned int dynamic_syminfo_nent
;
192 static char program_interpreter
[PATH_MAX
];
193 static bfd_vma dynamic_info
[DT_ENCODING
];
194 static bfd_vma dynamic_info_DT_GNU_HASH
;
195 static bfd_vma version_info
[16];
196 static Elf_Internal_Ehdr elf_header
;
197 static Elf_Internal_Shdr
* section_headers
;
198 static Elf_Internal_Phdr
* program_headers
;
199 static Elf_Internal_Dyn
* dynamic_section
;
200 static elf_section_list
* symtab_shndx_list
;
201 static bfd_boolean show_name
= FALSE
;
202 static bfd_boolean do_dynamic
= FALSE
;
203 static bfd_boolean do_syms
= FALSE
;
204 static bfd_boolean do_dyn_syms
= FALSE
;
205 static bfd_boolean do_reloc
= FALSE
;
206 static bfd_boolean do_sections
= FALSE
;
207 static bfd_boolean do_section_groups
= FALSE
;
208 static bfd_boolean do_section_details
= FALSE
;
209 static bfd_boolean do_segments
= FALSE
;
210 static bfd_boolean do_unwind
= FALSE
;
211 static bfd_boolean do_using_dynamic
= FALSE
;
212 static bfd_boolean do_header
= FALSE
;
213 static bfd_boolean do_dump
= FALSE
;
214 static bfd_boolean do_version
= FALSE
;
215 static bfd_boolean do_histogram
= FALSE
;
216 static bfd_boolean do_debugging
= FALSE
;
217 static bfd_boolean do_arch
= FALSE
;
218 static bfd_boolean do_notes
= FALSE
;
219 static bfd_boolean do_archive_index
= FALSE
;
220 static bfd_boolean is_32bit_elf
= FALSE
;
221 static bfd_boolean decompress_dumps
= FALSE
;
225 struct group_list
* next
;
226 unsigned int section_index
;
231 struct group_list
* root
;
232 unsigned int group_index
;
235 static size_t group_count
;
236 static struct group
* section_groups
;
237 static struct group
** section_headers_groups
;
240 /* Flag bits indicating particular types of dump. */
241 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
242 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
243 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
244 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
245 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
247 typedef unsigned char dump_type
;
249 /* A linked list of the section names for which dumps were requested. */
250 struct dump_list_entry
254 struct dump_list_entry
* next
;
256 static struct dump_list_entry
* dump_sects_byname
;
258 /* A dynamic array of flags indicating for which sections a dump
259 has been requested via command line switches. */
260 static dump_type
* cmdline_dump_sects
= NULL
;
261 static unsigned int num_cmdline_dump_sects
= 0;
263 /* A dynamic array of flags indicating for which sections a dump of
264 some kind has been requested. It is reset on a per-object file
265 basis and then initialised from the cmdline_dump_sects array,
266 the results of interpreting the -w switch, and the
267 dump_sects_byname list. */
268 static dump_type
* dump_sects
= NULL
;
269 static unsigned int num_dump_sects
= 0;
272 /* How to print a vma value. */
273 typedef enum print_mode
285 /* Versioned symbol info. */
286 enum versioned_symbol_info
293 static const char * get_symbol_version_string
294 (FILE *, bfd_boolean
, const char *, unsigned long, unsigned,
295 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
299 #define SECTION_NAME(X) \
300 ((X) == NULL ? _("<none>") \
301 : string_table == NULL ? _("<no-name>") \
302 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
303 : string_table + (X)->sh_name))
305 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
307 #define GET_ELF_SYMBOLS(file, section, sym_count) \
308 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
309 : get_64bit_elf_symbols (file, section, sym_count))
311 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
312 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
313 already been called and verified that the string exists. */
314 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
316 #define REMOVE_ARCH_BITS(ADDR) \
319 if (elf_header.e_machine == EM_ARM) \
324 /* Print a BFD_VMA to an internal buffer, for use in error messages.
325 BFD_FMA_FMT can't be used in translated strings. */
328 bfd_vmatoa (char *fmtch
, bfd_vma value
)
330 /* bfd_vmatoa is used more then once in a printf call for output.
331 Cycle through an array of buffers. */
332 static int buf_pos
= 0;
333 static struct bfd_vmatoa_buf
340 ret
= buf
[buf_pos
++].place
;
341 buf_pos
%= ARRAY_SIZE (buf
);
343 sprintf (fmt
, "%%%s%s", BFD_VMA_FMT
, fmtch
);
344 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
348 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
349 the offset of the current archive member, if we are examining an archive.
350 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
351 using malloc and fill that. In either case return the pointer to the start of
352 the retrieved data or NULL if something went wrong. If something does go wrong
353 and REASON is not NULL then emit an error message using REASON as part of the
357 get_data (void * var
, FILE * file
, unsigned long offset
, bfd_size_type size
,
358 bfd_size_type nmemb
, const char * reason
)
361 bfd_size_type amt
= size
* nmemb
;
363 if (size
== 0 || nmemb
== 0)
366 /* If the size_t type is smaller than the bfd_size_type, eg because
367 you are building a 32-bit tool on a 64-bit host, then make sure
368 that when the sizes are cast to (size_t) no information is lost. */
369 if (sizeof (size_t) < sizeof (bfd_size_type
)
370 && ( (bfd_size_type
) ((size_t) size
) != size
371 || (bfd_size_type
) ((size_t) nmemb
) != nmemb
))
374 error (_("Size truncation prevents reading %s"
375 " elements of size %s for %s\n"),
376 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
380 /* Check for size overflow. */
384 error (_("Size overflow prevents reading %s"
385 " elements of size %s for %s\n"),
386 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
390 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
391 attempting to allocate memory when the read is bound to fail. */
392 if (amt
> current_file_size
393 || offset
+ archive_file_offset
+ amt
> current_file_size
)
396 error (_("Reading %s bytes extends past end of file for %s\n"),
397 bfd_vmatoa ("u", amt
), reason
);
401 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
404 error (_("Unable to seek to 0x%lx for %s\n"),
405 archive_file_offset
+ offset
, reason
);
412 /* Check for overflow. */
413 if (nmemb
< (~(bfd_size_type
) 0 - 1) / size
)
414 /* + 1 so that we can '\0' terminate invalid string table sections. */
415 mvar
= malloc ((size_t) amt
+ 1);
420 error (_("Out of memory allocating %s bytes for %s\n"),
421 bfd_vmatoa ("u", amt
), reason
);
425 ((char *) mvar
)[amt
] = '\0';
428 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, file
) != nmemb
)
431 error (_("Unable to read in %s bytes of %s\n"),
432 bfd_vmatoa ("u", amt
), reason
);
441 /* Print a VMA value in the MODE specified.
442 Returns the number of characters displayed. */
445 print_vma (bfd_vma vma
, print_mode mode
)
457 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
464 return printf ("%5" BFD_VMA_FMT
"d", vma
);
470 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
473 return printf ("%" BFD_VMA_FMT
"d", vma
);
476 return printf ("%" BFD_VMA_FMT
"u", vma
);
479 /* FIXME: Report unrecognised mode ? */
484 /* Display a symbol on stdout. Handles the display of control characters and
485 multibye characters (assuming the host environment supports them).
487 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
489 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
490 padding as necessary.
492 Returns the number of emitted characters. */
495 print_symbol (signed int width
, const char *symbol
)
497 bfd_boolean extra_padding
= FALSE
;
498 signed int num_printed
= 0;
499 #ifdef HAVE_MBSTATE_T
502 unsigned int width_remaining
;
506 /* Keep the width positive. This helps the code below. */
508 extra_padding
= TRUE
;
513 /* Set the remaining width to a very large value.
514 This simplifies the code below. */
515 width_remaining
= INT_MAX
;
517 width_remaining
= width
;
519 #ifdef HAVE_MBSTATE_T
520 /* Initialise the multibyte conversion state. */
521 memset (& state
, 0, sizeof (state
));
524 while (width_remaining
)
527 const char c
= *symbol
++;
532 /* Do not print control characters directly as they can affect terminal
533 settings. Such characters usually appear in the names generated
534 by the assembler for local labels. */
537 if (width_remaining
< 2)
540 printf ("^%c", c
+ 0x40);
541 width_remaining
-= 2;
544 else if (ISPRINT (c
))
552 #ifdef HAVE_MBSTATE_T
555 /* Let printf do the hard work of displaying multibyte characters. */
556 printf ("%.1s", symbol
- 1);
560 #ifdef HAVE_MBSTATE_T
561 /* Try to find out how many bytes made up the character that was
562 just printed. Advance the symbol pointer past the bytes that
564 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
568 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
573 if (extra_padding
&& num_printed
< width
)
575 /* Fill in the remaining spaces. */
576 printf ("%-*s", width
- num_printed
, " ");
583 /* Returns a pointer to a static buffer containing a printable version of
584 the given section's name. Like print_symbol, except that it does not try
585 to print multibyte characters, it just interprets them as hex values. */
588 printable_section_name (const Elf_Internal_Shdr
* sec
)
590 #define MAX_PRINT_SEC_NAME_LEN 128
591 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
592 const char * name
= SECTION_NAME (sec
);
593 char * buf
= sec_name_buf
;
595 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
597 while ((c
= * name
++) != 0)
608 else if (ISPRINT (c
))
615 static char hex
[17] = "0123456789ABCDEF";
620 * buf
++ = hex
[(c
& 0xf0) >> 4];
621 * buf
++ = hex
[c
& 0x0f];
635 printable_section_name_from_index (unsigned long ndx
)
637 if (ndx
>= elf_header
.e_shnum
)
638 return _("<corrupt>");
640 return printable_section_name (section_headers
+ ndx
);
643 /* Return a pointer to section NAME, or NULL if no such section exists. */
645 static Elf_Internal_Shdr
*
646 find_section (const char * name
)
650 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
651 if (streq (SECTION_NAME (section_headers
+ i
), name
))
652 return section_headers
+ i
;
657 /* Return a pointer to a section containing ADDR, or NULL if no such
660 static Elf_Internal_Shdr
*
661 find_section_by_address (bfd_vma addr
)
665 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
667 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
668 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
675 static Elf_Internal_Shdr
*
676 find_section_by_type (unsigned int type
)
680 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
682 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
683 if (sec
->sh_type
== type
)
690 /* Return a pointer to section NAME, or NULL if no such section exists,
691 restricted to the list of sections given in SET. */
693 static Elf_Internal_Shdr
*
694 find_section_in_set (const char * name
, unsigned int * set
)
700 while ((i
= *set
++) > 0)
702 /* See PR 21156 for a reproducer. */
703 if (i
>= elf_header
.e_shnum
)
704 continue; /* FIXME: Should we issue an error message ? */
706 if (streq (SECTION_NAME (section_headers
+ i
), name
))
707 return section_headers
+ i
;
711 return find_section (name
);
714 /* Read an unsigned LEB128 encoded value from DATA.
715 Set *LENGTH_RETURN to the number of bytes read. */
717 static inline unsigned long
718 read_uleb128 (unsigned char * data
,
719 unsigned int * length_return
,
720 const unsigned char * const end
)
722 return read_leb128 (data
, length_return
, FALSE
, end
);
725 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
726 This OS has so many departures from the ELF standard that we test it at
729 static inline bfd_boolean
732 return elf_header
.e_machine
== EM_IA_64
733 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
736 /* Guess the relocation size commonly used by the specific machines. */
739 guess_is_rela (unsigned int e_machine
)
743 /* Targets that use REL relocations. */
758 /* Targets that use RELA relocations. */
762 case EM_ADAPTEVA_EPIPHANY
:
764 case EM_ALTERA_NIOS2
:
767 case EM_ARC_COMPACT2
:
787 case EM_LATTICEMICO32
:
796 case EM_CYGNUS_MN10200
:
798 case EM_CYGNUS_MN10300
:
834 case EM_MICROBLAZE_OLD
:
856 warn (_("Don't know about relocations on this machine architecture\n"));
861 /* Load RELA type relocations from FILE at REL_OFFSET extending for REL_SIZE bytes.
862 Returns TRUE upon success, FALSE otherwise. If successful then a
863 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
864 and the number of relocs loaded is placed in *NRELASP. It is the caller's
865 responsibility to free the allocated buffer. */
868 slurp_rela_relocs (FILE * file
,
869 unsigned long rel_offset
,
870 unsigned long rel_size
,
871 Elf_Internal_Rela
** relasp
,
872 unsigned long * nrelasp
)
874 Elf_Internal_Rela
* relas
;
880 Elf32_External_Rela
* erelas
;
882 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
883 rel_size
, _("32-bit relocation data"));
887 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
889 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
890 sizeof (Elf_Internal_Rela
));
895 error (_("out of memory parsing relocs\n"));
899 for (i
= 0; i
< nrelas
; i
++)
901 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
902 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
903 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
910 Elf64_External_Rela
* erelas
;
912 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
913 rel_size
, _("64-bit relocation data"));
917 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
919 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
920 sizeof (Elf_Internal_Rela
));
925 error (_("out of memory parsing relocs\n"));
929 for (i
= 0; i
< nrelas
; i
++)
931 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
932 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
933 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
935 /* The #ifdef BFD64 below is to prevent a compile time
936 warning. We know that if we do not have a 64 bit data
937 type that we will never execute this code anyway. */
939 if (elf_header
.e_machine
== EM_MIPS
940 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
942 /* In little-endian objects, r_info isn't really a
943 64-bit little-endian value: it has a 32-bit
944 little-endian symbol index followed by four
945 individual byte fields. Reorder INFO
947 bfd_vma inf
= relas
[i
].r_info
;
948 inf
= (((inf
& 0xffffffff) << 32)
949 | ((inf
>> 56) & 0xff)
950 | ((inf
>> 40) & 0xff00)
951 | ((inf
>> 24) & 0xff0000)
952 | ((inf
>> 8) & 0xff000000));
953 relas
[i
].r_info
= inf
;
966 /* Load REL type relocations from FILE at REL_OFFSET extending for REL_SIZE bytes.
967 Returns TRUE upon success, FALSE otherwise. If successful then a
968 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
969 and the number of relocs loaded is placed in *NRELSP. It is the caller's
970 responsibility to free the allocated buffer. */
973 slurp_rel_relocs (FILE * file
,
974 unsigned long rel_offset
,
975 unsigned long rel_size
,
976 Elf_Internal_Rela
** relsp
,
977 unsigned long * nrelsp
)
979 Elf_Internal_Rela
* rels
;
985 Elf32_External_Rel
* erels
;
987 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
988 rel_size
, _("32-bit relocation data"));
992 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
994 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
999 error (_("out of memory parsing relocs\n"));
1003 for (i
= 0; i
< nrels
; i
++)
1005 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1006 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1007 rels
[i
].r_addend
= 0;
1014 Elf64_External_Rel
* erels
;
1016 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
1017 rel_size
, _("64-bit relocation data"));
1021 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1023 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1028 error (_("out of memory parsing relocs\n"));
1032 for (i
= 0; i
< nrels
; i
++)
1034 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1035 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1036 rels
[i
].r_addend
= 0;
1038 /* The #ifdef BFD64 below is to prevent a compile time
1039 warning. We know that if we do not have a 64 bit data
1040 type that we will never execute this code anyway. */
1042 if (elf_header
.e_machine
== EM_MIPS
1043 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1045 /* In little-endian objects, r_info isn't really a
1046 64-bit little-endian value: it has a 32-bit
1047 little-endian symbol index followed by four
1048 individual byte fields. Reorder INFO
1050 bfd_vma inf
= rels
[i
].r_info
;
1051 inf
= (((inf
& 0xffffffff) << 32)
1052 | ((inf
>> 56) & 0xff)
1053 | ((inf
>> 40) & 0xff00)
1054 | ((inf
>> 24) & 0xff0000)
1055 | ((inf
>> 8) & 0xff000000));
1056 rels
[i
].r_info
= inf
;
1069 /* Returns the reloc type extracted from the reloc info field. */
1072 get_reloc_type (bfd_vma reloc_info
)
1075 return ELF32_R_TYPE (reloc_info
);
1077 switch (elf_header
.e_machine
)
1080 /* Note: We assume that reloc_info has already been adjusted for us. */
1081 return ELF64_MIPS_R_TYPE (reloc_info
);
1084 return ELF64_R_TYPE_ID (reloc_info
);
1087 return ELF64_R_TYPE (reloc_info
);
1091 /* Return the symbol index extracted from the reloc info field. */
1094 get_reloc_symindex (bfd_vma reloc_info
)
1096 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1099 static inline bfd_boolean
1100 uses_msp430x_relocs (void)
1103 elf_header
.e_machine
== EM_MSP430
/* Paranoia. */
1104 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1105 && (((elf_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1106 /* TI compiler uses ELFOSABI_NONE. */
1107 || (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1110 /* Display the contents of the relocation data found at the specified
1114 dump_relocations (FILE * file
,
1115 unsigned long rel_offset
,
1116 unsigned long rel_size
,
1117 Elf_Internal_Sym
* symtab
,
1118 unsigned long nsyms
,
1120 unsigned long strtablen
,
1122 bfd_boolean is_dynsym
)
1125 Elf_Internal_Rela
* rels
;
1126 bfd_boolean res
= TRUE
;
1128 if (is_rela
== UNKNOWN
)
1129 is_rela
= guess_is_rela (elf_header
.e_machine
);
1133 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1138 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1147 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1149 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1154 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1156 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1164 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1166 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1171 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1173 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1177 for (i
= 0; i
< rel_size
; i
++)
1182 bfd_vma symtab_index
;
1185 offset
= rels
[i
].r_offset
;
1186 inf
= rels
[i
].r_info
;
1188 type
= get_reloc_type (inf
);
1189 symtab_index
= get_reloc_symindex (inf
);
1193 printf ("%8.8lx %8.8lx ",
1194 (unsigned long) offset
& 0xffffffff,
1195 (unsigned long) inf
& 0xffffffff);
1199 #if BFD_HOST_64BIT_LONG
1201 ? "%16.16lx %16.16lx "
1202 : "%12.12lx %12.12lx ",
1204 #elif BFD_HOST_64BIT_LONG_LONG
1207 ? "%16.16llx %16.16llx "
1208 : "%12.12llx %12.12llx ",
1212 ? "%16.16I64x %16.16I64x "
1213 : "%12.12I64x %12.12I64x ",
1218 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1219 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1220 _bfd_int64_high (offset
),
1221 _bfd_int64_low (offset
),
1222 _bfd_int64_high (inf
),
1223 _bfd_int64_low (inf
));
1227 switch (elf_header
.e_machine
)
1234 rtype
= elf_aarch64_reloc_type (type
);
1238 case EM_CYGNUS_M32R
:
1239 rtype
= elf_m32r_reloc_type (type
);
1244 rtype
= elf_i386_reloc_type (type
);
1249 rtype
= elf_m68hc11_reloc_type (type
);
1253 rtype
= elf_m68k_reloc_type (type
);
1257 rtype
= elf_i960_reloc_type (type
);
1262 rtype
= elf_avr_reloc_type (type
);
1265 case EM_OLD_SPARCV9
:
1266 case EM_SPARC32PLUS
:
1269 rtype
= elf_sparc_reloc_type (type
);
1273 rtype
= elf_spu_reloc_type (type
);
1277 rtype
= v800_reloc_type (type
);
1280 case EM_CYGNUS_V850
:
1281 rtype
= v850_reloc_type (type
);
1285 case EM_CYGNUS_D10V
:
1286 rtype
= elf_d10v_reloc_type (type
);
1290 case EM_CYGNUS_D30V
:
1291 rtype
= elf_d30v_reloc_type (type
);
1295 rtype
= elf_dlx_reloc_type (type
);
1299 rtype
= elf_sh_reloc_type (type
);
1303 case EM_CYGNUS_MN10300
:
1304 rtype
= elf_mn10300_reloc_type (type
);
1308 case EM_CYGNUS_MN10200
:
1309 rtype
= elf_mn10200_reloc_type (type
);
1313 case EM_CYGNUS_FR30
:
1314 rtype
= elf_fr30_reloc_type (type
);
1318 rtype
= elf_frv_reloc_type (type
);
1322 rtype
= elf_ft32_reloc_type (type
);
1326 rtype
= elf_mcore_reloc_type (type
);
1330 rtype
= elf_mmix_reloc_type (type
);
1334 rtype
= elf_moxie_reloc_type (type
);
1338 if (uses_msp430x_relocs ())
1340 rtype
= elf_msp430x_reloc_type (type
);
1345 rtype
= elf_msp430_reloc_type (type
);
1349 rtype
= elf_nds32_reloc_type (type
);
1353 rtype
= elf_ppc_reloc_type (type
);
1357 rtype
= elf_ppc64_reloc_type (type
);
1361 case EM_MIPS_RS3_LE
:
1362 rtype
= elf_mips_reloc_type (type
);
1366 rtype
= elf_riscv_reloc_type (type
);
1370 rtype
= elf_alpha_reloc_type (type
);
1374 rtype
= elf_arm_reloc_type (type
);
1378 case EM_ARC_COMPACT
:
1379 case EM_ARC_COMPACT2
:
1380 rtype
= elf_arc_reloc_type (type
);
1384 rtype
= elf_hppa_reloc_type (type
);
1390 rtype
= elf_h8_reloc_type (type
);
1394 rtype
= elf_or1k_reloc_type (type
);
1399 rtype
= elf_pj_reloc_type (type
);
1402 rtype
= elf_ia64_reloc_type (type
);
1406 rtype
= elf_cris_reloc_type (type
);
1410 rtype
= elf_i860_reloc_type (type
);
1416 rtype
= elf_x86_64_reloc_type (type
);
1420 rtype
= i370_reloc_type (type
);
1425 rtype
= elf_s390_reloc_type (type
);
1429 rtype
= elf_score_reloc_type (type
);
1433 rtype
= elf_xstormy16_reloc_type (type
);
1437 rtype
= elf_crx_reloc_type (type
);
1441 rtype
= elf_vax_reloc_type (type
);
1445 rtype
= elf_visium_reloc_type (type
);
1448 case EM_ADAPTEVA_EPIPHANY
:
1449 rtype
= elf_epiphany_reloc_type (type
);
1454 rtype
= elf_ip2k_reloc_type (type
);
1458 rtype
= elf_iq2000_reloc_type (type
);
1463 rtype
= elf_xtensa_reloc_type (type
);
1466 case EM_LATTICEMICO32
:
1467 rtype
= elf_lm32_reloc_type (type
);
1472 rtype
= elf_m32c_reloc_type (type
);
1476 rtype
= elf_mt_reloc_type (type
);
1480 rtype
= elf_bfin_reloc_type (type
);
1484 rtype
= elf_mep_reloc_type (type
);
1488 rtype
= elf_cr16_reloc_type (type
);
1492 case EM_MICROBLAZE_OLD
:
1493 rtype
= elf_microblaze_reloc_type (type
);
1497 rtype
= elf_rl78_reloc_type (type
);
1501 rtype
= elf_rx_reloc_type (type
);
1505 rtype
= elf_metag_reloc_type (type
);
1510 rtype
= elf_xc16x_reloc_type (type
);
1514 rtype
= elf_tic6x_reloc_type (type
);
1518 rtype
= elf_tilegx_reloc_type (type
);
1522 rtype
= elf_tilepro_reloc_type (type
);
1525 case EM_WEBASSEMBLY
:
1526 rtype
= elf_wasm32_reloc_type (type
);
1530 rtype
= elf_xgate_reloc_type (type
);
1533 case EM_ALTERA_NIOS2
:
1534 rtype
= elf_nios2_reloc_type (type
);
1538 rtype
= elf_pru_reloc_type (type
);
1543 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1545 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
1547 if (elf_header
.e_machine
== EM_ALPHA
1549 && streq (rtype
, "R_ALPHA_LITUSE")
1552 switch (rels
[i
].r_addend
)
1554 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1555 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1556 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1557 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1558 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1559 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1560 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1561 default: rtype
= NULL
;
1565 printf (" (%s)", rtype
);
1569 printf (_("<unknown addend: %lx>"),
1570 (unsigned long) rels
[i
].r_addend
);
1574 else if (symtab_index
)
1576 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1578 error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index
);
1583 Elf_Internal_Sym
* psym
;
1584 const char * version_string
;
1585 enum versioned_symbol_info sym_info
;
1586 unsigned short vna_other
;
1588 psym
= symtab
+ symtab_index
;
1591 = get_symbol_version_string (file
, is_dynsym
,
1600 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1604 unsigned int width
= is_32bit_elf
? 8 : 14;
1606 /* Relocations against GNU_IFUNC symbols do not use the value
1607 of the symbol as the address to relocate against. Instead
1608 they invoke the function named by the symbol and use its
1609 result as the address for relocation.
1611 To indicate this to the user, do not display the value of
1612 the symbol in the "Symbols's Value" field. Instead show
1613 its name followed by () as a hint that the symbol is
1617 || psym
->st_name
== 0
1618 || psym
->st_name
>= strtablen
)
1621 name
= strtab
+ psym
->st_name
;
1623 len
= print_symbol (width
, name
);
1625 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1627 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1631 print_vma (psym
->st_value
, LONG_HEX
);
1633 printf (is_32bit_elf
? " " : " ");
1636 if (psym
->st_name
== 0)
1638 const char * sec_name
= "<null>";
1641 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1643 if (psym
->st_shndx
< elf_header
.e_shnum
)
1644 sec_name
= SECTION_NAME (section_headers
+ psym
->st_shndx
);
1645 else if (psym
->st_shndx
== SHN_ABS
)
1647 else if (psym
->st_shndx
== SHN_COMMON
)
1648 sec_name
= "COMMON";
1649 else if ((elf_header
.e_machine
== EM_MIPS
1650 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1651 || (elf_header
.e_machine
== EM_TI_C6000
1652 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1653 sec_name
= "SCOMMON";
1654 else if (elf_header
.e_machine
== EM_MIPS
1655 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1656 sec_name
= "SUNDEF";
1657 else if ((elf_header
.e_machine
== EM_X86_64
1658 || elf_header
.e_machine
== EM_L1OM
1659 || elf_header
.e_machine
== EM_K1OM
)
1660 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1661 sec_name
= "LARGE_COMMON";
1662 else if (elf_header
.e_machine
== EM_IA_64
1663 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1664 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1665 sec_name
= "ANSI_COM";
1666 else if (is_ia64_vms ()
1667 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1668 sec_name
= "VMS_SYMVEC";
1671 sprintf (name_buf
, "<section 0x%x>",
1672 (unsigned int) psym
->st_shndx
);
1673 sec_name
= name_buf
;
1676 print_symbol (22, sec_name
);
1678 else if (strtab
== NULL
)
1679 printf (_("<string table index: %3ld>"), psym
->st_name
);
1680 else if (psym
->st_name
>= strtablen
)
1682 error (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1687 print_symbol (22, strtab
+ psym
->st_name
);
1689 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1695 bfd_vma off
= rels
[i
].r_addend
;
1697 if ((bfd_signed_vma
) off
< 0)
1698 printf (" - %" BFD_VMA_FMT
"x", - off
);
1700 printf (" + %" BFD_VMA_FMT
"x", off
);
1706 bfd_vma off
= rels
[i
].r_addend
;
1708 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1709 if ((bfd_signed_vma
) off
< 0)
1710 printf ("-%" BFD_VMA_FMT
"x", - off
);
1712 printf ("%" BFD_VMA_FMT
"x", off
);
1715 if (elf_header
.e_machine
== EM_SPARCV9
1717 && streq (rtype
, "R_SPARC_OLO10"))
1718 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1723 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1725 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1726 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1727 const char * rtype2
= elf_mips_reloc_type (type2
);
1728 const char * rtype3
= elf_mips_reloc_type (type3
);
1730 printf (" Type2: ");
1733 printf (_("unrecognized: %-7lx"),
1734 (unsigned long) type2
& 0xffffffff);
1736 printf ("%-17.17s", rtype2
);
1738 printf ("\n Type3: ");
1741 printf (_("unrecognized: %-7lx"),
1742 (unsigned long) type3
& 0xffffffff);
1744 printf ("%-17.17s", rtype3
);
1757 get_mips_dynamic_type (unsigned long type
)
1761 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1762 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1763 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1764 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1765 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1766 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1767 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1768 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1769 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1770 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1771 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1772 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1773 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1774 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1775 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1776 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1777 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1778 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1779 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1780 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1781 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1782 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1783 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1784 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1785 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1786 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1787 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1788 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1789 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1790 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1791 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1792 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1793 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1794 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1795 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1796 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1797 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1798 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1799 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1800 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1801 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1802 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1803 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1804 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1805 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1806 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1813 get_sparc64_dynamic_type (unsigned long type
)
1817 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1824 get_ppc_dynamic_type (unsigned long type
)
1828 case DT_PPC_GOT
: return "PPC_GOT";
1829 case DT_PPC_OPT
: return "PPC_OPT";
1836 get_ppc64_dynamic_type (unsigned long type
)
1840 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1841 case DT_PPC64_OPD
: return "PPC64_OPD";
1842 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1843 case DT_PPC64_OPT
: return "PPC64_OPT";
1850 get_parisc_dynamic_type (unsigned long type
)
1854 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1855 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1856 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1857 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1858 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1859 case DT_HP_PREINIT
: return "HP_PREINIT";
1860 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1861 case DT_HP_NEEDED
: return "HP_NEEDED";
1862 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1863 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1864 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1865 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1866 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1867 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1868 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1869 case DT_HP_FILTERED
: return "HP_FILTERED";
1870 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1871 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1872 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1873 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1874 case DT_PLT
: return "PLT";
1875 case DT_PLT_SIZE
: return "PLT_SIZE";
1876 case DT_DLT
: return "DLT";
1877 case DT_DLT_SIZE
: return "DLT_SIZE";
1884 get_ia64_dynamic_type (unsigned long type
)
1888 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1889 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1890 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1891 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1892 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1893 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1894 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1895 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1896 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1897 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1898 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1899 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1900 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1901 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1902 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1903 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1904 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1905 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1906 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1907 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1908 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1909 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1910 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1911 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1912 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1913 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1914 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1915 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1916 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1917 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1918 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1925 get_solaris_section_type (unsigned long type
)
1929 case 0x6fffffee: return "SUNW_ancillary";
1930 case 0x6fffffef: return "SUNW_capchain";
1931 case 0x6ffffff0: return "SUNW_capinfo";
1932 case 0x6ffffff1: return "SUNW_symsort";
1933 case 0x6ffffff2: return "SUNW_tlssort";
1934 case 0x6ffffff3: return "SUNW_LDYNSYM";
1935 case 0x6ffffff4: return "SUNW_dof";
1936 case 0x6ffffff5: return "SUNW_cap";
1937 case 0x6ffffff6: return "SUNW_SIGNATURE";
1938 case 0x6ffffff7: return "SUNW_ANNOTATE";
1939 case 0x6ffffff8: return "SUNW_DEBUGSTR";
1940 case 0x6ffffff9: return "SUNW_DEBUG";
1941 case 0x6ffffffa: return "SUNW_move";
1942 case 0x6ffffffb: return "SUNW_COMDAT";
1943 case 0x6ffffffc: return "SUNW_syminfo";
1944 case 0x6ffffffd: return "SUNW_verdef";
1945 case 0x6ffffffe: return "SUNW_verneed";
1946 case 0x6fffffff: return "SUNW_versym";
1947 case 0x70000000: return "SPARC_GOTDATA";
1948 default: return NULL
;
1953 get_alpha_dynamic_type (unsigned long type
)
1957 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1958 default: return NULL
;
1963 get_score_dynamic_type (unsigned long type
)
1967 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1968 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1969 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1970 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1971 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1972 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1973 default: return NULL
;
1978 get_tic6x_dynamic_type (unsigned long type
)
1982 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1983 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1984 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1985 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1986 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1987 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1988 default: return NULL
;
1993 get_nios2_dynamic_type (unsigned long type
)
1997 case DT_NIOS2_GP
: return "NIOS2_GP";
1998 default: return NULL
;
2003 get_solaris_dynamic_type (unsigned long type
)
2007 case 0x6000000d: return "SUNW_AUXILIARY";
2008 case 0x6000000e: return "SUNW_RTLDINF";
2009 case 0x6000000f: return "SUNW_FILTER";
2010 case 0x60000010: return "SUNW_CAP";
2011 case 0x60000011: return "SUNW_SYMTAB";
2012 case 0x60000012: return "SUNW_SYMSZ";
2013 case 0x60000013: return "SUNW_SORTENT";
2014 case 0x60000014: return "SUNW_SYMSORT";
2015 case 0x60000015: return "SUNW_SYMSORTSZ";
2016 case 0x60000016: return "SUNW_TLSSORT";
2017 case 0x60000017: return "SUNW_TLSSORTSZ";
2018 case 0x60000018: return "SUNW_CAPINFO";
2019 case 0x60000019: return "SUNW_STRPAD";
2020 case 0x6000001a: return "SUNW_CAPCHAIN";
2021 case 0x6000001b: return "SUNW_LDMACH";
2022 case 0x6000001d: return "SUNW_CAPCHAINENT";
2023 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2024 case 0x60000021: return "SUNW_PARENT";
2025 case 0x60000023: return "SUNW_ASLR";
2026 case 0x60000025: return "SUNW_RELAX";
2027 case 0x60000029: return "SUNW_NXHEAP";
2028 case 0x6000002b: return "SUNW_NXSTACK";
2030 case 0x70000001: return "SPARC_REGISTER";
2031 case 0x7ffffffd: return "AUXILIARY";
2032 case 0x7ffffffe: return "USED";
2033 case 0x7fffffff: return "FILTER";
2035 default: return NULL
;
2040 get_dynamic_type (unsigned long type
)
2042 static char buff
[64];
2046 case DT_NULL
: return "NULL";
2047 case DT_NEEDED
: return "NEEDED";
2048 case DT_PLTRELSZ
: return "PLTRELSZ";
2049 case DT_PLTGOT
: return "PLTGOT";
2050 case DT_HASH
: return "HASH";
2051 case DT_STRTAB
: return "STRTAB";
2052 case DT_SYMTAB
: return "SYMTAB";
2053 case DT_RELA
: return "RELA";
2054 case DT_RELASZ
: return "RELASZ";
2055 case DT_RELAENT
: return "RELAENT";
2056 case DT_STRSZ
: return "STRSZ";
2057 case DT_SYMENT
: return "SYMENT";
2058 case DT_INIT
: return "INIT";
2059 case DT_FINI
: return "FINI";
2060 case DT_SONAME
: return "SONAME";
2061 case DT_RPATH
: return "RPATH";
2062 case DT_SYMBOLIC
: return "SYMBOLIC";
2063 case DT_REL
: return "REL";
2064 case DT_RELSZ
: return "RELSZ";
2065 case DT_RELENT
: return "RELENT";
2066 case DT_PLTREL
: return "PLTREL";
2067 case DT_DEBUG
: return "DEBUG";
2068 case DT_TEXTREL
: return "TEXTREL";
2069 case DT_JMPREL
: return "JMPREL";
2070 case DT_BIND_NOW
: return "BIND_NOW";
2071 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2072 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2073 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2074 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2075 case DT_RUNPATH
: return "RUNPATH";
2076 case DT_FLAGS
: return "FLAGS";
2078 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2079 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2080 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2082 case DT_CHECKSUM
: return "CHECKSUM";
2083 case DT_PLTPADSZ
: return "PLTPADSZ";
2084 case DT_MOVEENT
: return "MOVEENT";
2085 case DT_MOVESZ
: return "MOVESZ";
2086 case DT_FEATURE
: return "FEATURE";
2087 case DT_POSFLAG_1
: return "POSFLAG_1";
2088 case DT_SYMINSZ
: return "SYMINSZ";
2089 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2091 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2092 case DT_CONFIG
: return "CONFIG";
2093 case DT_DEPAUDIT
: return "DEPAUDIT";
2094 case DT_AUDIT
: return "AUDIT";
2095 case DT_PLTPAD
: return "PLTPAD";
2096 case DT_MOVETAB
: return "MOVETAB";
2097 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2099 case DT_VERSYM
: return "VERSYM";
2101 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2102 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2103 case DT_RELACOUNT
: return "RELACOUNT";
2104 case DT_RELCOUNT
: return "RELCOUNT";
2105 case DT_FLAGS_1
: return "FLAGS_1";
2106 case DT_VERDEF
: return "VERDEF";
2107 case DT_VERDEFNUM
: return "VERDEFNUM";
2108 case DT_VERNEED
: return "VERNEED";
2109 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2111 case DT_AUXILIARY
: return "AUXILIARY";
2112 case DT_USED
: return "USED";
2113 case DT_FILTER
: return "FILTER";
2115 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2116 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2117 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2118 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2119 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2120 case DT_GNU_HASH
: return "GNU_HASH";
2123 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2125 const char * result
;
2127 switch (elf_header
.e_machine
)
2130 case EM_MIPS_RS3_LE
:
2131 result
= get_mips_dynamic_type (type
);
2134 result
= get_sparc64_dynamic_type (type
);
2137 result
= get_ppc_dynamic_type (type
);
2140 result
= get_ppc64_dynamic_type (type
);
2143 result
= get_ia64_dynamic_type (type
);
2146 result
= get_alpha_dynamic_type (type
);
2149 result
= get_score_dynamic_type (type
);
2152 result
= get_tic6x_dynamic_type (type
);
2154 case EM_ALTERA_NIOS2
:
2155 result
= get_nios2_dynamic_type (type
);
2158 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2159 result
= get_solaris_dynamic_type (type
);
2168 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2170 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2171 || (elf_header
.e_machine
== EM_PARISC
2172 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2174 const char * result
;
2176 switch (elf_header
.e_machine
)
2179 result
= get_parisc_dynamic_type (type
);
2182 result
= get_ia64_dynamic_type (type
);
2185 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2186 result
= get_solaris_dynamic_type (type
);
2195 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2199 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2206 get_file_type (unsigned e_type
)
2208 static char buff
[32];
2212 case ET_NONE
: return _("NONE (None)");
2213 case ET_REL
: return _("REL (Relocatable file)");
2214 case ET_EXEC
: return _("EXEC (Executable file)");
2215 case ET_DYN
: return _("DYN (Shared object file)");
2216 case ET_CORE
: return _("CORE (Core file)");
2219 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2220 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2221 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2222 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2224 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2230 get_machine_name (unsigned e_machine
)
2232 static char buff
[64]; /* XXX */
2236 /* Please keep this switch table sorted by increasing EM_ value. */
2238 case EM_NONE
: return _("None");
2239 case EM_M32
: return "WE32100";
2240 case EM_SPARC
: return "Sparc";
2241 case EM_386
: return "Intel 80386";
2242 case EM_68K
: return "MC68000";
2243 case EM_88K
: return "MC88000";
2244 case EM_IAMCU
: return "Intel MCU";
2245 case EM_860
: return "Intel 80860";
2246 case EM_MIPS
: return "MIPS R3000";
2247 case EM_S370
: return "IBM System/370";
2249 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2250 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2251 case EM_PARISC
: return "HPPA";
2252 case EM_VPP550
: return "Fujitsu VPP500";
2253 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2254 case EM_960
: return "Intel 90860";
2255 case EM_PPC
: return "PowerPC";
2257 case EM_PPC64
: return "PowerPC64";
2259 case EM_S390
: return "IBM S/390";
2260 case EM_SPU
: return "SPU";
2262 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2263 case EM_FR20
: return "Fujitsu FR20";
2264 case EM_RH32
: return "TRW RH32";
2265 case EM_MCORE
: return "MCORE";
2267 case EM_ARM
: return "ARM";
2268 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2269 case EM_SH
: return "Renesas / SuperH SH";
2270 case EM_SPARCV9
: return "Sparc v9";
2271 case EM_TRICORE
: return "Siemens Tricore";
2272 case EM_ARC
: return "ARC";
2273 case EM_H8_300
: return "Renesas H8/300";
2274 case EM_H8_300H
: return "Renesas H8/300H";
2275 case EM_H8S
: return "Renesas H8S";
2276 case EM_H8_500
: return "Renesas H8/500";
2278 case EM_IA_64
: return "Intel IA-64";
2279 case EM_MIPS_X
: return "Stanford MIPS-X";
2280 case EM_COLDFIRE
: return "Motorola Coldfire";
2281 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2282 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2283 case EM_PCP
: return "Siemens PCP";
2284 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2285 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2286 case EM_STARCORE
: return "Motorola Star*Core processor";
2287 case EM_ME16
: return "Toyota ME16 processor";
2289 case EM_ST100
: return "STMicroelectronics ST100 processor";
2290 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2291 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2292 case EM_PDSP
: return "Sony DSP processor";
2293 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2294 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2295 case EM_FX66
: return "Siemens FX66 microcontroller";
2296 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2297 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2298 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2300 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2301 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2302 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2303 case EM_SVX
: return "Silicon Graphics SVx";
2304 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2305 case EM_VAX
: return "Digital VAX";
2306 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2307 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2308 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2309 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2311 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2312 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2313 case EM_PRISM
: return "Vitesse Prism";
2315 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2316 case EM_CYGNUS_FR30
:
2317 case EM_FR30
: return "Fujitsu FR30";
2318 case EM_CYGNUS_D10V
:
2319 case EM_D10V
: return "d10v";
2320 case EM_CYGNUS_D30V
:
2321 case EM_D30V
: return "d30v";
2322 case EM_CYGNUS_V850
:
2323 case EM_V850
: return "Renesas V850";
2324 case EM_CYGNUS_M32R
:
2325 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2326 case EM_CYGNUS_MN10300
:
2327 case EM_MN10300
: return "mn10300";
2329 case EM_CYGNUS_MN10200
:
2330 case EM_MN10200
: return "mn10200";
2331 case EM_PJ
: return "picoJava";
2332 case EM_OR1K
: return "OpenRISC 1000";
2333 case EM_ARC_COMPACT
: return "ARCompact";
2335 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2336 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2337 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2338 case EM_NS32K
: return "National Semiconductor 32000 series";
2339 case EM_TPC
: return "Tenor Network TPC processor";
2340 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2342 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2344 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2345 case EM_MAX
: return "MAX Processor";
2346 case EM_CR
: return "National Semiconductor CompactRISC";
2347 case EM_F2MC16
: return "Fujitsu F2MC16";
2348 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2349 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2350 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2351 case EM_SEP
: return "Sharp embedded microprocessor";
2352 case EM_ARCA
: return "Arca RISC microprocessor";
2354 case EM_UNICORE
: return "Unicore";
2355 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2356 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2357 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2358 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2359 case EM_XGATE
: return "Motorola XGATE embedded processor";
2361 case EM_XC16X
: return "Infineon Technologies xc16x";
2362 case EM_M16C
: return "Renesas M16C series microprocessors";
2363 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2364 case EM_CE
: return "Freescale Communication Engine RISC core";
2366 case EM_M32C
: return "Renesas M32c";
2368 case EM_TSK3000
: return "Altium TSK3000 core";
2369 case EM_RS08
: return "Freescale RS08 embedded processor";
2370 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2371 case EM_SCORE
: return "SUNPLUS S+Core";
2372 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2373 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2374 case EM_LATTICEMICO32
: return "Lattice Mico32";
2375 case EM_SE_C17
: return "Seiko Epson C17 family";
2377 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2378 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2379 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2380 case EM_TI_PRU
: return "TI PRU I/O processor";
2382 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2383 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2384 case EM_R32C
: return "Renesas R32C series microprocessors";
2385 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2386 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2387 case EM_8051
: return "Intel 8051 and variants";
2388 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2389 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2390 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2391 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2393 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2394 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2395 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2396 case EM_RX
: return "Renesas RX";
2397 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2398 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2399 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2402 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2403 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2404 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2406 case EM_L1OM
: return "Intel L1OM";
2407 case EM_K1OM
: return "Intel K1OM";
2408 case EM_INTEL182
: return "Intel (reserved)";
2409 case EM_AARCH64
: return "AArch64";
2410 case EM_ARM184
: return "ARM (reserved)";
2411 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2412 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2413 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2414 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2416 case EM_CUDA
: return "NVIDIA CUDA architecture";
2417 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2418 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2419 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2420 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2421 case EM_ARC_COMPACT2
: return "ARCv2";
2422 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2423 case EM_RL78
: return "Renesas RL78";
2424 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2425 case EM_78K0R
: return "Renesas 78K0R";
2427 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2428 case EM_BA1
: return "Beyond BA1 CPU architecture";
2429 case EM_BA2
: return "Beyond BA2 CPU architecture";
2430 case EM_XCORE
: return "XMOS xCORE processor family";
2431 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2433 case EM_KM32
: return "KM211 KM32 32-bit processor";
2434 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2435 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2436 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2437 case EM_KVARC
: return "KM211 KVARC processor";
2438 case EM_CDP
: return "Paneve CDP architecture family";
2439 case EM_COGE
: return "Cognitive Smart Memory Processor";
2440 case EM_COOL
: return "Bluechip Systems CoolEngine";
2441 case EM_NORC
: return "Nanoradio Optimized RISC";
2442 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2444 case EM_Z80
: return "Zilog Z80";
2445 case EM_VISIUM
: return "CDS VISIUMcore processor";
2446 case EM_FT32
: return "FTDI Chip FT32";
2447 case EM_MOXIE
: return "Moxie";
2448 case EM_AMDGPU
: return "AMD GPU";
2449 case EM_RISCV
: return "RISC-V";
2450 case EM_LANAI
: return "Lanai 32-bit processor";
2451 case EM_BPF
: return "Linux BPF";
2453 /* Large numbers... */
2454 case EM_MT
: return "Morpho Techologies MT processor";
2455 case EM_ALPHA
: return "Alpha";
2456 case EM_WEBASSEMBLY
: return "Web Assembly";
2457 case EM_DLX
: return "OpenDLX";
2458 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2459 case EM_IQ2000
: return "Vitesse IQ2000";
2461 case EM_NIOS32
: return "Altera Nios";
2462 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2463 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2464 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2467 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2473 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2475 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2476 other compilers don't a specific architecture type in the e_flags, and
2477 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2478 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2481 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2482 but also sets a specific architecture type in the e_flags field.
2484 However, when decoding the flags we don't worry if we see an
2485 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2486 ARCEM architecture type. */
2488 switch (e_flags
& EF_ARC_MACH_MSK
)
2490 /* We only expect these to occur for EM_ARC_COMPACT2. */
2491 case EF_ARC_CPU_ARCV2EM
:
2492 strcat (buf
, ", ARC EM");
2494 case EF_ARC_CPU_ARCV2HS
:
2495 strcat (buf
, ", ARC HS");
2498 /* We only expect these to occur for EM_ARC_COMPACT. */
2499 case E_ARC_MACH_ARC600
:
2500 strcat (buf
, ", ARC600");
2502 case E_ARC_MACH_ARC601
:
2503 strcat (buf
, ", ARC601");
2505 case E_ARC_MACH_ARC700
:
2506 strcat (buf
, ", ARC700");
2509 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2510 new ELF with new architecture being read by an old version of
2511 readelf, or (c) An ELF built with non-GNU compiler that does not
2512 set the architecture in the e_flags. */
2514 if (e_machine
== EM_ARC_COMPACT
)
2515 strcat (buf
, ", Unknown ARCompact");
2517 strcat (buf
, ", Unknown ARC");
2521 switch (e_flags
& EF_ARC_OSABI_MSK
)
2523 case E_ARC_OSABI_ORIG
:
2524 strcat (buf
, ", (ABI:legacy)");
2526 case E_ARC_OSABI_V2
:
2527 strcat (buf
, ", (ABI:v2)");
2529 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2530 case E_ARC_OSABI_V3
:
2531 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2533 case E_ARC_OSABI_V4
:
2534 strcat (buf
, ", v4 ABI");
2537 strcat (buf
, ", unrecognised ARC OSABI flag");
2543 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2546 bfd_boolean unknown
= FALSE
;
2548 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2549 e_flags
&= ~ EF_ARM_EABIMASK
;
2551 /* Handle "generic" ARM flags. */
2552 if (e_flags
& EF_ARM_RELEXEC
)
2554 strcat (buf
, ", relocatable executable");
2555 e_flags
&= ~ EF_ARM_RELEXEC
;
2558 /* Now handle EABI specific flags. */
2562 strcat (buf
, ", <unrecognized EABI>");
2567 case EF_ARM_EABI_VER1
:
2568 strcat (buf
, ", Version1 EABI");
2573 /* Process flags one bit at a time. */
2574 flag
= e_flags
& - e_flags
;
2579 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2580 strcat (buf
, ", sorted symbol tables");
2590 case EF_ARM_EABI_VER2
:
2591 strcat (buf
, ", Version2 EABI");
2596 /* Process flags one bit at a time. */
2597 flag
= e_flags
& - e_flags
;
2602 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2603 strcat (buf
, ", sorted symbol tables");
2606 case EF_ARM_DYNSYMSUSESEGIDX
:
2607 strcat (buf
, ", dynamic symbols use segment index");
2610 case EF_ARM_MAPSYMSFIRST
:
2611 strcat (buf
, ", mapping symbols precede others");
2621 case EF_ARM_EABI_VER3
:
2622 strcat (buf
, ", Version3 EABI");
2625 case EF_ARM_EABI_VER4
:
2626 strcat (buf
, ", Version4 EABI");
2631 /* Process flags one bit at a time. */
2632 flag
= e_flags
& - e_flags
;
2638 strcat (buf
, ", BE8");
2642 strcat (buf
, ", LE8");
2652 case EF_ARM_EABI_VER5
:
2653 strcat (buf
, ", Version5 EABI");
2658 /* Process flags one bit at a time. */
2659 flag
= e_flags
& - e_flags
;
2665 strcat (buf
, ", BE8");
2669 strcat (buf
, ", LE8");
2672 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2673 strcat (buf
, ", soft-float ABI");
2676 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2677 strcat (buf
, ", hard-float ABI");
2687 case EF_ARM_EABI_UNKNOWN
:
2688 strcat (buf
, ", GNU EABI");
2693 /* Process flags one bit at a time. */
2694 flag
= e_flags
& - e_flags
;
2699 case EF_ARM_INTERWORK
:
2700 strcat (buf
, ", interworking enabled");
2703 case EF_ARM_APCS_26
:
2704 strcat (buf
, ", uses APCS/26");
2707 case EF_ARM_APCS_FLOAT
:
2708 strcat (buf
, ", uses APCS/float");
2712 strcat (buf
, ", position independent");
2716 strcat (buf
, ", 8 bit structure alignment");
2719 case EF_ARM_NEW_ABI
:
2720 strcat (buf
, ", uses new ABI");
2723 case EF_ARM_OLD_ABI
:
2724 strcat (buf
, ", uses old ABI");
2727 case EF_ARM_SOFT_FLOAT
:
2728 strcat (buf
, ", software FP");
2731 case EF_ARM_VFP_FLOAT
:
2732 strcat (buf
, ", VFP");
2735 case EF_ARM_MAVERICK_FLOAT
:
2736 strcat (buf
, ", Maverick FP");
2747 strcat (buf
,_(", <unknown>"));
2751 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2753 --size
; /* Leave space for null terminator. */
2755 switch (e_flags
& EF_AVR_MACH
)
2757 case E_AVR_MACH_AVR1
:
2758 strncat (buf
, ", avr:1", size
);
2760 case E_AVR_MACH_AVR2
:
2761 strncat (buf
, ", avr:2", size
);
2763 case E_AVR_MACH_AVR25
:
2764 strncat (buf
, ", avr:25", size
);
2766 case E_AVR_MACH_AVR3
:
2767 strncat (buf
, ", avr:3", size
);
2769 case E_AVR_MACH_AVR31
:
2770 strncat (buf
, ", avr:31", size
);
2772 case E_AVR_MACH_AVR35
:
2773 strncat (buf
, ", avr:35", size
);
2775 case E_AVR_MACH_AVR4
:
2776 strncat (buf
, ", avr:4", size
);
2778 case E_AVR_MACH_AVR5
:
2779 strncat (buf
, ", avr:5", size
);
2781 case E_AVR_MACH_AVR51
:
2782 strncat (buf
, ", avr:51", size
);
2784 case E_AVR_MACH_AVR6
:
2785 strncat (buf
, ", avr:6", size
);
2787 case E_AVR_MACH_AVRTINY
:
2788 strncat (buf
, ", avr:100", size
);
2790 case E_AVR_MACH_XMEGA1
:
2791 strncat (buf
, ", avr:101", size
);
2793 case E_AVR_MACH_XMEGA2
:
2794 strncat (buf
, ", avr:102", size
);
2796 case E_AVR_MACH_XMEGA3
:
2797 strncat (buf
, ", avr:103", size
);
2799 case E_AVR_MACH_XMEGA4
:
2800 strncat (buf
, ", avr:104", size
);
2802 case E_AVR_MACH_XMEGA5
:
2803 strncat (buf
, ", avr:105", size
);
2805 case E_AVR_MACH_XMEGA6
:
2806 strncat (buf
, ", avr:106", size
);
2808 case E_AVR_MACH_XMEGA7
:
2809 strncat (buf
, ", avr:107", size
);
2812 strncat (buf
, ", avr:<unknown>", size
);
2816 size
-= strlen (buf
);
2817 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2818 strncat (buf
, ", link-relax", size
);
2822 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2828 bfd_boolean has_fpu
= FALSE
;
2831 static const char *ABI_STRINGS
[] =
2833 "ABI v0", /* use r5 as return register; only used in N1213HC */
2834 "ABI v1", /* use r0 as return register */
2835 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2836 "ABI v2fp", /* for FPU */
2840 static const char *VER_STRINGS
[] =
2842 "Andes ELF V1.3 or older",
2846 static const char *ARCH_STRINGS
[] =
2855 abi
= EF_NDS_ABI
& e_flags
;
2856 arch
= EF_NDS_ARCH
& e_flags
;
2857 config
= EF_NDS_INST
& e_flags
;
2858 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2860 memset (buf
, 0, size
);
2867 case E_NDS_ABI_V2FP
:
2868 case E_NDS_ABI_AABI
:
2869 case E_NDS_ABI_V2FP_PLUS
:
2870 /* In case there are holes in the array. */
2871 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2875 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2881 case E_NDS32_ELF_VER_1_2
:
2882 case E_NDS32_ELF_VER_1_3
:
2883 case E_NDS32_ELF_VER_1_4
:
2884 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2888 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2892 if (E_NDS_ABI_V0
== abi
)
2894 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2895 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2896 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2897 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2903 case E_NDS_ARCH_STAR_V1_0
:
2904 case E_NDS_ARCH_STAR_V2_0
:
2905 case E_NDS_ARCH_STAR_V3_0
:
2906 case E_NDS_ARCH_STAR_V3_M
:
2907 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2911 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2912 /* ARCH version determines how the e_flags are interpreted.
2913 If it is unknown, we cannot proceed. */
2917 /* Newer ABI; Now handle architecture specific flags. */
2918 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2920 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2921 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2923 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2924 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2926 if (config
& E_NDS32_HAS_DIV_INST
)
2927 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2929 if (config
& E_NDS32_HAS_16BIT_INST
)
2930 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2934 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2936 if (version
<= E_NDS32_ELF_VER_1_3
)
2937 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2939 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2942 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2943 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2945 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2946 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2948 if (config
& E_NDS32_HAS_16BIT_INST
)
2950 if (version
<= E_NDS32_ELF_VER_1_3
)
2951 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2953 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2957 if (config
& E_NDS32_HAS_EXT_INST
)
2958 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2960 if (config
& E_NDS32_HAS_EXT2_INST
)
2961 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2963 if (config
& E_NDS32_HAS_FPU_INST
)
2966 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2969 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2972 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2975 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2978 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2983 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2985 case E_NDS32_FPU_REG_8SP_4DP
:
2986 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2988 case E_NDS32_FPU_REG_16SP_8DP
:
2989 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2991 case E_NDS32_FPU_REG_32SP_16DP
:
2992 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2994 case E_NDS32_FPU_REG_32SP_32DP
:
2995 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3000 if (config
& E_NDS32_HAS_AUDIO_INST
)
3001 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3003 if (config
& E_NDS32_HAS_STRING_INST
)
3004 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3006 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3007 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3009 if (config
& E_NDS32_HAS_VIDEO_INST
)
3011 if (version
<= E_NDS32_ELF_VER_1_3
)
3012 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3014 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3017 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3018 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3020 if (config
& E_NDS32_HAS_L2C_INST
)
3021 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3025 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
3027 static char buf
[1024];
3038 case EM_ARC_COMPACT2
:
3039 case EM_ARC_COMPACT
:
3040 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3044 decode_ARM_machine_flags (e_flags
, buf
);
3048 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3052 if (e_flags
& EF_BFIN_PIC
)
3053 strcat (buf
, ", PIC");
3055 if (e_flags
& EF_BFIN_FDPIC
)
3056 strcat (buf
, ", FDPIC");
3058 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3059 strcat (buf
, ", code in L1");
3061 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3062 strcat (buf
, ", data in L1");
3067 switch (e_flags
& EF_FRV_CPU_MASK
)
3069 case EF_FRV_CPU_GENERIC
:
3073 strcat (buf
, ", fr???");
3076 case EF_FRV_CPU_FR300
:
3077 strcat (buf
, ", fr300");
3080 case EF_FRV_CPU_FR400
:
3081 strcat (buf
, ", fr400");
3083 case EF_FRV_CPU_FR405
:
3084 strcat (buf
, ", fr405");
3087 case EF_FRV_CPU_FR450
:
3088 strcat (buf
, ", fr450");
3091 case EF_FRV_CPU_FR500
:
3092 strcat (buf
, ", fr500");
3094 case EF_FRV_CPU_FR550
:
3095 strcat (buf
, ", fr550");
3098 case EF_FRV_CPU_SIMPLE
:
3099 strcat (buf
, ", simple");
3101 case EF_FRV_CPU_TOMCAT
:
3102 strcat (buf
, ", tomcat");
3108 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3109 strcat (buf
, ", m68000");
3110 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3111 strcat (buf
, ", cpu32");
3112 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3113 strcat (buf
, ", fido_a");
3116 char const * isa
= _("unknown");
3117 char const * mac
= _("unknown mac");
3118 char const * additional
= NULL
;
3120 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3122 case EF_M68K_CF_ISA_A_NODIV
:
3124 additional
= ", nodiv";
3126 case EF_M68K_CF_ISA_A
:
3129 case EF_M68K_CF_ISA_A_PLUS
:
3132 case EF_M68K_CF_ISA_B_NOUSP
:
3134 additional
= ", nousp";
3136 case EF_M68K_CF_ISA_B
:
3139 case EF_M68K_CF_ISA_C
:
3142 case EF_M68K_CF_ISA_C_NODIV
:
3144 additional
= ", nodiv";
3147 strcat (buf
, ", cf, isa ");
3150 strcat (buf
, additional
);
3151 if (e_flags
& EF_M68K_CF_FLOAT
)
3152 strcat (buf
, ", float");
3153 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3158 case EF_M68K_CF_MAC
:
3161 case EF_M68K_CF_EMAC
:
3164 case EF_M68K_CF_EMAC_B
:
3177 switch (e_flags
& EF_MEP_CPU_MASK
)
3179 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3180 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3181 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3182 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3183 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3184 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3185 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3188 switch (e_flags
& EF_MEP_COP_MASK
)
3190 case EF_MEP_COP_NONE
: break;
3191 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3192 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3193 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3194 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3195 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3198 if (e_flags
& EF_MEP_LIBRARY
)
3199 strcat (buf
, ", Built for Library");
3201 if (e_flags
& EF_MEP_INDEX_MASK
)
3202 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3203 e_flags
& EF_MEP_INDEX_MASK
);
3205 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3206 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3207 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3211 if (e_flags
& EF_PPC_EMB
)
3212 strcat (buf
, ", emb");
3214 if (e_flags
& EF_PPC_RELOCATABLE
)
3215 strcat (buf
, _(", relocatable"));
3217 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3218 strcat (buf
, _(", relocatable-lib"));
3222 if (e_flags
& EF_PPC64_ABI
)
3224 char abi
[] = ", abiv0";
3226 abi
[6] += e_flags
& EF_PPC64_ABI
;
3232 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3233 strcat (buf
, ", RH850 ABI");
3235 if (e_flags
& EF_V800_850E3
)
3236 strcat (buf
, ", V3 architecture");
3238 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3239 strcat (buf
, ", FPU not used");
3241 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3242 strcat (buf
, ", regmode: COMMON");
3244 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3245 strcat (buf
, ", r4 not used");
3247 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3248 strcat (buf
, ", r30 not used");
3250 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3251 strcat (buf
, ", r5 not used");
3253 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3254 strcat (buf
, ", r2 not used");
3256 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3258 switch (e_flags
& - e_flags
)
3260 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3261 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3262 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3263 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3264 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3265 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3266 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3267 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3268 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3269 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3270 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3271 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3278 case EM_CYGNUS_V850
:
3279 switch (e_flags
& EF_V850_ARCH
)
3281 case E_V850E3V5_ARCH
:
3282 strcat (buf
, ", v850e3v5");
3284 case E_V850E2V3_ARCH
:
3285 strcat (buf
, ", v850e2v3");
3288 strcat (buf
, ", v850e2");
3291 strcat (buf
, ", v850e1");
3294 strcat (buf
, ", v850e");
3297 strcat (buf
, ", v850");
3300 strcat (buf
, _(", unknown v850 architecture variant"));
3306 case EM_CYGNUS_M32R
:
3307 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3308 strcat (buf
, ", m32r");
3312 case EM_MIPS_RS3_LE
:
3313 if (e_flags
& EF_MIPS_NOREORDER
)
3314 strcat (buf
, ", noreorder");
3316 if (e_flags
& EF_MIPS_PIC
)
3317 strcat (buf
, ", pic");
3319 if (e_flags
& EF_MIPS_CPIC
)
3320 strcat (buf
, ", cpic");
3322 if (e_flags
& EF_MIPS_UCODE
)
3323 strcat (buf
, ", ugen_reserved");
3325 if (e_flags
& EF_MIPS_ABI2
)
3326 strcat (buf
, ", abi2");
3328 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3329 strcat (buf
, ", odk first");
3331 if (e_flags
& EF_MIPS_32BITMODE
)
3332 strcat (buf
, ", 32bitmode");
3334 if (e_flags
& EF_MIPS_NAN2008
)
3335 strcat (buf
, ", nan2008");
3337 if (e_flags
& EF_MIPS_FP64
)
3338 strcat (buf
, ", fp64");
3340 switch ((e_flags
& EF_MIPS_MACH
))
3342 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3343 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3344 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3345 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3346 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3347 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3348 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3349 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3350 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
3351 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3352 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3353 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3354 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3355 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3356 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3357 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3358 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3359 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3360 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3362 /* We simply ignore the field in this case to avoid confusion:
3363 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3366 default: strcat (buf
, _(", unknown CPU")); break;
3369 switch ((e_flags
& EF_MIPS_ABI
))
3371 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3372 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3373 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3374 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3376 /* We simply ignore the field in this case to avoid confusion:
3377 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3378 This means it is likely to be an o32 file, but not for
3381 default: strcat (buf
, _(", unknown ABI")); break;
3384 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3385 strcat (buf
, ", mdmx");
3387 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3388 strcat (buf
, ", mips16");
3390 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3391 strcat (buf
, ", micromips");
3393 switch ((e_flags
& EF_MIPS_ARCH
))
3395 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3396 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3397 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3398 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3399 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3400 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3401 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3402 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3403 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3404 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3405 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3406 default: strcat (buf
, _(", unknown ISA")); break;
3411 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3415 if (e_flags
& EF_RISCV_RVC
)
3416 strcat (buf
, ", RVC");
3418 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3420 case EF_RISCV_FLOAT_ABI_SOFT
:
3421 strcat (buf
, ", soft-float ABI");
3424 case EF_RISCV_FLOAT_ABI_SINGLE
:
3425 strcat (buf
, ", single-float ABI");
3428 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3429 strcat (buf
, ", double-float ABI");
3432 case EF_RISCV_FLOAT_ABI_QUAD
:
3433 strcat (buf
, ", quad-float ABI");
3439 switch ((e_flags
& EF_SH_MACH_MASK
))
3441 case EF_SH1
: strcat (buf
, ", sh1"); break;
3442 case EF_SH2
: strcat (buf
, ", sh2"); break;
3443 case EF_SH3
: strcat (buf
, ", sh3"); break;
3444 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3445 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3446 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3447 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3448 case EF_SH4
: strcat (buf
, ", sh4"); break;
3449 case EF_SH5
: strcat (buf
, ", sh5"); break;
3450 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3451 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3452 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3453 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3454 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3455 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3456 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3457 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3458 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3459 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3460 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3461 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3462 default: strcat (buf
, _(", unknown ISA")); break;
3465 if (e_flags
& EF_SH_PIC
)
3466 strcat (buf
, ", pic");
3468 if (e_flags
& EF_SH_FDPIC
)
3469 strcat (buf
, ", fdpic");
3473 if (e_flags
& EF_OR1K_NODELAY
)
3474 strcat (buf
, ", no delay");
3478 if (e_flags
& EF_SPARC_32PLUS
)
3479 strcat (buf
, ", v8+");
3481 if (e_flags
& EF_SPARC_SUN_US1
)
3482 strcat (buf
, ", ultrasparcI");
3484 if (e_flags
& EF_SPARC_SUN_US3
)
3485 strcat (buf
, ", ultrasparcIII");
3487 if (e_flags
& EF_SPARC_HAL_R1
)
3488 strcat (buf
, ", halr1");
3490 if (e_flags
& EF_SPARC_LEDATA
)
3491 strcat (buf
, ", ledata");
3493 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3494 strcat (buf
, ", tso");
3496 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3497 strcat (buf
, ", pso");
3499 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3500 strcat (buf
, ", rmo");
3504 switch (e_flags
& EF_PARISC_ARCH
)
3506 case EFA_PARISC_1_0
:
3507 strcpy (buf
, ", PA-RISC 1.0");
3509 case EFA_PARISC_1_1
:
3510 strcpy (buf
, ", PA-RISC 1.1");
3512 case EFA_PARISC_2_0
:
3513 strcpy (buf
, ", PA-RISC 2.0");
3518 if (e_flags
& EF_PARISC_TRAPNIL
)
3519 strcat (buf
, ", trapnil");
3520 if (e_flags
& EF_PARISC_EXT
)
3521 strcat (buf
, ", ext");
3522 if (e_flags
& EF_PARISC_LSB
)
3523 strcat (buf
, ", lsb");
3524 if (e_flags
& EF_PARISC_WIDE
)
3525 strcat (buf
, ", wide");
3526 if (e_flags
& EF_PARISC_NO_KABP
)
3527 strcat (buf
, ", no kabp");
3528 if (e_flags
& EF_PARISC_LAZYSWAP
)
3529 strcat (buf
, ", lazyswap");
3534 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3535 strcat (buf
, ", new calling convention");
3537 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3538 strcat (buf
, ", gnu calling convention");
3542 if ((e_flags
& EF_IA_64_ABI64
))
3543 strcat (buf
, ", 64-bit");
3545 strcat (buf
, ", 32-bit");
3546 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3547 strcat (buf
, ", reduced fp model");
3548 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3549 strcat (buf
, ", no function descriptors, constant gp");
3550 else if ((e_flags
& EF_IA_64_CONS_GP
))
3551 strcat (buf
, ", constant gp");
3552 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3553 strcat (buf
, ", absolute");
3554 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3556 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3557 strcat (buf
, ", vms_linkages");
3558 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3560 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3562 case EF_IA_64_VMS_COMCOD_WARNING
:
3563 strcat (buf
, ", warning");
3565 case EF_IA_64_VMS_COMCOD_ERROR
:
3566 strcat (buf
, ", error");
3568 case EF_IA_64_VMS_COMCOD_ABORT
:
3569 strcat (buf
, ", abort");
3572 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3573 e_flags
& EF_IA_64_VMS_COMCOD
);
3574 strcat (buf
, ", <unknown>");
3580 if ((e_flags
& EF_VAX_NONPIC
))
3581 strcat (buf
, ", non-PIC");
3582 if ((e_flags
& EF_VAX_DFLOAT
))
3583 strcat (buf
, ", D-Float");
3584 if ((e_flags
& EF_VAX_GFLOAT
))
3585 strcat (buf
, ", G-Float");
3589 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3590 strcat (buf
, ", mcm");
3591 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3592 strcat (buf
, ", mcm24");
3593 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3594 strcat (buf
, ", gr6");
3598 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3600 case E_FLAG_RL78_ANY_CPU
: break;
3601 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3602 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3603 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3605 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3606 strcat (buf
, ", 64-bit doubles");
3610 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3611 strcat (buf
, ", 64-bit doubles");
3612 if (e_flags
& E_FLAG_RX_DSP
)
3613 strcat (buf
, ", dsp");
3614 if (e_flags
& E_FLAG_RX_PID
)
3615 strcat (buf
, ", pid");
3616 if (e_flags
& E_FLAG_RX_ABI
)
3617 strcat (buf
, ", RX ABI");
3618 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3619 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3620 ? ", uses String instructions" : ", bans String instructions");
3621 if (e_flags
& E_FLAG_RX_V2
)
3622 strcat (buf
, ", V2");
3626 if (e_flags
& EF_S390_HIGH_GPRS
)
3627 strcat (buf
, ", highgprs");
3631 if ((e_flags
& EF_C6000_REL
))
3632 strcat (buf
, ", relocatable module");
3636 strcat (buf
, _(": architecture variant: "));
3637 switch (e_flags
& EF_MSP430_MACH
)
3639 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3640 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3641 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3642 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3643 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3644 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3645 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3646 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3647 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3648 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3649 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3650 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3651 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3652 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3653 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3655 strcat (buf
, _(": unknown")); break;
3658 if (e_flags
& ~ EF_MSP430_MACH
)
3659 strcat (buf
, _(": unknown extra flag bits also present"));
3667 get_osabi_name (unsigned int osabi
)
3669 static char buff
[32];
3673 case ELFOSABI_NONE
: return "UNIX - System V";
3674 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3675 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3676 case ELFOSABI_GNU
: return "UNIX - GNU";
3677 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3678 case ELFOSABI_AIX
: return "UNIX - AIX";
3679 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3680 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3681 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3682 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3683 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3684 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3685 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3686 case ELFOSABI_AROS
: return "AROS";
3687 case ELFOSABI_FENIXOS
: return "FenixOS";
3688 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3689 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3692 switch (elf_header
.e_machine
)
3697 case ELFOSABI_ARM
: return "ARM";
3708 case ELFOSABI_STANDALONE
: return _("Standalone App");
3717 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3718 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3727 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3733 get_aarch64_segment_type (unsigned long type
)
3737 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3738 default: return NULL
;
3743 get_arm_segment_type (unsigned long type
)
3747 case PT_ARM_EXIDX
: return "EXIDX";
3748 default: return NULL
;
3753 get_s390_segment_type (unsigned long type
)
3757 case PT_S390_PGSTE
: return "S390_PGSTE";
3758 default: return NULL
;
3763 get_mips_segment_type (unsigned long type
)
3767 case PT_MIPS_REGINFO
: return "REGINFO";
3768 case PT_MIPS_RTPROC
: return "RTPROC";
3769 case PT_MIPS_OPTIONS
: return "OPTIONS";
3770 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3771 default: return NULL
;
3776 get_parisc_segment_type (unsigned long type
)
3780 case PT_HP_TLS
: return "HP_TLS";
3781 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3782 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3783 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3784 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3785 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3786 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3787 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3788 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3789 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3790 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3791 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3792 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3793 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3794 case PT_HP_STACK
: return "HP_STACK";
3795 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3796 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3797 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3798 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3799 default: return NULL
;
3804 get_ia64_segment_type (unsigned long type
)
3808 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3809 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3810 case PT_HP_TLS
: return "HP_TLS";
3811 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3812 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3813 case PT_IA_64_HP_STACK
: return "HP_STACK";
3814 default: return NULL
;
3819 get_tic6x_segment_type (unsigned long type
)
3823 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3824 default: return NULL
;
3829 get_solaris_segment_type (unsigned long type
)
3833 case 0x6464e550: return "PT_SUNW_UNWIND";
3834 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3835 case 0x6ffffff7: return "PT_LOSUNW";
3836 case 0x6ffffffa: return "PT_SUNWBSS";
3837 case 0x6ffffffb: return "PT_SUNWSTACK";
3838 case 0x6ffffffc: return "PT_SUNWDTRACE";
3839 case 0x6ffffffd: return "PT_SUNWCAP";
3840 case 0x6fffffff: return "PT_HISUNW";
3841 default: return NULL
;
3846 get_segment_type (unsigned long p_type
)
3848 static char buff
[32];
3852 case PT_NULL
: return "NULL";
3853 case PT_LOAD
: return "LOAD";
3854 case PT_DYNAMIC
: return "DYNAMIC";
3855 case PT_INTERP
: return "INTERP";
3856 case PT_NOTE
: return "NOTE";
3857 case PT_SHLIB
: return "SHLIB";
3858 case PT_PHDR
: return "PHDR";
3859 case PT_TLS
: return "TLS";
3860 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
3861 case PT_GNU_STACK
: return "GNU_STACK";
3862 case PT_GNU_RELRO
: return "GNU_RELRO";
3865 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
3867 sprintf (buff
, "GNU_MBIND+%#lx",
3868 p_type
- PT_GNU_MBIND_LO
);
3870 else if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3872 const char * result
;
3874 switch (elf_header
.e_machine
)
3877 result
= get_aarch64_segment_type (p_type
);
3880 result
= get_arm_segment_type (p_type
);
3883 case EM_MIPS_RS3_LE
:
3884 result
= get_mips_segment_type (p_type
);
3887 result
= get_parisc_segment_type (p_type
);
3890 result
= get_ia64_segment_type (p_type
);
3893 result
= get_tic6x_segment_type (p_type
);
3897 result
= get_s390_segment_type (p_type
);
3907 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
3909 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3911 const char * result
;
3913 switch (elf_header
.e_machine
)
3916 result
= get_parisc_segment_type (p_type
);
3919 result
= get_ia64_segment_type (p_type
);
3922 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
3923 result
= get_solaris_segment_type (p_type
);
3932 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
3935 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3942 get_arc_section_type_name (unsigned int sh_type
)
3946 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
3954 get_mips_section_type_name (unsigned int sh_type
)
3958 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3959 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3960 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3961 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3962 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3963 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3964 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3965 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3966 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3967 case SHT_MIPS_RELD
: return "MIPS_RELD";
3968 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3969 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3970 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3971 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3972 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3973 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3974 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3975 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3976 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3977 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3978 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3979 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3980 case SHT_MIPS_LINE
: return "MIPS_LINE";
3981 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3982 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3983 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3984 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3985 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3986 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3987 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3988 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3989 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3990 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3991 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3992 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3993 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3994 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3995 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3996 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3997 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4005 get_parisc_section_type_name (unsigned int sh_type
)
4009 case SHT_PARISC_EXT
: return "PARISC_EXT";
4010 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4011 case SHT_PARISC_DOC
: return "PARISC_DOC";
4012 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4013 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4014 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4015 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4016 default: return NULL
;
4021 get_ia64_section_type_name (unsigned int sh_type
)
4023 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4024 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4025 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
4029 case SHT_IA_64_EXT
: return "IA_64_EXT";
4030 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4031 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4032 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4033 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4034 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4035 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4036 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4037 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4038 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4046 get_x86_64_section_type_name (unsigned int sh_type
)
4050 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4051 default: return NULL
;
4056 get_aarch64_section_type_name (unsigned int sh_type
)
4060 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4061 default: return NULL
;
4066 get_arm_section_type_name (unsigned int sh_type
)
4070 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4071 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4072 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4073 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4074 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4075 default: return NULL
;
4080 get_tic6x_section_type_name (unsigned int sh_type
)
4084 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4085 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4086 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4087 case SHT_TI_ICODE
: return "TI_ICODE";
4088 case SHT_TI_XREF
: return "TI_XREF";
4089 case SHT_TI_HANDLER
: return "TI_HANDLER";
4090 case SHT_TI_INITINFO
: return "TI_INITINFO";
4091 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4092 default: return NULL
;
4097 get_msp430x_section_type_name (unsigned int sh_type
)
4101 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4102 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4103 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4104 default: return NULL
;
4109 get_v850_section_type_name (unsigned int sh_type
)
4113 case SHT_V850_SCOMMON
: return "V850 Small Common";
4114 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4115 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4116 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4117 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4118 default: return NULL
;
4123 get_section_type_name (unsigned int sh_type
)
4125 static char buff
[32];
4126 const char * result
;
4130 case SHT_NULL
: return "NULL";
4131 case SHT_PROGBITS
: return "PROGBITS";
4132 case SHT_SYMTAB
: return "SYMTAB";
4133 case SHT_STRTAB
: return "STRTAB";
4134 case SHT_RELA
: return "RELA";
4135 case SHT_HASH
: return "HASH";
4136 case SHT_DYNAMIC
: return "DYNAMIC";
4137 case SHT_NOTE
: return "NOTE";
4138 case SHT_NOBITS
: return "NOBITS";
4139 case SHT_REL
: return "REL";
4140 case SHT_SHLIB
: return "SHLIB";
4141 case SHT_DYNSYM
: return "DYNSYM";
4142 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4143 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4144 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4145 case SHT_GNU_HASH
: return "GNU_HASH";
4146 case SHT_GROUP
: return "GROUP";
4147 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
4148 case SHT_GNU_verdef
: return "VERDEF";
4149 case SHT_GNU_verneed
: return "VERNEED";
4150 case SHT_GNU_versym
: return "VERSYM";
4151 case 0x6ffffff0: return "VERSYM";
4152 case 0x6ffffffc: return "VERDEF";
4153 case 0x7ffffffd: return "AUXILIARY";
4154 case 0x7fffffff: return "FILTER";
4155 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4158 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4160 switch (elf_header
.e_machine
)
4163 case EM_ARC_COMPACT
:
4164 case EM_ARC_COMPACT2
:
4165 result
= get_arc_section_type_name (sh_type
);
4168 case EM_MIPS_RS3_LE
:
4169 result
= get_mips_section_type_name (sh_type
);
4172 result
= get_parisc_section_type_name (sh_type
);
4175 result
= get_ia64_section_type_name (sh_type
);
4180 result
= get_x86_64_section_type_name (sh_type
);
4183 result
= get_aarch64_section_type_name (sh_type
);
4186 result
= get_arm_section_type_name (sh_type
);
4189 result
= get_tic6x_section_type_name (sh_type
);
4192 result
= get_msp430x_section_type_name (sh_type
);
4196 case EM_CYGNUS_V850
:
4197 result
= get_v850_section_type_name (sh_type
);
4207 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4209 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4211 switch (elf_header
.e_machine
)
4214 result
= get_ia64_section_type_name (sh_type
);
4217 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4218 result
= get_solaris_section_type (sh_type
);
4223 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4224 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4225 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4226 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4238 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4240 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4242 switch (elf_header
.e_machine
)
4246 case EM_CYGNUS_V850
:
4247 result
= get_v850_section_type_name (sh_type
);
4257 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4260 /* This message is probably going to be displayed in a 15
4261 character wide field, so put the hex value first. */
4262 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4268 #define OPTION_DEBUG_DUMP 512
4269 #define OPTION_DYN_SYMS 513
4270 #define OPTION_DWARF_DEPTH 514
4271 #define OPTION_DWARF_START 515
4272 #define OPTION_DWARF_CHECK 516
4274 static struct option options
[] =
4276 {"all", no_argument
, 0, 'a'},
4277 {"file-header", no_argument
, 0, 'h'},
4278 {"program-headers", no_argument
, 0, 'l'},
4279 {"headers", no_argument
, 0, 'e'},
4280 {"histogram", no_argument
, 0, 'I'},
4281 {"segments", no_argument
, 0, 'l'},
4282 {"sections", no_argument
, 0, 'S'},
4283 {"section-headers", no_argument
, 0, 'S'},
4284 {"section-groups", no_argument
, 0, 'g'},
4285 {"section-details", no_argument
, 0, 't'},
4286 {"full-section-name",no_argument
, 0, 'N'},
4287 {"symbols", no_argument
, 0, 's'},
4288 {"syms", no_argument
, 0, 's'},
4289 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4290 {"relocs", no_argument
, 0, 'r'},
4291 {"notes", no_argument
, 0, 'n'},
4292 {"dynamic", no_argument
, 0, 'd'},
4293 {"arch-specific", no_argument
, 0, 'A'},
4294 {"version-info", no_argument
, 0, 'V'},
4295 {"use-dynamic", no_argument
, 0, 'D'},
4296 {"unwind", no_argument
, 0, 'u'},
4297 {"archive-index", no_argument
, 0, 'c'},
4298 {"hex-dump", required_argument
, 0, 'x'},
4299 {"relocated-dump", required_argument
, 0, 'R'},
4300 {"string-dump", required_argument
, 0, 'p'},
4301 {"decompress", no_argument
, 0, 'z'},
4302 #ifdef SUPPORT_DISASSEMBLY
4303 {"instruction-dump", required_argument
, 0, 'i'},
4305 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4307 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4308 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4309 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4311 {"version", no_argument
, 0, 'v'},
4312 {"wide", no_argument
, 0, 'W'},
4313 {"help", no_argument
, 0, 'H'},
4314 {0, no_argument
, 0, 0}
4318 usage (FILE * stream
)
4320 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4321 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4322 fprintf (stream
, _(" Options are:\n\
4323 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4324 -h --file-header Display the ELF file header\n\
4325 -l --program-headers Display the program headers\n\
4326 --segments An alias for --program-headers\n\
4327 -S --section-headers Display the sections' header\n\
4328 --sections An alias for --section-headers\n\
4329 -g --section-groups Display the section groups\n\
4330 -t --section-details Display the section details\n\
4331 -e --headers Equivalent to: -h -l -S\n\
4332 -s --syms Display the symbol table\n\
4333 --symbols An alias for --syms\n\
4334 --dyn-syms Display the dynamic symbol table\n\
4335 -n --notes Display the core notes (if present)\n\
4336 -r --relocs Display the relocations (if present)\n\
4337 -u --unwind Display the unwind info (if present)\n\
4338 -d --dynamic Display the dynamic section (if present)\n\
4339 -V --version-info Display the version sections (if present)\n\
4340 -A --arch-specific Display architecture specific information (if any)\n\
4341 -c --archive-index Display the symbol/file index in an archive\n\
4342 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4343 -x --hex-dump=<number|name>\n\
4344 Dump the contents of section <number|name> as bytes\n\
4345 -p --string-dump=<number|name>\n\
4346 Dump the contents of section <number|name> as strings\n\
4347 -R --relocated-dump=<number|name>\n\
4348 Dump the contents of section <number|name> as relocated bytes\n\
4349 -z --decompress Decompress section before dumping it\n\
4350 -w[lLiaprmfFsoRt] or\n\
4351 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4352 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4353 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4355 Display the contents of DWARF2 debug sections\n"));
4356 fprintf (stream
, _("\
4357 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4358 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4360 #ifdef SUPPORT_DISASSEMBLY
4361 fprintf (stream
, _("\
4362 -i --instruction-dump=<number|name>\n\
4363 Disassemble the contents of section <number|name>\n"));
4365 fprintf (stream
, _("\
4366 -I --histogram Display histogram of bucket list lengths\n\
4367 -W --wide Allow output width to exceed 80 characters\n\
4368 @<file> Read options from <file>\n\
4369 -H --help Display this information\n\
4370 -v --version Display the version number of readelf\n"));
4372 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4373 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4375 exit (stream
== stdout
? 0 : 1);
4378 /* Record the fact that the user wants the contents of section number
4379 SECTION to be displayed using the method(s) encoded as flags bits
4380 in TYPE. Note, TYPE can be zero if we are creating the array for
4384 request_dump_bynumber (unsigned int section
, dump_type type
)
4386 if (section
>= num_dump_sects
)
4388 dump_type
* new_dump_sects
;
4390 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4391 sizeof (* dump_sects
));
4393 if (new_dump_sects
== NULL
)
4394 error (_("Out of memory allocating dump request table.\n"));
4399 /* Copy current flag settings. */
4400 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
4405 dump_sects
= new_dump_sects
;
4406 num_dump_sects
= section
+ 1;
4411 dump_sects
[section
] |= type
;
4416 /* Request a dump by section name. */
4419 request_dump_byname (const char * section
, dump_type type
)
4421 struct dump_list_entry
* new_request
;
4423 new_request
= (struct dump_list_entry
*)
4424 malloc (sizeof (struct dump_list_entry
));
4426 error (_("Out of memory allocating dump request table.\n"));
4428 new_request
->name
= strdup (section
);
4429 if (!new_request
->name
)
4430 error (_("Out of memory allocating dump request table.\n"));
4432 new_request
->type
= type
;
4434 new_request
->next
= dump_sects_byname
;
4435 dump_sects_byname
= new_request
;
4439 request_dump (dump_type type
)
4445 section
= strtoul (optarg
, & cp
, 0);
4447 if (! *cp
&& section
>= 0)
4448 request_dump_bynumber (section
, type
);
4450 request_dump_byname (optarg
, type
);
4455 parse_args (int argc
, char ** argv
)
4462 while ((c
= getopt_long
4463 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4481 do_section_groups
= TRUE
;
4484 do_histogram
= TRUE
;
4489 do_section_groups
= TRUE
;
4494 do_section_details
= TRUE
;
4505 do_using_dynamic
= TRUE
;
4529 do_histogram
= TRUE
;
4535 do_archive_index
= TRUE
;
4538 request_dump (HEX_DUMP
);
4541 request_dump (STRING_DUMP
);
4544 request_dump (RELOC_DUMP
);
4547 decompress_dumps
= TRUE
;
4553 do_debugging
= TRUE
;
4554 dwarf_select_sections_all ();
4558 do_debugging
= FALSE
;
4559 dwarf_select_sections_by_letters (optarg
);
4562 case OPTION_DEBUG_DUMP
:
4565 do_debugging
= TRUE
;
4568 do_debugging
= FALSE
;
4569 dwarf_select_sections_by_names (optarg
);
4572 case OPTION_DWARF_DEPTH
:
4576 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4579 case OPTION_DWARF_START
:
4583 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4586 case OPTION_DWARF_CHECK
:
4589 case OPTION_DYN_SYMS
:
4592 #ifdef SUPPORT_DISASSEMBLY
4594 request_dump (DISASS_DUMP
);
4598 print_version (program_name
);
4607 /* xgettext:c-format */
4608 error (_("Invalid option '-%c'\n"), c
);
4615 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4616 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4617 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4618 && !do_section_groups
&& !do_archive_index
4624 get_elf_class (unsigned int elf_class
)
4626 static char buff
[32];
4630 case ELFCLASSNONE
: return _("none");
4631 case ELFCLASS32
: return "ELF32";
4632 case ELFCLASS64
: return "ELF64";
4634 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4640 get_data_encoding (unsigned int encoding
)
4642 static char buff
[32];
4646 case ELFDATANONE
: return _("none");
4647 case ELFDATA2LSB
: return _("2's complement, little endian");
4648 case ELFDATA2MSB
: return _("2's complement, big endian");
4650 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4655 /* Decode the data held in 'elf_header'. */
4658 process_file_header (void)
4660 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4661 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4662 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4663 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4666 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4670 init_dwarf_regnames (elf_header
.e_machine
);
4676 printf (_("ELF Header:\n"));
4677 printf (_(" Magic: "));
4678 for (i
= 0; i
< EI_NIDENT
; i
++)
4679 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4681 printf (_(" Class: %s\n"),
4682 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4683 printf (_(" Data: %s\n"),
4684 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4685 printf (_(" Version: %d %s\n"),
4686 elf_header
.e_ident
[EI_VERSION
],
4687 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4689 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4690 ? _("<unknown: %lx>")
4692 printf (_(" OS/ABI: %s\n"),
4693 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4694 printf (_(" ABI Version: %d\n"),
4695 elf_header
.e_ident
[EI_ABIVERSION
]);
4696 printf (_(" Type: %s\n"),
4697 get_file_type (elf_header
.e_type
));
4698 printf (_(" Machine: %s\n"),
4699 get_machine_name (elf_header
.e_machine
));
4700 printf (_(" Version: 0x%lx\n"),
4701 (unsigned long) elf_header
.e_version
);
4703 printf (_(" Entry point address: "));
4704 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4705 printf (_("\n Start of program headers: "));
4706 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4707 printf (_(" (bytes into file)\n Start of section headers: "));
4708 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4709 printf (_(" (bytes into file)\n"));
4711 printf (_(" Flags: 0x%lx%s\n"),
4712 (unsigned long) elf_header
.e_flags
,
4713 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4714 printf (_(" Size of this header: %ld (bytes)\n"),
4715 (long) elf_header
.e_ehsize
);
4716 printf (_(" Size of program headers: %ld (bytes)\n"),
4717 (long) elf_header
.e_phentsize
);
4718 printf (_(" Number of program headers: %ld"),
4719 (long) elf_header
.e_phnum
);
4720 if (section_headers
!= NULL
4721 && elf_header
.e_phnum
== PN_XNUM
4722 && section_headers
[0].sh_info
!= 0)
4723 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4724 putc ('\n', stdout
);
4725 printf (_(" Size of section headers: %ld (bytes)\n"),
4726 (long) elf_header
.e_shentsize
);
4727 printf (_(" Number of section headers: %ld"),
4728 (long) elf_header
.e_shnum
);
4729 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4730 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4731 putc ('\n', stdout
);
4732 printf (_(" Section header string table index: %ld"),
4733 (long) elf_header
.e_shstrndx
);
4734 if (section_headers
!= NULL
4735 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4736 printf (" (%u)", section_headers
[0].sh_link
);
4737 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4738 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4739 printf (_(" <corrupt: out of range>"));
4740 putc ('\n', stdout
);
4743 if (section_headers
!= NULL
)
4745 if (elf_header
.e_phnum
== PN_XNUM
4746 && section_headers
[0].sh_info
!= 0)
4747 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4748 if (elf_header
.e_shnum
== SHN_UNDEF
)
4749 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4750 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4751 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4752 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4753 elf_header
.e_shstrndx
= SHN_UNDEF
;
4754 free (section_headers
);
4755 section_headers
= NULL
;
4762 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4764 Elf32_External_Phdr
* phdrs
;
4765 Elf32_External_Phdr
* external
;
4766 Elf_Internal_Phdr
* internal
;
4768 unsigned int size
= elf_header
.e_phentsize
;
4769 unsigned int num
= elf_header
.e_phnum
;
4771 /* PR binutils/17531: Cope with unexpected section header sizes. */
4772 if (size
== 0 || num
== 0)
4774 if (size
< sizeof * phdrs
)
4776 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4779 if (size
> sizeof * phdrs
)
4780 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4782 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4783 size
, num
, _("program headers"));
4787 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4788 i
< elf_header
.e_phnum
;
4789 i
++, internal
++, external
++)
4791 internal
->p_type
= BYTE_GET (external
->p_type
);
4792 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4793 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4794 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4795 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4796 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4797 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4798 internal
->p_align
= BYTE_GET (external
->p_align
);
4806 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4808 Elf64_External_Phdr
* phdrs
;
4809 Elf64_External_Phdr
* external
;
4810 Elf_Internal_Phdr
* internal
;
4812 unsigned int size
= elf_header
.e_phentsize
;
4813 unsigned int num
= elf_header
.e_phnum
;
4815 /* PR binutils/17531: Cope with unexpected section header sizes. */
4816 if (size
== 0 || num
== 0)
4818 if (size
< sizeof * phdrs
)
4820 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4823 if (size
> sizeof * phdrs
)
4824 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4826 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4827 size
, num
, _("program headers"));
4831 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4832 i
< elf_header
.e_phnum
;
4833 i
++, internal
++, external
++)
4835 internal
->p_type
= BYTE_GET (external
->p_type
);
4836 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4837 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4838 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4839 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4840 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4841 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4842 internal
->p_align
= BYTE_GET (external
->p_align
);
4849 /* Returns TRUE if the program headers were read into `program_headers'. */
4852 get_program_headers (FILE * file
)
4854 Elf_Internal_Phdr
* phdrs
;
4856 /* Check cache of prior read. */
4857 if (program_headers
!= NULL
)
4860 /* Be kind to memory checkers by looking for
4861 e_phnum values which we know must be invalid. */
4862 if (elf_header
.e_phnum
4863 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
4864 >= current_file_size
)
4866 error (_("Too many program headers - %#x - the file is not that big\n"),
4867 elf_header
.e_phnum
);
4871 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4872 sizeof (Elf_Internal_Phdr
));
4875 error (_("Out of memory reading %u program headers\n"),
4876 elf_header
.e_phnum
);
4881 ? get_32bit_program_headers (file
, phdrs
)
4882 : get_64bit_program_headers (file
, phdrs
))
4884 program_headers
= phdrs
;
4892 /* Returns TRUE if the program headers were loaded. */
4895 process_program_headers (FILE * file
)
4897 Elf_Internal_Phdr
* segment
;
4899 Elf_Internal_Phdr
* previous_load
= NULL
;
4901 if (elf_header
.e_phnum
== 0)
4903 /* PR binutils/12467. */
4904 if (elf_header
.e_phoff
!= 0)
4906 warn (_("possibly corrupt ELF header - it has a non-zero program"
4907 " header offset, but no program headers\n"));
4910 else if (do_segments
)
4911 printf (_("\nThere are no program headers in this file.\n"));
4915 if (do_segments
&& !do_header
)
4917 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4918 printf (_("Entry point "));
4919 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4920 printf (_("\nThere are %d program headers, starting at offset "),
4921 elf_header
.e_phnum
);
4922 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4926 if (! get_program_headers (file
))
4931 if (elf_header
.e_phnum
> 1)
4932 printf (_("\nProgram Headers:\n"));
4934 printf (_("\nProgram Headers:\n"));
4938 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4941 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4945 (_(" Type Offset VirtAddr PhysAddr\n"));
4947 (_(" FileSiz MemSiz Flags Align\n"));
4954 for (i
= 0, segment
= program_headers
;
4955 i
< elf_header
.e_phnum
;
4960 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4964 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4965 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4966 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4967 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4968 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4970 (segment
->p_flags
& PF_R
? 'R' : ' '),
4971 (segment
->p_flags
& PF_W
? 'W' : ' '),
4972 (segment
->p_flags
& PF_X
? 'E' : ' '));
4973 printf ("%#lx", (unsigned long) segment
->p_align
);
4977 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4978 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4981 print_vma (segment
->p_offset
, FULL_HEX
);
4985 print_vma (segment
->p_vaddr
, FULL_HEX
);
4987 print_vma (segment
->p_paddr
, FULL_HEX
);
4990 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4991 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4994 print_vma (segment
->p_filesz
, FULL_HEX
);
4998 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4999 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5002 print_vma (segment
->p_memsz
, FULL_HEX
);
5006 (segment
->p_flags
& PF_R
? 'R' : ' '),
5007 (segment
->p_flags
& PF_W
? 'W' : ' '),
5008 (segment
->p_flags
& PF_X
? 'E' : ' '));
5010 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5011 printf ("%#lx", (unsigned long) segment
->p_align
);
5014 print_vma (segment
->p_align
, PREFIX_HEX
);
5019 print_vma (segment
->p_offset
, FULL_HEX
);
5021 print_vma (segment
->p_vaddr
, FULL_HEX
);
5023 print_vma (segment
->p_paddr
, FULL_HEX
);
5025 print_vma (segment
->p_filesz
, FULL_HEX
);
5027 print_vma (segment
->p_memsz
, FULL_HEX
);
5029 (segment
->p_flags
& PF_R
? 'R' : ' '),
5030 (segment
->p_flags
& PF_W
? 'W' : ' '),
5031 (segment
->p_flags
& PF_X
? 'E' : ' '));
5032 print_vma (segment
->p_align
, PREFIX_HEX
);
5035 putc ('\n', stdout
);
5038 switch (segment
->p_type
)
5041 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5042 required by the ELF standard, several programs, including the Linux
5043 kernel, make use of non-ordered segments. */
5045 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5046 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5048 if (segment
->p_memsz
< segment
->p_filesz
)
5049 error (_("the segment's file size is larger than its memory size\n"));
5050 previous_load
= segment
;
5054 /* PR 20815 - Verify that the program header is loaded into memory. */
5055 if (i
> 0 && previous_load
!= NULL
)
5056 error (_("the PHDR segment must occur before any LOAD segment\n"));
5057 if (elf_header
.e_machine
!= EM_PARISC
)
5061 for (j
= 1; j
< elf_header
.e_phnum
; j
++)
5062 if (program_headers
[j
].p_vaddr
<= segment
->p_vaddr
5063 && (program_headers
[j
].p_vaddr
+ program_headers
[j
].p_memsz
)
5064 >= (segment
->p_vaddr
+ segment
->p_filesz
))
5066 if (j
== elf_header
.e_phnum
)
5067 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5073 error (_("more than one dynamic segment\n"));
5075 /* By default, assume that the .dynamic section is the first
5076 section in the DYNAMIC segment. */
5077 dynamic_addr
= segment
->p_offset
;
5078 dynamic_size
= segment
->p_filesz
;
5080 /* Try to locate the .dynamic section. If there is
5081 a section header table, we can easily locate it. */
5082 if (section_headers
!= NULL
)
5084 Elf_Internal_Shdr
* sec
;
5086 sec
= find_section (".dynamic");
5087 if (sec
== NULL
|| sec
->sh_size
== 0)
5089 /* A corresponding .dynamic section is expected, but on
5090 IA-64/OpenVMS it is OK for it to be missing. */
5091 if (!is_ia64_vms ())
5092 error (_("no .dynamic section in the dynamic segment\n"));
5096 if (sec
->sh_type
== SHT_NOBITS
)
5102 dynamic_addr
= sec
->sh_offset
;
5103 dynamic_size
= sec
->sh_size
;
5105 if (dynamic_addr
< segment
->p_offset
5106 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5107 warn (_("the .dynamic section is not contained"
5108 " within the dynamic segment\n"));
5109 else if (dynamic_addr
> segment
->p_offset
)
5110 warn (_("the .dynamic section is not the first section"
5111 " in the dynamic segment.\n"));
5114 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5115 segment. Check this after matching against the section headers
5116 so we don't warn on debuginfo file (which have NOBITS .dynamic
5118 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
5120 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5121 dynamic_addr
= dynamic_size
= 0;
5126 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
5128 error (_("Unable to find program interpreter name\n"));
5132 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5134 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5135 error (_("Internal error: failed to create format string to display program interpreter\n"));
5137 program_interpreter
[0] = 0;
5138 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
5139 error (_("Unable to read program interpreter name\n"));
5142 printf (_(" [Requesting program interpreter: %s]\n"),
5143 program_interpreter
);
5149 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
5151 printf (_("\n Section to Segment mapping:\n"));
5152 printf (_(" Segment Sections...\n"));
5154 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
5157 Elf_Internal_Shdr
* section
;
5159 segment
= program_headers
+ i
;
5160 section
= section_headers
+ 1;
5162 printf (" %2.2d ", i
);
5164 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
5166 if (!ELF_TBSS_SPECIAL (section
, segment
)
5167 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5168 printf ("%s ", printable_section_name (section
));
5179 /* Find the file offset corresponding to VMA by using the program headers. */
5182 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
5184 Elf_Internal_Phdr
* seg
;
5186 if (! get_program_headers (file
))
5188 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5192 for (seg
= program_headers
;
5193 seg
< program_headers
+ elf_header
.e_phnum
;
5196 if (seg
->p_type
!= PT_LOAD
)
5199 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5200 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5201 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5204 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5205 (unsigned long) vma
);
5210 /* Allocate memory and load the sections headers into the global pointer
5211 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
5212 generate any error messages if the load fails. */
5215 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
5217 Elf32_External_Shdr
* shdrs
;
5218 Elf_Internal_Shdr
* internal
;
5220 unsigned int size
= elf_header
.e_shentsize
;
5221 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5223 /* PR binutils/17531: Cope with unexpected section header sizes. */
5224 if (size
== 0 || num
== 0)
5226 if (size
< sizeof * shdrs
)
5229 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5232 if (!probe
&& size
> sizeof * shdrs
)
5233 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5235 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5237 probe
? NULL
: _("section headers"));
5241 if (section_headers
!= NULL
)
5242 free (section_headers
);
5243 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5244 sizeof (Elf_Internal_Shdr
));
5245 if (section_headers
== NULL
)
5248 error (_("Out of memory reading %u section headers\n"), num
);
5252 for (i
= 0, internal
= section_headers
;
5256 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5257 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5258 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5259 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5260 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5261 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5262 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5263 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5264 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5265 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5266 if (!probe
&& internal
->sh_link
> num
)
5267 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5268 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5269 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5277 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
5279 Elf64_External_Shdr
* shdrs
;
5280 Elf_Internal_Shdr
* internal
;
5282 unsigned int size
= elf_header
.e_shentsize
;
5283 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5285 /* PR binutils/17531: Cope with unexpected section header sizes. */
5286 if (size
== 0 || num
== 0)
5288 if (size
< sizeof * shdrs
)
5291 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5294 if (! probe
&& size
> sizeof * shdrs
)
5295 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5297 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5299 probe
? NULL
: _("section headers"));
5303 if (section_headers
!= NULL
)
5304 free (section_headers
);
5305 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5306 sizeof (Elf_Internal_Shdr
));
5307 if (section_headers
== NULL
)
5310 error (_("Out of memory reading %u section headers\n"), num
);
5314 for (i
= 0, internal
= section_headers
;
5318 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5319 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5320 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5321 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5322 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5323 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5324 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5325 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5326 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5327 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5328 if (!probe
&& internal
->sh_link
> num
)
5329 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5330 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5331 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5338 static Elf_Internal_Sym
*
5339 get_32bit_elf_symbols (FILE * file
,
5340 Elf_Internal_Shdr
* section
,
5341 unsigned long * num_syms_return
)
5343 unsigned long number
= 0;
5344 Elf32_External_Sym
* esyms
= NULL
;
5345 Elf_External_Sym_Shndx
* shndx
= NULL
;
5346 Elf_Internal_Sym
* isyms
= NULL
;
5347 Elf_Internal_Sym
* psym
;
5350 if (section
->sh_size
== 0)
5352 if (num_syms_return
!= NULL
)
5353 * num_syms_return
= 0;
5357 /* Run some sanity checks first. */
5358 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5360 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5361 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
5365 if (section
->sh_size
> current_file_size
)
5367 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5368 printable_section_name (section
), (unsigned long) section
->sh_size
);
5372 number
= section
->sh_size
/ section
->sh_entsize
;
5374 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5376 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5377 (unsigned long) section
->sh_size
,
5378 printable_section_name (section
),
5379 (unsigned long) section
->sh_entsize
);
5383 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5384 section
->sh_size
, _("symbols"));
5389 elf_section_list
* entry
;
5392 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5393 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5395 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5396 entry
->hdr
->sh_offset
,
5397 1, entry
->hdr
->sh_size
,
5398 _("symbol table section indicies"));
5401 /* PR17531: file: heap-buffer-overflow */
5402 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5404 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5405 printable_section_name (entry
->hdr
),
5406 (unsigned long) entry
->hdr
->sh_size
,
5407 (unsigned long) section
->sh_size
);
5413 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5417 error (_("Out of memory reading %lu symbols\n"),
5418 (unsigned long) number
);
5422 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5424 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5425 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5426 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5427 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5428 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5430 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5431 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5432 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5433 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5434 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5443 if (num_syms_return
!= NULL
)
5444 * num_syms_return
= isyms
== NULL
? 0 : number
;
5449 static Elf_Internal_Sym
*
5450 get_64bit_elf_symbols (FILE * file
,
5451 Elf_Internal_Shdr
* section
,
5452 unsigned long * num_syms_return
)
5454 unsigned long number
= 0;
5455 Elf64_External_Sym
* esyms
= NULL
;
5456 Elf_External_Sym_Shndx
* shndx
= NULL
;
5457 Elf_Internal_Sym
* isyms
= NULL
;
5458 Elf_Internal_Sym
* psym
;
5461 if (section
->sh_size
== 0)
5463 if (num_syms_return
!= NULL
)
5464 * num_syms_return
= 0;
5468 /* Run some sanity checks first. */
5469 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5471 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5472 printable_section_name (section
),
5473 (unsigned long) section
->sh_entsize
);
5477 if (section
->sh_size
> current_file_size
)
5479 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5480 printable_section_name (section
),
5481 (unsigned long) section
->sh_size
);
5485 number
= section
->sh_size
/ section
->sh_entsize
;
5487 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5489 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5490 (unsigned long) section
->sh_size
,
5491 printable_section_name (section
),
5492 (unsigned long) section
->sh_entsize
);
5496 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5497 section
->sh_size
, _("symbols"));
5502 elf_section_list
* entry
;
5505 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5506 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5508 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5509 entry
->hdr
->sh_offset
,
5510 1, entry
->hdr
->sh_size
,
5511 _("symbol table section indicies"));
5514 /* PR17531: file: heap-buffer-overflow */
5515 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5517 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5518 printable_section_name (entry
->hdr
),
5519 (unsigned long) entry
->hdr
->sh_size
,
5520 (unsigned long) section
->sh_size
);
5526 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5530 error (_("Out of memory reading %lu symbols\n"),
5531 (unsigned long) number
);
5535 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5537 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5538 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5539 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5540 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5542 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5544 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5545 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5546 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5548 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5549 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5558 if (num_syms_return
!= NULL
)
5559 * num_syms_return
= isyms
== NULL
? 0 : number
;
5565 get_elf_section_flags (bfd_vma sh_flags
)
5567 static char buff
[1024];
5569 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5571 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5572 bfd_vma os_flags
= 0;
5573 bfd_vma proc_flags
= 0;
5574 bfd_vma unknown_flags
= 0;
5582 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5583 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5584 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5585 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5586 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5587 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5588 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5589 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5590 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5591 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5592 /* IA-64 specific. */
5593 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5594 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5595 /* IA-64 OpenVMS specific. */
5596 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5597 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5598 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5599 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5600 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5601 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5603 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5604 /* SPARC specific. */
5605 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5606 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5608 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5609 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5610 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5612 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5614 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5617 if (do_section_details
)
5619 sprintf (buff
, "[%*.*lx]: ",
5620 field_size
, field_size
, (unsigned long) sh_flags
);
5621 p
+= field_size
+ 4;
5628 flag
= sh_flags
& - sh_flags
;
5631 if (do_section_details
)
5635 case SHF_WRITE
: sindex
= 0; break;
5636 case SHF_ALLOC
: sindex
= 1; break;
5637 case SHF_EXECINSTR
: sindex
= 2; break;
5638 case SHF_MERGE
: sindex
= 3; break;
5639 case SHF_STRINGS
: sindex
= 4; break;
5640 case SHF_INFO_LINK
: sindex
= 5; break;
5641 case SHF_LINK_ORDER
: sindex
= 6; break;
5642 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5643 case SHF_GROUP
: sindex
= 8; break;
5644 case SHF_TLS
: sindex
= 9; break;
5645 case SHF_EXCLUDE
: sindex
= 18; break;
5646 case SHF_COMPRESSED
: sindex
= 20; break;
5647 case SHF_GNU_MBIND
: sindex
= 24; break;
5651 switch (elf_header
.e_machine
)
5654 if (flag
== SHF_IA_64_SHORT
)
5656 else if (flag
== SHF_IA_64_NORECOV
)
5659 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5662 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5663 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5664 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5665 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5666 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5667 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5678 case EM_OLD_SPARCV9
:
5679 case EM_SPARC32PLUS
:
5682 if (flag
== SHF_ORDERED
)
5689 case SHF_ENTRYSECT
: sindex
= 21; break;
5690 case SHF_ARM_PURECODE
: sindex
= 22; break;
5691 case SHF_COMDEF
: sindex
= 23; break;
5696 if (flag
== SHF_PPC_VLE
)
5707 if (p
!= buff
+ field_size
+ 4)
5709 if (size
< (10 + 2))
5711 warn (_("Internal error: not enough buffer room for section flag info"));
5712 return _("<unknown>");
5719 size
-= flags
[sindex
].len
;
5720 p
= stpcpy (p
, flags
[sindex
].str
);
5722 else if (flag
& SHF_MASKOS
)
5724 else if (flag
& SHF_MASKPROC
)
5727 unknown_flags
|= flag
;
5733 case SHF_WRITE
: *p
= 'W'; break;
5734 case SHF_ALLOC
: *p
= 'A'; break;
5735 case SHF_EXECINSTR
: *p
= 'X'; break;
5736 case SHF_MERGE
: *p
= 'M'; break;
5737 case SHF_STRINGS
: *p
= 'S'; break;
5738 case SHF_INFO_LINK
: *p
= 'I'; break;
5739 case SHF_LINK_ORDER
: *p
= 'L'; break;
5740 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5741 case SHF_GROUP
: *p
= 'G'; break;
5742 case SHF_TLS
: *p
= 'T'; break;
5743 case SHF_EXCLUDE
: *p
= 'E'; break;
5744 case SHF_COMPRESSED
: *p
= 'C'; break;
5745 case SHF_GNU_MBIND
: *p
= 'D'; break;
5748 if ((elf_header
.e_machine
== EM_X86_64
5749 || elf_header
.e_machine
== EM_L1OM
5750 || elf_header
.e_machine
== EM_K1OM
)
5751 && flag
== SHF_X86_64_LARGE
)
5753 else if (elf_header
.e_machine
== EM_ARM
5754 && flag
== SHF_ARM_PURECODE
)
5756 else if (elf_header
.e_machine
== EM_PPC
5757 && flag
== SHF_PPC_VLE
)
5759 else if (flag
& SHF_MASKOS
)
5762 sh_flags
&= ~ SHF_MASKOS
;
5764 else if (flag
& SHF_MASKPROC
)
5767 sh_flags
&= ~ SHF_MASKPROC
;
5777 if (do_section_details
)
5781 size
-= 5 + field_size
;
5782 if (p
!= buff
+ field_size
+ 4)
5786 warn (_("Internal error: not enough buffer room for section flag info"));
5787 return _("<unknown>");
5793 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5794 (unsigned long) os_flags
);
5795 p
+= 5 + field_size
;
5799 size
-= 7 + field_size
;
5800 if (p
!= buff
+ field_size
+ 4)
5804 warn (_("Internal error: not enough buffer room for section flag info"));
5805 return _("<unknown>");
5811 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5812 (unsigned long) proc_flags
);
5813 p
+= 7 + field_size
;
5817 size
-= 10 + field_size
;
5818 if (p
!= buff
+ field_size
+ 4)
5822 warn (_("Internal error: not enough buffer room for section flag info"));
5823 return _("<unknown>");
5829 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5830 (unsigned long) unknown_flags
);
5831 p
+= 10 + field_size
;
5840 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
5844 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5846 if (size
< sizeof (* echdr
))
5848 error (_("Compressed section is too small even for a compression header\n"));
5852 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5853 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5854 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5855 return sizeof (*echdr
);
5859 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5861 if (size
< sizeof (* echdr
))
5863 error (_("Compressed section is too small even for a compression header\n"));
5867 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5868 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5869 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5870 return sizeof (*echdr
);
5875 process_section_headers (FILE * file
)
5877 Elf_Internal_Shdr
* section
;
5880 section_headers
= NULL
;
5882 if (elf_header
.e_shnum
== 0)
5884 /* PR binutils/12467. */
5885 if (elf_header
.e_shoff
!= 0)
5887 warn (_("possibly corrupt ELF file header - it has a non-zero"
5888 " section header offset, but no section headers\n"));
5891 else if (do_sections
)
5892 printf (_("\nThere are no sections in this file.\n"));
5897 if (do_sections
&& !do_header
)
5898 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5899 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5903 if (! get_32bit_section_headers (file
, FALSE
))
5908 if (! get_64bit_section_headers (file
, FALSE
))
5912 /* Read in the string table, so that we have names to display. */
5913 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5914 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5916 section
= section_headers
+ elf_header
.e_shstrndx
;
5918 if (section
->sh_size
!= 0)
5920 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5921 1, section
->sh_size
,
5924 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5928 /* Scan the sections for the dynamic symbol table
5929 and dynamic string table and debug sections. */
5930 dynamic_symbols
= NULL
;
5931 dynamic_strings
= NULL
;
5932 dynamic_syminfo
= NULL
;
5933 symtab_shndx_list
= NULL
;
5935 eh_addr_size
= is_32bit_elf
? 4 : 8;
5936 switch (elf_header
.e_machine
)
5939 case EM_MIPS_RS3_LE
:
5940 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5941 FDE addresses. However, the ABI also has a semi-official ILP32
5942 variant for which the normal FDE address size rules apply.
5944 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5945 section, where XX is the size of longs in bits. Unfortunately,
5946 earlier compilers provided no way of distinguishing ILP32 objects
5947 from LP64 objects, so if there's any doubt, we should assume that
5948 the official LP64 form is being used. */
5949 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5950 && find_section (".gcc_compiled_long32") == NULL
)
5956 switch (elf_header
.e_flags
& EF_H8_MACH
)
5958 case E_H8_MACH_H8300
:
5959 case E_H8_MACH_H8300HN
:
5960 case E_H8_MACH_H8300SN
:
5961 case E_H8_MACH_H8300SXN
:
5964 case E_H8_MACH_H8300H
:
5965 case E_H8_MACH_H8300S
:
5966 case E_H8_MACH_H8300SX
:
5974 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5976 case EF_M32C_CPU_M16C
:
5983 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5986 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5987 if (section->sh_entsize != expected_entsize) \
5990 sprintf_vma (buf, section->sh_entsize); \
5991 /* Note: coded this way so that there is a single string for \
5993 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5994 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5995 (unsigned) expected_entsize); \
5996 section->sh_entsize = expected_entsize; \
6001 #define CHECK_ENTSIZE(section, i, type) \
6002 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6003 sizeof (Elf64_External_##type))
6005 for (i
= 0, section
= section_headers
;
6006 i
< elf_header
.e_shnum
;
6009 char * name
= SECTION_NAME (section
);
6011 if (section
->sh_type
== SHT_DYNSYM
)
6013 if (dynamic_symbols
!= NULL
)
6015 error (_("File contains multiple dynamic symbol tables\n"));
6019 CHECK_ENTSIZE (section
, i
, Sym
);
6020 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
6022 else if (section
->sh_type
== SHT_STRTAB
6023 && streq (name
, ".dynstr"))
6025 if (dynamic_strings
!= NULL
)
6027 error (_("File contains multiple dynamic string tables\n"));
6031 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
6032 1, section
->sh_size
,
6033 _("dynamic strings"));
6034 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
6036 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6038 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6039 entry
->hdr
= section
;
6040 entry
->next
= symtab_shndx_list
;
6041 symtab_shndx_list
= entry
;
6043 else if (section
->sh_type
== SHT_SYMTAB
)
6044 CHECK_ENTSIZE (section
, i
, Sym
);
6045 else if (section
->sh_type
== SHT_GROUP
)
6046 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6047 else if (section
->sh_type
== SHT_REL
)
6048 CHECK_ENTSIZE (section
, i
, Rel
);
6049 else if (section
->sh_type
== SHT_RELA
)
6050 CHECK_ENTSIZE (section
, i
, Rela
);
6051 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6052 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6053 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6054 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6055 || do_debug_addr
|| do_debug_cu_index
)
6056 && (const_strneq (name
, ".debug_")
6057 || const_strneq (name
, ".zdebug_")))
6060 name
+= sizeof (".zdebug_") - 1;
6062 name
+= sizeof (".debug_") - 1;
6065 || (do_debug_info
&& const_strneq (name
, "info"))
6066 || (do_debug_info
&& const_strneq (name
, "types"))
6067 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6068 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6069 || (do_debug_lines
&& const_strneq (name
, "line."))
6070 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6071 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6072 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6073 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6074 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6075 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6076 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6077 || (do_debug_frames
&& const_strneq (name
, "frame"))
6078 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6079 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6080 || (do_debug_str
&& const_strneq (name
, "str"))
6081 || (do_debug_loc
&& const_strneq (name
, "loc"))
6082 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6083 || (do_debug_addr
&& const_strneq (name
, "addr"))
6084 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6085 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6087 request_dump_bynumber (i
, DEBUG_DUMP
);
6089 /* Linkonce section to be combined with .debug_info at link time. */
6090 else if ((do_debugging
|| do_debug_info
)
6091 && const_strneq (name
, ".gnu.linkonce.wi."))
6092 request_dump_bynumber (i
, DEBUG_DUMP
);
6093 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6094 request_dump_bynumber (i
, DEBUG_DUMP
);
6095 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6096 || streq (name
, ".debug_names")))
6097 request_dump_bynumber (i
, DEBUG_DUMP
);
6098 /* Trace sections for Itanium VMS. */
6099 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6100 || do_trace_aranges
)
6101 && const_strneq (name
, ".trace_"))
6103 name
+= sizeof (".trace_") - 1;
6106 || (do_trace_info
&& streq (name
, "info"))
6107 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6108 || (do_trace_aranges
&& streq (name
, "aranges"))
6110 request_dump_bynumber (i
, DEBUG_DUMP
);
6117 if (elf_header
.e_shnum
> 1)
6118 printf (_("\nSection Headers:\n"));
6120 printf (_("\nSection Header:\n"));
6124 if (do_section_details
)
6126 printf (_(" [Nr] Name\n"));
6127 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6131 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6135 if (do_section_details
)
6137 printf (_(" [Nr] Name\n"));
6138 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6142 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6146 if (do_section_details
)
6148 printf (_(" [Nr] Name\n"));
6149 printf (_(" Type Address Offset Link\n"));
6150 printf (_(" Size EntSize Info Align\n"));
6154 printf (_(" [Nr] Name Type Address Offset\n"));
6155 printf (_(" Size EntSize Flags Link Info Align\n"));
6159 if (do_section_details
)
6160 printf (_(" Flags\n"));
6162 for (i
= 0, section
= section_headers
;
6163 i
< elf_header
.e_shnum
;
6166 /* Run some sanity checks on the section header. */
6168 /* Check the sh_link field. */
6169 switch (section
->sh_type
)
6171 case SHT_SYMTAB_SHNDX
:
6175 case SHT_GNU_versym
:
6178 if (section
->sh_link
< 1
6179 || section
->sh_link
>= elf_header
.e_shnum
6180 || (section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6181 && section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6182 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6183 i
, section
->sh_link
);
6189 case SHT_GNU_verneed
:
6190 case SHT_GNU_verdef
:
6191 case SHT_GNU_LIBLIST
:
6192 if (section
->sh_link
< 1
6193 || section
->sh_link
>= elf_header
.e_shnum
6194 || section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6195 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6196 i
, section
->sh_link
);
6199 case SHT_INIT_ARRAY
:
6200 case SHT_FINI_ARRAY
:
6201 case SHT_PREINIT_ARRAY
:
6202 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6203 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6204 i
, section
->sh_link
);
6208 /* FIXME: Add support for target specific section types. */
6209 #if 0 /* Currently we do not check other section types as there are too
6210 many special cases. Stab sections for example have a type
6211 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6213 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6214 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6215 i
, section
->sh_link
);
6220 /* Check the sh_info field. */
6221 switch (section
->sh_type
)
6225 if (section
->sh_info
< 1
6226 || section
->sh_info
>= elf_header
.e_shnum
6227 || (section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6228 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6229 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6230 && section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6231 /* FIXME: Are other section types valid ? */
6232 && section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6234 if (section
->sh_info
== 0
6235 && (streq (SECTION_NAME (section
), ".rel.dyn")
6236 || streq (SECTION_NAME (section
), ".rela.dyn")))
6237 /* The .rel.dyn and .rela.dyn sections have an sh_info field
6238 of zero. The relocations in these sections may apply
6239 to many different sections. */
6242 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6243 i
, section
->sh_info
);
6249 case SHT_SYMTAB_SHNDX
:
6250 case SHT_INIT_ARRAY
:
6251 case SHT_FINI_ARRAY
:
6252 case SHT_PREINIT_ARRAY
:
6253 if (section
->sh_info
!= 0)
6254 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6255 i
, section
->sh_info
);
6261 /* A symbol index - we assume that it is valid. */
6265 /* FIXME: Add support for target specific section types. */
6266 if (section
->sh_type
== SHT_NOBITS
)
6267 /* NOBITS section headers with non-zero sh_info fields can be
6268 created when a binary is stripped of everything but its debug
6269 information. The stripped sections have their headers
6270 preserved but their types set to SHT_NOBITS. So do not check
6271 this type of section. */
6273 else if (section
->sh_flags
& SHF_INFO_LINK
)
6275 if (section
->sh_info
< 1 || section
->sh_info
>= elf_header
.e_shnum
)
6276 warn (_("[%2u]: Expected link to another section in info field"), i
);
6278 else if (section
->sh_type
< SHT_LOOS
6279 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6280 && section
->sh_info
!= 0)
6281 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6282 i
, section
->sh_info
);
6286 /* Check the sh_size field. */
6287 if (section
->sh_size
> current_file_size
6288 && section
->sh_type
!= SHT_NOBITS
6289 && section
->sh_type
!= SHT_NULL
6290 && section
->sh_type
< SHT_LOOS
)
6291 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6293 printf (" [%2u] ", i
);
6294 if (do_section_details
)
6295 printf ("%s\n ", printable_section_name (section
));
6297 print_symbol (-17, SECTION_NAME (section
));
6299 printf (do_wide
? " %-15s " : " %-15.15s ",
6300 get_section_type_name (section
->sh_type
));
6304 const char * link_too_big
= NULL
;
6306 print_vma (section
->sh_addr
, LONG_HEX
);
6308 printf ( " %6.6lx %6.6lx %2.2lx",
6309 (unsigned long) section
->sh_offset
,
6310 (unsigned long) section
->sh_size
,
6311 (unsigned long) section
->sh_entsize
);
6313 if (do_section_details
)
6314 fputs (" ", stdout
);
6316 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6318 if (section
->sh_link
>= elf_header
.e_shnum
)
6321 /* The sh_link value is out of range. Normally this indicates
6322 an error but it can have special values in Solaris binaries. */
6323 switch (elf_header
.e_machine
)
6330 case EM_OLD_SPARCV9
:
6331 case EM_SPARC32PLUS
:
6334 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6335 link_too_big
= "BEFORE";
6336 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6337 link_too_big
= "AFTER";
6344 if (do_section_details
)
6346 if (link_too_big
!= NULL
&& * link_too_big
)
6347 printf ("<%s> ", link_too_big
);
6349 printf ("%2u ", section
->sh_link
);
6350 printf ("%3u %2lu\n", section
->sh_info
,
6351 (unsigned long) section
->sh_addralign
);
6354 printf ("%2u %3u %2lu\n",
6357 (unsigned long) section
->sh_addralign
);
6359 if (link_too_big
&& ! * link_too_big
)
6360 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6361 i
, section
->sh_link
);
6365 print_vma (section
->sh_addr
, LONG_HEX
);
6367 if ((long) section
->sh_offset
== section
->sh_offset
)
6368 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6372 print_vma (section
->sh_offset
, LONG_HEX
);
6375 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6376 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6380 print_vma (section
->sh_size
, LONG_HEX
);
6383 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6384 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6388 print_vma (section
->sh_entsize
, LONG_HEX
);
6391 if (do_section_details
)
6392 fputs (" ", stdout
);
6394 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6396 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6398 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6399 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6402 print_vma (section
->sh_addralign
, DEC
);
6406 else if (do_section_details
)
6408 printf (" %-15.15s ",
6409 get_section_type_name (section
->sh_type
));
6410 print_vma (section
->sh_addr
, LONG_HEX
);
6411 if ((long) section
->sh_offset
== section
->sh_offset
)
6412 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6416 print_vma (section
->sh_offset
, LONG_HEX
);
6418 printf (" %u\n ", section
->sh_link
);
6419 print_vma (section
->sh_size
, LONG_HEX
);
6421 print_vma (section
->sh_entsize
, LONG_HEX
);
6423 printf (" %-16u %lu\n",
6425 (unsigned long) section
->sh_addralign
);
6430 print_vma (section
->sh_addr
, LONG_HEX
);
6431 if ((long) section
->sh_offset
== section
->sh_offset
)
6432 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6436 print_vma (section
->sh_offset
, LONG_HEX
);
6439 print_vma (section
->sh_size
, LONG_HEX
);
6441 print_vma (section
->sh_entsize
, LONG_HEX
);
6443 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6445 printf (" %2u %3u %lu\n",
6448 (unsigned long) section
->sh_addralign
);
6451 if (do_section_details
)
6453 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
6454 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6456 /* Minimum section size is 12 bytes for 32-bit compression
6457 header + 12 bytes for compressed data header. */
6458 unsigned char buf
[24];
6460 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6461 if (get_data (&buf
, (FILE *) file
, section
->sh_offset
, 1,
6462 sizeof (buf
), _("compression header")))
6464 Elf_Internal_Chdr chdr
;
6466 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6468 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6471 printf (_(" [<unknown>: 0x%x], "),
6473 print_vma (chdr
.ch_size
, LONG_HEX
);
6474 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6480 if (!do_section_details
)
6482 /* The ordering of the letters shown here matches the ordering of the
6483 corresponding SHF_xxx values, and hence the order in which these
6484 letters will be displayed to the user. */
6485 printf (_("Key to Flags:\n\
6486 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6487 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6488 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6489 if (elf_header
.e_machine
== EM_X86_64
6490 || elf_header
.e_machine
== EM_L1OM
6491 || elf_header
.e_machine
== EM_K1OM
)
6492 printf (_("l (large), "));
6493 else if (elf_header
.e_machine
== EM_ARM
)
6494 printf (_("y (purecode), "));
6495 else if (elf_header
.e_machine
== EM_PPC
)
6496 printf (_("v (VLE), "));
6497 printf ("p (processor specific)\n");
6504 get_group_flags (unsigned int flags
)
6506 static char buff
[128];
6510 else if (flags
== GRP_COMDAT
)
6513 snprintf (buff
, 14, _("[0x%x: "), flags
);
6515 flags
&= ~ GRP_COMDAT
;
6516 if (flags
& GRP_MASKOS
)
6518 strcat (buff
, "<OS specific>");
6519 flags
&= ~ GRP_MASKOS
;
6522 if (flags
& GRP_MASKPROC
)
6524 strcat (buff
, "<PROC specific>");
6525 flags
&= ~ GRP_MASKPROC
;
6529 strcat (buff
, "<unknown>");
6536 process_section_groups (FILE * file
)
6538 Elf_Internal_Shdr
* section
;
6540 struct group
* group
;
6541 Elf_Internal_Shdr
* symtab_sec
;
6542 Elf_Internal_Shdr
* strtab_sec
;
6543 Elf_Internal_Sym
* symtab
;
6544 unsigned long num_syms
;
6548 /* Don't process section groups unless needed. */
6549 if (!do_unwind
&& !do_section_groups
)
6552 if (elf_header
.e_shnum
== 0)
6554 if (do_section_groups
)
6555 printf (_("\nThere are no sections to group in this file.\n"));
6560 if (section_headers
== NULL
)
6562 error (_("Section headers are not available!\n"));
6563 /* PR 13622: This can happen with a corrupt ELF header. */
6567 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
6568 sizeof (struct group
*));
6570 if (section_headers_groups
== NULL
)
6572 error (_("Out of memory reading %u section group headers\n"),
6573 elf_header
.e_shnum
);
6577 /* Scan the sections for the group section. */
6579 for (i
= 0, section
= section_headers
;
6580 i
< elf_header
.e_shnum
;
6582 if (section
->sh_type
== SHT_GROUP
)
6585 if (group_count
== 0)
6587 if (do_section_groups
)
6588 printf (_("\nThere are no section groups in this file.\n"));
6593 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6595 if (section_groups
== NULL
)
6597 error (_("Out of memory reading %lu groups\n"),
6598 (unsigned long) group_count
);
6608 for (i
= 0, section
= section_headers
, group
= section_groups
;
6609 i
< elf_header
.e_shnum
;
6612 if (section
->sh_type
== SHT_GROUP
)
6614 const char * name
= printable_section_name (section
);
6615 const char * group_name
;
6616 unsigned char * start
;
6617 unsigned char * indices
;
6618 unsigned int entry
, j
, size
;
6619 Elf_Internal_Shdr
* sec
;
6620 Elf_Internal_Sym
* sym
;
6622 /* Get the symbol table. */
6623 if (section
->sh_link
>= elf_header
.e_shnum
6624 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
6627 error (_("Bad sh_link in group section `%s'\n"), name
);
6631 if (symtab_sec
!= sec
)
6636 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
6641 error (_("Corrupt header in group section `%s'\n"), name
);
6645 if (section
->sh_info
>= num_syms
)
6647 error (_("Bad sh_info in group section `%s'\n"), name
);
6651 sym
= symtab
+ section
->sh_info
;
6653 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6655 if (sym
->st_shndx
== 0
6656 || sym
->st_shndx
>= elf_header
.e_shnum
)
6658 error (_("Bad sh_info in group section `%s'\n"), name
);
6662 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
6671 /* Get the string table. */
6672 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
6681 != (sec
= section_headers
+ symtab_sec
->sh_link
))
6687 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
6688 1, strtab_sec
->sh_size
,
6690 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6692 group_name
= sym
->st_name
< strtab_size
6693 ? strtab
+ sym
->st_name
: _("<corrupt>");
6696 /* PR 17531: file: loop. */
6697 if (section
->sh_entsize
> section
->sh_size
)
6699 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6700 printable_section_name (section
),
6701 (unsigned long) section
->sh_entsize
,
6702 (unsigned long) section
->sh_size
);
6706 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
6707 1, section
->sh_size
,
6713 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6714 entry
= byte_get (indices
, 4);
6717 if (do_section_groups
)
6719 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6720 get_group_flags (entry
), i
, name
, group_name
, size
);
6722 printf (_(" [Index] Name\n"));
6725 group
->group_index
= i
;
6727 for (j
= 0; j
< size
; j
++)
6729 struct group_list
* g
;
6731 entry
= byte_get (indices
, 4);
6734 if (entry
>= elf_header
.e_shnum
)
6736 static unsigned num_group_errors
= 0;
6738 if (num_group_errors
++ < 10)
6740 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6741 entry
, i
, elf_header
.e_shnum
- 1);
6742 if (num_group_errors
== 10)
6743 warn (_("Further error messages about overlarge group section indicies suppressed\n"));
6748 if (section_headers_groups
[entry
] != NULL
)
6752 static unsigned num_errs
= 0;
6754 if (num_errs
++ < 10)
6756 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6758 section_headers_groups
[entry
]->group_index
);
6760 warn (_("Further error messages about already contained group sections suppressed\n"));
6766 /* Intel C/C++ compiler may put section 0 in a
6767 section group. We just warn it the first time
6768 and ignore it afterwards. */
6769 static bfd_boolean warned
= FALSE
;
6772 error (_("section 0 in group section [%5u]\n"),
6773 section_headers_groups
[entry
]->group_index
);
6779 section_headers_groups
[entry
] = group
;
6781 if (do_section_groups
)
6783 sec
= section_headers
+ entry
;
6784 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6787 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6788 g
->section_index
= entry
;
6789 g
->next
= group
->root
;
6807 /* Data used to display dynamic fixups. */
6809 struct ia64_vms_dynfixup
6811 bfd_vma needed_ident
; /* Library ident number. */
6812 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6813 bfd_vma fixup_needed
; /* Index of the library. */
6814 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6815 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6818 /* Data used to display dynamic relocations. */
6820 struct ia64_vms_dynimgrela
6822 bfd_vma img_rela_cnt
; /* Number of relocations. */
6823 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6826 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6830 dump_ia64_vms_dynamic_fixups (FILE * file
,
6831 struct ia64_vms_dynfixup
* fixup
,
6832 const char * strtab
,
6833 unsigned int strtab_sz
)
6835 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
6837 const char * lib_name
;
6839 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6840 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6841 _("dynamic section image fixups"));
6845 if (fixup
->needed
< strtab_sz
)
6846 lib_name
= strtab
+ fixup
->needed
;
6849 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6850 (unsigned long) fixup
->needed
);
6853 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6854 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6856 (_("Seg Offset Type SymVec DataType\n"));
6858 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6863 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6864 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6865 type
= BYTE_GET (imfs
[i
].type
);
6866 rtype
= elf_ia64_reloc_type (type
);
6868 printf (" 0x%08x ", type
);
6870 printf (" %-32s ", rtype
);
6871 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6872 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6879 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6882 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6884 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6887 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6888 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6889 _("dynamic section image relocations"));
6893 printf (_("\nImage relocs\n"));
6895 (_("Seg Offset Type Addend Seg Sym Off\n"));
6897 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6902 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6903 printf ("%08" BFD_VMA_FMT
"x ",
6904 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6905 type
= BYTE_GET (imrs
[i
].type
);
6906 rtype
= elf_ia64_reloc_type (type
);
6908 printf ("0x%08x ", type
);
6910 printf ("%-31s ", rtype
);
6911 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6912 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6913 printf ("%08" BFD_VMA_FMT
"x\n",
6914 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6921 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6924 process_ia64_vms_dynamic_relocs (FILE *file
)
6926 struct ia64_vms_dynfixup fixup
;
6927 struct ia64_vms_dynimgrela imgrela
;
6928 Elf_Internal_Dyn
*entry
;
6929 bfd_vma strtab_off
= 0;
6930 bfd_vma strtab_sz
= 0;
6931 char *strtab
= NULL
;
6932 bfd_boolean res
= TRUE
;
6934 memset (&fixup
, 0, sizeof (fixup
));
6935 memset (&imgrela
, 0, sizeof (imgrela
));
6937 /* Note: the order of the entries is specified by the OpenVMS specs. */
6938 for (entry
= dynamic_section
;
6939 entry
< dynamic_section
+ dynamic_nent
;
6942 switch (entry
->d_tag
)
6944 case DT_IA_64_VMS_STRTAB_OFFSET
:
6945 strtab_off
= entry
->d_un
.d_val
;
6948 strtab_sz
= entry
->d_un
.d_val
;
6950 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6951 1, strtab_sz
, _("dynamic string section"));
6954 case DT_IA_64_VMS_NEEDED_IDENT
:
6955 fixup
.needed_ident
= entry
->d_un
.d_val
;
6958 fixup
.needed
= entry
->d_un
.d_val
;
6960 case DT_IA_64_VMS_FIXUP_NEEDED
:
6961 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6963 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6964 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6966 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6967 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6968 if (! dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
))
6971 case DT_IA_64_VMS_IMG_RELA_CNT
:
6972 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6974 case DT_IA_64_VMS_IMG_RELA_OFF
:
6975 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6976 if (! dump_ia64_vms_dynamic_relocs (file
, &imgrela
))
6998 dynamic_relocations
[] =
7000 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7001 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7002 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7005 /* Process the reloc section. */
7008 process_relocs (FILE * file
)
7010 unsigned long rel_size
;
7011 unsigned long rel_offset
;
7016 if (do_using_dynamic
)
7020 bfd_boolean has_dynamic_reloc
;
7023 has_dynamic_reloc
= FALSE
;
7025 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7027 is_rela
= dynamic_relocations
[i
].rela
;
7028 name
= dynamic_relocations
[i
].name
;
7029 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
7030 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
7033 has_dynamic_reloc
= TRUE
;
7035 if (is_rela
== UNKNOWN
)
7037 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7038 switch (dynamic_info
[DT_PLTREL
])
7052 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7053 name
, rel_offset
, rel_size
);
7055 dump_relocations (file
,
7056 offset_from_vma (file
, rel_offset
, rel_size
),
7058 dynamic_symbols
, num_dynamic_syms
,
7059 dynamic_strings
, dynamic_strings_length
,
7060 is_rela
, TRUE
/* is_dynamic */);
7065 if (process_ia64_vms_dynamic_relocs (file
))
7066 has_dynamic_reloc
= TRUE
;
7068 if (! has_dynamic_reloc
)
7069 printf (_("\nThere are no dynamic relocations in this file.\n"));
7073 Elf_Internal_Shdr
* section
;
7075 bfd_boolean found
= FALSE
;
7077 for (i
= 0, section
= section_headers
;
7078 i
< elf_header
.e_shnum
;
7081 if ( section
->sh_type
!= SHT_RELA
7082 && section
->sh_type
!= SHT_REL
)
7085 rel_offset
= section
->sh_offset
;
7086 rel_size
= section
->sh_size
;
7090 Elf_Internal_Shdr
* strsec
;
7093 printf (_("\nRelocation section "));
7095 if (string_table
== NULL
)
7096 printf ("%d", section
->sh_name
);
7098 printf ("'%s'", printable_section_name (section
));
7100 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7101 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
7103 is_rela
= section
->sh_type
== SHT_RELA
;
7105 if (section
->sh_link
!= 0
7106 && section
->sh_link
< elf_header
.e_shnum
)
7108 Elf_Internal_Shdr
* symsec
;
7109 Elf_Internal_Sym
* symtab
;
7110 unsigned long nsyms
;
7111 unsigned long strtablen
= 0;
7112 char * strtab
= NULL
;
7114 symsec
= section_headers
+ section
->sh_link
;
7115 if (symsec
->sh_type
!= SHT_SYMTAB
7116 && symsec
->sh_type
!= SHT_DYNSYM
)
7119 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
7124 if (symsec
->sh_link
!= 0
7125 && symsec
->sh_link
< elf_header
.e_shnum
)
7127 strsec
= section_headers
+ symsec
->sh_link
;
7129 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7132 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7135 dump_relocations (file
, rel_offset
, rel_size
,
7136 symtab
, nsyms
, strtab
, strtablen
,
7138 symsec
->sh_type
== SHT_DYNSYM
);
7144 dump_relocations (file
, rel_offset
, rel_size
,
7145 NULL
, 0, NULL
, 0, is_rela
,
7146 FALSE
/* is_dynamic */);
7153 printf (_("\nThere are no relocations in this file.\n"));
7159 /* An absolute address consists of a section and an offset. If the
7160 section is NULL, the offset itself is the address, otherwise, the
7161 address equals to LOAD_ADDRESS(section) + offset. */
7165 unsigned short section
;
7169 #define ABSADDR(a) \
7171 ? section_headers [(a).section].sh_addr + (a).offset \
7174 /* Find the nearest symbol at or below ADDR. Returns the symbol
7175 name, if found, and the offset from the symbol to ADDR. */
7178 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
7179 unsigned long nsyms
,
7180 const char * strtab
,
7181 unsigned long strtab_size
,
7182 struct absaddr addr
,
7183 const char ** symname
,
7186 bfd_vma dist
= 0x100000;
7187 Elf_Internal_Sym
* sym
;
7188 Elf_Internal_Sym
* beg
;
7189 Elf_Internal_Sym
* end
;
7190 Elf_Internal_Sym
* best
= NULL
;
7192 REMOVE_ARCH_BITS (addr
.offset
);
7194 end
= symtab
+ nsyms
;
7200 sym
= beg
+ (end
- beg
) / 2;
7202 value
= sym
->st_value
;
7203 REMOVE_ARCH_BITS (value
);
7205 if (sym
->st_name
!= 0
7206 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7207 && addr
.offset
>= value
7208 && addr
.offset
- value
< dist
)
7211 dist
= addr
.offset
- value
;
7216 if (addr
.offset
< value
)
7224 *symname
= (best
->st_name
>= strtab_size
7225 ? _("<corrupt>") : strtab
+ best
->st_name
);
7231 *offset
= addr
.offset
;
7234 static /* signed */ int
7235 symcmp (const void *p
, const void *q
)
7237 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7238 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7240 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7243 /* Process the unwind section. */
7245 #include "unwind-ia64.h"
7247 struct ia64_unw_table_entry
7249 struct absaddr start
;
7251 struct absaddr info
;
7254 struct ia64_unw_aux_info
7256 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7257 unsigned long table_len
; /* Length of unwind table. */
7258 unsigned char * info
; /* Unwind info. */
7259 unsigned long info_size
; /* Size of unwind info. */
7260 bfd_vma info_addr
; /* Starting address of unwind info. */
7261 bfd_vma seg_base
; /* Starting address of segment. */
7262 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7263 unsigned long nsyms
; /* Number of symbols. */
7264 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7265 unsigned long nfuns
; /* Number of entries in funtab. */
7266 char * strtab
; /* The string table. */
7267 unsigned long strtab_size
; /* Size of string table. */
7271 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
7273 struct ia64_unw_table_entry
* tp
;
7274 unsigned long j
, nfuns
;
7276 bfd_boolean res
= TRUE
;
7278 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7279 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7280 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7281 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7283 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7285 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7289 const unsigned char * dp
;
7290 const unsigned char * head
;
7291 const unsigned char * end
;
7292 const char * procname
;
7294 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7295 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7297 fputs ("\n<", stdout
);
7301 fputs (procname
, stdout
);
7304 printf ("+%lx", (unsigned long) offset
);
7307 fputs (">: [", stdout
);
7308 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7309 fputc ('-', stdout
);
7310 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7311 printf ("], info at +0x%lx\n",
7312 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7314 /* PR 17531: file: 86232b32. */
7315 if (aux
->info
== NULL
)
7318 /* PR 17531: file: 0997b4d1. */
7319 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7321 warn (_("Invalid offset %lx in table entry %ld\n"),
7322 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7327 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7328 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7330 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7331 (unsigned) UNW_VER (stamp
),
7332 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7333 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7334 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7335 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7337 if (UNW_VER (stamp
) != 1)
7339 printf (_("\tUnknown version.\n"));
7344 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7345 /* PR 17531: file: 16ceda89. */
7346 if (end
> aux
->info
+ aux
->info_size
)
7347 end
= aux
->info
+ aux
->info_size
;
7348 for (dp
= head
+ 8; dp
< end
;)
7349 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7358 slurp_ia64_unwind_table (FILE * file
,
7359 struct ia64_unw_aux_info
* aux
,
7360 Elf_Internal_Shdr
* sec
)
7362 unsigned long size
, nrelas
, i
;
7363 Elf_Internal_Phdr
* seg
;
7364 struct ia64_unw_table_entry
* tep
;
7365 Elf_Internal_Shdr
* relsec
;
7366 Elf_Internal_Rela
* rela
;
7367 Elf_Internal_Rela
* rp
;
7368 unsigned char * table
;
7370 Elf_Internal_Sym
* sym
;
7371 const char * relname
;
7375 /* First, find the starting address of the segment that includes
7378 if (elf_header
.e_phnum
)
7380 if (! get_program_headers (file
))
7383 for (seg
= program_headers
;
7384 seg
< program_headers
+ elf_header
.e_phnum
;
7387 if (seg
->p_type
!= PT_LOAD
)
7390 if (sec
->sh_addr
>= seg
->p_vaddr
7391 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7393 aux
->seg_base
= seg
->p_vaddr
;
7399 /* Second, build the unwind table from the contents of the unwind section: */
7400 size
= sec
->sh_size
;
7401 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7406 aux
->table_len
= size
/ (3 * eh_addr_size
);
7407 aux
->table
= (struct ia64_unw_table_entry
*)
7408 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7411 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7413 tep
->start
.section
= SHN_UNDEF
;
7414 tep
->end
.section
= SHN_UNDEF
;
7415 tep
->info
.section
= SHN_UNDEF
;
7416 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7417 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7418 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7419 tep
->start
.offset
+= aux
->seg_base
;
7420 tep
->end
.offset
+= aux
->seg_base
;
7421 tep
->info
.offset
+= aux
->seg_base
;
7425 /* Third, apply any relocations to the unwind table: */
7426 for (relsec
= section_headers
;
7427 relsec
< section_headers
+ elf_header
.e_shnum
;
7430 if (relsec
->sh_type
!= SHT_RELA
7431 || relsec
->sh_info
>= elf_header
.e_shnum
7432 || section_headers
+ relsec
->sh_info
!= sec
)
7435 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7444 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7446 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
7447 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7449 /* PR 17531: file: 9fa67536. */
7450 if (relname
== NULL
)
7452 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp
->r_info
));
7456 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7458 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7462 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7464 /* PR 17531: file: 5bc8d9bf. */
7465 if (i
>= aux
->table_len
)
7467 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7471 switch (rp
->r_offset
/ eh_addr_size
% 3)
7474 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7475 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7478 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7479 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7482 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7483 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7497 ia64_process_unwind (FILE * file
)
7499 Elf_Internal_Shdr
* sec
;
7500 Elf_Internal_Shdr
* unwsec
= NULL
;
7501 Elf_Internal_Shdr
* strsec
;
7502 unsigned long i
, unwcount
= 0, unwstart
= 0;
7503 struct ia64_unw_aux_info aux
;
7504 bfd_boolean res
= TRUE
;
7506 memset (& aux
, 0, sizeof (aux
));
7508 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7510 if (sec
->sh_type
== SHT_SYMTAB
7511 && sec
->sh_link
< elf_header
.e_shnum
)
7513 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7515 strsec
= section_headers
+ sec
->sh_link
;
7516 if (aux
.strtab
!= NULL
)
7518 error (_("Multiple auxillary string tables encountered\n"));
7522 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7525 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7527 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7532 printf (_("\nThere are no unwind sections in this file.\n"));
7534 while (unwcount
-- > 0)
7539 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
7540 i
< elf_header
.e_shnum
; ++i
, ++sec
)
7541 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7546 /* We have already counted the number of SHT_IA64_UNWIND
7547 sections so the loop above should never fail. */
7548 assert (unwsec
!= NULL
);
7551 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7553 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7555 /* We need to find which section group it is in. */
7556 struct group_list
* g
;
7558 if (section_headers_groups
== NULL
7559 || section_headers_groups
[i
] == NULL
)
7560 i
= elf_header
.e_shnum
;
7563 g
= section_headers_groups
[i
]->root
;
7565 for (; g
!= NULL
; g
= g
->next
)
7567 sec
= section_headers
+ g
->section_index
;
7569 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7574 i
= elf_header
.e_shnum
;
7577 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7579 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7580 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7581 suffix
= SECTION_NAME (unwsec
) + len
;
7582 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7584 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7585 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7590 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7591 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7592 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7593 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7595 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7596 suffix
= SECTION_NAME (unwsec
) + len
;
7597 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7599 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7600 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7604 if (i
== elf_header
.e_shnum
)
7606 printf (_("\nCould not find unwind info section for "));
7608 if (string_table
== NULL
)
7609 printf ("%d", unwsec
->sh_name
);
7611 printf ("'%s'", printable_section_name (unwsec
));
7615 aux
.info_addr
= sec
->sh_addr
;
7616 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
7619 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7621 printf (_("\nUnwind section "));
7623 if (string_table
== NULL
)
7624 printf ("%d", unwsec
->sh_name
);
7626 printf ("'%s'", printable_section_name (unwsec
));
7628 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7629 (unsigned long) unwsec
->sh_offset
,
7630 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7632 if (slurp_ia64_unwind_table (file
, & aux
, unwsec
)
7633 && aux
.table_len
> 0)
7634 dump_ia64_unwind (& aux
);
7637 free ((char *) aux
.table
);
7639 free ((char *) aux
.info
);
7648 free ((char *) aux
.strtab
);
7653 struct hppa_unw_table_entry
7655 struct absaddr start
;
7657 unsigned int Cannot_unwind
:1; /* 0 */
7658 unsigned int Millicode
:1; /* 1 */
7659 unsigned int Millicode_save_sr0
:1; /* 2 */
7660 unsigned int Region_description
:2; /* 3..4 */
7661 unsigned int reserved1
:1; /* 5 */
7662 unsigned int Entry_SR
:1; /* 6 */
7663 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7664 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7665 unsigned int Args_stored
:1; /* 16 */
7666 unsigned int Variable_Frame
:1; /* 17 */
7667 unsigned int Separate_Package_Body
:1; /* 18 */
7668 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7669 unsigned int Stack_Overflow_Check
:1; /* 20 */
7670 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7671 unsigned int Ada_Region
:1; /* 22 */
7672 unsigned int cxx_info
:1; /* 23 */
7673 unsigned int cxx_try_catch
:1; /* 24 */
7674 unsigned int sched_entry_seq
:1; /* 25 */
7675 unsigned int reserved2
:1; /* 26 */
7676 unsigned int Save_SP
:1; /* 27 */
7677 unsigned int Save_RP
:1; /* 28 */
7678 unsigned int Save_MRP_in_frame
:1; /* 29 */
7679 unsigned int extn_ptr_defined
:1; /* 30 */
7680 unsigned int Cleanup_defined
:1; /* 31 */
7682 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7683 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7684 unsigned int Large_frame
:1; /* 2 */
7685 unsigned int Pseudo_SP_Set
:1; /* 3 */
7686 unsigned int reserved4
:1; /* 4 */
7687 unsigned int Total_frame_size
:27; /* 5..31 */
7690 struct hppa_unw_aux_info
7692 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7693 unsigned long table_len
; /* Length of unwind table. */
7694 bfd_vma seg_base
; /* Starting address of segment. */
7695 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7696 unsigned long nsyms
; /* Number of symbols. */
7697 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7698 unsigned long nfuns
; /* Number of entries in funtab. */
7699 char * strtab
; /* The string table. */
7700 unsigned long strtab_size
; /* Size of string table. */
7704 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
7706 struct hppa_unw_table_entry
* tp
;
7707 unsigned long j
, nfuns
;
7708 bfd_boolean res
= TRUE
;
7710 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7711 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7712 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7713 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7715 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7717 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7720 const char * procname
;
7722 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7723 aux
->strtab_size
, tp
->start
, &procname
,
7726 fputs ("\n<", stdout
);
7730 fputs (procname
, stdout
);
7733 printf ("+%lx", (unsigned long) offset
);
7736 fputs (">: [", stdout
);
7737 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7738 fputc ('-', stdout
);
7739 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7742 #define PF(_m) if (tp->_m) printf (#_m " ");
7743 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7746 PF(Millicode_save_sr0
);
7747 /* PV(Region_description); */
7753 PF(Separate_Package_Body
);
7754 PF(Frame_Extension_Millicode
);
7755 PF(Stack_Overflow_Check
);
7756 PF(Two_Instruction_SP_Increment
);
7760 PF(sched_entry_seq
);
7763 PF(Save_MRP_in_frame
);
7764 PF(extn_ptr_defined
);
7765 PF(Cleanup_defined
);
7766 PF(MPE_XL_interrupt_marker
);
7767 PF(HP_UX_interrupt_marker
);
7770 PV(Total_frame_size
);
7783 slurp_hppa_unwind_table (FILE * file
,
7784 struct hppa_unw_aux_info
* aux
,
7785 Elf_Internal_Shdr
* sec
)
7787 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7788 Elf_Internal_Phdr
* seg
;
7789 struct hppa_unw_table_entry
* tep
;
7790 Elf_Internal_Shdr
* relsec
;
7791 Elf_Internal_Rela
* rela
;
7792 Elf_Internal_Rela
* rp
;
7793 unsigned char * table
;
7795 Elf_Internal_Sym
* sym
;
7796 const char * relname
;
7798 /* First, find the starting address of the segment that includes
7800 if (elf_header
.e_phnum
)
7802 if (! get_program_headers (file
))
7805 for (seg
= program_headers
;
7806 seg
< program_headers
+ elf_header
.e_phnum
;
7809 if (seg
->p_type
!= PT_LOAD
)
7812 if (sec
->sh_addr
>= seg
->p_vaddr
7813 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7815 aux
->seg_base
= seg
->p_vaddr
;
7821 /* Second, build the unwind table from the contents of the unwind
7823 size
= sec
->sh_size
;
7824 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7830 nentries
= size
/ unw_ent_size
;
7831 size
= unw_ent_size
* nentries
;
7833 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7834 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7836 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7838 unsigned int tmp1
, tmp2
;
7840 tep
->start
.section
= SHN_UNDEF
;
7841 tep
->end
.section
= SHN_UNDEF
;
7843 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7844 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7845 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7846 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7848 tep
->start
.offset
+= aux
->seg_base
;
7849 tep
->end
.offset
+= aux
->seg_base
;
7851 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7852 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7853 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7854 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7855 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7856 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7857 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7858 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7859 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7860 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7861 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7862 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7863 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7864 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7865 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7866 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7867 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7868 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7869 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7870 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7871 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7872 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7873 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7874 tep
->Cleanup_defined
= tmp1
& 0x1;
7876 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7877 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7878 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7879 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7880 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7881 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7885 /* Third, apply any relocations to the unwind table. */
7886 for (relsec
= section_headers
;
7887 relsec
< section_headers
+ elf_header
.e_shnum
;
7890 if (relsec
->sh_type
!= SHT_RELA
7891 || relsec
->sh_info
>= elf_header
.e_shnum
7892 || section_headers
+ relsec
->sh_info
!= sec
)
7895 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7899 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7901 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7902 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7904 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7905 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7907 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7911 i
= rp
->r_offset
/ unw_ent_size
;
7913 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7916 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7917 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7920 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7921 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7931 aux
->table_len
= nentries
;
7937 hppa_process_unwind (FILE * file
)
7939 struct hppa_unw_aux_info aux
;
7940 Elf_Internal_Shdr
* unwsec
= NULL
;
7941 Elf_Internal_Shdr
* strsec
;
7942 Elf_Internal_Shdr
* sec
;
7944 bfd_boolean res
= TRUE
;
7946 if (string_table
== NULL
)
7949 memset (& aux
, 0, sizeof (aux
));
7951 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7953 if (sec
->sh_type
== SHT_SYMTAB
7954 && sec
->sh_link
< elf_header
.e_shnum
)
7956 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7958 strsec
= section_headers
+ sec
->sh_link
;
7959 if (aux
.strtab
!= NULL
)
7961 error (_("Multiple auxillary string tables encountered\n"));
7965 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7968 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7970 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7975 printf (_("\nThere are no unwind sections in this file.\n"));
7977 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7979 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7981 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7982 printable_section_name (sec
),
7983 (unsigned long) sec
->sh_offset
,
7984 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7986 if (! slurp_hppa_unwind_table (file
, &aux
, sec
))
7989 if (aux
.table_len
> 0)
7991 if (! dump_hppa_unwind (&aux
))
7996 free ((char *) aux
.table
);
8004 free ((char *) aux
.strtab
);
8011 unsigned char * data
; /* The unwind data. */
8012 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8013 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8014 unsigned long nrelas
; /* The number of relocations. */
8015 unsigned int rel_type
; /* REL or RELA ? */
8016 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8019 struct arm_unw_aux_info
8021 FILE * file
; /* The file containing the unwind sections. */
8022 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8023 unsigned long nsyms
; /* Number of symbols. */
8024 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8025 unsigned long nfuns
; /* Number of these symbols. */
8026 char * strtab
; /* The file's string table. */
8027 unsigned long strtab_size
; /* Size of string table. */
8031 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
8032 bfd_vma fn
, struct absaddr addr
)
8034 const char *procname
;
8037 if (addr
.section
== SHN_UNDEF
)
8040 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8041 aux
->strtab_size
, addr
, &procname
,
8044 print_vma (fn
, PREFIX_HEX
);
8048 fputs (" <", stdout
);
8049 fputs (procname
, stdout
);
8052 printf ("+0x%lx", (unsigned long) sym_offset
);
8053 fputc ('>', stdout
);
8060 arm_free_section (struct arm_section
*arm_sec
)
8062 if (arm_sec
->data
!= NULL
)
8063 free (arm_sec
->data
);
8065 if (arm_sec
->rela
!= NULL
)
8066 free (arm_sec
->rela
);
8069 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8070 cached section and install SEC instead.
8071 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8072 and return its valued in * WORDP, relocating if necessary.
8073 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8074 relocation's offset in ADDR.
8075 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8076 into the string table of the symbol associated with the reloc. If no
8077 reloc was applied store -1 there.
8078 5) Return TRUE upon success, FALSE otherwise. */
8081 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
8082 struct arm_section
* arm_sec
,
8083 Elf_Internal_Shdr
* sec
,
8084 bfd_vma word_offset
,
8085 unsigned int * wordp
,
8086 struct absaddr
* addr
,
8089 Elf_Internal_Rela
*rp
;
8090 Elf_Internal_Sym
*sym
;
8091 const char * relname
;
8093 bfd_boolean wrapped
;
8095 if (sec
== NULL
|| arm_sec
== NULL
)
8098 addr
->section
= SHN_UNDEF
;
8101 if (sym_name
!= NULL
)
8102 *sym_name
= (bfd_vma
) -1;
8104 /* If necessary, update the section cache. */
8105 if (sec
!= arm_sec
->sec
)
8107 Elf_Internal_Shdr
*relsec
;
8109 arm_free_section (arm_sec
);
8112 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
8113 sec
->sh_size
, _("unwind data"));
8114 arm_sec
->rela
= NULL
;
8115 arm_sec
->nrelas
= 0;
8117 for (relsec
= section_headers
;
8118 relsec
< section_headers
+ elf_header
.e_shnum
;
8121 if (relsec
->sh_info
>= elf_header
.e_shnum
8122 || section_headers
+ relsec
->sh_info
!= sec
8123 /* PR 15745: Check the section type as well. */
8124 || (relsec
->sh_type
!= SHT_REL
8125 && relsec
->sh_type
!= SHT_RELA
))
8128 arm_sec
->rel_type
= relsec
->sh_type
;
8129 if (relsec
->sh_type
== SHT_REL
)
8131 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
8133 & arm_sec
->rela
, & arm_sec
->nrelas
))
8136 else /* relsec->sh_type == SHT_RELA */
8138 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
8140 & arm_sec
->rela
, & arm_sec
->nrelas
))
8146 arm_sec
->next_rela
= arm_sec
->rela
;
8149 /* If there is no unwind data we can do nothing. */
8150 if (arm_sec
->data
== NULL
)
8153 /* If the offset is invalid then fail. */
8154 if (/* PR 21343 *//* PR 18879 */
8156 || word_offset
> (sec
->sh_size
- 4)
8157 || ((bfd_signed_vma
) word_offset
) < 0)
8160 /* Get the word at the required offset. */
8161 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8163 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8164 if (arm_sec
->rela
== NULL
)
8170 /* Look through the relocs to find the one that applies to the provided offset. */
8172 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8174 bfd_vma prelval
, offset
;
8176 if (rp
->r_offset
> word_offset
&& !wrapped
)
8181 if (rp
->r_offset
> word_offset
)
8184 if (rp
->r_offset
& 3)
8186 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8187 (unsigned long) rp
->r_offset
);
8191 if (rp
->r_offset
< word_offset
)
8194 /* PR 17531: file: 027-161405-0.004 */
8195 if (aux
->symtab
== NULL
)
8198 if (arm_sec
->rel_type
== SHT_REL
)
8200 offset
= word
& 0x7fffffff;
8201 if (offset
& 0x40000000)
8202 offset
|= ~ (bfd_vma
) 0x7fffffff;
8204 else if (arm_sec
->rel_type
== SHT_RELA
)
8205 offset
= rp
->r_addend
;
8208 error (_("Unknown section relocation type %d encountered\n"),
8213 /* PR 17531 file: 027-1241568-0.004. */
8214 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8216 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8217 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8221 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8222 offset
+= sym
->st_value
;
8223 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8225 /* Check that we are processing the expected reloc type. */
8226 if (elf_header
.e_machine
== EM_ARM
)
8228 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8229 if (relname
== NULL
)
8231 warn (_("Skipping unknown ARM relocation type: %d\n"),
8232 (int) ELF32_R_TYPE (rp
->r_info
));
8236 if (streq (relname
, "R_ARM_NONE"))
8239 if (! streq (relname
, "R_ARM_PREL31"))
8241 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8245 else if (elf_header
.e_machine
== EM_TI_C6000
)
8247 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8248 if (relname
== NULL
)
8250 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8251 (int) ELF32_R_TYPE (rp
->r_info
));
8255 if (streq (relname
, "R_C6000_NONE"))
8258 if (! streq (relname
, "R_C6000_PREL31"))
8260 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8268 /* This function currently only supports ARM and TI unwinders. */
8269 warn (_("Only TI and ARM unwinders are currently supported\n"));
8273 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8274 addr
->section
= sym
->st_shndx
;
8275 addr
->offset
= offset
;
8278 * sym_name
= sym
->st_name
;
8283 arm_sec
->next_rela
= rp
;
8288 static const char *tic6x_unwind_regnames
[16] =
8290 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8291 "A14", "A13", "A12", "A11", "A10",
8292 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8296 decode_tic6x_unwind_regmask (unsigned int mask
)
8300 for (i
= 12; mask
; mask
>>= 1, i
--)
8304 fputs (tic6x_unwind_regnames
[i
], stdout
);
8306 fputs (", ", stdout
);
8312 if (remaining == 0 && more_words) \
8315 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
8316 data_offset, & word, & addr, NULL)) \
8322 #define GET_OP(OP) \
8327 (OP) = word >> 24; \
8332 printf (_("[Truncated opcode]\n")); \
8335 printf ("0x%02x ", OP)
8338 decode_arm_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8340 unsigned int remaining
,
8341 unsigned int more_words
,
8342 bfd_vma data_offset
,
8343 Elf_Internal_Shdr
* data_sec
,
8344 struct arm_section
* data_arm_sec
)
8346 struct absaddr addr
;
8347 bfd_boolean res
= TRUE
;
8349 /* Decode the unwinding instructions. */
8352 unsigned int op
, op2
;
8361 printf (" 0x%02x ", op
);
8363 if ((op
& 0xc0) == 0x00)
8365 int offset
= ((op
& 0x3f) << 2) + 4;
8367 printf (" vsp = vsp + %d", offset
);
8369 else if ((op
& 0xc0) == 0x40)
8371 int offset
= ((op
& 0x3f) << 2) + 4;
8373 printf (" vsp = vsp - %d", offset
);
8375 else if ((op
& 0xf0) == 0x80)
8378 if (op
== 0x80 && op2
== 0)
8379 printf (_("Refuse to unwind"));
8382 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8383 bfd_boolean first
= TRUE
;
8387 for (i
= 0; i
< 12; i
++)
8388 if (mask
& (1 << i
))
8394 printf ("r%d", 4 + i
);
8399 else if ((op
& 0xf0) == 0x90)
8401 if (op
== 0x9d || op
== 0x9f)
8402 printf (_(" [Reserved]"));
8404 printf (" vsp = r%d", op
& 0x0f);
8406 else if ((op
& 0xf0) == 0xa0)
8408 int end
= 4 + (op
& 0x07);
8409 bfd_boolean first
= TRUE
;
8413 for (i
= 4; i
<= end
; i
++)
8429 else if (op
== 0xb0)
8430 printf (_(" finish"));
8431 else if (op
== 0xb1)
8434 if (op2
== 0 || (op2
& 0xf0) != 0)
8435 printf (_("[Spare]"));
8438 unsigned int mask
= op2
& 0x0f;
8439 bfd_boolean first
= TRUE
;
8443 for (i
= 0; i
< 12; i
++)
8444 if (mask
& (1 << i
))
8455 else if (op
== 0xb2)
8457 unsigned char buf
[9];
8458 unsigned int i
, len
;
8459 unsigned long offset
;
8461 for (i
= 0; i
< sizeof (buf
); i
++)
8464 if ((buf
[i
] & 0x80) == 0)
8467 if (i
== sizeof (buf
))
8469 error (_("corrupt change to vsp"));
8474 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8475 assert (len
== i
+ 1);
8476 offset
= offset
* 4 + 0x204;
8477 printf ("vsp = vsp + %ld", offset
);
8480 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8482 unsigned int first
, last
;
8489 printf ("pop {D%d", first
);
8491 printf ("-D%d", first
+ last
);
8494 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8496 unsigned int count
= op
& 0x07;
8500 printf ("-D%d", 8 + count
);
8503 else if (op
>= 0xc0 && op
<= 0xc5)
8505 unsigned int count
= op
& 0x07;
8507 printf (" pop {wR10");
8509 printf ("-wR%d", 10 + count
);
8512 else if (op
== 0xc6)
8514 unsigned int first
, last
;
8519 printf ("pop {wR%d", first
);
8521 printf ("-wR%d", first
+ last
);
8524 else if (op
== 0xc7)
8527 if (op2
== 0 || (op2
& 0xf0) != 0)
8528 printf (_("[Spare]"));
8531 unsigned int mask
= op2
& 0x0f;
8532 bfd_boolean first
= TRUE
;
8536 for (i
= 0; i
< 4; i
++)
8537 if (mask
& (1 << i
))
8543 printf ("wCGR%d", i
);
8550 printf (_(" [unsupported opcode]"));
8561 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8563 unsigned int remaining
,
8564 unsigned int more_words
,
8565 bfd_vma data_offset
,
8566 Elf_Internal_Shdr
* data_sec
,
8567 struct arm_section
* data_arm_sec
)
8569 struct absaddr addr
;
8571 /* Decode the unwinding instructions. */
8574 unsigned int op
, op2
;
8583 printf (" 0x%02x ", op
);
8585 if ((op
& 0xc0) == 0x00)
8587 int offset
= ((op
& 0x3f) << 3) + 8;
8588 printf (" sp = sp + %d", offset
);
8590 else if ((op
& 0xc0) == 0x80)
8593 if (op
== 0x80 && op2
== 0)
8594 printf (_("Refuse to unwind"));
8597 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8599 printf ("pop compact {");
8603 decode_tic6x_unwind_regmask (mask
);
8607 else if ((op
& 0xf0) == 0xc0)
8615 unsigned int offset
;
8619 /* Scan entire instruction first so that GET_OP output is not
8620 interleaved with disassembly. */
8622 for (i
= 0; nregs
< (op
& 0xf); i
++)
8628 regpos
[nregs
].offset
= i
* 2;
8629 regpos
[nregs
].reg
= reg
;
8636 regpos
[nregs
].offset
= i
* 2 + 1;
8637 regpos
[nregs
].reg
= reg
;
8642 printf (_("pop frame {"));
8644 for (i
= i
* 2; i
> 0; i
--)
8646 if (regpos
[reg
].offset
== i
- 1)
8648 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8655 fputs (name
, stdout
);
8662 else if (op
== 0xd0)
8663 printf (" MOV FP, SP");
8664 else if (op
== 0xd1)
8665 printf (" __c6xabi_pop_rts");
8666 else if (op
== 0xd2)
8668 unsigned char buf
[9];
8669 unsigned int i
, len
;
8670 unsigned long offset
;
8672 for (i
= 0; i
< sizeof (buf
); i
++)
8675 if ((buf
[i
] & 0x80) == 0)
8678 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8679 if (i
== sizeof (buf
))
8681 warn (_("Corrupt stack pointer adjustment detected\n"));
8685 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8686 assert (len
== i
+ 1);
8687 offset
= offset
* 8 + 0x408;
8688 printf (_("sp = sp + %ld"), offset
);
8690 else if ((op
& 0xf0) == 0xe0)
8692 if ((op
& 0x0f) == 7)
8695 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8699 printf (_(" [unsupported opcode]"));
8708 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
8712 offset
= word
& 0x7fffffff;
8713 if (offset
& 0x40000000)
8714 offset
|= ~ (bfd_vma
) 0x7fffffff;
8716 if (elf_header
.e_machine
== EM_TI_C6000
)
8719 return offset
+ where
;
8723 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
8725 unsigned int remaining
,
8726 bfd_vma data_offset
,
8727 Elf_Internal_Shdr
* data_sec
,
8728 struct arm_section
* data_arm_sec
)
8731 unsigned int more_words
= 0;
8732 struct absaddr addr
;
8733 bfd_vma sym_name
= (bfd_vma
) -1;
8734 bfd_boolean res
= TRUE
;
8738 /* Fetch the first word.
8739 Note - when decoding an object file the address extracted
8740 here will always be 0. So we also pass in the sym_name
8741 parameter so that we can find the symbol associated with
8742 the personality routine. */
8743 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
8744 & word
, & addr
, & sym_name
))
8750 if ((word
& 0x80000000) == 0)
8752 /* Expand prel31 for personality routine. */
8754 const char *procname
;
8756 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
8757 printf (_(" Personality routine: "));
8759 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8760 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8762 procname
= aux
->strtab
+ sym_name
;
8763 print_vma (fn
, PREFIX_HEX
);
8766 fputs (" <", stdout
);
8767 fputs (procname
, stdout
);
8768 fputc ('>', stdout
);
8772 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
8773 fputc ('\n', stdout
);
8775 /* The GCC personality routines use the standard compact
8776 encoding, starting with one byte giving the number of
8778 if (procname
!= NULL
8779 && (const_strneq (procname
, "__gcc_personality_v0")
8780 || const_strneq (procname
, "__gxx_personality_v0")
8781 || const_strneq (procname
, "__gcj_personality_v0")
8782 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8789 printf (_(" [Truncated data]\n"));
8792 more_words
= word
>> 24;
8802 /* ARM EHABI Section 6.3:
8804 An exception-handling table entry for the compact model looks like:
8808 1 0 index Data for personalityRoutine[index] */
8810 if (elf_header
.e_machine
== EM_ARM
8811 && (word
& 0x70000000))
8813 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8817 per_index
= (word
>> 24) & 0x7f;
8818 printf (_(" Compact model index: %d\n"), per_index
);
8825 else if (per_index
< 3)
8827 more_words
= (word
>> 16) & 0xff;
8833 switch (elf_header
.e_machine
)
8838 if (! decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
8839 data_offset
, data_sec
, data_arm_sec
))
8844 warn (_("Unknown ARM compact model index encountered\n"));
8845 printf (_(" [reserved]\n"));
8853 if (! decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
8854 data_offset
, data_sec
, data_arm_sec
))
8857 else if (per_index
< 5)
8859 if (((word
>> 17) & 0x7f) == 0x7f)
8860 printf (_(" Restore stack from frame pointer\n"));
8862 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8863 printf (_(" Registers restored: "));
8865 printf (" (compact) ");
8866 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8868 printf (_(" Return register: %s\n"),
8869 tic6x_unwind_regnames
[word
& 0xf]);
8872 printf (_(" [reserved (%d)]\n"), per_index
);
8876 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8877 elf_header
.e_machine
);
8881 /* Decode the descriptors. Not implemented. */
8887 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
8889 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8890 unsigned int i
, exidx_len
;
8891 unsigned long j
, nfuns
;
8892 bfd_boolean res
= TRUE
;
8894 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8895 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8896 exidx_len
= exidx_sec
->sh_size
/ 8;
8898 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8899 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8900 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8901 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8903 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8905 for (i
= 0; i
< exidx_len
; i
++)
8907 unsigned int exidx_fn
, exidx_entry
;
8908 struct absaddr fn_addr
, entry_addr
;
8911 fputc ('\n', stdout
);
8913 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8914 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8915 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8916 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8919 arm_free_section (& exidx_arm_sec
);
8920 arm_free_section (& extab_arm_sec
);
8924 /* ARM EHABI, Section 5:
8925 An index table entry consists of 2 words.
8926 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8927 if (exidx_fn
& 0x80000000)
8929 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8933 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8935 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8936 fputs (": ", stdout
);
8938 if (exidx_entry
== 1)
8940 print_vma (exidx_entry
, PREFIX_HEX
);
8941 fputs (" [cantunwind]\n", stdout
);
8943 else if (exidx_entry
& 0x80000000)
8945 print_vma (exidx_entry
, PREFIX_HEX
);
8946 fputc ('\n', stdout
);
8947 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8951 bfd_vma table
, table_offset
= 0;
8952 Elf_Internal_Shdr
*table_sec
;
8954 fputs ("@", stdout
);
8955 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8956 print_vma (table
, PREFIX_HEX
);
8959 /* Locate the matching .ARM.extab. */
8960 if (entry_addr
.section
!= SHN_UNDEF
8961 && entry_addr
.section
< elf_header
.e_shnum
)
8963 table_sec
= section_headers
+ entry_addr
.section
;
8964 table_offset
= entry_addr
.offset
;
8966 if (table_offset
> table_sec
->sh_size
8967 || ((bfd_signed_vma
) table_offset
) < 0)
8969 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8970 (unsigned long) table_offset
,
8971 printable_section_name (table_sec
));
8978 table_sec
= find_section_by_address (table
);
8979 if (table_sec
!= NULL
)
8980 table_offset
= table
- table_sec
->sh_addr
;
8983 if (table_sec
== NULL
)
8985 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8986 (unsigned long) table
);
8991 if (! decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
9000 arm_free_section (&exidx_arm_sec
);
9001 arm_free_section (&extab_arm_sec
);
9006 /* Used for both ARM and C6X unwinding tables. */
9009 arm_process_unwind (FILE *file
)
9011 struct arm_unw_aux_info aux
;
9012 Elf_Internal_Shdr
*unwsec
= NULL
;
9013 Elf_Internal_Shdr
*strsec
;
9014 Elf_Internal_Shdr
*sec
;
9016 unsigned int sec_type
;
9017 bfd_boolean res
= TRUE
;
9019 switch (elf_header
.e_machine
)
9022 sec_type
= SHT_ARM_EXIDX
;
9026 sec_type
= SHT_C6000_UNWIND
;
9030 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9031 elf_header
.e_machine
);
9035 if (string_table
== NULL
)
9038 memset (& aux
, 0, sizeof (aux
));
9041 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
9043 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
9045 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
9047 strsec
= section_headers
+ sec
->sh_link
;
9049 /* PR binutils/17531 file: 011-12666-0.004. */
9050 if (aux
.strtab
!= NULL
)
9052 error (_("Multiple string tables found in file.\n"));
9056 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
9057 1, strsec
->sh_size
, _("string table"));
9058 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
9060 else if (sec
->sh_type
== sec_type
)
9065 printf (_("\nThere are no unwind sections in this file.\n"));
9067 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
9069 if (sec
->sh_type
== sec_type
)
9071 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
9072 printable_section_name (sec
),
9073 (unsigned long) sec
->sh_offset
,
9074 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
9076 if (! dump_arm_unwind (&aux
, sec
))
9084 free ((char *) aux
.strtab
);
9090 process_unwind (FILE * file
)
9092 struct unwind_handler
9094 unsigned int machtype
;
9095 bfd_boolean (* handler
)(FILE *);
9098 { EM_ARM
, arm_process_unwind
},
9099 { EM_IA_64
, ia64_process_unwind
},
9100 { EM_PARISC
, hppa_process_unwind
},
9101 { EM_TI_C6000
, arm_process_unwind
},
9109 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9110 if (elf_header
.e_machine
== handlers
[i
].machtype
)
9111 return handlers
[i
].handler (file
);
9113 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9114 get_machine_name (elf_header
.e_machine
));
9119 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9121 switch (entry
->d_tag
)
9124 if (entry
->d_un
.d_val
== 0)
9128 static const char * opts
[] =
9130 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9131 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9132 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9133 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9137 bfd_boolean first
= TRUE
;
9139 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9140 if (entry
->d_un
.d_val
& (1 << cnt
))
9142 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9148 case DT_MIPS_IVERSION
:
9149 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9150 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9154 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9155 /* Note: coded this way so that there is a single string for translation. */
9156 printf (_("<corrupt: %s>"), buf
);
9160 case DT_MIPS_TIME_STAMP
:
9164 time_t atime
= entry
->d_un
.d_val
;
9166 tmp
= gmtime (&atime
);
9167 /* PR 17531: file: 6accc532. */
9169 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9171 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9172 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9173 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9174 printf (_("Time Stamp: %s"), timebuf
);
9178 case DT_MIPS_RLD_VERSION
:
9179 case DT_MIPS_LOCAL_GOTNO
:
9180 case DT_MIPS_CONFLICTNO
:
9181 case DT_MIPS_LIBLISTNO
:
9182 case DT_MIPS_SYMTABNO
:
9183 case DT_MIPS_UNREFEXTNO
:
9184 case DT_MIPS_HIPAGENO
:
9185 case DT_MIPS_DELTA_CLASS_NO
:
9186 case DT_MIPS_DELTA_INSTANCE_NO
:
9187 case DT_MIPS_DELTA_RELOC_NO
:
9188 case DT_MIPS_DELTA_SYM_NO
:
9189 case DT_MIPS_DELTA_CLASSSYM_NO
:
9190 case DT_MIPS_COMPACT_SIZE
:
9191 print_vma (entry
->d_un
.d_val
, DEC
);
9195 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9201 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9203 switch (entry
->d_tag
)
9205 case DT_HP_DLD_FLAGS
:
9214 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9215 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9216 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9217 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9218 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9219 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9220 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9221 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9222 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9223 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9224 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9225 { DT_HP_GST
, "HP_GST" },
9226 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9227 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9228 { DT_HP_NODELETE
, "HP_NODELETE" },
9229 { DT_HP_GROUP
, "HP_GROUP" },
9230 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9232 bfd_boolean first
= TRUE
;
9234 bfd_vma val
= entry
->d_un
.d_val
;
9236 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9237 if (val
& flags
[cnt
].bit
)
9241 fputs (flags
[cnt
].str
, stdout
);
9243 val
^= flags
[cnt
].bit
;
9246 if (val
!= 0 || first
)
9250 print_vma (val
, HEX
);
9256 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9264 /* VMS vs Unix time offset and factor. */
9266 #define VMS_EPOCH_OFFSET 35067168000000000LL
9267 #define VMS_GRANULARITY_FACTOR 10000000
9269 /* Display a VMS time in a human readable format. */
9272 print_vms_time (bfd_int64_t vmstime
)
9277 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9278 tm
= gmtime (&unxtime
);
9279 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9280 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9281 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9286 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9288 switch (entry
->d_tag
)
9290 case DT_IA_64_PLT_RESERVE
:
9291 /* First 3 slots reserved. */
9292 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9294 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9297 case DT_IA_64_VMS_LINKTIME
:
9299 print_vms_time (entry
->d_un
.d_val
);
9303 case DT_IA_64_VMS_LNKFLAGS
:
9304 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9305 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9306 printf (" CALL_DEBUG");
9307 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9308 printf (" NOP0BUFS");
9309 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9310 printf (" P0IMAGE");
9311 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9312 printf (" MKTHREADS");
9313 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9314 printf (" UPCALLS");
9315 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9317 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9318 printf (" INITIALIZE");
9319 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9321 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9322 printf (" EXE_INIT");
9323 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9324 printf (" TBK_IN_IMG");
9325 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9326 printf (" DBG_IN_IMG");
9327 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9328 printf (" TBK_IN_DSF");
9329 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9330 printf (" DBG_IN_DSF");
9331 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9332 printf (" SIGNATURES");
9333 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9334 printf (" REL_SEG_OFF");
9338 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9345 get_32bit_dynamic_section (FILE * file
)
9347 Elf32_External_Dyn
* edyn
;
9348 Elf32_External_Dyn
* ext
;
9349 Elf_Internal_Dyn
* entry
;
9351 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9352 dynamic_size
, _("dynamic section"));
9356 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9357 might not have the luxury of section headers. Look for the DT_NULL
9358 terminator to determine the number of entries. */
9359 for (ext
= edyn
, dynamic_nent
= 0;
9360 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9364 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9368 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9370 if (dynamic_section
== NULL
)
9372 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9373 (unsigned long) dynamic_nent
);
9378 for (ext
= edyn
, entry
= dynamic_section
;
9379 entry
< dynamic_section
+ dynamic_nent
;
9382 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9383 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9392 get_64bit_dynamic_section (FILE * file
)
9394 Elf64_External_Dyn
* edyn
;
9395 Elf64_External_Dyn
* ext
;
9396 Elf_Internal_Dyn
* entry
;
9398 /* Read in the data. */
9399 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9400 dynamic_size
, _("dynamic section"));
9404 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9405 might not have the luxury of section headers. Look for the DT_NULL
9406 terminator to determine the number of entries. */
9407 for (ext
= edyn
, dynamic_nent
= 0;
9408 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9409 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9413 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9417 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9419 if (dynamic_section
== NULL
)
9421 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9422 (unsigned long) dynamic_nent
);
9427 /* Convert from external to internal formats. */
9428 for (ext
= edyn
, entry
= dynamic_section
;
9429 entry
< dynamic_section
+ dynamic_nent
;
9432 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9433 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9442 print_dynamic_flags (bfd_vma flags
)
9444 bfd_boolean first
= TRUE
;
9450 flag
= flags
& - flags
;
9460 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9461 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9462 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9463 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9464 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9465 default: fputs (_("unknown"), stdout
); break;
9471 /* Parse and display the contents of the dynamic section. */
9474 process_dynamic_section (FILE * file
)
9476 Elf_Internal_Dyn
* entry
;
9478 if (dynamic_size
== 0)
9481 printf (_("\nThere is no dynamic section in this file.\n"));
9488 if (! get_32bit_dynamic_section (file
))
9493 if (! get_64bit_dynamic_section (file
))
9497 /* Find the appropriate symbol table. */
9498 if (dynamic_symbols
== NULL
)
9500 for (entry
= dynamic_section
;
9501 entry
< dynamic_section
+ dynamic_nent
;
9504 Elf_Internal_Shdr section
;
9506 if (entry
->d_tag
!= DT_SYMTAB
)
9509 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9511 /* Since we do not know how big the symbol table is,
9512 we default to reading in the entire file (!) and
9513 processing that. This is overkill, I know, but it
9515 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9516 if ((bfd_size_type
) section
.sh_offset
> current_file_size
)
9518 /* See PR 21379 for a reproducer. */
9519 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section
.sh_offset
);
9523 if (archive_file_offset
!= 0)
9524 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9527 if (fseek (file
, 0, SEEK_END
))
9528 error (_("Unable to seek to end of file!\n"));
9530 section
.sh_size
= ftell (file
) - section
.sh_offset
;
9534 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9536 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9537 section
.sh_name
= string_table_length
;
9539 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
9540 if (num_dynamic_syms
< 1)
9542 error (_("Unable to determine the number of symbols to load\n"));
9548 /* Similarly find a string table. */
9549 if (dynamic_strings
== NULL
)
9551 for (entry
= dynamic_section
;
9552 entry
< dynamic_section
+ dynamic_nent
;
9555 unsigned long offset
;
9558 if (entry
->d_tag
!= DT_STRTAB
)
9561 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9563 /* Since we do not know how big the string table is,
9564 we default to reading in the entire file (!) and
9565 processing that. This is overkill, I know, but it
9568 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9570 if (archive_file_offset
!= 0)
9571 str_tab_len
= archive_file_size
- offset
;
9574 if (fseek (file
, 0, SEEK_END
))
9575 error (_("Unable to seek to end of file\n"));
9576 str_tab_len
= ftell (file
) - offset
;
9579 if (str_tab_len
< 1)
9582 (_("Unable to determine the length of the dynamic string table\n"));
9586 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
9588 _("dynamic string table"));
9589 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9594 /* And find the syminfo section if available. */
9595 if (dynamic_syminfo
== NULL
)
9597 unsigned long syminsz
= 0;
9599 for (entry
= dynamic_section
;
9600 entry
< dynamic_section
+ dynamic_nent
;
9603 if (entry
->d_tag
== DT_SYMINENT
)
9605 /* Note: these braces are necessary to avoid a syntax
9606 error from the SunOS4 C compiler. */
9607 /* PR binutils/17531: A corrupt file can trigger this test.
9608 So do not use an assert, instead generate an error message. */
9609 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9610 error (_("Bad value (%d) for SYMINENT entry\n"),
9611 (int) entry
->d_un
.d_val
);
9613 else if (entry
->d_tag
== DT_SYMINSZ
)
9614 syminsz
= entry
->d_un
.d_val
;
9615 else if (entry
->d_tag
== DT_SYMINFO
)
9616 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
9620 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9622 Elf_External_Syminfo
* extsyminfo
;
9623 Elf_External_Syminfo
* extsym
;
9624 Elf_Internal_Syminfo
* syminfo
;
9626 /* There is a syminfo section. Read the data. */
9627 extsyminfo
= (Elf_External_Syminfo
*)
9628 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
9629 _("symbol information"));
9633 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9634 if (dynamic_syminfo
== NULL
)
9636 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9637 (unsigned long) syminsz
);
9641 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9642 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9643 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9644 ++syminfo
, ++extsym
)
9646 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9647 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9654 if (do_dynamic
&& dynamic_addr
)
9655 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9656 dynamic_addr
, (unsigned long) dynamic_nent
);
9658 printf (_(" Tag Type Name/Value\n"));
9660 for (entry
= dynamic_section
;
9661 entry
< dynamic_section
+ dynamic_nent
;
9669 print_vma (entry
->d_tag
, FULL_HEX
);
9670 dtype
= get_dynamic_type (entry
->d_tag
);
9671 printf (" (%s)%*s", dtype
,
9672 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
9675 switch (entry
->d_tag
)
9679 print_dynamic_flags (entry
->d_un
.d_val
);
9689 switch (entry
->d_tag
)
9692 printf (_("Auxiliary library"));
9696 printf (_("Filter library"));
9700 printf (_("Configuration file"));
9704 printf (_("Dependency audit library"));
9708 printf (_("Audit library"));
9712 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9713 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9717 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9726 printf (_("Flags:"));
9728 if (entry
->d_un
.d_val
== 0)
9729 printf (_(" None\n"));
9732 unsigned long int val
= entry
->d_un
.d_val
;
9734 if (val
& DTF_1_PARINIT
)
9736 printf (" PARINIT");
9737 val
^= DTF_1_PARINIT
;
9739 if (val
& DTF_1_CONFEXP
)
9741 printf (" CONFEXP");
9742 val
^= DTF_1_CONFEXP
;
9745 printf (" %lx", val
);
9754 printf (_("Flags:"));
9756 if (entry
->d_un
.d_val
== 0)
9757 printf (_(" None\n"));
9760 unsigned long int val
= entry
->d_un
.d_val
;
9762 if (val
& DF_P1_LAZYLOAD
)
9764 printf (" LAZYLOAD");
9765 val
^= DF_P1_LAZYLOAD
;
9767 if (val
& DF_P1_GROUPPERM
)
9769 printf (" GROUPPERM");
9770 val
^= DF_P1_GROUPPERM
;
9773 printf (" %lx", val
);
9782 printf (_("Flags:"));
9783 if (entry
->d_un
.d_val
== 0)
9784 printf (_(" None\n"));
9787 unsigned long int val
= entry
->d_un
.d_val
;
9794 if (val
& DF_1_GLOBAL
)
9799 if (val
& DF_1_GROUP
)
9804 if (val
& DF_1_NODELETE
)
9806 printf (" NODELETE");
9807 val
^= DF_1_NODELETE
;
9809 if (val
& DF_1_LOADFLTR
)
9811 printf (" LOADFLTR");
9812 val
^= DF_1_LOADFLTR
;
9814 if (val
& DF_1_INITFIRST
)
9816 printf (" INITFIRST");
9817 val
^= DF_1_INITFIRST
;
9819 if (val
& DF_1_NOOPEN
)
9824 if (val
& DF_1_ORIGIN
)
9829 if (val
& DF_1_DIRECT
)
9834 if (val
& DF_1_TRANS
)
9839 if (val
& DF_1_INTERPOSE
)
9841 printf (" INTERPOSE");
9842 val
^= DF_1_INTERPOSE
;
9844 if (val
& DF_1_NODEFLIB
)
9846 printf (" NODEFLIB");
9847 val
^= DF_1_NODEFLIB
;
9849 if (val
& DF_1_NODUMP
)
9854 if (val
& DF_1_CONFALT
)
9856 printf (" CONFALT");
9857 val
^= DF_1_CONFALT
;
9859 if (val
& DF_1_ENDFILTEE
)
9861 printf (" ENDFILTEE");
9862 val
^= DF_1_ENDFILTEE
;
9864 if (val
& DF_1_DISPRELDNE
)
9866 printf (" DISPRELDNE");
9867 val
^= DF_1_DISPRELDNE
;
9869 if (val
& DF_1_DISPRELPND
)
9871 printf (" DISPRELPND");
9872 val
^= DF_1_DISPRELPND
;
9874 if (val
& DF_1_NODIRECT
)
9876 printf (" NODIRECT");
9877 val
^= DF_1_NODIRECT
;
9879 if (val
& DF_1_IGNMULDEF
)
9881 printf (" IGNMULDEF");
9882 val
^= DF_1_IGNMULDEF
;
9884 if (val
& DF_1_NOKSYMS
)
9886 printf (" NOKSYMS");
9887 val
^= DF_1_NOKSYMS
;
9889 if (val
& DF_1_NOHDR
)
9894 if (val
& DF_1_EDITED
)
9899 if (val
& DF_1_NORELOC
)
9901 printf (" NORELOC");
9902 val
^= DF_1_NORELOC
;
9904 if (val
& DF_1_SYMINTPOSE
)
9906 printf (" SYMINTPOSE");
9907 val
^= DF_1_SYMINTPOSE
;
9909 if (val
& DF_1_GLOBAUDIT
)
9911 printf (" GLOBAUDIT");
9912 val
^= DF_1_GLOBAUDIT
;
9914 if (val
& DF_1_SINGLETON
)
9916 printf (" SINGLETON");
9917 val
^= DF_1_SINGLETON
;
9919 if (val
& DF_1_STUB
)
9930 printf (" %lx", val
);
9937 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9939 puts (get_dynamic_type (entry
->d_un
.d_val
));
9959 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9965 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9966 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9972 switch (entry
->d_tag
)
9975 printf (_("Shared library: [%s]"), name
);
9977 if (streq (name
, program_interpreter
))
9978 printf (_(" program interpreter"));
9982 printf (_("Library soname: [%s]"), name
);
9986 printf (_("Library rpath: [%s]"), name
);
9990 printf (_("Library runpath: [%s]"), name
);
9994 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9999 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10012 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10013 /* Fall through. */
10017 case DT_INIT_ARRAYSZ
:
10018 case DT_FINI_ARRAYSZ
:
10019 case DT_GNU_CONFLICTSZ
:
10020 case DT_GNU_LIBLISTSZ
:
10023 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10024 printf (_(" (bytes)\n"));
10029 case DT_VERNEEDNUM
:
10034 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10043 case DT_INIT_ARRAY
:
10044 case DT_FINI_ARRAY
:
10047 if (entry
->d_tag
== DT_USED
10048 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10050 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10054 printf (_("Not needed object: [%s]\n"), name
);
10059 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10065 /* The value of this entry is ignored. */
10070 case DT_GNU_PRELINKED
:
10074 time_t atime
= entry
->d_un
.d_val
;
10076 tmp
= gmtime (&atime
);
10077 /* PR 17533 file: 041-1244816-0.004. */
10079 printf (_("<corrupt time val: %lx"),
10080 (unsigned long) atime
);
10082 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10083 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10084 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10090 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10093 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10099 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10100 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10105 switch (elf_header
.e_machine
)
10108 case EM_MIPS_RS3_LE
:
10109 dynamic_section_mips_val (entry
);
10112 dynamic_section_parisc_val (entry
);
10115 dynamic_section_ia64_val (entry
);
10118 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10130 get_ver_flags (unsigned int flags
)
10132 static char buff
[32];
10139 if (flags
& VER_FLG_BASE
)
10140 strcat (buff
, "BASE");
10142 if (flags
& VER_FLG_WEAK
)
10144 if (flags
& VER_FLG_BASE
)
10145 strcat (buff
, " | ");
10147 strcat (buff
, "WEAK");
10150 if (flags
& VER_FLG_INFO
)
10152 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10153 strcat (buff
, " | ");
10155 strcat (buff
, "INFO");
10158 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10160 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10161 strcat (buff
, " | ");
10163 strcat (buff
, _("<unknown>"));
10169 /* Display the contents of the version sections. */
10172 process_version_sections (FILE * file
)
10174 Elf_Internal_Shdr
* section
;
10176 bfd_boolean found
= FALSE
;
10181 for (i
= 0, section
= section_headers
;
10182 i
< elf_header
.e_shnum
;
10185 switch (section
->sh_type
)
10187 case SHT_GNU_verdef
:
10189 Elf_External_Verdef
* edefs
;
10196 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
10197 printable_section_name (section
),
10200 printf (_(" Addr: 0x"));
10201 printf_vma (section
->sh_addr
);
10202 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10203 (unsigned long) section
->sh_offset
, section
->sh_link
,
10204 printable_section_name_from_index (section
->sh_link
));
10206 edefs
= (Elf_External_Verdef
*)
10207 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
10208 _("version definition section"));
10211 endbuf
= (char *) edefs
+ section
->sh_size
;
10213 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10216 Elf_External_Verdef
* edef
;
10217 Elf_Internal_Verdef ent
;
10218 Elf_External_Verdaux
* eaux
;
10219 Elf_Internal_Verdaux aux
;
10220 unsigned long isum
;
10223 vstart
= ((char *) edefs
) + idx
;
10224 if (vstart
+ sizeof (*edef
) > endbuf
)
10227 edef
= (Elf_External_Verdef
*) vstart
;
10229 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10230 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10231 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10232 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10233 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10234 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10235 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10237 printf (_(" %#06lx: Rev: %d Flags: %s"),
10238 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10240 printf (_(" Index: %d Cnt: %d "),
10241 ent
.vd_ndx
, ent
.vd_cnt
);
10243 /* Check for overflow. */
10244 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
10247 vstart
+= ent
.vd_aux
;
10249 if (vstart
+ sizeof (*eaux
) > endbuf
)
10251 eaux
= (Elf_External_Verdaux
*) vstart
;
10253 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10254 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10256 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10257 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10259 printf (_("Name index: %ld\n"), aux
.vda_name
);
10261 isum
= idx
+ ent
.vd_aux
;
10263 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10265 if (aux
.vda_next
< sizeof (*eaux
)
10266 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
10268 warn (_("Invalid vda_next field of %lx\n"),
10273 /* Check for overflow. */
10274 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10277 isum
+= aux
.vda_next
;
10278 vstart
+= aux
.vda_next
;
10280 if (vstart
+ sizeof (*eaux
) > endbuf
)
10282 eaux
= (Elf_External_Verdaux
*) vstart
;
10284 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10285 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10287 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10288 printf (_(" %#06lx: Parent %d: %s\n"),
10289 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10291 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10292 isum
, j
, aux
.vda_name
);
10295 if (j
< ent
.vd_cnt
)
10296 printf (_(" Version def aux past end of section\n"));
10299 file: id:000001,src:000172+005151,op:splice,rep:2. */
10300 if (ent
.vd_next
< sizeof (*edef
)
10301 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
10303 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
10304 cnt
= section
->sh_info
;
10307 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
10310 idx
+= ent
.vd_next
;
10313 if (cnt
< section
->sh_info
)
10314 printf (_(" Version definition past end of section\n"));
10320 case SHT_GNU_verneed
:
10322 Elf_External_Verneed
* eneed
;
10329 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
10330 printable_section_name (section
), section
->sh_info
);
10332 printf (_(" Addr: 0x"));
10333 printf_vma (section
->sh_addr
);
10334 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10335 (unsigned long) section
->sh_offset
, section
->sh_link
,
10336 printable_section_name_from_index (section
->sh_link
));
10338 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
10339 section
->sh_offset
, 1,
10341 _("Version Needs section"));
10344 endbuf
= (char *) eneed
+ section
->sh_size
;
10346 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10348 Elf_External_Verneed
* entry
;
10349 Elf_Internal_Verneed ent
;
10350 unsigned long isum
;
10354 vstart
= ((char *) eneed
) + idx
;
10355 if (vstart
+ sizeof (*entry
) > endbuf
)
10358 entry
= (Elf_External_Verneed
*) vstart
;
10360 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10361 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10362 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10363 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10364 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10366 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
10368 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10369 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10371 printf (_(" File: %lx"), ent
.vn_file
);
10373 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10375 /* Check for overflow. */
10376 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10378 vstart
+= ent
.vn_aux
;
10380 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10382 Elf_External_Vernaux
* eaux
;
10383 Elf_Internal_Vernaux aux
;
10385 if (vstart
+ sizeof (*eaux
) > endbuf
)
10387 eaux
= (Elf_External_Vernaux
*) vstart
;
10389 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10390 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10391 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10392 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10393 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10395 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10396 printf (_(" %#06lx: Name: %s"),
10397 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10399 printf (_(" %#06lx: Name index: %lx"),
10400 isum
, aux
.vna_name
);
10402 printf (_(" Flags: %s Version: %d\n"),
10403 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10405 if (aux
.vna_next
< sizeof (*eaux
)
10406 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
10408 warn (_("Invalid vna_next field of %lx\n"),
10413 /* Check for overflow. */
10414 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
10416 isum
+= aux
.vna_next
;
10417 vstart
+= aux
.vna_next
;
10420 if (j
< ent
.vn_cnt
)
10421 warn (_("Missing Version Needs auxillary information\n"));
10423 if (ent
.vn_next
< sizeof (*entry
)
10424 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
10426 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
10427 cnt
= section
->sh_info
;
10430 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
10432 idx
+= ent
.vn_next
;
10435 if (cnt
< section
->sh_info
)
10436 warn (_("Missing Version Needs information\n"));
10442 case SHT_GNU_versym
:
10444 Elf_Internal_Shdr
* link_section
;
10447 unsigned char * edata
;
10448 unsigned short * data
;
10450 Elf_Internal_Sym
* symbols
;
10451 Elf_Internal_Shdr
* string_sec
;
10452 unsigned long num_syms
;
10455 if (section
->sh_link
>= elf_header
.e_shnum
)
10458 link_section
= section_headers
+ section
->sh_link
;
10459 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10461 if (link_section
->sh_link
>= elf_header
.e_shnum
)
10466 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
10467 if (symbols
== NULL
)
10470 string_sec
= section_headers
+ link_section
->sh_link
;
10472 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
10473 string_sec
->sh_size
,
10474 _("version string table"));
10481 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10482 printable_section_name (section
), (unsigned long) total
);
10484 printf (_(" Addr: "));
10485 printf_vma (section
->sh_addr
);
10486 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10487 (unsigned long) section
->sh_offset
, section
->sh_link
,
10488 printable_section_name (link_section
));
10490 off
= offset_from_vma (file
,
10491 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10492 total
* sizeof (short));
10493 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
10495 _("version symbol data"));
10503 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10505 for (cnt
= total
; cnt
--;)
10506 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10511 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10515 char *invalid
= _("*invalid*");
10517 printf (" %03x:", cnt
);
10519 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10520 switch (data
[cnt
+ j
])
10523 fputs (_(" 0 (*local*) "), stdout
);
10527 fputs (_(" 1 (*global*) "), stdout
);
10531 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10532 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10534 /* If this index value is greater than the size of the symbols
10535 array, break to avoid an out-of-bounds read. */
10536 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10538 warn (_("invalid index into symbol array\n"));
10543 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10545 Elf_Internal_Verneed ivn
;
10546 unsigned long offset
;
10548 offset
= offset_from_vma
10549 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10550 sizeof (Elf_External_Verneed
));
10554 Elf_Internal_Vernaux ivna
;
10555 Elf_External_Verneed evn
;
10556 Elf_External_Vernaux evna
;
10557 unsigned long a_off
;
10559 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10560 _("version need")) == NULL
)
10563 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10564 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10566 a_off
= offset
+ ivn
.vn_aux
;
10570 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
10571 1, _("version need aux (2)")) == NULL
)
10574 ivna
.vna_other
= 0;
10578 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10579 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10582 a_off
+= ivna
.vna_next
;
10584 while (ivna
.vna_other
!= data
[cnt
+ j
]
10585 && ivna
.vna_next
!= 0);
10587 if (ivna
.vna_other
== data
[cnt
+ j
])
10589 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10591 if (ivna
.vna_name
>= string_sec
->sh_size
)
10594 name
= strtab
+ ivna
.vna_name
;
10598 offset
+= ivn
.vn_next
;
10600 while (ivn
.vn_next
);
10603 if (data
[cnt
+ j
] != 0x8001
10604 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10606 Elf_Internal_Verdef ivd
;
10607 Elf_External_Verdef evd
;
10608 unsigned long offset
;
10610 offset
= offset_from_vma
10611 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10616 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
10617 _("version def")) == NULL
)
10620 /* PR 17531: file: 046-1082287-0.004. */
10621 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10626 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10627 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10630 offset
+= ivd
.vd_next
;
10632 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10633 && ivd
.vd_next
!= 0);
10635 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10637 Elf_External_Verdaux evda
;
10638 Elf_Internal_Verdaux ivda
;
10640 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10642 if (get_data (&evda
, file
,
10643 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10645 _("version def aux")) == NULL
)
10648 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10650 if (ivda
.vda_name
>= string_sec
->sh_size
)
10652 else if (name
!= NULL
&& name
!= invalid
)
10653 name
= _("*both*");
10655 name
= strtab
+ ivda
.vda_name
;
10659 nn
+= printf ("(%s%-*s",
10661 12 - (int) strlen (name
),
10665 printf ("%*c", 18 - nn
, ' ');
10683 printf (_("\nNo version information found in this file.\n"));
10688 static const char *
10689 get_symbol_binding (unsigned int binding
)
10691 static char buff
[32];
10695 case STB_LOCAL
: return "LOCAL";
10696 case STB_GLOBAL
: return "GLOBAL";
10697 case STB_WEAK
: return "WEAK";
10699 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10700 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10702 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10704 if (binding
== STB_GNU_UNIQUE
10705 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10706 /* GNU is still using the default value 0. */
10707 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10709 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10712 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10717 static const char *
10718 get_symbol_type (unsigned int type
)
10720 static char buff
[32];
10724 case STT_NOTYPE
: return "NOTYPE";
10725 case STT_OBJECT
: return "OBJECT";
10726 case STT_FUNC
: return "FUNC";
10727 case STT_SECTION
: return "SECTION";
10728 case STT_FILE
: return "FILE";
10729 case STT_COMMON
: return "COMMON";
10730 case STT_TLS
: return "TLS";
10731 case STT_RELC
: return "RELC";
10732 case STT_SRELC
: return "SRELC";
10734 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10736 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10737 return "THUMB_FUNC";
10739 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10742 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10743 return "PARISC_MILLI";
10745 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10747 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10749 if (elf_header
.e_machine
== EM_PARISC
)
10751 if (type
== STT_HP_OPAQUE
)
10752 return "HP_OPAQUE";
10753 if (type
== STT_HP_STUB
)
10757 if (type
== STT_GNU_IFUNC
10758 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10759 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10760 /* GNU is still using the default value 0. */
10761 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10764 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10767 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10772 static const char *
10773 get_symbol_visibility (unsigned int visibility
)
10775 switch (visibility
)
10777 case STV_DEFAULT
: return "DEFAULT";
10778 case STV_INTERNAL
: return "INTERNAL";
10779 case STV_HIDDEN
: return "HIDDEN";
10780 case STV_PROTECTED
: return "PROTECTED";
10782 error (_("Unrecognized visibility value: %u"), visibility
);
10783 return _("<unknown>");
10787 static const char *
10788 get_solaris_symbol_visibility (unsigned int visibility
)
10790 switch (visibility
)
10792 case 4: return "EXPORTED";
10793 case 5: return "SINGLETON";
10794 case 6: return "ELIMINATE";
10795 default: return get_symbol_visibility (visibility
);
10799 static const char *
10800 get_mips_symbol_other (unsigned int other
)
10804 case STO_OPTIONAL
: return "OPTIONAL";
10805 case STO_MIPS_PLT
: return "MIPS PLT";
10806 case STO_MIPS_PIC
: return "MIPS PIC";
10807 case STO_MICROMIPS
: return "MICROMIPS";
10808 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
10809 case STO_MIPS16
: return "MIPS16";
10810 default: return NULL
;
10814 static const char *
10815 get_ia64_symbol_other (unsigned int other
)
10817 if (is_ia64_vms ())
10819 static char res
[32];
10823 /* Function types is for images and .STB files only. */
10824 switch (elf_header
.e_type
)
10828 switch (VMS_ST_FUNC_TYPE (other
))
10830 case VMS_SFT_CODE_ADDR
:
10831 strcat (res
, " CA");
10833 case VMS_SFT_SYMV_IDX
:
10834 strcat (res
, " VEC");
10837 strcat (res
, " FD");
10839 case VMS_SFT_RESERVE
:
10840 strcat (res
, " RSV");
10843 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10844 VMS_ST_FUNC_TYPE (other
));
10845 strcat (res
, " <unknown>");
10852 switch (VMS_ST_LINKAGE (other
))
10854 case VMS_STL_IGNORE
:
10855 strcat (res
, " IGN");
10857 case VMS_STL_RESERVE
:
10858 strcat (res
, " RSV");
10861 strcat (res
, " STD");
10864 strcat (res
, " LNK");
10867 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10868 VMS_ST_LINKAGE (other
));
10869 strcat (res
, " <unknown>");
10881 static const char *
10882 get_ppc64_symbol_other (unsigned int other
)
10884 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10886 static char buf
[32];
10887 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10888 PPC64_LOCAL_ENTRY_OFFSET (other
));
10894 static const char *
10895 get_symbol_other (unsigned int other
)
10897 const char * result
= NULL
;
10898 static char buff
[32];
10903 switch (elf_header
.e_machine
)
10906 result
= get_mips_symbol_other (other
);
10909 result
= get_ia64_symbol_other (other
);
10912 result
= get_ppc64_symbol_other (other
);
10922 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10926 static const char *
10927 get_symbol_index_type (unsigned int type
)
10929 static char buff
[32];
10933 case SHN_UNDEF
: return "UND";
10934 case SHN_ABS
: return "ABS";
10935 case SHN_COMMON
: return "COM";
10937 if (type
== SHN_IA_64_ANSI_COMMON
10938 && elf_header
.e_machine
== EM_IA_64
10939 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10941 else if ((elf_header
.e_machine
== EM_X86_64
10942 || elf_header
.e_machine
== EM_L1OM
10943 || elf_header
.e_machine
== EM_K1OM
)
10944 && type
== SHN_X86_64_LCOMMON
)
10945 return "LARGE_COM";
10946 else if ((type
== SHN_MIPS_SCOMMON
10947 && elf_header
.e_machine
== EM_MIPS
)
10948 || (type
== SHN_TIC6X_SCOMMON
10949 && elf_header
.e_machine
== EM_TI_C6000
))
10951 else if (type
== SHN_MIPS_SUNDEFINED
10952 && elf_header
.e_machine
== EM_MIPS
)
10954 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10955 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10956 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10957 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10958 else if (type
>= SHN_LORESERVE
)
10959 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10960 else if (type
>= elf_header
.e_shnum
)
10961 sprintf (buff
, _("bad section index[%3d]"), type
);
10963 sprintf (buff
, "%3d", type
);
10971 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
10973 unsigned char * e_data
;
10976 /* If the size_t type is smaller than the bfd_size_type, eg because
10977 you are building a 32-bit tool on a 64-bit host, then make sure
10978 that when (number) is cast to (size_t) no information is lost. */
10979 if (sizeof (size_t) < sizeof (bfd_size_type
)
10980 && (bfd_size_type
) ((size_t) number
) != number
)
10982 error (_("Size truncation prevents reading %s elements of size %u\n"),
10983 bfd_vmatoa ("u", number
), ent_size
);
10987 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10988 attempting to allocate memory when the read is bound to fail. */
10989 if (ent_size
* number
> current_file_size
)
10991 error (_("Invalid number of dynamic entries: %s\n"),
10992 bfd_vmatoa ("u", number
));
10996 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10997 if (e_data
== NULL
)
10999 error (_("Out of memory reading %s dynamic entries\n"),
11000 bfd_vmatoa ("u", number
));
11004 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
11006 error (_("Unable to read in %s bytes of dynamic data\n"),
11007 bfd_vmatoa ("u", number
* ent_size
));
11012 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
11013 if (i_data
== NULL
)
11015 error (_("Out of memory allocating space for %s dynamic entries\n"),
11016 bfd_vmatoa ("u", number
));
11022 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11030 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
11032 Elf_Internal_Sym
* psym
;
11035 n
= print_vma (si
, DEC_5
);
11037 fputs (&" "[n
], stdout
);
11038 printf (" %3lu: ", hn
);
11040 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
11042 printf (_("<No info available for dynamic symbol number %lu>\n"),
11043 (unsigned long) si
);
11047 psym
= dynamic_symbols
+ si
;
11048 print_vma (psym
->st_value
, LONG_HEX
);
11050 print_vma (psym
->st_size
, DEC_5
);
11052 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
11053 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
11055 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11056 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11059 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11061 printf (" %-7s", get_symbol_visibility (vis
));
11062 /* Check to see if any other bits in the st_other field are set.
11063 Note - displaying this information disrupts the layout of the
11064 table being generated, but for the moment this case is very
11066 if (psym
->st_other
^ vis
)
11067 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
11070 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
11071 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11072 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11074 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
11078 static const char *
11079 get_symbol_version_string (FILE * file
,
11080 bfd_boolean is_dynsym
,
11081 const char * strtab
,
11082 unsigned long int strtab_size
,
11084 Elf_Internal_Sym
* psym
,
11085 enum versioned_symbol_info
* sym_info
,
11086 unsigned short * vna_other
)
11088 unsigned char data
[2];
11089 unsigned short vers_data
;
11090 unsigned long offset
;
11093 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11096 offset
= offset_from_vma (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11097 sizeof data
+ si
* sizeof (vers_data
));
11099 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
11100 sizeof (data
), 1, _("version data")) == NULL
)
11103 vers_data
= byte_get (data
, 2);
11105 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
<= 1)
11108 /* Usually we'd only see verdef for defined symbols, and verneed for
11109 undefined symbols. However, symbols defined by the linker in
11110 .dynbss for variables copied from a shared library in order to
11111 avoid text relocations are defined yet have verneed. We could
11112 use a heuristic to detect the special case, for example, check
11113 for verneed first on symbols defined in SHT_NOBITS sections, but
11114 it is simpler and more reliable to just look for both verdef and
11115 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11117 if (psym
->st_shndx
!= SHN_UNDEF
11118 && vers_data
!= 0x8001
11119 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11121 Elf_Internal_Verdef ivd
;
11122 Elf_Internal_Verdaux ivda
;
11123 Elf_External_Verdaux evda
;
11126 off
= offset_from_vma (file
,
11127 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11128 sizeof (Elf_External_Verdef
));
11132 Elf_External_Verdef evd
;
11134 if (get_data (&evd
, file
, off
, sizeof (evd
), 1,
11135 _("version def")) == NULL
)
11143 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11144 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11145 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11148 off
+= ivd
.vd_next
;
11150 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11152 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11154 off
-= ivd
.vd_next
;
11157 if (get_data (&evda
, file
, off
, sizeof (evda
), 1,
11158 _("version def aux")) != NULL
)
11160 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11162 if (psym
->st_name
!= ivda
.vda_name
)
11164 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
11165 ? symbol_hidden
: symbol_public
);
11166 return (ivda
.vda_name
< strtab_size
11167 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11173 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11175 Elf_External_Verneed evn
;
11176 Elf_Internal_Verneed ivn
;
11177 Elf_Internal_Vernaux ivna
;
11179 offset
= offset_from_vma (file
,
11180 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11184 unsigned long vna_off
;
11186 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
11187 _("version need")) == NULL
)
11190 ivna
.vna_other
= 0;
11195 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11196 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11198 vna_off
= offset
+ ivn
.vn_aux
;
11202 Elf_External_Vernaux evna
;
11204 if (get_data (&evna
, file
, vna_off
, sizeof (evna
), 1,
11205 _("version need aux (3)")) == NULL
)
11208 ivna
.vna_other
= 0;
11213 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11214 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11215 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11218 vna_off
+= ivna
.vna_next
;
11220 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11222 if (ivna
.vna_other
== vers_data
)
11225 offset
+= ivn
.vn_next
;
11227 while (ivn
.vn_next
!= 0);
11229 if (ivna
.vna_other
== vers_data
)
11231 *sym_info
= symbol_undefined
;
11232 *vna_other
= ivna
.vna_other
;
11233 return (ivna
.vna_name
< strtab_size
11234 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11240 /* Dump the symbol table. */
11242 process_symbol_table (FILE * file
)
11244 Elf_Internal_Shdr
* section
;
11245 bfd_size_type nbuckets
= 0;
11246 bfd_size_type nchains
= 0;
11247 bfd_vma
* buckets
= NULL
;
11248 bfd_vma
* chains
= NULL
;
11249 bfd_vma ngnubuckets
= 0;
11250 bfd_vma
* gnubuckets
= NULL
;
11251 bfd_vma
* gnuchains
= NULL
;
11252 bfd_vma gnusymidx
= 0;
11253 bfd_size_type ngnuchains
= 0;
11255 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11258 if (dynamic_info
[DT_HASH
]
11260 || (do_using_dynamic
11262 && dynamic_strings
!= NULL
)))
11264 unsigned char nb
[8];
11265 unsigned char nc
[8];
11266 unsigned int hash_ent_size
= 4;
11268 if ((elf_header
.e_machine
== EM_ALPHA
11269 || elf_header
.e_machine
== EM_S390
11270 || elf_header
.e_machine
== EM_S390_OLD
)
11271 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11275 (archive_file_offset
11276 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
11277 sizeof nb
+ sizeof nc
)),
11280 error (_("Unable to seek to start of dynamic information\n"));
11284 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
11286 error (_("Failed to read in number of buckets\n"));
11290 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
11292 error (_("Failed to read in number of chains\n"));
11296 nbuckets
= byte_get (nb
, hash_ent_size
);
11297 nchains
= byte_get (nc
, hash_ent_size
);
11299 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
11300 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
11303 if (buckets
== NULL
|| chains
== NULL
)
11305 if (do_using_dynamic
)
11316 if (dynamic_info_DT_GNU_HASH
11318 || (do_using_dynamic
11320 && dynamic_strings
!= NULL
)))
11322 unsigned char nb
[16];
11323 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11324 bfd_vma buckets_vma
;
11327 (archive_file_offset
11328 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
11332 error (_("Unable to seek to start of dynamic information\n"));
11336 if (fread (nb
, 16, 1, file
) != 1)
11338 error (_("Failed to read in number of buckets\n"));
11342 ngnubuckets
= byte_get (nb
, 4);
11343 gnusymidx
= byte_get (nb
+ 4, 4);
11344 bitmaskwords
= byte_get (nb
+ 8, 4);
11345 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11347 buckets_vma
+= bitmaskwords
* 4;
11349 buckets_vma
+= bitmaskwords
* 8;
11352 (archive_file_offset
11353 + offset_from_vma (file
, buckets_vma
, 4)),
11356 error (_("Unable to seek to start of dynamic information\n"));
11360 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
11362 if (gnubuckets
== NULL
)
11365 for (i
= 0; i
< ngnubuckets
; i
++)
11366 if (gnubuckets
[i
] != 0)
11368 if (gnubuckets
[i
] < gnusymidx
)
11371 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11372 maxchain
= gnubuckets
[i
];
11375 if (maxchain
== 0xffffffff)
11378 maxchain
-= gnusymidx
;
11381 (archive_file_offset
11382 + offset_from_vma (file
, buckets_vma
11383 + 4 * (ngnubuckets
+ maxchain
), 4)),
11386 error (_("Unable to seek to start of dynamic information\n"));
11392 if (fread (nb
, 4, 1, file
) != 1)
11394 error (_("Failed to determine last chain length\n"));
11398 if (maxchain
+ 1 == 0)
11403 while ((byte_get (nb
, 4) & 1) == 0);
11406 (archive_file_offset
11407 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11410 error (_("Unable to seek to start of dynamic information\n"));
11414 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
11415 ngnuchains
= maxchain
;
11418 if (gnuchains
== NULL
)
11423 if (do_using_dynamic
)
11428 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11430 && do_using_dynamic
11431 && dynamic_strings
!= NULL
11432 && dynamic_symbols
!= NULL
)
11436 if (dynamic_info
[DT_HASH
])
11441 printf (_("\nSymbol table for image:\n"));
11443 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11445 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11447 visited
= xcmalloc (nchains
, 1);
11448 memset (visited
, 0, nchains
);
11449 for (hn
= 0; hn
< nbuckets
; hn
++)
11451 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11453 print_dynamic_symbol (si
, hn
);
11454 if (si
>= nchains
|| visited
[si
])
11456 error (_("histogram chain is corrupt\n"));
11465 if (dynamic_info_DT_GNU_HASH
)
11467 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11469 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11471 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11473 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11474 if (gnubuckets
[hn
] != 0)
11476 bfd_vma si
= gnubuckets
[hn
];
11477 bfd_vma off
= si
- gnusymidx
;
11481 print_dynamic_symbol (si
, hn
);
11484 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11488 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11489 && section_headers
!= NULL
)
11493 for (i
= 0, section
= section_headers
;
11494 i
< elf_header
.e_shnum
;
11498 char * strtab
= NULL
;
11499 unsigned long int strtab_size
= 0;
11500 Elf_Internal_Sym
* symtab
;
11501 Elf_Internal_Sym
* psym
;
11502 unsigned long num_syms
;
11504 if ((section
->sh_type
!= SHT_SYMTAB
11505 && section
->sh_type
!= SHT_DYNSYM
)
11507 && section
->sh_type
== SHT_SYMTAB
))
11510 if (section
->sh_entsize
== 0)
11512 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11513 printable_section_name (section
));
11517 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
11518 printable_section_name (section
),
11519 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
11522 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11524 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11526 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
11527 if (symtab
== NULL
)
11530 if (section
->sh_link
== elf_header
.e_shstrndx
)
11532 strtab
= string_table
;
11533 strtab_size
= string_table_length
;
11535 else if (section
->sh_link
< elf_header
.e_shnum
)
11537 Elf_Internal_Shdr
* string_sec
;
11539 string_sec
= section_headers
+ section
->sh_link
;
11541 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
11542 1, string_sec
->sh_size
,
11543 _("string table"));
11544 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11547 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11549 const char *version_string
;
11550 enum versioned_symbol_info sym_info
;
11551 unsigned short vna_other
;
11553 printf ("%6d: ", si
);
11554 print_vma (psym
->st_value
, LONG_HEX
);
11556 print_vma (psym
->st_size
, DEC_5
);
11557 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
11558 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
11559 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11560 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11563 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11565 printf (" %-7s", get_symbol_visibility (vis
));
11566 /* Check to see if any other bits in the st_other field are set.
11567 Note - displaying this information disrupts the layout of the
11568 table being generated, but for the moment this case is very rare. */
11569 if (psym
->st_other
^ vis
)
11570 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
11572 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
11573 print_symbol (25, psym
->st_name
< strtab_size
11574 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11577 = get_symbol_version_string (file
,
11578 section
->sh_type
== SHT_DYNSYM
,
11579 strtab
, strtab_size
, si
,
11580 psym
, &sym_info
, &vna_other
);
11581 if (version_string
)
11583 if (sym_info
== symbol_undefined
)
11584 printf ("@%s (%d)", version_string
, vna_other
);
11586 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11592 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11593 && si
>= section
->sh_info
11594 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11595 && elf_header
.e_machine
!= EM_MIPS
11596 /* Solaris binaries have been found to violate this requirement as
11597 well. Not sure if this is a bug or an ABI requirement. */
11598 && elf_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11599 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11600 si
, printable_section_name (section
), section
->sh_info
);
11604 if (strtab
!= string_table
)
11610 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11612 if (do_histogram
&& buckets
!= NULL
)
11614 unsigned long * lengths
;
11615 unsigned long * counts
;
11618 unsigned long maxlength
= 0;
11619 unsigned long nzero_counts
= 0;
11620 unsigned long nsyms
= 0;
11623 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11624 (unsigned long) nbuckets
);
11626 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11627 if (lengths
== NULL
)
11629 error (_("Out of memory allocating space for histogram buckets\n"));
11632 visited
= xcmalloc (nchains
, 1);
11633 memset (visited
, 0, nchains
);
11635 printf (_(" Length Number %% of total Coverage\n"));
11636 for (hn
= 0; hn
< nbuckets
; ++hn
)
11638 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11641 if (maxlength
< ++lengths
[hn
])
11643 if (si
>= nchains
|| visited
[si
])
11645 error (_("histogram chain is corrupt\n"));
11653 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11654 if (counts
== NULL
)
11657 error (_("Out of memory allocating space for histogram counts\n"));
11661 for (hn
= 0; hn
< nbuckets
; ++hn
)
11662 ++counts
[lengths
[hn
]];
11667 printf (" 0 %-10lu (%5.1f%%)\n",
11668 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11669 for (i
= 1; i
<= maxlength
; ++i
)
11671 nzero_counts
+= counts
[i
] * i
;
11672 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11673 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11674 (nzero_counts
* 100.0) / nsyms
);
11682 if (buckets
!= NULL
)
11688 if (do_histogram
&& gnubuckets
!= NULL
)
11690 unsigned long * lengths
;
11691 unsigned long * counts
;
11693 unsigned long maxlength
= 0;
11694 unsigned long nzero_counts
= 0;
11695 unsigned long nsyms
= 0;
11697 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11698 (unsigned long) ngnubuckets
);
11700 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11701 if (lengths
== NULL
)
11703 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11707 printf (_(" Length Number %% of total Coverage\n"));
11709 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11710 if (gnubuckets
[hn
] != 0)
11712 bfd_vma off
, length
= 1;
11714 for (off
= gnubuckets
[hn
] - gnusymidx
;
11715 /* PR 17531 file: 010-77222-0.004. */
11716 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11719 lengths
[hn
] = length
;
11720 if (length
> maxlength
)
11721 maxlength
= length
;
11725 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11726 if (counts
== NULL
)
11729 error (_("Out of memory allocating space for gnu histogram counts\n"));
11733 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11734 ++counts
[lengths
[hn
]];
11736 if (ngnubuckets
> 0)
11739 printf (" 0 %-10lu (%5.1f%%)\n",
11740 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11741 for (j
= 1; j
<= maxlength
; ++j
)
11743 nzero_counts
+= counts
[j
] * j
;
11744 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11745 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11746 (nzero_counts
* 100.0) / nsyms
);
11760 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
11764 if (dynamic_syminfo
== NULL
11766 /* No syminfo, this is ok. */
11769 /* There better should be a dynamic symbol section. */
11770 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11774 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11775 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11777 printf (_(" Num: Name BoundTo Flags\n"));
11778 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11780 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11782 printf ("%4d: ", i
);
11783 if (i
>= num_dynamic_syms
)
11784 printf (_("<corrupt index>"));
11785 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11786 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11788 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11791 switch (dynamic_syminfo
[i
].si_boundto
)
11793 case SYMINFO_BT_SELF
:
11794 fputs ("SELF ", stdout
);
11796 case SYMINFO_BT_PARENT
:
11797 fputs ("PARENT ", stdout
);
11800 if (dynamic_syminfo
[i
].si_boundto
> 0
11801 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11802 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11804 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11808 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11812 if (flags
& SYMINFO_FLG_DIRECT
)
11813 printf (" DIRECT");
11814 if (flags
& SYMINFO_FLG_PASSTHRU
)
11815 printf (" PASSTHRU");
11816 if (flags
& SYMINFO_FLG_COPY
)
11818 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11819 printf (" LAZYLOAD");
11827 #define IN_RANGE(START,END,ADDR,OFF) \
11828 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11830 /* Check to see if the given reloc needs to be handled in a target specific
11831 manner. If so then process the reloc and return TRUE otherwise return
11834 If called with reloc == NULL, then this is a signal that reloc processing
11835 for the current section has finished, and any saved state should be
11839 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
11840 unsigned char * start
,
11841 unsigned char * end
,
11842 Elf_Internal_Sym
* symtab
,
11843 unsigned long num_syms
)
11845 unsigned int reloc_type
= 0;
11846 unsigned long sym_index
= 0;
11850 reloc_type
= get_reloc_type (reloc
->r_info
);
11851 sym_index
= get_reloc_symindex (reloc
->r_info
);
11854 switch (elf_header
.e_machine
)
11857 case EM_MSP430_OLD
:
11859 static Elf_Internal_Sym
* saved_sym
= NULL
;
11867 switch (reloc_type
)
11869 case 10: /* R_MSP430_SYM_DIFF */
11870 if (uses_msp430x_relocs ())
11872 /* Fall through. */
11873 case 21: /* R_MSP430X_SYM_DIFF */
11875 if (sym_index
>= num_syms
)
11876 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11879 saved_sym
= symtab
+ sym_index
;
11882 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11883 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11884 goto handle_sym_diff
;
11886 case 5: /* R_MSP430_16_BYTE */
11887 case 9: /* R_MSP430_8 */
11888 if (uses_msp430x_relocs ())
11890 goto handle_sym_diff
;
11892 case 2: /* R_MSP430_ABS16 */
11893 case 15: /* R_MSP430X_ABS16 */
11894 if (! uses_msp430x_relocs ())
11896 goto handle_sym_diff
;
11899 if (saved_sym
!= NULL
)
11901 int reloc_size
= reloc_type
== 1 ? 4 : 2;
11904 if (sym_index
>= num_syms
)
11905 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
11909 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
11910 - saved_sym
->st_value
);
11912 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
11913 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
11916 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
11917 (long) reloc
->r_offset
);
11926 if (saved_sym
!= NULL
)
11927 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11934 case EM_CYGNUS_MN10300
:
11936 static Elf_Internal_Sym
* saved_sym
= NULL
;
11944 switch (reloc_type
)
11946 case 34: /* R_MN10300_ALIGN */
11948 case 33: /* R_MN10300_SYM_DIFF */
11949 if (sym_index
>= num_syms
)
11950 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
11953 saved_sym
= symtab
+ sym_index
;
11956 case 1: /* R_MN10300_32 */
11957 case 2: /* R_MN10300_16 */
11958 if (saved_sym
!= NULL
)
11960 int reloc_size
= reloc_type
== 1 ? 4 : 2;
11963 if (sym_index
>= num_syms
)
11964 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
11968 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
11969 - saved_sym
->st_value
);
11971 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
11972 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
11974 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
11975 (long) reloc
->r_offset
);
11983 if (saved_sym
!= NULL
)
11984 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11992 static bfd_vma saved_sym1
= 0;
11993 static bfd_vma saved_sym2
= 0;
11994 static bfd_vma value
;
11998 saved_sym1
= saved_sym2
= 0;
12002 switch (reloc_type
)
12004 case 0x80: /* R_RL78_SYM. */
12005 saved_sym1
= saved_sym2
;
12006 if (sym_index
>= num_syms
)
12007 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12011 saved_sym2
= symtab
[sym_index
].st_value
;
12012 saved_sym2
+= reloc
->r_addend
;
12016 case 0x83: /* R_RL78_OPsub. */
12017 value
= saved_sym1
- saved_sym2
;
12018 saved_sym2
= saved_sym1
= 0;
12022 case 0x41: /* R_RL78_ABS32. */
12023 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12024 byte_put (start
+ reloc
->r_offset
, value
, 4);
12026 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12027 (long) reloc
->r_offset
);
12031 case 0x43: /* R_RL78_ABS16. */
12032 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12033 byte_put (start
+ reloc
->r_offset
, value
, 2);
12035 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12036 (long) reloc
->r_offset
);
12050 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12051 DWARF debug sections. This is a target specific test. Note - we do not
12052 go through the whole including-target-headers-multiple-times route, (as
12053 we have already done with <elf/h8.h>) because this would become very
12054 messy and even then this function would have to contain target specific
12055 information (the names of the relocs instead of their numeric values).
12056 FIXME: This is not the correct way to solve this problem. The proper way
12057 is to have target specific reloc sizing and typing functions created by
12058 the reloc-macros.h header, in the same way that it already creates the
12059 reloc naming functions. */
12062 is_32bit_abs_reloc (unsigned int reloc_type
)
12064 /* Please keep this table alpha-sorted for ease of visual lookup. */
12065 switch (elf_header
.e_machine
)
12069 return reloc_type
== 1; /* R_386_32. */
12071 return reloc_type
== 1; /* R_68K_32. */
12073 return reloc_type
== 1; /* R_860_32. */
12075 return reloc_type
== 2; /* R_960_32. */
12077 return (reloc_type
== 258
12078 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12079 case EM_ADAPTEVA_EPIPHANY
:
12080 return reloc_type
== 3;
12082 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12084 return reloc_type
== 1; /* R_ARC_32. */
12085 case EM_ARC_COMPACT
:
12086 case EM_ARC_COMPACT2
:
12087 return reloc_type
== 4; /* R_ARC_32. */
12089 return reloc_type
== 2; /* R_ARM_ABS32 */
12092 return reloc_type
== 1;
12094 return reloc_type
== 0x12; /* R_byte4_data. */
12096 return reloc_type
== 3; /* R_CRIS_32. */
12098 return reloc_type
== 3; /* R_CR16_NUM32. */
12100 return reloc_type
== 15; /* R_CRX_NUM32. */
12101 case EM_CYGNUS_FRV
:
12102 return reloc_type
== 1;
12103 case EM_CYGNUS_D10V
:
12105 return reloc_type
== 6; /* R_D10V_32. */
12106 case EM_CYGNUS_D30V
:
12108 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12110 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12111 case EM_CYGNUS_FR30
:
12113 return reloc_type
== 3; /* R_FR30_32. */
12115 return reloc_type
== 1; /* R_FT32_32. */
12119 return reloc_type
== 1; /* R_H8_DIR32. */
12121 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12122 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12123 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12124 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12127 return reloc_type
== 2; /* R_IP2K_32. */
12129 return reloc_type
== 2; /* R_IQ2000_32. */
12130 case EM_LATTICEMICO32
:
12131 return reloc_type
== 3; /* R_LM32_32. */
12134 return reloc_type
== 3; /* R_M32C_32. */
12136 return reloc_type
== 34; /* R_M32R_32_RELA. */
12139 return reloc_type
== 6; /* R_M68HC11_32. */
12141 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12142 case EM_CYGNUS_MEP
:
12143 return reloc_type
== 4; /* R_MEP_32. */
12145 return reloc_type
== 2; /* R_METAG_ADDR32. */
12146 case EM_MICROBLAZE
:
12147 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12149 return reloc_type
== 2; /* R_MIPS_32. */
12151 return reloc_type
== 4; /* R_MMIX_32. */
12152 case EM_CYGNUS_MN10200
:
12154 return reloc_type
== 1; /* R_MN10200_32. */
12155 case EM_CYGNUS_MN10300
:
12157 return reloc_type
== 1; /* R_MN10300_32. */
12159 return reloc_type
== 1; /* R_MOXIE_32. */
12160 case EM_MSP430_OLD
:
12162 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12164 return reloc_type
== 2; /* R_MT_32. */
12166 return reloc_type
== 20; /* R_NDS32_RELA. */
12167 case EM_ALTERA_NIOS2
:
12168 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12170 return reloc_type
== 1; /* R_NIOS_32. */
12172 return reloc_type
== 1; /* R_OR1K_32. */
12174 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12175 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12178 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12180 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12182 return reloc_type
== 1; /* R_PPC_ADDR32. */
12184 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12186 return reloc_type
== 1; /* R_RISCV_32. */
12188 return reloc_type
== 1; /* R_RL78_DIR32. */
12190 return reloc_type
== 1; /* R_RX_DIR32. */
12192 return reloc_type
== 1; /* R_I370_ADDR31. */
12195 return reloc_type
== 4; /* R_S390_32. */
12197 return reloc_type
== 8; /* R_SCORE_ABS32. */
12199 return reloc_type
== 1; /* R_SH_DIR32. */
12200 case EM_SPARC32PLUS
:
12203 return reloc_type
== 3 /* R_SPARC_32. */
12204 || reloc_type
== 23; /* R_SPARC_UA32. */
12206 return reloc_type
== 6; /* R_SPU_ADDR32 */
12208 return reloc_type
== 1; /* R_C6000_ABS32. */
12210 return reloc_type
== 2; /* R_TILEGX_32. */
12212 return reloc_type
== 1; /* R_TILEPRO_32. */
12213 case EM_CYGNUS_V850
:
12215 return reloc_type
== 6; /* R_V850_ABS32. */
12217 return reloc_type
== 0x33; /* R_V810_WORD. */
12219 return reloc_type
== 1; /* R_VAX_32. */
12221 return reloc_type
== 3; /* R_VISIUM_32. */
12222 case EM_WEBASSEMBLY
:
12223 return reloc_type
== 1; /* R_WASM32_32. */
12227 return reloc_type
== 10; /* R_X86_64_32. */
12230 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12232 return reloc_type
== 4; /* R_XGATE_32. */
12234 return reloc_type
== 1; /* R_XSTROMY16_32. */
12235 case EM_XTENSA_OLD
:
12237 return reloc_type
== 1; /* R_XTENSA_32. */
12240 static unsigned int prev_warn
= 0;
12242 /* Avoid repeating the same warning multiple times. */
12243 if (prev_warn
!= elf_header
.e_machine
)
12244 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12245 elf_header
.e_machine
);
12246 prev_warn
= elf_header
.e_machine
;
12252 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12253 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12256 is_32bit_pcrel_reloc (unsigned int reloc_type
)
12258 switch (elf_header
.e_machine
)
12259 /* Please keep this table alpha-sorted for ease of visual lookup. */
12263 return reloc_type
== 2; /* R_386_PC32. */
12265 return reloc_type
== 4; /* R_68K_PC32. */
12267 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12268 case EM_ADAPTEVA_EPIPHANY
:
12269 return reloc_type
== 6;
12271 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12272 case EM_ARC_COMPACT
:
12273 case EM_ARC_COMPACT2
:
12274 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12276 return reloc_type
== 3; /* R_ARM_REL32 */
12279 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12280 case EM_MICROBLAZE
:
12281 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12283 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12285 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12287 return reloc_type
== 26; /* R_PPC_REL32. */
12289 return reloc_type
== 26; /* R_PPC64_REL32. */
12292 return reloc_type
== 5; /* R_390_PC32. */
12294 return reloc_type
== 2; /* R_SH_REL32. */
12295 case EM_SPARC32PLUS
:
12298 return reloc_type
== 6; /* R_SPARC_DISP32. */
12300 return reloc_type
== 13; /* R_SPU_REL32. */
12302 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12304 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12306 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12310 return reloc_type
== 2; /* R_X86_64_PC32. */
12311 case EM_XTENSA_OLD
:
12313 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12315 /* Do not abort or issue an error message here. Not all targets use
12316 pc-relative 32-bit relocs in their DWARF debug information and we
12317 have already tested for target coverage in is_32bit_abs_reloc. A
12318 more helpful warning message will be generated by apply_relocations
12319 anyway, so just return. */
12324 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12325 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12328 is_64bit_abs_reloc (unsigned int reloc_type
)
12330 switch (elf_header
.e_machine
)
12333 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12335 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12337 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12338 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12340 return reloc_type
== 80; /* R_PARISC_DIR64. */
12342 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12344 return reloc_type
== 2; /* R_RISCV_64. */
12345 case EM_SPARC32PLUS
:
12348 return reloc_type
== 32 /* R_SPARC_64. */
12349 || reloc_type
== 54; /* R_SPARC_UA64. */
12353 return reloc_type
== 1; /* R_X86_64_64. */
12356 return reloc_type
== 22; /* R_S390_64. */
12358 return reloc_type
== 1; /* R_TILEGX_64. */
12360 return reloc_type
== 18; /* R_MIPS_64. */
12366 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12367 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12370 is_64bit_pcrel_reloc (unsigned int reloc_type
)
12372 switch (elf_header
.e_machine
)
12375 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12377 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12379 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12380 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12382 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12384 return reloc_type
== 44; /* R_PPC64_REL64. */
12385 case EM_SPARC32PLUS
:
12388 return reloc_type
== 46; /* R_SPARC_DISP64. */
12392 return reloc_type
== 24; /* R_X86_64_PC64. */
12395 return reloc_type
== 23; /* R_S390_PC64. */
12397 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12403 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12404 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12407 is_24bit_abs_reloc (unsigned int reloc_type
)
12409 switch (elf_header
.e_machine
)
12411 case EM_CYGNUS_MN10200
:
12413 return reloc_type
== 4; /* R_MN10200_24. */
12415 return reloc_type
== 5; /* R_FT32_20. */
12421 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12422 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12425 is_16bit_abs_reloc (unsigned int reloc_type
)
12427 /* Please keep this table alpha-sorted for ease of visual lookup. */
12428 switch (elf_header
.e_machine
)
12431 case EM_ARC_COMPACT
:
12432 case EM_ARC_COMPACT2
:
12433 return reloc_type
== 2; /* R_ARC_16. */
12434 case EM_ADAPTEVA_EPIPHANY
:
12435 return reloc_type
== 5;
12438 return reloc_type
== 4; /* R_AVR_16. */
12439 case EM_CYGNUS_D10V
:
12441 return reloc_type
== 3; /* R_D10V_16. */
12445 return reloc_type
== R_H8_DIR16
;
12448 return reloc_type
== 1; /* R_IP2K_16. */
12451 return reloc_type
== 1; /* R_M32C_16 */
12452 case EM_CYGNUS_MN10200
:
12454 return reloc_type
== 2; /* R_MN10200_16. */
12455 case EM_CYGNUS_MN10300
:
12457 return reloc_type
== 2; /* R_MN10300_16. */
12459 if (uses_msp430x_relocs ())
12460 return reloc_type
== 2; /* R_MSP430_ABS16. */
12461 /* Fall through. */
12462 case EM_MSP430_OLD
:
12463 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12465 return reloc_type
== 19; /* R_NDS32_RELA. */
12466 case EM_ALTERA_NIOS2
:
12467 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12469 return reloc_type
== 9; /* R_NIOS_16. */
12471 return reloc_type
== 2; /* R_OR1K_16. */
12473 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12475 return reloc_type
== 2; /* R_C6000_ABS16. */
12477 return reloc_type
== 2; /* R_VISIUM_16. */
12480 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12482 return reloc_type
== 3; /* R_XGATE_16. */
12488 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12489 relocation entries (possibly formerly used for SHT_GROUP sections). */
12492 is_none_reloc (unsigned int reloc_type
)
12494 switch (elf_header
.e_machine
)
12496 case EM_386
: /* R_386_NONE. */
12497 case EM_68K
: /* R_68K_NONE. */
12498 case EM_ADAPTEVA_EPIPHANY
:
12499 case EM_ALPHA
: /* R_ALPHA_NONE. */
12500 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12501 case EM_ARC
: /* R_ARC_NONE. */
12502 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12503 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12504 case EM_ARM
: /* R_ARM_NONE. */
12505 case EM_C166
: /* R_XC16X_NONE. */
12506 case EM_CRIS
: /* R_CRIS_NONE. */
12507 case EM_FT32
: /* R_FT32_NONE. */
12508 case EM_IA_64
: /* R_IA64_NONE. */
12509 case EM_K1OM
: /* R_X86_64_NONE. */
12510 case EM_L1OM
: /* R_X86_64_NONE. */
12511 case EM_M32R
: /* R_M32R_NONE. */
12512 case EM_MIPS
: /* R_MIPS_NONE. */
12513 case EM_MN10300
: /* R_MN10300_NONE. */
12514 case EM_MOXIE
: /* R_MOXIE_NONE. */
12515 case EM_NIOS32
: /* R_NIOS_NONE. */
12516 case EM_OR1K
: /* R_OR1K_NONE. */
12517 case EM_PARISC
: /* R_PARISC_NONE. */
12518 case EM_PPC64
: /* R_PPC64_NONE. */
12519 case EM_PPC
: /* R_PPC_NONE. */
12520 case EM_RISCV
: /* R_RISCV_NONE. */
12521 case EM_S390
: /* R_390_NONE. */
12523 case EM_SH
: /* R_SH_NONE. */
12524 case EM_SPARC32PLUS
:
12525 case EM_SPARC
: /* R_SPARC_NONE. */
12527 case EM_TILEGX
: /* R_TILEGX_NONE. */
12528 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
12529 case EM_TI_C6000
:/* R_C6000_NONE. */
12530 case EM_X86_64
: /* R_X86_64_NONE. */
12532 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
12533 return reloc_type
== 0;
12536 return reloc_type
== 0 || reloc_type
== 256;
12539 return (reloc_type
== 0 /* R_AVR_NONE. */
12540 || reloc_type
== 30 /* R_AVR_DIFF8. */
12541 || reloc_type
== 31 /* R_AVR_DIFF16. */
12542 || reloc_type
== 32 /* R_AVR_DIFF32. */);
12544 return reloc_type
== 3; /* R_METAG_NONE. */
12546 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12547 || reloc_type
== 204 /* R_NDS32_DIFF8. */
12548 || reloc_type
== 205 /* R_NDS32_DIFF16. */
12549 || reloc_type
== 206 /* R_NDS32_DIFF32. */
12550 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
12552 return (reloc_type
== 0 /* R_PRU_NONE. */
12553 || reloc_type
== 65 /* R_PRU_DIFF8. */
12554 || reloc_type
== 66 /* R_PRU_DIFF16. */
12555 || reloc_type
== 67 /* R_PRU_DIFF32. */);
12556 case EM_XTENSA_OLD
:
12558 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12559 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
12560 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
12561 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
12566 /* Returns TRUE if there is a relocation against
12567 section NAME at OFFSET bytes. */
12570 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
12572 Elf_Internal_Rela
* relocs
;
12573 Elf_Internal_Rela
* rp
;
12575 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
12578 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
12580 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
12581 if (rp
->r_offset
== offset
)
12587 /* Apply relocations to a section.
12588 Returns TRUE upon success, FALSE otherwise.
12589 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12590 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
12591 will be set to the number of relocs loaded.
12593 Note: So far support has been added only for those relocations
12594 which can be found in debug sections. FIXME: Add support for
12595 more relocations ? */
12598 apply_relocations (void * file
,
12599 const Elf_Internal_Shdr
* section
,
12600 unsigned char * start
,
12601 bfd_size_type size
,
12602 void ** relocs_return
,
12603 unsigned long * num_relocs_return
)
12605 Elf_Internal_Shdr
* relsec
;
12606 unsigned char * end
= start
+ size
;
12607 bfd_boolean res
= TRUE
;
12609 if (relocs_return
!= NULL
)
12611 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
12612 * num_relocs_return
= 0;
12615 if (elf_header
.e_type
!= ET_REL
)
12616 /* No relocs to apply. */
12619 /* Find the reloc section associated with the section. */
12620 for (relsec
= section_headers
;
12621 relsec
< section_headers
+ elf_header
.e_shnum
;
12624 bfd_boolean is_rela
;
12625 unsigned long num_relocs
;
12626 Elf_Internal_Rela
* relocs
;
12627 Elf_Internal_Rela
* rp
;
12628 Elf_Internal_Shdr
* symsec
;
12629 Elf_Internal_Sym
* symtab
;
12630 unsigned long num_syms
;
12631 Elf_Internal_Sym
* sym
;
12633 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12634 || relsec
->sh_info
>= elf_header
.e_shnum
12635 || section_headers
+ relsec
->sh_info
!= section
12636 || relsec
->sh_size
== 0
12637 || relsec
->sh_link
>= elf_header
.e_shnum
)
12640 is_rela
= relsec
->sh_type
== SHT_RELA
;
12644 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
12645 relsec
->sh_size
, & relocs
, & num_relocs
))
12650 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
12651 relsec
->sh_size
, & relocs
, & num_relocs
))
12655 /* SH uses RELA but uses in place value instead of the addend field. */
12656 if (elf_header
.e_machine
== EM_SH
)
12659 symsec
= section_headers
+ relsec
->sh_link
;
12660 if (symsec
->sh_type
!= SHT_SYMTAB
12661 && symsec
->sh_type
!= SHT_DYNSYM
)
12663 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
12665 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
12668 unsigned int reloc_type
;
12669 unsigned int reloc_size
;
12670 unsigned char * rloc
;
12671 unsigned long sym_index
;
12673 reloc_type
= get_reloc_type (rp
->r_info
);
12675 if (target_specific_reloc_handling (rp
, start
, end
, symtab
, num_syms
))
12677 else if (is_none_reloc (reloc_type
))
12679 else if (is_32bit_abs_reloc (reloc_type
)
12680 || is_32bit_pcrel_reloc (reloc_type
))
12682 else if (is_64bit_abs_reloc (reloc_type
)
12683 || is_64bit_pcrel_reloc (reloc_type
))
12685 else if (is_24bit_abs_reloc (reloc_type
))
12687 else if (is_16bit_abs_reloc (reloc_type
))
12691 static unsigned int prev_reloc
= 0;
12692 if (reloc_type
!= prev_reloc
)
12693 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12694 reloc_type
, printable_section_name (section
));
12695 prev_reloc
= reloc_type
;
12700 rloc
= start
+ rp
->r_offset
;
12701 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
12703 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12704 (unsigned long) rp
->r_offset
,
12705 printable_section_name (section
));
12710 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
12711 if (sym_index
>= num_syms
)
12713 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12714 sym_index
, printable_section_name (section
));
12718 sym
= symtab
+ sym_index
;
12720 /* If the reloc has a symbol associated with it,
12721 make sure that it is of an appropriate type.
12723 Relocations against symbols without type can happen.
12724 Gcc -feliminate-dwarf2-dups may generate symbols
12725 without type for debug info.
12727 Icc generates relocations against function symbols
12728 instead of local labels.
12730 Relocations against object symbols can happen, eg when
12731 referencing a global array. For an example of this see
12732 the _clz.o binary in libgcc.a. */
12734 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
12735 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
12737 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12738 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
12739 (long int)(rp
- relocs
),
12740 printable_section_name (relsec
));
12747 addend
+= rp
->r_addend
;
12748 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12749 partial_inplace. */
12751 || (elf_header
.e_machine
== EM_XTENSA
12752 && reloc_type
== 1)
12753 || ((elf_header
.e_machine
== EM_PJ
12754 || elf_header
.e_machine
== EM_PJ_OLD
)
12755 && reloc_type
== 1)
12756 || ((elf_header
.e_machine
== EM_D30V
12757 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
12758 && reloc_type
== 12))
12759 addend
+= byte_get (rloc
, reloc_size
);
12761 if (is_32bit_pcrel_reloc (reloc_type
)
12762 || is_64bit_pcrel_reloc (reloc_type
))
12764 /* On HPPA, all pc-relative relocations are biased by 8. */
12765 if (elf_header
.e_machine
== EM_PARISC
)
12767 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
12771 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
12775 /* Let the target specific reloc processing code know that
12776 we have finished with these relocs. */
12777 target_specific_reloc_handling (NULL
, NULL
, NULL
, NULL
, 0);
12781 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
12782 * num_relocs_return
= num_relocs
;
12793 #ifdef SUPPORT_DISASSEMBLY
12795 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
12797 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
12799 /* FIXME: XXX -- to be done --- XXX */
12805 /* Reads in the contents of SECTION from FILE, returning a pointer
12806 to a malloc'ed buffer or NULL if something went wrong. */
12809 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
12811 bfd_size_type num_bytes
;
12813 num_bytes
= section
->sh_size
;
12815 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
12817 printf (_("Section '%s' has no data to dump.\n"),
12818 printable_section_name (section
));
12822 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
12823 _("section contents"));
12826 /* Uncompresses a section that was compressed using zlib, in place. */
12829 uncompress_section_contents (unsigned char **buffer
,
12830 dwarf_size_type uncompressed_size
,
12831 dwarf_size_type
*size
)
12833 dwarf_size_type compressed_size
= *size
;
12834 unsigned char * compressed_buffer
= *buffer
;
12835 unsigned char * uncompressed_buffer
;
12839 /* It is possible the section consists of several compressed
12840 buffers concatenated together, so we uncompress in a loop. */
12841 /* PR 18313: The state field in the z_stream structure is supposed
12842 to be invisible to the user (ie us), but some compilers will
12843 still complain about it being used without initialisation. So
12844 we first zero the entire z_stream structure and then set the fields
12846 memset (& strm
, 0, sizeof strm
);
12847 strm
.avail_in
= compressed_size
;
12848 strm
.next_in
= (Bytef
*) compressed_buffer
;
12849 strm
.avail_out
= uncompressed_size
;
12850 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
12852 rc
= inflateInit (& strm
);
12853 while (strm
.avail_in
> 0)
12857 strm
.next_out
= ((Bytef
*) uncompressed_buffer
12858 + (uncompressed_size
- strm
.avail_out
));
12859 rc
= inflate (&strm
, Z_FINISH
);
12860 if (rc
!= Z_STREAM_END
)
12862 rc
= inflateReset (& strm
);
12864 rc
= inflateEnd (& strm
);
12866 || strm
.avail_out
!= 0)
12869 *buffer
= uncompressed_buffer
;
12870 *size
= uncompressed_size
;
12874 free (uncompressed_buffer
);
12875 /* Indicate decompression failure. */
12881 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
12883 Elf_Internal_Shdr
* relsec
;
12884 bfd_size_type num_bytes
;
12885 unsigned char * data
;
12886 unsigned char * end
;
12887 unsigned char * real_start
;
12888 unsigned char * start
;
12889 bfd_boolean some_strings_shown
;
12891 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
12893 /* PR 21820: Do not fail if the section was empty. */
12894 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
12896 num_bytes
= section
->sh_size
;
12898 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
12900 if (decompress_dumps
)
12902 dwarf_size_type new_size
= num_bytes
;
12903 dwarf_size_type uncompressed_size
= 0;
12905 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12907 Elf_Internal_Chdr chdr
;
12908 unsigned int compression_header_size
12909 = get_compression_header (& chdr
, (unsigned char *) start
,
12912 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12914 warn (_("section '%s' has unsupported compress type: %d\n"),
12915 printable_section_name (section
), chdr
.ch_type
);
12918 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12920 warn (_("compressed section '%s' is corrupted\n"),
12921 printable_section_name (section
));
12924 uncompressed_size
= chdr
.ch_size
;
12925 start
+= compression_header_size
;
12926 new_size
-= compression_header_size
;
12928 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12930 /* Read the zlib header. In this case, it should be "ZLIB"
12931 followed by the uncompressed section size, 8 bytes in
12932 big-endian order. */
12933 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12934 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12935 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12936 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12937 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12938 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12939 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12940 uncompressed_size
+= start
[11];
12945 if (uncompressed_size
)
12947 if (uncompress_section_contents (& start
,
12948 uncompressed_size
, & new_size
))
12949 num_bytes
= new_size
;
12952 error (_("Unable to decompress section %s\n"),
12953 printable_section_name (section
));
12958 start
= real_start
;
12961 /* If the section being dumped has relocations against it the user might
12962 be expecting these relocations to have been applied. Check for this
12963 case and issue a warning message in order to avoid confusion.
12964 FIXME: Maybe we ought to have an option that dumps a section with
12965 relocs applied ? */
12966 for (relsec
= section_headers
;
12967 relsec
< section_headers
+ elf_header
.e_shnum
;
12970 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12971 || relsec
->sh_info
>= elf_header
.e_shnum
12972 || section_headers
+ relsec
->sh_info
!= section
12973 || relsec
->sh_size
== 0
12974 || relsec
->sh_link
>= elf_header
.e_shnum
)
12977 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12982 end
= start
+ num_bytes
;
12983 some_strings_shown
= FALSE
;
12987 while (!ISPRINT (* data
))
12988 if (++ data
>= end
)
12993 size_t maxlen
= end
- data
;
12996 /* PR 11128: Use two separate invocations in order to work
12997 around bugs in the Solaris 8 implementation of printf. */
12998 printf (" [%6tx] ", data
- start
);
13000 printf (" [%6Ix] ", (size_t) (data
- start
));
13004 print_symbol ((int) maxlen
, (const char *) data
);
13006 data
+= strnlen ((const char *) data
, maxlen
);
13010 printf (_("<corrupt>\n"));
13013 some_strings_shown
= TRUE
;
13017 if (! some_strings_shown
)
13018 printf (_(" No strings found in this section."));
13027 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13029 bfd_boolean relocate
)
13031 Elf_Internal_Shdr
* relsec
;
13032 bfd_size_type bytes
;
13033 bfd_size_type section_size
;
13035 unsigned char * data
;
13036 unsigned char * real_start
;
13037 unsigned char * start
;
13039 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
13041 /* PR 21820: Do not fail if the section was empty. */
13042 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13044 section_size
= section
->sh_size
;
13046 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
13048 if (decompress_dumps
)
13050 dwarf_size_type new_size
= section_size
;
13051 dwarf_size_type uncompressed_size
= 0;
13053 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13055 Elf_Internal_Chdr chdr
;
13056 unsigned int compression_header_size
13057 = get_compression_header (& chdr
, start
, section_size
);
13059 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13061 warn (_("section '%s' has unsupported compress type: %d\n"),
13062 printable_section_name (section
), chdr
.ch_type
);
13065 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
13067 warn (_("compressed section '%s' is corrupted\n"),
13068 printable_section_name (section
));
13071 uncompressed_size
= chdr
.ch_size
;
13072 start
+= compression_header_size
;
13073 new_size
-= compression_header_size
;
13075 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13077 /* Read the zlib header. In this case, it should be "ZLIB"
13078 followed by the uncompressed section size, 8 bytes in
13079 big-endian order. */
13080 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13081 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13082 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13083 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13084 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13085 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13086 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13087 uncompressed_size
+= start
[11];
13092 if (uncompressed_size
)
13094 if (uncompress_section_contents (& start
, uncompressed_size
,
13097 section_size
= new_size
;
13101 error (_("Unable to decompress section %s\n"),
13102 printable_section_name (section
));
13103 /* FIXME: Print the section anyway ? */
13108 start
= real_start
;
13113 if (! apply_relocations (file
, section
, start
, section_size
, NULL
, NULL
))
13118 /* If the section being dumped has relocations against it the user might
13119 be expecting these relocations to have been applied. Check for this
13120 case and issue a warning message in order to avoid confusion.
13121 FIXME: Maybe we ought to have an option that dumps a section with
13122 relocs applied ? */
13123 for (relsec
= section_headers
;
13124 relsec
< section_headers
+ elf_header
.e_shnum
;
13127 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13128 || relsec
->sh_info
>= elf_header
.e_shnum
13129 || section_headers
+ relsec
->sh_info
!= section
13130 || relsec
->sh_size
== 0
13131 || relsec
->sh_link
>= elf_header
.e_shnum
)
13134 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13139 addr
= section
->sh_addr
;
13140 bytes
= section_size
;
13149 lbytes
= (bytes
> 16 ? 16 : bytes
);
13151 printf (" 0x%8.8lx ", (unsigned long) addr
);
13153 for (j
= 0; j
< 16; j
++)
13156 printf ("%2.2x", data
[j
]);
13164 for (j
= 0; j
< lbytes
; j
++)
13167 if (k
>= ' ' && k
< 0x7f)
13187 load_specific_debug_section (enum dwarf_section_display_enum debug
,
13188 const Elf_Internal_Shdr
* sec
, void * file
)
13190 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13193 /* If it is already loaded, do nothing. */
13194 if (section
->start
!= NULL
)
13197 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
13198 section
->address
= sec
->sh_addr
;
13199 section
->user_data
= NULL
;
13200 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
13202 sec
->sh_size
, buf
);
13203 if (section
->start
== NULL
)
13207 unsigned char *start
= section
->start
;
13208 dwarf_size_type size
= sec
->sh_size
;
13209 dwarf_size_type uncompressed_size
= 0;
13211 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
13213 Elf_Internal_Chdr chdr
;
13214 unsigned int compression_header_size
;
13216 if (size
< (is_32bit_elf
13217 ? sizeof (Elf32_External_Chdr
)
13218 : sizeof (Elf64_External_Chdr
)))
13220 warn (_("compressed section %s is too small to contain a compression header"),
13225 compression_header_size
= get_compression_header (&chdr
, start
, size
);
13227 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13229 warn (_("section '%s' has unsupported compress type: %d\n"),
13230 section
->name
, chdr
.ch_type
);
13233 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
13235 warn (_("compressed section '%s' is corrupted\n"),
13239 uncompressed_size
= chdr
.ch_size
;
13240 start
+= compression_header_size
;
13241 size
-= compression_header_size
;
13243 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
13245 /* Read the zlib header. In this case, it should be "ZLIB"
13246 followed by the uncompressed section size, 8 bytes in
13247 big-endian order. */
13248 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13249 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13250 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13251 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13252 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13253 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13254 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13255 uncompressed_size
+= start
[11];
13260 if (uncompressed_size
)
13262 if (uncompress_section_contents (&start
, uncompressed_size
,
13265 /* Free the compressed buffer, update the section buffer
13266 and the section size if uncompress is successful. */
13267 free (section
->start
);
13268 section
->start
= start
;
13272 error (_("Unable to decompress section %s\n"),
13273 printable_section_name (sec
));
13278 section
->size
= size
;
13281 if (section
->start
== NULL
)
13284 if (debug_displays
[debug
].relocate
)
13286 if (! apply_relocations ((FILE *) file
, sec
, section
->start
, section
->size
,
13287 & section
->reloc_info
, & section
->num_relocs
))
13292 section
->reloc_info
= NULL
;
13293 section
->num_relocs
= 0;
13299 /* If this is not NULL, load_debug_section will only look for sections
13300 within the list of sections given here. */
13301 static unsigned int * section_subset
= NULL
;
13304 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
13306 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13307 Elf_Internal_Shdr
* sec
;
13309 /* Locate the debug section. */
13310 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
13312 section
->name
= section
->uncompressed_name
;
13315 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
13317 section
->name
= section
->compressed_name
;
13322 /* If we're loading from a subset of sections, and we've loaded
13323 a section matching this name before, it's likely that it's a
13325 if (section_subset
!= NULL
)
13326 free_debug_section (debug
);
13328 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
13332 free_debug_section (enum dwarf_section_display_enum debug
)
13334 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13336 if (section
->start
== NULL
)
13339 free ((char *) section
->start
);
13340 section
->start
= NULL
;
13341 section
->address
= 0;
13346 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
13348 char * name
= SECTION_NAME (section
);
13349 const char * print_name
= printable_section_name (section
);
13350 bfd_size_type length
;
13351 bfd_boolean result
= TRUE
;
13354 length
= section
->sh_size
;
13357 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
13360 if (section
->sh_type
== SHT_NOBITS
)
13362 /* There is no point in dumping the contents of a debugging section
13363 which has the NOBITS type - the bits in the file will be random.
13364 This can happen when a file containing a .eh_frame section is
13365 stripped with the --only-keep-debug command line option. */
13366 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13371 if (const_strneq (name
, ".gnu.linkonce.wi."))
13372 name
= ".debug_info";
13374 /* See if we know how to display the contents of this section. */
13375 for (i
= 0; i
< max
; i
++)
13376 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
13377 || (i
== line
&& const_strneq (name
, ".debug_line."))
13378 || streq (debug_displays
[i
].section
.compressed_name
, name
))
13380 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
13381 int secondary
= (section
!= find_section (name
));
13384 free_debug_section ((enum dwarf_section_display_enum
) i
);
13386 if (i
== line
&& const_strneq (name
, ".debug_line."))
13388 else if (streq (sec
->uncompressed_name
, name
))
13389 sec
->name
= sec
->uncompressed_name
;
13391 sec
->name
= sec
->compressed_name
;
13392 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
13395 /* If this debug section is part of a CU/TU set in a .dwp file,
13396 restrict load_debug_section to the sections in that set. */
13397 section_subset
= find_cu_tu_set (file
, shndx
);
13399 result
&= debug_displays
[i
].display (sec
, file
);
13401 section_subset
= NULL
;
13403 if (secondary
|| (i
!= info
&& i
!= abbrev
))
13404 free_debug_section ((enum dwarf_section_display_enum
) i
);
13412 printf (_("Unrecognized debug section: %s\n"), print_name
);
13419 /* Set DUMP_SECTS for all sections where dumps were requested
13420 based on section name. */
13423 initialise_dumps_byname (void)
13425 struct dump_list_entry
* cur
;
13427 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
13430 bfd_boolean any
= FALSE
;
13432 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
13433 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
13435 request_dump_bynumber (i
, cur
->type
);
13440 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13446 process_section_contents (FILE * file
)
13448 Elf_Internal_Shdr
* section
;
13450 bfd_boolean res
= TRUE
;
13455 initialise_dumps_byname ();
13457 for (i
= 0, section
= section_headers
;
13458 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
13461 #ifdef SUPPORT_DISASSEMBLY
13462 if (dump_sects
[i
] & DISASS_DUMP
)
13463 disassemble_section (section
, file
);
13465 if (dump_sects
[i
] & HEX_DUMP
)
13467 if (! dump_section_as_bytes (section
, file
, FALSE
))
13471 if (dump_sects
[i
] & RELOC_DUMP
)
13473 if (! dump_section_as_bytes (section
, file
, TRUE
))
13477 if (dump_sects
[i
] & STRING_DUMP
)
13479 if (! dump_section_as_strings (section
, file
))
13483 if (dump_sects
[i
] & DEBUG_DUMP
)
13485 if (! display_debug_section (i
, section
, file
))
13490 /* Check to see if the user requested a
13491 dump of a section that does not exist. */
13492 while (i
< num_dump_sects
)
13496 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
13506 process_mips_fpe_exception (int mask
)
13510 bfd_boolean first
= TRUE
;
13512 if (mask
& OEX_FPU_INEX
)
13513 fputs ("INEX", stdout
), first
= FALSE
;
13514 if (mask
& OEX_FPU_UFLO
)
13515 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
13516 if (mask
& OEX_FPU_OFLO
)
13517 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
13518 if (mask
& OEX_FPU_DIV0
)
13519 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
13520 if (mask
& OEX_FPU_INVAL
)
13521 printf ("%sINVAL", first
? "" : "|");
13524 fputs ("0", stdout
);
13527 /* Display's the value of TAG at location P. If TAG is
13528 greater than 0 it is assumed to be an unknown tag, and
13529 a message is printed to this effect. Otherwise it is
13530 assumed that a message has already been printed.
13532 If the bottom bit of TAG is set it assumed to have a
13533 string value, otherwise it is assumed to have an integer
13536 Returns an updated P pointing to the first unread byte
13537 beyond the end of TAG's value.
13539 Reads at or beyond END will not be made. */
13541 static unsigned char *
13542 display_tag_value (signed int tag
,
13544 const unsigned char * const end
)
13549 printf (" Tag_unknown_%d: ", tag
);
13553 warn (_("<corrupt tag>\n"));
13557 /* PR 17531 file: 027-19978-0.004. */
13558 size_t maxlen
= (end
- p
) - 1;
13563 print_symbol ((int) maxlen
, (const char *) p
);
13564 p
+= strnlen ((char *) p
, maxlen
) + 1;
13568 printf (_("<corrupt string tag>"));
13569 p
= (unsigned char *) end
;
13577 val
= read_uleb128 (p
, &len
, end
);
13579 printf ("%ld (0x%lx)\n", val
, val
);
13586 /* ARC ABI attributes section. */
13588 static unsigned char *
13589 display_arc_attribute (unsigned char * p
,
13590 const unsigned char * const end
)
13596 tag
= read_uleb128 (p
, &len
, end
);
13601 case Tag_ARC_PCS_config
:
13602 val
= read_uleb128 (p
, &len
, end
);
13604 printf (" Tag_ARC_PCS_config: ");
13608 printf (_("Absent/Non standard\n"));
13611 printf (_("Bare metal/mwdt\n"));
13614 printf (_("Bare metal/newlib\n"));
13617 printf (_("Linux/uclibc\n"));
13620 printf (_("Linux/glibc\n"));
13623 printf (_("Unknown\n"));
13628 case Tag_ARC_CPU_base
:
13629 val
= read_uleb128 (p
, &len
, end
);
13631 printf (" Tag_ARC_CPU_base: ");
13636 printf (_("Absent\n"));
13638 case TAG_CPU_ARC6xx
:
13639 printf ("ARC6xx\n");
13641 case TAG_CPU_ARC7xx
:
13642 printf ("ARC7xx\n");
13644 case TAG_CPU_ARCEM
:
13645 printf ("ARCEM\n");
13647 case TAG_CPU_ARCHS
:
13648 printf ("ARCHS\n");
13653 case Tag_ARC_CPU_variation
:
13654 val
= read_uleb128 (p
, &len
, end
);
13656 printf (" Tag_ARC_CPU_variation: ");
13660 if (val
> 0 && val
< 16)
13661 printf ("Core%d\n", val
);
13663 printf ("Unknown\n");
13667 printf (_("Absent\n"));
13672 case Tag_ARC_CPU_name
:
13673 printf (" Tag_ARC_CPU_name: ");
13674 p
= display_tag_value (-1, p
, end
);
13677 case Tag_ARC_ABI_rf16
:
13678 val
= read_uleb128 (p
, &len
, end
);
13680 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
13683 case Tag_ARC_ABI_osver
:
13684 val
= read_uleb128 (p
, &len
, end
);
13686 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
13689 case Tag_ARC_ABI_pic
:
13690 case Tag_ARC_ABI_sda
:
13691 val
= read_uleb128 (p
, &len
, end
);
13693 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
13694 : " Tag_ARC_ABI_pic: ");
13698 printf (_("Absent\n"));
13707 printf (_("Unknown\n"));
13712 case Tag_ARC_ABI_tls
:
13713 val
= read_uleb128 (p
, &len
, end
);
13715 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
13718 case Tag_ARC_ABI_enumsize
:
13719 val
= read_uleb128 (p
, &len
, end
);
13721 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
13725 case Tag_ARC_ABI_exceptions
:
13726 val
= read_uleb128 (p
, &len
, end
);
13728 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
13732 case Tag_ARC_ABI_double_size
:
13733 val
= read_uleb128 (p
, &len
, end
);
13735 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
13738 case Tag_ARC_ISA_config
:
13739 printf (" Tag_ARC_ISA_config: ");
13740 p
= display_tag_value (-1, p
, end
);
13743 case Tag_ARC_ISA_apex
:
13744 printf (" Tag_ARC_ISA_apex: ");
13745 p
= display_tag_value (-1, p
, end
);
13748 case Tag_ARC_ISA_mpy_option
:
13749 val
= read_uleb128 (p
, &len
, end
);
13751 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
13755 return display_tag_value (tag
& 1, p
, end
);
13761 /* ARM EABI attributes section. */
13766 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
13768 const char ** table
;
13769 } arm_attr_public_tag
;
13771 static const char * arm_attr_tag_CPU_arch
[] =
13772 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
13773 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
13775 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
13776 static const char * arm_attr_tag_THUMB_ISA_use
[] =
13777 {"No", "Thumb-1", "Thumb-2", "Yes"};
13778 static const char * arm_attr_tag_FP_arch
[] =
13779 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
13780 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
13781 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
13782 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
13783 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13784 "NEON for ARMv8.1"};
13785 static const char * arm_attr_tag_PCS_config
[] =
13786 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13787 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
13788 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
13789 {"V6", "SB", "TLS", "Unused"};
13790 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
13791 {"Absolute", "PC-relative", "SB-relative", "None"};
13792 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
13793 {"Absolute", "PC-relative", "None"};
13794 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
13795 {"None", "direct", "GOT-indirect"};
13796 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
13797 {"None", "??? 1", "2", "??? 3", "4"};
13798 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
13799 static const char * arm_attr_tag_ABI_FP_denormal
[] =
13800 {"Unused", "Needed", "Sign only"};
13801 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
13802 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
13803 static const char * arm_attr_tag_ABI_FP_number_model
[] =
13804 {"Unused", "Finite", "RTABI", "IEEE 754"};
13805 static const char * arm_attr_tag_ABI_enum_size
[] =
13806 {"Unused", "small", "int", "forced to int"};
13807 static const char * arm_attr_tag_ABI_HardFP_use
[] =
13808 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
13809 static const char * arm_attr_tag_ABI_VFP_args
[] =
13810 {"AAPCS", "VFP registers", "custom", "compatible"};
13811 static const char * arm_attr_tag_ABI_WMMX_args
[] =
13812 {"AAPCS", "WMMX registers", "custom"};
13813 static const char * arm_attr_tag_ABI_optimization_goals
[] =
13814 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13815 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
13816 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
13817 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13818 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
13819 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
13820 static const char * arm_attr_tag_FP_HP_extension
[] =
13821 {"Not Allowed", "Allowed"};
13822 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
13823 {"None", "IEEE 754", "Alternative Format"};
13824 static const char * arm_attr_tag_DSP_extension
[] =
13825 {"Follow architecture", "Allowed"};
13826 static const char * arm_attr_tag_MPextension_use
[] =
13827 {"Not Allowed", "Allowed"};
13828 static const char * arm_attr_tag_DIV_use
[] =
13829 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
13830 "Allowed in v7-A with integer division extension"};
13831 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
13832 static const char * arm_attr_tag_Virtualization_use
[] =
13833 {"Not Allowed", "TrustZone", "Virtualization Extensions",
13834 "TrustZone and Virtualization Extensions"};
13835 static const char * arm_attr_tag_MPextension_use_legacy
[] =
13836 {"Not Allowed", "Allowed"};
13838 #define LOOKUP(id, name) \
13839 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
13840 static arm_attr_public_tag arm_attr_public_tags
[] =
13842 {4, "CPU_raw_name", 1, NULL
},
13843 {5, "CPU_name", 1, NULL
},
13844 LOOKUP(6, CPU_arch
),
13845 {7, "CPU_arch_profile", 0, NULL
},
13846 LOOKUP(8, ARM_ISA_use
),
13847 LOOKUP(9, THUMB_ISA_use
),
13848 LOOKUP(10, FP_arch
),
13849 LOOKUP(11, WMMX_arch
),
13850 LOOKUP(12, Advanced_SIMD_arch
),
13851 LOOKUP(13, PCS_config
),
13852 LOOKUP(14, ABI_PCS_R9_use
),
13853 LOOKUP(15, ABI_PCS_RW_data
),
13854 LOOKUP(16, ABI_PCS_RO_data
),
13855 LOOKUP(17, ABI_PCS_GOT_use
),
13856 LOOKUP(18, ABI_PCS_wchar_t
),
13857 LOOKUP(19, ABI_FP_rounding
),
13858 LOOKUP(20, ABI_FP_denormal
),
13859 LOOKUP(21, ABI_FP_exceptions
),
13860 LOOKUP(22, ABI_FP_user_exceptions
),
13861 LOOKUP(23, ABI_FP_number_model
),
13862 {24, "ABI_align_needed", 0, NULL
},
13863 {25, "ABI_align_preserved", 0, NULL
},
13864 LOOKUP(26, ABI_enum_size
),
13865 LOOKUP(27, ABI_HardFP_use
),
13866 LOOKUP(28, ABI_VFP_args
),
13867 LOOKUP(29, ABI_WMMX_args
),
13868 LOOKUP(30, ABI_optimization_goals
),
13869 LOOKUP(31, ABI_FP_optimization_goals
),
13870 {32, "compatibility", 0, NULL
},
13871 LOOKUP(34, CPU_unaligned_access
),
13872 LOOKUP(36, FP_HP_extension
),
13873 LOOKUP(38, ABI_FP_16bit_format
),
13874 LOOKUP(42, MPextension_use
),
13875 LOOKUP(44, DIV_use
),
13876 LOOKUP(46, DSP_extension
),
13877 {64, "nodefaults", 0, NULL
},
13878 {65, "also_compatible_with", 0, NULL
},
13879 LOOKUP(66, T2EE_use
),
13880 {67, "conformance", 1, NULL
},
13881 LOOKUP(68, Virtualization_use
),
13882 LOOKUP(70, MPextension_use_legacy
)
13886 static unsigned char *
13887 display_arm_attribute (unsigned char * p
,
13888 const unsigned char * const end
)
13893 arm_attr_public_tag
* attr
;
13897 tag
= read_uleb128 (p
, &len
, end
);
13900 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
13902 if (arm_attr_public_tags
[i
].tag
== tag
)
13904 attr
= &arm_attr_public_tags
[i
];
13911 printf (" Tag_%s: ", attr
->name
);
13912 switch (attr
->type
)
13917 case 7: /* Tag_CPU_arch_profile. */
13918 val
= read_uleb128 (p
, &len
, end
);
13922 case 0: printf (_("None\n")); break;
13923 case 'A': printf (_("Application\n")); break;
13924 case 'R': printf (_("Realtime\n")); break;
13925 case 'M': printf (_("Microcontroller\n")); break;
13926 case 'S': printf (_("Application or Realtime\n")); break;
13927 default: printf ("??? (%d)\n", val
); break;
13931 case 24: /* Tag_align_needed. */
13932 val
= read_uleb128 (p
, &len
, end
);
13936 case 0: printf (_("None\n")); break;
13937 case 1: printf (_("8-byte\n")); break;
13938 case 2: printf (_("4-byte\n")); break;
13939 case 3: printf ("??? 3\n"); break;
13942 printf (_("8-byte and up to %d-byte extended\n"),
13945 printf ("??? (%d)\n", val
);
13950 case 25: /* Tag_align_preserved. */
13951 val
= read_uleb128 (p
, &len
, end
);
13955 case 0: printf (_("None\n")); break;
13956 case 1: printf (_("8-byte, except leaf SP\n")); break;
13957 case 2: printf (_("8-byte\n")); break;
13958 case 3: printf ("??? 3\n"); break;
13961 printf (_("8-byte and up to %d-byte extended\n"),
13964 printf ("??? (%d)\n", val
);
13969 case 32: /* Tag_compatibility. */
13971 val
= read_uleb128 (p
, &len
, end
);
13973 printf (_("flag = %d, vendor = "), val
);
13976 size_t maxlen
= (end
- p
) - 1;
13978 print_symbol ((int) maxlen
, (const char *) p
);
13979 p
+= strnlen ((char *) p
, maxlen
) + 1;
13983 printf (_("<corrupt>"));
13984 p
= (unsigned char *) end
;
13990 case 64: /* Tag_nodefaults. */
13991 /* PR 17531: file: 001-505008-0.01. */
13994 printf (_("True\n"));
13997 case 65: /* Tag_also_compatible_with. */
13998 val
= read_uleb128 (p
, &len
, end
);
14000 if (val
== 6 /* Tag_CPU_arch. */)
14002 val
= read_uleb128 (p
, &len
, end
);
14004 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
14005 printf ("??? (%d)\n", val
);
14007 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
14011 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
14016 printf (_("<unknown: %d>\n"), tag
);
14022 return display_tag_value (-1, p
, end
);
14024 return display_tag_value (0, p
, end
);
14027 assert (attr
->type
& 0x80);
14028 val
= read_uleb128 (p
, &len
, end
);
14030 type
= attr
->type
& 0x7f;
14032 printf ("??? (%d)\n", val
);
14034 printf ("%s\n", attr
->table
[val
]);
14039 return display_tag_value (tag
, p
, end
);
14042 static unsigned char *
14043 display_gnu_attribute (unsigned char * p
,
14044 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
14045 const unsigned char * const end
)
14051 tag
= read_uleb128 (p
, &len
, end
);
14054 /* Tag_compatibility is the only generic GNU attribute defined at
14058 val
= read_uleb128 (p
, &len
, end
);
14061 printf (_("flag = %d, vendor = "), val
);
14064 printf (_("<corrupt>\n"));
14065 warn (_("corrupt vendor attribute\n"));
14071 size_t maxlen
= (end
- p
) - 1;
14073 print_symbol ((int) maxlen
, (const char *) p
);
14074 p
+= strnlen ((char *) p
, maxlen
) + 1;
14078 printf (_("<corrupt>"));
14079 p
= (unsigned char *) end
;
14086 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
14087 return display_proc_gnu_attribute (p
, tag
, end
);
14089 return display_tag_value (tag
, p
, end
);
14092 static unsigned char *
14093 display_power_gnu_attribute (unsigned char * p
,
14095 const unsigned char * const end
)
14100 if (tag
== Tag_GNU_Power_ABI_FP
)
14102 val
= read_uleb128 (p
, &len
, end
);
14104 printf (" Tag_GNU_Power_ABI_FP: ");
14107 printf (_("<corrupt>\n"));
14112 printf ("(%#x), ", val
);
14117 printf (_("unspecified hard/soft float, "));
14120 printf (_("hard float, "));
14123 printf (_("soft float, "));
14126 printf (_("single-precision hard float, "));
14133 printf (_("unspecified long double\n"));
14136 printf (_("128-bit IBM long double\n"));
14139 printf (_("64-bit long double\n"));
14142 printf (_("128-bit IEEE long double\n"));
14148 if (tag
== Tag_GNU_Power_ABI_Vector
)
14150 val
= read_uleb128 (p
, &len
, end
);
14152 printf (" Tag_GNU_Power_ABI_Vector: ");
14155 printf (_("<corrupt>\n"));
14160 printf ("(%#x), ", val
);
14165 printf (_("unspecified\n"));
14168 printf (_("generic\n"));
14171 printf ("AltiVec\n");
14180 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
14182 val
= read_uleb128 (p
, &len
, end
);
14184 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
14187 printf (_("<corrupt>\n"));
14192 printf ("(%#x), ", val
);
14197 printf (_("unspecified\n"));
14200 printf ("r3/r4\n");
14203 printf (_("memory\n"));
14212 return display_tag_value (tag
& 1, p
, end
);
14215 static unsigned char *
14216 display_s390_gnu_attribute (unsigned char * p
,
14218 const unsigned char * const end
)
14223 if (tag
== Tag_GNU_S390_ABI_Vector
)
14225 val
= read_uleb128 (p
, &len
, end
);
14227 printf (" Tag_GNU_S390_ABI_Vector: ");
14232 printf (_("any\n"));
14235 printf (_("software\n"));
14238 printf (_("hardware\n"));
14241 printf ("??? (%d)\n", val
);
14247 return display_tag_value (tag
& 1, p
, end
);
14251 display_sparc_hwcaps (unsigned int mask
)
14255 bfd_boolean first
= TRUE
;
14257 if (mask
& ELF_SPARC_HWCAP_MUL32
)
14258 fputs ("mul32", stdout
), first
= FALSE
;
14259 if (mask
& ELF_SPARC_HWCAP_DIV32
)
14260 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
14261 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
14262 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
14263 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
14264 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
14265 if (mask
& ELF_SPARC_HWCAP_POPC
)
14266 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
14267 if (mask
& ELF_SPARC_HWCAP_VIS
)
14268 printf ("%svis", first
? "" : "|"), first
= FALSE
;
14269 if (mask
& ELF_SPARC_HWCAP_VIS2
)
14270 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
14271 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
14272 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
14273 if (mask
& ELF_SPARC_HWCAP_FMAF
)
14274 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
14275 if (mask
& ELF_SPARC_HWCAP_VIS3
)
14276 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
14277 if (mask
& ELF_SPARC_HWCAP_HPC
)
14278 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
14279 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
14280 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
14281 if (mask
& ELF_SPARC_HWCAP_TRANS
)
14282 printf ("%strans", first
? "" : "|"), first
= FALSE
;
14283 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
14284 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
14285 if (mask
& ELF_SPARC_HWCAP_IMA
)
14286 printf ("%sima", first
? "" : "|"), first
= FALSE
;
14287 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
14288 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
14291 fputc ('0', stdout
);
14292 fputc ('\n', stdout
);
14296 display_sparc_hwcaps2 (unsigned int mask
)
14300 bfd_boolean first
= TRUE
;
14302 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
14303 fputs ("fjathplus", stdout
), first
= FALSE
;
14304 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
14305 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
14306 if (mask
& ELF_SPARC_HWCAP2_ADP
)
14307 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
14308 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
14309 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
14310 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
14311 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
14312 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
14313 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
14314 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
14315 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
14316 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
14317 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
14318 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
14319 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
14320 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
14321 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
14322 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
14323 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
14326 fputc ('0', stdout
);
14327 fputc ('\n', stdout
);
14330 static unsigned char *
14331 display_sparc_gnu_attribute (unsigned char * p
,
14333 const unsigned char * const end
)
14338 if (tag
== Tag_GNU_Sparc_HWCAPS
)
14340 val
= read_uleb128 (p
, &len
, end
);
14342 printf (" Tag_GNU_Sparc_HWCAPS: ");
14343 display_sparc_hwcaps (val
);
14346 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
14348 val
= read_uleb128 (p
, &len
, end
);
14350 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14351 display_sparc_hwcaps2 (val
);
14355 return display_tag_value (tag
, p
, end
);
14359 print_mips_fp_abi_value (unsigned int val
)
14363 case Val_GNU_MIPS_ABI_FP_ANY
:
14364 printf (_("Hard or soft float\n"));
14366 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
14367 printf (_("Hard float (double precision)\n"));
14369 case Val_GNU_MIPS_ABI_FP_SINGLE
:
14370 printf (_("Hard float (single precision)\n"));
14372 case Val_GNU_MIPS_ABI_FP_SOFT
:
14373 printf (_("Soft float\n"));
14375 case Val_GNU_MIPS_ABI_FP_OLD_64
:
14376 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14378 case Val_GNU_MIPS_ABI_FP_XX
:
14379 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14381 case Val_GNU_MIPS_ABI_FP_64
:
14382 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14384 case Val_GNU_MIPS_ABI_FP_64A
:
14385 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14387 case Val_GNU_MIPS_ABI_FP_NAN2008
:
14388 printf (_("NaN 2008 compatibility\n"));
14391 printf ("??? (%d)\n", val
);
14396 static unsigned char *
14397 display_mips_gnu_attribute (unsigned char * p
,
14399 const unsigned char * const end
)
14401 if (tag
== Tag_GNU_MIPS_ABI_FP
)
14406 val
= read_uleb128 (p
, &len
, end
);
14408 printf (" Tag_GNU_MIPS_ABI_FP: ");
14410 print_mips_fp_abi_value (val
);
14415 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
14420 val
= read_uleb128 (p
, &len
, end
);
14422 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14426 case Val_GNU_MIPS_ABI_MSA_ANY
:
14427 printf (_("Any MSA or not\n"));
14429 case Val_GNU_MIPS_ABI_MSA_128
:
14430 printf (_("128-bit MSA\n"));
14433 printf ("??? (%d)\n", val
);
14439 return display_tag_value (tag
& 1, p
, end
);
14442 static unsigned char *
14443 display_tic6x_attribute (unsigned char * p
,
14444 const unsigned char * const end
)
14450 tag
= read_uleb128 (p
, &len
, end
);
14456 val
= read_uleb128 (p
, &len
, end
);
14458 printf (" Tag_ISA: ");
14462 case C6XABI_Tag_ISA_none
:
14463 printf (_("None\n"));
14465 case C6XABI_Tag_ISA_C62X
:
14468 case C6XABI_Tag_ISA_C67X
:
14471 case C6XABI_Tag_ISA_C67XP
:
14472 printf ("C67x+\n");
14474 case C6XABI_Tag_ISA_C64X
:
14477 case C6XABI_Tag_ISA_C64XP
:
14478 printf ("C64x+\n");
14480 case C6XABI_Tag_ISA_C674X
:
14481 printf ("C674x\n");
14484 printf ("??? (%d)\n", val
);
14489 case Tag_ABI_wchar_t
:
14490 val
= read_uleb128 (p
, &len
, end
);
14492 printf (" Tag_ABI_wchar_t: ");
14496 printf (_("Not used\n"));
14499 printf (_("2 bytes\n"));
14502 printf (_("4 bytes\n"));
14505 printf ("??? (%d)\n", val
);
14510 case Tag_ABI_stack_align_needed
:
14511 val
= read_uleb128 (p
, &len
, end
);
14513 printf (" Tag_ABI_stack_align_needed: ");
14517 printf (_("8-byte\n"));
14520 printf (_("16-byte\n"));
14523 printf ("??? (%d)\n", val
);
14528 case Tag_ABI_stack_align_preserved
:
14529 val
= read_uleb128 (p
, &len
, end
);
14531 printf (" Tag_ABI_stack_align_preserved: ");
14535 printf (_("8-byte\n"));
14538 printf (_("16-byte\n"));
14541 printf ("??? (%d)\n", val
);
14547 val
= read_uleb128 (p
, &len
, end
);
14549 printf (" Tag_ABI_DSBT: ");
14553 printf (_("DSBT addressing not used\n"));
14556 printf (_("DSBT addressing used\n"));
14559 printf ("??? (%d)\n", val
);
14565 val
= read_uleb128 (p
, &len
, end
);
14567 printf (" Tag_ABI_PID: ");
14571 printf (_("Data addressing position-dependent\n"));
14574 printf (_("Data addressing position-independent, GOT near DP\n"));
14577 printf (_("Data addressing position-independent, GOT far from DP\n"));
14580 printf ("??? (%d)\n", val
);
14586 val
= read_uleb128 (p
, &len
, end
);
14588 printf (" Tag_ABI_PIC: ");
14592 printf (_("Code addressing position-dependent\n"));
14595 printf (_("Code addressing position-independent\n"));
14598 printf ("??? (%d)\n", val
);
14603 case Tag_ABI_array_object_alignment
:
14604 val
= read_uleb128 (p
, &len
, end
);
14606 printf (" Tag_ABI_array_object_alignment: ");
14610 printf (_("8-byte\n"));
14613 printf (_("4-byte\n"));
14616 printf (_("16-byte\n"));
14619 printf ("??? (%d)\n", val
);
14624 case Tag_ABI_array_object_align_expected
:
14625 val
= read_uleb128 (p
, &len
, end
);
14627 printf (" Tag_ABI_array_object_align_expected: ");
14631 printf (_("8-byte\n"));
14634 printf (_("4-byte\n"));
14637 printf (_("16-byte\n"));
14640 printf ("??? (%d)\n", val
);
14645 case Tag_ABI_compatibility
:
14647 val
= read_uleb128 (p
, &len
, end
);
14649 printf (" Tag_ABI_compatibility: ");
14650 printf (_("flag = %d, vendor = "), val
);
14653 size_t maxlen
= (end
- p
) - 1;
14655 print_symbol ((int) maxlen
, (const char *) p
);
14656 p
+= strnlen ((char *) p
, maxlen
) + 1;
14660 printf (_("<corrupt>"));
14661 p
= (unsigned char *) end
;
14667 case Tag_ABI_conformance
:
14669 printf (" Tag_ABI_conformance: \"");
14672 size_t maxlen
= (end
- p
) - 1;
14674 print_symbol ((int) maxlen
, (const char *) p
);
14675 p
+= strnlen ((char *) p
, maxlen
) + 1;
14679 printf (_("<corrupt>"));
14680 p
= (unsigned char *) end
;
14687 return display_tag_value (tag
, p
, end
);
14691 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
14693 unsigned long addr
= 0;
14694 size_t bytes
= end
- p
;
14701 int lbytes
= (bytes
> 16 ? 16 : bytes
);
14703 printf (" 0x%8.8lx ", addr
);
14705 for (j
= 0; j
< 16; j
++)
14708 printf ("%2.2x", p
[j
]);
14716 for (j
= 0; j
< lbytes
; j
++)
14719 if (k
>= ' ' && k
< 0x7f)
14735 static unsigned char *
14736 display_msp430x_attribute (unsigned char * p
,
14737 const unsigned char * const end
)
14743 tag
= read_uleb128 (p
, & len
, end
);
14748 case OFBA_MSPABI_Tag_ISA
:
14749 val
= read_uleb128 (p
, &len
, end
);
14751 printf (" Tag_ISA: ");
14754 case 0: printf (_("None\n")); break;
14755 case 1: printf (_("MSP430\n")); break;
14756 case 2: printf (_("MSP430X\n")); break;
14757 default: printf ("??? (%d)\n", val
); break;
14761 case OFBA_MSPABI_Tag_Code_Model
:
14762 val
= read_uleb128 (p
, &len
, end
);
14764 printf (" Tag_Code_Model: ");
14767 case 0: printf (_("None\n")); break;
14768 case 1: printf (_("Small\n")); break;
14769 case 2: printf (_("Large\n")); break;
14770 default: printf ("??? (%d)\n", val
); break;
14774 case OFBA_MSPABI_Tag_Data_Model
:
14775 val
= read_uleb128 (p
, &len
, end
);
14777 printf (" Tag_Data_Model: ");
14780 case 0: printf (_("None\n")); break;
14781 case 1: printf (_("Small\n")); break;
14782 case 2: printf (_("Large\n")); break;
14783 case 3: printf (_("Restricted Large\n")); break;
14784 default: printf ("??? (%d)\n", val
); break;
14789 printf (_(" <unknown tag %d>: "), tag
);
14796 size_t maxlen
= (end
- p
) - 1;
14798 print_symbol ((int) maxlen
, (const char *) p
);
14799 p
+= strnlen ((char *) p
, maxlen
) + 1;
14803 printf (_("<corrupt>"));
14804 p
= (unsigned char *) end
;
14810 val
= read_uleb128 (p
, &len
, end
);
14812 printf ("%d (0x%x)\n", val
, val
);
14822 process_attributes (FILE * file
,
14823 const char * public_name
,
14824 unsigned int proc_type
,
14825 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
14826 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
14828 Elf_Internal_Shdr
* sect
;
14830 bfd_boolean res
= TRUE
;
14832 /* Find the section header so that we get the size. */
14833 for (i
= 0, sect
= section_headers
;
14834 i
< elf_header
.e_shnum
;
14837 unsigned char * contents
;
14840 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
14843 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
14844 sect
->sh_size
, _("attributes"));
14845 if (contents
== NULL
)
14852 /* The first character is the version of the attributes.
14853 Currently only version 1, (aka 'A') is recognised here. */
14856 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
14861 bfd_vma section_len
;
14863 section_len
= sect
->sh_size
- 1;
14866 while (section_len
> 0)
14869 unsigned int namelen
;
14870 bfd_boolean public_section
;
14871 bfd_boolean gnu_section
;
14873 if (section_len
<= 4)
14875 error (_("Tag section ends prematurely\n"));
14879 attr_len
= byte_get (p
, 4);
14882 if (attr_len
> section_len
)
14884 error (_("Bad attribute length (%u > %u)\n"),
14885 (unsigned) attr_len
, (unsigned) section_len
);
14886 attr_len
= section_len
;
14889 /* PR 17531: file: 001-101425-0.004 */
14890 else if (attr_len
< 5)
14892 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
14897 section_len
-= attr_len
;
14900 namelen
= strnlen ((char *) p
, attr_len
) + 1;
14901 if (namelen
== 0 || namelen
>= attr_len
)
14903 error (_("Corrupt attribute section name\n"));
14908 printf (_("Attribute Section: "));
14909 print_symbol (INT_MAX
, (const char *) p
);
14912 if (public_name
&& streq ((char *) p
, public_name
))
14913 public_section
= TRUE
;
14915 public_section
= FALSE
;
14917 if (streq ((char *) p
, "gnu"))
14918 gnu_section
= TRUE
;
14920 gnu_section
= FALSE
;
14923 attr_len
-= namelen
;
14925 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
14930 unsigned char * end
;
14932 /* PR binutils/17531: Safe handling of corrupt files. */
14935 error (_("Unused bytes at end of section\n"));
14942 size
= byte_get (p
, 4);
14943 if (size
> attr_len
)
14945 error (_("Bad subsection length (%u > %u)\n"),
14946 (unsigned) size
, (unsigned) attr_len
);
14950 /* PR binutils/17531: Safe handling of corrupt files. */
14953 error (_("Bad subsection length (%u < 6)\n"),
14961 end
= p
+ size
- 1;
14962 assert (end
<= contents
+ sect
->sh_size
);
14968 printf (_("File Attributes\n"));
14971 printf (_("Section Attributes:"));
14974 printf (_("Symbol Attributes:"));
14975 /* Fall through. */
14981 val
= read_uleb128 (p
, &j
, end
);
14985 printf (" %d", val
);
14990 printf (_("Unknown tag: %d\n"), tag
);
14991 public_section
= FALSE
;
14995 if (public_section
&& display_pub_attribute
!= NULL
)
14998 p
= display_pub_attribute (p
, end
);
15001 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
15004 p
= display_gnu_attribute (p
,
15005 display_proc_gnu_attribute
,
15011 printf (_(" Unknown attribute:\n"));
15012 display_raw_attribute (p
, end
);
15027 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15028 Print the Address, Access and Initial fields of an entry at VMA ADDR
15029 and return the VMA of the next entry, or -1 if there was a problem.
15030 Does not read from DATA_END or beyond. */
15033 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
15034 unsigned char * data_end
)
15037 print_vma (addr
, LONG_HEX
);
15039 if (addr
< pltgot
+ 0xfff0)
15040 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
15042 printf ("%10s", "");
15045 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15049 unsigned char * from
= data
+ addr
- pltgot
;
15051 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
15053 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15054 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
15055 return (bfd_vma
) -1;
15059 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15060 print_vma (entry
, LONG_HEX
);
15063 return addr
+ (is_32bit_elf
? 4 : 8);
15066 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15067 PLTGOT. Print the Address and Initial fields of an entry at VMA
15068 ADDR and return the VMA of the next entry. */
15071 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
15074 print_vma (addr
, LONG_HEX
);
15077 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15082 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15083 print_vma (entry
, LONG_HEX
);
15085 return addr
+ (is_32bit_elf
? 4 : 8);
15089 print_mips_ases (unsigned int mask
)
15091 if (mask
& AFL_ASE_DSP
)
15092 fputs ("\n\tDSP ASE", stdout
);
15093 if (mask
& AFL_ASE_DSPR2
)
15094 fputs ("\n\tDSP R2 ASE", stdout
);
15095 if (mask
& AFL_ASE_DSPR3
)
15096 fputs ("\n\tDSP R3 ASE", stdout
);
15097 if (mask
& AFL_ASE_EVA
)
15098 fputs ("\n\tEnhanced VA Scheme", stdout
);
15099 if (mask
& AFL_ASE_MCU
)
15100 fputs ("\n\tMCU (MicroController) ASE", stdout
);
15101 if (mask
& AFL_ASE_MDMX
)
15102 fputs ("\n\tMDMX ASE", stdout
);
15103 if (mask
& AFL_ASE_MIPS3D
)
15104 fputs ("\n\tMIPS-3D ASE", stdout
);
15105 if (mask
& AFL_ASE_MT
)
15106 fputs ("\n\tMT ASE", stdout
);
15107 if (mask
& AFL_ASE_SMARTMIPS
)
15108 fputs ("\n\tSmartMIPS ASE", stdout
);
15109 if (mask
& AFL_ASE_VIRT
)
15110 fputs ("\n\tVZ ASE", stdout
);
15111 if (mask
& AFL_ASE_MSA
)
15112 fputs ("\n\tMSA ASE", stdout
);
15113 if (mask
& AFL_ASE_MIPS16
)
15114 fputs ("\n\tMIPS16 ASE", stdout
);
15115 if (mask
& AFL_ASE_MICROMIPS
)
15116 fputs ("\n\tMICROMIPS ASE", stdout
);
15117 if (mask
& AFL_ASE_XPA
)
15118 fputs ("\n\tXPA ASE", stdout
);
15119 if (mask
& AFL_ASE_MIPS16E2
)
15120 fputs ("\n\tMIPS16e2 ASE", stdout
);
15122 fprintf (stdout
, "\n\t%s", _("None"));
15123 else if ((mask
& ~AFL_ASE_MASK
) != 0)
15124 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
15128 print_mips_isa_ext (unsigned int isa_ext
)
15133 fputs (_("None"), stdout
);
15136 fputs ("RMI XLR", stdout
);
15138 case AFL_EXT_OCTEON3
:
15139 fputs ("Cavium Networks Octeon3", stdout
);
15141 case AFL_EXT_OCTEON2
:
15142 fputs ("Cavium Networks Octeon2", stdout
);
15144 case AFL_EXT_OCTEONP
:
15145 fputs ("Cavium Networks OcteonP", stdout
);
15147 case AFL_EXT_LOONGSON_3A
:
15148 fputs ("Loongson 3A", stdout
);
15150 case AFL_EXT_OCTEON
:
15151 fputs ("Cavium Networks Octeon", stdout
);
15154 fputs ("Toshiba R5900", stdout
);
15157 fputs ("MIPS R4650", stdout
);
15160 fputs ("LSI R4010", stdout
);
15163 fputs ("NEC VR4100", stdout
);
15166 fputs ("Toshiba R3900", stdout
);
15168 case AFL_EXT_10000
:
15169 fputs ("MIPS R10000", stdout
);
15172 fputs ("Broadcom SB-1", stdout
);
15175 fputs ("NEC VR4111/VR4181", stdout
);
15178 fputs ("NEC VR4120", stdout
);
15181 fputs ("NEC VR5400", stdout
);
15184 fputs ("NEC VR5500", stdout
);
15186 case AFL_EXT_LOONGSON_2E
:
15187 fputs ("ST Microelectronics Loongson 2E", stdout
);
15189 case AFL_EXT_LOONGSON_2F
:
15190 fputs ("ST Microelectronics Loongson 2F", stdout
);
15192 case AFL_EXT_INTERAPTIV_MR2
:
15193 fputs ("Imagination interAptiv MR2", stdout
);
15196 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
15201 get_mips_reg_size (int reg_size
)
15203 return (reg_size
== AFL_REG_NONE
) ? 0
15204 : (reg_size
== AFL_REG_32
) ? 32
15205 : (reg_size
== AFL_REG_64
) ? 64
15206 : (reg_size
== AFL_REG_128
) ? 128
15211 process_mips_specific (FILE * file
)
15213 Elf_Internal_Dyn
* entry
;
15214 Elf_Internal_Shdr
*sect
= NULL
;
15215 size_t liblist_offset
= 0;
15216 size_t liblistno
= 0;
15217 size_t conflictsno
= 0;
15218 size_t options_offset
= 0;
15219 size_t conflicts_offset
= 0;
15220 size_t pltrelsz
= 0;
15222 bfd_vma pltgot
= 0;
15223 bfd_vma mips_pltgot
= 0;
15224 bfd_vma jmprel
= 0;
15225 bfd_vma local_gotno
= 0;
15226 bfd_vma gotsym
= 0;
15227 bfd_vma symtabno
= 0;
15228 bfd_boolean res
= TRUE
;
15230 if (! process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
15231 display_mips_gnu_attribute
))
15234 sect
= find_section (".MIPS.abiflags");
15238 Elf_External_ABIFlags_v0
*abiflags_ext
;
15239 Elf_Internal_ABIFlags_v0 abiflags_in
;
15241 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
15243 error (_("Corrupt MIPS ABI Flags section.\n"));
15248 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
15249 sect
->sh_size
, _("MIPS ABI Flags section"));
15252 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
15253 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
15254 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
15255 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
15256 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
15257 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
15258 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
15259 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
15260 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
15261 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
15262 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
15264 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
15265 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
15266 if (abiflags_in
.isa_rev
> 1)
15267 printf ("r%d", abiflags_in
.isa_rev
);
15268 printf ("\nGPR size: %d",
15269 get_mips_reg_size (abiflags_in
.gpr_size
));
15270 printf ("\nCPR1 size: %d",
15271 get_mips_reg_size (abiflags_in
.cpr1_size
));
15272 printf ("\nCPR2 size: %d",
15273 get_mips_reg_size (abiflags_in
.cpr2_size
));
15274 fputs ("\nFP ABI: ", stdout
);
15275 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
15276 fputs ("ISA Extension: ", stdout
);
15277 print_mips_isa_ext (abiflags_in
.isa_ext
);
15278 fputs ("\nASEs:", stdout
);
15279 print_mips_ases (abiflags_in
.ases
);
15280 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
15281 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
15282 fputc ('\n', stdout
);
15283 free (abiflags_ext
);
15288 /* We have a lot of special sections. Thanks SGI! */
15289 if (dynamic_section
== NULL
)
15291 /* No dynamic information available. See if there is static GOT. */
15292 sect
= find_section (".got");
15295 unsigned char *data_end
;
15296 unsigned char *data
;
15300 pltgot
= sect
->sh_addr
;
15303 addr_size
= (is_32bit_elf
? 4 : 8);
15304 end
= pltgot
+ sect
->sh_size
;
15306 data
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
,
15308 _("Global Offset Table data"));
15309 /* PR 12855: Null data is handled gracefully throughout. */
15310 data_end
= data
+ (end
- pltgot
);
15312 printf (_("\nStatic GOT:\n"));
15313 printf (_(" Canonical gp value: "));
15314 print_vma (ent
+ 0x7ff0, LONG_HEX
);
15317 /* In a dynamic binary GOT[0] is reserved for the dynamic
15318 loader to store the lazy resolver pointer, however in
15319 a static binary it may well have been omitted and GOT
15320 reduced to a table of addresses.
15321 PR 21344: Check for the entry being fully available
15322 before fetching it. */
15324 && data
+ ent
- pltgot
+ addr_size
<= data_end
15325 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
15327 printf (_(" Reserved entries:\n"));
15328 printf (_(" %*s %10s %*s\n"),
15329 addr_size
* 2, _("Address"), _("Access"),
15330 addr_size
* 2, _("Value"));
15331 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15333 if (ent
== (bfd_vma
) -1)
15334 goto sgot_print_fail
;
15336 /* Check for the MSB of GOT[1] being set, identifying a
15337 GNU object. This entry will be used by some runtime
15338 loaders, to store the module pointer. Otherwise this
15339 is an ordinary local entry.
15340 PR 21344: Check for the entry being fully available
15341 before fetching it. */
15343 && data
+ ent
- pltgot
+ addr_size
<= data_end
15344 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15345 >> (addr_size
* 8 - 1)) != 0)
15347 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15349 if (ent
== (bfd_vma
) -1)
15350 goto sgot_print_fail
;
15355 if (data
!= NULL
&& ent
< end
)
15357 printf (_(" Local entries:\n"));
15358 printf (" %*s %10s %*s\n",
15359 addr_size
* 2, _("Address"), _("Access"),
15360 addr_size
* 2, _("Value"));
15363 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15365 if (ent
== (bfd_vma
) -1)
15366 goto sgot_print_fail
;
15378 for (entry
= dynamic_section
;
15379 /* PR 17531 file: 012-50589-0.004. */
15380 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
15382 switch (entry
->d_tag
)
15384 case DT_MIPS_LIBLIST
:
15386 = offset_from_vma (file
, entry
->d_un
.d_val
,
15387 liblistno
* sizeof (Elf32_External_Lib
));
15389 case DT_MIPS_LIBLISTNO
:
15390 liblistno
= entry
->d_un
.d_val
;
15392 case DT_MIPS_OPTIONS
:
15393 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
15395 case DT_MIPS_CONFLICT
:
15397 = offset_from_vma (file
, entry
->d_un
.d_val
,
15398 conflictsno
* sizeof (Elf32_External_Conflict
));
15400 case DT_MIPS_CONFLICTNO
:
15401 conflictsno
= entry
->d_un
.d_val
;
15404 pltgot
= entry
->d_un
.d_ptr
;
15406 case DT_MIPS_LOCAL_GOTNO
:
15407 local_gotno
= entry
->d_un
.d_val
;
15409 case DT_MIPS_GOTSYM
:
15410 gotsym
= entry
->d_un
.d_val
;
15412 case DT_MIPS_SYMTABNO
:
15413 symtabno
= entry
->d_un
.d_val
;
15415 case DT_MIPS_PLTGOT
:
15416 mips_pltgot
= entry
->d_un
.d_ptr
;
15419 pltrel
= entry
->d_un
.d_val
;
15422 pltrelsz
= entry
->d_un
.d_val
;
15425 jmprel
= entry
->d_un
.d_ptr
;
15431 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
15433 Elf32_External_Lib
* elib
;
15436 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
15438 sizeof (Elf32_External_Lib
),
15439 _("liblist section data"));
15442 printf (_("\nSection '.liblist' contains %lu entries:\n"),
15443 (unsigned long) liblistno
);
15444 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
15447 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
15454 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15455 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15456 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15457 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15458 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15460 tmp
= gmtime (&atime
);
15461 snprintf (timebuf
, sizeof (timebuf
),
15462 "%04u-%02u-%02uT%02u:%02u:%02u",
15463 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15464 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15466 printf ("%3lu: ", (unsigned long) cnt
);
15467 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
15468 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
15470 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
15471 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
15472 liblist
.l_version
);
15474 if (liblist
.l_flags
== 0)
15478 static const struct
15485 { " EXACT_MATCH", LL_EXACT_MATCH
},
15486 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
15487 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
15488 { " EXPORTS", LL_EXPORTS
},
15489 { " DELAY_LOAD", LL_DELAY_LOAD
},
15490 { " DELTA", LL_DELTA
}
15492 int flags
= liblist
.l_flags
;
15495 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
15496 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
15498 fputs (l_flags_vals
[fcnt
].name
, stdout
);
15499 flags
^= l_flags_vals
[fcnt
].bit
;
15502 printf (" %#x", (unsigned int) flags
);
15514 if (options_offset
!= 0)
15516 Elf_External_Options
* eopt
;
15517 Elf_Internal_Options
* iopt
;
15518 Elf_Internal_Options
* option
;
15521 sect
= section_headers
;
15523 /* Find the section header so that we get the size. */
15524 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
15525 /* PR 17533 file: 012-277276-0.004. */
15528 error (_("No MIPS_OPTIONS header found\n"));
15532 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
15533 sect
->sh_size
, _("options"));
15536 iopt
= (Elf_Internal_Options
*)
15537 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
15540 error (_("Out of memory allocating space for MIPS options\n"));
15547 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
15549 Elf_External_Options
* eoption
;
15551 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
15553 option
->kind
= BYTE_GET (eoption
->kind
);
15554 option
->size
= BYTE_GET (eoption
->size
);
15555 option
->section
= BYTE_GET (eoption
->section
);
15556 option
->info
= BYTE_GET (eoption
->info
);
15558 /* PR 17531: file: ffa0fa3b. */
15559 if (option
->size
< sizeof (* eopt
)
15560 || offset
+ option
->size
> sect
->sh_size
)
15562 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
15565 offset
+= option
->size
;
15571 printf (_("\nSection '%s' contains %d entries:\n"),
15572 printable_section_name (sect
), cnt
);
15581 switch (option
->kind
)
15584 /* This shouldn't happen. */
15585 printf (" NULL %d %lx", option
->section
, option
->info
);
15588 printf (" REGINFO ");
15589 if (elf_header
.e_machine
== EM_MIPS
)
15592 Elf32_External_RegInfo
* ereg
;
15593 Elf32_RegInfo reginfo
;
15595 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
15596 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15597 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15598 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15599 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15600 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15601 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15603 printf ("GPR %08lx GP 0x%lx\n",
15604 reginfo
.ri_gprmask
,
15605 (unsigned long) reginfo
.ri_gp_value
);
15606 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15607 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15608 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15613 Elf64_External_RegInfo
* ereg
;
15614 Elf64_Internal_RegInfo reginfo
;
15616 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
15617 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15618 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15619 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15620 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15621 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15622 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15624 printf ("GPR %08lx GP 0x",
15625 reginfo
.ri_gprmask
);
15626 printf_vma (reginfo
.ri_gp_value
);
15629 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15630 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15631 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15635 case ODK_EXCEPTIONS
:
15636 fputs (" EXCEPTIONS fpe_min(", stdout
);
15637 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
15638 fputs (") fpe_max(", stdout
);
15639 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
15640 fputs (")", stdout
);
15642 if (option
->info
& OEX_PAGE0
)
15643 fputs (" PAGE0", stdout
);
15644 if (option
->info
& OEX_SMM
)
15645 fputs (" SMM", stdout
);
15646 if (option
->info
& OEX_FPDBUG
)
15647 fputs (" FPDBUG", stdout
);
15648 if (option
->info
& OEX_DISMISS
)
15649 fputs (" DISMISS", stdout
);
15652 fputs (" PAD ", stdout
);
15653 if (option
->info
& OPAD_PREFIX
)
15654 fputs (" PREFIX", stdout
);
15655 if (option
->info
& OPAD_POSTFIX
)
15656 fputs (" POSTFIX", stdout
);
15657 if (option
->info
& OPAD_SYMBOL
)
15658 fputs (" SYMBOL", stdout
);
15661 fputs (" HWPATCH ", stdout
);
15662 if (option
->info
& OHW_R4KEOP
)
15663 fputs (" R4KEOP", stdout
);
15664 if (option
->info
& OHW_R8KPFETCH
)
15665 fputs (" R8KPFETCH", stdout
);
15666 if (option
->info
& OHW_R5KEOP
)
15667 fputs (" R5KEOP", stdout
);
15668 if (option
->info
& OHW_R5KCVTL
)
15669 fputs (" R5KCVTL", stdout
);
15672 fputs (" FILL ", stdout
);
15673 /* XXX Print content of info word? */
15676 fputs (" TAGS ", stdout
);
15677 /* XXX Print content of info word? */
15680 fputs (" HWAND ", stdout
);
15681 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15682 fputs (" R4KEOP_CHECKED", stdout
);
15683 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15684 fputs (" R4KEOP_CLEAN", stdout
);
15687 fputs (" HWOR ", stdout
);
15688 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15689 fputs (" R4KEOP_CHECKED", stdout
);
15690 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15691 fputs (" R4KEOP_CLEAN", stdout
);
15694 printf (" GP_GROUP %#06lx self-contained %#06lx",
15695 option
->info
& OGP_GROUP
,
15696 (option
->info
& OGP_SELF
) >> 16);
15699 printf (" IDENT %#06lx self-contained %#06lx",
15700 option
->info
& OGP_GROUP
,
15701 (option
->info
& OGP_SELF
) >> 16);
15704 /* This shouldn't happen. */
15705 printf (" %3d ??? %d %lx",
15706 option
->kind
, option
->section
, option
->info
);
15710 len
= sizeof (* eopt
);
15711 while (len
< option
->size
)
15713 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
15715 if (ISPRINT (datum
))
15716 printf ("%c", datum
);
15718 printf ("\\%03o", datum
);
15721 fputs ("\n", stdout
);
15723 offset
+= option
->size
;
15733 if (conflicts_offset
!= 0 && conflictsno
!= 0)
15735 Elf32_Conflict
* iconf
;
15738 if (dynamic_symbols
== NULL
)
15740 error (_("conflict list found without a dynamic symbol table\n"));
15744 /* PR 21345 - print a slightly more helpful error message
15745 if we are sure that the cmalloc will fail. */
15746 if (conflictsno
* sizeof (* iconf
) > current_file_size
)
15748 error (_("Overlarge number of conflicts detected: %lx\n"),
15749 (long) conflictsno
);
15753 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
15756 error (_("Out of memory allocating space for dynamic conflicts\n"));
15762 Elf32_External_Conflict
* econf32
;
15764 econf32
= (Elf32_External_Conflict
*)
15765 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15766 sizeof (* econf32
), _("conflict"));
15770 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15771 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
15777 Elf64_External_Conflict
* econf64
;
15779 econf64
= (Elf64_External_Conflict
*)
15780 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15781 sizeof (* econf64
), _("conflict"));
15785 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15786 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
15791 printf (_("\nSection '.conflict' contains %lu entries:\n"),
15792 (unsigned long) conflictsno
);
15793 puts (_(" Num: Index Value Name"));
15795 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15797 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
15799 if (iconf
[cnt
] >= num_dynamic_syms
)
15800 printf (_("<corrupt symbol index>"));
15803 Elf_Internal_Sym
* psym
;
15805 psym
= & dynamic_symbols
[iconf
[cnt
]];
15806 print_vma (psym
->st_value
, FULL_HEX
);
15808 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15809 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
15811 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15819 if (pltgot
!= 0 && local_gotno
!= 0)
15821 bfd_vma ent
, local_end
, global_end
;
15823 unsigned char * data
;
15824 unsigned char * data_end
;
15828 addr_size
= (is_32bit_elf
? 4 : 8);
15829 local_end
= pltgot
+ local_gotno
* addr_size
;
15831 /* PR binutils/17533 file: 012-111227-0.004 */
15832 if (symtabno
< gotsym
)
15834 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
15835 (unsigned long) gotsym
, (unsigned long) symtabno
);
15839 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
15840 /* PR 17531: file: 54c91a34. */
15841 if (global_end
< local_end
)
15843 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
15847 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
15848 data
= (unsigned char *) get_data (NULL
, file
, offset
,
15849 global_end
- pltgot
, 1,
15850 _("Global Offset Table data"));
15851 /* PR 12855: Null data is handled gracefully throughout. */
15852 data_end
= data
+ (global_end
- pltgot
);
15854 printf (_("\nPrimary GOT:\n"));
15855 printf (_(" Canonical gp value: "));
15856 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
15859 printf (_(" Reserved entries:\n"));
15860 printf (_(" %*s %10s %*s Purpose\n"),
15861 addr_size
* 2, _("Address"), _("Access"),
15862 addr_size
* 2, _("Initial"));
15863 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15864 printf (_(" Lazy resolver\n"));
15865 if (ent
== (bfd_vma
) -1)
15866 goto got_print_fail
;
15868 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
15869 This entry will be used by some runtime loaders, to store the
15870 module pointer. Otherwise this is an ordinary local entry.
15871 PR 21344: Check for the entry being fully available before
15874 && data
+ ent
- pltgot
+ addr_size
<= data_end
15875 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15876 >> (addr_size
* 8 - 1)) != 0)
15878 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15879 printf (_(" Module pointer (GNU extension)\n"));
15880 if (ent
== (bfd_vma
) -1)
15881 goto got_print_fail
;
15885 if (data
!= NULL
&& ent
< local_end
)
15887 printf (_(" Local entries:\n"));
15888 printf (" %*s %10s %*s\n",
15889 addr_size
* 2, _("Address"), _("Access"),
15890 addr_size
* 2, _("Initial"));
15891 while (ent
< local_end
)
15893 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15895 if (ent
== (bfd_vma
) -1)
15896 goto got_print_fail
;
15901 if (data
!= NULL
&& gotsym
< symtabno
)
15905 printf (_(" Global entries:\n"));
15906 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
15907 addr_size
* 2, _("Address"),
15909 addr_size
* 2, _("Initial"),
15910 addr_size
* 2, _("Sym.Val."),
15912 /* Note for translators: "Ndx" = abbreviated form of "Index". */
15913 _("Ndx"), _("Name"));
15915 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
15917 for (i
= gotsym
; i
< symtabno
; i
++)
15919 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15922 if (dynamic_symbols
== NULL
)
15923 printf (_("<no dynamic symbols>"));
15924 else if (i
< num_dynamic_syms
)
15926 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
15928 print_vma (psym
->st_value
, LONG_HEX
);
15929 printf (" %-7s %3s ",
15930 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15931 get_symbol_index_type (psym
->st_shndx
));
15933 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15934 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15936 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15939 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15940 (unsigned long) i
);
15943 if (ent
== (bfd_vma
) -1)
15954 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
15957 size_t offset
, rel_offset
;
15958 unsigned long count
, i
;
15959 unsigned char * data
;
15960 int addr_size
, sym_width
;
15961 Elf_Internal_Rela
* rels
;
15963 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
15964 if (pltrel
== DT_RELA
)
15966 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15971 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15976 addr_size
= (is_32bit_elf
? 4 : 8);
15977 end
= mips_pltgot
+ (2 + count
) * addr_size
;
15979 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
15980 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
15981 1, _("Procedure Linkage Table data"));
15985 printf ("\nPLT GOT:\n\n");
15986 printf (_(" Reserved entries:\n"));
15987 printf (_(" %*s %*s Purpose\n"),
15988 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
15989 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15990 printf (_(" PLT lazy resolver\n"));
15991 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15992 printf (_(" Module pointer\n"));
15995 printf (_(" Entries:\n"));
15996 printf (" %*s %*s %*s %-7s %3s %s\n",
15997 addr_size
* 2, _("Address"),
15998 addr_size
* 2, _("Initial"),
15999 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16000 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
16001 for (i
= 0; i
< count
; i
++)
16003 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
16005 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16008 if (idx
>= num_dynamic_syms
)
16009 printf (_("<corrupt symbol index: %lu>"), idx
);
16012 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
16014 print_vma (psym
->st_value
, LONG_HEX
);
16015 printf (" %-7s %3s ",
16016 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
16017 get_symbol_index_type (psym
->st_shndx
));
16018 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16019 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
16021 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16036 process_nds32_specific (FILE * file
)
16038 Elf_Internal_Shdr
*sect
= NULL
;
16040 sect
= find_section (".nds32_e_flags");
16043 unsigned int *flag
;
16045 printf ("\nNDS32 elf flags section:\n");
16046 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
16047 sect
->sh_size
, _("NDS32 elf flags section"));
16052 switch ((*flag
) & 0x3)
16055 printf ("(VEC_SIZE):\tNo entry.\n");
16058 printf ("(VEC_SIZE):\t4 bytes\n");
16061 printf ("(VEC_SIZE):\t16 bytes\n");
16064 printf ("(VEC_SIZE):\treserved\n");
16073 process_gnu_liblist (FILE * file
)
16075 Elf_Internal_Shdr
* section
;
16076 Elf_Internal_Shdr
* string_sec
;
16077 Elf32_External_Lib
* elib
;
16079 size_t strtab_size
;
16082 bfd_boolean res
= TRUE
;
16087 for (i
= 0, section
= section_headers
;
16088 i
< elf_header
.e_shnum
;
16091 switch (section
->sh_type
)
16093 case SHT_GNU_LIBLIST
:
16094 if (section
->sh_link
>= elf_header
.e_shnum
)
16097 elib
= (Elf32_External_Lib
*)
16098 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
16099 _("liblist section data"));
16107 string_sec
= section_headers
+ section
->sh_link
;
16108 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
16109 string_sec
->sh_size
,
16110 _("liblist string table"));
16112 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
16119 strtab_size
= string_sec
->sh_size
;
16121 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
16122 printable_section_name (section
),
16123 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
16125 puts (_(" Library Time Stamp Checksum Version Flags"));
16127 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
16135 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16136 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16137 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16138 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16139 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16141 tmp
= gmtime (&atime
);
16142 snprintf (timebuf
, sizeof (timebuf
),
16143 "%04u-%02u-%02uT%02u:%02u:%02u",
16144 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16145 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16147 printf ("%3lu: ", (unsigned long) cnt
);
16149 printf ("%-20s", liblist
.l_name
< strtab_size
16150 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16152 printf ("%-20.20s", liblist
.l_name
< strtab_size
16153 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16154 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
16155 liblist
.l_version
, liblist
.l_flags
);
16166 static const char *
16167 get_note_type (unsigned e_type
)
16169 static char buff
[64];
16171 if (elf_header
.e_type
== ET_CORE
)
16175 return _("NT_AUXV (auxiliary vector)");
16177 return _("NT_PRSTATUS (prstatus structure)");
16179 return _("NT_FPREGSET (floating point registers)");
16181 return _("NT_PRPSINFO (prpsinfo structure)");
16182 case NT_TASKSTRUCT
:
16183 return _("NT_TASKSTRUCT (task structure)");
16185 return _("NT_PRXFPREG (user_xfpregs structure)");
16187 return _("NT_PPC_VMX (ppc Altivec registers)");
16189 return _("NT_PPC_VSX (ppc VSX registers)");
16191 return _("NT_PPC_TAR (ppc TAR register)");
16193 return _("NT_PPC_PPR (ppc PPR register)");
16195 return _("NT_PPC_DSCR (ppc DSCR register)");
16197 return _("NT_PPC_EBB (ppc EBB registers)");
16199 return _("NT_PPC_PMU (ppc PMU registers)");
16200 case NT_PPC_TM_CGPR
:
16201 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16202 case NT_PPC_TM_CFPR
:
16203 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16204 case NT_PPC_TM_CVMX
:
16205 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16206 case NT_PPC_TM_CVSX
:
16207 return _("NT_PPC_TM_VSX (ppc checkpointed VSX registers)");
16208 case NT_PPC_TM_SPR
:
16209 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16210 case NT_PPC_TM_CTAR
:
16211 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16212 case NT_PPC_TM_CPPR
:
16213 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16214 case NT_PPC_TM_CDSCR
:
16215 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16217 return _("NT_386_TLS (x86 TLS information)");
16218 case NT_386_IOPERM
:
16219 return _("NT_386_IOPERM (x86 I/O permissions)");
16220 case NT_X86_XSTATE
:
16221 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16222 case NT_S390_HIGH_GPRS
:
16223 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16224 case NT_S390_TIMER
:
16225 return _("NT_S390_TIMER (s390 timer register)");
16226 case NT_S390_TODCMP
:
16227 return _("NT_S390_TODCMP (s390 TOD comparator register)");
16228 case NT_S390_TODPREG
:
16229 return _("NT_S390_TODPREG (s390 TOD programmable register)");
16231 return _("NT_S390_CTRS (s390 control registers)");
16232 case NT_S390_PREFIX
:
16233 return _("NT_S390_PREFIX (s390 prefix register)");
16234 case NT_S390_LAST_BREAK
:
16235 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16236 case NT_S390_SYSTEM_CALL
:
16237 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16239 return _("NT_S390_TDB (s390 transaction diagnostic block)");
16240 case NT_S390_VXRS_LOW
:
16241 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16242 case NT_S390_VXRS_HIGH
:
16243 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16244 case NT_S390_GS_CB
:
16245 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16246 case NT_S390_GS_BC
:
16247 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16249 return _("NT_ARM_VFP (arm VFP registers)");
16251 return _("NT_ARM_TLS (AArch TLS registers)");
16252 case NT_ARM_HW_BREAK
:
16253 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16254 case NT_ARM_HW_WATCH
:
16255 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16257 return _("NT_PSTATUS (pstatus structure)");
16259 return _("NT_FPREGS (floating point registers)");
16261 return _("NT_PSINFO (psinfo structure)");
16263 return _("NT_LWPSTATUS (lwpstatus_t structure)");
16265 return _("NT_LWPSINFO (lwpsinfo_t structure)");
16266 case NT_WIN32PSTATUS
:
16267 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16269 return _("NT_SIGINFO (siginfo_t data)");
16271 return _("NT_FILE (mapped files)");
16279 return _("NT_VERSION (version)");
16281 return _("NT_ARCH (architecture)");
16282 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16283 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16284 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16285 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16290 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16295 print_core_note (Elf_Internal_Note
*pnote
)
16297 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
16298 bfd_vma count
, page_size
;
16299 unsigned char *descdata
, *filenames
, *descend
;
16301 if (pnote
->type
!= NT_FILE
)
16311 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
16312 /* Still "successful". */
16317 if (pnote
->descsz
< 2 * addr_size
)
16319 error (_(" Malformed note - too short for header\n"));
16323 descdata
= (unsigned char *) pnote
->descdata
;
16324 descend
= descdata
+ pnote
->descsz
;
16326 if (descdata
[pnote
->descsz
- 1] != '\0')
16328 error (_(" Malformed note - does not end with \\0\n"));
16332 count
= byte_get (descdata
, addr_size
);
16333 descdata
+= addr_size
;
16335 page_size
= byte_get (descdata
, addr_size
);
16336 descdata
+= addr_size
;
16338 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
16340 error (_(" Malformed note - too short for supplied file count\n"));
16344 printf (_(" Page size: "));
16345 print_vma (page_size
, DEC
);
16348 printf (_(" %*s%*s%*s\n"),
16349 (int) (2 + 2 * addr_size
), _("Start"),
16350 (int) (4 + 2 * addr_size
), _("End"),
16351 (int) (4 + 2 * addr_size
), _("Page Offset"));
16352 filenames
= descdata
+ count
* 3 * addr_size
;
16353 while (count
-- > 0)
16355 bfd_vma start
, end
, file_ofs
;
16357 if (filenames
== descend
)
16359 error (_(" Malformed note - filenames end too early\n"));
16363 start
= byte_get (descdata
, addr_size
);
16364 descdata
+= addr_size
;
16365 end
= byte_get (descdata
, addr_size
);
16366 descdata
+= addr_size
;
16367 file_ofs
= byte_get (descdata
, addr_size
);
16368 descdata
+= addr_size
;
16371 print_vma (start
, FULL_HEX
);
16373 print_vma (end
, FULL_HEX
);
16375 print_vma (file_ofs
, FULL_HEX
);
16376 printf ("\n %s\n", filenames
);
16378 filenames
+= 1 + strlen ((char *) filenames
);
16384 static const char *
16385 get_gnu_elf_note_type (unsigned e_type
)
16387 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
16390 case NT_GNU_ABI_TAG
:
16391 return _("NT_GNU_ABI_TAG (ABI version tag)");
16393 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16394 case NT_GNU_BUILD_ID
:
16395 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16396 case NT_GNU_GOLD_VERSION
:
16397 return _("NT_GNU_GOLD_VERSION (gold version)");
16398 case NT_GNU_PROPERTY_TYPE_0
:
16399 return _("NT_GNU_PROPERTY_TYPE_0");
16400 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16401 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16402 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16403 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16406 static char buff
[64];
16408 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16415 decode_x86_isa (unsigned int bitmask
)
16419 unsigned int bit
= bitmask
& (- bitmask
);
16424 case GNU_PROPERTY_X86_ISA_1_486
: printf ("i486"); break;
16425 case GNU_PROPERTY_X86_ISA_1_586
: printf ("586"); break;
16426 case GNU_PROPERTY_X86_ISA_1_686
: printf ("686"); break;
16427 case GNU_PROPERTY_X86_ISA_1_SSE
: printf ("SSE"); break;
16428 case GNU_PROPERTY_X86_ISA_1_SSE2
: printf ("SSE2"); break;
16429 case GNU_PROPERTY_X86_ISA_1_SSE3
: printf ("SSE3"); break;
16430 case GNU_PROPERTY_X86_ISA_1_SSSE3
: printf ("SSSE3"); break;
16431 case GNU_PROPERTY_X86_ISA_1_SSE4_1
: printf ("SSE4_1"); break;
16432 case GNU_PROPERTY_X86_ISA_1_SSE4_2
: printf ("SSE4_2"); break;
16433 case GNU_PROPERTY_X86_ISA_1_AVX
: printf ("AVX"); break;
16434 case GNU_PROPERTY_X86_ISA_1_AVX2
: printf ("AVX2"); break;
16435 case GNU_PROPERTY_X86_ISA_1_AVX512F
: printf ("AVX512F"); break;
16436 case GNU_PROPERTY_X86_ISA_1_AVX512CD
: printf ("AVX512CD"); break;
16437 case GNU_PROPERTY_X86_ISA_1_AVX512ER
: printf ("AVX512ER"); break;
16438 case GNU_PROPERTY_X86_ISA_1_AVX512PF
: printf ("AVX512PF"); break;
16439 case GNU_PROPERTY_X86_ISA_1_AVX512VL
: printf ("AVX512VL"); break;
16440 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
: printf ("AVX512DQ"); break;
16441 case GNU_PROPERTY_X86_ISA_1_AVX512BW
: printf ("AVX512BW"); break;
16442 default: printf (_("<unknown: %x>"), bit
); break;
16450 decode_x86_feature (unsigned int type
, unsigned int bitmask
)
16454 unsigned int bit
= bitmask
& (- bitmask
);
16459 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
16462 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16466 /* This should never happen. */
16470 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
16473 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16477 /* This should never happen. */
16482 printf (_("<unknown: %x>"), bit
);
16491 print_gnu_property_note (Elf_Internal_Note
* pnote
)
16493 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
16494 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
16495 unsigned int size
= is_32bit_elf
? 4 : 8;
16497 printf (_(" Properties: "));
16499 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
16501 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
16508 unsigned int type
= byte_get (ptr
, 4);
16509 unsigned int datasz
= byte_get (ptr
+ 4, 4);
16513 if ((ptr
+ datasz
) > ptr_end
)
16515 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16520 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
16522 if (elf_header
.e_machine
== EM_X86_64
16523 || elf_header
.e_machine
== EM_IAMCU
16524 || elf_header
.e_machine
== EM_386
)
16528 case GNU_PROPERTY_X86_ISA_1_USED
:
16529 printf ("x86 ISA used: ");
16531 printf (_("<corrupt length: %#x> "), datasz
);
16533 decode_x86_isa (byte_get (ptr
, 4));
16536 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
16537 printf ("x86 ISA needed: ");
16539 printf (_("<corrupt length: %#x> "), datasz
);
16541 decode_x86_isa (byte_get (ptr
, 4));
16544 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16545 printf ("x86 feature: ");
16547 printf (_("<corrupt length: %#x> "), datasz
);
16549 decode_x86_feature (type
, byte_get (ptr
, 4));
16561 case GNU_PROPERTY_STACK_SIZE
:
16562 printf (_("stack size: "));
16563 if (datasz
!= size
)
16564 printf (_("<corrupt length: %#x> "), datasz
);
16566 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
16569 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
16570 printf ("no copy on protected ");
16572 printf (_("<corrupt length: %#x> "), datasz
);
16580 if (type
< GNU_PROPERTY_LOPROC
)
16581 printf (_("<unknown type %#x data: "), type
);
16582 else if (type
< GNU_PROPERTY_LOUSER
)
16583 printf (_("<procesor-specific type %#x data: "), type
);
16585 printf (_("<application-specific type %#x data: "), type
);
16586 for (j
= 0; j
< datasz
; ++j
)
16587 printf ("%02x ", ptr
[j
] & 0xff);
16591 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
16592 if (ptr
== ptr_end
)
16602 if (ptr
> (ptr_end
- 8))
16604 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
16613 print_gnu_note (Elf_Internal_Note
*pnote
)
16615 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
16616 switch (pnote
->type
)
16618 case NT_GNU_BUILD_ID
:
16622 printf (_(" Build ID: "));
16623 for (i
= 0; i
< pnote
->descsz
; ++i
)
16624 printf ("%02x", pnote
->descdata
[i
] & 0xff);
16629 case NT_GNU_ABI_TAG
:
16631 unsigned long os
, major
, minor
, subminor
;
16632 const char *osname
;
16634 /* PR 17531: file: 030-599401-0.004. */
16635 if (pnote
->descsz
< 16)
16637 printf (_(" <corrupt GNU_ABI_TAG>\n"));
16641 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
16642 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
16643 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
16644 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
16648 case GNU_ABI_TAG_LINUX
:
16651 case GNU_ABI_TAG_HURD
:
16654 case GNU_ABI_TAG_SOLARIS
:
16655 osname
= "Solaris";
16657 case GNU_ABI_TAG_FREEBSD
:
16658 osname
= "FreeBSD";
16660 case GNU_ABI_TAG_NETBSD
:
16663 case GNU_ABI_TAG_SYLLABLE
:
16664 osname
= "Syllable";
16666 case GNU_ABI_TAG_NACL
:
16670 osname
= "Unknown";
16674 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
16675 major
, minor
, subminor
);
16679 case NT_GNU_GOLD_VERSION
:
16683 printf (_(" Version: "));
16684 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
16685 printf ("%c", pnote
->descdata
[i
]);
16692 unsigned long num_entries
, mask
;
16694 /* Hardware capabilities information. Word 0 is the number of entries.
16695 Word 1 is a bitmask of enabled entries. The rest of the descriptor
16696 is a series of entries, where each entry is a single byte followed
16697 by a nul terminated string. The byte gives the bit number to test
16698 if enabled in the bitmask. */
16699 printf (_(" Hardware Capabilities: "));
16700 if (pnote
->descsz
< 8)
16702 error (_("<corrupt GNU_HWCAP>\n"));
16705 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
16706 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
16707 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
16708 /* FIXME: Add code to display the entries... */
16712 case NT_GNU_PROPERTY_TYPE_0
:
16713 print_gnu_property_note (pnote
);
16717 /* Handle unrecognised types. An error message should have already been
16718 created by get_gnu_elf_note_type(), so all that we need to do is to
16719 display the data. */
16723 printf (_(" Description data: "));
16724 for (i
= 0; i
< pnote
->descsz
; ++i
)
16725 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
16734 static const char *
16735 get_v850_elf_note_type (enum v850_notes n_type
)
16737 static char buff
[64];
16741 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
16742 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
16743 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
16744 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
16745 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
16746 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
16748 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
16754 print_v850_note (Elf_Internal_Note
* pnote
)
16758 if (pnote
->descsz
!= 4)
16761 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
16765 printf (_("not set\n"));
16769 switch (pnote
->type
)
16771 case V850_NOTE_ALIGNMENT
:
16774 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
16775 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
16779 case V850_NOTE_DATA_SIZE
:
16782 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
16783 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
16787 case V850_NOTE_FPU_INFO
:
16790 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
16791 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
16795 case V850_NOTE_MMU_INFO
:
16796 case V850_NOTE_CACHE_INFO
:
16797 case V850_NOTE_SIMD_INFO
:
16798 if (val
== EF_RH850_SIMD
)
16800 printf (_("yes\n"));
16806 /* An 'unknown note type' message will already have been displayed. */
16810 printf (_("unknown value: %x\n"), val
);
16815 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
16817 unsigned int version
;
16819 switch (pnote
->type
)
16821 case NT_NETBSD_IDENT
:
16822 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
16823 if ((version
/ 10000) % 100)
16824 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
16825 version
, version
/ 100000000, (version
/ 1000000) % 100,
16826 (version
/ 10000) % 100 > 26 ? "Z" : "",
16827 'A' + (version
/ 10000) % 26);
16829 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
16830 version
, version
/ 100000000, (version
/ 1000000) % 100,
16831 (version
/ 100) % 100);
16834 case NT_NETBSD_MARCH
:
16835 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
16840 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
16846 static const char *
16847 get_freebsd_elfcore_note_type (unsigned e_type
)
16851 case NT_FREEBSD_THRMISC
:
16852 return _("NT_THRMISC (thrmisc structure)");
16853 case NT_FREEBSD_PROCSTAT_PROC
:
16854 return _("NT_PROCSTAT_PROC (proc data)");
16855 case NT_FREEBSD_PROCSTAT_FILES
:
16856 return _("NT_PROCSTAT_FILES (files data)");
16857 case NT_FREEBSD_PROCSTAT_VMMAP
:
16858 return _("NT_PROCSTAT_VMMAP (vmmap data)");
16859 case NT_FREEBSD_PROCSTAT_GROUPS
:
16860 return _("NT_PROCSTAT_GROUPS (groups data)");
16861 case NT_FREEBSD_PROCSTAT_UMASK
:
16862 return _("NT_PROCSTAT_UMASK (umask data)");
16863 case NT_FREEBSD_PROCSTAT_RLIMIT
:
16864 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
16865 case NT_FREEBSD_PROCSTAT_OSREL
:
16866 return _("NT_PROCSTAT_OSREL (osreldate data)");
16867 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
16868 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
16869 case NT_FREEBSD_PROCSTAT_AUXV
:
16870 return _("NT_PROCSTAT_AUXV (auxv data)");
16871 case NT_FREEBSD_PTLWPINFO
:
16872 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
16874 return get_note_type (e_type
);
16877 static const char *
16878 get_netbsd_elfcore_note_type (unsigned e_type
)
16880 static char buff
[64];
16882 if (e_type
== NT_NETBSDCORE_PROCINFO
)
16884 /* NetBSD core "procinfo" structure. */
16885 return _("NetBSD procinfo structure");
16888 /* As of Jan 2002 there are no other machine-independent notes
16889 defined for NetBSD core files. If the note type is less
16890 than the start of the machine-dependent note types, we don't
16893 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
16895 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16899 switch (elf_header
.e_machine
)
16901 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
16902 and PT_GETFPREGS == mach+2. */
16907 case EM_SPARC32PLUS
:
16911 case NT_NETBSDCORE_FIRSTMACH
+ 0:
16912 return _("PT_GETREGS (reg structure)");
16913 case NT_NETBSDCORE_FIRSTMACH
+ 2:
16914 return _("PT_GETFPREGS (fpreg structure)");
16920 /* On all other arch's, PT_GETREGS == mach+1 and
16921 PT_GETFPREGS == mach+3. */
16925 case NT_NETBSDCORE_FIRSTMACH
+ 1:
16926 return _("PT_GETREGS (reg structure)");
16927 case NT_NETBSDCORE_FIRSTMACH
+ 3:
16928 return _("PT_GETFPREGS (fpreg structure)");
16934 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
16935 e_type
- NT_NETBSDCORE_FIRSTMACH
);
16939 static const char *
16940 get_stapsdt_note_type (unsigned e_type
)
16942 static char buff
[64];
16947 return _("NT_STAPSDT (SystemTap probe descriptors)");
16953 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16958 print_stapsdt_note (Elf_Internal_Note
*pnote
)
16960 int addr_size
= is_32bit_elf
? 4 : 8;
16961 char *data
= pnote
->descdata
;
16962 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
16963 bfd_vma pc
, base_addr
, semaphore
;
16964 char *provider
, *probe
, *arg_fmt
;
16966 pc
= byte_get ((unsigned char *) data
, addr_size
);
16968 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
16970 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
16974 data
+= strlen (data
) + 1;
16976 data
+= strlen (data
) + 1;
16978 data
+= strlen (data
) + 1;
16980 printf (_(" Provider: %s\n"), provider
);
16981 printf (_(" Name: %s\n"), probe
);
16982 printf (_(" Location: "));
16983 print_vma (pc
, FULL_HEX
);
16984 printf (_(", Base: "));
16985 print_vma (base_addr
, FULL_HEX
);
16986 printf (_(", Semaphore: "));
16987 print_vma (semaphore
, FULL_HEX
);
16989 printf (_(" Arguments: %s\n"), arg_fmt
);
16991 return data
== data_end
;
16994 static const char *
16995 get_ia64_vms_note_type (unsigned e_type
)
16997 static char buff
[64];
17002 return _("NT_VMS_MHD (module header)");
17004 return _("NT_VMS_LNM (language name)");
17006 return _("NT_VMS_SRC (source files)");
17008 return "NT_VMS_TITLE";
17010 return _("NT_VMS_EIDC (consistency check)");
17011 case NT_VMS_FPMODE
:
17012 return _("NT_VMS_FPMODE (FP mode)");
17013 case NT_VMS_LINKTIME
:
17014 return "NT_VMS_LINKTIME";
17015 case NT_VMS_IMGNAM
:
17016 return _("NT_VMS_IMGNAM (image name)");
17018 return _("NT_VMS_IMGID (image id)");
17019 case NT_VMS_LINKID
:
17020 return _("NT_VMS_LINKID (link id)");
17021 case NT_VMS_IMGBID
:
17022 return _("NT_VMS_IMGBID (build id)");
17023 case NT_VMS_GSTNAM
:
17024 return _("NT_VMS_GSTNAM (sym table name)");
17025 case NT_VMS_ORIG_DYN
:
17026 return "NT_VMS_ORIG_DYN";
17027 case NT_VMS_PATCHTIME
:
17028 return "NT_VMS_PATCHTIME";
17030 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17036 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
17038 switch (pnote
->type
)
17041 if (pnote
->descsz
> 36)
17043 size_t l
= strlen (pnote
->descdata
+ 34);
17044 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
17045 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
17046 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
17047 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
17050 printf (_(" Invalid size\n"));
17053 printf (_(" Language: %s\n"), pnote
->descdata
);
17056 case NT_VMS_FPMODE
:
17057 printf (_(" Floating Point mode: "));
17058 printf ("0x%016" BFD_VMA_FMT
"x\n",
17059 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17061 case NT_VMS_LINKTIME
:
17062 printf (_(" Link time: "));
17064 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17067 case NT_VMS_PATCHTIME
:
17068 printf (_(" Patch time: "));
17070 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17073 case NT_VMS_ORIG_DYN
:
17074 printf (_(" Major id: %u, minor id: %u\n"),
17075 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
17076 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
17077 printf (_(" Last modified : "));
17079 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
17080 printf (_("\n Link flags : "));
17081 printf ("0x%016" BFD_VMA_FMT
"x\n",
17082 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
17083 printf (_(" Header flags: 0x%08x\n"),
17084 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
17085 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
17088 case NT_VMS_IMGNAM
:
17089 printf (_(" Image name: %s\n"), pnote
->descdata
);
17091 case NT_VMS_GSTNAM
:
17092 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
17095 printf (_(" Image id: %s\n"), pnote
->descdata
);
17097 case NT_VMS_LINKID
:
17098 printf (_(" Linker id: %s\n"), pnote
->descdata
);
17106 /* Print the name of the symbol associated with a build attribute
17107 that is attached to address OFFSET. */
17110 print_symbol_for_build_attribute (FILE * file
,
17111 unsigned long offset
,
17112 bfd_boolean is_open_attr
)
17114 static FILE * saved_file
= NULL
;
17115 static char * strtab
;
17116 static unsigned long strtablen
;
17117 static Elf_Internal_Sym
* symtab
;
17118 static unsigned long nsyms
;
17119 Elf_Internal_Sym
* saved_sym
= NULL
;
17120 Elf_Internal_Sym
* sym
;
17122 if (section_headers
!= NULL
17123 && (saved_file
== NULL
|| file
!= saved_file
))
17125 Elf_Internal_Shdr
* symsec
;
17127 /* Load the symbol and string sections. */
17128 for (symsec
= section_headers
;
17129 symsec
< section_headers
+ elf_header
.e_shnum
;
17132 if (symsec
->sh_type
== SHT_SYMTAB
)
17134 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
17136 if (symsec
->sh_link
< elf_header
.e_shnum
)
17138 Elf_Internal_Shdr
* strtab_sec
= section_headers
+ symsec
->sh_link
;
17140 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
17141 1, strtab_sec
->sh_size
,
17142 _("string table"));
17143 strtablen
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
17150 if (symtab
== NULL
|| strtab
== NULL
)
17156 /* Find a symbol whose value matches offset. */
17157 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
17158 if (sym
->st_value
== offset
)
17160 if (sym
->st_name
>= strtablen
)
17161 /* Huh ? This should not happen. */
17164 if (strtab
[sym
->st_name
] == 0)
17169 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17170 and FILE or OBJECT symbols over NOTYPE symbols. We skip
17171 FUNC symbols entirely. */
17172 switch (ELF_ST_TYPE (sym
->st_info
))
17176 /* We can stop searching now. */
17177 sym
= symtab
+ nsyms
;
17185 /* Ignore function symbols. */
17192 switch (ELF_ST_BIND (sym
->st_info
))
17195 if (saved_sym
== NULL
17196 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
17201 if (saved_sym
== NULL
)
17211 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
17219 printf (" (%s: %s)\n",
17220 is_open_attr
? _("file") : _("func"),
17221 saved_sym
? strtab
+ saved_sym
->st_name
: _("<no symbol found>)"));
17226 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
17229 static unsigned long global_offset
= 0;
17230 unsigned long offset
;
17231 unsigned int desc_size
= is_32bit_elf
? 4 : 8;
17232 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
17234 if (pnote
->descsz
== 0)
17238 printf (_(" Applies from offset %#lx\n"), global_offset
);
17243 printf (_(" Applies to func at %#lx"), global_offset
);
17244 return print_symbol_for_build_attribute (file
, global_offset
, is_open_attr
);
17248 if (pnote
->descsz
!= desc_size
)
17250 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
17251 printf (_(" <invalid descsz>"));
17255 offset
= byte_get ((unsigned char *) pnote
->descdata
, desc_size
);
17259 printf (_(" Applies from offset %#lx"), offset
);
17260 global_offset
= offset
;
17264 printf (_(" Applies to func at %#lx"), offset
);
17267 return print_symbol_for_build_attribute (file
, offset
, is_open_attr
);
17271 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
17273 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
17274 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
17275 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
17277 char name_attribute
;
17278 const char * expected_types
;
17279 const char * name
= pnote
->namedata
;
17283 if (name
== NULL
|| pnote
->namesz
< 2)
17285 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
17286 print_symbol (-20, _(" <corrupt name>"));
17292 /* Version 2 of the spec adds a "GA" prefix to the name field. */
17293 if (name
[0] == 'G' && name
[1] == 'A')
17300 switch ((name_type
= * name
))
17302 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
17303 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
17304 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
17305 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
17306 printf ("%c", * name
);
17310 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
17311 print_symbol (-20, _("<unknown name type>"));
17318 switch ((name_attribute
= * name
))
17320 case GNU_BUILD_ATTRIBUTE_VERSION
:
17321 text
= _("<version>");
17322 expected_types
= string_expected
;
17325 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
17326 text
= _("<stack prot>");
17327 expected_types
= "!+*";
17330 case GNU_BUILD_ATTRIBUTE_RELRO
:
17331 text
= _("<relro>");
17332 expected_types
= bool_expected
;
17335 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
17336 text
= _("<stack size>");
17337 expected_types
= number_expected
;
17340 case GNU_BUILD_ATTRIBUTE_TOOL
:
17341 text
= _("<tool>");
17342 expected_types
= string_expected
;
17345 case GNU_BUILD_ATTRIBUTE_ABI
:
17347 expected_types
= "$*";
17350 case GNU_BUILD_ATTRIBUTE_PIC
:
17352 expected_types
= number_expected
;
17355 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
17356 text
= _("<short enum>");
17357 expected_types
= bool_expected
;
17361 if (ISPRINT (* name
))
17363 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
17365 if (len
> left
&& ! do_wide
)
17367 printf ("%.*s:", len
, name
);
17373 static char tmpbuf
[128];
17375 error (_("unrecognised byte in name field: %d\n"), * name
);
17376 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
17380 expected_types
= "*$!+";
17385 left
-= printf ("%s", text
);
17387 if (strchr (expected_types
, name_type
) == NULL
)
17388 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
17390 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
17392 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17393 (unsigned long) pnote
->namesz
,
17394 (long) (name
- pnote
->namedata
));
17398 if (left
< 1 && ! do_wide
)
17403 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
17405 unsigned int bytes
;
17406 unsigned long long val
= 0;
17407 unsigned int shift
= 0;
17408 char * decoded
= NULL
;
17410 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
17412 /* The -1 is because the name field is always 0 terminated, and we
17413 want to be able to ensure that the shift in the while loop below
17414 will not overflow. */
17417 if (bytes
> sizeof (val
))
17419 fprintf (stderr
, "namesz %lx name %p namedata %p\n",
17420 pnote
->namesz
, name
, pnote
->namedata
);
17421 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
17423 bytes
= sizeof (val
);
17425 /* We do not bother to warn if bytes == 0 as this can
17426 happen with some early versions of the gcc plugin. */
17430 unsigned long byte
= (* name
++) & 0xff;
17432 val
|= byte
<< shift
;
17436 switch (name_attribute
)
17438 case GNU_BUILD_ATTRIBUTE_PIC
:
17441 case 0: decoded
= "static"; break;
17442 case 1: decoded
= "pic"; break;
17443 case 2: decoded
= "PIC"; break;
17444 case 3: decoded
= "pie"; break;
17445 case 4: decoded
= "PIE"; break;
17449 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
17452 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
17453 case 0: decoded
= "off"; break;
17454 case 1: decoded
= "on"; break;
17455 case 2: decoded
= "all"; break;
17456 case 3: decoded
= "strong"; break;
17457 case 4: decoded
= "explicit"; break;
17465 if (decoded
!= NULL
)
17467 print_symbol (-left
, decoded
);
17478 left
-= printf ("0x%llx", val
);
17480 left
-= printf ("0x%-.*llx", left
, val
);
17484 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
17485 left
-= print_symbol (- left
, name
);
17487 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
17488 left
-= print_symbol (- left
, "true");
17490 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
17491 left
-= print_symbol (- left
, "false");
17495 if (do_wide
&& left
> 0)
17496 printf ("%-*s", left
, " ");
17501 /* Note that by the ELF standard, the name field is already null byte
17502 terminated, and namesz includes the terminating null byte.
17503 I.E. the value of namesz for the name "FSF" is 4.
17505 If the value of namesz is zero, there is no name present. */
17508 process_note (Elf_Internal_Note
* pnote
,
17511 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
17514 if (pnote
->namesz
== 0)
17515 /* If there is no note name, then use the default set of
17516 note type strings. */
17517 nt
= get_note_type (pnote
->type
);
17519 else if (const_strneq (pnote
->namedata
, "GNU"))
17520 /* GNU-specific object file notes. */
17521 nt
= get_gnu_elf_note_type (pnote
->type
);
17523 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
17524 /* FreeBSD-specific core file notes. */
17525 nt
= get_freebsd_elfcore_note_type (pnote
->type
);
17527 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
17528 /* NetBSD-specific core file notes. */
17529 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
17531 else if (const_strneq (pnote
->namedata
, "NetBSD"))
17532 /* NetBSD-specific core file notes. */
17533 return process_netbsd_elf_note (pnote
);
17535 else if (strneq (pnote
->namedata
, "SPU/", 4))
17537 /* SPU-specific core file notes. */
17538 nt
= pnote
->namedata
+ 4;
17542 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
17543 /* VMS/ia64-specific file notes. */
17544 nt
= get_ia64_vms_note_type (pnote
->type
);
17546 else if (const_strneq (pnote
->namedata
, "stapsdt"))
17547 nt
= get_stapsdt_note_type (pnote
->type
);
17550 /* Don't recognize this note name; just use the default set of
17551 note type strings. */
17552 nt
= get_note_type (pnote
->type
);
17556 if (((const_strneq (pnote
->namedata
, "GA")
17557 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
17558 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
17559 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
17560 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
17561 print_gnu_build_attribute_name (pnote
);
17563 print_symbol (-20, name
);
17566 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
17568 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
17570 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
17571 return print_ia64_vms_note (pnote
);
17572 else if (const_strneq (pnote
->namedata
, "GNU"))
17573 return print_gnu_note (pnote
);
17574 else if (const_strneq (pnote
->namedata
, "stapsdt"))
17575 return print_stapsdt_note (pnote
);
17576 else if (const_strneq (pnote
->namedata
, "CORE"))
17577 return print_core_note (pnote
);
17578 else if (((const_strneq (pnote
->namedata
, "GA")
17579 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
17580 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
17581 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
17582 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
17583 return print_gnu_build_attribute_description (pnote
, file
);
17589 printf (_(" description data: "));
17590 for (i
= 0; i
< pnote
->descsz
; i
++)
17591 printf ("%02x ", pnote
->descdata
[i
]);
17603 process_notes_at (FILE * file
,
17604 Elf_Internal_Shdr
* section
,
17608 Elf_External_Note
* pnotes
;
17609 Elf_External_Note
* external
;
17611 bfd_boolean res
= TRUE
;
17618 pnotes
= (Elf_External_Note
*) get_section_contents (section
, file
);
17621 if (! apply_relocations (file
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
17626 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
17628 if (pnotes
== NULL
)
17634 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section
));
17636 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
17637 (unsigned long) offset
, (unsigned long) length
);
17639 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
17641 end
= (char *) pnotes
+ length
;
17642 while ((char *) external
< end
)
17644 Elf_Internal_Note inote
;
17647 char * temp
= NULL
;
17648 size_t data_remaining
= end
- (char *) external
;
17650 if (!is_ia64_vms ())
17652 /* PR binutils/15191
17653 Make sure that there is enough data to read. */
17654 min_notesz
= offsetof (Elf_External_Note
, name
);
17655 if (data_remaining
< min_notesz
)
17657 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17658 (int) data_remaining
);
17661 inote
.type
= BYTE_GET (external
->type
);
17662 inote
.namesz
= BYTE_GET (external
->namesz
);
17663 inote
.namedata
= external
->name
;
17664 inote
.descsz
= BYTE_GET (external
->descsz
);
17665 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
17666 /* PR 17531: file: 3443835e. */
17667 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
> end
)
17669 warn (_("Corrupt note: name size is too big: (got: %lx, expected no more than: %lx)\n"),
17670 inote
.namesz
, (long)(end
- inote
.namedata
));
17671 inote
.descdata
= inote
.namedata
;
17675 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17676 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
17680 Elf64_External_VMS_Note
*vms_external
;
17682 /* PR binutils/15191
17683 Make sure that there is enough data to read. */
17684 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
17685 if (data_remaining
< min_notesz
)
17687 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17688 (int) data_remaining
);
17692 vms_external
= (Elf64_External_VMS_Note
*) external
;
17693 inote
.type
= BYTE_GET (vms_external
->type
);
17694 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
17695 inote
.namedata
= vms_external
->name
;
17696 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
17697 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
17698 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17699 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
17702 if (inote
.descdata
< (char *) external
+ min_notesz
17703 || next
< (char *) external
+ min_notesz
17704 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
17705 || inote
.namedata
+ inote
.namesz
< inote
.namedata
17706 || inote
.descdata
+ inote
.descsz
< inote
.descdata
17707 || data_remaining
< (size_t)(next
- (char *) external
))
17709 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
17710 (unsigned long) ((char *) external
- (char *) pnotes
));
17711 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
17712 inote
.type
, inote
.namesz
, inote
.descsz
);
17716 external
= (Elf_External_Note
*) next
;
17718 /* Verify that name is null terminated. It appears that at least
17719 one version of Linux (RedHat 6.0) generates corefiles that don't
17720 comply with the ELF spec by failing to include the null byte in
17722 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
17724 temp
= (char *) malloc (inote
.namesz
+ 1);
17727 error (_("Out of memory allocating space for inote name\n"));
17732 memcpy (temp
, inote
.namedata
, inote
.namesz
);
17733 temp
[inote
.namesz
] = 0;
17735 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
17736 inote
.namedata
= temp
;
17739 if (! process_note (& inote
, file
))
17755 process_corefile_note_segments (FILE * file
)
17757 Elf_Internal_Phdr
* segment
;
17759 bfd_boolean res
= TRUE
;
17761 if (! get_program_headers (file
))
17764 for (i
= 0, segment
= program_headers
;
17765 i
< elf_header
.e_phnum
;
17768 if (segment
->p_type
== PT_NOTE
)
17769 if (! process_notes_at (file
, NULL
,
17770 (bfd_vma
) segment
->p_offset
,
17771 (bfd_vma
) segment
->p_filesz
))
17779 process_v850_notes (FILE * file
, bfd_vma offset
, bfd_vma length
)
17781 Elf_External_Note
* pnotes
;
17782 Elf_External_Note
* external
;
17784 bfd_boolean res
= TRUE
;
17789 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
17791 if (pnotes
== NULL
)
17795 end
= (char*) pnotes
+ length
;
17797 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
17798 (unsigned long) offset
, (unsigned long) length
);
17800 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
17802 Elf_External_Note
* next
;
17803 Elf_Internal_Note inote
;
17805 inote
.type
= BYTE_GET (external
->type
);
17806 inote
.namesz
= BYTE_GET (external
->namesz
);
17807 inote
.namedata
= external
->name
;
17808 inote
.descsz
= BYTE_GET (external
->descsz
);
17809 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
17810 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17812 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
17814 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
17815 inote
.descdata
= inote
.namedata
;
17819 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
17821 if ( ((char *) next
> end
)
17822 || ((char *) next
< (char *) pnotes
))
17824 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
17825 (unsigned long) ((char *) external
- (char *) pnotes
));
17826 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17827 inote
.type
, inote
.namesz
, inote
.descsz
);
17833 /* Prevent out-of-bounds indexing. */
17834 if ( inote
.namedata
+ inote
.namesz
> end
17835 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
17837 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
17838 (unsigned long) ((char *) external
- (char *) pnotes
));
17839 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17840 inote
.type
, inote
.namesz
, inote
.descsz
);
17844 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
17846 if (! print_v850_note (& inote
))
17849 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
17850 inote
.namesz
, inote
.descsz
);
17860 process_note_sections (FILE * file
)
17862 Elf_Internal_Shdr
* section
;
17864 unsigned int n
= 0;
17865 bfd_boolean res
= TRUE
;
17867 for (i
= 0, section
= section_headers
;
17868 i
< elf_header
.e_shnum
&& section
!= NULL
;
17871 if (section
->sh_type
== SHT_NOTE
)
17873 if (! process_notes_at (file
, section
,
17874 (bfd_vma
) section
->sh_offset
,
17875 (bfd_vma
) section
->sh_size
))
17880 if (( elf_header
.e_machine
== EM_V800
17881 || elf_header
.e_machine
== EM_V850
17882 || elf_header
.e_machine
== EM_CYGNUS_V850
)
17883 && section
->sh_type
== SHT_RENESAS_INFO
)
17885 if (! process_v850_notes (file
,
17886 (bfd_vma
) section
->sh_offset
,
17887 (bfd_vma
) section
->sh_size
))
17894 /* Try processing NOTE segments instead. */
17895 return process_corefile_note_segments (file
);
17901 process_notes (FILE * file
)
17903 /* If we have not been asked to display the notes then do nothing. */
17907 if (elf_header
.e_type
!= ET_CORE
)
17908 return process_note_sections (file
);
17910 /* No program headers means no NOTE segment. */
17911 if (elf_header
.e_phnum
> 0)
17912 return process_corefile_note_segments (file
);
17914 printf (_("No note segments present in the core file.\n"));
17918 static unsigned char *
17919 display_public_gnu_attributes (unsigned char * start
,
17920 const unsigned char * const end
)
17922 printf (_(" Unknown GNU attribute: %s\n"), start
);
17924 start
+= strnlen ((char *) start
, end
- start
);
17925 display_raw_attribute (start
, end
);
17927 return (unsigned char *) end
;
17930 static unsigned char *
17931 display_generic_attribute (unsigned char * start
,
17933 const unsigned char * const end
)
17936 return (unsigned char *) end
;
17938 return display_tag_value (tag
, start
, end
);
17942 process_arch_specific (FILE * file
)
17947 switch (elf_header
.e_machine
)
17950 case EM_ARC_COMPACT
:
17951 case EM_ARC_COMPACT2
:
17952 return process_attributes (file
, "ARC", SHT_ARC_ATTRIBUTES
,
17953 display_arc_attribute
,
17954 display_generic_attribute
);
17956 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
17957 display_arm_attribute
,
17958 display_generic_attribute
);
17961 case EM_MIPS_RS3_LE
:
17962 return process_mips_specific (file
);
17965 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
17966 display_msp430x_attribute
,
17967 display_generic_attribute
);
17970 return process_nds32_specific (file
);
17974 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17975 display_power_gnu_attribute
);
17979 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17980 display_s390_gnu_attribute
);
17983 case EM_SPARC32PLUS
:
17985 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17986 display_sparc_gnu_attribute
);
17989 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
17990 display_tic6x_attribute
,
17991 display_generic_attribute
);
17994 return process_attributes (file
, "gnu", SHT_GNU_ATTRIBUTES
,
17995 display_public_gnu_attributes
,
17996 display_generic_attribute
);
18001 get_file_header (FILE * file
)
18003 /* Read in the identity array. */
18004 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
18007 /* Determine how to read the rest of the header. */
18008 switch (elf_header
.e_ident
[EI_DATA
])
18013 byte_get
= byte_get_little_endian
;
18014 byte_put
= byte_put_little_endian
;
18017 byte_get
= byte_get_big_endian
;
18018 byte_put
= byte_put_big_endian
;
18022 /* For now we only support 32 bit and 64 bit ELF files. */
18023 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
18025 /* Read in the rest of the header. */
18028 Elf32_External_Ehdr ehdr32
;
18030 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
18033 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
18034 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
18035 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
18036 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
18037 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
18038 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
18039 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
18040 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
18041 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
18042 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
18043 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
18044 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
18045 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
18049 Elf64_External_Ehdr ehdr64
;
18051 /* If we have been compiled with sizeof (bfd_vma) == 4, then
18052 we will not be able to cope with the 64bit data found in
18053 64 ELF files. Detect this now and abort before we start
18054 overwriting things. */
18055 if (sizeof (bfd_vma
) < 8)
18057 error (_("This instance of readelf has been built without support for a\n\
18058 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18062 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
18065 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
18066 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
18067 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
18068 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
18069 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
18070 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
18071 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
18072 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
18073 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
18074 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
18075 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
18076 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
18077 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
18080 if (elf_header
.e_shoff
)
18082 /* There may be some extensions in the first section header. Don't
18083 bomb if we can't read it. */
18085 get_32bit_section_headers (file
, TRUE
);
18087 get_64bit_section_headers (file
, TRUE
);
18093 /* Process one ELF object file according to the command line options.
18094 This file may actually be stored in an archive. The file is
18095 positioned at the start of the ELF object. Returns TRUE if no
18096 problems were encountered, FALSE otherwise. */
18099 process_object (char * file_name
, FILE * file
)
18102 bfd_boolean res
= TRUE
;
18104 if (! get_file_header (file
))
18106 error (_("%s: Failed to read file header\n"), file_name
);
18110 /* Initialise per file variables. */
18111 for (i
= ARRAY_SIZE (version_info
); i
--;)
18112 version_info
[i
] = 0;
18114 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
18115 dynamic_info
[i
] = 0;
18116 dynamic_info_DT_GNU_HASH
= 0;
18118 /* Process the file. */
18120 printf (_("\nFile: %s\n"), file_name
);
18122 /* Initialise the dump_sects array from the cmdline_dump_sects array.
18123 Note we do this even if cmdline_dump_sects is empty because we
18124 must make sure that the dump_sets array is zeroed out before each
18125 object file is processed. */
18126 if (num_dump_sects
> num_cmdline_dump_sects
)
18127 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
18129 if (num_cmdline_dump_sects
> 0)
18131 if (num_dump_sects
== 0)
18132 /* A sneaky way of allocating the dump_sects array. */
18133 request_dump_bynumber (num_cmdline_dump_sects
, 0);
18135 assert (num_dump_sects
>= num_cmdline_dump_sects
);
18136 memcpy (dump_sects
, cmdline_dump_sects
,
18137 num_cmdline_dump_sects
* sizeof (* dump_sects
));
18140 if (! process_file_header ())
18143 if (! process_section_headers (file
))
18145 /* Without loaded section headers we cannot process lots of things. */
18146 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
18148 if (! do_using_dynamic
)
18149 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
18152 if (! process_section_groups (file
))
18153 /* Without loaded section groups we cannot process unwind. */
18156 if (process_program_headers (file
))
18157 process_dynamic_section (file
);
18161 if (! process_relocs (file
))
18164 if (! process_unwind (file
))
18167 if (! process_symbol_table (file
))
18170 if (! process_syminfo (file
))
18173 if (! process_version_sections (file
))
18176 if (! process_section_contents (file
))
18179 if (! process_notes (file
))
18182 if (! process_gnu_liblist (file
))
18185 if (! process_arch_specific (file
))
18188 if (program_headers
)
18190 free (program_headers
);
18191 program_headers
= NULL
;
18194 if (section_headers
)
18196 free (section_headers
);
18197 section_headers
= NULL
;
18202 free (string_table
);
18203 string_table
= NULL
;
18204 string_table_length
= 0;
18207 if (dynamic_strings
)
18209 free (dynamic_strings
);
18210 dynamic_strings
= NULL
;
18211 dynamic_strings_length
= 0;
18214 if (dynamic_symbols
)
18216 free (dynamic_symbols
);
18217 dynamic_symbols
= NULL
;
18218 num_dynamic_syms
= 0;
18221 if (dynamic_syminfo
)
18223 free (dynamic_syminfo
);
18224 dynamic_syminfo
= NULL
;
18227 if (dynamic_section
)
18229 free (dynamic_section
);
18230 dynamic_section
= NULL
;
18233 if (section_headers_groups
)
18235 free (section_headers_groups
);
18236 section_headers_groups
= NULL
;
18239 if (section_groups
)
18241 struct group_list
* g
;
18242 struct group_list
* next
;
18244 for (i
= 0; i
< group_count
; i
++)
18246 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
18253 free (section_groups
);
18254 section_groups
= NULL
;
18257 free_debug_memory ();
18262 /* Process an ELF archive.
18263 On entry the file is positioned just after the ARMAG string.
18264 Returns TRUE upon success, FALSE otherwise. */
18267 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
18269 struct archive_info arch
;
18270 struct archive_info nested_arch
;
18272 bfd_boolean ret
= TRUE
;
18276 /* The ARCH structure is used to hold information about this archive. */
18277 arch
.file_name
= NULL
;
18279 arch
.index_array
= NULL
;
18280 arch
.sym_table
= NULL
;
18281 arch
.longnames
= NULL
;
18283 /* The NESTED_ARCH structure is used as a single-item cache of information
18284 about a nested archive (when members of a thin archive reside within
18285 another regular archive file). */
18286 nested_arch
.file_name
= NULL
;
18287 nested_arch
.file
= NULL
;
18288 nested_arch
.index_array
= NULL
;
18289 nested_arch
.sym_table
= NULL
;
18290 nested_arch
.longnames
= NULL
;
18292 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
18298 if (do_archive_index
)
18300 if (arch
.sym_table
== NULL
)
18301 error (_("%s: unable to dump the index as none was found\n"), file_name
);
18304 unsigned long i
, l
;
18305 unsigned long current_pos
;
18307 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
18308 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
18309 current_pos
= ftell (file
);
18311 for (i
= l
= 0; i
< arch
.index_num
; i
++)
18313 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
18315 char * member_name
;
18317 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
18319 if (member_name
!= NULL
)
18321 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
18323 if (qualified_name
!= NULL
)
18325 printf (_("Contents of binary %s at offset "), qualified_name
);
18326 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
18328 free (qualified_name
);
18333 if (l
>= arch
.sym_size
)
18335 error (_("%s: end of the symbol table reached before the end of the index\n"),
18340 /* PR 17531: file: 0b6630b2. */
18341 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
18342 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
18345 if (arch
.uses_64bit_indicies
)
18350 if (l
< arch
.sym_size
)
18352 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
18353 file_name
, arch
.sym_size
- l
);
18357 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
18359 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
18365 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
18366 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
18367 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
18368 && !do_section_groups
&& !do_dyn_syms
)
18370 ret
= TRUE
; /* Archive index only. */
18379 char * qualified_name
;
18381 /* Read the next archive header. */
18382 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
18384 error (_("%s: failed to seek to next archive header\n"), file_name
);
18387 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
18388 if (got
!= sizeof arch
.arhdr
)
18392 error (_("%s: failed to read archive header\n"), file_name
);
18396 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
18398 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
18403 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
18405 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
18406 if (archive_file_size
& 01)
18407 ++archive_file_size
;
18409 name
= get_archive_member_name (&arch
, &nested_arch
);
18412 error (_("%s: bad archive file name\n"), file_name
);
18416 namelen
= strlen (name
);
18418 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
18419 if (qualified_name
== NULL
)
18421 error (_("%s: bad archive file name\n"), file_name
);
18426 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
18428 /* This is a proxy for an external member of a thin archive. */
18429 FILE * member_file
;
18430 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
18432 if (member_file_name
== NULL
)
18438 member_file
= fopen (member_file_name
, "rb");
18439 if (member_file
== NULL
)
18441 error (_("Input file '%s' is not readable.\n"), member_file_name
);
18442 free (member_file_name
);
18447 archive_file_offset
= arch
.nested_member_origin
;
18449 if (! process_object (qualified_name
, member_file
))
18452 fclose (member_file
);
18453 free (member_file_name
);
18455 else if (is_thin_archive
)
18457 /* PR 15140: Allow for corrupt thin archives. */
18458 if (nested_arch
.file
== NULL
)
18460 error (_("%s: contains corrupt thin archive: %s\n"),
18466 /* This is a proxy for a member of a nested archive. */
18467 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
18469 /* The nested archive file will have been opened and setup by
18470 get_archive_member_name. */
18471 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
18473 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
18478 if (! process_object (qualified_name
, nested_arch
.file
))
18483 archive_file_offset
= arch
.next_arhdr_offset
;
18484 arch
.next_arhdr_offset
+= archive_file_size
;
18486 if (! process_object (qualified_name
, file
))
18490 if (dump_sects
!= NULL
)
18494 num_dump_sects
= 0;
18497 free (qualified_name
);
18501 if (nested_arch
.file
!= NULL
)
18502 fclose (nested_arch
.file
);
18503 release_archive (&nested_arch
);
18504 release_archive (&arch
);
18510 process_file (char * file_name
)
18513 struct stat statbuf
;
18514 char armag
[SARMAG
];
18515 bfd_boolean ret
= TRUE
;
18517 if (stat (file_name
, &statbuf
) < 0)
18519 if (errno
== ENOENT
)
18520 error (_("'%s': No such file\n"), file_name
);
18522 error (_("Could not locate '%s'. System error message: %s\n"),
18523 file_name
, strerror (errno
));
18527 if (! S_ISREG (statbuf
.st_mode
))
18529 error (_("'%s' is not an ordinary file\n"), file_name
);
18533 file
= fopen (file_name
, "rb");
18536 error (_("Input file '%s' is not readable.\n"), file_name
);
18540 if (fread (armag
, SARMAG
, 1, file
) != 1)
18542 error (_("%s: Failed to read file's magic number\n"), file_name
);
18547 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
18549 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
18551 if (! process_archive (file_name
, file
, FALSE
))
18554 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
18556 if ( ! process_archive (file_name
, file
, TRUE
))
18561 if (do_archive_index
)
18562 error (_("File %s is not an archive so its index cannot be displayed.\n"),
18566 archive_file_size
= archive_file_offset
= 0;
18568 if (! process_object (file_name
, file
))
18573 current_file_size
= 0;
18578 #ifdef SUPPORT_DISASSEMBLY
18579 /* Needed by the i386 disassembler. For extra credit, someone could
18580 fix this so that we insert symbolic addresses here, esp for GOT/PLT
18584 print_address (unsigned int addr
, FILE * outfile
)
18586 fprintf (outfile
,"0x%8.8x", addr
);
18589 /* Needed by the i386 disassembler. */
18591 db_task_printsym (unsigned int addr
)
18593 print_address (addr
, stderr
);
18598 main (int argc
, char ** argv
)
18602 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
18603 setlocale (LC_MESSAGES
, "");
18605 #if defined (HAVE_SETLOCALE)
18606 setlocale (LC_CTYPE
, "");
18608 bindtextdomain (PACKAGE
, LOCALEDIR
);
18609 textdomain (PACKAGE
);
18611 expandargv (&argc
, &argv
);
18613 parse_args (argc
, argv
);
18615 if (num_dump_sects
> 0)
18617 /* Make a copy of the dump_sects array. */
18618 cmdline_dump_sects
= (dump_type
*)
18619 malloc (num_dump_sects
* sizeof (* dump_sects
));
18620 if (cmdline_dump_sects
== NULL
)
18621 error (_("Out of memory allocating dump request table.\n"));
18624 memcpy (cmdline_dump_sects
, dump_sects
,
18625 num_dump_sects
* sizeof (* dump_sects
));
18626 num_cmdline_dump_sects
= num_dump_sects
;
18630 if (optind
< (argc
- 1))
18632 else if (optind
>= argc
)
18634 warn (_("Nothing to do.\n"));
18639 while (optind
< argc
)
18640 if (! process_file (argv
[optind
++]))
18643 if (dump_sects
!= NULL
)
18645 if (cmdline_dump_sects
!= NULL
)
18646 free (cmdline_dump_sects
);
18648 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;