]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame_incremental - binutils/readelf.c
projects / thirdparty / binutils-gdb.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
FT32B is a new FT32 family member. It has a code compression scheme, which requires...
[thirdparty/binutils-gdb.git] / binutils / readelf.c
... / ...
CommitLineData
1/* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2017 Free Software Foundation, Inc.
3
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
6
7 This file is part of GNU Binutils.
8
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.
13
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.
18
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
22 02110-1301, USA. */
23\f
24/* The difference between readelf and objdump:
25
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
28
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.
35
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.
38
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. */
42\f
43#include "sysdep.h"
44#include <assert.h>
45#include <time.h>
46#include <zlib.h>
47#ifdef HAVE_WCHAR_H
48#include <wchar.h>
49#endif
50
51#if __GNUC__ >= 2
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. */
56#define BFD64
57#endif
58
59#include "bfd.h"
60#include "bucomm.h"
61#include "elfcomm.h"
62#include "dwarf.h"
63
64#include "elf/common.h"
65#include "elf/external.h"
66#include "elf/internal.h"
67
68
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. */
73
74#include "elf/h8.h"
75#undef _ELF_H8_H
76
77/* Undo the effects of #including reloc-macros.h. */
78
79#undef START_RELOC_NUMBERS
80#undef RELOC_NUMBER
81#undef FAKE_RELOC
82#undef EMPTY_RELOC
83#undef END_RELOC_NUMBERS
84#undef _RELOC_MACROS_H
85
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() */
89
90#define RELOC_MACROS_GEN_FUNC
91
92#include "elf/aarch64.h"
93#include "elf/alpha.h"
94#include "elf/arc.h"
95#include "elf/arm.h"
96#include "elf/avr.h"
97#include "elf/bfin.h"
98#include "elf/cr16.h"
99#include "elf/cris.h"
100#include "elf/crx.h"
101#include "elf/d10v.h"
102#include "elf/d30v.h"
103#include "elf/dlx.h"
104#include "elf/epiphany.h"
105#include "elf/fr30.h"
106#include "elf/frv.h"
107#include "elf/ft32.h"
108#include "elf/h8.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"
123#include "elf/mep.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"
132#include "elf/mt.h"
133#include "elf/msp430.h"
134#include "elf/nds32.h"
135#include "elf/nios2.h"
136#include "elf/or1k.h"
137#include "elf/pj.h"
138#include "elf/ppc.h"
139#include "elf/ppc64.h"
140#include "elf/pru.h"
141#include "elf/rl78.h"
142#include "elf/rx.h"
143#include "elf/s390.h"
144#include "elf/score.h"
145#include "elf/sh.h"
146#include "elf/sparc.h"
147#include "elf/spu.h"
148#include "elf/tic6x.h"
149#include "elf/tilegx.h"
150#include "elf/tilepro.h"
151#include "elf/v850.h"
152#include "elf/vax.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"
160
161#include "getopt.h"
162#include "libiberty.h"
163#include "safe-ctype.h"
164#include "filenames.h"
165
166#ifndef offsetof
167#define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
168#endif
169
170typedef struct elf_section_list
171{
172 Elf_Internal_Shdr * hdr;
173 struct elf_section_list * next;
174} elf_section_list;
175
176char * program_name = "readelf";
177static unsigned long archive_file_offset;
178static unsigned long archive_file_size;
179static bfd_size_type current_file_size;
180static unsigned long dynamic_addr;
181static bfd_size_type dynamic_size;
182static size_t dynamic_nent;
183static char * dynamic_strings;
184static unsigned long dynamic_strings_length;
185static char * string_table;
186static unsigned long string_table_length;
187static unsigned long num_dynamic_syms;
188static Elf_Internal_Sym * dynamic_symbols;
189static Elf_Internal_Syminfo * dynamic_syminfo;
190static unsigned long dynamic_syminfo_offset;
191static unsigned int dynamic_syminfo_nent;
192static char program_interpreter[PATH_MAX];
193static bfd_vma dynamic_info[DT_ENCODING];
194static bfd_vma dynamic_info_DT_GNU_HASH;
195static bfd_vma version_info[16];
196static Elf_Internal_Ehdr elf_header;
197static Elf_Internal_Shdr * section_headers;
198static Elf_Internal_Phdr * program_headers;
199static Elf_Internal_Dyn * dynamic_section;
200static elf_section_list * symtab_shndx_list;
201static bfd_boolean show_name = FALSE;
202static bfd_boolean do_dynamic = FALSE;
203static bfd_boolean do_syms = FALSE;
204static bfd_boolean do_dyn_syms = FALSE;
205static bfd_boolean do_reloc = FALSE;
206static bfd_boolean do_sections = FALSE;
207static bfd_boolean do_section_groups = FALSE;
208static bfd_boolean do_section_details = FALSE;
209static bfd_boolean do_segments = FALSE;
210static bfd_boolean do_unwind = FALSE;
211static bfd_boolean do_using_dynamic = FALSE;
212static bfd_boolean do_header = FALSE;
213static bfd_boolean do_dump = FALSE;
214static bfd_boolean do_version = FALSE;
215static bfd_boolean do_histogram = FALSE;
216static bfd_boolean do_debugging = FALSE;
217static bfd_boolean do_arch = FALSE;
218static bfd_boolean do_notes = FALSE;
219static bfd_boolean do_archive_index = FALSE;
220static bfd_boolean is_32bit_elf = FALSE;
221static bfd_boolean decompress_dumps = FALSE;
222
223struct group_list
224{
225 struct group_list * next;
226 unsigned int section_index;
227};
228
229struct group
230{
231 struct group_list * root;
232 unsigned int group_index;
233};
234
235static size_t group_count;
236static struct group * section_groups;
237static struct group ** section_headers_groups;
238
239
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. */
246
247typedef unsigned char dump_type;
248
249/* A linked list of the section names for which dumps were requested. */
250struct dump_list_entry
251{
252 char * name;
253 dump_type type;
254 struct dump_list_entry * next;
255};
256static struct dump_list_entry * dump_sects_byname;
257
258/* A dynamic array of flags indicating for which sections a dump
259 has been requested via command line switches. */
260static dump_type * cmdline_dump_sects = NULL;
261static unsigned int num_cmdline_dump_sects = 0;
262
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. */
268static dump_type * dump_sects = NULL;
269static unsigned int num_dump_sects = 0;
270
271
272/* How to print a vma value. */
273typedef enum print_mode
274{
275 HEX,
276 DEC,
277 DEC_5,
278 UNSIGNED,
279 PREFIX_HEX,
280 FULL_HEX,
281 LONG_HEX
282}
283print_mode;
284
285/* Versioned symbol info. */
286enum versioned_symbol_info
287{
288 symbol_undefined,
289 symbol_hidden,
290 symbol_public
291};
292
293static 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 *);
296
297#define UNKNOWN -1
298
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))
304
305#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
306
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))
310
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)
315
316#define REMOVE_ARCH_BITS(ADDR) \
317 do \
318 { \
319 if (elf_header.e_machine == EM_ARM) \
320 (ADDR) &= ~1; \
321 } \
322 while (0)
323\f
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. */
326
327static const char *
328bfd_vmatoa (char *fmtch, bfd_vma value)
329{
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
334 {
335 char place[64];
336 } buf[4];
337 char *ret;
338 char fmt[32];
339
340 ret = buf[buf_pos++].place;
341 buf_pos %= ARRAY_SIZE (buf);
342
343 sprintf (fmt, "%%%s%s", BFD_VMA_FMT, fmtch);
344 snprintf (ret, sizeof (buf[0].place), fmt, value);
345 return ret;
346}
347
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
354 context. */
355
356static void *
357get_data (void * var, FILE * file, unsigned long offset, bfd_size_type size,
358 bfd_size_type nmemb, const char * reason)
359{
360 void * mvar;
361 bfd_size_type amt = size * nmemb;
362
363 if (size == 0 || nmemb == 0)
364 return NULL;
365
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))
372 {
373 if (reason)
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);
377 return NULL;
378 }
379
380 /* Check for size overflow. */
381 if (amt < nmemb)
382 {
383 if (reason)
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);
387 return NULL;
388 }
389
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)
394 {
395 if (reason)
396 error (_("Reading %s bytes extends past end of file for %s\n"),
397 bfd_vmatoa ("u", amt), reason);
398 return NULL;
399 }
400
401 if (fseek (file, archive_file_offset + offset, SEEK_SET))
402 {
403 if (reason)
404 error (_("Unable to seek to 0x%lx for %s\n"),
405 archive_file_offset + offset, reason);
406 return NULL;
407 }
408
409 mvar = var;
410 if (mvar == NULL)
411 {
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);
416
417 if (mvar == NULL)
418 {
419 if (reason)
420 error (_("Out of memory allocating %s bytes for %s\n"),
421 bfd_vmatoa ("u", amt), reason);
422 return NULL;
423 }
424
425 ((char *) mvar)[amt] = '\0';
426 }
427
428 if (fread (mvar, (size_t) size, (size_t) nmemb, file) != nmemb)
429 {
430 if (reason)
431 error (_("Unable to read in %s bytes of %s\n"),
432 bfd_vmatoa ("u", amt), reason);
433 if (mvar != var)
434 free (mvar);
435 return NULL;
436 }
437
438 return mvar;
439}
440
441/* Print a VMA value in the MODE specified.
442 Returns the number of characters displayed. */
443
444static unsigned int
445print_vma (bfd_vma vma, print_mode mode)
446{
447 unsigned int nc = 0;
448
449 switch (mode)
450 {
451 case FULL_HEX:
452 nc = printf ("0x");
453 /* Fall through. */
454 case LONG_HEX:
455#ifdef BFD64
456 if (is_32bit_elf)
457 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
458#endif
459 printf_vma (vma);
460 return nc + 16;
461
462 case DEC_5:
463 if (vma <= 99999)
464 return printf ("%5" BFD_VMA_FMT "d", vma);
465 /* Fall through. */
466 case PREFIX_HEX:
467 nc = printf ("0x");
468 /* Fall through. */
469 case HEX:
470 return nc + printf ("%" BFD_VMA_FMT "x", vma);
471
472 case DEC:
473 return printf ("%" BFD_VMA_FMT "d", vma);
474
475 case UNSIGNED:
476 return printf ("%" BFD_VMA_FMT "u", vma);
477
478 default:
479 /* FIXME: Report unrecognised mode ? */
480 return 0;
481 }
482}
483
484/* Display a symbol on stdout. Handles the display of control characters and
485 multibye characters (assuming the host environment supports them).
486
487 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
488
489 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
490 padding as necessary.
491
492 Returns the number of emitted characters. */
493
494static unsigned int
495print_symbol (signed int width, const char *symbol)
496{
497 bfd_boolean extra_padding = FALSE;
498 signed int num_printed = 0;
499#ifdef HAVE_MBSTATE_T
500 mbstate_t state;
501#endif
502 unsigned int width_remaining;
503
504 if (width < 0)
505 {
506 /* Keep the width positive. This helps the code below. */
507 width = - width;
508 extra_padding = TRUE;
509 }
510 assert (width != 0);
511
512 if (do_wide)
513 /* Set the remaining width to a very large value.
514 This simplifies the code below. */
515 width_remaining = INT_MAX;
516 else
517 width_remaining = width;
518
519#ifdef HAVE_MBSTATE_T
520 /* Initialise the multibyte conversion state. */
521 memset (& state, 0, sizeof (state));
522#endif
523
524 while (width_remaining)
525 {
526 size_t n;
527 const char c = *symbol++;
528
529 if (c == 0)
530 break;
531
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. */
535 if (ISCNTRL (c))
536 {
537 if (width_remaining < 2)
538 break;
539
540 printf ("^%c", c + 0x40);
541 width_remaining -= 2;
542 num_printed += 2;
543 }
544 else if (ISPRINT (c))
545 {
546 putchar (c);
547 width_remaining --;
548 num_printed ++;
549 }
550 else
551 {
552#ifdef HAVE_MBSTATE_T
553 wchar_t w;
554#endif
555 /* Let printf do the hard work of displaying multibyte characters. */
556 printf ("%.1s", symbol - 1);
557 width_remaining --;
558 num_printed ++;
559
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
563 were displayed. */
564 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
565#else
566 n = 1;
567#endif
568 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
569 symbol += (n - 1);
570 }
571 }
572
573 if (extra_padding && num_printed < width)
574 {
575 /* Fill in the remaining spaces. */
576 printf ("%-*s", width - num_printed, " ");
577 num_printed = width;
578 }
579
580 return num_printed;
581}
582
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. */
586
587static const char *
588printable_section_name (const Elf_Internal_Shdr * sec)
589{
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;
594 char c;
595 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
596
597 while ((c = * name ++) != 0)
598 {
599 if (ISCNTRL (c))
600 {
601 if (remaining < 2)
602 break;
603
604 * buf ++ = '^';
605 * buf ++ = c + 0x40;
606 remaining -= 2;
607 }
608 else if (ISPRINT (c))
609 {
610 * buf ++ = c;
611 remaining -= 1;
612 }
613 else
614 {
615 static char hex[17] = "0123456789ABCDEF";
616
617 if (remaining < 4)
618 break;
619 * buf ++ = '<';
620 * buf ++ = hex[(c & 0xf0) >> 4];
621 * buf ++ = hex[c & 0x0f];
622 * buf ++ = '>';
623 remaining -= 4;
624 }
625
626 if (remaining == 0)
627 break;
628 }
629
630 * buf = 0;
631 return sec_name_buf;
632}
633
634static const char *
635printable_section_name_from_index (unsigned long ndx)
636{
637 if (ndx >= elf_header.e_shnum)
638 return _("<corrupt>");
639
640 return printable_section_name (section_headers + ndx);
641}
642
643/* Return a pointer to section NAME, or NULL if no such section exists. */
644
645static Elf_Internal_Shdr *
646find_section (const char * name)
647{
648 unsigned int i;
649
650 for (i = 0; i < elf_header.e_shnum; i++)
651 if (streq (SECTION_NAME (section_headers + i), name))
652 return section_headers + i;
653
654 return NULL;
655}
656
657/* Return a pointer to a section containing ADDR, or NULL if no such
658 section exists. */
659
660static Elf_Internal_Shdr *
661find_section_by_address (bfd_vma addr)
662{
663 unsigned int i;
664
665 for (i = 0; i < elf_header.e_shnum; i++)
666 {
667 Elf_Internal_Shdr *sec = section_headers + i;
668 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
669 return sec;
670 }
671
672 return NULL;
673}
674
675static Elf_Internal_Shdr *
676find_section_by_type (unsigned int type)
677{
678 unsigned int i;
679
680 for (i = 0; i < elf_header.e_shnum; i++)
681 {
682 Elf_Internal_Shdr *sec = section_headers + i;
683 if (sec->sh_type == type)
684 return sec;
685 }
686
687 return NULL;
688}
689
690/* Return a pointer to section NAME, or NULL if no such section exists,
691 restricted to the list of sections given in SET. */
692
693static Elf_Internal_Shdr *
694find_section_in_set (const char * name, unsigned int * set)
695{
696 unsigned int i;
697
698 if (set != NULL)
699 {
700 while ((i = *set++) > 0)
701 {
702 /* See PR 21156 for a reproducer. */
703 if (i >= elf_header.e_shnum)
704 continue; /* FIXME: Should we issue an error message ? */
705
706 if (streq (SECTION_NAME (section_headers + i), name))
707 return section_headers + i;
708 }
709 }
710
711 return find_section (name);
712}
713
714/* Read an unsigned LEB128 encoded value from DATA.
715 Set *LENGTH_RETURN to the number of bytes read. */
716
717static inline unsigned long
718read_uleb128 (unsigned char * data,
719 unsigned int * length_return,
720 const unsigned char * const end)
721{
722 return read_leb128 (data, length_return, FALSE, end);
723}
724
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
727 many places. */
728
729static inline bfd_boolean
730is_ia64_vms (void)
731{
732 return elf_header.e_machine == EM_IA_64
733 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
734}
735
736/* Guess the relocation size commonly used by the specific machines. */
737
738static bfd_boolean
739guess_is_rela (unsigned int e_machine)
740{
741 switch (e_machine)
742 {
743 /* Targets that use REL relocations. */
744 case EM_386:
745 case EM_IAMCU:
746 case EM_960:
747 case EM_ARM:
748 case EM_D10V:
749 case EM_CYGNUS_D10V:
750 case EM_DLX:
751 case EM_MIPS:
752 case EM_MIPS_RS3_LE:
753 case EM_CYGNUS_M32R:
754 case EM_SCORE:
755 case EM_XGATE:
756 return FALSE;
757
758 /* Targets that use RELA relocations. */
759 case EM_68K:
760 case EM_860:
761 case EM_AARCH64:
762 case EM_ADAPTEVA_EPIPHANY:
763 case EM_ALPHA:
764 case EM_ALTERA_NIOS2:
765 case EM_ARC:
766 case EM_ARC_COMPACT:
767 case EM_ARC_COMPACT2:
768 case EM_AVR:
769 case EM_AVR_OLD:
770 case EM_BLACKFIN:
771 case EM_CR16:
772 case EM_CRIS:
773 case EM_CRX:
774 case EM_D30V:
775 case EM_CYGNUS_D30V:
776 case EM_FR30:
777 case EM_FT32:
778 case EM_CYGNUS_FR30:
779 case EM_CYGNUS_FRV:
780 case EM_H8S:
781 case EM_H8_300:
782 case EM_H8_300H:
783 case EM_IA_64:
784 case EM_IP2K:
785 case EM_IP2K_OLD:
786 case EM_IQ2000:
787 case EM_LATTICEMICO32:
788 case EM_M32C_OLD:
789 case EM_M32C:
790 case EM_M32R:
791 case EM_MCORE:
792 case EM_CYGNUS_MEP:
793 case EM_METAG:
794 case EM_MMIX:
795 case EM_MN10200:
796 case EM_CYGNUS_MN10200:
797 case EM_MN10300:
798 case EM_CYGNUS_MN10300:
799 case EM_MOXIE:
800 case EM_MSP430:
801 case EM_MSP430_OLD:
802 case EM_MT:
803 case EM_NDS32:
804 case EM_NIOS32:
805 case EM_OR1K:
806 case EM_PPC64:
807 case EM_PPC:
808 case EM_TI_PRU:
809 case EM_RISCV:
810 case EM_RL78:
811 case EM_RX:
812 case EM_S390:
813 case EM_S390_OLD:
814 case EM_SH:
815 case EM_SPARC:
816 case EM_SPARC32PLUS:
817 case EM_SPARCV9:
818 case EM_SPU:
819 case EM_TI_C6000:
820 case EM_TILEGX:
821 case EM_TILEPRO:
822 case EM_V800:
823 case EM_V850:
824 case EM_CYGNUS_V850:
825 case EM_VAX:
826 case EM_VISIUM:
827 case EM_X86_64:
828 case EM_L1OM:
829 case EM_K1OM:
830 case EM_XSTORMY16:
831 case EM_XTENSA:
832 case EM_XTENSA_OLD:
833 case EM_MICROBLAZE:
834 case EM_MICROBLAZE_OLD:
835 case EM_WEBASSEMBLY:
836 return TRUE;
837
838 case EM_68HC05:
839 case EM_68HC08:
840 case EM_68HC11:
841 case EM_68HC16:
842 case EM_FX66:
843 case EM_ME16:
844 case EM_MMA:
845 case EM_NCPU:
846 case EM_NDR1:
847 case EM_PCP:
848 case EM_ST100:
849 case EM_ST19:
850 case EM_ST7:
851 case EM_ST9PLUS:
852 case EM_STARCORE:
853 case EM_SVX:
854 case EM_TINYJ:
855 default:
856 warn (_("Don't know about relocations on this machine architecture\n"));
857 return FALSE;
858 }
859}
860
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. */
866
867static bfd_boolean
868slurp_rela_relocs (FILE * file,
869 unsigned long rel_offset,
870 unsigned long rel_size,
871 Elf_Internal_Rela ** relasp,
872 unsigned long * nrelasp)
873{
874 Elf_Internal_Rela * relas;
875 size_t nrelas;
876 unsigned int i;
877
878 if (is_32bit_elf)
879 {
880 Elf32_External_Rela * erelas;
881
882 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
883 rel_size, _("32-bit relocation data"));
884 if (!erelas)
885 return FALSE;
886
887 nrelas = rel_size / sizeof (Elf32_External_Rela);
888
889 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
890 sizeof (Elf_Internal_Rela));
891
892 if (relas == NULL)
893 {
894 free (erelas);
895 error (_("out of memory parsing relocs\n"));
896 return FALSE;
897 }
898
899 for (i = 0; i < nrelas; i++)
900 {
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);
904 }
905
906 free (erelas);
907 }
908 else
909 {
910 Elf64_External_Rela * erelas;
911
912 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
913 rel_size, _("64-bit relocation data"));
914 if (!erelas)
915 return FALSE;
916
917 nrelas = rel_size / sizeof (Elf64_External_Rela);
918
919 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
920 sizeof (Elf_Internal_Rela));
921
922 if (relas == NULL)
923 {
924 free (erelas);
925 error (_("out of memory parsing relocs\n"));
926 return FALSE;
927 }
928
929 for (i = 0; i < nrelas; i++)
930 {
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);
934
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. */
938#ifdef BFD64
939 if (elf_header.e_machine == EM_MIPS
940 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
941 {
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
946 accordingly. */
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;
954 }
955#endif /* BFD64 */
956 }
957
958 free (erelas);
959 }
960
961 *relasp = relas;
962 *nrelasp = nrelas;
963 return TRUE;
964}
965
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. */
971
972static bfd_boolean
973slurp_rel_relocs (FILE * file,
974 unsigned long rel_offset,
975 unsigned long rel_size,
976 Elf_Internal_Rela ** relsp,
977 unsigned long * nrelsp)
978{
979 Elf_Internal_Rela * rels;
980 size_t nrels;
981 unsigned int i;
982
983 if (is_32bit_elf)
984 {
985 Elf32_External_Rel * erels;
986
987 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
988 rel_size, _("32-bit relocation data"));
989 if (!erels)
990 return FALSE;
991
992 nrels = rel_size / sizeof (Elf32_External_Rel);
993
994 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
995
996 if (rels == NULL)
997 {
998 free (erels);
999 error (_("out of memory parsing relocs\n"));
1000 return FALSE;
1001 }
1002
1003 for (i = 0; i < nrels; i++)
1004 {
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;
1008 }
1009
1010 free (erels);
1011 }
1012 else
1013 {
1014 Elf64_External_Rel * erels;
1015
1016 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
1017 rel_size, _("64-bit relocation data"));
1018 if (!erels)
1019 return FALSE;
1020
1021 nrels = rel_size / sizeof (Elf64_External_Rel);
1022
1023 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1024
1025 if (rels == NULL)
1026 {
1027 free (erels);
1028 error (_("out of memory parsing relocs\n"));
1029 return FALSE;
1030 }
1031
1032 for (i = 0; i < nrels; i++)
1033 {
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;
1037
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. */
1041#ifdef BFD64
1042 if (elf_header.e_machine == EM_MIPS
1043 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
1044 {
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
1049 accordingly. */
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;
1057 }
1058#endif /* BFD64 */
1059 }
1060
1061 free (erels);
1062 }
1063
1064 *relsp = rels;
1065 *nrelsp = nrels;
1066 return TRUE;
1067}
1068
1069/* Returns the reloc type extracted from the reloc info field. */
1070
1071static unsigned int
1072get_reloc_type (bfd_vma reloc_info)
1073{
1074 if (is_32bit_elf)
1075 return ELF32_R_TYPE (reloc_info);
1076
1077 switch (elf_header.e_machine)
1078 {
1079 case EM_MIPS:
1080 /* Note: We assume that reloc_info has already been adjusted for us. */
1081 return ELF64_MIPS_R_TYPE (reloc_info);
1082
1083 case EM_SPARCV9:
1084 return ELF64_R_TYPE_ID (reloc_info);
1085
1086 default:
1087 return ELF64_R_TYPE (reloc_info);
1088 }
1089}
1090
1091/* Return the symbol index extracted from the reloc info field. */
1092
1093static bfd_vma
1094get_reloc_symindex (bfd_vma reloc_info)
1095{
1096 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1097}
1098
1099static inline bfd_boolean
1100uses_msp430x_relocs (void)
1101{
1102 return
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));
1108}
1109
1110/* Display the contents of the relocation data found at the specified
1111 offset. */
1112
1113static bfd_boolean
1114dump_relocations (FILE * file,
1115 unsigned long rel_offset,
1116 unsigned long rel_size,
1117 Elf_Internal_Sym * symtab,
1118 unsigned long nsyms,
1119 char * strtab,
1120 unsigned long strtablen,
1121 int is_rela,
1122 bfd_boolean is_dynsym)
1123{
1124 unsigned long i;
1125 Elf_Internal_Rela * rels;
1126 bfd_boolean res = TRUE;
1127
1128 if (is_rela == UNKNOWN)
1129 is_rela = guess_is_rela (elf_header.e_machine);
1130
1131 if (is_rela)
1132 {
1133 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1134 return FALSE;
1135 }
1136 else
1137 {
1138 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1139 return FALSE;
1140 }
1141
1142 if (is_32bit_elf)
1143 {
1144 if (is_rela)
1145 {
1146 if (do_wide)
1147 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1148 else
1149 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1150 }
1151 else
1152 {
1153 if (do_wide)
1154 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1155 else
1156 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1157 }
1158 }
1159 else
1160 {
1161 if (is_rela)
1162 {
1163 if (do_wide)
1164 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1165 else
1166 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1167 }
1168 else
1169 {
1170 if (do_wide)
1171 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1172 else
1173 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1174 }
1175 }
1176
1177 for (i = 0; i < rel_size; i++)
1178 {
1179 const char * rtype;
1180 bfd_vma offset;
1181 bfd_vma inf;
1182 bfd_vma symtab_index;
1183 bfd_vma type;
1184
1185 offset = rels[i].r_offset;
1186 inf = rels[i].r_info;
1187
1188 type = get_reloc_type (inf);
1189 symtab_index = get_reloc_symindex (inf);
1190
1191 if (is_32bit_elf)
1192 {
1193 printf ("%8.8lx %8.8lx ",
1194 (unsigned long) offset & 0xffffffff,
1195 (unsigned long) inf & 0xffffffff);
1196 }
1197 else
1198 {
1199#if BFD_HOST_64BIT_LONG
1200 printf (do_wide
1201 ? "%16.16lx %16.16lx "
1202 : "%12.12lx %12.12lx ",
1203 offset, inf);
1204#elif BFD_HOST_64BIT_LONG_LONG
1205#ifndef __MSVCRT__
1206 printf (do_wide
1207 ? "%16.16llx %16.16llx "
1208 : "%12.12llx %12.12llx ",
1209 offset, inf);
1210#else
1211 printf (do_wide
1212 ? "%16.16I64x %16.16I64x "
1213 : "%12.12I64x %12.12I64x ",
1214 offset, inf);
1215#endif
1216#else
1217 printf (do_wide
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));
1224#endif
1225 }
1226
1227 switch (elf_header.e_machine)
1228 {
1229 default:
1230 rtype = NULL;
1231 break;
1232
1233 case EM_AARCH64:
1234 rtype = elf_aarch64_reloc_type (type);
1235 break;
1236
1237 case EM_M32R:
1238 case EM_CYGNUS_M32R:
1239 rtype = elf_m32r_reloc_type (type);
1240 break;
1241
1242 case EM_386:
1243 case EM_IAMCU:
1244 rtype = elf_i386_reloc_type (type);
1245 break;
1246
1247 case EM_68HC11:
1248 case EM_68HC12:
1249 rtype = elf_m68hc11_reloc_type (type);
1250 break;
1251
1252 case EM_68K:
1253 rtype = elf_m68k_reloc_type (type);
1254 break;
1255
1256 case EM_960:
1257 rtype = elf_i960_reloc_type (type);
1258 break;
1259
1260 case EM_AVR:
1261 case EM_AVR_OLD:
1262 rtype = elf_avr_reloc_type (type);
1263 break;
1264
1265 case EM_OLD_SPARCV9:
1266 case EM_SPARC32PLUS:
1267 case EM_SPARCV9:
1268 case EM_SPARC:
1269 rtype = elf_sparc_reloc_type (type);
1270 break;
1271
1272 case EM_SPU:
1273 rtype = elf_spu_reloc_type (type);
1274 break;
1275
1276 case EM_V800:
1277 rtype = v800_reloc_type (type);
1278 break;
1279 case EM_V850:
1280 case EM_CYGNUS_V850:
1281 rtype = v850_reloc_type (type);
1282 break;
1283
1284 case EM_D10V:
1285 case EM_CYGNUS_D10V:
1286 rtype = elf_d10v_reloc_type (type);
1287 break;
1288
1289 case EM_D30V:
1290 case EM_CYGNUS_D30V:
1291 rtype = elf_d30v_reloc_type (type);
1292 break;
1293
1294 case EM_DLX:
1295 rtype = elf_dlx_reloc_type (type);
1296 break;
1297
1298 case EM_SH:
1299 rtype = elf_sh_reloc_type (type);
1300 break;
1301
1302 case EM_MN10300:
1303 case EM_CYGNUS_MN10300:
1304 rtype = elf_mn10300_reloc_type (type);
1305 break;
1306
1307 case EM_MN10200:
1308 case EM_CYGNUS_MN10200:
1309 rtype = elf_mn10200_reloc_type (type);
1310 break;
1311
1312 case EM_FR30:
1313 case EM_CYGNUS_FR30:
1314 rtype = elf_fr30_reloc_type (type);
1315 break;
1316
1317 case EM_CYGNUS_FRV:
1318 rtype = elf_frv_reloc_type (type);
1319 break;
1320
1321 case EM_FT32:
1322 rtype = elf_ft32_reloc_type (type);
1323 break;
1324
1325 case EM_MCORE:
1326 rtype = elf_mcore_reloc_type (type);
1327 break;
1328
1329 case EM_MMIX:
1330 rtype = elf_mmix_reloc_type (type);
1331 break;
1332
1333 case EM_MOXIE:
1334 rtype = elf_moxie_reloc_type (type);
1335 break;
1336
1337 case EM_MSP430:
1338 if (uses_msp430x_relocs ())
1339 {
1340 rtype = elf_msp430x_reloc_type (type);
1341 break;
1342 }
1343 /* Fall through. */
1344 case EM_MSP430_OLD:
1345 rtype = elf_msp430_reloc_type (type);
1346 break;
1347
1348 case EM_NDS32:
1349 rtype = elf_nds32_reloc_type (type);
1350 break;
1351
1352 case EM_PPC:
1353 rtype = elf_ppc_reloc_type (type);
1354 break;
1355
1356 case EM_PPC64:
1357 rtype = elf_ppc64_reloc_type (type);
1358 break;
1359
1360 case EM_MIPS:
1361 case EM_MIPS_RS3_LE:
1362 rtype = elf_mips_reloc_type (type);
1363 break;
1364
1365 case EM_RISCV:
1366 rtype = elf_riscv_reloc_type (type);
1367 break;
1368
1369 case EM_ALPHA:
1370 rtype = elf_alpha_reloc_type (type);
1371 break;
1372
1373 case EM_ARM:
1374 rtype = elf_arm_reloc_type (type);
1375 break;
1376
1377 case EM_ARC:
1378 case EM_ARC_COMPACT:
1379 case EM_ARC_COMPACT2:
1380 rtype = elf_arc_reloc_type (type);
1381 break;
1382
1383 case EM_PARISC:
1384 rtype = elf_hppa_reloc_type (type);
1385 break;
1386
1387 case EM_H8_300:
1388 case EM_H8_300H:
1389 case EM_H8S:
1390 rtype = elf_h8_reloc_type (type);
1391 break;
1392
1393 case EM_OR1K:
1394 rtype = elf_or1k_reloc_type (type);
1395 break;
1396
1397 case EM_PJ:
1398 case EM_PJ_OLD:
1399 rtype = elf_pj_reloc_type (type);
1400 break;
1401 case EM_IA_64:
1402 rtype = elf_ia64_reloc_type (type);
1403 break;
1404
1405 case EM_CRIS:
1406 rtype = elf_cris_reloc_type (type);
1407 break;
1408
1409 case EM_860:
1410 rtype = elf_i860_reloc_type (type);
1411 break;
1412
1413 case EM_X86_64:
1414 case EM_L1OM:
1415 case EM_K1OM:
1416 rtype = elf_x86_64_reloc_type (type);
1417 break;
1418
1419 case EM_S370:
1420 rtype = i370_reloc_type (type);
1421 break;
1422
1423 case EM_S390_OLD:
1424 case EM_S390:
1425 rtype = elf_s390_reloc_type (type);
1426 break;
1427
1428 case EM_SCORE:
1429 rtype = elf_score_reloc_type (type);
1430 break;
1431
1432 case EM_XSTORMY16:
1433 rtype = elf_xstormy16_reloc_type (type);
1434 break;
1435
1436 case EM_CRX:
1437 rtype = elf_crx_reloc_type (type);
1438 break;
1439
1440 case EM_VAX:
1441 rtype = elf_vax_reloc_type (type);
1442 break;
1443
1444 case EM_VISIUM:
1445 rtype = elf_visium_reloc_type (type);
1446 break;
1447
1448 case EM_ADAPTEVA_EPIPHANY:
1449 rtype = elf_epiphany_reloc_type (type);
1450 break;
1451
1452 case EM_IP2K:
1453 case EM_IP2K_OLD:
1454 rtype = elf_ip2k_reloc_type (type);
1455 break;
1456
1457 case EM_IQ2000:
1458 rtype = elf_iq2000_reloc_type (type);
1459 break;
1460
1461 case EM_XTENSA_OLD:
1462 case EM_XTENSA:
1463 rtype = elf_xtensa_reloc_type (type);
1464 break;
1465
1466 case EM_LATTICEMICO32:
1467 rtype = elf_lm32_reloc_type (type);
1468 break;
1469
1470 case EM_M32C_OLD:
1471 case EM_M32C:
1472 rtype = elf_m32c_reloc_type (type);
1473 break;
1474
1475 case EM_MT:
1476 rtype = elf_mt_reloc_type (type);
1477 break;
1478
1479 case EM_BLACKFIN:
1480 rtype = elf_bfin_reloc_type (type);
1481 break;
1482
1483 case EM_CYGNUS_MEP:
1484 rtype = elf_mep_reloc_type (type);
1485 break;
1486
1487 case EM_CR16:
1488 rtype = elf_cr16_reloc_type (type);
1489 break;
1490
1491 case EM_MICROBLAZE:
1492 case EM_MICROBLAZE_OLD:
1493 rtype = elf_microblaze_reloc_type (type);
1494 break;
1495
1496 case EM_RL78:
1497 rtype = elf_rl78_reloc_type (type);
1498 break;
1499
1500 case EM_RX:
1501 rtype = elf_rx_reloc_type (type);
1502 break;
1503
1504 case EM_METAG:
1505 rtype = elf_metag_reloc_type (type);
1506 break;
1507
1508 case EM_XC16X:
1509 case EM_C166:
1510 rtype = elf_xc16x_reloc_type (type);
1511 break;
1512
1513 case EM_TI_C6000:
1514 rtype = elf_tic6x_reloc_type (type);
1515 break;
1516
1517 case EM_TILEGX:
1518 rtype = elf_tilegx_reloc_type (type);
1519 break;
1520
1521 case EM_TILEPRO:
1522 rtype = elf_tilepro_reloc_type (type);
1523 break;
1524
1525 case EM_WEBASSEMBLY:
1526 rtype = elf_wasm32_reloc_type (type);
1527 break;
1528
1529 case EM_XGATE:
1530 rtype = elf_xgate_reloc_type (type);
1531 break;
1532
1533 case EM_ALTERA_NIOS2:
1534 rtype = elf_nios2_reloc_type (type);
1535 break;
1536
1537 case EM_TI_PRU:
1538 rtype = elf_pru_reloc_type (type);
1539 break;
1540 }
1541
1542 if (rtype == NULL)
1543 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1544 else
1545 printf (do_wide ? "%-22s" : "%-17.17s", rtype);
1546
1547 if (elf_header.e_machine == EM_ALPHA
1548 && rtype != NULL
1549 && streq (rtype, "R_ALPHA_LITUSE")
1550 && is_rela)
1551 {
1552 switch (rels[i].r_addend)
1553 {
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;
1562 }
1563
1564 if (rtype)
1565 printf (" (%s)", rtype);
1566 else
1567 {
1568 putchar (' ');
1569 printf (_("<unknown addend: %lx>"),
1570 (unsigned long) rels[i].r_addend);
1571 res = FALSE;
1572 }
1573 }
1574 else if (symtab_index)
1575 {
1576 if (symtab == NULL || symtab_index >= nsyms)
1577 {
1578 error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index);
1579 res = FALSE;
1580 }
1581 else
1582 {
1583 Elf_Internal_Sym * psym;
1584 const char * version_string;
1585 enum versioned_symbol_info sym_info;
1586 unsigned short vna_other;
1587
1588 psym = symtab + symtab_index;
1589
1590 version_string
1591 = get_symbol_version_string (file, is_dynsym,
1592 strtab, strtablen,
1593 symtab_index,
1594 psym,
1595 &sym_info,
1596 &vna_other);
1597
1598 printf (" ");
1599
1600 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1601 {
1602 const char * name;
1603 unsigned int len;
1604 unsigned int width = is_32bit_elf ? 8 : 14;
1605
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.
1610
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
1614 invoked. */
1615
1616 if (strtab == NULL
1617 || psym->st_name == 0
1618 || psym->st_name >= strtablen)
1619 name = "??";
1620 else
1621 name = strtab + psym->st_name;
1622
1623 len = print_symbol (width, name);
1624 if (version_string)
1625 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1626 version_string);
1627 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1628 }
1629 else
1630 {
1631 print_vma (psym->st_value, LONG_HEX);
1632
1633 printf (is_32bit_elf ? " " : " ");
1634 }
1635
1636 if (psym->st_name == 0)
1637 {
1638 const char * sec_name = "<null>";
1639 char name_buf[40];
1640
1641 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1642 {
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)
1646 sec_name = "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";
1669 else
1670 {
1671 sprintf (name_buf, "<section 0x%x>",
1672 (unsigned int) psym->st_shndx);
1673 sec_name = name_buf;
1674 }
1675 }
1676 print_symbol (22, sec_name);
1677 }
1678 else if (strtab == NULL)
1679 printf (_("<string table index: %3ld>"), psym->st_name);
1680 else if (psym->st_name >= strtablen)
1681 {
1682 error (_("<corrupt string table index: %3ld>"), psym->st_name);
1683 res = FALSE;
1684 }
1685 else
1686 {
1687 print_symbol (22, strtab + psym->st_name);
1688 if (version_string)
1689 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1690 version_string);
1691 }
1692
1693 if (is_rela)
1694 {
1695 bfd_vma off = rels[i].r_addend;
1696
1697 if ((bfd_signed_vma) off < 0)
1698 printf (" - %" BFD_VMA_FMT "x", - off);
1699 else
1700 printf (" + %" BFD_VMA_FMT "x", off);
1701 }
1702 }
1703 }
1704 else if (is_rela)
1705 {
1706 bfd_vma off = rels[i].r_addend;
1707
1708 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1709 if ((bfd_signed_vma) off < 0)
1710 printf ("-%" BFD_VMA_FMT "x", - off);
1711 else
1712 printf ("%" BFD_VMA_FMT "x", off);
1713 }
1714
1715 if (elf_header.e_machine == EM_SPARCV9
1716 && rtype != NULL
1717 && streq (rtype, "R_SPARC_OLO10"))
1718 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1719
1720 putchar ('\n');
1721
1722#ifdef BFD64
1723 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1724 {
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);
1729
1730 printf (" Type2: ");
1731
1732 if (rtype2 == NULL)
1733 printf (_("unrecognized: %-7lx"),
1734 (unsigned long) type2 & 0xffffffff);
1735 else
1736 printf ("%-17.17s", rtype2);
1737
1738 printf ("\n Type3: ");
1739
1740 if (rtype3 == NULL)
1741 printf (_("unrecognized: %-7lx"),
1742 (unsigned long) type3 & 0xffffffff);
1743 else
1744 printf ("%-17.17s", rtype3);
1745
1746 putchar ('\n');
1747 }
1748#endif /* BFD64 */
1749 }
1750
1751 free (rels);
1752
1753 return res;
1754}
1755
1756static const char *
1757get_mips_dynamic_type (unsigned long type)
1758{
1759 switch (type)
1760 {
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";
1807 default:
1808 return NULL;
1809 }
1810}
1811
1812static const char *
1813get_sparc64_dynamic_type (unsigned long type)
1814{
1815 switch (type)
1816 {
1817 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1818 default:
1819 return NULL;
1820 }
1821}
1822
1823static const char *
1824get_ppc_dynamic_type (unsigned long type)
1825{
1826 switch (type)
1827 {
1828 case DT_PPC_GOT: return "PPC_GOT";
1829 case DT_PPC_OPT: return "PPC_OPT";
1830 default:
1831 return NULL;
1832 }
1833}
1834
1835static const char *
1836get_ppc64_dynamic_type (unsigned long type)
1837{
1838 switch (type)
1839 {
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";
1844 default:
1845 return NULL;
1846 }
1847}
1848
1849static const char *
1850get_parisc_dynamic_type (unsigned long type)
1851{
1852 switch (type)
1853 {
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";
1878 default:
1879 return NULL;
1880 }
1881}
1882
1883static const char *
1884get_ia64_dynamic_type (unsigned long type)
1885{
1886 switch (type)
1887 {
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";
1919 default:
1920 return NULL;
1921 }
1922}
1923
1924static const char *
1925get_solaris_section_type (unsigned long type)
1926{
1927 switch (type)
1928 {
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;
1949 }
1950}
1951
1952static const char *
1953get_alpha_dynamic_type (unsigned long type)
1954{
1955 switch (type)
1956 {
1957 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1958 default: return NULL;
1959 }
1960}
1961
1962static const char *
1963get_score_dynamic_type (unsigned long type)
1964{
1965 switch (type)
1966 {
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;
1974 }
1975}
1976
1977static const char *
1978get_tic6x_dynamic_type (unsigned long type)
1979{
1980 switch (type)
1981 {
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;
1989 }
1990}
1991
1992static const char *
1993get_nios2_dynamic_type (unsigned long type)
1994{
1995 switch (type)
1996 {
1997 case DT_NIOS2_GP: return "NIOS2_GP";
1998 default: return NULL;
1999 }
2000}
2001
2002static const char *
2003get_solaris_dynamic_type (unsigned long type)
2004{
2005 switch (type)
2006 {
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";
2029
2030 case 0x70000001: return "SPARC_REGISTER";
2031 case 0x7ffffffd: return "AUXILIARY";
2032 case 0x7ffffffe: return "USED";
2033 case 0x7fffffff: return "FILTER";
2034
2035 default: return NULL;
2036 }
2037}
2038
2039static const char *
2040get_dynamic_type (unsigned long type)
2041{
2042 static char buff[64];
2043
2044 switch (type)
2045 {
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";
2077
2078 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2079 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
2080 case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
2081
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 */
2090
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 */
2098
2099 case DT_VERSYM: return "VERSYM";
2100
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";
2110
2111 case DT_AUXILIARY: return "AUXILIARY";
2112 case DT_USED: return "USED";
2113 case DT_FILTER: return "FILTER";
2114
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";
2121
2122 default:
2123 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2124 {
2125 const char * result;
2126
2127 switch (elf_header.e_machine)
2128 {
2129 case EM_MIPS:
2130 case EM_MIPS_RS3_LE:
2131 result = get_mips_dynamic_type (type);
2132 break;
2133 case EM_SPARCV9:
2134 result = get_sparc64_dynamic_type (type);
2135 break;
2136 case EM_PPC:
2137 result = get_ppc_dynamic_type (type);
2138 break;
2139 case EM_PPC64:
2140 result = get_ppc64_dynamic_type (type);
2141 break;
2142 case EM_IA_64:
2143 result = get_ia64_dynamic_type (type);
2144 break;
2145 case EM_ALPHA:
2146 result = get_alpha_dynamic_type (type);
2147 break;
2148 case EM_SCORE:
2149 result = get_score_dynamic_type (type);
2150 break;
2151 case EM_TI_C6000:
2152 result = get_tic6x_dynamic_type (type);
2153 break;
2154 case EM_ALTERA_NIOS2:
2155 result = get_nios2_dynamic_type (type);
2156 break;
2157 default:
2158 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2159 result = get_solaris_dynamic_type (type);
2160 else
2161 result = NULL;
2162 break;
2163 }
2164
2165 if (result != NULL)
2166 return result;
2167
2168 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2169 }
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)))
2173 {
2174 const char * result;
2175
2176 switch (elf_header.e_machine)
2177 {
2178 case EM_PARISC:
2179 result = get_parisc_dynamic_type (type);
2180 break;
2181 case EM_IA_64:
2182 result = get_ia64_dynamic_type (type);
2183 break;
2184 default:
2185 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2186 result = get_solaris_dynamic_type (type);
2187 else
2188 result = NULL;
2189 break;
2190 }
2191
2192 if (result != NULL)
2193 return result;
2194
2195 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2196 type);
2197 }
2198 else
2199 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2200
2201 return buff;
2202 }
2203}
2204
2205static char *
2206get_file_type (unsigned e_type)
2207{
2208 static char buff[32];
2209
2210 switch (e_type)
2211 {
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)");
2217
2218 default:
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);
2223 else
2224 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2225 return buff;
2226 }
2227}
2228
2229static char *
2230get_machine_name (unsigned e_machine)
2231{
2232 static char buff[64]; /* XXX */
2233
2234 switch (e_machine)
2235 {
2236 /* Please keep this switch table sorted by increasing EM_ value. */
2237 /* 0 */
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";
2248 /* 10 */
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";
2256 /* 20 */
2257 case EM_PPC64: return "PowerPC64";
2258 case EM_S390_OLD:
2259 case EM_S390: return "IBM S/390";
2260 case EM_SPU: return "SPU";
2261 /* 30 */
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";
2266 /* 40 */
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";
2277 /* 50 */
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";
2288 /* 60 */
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";
2299 /* 70 */
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";
2310 /* 80 */
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";
2314 case EM_AVR_OLD:
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";
2328 /* 90 */
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";
2334 case EM_XTENSA_OLD:
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";
2341 /* 100 */
2342 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2343 case EM_IP2K_OLD:
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";
2353 /* 110 */
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";
2360 case EM_C166:
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";
2365 /* 120 */
2366 case EM_M32C: return "Renesas M32c";
2367 /* 130 */
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";
2376 /* 140 */
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";
2381 /* 160 */
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";
2392 /* 170 */
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";
2400 case EM_CR16:
2401 case EM_MICROBLAZE:
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";
2405 /* 180 */
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";
2415 /* 190 */
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";
2426 /* 200 */
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";
2432 /* 210 */
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";
2443 /* 220 */
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";
2452
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";
2460 case EM_M32C_OLD:
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";
2465
2466 default:
2467 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2468 return buff;
2469 }
2470}
2471
2472static void
2473decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2474{
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
2479 architectures.
2480
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.
2483
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. */
2487
2488 switch (e_flags & EF_ARC_MACH_MSK)
2489 {
2490 /* We only expect these to occur for EM_ARC_COMPACT2. */
2491 case EF_ARC_CPU_ARCV2EM:
2492 strcat (buf, ", ARC EM");
2493 break;
2494 case EF_ARC_CPU_ARCV2HS:
2495 strcat (buf, ", ARC HS");
2496 break;
2497
2498 /* We only expect these to occur for EM_ARC_COMPACT. */
2499 case E_ARC_MACH_ARC600:
2500 strcat (buf, ", ARC600");
2501 break;
2502 case E_ARC_MACH_ARC601:
2503 strcat (buf, ", ARC601");
2504 break;
2505 case E_ARC_MACH_ARC700:
2506 strcat (buf, ", ARC700");
2507 break;
2508
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. */
2513 default:
2514 if (e_machine == EM_ARC_COMPACT)
2515 strcat (buf, ", Unknown ARCompact");
2516 else
2517 strcat (buf, ", Unknown ARC");
2518 break;
2519 }
2520
2521 switch (e_flags & EF_ARC_OSABI_MSK)
2522 {
2523 case E_ARC_OSABI_ORIG:
2524 strcat (buf, ", (ABI:legacy)");
2525 break;
2526 case E_ARC_OSABI_V2:
2527 strcat (buf, ", (ABI:v2)");
2528 break;
2529 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2530 case E_ARC_OSABI_V3:
2531 strcat (buf, ", v3 no-legacy-syscalls ABI");
2532 break;
2533 case E_ARC_OSABI_V4:
2534 strcat (buf, ", v4 ABI");
2535 break;
2536 default:
2537 strcat (buf, ", unrecognised ARC OSABI flag");
2538 break;
2539 }
2540}
2541
2542static void
2543decode_ARM_machine_flags (unsigned e_flags, char buf[])
2544{
2545 unsigned eabi;
2546 bfd_boolean unknown = FALSE;
2547
2548 eabi = EF_ARM_EABI_VERSION (e_flags);
2549 e_flags &= ~ EF_ARM_EABIMASK;
2550
2551 /* Handle "generic" ARM flags. */
2552 if (e_flags & EF_ARM_RELEXEC)
2553 {
2554 strcat (buf, ", relocatable executable");
2555 e_flags &= ~ EF_ARM_RELEXEC;
2556 }
2557
2558 /* Now handle EABI specific flags. */
2559 switch (eabi)
2560 {
2561 default:
2562 strcat (buf, ", <unrecognized EABI>");
2563 if (e_flags)
2564 unknown = TRUE;
2565 break;
2566
2567 case EF_ARM_EABI_VER1:
2568 strcat (buf, ", Version1 EABI");
2569 while (e_flags)
2570 {
2571 unsigned flag;
2572
2573 /* Process flags one bit at a time. */
2574 flag = e_flags & - e_flags;
2575 e_flags &= ~ flag;
2576
2577 switch (flag)
2578 {
2579 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2580 strcat (buf, ", sorted symbol tables");
2581 break;
2582
2583 default:
2584 unknown = TRUE;
2585 break;
2586 }
2587 }
2588 break;
2589
2590 case EF_ARM_EABI_VER2:
2591 strcat (buf, ", Version2 EABI");
2592 while (e_flags)
2593 {
2594 unsigned flag;
2595
2596 /* Process flags one bit at a time. */
2597 flag = e_flags & - e_flags;
2598 e_flags &= ~ flag;
2599
2600 switch (flag)
2601 {
2602 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2603 strcat (buf, ", sorted symbol tables");
2604 break;
2605
2606 case EF_ARM_DYNSYMSUSESEGIDX:
2607 strcat (buf, ", dynamic symbols use segment index");
2608 break;
2609
2610 case EF_ARM_MAPSYMSFIRST:
2611 strcat (buf, ", mapping symbols precede others");
2612 break;
2613
2614 default:
2615 unknown = TRUE;
2616 break;
2617 }
2618 }
2619 break;
2620
2621 case EF_ARM_EABI_VER3:
2622 strcat (buf, ", Version3 EABI");
2623 break;
2624
2625 case EF_ARM_EABI_VER4:
2626 strcat (buf, ", Version4 EABI");
2627 while (e_flags)
2628 {
2629 unsigned flag;
2630
2631 /* Process flags one bit at a time. */
2632 flag = e_flags & - e_flags;
2633 e_flags &= ~ flag;
2634
2635 switch (flag)
2636 {
2637 case EF_ARM_BE8:
2638 strcat (buf, ", BE8");
2639 break;
2640
2641 case EF_ARM_LE8:
2642 strcat (buf, ", LE8");
2643 break;
2644
2645 default:
2646 unknown = TRUE;
2647 break;
2648 }
2649 }
2650 break;
2651
2652 case EF_ARM_EABI_VER5:
2653 strcat (buf, ", Version5 EABI");
2654 while (e_flags)
2655 {
2656 unsigned flag;
2657
2658 /* Process flags one bit at a time. */
2659 flag = e_flags & - e_flags;
2660 e_flags &= ~ flag;
2661
2662 switch (flag)
2663 {
2664 case EF_ARM_BE8:
2665 strcat (buf, ", BE8");
2666 break;
2667
2668 case EF_ARM_LE8:
2669 strcat (buf, ", LE8");
2670 break;
2671
2672 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2673 strcat (buf, ", soft-float ABI");
2674 break;
2675
2676 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2677 strcat (buf, ", hard-float ABI");
2678 break;
2679
2680 default:
2681 unknown = TRUE;
2682 break;
2683 }
2684 }
2685 break;
2686
2687 case EF_ARM_EABI_UNKNOWN:
2688 strcat (buf, ", GNU EABI");
2689 while (e_flags)
2690 {
2691 unsigned flag;
2692
2693 /* Process flags one bit at a time. */
2694 flag = e_flags & - e_flags;
2695 e_flags &= ~ flag;
2696
2697 switch (flag)
2698 {
2699 case EF_ARM_INTERWORK:
2700 strcat (buf, ", interworking enabled");
2701 break;
2702
2703 case EF_ARM_APCS_26:
2704 strcat (buf, ", uses APCS/26");
2705 break;
2706
2707 case EF_ARM_APCS_FLOAT:
2708 strcat (buf, ", uses APCS/float");
2709 break;
2710
2711 case EF_ARM_PIC:
2712 strcat (buf, ", position independent");
2713 break;
2714
2715 case EF_ARM_ALIGN8:
2716 strcat (buf, ", 8 bit structure alignment");
2717 break;
2718
2719 case EF_ARM_NEW_ABI:
2720 strcat (buf, ", uses new ABI");
2721 break;
2722
2723 case EF_ARM_OLD_ABI:
2724 strcat (buf, ", uses old ABI");
2725 break;
2726
2727 case EF_ARM_SOFT_FLOAT:
2728 strcat (buf, ", software FP");
2729 break;
2730
2731 case EF_ARM_VFP_FLOAT:
2732 strcat (buf, ", VFP");
2733 break;
2734
2735 case EF_ARM_MAVERICK_FLOAT:
2736 strcat (buf, ", Maverick FP");
2737 break;
2738
2739 default:
2740 unknown = TRUE;
2741 break;
2742 }
2743 }
2744 }
2745
2746 if (unknown)
2747 strcat (buf,_(", <unknown>"));
2748}
2749
2750static void
2751decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2752{
2753 --size; /* Leave space for null terminator. */
2754
2755 switch (e_flags & EF_AVR_MACH)
2756 {
2757 case E_AVR_MACH_AVR1:
2758 strncat (buf, ", avr:1", size);
2759 break;
2760 case E_AVR_MACH_AVR2:
2761 strncat (buf, ", avr:2", size);
2762 break;
2763 case E_AVR_MACH_AVR25:
2764 strncat (buf, ", avr:25", size);
2765 break;
2766 case E_AVR_MACH_AVR3:
2767 strncat (buf, ", avr:3", size);
2768 break;
2769 case E_AVR_MACH_AVR31:
2770 strncat (buf, ", avr:31", size);
2771 break;
2772 case E_AVR_MACH_AVR35:
2773 strncat (buf, ", avr:35", size);
2774 break;
2775 case E_AVR_MACH_AVR4:
2776 strncat (buf, ", avr:4", size);
2777 break;
2778 case E_AVR_MACH_AVR5:
2779 strncat (buf, ", avr:5", size);
2780 break;
2781 case E_AVR_MACH_AVR51:
2782 strncat (buf, ", avr:51", size);
2783 break;
2784 case E_AVR_MACH_AVR6:
2785 strncat (buf, ", avr:6", size);
2786 break;
2787 case E_AVR_MACH_AVRTINY:
2788 strncat (buf, ", avr:100", size);
2789 break;
2790 case E_AVR_MACH_XMEGA1:
2791 strncat (buf, ", avr:101", size);
2792 break;
2793 case E_AVR_MACH_XMEGA2:
2794 strncat (buf, ", avr:102", size);
2795 break;
2796 case E_AVR_MACH_XMEGA3:
2797 strncat (buf, ", avr:103", size);
2798 break;
2799 case E_AVR_MACH_XMEGA4:
2800 strncat (buf, ", avr:104", size);
2801 break;
2802 case E_AVR_MACH_XMEGA5:
2803 strncat (buf, ", avr:105", size);
2804 break;
2805 case E_AVR_MACH_XMEGA6:
2806 strncat (buf, ", avr:106", size);
2807 break;
2808 case E_AVR_MACH_XMEGA7:
2809 strncat (buf, ", avr:107", size);
2810 break;
2811 default:
2812 strncat (buf, ", avr:<unknown>", size);
2813 break;
2814 }
2815
2816 size -= strlen (buf);
2817 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2818 strncat (buf, ", link-relax", size);
2819}
2820
2821static void
2822decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2823{
2824 unsigned abi;
2825 unsigned arch;
2826 unsigned config;
2827 unsigned version;
2828 bfd_boolean has_fpu = FALSE;
2829 unsigned int r = 0;
2830
2831 static const char *ABI_STRINGS[] =
2832 {
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 */
2837 "AABI",
2838 "ABI2 FP+"
2839 };
2840 static const char *VER_STRINGS[] =
2841 {
2842 "Andes ELF V1.3 or older",
2843 "Andes ELF V1.3.1",
2844 "Andes ELF V1.4"
2845 };
2846 static const char *ARCH_STRINGS[] =
2847 {
2848 "",
2849 "Andes Star v1.0",
2850 "Andes Star v2.0",
2851 "Andes Star v3.0",
2852 "Andes Star v3.0m"
2853 };
2854
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;
2859
2860 memset (buf, 0, size);
2861
2862 switch (abi)
2863 {
2864 case E_NDS_ABI_V0:
2865 case E_NDS_ABI_V1:
2866 case E_NDS_ABI_V2:
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]);
2872 break;
2873
2874 default:
2875 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2876 break;
2877 }
2878
2879 switch (version)
2880 {
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]);
2885 break;
2886
2887 default:
2888 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2889 break;
2890 }
2891
2892 if (E_NDS_ABI_V0 == abi)
2893 {
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 */
2898 return;
2899 }
2900
2901 switch (arch)
2902 {
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]);
2908 break;
2909
2910 default:
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. */
2914 return;
2915 }
2916
2917 /* Newer ABI; Now handle architecture specific flags. */
2918 if (arch == E_NDS_ARCH_STAR_V1_0)
2919 {
2920 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2921 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2922
2923 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2924 r += snprintf (buf + r, size -r, ", MAC");
2925
2926 if (config & E_NDS32_HAS_DIV_INST)
2927 r += snprintf (buf + r, size -r, ", DIV");
2928
2929 if (config & E_NDS32_HAS_16BIT_INST)
2930 r += snprintf (buf + r, size -r, ", 16b");
2931 }
2932 else
2933 {
2934 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2935 {
2936 if (version <= E_NDS32_ELF_VER_1_3)
2937 r += snprintf (buf + r, size -r, ", [B8]");
2938 else
2939 r += snprintf (buf + r, size -r, ", EX9");
2940 }
2941
2942 if (config & E_NDS32_HAS_MAC_DX_INST)
2943 r += snprintf (buf + r, size -r, ", MAC_DX");
2944
2945 if (config & E_NDS32_HAS_DIV_DX_INST)
2946 r += snprintf (buf + r, size -r, ", DIV_DX");
2947
2948 if (config & E_NDS32_HAS_16BIT_INST)
2949 {
2950 if (version <= E_NDS32_ELF_VER_1_3)
2951 r += snprintf (buf + r, size -r, ", 16b");
2952 else
2953 r += snprintf (buf + r, size -r, ", IFC");
2954 }
2955 }
2956
2957 if (config & E_NDS32_HAS_EXT_INST)
2958 r += snprintf (buf + r, size -r, ", PERF1");
2959
2960 if (config & E_NDS32_HAS_EXT2_INST)
2961 r += snprintf (buf + r, size -r, ", PERF2");
2962
2963 if (config & E_NDS32_HAS_FPU_INST)
2964 {
2965 has_fpu = TRUE;
2966 r += snprintf (buf + r, size -r, ", FPU_SP");
2967 }
2968
2969 if (config & E_NDS32_HAS_FPU_DP_INST)
2970 {
2971 has_fpu = TRUE;
2972 r += snprintf (buf + r, size -r, ", FPU_DP");
2973 }
2974
2975 if (config & E_NDS32_HAS_FPU_MAC_INST)
2976 {
2977 has_fpu = TRUE;
2978 r += snprintf (buf + r, size -r, ", FPU_MAC");
2979 }
2980
2981 if (has_fpu)
2982 {
2983 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2984 {
2985 case E_NDS32_FPU_REG_8SP_4DP:
2986 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2987 break;
2988 case E_NDS32_FPU_REG_16SP_8DP:
2989 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2990 break;
2991 case E_NDS32_FPU_REG_32SP_16DP:
2992 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2993 break;
2994 case E_NDS32_FPU_REG_32SP_32DP:
2995 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2996 break;
2997 }
2998 }
2999
3000 if (config & E_NDS32_HAS_AUDIO_INST)
3001 r += snprintf (buf + r, size -r, ", AUDIO");
3002
3003 if (config & E_NDS32_HAS_STRING_INST)
3004 r += snprintf (buf + r, size -r, ", STR");
3005
3006 if (config & E_NDS32_HAS_REDUCED_REGS)
3007 r += snprintf (buf + r, size -r, ", 16REG");
3008
3009 if (config & E_NDS32_HAS_VIDEO_INST)
3010 {
3011 if (version <= E_NDS32_ELF_VER_1_3)
3012 r += snprintf (buf + r, size -r, ", VIDEO");
3013 else
3014 r += snprintf (buf + r, size -r, ", SATURATION");
3015 }
3016
3017 if (config & E_NDS32_HAS_ENCRIPT_INST)
3018 r += snprintf (buf + r, size -r, ", ENCRP");
3019
3020 if (config & E_NDS32_HAS_L2C_INST)
3021 r += snprintf (buf + r, size -r, ", L2C");
3022}
3023
3024static char *
3025get_machine_flags (unsigned e_flags, unsigned e_machine)
3026{
3027 static char buf[1024];
3028
3029 buf[0] = '\0';
3030
3031 if (e_flags)
3032 {
3033 switch (e_machine)
3034 {
3035 default:
3036 break;
3037
3038 case EM_ARC_COMPACT2:
3039 case EM_ARC_COMPACT:
3040 decode_ARC_machine_flags (e_flags, e_machine, buf);
3041 break;
3042
3043 case EM_ARM:
3044 decode_ARM_machine_flags (e_flags, buf);
3045 break;
3046
3047 case EM_AVR:
3048 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
3049 break;
3050
3051 case EM_BLACKFIN:
3052 if (e_flags & EF_BFIN_PIC)
3053 strcat (buf, ", PIC");
3054
3055 if (e_flags & EF_BFIN_FDPIC)
3056 strcat (buf, ", FDPIC");
3057
3058 if (e_flags & EF_BFIN_CODE_IN_L1)
3059 strcat (buf, ", code in L1");
3060
3061 if (e_flags & EF_BFIN_DATA_IN_L1)
3062 strcat (buf, ", data in L1");
3063
3064 break;
3065
3066 case EM_CYGNUS_FRV:
3067 switch (e_flags & EF_FRV_CPU_MASK)
3068 {
3069 case EF_FRV_CPU_GENERIC:
3070 break;
3071
3072 default:
3073 strcat (buf, ", fr???");
3074 break;
3075
3076 case EF_FRV_CPU_FR300:
3077 strcat (buf, ", fr300");
3078 break;
3079
3080 case EF_FRV_CPU_FR400:
3081 strcat (buf, ", fr400");
3082 break;
3083 case EF_FRV_CPU_FR405:
3084 strcat (buf, ", fr405");
3085 break;
3086
3087 case EF_FRV_CPU_FR450:
3088 strcat (buf, ", fr450");
3089 break;
3090
3091 case EF_FRV_CPU_FR500:
3092 strcat (buf, ", fr500");
3093 break;
3094 case EF_FRV_CPU_FR550:
3095 strcat (buf, ", fr550");
3096 break;
3097
3098 case EF_FRV_CPU_SIMPLE:
3099 strcat (buf, ", simple");
3100 break;
3101 case EF_FRV_CPU_TOMCAT:
3102 strcat (buf, ", tomcat");
3103 break;
3104 }
3105 break;
3106
3107 case EM_68K:
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");
3114 else
3115 {
3116 char const * isa = _("unknown");
3117 char const * mac = _("unknown mac");
3118 char const * additional = NULL;
3119
3120 switch (e_flags & EF_M68K_CF_ISA_MASK)
3121 {
3122 case EF_M68K_CF_ISA_A_NODIV:
3123 isa = "A";
3124 additional = ", nodiv";
3125 break;
3126 case EF_M68K_CF_ISA_A:
3127 isa = "A";
3128 break;
3129 case EF_M68K_CF_ISA_A_PLUS:
3130 isa = "A+";
3131 break;
3132 case EF_M68K_CF_ISA_B_NOUSP:
3133 isa = "B";
3134 additional = ", nousp";
3135 break;
3136 case EF_M68K_CF_ISA_B:
3137 isa = "B";
3138 break;
3139 case EF_M68K_CF_ISA_C:
3140 isa = "C";
3141 break;
3142 case EF_M68K_CF_ISA_C_NODIV:
3143 isa = "C";
3144 additional = ", nodiv";
3145 break;
3146 }
3147 strcat (buf, ", cf, isa ");
3148 strcat (buf, isa);
3149 if (additional)
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)
3154 {
3155 case 0:
3156 mac = NULL;
3157 break;
3158 case EF_M68K_CF_MAC:
3159 mac = "mac";
3160 break;
3161 case EF_M68K_CF_EMAC:
3162 mac = "emac";
3163 break;
3164 case EF_M68K_CF_EMAC_B:
3165 mac = "emac_b";
3166 break;
3167 }
3168 if (mac)
3169 {
3170 strcat (buf, ", ");
3171 strcat (buf, mac);
3172 }
3173 }
3174 break;
3175
3176 case EM_CYGNUS_MEP:
3177 switch (e_flags & EF_MEP_CPU_MASK)
3178 {
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;
3186 }
3187
3188 switch (e_flags & EF_MEP_COP_MASK)
3189 {
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;
3196 }
3197
3198 if (e_flags & EF_MEP_LIBRARY)
3199 strcat (buf, ", Built for Library");
3200
3201 if (e_flags & EF_MEP_INDEX_MASK)
3202 sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3203 e_flags & EF_MEP_INDEX_MASK);
3204
3205 if (e_flags & ~ EF_MEP_ALL_FLAGS)
3206 sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3207 e_flags & ~ EF_MEP_ALL_FLAGS);
3208 break;
3209
3210 case EM_PPC:
3211 if (e_flags & EF_PPC_EMB)
3212 strcat (buf, ", emb");
3213
3214 if (e_flags & EF_PPC_RELOCATABLE)
3215 strcat (buf, _(", relocatable"));
3216
3217 if (e_flags & EF_PPC_RELOCATABLE_LIB)
3218 strcat (buf, _(", relocatable-lib"));
3219 break;
3220
3221 case EM_PPC64:
3222 if (e_flags & EF_PPC64_ABI)
3223 {
3224 char abi[] = ", abiv0";
3225
3226 abi[6] += e_flags & EF_PPC64_ABI;
3227 strcat (buf, abi);
3228 }
3229 break;
3230
3231 case EM_V800:
3232 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3233 strcat (buf, ", RH850 ABI");
3234
3235 if (e_flags & EF_V800_850E3)
3236 strcat (buf, ", V3 architecture");
3237
3238 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3239 strcat (buf, ", FPU not used");
3240
3241 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3242 strcat (buf, ", regmode: COMMON");
3243
3244 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3245 strcat (buf, ", r4 not used");
3246
3247 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3248 strcat (buf, ", r30 not used");
3249
3250 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3251 strcat (buf, ", r5 not used");
3252
3253 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3254 strcat (buf, ", r2 not used");
3255
3256 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3257 {
3258 switch (e_flags & - e_flags)
3259 {
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;
3272 default: break;
3273 }
3274 }
3275 break;
3276
3277 case EM_V850:
3278 case EM_CYGNUS_V850:
3279 switch (e_flags & EF_V850_ARCH)
3280 {
3281 case E_V850E3V5_ARCH:
3282 strcat (buf, ", v850e3v5");
3283 break;
3284 case E_V850E2V3_ARCH:
3285 strcat (buf, ", v850e2v3");
3286 break;
3287 case E_V850E2_ARCH:
3288 strcat (buf, ", v850e2");
3289 break;
3290 case E_V850E1_ARCH:
3291 strcat (buf, ", v850e1");
3292 break;
3293 case E_V850E_ARCH:
3294 strcat (buf, ", v850e");
3295 break;
3296 case E_V850_ARCH:
3297 strcat (buf, ", v850");
3298 break;
3299 default:
3300 strcat (buf, _(", unknown v850 architecture variant"));
3301 break;
3302 }
3303 break;
3304
3305 case EM_M32R:
3306 case EM_CYGNUS_M32R:
3307 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3308 strcat (buf, ", m32r");
3309 break;
3310
3311 case EM_MIPS:
3312 case EM_MIPS_RS3_LE:
3313 if (e_flags & EF_MIPS_NOREORDER)
3314 strcat (buf, ", noreorder");
3315
3316 if (e_flags & EF_MIPS_PIC)
3317 strcat (buf, ", pic");
3318
3319 if (e_flags & EF_MIPS_CPIC)
3320 strcat (buf, ", cpic");
3321
3322 if (e_flags & EF_MIPS_UCODE)
3323 strcat (buf, ", ugen_reserved");
3324
3325 if (e_flags & EF_MIPS_ABI2)
3326 strcat (buf, ", abi2");
3327
3328 if (e_flags & EF_MIPS_OPTIONS_FIRST)
3329 strcat (buf, ", odk first");
3330
3331 if (e_flags & EF_MIPS_32BITMODE)
3332 strcat (buf, ", 32bitmode");
3333
3334 if (e_flags & EF_MIPS_NAN2008)
3335 strcat (buf, ", nan2008");
3336
3337 if (e_flags & EF_MIPS_FP64)
3338 strcat (buf, ", fp64");
3339
3340 switch ((e_flags & EF_MIPS_MACH))
3341 {
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;
3361 case 0:
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
3364 extension. */
3365 break;
3366 default: strcat (buf, _(", unknown CPU")); break;
3367 }
3368
3369 switch ((e_flags & EF_MIPS_ABI))
3370 {
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;
3375 case 0:
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
3379 sure. */
3380 break;
3381 default: strcat (buf, _(", unknown ABI")); break;
3382 }
3383
3384 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3385 strcat (buf, ", mdmx");
3386
3387 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3388 strcat (buf, ", mips16");
3389
3390 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3391 strcat (buf, ", micromips");
3392
3393 switch ((e_flags & EF_MIPS_ARCH))
3394 {
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;
3407 }
3408 break;
3409
3410 case EM_NDS32:
3411 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3412 break;
3413
3414 case EM_RISCV:
3415 if (e_flags & EF_RISCV_RVC)
3416 strcat (buf, ", RVC");
3417
3418 switch (e_flags & EF_RISCV_FLOAT_ABI)
3419 {
3420 case EF_RISCV_FLOAT_ABI_SOFT:
3421 strcat (buf, ", soft-float ABI");
3422 break;
3423
3424 case EF_RISCV_FLOAT_ABI_SINGLE:
3425 strcat (buf, ", single-float ABI");
3426 break;
3427
3428 case EF_RISCV_FLOAT_ABI_DOUBLE:
3429 strcat (buf, ", double-float ABI");
3430 break;
3431
3432 case EF_RISCV_FLOAT_ABI_QUAD:
3433 strcat (buf, ", quad-float ABI");
3434 break;
3435 }
3436 break;
3437
3438 case EM_SH:
3439 switch ((e_flags & EF_SH_MACH_MASK))
3440 {
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;
3463 }
3464
3465 if (e_flags & EF_SH_PIC)
3466 strcat (buf, ", pic");
3467
3468 if (e_flags & EF_SH_FDPIC)
3469 strcat (buf, ", fdpic");
3470 break;
3471
3472 case EM_OR1K:
3473 if (e_flags & EF_OR1K_NODELAY)
3474 strcat (buf, ", no delay");
3475 break;
3476
3477 case EM_SPARCV9:
3478 if (e_flags & EF_SPARC_32PLUS)
3479 strcat (buf, ", v8+");
3480
3481 if (e_flags & EF_SPARC_SUN_US1)
3482 strcat (buf, ", ultrasparcI");
3483
3484 if (e_flags & EF_SPARC_SUN_US3)
3485 strcat (buf, ", ultrasparcIII");
3486
3487 if (e_flags & EF_SPARC_HAL_R1)
3488 strcat (buf, ", halr1");
3489
3490 if (e_flags & EF_SPARC_LEDATA)
3491 strcat (buf, ", ledata");
3492
3493 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3494 strcat (buf, ", tso");
3495
3496 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3497 strcat (buf, ", pso");
3498
3499 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3500 strcat (buf, ", rmo");
3501 break;
3502
3503 case EM_PARISC:
3504 switch (e_flags & EF_PARISC_ARCH)
3505 {
3506 case EFA_PARISC_1_0:
3507 strcpy (buf, ", PA-RISC 1.0");
3508 break;
3509 case EFA_PARISC_1_1:
3510 strcpy (buf, ", PA-RISC 1.1");
3511 break;
3512 case EFA_PARISC_2_0:
3513 strcpy (buf, ", PA-RISC 2.0");
3514 break;
3515 default:
3516 break;
3517 }
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");
3530 break;
3531
3532 case EM_PJ:
3533 case EM_PJ_OLD:
3534 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3535 strcat (buf, ", new calling convention");
3536
3537 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3538 strcat (buf, ", gnu calling convention");
3539 break;
3540
3541 case EM_IA_64:
3542 if ((e_flags & EF_IA_64_ABI64))
3543 strcat (buf, ", 64-bit");
3544 else
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)
3555 {
3556 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3557 strcat (buf, ", vms_linkages");
3558 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3559 {
3560 case EF_IA_64_VMS_COMCOD_SUCCESS:
3561 break;
3562 case EF_IA_64_VMS_COMCOD_WARNING:
3563 strcat (buf, ", warning");
3564 break;
3565 case EF_IA_64_VMS_COMCOD_ERROR:
3566 strcat (buf, ", error");
3567 break;
3568 case EF_IA_64_VMS_COMCOD_ABORT:
3569 strcat (buf, ", abort");
3570 break;
3571 default:
3572 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3573 e_flags & EF_IA_64_VMS_COMCOD);
3574 strcat (buf, ", <unknown>");
3575 }
3576 }
3577 break;
3578
3579 case EM_VAX:
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");
3586 break;
3587
3588 case EM_VISIUM:
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");
3595 break;
3596
3597 case EM_RL78:
3598 switch (e_flags & E_FLAG_RL78_CPU_MASK)
3599 {
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;
3604 }
3605 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3606 strcat (buf, ", 64-bit doubles");
3607 break;
3608
3609 case EM_RX:
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");
3623 break;
3624
3625 case EM_S390:
3626 if (e_flags & EF_S390_HIGH_GPRS)
3627 strcat (buf, ", highgprs");
3628 break;
3629
3630 case EM_TI_C6000:
3631 if ((e_flags & EF_C6000_REL))
3632 strcat (buf, ", relocatable module");
3633 break;
3634
3635 case EM_MSP430:
3636 strcat (buf, _(": architecture variant: "));
3637 switch (e_flags & EF_MSP430_MACH)
3638 {
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;
3654 default:
3655 strcat (buf, _(": unknown")); break;
3656 }
3657
3658 if (e_flags & ~ EF_MSP430_MACH)
3659 strcat (buf, _(": unknown extra flag bits also present"));
3660 }
3661 }
3662
3663 return buf;
3664}
3665
3666static const char *
3667get_osabi_name (unsigned int osabi)
3668{
3669 static char buff[32];
3670
3671 switch (osabi)
3672 {
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";
3690 default:
3691 if (osabi >= 64)
3692 switch (elf_header.e_machine)
3693 {
3694 case EM_ARM:
3695 switch (osabi)
3696 {
3697 case ELFOSABI_ARM: return "ARM";
3698 default:
3699 break;
3700 }
3701 break;
3702
3703 case EM_MSP430:
3704 case EM_MSP430_OLD:
3705 case EM_VISIUM:
3706 switch (osabi)
3707 {
3708 case ELFOSABI_STANDALONE: return _("Standalone App");
3709 default:
3710 break;
3711 }
3712 break;
3713
3714 case EM_TI_C6000:
3715 switch (osabi)
3716 {
3717 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3718 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3719 default:
3720 break;
3721 }
3722 break;
3723
3724 default:
3725 break;
3726 }
3727 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3728 return buff;
3729 }
3730}
3731
3732static const char *
3733get_aarch64_segment_type (unsigned long type)
3734{
3735 switch (type)
3736 {
3737 case PT_AARCH64_ARCHEXT: return "AARCH64_ARCHEXT";
3738 default: return NULL;
3739 }
3740}
3741
3742static const char *
3743get_arm_segment_type (unsigned long type)
3744{
3745 switch (type)
3746 {
3747 case PT_ARM_EXIDX: return "EXIDX";
3748 default: return NULL;
3749 }
3750}
3751
3752static const char *
3753get_s390_segment_type (unsigned long type)
3754{
3755 switch (type)
3756 {
3757 case PT_S390_PGSTE: return "S390_PGSTE";
3758 default: return NULL;
3759 }
3760}
3761
3762static const char *
3763get_mips_segment_type (unsigned long type)
3764{
3765 switch (type)
3766 {
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;
3772 }
3773}
3774
3775static const char *
3776get_parisc_segment_type (unsigned long type)
3777{
3778 switch (type)
3779 {
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;
3800 }
3801}
3802
3803static const char *
3804get_ia64_segment_type (unsigned long type)
3805{
3806 switch (type)
3807 {
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;
3815 }
3816}
3817
3818static const char *
3819get_tic6x_segment_type (unsigned long type)
3820{
3821 switch (type)
3822 {
3823 case PT_C6000_PHATTR: return "C6000_PHATTR";
3824 default: return NULL;
3825 }
3826}
3827
3828static const char *
3829get_solaris_segment_type (unsigned long type)
3830{
3831 switch (type)
3832 {
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;
3842 }
3843}
3844
3845static const char *
3846get_segment_type (unsigned long p_type)
3847{
3848 static char buff[32];
3849
3850 switch (p_type)
3851 {
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";
3863
3864 default:
3865 if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
3866 {
3867 sprintf (buff, "GNU_MBIND+%#lx",
3868 p_type - PT_GNU_MBIND_LO);
3869 }
3870 else if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3871 {
3872 const char * result;
3873
3874 switch (elf_header.e_machine)
3875 {
3876 case EM_AARCH64:
3877 result = get_aarch64_segment_type (p_type);
3878 break;
3879 case EM_ARM:
3880 result = get_arm_segment_type (p_type);
3881 break;
3882 case EM_MIPS:
3883 case EM_MIPS_RS3_LE:
3884 result = get_mips_segment_type (p_type);
3885 break;
3886 case EM_PARISC:
3887 result = get_parisc_segment_type (p_type);
3888 break;
3889 case EM_IA_64:
3890 result = get_ia64_segment_type (p_type);
3891 break;
3892 case EM_TI_C6000:
3893 result = get_tic6x_segment_type (p_type);
3894 break;
3895 case EM_S390:
3896 case EM_S390_OLD:
3897 result = get_s390_segment_type (p_type);
3898 break;
3899 default:
3900 result = NULL;
3901 break;
3902 }
3903
3904 if (result != NULL)
3905 return result;
3906
3907 sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
3908 }
3909 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3910 {
3911 const char * result;
3912
3913 switch (elf_header.e_machine)
3914 {
3915 case EM_PARISC:
3916 result = get_parisc_segment_type (p_type);
3917 break;
3918 case EM_IA_64:
3919 result = get_ia64_segment_type (p_type);
3920 break;
3921 default:
3922 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
3923 result = get_solaris_segment_type (p_type);
3924 else
3925 result = NULL;
3926 break;
3927 }
3928
3929 if (result != NULL)
3930 return result;
3931
3932 sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
3933 }
3934 else
3935 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3936
3937 return buff;
3938 }
3939}
3940
3941static const char *
3942get_arc_section_type_name (unsigned int sh_type)
3943{
3944 switch (sh_type)
3945 {
3946 case SHT_ARC_ATTRIBUTES: return "ARC_ATTRIBUTES";
3947 default:
3948 break;
3949 }
3950 return NULL;
3951}
3952
3953static const char *
3954get_mips_section_type_name (unsigned int sh_type)
3955{
3956 switch (sh_type)
3957 {
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";
3998 default:
3999 break;
4000 }
4001 return NULL;
4002}
4003
4004static const char *
4005get_parisc_section_type_name (unsigned int sh_type)
4006{
4007 switch (sh_type)
4008 {
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;
4017 }
4018}
4019
4020static const char *
4021get_ia64_section_type_name (unsigned int sh_type)
4022{
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);
4026
4027 switch (sh_type)
4028 {
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";
4039 default:
4040 break;
4041 }
4042 return NULL;
4043}
4044
4045static const char *
4046get_x86_64_section_type_name (unsigned int sh_type)
4047{
4048 switch (sh_type)
4049 {
4050 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
4051 default: return NULL;
4052 }
4053}
4054
4055static const char *
4056get_aarch64_section_type_name (unsigned int sh_type)
4057{
4058 switch (sh_type)
4059 {
4060 case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4061 default: return NULL;
4062 }
4063}
4064
4065static const char *
4066get_arm_section_type_name (unsigned int sh_type)
4067{
4068 switch (sh_type)
4069 {
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;
4076 }
4077}
4078
4079static const char *
4080get_tic6x_section_type_name (unsigned int sh_type)
4081{
4082 switch (sh_type)
4083 {
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;
4093 }
4094}
4095
4096static const char *
4097get_msp430x_section_type_name (unsigned int sh_type)
4098{
4099 switch (sh_type)
4100 {
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;
4105 }
4106}
4107
4108static const char *
4109get_v850_section_type_name (unsigned int sh_type)
4110{
4111 switch (sh_type)
4112 {
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;
4119 }
4120}
4121
4122static const char *
4123get_section_type_name (unsigned int sh_type)
4124{
4125 static char buff[32];
4126 const char * result;
4127
4128 switch (sh_type)
4129 {
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";
4156
4157 default:
4158 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4159 {
4160 switch (elf_header.e_machine)
4161 {
4162 case EM_ARC:
4163 case EM_ARC_COMPACT:
4164 case EM_ARC_COMPACT2:
4165 result = get_arc_section_type_name (sh_type);
4166 break;
4167 case EM_MIPS:
4168 case EM_MIPS_RS3_LE:
4169 result = get_mips_section_type_name (sh_type);
4170 break;
4171 case EM_PARISC:
4172 result = get_parisc_section_type_name (sh_type);
4173 break;
4174 case EM_IA_64:
4175 result = get_ia64_section_type_name (sh_type);
4176 break;
4177 case EM_X86_64:
4178 case EM_L1OM:
4179 case EM_K1OM:
4180 result = get_x86_64_section_type_name (sh_type);
4181 break;
4182 case EM_AARCH64:
4183 result = get_aarch64_section_type_name (sh_type);
4184 break;
4185 case EM_ARM:
4186 result = get_arm_section_type_name (sh_type);
4187 break;
4188 case EM_TI_C6000:
4189 result = get_tic6x_section_type_name (sh_type);
4190 break;
4191 case EM_MSP430:
4192 result = get_msp430x_section_type_name (sh_type);
4193 break;
4194 case EM_V800:
4195 case EM_V850:
4196 case EM_CYGNUS_V850:
4197 result = get_v850_section_type_name (sh_type);
4198 break;
4199 default:
4200 result = NULL;
4201 break;
4202 }
4203
4204 if (result != NULL)
4205 return result;
4206
4207 sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4208 }
4209 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4210 {
4211 switch (elf_header.e_machine)
4212 {
4213 case EM_IA_64:
4214 result = get_ia64_section_type_name (sh_type);
4215 break;
4216 default:
4217 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4218 result = get_solaris_section_type (sh_type);
4219 else
4220 {
4221 switch (sh_type)
4222 {
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;
4227 default:
4228 result = NULL;
4229 break;
4230 }
4231 }
4232 break;
4233 }
4234
4235 if (result != NULL)
4236 return result;
4237
4238 sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4239 }
4240 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4241 {
4242 switch (elf_header.e_machine)
4243 {
4244 case EM_V800:
4245 case EM_V850:
4246 case EM_CYGNUS_V850:
4247 result = get_v850_section_type_name (sh_type);
4248 break;
4249 default:
4250 result = NULL;
4251 break;
4252 }
4253
4254 if (result != NULL)
4255 return result;
4256
4257 sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4258 }
4259 else
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);
4263
4264 return buff;
4265 }
4266}
4267
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
4273
4274static struct option options[] =
4275{
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'},
4304#endif
4305 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
4306
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},
4310
4311 {"version", no_argument, 0, 'v'},
4312 {"wide", no_argument, 0, 'W'},
4313 {"help", no_argument, 0, 'H'},
4314 {0, no_argument, 0, 0}
4315};
4316
4317static void
4318usage (FILE * stream)
4319{
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\
4354 =addr,=cu_index]\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\
4359 or deeper\n"));
4360#ifdef SUPPORT_DISASSEMBLY
4361 fprintf (stream, _("\
4362 -i --instruction-dump=<number|name>\n\
4363 Disassemble the contents of section <number|name>\n"));
4364#endif
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"));
4371
4372 if (REPORT_BUGS_TO[0] && stream == stdout)
4373 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4374
4375 exit (stream == stdout ? 0 : 1);
4376}
4377
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
4381 the first time. */
4382
4383static void
4384request_dump_bynumber (unsigned int section, dump_type type)
4385{
4386 if (section >= num_dump_sects)
4387 {
4388 dump_type * new_dump_sects;
4389
4390 new_dump_sects = (dump_type *) calloc (section + 1,
4391 sizeof (* dump_sects));
4392
4393 if (new_dump_sects == NULL)
4394 error (_("Out of memory allocating dump request table.\n"));
4395 else
4396 {
4397 if (dump_sects)
4398 {
4399 /* Copy current flag settings. */
4400 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
4401
4402 free (dump_sects);
4403 }
4404
4405 dump_sects = new_dump_sects;
4406 num_dump_sects = section + 1;
4407 }
4408 }
4409
4410 if (dump_sects)
4411 dump_sects[section] |= type;
4412
4413 return;
4414}
4415
4416/* Request a dump by section name. */
4417
4418static void
4419request_dump_byname (const char * section, dump_type type)
4420{
4421 struct dump_list_entry * new_request;
4422
4423 new_request = (struct dump_list_entry *)
4424 malloc (sizeof (struct dump_list_entry));
4425 if (!new_request)
4426 error (_("Out of memory allocating dump request table.\n"));
4427
4428 new_request->name = strdup (section);
4429 if (!new_request->name)
4430 error (_("Out of memory allocating dump request table.\n"));
4431
4432 new_request->type = type;
4433
4434 new_request->next = dump_sects_byname;
4435 dump_sects_byname = new_request;
4436}
4437
4438static inline void
4439request_dump (dump_type type)
4440{
4441 int section;
4442 char * cp;
4443
4444 do_dump++;
4445 section = strtoul (optarg, & cp, 0);
4446
4447 if (! *cp && section >= 0)
4448 request_dump_bynumber (section, type);
4449 else
4450 request_dump_byname (optarg, type);
4451}
4452
4453
4454static void
4455parse_args (int argc, char ** argv)
4456{
4457 int c;
4458
4459 if (argc < 2)
4460 usage (stderr);
4461
4462 while ((c = getopt_long
4463 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4464 {
4465 switch (c)
4466 {
4467 case 0:
4468 /* Long options. */
4469 break;
4470 case 'H':
4471 usage (stdout);
4472 break;
4473
4474 case 'a':
4475 do_syms = TRUE;
4476 do_reloc = TRUE;
4477 do_unwind = TRUE;
4478 do_dynamic = TRUE;
4479 do_header = TRUE;
4480 do_sections = TRUE;
4481 do_section_groups = TRUE;
4482 do_segments = TRUE;
4483 do_version = TRUE;
4484 do_histogram = TRUE;
4485 do_arch = TRUE;
4486 do_notes = TRUE;
4487 break;
4488 case 'g':
4489 do_section_groups = TRUE;
4490 break;
4491 case 't':
4492 case 'N':
4493 do_sections = TRUE;
4494 do_section_details = TRUE;
4495 break;
4496 case 'e':
4497 do_header = TRUE;
4498 do_sections = TRUE;
4499 do_segments = TRUE;
4500 break;
4501 case 'A':
4502 do_arch = TRUE;
4503 break;
4504 case 'D':
4505 do_using_dynamic = TRUE;
4506 break;
4507 case 'r':
4508 do_reloc = TRUE;
4509 break;
4510 case 'u':
4511 do_unwind = TRUE;
4512 break;
4513 case 'h':
4514 do_header = TRUE;
4515 break;
4516 case 'l':
4517 do_segments = TRUE;
4518 break;
4519 case 's':
4520 do_syms = TRUE;
4521 break;
4522 case 'S':
4523 do_sections = TRUE;
4524 break;
4525 case 'd':
4526 do_dynamic = TRUE;
4527 break;
4528 case 'I':
4529 do_histogram = TRUE;
4530 break;
4531 case 'n':
4532 do_notes = TRUE;
4533 break;
4534 case 'c':
4535 do_archive_index = TRUE;
4536 break;
4537 case 'x':
4538 request_dump (HEX_DUMP);
4539 break;
4540 case 'p':
4541 request_dump (STRING_DUMP);
4542 break;
4543 case 'R':
4544 request_dump (RELOC_DUMP);
4545 break;
4546 case 'z':
4547 decompress_dumps = TRUE;
4548 break;
4549 case 'w':
4550 do_dump = TRUE;
4551 if (optarg == 0)
4552 {
4553 do_debugging = TRUE;
4554 dwarf_select_sections_all ();
4555 }
4556 else
4557 {
4558 do_debugging = FALSE;
4559 dwarf_select_sections_by_letters (optarg);
4560 }
4561 break;
4562 case OPTION_DEBUG_DUMP:
4563 do_dump = TRUE;
4564 if (optarg == 0)
4565 do_debugging = TRUE;
4566 else
4567 {
4568 do_debugging = FALSE;
4569 dwarf_select_sections_by_names (optarg);
4570 }
4571 break;
4572 case OPTION_DWARF_DEPTH:
4573 {
4574 char *cp;
4575
4576 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4577 }
4578 break;
4579 case OPTION_DWARF_START:
4580 {
4581 char *cp;
4582
4583 dwarf_start_die = strtoul (optarg, & cp, 0);
4584 }
4585 break;
4586 case OPTION_DWARF_CHECK:
4587 dwarf_check = TRUE;
4588 break;
4589 case OPTION_DYN_SYMS:
4590 do_dyn_syms = TRUE;
4591 break;
4592#ifdef SUPPORT_DISASSEMBLY
4593 case 'i':
4594 request_dump (DISASS_DUMP);
4595 break;
4596#endif
4597 case 'v':
4598 print_version (program_name);
4599 break;
4600 case 'V':
4601 do_version = TRUE;
4602 break;
4603 case 'W':
4604 do_wide = TRUE;
4605 break;
4606 default:
4607 /* xgettext:c-format */
4608 error (_("Invalid option '-%c'\n"), c);
4609 /* Fall through. */
4610 case '?':
4611 usage (stderr);
4612 }
4613 }
4614
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
4619 && !do_dyn_syms)
4620 usage (stderr);
4621}
4622
4623static const char *
4624get_elf_class (unsigned int elf_class)
4625{
4626 static char buff[32];
4627
4628 switch (elf_class)
4629 {
4630 case ELFCLASSNONE: return _("none");
4631 case ELFCLASS32: return "ELF32";
4632 case ELFCLASS64: return "ELF64";
4633 default:
4634 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4635 return buff;
4636 }
4637}
4638
4639static const char *
4640get_data_encoding (unsigned int encoding)
4641{
4642 static char buff[32];
4643
4644 switch (encoding)
4645 {
4646 case ELFDATANONE: return _("none");
4647 case ELFDATA2LSB: return _("2's complement, little endian");
4648 case ELFDATA2MSB: return _("2's complement, big endian");
4649 default:
4650 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4651 return buff;
4652 }
4653}
4654
4655/* Decode the data held in 'elf_header'. */
4656
4657static bfd_boolean
4658process_file_header (void)
4659{
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)
4664 {
4665 error
4666 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4667 return FALSE;
4668 }
4669
4670 init_dwarf_regnames (elf_header.e_machine);
4671
4672 if (do_header)
4673 {
4674 unsigned i;
4675
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]);
4680 printf ("\n");
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
4688 ? "(current)"
4689 : (elf_header.e_ident[EI_VERSION] != EV_NONE
4690 ? _("<unknown: %lx>")
4691 : "")));
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);
4702
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"));
4710
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);
4741 }
4742
4743 if (section_headers != NULL)
4744 {
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;
4756 }
4757
4758 return TRUE;
4759}
4760
4761static bfd_boolean
4762get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4763{
4764 Elf32_External_Phdr * phdrs;
4765 Elf32_External_Phdr * external;
4766 Elf_Internal_Phdr * internal;
4767 unsigned int i;
4768 unsigned int size = elf_header.e_phentsize;
4769 unsigned int num = elf_header.e_phnum;
4770
4771 /* PR binutils/17531: Cope with unexpected section header sizes. */
4772 if (size == 0 || num == 0)
4773 return FALSE;
4774 if (size < sizeof * phdrs)
4775 {
4776 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4777 return FALSE;
4778 }
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"));
4781
4782 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4783 size, num, _("program headers"));
4784 if (phdrs == NULL)
4785 return FALSE;
4786
4787 for (i = 0, internal = pheaders, external = phdrs;
4788 i < elf_header.e_phnum;
4789 i++, internal++, external++)
4790 {
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);
4799 }
4800
4801 free (phdrs);
4802 return TRUE;
4803}
4804
4805static bfd_boolean
4806get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4807{
4808 Elf64_External_Phdr * phdrs;
4809 Elf64_External_Phdr * external;
4810 Elf_Internal_Phdr * internal;
4811 unsigned int i;
4812 unsigned int size = elf_header.e_phentsize;
4813 unsigned int num = elf_header.e_phnum;
4814
4815 /* PR binutils/17531: Cope with unexpected section header sizes. */
4816 if (size == 0 || num == 0)
4817 return FALSE;
4818 if (size < sizeof * phdrs)
4819 {
4820 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4821 return FALSE;
4822 }
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"));
4825
4826 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4827 size, num, _("program headers"));
4828 if (!phdrs)
4829 return FALSE;
4830
4831 for (i = 0, internal = pheaders, external = phdrs;
4832 i < elf_header.e_phnum;
4833 i++, internal++, external++)
4834 {
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);
4843 }
4844
4845 free (phdrs);
4846 return TRUE;
4847}
4848
4849/* Returns TRUE if the program headers were read into `program_headers'. */
4850
4851static bfd_boolean
4852get_program_headers (FILE * file)
4853{
4854 Elf_Internal_Phdr * phdrs;
4855
4856 /* Check cache of prior read. */
4857 if (program_headers != NULL)
4858 return TRUE;
4859
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)
4865 {
4866 error (_("Too many program headers - %#x - the file is not that big\n"),
4867 elf_header.e_phnum);
4868 return FALSE;
4869 }
4870
4871 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4872 sizeof (Elf_Internal_Phdr));
4873 if (phdrs == NULL)
4874 {
4875 error (_("Out of memory reading %u program headers\n"),
4876 elf_header.e_phnum);
4877 return FALSE;
4878 }
4879
4880 if (is_32bit_elf
4881 ? get_32bit_program_headers (file, phdrs)
4882 : get_64bit_program_headers (file, phdrs))
4883 {
4884 program_headers = phdrs;
4885 return TRUE;
4886 }
4887
4888 free (phdrs);
4889 return FALSE;
4890}
4891
4892/* Returns TRUE if the program headers were loaded. */
4893
4894static bfd_boolean
4895process_program_headers (FILE * file)
4896{
4897 Elf_Internal_Phdr * segment;
4898 unsigned int i;
4899 Elf_Internal_Phdr * previous_load = NULL;
4900
4901 if (elf_header.e_phnum == 0)
4902 {
4903 /* PR binutils/12467. */
4904 if (elf_header.e_phoff != 0)
4905 {
4906 warn (_("possibly corrupt ELF header - it has a non-zero program"
4907 " header offset, but no program headers\n"));
4908 return FALSE;
4909 }
4910 else if (do_segments)
4911 printf (_("\nThere are no program headers in this file.\n"));
4912 return TRUE;
4913 }
4914
4915 if (do_segments && !do_header)
4916 {
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);
4923 printf ("\n");
4924 }
4925
4926 if (! get_program_headers (file))
4927 return TRUE;
4928
4929 if (do_segments)
4930 {
4931 if (elf_header.e_phnum > 1)
4932 printf (_("\nProgram Headers:\n"));
4933 else
4934 printf (_("\nProgram Headers:\n"));
4935
4936 if (is_32bit_elf)
4937 printf
4938 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4939 else if (do_wide)
4940 printf
4941 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4942 else
4943 {
4944 printf
4945 (_(" Type Offset VirtAddr PhysAddr\n"));
4946 printf
4947 (_(" FileSiz MemSiz Flags Align\n"));
4948 }
4949 }
4950
4951 dynamic_addr = 0;
4952 dynamic_size = 0;
4953
4954 for (i = 0, segment = program_headers;
4955 i < elf_header.e_phnum;
4956 i++, segment++)
4957 {
4958 if (do_segments)
4959 {
4960 printf (" %-14.14s ", get_segment_type (segment->p_type));
4961
4962 if (is_32bit_elf)
4963 {
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);
4969 printf ("%c%c%c ",
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);
4974 }
4975 else if (do_wide)
4976 {
4977 if ((unsigned long) segment->p_offset == segment->p_offset)
4978 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4979 else
4980 {
4981 print_vma (segment->p_offset, FULL_HEX);
4982 putchar (' ');
4983 }
4984
4985 print_vma (segment->p_vaddr, FULL_HEX);
4986 putchar (' ');
4987 print_vma (segment->p_paddr, FULL_HEX);
4988 putchar (' ');
4989
4990 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4991 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4992 else
4993 {
4994 print_vma (segment->p_filesz, FULL_HEX);
4995 putchar (' ');
4996 }
4997
4998 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4999 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
5000 else
5001 {
5002 print_vma (segment->p_memsz, FULL_HEX);
5003 }
5004
5005 printf (" %c%c%c ",
5006 (segment->p_flags & PF_R ? 'R' : ' '),
5007 (segment->p_flags & PF_W ? 'W' : ' '),
5008 (segment->p_flags & PF_X ? 'E' : ' '));
5009
5010 if ((unsigned long) segment->p_align == segment->p_align)
5011 printf ("%#lx", (unsigned long) segment->p_align);
5012 else
5013 {
5014 print_vma (segment->p_align, PREFIX_HEX);
5015 }
5016 }
5017 else
5018 {
5019 print_vma (segment->p_offset, FULL_HEX);
5020 putchar (' ');
5021 print_vma (segment->p_vaddr, FULL_HEX);
5022 putchar (' ');
5023 print_vma (segment->p_paddr, FULL_HEX);
5024 printf ("\n ");
5025 print_vma (segment->p_filesz, FULL_HEX);
5026 putchar (' ');
5027 print_vma (segment->p_memsz, FULL_HEX);
5028 printf (" %c%c%c ",
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);
5033 }
5034
5035 putc ('\n', stdout);
5036 }
5037
5038 switch (segment->p_type)
5039 {
5040 case PT_LOAD:
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. */
5044 if (previous_load
5045 && previous_load->p_vaddr > segment->p_vaddr)
5046 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5047#endif
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;
5051 break;
5052
5053 case PT_PHDR:
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)
5058 {
5059 unsigned int j;
5060
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))
5065 break;
5066 if (j == elf_header.e_phnum)
5067 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5068 }
5069 break;
5070
5071 case PT_DYNAMIC:
5072 if (dynamic_addr)
5073 error (_("more than one dynamic segment\n"));
5074
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;
5079
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)
5083 {
5084 Elf_Internal_Shdr * sec;
5085
5086 sec = find_section (".dynamic");
5087 if (sec == NULL || sec->sh_size == 0)
5088 {
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"));
5093 break;
5094 }
5095
5096 if (sec->sh_type == SHT_NOBITS)
5097 {
5098 dynamic_size = 0;
5099 break;
5100 }
5101
5102 dynamic_addr = sec->sh_offset;
5103 dynamic_size = sec->sh_size;
5104
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"));
5112 }
5113
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
5117 sections). */
5118 if (dynamic_addr + dynamic_size >= current_file_size)
5119 {
5120 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5121 dynamic_addr = dynamic_size = 0;
5122 }
5123 break;
5124
5125 case PT_INTERP:
5126 if (fseek (file, archive_file_offset + (long) segment->p_offset,
5127 SEEK_SET))
5128 error (_("Unable to find program interpreter name\n"));
5129 else
5130 {
5131 char fmt [32];
5132 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5133
5134 if (ret >= (int) sizeof (fmt) || ret < 0)
5135 error (_("Internal error: failed to create format string to display program interpreter\n"));
5136
5137 program_interpreter[0] = 0;
5138 if (fscanf (file, fmt, program_interpreter) <= 0)
5139 error (_("Unable to read program interpreter name\n"));
5140
5141 if (do_segments)
5142 printf (_(" [Requesting program interpreter: %s]\n"),
5143 program_interpreter);
5144 }
5145 break;
5146 }
5147 }
5148
5149 if (do_segments && section_headers != NULL && string_table != NULL)
5150 {
5151 printf (_("\n Section to Segment mapping:\n"));
5152 printf (_(" Segment Sections...\n"));
5153
5154 for (i = 0; i < elf_header.e_phnum; i++)
5155 {
5156 unsigned int j;
5157 Elf_Internal_Shdr * section;
5158
5159 segment = program_headers + i;
5160 section = section_headers + 1;
5161
5162 printf (" %2.2d ", i);
5163
5164 for (j = 1; j < elf_header.e_shnum; j++, section++)
5165 {
5166 if (!ELF_TBSS_SPECIAL (section, segment)
5167 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5168 printf ("%s ", printable_section_name (section));
5169 }
5170
5171 putc ('\n',stdout);
5172 }
5173 }
5174
5175 return TRUE;
5176}
5177
5178
5179/* Find the file offset corresponding to VMA by using the program headers. */
5180
5181static long
5182offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
5183{
5184 Elf_Internal_Phdr * seg;
5185
5186 if (! get_program_headers (file))
5187 {
5188 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5189 return (long) vma;
5190 }
5191
5192 for (seg = program_headers;
5193 seg < program_headers + elf_header.e_phnum;
5194 ++seg)
5195 {
5196 if (seg->p_type != PT_LOAD)
5197 continue;
5198
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;
5202 }
5203
5204 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5205 (unsigned long) vma);
5206 return (long) vma;
5207}
5208
5209
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. */
5213
5214static bfd_boolean
5215get_32bit_section_headers (FILE * file, bfd_boolean probe)
5216{
5217 Elf32_External_Shdr * shdrs;
5218 Elf_Internal_Shdr * internal;
5219 unsigned int i;
5220 unsigned int size = elf_header.e_shentsize;
5221 unsigned int num = probe ? 1 : elf_header.e_shnum;
5222
5223 /* PR binutils/17531: Cope with unexpected section header sizes. */
5224 if (size == 0 || num == 0)
5225 return FALSE;
5226 if (size < sizeof * shdrs)
5227 {
5228 if (! probe)
5229 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5230 return FALSE;
5231 }
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"));
5234
5235 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
5236 size, num,
5237 probe ? NULL : _("section headers"));
5238 if (shdrs == NULL)
5239 return FALSE;
5240
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)
5246 {
5247 if (!probe)
5248 error (_("Out of memory reading %u section headers\n"), num);
5249 return FALSE;
5250 }
5251
5252 for (i = 0, internal = section_headers;
5253 i < num;
5254 i++, internal++)
5255 {
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);
5270 }
5271
5272 free (shdrs);
5273 return TRUE;
5274}
5275
5276static bfd_boolean
5277get_64bit_section_headers (FILE * file, bfd_boolean probe)
5278{
5279 Elf64_External_Shdr * shdrs;
5280 Elf_Internal_Shdr * internal;
5281 unsigned int i;
5282 unsigned int size = elf_header.e_shentsize;
5283 unsigned int num = probe ? 1 : elf_header.e_shnum;
5284
5285 /* PR binutils/17531: Cope with unexpected section header sizes. */
5286 if (size == 0 || num == 0)
5287 return FALSE;
5288 if (size < sizeof * shdrs)
5289 {
5290 if (! probe)
5291 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5292 return FALSE;
5293 }
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"));
5296
5297 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
5298 size, num,
5299 probe ? NULL : _("section headers"));
5300 if (shdrs == NULL)
5301 return FALSE;
5302
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)
5308 {
5309 if (! probe)
5310 error (_("Out of memory reading %u section headers\n"), num);
5311 return FALSE;
5312 }
5313
5314 for (i = 0, internal = section_headers;
5315 i < num;
5316 i++, internal++)
5317 {
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);
5332 }
5333
5334 free (shdrs);
5335 return TRUE;
5336}
5337
5338static Elf_Internal_Sym *
5339get_32bit_elf_symbols (FILE * file,
5340 Elf_Internal_Shdr * section,
5341 unsigned long * num_syms_return)
5342{
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;
5348 unsigned int j;
5349
5350 if (section->sh_size == 0)
5351 {
5352 if (num_syms_return != NULL)
5353 * num_syms_return = 0;
5354 return NULL;
5355 }
5356
5357 /* Run some sanity checks first. */
5358 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5359 {
5360 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5361 printable_section_name (section), (unsigned long) section->sh_entsize);
5362 goto exit_point;
5363 }
5364
5365 if (section->sh_size > current_file_size)
5366 {
5367 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5368 printable_section_name (section), (unsigned long) section->sh_size);
5369 goto exit_point;
5370 }
5371
5372 number = section->sh_size / section->sh_entsize;
5373
5374 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5375 {
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);
5380 goto exit_point;
5381 }
5382
5383 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5384 section->sh_size, _("symbols"));
5385 if (esyms == NULL)
5386 goto exit_point;
5387
5388 {
5389 elf_section_list * entry;
5390
5391 shndx = NULL;
5392 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5393 if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
5394 {
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"));
5399 if (shndx == NULL)
5400 goto exit_point;
5401 /* PR17531: file: heap-buffer-overflow */
5402 else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5403 {
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);
5408 goto exit_point;
5409 }
5410 }
5411 }
5412
5413 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5414
5415 if (isyms == NULL)
5416 {
5417 error (_("Out of memory reading %lu symbols\n"),
5418 (unsigned long) number);
5419 goto exit_point;
5420 }
5421
5422 for (j = 0, psym = isyms; j < number; j++, psym++)
5423 {
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)
5429 psym->st_shndx
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);
5435 }
5436
5437 exit_point:
5438 if (shndx != NULL)
5439 free (shndx);
5440 if (esyms != NULL)
5441 free (esyms);
5442
5443 if (num_syms_return != NULL)
5444 * num_syms_return = isyms == NULL ? 0 : number;
5445
5446 return isyms;
5447}
5448
5449static Elf_Internal_Sym *
5450get_64bit_elf_symbols (FILE * file,
5451 Elf_Internal_Shdr * section,
5452 unsigned long * num_syms_return)
5453{
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;
5459 unsigned int j;
5460
5461 if (section->sh_size == 0)
5462 {
5463 if (num_syms_return != NULL)
5464 * num_syms_return = 0;
5465 return NULL;
5466 }
5467
5468 /* Run some sanity checks first. */
5469 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5470 {
5471 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5472 printable_section_name (section),
5473 (unsigned long) section->sh_entsize);
5474 goto exit_point;
5475 }
5476
5477 if (section->sh_size > current_file_size)
5478 {
5479 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5480 printable_section_name (section),
5481 (unsigned long) section->sh_size);
5482 goto exit_point;
5483 }
5484
5485 number = section->sh_size / section->sh_entsize;
5486
5487 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5488 {
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);
5493 goto exit_point;
5494 }
5495
5496 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5497 section->sh_size, _("symbols"));
5498 if (!esyms)
5499 goto exit_point;
5500
5501 {
5502 elf_section_list * entry;
5503
5504 shndx = NULL;
5505 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5506 if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
5507 {
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"));
5512 if (shndx == NULL)
5513 goto exit_point;
5514 /* PR17531: file: heap-buffer-overflow */
5515 else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5516 {
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);
5521 goto exit_point;
5522 }
5523 }
5524 }
5525
5526 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5527
5528 if (isyms == NULL)
5529 {
5530 error (_("Out of memory reading %lu symbols\n"),
5531 (unsigned long) number);
5532 goto exit_point;
5533 }
5534
5535 for (j = 0, psym = isyms; j < number; j++, psym++)
5536 {
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);
5541
5542 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5543 psym->st_shndx
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);
5547
5548 psym->st_value = BYTE_GET (esyms[j].st_value);
5549 psym->st_size = BYTE_GET (esyms[j].st_size);
5550 }
5551
5552 exit_point:
5553 if (shndx != NULL)
5554 free (shndx);
5555 if (esyms != NULL)
5556 free (esyms);
5557
5558 if (num_syms_return != NULL)
5559 * num_syms_return = isyms == NULL ? 0 : number;
5560
5561 return isyms;
5562}
5563
5564static const char *
5565get_elf_section_flags (bfd_vma sh_flags)
5566{
5567 static char buff[1024];
5568 char * p = buff;
5569 unsigned int field_size = is_32bit_elf ? 8 : 16;
5570 signed int sindex;
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;
5575 static const struct
5576 {
5577 const char * str;
5578 unsigned int len;
5579 }
5580 flags [] =
5581 {
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") },
5602 /* Generic. */
5603 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5604 /* SPARC specific. */
5605 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5606 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5607 /* ARM specific. */
5608 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5609 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5610 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5611 /* GNU specific. */
5612 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5613 /* VLE specific. */
5614 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5615 };
5616
5617 if (do_section_details)
5618 {
5619 sprintf (buff, "[%*.*lx]: ",
5620 field_size, field_size, (unsigned long) sh_flags);
5621 p += field_size + 4;
5622 }
5623
5624 while (sh_flags)
5625 {
5626 bfd_vma flag;
5627
5628 flag = sh_flags & - sh_flags;
5629 sh_flags &= ~ flag;
5630
5631 if (do_section_details)
5632 {
5633 switch (flag)
5634 {
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;
5648
5649 default:
5650 sindex = -1;
5651 switch (elf_header.e_machine)
5652 {
5653 case EM_IA_64:
5654 if (flag == SHF_IA_64_SHORT)
5655 sindex = 10;
5656 else if (flag == SHF_IA_64_NORECOV)
5657 sindex = 11;
5658#ifdef BFD64
5659 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5660 switch (flag)
5661 {
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;
5668 default: break;
5669 }
5670#endif
5671 break;
5672
5673 case EM_386:
5674 case EM_IAMCU:
5675 case EM_X86_64:
5676 case EM_L1OM:
5677 case EM_K1OM:
5678 case EM_OLD_SPARCV9:
5679 case EM_SPARC32PLUS:
5680 case EM_SPARCV9:
5681 case EM_SPARC:
5682 if (flag == SHF_ORDERED)
5683 sindex = 19;
5684 break;
5685
5686 case EM_ARM:
5687 switch (flag)
5688 {
5689 case SHF_ENTRYSECT: sindex = 21; break;
5690 case SHF_ARM_PURECODE: sindex = 22; break;
5691 case SHF_COMDEF: sindex = 23; break;
5692 default: break;
5693 }
5694 break;
5695 case EM_PPC:
5696 if (flag == SHF_PPC_VLE)
5697 sindex = 25;
5698 break;
5699
5700 default:
5701 break;
5702 }
5703 }
5704
5705 if (sindex != -1)
5706 {
5707 if (p != buff + field_size + 4)
5708 {
5709 if (size < (10 + 2))
5710 {
5711 warn (_("Internal error: not enough buffer room for section flag info"));
5712 return _("<unknown>");
5713 }
5714 size -= 2;
5715 *p++ = ',';
5716 *p++ = ' ';
5717 }
5718
5719 size -= flags [sindex].len;
5720 p = stpcpy (p, flags [sindex].str);
5721 }
5722 else if (flag & SHF_MASKOS)
5723 os_flags |= flag;
5724 else if (flag & SHF_MASKPROC)
5725 proc_flags |= flag;
5726 else
5727 unknown_flags |= flag;
5728 }
5729 else
5730 {
5731 switch (flag)
5732 {
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;
5746
5747 default:
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)
5752 *p = 'l';
5753 else if (elf_header.e_machine == EM_ARM
5754 && flag == SHF_ARM_PURECODE)
5755 *p = 'y';
5756 else if (elf_header.e_machine == EM_PPC
5757 && flag == SHF_PPC_VLE)
5758 *p = 'v';
5759 else if (flag & SHF_MASKOS)
5760 {
5761 *p = 'o';
5762 sh_flags &= ~ SHF_MASKOS;
5763 }
5764 else if (flag & SHF_MASKPROC)
5765 {
5766 *p = 'p';
5767 sh_flags &= ~ SHF_MASKPROC;
5768 }
5769 else
5770 *p = 'x';
5771 break;
5772 }
5773 p++;
5774 }
5775 }
5776
5777 if (do_section_details)
5778 {
5779 if (os_flags)
5780 {
5781 size -= 5 + field_size;
5782 if (p != buff + field_size + 4)
5783 {
5784 if (size < (2 + 1))
5785 {
5786 warn (_("Internal error: not enough buffer room for section flag info"));
5787 return _("<unknown>");
5788 }
5789 size -= 2;
5790 *p++ = ',';
5791 *p++ = ' ';
5792 }
5793 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5794 (unsigned long) os_flags);
5795 p += 5 + field_size;
5796 }
5797 if (proc_flags)
5798 {
5799 size -= 7 + field_size;
5800 if (p != buff + field_size + 4)
5801 {
5802 if (size < (2 + 1))
5803 {
5804 warn (_("Internal error: not enough buffer room for section flag info"));
5805 return _("<unknown>");
5806 }
5807 size -= 2;
5808 *p++ = ',';
5809 *p++ = ' ';
5810 }
5811 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5812 (unsigned long) proc_flags);
5813 p += 7 + field_size;
5814 }
5815 if (unknown_flags)
5816 {
5817 size -= 10 + field_size;
5818 if (p != buff + field_size + 4)
5819 {
5820 if (size < (2 + 1))
5821 {
5822 warn (_("Internal error: not enough buffer room for section flag info"));
5823 return _("<unknown>");
5824 }
5825 size -= 2;
5826 *p++ = ',';
5827 *p++ = ' ';
5828 }
5829 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5830 (unsigned long) unknown_flags);
5831 p += 10 + field_size;
5832 }
5833 }
5834
5835 *p = '\0';
5836 return buff;
5837}
5838
5839static unsigned int
5840get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
5841{
5842 if (is_32bit_elf)
5843 {
5844 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5845
5846 if (size < sizeof (* echdr))
5847 {
5848 error (_("Compressed section is too small even for a compression header\n"));
5849 return 0;
5850 }
5851
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);
5856 }
5857 else
5858 {
5859 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5860
5861 if (size < sizeof (* echdr))
5862 {
5863 error (_("Compressed section is too small even for a compression header\n"));
5864 return 0;
5865 }
5866
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);
5871 }
5872}
5873
5874static bfd_boolean
5875process_section_headers (FILE * file)
5876{
5877 Elf_Internal_Shdr * section;
5878 unsigned int i;
5879
5880 section_headers = NULL;
5881
5882 if (elf_header.e_shnum == 0)
5883 {
5884 /* PR binutils/12467. */
5885 if (elf_header.e_shoff != 0)
5886 {
5887 warn (_("possibly corrupt ELF file header - it has a non-zero"
5888 " section header offset, but no section headers\n"));
5889 return FALSE;
5890 }
5891 else if (do_sections)
5892 printf (_("\nThere are no sections in this file.\n"));
5893
5894 return TRUE;
5895 }
5896
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);
5900
5901 if (is_32bit_elf)
5902 {
5903 if (! get_32bit_section_headers (file, FALSE))
5904 return FALSE;
5905 }
5906 else
5907 {
5908 if (! get_64bit_section_headers (file, FALSE))
5909 return FALSE;
5910 }
5911
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)
5915 {
5916 section = section_headers + elf_header.e_shstrndx;
5917
5918 if (section->sh_size != 0)
5919 {
5920 string_table = (char *) get_data (NULL, file, section->sh_offset,
5921 1, section->sh_size,
5922 _("string table"));
5923
5924 string_table_length = string_table != NULL ? section->sh_size : 0;
5925 }
5926 }
5927
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;
5934
5935 eh_addr_size = is_32bit_elf ? 4 : 8;
5936 switch (elf_header.e_machine)
5937 {
5938 case EM_MIPS:
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.
5943
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)
5951 eh_addr_size = 8;
5952 break;
5953
5954 case EM_H8_300:
5955 case EM_H8_300H:
5956 switch (elf_header.e_flags & EF_H8_MACH)
5957 {
5958 case E_H8_MACH_H8300:
5959 case E_H8_MACH_H8300HN:
5960 case E_H8_MACH_H8300SN:
5961 case E_H8_MACH_H8300SXN:
5962 eh_addr_size = 2;
5963 break;
5964 case E_H8_MACH_H8300H:
5965 case E_H8_MACH_H8300S:
5966 case E_H8_MACH_H8300SX:
5967 eh_addr_size = 4;
5968 break;
5969 }
5970 break;
5971
5972 case EM_M32C_OLD:
5973 case EM_M32C:
5974 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5975 {
5976 case EF_M32C_CPU_M16C:
5977 eh_addr_size = 2;
5978 break;
5979 }
5980 break;
5981 }
5982
5983#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5984 do \
5985 { \
5986 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5987 if (section->sh_entsize != expected_entsize) \
5988 { \
5989 char buf[40]; \
5990 sprintf_vma (buf, section->sh_entsize); \
5991 /* Note: coded this way so that there is a single string for \
5992 translation. */ \
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; \
5997 } \
5998 } \
5999 while (0)
6000
6001#define CHECK_ENTSIZE(section, i, type) \
6002 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6003 sizeof (Elf64_External_##type))
6004
6005 for (i = 0, section = section_headers;
6006 i < elf_header.e_shnum;
6007 i++, section++)
6008 {
6009 char * name = SECTION_NAME (section);
6010
6011 if (section->sh_type == SHT_DYNSYM)
6012 {
6013 if (dynamic_symbols != NULL)
6014 {
6015 error (_("File contains multiple dynamic symbol tables\n"));
6016 continue;
6017 }
6018
6019 CHECK_ENTSIZE (section, i, Sym);
6020 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
6021 }
6022 else if (section->sh_type == SHT_STRTAB
6023 && streq (name, ".dynstr"))
6024 {
6025 if (dynamic_strings != NULL)
6026 {
6027 error (_("File contains multiple dynamic string tables\n"));
6028 continue;
6029 }
6030
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;
6035 }
6036 else if (section->sh_type == SHT_SYMTAB_SHNDX)
6037 {
6038 elf_section_list * entry = xmalloc (sizeof * entry);
6039 entry->hdr = section;
6040 entry->next = symtab_shndx_list;
6041 symtab_shndx_list = entry;
6042 }
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_")))
6058 {
6059 if (name[1] == 'z')
6060 name += sizeof (".zdebug_") - 1;
6061 else
6062 name += sizeof (".debug_") - 1;
6063
6064 if (do_debugging
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"))
6086 )
6087 request_dump_bynumber (i, DEBUG_DUMP);
6088 }
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_"))
6102 {
6103 name += sizeof (".trace_") - 1;
6104
6105 if (do_debugging
6106 || (do_trace_info && streq (name, "info"))
6107 || (do_trace_abbrevs && streq (name, "abbrev"))
6108 || (do_trace_aranges && streq (name, "aranges"))
6109 )
6110 request_dump_bynumber (i, DEBUG_DUMP);
6111 }
6112 }
6113
6114 if (! do_sections)
6115 return TRUE;
6116
6117 if (elf_header.e_shnum > 1)
6118 printf (_("\nSection Headers:\n"));
6119 else
6120 printf (_("\nSection Header:\n"));
6121
6122 if (is_32bit_elf)
6123 {
6124 if (do_section_details)
6125 {
6126 printf (_(" [Nr] Name\n"));
6127 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6128 }
6129 else
6130 printf
6131 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6132 }
6133 else if (do_wide)
6134 {
6135 if (do_section_details)
6136 {
6137 printf (_(" [Nr] Name\n"));
6138 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6139 }
6140 else
6141 printf
6142 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6143 }
6144 else
6145 {
6146 if (do_section_details)
6147 {
6148 printf (_(" [Nr] Name\n"));
6149 printf (_(" Type Address Offset Link\n"));
6150 printf (_(" Size EntSize Info Align\n"));
6151 }
6152 else
6153 {
6154 printf (_(" [Nr] Name Type Address Offset\n"));
6155 printf (_(" Size EntSize Flags Link Info Align\n"));
6156 }
6157 }
6158
6159 if (do_section_details)
6160 printf (_(" Flags\n"));
6161
6162 for (i = 0, section = section_headers;
6163 i < elf_header.e_shnum;
6164 i++, section++)
6165 {
6166 /* Run some sanity checks on the section header. */
6167
6168 /* Check the sh_link field. */
6169 switch (section->sh_type)
6170 {
6171 case SHT_SYMTAB_SHNDX:
6172 case SHT_GROUP:
6173 case SHT_HASH:
6174 case SHT_GNU_HASH:
6175 case SHT_GNU_versym:
6176 case SHT_REL:
6177 case SHT_RELA:
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);
6184 break;
6185
6186 case SHT_DYNAMIC:
6187 case SHT_SYMTAB:
6188 case SHT_DYNSYM:
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);
6197 break;
6198
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);
6205 break;
6206
6207 default:
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
6212 section. */
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);
6216#endif
6217 break;
6218 }
6219
6220 /* Check the sh_info field. */
6221 switch (section->sh_type)
6222 {
6223 case SHT_REL:
6224 case SHT_RELA:
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))
6233 {
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. */
6240 ;
6241 else
6242 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6243 i, section->sh_info);
6244 }
6245 break;
6246
6247 case SHT_DYNAMIC:
6248 case SHT_HASH:
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);
6256 break;
6257
6258 case SHT_GROUP:
6259 case SHT_SYMTAB:
6260 case SHT_DYNSYM:
6261 /* A symbol index - we assume that it is valid. */
6262 break;
6263
6264 default:
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. */
6272 ;
6273 else if (section->sh_flags & SHF_INFO_LINK)
6274 {
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);
6277 }
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);
6283 break;
6284 }
6285
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);
6292
6293 printf (" [%2u] ", i);
6294 if (do_section_details)
6295 printf ("%s\n ", printable_section_name (section));
6296 else
6297 print_symbol (-17, SECTION_NAME (section));
6298
6299 printf (do_wide ? " %-15s " : " %-15.15s ",
6300 get_section_type_name (section->sh_type));
6301
6302 if (is_32bit_elf)
6303 {
6304 const char * link_too_big = NULL;
6305
6306 print_vma (section->sh_addr, LONG_HEX);
6307
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);
6312
6313 if (do_section_details)
6314 fputs (" ", stdout);
6315 else
6316 printf (" %3s ", get_elf_section_flags (section->sh_flags));
6317
6318 if (section->sh_link >= elf_header.e_shnum)
6319 {
6320 link_too_big = "";
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)
6324 {
6325 case EM_386:
6326 case EM_IAMCU:
6327 case EM_X86_64:
6328 case EM_L1OM:
6329 case EM_K1OM:
6330 case EM_OLD_SPARCV9:
6331 case EM_SPARC32PLUS:
6332 case EM_SPARCV9:
6333 case EM_SPARC:
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";
6338 break;
6339 default:
6340 break;
6341 }
6342 }
6343
6344 if (do_section_details)
6345 {
6346 if (link_too_big != NULL && * link_too_big)
6347 printf ("<%s> ", link_too_big);
6348 else
6349 printf ("%2u ", section->sh_link);
6350 printf ("%3u %2lu\n", section->sh_info,
6351 (unsigned long) section->sh_addralign);
6352 }
6353 else
6354 printf ("%2u %3u %2lu\n",
6355 section->sh_link,
6356 section->sh_info,
6357 (unsigned long) section->sh_addralign);
6358
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);
6362 }
6363 else if (do_wide)
6364 {
6365 print_vma (section->sh_addr, LONG_HEX);
6366
6367 if ((long) section->sh_offset == section->sh_offset)
6368 printf (" %6.6lx", (unsigned long) section->sh_offset);
6369 else
6370 {
6371 putchar (' ');
6372 print_vma (section->sh_offset, LONG_HEX);
6373 }
6374
6375 if ((unsigned long) section->sh_size == section->sh_size)
6376 printf (" %6.6lx", (unsigned long) section->sh_size);
6377 else
6378 {
6379 putchar (' ');
6380 print_vma (section->sh_size, LONG_HEX);
6381 }
6382
6383 if ((unsigned long) section->sh_entsize == section->sh_entsize)
6384 printf (" %2.2lx", (unsigned long) section->sh_entsize);
6385 else
6386 {
6387 putchar (' ');
6388 print_vma (section->sh_entsize, LONG_HEX);
6389 }
6390
6391 if (do_section_details)
6392 fputs (" ", stdout);
6393 else
6394 printf (" %3s ", get_elf_section_flags (section->sh_flags));
6395
6396 printf ("%2u %3u ", section->sh_link, section->sh_info);
6397
6398 if ((unsigned long) section->sh_addralign == section->sh_addralign)
6399 printf ("%2lu\n", (unsigned long) section->sh_addralign);
6400 else
6401 {
6402 print_vma (section->sh_addralign, DEC);
6403 putchar ('\n');
6404 }
6405 }
6406 else if (do_section_details)
6407 {
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);
6413 else
6414 {
6415 printf (" ");
6416 print_vma (section->sh_offset, LONG_HEX);
6417 }
6418 printf (" %u\n ", section->sh_link);
6419 print_vma (section->sh_size, LONG_HEX);
6420 putchar (' ');
6421 print_vma (section->sh_entsize, LONG_HEX);
6422
6423 printf (" %-16u %lu\n",
6424 section->sh_info,
6425 (unsigned long) section->sh_addralign);
6426 }
6427 else
6428 {
6429 putchar (' ');
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);
6433 else
6434 {
6435 printf (" ");
6436 print_vma (section->sh_offset, LONG_HEX);
6437 }
6438 printf ("\n ");
6439 print_vma (section->sh_size, LONG_HEX);
6440 printf (" ");
6441 print_vma (section->sh_entsize, LONG_HEX);
6442
6443 printf (" %3s ", get_elf_section_flags (section->sh_flags));
6444
6445 printf (" %2u %3u %lu\n",
6446 section->sh_link,
6447 section->sh_info,
6448 (unsigned long) section->sh_addralign);
6449 }
6450
6451 if (do_section_details)
6452 {
6453 printf (" %s\n", get_elf_section_flags (section->sh_flags));
6454 if ((section->sh_flags & SHF_COMPRESSED) != 0)
6455 {
6456 /* Minimum section size is 12 bytes for 32-bit compression
6457 header + 12 bytes for compressed data header. */
6458 unsigned char buf[24];
6459
6460 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6461 if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
6462 sizeof (buf), _("compression header")))
6463 {
6464 Elf_Internal_Chdr chdr;
6465
6466 (void) get_compression_header (&chdr, buf, sizeof (buf));
6467
6468 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6469 printf (" ZLIB, ");
6470 else
6471 printf (_(" [<unknown>: 0x%x], "),
6472 chdr.ch_type);
6473 print_vma (chdr.ch_size, LONG_HEX);
6474 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6475 }
6476 }
6477 }
6478 }
6479
6480 if (!do_section_details)
6481 {
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");
6498 }
6499
6500 return TRUE;
6501}
6502
6503static const char *
6504get_group_flags (unsigned int flags)
6505{
6506 static char buff[128];
6507
6508 if (flags == 0)
6509 return "";
6510 else if (flags == GRP_COMDAT)
6511 return "COMDAT ";
6512
6513 snprintf (buff, 14, _("[0x%x: "), flags);
6514
6515 flags &= ~ GRP_COMDAT;
6516 if (flags & GRP_MASKOS)
6517 {
6518 strcat (buff, "<OS specific>");
6519 flags &= ~ GRP_MASKOS;
6520 }
6521
6522 if (flags & GRP_MASKPROC)
6523 {
6524 strcat (buff, "<PROC specific>");
6525 flags &= ~ GRP_MASKPROC;
6526 }
6527
6528 if (flags)
6529 strcat (buff, "<unknown>");
6530
6531 strcat (buff, "]");
6532 return buff;
6533}
6534
6535static bfd_boolean
6536process_section_groups (FILE * file)
6537{
6538 Elf_Internal_Shdr * section;
6539 unsigned int i;
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;
6545 char * strtab;
6546 size_t strtab_size;
6547
6548 /* Don't process section groups unless needed. */
6549 if (!do_unwind && !do_section_groups)
6550 return TRUE;
6551
6552 if (elf_header.e_shnum == 0)
6553 {
6554 if (do_section_groups)
6555 printf (_("\nThere are no sections to group in this file.\n"));
6556
6557 return TRUE;
6558 }
6559
6560 if (section_headers == NULL)
6561 {
6562 error (_("Section headers are not available!\n"));
6563 /* PR 13622: This can happen with a corrupt ELF header. */
6564 return FALSE;
6565 }
6566
6567 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
6568 sizeof (struct group *));
6569
6570 if (section_headers_groups == NULL)
6571 {
6572 error (_("Out of memory reading %u section group headers\n"),
6573 elf_header.e_shnum);
6574 return FALSE;
6575 }
6576
6577 /* Scan the sections for the group section. */
6578 group_count = 0;
6579 for (i = 0, section = section_headers;
6580 i < elf_header.e_shnum;
6581 i++, section++)
6582 if (section->sh_type == SHT_GROUP)
6583 group_count++;
6584
6585 if (group_count == 0)
6586 {
6587 if (do_section_groups)
6588 printf (_("\nThere are no section groups in this file.\n"));
6589
6590 return TRUE;
6591 }
6592
6593 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6594
6595 if (section_groups == NULL)
6596 {
6597 error (_("Out of memory reading %lu groups\n"),
6598 (unsigned long) group_count);
6599 return FALSE;
6600 }
6601
6602 symtab_sec = NULL;
6603 strtab_sec = NULL;
6604 symtab = NULL;
6605 num_syms = 0;
6606 strtab = NULL;
6607 strtab_size = 0;
6608 for (i = 0, section = section_headers, group = section_groups;
6609 i < elf_header.e_shnum;
6610 i++, section++)
6611 {
6612 if (section->sh_type == SHT_GROUP)
6613 {
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;
6621
6622 /* Get the symbol table. */
6623 if (section->sh_link >= elf_header.e_shnum
6624 || ((sec = section_headers + section->sh_link)->sh_type
6625 != SHT_SYMTAB))
6626 {
6627 error (_("Bad sh_link in group section `%s'\n"), name);
6628 continue;
6629 }
6630
6631 if (symtab_sec != sec)
6632 {
6633 symtab_sec = sec;
6634 if (symtab)
6635 free (symtab);
6636 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
6637 }
6638
6639 if (symtab == NULL)
6640 {
6641 error (_("Corrupt header in group section `%s'\n"), name);
6642 continue;
6643 }
6644
6645 if (section->sh_info >= num_syms)
6646 {
6647 error (_("Bad sh_info in group section `%s'\n"), name);
6648 continue;
6649 }
6650
6651 sym = symtab + section->sh_info;
6652
6653 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6654 {
6655 if (sym->st_shndx == 0
6656 || sym->st_shndx >= elf_header.e_shnum)
6657 {
6658 error (_("Bad sh_info in group section `%s'\n"), name);
6659 continue;
6660 }
6661
6662 group_name = SECTION_NAME (section_headers + sym->st_shndx);
6663 strtab_sec = NULL;
6664 if (strtab)
6665 free (strtab);
6666 strtab = NULL;
6667 strtab_size = 0;
6668 }
6669 else
6670 {
6671 /* Get the string table. */
6672 if (symtab_sec->sh_link >= elf_header.e_shnum)
6673 {
6674 strtab_sec = NULL;
6675 if (strtab)
6676 free (strtab);
6677 strtab = NULL;
6678 strtab_size = 0;
6679 }
6680 else if (strtab_sec
6681 != (sec = section_headers + symtab_sec->sh_link))
6682 {
6683 strtab_sec = sec;
6684 if (strtab)
6685 free (strtab);
6686
6687 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
6688 1, strtab_sec->sh_size,
6689 _("string table"));
6690 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6691 }
6692 group_name = sym->st_name < strtab_size
6693 ? strtab + sym->st_name : _("<corrupt>");
6694 }
6695
6696 /* PR 17531: file: loop. */
6697 if (section->sh_entsize > section->sh_size)
6698 {
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);
6703 break;
6704 }
6705
6706 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6707 1, section->sh_size,
6708 _("section data"));
6709 if (start == NULL)
6710 continue;
6711
6712 indices = start;
6713 size = (section->sh_size / section->sh_entsize) - 1;
6714 entry = byte_get (indices, 4);
6715 indices += 4;
6716
6717 if (do_section_groups)
6718 {
6719 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6720 get_group_flags (entry), i, name, group_name, size);
6721
6722 printf (_(" [Index] Name\n"));
6723 }
6724
6725 group->group_index = i;
6726
6727 for (j = 0; j < size; j++)
6728 {
6729 struct group_list * g;
6730
6731 entry = byte_get (indices, 4);
6732 indices += 4;
6733
6734 if (entry >= elf_header.e_shnum)
6735 {
6736 static unsigned num_group_errors = 0;
6737
6738 if (num_group_errors ++ < 10)
6739 {
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"));
6744 }
6745 continue;
6746 }
6747
6748 if (section_headers_groups [entry] != NULL)
6749 {
6750 if (entry)
6751 {
6752 static unsigned num_errs = 0;
6753
6754 if (num_errs ++ < 10)
6755 {
6756 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6757 entry, i,
6758 section_headers_groups [entry]->group_index);
6759 if (num_errs == 10)
6760 warn (_("Further error messages about already contained group sections suppressed\n"));
6761 }
6762 continue;
6763 }
6764 else
6765 {
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;
6770 if (!warned)
6771 {
6772 error (_("section 0 in group section [%5u]\n"),
6773 section_headers_groups [entry]->group_index);
6774 warned = TRUE;
6775 }
6776 }
6777 }
6778
6779 section_headers_groups [entry] = group;
6780
6781 if (do_section_groups)
6782 {
6783 sec = section_headers + entry;
6784 printf (" [%5u] %s\n", entry, printable_section_name (sec));
6785 }
6786
6787 g = (struct group_list *) xmalloc (sizeof (struct group_list));
6788 g->section_index = entry;
6789 g->next = group->root;
6790 group->root = g;
6791 }
6792
6793 if (start)
6794 free (start);
6795
6796 group++;
6797 }
6798 }
6799
6800 if (symtab)
6801 free (symtab);
6802 if (strtab)
6803 free (strtab);
6804 return TRUE;
6805}
6806
6807/* Data used to display dynamic fixups. */
6808
6809struct ia64_vms_dynfixup
6810{
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. */
6816};
6817
6818/* Data used to display dynamic relocations. */
6819
6820struct ia64_vms_dynimgrela
6821{
6822 bfd_vma img_rela_cnt; /* Number of relocations. */
6823 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6824};
6825
6826/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6827 library). */
6828
6829static bfd_boolean
6830dump_ia64_vms_dynamic_fixups (FILE * file,
6831 struct ia64_vms_dynfixup * fixup,
6832 const char * strtab,
6833 unsigned int strtab_sz)
6834{
6835 Elf64_External_VMS_IMAGE_FIXUP * imfs;
6836 long i;
6837 const char * lib_name;
6838
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"));
6842 if (!imfs)
6843 return FALSE;
6844
6845 if (fixup->needed < strtab_sz)
6846 lib_name = strtab + fixup->needed;
6847 else
6848 {
6849 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6850 (unsigned long) fixup->needed);
6851 lib_name = "???";
6852 }
6853 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6854 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6855 printf
6856 (_("Seg Offset Type SymVec DataType\n"));
6857
6858 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6859 {
6860 unsigned int type;
6861 const char *rtype;
6862
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);
6867 if (rtype == NULL)
6868 printf (" 0x%08x ", type);
6869 else
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));
6873 }
6874
6875 free (imfs);
6876 return TRUE;
6877}
6878
6879/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6880
6881static bfd_boolean
6882dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6883{
6884 Elf64_External_VMS_IMAGE_RELA *imrs;
6885 long i;
6886
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"));
6890 if (!imrs)
6891 return FALSE;
6892
6893 printf (_("\nImage relocs\n"));
6894 printf
6895 (_("Seg Offset Type Addend Seg Sym Off\n"));
6896
6897 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6898 {
6899 unsigned int type;
6900 const char *rtype;
6901
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);
6907 if (rtype == NULL)
6908 printf ("0x%08x ", type);
6909 else
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));
6915 }
6916
6917 free (imrs);
6918 return TRUE;
6919}
6920
6921/* Display IA-64 OpenVMS dynamic relocations and fixups. */
6922
6923static bfd_boolean
6924process_ia64_vms_dynamic_relocs (FILE *file)
6925{
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;
6933
6934 memset (&fixup, 0, sizeof (fixup));
6935 memset (&imgrela, 0, sizeof (imgrela));
6936
6937 /* Note: the order of the entries is specified by the OpenVMS specs. */
6938 for (entry = dynamic_section;
6939 entry < dynamic_section + dynamic_nent;
6940 entry++)
6941 {
6942 switch (entry->d_tag)
6943 {
6944 case DT_IA_64_VMS_STRTAB_OFFSET:
6945 strtab_off = entry->d_un.d_val;
6946 break;
6947 case DT_STRSZ:
6948 strtab_sz = entry->d_un.d_val;
6949 if (strtab == NULL)
6950 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6951 1, strtab_sz, _("dynamic string section"));
6952 break;
6953
6954 case DT_IA_64_VMS_NEEDED_IDENT:
6955 fixup.needed_ident = entry->d_un.d_val;
6956 break;
6957 case DT_NEEDED:
6958 fixup.needed = entry->d_un.d_val;
6959 break;
6960 case DT_IA_64_VMS_FIXUP_NEEDED:
6961 fixup.fixup_needed = entry->d_un.d_val;
6962 break;
6963 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6964 fixup.fixup_rela_cnt = entry->d_un.d_val;
6965 break;
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))
6969 res = FALSE;
6970 break;
6971 case DT_IA_64_VMS_IMG_RELA_CNT:
6972 imgrela.img_rela_cnt = entry->d_un.d_val;
6973 break;
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))
6977 res = FALSE;
6978 break;
6979
6980 default:
6981 break;
6982 }
6983 }
6984
6985 if (strtab != NULL)
6986 free (strtab);
6987
6988 return res;
6989}
6990
6991static struct
6992{
6993 const char * name;
6994 int reloc;
6995 int size;
6996 int rela;
6997}
6998 dynamic_relocations [] =
6999{
7000 { "REL", DT_REL, DT_RELSZ, FALSE },
7001 { "RELA", DT_RELA, DT_RELASZ, TRUE },
7002 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
7003};
7004
7005/* Process the reloc section. */
7006
7007static bfd_boolean
7008process_relocs (FILE * file)
7009{
7010 unsigned long rel_size;
7011 unsigned long rel_offset;
7012
7013 if (!do_reloc)
7014 return TRUE;
7015
7016 if (do_using_dynamic)
7017 {
7018 int is_rela;
7019 const char * name;
7020 bfd_boolean has_dynamic_reloc;
7021 unsigned int i;
7022
7023 has_dynamic_reloc = FALSE;
7024
7025 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7026 {
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];
7031
7032 if (rel_size)
7033 has_dynamic_reloc = TRUE;
7034
7035 if (is_rela == UNKNOWN)
7036 {
7037 if (dynamic_relocations [i].reloc == DT_JMPREL)
7038 switch (dynamic_info[DT_PLTREL])
7039 {
7040 case DT_REL:
7041 is_rela = FALSE;
7042 break;
7043 case DT_RELA:
7044 is_rela = TRUE;
7045 break;
7046 }
7047 }
7048
7049 if (rel_size)
7050 {
7051 printf
7052 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7053 name, rel_offset, rel_size);
7054
7055 dump_relocations (file,
7056 offset_from_vma (file, rel_offset, rel_size),
7057 rel_size,
7058 dynamic_symbols, num_dynamic_syms,
7059 dynamic_strings, dynamic_strings_length,
7060 is_rela, TRUE /* is_dynamic */);
7061 }
7062 }
7063
7064 if (is_ia64_vms ())
7065 if (process_ia64_vms_dynamic_relocs (file))
7066 has_dynamic_reloc = TRUE;
7067
7068 if (! has_dynamic_reloc)
7069 printf (_("\nThere are no dynamic relocations in this file.\n"));
7070 }
7071 else
7072 {
7073 Elf_Internal_Shdr * section;
7074 unsigned long i;
7075 bfd_boolean found = FALSE;
7076
7077 for (i = 0, section = section_headers;
7078 i < elf_header.e_shnum;
7079 i++, section++)
7080 {
7081 if ( section->sh_type != SHT_RELA
7082 && section->sh_type != SHT_REL)
7083 continue;
7084
7085 rel_offset = section->sh_offset;
7086 rel_size = section->sh_size;
7087
7088 if (rel_size)
7089 {
7090 Elf_Internal_Shdr * strsec;
7091 int is_rela;
7092
7093 printf (_("\nRelocation section "));
7094
7095 if (string_table == NULL)
7096 printf ("%d", section->sh_name);
7097 else
7098 printf ("'%s'", printable_section_name (section));
7099
7100 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7101 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
7102
7103 is_rela = section->sh_type == SHT_RELA;
7104
7105 if (section->sh_link != 0
7106 && section->sh_link < elf_header.e_shnum)
7107 {
7108 Elf_Internal_Shdr * symsec;
7109 Elf_Internal_Sym * symtab;
7110 unsigned long nsyms;
7111 unsigned long strtablen = 0;
7112 char * strtab = NULL;
7113
7114 symsec = section_headers + section->sh_link;
7115 if (symsec->sh_type != SHT_SYMTAB
7116 && symsec->sh_type != SHT_DYNSYM)
7117 continue;
7118
7119 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
7120
7121 if (symtab == NULL)
7122 continue;
7123
7124 if (symsec->sh_link != 0
7125 && symsec->sh_link < elf_header.e_shnum)
7126 {
7127 strsec = section_headers + symsec->sh_link;
7128
7129 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7130 1, strsec->sh_size,
7131 _("string table"));
7132 strtablen = strtab == NULL ? 0 : strsec->sh_size;
7133 }
7134
7135 dump_relocations (file, rel_offset, rel_size,
7136 symtab, nsyms, strtab, strtablen,
7137 is_rela,
7138 symsec->sh_type == SHT_DYNSYM);
7139 if (strtab)
7140 free (strtab);
7141 free (symtab);
7142 }
7143 else
7144 dump_relocations (file, rel_offset, rel_size,
7145 NULL, 0, NULL, 0, is_rela,
7146 FALSE /* is_dynamic */);
7147
7148 found = TRUE;
7149 }
7150 }
7151
7152 if (! found)
7153 {
7154 /* Users sometimes forget the -D option, so try to be helpful. */
7155 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7156 {
7157 if (dynamic_info [dynamic_relocations [i].size])
7158 {
7159 printf (_("\nThere are no static relocations in this file."));
7160 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7161
7162 break;
7163 }
7164 }
7165 if (i == ARRAY_SIZE (dynamic_relocations))
7166 printf (_("\nThere are no relocations in this file.\n"));
7167 }
7168 }
7169
7170 return TRUE;
7171}
7172
7173/* An absolute address consists of a section and an offset. If the
7174 section is NULL, the offset itself is the address, otherwise, the
7175 address equals to LOAD_ADDRESS(section) + offset. */
7176
7177struct absaddr
7178{
7179 unsigned short section;
7180 bfd_vma offset;
7181};
7182
7183#define ABSADDR(a) \
7184 ((a).section \
7185 ? section_headers [(a).section].sh_addr + (a).offset \
7186 : (a).offset)
7187
7188/* Find the nearest symbol at or below ADDR. Returns the symbol
7189 name, if found, and the offset from the symbol to ADDR. */
7190
7191static void
7192find_symbol_for_address (Elf_Internal_Sym * symtab,
7193 unsigned long nsyms,
7194 const char * strtab,
7195 unsigned long strtab_size,
7196 struct absaddr addr,
7197 const char ** symname,
7198 bfd_vma * offset)
7199{
7200 bfd_vma dist = 0x100000;
7201 Elf_Internal_Sym * sym;
7202 Elf_Internal_Sym * beg;
7203 Elf_Internal_Sym * end;
7204 Elf_Internal_Sym * best = NULL;
7205
7206 REMOVE_ARCH_BITS (addr.offset);
7207 beg = symtab;
7208 end = symtab + nsyms;
7209
7210 while (beg < end)
7211 {
7212 bfd_vma value;
7213
7214 sym = beg + (end - beg) / 2;
7215
7216 value = sym->st_value;
7217 REMOVE_ARCH_BITS (value);
7218
7219 if (sym->st_name != 0
7220 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7221 && addr.offset >= value
7222 && addr.offset - value < dist)
7223 {
7224 best = sym;
7225 dist = addr.offset - value;
7226 if (!dist)
7227 break;
7228 }
7229
7230 if (addr.offset < value)
7231 end = sym;
7232 else
7233 beg = sym + 1;
7234 }
7235
7236 if (best)
7237 {
7238 *symname = (best->st_name >= strtab_size
7239 ? _("<corrupt>") : strtab + best->st_name);
7240 *offset = dist;
7241 return;
7242 }
7243
7244 *symname = NULL;
7245 *offset = addr.offset;
7246}
7247
7248static /* signed */ int
7249symcmp (const void *p, const void *q)
7250{
7251 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7252 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7253
7254 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7255}
7256
7257/* Process the unwind section. */
7258
7259#include "unwind-ia64.h"
7260
7261struct ia64_unw_table_entry
7262{
7263 struct absaddr start;
7264 struct absaddr end;
7265 struct absaddr info;
7266};
7267
7268struct ia64_unw_aux_info
7269{
7270 struct ia64_unw_table_entry * table; /* Unwind table. */
7271 unsigned long table_len; /* Length of unwind table. */
7272 unsigned char * info; /* Unwind info. */
7273 unsigned long info_size; /* Size of unwind info. */
7274 bfd_vma info_addr; /* Starting address of unwind info. */
7275 bfd_vma seg_base; /* Starting address of segment. */
7276 Elf_Internal_Sym * symtab; /* The symbol table. */
7277 unsigned long nsyms; /* Number of symbols. */
7278 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7279 unsigned long nfuns; /* Number of entries in funtab. */
7280 char * strtab; /* The string table. */
7281 unsigned long strtab_size; /* Size of string table. */
7282};
7283
7284static bfd_boolean
7285dump_ia64_unwind (struct ia64_unw_aux_info * aux)
7286{
7287 struct ia64_unw_table_entry * tp;
7288 unsigned long j, nfuns;
7289 int in_body;
7290 bfd_boolean res = TRUE;
7291
7292 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7293 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7294 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7295 aux->funtab[nfuns++] = aux->symtab[j];
7296 aux->nfuns = nfuns;
7297 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7298
7299 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7300 {
7301 bfd_vma stamp;
7302 bfd_vma offset;
7303 const unsigned char * dp;
7304 const unsigned char * head;
7305 const unsigned char * end;
7306 const char * procname;
7307
7308 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7309 aux->strtab_size, tp->start, &procname, &offset);
7310
7311 fputs ("\n<", stdout);
7312
7313 if (procname)
7314 {
7315 fputs (procname, stdout);
7316
7317 if (offset)
7318 printf ("+%lx", (unsigned long) offset);
7319 }
7320
7321 fputs (">: [", stdout);
7322 print_vma (tp->start.offset, PREFIX_HEX);
7323 fputc ('-', stdout);
7324 print_vma (tp->end.offset, PREFIX_HEX);
7325 printf ("], info at +0x%lx\n",
7326 (unsigned long) (tp->info.offset - aux->seg_base));
7327
7328 /* PR 17531: file: 86232b32. */
7329 if (aux->info == NULL)
7330 continue;
7331
7332 /* PR 17531: file: 0997b4d1. */
7333 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7334 {
7335 warn (_("Invalid offset %lx in table entry %ld\n"),
7336 (long) tp->info.offset, (long) (tp - aux->table));
7337 res = FALSE;
7338 continue;
7339 }
7340
7341 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
7342 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7343
7344 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7345 (unsigned) UNW_VER (stamp),
7346 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7347 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7348 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7349 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7350
7351 if (UNW_VER (stamp) != 1)
7352 {
7353 printf (_("\tUnknown version.\n"));
7354 continue;
7355 }
7356
7357 in_body = 0;
7358 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7359 /* PR 17531: file: 16ceda89. */
7360 if (end > aux->info + aux->info_size)
7361 end = aux->info + aux->info_size;
7362 for (dp = head + 8; dp < end;)
7363 dp = unw_decode (dp, in_body, & in_body, end);
7364 }
7365
7366 free (aux->funtab);
7367
7368 return res;
7369}
7370
7371static bfd_boolean
7372slurp_ia64_unwind_table (FILE * file,
7373 struct ia64_unw_aux_info * aux,
7374 Elf_Internal_Shdr * sec)
7375{
7376 unsigned long size, nrelas, i;
7377 Elf_Internal_Phdr * seg;
7378 struct ia64_unw_table_entry * tep;
7379 Elf_Internal_Shdr * relsec;
7380 Elf_Internal_Rela * rela;
7381 Elf_Internal_Rela * rp;
7382 unsigned char * table;
7383 unsigned char * tp;
7384 Elf_Internal_Sym * sym;
7385 const char * relname;
7386
7387 aux->table_len = 0;
7388
7389 /* First, find the starting address of the segment that includes
7390 this section: */
7391
7392 if (elf_header.e_phnum)
7393 {
7394 if (! get_program_headers (file))
7395 return FALSE;
7396
7397 for (seg = program_headers;
7398 seg < program_headers + elf_header.e_phnum;
7399 ++seg)
7400 {
7401 if (seg->p_type != PT_LOAD)
7402 continue;
7403
7404 if (sec->sh_addr >= seg->p_vaddr
7405 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7406 {
7407 aux->seg_base = seg->p_vaddr;
7408 break;
7409 }
7410 }
7411 }
7412
7413 /* Second, build the unwind table from the contents of the unwind section: */
7414 size = sec->sh_size;
7415 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7416 _("unwind table"));
7417 if (!table)
7418 return FALSE;
7419
7420 aux->table_len = size / (3 * eh_addr_size);
7421 aux->table = (struct ia64_unw_table_entry *)
7422 xcmalloc (aux->table_len, sizeof (aux->table[0]));
7423 tep = aux->table;
7424
7425 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7426 {
7427 tep->start.section = SHN_UNDEF;
7428 tep->end.section = SHN_UNDEF;
7429 tep->info.section = SHN_UNDEF;
7430 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7431 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7432 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7433 tep->start.offset += aux->seg_base;
7434 tep->end.offset += aux->seg_base;
7435 tep->info.offset += aux->seg_base;
7436 }
7437 free (table);
7438
7439 /* Third, apply any relocations to the unwind table: */
7440 for (relsec = section_headers;
7441 relsec < section_headers + elf_header.e_shnum;
7442 ++relsec)
7443 {
7444 if (relsec->sh_type != SHT_RELA
7445 || relsec->sh_info >= elf_header.e_shnum
7446 || section_headers + relsec->sh_info != sec)
7447 continue;
7448
7449 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7450 & rela, & nrelas))
7451 {
7452 free (aux->table);
7453 aux->table = NULL;
7454 aux->table_len = 0;
7455 return FALSE;
7456 }
7457
7458 for (rp = rela; rp < rela + nrelas; ++rp)
7459 {
7460 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
7461 sym = aux->symtab + get_reloc_symindex (rp->r_info);
7462
7463 /* PR 17531: file: 9fa67536. */
7464 if (relname == NULL)
7465 {
7466 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
7467 continue;
7468 }
7469
7470 if (! const_strneq (relname, "R_IA64_SEGREL"))
7471 {
7472 warn (_("Skipping unexpected relocation type: %s\n"), relname);
7473 continue;
7474 }
7475
7476 i = rp->r_offset / (3 * eh_addr_size);
7477
7478 /* PR 17531: file: 5bc8d9bf. */
7479 if (i >= aux->table_len)
7480 {
7481 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7482 continue;
7483 }
7484
7485 switch (rp->r_offset / eh_addr_size % 3)
7486 {
7487 case 0:
7488 aux->table[i].start.section = sym->st_shndx;
7489 aux->table[i].start.offset = rp->r_addend + sym->st_value;
7490 break;
7491 case 1:
7492 aux->table[i].end.section = sym->st_shndx;
7493 aux->table[i].end.offset = rp->r_addend + sym->st_value;
7494 break;
7495 case 2:
7496 aux->table[i].info.section = sym->st_shndx;
7497 aux->table[i].info.offset = rp->r_addend + sym->st_value;
7498 break;
7499 default:
7500 break;
7501 }
7502 }
7503
7504 free (rela);
7505 }
7506
7507 return TRUE;
7508}
7509
7510static bfd_boolean
7511ia64_process_unwind (FILE * file)
7512{
7513 Elf_Internal_Shdr * sec;
7514 Elf_Internal_Shdr * unwsec = NULL;
7515 Elf_Internal_Shdr * strsec;
7516 unsigned long i, unwcount = 0, unwstart = 0;
7517 struct ia64_unw_aux_info aux;
7518 bfd_boolean res = TRUE;
7519
7520 memset (& aux, 0, sizeof (aux));
7521
7522 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7523 {
7524 if (sec->sh_type == SHT_SYMTAB
7525 && sec->sh_link < elf_header.e_shnum)
7526 {
7527 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7528
7529 strsec = section_headers + sec->sh_link;
7530 if (aux.strtab != NULL)
7531 {
7532 error (_("Multiple auxillary string tables encountered\n"));
7533 free (aux.strtab);
7534 res = FALSE;
7535 }
7536 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7537 1, strsec->sh_size,
7538 _("string table"));
7539 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7540 }
7541 else if (sec->sh_type == SHT_IA_64_UNWIND)
7542 unwcount++;
7543 }
7544
7545 if (!unwcount)
7546 printf (_("\nThere are no unwind sections in this file.\n"));
7547
7548 while (unwcount-- > 0)
7549 {
7550 char * suffix;
7551 size_t len, len2;
7552
7553 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
7554 i < elf_header.e_shnum; ++i, ++sec)
7555 if (sec->sh_type == SHT_IA_64_UNWIND)
7556 {
7557 unwsec = sec;
7558 break;
7559 }
7560 /* We have already counted the number of SHT_IA64_UNWIND
7561 sections so the loop above should never fail. */
7562 assert (unwsec != NULL);
7563
7564 unwstart = i + 1;
7565 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7566
7567 if ((unwsec->sh_flags & SHF_GROUP) != 0)
7568 {
7569 /* We need to find which section group it is in. */
7570 struct group_list * g;
7571
7572 if (section_headers_groups == NULL
7573 || section_headers_groups [i] == NULL)
7574 i = elf_header.e_shnum;
7575 else
7576 {
7577 g = section_headers_groups [i]->root;
7578
7579 for (; g != NULL; g = g->next)
7580 {
7581 sec = section_headers + g->section_index;
7582
7583 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7584 break;
7585 }
7586
7587 if (g == NULL)
7588 i = elf_header.e_shnum;
7589 }
7590 }
7591 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7592 {
7593 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7594 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7595 suffix = SECTION_NAME (unwsec) + len;
7596 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7597 ++i, ++sec)
7598 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7599 && streq (SECTION_NAME (sec) + len2, suffix))
7600 break;
7601 }
7602 else
7603 {
7604 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7605 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7606 len = sizeof (ELF_STRING_ia64_unwind) - 1;
7607 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7608 suffix = "";
7609 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7610 suffix = SECTION_NAME (unwsec) + len;
7611 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7612 ++i, ++sec)
7613 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7614 && streq (SECTION_NAME (sec) + len2, suffix))
7615 break;
7616 }
7617
7618 if (i == elf_header.e_shnum)
7619 {
7620 printf (_("\nCould not find unwind info section for "));
7621
7622 if (string_table == NULL)
7623 printf ("%d", unwsec->sh_name);
7624 else
7625 printf ("'%s'", printable_section_name (unwsec));
7626 }
7627 else
7628 {
7629 aux.info_addr = sec->sh_addr;
7630 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
7631 sec->sh_size,
7632 _("unwind info"));
7633 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7634
7635 printf (_("\nUnwind section "));
7636
7637 if (string_table == NULL)
7638 printf ("%d", unwsec->sh_name);
7639 else
7640 printf ("'%s'", printable_section_name (unwsec));
7641
7642 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7643 (unsigned long) unwsec->sh_offset,
7644 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7645
7646 if (slurp_ia64_unwind_table (file, & aux, unwsec)
7647 && aux.table_len > 0)
7648 dump_ia64_unwind (& aux);
7649
7650 if (aux.table)
7651 free ((char *) aux.table);
7652 if (aux.info)
7653 free ((char *) aux.info);
7654 aux.table = NULL;
7655 aux.info = NULL;
7656 }
7657 }
7658
7659 if (aux.symtab)
7660 free (aux.symtab);
7661 if (aux.strtab)
7662 free ((char *) aux.strtab);
7663
7664 return res;
7665}
7666
7667struct hppa_unw_table_entry
7668{
7669 struct absaddr start;
7670 struct absaddr end;
7671 unsigned int Cannot_unwind:1; /* 0 */
7672 unsigned int Millicode:1; /* 1 */
7673 unsigned int Millicode_save_sr0:1; /* 2 */
7674 unsigned int Region_description:2; /* 3..4 */
7675 unsigned int reserved1:1; /* 5 */
7676 unsigned int Entry_SR:1; /* 6 */
7677 unsigned int Entry_FR:4; /* Number saved 7..10 */
7678 unsigned int Entry_GR:5; /* Number saved 11..15 */
7679 unsigned int Args_stored:1; /* 16 */
7680 unsigned int Variable_Frame:1; /* 17 */
7681 unsigned int Separate_Package_Body:1; /* 18 */
7682 unsigned int Frame_Extension_Millicode:1; /* 19 */
7683 unsigned int Stack_Overflow_Check:1; /* 20 */
7684 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
7685 unsigned int Ada_Region:1; /* 22 */
7686 unsigned int cxx_info:1; /* 23 */
7687 unsigned int cxx_try_catch:1; /* 24 */
7688 unsigned int sched_entry_seq:1; /* 25 */
7689 unsigned int reserved2:1; /* 26 */
7690 unsigned int Save_SP:1; /* 27 */
7691 unsigned int Save_RP:1; /* 28 */
7692 unsigned int Save_MRP_in_frame:1; /* 29 */
7693 unsigned int extn_ptr_defined:1; /* 30 */
7694 unsigned int Cleanup_defined:1; /* 31 */
7695
7696 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
7697 unsigned int HP_UX_interrupt_marker:1; /* 1 */
7698 unsigned int Large_frame:1; /* 2 */
7699 unsigned int Pseudo_SP_Set:1; /* 3 */
7700 unsigned int reserved4:1; /* 4 */
7701 unsigned int Total_frame_size:27; /* 5..31 */
7702};
7703
7704struct hppa_unw_aux_info
7705{
7706 struct hppa_unw_table_entry * table; /* Unwind table. */
7707 unsigned long table_len; /* Length of unwind table. */
7708 bfd_vma seg_base; /* Starting address of segment. */
7709 Elf_Internal_Sym * symtab; /* The symbol table. */
7710 unsigned long nsyms; /* Number of symbols. */
7711 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7712 unsigned long nfuns; /* Number of entries in funtab. */
7713 char * strtab; /* The string table. */
7714 unsigned long strtab_size; /* Size of string table. */
7715};
7716
7717static bfd_boolean
7718dump_hppa_unwind (struct hppa_unw_aux_info * aux)
7719{
7720 struct hppa_unw_table_entry * tp;
7721 unsigned long j, nfuns;
7722 bfd_boolean res = TRUE;
7723
7724 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7725 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7726 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7727 aux->funtab[nfuns++] = aux->symtab[j];
7728 aux->nfuns = nfuns;
7729 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7730
7731 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7732 {
7733 bfd_vma offset;
7734 const char * procname;
7735
7736 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7737 aux->strtab_size, tp->start, &procname,
7738 &offset);
7739
7740 fputs ("\n<", stdout);
7741
7742 if (procname)
7743 {
7744 fputs (procname, stdout);
7745
7746 if (offset)
7747 printf ("+%lx", (unsigned long) offset);
7748 }
7749
7750 fputs (">: [", stdout);
7751 print_vma (tp->start.offset, PREFIX_HEX);
7752 fputc ('-', stdout);
7753 print_vma (tp->end.offset, PREFIX_HEX);
7754 printf ("]\n\t");
7755
7756#define PF(_m) if (tp->_m) printf (#_m " ");
7757#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7758 PF(Cannot_unwind);
7759 PF(Millicode);
7760 PF(Millicode_save_sr0);
7761 /* PV(Region_description); */
7762 PF(Entry_SR);
7763 PV(Entry_FR);
7764 PV(Entry_GR);
7765 PF(Args_stored);
7766 PF(Variable_Frame);
7767 PF(Separate_Package_Body);
7768 PF(Frame_Extension_Millicode);
7769 PF(Stack_Overflow_Check);
7770 PF(Two_Instruction_SP_Increment);
7771 PF(Ada_Region);
7772 PF(cxx_info);
7773 PF(cxx_try_catch);
7774 PF(sched_entry_seq);
7775 PF(Save_SP);
7776 PF(Save_RP);
7777 PF(Save_MRP_in_frame);
7778 PF(extn_ptr_defined);
7779 PF(Cleanup_defined);
7780 PF(MPE_XL_interrupt_marker);
7781 PF(HP_UX_interrupt_marker);
7782 PF(Large_frame);
7783 PF(Pseudo_SP_Set);
7784 PV(Total_frame_size);
7785#undef PF
7786#undef PV
7787 }
7788
7789 printf ("\n");
7790
7791 free (aux->funtab);
7792
7793 return res;
7794}
7795
7796static bfd_boolean
7797slurp_hppa_unwind_table (FILE * file,
7798 struct hppa_unw_aux_info * aux,
7799 Elf_Internal_Shdr * sec)
7800{
7801 unsigned long size, unw_ent_size, nentries, nrelas, i;
7802 Elf_Internal_Phdr * seg;
7803 struct hppa_unw_table_entry * tep;
7804 Elf_Internal_Shdr * relsec;
7805 Elf_Internal_Rela * rela;
7806 Elf_Internal_Rela * rp;
7807 unsigned char * table;
7808 unsigned char * tp;
7809 Elf_Internal_Sym * sym;
7810 const char * relname;
7811
7812 /* First, find the starting address of the segment that includes
7813 this section. */
7814 if (elf_header.e_phnum)
7815 {
7816 if (! get_program_headers (file))
7817 return FALSE;
7818
7819 for (seg = program_headers;
7820 seg < program_headers + elf_header.e_phnum;
7821 ++seg)
7822 {
7823 if (seg->p_type != PT_LOAD)
7824 continue;
7825
7826 if (sec->sh_addr >= seg->p_vaddr
7827 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7828 {
7829 aux->seg_base = seg->p_vaddr;
7830 break;
7831 }
7832 }
7833 }
7834
7835 /* Second, build the unwind table from the contents of the unwind
7836 section. */
7837 size = sec->sh_size;
7838 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7839 _("unwind table"));
7840 if (!table)
7841 return FALSE;
7842
7843 unw_ent_size = 16;
7844 nentries = size / unw_ent_size;
7845 size = unw_ent_size * nentries;
7846
7847 tep = aux->table = (struct hppa_unw_table_entry *)
7848 xcmalloc (nentries, sizeof (aux->table[0]));
7849
7850 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7851 {
7852 unsigned int tmp1, tmp2;
7853
7854 tep->start.section = SHN_UNDEF;
7855 tep->end.section = SHN_UNDEF;
7856
7857 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7858 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7859 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7860 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7861
7862 tep->start.offset += aux->seg_base;
7863 tep->end.offset += aux->seg_base;
7864
7865 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7866 tep->Millicode = (tmp1 >> 30) & 0x1;
7867 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7868 tep->Region_description = (tmp1 >> 27) & 0x3;
7869 tep->reserved1 = (tmp1 >> 26) & 0x1;
7870 tep->Entry_SR = (tmp1 >> 25) & 0x1;
7871 tep->Entry_FR = (tmp1 >> 21) & 0xf;
7872 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7873 tep->Args_stored = (tmp1 >> 15) & 0x1;
7874 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7875 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7876 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7877 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7878 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7879 tep->Ada_Region = (tmp1 >> 9) & 0x1;
7880 tep->cxx_info = (tmp1 >> 8) & 0x1;
7881 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7882 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7883 tep->reserved2 = (tmp1 >> 5) & 0x1;
7884 tep->Save_SP = (tmp1 >> 4) & 0x1;
7885 tep->Save_RP = (tmp1 >> 3) & 0x1;
7886 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7887 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7888 tep->Cleanup_defined = tmp1 & 0x1;
7889
7890 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7891 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7892 tep->Large_frame = (tmp2 >> 29) & 0x1;
7893 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7894 tep->reserved4 = (tmp2 >> 27) & 0x1;
7895 tep->Total_frame_size = tmp2 & 0x7ffffff;
7896 }
7897 free (table);
7898
7899 /* Third, apply any relocations to the unwind table. */
7900 for (relsec = section_headers;
7901 relsec < section_headers + elf_header.e_shnum;
7902 ++relsec)
7903 {
7904 if (relsec->sh_type != SHT_RELA
7905 || relsec->sh_info >= elf_header.e_shnum
7906 || section_headers + relsec->sh_info != sec)
7907 continue;
7908
7909 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7910 & rela, & nrelas))
7911 return FALSE;
7912
7913 for (rp = rela; rp < rela + nrelas; ++rp)
7914 {
7915 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7916 sym = aux->symtab + get_reloc_symindex (rp->r_info);
7917
7918 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7919 if (! const_strneq (relname, "R_PARISC_SEGREL"))
7920 {
7921 warn (_("Skipping unexpected relocation type %s\n"), relname);
7922 continue;
7923 }
7924
7925 i = rp->r_offset / unw_ent_size;
7926
7927 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
7928 {
7929 case 0:
7930 aux->table[i].start.section = sym->st_shndx;
7931 aux->table[i].start.offset = sym->st_value + rp->r_addend;
7932 break;
7933 case 1:
7934 aux->table[i].end.section = sym->st_shndx;
7935 aux->table[i].end.offset = sym->st_value + rp->r_addend;
7936 break;
7937 default:
7938 break;
7939 }
7940 }
7941
7942 free (rela);
7943 }
7944
7945 aux->table_len = nentries;
7946
7947 return TRUE;
7948}
7949
7950static bfd_boolean
7951hppa_process_unwind (FILE * file)
7952{
7953 struct hppa_unw_aux_info aux;
7954 Elf_Internal_Shdr * unwsec = NULL;
7955 Elf_Internal_Shdr * strsec;
7956 Elf_Internal_Shdr * sec;
7957 unsigned long i;
7958 bfd_boolean res = TRUE;
7959
7960 if (string_table == NULL)
7961 return FALSE;
7962
7963 memset (& aux, 0, sizeof (aux));
7964
7965 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7966 {
7967 if (sec->sh_type == SHT_SYMTAB
7968 && sec->sh_link < elf_header.e_shnum)
7969 {
7970 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7971
7972 strsec = section_headers + sec->sh_link;
7973 if (aux.strtab != NULL)
7974 {
7975 error (_("Multiple auxillary string tables encountered\n"));
7976 free (aux.strtab);
7977 res = FALSE;
7978 }
7979 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7980 1, strsec->sh_size,
7981 _("string table"));
7982 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7983 }
7984 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7985 unwsec = sec;
7986 }
7987
7988 if (!unwsec)
7989 printf (_("\nThere are no unwind sections in this file.\n"));
7990
7991 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7992 {
7993 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7994 {
7995 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7996 printable_section_name (sec),
7997 (unsigned long) sec->sh_offset,
7998 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
7999
8000 if (! slurp_hppa_unwind_table (file, &aux, sec))
8001 res = FALSE;
8002
8003 if (aux.table_len > 0)
8004 {
8005 if (! dump_hppa_unwind (&aux))
8006 res = FALSE;
8007 }
8008
8009 if (aux.table)
8010 free ((char *) aux.table);
8011 aux.table = NULL;
8012 }
8013 }
8014
8015 if (aux.symtab)
8016 free (aux.symtab);
8017 if (aux.strtab)
8018 free ((char *) aux.strtab);
8019
8020 return res;
8021}
8022
8023struct arm_section
8024{
8025 unsigned char * data; /* The unwind data. */
8026 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
8027 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
8028 unsigned long nrelas; /* The number of relocations. */
8029 unsigned int rel_type; /* REL or RELA ? */
8030 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
8031};
8032
8033struct arm_unw_aux_info
8034{
8035 FILE * file; /* The file containing the unwind sections. */
8036 Elf_Internal_Sym * symtab; /* The file's symbol table. */
8037 unsigned long nsyms; /* Number of symbols. */
8038 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
8039 unsigned long nfuns; /* Number of these symbols. */
8040 char * strtab; /* The file's string table. */
8041 unsigned long strtab_size; /* Size of string table. */
8042};
8043
8044static const char *
8045arm_print_vma_and_name (struct arm_unw_aux_info *aux,
8046 bfd_vma fn, struct absaddr addr)
8047{
8048 const char *procname;
8049 bfd_vma sym_offset;
8050
8051 if (addr.section == SHN_UNDEF)
8052 addr.offset = fn;
8053
8054 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
8055 aux->strtab_size, addr, &procname,
8056 &sym_offset);
8057
8058 print_vma (fn, PREFIX_HEX);
8059
8060 if (procname)
8061 {
8062 fputs (" <", stdout);
8063 fputs (procname, stdout);
8064
8065 if (sym_offset)
8066 printf ("+0x%lx", (unsigned long) sym_offset);
8067 fputc ('>', stdout);
8068 }
8069
8070 return procname;
8071}
8072
8073static void
8074arm_free_section (struct arm_section *arm_sec)
8075{
8076 if (arm_sec->data != NULL)
8077 free (arm_sec->data);
8078
8079 if (arm_sec->rela != NULL)
8080 free (arm_sec->rela);
8081}
8082
8083/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8084 cached section and install SEC instead.
8085 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8086 and return its valued in * WORDP, relocating if necessary.
8087 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8088 relocation's offset in ADDR.
8089 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8090 into the string table of the symbol associated with the reloc. If no
8091 reloc was applied store -1 there.
8092 5) Return TRUE upon success, FALSE otherwise. */
8093
8094static bfd_boolean
8095get_unwind_section_word (struct arm_unw_aux_info * aux,
8096 struct arm_section * arm_sec,
8097 Elf_Internal_Shdr * sec,
8098 bfd_vma word_offset,
8099 unsigned int * wordp,
8100 struct absaddr * addr,
8101 bfd_vma * sym_name)
8102{
8103 Elf_Internal_Rela *rp;
8104 Elf_Internal_Sym *sym;
8105 const char * relname;
8106 unsigned int word;
8107 bfd_boolean wrapped;
8108
8109 if (sec == NULL || arm_sec == NULL)
8110 return FALSE;
8111
8112 addr->section = SHN_UNDEF;
8113 addr->offset = 0;
8114
8115 if (sym_name != NULL)
8116 *sym_name = (bfd_vma) -1;
8117
8118 /* If necessary, update the section cache. */
8119 if (sec != arm_sec->sec)
8120 {
8121 Elf_Internal_Shdr *relsec;
8122
8123 arm_free_section (arm_sec);
8124
8125 arm_sec->sec = sec;
8126 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
8127 sec->sh_size, _("unwind data"));
8128 arm_sec->rela = NULL;
8129 arm_sec->nrelas = 0;
8130
8131 for (relsec = section_headers;
8132 relsec < section_headers + elf_header.e_shnum;
8133 ++relsec)
8134 {
8135 if (relsec->sh_info >= elf_header.e_shnum
8136 || section_headers + relsec->sh_info != sec
8137 /* PR 15745: Check the section type as well. */
8138 || (relsec->sh_type != SHT_REL
8139 && relsec->sh_type != SHT_RELA))
8140 continue;
8141
8142 arm_sec->rel_type = relsec->sh_type;
8143 if (relsec->sh_type == SHT_REL)
8144 {
8145 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
8146 relsec->sh_size,
8147 & arm_sec->rela, & arm_sec->nrelas))
8148 return FALSE;
8149 }
8150 else /* relsec->sh_type == SHT_RELA */
8151 {
8152 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
8153 relsec->sh_size,
8154 & arm_sec->rela, & arm_sec->nrelas))
8155 return FALSE;
8156 }
8157 break;
8158 }
8159
8160 arm_sec->next_rela = arm_sec->rela;
8161 }
8162
8163 /* If there is no unwind data we can do nothing. */
8164 if (arm_sec->data == NULL)
8165 return FALSE;
8166
8167 /* If the offset is invalid then fail. */
8168 if (/* PR 21343 *//* PR 18879 */
8169 sec->sh_size < 4
8170 || word_offset > (sec->sh_size - 4)
8171 || ((bfd_signed_vma) word_offset) < 0)
8172 return FALSE;
8173
8174 /* Get the word at the required offset. */
8175 word = byte_get (arm_sec->data + word_offset, 4);
8176
8177 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8178 if (arm_sec->rela == NULL)
8179 {
8180 * wordp = word;
8181 return TRUE;
8182 }
8183
8184 /* Look through the relocs to find the one that applies to the provided offset. */
8185 wrapped = FALSE;
8186 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8187 {
8188 bfd_vma prelval, offset;
8189
8190 if (rp->r_offset > word_offset && !wrapped)
8191 {
8192 rp = arm_sec->rela;
8193 wrapped = TRUE;
8194 }
8195 if (rp->r_offset > word_offset)
8196 break;
8197
8198 if (rp->r_offset & 3)
8199 {
8200 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8201 (unsigned long) rp->r_offset);
8202 continue;
8203 }
8204
8205 if (rp->r_offset < word_offset)
8206 continue;
8207
8208 /* PR 17531: file: 027-161405-0.004 */
8209 if (aux->symtab == NULL)
8210 continue;
8211
8212 if (arm_sec->rel_type == SHT_REL)
8213 {
8214 offset = word & 0x7fffffff;
8215 if (offset & 0x40000000)
8216 offset |= ~ (bfd_vma) 0x7fffffff;
8217 }
8218 else if (arm_sec->rel_type == SHT_RELA)
8219 offset = rp->r_addend;
8220 else
8221 {
8222 error (_("Unknown section relocation type %d encountered\n"),
8223 arm_sec->rel_type);
8224 break;
8225 }
8226
8227 /* PR 17531 file: 027-1241568-0.004. */
8228 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8229 {
8230 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8231 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8232 break;
8233 }
8234
8235 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8236 offset += sym->st_value;
8237 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8238
8239 /* Check that we are processing the expected reloc type. */
8240 if (elf_header.e_machine == EM_ARM)
8241 {
8242 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8243 if (relname == NULL)
8244 {
8245 warn (_("Skipping unknown ARM relocation type: %d\n"),
8246 (int) ELF32_R_TYPE (rp->r_info));
8247 continue;
8248 }
8249
8250 if (streq (relname, "R_ARM_NONE"))
8251 continue;
8252
8253 if (! streq (relname, "R_ARM_PREL31"))
8254 {
8255 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8256 continue;
8257 }
8258 }
8259 else if (elf_header.e_machine == EM_TI_C6000)
8260 {
8261 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8262 if (relname == NULL)
8263 {
8264 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8265 (int) ELF32_R_TYPE (rp->r_info));
8266 continue;
8267 }
8268
8269 if (streq (relname, "R_C6000_NONE"))
8270 continue;
8271
8272 if (! streq (relname, "R_C6000_PREL31"))
8273 {
8274 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8275 continue;
8276 }
8277
8278 prelval >>= 1;
8279 }
8280 else
8281 {
8282 /* This function currently only supports ARM and TI unwinders. */
8283 warn (_("Only TI and ARM unwinders are currently supported\n"));
8284 break;
8285 }
8286
8287 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8288 addr->section = sym->st_shndx;
8289 addr->offset = offset;
8290
8291 if (sym_name)
8292 * sym_name = sym->st_name;
8293 break;
8294 }
8295
8296 *wordp = word;
8297 arm_sec->next_rela = rp;
8298
8299 return TRUE;
8300}
8301
8302static const char *tic6x_unwind_regnames[16] =
8303{
8304 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8305 "A14", "A13", "A12", "A11", "A10",
8306 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8307};
8308
8309static void
8310decode_tic6x_unwind_regmask (unsigned int mask)
8311{
8312 int i;
8313
8314 for (i = 12; mask; mask >>= 1, i--)
8315 {
8316 if (mask & 1)
8317 {
8318 fputs (tic6x_unwind_regnames[i], stdout);
8319 if (mask > 1)
8320 fputs (", ", stdout);
8321 }
8322 }
8323}
8324
8325#define ADVANCE \
8326 if (remaining == 0 && more_words) \
8327 { \
8328 data_offset += 4; \
8329 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
8330 data_offset, & word, & addr, NULL)) \
8331 return FALSE; \
8332 remaining = 4; \
8333 more_words--; \
8334 } \
8335
8336#define GET_OP(OP) \
8337 ADVANCE; \
8338 if (remaining) \
8339 { \
8340 remaining--; \
8341 (OP) = word >> 24; \
8342 word <<= 8; \
8343 } \
8344 else \
8345 { \
8346 printf (_("[Truncated opcode]\n")); \
8347 return FALSE; \
8348 } \
8349 printf ("0x%02x ", OP)
8350
8351static bfd_boolean
8352decode_arm_unwind_bytecode (struct arm_unw_aux_info * aux,
8353 unsigned int word,
8354 unsigned int remaining,
8355 unsigned int more_words,
8356 bfd_vma data_offset,
8357 Elf_Internal_Shdr * data_sec,
8358 struct arm_section * data_arm_sec)
8359{
8360 struct absaddr addr;
8361 bfd_boolean res = TRUE;
8362
8363 /* Decode the unwinding instructions. */
8364 while (1)
8365 {
8366 unsigned int op, op2;
8367
8368 ADVANCE;
8369 if (remaining == 0)
8370 break;
8371 remaining--;
8372 op = word >> 24;
8373 word <<= 8;
8374
8375 printf (" 0x%02x ", op);
8376
8377 if ((op & 0xc0) == 0x00)
8378 {
8379 int offset = ((op & 0x3f) << 2) + 4;
8380
8381 printf (" vsp = vsp + %d", offset);
8382 }
8383 else if ((op & 0xc0) == 0x40)
8384 {
8385 int offset = ((op & 0x3f) << 2) + 4;
8386
8387 printf (" vsp = vsp - %d", offset);
8388 }
8389 else if ((op & 0xf0) == 0x80)
8390 {
8391 GET_OP (op2);
8392 if (op == 0x80 && op2 == 0)
8393 printf (_("Refuse to unwind"));
8394 else
8395 {
8396 unsigned int mask = ((op & 0x0f) << 8) | op2;
8397 bfd_boolean first = TRUE;
8398 int i;
8399
8400 printf ("pop {");
8401 for (i = 0; i < 12; i++)
8402 if (mask & (1 << i))
8403 {
8404 if (first)
8405 first = FALSE;
8406 else
8407 printf (", ");
8408 printf ("r%d", 4 + i);
8409 }
8410 printf ("}");
8411 }
8412 }
8413 else if ((op & 0xf0) == 0x90)
8414 {
8415 if (op == 0x9d || op == 0x9f)
8416 printf (_(" [Reserved]"));
8417 else
8418 printf (" vsp = r%d", op & 0x0f);
8419 }
8420 else if ((op & 0xf0) == 0xa0)
8421 {
8422 int end = 4 + (op & 0x07);
8423 bfd_boolean first = TRUE;
8424 int i;
8425
8426 printf (" pop {");
8427 for (i = 4; i <= end; i++)
8428 {
8429 if (first)
8430 first = FALSE;
8431 else
8432 printf (", ");
8433 printf ("r%d", i);
8434 }
8435 if (op & 0x08)
8436 {
8437 if (!first)
8438 printf (", ");
8439 printf ("r14");
8440 }
8441 printf ("}");
8442 }
8443 else if (op == 0xb0)
8444 printf (_(" finish"));
8445 else if (op == 0xb1)
8446 {
8447 GET_OP (op2);
8448 if (op2 == 0 || (op2 & 0xf0) != 0)
8449 printf (_("[Spare]"));
8450 else
8451 {
8452 unsigned int mask = op2 & 0x0f;
8453 bfd_boolean first = TRUE;
8454 int i;
8455
8456 printf ("pop {");
8457 for (i = 0; i < 12; i++)
8458 if (mask & (1 << i))
8459 {
8460 if (first)
8461 first = FALSE;
8462 else
8463 printf (", ");
8464 printf ("r%d", i);
8465 }
8466 printf ("}");
8467 }
8468 }
8469 else if (op == 0xb2)
8470 {
8471 unsigned char buf[9];
8472 unsigned int i, len;
8473 unsigned long offset;
8474
8475 for (i = 0; i < sizeof (buf); i++)
8476 {
8477 GET_OP (buf[i]);
8478 if ((buf[i] & 0x80) == 0)
8479 break;
8480 }
8481 if (i == sizeof (buf))
8482 {
8483 error (_("corrupt change to vsp"));
8484 res = FALSE;
8485 }
8486 else
8487 {
8488 offset = read_uleb128 (buf, &len, buf + i + 1);
8489 assert (len == i + 1);
8490 offset = offset * 4 + 0x204;
8491 printf ("vsp = vsp + %ld", offset);
8492 }
8493 }
8494 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8495 {
8496 unsigned int first, last;
8497
8498 GET_OP (op2);
8499 first = op2 >> 4;
8500 last = op2 & 0x0f;
8501 if (op == 0xc8)
8502 first = first + 16;
8503 printf ("pop {D%d", first);
8504 if (last)
8505 printf ("-D%d", first + last);
8506 printf ("}");
8507 }
8508 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8509 {
8510 unsigned int count = op & 0x07;
8511
8512 printf ("pop {D8");
8513 if (count)
8514 printf ("-D%d", 8 + count);
8515 printf ("}");
8516 }
8517 else if (op >= 0xc0 && op <= 0xc5)
8518 {
8519 unsigned int count = op & 0x07;
8520
8521 printf (" pop {wR10");
8522 if (count)
8523 printf ("-wR%d", 10 + count);
8524 printf ("}");
8525 }
8526 else if (op == 0xc6)
8527 {
8528 unsigned int first, last;
8529
8530 GET_OP (op2);
8531 first = op2 >> 4;
8532 last = op2 & 0x0f;
8533 printf ("pop {wR%d", first);
8534 if (last)
8535 printf ("-wR%d", first + last);
8536 printf ("}");
8537 }
8538 else if (op == 0xc7)
8539 {
8540 GET_OP (op2);
8541 if (op2 == 0 || (op2 & 0xf0) != 0)
8542 printf (_("[Spare]"));
8543 else
8544 {
8545 unsigned int mask = op2 & 0x0f;
8546 bfd_boolean first = TRUE;
8547 int i;
8548
8549 printf ("pop {");
8550 for (i = 0; i < 4; i++)
8551 if (mask & (1 << i))
8552 {
8553 if (first)
8554 first = FALSE;
8555 else
8556 printf (", ");
8557 printf ("wCGR%d", i);
8558 }
8559 printf ("}");
8560 }
8561 }
8562 else
8563 {
8564 printf (_(" [unsupported opcode]"));
8565 res = FALSE;
8566 }
8567
8568 printf ("\n");
8569 }
8570
8571 return res;
8572}
8573
8574static bfd_boolean
8575decode_tic6x_unwind_bytecode (struct arm_unw_aux_info * aux,
8576 unsigned int word,
8577 unsigned int remaining,
8578 unsigned int more_words,
8579 bfd_vma data_offset,
8580 Elf_Internal_Shdr * data_sec,
8581 struct arm_section * data_arm_sec)
8582{
8583 struct absaddr addr;
8584
8585 /* Decode the unwinding instructions. */
8586 while (1)
8587 {
8588 unsigned int op, op2;
8589
8590 ADVANCE;
8591 if (remaining == 0)
8592 break;
8593 remaining--;
8594 op = word >> 24;
8595 word <<= 8;
8596
8597 printf (" 0x%02x ", op);
8598
8599 if ((op & 0xc0) == 0x00)
8600 {
8601 int offset = ((op & 0x3f) << 3) + 8;
8602 printf (" sp = sp + %d", offset);
8603 }
8604 else if ((op & 0xc0) == 0x80)
8605 {
8606 GET_OP (op2);
8607 if (op == 0x80 && op2 == 0)
8608 printf (_("Refuse to unwind"));
8609 else
8610 {
8611 unsigned int mask = ((op & 0x1f) << 8) | op2;
8612 if (op & 0x20)
8613 printf ("pop compact {");
8614 else
8615 printf ("pop {");
8616
8617 decode_tic6x_unwind_regmask (mask);
8618 printf("}");
8619 }
8620 }
8621 else if ((op & 0xf0) == 0xc0)
8622 {
8623 unsigned int reg;
8624 unsigned int nregs;
8625 unsigned int i;
8626 const char *name;
8627 struct
8628 {
8629 unsigned int offset;
8630 unsigned int reg;
8631 } regpos[16];
8632
8633 /* Scan entire instruction first so that GET_OP output is not
8634 interleaved with disassembly. */
8635 nregs = 0;
8636 for (i = 0; nregs < (op & 0xf); i++)
8637 {
8638 GET_OP (op2);
8639 reg = op2 >> 4;
8640 if (reg != 0xf)
8641 {
8642 regpos[nregs].offset = i * 2;
8643 regpos[nregs].reg = reg;
8644 nregs++;
8645 }
8646
8647 reg = op2 & 0xf;
8648 if (reg != 0xf)
8649 {
8650 regpos[nregs].offset = i * 2 + 1;
8651 regpos[nregs].reg = reg;
8652 nregs++;
8653 }
8654 }
8655
8656 printf (_("pop frame {"));
8657 reg = nregs - 1;
8658 for (i = i * 2; i > 0; i--)
8659 {
8660 if (regpos[reg].offset == i - 1)
8661 {
8662 name = tic6x_unwind_regnames[regpos[reg].reg];
8663 if (reg > 0)
8664 reg--;
8665 }
8666 else
8667 name = _("[pad]");
8668
8669 fputs (name, stdout);
8670 if (i > 1)
8671 printf (", ");
8672 }
8673
8674 printf ("}");
8675 }
8676 else if (op == 0xd0)
8677 printf (" MOV FP, SP");
8678 else if (op == 0xd1)
8679 printf (" __c6xabi_pop_rts");
8680 else if (op == 0xd2)
8681 {
8682 unsigned char buf[9];
8683 unsigned int i, len;
8684 unsigned long offset;
8685
8686 for (i = 0; i < sizeof (buf); i++)
8687 {
8688 GET_OP (buf[i]);
8689 if ((buf[i] & 0x80) == 0)
8690 break;
8691 }
8692 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8693 if (i == sizeof (buf))
8694 {
8695 warn (_("Corrupt stack pointer adjustment detected\n"));
8696 return FALSE;
8697 }
8698
8699 offset = read_uleb128 (buf, &len, buf + i + 1);
8700 assert (len == i + 1);
8701 offset = offset * 8 + 0x408;
8702 printf (_("sp = sp + %ld"), offset);
8703 }
8704 else if ((op & 0xf0) == 0xe0)
8705 {
8706 if ((op & 0x0f) == 7)
8707 printf (" RETURN");
8708 else
8709 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8710 }
8711 else
8712 {
8713 printf (_(" [unsupported opcode]"));
8714 }
8715 putchar ('\n');
8716 }
8717
8718 return TRUE;
8719}
8720
8721static bfd_vma
8722arm_expand_prel31 (bfd_vma word, bfd_vma where)
8723{
8724 bfd_vma offset;
8725
8726 offset = word & 0x7fffffff;
8727 if (offset & 0x40000000)
8728 offset |= ~ (bfd_vma) 0x7fffffff;
8729
8730 if (elf_header.e_machine == EM_TI_C6000)
8731 offset <<= 1;
8732
8733 return offset + where;
8734}
8735
8736static bfd_boolean
8737decode_arm_unwind (struct arm_unw_aux_info * aux,
8738 unsigned int word,
8739 unsigned int remaining,
8740 bfd_vma data_offset,
8741 Elf_Internal_Shdr * data_sec,
8742 struct arm_section * data_arm_sec)
8743{
8744 int per_index;
8745 unsigned int more_words = 0;
8746 struct absaddr addr;
8747 bfd_vma sym_name = (bfd_vma) -1;
8748 bfd_boolean res = TRUE;
8749
8750 if (remaining == 0)
8751 {
8752 /* Fetch the first word.
8753 Note - when decoding an object file the address extracted
8754 here will always be 0. So we also pass in the sym_name
8755 parameter so that we can find the symbol associated with
8756 the personality routine. */
8757 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8758 & word, & addr, & sym_name))
8759 return FALSE;
8760
8761 remaining = 4;
8762 }
8763
8764 if ((word & 0x80000000) == 0)
8765 {
8766 /* Expand prel31 for personality routine. */
8767 bfd_vma fn;
8768 const char *procname;
8769
8770 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
8771 printf (_(" Personality routine: "));
8772 if (fn == 0
8773 && addr.section == SHN_UNDEF && addr.offset == 0
8774 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8775 {
8776 procname = aux->strtab + sym_name;
8777 print_vma (fn, PREFIX_HEX);
8778 if (procname)
8779 {
8780 fputs (" <", stdout);
8781 fputs (procname, stdout);
8782 fputc ('>', stdout);
8783 }
8784 }
8785 else
8786 procname = arm_print_vma_and_name (aux, fn, addr);
8787 fputc ('\n', stdout);
8788
8789 /* The GCC personality routines use the standard compact
8790 encoding, starting with one byte giving the number of
8791 words. */
8792 if (procname != NULL
8793 && (const_strneq (procname, "__gcc_personality_v0")
8794 || const_strneq (procname, "__gxx_personality_v0")
8795 || const_strneq (procname, "__gcj_personality_v0")
8796 || const_strneq (procname, "__gnu_objc_personality_v0")))
8797 {
8798 remaining = 0;
8799 more_words = 1;
8800 ADVANCE;
8801 if (!remaining)
8802 {
8803 printf (_(" [Truncated data]\n"));
8804 return FALSE;
8805 }
8806 more_words = word >> 24;
8807 word <<= 8;
8808 remaining--;
8809 per_index = -1;
8810 }
8811 else
8812 return TRUE;
8813 }
8814 else
8815 {
8816 /* ARM EHABI Section 6.3:
8817
8818 An exception-handling table entry for the compact model looks like:
8819
8820 31 30-28 27-24 23-0
8821 -- ----- ----- ----
8822 1 0 index Data for personalityRoutine[index] */
8823
8824 if (elf_header.e_machine == EM_ARM
8825 && (word & 0x70000000))
8826 {
8827 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8828 res = FALSE;
8829 }
8830
8831 per_index = (word >> 24) & 0x7f;
8832 printf (_(" Compact model index: %d\n"), per_index);
8833 if (per_index == 0)
8834 {
8835 more_words = 0;
8836 word <<= 8;
8837 remaining--;
8838 }
8839 else if (per_index < 3)
8840 {
8841 more_words = (word >> 16) & 0xff;
8842 word <<= 16;
8843 remaining -= 2;
8844 }
8845 }
8846
8847 switch (elf_header.e_machine)
8848 {
8849 case EM_ARM:
8850 if (per_index < 3)
8851 {
8852 if (! decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8853 data_offset, data_sec, data_arm_sec))
8854 res = FALSE;
8855 }
8856 else
8857 {
8858 warn (_("Unknown ARM compact model index encountered\n"));
8859 printf (_(" [reserved]\n"));
8860 res = FALSE;
8861 }
8862 break;
8863
8864 case EM_TI_C6000:
8865 if (per_index < 3)
8866 {
8867 if (! decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
8868 data_offset, data_sec, data_arm_sec))
8869 res = FALSE;
8870 }
8871 else if (per_index < 5)
8872 {
8873 if (((word >> 17) & 0x7f) == 0x7f)
8874 printf (_(" Restore stack from frame pointer\n"));
8875 else
8876 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
8877 printf (_(" Registers restored: "));
8878 if (per_index == 4)
8879 printf (" (compact) ");
8880 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8881 putchar ('\n');
8882 printf (_(" Return register: %s\n"),
8883 tic6x_unwind_regnames[word & 0xf]);
8884 }
8885 else
8886 printf (_(" [reserved (%d)]\n"), per_index);
8887 break;
8888
8889 default:
8890 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8891 elf_header.e_machine);
8892 res = FALSE;
8893 }
8894
8895 /* Decode the descriptors. Not implemented. */
8896
8897 return res;
8898}
8899
8900static bfd_boolean
8901dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8902{
8903 struct arm_section exidx_arm_sec, extab_arm_sec;
8904 unsigned int i, exidx_len;
8905 unsigned long j, nfuns;
8906 bfd_boolean res = TRUE;
8907
8908 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8909 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8910 exidx_len = exidx_sec->sh_size / 8;
8911
8912 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8913 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8914 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8915 aux->funtab[nfuns++] = aux->symtab[j];
8916 aux->nfuns = nfuns;
8917 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8918
8919 for (i = 0; i < exidx_len; i++)
8920 {
8921 unsigned int exidx_fn, exidx_entry;
8922 struct absaddr fn_addr, entry_addr;
8923 bfd_vma fn;
8924
8925 fputc ('\n', stdout);
8926
8927 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8928 8 * i, & exidx_fn, & fn_addr, NULL)
8929 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8930 8 * i + 4, & exidx_entry, & entry_addr, NULL))
8931 {
8932 free (aux->funtab);
8933 arm_free_section (& exidx_arm_sec);
8934 arm_free_section (& extab_arm_sec);
8935 return FALSE;
8936 }
8937
8938 /* ARM EHABI, Section 5:
8939 An index table entry consists of 2 words.
8940 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8941 if (exidx_fn & 0x80000000)
8942 {
8943 warn (_("corrupt index table entry: %x\n"), exidx_fn);
8944 res = FALSE;
8945 }
8946
8947 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
8948
8949 arm_print_vma_and_name (aux, fn, fn_addr);
8950 fputs (": ", stdout);
8951
8952 if (exidx_entry == 1)
8953 {
8954 print_vma (exidx_entry, PREFIX_HEX);
8955 fputs (" [cantunwind]\n", stdout);
8956 }
8957 else if (exidx_entry & 0x80000000)
8958 {
8959 print_vma (exidx_entry, PREFIX_HEX);
8960 fputc ('\n', stdout);
8961 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8962 }
8963 else
8964 {
8965 bfd_vma table, table_offset = 0;
8966 Elf_Internal_Shdr *table_sec;
8967
8968 fputs ("@", stdout);
8969 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
8970 print_vma (table, PREFIX_HEX);
8971 printf ("\n");
8972
8973 /* Locate the matching .ARM.extab. */
8974 if (entry_addr.section != SHN_UNDEF
8975 && entry_addr.section < elf_header.e_shnum)
8976 {
8977 table_sec = section_headers + entry_addr.section;
8978 table_offset = entry_addr.offset;
8979 /* PR 18879 */
8980 if (table_offset > table_sec->sh_size
8981 || ((bfd_signed_vma) table_offset) < 0)
8982 {
8983 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8984 (unsigned long) table_offset,
8985 printable_section_name (table_sec));
8986 res = FALSE;
8987 continue;
8988 }
8989 }
8990 else
8991 {
8992 table_sec = find_section_by_address (table);
8993 if (table_sec != NULL)
8994 table_offset = table - table_sec->sh_addr;
8995 }
8996
8997 if (table_sec == NULL)
8998 {
8999 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9000 (unsigned long) table);
9001 res = FALSE;
9002 continue;
9003 }
9004
9005 if (! decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
9006 &extab_arm_sec))
9007 res = FALSE;
9008 }
9009 }
9010
9011 printf ("\n");
9012
9013 free (aux->funtab);
9014 arm_free_section (&exidx_arm_sec);
9015 arm_free_section (&extab_arm_sec);
9016
9017 return res;
9018}
9019
9020/* Used for both ARM and C6X unwinding tables. */
9021
9022static bfd_boolean
9023arm_process_unwind (FILE *file)
9024{
9025 struct arm_unw_aux_info aux;
9026 Elf_Internal_Shdr *unwsec = NULL;
9027 Elf_Internal_Shdr *strsec;
9028 Elf_Internal_Shdr *sec;
9029 unsigned long i;
9030 unsigned int sec_type;
9031 bfd_boolean res = TRUE;
9032
9033 switch (elf_header.e_machine)
9034 {
9035 case EM_ARM:
9036 sec_type = SHT_ARM_EXIDX;
9037 break;
9038
9039 case EM_TI_C6000:
9040 sec_type = SHT_C6000_UNWIND;
9041 break;
9042
9043 default:
9044 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9045 elf_header.e_machine);
9046 return FALSE;
9047 }
9048
9049 if (string_table == NULL)
9050 return FALSE;
9051
9052 memset (& aux, 0, sizeof (aux));
9053 aux.file = file;
9054
9055 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
9056 {
9057 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
9058 {
9059 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
9060
9061 strsec = section_headers + sec->sh_link;
9062
9063 /* PR binutils/17531 file: 011-12666-0.004. */
9064 if (aux.strtab != NULL)
9065 {
9066 error (_("Multiple string tables found in file.\n"));
9067 free (aux.strtab);
9068 res = FALSE;
9069 }
9070 aux.strtab = get_data (NULL, file, strsec->sh_offset,
9071 1, strsec->sh_size, _("string table"));
9072 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9073 }
9074 else if (sec->sh_type == sec_type)
9075 unwsec = sec;
9076 }
9077
9078 if (unwsec == NULL)
9079 printf (_("\nThere are no unwind sections in this file.\n"));
9080 else
9081 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
9082 {
9083 if (sec->sh_type == sec_type)
9084 {
9085 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
9086 printable_section_name (sec),
9087 (unsigned long) sec->sh_offset,
9088 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
9089
9090 if (! dump_arm_unwind (&aux, sec))
9091 res = FALSE;
9092 }
9093 }
9094
9095 if (aux.symtab)
9096 free (aux.symtab);
9097 if (aux.strtab)
9098 free ((char *) aux.strtab);
9099
9100 return res;
9101}
9102
9103static bfd_boolean
9104process_unwind (FILE * file)
9105{
9106 struct unwind_handler
9107 {
9108 unsigned int machtype;
9109 bfd_boolean (* handler)(FILE *);
9110 } handlers[] =
9111 {
9112 { EM_ARM, arm_process_unwind },
9113 { EM_IA_64, ia64_process_unwind },
9114 { EM_PARISC, hppa_process_unwind },
9115 { EM_TI_C6000, arm_process_unwind },
9116 { 0, NULL }
9117 };
9118 int i;
9119
9120 if (!do_unwind)
9121 return TRUE;
9122
9123 for (i = 0; handlers[i].handler != NULL; i++)
9124 if (elf_header.e_machine == handlers[i].machtype)
9125 return handlers[i].handler (file);
9126
9127 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9128 get_machine_name (elf_header.e_machine));
9129 return TRUE;
9130}
9131
9132static void
9133dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9134{
9135 switch (entry->d_tag)
9136 {
9137 case DT_MIPS_FLAGS:
9138 if (entry->d_un.d_val == 0)
9139 printf (_("NONE"));
9140 else
9141 {
9142 static const char * opts[] =
9143 {
9144 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9145 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9146 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9147 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9148 "RLD_ORDER_SAFE"
9149 };
9150 unsigned int cnt;
9151 bfd_boolean first = TRUE;
9152
9153 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9154 if (entry->d_un.d_val & (1 << cnt))
9155 {
9156 printf ("%s%s", first ? "" : " ", opts[cnt]);
9157 first = FALSE;
9158 }
9159 }
9160 break;
9161
9162 case DT_MIPS_IVERSION:
9163 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9164 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9165 else
9166 {
9167 char buf[40];
9168 sprintf_vma (buf, entry->d_un.d_ptr);
9169 /* Note: coded this way so that there is a single string for translation. */
9170 printf (_("<corrupt: %s>"), buf);
9171 }
9172 break;
9173
9174 case DT_MIPS_TIME_STAMP:
9175 {
9176 char timebuf[128];
9177 struct tm * tmp;
9178 time_t atime = entry->d_un.d_val;
9179
9180 tmp = gmtime (&atime);
9181 /* PR 17531: file: 6accc532. */
9182 if (tmp == NULL)
9183 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9184 else
9185 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9186 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9187 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9188 printf (_("Time Stamp: %s"), timebuf);
9189 }
9190 break;
9191
9192 case DT_MIPS_RLD_VERSION:
9193 case DT_MIPS_LOCAL_GOTNO:
9194 case DT_MIPS_CONFLICTNO:
9195 case DT_MIPS_LIBLISTNO:
9196 case DT_MIPS_SYMTABNO:
9197 case DT_MIPS_UNREFEXTNO:
9198 case DT_MIPS_HIPAGENO:
9199 case DT_MIPS_DELTA_CLASS_NO:
9200 case DT_MIPS_DELTA_INSTANCE_NO:
9201 case DT_MIPS_DELTA_RELOC_NO:
9202 case DT_MIPS_DELTA_SYM_NO:
9203 case DT_MIPS_DELTA_CLASSSYM_NO:
9204 case DT_MIPS_COMPACT_SIZE:
9205 print_vma (entry->d_un.d_val, DEC);
9206 break;
9207
9208 default:
9209 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9210 }
9211 putchar ('\n');
9212}
9213
9214static void
9215dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9216{
9217 switch (entry->d_tag)
9218 {
9219 case DT_HP_DLD_FLAGS:
9220 {
9221 static struct
9222 {
9223 long int bit;
9224 const char * str;
9225 }
9226 flags[] =
9227 {
9228 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9229 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9230 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9231 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9232 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9233 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9234 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9235 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9236 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9237 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9238 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9239 { DT_HP_GST, "HP_GST" },
9240 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9241 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9242 { DT_HP_NODELETE, "HP_NODELETE" },
9243 { DT_HP_GROUP, "HP_GROUP" },
9244 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9245 };
9246 bfd_boolean first = TRUE;
9247 size_t cnt;
9248 bfd_vma val = entry->d_un.d_val;
9249
9250 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9251 if (val & flags[cnt].bit)
9252 {
9253 if (! first)
9254 putchar (' ');
9255 fputs (flags[cnt].str, stdout);
9256 first = FALSE;
9257 val ^= flags[cnt].bit;
9258 }
9259
9260 if (val != 0 || first)
9261 {
9262 if (! first)
9263 putchar (' ');
9264 print_vma (val, HEX);
9265 }
9266 }
9267 break;
9268
9269 default:
9270 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9271 break;
9272 }
9273 putchar ('\n');
9274}
9275
9276#ifdef BFD64
9277
9278/* VMS vs Unix time offset and factor. */
9279
9280#define VMS_EPOCH_OFFSET 35067168000000000LL
9281#define VMS_GRANULARITY_FACTOR 10000000
9282
9283/* Display a VMS time in a human readable format. */
9284
9285static void
9286print_vms_time (bfd_int64_t vmstime)
9287{
9288 struct tm *tm;
9289 time_t unxtime;
9290
9291 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9292 tm = gmtime (&unxtime);
9293 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9294 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9295 tm->tm_hour, tm->tm_min, tm->tm_sec);
9296}
9297#endif /* BFD64 */
9298
9299static void
9300dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9301{
9302 switch (entry->d_tag)
9303 {
9304 case DT_IA_64_PLT_RESERVE:
9305 /* First 3 slots reserved. */
9306 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9307 printf (" -- ");
9308 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9309 break;
9310
9311 case DT_IA_64_VMS_LINKTIME:
9312#ifdef BFD64
9313 print_vms_time (entry->d_un.d_val);
9314#endif
9315 break;
9316
9317 case DT_IA_64_VMS_LNKFLAGS:
9318 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9319 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9320 printf (" CALL_DEBUG");
9321 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9322 printf (" NOP0BUFS");
9323 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9324 printf (" P0IMAGE");
9325 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9326 printf (" MKTHREADS");
9327 if (entry->d_un.d_val & VMS_LF_UPCALLS)
9328 printf (" UPCALLS");
9329 if (entry->d_un.d_val & VMS_LF_IMGSTA)
9330 printf (" IMGSTA");
9331 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9332 printf (" INITIALIZE");
9333 if (entry->d_un.d_val & VMS_LF_MAIN)
9334 printf (" MAIN");
9335 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9336 printf (" EXE_INIT");
9337 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9338 printf (" TBK_IN_IMG");
9339 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9340 printf (" DBG_IN_IMG");
9341 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9342 printf (" TBK_IN_DSF");
9343 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9344 printf (" DBG_IN_DSF");
9345 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9346 printf (" SIGNATURES");
9347 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9348 printf (" REL_SEG_OFF");
9349 break;
9350
9351 default:
9352 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9353 break;
9354 }
9355 putchar ('\n');
9356}
9357
9358static bfd_boolean
9359get_32bit_dynamic_section (FILE * file)
9360{
9361 Elf32_External_Dyn * edyn;
9362 Elf32_External_Dyn * ext;
9363 Elf_Internal_Dyn * entry;
9364
9365 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
9366 dynamic_size, _("dynamic section"));
9367 if (!edyn)
9368 return FALSE;
9369
9370 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9371 might not have the luxury of section headers. Look for the DT_NULL
9372 terminator to determine the number of entries. */
9373 for (ext = edyn, dynamic_nent = 0;
9374 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9375 ext++)
9376 {
9377 dynamic_nent++;
9378 if (BYTE_GET (ext->d_tag) == DT_NULL)
9379 break;
9380 }
9381
9382 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9383 sizeof (* entry));
9384 if (dynamic_section == NULL)
9385 {
9386 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9387 (unsigned long) dynamic_nent);
9388 free (edyn);
9389 return FALSE;
9390 }
9391
9392 for (ext = edyn, entry = dynamic_section;
9393 entry < dynamic_section + dynamic_nent;
9394 ext++, entry++)
9395 {
9396 entry->d_tag = BYTE_GET (ext->d_tag);
9397 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9398 }
9399
9400 free (edyn);
9401
9402 return TRUE;
9403}
9404
9405static bfd_boolean
9406get_64bit_dynamic_section (FILE * file)
9407{
9408 Elf64_External_Dyn * edyn;
9409 Elf64_External_Dyn * ext;
9410 Elf_Internal_Dyn * entry;
9411
9412 /* Read in the data. */
9413 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
9414 dynamic_size, _("dynamic section"));
9415 if (!edyn)
9416 return FALSE;
9417
9418 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9419 might not have the luxury of section headers. Look for the DT_NULL
9420 terminator to determine the number of entries. */
9421 for (ext = edyn, dynamic_nent = 0;
9422 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9423 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9424 ext++)
9425 {
9426 dynamic_nent++;
9427 if (BYTE_GET (ext->d_tag) == DT_NULL)
9428 break;
9429 }
9430
9431 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9432 sizeof (* entry));
9433 if (dynamic_section == NULL)
9434 {
9435 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9436 (unsigned long) dynamic_nent);
9437 free (edyn);
9438 return FALSE;
9439 }
9440
9441 /* Convert from external to internal formats. */
9442 for (ext = edyn, entry = dynamic_section;
9443 entry < dynamic_section + dynamic_nent;
9444 ext++, entry++)
9445 {
9446 entry->d_tag = BYTE_GET (ext->d_tag);
9447 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9448 }
9449
9450 free (edyn);
9451
9452 return TRUE;
9453}
9454
9455static void
9456print_dynamic_flags (bfd_vma flags)
9457{
9458 bfd_boolean first = TRUE;
9459
9460 while (flags)
9461 {
9462 bfd_vma flag;
9463
9464 flag = flags & - flags;
9465 flags &= ~ flag;
9466
9467 if (first)
9468 first = FALSE;
9469 else
9470 putc (' ', stdout);
9471
9472 switch (flag)
9473 {
9474 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
9475 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
9476 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
9477 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
9478 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
9479 default: fputs (_("unknown"), stdout); break;
9480 }
9481 }
9482 puts ("");
9483}
9484
9485/* Parse and display the contents of the dynamic section. */
9486
9487static bfd_boolean
9488process_dynamic_section (FILE * file)
9489{
9490 Elf_Internal_Dyn * entry;
9491
9492 if (dynamic_size == 0)
9493 {
9494 if (do_dynamic)
9495 printf (_("\nThere is no dynamic section in this file.\n"));
9496
9497 return TRUE;
9498 }
9499
9500 if (is_32bit_elf)
9501 {
9502 if (! get_32bit_dynamic_section (file))
9503 return FALSE;
9504 }
9505 else
9506 {
9507 if (! get_64bit_dynamic_section (file))
9508 return FALSE;
9509 }
9510
9511 /* Find the appropriate symbol table. */
9512 if (dynamic_symbols == NULL)
9513 {
9514 for (entry = dynamic_section;
9515 entry < dynamic_section + dynamic_nent;
9516 ++entry)
9517 {
9518 Elf_Internal_Shdr section;
9519
9520 if (entry->d_tag != DT_SYMTAB)
9521 continue;
9522
9523 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9524
9525 /* Since we do not know how big the symbol table is,
9526 we default to reading in the entire file (!) and
9527 processing that. This is overkill, I know, but it
9528 should work. */
9529 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
9530 if ((bfd_size_type) section.sh_offset > current_file_size)
9531 {
9532 /* See PR 21379 for a reproducer. */
9533 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9534 return FALSE;
9535 }
9536
9537 if (archive_file_offset != 0)
9538 section.sh_size = archive_file_size - section.sh_offset;
9539 else
9540 {
9541 if (fseek (file, 0, SEEK_END))
9542 error (_("Unable to seek to end of file!\n"));
9543
9544 section.sh_size = ftell (file) - section.sh_offset;
9545 }
9546
9547 if (is_32bit_elf)
9548 section.sh_entsize = sizeof (Elf32_External_Sym);
9549 else
9550 section.sh_entsize = sizeof (Elf64_External_Sym);
9551 section.sh_name = string_table_length;
9552
9553 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
9554 if (num_dynamic_syms < 1)
9555 {
9556 error (_("Unable to determine the number of symbols to load\n"));
9557 continue;
9558 }
9559 }
9560 }
9561
9562 /* Similarly find a string table. */
9563 if (dynamic_strings == NULL)
9564 {
9565 for (entry = dynamic_section;
9566 entry < dynamic_section + dynamic_nent;
9567 ++entry)
9568 {
9569 unsigned long offset;
9570 long str_tab_len;
9571
9572 if (entry->d_tag != DT_STRTAB)
9573 continue;
9574
9575 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9576
9577 /* Since we do not know how big the string table is,
9578 we default to reading in the entire file (!) and
9579 processing that. This is overkill, I know, but it
9580 should work. */
9581
9582 offset = offset_from_vma (file, entry->d_un.d_val, 0);
9583
9584 if (archive_file_offset != 0)
9585 str_tab_len = archive_file_size - offset;
9586 else
9587 {
9588 if (fseek (file, 0, SEEK_END))
9589 error (_("Unable to seek to end of file\n"));
9590 str_tab_len = ftell (file) - offset;
9591 }
9592
9593 if (str_tab_len < 1)
9594 {
9595 error
9596 (_("Unable to determine the length of the dynamic string table\n"));
9597 continue;
9598 }
9599
9600 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
9601 str_tab_len,
9602 _("dynamic string table"));
9603 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9604 break;
9605 }
9606 }
9607
9608 /* And find the syminfo section if available. */
9609 if (dynamic_syminfo == NULL)
9610 {
9611 unsigned long syminsz = 0;
9612
9613 for (entry = dynamic_section;
9614 entry < dynamic_section + dynamic_nent;
9615 ++entry)
9616 {
9617 if (entry->d_tag == DT_SYMINENT)
9618 {
9619 /* Note: these braces are necessary to avoid a syntax
9620 error from the SunOS4 C compiler. */
9621 /* PR binutils/17531: A corrupt file can trigger this test.
9622 So do not use an assert, instead generate an error message. */
9623 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9624 error (_("Bad value (%d) for SYMINENT entry\n"),
9625 (int) entry->d_un.d_val);
9626 }
9627 else if (entry->d_tag == DT_SYMINSZ)
9628 syminsz = entry->d_un.d_val;
9629 else if (entry->d_tag == DT_SYMINFO)
9630 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
9631 syminsz);
9632 }
9633
9634 if (dynamic_syminfo_offset != 0 && syminsz != 0)
9635 {
9636 Elf_External_Syminfo * extsyminfo;
9637 Elf_External_Syminfo * extsym;
9638 Elf_Internal_Syminfo * syminfo;
9639
9640 /* There is a syminfo section. Read the data. */
9641 extsyminfo = (Elf_External_Syminfo *)
9642 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
9643 _("symbol information"));
9644 if (!extsyminfo)
9645 return FALSE;
9646
9647 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9648 if (dynamic_syminfo == NULL)
9649 {
9650 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9651 (unsigned long) syminsz);
9652 return FALSE;
9653 }
9654
9655 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9656 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9657 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9658 ++syminfo, ++extsym)
9659 {
9660 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9661 syminfo->si_flags = BYTE_GET (extsym->si_flags);
9662 }
9663
9664 free (extsyminfo);
9665 }
9666 }
9667
9668 if (do_dynamic && dynamic_addr)
9669 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9670 dynamic_addr, (unsigned long) dynamic_nent);
9671 if (do_dynamic)
9672 printf (_(" Tag Type Name/Value\n"));
9673
9674 for (entry = dynamic_section;
9675 entry < dynamic_section + dynamic_nent;
9676 entry++)
9677 {
9678 if (do_dynamic)
9679 {
9680 const char * dtype;
9681
9682 putchar (' ');
9683 print_vma (entry->d_tag, FULL_HEX);
9684 dtype = get_dynamic_type (entry->d_tag);
9685 printf (" (%s)%*s", dtype,
9686 ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
9687 }
9688
9689 switch (entry->d_tag)
9690 {
9691 case DT_FLAGS:
9692 if (do_dynamic)
9693 print_dynamic_flags (entry->d_un.d_val);
9694 break;
9695
9696 case DT_AUXILIARY:
9697 case DT_FILTER:
9698 case DT_CONFIG:
9699 case DT_DEPAUDIT:
9700 case DT_AUDIT:
9701 if (do_dynamic)
9702 {
9703 switch (entry->d_tag)
9704 {
9705 case DT_AUXILIARY:
9706 printf (_("Auxiliary library"));
9707 break;
9708
9709 case DT_FILTER:
9710 printf (_("Filter library"));
9711 break;
9712
9713 case DT_CONFIG:
9714 printf (_("Configuration file"));
9715 break;
9716
9717 case DT_DEPAUDIT:
9718 printf (_("Dependency audit library"));
9719 break;
9720
9721 case DT_AUDIT:
9722 printf (_("Audit library"));
9723 break;
9724 }
9725
9726 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9727 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9728 else
9729 {
9730 printf (": ");
9731 print_vma (entry->d_un.d_val, PREFIX_HEX);
9732 putchar ('\n');
9733 }
9734 }
9735 break;
9736
9737 case DT_FEATURE:
9738 if (do_dynamic)
9739 {
9740 printf (_("Flags:"));
9741
9742 if (entry->d_un.d_val == 0)
9743 printf (_(" None\n"));
9744 else
9745 {
9746 unsigned long int val = entry->d_un.d_val;
9747
9748 if (val & DTF_1_PARINIT)
9749 {
9750 printf (" PARINIT");
9751 val ^= DTF_1_PARINIT;
9752 }
9753 if (val & DTF_1_CONFEXP)
9754 {
9755 printf (" CONFEXP");
9756 val ^= DTF_1_CONFEXP;
9757 }
9758 if (val != 0)
9759 printf (" %lx", val);
9760 puts ("");
9761 }
9762 }
9763 break;
9764
9765 case DT_POSFLAG_1:
9766 if (do_dynamic)
9767 {
9768 printf (_("Flags:"));
9769
9770 if (entry->d_un.d_val == 0)
9771 printf (_(" None\n"));
9772 else
9773 {
9774 unsigned long int val = entry->d_un.d_val;
9775
9776 if (val & DF_P1_LAZYLOAD)
9777 {
9778 printf (" LAZYLOAD");
9779 val ^= DF_P1_LAZYLOAD;
9780 }
9781 if (val & DF_P1_GROUPPERM)
9782 {
9783 printf (" GROUPPERM");
9784 val ^= DF_P1_GROUPPERM;
9785 }
9786 if (val != 0)
9787 printf (" %lx", val);
9788 puts ("");
9789 }
9790 }
9791 break;
9792
9793 case DT_FLAGS_1:
9794 if (do_dynamic)
9795 {
9796 printf (_("Flags:"));
9797 if (entry->d_un.d_val == 0)
9798 printf (_(" None\n"));
9799 else
9800 {
9801 unsigned long int val = entry->d_un.d_val;
9802
9803 if (val & DF_1_NOW)
9804 {
9805 printf (" NOW");
9806 val ^= DF_1_NOW;
9807 }
9808 if (val & DF_1_GLOBAL)
9809 {
9810 printf (" GLOBAL");
9811 val ^= DF_1_GLOBAL;
9812 }
9813 if (val & DF_1_GROUP)
9814 {
9815 printf (" GROUP");
9816 val ^= DF_1_GROUP;
9817 }
9818 if (val & DF_1_NODELETE)
9819 {
9820 printf (" NODELETE");
9821 val ^= DF_1_NODELETE;
9822 }
9823 if (val & DF_1_LOADFLTR)
9824 {
9825 printf (" LOADFLTR");
9826 val ^= DF_1_LOADFLTR;
9827 }
9828 if (val & DF_1_INITFIRST)
9829 {
9830 printf (" INITFIRST");
9831 val ^= DF_1_INITFIRST;
9832 }
9833 if (val & DF_1_NOOPEN)
9834 {
9835 printf (" NOOPEN");
9836 val ^= DF_1_NOOPEN;
9837 }
9838 if (val & DF_1_ORIGIN)
9839 {
9840 printf (" ORIGIN");
9841 val ^= DF_1_ORIGIN;
9842 }
9843 if (val & DF_1_DIRECT)
9844 {
9845 printf (" DIRECT");
9846 val ^= DF_1_DIRECT;
9847 }
9848 if (val & DF_1_TRANS)
9849 {
9850 printf (" TRANS");
9851 val ^= DF_1_TRANS;
9852 }
9853 if (val & DF_1_INTERPOSE)
9854 {
9855 printf (" INTERPOSE");
9856 val ^= DF_1_INTERPOSE;
9857 }
9858 if (val & DF_1_NODEFLIB)
9859 {
9860 printf (" NODEFLIB");
9861 val ^= DF_1_NODEFLIB;
9862 }
9863 if (val & DF_1_NODUMP)
9864 {
9865 printf (" NODUMP");
9866 val ^= DF_1_NODUMP;
9867 }
9868 if (val & DF_1_CONFALT)
9869 {
9870 printf (" CONFALT");
9871 val ^= DF_1_CONFALT;
9872 }
9873 if (val & DF_1_ENDFILTEE)
9874 {
9875 printf (" ENDFILTEE");
9876 val ^= DF_1_ENDFILTEE;
9877 }
9878 if (val & DF_1_DISPRELDNE)
9879 {
9880 printf (" DISPRELDNE");
9881 val ^= DF_1_DISPRELDNE;
9882 }
9883 if (val & DF_1_DISPRELPND)
9884 {
9885 printf (" DISPRELPND");
9886 val ^= DF_1_DISPRELPND;
9887 }
9888 if (val & DF_1_NODIRECT)
9889 {
9890 printf (" NODIRECT");
9891 val ^= DF_1_NODIRECT;
9892 }
9893 if (val & DF_1_IGNMULDEF)
9894 {
9895 printf (" IGNMULDEF");
9896 val ^= DF_1_IGNMULDEF;
9897 }
9898 if (val & DF_1_NOKSYMS)
9899 {
9900 printf (" NOKSYMS");
9901 val ^= DF_1_NOKSYMS;
9902 }
9903 if (val & DF_1_NOHDR)
9904 {
9905 printf (" NOHDR");
9906 val ^= DF_1_NOHDR;
9907 }
9908 if (val & DF_1_EDITED)
9909 {
9910 printf (" EDITED");
9911 val ^= DF_1_EDITED;
9912 }
9913 if (val & DF_1_NORELOC)
9914 {
9915 printf (" NORELOC");
9916 val ^= DF_1_NORELOC;
9917 }
9918 if (val & DF_1_SYMINTPOSE)
9919 {
9920 printf (" SYMINTPOSE");
9921 val ^= DF_1_SYMINTPOSE;
9922 }
9923 if (val & DF_1_GLOBAUDIT)
9924 {
9925 printf (" GLOBAUDIT");
9926 val ^= DF_1_GLOBAUDIT;
9927 }
9928 if (val & DF_1_SINGLETON)
9929 {
9930 printf (" SINGLETON");
9931 val ^= DF_1_SINGLETON;
9932 }
9933 if (val & DF_1_STUB)
9934 {
9935 printf (" STUB");
9936 val ^= DF_1_STUB;
9937 }
9938 if (val & DF_1_PIE)
9939 {
9940 printf (" PIE");
9941 val ^= DF_1_PIE;
9942 }
9943 if (val != 0)
9944 printf (" %lx", val);
9945 puts ("");
9946 }
9947 }
9948 break;
9949
9950 case DT_PLTREL:
9951 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9952 if (do_dynamic)
9953 puts (get_dynamic_type (entry->d_un.d_val));
9954 break;
9955
9956 case DT_NULL :
9957 case DT_NEEDED :
9958 case DT_PLTGOT :
9959 case DT_HASH :
9960 case DT_STRTAB :
9961 case DT_SYMTAB :
9962 case DT_RELA :
9963 case DT_INIT :
9964 case DT_FINI :
9965 case DT_SONAME :
9966 case DT_RPATH :
9967 case DT_SYMBOLIC:
9968 case DT_REL :
9969 case DT_DEBUG :
9970 case DT_TEXTREL :
9971 case DT_JMPREL :
9972 case DT_RUNPATH :
9973 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9974
9975 if (do_dynamic)
9976 {
9977 char * name;
9978
9979 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9980 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9981 else
9982 name = NULL;
9983
9984 if (name)
9985 {
9986 switch (entry->d_tag)
9987 {
9988 case DT_NEEDED:
9989 printf (_("Shared library: [%s]"), name);
9990
9991 if (streq (name, program_interpreter))
9992 printf (_(" program interpreter"));
9993 break;
9994
9995 case DT_SONAME:
9996 printf (_("Library soname: [%s]"), name);
9997 break;
9998
9999 case DT_RPATH:
10000 printf (_("Library rpath: [%s]"), name);
10001 break;
10002
10003 case DT_RUNPATH:
10004 printf (_("Library runpath: [%s]"), name);
10005 break;
10006
10007 default:
10008 print_vma (entry->d_un.d_val, PREFIX_HEX);
10009 break;
10010 }
10011 }
10012 else
10013 print_vma (entry->d_un.d_val, PREFIX_HEX);
10014
10015 putchar ('\n');
10016 }
10017 break;
10018
10019 case DT_PLTRELSZ:
10020 case DT_RELASZ :
10021 case DT_STRSZ :
10022 case DT_RELSZ :
10023 case DT_RELAENT :
10024 case DT_SYMENT :
10025 case DT_RELENT :
10026 dynamic_info[entry->d_tag] = entry->d_un.d_val;
10027 /* Fall through. */
10028 case DT_PLTPADSZ:
10029 case DT_MOVEENT :
10030 case DT_MOVESZ :
10031 case DT_INIT_ARRAYSZ:
10032 case DT_FINI_ARRAYSZ:
10033 case DT_GNU_CONFLICTSZ:
10034 case DT_GNU_LIBLISTSZ:
10035 if (do_dynamic)
10036 {
10037 print_vma (entry->d_un.d_val, UNSIGNED);
10038 printf (_(" (bytes)\n"));
10039 }
10040 break;
10041
10042 case DT_VERDEFNUM:
10043 case DT_VERNEEDNUM:
10044 case DT_RELACOUNT:
10045 case DT_RELCOUNT:
10046 if (do_dynamic)
10047 {
10048 print_vma (entry->d_un.d_val, UNSIGNED);
10049 putchar ('\n');
10050 }
10051 break;
10052
10053 case DT_SYMINSZ:
10054 case DT_SYMINENT:
10055 case DT_SYMINFO:
10056 case DT_USED:
10057 case DT_INIT_ARRAY:
10058 case DT_FINI_ARRAY:
10059 if (do_dynamic)
10060 {
10061 if (entry->d_tag == DT_USED
10062 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
10063 {
10064 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10065
10066 if (*name)
10067 {
10068 printf (_("Not needed object: [%s]\n"), name);
10069 break;
10070 }
10071 }
10072
10073 print_vma (entry->d_un.d_val, PREFIX_HEX);
10074 putchar ('\n');
10075 }
10076 break;
10077
10078 case DT_BIND_NOW:
10079 /* The value of this entry is ignored. */
10080 if (do_dynamic)
10081 putchar ('\n');
10082 break;
10083
10084 case DT_GNU_PRELINKED:
10085 if (do_dynamic)
10086 {
10087 struct tm * tmp;
10088 time_t atime = entry->d_un.d_val;
10089
10090 tmp = gmtime (&atime);
10091 /* PR 17533 file: 041-1244816-0.004. */
10092 if (tmp == NULL)
10093 printf (_("<corrupt time val: %lx"),
10094 (unsigned long) atime);
10095 else
10096 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10097 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10098 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10099
10100 }
10101 break;
10102
10103 case DT_GNU_HASH:
10104 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10105 if (do_dynamic)
10106 {
10107 print_vma (entry->d_un.d_val, PREFIX_HEX);
10108 putchar ('\n');
10109 }
10110 break;
10111
10112 default:
10113 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10114 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10115 entry->d_un.d_val;
10116
10117 if (do_dynamic)
10118 {
10119 switch (elf_header.e_machine)
10120 {
10121 case EM_MIPS:
10122 case EM_MIPS_RS3_LE:
10123 dynamic_section_mips_val (entry);
10124 break;
10125 case EM_PARISC:
10126 dynamic_section_parisc_val (entry);
10127 break;
10128 case EM_IA_64:
10129 dynamic_section_ia64_val (entry);
10130 break;
10131 default:
10132 print_vma (entry->d_un.d_val, PREFIX_HEX);
10133 putchar ('\n');
10134 }
10135 }
10136 break;
10137 }
10138 }
10139
10140 return TRUE;
10141}
10142
10143static char *
10144get_ver_flags (unsigned int flags)
10145{
10146 static char buff[32];
10147
10148 buff[0] = 0;
10149
10150 if (flags == 0)
10151 return _("none");
10152
10153 if (flags & VER_FLG_BASE)
10154 strcat (buff, "BASE");
10155
10156 if (flags & VER_FLG_WEAK)
10157 {
10158 if (flags & VER_FLG_BASE)
10159 strcat (buff, " | ");
10160
10161 strcat (buff, "WEAK");
10162 }
10163
10164 if (flags & VER_FLG_INFO)
10165 {
10166 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10167 strcat (buff, " | ");
10168
10169 strcat (buff, "INFO");
10170 }
10171
10172 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10173 {
10174 if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10175 strcat (buff, " | ");
10176
10177 strcat (buff, _("<unknown>"));
10178 }
10179
10180 return buff;
10181}
10182
10183/* Display the contents of the version sections. */
10184
10185static bfd_boolean
10186process_version_sections (FILE * file)
10187{
10188 Elf_Internal_Shdr * section;
10189 unsigned i;
10190 bfd_boolean found = FALSE;
10191
10192 if (! do_version)
10193 return TRUE;
10194
10195 for (i = 0, section = section_headers;
10196 i < elf_header.e_shnum;
10197 i++, section++)
10198 {
10199 switch (section->sh_type)
10200 {
10201 case SHT_GNU_verdef:
10202 {
10203 Elf_External_Verdef * edefs;
10204 unsigned long idx;
10205 unsigned long cnt;
10206 char * endbuf;
10207
10208 found = TRUE;
10209
10210 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
10211 printable_section_name (section),
10212 section->sh_info);
10213
10214 printf (_(" Addr: 0x"));
10215 printf_vma (section->sh_addr);
10216 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10217 (unsigned long) section->sh_offset, section->sh_link,
10218 printable_section_name_from_index (section->sh_link));
10219
10220 edefs = (Elf_External_Verdef *)
10221 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
10222 _("version definition section"));
10223 if (!edefs)
10224 break;
10225 endbuf = (char *) edefs + section->sh_size;
10226
10227 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10228 {
10229 char * vstart;
10230 Elf_External_Verdef * edef;
10231 Elf_Internal_Verdef ent;
10232 Elf_External_Verdaux * eaux;
10233 Elf_Internal_Verdaux aux;
10234 unsigned long isum;
10235 int j;
10236
10237 vstart = ((char *) edefs) + idx;
10238 if (vstart + sizeof (*edef) > endbuf)
10239 break;
10240
10241 edef = (Elf_External_Verdef *) vstart;
10242
10243 ent.vd_version = BYTE_GET (edef->vd_version);
10244 ent.vd_flags = BYTE_GET (edef->vd_flags);
10245 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
10246 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
10247 ent.vd_hash = BYTE_GET (edef->vd_hash);
10248 ent.vd_aux = BYTE_GET (edef->vd_aux);
10249 ent.vd_next = BYTE_GET (edef->vd_next);
10250
10251 printf (_(" %#06lx: Rev: %d Flags: %s"),
10252 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10253
10254 printf (_(" Index: %d Cnt: %d "),
10255 ent.vd_ndx, ent.vd_cnt);
10256
10257 /* Check for overflow. */
10258 if (ent.vd_aux > (size_t) (endbuf - vstart))
10259 break;
10260
10261 vstart += ent.vd_aux;
10262
10263 if (vstart + sizeof (*eaux) > endbuf)
10264 break;
10265 eaux = (Elf_External_Verdaux *) vstart;
10266
10267 aux.vda_name = BYTE_GET (eaux->vda_name);
10268 aux.vda_next = BYTE_GET (eaux->vda_next);
10269
10270 if (VALID_DYNAMIC_NAME (aux.vda_name))
10271 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10272 else
10273 printf (_("Name index: %ld\n"), aux.vda_name);
10274
10275 isum = idx + ent.vd_aux;
10276
10277 for (j = 1; j < ent.vd_cnt; j++)
10278 {
10279 if (aux.vda_next < sizeof (*eaux)
10280 && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
10281 {
10282 warn (_("Invalid vda_next field of %lx\n"),
10283 aux.vda_next);
10284 j = ent.vd_cnt;
10285 break;
10286 }
10287 /* Check for overflow. */
10288 if (aux.vda_next > (size_t) (endbuf - vstart))
10289 break;
10290
10291 isum += aux.vda_next;
10292 vstart += aux.vda_next;
10293
10294 if (vstart + sizeof (*eaux) > endbuf)
10295 break;
10296 eaux = (Elf_External_Verdaux *) vstart;
10297
10298 aux.vda_name = BYTE_GET (eaux->vda_name);
10299 aux.vda_next = BYTE_GET (eaux->vda_next);
10300
10301 if (VALID_DYNAMIC_NAME (aux.vda_name))
10302 printf (_(" %#06lx: Parent %d: %s\n"),
10303 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10304 else
10305 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10306 isum, j, aux.vda_name);
10307 }
10308
10309 if (j < ent.vd_cnt)
10310 printf (_(" Version def aux past end of section\n"));
10311
10312 /* PR 17531:
10313 file: id:000001,src:000172+005151,op:splice,rep:2. */
10314 if (ent.vd_next < sizeof (*edef)
10315 && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
10316 {
10317 warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
10318 cnt = section->sh_info;
10319 break;
10320 }
10321 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
10322 break;
10323
10324 idx += ent.vd_next;
10325 }
10326
10327 if (cnt < section->sh_info)
10328 printf (_(" Version definition past end of section\n"));
10329
10330 free (edefs);
10331 }
10332 break;
10333
10334 case SHT_GNU_verneed:
10335 {
10336 Elf_External_Verneed * eneed;
10337 unsigned long idx;
10338 unsigned long cnt;
10339 char * endbuf;
10340
10341 found = TRUE;
10342
10343 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
10344 printable_section_name (section), section->sh_info);
10345
10346 printf (_(" Addr: 0x"));
10347 printf_vma (section->sh_addr);
10348 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10349 (unsigned long) section->sh_offset, section->sh_link,
10350 printable_section_name_from_index (section->sh_link));
10351
10352 eneed = (Elf_External_Verneed *) get_data (NULL, file,
10353 section->sh_offset, 1,
10354 section->sh_size,
10355 _("Version Needs section"));
10356 if (!eneed)
10357 break;
10358 endbuf = (char *) eneed + section->sh_size;
10359
10360 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10361 {
10362 Elf_External_Verneed * entry;
10363 Elf_Internal_Verneed ent;
10364 unsigned long isum;
10365 int j;
10366 char * vstart;
10367
10368 vstart = ((char *) eneed) + idx;
10369 if (vstart + sizeof (*entry) > endbuf)
10370 break;
10371
10372 entry = (Elf_External_Verneed *) vstart;
10373
10374 ent.vn_version = BYTE_GET (entry->vn_version);
10375 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
10376 ent.vn_file = BYTE_GET (entry->vn_file);
10377 ent.vn_aux = BYTE_GET (entry->vn_aux);
10378 ent.vn_next = BYTE_GET (entry->vn_next);
10379
10380 printf (_(" %#06lx: Version: %d"), idx, ent.vn_version);
10381
10382 if (VALID_DYNAMIC_NAME (ent.vn_file))
10383 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10384 else
10385 printf (_(" File: %lx"), ent.vn_file);
10386
10387 printf (_(" Cnt: %d\n"), ent.vn_cnt);
10388
10389 /* Check for overflow. */
10390 if (ent.vn_aux > (size_t) (endbuf - vstart))
10391 break;
10392 vstart += ent.vn_aux;
10393
10394 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10395 {
10396 Elf_External_Vernaux * eaux;
10397 Elf_Internal_Vernaux aux;
10398
10399 if (vstart + sizeof (*eaux) > endbuf)
10400 break;
10401 eaux = (Elf_External_Vernaux *) vstart;
10402
10403 aux.vna_hash = BYTE_GET (eaux->vna_hash);
10404 aux.vna_flags = BYTE_GET (eaux->vna_flags);
10405 aux.vna_other = BYTE_GET (eaux->vna_other);
10406 aux.vna_name = BYTE_GET (eaux->vna_name);
10407 aux.vna_next = BYTE_GET (eaux->vna_next);
10408
10409 if (VALID_DYNAMIC_NAME (aux.vna_name))
10410 printf (_(" %#06lx: Name: %s"),
10411 isum, GET_DYNAMIC_NAME (aux.vna_name));
10412 else
10413 printf (_(" %#06lx: Name index: %lx"),
10414 isum, aux.vna_name);
10415
10416 printf (_(" Flags: %s Version: %d\n"),
10417 get_ver_flags (aux.vna_flags), aux.vna_other);
10418
10419 if (aux.vna_next < sizeof (*eaux)
10420 && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
10421 {
10422 warn (_("Invalid vna_next field of %lx\n"),
10423 aux.vna_next);
10424 j = ent.vn_cnt;
10425 break;
10426 }
10427 /* Check for overflow. */
10428 if (aux.vna_next > (size_t) (endbuf - vstart))
10429 break;
10430 isum += aux.vna_next;
10431 vstart += aux.vna_next;
10432 }
10433
10434 if (j < ent.vn_cnt)
10435 warn (_("Missing Version Needs auxillary information\n"));
10436
10437 if (ent.vn_next < sizeof (*entry)
10438 && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
10439 {
10440 warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
10441 cnt = section->sh_info;
10442 break;
10443 }
10444 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
10445 break;
10446 idx += ent.vn_next;
10447 }
10448
10449 if (cnt < section->sh_info)
10450 warn (_("Missing Version Needs information\n"));
10451
10452 free (eneed);
10453 }
10454 break;
10455
10456 case SHT_GNU_versym:
10457 {
10458 Elf_Internal_Shdr * link_section;
10459 size_t total;
10460 unsigned int cnt;
10461 unsigned char * edata;
10462 unsigned short * data;
10463 char * strtab;
10464 Elf_Internal_Sym * symbols;
10465 Elf_Internal_Shdr * string_sec;
10466 unsigned long num_syms;
10467 long off;
10468
10469 if (section->sh_link >= elf_header.e_shnum)
10470 break;
10471
10472 link_section = section_headers + section->sh_link;
10473 total = section->sh_size / sizeof (Elf_External_Versym);
10474
10475 if (link_section->sh_link >= elf_header.e_shnum)
10476 break;
10477
10478 found = TRUE;
10479
10480 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
10481 if (symbols == NULL)
10482 break;
10483
10484 string_sec = section_headers + link_section->sh_link;
10485
10486 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
10487 string_sec->sh_size,
10488 _("version string table"));
10489 if (!strtab)
10490 {
10491 free (symbols);
10492 break;
10493 }
10494
10495 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10496 printable_section_name (section), (unsigned long) total);
10497
10498 printf (_(" Addr: "));
10499 printf_vma (section->sh_addr);
10500 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10501 (unsigned long) section->sh_offset, section->sh_link,
10502 printable_section_name (link_section));
10503
10504 off = offset_from_vma (file,
10505 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10506 total * sizeof (short));
10507 edata = (unsigned char *) get_data (NULL, file, off, total,
10508 sizeof (short),
10509 _("version symbol data"));
10510 if (!edata)
10511 {
10512 free (strtab);
10513 free (symbols);
10514 break;
10515 }
10516
10517 data = (short unsigned int *) cmalloc (total, sizeof (short));
10518
10519 for (cnt = total; cnt --;)
10520 data[cnt] = byte_get (edata + cnt * sizeof (short),
10521 sizeof (short));
10522
10523 free (edata);
10524
10525 for (cnt = 0; cnt < total; cnt += 4)
10526 {
10527 int j, nn;
10528 char *name;
10529 char *invalid = _("*invalid*");
10530
10531 printf (" %03x:", cnt);
10532
10533 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10534 switch (data[cnt + j])
10535 {
10536 case 0:
10537 fputs (_(" 0 (*local*) "), stdout);
10538 break;
10539
10540 case 1:
10541 fputs (_(" 1 (*global*) "), stdout);
10542 break;
10543
10544 default:
10545 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10546 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10547
10548 /* If this index value is greater than the size of the symbols
10549 array, break to avoid an out-of-bounds read. */
10550 if ((unsigned long)(cnt + j) >= num_syms)
10551 {
10552 warn (_("invalid index into symbol array\n"));
10553 break;
10554 }
10555
10556 name = NULL;
10557 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10558 {
10559 Elf_Internal_Verneed ivn;
10560 unsigned long offset;
10561
10562 offset = offset_from_vma
10563 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10564 sizeof (Elf_External_Verneed));
10565
10566 do
10567 {
10568 Elf_Internal_Vernaux ivna;
10569 Elf_External_Verneed evn;
10570 Elf_External_Vernaux evna;
10571 unsigned long a_off;
10572
10573 if (get_data (&evn, file, offset, sizeof (evn), 1,
10574 _("version need")) == NULL)
10575 break;
10576
10577 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10578 ivn.vn_next = BYTE_GET (evn.vn_next);
10579
10580 a_off = offset + ivn.vn_aux;
10581
10582 do
10583 {
10584 if (get_data (&evna, file, a_off, sizeof (evna),
10585 1, _("version need aux (2)")) == NULL)
10586 {
10587 ivna.vna_next = 0;
10588 ivna.vna_other = 0;
10589 }
10590 else
10591 {
10592 ivna.vna_next = BYTE_GET (evna.vna_next);
10593 ivna.vna_other = BYTE_GET (evna.vna_other);
10594 }
10595
10596 a_off += ivna.vna_next;
10597 }
10598 while (ivna.vna_other != data[cnt + j]
10599 && ivna.vna_next != 0);
10600
10601 if (ivna.vna_other == data[cnt + j])
10602 {
10603 ivna.vna_name = BYTE_GET (evna.vna_name);
10604
10605 if (ivna.vna_name >= string_sec->sh_size)
10606 name = invalid;
10607 else
10608 name = strtab + ivna.vna_name;
10609 break;
10610 }
10611
10612 offset += ivn.vn_next;
10613 }
10614 while (ivn.vn_next);
10615 }
10616
10617 if (data[cnt + j] != 0x8001
10618 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10619 {
10620 Elf_Internal_Verdef ivd;
10621 Elf_External_Verdef evd;
10622 unsigned long offset;
10623
10624 offset = offset_from_vma
10625 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10626 sizeof evd);
10627
10628 do
10629 {
10630 if (get_data (&evd, file, offset, sizeof (evd), 1,
10631 _("version def")) == NULL)
10632 {
10633 ivd.vd_next = 0;
10634 /* PR 17531: file: 046-1082287-0.004. */
10635 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
10636 break;
10637 }
10638 else
10639 {
10640 ivd.vd_next = BYTE_GET (evd.vd_next);
10641 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10642 }
10643
10644 offset += ivd.vd_next;
10645 }
10646 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10647 && ivd.vd_next != 0);
10648
10649 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10650 {
10651 Elf_External_Verdaux evda;
10652 Elf_Internal_Verdaux ivda;
10653
10654 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10655
10656 if (get_data (&evda, file,
10657 offset - ivd.vd_next + ivd.vd_aux,
10658 sizeof (evda), 1,
10659 _("version def aux")) == NULL)
10660 break;
10661
10662 ivda.vda_name = BYTE_GET (evda.vda_name);
10663
10664 if (ivda.vda_name >= string_sec->sh_size)
10665 name = invalid;
10666 else if (name != NULL && name != invalid)
10667 name = _("*both*");
10668 else
10669 name = strtab + ivda.vda_name;
10670 }
10671 }
10672 if (name != NULL)
10673 nn += printf ("(%s%-*s",
10674 name,
10675 12 - (int) strlen (name),
10676 ")");
10677
10678 if (nn < 18)
10679 printf ("%*c", 18 - nn, ' ');
10680 }
10681
10682 putchar ('\n');
10683 }
10684
10685 free (data);
10686 free (strtab);
10687 free (symbols);
10688 }
10689 break;
10690
10691 default:
10692 break;
10693 }
10694 }
10695
10696 if (! found)
10697 printf (_("\nNo version information found in this file.\n"));
10698
10699 return TRUE;
10700}
10701
10702static const char *
10703get_symbol_binding (unsigned int binding)
10704{
10705 static char buff[32];
10706
10707 switch (binding)
10708 {
10709 case STB_LOCAL: return "LOCAL";
10710 case STB_GLOBAL: return "GLOBAL";
10711 case STB_WEAK: return "WEAK";
10712 default:
10713 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10714 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10715 binding);
10716 else if (binding >= STB_LOOS && binding <= STB_HIOS)
10717 {
10718 if (binding == STB_GNU_UNIQUE
10719 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10720 /* GNU is still using the default value 0. */
10721 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10722 return "UNIQUE";
10723 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10724 }
10725 else
10726 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10727 return buff;
10728 }
10729}
10730
10731static const char *
10732get_symbol_type (unsigned int type)
10733{
10734 static char buff[32];
10735
10736 switch (type)
10737 {
10738 case STT_NOTYPE: return "NOTYPE";
10739 case STT_OBJECT: return "OBJECT";
10740 case STT_FUNC: return "FUNC";
10741 case STT_SECTION: return "SECTION";
10742 case STT_FILE: return "FILE";
10743 case STT_COMMON: return "COMMON";
10744 case STT_TLS: return "TLS";
10745 case STT_RELC: return "RELC";
10746 case STT_SRELC: return "SRELC";
10747 default:
10748 if (type >= STT_LOPROC && type <= STT_HIPROC)
10749 {
10750 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10751 return "THUMB_FUNC";
10752
10753 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10754 return "REGISTER";
10755
10756 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10757 return "PARISC_MILLI";
10758
10759 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10760 }
10761 else if (type >= STT_LOOS && type <= STT_HIOS)
10762 {
10763 if (elf_header.e_machine == EM_PARISC)
10764 {
10765 if (type == STT_HP_OPAQUE)
10766 return "HP_OPAQUE";
10767 if (type == STT_HP_STUB)
10768 return "HP_STUB";
10769 }
10770
10771 if (type == STT_GNU_IFUNC
10772 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10773 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10774 /* GNU is still using the default value 0. */
10775 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10776 return "IFUNC";
10777
10778 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10779 }
10780 else
10781 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10782 return buff;
10783 }
10784}
10785
10786static const char *
10787get_symbol_visibility (unsigned int visibility)
10788{
10789 switch (visibility)
10790 {
10791 case STV_DEFAULT: return "DEFAULT";
10792 case STV_INTERNAL: return "INTERNAL";
10793 case STV_HIDDEN: return "HIDDEN";
10794 case STV_PROTECTED: return "PROTECTED";
10795 default:
10796 error (_("Unrecognized visibility value: %u"), visibility);
10797 return _("<unknown>");
10798 }
10799}
10800
10801static const char *
10802get_solaris_symbol_visibility (unsigned int visibility)
10803{
10804 switch (visibility)
10805 {
10806 case 4: return "EXPORTED";
10807 case 5: return "SINGLETON";
10808 case 6: return "ELIMINATE";
10809 default: return get_symbol_visibility (visibility);
10810 }
10811}
10812
10813static const char *
10814get_mips_symbol_other (unsigned int other)
10815{
10816 switch (other)
10817 {
10818 case STO_OPTIONAL: return "OPTIONAL";
10819 case STO_MIPS_PLT: return "MIPS PLT";
10820 case STO_MIPS_PIC: return "MIPS PIC";
10821 case STO_MICROMIPS: return "MICROMIPS";
10822 case STO_MICROMIPS | STO_MIPS_PIC: return "MICROMIPS, MIPS PIC";
10823 case STO_MIPS16: return "MIPS16";
10824 default: return NULL;
10825 }
10826}
10827
10828static const char *
10829get_ia64_symbol_other (unsigned int other)
10830{
10831 if (is_ia64_vms ())
10832 {
10833 static char res[32];
10834
10835 res[0] = 0;
10836
10837 /* Function types is for images and .STB files only. */
10838 switch (elf_header.e_type)
10839 {
10840 case ET_DYN:
10841 case ET_EXEC:
10842 switch (VMS_ST_FUNC_TYPE (other))
10843 {
10844 case VMS_SFT_CODE_ADDR:
10845 strcat (res, " CA");
10846 break;
10847 case VMS_SFT_SYMV_IDX:
10848 strcat (res, " VEC");
10849 break;
10850 case VMS_SFT_FD:
10851 strcat (res, " FD");
10852 break;
10853 case VMS_SFT_RESERVE:
10854 strcat (res, " RSV");
10855 break;
10856 default:
10857 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10858 VMS_ST_FUNC_TYPE (other));
10859 strcat (res, " <unknown>");
10860 break;
10861 }
10862 break;
10863 default:
10864 break;
10865 }
10866 switch (VMS_ST_LINKAGE (other))
10867 {
10868 case VMS_STL_IGNORE:
10869 strcat (res, " IGN");
10870 break;
10871 case VMS_STL_RESERVE:
10872 strcat (res, " RSV");
10873 break;
10874 case VMS_STL_STD:
10875 strcat (res, " STD");
10876 break;
10877 case VMS_STL_LNK:
10878 strcat (res, " LNK");
10879 break;
10880 default:
10881 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10882 VMS_ST_LINKAGE (other));
10883 strcat (res, " <unknown>");
10884 break;
10885 }
10886
10887 if (res[0] != 0)
10888 return res + 1;
10889 else
10890 return res;
10891 }
10892 return NULL;
10893}
10894
10895static const char *
10896get_ppc64_symbol_other (unsigned int other)
10897{
10898 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10899 {
10900 static char buf[32];
10901 snprintf (buf, sizeof buf, _("<localentry>: %d"),
10902 PPC64_LOCAL_ENTRY_OFFSET (other));
10903 return buf;
10904 }
10905 return NULL;
10906}
10907
10908static const char *
10909get_symbol_other (unsigned int other)
10910{
10911 const char * result = NULL;
10912 static char buff [32];
10913
10914 if (other == 0)
10915 return "";
10916
10917 switch (elf_header.e_machine)
10918 {
10919 case EM_MIPS:
10920 result = get_mips_symbol_other (other);
10921 break;
10922 case EM_IA_64:
10923 result = get_ia64_symbol_other (other);
10924 break;
10925 case EM_PPC64:
10926 result = get_ppc64_symbol_other (other);
10927 break;
10928 default:
10929 result = NULL;
10930 break;
10931 }
10932
10933 if (result)
10934 return result;
10935
10936 snprintf (buff, sizeof buff, _("<other>: %x"), other);
10937 return buff;
10938}
10939
10940static const char *
10941get_symbol_index_type (unsigned int type)
10942{
10943 static char buff[32];
10944
10945 switch (type)
10946 {
10947 case SHN_UNDEF: return "UND";
10948 case SHN_ABS: return "ABS";
10949 case SHN_COMMON: return "COM";
10950 default:
10951 if (type == SHN_IA_64_ANSI_COMMON
10952 && elf_header.e_machine == EM_IA_64
10953 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10954 return "ANSI_COM";
10955 else if ((elf_header.e_machine == EM_X86_64
10956 || elf_header.e_machine == EM_L1OM
10957 || elf_header.e_machine == EM_K1OM)
10958 && type == SHN_X86_64_LCOMMON)
10959 return "LARGE_COM";
10960 else if ((type == SHN_MIPS_SCOMMON
10961 && elf_header.e_machine == EM_MIPS)
10962 || (type == SHN_TIC6X_SCOMMON
10963 && elf_header.e_machine == EM_TI_C6000))
10964 return "SCOM";
10965 else if (type == SHN_MIPS_SUNDEFINED
10966 && elf_header.e_machine == EM_MIPS)
10967 return "SUND";
10968 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
10969 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
10970 else if (type >= SHN_LOOS && type <= SHN_HIOS)
10971 sprintf (buff, "OS [0x%04x]", type & 0xffff);
10972 else if (type >= SHN_LORESERVE)
10973 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
10974 else if (type >= elf_header.e_shnum)
10975 sprintf (buff, _("bad section index[%3d]"), type);
10976 else
10977 sprintf (buff, "%3d", type);
10978 break;
10979 }
10980
10981 return buff;
10982}
10983
10984static bfd_vma *
10985get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
10986{
10987 unsigned char * e_data;
10988 bfd_vma * i_data;
10989
10990 /* If the size_t type is smaller than the bfd_size_type, eg because
10991 you are building a 32-bit tool on a 64-bit host, then make sure
10992 that when (number) is cast to (size_t) no information is lost. */
10993 if (sizeof (size_t) < sizeof (bfd_size_type)
10994 && (bfd_size_type) ((size_t) number) != number)
10995 {
10996 error (_("Size truncation prevents reading %s elements of size %u\n"),
10997 bfd_vmatoa ("u", number), ent_size);
10998 return NULL;
10999 }
11000
11001 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11002 attempting to allocate memory when the read is bound to fail. */
11003 if (ent_size * number > current_file_size)
11004 {
11005 error (_("Invalid number of dynamic entries: %s\n"),
11006 bfd_vmatoa ("u", number));
11007 return NULL;
11008 }
11009
11010 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
11011 if (e_data == NULL)
11012 {
11013 error (_("Out of memory reading %s dynamic entries\n"),
11014 bfd_vmatoa ("u", number));
11015 return NULL;
11016 }
11017
11018 if (fread (e_data, ent_size, (size_t) number, file) != number)
11019 {
11020 error (_("Unable to read in %s bytes of dynamic data\n"),
11021 bfd_vmatoa ("u", number * ent_size));
11022 free (e_data);
11023 return NULL;
11024 }
11025
11026 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
11027 if (i_data == NULL)
11028 {
11029 error (_("Out of memory allocating space for %s dynamic entries\n"),
11030 bfd_vmatoa ("u", number));
11031 free (e_data);
11032 return NULL;
11033 }
11034
11035 while (number--)
11036 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
11037
11038 free (e_data);
11039
11040 return i_data;
11041}
11042
11043static void
11044print_dynamic_symbol (bfd_vma si, unsigned long hn)
11045{
11046 Elf_Internal_Sym * psym;
11047 int n;
11048
11049 n = print_vma (si, DEC_5);
11050 if (n < 5)
11051 fputs (&" "[n], stdout);
11052 printf (" %3lu: ", hn);
11053
11054 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
11055 {
11056 printf (_("<No info available for dynamic symbol number %lu>\n"),
11057 (unsigned long) si);
11058 return;
11059 }
11060
11061 psym = dynamic_symbols + si;
11062 print_vma (psym->st_value, LONG_HEX);
11063 putchar (' ');
11064 print_vma (psym->st_size, DEC_5);
11065
11066 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
11067 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
11068
11069 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11070 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
11071 else
11072 {
11073 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11074
11075 printf (" %-7s", get_symbol_visibility (vis));
11076 /* Check to see if any other bits in the st_other field are set.
11077 Note - displaying this information disrupts the layout of the
11078 table being generated, but for the moment this case is very
11079 rare. */
11080 if (psym->st_other ^ vis)
11081 printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
11082 }
11083
11084 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
11085 if (VALID_DYNAMIC_NAME (psym->st_name))
11086 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11087 else
11088 printf (_(" <corrupt: %14ld>"), psym->st_name);
11089 putchar ('\n');
11090}
11091
11092static const char *
11093get_symbol_version_string (FILE * file,
11094 bfd_boolean is_dynsym,
11095 const char * strtab,
11096 unsigned long int strtab_size,
11097 unsigned int si,
11098 Elf_Internal_Sym * psym,
11099 enum versioned_symbol_info * sym_info,
11100 unsigned short * vna_other)
11101{
11102 unsigned char data[2];
11103 unsigned short vers_data;
11104 unsigned long offset;
11105
11106 if (!is_dynsym
11107 || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11108 return NULL;
11109
11110 offset = offset_from_vma (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11111 sizeof data + si * sizeof (vers_data));
11112
11113 if (get_data (&data, file, offset + si * sizeof (vers_data),
11114 sizeof (data), 1, _("version data")) == NULL)
11115 return NULL;
11116
11117 vers_data = byte_get (data, 2);
11118
11119 if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
11120 return NULL;
11121
11122 /* Usually we'd only see verdef for defined symbols, and verneed for
11123 undefined symbols. However, symbols defined by the linker in
11124 .dynbss for variables copied from a shared library in order to
11125 avoid text relocations are defined yet have verneed. We could
11126 use a heuristic to detect the special case, for example, check
11127 for verneed first on symbols defined in SHT_NOBITS sections, but
11128 it is simpler and more reliable to just look for both verdef and
11129 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11130
11131 if (psym->st_shndx != SHN_UNDEF
11132 && vers_data != 0x8001
11133 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11134 {
11135 Elf_Internal_Verdef ivd;
11136 Elf_Internal_Verdaux ivda;
11137 Elf_External_Verdaux evda;
11138 unsigned long off;
11139
11140 off = offset_from_vma (file,
11141 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11142 sizeof (Elf_External_Verdef));
11143
11144 do
11145 {
11146 Elf_External_Verdef evd;
11147
11148 if (get_data (&evd, file, off, sizeof (evd), 1,
11149 _("version def")) == NULL)
11150 {
11151 ivd.vd_ndx = 0;
11152 ivd.vd_aux = 0;
11153 ivd.vd_next = 0;
11154 }
11155 else
11156 {
11157 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11158 ivd.vd_aux = BYTE_GET (evd.vd_aux);
11159 ivd.vd_next = BYTE_GET (evd.vd_next);
11160 }
11161
11162 off += ivd.vd_next;
11163 }
11164 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11165
11166 if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11167 {
11168 off -= ivd.vd_next;
11169 off += ivd.vd_aux;
11170
11171 if (get_data (&evda, file, off, sizeof (evda), 1,
11172 _("version def aux")) != NULL)
11173 {
11174 ivda.vda_name = BYTE_GET (evda.vda_name);
11175
11176 if (psym->st_name != ivda.vda_name)
11177 {
11178 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11179 ? symbol_hidden : symbol_public);
11180 return (ivda.vda_name < strtab_size
11181 ? strtab + ivda.vda_name : _("<corrupt>"));
11182 }
11183 }
11184 }
11185 }
11186
11187 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11188 {
11189 Elf_External_Verneed evn;
11190 Elf_Internal_Verneed ivn;
11191 Elf_Internal_Vernaux ivna;
11192
11193 offset = offset_from_vma (file,
11194 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11195 sizeof evn);
11196 do
11197 {
11198 unsigned long vna_off;
11199
11200 if (get_data (&evn, file, offset, sizeof (evn), 1,
11201 _("version need")) == NULL)
11202 {
11203 ivna.vna_next = 0;
11204 ivna.vna_other = 0;
11205 ivna.vna_name = 0;
11206 break;
11207 }
11208
11209 ivn.vn_aux = BYTE_GET (evn.vn_aux);
11210 ivn.vn_next = BYTE_GET (evn.vn_next);
11211
11212 vna_off = offset + ivn.vn_aux;
11213
11214 do
11215 {
11216 Elf_External_Vernaux evna;
11217
11218 if (get_data (&evna, file, vna_off, sizeof (evna), 1,
11219 _("version need aux (3)")) == NULL)
11220 {
11221 ivna.vna_next = 0;
11222 ivna.vna_other = 0;
11223 ivna.vna_name = 0;
11224 }
11225 else
11226 {
11227 ivna.vna_other = BYTE_GET (evna.vna_other);
11228 ivna.vna_next = BYTE_GET (evna.vna_next);
11229 ivna.vna_name = BYTE_GET (evna.vna_name);
11230 }
11231
11232 vna_off += ivna.vna_next;
11233 }
11234 while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11235
11236 if (ivna.vna_other == vers_data)
11237 break;
11238
11239 offset += ivn.vn_next;
11240 }
11241 while (ivn.vn_next != 0);
11242
11243 if (ivna.vna_other == vers_data)
11244 {
11245 *sym_info = symbol_undefined;
11246 *vna_other = ivna.vna_other;
11247 return (ivna.vna_name < strtab_size
11248 ? strtab + ivna.vna_name : _("<corrupt>"));
11249 }
11250 }
11251 return NULL;
11252}
11253
11254/* Dump the symbol table. */
11255static bfd_boolean
11256process_symbol_table (FILE * file)
11257{
11258 Elf_Internal_Shdr * section;
11259 bfd_size_type nbuckets = 0;
11260 bfd_size_type nchains = 0;
11261 bfd_vma * buckets = NULL;
11262 bfd_vma * chains = NULL;
11263 bfd_vma ngnubuckets = 0;
11264 bfd_vma * gnubuckets = NULL;
11265 bfd_vma * gnuchains = NULL;
11266 bfd_vma gnusymidx = 0;
11267 bfd_size_type ngnuchains = 0;
11268
11269 if (!do_syms && !do_dyn_syms && !do_histogram)
11270 return TRUE;
11271
11272 if (dynamic_info[DT_HASH]
11273 && (do_histogram
11274 || (do_using_dynamic
11275 && !do_dyn_syms
11276 && dynamic_strings != NULL)))
11277 {
11278 unsigned char nb[8];
11279 unsigned char nc[8];
11280 unsigned int hash_ent_size = 4;
11281
11282 if ((elf_header.e_machine == EM_ALPHA
11283 || elf_header.e_machine == EM_S390
11284 || elf_header.e_machine == EM_S390_OLD)
11285 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
11286 hash_ent_size = 8;
11287
11288 if (fseek (file,
11289 (archive_file_offset
11290 + offset_from_vma (file, dynamic_info[DT_HASH],
11291 sizeof nb + sizeof nc)),
11292 SEEK_SET))
11293 {
11294 error (_("Unable to seek to start of dynamic information\n"));
11295 goto no_hash;
11296 }
11297
11298 if (fread (nb, hash_ent_size, 1, file) != 1)
11299 {
11300 error (_("Failed to read in number of buckets\n"));
11301 goto no_hash;
11302 }
11303
11304 if (fread (nc, hash_ent_size, 1, file) != 1)
11305 {
11306 error (_("Failed to read in number of chains\n"));
11307 goto no_hash;
11308 }
11309
11310 nbuckets = byte_get (nb, hash_ent_size);
11311 nchains = byte_get (nc, hash_ent_size);
11312
11313 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
11314 chains = get_dynamic_data (file, nchains, hash_ent_size);
11315
11316 no_hash:
11317 if (buckets == NULL || chains == NULL)
11318 {
11319 if (do_using_dynamic)
11320 return FALSE;
11321 free (buckets);
11322 free (chains);
11323 buckets = NULL;
11324 chains = NULL;
11325 nbuckets = 0;
11326 nchains = 0;
11327 }
11328 }
11329
11330 if (dynamic_info_DT_GNU_HASH
11331 && (do_histogram
11332 || (do_using_dynamic
11333 && !do_dyn_syms
11334 && dynamic_strings != NULL)))
11335 {
11336 unsigned char nb[16];
11337 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11338 bfd_vma buckets_vma;
11339
11340 if (fseek (file,
11341 (archive_file_offset
11342 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
11343 sizeof nb)),
11344 SEEK_SET))
11345 {
11346 error (_("Unable to seek to start of dynamic information\n"));
11347 goto no_gnu_hash;
11348 }
11349
11350 if (fread (nb, 16, 1, file) != 1)
11351 {
11352 error (_("Failed to read in number of buckets\n"));
11353 goto no_gnu_hash;
11354 }
11355
11356 ngnubuckets = byte_get (nb, 4);
11357 gnusymidx = byte_get (nb + 4, 4);
11358 bitmaskwords = byte_get (nb + 8, 4);
11359 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11360 if (is_32bit_elf)
11361 buckets_vma += bitmaskwords * 4;
11362 else
11363 buckets_vma += bitmaskwords * 8;
11364
11365 if (fseek (file,
11366 (archive_file_offset
11367 + offset_from_vma (file, buckets_vma, 4)),
11368 SEEK_SET))
11369 {
11370 error (_("Unable to seek to start of dynamic information\n"));
11371 goto no_gnu_hash;
11372 }
11373
11374 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
11375
11376 if (gnubuckets == NULL)
11377 goto no_gnu_hash;
11378
11379 for (i = 0; i < ngnubuckets; i++)
11380 if (gnubuckets[i] != 0)
11381 {
11382 if (gnubuckets[i] < gnusymidx)
11383 return FALSE;
11384
11385 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11386 maxchain = gnubuckets[i];
11387 }
11388
11389 if (maxchain == 0xffffffff)
11390 goto no_gnu_hash;
11391
11392 maxchain -= gnusymidx;
11393
11394 if (fseek (file,
11395 (archive_file_offset
11396 + offset_from_vma (file, buckets_vma
11397 + 4 * (ngnubuckets + maxchain), 4)),
11398 SEEK_SET))
11399 {
11400 error (_("Unable to seek to start of dynamic information\n"));
11401 goto no_gnu_hash;
11402 }
11403
11404 do
11405 {
11406 if (fread (nb, 4, 1, file) != 1)
11407 {
11408 error (_("Failed to determine last chain length\n"));
11409 goto no_gnu_hash;
11410 }
11411
11412 if (maxchain + 1 == 0)
11413 goto no_gnu_hash;
11414
11415 ++maxchain;
11416 }
11417 while ((byte_get (nb, 4) & 1) == 0);
11418
11419 if (fseek (file,
11420 (archive_file_offset
11421 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
11422 SEEK_SET))
11423 {
11424 error (_("Unable to seek to start of dynamic information\n"));
11425 goto no_gnu_hash;
11426 }
11427
11428 gnuchains = get_dynamic_data (file, maxchain, 4);
11429 ngnuchains = maxchain;
11430
11431 no_gnu_hash:
11432 if (gnuchains == NULL)
11433 {
11434 free (gnubuckets);
11435 gnubuckets = NULL;
11436 ngnubuckets = 0;
11437 if (do_using_dynamic)
11438 return FALSE;
11439 }
11440 }
11441
11442 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11443 && do_syms
11444 && do_using_dynamic
11445 && dynamic_strings != NULL
11446 && dynamic_symbols != NULL)
11447 {
11448 unsigned long hn;
11449
11450 if (dynamic_info[DT_HASH])
11451 {
11452 bfd_vma si;
11453 char *visited;
11454
11455 printf (_("\nSymbol table for image:\n"));
11456 if (is_32bit_elf)
11457 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11458 else
11459 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11460
11461 visited = xcmalloc (nchains, 1);
11462 memset (visited, 0, nchains);
11463 for (hn = 0; hn < nbuckets; hn++)
11464 {
11465 for (si = buckets[hn]; si > 0; si = chains[si])
11466 {
11467 print_dynamic_symbol (si, hn);
11468 if (si >= nchains || visited[si])
11469 {
11470 error (_("histogram chain is corrupt\n"));
11471 break;
11472 }
11473 visited[si] = 1;
11474 }
11475 }
11476 free (visited);
11477 }
11478
11479 if (dynamic_info_DT_GNU_HASH)
11480 {
11481 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11482 if (is_32bit_elf)
11483 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11484 else
11485 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11486
11487 for (hn = 0; hn < ngnubuckets; ++hn)
11488 if (gnubuckets[hn] != 0)
11489 {
11490 bfd_vma si = gnubuckets[hn];
11491 bfd_vma off = si - gnusymidx;
11492
11493 do
11494 {
11495 print_dynamic_symbol (si, hn);
11496 si++;
11497 }
11498 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11499 }
11500 }
11501 }
11502 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11503 && section_headers != NULL)
11504 {
11505 unsigned int i;
11506
11507 for (i = 0, section = section_headers;
11508 i < elf_header.e_shnum;
11509 i++, section++)
11510 {
11511 unsigned int si;
11512 char * strtab = NULL;
11513 unsigned long int strtab_size = 0;
11514 Elf_Internal_Sym * symtab;
11515 Elf_Internal_Sym * psym;
11516 unsigned long num_syms;
11517
11518 if ((section->sh_type != SHT_SYMTAB
11519 && section->sh_type != SHT_DYNSYM)
11520 || (!do_syms
11521 && section->sh_type == SHT_SYMTAB))
11522 continue;
11523
11524 if (section->sh_entsize == 0)
11525 {
11526 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11527 printable_section_name (section));
11528 continue;
11529 }
11530
11531 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
11532 printable_section_name (section),
11533 (unsigned long) (section->sh_size / section->sh_entsize));
11534
11535 if (is_32bit_elf)
11536 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11537 else
11538 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11539
11540 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
11541 if (symtab == NULL)
11542 continue;
11543
11544 if (section->sh_link == elf_header.e_shstrndx)
11545 {
11546 strtab = string_table;
11547 strtab_size = string_table_length;
11548 }
11549 else if (section->sh_link < elf_header.e_shnum)
11550 {
11551 Elf_Internal_Shdr * string_sec;
11552
11553 string_sec = section_headers + section->sh_link;
11554
11555 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
11556 1, string_sec->sh_size,
11557 _("string table"));
11558 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11559 }
11560
11561 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11562 {
11563 const char *version_string;
11564 enum versioned_symbol_info sym_info;
11565 unsigned short vna_other;
11566
11567 printf ("%6d: ", si);
11568 print_vma (psym->st_value, LONG_HEX);
11569 putchar (' ');
11570 print_vma (psym->st_size, DEC_5);
11571 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
11572 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
11573 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11574 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
11575 else
11576 {
11577 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11578
11579 printf (" %-7s", get_symbol_visibility (vis));
11580 /* Check to see if any other bits in the st_other field are set.
11581 Note - displaying this information disrupts the layout of the
11582 table being generated, but for the moment this case is very rare. */
11583 if (psym->st_other ^ vis)
11584 printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
11585 }
11586 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
11587 print_symbol (25, psym->st_name < strtab_size
11588 ? strtab + psym->st_name : _("<corrupt>"));
11589
11590 version_string
11591 = get_symbol_version_string (file,
11592 section->sh_type == SHT_DYNSYM,
11593 strtab, strtab_size, si,
11594 psym, &sym_info, &vna_other);
11595 if (version_string)
11596 {
11597 if (sym_info == symbol_undefined)
11598 printf ("@%s (%d)", version_string, vna_other);
11599 else
11600 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11601 version_string);
11602 }
11603
11604 putchar ('\n');
11605
11606 if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
11607 && si >= section->sh_info
11608 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11609 && elf_header.e_machine != EM_MIPS
11610 /* Solaris binaries have been found to violate this requirement as
11611 well. Not sure if this is a bug or an ABI requirement. */
11612 && elf_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
11613 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11614 si, printable_section_name (section), section->sh_info);
11615 }
11616
11617 free (symtab);
11618 if (strtab != string_table)
11619 free (strtab);
11620 }
11621 }
11622 else if (do_syms)
11623 printf
11624 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11625
11626 if (do_histogram && buckets != NULL)
11627 {
11628 unsigned long * lengths;
11629 unsigned long * counts;
11630 unsigned long hn;
11631 bfd_vma si;
11632 unsigned long maxlength = 0;
11633 unsigned long nzero_counts = 0;
11634 unsigned long nsyms = 0;
11635 char *visited;
11636
11637 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11638 (unsigned long) nbuckets);
11639
11640 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11641 if (lengths == NULL)
11642 {
11643 error (_("Out of memory allocating space for histogram buckets\n"));
11644 return FALSE;
11645 }
11646 visited = xcmalloc (nchains, 1);
11647 memset (visited, 0, nchains);
11648
11649 printf (_(" Length Number %% of total Coverage\n"));
11650 for (hn = 0; hn < nbuckets; ++hn)
11651 {
11652 for (si = buckets[hn]; si > 0; si = chains[si])
11653 {
11654 ++nsyms;
11655 if (maxlength < ++lengths[hn])
11656 ++maxlength;
11657 if (si >= nchains || visited[si])
11658 {
11659 error (_("histogram chain is corrupt\n"));
11660 break;
11661 }
11662 visited[si] = 1;
11663 }
11664 }
11665 free (visited);
11666
11667 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11668 if (counts == NULL)
11669 {
11670 free (lengths);
11671 error (_("Out of memory allocating space for histogram counts\n"));
11672 return FALSE;
11673 }
11674
11675 for (hn = 0; hn < nbuckets; ++hn)
11676 ++counts[lengths[hn]];
11677
11678 if (nbuckets > 0)
11679 {
11680 unsigned long i;
11681 printf (" 0 %-10lu (%5.1f%%)\n",
11682 counts[0], (counts[0] * 100.0) / nbuckets);
11683 for (i = 1; i <= maxlength; ++i)
11684 {
11685 nzero_counts += counts[i] * i;
11686 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11687 i, counts[i], (counts[i] * 100.0) / nbuckets,
11688 (nzero_counts * 100.0) / nsyms);
11689 }
11690 }
11691
11692 free (counts);
11693 free (lengths);
11694 }
11695
11696 if (buckets != NULL)
11697 {
11698 free (buckets);
11699 free (chains);
11700 }
11701
11702 if (do_histogram && gnubuckets != NULL)
11703 {
11704 unsigned long * lengths;
11705 unsigned long * counts;
11706 unsigned long hn;
11707 unsigned long maxlength = 0;
11708 unsigned long nzero_counts = 0;
11709 unsigned long nsyms = 0;
11710
11711 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11712 (unsigned long) ngnubuckets);
11713
11714 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11715 if (lengths == NULL)
11716 {
11717 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11718 return FALSE;
11719 }
11720
11721 printf (_(" Length Number %% of total Coverage\n"));
11722
11723 for (hn = 0; hn < ngnubuckets; ++hn)
11724 if (gnubuckets[hn] != 0)
11725 {
11726 bfd_vma off, length = 1;
11727
11728 for (off = gnubuckets[hn] - gnusymidx;
11729 /* PR 17531 file: 010-77222-0.004. */
11730 off < ngnuchains && (gnuchains[off] & 1) == 0;
11731 ++off)
11732 ++length;
11733 lengths[hn] = length;
11734 if (length > maxlength)
11735 maxlength = length;
11736 nsyms += length;
11737 }
11738
11739 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11740 if (counts == NULL)
11741 {
11742 free (lengths);
11743 error (_("Out of memory allocating space for gnu histogram counts\n"));
11744 return FALSE;
11745 }
11746
11747 for (hn = 0; hn < ngnubuckets; ++hn)
11748 ++counts[lengths[hn]];
11749
11750 if (ngnubuckets > 0)
11751 {
11752 unsigned long j;
11753 printf (" 0 %-10lu (%5.1f%%)\n",
11754 counts[0], (counts[0] * 100.0) / ngnubuckets);
11755 for (j = 1; j <= maxlength; ++j)
11756 {
11757 nzero_counts += counts[j] * j;
11758 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11759 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11760 (nzero_counts * 100.0) / nsyms);
11761 }
11762 }
11763
11764 free (counts);
11765 free (lengths);
11766 free (gnubuckets);
11767 free (gnuchains);
11768 }
11769
11770 return TRUE;
11771}
11772
11773static bfd_boolean
11774process_syminfo (FILE * file ATTRIBUTE_UNUSED)
11775{
11776 unsigned int i;
11777
11778 if (dynamic_syminfo == NULL
11779 || !do_dynamic)
11780 /* No syminfo, this is ok. */
11781 return TRUE;
11782
11783 /* There better should be a dynamic symbol section. */
11784 if (dynamic_symbols == NULL || dynamic_strings == NULL)
11785 return FALSE;
11786
11787 if (dynamic_addr)
11788 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11789 dynamic_syminfo_offset, dynamic_syminfo_nent);
11790
11791 printf (_(" Num: Name BoundTo Flags\n"));
11792 for (i = 0; i < dynamic_syminfo_nent; ++i)
11793 {
11794 unsigned short int flags = dynamic_syminfo[i].si_flags;
11795
11796 printf ("%4d: ", i);
11797 if (i >= num_dynamic_syms)
11798 printf (_("<corrupt index>"));
11799 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
11800 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11801 else
11802 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
11803 putchar (' ');
11804
11805 switch (dynamic_syminfo[i].si_boundto)
11806 {
11807 case SYMINFO_BT_SELF:
11808 fputs ("SELF ", stdout);
11809 break;
11810 case SYMINFO_BT_PARENT:
11811 fputs ("PARENT ", stdout);
11812 break;
11813 default:
11814 if (dynamic_syminfo[i].si_boundto > 0
11815 && dynamic_syminfo[i].si_boundto < dynamic_nent
11816 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
11817 {
11818 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
11819 putchar (' ' );
11820 }
11821 else
11822 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11823 break;
11824 }
11825
11826 if (flags & SYMINFO_FLG_DIRECT)
11827 printf (" DIRECT");
11828 if (flags & SYMINFO_FLG_PASSTHRU)
11829 printf (" PASSTHRU");
11830 if (flags & SYMINFO_FLG_COPY)
11831 printf (" COPY");
11832 if (flags & SYMINFO_FLG_LAZYLOAD)
11833 printf (" LAZYLOAD");
11834
11835 puts ("");
11836 }
11837
11838 return TRUE;
11839}
11840
11841#define IN_RANGE(START,END,ADDR,OFF) \
11842 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11843
11844/* Check to see if the given reloc needs to be handled in a target specific
11845 manner. If so then process the reloc and return TRUE otherwise return
11846 FALSE.
11847
11848 If called with reloc == NULL, then this is a signal that reloc processing
11849 for the current section has finished, and any saved state should be
11850 discarded. */
11851
11852static bfd_boolean
11853target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11854 unsigned char * start,
11855 unsigned char * end,
11856 Elf_Internal_Sym * symtab,
11857 unsigned long num_syms)
11858{
11859 unsigned int reloc_type = 0;
11860 unsigned long sym_index = 0;
11861
11862 if (reloc)
11863 {
11864 reloc_type = get_reloc_type (reloc->r_info);
11865 sym_index = get_reloc_symindex (reloc->r_info);
11866 }
11867
11868 switch (elf_header.e_machine)
11869 {
11870 case EM_MSP430:
11871 case EM_MSP430_OLD:
11872 {
11873 static Elf_Internal_Sym * saved_sym = NULL;
11874
11875 if (reloc == NULL)
11876 {
11877 saved_sym = NULL;
11878 return TRUE;
11879 }
11880
11881 switch (reloc_type)
11882 {
11883 case 10: /* R_MSP430_SYM_DIFF */
11884 if (uses_msp430x_relocs ())
11885 break;
11886 /* Fall through. */
11887 case 21: /* R_MSP430X_SYM_DIFF */
11888 /* PR 21139. */
11889 if (sym_index >= num_syms)
11890 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11891 sym_index);
11892 else
11893 saved_sym = symtab + sym_index;
11894 return TRUE;
11895
11896 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11897 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11898 goto handle_sym_diff;
11899
11900 case 5: /* R_MSP430_16_BYTE */
11901 case 9: /* R_MSP430_8 */
11902 if (uses_msp430x_relocs ())
11903 break;
11904 goto handle_sym_diff;
11905
11906 case 2: /* R_MSP430_ABS16 */
11907 case 15: /* R_MSP430X_ABS16 */
11908 if (! uses_msp430x_relocs ())
11909 break;
11910 goto handle_sym_diff;
11911
11912 handle_sym_diff:
11913 if (saved_sym != NULL)
11914 {
11915 int reloc_size = reloc_type == 1 ? 4 : 2;
11916 bfd_vma value;
11917
11918 if (sym_index >= num_syms)
11919 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
11920 sym_index);
11921 else
11922 {
11923 value = reloc->r_addend + (symtab[sym_index].st_value
11924 - saved_sym->st_value);
11925
11926 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
11927 byte_put (start + reloc->r_offset, value, reloc_size);
11928 else
11929 /* PR 21137 */
11930 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
11931 (long) reloc->r_offset);
11932 }
11933
11934 saved_sym = NULL;
11935 return TRUE;
11936 }
11937 break;
11938
11939 default:
11940 if (saved_sym != NULL)
11941 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11942 break;
11943 }
11944 break;
11945 }
11946
11947 case EM_MN10300:
11948 case EM_CYGNUS_MN10300:
11949 {
11950 static Elf_Internal_Sym * saved_sym = NULL;
11951
11952 if (reloc == NULL)
11953 {
11954 saved_sym = NULL;
11955 return TRUE;
11956 }
11957
11958 switch (reloc_type)
11959 {
11960 case 34: /* R_MN10300_ALIGN */
11961 return TRUE;
11962 case 33: /* R_MN10300_SYM_DIFF */
11963 if (sym_index >= num_syms)
11964 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
11965 sym_index);
11966 else
11967 saved_sym = symtab + sym_index;
11968 return TRUE;
11969
11970 case 1: /* R_MN10300_32 */
11971 case 2: /* R_MN10300_16 */
11972 if (saved_sym != NULL)
11973 {
11974 int reloc_size = reloc_type == 1 ? 4 : 2;
11975 bfd_vma value;
11976
11977 if (sym_index >= num_syms)
11978 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
11979 sym_index);
11980 else
11981 {
11982 value = reloc->r_addend + (symtab[sym_index].st_value
11983 - saved_sym->st_value);
11984
11985 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
11986 byte_put (start + reloc->r_offset, value, reloc_size);
11987 else
11988 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
11989 (long) reloc->r_offset);
11990 }
11991
11992 saved_sym = NULL;
11993 return TRUE;
11994 }
11995 break;
11996 default:
11997 if (saved_sym != NULL)
11998 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11999 break;
12000 }
12001 break;
12002 }
12003
12004 case EM_RL78:
12005 {
12006 static bfd_vma saved_sym1 = 0;
12007 static bfd_vma saved_sym2 = 0;
12008 static bfd_vma value;
12009
12010 if (reloc == NULL)
12011 {
12012 saved_sym1 = saved_sym2 = 0;
12013 return TRUE;
12014 }
12015
12016 switch (reloc_type)
12017 {
12018 case 0x80: /* R_RL78_SYM. */
12019 saved_sym1 = saved_sym2;
12020 if (sym_index >= num_syms)
12021 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12022 sym_index);
12023 else
12024 {
12025 saved_sym2 = symtab[sym_index].st_value;
12026 saved_sym2 += reloc->r_addend;
12027 }
12028 return TRUE;
12029
12030 case 0x83: /* R_RL78_OPsub. */
12031 value = saved_sym1 - saved_sym2;
12032 saved_sym2 = saved_sym1 = 0;
12033 return TRUE;
12034 break;
12035
12036 case 0x41: /* R_RL78_ABS32. */
12037 if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12038 byte_put (start + reloc->r_offset, value, 4);
12039 else
12040 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12041 (long) reloc->r_offset);
12042 value = 0;
12043 return TRUE;
12044
12045 case 0x43: /* R_RL78_ABS16. */
12046 if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12047 byte_put (start + reloc->r_offset, value, 2);
12048 else
12049 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12050 (long) reloc->r_offset);
12051 value = 0;
12052 return TRUE;
12053
12054 default:
12055 break;
12056 }
12057 break;
12058 }
12059 }
12060
12061 return FALSE;
12062}
12063
12064/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12065 DWARF debug sections. This is a target specific test. Note - we do not
12066 go through the whole including-target-headers-multiple-times route, (as
12067 we have already done with <elf/h8.h>) because this would become very
12068 messy and even then this function would have to contain target specific
12069 information (the names of the relocs instead of their numeric values).
12070 FIXME: This is not the correct way to solve this problem. The proper way
12071 is to have target specific reloc sizing and typing functions created by
12072 the reloc-macros.h header, in the same way that it already creates the
12073 reloc naming functions. */
12074
12075static bfd_boolean
12076is_32bit_abs_reloc (unsigned int reloc_type)
12077{
12078 /* Please keep this table alpha-sorted for ease of visual lookup. */
12079 switch (elf_header.e_machine)
12080 {
12081 case EM_386:
12082 case EM_IAMCU:
12083 return reloc_type == 1; /* R_386_32. */
12084 case EM_68K:
12085 return reloc_type == 1; /* R_68K_32. */
12086 case EM_860:
12087 return reloc_type == 1; /* R_860_32. */
12088 case EM_960:
12089 return reloc_type == 2; /* R_960_32. */
12090 case EM_AARCH64:
12091 return (reloc_type == 258
12092 || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12093 case EM_ADAPTEVA_EPIPHANY:
12094 return reloc_type == 3;
12095 case EM_ALPHA:
12096 return reloc_type == 1; /* R_ALPHA_REFLONG. */
12097 case EM_ARC:
12098 return reloc_type == 1; /* R_ARC_32. */
12099 case EM_ARC_COMPACT:
12100 case EM_ARC_COMPACT2:
12101 return reloc_type == 4; /* R_ARC_32. */
12102 case EM_ARM:
12103 return reloc_type == 2; /* R_ARM_ABS32 */
12104 case EM_AVR_OLD:
12105 case EM_AVR:
12106 return reloc_type == 1;
12107 case EM_BLACKFIN:
12108 return reloc_type == 0x12; /* R_byte4_data. */
12109 case EM_CRIS:
12110 return reloc_type == 3; /* R_CRIS_32. */
12111 case EM_CR16:
12112 return reloc_type == 3; /* R_CR16_NUM32. */
12113 case EM_CRX:
12114 return reloc_type == 15; /* R_CRX_NUM32. */
12115 case EM_CYGNUS_FRV:
12116 return reloc_type == 1;
12117 case EM_CYGNUS_D10V:
12118 case EM_D10V:
12119 return reloc_type == 6; /* R_D10V_32. */
12120 case EM_CYGNUS_D30V:
12121 case EM_D30V:
12122 return reloc_type == 12; /* R_D30V_32_NORMAL. */
12123 case EM_DLX:
12124 return reloc_type == 3; /* R_DLX_RELOC_32. */
12125 case EM_CYGNUS_FR30:
12126 case EM_FR30:
12127 return reloc_type == 3; /* R_FR30_32. */
12128 case EM_FT32:
12129 return reloc_type == 1; /* R_FT32_32. */
12130 case EM_H8S:
12131 case EM_H8_300:
12132 case EM_H8_300H:
12133 return reloc_type == 1; /* R_H8_DIR32. */
12134 case EM_IA_64:
12135 return (reloc_type == 0x64 /* R_IA64_SECREL32MSB. */
12136 || reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
12137 || reloc_type == 0x24 /* R_IA64_DIR32MSB. */
12138 || reloc_type == 0x25 /* R_IA64_DIR32LSB. */);
12139 case EM_IP2K_OLD:
12140 case EM_IP2K:
12141 return reloc_type == 2; /* R_IP2K_32. */
12142 case EM_IQ2000:
12143 return reloc_type == 2; /* R_IQ2000_32. */
12144 case EM_LATTICEMICO32:
12145 return reloc_type == 3; /* R_LM32_32. */
12146 case EM_M32C_OLD:
12147 case EM_M32C:
12148 return reloc_type == 3; /* R_M32C_32. */
12149 case EM_M32R:
12150 return reloc_type == 34; /* R_M32R_32_RELA. */
12151 case EM_68HC11:
12152 case EM_68HC12:
12153 return reloc_type == 6; /* R_M68HC11_32. */
12154 case EM_MCORE:
12155 return reloc_type == 1; /* R_MCORE_ADDR32. */
12156 case EM_CYGNUS_MEP:
12157 return reloc_type == 4; /* R_MEP_32. */
12158 case EM_METAG:
12159 return reloc_type == 2; /* R_METAG_ADDR32. */
12160 case EM_MICROBLAZE:
12161 return reloc_type == 1; /* R_MICROBLAZE_32. */
12162 case EM_MIPS:
12163 return reloc_type == 2; /* R_MIPS_32. */
12164 case EM_MMIX:
12165 return reloc_type == 4; /* R_MMIX_32. */
12166 case EM_CYGNUS_MN10200:
12167 case EM_MN10200:
12168 return reloc_type == 1; /* R_MN10200_32. */
12169 case EM_CYGNUS_MN10300:
12170 case EM_MN10300:
12171 return reloc_type == 1; /* R_MN10300_32. */
12172 case EM_MOXIE:
12173 return reloc_type == 1; /* R_MOXIE_32. */
12174 case EM_MSP430_OLD:
12175 case EM_MSP430:
12176 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12177 case EM_MT:
12178 return reloc_type == 2; /* R_MT_32. */
12179 case EM_NDS32:
12180 return reloc_type == 20; /* R_NDS32_RELA. */
12181 case EM_ALTERA_NIOS2:
12182 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
12183 case EM_NIOS32:
12184 return reloc_type == 1; /* R_NIOS_32. */
12185 case EM_OR1K:
12186 return reloc_type == 1; /* R_OR1K_32. */
12187 case EM_PARISC:
12188 return (reloc_type == 1 /* R_PARISC_DIR32. */
12189 || reloc_type == 41); /* R_PARISC_SECREL32. */
12190 case EM_PJ:
12191 case EM_PJ_OLD:
12192 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
12193 case EM_PPC64:
12194 return reloc_type == 1; /* R_PPC64_ADDR32. */
12195 case EM_PPC:
12196 return reloc_type == 1; /* R_PPC_ADDR32. */
12197 case EM_TI_PRU:
12198 return reloc_type == 11; /* R_PRU_BFD_RELOC_32. */
12199 case EM_RISCV:
12200 return reloc_type == 1; /* R_RISCV_32. */
12201 case EM_RL78:
12202 return reloc_type == 1; /* R_RL78_DIR32. */
12203 case EM_RX:
12204 return reloc_type == 1; /* R_RX_DIR32. */
12205 case EM_S370:
12206 return reloc_type == 1; /* R_I370_ADDR31. */
12207 case EM_S390_OLD:
12208 case EM_S390:
12209 return reloc_type == 4; /* R_S390_32. */
12210 case EM_SCORE:
12211 return reloc_type == 8; /* R_SCORE_ABS32. */
12212 case EM_SH:
12213 return reloc_type == 1; /* R_SH_DIR32. */
12214 case EM_SPARC32PLUS:
12215 case EM_SPARCV9:
12216 case EM_SPARC:
12217 return reloc_type == 3 /* R_SPARC_32. */
12218 || reloc_type == 23; /* R_SPARC_UA32. */
12219 case EM_SPU:
12220 return reloc_type == 6; /* R_SPU_ADDR32 */
12221 case EM_TI_C6000:
12222 return reloc_type == 1; /* R_C6000_ABS32. */
12223 case EM_TILEGX:
12224 return reloc_type == 2; /* R_TILEGX_32. */
12225 case EM_TILEPRO:
12226 return reloc_type == 1; /* R_TILEPRO_32. */
12227 case EM_CYGNUS_V850:
12228 case EM_V850:
12229 return reloc_type == 6; /* R_V850_ABS32. */
12230 case EM_V800:
12231 return reloc_type == 0x33; /* R_V810_WORD. */
12232 case EM_VAX:
12233 return reloc_type == 1; /* R_VAX_32. */
12234 case EM_VISIUM:
12235 return reloc_type == 3; /* R_VISIUM_32. */
12236 case EM_WEBASSEMBLY:
12237 return reloc_type == 1; /* R_WASM32_32. */
12238 case EM_X86_64:
12239 case EM_L1OM:
12240 case EM_K1OM:
12241 return reloc_type == 10; /* R_X86_64_32. */
12242 case EM_XC16X:
12243 case EM_C166:
12244 return reloc_type == 3; /* R_XC16C_ABS_32. */
12245 case EM_XGATE:
12246 return reloc_type == 4; /* R_XGATE_32. */
12247 case EM_XSTORMY16:
12248 return reloc_type == 1; /* R_XSTROMY16_32. */
12249 case EM_XTENSA_OLD:
12250 case EM_XTENSA:
12251 return reloc_type == 1; /* R_XTENSA_32. */
12252 default:
12253 {
12254 static unsigned int prev_warn = 0;
12255
12256 /* Avoid repeating the same warning multiple times. */
12257 if (prev_warn != elf_header.e_machine)
12258 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12259 elf_header.e_machine);
12260 prev_warn = elf_header.e_machine;
12261 return FALSE;
12262 }
12263 }
12264}
12265
12266/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12267 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12268
12269static bfd_boolean
12270is_32bit_pcrel_reloc (unsigned int reloc_type)
12271{
12272 switch (elf_header.e_machine)
12273 /* Please keep this table alpha-sorted for ease of visual lookup. */
12274 {
12275 case EM_386:
12276 case EM_IAMCU:
12277 return reloc_type == 2; /* R_386_PC32. */
12278 case EM_68K:
12279 return reloc_type == 4; /* R_68K_PC32. */
12280 case EM_AARCH64:
12281 return reloc_type == 261; /* R_AARCH64_PREL32 */
12282 case EM_ADAPTEVA_EPIPHANY:
12283 return reloc_type == 6;
12284 case EM_ALPHA:
12285 return reloc_type == 10; /* R_ALPHA_SREL32. */
12286 case EM_ARC_COMPACT:
12287 case EM_ARC_COMPACT2:
12288 return reloc_type == 49; /* R_ARC_32_PCREL. */
12289 case EM_ARM:
12290 return reloc_type == 3; /* R_ARM_REL32 */
12291 case EM_AVR_OLD:
12292 case EM_AVR:
12293 return reloc_type == 36; /* R_AVR_32_PCREL. */
12294 case EM_MICROBLAZE:
12295 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
12296 case EM_OR1K:
12297 return reloc_type == 9; /* R_OR1K_32_PCREL. */
12298 case EM_PARISC:
12299 return reloc_type == 9; /* R_PARISC_PCREL32. */
12300 case EM_PPC:
12301 return reloc_type == 26; /* R_PPC_REL32. */
12302 case EM_PPC64:
12303 return reloc_type == 26; /* R_PPC64_REL32. */
12304 case EM_S390_OLD:
12305 case EM_S390:
12306 return reloc_type == 5; /* R_390_PC32. */
12307 case EM_SH:
12308 return reloc_type == 2; /* R_SH_REL32. */
12309 case EM_SPARC32PLUS:
12310 case EM_SPARCV9:
12311 case EM_SPARC:
12312 return reloc_type == 6; /* R_SPARC_DISP32. */
12313 case EM_SPU:
12314 return reloc_type == 13; /* R_SPU_REL32. */
12315 case EM_TILEGX:
12316 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
12317 case EM_TILEPRO:
12318 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
12319 case EM_VISIUM:
12320 return reloc_type == 6; /* R_VISIUM_32_PCREL */
12321 case EM_X86_64:
12322 case EM_L1OM:
12323 case EM_K1OM:
12324 return reloc_type == 2; /* R_X86_64_PC32. */
12325 case EM_XTENSA_OLD:
12326 case EM_XTENSA:
12327 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
12328 default:
12329 /* Do not abort or issue an error message here. Not all targets use
12330 pc-relative 32-bit relocs in their DWARF debug information and we
12331 have already tested for target coverage in is_32bit_abs_reloc. A
12332 more helpful warning message will be generated by apply_relocations
12333 anyway, so just return. */
12334 return FALSE;
12335 }
12336}
12337
12338/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12339 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12340
12341static bfd_boolean
12342is_64bit_abs_reloc (unsigned int reloc_type)
12343{
12344 switch (elf_header.e_machine)
12345 {
12346 case EM_AARCH64:
12347 return reloc_type == 257; /* R_AARCH64_ABS64. */
12348 case EM_ALPHA:
12349 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
12350 case EM_IA_64:
12351 return (reloc_type == 0x26 /* R_IA64_DIR64MSB. */
12352 || reloc_type == 0x27 /* R_IA64_DIR64LSB. */);
12353 case EM_PARISC:
12354 return reloc_type == 80; /* R_PARISC_DIR64. */
12355 case EM_PPC64:
12356 return reloc_type == 38; /* R_PPC64_ADDR64. */
12357 case EM_RISCV:
12358 return reloc_type == 2; /* R_RISCV_64. */
12359 case EM_SPARC32PLUS:
12360 case EM_SPARCV9:
12361 case EM_SPARC:
12362 return reloc_type == 32 /* R_SPARC_64. */
12363 || reloc_type == 54; /* R_SPARC_UA64. */
12364 case EM_X86_64:
12365 case EM_L1OM:
12366 case EM_K1OM:
12367 return reloc_type == 1; /* R_X86_64_64. */
12368 case EM_S390_OLD:
12369 case EM_S390:
12370 return reloc_type == 22; /* R_S390_64. */
12371 case EM_TILEGX:
12372 return reloc_type == 1; /* R_TILEGX_64. */
12373 case EM_MIPS:
12374 return reloc_type == 18; /* R_MIPS_64. */
12375 default:
12376 return FALSE;
12377 }
12378}
12379
12380/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12381 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12382
12383static bfd_boolean
12384is_64bit_pcrel_reloc (unsigned int reloc_type)
12385{
12386 switch (elf_header.e_machine)
12387 {
12388 case EM_AARCH64:
12389 return reloc_type == 260; /* R_AARCH64_PREL64. */
12390 case EM_ALPHA:
12391 return reloc_type == 11; /* R_ALPHA_SREL64. */
12392 case EM_IA_64:
12393 return (reloc_type == 0x4e /* R_IA64_PCREL64MSB. */
12394 || reloc_type == 0x4f /* R_IA64_PCREL64LSB. */);
12395 case EM_PARISC:
12396 return reloc_type == 72; /* R_PARISC_PCREL64. */
12397 case EM_PPC64:
12398 return reloc_type == 44; /* R_PPC64_REL64. */
12399 case EM_SPARC32PLUS:
12400 case EM_SPARCV9:
12401 case EM_SPARC:
12402 return reloc_type == 46; /* R_SPARC_DISP64. */
12403 case EM_X86_64:
12404 case EM_L1OM:
12405 case EM_K1OM:
12406 return reloc_type == 24; /* R_X86_64_PC64. */
12407 case EM_S390_OLD:
12408 case EM_S390:
12409 return reloc_type == 23; /* R_S390_PC64. */
12410 case EM_TILEGX:
12411 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
12412 default:
12413 return FALSE;
12414 }
12415}
12416
12417/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12418 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12419
12420static bfd_boolean
12421is_24bit_abs_reloc (unsigned int reloc_type)
12422{
12423 switch (elf_header.e_machine)
12424 {
12425 case EM_CYGNUS_MN10200:
12426 case EM_MN10200:
12427 return reloc_type == 4; /* R_MN10200_24. */
12428 case EM_FT32:
12429 return reloc_type == 5; /* R_FT32_20. */
12430 default:
12431 return FALSE;
12432 }
12433}
12434
12435/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12436 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12437
12438static bfd_boolean
12439is_16bit_abs_reloc (unsigned int reloc_type)
12440{
12441 /* Please keep this table alpha-sorted for ease of visual lookup. */
12442 switch (elf_header.e_machine)
12443 {
12444 case EM_ARC:
12445 case EM_ARC_COMPACT:
12446 case EM_ARC_COMPACT2:
12447 return reloc_type == 2; /* R_ARC_16. */
12448 case EM_ADAPTEVA_EPIPHANY:
12449 return reloc_type == 5;
12450 case EM_AVR_OLD:
12451 case EM_AVR:
12452 return reloc_type == 4; /* R_AVR_16. */
12453 case EM_CYGNUS_D10V:
12454 case EM_D10V:
12455 return reloc_type == 3; /* R_D10V_16. */
12456 case EM_FT32:
12457 return reloc_type == 2; /* R_FT32_16. */
12458 case EM_H8S:
12459 case EM_H8_300:
12460 case EM_H8_300H:
12461 return reloc_type == R_H8_DIR16;
12462 case EM_IP2K_OLD:
12463 case EM_IP2K:
12464 return reloc_type == 1; /* R_IP2K_16. */
12465 case EM_M32C_OLD:
12466 case EM_M32C:
12467 return reloc_type == 1; /* R_M32C_16 */
12468 case EM_CYGNUS_MN10200:
12469 case EM_MN10200:
12470 return reloc_type == 2; /* R_MN10200_16. */
12471 case EM_CYGNUS_MN10300:
12472 case EM_MN10300:
12473 return reloc_type == 2; /* R_MN10300_16. */
12474 case EM_MSP430:
12475 if (uses_msp430x_relocs ())
12476 return reloc_type == 2; /* R_MSP430_ABS16. */
12477 /* Fall through. */
12478 case EM_MSP430_OLD:
12479 return reloc_type == 5; /* R_MSP430_16_BYTE. */
12480 case EM_NDS32:
12481 return reloc_type == 19; /* R_NDS32_RELA. */
12482 case EM_ALTERA_NIOS2:
12483 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
12484 case EM_NIOS32:
12485 return reloc_type == 9; /* R_NIOS_16. */
12486 case EM_OR1K:
12487 return reloc_type == 2; /* R_OR1K_16. */
12488 case EM_TI_PRU:
12489 return reloc_type == 8; /* R_PRU_BFD_RELOC_16. */
12490 case EM_TI_C6000:
12491 return reloc_type == 2; /* R_C6000_ABS16. */
12492 case EM_VISIUM:
12493 return reloc_type == 2; /* R_VISIUM_16. */
12494 case EM_XC16X:
12495 case EM_C166:
12496 return reloc_type == 2; /* R_XC16C_ABS_16. */
12497 case EM_XGATE:
12498 return reloc_type == 3; /* R_XGATE_16. */
12499 default:
12500 return FALSE;
12501 }
12502}
12503
12504/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12505 relocation entries (possibly formerly used for SHT_GROUP sections). */
12506
12507static bfd_boolean
12508is_none_reloc (unsigned int reloc_type)
12509{
12510 switch (elf_header.e_machine)
12511 {
12512 case EM_386: /* R_386_NONE. */
12513 case EM_68K: /* R_68K_NONE. */
12514 case EM_ADAPTEVA_EPIPHANY:
12515 case EM_ALPHA: /* R_ALPHA_NONE. */
12516 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
12517 case EM_ARC: /* R_ARC_NONE. */
12518 case EM_ARC_COMPACT2: /* R_ARC_NONE. */
12519 case EM_ARC_COMPACT: /* R_ARC_NONE. */
12520 case EM_ARM: /* R_ARM_NONE. */
12521 case EM_C166: /* R_XC16X_NONE. */
12522 case EM_CRIS: /* R_CRIS_NONE. */
12523 case EM_FT32: /* R_FT32_NONE. */
12524 case EM_IA_64: /* R_IA64_NONE. */
12525 case EM_K1OM: /* R_X86_64_NONE. */
12526 case EM_L1OM: /* R_X86_64_NONE. */
12527 case EM_M32R: /* R_M32R_NONE. */
12528 case EM_MIPS: /* R_MIPS_NONE. */
12529 case EM_MN10300: /* R_MN10300_NONE. */
12530 case EM_MOXIE: /* R_MOXIE_NONE. */
12531 case EM_NIOS32: /* R_NIOS_NONE. */
12532 case EM_OR1K: /* R_OR1K_NONE. */
12533 case EM_PARISC: /* R_PARISC_NONE. */
12534 case EM_PPC64: /* R_PPC64_NONE. */
12535 case EM_PPC: /* R_PPC_NONE. */
12536 case EM_RISCV: /* R_RISCV_NONE. */
12537 case EM_S390: /* R_390_NONE. */
12538 case EM_S390_OLD:
12539 case EM_SH: /* R_SH_NONE. */
12540 case EM_SPARC32PLUS:
12541 case EM_SPARC: /* R_SPARC_NONE. */
12542 case EM_SPARCV9:
12543 case EM_TILEGX: /* R_TILEGX_NONE. */
12544 case EM_TILEPRO: /* R_TILEPRO_NONE. */
12545 case EM_TI_C6000:/* R_C6000_NONE. */
12546 case EM_X86_64: /* R_X86_64_NONE. */
12547 case EM_XC16X:
12548 case EM_WEBASSEMBLY: /* R_WASM32_NONE. */
12549 return reloc_type == 0;
12550
12551 case EM_AARCH64:
12552 return reloc_type == 0 || reloc_type == 256;
12553 case EM_AVR_OLD:
12554 case EM_AVR:
12555 return (reloc_type == 0 /* R_AVR_NONE. */
12556 || reloc_type == 30 /* R_AVR_DIFF8. */
12557 || reloc_type == 31 /* R_AVR_DIFF16. */
12558 || reloc_type == 32 /* R_AVR_DIFF32. */);
12559 case EM_METAG:
12560 return reloc_type == 3; /* R_METAG_NONE. */
12561 case EM_NDS32:
12562 return (reloc_type == 0 /* R_XTENSA_NONE. */
12563 || reloc_type == 204 /* R_NDS32_DIFF8. */
12564 || reloc_type == 205 /* R_NDS32_DIFF16. */
12565 || reloc_type == 206 /* R_NDS32_DIFF32. */
12566 || reloc_type == 207 /* R_NDS32_ULEB128. */);
12567 case EM_TI_PRU:
12568 return (reloc_type == 0 /* R_PRU_NONE. */
12569 || reloc_type == 65 /* R_PRU_DIFF8. */
12570 || reloc_type == 66 /* R_PRU_DIFF16. */
12571 || reloc_type == 67 /* R_PRU_DIFF32. */);
12572 case EM_XTENSA_OLD:
12573 case EM_XTENSA:
12574 return (reloc_type == 0 /* R_XTENSA_NONE. */
12575 || reloc_type == 17 /* R_XTENSA_DIFF8. */
12576 || reloc_type == 18 /* R_XTENSA_DIFF16. */
12577 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
12578 }
12579 return FALSE;
12580}
12581
12582/* Returns TRUE if there is a relocation against
12583 section NAME at OFFSET bytes. */
12584
12585bfd_boolean
12586reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
12587{
12588 Elf_Internal_Rela * relocs;
12589 Elf_Internal_Rela * rp;
12590
12591 if (dsec == NULL || dsec->reloc_info == NULL)
12592 return FALSE;
12593
12594 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
12595
12596 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
12597 if (rp->r_offset == offset)
12598 return TRUE;
12599
12600 return FALSE;
12601}
12602
12603/* Apply relocations to a section.
12604 Returns TRUE upon success, FALSE otherwise.
12605 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12606 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
12607 will be set to the number of relocs loaded.
12608
12609 Note: So far support has been added only for those relocations
12610 which can be found in debug sections. FIXME: Add support for
12611 more relocations ? */
12612
12613static bfd_boolean
12614apply_relocations (void * file,
12615 const Elf_Internal_Shdr * section,
12616 unsigned char * start,
12617 bfd_size_type size,
12618 void ** relocs_return,
12619 unsigned long * num_relocs_return)
12620{
12621 Elf_Internal_Shdr * relsec;
12622 unsigned char * end = start + size;
12623 bfd_boolean res = TRUE;
12624
12625 if (relocs_return != NULL)
12626 {
12627 * (Elf_Internal_Rela **) relocs_return = NULL;
12628 * num_relocs_return = 0;
12629 }
12630
12631 if (elf_header.e_type != ET_REL)
12632 /* No relocs to apply. */
12633 return TRUE;
12634
12635 /* Find the reloc section associated with the section. */
12636 for (relsec = section_headers;
12637 relsec < section_headers + elf_header.e_shnum;
12638 ++relsec)
12639 {
12640 bfd_boolean is_rela;
12641 unsigned long num_relocs;
12642 Elf_Internal_Rela * relocs;
12643 Elf_Internal_Rela * rp;
12644 Elf_Internal_Shdr * symsec;
12645 Elf_Internal_Sym * symtab;
12646 unsigned long num_syms;
12647 Elf_Internal_Sym * sym;
12648
12649 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12650 || relsec->sh_info >= elf_header.e_shnum
12651 || section_headers + relsec->sh_info != section
12652 || relsec->sh_size == 0
12653 || relsec->sh_link >= elf_header.e_shnum)
12654 continue;
12655
12656 is_rela = relsec->sh_type == SHT_RELA;
12657
12658 if (is_rela)
12659 {
12660 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
12661 relsec->sh_size, & relocs, & num_relocs))
12662 return FALSE;
12663 }
12664 else
12665 {
12666 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
12667 relsec->sh_size, & relocs, & num_relocs))
12668 return FALSE;
12669 }
12670
12671 /* SH uses RELA but uses in place value instead of the addend field. */
12672 if (elf_header.e_machine == EM_SH)
12673 is_rela = FALSE;
12674
12675 symsec = section_headers + relsec->sh_link;
12676 if (symsec->sh_type != SHT_SYMTAB
12677 && symsec->sh_type != SHT_DYNSYM)
12678 return FALSE;
12679 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
12680
12681 for (rp = relocs; rp < relocs + num_relocs; ++rp)
12682 {
12683 bfd_vma addend;
12684 unsigned int reloc_type;
12685 unsigned int reloc_size;
12686 unsigned char * rloc;
12687 unsigned long sym_index;
12688
12689 reloc_type = get_reloc_type (rp->r_info);
12690
12691 if (target_specific_reloc_handling (rp, start, end, symtab, num_syms))
12692 continue;
12693 else if (is_none_reloc (reloc_type))
12694 continue;
12695 else if (is_32bit_abs_reloc (reloc_type)
12696 || is_32bit_pcrel_reloc (reloc_type))
12697 reloc_size = 4;
12698 else if (is_64bit_abs_reloc (reloc_type)
12699 || is_64bit_pcrel_reloc (reloc_type))
12700 reloc_size = 8;
12701 else if (is_24bit_abs_reloc (reloc_type))
12702 reloc_size = 3;
12703 else if (is_16bit_abs_reloc (reloc_type))
12704 reloc_size = 2;
12705 else
12706 {
12707 static unsigned int prev_reloc = 0;
12708 if (reloc_type != prev_reloc)
12709 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12710 reloc_type, printable_section_name (section));
12711 prev_reloc = reloc_type;
12712 res = FALSE;
12713 continue;
12714 }
12715
12716 rloc = start + rp->r_offset;
12717 if ((rloc + reloc_size) > end || (rloc < start))
12718 {
12719 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12720 (unsigned long) rp->r_offset,
12721 printable_section_name (section));
12722 res = FALSE;
12723 continue;
12724 }
12725
12726 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
12727 if (sym_index >= num_syms)
12728 {
12729 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12730 sym_index, printable_section_name (section));
12731 res = FALSE;
12732 continue;
12733 }
12734 sym = symtab + sym_index;
12735
12736 /* If the reloc has a symbol associated with it,
12737 make sure that it is of an appropriate type.
12738
12739 Relocations against symbols without type can happen.
12740 Gcc -feliminate-dwarf2-dups may generate symbols
12741 without type for debug info.
12742
12743 Icc generates relocations against function symbols
12744 instead of local labels.
12745
12746 Relocations against object symbols can happen, eg when
12747 referencing a global array. For an example of this see
12748 the _clz.o binary in libgcc.a. */
12749 if (sym != symtab
12750 && ELF_ST_TYPE (sym->st_info) != STT_COMMON
12751 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
12752 {
12753 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12754 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
12755 (long int)(rp - relocs),
12756 printable_section_name (relsec));
12757 res = FALSE;
12758 continue;
12759 }
12760
12761 addend = 0;
12762 if (is_rela)
12763 addend += rp->r_addend;
12764 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12765 partial_inplace. */
12766 if (!is_rela
12767 || (elf_header.e_machine == EM_XTENSA
12768 && reloc_type == 1)
12769 || ((elf_header.e_machine == EM_PJ
12770 || elf_header.e_machine == EM_PJ_OLD)
12771 && reloc_type == 1)
12772 || ((elf_header.e_machine == EM_D30V
12773 || elf_header.e_machine == EM_CYGNUS_D30V)
12774 && reloc_type == 12))
12775 addend += byte_get (rloc, reloc_size);
12776
12777 if (is_32bit_pcrel_reloc (reloc_type)
12778 || is_64bit_pcrel_reloc (reloc_type))
12779 {
12780 /* On HPPA, all pc-relative relocations are biased by 8. */
12781 if (elf_header.e_machine == EM_PARISC)
12782 addend -= 8;
12783 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
12784 reloc_size);
12785 }
12786 else
12787 byte_put (rloc, addend + sym->st_value, reloc_size);
12788 }
12789
12790 free (symtab);
12791 /* Let the target specific reloc processing code know that
12792 we have finished with these relocs. */
12793 target_specific_reloc_handling (NULL, NULL, NULL, NULL, 0);
12794
12795 if (relocs_return)
12796 {
12797 * (Elf_Internal_Rela **) relocs_return = relocs;
12798 * num_relocs_return = num_relocs;
12799 }
12800 else
12801 free (relocs);
12802
12803 break;
12804 }
12805
12806 return res;
12807}
12808
12809#ifdef SUPPORT_DISASSEMBLY
12810static bfd_boolean
12811disassemble_section (Elf_Internal_Shdr * section, FILE * file)
12812{
12813 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
12814
12815 /* FIXME: XXX -- to be done --- XXX */
12816
12817 return TRUE;
12818}
12819#endif
12820
12821/* Reads in the contents of SECTION from FILE, returning a pointer
12822 to a malloc'ed buffer or NULL if something went wrong. */
12823
12824static char *
12825get_section_contents (Elf_Internal_Shdr * section, FILE * file)
12826{
12827 bfd_size_type num_bytes;
12828
12829 num_bytes = section->sh_size;
12830
12831 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
12832 {
12833 printf (_("Section '%s' has no data to dump.\n"),
12834 printable_section_name (section));
12835 return NULL;
12836 }
12837
12838 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
12839 _("section contents"));
12840}
12841
12842/* Uncompresses a section that was compressed using zlib, in place. */
12843
12844static bfd_boolean
12845uncompress_section_contents (unsigned char **buffer,
12846 dwarf_size_type uncompressed_size,
12847 dwarf_size_type *size)
12848{
12849 dwarf_size_type compressed_size = *size;
12850 unsigned char * compressed_buffer = *buffer;
12851 unsigned char * uncompressed_buffer;
12852 z_stream strm;
12853 int rc;
12854
12855 /* It is possible the section consists of several compressed
12856 buffers concatenated together, so we uncompress in a loop. */
12857 /* PR 18313: The state field in the z_stream structure is supposed
12858 to be invisible to the user (ie us), but some compilers will
12859 still complain about it being used without initialisation. So
12860 we first zero the entire z_stream structure and then set the fields
12861 that we need. */
12862 memset (& strm, 0, sizeof strm);
12863 strm.avail_in = compressed_size;
12864 strm.next_in = (Bytef *) compressed_buffer;
12865 strm.avail_out = uncompressed_size;
12866 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
12867
12868 rc = inflateInit (& strm);
12869 while (strm.avail_in > 0)
12870 {
12871 if (rc != Z_OK)
12872 goto fail;
12873 strm.next_out = ((Bytef *) uncompressed_buffer
12874 + (uncompressed_size - strm.avail_out));
12875 rc = inflate (&strm, Z_FINISH);
12876 if (rc != Z_STREAM_END)
12877 goto fail;
12878 rc = inflateReset (& strm);
12879 }
12880 rc = inflateEnd (& strm);
12881 if (rc != Z_OK
12882 || strm.avail_out != 0)
12883 goto fail;
12884
12885 *buffer = uncompressed_buffer;
12886 *size = uncompressed_size;
12887 return TRUE;
12888
12889 fail:
12890 free (uncompressed_buffer);
12891 /* Indicate decompression failure. */
12892 *buffer = NULL;
12893 return FALSE;
12894}
12895
12896static bfd_boolean
12897dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12898{
12899 Elf_Internal_Shdr * relsec;
12900 bfd_size_type num_bytes;
12901 unsigned char * data;
12902 unsigned char * end;
12903 unsigned char * real_start;
12904 unsigned char * start;
12905 bfd_boolean some_strings_shown;
12906
12907 real_start = start = (unsigned char *) get_section_contents (section, file);
12908 if (start == NULL)
12909 /* PR 21820: Do not fail if the section was empty. */
12910 return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
12911
12912 num_bytes = section->sh_size;
12913
12914 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
12915
12916 if (decompress_dumps)
12917 {
12918 dwarf_size_type new_size = num_bytes;
12919 dwarf_size_type uncompressed_size = 0;
12920
12921 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12922 {
12923 Elf_Internal_Chdr chdr;
12924 unsigned int compression_header_size
12925 = get_compression_header (& chdr, (unsigned char *) start,
12926 num_bytes);
12927
12928 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12929 {
12930 warn (_("section '%s' has unsupported compress type: %d\n"),
12931 printable_section_name (section), chdr.ch_type);
12932 return FALSE;
12933 }
12934 else if (chdr.ch_addralign != section->sh_addralign)
12935 {
12936 warn (_("compressed section '%s' is corrupted\n"),
12937 printable_section_name (section));
12938 return FALSE;
12939 }
12940 uncompressed_size = chdr.ch_size;
12941 start += compression_header_size;
12942 new_size -= compression_header_size;
12943 }
12944 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12945 {
12946 /* Read the zlib header. In this case, it should be "ZLIB"
12947 followed by the uncompressed section size, 8 bytes in
12948 big-endian order. */
12949 uncompressed_size = start[4]; uncompressed_size <<= 8;
12950 uncompressed_size += start[5]; uncompressed_size <<= 8;
12951 uncompressed_size += start[6]; uncompressed_size <<= 8;
12952 uncompressed_size += start[7]; uncompressed_size <<= 8;
12953 uncompressed_size += start[8]; uncompressed_size <<= 8;
12954 uncompressed_size += start[9]; uncompressed_size <<= 8;
12955 uncompressed_size += start[10]; uncompressed_size <<= 8;
12956 uncompressed_size += start[11];
12957 start += 12;
12958 new_size -= 12;
12959 }
12960
12961 if (uncompressed_size)
12962 {
12963 if (uncompress_section_contents (& start,
12964 uncompressed_size, & new_size))
12965 num_bytes = new_size;
12966 else
12967 {
12968 error (_("Unable to decompress section %s\n"),
12969 printable_section_name (section));
12970 return FALSE;
12971 }
12972 }
12973 else
12974 start = real_start;
12975 }
12976
12977 /* If the section being dumped has relocations against it the user might
12978 be expecting these relocations to have been applied. Check for this
12979 case and issue a warning message in order to avoid confusion.
12980 FIXME: Maybe we ought to have an option that dumps a section with
12981 relocs applied ? */
12982 for (relsec = section_headers;
12983 relsec < section_headers + elf_header.e_shnum;
12984 ++relsec)
12985 {
12986 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12987 || relsec->sh_info >= elf_header.e_shnum
12988 || section_headers + relsec->sh_info != section
12989 || relsec->sh_size == 0
12990 || relsec->sh_link >= elf_header.e_shnum)
12991 continue;
12992
12993 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12994 break;
12995 }
12996
12997 data = start;
12998 end = start + num_bytes;
12999 some_strings_shown = FALSE;
13000
13001 while (data < end)
13002 {
13003 while (!ISPRINT (* data))
13004 if (++ data >= end)
13005 break;
13006
13007 if (data < end)
13008 {
13009 size_t maxlen = end - data;
13010
13011#ifndef __MSVCRT__
13012 /* PR 11128: Use two separate invocations in order to work
13013 around bugs in the Solaris 8 implementation of printf. */
13014 printf (" [%6tx] ", data - start);
13015#else
13016 printf (" [%6Ix] ", (size_t) (data - start));
13017#endif
13018 if (maxlen > 0)
13019 {
13020 print_symbol ((int) maxlen, (const char *) data);
13021 putchar ('\n');
13022 data += strnlen ((const char *) data, maxlen);
13023 }
13024 else
13025 {
13026 printf (_("<corrupt>\n"));
13027 data = end;
13028 }
13029 some_strings_shown = TRUE;
13030 }
13031 }
13032
13033 if (! some_strings_shown)
13034 printf (_(" No strings found in this section."));
13035
13036 free (real_start);
13037
13038 putchar ('\n');
13039 return TRUE;
13040}
13041
13042static bfd_boolean
13043dump_section_as_bytes (Elf_Internal_Shdr * section,
13044 FILE * file,
13045 bfd_boolean relocate)
13046{
13047 Elf_Internal_Shdr * relsec;
13048 bfd_size_type bytes;
13049 bfd_size_type section_size;
13050 bfd_vma addr;
13051 unsigned char * data;
13052 unsigned char * real_start;
13053 unsigned char * start;
13054
13055 real_start = start = (unsigned char *) get_section_contents (section, file);
13056 if (start == NULL)
13057 /* PR 21820: Do not fail if the section was empty. */
13058 return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13059
13060 section_size = section->sh_size;
13061
13062 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
13063
13064 if (decompress_dumps)
13065 {
13066 dwarf_size_type new_size = section_size;
13067 dwarf_size_type uncompressed_size = 0;
13068
13069 if ((section->sh_flags & SHF_COMPRESSED) != 0)
13070 {
13071 Elf_Internal_Chdr chdr;
13072 unsigned int compression_header_size
13073 = get_compression_header (& chdr, start, section_size);
13074
13075 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13076 {
13077 warn (_("section '%s' has unsupported compress type: %d\n"),
13078 printable_section_name (section), chdr.ch_type);
13079 return FALSE;
13080 }
13081 else if (chdr.ch_addralign != section->sh_addralign)
13082 {
13083 warn (_("compressed section '%s' is corrupted\n"),
13084 printable_section_name (section));
13085 return FALSE;
13086 }
13087 uncompressed_size = chdr.ch_size;
13088 start += compression_header_size;
13089 new_size -= compression_header_size;
13090 }
13091 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13092 {
13093 /* Read the zlib header. In this case, it should be "ZLIB"
13094 followed by the uncompressed section size, 8 bytes in
13095 big-endian order. */
13096 uncompressed_size = start[4]; uncompressed_size <<= 8;
13097 uncompressed_size += start[5]; uncompressed_size <<= 8;
13098 uncompressed_size += start[6]; uncompressed_size <<= 8;
13099 uncompressed_size += start[7]; uncompressed_size <<= 8;
13100 uncompressed_size += start[8]; uncompressed_size <<= 8;
13101 uncompressed_size += start[9]; uncompressed_size <<= 8;
13102 uncompressed_size += start[10]; uncompressed_size <<= 8;
13103 uncompressed_size += start[11];
13104 start += 12;
13105 new_size -= 12;
13106 }
13107
13108 if (uncompressed_size)
13109 {
13110 if (uncompress_section_contents (& start, uncompressed_size,
13111 & new_size))
13112 {
13113 section_size = new_size;
13114 }
13115 else
13116 {
13117 error (_("Unable to decompress section %s\n"),
13118 printable_section_name (section));
13119 /* FIXME: Print the section anyway ? */
13120 return FALSE;
13121 }
13122 }
13123 else
13124 start = real_start;
13125 }
13126
13127 if (relocate)
13128 {
13129 if (! apply_relocations (file, section, start, section_size, NULL, NULL))
13130 return FALSE;
13131 }
13132 else
13133 {
13134 /* If the section being dumped has relocations against it the user might
13135 be expecting these relocations to have been applied. Check for this
13136 case and issue a warning message in order to avoid confusion.
13137 FIXME: Maybe we ought to have an option that dumps a section with
13138 relocs applied ? */
13139 for (relsec = section_headers;
13140 relsec < section_headers + elf_header.e_shnum;
13141 ++relsec)
13142 {
13143 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13144 || relsec->sh_info >= elf_header.e_shnum
13145 || section_headers + relsec->sh_info != section
13146 || relsec->sh_size == 0
13147 || relsec->sh_link >= elf_header.e_shnum)
13148 continue;
13149
13150 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13151 break;
13152 }
13153 }
13154
13155 addr = section->sh_addr;
13156 bytes = section_size;
13157 data = start;
13158
13159 while (bytes)
13160 {
13161 int j;
13162 int k;
13163 int lbytes;
13164
13165 lbytes = (bytes > 16 ? 16 : bytes);
13166
13167 printf (" 0x%8.8lx ", (unsigned long) addr);
13168
13169 for (j = 0; j < 16; j++)
13170 {
13171 if (j < lbytes)
13172 printf ("%2.2x", data[j]);
13173 else
13174 printf (" ");
13175
13176 if ((j & 3) == 3)
13177 printf (" ");
13178 }
13179
13180 for (j = 0; j < lbytes; j++)
13181 {
13182 k = data[j];
13183 if (k >= ' ' && k < 0x7f)
13184 printf ("%c", k);
13185 else
13186 printf (".");
13187 }
13188
13189 putchar ('\n');
13190
13191 data += lbytes;
13192 addr += lbytes;
13193 bytes -= lbytes;
13194 }
13195
13196 free (real_start);
13197
13198 putchar ('\n');
13199 return TRUE;
13200}
13201
13202static bfd_boolean
13203load_specific_debug_section (enum dwarf_section_display_enum debug,
13204 const Elf_Internal_Shdr * sec, void * file)
13205{
13206 struct dwarf_section * section = &debug_displays [debug].section;
13207 char buf [64];
13208
13209 /* If it is already loaded, do nothing. */
13210 if (section->start != NULL)
13211 return TRUE;
13212
13213 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
13214 section->address = sec->sh_addr;
13215 section->user_data = NULL;
13216 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
13217 sec->sh_offset, 1,
13218 sec->sh_size, buf);
13219 if (section->start == NULL)
13220 section->size = 0;
13221 else
13222 {
13223 unsigned char *start = section->start;
13224 dwarf_size_type size = sec->sh_size;
13225 dwarf_size_type uncompressed_size = 0;
13226
13227 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
13228 {
13229 Elf_Internal_Chdr chdr;
13230 unsigned int compression_header_size;
13231
13232 if (size < (is_32bit_elf
13233 ? sizeof (Elf32_External_Chdr)
13234 : sizeof (Elf64_External_Chdr)))
13235 {
13236 warn (_("compressed section %s is too small to contain a compression header"),
13237 section->name);
13238 return FALSE;
13239 }
13240
13241 compression_header_size = get_compression_header (&chdr, start, size);
13242
13243 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13244 {
13245 warn (_("section '%s' has unsupported compress type: %d\n"),
13246 section->name, chdr.ch_type);
13247 return FALSE;
13248 }
13249 else if (chdr.ch_addralign != sec->sh_addralign)
13250 {
13251 warn (_("compressed section '%s' is corrupted\n"),
13252 section->name);
13253 return FALSE;
13254 }
13255 uncompressed_size = chdr.ch_size;
13256 start += compression_header_size;
13257 size -= compression_header_size;
13258 }
13259 else if (size > 12 && streq ((char *) start, "ZLIB"))
13260 {
13261 /* Read the zlib header. In this case, it should be "ZLIB"
13262 followed by the uncompressed section size, 8 bytes in
13263 big-endian order. */
13264 uncompressed_size = start[4]; uncompressed_size <<= 8;
13265 uncompressed_size += start[5]; uncompressed_size <<= 8;
13266 uncompressed_size += start[6]; uncompressed_size <<= 8;
13267 uncompressed_size += start[7]; uncompressed_size <<= 8;
13268 uncompressed_size += start[8]; uncompressed_size <<= 8;
13269 uncompressed_size += start[9]; uncompressed_size <<= 8;
13270 uncompressed_size += start[10]; uncompressed_size <<= 8;
13271 uncompressed_size += start[11];
13272 start += 12;
13273 size -= 12;
13274 }
13275
13276 if (uncompressed_size)
13277 {
13278 if (uncompress_section_contents (&start, uncompressed_size,
13279 &size))
13280 {
13281 /* Free the compressed buffer, update the section buffer
13282 and the section size if uncompress is successful. */
13283 free (section->start);
13284 section->start = start;
13285 }
13286 else
13287 {
13288 error (_("Unable to decompress section %s\n"),
13289 printable_section_name (sec));
13290 return FALSE;
13291 }
13292 }
13293
13294 section->size = size;
13295 }
13296
13297 if (section->start == NULL)
13298 return FALSE;
13299
13300 if (debug_displays [debug].relocate)
13301 {
13302 if (! apply_relocations ((FILE *) file, sec, section->start, section->size,
13303 & section->reloc_info, & section->num_relocs))
13304 return FALSE;
13305 }
13306 else
13307 {
13308 section->reloc_info = NULL;
13309 section->num_relocs = 0;
13310 }
13311
13312 return TRUE;
13313}
13314
13315/* If this is not NULL, load_debug_section will only look for sections
13316 within the list of sections given here. */
13317static unsigned int * section_subset = NULL;
13318
13319bfd_boolean
13320load_debug_section (enum dwarf_section_display_enum debug, void * file)
13321{
13322 struct dwarf_section * section = &debug_displays [debug].section;
13323 Elf_Internal_Shdr * sec;
13324
13325 /* Locate the debug section. */
13326 sec = find_section_in_set (section->uncompressed_name, section_subset);
13327 if (sec != NULL)
13328 section->name = section->uncompressed_name;
13329 else
13330 {
13331 sec = find_section_in_set (section->compressed_name, section_subset);
13332 if (sec != NULL)
13333 section->name = section->compressed_name;
13334 }
13335 if (sec == NULL)
13336 return FALSE;
13337
13338 /* If we're loading from a subset of sections, and we've loaded
13339 a section matching this name before, it's likely that it's a
13340 different one. */
13341 if (section_subset != NULL)
13342 free_debug_section (debug);
13343
13344 return load_specific_debug_section (debug, sec, (FILE *) file);
13345}
13346
13347void
13348free_debug_section (enum dwarf_section_display_enum debug)
13349{
13350 struct dwarf_section * section = &debug_displays [debug].section;
13351
13352 if (section->start == NULL)
13353 return;
13354
13355 free ((char *) section->start);
13356 section->start = NULL;
13357 section->address = 0;
13358 section->size = 0;
13359}
13360
13361static bfd_boolean
13362display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
13363{
13364 char * name = SECTION_NAME (section);
13365 const char * print_name = printable_section_name (section);
13366 bfd_size_type length;
13367 bfd_boolean result = TRUE;
13368 int i;
13369
13370 length = section->sh_size;
13371 if (length == 0)
13372 {
13373 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
13374 return TRUE;
13375 }
13376 if (section->sh_type == SHT_NOBITS)
13377 {
13378 /* There is no point in dumping the contents of a debugging section
13379 which has the NOBITS type - the bits in the file will be random.
13380 This can happen when a file containing a .eh_frame section is
13381 stripped with the --only-keep-debug command line option. */
13382 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13383 print_name);
13384 return FALSE;
13385 }
13386
13387 if (const_strneq (name, ".gnu.linkonce.wi."))
13388 name = ".debug_info";
13389
13390 /* See if we know how to display the contents of this section. */
13391 for (i = 0; i < max; i++)
13392 if (streq (debug_displays[i].section.uncompressed_name, name)
13393 || (i == line && const_strneq (name, ".debug_line."))
13394 || streq (debug_displays[i].section.compressed_name, name))
13395 {
13396 struct dwarf_section * sec = &debug_displays [i].section;
13397 int secondary = (section != find_section (name));
13398
13399 if (secondary)
13400 free_debug_section ((enum dwarf_section_display_enum) i);
13401
13402 if (i == line && const_strneq (name, ".debug_line."))
13403 sec->name = name;
13404 else if (streq (sec->uncompressed_name, name))
13405 sec->name = sec->uncompressed_name;
13406 else
13407 sec->name = sec->compressed_name;
13408 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
13409 section, file))
13410 {
13411 /* If this debug section is part of a CU/TU set in a .dwp file,
13412 restrict load_debug_section to the sections in that set. */
13413 section_subset = find_cu_tu_set (file, shndx);
13414
13415 result &= debug_displays[i].display (sec, file);
13416
13417 section_subset = NULL;
13418
13419 if (secondary || (i != info && i != abbrev))
13420 free_debug_section ((enum dwarf_section_display_enum) i);
13421 }
13422
13423 break;
13424 }
13425
13426 if (i == max)
13427 {
13428 printf (_("Unrecognized debug section: %s\n"), print_name);
13429 result = FALSE;
13430 }
13431
13432 return result;
13433}
13434
13435/* Set DUMP_SECTS for all sections where dumps were requested
13436 based on section name. */
13437
13438static void
13439initialise_dumps_byname (void)
13440{
13441 struct dump_list_entry * cur;
13442
13443 for (cur = dump_sects_byname; cur; cur = cur->next)
13444 {
13445 unsigned int i;
13446 bfd_boolean any = FALSE;
13447
13448 for (i = 0; i < elf_header.e_shnum; i++)
13449 if (streq (SECTION_NAME (section_headers + i), cur->name))
13450 {
13451 request_dump_bynumber (i, cur->type);
13452 any = TRUE;
13453 }
13454
13455 if (!any)
13456 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13457 cur->name);
13458 }
13459}
13460
13461static bfd_boolean
13462process_section_contents (FILE * file)
13463{
13464 Elf_Internal_Shdr * section;
13465 unsigned int i;
13466 bfd_boolean res = TRUE;
13467
13468 if (! do_dump)
13469 return TRUE;
13470
13471 initialise_dumps_byname ();
13472
13473 for (i = 0, section = section_headers;
13474 i < elf_header.e_shnum && i < num_dump_sects;
13475 i++, section++)
13476 {
13477#ifdef SUPPORT_DISASSEMBLY
13478 if (dump_sects[i] & DISASS_DUMP)
13479 disassemble_section (section, file);
13480#endif
13481 if (dump_sects[i] & HEX_DUMP)
13482 {
13483 if (! dump_section_as_bytes (section, file, FALSE))
13484 res = FALSE;
13485 }
13486
13487 if (dump_sects[i] & RELOC_DUMP)
13488 {
13489 if (! dump_section_as_bytes (section, file, TRUE))
13490 res = FALSE;
13491 }
13492
13493 if (dump_sects[i] & STRING_DUMP)
13494 {
13495 if (! dump_section_as_strings (section, file))
13496 res = FALSE;
13497 }
13498
13499 if (dump_sects[i] & DEBUG_DUMP)
13500 {
13501 if (! display_debug_section (i, section, file))
13502 res = FALSE;
13503 }
13504 }
13505
13506 /* Check to see if the user requested a
13507 dump of a section that does not exist. */
13508 while (i < num_dump_sects)
13509 {
13510 if (dump_sects[i])
13511 {
13512 warn (_("Section %d was not dumped because it does not exist!\n"), i);
13513 res = FALSE;
13514 }
13515 i++;
13516 }
13517
13518 return res;
13519}
13520
13521static void
13522process_mips_fpe_exception (int mask)
13523{
13524 if (mask)
13525 {
13526 bfd_boolean first = TRUE;
13527
13528 if (mask & OEX_FPU_INEX)
13529 fputs ("INEX", stdout), first = FALSE;
13530 if (mask & OEX_FPU_UFLO)
13531 printf ("%sUFLO", first ? "" : "|"), first = FALSE;
13532 if (mask & OEX_FPU_OFLO)
13533 printf ("%sOFLO", first ? "" : "|"), first = FALSE;
13534 if (mask & OEX_FPU_DIV0)
13535 printf ("%sDIV0", first ? "" : "|"), first = FALSE;
13536 if (mask & OEX_FPU_INVAL)
13537 printf ("%sINVAL", first ? "" : "|");
13538 }
13539 else
13540 fputs ("0", stdout);
13541}
13542
13543/* Display's the value of TAG at location P. If TAG is
13544 greater than 0 it is assumed to be an unknown tag, and
13545 a message is printed to this effect. Otherwise it is
13546 assumed that a message has already been printed.
13547
13548 If the bottom bit of TAG is set it assumed to have a
13549 string value, otherwise it is assumed to have an integer
13550 value.
13551
13552 Returns an updated P pointing to the first unread byte
13553 beyond the end of TAG's value.
13554
13555 Reads at or beyond END will not be made. */
13556
13557static unsigned char *
13558display_tag_value (signed int tag,
13559 unsigned char * p,
13560 const unsigned char * const end)
13561{
13562 unsigned long val;
13563
13564 if (tag > 0)
13565 printf (" Tag_unknown_%d: ", tag);
13566
13567 if (p >= end)
13568 {
13569 warn (_("<corrupt tag>\n"));
13570 }
13571 else if (tag & 1)
13572 {
13573 /* PR 17531 file: 027-19978-0.004. */
13574 size_t maxlen = (end - p) - 1;
13575
13576 putchar ('"');
13577 if (maxlen > 0)
13578 {
13579 print_symbol ((int) maxlen, (const char *) p);
13580 p += strnlen ((char *) p, maxlen) + 1;
13581 }
13582 else
13583 {
13584 printf (_("<corrupt string tag>"));
13585 p = (unsigned char *) end;
13586 }
13587 printf ("\"\n");
13588 }
13589 else
13590 {
13591 unsigned int len;
13592
13593 val = read_uleb128 (p, &len, end);
13594 p += len;
13595 printf ("%ld (0x%lx)\n", val, val);
13596 }
13597
13598 assert (p <= end);
13599 return p;
13600}
13601
13602/* ARC ABI attributes section. */
13603
13604static unsigned char *
13605display_arc_attribute (unsigned char * p,
13606 const unsigned char * const end)
13607{
13608 unsigned int tag;
13609 unsigned int len;
13610 unsigned int val;
13611
13612 tag = read_uleb128 (p, &len, end);
13613 p += len;
13614
13615 switch (tag)
13616 {
13617 case Tag_ARC_PCS_config:
13618 val = read_uleb128 (p, &len, end);
13619 p += len;
13620 printf (" Tag_ARC_PCS_config: ");
13621 switch (val)
13622 {
13623 case 0:
13624 printf (_("Absent/Non standard\n"));
13625 break;
13626 case 1:
13627 printf (_("Bare metal/mwdt\n"));
13628 break;
13629 case 2:
13630 printf (_("Bare metal/newlib\n"));
13631 break;
13632 case 3:
13633 printf (_("Linux/uclibc\n"));
13634 break;
13635 case 4:
13636 printf (_("Linux/glibc\n"));
13637 break;
13638 default:
13639 printf (_("Unknown\n"));
13640 break;
13641 }
13642 break;
13643
13644 case Tag_ARC_CPU_base:
13645 val = read_uleb128 (p, &len, end);
13646 p += len;
13647 printf (" Tag_ARC_CPU_base: ");
13648 switch (val)
13649 {
13650 default:
13651 case TAG_CPU_NONE:
13652 printf (_("Absent\n"));
13653 break;
13654 case TAG_CPU_ARC6xx:
13655 printf ("ARC6xx\n");
13656 break;
13657 case TAG_CPU_ARC7xx:
13658 printf ("ARC7xx\n");
13659 break;
13660 case TAG_CPU_ARCEM:
13661 printf ("ARCEM\n");
13662 break;
13663 case TAG_CPU_ARCHS:
13664 printf ("ARCHS\n");
13665 break;
13666 }
13667 break;
13668
13669 case Tag_ARC_CPU_variation:
13670 val = read_uleb128 (p, &len, end);
13671 p += len;
13672 printf (" Tag_ARC_CPU_variation: ");
13673 switch (val)
13674 {
13675 default:
13676 if (val > 0 && val < 16)
13677 printf ("Core%d\n", val);
13678 else
13679 printf ("Unknown\n");
13680 break;
13681
13682 case 0:
13683 printf (_("Absent\n"));
13684 break;
13685 }
13686 break;
13687
13688 case Tag_ARC_CPU_name:
13689 printf (" Tag_ARC_CPU_name: ");
13690 p = display_tag_value (-1, p, end);
13691 break;
13692
13693 case Tag_ARC_ABI_rf16:
13694 val = read_uleb128 (p, &len, end);
13695 p += len;
13696 printf (" Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
13697 break;
13698
13699 case Tag_ARC_ABI_osver:
13700 val = read_uleb128 (p, &len, end);
13701 p += len;
13702 printf (" Tag_ARC_ABI_osver: v%d\n", val);
13703 break;
13704
13705 case Tag_ARC_ABI_pic:
13706 case Tag_ARC_ABI_sda:
13707 val = read_uleb128 (p, &len, end);
13708 p += len;
13709 printf (tag == Tag_ARC_ABI_sda ? " Tag_ARC_ABI_sda: "
13710 : " Tag_ARC_ABI_pic: ");
13711 switch (val)
13712 {
13713 case 0:
13714 printf (_("Absent\n"));
13715 break;
13716 case 1:
13717 printf ("MWDT\n");
13718 break;
13719 case 2:
13720 printf ("GNU\n");
13721 break;
13722 default:
13723 printf (_("Unknown\n"));
13724 break;
13725 }
13726 break;
13727
13728 case Tag_ARC_ABI_tls:
13729 val = read_uleb128 (p, &len, end);
13730 p += len;
13731 printf (" Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
13732 break;
13733
13734 case Tag_ARC_ABI_enumsize:
13735 val = read_uleb128 (p, &len, end);
13736 p += len;
13737 printf (" Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
13738 _("smallest"));
13739 break;
13740
13741 case Tag_ARC_ABI_exceptions:
13742 val = read_uleb128 (p, &len, end);
13743 p += len;
13744 printf (" Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
13745 : _("default"));
13746 break;
13747
13748 case Tag_ARC_ABI_double_size:
13749 val = read_uleb128 (p, &len, end);
13750 p += len;
13751 printf (" Tag_ARC_ABI_double_size: %d\n", val);
13752 break;
13753
13754 case Tag_ARC_ISA_config:
13755 printf (" Tag_ARC_ISA_config: ");
13756 p = display_tag_value (-1, p, end);
13757 break;
13758
13759 case Tag_ARC_ISA_apex:
13760 printf (" Tag_ARC_ISA_apex: ");
13761 p = display_tag_value (-1, p, end);
13762 break;
13763
13764 case Tag_ARC_ISA_mpy_option:
13765 val = read_uleb128 (p, &len, end);
13766 p += len;
13767 printf (" Tag_ARC_ISA_mpy_option: %d\n", val);
13768 break;
13769
13770 default:
13771 return display_tag_value (tag & 1, p, end);
13772 }
13773
13774 return p;
13775}
13776
13777/* ARM EABI attributes section. */
13778typedef struct
13779{
13780 unsigned int tag;
13781 const char * name;
13782 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
13783 unsigned int type;
13784 const char ** table;
13785} arm_attr_public_tag;
13786
13787static const char * arm_attr_tag_CPU_arch[] =
13788 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
13789 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
13790 "v8-M.mainline"};
13791static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
13792static const char * arm_attr_tag_THUMB_ISA_use[] =
13793 {"No", "Thumb-1", "Thumb-2", "Yes"};
13794static const char * arm_attr_tag_FP_arch[] =
13795 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
13796 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
13797static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
13798static const char * arm_attr_tag_Advanced_SIMD_arch[] =
13799 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13800 "NEON for ARMv8.1"};
13801static const char * arm_attr_tag_PCS_config[] =
13802 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13803 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
13804static const char * arm_attr_tag_ABI_PCS_R9_use[] =
13805 {"V6", "SB", "TLS", "Unused"};
13806static const char * arm_attr_tag_ABI_PCS_RW_data[] =
13807 {"Absolute", "PC-relative", "SB-relative", "None"};
13808static const char * arm_attr_tag_ABI_PCS_RO_data[] =
13809 {"Absolute", "PC-relative", "None"};
13810static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
13811 {"None", "direct", "GOT-indirect"};
13812static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
13813 {"None", "??? 1", "2", "??? 3", "4"};
13814static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
13815static const char * arm_attr_tag_ABI_FP_denormal[] =
13816 {"Unused", "Needed", "Sign only"};
13817static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
13818static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
13819static const char * arm_attr_tag_ABI_FP_number_model[] =
13820 {"Unused", "Finite", "RTABI", "IEEE 754"};
13821static const char * arm_attr_tag_ABI_enum_size[] =
13822 {"Unused", "small", "int", "forced to int"};
13823static const char * arm_attr_tag_ABI_HardFP_use[] =
13824 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
13825static const char * arm_attr_tag_ABI_VFP_args[] =
13826 {"AAPCS", "VFP registers", "custom", "compatible"};
13827static const char * arm_attr_tag_ABI_WMMX_args[] =
13828 {"AAPCS", "WMMX registers", "custom"};
13829static const char * arm_attr_tag_ABI_optimization_goals[] =
13830 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13831 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
13832static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
13833 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13834 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
13835static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
13836static const char * arm_attr_tag_FP_HP_extension[] =
13837 {"Not Allowed", "Allowed"};
13838static const char * arm_attr_tag_ABI_FP_16bit_format[] =
13839 {"None", "IEEE 754", "Alternative Format"};
13840static const char * arm_attr_tag_DSP_extension[] =
13841 {"Follow architecture", "Allowed"};
13842static const char * arm_attr_tag_MPextension_use[] =
13843 {"Not Allowed", "Allowed"};
13844static const char * arm_attr_tag_DIV_use[] =
13845 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
13846 "Allowed in v7-A with integer division extension"};
13847static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
13848static const char * arm_attr_tag_Virtualization_use[] =
13849 {"Not Allowed", "TrustZone", "Virtualization Extensions",
13850 "TrustZone and Virtualization Extensions"};
13851static const char * arm_attr_tag_MPextension_use_legacy[] =
13852 {"Not Allowed", "Allowed"};
13853
13854#define LOOKUP(id, name) \
13855 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
13856static arm_attr_public_tag arm_attr_public_tags[] =
13857{
13858 {4, "CPU_raw_name", 1, NULL},
13859 {5, "CPU_name", 1, NULL},
13860 LOOKUP(6, CPU_arch),
13861 {7, "CPU_arch_profile", 0, NULL},
13862 LOOKUP(8, ARM_ISA_use),
13863 LOOKUP(9, THUMB_ISA_use),
13864 LOOKUP(10, FP_arch),
13865 LOOKUP(11, WMMX_arch),
13866 LOOKUP(12, Advanced_SIMD_arch),
13867 LOOKUP(13, PCS_config),
13868 LOOKUP(14, ABI_PCS_R9_use),
13869 LOOKUP(15, ABI_PCS_RW_data),
13870 LOOKUP(16, ABI_PCS_RO_data),
13871 LOOKUP(17, ABI_PCS_GOT_use),
13872 LOOKUP(18, ABI_PCS_wchar_t),
13873 LOOKUP(19, ABI_FP_rounding),
13874 LOOKUP(20, ABI_FP_denormal),
13875 LOOKUP(21, ABI_FP_exceptions),
13876 LOOKUP(22, ABI_FP_user_exceptions),
13877 LOOKUP(23, ABI_FP_number_model),
13878 {24, "ABI_align_needed", 0, NULL},
13879 {25, "ABI_align_preserved", 0, NULL},
13880 LOOKUP(26, ABI_enum_size),
13881 LOOKUP(27, ABI_HardFP_use),
13882 LOOKUP(28, ABI_VFP_args),
13883 LOOKUP(29, ABI_WMMX_args),
13884 LOOKUP(30, ABI_optimization_goals),
13885 LOOKUP(31, ABI_FP_optimization_goals),
13886 {32, "compatibility", 0, NULL},
13887 LOOKUP(34, CPU_unaligned_access),
13888 LOOKUP(36, FP_HP_extension),
13889 LOOKUP(38, ABI_FP_16bit_format),
13890 LOOKUP(42, MPextension_use),
13891 LOOKUP(44, DIV_use),
13892 LOOKUP(46, DSP_extension),
13893 {64, "nodefaults", 0, NULL},
13894 {65, "also_compatible_with", 0, NULL},
13895 LOOKUP(66, T2EE_use),
13896 {67, "conformance", 1, NULL},
13897 LOOKUP(68, Virtualization_use),
13898 LOOKUP(70, MPextension_use_legacy)
13899};
13900#undef LOOKUP
13901
13902static unsigned char *
13903display_arm_attribute (unsigned char * p,
13904 const unsigned char * const end)
13905{
13906 unsigned int tag;
13907 unsigned int len;
13908 unsigned int val;
13909 arm_attr_public_tag * attr;
13910 unsigned i;
13911 unsigned int type;
13912
13913 tag = read_uleb128 (p, &len, end);
13914 p += len;
13915 attr = NULL;
13916 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
13917 {
13918 if (arm_attr_public_tags[i].tag == tag)
13919 {
13920 attr = &arm_attr_public_tags[i];
13921 break;
13922 }
13923 }
13924
13925 if (attr)
13926 {
13927 printf (" Tag_%s: ", attr->name);
13928 switch (attr->type)
13929 {
13930 case 0:
13931 switch (tag)
13932 {
13933 case 7: /* Tag_CPU_arch_profile. */
13934 val = read_uleb128 (p, &len, end);
13935 p += len;
13936 switch (val)
13937 {
13938 case 0: printf (_("None\n")); break;
13939 case 'A': printf (_("Application\n")); break;
13940 case 'R': printf (_("Realtime\n")); break;
13941 case 'M': printf (_("Microcontroller\n")); break;
13942 case 'S': printf (_("Application or Realtime\n")); break;
13943 default: printf ("??? (%d)\n", val); break;
13944 }
13945 break;
13946
13947 case 24: /* Tag_align_needed. */
13948 val = read_uleb128 (p, &len, end);
13949 p += len;
13950 switch (val)
13951 {
13952 case 0: printf (_("None\n")); break;
13953 case 1: printf (_("8-byte\n")); break;
13954 case 2: printf (_("4-byte\n")); break;
13955 case 3: printf ("??? 3\n"); break;
13956 default:
13957 if (val <= 12)
13958 printf (_("8-byte and up to %d-byte extended\n"),
13959 1 << val);
13960 else
13961 printf ("??? (%d)\n", val);
13962 break;
13963 }
13964 break;
13965
13966 case 25: /* Tag_align_preserved. */
13967 val = read_uleb128 (p, &len, end);
13968 p += len;
13969 switch (val)
13970 {
13971 case 0: printf (_("None\n")); break;
13972 case 1: printf (_("8-byte, except leaf SP\n")); break;
13973 case 2: printf (_("8-byte\n")); break;
13974 case 3: printf ("??? 3\n"); break;
13975 default:
13976 if (val <= 12)
13977 printf (_("8-byte and up to %d-byte extended\n"),
13978 1 << val);
13979 else
13980 printf ("??? (%d)\n", val);
13981 break;
13982 }
13983 break;
13984
13985 case 32: /* Tag_compatibility. */
13986 {
13987 val = read_uleb128 (p, &len, end);
13988 p += len;
13989 printf (_("flag = %d, vendor = "), val);
13990 if (p < end - 1)
13991 {
13992 size_t maxlen = (end - p) - 1;
13993
13994 print_symbol ((int) maxlen, (const char *) p);
13995 p += strnlen ((char *) p, maxlen) + 1;
13996 }
13997 else
13998 {
13999 printf (_("<corrupt>"));
14000 p = (unsigned char *) end;
14001 }
14002 putchar ('\n');
14003 }
14004 break;
14005
14006 case 64: /* Tag_nodefaults. */
14007 /* PR 17531: file: 001-505008-0.01. */
14008 if (p < end)
14009 p++;
14010 printf (_("True\n"));
14011 break;
14012
14013 case 65: /* Tag_also_compatible_with. */
14014 val = read_uleb128 (p, &len, end);
14015 p += len;
14016 if (val == 6 /* Tag_CPU_arch. */)
14017 {
14018 val = read_uleb128 (p, &len, end);
14019 p += len;
14020 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
14021 printf ("??? (%d)\n", val);
14022 else
14023 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
14024 }
14025 else
14026 printf ("???\n");
14027 while (p < end && *(p++) != '\0' /* NUL terminator. */)
14028 ;
14029 break;
14030
14031 default:
14032 printf (_("<unknown: %d>\n"), tag);
14033 break;
14034 }
14035 return p;
14036
14037 case 1:
14038 return display_tag_value (-1, p, end);
14039 case 2:
14040 return display_tag_value (0, p, end);
14041
14042 default:
14043 assert (attr->type & 0x80);
14044 val = read_uleb128 (p, &len, end);
14045 p += len;
14046 type = attr->type & 0x7f;
14047 if (val >= type)
14048 printf ("??? (%d)\n", val);
14049 else
14050 printf ("%s\n", attr->table[val]);
14051 return p;
14052 }
14053 }
14054
14055 return display_tag_value (tag, p, end);
14056}
14057
14058static unsigned char *
14059display_gnu_attribute (unsigned char * p,
14060 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
14061 const unsigned char * const end)
14062{
14063 int tag;
14064 unsigned int len;
14065 unsigned int val;
14066
14067 tag = read_uleb128 (p, &len, end);
14068 p += len;
14069
14070 /* Tag_compatibility is the only generic GNU attribute defined at
14071 present. */
14072 if (tag == 32)
14073 {
14074 val = read_uleb128 (p, &len, end);
14075 p += len;
14076
14077 printf (_("flag = %d, vendor = "), val);
14078 if (p == end)
14079 {
14080 printf (_("<corrupt>\n"));
14081 warn (_("corrupt vendor attribute\n"));
14082 }
14083 else
14084 {
14085 if (p < end - 1)
14086 {
14087 size_t maxlen = (end - p) - 1;
14088
14089 print_symbol ((int) maxlen, (const char *) p);
14090 p += strnlen ((char *) p, maxlen) + 1;
14091 }
14092 else
14093 {
14094 printf (_("<corrupt>"));
14095 p = (unsigned char *) end;
14096 }
14097 putchar ('\n');
14098 }
14099 return p;
14100 }
14101
14102 if ((tag & 2) == 0 && display_proc_gnu_attribute)
14103 return display_proc_gnu_attribute (p, tag, end);
14104
14105 return display_tag_value (tag, p, end);
14106}
14107
14108static unsigned char *
14109display_power_gnu_attribute (unsigned char * p,
14110 unsigned int tag,
14111 const unsigned char * const end)
14112{
14113 unsigned int len;
14114 unsigned int val;
14115
14116 if (tag == Tag_GNU_Power_ABI_FP)
14117 {
14118 val = read_uleb128 (p, &len, end);
14119 p += len;
14120 printf (" Tag_GNU_Power_ABI_FP: ");
14121 if (len == 0)
14122 {
14123 printf (_("<corrupt>\n"));
14124 return p;
14125 }
14126
14127 if (val > 15)
14128 printf ("(%#x), ", val);
14129
14130 switch (val & 3)
14131 {
14132 case 0:
14133 printf (_("unspecified hard/soft float, "));
14134 break;
14135 case 1:
14136 printf (_("hard float, "));
14137 break;
14138 case 2:
14139 printf (_("soft float, "));
14140 break;
14141 case 3:
14142 printf (_("single-precision hard float, "));
14143 break;
14144 }
14145
14146 switch (val & 0xC)
14147 {
14148 case 0:
14149 printf (_("unspecified long double\n"));
14150 break;
14151 case 4:
14152 printf (_("128-bit IBM long double\n"));
14153 break;
14154 case 8:
14155 printf (_("64-bit long double\n"));
14156 break;
14157 case 12:
14158 printf (_("128-bit IEEE long double\n"));
14159 break;
14160 }
14161 return p;
14162 }
14163
14164 if (tag == Tag_GNU_Power_ABI_Vector)
14165 {
14166 val = read_uleb128 (p, &len, end);
14167 p += len;
14168 printf (" Tag_GNU_Power_ABI_Vector: ");
14169 if (len == 0)
14170 {
14171 printf (_("<corrupt>\n"));
14172 return p;
14173 }
14174
14175 if (val > 3)
14176 printf ("(%#x), ", val);
14177
14178 switch (val & 3)
14179 {
14180 case 0:
14181 printf (_("unspecified\n"));
14182 break;
14183 case 1:
14184 printf (_("generic\n"));
14185 break;
14186 case 2:
14187 printf ("AltiVec\n");
14188 break;
14189 case 3:
14190 printf ("SPE\n");
14191 break;
14192 }
14193 return p;
14194 }
14195
14196 if (tag == Tag_GNU_Power_ABI_Struct_Return)
14197 {
14198 val = read_uleb128 (p, &len, end);
14199 p += len;
14200 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
14201 if (len == 0)
14202 {
14203 printf (_("<corrupt>\n"));
14204 return p;
14205 }
14206
14207 if (val > 2)
14208 printf ("(%#x), ", val);
14209
14210 switch (val & 3)
14211 {
14212 case 0:
14213 printf (_("unspecified\n"));
14214 break;
14215 case 1:
14216 printf ("r3/r4\n");
14217 break;
14218 case 2:
14219 printf (_("memory\n"));
14220 break;
14221 case 3:
14222 printf ("???\n");
14223 break;
14224 }
14225 return p;
14226 }
14227
14228 return display_tag_value (tag & 1, p, end);
14229}
14230
14231static unsigned char *
14232display_s390_gnu_attribute (unsigned char * p,
14233 unsigned int tag,
14234 const unsigned char * const end)
14235{
14236 unsigned int len;
14237 int val;
14238
14239 if (tag == Tag_GNU_S390_ABI_Vector)
14240 {
14241 val = read_uleb128 (p, &len, end);
14242 p += len;
14243 printf (" Tag_GNU_S390_ABI_Vector: ");
14244
14245 switch (val)
14246 {
14247 case 0:
14248 printf (_("any\n"));
14249 break;
14250 case 1:
14251 printf (_("software\n"));
14252 break;
14253 case 2:
14254 printf (_("hardware\n"));
14255 break;
14256 default:
14257 printf ("??? (%d)\n", val);
14258 break;
14259 }
14260 return p;
14261 }
14262
14263 return display_tag_value (tag & 1, p, end);
14264}
14265
14266static void
14267display_sparc_hwcaps (unsigned int mask)
14268{
14269 if (mask)
14270 {
14271 bfd_boolean first = TRUE;
14272
14273 if (mask & ELF_SPARC_HWCAP_MUL32)
14274 fputs ("mul32", stdout), first = FALSE;
14275 if (mask & ELF_SPARC_HWCAP_DIV32)
14276 printf ("%sdiv32", first ? "" : "|"), first = FALSE;
14277 if (mask & ELF_SPARC_HWCAP_FSMULD)
14278 printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
14279 if (mask & ELF_SPARC_HWCAP_V8PLUS)
14280 printf ("%sv8plus", first ? "" : "|"), first = FALSE;
14281 if (mask & ELF_SPARC_HWCAP_POPC)
14282 printf ("%spopc", first ? "" : "|"), first = FALSE;
14283 if (mask & ELF_SPARC_HWCAP_VIS)
14284 printf ("%svis", first ? "" : "|"), first = FALSE;
14285 if (mask & ELF_SPARC_HWCAP_VIS2)
14286 printf ("%svis2", first ? "" : "|"), first = FALSE;
14287 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
14288 printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
14289 if (mask & ELF_SPARC_HWCAP_FMAF)
14290 printf ("%sfmaf", first ? "" : "|"), first = FALSE;
14291 if (mask & ELF_SPARC_HWCAP_VIS3)
14292 printf ("%svis3", first ? "" : "|"), first = FALSE;
14293 if (mask & ELF_SPARC_HWCAP_HPC)
14294 printf ("%shpc", first ? "" : "|"), first = FALSE;
14295 if (mask & ELF_SPARC_HWCAP_RANDOM)
14296 printf ("%srandom", first ? "" : "|"), first = FALSE;
14297 if (mask & ELF_SPARC_HWCAP_TRANS)
14298 printf ("%strans", first ? "" : "|"), first = FALSE;
14299 if (mask & ELF_SPARC_HWCAP_FJFMAU)
14300 printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
14301 if (mask & ELF_SPARC_HWCAP_IMA)
14302 printf ("%sima", first ? "" : "|"), first = FALSE;
14303 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
14304 printf ("%scspare", first ? "" : "|"), first = FALSE;
14305 }
14306 else
14307 fputc ('0', stdout);
14308 fputc ('\n', stdout);
14309}
14310
14311static void
14312display_sparc_hwcaps2 (unsigned int mask)
14313{
14314 if (mask)
14315 {
14316 bfd_boolean first = TRUE;
14317
14318 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
14319 fputs ("fjathplus", stdout), first = FALSE;
14320 if (mask & ELF_SPARC_HWCAP2_VIS3B)
14321 printf ("%svis3b", first ? "" : "|"), first = FALSE;
14322 if (mask & ELF_SPARC_HWCAP2_ADP)
14323 printf ("%sadp", first ? "" : "|"), first = FALSE;
14324 if (mask & ELF_SPARC_HWCAP2_SPARC5)
14325 printf ("%ssparc5", first ? "" : "|"), first = FALSE;
14326 if (mask & ELF_SPARC_HWCAP2_MWAIT)
14327 printf ("%smwait", first ? "" : "|"), first = FALSE;
14328 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
14329 printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
14330 if (mask & ELF_SPARC_HWCAP2_XMONT)
14331 printf ("%sxmont2", first ? "" : "|"), first = FALSE;
14332 if (mask & ELF_SPARC_HWCAP2_NSEC)
14333 printf ("%snsec", first ? "" : "|"), first = FALSE;
14334 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
14335 printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
14336 if (mask & ELF_SPARC_HWCAP2_FJDES)
14337 printf ("%sfjdes", first ? "" : "|"), first = FALSE;
14338 if (mask & ELF_SPARC_HWCAP2_FJAES)
14339 printf ("%sfjaes", first ? "" : "|"), first = FALSE;
14340 }
14341 else
14342 fputc ('0', stdout);
14343 fputc ('\n', stdout);
14344}
14345
14346static unsigned char *
14347display_sparc_gnu_attribute (unsigned char * p,
14348 unsigned int tag,
14349 const unsigned char * const end)
14350{
14351 unsigned int len;
14352 int val;
14353
14354 if (tag == Tag_GNU_Sparc_HWCAPS)
14355 {
14356 val = read_uleb128 (p, &len, end);
14357 p += len;
14358 printf (" Tag_GNU_Sparc_HWCAPS: ");
14359 display_sparc_hwcaps (val);
14360 return p;
14361 }
14362 if (tag == Tag_GNU_Sparc_HWCAPS2)
14363 {
14364 val = read_uleb128 (p, &len, end);
14365 p += len;
14366 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14367 display_sparc_hwcaps2 (val);
14368 return p;
14369 }
14370
14371 return display_tag_value (tag, p, end);
14372}
14373
14374static void
14375print_mips_fp_abi_value (unsigned int val)
14376{
14377 switch (val)
14378 {
14379 case Val_GNU_MIPS_ABI_FP_ANY:
14380 printf (_("Hard or soft float\n"));
14381 break;
14382 case Val_GNU_MIPS_ABI_FP_DOUBLE:
14383 printf (_("Hard float (double precision)\n"));
14384 break;
14385 case Val_GNU_MIPS_ABI_FP_SINGLE:
14386 printf (_("Hard float (single precision)\n"));
14387 break;
14388 case Val_GNU_MIPS_ABI_FP_SOFT:
14389 printf (_("Soft float\n"));
14390 break;
14391 case Val_GNU_MIPS_ABI_FP_OLD_64:
14392 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14393 break;
14394 case Val_GNU_MIPS_ABI_FP_XX:
14395 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14396 break;
14397 case Val_GNU_MIPS_ABI_FP_64:
14398 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14399 break;
14400 case Val_GNU_MIPS_ABI_FP_64A:
14401 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14402 break;
14403 case Val_GNU_MIPS_ABI_FP_NAN2008:
14404 printf (_("NaN 2008 compatibility\n"));
14405 break;
14406 default:
14407 printf ("??? (%d)\n", val);
14408 break;
14409 }
14410}
14411
14412static unsigned char *
14413display_mips_gnu_attribute (unsigned char * p,
14414 unsigned int tag,
14415 const unsigned char * const end)
14416{
14417 if (tag == Tag_GNU_MIPS_ABI_FP)
14418 {
14419 unsigned int len;
14420 unsigned int val;
14421
14422 val = read_uleb128 (p, &len, end);
14423 p += len;
14424 printf (" Tag_GNU_MIPS_ABI_FP: ");
14425
14426 print_mips_fp_abi_value (val);
14427
14428 return p;
14429 }
14430
14431 if (tag == Tag_GNU_MIPS_ABI_MSA)
14432 {
14433 unsigned int len;
14434 unsigned int val;
14435
14436 val = read_uleb128 (p, &len, end);
14437 p += len;
14438 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14439
14440 switch (val)
14441 {
14442 case Val_GNU_MIPS_ABI_MSA_ANY:
14443 printf (_("Any MSA or not\n"));
14444 break;
14445 case Val_GNU_MIPS_ABI_MSA_128:
14446 printf (_("128-bit MSA\n"));
14447 break;
14448 default:
14449 printf ("??? (%d)\n", val);
14450 break;
14451 }
14452 return p;
14453 }
14454
14455 return display_tag_value (tag & 1, p, end);
14456}
14457
14458static unsigned char *
14459display_tic6x_attribute (unsigned char * p,
14460 const unsigned char * const end)
14461{
14462 unsigned int tag;
14463 unsigned int len;
14464 int val;
14465
14466 tag = read_uleb128 (p, &len, end);
14467 p += len;
14468
14469 switch (tag)
14470 {
14471 case Tag_ISA:
14472 val = read_uleb128 (p, &len, end);
14473 p += len;
14474 printf (" Tag_ISA: ");
14475
14476 switch (val)
14477 {
14478 case C6XABI_Tag_ISA_none:
14479 printf (_("None\n"));
14480 break;
14481 case C6XABI_Tag_ISA_C62X:
14482 printf ("C62x\n");
14483 break;
14484 case C6XABI_Tag_ISA_C67X:
14485 printf ("C67x\n");
14486 break;
14487 case C6XABI_Tag_ISA_C67XP:
14488 printf ("C67x+\n");
14489 break;
14490 case C6XABI_Tag_ISA_C64X:
14491 printf ("C64x\n");
14492 break;
14493 case C6XABI_Tag_ISA_C64XP:
14494 printf ("C64x+\n");
14495 break;
14496 case C6XABI_Tag_ISA_C674X:
14497 printf ("C674x\n");
14498 break;
14499 default:
14500 printf ("??? (%d)\n", val);
14501 break;
14502 }
14503 return p;
14504
14505 case Tag_ABI_wchar_t:
14506 val = read_uleb128 (p, &len, end);
14507 p += len;
14508 printf (" Tag_ABI_wchar_t: ");
14509 switch (val)
14510 {
14511 case 0:
14512 printf (_("Not used\n"));
14513 break;
14514 case 1:
14515 printf (_("2 bytes\n"));
14516 break;
14517 case 2:
14518 printf (_("4 bytes\n"));
14519 break;
14520 default:
14521 printf ("??? (%d)\n", val);
14522 break;
14523 }
14524 return p;
14525
14526 case Tag_ABI_stack_align_needed:
14527 val = read_uleb128 (p, &len, end);
14528 p += len;
14529 printf (" Tag_ABI_stack_align_needed: ");
14530 switch (val)
14531 {
14532 case 0:
14533 printf (_("8-byte\n"));
14534 break;
14535 case 1:
14536 printf (_("16-byte\n"));
14537 break;
14538 default:
14539 printf ("??? (%d)\n", val);
14540 break;
14541 }
14542 return p;
14543
14544 case Tag_ABI_stack_align_preserved:
14545 val = read_uleb128 (p, &len, end);
14546 p += len;
14547 printf (" Tag_ABI_stack_align_preserved: ");
14548 switch (val)
14549 {
14550 case 0:
14551 printf (_("8-byte\n"));
14552 break;
14553 case 1:
14554 printf (_("16-byte\n"));
14555 break;
14556 default:
14557 printf ("??? (%d)\n", val);
14558 break;
14559 }
14560 return p;
14561
14562 case Tag_ABI_DSBT:
14563 val = read_uleb128 (p, &len, end);
14564 p += len;
14565 printf (" Tag_ABI_DSBT: ");
14566 switch (val)
14567 {
14568 case 0:
14569 printf (_("DSBT addressing not used\n"));
14570 break;
14571 case 1:
14572 printf (_("DSBT addressing used\n"));
14573 break;
14574 default:
14575 printf ("??? (%d)\n", val);
14576 break;
14577 }
14578 return p;
14579
14580 case Tag_ABI_PID:
14581 val = read_uleb128 (p, &len, end);
14582 p += len;
14583 printf (" Tag_ABI_PID: ");
14584 switch (val)
14585 {
14586 case 0:
14587 printf (_("Data addressing position-dependent\n"));
14588 break;
14589 case 1:
14590 printf (_("Data addressing position-independent, GOT near DP\n"));
14591 break;
14592 case 2:
14593 printf (_("Data addressing position-independent, GOT far from DP\n"));
14594 break;
14595 default:
14596 printf ("??? (%d)\n", val);
14597 break;
14598 }
14599 return p;
14600
14601 case Tag_ABI_PIC:
14602 val = read_uleb128 (p, &len, end);
14603 p += len;
14604 printf (" Tag_ABI_PIC: ");
14605 switch (val)
14606 {
14607 case 0:
14608 printf (_("Code addressing position-dependent\n"));
14609 break;
14610 case 1:
14611 printf (_("Code addressing position-independent\n"));
14612 break;
14613 default:
14614 printf ("??? (%d)\n", val);
14615 break;
14616 }
14617 return p;
14618
14619 case Tag_ABI_array_object_alignment:
14620 val = read_uleb128 (p, &len, end);
14621 p += len;
14622 printf (" Tag_ABI_array_object_alignment: ");
14623 switch (val)
14624 {
14625 case 0:
14626 printf (_("8-byte\n"));
14627 break;
14628 case 1:
14629 printf (_("4-byte\n"));
14630 break;
14631 case 2:
14632 printf (_("16-byte\n"));
14633 break;
14634 default:
14635 printf ("??? (%d)\n", val);
14636 break;
14637 }
14638 return p;
14639
14640 case Tag_ABI_array_object_align_expected:
14641 val = read_uleb128 (p, &len, end);
14642 p += len;
14643 printf (" Tag_ABI_array_object_align_expected: ");
14644 switch (val)
14645 {
14646 case 0:
14647 printf (_("8-byte\n"));
14648 break;
14649 case 1:
14650 printf (_("4-byte\n"));
14651 break;
14652 case 2:
14653 printf (_("16-byte\n"));
14654 break;
14655 default:
14656 printf ("??? (%d)\n", val);
14657 break;
14658 }
14659 return p;
14660
14661 case Tag_ABI_compatibility:
14662 {
14663 val = read_uleb128 (p, &len, end);
14664 p += len;
14665 printf (" Tag_ABI_compatibility: ");
14666 printf (_("flag = %d, vendor = "), val);
14667 if (p < end - 1)
14668 {
14669 size_t maxlen = (end - p) - 1;
14670
14671 print_symbol ((int) maxlen, (const char *) p);
14672 p += strnlen ((char *) p, maxlen) + 1;
14673 }
14674 else
14675 {
14676 printf (_("<corrupt>"));
14677 p = (unsigned char *) end;
14678 }
14679 putchar ('\n');
14680 return p;
14681 }
14682
14683 case Tag_ABI_conformance:
14684 {
14685 printf (" Tag_ABI_conformance: \"");
14686 if (p < end - 1)
14687 {
14688 size_t maxlen = (end - p) - 1;
14689
14690 print_symbol ((int) maxlen, (const char *) p);
14691 p += strnlen ((char *) p, maxlen) + 1;
14692 }
14693 else
14694 {
14695 printf (_("<corrupt>"));
14696 p = (unsigned char *) end;
14697 }
14698 printf ("\"\n");
14699 return p;
14700 }
14701 }
14702
14703 return display_tag_value (tag, p, end);
14704}
14705
14706static void
14707display_raw_attribute (unsigned char * p, unsigned char const * const end)
14708{
14709 unsigned long addr = 0;
14710 size_t bytes = end - p;
14711
14712 assert (end > p);
14713 while (bytes)
14714 {
14715 int j;
14716 int k;
14717 int lbytes = (bytes > 16 ? 16 : bytes);
14718
14719 printf (" 0x%8.8lx ", addr);
14720
14721 for (j = 0; j < 16; j++)
14722 {
14723 if (j < lbytes)
14724 printf ("%2.2x", p[j]);
14725 else
14726 printf (" ");
14727
14728 if ((j & 3) == 3)
14729 printf (" ");
14730 }
14731
14732 for (j = 0; j < lbytes; j++)
14733 {
14734 k = p[j];
14735 if (k >= ' ' && k < 0x7f)
14736 printf ("%c", k);
14737 else
14738 printf (".");
14739 }
14740
14741 putchar ('\n');
14742
14743 p += lbytes;
14744 bytes -= lbytes;
14745 addr += lbytes;
14746 }
14747
14748 putchar ('\n');
14749}
14750
14751static unsigned char *
14752display_msp430x_attribute (unsigned char * p,
14753 const unsigned char * const end)
14754{
14755 unsigned int len;
14756 unsigned int val;
14757 unsigned int tag;
14758
14759 tag = read_uleb128 (p, & len, end);
14760 p += len;
14761
14762 switch (tag)
14763 {
14764 case OFBA_MSPABI_Tag_ISA:
14765 val = read_uleb128 (p, &len, end);
14766 p += len;
14767 printf (" Tag_ISA: ");
14768 switch (val)
14769 {
14770 case 0: printf (_("None\n")); break;
14771 case 1: printf (_("MSP430\n")); break;
14772 case 2: printf (_("MSP430X\n")); break;
14773 default: printf ("??? (%d)\n", val); break;
14774 }
14775 break;
14776
14777 case OFBA_MSPABI_Tag_Code_Model:
14778 val = read_uleb128 (p, &len, end);
14779 p += len;
14780 printf (" Tag_Code_Model: ");
14781 switch (val)
14782 {
14783 case 0: printf (_("None\n")); break;
14784 case 1: printf (_("Small\n")); break;
14785 case 2: printf (_("Large\n")); break;
14786 default: printf ("??? (%d)\n", val); break;
14787 }
14788 break;
14789
14790 case OFBA_MSPABI_Tag_Data_Model:
14791 val = read_uleb128 (p, &len, end);
14792 p += len;
14793 printf (" Tag_Data_Model: ");
14794 switch (val)
14795 {
14796 case 0: printf (_("None\n")); break;
14797 case 1: printf (_("Small\n")); break;
14798 case 2: printf (_("Large\n")); break;
14799 case 3: printf (_("Restricted Large\n")); break;
14800 default: printf ("??? (%d)\n", val); break;
14801 }
14802 break;
14803
14804 default:
14805 printf (_(" <unknown tag %d>: "), tag);
14806
14807 if (tag & 1)
14808 {
14809 putchar ('"');
14810 if (p < end - 1)
14811 {
14812 size_t maxlen = (end - p) - 1;
14813
14814 print_symbol ((int) maxlen, (const char *) p);
14815 p += strnlen ((char *) p, maxlen) + 1;
14816 }
14817 else
14818 {
14819 printf (_("<corrupt>"));
14820 p = (unsigned char *) end;
14821 }
14822 printf ("\"\n");
14823 }
14824 else
14825 {
14826 val = read_uleb128 (p, &len, end);
14827 p += len;
14828 printf ("%d (0x%x)\n", val, val);
14829 }
14830 break;
14831 }
14832
14833 assert (p <= end);
14834 return p;
14835}
14836
14837static bfd_boolean
14838process_attributes (FILE * file,
14839 const char * public_name,
14840 unsigned int proc_type,
14841 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
14842 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
14843{
14844 Elf_Internal_Shdr * sect;
14845 unsigned i;
14846 bfd_boolean res = TRUE;
14847
14848 /* Find the section header so that we get the size. */
14849 for (i = 0, sect = section_headers;
14850 i < elf_header.e_shnum;
14851 i++, sect++)
14852 {
14853 unsigned char * contents;
14854 unsigned char * p;
14855
14856 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
14857 continue;
14858
14859 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
14860 sect->sh_size, _("attributes"));
14861 if (contents == NULL)
14862 {
14863 res = FALSE;
14864 continue;
14865 }
14866
14867 p = contents;
14868 /* The first character is the version of the attributes.
14869 Currently only version 1, (aka 'A') is recognised here. */
14870 if (*p != 'A')
14871 {
14872 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
14873 res = FALSE;
14874 }
14875 else
14876 {
14877 bfd_vma section_len;
14878
14879 section_len = sect->sh_size - 1;
14880 p++;
14881
14882 while (section_len > 0)
14883 {
14884 bfd_vma attr_len;
14885 unsigned int namelen;
14886 bfd_boolean public_section;
14887 bfd_boolean gnu_section;
14888
14889 if (section_len <= 4)
14890 {
14891 error (_("Tag section ends prematurely\n"));
14892 res = FALSE;
14893 break;
14894 }
14895 attr_len = byte_get (p, 4);
14896 p += 4;
14897
14898 if (attr_len > section_len)
14899 {
14900 error (_("Bad attribute length (%u > %u)\n"),
14901 (unsigned) attr_len, (unsigned) section_len);
14902 attr_len = section_len;
14903 res = FALSE;
14904 }
14905 /* PR 17531: file: 001-101425-0.004 */
14906 else if (attr_len < 5)
14907 {
14908 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
14909 res = FALSE;
14910 break;
14911 }
14912
14913 section_len -= attr_len;
14914 attr_len -= 4;
14915
14916 namelen = strnlen ((char *) p, attr_len) + 1;
14917 if (namelen == 0 || namelen >= attr_len)
14918 {
14919 error (_("Corrupt attribute section name\n"));
14920 res = FALSE;
14921 break;
14922 }
14923
14924 printf (_("Attribute Section: "));
14925 print_symbol (INT_MAX, (const char *) p);
14926 putchar ('\n');
14927
14928 if (public_name && streq ((char *) p, public_name))
14929 public_section = TRUE;
14930 else
14931 public_section = FALSE;
14932
14933 if (streq ((char *) p, "gnu"))
14934 gnu_section = TRUE;
14935 else
14936 gnu_section = FALSE;
14937
14938 p += namelen;
14939 attr_len -= namelen;
14940
14941 while (attr_len > 0 && p < contents + sect->sh_size)
14942 {
14943 int tag;
14944 int val;
14945 bfd_vma size;
14946 unsigned char * end;
14947
14948 /* PR binutils/17531: Safe handling of corrupt files. */
14949 if (attr_len < 6)
14950 {
14951 error (_("Unused bytes at end of section\n"));
14952 res = FALSE;
14953 section_len = 0;
14954 break;
14955 }
14956
14957 tag = *(p++);
14958 size = byte_get (p, 4);
14959 if (size > attr_len)
14960 {
14961 error (_("Bad subsection length (%u > %u)\n"),
14962 (unsigned) size, (unsigned) attr_len);
14963 res = FALSE;
14964 size = attr_len;
14965 }
14966 /* PR binutils/17531: Safe handling of corrupt files. */
14967 if (size < 6)
14968 {
14969 error (_("Bad subsection length (%u < 6)\n"),
14970 (unsigned) size);
14971 res = FALSE;
14972 section_len = 0;
14973 break;
14974 }
14975
14976 attr_len -= size;
14977 end = p + size - 1;
14978 assert (end <= contents + sect->sh_size);
14979 p += 4;
14980
14981 switch (tag)
14982 {
14983 case 1:
14984 printf (_("File Attributes\n"));
14985 break;
14986 case 2:
14987 printf (_("Section Attributes:"));
14988 goto do_numlist;
14989 case 3:
14990 printf (_("Symbol Attributes:"));
14991 /* Fall through. */
14992 do_numlist:
14993 for (;;)
14994 {
14995 unsigned int j;
14996
14997 val = read_uleb128 (p, &j, end);
14998 p += j;
14999 if (val == 0)
15000 break;
15001 printf (" %d", val);
15002 }
15003 printf ("\n");
15004 break;
15005 default:
15006 printf (_("Unknown tag: %d\n"), tag);
15007 public_section = FALSE;
15008 break;
15009 }
15010
15011 if (public_section && display_pub_attribute != NULL)
15012 {
15013 while (p < end)
15014 p = display_pub_attribute (p, end);
15015 assert (p == end);
15016 }
15017 else if (gnu_section && display_proc_gnu_attribute != NULL)
15018 {
15019 while (p < end)
15020 p = display_gnu_attribute (p,
15021 display_proc_gnu_attribute,
15022 end);
15023 assert (p == end);
15024 }
15025 else if (p < end)
15026 {
15027 printf (_(" Unknown attribute:\n"));
15028 display_raw_attribute (p, end);
15029 p = end;
15030 }
15031 else
15032 attr_len = 0;
15033 }
15034 }
15035 }
15036
15037 free (contents);
15038 }
15039
15040 return res;
15041}
15042
15043/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15044 Print the Address, Access and Initial fields of an entry at VMA ADDR
15045 and return the VMA of the next entry, or -1 if there was a problem.
15046 Does not read from DATA_END or beyond. */
15047
15048static bfd_vma
15049print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
15050 unsigned char * data_end)
15051{
15052 printf (" ");
15053 print_vma (addr, LONG_HEX);
15054 printf (" ");
15055 if (addr < pltgot + 0xfff0)
15056 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
15057 else
15058 printf ("%10s", "");
15059 printf (" ");
15060 if (data == NULL)
15061 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15062 else
15063 {
15064 bfd_vma entry;
15065 unsigned char * from = data + addr - pltgot;
15066
15067 if (from + (is_32bit_elf ? 4 : 8) > data_end)
15068 {
15069 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15070 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
15071 return (bfd_vma) -1;
15072 }
15073 else
15074 {
15075 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15076 print_vma (entry, LONG_HEX);
15077 }
15078 }
15079 return addr + (is_32bit_elf ? 4 : 8);
15080}
15081
15082/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15083 PLTGOT. Print the Address and Initial fields of an entry at VMA
15084 ADDR and return the VMA of the next entry. */
15085
15086static bfd_vma
15087print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
15088{
15089 printf (" ");
15090 print_vma (addr, LONG_HEX);
15091 printf (" ");
15092 if (data == NULL)
15093 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15094 else
15095 {
15096 bfd_vma entry;
15097
15098 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15099 print_vma (entry, LONG_HEX);
15100 }
15101 return addr + (is_32bit_elf ? 4 : 8);
15102}
15103
15104static void
15105print_mips_ases (unsigned int mask)
15106{
15107 if (mask & AFL_ASE_DSP)
15108 fputs ("\n\tDSP ASE", stdout);
15109 if (mask & AFL_ASE_DSPR2)
15110 fputs ("\n\tDSP R2 ASE", stdout);
15111 if (mask & AFL_ASE_DSPR3)
15112 fputs ("\n\tDSP R3 ASE", stdout);
15113 if (mask & AFL_ASE_EVA)
15114 fputs ("\n\tEnhanced VA Scheme", stdout);
15115 if (mask & AFL_ASE_MCU)
15116 fputs ("\n\tMCU (MicroController) ASE", stdout);
15117 if (mask & AFL_ASE_MDMX)
15118 fputs ("\n\tMDMX ASE", stdout);
15119 if (mask & AFL_ASE_MIPS3D)
15120 fputs ("\n\tMIPS-3D ASE", stdout);
15121 if (mask & AFL_ASE_MT)
15122 fputs ("\n\tMT ASE", stdout);
15123 if (mask & AFL_ASE_SMARTMIPS)
15124 fputs ("\n\tSmartMIPS ASE", stdout);
15125 if (mask & AFL_ASE_VIRT)
15126 fputs ("\n\tVZ ASE", stdout);
15127 if (mask & AFL_ASE_MSA)
15128 fputs ("\n\tMSA ASE", stdout);
15129 if (mask & AFL_ASE_MIPS16)
15130 fputs ("\n\tMIPS16 ASE", stdout);
15131 if (mask & AFL_ASE_MICROMIPS)
15132 fputs ("\n\tMICROMIPS ASE", stdout);
15133 if (mask & AFL_ASE_XPA)
15134 fputs ("\n\tXPA ASE", stdout);
15135 if (mask & AFL_ASE_MIPS16E2)
15136 fputs ("\n\tMIPS16e2 ASE", stdout);
15137 if (mask == 0)
15138 fprintf (stdout, "\n\t%s", _("None"));
15139 else if ((mask & ~AFL_ASE_MASK) != 0)
15140 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
15141}
15142
15143static void
15144print_mips_isa_ext (unsigned int isa_ext)
15145{
15146 switch (isa_ext)
15147 {
15148 case 0:
15149 fputs (_("None"), stdout);
15150 break;
15151 case AFL_EXT_XLR:
15152 fputs ("RMI XLR", stdout);
15153 break;
15154 case AFL_EXT_OCTEON3:
15155 fputs ("Cavium Networks Octeon3", stdout);
15156 break;
15157 case AFL_EXT_OCTEON2:
15158 fputs ("Cavium Networks Octeon2", stdout);
15159 break;
15160 case AFL_EXT_OCTEONP:
15161 fputs ("Cavium Networks OcteonP", stdout);
15162 break;
15163 case AFL_EXT_LOONGSON_3A:
15164 fputs ("Loongson 3A", stdout);
15165 break;
15166 case AFL_EXT_OCTEON:
15167 fputs ("Cavium Networks Octeon", stdout);
15168 break;
15169 case AFL_EXT_5900:
15170 fputs ("Toshiba R5900", stdout);
15171 break;
15172 case AFL_EXT_4650:
15173 fputs ("MIPS R4650", stdout);
15174 break;
15175 case AFL_EXT_4010:
15176 fputs ("LSI R4010", stdout);
15177 break;
15178 case AFL_EXT_4100:
15179 fputs ("NEC VR4100", stdout);
15180 break;
15181 case AFL_EXT_3900:
15182 fputs ("Toshiba R3900", stdout);
15183 break;
15184 case AFL_EXT_10000:
15185 fputs ("MIPS R10000", stdout);
15186 break;
15187 case AFL_EXT_SB1:
15188 fputs ("Broadcom SB-1", stdout);
15189 break;
15190 case AFL_EXT_4111:
15191 fputs ("NEC VR4111/VR4181", stdout);
15192 break;
15193 case AFL_EXT_4120:
15194 fputs ("NEC VR4120", stdout);
15195 break;
15196 case AFL_EXT_5400:
15197 fputs ("NEC VR5400", stdout);
15198 break;
15199 case AFL_EXT_5500:
15200 fputs ("NEC VR5500", stdout);
15201 break;
15202 case AFL_EXT_LOONGSON_2E:
15203 fputs ("ST Microelectronics Loongson 2E", stdout);
15204 break;
15205 case AFL_EXT_LOONGSON_2F:
15206 fputs ("ST Microelectronics Loongson 2F", stdout);
15207 break;
15208 case AFL_EXT_INTERAPTIV_MR2:
15209 fputs ("Imagination interAptiv MR2", stdout);
15210 break;
15211 default:
15212 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
15213 }
15214}
15215
15216static signed int
15217get_mips_reg_size (int reg_size)
15218{
15219 return (reg_size == AFL_REG_NONE) ? 0
15220 : (reg_size == AFL_REG_32) ? 32
15221 : (reg_size == AFL_REG_64) ? 64
15222 : (reg_size == AFL_REG_128) ? 128
15223 : -1;
15224}
15225
15226static bfd_boolean
15227process_mips_specific (FILE * file)
15228{
15229 Elf_Internal_Dyn * entry;
15230 Elf_Internal_Shdr *sect = NULL;
15231 size_t liblist_offset = 0;
15232 size_t liblistno = 0;
15233 size_t conflictsno = 0;
15234 size_t options_offset = 0;
15235 size_t conflicts_offset = 0;
15236 size_t pltrelsz = 0;
15237 size_t pltrel = 0;
15238 bfd_vma pltgot = 0;
15239 bfd_vma mips_pltgot = 0;
15240 bfd_vma jmprel = 0;
15241 bfd_vma local_gotno = 0;
15242 bfd_vma gotsym = 0;
15243 bfd_vma symtabno = 0;
15244 bfd_boolean res = TRUE;
15245
15246 if (! process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
15247 display_mips_gnu_attribute))
15248 res = FALSE;
15249
15250 sect = find_section (".MIPS.abiflags");
15251
15252 if (sect != NULL)
15253 {
15254 Elf_External_ABIFlags_v0 *abiflags_ext;
15255 Elf_Internal_ABIFlags_v0 abiflags_in;
15256
15257 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
15258 {
15259 error (_("Corrupt MIPS ABI Flags section.\n"));
15260 res = FALSE;
15261 }
15262 else
15263 {
15264 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
15265 sect->sh_size, _("MIPS ABI Flags section"));
15266 if (abiflags_ext)
15267 {
15268 abiflags_in.version = BYTE_GET (abiflags_ext->version);
15269 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
15270 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
15271 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
15272 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
15273 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
15274 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
15275 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
15276 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
15277 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
15278 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
15279
15280 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
15281 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
15282 if (abiflags_in.isa_rev > 1)
15283 printf ("r%d", abiflags_in.isa_rev);
15284 printf ("\nGPR size: %d",
15285 get_mips_reg_size (abiflags_in.gpr_size));
15286 printf ("\nCPR1 size: %d",
15287 get_mips_reg_size (abiflags_in.cpr1_size));
15288 printf ("\nCPR2 size: %d",
15289 get_mips_reg_size (abiflags_in.cpr2_size));
15290 fputs ("\nFP ABI: ", stdout);
15291 print_mips_fp_abi_value (abiflags_in.fp_abi);
15292 fputs ("ISA Extension: ", stdout);
15293 print_mips_isa_ext (abiflags_in.isa_ext);
15294 fputs ("\nASEs:", stdout);
15295 print_mips_ases (abiflags_in.ases);
15296 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
15297 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
15298 fputc ('\n', stdout);
15299 free (abiflags_ext);
15300 }
15301 }
15302 }
15303
15304 /* We have a lot of special sections. Thanks SGI! */
15305 if (dynamic_section == NULL)
15306 {
15307 /* No dynamic information available. See if there is static GOT. */
15308 sect = find_section (".got");
15309 if (sect != NULL)
15310 {
15311 unsigned char *data_end;
15312 unsigned char *data;
15313 bfd_vma ent, end;
15314 int addr_size;
15315
15316 pltgot = sect->sh_addr;
15317
15318 ent = pltgot;
15319 addr_size = (is_32bit_elf ? 4 : 8);
15320 end = pltgot + sect->sh_size;
15321
15322 data = (unsigned char *) get_data (NULL, file, sect->sh_offset,
15323 end - pltgot, 1,
15324 _("Global Offset Table data"));
15325 /* PR 12855: Null data is handled gracefully throughout. */
15326 data_end = data + (end - pltgot);
15327
15328 printf (_("\nStatic GOT:\n"));
15329 printf (_(" Canonical gp value: "));
15330 print_vma (ent + 0x7ff0, LONG_HEX);
15331 printf ("\n\n");
15332
15333 /* In a dynamic binary GOT[0] is reserved for the dynamic
15334 loader to store the lazy resolver pointer, however in
15335 a static binary it may well have been omitted and GOT
15336 reduced to a table of addresses.
15337 PR 21344: Check for the entry being fully available
15338 before fetching it. */
15339 if (data
15340 && data + ent - pltgot + addr_size <= data_end
15341 && byte_get (data + ent - pltgot, addr_size) == 0)
15342 {
15343 printf (_(" Reserved entries:\n"));
15344 printf (_(" %*s %10s %*s\n"),
15345 addr_size * 2, _("Address"), _("Access"),
15346 addr_size * 2, _("Value"));
15347 ent = print_mips_got_entry (data, pltgot, ent, data_end);
15348 printf ("\n");
15349 if (ent == (bfd_vma) -1)
15350 goto sgot_print_fail;
15351
15352 /* Check for the MSB of GOT[1] being set, identifying a
15353 GNU object. This entry will be used by some runtime
15354 loaders, to store the module pointer. Otherwise this
15355 is an ordinary local entry.
15356 PR 21344: Check for the entry being fully available
15357 before fetching it. */
15358 if (data
15359 && data + ent - pltgot + addr_size <= data_end
15360 && (byte_get (data + ent - pltgot, addr_size)
15361 >> (addr_size * 8 - 1)) != 0)
15362 {
15363 ent = print_mips_got_entry (data, pltgot, ent, data_end);
15364 printf ("\n");
15365 if (ent == (bfd_vma) -1)
15366 goto sgot_print_fail;
15367 }
15368 printf ("\n");
15369 }
15370
15371 if (data != NULL && ent < end)
15372 {
15373 printf (_(" Local entries:\n"));
15374 printf (" %*s %10s %*s\n",
15375 addr_size * 2, _("Address"), _("Access"),
15376 addr_size * 2, _("Value"));
15377 while (ent < end)
15378 {
15379 ent = print_mips_got_entry (data, pltgot, ent, data_end);
15380 printf ("\n");
15381 if (ent == (bfd_vma) -1)
15382 goto sgot_print_fail;
15383 }
15384 printf ("\n");
15385 }
15386
15387 sgot_print_fail:
15388 if (data)
15389 free (data);
15390 }
15391 return res;
15392 }
15393
15394 for (entry = dynamic_section;
15395 /* PR 17531 file: 012-50589-0.004. */
15396 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
15397 ++entry)
15398 switch (entry->d_tag)
15399 {
15400 case DT_MIPS_LIBLIST:
15401 liblist_offset
15402 = offset_from_vma (file, entry->d_un.d_val,
15403 liblistno * sizeof (Elf32_External_Lib));
15404 break;
15405 case DT_MIPS_LIBLISTNO:
15406 liblistno = entry->d_un.d_val;
15407 break;
15408 case DT_MIPS_OPTIONS:
15409 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
15410 break;
15411 case DT_MIPS_CONFLICT:
15412 conflicts_offset
15413 = offset_from_vma (file, entry->d_un.d_val,
15414 conflictsno * sizeof (Elf32_External_Conflict));
15415 break;
15416 case DT_MIPS_CONFLICTNO:
15417 conflictsno = entry->d_un.d_val;
15418 break;
15419 case DT_PLTGOT:
15420 pltgot = entry->d_un.d_ptr;
15421 break;
15422 case DT_MIPS_LOCAL_GOTNO:
15423 local_gotno = entry->d_un.d_val;
15424 break;
15425 case DT_MIPS_GOTSYM:
15426 gotsym = entry->d_un.d_val;
15427 break;
15428 case DT_MIPS_SYMTABNO:
15429 symtabno = entry->d_un.d_val;
15430 break;
15431 case DT_MIPS_PLTGOT:
15432 mips_pltgot = entry->d_un.d_ptr;
15433 break;
15434 case DT_PLTREL:
15435 pltrel = entry->d_un.d_val;
15436 break;
15437 case DT_PLTRELSZ:
15438 pltrelsz = entry->d_un.d_val;
15439 break;
15440 case DT_JMPREL:
15441 jmprel = entry->d_un.d_ptr;
15442 break;
15443 default:
15444 break;
15445 }
15446
15447 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
15448 {
15449 Elf32_External_Lib * elib;
15450 size_t cnt;
15451
15452 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
15453 liblistno,
15454 sizeof (Elf32_External_Lib),
15455 _("liblist section data"));
15456 if (elib)
15457 {
15458 printf (_("\nSection '.liblist' contains %lu entries:\n"),
15459 (unsigned long) liblistno);
15460 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
15461 stdout);
15462
15463 for (cnt = 0; cnt < liblistno; ++cnt)
15464 {
15465 Elf32_Lib liblist;
15466 time_t atime;
15467 char timebuf[128];
15468 struct tm * tmp;
15469
15470 liblist.l_name = BYTE_GET (elib[cnt].l_name);
15471 atime = BYTE_GET (elib[cnt].l_time_stamp);
15472 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15473 liblist.l_version = BYTE_GET (elib[cnt].l_version);
15474 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15475
15476 tmp = gmtime (&atime);
15477 snprintf (timebuf, sizeof (timebuf),
15478 "%04u-%02u-%02uT%02u:%02u:%02u",
15479 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15480 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
15481
15482 printf ("%3lu: ", (unsigned long) cnt);
15483 if (VALID_DYNAMIC_NAME (liblist.l_name))
15484 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
15485 else
15486 printf (_("<corrupt: %9ld>"), liblist.l_name);
15487 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
15488 liblist.l_version);
15489
15490 if (liblist.l_flags == 0)
15491 puts (_(" NONE"));
15492 else
15493 {
15494 static const struct
15495 {
15496 const char * name;
15497 int bit;
15498 }
15499 l_flags_vals[] =
15500 {
15501 { " EXACT_MATCH", LL_EXACT_MATCH },
15502 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
15503 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
15504 { " EXPORTS", LL_EXPORTS },
15505 { " DELAY_LOAD", LL_DELAY_LOAD },
15506 { " DELTA", LL_DELTA }
15507 };
15508 int flags = liblist.l_flags;
15509 size_t fcnt;
15510
15511 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
15512 if ((flags & l_flags_vals[fcnt].bit) != 0)
15513 {
15514 fputs (l_flags_vals[fcnt].name, stdout);
15515 flags ^= l_flags_vals[fcnt].bit;
15516 }
15517 if (flags != 0)
15518 printf (" %#x", (unsigned int) flags);
15519
15520 puts ("");
15521 }
15522 }
15523
15524 free (elib);
15525 }
15526 else
15527 res = FALSE;
15528 }
15529
15530 if (options_offset != 0)
15531 {
15532 Elf_External_Options * eopt;
15533 Elf_Internal_Options * iopt;
15534 Elf_Internal_Options * option;
15535 size_t offset;
15536 int cnt;
15537 sect = section_headers;
15538
15539 /* Find the section header so that we get the size. */
15540 sect = find_section_by_type (SHT_MIPS_OPTIONS);
15541 /* PR 17533 file: 012-277276-0.004. */
15542 if (sect == NULL)
15543 {
15544 error (_("No MIPS_OPTIONS header found\n"));
15545 return FALSE;
15546 }
15547
15548 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
15549 sect->sh_size, _("options"));
15550 if (eopt)
15551 {
15552 iopt = (Elf_Internal_Options *)
15553 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
15554 if (iopt == NULL)
15555 {
15556 error (_("Out of memory allocating space for MIPS options\n"));
15557 return FALSE;
15558 }
15559
15560 offset = cnt = 0;
15561 option = iopt;
15562
15563 while (offset <= sect->sh_size - sizeof (* eopt))
15564 {
15565 Elf_External_Options * eoption;
15566
15567 eoption = (Elf_External_Options *) ((char *) eopt + offset);
15568
15569 option->kind = BYTE_GET (eoption->kind);
15570 option->size = BYTE_GET (eoption->size);
15571 option->section = BYTE_GET (eoption->section);
15572 option->info = BYTE_GET (eoption->info);
15573
15574 /* PR 17531: file: ffa0fa3b. */
15575 if (option->size < sizeof (* eopt)
15576 || offset + option->size > sect->sh_size)
15577 {
15578 error (_("Invalid size (%u) for MIPS option\n"), option->size);
15579 return FALSE;
15580 }
15581 offset += option->size;
15582
15583 ++option;
15584 ++cnt;
15585 }
15586
15587 printf (_("\nSection '%s' contains %d entries:\n"),
15588 printable_section_name (sect), cnt);
15589
15590 option = iopt;
15591 offset = 0;
15592
15593 while (cnt-- > 0)
15594 {
15595 size_t len;
15596
15597 switch (option->kind)
15598 {
15599 case ODK_NULL:
15600 /* This shouldn't happen. */
15601 printf (" NULL %d %lx", option->section, option->info);
15602 break;
15603 case ODK_REGINFO:
15604 printf (" REGINFO ");
15605 if (elf_header.e_machine == EM_MIPS)
15606 {
15607 /* 32bit form. */
15608 Elf32_External_RegInfo * ereg;
15609 Elf32_RegInfo reginfo;
15610
15611 ereg = (Elf32_External_RegInfo *) (option + 1);
15612 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
15613 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15614 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15615 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15616 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15617 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
15618
15619 printf ("GPR %08lx GP 0x%lx\n",
15620 reginfo.ri_gprmask,
15621 (unsigned long) reginfo.ri_gp_value);
15622 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15623 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15624 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15625 }
15626 else
15627 {
15628 /* 64 bit form. */
15629 Elf64_External_RegInfo * ereg;
15630 Elf64_Internal_RegInfo reginfo;
15631
15632 ereg = (Elf64_External_RegInfo *) (option + 1);
15633 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
15634 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15635 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15636 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15637 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15638 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
15639
15640 printf ("GPR %08lx GP 0x",
15641 reginfo.ri_gprmask);
15642 printf_vma (reginfo.ri_gp_value);
15643 printf ("\n");
15644
15645 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15646 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15647 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15648 }
15649 ++option;
15650 continue;
15651 case ODK_EXCEPTIONS:
15652 fputs (" EXCEPTIONS fpe_min(", stdout);
15653 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
15654 fputs (") fpe_max(", stdout);
15655 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
15656 fputs (")", stdout);
15657
15658 if (option->info & OEX_PAGE0)
15659 fputs (" PAGE0", stdout);
15660 if (option->info & OEX_SMM)
15661 fputs (" SMM", stdout);
15662 if (option->info & OEX_FPDBUG)
15663 fputs (" FPDBUG", stdout);
15664 if (option->info & OEX_DISMISS)
15665 fputs (" DISMISS", stdout);
15666 break;
15667 case ODK_PAD:
15668 fputs (" PAD ", stdout);
15669 if (option->info & OPAD_PREFIX)
15670 fputs (" PREFIX", stdout);
15671 if (option->info & OPAD_POSTFIX)
15672 fputs (" POSTFIX", stdout);
15673 if (option->info & OPAD_SYMBOL)
15674 fputs (" SYMBOL", stdout);
15675 break;
15676 case ODK_HWPATCH:
15677 fputs (" HWPATCH ", stdout);
15678 if (option->info & OHW_R4KEOP)
15679 fputs (" R4KEOP", stdout);
15680 if (option->info & OHW_R8KPFETCH)
15681 fputs (" R8KPFETCH", stdout);
15682 if (option->info & OHW_R5KEOP)
15683 fputs (" R5KEOP", stdout);
15684 if (option->info & OHW_R5KCVTL)
15685 fputs (" R5KCVTL", stdout);
15686 break;
15687 case ODK_FILL:
15688 fputs (" FILL ", stdout);
15689 /* XXX Print content of info word? */
15690 break;
15691 case ODK_TAGS:
15692 fputs (" TAGS ", stdout);
15693 /* XXX Print content of info word? */
15694 break;
15695 case ODK_HWAND:
15696 fputs (" HWAND ", stdout);
15697 if (option->info & OHWA0_R4KEOP_CHECKED)
15698 fputs (" R4KEOP_CHECKED", stdout);
15699 if (option->info & OHWA0_R4KEOP_CLEAN)
15700 fputs (" R4KEOP_CLEAN", stdout);
15701 break;
15702 case ODK_HWOR:
15703 fputs (" HWOR ", stdout);
15704 if (option->info & OHWA0_R4KEOP_CHECKED)
15705 fputs (" R4KEOP_CHECKED", stdout);
15706 if (option->info & OHWA0_R4KEOP_CLEAN)
15707 fputs (" R4KEOP_CLEAN", stdout);
15708 break;
15709 case ODK_GP_GROUP:
15710 printf (" GP_GROUP %#06lx self-contained %#06lx",
15711 option->info & OGP_GROUP,
15712 (option->info & OGP_SELF) >> 16);
15713 break;
15714 case ODK_IDENT:
15715 printf (" IDENT %#06lx self-contained %#06lx",
15716 option->info & OGP_GROUP,
15717 (option->info & OGP_SELF) >> 16);
15718 break;
15719 default:
15720 /* This shouldn't happen. */
15721 printf (" %3d ??? %d %lx",
15722 option->kind, option->section, option->info);
15723 break;
15724 }
15725
15726 len = sizeof (* eopt);
15727 while (len < option->size)
15728 {
15729 unsigned char datum = * ((unsigned char *) eopt + offset + len);
15730
15731 if (ISPRINT (datum))
15732 printf ("%c", datum);
15733 else
15734 printf ("\\%03o", datum);
15735 len ++;
15736 }
15737 fputs ("\n", stdout);
15738
15739 offset += option->size;
15740 ++option;
15741 }
15742
15743 free (eopt);
15744 }
15745 else
15746 res = FALSE;
15747 }
15748
15749 if (conflicts_offset != 0 && conflictsno != 0)
15750 {
15751 Elf32_Conflict * iconf;
15752 size_t cnt;
15753
15754 if (dynamic_symbols == NULL)
15755 {
15756 error (_("conflict list found without a dynamic symbol table\n"));
15757 return FALSE;
15758 }
15759
15760 /* PR 21345 - print a slightly more helpful error message
15761 if we are sure that the cmalloc will fail. */
15762 if (conflictsno * sizeof (* iconf) > current_file_size)
15763 {
15764 error (_("Overlarge number of conflicts detected: %lx\n"),
15765 (long) conflictsno);
15766 return FALSE;
15767 }
15768
15769 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
15770 if (iconf == NULL)
15771 {
15772 error (_("Out of memory allocating space for dynamic conflicts\n"));
15773 return FALSE;
15774 }
15775
15776 if (is_32bit_elf)
15777 {
15778 Elf32_External_Conflict * econf32;
15779
15780 econf32 = (Elf32_External_Conflict *)
15781 get_data (NULL, file, conflicts_offset, conflictsno,
15782 sizeof (* econf32), _("conflict"));
15783 if (!econf32)
15784 return FALSE;
15785
15786 for (cnt = 0; cnt < conflictsno; ++cnt)
15787 iconf[cnt] = BYTE_GET (econf32[cnt]);
15788
15789 free (econf32);
15790 }
15791 else
15792 {
15793 Elf64_External_Conflict * econf64;
15794
15795 econf64 = (Elf64_External_Conflict *)
15796 get_data (NULL, file, conflicts_offset, conflictsno,
15797 sizeof (* econf64), _("conflict"));
15798 if (!econf64)
15799 return FALSE;
15800
15801 for (cnt = 0; cnt < conflictsno; ++cnt)
15802 iconf[cnt] = BYTE_GET (econf64[cnt]);
15803
15804 free (econf64);
15805 }
15806
15807 printf (_("\nSection '.conflict' contains %lu entries:\n"),
15808 (unsigned long) conflictsno);
15809 puts (_(" Num: Index Value Name"));
15810
15811 for (cnt = 0; cnt < conflictsno; ++cnt)
15812 {
15813 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
15814
15815 if (iconf[cnt] >= num_dynamic_syms)
15816 printf (_("<corrupt symbol index>"));
15817 else
15818 {
15819 Elf_Internal_Sym * psym;
15820
15821 psym = & dynamic_symbols[iconf[cnt]];
15822 print_vma (psym->st_value, FULL_HEX);
15823 putchar (' ');
15824 if (VALID_DYNAMIC_NAME (psym->st_name))
15825 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
15826 else
15827 printf (_("<corrupt: %14ld>"), psym->st_name);
15828 }
15829 putchar ('\n');
15830 }
15831
15832 free (iconf);
15833 }
15834
15835 if (pltgot != 0 && local_gotno != 0)
15836 {
15837 bfd_vma ent, local_end, global_end;
15838 size_t i, offset;
15839 unsigned char * data;
15840 unsigned char * data_end;
15841 int addr_size;
15842
15843 ent = pltgot;
15844 addr_size = (is_32bit_elf ? 4 : 8);
15845 local_end = pltgot + local_gotno * addr_size;
15846
15847 /* PR binutils/17533 file: 012-111227-0.004 */
15848 if (symtabno < gotsym)
15849 {
15850 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
15851 (unsigned long) gotsym, (unsigned long) symtabno);
15852 return FALSE;
15853 }
15854
15855 global_end = local_end + (symtabno - gotsym) * addr_size;
15856 /* PR 17531: file: 54c91a34. */
15857 if (global_end < local_end)
15858 {
15859 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
15860 return FALSE;
15861 }
15862
15863 offset = offset_from_vma (file, pltgot, global_end - pltgot);
15864 data = (unsigned char *) get_data (NULL, file, offset,
15865 global_end - pltgot, 1,
15866 _("Global Offset Table data"));
15867 /* PR 12855: Null data is handled gracefully throughout. */
15868 data_end = data + (global_end - pltgot);
15869
15870 printf (_("\nPrimary GOT:\n"));
15871 printf (_(" Canonical gp value: "));
15872 print_vma (pltgot + 0x7ff0, LONG_HEX);
15873 printf ("\n\n");
15874
15875 printf (_(" Reserved entries:\n"));
15876 printf (_(" %*s %10s %*s Purpose\n"),
15877 addr_size * 2, _("Address"), _("Access"),
15878 addr_size * 2, _("Initial"));
15879 ent = print_mips_got_entry (data, pltgot, ent, data_end);
15880 printf (_(" Lazy resolver\n"));
15881 if (ent == (bfd_vma) -1)
15882 goto got_print_fail;
15883
15884 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
15885 This entry will be used by some runtime loaders, to store the
15886 module pointer. Otherwise this is an ordinary local entry.
15887 PR 21344: Check for the entry being fully available before
15888 fetching it. */
15889 if (data
15890 && data + ent - pltgot + addr_size <= data_end
15891 && (byte_get (data + ent - pltgot, addr_size)
15892 >> (addr_size * 8 - 1)) != 0)
15893 {
15894 ent = print_mips_got_entry (data, pltgot, ent, data_end);
15895 printf (_(" Module pointer (GNU extension)\n"));
15896 if (ent == (bfd_vma) -1)
15897 goto got_print_fail;
15898 }
15899 printf ("\n");
15900
15901 if (data != NULL && ent < local_end)
15902 {
15903 printf (_(" Local entries:\n"));
15904 printf (" %*s %10s %*s\n",
15905 addr_size * 2, _("Address"), _("Access"),
15906 addr_size * 2, _("Initial"));
15907 while (ent < local_end)
15908 {
15909 ent = print_mips_got_entry (data, pltgot, ent, data_end);
15910 printf ("\n");
15911 if (ent == (bfd_vma) -1)
15912 goto got_print_fail;
15913 }
15914 printf ("\n");
15915 }
15916
15917 if (data != NULL && gotsym < symtabno)
15918 {
15919 int sym_width;
15920
15921 printf (_(" Global entries:\n"));
15922 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
15923 addr_size * 2, _("Address"),
15924 _("Access"),
15925 addr_size * 2, _("Initial"),
15926 addr_size * 2, _("Sym.Val."),
15927 _("Type"),
15928 /* Note for translators: "Ndx" = abbreviated form of "Index". */
15929 _("Ndx"), _("Name"));
15930
15931 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
15932
15933 for (i = gotsym; i < symtabno; i++)
15934 {
15935 ent = print_mips_got_entry (data, pltgot, ent, data_end);
15936 printf (" ");
15937
15938 if (dynamic_symbols == NULL)
15939 printf (_("<no dynamic symbols>"));
15940 else if (i < num_dynamic_syms)
15941 {
15942 Elf_Internal_Sym * psym = dynamic_symbols + i;
15943
15944 print_vma (psym->st_value, LONG_HEX);
15945 printf (" %-7s %3s ",
15946 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
15947 get_symbol_index_type (psym->st_shndx));
15948
15949 if (VALID_DYNAMIC_NAME (psym->st_name))
15950 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
15951 else
15952 printf (_("<corrupt: %14ld>"), psym->st_name);
15953 }
15954 else
15955 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15956 (unsigned long) i);
15957
15958 printf ("\n");
15959 if (ent == (bfd_vma) -1)
15960 break;
15961 }
15962 printf ("\n");
15963 }
15964
15965 got_print_fail:
15966 if (data)
15967 free (data);
15968 }
15969
15970 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
15971 {
15972 bfd_vma ent, end;
15973 size_t offset, rel_offset;
15974 unsigned long count, i;
15975 unsigned char * data;
15976 int addr_size, sym_width;
15977 Elf_Internal_Rela * rels;
15978
15979 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
15980 if (pltrel == DT_RELA)
15981 {
15982 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
15983 return FALSE;
15984 }
15985 else
15986 {
15987 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
15988 return FALSE;
15989 }
15990
15991 ent = mips_pltgot;
15992 addr_size = (is_32bit_elf ? 4 : 8);
15993 end = mips_pltgot + (2 + count) * addr_size;
15994
15995 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
15996 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
15997 1, _("Procedure Linkage Table data"));
15998 if (data == NULL)
15999 return FALSE;
16000
16001 printf ("\nPLT GOT:\n\n");
16002 printf (_(" Reserved entries:\n"));
16003 printf (_(" %*s %*s Purpose\n"),
16004 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
16005 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16006 printf (_(" PLT lazy resolver\n"));
16007 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16008 printf (_(" Module pointer\n"));
16009 printf ("\n");
16010
16011 printf (_(" Entries:\n"));
16012 printf (" %*s %*s %*s %-7s %3s %s\n",
16013 addr_size * 2, _("Address"),
16014 addr_size * 2, _("Initial"),
16015 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16016 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
16017 for (i = 0; i < count; i++)
16018 {
16019 unsigned long idx = get_reloc_symindex (rels[i].r_info);
16020
16021 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16022 printf (" ");
16023
16024 if (idx >= num_dynamic_syms)
16025 printf (_("<corrupt symbol index: %lu>"), idx);
16026 else
16027 {
16028 Elf_Internal_Sym * psym = dynamic_symbols + idx;
16029
16030 print_vma (psym->st_value, LONG_HEX);
16031 printf (" %-7s %3s ",
16032 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
16033 get_symbol_index_type (psym->st_shndx));
16034 if (VALID_DYNAMIC_NAME (psym->st_name))
16035 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16036 else
16037 printf (_("<corrupt: %14ld>"), psym->st_name);
16038 }
16039 printf ("\n");
16040 }
16041 printf ("\n");
16042
16043 if (data)
16044 free (data);
16045 free (rels);
16046 }
16047
16048 return res;
16049}
16050
16051static bfd_boolean
16052process_nds32_specific (FILE * file)
16053{
16054 Elf_Internal_Shdr *sect = NULL;
16055
16056 sect = find_section (".nds32_e_flags");
16057 if (sect != NULL)
16058 {
16059 unsigned int *flag;
16060
16061 printf ("\nNDS32 elf flags section:\n");
16062 flag = get_data (NULL, file, sect->sh_offset, 1,
16063 sect->sh_size, _("NDS32 elf flags section"));
16064
16065 if (! flag)
16066 return FALSE;
16067
16068 switch ((*flag) & 0x3)
16069 {
16070 case 0:
16071 printf ("(VEC_SIZE):\tNo entry.\n");
16072 break;
16073 case 1:
16074 printf ("(VEC_SIZE):\t4 bytes\n");
16075 break;
16076 case 2:
16077 printf ("(VEC_SIZE):\t16 bytes\n");
16078 break;
16079 case 3:
16080 printf ("(VEC_SIZE):\treserved\n");
16081 break;
16082 }
16083 }
16084
16085 return TRUE;
16086}
16087
16088static bfd_boolean
16089process_gnu_liblist (FILE * file)
16090{
16091 Elf_Internal_Shdr * section;
16092 Elf_Internal_Shdr * string_sec;
16093 Elf32_External_Lib * elib;
16094 char * strtab;
16095 size_t strtab_size;
16096 size_t cnt;
16097 unsigned i;
16098 bfd_boolean res = TRUE;
16099
16100 if (! do_arch)
16101 return TRUE;
16102
16103 for (i = 0, section = section_headers;
16104 i < elf_header.e_shnum;
16105 i++, section++)
16106 {
16107 switch (section->sh_type)
16108 {
16109 case SHT_GNU_LIBLIST:
16110 if (section->sh_link >= elf_header.e_shnum)
16111 break;
16112
16113 elib = (Elf32_External_Lib *)
16114 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
16115 _("liblist section data"));
16116
16117 if (elib == NULL)
16118 {
16119 res = FALSE;
16120 break;
16121 }
16122
16123 string_sec = section_headers + section->sh_link;
16124 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
16125 string_sec->sh_size,
16126 _("liblist string table"));
16127 if (strtab == NULL
16128 || section->sh_entsize != sizeof (Elf32_External_Lib))
16129 {
16130 free (elib);
16131 free (strtab);
16132 res = FALSE;
16133 break;
16134 }
16135 strtab_size = string_sec->sh_size;
16136
16137 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
16138 printable_section_name (section),
16139 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
16140
16141 puts (_(" Library Time Stamp Checksum Version Flags"));
16142
16143 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
16144 ++cnt)
16145 {
16146 Elf32_Lib liblist;
16147 time_t atime;
16148 char timebuf[128];
16149 struct tm * tmp;
16150
16151 liblist.l_name = BYTE_GET (elib[cnt].l_name);
16152 atime = BYTE_GET (elib[cnt].l_time_stamp);
16153 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16154 liblist.l_version = BYTE_GET (elib[cnt].l_version);
16155 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16156
16157 tmp = gmtime (&atime);
16158 snprintf (timebuf, sizeof (timebuf),
16159 "%04u-%02u-%02uT%02u:%02u:%02u",
16160 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16161 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16162
16163 printf ("%3lu: ", (unsigned long) cnt);
16164 if (do_wide)
16165 printf ("%-20s", liblist.l_name < strtab_size
16166 ? strtab + liblist.l_name : _("<corrupt>"));
16167 else
16168 printf ("%-20.20s", liblist.l_name < strtab_size
16169 ? strtab + liblist.l_name : _("<corrupt>"));
16170 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
16171 liblist.l_version, liblist.l_flags);
16172 }
16173
16174 free (elib);
16175 free (strtab);
16176 }
16177 }
16178
16179 return res;
16180}
16181
16182static const char *
16183get_note_type (unsigned e_type)
16184{
16185 static char buff[64];
16186
16187 if (elf_header.e_type == ET_CORE)
16188 switch (e_type)
16189 {
16190 case NT_AUXV:
16191 return _("NT_AUXV (auxiliary vector)");
16192 case NT_PRSTATUS:
16193 return _("NT_PRSTATUS (prstatus structure)");
16194 case NT_FPREGSET:
16195 return _("NT_FPREGSET (floating point registers)");
16196 case NT_PRPSINFO:
16197 return _("NT_PRPSINFO (prpsinfo structure)");
16198 case NT_TASKSTRUCT:
16199 return _("NT_TASKSTRUCT (task structure)");
16200 case NT_PRXFPREG:
16201 return _("NT_PRXFPREG (user_xfpregs structure)");
16202 case NT_PPC_VMX:
16203 return _("NT_PPC_VMX (ppc Altivec registers)");
16204 case NT_PPC_VSX:
16205 return _("NT_PPC_VSX (ppc VSX registers)");
16206 case NT_PPC_TAR:
16207 return _("NT_PPC_TAR (ppc TAR register)");
16208 case NT_PPC_PPR:
16209 return _("NT_PPC_PPR (ppc PPR register)");
16210 case NT_PPC_DSCR:
16211 return _("NT_PPC_DSCR (ppc DSCR register)");
16212 case NT_PPC_EBB:
16213 return _("NT_PPC_EBB (ppc EBB registers)");
16214 case NT_PPC_PMU:
16215 return _("NT_PPC_PMU (ppc PMU registers)");
16216 case NT_PPC_TM_CGPR:
16217 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16218 case NT_PPC_TM_CFPR:
16219 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16220 case NT_PPC_TM_CVMX:
16221 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16222 case NT_PPC_TM_CVSX:
16223 return _("NT_PPC_TM_VSX (ppc checkpointed VSX registers)");
16224 case NT_PPC_TM_SPR:
16225 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16226 case NT_PPC_TM_CTAR:
16227 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16228 case NT_PPC_TM_CPPR:
16229 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16230 case NT_PPC_TM_CDSCR:
16231 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16232 case NT_386_TLS:
16233 return _("NT_386_TLS (x86 TLS information)");
16234 case NT_386_IOPERM:
16235 return _("NT_386_IOPERM (x86 I/O permissions)");
16236 case NT_X86_XSTATE:
16237 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16238 case NT_S390_HIGH_GPRS:
16239 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16240 case NT_S390_TIMER:
16241 return _("NT_S390_TIMER (s390 timer register)");
16242 case NT_S390_TODCMP:
16243 return _("NT_S390_TODCMP (s390 TOD comparator register)");
16244 case NT_S390_TODPREG:
16245 return _("NT_S390_TODPREG (s390 TOD programmable register)");
16246 case NT_S390_CTRS:
16247 return _("NT_S390_CTRS (s390 control registers)");
16248 case NT_S390_PREFIX:
16249 return _("NT_S390_PREFIX (s390 prefix register)");
16250 case NT_S390_LAST_BREAK:
16251 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16252 case NT_S390_SYSTEM_CALL:
16253 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16254 case NT_S390_TDB:
16255 return _("NT_S390_TDB (s390 transaction diagnostic block)");
16256 case NT_S390_VXRS_LOW:
16257 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16258 case NT_S390_VXRS_HIGH:
16259 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16260 case NT_S390_GS_CB:
16261 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16262 case NT_S390_GS_BC:
16263 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16264 case NT_ARM_VFP:
16265 return _("NT_ARM_VFP (arm VFP registers)");
16266 case NT_ARM_TLS:
16267 return _("NT_ARM_TLS (AArch TLS registers)");
16268 case NT_ARM_HW_BREAK:
16269 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16270 case NT_ARM_HW_WATCH:
16271 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16272 case NT_PSTATUS:
16273 return _("NT_PSTATUS (pstatus structure)");
16274 case NT_FPREGS:
16275 return _("NT_FPREGS (floating point registers)");
16276 case NT_PSINFO:
16277 return _("NT_PSINFO (psinfo structure)");
16278 case NT_LWPSTATUS:
16279 return _("NT_LWPSTATUS (lwpstatus_t structure)");
16280 case NT_LWPSINFO:
16281 return _("NT_LWPSINFO (lwpsinfo_t structure)");
16282 case NT_WIN32PSTATUS:
16283 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16284 case NT_SIGINFO:
16285 return _("NT_SIGINFO (siginfo_t data)");
16286 case NT_FILE:
16287 return _("NT_FILE (mapped files)");
16288 default:
16289 break;
16290 }
16291 else
16292 switch (e_type)
16293 {
16294 case NT_VERSION:
16295 return _("NT_VERSION (version)");
16296 case NT_ARCH:
16297 return _("NT_ARCH (architecture)");
16298 case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16299 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16300 case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16301 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16302 default:
16303 break;
16304 }
16305
16306 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16307 return buff;
16308}
16309
16310static bfd_boolean
16311print_core_note (Elf_Internal_Note *pnote)
16312{
16313 unsigned int addr_size = is_32bit_elf ? 4 : 8;
16314 bfd_vma count, page_size;
16315 unsigned char *descdata, *filenames, *descend;
16316
16317 if (pnote->type != NT_FILE)
16318 {
16319 if (do_wide)
16320 printf ("\n");
16321 return TRUE;
16322 }
16323
16324#ifndef BFD64
16325 if (!is_32bit_elf)
16326 {
16327 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
16328 /* Still "successful". */
16329 return TRUE;
16330 }
16331#endif
16332
16333 if (pnote->descsz < 2 * addr_size)
16334 {
16335 error (_(" Malformed note - too short for header\n"));
16336 return FALSE;
16337 }
16338
16339 descdata = (unsigned char *) pnote->descdata;
16340 descend = descdata + pnote->descsz;
16341
16342 if (descdata[pnote->descsz - 1] != '\0')
16343 {
16344 error (_(" Malformed note - does not end with \\0\n"));
16345 return FALSE;
16346 }
16347
16348 count = byte_get (descdata, addr_size);
16349 descdata += addr_size;
16350
16351 page_size = byte_get (descdata, addr_size);
16352 descdata += addr_size;
16353
16354 if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
16355 || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
16356 {
16357 error (_(" Malformed note - too short for supplied file count\n"));
16358 return FALSE;
16359 }
16360
16361 printf (_(" Page size: "));
16362 print_vma (page_size, DEC);
16363 printf ("\n");
16364
16365 printf (_(" %*s%*s%*s\n"),
16366 (int) (2 + 2 * addr_size), _("Start"),
16367 (int) (4 + 2 * addr_size), _("End"),
16368 (int) (4 + 2 * addr_size), _("Page Offset"));
16369 filenames = descdata + count * 3 * addr_size;
16370 while (count-- > 0)
16371 {
16372 bfd_vma start, end, file_ofs;
16373
16374 if (filenames == descend)
16375 {
16376 error (_(" Malformed note - filenames end too early\n"));
16377 return FALSE;
16378 }
16379
16380 start = byte_get (descdata, addr_size);
16381 descdata += addr_size;
16382 end = byte_get (descdata, addr_size);
16383 descdata += addr_size;
16384 file_ofs = byte_get (descdata, addr_size);
16385 descdata += addr_size;
16386
16387 printf (" ");
16388 print_vma (start, FULL_HEX);
16389 printf (" ");
16390 print_vma (end, FULL_HEX);
16391 printf (" ");
16392 print_vma (file_ofs, FULL_HEX);
16393 printf ("\n %s\n", filenames);
16394
16395 filenames += 1 + strlen ((char *) filenames);
16396 }
16397
16398 return TRUE;
16399}
16400
16401static const char *
16402get_gnu_elf_note_type (unsigned e_type)
16403{
16404 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
16405 switch (e_type)
16406 {
16407 case NT_GNU_ABI_TAG:
16408 return _("NT_GNU_ABI_TAG (ABI version tag)");
16409 case NT_GNU_HWCAP:
16410 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16411 case NT_GNU_BUILD_ID:
16412 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16413 case NT_GNU_GOLD_VERSION:
16414 return _("NT_GNU_GOLD_VERSION (gold version)");
16415 case NT_GNU_PROPERTY_TYPE_0:
16416 return _("NT_GNU_PROPERTY_TYPE_0");
16417 case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16418 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16419 case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16420 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16421 default:
16422 {
16423 static char buff[64];
16424
16425 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16426 return buff;
16427 }
16428 }
16429}
16430
16431static void
16432decode_x86_isa (unsigned int bitmask)
16433{
16434 while (bitmask)
16435 {
16436 unsigned int bit = bitmask & (- bitmask);
16437
16438 bitmask &= ~ bit;
16439 switch (bit)
16440 {
16441 case GNU_PROPERTY_X86_ISA_1_486: printf ("i486"); break;
16442 case GNU_PROPERTY_X86_ISA_1_586: printf ("586"); break;
16443 case GNU_PROPERTY_X86_ISA_1_686: printf ("686"); break;
16444 case GNU_PROPERTY_X86_ISA_1_SSE: printf ("SSE"); break;
16445 case GNU_PROPERTY_X86_ISA_1_SSE2: printf ("SSE2"); break;
16446 case GNU_PROPERTY_X86_ISA_1_SSE3: printf ("SSE3"); break;
16447 case GNU_PROPERTY_X86_ISA_1_SSSE3: printf ("SSSE3"); break;
16448 case GNU_PROPERTY_X86_ISA_1_SSE4_1: printf ("SSE4_1"); break;
16449 case GNU_PROPERTY_X86_ISA_1_SSE4_2: printf ("SSE4_2"); break;
16450 case GNU_PROPERTY_X86_ISA_1_AVX: printf ("AVX"); break;
16451 case GNU_PROPERTY_X86_ISA_1_AVX2: printf ("AVX2"); break;
16452 case GNU_PROPERTY_X86_ISA_1_AVX512F: printf ("AVX512F"); break;
16453 case GNU_PROPERTY_X86_ISA_1_AVX512CD: printf ("AVX512CD"); break;
16454 case GNU_PROPERTY_X86_ISA_1_AVX512ER: printf ("AVX512ER"); break;
16455 case GNU_PROPERTY_X86_ISA_1_AVX512PF: printf ("AVX512PF"); break;
16456 case GNU_PROPERTY_X86_ISA_1_AVX512VL: printf ("AVX512VL"); break;
16457 case GNU_PROPERTY_X86_ISA_1_AVX512DQ: printf ("AVX512DQ"); break;
16458 case GNU_PROPERTY_X86_ISA_1_AVX512BW: printf ("AVX512BW"); break;
16459 default: printf (_("<unknown: %x>"), bit); break;
16460 }
16461 if (bitmask)
16462 printf (", ");
16463 }
16464}
16465
16466static void
16467decode_x86_feature (unsigned int type, unsigned int bitmask)
16468{
16469 while (bitmask)
16470 {
16471 unsigned int bit = bitmask & (- bitmask);
16472
16473 bitmask &= ~ bit;
16474 switch (bit)
16475 {
16476 case GNU_PROPERTY_X86_FEATURE_1_IBT:
16477 switch (type)
16478 {
16479 case GNU_PROPERTY_X86_FEATURE_1_AND:
16480 printf ("IBT");
16481 break;
16482 default:
16483 /* This should never happen. */
16484 abort ();
16485 }
16486 break;
16487 case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
16488 switch (type)
16489 {
16490 case GNU_PROPERTY_X86_FEATURE_1_AND:
16491 printf ("SHSTK");
16492 break;
16493 default:
16494 /* This should never happen. */
16495 abort ();
16496 }
16497 break;
16498 default:
16499 printf (_("<unknown: %x>"), bit);
16500 break;
16501 }
16502 if (bitmask)
16503 printf (", ");
16504 }
16505}
16506
16507static void
16508print_gnu_property_note (Elf_Internal_Note * pnote)
16509{
16510 unsigned char * ptr = (unsigned char *) pnote->descdata;
16511 unsigned char * ptr_end = ptr + pnote->descsz;
16512 unsigned int size = is_32bit_elf ? 4 : 8;
16513
16514 printf (_(" Properties: "));
16515
16516 if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
16517 {
16518 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
16519 return;
16520 }
16521
16522 while (1)
16523 {
16524 unsigned int j;
16525 unsigned int type = byte_get (ptr, 4);
16526 unsigned int datasz = byte_get (ptr + 4, 4);
16527
16528 ptr += 8;
16529
16530 if ((ptr + datasz) > ptr_end)
16531 {
16532 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16533 type, datasz);
16534 break;
16535 }
16536
16537 if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
16538 {
16539 if (elf_header.e_machine == EM_X86_64
16540 || elf_header.e_machine == EM_IAMCU
16541 || elf_header.e_machine == EM_386)
16542 {
16543 switch (type)
16544 {
16545 case GNU_PROPERTY_X86_ISA_1_USED:
16546 printf ("x86 ISA used: ");
16547 if (datasz != 4)
16548 printf (_("<corrupt length: %#x> "), datasz);
16549 else
16550 decode_x86_isa (byte_get (ptr, 4));
16551 goto next;
16552
16553 case GNU_PROPERTY_X86_ISA_1_NEEDED:
16554 printf ("x86 ISA needed: ");
16555 if (datasz != 4)
16556 printf (_("<corrupt length: %#x> "), datasz);
16557 else
16558 decode_x86_isa (byte_get (ptr, 4));
16559 goto next;
16560
16561 case GNU_PROPERTY_X86_FEATURE_1_AND:
16562 printf ("x86 feature: ");
16563 if (datasz != 4)
16564 printf (_("<corrupt length: %#x> "), datasz);
16565 else
16566 decode_x86_feature (type, byte_get (ptr, 4));
16567 goto next;
16568
16569 default:
16570 break;
16571 }
16572 }
16573 }
16574 else
16575 {
16576 switch (type)
16577 {
16578 case GNU_PROPERTY_STACK_SIZE:
16579 printf (_("stack size: "));
16580 if (datasz != size)
16581 printf (_("<corrupt length: %#x> "), datasz);
16582 else
16583 printf ("%#lx", (unsigned long) byte_get (ptr, size));
16584 goto next;
16585
16586 case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
16587 printf ("no copy on protected ");
16588 if (datasz)
16589 printf (_("<corrupt length: %#x> "), datasz);
16590 goto next;
16591
16592 default:
16593 break;
16594 }
16595 }
16596
16597 if (type < GNU_PROPERTY_LOPROC)
16598 printf (_("<unknown type %#x data: "), type);
16599 else if (type < GNU_PROPERTY_LOUSER)
16600 printf (_("<procesor-specific type %#x data: "), type);
16601 else
16602 printf (_("<application-specific type %#x data: "), type);
16603 for (j = 0; j < datasz; ++j)
16604 printf ("%02x ", ptr[j] & 0xff);
16605 printf (">");
16606
16607next:
16608 ptr += ((datasz + (size - 1)) & ~ (size - 1));
16609 if (ptr == ptr_end)
16610 break;
16611 else
16612 {
16613 if (do_wide)
16614 printf (", ");
16615 else
16616 printf ("\n\t");
16617 }
16618
16619 if (ptr > (ptr_end - 8))
16620 {
16621 printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
16622 break;
16623 }
16624 }
16625
16626 printf ("\n");
16627}
16628
16629static bfd_boolean
16630print_gnu_note (Elf_Internal_Note *pnote)
16631{
16632 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
16633 switch (pnote->type)
16634 {
16635 case NT_GNU_BUILD_ID:
16636 {
16637 unsigned long i;
16638
16639 printf (_(" Build ID: "));
16640 for (i = 0; i < pnote->descsz; ++i)
16641 printf ("%02x", pnote->descdata[i] & 0xff);
16642 printf ("\n");
16643 }
16644 break;
16645
16646 case NT_GNU_ABI_TAG:
16647 {
16648 unsigned long os, major, minor, subminor;
16649 const char *osname;
16650
16651 /* PR 17531: file: 030-599401-0.004. */
16652 if (pnote->descsz < 16)
16653 {
16654 printf (_(" <corrupt GNU_ABI_TAG>\n"));
16655 break;
16656 }
16657
16658 os = byte_get ((unsigned char *) pnote->descdata, 4);
16659 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
16660 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
16661 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
16662
16663 switch (os)
16664 {
16665 case GNU_ABI_TAG_LINUX:
16666 osname = "Linux";
16667 break;
16668 case GNU_ABI_TAG_HURD:
16669 osname = "Hurd";
16670 break;
16671 case GNU_ABI_TAG_SOLARIS:
16672 osname = "Solaris";
16673 break;
16674 case GNU_ABI_TAG_FREEBSD:
16675 osname = "FreeBSD";
16676 break;
16677 case GNU_ABI_TAG_NETBSD:
16678 osname = "NetBSD";
16679 break;
16680 case GNU_ABI_TAG_SYLLABLE:
16681 osname = "Syllable";
16682 break;
16683 case GNU_ABI_TAG_NACL:
16684 osname = "NaCl";
16685 break;
16686 default:
16687 osname = "Unknown";
16688 break;
16689 }
16690
16691 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
16692 major, minor, subminor);
16693 }
16694 break;
16695
16696 case NT_GNU_GOLD_VERSION:
16697 {
16698 unsigned long i;
16699
16700 printf (_(" Version: "));
16701 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
16702 printf ("%c", pnote->descdata[i]);
16703 printf ("\n");
16704 }
16705 break;
16706
16707 case NT_GNU_HWCAP:
16708 {
16709 unsigned long num_entries, mask;
16710
16711 /* Hardware capabilities information. Word 0 is the number of entries.
16712 Word 1 is a bitmask of enabled entries. The rest of the descriptor
16713 is a series of entries, where each entry is a single byte followed
16714 by a nul terminated string. The byte gives the bit number to test
16715 if enabled in the bitmask. */
16716 printf (_(" Hardware Capabilities: "));
16717 if (pnote->descsz < 8)
16718 {
16719 error (_("<corrupt GNU_HWCAP>\n"));
16720 return FALSE;
16721 }
16722 num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
16723 mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
16724 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
16725 /* FIXME: Add code to display the entries... */
16726 }
16727 break;
16728
16729 case NT_GNU_PROPERTY_TYPE_0:
16730 print_gnu_property_note (pnote);
16731 break;
16732
16733 default:
16734 /* Handle unrecognised types. An error message should have already been
16735 created by get_gnu_elf_note_type(), so all that we need to do is to
16736 display the data. */
16737 {
16738 unsigned long i;
16739
16740 printf (_(" Description data: "));
16741 for (i = 0; i < pnote->descsz; ++i)
16742 printf ("%02x ", pnote->descdata[i] & 0xff);
16743 printf ("\n");
16744 }
16745 break;
16746 }
16747
16748 return TRUE;
16749}
16750
16751static const char *
16752get_v850_elf_note_type (enum v850_notes n_type)
16753{
16754 static char buff[64];
16755
16756 switch (n_type)
16757 {
16758 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
16759 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
16760 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
16761 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
16762 case V850_NOTE_CACHE_INFO: return _("Use of cache");
16763 case V850_NOTE_MMU_INFO: return _("Use of MMU");
16764 default:
16765 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
16766 return buff;
16767 }
16768}
16769
16770static bfd_boolean
16771print_v850_note (Elf_Internal_Note * pnote)
16772{
16773 unsigned int val;
16774
16775 if (pnote->descsz != 4)
16776 return FALSE;
16777
16778 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
16779
16780 if (val == 0)
16781 {
16782 printf (_("not set\n"));
16783 return TRUE;
16784 }
16785
16786 switch (pnote->type)
16787 {
16788 case V850_NOTE_ALIGNMENT:
16789 switch (val)
16790 {
16791 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
16792 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
16793 }
16794 break;
16795
16796 case V850_NOTE_DATA_SIZE:
16797 switch (val)
16798 {
16799 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
16800 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
16801 }
16802 break;
16803
16804 case V850_NOTE_FPU_INFO:
16805 switch (val)
16806 {
16807 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
16808 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
16809 }
16810 break;
16811
16812 case V850_NOTE_MMU_INFO:
16813 case V850_NOTE_CACHE_INFO:
16814 case V850_NOTE_SIMD_INFO:
16815 if (val == EF_RH850_SIMD)
16816 {
16817 printf (_("yes\n"));
16818 return TRUE;
16819 }
16820 break;
16821
16822 default:
16823 /* An 'unknown note type' message will already have been displayed. */
16824 break;
16825 }
16826
16827 printf (_("unknown value: %x\n"), val);
16828 return FALSE;
16829}
16830
16831static bfd_boolean
16832process_netbsd_elf_note (Elf_Internal_Note * pnote)
16833{
16834 unsigned int version;
16835
16836 switch (pnote->type)
16837 {
16838 case NT_NETBSD_IDENT:
16839 version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
16840 if ((version / 10000) % 100)
16841 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
16842 version, version / 100000000, (version / 1000000) % 100,
16843 (version / 10000) % 100 > 26 ? "Z" : "",
16844 'A' + (version / 10000) % 26);
16845 else
16846 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
16847 version, version / 100000000, (version / 1000000) % 100,
16848 (version / 100) % 100);
16849 return TRUE;
16850
16851 case NT_NETBSD_MARCH:
16852 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
16853 pnote->descdata);
16854 return TRUE;
16855
16856 default:
16857 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
16858 pnote->type);
16859 return FALSE;
16860 }
16861}
16862
16863static const char *
16864get_freebsd_elfcore_note_type (unsigned e_type)
16865{
16866 switch (e_type)
16867 {
16868 case NT_FREEBSD_THRMISC:
16869 return _("NT_THRMISC (thrmisc structure)");
16870 case NT_FREEBSD_PROCSTAT_PROC:
16871 return _("NT_PROCSTAT_PROC (proc data)");
16872 case NT_FREEBSD_PROCSTAT_FILES:
16873 return _("NT_PROCSTAT_FILES (files data)");
16874 case NT_FREEBSD_PROCSTAT_VMMAP:
16875 return _("NT_PROCSTAT_VMMAP (vmmap data)");
16876 case NT_FREEBSD_PROCSTAT_GROUPS:
16877 return _("NT_PROCSTAT_GROUPS (groups data)");
16878 case NT_FREEBSD_PROCSTAT_UMASK:
16879 return _("NT_PROCSTAT_UMASK (umask data)");
16880 case NT_FREEBSD_PROCSTAT_RLIMIT:
16881 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
16882 case NT_FREEBSD_PROCSTAT_OSREL:
16883 return _("NT_PROCSTAT_OSREL (osreldate data)");
16884 case NT_FREEBSD_PROCSTAT_PSSTRINGS:
16885 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
16886 case NT_FREEBSD_PROCSTAT_AUXV:
16887 return _("NT_PROCSTAT_AUXV (auxv data)");
16888 case NT_FREEBSD_PTLWPINFO:
16889 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
16890 }
16891 return get_note_type (e_type);
16892}
16893
16894static const char *
16895get_netbsd_elfcore_note_type (unsigned e_type)
16896{
16897 static char buff[64];
16898
16899 if (e_type == NT_NETBSDCORE_PROCINFO)
16900 {
16901 /* NetBSD core "procinfo" structure. */
16902 return _("NetBSD procinfo structure");
16903 }
16904
16905 /* As of Jan 2002 there are no other machine-independent notes
16906 defined for NetBSD core files. If the note type is less
16907 than the start of the machine-dependent note types, we don't
16908 understand it. */
16909
16910 if (e_type < NT_NETBSDCORE_FIRSTMACH)
16911 {
16912 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16913 return buff;
16914 }
16915
16916 switch (elf_header.e_machine)
16917 {
16918 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
16919 and PT_GETFPREGS == mach+2. */
16920
16921 case EM_OLD_ALPHA:
16922 case EM_ALPHA:
16923 case EM_SPARC:
16924 case EM_SPARC32PLUS:
16925 case EM_SPARCV9:
16926 switch (e_type)
16927 {
16928 case NT_NETBSDCORE_FIRSTMACH + 0:
16929 return _("PT_GETREGS (reg structure)");
16930 case NT_NETBSDCORE_FIRSTMACH + 2:
16931 return _("PT_GETFPREGS (fpreg structure)");
16932 default:
16933 break;
16934 }
16935 break;
16936
16937 /* On all other arch's, PT_GETREGS == mach+1 and
16938 PT_GETFPREGS == mach+3. */
16939 default:
16940 switch (e_type)
16941 {
16942 case NT_NETBSDCORE_FIRSTMACH + 1:
16943 return _("PT_GETREGS (reg structure)");
16944 case NT_NETBSDCORE_FIRSTMACH + 3:
16945 return _("PT_GETFPREGS (fpreg structure)");
16946 default:
16947 break;
16948 }
16949 }
16950
16951 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
16952 e_type - NT_NETBSDCORE_FIRSTMACH);
16953 return buff;
16954}
16955
16956static const char *
16957get_stapsdt_note_type (unsigned e_type)
16958{
16959 static char buff[64];
16960
16961 switch (e_type)
16962 {
16963 case NT_STAPSDT:
16964 return _("NT_STAPSDT (SystemTap probe descriptors)");
16965
16966 default:
16967 break;
16968 }
16969
16970 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16971 return buff;
16972}
16973
16974static bfd_boolean
16975print_stapsdt_note (Elf_Internal_Note *pnote)
16976{
16977 int addr_size = is_32bit_elf ? 4 : 8;
16978 char *data = pnote->descdata;
16979 char *data_end = pnote->descdata + pnote->descsz;
16980 bfd_vma pc, base_addr, semaphore;
16981 char *provider, *probe, *arg_fmt;
16982
16983 pc = byte_get ((unsigned char *) data, addr_size);
16984 data += addr_size;
16985 base_addr = byte_get ((unsigned char *) data, addr_size);
16986 data += addr_size;
16987 semaphore = byte_get ((unsigned char *) data, addr_size);
16988 data += addr_size;
16989
16990 provider = data;
16991 data += strlen (data) + 1;
16992 probe = data;
16993 data += strlen (data) + 1;
16994 arg_fmt = data;
16995 data += strlen (data) + 1;
16996
16997 printf (_(" Provider: %s\n"), provider);
16998 printf (_(" Name: %s\n"), probe);
16999 printf (_(" Location: "));
17000 print_vma (pc, FULL_HEX);
17001 printf (_(", Base: "));
17002 print_vma (base_addr, FULL_HEX);
17003 printf (_(", Semaphore: "));
17004 print_vma (semaphore, FULL_HEX);
17005 printf ("\n");
17006 printf (_(" Arguments: %s\n"), arg_fmt);
17007
17008 return data == data_end;
17009}
17010
17011static const char *
17012get_ia64_vms_note_type (unsigned e_type)
17013{
17014 static char buff[64];
17015
17016 switch (e_type)
17017 {
17018 case NT_VMS_MHD:
17019 return _("NT_VMS_MHD (module header)");
17020 case NT_VMS_LNM:
17021 return _("NT_VMS_LNM (language name)");
17022 case NT_VMS_SRC:
17023 return _("NT_VMS_SRC (source files)");
17024 case NT_VMS_TITLE:
17025 return "NT_VMS_TITLE";
17026 case NT_VMS_EIDC:
17027 return _("NT_VMS_EIDC (consistency check)");
17028 case NT_VMS_FPMODE:
17029 return _("NT_VMS_FPMODE (FP mode)");
17030 case NT_VMS_LINKTIME:
17031 return "NT_VMS_LINKTIME";
17032 case NT_VMS_IMGNAM:
17033 return _("NT_VMS_IMGNAM (image name)");
17034 case NT_VMS_IMGID:
17035 return _("NT_VMS_IMGID (image id)");
17036 case NT_VMS_LINKID:
17037 return _("NT_VMS_LINKID (link id)");
17038 case NT_VMS_IMGBID:
17039 return _("NT_VMS_IMGBID (build id)");
17040 case NT_VMS_GSTNAM:
17041 return _("NT_VMS_GSTNAM (sym table name)");
17042 case NT_VMS_ORIG_DYN:
17043 return "NT_VMS_ORIG_DYN";
17044 case NT_VMS_PATCHTIME:
17045 return "NT_VMS_PATCHTIME";
17046 default:
17047 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17048 return buff;
17049 }
17050}
17051
17052static bfd_boolean
17053print_ia64_vms_note (Elf_Internal_Note * pnote)
17054{
17055 switch (pnote->type)
17056 {
17057 case NT_VMS_MHD:
17058 if (pnote->descsz > 36)
17059 {
17060 size_t l = strlen (pnote->descdata + 34);
17061 printf (_(" Creation date : %.17s\n"), pnote->descdata);
17062 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
17063 printf (_(" Module name : %s\n"), pnote->descdata + 34);
17064 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
17065 }
17066 else
17067 printf (_(" Invalid size\n"));
17068 break;
17069 case NT_VMS_LNM:
17070 printf (_(" Language: %s\n"), pnote->descdata);
17071 break;
17072#ifdef BFD64
17073 case NT_VMS_FPMODE:
17074 printf (_(" Floating Point mode: "));
17075 printf ("0x%016" BFD_VMA_FMT "x\n",
17076 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
17077 break;
17078 case NT_VMS_LINKTIME:
17079 printf (_(" Link time: "));
17080 print_vms_time
17081 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17082 printf ("\n");
17083 break;
17084 case NT_VMS_PATCHTIME:
17085 printf (_(" Patch time: "));
17086 print_vms_time
17087 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17088 printf ("\n");
17089 break;
17090 case NT_VMS_ORIG_DYN:
17091 printf (_(" Major id: %u, minor id: %u\n"),
17092 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
17093 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
17094 printf (_(" Last modified : "));
17095 print_vms_time
17096 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
17097 printf (_("\n Link flags : "));
17098 printf ("0x%016" BFD_VMA_FMT "x\n",
17099 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
17100 printf (_(" Header flags: 0x%08x\n"),
17101 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
17102 printf (_(" Image id : %s\n"), pnote->descdata + 32);
17103 break;
17104#endif
17105 case NT_VMS_IMGNAM:
17106 printf (_(" Image name: %s\n"), pnote->descdata);
17107 break;
17108 case NT_VMS_GSTNAM:
17109 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
17110 break;
17111 case NT_VMS_IMGID:
17112 printf (_(" Image id: %s\n"), pnote->descdata);
17113 break;
17114 case NT_VMS_LINKID:
17115 printf (_(" Linker id: %s\n"), pnote->descdata);
17116 break;
17117 default:
17118 return FALSE;
17119 }
17120 return TRUE;
17121}
17122
17123/* Print the name of the symbol associated with a build attribute
17124 that is attached to address OFFSET. */
17125
17126static bfd_boolean
17127print_symbol_for_build_attribute (FILE * file,
17128 unsigned long offset,
17129 bfd_boolean is_open_attr)
17130{
17131 static FILE * saved_file = NULL;
17132 static char * strtab;
17133 static unsigned long strtablen;
17134 static Elf_Internal_Sym * symtab;
17135 static unsigned long nsyms;
17136 Elf_Internal_Sym * saved_sym = NULL;
17137 Elf_Internal_Sym * sym;
17138
17139 if (section_headers != NULL
17140 && (saved_file == NULL || file != saved_file))
17141 {
17142 Elf_Internal_Shdr * symsec;
17143
17144 /* Load the symbol and string sections. */
17145 for (symsec = section_headers;
17146 symsec < section_headers + elf_header.e_shnum;
17147 symsec ++)
17148 {
17149 if (symsec->sh_type == SHT_SYMTAB)
17150 {
17151 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
17152
17153 if (symsec->sh_link < elf_header.e_shnum)
17154 {
17155 Elf_Internal_Shdr * strtab_sec = section_headers + symsec->sh_link;
17156
17157 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
17158 1, strtab_sec->sh_size,
17159 _("string table"));
17160 strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
17161 }
17162 }
17163 }
17164 saved_file = file;
17165 }
17166
17167 if (symtab == NULL || strtab == NULL)
17168 {
17169 printf ("\n");
17170 return FALSE;
17171 }
17172
17173 /* Find a symbol whose value matches offset. */
17174 for (sym = symtab; sym < symtab + nsyms; sym ++)
17175 if (sym->st_value == offset)
17176 {
17177 if (sym->st_name >= strtablen)
17178 /* Huh ? This should not happen. */
17179 continue;
17180
17181 if (strtab[sym->st_name] == 0)
17182 continue;
17183
17184 if (is_open_attr)
17185 {
17186 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17187 and FILE or OBJECT symbols over NOTYPE symbols. We skip
17188 FUNC symbols entirely. */
17189 switch (ELF_ST_TYPE (sym->st_info))
17190 {
17191 case STT_FILE:
17192 saved_sym = sym;
17193 /* We can stop searching now. */
17194 sym = symtab + nsyms;
17195 continue;
17196
17197 case STT_OBJECT:
17198 saved_sym = sym;
17199 continue;
17200
17201 case STT_FUNC:
17202 /* Ignore function symbols. */
17203 continue;
17204
17205 default:
17206 break;
17207 }
17208
17209 switch (ELF_ST_BIND (sym->st_info))
17210 {
17211 case STB_GLOBAL:
17212 if (saved_sym == NULL
17213 || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
17214 saved_sym = sym;
17215 break;
17216
17217 case STB_LOCAL:
17218 if (saved_sym == NULL)
17219 saved_sym = sym;
17220 break;
17221
17222 default:
17223 break;
17224 }
17225 }
17226 else
17227 {
17228 if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
17229 continue;
17230
17231 saved_sym = sym;
17232 break;
17233 }
17234 }
17235
17236 printf (" (%s: %s)\n",
17237 is_open_attr ? _("file") : _("func"),
17238 saved_sym ? strtab + saved_sym->st_name : _("<no symbol found>)"));
17239 return TRUE;
17240}
17241
17242static bfd_boolean
17243print_gnu_build_attribute_description (Elf_Internal_Note * pnote,
17244 FILE * file)
17245{
17246 static unsigned long global_offset = 0;
17247 unsigned long offset;
17248 unsigned int desc_size = is_32bit_elf ? 4 : 8;
17249 bfd_boolean is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
17250
17251 if (pnote->descsz == 0)
17252 {
17253 if (is_open_attr)
17254 {
17255 printf (_(" Applies from offset %#lx\n"), global_offset);
17256 return TRUE;
17257 }
17258 else
17259 {
17260 printf (_(" Applies to func at %#lx"), global_offset);
17261 return print_symbol_for_build_attribute (file, global_offset, is_open_attr);
17262 }
17263 }
17264
17265 if (pnote->descsz != desc_size)
17266 {
17267 error (_(" <invalid description size: %lx>\n"), pnote->descsz);
17268 printf (_(" <invalid descsz>"));
17269 return FALSE;
17270 }
17271
17272 offset = byte_get ((unsigned char *) pnote->descdata, desc_size);
17273
17274 if (is_open_attr)
17275 {
17276 printf (_(" Applies from offset %#lx"), offset);
17277 global_offset = offset;
17278 }
17279 else
17280 {
17281 printf (_(" Applies to func at %#lx"), offset);
17282 }
17283
17284 return print_symbol_for_build_attribute (file, offset, is_open_attr);
17285}
17286
17287static bfd_boolean
17288print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
17289{
17290 static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
17291 static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
17292 static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
17293 char name_type;
17294 char name_attribute;
17295 const char * expected_types;
17296 const char * name = pnote->namedata;
17297 const char * text;
17298 signed int left;
17299
17300 if (name == NULL || pnote->namesz < 2)
17301 {
17302 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
17303 print_symbol (-20, _(" <corrupt name>"));
17304 return FALSE;
17305 }
17306
17307 left = 20;
17308
17309 /* Version 2 of the spec adds a "GA" prefix to the name field. */
17310 if (name[0] == 'G' && name[1] == 'A')
17311 {
17312 printf ("GA");
17313 name += 2;
17314 left -= 2;
17315 }
17316
17317 switch ((name_type = * name))
17318 {
17319 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17320 case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17321 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17322 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17323 printf ("%c", * name);
17324 left --;
17325 break;
17326 default:
17327 error (_("unrecognised attribute type in name field: %d\n"), name_type);
17328 print_symbol (-20, _("<unknown name type>"));
17329 return FALSE;
17330 }
17331
17332 ++ name;
17333 text = NULL;
17334
17335 switch ((name_attribute = * name))
17336 {
17337 case GNU_BUILD_ATTRIBUTE_VERSION:
17338 text = _("<version>");
17339 expected_types = string_expected;
17340 ++ name;
17341 break;
17342 case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17343 text = _("<stack prot>");
17344 expected_types = "!+*";
17345 ++ name;
17346 break;
17347 case GNU_BUILD_ATTRIBUTE_RELRO:
17348 text = _("<relro>");
17349 expected_types = bool_expected;
17350 ++ name;
17351 break;
17352 case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
17353 text = _("<stack size>");
17354 expected_types = number_expected;
17355 ++ name;
17356 break;
17357 case GNU_BUILD_ATTRIBUTE_TOOL:
17358 text = _("<tool>");
17359 expected_types = string_expected;
17360 ++ name;
17361 break;
17362 case GNU_BUILD_ATTRIBUTE_ABI:
17363 text = _("<ABI>");
17364 expected_types = "$*";
17365 ++ name;
17366 break;
17367 case GNU_BUILD_ATTRIBUTE_PIC:
17368 text = _("<PIC>");
17369 expected_types = number_expected;
17370 ++ name;
17371 break;
17372 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
17373 text = _("<short enum>");
17374 expected_types = bool_expected;
17375 ++ name;
17376 break;
17377 default:
17378 if (ISPRINT (* name))
17379 {
17380 int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
17381
17382 if (len > left && ! do_wide)
17383 len = left;
17384 printf ("%.*s:", len, name);
17385 left -= len;
17386 name += len;
17387 }
17388 else
17389 {
17390 static char tmpbuf [128];
17391
17392 error (_("unrecognised byte in name field: %d\n"), * name);
17393 sprintf (tmpbuf, _("<unknown:_%d>"), * name);
17394 text = tmpbuf;
17395 name ++;
17396 }
17397 expected_types = "*$!+";
17398 break;
17399 }
17400
17401 if (text)
17402 left -= printf ("%s", text);
17403
17404 if (strchr (expected_types, name_type) == NULL)
17405 warn (_("attribute does not have an expected type (%c)\n"), name_type);
17406
17407 if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
17408 {
17409 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17410 (unsigned long) pnote->namesz,
17411 (long) (name - pnote->namedata));
17412 return FALSE;
17413 }
17414
17415 if (left < 1 && ! do_wide)
17416 return TRUE;
17417
17418 switch (name_type)
17419 {
17420 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17421 {
17422 unsigned int bytes;
17423 unsigned long long val = 0;
17424 unsigned int shift = 0;
17425 char * decoded = NULL;
17426
17427 bytes = pnote->namesz - (name - pnote->namedata);
17428 if (bytes > 0)
17429 /* The -1 is because the name field is always 0 terminated, and we
17430 want to be able to ensure that the shift in the while loop below
17431 will not overflow. */
17432 -- bytes;
17433
17434 if (bytes > sizeof (val))
17435 {
17436 fprintf (stderr, "namesz %lx name %p namedata %p\n",
17437 pnote->namesz, name, pnote->namedata);
17438 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
17439 bytes);
17440 bytes = sizeof (val);
17441 }
17442 /* We do not bother to warn if bytes == 0 as this can
17443 happen with some early versions of the gcc plugin. */
17444
17445 while (bytes --)
17446 {
17447 unsigned long byte = (* name ++) & 0xff;
17448
17449 val |= byte << shift;
17450 shift += 8;
17451 }
17452
17453 switch (name_attribute)
17454 {
17455 case GNU_BUILD_ATTRIBUTE_PIC:
17456 switch (val)
17457 {
17458 case 0: decoded = "static"; break;
17459 case 1: decoded = "pic"; break;
17460 case 2: decoded = "PIC"; break;
17461 case 3: decoded = "pie"; break;
17462 case 4: decoded = "PIE"; break;
17463 default: break;
17464 }
17465 break;
17466 case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17467 switch (val)
17468 {
17469 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
17470 case 0: decoded = "off"; break;
17471 case 1: decoded = "on"; break;
17472 case 2: decoded = "all"; break;
17473 case 3: decoded = "strong"; break;
17474 case 4: decoded = "explicit"; break;
17475 default: break;
17476 }
17477 break;
17478 default:
17479 break;
17480 }
17481
17482 if (decoded != NULL)
17483 {
17484 print_symbol (-left, decoded);
17485 left = 0;
17486 }
17487 else if (val == 0)
17488 {
17489 printf ("0x0");
17490 left -= 3;
17491 }
17492 else
17493 {
17494 if (do_wide)
17495 left -= printf ("0x%llx", val);
17496 else
17497 left -= printf ("0x%-.*llx", left, val);
17498 }
17499 }
17500 break;
17501 case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17502 left -= print_symbol (- left, name);
17503 break;
17504 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17505 left -= print_symbol (- left, "true");
17506 break;
17507 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17508 left -= print_symbol (- left, "false");
17509 break;
17510 }
17511
17512 if (do_wide && left > 0)
17513 printf ("%-*s", left, " ");
17514
17515 return TRUE;
17516}
17517
17518/* Note that by the ELF standard, the name field is already null byte
17519 terminated, and namesz includes the terminating null byte.
17520 I.E. the value of namesz for the name "FSF" is 4.
17521
17522 If the value of namesz is zero, there is no name present. */
17523
17524static bfd_boolean
17525process_note (Elf_Internal_Note * pnote,
17526 FILE * file)
17527{
17528 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
17529 const char * nt;
17530
17531 if (pnote->namesz == 0)
17532 /* If there is no note name, then use the default set of
17533 note type strings. */
17534 nt = get_note_type (pnote->type);
17535
17536 else if (const_strneq (pnote->namedata, "GNU"))
17537 /* GNU-specific object file notes. */
17538 nt = get_gnu_elf_note_type (pnote->type);
17539
17540 else if (const_strneq (pnote->namedata, "FreeBSD"))
17541 /* FreeBSD-specific core file notes. */
17542 nt = get_freebsd_elfcore_note_type (pnote->type);
17543
17544 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
17545 /* NetBSD-specific core file notes. */
17546 nt = get_netbsd_elfcore_note_type (pnote->type);
17547
17548 else if (const_strneq (pnote->namedata, "NetBSD"))
17549 /* NetBSD-specific core file notes. */
17550 return process_netbsd_elf_note (pnote);
17551
17552 else if (strneq (pnote->namedata, "SPU/", 4))
17553 {
17554 /* SPU-specific core file notes. */
17555 nt = pnote->namedata + 4;
17556 name = "SPU";
17557 }
17558
17559 else if (const_strneq (pnote->namedata, "IPF/VMS"))
17560 /* VMS/ia64-specific file notes. */
17561 nt = get_ia64_vms_note_type (pnote->type);
17562
17563 else if (const_strneq (pnote->namedata, "stapsdt"))
17564 nt = get_stapsdt_note_type (pnote->type);
17565
17566 else
17567 /* Don't recognize this note name; just use the default set of
17568 note type strings. */
17569 nt = get_note_type (pnote->type);
17570
17571 printf (" ");
17572
17573 if (((const_strneq (pnote->namedata, "GA")
17574 && strchr ("*$!+", pnote->namedata[2]) != NULL)
17575 || strchr ("*$!+", pnote->namedata[0]) != NULL)
17576 && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17577 || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
17578 print_gnu_build_attribute_name (pnote);
17579 else
17580 print_symbol (-20, name);
17581
17582 if (do_wide)
17583 printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
17584 else
17585 printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
17586
17587 if (const_strneq (pnote->namedata, "IPF/VMS"))
17588 return print_ia64_vms_note (pnote);
17589 else if (const_strneq (pnote->namedata, "GNU"))
17590 return print_gnu_note (pnote);
17591 else if (const_strneq (pnote->namedata, "stapsdt"))
17592 return print_stapsdt_note (pnote);
17593 else if (const_strneq (pnote->namedata, "CORE"))
17594 return print_core_note (pnote);
17595 else if (((const_strneq (pnote->namedata, "GA")
17596 && strchr ("*$!+", pnote->namedata[2]) != NULL)
17597 || strchr ("*$!+", pnote->namedata[0]) != NULL)
17598 && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17599 || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
17600 return print_gnu_build_attribute_description (pnote, file);
17601
17602 if (pnote->descsz)
17603 {
17604 unsigned long i;
17605
17606 printf (_(" description data: "));
17607 for (i = 0; i < pnote->descsz; i++)
17608 printf ("%02x ", pnote->descdata[i]);
17609 if (!do_wide)
17610 printf ("\n");
17611 }
17612
17613 if (do_wide)
17614 printf ("\n");
17615
17616 return TRUE;
17617}
17618
17619static bfd_boolean
17620process_notes_at (FILE * file,
17621 Elf_Internal_Shdr * section,
17622 bfd_vma offset,
17623 bfd_vma length)
17624{
17625 Elf_External_Note * pnotes;
17626 Elf_External_Note * external;
17627 char * end;
17628 bfd_boolean res = TRUE;
17629
17630 if (length <= 0)
17631 return FALSE;
17632
17633 if (section)
17634 {
17635 pnotes = (Elf_External_Note *) get_section_contents (section, file);
17636 if (pnotes)
17637 {
17638 if (! apply_relocations (file, section, (unsigned char *) pnotes, length, NULL, NULL))
17639 return FALSE;
17640 }
17641 }
17642 else
17643 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
17644 _("notes"));
17645 if (pnotes == NULL)
17646 return FALSE;
17647
17648 external = pnotes;
17649
17650 if (section)
17651 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section));
17652 else
17653 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
17654 (unsigned long) offset, (unsigned long) length);
17655
17656 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
17657
17658 end = (char *) pnotes + length;
17659 while ((char *) external < end)
17660 {
17661 Elf_Internal_Note inote;
17662 size_t min_notesz;
17663 char *next;
17664 char * temp = NULL;
17665 size_t data_remaining = end - (char *) external;
17666
17667 if (!is_ia64_vms ())
17668 {
17669 /* PR binutils/15191
17670 Make sure that there is enough data to read. */
17671 min_notesz = offsetof (Elf_External_Note, name);
17672 if (data_remaining < min_notesz)
17673 {
17674 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17675 (int) data_remaining);
17676 break;
17677 }
17678 data_remaining -= min_notesz;
17679
17680 inote.type = BYTE_GET (external->type);
17681 inote.namesz = BYTE_GET (external->namesz);
17682 inote.namedata = external->name;
17683 inote.descsz = BYTE_GET (external->descsz);
17684 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
17685 inote.descpos = offset + (inote.descdata - (char *) pnotes);
17686 next = inote.descdata + align_power (inote.descsz, 2);
17687 }
17688 else
17689 {
17690 Elf64_External_VMS_Note *vms_external;
17691
17692 /* PR binutils/15191
17693 Make sure that there is enough data to read. */
17694 min_notesz = offsetof (Elf64_External_VMS_Note, name);
17695 if (data_remaining < min_notesz)
17696 {
17697 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17698 (int) data_remaining);
17699 break;
17700 }
17701 data_remaining -= min_notesz;
17702
17703 vms_external = (Elf64_External_VMS_Note *) external;
17704 inote.type = BYTE_GET (vms_external->type);
17705 inote.namesz = BYTE_GET (vms_external->namesz);
17706 inote.namedata = vms_external->name;
17707 inote.descsz = BYTE_GET (vms_external->descsz);
17708 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
17709 inote.descpos = offset + (inote.descdata - (char *) pnotes);
17710 next = inote.descdata + align_power (inote.descsz, 3);
17711 }
17712
17713 /* PR 17531: file: 3443835e. */
17714 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
17715 if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
17716 || (size_t) (inote.descdata - inote.namedata) > data_remaining
17717 || (size_t) (next - inote.descdata) < inote.descsz
17718 || ((size_t) (next - inote.descdata)
17719 > data_remaining - (size_t) (inote.descdata - inote.namedata)))
17720 {
17721 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
17722 (unsigned long) ((char *) external - (char *) pnotes));
17723 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
17724 inote.type, inote.namesz, inote.descsz);
17725 break;
17726 }
17727
17728 external = (Elf_External_Note *) next;
17729
17730 /* Verify that name is null terminated. It appears that at least
17731 one version of Linux (RedHat 6.0) generates corefiles that don't
17732 comply with the ELF spec by failing to include the null byte in
17733 namesz. */
17734 if (inote.namedata[inote.namesz - 1] != '\0')
17735 {
17736 if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
17737 {
17738 temp = (char *) malloc (inote.namesz + 1);
17739 if (temp == NULL)
17740 {
17741 error (_("Out of memory allocating space for inote name\n"));
17742 res = FALSE;
17743 break;
17744 }
17745
17746 memcpy (temp, inote.namedata, inote.namesz);
17747 inote.namedata = temp;
17748 }
17749 inote.namedata[inote.namesz] = 0;
17750 }
17751
17752 if (! process_note (& inote, file))
17753 res = FALSE;
17754
17755 if (temp != NULL)
17756 {
17757 free (temp);
17758 temp = NULL;
17759 }
17760 }
17761
17762 free (pnotes);
17763
17764 return res;
17765}
17766
17767static bfd_boolean
17768process_corefile_note_segments (FILE * file)
17769{
17770 Elf_Internal_Phdr * segment;
17771 unsigned int i;
17772 bfd_boolean res = TRUE;
17773
17774 if (! get_program_headers (file))
17775 return TRUE;
17776
17777 for (i = 0, segment = program_headers;
17778 i < elf_header.e_phnum;
17779 i++, segment++)
17780 {
17781 if (segment->p_type == PT_NOTE)
17782 if (! process_notes_at (file, NULL,
17783 (bfd_vma) segment->p_offset,
17784 (bfd_vma) segment->p_filesz))
17785 res = FALSE;
17786 }
17787
17788 return res;
17789}
17790
17791static bfd_boolean
17792process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
17793{
17794 Elf_External_Note * pnotes;
17795 Elf_External_Note * external;
17796 char * end;
17797 bfd_boolean res = TRUE;
17798
17799 if (length <= 0)
17800 return FALSE;
17801
17802 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
17803 _("v850 notes"));
17804 if (pnotes == NULL)
17805 return FALSE;
17806
17807 external = pnotes;
17808 end = (char*) pnotes + length;
17809
17810 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
17811 (unsigned long) offset, (unsigned long) length);
17812
17813 while ((char *) external + sizeof (Elf_External_Note) < end)
17814 {
17815 Elf_External_Note * next;
17816 Elf_Internal_Note inote;
17817
17818 inote.type = BYTE_GET (external->type);
17819 inote.namesz = BYTE_GET (external->namesz);
17820 inote.namedata = external->name;
17821 inote.descsz = BYTE_GET (external->descsz);
17822 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
17823 inote.descpos = offset + (inote.descdata - (char *) pnotes);
17824
17825 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
17826 {
17827 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
17828 inote.descdata = inote.namedata;
17829 inote.namesz = 0;
17830 }
17831
17832 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
17833
17834 if ( ((char *) next > end)
17835 || ((char *) next < (char *) pnotes))
17836 {
17837 warn (_("corrupt descsz 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);
17841 break;
17842 }
17843
17844 external = next;
17845
17846 /* Prevent out-of-bounds indexing. */
17847 if ( inote.namedata + inote.namesz > end
17848 || inote.namedata + inote.namesz < inote.namedata)
17849 {
17850 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
17851 (unsigned long) ((char *) external - (char *) pnotes));
17852 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17853 inote.type, inote.namesz, inote.descsz);
17854 break;
17855 }
17856
17857 printf (" %s: ", get_v850_elf_note_type (inote.type));
17858
17859 if (! print_v850_note (& inote))
17860 {
17861 res = FALSE;
17862 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
17863 inote.namesz, inote.descsz);
17864 }
17865 }
17866
17867 free (pnotes);
17868
17869 return res;
17870}
17871
17872static bfd_boolean
17873process_note_sections (FILE * file)
17874{
17875 Elf_Internal_Shdr * section;
17876 unsigned long i;
17877 unsigned int n = 0;
17878 bfd_boolean res = TRUE;
17879
17880 for (i = 0, section = section_headers;
17881 i < elf_header.e_shnum && section != NULL;
17882 i++, section++)
17883 {
17884 if (section->sh_type == SHT_NOTE)
17885 {
17886 if (! process_notes_at (file, section,
17887 (bfd_vma) section->sh_offset,
17888 (bfd_vma) section->sh_size))
17889 res = FALSE;
17890 n++;
17891 }
17892
17893 if (( elf_header.e_machine == EM_V800
17894 || elf_header.e_machine == EM_V850
17895 || elf_header.e_machine == EM_CYGNUS_V850)
17896 && section->sh_type == SHT_RENESAS_INFO)
17897 {
17898 if (! process_v850_notes (file,
17899 (bfd_vma) section->sh_offset,
17900 (bfd_vma) section->sh_size))
17901 res = FALSE;
17902 n++;
17903 }
17904 }
17905
17906 if (n == 0)
17907 /* Try processing NOTE segments instead. */
17908 return process_corefile_note_segments (file);
17909
17910 return res;
17911}
17912
17913static bfd_boolean
17914process_notes (FILE * file)
17915{
17916 /* If we have not been asked to display the notes then do nothing. */
17917 if (! do_notes)
17918 return TRUE;
17919
17920 if (elf_header.e_type != ET_CORE)
17921 return process_note_sections (file);
17922
17923 /* No program headers means no NOTE segment. */
17924 if (elf_header.e_phnum > 0)
17925 return process_corefile_note_segments (file);
17926
17927 printf (_("No note segments present in the core file.\n"));
17928 return TRUE;
17929}
17930
17931static unsigned char *
17932display_public_gnu_attributes (unsigned char * start,
17933 const unsigned char * const end)
17934{
17935 printf (_(" Unknown GNU attribute: %s\n"), start);
17936
17937 start += strnlen ((char *) start, end - start);
17938 display_raw_attribute (start, end);
17939
17940 return (unsigned char *) end;
17941}
17942
17943static unsigned char *
17944display_generic_attribute (unsigned char * start,
17945 unsigned int tag,
17946 const unsigned char * const end)
17947{
17948 if (tag == 0)
17949 return (unsigned char *) end;
17950
17951 return display_tag_value (tag, start, end);
17952}
17953
17954static bfd_boolean
17955process_arch_specific (FILE * file)
17956{
17957 if (! do_arch)
17958 return TRUE;
17959
17960 switch (elf_header.e_machine)
17961 {
17962 case EM_ARC:
17963 case EM_ARC_COMPACT:
17964 case EM_ARC_COMPACT2:
17965 return process_attributes (file, "ARC", SHT_ARC_ATTRIBUTES,
17966 display_arc_attribute,
17967 display_generic_attribute);
17968 case EM_ARM:
17969 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
17970 display_arm_attribute,
17971 display_generic_attribute);
17972
17973 case EM_MIPS:
17974 case EM_MIPS_RS3_LE:
17975 return process_mips_specific (file);
17976
17977 case EM_MSP430:
17978 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
17979 display_msp430x_attribute,
17980 display_generic_attribute);
17981
17982 case EM_NDS32:
17983 return process_nds32_specific (file);
17984
17985 case EM_PPC:
17986 case EM_PPC64:
17987 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17988 display_power_gnu_attribute);
17989
17990 case EM_S390:
17991 case EM_S390_OLD:
17992 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17993 display_s390_gnu_attribute);
17994
17995 case EM_SPARC:
17996 case EM_SPARC32PLUS:
17997 case EM_SPARCV9:
17998 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17999 display_sparc_gnu_attribute);
18000
18001 case EM_TI_C6000:
18002 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
18003 display_tic6x_attribute,
18004 display_generic_attribute);
18005
18006 default:
18007 return process_attributes (file, "gnu", SHT_GNU_ATTRIBUTES,
18008 display_public_gnu_attributes,
18009 display_generic_attribute);
18010 }
18011}
18012
18013static bfd_boolean
18014get_file_header (FILE * file)
18015{
18016 /* Read in the identity array. */
18017 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
18018 return FALSE;
18019
18020 /* Determine how to read the rest of the header. */
18021 switch (elf_header.e_ident[EI_DATA])
18022 {
18023 default:
18024 case ELFDATANONE:
18025 case ELFDATA2LSB:
18026 byte_get = byte_get_little_endian;
18027 byte_put = byte_put_little_endian;
18028 break;
18029 case ELFDATA2MSB:
18030 byte_get = byte_get_big_endian;
18031 byte_put = byte_put_big_endian;
18032 break;
18033 }
18034
18035 /* For now we only support 32 bit and 64 bit ELF files. */
18036 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
18037
18038 /* Read in the rest of the header. */
18039 if (is_32bit_elf)
18040 {
18041 Elf32_External_Ehdr ehdr32;
18042
18043 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
18044 return FALSE;
18045
18046 elf_header.e_type = BYTE_GET (ehdr32.e_type);
18047 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
18048 elf_header.e_version = BYTE_GET (ehdr32.e_version);
18049 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
18050 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
18051 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
18052 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
18053 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
18054 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
18055 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
18056 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
18057 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
18058 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
18059 }
18060 else
18061 {
18062 Elf64_External_Ehdr ehdr64;
18063
18064 /* If we have been compiled with sizeof (bfd_vma) == 4, then
18065 we will not be able to cope with the 64bit data found in
18066 64 ELF files. Detect this now and abort before we start
18067 overwriting things. */
18068 if (sizeof (bfd_vma) < 8)
18069 {
18070 error (_("This instance of readelf has been built without support for a\n\
1807164 bit data type and so it cannot read 64 bit ELF files.\n"));
18072 return FALSE;
18073 }
18074
18075 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
18076 return FALSE;
18077
18078 elf_header.e_type = BYTE_GET (ehdr64.e_type);
18079 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
18080 elf_header.e_version = BYTE_GET (ehdr64.e_version);
18081 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
18082 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
18083 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
18084 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
18085 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
18086 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
18087 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
18088 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
18089 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
18090 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
18091 }
18092
18093 if (elf_header.e_shoff)
18094 {
18095 /* There may be some extensions in the first section header. Don't
18096 bomb if we can't read it. */
18097 if (is_32bit_elf)
18098 get_32bit_section_headers (file, TRUE);
18099 else
18100 get_64bit_section_headers (file, TRUE);
18101 }
18102
18103 return TRUE;
18104}
18105
18106/* Process one ELF object file according to the command line options.
18107 This file may actually be stored in an archive. The file is
18108 positioned at the start of the ELF object. Returns TRUE if no
18109 problems were encountered, FALSE otherwise. */
18110
18111static bfd_boolean
18112process_object (char * file_name, FILE * file)
18113{
18114 unsigned int i;
18115 bfd_boolean res = TRUE;
18116
18117 if (! get_file_header (file))
18118 {
18119 error (_("%s: Failed to read file header\n"), file_name);
18120 return FALSE;
18121 }
18122
18123 /* Initialise per file variables. */
18124 for (i = ARRAY_SIZE (version_info); i--;)
18125 version_info[i] = 0;
18126
18127 for (i = ARRAY_SIZE (dynamic_info); i--;)
18128 dynamic_info[i] = 0;
18129 dynamic_info_DT_GNU_HASH = 0;
18130
18131 /* Process the file. */
18132 if (show_name)
18133 printf (_("\nFile: %s\n"), file_name);
18134
18135 /* Initialise the dump_sects array from the cmdline_dump_sects array.
18136 Note we do this even if cmdline_dump_sects is empty because we
18137 must make sure that the dump_sets array is zeroed out before each
18138 object file is processed. */
18139 if (num_dump_sects > num_cmdline_dump_sects)
18140 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18141
18142 if (num_cmdline_dump_sects > 0)
18143 {
18144 if (num_dump_sects == 0)
18145 /* A sneaky way of allocating the dump_sects array. */
18146 request_dump_bynumber (num_cmdline_dump_sects, 0);
18147
18148 assert (num_dump_sects >= num_cmdline_dump_sects);
18149 memcpy (dump_sects, cmdline_dump_sects,
18150 num_cmdline_dump_sects * sizeof (* dump_sects));
18151 }
18152
18153 if (! process_file_header ())
18154 return FALSE;
18155
18156 if (! process_section_headers (file))
18157 {
18158 /* Without loaded section headers we cannot process lots of things. */
18159 do_unwind = do_version = do_dump = do_arch = FALSE;
18160
18161 if (! do_using_dynamic)
18162 do_syms = do_dyn_syms = do_reloc = FALSE;
18163 }
18164
18165 if (! process_section_groups (file))
18166 /* Without loaded section groups we cannot process unwind. */
18167 do_unwind = FALSE;
18168
18169 if (process_program_headers (file))
18170 process_dynamic_section (file);
18171 else
18172 res = FALSE;
18173
18174 if (! process_relocs (file))
18175 res = FALSE;
18176
18177 if (! process_unwind (file))
18178 res = FALSE;
18179
18180 if (! process_symbol_table (file))
18181 res = FALSE;
18182
18183 if (! process_syminfo (file))
18184 res = FALSE;
18185
18186 if (! process_version_sections (file))
18187 res = FALSE;
18188
18189 if (! process_section_contents (file))
18190 res = FALSE;
18191
18192 if (! process_notes (file))
18193 res = FALSE;
18194
18195 if (! process_gnu_liblist (file))
18196 res = FALSE;
18197
18198 if (! process_arch_specific (file))
18199 res = FALSE;
18200
18201 if (program_headers)
18202 {
18203 free (program_headers);
18204 program_headers = NULL;
18205 }
18206
18207 if (section_headers)
18208 {
18209 free (section_headers);
18210 section_headers = NULL;
18211 }
18212
18213 if (string_table)
18214 {
18215 free (string_table);
18216 string_table = NULL;
18217 string_table_length = 0;
18218 }
18219
18220 if (dynamic_strings)
18221 {
18222 free (dynamic_strings);
18223 dynamic_strings = NULL;
18224 dynamic_strings_length = 0;
18225 }
18226
18227 if (dynamic_symbols)
18228 {
18229 free (dynamic_symbols);
18230 dynamic_symbols = NULL;
18231 num_dynamic_syms = 0;
18232 }
18233
18234 if (dynamic_syminfo)
18235 {
18236 free (dynamic_syminfo);
18237 dynamic_syminfo = NULL;
18238 }
18239
18240 if (dynamic_section)
18241 {
18242 free (dynamic_section);
18243 dynamic_section = NULL;
18244 }
18245
18246 if (section_headers_groups)
18247 {
18248 free (section_headers_groups);
18249 section_headers_groups = NULL;
18250 }
18251
18252 if (section_groups)
18253 {
18254 struct group_list * g;
18255 struct group_list * next;
18256
18257 for (i = 0; i < group_count; i++)
18258 {
18259 for (g = section_groups [i].root; g != NULL; g = next)
18260 {
18261 next = g->next;
18262 free (g);
18263 }
18264 }
18265
18266 free (section_groups);
18267 section_groups = NULL;
18268 }
18269
18270 free_debug_memory ();
18271
18272 return res;
18273}
18274
18275/* Process an ELF archive.
18276 On entry the file is positioned just after the ARMAG string.
18277 Returns TRUE upon success, FALSE otherwise. */
18278
18279static bfd_boolean
18280process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
18281{
18282 struct archive_info arch;
18283 struct archive_info nested_arch;
18284 size_t got;
18285 bfd_boolean ret = TRUE;
18286
18287 show_name = TRUE;
18288
18289 /* The ARCH structure is used to hold information about this archive. */
18290 arch.file_name = NULL;
18291 arch.file = NULL;
18292 arch.index_array = NULL;
18293 arch.sym_table = NULL;
18294 arch.longnames = NULL;
18295
18296 /* The NESTED_ARCH structure is used as a single-item cache of information
18297 about a nested archive (when members of a thin archive reside within
18298 another regular archive file). */
18299 nested_arch.file_name = NULL;
18300 nested_arch.file = NULL;
18301 nested_arch.index_array = NULL;
18302 nested_arch.sym_table = NULL;
18303 nested_arch.longnames = NULL;
18304
18305 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
18306 {
18307 ret = FALSE;
18308 goto out;
18309 }
18310
18311 if (do_archive_index)
18312 {
18313 if (arch.sym_table == NULL)
18314 error (_("%s: unable to dump the index as none was found\n"), file_name);
18315 else
18316 {
18317 unsigned long i, l;
18318 unsigned long current_pos;
18319
18320 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
18321 file_name, (unsigned long) arch.index_num, arch.sym_size);
18322 current_pos = ftell (file);
18323
18324 for (i = l = 0; i < arch.index_num; i++)
18325 {
18326 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
18327 {
18328 char * member_name;
18329
18330 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
18331
18332 if (member_name != NULL)
18333 {
18334 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
18335
18336 if (qualified_name != NULL)
18337 {
18338 printf (_("Contents of binary %s at offset "), qualified_name);
18339 (void) print_vma (arch.index_array[i], PREFIX_HEX);
18340 putchar ('\n');
18341 free (qualified_name);
18342 }
18343 }
18344 }
18345
18346 if (l >= arch.sym_size)
18347 {
18348 error (_("%s: end of the symbol table reached before the end of the index\n"),
18349 file_name);
18350 ret = FALSE;
18351 break;
18352 }
18353 /* PR 17531: file: 0b6630b2. */
18354 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
18355 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
18356 }
18357
18358 if (arch.uses_64bit_indicies)
18359 l = (l + 7) & ~ 7;
18360 else
18361 l += l & 1;
18362
18363 if (l < arch.sym_size)
18364 {
18365 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
18366 file_name, arch.sym_size - l);
18367 ret = FALSE;
18368 }
18369
18370 if (fseek (file, current_pos, SEEK_SET) != 0)
18371 {
18372 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
18373 ret = FALSE;
18374 goto out;
18375 }
18376 }
18377
18378 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
18379 && !do_segments && !do_header && !do_dump && !do_version
18380 && !do_histogram && !do_debugging && !do_arch && !do_notes
18381 && !do_section_groups && !do_dyn_syms)
18382 {
18383 ret = TRUE; /* Archive index only. */
18384 goto out;
18385 }
18386 }
18387
18388 while (1)
18389 {
18390 char * name;
18391 size_t namelen;
18392 char * qualified_name;
18393
18394 /* Read the next archive header. */
18395 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
18396 {
18397 error (_("%s: failed to seek to next archive header\n"), file_name);
18398 return FALSE;
18399 }
18400 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
18401 if (got != sizeof arch.arhdr)
18402 {
18403 if (got == 0)
18404 break;
18405 error (_("%s: failed to read archive header\n"), file_name);
18406 ret = FALSE;
18407 break;
18408 }
18409 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
18410 {
18411 error (_("%s: did not find a valid archive header\n"), arch.file_name);
18412 ret = FALSE;
18413 break;
18414 }
18415
18416 arch.next_arhdr_offset += sizeof arch.arhdr;
18417
18418 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
18419 if (archive_file_size & 01)
18420 ++archive_file_size;
18421
18422 name = get_archive_member_name (&arch, &nested_arch);
18423 if (name == NULL)
18424 {
18425 error (_("%s: bad archive file name\n"), file_name);
18426 ret = FALSE;
18427 break;
18428 }
18429 namelen = strlen (name);
18430
18431 qualified_name = make_qualified_name (&arch, &nested_arch, name);
18432 if (qualified_name == NULL)
18433 {
18434 error (_("%s: bad archive file name\n"), file_name);
18435 ret = FALSE;
18436 break;
18437 }
18438
18439 if (is_thin_archive && arch.nested_member_origin == 0)
18440 {
18441 /* This is a proxy for an external member of a thin archive. */
18442 FILE * member_file;
18443 char * member_file_name = adjust_relative_path (file_name, name, namelen);
18444
18445 if (member_file_name == NULL)
18446 {
18447 ret = FALSE;
18448 break;
18449 }
18450
18451 member_file = fopen (member_file_name, "rb");
18452 if (member_file == NULL)
18453 {
18454 error (_("Input file '%s' is not readable.\n"), member_file_name);
18455 free (member_file_name);
18456 ret = FALSE;
18457 break;
18458 }
18459
18460 archive_file_offset = arch.nested_member_origin;
18461
18462 if (! process_object (qualified_name, member_file))
18463 ret = FALSE;
18464
18465 fclose (member_file);
18466 free (member_file_name);
18467 }
18468 else if (is_thin_archive)
18469 {
18470 /* PR 15140: Allow for corrupt thin archives. */
18471 if (nested_arch.file == NULL)
18472 {
18473 error (_("%s: contains corrupt thin archive: %s\n"),
18474 file_name, name);
18475 ret = FALSE;
18476 break;
18477 }
18478
18479 /* This is a proxy for a member of a nested archive. */
18480 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
18481
18482 /* The nested archive file will have been opened and setup by
18483 get_archive_member_name. */
18484 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
18485 {
18486 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
18487 ret = FALSE;
18488 break;
18489 }
18490
18491 if (! process_object (qualified_name, nested_arch.file))
18492 ret = FALSE;
18493 }
18494 else
18495 {
18496 archive_file_offset = arch.next_arhdr_offset;
18497 arch.next_arhdr_offset += archive_file_size;
18498
18499 if (! process_object (qualified_name, file))
18500 ret = FALSE;
18501 }
18502
18503 if (dump_sects != NULL)
18504 {
18505 free (dump_sects);
18506 dump_sects = NULL;
18507 num_dump_sects = 0;
18508 }
18509
18510 free (qualified_name);
18511 }
18512
18513 out:
18514 if (nested_arch.file != NULL)
18515 fclose (nested_arch.file);
18516 release_archive (&nested_arch);
18517 release_archive (&arch);
18518
18519 return ret;
18520}
18521
18522static bfd_boolean
18523process_file (char * file_name)
18524{
18525 FILE * file;
18526 struct stat statbuf;
18527 char armag[SARMAG];
18528 bfd_boolean ret = TRUE;
18529
18530 if (stat (file_name, &statbuf) < 0)
18531 {
18532 if (errno == ENOENT)
18533 error (_("'%s': No such file\n"), file_name);
18534 else
18535 error (_("Could not locate '%s'. System error message: %s\n"),
18536 file_name, strerror (errno));
18537 return FALSE;
18538 }
18539
18540 if (! S_ISREG (statbuf.st_mode))
18541 {
18542 error (_("'%s' is not an ordinary file\n"), file_name);
18543 return FALSE;
18544 }
18545
18546 file = fopen (file_name, "rb");
18547 if (file == NULL)
18548 {
18549 error (_("Input file '%s' is not readable.\n"), file_name);
18550 return FALSE;
18551 }
18552
18553 if (fread (armag, SARMAG, 1, file) != 1)
18554 {
18555 error (_("%s: Failed to read file's magic number\n"), file_name);
18556 fclose (file);
18557 return FALSE;
18558 }
18559
18560 current_file_size = (bfd_size_type) statbuf.st_size;
18561
18562 if (memcmp (armag, ARMAG, SARMAG) == 0)
18563 {
18564 if (! process_archive (file_name, file, FALSE))
18565 ret = FALSE;
18566 }
18567 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
18568 {
18569 if ( ! process_archive (file_name, file, TRUE))
18570 ret = FALSE;
18571 }
18572 else
18573 {
18574 if (do_archive_index)
18575 error (_("File %s is not an archive so its index cannot be displayed.\n"),
18576 file_name);
18577
18578 rewind (file);
18579 archive_file_size = archive_file_offset = 0;
18580
18581 if (! process_object (file_name, file))
18582 ret = FALSE;
18583 }
18584
18585 fclose (file);
18586 current_file_size = 0;
18587
18588 return ret;
18589}
18590
18591#ifdef SUPPORT_DISASSEMBLY
18592/* Needed by the i386 disassembler. For extra credit, someone could
18593 fix this so that we insert symbolic addresses here, esp for GOT/PLT
18594 symbols. */
18595
18596void
18597print_address (unsigned int addr, FILE * outfile)
18598{
18599 fprintf (outfile,"0x%8.8x", addr);
18600}
18601
18602/* Needed by the i386 disassembler. */
18603void
18604db_task_printsym (unsigned int addr)
18605{
18606 print_address (addr, stderr);
18607}
18608#endif
18609
18610int
18611main (int argc, char ** argv)
18612{
18613 int err;
18614
18615#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
18616 setlocale (LC_MESSAGES, "");
18617#endif
18618#if defined (HAVE_SETLOCALE)
18619 setlocale (LC_CTYPE, "");
18620#endif
18621 bindtextdomain (PACKAGE, LOCALEDIR);
18622 textdomain (PACKAGE);
18623
18624 expandargv (&argc, &argv);
18625
18626 parse_args (argc, argv);
18627
18628 if (num_dump_sects > 0)
18629 {
18630 /* Make a copy of the dump_sects array. */
18631 cmdline_dump_sects = (dump_type *)
18632 malloc (num_dump_sects * sizeof (* dump_sects));
18633 if (cmdline_dump_sects == NULL)
18634 error (_("Out of memory allocating dump request table.\n"));
18635 else
18636 {
18637 memcpy (cmdline_dump_sects, dump_sects,
18638 num_dump_sects * sizeof (* dump_sects));
18639 num_cmdline_dump_sects = num_dump_sects;
18640 }
18641 }
18642
18643 if (optind < (argc - 1))
18644 show_name = TRUE;
18645 else if (optind >= argc)
18646 {
18647 warn (_("Nothing to do.\n"));
18648 usage (stderr);
18649 }
18650
18651 err = FALSE;
18652 while (optind < argc)
18653 if (! process_file (argv[optind++]))
18654 err = TRUE;
18655
18656 if (dump_sects != NULL)
18657 free (dump_sects);
18658 if (cmdline_dump_sects != NULL)
18659 free (cmdline_dump_sects);
18660
18661 return err ? EXIT_FAILURE : EXIT_SUCCESS;
18662}
A mirror of the official binutils-gdb repository