]> 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
Update the handling of shift rotate and load/store multiple instructions in the...
[thirdparty/binutils-gdb.git] / binutils / readelf.c
... / ...
CommitLineData
1/* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2019 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#include "ctf-api.h"
64
65#include "elf/common.h"
66#include "elf/external.h"
67#include "elf/internal.h"
68
69
70/* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
71 we can obtain the H8 reloc numbers. We need these for the
72 get_reloc_size() function. We include h8.h again after defining
73 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
74
75#include "elf/h8.h"
76#undef _ELF_H8_H
77
78/* Undo the effects of #including reloc-macros.h. */
79
80#undef START_RELOC_NUMBERS
81#undef RELOC_NUMBER
82#undef FAKE_RELOC
83#undef EMPTY_RELOC
84#undef END_RELOC_NUMBERS
85#undef _RELOC_MACROS_H
86
87/* The following headers use the elf/reloc-macros.h file to
88 automatically generate relocation recognition functions
89 such as elf_mips_reloc_type() */
90
91#define RELOC_MACROS_GEN_FUNC
92
93#include "elf/aarch64.h"
94#include "elf/alpha.h"
95#include "elf/arc.h"
96#include "elf/arm.h"
97#include "elf/avr.h"
98#include "elf/bfin.h"
99#include "elf/cr16.h"
100#include "elf/cris.h"
101#include "elf/crx.h"
102#include "elf/csky.h"
103#include "elf/d10v.h"
104#include "elf/d30v.h"
105#include "elf/dlx.h"
106#include "elf/bpf.h"
107#include "elf/epiphany.h"
108#include "elf/fr30.h"
109#include "elf/frv.h"
110#include "elf/ft32.h"
111#include "elf/h8.h"
112#include "elf/hppa.h"
113#include "elf/i386.h"
114#include "elf/i370.h"
115#include "elf/i860.h"
116#include "elf/i960.h"
117#include "elf/ia64.h"
118#include "elf/ip2k.h"
119#include "elf/lm32.h"
120#include "elf/iq2000.h"
121#include "elf/m32c.h"
122#include "elf/m32r.h"
123#include "elf/m68k.h"
124#include "elf/m68hc11.h"
125#include "elf/s12z.h"
126#include "elf/mcore.h"
127#include "elf/mep.h"
128#include "elf/metag.h"
129#include "elf/microblaze.h"
130#include "elf/mips.h"
131#include "elf/mmix.h"
132#include "elf/mn10200.h"
133#include "elf/mn10300.h"
134#include "elf/moxie.h"
135#include "elf/mt.h"
136#include "elf/msp430.h"
137#include "elf/nds32.h"
138#include "elf/nfp.h"
139#include "elf/nios2.h"
140#include "elf/or1k.h"
141#include "elf/pj.h"
142#include "elf/ppc.h"
143#include "elf/ppc64.h"
144#include "elf/pru.h"
145#include "elf/riscv.h"
146#include "elf/rl78.h"
147#include "elf/rx.h"
148#include "elf/s390.h"
149#include "elf/score.h"
150#include "elf/sh.h"
151#include "elf/sparc.h"
152#include "elf/spu.h"
153#include "elf/tic6x.h"
154#include "elf/tilegx.h"
155#include "elf/tilepro.h"
156#include "elf/v850.h"
157#include "elf/vax.h"
158#include "elf/visium.h"
159#include "elf/wasm32.h"
160#include "elf/x86-64.h"
161#include "elf/xc16x.h"
162#include "elf/xgate.h"
163#include "elf/xstormy16.h"
164#include "elf/xtensa.h"
165
166#include "getopt.h"
167#include "libiberty.h"
168#include "safe-ctype.h"
169#include "filenames.h"
170
171#ifndef offsetof
172#define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
173#endif
174
175typedef struct elf_section_list
176{
177 Elf_Internal_Shdr * hdr;
178 struct elf_section_list * next;
179} elf_section_list;
180
181/* Flag bits indicating particular types of dump. */
182#define HEX_DUMP (1 << 0) /* The -x command line switch. */
183#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
184#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
185#define STRING_DUMP (1 << 3) /* The -p command line switch. */
186#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
187#define CTF_DUMP (1 << 5) /* The --ctf command line switch. */
188
189typedef unsigned char dump_type;
190
191/* A linked list of the section names for which dumps were requested. */
192struct dump_list_entry
193{
194 char * name;
195 dump_type type;
196 struct dump_list_entry * next;
197};
198
199typedef struct filedata
200{
201 const char * file_name;
202 FILE * handle;
203 bfd_size_type file_size;
204 Elf_Internal_Ehdr file_header;
205 Elf_Internal_Shdr * section_headers;
206 Elf_Internal_Phdr * program_headers;
207 char * string_table;
208 unsigned long string_table_length;
209 /* A dynamic array of flags indicating for which sections a dump of
210 some kind has been requested. It is reset on a per-object file
211 basis and then initialised from the cmdline_dump_sects array,
212 the results of interpreting the -w switch, and the
213 dump_sects_byname list. */
214 dump_type * dump_sects;
215 unsigned int num_dump_sects;
216} Filedata;
217
218char * program_name = "readelf";
219
220static unsigned long archive_file_offset;
221static unsigned long archive_file_size;
222static unsigned long dynamic_addr;
223static bfd_size_type dynamic_size;
224static size_t dynamic_nent;
225static char * dynamic_strings;
226static unsigned long dynamic_strings_length;
227static unsigned long num_dynamic_syms;
228static Elf_Internal_Sym * dynamic_symbols;
229static Elf_Internal_Syminfo * dynamic_syminfo;
230static unsigned long dynamic_syminfo_offset;
231static unsigned int dynamic_syminfo_nent;
232static char program_interpreter[PATH_MAX];
233static bfd_vma dynamic_info[DT_ENCODING];
234static bfd_vma dynamic_info_DT_GNU_HASH;
235static bfd_vma version_info[16];
236static Elf_Internal_Dyn * dynamic_section;
237static elf_section_list * symtab_shndx_list;
238static bfd_boolean show_name = FALSE;
239static bfd_boolean do_dynamic = FALSE;
240static bfd_boolean do_syms = FALSE;
241static bfd_boolean do_dyn_syms = FALSE;
242static bfd_boolean do_reloc = FALSE;
243static bfd_boolean do_sections = FALSE;
244static bfd_boolean do_section_groups = FALSE;
245static bfd_boolean do_section_details = FALSE;
246static bfd_boolean do_segments = FALSE;
247static bfd_boolean do_unwind = FALSE;
248static bfd_boolean do_using_dynamic = FALSE;
249static bfd_boolean do_header = FALSE;
250static bfd_boolean do_dump = FALSE;
251static bfd_boolean do_version = FALSE;
252static bfd_boolean do_histogram = FALSE;
253static bfd_boolean do_debugging = FALSE;
254static bfd_boolean do_ctf = FALSE;
255static bfd_boolean do_arch = FALSE;
256static bfd_boolean do_notes = FALSE;
257static bfd_boolean do_archive_index = FALSE;
258static bfd_boolean is_32bit_elf = FALSE;
259static bfd_boolean decompress_dumps = FALSE;
260
261static char *dump_ctf_parent_name;
262static char *dump_ctf_symtab_name;
263static char *dump_ctf_strtab_name;
264
265struct group_list
266{
267 struct group_list * next;
268 unsigned int section_index;
269};
270
271struct group
272{
273 struct group_list * root;
274 unsigned int group_index;
275};
276
277static size_t group_count;
278static struct group * section_groups;
279static struct group ** section_headers_groups;
280
281/* A dynamic array of flags indicating for which sections a dump
282 has been requested via command line switches. */
283static Filedata cmdline;
284
285static struct dump_list_entry * dump_sects_byname;
286
287/* How to print a vma value. */
288typedef enum print_mode
289{
290 HEX,
291 DEC,
292 DEC_5,
293 UNSIGNED,
294 PREFIX_HEX,
295 FULL_HEX,
296 LONG_HEX
297}
298print_mode;
299
300/* Versioned symbol info. */
301enum versioned_symbol_info
302{
303 symbol_undefined,
304 symbol_hidden,
305 symbol_public
306};
307
308static const char * get_symbol_version_string
309 (Filedata *, bfd_boolean, const char *, unsigned long, unsigned,
310 Elf_Internal_Sym *, enum versioned_symbol_info *, unsigned short *);
311
312#define UNKNOWN -1
313
314#define SECTION_NAME(X) \
315 ((X) == NULL ? _("<none>") \
316 : filedata->string_table == NULL ? _("<no-strings>") \
317 : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>") \
318 : filedata->string_table + (X)->sh_name))
319
320#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
321
322#define GET_ELF_SYMBOLS(file, section, sym_count) \
323 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
324 : get_64bit_elf_symbols (file, section, sym_count))
325
326#define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
327/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
328 already been called and verified that the string exists. */
329#define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
330
331#define REMOVE_ARCH_BITS(ADDR) \
332 do \
333 { \
334 if (filedata->file_header.e_machine == EM_ARM) \
335 (ADDR) &= ~1; \
336 } \
337 while (0)
338\f
339/* Print a BFD_VMA to an internal buffer, for use in error messages.
340 BFD_FMA_FMT can't be used in translated strings. */
341
342static const char *
343bfd_vmatoa (char *fmtch, bfd_vma value)
344{
345 /* bfd_vmatoa is used more then once in a printf call for output.
346 Cycle through an array of buffers. */
347 static int buf_pos = 0;
348 static struct bfd_vmatoa_buf
349 {
350 char place[64];
351 } buf[4];
352 char *ret;
353 char fmt[32];
354
355 ret = buf[buf_pos++].place;
356 buf_pos %= ARRAY_SIZE (buf);
357
358 sprintf (fmt, "%%%s%s", BFD_VMA_FMT, fmtch);
359 snprintf (ret, sizeof (buf[0].place), fmt, value);
360 return ret;
361}
362
363/* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
364 OFFSET + the offset of the current archive member, if we are examining an
365 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
366 allocate a buffer using malloc and fill that. In either case return the
367 pointer to the start of the retrieved data or NULL if something went wrong.
368 If something does go wrong and REASON is not NULL then emit an error
369 message using REASON as part of the context. */
370
371static void *
372get_data (void * var,
373 Filedata * filedata,
374 unsigned long offset,
375 bfd_size_type size,
376 bfd_size_type nmemb,
377 const char * reason)
378{
379 void * mvar;
380 bfd_size_type amt = size * nmemb;
381
382 if (size == 0 || nmemb == 0)
383 return NULL;
384
385 /* If the size_t type is smaller than the bfd_size_type, eg because
386 you are building a 32-bit tool on a 64-bit host, then make sure
387 that when the sizes are cast to (size_t) no information is lost. */
388 if ((size_t) size != size
389 || (size_t) nmemb != nmemb
390 || (size_t) amt != amt)
391 {
392 if (reason)
393 error (_("Size truncation prevents reading %s"
394 " elements of size %s for %s\n"),
395 bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
396 return NULL;
397 }
398
399 /* Check for size overflow. */
400 if (amt / size != nmemb || (size_t) amt + 1 == 0)
401 {
402 if (reason)
403 error (_("Size overflow prevents reading %s"
404 " elements of size %s for %s\n"),
405 bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
406 return NULL;
407 }
408
409 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
410 attempting to allocate memory when the read is bound to fail. */
411 if (archive_file_offset > filedata->file_size
412 || offset > filedata->file_size - archive_file_offset
413 || amt > filedata->file_size - archive_file_offset - offset)
414 {
415 if (reason)
416 error (_("Reading %s bytes extends past end of file for %s\n"),
417 bfd_vmatoa ("u", amt), reason);
418 return NULL;
419 }
420
421 if (fseek (filedata->handle, archive_file_offset + offset, SEEK_SET))
422 {
423 if (reason)
424 error (_("Unable to seek to 0x%lx for %s\n"),
425 archive_file_offset + offset, reason);
426 return NULL;
427 }
428
429 mvar = var;
430 if (mvar == NULL)
431 {
432 /* + 1 so that we can '\0' terminate invalid string table sections. */
433 mvar = malloc ((size_t) amt + 1);
434
435 if (mvar == NULL)
436 {
437 if (reason)
438 error (_("Out of memory allocating %s bytes for %s\n"),
439 bfd_vmatoa ("u", amt), reason);
440 return NULL;
441 }
442
443 ((char *) mvar)[amt] = '\0';
444 }
445
446 if (fread (mvar, (size_t) size, (size_t) nmemb, filedata->handle) != nmemb)
447 {
448 if (reason)
449 error (_("Unable to read in %s bytes of %s\n"),
450 bfd_vmatoa ("u", amt), reason);
451 if (mvar != var)
452 free (mvar);
453 return NULL;
454 }
455
456 return mvar;
457}
458
459/* Print a VMA value in the MODE specified.
460 Returns the number of characters displayed. */
461
462static unsigned int
463print_vma (bfd_vma vma, print_mode mode)
464{
465 unsigned int nc = 0;
466
467 switch (mode)
468 {
469 case FULL_HEX:
470 nc = printf ("0x");
471 /* Fall through. */
472 case LONG_HEX:
473#ifdef BFD64
474 if (is_32bit_elf)
475 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
476#endif
477 printf_vma (vma);
478 return nc + 16;
479
480 case DEC_5:
481 if (vma <= 99999)
482 return printf ("%5" BFD_VMA_FMT "d", vma);
483 /* Fall through. */
484 case PREFIX_HEX:
485 nc = printf ("0x");
486 /* Fall through. */
487 case HEX:
488 return nc + printf ("%" BFD_VMA_FMT "x", vma);
489
490 case DEC:
491 return printf ("%" BFD_VMA_FMT "d", vma);
492
493 case UNSIGNED:
494 return printf ("%" BFD_VMA_FMT "u", vma);
495
496 default:
497 /* FIXME: Report unrecognised mode ? */
498 return 0;
499 }
500}
501
502/* Display a symbol on stdout. Handles the display of control characters and
503 multibye characters (assuming the host environment supports them).
504
505 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
506
507 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
508 padding as necessary.
509
510 Returns the number of emitted characters. */
511
512static unsigned int
513print_symbol (signed int width, const char *symbol)
514{
515 bfd_boolean extra_padding = FALSE;
516 signed int num_printed = 0;
517#ifdef HAVE_MBSTATE_T
518 mbstate_t state;
519#endif
520 unsigned int width_remaining;
521
522 if (width < 0)
523 {
524 /* Keep the width positive. This helps the code below. */
525 width = - width;
526 extra_padding = TRUE;
527 }
528 else if (width == 0)
529 return 0;
530
531 if (do_wide)
532 /* Set the remaining width to a very large value.
533 This simplifies the code below. */
534 width_remaining = INT_MAX;
535 else
536 width_remaining = width;
537
538#ifdef HAVE_MBSTATE_T
539 /* Initialise the multibyte conversion state. */
540 memset (& state, 0, sizeof (state));
541#endif
542
543 while (width_remaining)
544 {
545 size_t n;
546 const char c = *symbol++;
547
548 if (c == 0)
549 break;
550
551 /* Do not print control characters directly as they can affect terminal
552 settings. Such characters usually appear in the names generated
553 by the assembler for local labels. */
554 if (ISCNTRL (c))
555 {
556 if (width_remaining < 2)
557 break;
558
559 printf ("^%c", c + 0x40);
560 width_remaining -= 2;
561 num_printed += 2;
562 }
563 else if (ISPRINT (c))
564 {
565 putchar (c);
566 width_remaining --;
567 num_printed ++;
568 }
569 else
570 {
571#ifdef HAVE_MBSTATE_T
572 wchar_t w;
573#endif
574 /* Let printf do the hard work of displaying multibyte characters. */
575 printf ("%.1s", symbol - 1);
576 width_remaining --;
577 num_printed ++;
578
579#ifdef HAVE_MBSTATE_T
580 /* Try to find out how many bytes made up the character that was
581 just printed. Advance the symbol pointer past the bytes that
582 were displayed. */
583 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
584#else
585 n = 1;
586#endif
587 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
588 symbol += (n - 1);
589 }
590 }
591
592 if (extra_padding && num_printed < width)
593 {
594 /* Fill in the remaining spaces. */
595 printf ("%-*s", width - num_printed, " ");
596 num_printed = width;
597 }
598
599 return num_printed;
600}
601
602/* Returns a pointer to a static buffer containing a printable version of
603 the given section's name. Like print_symbol, except that it does not try
604 to print multibyte characters, it just interprets them as hex values. */
605
606static const char *
607printable_section_name (Filedata * filedata, const Elf_Internal_Shdr * sec)
608{
609#define MAX_PRINT_SEC_NAME_LEN 128
610 static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
611 const char * name = SECTION_NAME (sec);
612 char * buf = sec_name_buf;
613 char c;
614 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
615
616 while ((c = * name ++) != 0)
617 {
618 if (ISCNTRL (c))
619 {
620 if (remaining < 2)
621 break;
622
623 * buf ++ = '^';
624 * buf ++ = c + 0x40;
625 remaining -= 2;
626 }
627 else if (ISPRINT (c))
628 {
629 * buf ++ = c;
630 remaining -= 1;
631 }
632 else
633 {
634 static char hex[17] = "0123456789ABCDEF";
635
636 if (remaining < 4)
637 break;
638 * buf ++ = '<';
639 * buf ++ = hex[(c & 0xf0) >> 4];
640 * buf ++ = hex[c & 0x0f];
641 * buf ++ = '>';
642 remaining -= 4;
643 }
644
645 if (remaining == 0)
646 break;
647 }
648
649 * buf = 0;
650 return sec_name_buf;
651}
652
653static const char *
654printable_section_name_from_index (Filedata * filedata, unsigned long ndx)
655{
656 if (ndx >= filedata->file_header.e_shnum)
657 return _("<corrupt>");
658
659 return printable_section_name (filedata, filedata->section_headers + ndx);
660}
661
662/* Return a pointer to section NAME, or NULL if no such section exists. */
663
664static Elf_Internal_Shdr *
665find_section (Filedata * filedata, const char * name)
666{
667 unsigned int i;
668
669 if (filedata->section_headers == NULL)
670 return NULL;
671
672 for (i = 0; i < filedata->file_header.e_shnum; i++)
673 if (streq (SECTION_NAME (filedata->section_headers + i), name))
674 return filedata->section_headers + i;
675
676 return NULL;
677}
678
679/* Return a pointer to a section containing ADDR, or NULL if no such
680 section exists. */
681
682static Elf_Internal_Shdr *
683find_section_by_address (Filedata * filedata, bfd_vma addr)
684{
685 unsigned int i;
686
687 if (filedata->section_headers == NULL)
688 return NULL;
689
690 for (i = 0; i < filedata->file_header.e_shnum; i++)
691 {
692 Elf_Internal_Shdr *sec = filedata->section_headers + i;
693
694 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
695 return sec;
696 }
697
698 return NULL;
699}
700
701static Elf_Internal_Shdr *
702find_section_by_type (Filedata * filedata, unsigned int type)
703{
704 unsigned int i;
705
706 if (filedata->section_headers == NULL)
707 return NULL;
708
709 for (i = 0; i < filedata->file_header.e_shnum; i++)
710 {
711 Elf_Internal_Shdr *sec = filedata->section_headers + i;
712
713 if (sec->sh_type == type)
714 return sec;
715 }
716
717 return NULL;
718}
719
720/* Return a pointer to section NAME, or NULL if no such section exists,
721 restricted to the list of sections given in SET. */
722
723static Elf_Internal_Shdr *
724find_section_in_set (Filedata * filedata, const char * name, unsigned int * set)
725{
726 unsigned int i;
727
728 if (filedata->section_headers == NULL)
729 return NULL;
730
731 if (set != NULL)
732 {
733 while ((i = *set++) > 0)
734 {
735 /* See PR 21156 for a reproducer. */
736 if (i >= filedata->file_header.e_shnum)
737 continue; /* FIXME: Should we issue an error message ? */
738
739 if (streq (SECTION_NAME (filedata->section_headers + i), name))
740 return filedata->section_headers + i;
741 }
742 }
743
744 return find_section (filedata, name);
745}
746
747/* Read an unsigned LEB128 encoded value from DATA.
748 Set *LENGTH_RETURN to the number of bytes read. */
749
750static inline unsigned long
751read_uleb128 (unsigned char * data,
752 unsigned int * length_return,
753 const unsigned char * const end)
754{
755 return read_leb128 (data, length_return, FALSE, end);
756}
757
758/* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
759 This OS has so many departures from the ELF standard that we test it at
760 many places. */
761
762static inline bfd_boolean
763is_ia64_vms (Filedata * filedata)
764{
765 return filedata->file_header.e_machine == EM_IA_64
766 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
767}
768
769/* Guess the relocation size commonly used by the specific machines. */
770
771static bfd_boolean
772guess_is_rela (unsigned int e_machine)
773{
774 switch (e_machine)
775 {
776 /* Targets that use REL relocations. */
777 case EM_386:
778 case EM_IAMCU:
779 case EM_960:
780 case EM_ARM:
781 case EM_D10V:
782 case EM_CYGNUS_D10V:
783 case EM_DLX:
784 case EM_MIPS:
785 case EM_MIPS_RS3_LE:
786 case EM_CYGNUS_M32R:
787 case EM_SCORE:
788 case EM_XGATE:
789 case EM_NFP:
790 case EM_BPF:
791 return FALSE;
792
793 /* Targets that use RELA relocations. */
794 case EM_68K:
795 case EM_860:
796 case EM_AARCH64:
797 case EM_ADAPTEVA_EPIPHANY:
798 case EM_ALPHA:
799 case EM_ALTERA_NIOS2:
800 case EM_ARC:
801 case EM_ARC_COMPACT:
802 case EM_ARC_COMPACT2:
803 case EM_AVR:
804 case EM_AVR_OLD:
805 case EM_BLACKFIN:
806 case EM_CR16:
807 case EM_CRIS:
808 case EM_CRX:
809 case EM_CSKY:
810 case EM_D30V:
811 case EM_CYGNUS_D30V:
812 case EM_FR30:
813 case EM_FT32:
814 case EM_CYGNUS_FR30:
815 case EM_CYGNUS_FRV:
816 case EM_H8S:
817 case EM_H8_300:
818 case EM_H8_300H:
819 case EM_IA_64:
820 case EM_IP2K:
821 case EM_IP2K_OLD:
822 case EM_IQ2000:
823 case EM_LATTICEMICO32:
824 case EM_M32C_OLD:
825 case EM_M32C:
826 case EM_M32R:
827 case EM_MCORE:
828 case EM_CYGNUS_MEP:
829 case EM_METAG:
830 case EM_MMIX:
831 case EM_MN10200:
832 case EM_CYGNUS_MN10200:
833 case EM_MN10300:
834 case EM_CYGNUS_MN10300:
835 case EM_MOXIE:
836 case EM_MSP430:
837 case EM_MSP430_OLD:
838 case EM_MT:
839 case EM_NDS32:
840 case EM_NIOS32:
841 case EM_OR1K:
842 case EM_PPC64:
843 case EM_PPC:
844 case EM_TI_PRU:
845 case EM_RISCV:
846 case EM_RL78:
847 case EM_RX:
848 case EM_S390:
849 case EM_S390_OLD:
850 case EM_SH:
851 case EM_SPARC:
852 case EM_SPARC32PLUS:
853 case EM_SPARCV9:
854 case EM_SPU:
855 case EM_TI_C6000:
856 case EM_TILEGX:
857 case EM_TILEPRO:
858 case EM_V800:
859 case EM_V850:
860 case EM_CYGNUS_V850:
861 case EM_VAX:
862 case EM_VISIUM:
863 case EM_X86_64:
864 case EM_L1OM:
865 case EM_K1OM:
866 case EM_XSTORMY16:
867 case EM_XTENSA:
868 case EM_XTENSA_OLD:
869 case EM_MICROBLAZE:
870 case EM_MICROBLAZE_OLD:
871 case EM_WEBASSEMBLY:
872 return TRUE;
873
874 case EM_68HC05:
875 case EM_68HC08:
876 case EM_68HC11:
877 case EM_68HC16:
878 case EM_FX66:
879 case EM_ME16:
880 case EM_MMA:
881 case EM_NCPU:
882 case EM_NDR1:
883 case EM_PCP:
884 case EM_ST100:
885 case EM_ST19:
886 case EM_ST7:
887 case EM_ST9PLUS:
888 case EM_STARCORE:
889 case EM_SVX:
890 case EM_TINYJ:
891 default:
892 warn (_("Don't know about relocations on this machine architecture\n"));
893 return FALSE;
894 }
895}
896
897/* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
898 Returns TRUE upon success, FALSE otherwise. If successful then a
899 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
900 and the number of relocs loaded is placed in *NRELASP. It is the caller's
901 responsibility to free the allocated buffer. */
902
903static bfd_boolean
904slurp_rela_relocs (Filedata * filedata,
905 unsigned long rel_offset,
906 unsigned long rel_size,
907 Elf_Internal_Rela ** relasp,
908 unsigned long * nrelasp)
909{
910 Elf_Internal_Rela * relas;
911 size_t nrelas;
912 unsigned int i;
913
914 if (is_32bit_elf)
915 {
916 Elf32_External_Rela * erelas;
917
918 erelas = (Elf32_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
919 rel_size, _("32-bit relocation data"));
920 if (!erelas)
921 return FALSE;
922
923 nrelas = rel_size / sizeof (Elf32_External_Rela);
924
925 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
926 sizeof (Elf_Internal_Rela));
927
928 if (relas == NULL)
929 {
930 free (erelas);
931 error (_("out of memory parsing relocs\n"));
932 return FALSE;
933 }
934
935 for (i = 0; i < nrelas; i++)
936 {
937 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
938 relas[i].r_info = BYTE_GET (erelas[i].r_info);
939 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
940 }
941
942 free (erelas);
943 }
944 else
945 {
946 Elf64_External_Rela * erelas;
947
948 erelas = (Elf64_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
949 rel_size, _("64-bit relocation data"));
950 if (!erelas)
951 return FALSE;
952
953 nrelas = rel_size / sizeof (Elf64_External_Rela);
954
955 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
956 sizeof (Elf_Internal_Rela));
957
958 if (relas == NULL)
959 {
960 free (erelas);
961 error (_("out of memory parsing relocs\n"));
962 return FALSE;
963 }
964
965 for (i = 0; i < nrelas; i++)
966 {
967 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
968 relas[i].r_info = BYTE_GET (erelas[i].r_info);
969 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
970
971 /* The #ifdef BFD64 below is to prevent a compile time
972 warning. We know that if we do not have a 64 bit data
973 type that we will never execute this code anyway. */
974#ifdef BFD64
975 if (filedata->file_header.e_machine == EM_MIPS
976 && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
977 {
978 /* In little-endian objects, r_info isn't really a
979 64-bit little-endian value: it has a 32-bit
980 little-endian symbol index followed by four
981 individual byte fields. Reorder INFO
982 accordingly. */
983 bfd_vma inf = relas[i].r_info;
984 inf = (((inf & 0xffffffff) << 32)
985 | ((inf >> 56) & 0xff)
986 | ((inf >> 40) & 0xff00)
987 | ((inf >> 24) & 0xff0000)
988 | ((inf >> 8) & 0xff000000));
989 relas[i].r_info = inf;
990 }
991#endif /* BFD64 */
992 }
993
994 free (erelas);
995 }
996
997 *relasp = relas;
998 *nrelasp = nrelas;
999 return TRUE;
1000}
1001
1002/* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1003 Returns TRUE upon success, FALSE otherwise. If successful then a
1004 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1005 and the number of relocs loaded is placed in *NRELSP. It is the caller's
1006 responsibility to free the allocated buffer. */
1007
1008static bfd_boolean
1009slurp_rel_relocs (Filedata * filedata,
1010 unsigned long rel_offset,
1011 unsigned long rel_size,
1012 Elf_Internal_Rela ** relsp,
1013 unsigned long * nrelsp)
1014{
1015 Elf_Internal_Rela * rels;
1016 size_t nrels;
1017 unsigned int i;
1018
1019 if (is_32bit_elf)
1020 {
1021 Elf32_External_Rel * erels;
1022
1023 erels = (Elf32_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1024 rel_size, _("32-bit relocation data"));
1025 if (!erels)
1026 return FALSE;
1027
1028 nrels = rel_size / sizeof (Elf32_External_Rel);
1029
1030 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1031
1032 if (rels == NULL)
1033 {
1034 free (erels);
1035 error (_("out of memory parsing relocs\n"));
1036 return FALSE;
1037 }
1038
1039 for (i = 0; i < nrels; i++)
1040 {
1041 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1042 rels[i].r_info = BYTE_GET (erels[i].r_info);
1043 rels[i].r_addend = 0;
1044 }
1045
1046 free (erels);
1047 }
1048 else
1049 {
1050 Elf64_External_Rel * erels;
1051
1052 erels = (Elf64_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1053 rel_size, _("64-bit relocation data"));
1054 if (!erels)
1055 return FALSE;
1056
1057 nrels = rel_size / sizeof (Elf64_External_Rel);
1058
1059 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1060
1061 if (rels == NULL)
1062 {
1063 free (erels);
1064 error (_("out of memory parsing relocs\n"));
1065 return FALSE;
1066 }
1067
1068 for (i = 0; i < nrels; i++)
1069 {
1070 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1071 rels[i].r_info = BYTE_GET (erels[i].r_info);
1072 rels[i].r_addend = 0;
1073
1074 /* The #ifdef BFD64 below is to prevent a compile time
1075 warning. We know that if we do not have a 64 bit data
1076 type that we will never execute this code anyway. */
1077#ifdef BFD64
1078 if (filedata->file_header.e_machine == EM_MIPS
1079 && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
1080 {
1081 /* In little-endian objects, r_info isn't really a
1082 64-bit little-endian value: it has a 32-bit
1083 little-endian symbol index followed by four
1084 individual byte fields. Reorder INFO
1085 accordingly. */
1086 bfd_vma inf = rels[i].r_info;
1087 inf = (((inf & 0xffffffff) << 32)
1088 | ((inf >> 56) & 0xff)
1089 | ((inf >> 40) & 0xff00)
1090 | ((inf >> 24) & 0xff0000)
1091 | ((inf >> 8) & 0xff000000));
1092 rels[i].r_info = inf;
1093 }
1094#endif /* BFD64 */
1095 }
1096
1097 free (erels);
1098 }
1099
1100 *relsp = rels;
1101 *nrelsp = nrels;
1102 return TRUE;
1103}
1104
1105/* Returns the reloc type extracted from the reloc info field. */
1106
1107static unsigned int
1108get_reloc_type (Filedata * filedata, bfd_vma reloc_info)
1109{
1110 if (is_32bit_elf)
1111 return ELF32_R_TYPE (reloc_info);
1112
1113 switch (filedata->file_header.e_machine)
1114 {
1115 case EM_MIPS:
1116 /* Note: We assume that reloc_info has already been adjusted for us. */
1117 return ELF64_MIPS_R_TYPE (reloc_info);
1118
1119 case EM_SPARCV9:
1120 return ELF64_R_TYPE_ID (reloc_info);
1121
1122 default:
1123 return ELF64_R_TYPE (reloc_info);
1124 }
1125}
1126
1127/* Return the symbol index extracted from the reloc info field. */
1128
1129static bfd_vma
1130get_reloc_symindex (bfd_vma reloc_info)
1131{
1132 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1133}
1134
1135static inline bfd_boolean
1136uses_msp430x_relocs (Filedata * filedata)
1137{
1138 return
1139 filedata->file_header.e_machine == EM_MSP430 /* Paranoia. */
1140 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1141 && (((filedata->file_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1142 /* TI compiler uses ELFOSABI_NONE. */
1143 || (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1144}
1145
1146/* Display the contents of the relocation data found at the specified
1147 offset. */
1148
1149static bfd_boolean
1150dump_relocations (Filedata * filedata,
1151 unsigned long rel_offset,
1152 unsigned long rel_size,
1153 Elf_Internal_Sym * symtab,
1154 unsigned long nsyms,
1155 char * strtab,
1156 unsigned long strtablen,
1157 int is_rela,
1158 bfd_boolean is_dynsym)
1159{
1160 unsigned long i;
1161 Elf_Internal_Rela * rels;
1162 bfd_boolean res = TRUE;
1163
1164 if (is_rela == UNKNOWN)
1165 is_rela = guess_is_rela (filedata->file_header.e_machine);
1166
1167 if (is_rela)
1168 {
1169 if (!slurp_rela_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1170 return FALSE;
1171 }
1172 else
1173 {
1174 if (!slurp_rel_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1175 return FALSE;
1176 }
1177
1178 if (is_32bit_elf)
1179 {
1180 if (is_rela)
1181 {
1182 if (do_wide)
1183 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1184 else
1185 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1186 }
1187 else
1188 {
1189 if (do_wide)
1190 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1191 else
1192 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1193 }
1194 }
1195 else
1196 {
1197 if (is_rela)
1198 {
1199 if (do_wide)
1200 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1201 else
1202 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1203 }
1204 else
1205 {
1206 if (do_wide)
1207 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1208 else
1209 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1210 }
1211 }
1212
1213 for (i = 0; i < rel_size; i++)
1214 {
1215 const char * rtype;
1216 bfd_vma offset;
1217 bfd_vma inf;
1218 bfd_vma symtab_index;
1219 bfd_vma type;
1220
1221 offset = rels[i].r_offset;
1222 inf = rels[i].r_info;
1223
1224 type = get_reloc_type (filedata, inf);
1225 symtab_index = get_reloc_symindex (inf);
1226
1227 if (is_32bit_elf)
1228 {
1229 printf ("%8.8lx %8.8lx ",
1230 (unsigned long) offset & 0xffffffff,
1231 (unsigned long) inf & 0xffffffff);
1232 }
1233 else
1234 {
1235#if BFD_HOST_64BIT_LONG
1236 printf (do_wide
1237 ? "%16.16lx %16.16lx "
1238 : "%12.12lx %12.12lx ",
1239 offset, inf);
1240#elif BFD_HOST_64BIT_LONG_LONG
1241#ifndef __MSVCRT__
1242 printf (do_wide
1243 ? "%16.16llx %16.16llx "
1244 : "%12.12llx %12.12llx ",
1245 offset, inf);
1246#else
1247 printf (do_wide
1248 ? "%16.16I64x %16.16I64x "
1249 : "%12.12I64x %12.12I64x ",
1250 offset, inf);
1251#endif
1252#else
1253 printf (do_wide
1254 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1255 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1256 _bfd_int64_high (offset),
1257 _bfd_int64_low (offset),
1258 _bfd_int64_high (inf),
1259 _bfd_int64_low (inf));
1260#endif
1261 }
1262
1263 switch (filedata->file_header.e_machine)
1264 {
1265 default:
1266 rtype = NULL;
1267 break;
1268
1269 case EM_AARCH64:
1270 rtype = elf_aarch64_reloc_type (type);
1271 break;
1272
1273 case EM_M32R:
1274 case EM_CYGNUS_M32R:
1275 rtype = elf_m32r_reloc_type (type);
1276 break;
1277
1278 case EM_386:
1279 case EM_IAMCU:
1280 rtype = elf_i386_reloc_type (type);
1281 break;
1282
1283 case EM_68HC11:
1284 case EM_68HC12:
1285 rtype = elf_m68hc11_reloc_type (type);
1286 break;
1287
1288 case EM_S12Z:
1289 rtype = elf_s12z_reloc_type (type);
1290 break;
1291
1292 case EM_68K:
1293 rtype = elf_m68k_reloc_type (type);
1294 break;
1295
1296 case EM_960:
1297 rtype = elf_i960_reloc_type (type);
1298 break;
1299
1300 case EM_AVR:
1301 case EM_AVR_OLD:
1302 rtype = elf_avr_reloc_type (type);
1303 break;
1304
1305 case EM_OLD_SPARCV9:
1306 case EM_SPARC32PLUS:
1307 case EM_SPARCV9:
1308 case EM_SPARC:
1309 rtype = elf_sparc_reloc_type (type);
1310 break;
1311
1312 case EM_SPU:
1313 rtype = elf_spu_reloc_type (type);
1314 break;
1315
1316 case EM_V800:
1317 rtype = v800_reloc_type (type);
1318 break;
1319 case EM_V850:
1320 case EM_CYGNUS_V850:
1321 rtype = v850_reloc_type (type);
1322 break;
1323
1324 case EM_D10V:
1325 case EM_CYGNUS_D10V:
1326 rtype = elf_d10v_reloc_type (type);
1327 break;
1328
1329 case EM_D30V:
1330 case EM_CYGNUS_D30V:
1331 rtype = elf_d30v_reloc_type (type);
1332 break;
1333
1334 case EM_DLX:
1335 rtype = elf_dlx_reloc_type (type);
1336 break;
1337
1338 case EM_SH:
1339 rtype = elf_sh_reloc_type (type);
1340 break;
1341
1342 case EM_MN10300:
1343 case EM_CYGNUS_MN10300:
1344 rtype = elf_mn10300_reloc_type (type);
1345 break;
1346
1347 case EM_MN10200:
1348 case EM_CYGNUS_MN10200:
1349 rtype = elf_mn10200_reloc_type (type);
1350 break;
1351
1352 case EM_FR30:
1353 case EM_CYGNUS_FR30:
1354 rtype = elf_fr30_reloc_type (type);
1355 break;
1356
1357 case EM_CYGNUS_FRV:
1358 rtype = elf_frv_reloc_type (type);
1359 break;
1360
1361 case EM_CSKY:
1362 rtype = elf_csky_reloc_type (type);
1363 break;
1364
1365 case EM_FT32:
1366 rtype = elf_ft32_reloc_type (type);
1367 break;
1368
1369 case EM_MCORE:
1370 rtype = elf_mcore_reloc_type (type);
1371 break;
1372
1373 case EM_MMIX:
1374 rtype = elf_mmix_reloc_type (type);
1375 break;
1376
1377 case EM_MOXIE:
1378 rtype = elf_moxie_reloc_type (type);
1379 break;
1380
1381 case EM_MSP430:
1382 if (uses_msp430x_relocs (filedata))
1383 {
1384 rtype = elf_msp430x_reloc_type (type);
1385 break;
1386 }
1387 /* Fall through. */
1388 case EM_MSP430_OLD:
1389 rtype = elf_msp430_reloc_type (type);
1390 break;
1391
1392 case EM_NDS32:
1393 rtype = elf_nds32_reloc_type (type);
1394 break;
1395
1396 case EM_PPC:
1397 rtype = elf_ppc_reloc_type (type);
1398 break;
1399
1400 case EM_PPC64:
1401 rtype = elf_ppc64_reloc_type (type);
1402 break;
1403
1404 case EM_MIPS:
1405 case EM_MIPS_RS3_LE:
1406 rtype = elf_mips_reloc_type (type);
1407 break;
1408
1409 case EM_RISCV:
1410 rtype = elf_riscv_reloc_type (type);
1411 break;
1412
1413 case EM_ALPHA:
1414 rtype = elf_alpha_reloc_type (type);
1415 break;
1416
1417 case EM_ARM:
1418 rtype = elf_arm_reloc_type (type);
1419 break;
1420
1421 case EM_ARC:
1422 case EM_ARC_COMPACT:
1423 case EM_ARC_COMPACT2:
1424 rtype = elf_arc_reloc_type (type);
1425 break;
1426
1427 case EM_PARISC:
1428 rtype = elf_hppa_reloc_type (type);
1429 break;
1430
1431 case EM_H8_300:
1432 case EM_H8_300H:
1433 case EM_H8S:
1434 rtype = elf_h8_reloc_type (type);
1435 break;
1436
1437 case EM_OR1K:
1438 rtype = elf_or1k_reloc_type (type);
1439 break;
1440
1441 case EM_PJ:
1442 case EM_PJ_OLD:
1443 rtype = elf_pj_reloc_type (type);
1444 break;
1445 case EM_IA_64:
1446 rtype = elf_ia64_reloc_type (type);
1447 break;
1448
1449 case EM_CRIS:
1450 rtype = elf_cris_reloc_type (type);
1451 break;
1452
1453 case EM_860:
1454 rtype = elf_i860_reloc_type (type);
1455 break;
1456
1457 case EM_X86_64:
1458 case EM_L1OM:
1459 case EM_K1OM:
1460 rtype = elf_x86_64_reloc_type (type);
1461 break;
1462
1463 case EM_S370:
1464 rtype = i370_reloc_type (type);
1465 break;
1466
1467 case EM_S390_OLD:
1468 case EM_S390:
1469 rtype = elf_s390_reloc_type (type);
1470 break;
1471
1472 case EM_SCORE:
1473 rtype = elf_score_reloc_type (type);
1474 break;
1475
1476 case EM_XSTORMY16:
1477 rtype = elf_xstormy16_reloc_type (type);
1478 break;
1479
1480 case EM_CRX:
1481 rtype = elf_crx_reloc_type (type);
1482 break;
1483
1484 case EM_VAX:
1485 rtype = elf_vax_reloc_type (type);
1486 break;
1487
1488 case EM_VISIUM:
1489 rtype = elf_visium_reloc_type (type);
1490 break;
1491
1492 case EM_BPF:
1493 rtype = elf_bpf_reloc_type (type);
1494 break;
1495
1496 case EM_ADAPTEVA_EPIPHANY:
1497 rtype = elf_epiphany_reloc_type (type);
1498 break;
1499
1500 case EM_IP2K:
1501 case EM_IP2K_OLD:
1502 rtype = elf_ip2k_reloc_type (type);
1503 break;
1504
1505 case EM_IQ2000:
1506 rtype = elf_iq2000_reloc_type (type);
1507 break;
1508
1509 case EM_XTENSA_OLD:
1510 case EM_XTENSA:
1511 rtype = elf_xtensa_reloc_type (type);
1512 break;
1513
1514 case EM_LATTICEMICO32:
1515 rtype = elf_lm32_reloc_type (type);
1516 break;
1517
1518 case EM_M32C_OLD:
1519 case EM_M32C:
1520 rtype = elf_m32c_reloc_type (type);
1521 break;
1522
1523 case EM_MT:
1524 rtype = elf_mt_reloc_type (type);
1525 break;
1526
1527 case EM_BLACKFIN:
1528 rtype = elf_bfin_reloc_type (type);
1529 break;
1530
1531 case EM_CYGNUS_MEP:
1532 rtype = elf_mep_reloc_type (type);
1533 break;
1534
1535 case EM_CR16:
1536 rtype = elf_cr16_reloc_type (type);
1537 break;
1538
1539 case EM_MICROBLAZE:
1540 case EM_MICROBLAZE_OLD:
1541 rtype = elf_microblaze_reloc_type (type);
1542 break;
1543
1544 case EM_RL78:
1545 rtype = elf_rl78_reloc_type (type);
1546 break;
1547
1548 case EM_RX:
1549 rtype = elf_rx_reloc_type (type);
1550 break;
1551
1552 case EM_METAG:
1553 rtype = elf_metag_reloc_type (type);
1554 break;
1555
1556 case EM_XC16X:
1557 case EM_C166:
1558 rtype = elf_xc16x_reloc_type (type);
1559 break;
1560
1561 case EM_TI_C6000:
1562 rtype = elf_tic6x_reloc_type (type);
1563 break;
1564
1565 case EM_TILEGX:
1566 rtype = elf_tilegx_reloc_type (type);
1567 break;
1568
1569 case EM_TILEPRO:
1570 rtype = elf_tilepro_reloc_type (type);
1571 break;
1572
1573 case EM_WEBASSEMBLY:
1574 rtype = elf_wasm32_reloc_type (type);
1575 break;
1576
1577 case EM_XGATE:
1578 rtype = elf_xgate_reloc_type (type);
1579 break;
1580
1581 case EM_ALTERA_NIOS2:
1582 rtype = elf_nios2_reloc_type (type);
1583 break;
1584
1585 case EM_TI_PRU:
1586 rtype = elf_pru_reloc_type (type);
1587 break;
1588
1589 case EM_NFP:
1590 if (EF_NFP_MACH (filedata->file_header.e_flags) == E_NFP_MACH_3200)
1591 rtype = elf_nfp3200_reloc_type (type);
1592 else
1593 rtype = elf_nfp_reloc_type (type);
1594 break;
1595 }
1596
1597 if (rtype == NULL)
1598 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1599 else
1600 printf (do_wide ? "%-22s" : "%-17.17s", rtype);
1601
1602 if (filedata->file_header.e_machine == EM_ALPHA
1603 && rtype != NULL
1604 && streq (rtype, "R_ALPHA_LITUSE")
1605 && is_rela)
1606 {
1607 switch (rels[i].r_addend)
1608 {
1609 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1610 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1611 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1612 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1613 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1614 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1615 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1616 default: rtype = NULL;
1617 }
1618
1619 if (rtype)
1620 printf (" (%s)", rtype);
1621 else
1622 {
1623 putchar (' ');
1624 printf (_("<unknown addend: %lx>"),
1625 (unsigned long) rels[i].r_addend);
1626 res = FALSE;
1627 }
1628 }
1629 else if (symtab_index)
1630 {
1631 if (symtab == NULL || symtab_index >= nsyms)
1632 {
1633 error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index);
1634 res = FALSE;
1635 }
1636 else
1637 {
1638 Elf_Internal_Sym * psym;
1639 const char * version_string;
1640 enum versioned_symbol_info sym_info;
1641 unsigned short vna_other;
1642
1643 psym = symtab + symtab_index;
1644
1645 version_string
1646 = get_symbol_version_string (filedata, is_dynsym,
1647 strtab, strtablen,
1648 symtab_index,
1649 psym,
1650 &sym_info,
1651 &vna_other);
1652
1653 printf (" ");
1654
1655 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1656 {
1657 const char * name;
1658 unsigned int len;
1659 unsigned int width = is_32bit_elf ? 8 : 14;
1660
1661 /* Relocations against GNU_IFUNC symbols do not use the value
1662 of the symbol as the address to relocate against. Instead
1663 they invoke the function named by the symbol and use its
1664 result as the address for relocation.
1665
1666 To indicate this to the user, do not display the value of
1667 the symbol in the "Symbols's Value" field. Instead show
1668 its name followed by () as a hint that the symbol is
1669 invoked. */
1670
1671 if (strtab == NULL
1672 || psym->st_name == 0
1673 || psym->st_name >= strtablen)
1674 name = "??";
1675 else
1676 name = strtab + psym->st_name;
1677
1678 len = print_symbol (width, name);
1679 if (version_string)
1680 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1681 version_string);
1682 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1683 }
1684 else
1685 {
1686 print_vma (psym->st_value, LONG_HEX);
1687
1688 printf (is_32bit_elf ? " " : " ");
1689 }
1690
1691 if (psym->st_name == 0)
1692 {
1693 const char * sec_name = "<null>";
1694 char name_buf[40];
1695
1696 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1697 {
1698 if (psym->st_shndx < filedata->file_header.e_shnum)
1699 sec_name = SECTION_NAME (filedata->section_headers + psym->st_shndx);
1700 else if (psym->st_shndx == SHN_ABS)
1701 sec_name = "ABS";
1702 else if (psym->st_shndx == SHN_COMMON)
1703 sec_name = "COMMON";
1704 else if ((filedata->file_header.e_machine == EM_MIPS
1705 && psym->st_shndx == SHN_MIPS_SCOMMON)
1706 || (filedata->file_header.e_machine == EM_TI_C6000
1707 && psym->st_shndx == SHN_TIC6X_SCOMMON))
1708 sec_name = "SCOMMON";
1709 else if (filedata->file_header.e_machine == EM_MIPS
1710 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1711 sec_name = "SUNDEF";
1712 else if ((filedata->file_header.e_machine == EM_X86_64
1713 || filedata->file_header.e_machine == EM_L1OM
1714 || filedata->file_header.e_machine == EM_K1OM)
1715 && psym->st_shndx == SHN_X86_64_LCOMMON)
1716 sec_name = "LARGE_COMMON";
1717 else if (filedata->file_header.e_machine == EM_IA_64
1718 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1719 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1720 sec_name = "ANSI_COM";
1721 else if (is_ia64_vms (filedata)
1722 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1723 sec_name = "VMS_SYMVEC";
1724 else
1725 {
1726 sprintf (name_buf, "<section 0x%x>",
1727 (unsigned int) psym->st_shndx);
1728 sec_name = name_buf;
1729 }
1730 }
1731 print_symbol (22, sec_name);
1732 }
1733 else if (strtab == NULL)
1734 printf (_("<string table index: %3ld>"), psym->st_name);
1735 else if (psym->st_name >= strtablen)
1736 {
1737 error (_("<corrupt string table index: %3ld>"), psym->st_name);
1738 res = FALSE;
1739 }
1740 else
1741 {
1742 print_symbol (22, strtab + psym->st_name);
1743 if (version_string)
1744 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1745 version_string);
1746 }
1747
1748 if (is_rela)
1749 {
1750 bfd_vma off = rels[i].r_addend;
1751
1752 if ((bfd_signed_vma) off < 0)
1753 printf (" - %" BFD_VMA_FMT "x", - off);
1754 else
1755 printf (" + %" BFD_VMA_FMT "x", off);
1756 }
1757 }
1758 }
1759 else if (is_rela)
1760 {
1761 bfd_vma off = rels[i].r_addend;
1762
1763 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1764 if ((bfd_signed_vma) off < 0)
1765 printf ("-%" BFD_VMA_FMT "x", - off);
1766 else
1767 printf ("%" BFD_VMA_FMT "x", off);
1768 }
1769
1770 if (filedata->file_header.e_machine == EM_SPARCV9
1771 && rtype != NULL
1772 && streq (rtype, "R_SPARC_OLO10"))
1773 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1774
1775 putchar ('\n');
1776
1777#ifdef BFD64
1778 if (! is_32bit_elf && filedata->file_header.e_machine == EM_MIPS)
1779 {
1780 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1781 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1782 const char * rtype2 = elf_mips_reloc_type (type2);
1783 const char * rtype3 = elf_mips_reloc_type (type3);
1784
1785 printf (" Type2: ");
1786
1787 if (rtype2 == NULL)
1788 printf (_("unrecognized: %-7lx"),
1789 (unsigned long) type2 & 0xffffffff);
1790 else
1791 printf ("%-17.17s", rtype2);
1792
1793 printf ("\n Type3: ");
1794
1795 if (rtype3 == NULL)
1796 printf (_("unrecognized: %-7lx"),
1797 (unsigned long) type3 & 0xffffffff);
1798 else
1799 printf ("%-17.17s", rtype3);
1800
1801 putchar ('\n');
1802 }
1803#endif /* BFD64 */
1804 }
1805
1806 free (rels);
1807
1808 return res;
1809}
1810
1811static const char *
1812get_aarch64_dynamic_type (unsigned long type)
1813{
1814 switch (type)
1815 {
1816 case DT_AARCH64_BTI_PLT: return "AARCH64_BTI_PLT";
1817 case DT_AARCH64_PAC_PLT: return "AARCH64_PAC_PLT";
1818 case DT_AARCH64_VARIANT_PCS: return "AARCH64_VARIANT_PCS";
1819 default:
1820 return NULL;
1821 }
1822}
1823
1824static const char *
1825get_mips_dynamic_type (unsigned long type)
1826{
1827 switch (type)
1828 {
1829 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1830 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1831 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1832 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1833 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1834 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1835 case DT_MIPS_MSYM: return "MIPS_MSYM";
1836 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1837 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1838 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1839 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1840 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1841 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1842 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1843 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1844 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1845 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1846 case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
1847 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1848 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1849 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1850 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1851 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1852 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1853 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1854 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1855 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1856 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1857 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1858 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1859 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1860 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1861 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1862 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1863 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1864 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1865 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1866 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1867 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1868 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1869 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1870 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1871 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1872 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1873 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1874 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1875 default:
1876 return NULL;
1877 }
1878}
1879
1880static const char *
1881get_sparc64_dynamic_type (unsigned long type)
1882{
1883 switch (type)
1884 {
1885 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1886 default:
1887 return NULL;
1888 }
1889}
1890
1891static const char *
1892get_ppc_dynamic_type (unsigned long type)
1893{
1894 switch (type)
1895 {
1896 case DT_PPC_GOT: return "PPC_GOT";
1897 case DT_PPC_OPT: return "PPC_OPT";
1898 default:
1899 return NULL;
1900 }
1901}
1902
1903static const char *
1904get_ppc64_dynamic_type (unsigned long type)
1905{
1906 switch (type)
1907 {
1908 case DT_PPC64_GLINK: return "PPC64_GLINK";
1909 case DT_PPC64_OPD: return "PPC64_OPD";
1910 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1911 case DT_PPC64_OPT: return "PPC64_OPT";
1912 default:
1913 return NULL;
1914 }
1915}
1916
1917static const char *
1918get_parisc_dynamic_type (unsigned long type)
1919{
1920 switch (type)
1921 {
1922 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1923 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1924 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1925 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1926 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1927 case DT_HP_PREINIT: return "HP_PREINIT";
1928 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1929 case DT_HP_NEEDED: return "HP_NEEDED";
1930 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1931 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1932 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1933 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1934 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1935 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1936 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1937 case DT_HP_FILTERED: return "HP_FILTERED";
1938 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1939 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1940 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1941 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1942 case DT_PLT: return "PLT";
1943 case DT_PLT_SIZE: return "PLT_SIZE";
1944 case DT_DLT: return "DLT";
1945 case DT_DLT_SIZE: return "DLT_SIZE";
1946 default:
1947 return NULL;
1948 }
1949}
1950
1951static const char *
1952get_ia64_dynamic_type (unsigned long type)
1953{
1954 switch (type)
1955 {
1956 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1957 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1958 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1959 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1960 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1961 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1962 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1963 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1964 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1965 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1966 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1967 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1968 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1969 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1970 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1971 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1972 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1973 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1974 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1975 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1976 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1977 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1978 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1979 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1980 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1981 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1982 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1983 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1984 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1985 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1986 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
1987 default:
1988 return NULL;
1989 }
1990}
1991
1992static const char *
1993get_solaris_section_type (unsigned long type)
1994{
1995 switch (type)
1996 {
1997 case 0x6fffffee: return "SUNW_ancillary";
1998 case 0x6fffffef: return "SUNW_capchain";
1999 case 0x6ffffff0: return "SUNW_capinfo";
2000 case 0x6ffffff1: return "SUNW_symsort";
2001 case 0x6ffffff2: return "SUNW_tlssort";
2002 case 0x6ffffff3: return "SUNW_LDYNSYM";
2003 case 0x6ffffff4: return "SUNW_dof";
2004 case 0x6ffffff5: return "SUNW_cap";
2005 case 0x6ffffff6: return "SUNW_SIGNATURE";
2006 case 0x6ffffff7: return "SUNW_ANNOTATE";
2007 case 0x6ffffff8: return "SUNW_DEBUGSTR";
2008 case 0x6ffffff9: return "SUNW_DEBUG";
2009 case 0x6ffffffa: return "SUNW_move";
2010 case 0x6ffffffb: return "SUNW_COMDAT";
2011 case 0x6ffffffc: return "SUNW_syminfo";
2012 case 0x6ffffffd: return "SUNW_verdef";
2013 case 0x6ffffffe: return "SUNW_verneed";
2014 case 0x6fffffff: return "SUNW_versym";
2015 case 0x70000000: return "SPARC_GOTDATA";
2016 default: return NULL;
2017 }
2018}
2019
2020static const char *
2021get_alpha_dynamic_type (unsigned long type)
2022{
2023 switch (type)
2024 {
2025 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
2026 default: return NULL;
2027 }
2028}
2029
2030static const char *
2031get_score_dynamic_type (unsigned long type)
2032{
2033 switch (type)
2034 {
2035 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
2036 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
2037 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
2038 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
2039 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
2040 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
2041 default: return NULL;
2042 }
2043}
2044
2045static const char *
2046get_tic6x_dynamic_type (unsigned long type)
2047{
2048 switch (type)
2049 {
2050 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
2051 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
2052 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
2053 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
2054 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
2055 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
2056 default: return NULL;
2057 }
2058}
2059
2060static const char *
2061get_nios2_dynamic_type (unsigned long type)
2062{
2063 switch (type)
2064 {
2065 case DT_NIOS2_GP: return "NIOS2_GP";
2066 default: return NULL;
2067 }
2068}
2069
2070static const char *
2071get_solaris_dynamic_type (unsigned long type)
2072{
2073 switch (type)
2074 {
2075 case 0x6000000d: return "SUNW_AUXILIARY";
2076 case 0x6000000e: return "SUNW_RTLDINF";
2077 case 0x6000000f: return "SUNW_FILTER";
2078 case 0x60000010: return "SUNW_CAP";
2079 case 0x60000011: return "SUNW_SYMTAB";
2080 case 0x60000012: return "SUNW_SYMSZ";
2081 case 0x60000013: return "SUNW_SORTENT";
2082 case 0x60000014: return "SUNW_SYMSORT";
2083 case 0x60000015: return "SUNW_SYMSORTSZ";
2084 case 0x60000016: return "SUNW_TLSSORT";
2085 case 0x60000017: return "SUNW_TLSSORTSZ";
2086 case 0x60000018: return "SUNW_CAPINFO";
2087 case 0x60000019: return "SUNW_STRPAD";
2088 case 0x6000001a: return "SUNW_CAPCHAIN";
2089 case 0x6000001b: return "SUNW_LDMACH";
2090 case 0x6000001d: return "SUNW_CAPCHAINENT";
2091 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2092 case 0x60000021: return "SUNW_PARENT";
2093 case 0x60000023: return "SUNW_ASLR";
2094 case 0x60000025: return "SUNW_RELAX";
2095 case 0x60000029: return "SUNW_NXHEAP";
2096 case 0x6000002b: return "SUNW_NXSTACK";
2097
2098 case 0x70000001: return "SPARC_REGISTER";
2099 case 0x7ffffffd: return "AUXILIARY";
2100 case 0x7ffffffe: return "USED";
2101 case 0x7fffffff: return "FILTER";
2102
2103 default: return NULL;
2104 }
2105}
2106
2107static const char *
2108get_dynamic_type (Filedata * filedata, unsigned long type)
2109{
2110 static char buff[64];
2111
2112 switch (type)
2113 {
2114 case DT_NULL: return "NULL";
2115 case DT_NEEDED: return "NEEDED";
2116 case DT_PLTRELSZ: return "PLTRELSZ";
2117 case DT_PLTGOT: return "PLTGOT";
2118 case DT_HASH: return "HASH";
2119 case DT_STRTAB: return "STRTAB";
2120 case DT_SYMTAB: return "SYMTAB";
2121 case DT_RELA: return "RELA";
2122 case DT_RELASZ: return "RELASZ";
2123 case DT_RELAENT: return "RELAENT";
2124 case DT_STRSZ: return "STRSZ";
2125 case DT_SYMENT: return "SYMENT";
2126 case DT_INIT: return "INIT";
2127 case DT_FINI: return "FINI";
2128 case DT_SONAME: return "SONAME";
2129 case DT_RPATH: return "RPATH";
2130 case DT_SYMBOLIC: return "SYMBOLIC";
2131 case DT_REL: return "REL";
2132 case DT_RELSZ: return "RELSZ";
2133 case DT_RELENT: return "RELENT";
2134 case DT_PLTREL: return "PLTREL";
2135 case DT_DEBUG: return "DEBUG";
2136 case DT_TEXTREL: return "TEXTREL";
2137 case DT_JMPREL: return "JMPREL";
2138 case DT_BIND_NOW: return "BIND_NOW";
2139 case DT_INIT_ARRAY: return "INIT_ARRAY";
2140 case DT_FINI_ARRAY: return "FINI_ARRAY";
2141 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2142 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
2143 case DT_RUNPATH: return "RUNPATH";
2144 case DT_FLAGS: return "FLAGS";
2145
2146 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2147 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
2148 case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
2149
2150 case DT_CHECKSUM: return "CHECKSUM";
2151 case DT_PLTPADSZ: return "PLTPADSZ";
2152 case DT_MOVEENT: return "MOVEENT";
2153 case DT_MOVESZ: return "MOVESZ";
2154 case DT_FEATURE: return "FEATURE";
2155 case DT_POSFLAG_1: return "POSFLAG_1";
2156 case DT_SYMINSZ: return "SYMINSZ";
2157 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
2158
2159 case DT_ADDRRNGLO: return "ADDRRNGLO";
2160 case DT_CONFIG: return "CONFIG";
2161 case DT_DEPAUDIT: return "DEPAUDIT";
2162 case DT_AUDIT: return "AUDIT";
2163 case DT_PLTPAD: return "PLTPAD";
2164 case DT_MOVETAB: return "MOVETAB";
2165 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
2166
2167 case DT_VERSYM: return "VERSYM";
2168
2169 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2170 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
2171 case DT_RELACOUNT: return "RELACOUNT";
2172 case DT_RELCOUNT: return "RELCOUNT";
2173 case DT_FLAGS_1: return "FLAGS_1";
2174 case DT_VERDEF: return "VERDEF";
2175 case DT_VERDEFNUM: return "VERDEFNUM";
2176 case DT_VERNEED: return "VERNEED";
2177 case DT_VERNEEDNUM: return "VERNEEDNUM";
2178
2179 case DT_AUXILIARY: return "AUXILIARY";
2180 case DT_USED: return "USED";
2181 case DT_FILTER: return "FILTER";
2182
2183 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2184 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2185 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2186 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2187 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
2188 case DT_GNU_HASH: return "GNU_HASH";
2189
2190 default:
2191 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2192 {
2193 const char * result;
2194
2195 switch (filedata->file_header.e_machine)
2196 {
2197 case EM_AARCH64:
2198 result = get_aarch64_dynamic_type (type);
2199 break;
2200 case EM_MIPS:
2201 case EM_MIPS_RS3_LE:
2202 result = get_mips_dynamic_type (type);
2203 break;
2204 case EM_SPARCV9:
2205 result = get_sparc64_dynamic_type (type);
2206 break;
2207 case EM_PPC:
2208 result = get_ppc_dynamic_type (type);
2209 break;
2210 case EM_PPC64:
2211 result = get_ppc64_dynamic_type (type);
2212 break;
2213 case EM_IA_64:
2214 result = get_ia64_dynamic_type (type);
2215 break;
2216 case EM_ALPHA:
2217 result = get_alpha_dynamic_type (type);
2218 break;
2219 case EM_SCORE:
2220 result = get_score_dynamic_type (type);
2221 break;
2222 case EM_TI_C6000:
2223 result = get_tic6x_dynamic_type (type);
2224 break;
2225 case EM_ALTERA_NIOS2:
2226 result = get_nios2_dynamic_type (type);
2227 break;
2228 default:
2229 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2230 result = get_solaris_dynamic_type (type);
2231 else
2232 result = NULL;
2233 break;
2234 }
2235
2236 if (result != NULL)
2237 return result;
2238
2239 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2240 }
2241 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2242 || (filedata->file_header.e_machine == EM_PARISC
2243 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2244 {
2245 const char * result;
2246
2247 switch (filedata->file_header.e_machine)
2248 {
2249 case EM_PARISC:
2250 result = get_parisc_dynamic_type (type);
2251 break;
2252 case EM_IA_64:
2253 result = get_ia64_dynamic_type (type);
2254 break;
2255 default:
2256 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2257 result = get_solaris_dynamic_type (type);
2258 else
2259 result = NULL;
2260 break;
2261 }
2262
2263 if (result != NULL)
2264 return result;
2265
2266 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2267 type);
2268 }
2269 else
2270 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2271
2272 return buff;
2273 }
2274}
2275
2276static char *
2277get_file_type (unsigned e_type)
2278{
2279 static char buff[32];
2280
2281 switch (e_type)
2282 {
2283 case ET_NONE: return _("NONE (None)");
2284 case ET_REL: return _("REL (Relocatable file)");
2285 case ET_EXEC: return _("EXEC (Executable file)");
2286 case ET_DYN: return _("DYN (Shared object file)");
2287 case ET_CORE: return _("CORE (Core file)");
2288
2289 default:
2290 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2291 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2292 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2293 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2294 else
2295 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2296 return buff;
2297 }
2298}
2299
2300static char *
2301get_machine_name (unsigned e_machine)
2302{
2303 static char buff[64]; /* XXX */
2304
2305 switch (e_machine)
2306 {
2307 /* Please keep this switch table sorted by increasing EM_ value. */
2308 /* 0 */
2309 case EM_NONE: return _("None");
2310 case EM_M32: return "WE32100";
2311 case EM_SPARC: return "Sparc";
2312 case EM_386: return "Intel 80386";
2313 case EM_68K: return "MC68000";
2314 case EM_88K: return "MC88000";
2315 case EM_IAMCU: return "Intel MCU";
2316 case EM_860: return "Intel 80860";
2317 case EM_MIPS: return "MIPS R3000";
2318 case EM_S370: return "IBM System/370";
2319 /* 10 */
2320 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
2321 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
2322 case EM_PARISC: return "HPPA";
2323 case EM_VPP550: return "Fujitsu VPP500";
2324 case EM_SPARC32PLUS: return "Sparc v8+" ;
2325 case EM_960: return "Intel 80960";
2326 case EM_PPC: return "PowerPC";
2327 /* 20 */
2328 case EM_PPC64: return "PowerPC64";
2329 case EM_S390_OLD:
2330 case EM_S390: return "IBM S/390";
2331 case EM_SPU: return "SPU";
2332 /* 30 */
2333 case EM_V800: return "Renesas V850 (using RH850 ABI)";
2334 case EM_FR20: return "Fujitsu FR20";
2335 case EM_RH32: return "TRW RH32";
2336 case EM_MCORE: return "MCORE";
2337 /* 40 */
2338 case EM_ARM: return "ARM";
2339 case EM_OLD_ALPHA: return "Digital Alpha (old)";
2340 case EM_SH: return "Renesas / SuperH SH";
2341 case EM_SPARCV9: return "Sparc v9";
2342 case EM_TRICORE: return "Siemens Tricore";
2343 case EM_ARC: return "ARC";
2344 case EM_H8_300: return "Renesas H8/300";
2345 case EM_H8_300H: return "Renesas H8/300H";
2346 case EM_H8S: return "Renesas H8S";
2347 case EM_H8_500: return "Renesas H8/500";
2348 /* 50 */
2349 case EM_IA_64: return "Intel IA-64";
2350 case EM_MIPS_X: return "Stanford MIPS-X";
2351 case EM_COLDFIRE: return "Motorola Coldfire";
2352 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
2353 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2354 case EM_PCP: return "Siemens PCP";
2355 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2356 case EM_NDR1: return "Denso NDR1 microprocesspr";
2357 case EM_STARCORE: return "Motorola Star*Core processor";
2358 case EM_ME16: return "Toyota ME16 processor";
2359 /* 60 */
2360 case EM_ST100: return "STMicroelectronics ST100 processor";
2361 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
2362 case EM_X86_64: return "Advanced Micro Devices X86-64";
2363 case EM_PDSP: return "Sony DSP processor";
2364 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2365 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
2366 case EM_FX66: return "Siemens FX66 microcontroller";
2367 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2368 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2369 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
2370 /* 70 */
2371 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2372 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2373 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2374 case EM_SVX: return "Silicon Graphics SVx";
2375 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2376 case EM_VAX: return "Digital VAX";
2377 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
2378 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2379 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2380 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
2381 /* 80 */
2382 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
2383 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
2384 case EM_PRISM: return "Vitesse Prism";
2385 case EM_AVR_OLD:
2386 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
2387 case EM_CYGNUS_FR30:
2388 case EM_FR30: return "Fujitsu FR30";
2389 case EM_CYGNUS_D10V:
2390 case EM_D10V: return "d10v";
2391 case EM_CYGNUS_D30V:
2392 case EM_D30V: return "d30v";
2393 case EM_CYGNUS_V850:
2394 case EM_V850: return "Renesas V850";
2395 case EM_CYGNUS_M32R:
2396 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2397 case EM_CYGNUS_MN10300:
2398 case EM_MN10300: return "mn10300";
2399 /* 90 */
2400 case EM_CYGNUS_MN10200:
2401 case EM_MN10200: return "mn10200";
2402 case EM_PJ: return "picoJava";
2403 case EM_OR1K: return "OpenRISC 1000";
2404 case EM_ARC_COMPACT: return "ARCompact";
2405 case EM_XTENSA_OLD:
2406 case EM_XTENSA: return "Tensilica Xtensa Processor";
2407 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2408 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2409 case EM_NS32K: return "National Semiconductor 32000 series";
2410 case EM_TPC: return "Tenor Network TPC processor";
2411 case EM_SNP1K: return "Trebia SNP 1000 processor";
2412 /* 100 */
2413 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2414 case EM_IP2K_OLD:
2415 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
2416 case EM_MAX: return "MAX Processor";
2417 case EM_CR: return "National Semiconductor CompactRISC";
2418 case EM_F2MC16: return "Fujitsu F2MC16";
2419 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
2420 case EM_BLACKFIN: return "Analog Devices Blackfin";
2421 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2422 case EM_SEP: return "Sharp embedded microprocessor";
2423 case EM_ARCA: return "Arca RISC microprocessor";
2424 /* 110 */
2425 case EM_UNICORE: return "Unicore";
2426 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2427 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
2428 case EM_ALTERA_NIOS2: return "Altera Nios II";
2429 case EM_CRX: return "National Semiconductor CRX microprocessor";
2430 case EM_XGATE: return "Motorola XGATE embedded processor";
2431 case EM_C166:
2432 case EM_XC16X: return "Infineon Technologies xc16x";
2433 case EM_M16C: return "Renesas M16C series microprocessors";
2434 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2435 case EM_CE: return "Freescale Communication Engine RISC core";
2436 /* 120 */
2437 case EM_M32C: return "Renesas M32c";
2438 /* 130 */
2439 case EM_TSK3000: return "Altium TSK3000 core";
2440 case EM_RS08: return "Freescale RS08 embedded processor";
2441 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2442 case EM_SCORE: return "SUNPLUS S+Core";
2443 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2444 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2445 case EM_LATTICEMICO32: return "Lattice Mico32";
2446 case EM_SE_C17: return "Seiko Epson C17 family";
2447 /* 140 */
2448 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2449 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2450 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2451 case EM_TI_PRU: return "TI PRU I/O processor";
2452 /* 160 */
2453 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2454 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2455 case EM_R32C: return "Renesas R32C series microprocessors";
2456 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2457 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2458 case EM_8051: return "Intel 8051 and variants";
2459 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2460 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2461 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2462 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2463 /* 170 */
2464 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2465 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2466 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
2467 case EM_RX: return "Renesas RX";
2468 case EM_METAG: return "Imagination Technologies Meta processor architecture";
2469 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2470 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2471 case EM_CR16:
2472 case EM_MICROBLAZE:
2473 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
2474 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2475 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2476 /* 180 */
2477 case EM_L1OM: return "Intel L1OM";
2478 case EM_K1OM: return "Intel K1OM";
2479 case EM_INTEL182: return "Intel (reserved)";
2480 case EM_AARCH64: return "AArch64";
2481 case EM_ARM184: return "ARM (reserved)";
2482 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor";
2483 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2484 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2485 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
2486 /* 190 */
2487 case EM_CUDA: return "NVIDIA CUDA architecture";
2488 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
2489 case EM_CLOUDSHIELD: return "CloudShield architecture family";
2490 case EM_COREA_1ST: return "KIPO-KAIST Core-A 1st generation processor family";
2491 case EM_COREA_2ND: return "KIPO-KAIST Core-A 2nd generation processor family";
2492 case EM_ARC_COMPACT2: return "ARCv2";
2493 case EM_OPEN8: return "Open8 8-bit RISC soft processor core";
2494 case EM_RL78: return "Renesas RL78";
2495 case EM_VIDEOCORE5: return "Broadcom VideoCore V processor";
2496 case EM_78K0R: return "Renesas 78K0R";
2497 /* 200 */
2498 case EM_56800EX: return "Freescale 56800EX Digital Signal Controller (DSC)";
2499 case EM_BA1: return "Beyond BA1 CPU architecture";
2500 case EM_BA2: return "Beyond BA2 CPU architecture";
2501 case EM_XCORE: return "XMOS xCORE processor family";
2502 case EM_MCHP_PIC: return "Microchip 8-bit PIC(r) family";
2503 /* 210 */
2504 case EM_KM32: return "KM211 KM32 32-bit processor";
2505 case EM_KMX32: return "KM211 KMX32 32-bit processor";
2506 case EM_KMX16: return "KM211 KMX16 16-bit processor";
2507 case EM_KMX8: return "KM211 KMX8 8-bit processor";
2508 case EM_KVARC: return "KM211 KVARC processor";
2509 case EM_CDP: return "Paneve CDP architecture family";
2510 case EM_COGE: return "Cognitive Smart Memory Processor";
2511 case EM_COOL: return "Bluechip Systems CoolEngine";
2512 case EM_NORC: return "Nanoradio Optimized RISC";
2513 case EM_CSR_KALIMBA: return "CSR Kalimba architecture family";
2514 /* 220 */
2515 case EM_Z80: return "Zilog Z80";
2516 case EM_VISIUM: return "CDS VISIUMcore processor";
2517 case EM_FT32: return "FTDI Chip FT32";
2518 case EM_MOXIE: return "Moxie";
2519 case EM_AMDGPU: return "AMD GPU";
2520 case EM_RISCV: return "RISC-V";
2521 case EM_LANAI: return "Lanai 32-bit processor";
2522 case EM_BPF: return "Linux BPF";
2523 case EM_NFP: return "Netronome Flow Processor";
2524
2525 /* Large numbers... */
2526 case EM_MT: return "Morpho Techologies MT processor";
2527 case EM_ALPHA: return "Alpha";
2528 case EM_WEBASSEMBLY: return "Web Assembly";
2529 case EM_DLX: return "OpenDLX";
2530 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
2531 case EM_IQ2000: return "Vitesse IQ2000";
2532 case EM_M32C_OLD:
2533 case EM_NIOS32: return "Altera Nios";
2534 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
2535 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
2536 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2537 case EM_S12Z: return "Freescale S12Z";
2538 case EM_CSKY: return "C-SKY";
2539
2540 default:
2541 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2542 return buff;
2543 }
2544}
2545
2546static void
2547decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2548{
2549 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2550 other compilers don't a specific architecture type in the e_flags, and
2551 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2552 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2553 architectures.
2554
2555 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2556 but also sets a specific architecture type in the e_flags field.
2557
2558 However, when decoding the flags we don't worry if we see an
2559 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2560 ARCEM architecture type. */
2561
2562 switch (e_flags & EF_ARC_MACH_MSK)
2563 {
2564 /* We only expect these to occur for EM_ARC_COMPACT2. */
2565 case EF_ARC_CPU_ARCV2EM:
2566 strcat (buf, ", ARC EM");
2567 break;
2568 case EF_ARC_CPU_ARCV2HS:
2569 strcat (buf, ", ARC HS");
2570 break;
2571
2572 /* We only expect these to occur for EM_ARC_COMPACT. */
2573 case E_ARC_MACH_ARC600:
2574 strcat (buf, ", ARC600");
2575 break;
2576 case E_ARC_MACH_ARC601:
2577 strcat (buf, ", ARC601");
2578 break;
2579 case E_ARC_MACH_ARC700:
2580 strcat (buf, ", ARC700");
2581 break;
2582
2583 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2584 new ELF with new architecture being read by an old version of
2585 readelf, or (c) An ELF built with non-GNU compiler that does not
2586 set the architecture in the e_flags. */
2587 default:
2588 if (e_machine == EM_ARC_COMPACT)
2589 strcat (buf, ", Unknown ARCompact");
2590 else
2591 strcat (buf, ", Unknown ARC");
2592 break;
2593 }
2594
2595 switch (e_flags & EF_ARC_OSABI_MSK)
2596 {
2597 case E_ARC_OSABI_ORIG:
2598 strcat (buf, ", (ABI:legacy)");
2599 break;
2600 case E_ARC_OSABI_V2:
2601 strcat (buf, ", (ABI:v2)");
2602 break;
2603 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2604 case E_ARC_OSABI_V3:
2605 strcat (buf, ", v3 no-legacy-syscalls ABI");
2606 break;
2607 case E_ARC_OSABI_V4:
2608 strcat (buf, ", v4 ABI");
2609 break;
2610 default:
2611 strcat (buf, ", unrecognised ARC OSABI flag");
2612 break;
2613 }
2614}
2615
2616static void
2617decode_ARM_machine_flags (unsigned e_flags, char buf[])
2618{
2619 unsigned eabi;
2620 bfd_boolean unknown = FALSE;
2621
2622 eabi = EF_ARM_EABI_VERSION (e_flags);
2623 e_flags &= ~ EF_ARM_EABIMASK;
2624
2625 /* Handle "generic" ARM flags. */
2626 if (e_flags & EF_ARM_RELEXEC)
2627 {
2628 strcat (buf, ", relocatable executable");
2629 e_flags &= ~ EF_ARM_RELEXEC;
2630 }
2631
2632 if (e_flags & EF_ARM_PIC)
2633 {
2634 strcat (buf, ", position independent");
2635 e_flags &= ~ EF_ARM_PIC;
2636 }
2637
2638 /* Now handle EABI specific flags. */
2639 switch (eabi)
2640 {
2641 default:
2642 strcat (buf, ", <unrecognized EABI>");
2643 if (e_flags)
2644 unknown = TRUE;
2645 break;
2646
2647 case EF_ARM_EABI_VER1:
2648 strcat (buf, ", Version1 EABI");
2649 while (e_flags)
2650 {
2651 unsigned flag;
2652
2653 /* Process flags one bit at a time. */
2654 flag = e_flags & - e_flags;
2655 e_flags &= ~ flag;
2656
2657 switch (flag)
2658 {
2659 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2660 strcat (buf, ", sorted symbol tables");
2661 break;
2662
2663 default:
2664 unknown = TRUE;
2665 break;
2666 }
2667 }
2668 break;
2669
2670 case EF_ARM_EABI_VER2:
2671 strcat (buf, ", Version2 EABI");
2672 while (e_flags)
2673 {
2674 unsigned flag;
2675
2676 /* Process flags one bit at a time. */
2677 flag = e_flags & - e_flags;
2678 e_flags &= ~ flag;
2679
2680 switch (flag)
2681 {
2682 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2683 strcat (buf, ", sorted symbol tables");
2684 break;
2685
2686 case EF_ARM_DYNSYMSUSESEGIDX:
2687 strcat (buf, ", dynamic symbols use segment index");
2688 break;
2689
2690 case EF_ARM_MAPSYMSFIRST:
2691 strcat (buf, ", mapping symbols precede others");
2692 break;
2693
2694 default:
2695 unknown = TRUE;
2696 break;
2697 }
2698 }
2699 break;
2700
2701 case EF_ARM_EABI_VER3:
2702 strcat (buf, ", Version3 EABI");
2703 break;
2704
2705 case EF_ARM_EABI_VER4:
2706 strcat (buf, ", Version4 EABI");
2707 while (e_flags)
2708 {
2709 unsigned flag;
2710
2711 /* Process flags one bit at a time. */
2712 flag = e_flags & - e_flags;
2713 e_flags &= ~ flag;
2714
2715 switch (flag)
2716 {
2717 case EF_ARM_BE8:
2718 strcat (buf, ", BE8");
2719 break;
2720
2721 case EF_ARM_LE8:
2722 strcat (buf, ", LE8");
2723 break;
2724
2725 default:
2726 unknown = TRUE;
2727 break;
2728 }
2729 }
2730 break;
2731
2732 case EF_ARM_EABI_VER5:
2733 strcat (buf, ", Version5 EABI");
2734 while (e_flags)
2735 {
2736 unsigned flag;
2737
2738 /* Process flags one bit at a time. */
2739 flag = e_flags & - e_flags;
2740 e_flags &= ~ flag;
2741
2742 switch (flag)
2743 {
2744 case EF_ARM_BE8:
2745 strcat (buf, ", BE8");
2746 break;
2747
2748 case EF_ARM_LE8:
2749 strcat (buf, ", LE8");
2750 break;
2751
2752 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2753 strcat (buf, ", soft-float ABI");
2754 break;
2755
2756 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2757 strcat (buf, ", hard-float ABI");
2758 break;
2759
2760 default:
2761 unknown = TRUE;
2762 break;
2763 }
2764 }
2765 break;
2766
2767 case EF_ARM_EABI_UNKNOWN:
2768 strcat (buf, ", GNU EABI");
2769 while (e_flags)
2770 {
2771 unsigned flag;
2772
2773 /* Process flags one bit at a time. */
2774 flag = e_flags & - e_flags;
2775 e_flags &= ~ flag;
2776
2777 switch (flag)
2778 {
2779 case EF_ARM_INTERWORK:
2780 strcat (buf, ", interworking enabled");
2781 break;
2782
2783 case EF_ARM_APCS_26:
2784 strcat (buf, ", uses APCS/26");
2785 break;
2786
2787 case EF_ARM_APCS_FLOAT:
2788 strcat (buf, ", uses APCS/float");
2789 break;
2790
2791 case EF_ARM_PIC:
2792 strcat (buf, ", position independent");
2793 break;
2794
2795 case EF_ARM_ALIGN8:
2796 strcat (buf, ", 8 bit structure alignment");
2797 break;
2798
2799 case EF_ARM_NEW_ABI:
2800 strcat (buf, ", uses new ABI");
2801 break;
2802
2803 case EF_ARM_OLD_ABI:
2804 strcat (buf, ", uses old ABI");
2805 break;
2806
2807 case EF_ARM_SOFT_FLOAT:
2808 strcat (buf, ", software FP");
2809 break;
2810
2811 case EF_ARM_VFP_FLOAT:
2812 strcat (buf, ", VFP");
2813 break;
2814
2815 case EF_ARM_MAVERICK_FLOAT:
2816 strcat (buf, ", Maverick FP");
2817 break;
2818
2819 default:
2820 unknown = TRUE;
2821 break;
2822 }
2823 }
2824 }
2825
2826 if (unknown)
2827 strcat (buf,_(", <unknown>"));
2828}
2829
2830static void
2831decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2832{
2833 --size; /* Leave space for null terminator. */
2834
2835 switch (e_flags & EF_AVR_MACH)
2836 {
2837 case E_AVR_MACH_AVR1:
2838 strncat (buf, ", avr:1", size);
2839 break;
2840 case E_AVR_MACH_AVR2:
2841 strncat (buf, ", avr:2", size);
2842 break;
2843 case E_AVR_MACH_AVR25:
2844 strncat (buf, ", avr:25", size);
2845 break;
2846 case E_AVR_MACH_AVR3:
2847 strncat (buf, ", avr:3", size);
2848 break;
2849 case E_AVR_MACH_AVR31:
2850 strncat (buf, ", avr:31", size);
2851 break;
2852 case E_AVR_MACH_AVR35:
2853 strncat (buf, ", avr:35", size);
2854 break;
2855 case E_AVR_MACH_AVR4:
2856 strncat (buf, ", avr:4", size);
2857 break;
2858 case E_AVR_MACH_AVR5:
2859 strncat (buf, ", avr:5", size);
2860 break;
2861 case E_AVR_MACH_AVR51:
2862 strncat (buf, ", avr:51", size);
2863 break;
2864 case E_AVR_MACH_AVR6:
2865 strncat (buf, ", avr:6", size);
2866 break;
2867 case E_AVR_MACH_AVRTINY:
2868 strncat (buf, ", avr:100", size);
2869 break;
2870 case E_AVR_MACH_XMEGA1:
2871 strncat (buf, ", avr:101", size);
2872 break;
2873 case E_AVR_MACH_XMEGA2:
2874 strncat (buf, ", avr:102", size);
2875 break;
2876 case E_AVR_MACH_XMEGA3:
2877 strncat (buf, ", avr:103", size);
2878 break;
2879 case E_AVR_MACH_XMEGA4:
2880 strncat (buf, ", avr:104", size);
2881 break;
2882 case E_AVR_MACH_XMEGA5:
2883 strncat (buf, ", avr:105", size);
2884 break;
2885 case E_AVR_MACH_XMEGA6:
2886 strncat (buf, ", avr:106", size);
2887 break;
2888 case E_AVR_MACH_XMEGA7:
2889 strncat (buf, ", avr:107", size);
2890 break;
2891 default:
2892 strncat (buf, ", avr:<unknown>", size);
2893 break;
2894 }
2895
2896 size -= strlen (buf);
2897 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2898 strncat (buf, ", link-relax", size);
2899}
2900
2901static void
2902decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2903{
2904 unsigned abi;
2905 unsigned arch;
2906 unsigned config;
2907 unsigned version;
2908 bfd_boolean has_fpu = FALSE;
2909 unsigned int r = 0;
2910
2911 static const char *ABI_STRINGS[] =
2912 {
2913 "ABI v0", /* use r5 as return register; only used in N1213HC */
2914 "ABI v1", /* use r0 as return register */
2915 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2916 "ABI v2fp", /* for FPU */
2917 "AABI",
2918 "ABI2 FP+"
2919 };
2920 static const char *VER_STRINGS[] =
2921 {
2922 "Andes ELF V1.3 or older",
2923 "Andes ELF V1.3.1",
2924 "Andes ELF V1.4"
2925 };
2926 static const char *ARCH_STRINGS[] =
2927 {
2928 "",
2929 "Andes Star v1.0",
2930 "Andes Star v2.0",
2931 "Andes Star v3.0",
2932 "Andes Star v3.0m"
2933 };
2934
2935 abi = EF_NDS_ABI & e_flags;
2936 arch = EF_NDS_ARCH & e_flags;
2937 config = EF_NDS_INST & e_flags;
2938 version = EF_NDS32_ELF_VERSION & e_flags;
2939
2940 memset (buf, 0, size);
2941
2942 switch (abi)
2943 {
2944 case E_NDS_ABI_V0:
2945 case E_NDS_ABI_V1:
2946 case E_NDS_ABI_V2:
2947 case E_NDS_ABI_V2FP:
2948 case E_NDS_ABI_AABI:
2949 case E_NDS_ABI_V2FP_PLUS:
2950 /* In case there are holes in the array. */
2951 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2952 break;
2953
2954 default:
2955 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2956 break;
2957 }
2958
2959 switch (version)
2960 {
2961 case E_NDS32_ELF_VER_1_2:
2962 case E_NDS32_ELF_VER_1_3:
2963 case E_NDS32_ELF_VER_1_4:
2964 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2965 break;
2966
2967 default:
2968 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2969 break;
2970 }
2971
2972 if (E_NDS_ABI_V0 == abi)
2973 {
2974 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2975 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2976 if (arch == E_NDS_ARCH_STAR_V1_0)
2977 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2978 return;
2979 }
2980
2981 switch (arch)
2982 {
2983 case E_NDS_ARCH_STAR_V1_0:
2984 case E_NDS_ARCH_STAR_V2_0:
2985 case E_NDS_ARCH_STAR_V3_0:
2986 case E_NDS_ARCH_STAR_V3_M:
2987 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2988 break;
2989
2990 default:
2991 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2992 /* ARCH version determines how the e_flags are interpreted.
2993 If it is unknown, we cannot proceed. */
2994 return;
2995 }
2996
2997 /* Newer ABI; Now handle architecture specific flags. */
2998 if (arch == E_NDS_ARCH_STAR_V1_0)
2999 {
3000 if (config & E_NDS32_HAS_MFUSR_PC_INST)
3001 r += snprintf (buf + r, size -r, ", MFUSR_PC");
3002
3003 if (!(config & E_NDS32_HAS_NO_MAC_INST))
3004 r += snprintf (buf + r, size -r, ", MAC");
3005
3006 if (config & E_NDS32_HAS_DIV_INST)
3007 r += snprintf (buf + r, size -r, ", DIV");
3008
3009 if (config & E_NDS32_HAS_16BIT_INST)
3010 r += snprintf (buf + r, size -r, ", 16b");
3011 }
3012 else
3013 {
3014 if (config & E_NDS32_HAS_MFUSR_PC_INST)
3015 {
3016 if (version <= E_NDS32_ELF_VER_1_3)
3017 r += snprintf (buf + r, size -r, ", [B8]");
3018 else
3019 r += snprintf (buf + r, size -r, ", EX9");
3020 }
3021
3022 if (config & E_NDS32_HAS_MAC_DX_INST)
3023 r += snprintf (buf + r, size -r, ", MAC_DX");
3024
3025 if (config & E_NDS32_HAS_DIV_DX_INST)
3026 r += snprintf (buf + r, size -r, ", DIV_DX");
3027
3028 if (config & E_NDS32_HAS_16BIT_INST)
3029 {
3030 if (version <= E_NDS32_ELF_VER_1_3)
3031 r += snprintf (buf + r, size -r, ", 16b");
3032 else
3033 r += snprintf (buf + r, size -r, ", IFC");
3034 }
3035 }
3036
3037 if (config & E_NDS32_HAS_EXT_INST)
3038 r += snprintf (buf + r, size -r, ", PERF1");
3039
3040 if (config & E_NDS32_HAS_EXT2_INST)
3041 r += snprintf (buf + r, size -r, ", PERF2");
3042
3043 if (config & E_NDS32_HAS_FPU_INST)
3044 {
3045 has_fpu = TRUE;
3046 r += snprintf (buf + r, size -r, ", FPU_SP");
3047 }
3048
3049 if (config & E_NDS32_HAS_FPU_DP_INST)
3050 {
3051 has_fpu = TRUE;
3052 r += snprintf (buf + r, size -r, ", FPU_DP");
3053 }
3054
3055 if (config & E_NDS32_HAS_FPU_MAC_INST)
3056 {
3057 has_fpu = TRUE;
3058 r += snprintf (buf + r, size -r, ", FPU_MAC");
3059 }
3060
3061 if (has_fpu)
3062 {
3063 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
3064 {
3065 case E_NDS32_FPU_REG_8SP_4DP:
3066 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
3067 break;
3068 case E_NDS32_FPU_REG_16SP_8DP:
3069 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
3070 break;
3071 case E_NDS32_FPU_REG_32SP_16DP:
3072 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
3073 break;
3074 case E_NDS32_FPU_REG_32SP_32DP:
3075 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
3076 break;
3077 }
3078 }
3079
3080 if (config & E_NDS32_HAS_AUDIO_INST)
3081 r += snprintf (buf + r, size -r, ", AUDIO");
3082
3083 if (config & E_NDS32_HAS_STRING_INST)
3084 r += snprintf (buf + r, size -r, ", STR");
3085
3086 if (config & E_NDS32_HAS_REDUCED_REGS)
3087 r += snprintf (buf + r, size -r, ", 16REG");
3088
3089 if (config & E_NDS32_HAS_VIDEO_INST)
3090 {
3091 if (version <= E_NDS32_ELF_VER_1_3)
3092 r += snprintf (buf + r, size -r, ", VIDEO");
3093 else
3094 r += snprintf (buf + r, size -r, ", SATURATION");
3095 }
3096
3097 if (config & E_NDS32_HAS_ENCRIPT_INST)
3098 r += snprintf (buf + r, size -r, ", ENCRP");
3099
3100 if (config & E_NDS32_HAS_L2C_INST)
3101 r += snprintf (buf + r, size -r, ", L2C");
3102}
3103
3104static char *
3105get_machine_flags (Filedata * filedata, unsigned e_flags, unsigned e_machine)
3106{
3107 static char buf[1024];
3108
3109 buf[0] = '\0';
3110
3111 if (e_flags)
3112 {
3113 switch (e_machine)
3114 {
3115 default:
3116 break;
3117
3118 case EM_ARC_COMPACT2:
3119 case EM_ARC_COMPACT:
3120 decode_ARC_machine_flags (e_flags, e_machine, buf);
3121 break;
3122
3123 case EM_ARM:
3124 decode_ARM_machine_flags (e_flags, buf);
3125 break;
3126
3127 case EM_AVR:
3128 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
3129 break;
3130
3131 case EM_BLACKFIN:
3132 if (e_flags & EF_BFIN_PIC)
3133 strcat (buf, ", PIC");
3134
3135 if (e_flags & EF_BFIN_FDPIC)
3136 strcat (buf, ", FDPIC");
3137
3138 if (e_flags & EF_BFIN_CODE_IN_L1)
3139 strcat (buf, ", code in L1");
3140
3141 if (e_flags & EF_BFIN_DATA_IN_L1)
3142 strcat (buf, ", data in L1");
3143
3144 break;
3145
3146 case EM_CYGNUS_FRV:
3147 switch (e_flags & EF_FRV_CPU_MASK)
3148 {
3149 case EF_FRV_CPU_GENERIC:
3150 break;
3151
3152 default:
3153 strcat (buf, ", fr???");
3154 break;
3155
3156 case EF_FRV_CPU_FR300:
3157 strcat (buf, ", fr300");
3158 break;
3159
3160 case EF_FRV_CPU_FR400:
3161 strcat (buf, ", fr400");
3162 break;
3163 case EF_FRV_CPU_FR405:
3164 strcat (buf, ", fr405");
3165 break;
3166
3167 case EF_FRV_CPU_FR450:
3168 strcat (buf, ", fr450");
3169 break;
3170
3171 case EF_FRV_CPU_FR500:
3172 strcat (buf, ", fr500");
3173 break;
3174 case EF_FRV_CPU_FR550:
3175 strcat (buf, ", fr550");
3176 break;
3177
3178 case EF_FRV_CPU_SIMPLE:
3179 strcat (buf, ", simple");
3180 break;
3181 case EF_FRV_CPU_TOMCAT:
3182 strcat (buf, ", tomcat");
3183 break;
3184 }
3185 break;
3186
3187 case EM_68K:
3188 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
3189 strcat (buf, ", m68000");
3190 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3191 strcat (buf, ", cpu32");
3192 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3193 strcat (buf, ", fido_a");
3194 else
3195 {
3196 char const * isa = _("unknown");
3197 char const * mac = _("unknown mac");
3198 char const * additional = NULL;
3199
3200 switch (e_flags & EF_M68K_CF_ISA_MASK)
3201 {
3202 case EF_M68K_CF_ISA_A_NODIV:
3203 isa = "A";
3204 additional = ", nodiv";
3205 break;
3206 case EF_M68K_CF_ISA_A:
3207 isa = "A";
3208 break;
3209 case EF_M68K_CF_ISA_A_PLUS:
3210 isa = "A+";
3211 break;
3212 case EF_M68K_CF_ISA_B_NOUSP:
3213 isa = "B";
3214 additional = ", nousp";
3215 break;
3216 case EF_M68K_CF_ISA_B:
3217 isa = "B";
3218 break;
3219 case EF_M68K_CF_ISA_C:
3220 isa = "C";
3221 break;
3222 case EF_M68K_CF_ISA_C_NODIV:
3223 isa = "C";
3224 additional = ", nodiv";
3225 break;
3226 }
3227 strcat (buf, ", cf, isa ");
3228 strcat (buf, isa);
3229 if (additional)
3230 strcat (buf, additional);
3231 if (e_flags & EF_M68K_CF_FLOAT)
3232 strcat (buf, ", float");
3233 switch (e_flags & EF_M68K_CF_MAC_MASK)
3234 {
3235 case 0:
3236 mac = NULL;
3237 break;
3238 case EF_M68K_CF_MAC:
3239 mac = "mac";
3240 break;
3241 case EF_M68K_CF_EMAC:
3242 mac = "emac";
3243 break;
3244 case EF_M68K_CF_EMAC_B:
3245 mac = "emac_b";
3246 break;
3247 }
3248 if (mac)
3249 {
3250 strcat (buf, ", ");
3251 strcat (buf, mac);
3252 }
3253 }
3254 break;
3255
3256 case EM_CYGNUS_MEP:
3257 switch (e_flags & EF_MEP_CPU_MASK)
3258 {
3259 case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3260 case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3261 case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3262 case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3263 case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3264 case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3265 default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3266 }
3267
3268 switch (e_flags & EF_MEP_COP_MASK)
3269 {
3270 case EF_MEP_COP_NONE: break;
3271 case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3272 case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3273 case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3274 case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3275 default: strcat (buf, _("<unknown MeP copro type>")); break;
3276 }
3277
3278 if (e_flags & EF_MEP_LIBRARY)
3279 strcat (buf, ", Built for Library");
3280
3281 if (e_flags & EF_MEP_INDEX_MASK)
3282 sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3283 e_flags & EF_MEP_INDEX_MASK);
3284
3285 if (e_flags & ~ EF_MEP_ALL_FLAGS)
3286 sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3287 e_flags & ~ EF_MEP_ALL_FLAGS);
3288 break;
3289
3290 case EM_PPC:
3291 if (e_flags & EF_PPC_EMB)
3292 strcat (buf, ", emb");
3293
3294 if (e_flags & EF_PPC_RELOCATABLE)
3295 strcat (buf, _(", relocatable"));
3296
3297 if (e_flags & EF_PPC_RELOCATABLE_LIB)
3298 strcat (buf, _(", relocatable-lib"));
3299 break;
3300
3301 case EM_PPC64:
3302 if (e_flags & EF_PPC64_ABI)
3303 {
3304 char abi[] = ", abiv0";
3305
3306 abi[6] += e_flags & EF_PPC64_ABI;
3307 strcat (buf, abi);
3308 }
3309 break;
3310
3311 case EM_V800:
3312 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3313 strcat (buf, ", RH850 ABI");
3314
3315 if (e_flags & EF_V800_850E3)
3316 strcat (buf, ", V3 architecture");
3317
3318 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3319 strcat (buf, ", FPU not used");
3320
3321 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3322 strcat (buf, ", regmode: COMMON");
3323
3324 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3325 strcat (buf, ", r4 not used");
3326
3327 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3328 strcat (buf, ", r30 not used");
3329
3330 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3331 strcat (buf, ", r5 not used");
3332
3333 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3334 strcat (buf, ", r2 not used");
3335
3336 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3337 {
3338 switch (e_flags & - e_flags)
3339 {
3340 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3341 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3342 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3343 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3344 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3345 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3346 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3347 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3348 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3349 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3350 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3351 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3352 default: break;
3353 }
3354 }
3355 break;
3356
3357 case EM_V850:
3358 case EM_CYGNUS_V850:
3359 switch (e_flags & EF_V850_ARCH)
3360 {
3361 case E_V850E3V5_ARCH:
3362 strcat (buf, ", v850e3v5");
3363 break;
3364 case E_V850E2V3_ARCH:
3365 strcat (buf, ", v850e2v3");
3366 break;
3367 case E_V850E2_ARCH:
3368 strcat (buf, ", v850e2");
3369 break;
3370 case E_V850E1_ARCH:
3371 strcat (buf, ", v850e1");
3372 break;
3373 case E_V850E_ARCH:
3374 strcat (buf, ", v850e");
3375 break;
3376 case E_V850_ARCH:
3377 strcat (buf, ", v850");
3378 break;
3379 default:
3380 strcat (buf, _(", unknown v850 architecture variant"));
3381 break;
3382 }
3383 break;
3384
3385 case EM_M32R:
3386 case EM_CYGNUS_M32R:
3387 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3388 strcat (buf, ", m32r");
3389 break;
3390
3391 case EM_MIPS:
3392 case EM_MIPS_RS3_LE:
3393 if (e_flags & EF_MIPS_NOREORDER)
3394 strcat (buf, ", noreorder");
3395
3396 if (e_flags & EF_MIPS_PIC)
3397 strcat (buf, ", pic");
3398
3399 if (e_flags & EF_MIPS_CPIC)
3400 strcat (buf, ", cpic");
3401
3402 if (e_flags & EF_MIPS_UCODE)
3403 strcat (buf, ", ugen_reserved");
3404
3405 if (e_flags & EF_MIPS_ABI2)
3406 strcat (buf, ", abi2");
3407
3408 if (e_flags & EF_MIPS_OPTIONS_FIRST)
3409 strcat (buf, ", odk first");
3410
3411 if (e_flags & EF_MIPS_32BITMODE)
3412 strcat (buf, ", 32bitmode");
3413
3414 if (e_flags & EF_MIPS_NAN2008)
3415 strcat (buf, ", nan2008");
3416
3417 if (e_flags & EF_MIPS_FP64)
3418 strcat (buf, ", fp64");
3419
3420 switch ((e_flags & EF_MIPS_MACH))
3421 {
3422 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3423 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3424 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3425 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3426 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3427 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3428 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3429 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3430 case E_MIPS_MACH_5900: strcat (buf, ", 5900"); break;
3431 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
3432 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3433 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3434 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3435 case E_MIPS_MACH_GS464: strcat (buf, ", gs464"); break;
3436 case E_MIPS_MACH_GS464E: strcat (buf, ", gs464e"); break;
3437 case E_MIPS_MACH_GS264E: strcat (buf, ", gs264e"); break;
3438 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3439 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3440 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3441 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
3442 case E_MIPS_MACH_IAMR2: strcat (buf, ", interaptiv-mr2"); break;
3443 case 0:
3444 /* We simply ignore the field in this case to avoid confusion:
3445 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3446 extension. */
3447 break;
3448 default: strcat (buf, _(", unknown CPU")); break;
3449 }
3450
3451 switch ((e_flags & EF_MIPS_ABI))
3452 {
3453 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3454 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3455 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3456 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3457 case 0:
3458 /* We simply ignore the field in this case to avoid confusion:
3459 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3460 This means it is likely to be an o32 file, but not for
3461 sure. */
3462 break;
3463 default: strcat (buf, _(", unknown ABI")); break;
3464 }
3465
3466 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3467 strcat (buf, ", mdmx");
3468
3469 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3470 strcat (buf, ", mips16");
3471
3472 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3473 strcat (buf, ", micromips");
3474
3475 switch ((e_flags & EF_MIPS_ARCH))
3476 {
3477 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3478 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3479 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3480 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3481 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3482 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3483 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3484 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3485 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3486 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3487 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3488 default: strcat (buf, _(", unknown ISA")); break;
3489 }
3490 break;
3491
3492 case EM_NDS32:
3493 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3494 break;
3495
3496 case EM_NFP:
3497 switch (EF_NFP_MACH (e_flags))
3498 {
3499 case E_NFP_MACH_3200:
3500 strcat (buf, ", NFP-32xx");
3501 break;
3502 case E_NFP_MACH_6000:
3503 strcat (buf, ", NFP-6xxx");
3504 break;
3505 }
3506 break;
3507
3508 case EM_RISCV:
3509 if (e_flags & EF_RISCV_RVC)
3510 strcat (buf, ", RVC");
3511
3512 if (e_flags & EF_RISCV_RVE)
3513 strcat (buf, ", RVE");
3514
3515 switch (e_flags & EF_RISCV_FLOAT_ABI)
3516 {
3517 case EF_RISCV_FLOAT_ABI_SOFT:
3518 strcat (buf, ", soft-float ABI");
3519 break;
3520
3521 case EF_RISCV_FLOAT_ABI_SINGLE:
3522 strcat (buf, ", single-float ABI");
3523 break;
3524
3525 case EF_RISCV_FLOAT_ABI_DOUBLE:
3526 strcat (buf, ", double-float ABI");
3527 break;
3528
3529 case EF_RISCV_FLOAT_ABI_QUAD:
3530 strcat (buf, ", quad-float ABI");
3531 break;
3532 }
3533 break;
3534
3535 case EM_SH:
3536 switch ((e_flags & EF_SH_MACH_MASK))
3537 {
3538 case EF_SH1: strcat (buf, ", sh1"); break;
3539 case EF_SH2: strcat (buf, ", sh2"); break;
3540 case EF_SH3: strcat (buf, ", sh3"); break;
3541 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3542 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3543 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3544 case EF_SH3E: strcat (buf, ", sh3e"); break;
3545 case EF_SH4: strcat (buf, ", sh4"); break;
3546 case EF_SH5: strcat (buf, ", sh5"); break;
3547 case EF_SH2E: strcat (buf, ", sh2e"); break;
3548 case EF_SH4A: strcat (buf, ", sh4a"); break;
3549 case EF_SH2A: strcat (buf, ", sh2a"); break;
3550 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3551 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3552 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3553 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3554 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3555 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3556 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3557 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3558 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3559 default: strcat (buf, _(", unknown ISA")); break;
3560 }
3561
3562 if (e_flags & EF_SH_PIC)
3563 strcat (buf, ", pic");
3564
3565 if (e_flags & EF_SH_FDPIC)
3566 strcat (buf, ", fdpic");
3567 break;
3568
3569 case EM_OR1K:
3570 if (e_flags & EF_OR1K_NODELAY)
3571 strcat (buf, ", no delay");
3572 break;
3573
3574 case EM_SPARCV9:
3575 if (e_flags & EF_SPARC_32PLUS)
3576 strcat (buf, ", v8+");
3577
3578 if (e_flags & EF_SPARC_SUN_US1)
3579 strcat (buf, ", ultrasparcI");
3580
3581 if (e_flags & EF_SPARC_SUN_US3)
3582 strcat (buf, ", ultrasparcIII");
3583
3584 if (e_flags & EF_SPARC_HAL_R1)
3585 strcat (buf, ", halr1");
3586
3587 if (e_flags & EF_SPARC_LEDATA)
3588 strcat (buf, ", ledata");
3589
3590 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3591 strcat (buf, ", tso");
3592
3593 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3594 strcat (buf, ", pso");
3595
3596 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3597 strcat (buf, ", rmo");
3598 break;
3599
3600 case EM_PARISC:
3601 switch (e_flags & EF_PARISC_ARCH)
3602 {
3603 case EFA_PARISC_1_0:
3604 strcpy (buf, ", PA-RISC 1.0");
3605 break;
3606 case EFA_PARISC_1_1:
3607 strcpy (buf, ", PA-RISC 1.1");
3608 break;
3609 case EFA_PARISC_2_0:
3610 strcpy (buf, ", PA-RISC 2.0");
3611 break;
3612 default:
3613 break;
3614 }
3615 if (e_flags & EF_PARISC_TRAPNIL)
3616 strcat (buf, ", trapnil");
3617 if (e_flags & EF_PARISC_EXT)
3618 strcat (buf, ", ext");
3619 if (e_flags & EF_PARISC_LSB)
3620 strcat (buf, ", lsb");
3621 if (e_flags & EF_PARISC_WIDE)
3622 strcat (buf, ", wide");
3623 if (e_flags & EF_PARISC_NO_KABP)
3624 strcat (buf, ", no kabp");
3625 if (e_flags & EF_PARISC_LAZYSWAP)
3626 strcat (buf, ", lazyswap");
3627 break;
3628
3629 case EM_PJ:
3630 case EM_PJ_OLD:
3631 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3632 strcat (buf, ", new calling convention");
3633
3634 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3635 strcat (buf, ", gnu calling convention");
3636 break;
3637
3638 case EM_IA_64:
3639 if ((e_flags & EF_IA_64_ABI64))
3640 strcat (buf, ", 64-bit");
3641 else
3642 strcat (buf, ", 32-bit");
3643 if ((e_flags & EF_IA_64_REDUCEDFP))
3644 strcat (buf, ", reduced fp model");
3645 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3646 strcat (buf, ", no function descriptors, constant gp");
3647 else if ((e_flags & EF_IA_64_CONS_GP))
3648 strcat (buf, ", constant gp");
3649 if ((e_flags & EF_IA_64_ABSOLUTE))
3650 strcat (buf, ", absolute");
3651 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3652 {
3653 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3654 strcat (buf, ", vms_linkages");
3655 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3656 {
3657 case EF_IA_64_VMS_COMCOD_SUCCESS:
3658 break;
3659 case EF_IA_64_VMS_COMCOD_WARNING:
3660 strcat (buf, ", warning");
3661 break;
3662 case EF_IA_64_VMS_COMCOD_ERROR:
3663 strcat (buf, ", error");
3664 break;
3665 case EF_IA_64_VMS_COMCOD_ABORT:
3666 strcat (buf, ", abort");
3667 break;
3668 default:
3669 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3670 e_flags & EF_IA_64_VMS_COMCOD);
3671 strcat (buf, ", <unknown>");
3672 }
3673 }
3674 break;
3675
3676 case EM_VAX:
3677 if ((e_flags & EF_VAX_NONPIC))
3678 strcat (buf, ", non-PIC");
3679 if ((e_flags & EF_VAX_DFLOAT))
3680 strcat (buf, ", D-Float");
3681 if ((e_flags & EF_VAX_GFLOAT))
3682 strcat (buf, ", G-Float");
3683 break;
3684
3685 case EM_VISIUM:
3686 if (e_flags & EF_VISIUM_ARCH_MCM)
3687 strcat (buf, ", mcm");
3688 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3689 strcat (buf, ", mcm24");
3690 if (e_flags & EF_VISIUM_ARCH_GR6)
3691 strcat (buf, ", gr6");
3692 break;
3693
3694 case EM_RL78:
3695 switch (e_flags & E_FLAG_RL78_CPU_MASK)
3696 {
3697 case E_FLAG_RL78_ANY_CPU: break;
3698 case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3699 case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3700 case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3701 }
3702 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3703 strcat (buf, ", 64-bit doubles");
3704 break;
3705
3706 case EM_RX:
3707 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3708 strcat (buf, ", 64-bit doubles");
3709 if (e_flags & E_FLAG_RX_DSP)
3710 strcat (buf, ", dsp");
3711 if (e_flags & E_FLAG_RX_PID)
3712 strcat (buf, ", pid");
3713 if (e_flags & E_FLAG_RX_ABI)
3714 strcat (buf, ", RX ABI");
3715 if (e_flags & E_FLAG_RX_SINSNS_SET)
3716 strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3717 ? ", uses String instructions" : ", bans String instructions");
3718 if (e_flags & E_FLAG_RX_V2)
3719 strcat (buf, ", V2");
3720 if (e_flags & E_FLAG_RX_V3)
3721 strcat (buf, ", V3");
3722 break;
3723
3724 case EM_S390:
3725 if (e_flags & EF_S390_HIGH_GPRS)
3726 strcat (buf, ", highgprs");
3727 break;
3728
3729 case EM_TI_C6000:
3730 if ((e_flags & EF_C6000_REL))
3731 strcat (buf, ", relocatable module");
3732 break;
3733
3734 case EM_MSP430:
3735 strcat (buf, _(": architecture variant: "));
3736 switch (e_flags & EF_MSP430_MACH)
3737 {
3738 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3739 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3740 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3741 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3742 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3743 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3744 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3745 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3746 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3747 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3748 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3749 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3750 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3751 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3752 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3753 default:
3754 strcat (buf, _(": unknown")); break;
3755 }
3756
3757 if (e_flags & ~ EF_MSP430_MACH)
3758 strcat (buf, _(": unknown extra flag bits also present"));
3759 }
3760 }
3761
3762 return buf;
3763}
3764
3765static const char *
3766get_osabi_name (Filedata * filedata, unsigned int osabi)
3767{
3768 static char buff[32];
3769
3770 switch (osabi)
3771 {
3772 case ELFOSABI_NONE: return "UNIX - System V";
3773 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3774 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
3775 case ELFOSABI_GNU: return "UNIX - GNU";
3776 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3777 case ELFOSABI_AIX: return "UNIX - AIX";
3778 case ELFOSABI_IRIX: return "UNIX - IRIX";
3779 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3780 case ELFOSABI_TRU64: return "UNIX - TRU64";
3781 case ELFOSABI_MODESTO: return "Novell - Modesto";
3782 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3783 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3784 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3785 case ELFOSABI_AROS: return "AROS";
3786 case ELFOSABI_FENIXOS: return "FenixOS";
3787 case ELFOSABI_CLOUDABI: return "Nuxi CloudABI";
3788 case ELFOSABI_OPENVOS: return "Stratus Technologies OpenVOS";
3789 default:
3790 if (osabi >= 64)
3791 switch (filedata->file_header.e_machine)
3792 {
3793 case EM_ARM:
3794 switch (osabi)
3795 {
3796 case ELFOSABI_ARM: return "ARM";
3797 case ELFOSABI_ARM_FDPIC: return "ARM FDPIC";
3798 default:
3799 break;
3800 }
3801 break;
3802
3803 case EM_MSP430:
3804 case EM_MSP430_OLD:
3805 case EM_VISIUM:
3806 switch (osabi)
3807 {
3808 case ELFOSABI_STANDALONE: return _("Standalone App");
3809 default:
3810 break;
3811 }
3812 break;
3813
3814 case EM_TI_C6000:
3815 switch (osabi)
3816 {
3817 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3818 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3819 default:
3820 break;
3821 }
3822 break;
3823
3824 default:
3825 break;
3826 }
3827 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3828 return buff;
3829 }
3830}
3831
3832static const char *
3833get_aarch64_segment_type (unsigned long type)
3834{
3835 switch (type)
3836 {
3837 case PT_AARCH64_ARCHEXT: return "AARCH64_ARCHEXT";
3838 default: return NULL;
3839 }
3840}
3841
3842static const char *
3843get_arm_segment_type (unsigned long type)
3844{
3845 switch (type)
3846 {
3847 case PT_ARM_EXIDX: return "EXIDX";
3848 default: return NULL;
3849 }
3850}
3851
3852static const char *
3853get_s390_segment_type (unsigned long type)
3854{
3855 switch (type)
3856 {
3857 case PT_S390_PGSTE: return "S390_PGSTE";
3858 default: return NULL;
3859 }
3860}
3861
3862static const char *
3863get_mips_segment_type (unsigned long type)
3864{
3865 switch (type)
3866 {
3867 case PT_MIPS_REGINFO: return "REGINFO";
3868 case PT_MIPS_RTPROC: return "RTPROC";
3869 case PT_MIPS_OPTIONS: return "OPTIONS";
3870 case PT_MIPS_ABIFLAGS: return "ABIFLAGS";
3871 default: return NULL;
3872 }
3873}
3874
3875static const char *
3876get_parisc_segment_type (unsigned long type)
3877{
3878 switch (type)
3879 {
3880 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3881 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
3882 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
3883 default: return NULL;
3884 }
3885}
3886
3887static const char *
3888get_ia64_segment_type (unsigned long type)
3889{
3890 switch (type)
3891 {
3892 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3893 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
3894 default: return NULL;
3895 }
3896}
3897
3898static const char *
3899get_tic6x_segment_type (unsigned long type)
3900{
3901 switch (type)
3902 {
3903 case PT_C6000_PHATTR: return "C6000_PHATTR";
3904 default: return NULL;
3905 }
3906}
3907
3908static const char *
3909get_hpux_segment_type (unsigned long type, unsigned e_machine)
3910{
3911 if (e_machine == EM_PARISC)
3912 switch (type)
3913 {
3914 case PT_HP_TLS: return "HP_TLS";
3915 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3916 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3917 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3918 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3919 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3920 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3921 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3922 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3923 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3924 case PT_HP_PARALLEL: return "HP_PARALLEL";
3925 case PT_HP_FASTBIND: return "HP_FASTBIND";
3926 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3927 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3928 case PT_HP_STACK: return "HP_STACK";
3929 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
3930 default: return NULL;
3931 }
3932
3933 if (e_machine == EM_IA_64)
3934 switch (type)
3935 {
3936 case PT_HP_TLS: return "HP_TLS";
3937 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3938 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3939 case PT_IA_64_HP_STACK: return "HP_STACK";
3940 default: return NULL;
3941 }
3942
3943 return NULL;
3944}
3945
3946static const char *
3947get_solaris_segment_type (unsigned long type)
3948{
3949 switch (type)
3950 {
3951 case 0x6464e550: return "PT_SUNW_UNWIND";
3952 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3953 case 0x6ffffff7: return "PT_LOSUNW";
3954 case 0x6ffffffa: return "PT_SUNWBSS";
3955 case 0x6ffffffb: return "PT_SUNWSTACK";
3956 case 0x6ffffffc: return "PT_SUNWDTRACE";
3957 case 0x6ffffffd: return "PT_SUNWCAP";
3958 case 0x6fffffff: return "PT_HISUNW";
3959 default: return NULL;
3960 }
3961}
3962
3963static const char *
3964get_segment_type (Filedata * filedata, unsigned long p_type)
3965{
3966 static char buff[32];
3967
3968 switch (p_type)
3969 {
3970 case PT_NULL: return "NULL";
3971 case PT_LOAD: return "LOAD";
3972 case PT_DYNAMIC: return "DYNAMIC";
3973 case PT_INTERP: return "INTERP";
3974 case PT_NOTE: return "NOTE";
3975 case PT_SHLIB: return "SHLIB";
3976 case PT_PHDR: return "PHDR";
3977 case PT_TLS: return "TLS";
3978 case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
3979 case PT_GNU_STACK: return "GNU_STACK";
3980 case PT_GNU_RELRO: return "GNU_RELRO";
3981 case PT_GNU_PROPERTY: return "GNU_PROPERTY";
3982
3983 default:
3984 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3985 {
3986 const char * result;
3987
3988 switch (filedata->file_header.e_machine)
3989 {
3990 case EM_AARCH64:
3991 result = get_aarch64_segment_type (p_type);
3992 break;
3993 case EM_ARM:
3994 result = get_arm_segment_type (p_type);
3995 break;
3996 case EM_MIPS:
3997 case EM_MIPS_RS3_LE:
3998 result = get_mips_segment_type (p_type);
3999 break;
4000 case EM_PARISC:
4001 result = get_parisc_segment_type (p_type);
4002 break;
4003 case EM_IA_64:
4004 result = get_ia64_segment_type (p_type);
4005 break;
4006 case EM_TI_C6000:
4007 result = get_tic6x_segment_type (p_type);
4008 break;
4009 case EM_S390:
4010 case EM_S390_OLD:
4011 result = get_s390_segment_type (p_type);
4012 break;
4013 default:
4014 result = NULL;
4015 break;
4016 }
4017
4018 if (result != NULL)
4019 return result;
4020
4021 sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
4022 }
4023 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
4024 {
4025 const char * result = NULL;
4026
4027 switch (filedata->file_header.e_ident[EI_OSABI])
4028 {
4029 case ELFOSABI_GNU:
4030 case ELFOSABI_FREEBSD:
4031 if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
4032 {
4033 sprintf (buff, "GNU_MBIND+%#lx", p_type - PT_GNU_MBIND_LO);
4034 result = buff;
4035 }
4036 break;
4037 case ELFOSABI_HPUX:
4038 result = get_hpux_segment_type (p_type,
4039 filedata->file_header.e_machine);
4040 break;
4041 case ELFOSABI_SOLARIS:
4042 result = get_solaris_segment_type (p_type);
4043 break;
4044 default:
4045 break;
4046 }
4047 if (result != NULL)
4048 return result;
4049
4050 sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
4051 }
4052 else
4053 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
4054
4055 return buff;
4056 }
4057}
4058
4059static const char *
4060get_arc_section_type_name (unsigned int sh_type)
4061{
4062 switch (sh_type)
4063 {
4064 case SHT_ARC_ATTRIBUTES: return "ARC_ATTRIBUTES";
4065 default:
4066 break;
4067 }
4068 return NULL;
4069}
4070
4071static const char *
4072get_mips_section_type_name (unsigned int sh_type)
4073{
4074 switch (sh_type)
4075 {
4076 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
4077 case SHT_MIPS_MSYM: return "MIPS_MSYM";
4078 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
4079 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
4080 case SHT_MIPS_UCODE: return "MIPS_UCODE";
4081 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
4082 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
4083 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
4084 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
4085 case SHT_MIPS_RELD: return "MIPS_RELD";
4086 case SHT_MIPS_IFACE: return "MIPS_IFACE";
4087 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
4088 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
4089 case SHT_MIPS_SHDR: return "MIPS_SHDR";
4090 case SHT_MIPS_FDESC: return "MIPS_FDESC";
4091 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
4092 case SHT_MIPS_DENSE: return "MIPS_DENSE";
4093 case SHT_MIPS_PDESC: return "MIPS_PDESC";
4094 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
4095 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
4096 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
4097 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
4098 case SHT_MIPS_LINE: return "MIPS_LINE";
4099 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
4100 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
4101 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
4102 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
4103 case SHT_MIPS_DWARF: return "MIPS_DWARF";
4104 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
4105 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
4106 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
4107 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
4108 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
4109 case SHT_MIPS_XLATE: return "MIPS_XLATE";
4110 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
4111 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
4112 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
4113 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
4114 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
4115 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
4116 default:
4117 break;
4118 }
4119 return NULL;
4120}
4121
4122static const char *
4123get_parisc_section_type_name (unsigned int sh_type)
4124{
4125 switch (sh_type)
4126 {
4127 case SHT_PARISC_EXT: return "PARISC_EXT";
4128 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
4129 case SHT_PARISC_DOC: return "PARISC_DOC";
4130 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
4131 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
4132 case SHT_PARISC_STUBS: return "PARISC_STUBS";
4133 case SHT_PARISC_DLKM: return "PARISC_DLKM";
4134 default: return NULL;
4135 }
4136}
4137
4138static const char *
4139get_ia64_section_type_name (Filedata * filedata, unsigned int sh_type)
4140{
4141 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4142 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
4143 return get_osabi_name (filedata, (sh_type & 0x00FF0000) >> 16);
4144
4145 switch (sh_type)
4146 {
4147 case SHT_IA_64_EXT: return "IA_64_EXT";
4148 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
4149 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
4150 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
4151 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
4152 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
4153 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
4154 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
4155 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
4156 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4157 default:
4158 break;
4159 }
4160 return NULL;
4161}
4162
4163static const char *
4164get_x86_64_section_type_name (unsigned int sh_type)
4165{
4166 switch (sh_type)
4167 {
4168 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
4169 default: return NULL;
4170 }
4171}
4172
4173static const char *
4174get_aarch64_section_type_name (unsigned int sh_type)
4175{
4176 switch (sh_type)
4177 {
4178 case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4179 default: return NULL;
4180 }
4181}
4182
4183static const char *
4184get_arm_section_type_name (unsigned int sh_type)
4185{
4186 switch (sh_type)
4187 {
4188 case SHT_ARM_EXIDX: return "ARM_EXIDX";
4189 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
4190 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
4191 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
4192 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
4193 default: return NULL;
4194 }
4195}
4196
4197static const char *
4198get_tic6x_section_type_name (unsigned int sh_type)
4199{
4200 switch (sh_type)
4201 {
4202 case SHT_C6000_UNWIND: return "C6000_UNWIND";
4203 case SHT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
4204 case SHT_C6000_ATTRIBUTES: return "C6000_ATTRIBUTES";
4205 case SHT_TI_ICODE: return "TI_ICODE";
4206 case SHT_TI_XREF: return "TI_XREF";
4207 case SHT_TI_HANDLER: return "TI_HANDLER";
4208 case SHT_TI_INITINFO: return "TI_INITINFO";
4209 case SHT_TI_PHATTRS: return "TI_PHATTRS";
4210 default: return NULL;
4211 }
4212}
4213
4214static const char *
4215get_msp430x_section_type_name (unsigned int sh_type)
4216{
4217 switch (sh_type)
4218 {
4219 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
4220 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
4221 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
4222 default: return NULL;
4223 }
4224}
4225
4226static const char *
4227get_nfp_section_type_name (unsigned int sh_type)
4228{
4229 switch (sh_type)
4230 {
4231 case SHT_NFP_MECONFIG: return "NFP_MECONFIG";
4232 case SHT_NFP_INITREG: return "NFP_INITREG";
4233 case SHT_NFP_UDEBUG: return "NFP_UDEBUG";
4234 default: return NULL;
4235 }
4236}
4237
4238static const char *
4239get_v850_section_type_name (unsigned int sh_type)
4240{
4241 switch (sh_type)
4242 {
4243 case SHT_V850_SCOMMON: return "V850 Small Common";
4244 case SHT_V850_TCOMMON: return "V850 Tiny Common";
4245 case SHT_V850_ZCOMMON: return "V850 Zero Common";
4246 case SHT_RENESAS_IOP: return "RENESAS IOP";
4247 case SHT_RENESAS_INFO: return "RENESAS INFO";
4248 default: return NULL;
4249 }
4250}
4251
4252static const char *
4253get_riscv_section_type_name (unsigned int sh_type)
4254{
4255 switch (sh_type)
4256 {
4257 case SHT_RISCV_ATTRIBUTES: return "RISCV_ATTRIBUTES";
4258 default: return NULL;
4259 }
4260}
4261
4262static const char *
4263get_section_type_name (Filedata * filedata, unsigned int sh_type)
4264{
4265 static char buff[32];
4266 const char * result;
4267
4268 switch (sh_type)
4269 {
4270 case SHT_NULL: return "NULL";
4271 case SHT_PROGBITS: return "PROGBITS";
4272 case SHT_SYMTAB: return "SYMTAB";
4273 case SHT_STRTAB: return "STRTAB";
4274 case SHT_RELA: return "RELA";
4275 case SHT_HASH: return "HASH";
4276 case SHT_DYNAMIC: return "DYNAMIC";
4277 case SHT_NOTE: return "NOTE";
4278 case SHT_NOBITS: return "NOBITS";
4279 case SHT_REL: return "REL";
4280 case SHT_SHLIB: return "SHLIB";
4281 case SHT_DYNSYM: return "DYNSYM";
4282 case SHT_INIT_ARRAY: return "INIT_ARRAY";
4283 case SHT_FINI_ARRAY: return "FINI_ARRAY";
4284 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
4285 case SHT_GNU_HASH: return "GNU_HASH";
4286 case SHT_GROUP: return "GROUP";
4287 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICES";
4288 case SHT_GNU_verdef: return "VERDEF";
4289 case SHT_GNU_verneed: return "VERNEED";
4290 case SHT_GNU_versym: return "VERSYM";
4291 case 0x6ffffff0: return "VERSYM";
4292 case 0x6ffffffc: return "VERDEF";
4293 case 0x7ffffffd: return "AUXILIARY";
4294 case 0x7fffffff: return "FILTER";
4295 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
4296
4297 default:
4298 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4299 {
4300 switch (filedata->file_header.e_machine)
4301 {
4302 case EM_ARC:
4303 case EM_ARC_COMPACT:
4304 case EM_ARC_COMPACT2:
4305 result = get_arc_section_type_name (sh_type);
4306 break;
4307 case EM_MIPS:
4308 case EM_MIPS_RS3_LE:
4309 result = get_mips_section_type_name (sh_type);
4310 break;
4311 case EM_PARISC:
4312 result = get_parisc_section_type_name (sh_type);
4313 break;
4314 case EM_IA_64:
4315 result = get_ia64_section_type_name (filedata, sh_type);
4316 break;
4317 case EM_X86_64:
4318 case EM_L1OM:
4319 case EM_K1OM:
4320 result = get_x86_64_section_type_name (sh_type);
4321 break;
4322 case EM_AARCH64:
4323 result = get_aarch64_section_type_name (sh_type);
4324 break;
4325 case EM_ARM:
4326 result = get_arm_section_type_name (sh_type);
4327 break;
4328 case EM_TI_C6000:
4329 result = get_tic6x_section_type_name (sh_type);
4330 break;
4331 case EM_MSP430:
4332 result = get_msp430x_section_type_name (sh_type);
4333 break;
4334 case EM_NFP:
4335 result = get_nfp_section_type_name (sh_type);
4336 break;
4337 case EM_V800:
4338 case EM_V850:
4339 case EM_CYGNUS_V850:
4340 result = get_v850_section_type_name (sh_type);
4341 break;
4342 case EM_RISCV:
4343 result = get_riscv_section_type_name (sh_type);
4344 break;
4345 default:
4346 result = NULL;
4347 break;
4348 }
4349
4350 if (result != NULL)
4351 return result;
4352
4353 sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4354 }
4355 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4356 {
4357 switch (filedata->file_header.e_machine)
4358 {
4359 case EM_IA_64:
4360 result = get_ia64_section_type_name (filedata, sh_type);
4361 break;
4362 default:
4363 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4364 result = get_solaris_section_type (sh_type);
4365 else
4366 {
4367 switch (sh_type)
4368 {
4369 case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4370 case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4371 case SHT_GNU_HASH: result = "GNU_HASH"; break;
4372 case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4373 default:
4374 result = NULL;
4375 break;
4376 }
4377 }
4378 break;
4379 }
4380
4381 if (result != NULL)
4382 return result;
4383
4384 sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4385 }
4386 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4387 {
4388 switch (filedata->file_header.e_machine)
4389 {
4390 case EM_V800:
4391 case EM_V850:
4392 case EM_CYGNUS_V850:
4393 result = get_v850_section_type_name (sh_type);
4394 break;
4395 default:
4396 result = NULL;
4397 break;
4398 }
4399
4400 if (result != NULL)
4401 return result;
4402
4403 sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4404 }
4405 else
4406 /* This message is probably going to be displayed in a 15
4407 character wide field, so put the hex value first. */
4408 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4409
4410 return buff;
4411 }
4412}
4413
4414#define OPTION_DEBUG_DUMP 512
4415#define OPTION_DYN_SYMS 513
4416#define OPTION_DWARF_DEPTH 514
4417#define OPTION_DWARF_START 515
4418#define OPTION_DWARF_CHECK 516
4419#define OPTION_CTF_DUMP 517
4420#define OPTION_CTF_PARENT 518
4421#define OPTION_CTF_SYMBOLS 519
4422#define OPTION_CTF_STRINGS 520
4423
4424static struct option options[] =
4425{
4426 {"all", no_argument, 0, 'a'},
4427 {"file-header", no_argument, 0, 'h'},
4428 {"program-headers", no_argument, 0, 'l'},
4429 {"headers", no_argument, 0, 'e'},
4430 {"histogram", no_argument, 0, 'I'},
4431 {"segments", no_argument, 0, 'l'},
4432 {"sections", no_argument, 0, 'S'},
4433 {"section-headers", no_argument, 0, 'S'},
4434 {"section-groups", no_argument, 0, 'g'},
4435 {"section-details", no_argument, 0, 't'},
4436 {"full-section-name",no_argument, 0, 'N'},
4437 {"symbols", no_argument, 0, 's'},
4438 {"syms", no_argument, 0, 's'},
4439 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
4440 {"relocs", no_argument, 0, 'r'},
4441 {"notes", no_argument, 0, 'n'},
4442 {"dynamic", no_argument, 0, 'd'},
4443 {"arch-specific", no_argument, 0, 'A'},
4444 {"version-info", no_argument, 0, 'V'},
4445 {"use-dynamic", no_argument, 0, 'D'},
4446 {"unwind", no_argument, 0, 'u'},
4447 {"archive-index", no_argument, 0, 'c'},
4448 {"hex-dump", required_argument, 0, 'x'},
4449 {"relocated-dump", required_argument, 0, 'R'},
4450 {"string-dump", required_argument, 0, 'p'},
4451 {"decompress", no_argument, 0, 'z'},
4452#ifdef SUPPORT_DISASSEMBLY
4453 {"instruction-dump", required_argument, 0, 'i'},
4454#endif
4455 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
4456
4457 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
4458 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4459 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
4460
4461 {"ctf", required_argument, 0, OPTION_CTF_DUMP},
4462
4463 {"ctf-symbols", required_argument, 0, OPTION_CTF_SYMBOLS},
4464 {"ctf-strings", required_argument, 0, OPTION_CTF_STRINGS},
4465 {"ctf-parent", required_argument, 0, OPTION_CTF_PARENT},
4466
4467 {"version", no_argument, 0, 'v'},
4468 {"wide", no_argument, 0, 'W'},
4469 {"help", no_argument, 0, 'H'},
4470 {0, no_argument, 0, 0}
4471};
4472
4473static void
4474usage (FILE * stream)
4475{
4476 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4477 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4478 fprintf (stream, _(" Options are:\n\
4479 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4480 -h --file-header Display the ELF file header\n\
4481 -l --program-headers Display the program headers\n\
4482 --segments An alias for --program-headers\n\
4483 -S --section-headers Display the sections' header\n\
4484 --sections An alias for --section-headers\n\
4485 -g --section-groups Display the section groups\n\
4486 -t --section-details Display the section details\n\
4487 -e --headers Equivalent to: -h -l -S\n\
4488 -s --syms Display the symbol table\n\
4489 --symbols An alias for --syms\n\
4490 --dyn-syms Display the dynamic symbol table\n\
4491 -n --notes Display the core notes (if present)\n\
4492 -r --relocs Display the relocations (if present)\n\
4493 -u --unwind Display the unwind info (if present)\n\
4494 -d --dynamic Display the dynamic section (if present)\n\
4495 -V --version-info Display the version sections (if present)\n\
4496 -A --arch-specific Display architecture specific information (if any)\n\
4497 -c --archive-index Display the symbol/file index in an archive\n\
4498 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4499 -x --hex-dump=<number|name>\n\
4500 Dump the contents of section <number|name> as bytes\n\
4501 -p --string-dump=<number|name>\n\
4502 Dump the contents of section <number|name> as strings\n\
4503 -R --relocated-dump=<number|name>\n\
4504 Dump the contents of section <number|name> as relocated bytes\n\
4505 -z --decompress Decompress section before dumping it\n\
4506 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4507 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4508 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4509 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4510 =addr,=cu_index,=links,=follow-links]\n\
4511 Display the contents of DWARF debug sections\n"));
4512 fprintf (stream, _("\
4513 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4514 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4515 or deeper\n"));
4516 fprintf (stream, _("\
4517 --ctf=<number|name> Display CTF info from section <number|name>\n\
4518 --ctf-parent=<number|name>\n\
4519 Use section <number|name> as the CTF parent\n\n\
4520 --ctf-symbols=<number|name>\n\
4521 Use section <number|name> as the CTF external symtab\n\n\
4522 --ctf-strings=<number|name>\n\
4523 Use section <number|name> as the CTF external strtab\n\n"));
4524
4525#ifdef SUPPORT_DISASSEMBLY
4526 fprintf (stream, _("\
4527 -i --instruction-dump=<number|name>\n\
4528 Disassemble the contents of section <number|name>\n"));
4529#endif
4530 fprintf (stream, _("\
4531 -I --histogram Display histogram of bucket list lengths\n\
4532 -W --wide Allow output width to exceed 80 characters\n\
4533 @<file> Read options from <file>\n\
4534 -H --help Display this information\n\
4535 -v --version Display the version number of readelf\n"));
4536
4537 if (REPORT_BUGS_TO[0] && stream == stdout)
4538 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4539
4540 exit (stream == stdout ? 0 : 1);
4541}
4542
4543/* Record the fact that the user wants the contents of section number
4544 SECTION to be displayed using the method(s) encoded as flags bits
4545 in TYPE. Note, TYPE can be zero if we are creating the array for
4546 the first time. */
4547
4548static void
4549request_dump_bynumber (Filedata * filedata, unsigned int section, dump_type type)
4550{
4551 if (section >= filedata->num_dump_sects)
4552 {
4553 dump_type * new_dump_sects;
4554
4555 new_dump_sects = (dump_type *) calloc (section + 1,
4556 sizeof (* new_dump_sects));
4557
4558 if (new_dump_sects == NULL)
4559 error (_("Out of memory allocating dump request table.\n"));
4560 else
4561 {
4562 if (filedata->dump_sects)
4563 {
4564 /* Copy current flag settings. */
4565 memcpy (new_dump_sects, filedata->dump_sects,
4566 filedata->num_dump_sects * sizeof (* new_dump_sects));
4567
4568 free (filedata->dump_sects);
4569 }
4570
4571 filedata->dump_sects = new_dump_sects;
4572 filedata->num_dump_sects = section + 1;
4573 }
4574 }
4575
4576 if (filedata->dump_sects)
4577 filedata->dump_sects[section] |= type;
4578}
4579
4580/* Request a dump by section name. */
4581
4582static void
4583request_dump_byname (const char * section, dump_type type)
4584{
4585 struct dump_list_entry * new_request;
4586
4587 new_request = (struct dump_list_entry *)
4588 malloc (sizeof (struct dump_list_entry));
4589 if (!new_request)
4590 error (_("Out of memory allocating dump request table.\n"));
4591
4592 new_request->name = strdup (section);
4593 if (!new_request->name)
4594 error (_("Out of memory allocating dump request table.\n"));
4595
4596 new_request->type = type;
4597
4598 new_request->next = dump_sects_byname;
4599 dump_sects_byname = new_request;
4600}
4601
4602static inline void
4603request_dump (Filedata * filedata, dump_type type)
4604{
4605 int section;
4606 char * cp;
4607
4608 do_dump++;
4609 section = strtoul (optarg, & cp, 0);
4610
4611 if (! *cp && section >= 0)
4612 request_dump_bynumber (filedata, section, type);
4613 else
4614 request_dump_byname (optarg, type);
4615}
4616
4617static void
4618parse_args (Filedata * filedata, int argc, char ** argv)
4619{
4620 int c;
4621
4622 if (argc < 2)
4623 usage (stderr);
4624
4625 while ((c = getopt_long
4626 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4627 {
4628 switch (c)
4629 {
4630 case 0:
4631 /* Long options. */
4632 break;
4633 case 'H':
4634 usage (stdout);
4635 break;
4636
4637 case 'a':
4638 do_syms = TRUE;
4639 do_reloc = TRUE;
4640 do_unwind = TRUE;
4641 do_dynamic = TRUE;
4642 do_header = TRUE;
4643 do_sections = TRUE;
4644 do_section_groups = TRUE;
4645 do_segments = TRUE;
4646 do_version = TRUE;
4647 do_histogram = TRUE;
4648 do_arch = TRUE;
4649 do_notes = TRUE;
4650 break;
4651 case 'g':
4652 do_section_groups = TRUE;
4653 break;
4654 case 't':
4655 case 'N':
4656 do_sections = TRUE;
4657 do_section_details = TRUE;
4658 break;
4659 case 'e':
4660 do_header = TRUE;
4661 do_sections = TRUE;
4662 do_segments = TRUE;
4663 break;
4664 case 'A':
4665 do_arch = TRUE;
4666 break;
4667 case 'D':
4668 do_using_dynamic = TRUE;
4669 break;
4670 case 'r':
4671 do_reloc = TRUE;
4672 break;
4673 case 'u':
4674 do_unwind = TRUE;
4675 break;
4676 case 'h':
4677 do_header = TRUE;
4678 break;
4679 case 'l':
4680 do_segments = TRUE;
4681 break;
4682 case 's':
4683 do_syms = TRUE;
4684 break;
4685 case 'S':
4686 do_sections = TRUE;
4687 break;
4688 case 'd':
4689 do_dynamic = TRUE;
4690 break;
4691 case 'I':
4692 do_histogram = TRUE;
4693 break;
4694 case 'n':
4695 do_notes = TRUE;
4696 break;
4697 case 'c':
4698 do_archive_index = TRUE;
4699 break;
4700 case 'x':
4701 request_dump (filedata, HEX_DUMP);
4702 break;
4703 case 'p':
4704 request_dump (filedata, STRING_DUMP);
4705 break;
4706 case 'R':
4707 request_dump (filedata, RELOC_DUMP);
4708 break;
4709 case 'z':
4710 decompress_dumps = TRUE;
4711 break;
4712 case 'w':
4713 do_dump = TRUE;
4714 if (optarg == 0)
4715 {
4716 do_debugging = TRUE;
4717 dwarf_select_sections_all ();
4718 }
4719 else
4720 {
4721 do_debugging = FALSE;
4722 dwarf_select_sections_by_letters (optarg);
4723 }
4724 break;
4725 case OPTION_DEBUG_DUMP:
4726 do_dump = TRUE;
4727 if (optarg == 0)
4728 do_debugging = TRUE;
4729 else
4730 {
4731 do_debugging = FALSE;
4732 dwarf_select_sections_by_names (optarg);
4733 }
4734 break;
4735 case OPTION_DWARF_DEPTH:
4736 {
4737 char *cp;
4738
4739 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4740 }
4741 break;
4742 case OPTION_DWARF_START:
4743 {
4744 char *cp;
4745
4746 dwarf_start_die = strtoul (optarg, & cp, 0);
4747 }
4748 break;
4749 case OPTION_DWARF_CHECK:
4750 dwarf_check = TRUE;
4751 break;
4752 case OPTION_CTF_DUMP:
4753 do_ctf = TRUE;
4754 request_dump (filedata, CTF_DUMP);
4755 break;
4756 case OPTION_CTF_SYMBOLS:
4757 dump_ctf_symtab_name = strdup (optarg);
4758 break;
4759 case OPTION_CTF_STRINGS:
4760 dump_ctf_strtab_name = strdup (optarg);
4761 break;
4762 case OPTION_CTF_PARENT:
4763 dump_ctf_parent_name = strdup (optarg);
4764 break;
4765 case OPTION_DYN_SYMS:
4766 do_dyn_syms = TRUE;
4767 break;
4768#ifdef SUPPORT_DISASSEMBLY
4769 case 'i':
4770 request_dump (filedata, DISASS_DUMP);
4771 break;
4772#endif
4773 case 'v':
4774 print_version (program_name);
4775 break;
4776 case 'V':
4777 do_version = TRUE;
4778 break;
4779 case 'W':
4780 do_wide = TRUE;
4781 break;
4782 default:
4783 /* xgettext:c-format */
4784 error (_("Invalid option '-%c'\n"), c);
4785 /* Fall through. */
4786 case '?':
4787 usage (stderr);
4788 }
4789 }
4790
4791 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4792 && !do_segments && !do_header && !do_dump && !do_version
4793 && !do_histogram && !do_debugging && !do_arch && !do_notes
4794 && !do_section_groups && !do_archive_index
4795 && !do_dyn_syms)
4796 usage (stderr);
4797}
4798
4799static const char *
4800get_elf_class (unsigned int elf_class)
4801{
4802 static char buff[32];
4803
4804 switch (elf_class)
4805 {
4806 case ELFCLASSNONE: return _("none");
4807 case ELFCLASS32: return "ELF32";
4808 case ELFCLASS64: return "ELF64";
4809 default:
4810 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4811 return buff;
4812 }
4813}
4814
4815static const char *
4816get_data_encoding (unsigned int encoding)
4817{
4818 static char buff[32];
4819
4820 switch (encoding)
4821 {
4822 case ELFDATANONE: return _("none");
4823 case ELFDATA2LSB: return _("2's complement, little endian");
4824 case ELFDATA2MSB: return _("2's complement, big endian");
4825 default:
4826 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4827 return buff;
4828 }
4829}
4830
4831/* Decode the data held in 'filedata->file_header'. */
4832
4833static bfd_boolean
4834process_file_header (Filedata * filedata)
4835{
4836 Elf_Internal_Ehdr * header = & filedata->file_header;
4837
4838 if ( header->e_ident[EI_MAG0] != ELFMAG0
4839 || header->e_ident[EI_MAG1] != ELFMAG1
4840 || header->e_ident[EI_MAG2] != ELFMAG2
4841 || header->e_ident[EI_MAG3] != ELFMAG3)
4842 {
4843 error
4844 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4845 return FALSE;
4846 }
4847
4848 init_dwarf_regnames (header->e_machine);
4849
4850 if (do_header)
4851 {
4852 unsigned i;
4853
4854 printf (_("ELF Header:\n"));
4855 printf (_(" Magic: "));
4856 for (i = 0; i < EI_NIDENT; i++)
4857 printf ("%2.2x ", header->e_ident[i]);
4858 printf ("\n");
4859 printf (_(" Class: %s\n"),
4860 get_elf_class (header->e_ident[EI_CLASS]));
4861 printf (_(" Data: %s\n"),
4862 get_data_encoding (header->e_ident[EI_DATA]));
4863 printf (_(" Version: %d%s\n"),
4864 header->e_ident[EI_VERSION],
4865 (header->e_ident[EI_VERSION] == EV_CURRENT
4866 ? _(" (current)")
4867 : (header->e_ident[EI_VERSION] != EV_NONE
4868 ? _(" <unknown>")
4869 : "")));
4870 printf (_(" OS/ABI: %s\n"),
4871 get_osabi_name (filedata, header->e_ident[EI_OSABI]));
4872 printf (_(" ABI Version: %d\n"),
4873 header->e_ident[EI_ABIVERSION]);
4874 printf (_(" Type: %s\n"),
4875 get_file_type (header->e_type));
4876 printf (_(" Machine: %s\n"),
4877 get_machine_name (header->e_machine));
4878 printf (_(" Version: 0x%lx\n"),
4879 header->e_version);
4880
4881 printf (_(" Entry point address: "));
4882 print_vma (header->e_entry, PREFIX_HEX);
4883 printf (_("\n Start of program headers: "));
4884 print_vma (header->e_phoff, DEC);
4885 printf (_(" (bytes into file)\n Start of section headers: "));
4886 print_vma (header->e_shoff, DEC);
4887 printf (_(" (bytes into file)\n"));
4888
4889 printf (_(" Flags: 0x%lx%s\n"),
4890 header->e_flags,
4891 get_machine_flags (filedata, header->e_flags, header->e_machine));
4892 printf (_(" Size of this header: %u (bytes)\n"),
4893 header->e_ehsize);
4894 printf (_(" Size of program headers: %u (bytes)\n"),
4895 header->e_phentsize);
4896 printf (_(" Number of program headers: %u"),
4897 header->e_phnum);
4898 if (filedata->section_headers != NULL
4899 && header->e_phnum == PN_XNUM
4900 && filedata->section_headers[0].sh_info != 0)
4901 {
4902 header->e_phnum = filedata->section_headers[0].sh_info;
4903 printf (" (%u)", header->e_phnum);
4904 }
4905 putc ('\n', stdout);
4906 printf (_(" Size of section headers: %u (bytes)\n"),
4907 header->e_shentsize);
4908 printf (_(" Number of section headers: %u"),
4909 header->e_shnum);
4910 if (filedata->section_headers != NULL && header->e_shnum == SHN_UNDEF)
4911 {
4912 header->e_shnum = filedata->section_headers[0].sh_size;
4913 printf (" (%u)", header->e_shnum);
4914 }
4915 putc ('\n', stdout);
4916 printf (_(" Section header string table index: %u"),
4917 header->e_shstrndx);
4918 if (filedata->section_headers != NULL
4919 && header->e_shstrndx == (SHN_XINDEX & 0xffff))
4920 {
4921 header->e_shstrndx = filedata->section_headers[0].sh_link;
4922 printf (" (%u)", header->e_shstrndx);
4923 }
4924 if (header->e_shstrndx != SHN_UNDEF
4925 && header->e_shstrndx >= header->e_shnum)
4926 {
4927 header->e_shstrndx = SHN_UNDEF;
4928 printf (_(" <corrupt: out of range>"));
4929 }
4930 putc ('\n', stdout);
4931 }
4932
4933 if (filedata->section_headers != NULL)
4934 {
4935 if (header->e_phnum == PN_XNUM
4936 && filedata->section_headers[0].sh_info != 0)
4937 header->e_phnum = filedata->section_headers[0].sh_info;
4938 if (header->e_shnum == SHN_UNDEF)
4939 header->e_shnum = filedata->section_headers[0].sh_size;
4940 if (header->e_shstrndx == (SHN_XINDEX & 0xffff))
4941 header->e_shstrndx = filedata->section_headers[0].sh_link;
4942 if (header->e_shstrndx >= header->e_shnum)
4943 header->e_shstrndx = SHN_UNDEF;
4944 free (filedata->section_headers);
4945 filedata->section_headers = NULL;
4946 }
4947
4948 return TRUE;
4949}
4950
4951/* Read in the program headers from FILEDATA and store them in PHEADERS.
4952 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
4953
4954static bfd_boolean
4955get_32bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4956{
4957 Elf32_External_Phdr * phdrs;
4958 Elf32_External_Phdr * external;
4959 Elf_Internal_Phdr * internal;
4960 unsigned int i;
4961 unsigned int size = filedata->file_header.e_phentsize;
4962 unsigned int num = filedata->file_header.e_phnum;
4963
4964 /* PR binutils/17531: Cope with unexpected section header sizes. */
4965 if (size == 0 || num == 0)
4966 return FALSE;
4967 if (size < sizeof * phdrs)
4968 {
4969 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4970 return FALSE;
4971 }
4972 if (size > sizeof * phdrs)
4973 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4974
4975 phdrs = (Elf32_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4976 size, num, _("program headers"));
4977 if (phdrs == NULL)
4978 return FALSE;
4979
4980 for (i = 0, internal = pheaders, external = phdrs;
4981 i < filedata->file_header.e_phnum;
4982 i++, internal++, external++)
4983 {
4984 internal->p_type = BYTE_GET (external->p_type);
4985 internal->p_offset = BYTE_GET (external->p_offset);
4986 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4987 internal->p_paddr = BYTE_GET (external->p_paddr);
4988 internal->p_filesz = BYTE_GET (external->p_filesz);
4989 internal->p_memsz = BYTE_GET (external->p_memsz);
4990 internal->p_flags = BYTE_GET (external->p_flags);
4991 internal->p_align = BYTE_GET (external->p_align);
4992 }
4993
4994 free (phdrs);
4995 return TRUE;
4996}
4997
4998/* Read in the program headers from FILEDATA and store them in PHEADERS.
4999 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5000
5001static bfd_boolean
5002get_64bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
5003{
5004 Elf64_External_Phdr * phdrs;
5005 Elf64_External_Phdr * external;
5006 Elf_Internal_Phdr * internal;
5007 unsigned int i;
5008 unsigned int size = filedata->file_header.e_phentsize;
5009 unsigned int num = filedata->file_header.e_phnum;
5010
5011 /* PR binutils/17531: Cope with unexpected section header sizes. */
5012 if (size == 0 || num == 0)
5013 return FALSE;
5014 if (size < sizeof * phdrs)
5015 {
5016 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5017 return FALSE;
5018 }
5019 if (size > sizeof * phdrs)
5020 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5021
5022 phdrs = (Elf64_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
5023 size, num, _("program headers"));
5024 if (!phdrs)
5025 return FALSE;
5026
5027 for (i = 0, internal = pheaders, external = phdrs;
5028 i < filedata->file_header.e_phnum;
5029 i++, internal++, external++)
5030 {
5031 internal->p_type = BYTE_GET (external->p_type);
5032 internal->p_flags = BYTE_GET (external->p_flags);
5033 internal->p_offset = BYTE_GET (external->p_offset);
5034 internal->p_vaddr = BYTE_GET (external->p_vaddr);
5035 internal->p_paddr = BYTE_GET (external->p_paddr);
5036 internal->p_filesz = BYTE_GET (external->p_filesz);
5037 internal->p_memsz = BYTE_GET (external->p_memsz);
5038 internal->p_align = BYTE_GET (external->p_align);
5039 }
5040
5041 free (phdrs);
5042 return TRUE;
5043}
5044
5045/* Returns TRUE if the program headers were read into `program_headers'. */
5046
5047static bfd_boolean
5048get_program_headers (Filedata * filedata)
5049{
5050 Elf_Internal_Phdr * phdrs;
5051
5052 /* Check cache of prior read. */
5053 if (filedata->program_headers != NULL)
5054 return TRUE;
5055
5056 /* Be kind to memory checkers by looking for
5057 e_phnum values which we know must be invalid. */
5058 if (filedata->file_header.e_phnum
5059 * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
5060 >= filedata->file_size)
5061 {
5062 error (_("Too many program headers - %#x - the file is not that big\n"),
5063 filedata->file_header.e_phnum);
5064 return FALSE;
5065 }
5066
5067 phdrs = (Elf_Internal_Phdr *) cmalloc (filedata->file_header.e_phnum,
5068 sizeof (Elf_Internal_Phdr));
5069 if (phdrs == NULL)
5070 {
5071 error (_("Out of memory reading %u program headers\n"),
5072 filedata->file_header.e_phnum);
5073 return FALSE;
5074 }
5075
5076 if (is_32bit_elf
5077 ? get_32bit_program_headers (filedata, phdrs)
5078 : get_64bit_program_headers (filedata, phdrs))
5079 {
5080 filedata->program_headers = phdrs;
5081 return TRUE;
5082 }
5083
5084 free (phdrs);
5085 return FALSE;
5086}
5087
5088/* Returns TRUE if the program headers were loaded. */
5089
5090static bfd_boolean
5091process_program_headers (Filedata * filedata)
5092{
5093 Elf_Internal_Phdr * segment;
5094 unsigned int i;
5095 Elf_Internal_Phdr * previous_load = NULL;
5096
5097 if (filedata->file_header.e_phnum == 0)
5098 {
5099 /* PR binutils/12467. */
5100 if (filedata->file_header.e_phoff != 0)
5101 {
5102 warn (_("possibly corrupt ELF header - it has a non-zero program"
5103 " header offset, but no program headers\n"));
5104 return FALSE;
5105 }
5106 else if (do_segments)
5107 printf (_("\nThere are no program headers in this file.\n"));
5108 return TRUE;
5109 }
5110
5111 if (do_segments && !do_header)
5112 {
5113 printf (_("\nElf file type is %s\n"), get_file_type (filedata->file_header.e_type));
5114 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata->file_header.e_entry));
5115 printf (ngettext ("There is %d program header, starting at offset %s\n",
5116 "There are %d program headers, starting at offset %s\n",
5117 filedata->file_header.e_phnum),
5118 filedata->file_header.e_phnum,
5119 bfd_vmatoa ("u", filedata->file_header.e_phoff));
5120 }
5121
5122 if (! get_program_headers (filedata))
5123 return TRUE;
5124
5125 if (do_segments)
5126 {
5127 if (filedata->file_header.e_phnum > 1)
5128 printf (_("\nProgram Headers:\n"));
5129 else
5130 printf (_("\nProgram Headers:\n"));
5131
5132 if (is_32bit_elf)
5133 printf
5134 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5135 else if (do_wide)
5136 printf
5137 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5138 else
5139 {
5140 printf
5141 (_(" Type Offset VirtAddr PhysAddr\n"));
5142 printf
5143 (_(" FileSiz MemSiz Flags Align\n"));
5144 }
5145 }
5146
5147 dynamic_addr = 0;
5148 dynamic_size = 0;
5149
5150 for (i = 0, segment = filedata->program_headers;
5151 i < filedata->file_header.e_phnum;
5152 i++, segment++)
5153 {
5154 if (do_segments)
5155 {
5156 printf (" %-14.14s ", get_segment_type (filedata, segment->p_type));
5157
5158 if (is_32bit_elf)
5159 {
5160 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5161 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
5162 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
5163 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
5164 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
5165 printf ("%c%c%c ",
5166 (segment->p_flags & PF_R ? 'R' : ' '),
5167 (segment->p_flags & PF_W ? 'W' : ' '),
5168 (segment->p_flags & PF_X ? 'E' : ' '));
5169 printf ("%#lx", (unsigned long) segment->p_align);
5170 }
5171 else if (do_wide)
5172 {
5173 if ((unsigned long) segment->p_offset == segment->p_offset)
5174 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5175 else
5176 {
5177 print_vma (segment->p_offset, FULL_HEX);
5178 putchar (' ');
5179 }
5180
5181 print_vma (segment->p_vaddr, FULL_HEX);
5182 putchar (' ');
5183 print_vma (segment->p_paddr, FULL_HEX);
5184 putchar (' ');
5185
5186 if ((unsigned long) segment->p_filesz == segment->p_filesz)
5187 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
5188 else
5189 {
5190 print_vma (segment->p_filesz, FULL_HEX);
5191 putchar (' ');
5192 }
5193
5194 if ((unsigned long) segment->p_memsz == segment->p_memsz)
5195 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
5196 else
5197 {
5198 print_vma (segment->p_memsz, FULL_HEX);
5199 }
5200
5201 printf (" %c%c%c ",
5202 (segment->p_flags & PF_R ? 'R' : ' '),
5203 (segment->p_flags & PF_W ? 'W' : ' '),
5204 (segment->p_flags & PF_X ? 'E' : ' '));
5205
5206 if ((unsigned long) segment->p_align == segment->p_align)
5207 printf ("%#lx", (unsigned long) segment->p_align);
5208 else
5209 {
5210 print_vma (segment->p_align, PREFIX_HEX);
5211 }
5212 }
5213 else
5214 {
5215 print_vma (segment->p_offset, FULL_HEX);
5216 putchar (' ');
5217 print_vma (segment->p_vaddr, FULL_HEX);
5218 putchar (' ');
5219 print_vma (segment->p_paddr, FULL_HEX);
5220 printf ("\n ");
5221 print_vma (segment->p_filesz, FULL_HEX);
5222 putchar (' ');
5223 print_vma (segment->p_memsz, FULL_HEX);
5224 printf (" %c%c%c ",
5225 (segment->p_flags & PF_R ? 'R' : ' '),
5226 (segment->p_flags & PF_W ? 'W' : ' '),
5227 (segment->p_flags & PF_X ? 'E' : ' '));
5228 print_vma (segment->p_align, PREFIX_HEX);
5229 }
5230
5231 putc ('\n', stdout);
5232 }
5233
5234 switch (segment->p_type)
5235 {
5236 case PT_LOAD:
5237#if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5238 required by the ELF standard, several programs, including the Linux
5239 kernel, make use of non-ordered segments. */
5240 if (previous_load
5241 && previous_load->p_vaddr > segment->p_vaddr)
5242 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5243#endif
5244 if (segment->p_memsz < segment->p_filesz)
5245 error (_("the segment's file size is larger than its memory size\n"));
5246 previous_load = segment;
5247 break;
5248
5249 case PT_PHDR:
5250 /* PR 20815 - Verify that the program header is loaded into memory. */
5251 if (i > 0 && previous_load != NULL)
5252 error (_("the PHDR segment must occur before any LOAD segment\n"));
5253 if (filedata->file_header.e_machine != EM_PARISC)
5254 {
5255 unsigned int j;
5256
5257 for (j = 1; j < filedata->file_header.e_phnum; j++)
5258 if (filedata->program_headers[j].p_vaddr <= segment->p_vaddr
5259 && (filedata->program_headers[j].p_vaddr
5260 + filedata->program_headers[j].p_memsz)
5261 >= (segment->p_vaddr + segment->p_filesz))
5262 break;
5263 if (j == filedata->file_header.e_phnum)
5264 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5265 }
5266 break;
5267
5268 case PT_DYNAMIC:
5269 if (dynamic_addr)
5270 error (_("more than one dynamic segment\n"));
5271
5272 /* By default, assume that the .dynamic section is the first
5273 section in the DYNAMIC segment. */
5274 dynamic_addr = segment->p_offset;
5275 dynamic_size = segment->p_filesz;
5276
5277 /* Try to locate the .dynamic section. If there is
5278 a section header table, we can easily locate it. */
5279 if (filedata->section_headers != NULL)
5280 {
5281 Elf_Internal_Shdr * sec;
5282
5283 sec = find_section (filedata, ".dynamic");
5284 if (sec == NULL || sec->sh_size == 0)
5285 {
5286 /* A corresponding .dynamic section is expected, but on
5287 IA-64/OpenVMS it is OK for it to be missing. */
5288 if (!is_ia64_vms (filedata))
5289 error (_("no .dynamic section in the dynamic segment\n"));
5290 break;
5291 }
5292
5293 if (sec->sh_type == SHT_NOBITS)
5294 {
5295 dynamic_size = 0;
5296 break;
5297 }
5298
5299 dynamic_addr = sec->sh_offset;
5300 dynamic_size = sec->sh_size;
5301
5302 if (dynamic_addr < segment->p_offset
5303 || dynamic_addr > segment->p_offset + segment->p_filesz)
5304 warn (_("the .dynamic section is not contained"
5305 " within the dynamic segment\n"));
5306 else if (dynamic_addr > segment->p_offset)
5307 warn (_("the .dynamic section is not the first section"
5308 " in the dynamic segment.\n"));
5309 }
5310
5311 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5312 segment. Check this after matching against the section headers
5313 so we don't warn on debuginfo file (which have NOBITS .dynamic
5314 sections). */
5315 if (dynamic_addr > filedata->file_size
5316 || dynamic_size > filedata->file_size - dynamic_addr)
5317 {
5318 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5319 dynamic_addr = dynamic_size = 0;
5320 }
5321 break;
5322
5323 case PT_INTERP:
5324 if (fseek (filedata->handle, archive_file_offset + (long) segment->p_offset,
5325 SEEK_SET))
5326 error (_("Unable to find program interpreter name\n"));
5327 else
5328 {
5329 char fmt [32];
5330 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5331
5332 if (ret >= (int) sizeof (fmt) || ret < 0)
5333 error (_("Internal error: failed to create format string to display program interpreter\n"));
5334
5335 program_interpreter[0] = 0;
5336 if (fscanf (filedata->handle, fmt, program_interpreter) <= 0)
5337 error (_("Unable to read program interpreter name\n"));
5338
5339 if (do_segments)
5340 printf (_(" [Requesting program interpreter: %s]\n"),
5341 program_interpreter);
5342 }
5343 break;
5344 }
5345 }
5346
5347 if (do_segments
5348 && filedata->section_headers != NULL
5349 && filedata->string_table != NULL)
5350 {
5351 printf (_("\n Section to Segment mapping:\n"));
5352 printf (_(" Segment Sections...\n"));
5353
5354 for (i = 0; i < filedata->file_header.e_phnum; i++)
5355 {
5356 unsigned int j;
5357 Elf_Internal_Shdr * section;
5358
5359 segment = filedata->program_headers + i;
5360 section = filedata->section_headers + 1;
5361
5362 printf (" %2.2d ", i);
5363
5364 for (j = 1; j < filedata->file_header.e_shnum; j++, section++)
5365 {
5366 if (!ELF_TBSS_SPECIAL (section, segment)
5367 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5368 printf ("%s ", printable_section_name (filedata, section));
5369 }
5370
5371 putc ('\n',stdout);
5372 }
5373 }
5374
5375 return TRUE;
5376}
5377
5378
5379/* Find the file offset corresponding to VMA by using the program headers. */
5380
5381static long
5382offset_from_vma (Filedata * filedata, bfd_vma vma, bfd_size_type size)
5383{
5384 Elf_Internal_Phdr * seg;
5385
5386 if (! get_program_headers (filedata))
5387 {
5388 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5389 return (long) vma;
5390 }
5391
5392 for (seg = filedata->program_headers;
5393 seg < filedata->program_headers + filedata->file_header.e_phnum;
5394 ++seg)
5395 {
5396 if (seg->p_type != PT_LOAD)
5397 continue;
5398
5399 if (vma >= (seg->p_vaddr & -seg->p_align)
5400 && vma + size <= seg->p_vaddr + seg->p_filesz)
5401 return vma - seg->p_vaddr + seg->p_offset;
5402 }
5403
5404 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5405 (unsigned long) vma);
5406 return (long) vma;
5407}
5408
5409
5410/* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5411 If PROBE is true, this is just a probe and we do not generate any error
5412 messages if the load fails. */
5413
5414static bfd_boolean
5415get_32bit_section_headers (Filedata * filedata, bfd_boolean probe)
5416{
5417 Elf32_External_Shdr * shdrs;
5418 Elf_Internal_Shdr * internal;
5419 unsigned int i;
5420 unsigned int size = filedata->file_header.e_shentsize;
5421 unsigned int num = probe ? 1 : filedata->file_header.e_shnum;
5422
5423 /* PR binutils/17531: Cope with unexpected section header sizes. */
5424 if (size == 0 || num == 0)
5425 return FALSE;
5426 if (size < sizeof * shdrs)
5427 {
5428 if (! probe)
5429 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5430 return FALSE;
5431 }
5432 if (!probe && size > sizeof * shdrs)
5433 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5434
5435 shdrs = (Elf32_External_Shdr *) get_data (NULL, filedata, filedata->file_header.e_shoff,
5436 size, num,
5437 probe ? NULL : _("section headers"));
5438 if (shdrs == NULL)
5439 return FALSE;
5440
5441 free (filedata->section_headers);
5442 filedata->section_headers = (Elf_Internal_Shdr *)
5443 cmalloc (num, sizeof (Elf_Internal_Shdr));
5444 if (filedata->section_headers == NULL)
5445 {
5446 if (!probe)
5447 error (_("Out of memory reading %u section headers\n"), num);
5448 free (shdrs);
5449 return FALSE;
5450 }
5451
5452 for (i = 0, internal = filedata->section_headers;
5453 i < num;
5454 i++, internal++)
5455 {
5456 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5457 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5458 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5459 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5460 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5461 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5462 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5463 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5464 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5465 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
5466 if (!probe && internal->sh_link > num)
5467 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5468 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5469 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5470 }
5471
5472 free (shdrs);
5473 return TRUE;
5474}
5475
5476/* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5477
5478static bfd_boolean
5479get_64bit_section_headers (Filedata * filedata, bfd_boolean probe)
5480{
5481 Elf64_External_Shdr * shdrs;
5482 Elf_Internal_Shdr * internal;
5483 unsigned int i;
5484 unsigned int size = filedata->file_header.e_shentsize;
5485 unsigned int num = probe ? 1 : filedata->file_header.e_shnum;
5486
5487 /* PR binutils/17531: Cope with unexpected section header sizes. */
5488 if (size == 0 || num == 0)
5489 return FALSE;
5490
5491 if (size < sizeof * shdrs)
5492 {
5493 if (! probe)
5494 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5495 return FALSE;
5496 }
5497
5498 if (! probe && size > sizeof * shdrs)
5499 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5500
5501 shdrs = (Elf64_External_Shdr *) get_data (NULL, filedata,
5502 filedata->file_header.e_shoff,
5503 size, num,
5504 probe ? NULL : _("section headers"));
5505 if (shdrs == NULL)
5506 return FALSE;
5507
5508 free (filedata->section_headers);
5509 filedata->section_headers = (Elf_Internal_Shdr *)
5510 cmalloc (num, sizeof (Elf_Internal_Shdr));
5511 if (filedata->section_headers == NULL)
5512 {
5513 if (! probe)
5514 error (_("Out of memory reading %u section headers\n"), num);
5515 free (shdrs);
5516 return FALSE;
5517 }
5518
5519 for (i = 0, internal = filedata->section_headers;
5520 i < num;
5521 i++, internal++)
5522 {
5523 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5524 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5525 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5526 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5527 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5528 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
5529 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5530 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5531 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5532 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5533 if (!probe && internal->sh_link > num)
5534 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5535 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5536 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5537 }
5538
5539 free (shdrs);
5540 return TRUE;
5541}
5542
5543static Elf_Internal_Sym *
5544get_32bit_elf_symbols (Filedata * filedata,
5545 Elf_Internal_Shdr * section,
5546 unsigned long * num_syms_return)
5547{
5548 unsigned long number = 0;
5549 Elf32_External_Sym * esyms = NULL;
5550 Elf_External_Sym_Shndx * shndx = NULL;
5551 Elf_Internal_Sym * isyms = NULL;
5552 Elf_Internal_Sym * psym;
5553 unsigned int j;
5554 elf_section_list * entry;
5555
5556 if (section->sh_size == 0)
5557 {
5558 if (num_syms_return != NULL)
5559 * num_syms_return = 0;
5560 return NULL;
5561 }
5562
5563 /* Run some sanity checks first. */
5564 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5565 {
5566 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5567 printable_section_name (filedata, section),
5568 (unsigned long) section->sh_entsize);
5569 goto exit_point;
5570 }
5571
5572 if (section->sh_size > filedata->file_size)
5573 {
5574 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5575 printable_section_name (filedata, section),
5576 (unsigned long) section->sh_size);
5577 goto exit_point;
5578 }
5579
5580 number = section->sh_size / section->sh_entsize;
5581
5582 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5583 {
5584 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5585 (unsigned long) section->sh_size,
5586 printable_section_name (filedata, section),
5587 (unsigned long) section->sh_entsize);
5588 goto exit_point;
5589 }
5590
5591 esyms = (Elf32_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5592 section->sh_size, _("symbols"));
5593 if (esyms == NULL)
5594 goto exit_point;
5595
5596 shndx = NULL;
5597 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5598 {
5599 if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5600 continue;
5601
5602 if (shndx != NULL)
5603 {
5604 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5605 free (shndx);
5606 }
5607
5608 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5609 entry->hdr->sh_offset,
5610 1, entry->hdr->sh_size,
5611 _("symbol table section indices"));
5612 if (shndx == NULL)
5613 goto exit_point;
5614
5615 /* PR17531: file: heap-buffer-overflow */
5616 if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5617 {
5618 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5619 printable_section_name (filedata, entry->hdr),
5620 (unsigned long) entry->hdr->sh_size,
5621 (unsigned long) section->sh_size);
5622 goto exit_point;
5623 }
5624 }
5625
5626 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5627
5628 if (isyms == NULL)
5629 {
5630 error (_("Out of memory reading %lu symbols\n"),
5631 (unsigned long) number);
5632 goto exit_point;
5633 }
5634
5635 for (j = 0, psym = isyms; j < number; j++, psym++)
5636 {
5637 psym->st_name = BYTE_GET (esyms[j].st_name);
5638 psym->st_value = BYTE_GET (esyms[j].st_value);
5639 psym->st_size = BYTE_GET (esyms[j].st_size);
5640 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5641 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5642 psym->st_shndx
5643 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5644 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5645 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5646 psym->st_info = BYTE_GET (esyms[j].st_info);
5647 psym->st_other = BYTE_GET (esyms[j].st_other);
5648 }
5649
5650 exit_point:
5651 free (shndx);
5652 free (esyms);
5653
5654 if (num_syms_return != NULL)
5655 * num_syms_return = isyms == NULL ? 0 : number;
5656
5657 return isyms;
5658}
5659
5660static Elf_Internal_Sym *
5661get_64bit_elf_symbols (Filedata * filedata,
5662 Elf_Internal_Shdr * section,
5663 unsigned long * num_syms_return)
5664{
5665 unsigned long number = 0;
5666 Elf64_External_Sym * esyms = NULL;
5667 Elf_External_Sym_Shndx * shndx = NULL;
5668 Elf_Internal_Sym * isyms = NULL;
5669 Elf_Internal_Sym * psym;
5670 unsigned int j;
5671 elf_section_list * entry;
5672
5673 if (section->sh_size == 0)
5674 {
5675 if (num_syms_return != NULL)
5676 * num_syms_return = 0;
5677 return NULL;
5678 }
5679
5680 /* Run some sanity checks first. */
5681 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5682 {
5683 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5684 printable_section_name (filedata, section),
5685 (unsigned long) section->sh_entsize);
5686 goto exit_point;
5687 }
5688
5689 if (section->sh_size > filedata->file_size)
5690 {
5691 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5692 printable_section_name (filedata, section),
5693 (unsigned long) section->sh_size);
5694 goto exit_point;
5695 }
5696
5697 number = section->sh_size / section->sh_entsize;
5698
5699 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5700 {
5701 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5702 (unsigned long) section->sh_size,
5703 printable_section_name (filedata, section),
5704 (unsigned long) section->sh_entsize);
5705 goto exit_point;
5706 }
5707
5708 esyms = (Elf64_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5709 section->sh_size, _("symbols"));
5710 if (!esyms)
5711 goto exit_point;
5712
5713 shndx = NULL;
5714 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5715 {
5716 if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5717 continue;
5718
5719 if (shndx != NULL)
5720 {
5721 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5722 free (shndx);
5723 }
5724
5725 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5726 entry->hdr->sh_offset,
5727 1, entry->hdr->sh_size,
5728 _("symbol table section indices"));
5729 if (shndx == NULL)
5730 goto exit_point;
5731
5732 /* PR17531: file: heap-buffer-overflow */
5733 if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5734 {
5735 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5736 printable_section_name (filedata, entry->hdr),
5737 (unsigned long) entry->hdr->sh_size,
5738 (unsigned long) section->sh_size);
5739 goto exit_point;
5740 }
5741 }
5742
5743 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5744
5745 if (isyms == NULL)
5746 {
5747 error (_("Out of memory reading %lu symbols\n"),
5748 (unsigned long) number);
5749 goto exit_point;
5750 }
5751
5752 for (j = 0, psym = isyms; j < number; j++, psym++)
5753 {
5754 psym->st_name = BYTE_GET (esyms[j].st_name);
5755 psym->st_info = BYTE_GET (esyms[j].st_info);
5756 psym->st_other = BYTE_GET (esyms[j].st_other);
5757 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5758
5759 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5760 psym->st_shndx
5761 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5762 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5763 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5764
5765 psym->st_value = BYTE_GET (esyms[j].st_value);
5766 psym->st_size = BYTE_GET (esyms[j].st_size);
5767 }
5768
5769 exit_point:
5770 free (shndx);
5771 free (esyms);
5772
5773 if (num_syms_return != NULL)
5774 * num_syms_return = isyms == NULL ? 0 : number;
5775
5776 return isyms;
5777}
5778
5779static const char *
5780get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
5781{
5782 static char buff[1024];
5783 char * p = buff;
5784 unsigned int field_size = is_32bit_elf ? 8 : 16;
5785 signed int sindex;
5786 unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5787 bfd_vma os_flags = 0;
5788 bfd_vma proc_flags = 0;
5789 bfd_vma unknown_flags = 0;
5790 static const struct
5791 {
5792 const char * str;
5793 unsigned int len;
5794 }
5795 flags [] =
5796 {
5797 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5798 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5799 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5800 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5801 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5802 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5803 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5804 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5805 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5806 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5807 /* IA-64 specific. */
5808 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5809 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5810 /* IA-64 OpenVMS specific. */
5811 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5812 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5813 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5814 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5815 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5816 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5817 /* Generic. */
5818 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5819 /* SPARC specific. */
5820 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5821 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5822 /* ARM specific. */
5823 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5824 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5825 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5826 /* GNU specific. */
5827 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5828 /* VLE specific. */
5829 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5830 };
5831
5832 if (do_section_details)
5833 {
5834 sprintf (buff, "[%*.*lx]: ",
5835 field_size, field_size, (unsigned long) sh_flags);
5836 p += field_size + 4;
5837 }
5838
5839 while (sh_flags)
5840 {
5841 bfd_vma flag;
5842
5843 flag = sh_flags & - sh_flags;
5844 sh_flags &= ~ flag;
5845
5846 if (do_section_details)
5847 {
5848 switch (flag)
5849 {
5850 case SHF_WRITE: sindex = 0; break;
5851 case SHF_ALLOC: sindex = 1; break;
5852 case SHF_EXECINSTR: sindex = 2; break;
5853 case SHF_MERGE: sindex = 3; break;
5854 case SHF_STRINGS: sindex = 4; break;
5855 case SHF_INFO_LINK: sindex = 5; break;
5856 case SHF_LINK_ORDER: sindex = 6; break;
5857 case SHF_OS_NONCONFORMING: sindex = 7; break;
5858 case SHF_GROUP: sindex = 8; break;
5859 case SHF_TLS: sindex = 9; break;
5860 case SHF_EXCLUDE: sindex = 18; break;
5861 case SHF_COMPRESSED: sindex = 20; break;
5862 case SHF_GNU_MBIND: sindex = 24; break;
5863
5864 default:
5865 sindex = -1;
5866 switch (filedata->file_header.e_machine)
5867 {
5868 case EM_IA_64:
5869 if (flag == SHF_IA_64_SHORT)
5870 sindex = 10;
5871 else if (flag == SHF_IA_64_NORECOV)
5872 sindex = 11;
5873#ifdef BFD64
5874 else if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5875 switch (flag)
5876 {
5877 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5878 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5879 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5880 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5881 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5882 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
5883 default: break;
5884 }
5885#endif
5886 break;
5887
5888 case EM_386:
5889 case EM_IAMCU:
5890 case EM_X86_64:
5891 case EM_L1OM:
5892 case EM_K1OM:
5893 case EM_OLD_SPARCV9:
5894 case EM_SPARC32PLUS:
5895 case EM_SPARCV9:
5896 case EM_SPARC:
5897 if (flag == SHF_ORDERED)
5898 sindex = 19;
5899 break;
5900
5901 case EM_ARM:
5902 switch (flag)
5903 {
5904 case SHF_ENTRYSECT: sindex = 21; break;
5905 case SHF_ARM_PURECODE: sindex = 22; break;
5906 case SHF_COMDEF: sindex = 23; break;
5907 default: break;
5908 }
5909 break;
5910 case EM_PPC:
5911 if (flag == SHF_PPC_VLE)
5912 sindex = 25;
5913 break;
5914
5915 default:
5916 break;
5917 }
5918 }
5919
5920 if (sindex != -1)
5921 {
5922 if (p != buff + field_size + 4)
5923 {
5924 if (size < (10 + 2))
5925 {
5926 warn (_("Internal error: not enough buffer room for section flag info"));
5927 return _("<unknown>");
5928 }
5929 size -= 2;
5930 *p++ = ',';
5931 *p++ = ' ';
5932 }
5933
5934 size -= flags [sindex].len;
5935 p = stpcpy (p, flags [sindex].str);
5936 }
5937 else if (flag & SHF_MASKOS)
5938 os_flags |= flag;
5939 else if (flag & SHF_MASKPROC)
5940 proc_flags |= flag;
5941 else
5942 unknown_flags |= flag;
5943 }
5944 else
5945 {
5946 switch (flag)
5947 {
5948 case SHF_WRITE: *p = 'W'; break;
5949 case SHF_ALLOC: *p = 'A'; break;
5950 case SHF_EXECINSTR: *p = 'X'; break;
5951 case SHF_MERGE: *p = 'M'; break;
5952 case SHF_STRINGS: *p = 'S'; break;
5953 case SHF_INFO_LINK: *p = 'I'; break;
5954 case SHF_LINK_ORDER: *p = 'L'; break;
5955 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5956 case SHF_GROUP: *p = 'G'; break;
5957 case SHF_TLS: *p = 'T'; break;
5958 case SHF_EXCLUDE: *p = 'E'; break;
5959 case SHF_COMPRESSED: *p = 'C'; break;
5960 case SHF_GNU_MBIND: *p = 'D'; break;
5961
5962 default:
5963 if ((filedata->file_header.e_machine == EM_X86_64
5964 || filedata->file_header.e_machine == EM_L1OM
5965 || filedata->file_header.e_machine == EM_K1OM)
5966 && flag == SHF_X86_64_LARGE)
5967 *p = 'l';
5968 else if (filedata->file_header.e_machine == EM_ARM
5969 && flag == SHF_ARM_PURECODE)
5970 *p = 'y';
5971 else if (filedata->file_header.e_machine == EM_PPC
5972 && flag == SHF_PPC_VLE)
5973 *p = 'v';
5974 else if (flag & SHF_MASKOS)
5975 {
5976 *p = 'o';
5977 sh_flags &= ~ SHF_MASKOS;
5978 }
5979 else if (flag & SHF_MASKPROC)
5980 {
5981 *p = 'p';
5982 sh_flags &= ~ SHF_MASKPROC;
5983 }
5984 else
5985 *p = 'x';
5986 break;
5987 }
5988 p++;
5989 }
5990 }
5991
5992 if (do_section_details)
5993 {
5994 if (os_flags)
5995 {
5996 size -= 5 + field_size;
5997 if (p != buff + field_size + 4)
5998 {
5999 if (size < (2 + 1))
6000 {
6001 warn (_("Internal error: not enough buffer room for section flag info"));
6002 return _("<unknown>");
6003 }
6004 size -= 2;
6005 *p++ = ',';
6006 *p++ = ' ';
6007 }
6008 sprintf (p, "OS (%*.*lx)", field_size, field_size,
6009 (unsigned long) os_flags);
6010 p += 5 + field_size;
6011 }
6012 if (proc_flags)
6013 {
6014 size -= 7 + field_size;
6015 if (p != buff + field_size + 4)
6016 {
6017 if (size < (2 + 1))
6018 {
6019 warn (_("Internal error: not enough buffer room for section flag info"));
6020 return _("<unknown>");
6021 }
6022 size -= 2;
6023 *p++ = ',';
6024 *p++ = ' ';
6025 }
6026 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
6027 (unsigned long) proc_flags);
6028 p += 7 + field_size;
6029 }
6030 if (unknown_flags)
6031 {
6032 size -= 10 + field_size;
6033 if (p != buff + field_size + 4)
6034 {
6035 if (size < (2 + 1))
6036 {
6037 warn (_("Internal error: not enough buffer room for section flag info"));
6038 return _("<unknown>");
6039 }
6040 size -= 2;
6041 *p++ = ',';
6042 *p++ = ' ';
6043 }
6044 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
6045 (unsigned long) unknown_flags);
6046 p += 10 + field_size;
6047 }
6048 }
6049
6050 *p = '\0';
6051 return buff;
6052}
6053
6054static unsigned int
6055get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
6056{
6057 if (is_32bit_elf)
6058 {
6059 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
6060
6061 if (size < sizeof (* echdr))
6062 {
6063 error (_("Compressed section is too small even for a compression header\n"));
6064 return 0;
6065 }
6066
6067 chdr->ch_type = BYTE_GET (echdr->ch_type);
6068 chdr->ch_size = BYTE_GET (echdr->ch_size);
6069 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
6070 return sizeof (*echdr);
6071 }
6072 else
6073 {
6074 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
6075
6076 if (size < sizeof (* echdr))
6077 {
6078 error (_("Compressed section is too small even for a compression header\n"));
6079 return 0;
6080 }
6081
6082 chdr->ch_type = BYTE_GET (echdr->ch_type);
6083 chdr->ch_size = BYTE_GET (echdr->ch_size);
6084 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
6085 return sizeof (*echdr);
6086 }
6087}
6088
6089static bfd_boolean
6090process_section_headers (Filedata * filedata)
6091{
6092 Elf_Internal_Shdr * section;
6093 unsigned int i;
6094
6095 filedata->section_headers = NULL;
6096
6097 if (filedata->file_header.e_shnum == 0)
6098 {
6099 /* PR binutils/12467. */
6100 if (filedata->file_header.e_shoff != 0)
6101 {
6102 warn (_("possibly corrupt ELF file header - it has a non-zero"
6103 " section header offset, but no section headers\n"));
6104 return FALSE;
6105 }
6106 else if (do_sections)
6107 printf (_("\nThere are no sections in this file.\n"));
6108
6109 return TRUE;
6110 }
6111
6112 if (do_sections && !do_header)
6113 printf (ngettext ("There is %d section header, "
6114 "starting at offset 0x%lx:\n",
6115 "There are %d section headers, "
6116 "starting at offset 0x%lx:\n",
6117 filedata->file_header.e_shnum),
6118 filedata->file_header.e_shnum,
6119 (unsigned long) filedata->file_header.e_shoff);
6120
6121 if (is_32bit_elf)
6122 {
6123 if (! get_32bit_section_headers (filedata, FALSE))
6124 return FALSE;
6125 }
6126 else
6127 {
6128 if (! get_64bit_section_headers (filedata, FALSE))
6129 return FALSE;
6130 }
6131
6132 /* Read in the string table, so that we have names to display. */
6133 if (filedata->file_header.e_shstrndx != SHN_UNDEF
6134 && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
6135 {
6136 section = filedata->section_headers + filedata->file_header.e_shstrndx;
6137
6138 if (section->sh_size != 0)
6139 {
6140 filedata->string_table = (char *) get_data (NULL, filedata, section->sh_offset,
6141 1, section->sh_size,
6142 _("string table"));
6143
6144 filedata->string_table_length = filedata->string_table != NULL ? section->sh_size : 0;
6145 }
6146 }
6147
6148 /* Scan the sections for the dynamic symbol table
6149 and dynamic string table and debug sections. */
6150 dynamic_symbols = NULL;
6151 dynamic_strings = NULL;
6152 dynamic_syminfo = NULL;
6153 symtab_shndx_list = NULL;
6154
6155 eh_addr_size = is_32bit_elf ? 4 : 8;
6156 switch (filedata->file_header.e_machine)
6157 {
6158 case EM_MIPS:
6159 case EM_MIPS_RS3_LE:
6160 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6161 FDE addresses. However, the ABI also has a semi-official ILP32
6162 variant for which the normal FDE address size rules apply.
6163
6164 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6165 section, where XX is the size of longs in bits. Unfortunately,
6166 earlier compilers provided no way of distinguishing ILP32 objects
6167 from LP64 objects, so if there's any doubt, we should assume that
6168 the official LP64 form is being used. */
6169 if ((filedata->file_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
6170 && find_section (filedata, ".gcc_compiled_long32") == NULL)
6171 eh_addr_size = 8;
6172 break;
6173
6174 case EM_H8_300:
6175 case EM_H8_300H:
6176 switch (filedata->file_header.e_flags & EF_H8_MACH)
6177 {
6178 case E_H8_MACH_H8300:
6179 case E_H8_MACH_H8300HN:
6180 case E_H8_MACH_H8300SN:
6181 case E_H8_MACH_H8300SXN:
6182 eh_addr_size = 2;
6183 break;
6184 case E_H8_MACH_H8300H:
6185 case E_H8_MACH_H8300S:
6186 case E_H8_MACH_H8300SX:
6187 eh_addr_size = 4;
6188 break;
6189 }
6190 break;
6191
6192 case EM_M32C_OLD:
6193 case EM_M32C:
6194 switch (filedata->file_header.e_flags & EF_M32C_CPU_MASK)
6195 {
6196 case EF_M32C_CPU_M16C:
6197 eh_addr_size = 2;
6198 break;
6199 }
6200 break;
6201 }
6202
6203#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6204 do \
6205 { \
6206 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6207 if (section->sh_entsize != expected_entsize) \
6208 { \
6209 char buf[40]; \
6210 sprintf_vma (buf, section->sh_entsize); \
6211 /* Note: coded this way so that there is a single string for \
6212 translation. */ \
6213 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6214 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6215 (unsigned) expected_entsize); \
6216 section->sh_entsize = expected_entsize; \
6217 } \
6218 } \
6219 while (0)
6220
6221#define CHECK_ENTSIZE(section, i, type) \
6222 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6223 sizeof (Elf64_External_##type))
6224
6225 for (i = 0, section = filedata->section_headers;
6226 i < filedata->file_header.e_shnum;
6227 i++, section++)
6228 {
6229 char * name = SECTION_NAME (section);
6230
6231 if (section->sh_type == SHT_DYNSYM)
6232 {
6233 if (dynamic_symbols != NULL)
6234 {
6235 error (_("File contains multiple dynamic symbol tables\n"));
6236 continue;
6237 }
6238
6239 CHECK_ENTSIZE (section, i, Sym);
6240 dynamic_symbols = GET_ELF_SYMBOLS (filedata, section, & num_dynamic_syms);
6241 }
6242 else if (section->sh_type == SHT_STRTAB
6243 && streq (name, ".dynstr"))
6244 {
6245 if (dynamic_strings != NULL)
6246 {
6247 error (_("File contains multiple dynamic string tables\n"));
6248 continue;
6249 }
6250
6251 dynamic_strings = (char *) get_data (NULL, filedata, section->sh_offset,
6252 1, section->sh_size,
6253 _("dynamic strings"));
6254 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
6255 }
6256 else if (section->sh_type == SHT_SYMTAB_SHNDX)
6257 {
6258 elf_section_list * entry = xmalloc (sizeof * entry);
6259
6260 entry->hdr = section;
6261 entry->next = symtab_shndx_list;
6262 symtab_shndx_list = entry;
6263 }
6264 else if (section->sh_type == SHT_SYMTAB)
6265 CHECK_ENTSIZE (section, i, Sym);
6266 else if (section->sh_type == SHT_GROUP)
6267 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6268 else if (section->sh_type == SHT_REL)
6269 CHECK_ENTSIZE (section, i, Rel);
6270 else if (section->sh_type == SHT_RELA)
6271 CHECK_ENTSIZE (section, i, Rela);
6272 else if ((do_debugging || do_debug_info || do_debug_abbrevs
6273 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
6274 || do_debug_aranges || do_debug_frames || do_debug_macinfo
6275 || do_debug_str || do_debug_loc || do_debug_ranges
6276 || do_debug_addr || do_debug_cu_index || do_debug_links)
6277 && (const_strneq (name, ".debug_")
6278 || const_strneq (name, ".zdebug_")))
6279 {
6280 if (name[1] == 'z')
6281 name += sizeof (".zdebug_") - 1;
6282 else
6283 name += sizeof (".debug_") - 1;
6284
6285 if (do_debugging
6286 || (do_debug_info && const_strneq (name, "info"))
6287 || (do_debug_info && const_strneq (name, "types"))
6288 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
6289 || (do_debug_lines && strcmp (name, "line") == 0)
6290 || (do_debug_lines && const_strneq (name, "line."))
6291 || (do_debug_pubnames && const_strneq (name, "pubnames"))
6292 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6293 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6294 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6295 || (do_debug_aranges && const_strneq (name, "aranges"))
6296 || (do_debug_ranges && const_strneq (name, "ranges"))
6297 || (do_debug_ranges && const_strneq (name, "rnglists"))
6298 || (do_debug_frames && const_strneq (name, "frame"))
6299 || (do_debug_macinfo && const_strneq (name, "macinfo"))
6300 || (do_debug_macinfo && const_strneq (name, "macro"))
6301 || (do_debug_str && const_strneq (name, "str"))
6302 || (do_debug_loc && const_strneq (name, "loc"))
6303 || (do_debug_loc && const_strneq (name, "loclists"))
6304 || (do_debug_addr && const_strneq (name, "addr"))
6305 || (do_debug_cu_index && const_strneq (name, "cu_index"))
6306 || (do_debug_cu_index && const_strneq (name, "tu_index"))
6307 )
6308 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6309 }
6310 /* Linkonce section to be combined with .debug_info at link time. */
6311 else if ((do_debugging || do_debug_info)
6312 && const_strneq (name, ".gnu.linkonce.wi."))
6313 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6314 else if (do_debug_frames && streq (name, ".eh_frame"))
6315 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6316 else if (do_gdb_index && (streq (name, ".gdb_index")
6317 || streq (name, ".debug_names")))
6318 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6319 /* Trace sections for Itanium VMS. */
6320 else if ((do_debugging || do_trace_info || do_trace_abbrevs
6321 || do_trace_aranges)
6322 && const_strneq (name, ".trace_"))
6323 {
6324 name += sizeof (".trace_") - 1;
6325
6326 if (do_debugging
6327 || (do_trace_info && streq (name, "info"))
6328 || (do_trace_abbrevs && streq (name, "abbrev"))
6329 || (do_trace_aranges && streq (name, "aranges"))
6330 )
6331 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6332 }
6333 else if ((do_debugging || do_debug_links)
6334 && (const_strneq (name, ".gnu_debuglink")
6335 || const_strneq (name, ".gnu_debugaltlink")))
6336 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6337 }
6338
6339 if (! do_sections)
6340 return TRUE;
6341
6342 if (filedata->file_header.e_shnum > 1)
6343 printf (_("\nSection Headers:\n"));
6344 else
6345 printf (_("\nSection Header:\n"));
6346
6347 if (is_32bit_elf)
6348 {
6349 if (do_section_details)
6350 {
6351 printf (_(" [Nr] Name\n"));
6352 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6353 }
6354 else
6355 printf
6356 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6357 }
6358 else if (do_wide)
6359 {
6360 if (do_section_details)
6361 {
6362 printf (_(" [Nr] Name\n"));
6363 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6364 }
6365 else
6366 printf
6367 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6368 }
6369 else
6370 {
6371 if (do_section_details)
6372 {
6373 printf (_(" [Nr] Name\n"));
6374 printf (_(" Type Address Offset Link\n"));
6375 printf (_(" Size EntSize Info Align\n"));
6376 }
6377 else
6378 {
6379 printf (_(" [Nr] Name Type Address Offset\n"));
6380 printf (_(" Size EntSize Flags Link Info Align\n"));
6381 }
6382 }
6383
6384 if (do_section_details)
6385 printf (_(" Flags\n"));
6386
6387 for (i = 0, section = filedata->section_headers;
6388 i < filedata->file_header.e_shnum;
6389 i++, section++)
6390 {
6391 /* Run some sanity checks on the section header. */
6392
6393 /* Check the sh_link field. */
6394 switch (section->sh_type)
6395 {
6396 case SHT_REL:
6397 case SHT_RELA:
6398 if (section->sh_link == 0
6399 && (filedata->file_header.e_type == ET_EXEC
6400 || filedata->file_header.e_type == ET_DYN))
6401 /* A dynamic relocation section where all entries use a
6402 zero symbol index need not specify a symtab section. */
6403 break;
6404 /* Fall through. */
6405 case SHT_SYMTAB_SHNDX:
6406 case SHT_GROUP:
6407 case SHT_HASH:
6408 case SHT_GNU_HASH:
6409 case SHT_GNU_versym:
6410 if (section->sh_link == 0
6411 || section->sh_link >= filedata->file_header.e_shnum
6412 || (filedata->section_headers[section->sh_link].sh_type != SHT_SYMTAB
6413 && filedata->section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6414 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6415 i, section->sh_link);
6416 break;
6417
6418 case SHT_DYNAMIC:
6419 case SHT_SYMTAB:
6420 case SHT_DYNSYM:
6421 case SHT_GNU_verneed:
6422 case SHT_GNU_verdef:
6423 case SHT_GNU_LIBLIST:
6424 if (section->sh_link == 0
6425 || section->sh_link >= filedata->file_header.e_shnum
6426 || filedata->section_headers[section->sh_link].sh_type != SHT_STRTAB)
6427 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6428 i, section->sh_link);
6429 break;
6430
6431 case SHT_INIT_ARRAY:
6432 case SHT_FINI_ARRAY:
6433 case SHT_PREINIT_ARRAY:
6434 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6435 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6436 i, section->sh_link);
6437 break;
6438
6439 default:
6440 /* FIXME: Add support for target specific section types. */
6441#if 0 /* Currently we do not check other section types as there are too
6442 many special cases. Stab sections for example have a type
6443 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6444 section. */
6445 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6446 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6447 i, section->sh_link);
6448#endif
6449 break;
6450 }
6451
6452 /* Check the sh_info field. */
6453 switch (section->sh_type)
6454 {
6455 case SHT_REL:
6456 case SHT_RELA:
6457 if (section->sh_info == 0
6458 && (filedata->file_header.e_type == ET_EXEC
6459 || filedata->file_header.e_type == ET_DYN))
6460 /* Dynamic relocations apply to segments, so they do not
6461 need to specify the section they relocate. */
6462 break;
6463 if (section->sh_info == 0
6464 || section->sh_info >= filedata->file_header.e_shnum
6465 || (filedata->section_headers[section->sh_info].sh_type != SHT_PROGBITS
6466 && filedata->section_headers[section->sh_info].sh_type != SHT_NOBITS
6467 && filedata->section_headers[section->sh_info].sh_type != SHT_NOTE
6468 && filedata->section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6469 && filedata->section_headers[section->sh_info].sh_type != SHT_FINI_ARRAY
6470 && filedata->section_headers[section->sh_info].sh_type != SHT_PREINIT_ARRAY
6471 /* FIXME: Are other section types valid ? */
6472 && filedata->section_headers[section->sh_info].sh_type < SHT_LOOS))
6473 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6474 i, section->sh_info);
6475 break;
6476
6477 case SHT_DYNAMIC:
6478 case SHT_HASH:
6479 case SHT_SYMTAB_SHNDX:
6480 case SHT_INIT_ARRAY:
6481 case SHT_FINI_ARRAY:
6482 case SHT_PREINIT_ARRAY:
6483 if (section->sh_info != 0)
6484 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6485 i, section->sh_info);
6486 break;
6487
6488 case SHT_GROUP:
6489 case SHT_SYMTAB:
6490 case SHT_DYNSYM:
6491 /* A symbol index - we assume that it is valid. */
6492 break;
6493
6494 default:
6495 /* FIXME: Add support for target specific section types. */
6496 if (section->sh_type == SHT_NOBITS)
6497 /* NOBITS section headers with non-zero sh_info fields can be
6498 created when a binary is stripped of everything but its debug
6499 information. The stripped sections have their headers
6500 preserved but their types set to SHT_NOBITS. So do not check
6501 this type of section. */
6502 ;
6503 else if (section->sh_flags & SHF_INFO_LINK)
6504 {
6505 if (section->sh_info < 1 || section->sh_info >= filedata->file_header.e_shnum)
6506 warn (_("[%2u]: Expected link to another section in info field"), i);
6507 }
6508 else if (section->sh_type < SHT_LOOS
6509 && (section->sh_flags & SHF_GNU_MBIND) == 0
6510 && section->sh_info != 0)
6511 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6512 i, section->sh_info);
6513 break;
6514 }
6515
6516 /* Check the sh_size field. */
6517 if (section->sh_size > filedata->file_size
6518 && section->sh_type != SHT_NOBITS
6519 && section->sh_type != SHT_NULL
6520 && section->sh_type < SHT_LOOS)
6521 warn (_("Size of section %u is larger than the entire file!\n"), i);
6522
6523 printf (" [%2u] ", i);
6524 if (do_section_details)
6525 printf ("%s\n ", printable_section_name (filedata, section));
6526 else
6527 print_symbol (-17, SECTION_NAME (section));
6528
6529 printf (do_wide ? " %-15s " : " %-15.15s ",
6530 get_section_type_name (filedata, section->sh_type));
6531
6532 if (is_32bit_elf)
6533 {
6534 const char * link_too_big = NULL;
6535
6536 print_vma (section->sh_addr, LONG_HEX);
6537
6538 printf ( " %6.6lx %6.6lx %2.2lx",
6539 (unsigned long) section->sh_offset,
6540 (unsigned long) section->sh_size,
6541 (unsigned long) section->sh_entsize);
6542
6543 if (do_section_details)
6544 fputs (" ", stdout);
6545 else
6546 printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6547
6548 if (section->sh_link >= filedata->file_header.e_shnum)
6549 {
6550 link_too_big = "";
6551 /* The sh_link value is out of range. Normally this indicates
6552 an error but it can have special values in Solaris binaries. */
6553 switch (filedata->file_header.e_machine)
6554 {
6555 case EM_386:
6556 case EM_IAMCU:
6557 case EM_X86_64:
6558 case EM_L1OM:
6559 case EM_K1OM:
6560 case EM_OLD_SPARCV9:
6561 case EM_SPARC32PLUS:
6562 case EM_SPARCV9:
6563 case EM_SPARC:
6564 if (section->sh_link == (SHN_BEFORE & 0xffff))
6565 link_too_big = "BEFORE";
6566 else if (section->sh_link == (SHN_AFTER & 0xffff))
6567 link_too_big = "AFTER";
6568 break;
6569 default:
6570 break;
6571 }
6572 }
6573
6574 if (do_section_details)
6575 {
6576 if (link_too_big != NULL && * link_too_big)
6577 printf ("<%s> ", link_too_big);
6578 else
6579 printf ("%2u ", section->sh_link);
6580 printf ("%3u %2lu\n", section->sh_info,
6581 (unsigned long) section->sh_addralign);
6582 }
6583 else
6584 printf ("%2u %3u %2lu\n",
6585 section->sh_link,
6586 section->sh_info,
6587 (unsigned long) section->sh_addralign);
6588
6589 if (link_too_big && ! * link_too_big)
6590 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6591 i, section->sh_link);
6592 }
6593 else if (do_wide)
6594 {
6595 print_vma (section->sh_addr, LONG_HEX);
6596
6597 if ((long) section->sh_offset == section->sh_offset)
6598 printf (" %6.6lx", (unsigned long) section->sh_offset);
6599 else
6600 {
6601 putchar (' ');
6602 print_vma (section->sh_offset, LONG_HEX);
6603 }
6604
6605 if ((unsigned long) section->sh_size == section->sh_size)
6606 printf (" %6.6lx", (unsigned long) section->sh_size);
6607 else
6608 {
6609 putchar (' ');
6610 print_vma (section->sh_size, LONG_HEX);
6611 }
6612
6613 if ((unsigned long) section->sh_entsize == section->sh_entsize)
6614 printf (" %2.2lx", (unsigned long) section->sh_entsize);
6615 else
6616 {
6617 putchar (' ');
6618 print_vma (section->sh_entsize, LONG_HEX);
6619 }
6620
6621 if (do_section_details)
6622 fputs (" ", stdout);
6623 else
6624 printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6625
6626 printf ("%2u %3u ", section->sh_link, section->sh_info);
6627
6628 if ((unsigned long) section->sh_addralign == section->sh_addralign)
6629 printf ("%2lu\n", (unsigned long) section->sh_addralign);
6630 else
6631 {
6632 print_vma (section->sh_addralign, DEC);
6633 putchar ('\n');
6634 }
6635 }
6636 else if (do_section_details)
6637 {
6638 putchar (' ');
6639 print_vma (section->sh_addr, LONG_HEX);
6640 if ((long) section->sh_offset == section->sh_offset)
6641 printf (" %16.16lx", (unsigned long) section->sh_offset);
6642 else
6643 {
6644 printf (" ");
6645 print_vma (section->sh_offset, LONG_HEX);
6646 }
6647 printf (" %u\n ", section->sh_link);
6648 print_vma (section->sh_size, LONG_HEX);
6649 putchar (' ');
6650 print_vma (section->sh_entsize, LONG_HEX);
6651
6652 printf (" %-16u %lu\n",
6653 section->sh_info,
6654 (unsigned long) section->sh_addralign);
6655 }
6656 else
6657 {
6658 putchar (' ');
6659 print_vma (section->sh_addr, LONG_HEX);
6660 if ((long) section->sh_offset == section->sh_offset)
6661 printf (" %8.8lx", (unsigned long) section->sh_offset);
6662 else
6663 {
6664 printf (" ");
6665 print_vma (section->sh_offset, LONG_HEX);
6666 }
6667 printf ("\n ");
6668 print_vma (section->sh_size, LONG_HEX);
6669 printf (" ");
6670 print_vma (section->sh_entsize, LONG_HEX);
6671
6672 printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6673
6674 printf (" %2u %3u %lu\n",
6675 section->sh_link,
6676 section->sh_info,
6677 (unsigned long) section->sh_addralign);
6678 }
6679
6680 if (do_section_details)
6681 {
6682 printf (" %s\n", get_elf_section_flags (filedata, section->sh_flags));
6683 if ((section->sh_flags & SHF_COMPRESSED) != 0)
6684 {
6685 /* Minimum section size is 12 bytes for 32-bit compression
6686 header + 12 bytes for compressed data header. */
6687 unsigned char buf[24];
6688
6689 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6690 if (get_data (&buf, filedata, section->sh_offset, 1,
6691 sizeof (buf), _("compression header")))
6692 {
6693 Elf_Internal_Chdr chdr;
6694
6695 (void) get_compression_header (&chdr, buf, sizeof (buf));
6696
6697 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6698 printf (" ZLIB, ");
6699 else
6700 printf (_(" [<unknown>: 0x%x], "),
6701 chdr.ch_type);
6702 print_vma (chdr.ch_size, LONG_HEX);
6703 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6704 }
6705 }
6706 }
6707 }
6708
6709 if (!do_section_details)
6710 {
6711 /* The ordering of the letters shown here matches the ordering of the
6712 corresponding SHF_xxx values, and hence the order in which these
6713 letters will be displayed to the user. */
6714 printf (_("Key to Flags:\n\
6715 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6716 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6717 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6718 if (filedata->file_header.e_machine == EM_X86_64
6719 || filedata->file_header.e_machine == EM_L1OM
6720 || filedata->file_header.e_machine == EM_K1OM)
6721 printf (_("l (large), "));
6722 else if (filedata->file_header.e_machine == EM_ARM)
6723 printf (_("y (purecode), "));
6724 else if (filedata->file_header.e_machine == EM_PPC)
6725 printf (_("v (VLE), "));
6726 printf ("p (processor specific)\n");
6727 }
6728
6729 return TRUE;
6730}
6731
6732static const char *
6733get_group_flags (unsigned int flags)
6734{
6735 static char buff[128];
6736
6737 if (flags == 0)
6738 return "";
6739 else if (flags == GRP_COMDAT)
6740 return "COMDAT ";
6741
6742 snprintf (buff, 14, _("[0x%x: "), flags);
6743
6744 flags &= ~ GRP_COMDAT;
6745 if (flags & GRP_MASKOS)
6746 {
6747 strcat (buff, "<OS specific>");
6748 flags &= ~ GRP_MASKOS;
6749 }
6750
6751 if (flags & GRP_MASKPROC)
6752 {
6753 strcat (buff, "<PROC specific>");
6754 flags &= ~ GRP_MASKPROC;
6755 }
6756
6757 if (flags)
6758 strcat (buff, "<unknown>");
6759
6760 strcat (buff, "]");
6761 return buff;
6762}
6763
6764static bfd_boolean
6765process_section_groups (Filedata * filedata)
6766{
6767 Elf_Internal_Shdr * section;
6768 unsigned int i;
6769 struct group * group;
6770 Elf_Internal_Shdr * symtab_sec;
6771 Elf_Internal_Shdr * strtab_sec;
6772 Elf_Internal_Sym * symtab;
6773 unsigned long num_syms;
6774 char * strtab;
6775 size_t strtab_size;
6776
6777 /* Don't process section groups unless needed. */
6778 if (!do_unwind && !do_section_groups)
6779 return TRUE;
6780
6781 if (filedata->file_header.e_shnum == 0)
6782 {
6783 if (do_section_groups)
6784 printf (_("\nThere are no sections to group in this file.\n"));
6785
6786 return TRUE;
6787 }
6788
6789 if (filedata->section_headers == NULL)
6790 {
6791 error (_("Section headers are not available!\n"));
6792 /* PR 13622: This can happen with a corrupt ELF header. */
6793 return FALSE;
6794 }
6795
6796 section_headers_groups = (struct group **) calloc (filedata->file_header.e_shnum,
6797 sizeof (struct group *));
6798
6799 if (section_headers_groups == NULL)
6800 {
6801 error (_("Out of memory reading %u section group headers\n"),
6802 filedata->file_header.e_shnum);
6803 return FALSE;
6804 }
6805
6806 /* Scan the sections for the group section. */
6807 group_count = 0;
6808 for (i = 0, section = filedata->section_headers;
6809 i < filedata->file_header.e_shnum;
6810 i++, section++)
6811 if (section->sh_type == SHT_GROUP)
6812 group_count++;
6813
6814 if (group_count == 0)
6815 {
6816 if (do_section_groups)
6817 printf (_("\nThere are no section groups in this file.\n"));
6818
6819 return TRUE;
6820 }
6821
6822 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6823
6824 if (section_groups == NULL)
6825 {
6826 error (_("Out of memory reading %lu groups\n"),
6827 (unsigned long) group_count);
6828 return FALSE;
6829 }
6830
6831 symtab_sec = NULL;
6832 strtab_sec = NULL;
6833 symtab = NULL;
6834 num_syms = 0;
6835 strtab = NULL;
6836 strtab_size = 0;
6837 for (i = 0, section = filedata->section_headers, group = section_groups;
6838 i < filedata->file_header.e_shnum;
6839 i++, section++)
6840 {
6841 if (section->sh_type == SHT_GROUP)
6842 {
6843 const char * name = printable_section_name (filedata, section);
6844 const char * group_name;
6845 unsigned char * start;
6846 unsigned char * indices;
6847 unsigned int entry, j, size;
6848 Elf_Internal_Shdr * sec;
6849 Elf_Internal_Sym * sym;
6850
6851 /* Get the symbol table. */
6852 if (section->sh_link >= filedata->file_header.e_shnum
6853 || ((sec = filedata->section_headers + section->sh_link)->sh_type
6854 != SHT_SYMTAB))
6855 {
6856 error (_("Bad sh_link in group section `%s'\n"), name);
6857 continue;
6858 }
6859
6860 if (symtab_sec != sec)
6861 {
6862 symtab_sec = sec;
6863 if (symtab)
6864 free (symtab);
6865 symtab = GET_ELF_SYMBOLS (filedata, symtab_sec, & num_syms);
6866 }
6867
6868 if (symtab == NULL)
6869 {
6870 error (_("Corrupt header in group section `%s'\n"), name);
6871 continue;
6872 }
6873
6874 if (section->sh_info >= num_syms)
6875 {
6876 error (_("Bad sh_info in group section `%s'\n"), name);
6877 continue;
6878 }
6879
6880 sym = symtab + section->sh_info;
6881
6882 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6883 {
6884 if (sym->st_shndx == 0
6885 || sym->st_shndx >= filedata->file_header.e_shnum)
6886 {
6887 error (_("Bad sh_info in group section `%s'\n"), name);
6888 continue;
6889 }
6890
6891 group_name = SECTION_NAME (filedata->section_headers + sym->st_shndx);
6892 strtab_sec = NULL;
6893 if (strtab)
6894 free (strtab);
6895 strtab = NULL;
6896 strtab_size = 0;
6897 }
6898 else
6899 {
6900 /* Get the string table. */
6901 if (symtab_sec->sh_link >= filedata->file_header.e_shnum)
6902 {
6903 strtab_sec = NULL;
6904 if (strtab)
6905 free (strtab);
6906 strtab = NULL;
6907 strtab_size = 0;
6908 }
6909 else if (strtab_sec
6910 != (sec = filedata->section_headers + symtab_sec->sh_link))
6911 {
6912 strtab_sec = sec;
6913 if (strtab)
6914 free (strtab);
6915
6916 strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
6917 1, strtab_sec->sh_size,
6918 _("string table"));
6919 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6920 }
6921 group_name = sym->st_name < strtab_size
6922 ? strtab + sym->st_name : _("<corrupt>");
6923 }
6924
6925 /* PR 17531: file: loop. */
6926 if (section->sh_entsize > section->sh_size)
6927 {
6928 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6929 printable_section_name (filedata, section),
6930 (unsigned long) section->sh_entsize,
6931 (unsigned long) section->sh_size);
6932 continue;
6933 }
6934
6935 start = (unsigned char *) get_data (NULL, filedata, section->sh_offset,
6936 1, section->sh_size,
6937 _("section data"));
6938 if (start == NULL)
6939 continue;
6940
6941 indices = start;
6942 size = (section->sh_size / section->sh_entsize) - 1;
6943 entry = byte_get (indices, 4);
6944 indices += 4;
6945
6946 if (do_section_groups)
6947 {
6948 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6949 get_group_flags (entry), i, name, group_name, size);
6950
6951 printf (_(" [Index] Name\n"));
6952 }
6953
6954 group->group_index = i;
6955
6956 for (j = 0; j < size; j++)
6957 {
6958 struct group_list * g;
6959
6960 entry = byte_get (indices, 4);
6961 indices += 4;
6962
6963 if (entry >= filedata->file_header.e_shnum)
6964 {
6965 static unsigned num_group_errors = 0;
6966
6967 if (num_group_errors ++ < 10)
6968 {
6969 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6970 entry, i, filedata->file_header.e_shnum - 1);
6971 if (num_group_errors == 10)
6972 warn (_("Further error messages about overlarge group section indices suppressed\n"));
6973 }
6974 continue;
6975 }
6976
6977 if (section_headers_groups [entry] != NULL)
6978 {
6979 if (entry)
6980 {
6981 static unsigned num_errs = 0;
6982
6983 if (num_errs ++ < 10)
6984 {
6985 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6986 entry, i,
6987 section_headers_groups [entry]->group_index);
6988 if (num_errs == 10)
6989 warn (_("Further error messages about already contained group sections suppressed\n"));
6990 }
6991 continue;
6992 }
6993 else
6994 {
6995 /* Intel C/C++ compiler may put section 0 in a
6996 section group. We just warn it the first time
6997 and ignore it afterwards. */
6998 static bfd_boolean warned = FALSE;
6999 if (!warned)
7000 {
7001 error (_("section 0 in group section [%5u]\n"),
7002 section_headers_groups [entry]->group_index);
7003 warned = TRUE;
7004 }
7005 }
7006 }
7007
7008 section_headers_groups [entry] = group;
7009
7010 if (do_section_groups)
7011 {
7012 sec = filedata->section_headers + entry;
7013 printf (" [%5u] %s\n", entry, printable_section_name (filedata, sec));
7014 }
7015
7016 g = (struct group_list *) xmalloc (sizeof (struct group_list));
7017 g->section_index = entry;
7018 g->next = group->root;
7019 group->root = g;
7020 }
7021
7022 if (start)
7023 free (start);
7024
7025 group++;
7026 }
7027 }
7028
7029 if (symtab)
7030 free (symtab);
7031 if (strtab)
7032 free (strtab);
7033 return TRUE;
7034}
7035
7036/* Data used to display dynamic fixups. */
7037
7038struct ia64_vms_dynfixup
7039{
7040 bfd_vma needed_ident; /* Library ident number. */
7041 bfd_vma needed; /* Index in the dstrtab of the library name. */
7042 bfd_vma fixup_needed; /* Index of the library. */
7043 bfd_vma fixup_rela_cnt; /* Number of fixups. */
7044 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
7045};
7046
7047/* Data used to display dynamic relocations. */
7048
7049struct ia64_vms_dynimgrela
7050{
7051 bfd_vma img_rela_cnt; /* Number of relocations. */
7052 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
7053};
7054
7055/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7056 library). */
7057
7058static bfd_boolean
7059dump_ia64_vms_dynamic_fixups (Filedata * filedata,
7060 struct ia64_vms_dynfixup * fixup,
7061 const char * strtab,
7062 unsigned int strtab_sz)
7063{
7064 Elf64_External_VMS_IMAGE_FIXUP * imfs;
7065 long i;
7066 const char * lib_name;
7067
7068 imfs = get_data (NULL, filedata, dynamic_addr + fixup->fixup_rela_off,
7069 1, fixup->fixup_rela_cnt * sizeof (*imfs),
7070 _("dynamic section image fixups"));
7071 if (!imfs)
7072 return FALSE;
7073
7074 if (fixup->needed < strtab_sz)
7075 lib_name = strtab + fixup->needed;
7076 else
7077 {
7078 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7079 (unsigned long) fixup->needed);
7080 lib_name = "???";
7081 }
7082 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7083 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
7084 printf
7085 (_("Seg Offset Type SymVec DataType\n"));
7086
7087 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
7088 {
7089 unsigned int type;
7090 const char *rtype;
7091
7092 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
7093 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
7094 type = BYTE_GET (imfs [i].type);
7095 rtype = elf_ia64_reloc_type (type);
7096 if (rtype == NULL)
7097 printf (" 0x%08x ", type);
7098 else
7099 printf (" %-32s ", rtype);
7100 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
7101 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
7102 }
7103
7104 free (imfs);
7105 return TRUE;
7106}
7107
7108/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7109
7110static bfd_boolean
7111dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *imgrela)
7112{
7113 Elf64_External_VMS_IMAGE_RELA *imrs;
7114 long i;
7115
7116 imrs = get_data (NULL, filedata, dynamic_addr + imgrela->img_rela_off,
7117 1, imgrela->img_rela_cnt * sizeof (*imrs),
7118 _("dynamic section image relocations"));
7119 if (!imrs)
7120 return FALSE;
7121
7122 printf (_("\nImage relocs\n"));
7123 printf
7124 (_("Seg Offset Type Addend Seg Sym Off\n"));
7125
7126 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
7127 {
7128 unsigned int type;
7129 const char *rtype;
7130
7131 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
7132 printf ("%08" BFD_VMA_FMT "x ",
7133 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
7134 type = BYTE_GET (imrs [i].type);
7135 rtype = elf_ia64_reloc_type (type);
7136 if (rtype == NULL)
7137 printf ("0x%08x ", type);
7138 else
7139 printf ("%-31s ", rtype);
7140 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
7141 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
7142 printf ("%08" BFD_VMA_FMT "x\n",
7143 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
7144 }
7145
7146 free (imrs);
7147 return TRUE;
7148}
7149
7150/* Display IA-64 OpenVMS dynamic relocations and fixups. */
7151
7152static bfd_boolean
7153process_ia64_vms_dynamic_relocs (Filedata * filedata)
7154{
7155 struct ia64_vms_dynfixup fixup;
7156 struct ia64_vms_dynimgrela imgrela;
7157 Elf_Internal_Dyn *entry;
7158 bfd_vma strtab_off = 0;
7159 bfd_vma strtab_sz = 0;
7160 char *strtab = NULL;
7161 bfd_boolean res = TRUE;
7162
7163 memset (&fixup, 0, sizeof (fixup));
7164 memset (&imgrela, 0, sizeof (imgrela));
7165
7166 /* Note: the order of the entries is specified by the OpenVMS specs. */
7167 for (entry = dynamic_section;
7168 entry < dynamic_section + dynamic_nent;
7169 entry++)
7170 {
7171 switch (entry->d_tag)
7172 {
7173 case DT_IA_64_VMS_STRTAB_OFFSET:
7174 strtab_off = entry->d_un.d_val;
7175 break;
7176 case DT_STRSZ:
7177 strtab_sz = entry->d_un.d_val;
7178 if (strtab == NULL)
7179 strtab = get_data (NULL, filedata, dynamic_addr + strtab_off,
7180 1, strtab_sz, _("dynamic string section"));
7181 break;
7182
7183 case DT_IA_64_VMS_NEEDED_IDENT:
7184 fixup.needed_ident = entry->d_un.d_val;
7185 break;
7186 case DT_NEEDED:
7187 fixup.needed = entry->d_un.d_val;
7188 break;
7189 case DT_IA_64_VMS_FIXUP_NEEDED:
7190 fixup.fixup_needed = entry->d_un.d_val;
7191 break;
7192 case DT_IA_64_VMS_FIXUP_RELA_CNT:
7193 fixup.fixup_rela_cnt = entry->d_un.d_val;
7194 break;
7195 case DT_IA_64_VMS_FIXUP_RELA_OFF:
7196 fixup.fixup_rela_off = entry->d_un.d_val;
7197 if (! dump_ia64_vms_dynamic_fixups (filedata, &fixup, strtab, strtab_sz))
7198 res = FALSE;
7199 break;
7200 case DT_IA_64_VMS_IMG_RELA_CNT:
7201 imgrela.img_rela_cnt = entry->d_un.d_val;
7202 break;
7203 case DT_IA_64_VMS_IMG_RELA_OFF:
7204 imgrela.img_rela_off = entry->d_un.d_val;
7205 if (! dump_ia64_vms_dynamic_relocs (filedata, &imgrela))
7206 res = FALSE;
7207 break;
7208
7209 default:
7210 break;
7211 }
7212 }
7213
7214 if (strtab != NULL)
7215 free (strtab);
7216
7217 return res;
7218}
7219
7220static struct
7221{
7222 const char * name;
7223 int reloc;
7224 int size;
7225 int rela;
7226}
7227 dynamic_relocations [] =
7228{
7229 { "REL", DT_REL, DT_RELSZ, FALSE },
7230 { "RELA", DT_RELA, DT_RELASZ, TRUE },
7231 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
7232};
7233
7234/* Process the reloc section. */
7235
7236static bfd_boolean
7237process_relocs (Filedata * filedata)
7238{
7239 unsigned long rel_size;
7240 unsigned long rel_offset;
7241
7242 if (!do_reloc)
7243 return TRUE;
7244
7245 if (do_using_dynamic)
7246 {
7247 int is_rela;
7248 const char * name;
7249 bfd_boolean has_dynamic_reloc;
7250 unsigned int i;
7251
7252 has_dynamic_reloc = FALSE;
7253
7254 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7255 {
7256 is_rela = dynamic_relocations [i].rela;
7257 name = dynamic_relocations [i].name;
7258 rel_size = dynamic_info [dynamic_relocations [i].size];
7259 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
7260
7261 if (rel_size)
7262 has_dynamic_reloc = TRUE;
7263
7264 if (is_rela == UNKNOWN)
7265 {
7266 if (dynamic_relocations [i].reloc == DT_JMPREL)
7267 switch (dynamic_info[DT_PLTREL])
7268 {
7269 case DT_REL:
7270 is_rela = FALSE;
7271 break;
7272 case DT_RELA:
7273 is_rela = TRUE;
7274 break;
7275 }
7276 }
7277
7278 if (rel_size)
7279 {
7280 printf
7281 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7282 name, rel_offset, rel_size);
7283
7284 dump_relocations (filedata,
7285 offset_from_vma (filedata, rel_offset, rel_size),
7286 rel_size,
7287 dynamic_symbols, num_dynamic_syms,
7288 dynamic_strings, dynamic_strings_length,
7289 is_rela, TRUE /* is_dynamic */);
7290 }
7291 }
7292
7293 if (is_ia64_vms (filedata))
7294 if (process_ia64_vms_dynamic_relocs (filedata))
7295 has_dynamic_reloc = TRUE;
7296
7297 if (! has_dynamic_reloc)
7298 printf (_("\nThere are no dynamic relocations in this file.\n"));
7299 }
7300 else
7301 {
7302 Elf_Internal_Shdr * section;
7303 unsigned long i;
7304 bfd_boolean found = FALSE;
7305
7306 for (i = 0, section = filedata->section_headers;
7307 i < filedata->file_header.e_shnum;
7308 i++, section++)
7309 {
7310 if ( section->sh_type != SHT_RELA
7311 && section->sh_type != SHT_REL)
7312 continue;
7313
7314 rel_offset = section->sh_offset;
7315 rel_size = section->sh_size;
7316
7317 if (rel_size)
7318 {
7319 Elf_Internal_Shdr * strsec;
7320 int is_rela;
7321 unsigned long num_rela;
7322
7323 printf (_("\nRelocation section "));
7324
7325 if (filedata->string_table == NULL)
7326 printf ("%d", section->sh_name);
7327 else
7328 printf ("'%s'", printable_section_name (filedata, section));
7329
7330 num_rela = rel_size / section->sh_entsize;
7331 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7332 " at offset 0x%lx contains %lu entries:\n",
7333 num_rela),
7334 rel_offset, num_rela);
7335
7336 is_rela = section->sh_type == SHT_RELA;
7337
7338 if (section->sh_link != 0
7339 && section->sh_link < filedata->file_header.e_shnum)
7340 {
7341 Elf_Internal_Shdr * symsec;
7342 Elf_Internal_Sym * symtab;
7343 unsigned long nsyms;
7344 unsigned long strtablen = 0;
7345 char * strtab = NULL;
7346
7347 symsec = filedata->section_headers + section->sh_link;
7348 if (symsec->sh_type != SHT_SYMTAB
7349 && symsec->sh_type != SHT_DYNSYM)
7350 continue;
7351
7352 symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
7353
7354 if (symtab == NULL)
7355 continue;
7356
7357 if (symsec->sh_link != 0
7358 && symsec->sh_link < filedata->file_header.e_shnum)
7359 {
7360 strsec = filedata->section_headers + symsec->sh_link;
7361
7362 strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7363 1, strsec->sh_size,
7364 _("string table"));
7365 strtablen = strtab == NULL ? 0 : strsec->sh_size;
7366 }
7367
7368 dump_relocations (filedata, rel_offset, rel_size,
7369 symtab, nsyms, strtab, strtablen,
7370 is_rela,
7371 symsec->sh_type == SHT_DYNSYM);
7372 if (strtab)
7373 free (strtab);
7374 free (symtab);
7375 }
7376 else
7377 dump_relocations (filedata, rel_offset, rel_size,
7378 NULL, 0, NULL, 0, is_rela,
7379 FALSE /* is_dynamic */);
7380
7381 found = TRUE;
7382 }
7383 }
7384
7385 if (! found)
7386 {
7387 /* Users sometimes forget the -D option, so try to be helpful. */
7388 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7389 {
7390 if (dynamic_info [dynamic_relocations [i].size])
7391 {
7392 printf (_("\nThere are no static relocations in this file."));
7393 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7394
7395 break;
7396 }
7397 }
7398 if (i == ARRAY_SIZE (dynamic_relocations))
7399 printf (_("\nThere are no relocations in this file.\n"));
7400 }
7401 }
7402
7403 return TRUE;
7404}
7405
7406/* An absolute address consists of a section and an offset. If the
7407 section is NULL, the offset itself is the address, otherwise, the
7408 address equals to LOAD_ADDRESS(section) + offset. */
7409
7410struct absaddr
7411{
7412 unsigned short section;
7413 bfd_vma offset;
7414};
7415
7416/* Find the nearest symbol at or below ADDR. Returns the symbol
7417 name, if found, and the offset from the symbol to ADDR. */
7418
7419static void
7420find_symbol_for_address (Filedata * filedata,
7421 Elf_Internal_Sym * symtab,
7422 unsigned long nsyms,
7423 const char * strtab,
7424 unsigned long strtab_size,
7425 struct absaddr addr,
7426 const char ** symname,
7427 bfd_vma * offset)
7428{
7429 bfd_vma dist = 0x100000;
7430 Elf_Internal_Sym * sym;
7431 Elf_Internal_Sym * beg;
7432 Elf_Internal_Sym * end;
7433 Elf_Internal_Sym * best = NULL;
7434
7435 REMOVE_ARCH_BITS (addr.offset);
7436 beg = symtab;
7437 end = symtab + nsyms;
7438
7439 while (beg < end)
7440 {
7441 bfd_vma value;
7442
7443 sym = beg + (end - beg) / 2;
7444
7445 value = sym->st_value;
7446 REMOVE_ARCH_BITS (value);
7447
7448 if (sym->st_name != 0
7449 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7450 && addr.offset >= value
7451 && addr.offset - value < dist)
7452 {
7453 best = sym;
7454 dist = addr.offset - value;
7455 if (!dist)
7456 break;
7457 }
7458
7459 if (addr.offset < value)
7460 end = sym;
7461 else
7462 beg = sym + 1;
7463 }
7464
7465 if (best)
7466 {
7467 *symname = (best->st_name >= strtab_size
7468 ? _("<corrupt>") : strtab + best->st_name);
7469 *offset = dist;
7470 return;
7471 }
7472
7473 *symname = NULL;
7474 *offset = addr.offset;
7475}
7476
7477static /* signed */ int
7478symcmp (const void *p, const void *q)
7479{
7480 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7481 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7482
7483 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7484}
7485
7486/* Process the unwind section. */
7487
7488#include "unwind-ia64.h"
7489
7490struct ia64_unw_table_entry
7491{
7492 struct absaddr start;
7493 struct absaddr end;
7494 struct absaddr info;
7495};
7496
7497struct ia64_unw_aux_info
7498{
7499 struct ia64_unw_table_entry * table; /* Unwind table. */
7500 unsigned long table_len; /* Length of unwind table. */
7501 unsigned char * info; /* Unwind info. */
7502 unsigned long info_size; /* Size of unwind info. */
7503 bfd_vma info_addr; /* Starting address of unwind info. */
7504 bfd_vma seg_base; /* Starting address of segment. */
7505 Elf_Internal_Sym * symtab; /* The symbol table. */
7506 unsigned long nsyms; /* Number of symbols. */
7507 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7508 unsigned long nfuns; /* Number of entries in funtab. */
7509 char * strtab; /* The string table. */
7510 unsigned long strtab_size; /* Size of string table. */
7511};
7512
7513static bfd_boolean
7514dump_ia64_unwind (Filedata * filedata, struct ia64_unw_aux_info * aux)
7515{
7516 struct ia64_unw_table_entry * tp;
7517 unsigned long j, nfuns;
7518 int in_body;
7519 bfd_boolean res = TRUE;
7520
7521 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7522 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7523 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7524 aux->funtab[nfuns++] = aux->symtab[j];
7525 aux->nfuns = nfuns;
7526 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7527
7528 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7529 {
7530 bfd_vma stamp;
7531 bfd_vma offset;
7532 const unsigned char * dp;
7533 const unsigned char * head;
7534 const unsigned char * end;
7535 const char * procname;
7536
7537 find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7538 aux->strtab_size, tp->start, &procname, &offset);
7539
7540 fputs ("\n<", stdout);
7541
7542 if (procname)
7543 {
7544 fputs (procname, stdout);
7545
7546 if (offset)
7547 printf ("+%lx", (unsigned long) offset);
7548 }
7549
7550 fputs (">: [", stdout);
7551 print_vma (tp->start.offset, PREFIX_HEX);
7552 fputc ('-', stdout);
7553 print_vma (tp->end.offset, PREFIX_HEX);
7554 printf ("], info at +0x%lx\n",
7555 (unsigned long) (tp->info.offset - aux->seg_base));
7556
7557 /* PR 17531: file: 86232b32. */
7558 if (aux->info == NULL)
7559 continue;
7560
7561 offset = tp->info.offset;
7562 if (tp->info.section)
7563 {
7564 if (tp->info.section >= filedata->file_header.e_shnum)
7565 {
7566 warn (_("Invalid section %u in table entry %ld\n"),
7567 tp->info.section, (long) (tp - aux->table));
7568 res = FALSE;
7569 continue;
7570 }
7571 offset += filedata->section_headers[tp->info.section].sh_addr;
7572 }
7573 offset -= aux->info_addr;
7574 /* PR 17531: file: 0997b4d1. */
7575 if (offset >= aux->info_size
7576 || aux->info_size - offset < 8)
7577 {
7578 warn (_("Invalid offset %lx in table entry %ld\n"),
7579 (long) tp->info.offset, (long) (tp - aux->table));
7580 res = FALSE;
7581 continue;
7582 }
7583
7584 head = aux->info + offset;
7585 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7586
7587 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7588 (unsigned) UNW_VER (stamp),
7589 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7590 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7591 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7592 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7593
7594 if (UNW_VER (stamp) != 1)
7595 {
7596 printf (_("\tUnknown version.\n"));
7597 continue;
7598 }
7599
7600 in_body = 0;
7601 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7602 /* PR 17531: file: 16ceda89. */
7603 if (end > aux->info + aux->info_size)
7604 end = aux->info + aux->info_size;
7605 for (dp = head + 8; dp < end;)
7606 dp = unw_decode (dp, in_body, & in_body, end);
7607 }
7608
7609 free (aux->funtab);
7610
7611 return res;
7612}
7613
7614static bfd_boolean
7615slurp_ia64_unwind_table (Filedata * filedata,
7616 struct ia64_unw_aux_info * aux,
7617 Elf_Internal_Shdr * sec)
7618{
7619 unsigned long size, nrelas, i;
7620 Elf_Internal_Phdr * seg;
7621 struct ia64_unw_table_entry * tep;
7622 Elf_Internal_Shdr * relsec;
7623 Elf_Internal_Rela * rela;
7624 Elf_Internal_Rela * rp;
7625 unsigned char * table;
7626 unsigned char * tp;
7627 Elf_Internal_Sym * sym;
7628 const char * relname;
7629
7630 aux->table_len = 0;
7631
7632 /* First, find the starting address of the segment that includes
7633 this section: */
7634
7635 if (filedata->file_header.e_phnum)
7636 {
7637 if (! get_program_headers (filedata))
7638 return FALSE;
7639
7640 for (seg = filedata->program_headers;
7641 seg < filedata->program_headers + filedata->file_header.e_phnum;
7642 ++seg)
7643 {
7644 if (seg->p_type != PT_LOAD)
7645 continue;
7646
7647 if (sec->sh_addr >= seg->p_vaddr
7648 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7649 {
7650 aux->seg_base = seg->p_vaddr;
7651 break;
7652 }
7653 }
7654 }
7655
7656 /* Second, build the unwind table from the contents of the unwind section: */
7657 size = sec->sh_size;
7658 table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7659 _("unwind table"));
7660 if (!table)
7661 return FALSE;
7662
7663 aux->table_len = size / (3 * eh_addr_size);
7664 aux->table = (struct ia64_unw_table_entry *)
7665 xcmalloc (aux->table_len, sizeof (aux->table[0]));
7666 tep = aux->table;
7667
7668 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7669 {
7670 tep->start.section = SHN_UNDEF;
7671 tep->end.section = SHN_UNDEF;
7672 tep->info.section = SHN_UNDEF;
7673 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7674 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7675 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7676 tep->start.offset += aux->seg_base;
7677 tep->end.offset += aux->seg_base;
7678 tep->info.offset += aux->seg_base;
7679 }
7680 free (table);
7681
7682 /* Third, apply any relocations to the unwind table: */
7683 for (relsec = filedata->section_headers;
7684 relsec < filedata->section_headers + filedata->file_header.e_shnum;
7685 ++relsec)
7686 {
7687 if (relsec->sh_type != SHT_RELA
7688 || relsec->sh_info >= filedata->file_header.e_shnum
7689 || filedata->section_headers + relsec->sh_info != sec)
7690 continue;
7691
7692 if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7693 & rela, & nrelas))
7694 {
7695 free (aux->table);
7696 aux->table = NULL;
7697 aux->table_len = 0;
7698 return FALSE;
7699 }
7700
7701 for (rp = rela; rp < rela + nrelas; ++rp)
7702 {
7703 unsigned int sym_ndx;
7704 unsigned int r_type = get_reloc_type (filedata, rp->r_info);
7705 relname = elf_ia64_reloc_type (r_type);
7706
7707 /* PR 17531: file: 9fa67536. */
7708 if (relname == NULL)
7709 {
7710 warn (_("Skipping unknown relocation type: %u\n"), r_type);
7711 continue;
7712 }
7713
7714 if (! const_strneq (relname, "R_IA64_SEGREL"))
7715 {
7716 warn (_("Skipping unexpected relocation type: %s\n"), relname);
7717 continue;
7718 }
7719
7720 i = rp->r_offset / (3 * eh_addr_size);
7721
7722 /* PR 17531: file: 5bc8d9bf. */
7723 if (i >= aux->table_len)
7724 {
7725 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7726 continue;
7727 }
7728
7729 sym_ndx = get_reloc_symindex (rp->r_info);
7730 if (sym_ndx >= aux->nsyms)
7731 {
7732 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7733 sym_ndx);
7734 continue;
7735 }
7736 sym = aux->symtab + sym_ndx;
7737
7738 switch (rp->r_offset / eh_addr_size % 3)
7739 {
7740 case 0:
7741 aux->table[i].start.section = sym->st_shndx;
7742 aux->table[i].start.offset = rp->r_addend + sym->st_value;
7743 break;
7744 case 1:
7745 aux->table[i].end.section = sym->st_shndx;
7746 aux->table[i].end.offset = rp->r_addend + sym->st_value;
7747 break;
7748 case 2:
7749 aux->table[i].info.section = sym->st_shndx;
7750 aux->table[i].info.offset = rp->r_addend + sym->st_value;
7751 break;
7752 default:
7753 break;
7754 }
7755 }
7756
7757 free (rela);
7758 }
7759
7760 return TRUE;
7761}
7762
7763static bfd_boolean
7764ia64_process_unwind (Filedata * filedata)
7765{
7766 Elf_Internal_Shdr * sec;
7767 Elf_Internal_Shdr * unwsec = NULL;
7768 Elf_Internal_Shdr * strsec;
7769 unsigned long i, unwcount = 0, unwstart = 0;
7770 struct ia64_unw_aux_info aux;
7771 bfd_boolean res = TRUE;
7772
7773 memset (& aux, 0, sizeof (aux));
7774
7775 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
7776 {
7777 if (sec->sh_type == SHT_SYMTAB
7778 && sec->sh_link < filedata->file_header.e_shnum)
7779 {
7780 aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
7781
7782 strsec = filedata->section_headers + sec->sh_link;
7783 if (aux.strtab != NULL)
7784 {
7785 error (_("Multiple auxillary string tables encountered\n"));
7786 free (aux.strtab);
7787 res = FALSE;
7788 }
7789 aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7790 1, strsec->sh_size,
7791 _("string table"));
7792 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7793 }
7794 else if (sec->sh_type == SHT_IA_64_UNWIND)
7795 unwcount++;
7796 }
7797
7798 if (!unwcount)
7799 printf (_("\nThere are no unwind sections in this file.\n"));
7800
7801 while (unwcount-- > 0)
7802 {
7803 char * suffix;
7804 size_t len, len2;
7805
7806 for (i = unwstart, sec = filedata->section_headers + unwstart, unwsec = NULL;
7807 i < filedata->file_header.e_shnum; ++i, ++sec)
7808 if (sec->sh_type == SHT_IA_64_UNWIND)
7809 {
7810 unwsec = sec;
7811 break;
7812 }
7813 /* We have already counted the number of SHT_IA64_UNWIND
7814 sections so the loop above should never fail. */
7815 assert (unwsec != NULL);
7816
7817 unwstart = i + 1;
7818 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7819
7820 if ((unwsec->sh_flags & SHF_GROUP) != 0)
7821 {
7822 /* We need to find which section group it is in. */
7823 struct group_list * g;
7824
7825 if (section_headers_groups == NULL
7826 || section_headers_groups [i] == NULL)
7827 i = filedata->file_header.e_shnum;
7828 else
7829 {
7830 g = section_headers_groups [i]->root;
7831
7832 for (; g != NULL; g = g->next)
7833 {
7834 sec = filedata->section_headers + g->section_index;
7835
7836 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7837 break;
7838 }
7839
7840 if (g == NULL)
7841 i = filedata->file_header.e_shnum;
7842 }
7843 }
7844 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7845 {
7846 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7847 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7848 suffix = SECTION_NAME (unwsec) + len;
7849 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7850 ++i, ++sec)
7851 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7852 && streq (SECTION_NAME (sec) + len2, suffix))
7853 break;
7854 }
7855 else
7856 {
7857 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7858 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7859 len = sizeof (ELF_STRING_ia64_unwind) - 1;
7860 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7861 suffix = "";
7862 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7863 suffix = SECTION_NAME (unwsec) + len;
7864 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7865 ++i, ++sec)
7866 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7867 && streq (SECTION_NAME (sec) + len2, suffix))
7868 break;
7869 }
7870
7871 if (i == filedata->file_header.e_shnum)
7872 {
7873 printf (_("\nCould not find unwind info section for "));
7874
7875 if (filedata->string_table == NULL)
7876 printf ("%d", unwsec->sh_name);
7877 else
7878 printf ("'%s'", printable_section_name (filedata, unwsec));
7879 }
7880 else
7881 {
7882 aux.info_addr = sec->sh_addr;
7883 aux.info = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1,
7884 sec->sh_size,
7885 _("unwind info"));
7886 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7887
7888 printf (_("\nUnwind section "));
7889
7890 if (filedata->string_table == NULL)
7891 printf ("%d", unwsec->sh_name);
7892 else
7893 printf ("'%s'", printable_section_name (filedata, unwsec));
7894
7895 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7896 (unsigned long) unwsec->sh_offset,
7897 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7898
7899 if (slurp_ia64_unwind_table (filedata, & aux, unwsec)
7900 && aux.table_len > 0)
7901 dump_ia64_unwind (filedata, & aux);
7902
7903 if (aux.table)
7904 free ((char *) aux.table);
7905 if (aux.info)
7906 free ((char *) aux.info);
7907 aux.table = NULL;
7908 aux.info = NULL;
7909 }
7910 }
7911
7912 if (aux.symtab)
7913 free (aux.symtab);
7914 if (aux.strtab)
7915 free ((char *) aux.strtab);
7916
7917 return res;
7918}
7919
7920struct hppa_unw_table_entry
7921{
7922 struct absaddr start;
7923 struct absaddr end;
7924 unsigned int Cannot_unwind:1; /* 0 */
7925 unsigned int Millicode:1; /* 1 */
7926 unsigned int Millicode_save_sr0:1; /* 2 */
7927 unsigned int Region_description:2; /* 3..4 */
7928 unsigned int reserved1:1; /* 5 */
7929 unsigned int Entry_SR:1; /* 6 */
7930 unsigned int Entry_FR:4; /* Number saved 7..10 */
7931 unsigned int Entry_GR:5; /* Number saved 11..15 */
7932 unsigned int Args_stored:1; /* 16 */
7933 unsigned int Variable_Frame:1; /* 17 */
7934 unsigned int Separate_Package_Body:1; /* 18 */
7935 unsigned int Frame_Extension_Millicode:1; /* 19 */
7936 unsigned int Stack_Overflow_Check:1; /* 20 */
7937 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
7938 unsigned int Ada_Region:1; /* 22 */
7939 unsigned int cxx_info:1; /* 23 */
7940 unsigned int cxx_try_catch:1; /* 24 */
7941 unsigned int sched_entry_seq:1; /* 25 */
7942 unsigned int reserved2:1; /* 26 */
7943 unsigned int Save_SP:1; /* 27 */
7944 unsigned int Save_RP:1; /* 28 */
7945 unsigned int Save_MRP_in_frame:1; /* 29 */
7946 unsigned int extn_ptr_defined:1; /* 30 */
7947 unsigned int Cleanup_defined:1; /* 31 */
7948
7949 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
7950 unsigned int HP_UX_interrupt_marker:1; /* 1 */
7951 unsigned int Large_frame:1; /* 2 */
7952 unsigned int Pseudo_SP_Set:1; /* 3 */
7953 unsigned int reserved4:1; /* 4 */
7954 unsigned int Total_frame_size:27; /* 5..31 */
7955};
7956
7957struct hppa_unw_aux_info
7958{
7959 struct hppa_unw_table_entry * table; /* Unwind table. */
7960 unsigned long table_len; /* Length of unwind table. */
7961 bfd_vma seg_base; /* Starting address of segment. */
7962 Elf_Internal_Sym * symtab; /* The symbol table. */
7963 unsigned long nsyms; /* Number of symbols. */
7964 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7965 unsigned long nfuns; /* Number of entries in funtab. */
7966 char * strtab; /* The string table. */
7967 unsigned long strtab_size; /* Size of string table. */
7968};
7969
7970static bfd_boolean
7971dump_hppa_unwind (Filedata * filedata, struct hppa_unw_aux_info * aux)
7972{
7973 struct hppa_unw_table_entry * tp;
7974 unsigned long j, nfuns;
7975 bfd_boolean res = TRUE;
7976
7977 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7978 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7979 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7980 aux->funtab[nfuns++] = aux->symtab[j];
7981 aux->nfuns = nfuns;
7982 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7983
7984 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7985 {
7986 bfd_vma offset;
7987 const char * procname;
7988
7989 find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7990 aux->strtab_size, tp->start, &procname,
7991 &offset);
7992
7993 fputs ("\n<", stdout);
7994
7995 if (procname)
7996 {
7997 fputs (procname, stdout);
7998
7999 if (offset)
8000 printf ("+%lx", (unsigned long) offset);
8001 }
8002
8003 fputs (">: [", stdout);
8004 print_vma (tp->start.offset, PREFIX_HEX);
8005 fputc ('-', stdout);
8006 print_vma (tp->end.offset, PREFIX_HEX);
8007 printf ("]\n\t");
8008
8009#define PF(_m) if (tp->_m) printf (#_m " ");
8010#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8011 PF(Cannot_unwind);
8012 PF(Millicode);
8013 PF(Millicode_save_sr0);
8014 /* PV(Region_description); */
8015 PF(Entry_SR);
8016 PV(Entry_FR);
8017 PV(Entry_GR);
8018 PF(Args_stored);
8019 PF(Variable_Frame);
8020 PF(Separate_Package_Body);
8021 PF(Frame_Extension_Millicode);
8022 PF(Stack_Overflow_Check);
8023 PF(Two_Instruction_SP_Increment);
8024 PF(Ada_Region);
8025 PF(cxx_info);
8026 PF(cxx_try_catch);
8027 PF(sched_entry_seq);
8028 PF(Save_SP);
8029 PF(Save_RP);
8030 PF(Save_MRP_in_frame);
8031 PF(extn_ptr_defined);
8032 PF(Cleanup_defined);
8033 PF(MPE_XL_interrupt_marker);
8034 PF(HP_UX_interrupt_marker);
8035 PF(Large_frame);
8036 PF(Pseudo_SP_Set);
8037 PV(Total_frame_size);
8038#undef PF
8039#undef PV
8040 }
8041
8042 printf ("\n");
8043
8044 free (aux->funtab);
8045
8046 return res;
8047}
8048
8049static bfd_boolean
8050slurp_hppa_unwind_table (Filedata * filedata,
8051 struct hppa_unw_aux_info * aux,
8052 Elf_Internal_Shdr * sec)
8053{
8054 unsigned long size, unw_ent_size, nentries, nrelas, i;
8055 Elf_Internal_Phdr * seg;
8056 struct hppa_unw_table_entry * tep;
8057 Elf_Internal_Shdr * relsec;
8058 Elf_Internal_Rela * rela;
8059 Elf_Internal_Rela * rp;
8060 unsigned char * table;
8061 unsigned char * tp;
8062 Elf_Internal_Sym * sym;
8063 const char * relname;
8064
8065 /* First, find the starting address of the segment that includes
8066 this section. */
8067 if (filedata->file_header.e_phnum)
8068 {
8069 if (! get_program_headers (filedata))
8070 return FALSE;
8071
8072 for (seg = filedata->program_headers;
8073 seg < filedata->program_headers + filedata->file_header.e_phnum;
8074 ++seg)
8075 {
8076 if (seg->p_type != PT_LOAD)
8077 continue;
8078
8079 if (sec->sh_addr >= seg->p_vaddr
8080 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
8081 {
8082 aux->seg_base = seg->p_vaddr;
8083 break;
8084 }
8085 }
8086 }
8087
8088 /* Second, build the unwind table from the contents of the unwind
8089 section. */
8090 size = sec->sh_size;
8091 table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
8092 _("unwind table"));
8093 if (!table)
8094 return FALSE;
8095
8096 unw_ent_size = 16;
8097 nentries = size / unw_ent_size;
8098 size = unw_ent_size * nentries;
8099
8100 tep = aux->table = (struct hppa_unw_table_entry *)
8101 xcmalloc (nentries, sizeof (aux->table[0]));
8102
8103 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
8104 {
8105 unsigned int tmp1, tmp2;
8106
8107 tep->start.section = SHN_UNDEF;
8108 tep->end.section = SHN_UNDEF;
8109
8110 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
8111 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
8112 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
8113 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
8114
8115 tep->start.offset += aux->seg_base;
8116 tep->end.offset += aux->seg_base;
8117
8118 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
8119 tep->Millicode = (tmp1 >> 30) & 0x1;
8120 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
8121 tep->Region_description = (tmp1 >> 27) & 0x3;
8122 tep->reserved1 = (tmp1 >> 26) & 0x1;
8123 tep->Entry_SR = (tmp1 >> 25) & 0x1;
8124 tep->Entry_FR = (tmp1 >> 21) & 0xf;
8125 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
8126 tep->Args_stored = (tmp1 >> 15) & 0x1;
8127 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
8128 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
8129 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
8130 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
8131 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
8132 tep->Ada_Region = (tmp1 >> 9) & 0x1;
8133 tep->cxx_info = (tmp1 >> 8) & 0x1;
8134 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
8135 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
8136 tep->reserved2 = (tmp1 >> 5) & 0x1;
8137 tep->Save_SP = (tmp1 >> 4) & 0x1;
8138 tep->Save_RP = (tmp1 >> 3) & 0x1;
8139 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
8140 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
8141 tep->Cleanup_defined = tmp1 & 0x1;
8142
8143 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
8144 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
8145 tep->Large_frame = (tmp2 >> 29) & 0x1;
8146 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
8147 tep->reserved4 = (tmp2 >> 27) & 0x1;
8148 tep->Total_frame_size = tmp2 & 0x7ffffff;
8149 }
8150 free (table);
8151
8152 /* Third, apply any relocations to the unwind table. */
8153 for (relsec = filedata->section_headers;
8154 relsec < filedata->section_headers + filedata->file_header.e_shnum;
8155 ++relsec)
8156 {
8157 if (relsec->sh_type != SHT_RELA
8158 || relsec->sh_info >= filedata->file_header.e_shnum
8159 || filedata->section_headers + relsec->sh_info != sec)
8160 continue;
8161
8162 if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
8163 & rela, & nrelas))
8164 return FALSE;
8165
8166 for (rp = rela; rp < rela + nrelas; ++rp)
8167 {
8168 unsigned int sym_ndx;
8169 unsigned int r_type = get_reloc_type (filedata, rp->r_info);
8170 relname = elf_hppa_reloc_type (r_type);
8171
8172 if (relname == NULL)
8173 {
8174 warn (_("Skipping unknown relocation type: %u\n"), r_type);
8175 continue;
8176 }
8177
8178 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8179 if (! const_strneq (relname, "R_PARISC_SEGREL"))
8180 {
8181 warn (_("Skipping unexpected relocation type: %s\n"), relname);
8182 continue;
8183 }
8184
8185 i = rp->r_offset / unw_ent_size;
8186 if (i >= aux->table_len)
8187 {
8188 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
8189 continue;
8190 }
8191
8192 sym_ndx = get_reloc_symindex (rp->r_info);
8193 if (sym_ndx >= aux->nsyms)
8194 {
8195 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8196 sym_ndx);
8197 continue;
8198 }
8199 sym = aux->symtab + sym_ndx;
8200
8201 switch ((rp->r_offset % unw_ent_size) / 4)
8202 {
8203 case 0:
8204 aux->table[i].start.section = sym->st_shndx;
8205 aux->table[i].start.offset = sym->st_value + rp->r_addend;
8206 break;
8207 case 1:
8208 aux->table[i].end.section = sym->st_shndx;
8209 aux->table[i].end.offset = sym->st_value + rp->r_addend;
8210 break;
8211 default:
8212 break;
8213 }
8214 }
8215
8216 free (rela);
8217 }
8218
8219 aux->table_len = nentries;
8220
8221 return TRUE;
8222}
8223
8224static bfd_boolean
8225hppa_process_unwind (Filedata * filedata)
8226{
8227 struct hppa_unw_aux_info aux;
8228 Elf_Internal_Shdr * unwsec = NULL;
8229 Elf_Internal_Shdr * strsec;
8230 Elf_Internal_Shdr * sec;
8231 unsigned long i;
8232 bfd_boolean res = TRUE;
8233
8234 if (filedata->string_table == NULL)
8235 return FALSE;
8236
8237 memset (& aux, 0, sizeof (aux));
8238
8239 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8240 {
8241 if (sec->sh_type == SHT_SYMTAB
8242 && sec->sh_link < filedata->file_header.e_shnum)
8243 {
8244 aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
8245
8246 strsec = filedata->section_headers + sec->sh_link;
8247 if (aux.strtab != NULL)
8248 {
8249 error (_("Multiple auxillary string tables encountered\n"));
8250 free (aux.strtab);
8251 res = FALSE;
8252 }
8253 aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
8254 1, strsec->sh_size,
8255 _("string table"));
8256 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8257 }
8258 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8259 unwsec = sec;
8260 }
8261
8262 if (!unwsec)
8263 printf (_("\nThere are no unwind sections in this file.\n"));
8264
8265 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8266 {
8267 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8268 {
8269 unsigned long num_unwind = sec->sh_size / 16;
8270
8271 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8272 "contains %lu entry:\n",
8273 "\nUnwind section '%s' at offset 0x%lx "
8274 "contains %lu entries:\n",
8275 num_unwind),
8276 printable_section_name (filedata, sec),
8277 (unsigned long) sec->sh_offset,
8278 num_unwind);
8279
8280 if (! slurp_hppa_unwind_table (filedata, &aux, sec))
8281 res = FALSE;
8282
8283 if (res && aux.table_len > 0)
8284 {
8285 if (! dump_hppa_unwind (filedata, &aux))
8286 res = FALSE;
8287 }
8288
8289 if (aux.table)
8290 free ((char *) aux.table);
8291 aux.table = NULL;
8292 }
8293 }
8294
8295 if (aux.symtab)
8296 free (aux.symtab);
8297 if (aux.strtab)
8298 free ((char *) aux.strtab);
8299
8300 return res;
8301}
8302
8303struct arm_section
8304{
8305 unsigned char * data; /* The unwind data. */
8306 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
8307 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
8308 unsigned long nrelas; /* The number of relocations. */
8309 unsigned int rel_type; /* REL or RELA ? */
8310 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
8311};
8312
8313struct arm_unw_aux_info
8314{
8315 Filedata * filedata; /* The file containing the unwind sections. */
8316 Elf_Internal_Sym * symtab; /* The file's symbol table. */
8317 unsigned long nsyms; /* Number of symbols. */
8318 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
8319 unsigned long nfuns; /* Number of these symbols. */
8320 char * strtab; /* The file's string table. */
8321 unsigned long strtab_size; /* Size of string table. */
8322};
8323
8324static const char *
8325arm_print_vma_and_name (Filedata * filedata,
8326 struct arm_unw_aux_info * aux,
8327 bfd_vma fn,
8328 struct absaddr addr)
8329{
8330 const char *procname;
8331 bfd_vma sym_offset;
8332
8333 if (addr.section == SHN_UNDEF)
8334 addr.offset = fn;
8335
8336 find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8337 aux->strtab_size, addr, &procname,
8338 &sym_offset);
8339
8340 print_vma (fn, PREFIX_HEX);
8341
8342 if (procname)
8343 {
8344 fputs (" <", stdout);
8345 fputs (procname, stdout);
8346
8347 if (sym_offset)
8348 printf ("+0x%lx", (unsigned long) sym_offset);
8349 fputc ('>', stdout);
8350 }
8351
8352 return procname;
8353}
8354
8355static void
8356arm_free_section (struct arm_section *arm_sec)
8357{
8358 if (arm_sec->data != NULL)
8359 free (arm_sec->data);
8360
8361 if (arm_sec->rela != NULL)
8362 free (arm_sec->rela);
8363}
8364
8365/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8366 cached section and install SEC instead.
8367 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8368 and return its valued in * WORDP, relocating if necessary.
8369 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8370 relocation's offset in ADDR.
8371 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8372 into the string table of the symbol associated with the reloc. If no
8373 reloc was applied store -1 there.
8374 5) Return TRUE upon success, FALSE otherwise. */
8375
8376static bfd_boolean
8377get_unwind_section_word (Filedata * filedata,
8378 struct arm_unw_aux_info * aux,
8379 struct arm_section * arm_sec,
8380 Elf_Internal_Shdr * sec,
8381 bfd_vma word_offset,
8382 unsigned int * wordp,
8383 struct absaddr * addr,
8384 bfd_vma * sym_name)
8385{
8386 Elf_Internal_Rela *rp;
8387 Elf_Internal_Sym *sym;
8388 const char * relname;
8389 unsigned int word;
8390 bfd_boolean wrapped;
8391
8392 if (sec == NULL || arm_sec == NULL)
8393 return FALSE;
8394
8395 addr->section = SHN_UNDEF;
8396 addr->offset = 0;
8397
8398 if (sym_name != NULL)
8399 *sym_name = (bfd_vma) -1;
8400
8401 /* If necessary, update the section cache. */
8402 if (sec != arm_sec->sec)
8403 {
8404 Elf_Internal_Shdr *relsec;
8405
8406 arm_free_section (arm_sec);
8407
8408 arm_sec->sec = sec;
8409 arm_sec->data = get_data (NULL, aux->filedata, sec->sh_offset, 1,
8410 sec->sh_size, _("unwind data"));
8411 arm_sec->rela = NULL;
8412 arm_sec->nrelas = 0;
8413
8414 for (relsec = filedata->section_headers;
8415 relsec < filedata->section_headers + filedata->file_header.e_shnum;
8416 ++relsec)
8417 {
8418 if (relsec->sh_info >= filedata->file_header.e_shnum
8419 || filedata->section_headers + relsec->sh_info != sec
8420 /* PR 15745: Check the section type as well. */
8421 || (relsec->sh_type != SHT_REL
8422 && relsec->sh_type != SHT_RELA))
8423 continue;
8424
8425 arm_sec->rel_type = relsec->sh_type;
8426 if (relsec->sh_type == SHT_REL)
8427 {
8428 if (!slurp_rel_relocs (aux->filedata, relsec->sh_offset,
8429 relsec->sh_size,
8430 & arm_sec->rela, & arm_sec->nrelas))
8431 return FALSE;
8432 }
8433 else /* relsec->sh_type == SHT_RELA */
8434 {
8435 if (!slurp_rela_relocs (aux->filedata, relsec->sh_offset,
8436 relsec->sh_size,
8437 & arm_sec->rela, & arm_sec->nrelas))
8438 return FALSE;
8439 }
8440 break;
8441 }
8442
8443 arm_sec->next_rela = arm_sec->rela;
8444 }
8445
8446 /* If there is no unwind data we can do nothing. */
8447 if (arm_sec->data == NULL)
8448 return FALSE;
8449
8450 /* If the offset is invalid then fail. */
8451 if (/* PR 21343 *//* PR 18879 */
8452 sec->sh_size < 4
8453 || word_offset > (sec->sh_size - 4)
8454 || ((bfd_signed_vma) word_offset) < 0)
8455 return FALSE;
8456
8457 /* Get the word at the required offset. */
8458 word = byte_get (arm_sec->data + word_offset, 4);
8459
8460 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8461 if (arm_sec->rela == NULL)
8462 {
8463 * wordp = word;
8464 return TRUE;
8465 }
8466
8467 /* Look through the relocs to find the one that applies to the provided offset. */
8468 wrapped = FALSE;
8469 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8470 {
8471 bfd_vma prelval, offset;
8472
8473 if (rp->r_offset > word_offset && !wrapped)
8474 {
8475 rp = arm_sec->rela;
8476 wrapped = TRUE;
8477 }
8478 if (rp->r_offset > word_offset)
8479 break;
8480
8481 if (rp->r_offset & 3)
8482 {
8483 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8484 (unsigned long) rp->r_offset);
8485 continue;
8486 }
8487
8488 if (rp->r_offset < word_offset)
8489 continue;
8490
8491 /* PR 17531: file: 027-161405-0.004 */
8492 if (aux->symtab == NULL)
8493 continue;
8494
8495 if (arm_sec->rel_type == SHT_REL)
8496 {
8497 offset = word & 0x7fffffff;
8498 if (offset & 0x40000000)
8499 offset |= ~ (bfd_vma) 0x7fffffff;
8500 }
8501 else if (arm_sec->rel_type == SHT_RELA)
8502 offset = rp->r_addend;
8503 else
8504 {
8505 error (_("Unknown section relocation type %d encountered\n"),
8506 arm_sec->rel_type);
8507 break;
8508 }
8509
8510 /* PR 17531 file: 027-1241568-0.004. */
8511 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8512 {
8513 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8514 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8515 break;
8516 }
8517
8518 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8519 offset += sym->st_value;
8520 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8521
8522 /* Check that we are processing the expected reloc type. */
8523 if (filedata->file_header.e_machine == EM_ARM)
8524 {
8525 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8526 if (relname == NULL)
8527 {
8528 warn (_("Skipping unknown ARM relocation type: %d\n"),
8529 (int) ELF32_R_TYPE (rp->r_info));
8530 continue;
8531 }
8532
8533 if (streq (relname, "R_ARM_NONE"))
8534 continue;
8535
8536 if (! streq (relname, "R_ARM_PREL31"))
8537 {
8538 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8539 continue;
8540 }
8541 }
8542 else if (filedata->file_header.e_machine == EM_TI_C6000)
8543 {
8544 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8545 if (relname == NULL)
8546 {
8547 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8548 (int) ELF32_R_TYPE (rp->r_info));
8549 continue;
8550 }
8551
8552 if (streq (relname, "R_C6000_NONE"))
8553 continue;
8554
8555 if (! streq (relname, "R_C6000_PREL31"))
8556 {
8557 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8558 continue;
8559 }
8560
8561 prelval >>= 1;
8562 }
8563 else
8564 {
8565 /* This function currently only supports ARM and TI unwinders. */
8566 warn (_("Only TI and ARM unwinders are currently supported\n"));
8567 break;
8568 }
8569
8570 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8571 addr->section = sym->st_shndx;
8572 addr->offset = offset;
8573
8574 if (sym_name)
8575 * sym_name = sym->st_name;
8576 break;
8577 }
8578
8579 *wordp = word;
8580 arm_sec->next_rela = rp;
8581
8582 return TRUE;
8583}
8584
8585static const char *tic6x_unwind_regnames[16] =
8586{
8587 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8588 "A14", "A13", "A12", "A11", "A10",
8589 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8590};
8591
8592static void
8593decode_tic6x_unwind_regmask (unsigned int mask)
8594{
8595 int i;
8596
8597 for (i = 12; mask; mask >>= 1, i--)
8598 {
8599 if (mask & 1)
8600 {
8601 fputs (tic6x_unwind_regnames[i], stdout);
8602 if (mask > 1)
8603 fputs (", ", stdout);
8604 }
8605 }
8606}
8607
8608#define ADVANCE \
8609 if (remaining == 0 && more_words) \
8610 { \
8611 data_offset += 4; \
8612 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8613 data_offset, & word, & addr, NULL)) \
8614 return FALSE; \
8615 remaining = 4; \
8616 more_words--; \
8617 } \
8618
8619#define GET_OP(OP) \
8620 ADVANCE; \
8621 if (remaining) \
8622 { \
8623 remaining--; \
8624 (OP) = word >> 24; \
8625 word <<= 8; \
8626 } \
8627 else \
8628 { \
8629 printf (_("[Truncated opcode]\n")); \
8630 return FALSE; \
8631 } \
8632 printf ("0x%02x ", OP)
8633
8634static bfd_boolean
8635decode_arm_unwind_bytecode (Filedata * filedata,
8636 struct arm_unw_aux_info * aux,
8637 unsigned int word,
8638 unsigned int remaining,
8639 unsigned int more_words,
8640 bfd_vma data_offset,
8641 Elf_Internal_Shdr * data_sec,
8642 struct arm_section * data_arm_sec)
8643{
8644 struct absaddr addr;
8645 bfd_boolean res = TRUE;
8646
8647 /* Decode the unwinding instructions. */
8648 while (1)
8649 {
8650 unsigned int op, op2;
8651
8652 ADVANCE;
8653 if (remaining == 0)
8654 break;
8655 remaining--;
8656 op = word >> 24;
8657 word <<= 8;
8658
8659 printf (" 0x%02x ", op);
8660
8661 if ((op & 0xc0) == 0x00)
8662 {
8663 int offset = ((op & 0x3f) << 2) + 4;
8664
8665 printf (" vsp = vsp + %d", offset);
8666 }
8667 else if ((op & 0xc0) == 0x40)
8668 {
8669 int offset = ((op & 0x3f) << 2) + 4;
8670
8671 printf (" vsp = vsp - %d", offset);
8672 }
8673 else if ((op & 0xf0) == 0x80)
8674 {
8675 GET_OP (op2);
8676 if (op == 0x80 && op2 == 0)
8677 printf (_("Refuse to unwind"));
8678 else
8679 {
8680 unsigned int mask = ((op & 0x0f) << 8) | op2;
8681 bfd_boolean first = TRUE;
8682 int i;
8683
8684 printf ("pop {");
8685 for (i = 0; i < 12; i++)
8686 if (mask & (1 << i))
8687 {
8688 if (first)
8689 first = FALSE;
8690 else
8691 printf (", ");
8692 printf ("r%d", 4 + i);
8693 }
8694 printf ("}");
8695 }
8696 }
8697 else if ((op & 0xf0) == 0x90)
8698 {
8699 if (op == 0x9d || op == 0x9f)
8700 printf (_(" [Reserved]"));
8701 else
8702 printf (" vsp = r%d", op & 0x0f);
8703 }
8704 else if ((op & 0xf0) == 0xa0)
8705 {
8706 int end = 4 + (op & 0x07);
8707 bfd_boolean first = TRUE;
8708 int i;
8709
8710 printf (" pop {");
8711 for (i = 4; i <= end; i++)
8712 {
8713 if (first)
8714 first = FALSE;
8715 else
8716 printf (", ");
8717 printf ("r%d", i);
8718 }
8719 if (op & 0x08)
8720 {
8721 if (!first)
8722 printf (", ");
8723 printf ("r14");
8724 }
8725 printf ("}");
8726 }
8727 else if (op == 0xb0)
8728 printf (_(" finish"));
8729 else if (op == 0xb1)
8730 {
8731 GET_OP (op2);
8732 if (op2 == 0 || (op2 & 0xf0) != 0)
8733 printf (_("[Spare]"));
8734 else
8735 {
8736 unsigned int mask = op2 & 0x0f;
8737 bfd_boolean first = TRUE;
8738 int i;
8739
8740 printf ("pop {");
8741 for (i = 0; i < 12; i++)
8742 if (mask & (1 << i))
8743 {
8744 if (first)
8745 first = FALSE;
8746 else
8747 printf (", ");
8748 printf ("r%d", i);
8749 }
8750 printf ("}");
8751 }
8752 }
8753 else if (op == 0xb2)
8754 {
8755 unsigned char buf[9];
8756 unsigned int i, len;
8757 unsigned long offset;
8758
8759 for (i = 0; i < sizeof (buf); i++)
8760 {
8761 GET_OP (buf[i]);
8762 if ((buf[i] & 0x80) == 0)
8763 break;
8764 }
8765 if (i == sizeof (buf))
8766 {
8767 error (_("corrupt change to vsp"));
8768 res = FALSE;
8769 }
8770 else
8771 {
8772 offset = read_uleb128 (buf, &len, buf + i + 1);
8773 assert (len == i + 1);
8774 offset = offset * 4 + 0x204;
8775 printf ("vsp = vsp + %ld", offset);
8776 }
8777 }
8778 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8779 {
8780 unsigned int first, last;
8781
8782 GET_OP (op2);
8783 first = op2 >> 4;
8784 last = op2 & 0x0f;
8785 if (op == 0xc8)
8786 first = first + 16;
8787 printf ("pop {D%d", first);
8788 if (last)
8789 printf ("-D%d", first + last);
8790 printf ("}");
8791 }
8792 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8793 {
8794 unsigned int count = op & 0x07;
8795
8796 printf ("pop {D8");
8797 if (count)
8798 printf ("-D%d", 8 + count);
8799 printf ("}");
8800 }
8801 else if (op >= 0xc0 && op <= 0xc5)
8802 {
8803 unsigned int count = op & 0x07;
8804
8805 printf (" pop {wR10");
8806 if (count)
8807 printf ("-wR%d", 10 + count);
8808 printf ("}");
8809 }
8810 else if (op == 0xc6)
8811 {
8812 unsigned int first, last;
8813
8814 GET_OP (op2);
8815 first = op2 >> 4;
8816 last = op2 & 0x0f;
8817 printf ("pop {wR%d", first);
8818 if (last)
8819 printf ("-wR%d", first + last);
8820 printf ("}");
8821 }
8822 else if (op == 0xc7)
8823 {
8824 GET_OP (op2);
8825 if (op2 == 0 || (op2 & 0xf0) != 0)
8826 printf (_("[Spare]"));
8827 else
8828 {
8829 unsigned int mask = op2 & 0x0f;
8830 bfd_boolean first = TRUE;
8831 int i;
8832
8833 printf ("pop {");
8834 for (i = 0; i < 4; i++)
8835 if (mask & (1 << i))
8836 {
8837 if (first)
8838 first = FALSE;
8839 else
8840 printf (", ");
8841 printf ("wCGR%d", i);
8842 }
8843 printf ("}");
8844 }
8845 }
8846 else
8847 {
8848 printf (_(" [unsupported opcode]"));
8849 res = FALSE;
8850 }
8851
8852 printf ("\n");
8853 }
8854
8855 return res;
8856}
8857
8858static bfd_boolean
8859decode_tic6x_unwind_bytecode (Filedata * filedata,
8860 struct arm_unw_aux_info * aux,
8861 unsigned int word,
8862 unsigned int remaining,
8863 unsigned int more_words,
8864 bfd_vma data_offset,
8865 Elf_Internal_Shdr * data_sec,
8866 struct arm_section * data_arm_sec)
8867{
8868 struct absaddr addr;
8869
8870 /* Decode the unwinding instructions. */
8871 while (1)
8872 {
8873 unsigned int op, op2;
8874
8875 ADVANCE;
8876 if (remaining == 0)
8877 break;
8878 remaining--;
8879 op = word >> 24;
8880 word <<= 8;
8881
8882 printf (" 0x%02x ", op);
8883
8884 if ((op & 0xc0) == 0x00)
8885 {
8886 int offset = ((op & 0x3f) << 3) + 8;
8887 printf (" sp = sp + %d", offset);
8888 }
8889 else if ((op & 0xc0) == 0x80)
8890 {
8891 GET_OP (op2);
8892 if (op == 0x80 && op2 == 0)
8893 printf (_("Refuse to unwind"));
8894 else
8895 {
8896 unsigned int mask = ((op & 0x1f) << 8) | op2;
8897 if (op & 0x20)
8898 printf ("pop compact {");
8899 else
8900 printf ("pop {");
8901
8902 decode_tic6x_unwind_regmask (mask);
8903 printf("}");
8904 }
8905 }
8906 else if ((op & 0xf0) == 0xc0)
8907 {
8908 unsigned int reg;
8909 unsigned int nregs;
8910 unsigned int i;
8911 const char *name;
8912 struct
8913 {
8914 unsigned int offset;
8915 unsigned int reg;
8916 } regpos[16];
8917
8918 /* Scan entire instruction first so that GET_OP output is not
8919 interleaved with disassembly. */
8920 nregs = 0;
8921 for (i = 0; nregs < (op & 0xf); i++)
8922 {
8923 GET_OP (op2);
8924 reg = op2 >> 4;
8925 if (reg != 0xf)
8926 {
8927 regpos[nregs].offset = i * 2;
8928 regpos[nregs].reg = reg;
8929 nregs++;
8930 }
8931
8932 reg = op2 & 0xf;
8933 if (reg != 0xf)
8934 {
8935 regpos[nregs].offset = i * 2 + 1;
8936 regpos[nregs].reg = reg;
8937 nregs++;
8938 }
8939 }
8940
8941 printf (_("pop frame {"));
8942 if (nregs == 0)
8943 {
8944 printf (_("*corrupt* - no registers specified"));
8945 }
8946 else
8947 {
8948 reg = nregs - 1;
8949 for (i = i * 2; i > 0; i--)
8950 {
8951 if (regpos[reg].offset == i - 1)
8952 {
8953 name = tic6x_unwind_regnames[regpos[reg].reg];
8954 if (reg > 0)
8955 reg--;
8956 }
8957 else
8958 name = _("[pad]");
8959
8960 fputs (name, stdout);
8961 if (i > 1)
8962 printf (", ");
8963 }
8964 }
8965
8966 printf ("}");
8967 }
8968 else if (op == 0xd0)
8969 printf (" MOV FP, SP");
8970 else if (op == 0xd1)
8971 printf (" __c6xabi_pop_rts");
8972 else if (op == 0xd2)
8973 {
8974 unsigned char buf[9];
8975 unsigned int i, len;
8976 unsigned long offset;
8977
8978 for (i = 0; i < sizeof (buf); i++)
8979 {
8980 GET_OP (buf[i]);
8981 if ((buf[i] & 0x80) == 0)
8982 break;
8983 }
8984 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8985 if (i == sizeof (buf))
8986 {
8987 warn (_("Corrupt stack pointer adjustment detected\n"));
8988 return FALSE;
8989 }
8990
8991 offset = read_uleb128 (buf, &len, buf + i + 1);
8992 assert (len == i + 1);
8993 offset = offset * 8 + 0x408;
8994 printf (_("sp = sp + %ld"), offset);
8995 }
8996 else if ((op & 0xf0) == 0xe0)
8997 {
8998 if ((op & 0x0f) == 7)
8999 printf (" RETURN");
9000 else
9001 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
9002 }
9003 else
9004 {
9005 printf (_(" [unsupported opcode]"));
9006 }
9007 putchar ('\n');
9008 }
9009
9010 return TRUE;
9011}
9012
9013static bfd_vma
9014arm_expand_prel31 (Filedata * filedata, bfd_vma word, bfd_vma where)
9015{
9016 bfd_vma offset;
9017
9018 offset = word & 0x7fffffff;
9019 if (offset & 0x40000000)
9020 offset |= ~ (bfd_vma) 0x7fffffff;
9021
9022 if (filedata->file_header.e_machine == EM_TI_C6000)
9023 offset <<= 1;
9024
9025 return offset + where;
9026}
9027
9028static bfd_boolean
9029decode_arm_unwind (Filedata * filedata,
9030 struct arm_unw_aux_info * aux,
9031 unsigned int word,
9032 unsigned int remaining,
9033 bfd_vma data_offset,
9034 Elf_Internal_Shdr * data_sec,
9035 struct arm_section * data_arm_sec)
9036{
9037 int per_index;
9038 unsigned int more_words = 0;
9039 struct absaddr addr;
9040 bfd_vma sym_name = (bfd_vma) -1;
9041 bfd_boolean res = TRUE;
9042
9043 if (remaining == 0)
9044 {
9045 /* Fetch the first word.
9046 Note - when decoding an object file the address extracted
9047 here will always be 0. So we also pass in the sym_name
9048 parameter so that we can find the symbol associated with
9049 the personality routine. */
9050 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, data_offset,
9051 & word, & addr, & sym_name))
9052 return FALSE;
9053
9054 remaining = 4;
9055 }
9056 else
9057 {
9058 addr.section = SHN_UNDEF;
9059 addr.offset = 0;
9060 }
9061
9062 if ((word & 0x80000000) == 0)
9063 {
9064 /* Expand prel31 for personality routine. */
9065 bfd_vma fn;
9066 const char *procname;
9067
9068 fn = arm_expand_prel31 (filedata, word, data_sec->sh_addr + data_offset);
9069 printf (_(" Personality routine: "));
9070 if (fn == 0
9071 && addr.section == SHN_UNDEF && addr.offset == 0
9072 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
9073 {
9074 procname = aux->strtab + sym_name;
9075 print_vma (fn, PREFIX_HEX);
9076 if (procname)
9077 {
9078 fputs (" <", stdout);
9079 fputs (procname, stdout);
9080 fputc ('>', stdout);
9081 }
9082 }
9083 else
9084 procname = arm_print_vma_and_name (filedata, aux, fn, addr);
9085 fputc ('\n', stdout);
9086
9087 /* The GCC personality routines use the standard compact
9088 encoding, starting with one byte giving the number of
9089 words. */
9090 if (procname != NULL
9091 && (const_strneq (procname, "__gcc_personality_v0")
9092 || const_strneq (procname, "__gxx_personality_v0")
9093 || const_strneq (procname, "__gcj_personality_v0")
9094 || const_strneq (procname, "__gnu_objc_personality_v0")))
9095 {
9096 remaining = 0;
9097 more_words = 1;
9098 ADVANCE;
9099 if (!remaining)
9100 {
9101 printf (_(" [Truncated data]\n"));
9102 return FALSE;
9103 }
9104 more_words = word >> 24;
9105 word <<= 8;
9106 remaining--;
9107 per_index = -1;
9108 }
9109 else
9110 return TRUE;
9111 }
9112 else
9113 {
9114 /* ARM EHABI Section 6.3:
9115
9116 An exception-handling table entry for the compact model looks like:
9117
9118 31 30-28 27-24 23-0
9119 -- ----- ----- ----
9120 1 0 index Data for personalityRoutine[index] */
9121
9122 if (filedata->file_header.e_machine == EM_ARM
9123 && (word & 0x70000000))
9124 {
9125 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
9126 res = FALSE;
9127 }
9128
9129 per_index = (word >> 24) & 0x7f;
9130 printf (_(" Compact model index: %d\n"), per_index);
9131 if (per_index == 0)
9132 {
9133 more_words = 0;
9134 word <<= 8;
9135 remaining--;
9136 }
9137 else if (per_index < 3)
9138 {
9139 more_words = (word >> 16) & 0xff;
9140 word <<= 16;
9141 remaining -= 2;
9142 }
9143 }
9144
9145 switch (filedata->file_header.e_machine)
9146 {
9147 case EM_ARM:
9148 if (per_index < 3)
9149 {
9150 if (! decode_arm_unwind_bytecode (filedata, aux, word, remaining, more_words,
9151 data_offset, data_sec, data_arm_sec))
9152 res = FALSE;
9153 }
9154 else
9155 {
9156 warn (_("Unknown ARM compact model index encountered\n"));
9157 printf (_(" [reserved]\n"));
9158 res = FALSE;
9159 }
9160 break;
9161
9162 case EM_TI_C6000:
9163 if (per_index < 3)
9164 {
9165 if (! decode_tic6x_unwind_bytecode (filedata, aux, word, remaining, more_words,
9166 data_offset, data_sec, data_arm_sec))
9167 res = FALSE;
9168 }
9169 else if (per_index < 5)
9170 {
9171 if (((word >> 17) & 0x7f) == 0x7f)
9172 printf (_(" Restore stack from frame pointer\n"));
9173 else
9174 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
9175 printf (_(" Registers restored: "));
9176 if (per_index == 4)
9177 printf (" (compact) ");
9178 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
9179 putchar ('\n');
9180 printf (_(" Return register: %s\n"),
9181 tic6x_unwind_regnames[word & 0xf]);
9182 }
9183 else
9184 printf (_(" [reserved (%d)]\n"), per_index);
9185 break;
9186
9187 default:
9188 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9189 filedata->file_header.e_machine);
9190 res = FALSE;
9191 }
9192
9193 /* Decode the descriptors. Not implemented. */
9194
9195 return res;
9196}
9197
9198static bfd_boolean
9199dump_arm_unwind (Filedata * filedata,
9200 struct arm_unw_aux_info * aux,
9201 Elf_Internal_Shdr * exidx_sec)
9202{
9203 struct arm_section exidx_arm_sec, extab_arm_sec;
9204 unsigned int i, exidx_len;
9205 unsigned long j, nfuns;
9206 bfd_boolean res = TRUE;
9207
9208 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
9209 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
9210 exidx_len = exidx_sec->sh_size / 8;
9211
9212 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
9213 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
9214 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
9215 aux->funtab[nfuns++] = aux->symtab[j];
9216 aux->nfuns = nfuns;
9217 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
9218
9219 for (i = 0; i < exidx_len; i++)
9220 {
9221 unsigned int exidx_fn, exidx_entry;
9222 struct absaddr fn_addr, entry_addr;
9223 bfd_vma fn;
9224
9225 fputc ('\n', stdout);
9226
9227 if (! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9228 8 * i, & exidx_fn, & fn_addr, NULL)
9229 || ! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9230 8 * i + 4, & exidx_entry, & entry_addr, NULL))
9231 {
9232 free (aux->funtab);
9233 arm_free_section (& exidx_arm_sec);
9234 arm_free_section (& extab_arm_sec);
9235 return FALSE;
9236 }
9237
9238 /* ARM EHABI, Section 5:
9239 An index table entry consists of 2 words.
9240 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9241 if (exidx_fn & 0x80000000)
9242 {
9243 warn (_("corrupt index table entry: %x\n"), exidx_fn);
9244 res = FALSE;
9245 }
9246
9247 fn = arm_expand_prel31 (filedata, exidx_fn, exidx_sec->sh_addr + 8 * i);
9248
9249 arm_print_vma_and_name (filedata, aux, fn, fn_addr);
9250 fputs (": ", stdout);
9251
9252 if (exidx_entry == 1)
9253 {
9254 print_vma (exidx_entry, PREFIX_HEX);
9255 fputs (" [cantunwind]\n", stdout);
9256 }
9257 else if (exidx_entry & 0x80000000)
9258 {
9259 print_vma (exidx_entry, PREFIX_HEX);
9260 fputc ('\n', stdout);
9261 decode_arm_unwind (filedata, aux, exidx_entry, 4, 0, NULL, NULL);
9262 }
9263 else
9264 {
9265 bfd_vma table, table_offset = 0;
9266 Elf_Internal_Shdr *table_sec;
9267
9268 fputs ("@", stdout);
9269 table = arm_expand_prel31 (filedata, exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
9270 print_vma (table, PREFIX_HEX);
9271 printf ("\n");
9272
9273 /* Locate the matching .ARM.extab. */
9274 if (entry_addr.section != SHN_UNDEF
9275 && entry_addr.section < filedata->file_header.e_shnum)
9276 {
9277 table_sec = filedata->section_headers + entry_addr.section;
9278 table_offset = entry_addr.offset;
9279 /* PR 18879 */
9280 if (table_offset > table_sec->sh_size
9281 || ((bfd_signed_vma) table_offset) < 0)
9282 {
9283 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9284 (unsigned long) table_offset,
9285 printable_section_name (filedata, table_sec));
9286 res = FALSE;
9287 continue;
9288 }
9289 }
9290 else
9291 {
9292 table_sec = find_section_by_address (filedata, table);
9293 if (table_sec != NULL)
9294 table_offset = table - table_sec->sh_addr;
9295 }
9296
9297 if (table_sec == NULL)
9298 {
9299 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9300 (unsigned long) table);
9301 res = FALSE;
9302 continue;
9303 }
9304
9305 if (! decode_arm_unwind (filedata, aux, 0, 0, table_offset, table_sec,
9306 &extab_arm_sec))
9307 res = FALSE;
9308 }
9309 }
9310
9311 printf ("\n");
9312
9313 free (aux->funtab);
9314 arm_free_section (&exidx_arm_sec);
9315 arm_free_section (&extab_arm_sec);
9316
9317 return res;
9318}
9319
9320/* Used for both ARM and C6X unwinding tables. */
9321
9322static bfd_boolean
9323arm_process_unwind (Filedata * filedata)
9324{
9325 struct arm_unw_aux_info aux;
9326 Elf_Internal_Shdr *unwsec = NULL;
9327 Elf_Internal_Shdr *strsec;
9328 Elf_Internal_Shdr *sec;
9329 unsigned long i;
9330 unsigned int sec_type;
9331 bfd_boolean res = TRUE;
9332
9333 switch (filedata->file_header.e_machine)
9334 {
9335 case EM_ARM:
9336 sec_type = SHT_ARM_EXIDX;
9337 break;
9338
9339 case EM_TI_C6000:
9340 sec_type = SHT_C6000_UNWIND;
9341 break;
9342
9343 default:
9344 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9345 filedata->file_header.e_machine);
9346 return FALSE;
9347 }
9348
9349 if (filedata->string_table == NULL)
9350 return FALSE;
9351
9352 memset (& aux, 0, sizeof (aux));
9353 aux.filedata = filedata;
9354
9355 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9356 {
9357 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < filedata->file_header.e_shnum)
9358 {
9359 aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
9360
9361 strsec = filedata->section_headers + sec->sh_link;
9362
9363 /* PR binutils/17531 file: 011-12666-0.004. */
9364 if (aux.strtab != NULL)
9365 {
9366 error (_("Multiple string tables found in file.\n"));
9367 free (aux.strtab);
9368 res = FALSE;
9369 }
9370 aux.strtab = get_data (NULL, filedata, strsec->sh_offset,
9371 1, strsec->sh_size, _("string table"));
9372 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9373 }
9374 else if (sec->sh_type == sec_type)
9375 unwsec = sec;
9376 }
9377
9378 if (unwsec == NULL)
9379 printf (_("\nThere are no unwind sections in this file.\n"));
9380 else
9381 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9382 {
9383 if (sec->sh_type == sec_type)
9384 {
9385 unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size);
9386 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9387 "contains %lu entry:\n",
9388 "\nUnwind section '%s' at offset 0x%lx "
9389 "contains %lu entries:\n",
9390 num_unwind),
9391 printable_section_name (filedata, sec),
9392 (unsigned long) sec->sh_offset,
9393 num_unwind);
9394
9395 if (! dump_arm_unwind (filedata, &aux, sec))
9396 res = FALSE;
9397 }
9398 }
9399
9400 if (aux.symtab)
9401 free (aux.symtab);
9402 if (aux.strtab)
9403 free ((char *) aux.strtab);
9404
9405 return res;
9406}
9407
9408static bfd_boolean
9409process_unwind (Filedata * filedata)
9410{
9411 struct unwind_handler
9412 {
9413 unsigned int machtype;
9414 bfd_boolean (* handler)(Filedata *);
9415 } handlers[] =
9416 {
9417 { EM_ARM, arm_process_unwind },
9418 { EM_IA_64, ia64_process_unwind },
9419 { EM_PARISC, hppa_process_unwind },
9420 { EM_TI_C6000, arm_process_unwind },
9421 { 0, NULL }
9422 };
9423 int i;
9424
9425 if (!do_unwind)
9426 return TRUE;
9427
9428 for (i = 0; handlers[i].handler != NULL; i++)
9429 if (filedata->file_header.e_machine == handlers[i].machtype)
9430 return handlers[i].handler (filedata);
9431
9432 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9433 get_machine_name (filedata->file_header.e_machine));
9434 return TRUE;
9435}
9436
9437static void
9438dynamic_section_aarch64_val (Elf_Internal_Dyn * entry)
9439{
9440 switch (entry->d_tag)
9441 {
9442 case DT_AARCH64_BTI_PLT:
9443 case DT_AARCH64_PAC_PLT:
9444 break;
9445 default:
9446 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9447 break;
9448 }
9449 putchar ('\n');
9450}
9451
9452static void
9453dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9454{
9455 switch (entry->d_tag)
9456 {
9457 case DT_MIPS_FLAGS:
9458 if (entry->d_un.d_val == 0)
9459 printf (_("NONE"));
9460 else
9461 {
9462 static const char * opts[] =
9463 {
9464 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9465 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9466 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9467 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9468 "RLD_ORDER_SAFE"
9469 };
9470 unsigned int cnt;
9471 bfd_boolean first = TRUE;
9472
9473 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9474 if (entry->d_un.d_val & (1 << cnt))
9475 {
9476 printf ("%s%s", first ? "" : " ", opts[cnt]);
9477 first = FALSE;
9478 }
9479 }
9480 break;
9481
9482 case DT_MIPS_IVERSION:
9483 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9484 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9485 else
9486 {
9487 char buf[40];
9488 sprintf_vma (buf, entry->d_un.d_ptr);
9489 /* Note: coded this way so that there is a single string for translation. */
9490 printf (_("<corrupt: %s>"), buf);
9491 }
9492 break;
9493
9494 case DT_MIPS_TIME_STAMP:
9495 {
9496 char timebuf[128];
9497 struct tm * tmp;
9498 time_t atime = entry->d_un.d_val;
9499
9500 tmp = gmtime (&atime);
9501 /* PR 17531: file: 6accc532. */
9502 if (tmp == NULL)
9503 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9504 else
9505 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9506 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9507 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9508 printf (_("Time Stamp: %s"), timebuf);
9509 }
9510 break;
9511
9512 case DT_MIPS_RLD_VERSION:
9513 case DT_MIPS_LOCAL_GOTNO:
9514 case DT_MIPS_CONFLICTNO:
9515 case DT_MIPS_LIBLISTNO:
9516 case DT_MIPS_SYMTABNO:
9517 case DT_MIPS_UNREFEXTNO:
9518 case DT_MIPS_HIPAGENO:
9519 case DT_MIPS_DELTA_CLASS_NO:
9520 case DT_MIPS_DELTA_INSTANCE_NO:
9521 case DT_MIPS_DELTA_RELOC_NO:
9522 case DT_MIPS_DELTA_SYM_NO:
9523 case DT_MIPS_DELTA_CLASSSYM_NO:
9524 case DT_MIPS_COMPACT_SIZE:
9525 print_vma (entry->d_un.d_val, DEC);
9526 break;
9527
9528 default:
9529 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9530 }
9531 putchar ('\n');
9532}
9533
9534static void
9535dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9536{
9537 switch (entry->d_tag)
9538 {
9539 case DT_HP_DLD_FLAGS:
9540 {
9541 static struct
9542 {
9543 long int bit;
9544 const char * str;
9545 }
9546 flags[] =
9547 {
9548 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9549 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9550 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9551 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9552 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9553 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9554 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9555 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9556 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9557 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9558 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9559 { DT_HP_GST, "HP_GST" },
9560 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9561 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9562 { DT_HP_NODELETE, "HP_NODELETE" },
9563 { DT_HP_GROUP, "HP_GROUP" },
9564 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9565 };
9566 bfd_boolean first = TRUE;
9567 size_t cnt;
9568 bfd_vma val = entry->d_un.d_val;
9569
9570 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9571 if (val & flags[cnt].bit)
9572 {
9573 if (! first)
9574 putchar (' ');
9575 fputs (flags[cnt].str, stdout);
9576 first = FALSE;
9577 val ^= flags[cnt].bit;
9578 }
9579
9580 if (val != 0 || first)
9581 {
9582 if (! first)
9583 putchar (' ');
9584 print_vma (val, HEX);
9585 }
9586 }
9587 break;
9588
9589 default:
9590 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9591 break;
9592 }
9593 putchar ('\n');
9594}
9595
9596#ifdef BFD64
9597
9598/* VMS vs Unix time offset and factor. */
9599
9600#define VMS_EPOCH_OFFSET 35067168000000000LL
9601#define VMS_GRANULARITY_FACTOR 10000000
9602
9603/* Display a VMS time in a human readable format. */
9604
9605static void
9606print_vms_time (bfd_int64_t vmstime)
9607{
9608 struct tm *tm;
9609 time_t unxtime;
9610
9611 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9612 tm = gmtime (&unxtime);
9613 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9614 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9615 tm->tm_hour, tm->tm_min, tm->tm_sec);
9616}
9617#endif /* BFD64 */
9618
9619static void
9620dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9621{
9622 switch (entry->d_tag)
9623 {
9624 case DT_IA_64_PLT_RESERVE:
9625 /* First 3 slots reserved. */
9626 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9627 printf (" -- ");
9628 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9629 break;
9630
9631 case DT_IA_64_VMS_LINKTIME:
9632#ifdef BFD64
9633 print_vms_time (entry->d_un.d_val);
9634#endif
9635 break;
9636
9637 case DT_IA_64_VMS_LNKFLAGS:
9638 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9639 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9640 printf (" CALL_DEBUG");
9641 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9642 printf (" NOP0BUFS");
9643 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9644 printf (" P0IMAGE");
9645 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9646 printf (" MKTHREADS");
9647 if (entry->d_un.d_val & VMS_LF_UPCALLS)
9648 printf (" UPCALLS");
9649 if (entry->d_un.d_val & VMS_LF_IMGSTA)
9650 printf (" IMGSTA");
9651 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9652 printf (" INITIALIZE");
9653 if (entry->d_un.d_val & VMS_LF_MAIN)
9654 printf (" MAIN");
9655 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9656 printf (" EXE_INIT");
9657 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9658 printf (" TBK_IN_IMG");
9659 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9660 printf (" DBG_IN_IMG");
9661 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9662 printf (" TBK_IN_DSF");
9663 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9664 printf (" DBG_IN_DSF");
9665 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9666 printf (" SIGNATURES");
9667 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9668 printf (" REL_SEG_OFF");
9669 break;
9670
9671 default:
9672 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9673 break;
9674 }
9675 putchar ('\n');
9676}
9677
9678static bfd_boolean
9679get_32bit_dynamic_section (Filedata * filedata)
9680{
9681 Elf32_External_Dyn * edyn;
9682 Elf32_External_Dyn * ext;
9683 Elf_Internal_Dyn * entry;
9684
9685 edyn = (Elf32_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9686 dynamic_size, _("dynamic section"));
9687 if (!edyn)
9688 return FALSE;
9689
9690 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9691 might not have the luxury of section headers. Look for the DT_NULL
9692 terminator to determine the number of entries. */
9693 for (ext = edyn, dynamic_nent = 0;
9694 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9695 ext++)
9696 {
9697 dynamic_nent++;
9698 if (BYTE_GET (ext->d_tag) == DT_NULL)
9699 break;
9700 }
9701
9702 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9703 sizeof (* entry));
9704 if (dynamic_section == NULL)
9705 {
9706 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9707 (unsigned long) dynamic_nent);
9708 free (edyn);
9709 return FALSE;
9710 }
9711
9712 for (ext = edyn, entry = dynamic_section;
9713 entry < dynamic_section + dynamic_nent;
9714 ext++, entry++)
9715 {
9716 entry->d_tag = BYTE_GET (ext->d_tag);
9717 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9718 }
9719
9720 free (edyn);
9721
9722 return TRUE;
9723}
9724
9725static bfd_boolean
9726get_64bit_dynamic_section (Filedata * filedata)
9727{
9728 Elf64_External_Dyn * edyn;
9729 Elf64_External_Dyn * ext;
9730 Elf_Internal_Dyn * entry;
9731
9732 /* Read in the data. */
9733 edyn = (Elf64_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9734 dynamic_size, _("dynamic section"));
9735 if (!edyn)
9736 return FALSE;
9737
9738 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9739 might not have the luxury of section headers. Look for the DT_NULL
9740 terminator to determine the number of entries. */
9741 for (ext = edyn, dynamic_nent = 0;
9742 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9743 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9744 ext++)
9745 {
9746 dynamic_nent++;
9747 if (BYTE_GET (ext->d_tag) == DT_NULL)
9748 break;
9749 }
9750
9751 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9752 sizeof (* entry));
9753 if (dynamic_section == NULL)
9754 {
9755 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9756 (unsigned long) dynamic_nent);
9757 free (edyn);
9758 return FALSE;
9759 }
9760
9761 /* Convert from external to internal formats. */
9762 for (ext = edyn, entry = dynamic_section;
9763 entry < dynamic_section + dynamic_nent;
9764 ext++, entry++)
9765 {
9766 entry->d_tag = BYTE_GET (ext->d_tag);
9767 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9768 }
9769
9770 free (edyn);
9771
9772 return TRUE;
9773}
9774
9775static void
9776print_dynamic_flags (bfd_vma flags)
9777{
9778 bfd_boolean first = TRUE;
9779
9780 while (flags)
9781 {
9782 bfd_vma flag;
9783
9784 flag = flags & - flags;
9785 flags &= ~ flag;
9786
9787 if (first)
9788 first = FALSE;
9789 else
9790 putc (' ', stdout);
9791
9792 switch (flag)
9793 {
9794 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
9795 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
9796 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
9797 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
9798 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
9799 default: fputs (_("unknown"), stdout); break;
9800 }
9801 }
9802 puts ("");
9803}
9804
9805/* Parse and display the contents of the dynamic section. */
9806
9807static bfd_boolean
9808process_dynamic_section (Filedata * filedata)
9809{
9810 Elf_Internal_Dyn * entry;
9811
9812 if (dynamic_size == 0)
9813 {
9814 if (do_dynamic)
9815 printf (_("\nThere is no dynamic section in this file.\n"));
9816
9817 return TRUE;
9818 }
9819
9820 if (is_32bit_elf)
9821 {
9822 if (! get_32bit_dynamic_section (filedata))
9823 return FALSE;
9824 }
9825 else
9826 {
9827 if (! get_64bit_dynamic_section (filedata))
9828 return FALSE;
9829 }
9830
9831 /* Find the appropriate symbol table. */
9832 if (dynamic_symbols == NULL)
9833 {
9834 for (entry = dynamic_section;
9835 entry < dynamic_section + dynamic_nent;
9836 ++entry)
9837 {
9838 Elf_Internal_Shdr section;
9839
9840 if (entry->d_tag != DT_SYMTAB)
9841 continue;
9842
9843 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9844
9845 /* Since we do not know how big the symbol table is,
9846 we default to reading in the entire file (!) and
9847 processing that. This is overkill, I know, but it
9848 should work. */
9849 section.sh_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9850 if ((bfd_size_type) section.sh_offset > filedata->file_size)
9851 {
9852 /* See PR 21379 for a reproducer. */
9853 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9854 return FALSE;
9855 }
9856
9857 if (archive_file_offset != 0)
9858 section.sh_size = archive_file_size - section.sh_offset;
9859 else
9860 section.sh_size = filedata->file_size - section.sh_offset;
9861
9862 if (is_32bit_elf)
9863 section.sh_entsize = sizeof (Elf32_External_Sym);
9864 else
9865 section.sh_entsize = sizeof (Elf64_External_Sym);
9866 section.sh_name = filedata->string_table_length;
9867
9868 if (dynamic_symbols != NULL)
9869 {
9870 error (_("Multiple dynamic symbol table sections found\n"));
9871 free (dynamic_symbols);
9872 }
9873 dynamic_symbols = GET_ELF_SYMBOLS (filedata, &section, & num_dynamic_syms);
9874 if (num_dynamic_syms < 1)
9875 {
9876 error (_("Unable to determine the number of symbols to load\n"));
9877 continue;
9878 }
9879 }
9880 }
9881
9882 /* Similarly find a string table. */
9883 if (dynamic_strings == NULL)
9884 {
9885 for (entry = dynamic_section;
9886 entry < dynamic_section + dynamic_nent;
9887 ++entry)
9888 {
9889 unsigned long offset;
9890 long str_tab_len;
9891
9892 if (entry->d_tag != DT_STRTAB)
9893 continue;
9894
9895 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9896
9897 /* Since we do not know how big the string table is,
9898 we default to reading in the entire file (!) and
9899 processing that. This is overkill, I know, but it
9900 should work. */
9901
9902 offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9903
9904 if (archive_file_offset != 0)
9905 str_tab_len = archive_file_size - offset;
9906 else
9907 str_tab_len = filedata->file_size - offset;
9908
9909 if (str_tab_len < 1)
9910 {
9911 error
9912 (_("Unable to determine the length of the dynamic string table\n"));
9913 continue;
9914 }
9915
9916 if (dynamic_strings != NULL)
9917 {
9918 error (_("Multiple dynamic string tables found\n"));
9919 free (dynamic_strings);
9920 }
9921
9922 dynamic_strings = (char *) get_data (NULL, filedata, offset, 1,
9923 str_tab_len,
9924 _("dynamic string table"));
9925 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9926 }
9927 }
9928
9929 /* And find the syminfo section if available. */
9930 if (dynamic_syminfo == NULL)
9931 {
9932 unsigned long syminsz = 0;
9933
9934 for (entry = dynamic_section;
9935 entry < dynamic_section + dynamic_nent;
9936 ++entry)
9937 {
9938 if (entry->d_tag == DT_SYMINENT)
9939 {
9940 /* Note: these braces are necessary to avoid a syntax
9941 error from the SunOS4 C compiler. */
9942 /* PR binutils/17531: A corrupt file can trigger this test.
9943 So do not use an assert, instead generate an error message. */
9944 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9945 error (_("Bad value (%d) for SYMINENT entry\n"),
9946 (int) entry->d_un.d_val);
9947 }
9948 else if (entry->d_tag == DT_SYMINSZ)
9949 syminsz = entry->d_un.d_val;
9950 else if (entry->d_tag == DT_SYMINFO)
9951 dynamic_syminfo_offset = offset_from_vma (filedata, entry->d_un.d_val,
9952 syminsz);
9953 }
9954
9955 if (dynamic_syminfo_offset != 0 && syminsz != 0)
9956 {
9957 Elf_External_Syminfo * extsyminfo;
9958 Elf_External_Syminfo * extsym;
9959 Elf_Internal_Syminfo * syminfo;
9960
9961 /* There is a syminfo section. Read the data. */
9962 extsyminfo = (Elf_External_Syminfo *)
9963 get_data (NULL, filedata, dynamic_syminfo_offset, 1, syminsz,
9964 _("symbol information"));
9965 if (!extsyminfo)
9966 return FALSE;
9967
9968 if (dynamic_syminfo != NULL)
9969 {
9970 error (_("Multiple dynamic symbol information sections found\n"));
9971 free (dynamic_syminfo);
9972 }
9973 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9974 if (dynamic_syminfo == NULL)
9975 {
9976 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9977 (unsigned long) syminsz);
9978 return FALSE;
9979 }
9980
9981 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9982 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9983 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9984 ++syminfo, ++extsym)
9985 {
9986 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9987 syminfo->si_flags = BYTE_GET (extsym->si_flags);
9988 }
9989
9990 free (extsyminfo);
9991 }
9992 }
9993
9994 if (do_dynamic && dynamic_addr)
9995 printf (ngettext ("\nDynamic section at offset 0x%lx "
9996 "contains %lu entry:\n",
9997 "\nDynamic section at offset 0x%lx "
9998 "contains %lu entries:\n",
9999 dynamic_nent),
10000 dynamic_addr, (unsigned long) dynamic_nent);
10001 if (do_dynamic)
10002 printf (_(" Tag Type Name/Value\n"));
10003
10004 for (entry = dynamic_section;
10005 entry < dynamic_section + dynamic_nent;
10006 entry++)
10007 {
10008 if (do_dynamic)
10009 {
10010 const char * dtype;
10011
10012 putchar (' ');
10013 print_vma (entry->d_tag, FULL_HEX);
10014 dtype = get_dynamic_type (filedata, entry->d_tag);
10015 printf (" (%s)%*s", dtype,
10016 ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
10017 }
10018
10019 switch (entry->d_tag)
10020 {
10021 case DT_FLAGS:
10022 if (do_dynamic)
10023 print_dynamic_flags (entry->d_un.d_val);
10024 break;
10025
10026 case DT_AUXILIARY:
10027 case DT_FILTER:
10028 case DT_CONFIG:
10029 case DT_DEPAUDIT:
10030 case DT_AUDIT:
10031 if (do_dynamic)
10032 {
10033 switch (entry->d_tag)
10034 {
10035 case DT_AUXILIARY:
10036 printf (_("Auxiliary library"));
10037 break;
10038
10039 case DT_FILTER:
10040 printf (_("Filter library"));
10041 break;
10042
10043 case DT_CONFIG:
10044 printf (_("Configuration file"));
10045 break;
10046
10047 case DT_DEPAUDIT:
10048 printf (_("Dependency audit library"));
10049 break;
10050
10051 case DT_AUDIT:
10052 printf (_("Audit library"));
10053 break;
10054 }
10055
10056 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10057 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
10058 else
10059 {
10060 printf (": ");
10061 print_vma (entry->d_un.d_val, PREFIX_HEX);
10062 putchar ('\n');
10063 }
10064 }
10065 break;
10066
10067 case DT_FEATURE:
10068 if (do_dynamic)
10069 {
10070 printf (_("Flags:"));
10071
10072 if (entry->d_un.d_val == 0)
10073 printf (_(" None\n"));
10074 else
10075 {
10076 unsigned long int val = entry->d_un.d_val;
10077
10078 if (val & DTF_1_PARINIT)
10079 {
10080 printf (" PARINIT");
10081 val ^= DTF_1_PARINIT;
10082 }
10083 if (val & DTF_1_CONFEXP)
10084 {
10085 printf (" CONFEXP");
10086 val ^= DTF_1_CONFEXP;
10087 }
10088 if (val != 0)
10089 printf (" %lx", val);
10090 puts ("");
10091 }
10092 }
10093 break;
10094
10095 case DT_POSFLAG_1:
10096 if (do_dynamic)
10097 {
10098 printf (_("Flags:"));
10099
10100 if (entry->d_un.d_val == 0)
10101 printf (_(" None\n"));
10102 else
10103 {
10104 unsigned long int val = entry->d_un.d_val;
10105
10106 if (val & DF_P1_LAZYLOAD)
10107 {
10108 printf (" LAZYLOAD");
10109 val ^= DF_P1_LAZYLOAD;
10110 }
10111 if (val & DF_P1_GROUPPERM)
10112 {
10113 printf (" GROUPPERM");
10114 val ^= DF_P1_GROUPPERM;
10115 }
10116 if (val != 0)
10117 printf (" %lx", val);
10118 puts ("");
10119 }
10120 }
10121 break;
10122
10123 case DT_FLAGS_1:
10124 if (do_dynamic)
10125 {
10126 printf (_("Flags:"));
10127 if (entry->d_un.d_val == 0)
10128 printf (_(" None\n"));
10129 else
10130 {
10131 unsigned long int val = entry->d_un.d_val;
10132
10133 if (val & DF_1_NOW)
10134 {
10135 printf (" NOW");
10136 val ^= DF_1_NOW;
10137 }
10138 if (val & DF_1_GLOBAL)
10139 {
10140 printf (" GLOBAL");
10141 val ^= DF_1_GLOBAL;
10142 }
10143 if (val & DF_1_GROUP)
10144 {
10145 printf (" GROUP");
10146 val ^= DF_1_GROUP;
10147 }
10148 if (val & DF_1_NODELETE)
10149 {
10150 printf (" NODELETE");
10151 val ^= DF_1_NODELETE;
10152 }
10153 if (val & DF_1_LOADFLTR)
10154 {
10155 printf (" LOADFLTR");
10156 val ^= DF_1_LOADFLTR;
10157 }
10158 if (val & DF_1_INITFIRST)
10159 {
10160 printf (" INITFIRST");
10161 val ^= DF_1_INITFIRST;
10162 }
10163 if (val & DF_1_NOOPEN)
10164 {
10165 printf (" NOOPEN");
10166 val ^= DF_1_NOOPEN;
10167 }
10168 if (val & DF_1_ORIGIN)
10169 {
10170 printf (" ORIGIN");
10171 val ^= DF_1_ORIGIN;
10172 }
10173 if (val & DF_1_DIRECT)
10174 {
10175 printf (" DIRECT");
10176 val ^= DF_1_DIRECT;
10177 }
10178 if (val & DF_1_TRANS)
10179 {
10180 printf (" TRANS");
10181 val ^= DF_1_TRANS;
10182 }
10183 if (val & DF_1_INTERPOSE)
10184 {
10185 printf (" INTERPOSE");
10186 val ^= DF_1_INTERPOSE;
10187 }
10188 if (val & DF_1_NODEFLIB)
10189 {
10190 printf (" NODEFLIB");
10191 val ^= DF_1_NODEFLIB;
10192 }
10193 if (val & DF_1_NODUMP)
10194 {
10195 printf (" NODUMP");
10196 val ^= DF_1_NODUMP;
10197 }
10198 if (val & DF_1_CONFALT)
10199 {
10200 printf (" CONFALT");
10201 val ^= DF_1_CONFALT;
10202 }
10203 if (val & DF_1_ENDFILTEE)
10204 {
10205 printf (" ENDFILTEE");
10206 val ^= DF_1_ENDFILTEE;
10207 }
10208 if (val & DF_1_DISPRELDNE)
10209 {
10210 printf (" DISPRELDNE");
10211 val ^= DF_1_DISPRELDNE;
10212 }
10213 if (val & DF_1_DISPRELPND)
10214 {
10215 printf (" DISPRELPND");
10216 val ^= DF_1_DISPRELPND;
10217 }
10218 if (val & DF_1_NODIRECT)
10219 {
10220 printf (" NODIRECT");
10221 val ^= DF_1_NODIRECT;
10222 }
10223 if (val & DF_1_IGNMULDEF)
10224 {
10225 printf (" IGNMULDEF");
10226 val ^= DF_1_IGNMULDEF;
10227 }
10228 if (val & DF_1_NOKSYMS)
10229 {
10230 printf (" NOKSYMS");
10231 val ^= DF_1_NOKSYMS;
10232 }
10233 if (val & DF_1_NOHDR)
10234 {
10235 printf (" NOHDR");
10236 val ^= DF_1_NOHDR;
10237 }
10238 if (val & DF_1_EDITED)
10239 {
10240 printf (" EDITED");
10241 val ^= DF_1_EDITED;
10242 }
10243 if (val & DF_1_NORELOC)
10244 {
10245 printf (" NORELOC");
10246 val ^= DF_1_NORELOC;
10247 }
10248 if (val & DF_1_SYMINTPOSE)
10249 {
10250 printf (" SYMINTPOSE");
10251 val ^= DF_1_SYMINTPOSE;
10252 }
10253 if (val & DF_1_GLOBAUDIT)
10254 {
10255 printf (" GLOBAUDIT");
10256 val ^= DF_1_GLOBAUDIT;
10257 }
10258 if (val & DF_1_SINGLETON)
10259 {
10260 printf (" SINGLETON");
10261 val ^= DF_1_SINGLETON;
10262 }
10263 if (val & DF_1_STUB)
10264 {
10265 printf (" STUB");
10266 val ^= DF_1_STUB;
10267 }
10268 if (val & DF_1_PIE)
10269 {
10270 printf (" PIE");
10271 val ^= DF_1_PIE;
10272 }
10273 if (val & DF_1_KMOD)
10274 {
10275 printf (" KMOD");
10276 val ^= DF_1_KMOD;
10277 }
10278 if (val & DF_1_WEAKFILTER)
10279 {
10280 printf (" WEAKFILTER");
10281 val ^= DF_1_WEAKFILTER;
10282 }
10283 if (val & DF_1_NOCOMMON)
10284 {
10285 printf (" NOCOMMON");
10286 val ^= DF_1_NOCOMMON;
10287 }
10288 if (val != 0)
10289 printf (" %lx", val);
10290 puts ("");
10291 }
10292 }
10293 break;
10294
10295 case DT_PLTREL:
10296 dynamic_info[entry->d_tag] = entry->d_un.d_val;
10297 if (do_dynamic)
10298 puts (get_dynamic_type (filedata, entry->d_un.d_val));
10299 break;
10300
10301 case DT_NULL :
10302 case DT_NEEDED :
10303 case DT_PLTGOT :
10304 case DT_HASH :
10305 case DT_STRTAB :
10306 case DT_SYMTAB :
10307 case DT_RELA :
10308 case DT_INIT :
10309 case DT_FINI :
10310 case DT_SONAME :
10311 case DT_RPATH :
10312 case DT_SYMBOLIC:
10313 case DT_REL :
10314 case DT_DEBUG :
10315 case DT_TEXTREL :
10316 case DT_JMPREL :
10317 case DT_RUNPATH :
10318 dynamic_info[entry->d_tag] = entry->d_un.d_val;
10319
10320 if (do_dynamic)
10321 {
10322 char * name;
10323
10324 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10325 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10326 else
10327 name = NULL;
10328
10329 if (name)
10330 {
10331 switch (entry->d_tag)
10332 {
10333 case DT_NEEDED:
10334 printf (_("Shared library: [%s]"), name);
10335
10336 if (streq (name, program_interpreter))
10337 printf (_(" program interpreter"));
10338 break;
10339
10340 case DT_SONAME:
10341 printf (_("Library soname: [%s]"), name);
10342 break;
10343
10344 case DT_RPATH:
10345 printf (_("Library rpath: [%s]"), name);
10346 break;
10347
10348 case DT_RUNPATH:
10349 printf (_("Library runpath: [%s]"), name);
10350 break;
10351
10352 default:
10353 print_vma (entry->d_un.d_val, PREFIX_HEX);
10354 break;
10355 }
10356 }
10357 else
10358 print_vma (entry->d_un.d_val, PREFIX_HEX);
10359
10360 putchar ('\n');
10361 }
10362 break;
10363
10364 case DT_PLTRELSZ:
10365 case DT_RELASZ :
10366 case DT_STRSZ :
10367 case DT_RELSZ :
10368 case DT_RELAENT :
10369 case DT_SYMENT :
10370 case DT_RELENT :
10371 dynamic_info[entry->d_tag] = entry->d_un.d_val;
10372 /* Fall through. */
10373 case DT_PLTPADSZ:
10374 case DT_MOVEENT :
10375 case DT_MOVESZ :
10376 case DT_INIT_ARRAYSZ:
10377 case DT_FINI_ARRAYSZ:
10378 case DT_GNU_CONFLICTSZ:
10379 case DT_GNU_LIBLISTSZ:
10380 if (do_dynamic)
10381 {
10382 print_vma (entry->d_un.d_val, UNSIGNED);
10383 printf (_(" (bytes)\n"));
10384 }
10385 break;
10386
10387 case DT_VERDEFNUM:
10388 case DT_VERNEEDNUM:
10389 case DT_RELACOUNT:
10390 case DT_RELCOUNT:
10391 if (do_dynamic)
10392 {
10393 print_vma (entry->d_un.d_val, UNSIGNED);
10394 putchar ('\n');
10395 }
10396 break;
10397
10398 case DT_SYMINSZ:
10399 case DT_SYMINENT:
10400 case DT_SYMINFO:
10401 case DT_USED:
10402 case DT_INIT_ARRAY:
10403 case DT_FINI_ARRAY:
10404 if (do_dynamic)
10405 {
10406 if (entry->d_tag == DT_USED
10407 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
10408 {
10409 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10410
10411 if (*name)
10412 {
10413 printf (_("Not needed object: [%s]\n"), name);
10414 break;
10415 }
10416 }
10417
10418 print_vma (entry->d_un.d_val, PREFIX_HEX);
10419 putchar ('\n');
10420 }
10421 break;
10422
10423 case DT_BIND_NOW:
10424 /* The value of this entry is ignored. */
10425 if (do_dynamic)
10426 putchar ('\n');
10427 break;
10428
10429 case DT_GNU_PRELINKED:
10430 if (do_dynamic)
10431 {
10432 struct tm * tmp;
10433 time_t atime = entry->d_un.d_val;
10434
10435 tmp = gmtime (&atime);
10436 /* PR 17533 file: 041-1244816-0.004. */
10437 if (tmp == NULL)
10438 printf (_("<corrupt time val: %lx"),
10439 (unsigned long) atime);
10440 else
10441 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10442 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10443 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10444
10445 }
10446 break;
10447
10448 case DT_GNU_HASH:
10449 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10450 if (do_dynamic)
10451 {
10452 print_vma (entry->d_un.d_val, PREFIX_HEX);
10453 putchar ('\n');
10454 }
10455 break;
10456
10457 default:
10458 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10459 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10460 entry->d_un.d_val;
10461
10462 if (do_dynamic)
10463 {
10464 switch (filedata->file_header.e_machine)
10465 {
10466 case EM_AARCH64:
10467 dynamic_section_aarch64_val (entry);
10468 break;
10469 case EM_MIPS:
10470 case EM_MIPS_RS3_LE:
10471 dynamic_section_mips_val (entry);
10472 break;
10473 case EM_PARISC:
10474 dynamic_section_parisc_val (entry);
10475 break;
10476 case EM_IA_64:
10477 dynamic_section_ia64_val (entry);
10478 break;
10479 default:
10480 print_vma (entry->d_un.d_val, PREFIX_HEX);
10481 putchar ('\n');
10482 }
10483 }
10484 break;
10485 }
10486 }
10487
10488 return TRUE;
10489}
10490
10491static char *
10492get_ver_flags (unsigned int flags)
10493{
10494 static char buff[128];
10495
10496 buff[0] = 0;
10497
10498 if (flags == 0)
10499 return _("none");
10500
10501 if (flags & VER_FLG_BASE)
10502 strcat (buff, "BASE");
10503
10504 if (flags & VER_FLG_WEAK)
10505 {
10506 if (flags & VER_FLG_BASE)
10507 strcat (buff, " | ");
10508
10509 strcat (buff, "WEAK");
10510 }
10511
10512 if (flags & VER_FLG_INFO)
10513 {
10514 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10515 strcat (buff, " | ");
10516
10517 strcat (buff, "INFO");
10518 }
10519
10520 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10521 {
10522 if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10523 strcat (buff, " | ");
10524
10525 strcat (buff, _("<unknown>"));
10526 }
10527
10528 return buff;
10529}
10530
10531/* Display the contents of the version sections. */
10532
10533static bfd_boolean
10534process_version_sections (Filedata * filedata)
10535{
10536 Elf_Internal_Shdr * section;
10537 unsigned i;
10538 bfd_boolean found = FALSE;
10539
10540 if (! do_version)
10541 return TRUE;
10542
10543 for (i = 0, section = filedata->section_headers;
10544 i < filedata->file_header.e_shnum;
10545 i++, section++)
10546 {
10547 switch (section->sh_type)
10548 {
10549 case SHT_GNU_verdef:
10550 {
10551 Elf_External_Verdef * edefs;
10552 unsigned long idx;
10553 unsigned long cnt;
10554 char * endbuf;
10555
10556 found = TRUE;
10557
10558 printf (ngettext ("\nVersion definition section '%s' "
10559 "contains %u entry:\n",
10560 "\nVersion definition section '%s' "
10561 "contains %u entries:\n",
10562 section->sh_info),
10563 printable_section_name (filedata, section),
10564 section->sh_info);
10565
10566 printf (_(" Addr: 0x"));
10567 printf_vma (section->sh_addr);
10568 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10569 (unsigned long) section->sh_offset, section->sh_link,
10570 printable_section_name_from_index (filedata, section->sh_link));
10571
10572 edefs = (Elf_External_Verdef *)
10573 get_data (NULL, filedata, section->sh_offset, 1,section->sh_size,
10574 _("version definition section"));
10575 if (!edefs)
10576 break;
10577 endbuf = (char *) edefs + section->sh_size;
10578
10579 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10580 {
10581 char * vstart;
10582 Elf_External_Verdef * edef;
10583 Elf_Internal_Verdef ent;
10584 Elf_External_Verdaux * eaux;
10585 Elf_Internal_Verdaux aux;
10586 unsigned long isum;
10587 int j;
10588
10589 vstart = ((char *) edefs) + idx;
10590 if (vstart + sizeof (*edef) > endbuf)
10591 break;
10592
10593 edef = (Elf_External_Verdef *) vstart;
10594
10595 ent.vd_version = BYTE_GET (edef->vd_version);
10596 ent.vd_flags = BYTE_GET (edef->vd_flags);
10597 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
10598 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
10599 ent.vd_hash = BYTE_GET (edef->vd_hash);
10600 ent.vd_aux = BYTE_GET (edef->vd_aux);
10601 ent.vd_next = BYTE_GET (edef->vd_next);
10602
10603 printf (_(" %#06lx: Rev: %d Flags: %s"),
10604 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10605
10606 printf (_(" Index: %d Cnt: %d "),
10607 ent.vd_ndx, ent.vd_cnt);
10608
10609 /* Check for overflow. */
10610 if (ent.vd_aux > (size_t) (endbuf - vstart))
10611 break;
10612
10613 vstart += ent.vd_aux;
10614
10615 if (vstart + sizeof (*eaux) > endbuf)
10616 break;
10617 eaux = (Elf_External_Verdaux *) vstart;
10618
10619 aux.vda_name = BYTE_GET (eaux->vda_name);
10620 aux.vda_next = BYTE_GET (eaux->vda_next);
10621
10622 if (VALID_DYNAMIC_NAME (aux.vda_name))
10623 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10624 else
10625 printf (_("Name index: %ld\n"), aux.vda_name);
10626
10627 isum = idx + ent.vd_aux;
10628
10629 for (j = 1; j < ent.vd_cnt; j++)
10630 {
10631 if (aux.vda_next < sizeof (*eaux)
10632 && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
10633 {
10634 warn (_("Invalid vda_next field of %lx\n"),
10635 aux.vda_next);
10636 j = ent.vd_cnt;
10637 break;
10638 }
10639 /* Check for overflow. */
10640 if (aux.vda_next > (size_t) (endbuf - vstart))
10641 break;
10642
10643 isum += aux.vda_next;
10644 vstart += aux.vda_next;
10645
10646 if (vstart + sizeof (*eaux) > endbuf)
10647 break;
10648 eaux = (Elf_External_Verdaux *) vstart;
10649
10650 aux.vda_name = BYTE_GET (eaux->vda_name);
10651 aux.vda_next = BYTE_GET (eaux->vda_next);
10652
10653 if (VALID_DYNAMIC_NAME (aux.vda_name))
10654 printf (_(" %#06lx: Parent %d: %s\n"),
10655 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10656 else
10657 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10658 isum, j, aux.vda_name);
10659 }
10660
10661 if (j < ent.vd_cnt)
10662 printf (_(" Version def aux past end of section\n"));
10663
10664 /* PR 17531:
10665 file: id:000001,src:000172+005151,op:splice,rep:2. */
10666 if (ent.vd_next < sizeof (*edef)
10667 && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
10668 {
10669 warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
10670 cnt = section->sh_info;
10671 break;
10672 }
10673 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
10674 break;
10675
10676 idx += ent.vd_next;
10677 }
10678
10679 if (cnt < section->sh_info)
10680 printf (_(" Version definition past end of section\n"));
10681
10682 free (edefs);
10683 }
10684 break;
10685
10686 case SHT_GNU_verneed:
10687 {
10688 Elf_External_Verneed * eneed;
10689 unsigned long idx;
10690 unsigned long cnt;
10691 char * endbuf;
10692
10693 found = TRUE;
10694
10695 printf (ngettext ("\nVersion needs section '%s' "
10696 "contains %u entry:\n",
10697 "\nVersion needs section '%s' "
10698 "contains %u entries:\n",
10699 section->sh_info),
10700 printable_section_name (filedata, section), section->sh_info);
10701
10702 printf (_(" Addr: 0x"));
10703 printf_vma (section->sh_addr);
10704 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10705 (unsigned long) section->sh_offset, section->sh_link,
10706 printable_section_name_from_index (filedata, section->sh_link));
10707
10708 eneed = (Elf_External_Verneed *) get_data (NULL, filedata,
10709 section->sh_offset, 1,
10710 section->sh_size,
10711 _("Version Needs section"));
10712 if (!eneed)
10713 break;
10714 endbuf = (char *) eneed + section->sh_size;
10715
10716 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10717 {
10718 Elf_External_Verneed * entry;
10719 Elf_Internal_Verneed ent;
10720 unsigned long isum;
10721 int j;
10722 char * vstart;
10723
10724 vstart = ((char *) eneed) + idx;
10725 if (vstart + sizeof (*entry) > endbuf)
10726 break;
10727
10728 entry = (Elf_External_Verneed *) vstart;
10729
10730 ent.vn_version = BYTE_GET (entry->vn_version);
10731 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
10732 ent.vn_file = BYTE_GET (entry->vn_file);
10733 ent.vn_aux = BYTE_GET (entry->vn_aux);
10734 ent.vn_next = BYTE_GET (entry->vn_next);
10735
10736 printf (_(" %#06lx: Version: %d"), idx, ent.vn_version);
10737
10738 if (VALID_DYNAMIC_NAME (ent.vn_file))
10739 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10740 else
10741 printf (_(" File: %lx"), ent.vn_file);
10742
10743 printf (_(" Cnt: %d\n"), ent.vn_cnt);
10744
10745 /* Check for overflow. */
10746 if (ent.vn_aux > (size_t) (endbuf - vstart))
10747 break;
10748 vstart += ent.vn_aux;
10749
10750 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10751 {
10752 Elf_External_Vernaux * eaux;
10753 Elf_Internal_Vernaux aux;
10754
10755 if (vstart + sizeof (*eaux) > endbuf)
10756 break;
10757 eaux = (Elf_External_Vernaux *) vstart;
10758
10759 aux.vna_hash = BYTE_GET (eaux->vna_hash);
10760 aux.vna_flags = BYTE_GET (eaux->vna_flags);
10761 aux.vna_other = BYTE_GET (eaux->vna_other);
10762 aux.vna_name = BYTE_GET (eaux->vna_name);
10763 aux.vna_next = BYTE_GET (eaux->vna_next);
10764
10765 if (VALID_DYNAMIC_NAME (aux.vna_name))
10766 printf (_(" %#06lx: Name: %s"),
10767 isum, GET_DYNAMIC_NAME (aux.vna_name));
10768 else
10769 printf (_(" %#06lx: Name index: %lx"),
10770 isum, aux.vna_name);
10771
10772 printf (_(" Flags: %s Version: %d\n"),
10773 get_ver_flags (aux.vna_flags), aux.vna_other);
10774
10775 if (aux.vna_next < sizeof (*eaux)
10776 && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
10777 {
10778 warn (_("Invalid vna_next field of %lx\n"),
10779 aux.vna_next);
10780 j = ent.vn_cnt;
10781 break;
10782 }
10783 /* Check for overflow. */
10784 if (aux.vna_next > (size_t) (endbuf - vstart))
10785 break;
10786 isum += aux.vna_next;
10787 vstart += aux.vna_next;
10788 }
10789
10790 if (j < ent.vn_cnt)
10791 warn (_("Missing Version Needs auxillary information\n"));
10792
10793 if (ent.vn_next < sizeof (*entry)
10794 && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
10795 {
10796 warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
10797 cnt = section->sh_info;
10798 break;
10799 }
10800 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
10801 break;
10802 idx += ent.vn_next;
10803 }
10804
10805 if (cnt < section->sh_info)
10806 warn (_("Missing Version Needs information\n"));
10807
10808 free (eneed);
10809 }
10810 break;
10811
10812 case SHT_GNU_versym:
10813 {
10814 Elf_Internal_Shdr * link_section;
10815 size_t total;
10816 unsigned int cnt;
10817 unsigned char * edata;
10818 unsigned short * data;
10819 char * strtab;
10820 Elf_Internal_Sym * symbols;
10821 Elf_Internal_Shdr * string_sec;
10822 unsigned long num_syms;
10823 long off;
10824
10825 if (section->sh_link >= filedata->file_header.e_shnum)
10826 break;
10827
10828 link_section = filedata->section_headers + section->sh_link;
10829 total = section->sh_size / sizeof (Elf_External_Versym);
10830
10831 if (link_section->sh_link >= filedata->file_header.e_shnum)
10832 break;
10833
10834 found = TRUE;
10835
10836 symbols = GET_ELF_SYMBOLS (filedata, link_section, & num_syms);
10837 if (symbols == NULL)
10838 break;
10839
10840 string_sec = filedata->section_headers + link_section->sh_link;
10841
10842 strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
10843 string_sec->sh_size,
10844 _("version string table"));
10845 if (!strtab)
10846 {
10847 free (symbols);
10848 break;
10849 }
10850
10851 printf (ngettext ("\nVersion symbols section '%s' "
10852 "contains %lu entry:\n",
10853 "\nVersion symbols section '%s' "
10854 "contains %lu entries:\n",
10855 total),
10856 printable_section_name (filedata, section), (unsigned long) total);
10857
10858 printf (_(" Addr: 0x"));
10859 printf_vma (section->sh_addr);
10860 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10861 (unsigned long) section->sh_offset, section->sh_link,
10862 printable_section_name (filedata, link_section));
10863
10864 off = offset_from_vma (filedata,
10865 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10866 total * sizeof (short));
10867 edata = (unsigned char *) get_data (NULL, filedata, off, total,
10868 sizeof (short),
10869 _("version symbol data"));
10870 if (!edata)
10871 {
10872 free (strtab);
10873 free (symbols);
10874 break;
10875 }
10876
10877 data = (short unsigned int *) cmalloc (total, sizeof (short));
10878
10879 for (cnt = total; cnt --;)
10880 data[cnt] = byte_get (edata + cnt * sizeof (short),
10881 sizeof (short));
10882
10883 free (edata);
10884
10885 for (cnt = 0; cnt < total; cnt += 4)
10886 {
10887 int j, nn;
10888 char *name;
10889 char *invalid = _("*invalid*");
10890
10891 printf (" %03x:", cnt);
10892
10893 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10894 switch (data[cnt + j])
10895 {
10896 case 0:
10897 fputs (_(" 0 (*local*) "), stdout);
10898 break;
10899
10900 case 1:
10901 fputs (_(" 1 (*global*) "), stdout);
10902 break;
10903
10904 default:
10905 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10906 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10907
10908 /* If this index value is greater than the size of the symbols
10909 array, break to avoid an out-of-bounds read. */
10910 if ((unsigned long)(cnt + j) >= num_syms)
10911 {
10912 warn (_("invalid index into symbol array\n"));
10913 break;
10914 }
10915
10916 name = NULL;
10917 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10918 {
10919 Elf_Internal_Verneed ivn;
10920 unsigned long offset;
10921
10922 offset = offset_from_vma
10923 (filedata, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10924 sizeof (Elf_External_Verneed));
10925
10926 do
10927 {
10928 Elf_Internal_Vernaux ivna;
10929 Elf_External_Verneed evn;
10930 Elf_External_Vernaux evna;
10931 unsigned long a_off;
10932
10933 if (get_data (&evn, filedata, offset, sizeof (evn), 1,
10934 _("version need")) == NULL)
10935 break;
10936
10937 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10938 ivn.vn_next = BYTE_GET (evn.vn_next);
10939
10940 a_off = offset + ivn.vn_aux;
10941
10942 do
10943 {
10944 if (get_data (&evna, filedata, a_off, sizeof (evna),
10945 1, _("version need aux (2)")) == NULL)
10946 {
10947 ivna.vna_next = 0;
10948 ivna.vna_other = 0;
10949 }
10950 else
10951 {
10952 ivna.vna_next = BYTE_GET (evna.vna_next);
10953 ivna.vna_other = BYTE_GET (evna.vna_other);
10954 }
10955
10956 a_off += ivna.vna_next;
10957 }
10958 while (ivna.vna_other != data[cnt + j]
10959 && ivna.vna_next != 0);
10960
10961 if (ivna.vna_other == data[cnt + j])
10962 {
10963 ivna.vna_name = BYTE_GET (evna.vna_name);
10964
10965 if (ivna.vna_name >= string_sec->sh_size)
10966 name = invalid;
10967 else
10968 name = strtab + ivna.vna_name;
10969 break;
10970 }
10971
10972 offset += ivn.vn_next;
10973 }
10974 while (ivn.vn_next);
10975 }
10976
10977 if (data[cnt + j] != 0x8001
10978 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10979 {
10980 Elf_Internal_Verdef ivd;
10981 Elf_External_Verdef evd;
10982 unsigned long offset;
10983
10984 offset = offset_from_vma
10985 (filedata, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10986 sizeof evd);
10987
10988 do
10989 {
10990 if (get_data (&evd, filedata, offset, sizeof (evd), 1,
10991 _("version def")) == NULL)
10992 {
10993 ivd.vd_next = 0;
10994 /* PR 17531: file: 046-1082287-0.004. */
10995 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
10996 break;
10997 }
10998 else
10999 {
11000 ivd.vd_next = BYTE_GET (evd.vd_next);
11001 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11002 }
11003
11004 offset += ivd.vd_next;
11005 }
11006 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
11007 && ivd.vd_next != 0);
11008
11009 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
11010 {
11011 Elf_External_Verdaux evda;
11012 Elf_Internal_Verdaux ivda;
11013
11014 ivd.vd_aux = BYTE_GET (evd.vd_aux);
11015
11016 if (get_data (&evda, filedata,
11017 offset - ivd.vd_next + ivd.vd_aux,
11018 sizeof (evda), 1,
11019 _("version def aux")) == NULL)
11020 break;
11021
11022 ivda.vda_name = BYTE_GET (evda.vda_name);
11023
11024 if (ivda.vda_name >= string_sec->sh_size)
11025 name = invalid;
11026 else if (name != NULL && name != invalid)
11027 name = _("*both*");
11028 else
11029 name = strtab + ivda.vda_name;
11030 }
11031 }
11032 if (name != NULL)
11033 nn += printf ("(%s%-*s",
11034 name,
11035 12 - (int) strlen (name),
11036 ")");
11037
11038 if (nn < 18)
11039 printf ("%*c", 18 - nn, ' ');
11040 }
11041
11042 putchar ('\n');
11043 }
11044
11045 free (data);
11046 free (strtab);
11047 free (symbols);
11048 }
11049 break;
11050
11051 default:
11052 break;
11053 }
11054 }
11055
11056 if (! found)
11057 printf (_("\nNo version information found in this file.\n"));
11058
11059 return TRUE;
11060}
11061
11062static const char *
11063get_symbol_binding (Filedata * filedata, unsigned int binding)
11064{
11065 static char buff[32];
11066
11067 switch (binding)
11068 {
11069 case STB_LOCAL: return "LOCAL";
11070 case STB_GLOBAL: return "GLOBAL";
11071 case STB_WEAK: return "WEAK";
11072 default:
11073 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
11074 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
11075 binding);
11076 else if (binding >= STB_LOOS && binding <= STB_HIOS)
11077 {
11078 if (binding == STB_GNU_UNIQUE
11079 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU)
11080 return "UNIQUE";
11081 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
11082 }
11083 else
11084 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
11085 return buff;
11086 }
11087}
11088
11089static const char *
11090get_symbol_type (Filedata * filedata, unsigned int type)
11091{
11092 static char buff[32];
11093
11094 switch (type)
11095 {
11096 case STT_NOTYPE: return "NOTYPE";
11097 case STT_OBJECT: return "OBJECT";
11098 case STT_FUNC: return "FUNC";
11099 case STT_SECTION: return "SECTION";
11100 case STT_FILE: return "FILE";
11101 case STT_COMMON: return "COMMON";
11102 case STT_TLS: return "TLS";
11103 case STT_RELC: return "RELC";
11104 case STT_SRELC: return "SRELC";
11105 default:
11106 if (type >= STT_LOPROC && type <= STT_HIPROC)
11107 {
11108 if (filedata->file_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
11109 return "THUMB_FUNC";
11110
11111 if (filedata->file_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
11112 return "REGISTER";
11113
11114 if (filedata->file_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
11115 return "PARISC_MILLI";
11116
11117 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
11118 }
11119 else if (type >= STT_LOOS && type <= STT_HIOS)
11120 {
11121 if (filedata->file_header.e_machine == EM_PARISC)
11122 {
11123 if (type == STT_HP_OPAQUE)
11124 return "HP_OPAQUE";
11125 if (type == STT_HP_STUB)
11126 return "HP_STUB";
11127 }
11128
11129 if (type == STT_GNU_IFUNC
11130 && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
11131 || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD))
11132 return "IFUNC";
11133
11134 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
11135 }
11136 else
11137 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
11138 return buff;
11139 }
11140}
11141
11142static const char *
11143get_symbol_visibility (unsigned int visibility)
11144{
11145 switch (visibility)
11146 {
11147 case STV_DEFAULT: return "DEFAULT";
11148 case STV_INTERNAL: return "INTERNAL";
11149 case STV_HIDDEN: return "HIDDEN";
11150 case STV_PROTECTED: return "PROTECTED";
11151 default:
11152 error (_("Unrecognized visibility value: %u"), visibility);
11153 return _("<unknown>");
11154 }
11155}
11156
11157static const char *
11158get_alpha_symbol_other (unsigned int other)
11159{
11160 switch (other)
11161 {
11162 case STO_ALPHA_NOPV: return "NOPV";
11163 case STO_ALPHA_STD_GPLOAD: return "STD GPLOAD";
11164 default:
11165 error (_("Unrecognized alpah specific other value: %u"), other);
11166 return _("<unknown>");
11167 }
11168}
11169
11170static const char *
11171get_solaris_symbol_visibility (unsigned int visibility)
11172{
11173 switch (visibility)
11174 {
11175 case 4: return "EXPORTED";
11176 case 5: return "SINGLETON";
11177 case 6: return "ELIMINATE";
11178 default: return get_symbol_visibility (visibility);
11179 }
11180}
11181
11182static const char *
11183get_aarch64_symbol_other (unsigned int other)
11184{
11185 static char buf[32];
11186
11187 if (other & STO_AARCH64_VARIANT_PCS)
11188 {
11189 other &= ~STO_AARCH64_VARIANT_PCS;
11190 if (other == 0)
11191 return "VARIANT_PCS";
11192 snprintf (buf, sizeof buf, "VARIANT_PCS | %x", other);
11193 return buf;
11194 }
11195 return NULL;
11196}
11197
11198static const char *
11199get_mips_symbol_other (unsigned int other)
11200{
11201 switch (other)
11202 {
11203 case STO_OPTIONAL: return "OPTIONAL";
11204 case STO_MIPS_PLT: return "MIPS PLT";
11205 case STO_MIPS_PIC: return "MIPS PIC";
11206 case STO_MICROMIPS: return "MICROMIPS";
11207 case STO_MICROMIPS | STO_MIPS_PIC: return "MICROMIPS, MIPS PIC";
11208 case STO_MIPS16: return "MIPS16";
11209 default: return NULL;
11210 }
11211}
11212
11213static const char *
11214get_ia64_symbol_other (Filedata * filedata, unsigned int other)
11215{
11216 if (is_ia64_vms (filedata))
11217 {
11218 static char res[32];
11219
11220 res[0] = 0;
11221
11222 /* Function types is for images and .STB files only. */
11223 switch (filedata->file_header.e_type)
11224 {
11225 case ET_DYN:
11226 case ET_EXEC:
11227 switch (VMS_ST_FUNC_TYPE (other))
11228 {
11229 case VMS_SFT_CODE_ADDR:
11230 strcat (res, " CA");
11231 break;
11232 case VMS_SFT_SYMV_IDX:
11233 strcat (res, " VEC");
11234 break;
11235 case VMS_SFT_FD:
11236 strcat (res, " FD");
11237 break;
11238 case VMS_SFT_RESERVE:
11239 strcat (res, " RSV");
11240 break;
11241 default:
11242 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11243 VMS_ST_FUNC_TYPE (other));
11244 strcat (res, " <unknown>");
11245 break;
11246 }
11247 break;
11248 default:
11249 break;
11250 }
11251 switch (VMS_ST_LINKAGE (other))
11252 {
11253 case VMS_STL_IGNORE:
11254 strcat (res, " IGN");
11255 break;
11256 case VMS_STL_RESERVE:
11257 strcat (res, " RSV");
11258 break;
11259 case VMS_STL_STD:
11260 strcat (res, " STD");
11261 break;
11262 case VMS_STL_LNK:
11263 strcat (res, " LNK");
11264 break;
11265 default:
11266 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11267 VMS_ST_LINKAGE (other));
11268 strcat (res, " <unknown>");
11269 break;
11270 }
11271
11272 if (res[0] != 0)
11273 return res + 1;
11274 else
11275 return res;
11276 }
11277 return NULL;
11278}
11279
11280static const char *
11281get_ppc64_symbol_other (unsigned int other)
11282{
11283 if ((other & ~STO_PPC64_LOCAL_MASK) != 0)
11284 return NULL;
11285
11286 other >>= STO_PPC64_LOCAL_BIT;
11287 if (other <= 6)
11288 {
11289 static char buf[32];
11290 if (other >= 2)
11291 other = ppc64_decode_local_entry (other);
11292 snprintf (buf, sizeof buf, _("<localentry>: %d"), other);
11293 return buf;
11294 }
11295 return NULL;
11296}
11297
11298static const char *
11299get_symbol_other (Filedata * filedata, unsigned int other)
11300{
11301 const char * result = NULL;
11302 static char buff [32];
11303
11304 if (other == 0)
11305 return "";
11306
11307 switch (filedata->file_header.e_machine)
11308 {
11309 case EM_ALPHA:
11310 result = get_alpha_symbol_other (other);
11311 break;
11312 case EM_AARCH64:
11313 result = get_aarch64_symbol_other (other);
11314 break;
11315 case EM_MIPS:
11316 result = get_mips_symbol_other (other);
11317 break;
11318 case EM_IA_64:
11319 result = get_ia64_symbol_other (filedata, other);
11320 break;
11321 case EM_PPC64:
11322 result = get_ppc64_symbol_other (other);
11323 break;
11324 default:
11325 result = NULL;
11326 break;
11327 }
11328
11329 if (result)
11330 return result;
11331
11332 snprintf (buff, sizeof buff, _("<other>: %x"), other);
11333 return buff;
11334}
11335
11336static const char *
11337get_symbol_index_type (Filedata * filedata, unsigned int type)
11338{
11339 static char buff[32];
11340
11341 switch (type)
11342 {
11343 case SHN_UNDEF: return "UND";
11344 case SHN_ABS: return "ABS";
11345 case SHN_COMMON: return "COM";
11346 default:
11347 if (type == SHN_IA_64_ANSI_COMMON
11348 && filedata->file_header.e_machine == EM_IA_64
11349 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
11350 return "ANSI_COM";
11351 else if ((filedata->file_header.e_machine == EM_X86_64
11352 || filedata->file_header.e_machine == EM_L1OM
11353 || filedata->file_header.e_machine == EM_K1OM)
11354 && type == SHN_X86_64_LCOMMON)
11355 return "LARGE_COM";
11356 else if ((type == SHN_MIPS_SCOMMON
11357 && filedata->file_header.e_machine == EM_MIPS)
11358 || (type == SHN_TIC6X_SCOMMON
11359 && filedata->file_header.e_machine == EM_TI_C6000))
11360 return "SCOM";
11361 else if (type == SHN_MIPS_SUNDEFINED
11362 && filedata->file_header.e_machine == EM_MIPS)
11363 return "SUND";
11364 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
11365 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
11366 else if (type >= SHN_LOOS && type <= SHN_HIOS)
11367 sprintf (buff, "OS [0x%04x]", type & 0xffff);
11368 else if (type >= SHN_LORESERVE)
11369 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
11370 else if (type >= filedata->file_header.e_shnum)
11371 sprintf (buff, _("bad section index[%3d]"), type);
11372 else
11373 sprintf (buff, "%3d", type);
11374 break;
11375 }
11376
11377 return buff;
11378}
11379
11380static bfd_vma *
11381get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_size)
11382{
11383 unsigned char * e_data;
11384 bfd_vma * i_data;
11385
11386 /* If the size_t type is smaller than the bfd_size_type, eg because
11387 you are building a 32-bit tool on a 64-bit host, then make sure
11388 that when (number) is cast to (size_t) no information is lost. */
11389 if (sizeof (size_t) < sizeof (bfd_size_type)
11390 && (bfd_size_type) ((size_t) number) != number)
11391 {
11392 error (_("Size truncation prevents reading %s elements of size %u\n"),
11393 bfd_vmatoa ("u", number), ent_size);
11394 return NULL;
11395 }
11396
11397 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11398 attempting to allocate memory when the read is bound to fail. */
11399 if (ent_size * number > filedata->file_size)
11400 {
11401 error (_("Invalid number of dynamic entries: %s\n"),
11402 bfd_vmatoa ("u", number));
11403 return NULL;
11404 }
11405
11406 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
11407 if (e_data == NULL)
11408 {
11409 error (_("Out of memory reading %s dynamic entries\n"),
11410 bfd_vmatoa ("u", number));
11411 return NULL;
11412 }
11413
11414 if (fread (e_data, ent_size, (size_t) number, filedata->handle) != number)
11415 {
11416 error (_("Unable to read in %s bytes of dynamic data\n"),
11417 bfd_vmatoa ("u", number * ent_size));
11418 free (e_data);
11419 return NULL;
11420 }
11421
11422 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
11423 if (i_data == NULL)
11424 {
11425 error (_("Out of memory allocating space for %s dynamic entries\n"),
11426 bfd_vmatoa ("u", number));
11427 free (e_data);
11428 return NULL;
11429 }
11430
11431 while (number--)
11432 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
11433
11434 free (e_data);
11435
11436 return i_data;
11437}
11438
11439static void
11440print_dynamic_symbol (Filedata * filedata, bfd_vma si, unsigned long hn)
11441{
11442 Elf_Internal_Sym * psym;
11443 int n;
11444
11445 n = print_vma (si, DEC_5);
11446 if (n < 5)
11447 fputs (&" "[n], stdout);
11448 printf (" %3lu: ", hn);
11449
11450 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
11451 {
11452 printf (_("<No info available for dynamic symbol number %lu>\n"),
11453 (unsigned long) si);
11454 return;
11455 }
11456
11457 psym = dynamic_symbols + si;
11458 print_vma (psym->st_value, LONG_HEX);
11459 putchar (' ');
11460 print_vma (psym->st_size, DEC_5);
11461
11462 printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11463 printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11464
11465 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11466 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
11467 else
11468 {
11469 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11470
11471 printf (" %-7s", get_symbol_visibility (vis));
11472 /* Check to see if any other bits in the st_other field are set.
11473 Note - displaying this information disrupts the layout of the
11474 table being generated, but for the moment this case is very
11475 rare. */
11476 if (psym->st_other ^ vis)
11477 printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11478 }
11479
11480 printf (" %3.3s ", get_symbol_index_type (filedata, psym->st_shndx));
11481 if (VALID_DYNAMIC_NAME (psym->st_name))
11482 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11483 else
11484 printf (_(" <corrupt: %14ld>"), psym->st_name);
11485 putchar ('\n');
11486}
11487
11488static const char *
11489get_symbol_version_string (Filedata * filedata,
11490 bfd_boolean is_dynsym,
11491 const char * strtab,
11492 unsigned long int strtab_size,
11493 unsigned int si,
11494 Elf_Internal_Sym * psym,
11495 enum versioned_symbol_info * sym_info,
11496 unsigned short * vna_other)
11497{
11498 unsigned char data[2];
11499 unsigned short vers_data;
11500 unsigned long offset;
11501 unsigned short max_vd_ndx;
11502
11503 if (!is_dynsym
11504 || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11505 return NULL;
11506
11507 offset = offset_from_vma (filedata, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11508 sizeof data + si * sizeof (vers_data));
11509
11510 if (get_data (&data, filedata, offset + si * sizeof (vers_data),
11511 sizeof (data), 1, _("version data")) == NULL)
11512 return NULL;
11513
11514 vers_data = byte_get (data, 2);
11515
11516 if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data == 0)
11517 return NULL;
11518
11519 max_vd_ndx = 0;
11520
11521 /* Usually we'd only see verdef for defined symbols, and verneed for
11522 undefined symbols. However, symbols defined by the linker in
11523 .dynbss for variables copied from a shared library in order to
11524 avoid text relocations are defined yet have verneed. We could
11525 use a heuristic to detect the special case, for example, check
11526 for verneed first on symbols defined in SHT_NOBITS sections, but
11527 it is simpler and more reliable to just look for both verdef and
11528 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11529
11530 if (psym->st_shndx != SHN_UNDEF
11531 && vers_data != 0x8001
11532 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11533 {
11534 Elf_Internal_Verdef ivd;
11535 Elf_Internal_Verdaux ivda;
11536 Elf_External_Verdaux evda;
11537 unsigned long off;
11538
11539 off = offset_from_vma (filedata,
11540 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11541 sizeof (Elf_External_Verdef));
11542
11543 do
11544 {
11545 Elf_External_Verdef evd;
11546
11547 if (get_data (&evd, filedata, off, sizeof (evd), 1,
11548 _("version def")) == NULL)
11549 {
11550 ivd.vd_ndx = 0;
11551 ivd.vd_aux = 0;
11552 ivd.vd_next = 0;
11553 ivd.vd_flags = 0;
11554 }
11555 else
11556 {
11557 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11558 ivd.vd_aux = BYTE_GET (evd.vd_aux);
11559 ivd.vd_next = BYTE_GET (evd.vd_next);
11560 ivd.vd_flags = BYTE_GET (evd.vd_flags);
11561 }
11562
11563 if ((ivd.vd_ndx & VERSYM_VERSION) > max_vd_ndx)
11564 max_vd_ndx = ivd.vd_ndx & VERSYM_VERSION;
11565
11566 off += ivd.vd_next;
11567 }
11568 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11569
11570 if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11571 {
11572 if (ivd.vd_ndx == 1 && ivd.vd_flags == VER_FLG_BASE)
11573 return NULL;
11574
11575 off -= ivd.vd_next;
11576 off += ivd.vd_aux;
11577
11578 if (get_data (&evda, filedata, off, sizeof (evda), 1,
11579 _("version def aux")) != NULL)
11580 {
11581 ivda.vda_name = BYTE_GET (evda.vda_name);
11582
11583 if (psym->st_name != ivda.vda_name)
11584 {
11585 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11586 ? symbol_hidden : symbol_public);
11587 return (ivda.vda_name < strtab_size
11588 ? strtab + ivda.vda_name : _("<corrupt>"));
11589 }
11590 }
11591 }
11592 }
11593
11594 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11595 {
11596 Elf_External_Verneed evn;
11597 Elf_Internal_Verneed ivn;
11598 Elf_Internal_Vernaux ivna;
11599
11600 offset = offset_from_vma (filedata,
11601 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11602 sizeof evn);
11603 do
11604 {
11605 unsigned long vna_off;
11606
11607 if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11608 _("version need")) == NULL)
11609 {
11610 ivna.vna_next = 0;
11611 ivna.vna_other = 0;
11612 ivna.vna_name = 0;
11613 break;
11614 }
11615
11616 ivn.vn_aux = BYTE_GET (evn.vn_aux);
11617 ivn.vn_next = BYTE_GET (evn.vn_next);
11618
11619 vna_off = offset + ivn.vn_aux;
11620
11621 do
11622 {
11623 Elf_External_Vernaux evna;
11624
11625 if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
11626 _("version need aux (3)")) == NULL)
11627 {
11628 ivna.vna_next = 0;
11629 ivna.vna_other = 0;
11630 ivna.vna_name = 0;
11631 }
11632 else
11633 {
11634 ivna.vna_other = BYTE_GET (evna.vna_other);
11635 ivna.vna_next = BYTE_GET (evna.vna_next);
11636 ivna.vna_name = BYTE_GET (evna.vna_name);
11637 }
11638
11639 vna_off += ivna.vna_next;
11640 }
11641 while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11642
11643 if (ivna.vna_other == vers_data)
11644 break;
11645
11646 offset += ivn.vn_next;
11647 }
11648 while (ivn.vn_next != 0);
11649
11650 if (ivna.vna_other == vers_data)
11651 {
11652 *sym_info = symbol_undefined;
11653 *vna_other = ivna.vna_other;
11654 return (ivna.vna_name < strtab_size
11655 ? strtab + ivna.vna_name : _("<corrupt>"));
11656 }
11657 else if ((max_vd_ndx || (vers_data & VERSYM_VERSION) != 1)
11658 && (vers_data & VERSYM_VERSION) > max_vd_ndx)
11659 return _("<corrupt>");
11660 }
11661 return NULL;
11662}
11663
11664/* Dump the symbol table. */
11665static bfd_boolean
11666process_symbol_table (Filedata * filedata)
11667{
11668 Elf_Internal_Shdr * section;
11669 bfd_size_type nbuckets = 0;
11670 bfd_size_type nchains = 0;
11671 bfd_vma * buckets = NULL;
11672 bfd_vma * chains = NULL;
11673 bfd_vma ngnubuckets = 0;
11674 bfd_vma * gnubuckets = NULL;
11675 bfd_vma * gnuchains = NULL;
11676 bfd_vma gnusymidx = 0;
11677 bfd_size_type ngnuchains = 0;
11678
11679 if (!do_syms && !do_dyn_syms && !do_histogram)
11680 return TRUE;
11681
11682 if (dynamic_info[DT_HASH]
11683 && (do_histogram
11684 || (do_using_dynamic
11685 && !do_dyn_syms
11686 && dynamic_strings != NULL)))
11687 {
11688 unsigned char nb[8];
11689 unsigned char nc[8];
11690 unsigned int hash_ent_size = 4;
11691
11692 if ((filedata->file_header.e_machine == EM_ALPHA
11693 || filedata->file_header.e_machine == EM_S390
11694 || filedata->file_header.e_machine == EM_S390_OLD)
11695 && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
11696 hash_ent_size = 8;
11697
11698 if (fseek (filedata->handle,
11699 (archive_file_offset
11700 + offset_from_vma (filedata, dynamic_info[DT_HASH],
11701 sizeof nb + sizeof nc)),
11702 SEEK_SET))
11703 {
11704 error (_("Unable to seek to start of dynamic information\n"));
11705 goto no_hash;
11706 }
11707
11708 if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
11709 {
11710 error (_("Failed to read in number of buckets\n"));
11711 goto no_hash;
11712 }
11713
11714 if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
11715 {
11716 error (_("Failed to read in number of chains\n"));
11717 goto no_hash;
11718 }
11719
11720 nbuckets = byte_get (nb, hash_ent_size);
11721 nchains = byte_get (nc, hash_ent_size);
11722
11723 buckets = get_dynamic_data (filedata, nbuckets, hash_ent_size);
11724 chains = get_dynamic_data (filedata, nchains, hash_ent_size);
11725
11726 no_hash:
11727 if (buckets == NULL || chains == NULL)
11728 {
11729 if (do_using_dynamic)
11730 return FALSE;
11731 free (buckets);
11732 free (chains);
11733 buckets = NULL;
11734 chains = NULL;
11735 nbuckets = 0;
11736 nchains = 0;
11737 }
11738 }
11739
11740 if (dynamic_info_DT_GNU_HASH
11741 && (do_histogram
11742 || (do_using_dynamic
11743 && !do_dyn_syms
11744 && dynamic_strings != NULL)))
11745 {
11746 unsigned char nb[16];
11747 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11748 bfd_vma buckets_vma;
11749
11750 if (fseek (filedata->handle,
11751 (archive_file_offset
11752 + offset_from_vma (filedata, dynamic_info_DT_GNU_HASH,
11753 sizeof nb)),
11754 SEEK_SET))
11755 {
11756 error (_("Unable to seek to start of dynamic information\n"));
11757 goto no_gnu_hash;
11758 }
11759
11760 if (fread (nb, 16, 1, filedata->handle) != 1)
11761 {
11762 error (_("Failed to read in number of buckets\n"));
11763 goto no_gnu_hash;
11764 }
11765
11766 ngnubuckets = byte_get (nb, 4);
11767 gnusymidx = byte_get (nb + 4, 4);
11768 bitmaskwords = byte_get (nb + 8, 4);
11769 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11770 if (is_32bit_elf)
11771 buckets_vma += bitmaskwords * 4;
11772 else
11773 buckets_vma += bitmaskwords * 8;
11774
11775 if (fseek (filedata->handle,
11776 (archive_file_offset
11777 + offset_from_vma (filedata, buckets_vma, 4)),
11778 SEEK_SET))
11779 {
11780 error (_("Unable to seek to start of dynamic information\n"));
11781 goto no_gnu_hash;
11782 }
11783
11784 gnubuckets = get_dynamic_data (filedata, ngnubuckets, 4);
11785
11786 if (gnubuckets == NULL)
11787 goto no_gnu_hash;
11788
11789 for (i = 0; i < ngnubuckets; i++)
11790 if (gnubuckets[i] != 0)
11791 {
11792 if (gnubuckets[i] < gnusymidx)
11793 return FALSE;
11794
11795 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11796 maxchain = gnubuckets[i];
11797 }
11798
11799 if (maxchain == 0xffffffff)
11800 goto no_gnu_hash;
11801
11802 maxchain -= gnusymidx;
11803
11804 if (fseek (filedata->handle,
11805 (archive_file_offset
11806 + offset_from_vma (filedata, buckets_vma
11807 + 4 * (ngnubuckets + maxchain), 4)),
11808 SEEK_SET))
11809 {
11810 error (_("Unable to seek to start of dynamic information\n"));
11811 goto no_gnu_hash;
11812 }
11813
11814 do
11815 {
11816 if (fread (nb, 4, 1, filedata->handle) != 1)
11817 {
11818 error (_("Failed to determine last chain length\n"));
11819 goto no_gnu_hash;
11820 }
11821
11822 if (maxchain + 1 == 0)
11823 goto no_gnu_hash;
11824
11825 ++maxchain;
11826 }
11827 while ((byte_get (nb, 4) & 1) == 0);
11828
11829 if (fseek (filedata->handle,
11830 (archive_file_offset
11831 + offset_from_vma (filedata, buckets_vma + 4 * ngnubuckets, 4)),
11832 SEEK_SET))
11833 {
11834 error (_("Unable to seek to start of dynamic information\n"));
11835 goto no_gnu_hash;
11836 }
11837
11838 gnuchains = get_dynamic_data (filedata, maxchain, 4);
11839 ngnuchains = maxchain;
11840
11841 no_gnu_hash:
11842 if (gnuchains == NULL)
11843 {
11844 free (gnubuckets);
11845 gnubuckets = NULL;
11846 ngnubuckets = 0;
11847 if (do_using_dynamic)
11848 return FALSE;
11849 }
11850 }
11851
11852 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11853 && do_syms
11854 && do_using_dynamic
11855 && dynamic_strings != NULL
11856 && dynamic_symbols != NULL)
11857 {
11858 unsigned long hn;
11859
11860 if (dynamic_info[DT_HASH])
11861 {
11862 bfd_vma si;
11863 char *visited;
11864
11865 printf (_("\nSymbol table for image:\n"));
11866 if (is_32bit_elf)
11867 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11868 else
11869 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11870
11871 visited = xcmalloc (nchains, 1);
11872 memset (visited, 0, nchains);
11873 for (hn = 0; hn < nbuckets; hn++)
11874 {
11875 for (si = buckets[hn]; si > 0; si = chains[si])
11876 {
11877 print_dynamic_symbol (filedata, si, hn);
11878 if (si >= nchains || visited[si])
11879 {
11880 error (_("histogram chain is corrupt\n"));
11881 break;
11882 }
11883 visited[si] = 1;
11884 }
11885 }
11886 free (visited);
11887 }
11888
11889 if (dynamic_info_DT_GNU_HASH)
11890 {
11891 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11892 if (is_32bit_elf)
11893 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11894 else
11895 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11896
11897 for (hn = 0; hn < ngnubuckets; ++hn)
11898 if (gnubuckets[hn] != 0)
11899 {
11900 bfd_vma si = gnubuckets[hn];
11901 bfd_vma off = si - gnusymidx;
11902
11903 do
11904 {
11905 print_dynamic_symbol (filedata, si, hn);
11906 si++;
11907 }
11908 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11909 }
11910 }
11911 }
11912 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11913 && filedata->section_headers != NULL)
11914 {
11915 unsigned int i;
11916
11917 for (i = 0, section = filedata->section_headers;
11918 i < filedata->file_header.e_shnum;
11919 i++, section++)
11920 {
11921 unsigned int si;
11922 char * strtab = NULL;
11923 unsigned long int strtab_size = 0;
11924 Elf_Internal_Sym * symtab;
11925 Elf_Internal_Sym * psym;
11926 unsigned long num_syms;
11927
11928 if ((section->sh_type != SHT_SYMTAB
11929 && section->sh_type != SHT_DYNSYM)
11930 || (!do_syms
11931 && section->sh_type == SHT_SYMTAB))
11932 continue;
11933
11934 if (section->sh_entsize == 0)
11935 {
11936 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11937 printable_section_name (filedata, section));
11938 continue;
11939 }
11940
11941 num_syms = section->sh_size / section->sh_entsize;
11942 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11943 "\nSymbol table '%s' contains %lu entries:\n",
11944 num_syms),
11945 printable_section_name (filedata, section),
11946 num_syms);
11947
11948 if (is_32bit_elf)
11949 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11950 else
11951 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11952
11953 symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
11954 if (symtab == NULL)
11955 continue;
11956
11957 if (section->sh_link == filedata->file_header.e_shstrndx)
11958 {
11959 strtab = filedata->string_table;
11960 strtab_size = filedata->string_table_length;
11961 }
11962 else if (section->sh_link < filedata->file_header.e_shnum)
11963 {
11964 Elf_Internal_Shdr * string_sec;
11965
11966 string_sec = filedata->section_headers + section->sh_link;
11967
11968 strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
11969 1, string_sec->sh_size,
11970 _("string table"));
11971 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11972 }
11973
11974 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11975 {
11976 const char *version_string;
11977 enum versioned_symbol_info sym_info;
11978 unsigned short vna_other;
11979
11980 printf ("%6d: ", si);
11981 print_vma (psym->st_value, LONG_HEX);
11982 putchar (' ');
11983 print_vma (psym->st_size, DEC_5);
11984 printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11985 printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11986 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11987 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
11988 else
11989 {
11990 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11991
11992 printf (" %-7s", get_symbol_visibility (vis));
11993 /* Check to see if any other bits in the st_other field are set.
11994 Note - displaying this information disrupts the layout of the
11995 table being generated, but for the moment this case is very rare. */
11996 if (psym->st_other ^ vis)
11997 printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11998 }
11999 printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
12000 print_symbol (25, psym->st_name < strtab_size
12001 ? strtab + psym->st_name : _("<corrupt>"));
12002
12003 version_string
12004 = get_symbol_version_string (filedata,
12005 section->sh_type == SHT_DYNSYM,
12006 strtab, strtab_size, si,
12007 psym, &sym_info, &vna_other);
12008 if (version_string)
12009 {
12010 if (sym_info == symbol_undefined)
12011 printf ("@%s (%d)", version_string, vna_other);
12012 else
12013 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
12014 version_string);
12015 }
12016
12017 putchar ('\n');
12018
12019 if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
12020 && si >= section->sh_info
12021 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12022 && filedata->file_header.e_machine != EM_MIPS
12023 /* Solaris binaries have been found to violate this requirement as
12024 well. Not sure if this is a bug or an ABI requirement. */
12025 && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
12026 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
12027 si, printable_section_name (filedata, section), section->sh_info);
12028 }
12029
12030 free (symtab);
12031 if (strtab != filedata->string_table)
12032 free (strtab);
12033 }
12034 }
12035 else if (do_syms)
12036 printf
12037 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12038
12039 if (do_histogram && buckets != NULL)
12040 {
12041 unsigned long * lengths;
12042 unsigned long * counts;
12043 unsigned long hn;
12044 bfd_vma si;
12045 unsigned long maxlength = 0;
12046 unsigned long nzero_counts = 0;
12047 unsigned long nsyms = 0;
12048 char *visited;
12049
12050 printf (ngettext ("\nHistogram for bucket list length "
12051 "(total of %lu bucket):\n",
12052 "\nHistogram for bucket list length "
12053 "(total of %lu buckets):\n",
12054 (unsigned long) nbuckets),
12055 (unsigned long) nbuckets);
12056
12057 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
12058 if (lengths == NULL)
12059 {
12060 error (_("Out of memory allocating space for histogram buckets\n"));
12061 return FALSE;
12062 }
12063 visited = xcmalloc (nchains, 1);
12064 memset (visited, 0, nchains);
12065
12066 printf (_(" Length Number %% of total Coverage\n"));
12067 for (hn = 0; hn < nbuckets; ++hn)
12068 {
12069 for (si = buckets[hn]; si > 0; si = chains[si])
12070 {
12071 ++nsyms;
12072 if (maxlength < ++lengths[hn])
12073 ++maxlength;
12074 if (si >= nchains || visited[si])
12075 {
12076 error (_("histogram chain is corrupt\n"));
12077 break;
12078 }
12079 visited[si] = 1;
12080 }
12081 }
12082 free (visited);
12083
12084 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
12085 if (counts == NULL)
12086 {
12087 free (lengths);
12088 error (_("Out of memory allocating space for histogram counts\n"));
12089 return FALSE;
12090 }
12091
12092 for (hn = 0; hn < nbuckets; ++hn)
12093 ++counts[lengths[hn]];
12094
12095 if (nbuckets > 0)
12096 {
12097 unsigned long i;
12098 printf (" 0 %-10lu (%5.1f%%)\n",
12099 counts[0], (counts[0] * 100.0) / nbuckets);
12100 for (i = 1; i <= maxlength; ++i)
12101 {
12102 nzero_counts += counts[i] * i;
12103 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12104 i, counts[i], (counts[i] * 100.0) / nbuckets,
12105 (nzero_counts * 100.0) / nsyms);
12106 }
12107 }
12108
12109 free (counts);
12110 free (lengths);
12111 }
12112
12113 if (buckets != NULL)
12114 {
12115 free (buckets);
12116 free (chains);
12117 }
12118
12119 if (do_histogram && gnubuckets != NULL)
12120 {
12121 unsigned long * lengths;
12122 unsigned long * counts;
12123 unsigned long hn;
12124 unsigned long maxlength = 0;
12125 unsigned long nzero_counts = 0;
12126 unsigned long nsyms = 0;
12127
12128 printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
12129 "(total of %lu bucket):\n",
12130 "\nHistogram for `.gnu.hash' bucket list length "
12131 "(total of %lu buckets):\n",
12132 (unsigned long) ngnubuckets),
12133 (unsigned long) ngnubuckets);
12134
12135 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
12136 if (lengths == NULL)
12137 {
12138 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12139 return FALSE;
12140 }
12141
12142 printf (_(" Length Number %% of total Coverage\n"));
12143
12144 for (hn = 0; hn < ngnubuckets; ++hn)
12145 if (gnubuckets[hn] != 0)
12146 {
12147 bfd_vma off, length = 1;
12148
12149 for (off = gnubuckets[hn] - gnusymidx;
12150 /* PR 17531 file: 010-77222-0.004. */
12151 off < ngnuchains && (gnuchains[off] & 1) == 0;
12152 ++off)
12153 ++length;
12154 lengths[hn] = length;
12155 if (length > maxlength)
12156 maxlength = length;
12157 nsyms += length;
12158 }
12159
12160 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
12161 if (counts == NULL)
12162 {
12163 free (lengths);
12164 error (_("Out of memory allocating space for gnu histogram counts\n"));
12165 return FALSE;
12166 }
12167
12168 for (hn = 0; hn < ngnubuckets; ++hn)
12169 ++counts[lengths[hn]];
12170
12171 if (ngnubuckets > 0)
12172 {
12173 unsigned long j;
12174 printf (" 0 %-10lu (%5.1f%%)\n",
12175 counts[0], (counts[0] * 100.0) / ngnubuckets);
12176 for (j = 1; j <= maxlength; ++j)
12177 {
12178 nzero_counts += counts[j] * j;
12179 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12180 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
12181 (nzero_counts * 100.0) / nsyms);
12182 }
12183 }
12184
12185 free (counts);
12186 free (lengths);
12187 free (gnubuckets);
12188 free (gnuchains);
12189 }
12190
12191 return TRUE;
12192}
12193
12194static bfd_boolean
12195process_syminfo (Filedata * filedata ATTRIBUTE_UNUSED)
12196{
12197 unsigned int i;
12198
12199 if (dynamic_syminfo == NULL
12200 || !do_dynamic)
12201 /* No syminfo, this is ok. */
12202 return TRUE;
12203
12204 /* There better should be a dynamic symbol section. */
12205 if (dynamic_symbols == NULL || dynamic_strings == NULL)
12206 return FALSE;
12207
12208 if (dynamic_addr)
12209 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12210 "contains %d entry:\n",
12211 "\nDynamic info segment at offset 0x%lx "
12212 "contains %d entries:\n",
12213 dynamic_syminfo_nent),
12214 dynamic_syminfo_offset, dynamic_syminfo_nent);
12215
12216 printf (_(" Num: Name BoundTo Flags\n"));
12217 for (i = 0; i < dynamic_syminfo_nent; ++i)
12218 {
12219 unsigned short int flags = dynamic_syminfo[i].si_flags;
12220
12221 printf ("%4d: ", i);
12222 if (i >= num_dynamic_syms)
12223 printf (_("<corrupt index>"));
12224 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
12225 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
12226 else
12227 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
12228 putchar (' ');
12229
12230 switch (dynamic_syminfo[i].si_boundto)
12231 {
12232 case SYMINFO_BT_SELF:
12233 fputs ("SELF ", stdout);
12234 break;
12235 case SYMINFO_BT_PARENT:
12236 fputs ("PARENT ", stdout);
12237 break;
12238 default:
12239 if (dynamic_syminfo[i].si_boundto > 0
12240 && dynamic_syminfo[i].si_boundto < dynamic_nent
12241 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
12242 {
12243 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
12244 putchar (' ' );
12245 }
12246 else
12247 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
12248 break;
12249 }
12250
12251 if (flags & SYMINFO_FLG_DIRECT)
12252 printf (" DIRECT");
12253 if (flags & SYMINFO_FLG_PASSTHRU)
12254 printf (" PASSTHRU");
12255 if (flags & SYMINFO_FLG_COPY)
12256 printf (" COPY");
12257 if (flags & SYMINFO_FLG_LAZYLOAD)
12258 printf (" LAZYLOAD");
12259
12260 puts ("");
12261 }
12262
12263 return TRUE;
12264}
12265
12266#define IN_RANGE(START,END,ADDR,OFF) \
12267 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
12268
12269/* Check to see if the given reloc needs to be handled in a target specific
12270 manner. If so then process the reloc and return TRUE otherwise return
12271 FALSE.
12272
12273 If called with reloc == NULL, then this is a signal that reloc processing
12274 for the current section has finished, and any saved state should be
12275 discarded. */
12276
12277static bfd_boolean
12278target_specific_reloc_handling (Filedata * filedata,
12279 Elf_Internal_Rela * reloc,
12280 unsigned char * start,
12281 unsigned char * end,
12282 Elf_Internal_Sym * symtab,
12283 unsigned long num_syms)
12284{
12285 unsigned int reloc_type = 0;
12286 unsigned long sym_index = 0;
12287
12288 if (reloc)
12289 {
12290 reloc_type = get_reloc_type (filedata, reloc->r_info);
12291 sym_index = get_reloc_symindex (reloc->r_info);
12292 }
12293
12294 switch (filedata->file_header.e_machine)
12295 {
12296 case EM_MSP430:
12297 case EM_MSP430_OLD:
12298 {
12299 static Elf_Internal_Sym * saved_sym = NULL;
12300
12301 if (reloc == NULL)
12302 {
12303 saved_sym = NULL;
12304 return TRUE;
12305 }
12306
12307 switch (reloc_type)
12308 {
12309 case 10: /* R_MSP430_SYM_DIFF */
12310 if (uses_msp430x_relocs (filedata))
12311 break;
12312 /* Fall through. */
12313 case 21: /* R_MSP430X_SYM_DIFF */
12314 /* PR 21139. */
12315 if (sym_index >= num_syms)
12316 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12317 sym_index);
12318 else
12319 saved_sym = symtab + sym_index;
12320 return TRUE;
12321
12322 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12323 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12324 goto handle_sym_diff;
12325
12326 case 5: /* R_MSP430_16_BYTE */
12327 case 9: /* R_MSP430_8 */
12328 if (uses_msp430x_relocs (filedata))
12329 break;
12330 goto handle_sym_diff;
12331
12332 case 2: /* R_MSP430_ABS16 */
12333 case 15: /* R_MSP430X_ABS16 */
12334 if (! uses_msp430x_relocs (filedata))
12335 break;
12336 goto handle_sym_diff;
12337
12338 handle_sym_diff:
12339 if (saved_sym != NULL)
12340 {
12341 int reloc_size = reloc_type == 1 ? 4 : 2;
12342 bfd_vma value;
12343
12344 if (sym_index >= num_syms)
12345 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12346 sym_index);
12347 else
12348 {
12349 value = reloc->r_addend + (symtab[sym_index].st_value
12350 - saved_sym->st_value);
12351
12352 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12353 byte_put (start + reloc->r_offset, value, reloc_size);
12354 else
12355 /* PR 21137 */
12356 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12357 (long) reloc->r_offset);
12358 }
12359
12360 saved_sym = NULL;
12361 return TRUE;
12362 }
12363 break;
12364
12365 default:
12366 if (saved_sym != NULL)
12367 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12368 break;
12369 }
12370 break;
12371 }
12372
12373 case EM_MN10300:
12374 case EM_CYGNUS_MN10300:
12375 {
12376 static Elf_Internal_Sym * saved_sym = NULL;
12377
12378 if (reloc == NULL)
12379 {
12380 saved_sym = NULL;
12381 return TRUE;
12382 }
12383
12384 switch (reloc_type)
12385 {
12386 case 34: /* R_MN10300_ALIGN */
12387 return TRUE;
12388 case 33: /* R_MN10300_SYM_DIFF */
12389 if (sym_index >= num_syms)
12390 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12391 sym_index);
12392 else
12393 saved_sym = symtab + sym_index;
12394 return TRUE;
12395
12396 case 1: /* R_MN10300_32 */
12397 case 2: /* R_MN10300_16 */
12398 if (saved_sym != NULL)
12399 {
12400 int reloc_size = reloc_type == 1 ? 4 : 2;
12401 bfd_vma value;
12402
12403 if (sym_index >= num_syms)
12404 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12405 sym_index);
12406 else
12407 {
12408 value = reloc->r_addend + (symtab[sym_index].st_value
12409 - saved_sym->st_value);
12410
12411 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12412 byte_put (start + reloc->r_offset, value, reloc_size);
12413 else
12414 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12415 (long) reloc->r_offset);
12416 }
12417
12418 saved_sym = NULL;
12419 return TRUE;
12420 }
12421 break;
12422 default:
12423 if (saved_sym != NULL)
12424 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12425 break;
12426 }
12427 break;
12428 }
12429
12430 case EM_RL78:
12431 {
12432 static bfd_vma saved_sym1 = 0;
12433 static bfd_vma saved_sym2 = 0;
12434 static bfd_vma value;
12435
12436 if (reloc == NULL)
12437 {
12438 saved_sym1 = saved_sym2 = 0;
12439 return TRUE;
12440 }
12441
12442 switch (reloc_type)
12443 {
12444 case 0x80: /* R_RL78_SYM. */
12445 saved_sym1 = saved_sym2;
12446 if (sym_index >= num_syms)
12447 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12448 sym_index);
12449 else
12450 {
12451 saved_sym2 = symtab[sym_index].st_value;
12452 saved_sym2 += reloc->r_addend;
12453 }
12454 return TRUE;
12455
12456 case 0x83: /* R_RL78_OPsub. */
12457 value = saved_sym1 - saved_sym2;
12458 saved_sym2 = saved_sym1 = 0;
12459 return TRUE;
12460 break;
12461
12462 case 0x41: /* R_RL78_ABS32. */
12463 if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12464 byte_put (start + reloc->r_offset, value, 4);
12465 else
12466 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12467 (long) reloc->r_offset);
12468 value = 0;
12469 return TRUE;
12470
12471 case 0x43: /* R_RL78_ABS16. */
12472 if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12473 byte_put (start + reloc->r_offset, value, 2);
12474 else
12475 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12476 (long) reloc->r_offset);
12477 value = 0;
12478 return TRUE;
12479
12480 default:
12481 break;
12482 }
12483 break;
12484 }
12485 }
12486
12487 return FALSE;
12488}
12489
12490/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12491 DWARF debug sections. This is a target specific test. Note - we do not
12492 go through the whole including-target-headers-multiple-times route, (as
12493 we have already done with <elf/h8.h>) because this would become very
12494 messy and even then this function would have to contain target specific
12495 information (the names of the relocs instead of their numeric values).
12496 FIXME: This is not the correct way to solve this problem. The proper way
12497 is to have target specific reloc sizing and typing functions created by
12498 the reloc-macros.h header, in the same way that it already creates the
12499 reloc naming functions. */
12500
12501static bfd_boolean
12502is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12503{
12504 /* Please keep this table alpha-sorted for ease of visual lookup. */
12505 switch (filedata->file_header.e_machine)
12506 {
12507 case EM_386:
12508 case EM_IAMCU:
12509 return reloc_type == 1; /* R_386_32. */
12510 case EM_68K:
12511 return reloc_type == 1; /* R_68K_32. */
12512 case EM_860:
12513 return reloc_type == 1; /* R_860_32. */
12514 case EM_960:
12515 return reloc_type == 2; /* R_960_32. */
12516 case EM_AARCH64:
12517 return (reloc_type == 258
12518 || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12519 case EM_BPF:
12520 return reloc_type == 11; /* R_BPF_DATA_32 */
12521 case EM_ADAPTEVA_EPIPHANY:
12522 return reloc_type == 3;
12523 case EM_ALPHA:
12524 return reloc_type == 1; /* R_ALPHA_REFLONG. */
12525 case EM_ARC:
12526 return reloc_type == 1; /* R_ARC_32. */
12527 case EM_ARC_COMPACT:
12528 case EM_ARC_COMPACT2:
12529 return reloc_type == 4; /* R_ARC_32. */
12530 case EM_ARM:
12531 return reloc_type == 2; /* R_ARM_ABS32 */
12532 case EM_AVR_OLD:
12533 case EM_AVR:
12534 return reloc_type == 1;
12535 case EM_BLACKFIN:
12536 return reloc_type == 0x12; /* R_byte4_data. */
12537 case EM_CRIS:
12538 return reloc_type == 3; /* R_CRIS_32. */
12539 case EM_CR16:
12540 return reloc_type == 3; /* R_CR16_NUM32. */
12541 case EM_CRX:
12542 return reloc_type == 15; /* R_CRX_NUM32. */
12543 case EM_CSKY:
12544 return reloc_type == 1; /* R_CKCORE_ADDR32. */
12545 case EM_CYGNUS_FRV:
12546 return reloc_type == 1;
12547 case EM_CYGNUS_D10V:
12548 case EM_D10V:
12549 return reloc_type == 6; /* R_D10V_32. */
12550 case EM_CYGNUS_D30V:
12551 case EM_D30V:
12552 return reloc_type == 12; /* R_D30V_32_NORMAL. */
12553 case EM_DLX:
12554 return reloc_type == 3; /* R_DLX_RELOC_32. */
12555 case EM_CYGNUS_FR30:
12556 case EM_FR30:
12557 return reloc_type == 3; /* R_FR30_32. */
12558 case EM_FT32:
12559 return reloc_type == 1; /* R_FT32_32. */
12560 case EM_H8S:
12561 case EM_H8_300:
12562 case EM_H8_300H:
12563 return reloc_type == 1; /* R_H8_DIR32. */
12564 case EM_IA_64:
12565 return (reloc_type == 0x64 /* R_IA64_SECREL32MSB. */
12566 || reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
12567 || reloc_type == 0x24 /* R_IA64_DIR32MSB. */
12568 || reloc_type == 0x25 /* R_IA64_DIR32LSB. */);
12569 case EM_IP2K_OLD:
12570 case EM_IP2K:
12571 return reloc_type == 2; /* R_IP2K_32. */
12572 case EM_IQ2000:
12573 return reloc_type == 2; /* R_IQ2000_32. */
12574 case EM_LATTICEMICO32:
12575 return reloc_type == 3; /* R_LM32_32. */
12576 case EM_M32C_OLD:
12577 case EM_M32C:
12578 return reloc_type == 3; /* R_M32C_32. */
12579 case EM_M32R:
12580 return reloc_type == 34; /* R_M32R_32_RELA. */
12581 case EM_68HC11:
12582 case EM_68HC12:
12583 return reloc_type == 6; /* R_M68HC11_32. */
12584 case EM_S12Z:
12585 return reloc_type == 7 || /* R_S12Z_EXT32 */
12586 reloc_type == 6; /* R_S12Z_CW32. */
12587 case EM_MCORE:
12588 return reloc_type == 1; /* R_MCORE_ADDR32. */
12589 case EM_CYGNUS_MEP:
12590 return reloc_type == 4; /* R_MEP_32. */
12591 case EM_METAG:
12592 return reloc_type == 2; /* R_METAG_ADDR32. */
12593 case EM_MICROBLAZE:
12594 return reloc_type == 1; /* R_MICROBLAZE_32. */
12595 case EM_MIPS:
12596 return reloc_type == 2; /* R_MIPS_32. */
12597 case EM_MMIX:
12598 return reloc_type == 4; /* R_MMIX_32. */
12599 case EM_CYGNUS_MN10200:
12600 case EM_MN10200:
12601 return reloc_type == 1; /* R_MN10200_32. */
12602 case EM_CYGNUS_MN10300:
12603 case EM_MN10300:
12604 return reloc_type == 1; /* R_MN10300_32. */
12605 case EM_MOXIE:
12606 return reloc_type == 1; /* R_MOXIE_32. */
12607 case EM_MSP430_OLD:
12608 case EM_MSP430:
12609 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12610 case EM_MT:
12611 return reloc_type == 2; /* R_MT_32. */
12612 case EM_NDS32:
12613 return reloc_type == 20; /* R_NDS32_RELA. */
12614 case EM_ALTERA_NIOS2:
12615 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
12616 case EM_NIOS32:
12617 return reloc_type == 1; /* R_NIOS_32. */
12618 case EM_OR1K:
12619 return reloc_type == 1; /* R_OR1K_32. */
12620 case EM_PARISC:
12621 return (reloc_type == 1 /* R_PARISC_DIR32. */
12622 || reloc_type == 2 /* R_PARISC_DIR21L. */
12623 || reloc_type == 41); /* R_PARISC_SECREL32. */
12624 case EM_PJ:
12625 case EM_PJ_OLD:
12626 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
12627 case EM_PPC64:
12628 return reloc_type == 1; /* R_PPC64_ADDR32. */
12629 case EM_PPC:
12630 return reloc_type == 1; /* R_PPC_ADDR32. */
12631 case EM_TI_PRU:
12632 return reloc_type == 11; /* R_PRU_BFD_RELOC_32. */
12633 case EM_RISCV:
12634 return reloc_type == 1; /* R_RISCV_32. */
12635 case EM_RL78:
12636 return reloc_type == 1; /* R_RL78_DIR32. */
12637 case EM_RX:
12638 return reloc_type == 1; /* R_RX_DIR32. */
12639 case EM_S370:
12640 return reloc_type == 1; /* R_I370_ADDR31. */
12641 case EM_S390_OLD:
12642 case EM_S390:
12643 return reloc_type == 4; /* R_S390_32. */
12644 case EM_SCORE:
12645 return reloc_type == 8; /* R_SCORE_ABS32. */
12646 case EM_SH:
12647 return reloc_type == 1; /* R_SH_DIR32. */
12648 case EM_SPARC32PLUS:
12649 case EM_SPARCV9:
12650 case EM_SPARC:
12651 return reloc_type == 3 /* R_SPARC_32. */
12652 || reloc_type == 23; /* R_SPARC_UA32. */
12653 case EM_SPU:
12654 return reloc_type == 6; /* R_SPU_ADDR32 */
12655 case EM_TI_C6000:
12656 return reloc_type == 1; /* R_C6000_ABS32. */
12657 case EM_TILEGX:
12658 return reloc_type == 2; /* R_TILEGX_32. */
12659 case EM_TILEPRO:
12660 return reloc_type == 1; /* R_TILEPRO_32. */
12661 case EM_CYGNUS_V850:
12662 case EM_V850:
12663 return reloc_type == 6; /* R_V850_ABS32. */
12664 case EM_V800:
12665 return reloc_type == 0x33; /* R_V810_WORD. */
12666 case EM_VAX:
12667 return reloc_type == 1; /* R_VAX_32. */
12668 case EM_VISIUM:
12669 return reloc_type == 3; /* R_VISIUM_32. */
12670 case EM_WEBASSEMBLY:
12671 return reloc_type == 1; /* R_WASM32_32. */
12672 case EM_X86_64:
12673 case EM_L1OM:
12674 case EM_K1OM:
12675 return reloc_type == 10; /* R_X86_64_32. */
12676 case EM_XC16X:
12677 case EM_C166:
12678 return reloc_type == 3; /* R_XC16C_ABS_32. */
12679 case EM_XGATE:
12680 return reloc_type == 4; /* R_XGATE_32. */
12681 case EM_XSTORMY16:
12682 return reloc_type == 1; /* R_XSTROMY16_32. */
12683 case EM_XTENSA_OLD:
12684 case EM_XTENSA:
12685 return reloc_type == 1; /* R_XTENSA_32. */
12686 default:
12687 {
12688 static unsigned int prev_warn = 0;
12689
12690 /* Avoid repeating the same warning multiple times. */
12691 if (prev_warn != filedata->file_header.e_machine)
12692 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12693 filedata->file_header.e_machine);
12694 prev_warn = filedata->file_header.e_machine;
12695 return FALSE;
12696 }
12697 }
12698}
12699
12700/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12701 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12702
12703static bfd_boolean
12704is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12705{
12706 switch (filedata->file_header.e_machine)
12707 /* Please keep this table alpha-sorted for ease of visual lookup. */
12708 {
12709 case EM_386:
12710 case EM_IAMCU:
12711 return reloc_type == 2; /* R_386_PC32. */
12712 case EM_68K:
12713 return reloc_type == 4; /* R_68K_PC32. */
12714 case EM_AARCH64:
12715 return reloc_type == 261; /* R_AARCH64_PREL32 */
12716 case EM_ADAPTEVA_EPIPHANY:
12717 return reloc_type == 6;
12718 case EM_ALPHA:
12719 return reloc_type == 10; /* R_ALPHA_SREL32. */
12720 case EM_ARC_COMPACT:
12721 case EM_ARC_COMPACT2:
12722 return reloc_type == 49; /* R_ARC_32_PCREL. */
12723 case EM_ARM:
12724 return reloc_type == 3; /* R_ARM_REL32 */
12725 case EM_AVR_OLD:
12726 case EM_AVR:
12727 return reloc_type == 36; /* R_AVR_32_PCREL. */
12728 case EM_MICROBLAZE:
12729 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
12730 case EM_OR1K:
12731 return reloc_type == 9; /* R_OR1K_32_PCREL. */
12732 case EM_PARISC:
12733 return reloc_type == 9; /* R_PARISC_PCREL32. */
12734 case EM_PPC:
12735 return reloc_type == 26; /* R_PPC_REL32. */
12736 case EM_PPC64:
12737 return reloc_type == 26; /* R_PPC64_REL32. */
12738 case EM_RISCV:
12739 return reloc_type == 57; /* R_RISCV_32_PCREL. */
12740 case EM_S390_OLD:
12741 case EM_S390:
12742 return reloc_type == 5; /* R_390_PC32. */
12743 case EM_SH:
12744 return reloc_type == 2; /* R_SH_REL32. */
12745 case EM_SPARC32PLUS:
12746 case EM_SPARCV9:
12747 case EM_SPARC:
12748 return reloc_type == 6; /* R_SPARC_DISP32. */
12749 case EM_SPU:
12750 return reloc_type == 13; /* R_SPU_REL32. */
12751 case EM_TILEGX:
12752 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
12753 case EM_TILEPRO:
12754 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
12755 case EM_VISIUM:
12756 return reloc_type == 6; /* R_VISIUM_32_PCREL */
12757 case EM_X86_64:
12758 case EM_L1OM:
12759 case EM_K1OM:
12760 return reloc_type == 2; /* R_X86_64_PC32. */
12761 case EM_VAX:
12762 return reloc_type == 4; /* R_VAX_PCREL32. */
12763 case EM_XTENSA_OLD:
12764 case EM_XTENSA:
12765 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
12766 default:
12767 /* Do not abort or issue an error message here. Not all targets use
12768 pc-relative 32-bit relocs in their DWARF debug information and we
12769 have already tested for target coverage in is_32bit_abs_reloc. A
12770 more helpful warning message will be generated by apply_relocations
12771 anyway, so just return. */
12772 return FALSE;
12773 }
12774}
12775
12776/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12777 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12778
12779static bfd_boolean
12780is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12781{
12782 switch (filedata->file_header.e_machine)
12783 {
12784 case EM_AARCH64:
12785 return reloc_type == 257; /* R_AARCH64_ABS64. */
12786 case EM_ALPHA:
12787 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
12788 case EM_IA_64:
12789 return (reloc_type == 0x26 /* R_IA64_DIR64MSB. */
12790 || reloc_type == 0x27 /* R_IA64_DIR64LSB. */);
12791 case EM_PARISC:
12792 return reloc_type == 80; /* R_PARISC_DIR64. */
12793 case EM_PPC64:
12794 return reloc_type == 38; /* R_PPC64_ADDR64. */
12795 case EM_RISCV:
12796 return reloc_type == 2; /* R_RISCV_64. */
12797 case EM_SPARC32PLUS:
12798 case EM_SPARCV9:
12799 case EM_SPARC:
12800 return reloc_type == 32 /* R_SPARC_64. */
12801 || reloc_type == 54; /* R_SPARC_UA64. */
12802 case EM_X86_64:
12803 case EM_L1OM:
12804 case EM_K1OM:
12805 return reloc_type == 1; /* R_X86_64_64. */
12806 case EM_S390_OLD:
12807 case EM_S390:
12808 return reloc_type == 22; /* R_S390_64. */
12809 case EM_TILEGX:
12810 return reloc_type == 1; /* R_TILEGX_64. */
12811 case EM_MIPS:
12812 return reloc_type == 18; /* R_MIPS_64. */
12813 default:
12814 return FALSE;
12815 }
12816}
12817
12818/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12819 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12820
12821static bfd_boolean
12822is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12823{
12824 switch (filedata->file_header.e_machine)
12825 {
12826 case EM_AARCH64:
12827 return reloc_type == 260; /* R_AARCH64_PREL64. */
12828 case EM_ALPHA:
12829 return reloc_type == 11; /* R_ALPHA_SREL64. */
12830 case EM_IA_64:
12831 return (reloc_type == 0x4e /* R_IA64_PCREL64MSB. */
12832 || reloc_type == 0x4f /* R_IA64_PCREL64LSB. */);
12833 case EM_PARISC:
12834 return reloc_type == 72; /* R_PARISC_PCREL64. */
12835 case EM_PPC64:
12836 return reloc_type == 44; /* R_PPC64_REL64. */
12837 case EM_SPARC32PLUS:
12838 case EM_SPARCV9:
12839 case EM_SPARC:
12840 return reloc_type == 46; /* R_SPARC_DISP64. */
12841 case EM_X86_64:
12842 case EM_L1OM:
12843 case EM_K1OM:
12844 return reloc_type == 24; /* R_X86_64_PC64. */
12845 case EM_S390_OLD:
12846 case EM_S390:
12847 return reloc_type == 23; /* R_S390_PC64. */
12848 case EM_TILEGX:
12849 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
12850 default:
12851 return FALSE;
12852 }
12853}
12854
12855/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12856 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12857
12858static bfd_boolean
12859is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12860{
12861 switch (filedata->file_header.e_machine)
12862 {
12863 case EM_CYGNUS_MN10200:
12864 case EM_MN10200:
12865 return reloc_type == 4; /* R_MN10200_24. */
12866 case EM_FT32:
12867 return reloc_type == 5; /* R_FT32_20. */
12868 default:
12869 return FALSE;
12870 }
12871}
12872
12873/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12874 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12875
12876static bfd_boolean
12877is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12878{
12879 /* Please keep this table alpha-sorted for ease of visual lookup. */
12880 switch (filedata->file_header.e_machine)
12881 {
12882 case EM_ARC:
12883 case EM_ARC_COMPACT:
12884 case EM_ARC_COMPACT2:
12885 return reloc_type == 2; /* R_ARC_16. */
12886 case EM_ADAPTEVA_EPIPHANY:
12887 return reloc_type == 5;
12888 case EM_AVR_OLD:
12889 case EM_AVR:
12890 return reloc_type == 4; /* R_AVR_16. */
12891 case EM_CYGNUS_D10V:
12892 case EM_D10V:
12893 return reloc_type == 3; /* R_D10V_16. */
12894 case EM_FT32:
12895 return reloc_type == 2; /* R_FT32_16. */
12896 case EM_H8S:
12897 case EM_H8_300:
12898 case EM_H8_300H:
12899 return reloc_type == R_H8_DIR16;
12900 case EM_IP2K_OLD:
12901 case EM_IP2K:
12902 return reloc_type == 1; /* R_IP2K_16. */
12903 case EM_M32C_OLD:
12904 case EM_M32C:
12905 return reloc_type == 1; /* R_M32C_16 */
12906 case EM_CYGNUS_MN10200:
12907 case EM_MN10200:
12908 return reloc_type == 2; /* R_MN10200_16. */
12909 case EM_CYGNUS_MN10300:
12910 case EM_MN10300:
12911 return reloc_type == 2; /* R_MN10300_16. */
12912 case EM_MSP430:
12913 if (uses_msp430x_relocs (filedata))
12914 return reloc_type == 2; /* R_MSP430_ABS16. */
12915 /* Fall through. */
12916 case EM_MSP430_OLD:
12917 return reloc_type == 5; /* R_MSP430_16_BYTE. */
12918 case EM_NDS32:
12919 return reloc_type == 19; /* R_NDS32_RELA. */
12920 case EM_ALTERA_NIOS2:
12921 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
12922 case EM_NIOS32:
12923 return reloc_type == 9; /* R_NIOS_16. */
12924 case EM_OR1K:
12925 return reloc_type == 2; /* R_OR1K_16. */
12926 case EM_RISCV:
12927 return reloc_type == 55; /* R_RISCV_SET16. */
12928 case EM_TI_PRU:
12929 return reloc_type == 8; /* R_PRU_BFD_RELOC_16. */
12930 case EM_TI_C6000:
12931 return reloc_type == 2; /* R_C6000_ABS16. */
12932 case EM_VISIUM:
12933 return reloc_type == 2; /* R_VISIUM_16. */
12934 case EM_XC16X:
12935 case EM_C166:
12936 return reloc_type == 2; /* R_XC16C_ABS_16. */
12937 case EM_XGATE:
12938 return reloc_type == 3; /* R_XGATE_16. */
12939 default:
12940 return FALSE;
12941 }
12942}
12943
12944/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12945 a 8-bit absolute RELA relocation used in DWARF debug sections. */
12946
12947static bfd_boolean
12948is_8bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12949{
12950 switch (filedata->file_header.e_machine)
12951 {
12952 case EM_RISCV:
12953 return reloc_type == 54; /* R_RISCV_SET8. */
12954 default:
12955 return FALSE;
12956 }
12957}
12958
12959/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12960 a 6-bit absolute RELA relocation used in DWARF debug sections. */
12961
12962static bfd_boolean
12963is_6bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12964{
12965 switch (filedata->file_header.e_machine)
12966 {
12967 case EM_RISCV:
12968 return reloc_type == 53; /* R_RISCV_SET6. */
12969 default:
12970 return FALSE;
12971 }
12972}
12973
12974/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12975 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
12976
12977static bfd_boolean
12978is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12979{
12980 /* Please keep this table alpha-sorted for ease of visual lookup. */
12981 switch (filedata->file_header.e_machine)
12982 {
12983 case EM_RISCV:
12984 return reloc_type == 35; /* R_RISCV_ADD32. */
12985 default:
12986 return FALSE;
12987 }
12988}
12989
12990/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12991 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
12992
12993static bfd_boolean
12994is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12995{
12996 /* Please keep this table alpha-sorted for ease of visual lookup. */
12997 switch (filedata->file_header.e_machine)
12998 {
12999 case EM_RISCV:
13000 return reloc_type == 39; /* R_RISCV_SUB32. */
13001 default:
13002 return FALSE;
13003 }
13004}
13005
13006/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13007 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13008
13009static bfd_boolean
13010is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13011{
13012 /* Please keep this table alpha-sorted for ease of visual lookup. */
13013 switch (filedata->file_header.e_machine)
13014 {
13015 case EM_RISCV:
13016 return reloc_type == 36; /* R_RISCV_ADD64. */
13017 default:
13018 return FALSE;
13019 }
13020}
13021
13022/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13023 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13024
13025static bfd_boolean
13026is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13027{
13028 /* Please keep this table alpha-sorted for ease of visual lookup. */
13029 switch (filedata->file_header.e_machine)
13030 {
13031 case EM_RISCV:
13032 return reloc_type == 40; /* R_RISCV_SUB64. */
13033 default:
13034 return FALSE;
13035 }
13036}
13037
13038/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13039 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13040
13041static bfd_boolean
13042is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13043{
13044 /* Please keep this table alpha-sorted for ease of visual lookup. */
13045 switch (filedata->file_header.e_machine)
13046 {
13047 case EM_RISCV:
13048 return reloc_type == 34; /* R_RISCV_ADD16. */
13049 default:
13050 return FALSE;
13051 }
13052}
13053
13054/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13055 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13056
13057static bfd_boolean
13058is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13059{
13060 /* Please keep this table alpha-sorted for ease of visual lookup. */
13061 switch (filedata->file_header.e_machine)
13062 {
13063 case EM_RISCV:
13064 return reloc_type == 38; /* R_RISCV_SUB16. */
13065 default:
13066 return FALSE;
13067 }
13068}
13069
13070/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13071 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13072
13073static bfd_boolean
13074is_8bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13075{
13076 /* Please keep this table alpha-sorted for ease of visual lookup. */
13077 switch (filedata->file_header.e_machine)
13078 {
13079 case EM_RISCV:
13080 return reloc_type == 33; /* R_RISCV_ADD8. */
13081 default:
13082 return FALSE;
13083 }
13084}
13085
13086/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13087 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13088
13089static bfd_boolean
13090is_8bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13091{
13092 /* Please keep this table alpha-sorted for ease of visual lookup. */
13093 switch (filedata->file_header.e_machine)
13094 {
13095 case EM_RISCV:
13096 return reloc_type == 37; /* R_RISCV_SUB8. */
13097 default:
13098 return FALSE;
13099 }
13100}
13101
13102/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13103 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13104
13105static bfd_boolean
13106is_6bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13107{
13108 switch (filedata->file_header.e_machine)
13109 {
13110 case EM_RISCV:
13111 return reloc_type == 52; /* R_RISCV_SUB6. */
13112 default:
13113 return FALSE;
13114 }
13115}
13116
13117/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13118 relocation entries (possibly formerly used for SHT_GROUP sections). */
13119
13120static bfd_boolean
13121is_none_reloc (Filedata * filedata, unsigned int reloc_type)
13122{
13123 switch (filedata->file_header.e_machine)
13124 {
13125 case EM_386: /* R_386_NONE. */
13126 case EM_68K: /* R_68K_NONE. */
13127 case EM_ADAPTEVA_EPIPHANY:
13128 case EM_ALPHA: /* R_ALPHA_NONE. */
13129 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
13130 case EM_ARC: /* R_ARC_NONE. */
13131 case EM_ARC_COMPACT2: /* R_ARC_NONE. */
13132 case EM_ARC_COMPACT: /* R_ARC_NONE. */
13133 case EM_ARM: /* R_ARM_NONE. */
13134 case EM_C166: /* R_XC16X_NONE. */
13135 case EM_CRIS: /* R_CRIS_NONE. */
13136 case EM_FT32: /* R_FT32_NONE. */
13137 case EM_IA_64: /* R_IA64_NONE. */
13138 case EM_K1OM: /* R_X86_64_NONE. */
13139 case EM_L1OM: /* R_X86_64_NONE. */
13140 case EM_M32R: /* R_M32R_NONE. */
13141 case EM_MIPS: /* R_MIPS_NONE. */
13142 case EM_MN10300: /* R_MN10300_NONE. */
13143 case EM_MOXIE: /* R_MOXIE_NONE. */
13144 case EM_NIOS32: /* R_NIOS_NONE. */
13145 case EM_OR1K: /* R_OR1K_NONE. */
13146 case EM_PARISC: /* R_PARISC_NONE. */
13147 case EM_PPC64: /* R_PPC64_NONE. */
13148 case EM_PPC: /* R_PPC_NONE. */
13149 case EM_RISCV: /* R_RISCV_NONE. */
13150 case EM_S390: /* R_390_NONE. */
13151 case EM_S390_OLD:
13152 case EM_SH: /* R_SH_NONE. */
13153 case EM_SPARC32PLUS:
13154 case EM_SPARC: /* R_SPARC_NONE. */
13155 case EM_SPARCV9:
13156 case EM_TILEGX: /* R_TILEGX_NONE. */
13157 case EM_TILEPRO: /* R_TILEPRO_NONE. */
13158 case EM_TI_C6000:/* R_C6000_NONE. */
13159 case EM_X86_64: /* R_X86_64_NONE. */
13160 case EM_XC16X:
13161 case EM_WEBASSEMBLY: /* R_WASM32_NONE. */
13162 return reloc_type == 0;
13163
13164 case EM_AARCH64:
13165 return reloc_type == 0 || reloc_type == 256;
13166 case EM_AVR_OLD:
13167 case EM_AVR:
13168 return (reloc_type == 0 /* R_AVR_NONE. */
13169 || reloc_type == 30 /* R_AVR_DIFF8. */
13170 || reloc_type == 31 /* R_AVR_DIFF16. */
13171 || reloc_type == 32 /* R_AVR_DIFF32. */);
13172 case EM_METAG:
13173 return reloc_type == 3; /* R_METAG_NONE. */
13174 case EM_NDS32:
13175 return (reloc_type == 0 /* R_XTENSA_NONE. */
13176 || reloc_type == 204 /* R_NDS32_DIFF8. */
13177 || reloc_type == 205 /* R_NDS32_DIFF16. */
13178 || reloc_type == 206 /* R_NDS32_DIFF32. */
13179 || reloc_type == 207 /* R_NDS32_ULEB128. */);
13180 case EM_TI_PRU:
13181 return (reloc_type == 0 /* R_PRU_NONE. */
13182 || reloc_type == 65 /* R_PRU_DIFF8. */
13183 || reloc_type == 66 /* R_PRU_DIFF16. */
13184 || reloc_type == 67 /* R_PRU_DIFF32. */);
13185 case EM_XTENSA_OLD:
13186 case EM_XTENSA:
13187 return (reloc_type == 0 /* R_XTENSA_NONE. */
13188 || reloc_type == 17 /* R_XTENSA_DIFF8. */
13189 || reloc_type == 18 /* R_XTENSA_DIFF16. */
13190 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
13191 }
13192 return FALSE;
13193}
13194
13195/* Returns TRUE if there is a relocation against
13196 section NAME at OFFSET bytes. */
13197
13198bfd_boolean
13199reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
13200{
13201 Elf_Internal_Rela * relocs;
13202 Elf_Internal_Rela * rp;
13203
13204 if (dsec == NULL || dsec->reloc_info == NULL)
13205 return FALSE;
13206
13207 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
13208
13209 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
13210 if (rp->r_offset == offset)
13211 return TRUE;
13212
13213 return FALSE;
13214}
13215
13216/* Apply relocations to a section.
13217 Returns TRUE upon success, FALSE otherwise.
13218 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13219 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13220 will be set to the number of relocs loaded.
13221
13222 Note: So far support has been added only for those relocations
13223 which can be found in debug sections. FIXME: Add support for
13224 more relocations ? */
13225
13226static bfd_boolean
13227apply_relocations (Filedata * filedata,
13228 const Elf_Internal_Shdr * section,
13229 unsigned char * start,
13230 bfd_size_type size,
13231 void ** relocs_return,
13232 unsigned long * num_relocs_return)
13233{
13234 Elf_Internal_Shdr * relsec;
13235 unsigned char * end = start + size;
13236
13237 if (relocs_return != NULL)
13238 {
13239 * (Elf_Internal_Rela **) relocs_return = NULL;
13240 * num_relocs_return = 0;
13241 }
13242
13243 if (filedata->file_header.e_type != ET_REL)
13244 /* No relocs to apply. */
13245 return TRUE;
13246
13247 /* Find the reloc section associated with the section. */
13248 for (relsec = filedata->section_headers;
13249 relsec < filedata->section_headers + filedata->file_header.e_shnum;
13250 ++relsec)
13251 {
13252 bfd_boolean is_rela;
13253 unsigned long num_relocs;
13254 Elf_Internal_Rela * relocs;
13255 Elf_Internal_Rela * rp;
13256 Elf_Internal_Shdr * symsec;
13257 Elf_Internal_Sym * symtab;
13258 unsigned long num_syms;
13259 Elf_Internal_Sym * sym;
13260
13261 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13262 || relsec->sh_info >= filedata->file_header.e_shnum
13263 || filedata->section_headers + relsec->sh_info != section
13264 || relsec->sh_size == 0
13265 || relsec->sh_link >= filedata->file_header.e_shnum)
13266 continue;
13267
13268 is_rela = relsec->sh_type == SHT_RELA;
13269
13270 if (is_rela)
13271 {
13272 if (!slurp_rela_relocs (filedata, relsec->sh_offset,
13273 relsec->sh_size, & relocs, & num_relocs))
13274 return FALSE;
13275 }
13276 else
13277 {
13278 if (!slurp_rel_relocs (filedata, relsec->sh_offset,
13279 relsec->sh_size, & relocs, & num_relocs))
13280 return FALSE;
13281 }
13282
13283 /* SH uses RELA but uses in place value instead of the addend field. */
13284 if (filedata->file_header.e_machine == EM_SH)
13285 is_rela = FALSE;
13286
13287 symsec = filedata->section_headers + relsec->sh_link;
13288 if (symsec->sh_type != SHT_SYMTAB
13289 && symsec->sh_type != SHT_DYNSYM)
13290 return FALSE;
13291 symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
13292
13293 for (rp = relocs; rp < relocs + num_relocs; ++rp)
13294 {
13295 bfd_vma addend;
13296 unsigned int reloc_type;
13297 unsigned int reloc_size;
13298 bfd_boolean reloc_inplace = FALSE;
13299 bfd_boolean reloc_subtract = FALSE;
13300 unsigned char * rloc;
13301 unsigned long sym_index;
13302
13303 reloc_type = get_reloc_type (filedata, rp->r_info);
13304
13305 if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
13306 continue;
13307 else if (is_none_reloc (filedata, reloc_type))
13308 continue;
13309 else if (is_32bit_abs_reloc (filedata, reloc_type)
13310 || is_32bit_pcrel_reloc (filedata, reloc_type))
13311 reloc_size = 4;
13312 else if (is_64bit_abs_reloc (filedata, reloc_type)
13313 || is_64bit_pcrel_reloc (filedata, reloc_type))
13314 reloc_size = 8;
13315 else if (is_24bit_abs_reloc (filedata, reloc_type))
13316 reloc_size = 3;
13317 else if (is_16bit_abs_reloc (filedata, reloc_type))
13318 reloc_size = 2;
13319 else if (is_8bit_abs_reloc (filedata, reloc_type)
13320 || is_6bit_abs_reloc (filedata, reloc_type))
13321 reloc_size = 1;
13322 else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
13323 reloc_type))
13324 || is_32bit_inplace_add_reloc (filedata, reloc_type))
13325 {
13326 reloc_size = 4;
13327 reloc_inplace = TRUE;
13328 }
13329 else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
13330 reloc_type))
13331 || is_64bit_inplace_add_reloc (filedata, reloc_type))
13332 {
13333 reloc_size = 8;
13334 reloc_inplace = TRUE;
13335 }
13336 else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
13337 reloc_type))
13338 || is_16bit_inplace_add_reloc (filedata, reloc_type))
13339 {
13340 reloc_size = 2;
13341 reloc_inplace = TRUE;
13342 }
13343 else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
13344 reloc_type))
13345 || is_8bit_inplace_add_reloc (filedata, reloc_type))
13346 {
13347 reloc_size = 1;
13348 reloc_inplace = TRUE;
13349 }
13350 else if ((reloc_subtract = is_6bit_inplace_sub_reloc (filedata,
13351 reloc_type)))
13352 {
13353 reloc_size = 1;
13354 reloc_inplace = TRUE;
13355 }
13356 else
13357 {
13358 static unsigned int prev_reloc = 0;
13359
13360 if (reloc_type != prev_reloc)
13361 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13362 reloc_type, printable_section_name (filedata, section));
13363 prev_reloc = reloc_type;
13364 continue;
13365 }
13366
13367 rloc = start + rp->r_offset;
13368 if (rloc >= end || (rloc + reloc_size) > end || (rloc < start))
13369 {
13370 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13371 (unsigned long) rp->r_offset,
13372 printable_section_name (filedata, section));
13373 continue;
13374 }
13375
13376 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
13377 if (sym_index >= num_syms)
13378 {
13379 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13380 sym_index, printable_section_name (filedata, section));
13381 continue;
13382 }
13383 sym = symtab + sym_index;
13384
13385 /* If the reloc has a symbol associated with it,
13386 make sure that it is of an appropriate type.
13387
13388 Relocations against symbols without type can happen.
13389 Gcc -feliminate-dwarf2-dups may generate symbols
13390 without type for debug info.
13391
13392 Icc generates relocations against function symbols
13393 instead of local labels.
13394
13395 Relocations against object symbols can happen, eg when
13396 referencing a global array. For an example of this see
13397 the _clz.o binary in libgcc.a. */
13398 if (sym != symtab
13399 && ELF_ST_TYPE (sym->st_info) != STT_COMMON
13400 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
13401 {
13402 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13403 get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
13404 printable_section_name (filedata, relsec),
13405 (long int)(rp - relocs));
13406 continue;
13407 }
13408
13409 addend = 0;
13410 if (is_rela)
13411 addend += rp->r_addend;
13412 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13413 partial_inplace. */
13414 if (!is_rela
13415 || (filedata->file_header.e_machine == EM_XTENSA
13416 && reloc_type == 1)
13417 || ((filedata->file_header.e_machine == EM_PJ
13418 || filedata->file_header.e_machine == EM_PJ_OLD)
13419 && reloc_type == 1)
13420 || ((filedata->file_header.e_machine == EM_D30V
13421 || filedata->file_header.e_machine == EM_CYGNUS_D30V)
13422 && reloc_type == 12)
13423 || reloc_inplace)
13424 {
13425 if (is_6bit_inplace_sub_reloc (filedata, reloc_type))
13426 addend += byte_get (rloc, reloc_size) & 0x3f;
13427 else
13428 addend += byte_get (rloc, reloc_size);
13429 }
13430
13431 if (is_32bit_pcrel_reloc (filedata, reloc_type)
13432 || is_64bit_pcrel_reloc (filedata, reloc_type))
13433 {
13434 /* On HPPA, all pc-relative relocations are biased by 8. */
13435 if (filedata->file_header.e_machine == EM_PARISC)
13436 addend -= 8;
13437 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
13438 reloc_size);
13439 }
13440 else if (is_6bit_abs_reloc (filedata, reloc_type)
13441 || is_6bit_inplace_sub_reloc (filedata, reloc_type))
13442 {
13443 if (reloc_subtract)
13444 addend -= sym->st_value;
13445 else
13446 addend += sym->st_value;
13447 addend = (addend & 0x3f) | (byte_get (rloc, reloc_size) & 0xc0);
13448 byte_put (rloc, addend, reloc_size);
13449 }
13450 else if (reloc_subtract)
13451 byte_put (rloc, addend - sym->st_value, reloc_size);
13452 else
13453 byte_put (rloc, addend + sym->st_value, reloc_size);
13454 }
13455
13456 free (symtab);
13457 /* Let the target specific reloc processing code know that
13458 we have finished with these relocs. */
13459 target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
13460
13461 if (relocs_return)
13462 {
13463 * (Elf_Internal_Rela **) relocs_return = relocs;
13464 * num_relocs_return = num_relocs;
13465 }
13466 else
13467 free (relocs);
13468
13469 break;
13470 }
13471
13472 return TRUE;
13473}
13474
13475#ifdef SUPPORT_DISASSEMBLY
13476static bfd_boolean
13477disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
13478{
13479 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
13480
13481 /* FIXME: XXX -- to be done --- XXX */
13482
13483 return TRUE;
13484}
13485#endif
13486
13487/* Reads in the contents of SECTION from FILE, returning a pointer
13488 to a malloc'ed buffer or NULL if something went wrong. */
13489
13490static char *
13491get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
13492{
13493 bfd_size_type num_bytes = section->sh_size;
13494
13495 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
13496 {
13497 printf (_("Section '%s' has no data to dump.\n"),
13498 printable_section_name (filedata, section));
13499 return NULL;
13500 }
13501
13502 return (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
13503 _("section contents"));
13504}
13505
13506/* Uncompresses a section that was compressed using zlib, in place. */
13507
13508static bfd_boolean
13509uncompress_section_contents (unsigned char ** buffer,
13510 dwarf_size_type uncompressed_size,
13511 dwarf_size_type * size)
13512{
13513 dwarf_size_type compressed_size = *size;
13514 unsigned char * compressed_buffer = *buffer;
13515 unsigned char * uncompressed_buffer;
13516 z_stream strm;
13517 int rc;
13518
13519 /* It is possible the section consists of several compressed
13520 buffers concatenated together, so we uncompress in a loop. */
13521 /* PR 18313: The state field in the z_stream structure is supposed
13522 to be invisible to the user (ie us), but some compilers will
13523 still complain about it being used without initialisation. So
13524 we first zero the entire z_stream structure and then set the fields
13525 that we need. */
13526 memset (& strm, 0, sizeof strm);
13527 strm.avail_in = compressed_size;
13528 strm.next_in = (Bytef *) compressed_buffer;
13529 strm.avail_out = uncompressed_size;
13530 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
13531
13532 rc = inflateInit (& strm);
13533 while (strm.avail_in > 0)
13534 {
13535 if (rc != Z_OK)
13536 goto fail;
13537 strm.next_out = ((Bytef *) uncompressed_buffer
13538 + (uncompressed_size - strm.avail_out));
13539 rc = inflate (&strm, Z_FINISH);
13540 if (rc != Z_STREAM_END)
13541 goto fail;
13542 rc = inflateReset (& strm);
13543 }
13544 rc = inflateEnd (& strm);
13545 if (rc != Z_OK
13546 || strm.avail_out != 0)
13547 goto fail;
13548
13549 *buffer = uncompressed_buffer;
13550 *size = uncompressed_size;
13551 return TRUE;
13552
13553 fail:
13554 free (uncompressed_buffer);
13555 /* Indicate decompression failure. */
13556 *buffer = NULL;
13557 return FALSE;
13558}
13559
13560static bfd_boolean
13561dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
13562{
13563 Elf_Internal_Shdr * relsec;
13564 bfd_size_type num_bytes;
13565 unsigned char * data;
13566 unsigned char * end;
13567 unsigned char * real_start;
13568 unsigned char * start;
13569 bfd_boolean some_strings_shown;
13570
13571 real_start = start = (unsigned char *) get_section_contents (section, filedata);
13572 if (start == NULL)
13573 /* PR 21820: Do not fail if the section was empty. */
13574 return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13575
13576 num_bytes = section->sh_size;
13577
13578 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
13579
13580 if (decompress_dumps)
13581 {
13582 dwarf_size_type new_size = num_bytes;
13583 dwarf_size_type uncompressed_size = 0;
13584
13585 if ((section->sh_flags & SHF_COMPRESSED) != 0)
13586 {
13587 Elf_Internal_Chdr chdr;
13588 unsigned int compression_header_size
13589 = get_compression_header (& chdr, (unsigned char *) start,
13590 num_bytes);
13591
13592 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13593 {
13594 warn (_("section '%s' has unsupported compress type: %d\n"),
13595 printable_section_name (filedata, section), chdr.ch_type);
13596 return FALSE;
13597 }
13598 uncompressed_size = chdr.ch_size;
13599 start += compression_header_size;
13600 new_size -= compression_header_size;
13601 }
13602 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13603 {
13604 /* Read the zlib header. In this case, it should be "ZLIB"
13605 followed by the uncompressed section size, 8 bytes in
13606 big-endian order. */
13607 uncompressed_size = start[4]; uncompressed_size <<= 8;
13608 uncompressed_size += start[5]; uncompressed_size <<= 8;
13609 uncompressed_size += start[6]; uncompressed_size <<= 8;
13610 uncompressed_size += start[7]; uncompressed_size <<= 8;
13611 uncompressed_size += start[8]; uncompressed_size <<= 8;
13612 uncompressed_size += start[9]; uncompressed_size <<= 8;
13613 uncompressed_size += start[10]; uncompressed_size <<= 8;
13614 uncompressed_size += start[11];
13615 start += 12;
13616 new_size -= 12;
13617 }
13618
13619 if (uncompressed_size)
13620 {
13621 if (uncompress_section_contents (& start,
13622 uncompressed_size, & new_size))
13623 num_bytes = new_size;
13624 else
13625 {
13626 error (_("Unable to decompress section %s\n"),
13627 printable_section_name (filedata, section));
13628 return FALSE;
13629 }
13630 }
13631 else
13632 start = real_start;
13633 }
13634
13635 /* If the section being dumped has relocations against it the user might
13636 be expecting these relocations to have been applied. Check for this
13637 case and issue a warning message in order to avoid confusion.
13638 FIXME: Maybe we ought to have an option that dumps a section with
13639 relocs applied ? */
13640 for (relsec = filedata->section_headers;
13641 relsec < filedata->section_headers + filedata->file_header.e_shnum;
13642 ++relsec)
13643 {
13644 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13645 || relsec->sh_info >= filedata->file_header.e_shnum
13646 || filedata->section_headers + relsec->sh_info != section
13647 || relsec->sh_size == 0
13648 || relsec->sh_link >= filedata->file_header.e_shnum)
13649 continue;
13650
13651 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13652 break;
13653 }
13654
13655 data = start;
13656 end = start + num_bytes;
13657 some_strings_shown = FALSE;
13658
13659 while (data < end)
13660 {
13661 while (!ISPRINT (* data))
13662 if (++ data >= end)
13663 break;
13664
13665 if (data < end)
13666 {
13667 size_t maxlen = end - data;
13668
13669#ifndef __MSVCRT__
13670 /* PR 11128: Use two separate invocations in order to work
13671 around bugs in the Solaris 8 implementation of printf. */
13672 printf (" [%6tx] ", data - start);
13673#else
13674 printf (" [%6Ix] ", (size_t) (data - start));
13675#endif
13676 if (maxlen > 0)
13677 {
13678 print_symbol ((int) maxlen, (const char *) data);
13679 putchar ('\n');
13680 data += strnlen ((const char *) data, maxlen);
13681 }
13682 else
13683 {
13684 printf (_("<corrupt>\n"));
13685 data = end;
13686 }
13687 some_strings_shown = TRUE;
13688 }
13689 }
13690
13691 if (! some_strings_shown)
13692 printf (_(" No strings found in this section."));
13693
13694 free (real_start);
13695
13696 putchar ('\n');
13697 return TRUE;
13698}
13699
13700static bfd_boolean
13701dump_section_as_bytes (Elf_Internal_Shdr * section,
13702 Filedata * filedata,
13703 bfd_boolean relocate)
13704{
13705 Elf_Internal_Shdr * relsec;
13706 bfd_size_type bytes;
13707 bfd_size_type section_size;
13708 bfd_vma addr;
13709 unsigned char * data;
13710 unsigned char * real_start;
13711 unsigned char * start;
13712
13713 real_start = start = (unsigned char *) get_section_contents (section, filedata);
13714 if (start == NULL)
13715 /* PR 21820: Do not fail if the section was empty. */
13716 return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13717
13718 section_size = section->sh_size;
13719
13720 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
13721
13722 if (decompress_dumps)
13723 {
13724 dwarf_size_type new_size = section_size;
13725 dwarf_size_type uncompressed_size = 0;
13726
13727 if ((section->sh_flags & SHF_COMPRESSED) != 0)
13728 {
13729 Elf_Internal_Chdr chdr;
13730 unsigned int compression_header_size
13731 = get_compression_header (& chdr, start, section_size);
13732
13733 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13734 {
13735 warn (_("section '%s' has unsupported compress type: %d\n"),
13736 printable_section_name (filedata, section), chdr.ch_type);
13737 return FALSE;
13738 }
13739 uncompressed_size = chdr.ch_size;
13740 start += compression_header_size;
13741 new_size -= compression_header_size;
13742 }
13743 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13744 {
13745 /* Read the zlib header. In this case, it should be "ZLIB"
13746 followed by the uncompressed section size, 8 bytes in
13747 big-endian order. */
13748 uncompressed_size = start[4]; uncompressed_size <<= 8;
13749 uncompressed_size += start[5]; uncompressed_size <<= 8;
13750 uncompressed_size += start[6]; uncompressed_size <<= 8;
13751 uncompressed_size += start[7]; uncompressed_size <<= 8;
13752 uncompressed_size += start[8]; uncompressed_size <<= 8;
13753 uncompressed_size += start[9]; uncompressed_size <<= 8;
13754 uncompressed_size += start[10]; uncompressed_size <<= 8;
13755 uncompressed_size += start[11];
13756 start += 12;
13757 new_size -= 12;
13758 }
13759
13760 if (uncompressed_size)
13761 {
13762 if (uncompress_section_contents (& start, uncompressed_size,
13763 & new_size))
13764 {
13765 section_size = new_size;
13766 }
13767 else
13768 {
13769 error (_("Unable to decompress section %s\n"),
13770 printable_section_name (filedata, section));
13771 /* FIXME: Print the section anyway ? */
13772 return FALSE;
13773 }
13774 }
13775 else
13776 start = real_start;
13777 }
13778
13779 if (relocate)
13780 {
13781 if (! apply_relocations (filedata, section, start, section_size, NULL, NULL))
13782 return FALSE;
13783 }
13784 else
13785 {
13786 /* If the section being dumped has relocations against it the user might
13787 be expecting these relocations to have been applied. Check for this
13788 case and issue a warning message in order to avoid confusion.
13789 FIXME: Maybe we ought to have an option that dumps a section with
13790 relocs applied ? */
13791 for (relsec = filedata->section_headers;
13792 relsec < filedata->section_headers + filedata->file_header.e_shnum;
13793 ++relsec)
13794 {
13795 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13796 || relsec->sh_info >= filedata->file_header.e_shnum
13797 || filedata->section_headers + relsec->sh_info != section
13798 || relsec->sh_size == 0
13799 || relsec->sh_link >= filedata->file_header.e_shnum)
13800 continue;
13801
13802 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13803 break;
13804 }
13805 }
13806
13807 addr = section->sh_addr;
13808 bytes = section_size;
13809 data = start;
13810
13811 while (bytes)
13812 {
13813 int j;
13814 int k;
13815 int lbytes;
13816
13817 lbytes = (bytes > 16 ? 16 : bytes);
13818
13819 printf (" 0x%8.8lx ", (unsigned long) addr);
13820
13821 for (j = 0; j < 16; j++)
13822 {
13823 if (j < lbytes)
13824 printf ("%2.2x", data[j]);
13825 else
13826 printf (" ");
13827
13828 if ((j & 3) == 3)
13829 printf (" ");
13830 }
13831
13832 for (j = 0; j < lbytes; j++)
13833 {
13834 k = data[j];
13835 if (k >= ' ' && k < 0x7f)
13836 printf ("%c", k);
13837 else
13838 printf (".");
13839 }
13840
13841 putchar ('\n');
13842
13843 data += lbytes;
13844 addr += lbytes;
13845 bytes -= lbytes;
13846 }
13847
13848 free (real_start);
13849
13850 putchar ('\n');
13851 return TRUE;
13852}
13853
13854static ctf_sect_t *
13855shdr_to_ctf_sect (ctf_sect_t *buf, Elf_Internal_Shdr *shdr, Filedata *filedata)
13856{
13857 buf->cts_name = SECTION_NAME (shdr);
13858 buf->cts_size = shdr->sh_size;
13859 buf->cts_entsize = shdr->sh_entsize;
13860
13861 return buf;
13862}
13863
13864/* Formatting callback function passed to ctf_dump. Returns either the pointer
13865 it is passed, or a pointer to newly-allocated storage, in which case
13866 dump_ctf() will free it when it no longer needs it. */
13867
13868static char *dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED,
13869 char *s, void *arg)
13870{
13871 const char *blanks = arg;
13872 char *new_s;
13873
13874 if (asprintf (&new_s, "%s%s", blanks, s) < 0)
13875 return s;
13876 return new_s;
13877}
13878
13879static bfd_boolean
13880dump_section_as_ctf (Elf_Internal_Shdr * section, Filedata * filedata)
13881{
13882 Elf_Internal_Shdr * parent_sec = NULL;
13883 Elf_Internal_Shdr * symtab_sec = NULL;
13884 Elf_Internal_Shdr * strtab_sec = NULL;
13885 void * data = NULL;
13886 void * symdata = NULL;
13887 void * strdata = NULL;
13888 void * parentdata = NULL;
13889 ctf_sect_t ctfsect, symsect, strsect, parentsect;
13890 ctf_sect_t * symsectp = NULL;
13891 ctf_sect_t * strsectp = NULL;
13892 ctf_file_t * ctf = NULL;
13893 ctf_file_t * parent = NULL;
13894
13895 const char *things[] = {"Labels", "Data objects", "Function objects",
13896 "Variables", "Types", "Strings", ""};
13897 const char **thing;
13898 int err;
13899 bfd_boolean ret = FALSE;
13900 size_t i;
13901
13902 shdr_to_ctf_sect (&ctfsect, section, filedata);
13903 data = get_section_contents (section, filedata);
13904 ctfsect.cts_data = data;
13905
13906 if (dump_ctf_symtab_name)
13907 {
13908 if ((symtab_sec = find_section (filedata, dump_ctf_symtab_name)) == NULL)
13909 {
13910 error (_("No symbol section named %s\n"), dump_ctf_symtab_name);
13911 goto fail;
13912 }
13913 if ((symdata = (void *) get_data (NULL, filedata,
13914 symtab_sec->sh_offset, 1,
13915 symtab_sec->sh_size,
13916 _("symbols"))) == NULL)
13917 goto fail;
13918 symsectp = shdr_to_ctf_sect (&symsect, symtab_sec, filedata);
13919 symsect.cts_data = symdata;
13920 }
13921 if (dump_ctf_strtab_name)
13922 {
13923 if ((strtab_sec = find_section (filedata, dump_ctf_strtab_name)) == NULL)
13924 {
13925 error (_("No string table section named %s\n"),
13926 dump_ctf_strtab_name);
13927 goto fail;
13928 }
13929 if ((strdata = (void *) get_data (NULL, filedata,
13930 strtab_sec->sh_offset, 1,
13931 strtab_sec->sh_size,
13932 _("strings"))) == NULL)
13933 goto fail;
13934 strsectp = shdr_to_ctf_sect (&strsect, strtab_sec, filedata);
13935 strsect.cts_data = strdata;
13936 }
13937 if (dump_ctf_parent_name)
13938 {
13939 if ((parent_sec = find_section (filedata, dump_ctf_parent_name)) == NULL)
13940 {
13941 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name);
13942 goto fail;
13943 }
13944 if ((parentdata = (void *) get_data (NULL, filedata,
13945 parent_sec->sh_offset, 1,
13946 parent_sec->sh_size,
13947 _("CTF parent"))) == NULL)
13948 goto fail;
13949 shdr_to_ctf_sect (&parentsect, parent_sec, filedata);
13950 parentsect.cts_data = parentdata;
13951 }
13952
13953 /* Load the CTF file and dump it. */
13954
13955 if ((ctf = ctf_bufopen (&ctfsect, symsectp, strsectp, &err)) == NULL)
13956 {
13957 error (_("CTF open failure: %s\n"), ctf_errmsg (err));
13958 goto fail;
13959 }
13960
13961 if (parentdata)
13962 {
13963 if ((parent = ctf_bufopen (&parentsect, symsectp, strsectp, &err)) == NULL)
13964 {
13965 error (_("CTF open failure: %s\n"), ctf_errmsg (err));
13966 goto fail;
13967 }
13968
13969 ctf_import (ctf, parent);
13970 }
13971
13972 ret = TRUE;
13973
13974 printf (_("\nDump of CTF section '%s':\n"),
13975 printable_section_name (filedata, section));
13976
13977 for (i = 1, thing = things; *thing[0]; thing++, i++)
13978 {
13979 ctf_dump_state_t *s = NULL;
13980 char *item;
13981
13982 printf ("\n %s:\n", *thing);
13983 while ((item = ctf_dump (ctf, &s, i, dump_ctf_indent_lines,
13984 (void *) " ")) != NULL)
13985 {
13986 printf ("%s\n", item);
13987 free (item);
13988 }
13989
13990 if (ctf_errno (ctf))
13991 {
13992 error (_("Iteration failed: %s, %s\n"), *thing,
13993 ctf_errmsg (ctf_errno (ctf)));
13994 ret = FALSE;
13995 }
13996 }
13997
13998 fail:
13999 ctf_file_close (ctf);
14000 ctf_file_close (parent);
14001 free (parentdata);
14002 free (data);
14003 free (symdata);
14004 free (strdata);
14005 return ret;
14006}
14007
14008static bfd_boolean
14009load_specific_debug_section (enum dwarf_section_display_enum debug,
14010 const Elf_Internal_Shdr * sec,
14011 void * data)
14012{
14013 struct dwarf_section * section = &debug_displays [debug].section;
14014 char buf [64];
14015 Filedata * filedata = (Filedata *) data;
14016
14017 if (section->start != NULL)
14018 {
14019 /* If it is already loaded, do nothing. */
14020 if (streq (section->filename, filedata->file_name))
14021 return TRUE;
14022 free (section->start);
14023 }
14024
14025 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
14026 section->address = sec->sh_addr;
14027 section->user_data = NULL;
14028 section->filename = filedata->file_name;
14029 section->start = (unsigned char *) get_data (NULL, filedata,
14030 sec->sh_offset, 1,
14031 sec->sh_size, buf);
14032 if (section->start == NULL)
14033 section->size = 0;
14034 else
14035 {
14036 unsigned char *start = section->start;
14037 dwarf_size_type size = sec->sh_size;
14038 dwarf_size_type uncompressed_size = 0;
14039
14040 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
14041 {
14042 Elf_Internal_Chdr chdr;
14043 unsigned int compression_header_size;
14044
14045 if (size < (is_32bit_elf
14046 ? sizeof (Elf32_External_Chdr)
14047 : sizeof (Elf64_External_Chdr)))
14048 {
14049 warn (_("compressed section %s is too small to contain a compression header"),
14050 section->name);
14051 return FALSE;
14052 }
14053
14054 compression_header_size = get_compression_header (&chdr, start, size);
14055
14056 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
14057 {
14058 warn (_("section '%s' has unsupported compress type: %d\n"),
14059 section->name, chdr.ch_type);
14060 return FALSE;
14061 }
14062 uncompressed_size = chdr.ch_size;
14063 start += compression_header_size;
14064 size -= compression_header_size;
14065 }
14066 else if (size > 12 && streq ((char *) start, "ZLIB"))
14067 {
14068 /* Read the zlib header. In this case, it should be "ZLIB"
14069 followed by the uncompressed section size, 8 bytes in
14070 big-endian order. */
14071 uncompressed_size = start[4]; uncompressed_size <<= 8;
14072 uncompressed_size += start[5]; uncompressed_size <<= 8;
14073 uncompressed_size += start[6]; uncompressed_size <<= 8;
14074 uncompressed_size += start[7]; uncompressed_size <<= 8;
14075 uncompressed_size += start[8]; uncompressed_size <<= 8;
14076 uncompressed_size += start[9]; uncompressed_size <<= 8;
14077 uncompressed_size += start[10]; uncompressed_size <<= 8;
14078 uncompressed_size += start[11];
14079 start += 12;
14080 size -= 12;
14081 }
14082
14083 if (uncompressed_size)
14084 {
14085 if (uncompress_section_contents (&start, uncompressed_size,
14086 &size))
14087 {
14088 /* Free the compressed buffer, update the section buffer
14089 and the section size if uncompress is successful. */
14090 free (section->start);
14091 section->start = start;
14092 }
14093 else
14094 {
14095 error (_("Unable to decompress section %s\n"),
14096 printable_section_name (filedata, sec));
14097 return FALSE;
14098 }
14099 }
14100
14101 section->size = size;
14102 }
14103
14104 if (section->start == NULL)
14105 return FALSE;
14106
14107 if (debug_displays [debug].relocate)
14108 {
14109 if (! apply_relocations (filedata, sec, section->start, section->size,
14110 & section->reloc_info, & section->num_relocs))
14111 return FALSE;
14112 }
14113 else
14114 {
14115 section->reloc_info = NULL;
14116 section->num_relocs = 0;
14117 }
14118
14119 return TRUE;
14120}
14121
14122/* If this is not NULL, load_debug_section will only look for sections
14123 within the list of sections given here. */
14124static unsigned int * section_subset = NULL;
14125
14126bfd_boolean
14127load_debug_section (enum dwarf_section_display_enum debug, void * data)
14128{
14129 struct dwarf_section * section = &debug_displays [debug].section;
14130 Elf_Internal_Shdr * sec;
14131 Filedata * filedata = (Filedata *) data;
14132
14133 /* Without section headers we cannot find any sections. */
14134 if (filedata->section_headers == NULL)
14135 return FALSE;
14136
14137 if (filedata->string_table == NULL
14138 && filedata->file_header.e_shstrndx != SHN_UNDEF
14139 && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
14140 {
14141 Elf_Internal_Shdr * strs;
14142
14143 /* Read in the string table, so that we have section names to scan. */
14144 strs = filedata->section_headers + filedata->file_header.e_shstrndx;
14145
14146 if (strs != NULL && strs->sh_size != 0)
14147 {
14148 filedata->string_table
14149 = (char *) get_data (NULL, filedata, strs->sh_offset,
14150 1, strs->sh_size, _("string table"));
14151
14152 filedata->string_table_length
14153 = filedata->string_table != NULL ? strs->sh_size : 0;
14154 }
14155 }
14156
14157 /* Locate the debug section. */
14158 sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
14159 if (sec != NULL)
14160 section->name = section->uncompressed_name;
14161 else
14162 {
14163 sec = find_section_in_set (filedata, section->compressed_name, section_subset);
14164 if (sec != NULL)
14165 section->name = section->compressed_name;
14166 }
14167 if (sec == NULL)
14168 return FALSE;
14169
14170 /* If we're loading from a subset of sections, and we've loaded
14171 a section matching this name before, it's likely that it's a
14172 different one. */
14173 if (section_subset != NULL)
14174 free_debug_section (debug);
14175
14176 return load_specific_debug_section (debug, sec, data);
14177}
14178
14179void
14180free_debug_section (enum dwarf_section_display_enum debug)
14181{
14182 struct dwarf_section * section = &debug_displays [debug].section;
14183
14184 if (section->start == NULL)
14185 return;
14186
14187 free ((char *) section->start);
14188 section->start = NULL;
14189 section->address = 0;
14190 section->size = 0;
14191}
14192
14193static bfd_boolean
14194display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
14195{
14196 char * name = SECTION_NAME (section);
14197 const char * print_name = printable_section_name (filedata, section);
14198 bfd_size_type length;
14199 bfd_boolean result = TRUE;
14200 int i;
14201
14202 length = section->sh_size;
14203 if (length == 0)
14204 {
14205 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
14206 return TRUE;
14207 }
14208 if (section->sh_type == SHT_NOBITS)
14209 {
14210 /* There is no point in dumping the contents of a debugging section
14211 which has the NOBITS type - the bits in the file will be random.
14212 This can happen when a file containing a .eh_frame section is
14213 stripped with the --only-keep-debug command line option. */
14214 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14215 print_name);
14216 return FALSE;
14217 }
14218
14219 if (const_strneq (name, ".gnu.linkonce.wi."))
14220 name = ".debug_info";
14221
14222 /* See if we know how to display the contents of this section. */
14223 for (i = 0; i < max; i++)
14224 {
14225 enum dwarf_section_display_enum id = (enum dwarf_section_display_enum) i;
14226 struct dwarf_section_display * display = debug_displays + i;
14227 struct dwarf_section * sec = & display->section;
14228
14229 if (streq (sec->uncompressed_name, name)
14230 || (id == line && const_strneq (name, ".debug_line."))
14231 || streq (sec->compressed_name, name))
14232 {
14233 bfd_boolean secondary = (section != find_section (filedata, name));
14234
14235 if (secondary)
14236 free_debug_section (id);
14237
14238 if (i == line && const_strneq (name, ".debug_line."))
14239 sec->name = name;
14240 else if (streq (sec->uncompressed_name, name))
14241 sec->name = sec->uncompressed_name;
14242 else
14243 sec->name = sec->compressed_name;
14244
14245 if (load_specific_debug_section (id, section, filedata))
14246 {
14247 /* If this debug section is part of a CU/TU set in a .dwp file,
14248 restrict load_debug_section to the sections in that set. */
14249 section_subset = find_cu_tu_set (filedata, shndx);
14250
14251 result &= display->display (sec, filedata);
14252
14253 section_subset = NULL;
14254
14255 if (secondary || (id != info && id != abbrev))
14256 free_debug_section (id);
14257 }
14258 break;
14259 }
14260 }
14261
14262 if (i == max)
14263 {
14264 printf (_("Unrecognized debug section: %s\n"), print_name);
14265 result = FALSE;
14266 }
14267
14268 return result;
14269}
14270
14271/* Set DUMP_SECTS for all sections where dumps were requested
14272 based on section name. */
14273
14274static void
14275initialise_dumps_byname (Filedata * filedata)
14276{
14277 struct dump_list_entry * cur;
14278
14279 for (cur = dump_sects_byname; cur; cur = cur->next)
14280 {
14281 unsigned int i;
14282 bfd_boolean any = FALSE;
14283
14284 for (i = 0; i < filedata->file_header.e_shnum; i++)
14285 if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
14286 {
14287 request_dump_bynumber (filedata, i, cur->type);
14288 any = TRUE;
14289 }
14290
14291 if (!any)
14292 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14293 cur->name);
14294 }
14295}
14296
14297static bfd_boolean
14298process_section_contents (Filedata * filedata)
14299{
14300 Elf_Internal_Shdr * section;
14301 unsigned int i;
14302 bfd_boolean res = TRUE;
14303
14304 if (! do_dump)
14305 return TRUE;
14306
14307 initialise_dumps_byname (filedata);
14308
14309 for (i = 0, section = filedata->section_headers;
14310 i < filedata->file_header.e_shnum && i < filedata->num_dump_sects;
14311 i++, section++)
14312 {
14313 dump_type dump = filedata->dump_sects[i];
14314
14315#ifdef SUPPORT_DISASSEMBLY
14316 if (dump & DISASS_DUMP)
14317 {
14318 if (! disassemble_section (section, filedata))
14319 res = FALSE;
14320 }
14321#endif
14322 if (dump & HEX_DUMP)
14323 {
14324 if (! dump_section_as_bytes (section, filedata, FALSE))
14325 res = FALSE;
14326 }
14327
14328 if (dump & RELOC_DUMP)
14329 {
14330 if (! dump_section_as_bytes (section, filedata, TRUE))
14331 res = FALSE;
14332 }
14333
14334 if (dump & STRING_DUMP)
14335 {
14336 if (! dump_section_as_strings (section, filedata))
14337 res = FALSE;
14338 }
14339
14340 if (dump & DEBUG_DUMP)
14341 {
14342 if (! display_debug_section (i, section, filedata))
14343 res = FALSE;
14344 }
14345
14346 if (dump & CTF_DUMP)
14347 {
14348 if (! dump_section_as_ctf (section, filedata))
14349 res = FALSE;
14350 }
14351 }
14352
14353 /* Check to see if the user requested a
14354 dump of a section that does not exist. */
14355 while (i < filedata->num_dump_sects)
14356 {
14357 if (filedata->dump_sects[i])
14358 {
14359 warn (_("Section %d was not dumped because it does not exist!\n"), i);
14360 res = FALSE;
14361 }
14362 i++;
14363 }
14364
14365 return res;
14366}
14367
14368static void
14369process_mips_fpe_exception (int mask)
14370{
14371 if (mask)
14372 {
14373 bfd_boolean first = TRUE;
14374
14375 if (mask & OEX_FPU_INEX)
14376 fputs ("INEX", stdout), first = FALSE;
14377 if (mask & OEX_FPU_UFLO)
14378 printf ("%sUFLO", first ? "" : "|"), first = FALSE;
14379 if (mask & OEX_FPU_OFLO)
14380 printf ("%sOFLO", first ? "" : "|"), first = FALSE;
14381 if (mask & OEX_FPU_DIV0)
14382 printf ("%sDIV0", first ? "" : "|"), first = FALSE;
14383 if (mask & OEX_FPU_INVAL)
14384 printf ("%sINVAL", first ? "" : "|");
14385 }
14386 else
14387 fputs ("0", stdout);
14388}
14389
14390/* Display's the value of TAG at location P. If TAG is
14391 greater than 0 it is assumed to be an unknown tag, and
14392 a message is printed to this effect. Otherwise it is
14393 assumed that a message has already been printed.
14394
14395 If the bottom bit of TAG is set it assumed to have a
14396 string value, otherwise it is assumed to have an integer
14397 value.
14398
14399 Returns an updated P pointing to the first unread byte
14400 beyond the end of TAG's value.
14401
14402 Reads at or beyond END will not be made. */
14403
14404static unsigned char *
14405display_tag_value (signed int tag,
14406 unsigned char * p,
14407 const unsigned char * const end)
14408{
14409 unsigned long val;
14410
14411 if (tag > 0)
14412 printf (" Tag_unknown_%d: ", tag);
14413
14414 if (p >= end)
14415 {
14416 warn (_("<corrupt tag>\n"));
14417 }
14418 else if (tag & 1)
14419 {
14420 /* PR 17531 file: 027-19978-0.004. */
14421 size_t maxlen = (end - p) - 1;
14422
14423 putchar ('"');
14424 if (maxlen > 0)
14425 {
14426 print_symbol ((int) maxlen, (const char *) p);
14427 p += strnlen ((char *) p, maxlen) + 1;
14428 }
14429 else
14430 {
14431 printf (_("<corrupt string tag>"));
14432 p = (unsigned char *) end;
14433 }
14434 printf ("\"\n");
14435 }
14436 else
14437 {
14438 unsigned int len;
14439
14440 val = read_uleb128 (p, &len, end);
14441 p += len;
14442 printf ("%ld (0x%lx)\n", val, val);
14443 }
14444
14445 assert (p <= end);
14446 return p;
14447}
14448
14449/* ARC ABI attributes section. */
14450
14451static unsigned char *
14452display_arc_attribute (unsigned char * p,
14453 const unsigned char * const end)
14454{
14455 unsigned int tag;
14456 unsigned int len;
14457 unsigned int val;
14458
14459 tag = read_uleb128 (p, &len, end);
14460 p += len;
14461
14462 switch (tag)
14463 {
14464 case Tag_ARC_PCS_config:
14465 val = read_uleb128 (p, &len, end);
14466 p += len;
14467 printf (" Tag_ARC_PCS_config: ");
14468 switch (val)
14469 {
14470 case 0:
14471 printf (_("Absent/Non standard\n"));
14472 break;
14473 case 1:
14474 printf (_("Bare metal/mwdt\n"));
14475 break;
14476 case 2:
14477 printf (_("Bare metal/newlib\n"));
14478 break;
14479 case 3:
14480 printf (_("Linux/uclibc\n"));
14481 break;
14482 case 4:
14483 printf (_("Linux/glibc\n"));
14484 break;
14485 default:
14486 printf (_("Unknown\n"));
14487 break;
14488 }
14489 break;
14490
14491 case Tag_ARC_CPU_base:
14492 val = read_uleb128 (p, &len, end);
14493 p += len;
14494 printf (" Tag_ARC_CPU_base: ");
14495 switch (val)
14496 {
14497 default:
14498 case TAG_CPU_NONE:
14499 printf (_("Absent\n"));
14500 break;
14501 case TAG_CPU_ARC6xx:
14502 printf ("ARC6xx\n");
14503 break;
14504 case TAG_CPU_ARC7xx:
14505 printf ("ARC7xx\n");
14506 break;
14507 case TAG_CPU_ARCEM:
14508 printf ("ARCEM\n");
14509 break;
14510 case TAG_CPU_ARCHS:
14511 printf ("ARCHS\n");
14512 break;
14513 }
14514 break;
14515
14516 case Tag_ARC_CPU_variation:
14517 val = read_uleb128 (p, &len, end);
14518 p += len;
14519 printf (" Tag_ARC_CPU_variation: ");
14520 switch (val)
14521 {
14522 default:
14523 if (val > 0 && val < 16)
14524 printf ("Core%d\n", val);
14525 else
14526 printf ("Unknown\n");
14527 break;
14528
14529 case 0:
14530 printf (_("Absent\n"));
14531 break;
14532 }
14533 break;
14534
14535 case Tag_ARC_CPU_name:
14536 printf (" Tag_ARC_CPU_name: ");
14537 p = display_tag_value (-1, p, end);
14538 break;
14539
14540 case Tag_ARC_ABI_rf16:
14541 val = read_uleb128 (p, &len, end);
14542 p += len;
14543 printf (" Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
14544 break;
14545
14546 case Tag_ARC_ABI_osver:
14547 val = read_uleb128 (p, &len, end);
14548 p += len;
14549 printf (" Tag_ARC_ABI_osver: v%d\n", val);
14550 break;
14551
14552 case Tag_ARC_ABI_pic:
14553 case Tag_ARC_ABI_sda:
14554 val = read_uleb128 (p, &len, end);
14555 p += len;
14556 printf (tag == Tag_ARC_ABI_sda ? " Tag_ARC_ABI_sda: "
14557 : " Tag_ARC_ABI_pic: ");
14558 switch (val)
14559 {
14560 case 0:
14561 printf (_("Absent\n"));
14562 break;
14563 case 1:
14564 printf ("MWDT\n");
14565 break;
14566 case 2:
14567 printf ("GNU\n");
14568 break;
14569 default:
14570 printf (_("Unknown\n"));
14571 break;
14572 }
14573 break;
14574
14575 case Tag_ARC_ABI_tls:
14576 val = read_uleb128 (p, &len, end);
14577 p += len;
14578 printf (" Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
14579 break;
14580
14581 case Tag_ARC_ABI_enumsize:
14582 val = read_uleb128 (p, &len, end);
14583 p += len;
14584 printf (" Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
14585 _("smallest"));
14586 break;
14587
14588 case Tag_ARC_ABI_exceptions:
14589 val = read_uleb128 (p, &len, end);
14590 p += len;
14591 printf (" Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
14592 : _("default"));
14593 break;
14594
14595 case Tag_ARC_ABI_double_size:
14596 val = read_uleb128 (p, &len, end);
14597 p += len;
14598 printf (" Tag_ARC_ABI_double_size: %d\n", val);
14599 break;
14600
14601 case Tag_ARC_ISA_config:
14602 printf (" Tag_ARC_ISA_config: ");
14603 p = display_tag_value (-1, p, end);
14604 break;
14605
14606 case Tag_ARC_ISA_apex:
14607 printf (" Tag_ARC_ISA_apex: ");
14608 p = display_tag_value (-1, p, end);
14609 break;
14610
14611 case Tag_ARC_ISA_mpy_option:
14612 val = read_uleb128 (p, &len, end);
14613 p += len;
14614 printf (" Tag_ARC_ISA_mpy_option: %d\n", val);
14615 break;
14616
14617 case Tag_ARC_ATR_version:
14618 val = read_uleb128 (p, &len, end);
14619 p += len;
14620 printf (" Tag_ARC_ATR_version: %d\n", val);
14621 break;
14622
14623 default:
14624 return display_tag_value (tag & 1, p, end);
14625 }
14626
14627 return p;
14628}
14629
14630/* ARM EABI attributes section. */
14631typedef struct
14632{
14633 unsigned int tag;
14634 const char * name;
14635 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14636 unsigned int type;
14637 const char ** table;
14638} arm_attr_public_tag;
14639
14640static const char * arm_attr_tag_CPU_arch[] =
14641 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14642 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14643 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
14644static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
14645static const char * arm_attr_tag_THUMB_ISA_use[] =
14646 {"No", "Thumb-1", "Thumb-2", "Yes"};
14647static const char * arm_attr_tag_FP_arch[] =
14648 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14649 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14650static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
14651static const char * arm_attr_tag_Advanced_SIMD_arch[] =
14652 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14653 "NEON for ARMv8.1"};
14654static const char * arm_attr_tag_PCS_config[] =
14655 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14656 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14657static const char * arm_attr_tag_ABI_PCS_R9_use[] =
14658 {"V6", "SB", "TLS", "Unused"};
14659static const char * arm_attr_tag_ABI_PCS_RW_data[] =
14660 {"Absolute", "PC-relative", "SB-relative", "None"};
14661static const char * arm_attr_tag_ABI_PCS_RO_data[] =
14662 {"Absolute", "PC-relative", "None"};
14663static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
14664 {"None", "direct", "GOT-indirect"};
14665static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
14666 {"None", "??? 1", "2", "??? 3", "4"};
14667static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
14668static const char * arm_attr_tag_ABI_FP_denormal[] =
14669 {"Unused", "Needed", "Sign only"};
14670static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
14671static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
14672static const char * arm_attr_tag_ABI_FP_number_model[] =
14673 {"Unused", "Finite", "RTABI", "IEEE 754"};
14674static const char * arm_attr_tag_ABI_enum_size[] =
14675 {"Unused", "small", "int", "forced to int"};
14676static const char * arm_attr_tag_ABI_HardFP_use[] =
14677 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14678static const char * arm_attr_tag_ABI_VFP_args[] =
14679 {"AAPCS", "VFP registers", "custom", "compatible"};
14680static const char * arm_attr_tag_ABI_WMMX_args[] =
14681 {"AAPCS", "WMMX registers", "custom"};
14682static const char * arm_attr_tag_ABI_optimization_goals[] =
14683 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14684 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14685static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
14686 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14687 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14688static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
14689static const char * arm_attr_tag_FP_HP_extension[] =
14690 {"Not Allowed", "Allowed"};
14691static const char * arm_attr_tag_ABI_FP_16bit_format[] =
14692 {"None", "IEEE 754", "Alternative Format"};
14693static const char * arm_attr_tag_DSP_extension[] =
14694 {"Follow architecture", "Allowed"};
14695static const char * arm_attr_tag_MPextension_use[] =
14696 {"Not Allowed", "Allowed"};
14697static const char * arm_attr_tag_DIV_use[] =
14698 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14699 "Allowed in v7-A with integer division extension"};
14700static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
14701static const char * arm_attr_tag_Virtualization_use[] =
14702 {"Not Allowed", "TrustZone", "Virtualization Extensions",
14703 "TrustZone and Virtualization Extensions"};
14704static const char * arm_attr_tag_MPextension_use_legacy[] =
14705 {"Not Allowed", "Allowed"};
14706
14707static const char * arm_attr_tag_MVE_arch[] =
14708 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
14709
14710#define LOOKUP(id, name) \
14711 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14712static arm_attr_public_tag arm_attr_public_tags[] =
14713{
14714 {4, "CPU_raw_name", 1, NULL},
14715 {5, "CPU_name", 1, NULL},
14716 LOOKUP(6, CPU_arch),
14717 {7, "CPU_arch_profile", 0, NULL},
14718 LOOKUP(8, ARM_ISA_use),
14719 LOOKUP(9, THUMB_ISA_use),
14720 LOOKUP(10, FP_arch),
14721 LOOKUP(11, WMMX_arch),
14722 LOOKUP(12, Advanced_SIMD_arch),
14723 LOOKUP(13, PCS_config),
14724 LOOKUP(14, ABI_PCS_R9_use),
14725 LOOKUP(15, ABI_PCS_RW_data),
14726 LOOKUP(16, ABI_PCS_RO_data),
14727 LOOKUP(17, ABI_PCS_GOT_use),
14728 LOOKUP(18, ABI_PCS_wchar_t),
14729 LOOKUP(19, ABI_FP_rounding),
14730 LOOKUP(20, ABI_FP_denormal),
14731 LOOKUP(21, ABI_FP_exceptions),
14732 LOOKUP(22, ABI_FP_user_exceptions),
14733 LOOKUP(23, ABI_FP_number_model),
14734 {24, "ABI_align_needed", 0, NULL},
14735 {25, "ABI_align_preserved", 0, NULL},
14736 LOOKUP(26, ABI_enum_size),
14737 LOOKUP(27, ABI_HardFP_use),
14738 LOOKUP(28, ABI_VFP_args),
14739 LOOKUP(29, ABI_WMMX_args),
14740 LOOKUP(30, ABI_optimization_goals),
14741 LOOKUP(31, ABI_FP_optimization_goals),
14742 {32, "compatibility", 0, NULL},
14743 LOOKUP(34, CPU_unaligned_access),
14744 LOOKUP(36, FP_HP_extension),
14745 LOOKUP(38, ABI_FP_16bit_format),
14746 LOOKUP(42, MPextension_use),
14747 LOOKUP(44, DIV_use),
14748 LOOKUP(46, DSP_extension),
14749 LOOKUP(48, MVE_arch),
14750 {64, "nodefaults", 0, NULL},
14751 {65, "also_compatible_with", 0, NULL},
14752 LOOKUP(66, T2EE_use),
14753 {67, "conformance", 1, NULL},
14754 LOOKUP(68, Virtualization_use),
14755 LOOKUP(70, MPextension_use_legacy)
14756};
14757#undef LOOKUP
14758
14759static unsigned char *
14760display_arm_attribute (unsigned char * p,
14761 const unsigned char * const end)
14762{
14763 unsigned int tag;
14764 unsigned int len;
14765 unsigned int val;
14766 arm_attr_public_tag * attr;
14767 unsigned i;
14768 unsigned int type;
14769
14770 tag = read_uleb128 (p, &len, end);
14771 p += len;
14772 attr = NULL;
14773 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
14774 {
14775 if (arm_attr_public_tags[i].tag == tag)
14776 {
14777 attr = &arm_attr_public_tags[i];
14778 break;
14779 }
14780 }
14781
14782 if (attr)
14783 {
14784 printf (" Tag_%s: ", attr->name);
14785 switch (attr->type)
14786 {
14787 case 0:
14788 switch (tag)
14789 {
14790 case 7: /* Tag_CPU_arch_profile. */
14791 val = read_uleb128 (p, &len, end);
14792 p += len;
14793 switch (val)
14794 {
14795 case 0: printf (_("None\n")); break;
14796 case 'A': printf (_("Application\n")); break;
14797 case 'R': printf (_("Realtime\n")); break;
14798 case 'M': printf (_("Microcontroller\n")); break;
14799 case 'S': printf (_("Application or Realtime\n")); break;
14800 default: printf ("??? (%d)\n", val); break;
14801 }
14802 break;
14803
14804 case 24: /* Tag_align_needed. */
14805 val = read_uleb128 (p, &len, end);
14806 p += len;
14807 switch (val)
14808 {
14809 case 0: printf (_("None\n")); break;
14810 case 1: printf (_("8-byte\n")); break;
14811 case 2: printf (_("4-byte\n")); break;
14812 case 3: printf ("??? 3\n"); break;
14813 default:
14814 if (val <= 12)
14815 printf (_("8-byte and up to %d-byte extended\n"),
14816 1 << val);
14817 else
14818 printf ("??? (%d)\n", val);
14819 break;
14820 }
14821 break;
14822
14823 case 25: /* Tag_align_preserved. */
14824 val = read_uleb128 (p, &len, end);
14825 p += len;
14826 switch (val)
14827 {
14828 case 0: printf (_("None\n")); break;
14829 case 1: printf (_("8-byte, except leaf SP\n")); break;
14830 case 2: printf (_("8-byte\n")); break;
14831 case 3: printf ("??? 3\n"); break;
14832 default:
14833 if (val <= 12)
14834 printf (_("8-byte and up to %d-byte extended\n"),
14835 1 << val);
14836 else
14837 printf ("??? (%d)\n", val);
14838 break;
14839 }
14840 break;
14841
14842 case 32: /* Tag_compatibility. */
14843 {
14844 val = read_uleb128 (p, &len, end);
14845 p += len;
14846 printf (_("flag = %d, vendor = "), val);
14847 if (p < end - 1)
14848 {
14849 size_t maxlen = (end - p) - 1;
14850
14851 print_symbol ((int) maxlen, (const char *) p);
14852 p += strnlen ((char *) p, maxlen) + 1;
14853 }
14854 else
14855 {
14856 printf (_("<corrupt>"));
14857 p = (unsigned char *) end;
14858 }
14859 putchar ('\n');
14860 }
14861 break;
14862
14863 case 64: /* Tag_nodefaults. */
14864 /* PR 17531: file: 001-505008-0.01. */
14865 if (p < end)
14866 p++;
14867 printf (_("True\n"));
14868 break;
14869
14870 case 65: /* Tag_also_compatible_with. */
14871 val = read_uleb128 (p, &len, end);
14872 p += len;
14873 if (val == 6 /* Tag_CPU_arch. */)
14874 {
14875 val = read_uleb128 (p, &len, end);
14876 p += len;
14877 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
14878 printf ("??? (%d)\n", val);
14879 else
14880 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
14881 }
14882 else
14883 printf ("???\n");
14884 while (p < end && *(p++) != '\0' /* NUL terminator. */)
14885 ;
14886 break;
14887
14888 default:
14889 printf (_("<unknown: %d>\n"), tag);
14890 break;
14891 }
14892 return p;
14893
14894 case 1:
14895 return display_tag_value (-1, p, end);
14896 case 2:
14897 return display_tag_value (0, p, end);
14898
14899 default:
14900 assert (attr->type & 0x80);
14901 val = read_uleb128 (p, &len, end);
14902 p += len;
14903 type = attr->type & 0x7f;
14904 if (val >= type)
14905 printf ("??? (%d)\n", val);
14906 else
14907 printf ("%s\n", attr->table[val]);
14908 return p;
14909 }
14910 }
14911
14912 return display_tag_value (tag, p, end);
14913}
14914
14915static unsigned char *
14916display_gnu_attribute (unsigned char * p,
14917 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
14918 const unsigned char * const end)
14919{
14920 int tag;
14921 unsigned int len;
14922 unsigned int val;
14923
14924 tag = read_uleb128 (p, &len, end);
14925 p += len;
14926
14927 /* Tag_compatibility is the only generic GNU attribute defined at
14928 present. */
14929 if (tag == 32)
14930 {
14931 val = read_uleb128 (p, &len, end);
14932 p += len;
14933
14934 printf (_("flag = %d, vendor = "), val);
14935 if (p == end)
14936 {
14937 printf (_("<corrupt>\n"));
14938 warn (_("corrupt vendor attribute\n"));
14939 }
14940 else
14941 {
14942 if (p < end - 1)
14943 {
14944 size_t maxlen = (end - p) - 1;
14945
14946 print_symbol ((int) maxlen, (const char *) p);
14947 p += strnlen ((char *) p, maxlen) + 1;
14948 }
14949 else
14950 {
14951 printf (_("<corrupt>"));
14952 p = (unsigned char *) end;
14953 }
14954 putchar ('\n');
14955 }
14956 return p;
14957 }
14958
14959 if ((tag & 2) == 0 && display_proc_gnu_attribute)
14960 return display_proc_gnu_attribute (p, tag, end);
14961
14962 return display_tag_value (tag, p, end);
14963}
14964
14965static unsigned char *
14966display_power_gnu_attribute (unsigned char * p,
14967 unsigned int tag,
14968 const unsigned char * const end)
14969{
14970 unsigned int len;
14971 unsigned int val;
14972
14973 if (tag == Tag_GNU_Power_ABI_FP)
14974 {
14975 val = read_uleb128 (p, &len, end);
14976 p += len;
14977 printf (" Tag_GNU_Power_ABI_FP: ");
14978 if (len == 0)
14979 {
14980 printf (_("<corrupt>\n"));
14981 return p;
14982 }
14983
14984 if (val > 15)
14985 printf ("(%#x), ", val);
14986
14987 switch (val & 3)
14988 {
14989 case 0:
14990 printf (_("unspecified hard/soft float, "));
14991 break;
14992 case 1:
14993 printf (_("hard float, "));
14994 break;
14995 case 2:
14996 printf (_("soft float, "));
14997 break;
14998 case 3:
14999 printf (_("single-precision hard float, "));
15000 break;
15001 }
15002
15003 switch (val & 0xC)
15004 {
15005 case 0:
15006 printf (_("unspecified long double\n"));
15007 break;
15008 case 4:
15009 printf (_("128-bit IBM long double\n"));
15010 break;
15011 case 8:
15012 printf (_("64-bit long double\n"));
15013 break;
15014 case 12:
15015 printf (_("128-bit IEEE long double\n"));
15016 break;
15017 }
15018 return p;
15019 }
15020
15021 if (tag == Tag_GNU_Power_ABI_Vector)
15022 {
15023 val = read_uleb128 (p, &len, end);
15024 p += len;
15025 printf (" Tag_GNU_Power_ABI_Vector: ");
15026 if (len == 0)
15027 {
15028 printf (_("<corrupt>\n"));
15029 return p;
15030 }
15031
15032 if (val > 3)
15033 printf ("(%#x), ", val);
15034
15035 switch (val & 3)
15036 {
15037 case 0:
15038 printf (_("unspecified\n"));
15039 break;
15040 case 1:
15041 printf (_("generic\n"));
15042 break;
15043 case 2:
15044 printf ("AltiVec\n");
15045 break;
15046 case 3:
15047 printf ("SPE\n");
15048 break;
15049 }
15050 return p;
15051 }
15052
15053 if (tag == Tag_GNU_Power_ABI_Struct_Return)
15054 {
15055 val = read_uleb128 (p, &len, end);
15056 p += len;
15057 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15058 if (len == 0)
15059 {
15060 printf (_("<corrupt>\n"));
15061 return p;
15062 }
15063
15064 if (val > 2)
15065 printf ("(%#x), ", val);
15066
15067 switch (val & 3)
15068 {
15069 case 0:
15070 printf (_("unspecified\n"));
15071 break;
15072 case 1:
15073 printf ("r3/r4\n");
15074 break;
15075 case 2:
15076 printf (_("memory\n"));
15077 break;
15078 case 3:
15079 printf ("???\n");
15080 break;
15081 }
15082 return p;
15083 }
15084
15085 return display_tag_value (tag & 1, p, end);
15086}
15087
15088static unsigned char *
15089display_s390_gnu_attribute (unsigned char * p,
15090 unsigned int tag,
15091 const unsigned char * const end)
15092{
15093 unsigned int len;
15094 int val;
15095
15096 if (tag == Tag_GNU_S390_ABI_Vector)
15097 {
15098 val = read_uleb128 (p, &len, end);
15099 p += len;
15100 printf (" Tag_GNU_S390_ABI_Vector: ");
15101
15102 switch (val)
15103 {
15104 case 0:
15105 printf (_("any\n"));
15106 break;
15107 case 1:
15108 printf (_("software\n"));
15109 break;
15110 case 2:
15111 printf (_("hardware\n"));
15112 break;
15113 default:
15114 printf ("??? (%d)\n", val);
15115 break;
15116 }
15117 return p;
15118 }
15119
15120 return display_tag_value (tag & 1, p, end);
15121}
15122
15123static void
15124display_sparc_hwcaps (unsigned int mask)
15125{
15126 if (mask)
15127 {
15128 bfd_boolean first = TRUE;
15129
15130 if (mask & ELF_SPARC_HWCAP_MUL32)
15131 fputs ("mul32", stdout), first = FALSE;
15132 if (mask & ELF_SPARC_HWCAP_DIV32)
15133 printf ("%sdiv32", first ? "" : "|"), first = FALSE;
15134 if (mask & ELF_SPARC_HWCAP_FSMULD)
15135 printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
15136 if (mask & ELF_SPARC_HWCAP_V8PLUS)
15137 printf ("%sv8plus", first ? "" : "|"), first = FALSE;
15138 if (mask & ELF_SPARC_HWCAP_POPC)
15139 printf ("%spopc", first ? "" : "|"), first = FALSE;
15140 if (mask & ELF_SPARC_HWCAP_VIS)
15141 printf ("%svis", first ? "" : "|"), first = FALSE;
15142 if (mask & ELF_SPARC_HWCAP_VIS2)
15143 printf ("%svis2", first ? "" : "|"), first = FALSE;
15144 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
15145 printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
15146 if (mask & ELF_SPARC_HWCAP_FMAF)
15147 printf ("%sfmaf", first ? "" : "|"), first = FALSE;
15148 if (mask & ELF_SPARC_HWCAP_VIS3)
15149 printf ("%svis3", first ? "" : "|"), first = FALSE;
15150 if (mask & ELF_SPARC_HWCAP_HPC)
15151 printf ("%shpc", first ? "" : "|"), first = FALSE;
15152 if (mask & ELF_SPARC_HWCAP_RANDOM)
15153 printf ("%srandom", first ? "" : "|"), first = FALSE;
15154 if (mask & ELF_SPARC_HWCAP_TRANS)
15155 printf ("%strans", first ? "" : "|"), first = FALSE;
15156 if (mask & ELF_SPARC_HWCAP_FJFMAU)
15157 printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
15158 if (mask & ELF_SPARC_HWCAP_IMA)
15159 printf ("%sima", first ? "" : "|"), first = FALSE;
15160 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
15161 printf ("%scspare", first ? "" : "|"), first = FALSE;
15162 }
15163 else
15164 fputc ('0', stdout);
15165 fputc ('\n', stdout);
15166}
15167
15168static void
15169display_sparc_hwcaps2 (unsigned int mask)
15170{
15171 if (mask)
15172 {
15173 bfd_boolean first = TRUE;
15174
15175 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
15176 fputs ("fjathplus", stdout), first = FALSE;
15177 if (mask & ELF_SPARC_HWCAP2_VIS3B)
15178 printf ("%svis3b", first ? "" : "|"), first = FALSE;
15179 if (mask & ELF_SPARC_HWCAP2_ADP)
15180 printf ("%sadp", first ? "" : "|"), first = FALSE;
15181 if (mask & ELF_SPARC_HWCAP2_SPARC5)
15182 printf ("%ssparc5", first ? "" : "|"), first = FALSE;
15183 if (mask & ELF_SPARC_HWCAP2_MWAIT)
15184 printf ("%smwait", first ? "" : "|"), first = FALSE;
15185 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
15186 printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
15187 if (mask & ELF_SPARC_HWCAP2_XMONT)
15188 printf ("%sxmont2", first ? "" : "|"), first = FALSE;
15189 if (mask & ELF_SPARC_HWCAP2_NSEC)
15190 printf ("%snsec", first ? "" : "|"), first = FALSE;
15191 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
15192 printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
15193 if (mask & ELF_SPARC_HWCAP2_FJDES)
15194 printf ("%sfjdes", first ? "" : "|"), first = FALSE;
15195 if (mask & ELF_SPARC_HWCAP2_FJAES)
15196 printf ("%sfjaes", first ? "" : "|"), first = FALSE;
15197 }
15198 else
15199 fputc ('0', stdout);
15200 fputc ('\n', stdout);
15201}
15202
15203static unsigned char *
15204display_sparc_gnu_attribute (unsigned char * p,
15205 unsigned int tag,
15206 const unsigned char * const end)
15207{
15208 unsigned int len;
15209 int val;
15210
15211 if (tag == Tag_GNU_Sparc_HWCAPS)
15212 {
15213 val = read_uleb128 (p, &len, end);
15214 p += len;
15215 printf (" Tag_GNU_Sparc_HWCAPS: ");
15216 display_sparc_hwcaps (val);
15217 return p;
15218 }
15219 if (tag == Tag_GNU_Sparc_HWCAPS2)
15220 {
15221 val = read_uleb128 (p, &len, end);
15222 p += len;
15223 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15224 display_sparc_hwcaps2 (val);
15225 return p;
15226 }
15227
15228 return display_tag_value (tag, p, end);
15229}
15230
15231static void
15232print_mips_fp_abi_value (unsigned int val)
15233{
15234 switch (val)
15235 {
15236 case Val_GNU_MIPS_ABI_FP_ANY:
15237 printf (_("Hard or soft float\n"));
15238 break;
15239 case Val_GNU_MIPS_ABI_FP_DOUBLE:
15240 printf (_("Hard float (double precision)\n"));
15241 break;
15242 case Val_GNU_MIPS_ABI_FP_SINGLE:
15243 printf (_("Hard float (single precision)\n"));
15244 break;
15245 case Val_GNU_MIPS_ABI_FP_SOFT:
15246 printf (_("Soft float\n"));
15247 break;
15248 case Val_GNU_MIPS_ABI_FP_OLD_64:
15249 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15250 break;
15251 case Val_GNU_MIPS_ABI_FP_XX:
15252 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15253 break;
15254 case Val_GNU_MIPS_ABI_FP_64:
15255 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15256 break;
15257 case Val_GNU_MIPS_ABI_FP_64A:
15258 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15259 break;
15260 case Val_GNU_MIPS_ABI_FP_NAN2008:
15261 printf (_("NaN 2008 compatibility\n"));
15262 break;
15263 default:
15264 printf ("??? (%d)\n", val);
15265 break;
15266 }
15267}
15268
15269static unsigned char *
15270display_mips_gnu_attribute (unsigned char * p,
15271 unsigned int tag,
15272 const unsigned char * const end)
15273{
15274 if (tag == Tag_GNU_MIPS_ABI_FP)
15275 {
15276 unsigned int len;
15277 unsigned int val;
15278
15279 val = read_uleb128 (p, &len, end);
15280 p += len;
15281 printf (" Tag_GNU_MIPS_ABI_FP: ");
15282
15283 print_mips_fp_abi_value (val);
15284
15285 return p;
15286 }
15287
15288 if (tag == Tag_GNU_MIPS_ABI_MSA)
15289 {
15290 unsigned int len;
15291 unsigned int val;
15292
15293 val = read_uleb128 (p, &len, end);
15294 p += len;
15295 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15296
15297 switch (val)
15298 {
15299 case Val_GNU_MIPS_ABI_MSA_ANY:
15300 printf (_("Any MSA or not\n"));
15301 break;
15302 case Val_GNU_MIPS_ABI_MSA_128:
15303 printf (_("128-bit MSA\n"));
15304 break;
15305 default:
15306 printf ("??? (%d)\n", val);
15307 break;
15308 }
15309 return p;
15310 }
15311
15312 return display_tag_value (tag & 1, p, end);
15313}
15314
15315static unsigned char *
15316display_tic6x_attribute (unsigned char * p,
15317 const unsigned char * const end)
15318{
15319 unsigned int tag;
15320 unsigned int len;
15321 int val;
15322
15323 tag = read_uleb128 (p, &len, end);
15324 p += len;
15325
15326 switch (tag)
15327 {
15328 case Tag_ISA:
15329 val = read_uleb128 (p, &len, end);
15330 p += len;
15331 printf (" Tag_ISA: ");
15332
15333 switch (val)
15334 {
15335 case C6XABI_Tag_ISA_none:
15336 printf (_("None\n"));
15337 break;
15338 case C6XABI_Tag_ISA_C62X:
15339 printf ("C62x\n");
15340 break;
15341 case C6XABI_Tag_ISA_C67X:
15342 printf ("C67x\n");
15343 break;
15344 case C6XABI_Tag_ISA_C67XP:
15345 printf ("C67x+\n");
15346 break;
15347 case C6XABI_Tag_ISA_C64X:
15348 printf ("C64x\n");
15349 break;
15350 case C6XABI_Tag_ISA_C64XP:
15351 printf ("C64x+\n");
15352 break;
15353 case C6XABI_Tag_ISA_C674X:
15354 printf ("C674x\n");
15355 break;
15356 default:
15357 printf ("??? (%d)\n", val);
15358 break;
15359 }
15360 return p;
15361
15362 case Tag_ABI_wchar_t:
15363 val = read_uleb128 (p, &len, end);
15364 p += len;
15365 printf (" Tag_ABI_wchar_t: ");
15366 switch (val)
15367 {
15368 case 0:
15369 printf (_("Not used\n"));
15370 break;
15371 case 1:
15372 printf (_("2 bytes\n"));
15373 break;
15374 case 2:
15375 printf (_("4 bytes\n"));
15376 break;
15377 default:
15378 printf ("??? (%d)\n", val);
15379 break;
15380 }
15381 return p;
15382
15383 case Tag_ABI_stack_align_needed:
15384 val = read_uleb128 (p, &len, end);
15385 p += len;
15386 printf (" Tag_ABI_stack_align_needed: ");
15387 switch (val)
15388 {
15389 case 0:
15390 printf (_("8-byte\n"));
15391 break;
15392 case 1:
15393 printf (_("16-byte\n"));
15394 break;
15395 default:
15396 printf ("??? (%d)\n", val);
15397 break;
15398 }
15399 return p;
15400
15401 case Tag_ABI_stack_align_preserved:
15402 val = read_uleb128 (p, &len, end);
15403 p += len;
15404 printf (" Tag_ABI_stack_align_preserved: ");
15405 switch (val)
15406 {
15407 case 0:
15408 printf (_("8-byte\n"));
15409 break;
15410 case 1:
15411 printf (_("16-byte\n"));
15412 break;
15413 default:
15414 printf ("??? (%d)\n", val);
15415 break;
15416 }
15417 return p;
15418
15419 case Tag_ABI_DSBT:
15420 val = read_uleb128 (p, &len, end);
15421 p += len;
15422 printf (" Tag_ABI_DSBT: ");
15423 switch (val)
15424 {
15425 case 0:
15426 printf (_("DSBT addressing not used\n"));
15427 break;
15428 case 1:
15429 printf (_("DSBT addressing used\n"));
15430 break;
15431 default:
15432 printf ("??? (%d)\n", val);
15433 break;
15434 }
15435 return p;
15436
15437 case Tag_ABI_PID:
15438 val = read_uleb128 (p, &len, end);
15439 p += len;
15440 printf (" Tag_ABI_PID: ");
15441 switch (val)
15442 {
15443 case 0:
15444 printf (_("Data addressing position-dependent\n"));
15445 break;
15446 case 1:
15447 printf (_("Data addressing position-independent, GOT near DP\n"));
15448 break;
15449 case 2:
15450 printf (_("Data addressing position-independent, GOT far from DP\n"));
15451 break;
15452 default:
15453 printf ("??? (%d)\n", val);
15454 break;
15455 }
15456 return p;
15457
15458 case Tag_ABI_PIC:
15459 val = read_uleb128 (p, &len, end);
15460 p += len;
15461 printf (" Tag_ABI_PIC: ");
15462 switch (val)
15463 {
15464 case 0:
15465 printf (_("Code addressing position-dependent\n"));
15466 break;
15467 case 1:
15468 printf (_("Code addressing position-independent\n"));
15469 break;
15470 default:
15471 printf ("??? (%d)\n", val);
15472 break;
15473 }
15474 return p;
15475
15476 case Tag_ABI_array_object_alignment:
15477 val = read_uleb128 (p, &len, end);
15478 p += len;
15479 printf (" Tag_ABI_array_object_alignment: ");
15480 switch (val)
15481 {
15482 case 0:
15483 printf (_("8-byte\n"));
15484 break;
15485 case 1:
15486 printf (_("4-byte\n"));
15487 break;
15488 case 2:
15489 printf (_("16-byte\n"));
15490 break;
15491 default:
15492 printf ("??? (%d)\n", val);
15493 break;
15494 }
15495 return p;
15496
15497 case Tag_ABI_array_object_align_expected:
15498 val = read_uleb128 (p, &len, end);
15499 p += len;
15500 printf (" Tag_ABI_array_object_align_expected: ");
15501 switch (val)
15502 {
15503 case 0:
15504 printf (_("8-byte\n"));
15505 break;
15506 case 1:
15507 printf (_("4-byte\n"));
15508 break;
15509 case 2:
15510 printf (_("16-byte\n"));
15511 break;
15512 default:
15513 printf ("??? (%d)\n", val);
15514 break;
15515 }
15516 return p;
15517
15518 case Tag_ABI_compatibility:
15519 {
15520 val = read_uleb128 (p, &len, end);
15521 p += len;
15522 printf (" Tag_ABI_compatibility: ");
15523 printf (_("flag = %d, vendor = "), val);
15524 if (p < end - 1)
15525 {
15526 size_t maxlen = (end - p) - 1;
15527
15528 print_symbol ((int) maxlen, (const char *) p);
15529 p += strnlen ((char *) p, maxlen) + 1;
15530 }
15531 else
15532 {
15533 printf (_("<corrupt>"));
15534 p = (unsigned char *) end;
15535 }
15536 putchar ('\n');
15537 return p;
15538 }
15539
15540 case Tag_ABI_conformance:
15541 {
15542 printf (" Tag_ABI_conformance: \"");
15543 if (p < end - 1)
15544 {
15545 size_t maxlen = (end - p) - 1;
15546
15547 print_symbol ((int) maxlen, (const char *) p);
15548 p += strnlen ((char *) p, maxlen) + 1;
15549 }
15550 else
15551 {
15552 printf (_("<corrupt>"));
15553 p = (unsigned char *) end;
15554 }
15555 printf ("\"\n");
15556 return p;
15557 }
15558 }
15559
15560 return display_tag_value (tag, p, end);
15561}
15562
15563static void
15564display_raw_attribute (unsigned char * p, unsigned char const * const end)
15565{
15566 unsigned long addr = 0;
15567 size_t bytes = end - p;
15568
15569 assert (end >= p);
15570 while (bytes)
15571 {
15572 int j;
15573 int k;
15574 int lbytes = (bytes > 16 ? 16 : bytes);
15575
15576 printf (" 0x%8.8lx ", addr);
15577
15578 for (j = 0; j < 16; j++)
15579 {
15580 if (j < lbytes)
15581 printf ("%2.2x", p[j]);
15582 else
15583 printf (" ");
15584
15585 if ((j & 3) == 3)
15586 printf (" ");
15587 }
15588
15589 for (j = 0; j < lbytes; j++)
15590 {
15591 k = p[j];
15592 if (k >= ' ' && k < 0x7f)
15593 printf ("%c", k);
15594 else
15595 printf (".");
15596 }
15597
15598 putchar ('\n');
15599
15600 p += lbytes;
15601 bytes -= lbytes;
15602 addr += lbytes;
15603 }
15604
15605 putchar ('\n');
15606}
15607
15608static unsigned char *
15609display_msp430x_attribute (unsigned char * p,
15610 const unsigned char * const end)
15611{
15612 unsigned int len;
15613 unsigned int val;
15614 unsigned int tag;
15615
15616 tag = read_uleb128 (p, & len, end);
15617 p += len;
15618
15619 switch (tag)
15620 {
15621 case OFBA_MSPABI_Tag_ISA:
15622 val = read_uleb128 (p, &len, end);
15623 p += len;
15624 printf (" Tag_ISA: ");
15625 switch (val)
15626 {
15627 case 0: printf (_("None\n")); break;
15628 case 1: printf (_("MSP430\n")); break;
15629 case 2: printf (_("MSP430X\n")); break;
15630 default: printf ("??? (%d)\n", val); break;
15631 }
15632 break;
15633
15634 case OFBA_MSPABI_Tag_Code_Model:
15635 val = read_uleb128 (p, &len, end);
15636 p += len;
15637 printf (" Tag_Code_Model: ");
15638 switch (val)
15639 {
15640 case 0: printf (_("None\n")); break;
15641 case 1: printf (_("Small\n")); break;
15642 case 2: printf (_("Large\n")); break;
15643 default: printf ("??? (%d)\n", val); break;
15644 }
15645 break;
15646
15647 case OFBA_MSPABI_Tag_Data_Model:
15648 val = read_uleb128 (p, &len, end);
15649 p += len;
15650 printf (" Tag_Data_Model: ");
15651 switch (val)
15652 {
15653 case 0: printf (_("None\n")); break;
15654 case 1: printf (_("Small\n")); break;
15655 case 2: printf (_("Large\n")); break;
15656 case 3: printf (_("Restricted Large\n")); break;
15657 default: printf ("??? (%d)\n", val); break;
15658 }
15659 break;
15660
15661 default:
15662 printf (_(" <unknown tag %d>: "), tag);
15663
15664 if (tag & 1)
15665 {
15666 putchar ('"');
15667 if (p < end - 1)
15668 {
15669 size_t maxlen = (end - p) - 1;
15670
15671 print_symbol ((int) maxlen, (const char *) p);
15672 p += strnlen ((char *) p, maxlen) + 1;
15673 }
15674 else
15675 {
15676 printf (_("<corrupt>"));
15677 p = (unsigned char *) end;
15678 }
15679 printf ("\"\n");
15680 }
15681 else
15682 {
15683 val = read_uleb128 (p, &len, end);
15684 p += len;
15685 printf ("%d (0x%x)\n", val, val);
15686 }
15687 break;
15688 }
15689
15690 assert (p <= end);
15691 return p;
15692}
15693
15694struct riscv_attr_tag_t {
15695 const char *name;
15696 int tag;
15697};
15698
15699static struct riscv_attr_tag_t riscv_attr_tag[] =
15700{
15701#define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
15702 T(arch),
15703 T(priv_spec),
15704 T(priv_spec_minor),
15705 T(priv_spec_revision),
15706 T(unaligned_access),
15707 T(stack_align),
15708#undef T
15709};
15710
15711static unsigned char *
15712display_riscv_attribute (unsigned char *p,
15713 const unsigned char * const end)
15714{
15715 unsigned int len;
15716 int val;
15717 int tag;
15718 struct riscv_attr_tag_t *attr = NULL;
15719 unsigned i;
15720
15721 tag = read_uleb128 (p, &len, end);
15722 p += len;
15723
15724 /* Find the name of attribute. */
15725 for (i = 0; i < ARRAY_SIZE (riscv_attr_tag); i++)
15726 {
15727 if (riscv_attr_tag[i].tag == tag)
15728 {
15729 attr = &riscv_attr_tag[i];
15730 break;
15731 }
15732 }
15733
15734 if (attr)
15735 printf (" %s: ", attr->name);
15736 else
15737 return display_tag_value (tag, p, end);
15738
15739 switch (tag)
15740 {
15741 case Tag_RISCV_priv_spec:
15742 case Tag_RISCV_priv_spec_minor:
15743 case Tag_RISCV_priv_spec_revision:
15744 val = read_uleb128 (p, &len, end);
15745 p += len;
15746 printf (_("%d\n"), val);
15747 break;
15748 case Tag_RISCV_unaligned_access:
15749 val = read_uleb128 (p, &len, end);
15750 p += len;
15751 switch (val)
15752 {
15753 case 0:
15754 printf (_("No unaligned access\n"));
15755 break;
15756 case 1:
15757 printf (_("Unaligned access\n"));
15758 break;
15759 }
15760 break;
15761 case Tag_RISCV_stack_align:
15762 val = read_uleb128 (p, &len, end);
15763 p += len;
15764 printf (_("%d-bytes\n"), val);
15765 break;
15766 case Tag_RISCV_arch:
15767 p = display_tag_value (-1, p, end);
15768 break;
15769 default:
15770 return display_tag_value (tag, p, end);
15771 }
15772
15773 return p;
15774}
15775
15776static bfd_boolean
15777process_attributes (Filedata * filedata,
15778 const char * public_name,
15779 unsigned int proc_type,
15780 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
15781 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
15782{
15783 Elf_Internal_Shdr * sect;
15784 unsigned i;
15785 bfd_boolean res = TRUE;
15786
15787 /* Find the section header so that we get the size. */
15788 for (i = 0, sect = filedata->section_headers;
15789 i < filedata->file_header.e_shnum;
15790 i++, sect++)
15791 {
15792 unsigned char * contents;
15793 unsigned char * p;
15794
15795 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
15796 continue;
15797
15798 contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
15799 sect->sh_size, _("attributes"));
15800 if (contents == NULL)
15801 {
15802 res = FALSE;
15803 continue;
15804 }
15805
15806 p = contents;
15807 /* The first character is the version of the attributes.
15808 Currently only version 1, (aka 'A') is recognised here. */
15809 if (*p != 'A')
15810 {
15811 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
15812 res = FALSE;
15813 }
15814 else
15815 {
15816 bfd_vma section_len;
15817
15818 section_len = sect->sh_size - 1;
15819 p++;
15820
15821 while (section_len > 0)
15822 {
15823 bfd_vma attr_len;
15824 unsigned int namelen;
15825 bfd_boolean public_section;
15826 bfd_boolean gnu_section;
15827
15828 if (section_len <= 4)
15829 {
15830 error (_("Tag section ends prematurely\n"));
15831 res = FALSE;
15832 break;
15833 }
15834 attr_len = byte_get (p, 4);
15835 p += 4;
15836
15837 if (attr_len > section_len)
15838 {
15839 error (_("Bad attribute length (%u > %u)\n"),
15840 (unsigned) attr_len, (unsigned) section_len);
15841 attr_len = section_len;
15842 res = FALSE;
15843 }
15844 /* PR 17531: file: 001-101425-0.004 */
15845 else if (attr_len < 5)
15846 {
15847 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
15848 res = FALSE;
15849 break;
15850 }
15851
15852 section_len -= attr_len;
15853 attr_len -= 4;
15854
15855 namelen = strnlen ((char *) p, attr_len) + 1;
15856 if (namelen == 0 || namelen >= attr_len)
15857 {
15858 error (_("Corrupt attribute section name\n"));
15859 res = FALSE;
15860 break;
15861 }
15862
15863 printf (_("Attribute Section: "));
15864 print_symbol (INT_MAX, (const char *) p);
15865 putchar ('\n');
15866
15867 if (public_name && streq ((char *) p, public_name))
15868 public_section = TRUE;
15869 else
15870 public_section = FALSE;
15871
15872 if (streq ((char *) p, "gnu"))
15873 gnu_section = TRUE;
15874 else
15875 gnu_section = FALSE;
15876
15877 p += namelen;
15878 attr_len -= namelen;
15879
15880 while (attr_len > 0 && p < contents + sect->sh_size)
15881 {
15882 int tag;
15883 int val;
15884 bfd_vma size;
15885 unsigned char * end;
15886
15887 /* PR binutils/17531: Safe handling of corrupt files. */
15888 if (attr_len < 6)
15889 {
15890 error (_("Unused bytes at end of section\n"));
15891 res = FALSE;
15892 section_len = 0;
15893 break;
15894 }
15895
15896 tag = *(p++);
15897 size = byte_get (p, 4);
15898 if (size > attr_len)
15899 {
15900 error (_("Bad subsection length (%u > %u)\n"),
15901 (unsigned) size, (unsigned) attr_len);
15902 res = FALSE;
15903 size = attr_len;
15904 }
15905 /* PR binutils/17531: Safe handling of corrupt files. */
15906 if (size < 6)
15907 {
15908 error (_("Bad subsection length (%u < 6)\n"),
15909 (unsigned) size);
15910 res = FALSE;
15911 section_len = 0;
15912 break;
15913 }
15914
15915 attr_len -= size;
15916 end = p + size - 1;
15917 assert (end <= contents + sect->sh_size);
15918 p += 4;
15919
15920 switch (tag)
15921 {
15922 case 1:
15923 printf (_("File Attributes\n"));
15924 break;
15925 case 2:
15926 printf (_("Section Attributes:"));
15927 goto do_numlist;
15928 case 3:
15929 printf (_("Symbol Attributes:"));
15930 /* Fall through. */
15931 do_numlist:
15932 for (;;)
15933 {
15934 unsigned int j;
15935
15936 val = read_uleb128 (p, &j, end);
15937 p += j;
15938 if (val == 0)
15939 break;
15940 printf (" %d", val);
15941 }
15942 printf ("\n");
15943 break;
15944 default:
15945 printf (_("Unknown tag: %d\n"), tag);
15946 public_section = FALSE;
15947 break;
15948 }
15949
15950 if (public_section && display_pub_attribute != NULL)
15951 {
15952 while (p < end)
15953 p = display_pub_attribute (p, end);
15954 assert (p == end);
15955 }
15956 else if (gnu_section && display_proc_gnu_attribute != NULL)
15957 {
15958 while (p < end)
15959 p = display_gnu_attribute (p,
15960 display_proc_gnu_attribute,
15961 end);
15962 assert (p == end);
15963 }
15964 else if (p < end)
15965 {
15966 printf (_(" Unknown attribute:\n"));
15967 display_raw_attribute (p, end);
15968 p = end;
15969 }
15970 else
15971 attr_len = 0;
15972 }
15973 }
15974 }
15975
15976 free (contents);
15977 }
15978
15979 return res;
15980}
15981
15982/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15983 Print the Address, Access and Initial fields of an entry at VMA ADDR
15984 and return the VMA of the next entry, or -1 if there was a problem.
15985 Does not read from DATA_END or beyond. */
15986
15987static bfd_vma
15988print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
15989 unsigned char * data_end)
15990{
15991 printf (" ");
15992 print_vma (addr, LONG_HEX);
15993 printf (" ");
15994 if (addr < pltgot + 0xfff0)
15995 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
15996 else
15997 printf ("%10s", "");
15998 printf (" ");
15999 if (data == NULL)
16000 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
16001 else
16002 {
16003 bfd_vma entry;
16004 unsigned char * from = data + addr - pltgot;
16005
16006 if (from + (is_32bit_elf ? 4 : 8) > data_end)
16007 {
16008 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16009 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
16010 return (bfd_vma) -1;
16011 }
16012 else
16013 {
16014 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
16015 print_vma (entry, LONG_HEX);
16016 }
16017 }
16018 return addr + (is_32bit_elf ? 4 : 8);
16019}
16020
16021/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16022 PLTGOT. Print the Address and Initial fields of an entry at VMA
16023 ADDR and return the VMA of the next entry. */
16024
16025static bfd_vma
16026print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
16027{
16028 printf (" ");
16029 print_vma (addr, LONG_HEX);
16030 printf (" ");
16031 if (data == NULL)
16032 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
16033 else
16034 {
16035 bfd_vma entry;
16036
16037 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
16038 print_vma (entry, LONG_HEX);
16039 }
16040 return addr + (is_32bit_elf ? 4 : 8);
16041}
16042
16043static void
16044print_mips_ases (unsigned int mask)
16045{
16046 if (mask & AFL_ASE_DSP)
16047 fputs ("\n\tDSP ASE", stdout);
16048 if (mask & AFL_ASE_DSPR2)
16049 fputs ("\n\tDSP R2 ASE", stdout);
16050 if (mask & AFL_ASE_DSPR3)
16051 fputs ("\n\tDSP R3 ASE", stdout);
16052 if (mask & AFL_ASE_EVA)
16053 fputs ("\n\tEnhanced VA Scheme", stdout);
16054 if (mask & AFL_ASE_MCU)
16055 fputs ("\n\tMCU (MicroController) ASE", stdout);
16056 if (mask & AFL_ASE_MDMX)
16057 fputs ("\n\tMDMX ASE", stdout);
16058 if (mask & AFL_ASE_MIPS3D)
16059 fputs ("\n\tMIPS-3D ASE", stdout);
16060 if (mask & AFL_ASE_MT)
16061 fputs ("\n\tMT ASE", stdout);
16062 if (mask & AFL_ASE_SMARTMIPS)
16063 fputs ("\n\tSmartMIPS ASE", stdout);
16064 if (mask & AFL_ASE_VIRT)
16065 fputs ("\n\tVZ ASE", stdout);
16066 if (mask & AFL_ASE_MSA)
16067 fputs ("\n\tMSA ASE", stdout);
16068 if (mask & AFL_ASE_MIPS16)
16069 fputs ("\n\tMIPS16 ASE", stdout);
16070 if (mask & AFL_ASE_MICROMIPS)
16071 fputs ("\n\tMICROMIPS ASE", stdout);
16072 if (mask & AFL_ASE_XPA)
16073 fputs ("\n\tXPA ASE", stdout);
16074 if (mask & AFL_ASE_MIPS16E2)
16075 fputs ("\n\tMIPS16e2 ASE", stdout);
16076 if (mask & AFL_ASE_CRC)
16077 fputs ("\n\tCRC ASE", stdout);
16078 if (mask & AFL_ASE_GINV)
16079 fputs ("\n\tGINV ASE", stdout);
16080 if (mask & AFL_ASE_LOONGSON_MMI)
16081 fputs ("\n\tLoongson MMI ASE", stdout);
16082 if (mask & AFL_ASE_LOONGSON_CAM)
16083 fputs ("\n\tLoongson CAM ASE", stdout);
16084 if (mask & AFL_ASE_LOONGSON_EXT)
16085 fputs ("\n\tLoongson EXT ASE", stdout);
16086 if (mask & AFL_ASE_LOONGSON_EXT2)
16087 fputs ("\n\tLoongson EXT2 ASE", stdout);
16088 if (mask == 0)
16089 fprintf (stdout, "\n\t%s", _("None"));
16090 else if ((mask & ~AFL_ASE_MASK) != 0)
16091 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
16092}
16093
16094static void
16095print_mips_isa_ext (unsigned int isa_ext)
16096{
16097 switch (isa_ext)
16098 {
16099 case 0:
16100 fputs (_("None"), stdout);
16101 break;
16102 case AFL_EXT_XLR:
16103 fputs ("RMI XLR", stdout);
16104 break;
16105 case AFL_EXT_OCTEON3:
16106 fputs ("Cavium Networks Octeon3", stdout);
16107 break;
16108 case AFL_EXT_OCTEON2:
16109 fputs ("Cavium Networks Octeon2", stdout);
16110 break;
16111 case AFL_EXT_OCTEONP:
16112 fputs ("Cavium Networks OcteonP", stdout);
16113 break;
16114 case AFL_EXT_OCTEON:
16115 fputs ("Cavium Networks Octeon", stdout);
16116 break;
16117 case AFL_EXT_5900:
16118 fputs ("Toshiba R5900", stdout);
16119 break;
16120 case AFL_EXT_4650:
16121 fputs ("MIPS R4650", stdout);
16122 break;
16123 case AFL_EXT_4010:
16124 fputs ("LSI R4010", stdout);
16125 break;
16126 case AFL_EXT_4100:
16127 fputs ("NEC VR4100", stdout);
16128 break;
16129 case AFL_EXT_3900:
16130 fputs ("Toshiba R3900", stdout);
16131 break;
16132 case AFL_EXT_10000:
16133 fputs ("MIPS R10000", stdout);
16134 break;
16135 case AFL_EXT_SB1:
16136 fputs ("Broadcom SB-1", stdout);
16137 break;
16138 case AFL_EXT_4111:
16139 fputs ("NEC VR4111/VR4181", stdout);
16140 break;
16141 case AFL_EXT_4120:
16142 fputs ("NEC VR4120", stdout);
16143 break;
16144 case AFL_EXT_5400:
16145 fputs ("NEC VR5400", stdout);
16146 break;
16147 case AFL_EXT_5500:
16148 fputs ("NEC VR5500", stdout);
16149 break;
16150 case AFL_EXT_LOONGSON_2E:
16151 fputs ("ST Microelectronics Loongson 2E", stdout);
16152 break;
16153 case AFL_EXT_LOONGSON_2F:
16154 fputs ("ST Microelectronics Loongson 2F", stdout);
16155 break;
16156 case AFL_EXT_INTERAPTIV_MR2:
16157 fputs ("Imagination interAptiv MR2", stdout);
16158 break;
16159 default:
16160 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
16161 }
16162}
16163
16164static signed int
16165get_mips_reg_size (int reg_size)
16166{
16167 return (reg_size == AFL_REG_NONE) ? 0
16168 : (reg_size == AFL_REG_32) ? 32
16169 : (reg_size == AFL_REG_64) ? 64
16170 : (reg_size == AFL_REG_128) ? 128
16171 : -1;
16172}
16173
16174static bfd_boolean
16175process_mips_specific (Filedata * filedata)
16176{
16177 Elf_Internal_Dyn * entry;
16178 Elf_Internal_Shdr *sect = NULL;
16179 size_t liblist_offset = 0;
16180 size_t liblistno = 0;
16181 size_t conflictsno = 0;
16182 size_t options_offset = 0;
16183 size_t conflicts_offset = 0;
16184 size_t pltrelsz = 0;
16185 size_t pltrel = 0;
16186 bfd_vma pltgot = 0;
16187 bfd_vma mips_pltgot = 0;
16188 bfd_vma jmprel = 0;
16189 bfd_vma local_gotno = 0;
16190 bfd_vma gotsym = 0;
16191 bfd_vma symtabno = 0;
16192 bfd_boolean res = TRUE;
16193
16194 if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
16195 display_mips_gnu_attribute))
16196 res = FALSE;
16197
16198 sect = find_section (filedata, ".MIPS.abiflags");
16199
16200 if (sect != NULL)
16201 {
16202 Elf_External_ABIFlags_v0 *abiflags_ext;
16203 Elf_Internal_ABIFlags_v0 abiflags_in;
16204
16205 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
16206 {
16207 error (_("Corrupt MIPS ABI Flags section.\n"));
16208 res = FALSE;
16209 }
16210 else
16211 {
16212 abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
16213 sect->sh_size, _("MIPS ABI Flags section"));
16214 if (abiflags_ext)
16215 {
16216 abiflags_in.version = BYTE_GET (abiflags_ext->version);
16217 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
16218 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
16219 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
16220 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
16221 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
16222 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
16223 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
16224 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
16225 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
16226 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
16227
16228 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
16229 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
16230 if (abiflags_in.isa_rev > 1)
16231 printf ("r%d", abiflags_in.isa_rev);
16232 printf ("\nGPR size: %d",
16233 get_mips_reg_size (abiflags_in.gpr_size));
16234 printf ("\nCPR1 size: %d",
16235 get_mips_reg_size (abiflags_in.cpr1_size));
16236 printf ("\nCPR2 size: %d",
16237 get_mips_reg_size (abiflags_in.cpr2_size));
16238 fputs ("\nFP ABI: ", stdout);
16239 print_mips_fp_abi_value (abiflags_in.fp_abi);
16240 fputs ("ISA Extension: ", stdout);
16241 print_mips_isa_ext (abiflags_in.isa_ext);
16242 fputs ("\nASEs:", stdout);
16243 print_mips_ases (abiflags_in.ases);
16244 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
16245 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
16246 fputc ('\n', stdout);
16247 free (abiflags_ext);
16248 }
16249 }
16250 }
16251
16252 /* We have a lot of special sections. Thanks SGI! */
16253 if (dynamic_section == NULL)
16254 {
16255 /* No dynamic information available. See if there is static GOT. */
16256 sect = find_section (filedata, ".got");
16257 if (sect != NULL)
16258 {
16259 unsigned char *data_end;
16260 unsigned char *data;
16261 bfd_vma ent, end;
16262 int addr_size;
16263
16264 pltgot = sect->sh_addr;
16265
16266 ent = pltgot;
16267 addr_size = (is_32bit_elf ? 4 : 8);
16268 end = pltgot + sect->sh_size;
16269
16270 data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
16271 end - pltgot, 1,
16272 _("Global Offset Table data"));
16273 /* PR 12855: Null data is handled gracefully throughout. */
16274 data_end = data + (end - pltgot);
16275
16276 printf (_("\nStatic GOT:\n"));
16277 printf (_(" Canonical gp value: "));
16278 print_vma (ent + 0x7ff0, LONG_HEX);
16279 printf ("\n\n");
16280
16281 /* In a dynamic binary GOT[0] is reserved for the dynamic
16282 loader to store the lazy resolver pointer, however in
16283 a static binary it may well have been omitted and GOT
16284 reduced to a table of addresses.
16285 PR 21344: Check for the entry being fully available
16286 before fetching it. */
16287 if (data
16288 && data + ent - pltgot + addr_size <= data_end
16289 && byte_get (data + ent - pltgot, addr_size) == 0)
16290 {
16291 printf (_(" Reserved entries:\n"));
16292 printf (_(" %*s %10s %*s\n"),
16293 addr_size * 2, _("Address"), _("Access"),
16294 addr_size * 2, _("Value"));
16295 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16296 printf ("\n");
16297 if (ent == (bfd_vma) -1)
16298 goto sgot_print_fail;
16299
16300 /* Check for the MSB of GOT[1] being set, identifying a
16301 GNU object. This entry will be used by some runtime
16302 loaders, to store the module pointer. Otherwise this
16303 is an ordinary local entry.
16304 PR 21344: Check for the entry being fully available
16305 before fetching it. */
16306 if (data
16307 && data + ent - pltgot + addr_size <= data_end
16308 && (byte_get (data + ent - pltgot, addr_size)
16309 >> (addr_size * 8 - 1)) != 0)
16310 {
16311 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16312 printf ("\n");
16313 if (ent == (bfd_vma) -1)
16314 goto sgot_print_fail;
16315 }
16316 printf ("\n");
16317 }
16318
16319 if (data != NULL && ent < end)
16320 {
16321 printf (_(" Local entries:\n"));
16322 printf (" %*s %10s %*s\n",
16323 addr_size * 2, _("Address"), _("Access"),
16324 addr_size * 2, _("Value"));
16325 while (ent < end)
16326 {
16327 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16328 printf ("\n");
16329 if (ent == (bfd_vma) -1)
16330 goto sgot_print_fail;
16331 }
16332 printf ("\n");
16333 }
16334
16335 sgot_print_fail:
16336 if (data)
16337 free (data);
16338 }
16339 return res;
16340 }
16341
16342 for (entry = dynamic_section;
16343 /* PR 17531 file: 012-50589-0.004. */
16344 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
16345 ++entry)
16346 switch (entry->d_tag)
16347 {
16348 case DT_MIPS_LIBLIST:
16349 liblist_offset
16350 = offset_from_vma (filedata, entry->d_un.d_val,
16351 liblistno * sizeof (Elf32_External_Lib));
16352 break;
16353 case DT_MIPS_LIBLISTNO:
16354 liblistno = entry->d_un.d_val;
16355 break;
16356 case DT_MIPS_OPTIONS:
16357 options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
16358 break;
16359 case DT_MIPS_CONFLICT:
16360 conflicts_offset
16361 = offset_from_vma (filedata, entry->d_un.d_val,
16362 conflictsno * sizeof (Elf32_External_Conflict));
16363 break;
16364 case DT_MIPS_CONFLICTNO:
16365 conflictsno = entry->d_un.d_val;
16366 break;
16367 case DT_PLTGOT:
16368 pltgot = entry->d_un.d_ptr;
16369 break;
16370 case DT_MIPS_LOCAL_GOTNO:
16371 local_gotno = entry->d_un.d_val;
16372 break;
16373 case DT_MIPS_GOTSYM:
16374 gotsym = entry->d_un.d_val;
16375 break;
16376 case DT_MIPS_SYMTABNO:
16377 symtabno = entry->d_un.d_val;
16378 break;
16379 case DT_MIPS_PLTGOT:
16380 mips_pltgot = entry->d_un.d_ptr;
16381 break;
16382 case DT_PLTREL:
16383 pltrel = entry->d_un.d_val;
16384 break;
16385 case DT_PLTRELSZ:
16386 pltrelsz = entry->d_un.d_val;
16387 break;
16388 case DT_JMPREL:
16389 jmprel = entry->d_un.d_ptr;
16390 break;
16391 default:
16392 break;
16393 }
16394
16395 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
16396 {
16397 Elf32_External_Lib * elib;
16398 size_t cnt;
16399
16400 elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
16401 liblistno,
16402 sizeof (Elf32_External_Lib),
16403 _("liblist section data"));
16404 if (elib)
16405 {
16406 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16407 "\nSection '.liblist' contains %lu entries:\n",
16408 (unsigned long) liblistno),
16409 (unsigned long) liblistno);
16410 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16411 stdout);
16412
16413 for (cnt = 0; cnt < liblistno; ++cnt)
16414 {
16415 Elf32_Lib liblist;
16416 time_t atime;
16417 char timebuf[128];
16418 struct tm * tmp;
16419
16420 liblist.l_name = BYTE_GET (elib[cnt].l_name);
16421 atime = BYTE_GET (elib[cnt].l_time_stamp);
16422 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16423 liblist.l_version = BYTE_GET (elib[cnt].l_version);
16424 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16425
16426 tmp = gmtime (&atime);
16427 snprintf (timebuf, sizeof (timebuf),
16428 "%04u-%02u-%02uT%02u:%02u:%02u",
16429 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16430 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16431
16432 printf ("%3lu: ", (unsigned long) cnt);
16433 if (VALID_DYNAMIC_NAME (liblist.l_name))
16434 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
16435 else
16436 printf (_("<corrupt: %9ld>"), liblist.l_name);
16437 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
16438 liblist.l_version);
16439
16440 if (liblist.l_flags == 0)
16441 puts (_(" NONE"));
16442 else
16443 {
16444 static const struct
16445 {
16446 const char * name;
16447 int bit;
16448 }
16449 l_flags_vals[] =
16450 {
16451 { " EXACT_MATCH", LL_EXACT_MATCH },
16452 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
16453 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
16454 { " EXPORTS", LL_EXPORTS },
16455 { " DELAY_LOAD", LL_DELAY_LOAD },
16456 { " DELTA", LL_DELTA }
16457 };
16458 int flags = liblist.l_flags;
16459 size_t fcnt;
16460
16461 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
16462 if ((flags & l_flags_vals[fcnt].bit) != 0)
16463 {
16464 fputs (l_flags_vals[fcnt].name, stdout);
16465 flags ^= l_flags_vals[fcnt].bit;
16466 }
16467 if (flags != 0)
16468 printf (" %#x", (unsigned int) flags);
16469
16470 puts ("");
16471 }
16472 }
16473
16474 free (elib);
16475 }
16476 else
16477 res = FALSE;
16478 }
16479
16480 if (options_offset != 0)
16481 {
16482 Elf_External_Options * eopt;
16483 size_t offset;
16484 int cnt;
16485 sect = filedata->section_headers;
16486
16487 /* Find the section header so that we get the size. */
16488 sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
16489 /* PR 17533 file: 012-277276-0.004. */
16490 if (sect == NULL)
16491 {
16492 error (_("No MIPS_OPTIONS header found\n"));
16493 return FALSE;
16494 }
16495 /* PR 24243 */
16496 if (sect->sh_size < sizeof (* eopt))
16497 {
16498 error (_("The MIPS options section is too small.\n"));
16499 return FALSE;
16500 }
16501
16502 eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
16503 sect->sh_size, _("options"));
16504 if (eopt)
16505 {
16506 Elf_Internal_Options * iopt;
16507 Elf_Internal_Options * option;
16508 Elf_Internal_Options * iopt_end;
16509
16510 iopt = (Elf_Internal_Options *)
16511 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
16512 if (iopt == NULL)
16513 {
16514 error (_("Out of memory allocating space for MIPS options\n"));
16515 return FALSE;
16516 }
16517
16518 offset = cnt = 0;
16519 option = iopt;
16520 iopt_end = iopt + (sect->sh_size / sizeof (eopt));
16521
16522 while (offset <= sect->sh_size - sizeof (* eopt))
16523 {
16524 Elf_External_Options * eoption;
16525
16526 eoption = (Elf_External_Options *) ((char *) eopt + offset);
16527
16528 option->kind = BYTE_GET (eoption->kind);
16529 option->size = BYTE_GET (eoption->size);
16530 option->section = BYTE_GET (eoption->section);
16531 option->info = BYTE_GET (eoption->info);
16532
16533 /* PR 17531: file: ffa0fa3b. */
16534 if (option->size < sizeof (* eopt)
16535 || offset + option->size > sect->sh_size)
16536 {
16537 error (_("Invalid size (%u) for MIPS option\n"), option->size);
16538 return FALSE;
16539 }
16540 offset += option->size;
16541
16542 ++option;
16543 ++cnt;
16544 }
16545
16546 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16547 "\nSection '%s' contains %d entries:\n",
16548 cnt),
16549 printable_section_name (filedata, sect), cnt);
16550
16551 option = iopt;
16552 offset = 0;
16553
16554 while (cnt-- > 0)
16555 {
16556 size_t len;
16557
16558 switch (option->kind)
16559 {
16560 case ODK_NULL:
16561 /* This shouldn't happen. */
16562 printf (" NULL %d %lx", option->section, option->info);
16563 break;
16564
16565 case ODK_REGINFO:
16566 printf (" REGINFO ");
16567 if (filedata->file_header.e_machine == EM_MIPS)
16568 {
16569 Elf32_External_RegInfo * ereg;
16570 Elf32_RegInfo reginfo;
16571
16572 /* 32bit form. */
16573 if (option + 2 > iopt_end)
16574 {
16575 printf (_("<corrupt>\n"));
16576 error (_("Truncated MIPS REGINFO option\n"));
16577 cnt = 0;
16578 break;
16579 }
16580
16581 ereg = (Elf32_External_RegInfo *) (option + 1);
16582
16583 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
16584 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16585 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16586 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16587 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16588 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
16589
16590 printf ("GPR %08lx GP 0x%lx\n",
16591 reginfo.ri_gprmask,
16592 (unsigned long) reginfo.ri_gp_value);
16593 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16594 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16595 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16596 }
16597 else
16598 {
16599 /* 64 bit form. */
16600 Elf64_External_RegInfo * ereg;
16601 Elf64_Internal_RegInfo reginfo;
16602
16603 if (option + 2 > iopt_end)
16604 {
16605 printf (_("<corrupt>\n"));
16606 error (_("Truncated MIPS REGINFO option\n"));
16607 cnt = 0;
16608 break;
16609 }
16610
16611 ereg = (Elf64_External_RegInfo *) (option + 1);
16612 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
16613 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16614 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16615 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16616 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16617 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
16618
16619 printf ("GPR %08lx GP 0x",
16620 reginfo.ri_gprmask);
16621 printf_vma (reginfo.ri_gp_value);
16622 printf ("\n");
16623
16624 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16625 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16626 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16627 }
16628 ++option;
16629 continue;
16630
16631 case ODK_EXCEPTIONS:
16632 fputs (" EXCEPTIONS fpe_min(", stdout);
16633 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
16634 fputs (") fpe_max(", stdout);
16635 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
16636 fputs (")", stdout);
16637
16638 if (option->info & OEX_PAGE0)
16639 fputs (" PAGE0", stdout);
16640 if (option->info & OEX_SMM)
16641 fputs (" SMM", stdout);
16642 if (option->info & OEX_FPDBUG)
16643 fputs (" FPDBUG", stdout);
16644 if (option->info & OEX_DISMISS)
16645 fputs (" DISMISS", stdout);
16646 break;
16647
16648 case ODK_PAD:
16649 fputs (" PAD ", stdout);
16650 if (option->info & OPAD_PREFIX)
16651 fputs (" PREFIX", stdout);
16652 if (option->info & OPAD_POSTFIX)
16653 fputs (" POSTFIX", stdout);
16654 if (option->info & OPAD_SYMBOL)
16655 fputs (" SYMBOL", stdout);
16656 break;
16657
16658 case ODK_HWPATCH:
16659 fputs (" HWPATCH ", stdout);
16660 if (option->info & OHW_R4KEOP)
16661 fputs (" R4KEOP", stdout);
16662 if (option->info & OHW_R8KPFETCH)
16663 fputs (" R8KPFETCH", stdout);
16664 if (option->info & OHW_R5KEOP)
16665 fputs (" R5KEOP", stdout);
16666 if (option->info & OHW_R5KCVTL)
16667 fputs (" R5KCVTL", stdout);
16668 break;
16669
16670 case ODK_FILL:
16671 fputs (" FILL ", stdout);
16672 /* XXX Print content of info word? */
16673 break;
16674
16675 case ODK_TAGS:
16676 fputs (" TAGS ", stdout);
16677 /* XXX Print content of info word? */
16678 break;
16679
16680 case ODK_HWAND:
16681 fputs (" HWAND ", stdout);
16682 if (option->info & OHWA0_R4KEOP_CHECKED)
16683 fputs (" R4KEOP_CHECKED", stdout);
16684 if (option->info & OHWA0_R4KEOP_CLEAN)
16685 fputs (" R4KEOP_CLEAN", stdout);
16686 break;
16687
16688 case ODK_HWOR:
16689 fputs (" HWOR ", stdout);
16690 if (option->info & OHWA0_R4KEOP_CHECKED)
16691 fputs (" R4KEOP_CHECKED", stdout);
16692 if (option->info & OHWA0_R4KEOP_CLEAN)
16693 fputs (" R4KEOP_CLEAN", stdout);
16694 break;
16695
16696 case ODK_GP_GROUP:
16697 printf (" GP_GROUP %#06lx self-contained %#06lx",
16698 option->info & OGP_GROUP,
16699 (option->info & OGP_SELF) >> 16);
16700 break;
16701
16702 case ODK_IDENT:
16703 printf (" IDENT %#06lx self-contained %#06lx",
16704 option->info & OGP_GROUP,
16705 (option->info & OGP_SELF) >> 16);
16706 break;
16707
16708 default:
16709 /* This shouldn't happen. */
16710 printf (" %3d ??? %d %lx",
16711 option->kind, option->section, option->info);
16712 break;
16713 }
16714
16715 len = sizeof (* eopt);
16716 while (len < option->size)
16717 {
16718 unsigned char datum = * ((unsigned char *) eopt + offset + len);
16719
16720 if (ISPRINT (datum))
16721 printf ("%c", datum);
16722 else
16723 printf ("\\%03o", datum);
16724 len ++;
16725 }
16726 fputs ("\n", stdout);
16727
16728 offset += option->size;
16729 ++option;
16730 }
16731
16732 free (eopt);
16733 }
16734 else
16735 res = FALSE;
16736 }
16737
16738 if (conflicts_offset != 0 && conflictsno != 0)
16739 {
16740 Elf32_Conflict * iconf;
16741 size_t cnt;
16742
16743 if (dynamic_symbols == NULL)
16744 {
16745 error (_("conflict list found without a dynamic symbol table\n"));
16746 return FALSE;
16747 }
16748
16749 /* PR 21345 - print a slightly more helpful error message
16750 if we are sure that the cmalloc will fail. */
16751 if (conflictsno * sizeof (* iconf) > filedata->file_size)
16752 {
16753 error (_("Overlarge number of conflicts detected: %lx\n"),
16754 (long) conflictsno);
16755 return FALSE;
16756 }
16757
16758 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
16759 if (iconf == NULL)
16760 {
16761 error (_("Out of memory allocating space for dynamic conflicts\n"));
16762 return FALSE;
16763 }
16764
16765 if (is_32bit_elf)
16766 {
16767 Elf32_External_Conflict * econf32;
16768
16769 econf32 = (Elf32_External_Conflict *)
16770 get_data (NULL, filedata, conflicts_offset, conflictsno,
16771 sizeof (* econf32), _("conflict"));
16772 if (!econf32)
16773 return FALSE;
16774
16775 for (cnt = 0; cnt < conflictsno; ++cnt)
16776 iconf[cnt] = BYTE_GET (econf32[cnt]);
16777
16778 free (econf32);
16779 }
16780 else
16781 {
16782 Elf64_External_Conflict * econf64;
16783
16784 econf64 = (Elf64_External_Conflict *)
16785 get_data (NULL, filedata, conflicts_offset, conflictsno,
16786 sizeof (* econf64), _("conflict"));
16787 if (!econf64)
16788 return FALSE;
16789
16790 for (cnt = 0; cnt < conflictsno; ++cnt)
16791 iconf[cnt] = BYTE_GET (econf64[cnt]);
16792
16793 free (econf64);
16794 }
16795
16796 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16797 "\nSection '.conflict' contains %lu entries:\n",
16798 (unsigned long) conflictsno),
16799 (unsigned long) conflictsno);
16800 puts (_(" Num: Index Value Name"));
16801
16802 for (cnt = 0; cnt < conflictsno; ++cnt)
16803 {
16804 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
16805
16806 if (iconf[cnt] >= num_dynamic_syms)
16807 printf (_("<corrupt symbol index>"));
16808 else
16809 {
16810 Elf_Internal_Sym * psym;
16811
16812 psym = & dynamic_symbols[iconf[cnt]];
16813 print_vma (psym->st_value, FULL_HEX);
16814 putchar (' ');
16815 if (VALID_DYNAMIC_NAME (psym->st_name))
16816 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
16817 else
16818 printf (_("<corrupt: %14ld>"), psym->st_name);
16819 }
16820 putchar ('\n');
16821 }
16822
16823 free (iconf);
16824 }
16825
16826 if (pltgot != 0 && local_gotno != 0)
16827 {
16828 bfd_vma ent, local_end, global_end;
16829 size_t i, offset;
16830 unsigned char * data;
16831 unsigned char * data_end;
16832 int addr_size;
16833
16834 ent = pltgot;
16835 addr_size = (is_32bit_elf ? 4 : 8);
16836 local_end = pltgot + local_gotno * addr_size;
16837
16838 /* PR binutils/17533 file: 012-111227-0.004 */
16839 if (symtabno < gotsym)
16840 {
16841 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16842 (unsigned long) gotsym, (unsigned long) symtabno);
16843 return FALSE;
16844 }
16845
16846 global_end = local_end + (symtabno - gotsym) * addr_size;
16847 /* PR 17531: file: 54c91a34. */
16848 if (global_end < local_end)
16849 {
16850 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
16851 return FALSE;
16852 }
16853
16854 offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
16855 data = (unsigned char *) get_data (NULL, filedata, offset,
16856 global_end - pltgot, 1,
16857 _("Global Offset Table data"));
16858 /* PR 12855: Null data is handled gracefully throughout. */
16859 data_end = data + (global_end - pltgot);
16860
16861 printf (_("\nPrimary GOT:\n"));
16862 printf (_(" Canonical gp value: "));
16863 print_vma (pltgot + 0x7ff0, LONG_HEX);
16864 printf ("\n\n");
16865
16866 printf (_(" Reserved entries:\n"));
16867 printf (_(" %*s %10s %*s Purpose\n"),
16868 addr_size * 2, _("Address"), _("Access"),
16869 addr_size * 2, _("Initial"));
16870 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16871 printf (_(" Lazy resolver\n"));
16872 if (ent == (bfd_vma) -1)
16873 goto got_print_fail;
16874
16875 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16876 This entry will be used by some runtime loaders, to store the
16877 module pointer. Otherwise this is an ordinary local entry.
16878 PR 21344: Check for the entry being fully available before
16879 fetching it. */
16880 if (data
16881 && data + ent - pltgot + addr_size <= data_end
16882 && (byte_get (data + ent - pltgot, addr_size)
16883 >> (addr_size * 8 - 1)) != 0)
16884 {
16885 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16886 printf (_(" Module pointer (GNU extension)\n"));
16887 if (ent == (bfd_vma) -1)
16888 goto got_print_fail;
16889 }
16890 printf ("\n");
16891
16892 if (data != NULL && ent < local_end)
16893 {
16894 printf (_(" Local entries:\n"));
16895 printf (" %*s %10s %*s\n",
16896 addr_size * 2, _("Address"), _("Access"),
16897 addr_size * 2, _("Initial"));
16898 while (ent < local_end)
16899 {
16900 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16901 printf ("\n");
16902 if (ent == (bfd_vma) -1)
16903 goto got_print_fail;
16904 }
16905 printf ("\n");
16906 }
16907
16908 if (data != NULL && gotsym < symtabno)
16909 {
16910 int sym_width;
16911
16912 printf (_(" Global entries:\n"));
16913 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
16914 addr_size * 2, _("Address"),
16915 _("Access"),
16916 addr_size * 2, _("Initial"),
16917 addr_size * 2, _("Sym.Val."),
16918 _("Type"),
16919 /* Note for translators: "Ndx" = abbreviated form of "Index". */
16920 _("Ndx"), _("Name"));
16921
16922 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
16923
16924 for (i = gotsym; i < symtabno; i++)
16925 {
16926 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16927 printf (" ");
16928
16929 if (dynamic_symbols == NULL)
16930 printf (_("<no dynamic symbols>"));
16931 else if (i < num_dynamic_syms)
16932 {
16933 Elf_Internal_Sym * psym = dynamic_symbols + i;
16934
16935 print_vma (psym->st_value, LONG_HEX);
16936 printf (" %-7s %3s ",
16937 get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16938 get_symbol_index_type (filedata, psym->st_shndx));
16939
16940 if (VALID_DYNAMIC_NAME (psym->st_name))
16941 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16942 else
16943 printf (_("<corrupt: %14ld>"), psym->st_name);
16944 }
16945 else
16946 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16947 (unsigned long) i);
16948
16949 printf ("\n");
16950 if (ent == (bfd_vma) -1)
16951 break;
16952 }
16953 printf ("\n");
16954 }
16955
16956 got_print_fail:
16957 if (data)
16958 free (data);
16959 }
16960
16961 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
16962 {
16963 bfd_vma ent, end;
16964 size_t offset, rel_offset;
16965 unsigned long count, i;
16966 unsigned char * data;
16967 int addr_size, sym_width;
16968 Elf_Internal_Rela * rels;
16969
16970 rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
16971 if (pltrel == DT_RELA)
16972 {
16973 if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16974 return FALSE;
16975 }
16976 else
16977 {
16978 if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16979 return FALSE;
16980 }
16981
16982 ent = mips_pltgot;
16983 addr_size = (is_32bit_elf ? 4 : 8);
16984 end = mips_pltgot + (2 + count) * addr_size;
16985
16986 offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
16987 data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
16988 1, _("Procedure Linkage Table data"));
16989 if (data == NULL)
16990 return FALSE;
16991
16992 printf ("\nPLT GOT:\n\n");
16993 printf (_(" Reserved entries:\n"));
16994 printf (_(" %*s %*s Purpose\n"),
16995 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
16996 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16997 printf (_(" PLT lazy resolver\n"));
16998 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16999 printf (_(" Module pointer\n"));
17000 printf ("\n");
17001
17002 printf (_(" Entries:\n"));
17003 printf (" %*s %*s %*s %-7s %3s %s\n",
17004 addr_size * 2, _("Address"),
17005 addr_size * 2, _("Initial"),
17006 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17007 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
17008 for (i = 0; i < count; i++)
17009 {
17010 unsigned long idx = get_reloc_symindex (rels[i].r_info);
17011
17012 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
17013 printf (" ");
17014
17015 if (idx >= num_dynamic_syms)
17016 printf (_("<corrupt symbol index: %lu>"), idx);
17017 else
17018 {
17019 Elf_Internal_Sym * psym = dynamic_symbols + idx;
17020
17021 print_vma (psym->st_value, LONG_HEX);
17022 printf (" %-7s %3s ",
17023 get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
17024 get_symbol_index_type (filedata, psym->st_shndx));
17025 if (VALID_DYNAMIC_NAME (psym->st_name))
17026 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
17027 else
17028 printf (_("<corrupt: %14ld>"), psym->st_name);
17029 }
17030 printf ("\n");
17031 }
17032 printf ("\n");
17033
17034 if (data)
17035 free (data);
17036 free (rels);
17037 }
17038
17039 return res;
17040}
17041
17042static bfd_boolean
17043process_nds32_specific (Filedata * filedata)
17044{
17045 Elf_Internal_Shdr *sect = NULL;
17046
17047 sect = find_section (filedata, ".nds32_e_flags");
17048 if (sect != NULL)
17049 {
17050 unsigned int *flag;
17051
17052 printf ("\nNDS32 elf flags section:\n");
17053 flag = get_data (NULL, filedata, sect->sh_offset, 1,
17054 sect->sh_size, _("NDS32 elf flags section"));
17055
17056 if (! flag)
17057 return FALSE;
17058
17059 switch ((*flag) & 0x3)
17060 {
17061 case 0:
17062 printf ("(VEC_SIZE):\tNo entry.\n");
17063 break;
17064 case 1:
17065 printf ("(VEC_SIZE):\t4 bytes\n");
17066 break;
17067 case 2:
17068 printf ("(VEC_SIZE):\t16 bytes\n");
17069 break;
17070 case 3:
17071 printf ("(VEC_SIZE):\treserved\n");
17072 break;
17073 }
17074 }
17075
17076 return TRUE;
17077}
17078
17079static bfd_boolean
17080process_gnu_liblist (Filedata * filedata)
17081{
17082 Elf_Internal_Shdr * section;
17083 Elf_Internal_Shdr * string_sec;
17084 Elf32_External_Lib * elib;
17085 char * strtab;
17086 size_t strtab_size;
17087 size_t cnt;
17088 unsigned long num_liblist;
17089 unsigned i;
17090 bfd_boolean res = TRUE;
17091
17092 if (! do_arch)
17093 return TRUE;
17094
17095 for (i = 0, section = filedata->section_headers;
17096 i < filedata->file_header.e_shnum;
17097 i++, section++)
17098 {
17099 switch (section->sh_type)
17100 {
17101 case SHT_GNU_LIBLIST:
17102 if (section->sh_link >= filedata->file_header.e_shnum)
17103 break;
17104
17105 elib = (Elf32_External_Lib *)
17106 get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
17107 _("liblist section data"));
17108
17109 if (elib == NULL)
17110 {
17111 res = FALSE;
17112 break;
17113 }
17114
17115 string_sec = filedata->section_headers + section->sh_link;
17116 strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
17117 string_sec->sh_size,
17118 _("liblist string table"));
17119 if (strtab == NULL
17120 || section->sh_entsize != sizeof (Elf32_External_Lib))
17121 {
17122 free (elib);
17123 free (strtab);
17124 res = FALSE;
17125 break;
17126 }
17127 strtab_size = string_sec->sh_size;
17128
17129 num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
17130 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17131 "\nLibrary list section '%s' contains %lu entries:\n",
17132 num_liblist),
17133 printable_section_name (filedata, section),
17134 num_liblist);
17135
17136 puts (_(" Library Time Stamp Checksum Version Flags"));
17137
17138 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
17139 ++cnt)
17140 {
17141 Elf32_Lib liblist;
17142 time_t atime;
17143 char timebuf[128];
17144 struct tm * tmp;
17145
17146 liblist.l_name = BYTE_GET (elib[cnt].l_name);
17147 atime = BYTE_GET (elib[cnt].l_time_stamp);
17148 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
17149 liblist.l_version = BYTE_GET (elib[cnt].l_version);
17150 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
17151
17152 tmp = gmtime (&atime);
17153 snprintf (timebuf, sizeof (timebuf),
17154 "%04u-%02u-%02uT%02u:%02u:%02u",
17155 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
17156 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
17157
17158 printf ("%3lu: ", (unsigned long) cnt);
17159 if (do_wide)
17160 printf ("%-20s", liblist.l_name < strtab_size
17161 ? strtab + liblist.l_name : _("<corrupt>"));
17162 else
17163 printf ("%-20.20s", liblist.l_name < strtab_size
17164 ? strtab + liblist.l_name : _("<corrupt>"));
17165 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
17166 liblist.l_version, liblist.l_flags);
17167 }
17168
17169 free (elib);
17170 free (strtab);
17171 }
17172 }
17173
17174 return res;
17175}
17176
17177static const char *
17178get_note_type (Filedata * filedata, unsigned e_type)
17179{
17180 static char buff[64];
17181
17182 if (filedata->file_header.e_type == ET_CORE)
17183 switch (e_type)
17184 {
17185 case NT_AUXV:
17186 return _("NT_AUXV (auxiliary vector)");
17187 case NT_PRSTATUS:
17188 return _("NT_PRSTATUS (prstatus structure)");
17189 case NT_FPREGSET:
17190 return _("NT_FPREGSET (floating point registers)");
17191 case NT_PRPSINFO:
17192 return _("NT_PRPSINFO (prpsinfo structure)");
17193 case NT_TASKSTRUCT:
17194 return _("NT_TASKSTRUCT (task structure)");
17195 case NT_PRXFPREG:
17196 return _("NT_PRXFPREG (user_xfpregs structure)");
17197 case NT_PPC_VMX:
17198 return _("NT_PPC_VMX (ppc Altivec registers)");
17199 case NT_PPC_VSX:
17200 return _("NT_PPC_VSX (ppc VSX registers)");
17201 case NT_PPC_TAR:
17202 return _("NT_PPC_TAR (ppc TAR register)");
17203 case NT_PPC_PPR:
17204 return _("NT_PPC_PPR (ppc PPR register)");
17205 case NT_PPC_DSCR:
17206 return _("NT_PPC_DSCR (ppc DSCR register)");
17207 case NT_PPC_EBB:
17208 return _("NT_PPC_EBB (ppc EBB registers)");
17209 case NT_PPC_PMU:
17210 return _("NT_PPC_PMU (ppc PMU registers)");
17211 case NT_PPC_TM_CGPR:
17212 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17213 case NT_PPC_TM_CFPR:
17214 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17215 case NT_PPC_TM_CVMX:
17216 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17217 case NT_PPC_TM_CVSX:
17218 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17219 case NT_PPC_TM_SPR:
17220 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17221 case NT_PPC_TM_CTAR:
17222 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17223 case NT_PPC_TM_CPPR:
17224 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17225 case NT_PPC_TM_CDSCR:
17226 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17227 case NT_386_TLS:
17228 return _("NT_386_TLS (x86 TLS information)");
17229 case NT_386_IOPERM:
17230 return _("NT_386_IOPERM (x86 I/O permissions)");
17231 case NT_X86_XSTATE:
17232 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17233 case NT_S390_HIGH_GPRS:
17234 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17235 case NT_S390_TIMER:
17236 return _("NT_S390_TIMER (s390 timer register)");
17237 case NT_S390_TODCMP:
17238 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17239 case NT_S390_TODPREG:
17240 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17241 case NT_S390_CTRS:
17242 return _("NT_S390_CTRS (s390 control registers)");
17243 case NT_S390_PREFIX:
17244 return _("NT_S390_PREFIX (s390 prefix register)");
17245 case NT_S390_LAST_BREAK:
17246 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17247 case NT_S390_SYSTEM_CALL:
17248 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17249 case NT_S390_TDB:
17250 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17251 case NT_S390_VXRS_LOW:
17252 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17253 case NT_S390_VXRS_HIGH:
17254 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17255 case NT_S390_GS_CB:
17256 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17257 case NT_S390_GS_BC:
17258 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17259 case NT_ARM_VFP:
17260 return _("NT_ARM_VFP (arm VFP registers)");
17261 case NT_ARM_TLS:
17262 return _("NT_ARM_TLS (AArch TLS registers)");
17263 case NT_ARM_HW_BREAK:
17264 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17265 case NT_ARM_HW_WATCH:
17266 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17267 case NT_PSTATUS:
17268 return _("NT_PSTATUS (pstatus structure)");
17269 case NT_FPREGS:
17270 return _("NT_FPREGS (floating point registers)");
17271 case NT_PSINFO:
17272 return _("NT_PSINFO (psinfo structure)");
17273 case NT_LWPSTATUS:
17274 return _("NT_LWPSTATUS (lwpstatus_t structure)");
17275 case NT_LWPSINFO:
17276 return _("NT_LWPSINFO (lwpsinfo_t structure)");
17277 case NT_WIN32PSTATUS:
17278 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17279 case NT_SIGINFO:
17280 return _("NT_SIGINFO (siginfo_t data)");
17281 case NT_FILE:
17282 return _("NT_FILE (mapped files)");
17283 default:
17284 break;
17285 }
17286 else
17287 switch (e_type)
17288 {
17289 case NT_VERSION:
17290 return _("NT_VERSION (version)");
17291 case NT_ARCH:
17292 return _("NT_ARCH (architecture)");
17293 case NT_GNU_BUILD_ATTRIBUTE_OPEN:
17294 return _("OPEN");
17295 case NT_GNU_BUILD_ATTRIBUTE_FUNC:
17296 return _("func");
17297 default:
17298 break;
17299 }
17300
17301 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17302 return buff;
17303}
17304
17305static bfd_boolean
17306print_core_note (Elf_Internal_Note *pnote)
17307{
17308 unsigned int addr_size = is_32bit_elf ? 4 : 8;
17309 bfd_vma count, page_size;
17310 unsigned char *descdata, *filenames, *descend;
17311
17312 if (pnote->type != NT_FILE)
17313 {
17314 if (do_wide)
17315 printf ("\n");
17316 return TRUE;
17317 }
17318
17319#ifndef BFD64
17320 if (!is_32bit_elf)
17321 {
17322 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
17323 /* Still "successful". */
17324 return TRUE;
17325 }
17326#endif
17327
17328 if (pnote->descsz < 2 * addr_size)
17329 {
17330 error (_(" Malformed note - too short for header\n"));
17331 return FALSE;
17332 }
17333
17334 descdata = (unsigned char *) pnote->descdata;
17335 descend = descdata + pnote->descsz;
17336
17337 if (descdata[pnote->descsz - 1] != '\0')
17338 {
17339 error (_(" Malformed note - does not end with \\0\n"));
17340 return FALSE;
17341 }
17342
17343 count = byte_get (descdata, addr_size);
17344 descdata += addr_size;
17345
17346 page_size = byte_get (descdata, addr_size);
17347 descdata += addr_size;
17348
17349 if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
17350 || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
17351 {
17352 error (_(" Malformed note - too short for supplied file count\n"));
17353 return FALSE;
17354 }
17355
17356 printf (_(" Page size: "));
17357 print_vma (page_size, DEC);
17358 printf ("\n");
17359
17360 printf (_(" %*s%*s%*s\n"),
17361 (int) (2 + 2 * addr_size), _("Start"),
17362 (int) (4 + 2 * addr_size), _("End"),
17363 (int) (4 + 2 * addr_size), _("Page Offset"));
17364 filenames = descdata + count * 3 * addr_size;
17365 while (count-- > 0)
17366 {
17367 bfd_vma start, end, file_ofs;
17368
17369 if (filenames == descend)
17370 {
17371 error (_(" Malformed note - filenames end too early\n"));
17372 return FALSE;
17373 }
17374
17375 start = byte_get (descdata, addr_size);
17376 descdata += addr_size;
17377 end = byte_get (descdata, addr_size);
17378 descdata += addr_size;
17379 file_ofs = byte_get (descdata, addr_size);
17380 descdata += addr_size;
17381
17382 printf (" ");
17383 print_vma (start, FULL_HEX);
17384 printf (" ");
17385 print_vma (end, FULL_HEX);
17386 printf (" ");
17387 print_vma (file_ofs, FULL_HEX);
17388 printf ("\n %s\n", filenames);
17389
17390 filenames += 1 + strlen ((char *) filenames);
17391 }
17392
17393 return TRUE;
17394}
17395
17396static const char *
17397get_gnu_elf_note_type (unsigned e_type)
17398{
17399 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17400 switch (e_type)
17401 {
17402 case NT_GNU_ABI_TAG:
17403 return _("NT_GNU_ABI_TAG (ABI version tag)");
17404 case NT_GNU_HWCAP:
17405 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17406 case NT_GNU_BUILD_ID:
17407 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17408 case NT_GNU_GOLD_VERSION:
17409 return _("NT_GNU_GOLD_VERSION (gold version)");
17410 case NT_GNU_PROPERTY_TYPE_0:
17411 return _("NT_GNU_PROPERTY_TYPE_0");
17412 case NT_GNU_BUILD_ATTRIBUTE_OPEN:
17413 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17414 case NT_GNU_BUILD_ATTRIBUTE_FUNC:
17415 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17416 default:
17417 {
17418 static char buff[64];
17419
17420 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17421 return buff;
17422 }
17423 }
17424}
17425
17426static void
17427decode_x86_compat_isa (unsigned int bitmask)
17428{
17429 while (bitmask)
17430 {
17431 unsigned int bit = bitmask & (- bitmask);
17432
17433 bitmask &= ~ bit;
17434 switch (bit)
17435 {
17436 case GNU_PROPERTY_X86_COMPAT_ISA_1_486:
17437 printf ("i486");
17438 break;
17439 case GNU_PROPERTY_X86_COMPAT_ISA_1_586:
17440 printf ("586");
17441 break;
17442 case GNU_PROPERTY_X86_COMPAT_ISA_1_686:
17443 printf ("686");
17444 break;
17445 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE:
17446 printf ("SSE");
17447 break;
17448 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2:
17449 printf ("SSE2");
17450 break;
17451 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3:
17452 printf ("SSE3");
17453 break;
17454 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3:
17455 printf ("SSSE3");
17456 break;
17457 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1:
17458 printf ("SSE4_1");
17459 break;
17460 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2:
17461 printf ("SSE4_2");
17462 break;
17463 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX:
17464 printf ("AVX");
17465 break;
17466 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2:
17467 printf ("AVX2");
17468 break;
17469 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F:
17470 printf ("AVX512F");
17471 break;
17472 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD:
17473 printf ("AVX512CD");
17474 break;
17475 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER:
17476 printf ("AVX512ER");
17477 break;
17478 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF:
17479 printf ("AVX512PF");
17480 break;
17481 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL:
17482 printf ("AVX512VL");
17483 break;
17484 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ:
17485 printf ("AVX512DQ");
17486 break;
17487 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW:
17488 printf ("AVX512BW");
17489 break;
17490 default:
17491 printf (_("<unknown: %x>"), bit);
17492 break;
17493 }
17494 if (bitmask)
17495 printf (", ");
17496 }
17497}
17498
17499static void
17500decode_x86_isa (unsigned int bitmask)
17501{
17502 if (!bitmask)
17503 {
17504 printf (_("<None>"));
17505 return;
17506 }
17507
17508 while (bitmask)
17509 {
17510 unsigned int bit = bitmask & (- bitmask);
17511
17512 bitmask &= ~ bit;
17513 switch (bit)
17514 {
17515 case GNU_PROPERTY_X86_ISA_1_CMOV:
17516 printf ("CMOV");
17517 break;
17518 case GNU_PROPERTY_X86_ISA_1_SSE:
17519 printf ("SSE");
17520 break;
17521 case GNU_PROPERTY_X86_ISA_1_SSE2:
17522 printf ("SSE2");
17523 break;
17524 case GNU_PROPERTY_X86_ISA_1_SSE3:
17525 printf ("SSE3");
17526 break;
17527 case GNU_PROPERTY_X86_ISA_1_SSSE3:
17528 printf ("SSSE3");
17529 break;
17530 case GNU_PROPERTY_X86_ISA_1_SSE4_1:
17531 printf ("SSE4_1");
17532 break;
17533 case GNU_PROPERTY_X86_ISA_1_SSE4_2:
17534 printf ("SSE4_2");
17535 break;
17536 case GNU_PROPERTY_X86_ISA_1_AVX:
17537 printf ("AVX");
17538 break;
17539 case GNU_PROPERTY_X86_ISA_1_AVX2:
17540 printf ("AVX2");
17541 break;
17542 case GNU_PROPERTY_X86_ISA_1_FMA:
17543 printf ("FMA");
17544 break;
17545 case GNU_PROPERTY_X86_ISA_1_AVX512F:
17546 printf ("AVX512F");
17547 break;
17548 case GNU_PROPERTY_X86_ISA_1_AVX512CD:
17549 printf ("AVX512CD");
17550 break;
17551 case GNU_PROPERTY_X86_ISA_1_AVX512ER:
17552 printf ("AVX512ER");
17553 break;
17554 case GNU_PROPERTY_X86_ISA_1_AVX512PF:
17555 printf ("AVX512PF");
17556 break;
17557 case GNU_PROPERTY_X86_ISA_1_AVX512VL:
17558 printf ("AVX512VL");
17559 break;
17560 case GNU_PROPERTY_X86_ISA_1_AVX512DQ:
17561 printf ("AVX512DQ");
17562 break;
17563 case GNU_PROPERTY_X86_ISA_1_AVX512BW:
17564 printf ("AVX512BW");
17565 break;
17566 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS:
17567 printf ("AVX512_4FMAPS");
17568 break;
17569 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW:
17570 printf ("AVX512_4VNNIW");
17571 break;
17572 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG:
17573 printf ("AVX512_BITALG");
17574 break;
17575 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA:
17576 printf ("AVX512_IFMA");
17577 break;
17578 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI:
17579 printf ("AVX512_VBMI");
17580 break;
17581 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2:
17582 printf ("AVX512_VBMI2");
17583 break;
17584 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI:
17585 printf ("AVX512_VNNI");
17586 break;
17587 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16:
17588 printf ("AVX512_BF16");
17589 break;
17590 default:
17591 printf (_("<unknown: %x>"), bit);
17592 break;
17593 }
17594 if (bitmask)
17595 printf (", ");
17596 }
17597}
17598
17599static void
17600decode_x86_feature_1 (unsigned int bitmask)
17601{
17602 if (!bitmask)
17603 {
17604 printf (_("<None>"));
17605 return;
17606 }
17607
17608 while (bitmask)
17609 {
17610 unsigned int bit = bitmask & (- bitmask);
17611
17612 bitmask &= ~ bit;
17613 switch (bit)
17614 {
17615 case GNU_PROPERTY_X86_FEATURE_1_IBT:
17616 printf ("IBT");
17617 break;
17618 case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
17619 printf ("SHSTK");
17620 break;
17621 default:
17622 printf (_("<unknown: %x>"), bit);
17623 break;
17624 }
17625 if (bitmask)
17626 printf (", ");
17627 }
17628}
17629
17630static void
17631decode_x86_feature_2 (unsigned int bitmask)
17632{
17633 if (!bitmask)
17634 {
17635 printf (_("<None>"));
17636 return;
17637 }
17638
17639 while (bitmask)
17640 {
17641 unsigned int bit = bitmask & (- bitmask);
17642
17643 bitmask &= ~ bit;
17644 switch (bit)
17645 {
17646 case GNU_PROPERTY_X86_FEATURE_2_X86:
17647 printf ("x86");
17648 break;
17649 case GNU_PROPERTY_X86_FEATURE_2_X87:
17650 printf ("x87");
17651 break;
17652 case GNU_PROPERTY_X86_FEATURE_2_MMX:
17653 printf ("MMX");
17654 break;
17655 case GNU_PROPERTY_X86_FEATURE_2_XMM:
17656 printf ("XMM");
17657 break;
17658 case GNU_PROPERTY_X86_FEATURE_2_YMM:
17659 printf ("YMM");
17660 break;
17661 case GNU_PROPERTY_X86_FEATURE_2_ZMM:
17662 printf ("ZMM");
17663 break;
17664 case GNU_PROPERTY_X86_FEATURE_2_FXSR:
17665 printf ("FXSR");
17666 break;
17667 case GNU_PROPERTY_X86_FEATURE_2_XSAVE:
17668 printf ("XSAVE");
17669 break;
17670 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT:
17671 printf ("XSAVEOPT");
17672 break;
17673 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC:
17674 printf ("XSAVEC");
17675 break;
17676 default:
17677 printf (_("<unknown: %x>"), bit);
17678 break;
17679 }
17680 if (bitmask)
17681 printf (", ");
17682 }
17683}
17684
17685static void
17686decode_aarch64_feature_1_and (unsigned int bitmask)
17687{
17688 while (bitmask)
17689 {
17690 unsigned int bit = bitmask & (- bitmask);
17691
17692 bitmask &= ~ bit;
17693 switch (bit)
17694 {
17695 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI:
17696 printf ("BTI");
17697 break;
17698
17699 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC:
17700 printf ("PAC");
17701 break;
17702
17703 default:
17704 printf (_("<unknown: %x>"), bit);
17705 break;
17706 }
17707 if (bitmask)
17708 printf (", ");
17709 }
17710}
17711
17712static void
17713print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
17714{
17715 unsigned char * ptr = (unsigned char *) pnote->descdata;
17716 unsigned char * ptr_end = ptr + pnote->descsz;
17717 unsigned int size = is_32bit_elf ? 4 : 8;
17718
17719 printf (_(" Properties: "));
17720
17721 if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
17722 {
17723 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
17724 return;
17725 }
17726
17727 while (ptr < ptr_end)
17728 {
17729 unsigned int j;
17730 unsigned int type;
17731 unsigned int datasz;
17732
17733 if ((size_t) (ptr_end - ptr) < 8)
17734 {
17735 printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
17736 break;
17737 }
17738
17739 type = byte_get (ptr, 4);
17740 datasz = byte_get (ptr + 4, 4);
17741
17742 ptr += 8;
17743
17744 if (datasz > (size_t) (ptr_end - ptr))
17745 {
17746 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17747 type, datasz);
17748 break;
17749 }
17750
17751 if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
17752 {
17753 if (filedata->file_header.e_machine == EM_X86_64
17754 || filedata->file_header.e_machine == EM_IAMCU
17755 || filedata->file_header.e_machine == EM_386)
17756 {
17757 unsigned int bitmask;
17758
17759 if (datasz == 4)
17760 bitmask = byte_get (ptr, 4);
17761 else
17762 bitmask = 0;
17763
17764 switch (type)
17765 {
17766 case GNU_PROPERTY_X86_ISA_1_USED:
17767 if (datasz != 4)
17768 printf (_("x86 ISA used: <corrupt length: %#x> "),
17769 datasz);
17770 else
17771 {
17772 printf ("x86 ISA used: ");
17773 decode_x86_isa (bitmask);
17774 }
17775 goto next;
17776
17777 case GNU_PROPERTY_X86_ISA_1_NEEDED:
17778 if (datasz != 4)
17779 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17780 datasz);
17781 else
17782 {
17783 printf ("x86 ISA needed: ");
17784 decode_x86_isa (bitmask);
17785 }
17786 goto next;
17787
17788 case GNU_PROPERTY_X86_FEATURE_1_AND:
17789 if (datasz != 4)
17790 printf (_("x86 feature: <corrupt length: %#x> "),
17791 datasz);
17792 else
17793 {
17794 printf ("x86 feature: ");
17795 decode_x86_feature_1 (bitmask);
17796 }
17797 goto next;
17798
17799 case GNU_PROPERTY_X86_FEATURE_2_USED:
17800 if (datasz != 4)
17801 printf (_("x86 feature used: <corrupt length: %#x> "),
17802 datasz);
17803 else
17804 {
17805 printf ("x86 feature used: ");
17806 decode_x86_feature_2 (bitmask);
17807 }
17808 goto next;
17809
17810 case GNU_PROPERTY_X86_FEATURE_2_NEEDED:
17811 if (datasz != 4)
17812 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz);
17813 else
17814 {
17815 printf ("x86 feature needed: ");
17816 decode_x86_feature_2 (bitmask);
17817 }
17818 goto next;
17819
17820 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED:
17821 if (datasz != 4)
17822 printf (_("x86 ISA used: <corrupt length: %#x> "),
17823 datasz);
17824 else
17825 {
17826 printf ("x86 ISA used: ");
17827 decode_x86_compat_isa (bitmask);
17828 }
17829 goto next;
17830
17831 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED:
17832 if (datasz != 4)
17833 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17834 datasz);
17835 else
17836 {
17837 printf ("x86 ISA needed: ");
17838 decode_x86_compat_isa (bitmask);
17839 }
17840 goto next;
17841
17842 default:
17843 break;
17844 }
17845 }
17846 else if (filedata->file_header.e_machine == EM_AARCH64)
17847 {
17848 if (type == GNU_PROPERTY_AARCH64_FEATURE_1_AND)
17849 {
17850 printf ("AArch64 feature: ");
17851 if (datasz != 4)
17852 printf (_("<corrupt length: %#x> "), datasz);
17853 else
17854 decode_aarch64_feature_1_and (byte_get (ptr, 4));
17855 goto next;
17856 }
17857 }
17858 }
17859 else
17860 {
17861 switch (type)
17862 {
17863 case GNU_PROPERTY_STACK_SIZE:
17864 printf (_("stack size: "));
17865 if (datasz != size)
17866 printf (_("<corrupt length: %#x> "), datasz);
17867 else
17868 printf ("%#lx", (unsigned long) byte_get (ptr, size));
17869 goto next;
17870
17871 case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
17872 printf ("no copy on protected ");
17873 if (datasz)
17874 printf (_("<corrupt length: %#x> "), datasz);
17875 goto next;
17876
17877 default:
17878 break;
17879 }
17880 }
17881
17882 if (type < GNU_PROPERTY_LOPROC)
17883 printf (_("<unknown type %#x data: "), type);
17884 else if (type < GNU_PROPERTY_LOUSER)
17885 printf (_("<procesor-specific type %#x data: "), type);
17886 else
17887 printf (_("<application-specific type %#x data: "), type);
17888 for (j = 0; j < datasz; ++j)
17889 printf ("%02x ", ptr[j] & 0xff);
17890 printf (">");
17891
17892next:
17893 ptr += ((datasz + (size - 1)) & ~ (size - 1));
17894 if (ptr == ptr_end)
17895 break;
17896
17897 if (do_wide)
17898 printf (", ");
17899 else
17900 printf ("\n\t");
17901 }
17902
17903 printf ("\n");
17904}
17905
17906static bfd_boolean
17907print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
17908{
17909 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
17910 switch (pnote->type)
17911 {
17912 case NT_GNU_BUILD_ID:
17913 {
17914 unsigned long i;
17915
17916 printf (_(" Build ID: "));
17917 for (i = 0; i < pnote->descsz; ++i)
17918 printf ("%02x", pnote->descdata[i] & 0xff);
17919 printf ("\n");
17920 }
17921 break;
17922
17923 case NT_GNU_ABI_TAG:
17924 {
17925 unsigned long os, major, minor, subminor;
17926 const char *osname;
17927
17928 /* PR 17531: file: 030-599401-0.004. */
17929 if (pnote->descsz < 16)
17930 {
17931 printf (_(" <corrupt GNU_ABI_TAG>\n"));
17932 break;
17933 }
17934
17935 os = byte_get ((unsigned char *) pnote->descdata, 4);
17936 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17937 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
17938 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
17939
17940 switch (os)
17941 {
17942 case GNU_ABI_TAG_LINUX:
17943 osname = "Linux";
17944 break;
17945 case GNU_ABI_TAG_HURD:
17946 osname = "Hurd";
17947 break;
17948 case GNU_ABI_TAG_SOLARIS:
17949 osname = "Solaris";
17950 break;
17951 case GNU_ABI_TAG_FREEBSD:
17952 osname = "FreeBSD";
17953 break;
17954 case GNU_ABI_TAG_NETBSD:
17955 osname = "NetBSD";
17956 break;
17957 case GNU_ABI_TAG_SYLLABLE:
17958 osname = "Syllable";
17959 break;
17960 case GNU_ABI_TAG_NACL:
17961 osname = "NaCl";
17962 break;
17963 default:
17964 osname = "Unknown";
17965 break;
17966 }
17967
17968 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
17969 major, minor, subminor);
17970 }
17971 break;
17972
17973 case NT_GNU_GOLD_VERSION:
17974 {
17975 unsigned long i;
17976
17977 printf (_(" Version: "));
17978 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
17979 printf ("%c", pnote->descdata[i]);
17980 printf ("\n");
17981 }
17982 break;
17983
17984 case NT_GNU_HWCAP:
17985 {
17986 unsigned long num_entries, mask;
17987
17988 /* Hardware capabilities information. Word 0 is the number of entries.
17989 Word 1 is a bitmask of enabled entries. The rest of the descriptor
17990 is a series of entries, where each entry is a single byte followed
17991 by a nul terminated string. The byte gives the bit number to test
17992 if enabled in the bitmask. */
17993 printf (_(" Hardware Capabilities: "));
17994 if (pnote->descsz < 8)
17995 {
17996 error (_("<corrupt GNU_HWCAP>\n"));
17997 return FALSE;
17998 }
17999 num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
18000 mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
18001 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
18002 /* FIXME: Add code to display the entries... */
18003 }
18004 break;
18005
18006 case NT_GNU_PROPERTY_TYPE_0:
18007 print_gnu_property_note (filedata, pnote);
18008 break;
18009
18010 default:
18011 /* Handle unrecognised types. An error message should have already been
18012 created by get_gnu_elf_note_type(), so all that we need to do is to
18013 display the data. */
18014 {
18015 unsigned long i;
18016
18017 printf (_(" Description data: "));
18018 for (i = 0; i < pnote->descsz; ++i)
18019 printf ("%02x ", pnote->descdata[i] & 0xff);
18020 printf ("\n");
18021 }
18022 break;
18023 }
18024
18025 return TRUE;
18026}
18027
18028static const char *
18029get_v850_elf_note_type (enum v850_notes n_type)
18030{
18031 static char buff[64];
18032
18033 switch (n_type)
18034 {
18035 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
18036 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
18037 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
18038 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
18039 case V850_NOTE_CACHE_INFO: return _("Use of cache");
18040 case V850_NOTE_MMU_INFO: return _("Use of MMU");
18041 default:
18042 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
18043 return buff;
18044 }
18045}
18046
18047static bfd_boolean
18048print_v850_note (Elf_Internal_Note * pnote)
18049{
18050 unsigned int val;
18051
18052 if (pnote->descsz != 4)
18053 return FALSE;
18054
18055 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
18056
18057 if (val == 0)
18058 {
18059 printf (_("not set\n"));
18060 return TRUE;
18061 }
18062
18063 switch (pnote->type)
18064 {
18065 case V850_NOTE_ALIGNMENT:
18066 switch (val)
18067 {
18068 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
18069 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
18070 }
18071 break;
18072
18073 case V850_NOTE_DATA_SIZE:
18074 switch (val)
18075 {
18076 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
18077 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
18078 }
18079 break;
18080
18081 case V850_NOTE_FPU_INFO:
18082 switch (val)
18083 {
18084 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
18085 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
18086 }
18087 break;
18088
18089 case V850_NOTE_MMU_INFO:
18090 case V850_NOTE_CACHE_INFO:
18091 case V850_NOTE_SIMD_INFO:
18092 if (val == EF_RH850_SIMD)
18093 {
18094 printf (_("yes\n"));
18095 return TRUE;
18096 }
18097 break;
18098
18099 default:
18100 /* An 'unknown note type' message will already have been displayed. */
18101 break;
18102 }
18103
18104 printf (_("unknown value: %x\n"), val);
18105 return FALSE;
18106}
18107
18108static bfd_boolean
18109process_netbsd_elf_note (Elf_Internal_Note * pnote)
18110{
18111 unsigned int version;
18112
18113 switch (pnote->type)
18114 {
18115 case NT_NETBSD_IDENT:
18116 version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
18117 if ((version / 10000) % 100)
18118 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
18119 version, version / 100000000, (version / 1000000) % 100,
18120 (version / 10000) % 100 > 26 ? "Z" : "",
18121 'A' + (version / 10000) % 26);
18122 else
18123 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
18124 version, version / 100000000, (version / 1000000) % 100,
18125 (version / 100) % 100);
18126 return TRUE;
18127
18128 case NT_NETBSD_MARCH:
18129 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
18130 pnote->descdata);
18131 return TRUE;
18132
18133#ifdef NT_NETBSD_PAX
18134 case NT_NETBSD_PAX:
18135 version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
18136 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote->descsz,
18137 ((version & NT_NETBSD_PAX_MPROTECT) ? "+mprotect" : ""),
18138 ((version & NT_NETBSD_PAX_NOMPROTECT) ? "-mprotect" : ""),
18139 ((version & NT_NETBSD_PAX_GUARD) ? "+guard" : ""),
18140 ((version & NT_NETBSD_PAX_NOGUARD) ? "-guard" : ""),
18141 ((version & NT_NETBSD_PAX_ASLR) ? "+ASLR" : ""),
18142 ((version & NT_NETBSD_PAX_NOASLR) ? "-ASLR" : ""));
18143 return TRUE;
18144#endif
18145
18146 default:
18147 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
18148 pnote->type);
18149 return FALSE;
18150 }
18151}
18152
18153static const char *
18154get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
18155{
18156 switch (e_type)
18157 {
18158 case NT_FREEBSD_THRMISC:
18159 return _("NT_THRMISC (thrmisc structure)");
18160 case NT_FREEBSD_PROCSTAT_PROC:
18161 return _("NT_PROCSTAT_PROC (proc data)");
18162 case NT_FREEBSD_PROCSTAT_FILES:
18163 return _("NT_PROCSTAT_FILES (files data)");
18164 case NT_FREEBSD_PROCSTAT_VMMAP:
18165 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18166 case NT_FREEBSD_PROCSTAT_GROUPS:
18167 return _("NT_PROCSTAT_GROUPS (groups data)");
18168 case NT_FREEBSD_PROCSTAT_UMASK:
18169 return _("NT_PROCSTAT_UMASK (umask data)");
18170 case NT_FREEBSD_PROCSTAT_RLIMIT:
18171 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18172 case NT_FREEBSD_PROCSTAT_OSREL:
18173 return _("NT_PROCSTAT_OSREL (osreldate data)");
18174 case NT_FREEBSD_PROCSTAT_PSSTRINGS:
18175 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18176 case NT_FREEBSD_PROCSTAT_AUXV:
18177 return _("NT_PROCSTAT_AUXV (auxv data)");
18178 case NT_FREEBSD_PTLWPINFO:
18179 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18180 }
18181 return get_note_type (filedata, e_type);
18182}
18183
18184static const char *
18185get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
18186{
18187 static char buff[64];
18188
18189 switch (e_type)
18190 {
18191 case NT_NETBSDCORE_PROCINFO:
18192 /* NetBSD core "procinfo" structure. */
18193 return _("NetBSD procinfo structure");
18194
18195#ifdef NT_NETBSDCORE_AUXV
18196 case NT_NETBSDCORE_AUXV:
18197 return _("NetBSD ELF auxiliary vector data");
18198#endif
18199
18200 default:
18201 /* As of Jan 2002 there are no other machine-independent notes
18202 defined for NetBSD core files. If the note type is less
18203 than the start of the machine-dependent note types, we don't
18204 understand it. */
18205
18206 if (e_type < NT_NETBSDCORE_FIRSTMACH)
18207 {
18208 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18209 return buff;
18210 }
18211 break;
18212 }
18213
18214 switch (filedata->file_header.e_machine)
18215 {
18216 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18217 and PT_GETFPREGS == mach+2. */
18218
18219 case EM_OLD_ALPHA:
18220 case EM_ALPHA:
18221 case EM_SPARC:
18222 case EM_SPARC32PLUS:
18223 case EM_SPARCV9:
18224 switch (e_type)
18225 {
18226 case NT_NETBSDCORE_FIRSTMACH + 0:
18227 return _("PT_GETREGS (reg structure)");
18228 case NT_NETBSDCORE_FIRSTMACH + 2:
18229 return _("PT_GETFPREGS (fpreg structure)");
18230 default:
18231 break;
18232 }
18233 break;
18234
18235 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18236 There's also old PT___GETREGS40 == mach + 1 for old reg
18237 structure which lacks GBR. */
18238 case EM_SH:
18239 switch (e_type)
18240 {
18241 case NT_NETBSDCORE_FIRSTMACH + 1:
18242 return _("PT___GETREGS40 (old reg structure)");
18243 case NT_NETBSDCORE_FIRSTMACH + 3:
18244 return _("PT_GETREGS (reg structure)");
18245 case NT_NETBSDCORE_FIRSTMACH + 5:
18246 return _("PT_GETFPREGS (fpreg structure)");
18247 default:
18248 break;
18249 }
18250 break;
18251
18252 /* On all other arch's, PT_GETREGS == mach+1 and
18253 PT_GETFPREGS == mach+3. */
18254 default:
18255 switch (e_type)
18256 {
18257 case NT_NETBSDCORE_FIRSTMACH + 1:
18258 return _("PT_GETREGS (reg structure)");
18259 case NT_NETBSDCORE_FIRSTMACH + 3:
18260 return _("PT_GETFPREGS (fpreg structure)");
18261 default:
18262 break;
18263 }
18264 }
18265
18266 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
18267 e_type - NT_NETBSDCORE_FIRSTMACH);
18268 return buff;
18269}
18270
18271static const char *
18272get_stapsdt_note_type (unsigned e_type)
18273{
18274 static char buff[64];
18275
18276 switch (e_type)
18277 {
18278 case NT_STAPSDT:
18279 return _("NT_STAPSDT (SystemTap probe descriptors)");
18280
18281 default:
18282 break;
18283 }
18284
18285 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18286 return buff;
18287}
18288
18289static bfd_boolean
18290print_stapsdt_note (Elf_Internal_Note *pnote)
18291{
18292 size_t len, maxlen;
18293 unsigned long addr_size = is_32bit_elf ? 4 : 8;
18294 char *data = pnote->descdata;
18295 char *data_end = pnote->descdata + pnote->descsz;
18296 bfd_vma pc, base_addr, semaphore;
18297 char *provider, *probe, *arg_fmt;
18298
18299 if (pnote->descsz < (addr_size * 3))
18300 goto stapdt_note_too_small;
18301
18302 pc = byte_get ((unsigned char *) data, addr_size);
18303 data += addr_size;
18304
18305 base_addr = byte_get ((unsigned char *) data, addr_size);
18306 data += addr_size;
18307
18308 semaphore = byte_get ((unsigned char *) data, addr_size);
18309 data += addr_size;
18310
18311 if (data >= data_end)
18312 goto stapdt_note_too_small;
18313 maxlen = data_end - data;
18314 len = strnlen (data, maxlen);
18315 if (len < maxlen)
18316 {
18317 provider = data;
18318 data += len + 1;
18319 }
18320 else
18321 goto stapdt_note_too_small;
18322
18323 if (data >= data_end)
18324 goto stapdt_note_too_small;
18325 maxlen = data_end - data;
18326 len = strnlen (data, maxlen);
18327 if (len < maxlen)
18328 {
18329 probe = data;
18330 data += len + 1;
18331 }
18332 else
18333 goto stapdt_note_too_small;
18334
18335 if (data >= data_end)
18336 goto stapdt_note_too_small;
18337 maxlen = data_end - data;
18338 len = strnlen (data, maxlen);
18339 if (len < maxlen)
18340 {
18341 arg_fmt = data;
18342 data += len + 1;
18343 }
18344 else
18345 goto stapdt_note_too_small;
18346
18347 printf (_(" Provider: %s\n"), provider);
18348 printf (_(" Name: %s\n"), probe);
18349 printf (_(" Location: "));
18350 print_vma (pc, FULL_HEX);
18351 printf (_(", Base: "));
18352 print_vma (base_addr, FULL_HEX);
18353 printf (_(", Semaphore: "));
18354 print_vma (semaphore, FULL_HEX);
18355 printf ("\n");
18356 printf (_(" Arguments: %s\n"), arg_fmt);
18357
18358 return data == data_end;
18359
18360 stapdt_note_too_small:
18361 printf (_(" <corrupt - note is too small>\n"));
18362 error (_("corrupt stapdt note - the data size is too small\n"));
18363 return FALSE;
18364}
18365
18366static const char *
18367get_ia64_vms_note_type (unsigned e_type)
18368{
18369 static char buff[64];
18370
18371 switch (e_type)
18372 {
18373 case NT_VMS_MHD:
18374 return _("NT_VMS_MHD (module header)");
18375 case NT_VMS_LNM:
18376 return _("NT_VMS_LNM (language name)");
18377 case NT_VMS_SRC:
18378 return _("NT_VMS_SRC (source files)");
18379 case NT_VMS_TITLE:
18380 return "NT_VMS_TITLE";
18381 case NT_VMS_EIDC:
18382 return _("NT_VMS_EIDC (consistency check)");
18383 case NT_VMS_FPMODE:
18384 return _("NT_VMS_FPMODE (FP mode)");
18385 case NT_VMS_LINKTIME:
18386 return "NT_VMS_LINKTIME";
18387 case NT_VMS_IMGNAM:
18388 return _("NT_VMS_IMGNAM (image name)");
18389 case NT_VMS_IMGID:
18390 return _("NT_VMS_IMGID (image id)");
18391 case NT_VMS_LINKID:
18392 return _("NT_VMS_LINKID (link id)");
18393 case NT_VMS_IMGBID:
18394 return _("NT_VMS_IMGBID (build id)");
18395 case NT_VMS_GSTNAM:
18396 return _("NT_VMS_GSTNAM (sym table name)");
18397 case NT_VMS_ORIG_DYN:
18398 return "NT_VMS_ORIG_DYN";
18399 case NT_VMS_PATCHTIME:
18400 return "NT_VMS_PATCHTIME";
18401 default:
18402 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18403 return buff;
18404 }
18405}
18406
18407static bfd_boolean
18408print_ia64_vms_note (Elf_Internal_Note * pnote)
18409{
18410 int maxlen = pnote->descsz;
18411
18412 if (maxlen < 2 || (unsigned long) maxlen != pnote->descsz)
18413 goto desc_size_fail;
18414
18415 switch (pnote->type)
18416 {
18417 case NT_VMS_MHD:
18418 if (maxlen <= 36)
18419 goto desc_size_fail;
18420
18421 int l = (int) strnlen (pnote->descdata + 34, maxlen - 34);
18422
18423 printf (_(" Creation date : %.17s\n"), pnote->descdata);
18424 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
18425 if (l + 34 < maxlen)
18426 {
18427 printf (_(" Module name : %s\n"), pnote->descdata + 34);
18428 if (l + 35 < maxlen)
18429 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
18430 else
18431 printf (_(" Module version : <missing>\n"));
18432 }
18433 else
18434 {
18435 printf (_(" Module name : <missing>\n"));
18436 printf (_(" Module version : <missing>\n"));
18437 }
18438 break;
18439
18440 case NT_VMS_LNM:
18441 printf (_(" Language: %.*s\n"), maxlen, pnote->descdata);
18442 break;
18443
18444#ifdef BFD64
18445 case NT_VMS_FPMODE:
18446 printf (_(" Floating Point mode: "));
18447 if (maxlen < 8)
18448 goto desc_size_fail;
18449 /* FIXME: Generate an error if descsz > 8 ? */
18450
18451 printf ("0x%016" BFD_VMA_FMT "x\n",
18452 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
18453 break;
18454
18455 case NT_VMS_LINKTIME:
18456 printf (_(" Link time: "));
18457 if (maxlen < 8)
18458 goto desc_size_fail;
18459 /* FIXME: Generate an error if descsz > 8 ? */
18460
18461 print_vms_time
18462 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
18463 printf ("\n");
18464 break;
18465
18466 case NT_VMS_PATCHTIME:
18467 printf (_(" Patch time: "));
18468 if (maxlen < 8)
18469 goto desc_size_fail;
18470 /* FIXME: Generate an error if descsz > 8 ? */
18471
18472 print_vms_time
18473 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
18474 printf ("\n");
18475 break;
18476
18477 case NT_VMS_ORIG_DYN:
18478 if (maxlen < 34)
18479 goto desc_size_fail;
18480
18481 printf (_(" Major id: %u, minor id: %u\n"),
18482 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
18483 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
18484 printf (_(" Last modified : "));
18485 print_vms_time
18486 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
18487 printf (_("\n Link flags : "));
18488 printf ("0x%016" BFD_VMA_FMT "x\n",
18489 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
18490 printf (_(" Header flags: 0x%08x\n"),
18491 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
18492 printf (_(" Image id : %.*s\n"), maxlen - 32, pnote->descdata + 32);
18493 break;
18494#endif
18495
18496 case NT_VMS_IMGNAM:
18497 printf (_(" Image name: %.*s\n"), maxlen, pnote->descdata);
18498 break;
18499
18500 case NT_VMS_GSTNAM:
18501 printf (_(" Global symbol table name: %.*s\n"), maxlen, pnote->descdata);
18502 break;
18503
18504 case NT_VMS_IMGID:
18505 printf (_(" Image id: %.*s\n"), maxlen, pnote->descdata);
18506 break;
18507
18508 case NT_VMS_LINKID:
18509 printf (_(" Linker id: %.*s\n"), maxlen, pnote->descdata);
18510 break;
18511
18512 default:
18513 return FALSE;
18514 }
18515
18516 return TRUE;
18517
18518 desc_size_fail:
18519 printf (_(" <corrupt - data size is too small>\n"));
18520 error (_("corrupt IA64 note: data size is too small\n"));
18521 return FALSE;
18522}
18523
18524/* Find the symbol associated with a build attribute that is attached
18525 to address OFFSET. If PNAME is non-NULL then store the name of
18526 the symbol (if found) in the provided pointer, Returns NULL if a
18527 symbol could not be found. */
18528
18529static Elf_Internal_Sym *
18530get_symbol_for_build_attribute (Filedata * filedata,
18531 unsigned long offset,
18532 bfd_boolean is_open_attr,
18533 const char ** pname)
18534{
18535 static Filedata * saved_filedata = NULL;
18536 static char * strtab;
18537 static unsigned long strtablen;
18538 static Elf_Internal_Sym * symtab;
18539 static unsigned long nsyms;
18540 Elf_Internal_Sym * saved_sym = NULL;
18541 Elf_Internal_Sym * sym;
18542
18543 if (filedata->section_headers != NULL
18544 && (saved_filedata == NULL || filedata != saved_filedata))
18545 {
18546 Elf_Internal_Shdr * symsec;
18547
18548 /* Load the symbol and string sections. */
18549 for (symsec = filedata->section_headers;
18550 symsec < filedata->section_headers + filedata->file_header.e_shnum;
18551 symsec ++)
18552 {
18553 if (symsec->sh_type == SHT_SYMTAB)
18554 {
18555 symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
18556
18557 if (symsec->sh_link < filedata->file_header.e_shnum)
18558 {
18559 Elf_Internal_Shdr * strtab_sec = filedata->section_headers + symsec->sh_link;
18560
18561 strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
18562 1, strtab_sec->sh_size,
18563 _("string table"));
18564 strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
18565 }
18566 }
18567 }
18568 saved_filedata = filedata;
18569 }
18570
18571 if (symtab == NULL || strtab == NULL)
18572 return NULL;
18573
18574 /* Find a symbol whose value matches offset. */
18575 for (sym = symtab; sym < symtab + nsyms; sym ++)
18576 if (sym->st_value == offset)
18577 {
18578 if (sym->st_name >= strtablen)
18579 /* Huh ? This should not happen. */
18580 continue;
18581
18582 if (strtab[sym->st_name] == 0)
18583 continue;
18584
18585 /* The AArch64 and ARM architectures define mapping symbols
18586 (eg $d, $x, $t) which we want to ignore. */
18587 if (strtab[sym->st_name] == '$'
18588 && strtab[sym->st_name + 1] != 0
18589 && strtab[sym->st_name + 2] == 0)
18590 continue;
18591
18592 if (is_open_attr)
18593 {
18594 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
18595 and FILE or OBJECT symbols over NOTYPE symbols. We skip
18596 FUNC symbols entirely. */
18597 switch (ELF_ST_TYPE (sym->st_info))
18598 {
18599 case STT_OBJECT:
18600 case STT_FILE:
18601 saved_sym = sym;
18602 if (sym->st_size)
18603 {
18604 /* If the symbol has a size associated
18605 with it then we can stop searching. */
18606 sym = symtab + nsyms;
18607 }
18608 continue;
18609
18610 case STT_FUNC:
18611 /* Ignore function symbols. */
18612 continue;
18613
18614 default:
18615 break;
18616 }
18617
18618 switch (ELF_ST_BIND (sym->st_info))
18619 {
18620 case STB_GLOBAL:
18621 if (saved_sym == NULL
18622 || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
18623 saved_sym = sym;
18624 break;
18625
18626 case STB_LOCAL:
18627 if (saved_sym == NULL)
18628 saved_sym = sym;
18629 break;
18630
18631 default:
18632 break;
18633 }
18634 }
18635 else
18636 {
18637 if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
18638 continue;
18639
18640 saved_sym = sym;
18641 break;
18642 }
18643 }
18644
18645 if (saved_sym && pname)
18646 * pname = strtab + saved_sym->st_name;
18647
18648 return saved_sym;
18649}
18650
18651/* Returns true iff addr1 and addr2 are in the same section. */
18652
18653static bfd_boolean
18654same_section (Filedata * filedata, unsigned long addr1, unsigned long addr2)
18655{
18656 Elf_Internal_Shdr * a1;
18657 Elf_Internal_Shdr * a2;
18658
18659 a1 = find_section_by_address (filedata, addr1);
18660 a2 = find_section_by_address (filedata, addr2);
18661
18662 return a1 == a2 && a1 != NULL;
18663}
18664
18665static bfd_boolean
18666print_gnu_build_attribute_description (Elf_Internal_Note * pnote,
18667 Filedata * filedata)
18668{
18669 static unsigned long global_offset = 0;
18670 static unsigned long global_end = 0;
18671 static unsigned long func_offset = 0;
18672 static unsigned long func_end = 0;
18673
18674 Elf_Internal_Sym * sym;
18675 const char * name;
18676 unsigned long start;
18677 unsigned long end;
18678 bfd_boolean is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
18679
18680 switch (pnote->descsz)
18681 {
18682 case 0:
18683 /* A zero-length description means that the range of
18684 the previous note of the same type should be used. */
18685 if (is_open_attr)
18686 {
18687 if (global_end > global_offset)
18688 printf (_(" Applies to region from %#lx to %#lx\n"),
18689 global_offset, global_end);
18690 else
18691 printf (_(" Applies to region from %#lx\n"), global_offset);
18692 }
18693 else
18694 {
18695 if (func_end > func_offset)
18696 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset, func_end);
18697 else
18698 printf (_(" Applies to region from %#lx\n"), func_offset);
18699 }
18700 return TRUE;
18701
18702 case 4:
18703 start = byte_get ((unsigned char *) pnote->descdata, 4);
18704 end = 0;
18705 break;
18706
18707 case 8:
18708 if (is_32bit_elf)
18709 {
18710 /* FIXME: We should check that version 3+ notes are being used here... */
18711 start = byte_get ((unsigned char *) pnote->descdata, 4);
18712 end = byte_get ((unsigned char *) pnote->descdata + 4, 4);
18713 }
18714 else
18715 {
18716 start = byte_get ((unsigned char *) pnote->descdata, 8);
18717 end = 0;
18718 }
18719 break;
18720
18721 case 16:
18722 start = byte_get ((unsigned char *) pnote->descdata, 8);
18723 end = byte_get ((unsigned char *) pnote->descdata + 8, 8);
18724 break;
18725
18726 default:
18727 error (_(" <invalid description size: %lx>\n"), pnote->descsz);
18728 printf (_(" <invalid descsz>"));
18729 return FALSE;
18730 }
18731
18732 name = NULL;
18733 sym = get_symbol_for_build_attribute (filedata, start, is_open_attr, & name);
18734 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
18735 in order to avoid them being confused with the start address of the
18736 first function in the file... */
18737 if (sym == NULL && is_open_attr)
18738 sym = get_symbol_for_build_attribute (filedata, start + 2, is_open_attr,
18739 & name);
18740
18741 if (end == 0 && sym != NULL && sym->st_size > 0)
18742 end = start + sym->st_size;
18743
18744 if (is_open_attr)
18745 {
18746 /* FIXME: Need to properly allow for section alignment.
18747 16 is just the alignment used on x86_64. */
18748 if (global_end > 0
18749 && start > BFD_ALIGN (global_end, 16)
18750 /* Build notes are not guaranteed to be organised in order of
18751 increasing address, but we should find the all of the notes
18752 for one section in the same place. */
18753 && same_section (filedata, start, global_end))
18754 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
18755 global_end + 1, start - 1);
18756
18757 printf (_(" Applies to region from %#lx"), start);
18758 global_offset = start;
18759
18760 if (end)
18761 {
18762 printf (_(" to %#lx"), end);
18763 global_end = end;
18764 }
18765 }
18766 else
18767 {
18768 printf (_(" Applies to region from %#lx"), start);
18769 func_offset = start;
18770
18771 if (end)
18772 {
18773 printf (_(" to %#lx"), end);
18774 func_end = end;
18775 }
18776 }
18777
18778 if (sym && name)
18779 printf (_(" (%s)"), name);
18780
18781 printf ("\n");
18782 return TRUE;
18783}
18784
18785static bfd_boolean
18786print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
18787{
18788 static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
18789 static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
18790 static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
18791 char name_type;
18792 char name_attribute;
18793 const char * expected_types;
18794 const char * name = pnote->namedata;
18795 const char * text;
18796 signed int left;
18797
18798 if (name == NULL || pnote->namesz < 2)
18799 {
18800 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18801 print_symbol (-20, _(" <corrupt name>"));
18802 return FALSE;
18803 }
18804
18805 if (do_wide)
18806 left = 28;
18807 else
18808 left = 20;
18809
18810 /* Version 2 of the spec adds a "GA" prefix to the name field. */
18811 if (name[0] == 'G' && name[1] == 'A')
18812 {
18813 if (pnote->namesz < 4)
18814 {
18815 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18816 print_symbol (-20, _(" <corrupt name>"));
18817 return FALSE;
18818 }
18819
18820 printf ("GA");
18821 name += 2;
18822 left -= 2;
18823 }
18824
18825 switch ((name_type = * name))
18826 {
18827 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
18828 case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
18829 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
18830 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
18831 printf ("%c", * name);
18832 left --;
18833 break;
18834 default:
18835 error (_("unrecognised attribute type in name field: %d\n"), name_type);
18836 print_symbol (-20, _("<unknown name type>"));
18837 return FALSE;
18838 }
18839
18840 ++ name;
18841 text = NULL;
18842
18843 switch ((name_attribute = * name))
18844 {
18845 case GNU_BUILD_ATTRIBUTE_VERSION:
18846 text = _("<version>");
18847 expected_types = string_expected;
18848 ++ name;
18849 break;
18850 case GNU_BUILD_ATTRIBUTE_STACK_PROT:
18851 text = _("<stack prot>");
18852 expected_types = "!+*";
18853 ++ name;
18854 break;
18855 case GNU_BUILD_ATTRIBUTE_RELRO:
18856 text = _("<relro>");
18857 expected_types = bool_expected;
18858 ++ name;
18859 break;
18860 case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
18861 text = _("<stack size>");
18862 expected_types = number_expected;
18863 ++ name;
18864 break;
18865 case GNU_BUILD_ATTRIBUTE_TOOL:
18866 text = _("<tool>");
18867 expected_types = string_expected;
18868 ++ name;
18869 break;
18870 case GNU_BUILD_ATTRIBUTE_ABI:
18871 text = _("<ABI>");
18872 expected_types = "$*";
18873 ++ name;
18874 break;
18875 case GNU_BUILD_ATTRIBUTE_PIC:
18876 text = _("<PIC>");
18877 expected_types = number_expected;
18878 ++ name;
18879 break;
18880 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
18881 text = _("<short enum>");
18882 expected_types = bool_expected;
18883 ++ name;
18884 break;
18885 default:
18886 if (ISPRINT (* name))
18887 {
18888 int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
18889
18890 if (len > left && ! do_wide)
18891 len = left;
18892 printf ("%.*s:", len, name);
18893 left -= len;
18894 name += len;
18895 }
18896 else
18897 {
18898 static char tmpbuf [128];
18899
18900 error (_("unrecognised byte in name field: %d\n"), * name);
18901 sprintf (tmpbuf, _("<unknown:_%d>"), * name);
18902 text = tmpbuf;
18903 name ++;
18904 }
18905 expected_types = "*$!+";
18906 break;
18907 }
18908
18909 if (text)
18910 left -= printf ("%s", text);
18911
18912 if (strchr (expected_types, name_type) == NULL)
18913 warn (_("attribute does not have an expected type (%c)\n"), name_type);
18914
18915 if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
18916 {
18917 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
18918 (unsigned long) pnote->namesz,
18919 (long) (name - pnote->namedata));
18920 return FALSE;
18921 }
18922
18923 if (left < 1 && ! do_wide)
18924 return TRUE;
18925
18926 switch (name_type)
18927 {
18928 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
18929 {
18930 unsigned int bytes;
18931 unsigned long long val = 0;
18932 unsigned int shift = 0;
18933 char * decoded = NULL;
18934
18935 bytes = pnote->namesz - (name - pnote->namedata);
18936 if (bytes > 0)
18937 /* The -1 is because the name field is always 0 terminated, and we
18938 want to be able to ensure that the shift in the while loop below
18939 will not overflow. */
18940 -- bytes;
18941
18942 if (bytes > sizeof (val))
18943 {
18944 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
18945 bytes);
18946 bytes = sizeof (val);
18947 }
18948 /* We do not bother to warn if bytes == 0 as this can
18949 happen with some early versions of the gcc plugin. */
18950
18951 while (bytes --)
18952 {
18953 unsigned long byte = (* name ++) & 0xff;
18954
18955 val |= byte << shift;
18956 shift += 8;
18957 }
18958
18959 switch (name_attribute)
18960 {
18961 case GNU_BUILD_ATTRIBUTE_PIC:
18962 switch (val)
18963 {
18964 case 0: decoded = "static"; break;
18965 case 1: decoded = "pic"; break;
18966 case 2: decoded = "PIC"; break;
18967 case 3: decoded = "pie"; break;
18968 case 4: decoded = "PIE"; break;
18969 default: break;
18970 }
18971 break;
18972 case GNU_BUILD_ATTRIBUTE_STACK_PROT:
18973 switch (val)
18974 {
18975 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
18976 case 0: decoded = "off"; break;
18977 case 1: decoded = "on"; break;
18978 case 2: decoded = "all"; break;
18979 case 3: decoded = "strong"; break;
18980 case 4: decoded = "explicit"; break;
18981 default: break;
18982 }
18983 break;
18984 default:
18985 break;
18986 }
18987
18988 if (decoded != NULL)
18989 {
18990 print_symbol (-left, decoded);
18991 left = 0;
18992 }
18993 else if (val == 0)
18994 {
18995 printf ("0x0");
18996 left -= 3;
18997 }
18998 else
18999 {
19000 if (do_wide)
19001 left -= printf ("0x%llx", val);
19002 else
19003 left -= printf ("0x%-.*llx", left, val);
19004 }
19005 }
19006 break;
19007 case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
19008 left -= print_symbol (- left, name);
19009 break;
19010 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
19011 left -= print_symbol (- left, "true");
19012 break;
19013 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
19014 left -= print_symbol (- left, "false");
19015 break;
19016 }
19017
19018 if (do_wide && left > 0)
19019 printf ("%-*s", left, " ");
19020
19021 return TRUE;
19022}
19023
19024/* Note that by the ELF standard, the name field is already null byte
19025 terminated, and namesz includes the terminating null byte.
19026 I.E. the value of namesz for the name "FSF" is 4.
19027
19028 If the value of namesz is zero, there is no name present. */
19029
19030static bfd_boolean
19031process_note (Elf_Internal_Note * pnote,
19032 Filedata * filedata)
19033{
19034 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
19035 const char * nt;
19036
19037 if (pnote->namesz == 0)
19038 /* If there is no note name, then use the default set of
19039 note type strings. */
19040 nt = get_note_type (filedata, pnote->type);
19041
19042 else if (const_strneq (pnote->namedata, "GNU"))
19043 /* GNU-specific object file notes. */
19044 nt = get_gnu_elf_note_type (pnote->type);
19045
19046 else if (const_strneq (pnote->namedata, "FreeBSD"))
19047 /* FreeBSD-specific core file notes. */
19048 nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
19049
19050 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
19051 /* NetBSD-specific core file notes. */
19052 nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
19053
19054 else if (const_strneq (pnote->namedata, "NetBSD"))
19055 /* NetBSD-specific core file notes. */
19056 return process_netbsd_elf_note (pnote);
19057
19058 else if (const_strneq (pnote->namedata, "PaX"))
19059 /* NetBSD-specific core file notes. */
19060 return process_netbsd_elf_note (pnote);
19061
19062 else if (strneq (pnote->namedata, "SPU/", 4))
19063 {
19064 /* SPU-specific core file notes. */
19065 nt = pnote->namedata + 4;
19066 name = "SPU";
19067 }
19068
19069 else if (const_strneq (pnote->namedata, "IPF/VMS"))
19070 /* VMS/ia64-specific file notes. */
19071 nt = get_ia64_vms_note_type (pnote->type);
19072
19073 else if (const_strneq (pnote->namedata, "stapsdt"))
19074 nt = get_stapsdt_note_type (pnote->type);
19075
19076 else
19077 /* Don't recognize this note name; just use the default set of
19078 note type strings. */
19079 nt = get_note_type (filedata, pnote->type);
19080
19081 printf (" ");
19082
19083 if (((const_strneq (pnote->namedata, "GA")
19084 && strchr ("*$!+", pnote->namedata[2]) != NULL)
19085 || strchr ("*$!+", pnote->namedata[0]) != NULL)
19086 && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
19087 || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
19088 print_gnu_build_attribute_name (pnote);
19089 else
19090 print_symbol (-20, name);
19091
19092 if (do_wide)
19093 printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
19094 else
19095 printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
19096
19097 if (const_strneq (pnote->namedata, "IPF/VMS"))
19098 return print_ia64_vms_note (pnote);
19099 else if (const_strneq (pnote->namedata, "GNU"))
19100 return print_gnu_note (filedata, pnote);
19101 else if (const_strneq (pnote->namedata, "stapsdt"))
19102 return print_stapsdt_note (pnote);
19103 else if (const_strneq (pnote->namedata, "CORE"))
19104 return print_core_note (pnote);
19105 else if (((const_strneq (pnote->namedata, "GA")
19106 && strchr ("*$!+", pnote->namedata[2]) != NULL)
19107 || strchr ("*$!+", pnote->namedata[0]) != NULL)
19108 && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
19109 || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
19110 return print_gnu_build_attribute_description (pnote, filedata);
19111
19112 if (pnote->descsz)
19113 {
19114 unsigned long i;
19115
19116 printf (_(" description data: "));
19117 for (i = 0; i < pnote->descsz; i++)
19118 printf ("%02x ", pnote->descdata[i] & 0xff);
19119 if (!do_wide)
19120 printf ("\n");
19121 }
19122
19123 if (do_wide)
19124 printf ("\n");
19125
19126 return TRUE;
19127}
19128
19129static bfd_boolean
19130process_notes_at (Filedata * filedata,
19131 Elf_Internal_Shdr * section,
19132 bfd_vma offset,
19133 bfd_vma length,
19134 bfd_vma align)
19135{
19136 Elf_External_Note * pnotes;
19137 Elf_External_Note * external;
19138 char * end;
19139 bfd_boolean res = TRUE;
19140
19141 if (length <= 0)
19142 return FALSE;
19143
19144 if (section)
19145 {
19146 pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
19147 if (pnotes)
19148 {
19149 if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
19150 return FALSE;
19151 }
19152 }
19153 else
19154 pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
19155 _("notes"));
19156
19157 if (pnotes == NULL)
19158 return FALSE;
19159
19160 external = pnotes;
19161
19162 if (section)
19163 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
19164 else
19165 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19166 (unsigned long) offset, (unsigned long) length);
19167
19168 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19169 specifies that notes should be aligned to 4 bytes in 32-bit
19170 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19171 we also support 4 byte alignment in 64-bit objects. If section
19172 alignment is less than 4, we treate alignment as 4 bytes. */
19173 if (align < 4)
19174 align = 4;
19175 else if (align != 4 && align != 8)
19176 {
19177 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19178 (long) align);
19179 return FALSE;
19180 }
19181
19182 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
19183
19184 end = (char *) pnotes + length;
19185 while ((char *) external < end)
19186 {
19187 Elf_Internal_Note inote;
19188 size_t min_notesz;
19189 char * next;
19190 char * temp = NULL;
19191 size_t data_remaining = end - (char *) external;
19192
19193 if (!is_ia64_vms (filedata))
19194 {
19195 /* PR binutils/15191
19196 Make sure that there is enough data to read. */
19197 min_notesz = offsetof (Elf_External_Note, name);
19198 if (data_remaining < min_notesz)
19199 {
19200 warn (ngettext ("Corrupt note: only %ld byte remains, "
19201 "not enough for a full note\n",
19202 "Corrupt note: only %ld bytes remain, "
19203 "not enough for a full note\n",
19204 data_remaining),
19205 (long) data_remaining);
19206 break;
19207 }
19208 data_remaining -= min_notesz;
19209
19210 inote.type = BYTE_GET (external->type);
19211 inote.namesz = BYTE_GET (external->namesz);
19212 inote.namedata = external->name;
19213 inote.descsz = BYTE_GET (external->descsz);
19214 inote.descdata = ((char *) external
19215 + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
19216 inote.descpos = offset + (inote.descdata - (char *) pnotes);
19217 next = ((char *) external
19218 + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
19219 }
19220 else
19221 {
19222 Elf64_External_VMS_Note *vms_external;
19223
19224 /* PR binutils/15191
19225 Make sure that there is enough data to read. */
19226 min_notesz = offsetof (Elf64_External_VMS_Note, name);
19227 if (data_remaining < min_notesz)
19228 {
19229 warn (ngettext ("Corrupt note: only %ld byte remains, "
19230 "not enough for a full note\n",
19231 "Corrupt note: only %ld bytes remain, "
19232 "not enough for a full note\n",
19233 data_remaining),
19234 (long) data_remaining);
19235 break;
19236 }
19237 data_remaining -= min_notesz;
19238
19239 vms_external = (Elf64_External_VMS_Note *) external;
19240 inote.type = BYTE_GET (vms_external->type);
19241 inote.namesz = BYTE_GET (vms_external->namesz);
19242 inote.namedata = vms_external->name;
19243 inote.descsz = BYTE_GET (vms_external->descsz);
19244 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
19245 inote.descpos = offset + (inote.descdata - (char *) pnotes);
19246 next = inote.descdata + align_power (inote.descsz, 3);
19247 }
19248
19249 /* PR 17531: file: 3443835e. */
19250 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19251 if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
19252 || (size_t) (inote.descdata - inote.namedata) > data_remaining
19253 || (size_t) (next - inote.descdata) < inote.descsz
19254 || ((size_t) (next - inote.descdata)
19255 > data_remaining - (size_t) (inote.descdata - inote.namedata)))
19256 {
19257 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19258 (unsigned long) ((char *) external - (char *) pnotes));
19259 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19260 inote.type, inote.namesz, inote.descsz, (int) align);
19261 break;
19262 }
19263
19264 external = (Elf_External_Note *) next;
19265
19266 /* Verify that name is null terminated. It appears that at least
19267 one version of Linux (RedHat 6.0) generates corefiles that don't
19268 comply with the ELF spec by failing to include the null byte in
19269 namesz. */
19270 if (inote.namesz > 0 && inote.namedata[inote.namesz - 1] != '\0')
19271 {
19272 if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
19273 {
19274 temp = (char *) malloc (inote.namesz + 1);
19275 if (temp == NULL)
19276 {
19277 error (_("Out of memory allocating space for inote name\n"));
19278 res = FALSE;
19279 break;
19280 }
19281
19282 memcpy (temp, inote.namedata, inote.namesz);
19283 inote.namedata = temp;
19284 }
19285 inote.namedata[inote.namesz] = 0;
19286 }
19287
19288 if (! process_note (& inote, filedata))
19289 res = FALSE;
19290
19291 if (temp != NULL)
19292 {
19293 free (temp);
19294 temp = NULL;
19295 }
19296 }
19297
19298 free (pnotes);
19299
19300 return res;
19301}
19302
19303static bfd_boolean
19304process_corefile_note_segments (Filedata * filedata)
19305{
19306 Elf_Internal_Phdr * segment;
19307 unsigned int i;
19308 bfd_boolean res = TRUE;
19309
19310 if (! get_program_headers (filedata))
19311 return TRUE;
19312
19313 for (i = 0, segment = filedata->program_headers;
19314 i < filedata->file_header.e_phnum;
19315 i++, segment++)
19316 {
19317 if (segment->p_type == PT_NOTE)
19318 if (! process_notes_at (filedata, NULL,
19319 (bfd_vma) segment->p_offset,
19320 (bfd_vma) segment->p_filesz,
19321 (bfd_vma) segment->p_align))
19322 res = FALSE;
19323 }
19324
19325 return res;
19326}
19327
19328static bfd_boolean
19329process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
19330{
19331 Elf_External_Note * pnotes;
19332 Elf_External_Note * external;
19333 char * end;
19334 bfd_boolean res = TRUE;
19335
19336 if (length <= 0)
19337 return FALSE;
19338
19339 pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
19340 _("v850 notes"));
19341 if (pnotes == NULL)
19342 return FALSE;
19343
19344 external = pnotes;
19345 end = (char*) pnotes + length;
19346
19347 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19348 (unsigned long) offset, (unsigned long) length);
19349
19350 while ((char *) external + sizeof (Elf_External_Note) < end)
19351 {
19352 Elf_External_Note * next;
19353 Elf_Internal_Note inote;
19354
19355 inote.type = BYTE_GET (external->type);
19356 inote.namesz = BYTE_GET (external->namesz);
19357 inote.namedata = external->name;
19358 inote.descsz = BYTE_GET (external->descsz);
19359 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
19360 inote.descpos = offset + (inote.descdata - (char *) pnotes);
19361
19362 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
19363 {
19364 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
19365 inote.descdata = inote.namedata;
19366 inote.namesz = 0;
19367 }
19368
19369 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
19370
19371 if ( ((char *) next > end)
19372 || ((char *) next < (char *) pnotes))
19373 {
19374 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19375 (unsigned long) ((char *) external - (char *) pnotes));
19376 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19377 inote.type, inote.namesz, inote.descsz);
19378 break;
19379 }
19380
19381 external = next;
19382
19383 /* Prevent out-of-bounds indexing. */
19384 if ( inote.namedata + inote.namesz > end
19385 || inote.namedata + inote.namesz < inote.namedata)
19386 {
19387 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19388 (unsigned long) ((char *) external - (char *) pnotes));
19389 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19390 inote.type, inote.namesz, inote.descsz);
19391 break;
19392 }
19393
19394 printf (" %s: ", get_v850_elf_note_type (inote.type));
19395
19396 if (! print_v850_note (& inote))
19397 {
19398 res = FALSE;
19399 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19400 inote.namesz, inote.descsz);
19401 }
19402 }
19403
19404 free (pnotes);
19405
19406 return res;
19407}
19408
19409static bfd_boolean
19410process_note_sections (Filedata * filedata)
19411{
19412 Elf_Internal_Shdr * section;
19413 unsigned long i;
19414 unsigned int n = 0;
19415 bfd_boolean res = TRUE;
19416
19417 for (i = 0, section = filedata->section_headers;
19418 i < filedata->file_header.e_shnum && section != NULL;
19419 i++, section++)
19420 {
19421 if (section->sh_type == SHT_NOTE)
19422 {
19423 if (! process_notes_at (filedata, section,
19424 (bfd_vma) section->sh_offset,
19425 (bfd_vma) section->sh_size,
19426 (bfd_vma) section->sh_addralign))
19427 res = FALSE;
19428 n++;
19429 }
19430
19431 if (( filedata->file_header.e_machine == EM_V800
19432 || filedata->file_header.e_machine == EM_V850
19433 || filedata->file_header.e_machine == EM_CYGNUS_V850)
19434 && section->sh_type == SHT_RENESAS_INFO)
19435 {
19436 if (! process_v850_notes (filedata,
19437 (bfd_vma) section->sh_offset,
19438 (bfd_vma) section->sh_size))
19439 res = FALSE;
19440 n++;
19441 }
19442 }
19443
19444 if (n == 0)
19445 /* Try processing NOTE segments instead. */
19446 return process_corefile_note_segments (filedata);
19447
19448 return res;
19449}
19450
19451static bfd_boolean
19452process_notes (Filedata * filedata)
19453{
19454 /* If we have not been asked to display the notes then do nothing. */
19455 if (! do_notes)
19456 return TRUE;
19457
19458 if (filedata->file_header.e_type != ET_CORE)
19459 return process_note_sections (filedata);
19460
19461 /* No program headers means no NOTE segment. */
19462 if (filedata->file_header.e_phnum > 0)
19463 return process_corefile_note_segments (filedata);
19464
19465 printf (_("No note segments present in the core file.\n"));
19466 return TRUE;
19467}
19468
19469static unsigned char *
19470display_public_gnu_attributes (unsigned char * start,
19471 const unsigned char * const end)
19472{
19473 printf (_(" Unknown GNU attribute: %s\n"), start);
19474
19475 start += strnlen ((char *) start, end - start);
19476 display_raw_attribute (start, end);
19477
19478 return (unsigned char *) end;
19479}
19480
19481static unsigned char *
19482display_generic_attribute (unsigned char * start,
19483 unsigned int tag,
19484 const unsigned char * const end)
19485{
19486 if (tag == 0)
19487 return (unsigned char *) end;
19488
19489 return display_tag_value (tag, start, end);
19490}
19491
19492static bfd_boolean
19493process_arch_specific (Filedata * filedata)
19494{
19495 if (! do_arch)
19496 return TRUE;
19497
19498 switch (filedata->file_header.e_machine)
19499 {
19500 case EM_ARC:
19501 case EM_ARC_COMPACT:
19502 case EM_ARC_COMPACT2:
19503 return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
19504 display_arc_attribute,
19505 display_generic_attribute);
19506 case EM_ARM:
19507 return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
19508 display_arm_attribute,
19509 display_generic_attribute);
19510
19511 case EM_MIPS:
19512 case EM_MIPS_RS3_LE:
19513 return process_mips_specific (filedata);
19514
19515 case EM_MSP430:
19516 return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
19517 display_msp430x_attribute,
19518 display_generic_attribute);
19519
19520 case EM_RISCV:
19521 return process_attributes (filedata, "riscv", SHT_RISCV_ATTRIBUTES,
19522 display_riscv_attribute,
19523 display_generic_attribute);
19524
19525 case EM_NDS32:
19526 return process_nds32_specific (filedata);
19527
19528 case EM_PPC:
19529 case EM_PPC64:
19530 return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19531 display_power_gnu_attribute);
19532
19533 case EM_S390:
19534 case EM_S390_OLD:
19535 return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19536 display_s390_gnu_attribute);
19537
19538 case EM_SPARC:
19539 case EM_SPARC32PLUS:
19540 case EM_SPARCV9:
19541 return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19542 display_sparc_gnu_attribute);
19543
19544 case EM_TI_C6000:
19545 return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
19546 display_tic6x_attribute,
19547 display_generic_attribute);
19548
19549 default:
19550 return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
19551 display_public_gnu_attributes,
19552 display_generic_attribute);
19553 }
19554}
19555
19556static bfd_boolean
19557get_file_header (Filedata * filedata)
19558{
19559 /* Read in the identity array. */
19560 if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
19561 return FALSE;
19562
19563 /* Determine how to read the rest of the header. */
19564 switch (filedata->file_header.e_ident[EI_DATA])
19565 {
19566 default:
19567 case ELFDATANONE:
19568 case ELFDATA2LSB:
19569 byte_get = byte_get_little_endian;
19570 byte_put = byte_put_little_endian;
19571 break;
19572 case ELFDATA2MSB:
19573 byte_get = byte_get_big_endian;
19574 byte_put = byte_put_big_endian;
19575 break;
19576 }
19577
19578 /* For now we only support 32 bit and 64 bit ELF files. */
19579 is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
19580
19581 /* Read in the rest of the header. */
19582 if (is_32bit_elf)
19583 {
19584 Elf32_External_Ehdr ehdr32;
19585
19586 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
19587 return FALSE;
19588
19589 filedata->file_header.e_type = BYTE_GET (ehdr32.e_type);
19590 filedata->file_header.e_machine = BYTE_GET (ehdr32.e_machine);
19591 filedata->file_header.e_version = BYTE_GET (ehdr32.e_version);
19592 filedata->file_header.e_entry = BYTE_GET (ehdr32.e_entry);
19593 filedata->file_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
19594 filedata->file_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
19595 filedata->file_header.e_flags = BYTE_GET (ehdr32.e_flags);
19596 filedata->file_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
19597 filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
19598 filedata->file_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
19599 filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
19600 filedata->file_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
19601 filedata->file_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
19602 }
19603 else
19604 {
19605 Elf64_External_Ehdr ehdr64;
19606
19607 /* If we have been compiled with sizeof (bfd_vma) == 4, then
19608 we will not be able to cope with the 64bit data found in
19609 64 ELF files. Detect this now and abort before we start
19610 overwriting things. */
19611 if (sizeof (bfd_vma) < 8)
19612 {
19613 error (_("This instance of readelf has been built without support for a\n\
1961464 bit data type and so it cannot read 64 bit ELF files.\n"));
19615 return FALSE;
19616 }
19617
19618 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
19619 return FALSE;
19620
19621 filedata->file_header.e_type = BYTE_GET (ehdr64.e_type);
19622 filedata->file_header.e_machine = BYTE_GET (ehdr64.e_machine);
19623 filedata->file_header.e_version = BYTE_GET (ehdr64.e_version);
19624 filedata->file_header.e_entry = BYTE_GET (ehdr64.e_entry);
19625 filedata->file_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
19626 filedata->file_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
19627 filedata->file_header.e_flags = BYTE_GET (ehdr64.e_flags);
19628 filedata->file_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
19629 filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
19630 filedata->file_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
19631 filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
19632 filedata->file_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
19633 filedata->file_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
19634 }
19635
19636 if (filedata->file_header.e_shoff)
19637 {
19638 /* There may be some extensions in the first section header. Don't
19639 bomb if we can't read it. */
19640 if (is_32bit_elf)
19641 get_32bit_section_headers (filedata, TRUE);
19642 else
19643 get_64bit_section_headers (filedata, TRUE);
19644 }
19645
19646 return TRUE;
19647}
19648
19649static void
19650close_file (Filedata * filedata)
19651{
19652 if (filedata)
19653 {
19654 if (filedata->handle)
19655 fclose (filedata->handle);
19656 free (filedata);
19657 }
19658}
19659
19660void
19661close_debug_file (void * data)
19662{
19663 close_file ((Filedata *) data);
19664}
19665
19666static Filedata *
19667open_file (const char * pathname)
19668{
19669 struct stat statbuf;
19670 Filedata * filedata = NULL;
19671
19672 if (stat (pathname, & statbuf) < 0
19673 || ! S_ISREG (statbuf.st_mode))
19674 goto fail;
19675
19676 filedata = calloc (1, sizeof * filedata);
19677 if (filedata == NULL)
19678 goto fail;
19679
19680 filedata->handle = fopen (pathname, "rb");
19681 if (filedata->handle == NULL)
19682 goto fail;
19683
19684 filedata->file_size = (bfd_size_type) statbuf.st_size;
19685 filedata->file_name = pathname;
19686
19687 if (! get_file_header (filedata))
19688 goto fail;
19689
19690 if (filedata->file_header.e_shoff)
19691 {
19692 bfd_boolean res;
19693
19694 /* Read the section headers again, this time for real. */
19695 if (is_32bit_elf)
19696 res = get_32bit_section_headers (filedata, FALSE);
19697 else
19698 res = get_64bit_section_headers (filedata, FALSE);
19699
19700 if (!res)
19701 goto fail;
19702 }
19703
19704 return filedata;
19705
19706 fail:
19707 if (filedata)
19708 {
19709 if (filedata->handle)
19710 fclose (filedata->handle);
19711 free (filedata);
19712 }
19713 return NULL;
19714}
19715
19716void *
19717open_debug_file (const char * pathname)
19718{
19719 return open_file (pathname);
19720}
19721
19722/* Process one ELF object file according to the command line options.
19723 This file may actually be stored in an archive. The file is
19724 positioned at the start of the ELF object. Returns TRUE if no
19725 problems were encountered, FALSE otherwise. */
19726
19727static bfd_boolean
19728process_object (Filedata * filedata)
19729{
19730 bfd_boolean have_separate_files;
19731 unsigned int i;
19732 bfd_boolean res = TRUE;
19733
19734 if (! get_file_header (filedata))
19735 {
19736 error (_("%s: Failed to read file header\n"), filedata->file_name);
19737 return FALSE;
19738 }
19739
19740 /* Initialise per file variables. */
19741 for (i = ARRAY_SIZE (version_info); i--;)
19742 version_info[i] = 0;
19743
19744 for (i = ARRAY_SIZE (dynamic_info); i--;)
19745 dynamic_info[i] = 0;
19746 dynamic_info_DT_GNU_HASH = 0;
19747
19748 /* Process the file. */
19749 if (show_name)
19750 printf (_("\nFile: %s\n"), filedata->file_name);
19751
19752 /* Initialise the dump_sects array from the cmdline_dump_sects array.
19753 Note we do this even if cmdline_dump_sects is empty because we
19754 must make sure that the dump_sets array is zeroed out before each
19755 object file is processed. */
19756 if (filedata->num_dump_sects > cmdline.num_dump_sects)
19757 memset (filedata->dump_sects, 0, filedata->num_dump_sects * sizeof (* filedata->dump_sects));
19758
19759 if (cmdline.num_dump_sects > 0)
19760 {
19761 if (filedata->num_dump_sects == 0)
19762 /* A sneaky way of allocating the dump_sects array. */
19763 request_dump_bynumber (filedata, cmdline.num_dump_sects, 0);
19764
19765 assert (filedata->num_dump_sects >= cmdline.num_dump_sects);
19766 memcpy (filedata->dump_sects, cmdline.dump_sects,
19767 cmdline.num_dump_sects * sizeof (* filedata->dump_sects));
19768 }
19769
19770 if (! process_file_header (filedata))
19771 return FALSE;
19772
19773 if (! process_section_headers (filedata))
19774 {
19775 /* Without loaded section headers we cannot process lots of things. */
19776 do_unwind = do_version = do_dump = do_arch = FALSE;
19777
19778 if (! do_using_dynamic)
19779 do_syms = do_dyn_syms = do_reloc = FALSE;
19780 }
19781
19782 if (! process_section_groups (filedata))
19783 /* Without loaded section groups we cannot process unwind. */
19784 do_unwind = FALSE;
19785
19786 if (process_program_headers (filedata))
19787 process_dynamic_section (filedata);
19788 else
19789 res = FALSE;
19790
19791 if (! process_relocs (filedata))
19792 res = FALSE;
19793
19794 if (! process_unwind (filedata))
19795 res = FALSE;
19796
19797 if (! process_symbol_table (filedata))
19798 res = FALSE;
19799
19800 if (! process_syminfo (filedata))
19801 res = FALSE;
19802
19803 if (! process_version_sections (filedata))
19804 res = FALSE;
19805
19806 if (filedata->file_header.e_shstrndx != SHN_UNDEF)
19807 have_separate_files = load_separate_debug_files (filedata, filedata->file_name);
19808 else
19809 have_separate_files = FALSE;
19810
19811 if (! process_section_contents (filedata))
19812 res = FALSE;
19813
19814 if (have_separate_files)
19815 {
19816 separate_info * d;
19817
19818 for (d = first_separate_info; d != NULL; d = d->next)
19819 {
19820 if (! process_section_headers (d->handle))
19821 res = FALSE;
19822 else if (! process_section_contents (d->handle))
19823 res = FALSE;
19824 }
19825
19826 /* The file handles are closed by the call to free_debug_memory() below. */
19827 }
19828
19829 if (! process_notes (filedata))
19830 res = FALSE;
19831
19832 if (! process_gnu_liblist (filedata))
19833 res = FALSE;
19834
19835 if (! process_arch_specific (filedata))
19836 res = FALSE;
19837
19838 free (filedata->program_headers);
19839 filedata->program_headers = NULL;
19840
19841 free (filedata->section_headers);
19842 filedata->section_headers = NULL;
19843
19844 free (filedata->string_table);
19845 filedata->string_table = NULL;
19846 filedata->string_table_length = 0;
19847
19848 if (dynamic_strings)
19849 {
19850 free (dynamic_strings);
19851 dynamic_strings = NULL;
19852 dynamic_strings_length = 0;
19853 }
19854
19855 if (dynamic_symbols)
19856 {
19857 free (dynamic_symbols);
19858 dynamic_symbols = NULL;
19859 num_dynamic_syms = 0;
19860 }
19861
19862 if (dynamic_syminfo)
19863 {
19864 free (dynamic_syminfo);
19865 dynamic_syminfo = NULL;
19866 }
19867
19868 if (dynamic_section)
19869 {
19870 free (dynamic_section);
19871 dynamic_section = NULL;
19872 }
19873
19874 if (section_headers_groups)
19875 {
19876 free (section_headers_groups);
19877 section_headers_groups = NULL;
19878 }
19879
19880 if (section_groups)
19881 {
19882 struct group_list * g;
19883 struct group_list * next;
19884
19885 for (i = 0; i < group_count; i++)
19886 {
19887 for (g = section_groups [i].root; g != NULL; g = next)
19888 {
19889 next = g->next;
19890 free (g);
19891 }
19892 }
19893
19894 free (section_groups);
19895 section_groups = NULL;
19896 }
19897
19898 free_debug_memory ();
19899
19900 return res;
19901}
19902
19903/* Process an ELF archive.
19904 On entry the file is positioned just after the ARMAG string.
19905 Returns TRUE upon success, FALSE otherwise. */
19906
19907static bfd_boolean
19908process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
19909{
19910 struct archive_info arch;
19911 struct archive_info nested_arch;
19912 size_t got;
19913 bfd_boolean ret = TRUE;
19914
19915 show_name = TRUE;
19916
19917 /* The ARCH structure is used to hold information about this archive. */
19918 arch.file_name = NULL;
19919 arch.file = NULL;
19920 arch.index_array = NULL;
19921 arch.sym_table = NULL;
19922 arch.longnames = NULL;
19923
19924 /* The NESTED_ARCH structure is used as a single-item cache of information
19925 about a nested archive (when members of a thin archive reside within
19926 another regular archive file). */
19927 nested_arch.file_name = NULL;
19928 nested_arch.file = NULL;
19929 nested_arch.index_array = NULL;
19930 nested_arch.sym_table = NULL;
19931 nested_arch.longnames = NULL;
19932
19933 if (setup_archive (&arch, filedata->file_name, filedata->handle,
19934 is_thin_archive, do_archive_index) != 0)
19935 {
19936 ret = FALSE;
19937 goto out;
19938 }
19939
19940 if (do_archive_index)
19941 {
19942 if (arch.sym_table == NULL)
19943 error (_("%s: unable to dump the index as none was found\n"), filedata->file_name);
19944 else
19945 {
19946 unsigned long i, l;
19947 unsigned long current_pos;
19948
19949 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
19950 filedata->file_name, (unsigned long) arch.index_num, arch.sym_size);
19951
19952 current_pos = ftell (filedata->handle);
19953
19954 for (i = l = 0; i < arch.index_num; i++)
19955 {
19956 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
19957 {
19958 char * member_name;
19959
19960 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
19961
19962 if (member_name != NULL)
19963 {
19964 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
19965
19966 if (qualified_name != NULL)
19967 {
19968 printf (_("Contents of binary %s at offset "), qualified_name);
19969 (void) print_vma (arch.index_array[i], PREFIX_HEX);
19970 putchar ('\n');
19971 free (qualified_name);
19972 }
19973 }
19974 }
19975
19976 if (l >= arch.sym_size)
19977 {
19978 error (_("%s: end of the symbol table reached before the end of the index\n"),
19979 filedata->file_name);
19980 ret = FALSE;
19981 break;
19982 }
19983 /* PR 17531: file: 0b6630b2. */
19984 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
19985 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
19986 }
19987
19988 if (arch.uses_64bit_indices)
19989 l = (l + 7) & ~ 7;
19990 else
19991 l += l & 1;
19992
19993 if (l < arch.sym_size)
19994 {
19995 error (ngettext ("%s: %ld byte remains in the symbol table, "
19996 "but without corresponding entries in "
19997 "the index table\n",
19998 "%s: %ld bytes remain in the symbol table, "
19999 "but without corresponding entries in "
20000 "the index table\n",
20001 arch.sym_size - l),
20002 filedata->file_name, arch.sym_size - l);
20003 ret = FALSE;
20004 }
20005
20006 if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
20007 {
20008 error (_("%s: failed to seek back to start of object files in the archive\n"),
20009 filedata->file_name);
20010 ret = FALSE;
20011 goto out;
20012 }
20013 }
20014
20015 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
20016 && !do_segments && !do_header && !do_dump && !do_version
20017 && !do_histogram && !do_debugging && !do_arch && !do_notes
20018 && !do_section_groups && !do_dyn_syms)
20019 {
20020 ret = TRUE; /* Archive index only. */
20021 goto out;
20022 }
20023 }
20024
20025 while (1)
20026 {
20027 char * name;
20028 size_t namelen;
20029 char * qualified_name;
20030
20031 /* Read the next archive header. */
20032 if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
20033 {
20034 error (_("%s: failed to seek to next archive header\n"), arch.file_name);
20035 return FALSE;
20036 }
20037 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
20038 if (got != sizeof arch.arhdr)
20039 {
20040 if (got == 0)
20041 break;
20042 /* PR 24049 - we cannot use filedata->file_name as this will
20043 have already been freed. */
20044 error (_("%s: failed to read archive header\n"), arch.file_name);
20045
20046 ret = FALSE;
20047 break;
20048 }
20049 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
20050 {
20051 error (_("%s: did not find a valid archive header\n"), arch.file_name);
20052 ret = FALSE;
20053 break;
20054 }
20055
20056 arch.next_arhdr_offset += sizeof arch.arhdr;
20057
20058 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
20059 if (archive_file_size & 01)
20060 ++archive_file_size;
20061
20062 name = get_archive_member_name (&arch, &nested_arch);
20063 if (name == NULL)
20064 {
20065 error (_("%s: bad archive file name\n"), arch.file_name);
20066 ret = FALSE;
20067 break;
20068 }
20069 namelen = strlen (name);
20070
20071 qualified_name = make_qualified_name (&arch, &nested_arch, name);
20072 if (qualified_name == NULL)
20073 {
20074 error (_("%s: bad archive file name\n"), arch.file_name);
20075 ret = FALSE;
20076 break;
20077 }
20078
20079 if (is_thin_archive && arch.nested_member_origin == 0)
20080 {
20081 /* This is a proxy for an external member of a thin archive. */
20082 Filedata * member_filedata;
20083 char * member_file_name = adjust_relative_path
20084 (filedata->file_name, name, namelen);
20085
20086 if (member_file_name == NULL)
20087 {
20088 ret = FALSE;
20089 break;
20090 }
20091
20092 member_filedata = open_file (member_file_name);
20093 if (member_filedata == NULL)
20094 {
20095 error (_("Input file '%s' is not readable.\n"), member_file_name);
20096 free (member_file_name);
20097 ret = FALSE;
20098 break;
20099 }
20100
20101 archive_file_offset = arch.nested_member_origin;
20102 member_filedata->file_name = qualified_name;
20103
20104 if (! process_object (member_filedata))
20105 ret = FALSE;
20106
20107 close_file (member_filedata);
20108 free (member_file_name);
20109 }
20110 else if (is_thin_archive)
20111 {
20112 Filedata thin_filedata;
20113
20114 memset (&thin_filedata, 0, sizeof (thin_filedata));
20115
20116 /* PR 15140: Allow for corrupt thin archives. */
20117 if (nested_arch.file == NULL)
20118 {
20119 error (_("%s: contains corrupt thin archive: %s\n"),
20120 qualified_name, name);
20121 ret = FALSE;
20122 break;
20123 }
20124
20125 /* This is a proxy for a member of a nested archive. */
20126 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
20127
20128 /* The nested archive file will have been opened and setup by
20129 get_archive_member_name. */
20130 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
20131 {
20132 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
20133 ret = FALSE;
20134 break;
20135 }
20136
20137 thin_filedata.handle = nested_arch.file;
20138 thin_filedata.file_name = qualified_name;
20139
20140 if (! process_object (& thin_filedata))
20141 ret = FALSE;
20142 }
20143 else
20144 {
20145 archive_file_offset = arch.next_arhdr_offset;
20146 arch.next_arhdr_offset += archive_file_size;
20147
20148 filedata->file_name = qualified_name;
20149 if (! process_object (filedata))
20150 ret = FALSE;
20151 }
20152
20153 if (filedata->dump_sects != NULL)
20154 {
20155 free (filedata->dump_sects);
20156 filedata->dump_sects = NULL;
20157 filedata->num_dump_sects = 0;
20158 }
20159
20160 free (qualified_name);
20161 }
20162
20163 out:
20164 if (nested_arch.file != NULL)
20165 fclose (nested_arch.file);
20166 release_archive (&nested_arch);
20167 release_archive (&arch);
20168
20169 return ret;
20170}
20171
20172static bfd_boolean
20173process_file (char * file_name)
20174{
20175 Filedata * filedata = NULL;
20176 struct stat statbuf;
20177 char armag[SARMAG];
20178 bfd_boolean ret = TRUE;
20179
20180 if (stat (file_name, &statbuf) < 0)
20181 {
20182 if (errno == ENOENT)
20183 error (_("'%s': No such file\n"), file_name);
20184 else
20185 error (_("Could not locate '%s'. System error message: %s\n"),
20186 file_name, strerror (errno));
20187 return FALSE;
20188 }
20189
20190 if (! S_ISREG (statbuf.st_mode))
20191 {
20192 error (_("'%s' is not an ordinary file\n"), file_name);
20193 return FALSE;
20194 }
20195
20196 filedata = calloc (1, sizeof * filedata);
20197 if (filedata == NULL)
20198 {
20199 error (_("Out of memory allocating file data structure\n"));
20200 return FALSE;
20201 }
20202
20203 filedata->file_name = file_name;
20204 filedata->handle = fopen (file_name, "rb");
20205 if (filedata->handle == NULL)
20206 {
20207 error (_("Input file '%s' is not readable.\n"), file_name);
20208 free (filedata);
20209 return FALSE;
20210 }
20211
20212 if (fread (armag, SARMAG, 1, filedata->handle) != 1)
20213 {
20214 error (_("%s: Failed to read file's magic number\n"), file_name);
20215 fclose (filedata->handle);
20216 free (filedata);
20217 return FALSE;
20218 }
20219
20220 filedata->file_size = (bfd_size_type) statbuf.st_size;
20221
20222 if (memcmp (armag, ARMAG, SARMAG) == 0)
20223 {
20224 if (! process_archive (filedata, FALSE))
20225 ret = FALSE;
20226 }
20227 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
20228 {
20229 if ( ! process_archive (filedata, TRUE))
20230 ret = FALSE;
20231 }
20232 else
20233 {
20234 if (do_archive_index)
20235 error (_("File %s is not an archive so its index cannot be displayed.\n"),
20236 file_name);
20237
20238 rewind (filedata->handle);
20239 archive_file_size = archive_file_offset = 0;
20240
20241 if (! process_object (filedata))
20242 ret = FALSE;
20243 }
20244
20245 fclose (filedata->handle);
20246 free (filedata);
20247
20248 return ret;
20249}
20250
20251#ifdef SUPPORT_DISASSEMBLY
20252/* Needed by the i386 disassembler. For extra credit, someone could
20253 fix this so that we insert symbolic addresses here, esp for GOT/PLT
20254 symbols. */
20255
20256void
20257print_address (unsigned int addr, FILE * outfile)
20258{
20259 fprintf (outfile,"0x%8.8x", addr);
20260}
20261
20262/* Needed by the i386 disassembler. */
20263
20264void
20265db_task_printsym (unsigned int addr)
20266{
20267 print_address (addr, stderr);
20268}
20269#endif
20270
20271int
20272main (int argc, char ** argv)
20273{
20274 int err;
20275
20276#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20277 setlocale (LC_MESSAGES, "");
20278#endif
20279#if defined (HAVE_SETLOCALE)
20280 setlocale (LC_CTYPE, "");
20281#endif
20282 bindtextdomain (PACKAGE, LOCALEDIR);
20283 textdomain (PACKAGE);
20284
20285 expandargv (&argc, &argv);
20286
20287 cmdline.file_name = "<cmdline>";
20288 parse_args (& cmdline, argc, argv);
20289
20290 if (optind < (argc - 1))
20291 show_name = TRUE;
20292 else if (optind >= argc)
20293 {
20294 warn (_("Nothing to do.\n"));
20295 usage (stderr);
20296 }
20297
20298 err = FALSE;
20299 while (optind < argc)
20300 if (! process_file (argv[optind++]))
20301 err = TRUE;
20302
20303 if (cmdline.dump_sects != NULL)
20304 free (cmdline.dump_sects);
20305
20306 free (dump_ctf_symtab_name);
20307 free (dump_ctf_strtab_name);
20308 free (dump_ctf_parent_name);
20309
20310 return err ? EXIT_FAILURE : EXIT_SUCCESS;
20311}
A mirror of the official binutils-gdb repository