]> 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
Add support to readelf to display NetBSD auxv notes in core files.
[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 (sizeof (size_t) < sizeof (bfd_size_type)
389 && ( (bfd_size_type) ((size_t) size) != size
390 || (bfd_size_type) ((size_t) nmemb) != nmemb))
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 < nmemb)
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 /* Check for overflow. */
433 if (nmemb < (~(bfd_size_type) 0 - 1) / size)
434 /* + 1 so that we can '\0' terminate invalid string table sections. */
435 mvar = malloc ((size_t) amt + 1);
436
437 if (mvar == NULL)
438 {
439 if (reason)
440 error (_("Out of memory allocating %s bytes for %s\n"),
441 bfd_vmatoa ("u", amt), reason);
442 return NULL;
443 }
444
445 ((char *) mvar)[amt] = '\0';
446 }
447
448 if (fread (mvar, (size_t) size, (size_t) nmemb, filedata->handle) != nmemb)
449 {
450 if (reason)
451 error (_("Unable to read in %s bytes of %s\n"),
452 bfd_vmatoa ("u", amt), reason);
453 if (mvar != var)
454 free (mvar);
455 return NULL;
456 }
457
458 return mvar;
459}
460
461/* Print a VMA value in the MODE specified.
462 Returns the number of characters displayed. */
463
464static unsigned int
465print_vma (bfd_vma vma, print_mode mode)
466{
467 unsigned int nc = 0;
468
469 switch (mode)
470 {
471 case FULL_HEX:
472 nc = printf ("0x");
473 /* Fall through. */
474 case LONG_HEX:
475#ifdef BFD64
476 if (is_32bit_elf)
477 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
478#endif
479 printf_vma (vma);
480 return nc + 16;
481
482 case DEC_5:
483 if (vma <= 99999)
484 return printf ("%5" BFD_VMA_FMT "d", vma);
485 /* Fall through. */
486 case PREFIX_HEX:
487 nc = printf ("0x");
488 /* Fall through. */
489 case HEX:
490 return nc + printf ("%" BFD_VMA_FMT "x", vma);
491
492 case DEC:
493 return printf ("%" BFD_VMA_FMT "d", vma);
494
495 case UNSIGNED:
496 return printf ("%" BFD_VMA_FMT "u", vma);
497
498 default:
499 /* FIXME: Report unrecognised mode ? */
500 return 0;
501 }
502}
503
504/* Display a symbol on stdout. Handles the display of control characters and
505 multibye characters (assuming the host environment supports them).
506
507 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
508
509 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
510 padding as necessary.
511
512 Returns the number of emitted characters. */
513
514static unsigned int
515print_symbol (signed int width, const char *symbol)
516{
517 bfd_boolean extra_padding = FALSE;
518 signed int num_printed = 0;
519#ifdef HAVE_MBSTATE_T
520 mbstate_t state;
521#endif
522 unsigned int width_remaining;
523
524 if (width < 0)
525 {
526 /* Keep the width positive. This helps the code below. */
527 width = - width;
528 extra_padding = TRUE;
529 }
530 else if (width == 0)
531 return 0;
532
533 if (do_wide)
534 /* Set the remaining width to a very large value.
535 This simplifies the code below. */
536 width_remaining = INT_MAX;
537 else
538 width_remaining = width;
539
540#ifdef HAVE_MBSTATE_T
541 /* Initialise the multibyte conversion state. */
542 memset (& state, 0, sizeof (state));
543#endif
544
545 while (width_remaining)
546 {
547 size_t n;
548 const char c = *symbol++;
549
550 if (c == 0)
551 break;
552
553 /* Do not print control characters directly as they can affect terminal
554 settings. Such characters usually appear in the names generated
555 by the assembler for local labels. */
556 if (ISCNTRL (c))
557 {
558 if (width_remaining < 2)
559 break;
560
561 printf ("^%c", c + 0x40);
562 width_remaining -= 2;
563 num_printed += 2;
564 }
565 else if (ISPRINT (c))
566 {
567 putchar (c);
568 width_remaining --;
569 num_printed ++;
570 }
571 else
572 {
573#ifdef HAVE_MBSTATE_T
574 wchar_t w;
575#endif
576 /* Let printf do the hard work of displaying multibyte characters. */
577 printf ("%.1s", symbol - 1);
578 width_remaining --;
579 num_printed ++;
580
581#ifdef HAVE_MBSTATE_T
582 /* Try to find out how many bytes made up the character that was
583 just printed. Advance the symbol pointer past the bytes that
584 were displayed. */
585 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
586#else
587 n = 1;
588#endif
589 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
590 symbol += (n - 1);
591 }
592 }
593
594 if (extra_padding && num_printed < width)
595 {
596 /* Fill in the remaining spaces. */
597 printf ("%-*s", width - num_printed, " ");
598 num_printed = width;
599 }
600
601 return num_printed;
602}
603
604/* Returns a pointer to a static buffer containing a printable version of
605 the given section's name. Like print_symbol, except that it does not try
606 to print multibyte characters, it just interprets them as hex values. */
607
608static const char *
609printable_section_name (Filedata * filedata, const Elf_Internal_Shdr * sec)
610{
611#define MAX_PRINT_SEC_NAME_LEN 128
612 static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
613 const char * name = SECTION_NAME (sec);
614 char * buf = sec_name_buf;
615 char c;
616 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
617
618 while ((c = * name ++) != 0)
619 {
620 if (ISCNTRL (c))
621 {
622 if (remaining < 2)
623 break;
624
625 * buf ++ = '^';
626 * buf ++ = c + 0x40;
627 remaining -= 2;
628 }
629 else if (ISPRINT (c))
630 {
631 * buf ++ = c;
632 remaining -= 1;
633 }
634 else
635 {
636 static char hex[17] = "0123456789ABCDEF";
637
638 if (remaining < 4)
639 break;
640 * buf ++ = '<';
641 * buf ++ = hex[(c & 0xf0) >> 4];
642 * buf ++ = hex[c & 0x0f];
643 * buf ++ = '>';
644 remaining -= 4;
645 }
646
647 if (remaining == 0)
648 break;
649 }
650
651 * buf = 0;
652 return sec_name_buf;
653}
654
655static const char *
656printable_section_name_from_index (Filedata * filedata, unsigned long ndx)
657{
658 if (ndx >= filedata->file_header.e_shnum)
659 return _("<corrupt>");
660
661 return printable_section_name (filedata, filedata->section_headers + ndx);
662}
663
664/* Return a pointer to section NAME, or NULL if no such section exists. */
665
666static Elf_Internal_Shdr *
667find_section (Filedata * filedata, const char * name)
668{
669 unsigned int i;
670
671 if (filedata->section_headers == NULL)
672 return NULL;
673
674 for (i = 0; i < filedata->file_header.e_shnum; i++)
675 if (streq (SECTION_NAME (filedata->section_headers + i), name))
676 return filedata->section_headers + i;
677
678 return NULL;
679}
680
681/* Return a pointer to a section containing ADDR, or NULL if no such
682 section exists. */
683
684static Elf_Internal_Shdr *
685find_section_by_address (Filedata * filedata, bfd_vma addr)
686{
687 unsigned int i;
688
689 if (filedata->section_headers == NULL)
690 return NULL;
691
692 for (i = 0; i < filedata->file_header.e_shnum; i++)
693 {
694 Elf_Internal_Shdr *sec = filedata->section_headers + i;
695
696 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
697 return sec;
698 }
699
700 return NULL;
701}
702
703static Elf_Internal_Shdr *
704find_section_by_type (Filedata * filedata, unsigned int type)
705{
706 unsigned int i;
707
708 if (filedata->section_headers == NULL)
709 return NULL;
710
711 for (i = 0; i < filedata->file_header.e_shnum; i++)
712 {
713 Elf_Internal_Shdr *sec = filedata->section_headers + i;
714
715 if (sec->sh_type == type)
716 return sec;
717 }
718
719 return NULL;
720}
721
722/* Return a pointer to section NAME, or NULL if no such section exists,
723 restricted to the list of sections given in SET. */
724
725static Elf_Internal_Shdr *
726find_section_in_set (Filedata * filedata, const char * name, unsigned int * set)
727{
728 unsigned int i;
729
730 if (filedata->section_headers == NULL)
731 return NULL;
732
733 if (set != NULL)
734 {
735 while ((i = *set++) > 0)
736 {
737 /* See PR 21156 for a reproducer. */
738 if (i >= filedata->file_header.e_shnum)
739 continue; /* FIXME: Should we issue an error message ? */
740
741 if (streq (SECTION_NAME (filedata->section_headers + i), name))
742 return filedata->section_headers + i;
743 }
744 }
745
746 return find_section (filedata, name);
747}
748
749/* Read an unsigned LEB128 encoded value from DATA.
750 Set *LENGTH_RETURN to the number of bytes read. */
751
752static inline unsigned long
753read_uleb128 (unsigned char * data,
754 unsigned int * length_return,
755 const unsigned char * const end)
756{
757 return read_leb128 (data, length_return, FALSE, end);
758}
759
760/* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
761 This OS has so many departures from the ELF standard that we test it at
762 many places. */
763
764static inline bfd_boolean
765is_ia64_vms (Filedata * filedata)
766{
767 return filedata->file_header.e_machine == EM_IA_64
768 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
769}
770
771/* Guess the relocation size commonly used by the specific machines. */
772
773static bfd_boolean
774guess_is_rela (unsigned int e_machine)
775{
776 switch (e_machine)
777 {
778 /* Targets that use REL relocations. */
779 case EM_386:
780 case EM_IAMCU:
781 case EM_960:
782 case EM_ARM:
783 case EM_D10V:
784 case EM_CYGNUS_D10V:
785 case EM_DLX:
786 case EM_MIPS:
787 case EM_MIPS_RS3_LE:
788 case EM_CYGNUS_M32R:
789 case EM_SCORE:
790 case EM_XGATE:
791 case EM_NFP:
792 case EM_BPF:
793 return FALSE;
794
795 /* Targets that use RELA relocations. */
796 case EM_68K:
797 case EM_860:
798 case EM_AARCH64:
799 case EM_ADAPTEVA_EPIPHANY:
800 case EM_ALPHA:
801 case EM_ALTERA_NIOS2:
802 case EM_ARC:
803 case EM_ARC_COMPACT:
804 case EM_ARC_COMPACT2:
805 case EM_AVR:
806 case EM_AVR_OLD:
807 case EM_BLACKFIN:
808 case EM_CR16:
809 case EM_CRIS:
810 case EM_CRX:
811 case EM_CSKY:
812 case EM_D30V:
813 case EM_CYGNUS_D30V:
814 case EM_FR30:
815 case EM_FT32:
816 case EM_CYGNUS_FR30:
817 case EM_CYGNUS_FRV:
818 case EM_H8S:
819 case EM_H8_300:
820 case EM_H8_300H:
821 case EM_IA_64:
822 case EM_IP2K:
823 case EM_IP2K_OLD:
824 case EM_IQ2000:
825 case EM_LATTICEMICO32:
826 case EM_M32C_OLD:
827 case EM_M32C:
828 case EM_M32R:
829 case EM_MCORE:
830 case EM_CYGNUS_MEP:
831 case EM_METAG:
832 case EM_MMIX:
833 case EM_MN10200:
834 case EM_CYGNUS_MN10200:
835 case EM_MN10300:
836 case EM_CYGNUS_MN10300:
837 case EM_MOXIE:
838 case EM_MSP430:
839 case EM_MSP430_OLD:
840 case EM_MT:
841 case EM_NDS32:
842 case EM_NIOS32:
843 case EM_OR1K:
844 case EM_PPC64:
845 case EM_PPC:
846 case EM_TI_PRU:
847 case EM_RISCV:
848 case EM_RL78:
849 case EM_RX:
850 case EM_S390:
851 case EM_S390_OLD:
852 case EM_SH:
853 case EM_SPARC:
854 case EM_SPARC32PLUS:
855 case EM_SPARCV9:
856 case EM_SPU:
857 case EM_TI_C6000:
858 case EM_TILEGX:
859 case EM_TILEPRO:
860 case EM_V800:
861 case EM_V850:
862 case EM_CYGNUS_V850:
863 case EM_VAX:
864 case EM_VISIUM:
865 case EM_X86_64:
866 case EM_L1OM:
867 case EM_K1OM:
868 case EM_XSTORMY16:
869 case EM_XTENSA:
870 case EM_XTENSA_OLD:
871 case EM_MICROBLAZE:
872 case EM_MICROBLAZE_OLD:
873 case EM_WEBASSEMBLY:
874 return TRUE;
875
876 case EM_68HC05:
877 case EM_68HC08:
878 case EM_68HC11:
879 case EM_68HC16:
880 case EM_FX66:
881 case EM_ME16:
882 case EM_MMA:
883 case EM_NCPU:
884 case EM_NDR1:
885 case EM_PCP:
886 case EM_ST100:
887 case EM_ST19:
888 case EM_ST7:
889 case EM_ST9PLUS:
890 case EM_STARCORE:
891 case EM_SVX:
892 case EM_TINYJ:
893 default:
894 warn (_("Don't know about relocations on this machine architecture\n"));
895 return FALSE;
896 }
897}
898
899/* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
900 Returns TRUE upon success, FALSE otherwise. If successful then a
901 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
902 and the number of relocs loaded is placed in *NRELASP. It is the caller's
903 responsibility to free the allocated buffer. */
904
905static bfd_boolean
906slurp_rela_relocs (Filedata * filedata,
907 unsigned long rel_offset,
908 unsigned long rel_size,
909 Elf_Internal_Rela ** relasp,
910 unsigned long * nrelasp)
911{
912 Elf_Internal_Rela * relas;
913 size_t nrelas;
914 unsigned int i;
915
916 if (is_32bit_elf)
917 {
918 Elf32_External_Rela * erelas;
919
920 erelas = (Elf32_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
921 rel_size, _("32-bit relocation data"));
922 if (!erelas)
923 return FALSE;
924
925 nrelas = rel_size / sizeof (Elf32_External_Rela);
926
927 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
928 sizeof (Elf_Internal_Rela));
929
930 if (relas == NULL)
931 {
932 free (erelas);
933 error (_("out of memory parsing relocs\n"));
934 return FALSE;
935 }
936
937 for (i = 0; i < nrelas; i++)
938 {
939 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
940 relas[i].r_info = BYTE_GET (erelas[i].r_info);
941 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
942 }
943
944 free (erelas);
945 }
946 else
947 {
948 Elf64_External_Rela * erelas;
949
950 erelas = (Elf64_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
951 rel_size, _("64-bit relocation data"));
952 if (!erelas)
953 return FALSE;
954
955 nrelas = rel_size / sizeof (Elf64_External_Rela);
956
957 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
958 sizeof (Elf_Internal_Rela));
959
960 if (relas == NULL)
961 {
962 free (erelas);
963 error (_("out of memory parsing relocs\n"));
964 return FALSE;
965 }
966
967 for (i = 0; i < nrelas; i++)
968 {
969 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
970 relas[i].r_info = BYTE_GET (erelas[i].r_info);
971 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
972
973 /* The #ifdef BFD64 below is to prevent a compile time
974 warning. We know that if we do not have a 64 bit data
975 type that we will never execute this code anyway. */
976#ifdef BFD64
977 if (filedata->file_header.e_machine == EM_MIPS
978 && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
979 {
980 /* In little-endian objects, r_info isn't really a
981 64-bit little-endian value: it has a 32-bit
982 little-endian symbol index followed by four
983 individual byte fields. Reorder INFO
984 accordingly. */
985 bfd_vma inf = relas[i].r_info;
986 inf = (((inf & 0xffffffff) << 32)
987 | ((inf >> 56) & 0xff)
988 | ((inf >> 40) & 0xff00)
989 | ((inf >> 24) & 0xff0000)
990 | ((inf >> 8) & 0xff000000));
991 relas[i].r_info = inf;
992 }
993#endif /* BFD64 */
994 }
995
996 free (erelas);
997 }
998
999 *relasp = relas;
1000 *nrelasp = nrelas;
1001 return TRUE;
1002}
1003
1004/* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1005 Returns TRUE upon success, FALSE otherwise. If successful then a
1006 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1007 and the number of relocs loaded is placed in *NRELSP. It is the caller's
1008 responsibility to free the allocated buffer. */
1009
1010static bfd_boolean
1011slurp_rel_relocs (Filedata * filedata,
1012 unsigned long rel_offset,
1013 unsigned long rel_size,
1014 Elf_Internal_Rela ** relsp,
1015 unsigned long * nrelsp)
1016{
1017 Elf_Internal_Rela * rels;
1018 size_t nrels;
1019 unsigned int i;
1020
1021 if (is_32bit_elf)
1022 {
1023 Elf32_External_Rel * erels;
1024
1025 erels = (Elf32_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1026 rel_size, _("32-bit relocation data"));
1027 if (!erels)
1028 return FALSE;
1029
1030 nrels = rel_size / sizeof (Elf32_External_Rel);
1031
1032 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1033
1034 if (rels == NULL)
1035 {
1036 free (erels);
1037 error (_("out of memory parsing relocs\n"));
1038 return FALSE;
1039 }
1040
1041 for (i = 0; i < nrels; i++)
1042 {
1043 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1044 rels[i].r_info = BYTE_GET (erels[i].r_info);
1045 rels[i].r_addend = 0;
1046 }
1047
1048 free (erels);
1049 }
1050 else
1051 {
1052 Elf64_External_Rel * erels;
1053
1054 erels = (Elf64_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1055 rel_size, _("64-bit relocation data"));
1056 if (!erels)
1057 return FALSE;
1058
1059 nrels = rel_size / sizeof (Elf64_External_Rel);
1060
1061 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1062
1063 if (rels == NULL)
1064 {
1065 free (erels);
1066 error (_("out of memory parsing relocs\n"));
1067 return FALSE;
1068 }
1069
1070 for (i = 0; i < nrels; i++)
1071 {
1072 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1073 rels[i].r_info = BYTE_GET (erels[i].r_info);
1074 rels[i].r_addend = 0;
1075
1076 /* The #ifdef BFD64 below is to prevent a compile time
1077 warning. We know that if we do not have a 64 bit data
1078 type that we will never execute this code anyway. */
1079#ifdef BFD64
1080 if (filedata->file_header.e_machine == EM_MIPS
1081 && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
1082 {
1083 /* In little-endian objects, r_info isn't really a
1084 64-bit little-endian value: it has a 32-bit
1085 little-endian symbol index followed by four
1086 individual byte fields. Reorder INFO
1087 accordingly. */
1088 bfd_vma inf = rels[i].r_info;
1089 inf = (((inf & 0xffffffff) << 32)
1090 | ((inf >> 56) & 0xff)
1091 | ((inf >> 40) & 0xff00)
1092 | ((inf >> 24) & 0xff0000)
1093 | ((inf >> 8) & 0xff000000));
1094 rels[i].r_info = inf;
1095 }
1096#endif /* BFD64 */
1097 }
1098
1099 free (erels);
1100 }
1101
1102 *relsp = rels;
1103 *nrelsp = nrels;
1104 return TRUE;
1105}
1106
1107/* Returns the reloc type extracted from the reloc info field. */
1108
1109static unsigned int
1110get_reloc_type (Filedata * filedata, bfd_vma reloc_info)
1111{
1112 if (is_32bit_elf)
1113 return ELF32_R_TYPE (reloc_info);
1114
1115 switch (filedata->file_header.e_machine)
1116 {
1117 case EM_MIPS:
1118 /* Note: We assume that reloc_info has already been adjusted for us. */
1119 return ELF64_MIPS_R_TYPE (reloc_info);
1120
1121 case EM_SPARCV9:
1122 return ELF64_R_TYPE_ID (reloc_info);
1123
1124 default:
1125 return ELF64_R_TYPE (reloc_info);
1126 }
1127}
1128
1129/* Return the symbol index extracted from the reloc info field. */
1130
1131static bfd_vma
1132get_reloc_symindex (bfd_vma reloc_info)
1133{
1134 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1135}
1136
1137static inline bfd_boolean
1138uses_msp430x_relocs (Filedata * filedata)
1139{
1140 return
1141 filedata->file_header.e_machine == EM_MSP430 /* Paranoia. */
1142 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1143 && (((filedata->file_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1144 /* TI compiler uses ELFOSABI_NONE. */
1145 || (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1146}
1147
1148/* Display the contents of the relocation data found at the specified
1149 offset. */
1150
1151static bfd_boolean
1152dump_relocations (Filedata * filedata,
1153 unsigned long rel_offset,
1154 unsigned long rel_size,
1155 Elf_Internal_Sym * symtab,
1156 unsigned long nsyms,
1157 char * strtab,
1158 unsigned long strtablen,
1159 int is_rela,
1160 bfd_boolean is_dynsym)
1161{
1162 unsigned long i;
1163 Elf_Internal_Rela * rels;
1164 bfd_boolean res = TRUE;
1165
1166 if (is_rela == UNKNOWN)
1167 is_rela = guess_is_rela (filedata->file_header.e_machine);
1168
1169 if (is_rela)
1170 {
1171 if (!slurp_rela_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1172 return FALSE;
1173 }
1174 else
1175 {
1176 if (!slurp_rel_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1177 return FALSE;
1178 }
1179
1180 if (is_32bit_elf)
1181 {
1182 if (is_rela)
1183 {
1184 if (do_wide)
1185 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1186 else
1187 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1188 }
1189 else
1190 {
1191 if (do_wide)
1192 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1193 else
1194 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1195 }
1196 }
1197 else
1198 {
1199 if (is_rela)
1200 {
1201 if (do_wide)
1202 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1203 else
1204 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1205 }
1206 else
1207 {
1208 if (do_wide)
1209 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1210 else
1211 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1212 }
1213 }
1214
1215 for (i = 0; i < rel_size; i++)
1216 {
1217 const char * rtype;
1218 bfd_vma offset;
1219 bfd_vma inf;
1220 bfd_vma symtab_index;
1221 bfd_vma type;
1222
1223 offset = rels[i].r_offset;
1224 inf = rels[i].r_info;
1225
1226 type = get_reloc_type (filedata, inf);
1227 symtab_index = get_reloc_symindex (inf);
1228
1229 if (is_32bit_elf)
1230 {
1231 printf ("%8.8lx %8.8lx ",
1232 (unsigned long) offset & 0xffffffff,
1233 (unsigned long) inf & 0xffffffff);
1234 }
1235 else
1236 {
1237#if BFD_HOST_64BIT_LONG
1238 printf (do_wide
1239 ? "%16.16lx %16.16lx "
1240 : "%12.12lx %12.12lx ",
1241 offset, inf);
1242#elif BFD_HOST_64BIT_LONG_LONG
1243#ifndef __MSVCRT__
1244 printf (do_wide
1245 ? "%16.16llx %16.16llx "
1246 : "%12.12llx %12.12llx ",
1247 offset, inf);
1248#else
1249 printf (do_wide
1250 ? "%16.16I64x %16.16I64x "
1251 : "%12.12I64x %12.12I64x ",
1252 offset, inf);
1253#endif
1254#else
1255 printf (do_wide
1256 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1257 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1258 _bfd_int64_high (offset),
1259 _bfd_int64_low (offset),
1260 _bfd_int64_high (inf),
1261 _bfd_int64_low (inf));
1262#endif
1263 }
1264
1265 switch (filedata->file_header.e_machine)
1266 {
1267 default:
1268 rtype = NULL;
1269 break;
1270
1271 case EM_AARCH64:
1272 rtype = elf_aarch64_reloc_type (type);
1273 break;
1274
1275 case EM_M32R:
1276 case EM_CYGNUS_M32R:
1277 rtype = elf_m32r_reloc_type (type);
1278 break;
1279
1280 case EM_386:
1281 case EM_IAMCU:
1282 rtype = elf_i386_reloc_type (type);
1283 break;
1284
1285 case EM_68HC11:
1286 case EM_68HC12:
1287 rtype = elf_m68hc11_reloc_type (type);
1288 break;
1289
1290 case EM_S12Z:
1291 rtype = elf_s12z_reloc_type (type);
1292 break;
1293
1294 case EM_68K:
1295 rtype = elf_m68k_reloc_type (type);
1296 break;
1297
1298 case EM_960:
1299 rtype = elf_i960_reloc_type (type);
1300 break;
1301
1302 case EM_AVR:
1303 case EM_AVR_OLD:
1304 rtype = elf_avr_reloc_type (type);
1305 break;
1306
1307 case EM_OLD_SPARCV9:
1308 case EM_SPARC32PLUS:
1309 case EM_SPARCV9:
1310 case EM_SPARC:
1311 rtype = elf_sparc_reloc_type (type);
1312 break;
1313
1314 case EM_SPU:
1315 rtype = elf_spu_reloc_type (type);
1316 break;
1317
1318 case EM_V800:
1319 rtype = v800_reloc_type (type);
1320 break;
1321 case EM_V850:
1322 case EM_CYGNUS_V850:
1323 rtype = v850_reloc_type (type);
1324 break;
1325
1326 case EM_D10V:
1327 case EM_CYGNUS_D10V:
1328 rtype = elf_d10v_reloc_type (type);
1329 break;
1330
1331 case EM_D30V:
1332 case EM_CYGNUS_D30V:
1333 rtype = elf_d30v_reloc_type (type);
1334 break;
1335
1336 case EM_DLX:
1337 rtype = elf_dlx_reloc_type (type);
1338 break;
1339
1340 case EM_SH:
1341 rtype = elf_sh_reloc_type (type);
1342 break;
1343
1344 case EM_MN10300:
1345 case EM_CYGNUS_MN10300:
1346 rtype = elf_mn10300_reloc_type (type);
1347 break;
1348
1349 case EM_MN10200:
1350 case EM_CYGNUS_MN10200:
1351 rtype = elf_mn10200_reloc_type (type);
1352 break;
1353
1354 case EM_FR30:
1355 case EM_CYGNUS_FR30:
1356 rtype = elf_fr30_reloc_type (type);
1357 break;
1358
1359 case EM_CYGNUS_FRV:
1360 rtype = elf_frv_reloc_type (type);
1361 break;
1362
1363 case EM_CSKY:
1364 rtype = elf_csky_reloc_type (type);
1365 break;
1366
1367 case EM_FT32:
1368 rtype = elf_ft32_reloc_type (type);
1369 break;
1370
1371 case EM_MCORE:
1372 rtype = elf_mcore_reloc_type (type);
1373 break;
1374
1375 case EM_MMIX:
1376 rtype = elf_mmix_reloc_type (type);
1377 break;
1378
1379 case EM_MOXIE:
1380 rtype = elf_moxie_reloc_type (type);
1381 break;
1382
1383 case EM_MSP430:
1384 if (uses_msp430x_relocs (filedata))
1385 {
1386 rtype = elf_msp430x_reloc_type (type);
1387 break;
1388 }
1389 /* Fall through. */
1390 case EM_MSP430_OLD:
1391 rtype = elf_msp430_reloc_type (type);
1392 break;
1393
1394 case EM_NDS32:
1395 rtype = elf_nds32_reloc_type (type);
1396 break;
1397
1398 case EM_PPC:
1399 rtype = elf_ppc_reloc_type (type);
1400 break;
1401
1402 case EM_PPC64:
1403 rtype = elf_ppc64_reloc_type (type);
1404 break;
1405
1406 case EM_MIPS:
1407 case EM_MIPS_RS3_LE:
1408 rtype = elf_mips_reloc_type (type);
1409 break;
1410
1411 case EM_RISCV:
1412 rtype = elf_riscv_reloc_type (type);
1413 break;
1414
1415 case EM_ALPHA:
1416 rtype = elf_alpha_reloc_type (type);
1417 break;
1418
1419 case EM_ARM:
1420 rtype = elf_arm_reloc_type (type);
1421 break;
1422
1423 case EM_ARC:
1424 case EM_ARC_COMPACT:
1425 case EM_ARC_COMPACT2:
1426 rtype = elf_arc_reloc_type (type);
1427 break;
1428
1429 case EM_PARISC:
1430 rtype = elf_hppa_reloc_type (type);
1431 break;
1432
1433 case EM_H8_300:
1434 case EM_H8_300H:
1435 case EM_H8S:
1436 rtype = elf_h8_reloc_type (type);
1437 break;
1438
1439 case EM_OR1K:
1440 rtype = elf_or1k_reloc_type (type);
1441 break;
1442
1443 case EM_PJ:
1444 case EM_PJ_OLD:
1445 rtype = elf_pj_reloc_type (type);
1446 break;
1447 case EM_IA_64:
1448 rtype = elf_ia64_reloc_type (type);
1449 break;
1450
1451 case EM_CRIS:
1452 rtype = elf_cris_reloc_type (type);
1453 break;
1454
1455 case EM_860:
1456 rtype = elf_i860_reloc_type (type);
1457 break;
1458
1459 case EM_X86_64:
1460 case EM_L1OM:
1461 case EM_K1OM:
1462 rtype = elf_x86_64_reloc_type (type);
1463 break;
1464
1465 case EM_S370:
1466 rtype = i370_reloc_type (type);
1467 break;
1468
1469 case EM_S390_OLD:
1470 case EM_S390:
1471 rtype = elf_s390_reloc_type (type);
1472 break;
1473
1474 case EM_SCORE:
1475 rtype = elf_score_reloc_type (type);
1476 break;
1477
1478 case EM_XSTORMY16:
1479 rtype = elf_xstormy16_reloc_type (type);
1480 break;
1481
1482 case EM_CRX:
1483 rtype = elf_crx_reloc_type (type);
1484 break;
1485
1486 case EM_VAX:
1487 rtype = elf_vax_reloc_type (type);
1488 break;
1489
1490 case EM_VISIUM:
1491 rtype = elf_visium_reloc_type (type);
1492 break;
1493
1494 case EM_BPF:
1495 rtype = elf_bpf_reloc_type (type);
1496 break;
1497
1498 case EM_ADAPTEVA_EPIPHANY:
1499 rtype = elf_epiphany_reloc_type (type);
1500 break;
1501
1502 case EM_IP2K:
1503 case EM_IP2K_OLD:
1504 rtype = elf_ip2k_reloc_type (type);
1505 break;
1506
1507 case EM_IQ2000:
1508 rtype = elf_iq2000_reloc_type (type);
1509 break;
1510
1511 case EM_XTENSA_OLD:
1512 case EM_XTENSA:
1513 rtype = elf_xtensa_reloc_type (type);
1514 break;
1515
1516 case EM_LATTICEMICO32:
1517 rtype = elf_lm32_reloc_type (type);
1518 break;
1519
1520 case EM_M32C_OLD:
1521 case EM_M32C:
1522 rtype = elf_m32c_reloc_type (type);
1523 break;
1524
1525 case EM_MT:
1526 rtype = elf_mt_reloc_type (type);
1527 break;
1528
1529 case EM_BLACKFIN:
1530 rtype = elf_bfin_reloc_type (type);
1531 break;
1532
1533 case EM_CYGNUS_MEP:
1534 rtype = elf_mep_reloc_type (type);
1535 break;
1536
1537 case EM_CR16:
1538 rtype = elf_cr16_reloc_type (type);
1539 break;
1540
1541 case EM_MICROBLAZE:
1542 case EM_MICROBLAZE_OLD:
1543 rtype = elf_microblaze_reloc_type (type);
1544 break;
1545
1546 case EM_RL78:
1547 rtype = elf_rl78_reloc_type (type);
1548 break;
1549
1550 case EM_RX:
1551 rtype = elf_rx_reloc_type (type);
1552 break;
1553
1554 case EM_METAG:
1555 rtype = elf_metag_reloc_type (type);
1556 break;
1557
1558 case EM_XC16X:
1559 case EM_C166:
1560 rtype = elf_xc16x_reloc_type (type);
1561 break;
1562
1563 case EM_TI_C6000:
1564 rtype = elf_tic6x_reloc_type (type);
1565 break;
1566
1567 case EM_TILEGX:
1568 rtype = elf_tilegx_reloc_type (type);
1569 break;
1570
1571 case EM_TILEPRO:
1572 rtype = elf_tilepro_reloc_type (type);
1573 break;
1574
1575 case EM_WEBASSEMBLY:
1576 rtype = elf_wasm32_reloc_type (type);
1577 break;
1578
1579 case EM_XGATE:
1580 rtype = elf_xgate_reloc_type (type);
1581 break;
1582
1583 case EM_ALTERA_NIOS2:
1584 rtype = elf_nios2_reloc_type (type);
1585 break;
1586
1587 case EM_TI_PRU:
1588 rtype = elf_pru_reloc_type (type);
1589 break;
1590
1591 case EM_NFP:
1592 if (EF_NFP_MACH (filedata->file_header.e_flags) == E_NFP_MACH_3200)
1593 rtype = elf_nfp3200_reloc_type (type);
1594 else
1595 rtype = elf_nfp_reloc_type (type);
1596 break;
1597 }
1598
1599 if (rtype == NULL)
1600 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1601 else
1602 printf (do_wide ? "%-22s" : "%-17.17s", rtype);
1603
1604 if (filedata->file_header.e_machine == EM_ALPHA
1605 && rtype != NULL
1606 && streq (rtype, "R_ALPHA_LITUSE")
1607 && is_rela)
1608 {
1609 switch (rels[i].r_addend)
1610 {
1611 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1612 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1613 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1614 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1615 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1616 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1617 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1618 default: rtype = NULL;
1619 }
1620
1621 if (rtype)
1622 printf (" (%s)", rtype);
1623 else
1624 {
1625 putchar (' ');
1626 printf (_("<unknown addend: %lx>"),
1627 (unsigned long) rels[i].r_addend);
1628 res = FALSE;
1629 }
1630 }
1631 else if (symtab_index)
1632 {
1633 if (symtab == NULL || symtab_index >= nsyms)
1634 {
1635 error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index);
1636 res = FALSE;
1637 }
1638 else
1639 {
1640 Elf_Internal_Sym * psym;
1641 const char * version_string;
1642 enum versioned_symbol_info sym_info;
1643 unsigned short vna_other;
1644
1645 psym = symtab + symtab_index;
1646
1647 version_string
1648 = get_symbol_version_string (filedata, is_dynsym,
1649 strtab, strtablen,
1650 symtab_index,
1651 psym,
1652 &sym_info,
1653 &vna_other);
1654
1655 printf (" ");
1656
1657 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1658 {
1659 const char * name;
1660 unsigned int len;
1661 unsigned int width = is_32bit_elf ? 8 : 14;
1662
1663 /* Relocations against GNU_IFUNC symbols do not use the value
1664 of the symbol as the address to relocate against. Instead
1665 they invoke the function named by the symbol and use its
1666 result as the address for relocation.
1667
1668 To indicate this to the user, do not display the value of
1669 the symbol in the "Symbols's Value" field. Instead show
1670 its name followed by () as a hint that the symbol is
1671 invoked. */
1672
1673 if (strtab == NULL
1674 || psym->st_name == 0
1675 || psym->st_name >= strtablen)
1676 name = "??";
1677 else
1678 name = strtab + psym->st_name;
1679
1680 len = print_symbol (width, name);
1681 if (version_string)
1682 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1683 version_string);
1684 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1685 }
1686 else
1687 {
1688 print_vma (psym->st_value, LONG_HEX);
1689
1690 printf (is_32bit_elf ? " " : " ");
1691 }
1692
1693 if (psym->st_name == 0)
1694 {
1695 const char * sec_name = "<null>";
1696 char name_buf[40];
1697
1698 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1699 {
1700 if (psym->st_shndx < filedata->file_header.e_shnum)
1701 sec_name = SECTION_NAME (filedata->section_headers + psym->st_shndx);
1702 else if (psym->st_shndx == SHN_ABS)
1703 sec_name = "ABS";
1704 else if (psym->st_shndx == SHN_COMMON)
1705 sec_name = "COMMON";
1706 else if ((filedata->file_header.e_machine == EM_MIPS
1707 && psym->st_shndx == SHN_MIPS_SCOMMON)
1708 || (filedata->file_header.e_machine == EM_TI_C6000
1709 && psym->st_shndx == SHN_TIC6X_SCOMMON))
1710 sec_name = "SCOMMON";
1711 else if (filedata->file_header.e_machine == EM_MIPS
1712 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1713 sec_name = "SUNDEF";
1714 else if ((filedata->file_header.e_machine == EM_X86_64
1715 || filedata->file_header.e_machine == EM_L1OM
1716 || filedata->file_header.e_machine == EM_K1OM)
1717 && psym->st_shndx == SHN_X86_64_LCOMMON)
1718 sec_name = "LARGE_COMMON";
1719 else if (filedata->file_header.e_machine == EM_IA_64
1720 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1721 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1722 sec_name = "ANSI_COM";
1723 else if (is_ia64_vms (filedata)
1724 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1725 sec_name = "VMS_SYMVEC";
1726 else
1727 {
1728 sprintf (name_buf, "<section 0x%x>",
1729 (unsigned int) psym->st_shndx);
1730 sec_name = name_buf;
1731 }
1732 }
1733 print_symbol (22, sec_name);
1734 }
1735 else if (strtab == NULL)
1736 printf (_("<string table index: %3ld>"), psym->st_name);
1737 else if (psym->st_name >= strtablen)
1738 {
1739 error (_("<corrupt string table index: %3ld>"), psym->st_name);
1740 res = FALSE;
1741 }
1742 else
1743 {
1744 print_symbol (22, strtab + psym->st_name);
1745 if (version_string)
1746 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1747 version_string);
1748 }
1749
1750 if (is_rela)
1751 {
1752 bfd_vma off = rels[i].r_addend;
1753
1754 if ((bfd_signed_vma) off < 0)
1755 printf (" - %" BFD_VMA_FMT "x", - off);
1756 else
1757 printf (" + %" BFD_VMA_FMT "x", off);
1758 }
1759 }
1760 }
1761 else if (is_rela)
1762 {
1763 bfd_vma off = rels[i].r_addend;
1764
1765 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1766 if ((bfd_signed_vma) off < 0)
1767 printf ("-%" BFD_VMA_FMT "x", - off);
1768 else
1769 printf ("%" BFD_VMA_FMT "x", off);
1770 }
1771
1772 if (filedata->file_header.e_machine == EM_SPARCV9
1773 && rtype != NULL
1774 && streq (rtype, "R_SPARC_OLO10"))
1775 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1776
1777 putchar ('\n');
1778
1779#ifdef BFD64
1780 if (! is_32bit_elf && filedata->file_header.e_machine == EM_MIPS)
1781 {
1782 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1783 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1784 const char * rtype2 = elf_mips_reloc_type (type2);
1785 const char * rtype3 = elf_mips_reloc_type (type3);
1786
1787 printf (" Type2: ");
1788
1789 if (rtype2 == NULL)
1790 printf (_("unrecognized: %-7lx"),
1791 (unsigned long) type2 & 0xffffffff);
1792 else
1793 printf ("%-17.17s", rtype2);
1794
1795 printf ("\n Type3: ");
1796
1797 if (rtype3 == NULL)
1798 printf (_("unrecognized: %-7lx"),
1799 (unsigned long) type3 & 0xffffffff);
1800 else
1801 printf ("%-17.17s", rtype3);
1802
1803 putchar ('\n');
1804 }
1805#endif /* BFD64 */
1806 }
1807
1808 free (rels);
1809
1810 return res;
1811}
1812
1813static const char *
1814get_aarch64_dynamic_type (unsigned long type)
1815{
1816 switch (type)
1817 {
1818 case DT_AARCH64_BTI_PLT: return "AARCH64_BTI_PLT";
1819 case DT_AARCH64_PAC_PLT: return "AARCH64_PAC_PLT";
1820 case DT_AARCH64_VARIANT_PCS: return "AARCH64_VARIANT_PCS";
1821 default:
1822 return NULL;
1823 }
1824}
1825
1826static const char *
1827get_mips_dynamic_type (unsigned long type)
1828{
1829 switch (type)
1830 {
1831 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1832 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1833 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1834 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1835 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1836 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1837 case DT_MIPS_MSYM: return "MIPS_MSYM";
1838 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1839 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1840 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1841 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1842 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1843 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1844 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1845 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1846 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1847 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1848 case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
1849 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1850 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1851 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1852 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1853 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1854 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1855 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1856 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1857 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1858 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1859 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1860 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1861 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1862 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1863 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1864 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1865 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1866 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1867 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1868 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1869 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1870 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1871 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1872 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1873 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1874 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1875 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1876 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1877 default:
1878 return NULL;
1879 }
1880}
1881
1882static const char *
1883get_sparc64_dynamic_type (unsigned long type)
1884{
1885 switch (type)
1886 {
1887 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1888 default:
1889 return NULL;
1890 }
1891}
1892
1893static const char *
1894get_ppc_dynamic_type (unsigned long type)
1895{
1896 switch (type)
1897 {
1898 case DT_PPC_GOT: return "PPC_GOT";
1899 case DT_PPC_OPT: return "PPC_OPT";
1900 default:
1901 return NULL;
1902 }
1903}
1904
1905static const char *
1906get_ppc64_dynamic_type (unsigned long type)
1907{
1908 switch (type)
1909 {
1910 case DT_PPC64_GLINK: return "PPC64_GLINK";
1911 case DT_PPC64_OPD: return "PPC64_OPD";
1912 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1913 case DT_PPC64_OPT: return "PPC64_OPT";
1914 default:
1915 return NULL;
1916 }
1917}
1918
1919static const char *
1920get_parisc_dynamic_type (unsigned long type)
1921{
1922 switch (type)
1923 {
1924 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1925 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1926 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1927 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1928 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1929 case DT_HP_PREINIT: return "HP_PREINIT";
1930 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1931 case DT_HP_NEEDED: return "HP_NEEDED";
1932 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1933 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1934 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1935 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1936 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1937 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1938 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1939 case DT_HP_FILTERED: return "HP_FILTERED";
1940 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1941 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1942 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1943 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1944 case DT_PLT: return "PLT";
1945 case DT_PLT_SIZE: return "PLT_SIZE";
1946 case DT_DLT: return "DLT";
1947 case DT_DLT_SIZE: return "DLT_SIZE";
1948 default:
1949 return NULL;
1950 }
1951}
1952
1953static const char *
1954get_ia64_dynamic_type (unsigned long type)
1955{
1956 switch (type)
1957 {
1958 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1959 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1960 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1961 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1962 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1963 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1964 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1965 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1966 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1967 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1968 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1969 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1970 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1971 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1972 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1973 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1974 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1975 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1976 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1977 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1978 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1979 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1980 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1981 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1982 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1983 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1984 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1985 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1986 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1987 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1988 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
1989 default:
1990 return NULL;
1991 }
1992}
1993
1994static const char *
1995get_solaris_section_type (unsigned long type)
1996{
1997 switch (type)
1998 {
1999 case 0x6fffffee: return "SUNW_ancillary";
2000 case 0x6fffffef: return "SUNW_capchain";
2001 case 0x6ffffff0: return "SUNW_capinfo";
2002 case 0x6ffffff1: return "SUNW_symsort";
2003 case 0x6ffffff2: return "SUNW_tlssort";
2004 case 0x6ffffff3: return "SUNW_LDYNSYM";
2005 case 0x6ffffff4: return "SUNW_dof";
2006 case 0x6ffffff5: return "SUNW_cap";
2007 case 0x6ffffff6: return "SUNW_SIGNATURE";
2008 case 0x6ffffff7: return "SUNW_ANNOTATE";
2009 case 0x6ffffff8: return "SUNW_DEBUGSTR";
2010 case 0x6ffffff9: return "SUNW_DEBUG";
2011 case 0x6ffffffa: return "SUNW_move";
2012 case 0x6ffffffb: return "SUNW_COMDAT";
2013 case 0x6ffffffc: return "SUNW_syminfo";
2014 case 0x6ffffffd: return "SUNW_verdef";
2015 case 0x6ffffffe: return "SUNW_verneed";
2016 case 0x6fffffff: return "SUNW_versym";
2017 case 0x70000000: return "SPARC_GOTDATA";
2018 default: return NULL;
2019 }
2020}
2021
2022static const char *
2023get_alpha_dynamic_type (unsigned long type)
2024{
2025 switch (type)
2026 {
2027 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
2028 default: return NULL;
2029 }
2030}
2031
2032static const char *
2033get_score_dynamic_type (unsigned long type)
2034{
2035 switch (type)
2036 {
2037 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
2038 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
2039 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
2040 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
2041 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
2042 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
2043 default: return NULL;
2044 }
2045}
2046
2047static const char *
2048get_tic6x_dynamic_type (unsigned long type)
2049{
2050 switch (type)
2051 {
2052 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
2053 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
2054 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
2055 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
2056 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
2057 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
2058 default: return NULL;
2059 }
2060}
2061
2062static const char *
2063get_nios2_dynamic_type (unsigned long type)
2064{
2065 switch (type)
2066 {
2067 case DT_NIOS2_GP: return "NIOS2_GP";
2068 default: return NULL;
2069 }
2070}
2071
2072static const char *
2073get_solaris_dynamic_type (unsigned long type)
2074{
2075 switch (type)
2076 {
2077 case 0x6000000d: return "SUNW_AUXILIARY";
2078 case 0x6000000e: return "SUNW_RTLDINF";
2079 case 0x6000000f: return "SUNW_FILTER";
2080 case 0x60000010: return "SUNW_CAP";
2081 case 0x60000011: return "SUNW_SYMTAB";
2082 case 0x60000012: return "SUNW_SYMSZ";
2083 case 0x60000013: return "SUNW_SORTENT";
2084 case 0x60000014: return "SUNW_SYMSORT";
2085 case 0x60000015: return "SUNW_SYMSORTSZ";
2086 case 0x60000016: return "SUNW_TLSSORT";
2087 case 0x60000017: return "SUNW_TLSSORTSZ";
2088 case 0x60000018: return "SUNW_CAPINFO";
2089 case 0x60000019: return "SUNW_STRPAD";
2090 case 0x6000001a: return "SUNW_CAPCHAIN";
2091 case 0x6000001b: return "SUNW_LDMACH";
2092 case 0x6000001d: return "SUNW_CAPCHAINENT";
2093 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2094 case 0x60000021: return "SUNW_PARENT";
2095 case 0x60000023: return "SUNW_ASLR";
2096 case 0x60000025: return "SUNW_RELAX";
2097 case 0x60000029: return "SUNW_NXHEAP";
2098 case 0x6000002b: return "SUNW_NXSTACK";
2099
2100 case 0x70000001: return "SPARC_REGISTER";
2101 case 0x7ffffffd: return "AUXILIARY";
2102 case 0x7ffffffe: return "USED";
2103 case 0x7fffffff: return "FILTER";
2104
2105 default: return NULL;
2106 }
2107}
2108
2109static const char *
2110get_dynamic_type (Filedata * filedata, unsigned long type)
2111{
2112 static char buff[64];
2113
2114 switch (type)
2115 {
2116 case DT_NULL: return "NULL";
2117 case DT_NEEDED: return "NEEDED";
2118 case DT_PLTRELSZ: return "PLTRELSZ";
2119 case DT_PLTGOT: return "PLTGOT";
2120 case DT_HASH: return "HASH";
2121 case DT_STRTAB: return "STRTAB";
2122 case DT_SYMTAB: return "SYMTAB";
2123 case DT_RELA: return "RELA";
2124 case DT_RELASZ: return "RELASZ";
2125 case DT_RELAENT: return "RELAENT";
2126 case DT_STRSZ: return "STRSZ";
2127 case DT_SYMENT: return "SYMENT";
2128 case DT_INIT: return "INIT";
2129 case DT_FINI: return "FINI";
2130 case DT_SONAME: return "SONAME";
2131 case DT_RPATH: return "RPATH";
2132 case DT_SYMBOLIC: return "SYMBOLIC";
2133 case DT_REL: return "REL";
2134 case DT_RELSZ: return "RELSZ";
2135 case DT_RELENT: return "RELENT";
2136 case DT_PLTREL: return "PLTREL";
2137 case DT_DEBUG: return "DEBUG";
2138 case DT_TEXTREL: return "TEXTREL";
2139 case DT_JMPREL: return "JMPREL";
2140 case DT_BIND_NOW: return "BIND_NOW";
2141 case DT_INIT_ARRAY: return "INIT_ARRAY";
2142 case DT_FINI_ARRAY: return "FINI_ARRAY";
2143 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2144 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
2145 case DT_RUNPATH: return "RUNPATH";
2146 case DT_FLAGS: return "FLAGS";
2147
2148 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2149 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
2150 case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
2151
2152 case DT_CHECKSUM: return "CHECKSUM";
2153 case DT_PLTPADSZ: return "PLTPADSZ";
2154 case DT_MOVEENT: return "MOVEENT";
2155 case DT_MOVESZ: return "MOVESZ";
2156 case DT_FEATURE: return "FEATURE";
2157 case DT_POSFLAG_1: return "POSFLAG_1";
2158 case DT_SYMINSZ: return "SYMINSZ";
2159 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
2160
2161 case DT_ADDRRNGLO: return "ADDRRNGLO";
2162 case DT_CONFIG: return "CONFIG";
2163 case DT_DEPAUDIT: return "DEPAUDIT";
2164 case DT_AUDIT: return "AUDIT";
2165 case DT_PLTPAD: return "PLTPAD";
2166 case DT_MOVETAB: return "MOVETAB";
2167 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
2168
2169 case DT_VERSYM: return "VERSYM";
2170
2171 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2172 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
2173 case DT_RELACOUNT: return "RELACOUNT";
2174 case DT_RELCOUNT: return "RELCOUNT";
2175 case DT_FLAGS_1: return "FLAGS_1";
2176 case DT_VERDEF: return "VERDEF";
2177 case DT_VERDEFNUM: return "VERDEFNUM";
2178 case DT_VERNEED: return "VERNEED";
2179 case DT_VERNEEDNUM: return "VERNEEDNUM";
2180
2181 case DT_AUXILIARY: return "AUXILIARY";
2182 case DT_USED: return "USED";
2183 case DT_FILTER: return "FILTER";
2184
2185 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2186 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2187 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2188 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2189 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
2190 case DT_GNU_HASH: return "GNU_HASH";
2191
2192 default:
2193 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2194 {
2195 const char * result;
2196
2197 switch (filedata->file_header.e_machine)
2198 {
2199 case EM_AARCH64:
2200 result = get_aarch64_dynamic_type (type);
2201 break;
2202 case EM_MIPS:
2203 case EM_MIPS_RS3_LE:
2204 result = get_mips_dynamic_type (type);
2205 break;
2206 case EM_SPARCV9:
2207 result = get_sparc64_dynamic_type (type);
2208 break;
2209 case EM_PPC:
2210 result = get_ppc_dynamic_type (type);
2211 break;
2212 case EM_PPC64:
2213 result = get_ppc64_dynamic_type (type);
2214 break;
2215 case EM_IA_64:
2216 result = get_ia64_dynamic_type (type);
2217 break;
2218 case EM_ALPHA:
2219 result = get_alpha_dynamic_type (type);
2220 break;
2221 case EM_SCORE:
2222 result = get_score_dynamic_type (type);
2223 break;
2224 case EM_TI_C6000:
2225 result = get_tic6x_dynamic_type (type);
2226 break;
2227 case EM_ALTERA_NIOS2:
2228 result = get_nios2_dynamic_type (type);
2229 break;
2230 default:
2231 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2232 result = get_solaris_dynamic_type (type);
2233 else
2234 result = NULL;
2235 break;
2236 }
2237
2238 if (result != NULL)
2239 return result;
2240
2241 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2242 }
2243 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2244 || (filedata->file_header.e_machine == EM_PARISC
2245 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2246 {
2247 const char * result;
2248
2249 switch (filedata->file_header.e_machine)
2250 {
2251 case EM_PARISC:
2252 result = get_parisc_dynamic_type (type);
2253 break;
2254 case EM_IA_64:
2255 result = get_ia64_dynamic_type (type);
2256 break;
2257 default:
2258 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2259 result = get_solaris_dynamic_type (type);
2260 else
2261 result = NULL;
2262 break;
2263 }
2264
2265 if (result != NULL)
2266 return result;
2267
2268 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2269 type);
2270 }
2271 else
2272 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2273
2274 return buff;
2275 }
2276}
2277
2278static char *
2279get_file_type (unsigned e_type)
2280{
2281 static char buff[32];
2282
2283 switch (e_type)
2284 {
2285 case ET_NONE: return _("NONE (None)");
2286 case ET_REL: return _("REL (Relocatable file)");
2287 case ET_EXEC: return _("EXEC (Executable file)");
2288 case ET_DYN: return _("DYN (Shared object file)");
2289 case ET_CORE: return _("CORE (Core file)");
2290
2291 default:
2292 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2293 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2294 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2295 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2296 else
2297 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2298 return buff;
2299 }
2300}
2301
2302static char *
2303get_machine_name (unsigned e_machine)
2304{
2305 static char buff[64]; /* XXX */
2306
2307 switch (e_machine)
2308 {
2309 /* Please keep this switch table sorted by increasing EM_ value. */
2310 /* 0 */
2311 case EM_NONE: return _("None");
2312 case EM_M32: return "WE32100";
2313 case EM_SPARC: return "Sparc";
2314 case EM_386: return "Intel 80386";
2315 case EM_68K: return "MC68000";
2316 case EM_88K: return "MC88000";
2317 case EM_IAMCU: return "Intel MCU";
2318 case EM_860: return "Intel 80860";
2319 case EM_MIPS: return "MIPS R3000";
2320 case EM_S370: return "IBM System/370";
2321 /* 10 */
2322 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
2323 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
2324 case EM_PARISC: return "HPPA";
2325 case EM_VPP550: return "Fujitsu VPP500";
2326 case EM_SPARC32PLUS: return "Sparc v8+" ;
2327 case EM_960: return "Intel 80960";
2328 case EM_PPC: return "PowerPC";
2329 /* 20 */
2330 case EM_PPC64: return "PowerPC64";
2331 case EM_S390_OLD:
2332 case EM_S390: return "IBM S/390";
2333 case EM_SPU: return "SPU";
2334 /* 30 */
2335 case EM_V800: return "Renesas V850 (using RH850 ABI)";
2336 case EM_FR20: return "Fujitsu FR20";
2337 case EM_RH32: return "TRW RH32";
2338 case EM_MCORE: return "MCORE";
2339 /* 40 */
2340 case EM_ARM: return "ARM";
2341 case EM_OLD_ALPHA: return "Digital Alpha (old)";
2342 case EM_SH: return "Renesas / SuperH SH";
2343 case EM_SPARCV9: return "Sparc v9";
2344 case EM_TRICORE: return "Siemens Tricore";
2345 case EM_ARC: return "ARC";
2346 case EM_H8_300: return "Renesas H8/300";
2347 case EM_H8_300H: return "Renesas H8/300H";
2348 case EM_H8S: return "Renesas H8S";
2349 case EM_H8_500: return "Renesas H8/500";
2350 /* 50 */
2351 case EM_IA_64: return "Intel IA-64";
2352 case EM_MIPS_X: return "Stanford MIPS-X";
2353 case EM_COLDFIRE: return "Motorola Coldfire";
2354 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
2355 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2356 case EM_PCP: return "Siemens PCP";
2357 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2358 case EM_NDR1: return "Denso NDR1 microprocesspr";
2359 case EM_STARCORE: return "Motorola Star*Core processor";
2360 case EM_ME16: return "Toyota ME16 processor";
2361 /* 60 */
2362 case EM_ST100: return "STMicroelectronics ST100 processor";
2363 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
2364 case EM_X86_64: return "Advanced Micro Devices X86-64";
2365 case EM_PDSP: return "Sony DSP processor";
2366 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2367 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
2368 case EM_FX66: return "Siemens FX66 microcontroller";
2369 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2370 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2371 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
2372 /* 70 */
2373 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2374 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2375 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2376 case EM_SVX: return "Silicon Graphics SVx";
2377 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2378 case EM_VAX: return "Digital VAX";
2379 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
2380 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2381 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2382 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
2383 /* 80 */
2384 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
2385 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
2386 case EM_PRISM: return "Vitesse Prism";
2387 case EM_AVR_OLD:
2388 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
2389 case EM_CYGNUS_FR30:
2390 case EM_FR30: return "Fujitsu FR30";
2391 case EM_CYGNUS_D10V:
2392 case EM_D10V: return "d10v";
2393 case EM_CYGNUS_D30V:
2394 case EM_D30V: return "d30v";
2395 case EM_CYGNUS_V850:
2396 case EM_V850: return "Renesas V850";
2397 case EM_CYGNUS_M32R:
2398 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2399 case EM_CYGNUS_MN10300:
2400 case EM_MN10300: return "mn10300";
2401 /* 90 */
2402 case EM_CYGNUS_MN10200:
2403 case EM_MN10200: return "mn10200";
2404 case EM_PJ: return "picoJava";
2405 case EM_OR1K: return "OpenRISC 1000";
2406 case EM_ARC_COMPACT: return "ARCompact";
2407 case EM_XTENSA_OLD:
2408 case EM_XTENSA: return "Tensilica Xtensa Processor";
2409 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2410 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2411 case EM_NS32K: return "National Semiconductor 32000 series";
2412 case EM_TPC: return "Tenor Network TPC processor";
2413 case EM_SNP1K: return "Trebia SNP 1000 processor";
2414 /* 100 */
2415 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2416 case EM_IP2K_OLD:
2417 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
2418 case EM_MAX: return "MAX Processor";
2419 case EM_CR: return "National Semiconductor CompactRISC";
2420 case EM_F2MC16: return "Fujitsu F2MC16";
2421 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
2422 case EM_BLACKFIN: return "Analog Devices Blackfin";
2423 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2424 case EM_SEP: return "Sharp embedded microprocessor";
2425 case EM_ARCA: return "Arca RISC microprocessor";
2426 /* 110 */
2427 case EM_UNICORE: return "Unicore";
2428 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2429 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
2430 case EM_ALTERA_NIOS2: return "Altera Nios II";
2431 case EM_CRX: return "National Semiconductor CRX microprocessor";
2432 case EM_XGATE: return "Motorola XGATE embedded processor";
2433 case EM_C166:
2434 case EM_XC16X: return "Infineon Technologies xc16x";
2435 case EM_M16C: return "Renesas M16C series microprocessors";
2436 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2437 case EM_CE: return "Freescale Communication Engine RISC core";
2438 /* 120 */
2439 case EM_M32C: return "Renesas M32c";
2440 /* 130 */
2441 case EM_TSK3000: return "Altium TSK3000 core";
2442 case EM_RS08: return "Freescale RS08 embedded processor";
2443 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2444 case EM_SCORE: return "SUNPLUS S+Core";
2445 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2446 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2447 case EM_LATTICEMICO32: return "Lattice Mico32";
2448 case EM_SE_C17: return "Seiko Epson C17 family";
2449 /* 140 */
2450 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2451 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2452 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2453 case EM_TI_PRU: return "TI PRU I/O processor";
2454 /* 160 */
2455 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2456 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2457 case EM_R32C: return "Renesas R32C series microprocessors";
2458 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2459 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2460 case EM_8051: return "Intel 8051 and variants";
2461 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2462 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2463 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2464 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2465 /* 170 */
2466 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2467 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2468 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
2469 case EM_RX: return "Renesas RX";
2470 case EM_METAG: return "Imagination Technologies Meta processor architecture";
2471 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2472 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2473 case EM_CR16:
2474 case EM_MICROBLAZE:
2475 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
2476 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2477 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2478 /* 180 */
2479 case EM_L1OM: return "Intel L1OM";
2480 case EM_K1OM: return "Intel K1OM";
2481 case EM_INTEL182: return "Intel (reserved)";
2482 case EM_AARCH64: return "AArch64";
2483 case EM_ARM184: return "ARM (reserved)";
2484 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor";
2485 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2486 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2487 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
2488 /* 190 */
2489 case EM_CUDA: return "NVIDIA CUDA architecture";
2490 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
2491 case EM_CLOUDSHIELD: return "CloudShield architecture family";
2492 case EM_COREA_1ST: return "KIPO-KAIST Core-A 1st generation processor family";
2493 case EM_COREA_2ND: return "KIPO-KAIST Core-A 2nd generation processor family";
2494 case EM_ARC_COMPACT2: return "ARCv2";
2495 case EM_OPEN8: return "Open8 8-bit RISC soft processor core";
2496 case EM_RL78: return "Renesas RL78";
2497 case EM_VIDEOCORE5: return "Broadcom VideoCore V processor";
2498 case EM_78K0R: return "Renesas 78K0R";
2499 /* 200 */
2500 case EM_56800EX: return "Freescale 56800EX Digital Signal Controller (DSC)";
2501 case EM_BA1: return "Beyond BA1 CPU architecture";
2502 case EM_BA2: return "Beyond BA2 CPU architecture";
2503 case EM_XCORE: return "XMOS xCORE processor family";
2504 case EM_MCHP_PIC: return "Microchip 8-bit PIC(r) family";
2505 /* 210 */
2506 case EM_KM32: return "KM211 KM32 32-bit processor";
2507 case EM_KMX32: return "KM211 KMX32 32-bit processor";
2508 case EM_KMX16: return "KM211 KMX16 16-bit processor";
2509 case EM_KMX8: return "KM211 KMX8 8-bit processor";
2510 case EM_KVARC: return "KM211 KVARC processor";
2511 case EM_CDP: return "Paneve CDP architecture family";
2512 case EM_COGE: return "Cognitive Smart Memory Processor";
2513 case EM_COOL: return "Bluechip Systems CoolEngine";
2514 case EM_NORC: return "Nanoradio Optimized RISC";
2515 case EM_CSR_KALIMBA: return "CSR Kalimba architecture family";
2516 /* 220 */
2517 case EM_Z80: return "Zilog Z80";
2518 case EM_VISIUM: return "CDS VISIUMcore processor";
2519 case EM_FT32: return "FTDI Chip FT32";
2520 case EM_MOXIE: return "Moxie";
2521 case EM_AMDGPU: return "AMD GPU";
2522 case EM_RISCV: return "RISC-V";
2523 case EM_LANAI: return "Lanai 32-bit processor";
2524 case EM_BPF: return "Linux BPF";
2525 case EM_NFP: return "Netronome Flow Processor";
2526
2527 /* Large numbers... */
2528 case EM_MT: return "Morpho Techologies MT processor";
2529 case EM_ALPHA: return "Alpha";
2530 case EM_WEBASSEMBLY: return "Web Assembly";
2531 case EM_DLX: return "OpenDLX";
2532 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
2533 case EM_IQ2000: return "Vitesse IQ2000";
2534 case EM_M32C_OLD:
2535 case EM_NIOS32: return "Altera Nios";
2536 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
2537 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
2538 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2539 case EM_S12Z: return "Freescale S12Z";
2540 case EM_CSKY: return "C-SKY";
2541
2542 default:
2543 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2544 return buff;
2545 }
2546}
2547
2548static void
2549decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2550{
2551 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2552 other compilers don't a specific architecture type in the e_flags, and
2553 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2554 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2555 architectures.
2556
2557 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2558 but also sets a specific architecture type in the e_flags field.
2559
2560 However, when decoding the flags we don't worry if we see an
2561 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2562 ARCEM architecture type. */
2563
2564 switch (e_flags & EF_ARC_MACH_MSK)
2565 {
2566 /* We only expect these to occur for EM_ARC_COMPACT2. */
2567 case EF_ARC_CPU_ARCV2EM:
2568 strcat (buf, ", ARC EM");
2569 break;
2570 case EF_ARC_CPU_ARCV2HS:
2571 strcat (buf, ", ARC HS");
2572 break;
2573
2574 /* We only expect these to occur for EM_ARC_COMPACT. */
2575 case E_ARC_MACH_ARC600:
2576 strcat (buf, ", ARC600");
2577 break;
2578 case E_ARC_MACH_ARC601:
2579 strcat (buf, ", ARC601");
2580 break;
2581 case E_ARC_MACH_ARC700:
2582 strcat (buf, ", ARC700");
2583 break;
2584
2585 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2586 new ELF with new architecture being read by an old version of
2587 readelf, or (c) An ELF built with non-GNU compiler that does not
2588 set the architecture in the e_flags. */
2589 default:
2590 if (e_machine == EM_ARC_COMPACT)
2591 strcat (buf, ", Unknown ARCompact");
2592 else
2593 strcat (buf, ", Unknown ARC");
2594 break;
2595 }
2596
2597 switch (e_flags & EF_ARC_OSABI_MSK)
2598 {
2599 case E_ARC_OSABI_ORIG:
2600 strcat (buf, ", (ABI:legacy)");
2601 break;
2602 case E_ARC_OSABI_V2:
2603 strcat (buf, ", (ABI:v2)");
2604 break;
2605 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2606 case E_ARC_OSABI_V3:
2607 strcat (buf, ", v3 no-legacy-syscalls ABI");
2608 break;
2609 case E_ARC_OSABI_V4:
2610 strcat (buf, ", v4 ABI");
2611 break;
2612 default:
2613 strcat (buf, ", unrecognised ARC OSABI flag");
2614 break;
2615 }
2616}
2617
2618static void
2619decode_ARM_machine_flags (unsigned e_flags, char buf[])
2620{
2621 unsigned eabi;
2622 bfd_boolean unknown = FALSE;
2623
2624 eabi = EF_ARM_EABI_VERSION (e_flags);
2625 e_flags &= ~ EF_ARM_EABIMASK;
2626
2627 /* Handle "generic" ARM flags. */
2628 if (e_flags & EF_ARM_RELEXEC)
2629 {
2630 strcat (buf, ", relocatable executable");
2631 e_flags &= ~ EF_ARM_RELEXEC;
2632 }
2633
2634 if (e_flags & EF_ARM_PIC)
2635 {
2636 strcat (buf, ", position independent");
2637 e_flags &= ~ EF_ARM_PIC;
2638 }
2639
2640 /* Now handle EABI specific flags. */
2641 switch (eabi)
2642 {
2643 default:
2644 strcat (buf, ", <unrecognized EABI>");
2645 if (e_flags)
2646 unknown = TRUE;
2647 break;
2648
2649 case EF_ARM_EABI_VER1:
2650 strcat (buf, ", Version1 EABI");
2651 while (e_flags)
2652 {
2653 unsigned flag;
2654
2655 /* Process flags one bit at a time. */
2656 flag = e_flags & - e_flags;
2657 e_flags &= ~ flag;
2658
2659 switch (flag)
2660 {
2661 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2662 strcat (buf, ", sorted symbol tables");
2663 break;
2664
2665 default:
2666 unknown = TRUE;
2667 break;
2668 }
2669 }
2670 break;
2671
2672 case EF_ARM_EABI_VER2:
2673 strcat (buf, ", Version2 EABI");
2674 while (e_flags)
2675 {
2676 unsigned flag;
2677
2678 /* Process flags one bit at a time. */
2679 flag = e_flags & - e_flags;
2680 e_flags &= ~ flag;
2681
2682 switch (flag)
2683 {
2684 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2685 strcat (buf, ", sorted symbol tables");
2686 break;
2687
2688 case EF_ARM_DYNSYMSUSESEGIDX:
2689 strcat (buf, ", dynamic symbols use segment index");
2690 break;
2691
2692 case EF_ARM_MAPSYMSFIRST:
2693 strcat (buf, ", mapping symbols precede others");
2694 break;
2695
2696 default:
2697 unknown = TRUE;
2698 break;
2699 }
2700 }
2701 break;
2702
2703 case EF_ARM_EABI_VER3:
2704 strcat (buf, ", Version3 EABI");
2705 break;
2706
2707 case EF_ARM_EABI_VER4:
2708 strcat (buf, ", Version4 EABI");
2709 while (e_flags)
2710 {
2711 unsigned flag;
2712
2713 /* Process flags one bit at a time. */
2714 flag = e_flags & - e_flags;
2715 e_flags &= ~ flag;
2716
2717 switch (flag)
2718 {
2719 case EF_ARM_BE8:
2720 strcat (buf, ", BE8");
2721 break;
2722
2723 case EF_ARM_LE8:
2724 strcat (buf, ", LE8");
2725 break;
2726
2727 default:
2728 unknown = TRUE;
2729 break;
2730 }
2731 }
2732 break;
2733
2734 case EF_ARM_EABI_VER5:
2735 strcat (buf, ", Version5 EABI");
2736 while (e_flags)
2737 {
2738 unsigned flag;
2739
2740 /* Process flags one bit at a time. */
2741 flag = e_flags & - e_flags;
2742 e_flags &= ~ flag;
2743
2744 switch (flag)
2745 {
2746 case EF_ARM_BE8:
2747 strcat (buf, ", BE8");
2748 break;
2749
2750 case EF_ARM_LE8:
2751 strcat (buf, ", LE8");
2752 break;
2753
2754 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2755 strcat (buf, ", soft-float ABI");
2756 break;
2757
2758 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2759 strcat (buf, ", hard-float ABI");
2760 break;
2761
2762 default:
2763 unknown = TRUE;
2764 break;
2765 }
2766 }
2767 break;
2768
2769 case EF_ARM_EABI_UNKNOWN:
2770 strcat (buf, ", GNU EABI");
2771 while (e_flags)
2772 {
2773 unsigned flag;
2774
2775 /* Process flags one bit at a time. */
2776 flag = e_flags & - e_flags;
2777 e_flags &= ~ flag;
2778
2779 switch (flag)
2780 {
2781 case EF_ARM_INTERWORK:
2782 strcat (buf, ", interworking enabled");
2783 break;
2784
2785 case EF_ARM_APCS_26:
2786 strcat (buf, ", uses APCS/26");
2787 break;
2788
2789 case EF_ARM_APCS_FLOAT:
2790 strcat (buf, ", uses APCS/float");
2791 break;
2792
2793 case EF_ARM_PIC:
2794 strcat (buf, ", position independent");
2795 break;
2796
2797 case EF_ARM_ALIGN8:
2798 strcat (buf, ", 8 bit structure alignment");
2799 break;
2800
2801 case EF_ARM_NEW_ABI:
2802 strcat (buf, ", uses new ABI");
2803 break;
2804
2805 case EF_ARM_OLD_ABI:
2806 strcat (buf, ", uses old ABI");
2807 break;
2808
2809 case EF_ARM_SOFT_FLOAT:
2810 strcat (buf, ", software FP");
2811 break;
2812
2813 case EF_ARM_VFP_FLOAT:
2814 strcat (buf, ", VFP");
2815 break;
2816
2817 case EF_ARM_MAVERICK_FLOAT:
2818 strcat (buf, ", Maverick FP");
2819 break;
2820
2821 default:
2822 unknown = TRUE;
2823 break;
2824 }
2825 }
2826 }
2827
2828 if (unknown)
2829 strcat (buf,_(", <unknown>"));
2830}
2831
2832static void
2833decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2834{
2835 --size; /* Leave space for null terminator. */
2836
2837 switch (e_flags & EF_AVR_MACH)
2838 {
2839 case E_AVR_MACH_AVR1:
2840 strncat (buf, ", avr:1", size);
2841 break;
2842 case E_AVR_MACH_AVR2:
2843 strncat (buf, ", avr:2", size);
2844 break;
2845 case E_AVR_MACH_AVR25:
2846 strncat (buf, ", avr:25", size);
2847 break;
2848 case E_AVR_MACH_AVR3:
2849 strncat (buf, ", avr:3", size);
2850 break;
2851 case E_AVR_MACH_AVR31:
2852 strncat (buf, ", avr:31", size);
2853 break;
2854 case E_AVR_MACH_AVR35:
2855 strncat (buf, ", avr:35", size);
2856 break;
2857 case E_AVR_MACH_AVR4:
2858 strncat (buf, ", avr:4", size);
2859 break;
2860 case E_AVR_MACH_AVR5:
2861 strncat (buf, ", avr:5", size);
2862 break;
2863 case E_AVR_MACH_AVR51:
2864 strncat (buf, ", avr:51", size);
2865 break;
2866 case E_AVR_MACH_AVR6:
2867 strncat (buf, ", avr:6", size);
2868 break;
2869 case E_AVR_MACH_AVRTINY:
2870 strncat (buf, ", avr:100", size);
2871 break;
2872 case E_AVR_MACH_XMEGA1:
2873 strncat (buf, ", avr:101", size);
2874 break;
2875 case E_AVR_MACH_XMEGA2:
2876 strncat (buf, ", avr:102", size);
2877 break;
2878 case E_AVR_MACH_XMEGA3:
2879 strncat (buf, ", avr:103", size);
2880 break;
2881 case E_AVR_MACH_XMEGA4:
2882 strncat (buf, ", avr:104", size);
2883 break;
2884 case E_AVR_MACH_XMEGA5:
2885 strncat (buf, ", avr:105", size);
2886 break;
2887 case E_AVR_MACH_XMEGA6:
2888 strncat (buf, ", avr:106", size);
2889 break;
2890 case E_AVR_MACH_XMEGA7:
2891 strncat (buf, ", avr:107", size);
2892 break;
2893 default:
2894 strncat (buf, ", avr:<unknown>", size);
2895 break;
2896 }
2897
2898 size -= strlen (buf);
2899 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2900 strncat (buf, ", link-relax", size);
2901}
2902
2903static void
2904decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2905{
2906 unsigned abi;
2907 unsigned arch;
2908 unsigned config;
2909 unsigned version;
2910 bfd_boolean has_fpu = FALSE;
2911 unsigned int r = 0;
2912
2913 static const char *ABI_STRINGS[] =
2914 {
2915 "ABI v0", /* use r5 as return register; only used in N1213HC */
2916 "ABI v1", /* use r0 as return register */
2917 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2918 "ABI v2fp", /* for FPU */
2919 "AABI",
2920 "ABI2 FP+"
2921 };
2922 static const char *VER_STRINGS[] =
2923 {
2924 "Andes ELF V1.3 or older",
2925 "Andes ELF V1.3.1",
2926 "Andes ELF V1.4"
2927 };
2928 static const char *ARCH_STRINGS[] =
2929 {
2930 "",
2931 "Andes Star v1.0",
2932 "Andes Star v2.0",
2933 "Andes Star v3.0",
2934 "Andes Star v3.0m"
2935 };
2936
2937 abi = EF_NDS_ABI & e_flags;
2938 arch = EF_NDS_ARCH & e_flags;
2939 config = EF_NDS_INST & e_flags;
2940 version = EF_NDS32_ELF_VERSION & e_flags;
2941
2942 memset (buf, 0, size);
2943
2944 switch (abi)
2945 {
2946 case E_NDS_ABI_V0:
2947 case E_NDS_ABI_V1:
2948 case E_NDS_ABI_V2:
2949 case E_NDS_ABI_V2FP:
2950 case E_NDS_ABI_AABI:
2951 case E_NDS_ABI_V2FP_PLUS:
2952 /* In case there are holes in the array. */
2953 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2954 break;
2955
2956 default:
2957 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2958 break;
2959 }
2960
2961 switch (version)
2962 {
2963 case E_NDS32_ELF_VER_1_2:
2964 case E_NDS32_ELF_VER_1_3:
2965 case E_NDS32_ELF_VER_1_4:
2966 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2967 break;
2968
2969 default:
2970 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2971 break;
2972 }
2973
2974 if (E_NDS_ABI_V0 == abi)
2975 {
2976 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2977 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2978 if (arch == E_NDS_ARCH_STAR_V1_0)
2979 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2980 return;
2981 }
2982
2983 switch (arch)
2984 {
2985 case E_NDS_ARCH_STAR_V1_0:
2986 case E_NDS_ARCH_STAR_V2_0:
2987 case E_NDS_ARCH_STAR_V3_0:
2988 case E_NDS_ARCH_STAR_V3_M:
2989 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2990 break;
2991
2992 default:
2993 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2994 /* ARCH version determines how the e_flags are interpreted.
2995 If it is unknown, we cannot proceed. */
2996 return;
2997 }
2998
2999 /* Newer ABI; Now handle architecture specific flags. */
3000 if (arch == E_NDS_ARCH_STAR_V1_0)
3001 {
3002 if (config & E_NDS32_HAS_MFUSR_PC_INST)
3003 r += snprintf (buf + r, size -r, ", MFUSR_PC");
3004
3005 if (!(config & E_NDS32_HAS_NO_MAC_INST))
3006 r += snprintf (buf + r, size -r, ", MAC");
3007
3008 if (config & E_NDS32_HAS_DIV_INST)
3009 r += snprintf (buf + r, size -r, ", DIV");
3010
3011 if (config & E_NDS32_HAS_16BIT_INST)
3012 r += snprintf (buf + r, size -r, ", 16b");
3013 }
3014 else
3015 {
3016 if (config & E_NDS32_HAS_MFUSR_PC_INST)
3017 {
3018 if (version <= E_NDS32_ELF_VER_1_3)
3019 r += snprintf (buf + r, size -r, ", [B8]");
3020 else
3021 r += snprintf (buf + r, size -r, ", EX9");
3022 }
3023
3024 if (config & E_NDS32_HAS_MAC_DX_INST)
3025 r += snprintf (buf + r, size -r, ", MAC_DX");
3026
3027 if (config & E_NDS32_HAS_DIV_DX_INST)
3028 r += snprintf (buf + r, size -r, ", DIV_DX");
3029
3030 if (config & E_NDS32_HAS_16BIT_INST)
3031 {
3032 if (version <= E_NDS32_ELF_VER_1_3)
3033 r += snprintf (buf + r, size -r, ", 16b");
3034 else
3035 r += snprintf (buf + r, size -r, ", IFC");
3036 }
3037 }
3038
3039 if (config & E_NDS32_HAS_EXT_INST)
3040 r += snprintf (buf + r, size -r, ", PERF1");
3041
3042 if (config & E_NDS32_HAS_EXT2_INST)
3043 r += snprintf (buf + r, size -r, ", PERF2");
3044
3045 if (config & E_NDS32_HAS_FPU_INST)
3046 {
3047 has_fpu = TRUE;
3048 r += snprintf (buf + r, size -r, ", FPU_SP");
3049 }
3050
3051 if (config & E_NDS32_HAS_FPU_DP_INST)
3052 {
3053 has_fpu = TRUE;
3054 r += snprintf (buf + r, size -r, ", FPU_DP");
3055 }
3056
3057 if (config & E_NDS32_HAS_FPU_MAC_INST)
3058 {
3059 has_fpu = TRUE;
3060 r += snprintf (buf + r, size -r, ", FPU_MAC");
3061 }
3062
3063 if (has_fpu)
3064 {
3065 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
3066 {
3067 case E_NDS32_FPU_REG_8SP_4DP:
3068 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
3069 break;
3070 case E_NDS32_FPU_REG_16SP_8DP:
3071 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
3072 break;
3073 case E_NDS32_FPU_REG_32SP_16DP:
3074 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
3075 break;
3076 case E_NDS32_FPU_REG_32SP_32DP:
3077 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
3078 break;
3079 }
3080 }
3081
3082 if (config & E_NDS32_HAS_AUDIO_INST)
3083 r += snprintf (buf + r, size -r, ", AUDIO");
3084
3085 if (config & E_NDS32_HAS_STRING_INST)
3086 r += snprintf (buf + r, size -r, ", STR");
3087
3088 if (config & E_NDS32_HAS_REDUCED_REGS)
3089 r += snprintf (buf + r, size -r, ", 16REG");
3090
3091 if (config & E_NDS32_HAS_VIDEO_INST)
3092 {
3093 if (version <= E_NDS32_ELF_VER_1_3)
3094 r += snprintf (buf + r, size -r, ", VIDEO");
3095 else
3096 r += snprintf (buf + r, size -r, ", SATURATION");
3097 }
3098
3099 if (config & E_NDS32_HAS_ENCRIPT_INST)
3100 r += snprintf (buf + r, size -r, ", ENCRP");
3101
3102 if (config & E_NDS32_HAS_L2C_INST)
3103 r += snprintf (buf + r, size -r, ", L2C");
3104}
3105
3106static char *
3107get_machine_flags (Filedata * filedata, unsigned e_flags, unsigned e_machine)
3108{
3109 static char buf[1024];
3110
3111 buf[0] = '\0';
3112
3113 if (e_flags)
3114 {
3115 switch (e_machine)
3116 {
3117 default:
3118 break;
3119
3120 case EM_ARC_COMPACT2:
3121 case EM_ARC_COMPACT:
3122 decode_ARC_machine_flags (e_flags, e_machine, buf);
3123 break;
3124
3125 case EM_ARM:
3126 decode_ARM_machine_flags (e_flags, buf);
3127 break;
3128
3129 case EM_AVR:
3130 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
3131 break;
3132
3133 case EM_BLACKFIN:
3134 if (e_flags & EF_BFIN_PIC)
3135 strcat (buf, ", PIC");
3136
3137 if (e_flags & EF_BFIN_FDPIC)
3138 strcat (buf, ", FDPIC");
3139
3140 if (e_flags & EF_BFIN_CODE_IN_L1)
3141 strcat (buf, ", code in L1");
3142
3143 if (e_flags & EF_BFIN_DATA_IN_L1)
3144 strcat (buf, ", data in L1");
3145
3146 break;
3147
3148 case EM_CYGNUS_FRV:
3149 switch (e_flags & EF_FRV_CPU_MASK)
3150 {
3151 case EF_FRV_CPU_GENERIC:
3152 break;
3153
3154 default:
3155 strcat (buf, ", fr???");
3156 break;
3157
3158 case EF_FRV_CPU_FR300:
3159 strcat (buf, ", fr300");
3160 break;
3161
3162 case EF_FRV_CPU_FR400:
3163 strcat (buf, ", fr400");
3164 break;
3165 case EF_FRV_CPU_FR405:
3166 strcat (buf, ", fr405");
3167 break;
3168
3169 case EF_FRV_CPU_FR450:
3170 strcat (buf, ", fr450");
3171 break;
3172
3173 case EF_FRV_CPU_FR500:
3174 strcat (buf, ", fr500");
3175 break;
3176 case EF_FRV_CPU_FR550:
3177 strcat (buf, ", fr550");
3178 break;
3179
3180 case EF_FRV_CPU_SIMPLE:
3181 strcat (buf, ", simple");
3182 break;
3183 case EF_FRV_CPU_TOMCAT:
3184 strcat (buf, ", tomcat");
3185 break;
3186 }
3187 break;
3188
3189 case EM_68K:
3190 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
3191 strcat (buf, ", m68000");
3192 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3193 strcat (buf, ", cpu32");
3194 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3195 strcat (buf, ", fido_a");
3196 else
3197 {
3198 char const * isa = _("unknown");
3199 char const * mac = _("unknown mac");
3200 char const * additional = NULL;
3201
3202 switch (e_flags & EF_M68K_CF_ISA_MASK)
3203 {
3204 case EF_M68K_CF_ISA_A_NODIV:
3205 isa = "A";
3206 additional = ", nodiv";
3207 break;
3208 case EF_M68K_CF_ISA_A:
3209 isa = "A";
3210 break;
3211 case EF_M68K_CF_ISA_A_PLUS:
3212 isa = "A+";
3213 break;
3214 case EF_M68K_CF_ISA_B_NOUSP:
3215 isa = "B";
3216 additional = ", nousp";
3217 break;
3218 case EF_M68K_CF_ISA_B:
3219 isa = "B";
3220 break;
3221 case EF_M68K_CF_ISA_C:
3222 isa = "C";
3223 break;
3224 case EF_M68K_CF_ISA_C_NODIV:
3225 isa = "C";
3226 additional = ", nodiv";
3227 break;
3228 }
3229 strcat (buf, ", cf, isa ");
3230 strcat (buf, isa);
3231 if (additional)
3232 strcat (buf, additional);
3233 if (e_flags & EF_M68K_CF_FLOAT)
3234 strcat (buf, ", float");
3235 switch (e_flags & EF_M68K_CF_MAC_MASK)
3236 {
3237 case 0:
3238 mac = NULL;
3239 break;
3240 case EF_M68K_CF_MAC:
3241 mac = "mac";
3242 break;
3243 case EF_M68K_CF_EMAC:
3244 mac = "emac";
3245 break;
3246 case EF_M68K_CF_EMAC_B:
3247 mac = "emac_b";
3248 break;
3249 }
3250 if (mac)
3251 {
3252 strcat (buf, ", ");
3253 strcat (buf, mac);
3254 }
3255 }
3256 break;
3257
3258 case EM_CYGNUS_MEP:
3259 switch (e_flags & EF_MEP_CPU_MASK)
3260 {
3261 case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3262 case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3263 case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3264 case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3265 case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3266 case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3267 default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3268 }
3269
3270 switch (e_flags & EF_MEP_COP_MASK)
3271 {
3272 case EF_MEP_COP_NONE: break;
3273 case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3274 case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3275 case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3276 case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3277 default: strcat (buf, _("<unknown MeP copro type>")); break;
3278 }
3279
3280 if (e_flags & EF_MEP_LIBRARY)
3281 strcat (buf, ", Built for Library");
3282
3283 if (e_flags & EF_MEP_INDEX_MASK)
3284 sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3285 e_flags & EF_MEP_INDEX_MASK);
3286
3287 if (e_flags & ~ EF_MEP_ALL_FLAGS)
3288 sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3289 e_flags & ~ EF_MEP_ALL_FLAGS);
3290 break;
3291
3292 case EM_PPC:
3293 if (e_flags & EF_PPC_EMB)
3294 strcat (buf, ", emb");
3295
3296 if (e_flags & EF_PPC_RELOCATABLE)
3297 strcat (buf, _(", relocatable"));
3298
3299 if (e_flags & EF_PPC_RELOCATABLE_LIB)
3300 strcat (buf, _(", relocatable-lib"));
3301 break;
3302
3303 case EM_PPC64:
3304 if (e_flags & EF_PPC64_ABI)
3305 {
3306 char abi[] = ", abiv0";
3307
3308 abi[6] += e_flags & EF_PPC64_ABI;
3309 strcat (buf, abi);
3310 }
3311 break;
3312
3313 case EM_V800:
3314 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3315 strcat (buf, ", RH850 ABI");
3316
3317 if (e_flags & EF_V800_850E3)
3318 strcat (buf, ", V3 architecture");
3319
3320 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3321 strcat (buf, ", FPU not used");
3322
3323 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3324 strcat (buf, ", regmode: COMMON");
3325
3326 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3327 strcat (buf, ", r4 not used");
3328
3329 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3330 strcat (buf, ", r30 not used");
3331
3332 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3333 strcat (buf, ", r5 not used");
3334
3335 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3336 strcat (buf, ", r2 not used");
3337
3338 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3339 {
3340 switch (e_flags & - e_flags)
3341 {
3342 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3343 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3344 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3345 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3346 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3347 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3348 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3349 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3350 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3351 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3352 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3353 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3354 default: break;
3355 }
3356 }
3357 break;
3358
3359 case EM_V850:
3360 case EM_CYGNUS_V850:
3361 switch (e_flags & EF_V850_ARCH)
3362 {
3363 case E_V850E3V5_ARCH:
3364 strcat (buf, ", v850e3v5");
3365 break;
3366 case E_V850E2V3_ARCH:
3367 strcat (buf, ", v850e2v3");
3368 break;
3369 case E_V850E2_ARCH:
3370 strcat (buf, ", v850e2");
3371 break;
3372 case E_V850E1_ARCH:
3373 strcat (buf, ", v850e1");
3374 break;
3375 case E_V850E_ARCH:
3376 strcat (buf, ", v850e");
3377 break;
3378 case E_V850_ARCH:
3379 strcat (buf, ", v850");
3380 break;
3381 default:
3382 strcat (buf, _(", unknown v850 architecture variant"));
3383 break;
3384 }
3385 break;
3386
3387 case EM_M32R:
3388 case EM_CYGNUS_M32R:
3389 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3390 strcat (buf, ", m32r");
3391 break;
3392
3393 case EM_MIPS:
3394 case EM_MIPS_RS3_LE:
3395 if (e_flags & EF_MIPS_NOREORDER)
3396 strcat (buf, ", noreorder");
3397
3398 if (e_flags & EF_MIPS_PIC)
3399 strcat (buf, ", pic");
3400
3401 if (e_flags & EF_MIPS_CPIC)
3402 strcat (buf, ", cpic");
3403
3404 if (e_flags & EF_MIPS_UCODE)
3405 strcat (buf, ", ugen_reserved");
3406
3407 if (e_flags & EF_MIPS_ABI2)
3408 strcat (buf, ", abi2");
3409
3410 if (e_flags & EF_MIPS_OPTIONS_FIRST)
3411 strcat (buf, ", odk first");
3412
3413 if (e_flags & EF_MIPS_32BITMODE)
3414 strcat (buf, ", 32bitmode");
3415
3416 if (e_flags & EF_MIPS_NAN2008)
3417 strcat (buf, ", nan2008");
3418
3419 if (e_flags & EF_MIPS_FP64)
3420 strcat (buf, ", fp64");
3421
3422 switch ((e_flags & EF_MIPS_MACH))
3423 {
3424 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3425 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3426 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3427 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3428 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3429 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3430 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3431 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3432 case E_MIPS_MACH_5900: strcat (buf, ", 5900"); break;
3433 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
3434 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3435 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3436 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3437 case E_MIPS_MACH_GS464: strcat (buf, ", gs464"); break;
3438 case E_MIPS_MACH_GS464E: strcat (buf, ", gs464e"); break;
3439 case E_MIPS_MACH_GS264E: strcat (buf, ", gs264e"); break;
3440 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3441 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3442 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3443 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
3444 case E_MIPS_MACH_IAMR2: strcat (buf, ", interaptiv-mr2"); break;
3445 case 0:
3446 /* We simply ignore the field in this case to avoid confusion:
3447 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3448 extension. */
3449 break;
3450 default: strcat (buf, _(", unknown CPU")); break;
3451 }
3452
3453 switch ((e_flags & EF_MIPS_ABI))
3454 {
3455 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3456 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3457 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3458 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3459 case 0:
3460 /* We simply ignore the field in this case to avoid confusion:
3461 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3462 This means it is likely to be an o32 file, but not for
3463 sure. */
3464 break;
3465 default: strcat (buf, _(", unknown ABI")); break;
3466 }
3467
3468 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3469 strcat (buf, ", mdmx");
3470
3471 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3472 strcat (buf, ", mips16");
3473
3474 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3475 strcat (buf, ", micromips");
3476
3477 switch ((e_flags & EF_MIPS_ARCH))
3478 {
3479 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3480 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3481 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3482 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3483 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3484 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3485 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3486 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3487 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3488 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3489 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3490 default: strcat (buf, _(", unknown ISA")); break;
3491 }
3492 break;
3493
3494 case EM_NDS32:
3495 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3496 break;
3497
3498 case EM_NFP:
3499 switch (EF_NFP_MACH (e_flags))
3500 {
3501 case E_NFP_MACH_3200:
3502 strcat (buf, ", NFP-32xx");
3503 break;
3504 case E_NFP_MACH_6000:
3505 strcat (buf, ", NFP-6xxx");
3506 break;
3507 }
3508 break;
3509
3510 case EM_RISCV:
3511 if (e_flags & EF_RISCV_RVC)
3512 strcat (buf, ", RVC");
3513
3514 if (e_flags & EF_RISCV_RVE)
3515 strcat (buf, ", RVE");
3516
3517 switch (e_flags & EF_RISCV_FLOAT_ABI)
3518 {
3519 case EF_RISCV_FLOAT_ABI_SOFT:
3520 strcat (buf, ", soft-float ABI");
3521 break;
3522
3523 case EF_RISCV_FLOAT_ABI_SINGLE:
3524 strcat (buf, ", single-float ABI");
3525 break;
3526
3527 case EF_RISCV_FLOAT_ABI_DOUBLE:
3528 strcat (buf, ", double-float ABI");
3529 break;
3530
3531 case EF_RISCV_FLOAT_ABI_QUAD:
3532 strcat (buf, ", quad-float ABI");
3533 break;
3534 }
3535 break;
3536
3537 case EM_SH:
3538 switch ((e_flags & EF_SH_MACH_MASK))
3539 {
3540 case EF_SH1: strcat (buf, ", sh1"); break;
3541 case EF_SH2: strcat (buf, ", sh2"); break;
3542 case EF_SH3: strcat (buf, ", sh3"); break;
3543 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3544 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3545 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3546 case EF_SH3E: strcat (buf, ", sh3e"); break;
3547 case EF_SH4: strcat (buf, ", sh4"); break;
3548 case EF_SH5: strcat (buf, ", sh5"); break;
3549 case EF_SH2E: strcat (buf, ", sh2e"); break;
3550 case EF_SH4A: strcat (buf, ", sh4a"); break;
3551 case EF_SH2A: strcat (buf, ", sh2a"); break;
3552 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3553 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3554 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3555 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3556 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3557 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3558 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3559 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3560 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3561 default: strcat (buf, _(", unknown ISA")); break;
3562 }
3563
3564 if (e_flags & EF_SH_PIC)
3565 strcat (buf, ", pic");
3566
3567 if (e_flags & EF_SH_FDPIC)
3568 strcat (buf, ", fdpic");
3569 break;
3570
3571 case EM_OR1K:
3572 if (e_flags & EF_OR1K_NODELAY)
3573 strcat (buf, ", no delay");
3574 break;
3575
3576 case EM_SPARCV9:
3577 if (e_flags & EF_SPARC_32PLUS)
3578 strcat (buf, ", v8+");
3579
3580 if (e_flags & EF_SPARC_SUN_US1)
3581 strcat (buf, ", ultrasparcI");
3582
3583 if (e_flags & EF_SPARC_SUN_US3)
3584 strcat (buf, ", ultrasparcIII");
3585
3586 if (e_flags & EF_SPARC_HAL_R1)
3587 strcat (buf, ", halr1");
3588
3589 if (e_flags & EF_SPARC_LEDATA)
3590 strcat (buf, ", ledata");
3591
3592 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3593 strcat (buf, ", tso");
3594
3595 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3596 strcat (buf, ", pso");
3597
3598 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3599 strcat (buf, ", rmo");
3600 break;
3601
3602 case EM_PARISC:
3603 switch (e_flags & EF_PARISC_ARCH)
3604 {
3605 case EFA_PARISC_1_0:
3606 strcpy (buf, ", PA-RISC 1.0");
3607 break;
3608 case EFA_PARISC_1_1:
3609 strcpy (buf, ", PA-RISC 1.1");
3610 break;
3611 case EFA_PARISC_2_0:
3612 strcpy (buf, ", PA-RISC 2.0");
3613 break;
3614 default:
3615 break;
3616 }
3617 if (e_flags & EF_PARISC_TRAPNIL)
3618 strcat (buf, ", trapnil");
3619 if (e_flags & EF_PARISC_EXT)
3620 strcat (buf, ", ext");
3621 if (e_flags & EF_PARISC_LSB)
3622 strcat (buf, ", lsb");
3623 if (e_flags & EF_PARISC_WIDE)
3624 strcat (buf, ", wide");
3625 if (e_flags & EF_PARISC_NO_KABP)
3626 strcat (buf, ", no kabp");
3627 if (e_flags & EF_PARISC_LAZYSWAP)
3628 strcat (buf, ", lazyswap");
3629 break;
3630
3631 case EM_PJ:
3632 case EM_PJ_OLD:
3633 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3634 strcat (buf, ", new calling convention");
3635
3636 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3637 strcat (buf, ", gnu calling convention");
3638 break;
3639
3640 case EM_IA_64:
3641 if ((e_flags & EF_IA_64_ABI64))
3642 strcat (buf, ", 64-bit");
3643 else
3644 strcat (buf, ", 32-bit");
3645 if ((e_flags & EF_IA_64_REDUCEDFP))
3646 strcat (buf, ", reduced fp model");
3647 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3648 strcat (buf, ", no function descriptors, constant gp");
3649 else if ((e_flags & EF_IA_64_CONS_GP))
3650 strcat (buf, ", constant gp");
3651 if ((e_flags & EF_IA_64_ABSOLUTE))
3652 strcat (buf, ", absolute");
3653 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3654 {
3655 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3656 strcat (buf, ", vms_linkages");
3657 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3658 {
3659 case EF_IA_64_VMS_COMCOD_SUCCESS:
3660 break;
3661 case EF_IA_64_VMS_COMCOD_WARNING:
3662 strcat (buf, ", warning");
3663 break;
3664 case EF_IA_64_VMS_COMCOD_ERROR:
3665 strcat (buf, ", error");
3666 break;
3667 case EF_IA_64_VMS_COMCOD_ABORT:
3668 strcat (buf, ", abort");
3669 break;
3670 default:
3671 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3672 e_flags & EF_IA_64_VMS_COMCOD);
3673 strcat (buf, ", <unknown>");
3674 }
3675 }
3676 break;
3677
3678 case EM_VAX:
3679 if ((e_flags & EF_VAX_NONPIC))
3680 strcat (buf, ", non-PIC");
3681 if ((e_flags & EF_VAX_DFLOAT))
3682 strcat (buf, ", D-Float");
3683 if ((e_flags & EF_VAX_GFLOAT))
3684 strcat (buf, ", G-Float");
3685 break;
3686
3687 case EM_VISIUM:
3688 if (e_flags & EF_VISIUM_ARCH_MCM)
3689 strcat (buf, ", mcm");
3690 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3691 strcat (buf, ", mcm24");
3692 if (e_flags & EF_VISIUM_ARCH_GR6)
3693 strcat (buf, ", gr6");
3694 break;
3695
3696 case EM_RL78:
3697 switch (e_flags & E_FLAG_RL78_CPU_MASK)
3698 {
3699 case E_FLAG_RL78_ANY_CPU: break;
3700 case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3701 case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3702 case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3703 }
3704 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3705 strcat (buf, ", 64-bit doubles");
3706 break;
3707
3708 case EM_RX:
3709 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3710 strcat (buf, ", 64-bit doubles");
3711 if (e_flags & E_FLAG_RX_DSP)
3712 strcat (buf, ", dsp");
3713 if (e_flags & E_FLAG_RX_PID)
3714 strcat (buf, ", pid");
3715 if (e_flags & E_FLAG_RX_ABI)
3716 strcat (buf, ", RX ABI");
3717 if (e_flags & E_FLAG_RX_SINSNS_SET)
3718 strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3719 ? ", uses String instructions" : ", bans String instructions");
3720 if (e_flags & E_FLAG_RX_V2)
3721 strcat (buf, ", V2");
3722 if (e_flags & E_FLAG_RX_V3)
3723 strcat (buf, ", V3");
3724 break;
3725
3726 case EM_S390:
3727 if (e_flags & EF_S390_HIGH_GPRS)
3728 strcat (buf, ", highgprs");
3729 break;
3730
3731 case EM_TI_C6000:
3732 if ((e_flags & EF_C6000_REL))
3733 strcat (buf, ", relocatable module");
3734 break;
3735
3736 case EM_MSP430:
3737 strcat (buf, _(": architecture variant: "));
3738 switch (e_flags & EF_MSP430_MACH)
3739 {
3740 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3741 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3742 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3743 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3744 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3745 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3746 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3747 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3748 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3749 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3750 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3751 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3752 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3753 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3754 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3755 default:
3756 strcat (buf, _(": unknown")); break;
3757 }
3758
3759 if (e_flags & ~ EF_MSP430_MACH)
3760 strcat (buf, _(": unknown extra flag bits also present"));
3761 }
3762 }
3763
3764 return buf;
3765}
3766
3767static const char *
3768get_osabi_name (Filedata * filedata, unsigned int osabi)
3769{
3770 static char buff[32];
3771
3772 switch (osabi)
3773 {
3774 case ELFOSABI_NONE: return "UNIX - System V";
3775 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3776 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
3777 case ELFOSABI_GNU: return "UNIX - GNU";
3778 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3779 case ELFOSABI_AIX: return "UNIX - AIX";
3780 case ELFOSABI_IRIX: return "UNIX - IRIX";
3781 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3782 case ELFOSABI_TRU64: return "UNIX - TRU64";
3783 case ELFOSABI_MODESTO: return "Novell - Modesto";
3784 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3785 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3786 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3787 case ELFOSABI_AROS: return "AROS";
3788 case ELFOSABI_FENIXOS: return "FenixOS";
3789 case ELFOSABI_CLOUDABI: return "Nuxi CloudABI";
3790 case ELFOSABI_OPENVOS: return "Stratus Technologies OpenVOS";
3791 default:
3792 if (osabi >= 64)
3793 switch (filedata->file_header.e_machine)
3794 {
3795 case EM_ARM:
3796 switch (osabi)
3797 {
3798 case ELFOSABI_ARM: return "ARM";
3799 case ELFOSABI_ARM_FDPIC: return "ARM FDPIC";
3800 default:
3801 break;
3802 }
3803 break;
3804
3805 case EM_MSP430:
3806 case EM_MSP430_OLD:
3807 case EM_VISIUM:
3808 switch (osabi)
3809 {
3810 case ELFOSABI_STANDALONE: return _("Standalone App");
3811 default:
3812 break;
3813 }
3814 break;
3815
3816 case EM_TI_C6000:
3817 switch (osabi)
3818 {
3819 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3820 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3821 default:
3822 break;
3823 }
3824 break;
3825
3826 default:
3827 break;
3828 }
3829 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3830 return buff;
3831 }
3832}
3833
3834static const char *
3835get_aarch64_segment_type (unsigned long type)
3836{
3837 switch (type)
3838 {
3839 case PT_AARCH64_ARCHEXT: return "AARCH64_ARCHEXT";
3840 default: return NULL;
3841 }
3842}
3843
3844static const char *
3845get_arm_segment_type (unsigned long type)
3846{
3847 switch (type)
3848 {
3849 case PT_ARM_EXIDX: return "EXIDX";
3850 default: return NULL;
3851 }
3852}
3853
3854static const char *
3855get_s390_segment_type (unsigned long type)
3856{
3857 switch (type)
3858 {
3859 case PT_S390_PGSTE: return "S390_PGSTE";
3860 default: return NULL;
3861 }
3862}
3863
3864static const char *
3865get_mips_segment_type (unsigned long type)
3866{
3867 switch (type)
3868 {
3869 case PT_MIPS_REGINFO: return "REGINFO";
3870 case PT_MIPS_RTPROC: return "RTPROC";
3871 case PT_MIPS_OPTIONS: return "OPTIONS";
3872 case PT_MIPS_ABIFLAGS: return "ABIFLAGS";
3873 default: return NULL;
3874 }
3875}
3876
3877static const char *
3878get_parisc_segment_type (unsigned long type)
3879{
3880 switch (type)
3881 {
3882 case PT_HP_TLS: return "HP_TLS";
3883 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3884 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3885 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3886 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3887 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3888 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3889 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3890 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3891 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3892 case PT_HP_PARALLEL: return "HP_PARALLEL";
3893 case PT_HP_FASTBIND: return "HP_FASTBIND";
3894 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3895 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3896 case PT_HP_STACK: return "HP_STACK";
3897 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
3898 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3899 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
3900 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
3901 default: return NULL;
3902 }
3903}
3904
3905static const char *
3906get_ia64_segment_type (unsigned long type)
3907{
3908 switch (type)
3909 {
3910 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3911 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
3912 case PT_HP_TLS: return "HP_TLS";
3913 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3914 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3915 case PT_IA_64_HP_STACK: return "HP_STACK";
3916 default: return NULL;
3917 }
3918}
3919
3920static const char *
3921get_tic6x_segment_type (unsigned long type)
3922{
3923 switch (type)
3924 {
3925 case PT_C6000_PHATTR: return "C6000_PHATTR";
3926 default: return NULL;
3927 }
3928}
3929
3930static const char *
3931get_solaris_segment_type (unsigned long type)
3932{
3933 switch (type)
3934 {
3935 case 0x6464e550: return "PT_SUNW_UNWIND";
3936 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3937 case 0x6ffffff7: return "PT_LOSUNW";
3938 case 0x6ffffffa: return "PT_SUNWBSS";
3939 case 0x6ffffffb: return "PT_SUNWSTACK";
3940 case 0x6ffffffc: return "PT_SUNWDTRACE";
3941 case 0x6ffffffd: return "PT_SUNWCAP";
3942 case 0x6fffffff: return "PT_HISUNW";
3943 default: return NULL;
3944 }
3945}
3946
3947static const char *
3948get_segment_type (Filedata * filedata, unsigned long p_type)
3949{
3950 static char buff[32];
3951
3952 switch (p_type)
3953 {
3954 case PT_NULL: return "NULL";
3955 case PT_LOAD: return "LOAD";
3956 case PT_DYNAMIC: return "DYNAMIC";
3957 case PT_INTERP: return "INTERP";
3958 case PT_NOTE: return "NOTE";
3959 case PT_SHLIB: return "SHLIB";
3960 case PT_PHDR: return "PHDR";
3961 case PT_TLS: return "TLS";
3962 case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
3963 case PT_GNU_STACK: return "GNU_STACK";
3964 case PT_GNU_RELRO: return "GNU_RELRO";
3965 case PT_GNU_PROPERTY: return "GNU_PROPERTY";
3966
3967 default:
3968 if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
3969 {
3970 sprintf (buff, "GNU_MBIND+%#lx",
3971 p_type - PT_GNU_MBIND_LO);
3972 }
3973 else if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3974 {
3975 const char * result;
3976
3977 switch (filedata->file_header.e_machine)
3978 {
3979 case EM_AARCH64:
3980 result = get_aarch64_segment_type (p_type);
3981 break;
3982 case EM_ARM:
3983 result = get_arm_segment_type (p_type);
3984 break;
3985 case EM_MIPS:
3986 case EM_MIPS_RS3_LE:
3987 result = get_mips_segment_type (p_type);
3988 break;
3989 case EM_PARISC:
3990 result = get_parisc_segment_type (p_type);
3991 break;
3992 case EM_IA_64:
3993 result = get_ia64_segment_type (p_type);
3994 break;
3995 case EM_TI_C6000:
3996 result = get_tic6x_segment_type (p_type);
3997 break;
3998 case EM_S390:
3999 case EM_S390_OLD:
4000 result = get_s390_segment_type (p_type);
4001 break;
4002 default:
4003 result = NULL;
4004 break;
4005 }
4006
4007 if (result != NULL)
4008 return result;
4009
4010 sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
4011 }
4012 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
4013 {
4014 const char * result;
4015
4016 switch (filedata->file_header.e_machine)
4017 {
4018 case EM_PARISC:
4019 result = get_parisc_segment_type (p_type);
4020 break;
4021 case EM_IA_64:
4022 result = get_ia64_segment_type (p_type);
4023 break;
4024 default:
4025 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4026 result = get_solaris_segment_type (p_type);
4027 else
4028 result = NULL;
4029 break;
4030 }
4031
4032 if (result != NULL)
4033 return result;
4034
4035 sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
4036 }
4037 else
4038 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
4039
4040 return buff;
4041 }
4042}
4043
4044static const char *
4045get_arc_section_type_name (unsigned int sh_type)
4046{
4047 switch (sh_type)
4048 {
4049 case SHT_ARC_ATTRIBUTES: return "ARC_ATTRIBUTES";
4050 default:
4051 break;
4052 }
4053 return NULL;
4054}
4055
4056static const char *
4057get_mips_section_type_name (unsigned int sh_type)
4058{
4059 switch (sh_type)
4060 {
4061 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
4062 case SHT_MIPS_MSYM: return "MIPS_MSYM";
4063 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
4064 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
4065 case SHT_MIPS_UCODE: return "MIPS_UCODE";
4066 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
4067 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
4068 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
4069 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
4070 case SHT_MIPS_RELD: return "MIPS_RELD";
4071 case SHT_MIPS_IFACE: return "MIPS_IFACE";
4072 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
4073 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
4074 case SHT_MIPS_SHDR: return "MIPS_SHDR";
4075 case SHT_MIPS_FDESC: return "MIPS_FDESC";
4076 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
4077 case SHT_MIPS_DENSE: return "MIPS_DENSE";
4078 case SHT_MIPS_PDESC: return "MIPS_PDESC";
4079 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
4080 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
4081 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
4082 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
4083 case SHT_MIPS_LINE: return "MIPS_LINE";
4084 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
4085 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
4086 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
4087 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
4088 case SHT_MIPS_DWARF: return "MIPS_DWARF";
4089 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
4090 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
4091 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
4092 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
4093 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
4094 case SHT_MIPS_XLATE: return "MIPS_XLATE";
4095 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
4096 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
4097 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
4098 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
4099 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
4100 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
4101 default:
4102 break;
4103 }
4104 return NULL;
4105}
4106
4107static const char *
4108get_parisc_section_type_name (unsigned int sh_type)
4109{
4110 switch (sh_type)
4111 {
4112 case SHT_PARISC_EXT: return "PARISC_EXT";
4113 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
4114 case SHT_PARISC_DOC: return "PARISC_DOC";
4115 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
4116 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
4117 case SHT_PARISC_STUBS: return "PARISC_STUBS";
4118 case SHT_PARISC_DLKM: return "PARISC_DLKM";
4119 default: return NULL;
4120 }
4121}
4122
4123static const char *
4124get_ia64_section_type_name (Filedata * filedata, unsigned int sh_type)
4125{
4126 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4127 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
4128 return get_osabi_name (filedata, (sh_type & 0x00FF0000) >> 16);
4129
4130 switch (sh_type)
4131 {
4132 case SHT_IA_64_EXT: return "IA_64_EXT";
4133 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
4134 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
4135 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
4136 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
4137 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
4138 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
4139 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
4140 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
4141 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4142 default:
4143 break;
4144 }
4145 return NULL;
4146}
4147
4148static const char *
4149get_x86_64_section_type_name (unsigned int sh_type)
4150{
4151 switch (sh_type)
4152 {
4153 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
4154 default: return NULL;
4155 }
4156}
4157
4158static const char *
4159get_aarch64_section_type_name (unsigned int sh_type)
4160{
4161 switch (sh_type)
4162 {
4163 case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4164 default: return NULL;
4165 }
4166}
4167
4168static const char *
4169get_arm_section_type_name (unsigned int sh_type)
4170{
4171 switch (sh_type)
4172 {
4173 case SHT_ARM_EXIDX: return "ARM_EXIDX";
4174 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
4175 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
4176 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
4177 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
4178 default: return NULL;
4179 }
4180}
4181
4182static const char *
4183get_tic6x_section_type_name (unsigned int sh_type)
4184{
4185 switch (sh_type)
4186 {
4187 case SHT_C6000_UNWIND: return "C6000_UNWIND";
4188 case SHT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
4189 case SHT_C6000_ATTRIBUTES: return "C6000_ATTRIBUTES";
4190 case SHT_TI_ICODE: return "TI_ICODE";
4191 case SHT_TI_XREF: return "TI_XREF";
4192 case SHT_TI_HANDLER: return "TI_HANDLER";
4193 case SHT_TI_INITINFO: return "TI_INITINFO";
4194 case SHT_TI_PHATTRS: return "TI_PHATTRS";
4195 default: return NULL;
4196 }
4197}
4198
4199static const char *
4200get_msp430x_section_type_name (unsigned int sh_type)
4201{
4202 switch (sh_type)
4203 {
4204 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
4205 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
4206 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
4207 default: return NULL;
4208 }
4209}
4210
4211static const char *
4212get_nfp_section_type_name (unsigned int sh_type)
4213{
4214 switch (sh_type)
4215 {
4216 case SHT_NFP_MECONFIG: return "NFP_MECONFIG";
4217 case SHT_NFP_INITREG: return "NFP_INITREG";
4218 case SHT_NFP_UDEBUG: return "NFP_UDEBUG";
4219 default: return NULL;
4220 }
4221}
4222
4223static const char *
4224get_v850_section_type_name (unsigned int sh_type)
4225{
4226 switch (sh_type)
4227 {
4228 case SHT_V850_SCOMMON: return "V850 Small Common";
4229 case SHT_V850_TCOMMON: return "V850 Tiny Common";
4230 case SHT_V850_ZCOMMON: return "V850 Zero Common";
4231 case SHT_RENESAS_IOP: return "RENESAS IOP";
4232 case SHT_RENESAS_INFO: return "RENESAS INFO";
4233 default: return NULL;
4234 }
4235}
4236
4237static const char *
4238get_riscv_section_type_name (unsigned int sh_type)
4239{
4240 switch (sh_type)
4241 {
4242 case SHT_RISCV_ATTRIBUTES: return "RISCV_ATTRIBUTES";
4243 default: return NULL;
4244 }
4245}
4246
4247static const char *
4248get_section_type_name (Filedata * filedata, unsigned int sh_type)
4249{
4250 static char buff[32];
4251 const char * result;
4252
4253 switch (sh_type)
4254 {
4255 case SHT_NULL: return "NULL";
4256 case SHT_PROGBITS: return "PROGBITS";
4257 case SHT_SYMTAB: return "SYMTAB";
4258 case SHT_STRTAB: return "STRTAB";
4259 case SHT_RELA: return "RELA";
4260 case SHT_HASH: return "HASH";
4261 case SHT_DYNAMIC: return "DYNAMIC";
4262 case SHT_NOTE: return "NOTE";
4263 case SHT_NOBITS: return "NOBITS";
4264 case SHT_REL: return "REL";
4265 case SHT_SHLIB: return "SHLIB";
4266 case SHT_DYNSYM: return "DYNSYM";
4267 case SHT_INIT_ARRAY: return "INIT_ARRAY";
4268 case SHT_FINI_ARRAY: return "FINI_ARRAY";
4269 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
4270 case SHT_GNU_HASH: return "GNU_HASH";
4271 case SHT_GROUP: return "GROUP";
4272 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICES";
4273 case SHT_GNU_verdef: return "VERDEF";
4274 case SHT_GNU_verneed: return "VERNEED";
4275 case SHT_GNU_versym: return "VERSYM";
4276 case 0x6ffffff0: return "VERSYM";
4277 case 0x6ffffffc: return "VERDEF";
4278 case 0x7ffffffd: return "AUXILIARY";
4279 case 0x7fffffff: return "FILTER";
4280 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
4281
4282 default:
4283 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4284 {
4285 switch (filedata->file_header.e_machine)
4286 {
4287 case EM_ARC:
4288 case EM_ARC_COMPACT:
4289 case EM_ARC_COMPACT2:
4290 result = get_arc_section_type_name (sh_type);
4291 break;
4292 case EM_MIPS:
4293 case EM_MIPS_RS3_LE:
4294 result = get_mips_section_type_name (sh_type);
4295 break;
4296 case EM_PARISC:
4297 result = get_parisc_section_type_name (sh_type);
4298 break;
4299 case EM_IA_64:
4300 result = get_ia64_section_type_name (filedata, sh_type);
4301 break;
4302 case EM_X86_64:
4303 case EM_L1OM:
4304 case EM_K1OM:
4305 result = get_x86_64_section_type_name (sh_type);
4306 break;
4307 case EM_AARCH64:
4308 result = get_aarch64_section_type_name (sh_type);
4309 break;
4310 case EM_ARM:
4311 result = get_arm_section_type_name (sh_type);
4312 break;
4313 case EM_TI_C6000:
4314 result = get_tic6x_section_type_name (sh_type);
4315 break;
4316 case EM_MSP430:
4317 result = get_msp430x_section_type_name (sh_type);
4318 break;
4319 case EM_NFP:
4320 result = get_nfp_section_type_name (sh_type);
4321 break;
4322 case EM_V800:
4323 case EM_V850:
4324 case EM_CYGNUS_V850:
4325 result = get_v850_section_type_name (sh_type);
4326 break;
4327 case EM_RISCV:
4328 result = get_riscv_section_type_name (sh_type);
4329 break;
4330 default:
4331 result = NULL;
4332 break;
4333 }
4334
4335 if (result != NULL)
4336 return result;
4337
4338 sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4339 }
4340 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4341 {
4342 switch (filedata->file_header.e_machine)
4343 {
4344 case EM_IA_64:
4345 result = get_ia64_section_type_name (filedata, sh_type);
4346 break;
4347 default:
4348 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4349 result = get_solaris_section_type (sh_type);
4350 else
4351 {
4352 switch (sh_type)
4353 {
4354 case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4355 case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4356 case SHT_GNU_HASH: result = "GNU_HASH"; break;
4357 case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4358 default:
4359 result = NULL;
4360 break;
4361 }
4362 }
4363 break;
4364 }
4365
4366 if (result != NULL)
4367 return result;
4368
4369 sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4370 }
4371 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4372 {
4373 switch (filedata->file_header.e_machine)
4374 {
4375 case EM_V800:
4376 case EM_V850:
4377 case EM_CYGNUS_V850:
4378 result = get_v850_section_type_name (sh_type);
4379 break;
4380 default:
4381 result = NULL;
4382 break;
4383 }
4384
4385 if (result != NULL)
4386 return result;
4387
4388 sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4389 }
4390 else
4391 /* This message is probably going to be displayed in a 15
4392 character wide field, so put the hex value first. */
4393 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4394
4395 return buff;
4396 }
4397}
4398
4399#define OPTION_DEBUG_DUMP 512
4400#define OPTION_DYN_SYMS 513
4401#define OPTION_DWARF_DEPTH 514
4402#define OPTION_DWARF_START 515
4403#define OPTION_DWARF_CHECK 516
4404#define OPTION_CTF_DUMP 517
4405#define OPTION_CTF_PARENT 518
4406#define OPTION_CTF_SYMBOLS 519
4407#define OPTION_CTF_STRINGS 520
4408
4409static struct option options[] =
4410{
4411 {"all", no_argument, 0, 'a'},
4412 {"file-header", no_argument, 0, 'h'},
4413 {"program-headers", no_argument, 0, 'l'},
4414 {"headers", no_argument, 0, 'e'},
4415 {"histogram", no_argument, 0, 'I'},
4416 {"segments", no_argument, 0, 'l'},
4417 {"sections", no_argument, 0, 'S'},
4418 {"section-headers", no_argument, 0, 'S'},
4419 {"section-groups", no_argument, 0, 'g'},
4420 {"section-details", no_argument, 0, 't'},
4421 {"full-section-name",no_argument, 0, 'N'},
4422 {"symbols", no_argument, 0, 's'},
4423 {"syms", no_argument, 0, 's'},
4424 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
4425 {"relocs", no_argument, 0, 'r'},
4426 {"notes", no_argument, 0, 'n'},
4427 {"dynamic", no_argument, 0, 'd'},
4428 {"arch-specific", no_argument, 0, 'A'},
4429 {"version-info", no_argument, 0, 'V'},
4430 {"use-dynamic", no_argument, 0, 'D'},
4431 {"unwind", no_argument, 0, 'u'},
4432 {"archive-index", no_argument, 0, 'c'},
4433 {"hex-dump", required_argument, 0, 'x'},
4434 {"relocated-dump", required_argument, 0, 'R'},
4435 {"string-dump", required_argument, 0, 'p'},
4436 {"decompress", no_argument, 0, 'z'},
4437#ifdef SUPPORT_DISASSEMBLY
4438 {"instruction-dump", required_argument, 0, 'i'},
4439#endif
4440 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
4441
4442 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
4443 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4444 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
4445
4446 {"ctf", required_argument, 0, OPTION_CTF_DUMP},
4447
4448 {"ctf-symbols", required_argument, 0, OPTION_CTF_SYMBOLS},
4449 {"ctf-strings", required_argument, 0, OPTION_CTF_STRINGS},
4450 {"ctf-parent", required_argument, 0, OPTION_CTF_PARENT},
4451
4452 {"version", no_argument, 0, 'v'},
4453 {"wide", no_argument, 0, 'W'},
4454 {"help", no_argument, 0, 'H'},
4455 {0, no_argument, 0, 0}
4456};
4457
4458static void
4459usage (FILE * stream)
4460{
4461 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4462 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4463 fprintf (stream, _(" Options are:\n\
4464 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4465 -h --file-header Display the ELF file header\n\
4466 -l --program-headers Display the program headers\n\
4467 --segments An alias for --program-headers\n\
4468 -S --section-headers Display the sections' header\n\
4469 --sections An alias for --section-headers\n\
4470 -g --section-groups Display the section groups\n\
4471 -t --section-details Display the section details\n\
4472 -e --headers Equivalent to: -h -l -S\n\
4473 -s --syms Display the symbol table\n\
4474 --symbols An alias for --syms\n\
4475 --dyn-syms Display the dynamic symbol table\n\
4476 -n --notes Display the core notes (if present)\n\
4477 -r --relocs Display the relocations (if present)\n\
4478 -u --unwind Display the unwind info (if present)\n\
4479 -d --dynamic Display the dynamic section (if present)\n\
4480 -V --version-info Display the version sections (if present)\n\
4481 -A --arch-specific Display architecture specific information (if any)\n\
4482 -c --archive-index Display the symbol/file index in an archive\n\
4483 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4484 -x --hex-dump=<number|name>\n\
4485 Dump the contents of section <number|name> as bytes\n\
4486 -p --string-dump=<number|name>\n\
4487 Dump the contents of section <number|name> as strings\n\
4488 -R --relocated-dump=<number|name>\n\
4489 Dump the contents of section <number|name> as relocated bytes\n\
4490 -z --decompress Decompress section before dumping it\n\
4491 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4492 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4493 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4494 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4495 =addr,=cu_index,=links,=follow-links]\n\
4496 Display the contents of DWARF debug sections\n"));
4497 fprintf (stream, _("\
4498 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4499 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4500 or deeper\n"));
4501 fprintf (stream, _("\
4502 --ctf=<number|name> Display CTF info from section <number|name>\n\
4503 --ctf-parent=<number|name>\n\
4504 Use section <number|name> as the CTF parent\n\n\
4505 --ctf-symbols=<number|name>\n\
4506 Use section <number|name> as the CTF external symtab\n\n\
4507 --ctf-strings=<number|name>\n\
4508 Use section <number|name> as the CTF external strtab\n\n"));
4509
4510#ifdef SUPPORT_DISASSEMBLY
4511 fprintf (stream, _("\
4512 -i --instruction-dump=<number|name>\n\
4513 Disassemble the contents of section <number|name>\n"));
4514#endif
4515 fprintf (stream, _("\
4516 -I --histogram Display histogram of bucket list lengths\n\
4517 -W --wide Allow output width to exceed 80 characters\n\
4518 @<file> Read options from <file>\n\
4519 -H --help Display this information\n\
4520 -v --version Display the version number of readelf\n"));
4521
4522 if (REPORT_BUGS_TO[0] && stream == stdout)
4523 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4524
4525 exit (stream == stdout ? 0 : 1);
4526}
4527
4528/* Record the fact that the user wants the contents of section number
4529 SECTION to be displayed using the method(s) encoded as flags bits
4530 in TYPE. Note, TYPE can be zero if we are creating the array for
4531 the first time. */
4532
4533static void
4534request_dump_bynumber (Filedata * filedata, unsigned int section, dump_type type)
4535{
4536 if (section >= filedata->num_dump_sects)
4537 {
4538 dump_type * new_dump_sects;
4539
4540 new_dump_sects = (dump_type *) calloc (section + 1,
4541 sizeof (* new_dump_sects));
4542
4543 if (new_dump_sects == NULL)
4544 error (_("Out of memory allocating dump request table.\n"));
4545 else
4546 {
4547 if (filedata->dump_sects)
4548 {
4549 /* Copy current flag settings. */
4550 memcpy (new_dump_sects, filedata->dump_sects,
4551 filedata->num_dump_sects * sizeof (* new_dump_sects));
4552
4553 free (filedata->dump_sects);
4554 }
4555
4556 filedata->dump_sects = new_dump_sects;
4557 filedata->num_dump_sects = section + 1;
4558 }
4559 }
4560
4561 if (filedata->dump_sects)
4562 filedata->dump_sects[section] |= type;
4563}
4564
4565/* Request a dump by section name. */
4566
4567static void
4568request_dump_byname (const char * section, dump_type type)
4569{
4570 struct dump_list_entry * new_request;
4571
4572 new_request = (struct dump_list_entry *)
4573 malloc (sizeof (struct dump_list_entry));
4574 if (!new_request)
4575 error (_("Out of memory allocating dump request table.\n"));
4576
4577 new_request->name = strdup (section);
4578 if (!new_request->name)
4579 error (_("Out of memory allocating dump request table.\n"));
4580
4581 new_request->type = type;
4582
4583 new_request->next = dump_sects_byname;
4584 dump_sects_byname = new_request;
4585}
4586
4587static inline void
4588request_dump (Filedata * filedata, dump_type type)
4589{
4590 int section;
4591 char * cp;
4592
4593 do_dump++;
4594 section = strtoul (optarg, & cp, 0);
4595
4596 if (! *cp && section >= 0)
4597 request_dump_bynumber (filedata, section, type);
4598 else
4599 request_dump_byname (optarg, type);
4600}
4601
4602static void
4603parse_args (Filedata * filedata, int argc, char ** argv)
4604{
4605 int c;
4606
4607 if (argc < 2)
4608 usage (stderr);
4609
4610 while ((c = getopt_long
4611 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4612 {
4613 switch (c)
4614 {
4615 case 0:
4616 /* Long options. */
4617 break;
4618 case 'H':
4619 usage (stdout);
4620 break;
4621
4622 case 'a':
4623 do_syms = TRUE;
4624 do_reloc = TRUE;
4625 do_unwind = TRUE;
4626 do_dynamic = TRUE;
4627 do_header = TRUE;
4628 do_sections = TRUE;
4629 do_section_groups = TRUE;
4630 do_segments = TRUE;
4631 do_version = TRUE;
4632 do_histogram = TRUE;
4633 do_arch = TRUE;
4634 do_notes = TRUE;
4635 break;
4636 case 'g':
4637 do_section_groups = TRUE;
4638 break;
4639 case 't':
4640 case 'N':
4641 do_sections = TRUE;
4642 do_section_details = TRUE;
4643 break;
4644 case 'e':
4645 do_header = TRUE;
4646 do_sections = TRUE;
4647 do_segments = TRUE;
4648 break;
4649 case 'A':
4650 do_arch = TRUE;
4651 break;
4652 case 'D':
4653 do_using_dynamic = TRUE;
4654 break;
4655 case 'r':
4656 do_reloc = TRUE;
4657 break;
4658 case 'u':
4659 do_unwind = TRUE;
4660 break;
4661 case 'h':
4662 do_header = TRUE;
4663 break;
4664 case 'l':
4665 do_segments = TRUE;
4666 break;
4667 case 's':
4668 do_syms = TRUE;
4669 break;
4670 case 'S':
4671 do_sections = TRUE;
4672 break;
4673 case 'd':
4674 do_dynamic = TRUE;
4675 break;
4676 case 'I':
4677 do_histogram = TRUE;
4678 break;
4679 case 'n':
4680 do_notes = TRUE;
4681 break;
4682 case 'c':
4683 do_archive_index = TRUE;
4684 break;
4685 case 'x':
4686 request_dump (filedata, HEX_DUMP);
4687 break;
4688 case 'p':
4689 request_dump (filedata, STRING_DUMP);
4690 break;
4691 case 'R':
4692 request_dump (filedata, RELOC_DUMP);
4693 break;
4694 case 'z':
4695 decompress_dumps = TRUE;
4696 break;
4697 case 'w':
4698 do_dump = TRUE;
4699 if (optarg == 0)
4700 {
4701 do_debugging = TRUE;
4702 dwarf_select_sections_all ();
4703 }
4704 else
4705 {
4706 do_debugging = FALSE;
4707 dwarf_select_sections_by_letters (optarg);
4708 }
4709 break;
4710 case OPTION_DEBUG_DUMP:
4711 do_dump = TRUE;
4712 if (optarg == 0)
4713 do_debugging = TRUE;
4714 else
4715 {
4716 do_debugging = FALSE;
4717 dwarf_select_sections_by_names (optarg);
4718 }
4719 break;
4720 case OPTION_DWARF_DEPTH:
4721 {
4722 char *cp;
4723
4724 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4725 }
4726 break;
4727 case OPTION_DWARF_START:
4728 {
4729 char *cp;
4730
4731 dwarf_start_die = strtoul (optarg, & cp, 0);
4732 }
4733 break;
4734 case OPTION_DWARF_CHECK:
4735 dwarf_check = TRUE;
4736 break;
4737 case OPTION_CTF_DUMP:
4738 do_ctf = TRUE;
4739 request_dump (filedata, CTF_DUMP);
4740 break;
4741 case OPTION_CTF_SYMBOLS:
4742 dump_ctf_symtab_name = strdup (optarg);
4743 break;
4744 case OPTION_CTF_STRINGS:
4745 dump_ctf_strtab_name = strdup (optarg);
4746 break;
4747 case OPTION_CTF_PARENT:
4748 dump_ctf_parent_name = strdup (optarg);
4749 break;
4750 case OPTION_DYN_SYMS:
4751 do_dyn_syms = TRUE;
4752 break;
4753#ifdef SUPPORT_DISASSEMBLY
4754 case 'i':
4755 request_dump (filedata, DISASS_DUMP);
4756 break;
4757#endif
4758 case 'v':
4759 print_version (program_name);
4760 break;
4761 case 'V':
4762 do_version = TRUE;
4763 break;
4764 case 'W':
4765 do_wide = TRUE;
4766 break;
4767 default:
4768 /* xgettext:c-format */
4769 error (_("Invalid option '-%c'\n"), c);
4770 /* Fall through. */
4771 case '?':
4772 usage (stderr);
4773 }
4774 }
4775
4776 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4777 && !do_segments && !do_header && !do_dump && !do_version
4778 && !do_histogram && !do_debugging && !do_arch && !do_notes
4779 && !do_section_groups && !do_archive_index
4780 && !do_dyn_syms)
4781 usage (stderr);
4782}
4783
4784static const char *
4785get_elf_class (unsigned int elf_class)
4786{
4787 static char buff[32];
4788
4789 switch (elf_class)
4790 {
4791 case ELFCLASSNONE: return _("none");
4792 case ELFCLASS32: return "ELF32";
4793 case ELFCLASS64: return "ELF64";
4794 default:
4795 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4796 return buff;
4797 }
4798}
4799
4800static const char *
4801get_data_encoding (unsigned int encoding)
4802{
4803 static char buff[32];
4804
4805 switch (encoding)
4806 {
4807 case ELFDATANONE: return _("none");
4808 case ELFDATA2LSB: return _("2's complement, little endian");
4809 case ELFDATA2MSB: return _("2's complement, big endian");
4810 default:
4811 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4812 return buff;
4813 }
4814}
4815
4816/* Decode the data held in 'filedata->file_header'. */
4817
4818static bfd_boolean
4819process_file_header (Filedata * filedata)
4820{
4821 Elf_Internal_Ehdr * header = & filedata->file_header;
4822
4823 if ( header->e_ident[EI_MAG0] != ELFMAG0
4824 || header->e_ident[EI_MAG1] != ELFMAG1
4825 || header->e_ident[EI_MAG2] != ELFMAG2
4826 || header->e_ident[EI_MAG3] != ELFMAG3)
4827 {
4828 error
4829 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4830 return FALSE;
4831 }
4832
4833 init_dwarf_regnames (header->e_machine);
4834
4835 if (do_header)
4836 {
4837 unsigned i;
4838
4839 printf (_("ELF Header:\n"));
4840 printf (_(" Magic: "));
4841 for (i = 0; i < EI_NIDENT; i++)
4842 printf ("%2.2x ", header->e_ident[i]);
4843 printf ("\n");
4844 printf (_(" Class: %s\n"),
4845 get_elf_class (header->e_ident[EI_CLASS]));
4846 printf (_(" Data: %s\n"),
4847 get_data_encoding (header->e_ident[EI_DATA]));
4848 printf (_(" Version: %d%s\n"),
4849 header->e_ident[EI_VERSION],
4850 (header->e_ident[EI_VERSION] == EV_CURRENT
4851 ? _(" (current)")
4852 : (header->e_ident[EI_VERSION] != EV_NONE
4853 ? _(" <unknown>")
4854 : "")));
4855 printf (_(" OS/ABI: %s\n"),
4856 get_osabi_name (filedata, header->e_ident[EI_OSABI]));
4857 printf (_(" ABI Version: %d\n"),
4858 header->e_ident[EI_ABIVERSION]);
4859 printf (_(" Type: %s\n"),
4860 get_file_type (header->e_type));
4861 printf (_(" Machine: %s\n"),
4862 get_machine_name (header->e_machine));
4863 printf (_(" Version: 0x%lx\n"),
4864 header->e_version);
4865
4866 printf (_(" Entry point address: "));
4867 print_vma (header->e_entry, PREFIX_HEX);
4868 printf (_("\n Start of program headers: "));
4869 print_vma (header->e_phoff, DEC);
4870 printf (_(" (bytes into file)\n Start of section headers: "));
4871 print_vma (header->e_shoff, DEC);
4872 printf (_(" (bytes into file)\n"));
4873
4874 printf (_(" Flags: 0x%lx%s\n"),
4875 header->e_flags,
4876 get_machine_flags (filedata, header->e_flags, header->e_machine));
4877 printf (_(" Size of this header: %u (bytes)\n"),
4878 header->e_ehsize);
4879 printf (_(" Size of program headers: %u (bytes)\n"),
4880 header->e_phentsize);
4881 printf (_(" Number of program headers: %u"),
4882 header->e_phnum);
4883 if (filedata->section_headers != NULL
4884 && header->e_phnum == PN_XNUM
4885 && filedata->section_headers[0].sh_info != 0)
4886 {
4887 header->e_phnum = filedata->section_headers[0].sh_info;
4888 printf (" (%u)", header->e_phnum);
4889 }
4890 putc ('\n', stdout);
4891 printf (_(" Size of section headers: %u (bytes)\n"),
4892 header->e_shentsize);
4893 printf (_(" Number of section headers: %u"),
4894 header->e_shnum);
4895 if (filedata->section_headers != NULL && header->e_shnum == SHN_UNDEF)
4896 {
4897 header->e_shnum = filedata->section_headers[0].sh_size;
4898 printf (" (%u)", header->e_shnum);
4899 }
4900 putc ('\n', stdout);
4901 printf (_(" Section header string table index: %u"),
4902 header->e_shstrndx);
4903 if (filedata->section_headers != NULL
4904 && header->e_shstrndx == (SHN_XINDEX & 0xffff))
4905 {
4906 header->e_shstrndx = filedata->section_headers[0].sh_link;
4907 printf (" (%u)", header->e_shstrndx);
4908 }
4909 if (header->e_shstrndx != SHN_UNDEF
4910 && header->e_shstrndx >= header->e_shnum)
4911 {
4912 header->e_shstrndx = SHN_UNDEF;
4913 printf (_(" <corrupt: out of range>"));
4914 }
4915 putc ('\n', stdout);
4916 }
4917
4918 if (filedata->section_headers != NULL)
4919 {
4920 if (header->e_phnum == PN_XNUM
4921 && filedata->section_headers[0].sh_info != 0)
4922 header->e_phnum = filedata->section_headers[0].sh_info;
4923 if (header->e_shnum == SHN_UNDEF)
4924 header->e_shnum = filedata->section_headers[0].sh_size;
4925 if (header->e_shstrndx == (SHN_XINDEX & 0xffff))
4926 header->e_shstrndx = filedata->section_headers[0].sh_link;
4927 if (header->e_shstrndx >= header->e_shnum)
4928 header->e_shstrndx = SHN_UNDEF;
4929 free (filedata->section_headers);
4930 filedata->section_headers = NULL;
4931 }
4932
4933 return TRUE;
4934}
4935
4936/* Read in the program headers from FILEDATA and store them in PHEADERS.
4937 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
4938
4939static bfd_boolean
4940get_32bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4941{
4942 Elf32_External_Phdr * phdrs;
4943 Elf32_External_Phdr * external;
4944 Elf_Internal_Phdr * internal;
4945 unsigned int i;
4946 unsigned int size = filedata->file_header.e_phentsize;
4947 unsigned int num = filedata->file_header.e_phnum;
4948
4949 /* PR binutils/17531: Cope with unexpected section header sizes. */
4950 if (size == 0 || num == 0)
4951 return FALSE;
4952 if (size < sizeof * phdrs)
4953 {
4954 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4955 return FALSE;
4956 }
4957 if (size > sizeof * phdrs)
4958 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4959
4960 phdrs = (Elf32_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4961 size, num, _("program headers"));
4962 if (phdrs == NULL)
4963 return FALSE;
4964
4965 for (i = 0, internal = pheaders, external = phdrs;
4966 i < filedata->file_header.e_phnum;
4967 i++, internal++, external++)
4968 {
4969 internal->p_type = BYTE_GET (external->p_type);
4970 internal->p_offset = BYTE_GET (external->p_offset);
4971 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4972 internal->p_paddr = BYTE_GET (external->p_paddr);
4973 internal->p_filesz = BYTE_GET (external->p_filesz);
4974 internal->p_memsz = BYTE_GET (external->p_memsz);
4975 internal->p_flags = BYTE_GET (external->p_flags);
4976 internal->p_align = BYTE_GET (external->p_align);
4977 }
4978
4979 free (phdrs);
4980 return TRUE;
4981}
4982
4983/* Read in the program headers from FILEDATA and store them in PHEADERS.
4984 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
4985
4986static bfd_boolean
4987get_64bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4988{
4989 Elf64_External_Phdr * phdrs;
4990 Elf64_External_Phdr * external;
4991 Elf_Internal_Phdr * internal;
4992 unsigned int i;
4993 unsigned int size = filedata->file_header.e_phentsize;
4994 unsigned int num = filedata->file_header.e_phnum;
4995
4996 /* PR binutils/17531: Cope with unexpected section header sizes. */
4997 if (size == 0 || num == 0)
4998 return FALSE;
4999 if (size < sizeof * phdrs)
5000 {
5001 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5002 return FALSE;
5003 }
5004 if (size > sizeof * phdrs)
5005 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5006
5007 phdrs = (Elf64_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
5008 size, num, _("program headers"));
5009 if (!phdrs)
5010 return FALSE;
5011
5012 for (i = 0, internal = pheaders, external = phdrs;
5013 i < filedata->file_header.e_phnum;
5014 i++, internal++, external++)
5015 {
5016 internal->p_type = BYTE_GET (external->p_type);
5017 internal->p_flags = BYTE_GET (external->p_flags);
5018 internal->p_offset = BYTE_GET (external->p_offset);
5019 internal->p_vaddr = BYTE_GET (external->p_vaddr);
5020 internal->p_paddr = BYTE_GET (external->p_paddr);
5021 internal->p_filesz = BYTE_GET (external->p_filesz);
5022 internal->p_memsz = BYTE_GET (external->p_memsz);
5023 internal->p_align = BYTE_GET (external->p_align);
5024 }
5025
5026 free (phdrs);
5027 return TRUE;
5028}
5029
5030/* Returns TRUE if the program headers were read into `program_headers'. */
5031
5032static bfd_boolean
5033get_program_headers (Filedata * filedata)
5034{
5035 Elf_Internal_Phdr * phdrs;
5036
5037 /* Check cache of prior read. */
5038 if (filedata->program_headers != NULL)
5039 return TRUE;
5040
5041 /* Be kind to memory checkers by looking for
5042 e_phnum values which we know must be invalid. */
5043 if (filedata->file_header.e_phnum
5044 * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
5045 >= filedata->file_size)
5046 {
5047 error (_("Too many program headers - %#x - the file is not that big\n"),
5048 filedata->file_header.e_phnum);
5049 return FALSE;
5050 }
5051
5052 phdrs = (Elf_Internal_Phdr *) cmalloc (filedata->file_header.e_phnum,
5053 sizeof (Elf_Internal_Phdr));
5054 if (phdrs == NULL)
5055 {
5056 error (_("Out of memory reading %u program headers\n"),
5057 filedata->file_header.e_phnum);
5058 return FALSE;
5059 }
5060
5061 if (is_32bit_elf
5062 ? get_32bit_program_headers (filedata, phdrs)
5063 : get_64bit_program_headers (filedata, phdrs))
5064 {
5065 filedata->program_headers = phdrs;
5066 return TRUE;
5067 }
5068
5069 free (phdrs);
5070 return FALSE;
5071}
5072
5073/* Returns TRUE if the program headers were loaded. */
5074
5075static bfd_boolean
5076process_program_headers (Filedata * filedata)
5077{
5078 Elf_Internal_Phdr * segment;
5079 unsigned int i;
5080 Elf_Internal_Phdr * previous_load = NULL;
5081
5082 if (filedata->file_header.e_phnum == 0)
5083 {
5084 /* PR binutils/12467. */
5085 if (filedata->file_header.e_phoff != 0)
5086 {
5087 warn (_("possibly corrupt ELF header - it has a non-zero program"
5088 " header offset, but no program headers\n"));
5089 return FALSE;
5090 }
5091 else if (do_segments)
5092 printf (_("\nThere are no program headers in this file.\n"));
5093 return TRUE;
5094 }
5095
5096 if (do_segments && !do_header)
5097 {
5098 printf (_("\nElf file type is %s\n"), get_file_type (filedata->file_header.e_type));
5099 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata->file_header.e_entry));
5100 printf (ngettext ("There is %d program header, starting at offset %s\n",
5101 "There are %d program headers, starting at offset %s\n",
5102 filedata->file_header.e_phnum),
5103 filedata->file_header.e_phnum,
5104 bfd_vmatoa ("u", filedata->file_header.e_phoff));
5105 }
5106
5107 if (! get_program_headers (filedata))
5108 return TRUE;
5109
5110 if (do_segments)
5111 {
5112 if (filedata->file_header.e_phnum > 1)
5113 printf (_("\nProgram Headers:\n"));
5114 else
5115 printf (_("\nProgram Headers:\n"));
5116
5117 if (is_32bit_elf)
5118 printf
5119 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5120 else if (do_wide)
5121 printf
5122 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5123 else
5124 {
5125 printf
5126 (_(" Type Offset VirtAddr PhysAddr\n"));
5127 printf
5128 (_(" FileSiz MemSiz Flags Align\n"));
5129 }
5130 }
5131
5132 dynamic_addr = 0;
5133 dynamic_size = 0;
5134
5135 for (i = 0, segment = filedata->program_headers;
5136 i < filedata->file_header.e_phnum;
5137 i++, segment++)
5138 {
5139 if (do_segments)
5140 {
5141 printf (" %-14.14s ", get_segment_type (filedata, segment->p_type));
5142
5143 if (is_32bit_elf)
5144 {
5145 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5146 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
5147 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
5148 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
5149 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
5150 printf ("%c%c%c ",
5151 (segment->p_flags & PF_R ? 'R' : ' '),
5152 (segment->p_flags & PF_W ? 'W' : ' '),
5153 (segment->p_flags & PF_X ? 'E' : ' '));
5154 printf ("%#lx", (unsigned long) segment->p_align);
5155 }
5156 else if (do_wide)
5157 {
5158 if ((unsigned long) segment->p_offset == segment->p_offset)
5159 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5160 else
5161 {
5162 print_vma (segment->p_offset, FULL_HEX);
5163 putchar (' ');
5164 }
5165
5166 print_vma (segment->p_vaddr, FULL_HEX);
5167 putchar (' ');
5168 print_vma (segment->p_paddr, FULL_HEX);
5169 putchar (' ');
5170
5171 if ((unsigned long) segment->p_filesz == segment->p_filesz)
5172 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
5173 else
5174 {
5175 print_vma (segment->p_filesz, FULL_HEX);
5176 putchar (' ');
5177 }
5178
5179 if ((unsigned long) segment->p_memsz == segment->p_memsz)
5180 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
5181 else
5182 {
5183 print_vma (segment->p_memsz, FULL_HEX);
5184 }
5185
5186 printf (" %c%c%c ",
5187 (segment->p_flags & PF_R ? 'R' : ' '),
5188 (segment->p_flags & PF_W ? 'W' : ' '),
5189 (segment->p_flags & PF_X ? 'E' : ' '));
5190
5191 if ((unsigned long) segment->p_align == segment->p_align)
5192 printf ("%#lx", (unsigned long) segment->p_align);
5193 else
5194 {
5195 print_vma (segment->p_align, PREFIX_HEX);
5196 }
5197 }
5198 else
5199 {
5200 print_vma (segment->p_offset, FULL_HEX);
5201 putchar (' ');
5202 print_vma (segment->p_vaddr, FULL_HEX);
5203 putchar (' ');
5204 print_vma (segment->p_paddr, FULL_HEX);
5205 printf ("\n ");
5206 print_vma (segment->p_filesz, FULL_HEX);
5207 putchar (' ');
5208 print_vma (segment->p_memsz, FULL_HEX);
5209 printf (" %c%c%c ",
5210 (segment->p_flags & PF_R ? 'R' : ' '),
5211 (segment->p_flags & PF_W ? 'W' : ' '),
5212 (segment->p_flags & PF_X ? 'E' : ' '));
5213 print_vma (segment->p_align, PREFIX_HEX);
5214 }
5215
5216 putc ('\n', stdout);
5217 }
5218
5219 switch (segment->p_type)
5220 {
5221 case PT_LOAD:
5222#if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5223 required by the ELF standard, several programs, including the Linux
5224 kernel, make use of non-ordered segments. */
5225 if (previous_load
5226 && previous_load->p_vaddr > segment->p_vaddr)
5227 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5228#endif
5229 if (segment->p_memsz < segment->p_filesz)
5230 error (_("the segment's file size is larger than its memory size\n"));
5231 previous_load = segment;
5232 break;
5233
5234 case PT_PHDR:
5235 /* PR 20815 - Verify that the program header is loaded into memory. */
5236 if (i > 0 && previous_load != NULL)
5237 error (_("the PHDR segment must occur before any LOAD segment\n"));
5238 if (filedata->file_header.e_machine != EM_PARISC)
5239 {
5240 unsigned int j;
5241
5242 for (j = 1; j < filedata->file_header.e_phnum; j++)
5243 if (filedata->program_headers[j].p_vaddr <= segment->p_vaddr
5244 && (filedata->program_headers[j].p_vaddr
5245 + filedata->program_headers[j].p_memsz)
5246 >= (segment->p_vaddr + segment->p_filesz))
5247 break;
5248 if (j == filedata->file_header.e_phnum)
5249 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5250 }
5251 break;
5252
5253 case PT_DYNAMIC:
5254 if (dynamic_addr)
5255 error (_("more than one dynamic segment\n"));
5256
5257 /* By default, assume that the .dynamic section is the first
5258 section in the DYNAMIC segment. */
5259 dynamic_addr = segment->p_offset;
5260 dynamic_size = segment->p_filesz;
5261
5262 /* Try to locate the .dynamic section. If there is
5263 a section header table, we can easily locate it. */
5264 if (filedata->section_headers != NULL)
5265 {
5266 Elf_Internal_Shdr * sec;
5267
5268 sec = find_section (filedata, ".dynamic");
5269 if (sec == NULL || sec->sh_size == 0)
5270 {
5271 /* A corresponding .dynamic section is expected, but on
5272 IA-64/OpenVMS it is OK for it to be missing. */
5273 if (!is_ia64_vms (filedata))
5274 error (_("no .dynamic section in the dynamic segment\n"));
5275 break;
5276 }
5277
5278 if (sec->sh_type == SHT_NOBITS)
5279 {
5280 dynamic_size = 0;
5281 break;
5282 }
5283
5284 dynamic_addr = sec->sh_offset;
5285 dynamic_size = sec->sh_size;
5286
5287 if (dynamic_addr < segment->p_offset
5288 || dynamic_addr > segment->p_offset + segment->p_filesz)
5289 warn (_("the .dynamic section is not contained"
5290 " within the dynamic segment\n"));
5291 else if (dynamic_addr > segment->p_offset)
5292 warn (_("the .dynamic section is not the first section"
5293 " in the dynamic segment.\n"));
5294 }
5295
5296 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5297 segment. Check this after matching against the section headers
5298 so we don't warn on debuginfo file (which have NOBITS .dynamic
5299 sections). */
5300 if (dynamic_addr > filedata->file_size
5301 || dynamic_size > filedata->file_size - dynamic_addr)
5302 {
5303 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5304 dynamic_addr = dynamic_size = 0;
5305 }
5306 break;
5307
5308 case PT_INTERP:
5309 if (fseek (filedata->handle, archive_file_offset + (long) segment->p_offset,
5310 SEEK_SET))
5311 error (_("Unable to find program interpreter name\n"));
5312 else
5313 {
5314 char fmt [32];
5315 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5316
5317 if (ret >= (int) sizeof (fmt) || ret < 0)
5318 error (_("Internal error: failed to create format string to display program interpreter\n"));
5319
5320 program_interpreter[0] = 0;
5321 if (fscanf (filedata->handle, fmt, program_interpreter) <= 0)
5322 error (_("Unable to read program interpreter name\n"));
5323
5324 if (do_segments)
5325 printf (_(" [Requesting program interpreter: %s]\n"),
5326 program_interpreter);
5327 }
5328 break;
5329 }
5330 }
5331
5332 if (do_segments
5333 && filedata->section_headers != NULL
5334 && filedata->string_table != NULL)
5335 {
5336 printf (_("\n Section to Segment mapping:\n"));
5337 printf (_(" Segment Sections...\n"));
5338
5339 for (i = 0; i < filedata->file_header.e_phnum; i++)
5340 {
5341 unsigned int j;
5342 Elf_Internal_Shdr * section;
5343
5344 segment = filedata->program_headers + i;
5345 section = filedata->section_headers + 1;
5346
5347 printf (" %2.2d ", i);
5348
5349 for (j = 1; j < filedata->file_header.e_shnum; j++, section++)
5350 {
5351 if (!ELF_TBSS_SPECIAL (section, segment)
5352 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5353 printf ("%s ", printable_section_name (filedata, section));
5354 }
5355
5356 putc ('\n',stdout);
5357 }
5358 }
5359
5360 return TRUE;
5361}
5362
5363
5364/* Find the file offset corresponding to VMA by using the program headers. */
5365
5366static long
5367offset_from_vma (Filedata * filedata, bfd_vma vma, bfd_size_type size)
5368{
5369 Elf_Internal_Phdr * seg;
5370
5371 if (! get_program_headers (filedata))
5372 {
5373 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5374 return (long) vma;
5375 }
5376
5377 for (seg = filedata->program_headers;
5378 seg < filedata->program_headers + filedata->file_header.e_phnum;
5379 ++seg)
5380 {
5381 if (seg->p_type != PT_LOAD)
5382 continue;
5383
5384 if (vma >= (seg->p_vaddr & -seg->p_align)
5385 && vma + size <= seg->p_vaddr + seg->p_filesz)
5386 return vma - seg->p_vaddr + seg->p_offset;
5387 }
5388
5389 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5390 (unsigned long) vma);
5391 return (long) vma;
5392}
5393
5394
5395/* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5396 If PROBE is true, this is just a probe and we do not generate any error
5397 messages if the load fails. */
5398
5399static bfd_boolean
5400get_32bit_section_headers (Filedata * filedata, bfd_boolean probe)
5401{
5402 Elf32_External_Shdr * shdrs;
5403 Elf_Internal_Shdr * internal;
5404 unsigned int i;
5405 unsigned int size = filedata->file_header.e_shentsize;
5406 unsigned int num = probe ? 1 : filedata->file_header.e_shnum;
5407
5408 /* PR binutils/17531: Cope with unexpected section header sizes. */
5409 if (size == 0 || num == 0)
5410 return FALSE;
5411 if (size < sizeof * shdrs)
5412 {
5413 if (! probe)
5414 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5415 return FALSE;
5416 }
5417 if (!probe && size > sizeof * shdrs)
5418 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5419
5420 shdrs = (Elf32_External_Shdr *) get_data (NULL, filedata, filedata->file_header.e_shoff,
5421 size, num,
5422 probe ? NULL : _("section headers"));
5423 if (shdrs == NULL)
5424 return FALSE;
5425
5426 free (filedata->section_headers);
5427 filedata->section_headers = (Elf_Internal_Shdr *)
5428 cmalloc (num, sizeof (Elf_Internal_Shdr));
5429 if (filedata->section_headers == NULL)
5430 {
5431 if (!probe)
5432 error (_("Out of memory reading %u section headers\n"), num);
5433 free (shdrs);
5434 return FALSE;
5435 }
5436
5437 for (i = 0, internal = filedata->section_headers;
5438 i < num;
5439 i++, internal++)
5440 {
5441 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5442 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5443 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5444 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5445 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5446 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5447 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5448 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5449 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5450 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
5451 if (!probe && internal->sh_link > num)
5452 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5453 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5454 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5455 }
5456
5457 free (shdrs);
5458 return TRUE;
5459}
5460
5461/* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5462
5463static bfd_boolean
5464get_64bit_section_headers (Filedata * filedata, bfd_boolean probe)
5465{
5466 Elf64_External_Shdr * shdrs;
5467 Elf_Internal_Shdr * internal;
5468 unsigned int i;
5469 unsigned int size = filedata->file_header.e_shentsize;
5470 unsigned int num = probe ? 1 : filedata->file_header.e_shnum;
5471
5472 /* PR binutils/17531: Cope with unexpected section header sizes. */
5473 if (size == 0 || num == 0)
5474 return FALSE;
5475
5476 if (size < sizeof * shdrs)
5477 {
5478 if (! probe)
5479 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5480 return FALSE;
5481 }
5482
5483 if (! probe && size > sizeof * shdrs)
5484 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5485
5486 shdrs = (Elf64_External_Shdr *) get_data (NULL, filedata,
5487 filedata->file_header.e_shoff,
5488 size, num,
5489 probe ? NULL : _("section headers"));
5490 if (shdrs == NULL)
5491 return FALSE;
5492
5493 free (filedata->section_headers);
5494 filedata->section_headers = (Elf_Internal_Shdr *)
5495 cmalloc (num, sizeof (Elf_Internal_Shdr));
5496 if (filedata->section_headers == NULL)
5497 {
5498 if (! probe)
5499 error (_("Out of memory reading %u section headers\n"), num);
5500 free (shdrs);
5501 return FALSE;
5502 }
5503
5504 for (i = 0, internal = filedata->section_headers;
5505 i < num;
5506 i++, internal++)
5507 {
5508 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5509 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5510 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5511 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5512 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5513 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
5514 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5515 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5516 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5517 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5518 if (!probe && internal->sh_link > num)
5519 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5520 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5521 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5522 }
5523
5524 free (shdrs);
5525 return TRUE;
5526}
5527
5528static Elf_Internal_Sym *
5529get_32bit_elf_symbols (Filedata * filedata,
5530 Elf_Internal_Shdr * section,
5531 unsigned long * num_syms_return)
5532{
5533 unsigned long number = 0;
5534 Elf32_External_Sym * esyms = NULL;
5535 Elf_External_Sym_Shndx * shndx = NULL;
5536 Elf_Internal_Sym * isyms = NULL;
5537 Elf_Internal_Sym * psym;
5538 unsigned int j;
5539 elf_section_list * entry;
5540
5541 if (section->sh_size == 0)
5542 {
5543 if (num_syms_return != NULL)
5544 * num_syms_return = 0;
5545 return NULL;
5546 }
5547
5548 /* Run some sanity checks first. */
5549 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5550 {
5551 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5552 printable_section_name (filedata, section),
5553 (unsigned long) section->sh_entsize);
5554 goto exit_point;
5555 }
5556
5557 if (section->sh_size > filedata->file_size)
5558 {
5559 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5560 printable_section_name (filedata, section),
5561 (unsigned long) section->sh_size);
5562 goto exit_point;
5563 }
5564
5565 number = section->sh_size / section->sh_entsize;
5566
5567 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5568 {
5569 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5570 (unsigned long) section->sh_size,
5571 printable_section_name (filedata, section),
5572 (unsigned long) section->sh_entsize);
5573 goto exit_point;
5574 }
5575
5576 esyms = (Elf32_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5577 section->sh_size, _("symbols"));
5578 if (esyms == NULL)
5579 goto exit_point;
5580
5581 shndx = NULL;
5582 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5583 {
5584 if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5585 continue;
5586
5587 if (shndx != NULL)
5588 {
5589 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5590 free (shndx);
5591 }
5592
5593 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5594 entry->hdr->sh_offset,
5595 1, entry->hdr->sh_size,
5596 _("symbol table section indices"));
5597 if (shndx == NULL)
5598 goto exit_point;
5599
5600 /* PR17531: file: heap-buffer-overflow */
5601 if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5602 {
5603 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5604 printable_section_name (filedata, entry->hdr),
5605 (unsigned long) entry->hdr->sh_size,
5606 (unsigned long) section->sh_size);
5607 goto exit_point;
5608 }
5609 }
5610
5611 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5612
5613 if (isyms == NULL)
5614 {
5615 error (_("Out of memory reading %lu symbols\n"),
5616 (unsigned long) number);
5617 goto exit_point;
5618 }
5619
5620 for (j = 0, psym = isyms; j < number; j++, psym++)
5621 {
5622 psym->st_name = BYTE_GET (esyms[j].st_name);
5623 psym->st_value = BYTE_GET (esyms[j].st_value);
5624 psym->st_size = BYTE_GET (esyms[j].st_size);
5625 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5626 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5627 psym->st_shndx
5628 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5629 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5630 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5631 psym->st_info = BYTE_GET (esyms[j].st_info);
5632 psym->st_other = BYTE_GET (esyms[j].st_other);
5633 }
5634
5635 exit_point:
5636 free (shndx);
5637 free (esyms);
5638
5639 if (num_syms_return != NULL)
5640 * num_syms_return = isyms == NULL ? 0 : number;
5641
5642 return isyms;
5643}
5644
5645static Elf_Internal_Sym *
5646get_64bit_elf_symbols (Filedata * filedata,
5647 Elf_Internal_Shdr * section,
5648 unsigned long * num_syms_return)
5649{
5650 unsigned long number = 0;
5651 Elf64_External_Sym * esyms = NULL;
5652 Elf_External_Sym_Shndx * shndx = NULL;
5653 Elf_Internal_Sym * isyms = NULL;
5654 Elf_Internal_Sym * psym;
5655 unsigned int j;
5656 elf_section_list * entry;
5657
5658 if (section->sh_size == 0)
5659 {
5660 if (num_syms_return != NULL)
5661 * num_syms_return = 0;
5662 return NULL;
5663 }
5664
5665 /* Run some sanity checks first. */
5666 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5667 {
5668 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5669 printable_section_name (filedata, section),
5670 (unsigned long) section->sh_entsize);
5671 goto exit_point;
5672 }
5673
5674 if (section->sh_size > filedata->file_size)
5675 {
5676 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5677 printable_section_name (filedata, section),
5678 (unsigned long) section->sh_size);
5679 goto exit_point;
5680 }
5681
5682 number = section->sh_size / section->sh_entsize;
5683
5684 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5685 {
5686 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5687 (unsigned long) section->sh_size,
5688 printable_section_name (filedata, section),
5689 (unsigned long) section->sh_entsize);
5690 goto exit_point;
5691 }
5692
5693 esyms = (Elf64_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5694 section->sh_size, _("symbols"));
5695 if (!esyms)
5696 goto exit_point;
5697
5698 shndx = NULL;
5699 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5700 {
5701 if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5702 continue;
5703
5704 if (shndx != NULL)
5705 {
5706 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5707 free (shndx);
5708 }
5709
5710 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5711 entry->hdr->sh_offset,
5712 1, entry->hdr->sh_size,
5713 _("symbol table section indices"));
5714 if (shndx == NULL)
5715 goto exit_point;
5716
5717 /* PR17531: file: heap-buffer-overflow */
5718 if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5719 {
5720 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5721 printable_section_name (filedata, entry->hdr),
5722 (unsigned long) entry->hdr->sh_size,
5723 (unsigned long) section->sh_size);
5724 goto exit_point;
5725 }
5726 }
5727
5728 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5729
5730 if (isyms == NULL)
5731 {
5732 error (_("Out of memory reading %lu symbols\n"),
5733 (unsigned long) number);
5734 goto exit_point;
5735 }
5736
5737 for (j = 0, psym = isyms; j < number; j++, psym++)
5738 {
5739 psym->st_name = BYTE_GET (esyms[j].st_name);
5740 psym->st_info = BYTE_GET (esyms[j].st_info);
5741 psym->st_other = BYTE_GET (esyms[j].st_other);
5742 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5743
5744 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5745 psym->st_shndx
5746 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5747 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5748 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5749
5750 psym->st_value = BYTE_GET (esyms[j].st_value);
5751 psym->st_size = BYTE_GET (esyms[j].st_size);
5752 }
5753
5754 exit_point:
5755 free (shndx);
5756 free (esyms);
5757
5758 if (num_syms_return != NULL)
5759 * num_syms_return = isyms == NULL ? 0 : number;
5760
5761 return isyms;
5762}
5763
5764static const char *
5765get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
5766{
5767 static char buff[1024];
5768 char * p = buff;
5769 unsigned int field_size = is_32bit_elf ? 8 : 16;
5770 signed int sindex;
5771 unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5772 bfd_vma os_flags = 0;
5773 bfd_vma proc_flags = 0;
5774 bfd_vma unknown_flags = 0;
5775 static const struct
5776 {
5777 const char * str;
5778 unsigned int len;
5779 }
5780 flags [] =
5781 {
5782 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5783 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5784 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5785 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5786 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5787 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5788 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5789 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5790 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5791 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5792 /* IA-64 specific. */
5793 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5794 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5795 /* IA-64 OpenVMS specific. */
5796 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5797 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5798 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5799 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5800 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5801 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5802 /* Generic. */
5803 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5804 /* SPARC specific. */
5805 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5806 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5807 /* ARM specific. */
5808 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5809 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5810 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5811 /* GNU specific. */
5812 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5813 /* VLE specific. */
5814 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5815 };
5816
5817 if (do_section_details)
5818 {
5819 sprintf (buff, "[%*.*lx]: ",
5820 field_size, field_size, (unsigned long) sh_flags);
5821 p += field_size + 4;
5822 }
5823
5824 while (sh_flags)
5825 {
5826 bfd_vma flag;
5827
5828 flag = sh_flags & - sh_flags;
5829 sh_flags &= ~ flag;
5830
5831 if (do_section_details)
5832 {
5833 switch (flag)
5834 {
5835 case SHF_WRITE: sindex = 0; break;
5836 case SHF_ALLOC: sindex = 1; break;
5837 case SHF_EXECINSTR: sindex = 2; break;
5838 case SHF_MERGE: sindex = 3; break;
5839 case SHF_STRINGS: sindex = 4; break;
5840 case SHF_INFO_LINK: sindex = 5; break;
5841 case SHF_LINK_ORDER: sindex = 6; break;
5842 case SHF_OS_NONCONFORMING: sindex = 7; break;
5843 case SHF_GROUP: sindex = 8; break;
5844 case SHF_TLS: sindex = 9; break;
5845 case SHF_EXCLUDE: sindex = 18; break;
5846 case SHF_COMPRESSED: sindex = 20; break;
5847 case SHF_GNU_MBIND: sindex = 24; break;
5848
5849 default:
5850 sindex = -1;
5851 switch (filedata->file_header.e_machine)
5852 {
5853 case EM_IA_64:
5854 if (flag == SHF_IA_64_SHORT)
5855 sindex = 10;
5856 else if (flag == SHF_IA_64_NORECOV)
5857 sindex = 11;
5858#ifdef BFD64
5859 else if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5860 switch (flag)
5861 {
5862 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5863 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5864 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5865 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5866 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5867 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
5868 default: break;
5869 }
5870#endif
5871 break;
5872
5873 case EM_386:
5874 case EM_IAMCU:
5875 case EM_X86_64:
5876 case EM_L1OM:
5877 case EM_K1OM:
5878 case EM_OLD_SPARCV9:
5879 case EM_SPARC32PLUS:
5880 case EM_SPARCV9:
5881 case EM_SPARC:
5882 if (flag == SHF_ORDERED)
5883 sindex = 19;
5884 break;
5885
5886 case EM_ARM:
5887 switch (flag)
5888 {
5889 case SHF_ENTRYSECT: sindex = 21; break;
5890 case SHF_ARM_PURECODE: sindex = 22; break;
5891 case SHF_COMDEF: sindex = 23; break;
5892 default: break;
5893 }
5894 break;
5895 case EM_PPC:
5896 if (flag == SHF_PPC_VLE)
5897 sindex = 25;
5898 break;
5899
5900 default:
5901 break;
5902 }
5903 }
5904
5905 if (sindex != -1)
5906 {
5907 if (p != buff + field_size + 4)
5908 {
5909 if (size < (10 + 2))
5910 {
5911 warn (_("Internal error: not enough buffer room for section flag info"));
5912 return _("<unknown>");
5913 }
5914 size -= 2;
5915 *p++ = ',';
5916 *p++ = ' ';
5917 }
5918
5919 size -= flags [sindex].len;
5920 p = stpcpy (p, flags [sindex].str);
5921 }
5922 else if (flag & SHF_MASKOS)
5923 os_flags |= flag;
5924 else if (flag & SHF_MASKPROC)
5925 proc_flags |= flag;
5926 else
5927 unknown_flags |= flag;
5928 }
5929 else
5930 {
5931 switch (flag)
5932 {
5933 case SHF_WRITE: *p = 'W'; break;
5934 case SHF_ALLOC: *p = 'A'; break;
5935 case SHF_EXECINSTR: *p = 'X'; break;
5936 case SHF_MERGE: *p = 'M'; break;
5937 case SHF_STRINGS: *p = 'S'; break;
5938 case SHF_INFO_LINK: *p = 'I'; break;
5939 case SHF_LINK_ORDER: *p = 'L'; break;
5940 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5941 case SHF_GROUP: *p = 'G'; break;
5942 case SHF_TLS: *p = 'T'; break;
5943 case SHF_EXCLUDE: *p = 'E'; break;
5944 case SHF_COMPRESSED: *p = 'C'; break;
5945 case SHF_GNU_MBIND: *p = 'D'; break;
5946
5947 default:
5948 if ((filedata->file_header.e_machine == EM_X86_64
5949 || filedata->file_header.e_machine == EM_L1OM
5950 || filedata->file_header.e_machine == EM_K1OM)
5951 && flag == SHF_X86_64_LARGE)
5952 *p = 'l';
5953 else if (filedata->file_header.e_machine == EM_ARM
5954 && flag == SHF_ARM_PURECODE)
5955 *p = 'y';
5956 else if (filedata->file_header.e_machine == EM_PPC
5957 && flag == SHF_PPC_VLE)
5958 *p = 'v';
5959 else if (flag & SHF_MASKOS)
5960 {
5961 *p = 'o';
5962 sh_flags &= ~ SHF_MASKOS;
5963 }
5964 else if (flag & SHF_MASKPROC)
5965 {
5966 *p = 'p';
5967 sh_flags &= ~ SHF_MASKPROC;
5968 }
5969 else
5970 *p = 'x';
5971 break;
5972 }
5973 p++;
5974 }
5975 }
5976
5977 if (do_section_details)
5978 {
5979 if (os_flags)
5980 {
5981 size -= 5 + field_size;
5982 if (p != buff + field_size + 4)
5983 {
5984 if (size < (2 + 1))
5985 {
5986 warn (_("Internal error: not enough buffer room for section flag info"));
5987 return _("<unknown>");
5988 }
5989 size -= 2;
5990 *p++ = ',';
5991 *p++ = ' ';
5992 }
5993 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5994 (unsigned long) os_flags);
5995 p += 5 + field_size;
5996 }
5997 if (proc_flags)
5998 {
5999 size -= 7 + field_size;
6000 if (p != buff + field_size + 4)
6001 {
6002 if (size < (2 + 1))
6003 {
6004 warn (_("Internal error: not enough buffer room for section flag info"));
6005 return _("<unknown>");
6006 }
6007 size -= 2;
6008 *p++ = ',';
6009 *p++ = ' ';
6010 }
6011 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
6012 (unsigned long) proc_flags);
6013 p += 7 + field_size;
6014 }
6015 if (unknown_flags)
6016 {
6017 size -= 10 + field_size;
6018 if (p != buff + field_size + 4)
6019 {
6020 if (size < (2 + 1))
6021 {
6022 warn (_("Internal error: not enough buffer room for section flag info"));
6023 return _("<unknown>");
6024 }
6025 size -= 2;
6026 *p++ = ',';
6027 *p++ = ' ';
6028 }
6029 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
6030 (unsigned long) unknown_flags);
6031 p += 10 + field_size;
6032 }
6033 }
6034
6035 *p = '\0';
6036 return buff;
6037}
6038
6039static unsigned int
6040get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
6041{
6042 if (is_32bit_elf)
6043 {
6044 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
6045
6046 if (size < sizeof (* echdr))
6047 {
6048 error (_("Compressed section is too small even for a compression header\n"));
6049 return 0;
6050 }
6051
6052 chdr->ch_type = BYTE_GET (echdr->ch_type);
6053 chdr->ch_size = BYTE_GET (echdr->ch_size);
6054 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
6055 return sizeof (*echdr);
6056 }
6057 else
6058 {
6059 Elf64_External_Chdr *echdr = (Elf64_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}
6073
6074static bfd_boolean
6075process_section_headers (Filedata * filedata)
6076{
6077 Elf_Internal_Shdr * section;
6078 unsigned int i;
6079
6080 filedata->section_headers = NULL;
6081
6082 if (filedata->file_header.e_shnum == 0)
6083 {
6084 /* PR binutils/12467. */
6085 if (filedata->file_header.e_shoff != 0)
6086 {
6087 warn (_("possibly corrupt ELF file header - it has a non-zero"
6088 " section header offset, but no section headers\n"));
6089 return FALSE;
6090 }
6091 else if (do_sections)
6092 printf (_("\nThere are no sections in this file.\n"));
6093
6094 return TRUE;
6095 }
6096
6097 if (do_sections && !do_header)
6098 printf (ngettext ("There is %d section header, "
6099 "starting at offset 0x%lx:\n",
6100 "There are %d section headers, "
6101 "starting at offset 0x%lx:\n",
6102 filedata->file_header.e_shnum),
6103 filedata->file_header.e_shnum,
6104 (unsigned long) filedata->file_header.e_shoff);
6105
6106 if (is_32bit_elf)
6107 {
6108 if (! get_32bit_section_headers (filedata, FALSE))
6109 return FALSE;
6110 }
6111 else
6112 {
6113 if (! get_64bit_section_headers (filedata, FALSE))
6114 return FALSE;
6115 }
6116
6117 /* Read in the string table, so that we have names to display. */
6118 if (filedata->file_header.e_shstrndx != SHN_UNDEF
6119 && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
6120 {
6121 section = filedata->section_headers + filedata->file_header.e_shstrndx;
6122
6123 if (section->sh_size != 0)
6124 {
6125 filedata->string_table = (char *) get_data (NULL, filedata, section->sh_offset,
6126 1, section->sh_size,
6127 _("string table"));
6128
6129 filedata->string_table_length = filedata->string_table != NULL ? section->sh_size : 0;
6130 }
6131 }
6132
6133 /* Scan the sections for the dynamic symbol table
6134 and dynamic string table and debug sections. */
6135 dynamic_symbols = NULL;
6136 dynamic_strings = NULL;
6137 dynamic_syminfo = NULL;
6138 symtab_shndx_list = NULL;
6139
6140 eh_addr_size = is_32bit_elf ? 4 : 8;
6141 switch (filedata->file_header.e_machine)
6142 {
6143 case EM_MIPS:
6144 case EM_MIPS_RS3_LE:
6145 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6146 FDE addresses. However, the ABI also has a semi-official ILP32
6147 variant for which the normal FDE address size rules apply.
6148
6149 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6150 section, where XX is the size of longs in bits. Unfortunately,
6151 earlier compilers provided no way of distinguishing ILP32 objects
6152 from LP64 objects, so if there's any doubt, we should assume that
6153 the official LP64 form is being used. */
6154 if ((filedata->file_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
6155 && find_section (filedata, ".gcc_compiled_long32") == NULL)
6156 eh_addr_size = 8;
6157 break;
6158
6159 case EM_H8_300:
6160 case EM_H8_300H:
6161 switch (filedata->file_header.e_flags & EF_H8_MACH)
6162 {
6163 case E_H8_MACH_H8300:
6164 case E_H8_MACH_H8300HN:
6165 case E_H8_MACH_H8300SN:
6166 case E_H8_MACH_H8300SXN:
6167 eh_addr_size = 2;
6168 break;
6169 case E_H8_MACH_H8300H:
6170 case E_H8_MACH_H8300S:
6171 case E_H8_MACH_H8300SX:
6172 eh_addr_size = 4;
6173 break;
6174 }
6175 break;
6176
6177 case EM_M32C_OLD:
6178 case EM_M32C:
6179 switch (filedata->file_header.e_flags & EF_M32C_CPU_MASK)
6180 {
6181 case EF_M32C_CPU_M16C:
6182 eh_addr_size = 2;
6183 break;
6184 }
6185 break;
6186 }
6187
6188#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6189 do \
6190 { \
6191 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6192 if (section->sh_entsize != expected_entsize) \
6193 { \
6194 char buf[40]; \
6195 sprintf_vma (buf, section->sh_entsize); \
6196 /* Note: coded this way so that there is a single string for \
6197 translation. */ \
6198 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6199 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6200 (unsigned) expected_entsize); \
6201 section->sh_entsize = expected_entsize; \
6202 } \
6203 } \
6204 while (0)
6205
6206#define CHECK_ENTSIZE(section, i, type) \
6207 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6208 sizeof (Elf64_External_##type))
6209
6210 for (i = 0, section = filedata->section_headers;
6211 i < filedata->file_header.e_shnum;
6212 i++, section++)
6213 {
6214 char * name = SECTION_NAME (section);
6215
6216 if (section->sh_type == SHT_DYNSYM)
6217 {
6218 if (dynamic_symbols != NULL)
6219 {
6220 error (_("File contains multiple dynamic symbol tables\n"));
6221 continue;
6222 }
6223
6224 CHECK_ENTSIZE (section, i, Sym);
6225 dynamic_symbols = GET_ELF_SYMBOLS (filedata, section, & num_dynamic_syms);
6226 }
6227 else if (section->sh_type == SHT_STRTAB
6228 && streq (name, ".dynstr"))
6229 {
6230 if (dynamic_strings != NULL)
6231 {
6232 error (_("File contains multiple dynamic string tables\n"));
6233 continue;
6234 }
6235
6236 dynamic_strings = (char *) get_data (NULL, filedata, section->sh_offset,
6237 1, section->sh_size,
6238 _("dynamic strings"));
6239 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
6240 }
6241 else if (section->sh_type == SHT_SYMTAB_SHNDX)
6242 {
6243 elf_section_list * entry = xmalloc (sizeof * entry);
6244
6245 entry->hdr = section;
6246 entry->next = symtab_shndx_list;
6247 symtab_shndx_list = entry;
6248 }
6249 else if (section->sh_type == SHT_SYMTAB)
6250 CHECK_ENTSIZE (section, i, Sym);
6251 else if (section->sh_type == SHT_GROUP)
6252 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6253 else if (section->sh_type == SHT_REL)
6254 CHECK_ENTSIZE (section, i, Rel);
6255 else if (section->sh_type == SHT_RELA)
6256 CHECK_ENTSIZE (section, i, Rela);
6257 else if ((do_debugging || do_debug_info || do_debug_abbrevs
6258 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
6259 || do_debug_aranges || do_debug_frames || do_debug_macinfo
6260 || do_debug_str || do_debug_loc || do_debug_ranges
6261 || do_debug_addr || do_debug_cu_index || do_debug_links)
6262 && (const_strneq (name, ".debug_")
6263 || const_strneq (name, ".zdebug_")))
6264 {
6265 if (name[1] == 'z')
6266 name += sizeof (".zdebug_") - 1;
6267 else
6268 name += sizeof (".debug_") - 1;
6269
6270 if (do_debugging
6271 || (do_debug_info && const_strneq (name, "info"))
6272 || (do_debug_info && const_strneq (name, "types"))
6273 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
6274 || (do_debug_lines && strcmp (name, "line") == 0)
6275 || (do_debug_lines && const_strneq (name, "line."))
6276 || (do_debug_pubnames && const_strneq (name, "pubnames"))
6277 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6278 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6279 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6280 || (do_debug_aranges && const_strneq (name, "aranges"))
6281 || (do_debug_ranges && const_strneq (name, "ranges"))
6282 || (do_debug_ranges && const_strneq (name, "rnglists"))
6283 || (do_debug_frames && const_strneq (name, "frame"))
6284 || (do_debug_macinfo && const_strneq (name, "macinfo"))
6285 || (do_debug_macinfo && const_strneq (name, "macro"))
6286 || (do_debug_str && const_strneq (name, "str"))
6287 || (do_debug_loc && const_strneq (name, "loc"))
6288 || (do_debug_loc && const_strneq (name, "loclists"))
6289 || (do_debug_addr && const_strneq (name, "addr"))
6290 || (do_debug_cu_index && const_strneq (name, "cu_index"))
6291 || (do_debug_cu_index && const_strneq (name, "tu_index"))
6292 )
6293 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6294 }
6295 /* Linkonce section to be combined with .debug_info at link time. */
6296 else if ((do_debugging || do_debug_info)
6297 && const_strneq (name, ".gnu.linkonce.wi."))
6298 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6299 else if (do_debug_frames && streq (name, ".eh_frame"))
6300 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6301 else if (do_gdb_index && (streq (name, ".gdb_index")
6302 || streq (name, ".debug_names")))
6303 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6304 /* Trace sections for Itanium VMS. */
6305 else if ((do_debugging || do_trace_info || do_trace_abbrevs
6306 || do_trace_aranges)
6307 && const_strneq (name, ".trace_"))
6308 {
6309 name += sizeof (".trace_") - 1;
6310
6311 if (do_debugging
6312 || (do_trace_info && streq (name, "info"))
6313 || (do_trace_abbrevs && streq (name, "abbrev"))
6314 || (do_trace_aranges && streq (name, "aranges"))
6315 )
6316 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6317 }
6318 else if ((do_debugging || do_debug_links)
6319 && (const_strneq (name, ".gnu_debuglink")
6320 || const_strneq (name, ".gnu_debugaltlink")))
6321 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6322 }
6323
6324 if (! do_sections)
6325 return TRUE;
6326
6327 if (filedata->file_header.e_shnum > 1)
6328 printf (_("\nSection Headers:\n"));
6329 else
6330 printf (_("\nSection Header:\n"));
6331
6332 if (is_32bit_elf)
6333 {
6334 if (do_section_details)
6335 {
6336 printf (_(" [Nr] Name\n"));
6337 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6338 }
6339 else
6340 printf
6341 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6342 }
6343 else if (do_wide)
6344 {
6345 if (do_section_details)
6346 {
6347 printf (_(" [Nr] Name\n"));
6348 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6349 }
6350 else
6351 printf
6352 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6353 }
6354 else
6355 {
6356 if (do_section_details)
6357 {
6358 printf (_(" [Nr] Name\n"));
6359 printf (_(" Type Address Offset Link\n"));
6360 printf (_(" Size EntSize Info Align\n"));
6361 }
6362 else
6363 {
6364 printf (_(" [Nr] Name Type Address Offset\n"));
6365 printf (_(" Size EntSize Flags Link Info Align\n"));
6366 }
6367 }
6368
6369 if (do_section_details)
6370 printf (_(" Flags\n"));
6371
6372 for (i = 0, section = filedata->section_headers;
6373 i < filedata->file_header.e_shnum;
6374 i++, section++)
6375 {
6376 /* Run some sanity checks on the section header. */
6377
6378 /* Check the sh_link field. */
6379 switch (section->sh_type)
6380 {
6381 case SHT_REL:
6382 case SHT_RELA:
6383 if (section->sh_link == 0
6384 && (filedata->file_header.e_type == ET_EXEC
6385 || filedata->file_header.e_type == ET_DYN))
6386 /* A dynamic relocation section where all entries use a
6387 zero symbol index need not specify a symtab section. */
6388 break;
6389 /* Fall through. */
6390 case SHT_SYMTAB_SHNDX:
6391 case SHT_GROUP:
6392 case SHT_HASH:
6393 case SHT_GNU_HASH:
6394 case SHT_GNU_versym:
6395 if (section->sh_link == 0
6396 || section->sh_link >= filedata->file_header.e_shnum
6397 || (filedata->section_headers[section->sh_link].sh_type != SHT_SYMTAB
6398 && filedata->section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6399 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6400 i, section->sh_link);
6401 break;
6402
6403 case SHT_DYNAMIC:
6404 case SHT_SYMTAB:
6405 case SHT_DYNSYM:
6406 case SHT_GNU_verneed:
6407 case SHT_GNU_verdef:
6408 case SHT_GNU_LIBLIST:
6409 if (section->sh_link == 0
6410 || section->sh_link >= filedata->file_header.e_shnum
6411 || filedata->section_headers[section->sh_link].sh_type != SHT_STRTAB)
6412 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6413 i, section->sh_link);
6414 break;
6415
6416 case SHT_INIT_ARRAY:
6417 case SHT_FINI_ARRAY:
6418 case SHT_PREINIT_ARRAY:
6419 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6420 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6421 i, section->sh_link);
6422 break;
6423
6424 default:
6425 /* FIXME: Add support for target specific section types. */
6426#if 0 /* Currently we do not check other section types as there are too
6427 many special cases. Stab sections for example have a type
6428 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6429 section. */
6430 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6431 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6432 i, section->sh_link);
6433#endif
6434 break;
6435 }
6436
6437 /* Check the sh_info field. */
6438 switch (section->sh_type)
6439 {
6440 case SHT_REL:
6441 case SHT_RELA:
6442 if (section->sh_info == 0
6443 && (filedata->file_header.e_type == ET_EXEC
6444 || filedata->file_header.e_type == ET_DYN))
6445 /* Dynamic relocations apply to segments, so they do not
6446 need to specify the section they relocate. */
6447 break;
6448 if (section->sh_info == 0
6449 || section->sh_info >= filedata->file_header.e_shnum
6450 || (filedata->section_headers[section->sh_info].sh_type != SHT_PROGBITS
6451 && filedata->section_headers[section->sh_info].sh_type != SHT_NOBITS
6452 && filedata->section_headers[section->sh_info].sh_type != SHT_NOTE
6453 && filedata->section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6454 && filedata->section_headers[section->sh_info].sh_type != SHT_FINI_ARRAY
6455 && filedata->section_headers[section->sh_info].sh_type != SHT_PREINIT_ARRAY
6456 /* FIXME: Are other section types valid ? */
6457 && filedata->section_headers[section->sh_info].sh_type < SHT_LOOS))
6458 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6459 i, section->sh_info);
6460 break;
6461
6462 case SHT_DYNAMIC:
6463 case SHT_HASH:
6464 case SHT_SYMTAB_SHNDX:
6465 case SHT_INIT_ARRAY:
6466 case SHT_FINI_ARRAY:
6467 case SHT_PREINIT_ARRAY:
6468 if (section->sh_info != 0)
6469 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6470 i, section->sh_info);
6471 break;
6472
6473 case SHT_GROUP:
6474 case SHT_SYMTAB:
6475 case SHT_DYNSYM:
6476 /* A symbol index - we assume that it is valid. */
6477 break;
6478
6479 default:
6480 /* FIXME: Add support for target specific section types. */
6481 if (section->sh_type == SHT_NOBITS)
6482 /* NOBITS section headers with non-zero sh_info fields can be
6483 created when a binary is stripped of everything but its debug
6484 information. The stripped sections have their headers
6485 preserved but their types set to SHT_NOBITS. So do not check
6486 this type of section. */
6487 ;
6488 else if (section->sh_flags & SHF_INFO_LINK)
6489 {
6490 if (section->sh_info < 1 || section->sh_info >= filedata->file_header.e_shnum)
6491 warn (_("[%2u]: Expected link to another section in info field"), i);
6492 }
6493 else if (section->sh_type < SHT_LOOS
6494 && (section->sh_flags & SHF_GNU_MBIND) == 0
6495 && section->sh_info != 0)
6496 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6497 i, section->sh_info);
6498 break;
6499 }
6500
6501 /* Check the sh_size field. */
6502 if (section->sh_size > filedata->file_size
6503 && section->sh_type != SHT_NOBITS
6504 && section->sh_type != SHT_NULL
6505 && section->sh_type < SHT_LOOS)
6506 warn (_("Size of section %u is larger than the entire file!\n"), i);
6507
6508 printf (" [%2u] ", i);
6509 if (do_section_details)
6510 printf ("%s\n ", printable_section_name (filedata, section));
6511 else
6512 print_symbol (-17, SECTION_NAME (section));
6513
6514 printf (do_wide ? " %-15s " : " %-15.15s ",
6515 get_section_type_name (filedata, section->sh_type));
6516
6517 if (is_32bit_elf)
6518 {
6519 const char * link_too_big = NULL;
6520
6521 print_vma (section->sh_addr, LONG_HEX);
6522
6523 printf ( " %6.6lx %6.6lx %2.2lx",
6524 (unsigned long) section->sh_offset,
6525 (unsigned long) section->sh_size,
6526 (unsigned long) section->sh_entsize);
6527
6528 if (do_section_details)
6529 fputs (" ", stdout);
6530 else
6531 printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6532
6533 if (section->sh_link >= filedata->file_header.e_shnum)
6534 {
6535 link_too_big = "";
6536 /* The sh_link value is out of range. Normally this indicates
6537 an error but it can have special values in Solaris binaries. */
6538 switch (filedata->file_header.e_machine)
6539 {
6540 case EM_386:
6541 case EM_IAMCU:
6542 case EM_X86_64:
6543 case EM_L1OM:
6544 case EM_K1OM:
6545 case EM_OLD_SPARCV9:
6546 case EM_SPARC32PLUS:
6547 case EM_SPARCV9:
6548 case EM_SPARC:
6549 if (section->sh_link == (SHN_BEFORE & 0xffff))
6550 link_too_big = "BEFORE";
6551 else if (section->sh_link == (SHN_AFTER & 0xffff))
6552 link_too_big = "AFTER";
6553 break;
6554 default:
6555 break;
6556 }
6557 }
6558
6559 if (do_section_details)
6560 {
6561 if (link_too_big != NULL && * link_too_big)
6562 printf ("<%s> ", link_too_big);
6563 else
6564 printf ("%2u ", section->sh_link);
6565 printf ("%3u %2lu\n", section->sh_info,
6566 (unsigned long) section->sh_addralign);
6567 }
6568 else
6569 printf ("%2u %3u %2lu\n",
6570 section->sh_link,
6571 section->sh_info,
6572 (unsigned long) section->sh_addralign);
6573
6574 if (link_too_big && ! * link_too_big)
6575 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6576 i, section->sh_link);
6577 }
6578 else if (do_wide)
6579 {
6580 print_vma (section->sh_addr, LONG_HEX);
6581
6582 if ((long) section->sh_offset == section->sh_offset)
6583 printf (" %6.6lx", (unsigned long) section->sh_offset);
6584 else
6585 {
6586 putchar (' ');
6587 print_vma (section->sh_offset, LONG_HEX);
6588 }
6589
6590 if ((unsigned long) section->sh_size == section->sh_size)
6591 printf (" %6.6lx", (unsigned long) section->sh_size);
6592 else
6593 {
6594 putchar (' ');
6595 print_vma (section->sh_size, LONG_HEX);
6596 }
6597
6598 if ((unsigned long) section->sh_entsize == section->sh_entsize)
6599 printf (" %2.2lx", (unsigned long) section->sh_entsize);
6600 else
6601 {
6602 putchar (' ');
6603 print_vma (section->sh_entsize, LONG_HEX);
6604 }
6605
6606 if (do_section_details)
6607 fputs (" ", stdout);
6608 else
6609 printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6610
6611 printf ("%2u %3u ", section->sh_link, section->sh_info);
6612
6613 if ((unsigned long) section->sh_addralign == section->sh_addralign)
6614 printf ("%2lu\n", (unsigned long) section->sh_addralign);
6615 else
6616 {
6617 print_vma (section->sh_addralign, DEC);
6618 putchar ('\n');
6619 }
6620 }
6621 else if (do_section_details)
6622 {
6623 putchar (' ');
6624 print_vma (section->sh_addr, LONG_HEX);
6625 if ((long) section->sh_offset == section->sh_offset)
6626 printf (" %16.16lx", (unsigned long) section->sh_offset);
6627 else
6628 {
6629 printf (" ");
6630 print_vma (section->sh_offset, LONG_HEX);
6631 }
6632 printf (" %u\n ", section->sh_link);
6633 print_vma (section->sh_size, LONG_HEX);
6634 putchar (' ');
6635 print_vma (section->sh_entsize, LONG_HEX);
6636
6637 printf (" %-16u %lu\n",
6638 section->sh_info,
6639 (unsigned long) section->sh_addralign);
6640 }
6641 else
6642 {
6643 putchar (' ');
6644 print_vma (section->sh_addr, LONG_HEX);
6645 if ((long) section->sh_offset == section->sh_offset)
6646 printf (" %8.8lx", (unsigned long) section->sh_offset);
6647 else
6648 {
6649 printf (" ");
6650 print_vma (section->sh_offset, LONG_HEX);
6651 }
6652 printf ("\n ");
6653 print_vma (section->sh_size, LONG_HEX);
6654 printf (" ");
6655 print_vma (section->sh_entsize, LONG_HEX);
6656
6657 printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6658
6659 printf (" %2u %3u %lu\n",
6660 section->sh_link,
6661 section->sh_info,
6662 (unsigned long) section->sh_addralign);
6663 }
6664
6665 if (do_section_details)
6666 {
6667 printf (" %s\n", get_elf_section_flags (filedata, section->sh_flags));
6668 if ((section->sh_flags & SHF_COMPRESSED) != 0)
6669 {
6670 /* Minimum section size is 12 bytes for 32-bit compression
6671 header + 12 bytes for compressed data header. */
6672 unsigned char buf[24];
6673
6674 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6675 if (get_data (&buf, filedata, section->sh_offset, 1,
6676 sizeof (buf), _("compression header")))
6677 {
6678 Elf_Internal_Chdr chdr;
6679
6680 (void) get_compression_header (&chdr, buf, sizeof (buf));
6681
6682 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6683 printf (" ZLIB, ");
6684 else
6685 printf (_(" [<unknown>: 0x%x], "),
6686 chdr.ch_type);
6687 print_vma (chdr.ch_size, LONG_HEX);
6688 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6689 }
6690 }
6691 }
6692 }
6693
6694 if (!do_section_details)
6695 {
6696 /* The ordering of the letters shown here matches the ordering of the
6697 corresponding SHF_xxx values, and hence the order in which these
6698 letters will be displayed to the user. */
6699 printf (_("Key to Flags:\n\
6700 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6701 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6702 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6703 if (filedata->file_header.e_machine == EM_X86_64
6704 || filedata->file_header.e_machine == EM_L1OM
6705 || filedata->file_header.e_machine == EM_K1OM)
6706 printf (_("l (large), "));
6707 else if (filedata->file_header.e_machine == EM_ARM)
6708 printf (_("y (purecode), "));
6709 else if (filedata->file_header.e_machine == EM_PPC)
6710 printf (_("v (VLE), "));
6711 printf ("p (processor specific)\n");
6712 }
6713
6714 return TRUE;
6715}
6716
6717static const char *
6718get_group_flags (unsigned int flags)
6719{
6720 static char buff[128];
6721
6722 if (flags == 0)
6723 return "";
6724 else if (flags == GRP_COMDAT)
6725 return "COMDAT ";
6726
6727 snprintf (buff, 14, _("[0x%x: "), flags);
6728
6729 flags &= ~ GRP_COMDAT;
6730 if (flags & GRP_MASKOS)
6731 {
6732 strcat (buff, "<OS specific>");
6733 flags &= ~ GRP_MASKOS;
6734 }
6735
6736 if (flags & GRP_MASKPROC)
6737 {
6738 strcat (buff, "<PROC specific>");
6739 flags &= ~ GRP_MASKPROC;
6740 }
6741
6742 if (flags)
6743 strcat (buff, "<unknown>");
6744
6745 strcat (buff, "]");
6746 return buff;
6747}
6748
6749static bfd_boolean
6750process_section_groups (Filedata * filedata)
6751{
6752 Elf_Internal_Shdr * section;
6753 unsigned int i;
6754 struct group * group;
6755 Elf_Internal_Shdr * symtab_sec;
6756 Elf_Internal_Shdr * strtab_sec;
6757 Elf_Internal_Sym * symtab;
6758 unsigned long num_syms;
6759 char * strtab;
6760 size_t strtab_size;
6761
6762 /* Don't process section groups unless needed. */
6763 if (!do_unwind && !do_section_groups)
6764 return TRUE;
6765
6766 if (filedata->file_header.e_shnum == 0)
6767 {
6768 if (do_section_groups)
6769 printf (_("\nThere are no sections to group in this file.\n"));
6770
6771 return TRUE;
6772 }
6773
6774 if (filedata->section_headers == NULL)
6775 {
6776 error (_("Section headers are not available!\n"));
6777 /* PR 13622: This can happen with a corrupt ELF header. */
6778 return FALSE;
6779 }
6780
6781 section_headers_groups = (struct group **) calloc (filedata->file_header.e_shnum,
6782 sizeof (struct group *));
6783
6784 if (section_headers_groups == NULL)
6785 {
6786 error (_("Out of memory reading %u section group headers\n"),
6787 filedata->file_header.e_shnum);
6788 return FALSE;
6789 }
6790
6791 /* Scan the sections for the group section. */
6792 group_count = 0;
6793 for (i = 0, section = filedata->section_headers;
6794 i < filedata->file_header.e_shnum;
6795 i++, section++)
6796 if (section->sh_type == SHT_GROUP)
6797 group_count++;
6798
6799 if (group_count == 0)
6800 {
6801 if (do_section_groups)
6802 printf (_("\nThere are no section groups in this file.\n"));
6803
6804 return TRUE;
6805 }
6806
6807 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6808
6809 if (section_groups == NULL)
6810 {
6811 error (_("Out of memory reading %lu groups\n"),
6812 (unsigned long) group_count);
6813 return FALSE;
6814 }
6815
6816 symtab_sec = NULL;
6817 strtab_sec = NULL;
6818 symtab = NULL;
6819 num_syms = 0;
6820 strtab = NULL;
6821 strtab_size = 0;
6822 for (i = 0, section = filedata->section_headers, group = section_groups;
6823 i < filedata->file_header.e_shnum;
6824 i++, section++)
6825 {
6826 if (section->sh_type == SHT_GROUP)
6827 {
6828 const char * name = printable_section_name (filedata, section);
6829 const char * group_name;
6830 unsigned char * start;
6831 unsigned char * indices;
6832 unsigned int entry, j, size;
6833 Elf_Internal_Shdr * sec;
6834 Elf_Internal_Sym * sym;
6835
6836 /* Get the symbol table. */
6837 if (section->sh_link >= filedata->file_header.e_shnum
6838 || ((sec = filedata->section_headers + section->sh_link)->sh_type
6839 != SHT_SYMTAB))
6840 {
6841 error (_("Bad sh_link in group section `%s'\n"), name);
6842 continue;
6843 }
6844
6845 if (symtab_sec != sec)
6846 {
6847 symtab_sec = sec;
6848 if (symtab)
6849 free (symtab);
6850 symtab = GET_ELF_SYMBOLS (filedata, symtab_sec, & num_syms);
6851 }
6852
6853 if (symtab == NULL)
6854 {
6855 error (_("Corrupt header in group section `%s'\n"), name);
6856 continue;
6857 }
6858
6859 if (section->sh_info >= num_syms)
6860 {
6861 error (_("Bad sh_info in group section `%s'\n"), name);
6862 continue;
6863 }
6864
6865 sym = symtab + section->sh_info;
6866
6867 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6868 {
6869 if (sym->st_shndx == 0
6870 || sym->st_shndx >= filedata->file_header.e_shnum)
6871 {
6872 error (_("Bad sh_info in group section `%s'\n"), name);
6873 continue;
6874 }
6875
6876 group_name = SECTION_NAME (filedata->section_headers + sym->st_shndx);
6877 strtab_sec = NULL;
6878 if (strtab)
6879 free (strtab);
6880 strtab = NULL;
6881 strtab_size = 0;
6882 }
6883 else
6884 {
6885 /* Get the string table. */
6886 if (symtab_sec->sh_link >= filedata->file_header.e_shnum)
6887 {
6888 strtab_sec = NULL;
6889 if (strtab)
6890 free (strtab);
6891 strtab = NULL;
6892 strtab_size = 0;
6893 }
6894 else if (strtab_sec
6895 != (sec = filedata->section_headers + symtab_sec->sh_link))
6896 {
6897 strtab_sec = sec;
6898 if (strtab)
6899 free (strtab);
6900
6901 strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
6902 1, strtab_sec->sh_size,
6903 _("string table"));
6904 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6905 }
6906 group_name = sym->st_name < strtab_size
6907 ? strtab + sym->st_name : _("<corrupt>");
6908 }
6909
6910 /* PR 17531: file: loop. */
6911 if (section->sh_entsize > section->sh_size)
6912 {
6913 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6914 printable_section_name (filedata, section),
6915 (unsigned long) section->sh_entsize,
6916 (unsigned long) section->sh_size);
6917 continue;
6918 }
6919
6920 start = (unsigned char *) get_data (NULL, filedata, section->sh_offset,
6921 1, section->sh_size,
6922 _("section data"));
6923 if (start == NULL)
6924 continue;
6925
6926 indices = start;
6927 size = (section->sh_size / section->sh_entsize) - 1;
6928 entry = byte_get (indices, 4);
6929 indices += 4;
6930
6931 if (do_section_groups)
6932 {
6933 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6934 get_group_flags (entry), i, name, group_name, size);
6935
6936 printf (_(" [Index] Name\n"));
6937 }
6938
6939 group->group_index = i;
6940
6941 for (j = 0; j < size; j++)
6942 {
6943 struct group_list * g;
6944
6945 entry = byte_get (indices, 4);
6946 indices += 4;
6947
6948 if (entry >= filedata->file_header.e_shnum)
6949 {
6950 static unsigned num_group_errors = 0;
6951
6952 if (num_group_errors ++ < 10)
6953 {
6954 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6955 entry, i, filedata->file_header.e_shnum - 1);
6956 if (num_group_errors == 10)
6957 warn (_("Further error messages about overlarge group section indices suppressed\n"));
6958 }
6959 continue;
6960 }
6961
6962 if (section_headers_groups [entry] != NULL)
6963 {
6964 if (entry)
6965 {
6966 static unsigned num_errs = 0;
6967
6968 if (num_errs ++ < 10)
6969 {
6970 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6971 entry, i,
6972 section_headers_groups [entry]->group_index);
6973 if (num_errs == 10)
6974 warn (_("Further error messages about already contained group sections suppressed\n"));
6975 }
6976 continue;
6977 }
6978 else
6979 {
6980 /* Intel C/C++ compiler may put section 0 in a
6981 section group. We just warn it the first time
6982 and ignore it afterwards. */
6983 static bfd_boolean warned = FALSE;
6984 if (!warned)
6985 {
6986 error (_("section 0 in group section [%5u]\n"),
6987 section_headers_groups [entry]->group_index);
6988 warned = TRUE;
6989 }
6990 }
6991 }
6992
6993 section_headers_groups [entry] = group;
6994
6995 if (do_section_groups)
6996 {
6997 sec = filedata->section_headers + entry;
6998 printf (" [%5u] %s\n", entry, printable_section_name (filedata, sec));
6999 }
7000
7001 g = (struct group_list *) xmalloc (sizeof (struct group_list));
7002 g->section_index = entry;
7003 g->next = group->root;
7004 group->root = g;
7005 }
7006
7007 if (start)
7008 free (start);
7009
7010 group++;
7011 }
7012 }
7013
7014 if (symtab)
7015 free (symtab);
7016 if (strtab)
7017 free (strtab);
7018 return TRUE;
7019}
7020
7021/* Data used to display dynamic fixups. */
7022
7023struct ia64_vms_dynfixup
7024{
7025 bfd_vma needed_ident; /* Library ident number. */
7026 bfd_vma needed; /* Index in the dstrtab of the library name. */
7027 bfd_vma fixup_needed; /* Index of the library. */
7028 bfd_vma fixup_rela_cnt; /* Number of fixups. */
7029 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
7030};
7031
7032/* Data used to display dynamic relocations. */
7033
7034struct ia64_vms_dynimgrela
7035{
7036 bfd_vma img_rela_cnt; /* Number of relocations. */
7037 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
7038};
7039
7040/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7041 library). */
7042
7043static bfd_boolean
7044dump_ia64_vms_dynamic_fixups (Filedata * filedata,
7045 struct ia64_vms_dynfixup * fixup,
7046 const char * strtab,
7047 unsigned int strtab_sz)
7048{
7049 Elf64_External_VMS_IMAGE_FIXUP * imfs;
7050 long i;
7051 const char * lib_name;
7052
7053 imfs = get_data (NULL, filedata, dynamic_addr + fixup->fixup_rela_off,
7054 1, fixup->fixup_rela_cnt * sizeof (*imfs),
7055 _("dynamic section image fixups"));
7056 if (!imfs)
7057 return FALSE;
7058
7059 if (fixup->needed < strtab_sz)
7060 lib_name = strtab + fixup->needed;
7061 else
7062 {
7063 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7064 (unsigned long) fixup->needed);
7065 lib_name = "???";
7066 }
7067 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7068 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
7069 printf
7070 (_("Seg Offset Type SymVec DataType\n"));
7071
7072 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
7073 {
7074 unsigned int type;
7075 const char *rtype;
7076
7077 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
7078 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
7079 type = BYTE_GET (imfs [i].type);
7080 rtype = elf_ia64_reloc_type (type);
7081 if (rtype == NULL)
7082 printf (" 0x%08x ", type);
7083 else
7084 printf (" %-32s ", rtype);
7085 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
7086 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
7087 }
7088
7089 free (imfs);
7090 return TRUE;
7091}
7092
7093/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7094
7095static bfd_boolean
7096dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *imgrela)
7097{
7098 Elf64_External_VMS_IMAGE_RELA *imrs;
7099 long i;
7100
7101 imrs = get_data (NULL, filedata, dynamic_addr + imgrela->img_rela_off,
7102 1, imgrela->img_rela_cnt * sizeof (*imrs),
7103 _("dynamic section image relocations"));
7104 if (!imrs)
7105 return FALSE;
7106
7107 printf (_("\nImage relocs\n"));
7108 printf
7109 (_("Seg Offset Type Addend Seg Sym Off\n"));
7110
7111 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
7112 {
7113 unsigned int type;
7114 const char *rtype;
7115
7116 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
7117 printf ("%08" BFD_VMA_FMT "x ",
7118 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
7119 type = BYTE_GET (imrs [i].type);
7120 rtype = elf_ia64_reloc_type (type);
7121 if (rtype == NULL)
7122 printf ("0x%08x ", type);
7123 else
7124 printf ("%-31s ", rtype);
7125 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
7126 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
7127 printf ("%08" BFD_VMA_FMT "x\n",
7128 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
7129 }
7130
7131 free (imrs);
7132 return TRUE;
7133}
7134
7135/* Display IA-64 OpenVMS dynamic relocations and fixups. */
7136
7137static bfd_boolean
7138process_ia64_vms_dynamic_relocs (Filedata * filedata)
7139{
7140 struct ia64_vms_dynfixup fixup;
7141 struct ia64_vms_dynimgrela imgrela;
7142 Elf_Internal_Dyn *entry;
7143 bfd_vma strtab_off = 0;
7144 bfd_vma strtab_sz = 0;
7145 char *strtab = NULL;
7146 bfd_boolean res = TRUE;
7147
7148 memset (&fixup, 0, sizeof (fixup));
7149 memset (&imgrela, 0, sizeof (imgrela));
7150
7151 /* Note: the order of the entries is specified by the OpenVMS specs. */
7152 for (entry = dynamic_section;
7153 entry < dynamic_section + dynamic_nent;
7154 entry++)
7155 {
7156 switch (entry->d_tag)
7157 {
7158 case DT_IA_64_VMS_STRTAB_OFFSET:
7159 strtab_off = entry->d_un.d_val;
7160 break;
7161 case DT_STRSZ:
7162 strtab_sz = entry->d_un.d_val;
7163 if (strtab == NULL)
7164 strtab = get_data (NULL, filedata, dynamic_addr + strtab_off,
7165 1, strtab_sz, _("dynamic string section"));
7166 break;
7167
7168 case DT_IA_64_VMS_NEEDED_IDENT:
7169 fixup.needed_ident = entry->d_un.d_val;
7170 break;
7171 case DT_NEEDED:
7172 fixup.needed = entry->d_un.d_val;
7173 break;
7174 case DT_IA_64_VMS_FIXUP_NEEDED:
7175 fixup.fixup_needed = entry->d_un.d_val;
7176 break;
7177 case DT_IA_64_VMS_FIXUP_RELA_CNT:
7178 fixup.fixup_rela_cnt = entry->d_un.d_val;
7179 break;
7180 case DT_IA_64_VMS_FIXUP_RELA_OFF:
7181 fixup.fixup_rela_off = entry->d_un.d_val;
7182 if (! dump_ia64_vms_dynamic_fixups (filedata, &fixup, strtab, strtab_sz))
7183 res = FALSE;
7184 break;
7185 case DT_IA_64_VMS_IMG_RELA_CNT:
7186 imgrela.img_rela_cnt = entry->d_un.d_val;
7187 break;
7188 case DT_IA_64_VMS_IMG_RELA_OFF:
7189 imgrela.img_rela_off = entry->d_un.d_val;
7190 if (! dump_ia64_vms_dynamic_relocs (filedata, &imgrela))
7191 res = FALSE;
7192 break;
7193
7194 default:
7195 break;
7196 }
7197 }
7198
7199 if (strtab != NULL)
7200 free (strtab);
7201
7202 return res;
7203}
7204
7205static struct
7206{
7207 const char * name;
7208 int reloc;
7209 int size;
7210 int rela;
7211}
7212 dynamic_relocations [] =
7213{
7214 { "REL", DT_REL, DT_RELSZ, FALSE },
7215 { "RELA", DT_RELA, DT_RELASZ, TRUE },
7216 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
7217};
7218
7219/* Process the reloc section. */
7220
7221static bfd_boolean
7222process_relocs (Filedata * filedata)
7223{
7224 unsigned long rel_size;
7225 unsigned long rel_offset;
7226
7227 if (!do_reloc)
7228 return TRUE;
7229
7230 if (do_using_dynamic)
7231 {
7232 int is_rela;
7233 const char * name;
7234 bfd_boolean has_dynamic_reloc;
7235 unsigned int i;
7236
7237 has_dynamic_reloc = FALSE;
7238
7239 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7240 {
7241 is_rela = dynamic_relocations [i].rela;
7242 name = dynamic_relocations [i].name;
7243 rel_size = dynamic_info [dynamic_relocations [i].size];
7244 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
7245
7246 if (rel_size)
7247 has_dynamic_reloc = TRUE;
7248
7249 if (is_rela == UNKNOWN)
7250 {
7251 if (dynamic_relocations [i].reloc == DT_JMPREL)
7252 switch (dynamic_info[DT_PLTREL])
7253 {
7254 case DT_REL:
7255 is_rela = FALSE;
7256 break;
7257 case DT_RELA:
7258 is_rela = TRUE;
7259 break;
7260 }
7261 }
7262
7263 if (rel_size)
7264 {
7265 printf
7266 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7267 name, rel_offset, rel_size);
7268
7269 dump_relocations (filedata,
7270 offset_from_vma (filedata, rel_offset, rel_size),
7271 rel_size,
7272 dynamic_symbols, num_dynamic_syms,
7273 dynamic_strings, dynamic_strings_length,
7274 is_rela, TRUE /* is_dynamic */);
7275 }
7276 }
7277
7278 if (is_ia64_vms (filedata))
7279 if (process_ia64_vms_dynamic_relocs (filedata))
7280 has_dynamic_reloc = TRUE;
7281
7282 if (! has_dynamic_reloc)
7283 printf (_("\nThere are no dynamic relocations in this file.\n"));
7284 }
7285 else
7286 {
7287 Elf_Internal_Shdr * section;
7288 unsigned long i;
7289 bfd_boolean found = FALSE;
7290
7291 for (i = 0, section = filedata->section_headers;
7292 i < filedata->file_header.e_shnum;
7293 i++, section++)
7294 {
7295 if ( section->sh_type != SHT_RELA
7296 && section->sh_type != SHT_REL)
7297 continue;
7298
7299 rel_offset = section->sh_offset;
7300 rel_size = section->sh_size;
7301
7302 if (rel_size)
7303 {
7304 Elf_Internal_Shdr * strsec;
7305 int is_rela;
7306 unsigned long num_rela;
7307
7308 printf (_("\nRelocation section "));
7309
7310 if (filedata->string_table == NULL)
7311 printf ("%d", section->sh_name);
7312 else
7313 printf ("'%s'", printable_section_name (filedata, section));
7314
7315 num_rela = rel_size / section->sh_entsize;
7316 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7317 " at offset 0x%lx contains %lu entries:\n",
7318 num_rela),
7319 rel_offset, num_rela);
7320
7321 is_rela = section->sh_type == SHT_RELA;
7322
7323 if (section->sh_link != 0
7324 && section->sh_link < filedata->file_header.e_shnum)
7325 {
7326 Elf_Internal_Shdr * symsec;
7327 Elf_Internal_Sym * symtab;
7328 unsigned long nsyms;
7329 unsigned long strtablen = 0;
7330 char * strtab = NULL;
7331
7332 symsec = filedata->section_headers + section->sh_link;
7333 if (symsec->sh_type != SHT_SYMTAB
7334 && symsec->sh_type != SHT_DYNSYM)
7335 continue;
7336
7337 symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
7338
7339 if (symtab == NULL)
7340 continue;
7341
7342 if (symsec->sh_link != 0
7343 && symsec->sh_link < filedata->file_header.e_shnum)
7344 {
7345 strsec = filedata->section_headers + symsec->sh_link;
7346
7347 strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7348 1, strsec->sh_size,
7349 _("string table"));
7350 strtablen = strtab == NULL ? 0 : strsec->sh_size;
7351 }
7352
7353 dump_relocations (filedata, rel_offset, rel_size,
7354 symtab, nsyms, strtab, strtablen,
7355 is_rela,
7356 symsec->sh_type == SHT_DYNSYM);
7357 if (strtab)
7358 free (strtab);
7359 free (symtab);
7360 }
7361 else
7362 dump_relocations (filedata, rel_offset, rel_size,
7363 NULL, 0, NULL, 0, is_rela,
7364 FALSE /* is_dynamic */);
7365
7366 found = TRUE;
7367 }
7368 }
7369
7370 if (! found)
7371 {
7372 /* Users sometimes forget the -D option, so try to be helpful. */
7373 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7374 {
7375 if (dynamic_info [dynamic_relocations [i].size])
7376 {
7377 printf (_("\nThere are no static relocations in this file."));
7378 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7379
7380 break;
7381 }
7382 }
7383 if (i == ARRAY_SIZE (dynamic_relocations))
7384 printf (_("\nThere are no relocations in this file.\n"));
7385 }
7386 }
7387
7388 return TRUE;
7389}
7390
7391/* An absolute address consists of a section and an offset. If the
7392 section is NULL, the offset itself is the address, otherwise, the
7393 address equals to LOAD_ADDRESS(section) + offset. */
7394
7395struct absaddr
7396{
7397 unsigned short section;
7398 bfd_vma offset;
7399};
7400
7401#define ABSADDR(a) \
7402 ((a).section \
7403 ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7404 : (a).offset)
7405
7406/* Find the nearest symbol at or below ADDR. Returns the symbol
7407 name, if found, and the offset from the symbol to ADDR. */
7408
7409static void
7410find_symbol_for_address (Filedata * filedata,
7411 Elf_Internal_Sym * symtab,
7412 unsigned long nsyms,
7413 const char * strtab,
7414 unsigned long strtab_size,
7415 struct absaddr addr,
7416 const char ** symname,
7417 bfd_vma * offset)
7418{
7419 bfd_vma dist = 0x100000;
7420 Elf_Internal_Sym * sym;
7421 Elf_Internal_Sym * beg;
7422 Elf_Internal_Sym * end;
7423 Elf_Internal_Sym * best = NULL;
7424
7425 REMOVE_ARCH_BITS (addr.offset);
7426 beg = symtab;
7427 end = symtab + nsyms;
7428
7429 while (beg < end)
7430 {
7431 bfd_vma value;
7432
7433 sym = beg + (end - beg) / 2;
7434
7435 value = sym->st_value;
7436 REMOVE_ARCH_BITS (value);
7437
7438 if (sym->st_name != 0
7439 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7440 && addr.offset >= value
7441 && addr.offset - value < dist)
7442 {
7443 best = sym;
7444 dist = addr.offset - value;
7445 if (!dist)
7446 break;
7447 }
7448
7449 if (addr.offset < value)
7450 end = sym;
7451 else
7452 beg = sym + 1;
7453 }
7454
7455 if (best)
7456 {
7457 *symname = (best->st_name >= strtab_size
7458 ? _("<corrupt>") : strtab + best->st_name);
7459 *offset = dist;
7460 return;
7461 }
7462
7463 *symname = NULL;
7464 *offset = addr.offset;
7465}
7466
7467static /* signed */ int
7468symcmp (const void *p, const void *q)
7469{
7470 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7471 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7472
7473 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7474}
7475
7476/* Process the unwind section. */
7477
7478#include "unwind-ia64.h"
7479
7480struct ia64_unw_table_entry
7481{
7482 struct absaddr start;
7483 struct absaddr end;
7484 struct absaddr info;
7485};
7486
7487struct ia64_unw_aux_info
7488{
7489 struct ia64_unw_table_entry * table; /* Unwind table. */
7490 unsigned long table_len; /* Length of unwind table. */
7491 unsigned char * info; /* Unwind info. */
7492 unsigned long info_size; /* Size of unwind info. */
7493 bfd_vma info_addr; /* Starting address of unwind info. */
7494 bfd_vma seg_base; /* Starting address of segment. */
7495 Elf_Internal_Sym * symtab; /* The symbol table. */
7496 unsigned long nsyms; /* Number of symbols. */
7497 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7498 unsigned long nfuns; /* Number of entries in funtab. */
7499 char * strtab; /* The string table. */
7500 unsigned long strtab_size; /* Size of string table. */
7501};
7502
7503static bfd_boolean
7504dump_ia64_unwind (Filedata * filedata, struct ia64_unw_aux_info * aux)
7505{
7506 struct ia64_unw_table_entry * tp;
7507 unsigned long j, nfuns;
7508 int in_body;
7509 bfd_boolean res = TRUE;
7510
7511 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7512 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7513 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7514 aux->funtab[nfuns++] = aux->symtab[j];
7515 aux->nfuns = nfuns;
7516 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7517
7518 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7519 {
7520 bfd_vma stamp;
7521 bfd_vma offset;
7522 const unsigned char * dp;
7523 const unsigned char * head;
7524 const unsigned char * end;
7525 const char * procname;
7526
7527 find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7528 aux->strtab_size, tp->start, &procname, &offset);
7529
7530 fputs ("\n<", stdout);
7531
7532 if (procname)
7533 {
7534 fputs (procname, stdout);
7535
7536 if (offset)
7537 printf ("+%lx", (unsigned long) offset);
7538 }
7539
7540 fputs (">: [", stdout);
7541 print_vma (tp->start.offset, PREFIX_HEX);
7542 fputc ('-', stdout);
7543 print_vma (tp->end.offset, PREFIX_HEX);
7544 printf ("], info at +0x%lx\n",
7545 (unsigned long) (tp->info.offset - aux->seg_base));
7546
7547 /* PR 17531: file: 86232b32. */
7548 if (aux->info == NULL)
7549 continue;
7550
7551 /* PR 17531: file: 0997b4d1. */
7552 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7553 {
7554 warn (_("Invalid offset %lx in table entry %ld\n"),
7555 (long) tp->info.offset, (long) (tp - aux->table));
7556 res = FALSE;
7557 continue;
7558 }
7559
7560 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
7561 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7562
7563 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7564 (unsigned) UNW_VER (stamp),
7565 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7566 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7567 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7568 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7569
7570 if (UNW_VER (stamp) != 1)
7571 {
7572 printf (_("\tUnknown version.\n"));
7573 continue;
7574 }
7575
7576 in_body = 0;
7577 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7578 /* PR 17531: file: 16ceda89. */
7579 if (end > aux->info + aux->info_size)
7580 end = aux->info + aux->info_size;
7581 for (dp = head + 8; dp < end;)
7582 dp = unw_decode (dp, in_body, & in_body, end);
7583 }
7584
7585 free (aux->funtab);
7586
7587 return res;
7588}
7589
7590static bfd_boolean
7591slurp_ia64_unwind_table (Filedata * filedata,
7592 struct ia64_unw_aux_info * aux,
7593 Elf_Internal_Shdr * sec)
7594{
7595 unsigned long size, nrelas, i;
7596 Elf_Internal_Phdr * seg;
7597 struct ia64_unw_table_entry * tep;
7598 Elf_Internal_Shdr * relsec;
7599 Elf_Internal_Rela * rela;
7600 Elf_Internal_Rela * rp;
7601 unsigned char * table;
7602 unsigned char * tp;
7603 Elf_Internal_Sym * sym;
7604 const char * relname;
7605
7606 aux->table_len = 0;
7607
7608 /* First, find the starting address of the segment that includes
7609 this section: */
7610
7611 if (filedata->file_header.e_phnum)
7612 {
7613 if (! get_program_headers (filedata))
7614 return FALSE;
7615
7616 for (seg = filedata->program_headers;
7617 seg < filedata->program_headers + filedata->file_header.e_phnum;
7618 ++seg)
7619 {
7620 if (seg->p_type != PT_LOAD)
7621 continue;
7622
7623 if (sec->sh_addr >= seg->p_vaddr
7624 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7625 {
7626 aux->seg_base = seg->p_vaddr;
7627 break;
7628 }
7629 }
7630 }
7631
7632 /* Second, build the unwind table from the contents of the unwind section: */
7633 size = sec->sh_size;
7634 table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7635 _("unwind table"));
7636 if (!table)
7637 return FALSE;
7638
7639 aux->table_len = size / (3 * eh_addr_size);
7640 aux->table = (struct ia64_unw_table_entry *)
7641 xcmalloc (aux->table_len, sizeof (aux->table[0]));
7642 tep = aux->table;
7643
7644 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7645 {
7646 tep->start.section = SHN_UNDEF;
7647 tep->end.section = SHN_UNDEF;
7648 tep->info.section = SHN_UNDEF;
7649 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7650 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7651 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7652 tep->start.offset += aux->seg_base;
7653 tep->end.offset += aux->seg_base;
7654 tep->info.offset += aux->seg_base;
7655 }
7656 free (table);
7657
7658 /* Third, apply any relocations to the unwind table: */
7659 for (relsec = filedata->section_headers;
7660 relsec < filedata->section_headers + filedata->file_header.e_shnum;
7661 ++relsec)
7662 {
7663 if (relsec->sh_type != SHT_RELA
7664 || relsec->sh_info >= filedata->file_header.e_shnum
7665 || filedata->section_headers + relsec->sh_info != sec)
7666 continue;
7667
7668 if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7669 & rela, & nrelas))
7670 {
7671 free (aux->table);
7672 aux->table = NULL;
7673 aux->table_len = 0;
7674 return FALSE;
7675 }
7676
7677 for (rp = rela; rp < rela + nrelas; ++rp)
7678 {
7679 unsigned int sym_ndx;
7680 unsigned int r_type = get_reloc_type (filedata, rp->r_info);
7681 relname = elf_ia64_reloc_type (r_type);
7682
7683 /* PR 17531: file: 9fa67536. */
7684 if (relname == NULL)
7685 {
7686 warn (_("Skipping unknown relocation type: %u\n"), r_type);
7687 continue;
7688 }
7689
7690 if (! const_strneq (relname, "R_IA64_SEGREL"))
7691 {
7692 warn (_("Skipping unexpected relocation type: %s\n"), relname);
7693 continue;
7694 }
7695
7696 i = rp->r_offset / (3 * eh_addr_size);
7697
7698 /* PR 17531: file: 5bc8d9bf. */
7699 if (i >= aux->table_len)
7700 {
7701 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7702 continue;
7703 }
7704
7705 sym_ndx = get_reloc_symindex (rp->r_info);
7706 if (sym_ndx >= aux->nsyms)
7707 {
7708 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7709 sym_ndx);
7710 continue;
7711 }
7712 sym = aux->symtab + sym_ndx;
7713
7714 switch (rp->r_offset / eh_addr_size % 3)
7715 {
7716 case 0:
7717 aux->table[i].start.section = sym->st_shndx;
7718 aux->table[i].start.offset = rp->r_addend + sym->st_value;
7719 break;
7720 case 1:
7721 aux->table[i].end.section = sym->st_shndx;
7722 aux->table[i].end.offset = rp->r_addend + sym->st_value;
7723 break;
7724 case 2:
7725 aux->table[i].info.section = sym->st_shndx;
7726 aux->table[i].info.offset = rp->r_addend + sym->st_value;
7727 break;
7728 default:
7729 break;
7730 }
7731 }
7732
7733 free (rela);
7734 }
7735
7736 return TRUE;
7737}
7738
7739static bfd_boolean
7740ia64_process_unwind (Filedata * filedata)
7741{
7742 Elf_Internal_Shdr * sec;
7743 Elf_Internal_Shdr * unwsec = NULL;
7744 Elf_Internal_Shdr * strsec;
7745 unsigned long i, unwcount = 0, unwstart = 0;
7746 struct ia64_unw_aux_info aux;
7747 bfd_boolean res = TRUE;
7748
7749 memset (& aux, 0, sizeof (aux));
7750
7751 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
7752 {
7753 if (sec->sh_type == SHT_SYMTAB
7754 && sec->sh_link < filedata->file_header.e_shnum)
7755 {
7756 aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
7757
7758 strsec = filedata->section_headers + sec->sh_link;
7759 if (aux.strtab != NULL)
7760 {
7761 error (_("Multiple auxillary string tables encountered\n"));
7762 free (aux.strtab);
7763 res = FALSE;
7764 }
7765 aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7766 1, strsec->sh_size,
7767 _("string table"));
7768 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7769 }
7770 else if (sec->sh_type == SHT_IA_64_UNWIND)
7771 unwcount++;
7772 }
7773
7774 if (!unwcount)
7775 printf (_("\nThere are no unwind sections in this file.\n"));
7776
7777 while (unwcount-- > 0)
7778 {
7779 char * suffix;
7780 size_t len, len2;
7781
7782 for (i = unwstart, sec = filedata->section_headers + unwstart, unwsec = NULL;
7783 i < filedata->file_header.e_shnum; ++i, ++sec)
7784 if (sec->sh_type == SHT_IA_64_UNWIND)
7785 {
7786 unwsec = sec;
7787 break;
7788 }
7789 /* We have already counted the number of SHT_IA64_UNWIND
7790 sections so the loop above should never fail. */
7791 assert (unwsec != NULL);
7792
7793 unwstart = i + 1;
7794 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7795
7796 if ((unwsec->sh_flags & SHF_GROUP) != 0)
7797 {
7798 /* We need to find which section group it is in. */
7799 struct group_list * g;
7800
7801 if (section_headers_groups == NULL
7802 || section_headers_groups [i] == NULL)
7803 i = filedata->file_header.e_shnum;
7804 else
7805 {
7806 g = section_headers_groups [i]->root;
7807
7808 for (; g != NULL; g = g->next)
7809 {
7810 sec = filedata->section_headers + g->section_index;
7811
7812 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7813 break;
7814 }
7815
7816 if (g == NULL)
7817 i = filedata->file_header.e_shnum;
7818 }
7819 }
7820 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7821 {
7822 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7823 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7824 suffix = SECTION_NAME (unwsec) + len;
7825 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7826 ++i, ++sec)
7827 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7828 && streq (SECTION_NAME (sec) + len2, suffix))
7829 break;
7830 }
7831 else
7832 {
7833 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7834 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7835 len = sizeof (ELF_STRING_ia64_unwind) - 1;
7836 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7837 suffix = "";
7838 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7839 suffix = SECTION_NAME (unwsec) + len;
7840 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7841 ++i, ++sec)
7842 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7843 && streq (SECTION_NAME (sec) + len2, suffix))
7844 break;
7845 }
7846
7847 if (i == filedata->file_header.e_shnum)
7848 {
7849 printf (_("\nCould not find unwind info section for "));
7850
7851 if (filedata->string_table == NULL)
7852 printf ("%d", unwsec->sh_name);
7853 else
7854 printf ("'%s'", printable_section_name (filedata, unwsec));
7855 }
7856 else
7857 {
7858 aux.info_addr = sec->sh_addr;
7859 aux.info = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1,
7860 sec->sh_size,
7861 _("unwind info"));
7862 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7863
7864 printf (_("\nUnwind section "));
7865
7866 if (filedata->string_table == NULL)
7867 printf ("%d", unwsec->sh_name);
7868 else
7869 printf ("'%s'", printable_section_name (filedata, unwsec));
7870
7871 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7872 (unsigned long) unwsec->sh_offset,
7873 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7874
7875 if (slurp_ia64_unwind_table (filedata, & aux, unwsec)
7876 && aux.table_len > 0)
7877 dump_ia64_unwind (filedata, & aux);
7878
7879 if (aux.table)
7880 free ((char *) aux.table);
7881 if (aux.info)
7882 free ((char *) aux.info);
7883 aux.table = NULL;
7884 aux.info = NULL;
7885 }
7886 }
7887
7888 if (aux.symtab)
7889 free (aux.symtab);
7890 if (aux.strtab)
7891 free ((char *) aux.strtab);
7892
7893 return res;
7894}
7895
7896struct hppa_unw_table_entry
7897{
7898 struct absaddr start;
7899 struct absaddr end;
7900 unsigned int Cannot_unwind:1; /* 0 */
7901 unsigned int Millicode:1; /* 1 */
7902 unsigned int Millicode_save_sr0:1; /* 2 */
7903 unsigned int Region_description:2; /* 3..4 */
7904 unsigned int reserved1:1; /* 5 */
7905 unsigned int Entry_SR:1; /* 6 */
7906 unsigned int Entry_FR:4; /* Number saved 7..10 */
7907 unsigned int Entry_GR:5; /* Number saved 11..15 */
7908 unsigned int Args_stored:1; /* 16 */
7909 unsigned int Variable_Frame:1; /* 17 */
7910 unsigned int Separate_Package_Body:1; /* 18 */
7911 unsigned int Frame_Extension_Millicode:1; /* 19 */
7912 unsigned int Stack_Overflow_Check:1; /* 20 */
7913 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
7914 unsigned int Ada_Region:1; /* 22 */
7915 unsigned int cxx_info:1; /* 23 */
7916 unsigned int cxx_try_catch:1; /* 24 */
7917 unsigned int sched_entry_seq:1; /* 25 */
7918 unsigned int reserved2:1; /* 26 */
7919 unsigned int Save_SP:1; /* 27 */
7920 unsigned int Save_RP:1; /* 28 */
7921 unsigned int Save_MRP_in_frame:1; /* 29 */
7922 unsigned int extn_ptr_defined:1; /* 30 */
7923 unsigned int Cleanup_defined:1; /* 31 */
7924
7925 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
7926 unsigned int HP_UX_interrupt_marker:1; /* 1 */
7927 unsigned int Large_frame:1; /* 2 */
7928 unsigned int Pseudo_SP_Set:1; /* 3 */
7929 unsigned int reserved4:1; /* 4 */
7930 unsigned int Total_frame_size:27; /* 5..31 */
7931};
7932
7933struct hppa_unw_aux_info
7934{
7935 struct hppa_unw_table_entry * table; /* Unwind table. */
7936 unsigned long table_len; /* Length of unwind table. */
7937 bfd_vma seg_base; /* Starting address of segment. */
7938 Elf_Internal_Sym * symtab; /* The symbol table. */
7939 unsigned long nsyms; /* Number of symbols. */
7940 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7941 unsigned long nfuns; /* Number of entries in funtab. */
7942 char * strtab; /* The string table. */
7943 unsigned long strtab_size; /* Size of string table. */
7944};
7945
7946static bfd_boolean
7947dump_hppa_unwind (Filedata * filedata, struct hppa_unw_aux_info * aux)
7948{
7949 struct hppa_unw_table_entry * tp;
7950 unsigned long j, nfuns;
7951 bfd_boolean res = TRUE;
7952
7953 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7954 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7955 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7956 aux->funtab[nfuns++] = aux->symtab[j];
7957 aux->nfuns = nfuns;
7958 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7959
7960 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7961 {
7962 bfd_vma offset;
7963 const char * procname;
7964
7965 find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7966 aux->strtab_size, tp->start, &procname,
7967 &offset);
7968
7969 fputs ("\n<", stdout);
7970
7971 if (procname)
7972 {
7973 fputs (procname, stdout);
7974
7975 if (offset)
7976 printf ("+%lx", (unsigned long) offset);
7977 }
7978
7979 fputs (">: [", stdout);
7980 print_vma (tp->start.offset, PREFIX_HEX);
7981 fputc ('-', stdout);
7982 print_vma (tp->end.offset, PREFIX_HEX);
7983 printf ("]\n\t");
7984
7985#define PF(_m) if (tp->_m) printf (#_m " ");
7986#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7987 PF(Cannot_unwind);
7988 PF(Millicode);
7989 PF(Millicode_save_sr0);
7990 /* PV(Region_description); */
7991 PF(Entry_SR);
7992 PV(Entry_FR);
7993 PV(Entry_GR);
7994 PF(Args_stored);
7995 PF(Variable_Frame);
7996 PF(Separate_Package_Body);
7997 PF(Frame_Extension_Millicode);
7998 PF(Stack_Overflow_Check);
7999 PF(Two_Instruction_SP_Increment);
8000 PF(Ada_Region);
8001 PF(cxx_info);
8002 PF(cxx_try_catch);
8003 PF(sched_entry_seq);
8004 PF(Save_SP);
8005 PF(Save_RP);
8006 PF(Save_MRP_in_frame);
8007 PF(extn_ptr_defined);
8008 PF(Cleanup_defined);
8009 PF(MPE_XL_interrupt_marker);
8010 PF(HP_UX_interrupt_marker);
8011 PF(Large_frame);
8012 PF(Pseudo_SP_Set);
8013 PV(Total_frame_size);
8014#undef PF
8015#undef PV
8016 }
8017
8018 printf ("\n");
8019
8020 free (aux->funtab);
8021
8022 return res;
8023}
8024
8025static bfd_boolean
8026slurp_hppa_unwind_table (Filedata * filedata,
8027 struct hppa_unw_aux_info * aux,
8028 Elf_Internal_Shdr * sec)
8029{
8030 unsigned long size, unw_ent_size, nentries, nrelas, i;
8031 Elf_Internal_Phdr * seg;
8032 struct hppa_unw_table_entry * tep;
8033 Elf_Internal_Shdr * relsec;
8034 Elf_Internal_Rela * rela;
8035 Elf_Internal_Rela * rp;
8036 unsigned char * table;
8037 unsigned char * tp;
8038 Elf_Internal_Sym * sym;
8039 const char * relname;
8040
8041 /* First, find the starting address of the segment that includes
8042 this section. */
8043 if (filedata->file_header.e_phnum)
8044 {
8045 if (! get_program_headers (filedata))
8046 return FALSE;
8047
8048 for (seg = filedata->program_headers;
8049 seg < filedata->program_headers + filedata->file_header.e_phnum;
8050 ++seg)
8051 {
8052 if (seg->p_type != PT_LOAD)
8053 continue;
8054
8055 if (sec->sh_addr >= seg->p_vaddr
8056 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
8057 {
8058 aux->seg_base = seg->p_vaddr;
8059 break;
8060 }
8061 }
8062 }
8063
8064 /* Second, build the unwind table from the contents of the unwind
8065 section. */
8066 size = sec->sh_size;
8067 table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
8068 _("unwind table"));
8069 if (!table)
8070 return FALSE;
8071
8072 unw_ent_size = 16;
8073 nentries = size / unw_ent_size;
8074 size = unw_ent_size * nentries;
8075
8076 tep = aux->table = (struct hppa_unw_table_entry *)
8077 xcmalloc (nentries, sizeof (aux->table[0]));
8078
8079 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
8080 {
8081 unsigned int tmp1, tmp2;
8082
8083 tep->start.section = SHN_UNDEF;
8084 tep->end.section = SHN_UNDEF;
8085
8086 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
8087 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
8088 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
8089 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
8090
8091 tep->start.offset += aux->seg_base;
8092 tep->end.offset += aux->seg_base;
8093
8094 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
8095 tep->Millicode = (tmp1 >> 30) & 0x1;
8096 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
8097 tep->Region_description = (tmp1 >> 27) & 0x3;
8098 tep->reserved1 = (tmp1 >> 26) & 0x1;
8099 tep->Entry_SR = (tmp1 >> 25) & 0x1;
8100 tep->Entry_FR = (tmp1 >> 21) & 0xf;
8101 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
8102 tep->Args_stored = (tmp1 >> 15) & 0x1;
8103 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
8104 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
8105 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
8106 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
8107 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
8108 tep->Ada_Region = (tmp1 >> 9) & 0x1;
8109 tep->cxx_info = (tmp1 >> 8) & 0x1;
8110 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
8111 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
8112 tep->reserved2 = (tmp1 >> 5) & 0x1;
8113 tep->Save_SP = (tmp1 >> 4) & 0x1;
8114 tep->Save_RP = (tmp1 >> 3) & 0x1;
8115 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
8116 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
8117 tep->Cleanup_defined = tmp1 & 0x1;
8118
8119 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
8120 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
8121 tep->Large_frame = (tmp2 >> 29) & 0x1;
8122 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
8123 tep->reserved4 = (tmp2 >> 27) & 0x1;
8124 tep->Total_frame_size = tmp2 & 0x7ffffff;
8125 }
8126 free (table);
8127
8128 /* Third, apply any relocations to the unwind table. */
8129 for (relsec = filedata->section_headers;
8130 relsec < filedata->section_headers + filedata->file_header.e_shnum;
8131 ++relsec)
8132 {
8133 if (relsec->sh_type != SHT_RELA
8134 || relsec->sh_info >= filedata->file_header.e_shnum
8135 || filedata->section_headers + relsec->sh_info != sec)
8136 continue;
8137
8138 if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
8139 & rela, & nrelas))
8140 return FALSE;
8141
8142 for (rp = rela; rp < rela + nrelas; ++rp)
8143 {
8144 unsigned int sym_ndx;
8145 unsigned int r_type = get_reloc_type (filedata, rp->r_info);
8146 relname = elf_hppa_reloc_type (r_type);
8147
8148 if (relname == NULL)
8149 {
8150 warn (_("Skipping unknown relocation type: %u\n"), r_type);
8151 continue;
8152 }
8153
8154 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8155 if (! const_strneq (relname, "R_PARISC_SEGREL"))
8156 {
8157 warn (_("Skipping unexpected relocation type: %s\n"), relname);
8158 continue;
8159 }
8160
8161 i = rp->r_offset / unw_ent_size;
8162 if (i >= aux->table_len)
8163 {
8164 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
8165 continue;
8166 }
8167
8168 sym_ndx = get_reloc_symindex (rp->r_info);
8169 if (sym_ndx >= aux->nsyms)
8170 {
8171 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8172 sym_ndx);
8173 continue;
8174 }
8175 sym = aux->symtab + sym_ndx;
8176
8177 switch ((rp->r_offset % unw_ent_size) / 4)
8178 {
8179 case 0:
8180 aux->table[i].start.section = sym->st_shndx;
8181 aux->table[i].start.offset = sym->st_value + rp->r_addend;
8182 break;
8183 case 1:
8184 aux->table[i].end.section = sym->st_shndx;
8185 aux->table[i].end.offset = sym->st_value + rp->r_addend;
8186 break;
8187 default:
8188 break;
8189 }
8190 }
8191
8192 free (rela);
8193 }
8194
8195 aux->table_len = nentries;
8196
8197 return TRUE;
8198}
8199
8200static bfd_boolean
8201hppa_process_unwind (Filedata * filedata)
8202{
8203 struct hppa_unw_aux_info aux;
8204 Elf_Internal_Shdr * unwsec = NULL;
8205 Elf_Internal_Shdr * strsec;
8206 Elf_Internal_Shdr * sec;
8207 unsigned long i;
8208 bfd_boolean res = TRUE;
8209
8210 if (filedata->string_table == NULL)
8211 return FALSE;
8212
8213 memset (& aux, 0, sizeof (aux));
8214
8215 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8216 {
8217 if (sec->sh_type == SHT_SYMTAB
8218 && sec->sh_link < filedata->file_header.e_shnum)
8219 {
8220 aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
8221
8222 strsec = filedata->section_headers + sec->sh_link;
8223 if (aux.strtab != NULL)
8224 {
8225 error (_("Multiple auxillary string tables encountered\n"));
8226 free (aux.strtab);
8227 res = FALSE;
8228 }
8229 aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
8230 1, strsec->sh_size,
8231 _("string table"));
8232 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8233 }
8234 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8235 unwsec = sec;
8236 }
8237
8238 if (!unwsec)
8239 printf (_("\nThere are no unwind sections in this file.\n"));
8240
8241 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8242 {
8243 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8244 {
8245 unsigned long num_unwind = sec->sh_size / 16;
8246
8247 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8248 "contains %lu entry:\n",
8249 "\nUnwind section '%s' at offset 0x%lx "
8250 "contains %lu entries:\n",
8251 num_unwind),
8252 printable_section_name (filedata, sec),
8253 (unsigned long) sec->sh_offset,
8254 num_unwind);
8255
8256 if (! slurp_hppa_unwind_table (filedata, &aux, sec))
8257 res = FALSE;
8258
8259 if (res && aux.table_len > 0)
8260 {
8261 if (! dump_hppa_unwind (filedata, &aux))
8262 res = FALSE;
8263 }
8264
8265 if (aux.table)
8266 free ((char *) aux.table);
8267 aux.table = NULL;
8268 }
8269 }
8270
8271 if (aux.symtab)
8272 free (aux.symtab);
8273 if (aux.strtab)
8274 free ((char *) aux.strtab);
8275
8276 return res;
8277}
8278
8279struct arm_section
8280{
8281 unsigned char * data; /* The unwind data. */
8282 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
8283 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
8284 unsigned long nrelas; /* The number of relocations. */
8285 unsigned int rel_type; /* REL or RELA ? */
8286 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
8287};
8288
8289struct arm_unw_aux_info
8290{
8291 Filedata * filedata; /* The file containing the unwind sections. */
8292 Elf_Internal_Sym * symtab; /* The file's symbol table. */
8293 unsigned long nsyms; /* Number of symbols. */
8294 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
8295 unsigned long nfuns; /* Number of these symbols. */
8296 char * strtab; /* The file's string table. */
8297 unsigned long strtab_size; /* Size of string table. */
8298};
8299
8300static const char *
8301arm_print_vma_and_name (Filedata * filedata,
8302 struct arm_unw_aux_info * aux,
8303 bfd_vma fn,
8304 struct absaddr addr)
8305{
8306 const char *procname;
8307 bfd_vma sym_offset;
8308
8309 if (addr.section == SHN_UNDEF)
8310 addr.offset = fn;
8311
8312 find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8313 aux->strtab_size, addr, &procname,
8314 &sym_offset);
8315
8316 print_vma (fn, PREFIX_HEX);
8317
8318 if (procname)
8319 {
8320 fputs (" <", stdout);
8321 fputs (procname, stdout);
8322
8323 if (sym_offset)
8324 printf ("+0x%lx", (unsigned long) sym_offset);
8325 fputc ('>', stdout);
8326 }
8327
8328 return procname;
8329}
8330
8331static void
8332arm_free_section (struct arm_section *arm_sec)
8333{
8334 if (arm_sec->data != NULL)
8335 free (arm_sec->data);
8336
8337 if (arm_sec->rela != NULL)
8338 free (arm_sec->rela);
8339}
8340
8341/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8342 cached section and install SEC instead.
8343 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8344 and return its valued in * WORDP, relocating if necessary.
8345 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8346 relocation's offset in ADDR.
8347 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8348 into the string table of the symbol associated with the reloc. If no
8349 reloc was applied store -1 there.
8350 5) Return TRUE upon success, FALSE otherwise. */
8351
8352static bfd_boolean
8353get_unwind_section_word (Filedata * filedata,
8354 struct arm_unw_aux_info * aux,
8355 struct arm_section * arm_sec,
8356 Elf_Internal_Shdr * sec,
8357 bfd_vma word_offset,
8358 unsigned int * wordp,
8359 struct absaddr * addr,
8360 bfd_vma * sym_name)
8361{
8362 Elf_Internal_Rela *rp;
8363 Elf_Internal_Sym *sym;
8364 const char * relname;
8365 unsigned int word;
8366 bfd_boolean wrapped;
8367
8368 if (sec == NULL || arm_sec == NULL)
8369 return FALSE;
8370
8371 addr->section = SHN_UNDEF;
8372 addr->offset = 0;
8373
8374 if (sym_name != NULL)
8375 *sym_name = (bfd_vma) -1;
8376
8377 /* If necessary, update the section cache. */
8378 if (sec != arm_sec->sec)
8379 {
8380 Elf_Internal_Shdr *relsec;
8381
8382 arm_free_section (arm_sec);
8383
8384 arm_sec->sec = sec;
8385 arm_sec->data = get_data (NULL, aux->filedata, sec->sh_offset, 1,
8386 sec->sh_size, _("unwind data"));
8387 arm_sec->rela = NULL;
8388 arm_sec->nrelas = 0;
8389
8390 for (relsec = filedata->section_headers;
8391 relsec < filedata->section_headers + filedata->file_header.e_shnum;
8392 ++relsec)
8393 {
8394 if (relsec->sh_info >= filedata->file_header.e_shnum
8395 || filedata->section_headers + relsec->sh_info != sec
8396 /* PR 15745: Check the section type as well. */
8397 || (relsec->sh_type != SHT_REL
8398 && relsec->sh_type != SHT_RELA))
8399 continue;
8400
8401 arm_sec->rel_type = relsec->sh_type;
8402 if (relsec->sh_type == SHT_REL)
8403 {
8404 if (!slurp_rel_relocs (aux->filedata, relsec->sh_offset,
8405 relsec->sh_size,
8406 & arm_sec->rela, & arm_sec->nrelas))
8407 return FALSE;
8408 }
8409 else /* relsec->sh_type == SHT_RELA */
8410 {
8411 if (!slurp_rela_relocs (aux->filedata, relsec->sh_offset,
8412 relsec->sh_size,
8413 & arm_sec->rela, & arm_sec->nrelas))
8414 return FALSE;
8415 }
8416 break;
8417 }
8418
8419 arm_sec->next_rela = arm_sec->rela;
8420 }
8421
8422 /* If there is no unwind data we can do nothing. */
8423 if (arm_sec->data == NULL)
8424 return FALSE;
8425
8426 /* If the offset is invalid then fail. */
8427 if (/* PR 21343 *//* PR 18879 */
8428 sec->sh_size < 4
8429 || word_offset > (sec->sh_size - 4)
8430 || ((bfd_signed_vma) word_offset) < 0)
8431 return FALSE;
8432
8433 /* Get the word at the required offset. */
8434 word = byte_get (arm_sec->data + word_offset, 4);
8435
8436 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8437 if (arm_sec->rela == NULL)
8438 {
8439 * wordp = word;
8440 return TRUE;
8441 }
8442
8443 /* Look through the relocs to find the one that applies to the provided offset. */
8444 wrapped = FALSE;
8445 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8446 {
8447 bfd_vma prelval, offset;
8448
8449 if (rp->r_offset > word_offset && !wrapped)
8450 {
8451 rp = arm_sec->rela;
8452 wrapped = TRUE;
8453 }
8454 if (rp->r_offset > word_offset)
8455 break;
8456
8457 if (rp->r_offset & 3)
8458 {
8459 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8460 (unsigned long) rp->r_offset);
8461 continue;
8462 }
8463
8464 if (rp->r_offset < word_offset)
8465 continue;
8466
8467 /* PR 17531: file: 027-161405-0.004 */
8468 if (aux->symtab == NULL)
8469 continue;
8470
8471 if (arm_sec->rel_type == SHT_REL)
8472 {
8473 offset = word & 0x7fffffff;
8474 if (offset & 0x40000000)
8475 offset |= ~ (bfd_vma) 0x7fffffff;
8476 }
8477 else if (arm_sec->rel_type == SHT_RELA)
8478 offset = rp->r_addend;
8479 else
8480 {
8481 error (_("Unknown section relocation type %d encountered\n"),
8482 arm_sec->rel_type);
8483 break;
8484 }
8485
8486 /* PR 17531 file: 027-1241568-0.004. */
8487 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8488 {
8489 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8490 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8491 break;
8492 }
8493
8494 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8495 offset += sym->st_value;
8496 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8497
8498 /* Check that we are processing the expected reloc type. */
8499 if (filedata->file_header.e_machine == EM_ARM)
8500 {
8501 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8502 if (relname == NULL)
8503 {
8504 warn (_("Skipping unknown ARM relocation type: %d\n"),
8505 (int) ELF32_R_TYPE (rp->r_info));
8506 continue;
8507 }
8508
8509 if (streq (relname, "R_ARM_NONE"))
8510 continue;
8511
8512 if (! streq (relname, "R_ARM_PREL31"))
8513 {
8514 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8515 continue;
8516 }
8517 }
8518 else if (filedata->file_header.e_machine == EM_TI_C6000)
8519 {
8520 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8521 if (relname == NULL)
8522 {
8523 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8524 (int) ELF32_R_TYPE (rp->r_info));
8525 continue;
8526 }
8527
8528 if (streq (relname, "R_C6000_NONE"))
8529 continue;
8530
8531 if (! streq (relname, "R_C6000_PREL31"))
8532 {
8533 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8534 continue;
8535 }
8536
8537 prelval >>= 1;
8538 }
8539 else
8540 {
8541 /* This function currently only supports ARM and TI unwinders. */
8542 warn (_("Only TI and ARM unwinders are currently supported\n"));
8543 break;
8544 }
8545
8546 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8547 addr->section = sym->st_shndx;
8548 addr->offset = offset;
8549
8550 if (sym_name)
8551 * sym_name = sym->st_name;
8552 break;
8553 }
8554
8555 *wordp = word;
8556 arm_sec->next_rela = rp;
8557
8558 return TRUE;
8559}
8560
8561static const char *tic6x_unwind_regnames[16] =
8562{
8563 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8564 "A14", "A13", "A12", "A11", "A10",
8565 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8566};
8567
8568static void
8569decode_tic6x_unwind_regmask (unsigned int mask)
8570{
8571 int i;
8572
8573 for (i = 12; mask; mask >>= 1, i--)
8574 {
8575 if (mask & 1)
8576 {
8577 fputs (tic6x_unwind_regnames[i], stdout);
8578 if (mask > 1)
8579 fputs (", ", stdout);
8580 }
8581 }
8582}
8583
8584#define ADVANCE \
8585 if (remaining == 0 && more_words) \
8586 { \
8587 data_offset += 4; \
8588 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8589 data_offset, & word, & addr, NULL)) \
8590 return FALSE; \
8591 remaining = 4; \
8592 more_words--; \
8593 } \
8594
8595#define GET_OP(OP) \
8596 ADVANCE; \
8597 if (remaining) \
8598 { \
8599 remaining--; \
8600 (OP) = word >> 24; \
8601 word <<= 8; \
8602 } \
8603 else \
8604 { \
8605 printf (_("[Truncated opcode]\n")); \
8606 return FALSE; \
8607 } \
8608 printf ("0x%02x ", OP)
8609
8610static bfd_boolean
8611decode_arm_unwind_bytecode (Filedata * filedata,
8612 struct arm_unw_aux_info * aux,
8613 unsigned int word,
8614 unsigned int remaining,
8615 unsigned int more_words,
8616 bfd_vma data_offset,
8617 Elf_Internal_Shdr * data_sec,
8618 struct arm_section * data_arm_sec)
8619{
8620 struct absaddr addr;
8621 bfd_boolean res = TRUE;
8622
8623 /* Decode the unwinding instructions. */
8624 while (1)
8625 {
8626 unsigned int op, op2;
8627
8628 ADVANCE;
8629 if (remaining == 0)
8630 break;
8631 remaining--;
8632 op = word >> 24;
8633 word <<= 8;
8634
8635 printf (" 0x%02x ", op);
8636
8637 if ((op & 0xc0) == 0x00)
8638 {
8639 int offset = ((op & 0x3f) << 2) + 4;
8640
8641 printf (" vsp = vsp + %d", offset);
8642 }
8643 else if ((op & 0xc0) == 0x40)
8644 {
8645 int offset = ((op & 0x3f) << 2) + 4;
8646
8647 printf (" vsp = vsp - %d", offset);
8648 }
8649 else if ((op & 0xf0) == 0x80)
8650 {
8651 GET_OP (op2);
8652 if (op == 0x80 && op2 == 0)
8653 printf (_("Refuse to unwind"));
8654 else
8655 {
8656 unsigned int mask = ((op & 0x0f) << 8) | op2;
8657 bfd_boolean first = TRUE;
8658 int i;
8659
8660 printf ("pop {");
8661 for (i = 0; i < 12; i++)
8662 if (mask & (1 << i))
8663 {
8664 if (first)
8665 first = FALSE;
8666 else
8667 printf (", ");
8668 printf ("r%d", 4 + i);
8669 }
8670 printf ("}");
8671 }
8672 }
8673 else if ((op & 0xf0) == 0x90)
8674 {
8675 if (op == 0x9d || op == 0x9f)
8676 printf (_(" [Reserved]"));
8677 else
8678 printf (" vsp = r%d", op & 0x0f);
8679 }
8680 else if ((op & 0xf0) == 0xa0)
8681 {
8682 int end = 4 + (op & 0x07);
8683 bfd_boolean first = TRUE;
8684 int i;
8685
8686 printf (" pop {");
8687 for (i = 4; i <= end; i++)
8688 {
8689 if (first)
8690 first = FALSE;
8691 else
8692 printf (", ");
8693 printf ("r%d", i);
8694 }
8695 if (op & 0x08)
8696 {
8697 if (!first)
8698 printf (", ");
8699 printf ("r14");
8700 }
8701 printf ("}");
8702 }
8703 else if (op == 0xb0)
8704 printf (_(" finish"));
8705 else if (op == 0xb1)
8706 {
8707 GET_OP (op2);
8708 if (op2 == 0 || (op2 & 0xf0) != 0)
8709 printf (_("[Spare]"));
8710 else
8711 {
8712 unsigned int mask = op2 & 0x0f;
8713 bfd_boolean first = TRUE;
8714 int i;
8715
8716 printf ("pop {");
8717 for (i = 0; i < 12; i++)
8718 if (mask & (1 << i))
8719 {
8720 if (first)
8721 first = FALSE;
8722 else
8723 printf (", ");
8724 printf ("r%d", i);
8725 }
8726 printf ("}");
8727 }
8728 }
8729 else if (op == 0xb2)
8730 {
8731 unsigned char buf[9];
8732 unsigned int i, len;
8733 unsigned long offset;
8734
8735 for (i = 0; i < sizeof (buf); i++)
8736 {
8737 GET_OP (buf[i]);
8738 if ((buf[i] & 0x80) == 0)
8739 break;
8740 }
8741 if (i == sizeof (buf))
8742 {
8743 error (_("corrupt change to vsp"));
8744 res = FALSE;
8745 }
8746 else
8747 {
8748 offset = read_uleb128 (buf, &len, buf + i + 1);
8749 assert (len == i + 1);
8750 offset = offset * 4 + 0x204;
8751 printf ("vsp = vsp + %ld", offset);
8752 }
8753 }
8754 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8755 {
8756 unsigned int first, last;
8757
8758 GET_OP (op2);
8759 first = op2 >> 4;
8760 last = op2 & 0x0f;
8761 if (op == 0xc8)
8762 first = first + 16;
8763 printf ("pop {D%d", first);
8764 if (last)
8765 printf ("-D%d", first + last);
8766 printf ("}");
8767 }
8768 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8769 {
8770 unsigned int count = op & 0x07;
8771
8772 printf ("pop {D8");
8773 if (count)
8774 printf ("-D%d", 8 + count);
8775 printf ("}");
8776 }
8777 else if (op >= 0xc0 && op <= 0xc5)
8778 {
8779 unsigned int count = op & 0x07;
8780
8781 printf (" pop {wR10");
8782 if (count)
8783 printf ("-wR%d", 10 + count);
8784 printf ("}");
8785 }
8786 else if (op == 0xc6)
8787 {
8788 unsigned int first, last;
8789
8790 GET_OP (op2);
8791 first = op2 >> 4;
8792 last = op2 & 0x0f;
8793 printf ("pop {wR%d", first);
8794 if (last)
8795 printf ("-wR%d", first + last);
8796 printf ("}");
8797 }
8798 else if (op == 0xc7)
8799 {
8800 GET_OP (op2);
8801 if (op2 == 0 || (op2 & 0xf0) != 0)
8802 printf (_("[Spare]"));
8803 else
8804 {
8805 unsigned int mask = op2 & 0x0f;
8806 bfd_boolean first = TRUE;
8807 int i;
8808
8809 printf ("pop {");
8810 for (i = 0; i < 4; i++)
8811 if (mask & (1 << i))
8812 {
8813 if (first)
8814 first = FALSE;
8815 else
8816 printf (", ");
8817 printf ("wCGR%d", i);
8818 }
8819 printf ("}");
8820 }
8821 }
8822 else
8823 {
8824 printf (_(" [unsupported opcode]"));
8825 res = FALSE;
8826 }
8827
8828 printf ("\n");
8829 }
8830
8831 return res;
8832}
8833
8834static bfd_boolean
8835decode_tic6x_unwind_bytecode (Filedata * filedata,
8836 struct arm_unw_aux_info * aux,
8837 unsigned int word,
8838 unsigned int remaining,
8839 unsigned int more_words,
8840 bfd_vma data_offset,
8841 Elf_Internal_Shdr * data_sec,
8842 struct arm_section * data_arm_sec)
8843{
8844 struct absaddr addr;
8845
8846 /* Decode the unwinding instructions. */
8847 while (1)
8848 {
8849 unsigned int op, op2;
8850
8851 ADVANCE;
8852 if (remaining == 0)
8853 break;
8854 remaining--;
8855 op = word >> 24;
8856 word <<= 8;
8857
8858 printf (" 0x%02x ", op);
8859
8860 if ((op & 0xc0) == 0x00)
8861 {
8862 int offset = ((op & 0x3f) << 3) + 8;
8863 printf (" sp = sp + %d", offset);
8864 }
8865 else if ((op & 0xc0) == 0x80)
8866 {
8867 GET_OP (op2);
8868 if (op == 0x80 && op2 == 0)
8869 printf (_("Refuse to unwind"));
8870 else
8871 {
8872 unsigned int mask = ((op & 0x1f) << 8) | op2;
8873 if (op & 0x20)
8874 printf ("pop compact {");
8875 else
8876 printf ("pop {");
8877
8878 decode_tic6x_unwind_regmask (mask);
8879 printf("}");
8880 }
8881 }
8882 else if ((op & 0xf0) == 0xc0)
8883 {
8884 unsigned int reg;
8885 unsigned int nregs;
8886 unsigned int i;
8887 const char *name;
8888 struct
8889 {
8890 unsigned int offset;
8891 unsigned int reg;
8892 } regpos[16];
8893
8894 /* Scan entire instruction first so that GET_OP output is not
8895 interleaved with disassembly. */
8896 nregs = 0;
8897 for (i = 0; nregs < (op & 0xf); i++)
8898 {
8899 GET_OP (op2);
8900 reg = op2 >> 4;
8901 if (reg != 0xf)
8902 {
8903 regpos[nregs].offset = i * 2;
8904 regpos[nregs].reg = reg;
8905 nregs++;
8906 }
8907
8908 reg = op2 & 0xf;
8909 if (reg != 0xf)
8910 {
8911 regpos[nregs].offset = i * 2 + 1;
8912 regpos[nregs].reg = reg;
8913 nregs++;
8914 }
8915 }
8916
8917 printf (_("pop frame {"));
8918 if (nregs == 0)
8919 {
8920 printf (_("*corrupt* - no registers specified"));
8921 }
8922 else
8923 {
8924 reg = nregs - 1;
8925 for (i = i * 2; i > 0; i--)
8926 {
8927 if (regpos[reg].offset == i - 1)
8928 {
8929 name = tic6x_unwind_regnames[regpos[reg].reg];
8930 if (reg > 0)
8931 reg--;
8932 }
8933 else
8934 name = _("[pad]");
8935
8936 fputs (name, stdout);
8937 if (i > 1)
8938 printf (", ");
8939 }
8940 }
8941
8942 printf ("}");
8943 }
8944 else if (op == 0xd0)
8945 printf (" MOV FP, SP");
8946 else if (op == 0xd1)
8947 printf (" __c6xabi_pop_rts");
8948 else if (op == 0xd2)
8949 {
8950 unsigned char buf[9];
8951 unsigned int i, len;
8952 unsigned long offset;
8953
8954 for (i = 0; i < sizeof (buf); i++)
8955 {
8956 GET_OP (buf[i]);
8957 if ((buf[i] & 0x80) == 0)
8958 break;
8959 }
8960 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8961 if (i == sizeof (buf))
8962 {
8963 warn (_("Corrupt stack pointer adjustment detected\n"));
8964 return FALSE;
8965 }
8966
8967 offset = read_uleb128 (buf, &len, buf + i + 1);
8968 assert (len == i + 1);
8969 offset = offset * 8 + 0x408;
8970 printf (_("sp = sp + %ld"), offset);
8971 }
8972 else if ((op & 0xf0) == 0xe0)
8973 {
8974 if ((op & 0x0f) == 7)
8975 printf (" RETURN");
8976 else
8977 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8978 }
8979 else
8980 {
8981 printf (_(" [unsupported opcode]"));
8982 }
8983 putchar ('\n');
8984 }
8985
8986 return TRUE;
8987}
8988
8989static bfd_vma
8990arm_expand_prel31 (Filedata * filedata, bfd_vma word, bfd_vma where)
8991{
8992 bfd_vma offset;
8993
8994 offset = word & 0x7fffffff;
8995 if (offset & 0x40000000)
8996 offset |= ~ (bfd_vma) 0x7fffffff;
8997
8998 if (filedata->file_header.e_machine == EM_TI_C6000)
8999 offset <<= 1;
9000
9001 return offset + where;
9002}
9003
9004static bfd_boolean
9005decode_arm_unwind (Filedata * filedata,
9006 struct arm_unw_aux_info * aux,
9007 unsigned int word,
9008 unsigned int remaining,
9009 bfd_vma data_offset,
9010 Elf_Internal_Shdr * data_sec,
9011 struct arm_section * data_arm_sec)
9012{
9013 int per_index;
9014 unsigned int more_words = 0;
9015 struct absaddr addr;
9016 bfd_vma sym_name = (bfd_vma) -1;
9017 bfd_boolean res = TRUE;
9018
9019 if (remaining == 0)
9020 {
9021 /* Fetch the first word.
9022 Note - when decoding an object file the address extracted
9023 here will always be 0. So we also pass in the sym_name
9024 parameter so that we can find the symbol associated with
9025 the personality routine. */
9026 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, data_offset,
9027 & word, & addr, & sym_name))
9028 return FALSE;
9029
9030 remaining = 4;
9031 }
9032 else
9033 {
9034 addr.section = SHN_UNDEF;
9035 addr.offset = 0;
9036 }
9037
9038 if ((word & 0x80000000) == 0)
9039 {
9040 /* Expand prel31 for personality routine. */
9041 bfd_vma fn;
9042 const char *procname;
9043
9044 fn = arm_expand_prel31 (filedata, word, data_sec->sh_addr + data_offset);
9045 printf (_(" Personality routine: "));
9046 if (fn == 0
9047 && addr.section == SHN_UNDEF && addr.offset == 0
9048 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
9049 {
9050 procname = aux->strtab + sym_name;
9051 print_vma (fn, PREFIX_HEX);
9052 if (procname)
9053 {
9054 fputs (" <", stdout);
9055 fputs (procname, stdout);
9056 fputc ('>', stdout);
9057 }
9058 }
9059 else
9060 procname = arm_print_vma_and_name (filedata, aux, fn, addr);
9061 fputc ('\n', stdout);
9062
9063 /* The GCC personality routines use the standard compact
9064 encoding, starting with one byte giving the number of
9065 words. */
9066 if (procname != NULL
9067 && (const_strneq (procname, "__gcc_personality_v0")
9068 || const_strneq (procname, "__gxx_personality_v0")
9069 || const_strneq (procname, "__gcj_personality_v0")
9070 || const_strneq (procname, "__gnu_objc_personality_v0")))
9071 {
9072 remaining = 0;
9073 more_words = 1;
9074 ADVANCE;
9075 if (!remaining)
9076 {
9077 printf (_(" [Truncated data]\n"));
9078 return FALSE;
9079 }
9080 more_words = word >> 24;
9081 word <<= 8;
9082 remaining--;
9083 per_index = -1;
9084 }
9085 else
9086 return TRUE;
9087 }
9088 else
9089 {
9090 /* ARM EHABI Section 6.3:
9091
9092 An exception-handling table entry for the compact model looks like:
9093
9094 31 30-28 27-24 23-0
9095 -- ----- ----- ----
9096 1 0 index Data for personalityRoutine[index] */
9097
9098 if (filedata->file_header.e_machine == EM_ARM
9099 && (word & 0x70000000))
9100 {
9101 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
9102 res = FALSE;
9103 }
9104
9105 per_index = (word >> 24) & 0x7f;
9106 printf (_(" Compact model index: %d\n"), per_index);
9107 if (per_index == 0)
9108 {
9109 more_words = 0;
9110 word <<= 8;
9111 remaining--;
9112 }
9113 else if (per_index < 3)
9114 {
9115 more_words = (word >> 16) & 0xff;
9116 word <<= 16;
9117 remaining -= 2;
9118 }
9119 }
9120
9121 switch (filedata->file_header.e_machine)
9122 {
9123 case EM_ARM:
9124 if (per_index < 3)
9125 {
9126 if (! decode_arm_unwind_bytecode (filedata, aux, word, remaining, more_words,
9127 data_offset, data_sec, data_arm_sec))
9128 res = FALSE;
9129 }
9130 else
9131 {
9132 warn (_("Unknown ARM compact model index encountered\n"));
9133 printf (_(" [reserved]\n"));
9134 res = FALSE;
9135 }
9136 break;
9137
9138 case EM_TI_C6000:
9139 if (per_index < 3)
9140 {
9141 if (! decode_tic6x_unwind_bytecode (filedata, aux, word, remaining, more_words,
9142 data_offset, data_sec, data_arm_sec))
9143 res = FALSE;
9144 }
9145 else if (per_index < 5)
9146 {
9147 if (((word >> 17) & 0x7f) == 0x7f)
9148 printf (_(" Restore stack from frame pointer\n"));
9149 else
9150 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
9151 printf (_(" Registers restored: "));
9152 if (per_index == 4)
9153 printf (" (compact) ");
9154 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
9155 putchar ('\n');
9156 printf (_(" Return register: %s\n"),
9157 tic6x_unwind_regnames[word & 0xf]);
9158 }
9159 else
9160 printf (_(" [reserved (%d)]\n"), per_index);
9161 break;
9162
9163 default:
9164 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9165 filedata->file_header.e_machine);
9166 res = FALSE;
9167 }
9168
9169 /* Decode the descriptors. Not implemented. */
9170
9171 return res;
9172}
9173
9174static bfd_boolean
9175dump_arm_unwind (Filedata * filedata,
9176 struct arm_unw_aux_info * aux,
9177 Elf_Internal_Shdr * exidx_sec)
9178{
9179 struct arm_section exidx_arm_sec, extab_arm_sec;
9180 unsigned int i, exidx_len;
9181 unsigned long j, nfuns;
9182 bfd_boolean res = TRUE;
9183
9184 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
9185 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
9186 exidx_len = exidx_sec->sh_size / 8;
9187
9188 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
9189 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
9190 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
9191 aux->funtab[nfuns++] = aux->symtab[j];
9192 aux->nfuns = nfuns;
9193 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
9194
9195 for (i = 0; i < exidx_len; i++)
9196 {
9197 unsigned int exidx_fn, exidx_entry;
9198 struct absaddr fn_addr, entry_addr;
9199 bfd_vma fn;
9200
9201 fputc ('\n', stdout);
9202
9203 if (! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9204 8 * i, & exidx_fn, & fn_addr, NULL)
9205 || ! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9206 8 * i + 4, & exidx_entry, & entry_addr, NULL))
9207 {
9208 free (aux->funtab);
9209 arm_free_section (& exidx_arm_sec);
9210 arm_free_section (& extab_arm_sec);
9211 return FALSE;
9212 }
9213
9214 /* ARM EHABI, Section 5:
9215 An index table entry consists of 2 words.
9216 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9217 if (exidx_fn & 0x80000000)
9218 {
9219 warn (_("corrupt index table entry: %x\n"), exidx_fn);
9220 res = FALSE;
9221 }
9222
9223 fn = arm_expand_prel31 (filedata, exidx_fn, exidx_sec->sh_addr + 8 * i);
9224
9225 arm_print_vma_and_name (filedata, aux, fn, fn_addr);
9226 fputs (": ", stdout);
9227
9228 if (exidx_entry == 1)
9229 {
9230 print_vma (exidx_entry, PREFIX_HEX);
9231 fputs (" [cantunwind]\n", stdout);
9232 }
9233 else if (exidx_entry & 0x80000000)
9234 {
9235 print_vma (exidx_entry, PREFIX_HEX);
9236 fputc ('\n', stdout);
9237 decode_arm_unwind (filedata, aux, exidx_entry, 4, 0, NULL, NULL);
9238 }
9239 else
9240 {
9241 bfd_vma table, table_offset = 0;
9242 Elf_Internal_Shdr *table_sec;
9243
9244 fputs ("@", stdout);
9245 table = arm_expand_prel31 (filedata, exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
9246 print_vma (table, PREFIX_HEX);
9247 printf ("\n");
9248
9249 /* Locate the matching .ARM.extab. */
9250 if (entry_addr.section != SHN_UNDEF
9251 && entry_addr.section < filedata->file_header.e_shnum)
9252 {
9253 table_sec = filedata->section_headers + entry_addr.section;
9254 table_offset = entry_addr.offset;
9255 /* PR 18879 */
9256 if (table_offset > table_sec->sh_size
9257 || ((bfd_signed_vma) table_offset) < 0)
9258 {
9259 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9260 (unsigned long) table_offset,
9261 printable_section_name (filedata, table_sec));
9262 res = FALSE;
9263 continue;
9264 }
9265 }
9266 else
9267 {
9268 table_sec = find_section_by_address (filedata, table);
9269 if (table_sec != NULL)
9270 table_offset = table - table_sec->sh_addr;
9271 }
9272
9273 if (table_sec == NULL)
9274 {
9275 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9276 (unsigned long) table);
9277 res = FALSE;
9278 continue;
9279 }
9280
9281 if (! decode_arm_unwind (filedata, aux, 0, 0, table_offset, table_sec,
9282 &extab_arm_sec))
9283 res = FALSE;
9284 }
9285 }
9286
9287 printf ("\n");
9288
9289 free (aux->funtab);
9290 arm_free_section (&exidx_arm_sec);
9291 arm_free_section (&extab_arm_sec);
9292
9293 return res;
9294}
9295
9296/* Used for both ARM and C6X unwinding tables. */
9297
9298static bfd_boolean
9299arm_process_unwind (Filedata * filedata)
9300{
9301 struct arm_unw_aux_info aux;
9302 Elf_Internal_Shdr *unwsec = NULL;
9303 Elf_Internal_Shdr *strsec;
9304 Elf_Internal_Shdr *sec;
9305 unsigned long i;
9306 unsigned int sec_type;
9307 bfd_boolean res = TRUE;
9308
9309 switch (filedata->file_header.e_machine)
9310 {
9311 case EM_ARM:
9312 sec_type = SHT_ARM_EXIDX;
9313 break;
9314
9315 case EM_TI_C6000:
9316 sec_type = SHT_C6000_UNWIND;
9317 break;
9318
9319 default:
9320 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9321 filedata->file_header.e_machine);
9322 return FALSE;
9323 }
9324
9325 if (filedata->string_table == NULL)
9326 return FALSE;
9327
9328 memset (& aux, 0, sizeof (aux));
9329 aux.filedata = filedata;
9330
9331 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9332 {
9333 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < filedata->file_header.e_shnum)
9334 {
9335 aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
9336
9337 strsec = filedata->section_headers + sec->sh_link;
9338
9339 /* PR binutils/17531 file: 011-12666-0.004. */
9340 if (aux.strtab != NULL)
9341 {
9342 error (_("Multiple string tables found in file.\n"));
9343 free (aux.strtab);
9344 res = FALSE;
9345 }
9346 aux.strtab = get_data (NULL, filedata, strsec->sh_offset,
9347 1, strsec->sh_size, _("string table"));
9348 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9349 }
9350 else if (sec->sh_type == sec_type)
9351 unwsec = sec;
9352 }
9353
9354 if (unwsec == NULL)
9355 printf (_("\nThere are no unwind sections in this file.\n"));
9356 else
9357 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9358 {
9359 if (sec->sh_type == sec_type)
9360 {
9361 unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size);
9362 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9363 "contains %lu entry:\n",
9364 "\nUnwind section '%s' at offset 0x%lx "
9365 "contains %lu entries:\n",
9366 num_unwind),
9367 printable_section_name (filedata, sec),
9368 (unsigned long) sec->sh_offset,
9369 num_unwind);
9370
9371 if (! dump_arm_unwind (filedata, &aux, sec))
9372 res = FALSE;
9373 }
9374 }
9375
9376 if (aux.symtab)
9377 free (aux.symtab);
9378 if (aux.strtab)
9379 free ((char *) aux.strtab);
9380
9381 return res;
9382}
9383
9384static bfd_boolean
9385process_unwind (Filedata * filedata)
9386{
9387 struct unwind_handler
9388 {
9389 unsigned int machtype;
9390 bfd_boolean (* handler)(Filedata *);
9391 } handlers[] =
9392 {
9393 { EM_ARM, arm_process_unwind },
9394 { EM_IA_64, ia64_process_unwind },
9395 { EM_PARISC, hppa_process_unwind },
9396 { EM_TI_C6000, arm_process_unwind },
9397 { 0, NULL }
9398 };
9399 int i;
9400
9401 if (!do_unwind)
9402 return TRUE;
9403
9404 for (i = 0; handlers[i].handler != NULL; i++)
9405 if (filedata->file_header.e_machine == handlers[i].machtype)
9406 return handlers[i].handler (filedata);
9407
9408 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9409 get_machine_name (filedata->file_header.e_machine));
9410 return TRUE;
9411}
9412
9413static void
9414dynamic_section_aarch64_val (Elf_Internal_Dyn * entry)
9415{
9416 switch (entry->d_tag)
9417 {
9418 case DT_AARCH64_BTI_PLT:
9419 case DT_AARCH64_PAC_PLT:
9420 break;
9421 default:
9422 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9423 break;
9424 }
9425 putchar ('\n');
9426}
9427
9428static void
9429dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9430{
9431 switch (entry->d_tag)
9432 {
9433 case DT_MIPS_FLAGS:
9434 if (entry->d_un.d_val == 0)
9435 printf (_("NONE"));
9436 else
9437 {
9438 static const char * opts[] =
9439 {
9440 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9441 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9442 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9443 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9444 "RLD_ORDER_SAFE"
9445 };
9446 unsigned int cnt;
9447 bfd_boolean first = TRUE;
9448
9449 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9450 if (entry->d_un.d_val & (1 << cnt))
9451 {
9452 printf ("%s%s", first ? "" : " ", opts[cnt]);
9453 first = FALSE;
9454 }
9455 }
9456 break;
9457
9458 case DT_MIPS_IVERSION:
9459 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9460 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9461 else
9462 {
9463 char buf[40];
9464 sprintf_vma (buf, entry->d_un.d_ptr);
9465 /* Note: coded this way so that there is a single string for translation. */
9466 printf (_("<corrupt: %s>"), buf);
9467 }
9468 break;
9469
9470 case DT_MIPS_TIME_STAMP:
9471 {
9472 char timebuf[128];
9473 struct tm * tmp;
9474 time_t atime = entry->d_un.d_val;
9475
9476 tmp = gmtime (&atime);
9477 /* PR 17531: file: 6accc532. */
9478 if (tmp == NULL)
9479 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9480 else
9481 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9482 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9483 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9484 printf (_("Time Stamp: %s"), timebuf);
9485 }
9486 break;
9487
9488 case DT_MIPS_RLD_VERSION:
9489 case DT_MIPS_LOCAL_GOTNO:
9490 case DT_MIPS_CONFLICTNO:
9491 case DT_MIPS_LIBLISTNO:
9492 case DT_MIPS_SYMTABNO:
9493 case DT_MIPS_UNREFEXTNO:
9494 case DT_MIPS_HIPAGENO:
9495 case DT_MIPS_DELTA_CLASS_NO:
9496 case DT_MIPS_DELTA_INSTANCE_NO:
9497 case DT_MIPS_DELTA_RELOC_NO:
9498 case DT_MIPS_DELTA_SYM_NO:
9499 case DT_MIPS_DELTA_CLASSSYM_NO:
9500 case DT_MIPS_COMPACT_SIZE:
9501 print_vma (entry->d_un.d_val, DEC);
9502 break;
9503
9504 default:
9505 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9506 }
9507 putchar ('\n');
9508}
9509
9510static void
9511dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9512{
9513 switch (entry->d_tag)
9514 {
9515 case DT_HP_DLD_FLAGS:
9516 {
9517 static struct
9518 {
9519 long int bit;
9520 const char * str;
9521 }
9522 flags[] =
9523 {
9524 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9525 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9526 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9527 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9528 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9529 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9530 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9531 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9532 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9533 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9534 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9535 { DT_HP_GST, "HP_GST" },
9536 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9537 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9538 { DT_HP_NODELETE, "HP_NODELETE" },
9539 { DT_HP_GROUP, "HP_GROUP" },
9540 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9541 };
9542 bfd_boolean first = TRUE;
9543 size_t cnt;
9544 bfd_vma val = entry->d_un.d_val;
9545
9546 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9547 if (val & flags[cnt].bit)
9548 {
9549 if (! first)
9550 putchar (' ');
9551 fputs (flags[cnt].str, stdout);
9552 first = FALSE;
9553 val ^= flags[cnt].bit;
9554 }
9555
9556 if (val != 0 || first)
9557 {
9558 if (! first)
9559 putchar (' ');
9560 print_vma (val, HEX);
9561 }
9562 }
9563 break;
9564
9565 default:
9566 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9567 break;
9568 }
9569 putchar ('\n');
9570}
9571
9572#ifdef BFD64
9573
9574/* VMS vs Unix time offset and factor. */
9575
9576#define VMS_EPOCH_OFFSET 35067168000000000LL
9577#define VMS_GRANULARITY_FACTOR 10000000
9578
9579/* Display a VMS time in a human readable format. */
9580
9581static void
9582print_vms_time (bfd_int64_t vmstime)
9583{
9584 struct tm *tm;
9585 time_t unxtime;
9586
9587 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9588 tm = gmtime (&unxtime);
9589 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9590 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9591 tm->tm_hour, tm->tm_min, tm->tm_sec);
9592}
9593#endif /* BFD64 */
9594
9595static void
9596dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9597{
9598 switch (entry->d_tag)
9599 {
9600 case DT_IA_64_PLT_RESERVE:
9601 /* First 3 slots reserved. */
9602 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9603 printf (" -- ");
9604 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9605 break;
9606
9607 case DT_IA_64_VMS_LINKTIME:
9608#ifdef BFD64
9609 print_vms_time (entry->d_un.d_val);
9610#endif
9611 break;
9612
9613 case DT_IA_64_VMS_LNKFLAGS:
9614 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9615 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9616 printf (" CALL_DEBUG");
9617 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9618 printf (" NOP0BUFS");
9619 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9620 printf (" P0IMAGE");
9621 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9622 printf (" MKTHREADS");
9623 if (entry->d_un.d_val & VMS_LF_UPCALLS)
9624 printf (" UPCALLS");
9625 if (entry->d_un.d_val & VMS_LF_IMGSTA)
9626 printf (" IMGSTA");
9627 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9628 printf (" INITIALIZE");
9629 if (entry->d_un.d_val & VMS_LF_MAIN)
9630 printf (" MAIN");
9631 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9632 printf (" EXE_INIT");
9633 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9634 printf (" TBK_IN_IMG");
9635 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9636 printf (" DBG_IN_IMG");
9637 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9638 printf (" TBK_IN_DSF");
9639 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9640 printf (" DBG_IN_DSF");
9641 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9642 printf (" SIGNATURES");
9643 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9644 printf (" REL_SEG_OFF");
9645 break;
9646
9647 default:
9648 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9649 break;
9650 }
9651 putchar ('\n');
9652}
9653
9654static bfd_boolean
9655get_32bit_dynamic_section (Filedata * filedata)
9656{
9657 Elf32_External_Dyn * edyn;
9658 Elf32_External_Dyn * ext;
9659 Elf_Internal_Dyn * entry;
9660
9661 edyn = (Elf32_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9662 dynamic_size, _("dynamic section"));
9663 if (!edyn)
9664 return FALSE;
9665
9666 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9667 might not have the luxury of section headers. Look for the DT_NULL
9668 terminator to determine the number of entries. */
9669 for (ext = edyn, dynamic_nent = 0;
9670 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9671 ext++)
9672 {
9673 dynamic_nent++;
9674 if (BYTE_GET (ext->d_tag) == DT_NULL)
9675 break;
9676 }
9677
9678 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9679 sizeof (* entry));
9680 if (dynamic_section == NULL)
9681 {
9682 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9683 (unsigned long) dynamic_nent);
9684 free (edyn);
9685 return FALSE;
9686 }
9687
9688 for (ext = edyn, entry = dynamic_section;
9689 entry < dynamic_section + dynamic_nent;
9690 ext++, entry++)
9691 {
9692 entry->d_tag = BYTE_GET (ext->d_tag);
9693 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9694 }
9695
9696 free (edyn);
9697
9698 return TRUE;
9699}
9700
9701static bfd_boolean
9702get_64bit_dynamic_section (Filedata * filedata)
9703{
9704 Elf64_External_Dyn * edyn;
9705 Elf64_External_Dyn * ext;
9706 Elf_Internal_Dyn * entry;
9707
9708 /* Read in the data. */
9709 edyn = (Elf64_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9710 dynamic_size, _("dynamic section"));
9711 if (!edyn)
9712 return FALSE;
9713
9714 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9715 might not have the luxury of section headers. Look for the DT_NULL
9716 terminator to determine the number of entries. */
9717 for (ext = edyn, dynamic_nent = 0;
9718 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9719 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9720 ext++)
9721 {
9722 dynamic_nent++;
9723 if (BYTE_GET (ext->d_tag) == DT_NULL)
9724 break;
9725 }
9726
9727 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9728 sizeof (* entry));
9729 if (dynamic_section == NULL)
9730 {
9731 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9732 (unsigned long) dynamic_nent);
9733 free (edyn);
9734 return FALSE;
9735 }
9736
9737 /* Convert from external to internal formats. */
9738 for (ext = edyn, entry = dynamic_section;
9739 entry < dynamic_section + dynamic_nent;
9740 ext++, entry++)
9741 {
9742 entry->d_tag = BYTE_GET (ext->d_tag);
9743 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9744 }
9745
9746 free (edyn);
9747
9748 return TRUE;
9749}
9750
9751static void
9752print_dynamic_flags (bfd_vma flags)
9753{
9754 bfd_boolean first = TRUE;
9755
9756 while (flags)
9757 {
9758 bfd_vma flag;
9759
9760 flag = flags & - flags;
9761 flags &= ~ flag;
9762
9763 if (first)
9764 first = FALSE;
9765 else
9766 putc (' ', stdout);
9767
9768 switch (flag)
9769 {
9770 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
9771 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
9772 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
9773 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
9774 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
9775 default: fputs (_("unknown"), stdout); break;
9776 }
9777 }
9778 puts ("");
9779}
9780
9781/* Parse and display the contents of the dynamic section. */
9782
9783static bfd_boolean
9784process_dynamic_section (Filedata * filedata)
9785{
9786 Elf_Internal_Dyn * entry;
9787
9788 if (dynamic_size == 0)
9789 {
9790 if (do_dynamic)
9791 printf (_("\nThere is no dynamic section in this file.\n"));
9792
9793 return TRUE;
9794 }
9795
9796 if (is_32bit_elf)
9797 {
9798 if (! get_32bit_dynamic_section (filedata))
9799 return FALSE;
9800 }
9801 else
9802 {
9803 if (! get_64bit_dynamic_section (filedata))
9804 return FALSE;
9805 }
9806
9807 /* Find the appropriate symbol table. */
9808 if (dynamic_symbols == NULL)
9809 {
9810 for (entry = dynamic_section;
9811 entry < dynamic_section + dynamic_nent;
9812 ++entry)
9813 {
9814 Elf_Internal_Shdr section;
9815
9816 if (entry->d_tag != DT_SYMTAB)
9817 continue;
9818
9819 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9820
9821 /* Since we do not know how big the symbol table is,
9822 we default to reading in the entire file (!) and
9823 processing that. This is overkill, I know, but it
9824 should work. */
9825 section.sh_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9826 if ((bfd_size_type) section.sh_offset > filedata->file_size)
9827 {
9828 /* See PR 21379 for a reproducer. */
9829 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9830 return FALSE;
9831 }
9832
9833 if (archive_file_offset != 0)
9834 section.sh_size = archive_file_size - section.sh_offset;
9835 else
9836 section.sh_size = filedata->file_size - section.sh_offset;
9837
9838 if (is_32bit_elf)
9839 section.sh_entsize = sizeof (Elf32_External_Sym);
9840 else
9841 section.sh_entsize = sizeof (Elf64_External_Sym);
9842 section.sh_name = filedata->string_table_length;
9843
9844 if (dynamic_symbols != NULL)
9845 {
9846 error (_("Multiple dynamic symbol table sections found\n"));
9847 free (dynamic_symbols);
9848 }
9849 dynamic_symbols = GET_ELF_SYMBOLS (filedata, &section, & num_dynamic_syms);
9850 if (num_dynamic_syms < 1)
9851 {
9852 error (_("Unable to determine the number of symbols to load\n"));
9853 continue;
9854 }
9855 }
9856 }
9857
9858 /* Similarly find a string table. */
9859 if (dynamic_strings == NULL)
9860 {
9861 for (entry = dynamic_section;
9862 entry < dynamic_section + dynamic_nent;
9863 ++entry)
9864 {
9865 unsigned long offset;
9866 long str_tab_len;
9867
9868 if (entry->d_tag != DT_STRTAB)
9869 continue;
9870
9871 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9872
9873 /* Since we do not know how big the string table is,
9874 we default to reading in the entire file (!) and
9875 processing that. This is overkill, I know, but it
9876 should work. */
9877
9878 offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9879
9880 if (archive_file_offset != 0)
9881 str_tab_len = archive_file_size - offset;
9882 else
9883 str_tab_len = filedata->file_size - offset;
9884
9885 if (str_tab_len < 1)
9886 {
9887 error
9888 (_("Unable to determine the length of the dynamic string table\n"));
9889 continue;
9890 }
9891
9892 if (dynamic_strings != NULL)
9893 {
9894 error (_("Multiple dynamic string tables found\n"));
9895 free (dynamic_strings);
9896 }
9897
9898 dynamic_strings = (char *) get_data (NULL, filedata, offset, 1,
9899 str_tab_len,
9900 _("dynamic string table"));
9901 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9902 }
9903 }
9904
9905 /* And find the syminfo section if available. */
9906 if (dynamic_syminfo == NULL)
9907 {
9908 unsigned long syminsz = 0;
9909
9910 for (entry = dynamic_section;
9911 entry < dynamic_section + dynamic_nent;
9912 ++entry)
9913 {
9914 if (entry->d_tag == DT_SYMINENT)
9915 {
9916 /* Note: these braces are necessary to avoid a syntax
9917 error from the SunOS4 C compiler. */
9918 /* PR binutils/17531: A corrupt file can trigger this test.
9919 So do not use an assert, instead generate an error message. */
9920 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9921 error (_("Bad value (%d) for SYMINENT entry\n"),
9922 (int) entry->d_un.d_val);
9923 }
9924 else if (entry->d_tag == DT_SYMINSZ)
9925 syminsz = entry->d_un.d_val;
9926 else if (entry->d_tag == DT_SYMINFO)
9927 dynamic_syminfo_offset = offset_from_vma (filedata, entry->d_un.d_val,
9928 syminsz);
9929 }
9930
9931 if (dynamic_syminfo_offset != 0 && syminsz != 0)
9932 {
9933 Elf_External_Syminfo * extsyminfo;
9934 Elf_External_Syminfo * extsym;
9935 Elf_Internal_Syminfo * syminfo;
9936
9937 /* There is a syminfo section. Read the data. */
9938 extsyminfo = (Elf_External_Syminfo *)
9939 get_data (NULL, filedata, dynamic_syminfo_offset, 1, syminsz,
9940 _("symbol information"));
9941 if (!extsyminfo)
9942 return FALSE;
9943
9944 if (dynamic_syminfo != NULL)
9945 {
9946 error (_("Multiple dynamic symbol information sections found\n"));
9947 free (dynamic_syminfo);
9948 }
9949 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9950 if (dynamic_syminfo == NULL)
9951 {
9952 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9953 (unsigned long) syminsz);
9954 return FALSE;
9955 }
9956
9957 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9958 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9959 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9960 ++syminfo, ++extsym)
9961 {
9962 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9963 syminfo->si_flags = BYTE_GET (extsym->si_flags);
9964 }
9965
9966 free (extsyminfo);
9967 }
9968 }
9969
9970 if (do_dynamic && dynamic_addr)
9971 printf (ngettext ("\nDynamic section at offset 0x%lx "
9972 "contains %lu entry:\n",
9973 "\nDynamic section at offset 0x%lx "
9974 "contains %lu entries:\n",
9975 dynamic_nent),
9976 dynamic_addr, (unsigned long) dynamic_nent);
9977 if (do_dynamic)
9978 printf (_(" Tag Type Name/Value\n"));
9979
9980 for (entry = dynamic_section;
9981 entry < dynamic_section + dynamic_nent;
9982 entry++)
9983 {
9984 if (do_dynamic)
9985 {
9986 const char * dtype;
9987
9988 putchar (' ');
9989 print_vma (entry->d_tag, FULL_HEX);
9990 dtype = get_dynamic_type (filedata, entry->d_tag);
9991 printf (" (%s)%*s", dtype,
9992 ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
9993 }
9994
9995 switch (entry->d_tag)
9996 {
9997 case DT_FLAGS:
9998 if (do_dynamic)
9999 print_dynamic_flags (entry->d_un.d_val);
10000 break;
10001
10002 case DT_AUXILIARY:
10003 case DT_FILTER:
10004 case DT_CONFIG:
10005 case DT_DEPAUDIT:
10006 case DT_AUDIT:
10007 if (do_dynamic)
10008 {
10009 switch (entry->d_tag)
10010 {
10011 case DT_AUXILIARY:
10012 printf (_("Auxiliary library"));
10013 break;
10014
10015 case DT_FILTER:
10016 printf (_("Filter library"));
10017 break;
10018
10019 case DT_CONFIG:
10020 printf (_("Configuration file"));
10021 break;
10022
10023 case DT_DEPAUDIT:
10024 printf (_("Dependency audit library"));
10025 break;
10026
10027 case DT_AUDIT:
10028 printf (_("Audit library"));
10029 break;
10030 }
10031
10032 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10033 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
10034 else
10035 {
10036 printf (": ");
10037 print_vma (entry->d_un.d_val, PREFIX_HEX);
10038 putchar ('\n');
10039 }
10040 }
10041 break;
10042
10043 case DT_FEATURE:
10044 if (do_dynamic)
10045 {
10046 printf (_("Flags:"));
10047
10048 if (entry->d_un.d_val == 0)
10049 printf (_(" None\n"));
10050 else
10051 {
10052 unsigned long int val = entry->d_un.d_val;
10053
10054 if (val & DTF_1_PARINIT)
10055 {
10056 printf (" PARINIT");
10057 val ^= DTF_1_PARINIT;
10058 }
10059 if (val & DTF_1_CONFEXP)
10060 {
10061 printf (" CONFEXP");
10062 val ^= DTF_1_CONFEXP;
10063 }
10064 if (val != 0)
10065 printf (" %lx", val);
10066 puts ("");
10067 }
10068 }
10069 break;
10070
10071 case DT_POSFLAG_1:
10072 if (do_dynamic)
10073 {
10074 printf (_("Flags:"));
10075
10076 if (entry->d_un.d_val == 0)
10077 printf (_(" None\n"));
10078 else
10079 {
10080 unsigned long int val = entry->d_un.d_val;
10081
10082 if (val & DF_P1_LAZYLOAD)
10083 {
10084 printf (" LAZYLOAD");
10085 val ^= DF_P1_LAZYLOAD;
10086 }
10087 if (val & DF_P1_GROUPPERM)
10088 {
10089 printf (" GROUPPERM");
10090 val ^= DF_P1_GROUPPERM;
10091 }
10092 if (val != 0)
10093 printf (" %lx", val);
10094 puts ("");
10095 }
10096 }
10097 break;
10098
10099 case DT_FLAGS_1:
10100 if (do_dynamic)
10101 {
10102 printf (_("Flags:"));
10103 if (entry->d_un.d_val == 0)
10104 printf (_(" None\n"));
10105 else
10106 {
10107 unsigned long int val = entry->d_un.d_val;
10108
10109 if (val & DF_1_NOW)
10110 {
10111 printf (" NOW");
10112 val ^= DF_1_NOW;
10113 }
10114 if (val & DF_1_GLOBAL)
10115 {
10116 printf (" GLOBAL");
10117 val ^= DF_1_GLOBAL;
10118 }
10119 if (val & DF_1_GROUP)
10120 {
10121 printf (" GROUP");
10122 val ^= DF_1_GROUP;
10123 }
10124 if (val & DF_1_NODELETE)
10125 {
10126 printf (" NODELETE");
10127 val ^= DF_1_NODELETE;
10128 }
10129 if (val & DF_1_LOADFLTR)
10130 {
10131 printf (" LOADFLTR");
10132 val ^= DF_1_LOADFLTR;
10133 }
10134 if (val & DF_1_INITFIRST)
10135 {
10136 printf (" INITFIRST");
10137 val ^= DF_1_INITFIRST;
10138 }
10139 if (val & DF_1_NOOPEN)
10140 {
10141 printf (" NOOPEN");
10142 val ^= DF_1_NOOPEN;
10143 }
10144 if (val & DF_1_ORIGIN)
10145 {
10146 printf (" ORIGIN");
10147 val ^= DF_1_ORIGIN;
10148 }
10149 if (val & DF_1_DIRECT)
10150 {
10151 printf (" DIRECT");
10152 val ^= DF_1_DIRECT;
10153 }
10154 if (val & DF_1_TRANS)
10155 {
10156 printf (" TRANS");
10157 val ^= DF_1_TRANS;
10158 }
10159 if (val & DF_1_INTERPOSE)
10160 {
10161 printf (" INTERPOSE");
10162 val ^= DF_1_INTERPOSE;
10163 }
10164 if (val & DF_1_NODEFLIB)
10165 {
10166 printf (" NODEFLIB");
10167 val ^= DF_1_NODEFLIB;
10168 }
10169 if (val & DF_1_NODUMP)
10170 {
10171 printf (" NODUMP");
10172 val ^= DF_1_NODUMP;
10173 }
10174 if (val & DF_1_CONFALT)
10175 {
10176 printf (" CONFALT");
10177 val ^= DF_1_CONFALT;
10178 }
10179 if (val & DF_1_ENDFILTEE)
10180 {
10181 printf (" ENDFILTEE");
10182 val ^= DF_1_ENDFILTEE;
10183 }
10184 if (val & DF_1_DISPRELDNE)
10185 {
10186 printf (" DISPRELDNE");
10187 val ^= DF_1_DISPRELDNE;
10188 }
10189 if (val & DF_1_DISPRELPND)
10190 {
10191 printf (" DISPRELPND");
10192 val ^= DF_1_DISPRELPND;
10193 }
10194 if (val & DF_1_NODIRECT)
10195 {
10196 printf (" NODIRECT");
10197 val ^= DF_1_NODIRECT;
10198 }
10199 if (val & DF_1_IGNMULDEF)
10200 {
10201 printf (" IGNMULDEF");
10202 val ^= DF_1_IGNMULDEF;
10203 }
10204 if (val & DF_1_NOKSYMS)
10205 {
10206 printf (" NOKSYMS");
10207 val ^= DF_1_NOKSYMS;
10208 }
10209 if (val & DF_1_NOHDR)
10210 {
10211 printf (" NOHDR");
10212 val ^= DF_1_NOHDR;
10213 }
10214 if (val & DF_1_EDITED)
10215 {
10216 printf (" EDITED");
10217 val ^= DF_1_EDITED;
10218 }
10219 if (val & DF_1_NORELOC)
10220 {
10221 printf (" NORELOC");
10222 val ^= DF_1_NORELOC;
10223 }
10224 if (val & DF_1_SYMINTPOSE)
10225 {
10226 printf (" SYMINTPOSE");
10227 val ^= DF_1_SYMINTPOSE;
10228 }
10229 if (val & DF_1_GLOBAUDIT)
10230 {
10231 printf (" GLOBAUDIT");
10232 val ^= DF_1_GLOBAUDIT;
10233 }
10234 if (val & DF_1_SINGLETON)
10235 {
10236 printf (" SINGLETON");
10237 val ^= DF_1_SINGLETON;
10238 }
10239 if (val & DF_1_STUB)
10240 {
10241 printf (" STUB");
10242 val ^= DF_1_STUB;
10243 }
10244 if (val & DF_1_PIE)
10245 {
10246 printf (" PIE");
10247 val ^= DF_1_PIE;
10248 }
10249 if (val & DF_1_KMOD)
10250 {
10251 printf (" KMOD");
10252 val ^= DF_1_KMOD;
10253 }
10254 if (val & DF_1_WEAKFILTER)
10255 {
10256 printf (" WEAKFILTER");
10257 val ^= DF_1_WEAKFILTER;
10258 }
10259 if (val & DF_1_NOCOMMON)
10260 {
10261 printf (" NOCOMMON");
10262 val ^= DF_1_NOCOMMON;
10263 }
10264 if (val != 0)
10265 printf (" %lx", val);
10266 puts ("");
10267 }
10268 }
10269 break;
10270
10271 case DT_PLTREL:
10272 dynamic_info[entry->d_tag] = entry->d_un.d_val;
10273 if (do_dynamic)
10274 puts (get_dynamic_type (filedata, entry->d_un.d_val));
10275 break;
10276
10277 case DT_NULL :
10278 case DT_NEEDED :
10279 case DT_PLTGOT :
10280 case DT_HASH :
10281 case DT_STRTAB :
10282 case DT_SYMTAB :
10283 case DT_RELA :
10284 case DT_INIT :
10285 case DT_FINI :
10286 case DT_SONAME :
10287 case DT_RPATH :
10288 case DT_SYMBOLIC:
10289 case DT_REL :
10290 case DT_DEBUG :
10291 case DT_TEXTREL :
10292 case DT_JMPREL :
10293 case DT_RUNPATH :
10294 dynamic_info[entry->d_tag] = entry->d_un.d_val;
10295
10296 if (do_dynamic)
10297 {
10298 char * name;
10299
10300 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10301 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10302 else
10303 name = NULL;
10304
10305 if (name)
10306 {
10307 switch (entry->d_tag)
10308 {
10309 case DT_NEEDED:
10310 printf (_("Shared library: [%s]"), name);
10311
10312 if (streq (name, program_interpreter))
10313 printf (_(" program interpreter"));
10314 break;
10315
10316 case DT_SONAME:
10317 printf (_("Library soname: [%s]"), name);
10318 break;
10319
10320 case DT_RPATH:
10321 printf (_("Library rpath: [%s]"), name);
10322 break;
10323
10324 case DT_RUNPATH:
10325 printf (_("Library runpath: [%s]"), name);
10326 break;
10327
10328 default:
10329 print_vma (entry->d_un.d_val, PREFIX_HEX);
10330 break;
10331 }
10332 }
10333 else
10334 print_vma (entry->d_un.d_val, PREFIX_HEX);
10335
10336 putchar ('\n');
10337 }
10338 break;
10339
10340 case DT_PLTRELSZ:
10341 case DT_RELASZ :
10342 case DT_STRSZ :
10343 case DT_RELSZ :
10344 case DT_RELAENT :
10345 case DT_SYMENT :
10346 case DT_RELENT :
10347 dynamic_info[entry->d_tag] = entry->d_un.d_val;
10348 /* Fall through. */
10349 case DT_PLTPADSZ:
10350 case DT_MOVEENT :
10351 case DT_MOVESZ :
10352 case DT_INIT_ARRAYSZ:
10353 case DT_FINI_ARRAYSZ:
10354 case DT_GNU_CONFLICTSZ:
10355 case DT_GNU_LIBLISTSZ:
10356 if (do_dynamic)
10357 {
10358 print_vma (entry->d_un.d_val, UNSIGNED);
10359 printf (_(" (bytes)\n"));
10360 }
10361 break;
10362
10363 case DT_VERDEFNUM:
10364 case DT_VERNEEDNUM:
10365 case DT_RELACOUNT:
10366 case DT_RELCOUNT:
10367 if (do_dynamic)
10368 {
10369 print_vma (entry->d_un.d_val, UNSIGNED);
10370 putchar ('\n');
10371 }
10372 break;
10373
10374 case DT_SYMINSZ:
10375 case DT_SYMINENT:
10376 case DT_SYMINFO:
10377 case DT_USED:
10378 case DT_INIT_ARRAY:
10379 case DT_FINI_ARRAY:
10380 if (do_dynamic)
10381 {
10382 if (entry->d_tag == DT_USED
10383 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
10384 {
10385 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10386
10387 if (*name)
10388 {
10389 printf (_("Not needed object: [%s]\n"), name);
10390 break;
10391 }
10392 }
10393
10394 print_vma (entry->d_un.d_val, PREFIX_HEX);
10395 putchar ('\n');
10396 }
10397 break;
10398
10399 case DT_BIND_NOW:
10400 /* The value of this entry is ignored. */
10401 if (do_dynamic)
10402 putchar ('\n');
10403 break;
10404
10405 case DT_GNU_PRELINKED:
10406 if (do_dynamic)
10407 {
10408 struct tm * tmp;
10409 time_t atime = entry->d_un.d_val;
10410
10411 tmp = gmtime (&atime);
10412 /* PR 17533 file: 041-1244816-0.004. */
10413 if (tmp == NULL)
10414 printf (_("<corrupt time val: %lx"),
10415 (unsigned long) atime);
10416 else
10417 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10418 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10419 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10420
10421 }
10422 break;
10423
10424 case DT_GNU_HASH:
10425 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10426 if (do_dynamic)
10427 {
10428 print_vma (entry->d_un.d_val, PREFIX_HEX);
10429 putchar ('\n');
10430 }
10431 break;
10432
10433 default:
10434 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10435 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10436 entry->d_un.d_val;
10437
10438 if (do_dynamic)
10439 {
10440 switch (filedata->file_header.e_machine)
10441 {
10442 case EM_AARCH64:
10443 dynamic_section_aarch64_val (entry);
10444 break;
10445 case EM_MIPS:
10446 case EM_MIPS_RS3_LE:
10447 dynamic_section_mips_val (entry);
10448 break;
10449 case EM_PARISC:
10450 dynamic_section_parisc_val (entry);
10451 break;
10452 case EM_IA_64:
10453 dynamic_section_ia64_val (entry);
10454 break;
10455 default:
10456 print_vma (entry->d_un.d_val, PREFIX_HEX);
10457 putchar ('\n');
10458 }
10459 }
10460 break;
10461 }
10462 }
10463
10464 return TRUE;
10465}
10466
10467static char *
10468get_ver_flags (unsigned int flags)
10469{
10470 static char buff[128];
10471
10472 buff[0] = 0;
10473
10474 if (flags == 0)
10475 return _("none");
10476
10477 if (flags & VER_FLG_BASE)
10478 strcat (buff, "BASE");
10479
10480 if (flags & VER_FLG_WEAK)
10481 {
10482 if (flags & VER_FLG_BASE)
10483 strcat (buff, " | ");
10484
10485 strcat (buff, "WEAK");
10486 }
10487
10488 if (flags & VER_FLG_INFO)
10489 {
10490 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10491 strcat (buff, " | ");
10492
10493 strcat (buff, "INFO");
10494 }
10495
10496 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10497 {
10498 if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10499 strcat (buff, " | ");
10500
10501 strcat (buff, _("<unknown>"));
10502 }
10503
10504 return buff;
10505}
10506
10507/* Display the contents of the version sections. */
10508
10509static bfd_boolean
10510process_version_sections (Filedata * filedata)
10511{
10512 Elf_Internal_Shdr * section;
10513 unsigned i;
10514 bfd_boolean found = FALSE;
10515
10516 if (! do_version)
10517 return TRUE;
10518
10519 for (i = 0, section = filedata->section_headers;
10520 i < filedata->file_header.e_shnum;
10521 i++, section++)
10522 {
10523 switch (section->sh_type)
10524 {
10525 case SHT_GNU_verdef:
10526 {
10527 Elf_External_Verdef * edefs;
10528 unsigned long idx;
10529 unsigned long cnt;
10530 char * endbuf;
10531
10532 found = TRUE;
10533
10534 printf (ngettext ("\nVersion definition section '%s' "
10535 "contains %u entry:\n",
10536 "\nVersion definition section '%s' "
10537 "contains %u entries:\n",
10538 section->sh_info),
10539 printable_section_name (filedata, section),
10540 section->sh_info);
10541
10542 printf (_(" Addr: 0x"));
10543 printf_vma (section->sh_addr);
10544 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10545 (unsigned long) section->sh_offset, section->sh_link,
10546 printable_section_name_from_index (filedata, section->sh_link));
10547
10548 edefs = (Elf_External_Verdef *)
10549 get_data (NULL, filedata, section->sh_offset, 1,section->sh_size,
10550 _("version definition section"));
10551 if (!edefs)
10552 break;
10553 endbuf = (char *) edefs + section->sh_size;
10554
10555 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10556 {
10557 char * vstart;
10558 Elf_External_Verdef * edef;
10559 Elf_Internal_Verdef ent;
10560 Elf_External_Verdaux * eaux;
10561 Elf_Internal_Verdaux aux;
10562 unsigned long isum;
10563 int j;
10564
10565 vstart = ((char *) edefs) + idx;
10566 if (vstart + sizeof (*edef) > endbuf)
10567 break;
10568
10569 edef = (Elf_External_Verdef *) vstart;
10570
10571 ent.vd_version = BYTE_GET (edef->vd_version);
10572 ent.vd_flags = BYTE_GET (edef->vd_flags);
10573 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
10574 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
10575 ent.vd_hash = BYTE_GET (edef->vd_hash);
10576 ent.vd_aux = BYTE_GET (edef->vd_aux);
10577 ent.vd_next = BYTE_GET (edef->vd_next);
10578
10579 printf (_(" %#06lx: Rev: %d Flags: %s"),
10580 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10581
10582 printf (_(" Index: %d Cnt: %d "),
10583 ent.vd_ndx, ent.vd_cnt);
10584
10585 /* Check for overflow. */
10586 if (ent.vd_aux > (size_t) (endbuf - vstart))
10587 break;
10588
10589 vstart += ent.vd_aux;
10590
10591 if (vstart + sizeof (*eaux) > endbuf)
10592 break;
10593 eaux = (Elf_External_Verdaux *) vstart;
10594
10595 aux.vda_name = BYTE_GET (eaux->vda_name);
10596 aux.vda_next = BYTE_GET (eaux->vda_next);
10597
10598 if (VALID_DYNAMIC_NAME (aux.vda_name))
10599 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10600 else
10601 printf (_("Name index: %ld\n"), aux.vda_name);
10602
10603 isum = idx + ent.vd_aux;
10604
10605 for (j = 1; j < ent.vd_cnt; j++)
10606 {
10607 if (aux.vda_next < sizeof (*eaux)
10608 && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
10609 {
10610 warn (_("Invalid vda_next field of %lx\n"),
10611 aux.vda_next);
10612 j = ent.vd_cnt;
10613 break;
10614 }
10615 /* Check for overflow. */
10616 if (aux.vda_next > (size_t) (endbuf - vstart))
10617 break;
10618
10619 isum += aux.vda_next;
10620 vstart += aux.vda_next;
10621
10622 if (vstart + sizeof (*eaux) > endbuf)
10623 break;
10624 eaux = (Elf_External_Verdaux *) vstart;
10625
10626 aux.vda_name = BYTE_GET (eaux->vda_name);
10627 aux.vda_next = BYTE_GET (eaux->vda_next);
10628
10629 if (VALID_DYNAMIC_NAME (aux.vda_name))
10630 printf (_(" %#06lx: Parent %d: %s\n"),
10631 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10632 else
10633 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10634 isum, j, aux.vda_name);
10635 }
10636
10637 if (j < ent.vd_cnt)
10638 printf (_(" Version def aux past end of section\n"));
10639
10640 /* PR 17531:
10641 file: id:000001,src:000172+005151,op:splice,rep:2. */
10642 if (ent.vd_next < sizeof (*edef)
10643 && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
10644 {
10645 warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
10646 cnt = section->sh_info;
10647 break;
10648 }
10649 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
10650 break;
10651
10652 idx += ent.vd_next;
10653 }
10654
10655 if (cnt < section->sh_info)
10656 printf (_(" Version definition past end of section\n"));
10657
10658 free (edefs);
10659 }
10660 break;
10661
10662 case SHT_GNU_verneed:
10663 {
10664 Elf_External_Verneed * eneed;
10665 unsigned long idx;
10666 unsigned long cnt;
10667 char * endbuf;
10668
10669 found = TRUE;
10670
10671 printf (ngettext ("\nVersion needs section '%s' "
10672 "contains %u entry:\n",
10673 "\nVersion needs section '%s' "
10674 "contains %u entries:\n",
10675 section->sh_info),
10676 printable_section_name (filedata, section), section->sh_info);
10677
10678 printf (_(" Addr: 0x"));
10679 printf_vma (section->sh_addr);
10680 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10681 (unsigned long) section->sh_offset, section->sh_link,
10682 printable_section_name_from_index (filedata, section->sh_link));
10683
10684 eneed = (Elf_External_Verneed *) get_data (NULL, filedata,
10685 section->sh_offset, 1,
10686 section->sh_size,
10687 _("Version Needs section"));
10688 if (!eneed)
10689 break;
10690 endbuf = (char *) eneed + section->sh_size;
10691
10692 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10693 {
10694 Elf_External_Verneed * entry;
10695 Elf_Internal_Verneed ent;
10696 unsigned long isum;
10697 int j;
10698 char * vstart;
10699
10700 vstart = ((char *) eneed) + idx;
10701 if (vstart + sizeof (*entry) > endbuf)
10702 break;
10703
10704 entry = (Elf_External_Verneed *) vstart;
10705
10706 ent.vn_version = BYTE_GET (entry->vn_version);
10707 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
10708 ent.vn_file = BYTE_GET (entry->vn_file);
10709 ent.vn_aux = BYTE_GET (entry->vn_aux);
10710 ent.vn_next = BYTE_GET (entry->vn_next);
10711
10712 printf (_(" %#06lx: Version: %d"), idx, ent.vn_version);
10713
10714 if (VALID_DYNAMIC_NAME (ent.vn_file))
10715 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10716 else
10717 printf (_(" File: %lx"), ent.vn_file);
10718
10719 printf (_(" Cnt: %d\n"), ent.vn_cnt);
10720
10721 /* Check for overflow. */
10722 if (ent.vn_aux > (size_t) (endbuf - vstart))
10723 break;
10724 vstart += ent.vn_aux;
10725
10726 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10727 {
10728 Elf_External_Vernaux * eaux;
10729 Elf_Internal_Vernaux aux;
10730
10731 if (vstart + sizeof (*eaux) > endbuf)
10732 break;
10733 eaux = (Elf_External_Vernaux *) vstart;
10734
10735 aux.vna_hash = BYTE_GET (eaux->vna_hash);
10736 aux.vna_flags = BYTE_GET (eaux->vna_flags);
10737 aux.vna_other = BYTE_GET (eaux->vna_other);
10738 aux.vna_name = BYTE_GET (eaux->vna_name);
10739 aux.vna_next = BYTE_GET (eaux->vna_next);
10740
10741 if (VALID_DYNAMIC_NAME (aux.vna_name))
10742 printf (_(" %#06lx: Name: %s"),
10743 isum, GET_DYNAMIC_NAME (aux.vna_name));
10744 else
10745 printf (_(" %#06lx: Name index: %lx"),
10746 isum, aux.vna_name);
10747
10748 printf (_(" Flags: %s Version: %d\n"),
10749 get_ver_flags (aux.vna_flags), aux.vna_other);
10750
10751 if (aux.vna_next < sizeof (*eaux)
10752 && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
10753 {
10754 warn (_("Invalid vna_next field of %lx\n"),
10755 aux.vna_next);
10756 j = ent.vn_cnt;
10757 break;
10758 }
10759 /* Check for overflow. */
10760 if (aux.vna_next > (size_t) (endbuf - vstart))
10761 break;
10762 isum += aux.vna_next;
10763 vstart += aux.vna_next;
10764 }
10765
10766 if (j < ent.vn_cnt)
10767 warn (_("Missing Version Needs auxillary information\n"));
10768
10769 if (ent.vn_next < sizeof (*entry)
10770 && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
10771 {
10772 warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
10773 cnt = section->sh_info;
10774 break;
10775 }
10776 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
10777 break;
10778 idx += ent.vn_next;
10779 }
10780
10781 if (cnt < section->sh_info)
10782 warn (_("Missing Version Needs information\n"));
10783
10784 free (eneed);
10785 }
10786 break;
10787
10788 case SHT_GNU_versym:
10789 {
10790 Elf_Internal_Shdr * link_section;
10791 size_t total;
10792 unsigned int cnt;
10793 unsigned char * edata;
10794 unsigned short * data;
10795 char * strtab;
10796 Elf_Internal_Sym * symbols;
10797 Elf_Internal_Shdr * string_sec;
10798 unsigned long num_syms;
10799 long off;
10800
10801 if (section->sh_link >= filedata->file_header.e_shnum)
10802 break;
10803
10804 link_section = filedata->section_headers + section->sh_link;
10805 total = section->sh_size / sizeof (Elf_External_Versym);
10806
10807 if (link_section->sh_link >= filedata->file_header.e_shnum)
10808 break;
10809
10810 found = TRUE;
10811
10812 symbols = GET_ELF_SYMBOLS (filedata, link_section, & num_syms);
10813 if (symbols == NULL)
10814 break;
10815
10816 string_sec = filedata->section_headers + link_section->sh_link;
10817
10818 strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
10819 string_sec->sh_size,
10820 _("version string table"));
10821 if (!strtab)
10822 {
10823 free (symbols);
10824 break;
10825 }
10826
10827 printf (ngettext ("\nVersion symbols section '%s' "
10828 "contains %lu entry:\n",
10829 "\nVersion symbols section '%s' "
10830 "contains %lu entries:\n",
10831 total),
10832 printable_section_name (filedata, section), (unsigned long) total);
10833
10834 printf (_(" Addr: 0x"));
10835 printf_vma (section->sh_addr);
10836 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10837 (unsigned long) section->sh_offset, section->sh_link,
10838 printable_section_name (filedata, link_section));
10839
10840 off = offset_from_vma (filedata,
10841 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10842 total * sizeof (short));
10843 edata = (unsigned char *) get_data (NULL, filedata, off, total,
10844 sizeof (short),
10845 _("version symbol data"));
10846 if (!edata)
10847 {
10848 free (strtab);
10849 free (symbols);
10850 break;
10851 }
10852
10853 data = (short unsigned int *) cmalloc (total, sizeof (short));
10854
10855 for (cnt = total; cnt --;)
10856 data[cnt] = byte_get (edata + cnt * sizeof (short),
10857 sizeof (short));
10858
10859 free (edata);
10860
10861 for (cnt = 0; cnt < total; cnt += 4)
10862 {
10863 int j, nn;
10864 char *name;
10865 char *invalid = _("*invalid*");
10866
10867 printf (" %03x:", cnt);
10868
10869 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10870 switch (data[cnt + j])
10871 {
10872 case 0:
10873 fputs (_(" 0 (*local*) "), stdout);
10874 break;
10875
10876 case 1:
10877 fputs (_(" 1 (*global*) "), stdout);
10878 break;
10879
10880 default:
10881 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10882 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10883
10884 /* If this index value is greater than the size of the symbols
10885 array, break to avoid an out-of-bounds read. */
10886 if ((unsigned long)(cnt + j) >= num_syms)
10887 {
10888 warn (_("invalid index into symbol array\n"));
10889 break;
10890 }
10891
10892 name = NULL;
10893 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10894 {
10895 Elf_Internal_Verneed ivn;
10896 unsigned long offset;
10897
10898 offset = offset_from_vma
10899 (filedata, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10900 sizeof (Elf_External_Verneed));
10901
10902 do
10903 {
10904 Elf_Internal_Vernaux ivna;
10905 Elf_External_Verneed evn;
10906 Elf_External_Vernaux evna;
10907 unsigned long a_off;
10908
10909 if (get_data (&evn, filedata, offset, sizeof (evn), 1,
10910 _("version need")) == NULL)
10911 break;
10912
10913 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10914 ivn.vn_next = BYTE_GET (evn.vn_next);
10915
10916 a_off = offset + ivn.vn_aux;
10917
10918 do
10919 {
10920 if (get_data (&evna, filedata, a_off, sizeof (evna),
10921 1, _("version need aux (2)")) == NULL)
10922 {
10923 ivna.vna_next = 0;
10924 ivna.vna_other = 0;
10925 }
10926 else
10927 {
10928 ivna.vna_next = BYTE_GET (evna.vna_next);
10929 ivna.vna_other = BYTE_GET (evna.vna_other);
10930 }
10931
10932 a_off += ivna.vna_next;
10933 }
10934 while (ivna.vna_other != data[cnt + j]
10935 && ivna.vna_next != 0);
10936
10937 if (ivna.vna_other == data[cnt + j])
10938 {
10939 ivna.vna_name = BYTE_GET (evna.vna_name);
10940
10941 if (ivna.vna_name >= string_sec->sh_size)
10942 name = invalid;
10943 else
10944 name = strtab + ivna.vna_name;
10945 break;
10946 }
10947
10948 offset += ivn.vn_next;
10949 }
10950 while (ivn.vn_next);
10951 }
10952
10953 if (data[cnt + j] != 0x8001
10954 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10955 {
10956 Elf_Internal_Verdef ivd;
10957 Elf_External_Verdef evd;
10958 unsigned long offset;
10959
10960 offset = offset_from_vma
10961 (filedata, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10962 sizeof evd);
10963
10964 do
10965 {
10966 if (get_data (&evd, filedata, offset, sizeof (evd), 1,
10967 _("version def")) == NULL)
10968 {
10969 ivd.vd_next = 0;
10970 /* PR 17531: file: 046-1082287-0.004. */
10971 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
10972 break;
10973 }
10974 else
10975 {
10976 ivd.vd_next = BYTE_GET (evd.vd_next);
10977 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10978 }
10979
10980 offset += ivd.vd_next;
10981 }
10982 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10983 && ivd.vd_next != 0);
10984
10985 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10986 {
10987 Elf_External_Verdaux evda;
10988 Elf_Internal_Verdaux ivda;
10989
10990 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10991
10992 if (get_data (&evda, filedata,
10993 offset - ivd.vd_next + ivd.vd_aux,
10994 sizeof (evda), 1,
10995 _("version def aux")) == NULL)
10996 break;
10997
10998 ivda.vda_name = BYTE_GET (evda.vda_name);
10999
11000 if (ivda.vda_name >= string_sec->sh_size)
11001 name = invalid;
11002 else if (name != NULL && name != invalid)
11003 name = _("*both*");
11004 else
11005 name = strtab + ivda.vda_name;
11006 }
11007 }
11008 if (name != NULL)
11009 nn += printf ("(%s%-*s",
11010 name,
11011 12 - (int) strlen (name),
11012 ")");
11013
11014 if (nn < 18)
11015 printf ("%*c", 18 - nn, ' ');
11016 }
11017
11018 putchar ('\n');
11019 }
11020
11021 free (data);
11022 free (strtab);
11023 free (symbols);
11024 }
11025 break;
11026
11027 default:
11028 break;
11029 }
11030 }
11031
11032 if (! found)
11033 printf (_("\nNo version information found in this file.\n"));
11034
11035 return TRUE;
11036}
11037
11038static const char *
11039get_symbol_binding (Filedata * filedata, unsigned int binding)
11040{
11041 static char buff[32];
11042
11043 switch (binding)
11044 {
11045 case STB_LOCAL: return "LOCAL";
11046 case STB_GLOBAL: return "GLOBAL";
11047 case STB_WEAK: return "WEAK";
11048 default:
11049 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
11050 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
11051 binding);
11052 else if (binding >= STB_LOOS && binding <= STB_HIOS)
11053 {
11054 if (binding == STB_GNU_UNIQUE
11055 && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
11056 /* GNU is still using the default value 0. */
11057 || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
11058 return "UNIQUE";
11059 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
11060 }
11061 else
11062 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
11063 return buff;
11064 }
11065}
11066
11067static const char *
11068get_symbol_type (Filedata * filedata, unsigned int type)
11069{
11070 static char buff[32];
11071
11072 switch (type)
11073 {
11074 case STT_NOTYPE: return "NOTYPE";
11075 case STT_OBJECT: return "OBJECT";
11076 case STT_FUNC: return "FUNC";
11077 case STT_SECTION: return "SECTION";
11078 case STT_FILE: return "FILE";
11079 case STT_COMMON: return "COMMON";
11080 case STT_TLS: return "TLS";
11081 case STT_RELC: return "RELC";
11082 case STT_SRELC: return "SRELC";
11083 default:
11084 if (type >= STT_LOPROC && type <= STT_HIPROC)
11085 {
11086 if (filedata->file_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
11087 return "THUMB_FUNC";
11088
11089 if (filedata->file_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
11090 return "REGISTER";
11091
11092 if (filedata->file_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
11093 return "PARISC_MILLI";
11094
11095 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
11096 }
11097 else if (type >= STT_LOOS && type <= STT_HIOS)
11098 {
11099 if (filedata->file_header.e_machine == EM_PARISC)
11100 {
11101 if (type == STT_HP_OPAQUE)
11102 return "HP_OPAQUE";
11103 if (type == STT_HP_STUB)
11104 return "HP_STUB";
11105 }
11106
11107 if (type == STT_GNU_IFUNC
11108 && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
11109 || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
11110 /* GNU is still using the default value 0. */
11111 || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
11112 return "IFUNC";
11113
11114 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
11115 }
11116 else
11117 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
11118 return buff;
11119 }
11120}
11121
11122static const char *
11123get_symbol_visibility (unsigned int visibility)
11124{
11125 switch (visibility)
11126 {
11127 case STV_DEFAULT: return "DEFAULT";
11128 case STV_INTERNAL: return "INTERNAL";
11129 case STV_HIDDEN: return "HIDDEN";
11130 case STV_PROTECTED: return "PROTECTED";
11131 default:
11132 error (_("Unrecognized visibility value: %u"), visibility);
11133 return _("<unknown>");
11134 }
11135}
11136
11137static const char *
11138get_alpha_symbol_other (unsigned int other)
11139{
11140 switch (other)
11141 {
11142 case STO_ALPHA_NOPV: return "NOPV";
11143 case STO_ALPHA_STD_GPLOAD: return "STD GPLOAD";
11144 default:
11145 error (_("Unrecognized alpah specific other value: %u"), other);
11146 return _("<unknown>");
11147 }
11148}
11149
11150static const char *
11151get_solaris_symbol_visibility (unsigned int visibility)
11152{
11153 switch (visibility)
11154 {
11155 case 4: return "EXPORTED";
11156 case 5: return "SINGLETON";
11157 case 6: return "ELIMINATE";
11158 default: return get_symbol_visibility (visibility);
11159 }
11160}
11161
11162static const char *
11163get_aarch64_symbol_other (unsigned int other)
11164{
11165 static char buf[32];
11166
11167 if (other & STO_AARCH64_VARIANT_PCS)
11168 {
11169 other &= ~STO_AARCH64_VARIANT_PCS;
11170 if (other == 0)
11171 return "VARIANT_PCS";
11172 snprintf (buf, sizeof buf, "VARIANT_PCS | %x", other);
11173 return buf;
11174 }
11175 return NULL;
11176}
11177
11178static const char *
11179get_mips_symbol_other (unsigned int other)
11180{
11181 switch (other)
11182 {
11183 case STO_OPTIONAL: return "OPTIONAL";
11184 case STO_MIPS_PLT: return "MIPS PLT";
11185 case STO_MIPS_PIC: return "MIPS PIC";
11186 case STO_MICROMIPS: return "MICROMIPS";
11187 case STO_MICROMIPS | STO_MIPS_PIC: return "MICROMIPS, MIPS PIC";
11188 case STO_MIPS16: return "MIPS16";
11189 default: return NULL;
11190 }
11191}
11192
11193static const char *
11194get_ia64_symbol_other (Filedata * filedata, unsigned int other)
11195{
11196 if (is_ia64_vms (filedata))
11197 {
11198 static char res[32];
11199
11200 res[0] = 0;
11201
11202 /* Function types is for images and .STB files only. */
11203 switch (filedata->file_header.e_type)
11204 {
11205 case ET_DYN:
11206 case ET_EXEC:
11207 switch (VMS_ST_FUNC_TYPE (other))
11208 {
11209 case VMS_SFT_CODE_ADDR:
11210 strcat (res, " CA");
11211 break;
11212 case VMS_SFT_SYMV_IDX:
11213 strcat (res, " VEC");
11214 break;
11215 case VMS_SFT_FD:
11216 strcat (res, " FD");
11217 break;
11218 case VMS_SFT_RESERVE:
11219 strcat (res, " RSV");
11220 break;
11221 default:
11222 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11223 VMS_ST_FUNC_TYPE (other));
11224 strcat (res, " <unknown>");
11225 break;
11226 }
11227 break;
11228 default:
11229 break;
11230 }
11231 switch (VMS_ST_LINKAGE (other))
11232 {
11233 case VMS_STL_IGNORE:
11234 strcat (res, " IGN");
11235 break;
11236 case VMS_STL_RESERVE:
11237 strcat (res, " RSV");
11238 break;
11239 case VMS_STL_STD:
11240 strcat (res, " STD");
11241 break;
11242 case VMS_STL_LNK:
11243 strcat (res, " LNK");
11244 break;
11245 default:
11246 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11247 VMS_ST_LINKAGE (other));
11248 strcat (res, " <unknown>");
11249 break;
11250 }
11251
11252 if (res[0] != 0)
11253 return res + 1;
11254 else
11255 return res;
11256 }
11257 return NULL;
11258}
11259
11260static const char *
11261get_ppc64_symbol_other (unsigned int other)
11262{
11263 if ((other & ~STO_PPC64_LOCAL_MASK) != 0)
11264 return NULL;
11265
11266 other >>= STO_PPC64_LOCAL_BIT;
11267 if (other <= 6)
11268 {
11269 static char buf[32];
11270 if (other >= 2)
11271 other = ppc64_decode_local_entry (other);
11272 snprintf (buf, sizeof buf, _("<localentry>: %d"), other);
11273 return buf;
11274 }
11275 return NULL;
11276}
11277
11278static const char *
11279get_symbol_other (Filedata * filedata, unsigned int other)
11280{
11281 const char * result = NULL;
11282 static char buff [32];
11283
11284 if (other == 0)
11285 return "";
11286
11287 switch (filedata->file_header.e_machine)
11288 {
11289 case EM_ALPHA:
11290 result = get_alpha_symbol_other (other);
11291 break;
11292 case EM_AARCH64:
11293 result = get_aarch64_symbol_other (other);
11294 break;
11295 case EM_MIPS:
11296 result = get_mips_symbol_other (other);
11297 break;
11298 case EM_IA_64:
11299 result = get_ia64_symbol_other (filedata, other);
11300 break;
11301 case EM_PPC64:
11302 result = get_ppc64_symbol_other (other);
11303 break;
11304 default:
11305 result = NULL;
11306 break;
11307 }
11308
11309 if (result)
11310 return result;
11311
11312 snprintf (buff, sizeof buff, _("<other>: %x"), other);
11313 return buff;
11314}
11315
11316static const char *
11317get_symbol_index_type (Filedata * filedata, unsigned int type)
11318{
11319 static char buff[32];
11320
11321 switch (type)
11322 {
11323 case SHN_UNDEF: return "UND";
11324 case SHN_ABS: return "ABS";
11325 case SHN_COMMON: return "COM";
11326 default:
11327 if (type == SHN_IA_64_ANSI_COMMON
11328 && filedata->file_header.e_machine == EM_IA_64
11329 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
11330 return "ANSI_COM";
11331 else if ((filedata->file_header.e_machine == EM_X86_64
11332 || filedata->file_header.e_machine == EM_L1OM
11333 || filedata->file_header.e_machine == EM_K1OM)
11334 && type == SHN_X86_64_LCOMMON)
11335 return "LARGE_COM";
11336 else if ((type == SHN_MIPS_SCOMMON
11337 && filedata->file_header.e_machine == EM_MIPS)
11338 || (type == SHN_TIC6X_SCOMMON
11339 && filedata->file_header.e_machine == EM_TI_C6000))
11340 return "SCOM";
11341 else if (type == SHN_MIPS_SUNDEFINED
11342 && filedata->file_header.e_machine == EM_MIPS)
11343 return "SUND";
11344 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
11345 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
11346 else if (type >= SHN_LOOS && type <= SHN_HIOS)
11347 sprintf (buff, "OS [0x%04x]", type & 0xffff);
11348 else if (type >= SHN_LORESERVE)
11349 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
11350 else if (type >= filedata->file_header.e_shnum)
11351 sprintf (buff, _("bad section index[%3d]"), type);
11352 else
11353 sprintf (buff, "%3d", type);
11354 break;
11355 }
11356
11357 return buff;
11358}
11359
11360static bfd_vma *
11361get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_size)
11362{
11363 unsigned char * e_data;
11364 bfd_vma * i_data;
11365
11366 /* If the size_t type is smaller than the bfd_size_type, eg because
11367 you are building a 32-bit tool on a 64-bit host, then make sure
11368 that when (number) is cast to (size_t) no information is lost. */
11369 if (sizeof (size_t) < sizeof (bfd_size_type)
11370 && (bfd_size_type) ((size_t) number) != number)
11371 {
11372 error (_("Size truncation prevents reading %s elements of size %u\n"),
11373 bfd_vmatoa ("u", number), ent_size);
11374 return NULL;
11375 }
11376
11377 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11378 attempting to allocate memory when the read is bound to fail. */
11379 if (ent_size * number > filedata->file_size)
11380 {
11381 error (_("Invalid number of dynamic entries: %s\n"),
11382 bfd_vmatoa ("u", number));
11383 return NULL;
11384 }
11385
11386 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
11387 if (e_data == NULL)
11388 {
11389 error (_("Out of memory reading %s dynamic entries\n"),
11390 bfd_vmatoa ("u", number));
11391 return NULL;
11392 }
11393
11394 if (fread (e_data, ent_size, (size_t) number, filedata->handle) != number)
11395 {
11396 error (_("Unable to read in %s bytes of dynamic data\n"),
11397 bfd_vmatoa ("u", number * ent_size));
11398 free (e_data);
11399 return NULL;
11400 }
11401
11402 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
11403 if (i_data == NULL)
11404 {
11405 error (_("Out of memory allocating space for %s dynamic entries\n"),
11406 bfd_vmatoa ("u", number));
11407 free (e_data);
11408 return NULL;
11409 }
11410
11411 while (number--)
11412 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
11413
11414 free (e_data);
11415
11416 return i_data;
11417}
11418
11419static void
11420print_dynamic_symbol (Filedata * filedata, bfd_vma si, unsigned long hn)
11421{
11422 Elf_Internal_Sym * psym;
11423 int n;
11424
11425 n = print_vma (si, DEC_5);
11426 if (n < 5)
11427 fputs (&" "[n], stdout);
11428 printf (" %3lu: ", hn);
11429
11430 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
11431 {
11432 printf (_("<No info available for dynamic symbol number %lu>\n"),
11433 (unsigned long) si);
11434 return;
11435 }
11436
11437 psym = dynamic_symbols + si;
11438 print_vma (psym->st_value, LONG_HEX);
11439 putchar (' ');
11440 print_vma (psym->st_size, DEC_5);
11441
11442 printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11443 printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11444
11445 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11446 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
11447 else
11448 {
11449 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11450
11451 printf (" %-7s", get_symbol_visibility (vis));
11452 /* Check to see if any other bits in the st_other field are set.
11453 Note - displaying this information disrupts the layout of the
11454 table being generated, but for the moment this case is very
11455 rare. */
11456 if (psym->st_other ^ vis)
11457 printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11458 }
11459
11460 printf (" %3.3s ", get_symbol_index_type (filedata, psym->st_shndx));
11461 if (VALID_DYNAMIC_NAME (psym->st_name))
11462 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11463 else
11464 printf (_(" <corrupt: %14ld>"), psym->st_name);
11465 putchar ('\n');
11466}
11467
11468static const char *
11469get_symbol_version_string (Filedata * filedata,
11470 bfd_boolean is_dynsym,
11471 const char * strtab,
11472 unsigned long int strtab_size,
11473 unsigned int si,
11474 Elf_Internal_Sym * psym,
11475 enum versioned_symbol_info * sym_info,
11476 unsigned short * vna_other)
11477{
11478 unsigned char data[2];
11479 unsigned short vers_data;
11480 unsigned long offset;
11481 unsigned short max_vd_ndx;
11482
11483 if (!is_dynsym
11484 || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11485 return NULL;
11486
11487 offset = offset_from_vma (filedata, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11488 sizeof data + si * sizeof (vers_data));
11489
11490 if (get_data (&data, filedata, offset + si * sizeof (vers_data),
11491 sizeof (data), 1, _("version data")) == NULL)
11492 return NULL;
11493
11494 vers_data = byte_get (data, 2);
11495
11496 if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data == 0)
11497 return NULL;
11498
11499 max_vd_ndx = 0;
11500
11501 /* Usually we'd only see verdef for defined symbols, and verneed for
11502 undefined symbols. However, symbols defined by the linker in
11503 .dynbss for variables copied from a shared library in order to
11504 avoid text relocations are defined yet have verneed. We could
11505 use a heuristic to detect the special case, for example, check
11506 for verneed first on symbols defined in SHT_NOBITS sections, but
11507 it is simpler and more reliable to just look for both verdef and
11508 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11509
11510 if (psym->st_shndx != SHN_UNDEF
11511 && vers_data != 0x8001
11512 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11513 {
11514 Elf_Internal_Verdef ivd;
11515 Elf_Internal_Verdaux ivda;
11516 Elf_External_Verdaux evda;
11517 unsigned long off;
11518
11519 off = offset_from_vma (filedata,
11520 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11521 sizeof (Elf_External_Verdef));
11522
11523 do
11524 {
11525 Elf_External_Verdef evd;
11526
11527 if (get_data (&evd, filedata, off, sizeof (evd), 1,
11528 _("version def")) == NULL)
11529 {
11530 ivd.vd_ndx = 0;
11531 ivd.vd_aux = 0;
11532 ivd.vd_next = 0;
11533 ivd.vd_flags = 0;
11534 }
11535 else
11536 {
11537 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11538 ivd.vd_aux = BYTE_GET (evd.vd_aux);
11539 ivd.vd_next = BYTE_GET (evd.vd_next);
11540 ivd.vd_flags = BYTE_GET (evd.vd_flags);
11541 }
11542
11543 if ((ivd.vd_ndx & VERSYM_VERSION) > max_vd_ndx)
11544 max_vd_ndx = ivd.vd_ndx & VERSYM_VERSION;
11545
11546 off += ivd.vd_next;
11547 }
11548 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11549
11550 if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11551 {
11552 if (ivd.vd_ndx == 1 && ivd.vd_flags == VER_FLG_BASE)
11553 return NULL;
11554
11555 off -= ivd.vd_next;
11556 off += ivd.vd_aux;
11557
11558 if (get_data (&evda, filedata, off, sizeof (evda), 1,
11559 _("version def aux")) != NULL)
11560 {
11561 ivda.vda_name = BYTE_GET (evda.vda_name);
11562
11563 if (psym->st_name != ivda.vda_name)
11564 {
11565 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11566 ? symbol_hidden : symbol_public);
11567 return (ivda.vda_name < strtab_size
11568 ? strtab + ivda.vda_name : _("<corrupt>"));
11569 }
11570 }
11571 }
11572 }
11573
11574 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11575 {
11576 Elf_External_Verneed evn;
11577 Elf_Internal_Verneed ivn;
11578 Elf_Internal_Vernaux ivna;
11579
11580 offset = offset_from_vma (filedata,
11581 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11582 sizeof evn);
11583 do
11584 {
11585 unsigned long vna_off;
11586
11587 if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11588 _("version need")) == NULL)
11589 {
11590 ivna.vna_next = 0;
11591 ivna.vna_other = 0;
11592 ivna.vna_name = 0;
11593 break;
11594 }
11595
11596 ivn.vn_aux = BYTE_GET (evn.vn_aux);
11597 ivn.vn_next = BYTE_GET (evn.vn_next);
11598
11599 vna_off = offset + ivn.vn_aux;
11600
11601 do
11602 {
11603 Elf_External_Vernaux evna;
11604
11605 if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
11606 _("version need aux (3)")) == NULL)
11607 {
11608 ivna.vna_next = 0;
11609 ivna.vna_other = 0;
11610 ivna.vna_name = 0;
11611 }
11612 else
11613 {
11614 ivna.vna_other = BYTE_GET (evna.vna_other);
11615 ivna.vna_next = BYTE_GET (evna.vna_next);
11616 ivna.vna_name = BYTE_GET (evna.vna_name);
11617 }
11618
11619 vna_off += ivna.vna_next;
11620 }
11621 while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11622
11623 if (ivna.vna_other == vers_data)
11624 break;
11625
11626 offset += ivn.vn_next;
11627 }
11628 while (ivn.vn_next != 0);
11629
11630 if (ivna.vna_other == vers_data)
11631 {
11632 *sym_info = symbol_undefined;
11633 *vna_other = ivna.vna_other;
11634 return (ivna.vna_name < strtab_size
11635 ? strtab + ivna.vna_name : _("<corrupt>"));
11636 }
11637 else if ((max_vd_ndx || (vers_data & VERSYM_VERSION) != 1)
11638 && (vers_data & VERSYM_VERSION) > max_vd_ndx)
11639 return _("<corrupt>");
11640 }
11641 return NULL;
11642}
11643
11644/* Dump the symbol table. */
11645static bfd_boolean
11646process_symbol_table (Filedata * filedata)
11647{
11648 Elf_Internal_Shdr * section;
11649 bfd_size_type nbuckets = 0;
11650 bfd_size_type nchains = 0;
11651 bfd_vma * buckets = NULL;
11652 bfd_vma * chains = NULL;
11653 bfd_vma ngnubuckets = 0;
11654 bfd_vma * gnubuckets = NULL;
11655 bfd_vma * gnuchains = NULL;
11656 bfd_vma gnusymidx = 0;
11657 bfd_size_type ngnuchains = 0;
11658
11659 if (!do_syms && !do_dyn_syms && !do_histogram)
11660 return TRUE;
11661
11662 if (dynamic_info[DT_HASH]
11663 && (do_histogram
11664 || (do_using_dynamic
11665 && !do_dyn_syms
11666 && dynamic_strings != NULL)))
11667 {
11668 unsigned char nb[8];
11669 unsigned char nc[8];
11670 unsigned int hash_ent_size = 4;
11671
11672 if ((filedata->file_header.e_machine == EM_ALPHA
11673 || filedata->file_header.e_machine == EM_S390
11674 || filedata->file_header.e_machine == EM_S390_OLD)
11675 && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
11676 hash_ent_size = 8;
11677
11678 if (fseek (filedata->handle,
11679 (archive_file_offset
11680 + offset_from_vma (filedata, dynamic_info[DT_HASH],
11681 sizeof nb + sizeof nc)),
11682 SEEK_SET))
11683 {
11684 error (_("Unable to seek to start of dynamic information\n"));
11685 goto no_hash;
11686 }
11687
11688 if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
11689 {
11690 error (_("Failed to read in number of buckets\n"));
11691 goto no_hash;
11692 }
11693
11694 if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
11695 {
11696 error (_("Failed to read in number of chains\n"));
11697 goto no_hash;
11698 }
11699
11700 nbuckets = byte_get (nb, hash_ent_size);
11701 nchains = byte_get (nc, hash_ent_size);
11702
11703 buckets = get_dynamic_data (filedata, nbuckets, hash_ent_size);
11704 chains = get_dynamic_data (filedata, nchains, hash_ent_size);
11705
11706 no_hash:
11707 if (buckets == NULL || chains == NULL)
11708 {
11709 if (do_using_dynamic)
11710 return FALSE;
11711 free (buckets);
11712 free (chains);
11713 buckets = NULL;
11714 chains = NULL;
11715 nbuckets = 0;
11716 nchains = 0;
11717 }
11718 }
11719
11720 if (dynamic_info_DT_GNU_HASH
11721 && (do_histogram
11722 || (do_using_dynamic
11723 && !do_dyn_syms
11724 && dynamic_strings != NULL)))
11725 {
11726 unsigned char nb[16];
11727 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11728 bfd_vma buckets_vma;
11729
11730 if (fseek (filedata->handle,
11731 (archive_file_offset
11732 + offset_from_vma (filedata, dynamic_info_DT_GNU_HASH,
11733 sizeof nb)),
11734 SEEK_SET))
11735 {
11736 error (_("Unable to seek to start of dynamic information\n"));
11737 goto no_gnu_hash;
11738 }
11739
11740 if (fread (nb, 16, 1, filedata->handle) != 1)
11741 {
11742 error (_("Failed to read in number of buckets\n"));
11743 goto no_gnu_hash;
11744 }
11745
11746 ngnubuckets = byte_get (nb, 4);
11747 gnusymidx = byte_get (nb + 4, 4);
11748 bitmaskwords = byte_get (nb + 8, 4);
11749 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11750 if (is_32bit_elf)
11751 buckets_vma += bitmaskwords * 4;
11752 else
11753 buckets_vma += bitmaskwords * 8;
11754
11755 if (fseek (filedata->handle,
11756 (archive_file_offset
11757 + offset_from_vma (filedata, buckets_vma, 4)),
11758 SEEK_SET))
11759 {
11760 error (_("Unable to seek to start of dynamic information\n"));
11761 goto no_gnu_hash;
11762 }
11763
11764 gnubuckets = get_dynamic_data (filedata, ngnubuckets, 4);
11765
11766 if (gnubuckets == NULL)
11767 goto no_gnu_hash;
11768
11769 for (i = 0; i < ngnubuckets; i++)
11770 if (gnubuckets[i] != 0)
11771 {
11772 if (gnubuckets[i] < gnusymidx)
11773 return FALSE;
11774
11775 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11776 maxchain = gnubuckets[i];
11777 }
11778
11779 if (maxchain == 0xffffffff)
11780 goto no_gnu_hash;
11781
11782 maxchain -= gnusymidx;
11783
11784 if (fseek (filedata->handle,
11785 (archive_file_offset
11786 + offset_from_vma (filedata, buckets_vma
11787 + 4 * (ngnubuckets + maxchain), 4)),
11788 SEEK_SET))
11789 {
11790 error (_("Unable to seek to start of dynamic information\n"));
11791 goto no_gnu_hash;
11792 }
11793
11794 do
11795 {
11796 if (fread (nb, 4, 1, filedata->handle) != 1)
11797 {
11798 error (_("Failed to determine last chain length\n"));
11799 goto no_gnu_hash;
11800 }
11801
11802 if (maxchain + 1 == 0)
11803 goto no_gnu_hash;
11804
11805 ++maxchain;
11806 }
11807 while ((byte_get (nb, 4) & 1) == 0);
11808
11809 if (fseek (filedata->handle,
11810 (archive_file_offset
11811 + offset_from_vma (filedata, buckets_vma + 4 * ngnubuckets, 4)),
11812 SEEK_SET))
11813 {
11814 error (_("Unable to seek to start of dynamic information\n"));
11815 goto no_gnu_hash;
11816 }
11817
11818 gnuchains = get_dynamic_data (filedata, maxchain, 4);
11819 ngnuchains = maxchain;
11820
11821 no_gnu_hash:
11822 if (gnuchains == NULL)
11823 {
11824 free (gnubuckets);
11825 gnubuckets = NULL;
11826 ngnubuckets = 0;
11827 if (do_using_dynamic)
11828 return FALSE;
11829 }
11830 }
11831
11832 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11833 && do_syms
11834 && do_using_dynamic
11835 && dynamic_strings != NULL
11836 && dynamic_symbols != NULL)
11837 {
11838 unsigned long hn;
11839
11840 if (dynamic_info[DT_HASH])
11841 {
11842 bfd_vma si;
11843 char *visited;
11844
11845 printf (_("\nSymbol table for image:\n"));
11846 if (is_32bit_elf)
11847 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11848 else
11849 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11850
11851 visited = xcmalloc (nchains, 1);
11852 memset (visited, 0, nchains);
11853 for (hn = 0; hn < nbuckets; hn++)
11854 {
11855 for (si = buckets[hn]; si > 0; si = chains[si])
11856 {
11857 print_dynamic_symbol (filedata, si, hn);
11858 if (si >= nchains || visited[si])
11859 {
11860 error (_("histogram chain is corrupt\n"));
11861 break;
11862 }
11863 visited[si] = 1;
11864 }
11865 }
11866 free (visited);
11867 }
11868
11869 if (dynamic_info_DT_GNU_HASH)
11870 {
11871 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11872 if (is_32bit_elf)
11873 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11874 else
11875 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11876
11877 for (hn = 0; hn < ngnubuckets; ++hn)
11878 if (gnubuckets[hn] != 0)
11879 {
11880 bfd_vma si = gnubuckets[hn];
11881 bfd_vma off = si - gnusymidx;
11882
11883 do
11884 {
11885 print_dynamic_symbol (filedata, si, hn);
11886 si++;
11887 }
11888 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11889 }
11890 }
11891 }
11892 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11893 && filedata->section_headers != NULL)
11894 {
11895 unsigned int i;
11896
11897 for (i = 0, section = filedata->section_headers;
11898 i < filedata->file_header.e_shnum;
11899 i++, section++)
11900 {
11901 unsigned int si;
11902 char * strtab = NULL;
11903 unsigned long int strtab_size = 0;
11904 Elf_Internal_Sym * symtab;
11905 Elf_Internal_Sym * psym;
11906 unsigned long num_syms;
11907
11908 if ((section->sh_type != SHT_SYMTAB
11909 && section->sh_type != SHT_DYNSYM)
11910 || (!do_syms
11911 && section->sh_type == SHT_SYMTAB))
11912 continue;
11913
11914 if (section->sh_entsize == 0)
11915 {
11916 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11917 printable_section_name (filedata, section));
11918 continue;
11919 }
11920
11921 num_syms = section->sh_size / section->sh_entsize;
11922 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11923 "\nSymbol table '%s' contains %lu entries:\n",
11924 num_syms),
11925 printable_section_name (filedata, section),
11926 num_syms);
11927
11928 if (is_32bit_elf)
11929 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11930 else
11931 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11932
11933 symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
11934 if (symtab == NULL)
11935 continue;
11936
11937 if (section->sh_link == filedata->file_header.e_shstrndx)
11938 {
11939 strtab = filedata->string_table;
11940 strtab_size = filedata->string_table_length;
11941 }
11942 else if (section->sh_link < filedata->file_header.e_shnum)
11943 {
11944 Elf_Internal_Shdr * string_sec;
11945
11946 string_sec = filedata->section_headers + section->sh_link;
11947
11948 strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
11949 1, string_sec->sh_size,
11950 _("string table"));
11951 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11952 }
11953
11954 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11955 {
11956 const char *version_string;
11957 enum versioned_symbol_info sym_info;
11958 unsigned short vna_other;
11959
11960 printf ("%6d: ", si);
11961 print_vma (psym->st_value, LONG_HEX);
11962 putchar (' ');
11963 print_vma (psym->st_size, DEC_5);
11964 printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11965 printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11966 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11967 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
11968 else
11969 {
11970 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11971
11972 printf (" %-7s", get_symbol_visibility (vis));
11973 /* Check to see if any other bits in the st_other field are set.
11974 Note - displaying this information disrupts the layout of the
11975 table being generated, but for the moment this case is very rare. */
11976 if (psym->st_other ^ vis)
11977 printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11978 }
11979 printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
11980 print_symbol (25, psym->st_name < strtab_size
11981 ? strtab + psym->st_name : _("<corrupt>"));
11982
11983 version_string
11984 = get_symbol_version_string (filedata,
11985 section->sh_type == SHT_DYNSYM,
11986 strtab, strtab_size, si,
11987 psym, &sym_info, &vna_other);
11988 if (version_string)
11989 {
11990 if (sym_info == symbol_undefined)
11991 printf ("@%s (%d)", version_string, vna_other);
11992 else
11993 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11994 version_string);
11995 }
11996
11997 putchar ('\n');
11998
11999 if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
12000 && si >= section->sh_info
12001 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12002 && filedata->file_header.e_machine != EM_MIPS
12003 /* Solaris binaries have been found to violate this requirement as
12004 well. Not sure if this is a bug or an ABI requirement. */
12005 && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
12006 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
12007 si, printable_section_name (filedata, section), section->sh_info);
12008 }
12009
12010 free (symtab);
12011 if (strtab != filedata->string_table)
12012 free (strtab);
12013 }
12014 }
12015 else if (do_syms)
12016 printf
12017 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12018
12019 if (do_histogram && buckets != NULL)
12020 {
12021 unsigned long * lengths;
12022 unsigned long * counts;
12023 unsigned long hn;
12024 bfd_vma si;
12025 unsigned long maxlength = 0;
12026 unsigned long nzero_counts = 0;
12027 unsigned long nsyms = 0;
12028 char *visited;
12029
12030 printf (ngettext ("\nHistogram for bucket list length "
12031 "(total of %lu bucket):\n",
12032 "\nHistogram for bucket list length "
12033 "(total of %lu buckets):\n",
12034 (unsigned long) nbuckets),
12035 (unsigned long) nbuckets);
12036
12037 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
12038 if (lengths == NULL)
12039 {
12040 error (_("Out of memory allocating space for histogram buckets\n"));
12041 return FALSE;
12042 }
12043 visited = xcmalloc (nchains, 1);
12044 memset (visited, 0, nchains);
12045
12046 printf (_(" Length Number %% of total Coverage\n"));
12047 for (hn = 0; hn < nbuckets; ++hn)
12048 {
12049 for (si = buckets[hn]; si > 0; si = chains[si])
12050 {
12051 ++nsyms;
12052 if (maxlength < ++lengths[hn])
12053 ++maxlength;
12054 if (si >= nchains || visited[si])
12055 {
12056 error (_("histogram chain is corrupt\n"));
12057 break;
12058 }
12059 visited[si] = 1;
12060 }
12061 }
12062 free (visited);
12063
12064 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
12065 if (counts == NULL)
12066 {
12067 free (lengths);
12068 error (_("Out of memory allocating space for histogram counts\n"));
12069 return FALSE;
12070 }
12071
12072 for (hn = 0; hn < nbuckets; ++hn)
12073 ++counts[lengths[hn]];
12074
12075 if (nbuckets > 0)
12076 {
12077 unsigned long i;
12078 printf (" 0 %-10lu (%5.1f%%)\n",
12079 counts[0], (counts[0] * 100.0) / nbuckets);
12080 for (i = 1; i <= maxlength; ++i)
12081 {
12082 nzero_counts += counts[i] * i;
12083 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12084 i, counts[i], (counts[i] * 100.0) / nbuckets,
12085 (nzero_counts * 100.0) / nsyms);
12086 }
12087 }
12088
12089 free (counts);
12090 free (lengths);
12091 }
12092
12093 if (buckets != NULL)
12094 {
12095 free (buckets);
12096 free (chains);
12097 }
12098
12099 if (do_histogram && gnubuckets != NULL)
12100 {
12101 unsigned long * lengths;
12102 unsigned long * counts;
12103 unsigned long hn;
12104 unsigned long maxlength = 0;
12105 unsigned long nzero_counts = 0;
12106 unsigned long nsyms = 0;
12107
12108 printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
12109 "(total of %lu bucket):\n",
12110 "\nHistogram for `.gnu.hash' bucket list length "
12111 "(total of %lu buckets):\n",
12112 (unsigned long) ngnubuckets),
12113 (unsigned long) ngnubuckets);
12114
12115 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
12116 if (lengths == NULL)
12117 {
12118 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12119 return FALSE;
12120 }
12121
12122 printf (_(" Length Number %% of total Coverage\n"));
12123
12124 for (hn = 0; hn < ngnubuckets; ++hn)
12125 if (gnubuckets[hn] != 0)
12126 {
12127 bfd_vma off, length = 1;
12128
12129 for (off = gnubuckets[hn] - gnusymidx;
12130 /* PR 17531 file: 010-77222-0.004. */
12131 off < ngnuchains && (gnuchains[off] & 1) == 0;
12132 ++off)
12133 ++length;
12134 lengths[hn] = length;
12135 if (length > maxlength)
12136 maxlength = length;
12137 nsyms += length;
12138 }
12139
12140 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
12141 if (counts == NULL)
12142 {
12143 free (lengths);
12144 error (_("Out of memory allocating space for gnu histogram counts\n"));
12145 return FALSE;
12146 }
12147
12148 for (hn = 0; hn < ngnubuckets; ++hn)
12149 ++counts[lengths[hn]];
12150
12151 if (ngnubuckets > 0)
12152 {
12153 unsigned long j;
12154 printf (" 0 %-10lu (%5.1f%%)\n",
12155 counts[0], (counts[0] * 100.0) / ngnubuckets);
12156 for (j = 1; j <= maxlength; ++j)
12157 {
12158 nzero_counts += counts[j] * j;
12159 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12160 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
12161 (nzero_counts * 100.0) / nsyms);
12162 }
12163 }
12164
12165 free (counts);
12166 free (lengths);
12167 free (gnubuckets);
12168 free (gnuchains);
12169 }
12170
12171 return TRUE;
12172}
12173
12174static bfd_boolean
12175process_syminfo (Filedata * filedata ATTRIBUTE_UNUSED)
12176{
12177 unsigned int i;
12178
12179 if (dynamic_syminfo == NULL
12180 || !do_dynamic)
12181 /* No syminfo, this is ok. */
12182 return TRUE;
12183
12184 /* There better should be a dynamic symbol section. */
12185 if (dynamic_symbols == NULL || dynamic_strings == NULL)
12186 return FALSE;
12187
12188 if (dynamic_addr)
12189 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12190 "contains %d entry:\n",
12191 "\nDynamic info segment at offset 0x%lx "
12192 "contains %d entries:\n",
12193 dynamic_syminfo_nent),
12194 dynamic_syminfo_offset, dynamic_syminfo_nent);
12195
12196 printf (_(" Num: Name BoundTo Flags\n"));
12197 for (i = 0; i < dynamic_syminfo_nent; ++i)
12198 {
12199 unsigned short int flags = dynamic_syminfo[i].si_flags;
12200
12201 printf ("%4d: ", i);
12202 if (i >= num_dynamic_syms)
12203 printf (_("<corrupt index>"));
12204 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
12205 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
12206 else
12207 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
12208 putchar (' ');
12209
12210 switch (dynamic_syminfo[i].si_boundto)
12211 {
12212 case SYMINFO_BT_SELF:
12213 fputs ("SELF ", stdout);
12214 break;
12215 case SYMINFO_BT_PARENT:
12216 fputs ("PARENT ", stdout);
12217 break;
12218 default:
12219 if (dynamic_syminfo[i].si_boundto > 0
12220 && dynamic_syminfo[i].si_boundto < dynamic_nent
12221 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
12222 {
12223 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
12224 putchar (' ' );
12225 }
12226 else
12227 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
12228 break;
12229 }
12230
12231 if (flags & SYMINFO_FLG_DIRECT)
12232 printf (" DIRECT");
12233 if (flags & SYMINFO_FLG_PASSTHRU)
12234 printf (" PASSTHRU");
12235 if (flags & SYMINFO_FLG_COPY)
12236 printf (" COPY");
12237 if (flags & SYMINFO_FLG_LAZYLOAD)
12238 printf (" LAZYLOAD");
12239
12240 puts ("");
12241 }
12242
12243 return TRUE;
12244}
12245
12246#define IN_RANGE(START,END,ADDR,OFF) \
12247 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
12248
12249/* Check to see if the given reloc needs to be handled in a target specific
12250 manner. If so then process the reloc and return TRUE otherwise return
12251 FALSE.
12252
12253 If called with reloc == NULL, then this is a signal that reloc processing
12254 for the current section has finished, and any saved state should be
12255 discarded. */
12256
12257static bfd_boolean
12258target_specific_reloc_handling (Filedata * filedata,
12259 Elf_Internal_Rela * reloc,
12260 unsigned char * start,
12261 unsigned char * end,
12262 Elf_Internal_Sym * symtab,
12263 unsigned long num_syms)
12264{
12265 unsigned int reloc_type = 0;
12266 unsigned long sym_index = 0;
12267
12268 if (reloc)
12269 {
12270 reloc_type = get_reloc_type (filedata, reloc->r_info);
12271 sym_index = get_reloc_symindex (reloc->r_info);
12272 }
12273
12274 switch (filedata->file_header.e_machine)
12275 {
12276 case EM_MSP430:
12277 case EM_MSP430_OLD:
12278 {
12279 static Elf_Internal_Sym * saved_sym = NULL;
12280
12281 if (reloc == NULL)
12282 {
12283 saved_sym = NULL;
12284 return TRUE;
12285 }
12286
12287 switch (reloc_type)
12288 {
12289 case 10: /* R_MSP430_SYM_DIFF */
12290 if (uses_msp430x_relocs (filedata))
12291 break;
12292 /* Fall through. */
12293 case 21: /* R_MSP430X_SYM_DIFF */
12294 /* PR 21139. */
12295 if (sym_index >= num_syms)
12296 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12297 sym_index);
12298 else
12299 saved_sym = symtab + sym_index;
12300 return TRUE;
12301
12302 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12303 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12304 goto handle_sym_diff;
12305
12306 case 5: /* R_MSP430_16_BYTE */
12307 case 9: /* R_MSP430_8 */
12308 if (uses_msp430x_relocs (filedata))
12309 break;
12310 goto handle_sym_diff;
12311
12312 case 2: /* R_MSP430_ABS16 */
12313 case 15: /* R_MSP430X_ABS16 */
12314 if (! uses_msp430x_relocs (filedata))
12315 break;
12316 goto handle_sym_diff;
12317
12318 handle_sym_diff:
12319 if (saved_sym != NULL)
12320 {
12321 int reloc_size = reloc_type == 1 ? 4 : 2;
12322 bfd_vma value;
12323
12324 if (sym_index >= num_syms)
12325 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12326 sym_index);
12327 else
12328 {
12329 value = reloc->r_addend + (symtab[sym_index].st_value
12330 - saved_sym->st_value);
12331
12332 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12333 byte_put (start + reloc->r_offset, value, reloc_size);
12334 else
12335 /* PR 21137 */
12336 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12337 (long) reloc->r_offset);
12338 }
12339
12340 saved_sym = NULL;
12341 return TRUE;
12342 }
12343 break;
12344
12345 default:
12346 if (saved_sym != NULL)
12347 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12348 break;
12349 }
12350 break;
12351 }
12352
12353 case EM_MN10300:
12354 case EM_CYGNUS_MN10300:
12355 {
12356 static Elf_Internal_Sym * saved_sym = NULL;
12357
12358 if (reloc == NULL)
12359 {
12360 saved_sym = NULL;
12361 return TRUE;
12362 }
12363
12364 switch (reloc_type)
12365 {
12366 case 34: /* R_MN10300_ALIGN */
12367 return TRUE;
12368 case 33: /* R_MN10300_SYM_DIFF */
12369 if (sym_index >= num_syms)
12370 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12371 sym_index);
12372 else
12373 saved_sym = symtab + sym_index;
12374 return TRUE;
12375
12376 case 1: /* R_MN10300_32 */
12377 case 2: /* R_MN10300_16 */
12378 if (saved_sym != NULL)
12379 {
12380 int reloc_size = reloc_type == 1 ? 4 : 2;
12381 bfd_vma value;
12382
12383 if (sym_index >= num_syms)
12384 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12385 sym_index);
12386 else
12387 {
12388 value = reloc->r_addend + (symtab[sym_index].st_value
12389 - saved_sym->st_value);
12390
12391 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12392 byte_put (start + reloc->r_offset, value, reloc_size);
12393 else
12394 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12395 (long) reloc->r_offset);
12396 }
12397
12398 saved_sym = NULL;
12399 return TRUE;
12400 }
12401 break;
12402 default:
12403 if (saved_sym != NULL)
12404 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12405 break;
12406 }
12407 break;
12408 }
12409
12410 case EM_RL78:
12411 {
12412 static bfd_vma saved_sym1 = 0;
12413 static bfd_vma saved_sym2 = 0;
12414 static bfd_vma value;
12415
12416 if (reloc == NULL)
12417 {
12418 saved_sym1 = saved_sym2 = 0;
12419 return TRUE;
12420 }
12421
12422 switch (reloc_type)
12423 {
12424 case 0x80: /* R_RL78_SYM. */
12425 saved_sym1 = saved_sym2;
12426 if (sym_index >= num_syms)
12427 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12428 sym_index);
12429 else
12430 {
12431 saved_sym2 = symtab[sym_index].st_value;
12432 saved_sym2 += reloc->r_addend;
12433 }
12434 return TRUE;
12435
12436 case 0x83: /* R_RL78_OPsub. */
12437 value = saved_sym1 - saved_sym2;
12438 saved_sym2 = saved_sym1 = 0;
12439 return TRUE;
12440 break;
12441
12442 case 0x41: /* R_RL78_ABS32. */
12443 if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12444 byte_put (start + reloc->r_offset, value, 4);
12445 else
12446 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12447 (long) reloc->r_offset);
12448 value = 0;
12449 return TRUE;
12450
12451 case 0x43: /* R_RL78_ABS16. */
12452 if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12453 byte_put (start + reloc->r_offset, value, 2);
12454 else
12455 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12456 (long) reloc->r_offset);
12457 value = 0;
12458 return TRUE;
12459
12460 default:
12461 break;
12462 }
12463 break;
12464 }
12465 }
12466
12467 return FALSE;
12468}
12469
12470/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12471 DWARF debug sections. This is a target specific test. Note - we do not
12472 go through the whole including-target-headers-multiple-times route, (as
12473 we have already done with <elf/h8.h>) because this would become very
12474 messy and even then this function would have to contain target specific
12475 information (the names of the relocs instead of their numeric values).
12476 FIXME: This is not the correct way to solve this problem. The proper way
12477 is to have target specific reloc sizing and typing functions created by
12478 the reloc-macros.h header, in the same way that it already creates the
12479 reloc naming functions. */
12480
12481static bfd_boolean
12482is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12483{
12484 /* Please keep this table alpha-sorted for ease of visual lookup. */
12485 switch (filedata->file_header.e_machine)
12486 {
12487 case EM_386:
12488 case EM_IAMCU:
12489 return reloc_type == 1; /* R_386_32. */
12490 case EM_68K:
12491 return reloc_type == 1; /* R_68K_32. */
12492 case EM_860:
12493 return reloc_type == 1; /* R_860_32. */
12494 case EM_960:
12495 return reloc_type == 2; /* R_960_32. */
12496 case EM_AARCH64:
12497 return (reloc_type == 258
12498 || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12499 case EM_BPF:
12500 return reloc_type == 11; /* R_BPF_DATA_32 */
12501 case EM_ADAPTEVA_EPIPHANY:
12502 return reloc_type == 3;
12503 case EM_ALPHA:
12504 return reloc_type == 1; /* R_ALPHA_REFLONG. */
12505 case EM_ARC:
12506 return reloc_type == 1; /* R_ARC_32. */
12507 case EM_ARC_COMPACT:
12508 case EM_ARC_COMPACT2:
12509 return reloc_type == 4; /* R_ARC_32. */
12510 case EM_ARM:
12511 return reloc_type == 2; /* R_ARM_ABS32 */
12512 case EM_AVR_OLD:
12513 case EM_AVR:
12514 return reloc_type == 1;
12515 case EM_BLACKFIN:
12516 return reloc_type == 0x12; /* R_byte4_data. */
12517 case EM_CRIS:
12518 return reloc_type == 3; /* R_CRIS_32. */
12519 case EM_CR16:
12520 return reloc_type == 3; /* R_CR16_NUM32. */
12521 case EM_CRX:
12522 return reloc_type == 15; /* R_CRX_NUM32. */
12523 case EM_CSKY:
12524 return reloc_type == 1; /* R_CKCORE_ADDR32. */
12525 case EM_CYGNUS_FRV:
12526 return reloc_type == 1;
12527 case EM_CYGNUS_D10V:
12528 case EM_D10V:
12529 return reloc_type == 6; /* R_D10V_32. */
12530 case EM_CYGNUS_D30V:
12531 case EM_D30V:
12532 return reloc_type == 12; /* R_D30V_32_NORMAL. */
12533 case EM_DLX:
12534 return reloc_type == 3; /* R_DLX_RELOC_32. */
12535 case EM_CYGNUS_FR30:
12536 case EM_FR30:
12537 return reloc_type == 3; /* R_FR30_32. */
12538 case EM_FT32:
12539 return reloc_type == 1; /* R_FT32_32. */
12540 case EM_H8S:
12541 case EM_H8_300:
12542 case EM_H8_300H:
12543 return reloc_type == 1; /* R_H8_DIR32. */
12544 case EM_IA_64:
12545 return (reloc_type == 0x64 /* R_IA64_SECREL32MSB. */
12546 || reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
12547 || reloc_type == 0x24 /* R_IA64_DIR32MSB. */
12548 || reloc_type == 0x25 /* R_IA64_DIR32LSB. */);
12549 case EM_IP2K_OLD:
12550 case EM_IP2K:
12551 return reloc_type == 2; /* R_IP2K_32. */
12552 case EM_IQ2000:
12553 return reloc_type == 2; /* R_IQ2000_32. */
12554 case EM_LATTICEMICO32:
12555 return reloc_type == 3; /* R_LM32_32. */
12556 case EM_M32C_OLD:
12557 case EM_M32C:
12558 return reloc_type == 3; /* R_M32C_32. */
12559 case EM_M32R:
12560 return reloc_type == 34; /* R_M32R_32_RELA. */
12561 case EM_68HC11:
12562 case EM_68HC12:
12563 return reloc_type == 6; /* R_M68HC11_32. */
12564 case EM_S12Z:
12565 return reloc_type == 7 || /* R_S12Z_EXT32 */
12566 reloc_type == 6; /* R_S12Z_CW32. */
12567 case EM_MCORE:
12568 return reloc_type == 1; /* R_MCORE_ADDR32. */
12569 case EM_CYGNUS_MEP:
12570 return reloc_type == 4; /* R_MEP_32. */
12571 case EM_METAG:
12572 return reloc_type == 2; /* R_METAG_ADDR32. */
12573 case EM_MICROBLAZE:
12574 return reloc_type == 1; /* R_MICROBLAZE_32. */
12575 case EM_MIPS:
12576 return reloc_type == 2; /* R_MIPS_32. */
12577 case EM_MMIX:
12578 return reloc_type == 4; /* R_MMIX_32. */
12579 case EM_CYGNUS_MN10200:
12580 case EM_MN10200:
12581 return reloc_type == 1; /* R_MN10200_32. */
12582 case EM_CYGNUS_MN10300:
12583 case EM_MN10300:
12584 return reloc_type == 1; /* R_MN10300_32. */
12585 case EM_MOXIE:
12586 return reloc_type == 1; /* R_MOXIE_32. */
12587 case EM_MSP430_OLD:
12588 case EM_MSP430:
12589 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12590 case EM_MT:
12591 return reloc_type == 2; /* R_MT_32. */
12592 case EM_NDS32:
12593 return reloc_type == 20; /* R_NDS32_RELA. */
12594 case EM_ALTERA_NIOS2:
12595 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
12596 case EM_NIOS32:
12597 return reloc_type == 1; /* R_NIOS_32. */
12598 case EM_OR1K:
12599 return reloc_type == 1; /* R_OR1K_32. */
12600 case EM_PARISC:
12601 return (reloc_type == 1 /* R_PARISC_DIR32. */
12602 || reloc_type == 2 /* R_PARISC_DIR21L. */
12603 || reloc_type == 41); /* R_PARISC_SECREL32. */
12604 case EM_PJ:
12605 case EM_PJ_OLD:
12606 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
12607 case EM_PPC64:
12608 return reloc_type == 1; /* R_PPC64_ADDR32. */
12609 case EM_PPC:
12610 return reloc_type == 1; /* R_PPC_ADDR32. */
12611 case EM_TI_PRU:
12612 return reloc_type == 11; /* R_PRU_BFD_RELOC_32. */
12613 case EM_RISCV:
12614 return reloc_type == 1; /* R_RISCV_32. */
12615 case EM_RL78:
12616 return reloc_type == 1; /* R_RL78_DIR32. */
12617 case EM_RX:
12618 return reloc_type == 1; /* R_RX_DIR32. */
12619 case EM_S370:
12620 return reloc_type == 1; /* R_I370_ADDR31. */
12621 case EM_S390_OLD:
12622 case EM_S390:
12623 return reloc_type == 4; /* R_S390_32. */
12624 case EM_SCORE:
12625 return reloc_type == 8; /* R_SCORE_ABS32. */
12626 case EM_SH:
12627 return reloc_type == 1; /* R_SH_DIR32. */
12628 case EM_SPARC32PLUS:
12629 case EM_SPARCV9:
12630 case EM_SPARC:
12631 return reloc_type == 3 /* R_SPARC_32. */
12632 || reloc_type == 23; /* R_SPARC_UA32. */
12633 case EM_SPU:
12634 return reloc_type == 6; /* R_SPU_ADDR32 */
12635 case EM_TI_C6000:
12636 return reloc_type == 1; /* R_C6000_ABS32. */
12637 case EM_TILEGX:
12638 return reloc_type == 2; /* R_TILEGX_32. */
12639 case EM_TILEPRO:
12640 return reloc_type == 1; /* R_TILEPRO_32. */
12641 case EM_CYGNUS_V850:
12642 case EM_V850:
12643 return reloc_type == 6; /* R_V850_ABS32. */
12644 case EM_V800:
12645 return reloc_type == 0x33; /* R_V810_WORD. */
12646 case EM_VAX:
12647 return reloc_type == 1; /* R_VAX_32. */
12648 case EM_VISIUM:
12649 return reloc_type == 3; /* R_VISIUM_32. */
12650 case EM_WEBASSEMBLY:
12651 return reloc_type == 1; /* R_WASM32_32. */
12652 case EM_X86_64:
12653 case EM_L1OM:
12654 case EM_K1OM:
12655 return reloc_type == 10; /* R_X86_64_32. */
12656 case EM_XC16X:
12657 case EM_C166:
12658 return reloc_type == 3; /* R_XC16C_ABS_32. */
12659 case EM_XGATE:
12660 return reloc_type == 4; /* R_XGATE_32. */
12661 case EM_XSTORMY16:
12662 return reloc_type == 1; /* R_XSTROMY16_32. */
12663 case EM_XTENSA_OLD:
12664 case EM_XTENSA:
12665 return reloc_type == 1; /* R_XTENSA_32. */
12666 default:
12667 {
12668 static unsigned int prev_warn = 0;
12669
12670 /* Avoid repeating the same warning multiple times. */
12671 if (prev_warn != filedata->file_header.e_machine)
12672 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12673 filedata->file_header.e_machine);
12674 prev_warn = filedata->file_header.e_machine;
12675 return FALSE;
12676 }
12677 }
12678}
12679
12680/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12681 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12682
12683static bfd_boolean
12684is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12685{
12686 switch (filedata->file_header.e_machine)
12687 /* Please keep this table alpha-sorted for ease of visual lookup. */
12688 {
12689 case EM_386:
12690 case EM_IAMCU:
12691 return reloc_type == 2; /* R_386_PC32. */
12692 case EM_68K:
12693 return reloc_type == 4; /* R_68K_PC32. */
12694 case EM_AARCH64:
12695 return reloc_type == 261; /* R_AARCH64_PREL32 */
12696 case EM_ADAPTEVA_EPIPHANY:
12697 return reloc_type == 6;
12698 case EM_ALPHA:
12699 return reloc_type == 10; /* R_ALPHA_SREL32. */
12700 case EM_ARC_COMPACT:
12701 case EM_ARC_COMPACT2:
12702 return reloc_type == 49; /* R_ARC_32_PCREL. */
12703 case EM_ARM:
12704 return reloc_type == 3; /* R_ARM_REL32 */
12705 case EM_AVR_OLD:
12706 case EM_AVR:
12707 return reloc_type == 36; /* R_AVR_32_PCREL. */
12708 case EM_MICROBLAZE:
12709 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
12710 case EM_OR1K:
12711 return reloc_type == 9; /* R_OR1K_32_PCREL. */
12712 case EM_PARISC:
12713 return reloc_type == 9; /* R_PARISC_PCREL32. */
12714 case EM_PPC:
12715 return reloc_type == 26; /* R_PPC_REL32. */
12716 case EM_PPC64:
12717 return reloc_type == 26; /* R_PPC64_REL32. */
12718 case EM_RISCV:
12719 return reloc_type == 57; /* R_RISCV_32_PCREL. */
12720 case EM_S390_OLD:
12721 case EM_S390:
12722 return reloc_type == 5; /* R_390_PC32. */
12723 case EM_SH:
12724 return reloc_type == 2; /* R_SH_REL32. */
12725 case EM_SPARC32PLUS:
12726 case EM_SPARCV9:
12727 case EM_SPARC:
12728 return reloc_type == 6; /* R_SPARC_DISP32. */
12729 case EM_SPU:
12730 return reloc_type == 13; /* R_SPU_REL32. */
12731 case EM_TILEGX:
12732 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
12733 case EM_TILEPRO:
12734 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
12735 case EM_VISIUM:
12736 return reloc_type == 6; /* R_VISIUM_32_PCREL */
12737 case EM_X86_64:
12738 case EM_L1OM:
12739 case EM_K1OM:
12740 return reloc_type == 2; /* R_X86_64_PC32. */
12741 case EM_VAX:
12742 return reloc_type == 4; /* R_VAX_PCREL32. */
12743 case EM_XTENSA_OLD:
12744 case EM_XTENSA:
12745 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
12746 default:
12747 /* Do not abort or issue an error message here. Not all targets use
12748 pc-relative 32-bit relocs in their DWARF debug information and we
12749 have already tested for target coverage in is_32bit_abs_reloc. A
12750 more helpful warning message will be generated by apply_relocations
12751 anyway, so just return. */
12752 return FALSE;
12753 }
12754}
12755
12756/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12757 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12758
12759static bfd_boolean
12760is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12761{
12762 switch (filedata->file_header.e_machine)
12763 {
12764 case EM_AARCH64:
12765 return reloc_type == 257; /* R_AARCH64_ABS64. */
12766 case EM_ALPHA:
12767 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
12768 case EM_IA_64:
12769 return (reloc_type == 0x26 /* R_IA64_DIR64MSB. */
12770 || reloc_type == 0x27 /* R_IA64_DIR64LSB. */);
12771 case EM_PARISC:
12772 return reloc_type == 80; /* R_PARISC_DIR64. */
12773 case EM_PPC64:
12774 return reloc_type == 38; /* R_PPC64_ADDR64. */
12775 case EM_RISCV:
12776 return reloc_type == 2; /* R_RISCV_64. */
12777 case EM_SPARC32PLUS:
12778 case EM_SPARCV9:
12779 case EM_SPARC:
12780 return reloc_type == 32 /* R_SPARC_64. */
12781 || reloc_type == 54; /* R_SPARC_UA64. */
12782 case EM_X86_64:
12783 case EM_L1OM:
12784 case EM_K1OM:
12785 return reloc_type == 1; /* R_X86_64_64. */
12786 case EM_S390_OLD:
12787 case EM_S390:
12788 return reloc_type == 22; /* R_S390_64. */
12789 case EM_TILEGX:
12790 return reloc_type == 1; /* R_TILEGX_64. */
12791 case EM_MIPS:
12792 return reloc_type == 18; /* R_MIPS_64. */
12793 default:
12794 return FALSE;
12795 }
12796}
12797
12798/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12799 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12800
12801static bfd_boolean
12802is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12803{
12804 switch (filedata->file_header.e_machine)
12805 {
12806 case EM_AARCH64:
12807 return reloc_type == 260; /* R_AARCH64_PREL64. */
12808 case EM_ALPHA:
12809 return reloc_type == 11; /* R_ALPHA_SREL64. */
12810 case EM_IA_64:
12811 return (reloc_type == 0x4e /* R_IA64_PCREL64MSB. */
12812 || reloc_type == 0x4f /* R_IA64_PCREL64LSB. */);
12813 case EM_PARISC:
12814 return reloc_type == 72; /* R_PARISC_PCREL64. */
12815 case EM_PPC64:
12816 return reloc_type == 44; /* R_PPC64_REL64. */
12817 case EM_SPARC32PLUS:
12818 case EM_SPARCV9:
12819 case EM_SPARC:
12820 return reloc_type == 46; /* R_SPARC_DISP64. */
12821 case EM_X86_64:
12822 case EM_L1OM:
12823 case EM_K1OM:
12824 return reloc_type == 24; /* R_X86_64_PC64. */
12825 case EM_S390_OLD:
12826 case EM_S390:
12827 return reloc_type == 23; /* R_S390_PC64. */
12828 case EM_TILEGX:
12829 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
12830 default:
12831 return FALSE;
12832 }
12833}
12834
12835/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12836 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12837
12838static bfd_boolean
12839is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12840{
12841 switch (filedata->file_header.e_machine)
12842 {
12843 case EM_CYGNUS_MN10200:
12844 case EM_MN10200:
12845 return reloc_type == 4; /* R_MN10200_24. */
12846 case EM_FT32:
12847 return reloc_type == 5; /* R_FT32_20. */
12848 default:
12849 return FALSE;
12850 }
12851}
12852
12853/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12854 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12855
12856static bfd_boolean
12857is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12858{
12859 /* Please keep this table alpha-sorted for ease of visual lookup. */
12860 switch (filedata->file_header.e_machine)
12861 {
12862 case EM_ARC:
12863 case EM_ARC_COMPACT:
12864 case EM_ARC_COMPACT2:
12865 return reloc_type == 2; /* R_ARC_16. */
12866 case EM_ADAPTEVA_EPIPHANY:
12867 return reloc_type == 5;
12868 case EM_AVR_OLD:
12869 case EM_AVR:
12870 return reloc_type == 4; /* R_AVR_16. */
12871 case EM_CYGNUS_D10V:
12872 case EM_D10V:
12873 return reloc_type == 3; /* R_D10V_16. */
12874 case EM_FT32:
12875 return reloc_type == 2; /* R_FT32_16. */
12876 case EM_H8S:
12877 case EM_H8_300:
12878 case EM_H8_300H:
12879 return reloc_type == R_H8_DIR16;
12880 case EM_IP2K_OLD:
12881 case EM_IP2K:
12882 return reloc_type == 1; /* R_IP2K_16. */
12883 case EM_M32C_OLD:
12884 case EM_M32C:
12885 return reloc_type == 1; /* R_M32C_16 */
12886 case EM_CYGNUS_MN10200:
12887 case EM_MN10200:
12888 return reloc_type == 2; /* R_MN10200_16. */
12889 case EM_CYGNUS_MN10300:
12890 case EM_MN10300:
12891 return reloc_type == 2; /* R_MN10300_16. */
12892 case EM_MSP430:
12893 if (uses_msp430x_relocs (filedata))
12894 return reloc_type == 2; /* R_MSP430_ABS16. */
12895 /* Fall through. */
12896 case EM_MSP430_OLD:
12897 return reloc_type == 5; /* R_MSP430_16_BYTE. */
12898 case EM_NDS32:
12899 return reloc_type == 19; /* R_NDS32_RELA. */
12900 case EM_ALTERA_NIOS2:
12901 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
12902 case EM_NIOS32:
12903 return reloc_type == 9; /* R_NIOS_16. */
12904 case EM_OR1K:
12905 return reloc_type == 2; /* R_OR1K_16. */
12906 case EM_RISCV:
12907 return reloc_type == 55; /* R_RISCV_SET16. */
12908 case EM_TI_PRU:
12909 return reloc_type == 8; /* R_PRU_BFD_RELOC_16. */
12910 case EM_TI_C6000:
12911 return reloc_type == 2; /* R_C6000_ABS16. */
12912 case EM_VISIUM:
12913 return reloc_type == 2; /* R_VISIUM_16. */
12914 case EM_XC16X:
12915 case EM_C166:
12916 return reloc_type == 2; /* R_XC16C_ABS_16. */
12917 case EM_XGATE:
12918 return reloc_type == 3; /* R_XGATE_16. */
12919 default:
12920 return FALSE;
12921 }
12922}
12923
12924/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12925 a 8-bit absolute RELA relocation used in DWARF debug sections. */
12926
12927static bfd_boolean
12928is_8bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12929{
12930 switch (filedata->file_header.e_machine)
12931 {
12932 case EM_RISCV:
12933 return reloc_type == 54; /* R_RISCV_SET8. */
12934 default:
12935 return FALSE;
12936 }
12937}
12938
12939/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12940 a 6-bit absolute RELA relocation used in DWARF debug sections. */
12941
12942static bfd_boolean
12943is_6bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12944{
12945 switch (filedata->file_header.e_machine)
12946 {
12947 case EM_RISCV:
12948 return reloc_type == 53; /* R_RISCV_SET6. */
12949 default:
12950 return FALSE;
12951 }
12952}
12953
12954/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12955 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
12956
12957static bfd_boolean
12958is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12959{
12960 /* Please keep this table alpha-sorted for ease of visual lookup. */
12961 switch (filedata->file_header.e_machine)
12962 {
12963 case EM_RISCV:
12964 return reloc_type == 35; /* R_RISCV_ADD32. */
12965 default:
12966 return FALSE;
12967 }
12968}
12969
12970/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12971 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
12972
12973static bfd_boolean
12974is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12975{
12976 /* Please keep this table alpha-sorted for ease of visual lookup. */
12977 switch (filedata->file_header.e_machine)
12978 {
12979 case EM_RISCV:
12980 return reloc_type == 39; /* R_RISCV_SUB32. */
12981 default:
12982 return FALSE;
12983 }
12984}
12985
12986/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12987 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
12988
12989static bfd_boolean
12990is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12991{
12992 /* Please keep this table alpha-sorted for ease of visual lookup. */
12993 switch (filedata->file_header.e_machine)
12994 {
12995 case EM_RISCV:
12996 return reloc_type == 36; /* R_RISCV_ADD64. */
12997 default:
12998 return FALSE;
12999 }
13000}
13001
13002/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13003 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13004
13005static bfd_boolean
13006is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13007{
13008 /* Please keep this table alpha-sorted for ease of visual lookup. */
13009 switch (filedata->file_header.e_machine)
13010 {
13011 case EM_RISCV:
13012 return reloc_type == 40; /* R_RISCV_SUB64. */
13013 default:
13014 return FALSE;
13015 }
13016}
13017
13018/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13019 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13020
13021static bfd_boolean
13022is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13023{
13024 /* Please keep this table alpha-sorted for ease of visual lookup. */
13025 switch (filedata->file_header.e_machine)
13026 {
13027 case EM_RISCV:
13028 return reloc_type == 34; /* R_RISCV_ADD16. */
13029 default:
13030 return FALSE;
13031 }
13032}
13033
13034/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13035 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13036
13037static bfd_boolean
13038is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13039{
13040 /* Please keep this table alpha-sorted for ease of visual lookup. */
13041 switch (filedata->file_header.e_machine)
13042 {
13043 case EM_RISCV:
13044 return reloc_type == 38; /* R_RISCV_SUB16. */
13045 default:
13046 return FALSE;
13047 }
13048}
13049
13050/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13051 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13052
13053static bfd_boolean
13054is_8bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13055{
13056 /* Please keep this table alpha-sorted for ease of visual lookup. */
13057 switch (filedata->file_header.e_machine)
13058 {
13059 case EM_RISCV:
13060 return reloc_type == 33; /* R_RISCV_ADD8. */
13061 default:
13062 return FALSE;
13063 }
13064}
13065
13066/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13067 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13068
13069static bfd_boolean
13070is_8bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13071{
13072 /* Please keep this table alpha-sorted for ease of visual lookup. */
13073 switch (filedata->file_header.e_machine)
13074 {
13075 case EM_RISCV:
13076 return reloc_type == 37; /* R_RISCV_SUB8. */
13077 default:
13078 return FALSE;
13079 }
13080}
13081
13082/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13083 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13084
13085static bfd_boolean
13086is_6bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13087{
13088 switch (filedata->file_header.e_machine)
13089 {
13090 case EM_RISCV:
13091 return reloc_type == 52; /* R_RISCV_SUB6. */
13092 default:
13093 return FALSE;
13094 }
13095}
13096
13097/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13098 relocation entries (possibly formerly used for SHT_GROUP sections). */
13099
13100static bfd_boolean
13101is_none_reloc (Filedata * filedata, unsigned int reloc_type)
13102{
13103 switch (filedata->file_header.e_machine)
13104 {
13105 case EM_386: /* R_386_NONE. */
13106 case EM_68K: /* R_68K_NONE. */
13107 case EM_ADAPTEVA_EPIPHANY:
13108 case EM_ALPHA: /* R_ALPHA_NONE. */
13109 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
13110 case EM_ARC: /* R_ARC_NONE. */
13111 case EM_ARC_COMPACT2: /* R_ARC_NONE. */
13112 case EM_ARC_COMPACT: /* R_ARC_NONE. */
13113 case EM_ARM: /* R_ARM_NONE. */
13114 case EM_C166: /* R_XC16X_NONE. */
13115 case EM_CRIS: /* R_CRIS_NONE. */
13116 case EM_FT32: /* R_FT32_NONE. */
13117 case EM_IA_64: /* R_IA64_NONE. */
13118 case EM_K1OM: /* R_X86_64_NONE. */
13119 case EM_L1OM: /* R_X86_64_NONE. */
13120 case EM_M32R: /* R_M32R_NONE. */
13121 case EM_MIPS: /* R_MIPS_NONE. */
13122 case EM_MN10300: /* R_MN10300_NONE. */
13123 case EM_MOXIE: /* R_MOXIE_NONE. */
13124 case EM_NIOS32: /* R_NIOS_NONE. */
13125 case EM_OR1K: /* R_OR1K_NONE. */
13126 case EM_PARISC: /* R_PARISC_NONE. */
13127 case EM_PPC64: /* R_PPC64_NONE. */
13128 case EM_PPC: /* R_PPC_NONE. */
13129 case EM_RISCV: /* R_RISCV_NONE. */
13130 case EM_S390: /* R_390_NONE. */
13131 case EM_S390_OLD:
13132 case EM_SH: /* R_SH_NONE. */
13133 case EM_SPARC32PLUS:
13134 case EM_SPARC: /* R_SPARC_NONE. */
13135 case EM_SPARCV9:
13136 case EM_TILEGX: /* R_TILEGX_NONE. */
13137 case EM_TILEPRO: /* R_TILEPRO_NONE. */
13138 case EM_TI_C6000:/* R_C6000_NONE. */
13139 case EM_X86_64: /* R_X86_64_NONE. */
13140 case EM_XC16X:
13141 case EM_WEBASSEMBLY: /* R_WASM32_NONE. */
13142 return reloc_type == 0;
13143
13144 case EM_AARCH64:
13145 return reloc_type == 0 || reloc_type == 256;
13146 case EM_AVR_OLD:
13147 case EM_AVR:
13148 return (reloc_type == 0 /* R_AVR_NONE. */
13149 || reloc_type == 30 /* R_AVR_DIFF8. */
13150 || reloc_type == 31 /* R_AVR_DIFF16. */
13151 || reloc_type == 32 /* R_AVR_DIFF32. */);
13152 case EM_METAG:
13153 return reloc_type == 3; /* R_METAG_NONE. */
13154 case EM_NDS32:
13155 return (reloc_type == 0 /* R_XTENSA_NONE. */
13156 || reloc_type == 204 /* R_NDS32_DIFF8. */
13157 || reloc_type == 205 /* R_NDS32_DIFF16. */
13158 || reloc_type == 206 /* R_NDS32_DIFF32. */
13159 || reloc_type == 207 /* R_NDS32_ULEB128. */);
13160 case EM_TI_PRU:
13161 return (reloc_type == 0 /* R_PRU_NONE. */
13162 || reloc_type == 65 /* R_PRU_DIFF8. */
13163 || reloc_type == 66 /* R_PRU_DIFF16. */
13164 || reloc_type == 67 /* R_PRU_DIFF32. */);
13165 case EM_XTENSA_OLD:
13166 case EM_XTENSA:
13167 return (reloc_type == 0 /* R_XTENSA_NONE. */
13168 || reloc_type == 17 /* R_XTENSA_DIFF8. */
13169 || reloc_type == 18 /* R_XTENSA_DIFF16. */
13170 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
13171 }
13172 return FALSE;
13173}
13174
13175/* Returns TRUE if there is a relocation against
13176 section NAME at OFFSET bytes. */
13177
13178bfd_boolean
13179reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
13180{
13181 Elf_Internal_Rela * relocs;
13182 Elf_Internal_Rela * rp;
13183
13184 if (dsec == NULL || dsec->reloc_info == NULL)
13185 return FALSE;
13186
13187 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
13188
13189 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
13190 if (rp->r_offset == offset)
13191 return TRUE;
13192
13193 return FALSE;
13194}
13195
13196/* Apply relocations to a section.
13197 Returns TRUE upon success, FALSE otherwise.
13198 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13199 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13200 will be set to the number of relocs loaded.
13201
13202 Note: So far support has been added only for those relocations
13203 which can be found in debug sections. FIXME: Add support for
13204 more relocations ? */
13205
13206static bfd_boolean
13207apply_relocations (Filedata * filedata,
13208 const Elf_Internal_Shdr * section,
13209 unsigned char * start,
13210 bfd_size_type size,
13211 void ** relocs_return,
13212 unsigned long * num_relocs_return)
13213{
13214 Elf_Internal_Shdr * relsec;
13215 unsigned char * end = start + size;
13216
13217 if (relocs_return != NULL)
13218 {
13219 * (Elf_Internal_Rela **) relocs_return = NULL;
13220 * num_relocs_return = 0;
13221 }
13222
13223 if (filedata->file_header.e_type != ET_REL)
13224 /* No relocs to apply. */
13225 return TRUE;
13226
13227 /* Find the reloc section associated with the section. */
13228 for (relsec = filedata->section_headers;
13229 relsec < filedata->section_headers + filedata->file_header.e_shnum;
13230 ++relsec)
13231 {
13232 bfd_boolean is_rela;
13233 unsigned long num_relocs;
13234 Elf_Internal_Rela * relocs;
13235 Elf_Internal_Rela * rp;
13236 Elf_Internal_Shdr * symsec;
13237 Elf_Internal_Sym * symtab;
13238 unsigned long num_syms;
13239 Elf_Internal_Sym * sym;
13240
13241 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13242 || relsec->sh_info >= filedata->file_header.e_shnum
13243 || filedata->section_headers + relsec->sh_info != section
13244 || relsec->sh_size == 0
13245 || relsec->sh_link >= filedata->file_header.e_shnum)
13246 continue;
13247
13248 is_rela = relsec->sh_type == SHT_RELA;
13249
13250 if (is_rela)
13251 {
13252 if (!slurp_rela_relocs (filedata, relsec->sh_offset,
13253 relsec->sh_size, & relocs, & num_relocs))
13254 return FALSE;
13255 }
13256 else
13257 {
13258 if (!slurp_rel_relocs (filedata, relsec->sh_offset,
13259 relsec->sh_size, & relocs, & num_relocs))
13260 return FALSE;
13261 }
13262
13263 /* SH uses RELA but uses in place value instead of the addend field. */
13264 if (filedata->file_header.e_machine == EM_SH)
13265 is_rela = FALSE;
13266
13267 symsec = filedata->section_headers + relsec->sh_link;
13268 if (symsec->sh_type != SHT_SYMTAB
13269 && symsec->sh_type != SHT_DYNSYM)
13270 return FALSE;
13271 symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
13272
13273 for (rp = relocs; rp < relocs + num_relocs; ++rp)
13274 {
13275 bfd_vma addend;
13276 unsigned int reloc_type;
13277 unsigned int reloc_size;
13278 bfd_boolean reloc_inplace = FALSE;
13279 bfd_boolean reloc_subtract = FALSE;
13280 unsigned char * rloc;
13281 unsigned long sym_index;
13282
13283 reloc_type = get_reloc_type (filedata, rp->r_info);
13284
13285 if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
13286 continue;
13287 else if (is_none_reloc (filedata, reloc_type))
13288 continue;
13289 else if (is_32bit_abs_reloc (filedata, reloc_type)
13290 || is_32bit_pcrel_reloc (filedata, reloc_type))
13291 reloc_size = 4;
13292 else if (is_64bit_abs_reloc (filedata, reloc_type)
13293 || is_64bit_pcrel_reloc (filedata, reloc_type))
13294 reloc_size = 8;
13295 else if (is_24bit_abs_reloc (filedata, reloc_type))
13296 reloc_size = 3;
13297 else if (is_16bit_abs_reloc (filedata, reloc_type))
13298 reloc_size = 2;
13299 else if (is_8bit_abs_reloc (filedata, reloc_type)
13300 || is_6bit_abs_reloc (filedata, reloc_type))
13301 reloc_size = 1;
13302 else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
13303 reloc_type))
13304 || is_32bit_inplace_add_reloc (filedata, reloc_type))
13305 {
13306 reloc_size = 4;
13307 reloc_inplace = TRUE;
13308 }
13309 else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
13310 reloc_type))
13311 || is_64bit_inplace_add_reloc (filedata, reloc_type))
13312 {
13313 reloc_size = 8;
13314 reloc_inplace = TRUE;
13315 }
13316 else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
13317 reloc_type))
13318 || is_16bit_inplace_add_reloc (filedata, reloc_type))
13319 {
13320 reloc_size = 2;
13321 reloc_inplace = TRUE;
13322 }
13323 else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
13324 reloc_type))
13325 || is_8bit_inplace_add_reloc (filedata, reloc_type))
13326 {
13327 reloc_size = 1;
13328 reloc_inplace = TRUE;
13329 }
13330 else if ((reloc_subtract = is_6bit_inplace_sub_reloc (filedata,
13331 reloc_type)))
13332 {
13333 reloc_size = 1;
13334 reloc_inplace = TRUE;
13335 }
13336 else
13337 {
13338 static unsigned int prev_reloc = 0;
13339
13340 if (reloc_type != prev_reloc)
13341 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13342 reloc_type, printable_section_name (filedata, section));
13343 prev_reloc = reloc_type;
13344 continue;
13345 }
13346
13347 rloc = start + rp->r_offset;
13348 if ((rloc + reloc_size) > end || (rloc < start))
13349 {
13350 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13351 (unsigned long) rp->r_offset,
13352 printable_section_name (filedata, section));
13353 continue;
13354 }
13355
13356 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
13357 if (sym_index >= num_syms)
13358 {
13359 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13360 sym_index, printable_section_name (filedata, section));
13361 continue;
13362 }
13363 sym = symtab + sym_index;
13364
13365 /* If the reloc has a symbol associated with it,
13366 make sure that it is of an appropriate type.
13367
13368 Relocations against symbols without type can happen.
13369 Gcc -feliminate-dwarf2-dups may generate symbols
13370 without type for debug info.
13371
13372 Icc generates relocations against function symbols
13373 instead of local labels.
13374
13375 Relocations against object symbols can happen, eg when
13376 referencing a global array. For an example of this see
13377 the _clz.o binary in libgcc.a. */
13378 if (sym != symtab
13379 && ELF_ST_TYPE (sym->st_info) != STT_COMMON
13380 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
13381 {
13382 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13383 get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
13384 printable_section_name (filedata, relsec),
13385 (long int)(rp - relocs));
13386 continue;
13387 }
13388
13389 addend = 0;
13390 if (is_rela)
13391 addend += rp->r_addend;
13392 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13393 partial_inplace. */
13394 if (!is_rela
13395 || (filedata->file_header.e_machine == EM_XTENSA
13396 && reloc_type == 1)
13397 || ((filedata->file_header.e_machine == EM_PJ
13398 || filedata->file_header.e_machine == EM_PJ_OLD)
13399 && reloc_type == 1)
13400 || ((filedata->file_header.e_machine == EM_D30V
13401 || filedata->file_header.e_machine == EM_CYGNUS_D30V)
13402 && reloc_type == 12)
13403 || reloc_inplace)
13404 {
13405 if (is_6bit_inplace_sub_reloc (filedata, reloc_type))
13406 addend += byte_get (rloc, reloc_size) & 0x3f;
13407 else
13408 addend += byte_get (rloc, reloc_size);
13409 }
13410
13411 if (is_32bit_pcrel_reloc (filedata, reloc_type)
13412 || is_64bit_pcrel_reloc (filedata, reloc_type))
13413 {
13414 /* On HPPA, all pc-relative relocations are biased by 8. */
13415 if (filedata->file_header.e_machine == EM_PARISC)
13416 addend -= 8;
13417 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
13418 reloc_size);
13419 }
13420 else if (is_6bit_abs_reloc (filedata, reloc_type)
13421 || is_6bit_inplace_sub_reloc (filedata, reloc_type))
13422 {
13423 if (reloc_subtract)
13424 addend -= sym->st_value;
13425 else
13426 addend += sym->st_value;
13427 addend = (addend & 0x3f) | (byte_get (rloc, reloc_size) & 0xc0);
13428 byte_put (rloc, addend, reloc_size);
13429 }
13430 else if (reloc_subtract)
13431 byte_put (rloc, addend - sym->st_value, reloc_size);
13432 else
13433 byte_put (rloc, addend + sym->st_value, reloc_size);
13434 }
13435
13436 free (symtab);
13437 /* Let the target specific reloc processing code know that
13438 we have finished with these relocs. */
13439 target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
13440
13441 if (relocs_return)
13442 {
13443 * (Elf_Internal_Rela **) relocs_return = relocs;
13444 * num_relocs_return = num_relocs;
13445 }
13446 else
13447 free (relocs);
13448
13449 break;
13450 }
13451
13452 return TRUE;
13453}
13454
13455#ifdef SUPPORT_DISASSEMBLY
13456static bfd_boolean
13457disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
13458{
13459 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
13460
13461 /* FIXME: XXX -- to be done --- XXX */
13462
13463 return TRUE;
13464}
13465#endif
13466
13467/* Reads in the contents of SECTION from FILE, returning a pointer
13468 to a malloc'ed buffer or NULL if something went wrong. */
13469
13470static char *
13471get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
13472{
13473 bfd_size_type num_bytes = section->sh_size;
13474
13475 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
13476 {
13477 printf (_("Section '%s' has no data to dump.\n"),
13478 printable_section_name (filedata, section));
13479 return NULL;
13480 }
13481
13482 return (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
13483 _("section contents"));
13484}
13485
13486/* Uncompresses a section that was compressed using zlib, in place. */
13487
13488static bfd_boolean
13489uncompress_section_contents (unsigned char ** buffer,
13490 dwarf_size_type uncompressed_size,
13491 dwarf_size_type * size)
13492{
13493 dwarf_size_type compressed_size = *size;
13494 unsigned char * compressed_buffer = *buffer;
13495 unsigned char * uncompressed_buffer;
13496 z_stream strm;
13497 int rc;
13498
13499 /* It is possible the section consists of several compressed
13500 buffers concatenated together, so we uncompress in a loop. */
13501 /* PR 18313: The state field in the z_stream structure is supposed
13502 to be invisible to the user (ie us), but some compilers will
13503 still complain about it being used without initialisation. So
13504 we first zero the entire z_stream structure and then set the fields
13505 that we need. */
13506 memset (& strm, 0, sizeof strm);
13507 strm.avail_in = compressed_size;
13508 strm.next_in = (Bytef *) compressed_buffer;
13509 strm.avail_out = uncompressed_size;
13510 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
13511
13512 rc = inflateInit (& strm);
13513 while (strm.avail_in > 0)
13514 {
13515 if (rc != Z_OK)
13516 goto fail;
13517 strm.next_out = ((Bytef *) uncompressed_buffer
13518 + (uncompressed_size - strm.avail_out));
13519 rc = inflate (&strm, Z_FINISH);
13520 if (rc != Z_STREAM_END)
13521 goto fail;
13522 rc = inflateReset (& strm);
13523 }
13524 rc = inflateEnd (& strm);
13525 if (rc != Z_OK
13526 || strm.avail_out != 0)
13527 goto fail;
13528
13529 *buffer = uncompressed_buffer;
13530 *size = uncompressed_size;
13531 return TRUE;
13532
13533 fail:
13534 free (uncompressed_buffer);
13535 /* Indicate decompression failure. */
13536 *buffer = NULL;
13537 return FALSE;
13538}
13539
13540static bfd_boolean
13541dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
13542{
13543 Elf_Internal_Shdr * relsec;
13544 bfd_size_type num_bytes;
13545 unsigned char * data;
13546 unsigned char * end;
13547 unsigned char * real_start;
13548 unsigned char * start;
13549 bfd_boolean some_strings_shown;
13550
13551 real_start = start = (unsigned char *) get_section_contents (section, filedata);
13552 if (start == NULL)
13553 /* PR 21820: Do not fail if the section was empty. */
13554 return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13555
13556 num_bytes = section->sh_size;
13557
13558 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
13559
13560 if (decompress_dumps)
13561 {
13562 dwarf_size_type new_size = num_bytes;
13563 dwarf_size_type uncompressed_size = 0;
13564
13565 if ((section->sh_flags & SHF_COMPRESSED) != 0)
13566 {
13567 Elf_Internal_Chdr chdr;
13568 unsigned int compression_header_size
13569 = get_compression_header (& chdr, (unsigned char *) start,
13570 num_bytes);
13571
13572 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13573 {
13574 warn (_("section '%s' has unsupported compress type: %d\n"),
13575 printable_section_name (filedata, section), chdr.ch_type);
13576 return FALSE;
13577 }
13578 uncompressed_size = chdr.ch_size;
13579 start += compression_header_size;
13580 new_size -= compression_header_size;
13581 }
13582 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13583 {
13584 /* Read the zlib header. In this case, it should be "ZLIB"
13585 followed by the uncompressed section size, 8 bytes in
13586 big-endian order. */
13587 uncompressed_size = start[4]; uncompressed_size <<= 8;
13588 uncompressed_size += start[5]; uncompressed_size <<= 8;
13589 uncompressed_size += start[6]; uncompressed_size <<= 8;
13590 uncompressed_size += start[7]; uncompressed_size <<= 8;
13591 uncompressed_size += start[8]; uncompressed_size <<= 8;
13592 uncompressed_size += start[9]; uncompressed_size <<= 8;
13593 uncompressed_size += start[10]; uncompressed_size <<= 8;
13594 uncompressed_size += start[11];
13595 start += 12;
13596 new_size -= 12;
13597 }
13598
13599 if (uncompressed_size)
13600 {
13601 if (uncompress_section_contents (& start,
13602 uncompressed_size, & new_size))
13603 num_bytes = new_size;
13604 else
13605 {
13606 error (_("Unable to decompress section %s\n"),
13607 printable_section_name (filedata, section));
13608 return FALSE;
13609 }
13610 }
13611 else
13612 start = real_start;
13613 }
13614
13615 /* If the section being dumped has relocations against it the user might
13616 be expecting these relocations to have been applied. Check for this
13617 case and issue a warning message in order to avoid confusion.
13618 FIXME: Maybe we ought to have an option that dumps a section with
13619 relocs applied ? */
13620 for (relsec = filedata->section_headers;
13621 relsec < filedata->section_headers + filedata->file_header.e_shnum;
13622 ++relsec)
13623 {
13624 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13625 || relsec->sh_info >= filedata->file_header.e_shnum
13626 || filedata->section_headers + relsec->sh_info != section
13627 || relsec->sh_size == 0
13628 || relsec->sh_link >= filedata->file_header.e_shnum)
13629 continue;
13630
13631 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13632 break;
13633 }
13634
13635 data = start;
13636 end = start + num_bytes;
13637 some_strings_shown = FALSE;
13638
13639 while (data < end)
13640 {
13641 while (!ISPRINT (* data))
13642 if (++ data >= end)
13643 break;
13644
13645 if (data < end)
13646 {
13647 size_t maxlen = end - data;
13648
13649#ifndef __MSVCRT__
13650 /* PR 11128: Use two separate invocations in order to work
13651 around bugs in the Solaris 8 implementation of printf. */
13652 printf (" [%6tx] ", data - start);
13653#else
13654 printf (" [%6Ix] ", (size_t) (data - start));
13655#endif
13656 if (maxlen > 0)
13657 {
13658 print_symbol ((int) maxlen, (const char *) data);
13659 putchar ('\n');
13660 data += strnlen ((const char *) data, maxlen);
13661 }
13662 else
13663 {
13664 printf (_("<corrupt>\n"));
13665 data = end;
13666 }
13667 some_strings_shown = TRUE;
13668 }
13669 }
13670
13671 if (! some_strings_shown)
13672 printf (_(" No strings found in this section."));
13673
13674 free (real_start);
13675
13676 putchar ('\n');
13677 return TRUE;
13678}
13679
13680static bfd_boolean
13681dump_section_as_bytes (Elf_Internal_Shdr * section,
13682 Filedata * filedata,
13683 bfd_boolean relocate)
13684{
13685 Elf_Internal_Shdr * relsec;
13686 bfd_size_type bytes;
13687 bfd_size_type section_size;
13688 bfd_vma addr;
13689 unsigned char * data;
13690 unsigned char * real_start;
13691 unsigned char * start;
13692
13693 real_start = start = (unsigned char *) get_section_contents (section, filedata);
13694 if (start == NULL)
13695 /* PR 21820: Do not fail if the section was empty. */
13696 return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13697
13698 section_size = section->sh_size;
13699
13700 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
13701
13702 if (decompress_dumps)
13703 {
13704 dwarf_size_type new_size = section_size;
13705 dwarf_size_type uncompressed_size = 0;
13706
13707 if ((section->sh_flags & SHF_COMPRESSED) != 0)
13708 {
13709 Elf_Internal_Chdr chdr;
13710 unsigned int compression_header_size
13711 = get_compression_header (& chdr, start, section_size);
13712
13713 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13714 {
13715 warn (_("section '%s' has unsupported compress type: %d\n"),
13716 printable_section_name (filedata, section), chdr.ch_type);
13717 return FALSE;
13718 }
13719 uncompressed_size = chdr.ch_size;
13720 start += compression_header_size;
13721 new_size -= compression_header_size;
13722 }
13723 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13724 {
13725 /* Read the zlib header. In this case, it should be "ZLIB"
13726 followed by the uncompressed section size, 8 bytes in
13727 big-endian order. */
13728 uncompressed_size = start[4]; uncompressed_size <<= 8;
13729 uncompressed_size += start[5]; uncompressed_size <<= 8;
13730 uncompressed_size += start[6]; uncompressed_size <<= 8;
13731 uncompressed_size += start[7]; uncompressed_size <<= 8;
13732 uncompressed_size += start[8]; uncompressed_size <<= 8;
13733 uncompressed_size += start[9]; uncompressed_size <<= 8;
13734 uncompressed_size += start[10]; uncompressed_size <<= 8;
13735 uncompressed_size += start[11];
13736 start += 12;
13737 new_size -= 12;
13738 }
13739
13740 if (uncompressed_size)
13741 {
13742 if (uncompress_section_contents (& start, uncompressed_size,
13743 & new_size))
13744 {
13745 section_size = new_size;
13746 }
13747 else
13748 {
13749 error (_("Unable to decompress section %s\n"),
13750 printable_section_name (filedata, section));
13751 /* FIXME: Print the section anyway ? */
13752 return FALSE;
13753 }
13754 }
13755 else
13756 start = real_start;
13757 }
13758
13759 if (relocate)
13760 {
13761 if (! apply_relocations (filedata, section, start, section_size, NULL, NULL))
13762 return FALSE;
13763 }
13764 else
13765 {
13766 /* If the section being dumped has relocations against it the user might
13767 be expecting these relocations to have been applied. Check for this
13768 case and issue a warning message in order to avoid confusion.
13769 FIXME: Maybe we ought to have an option that dumps a section with
13770 relocs applied ? */
13771 for (relsec = filedata->section_headers;
13772 relsec < filedata->section_headers + filedata->file_header.e_shnum;
13773 ++relsec)
13774 {
13775 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13776 || relsec->sh_info >= filedata->file_header.e_shnum
13777 || filedata->section_headers + relsec->sh_info != section
13778 || relsec->sh_size == 0
13779 || relsec->sh_link >= filedata->file_header.e_shnum)
13780 continue;
13781
13782 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13783 break;
13784 }
13785 }
13786
13787 addr = section->sh_addr;
13788 bytes = section_size;
13789 data = start;
13790
13791 while (bytes)
13792 {
13793 int j;
13794 int k;
13795 int lbytes;
13796
13797 lbytes = (bytes > 16 ? 16 : bytes);
13798
13799 printf (" 0x%8.8lx ", (unsigned long) addr);
13800
13801 for (j = 0; j < 16; j++)
13802 {
13803 if (j < lbytes)
13804 printf ("%2.2x", data[j]);
13805 else
13806 printf (" ");
13807
13808 if ((j & 3) == 3)
13809 printf (" ");
13810 }
13811
13812 for (j = 0; j < lbytes; j++)
13813 {
13814 k = data[j];
13815 if (k >= ' ' && k < 0x7f)
13816 printf ("%c", k);
13817 else
13818 printf (".");
13819 }
13820
13821 putchar ('\n');
13822
13823 data += lbytes;
13824 addr += lbytes;
13825 bytes -= lbytes;
13826 }
13827
13828 free (real_start);
13829
13830 putchar ('\n');
13831 return TRUE;
13832}
13833
13834static ctf_sect_t *
13835shdr_to_ctf_sect (ctf_sect_t *buf, Elf_Internal_Shdr *shdr, Filedata *filedata)
13836{
13837 buf->cts_name = SECTION_NAME (shdr);
13838 buf->cts_size = shdr->sh_size;
13839 buf->cts_entsize = shdr->sh_entsize;
13840
13841 return buf;
13842}
13843
13844/* Formatting callback function passed to ctf_dump. Returns either the pointer
13845 it is passed, or a pointer to newly-allocated storage, in which case
13846 dump_ctf() will free it when it no longer needs it. */
13847
13848static char *dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED,
13849 char *s, void *arg)
13850{
13851 char *spaces = arg;
13852 char *new_s;
13853
13854 if (asprintf (&new_s, "%s%s", spaces, s) < 0)
13855 return s;
13856 return new_s;
13857}
13858
13859static bfd_boolean
13860dump_section_as_ctf (Elf_Internal_Shdr * section, Filedata * filedata)
13861{
13862 Elf_Internal_Shdr * parent_sec = NULL;
13863 Elf_Internal_Shdr * symtab_sec = NULL;
13864 Elf_Internal_Shdr * strtab_sec = NULL;
13865 void * data = NULL;
13866 void * symdata = NULL;
13867 void * strdata = NULL;
13868 void * parentdata = NULL;
13869 ctf_sect_t ctfsect, symsect, strsect, parentsect;
13870 ctf_sect_t * symsectp = NULL;
13871 ctf_sect_t * strsectp = NULL;
13872 ctf_file_t * ctf = NULL;
13873 ctf_file_t * parent = NULL;
13874
13875 const char *things[] = {"Labels", "Data objects", "Function objects",
13876 "Variables", "Types", "Strings", ""};
13877 const char **thing;
13878 int err;
13879 bfd_boolean ret = FALSE;
13880 size_t i;
13881
13882 shdr_to_ctf_sect (&ctfsect, section, filedata);
13883 data = get_section_contents (section, filedata);
13884 ctfsect.cts_data = data;
13885
13886 if (dump_ctf_symtab_name)
13887 {
13888 if ((symtab_sec = find_section (filedata, dump_ctf_symtab_name)) == NULL)
13889 {
13890 error (_("No symbol section named %s\n"), dump_ctf_symtab_name);
13891 goto fail;
13892 }
13893 if ((symdata = (void *) get_data (NULL, filedata,
13894 symtab_sec->sh_offset, 1,
13895 symtab_sec->sh_size,
13896 _("symbols"))) == NULL)
13897 goto fail;
13898 symsectp = shdr_to_ctf_sect (&symsect, symtab_sec, filedata);
13899 symsect.cts_data = symdata;
13900 }
13901 if (dump_ctf_strtab_name)
13902 {
13903 if ((strtab_sec = find_section (filedata, dump_ctf_strtab_name)) == NULL)
13904 {
13905 error (_("No string table section named %s\n"),
13906 dump_ctf_strtab_name);
13907 goto fail;
13908 }
13909 if ((strdata = (void *) get_data (NULL, filedata,
13910 strtab_sec->sh_offset, 1,
13911 strtab_sec->sh_size,
13912 _("strings"))) == NULL)
13913 goto fail;
13914 strsectp = shdr_to_ctf_sect (&strsect, strtab_sec, filedata);
13915 strsect.cts_data = strdata;
13916 }
13917 if (dump_ctf_parent_name)
13918 {
13919 if ((parent_sec = find_section (filedata, dump_ctf_parent_name)) == NULL)
13920 {
13921 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name);
13922 goto fail;
13923 }
13924 if ((parentdata = (void *) get_data (NULL, filedata,
13925 parent_sec->sh_offset, 1,
13926 parent_sec->sh_size,
13927 _("CTF parent"))) == NULL)
13928 goto fail;
13929 shdr_to_ctf_sect (&parentsect, parent_sec, filedata);
13930 parentsect.cts_data = parentdata;
13931 }
13932
13933 /* Load the CTF file and dump it. */
13934
13935 if ((ctf = ctf_bufopen (&ctfsect, symsectp, strsectp, &err)) == NULL)
13936 {
13937 error (_("CTF open failure: %s\n"), ctf_errmsg (err));
13938 goto fail;
13939 }
13940
13941 if (parentdata)
13942 {
13943 if ((parent = ctf_bufopen (&parentsect, symsectp, strsectp, &err)) == NULL)
13944 {
13945 error (_("CTF open failure: %s\n"), ctf_errmsg (err));
13946 goto fail;
13947 }
13948
13949 ctf_import (ctf, parent);
13950 }
13951
13952 ret = TRUE;
13953
13954 printf (_("\nDump of CTF section '%s':\n"),
13955 printable_section_name (filedata, section));
13956
13957 for (i = 1, thing = things; *thing[0]; thing++, i++)
13958 {
13959 ctf_dump_state_t *s = NULL;
13960 char *item;
13961
13962 printf ("\n %s:\n", *thing);
13963 while ((item = ctf_dump (ctf, &s, i, dump_ctf_indent_lines,
13964 (void *) " ")) != NULL)
13965 {
13966 printf ("%s\n", item);
13967 free (item);
13968 }
13969
13970 if (ctf_errno (ctf))
13971 {
13972 error (_("Iteration failed: %s, %s\n"), *thing,
13973 ctf_errmsg (ctf_errno (ctf)));
13974 ret = FALSE;
13975 }
13976 }
13977
13978 fail:
13979 ctf_file_close (ctf);
13980 ctf_file_close (parent);
13981 free (parentdata);
13982 free (data);
13983 free (symdata);
13984 free (strdata);
13985 return ret;
13986}
13987
13988static bfd_boolean
13989load_specific_debug_section (enum dwarf_section_display_enum debug,
13990 const Elf_Internal_Shdr * sec,
13991 void * data)
13992{
13993 struct dwarf_section * section = &debug_displays [debug].section;
13994 char buf [64];
13995 Filedata * filedata = (Filedata *) data;
13996
13997 if (section->start != NULL)
13998 {
13999 /* If it is already loaded, do nothing. */
14000 if (streq (section->filename, filedata->file_name))
14001 return TRUE;
14002 free (section->start);
14003 }
14004
14005 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
14006 section->address = sec->sh_addr;
14007 section->user_data = NULL;
14008 section->filename = filedata->file_name;
14009 section->start = (unsigned char *) get_data (NULL, filedata,
14010 sec->sh_offset, 1,
14011 sec->sh_size, buf);
14012 if (section->start == NULL)
14013 section->size = 0;
14014 else
14015 {
14016 unsigned char *start = section->start;
14017 dwarf_size_type size = sec->sh_size;
14018 dwarf_size_type uncompressed_size = 0;
14019
14020 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
14021 {
14022 Elf_Internal_Chdr chdr;
14023 unsigned int compression_header_size;
14024
14025 if (size < (is_32bit_elf
14026 ? sizeof (Elf32_External_Chdr)
14027 : sizeof (Elf64_External_Chdr)))
14028 {
14029 warn (_("compressed section %s is too small to contain a compression header"),
14030 section->name);
14031 return FALSE;
14032 }
14033
14034 compression_header_size = get_compression_header (&chdr, start, size);
14035
14036 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
14037 {
14038 warn (_("section '%s' has unsupported compress type: %d\n"),
14039 section->name, chdr.ch_type);
14040 return FALSE;
14041 }
14042 uncompressed_size = chdr.ch_size;
14043 start += compression_header_size;
14044 size -= compression_header_size;
14045 }
14046 else if (size > 12 && streq ((char *) start, "ZLIB"))
14047 {
14048 /* Read the zlib header. In this case, it should be "ZLIB"
14049 followed by the uncompressed section size, 8 bytes in
14050 big-endian order. */
14051 uncompressed_size = start[4]; uncompressed_size <<= 8;
14052 uncompressed_size += start[5]; uncompressed_size <<= 8;
14053 uncompressed_size += start[6]; uncompressed_size <<= 8;
14054 uncompressed_size += start[7]; uncompressed_size <<= 8;
14055 uncompressed_size += start[8]; uncompressed_size <<= 8;
14056 uncompressed_size += start[9]; uncompressed_size <<= 8;
14057 uncompressed_size += start[10]; uncompressed_size <<= 8;
14058 uncompressed_size += start[11];
14059 start += 12;
14060 size -= 12;
14061 }
14062
14063 if (uncompressed_size)
14064 {
14065 if (uncompress_section_contents (&start, uncompressed_size,
14066 &size))
14067 {
14068 /* Free the compressed buffer, update the section buffer
14069 and the section size if uncompress is successful. */
14070 free (section->start);
14071 section->start = start;
14072 }
14073 else
14074 {
14075 error (_("Unable to decompress section %s\n"),
14076 printable_section_name (filedata, sec));
14077 return FALSE;
14078 }
14079 }
14080
14081 section->size = size;
14082 }
14083
14084 if (section->start == NULL)
14085 return FALSE;
14086
14087 if (debug_displays [debug].relocate)
14088 {
14089 if (! apply_relocations (filedata, sec, section->start, section->size,
14090 & section->reloc_info, & section->num_relocs))
14091 return FALSE;
14092 }
14093 else
14094 {
14095 section->reloc_info = NULL;
14096 section->num_relocs = 0;
14097 }
14098
14099 return TRUE;
14100}
14101
14102/* If this is not NULL, load_debug_section will only look for sections
14103 within the list of sections given here. */
14104static unsigned int * section_subset = NULL;
14105
14106bfd_boolean
14107load_debug_section (enum dwarf_section_display_enum debug, void * data)
14108{
14109 struct dwarf_section * section = &debug_displays [debug].section;
14110 Elf_Internal_Shdr * sec;
14111 Filedata * filedata = (Filedata *) data;
14112
14113 /* Without section headers we cannot find any sections. */
14114 if (filedata->section_headers == NULL)
14115 return FALSE;
14116
14117 if (filedata->string_table == NULL
14118 && filedata->file_header.e_shstrndx != SHN_UNDEF
14119 && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
14120 {
14121 Elf_Internal_Shdr * strs;
14122
14123 /* Read in the string table, so that we have section names to scan. */
14124 strs = filedata->section_headers + filedata->file_header.e_shstrndx;
14125
14126 if (strs != NULL && strs->sh_size != 0)
14127 {
14128 filedata->string_table
14129 = (char *) get_data (NULL, filedata, strs->sh_offset,
14130 1, strs->sh_size, _("string table"));
14131
14132 filedata->string_table_length
14133 = filedata->string_table != NULL ? strs->sh_size : 0;
14134 }
14135 }
14136
14137 /* Locate the debug section. */
14138 sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
14139 if (sec != NULL)
14140 section->name = section->uncompressed_name;
14141 else
14142 {
14143 sec = find_section_in_set (filedata, section->compressed_name, section_subset);
14144 if (sec != NULL)
14145 section->name = section->compressed_name;
14146 }
14147 if (sec == NULL)
14148 return FALSE;
14149
14150 /* If we're loading from a subset of sections, and we've loaded
14151 a section matching this name before, it's likely that it's a
14152 different one. */
14153 if (section_subset != NULL)
14154 free_debug_section (debug);
14155
14156 return load_specific_debug_section (debug, sec, data);
14157}
14158
14159void
14160free_debug_section (enum dwarf_section_display_enum debug)
14161{
14162 struct dwarf_section * section = &debug_displays [debug].section;
14163
14164 if (section->start == NULL)
14165 return;
14166
14167 free ((char *) section->start);
14168 section->start = NULL;
14169 section->address = 0;
14170 section->size = 0;
14171}
14172
14173static bfd_boolean
14174display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
14175{
14176 char * name = SECTION_NAME (section);
14177 const char * print_name = printable_section_name (filedata, section);
14178 bfd_size_type length;
14179 bfd_boolean result = TRUE;
14180 int i;
14181
14182 length = section->sh_size;
14183 if (length == 0)
14184 {
14185 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
14186 return TRUE;
14187 }
14188 if (section->sh_type == SHT_NOBITS)
14189 {
14190 /* There is no point in dumping the contents of a debugging section
14191 which has the NOBITS type - the bits in the file will be random.
14192 This can happen when a file containing a .eh_frame section is
14193 stripped with the --only-keep-debug command line option. */
14194 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14195 print_name);
14196 return FALSE;
14197 }
14198
14199 if (const_strneq (name, ".gnu.linkonce.wi."))
14200 name = ".debug_info";
14201
14202 /* See if we know how to display the contents of this section. */
14203 for (i = 0; i < max; i++)
14204 {
14205 enum dwarf_section_display_enum id = (enum dwarf_section_display_enum) i;
14206 struct dwarf_section_display * display = debug_displays + i;
14207 struct dwarf_section * sec = & display->section;
14208
14209 if (streq (sec->uncompressed_name, name)
14210 || (id == line && const_strneq (name, ".debug_line."))
14211 || streq (sec->compressed_name, name))
14212 {
14213 bfd_boolean secondary = (section != find_section (filedata, name));
14214
14215 if (secondary)
14216 free_debug_section (id);
14217
14218 if (i == line && const_strneq (name, ".debug_line."))
14219 sec->name = name;
14220 else if (streq (sec->uncompressed_name, name))
14221 sec->name = sec->uncompressed_name;
14222 else
14223 sec->name = sec->compressed_name;
14224
14225 if (load_specific_debug_section (id, section, filedata))
14226 {
14227 /* If this debug section is part of a CU/TU set in a .dwp file,
14228 restrict load_debug_section to the sections in that set. */
14229 section_subset = find_cu_tu_set (filedata, shndx);
14230
14231 result &= display->display (sec, filedata);
14232
14233 section_subset = NULL;
14234
14235 if (secondary || (id != info && id != abbrev))
14236 free_debug_section (id);
14237 }
14238 break;
14239 }
14240 }
14241
14242 if (i == max)
14243 {
14244 printf (_("Unrecognized debug section: %s\n"), print_name);
14245 result = FALSE;
14246 }
14247
14248 return result;
14249}
14250
14251/* Set DUMP_SECTS for all sections where dumps were requested
14252 based on section name. */
14253
14254static void
14255initialise_dumps_byname (Filedata * filedata)
14256{
14257 struct dump_list_entry * cur;
14258
14259 for (cur = dump_sects_byname; cur; cur = cur->next)
14260 {
14261 unsigned int i;
14262 bfd_boolean any = FALSE;
14263
14264 for (i = 0; i < filedata->file_header.e_shnum; i++)
14265 if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
14266 {
14267 request_dump_bynumber (filedata, i, cur->type);
14268 any = TRUE;
14269 }
14270
14271 if (!any)
14272 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14273 cur->name);
14274 }
14275}
14276
14277static bfd_boolean
14278process_section_contents (Filedata * filedata)
14279{
14280 Elf_Internal_Shdr * section;
14281 unsigned int i;
14282 bfd_boolean res = TRUE;
14283
14284 if (! do_dump)
14285 return TRUE;
14286
14287 initialise_dumps_byname (filedata);
14288
14289 for (i = 0, section = filedata->section_headers;
14290 i < filedata->file_header.e_shnum && i < filedata->num_dump_sects;
14291 i++, section++)
14292 {
14293 dump_type dump = filedata->dump_sects[i];
14294
14295#ifdef SUPPORT_DISASSEMBLY
14296 if (dump & DISASS_DUMP)
14297 {
14298 if (! disassemble_section (section, filedata))
14299 res = FALSE;
14300 }
14301#endif
14302 if (dump & HEX_DUMP)
14303 {
14304 if (! dump_section_as_bytes (section, filedata, FALSE))
14305 res = FALSE;
14306 }
14307
14308 if (dump & RELOC_DUMP)
14309 {
14310 if (! dump_section_as_bytes (section, filedata, TRUE))
14311 res = FALSE;
14312 }
14313
14314 if (dump & STRING_DUMP)
14315 {
14316 if (! dump_section_as_strings (section, filedata))
14317 res = FALSE;
14318 }
14319
14320 if (dump & DEBUG_DUMP)
14321 {
14322 if (! display_debug_section (i, section, filedata))
14323 res = FALSE;
14324 }
14325
14326 if (dump & CTF_DUMP)
14327 {
14328 if (! dump_section_as_ctf (section, filedata))
14329 res = FALSE;
14330 }
14331 }
14332
14333 /* Check to see if the user requested a
14334 dump of a section that does not exist. */
14335 while (i < filedata->num_dump_sects)
14336 {
14337 if (filedata->dump_sects[i])
14338 {
14339 warn (_("Section %d was not dumped because it does not exist!\n"), i);
14340 res = FALSE;
14341 }
14342 i++;
14343 }
14344
14345 return res;
14346}
14347
14348static void
14349process_mips_fpe_exception (int mask)
14350{
14351 if (mask)
14352 {
14353 bfd_boolean first = TRUE;
14354
14355 if (mask & OEX_FPU_INEX)
14356 fputs ("INEX", stdout), first = FALSE;
14357 if (mask & OEX_FPU_UFLO)
14358 printf ("%sUFLO", first ? "" : "|"), first = FALSE;
14359 if (mask & OEX_FPU_OFLO)
14360 printf ("%sOFLO", first ? "" : "|"), first = FALSE;
14361 if (mask & OEX_FPU_DIV0)
14362 printf ("%sDIV0", first ? "" : "|"), first = FALSE;
14363 if (mask & OEX_FPU_INVAL)
14364 printf ("%sINVAL", first ? "" : "|");
14365 }
14366 else
14367 fputs ("0", stdout);
14368}
14369
14370/* Display's the value of TAG at location P. If TAG is
14371 greater than 0 it is assumed to be an unknown tag, and
14372 a message is printed to this effect. Otherwise it is
14373 assumed that a message has already been printed.
14374
14375 If the bottom bit of TAG is set it assumed to have a
14376 string value, otherwise it is assumed to have an integer
14377 value.
14378
14379 Returns an updated P pointing to the first unread byte
14380 beyond the end of TAG's value.
14381
14382 Reads at or beyond END will not be made. */
14383
14384static unsigned char *
14385display_tag_value (signed int tag,
14386 unsigned char * p,
14387 const unsigned char * const end)
14388{
14389 unsigned long val;
14390
14391 if (tag > 0)
14392 printf (" Tag_unknown_%d: ", tag);
14393
14394 if (p >= end)
14395 {
14396 warn (_("<corrupt tag>\n"));
14397 }
14398 else if (tag & 1)
14399 {
14400 /* PR 17531 file: 027-19978-0.004. */
14401 size_t maxlen = (end - p) - 1;
14402
14403 putchar ('"');
14404 if (maxlen > 0)
14405 {
14406 print_symbol ((int) maxlen, (const char *) p);
14407 p += strnlen ((char *) p, maxlen) + 1;
14408 }
14409 else
14410 {
14411 printf (_("<corrupt string tag>"));
14412 p = (unsigned char *) end;
14413 }
14414 printf ("\"\n");
14415 }
14416 else
14417 {
14418 unsigned int len;
14419
14420 val = read_uleb128 (p, &len, end);
14421 p += len;
14422 printf ("%ld (0x%lx)\n", val, val);
14423 }
14424
14425 assert (p <= end);
14426 return p;
14427}
14428
14429/* ARC ABI attributes section. */
14430
14431static unsigned char *
14432display_arc_attribute (unsigned char * p,
14433 const unsigned char * const end)
14434{
14435 unsigned int tag;
14436 unsigned int len;
14437 unsigned int val;
14438
14439 tag = read_uleb128 (p, &len, end);
14440 p += len;
14441
14442 switch (tag)
14443 {
14444 case Tag_ARC_PCS_config:
14445 val = read_uleb128 (p, &len, end);
14446 p += len;
14447 printf (" Tag_ARC_PCS_config: ");
14448 switch (val)
14449 {
14450 case 0:
14451 printf (_("Absent/Non standard\n"));
14452 break;
14453 case 1:
14454 printf (_("Bare metal/mwdt\n"));
14455 break;
14456 case 2:
14457 printf (_("Bare metal/newlib\n"));
14458 break;
14459 case 3:
14460 printf (_("Linux/uclibc\n"));
14461 break;
14462 case 4:
14463 printf (_("Linux/glibc\n"));
14464 break;
14465 default:
14466 printf (_("Unknown\n"));
14467 break;
14468 }
14469 break;
14470
14471 case Tag_ARC_CPU_base:
14472 val = read_uleb128 (p, &len, end);
14473 p += len;
14474 printf (" Tag_ARC_CPU_base: ");
14475 switch (val)
14476 {
14477 default:
14478 case TAG_CPU_NONE:
14479 printf (_("Absent\n"));
14480 break;
14481 case TAG_CPU_ARC6xx:
14482 printf ("ARC6xx\n");
14483 break;
14484 case TAG_CPU_ARC7xx:
14485 printf ("ARC7xx\n");
14486 break;
14487 case TAG_CPU_ARCEM:
14488 printf ("ARCEM\n");
14489 break;
14490 case TAG_CPU_ARCHS:
14491 printf ("ARCHS\n");
14492 break;
14493 }
14494 break;
14495
14496 case Tag_ARC_CPU_variation:
14497 val = read_uleb128 (p, &len, end);
14498 p += len;
14499 printf (" Tag_ARC_CPU_variation: ");
14500 switch (val)
14501 {
14502 default:
14503 if (val > 0 && val < 16)
14504 printf ("Core%d\n", val);
14505 else
14506 printf ("Unknown\n");
14507 break;
14508
14509 case 0:
14510 printf (_("Absent\n"));
14511 break;
14512 }
14513 break;
14514
14515 case Tag_ARC_CPU_name:
14516 printf (" Tag_ARC_CPU_name: ");
14517 p = display_tag_value (-1, p, end);
14518 break;
14519
14520 case Tag_ARC_ABI_rf16:
14521 val = read_uleb128 (p, &len, end);
14522 p += len;
14523 printf (" Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
14524 break;
14525
14526 case Tag_ARC_ABI_osver:
14527 val = read_uleb128 (p, &len, end);
14528 p += len;
14529 printf (" Tag_ARC_ABI_osver: v%d\n", val);
14530 break;
14531
14532 case Tag_ARC_ABI_pic:
14533 case Tag_ARC_ABI_sda:
14534 val = read_uleb128 (p, &len, end);
14535 p += len;
14536 printf (tag == Tag_ARC_ABI_sda ? " Tag_ARC_ABI_sda: "
14537 : " Tag_ARC_ABI_pic: ");
14538 switch (val)
14539 {
14540 case 0:
14541 printf (_("Absent\n"));
14542 break;
14543 case 1:
14544 printf ("MWDT\n");
14545 break;
14546 case 2:
14547 printf ("GNU\n");
14548 break;
14549 default:
14550 printf (_("Unknown\n"));
14551 break;
14552 }
14553 break;
14554
14555 case Tag_ARC_ABI_tls:
14556 val = read_uleb128 (p, &len, end);
14557 p += len;
14558 printf (" Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
14559 break;
14560
14561 case Tag_ARC_ABI_enumsize:
14562 val = read_uleb128 (p, &len, end);
14563 p += len;
14564 printf (" Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
14565 _("smallest"));
14566 break;
14567
14568 case Tag_ARC_ABI_exceptions:
14569 val = read_uleb128 (p, &len, end);
14570 p += len;
14571 printf (" Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
14572 : _("default"));
14573 break;
14574
14575 case Tag_ARC_ABI_double_size:
14576 val = read_uleb128 (p, &len, end);
14577 p += len;
14578 printf (" Tag_ARC_ABI_double_size: %d\n", val);
14579 break;
14580
14581 case Tag_ARC_ISA_config:
14582 printf (" Tag_ARC_ISA_config: ");
14583 p = display_tag_value (-1, p, end);
14584 break;
14585
14586 case Tag_ARC_ISA_apex:
14587 printf (" Tag_ARC_ISA_apex: ");
14588 p = display_tag_value (-1, p, end);
14589 break;
14590
14591 case Tag_ARC_ISA_mpy_option:
14592 val = read_uleb128 (p, &len, end);
14593 p += len;
14594 printf (" Tag_ARC_ISA_mpy_option: %d\n", val);
14595 break;
14596
14597 case Tag_ARC_ATR_version:
14598 val = read_uleb128 (p, &len, end);
14599 p += len;
14600 printf (" Tag_ARC_ATR_version: %d\n", val);
14601 break;
14602
14603 default:
14604 return display_tag_value (tag & 1, p, end);
14605 }
14606
14607 return p;
14608}
14609
14610/* ARM EABI attributes section. */
14611typedef struct
14612{
14613 unsigned int tag;
14614 const char * name;
14615 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14616 unsigned int type;
14617 const char ** table;
14618} arm_attr_public_tag;
14619
14620static const char * arm_attr_tag_CPU_arch[] =
14621 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14622 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14623 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
14624static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
14625static const char * arm_attr_tag_THUMB_ISA_use[] =
14626 {"No", "Thumb-1", "Thumb-2", "Yes"};
14627static const char * arm_attr_tag_FP_arch[] =
14628 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14629 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14630static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
14631static const char * arm_attr_tag_Advanced_SIMD_arch[] =
14632 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14633 "NEON for ARMv8.1"};
14634static const char * arm_attr_tag_PCS_config[] =
14635 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14636 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14637static const char * arm_attr_tag_ABI_PCS_R9_use[] =
14638 {"V6", "SB", "TLS", "Unused"};
14639static const char * arm_attr_tag_ABI_PCS_RW_data[] =
14640 {"Absolute", "PC-relative", "SB-relative", "None"};
14641static const char * arm_attr_tag_ABI_PCS_RO_data[] =
14642 {"Absolute", "PC-relative", "None"};
14643static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
14644 {"None", "direct", "GOT-indirect"};
14645static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
14646 {"None", "??? 1", "2", "??? 3", "4"};
14647static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
14648static const char * arm_attr_tag_ABI_FP_denormal[] =
14649 {"Unused", "Needed", "Sign only"};
14650static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
14651static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
14652static const char * arm_attr_tag_ABI_FP_number_model[] =
14653 {"Unused", "Finite", "RTABI", "IEEE 754"};
14654static const char * arm_attr_tag_ABI_enum_size[] =
14655 {"Unused", "small", "int", "forced to int"};
14656static const char * arm_attr_tag_ABI_HardFP_use[] =
14657 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14658static const char * arm_attr_tag_ABI_VFP_args[] =
14659 {"AAPCS", "VFP registers", "custom", "compatible"};
14660static const char * arm_attr_tag_ABI_WMMX_args[] =
14661 {"AAPCS", "WMMX registers", "custom"};
14662static const char * arm_attr_tag_ABI_optimization_goals[] =
14663 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14664 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14665static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
14666 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14667 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14668static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
14669static const char * arm_attr_tag_FP_HP_extension[] =
14670 {"Not Allowed", "Allowed"};
14671static const char * arm_attr_tag_ABI_FP_16bit_format[] =
14672 {"None", "IEEE 754", "Alternative Format"};
14673static const char * arm_attr_tag_DSP_extension[] =
14674 {"Follow architecture", "Allowed"};
14675static const char * arm_attr_tag_MPextension_use[] =
14676 {"Not Allowed", "Allowed"};
14677static const char * arm_attr_tag_DIV_use[] =
14678 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14679 "Allowed in v7-A with integer division extension"};
14680static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
14681static const char * arm_attr_tag_Virtualization_use[] =
14682 {"Not Allowed", "TrustZone", "Virtualization Extensions",
14683 "TrustZone and Virtualization Extensions"};
14684static const char * arm_attr_tag_MPextension_use_legacy[] =
14685 {"Not Allowed", "Allowed"};
14686
14687static const char * arm_attr_tag_MVE_arch[] =
14688 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
14689
14690#define LOOKUP(id, name) \
14691 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14692static arm_attr_public_tag arm_attr_public_tags[] =
14693{
14694 {4, "CPU_raw_name", 1, NULL},
14695 {5, "CPU_name", 1, NULL},
14696 LOOKUP(6, CPU_arch),
14697 {7, "CPU_arch_profile", 0, NULL},
14698 LOOKUP(8, ARM_ISA_use),
14699 LOOKUP(9, THUMB_ISA_use),
14700 LOOKUP(10, FP_arch),
14701 LOOKUP(11, WMMX_arch),
14702 LOOKUP(12, Advanced_SIMD_arch),
14703 LOOKUP(13, PCS_config),
14704 LOOKUP(14, ABI_PCS_R9_use),
14705 LOOKUP(15, ABI_PCS_RW_data),
14706 LOOKUP(16, ABI_PCS_RO_data),
14707 LOOKUP(17, ABI_PCS_GOT_use),
14708 LOOKUP(18, ABI_PCS_wchar_t),
14709 LOOKUP(19, ABI_FP_rounding),
14710 LOOKUP(20, ABI_FP_denormal),
14711 LOOKUP(21, ABI_FP_exceptions),
14712 LOOKUP(22, ABI_FP_user_exceptions),
14713 LOOKUP(23, ABI_FP_number_model),
14714 {24, "ABI_align_needed", 0, NULL},
14715 {25, "ABI_align_preserved", 0, NULL},
14716 LOOKUP(26, ABI_enum_size),
14717 LOOKUP(27, ABI_HardFP_use),
14718 LOOKUP(28, ABI_VFP_args),
14719 LOOKUP(29, ABI_WMMX_args),
14720 LOOKUP(30, ABI_optimization_goals),
14721 LOOKUP(31, ABI_FP_optimization_goals),
14722 {32, "compatibility", 0, NULL},
14723 LOOKUP(34, CPU_unaligned_access),
14724 LOOKUP(36, FP_HP_extension),
14725 LOOKUP(38, ABI_FP_16bit_format),
14726 LOOKUP(42, MPextension_use),
14727 LOOKUP(44, DIV_use),
14728 LOOKUP(46, DSP_extension),
14729 LOOKUP(48, MVE_arch),
14730 {64, "nodefaults", 0, NULL},
14731 {65, "also_compatible_with", 0, NULL},
14732 LOOKUP(66, T2EE_use),
14733 {67, "conformance", 1, NULL},
14734 LOOKUP(68, Virtualization_use),
14735 LOOKUP(70, MPextension_use_legacy)
14736};
14737#undef LOOKUP
14738
14739static unsigned char *
14740display_arm_attribute (unsigned char * p,
14741 const unsigned char * const end)
14742{
14743 unsigned int tag;
14744 unsigned int len;
14745 unsigned int val;
14746 arm_attr_public_tag * attr;
14747 unsigned i;
14748 unsigned int type;
14749
14750 tag = read_uleb128 (p, &len, end);
14751 p += len;
14752 attr = NULL;
14753 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
14754 {
14755 if (arm_attr_public_tags[i].tag == tag)
14756 {
14757 attr = &arm_attr_public_tags[i];
14758 break;
14759 }
14760 }
14761
14762 if (attr)
14763 {
14764 printf (" Tag_%s: ", attr->name);
14765 switch (attr->type)
14766 {
14767 case 0:
14768 switch (tag)
14769 {
14770 case 7: /* Tag_CPU_arch_profile. */
14771 val = read_uleb128 (p, &len, end);
14772 p += len;
14773 switch (val)
14774 {
14775 case 0: printf (_("None\n")); break;
14776 case 'A': printf (_("Application\n")); break;
14777 case 'R': printf (_("Realtime\n")); break;
14778 case 'M': printf (_("Microcontroller\n")); break;
14779 case 'S': printf (_("Application or Realtime\n")); break;
14780 default: printf ("??? (%d)\n", val); break;
14781 }
14782 break;
14783
14784 case 24: /* Tag_align_needed. */
14785 val = read_uleb128 (p, &len, end);
14786 p += len;
14787 switch (val)
14788 {
14789 case 0: printf (_("None\n")); break;
14790 case 1: printf (_("8-byte\n")); break;
14791 case 2: printf (_("4-byte\n")); break;
14792 case 3: printf ("??? 3\n"); break;
14793 default:
14794 if (val <= 12)
14795 printf (_("8-byte and up to %d-byte extended\n"),
14796 1 << val);
14797 else
14798 printf ("??? (%d)\n", val);
14799 break;
14800 }
14801 break;
14802
14803 case 25: /* Tag_align_preserved. */
14804 val = read_uleb128 (p, &len, end);
14805 p += len;
14806 switch (val)
14807 {
14808 case 0: printf (_("None\n")); break;
14809 case 1: printf (_("8-byte, except leaf SP\n")); break;
14810 case 2: printf (_("8-byte\n")); break;
14811 case 3: printf ("??? 3\n"); break;
14812 default:
14813 if (val <= 12)
14814 printf (_("8-byte and up to %d-byte extended\n"),
14815 1 << val);
14816 else
14817 printf ("??? (%d)\n", val);
14818 break;
14819 }
14820 break;
14821
14822 case 32: /* Tag_compatibility. */
14823 {
14824 val = read_uleb128 (p, &len, end);
14825 p += len;
14826 printf (_("flag = %d, vendor = "), val);
14827 if (p < end - 1)
14828 {
14829 size_t maxlen = (end - p) - 1;
14830
14831 print_symbol ((int) maxlen, (const char *) p);
14832 p += strnlen ((char *) p, maxlen) + 1;
14833 }
14834 else
14835 {
14836 printf (_("<corrupt>"));
14837 p = (unsigned char *) end;
14838 }
14839 putchar ('\n');
14840 }
14841 break;
14842
14843 case 64: /* Tag_nodefaults. */
14844 /* PR 17531: file: 001-505008-0.01. */
14845 if (p < end)
14846 p++;
14847 printf (_("True\n"));
14848 break;
14849
14850 case 65: /* Tag_also_compatible_with. */
14851 val = read_uleb128 (p, &len, end);
14852 p += len;
14853 if (val == 6 /* Tag_CPU_arch. */)
14854 {
14855 val = read_uleb128 (p, &len, end);
14856 p += len;
14857 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
14858 printf ("??? (%d)\n", val);
14859 else
14860 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
14861 }
14862 else
14863 printf ("???\n");
14864 while (p < end && *(p++) != '\0' /* NUL terminator. */)
14865 ;
14866 break;
14867
14868 default:
14869 printf (_("<unknown: %d>\n"), tag);
14870 break;
14871 }
14872 return p;
14873
14874 case 1:
14875 return display_tag_value (-1, p, end);
14876 case 2:
14877 return display_tag_value (0, p, end);
14878
14879 default:
14880 assert (attr->type & 0x80);
14881 val = read_uleb128 (p, &len, end);
14882 p += len;
14883 type = attr->type & 0x7f;
14884 if (val >= type)
14885 printf ("??? (%d)\n", val);
14886 else
14887 printf ("%s\n", attr->table[val]);
14888 return p;
14889 }
14890 }
14891
14892 return display_tag_value (tag, p, end);
14893}
14894
14895static unsigned char *
14896display_gnu_attribute (unsigned char * p,
14897 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
14898 const unsigned char * const end)
14899{
14900 int tag;
14901 unsigned int len;
14902 unsigned int val;
14903
14904 tag = read_uleb128 (p, &len, end);
14905 p += len;
14906
14907 /* Tag_compatibility is the only generic GNU attribute defined at
14908 present. */
14909 if (tag == 32)
14910 {
14911 val = read_uleb128 (p, &len, end);
14912 p += len;
14913
14914 printf (_("flag = %d, vendor = "), val);
14915 if (p == end)
14916 {
14917 printf (_("<corrupt>\n"));
14918 warn (_("corrupt vendor attribute\n"));
14919 }
14920 else
14921 {
14922 if (p < end - 1)
14923 {
14924 size_t maxlen = (end - p) - 1;
14925
14926 print_symbol ((int) maxlen, (const char *) p);
14927 p += strnlen ((char *) p, maxlen) + 1;
14928 }
14929 else
14930 {
14931 printf (_("<corrupt>"));
14932 p = (unsigned char *) end;
14933 }
14934 putchar ('\n');
14935 }
14936 return p;
14937 }
14938
14939 if ((tag & 2) == 0 && display_proc_gnu_attribute)
14940 return display_proc_gnu_attribute (p, tag, end);
14941
14942 return display_tag_value (tag, p, end);
14943}
14944
14945static unsigned char *
14946display_power_gnu_attribute (unsigned char * p,
14947 unsigned int tag,
14948 const unsigned char * const end)
14949{
14950 unsigned int len;
14951 unsigned int val;
14952
14953 if (tag == Tag_GNU_Power_ABI_FP)
14954 {
14955 val = read_uleb128 (p, &len, end);
14956 p += len;
14957 printf (" Tag_GNU_Power_ABI_FP: ");
14958 if (len == 0)
14959 {
14960 printf (_("<corrupt>\n"));
14961 return p;
14962 }
14963
14964 if (val > 15)
14965 printf ("(%#x), ", val);
14966
14967 switch (val & 3)
14968 {
14969 case 0:
14970 printf (_("unspecified hard/soft float, "));
14971 break;
14972 case 1:
14973 printf (_("hard float, "));
14974 break;
14975 case 2:
14976 printf (_("soft float, "));
14977 break;
14978 case 3:
14979 printf (_("single-precision hard float, "));
14980 break;
14981 }
14982
14983 switch (val & 0xC)
14984 {
14985 case 0:
14986 printf (_("unspecified long double\n"));
14987 break;
14988 case 4:
14989 printf (_("128-bit IBM long double\n"));
14990 break;
14991 case 8:
14992 printf (_("64-bit long double\n"));
14993 break;
14994 case 12:
14995 printf (_("128-bit IEEE long double\n"));
14996 break;
14997 }
14998 return p;
14999 }
15000
15001 if (tag == Tag_GNU_Power_ABI_Vector)
15002 {
15003 val = read_uleb128 (p, &len, end);
15004 p += len;
15005 printf (" Tag_GNU_Power_ABI_Vector: ");
15006 if (len == 0)
15007 {
15008 printf (_("<corrupt>\n"));
15009 return p;
15010 }
15011
15012 if (val > 3)
15013 printf ("(%#x), ", val);
15014
15015 switch (val & 3)
15016 {
15017 case 0:
15018 printf (_("unspecified\n"));
15019 break;
15020 case 1:
15021 printf (_("generic\n"));
15022 break;
15023 case 2:
15024 printf ("AltiVec\n");
15025 break;
15026 case 3:
15027 printf ("SPE\n");
15028 break;
15029 }
15030 return p;
15031 }
15032
15033 if (tag == Tag_GNU_Power_ABI_Struct_Return)
15034 {
15035 val = read_uleb128 (p, &len, end);
15036 p += len;
15037 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15038 if (len == 0)
15039 {
15040 printf (_("<corrupt>\n"));
15041 return p;
15042 }
15043
15044 if (val > 2)
15045 printf ("(%#x), ", val);
15046
15047 switch (val & 3)
15048 {
15049 case 0:
15050 printf (_("unspecified\n"));
15051 break;
15052 case 1:
15053 printf ("r3/r4\n");
15054 break;
15055 case 2:
15056 printf (_("memory\n"));
15057 break;
15058 case 3:
15059 printf ("???\n");
15060 break;
15061 }
15062 return p;
15063 }
15064
15065 return display_tag_value (tag & 1, p, end);
15066}
15067
15068static unsigned char *
15069display_s390_gnu_attribute (unsigned char * p,
15070 unsigned int tag,
15071 const unsigned char * const end)
15072{
15073 unsigned int len;
15074 int val;
15075
15076 if (tag == Tag_GNU_S390_ABI_Vector)
15077 {
15078 val = read_uleb128 (p, &len, end);
15079 p += len;
15080 printf (" Tag_GNU_S390_ABI_Vector: ");
15081
15082 switch (val)
15083 {
15084 case 0:
15085 printf (_("any\n"));
15086 break;
15087 case 1:
15088 printf (_("software\n"));
15089 break;
15090 case 2:
15091 printf (_("hardware\n"));
15092 break;
15093 default:
15094 printf ("??? (%d)\n", val);
15095 break;
15096 }
15097 return p;
15098 }
15099
15100 return display_tag_value (tag & 1, p, end);
15101}
15102
15103static void
15104display_sparc_hwcaps (unsigned int mask)
15105{
15106 if (mask)
15107 {
15108 bfd_boolean first = TRUE;
15109
15110 if (mask & ELF_SPARC_HWCAP_MUL32)
15111 fputs ("mul32", stdout), first = FALSE;
15112 if (mask & ELF_SPARC_HWCAP_DIV32)
15113 printf ("%sdiv32", first ? "" : "|"), first = FALSE;
15114 if (mask & ELF_SPARC_HWCAP_FSMULD)
15115 printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
15116 if (mask & ELF_SPARC_HWCAP_V8PLUS)
15117 printf ("%sv8plus", first ? "" : "|"), first = FALSE;
15118 if (mask & ELF_SPARC_HWCAP_POPC)
15119 printf ("%spopc", first ? "" : "|"), first = FALSE;
15120 if (mask & ELF_SPARC_HWCAP_VIS)
15121 printf ("%svis", first ? "" : "|"), first = FALSE;
15122 if (mask & ELF_SPARC_HWCAP_VIS2)
15123 printf ("%svis2", first ? "" : "|"), first = FALSE;
15124 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
15125 printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
15126 if (mask & ELF_SPARC_HWCAP_FMAF)
15127 printf ("%sfmaf", first ? "" : "|"), first = FALSE;
15128 if (mask & ELF_SPARC_HWCAP_VIS3)
15129 printf ("%svis3", first ? "" : "|"), first = FALSE;
15130 if (mask & ELF_SPARC_HWCAP_HPC)
15131 printf ("%shpc", first ? "" : "|"), first = FALSE;
15132 if (mask & ELF_SPARC_HWCAP_RANDOM)
15133 printf ("%srandom", first ? "" : "|"), first = FALSE;
15134 if (mask & ELF_SPARC_HWCAP_TRANS)
15135 printf ("%strans", first ? "" : "|"), first = FALSE;
15136 if (mask & ELF_SPARC_HWCAP_FJFMAU)
15137 printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
15138 if (mask & ELF_SPARC_HWCAP_IMA)
15139 printf ("%sima", first ? "" : "|"), first = FALSE;
15140 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
15141 printf ("%scspare", first ? "" : "|"), first = FALSE;
15142 }
15143 else
15144 fputc ('0', stdout);
15145 fputc ('\n', stdout);
15146}
15147
15148static void
15149display_sparc_hwcaps2 (unsigned int mask)
15150{
15151 if (mask)
15152 {
15153 bfd_boolean first = TRUE;
15154
15155 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
15156 fputs ("fjathplus", stdout), first = FALSE;
15157 if (mask & ELF_SPARC_HWCAP2_VIS3B)
15158 printf ("%svis3b", first ? "" : "|"), first = FALSE;
15159 if (mask & ELF_SPARC_HWCAP2_ADP)
15160 printf ("%sadp", first ? "" : "|"), first = FALSE;
15161 if (mask & ELF_SPARC_HWCAP2_SPARC5)
15162 printf ("%ssparc5", first ? "" : "|"), first = FALSE;
15163 if (mask & ELF_SPARC_HWCAP2_MWAIT)
15164 printf ("%smwait", first ? "" : "|"), first = FALSE;
15165 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
15166 printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
15167 if (mask & ELF_SPARC_HWCAP2_XMONT)
15168 printf ("%sxmont2", first ? "" : "|"), first = FALSE;
15169 if (mask & ELF_SPARC_HWCAP2_NSEC)
15170 printf ("%snsec", first ? "" : "|"), first = FALSE;
15171 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
15172 printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
15173 if (mask & ELF_SPARC_HWCAP2_FJDES)
15174 printf ("%sfjdes", first ? "" : "|"), first = FALSE;
15175 if (mask & ELF_SPARC_HWCAP2_FJAES)
15176 printf ("%sfjaes", first ? "" : "|"), first = FALSE;
15177 }
15178 else
15179 fputc ('0', stdout);
15180 fputc ('\n', stdout);
15181}
15182
15183static unsigned char *
15184display_sparc_gnu_attribute (unsigned char * p,
15185 unsigned int tag,
15186 const unsigned char * const end)
15187{
15188 unsigned int len;
15189 int val;
15190
15191 if (tag == Tag_GNU_Sparc_HWCAPS)
15192 {
15193 val = read_uleb128 (p, &len, end);
15194 p += len;
15195 printf (" Tag_GNU_Sparc_HWCAPS: ");
15196 display_sparc_hwcaps (val);
15197 return p;
15198 }
15199 if (tag == Tag_GNU_Sparc_HWCAPS2)
15200 {
15201 val = read_uleb128 (p, &len, end);
15202 p += len;
15203 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15204 display_sparc_hwcaps2 (val);
15205 return p;
15206 }
15207
15208 return display_tag_value (tag, p, end);
15209}
15210
15211static void
15212print_mips_fp_abi_value (unsigned int val)
15213{
15214 switch (val)
15215 {
15216 case Val_GNU_MIPS_ABI_FP_ANY:
15217 printf (_("Hard or soft float\n"));
15218 break;
15219 case Val_GNU_MIPS_ABI_FP_DOUBLE:
15220 printf (_("Hard float (double precision)\n"));
15221 break;
15222 case Val_GNU_MIPS_ABI_FP_SINGLE:
15223 printf (_("Hard float (single precision)\n"));
15224 break;
15225 case Val_GNU_MIPS_ABI_FP_SOFT:
15226 printf (_("Soft float\n"));
15227 break;
15228 case Val_GNU_MIPS_ABI_FP_OLD_64:
15229 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15230 break;
15231 case Val_GNU_MIPS_ABI_FP_XX:
15232 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15233 break;
15234 case Val_GNU_MIPS_ABI_FP_64:
15235 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15236 break;
15237 case Val_GNU_MIPS_ABI_FP_64A:
15238 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15239 break;
15240 case Val_GNU_MIPS_ABI_FP_NAN2008:
15241 printf (_("NaN 2008 compatibility\n"));
15242 break;
15243 default:
15244 printf ("??? (%d)\n", val);
15245 break;
15246 }
15247}
15248
15249static unsigned char *
15250display_mips_gnu_attribute (unsigned char * p,
15251 unsigned int tag,
15252 const unsigned char * const end)
15253{
15254 if (tag == Tag_GNU_MIPS_ABI_FP)
15255 {
15256 unsigned int len;
15257 unsigned int val;
15258
15259 val = read_uleb128 (p, &len, end);
15260 p += len;
15261 printf (" Tag_GNU_MIPS_ABI_FP: ");
15262
15263 print_mips_fp_abi_value (val);
15264
15265 return p;
15266 }
15267
15268 if (tag == Tag_GNU_MIPS_ABI_MSA)
15269 {
15270 unsigned int len;
15271 unsigned int val;
15272
15273 val = read_uleb128 (p, &len, end);
15274 p += len;
15275 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15276
15277 switch (val)
15278 {
15279 case Val_GNU_MIPS_ABI_MSA_ANY:
15280 printf (_("Any MSA or not\n"));
15281 break;
15282 case Val_GNU_MIPS_ABI_MSA_128:
15283 printf (_("128-bit MSA\n"));
15284 break;
15285 default:
15286 printf ("??? (%d)\n", val);
15287 break;
15288 }
15289 return p;
15290 }
15291
15292 return display_tag_value (tag & 1, p, end);
15293}
15294
15295static unsigned char *
15296display_tic6x_attribute (unsigned char * p,
15297 const unsigned char * const end)
15298{
15299 unsigned int tag;
15300 unsigned int len;
15301 int val;
15302
15303 tag = read_uleb128 (p, &len, end);
15304 p += len;
15305
15306 switch (tag)
15307 {
15308 case Tag_ISA:
15309 val = read_uleb128 (p, &len, end);
15310 p += len;
15311 printf (" Tag_ISA: ");
15312
15313 switch (val)
15314 {
15315 case C6XABI_Tag_ISA_none:
15316 printf (_("None\n"));
15317 break;
15318 case C6XABI_Tag_ISA_C62X:
15319 printf ("C62x\n");
15320 break;
15321 case C6XABI_Tag_ISA_C67X:
15322 printf ("C67x\n");
15323 break;
15324 case C6XABI_Tag_ISA_C67XP:
15325 printf ("C67x+\n");
15326 break;
15327 case C6XABI_Tag_ISA_C64X:
15328 printf ("C64x\n");
15329 break;
15330 case C6XABI_Tag_ISA_C64XP:
15331 printf ("C64x+\n");
15332 break;
15333 case C6XABI_Tag_ISA_C674X:
15334 printf ("C674x\n");
15335 break;
15336 default:
15337 printf ("??? (%d)\n", val);
15338 break;
15339 }
15340 return p;
15341
15342 case Tag_ABI_wchar_t:
15343 val = read_uleb128 (p, &len, end);
15344 p += len;
15345 printf (" Tag_ABI_wchar_t: ");
15346 switch (val)
15347 {
15348 case 0:
15349 printf (_("Not used\n"));
15350 break;
15351 case 1:
15352 printf (_("2 bytes\n"));
15353 break;
15354 case 2:
15355 printf (_("4 bytes\n"));
15356 break;
15357 default:
15358 printf ("??? (%d)\n", val);
15359 break;
15360 }
15361 return p;
15362
15363 case Tag_ABI_stack_align_needed:
15364 val = read_uleb128 (p, &len, end);
15365 p += len;
15366 printf (" Tag_ABI_stack_align_needed: ");
15367 switch (val)
15368 {
15369 case 0:
15370 printf (_("8-byte\n"));
15371 break;
15372 case 1:
15373 printf (_("16-byte\n"));
15374 break;
15375 default:
15376 printf ("??? (%d)\n", val);
15377 break;
15378 }
15379 return p;
15380
15381 case Tag_ABI_stack_align_preserved:
15382 val = read_uleb128 (p, &len, end);
15383 p += len;
15384 printf (" Tag_ABI_stack_align_preserved: ");
15385 switch (val)
15386 {
15387 case 0:
15388 printf (_("8-byte\n"));
15389 break;
15390 case 1:
15391 printf (_("16-byte\n"));
15392 break;
15393 default:
15394 printf ("??? (%d)\n", val);
15395 break;
15396 }
15397 return p;
15398
15399 case Tag_ABI_DSBT:
15400 val = read_uleb128 (p, &len, end);
15401 p += len;
15402 printf (" Tag_ABI_DSBT: ");
15403 switch (val)
15404 {
15405 case 0:
15406 printf (_("DSBT addressing not used\n"));
15407 break;
15408 case 1:
15409 printf (_("DSBT addressing used\n"));
15410 break;
15411 default:
15412 printf ("??? (%d)\n", val);
15413 break;
15414 }
15415 return p;
15416
15417 case Tag_ABI_PID:
15418 val = read_uleb128 (p, &len, end);
15419 p += len;
15420 printf (" Tag_ABI_PID: ");
15421 switch (val)
15422 {
15423 case 0:
15424 printf (_("Data addressing position-dependent\n"));
15425 break;
15426 case 1:
15427 printf (_("Data addressing position-independent, GOT near DP\n"));
15428 break;
15429 case 2:
15430 printf (_("Data addressing position-independent, GOT far from DP\n"));
15431 break;
15432 default:
15433 printf ("??? (%d)\n", val);
15434 break;
15435 }
15436 return p;
15437
15438 case Tag_ABI_PIC:
15439 val = read_uleb128 (p, &len, end);
15440 p += len;
15441 printf (" Tag_ABI_PIC: ");
15442 switch (val)
15443 {
15444 case 0:
15445 printf (_("Code addressing position-dependent\n"));
15446 break;
15447 case 1:
15448 printf (_("Code addressing position-independent\n"));
15449 break;
15450 default:
15451 printf ("??? (%d)\n", val);
15452 break;
15453 }
15454 return p;
15455
15456 case Tag_ABI_array_object_alignment:
15457 val = read_uleb128 (p, &len, end);
15458 p += len;
15459 printf (" Tag_ABI_array_object_alignment: ");
15460 switch (val)
15461 {
15462 case 0:
15463 printf (_("8-byte\n"));
15464 break;
15465 case 1:
15466 printf (_("4-byte\n"));
15467 break;
15468 case 2:
15469 printf (_("16-byte\n"));
15470 break;
15471 default:
15472 printf ("??? (%d)\n", val);
15473 break;
15474 }
15475 return p;
15476
15477 case Tag_ABI_array_object_align_expected:
15478 val = read_uleb128 (p, &len, end);
15479 p += len;
15480 printf (" Tag_ABI_array_object_align_expected: ");
15481 switch (val)
15482 {
15483 case 0:
15484 printf (_("8-byte\n"));
15485 break;
15486 case 1:
15487 printf (_("4-byte\n"));
15488 break;
15489 case 2:
15490 printf (_("16-byte\n"));
15491 break;
15492 default:
15493 printf ("??? (%d)\n", val);
15494 break;
15495 }
15496 return p;
15497
15498 case Tag_ABI_compatibility:
15499 {
15500 val = read_uleb128 (p, &len, end);
15501 p += len;
15502 printf (" Tag_ABI_compatibility: ");
15503 printf (_("flag = %d, vendor = "), val);
15504 if (p < end - 1)
15505 {
15506 size_t maxlen = (end - p) - 1;
15507
15508 print_symbol ((int) maxlen, (const char *) p);
15509 p += strnlen ((char *) p, maxlen) + 1;
15510 }
15511 else
15512 {
15513 printf (_("<corrupt>"));
15514 p = (unsigned char *) end;
15515 }
15516 putchar ('\n');
15517 return p;
15518 }
15519
15520 case Tag_ABI_conformance:
15521 {
15522 printf (" Tag_ABI_conformance: \"");
15523 if (p < end - 1)
15524 {
15525 size_t maxlen = (end - p) - 1;
15526
15527 print_symbol ((int) maxlen, (const char *) p);
15528 p += strnlen ((char *) p, maxlen) + 1;
15529 }
15530 else
15531 {
15532 printf (_("<corrupt>"));
15533 p = (unsigned char *) end;
15534 }
15535 printf ("\"\n");
15536 return p;
15537 }
15538 }
15539
15540 return display_tag_value (tag, p, end);
15541}
15542
15543static void
15544display_raw_attribute (unsigned char * p, unsigned char const * const end)
15545{
15546 unsigned long addr = 0;
15547 size_t bytes = end - p;
15548
15549 assert (end >= p);
15550 while (bytes)
15551 {
15552 int j;
15553 int k;
15554 int lbytes = (bytes > 16 ? 16 : bytes);
15555
15556 printf (" 0x%8.8lx ", addr);
15557
15558 for (j = 0; j < 16; j++)
15559 {
15560 if (j < lbytes)
15561 printf ("%2.2x", p[j]);
15562 else
15563 printf (" ");
15564
15565 if ((j & 3) == 3)
15566 printf (" ");
15567 }
15568
15569 for (j = 0; j < lbytes; j++)
15570 {
15571 k = p[j];
15572 if (k >= ' ' && k < 0x7f)
15573 printf ("%c", k);
15574 else
15575 printf (".");
15576 }
15577
15578 putchar ('\n');
15579
15580 p += lbytes;
15581 bytes -= lbytes;
15582 addr += lbytes;
15583 }
15584
15585 putchar ('\n');
15586}
15587
15588static unsigned char *
15589display_msp430x_attribute (unsigned char * p,
15590 const unsigned char * const end)
15591{
15592 unsigned int len;
15593 unsigned int val;
15594 unsigned int tag;
15595
15596 tag = read_uleb128 (p, & len, end);
15597 p += len;
15598
15599 switch (tag)
15600 {
15601 case OFBA_MSPABI_Tag_ISA:
15602 val = read_uleb128 (p, &len, end);
15603 p += len;
15604 printf (" Tag_ISA: ");
15605 switch (val)
15606 {
15607 case 0: printf (_("None\n")); break;
15608 case 1: printf (_("MSP430\n")); break;
15609 case 2: printf (_("MSP430X\n")); break;
15610 default: printf ("??? (%d)\n", val); break;
15611 }
15612 break;
15613
15614 case OFBA_MSPABI_Tag_Code_Model:
15615 val = read_uleb128 (p, &len, end);
15616 p += len;
15617 printf (" Tag_Code_Model: ");
15618 switch (val)
15619 {
15620 case 0: printf (_("None\n")); break;
15621 case 1: printf (_("Small\n")); break;
15622 case 2: printf (_("Large\n")); break;
15623 default: printf ("??? (%d)\n", val); break;
15624 }
15625 break;
15626
15627 case OFBA_MSPABI_Tag_Data_Model:
15628 val = read_uleb128 (p, &len, end);
15629 p += len;
15630 printf (" Tag_Data_Model: ");
15631 switch (val)
15632 {
15633 case 0: printf (_("None\n")); break;
15634 case 1: printf (_("Small\n")); break;
15635 case 2: printf (_("Large\n")); break;
15636 case 3: printf (_("Restricted Large\n")); break;
15637 default: printf ("??? (%d)\n", val); break;
15638 }
15639 break;
15640
15641 default:
15642 printf (_(" <unknown tag %d>: "), tag);
15643
15644 if (tag & 1)
15645 {
15646 putchar ('"');
15647 if (p < end - 1)
15648 {
15649 size_t maxlen = (end - p) - 1;
15650
15651 print_symbol ((int) maxlen, (const char *) p);
15652 p += strnlen ((char *) p, maxlen) + 1;
15653 }
15654 else
15655 {
15656 printf (_("<corrupt>"));
15657 p = (unsigned char *) end;
15658 }
15659 printf ("\"\n");
15660 }
15661 else
15662 {
15663 val = read_uleb128 (p, &len, end);
15664 p += len;
15665 printf ("%d (0x%x)\n", val, val);
15666 }
15667 break;
15668 }
15669
15670 assert (p <= end);
15671 return p;
15672}
15673
15674struct riscv_attr_tag_t {
15675 const char *name;
15676 int tag;
15677};
15678
15679static struct riscv_attr_tag_t riscv_attr_tag[] =
15680{
15681#define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
15682 T(arch),
15683 T(priv_spec),
15684 T(priv_spec_minor),
15685 T(priv_spec_revision),
15686 T(unaligned_access),
15687 T(stack_align),
15688#undef T
15689};
15690
15691static unsigned char *
15692display_riscv_attribute (unsigned char *p,
15693 const unsigned char * const end)
15694{
15695 unsigned int len;
15696 int val;
15697 int tag;
15698 struct riscv_attr_tag_t *attr = NULL;
15699 unsigned i;
15700
15701 tag = read_uleb128 (p, &len, end);
15702 p += len;
15703
15704 /* Find the name of attribute. */
15705 for (i = 0; i < ARRAY_SIZE (riscv_attr_tag); i++)
15706 {
15707 if (riscv_attr_tag[i].tag == tag)
15708 {
15709 attr = &riscv_attr_tag[i];
15710 break;
15711 }
15712 }
15713
15714 if (attr)
15715 printf (" %s: ", attr->name);
15716 else
15717 return display_tag_value (tag, p, end);
15718
15719 switch (tag)
15720 {
15721 case Tag_RISCV_priv_spec:
15722 case Tag_RISCV_priv_spec_minor:
15723 case Tag_RISCV_priv_spec_revision:
15724 val = read_uleb128 (p, &len, end);
15725 p += len;
15726 printf (_("%d\n"), val);
15727 break;
15728 case Tag_RISCV_unaligned_access:
15729 val = read_uleb128 (p, &len, end);
15730 p += len;
15731 switch (val)
15732 {
15733 case 0:
15734 printf (_("No unaligned access\n"));
15735 break;
15736 case 1:
15737 printf (_("Unaligned access\n"));
15738 break;
15739 }
15740 break;
15741 case Tag_RISCV_stack_align:
15742 val = read_uleb128 (p, &len, end);
15743 p += len;
15744 printf (_("%d-bytes\n"), val);
15745 break;
15746 case Tag_RISCV_arch:
15747 p = display_tag_value (-1, p, end);
15748 break;
15749 default:
15750 return display_tag_value (tag, p, end);
15751 }
15752
15753 return p;
15754}
15755
15756static bfd_boolean
15757process_attributes (Filedata * filedata,
15758 const char * public_name,
15759 unsigned int proc_type,
15760 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
15761 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
15762{
15763 Elf_Internal_Shdr * sect;
15764 unsigned i;
15765 bfd_boolean res = TRUE;
15766
15767 /* Find the section header so that we get the size. */
15768 for (i = 0, sect = filedata->section_headers;
15769 i < filedata->file_header.e_shnum;
15770 i++, sect++)
15771 {
15772 unsigned char * contents;
15773 unsigned char * p;
15774
15775 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
15776 continue;
15777
15778 contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
15779 sect->sh_size, _("attributes"));
15780 if (contents == NULL)
15781 {
15782 res = FALSE;
15783 continue;
15784 }
15785
15786 p = contents;
15787 /* The first character is the version of the attributes.
15788 Currently only version 1, (aka 'A') is recognised here. */
15789 if (*p != 'A')
15790 {
15791 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
15792 res = FALSE;
15793 }
15794 else
15795 {
15796 bfd_vma section_len;
15797
15798 section_len = sect->sh_size - 1;
15799 p++;
15800
15801 while (section_len > 0)
15802 {
15803 bfd_vma attr_len;
15804 unsigned int namelen;
15805 bfd_boolean public_section;
15806 bfd_boolean gnu_section;
15807
15808 if (section_len <= 4)
15809 {
15810 error (_("Tag section ends prematurely\n"));
15811 res = FALSE;
15812 break;
15813 }
15814 attr_len = byte_get (p, 4);
15815 p += 4;
15816
15817 if (attr_len > section_len)
15818 {
15819 error (_("Bad attribute length (%u > %u)\n"),
15820 (unsigned) attr_len, (unsigned) section_len);
15821 attr_len = section_len;
15822 res = FALSE;
15823 }
15824 /* PR 17531: file: 001-101425-0.004 */
15825 else if (attr_len < 5)
15826 {
15827 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
15828 res = FALSE;
15829 break;
15830 }
15831
15832 section_len -= attr_len;
15833 attr_len -= 4;
15834
15835 namelen = strnlen ((char *) p, attr_len) + 1;
15836 if (namelen == 0 || namelen >= attr_len)
15837 {
15838 error (_("Corrupt attribute section name\n"));
15839 res = FALSE;
15840 break;
15841 }
15842
15843 printf (_("Attribute Section: "));
15844 print_symbol (INT_MAX, (const char *) p);
15845 putchar ('\n');
15846
15847 if (public_name && streq ((char *) p, public_name))
15848 public_section = TRUE;
15849 else
15850 public_section = FALSE;
15851
15852 if (streq ((char *) p, "gnu"))
15853 gnu_section = TRUE;
15854 else
15855 gnu_section = FALSE;
15856
15857 p += namelen;
15858 attr_len -= namelen;
15859
15860 while (attr_len > 0 && p < contents + sect->sh_size)
15861 {
15862 int tag;
15863 int val;
15864 bfd_vma size;
15865 unsigned char * end;
15866
15867 /* PR binutils/17531: Safe handling of corrupt files. */
15868 if (attr_len < 6)
15869 {
15870 error (_("Unused bytes at end of section\n"));
15871 res = FALSE;
15872 section_len = 0;
15873 break;
15874 }
15875
15876 tag = *(p++);
15877 size = byte_get (p, 4);
15878 if (size > attr_len)
15879 {
15880 error (_("Bad subsection length (%u > %u)\n"),
15881 (unsigned) size, (unsigned) attr_len);
15882 res = FALSE;
15883 size = attr_len;
15884 }
15885 /* PR binutils/17531: Safe handling of corrupt files. */
15886 if (size < 6)
15887 {
15888 error (_("Bad subsection length (%u < 6)\n"),
15889 (unsigned) size);
15890 res = FALSE;
15891 section_len = 0;
15892 break;
15893 }
15894
15895 attr_len -= size;
15896 end = p + size - 1;
15897 assert (end <= contents + sect->sh_size);
15898 p += 4;
15899
15900 switch (tag)
15901 {
15902 case 1:
15903 printf (_("File Attributes\n"));
15904 break;
15905 case 2:
15906 printf (_("Section Attributes:"));
15907 goto do_numlist;
15908 case 3:
15909 printf (_("Symbol Attributes:"));
15910 /* Fall through. */
15911 do_numlist:
15912 for (;;)
15913 {
15914 unsigned int j;
15915
15916 val = read_uleb128 (p, &j, end);
15917 p += j;
15918 if (val == 0)
15919 break;
15920 printf (" %d", val);
15921 }
15922 printf ("\n");
15923 break;
15924 default:
15925 printf (_("Unknown tag: %d\n"), tag);
15926 public_section = FALSE;
15927 break;
15928 }
15929
15930 if (public_section && display_pub_attribute != NULL)
15931 {
15932 while (p < end)
15933 p = display_pub_attribute (p, end);
15934 assert (p == end);
15935 }
15936 else if (gnu_section && display_proc_gnu_attribute != NULL)
15937 {
15938 while (p < end)
15939 p = display_gnu_attribute (p,
15940 display_proc_gnu_attribute,
15941 end);
15942 assert (p == end);
15943 }
15944 else if (p < end)
15945 {
15946 printf (_(" Unknown attribute:\n"));
15947 display_raw_attribute (p, end);
15948 p = end;
15949 }
15950 else
15951 attr_len = 0;
15952 }
15953 }
15954 }
15955
15956 free (contents);
15957 }
15958
15959 return res;
15960}
15961
15962/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15963 Print the Address, Access and Initial fields of an entry at VMA ADDR
15964 and return the VMA of the next entry, or -1 if there was a problem.
15965 Does not read from DATA_END or beyond. */
15966
15967static bfd_vma
15968print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
15969 unsigned char * data_end)
15970{
15971 printf (" ");
15972 print_vma (addr, LONG_HEX);
15973 printf (" ");
15974 if (addr < pltgot + 0xfff0)
15975 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
15976 else
15977 printf ("%10s", "");
15978 printf (" ");
15979 if (data == NULL)
15980 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15981 else
15982 {
15983 bfd_vma entry;
15984 unsigned char * from = data + addr - pltgot;
15985
15986 if (from + (is_32bit_elf ? 4 : 8) > data_end)
15987 {
15988 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15989 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
15990 return (bfd_vma) -1;
15991 }
15992 else
15993 {
15994 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15995 print_vma (entry, LONG_HEX);
15996 }
15997 }
15998 return addr + (is_32bit_elf ? 4 : 8);
15999}
16000
16001/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16002 PLTGOT. Print the Address and Initial fields of an entry at VMA
16003 ADDR and return the VMA of the next entry. */
16004
16005static bfd_vma
16006print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
16007{
16008 printf (" ");
16009 print_vma (addr, LONG_HEX);
16010 printf (" ");
16011 if (data == NULL)
16012 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
16013 else
16014 {
16015 bfd_vma entry;
16016
16017 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
16018 print_vma (entry, LONG_HEX);
16019 }
16020 return addr + (is_32bit_elf ? 4 : 8);
16021}
16022
16023static void
16024print_mips_ases (unsigned int mask)
16025{
16026 if (mask & AFL_ASE_DSP)
16027 fputs ("\n\tDSP ASE", stdout);
16028 if (mask & AFL_ASE_DSPR2)
16029 fputs ("\n\tDSP R2 ASE", stdout);
16030 if (mask & AFL_ASE_DSPR3)
16031 fputs ("\n\tDSP R3 ASE", stdout);
16032 if (mask & AFL_ASE_EVA)
16033 fputs ("\n\tEnhanced VA Scheme", stdout);
16034 if (mask & AFL_ASE_MCU)
16035 fputs ("\n\tMCU (MicroController) ASE", stdout);
16036 if (mask & AFL_ASE_MDMX)
16037 fputs ("\n\tMDMX ASE", stdout);
16038 if (mask & AFL_ASE_MIPS3D)
16039 fputs ("\n\tMIPS-3D ASE", stdout);
16040 if (mask & AFL_ASE_MT)
16041 fputs ("\n\tMT ASE", stdout);
16042 if (mask & AFL_ASE_SMARTMIPS)
16043 fputs ("\n\tSmartMIPS ASE", stdout);
16044 if (mask & AFL_ASE_VIRT)
16045 fputs ("\n\tVZ ASE", stdout);
16046 if (mask & AFL_ASE_MSA)
16047 fputs ("\n\tMSA ASE", stdout);
16048 if (mask & AFL_ASE_MIPS16)
16049 fputs ("\n\tMIPS16 ASE", stdout);
16050 if (mask & AFL_ASE_MICROMIPS)
16051 fputs ("\n\tMICROMIPS ASE", stdout);
16052 if (mask & AFL_ASE_XPA)
16053 fputs ("\n\tXPA ASE", stdout);
16054 if (mask & AFL_ASE_MIPS16E2)
16055 fputs ("\n\tMIPS16e2 ASE", stdout);
16056 if (mask & AFL_ASE_CRC)
16057 fputs ("\n\tCRC ASE", stdout);
16058 if (mask & AFL_ASE_GINV)
16059 fputs ("\n\tGINV ASE", stdout);
16060 if (mask & AFL_ASE_LOONGSON_MMI)
16061 fputs ("\n\tLoongson MMI ASE", stdout);
16062 if (mask & AFL_ASE_LOONGSON_CAM)
16063 fputs ("\n\tLoongson CAM ASE", stdout);
16064 if (mask & AFL_ASE_LOONGSON_EXT)
16065 fputs ("\n\tLoongson EXT ASE", stdout);
16066 if (mask & AFL_ASE_LOONGSON_EXT2)
16067 fputs ("\n\tLoongson EXT2 ASE", stdout);
16068 if (mask == 0)
16069 fprintf (stdout, "\n\t%s", _("None"));
16070 else if ((mask & ~AFL_ASE_MASK) != 0)
16071 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
16072}
16073
16074static void
16075print_mips_isa_ext (unsigned int isa_ext)
16076{
16077 switch (isa_ext)
16078 {
16079 case 0:
16080 fputs (_("None"), stdout);
16081 break;
16082 case AFL_EXT_XLR:
16083 fputs ("RMI XLR", stdout);
16084 break;
16085 case AFL_EXT_OCTEON3:
16086 fputs ("Cavium Networks Octeon3", stdout);
16087 break;
16088 case AFL_EXT_OCTEON2:
16089 fputs ("Cavium Networks Octeon2", stdout);
16090 break;
16091 case AFL_EXT_OCTEONP:
16092 fputs ("Cavium Networks OcteonP", stdout);
16093 break;
16094 case AFL_EXT_OCTEON:
16095 fputs ("Cavium Networks Octeon", stdout);
16096 break;
16097 case AFL_EXT_5900:
16098 fputs ("Toshiba R5900", stdout);
16099 break;
16100 case AFL_EXT_4650:
16101 fputs ("MIPS R4650", stdout);
16102 break;
16103 case AFL_EXT_4010:
16104 fputs ("LSI R4010", stdout);
16105 break;
16106 case AFL_EXT_4100:
16107 fputs ("NEC VR4100", stdout);
16108 break;
16109 case AFL_EXT_3900:
16110 fputs ("Toshiba R3900", stdout);
16111 break;
16112 case AFL_EXT_10000:
16113 fputs ("MIPS R10000", stdout);
16114 break;
16115 case AFL_EXT_SB1:
16116 fputs ("Broadcom SB-1", stdout);
16117 break;
16118 case AFL_EXT_4111:
16119 fputs ("NEC VR4111/VR4181", stdout);
16120 break;
16121 case AFL_EXT_4120:
16122 fputs ("NEC VR4120", stdout);
16123 break;
16124 case AFL_EXT_5400:
16125 fputs ("NEC VR5400", stdout);
16126 break;
16127 case AFL_EXT_5500:
16128 fputs ("NEC VR5500", stdout);
16129 break;
16130 case AFL_EXT_LOONGSON_2E:
16131 fputs ("ST Microelectronics Loongson 2E", stdout);
16132 break;
16133 case AFL_EXT_LOONGSON_2F:
16134 fputs ("ST Microelectronics Loongson 2F", stdout);
16135 break;
16136 case AFL_EXT_INTERAPTIV_MR2:
16137 fputs ("Imagination interAptiv MR2", stdout);
16138 break;
16139 default:
16140 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
16141 }
16142}
16143
16144static signed int
16145get_mips_reg_size (int reg_size)
16146{
16147 return (reg_size == AFL_REG_NONE) ? 0
16148 : (reg_size == AFL_REG_32) ? 32
16149 : (reg_size == AFL_REG_64) ? 64
16150 : (reg_size == AFL_REG_128) ? 128
16151 : -1;
16152}
16153
16154static bfd_boolean
16155process_mips_specific (Filedata * filedata)
16156{
16157 Elf_Internal_Dyn * entry;
16158 Elf_Internal_Shdr *sect = NULL;
16159 size_t liblist_offset = 0;
16160 size_t liblistno = 0;
16161 size_t conflictsno = 0;
16162 size_t options_offset = 0;
16163 size_t conflicts_offset = 0;
16164 size_t pltrelsz = 0;
16165 size_t pltrel = 0;
16166 bfd_vma pltgot = 0;
16167 bfd_vma mips_pltgot = 0;
16168 bfd_vma jmprel = 0;
16169 bfd_vma local_gotno = 0;
16170 bfd_vma gotsym = 0;
16171 bfd_vma symtabno = 0;
16172 bfd_boolean res = TRUE;
16173
16174 if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
16175 display_mips_gnu_attribute))
16176 res = FALSE;
16177
16178 sect = find_section (filedata, ".MIPS.abiflags");
16179
16180 if (sect != NULL)
16181 {
16182 Elf_External_ABIFlags_v0 *abiflags_ext;
16183 Elf_Internal_ABIFlags_v0 abiflags_in;
16184
16185 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
16186 {
16187 error (_("Corrupt MIPS ABI Flags section.\n"));
16188 res = FALSE;
16189 }
16190 else
16191 {
16192 abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
16193 sect->sh_size, _("MIPS ABI Flags section"));
16194 if (abiflags_ext)
16195 {
16196 abiflags_in.version = BYTE_GET (abiflags_ext->version);
16197 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
16198 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
16199 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
16200 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
16201 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
16202 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
16203 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
16204 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
16205 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
16206 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
16207
16208 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
16209 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
16210 if (abiflags_in.isa_rev > 1)
16211 printf ("r%d", abiflags_in.isa_rev);
16212 printf ("\nGPR size: %d",
16213 get_mips_reg_size (abiflags_in.gpr_size));
16214 printf ("\nCPR1 size: %d",
16215 get_mips_reg_size (abiflags_in.cpr1_size));
16216 printf ("\nCPR2 size: %d",
16217 get_mips_reg_size (abiflags_in.cpr2_size));
16218 fputs ("\nFP ABI: ", stdout);
16219 print_mips_fp_abi_value (abiflags_in.fp_abi);
16220 fputs ("ISA Extension: ", stdout);
16221 print_mips_isa_ext (abiflags_in.isa_ext);
16222 fputs ("\nASEs:", stdout);
16223 print_mips_ases (abiflags_in.ases);
16224 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
16225 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
16226 fputc ('\n', stdout);
16227 free (abiflags_ext);
16228 }
16229 }
16230 }
16231
16232 /* We have a lot of special sections. Thanks SGI! */
16233 if (dynamic_section == NULL)
16234 {
16235 /* No dynamic information available. See if there is static GOT. */
16236 sect = find_section (filedata, ".got");
16237 if (sect != NULL)
16238 {
16239 unsigned char *data_end;
16240 unsigned char *data;
16241 bfd_vma ent, end;
16242 int addr_size;
16243
16244 pltgot = sect->sh_addr;
16245
16246 ent = pltgot;
16247 addr_size = (is_32bit_elf ? 4 : 8);
16248 end = pltgot + sect->sh_size;
16249
16250 data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
16251 end - pltgot, 1,
16252 _("Global Offset Table data"));
16253 /* PR 12855: Null data is handled gracefully throughout. */
16254 data_end = data + (end - pltgot);
16255
16256 printf (_("\nStatic GOT:\n"));
16257 printf (_(" Canonical gp value: "));
16258 print_vma (ent + 0x7ff0, LONG_HEX);
16259 printf ("\n\n");
16260
16261 /* In a dynamic binary GOT[0] is reserved for the dynamic
16262 loader to store the lazy resolver pointer, however in
16263 a static binary it may well have been omitted and GOT
16264 reduced to a table of addresses.
16265 PR 21344: Check for the entry being fully available
16266 before fetching it. */
16267 if (data
16268 && data + ent - pltgot + addr_size <= data_end
16269 && byte_get (data + ent - pltgot, addr_size) == 0)
16270 {
16271 printf (_(" Reserved entries:\n"));
16272 printf (_(" %*s %10s %*s\n"),
16273 addr_size * 2, _("Address"), _("Access"),
16274 addr_size * 2, _("Value"));
16275 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16276 printf ("\n");
16277 if (ent == (bfd_vma) -1)
16278 goto sgot_print_fail;
16279
16280 /* Check for the MSB of GOT[1] being set, identifying a
16281 GNU object. This entry will be used by some runtime
16282 loaders, to store the module pointer. Otherwise this
16283 is an ordinary local entry.
16284 PR 21344: Check for the entry being fully available
16285 before fetching it. */
16286 if (data
16287 && data + ent - pltgot + addr_size <= data_end
16288 && (byte_get (data + ent - pltgot, addr_size)
16289 >> (addr_size * 8 - 1)) != 0)
16290 {
16291 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16292 printf ("\n");
16293 if (ent == (bfd_vma) -1)
16294 goto sgot_print_fail;
16295 }
16296 printf ("\n");
16297 }
16298
16299 if (data != NULL && ent < end)
16300 {
16301 printf (_(" Local entries:\n"));
16302 printf (" %*s %10s %*s\n",
16303 addr_size * 2, _("Address"), _("Access"),
16304 addr_size * 2, _("Value"));
16305 while (ent < end)
16306 {
16307 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16308 printf ("\n");
16309 if (ent == (bfd_vma) -1)
16310 goto sgot_print_fail;
16311 }
16312 printf ("\n");
16313 }
16314
16315 sgot_print_fail:
16316 if (data)
16317 free (data);
16318 }
16319 return res;
16320 }
16321
16322 for (entry = dynamic_section;
16323 /* PR 17531 file: 012-50589-0.004. */
16324 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
16325 ++entry)
16326 switch (entry->d_tag)
16327 {
16328 case DT_MIPS_LIBLIST:
16329 liblist_offset
16330 = offset_from_vma (filedata, entry->d_un.d_val,
16331 liblistno * sizeof (Elf32_External_Lib));
16332 break;
16333 case DT_MIPS_LIBLISTNO:
16334 liblistno = entry->d_un.d_val;
16335 break;
16336 case DT_MIPS_OPTIONS:
16337 options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
16338 break;
16339 case DT_MIPS_CONFLICT:
16340 conflicts_offset
16341 = offset_from_vma (filedata, entry->d_un.d_val,
16342 conflictsno * sizeof (Elf32_External_Conflict));
16343 break;
16344 case DT_MIPS_CONFLICTNO:
16345 conflictsno = entry->d_un.d_val;
16346 break;
16347 case DT_PLTGOT:
16348 pltgot = entry->d_un.d_ptr;
16349 break;
16350 case DT_MIPS_LOCAL_GOTNO:
16351 local_gotno = entry->d_un.d_val;
16352 break;
16353 case DT_MIPS_GOTSYM:
16354 gotsym = entry->d_un.d_val;
16355 break;
16356 case DT_MIPS_SYMTABNO:
16357 symtabno = entry->d_un.d_val;
16358 break;
16359 case DT_MIPS_PLTGOT:
16360 mips_pltgot = entry->d_un.d_ptr;
16361 break;
16362 case DT_PLTREL:
16363 pltrel = entry->d_un.d_val;
16364 break;
16365 case DT_PLTRELSZ:
16366 pltrelsz = entry->d_un.d_val;
16367 break;
16368 case DT_JMPREL:
16369 jmprel = entry->d_un.d_ptr;
16370 break;
16371 default:
16372 break;
16373 }
16374
16375 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
16376 {
16377 Elf32_External_Lib * elib;
16378 size_t cnt;
16379
16380 elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
16381 liblistno,
16382 sizeof (Elf32_External_Lib),
16383 _("liblist section data"));
16384 if (elib)
16385 {
16386 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16387 "\nSection '.liblist' contains %lu entries:\n",
16388 (unsigned long) liblistno),
16389 (unsigned long) liblistno);
16390 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16391 stdout);
16392
16393 for (cnt = 0; cnt < liblistno; ++cnt)
16394 {
16395 Elf32_Lib liblist;
16396 time_t atime;
16397 char timebuf[128];
16398 struct tm * tmp;
16399
16400 liblist.l_name = BYTE_GET (elib[cnt].l_name);
16401 atime = BYTE_GET (elib[cnt].l_time_stamp);
16402 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16403 liblist.l_version = BYTE_GET (elib[cnt].l_version);
16404 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16405
16406 tmp = gmtime (&atime);
16407 snprintf (timebuf, sizeof (timebuf),
16408 "%04u-%02u-%02uT%02u:%02u:%02u",
16409 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16410 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16411
16412 printf ("%3lu: ", (unsigned long) cnt);
16413 if (VALID_DYNAMIC_NAME (liblist.l_name))
16414 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
16415 else
16416 printf (_("<corrupt: %9ld>"), liblist.l_name);
16417 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
16418 liblist.l_version);
16419
16420 if (liblist.l_flags == 0)
16421 puts (_(" NONE"));
16422 else
16423 {
16424 static const struct
16425 {
16426 const char * name;
16427 int bit;
16428 }
16429 l_flags_vals[] =
16430 {
16431 { " EXACT_MATCH", LL_EXACT_MATCH },
16432 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
16433 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
16434 { " EXPORTS", LL_EXPORTS },
16435 { " DELAY_LOAD", LL_DELAY_LOAD },
16436 { " DELTA", LL_DELTA }
16437 };
16438 int flags = liblist.l_flags;
16439 size_t fcnt;
16440
16441 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
16442 if ((flags & l_flags_vals[fcnt].bit) != 0)
16443 {
16444 fputs (l_flags_vals[fcnt].name, stdout);
16445 flags ^= l_flags_vals[fcnt].bit;
16446 }
16447 if (flags != 0)
16448 printf (" %#x", (unsigned int) flags);
16449
16450 puts ("");
16451 }
16452 }
16453
16454 free (elib);
16455 }
16456 else
16457 res = FALSE;
16458 }
16459
16460 if (options_offset != 0)
16461 {
16462 Elf_External_Options * eopt;
16463 Elf_Internal_Options * iopt;
16464 Elf_Internal_Options * option;
16465 size_t offset;
16466 int cnt;
16467 sect = filedata->section_headers;
16468
16469 /* Find the section header so that we get the size. */
16470 sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
16471 /* PR 17533 file: 012-277276-0.004. */
16472 if (sect == NULL)
16473 {
16474 error (_("No MIPS_OPTIONS header found\n"));
16475 return FALSE;
16476 }
16477 /* PR 24243 */
16478 if (sect->sh_size < sizeof (* eopt))
16479 {
16480 error (_("The MIPS options section is too small.\n"));
16481 return FALSE;
16482 }
16483
16484 eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
16485 sect->sh_size, _("options"));
16486 if (eopt)
16487 {
16488 iopt = (Elf_Internal_Options *)
16489 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
16490 if (iopt == NULL)
16491 {
16492 error (_("Out of memory allocating space for MIPS options\n"));
16493 return FALSE;
16494 }
16495
16496 offset = cnt = 0;
16497 option = iopt;
16498
16499 while (offset <= sect->sh_size - sizeof (* eopt))
16500 {
16501 Elf_External_Options * eoption;
16502
16503 eoption = (Elf_External_Options *) ((char *) eopt + offset);
16504
16505 option->kind = BYTE_GET (eoption->kind);
16506 option->size = BYTE_GET (eoption->size);
16507 option->section = BYTE_GET (eoption->section);
16508 option->info = BYTE_GET (eoption->info);
16509
16510 /* PR 17531: file: ffa0fa3b. */
16511 if (option->size < sizeof (* eopt)
16512 || offset + option->size > sect->sh_size)
16513 {
16514 error (_("Invalid size (%u) for MIPS option\n"), option->size);
16515 return FALSE;
16516 }
16517 offset += option->size;
16518
16519 ++option;
16520 ++cnt;
16521 }
16522
16523 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16524 "\nSection '%s' contains %d entries:\n",
16525 cnt),
16526 printable_section_name (filedata, sect), cnt);
16527
16528 option = iopt;
16529 offset = 0;
16530
16531 while (cnt-- > 0)
16532 {
16533 size_t len;
16534
16535 switch (option->kind)
16536 {
16537 case ODK_NULL:
16538 /* This shouldn't happen. */
16539 printf (" NULL %d %lx", option->section, option->info);
16540 break;
16541 case ODK_REGINFO:
16542 printf (" REGINFO ");
16543 if (filedata->file_header.e_machine == EM_MIPS)
16544 {
16545 /* 32bit form. */
16546 Elf32_External_RegInfo * ereg;
16547 Elf32_RegInfo reginfo;
16548
16549 ereg = (Elf32_External_RegInfo *) (option + 1);
16550 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
16551 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16552 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16553 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16554 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16555 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
16556
16557 printf ("GPR %08lx GP 0x%lx\n",
16558 reginfo.ri_gprmask,
16559 (unsigned long) reginfo.ri_gp_value);
16560 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16561 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16562 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16563 }
16564 else
16565 {
16566 /* 64 bit form. */
16567 Elf64_External_RegInfo * ereg;
16568 Elf64_Internal_RegInfo reginfo;
16569
16570 ereg = (Elf64_External_RegInfo *) (option + 1);
16571 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
16572 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16573 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16574 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16575 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16576 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
16577
16578 printf ("GPR %08lx GP 0x",
16579 reginfo.ri_gprmask);
16580 printf_vma (reginfo.ri_gp_value);
16581 printf ("\n");
16582
16583 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16584 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16585 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16586 }
16587 ++option;
16588 continue;
16589 case ODK_EXCEPTIONS:
16590 fputs (" EXCEPTIONS fpe_min(", stdout);
16591 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
16592 fputs (") fpe_max(", stdout);
16593 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
16594 fputs (")", stdout);
16595
16596 if (option->info & OEX_PAGE0)
16597 fputs (" PAGE0", stdout);
16598 if (option->info & OEX_SMM)
16599 fputs (" SMM", stdout);
16600 if (option->info & OEX_FPDBUG)
16601 fputs (" FPDBUG", stdout);
16602 if (option->info & OEX_DISMISS)
16603 fputs (" DISMISS", stdout);
16604 break;
16605 case ODK_PAD:
16606 fputs (" PAD ", stdout);
16607 if (option->info & OPAD_PREFIX)
16608 fputs (" PREFIX", stdout);
16609 if (option->info & OPAD_POSTFIX)
16610 fputs (" POSTFIX", stdout);
16611 if (option->info & OPAD_SYMBOL)
16612 fputs (" SYMBOL", stdout);
16613 break;
16614 case ODK_HWPATCH:
16615 fputs (" HWPATCH ", stdout);
16616 if (option->info & OHW_R4KEOP)
16617 fputs (" R4KEOP", stdout);
16618 if (option->info & OHW_R8KPFETCH)
16619 fputs (" R8KPFETCH", stdout);
16620 if (option->info & OHW_R5KEOP)
16621 fputs (" R5KEOP", stdout);
16622 if (option->info & OHW_R5KCVTL)
16623 fputs (" R5KCVTL", stdout);
16624 break;
16625 case ODK_FILL:
16626 fputs (" FILL ", stdout);
16627 /* XXX Print content of info word? */
16628 break;
16629 case ODK_TAGS:
16630 fputs (" TAGS ", stdout);
16631 /* XXX Print content of info word? */
16632 break;
16633 case ODK_HWAND:
16634 fputs (" HWAND ", stdout);
16635 if (option->info & OHWA0_R4KEOP_CHECKED)
16636 fputs (" R4KEOP_CHECKED", stdout);
16637 if (option->info & OHWA0_R4KEOP_CLEAN)
16638 fputs (" R4KEOP_CLEAN", stdout);
16639 break;
16640 case ODK_HWOR:
16641 fputs (" HWOR ", stdout);
16642 if (option->info & OHWA0_R4KEOP_CHECKED)
16643 fputs (" R4KEOP_CHECKED", stdout);
16644 if (option->info & OHWA0_R4KEOP_CLEAN)
16645 fputs (" R4KEOP_CLEAN", stdout);
16646 break;
16647 case ODK_GP_GROUP:
16648 printf (" GP_GROUP %#06lx self-contained %#06lx",
16649 option->info & OGP_GROUP,
16650 (option->info & OGP_SELF) >> 16);
16651 break;
16652 case ODK_IDENT:
16653 printf (" IDENT %#06lx self-contained %#06lx",
16654 option->info & OGP_GROUP,
16655 (option->info & OGP_SELF) >> 16);
16656 break;
16657 default:
16658 /* This shouldn't happen. */
16659 printf (" %3d ??? %d %lx",
16660 option->kind, option->section, option->info);
16661 break;
16662 }
16663
16664 len = sizeof (* eopt);
16665 while (len < option->size)
16666 {
16667 unsigned char datum = * ((unsigned char *) eopt + offset + len);
16668
16669 if (ISPRINT (datum))
16670 printf ("%c", datum);
16671 else
16672 printf ("\\%03o", datum);
16673 len ++;
16674 }
16675 fputs ("\n", stdout);
16676
16677 offset += option->size;
16678 ++option;
16679 }
16680
16681 free (eopt);
16682 }
16683 else
16684 res = FALSE;
16685 }
16686
16687 if (conflicts_offset != 0 && conflictsno != 0)
16688 {
16689 Elf32_Conflict * iconf;
16690 size_t cnt;
16691
16692 if (dynamic_symbols == NULL)
16693 {
16694 error (_("conflict list found without a dynamic symbol table\n"));
16695 return FALSE;
16696 }
16697
16698 /* PR 21345 - print a slightly more helpful error message
16699 if we are sure that the cmalloc will fail. */
16700 if (conflictsno * sizeof (* iconf) > filedata->file_size)
16701 {
16702 error (_("Overlarge number of conflicts detected: %lx\n"),
16703 (long) conflictsno);
16704 return FALSE;
16705 }
16706
16707 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
16708 if (iconf == NULL)
16709 {
16710 error (_("Out of memory allocating space for dynamic conflicts\n"));
16711 return FALSE;
16712 }
16713
16714 if (is_32bit_elf)
16715 {
16716 Elf32_External_Conflict * econf32;
16717
16718 econf32 = (Elf32_External_Conflict *)
16719 get_data (NULL, filedata, conflicts_offset, conflictsno,
16720 sizeof (* econf32), _("conflict"));
16721 if (!econf32)
16722 return FALSE;
16723
16724 for (cnt = 0; cnt < conflictsno; ++cnt)
16725 iconf[cnt] = BYTE_GET (econf32[cnt]);
16726
16727 free (econf32);
16728 }
16729 else
16730 {
16731 Elf64_External_Conflict * econf64;
16732
16733 econf64 = (Elf64_External_Conflict *)
16734 get_data (NULL, filedata, conflicts_offset, conflictsno,
16735 sizeof (* econf64), _("conflict"));
16736 if (!econf64)
16737 return FALSE;
16738
16739 for (cnt = 0; cnt < conflictsno; ++cnt)
16740 iconf[cnt] = BYTE_GET (econf64[cnt]);
16741
16742 free (econf64);
16743 }
16744
16745 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16746 "\nSection '.conflict' contains %lu entries:\n",
16747 (unsigned long) conflictsno),
16748 (unsigned long) conflictsno);
16749 puts (_(" Num: Index Value Name"));
16750
16751 for (cnt = 0; cnt < conflictsno; ++cnt)
16752 {
16753 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
16754
16755 if (iconf[cnt] >= num_dynamic_syms)
16756 printf (_("<corrupt symbol index>"));
16757 else
16758 {
16759 Elf_Internal_Sym * psym;
16760
16761 psym = & dynamic_symbols[iconf[cnt]];
16762 print_vma (psym->st_value, FULL_HEX);
16763 putchar (' ');
16764 if (VALID_DYNAMIC_NAME (psym->st_name))
16765 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
16766 else
16767 printf (_("<corrupt: %14ld>"), psym->st_name);
16768 }
16769 putchar ('\n');
16770 }
16771
16772 free (iconf);
16773 }
16774
16775 if (pltgot != 0 && local_gotno != 0)
16776 {
16777 bfd_vma ent, local_end, global_end;
16778 size_t i, offset;
16779 unsigned char * data;
16780 unsigned char * data_end;
16781 int addr_size;
16782
16783 ent = pltgot;
16784 addr_size = (is_32bit_elf ? 4 : 8);
16785 local_end = pltgot + local_gotno * addr_size;
16786
16787 /* PR binutils/17533 file: 012-111227-0.004 */
16788 if (symtabno < gotsym)
16789 {
16790 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16791 (unsigned long) gotsym, (unsigned long) symtabno);
16792 return FALSE;
16793 }
16794
16795 global_end = local_end + (symtabno - gotsym) * addr_size;
16796 /* PR 17531: file: 54c91a34. */
16797 if (global_end < local_end)
16798 {
16799 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
16800 return FALSE;
16801 }
16802
16803 offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
16804 data = (unsigned char *) get_data (NULL, filedata, offset,
16805 global_end - pltgot, 1,
16806 _("Global Offset Table data"));
16807 /* PR 12855: Null data is handled gracefully throughout. */
16808 data_end = data + (global_end - pltgot);
16809
16810 printf (_("\nPrimary GOT:\n"));
16811 printf (_(" Canonical gp value: "));
16812 print_vma (pltgot + 0x7ff0, LONG_HEX);
16813 printf ("\n\n");
16814
16815 printf (_(" Reserved entries:\n"));
16816 printf (_(" %*s %10s %*s Purpose\n"),
16817 addr_size * 2, _("Address"), _("Access"),
16818 addr_size * 2, _("Initial"));
16819 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16820 printf (_(" Lazy resolver\n"));
16821 if (ent == (bfd_vma) -1)
16822 goto got_print_fail;
16823
16824 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16825 This entry will be used by some runtime loaders, to store the
16826 module pointer. Otherwise this is an ordinary local entry.
16827 PR 21344: Check for the entry being fully available before
16828 fetching it. */
16829 if (data
16830 && data + ent - pltgot + addr_size <= data_end
16831 && (byte_get (data + ent - pltgot, addr_size)
16832 >> (addr_size * 8 - 1)) != 0)
16833 {
16834 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16835 printf (_(" Module pointer (GNU extension)\n"));
16836 if (ent == (bfd_vma) -1)
16837 goto got_print_fail;
16838 }
16839 printf ("\n");
16840
16841 if (data != NULL && ent < local_end)
16842 {
16843 printf (_(" Local entries:\n"));
16844 printf (" %*s %10s %*s\n",
16845 addr_size * 2, _("Address"), _("Access"),
16846 addr_size * 2, _("Initial"));
16847 while (ent < local_end)
16848 {
16849 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16850 printf ("\n");
16851 if (ent == (bfd_vma) -1)
16852 goto got_print_fail;
16853 }
16854 printf ("\n");
16855 }
16856
16857 if (data != NULL && gotsym < symtabno)
16858 {
16859 int sym_width;
16860
16861 printf (_(" Global entries:\n"));
16862 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
16863 addr_size * 2, _("Address"),
16864 _("Access"),
16865 addr_size * 2, _("Initial"),
16866 addr_size * 2, _("Sym.Val."),
16867 _("Type"),
16868 /* Note for translators: "Ndx" = abbreviated form of "Index". */
16869 _("Ndx"), _("Name"));
16870
16871 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
16872
16873 for (i = gotsym; i < symtabno; i++)
16874 {
16875 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16876 printf (" ");
16877
16878 if (dynamic_symbols == NULL)
16879 printf (_("<no dynamic symbols>"));
16880 else if (i < num_dynamic_syms)
16881 {
16882 Elf_Internal_Sym * psym = dynamic_symbols + i;
16883
16884 print_vma (psym->st_value, LONG_HEX);
16885 printf (" %-7s %3s ",
16886 get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16887 get_symbol_index_type (filedata, psym->st_shndx));
16888
16889 if (VALID_DYNAMIC_NAME (psym->st_name))
16890 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16891 else
16892 printf (_("<corrupt: %14ld>"), psym->st_name);
16893 }
16894 else
16895 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16896 (unsigned long) i);
16897
16898 printf ("\n");
16899 if (ent == (bfd_vma) -1)
16900 break;
16901 }
16902 printf ("\n");
16903 }
16904
16905 got_print_fail:
16906 if (data)
16907 free (data);
16908 }
16909
16910 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
16911 {
16912 bfd_vma ent, end;
16913 size_t offset, rel_offset;
16914 unsigned long count, i;
16915 unsigned char * data;
16916 int addr_size, sym_width;
16917 Elf_Internal_Rela * rels;
16918
16919 rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
16920 if (pltrel == DT_RELA)
16921 {
16922 if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16923 return FALSE;
16924 }
16925 else
16926 {
16927 if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16928 return FALSE;
16929 }
16930
16931 ent = mips_pltgot;
16932 addr_size = (is_32bit_elf ? 4 : 8);
16933 end = mips_pltgot + (2 + count) * addr_size;
16934
16935 offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
16936 data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
16937 1, _("Procedure Linkage Table data"));
16938 if (data == NULL)
16939 return FALSE;
16940
16941 printf ("\nPLT GOT:\n\n");
16942 printf (_(" Reserved entries:\n"));
16943 printf (_(" %*s %*s Purpose\n"),
16944 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
16945 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16946 printf (_(" PLT lazy resolver\n"));
16947 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16948 printf (_(" Module pointer\n"));
16949 printf ("\n");
16950
16951 printf (_(" Entries:\n"));
16952 printf (" %*s %*s %*s %-7s %3s %s\n",
16953 addr_size * 2, _("Address"),
16954 addr_size * 2, _("Initial"),
16955 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16956 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
16957 for (i = 0; i < count; i++)
16958 {
16959 unsigned long idx = get_reloc_symindex (rels[i].r_info);
16960
16961 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16962 printf (" ");
16963
16964 if (idx >= num_dynamic_syms)
16965 printf (_("<corrupt symbol index: %lu>"), idx);
16966 else
16967 {
16968 Elf_Internal_Sym * psym = dynamic_symbols + idx;
16969
16970 print_vma (psym->st_value, LONG_HEX);
16971 printf (" %-7s %3s ",
16972 get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16973 get_symbol_index_type (filedata, psym->st_shndx));
16974 if (VALID_DYNAMIC_NAME (psym->st_name))
16975 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16976 else
16977 printf (_("<corrupt: %14ld>"), psym->st_name);
16978 }
16979 printf ("\n");
16980 }
16981 printf ("\n");
16982
16983 if (data)
16984 free (data);
16985 free (rels);
16986 }
16987
16988 return res;
16989}
16990
16991static bfd_boolean
16992process_nds32_specific (Filedata * filedata)
16993{
16994 Elf_Internal_Shdr *sect = NULL;
16995
16996 sect = find_section (filedata, ".nds32_e_flags");
16997 if (sect != NULL)
16998 {
16999 unsigned int *flag;
17000
17001 printf ("\nNDS32 elf flags section:\n");
17002 flag = get_data (NULL, filedata, sect->sh_offset, 1,
17003 sect->sh_size, _("NDS32 elf flags section"));
17004
17005 if (! flag)
17006 return FALSE;
17007
17008 switch ((*flag) & 0x3)
17009 {
17010 case 0:
17011 printf ("(VEC_SIZE):\tNo entry.\n");
17012 break;
17013 case 1:
17014 printf ("(VEC_SIZE):\t4 bytes\n");
17015 break;
17016 case 2:
17017 printf ("(VEC_SIZE):\t16 bytes\n");
17018 break;
17019 case 3:
17020 printf ("(VEC_SIZE):\treserved\n");
17021 break;
17022 }
17023 }
17024
17025 return TRUE;
17026}
17027
17028static bfd_boolean
17029process_gnu_liblist (Filedata * filedata)
17030{
17031 Elf_Internal_Shdr * section;
17032 Elf_Internal_Shdr * string_sec;
17033 Elf32_External_Lib * elib;
17034 char * strtab;
17035 size_t strtab_size;
17036 size_t cnt;
17037 unsigned long num_liblist;
17038 unsigned i;
17039 bfd_boolean res = TRUE;
17040
17041 if (! do_arch)
17042 return TRUE;
17043
17044 for (i = 0, section = filedata->section_headers;
17045 i < filedata->file_header.e_shnum;
17046 i++, section++)
17047 {
17048 switch (section->sh_type)
17049 {
17050 case SHT_GNU_LIBLIST:
17051 if (section->sh_link >= filedata->file_header.e_shnum)
17052 break;
17053
17054 elib = (Elf32_External_Lib *)
17055 get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
17056 _("liblist section data"));
17057
17058 if (elib == NULL)
17059 {
17060 res = FALSE;
17061 break;
17062 }
17063
17064 string_sec = filedata->section_headers + section->sh_link;
17065 strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
17066 string_sec->sh_size,
17067 _("liblist string table"));
17068 if (strtab == NULL
17069 || section->sh_entsize != sizeof (Elf32_External_Lib))
17070 {
17071 free (elib);
17072 free (strtab);
17073 res = FALSE;
17074 break;
17075 }
17076 strtab_size = string_sec->sh_size;
17077
17078 num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
17079 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17080 "\nLibrary list section '%s' contains %lu entries:\n",
17081 num_liblist),
17082 printable_section_name (filedata, section),
17083 num_liblist);
17084
17085 puts (_(" Library Time Stamp Checksum Version Flags"));
17086
17087 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
17088 ++cnt)
17089 {
17090 Elf32_Lib liblist;
17091 time_t atime;
17092 char timebuf[128];
17093 struct tm * tmp;
17094
17095 liblist.l_name = BYTE_GET (elib[cnt].l_name);
17096 atime = BYTE_GET (elib[cnt].l_time_stamp);
17097 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
17098 liblist.l_version = BYTE_GET (elib[cnt].l_version);
17099 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
17100
17101 tmp = gmtime (&atime);
17102 snprintf (timebuf, sizeof (timebuf),
17103 "%04u-%02u-%02uT%02u:%02u:%02u",
17104 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
17105 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
17106
17107 printf ("%3lu: ", (unsigned long) cnt);
17108 if (do_wide)
17109 printf ("%-20s", liblist.l_name < strtab_size
17110 ? strtab + liblist.l_name : _("<corrupt>"));
17111 else
17112 printf ("%-20.20s", liblist.l_name < strtab_size
17113 ? strtab + liblist.l_name : _("<corrupt>"));
17114 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
17115 liblist.l_version, liblist.l_flags);
17116 }
17117
17118 free (elib);
17119 free (strtab);
17120 }
17121 }
17122
17123 return res;
17124}
17125
17126static const char *
17127get_note_type (Filedata * filedata, unsigned e_type)
17128{
17129 static char buff[64];
17130
17131 if (filedata->file_header.e_type == ET_CORE)
17132 switch (e_type)
17133 {
17134 case NT_AUXV:
17135 return _("NT_AUXV (auxiliary vector)");
17136 case NT_PRSTATUS:
17137 return _("NT_PRSTATUS (prstatus structure)");
17138 case NT_FPREGSET:
17139 return _("NT_FPREGSET (floating point registers)");
17140 case NT_PRPSINFO:
17141 return _("NT_PRPSINFO (prpsinfo structure)");
17142 case NT_TASKSTRUCT:
17143 return _("NT_TASKSTRUCT (task structure)");
17144 case NT_PRXFPREG:
17145 return _("NT_PRXFPREG (user_xfpregs structure)");
17146 case NT_PPC_VMX:
17147 return _("NT_PPC_VMX (ppc Altivec registers)");
17148 case NT_PPC_VSX:
17149 return _("NT_PPC_VSX (ppc VSX registers)");
17150 case NT_PPC_TAR:
17151 return _("NT_PPC_TAR (ppc TAR register)");
17152 case NT_PPC_PPR:
17153 return _("NT_PPC_PPR (ppc PPR register)");
17154 case NT_PPC_DSCR:
17155 return _("NT_PPC_DSCR (ppc DSCR register)");
17156 case NT_PPC_EBB:
17157 return _("NT_PPC_EBB (ppc EBB registers)");
17158 case NT_PPC_PMU:
17159 return _("NT_PPC_PMU (ppc PMU registers)");
17160 case NT_PPC_TM_CGPR:
17161 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17162 case NT_PPC_TM_CFPR:
17163 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17164 case NT_PPC_TM_CVMX:
17165 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17166 case NT_PPC_TM_CVSX:
17167 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17168 case NT_PPC_TM_SPR:
17169 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17170 case NT_PPC_TM_CTAR:
17171 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17172 case NT_PPC_TM_CPPR:
17173 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17174 case NT_PPC_TM_CDSCR:
17175 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17176 case NT_386_TLS:
17177 return _("NT_386_TLS (x86 TLS information)");
17178 case NT_386_IOPERM:
17179 return _("NT_386_IOPERM (x86 I/O permissions)");
17180 case NT_X86_XSTATE:
17181 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17182 case NT_S390_HIGH_GPRS:
17183 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17184 case NT_S390_TIMER:
17185 return _("NT_S390_TIMER (s390 timer register)");
17186 case NT_S390_TODCMP:
17187 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17188 case NT_S390_TODPREG:
17189 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17190 case NT_S390_CTRS:
17191 return _("NT_S390_CTRS (s390 control registers)");
17192 case NT_S390_PREFIX:
17193 return _("NT_S390_PREFIX (s390 prefix register)");
17194 case NT_S390_LAST_BREAK:
17195 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17196 case NT_S390_SYSTEM_CALL:
17197 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17198 case NT_S390_TDB:
17199 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17200 case NT_S390_VXRS_LOW:
17201 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17202 case NT_S390_VXRS_HIGH:
17203 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17204 case NT_S390_GS_CB:
17205 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17206 case NT_S390_GS_BC:
17207 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17208 case NT_ARM_VFP:
17209 return _("NT_ARM_VFP (arm VFP registers)");
17210 case NT_ARM_TLS:
17211 return _("NT_ARM_TLS (AArch TLS registers)");
17212 case NT_ARM_HW_BREAK:
17213 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17214 case NT_ARM_HW_WATCH:
17215 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17216 case NT_PSTATUS:
17217 return _("NT_PSTATUS (pstatus structure)");
17218 case NT_FPREGS:
17219 return _("NT_FPREGS (floating point registers)");
17220 case NT_PSINFO:
17221 return _("NT_PSINFO (psinfo structure)");
17222 case NT_LWPSTATUS:
17223 return _("NT_LWPSTATUS (lwpstatus_t structure)");
17224 case NT_LWPSINFO:
17225 return _("NT_LWPSINFO (lwpsinfo_t structure)");
17226 case NT_WIN32PSTATUS:
17227 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17228 case NT_SIGINFO:
17229 return _("NT_SIGINFO (siginfo_t data)");
17230 case NT_FILE:
17231 return _("NT_FILE (mapped files)");
17232 default:
17233 break;
17234 }
17235 else
17236 switch (e_type)
17237 {
17238 case NT_VERSION:
17239 return _("NT_VERSION (version)");
17240 case NT_ARCH:
17241 return _("NT_ARCH (architecture)");
17242 case NT_GNU_BUILD_ATTRIBUTE_OPEN:
17243 return _("OPEN");
17244 case NT_GNU_BUILD_ATTRIBUTE_FUNC:
17245 return _("func");
17246 default:
17247 break;
17248 }
17249
17250 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17251 return buff;
17252}
17253
17254static bfd_boolean
17255print_core_note (Elf_Internal_Note *pnote)
17256{
17257 unsigned int addr_size = is_32bit_elf ? 4 : 8;
17258 bfd_vma count, page_size;
17259 unsigned char *descdata, *filenames, *descend;
17260
17261 if (pnote->type != NT_FILE)
17262 {
17263 if (do_wide)
17264 printf ("\n");
17265 return TRUE;
17266 }
17267
17268#ifndef BFD64
17269 if (!is_32bit_elf)
17270 {
17271 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
17272 /* Still "successful". */
17273 return TRUE;
17274 }
17275#endif
17276
17277 if (pnote->descsz < 2 * addr_size)
17278 {
17279 error (_(" Malformed note - too short for header\n"));
17280 return FALSE;
17281 }
17282
17283 descdata = (unsigned char *) pnote->descdata;
17284 descend = descdata + pnote->descsz;
17285
17286 if (descdata[pnote->descsz - 1] != '\0')
17287 {
17288 error (_(" Malformed note - does not end with \\0\n"));
17289 return FALSE;
17290 }
17291
17292 count = byte_get (descdata, addr_size);
17293 descdata += addr_size;
17294
17295 page_size = byte_get (descdata, addr_size);
17296 descdata += addr_size;
17297
17298 if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
17299 || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
17300 {
17301 error (_(" Malformed note - too short for supplied file count\n"));
17302 return FALSE;
17303 }
17304
17305 printf (_(" Page size: "));
17306 print_vma (page_size, DEC);
17307 printf ("\n");
17308
17309 printf (_(" %*s%*s%*s\n"),
17310 (int) (2 + 2 * addr_size), _("Start"),
17311 (int) (4 + 2 * addr_size), _("End"),
17312 (int) (4 + 2 * addr_size), _("Page Offset"));
17313 filenames = descdata + count * 3 * addr_size;
17314 while (count-- > 0)
17315 {
17316 bfd_vma start, end, file_ofs;
17317
17318 if (filenames == descend)
17319 {
17320 error (_(" Malformed note - filenames end too early\n"));
17321 return FALSE;
17322 }
17323
17324 start = byte_get (descdata, addr_size);
17325 descdata += addr_size;
17326 end = byte_get (descdata, addr_size);
17327 descdata += addr_size;
17328 file_ofs = byte_get (descdata, addr_size);
17329 descdata += addr_size;
17330
17331 printf (" ");
17332 print_vma (start, FULL_HEX);
17333 printf (" ");
17334 print_vma (end, FULL_HEX);
17335 printf (" ");
17336 print_vma (file_ofs, FULL_HEX);
17337 printf ("\n %s\n", filenames);
17338
17339 filenames += 1 + strlen ((char *) filenames);
17340 }
17341
17342 return TRUE;
17343}
17344
17345static const char *
17346get_gnu_elf_note_type (unsigned e_type)
17347{
17348 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17349 switch (e_type)
17350 {
17351 case NT_GNU_ABI_TAG:
17352 return _("NT_GNU_ABI_TAG (ABI version tag)");
17353 case NT_GNU_HWCAP:
17354 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17355 case NT_GNU_BUILD_ID:
17356 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17357 case NT_GNU_GOLD_VERSION:
17358 return _("NT_GNU_GOLD_VERSION (gold version)");
17359 case NT_GNU_PROPERTY_TYPE_0:
17360 return _("NT_GNU_PROPERTY_TYPE_0");
17361 case NT_GNU_BUILD_ATTRIBUTE_OPEN:
17362 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17363 case NT_GNU_BUILD_ATTRIBUTE_FUNC:
17364 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17365 default:
17366 {
17367 static char buff[64];
17368
17369 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17370 return buff;
17371 }
17372 }
17373}
17374
17375static void
17376decode_x86_compat_isa (unsigned int bitmask)
17377{
17378 while (bitmask)
17379 {
17380 unsigned int bit = bitmask & (- bitmask);
17381
17382 bitmask &= ~ bit;
17383 switch (bit)
17384 {
17385 case GNU_PROPERTY_X86_COMPAT_ISA_1_486:
17386 printf ("i486");
17387 break;
17388 case GNU_PROPERTY_X86_COMPAT_ISA_1_586:
17389 printf ("586");
17390 break;
17391 case GNU_PROPERTY_X86_COMPAT_ISA_1_686:
17392 printf ("686");
17393 break;
17394 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE:
17395 printf ("SSE");
17396 break;
17397 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2:
17398 printf ("SSE2");
17399 break;
17400 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3:
17401 printf ("SSE3");
17402 break;
17403 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3:
17404 printf ("SSSE3");
17405 break;
17406 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1:
17407 printf ("SSE4_1");
17408 break;
17409 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2:
17410 printf ("SSE4_2");
17411 break;
17412 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX:
17413 printf ("AVX");
17414 break;
17415 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2:
17416 printf ("AVX2");
17417 break;
17418 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F:
17419 printf ("AVX512F");
17420 break;
17421 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD:
17422 printf ("AVX512CD");
17423 break;
17424 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER:
17425 printf ("AVX512ER");
17426 break;
17427 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF:
17428 printf ("AVX512PF");
17429 break;
17430 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL:
17431 printf ("AVX512VL");
17432 break;
17433 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ:
17434 printf ("AVX512DQ");
17435 break;
17436 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW:
17437 printf ("AVX512BW");
17438 break;
17439 default:
17440 printf (_("<unknown: %x>"), bit);
17441 break;
17442 }
17443 if (bitmask)
17444 printf (", ");
17445 }
17446}
17447
17448static void
17449decode_x86_isa (unsigned int bitmask)
17450{
17451 if (!bitmask)
17452 {
17453 printf (_("<None>"));
17454 return;
17455 }
17456
17457 while (bitmask)
17458 {
17459 unsigned int bit = bitmask & (- bitmask);
17460
17461 bitmask &= ~ bit;
17462 switch (bit)
17463 {
17464 case GNU_PROPERTY_X86_ISA_1_CMOV:
17465 printf ("CMOV");
17466 break;
17467 case GNU_PROPERTY_X86_ISA_1_SSE:
17468 printf ("SSE");
17469 break;
17470 case GNU_PROPERTY_X86_ISA_1_SSE2:
17471 printf ("SSE2");
17472 break;
17473 case GNU_PROPERTY_X86_ISA_1_SSE3:
17474 printf ("SSE3");
17475 break;
17476 case GNU_PROPERTY_X86_ISA_1_SSSE3:
17477 printf ("SSSE3");
17478 break;
17479 case GNU_PROPERTY_X86_ISA_1_SSE4_1:
17480 printf ("SSE4_1");
17481 break;
17482 case GNU_PROPERTY_X86_ISA_1_SSE4_2:
17483 printf ("SSE4_2");
17484 break;
17485 case GNU_PROPERTY_X86_ISA_1_AVX:
17486 printf ("AVX");
17487 break;
17488 case GNU_PROPERTY_X86_ISA_1_AVX2:
17489 printf ("AVX2");
17490 break;
17491 case GNU_PROPERTY_X86_ISA_1_FMA:
17492 printf ("FMA");
17493 break;
17494 case GNU_PROPERTY_X86_ISA_1_AVX512F:
17495 printf ("AVX512F");
17496 break;
17497 case GNU_PROPERTY_X86_ISA_1_AVX512CD:
17498 printf ("AVX512CD");
17499 break;
17500 case GNU_PROPERTY_X86_ISA_1_AVX512ER:
17501 printf ("AVX512ER");
17502 break;
17503 case GNU_PROPERTY_X86_ISA_1_AVX512PF:
17504 printf ("AVX512PF");
17505 break;
17506 case GNU_PROPERTY_X86_ISA_1_AVX512VL:
17507 printf ("AVX512VL");
17508 break;
17509 case GNU_PROPERTY_X86_ISA_1_AVX512DQ:
17510 printf ("AVX512DQ");
17511 break;
17512 case GNU_PROPERTY_X86_ISA_1_AVX512BW:
17513 printf ("AVX512BW");
17514 break;
17515 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS:
17516 printf ("AVX512_4FMAPS");
17517 break;
17518 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW:
17519 printf ("AVX512_4VNNIW");
17520 break;
17521 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG:
17522 printf ("AVX512_BITALG");
17523 break;
17524 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA:
17525 printf ("AVX512_IFMA");
17526 break;
17527 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI:
17528 printf ("AVX512_VBMI");
17529 break;
17530 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2:
17531 printf ("AVX512_VBMI2");
17532 break;
17533 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI:
17534 printf ("AVX512_VNNI");
17535 break;
17536 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16:
17537 printf ("AVX512_BF16");
17538 break;
17539 default:
17540 printf (_("<unknown: %x>"), bit);
17541 break;
17542 }
17543 if (bitmask)
17544 printf (", ");
17545 }
17546}
17547
17548static void
17549decode_x86_feature_1 (unsigned int bitmask)
17550{
17551 if (!bitmask)
17552 {
17553 printf (_("<None>"));
17554 return;
17555 }
17556
17557 while (bitmask)
17558 {
17559 unsigned int bit = bitmask & (- bitmask);
17560
17561 bitmask &= ~ bit;
17562 switch (bit)
17563 {
17564 case GNU_PROPERTY_X86_FEATURE_1_IBT:
17565 printf ("IBT");
17566 break;
17567 case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
17568 printf ("SHSTK");
17569 break;
17570 default:
17571 printf (_("<unknown: %x>"), bit);
17572 break;
17573 }
17574 if (bitmask)
17575 printf (", ");
17576 }
17577}
17578
17579static void
17580decode_x86_feature_2 (unsigned int bitmask)
17581{
17582 if (!bitmask)
17583 {
17584 printf (_("<None>"));
17585 return;
17586 }
17587
17588 while (bitmask)
17589 {
17590 unsigned int bit = bitmask & (- bitmask);
17591
17592 bitmask &= ~ bit;
17593 switch (bit)
17594 {
17595 case GNU_PROPERTY_X86_FEATURE_2_X86:
17596 printf ("x86");
17597 break;
17598 case GNU_PROPERTY_X86_FEATURE_2_X87:
17599 printf ("x87");
17600 break;
17601 case GNU_PROPERTY_X86_FEATURE_2_MMX:
17602 printf ("MMX");
17603 break;
17604 case GNU_PROPERTY_X86_FEATURE_2_XMM:
17605 printf ("XMM");
17606 break;
17607 case GNU_PROPERTY_X86_FEATURE_2_YMM:
17608 printf ("YMM");
17609 break;
17610 case GNU_PROPERTY_X86_FEATURE_2_ZMM:
17611 printf ("ZMM");
17612 break;
17613 case GNU_PROPERTY_X86_FEATURE_2_FXSR:
17614 printf ("FXSR");
17615 break;
17616 case GNU_PROPERTY_X86_FEATURE_2_XSAVE:
17617 printf ("XSAVE");
17618 break;
17619 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT:
17620 printf ("XSAVEOPT");
17621 break;
17622 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC:
17623 printf ("XSAVEC");
17624 break;
17625 default:
17626 printf (_("<unknown: %x>"), bit);
17627 break;
17628 }
17629 if (bitmask)
17630 printf (", ");
17631 }
17632}
17633
17634static void
17635decode_aarch64_feature_1_and (unsigned int bitmask)
17636{
17637 while (bitmask)
17638 {
17639 unsigned int bit = bitmask & (- bitmask);
17640
17641 bitmask &= ~ bit;
17642 switch (bit)
17643 {
17644 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI:
17645 printf ("BTI");
17646 break;
17647
17648 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC:
17649 printf ("PAC");
17650 break;
17651
17652 default:
17653 printf (_("<unknown: %x>"), bit);
17654 break;
17655 }
17656 if (bitmask)
17657 printf (", ");
17658 }
17659}
17660
17661static void
17662print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
17663{
17664 unsigned char * ptr = (unsigned char *) pnote->descdata;
17665 unsigned char * ptr_end = ptr + pnote->descsz;
17666 unsigned int size = is_32bit_elf ? 4 : 8;
17667
17668 printf (_(" Properties: "));
17669
17670 if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
17671 {
17672 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
17673 return;
17674 }
17675
17676 while (ptr < ptr_end)
17677 {
17678 unsigned int j;
17679 unsigned int type;
17680 unsigned int datasz;
17681
17682 if ((size_t) (ptr_end - ptr) < 8)
17683 {
17684 printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
17685 break;
17686 }
17687
17688 type = byte_get (ptr, 4);
17689 datasz = byte_get (ptr + 4, 4);
17690
17691 ptr += 8;
17692
17693 if (datasz > (size_t) (ptr_end - ptr))
17694 {
17695 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17696 type, datasz);
17697 break;
17698 }
17699
17700 if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
17701 {
17702 if (filedata->file_header.e_machine == EM_X86_64
17703 || filedata->file_header.e_machine == EM_IAMCU
17704 || filedata->file_header.e_machine == EM_386)
17705 {
17706 unsigned int bitmask;
17707
17708 if (datasz == 4)
17709 bitmask = byte_get (ptr, 4);
17710 else
17711 bitmask = 0;
17712
17713 switch (type)
17714 {
17715 case GNU_PROPERTY_X86_ISA_1_USED:
17716 if (datasz != 4)
17717 printf (_("x86 ISA used: <corrupt length: %#x> "),
17718 datasz);
17719 else
17720 {
17721 printf ("x86 ISA used: ");
17722 decode_x86_isa (bitmask);
17723 }
17724 goto next;
17725
17726 case GNU_PROPERTY_X86_ISA_1_NEEDED:
17727 if (datasz != 4)
17728 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17729 datasz);
17730 else
17731 {
17732 printf ("x86 ISA needed: ");
17733 decode_x86_isa (bitmask);
17734 }
17735 goto next;
17736
17737 case GNU_PROPERTY_X86_FEATURE_1_AND:
17738 if (datasz != 4)
17739 printf (_("x86 feature: <corrupt length: %#x> "),
17740 datasz);
17741 else
17742 {
17743 printf ("x86 feature: ");
17744 decode_x86_feature_1 (bitmask);
17745 }
17746 goto next;
17747
17748 case GNU_PROPERTY_X86_FEATURE_2_USED:
17749 if (datasz != 4)
17750 printf (_("x86 feature used: <corrupt length: %#x> "),
17751 datasz);
17752 else
17753 {
17754 printf ("x86 feature used: ");
17755 decode_x86_feature_2 (bitmask);
17756 }
17757 goto next;
17758
17759 case GNU_PROPERTY_X86_FEATURE_2_NEEDED:
17760 if (datasz != 4)
17761 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz);
17762 else
17763 {
17764 printf ("x86 feature needed: ");
17765 decode_x86_feature_2 (bitmask);
17766 }
17767 goto next;
17768
17769 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED:
17770 if (datasz != 4)
17771 printf (_("x86 ISA used: <corrupt length: %#x> "),
17772 datasz);
17773 else
17774 {
17775 printf ("x86 ISA used: ");
17776 decode_x86_compat_isa (bitmask);
17777 }
17778 goto next;
17779
17780 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED:
17781 if (datasz != 4)
17782 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17783 datasz);
17784 else
17785 {
17786 printf ("x86 ISA needed: ");
17787 decode_x86_compat_isa (bitmask);
17788 }
17789 goto next;
17790
17791 default:
17792 break;
17793 }
17794 }
17795 else if (filedata->file_header.e_machine == EM_AARCH64)
17796 {
17797 if (type == GNU_PROPERTY_AARCH64_FEATURE_1_AND)
17798 {
17799 printf ("AArch64 feature: ");
17800 if (datasz != 4)
17801 printf (_("<corrupt length: %#x> "), datasz);
17802 else
17803 decode_aarch64_feature_1_and (byte_get (ptr, 4));
17804 goto next;
17805 }
17806 }
17807 }
17808 else
17809 {
17810 switch (type)
17811 {
17812 case GNU_PROPERTY_STACK_SIZE:
17813 printf (_("stack size: "));
17814 if (datasz != size)
17815 printf (_("<corrupt length: %#x> "), datasz);
17816 else
17817 printf ("%#lx", (unsigned long) byte_get (ptr, size));
17818 goto next;
17819
17820 case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
17821 printf ("no copy on protected ");
17822 if (datasz)
17823 printf (_("<corrupt length: %#x> "), datasz);
17824 goto next;
17825
17826 default:
17827 break;
17828 }
17829 }
17830
17831 if (type < GNU_PROPERTY_LOPROC)
17832 printf (_("<unknown type %#x data: "), type);
17833 else if (type < GNU_PROPERTY_LOUSER)
17834 printf (_("<procesor-specific type %#x data: "), type);
17835 else
17836 printf (_("<application-specific type %#x data: "), type);
17837 for (j = 0; j < datasz; ++j)
17838 printf ("%02x ", ptr[j] & 0xff);
17839 printf (">");
17840
17841next:
17842 ptr += ((datasz + (size - 1)) & ~ (size - 1));
17843 if (ptr == ptr_end)
17844 break;
17845
17846 if (do_wide)
17847 printf (", ");
17848 else
17849 printf ("\n\t");
17850 }
17851
17852 printf ("\n");
17853}
17854
17855static bfd_boolean
17856print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
17857{
17858 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
17859 switch (pnote->type)
17860 {
17861 case NT_GNU_BUILD_ID:
17862 {
17863 unsigned long i;
17864
17865 printf (_(" Build ID: "));
17866 for (i = 0; i < pnote->descsz; ++i)
17867 printf ("%02x", pnote->descdata[i] & 0xff);
17868 printf ("\n");
17869 }
17870 break;
17871
17872 case NT_GNU_ABI_TAG:
17873 {
17874 unsigned long os, major, minor, subminor;
17875 const char *osname;
17876
17877 /* PR 17531: file: 030-599401-0.004. */
17878 if (pnote->descsz < 16)
17879 {
17880 printf (_(" <corrupt GNU_ABI_TAG>\n"));
17881 break;
17882 }
17883
17884 os = byte_get ((unsigned char *) pnote->descdata, 4);
17885 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17886 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
17887 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
17888
17889 switch (os)
17890 {
17891 case GNU_ABI_TAG_LINUX:
17892 osname = "Linux";
17893 break;
17894 case GNU_ABI_TAG_HURD:
17895 osname = "Hurd";
17896 break;
17897 case GNU_ABI_TAG_SOLARIS:
17898 osname = "Solaris";
17899 break;
17900 case GNU_ABI_TAG_FREEBSD:
17901 osname = "FreeBSD";
17902 break;
17903 case GNU_ABI_TAG_NETBSD:
17904 osname = "NetBSD";
17905 break;
17906 case GNU_ABI_TAG_SYLLABLE:
17907 osname = "Syllable";
17908 break;
17909 case GNU_ABI_TAG_NACL:
17910 osname = "NaCl";
17911 break;
17912 default:
17913 osname = "Unknown";
17914 break;
17915 }
17916
17917 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
17918 major, minor, subminor);
17919 }
17920 break;
17921
17922 case NT_GNU_GOLD_VERSION:
17923 {
17924 unsigned long i;
17925
17926 printf (_(" Version: "));
17927 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
17928 printf ("%c", pnote->descdata[i]);
17929 printf ("\n");
17930 }
17931 break;
17932
17933 case NT_GNU_HWCAP:
17934 {
17935 unsigned long num_entries, mask;
17936
17937 /* Hardware capabilities information. Word 0 is the number of entries.
17938 Word 1 is a bitmask of enabled entries. The rest of the descriptor
17939 is a series of entries, where each entry is a single byte followed
17940 by a nul terminated string. The byte gives the bit number to test
17941 if enabled in the bitmask. */
17942 printf (_(" Hardware Capabilities: "));
17943 if (pnote->descsz < 8)
17944 {
17945 error (_("<corrupt GNU_HWCAP>\n"));
17946 return FALSE;
17947 }
17948 num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
17949 mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17950 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
17951 /* FIXME: Add code to display the entries... */
17952 }
17953 break;
17954
17955 case NT_GNU_PROPERTY_TYPE_0:
17956 print_gnu_property_note (filedata, pnote);
17957 break;
17958
17959 default:
17960 /* Handle unrecognised types. An error message should have already been
17961 created by get_gnu_elf_note_type(), so all that we need to do is to
17962 display the data. */
17963 {
17964 unsigned long i;
17965
17966 printf (_(" Description data: "));
17967 for (i = 0; i < pnote->descsz; ++i)
17968 printf ("%02x ", pnote->descdata[i] & 0xff);
17969 printf ("\n");
17970 }
17971 break;
17972 }
17973
17974 return TRUE;
17975}
17976
17977static const char *
17978get_v850_elf_note_type (enum v850_notes n_type)
17979{
17980 static char buff[64];
17981
17982 switch (n_type)
17983 {
17984 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
17985 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
17986 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
17987 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
17988 case V850_NOTE_CACHE_INFO: return _("Use of cache");
17989 case V850_NOTE_MMU_INFO: return _("Use of MMU");
17990 default:
17991 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
17992 return buff;
17993 }
17994}
17995
17996static bfd_boolean
17997print_v850_note (Elf_Internal_Note * pnote)
17998{
17999 unsigned int val;
18000
18001 if (pnote->descsz != 4)
18002 return FALSE;
18003
18004 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
18005
18006 if (val == 0)
18007 {
18008 printf (_("not set\n"));
18009 return TRUE;
18010 }
18011
18012 switch (pnote->type)
18013 {
18014 case V850_NOTE_ALIGNMENT:
18015 switch (val)
18016 {
18017 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
18018 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
18019 }
18020 break;
18021
18022 case V850_NOTE_DATA_SIZE:
18023 switch (val)
18024 {
18025 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
18026 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
18027 }
18028 break;
18029
18030 case V850_NOTE_FPU_INFO:
18031 switch (val)
18032 {
18033 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
18034 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
18035 }
18036 break;
18037
18038 case V850_NOTE_MMU_INFO:
18039 case V850_NOTE_CACHE_INFO:
18040 case V850_NOTE_SIMD_INFO:
18041 if (val == EF_RH850_SIMD)
18042 {
18043 printf (_("yes\n"));
18044 return TRUE;
18045 }
18046 break;
18047
18048 default:
18049 /* An 'unknown note type' message will already have been displayed. */
18050 break;
18051 }
18052
18053 printf (_("unknown value: %x\n"), val);
18054 return FALSE;
18055}
18056
18057static bfd_boolean
18058process_netbsd_elf_note (Elf_Internal_Note * pnote)
18059{
18060 unsigned int version;
18061
18062 switch (pnote->type)
18063 {
18064 case NT_NETBSD_IDENT:
18065 version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
18066 if ((version / 10000) % 100)
18067 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
18068 version, version / 100000000, (version / 1000000) % 100,
18069 (version / 10000) % 100 > 26 ? "Z" : "",
18070 'A' + (version / 10000) % 26);
18071 else
18072 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
18073 version, version / 100000000, (version / 1000000) % 100,
18074 (version / 100) % 100);
18075 return TRUE;
18076
18077 case NT_NETBSD_MARCH:
18078 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
18079 pnote->descdata);
18080 return TRUE;
18081
18082 default:
18083 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
18084 pnote->type);
18085 return FALSE;
18086 }
18087}
18088
18089static const char *
18090get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
18091{
18092 switch (e_type)
18093 {
18094 case NT_FREEBSD_THRMISC:
18095 return _("NT_THRMISC (thrmisc structure)");
18096 case NT_FREEBSD_PROCSTAT_PROC:
18097 return _("NT_PROCSTAT_PROC (proc data)");
18098 case NT_FREEBSD_PROCSTAT_FILES:
18099 return _("NT_PROCSTAT_FILES (files data)");
18100 case NT_FREEBSD_PROCSTAT_VMMAP:
18101 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18102 case NT_FREEBSD_PROCSTAT_GROUPS:
18103 return _("NT_PROCSTAT_GROUPS (groups data)");
18104 case NT_FREEBSD_PROCSTAT_UMASK:
18105 return _("NT_PROCSTAT_UMASK (umask data)");
18106 case NT_FREEBSD_PROCSTAT_RLIMIT:
18107 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18108 case NT_FREEBSD_PROCSTAT_OSREL:
18109 return _("NT_PROCSTAT_OSREL (osreldate data)");
18110 case NT_FREEBSD_PROCSTAT_PSSTRINGS:
18111 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18112 case NT_FREEBSD_PROCSTAT_AUXV:
18113 return _("NT_PROCSTAT_AUXV (auxv data)");
18114 case NT_FREEBSD_PTLWPINFO:
18115 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18116 }
18117 return get_note_type (filedata, e_type);
18118}
18119
18120static const char *
18121get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
18122{
18123 static char buff[64];
18124
18125 switch (e_type)
18126 {
18127 case NT_NETBSDCORE_PROCINFO:
18128 /* NetBSD core "procinfo" structure. */
18129 return _("NetBSD procinfo structure");
18130
18131#ifdef NT_NETBSDCORE_AUXV
18132 case NT_NETBSDCORE_AUXV:
18133 return _("NetBSD ELF auxiliary vector data");
18134#endif
18135
18136 default:
18137 /* As of Jan 2002 there are no other machine-independent notes
18138 defined for NetBSD core files. If the note type is less
18139 than the start of the machine-dependent note types, we don't
18140 understand it. */
18141
18142 if (e_type < NT_NETBSDCORE_FIRSTMACH)
18143 {
18144 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18145 return buff;
18146 }
18147 break;
18148 }
18149
18150 switch (filedata->file_header.e_machine)
18151 {
18152 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18153 and PT_GETFPREGS == mach+2. */
18154
18155 case EM_OLD_ALPHA:
18156 case EM_ALPHA:
18157 case EM_SPARC:
18158 case EM_SPARC32PLUS:
18159 case EM_SPARCV9:
18160 switch (e_type)
18161 {
18162 case NT_NETBSDCORE_FIRSTMACH + 0:
18163 return _("PT_GETREGS (reg structure)");
18164 case NT_NETBSDCORE_FIRSTMACH + 2:
18165 return _("PT_GETFPREGS (fpreg structure)");
18166 default:
18167 break;
18168 }
18169 break;
18170
18171 /* On all other arch's, PT_GETREGS == mach+1 and
18172 PT_GETFPREGS == mach+3. */
18173 default:
18174 switch (e_type)
18175 {
18176 case NT_NETBSDCORE_FIRSTMACH + 1:
18177 return _("PT_GETREGS (reg structure)");
18178 case NT_NETBSDCORE_FIRSTMACH + 3:
18179 return _("PT_GETFPREGS (fpreg structure)");
18180 default:
18181 break;
18182 }
18183 }
18184
18185 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
18186 e_type - NT_NETBSDCORE_FIRSTMACH);
18187 return buff;
18188}
18189
18190static const char *
18191get_stapsdt_note_type (unsigned e_type)
18192{
18193 static char buff[64];
18194
18195 switch (e_type)
18196 {
18197 case NT_STAPSDT:
18198 return _("NT_STAPSDT (SystemTap probe descriptors)");
18199
18200 default:
18201 break;
18202 }
18203
18204 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18205 return buff;
18206}
18207
18208static bfd_boolean
18209print_stapsdt_note (Elf_Internal_Note *pnote)
18210{
18211 size_t len, maxlen;
18212 unsigned long addr_size = is_32bit_elf ? 4 : 8;
18213 char *data = pnote->descdata;
18214 char *data_end = pnote->descdata + pnote->descsz;
18215 bfd_vma pc, base_addr, semaphore;
18216 char *provider, *probe, *arg_fmt;
18217
18218 if (pnote->descsz < (addr_size * 3))
18219 goto stapdt_note_too_small;
18220
18221 pc = byte_get ((unsigned char *) data, addr_size);
18222 data += addr_size;
18223
18224 base_addr = byte_get ((unsigned char *) data, addr_size);
18225 data += addr_size;
18226
18227 semaphore = byte_get ((unsigned char *) data, addr_size);
18228 data += addr_size;
18229
18230 if (data >= data_end)
18231 goto stapdt_note_too_small;
18232 maxlen = data_end - data;
18233 len = strnlen (data, maxlen);
18234 if (len < maxlen)
18235 {
18236 provider = data;
18237 data += len + 1;
18238 }
18239 else
18240 goto stapdt_note_too_small;
18241
18242 if (data >= data_end)
18243 goto stapdt_note_too_small;
18244 maxlen = data_end - data;
18245 len = strnlen (data, maxlen);
18246 if (len < maxlen)
18247 {
18248 probe = data;
18249 data += len + 1;
18250 }
18251 else
18252 goto stapdt_note_too_small;
18253
18254 if (data >= data_end)
18255 goto stapdt_note_too_small;
18256 maxlen = data_end - data;
18257 len = strnlen (data, maxlen);
18258 if (len < maxlen)
18259 {
18260 arg_fmt = data;
18261 data += len + 1;
18262 }
18263 else
18264 goto stapdt_note_too_small;
18265
18266 printf (_(" Provider: %s\n"), provider);
18267 printf (_(" Name: %s\n"), probe);
18268 printf (_(" Location: "));
18269 print_vma (pc, FULL_HEX);
18270 printf (_(", Base: "));
18271 print_vma (base_addr, FULL_HEX);
18272 printf (_(", Semaphore: "));
18273 print_vma (semaphore, FULL_HEX);
18274 printf ("\n");
18275 printf (_(" Arguments: %s\n"), arg_fmt);
18276
18277 return data == data_end;
18278
18279 stapdt_note_too_small:
18280 printf (_(" <corrupt - note is too small>\n"));
18281 error (_("corrupt stapdt note - the data size is too small\n"));
18282 return FALSE;
18283}
18284
18285static const char *
18286get_ia64_vms_note_type (unsigned e_type)
18287{
18288 static char buff[64];
18289
18290 switch (e_type)
18291 {
18292 case NT_VMS_MHD:
18293 return _("NT_VMS_MHD (module header)");
18294 case NT_VMS_LNM:
18295 return _("NT_VMS_LNM (language name)");
18296 case NT_VMS_SRC:
18297 return _("NT_VMS_SRC (source files)");
18298 case NT_VMS_TITLE:
18299 return "NT_VMS_TITLE";
18300 case NT_VMS_EIDC:
18301 return _("NT_VMS_EIDC (consistency check)");
18302 case NT_VMS_FPMODE:
18303 return _("NT_VMS_FPMODE (FP mode)");
18304 case NT_VMS_LINKTIME:
18305 return "NT_VMS_LINKTIME";
18306 case NT_VMS_IMGNAM:
18307 return _("NT_VMS_IMGNAM (image name)");
18308 case NT_VMS_IMGID:
18309 return _("NT_VMS_IMGID (image id)");
18310 case NT_VMS_LINKID:
18311 return _("NT_VMS_LINKID (link id)");
18312 case NT_VMS_IMGBID:
18313 return _("NT_VMS_IMGBID (build id)");
18314 case NT_VMS_GSTNAM:
18315 return _("NT_VMS_GSTNAM (sym table name)");
18316 case NT_VMS_ORIG_DYN:
18317 return "NT_VMS_ORIG_DYN";
18318 case NT_VMS_PATCHTIME:
18319 return "NT_VMS_PATCHTIME";
18320 default:
18321 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18322 return buff;
18323 }
18324}
18325
18326static bfd_boolean
18327print_ia64_vms_note (Elf_Internal_Note * pnote)
18328{
18329 int maxlen = pnote->descsz;
18330
18331 if (maxlen < 2 || (unsigned long) maxlen != pnote->descsz)
18332 goto desc_size_fail;
18333
18334 switch (pnote->type)
18335 {
18336 case NT_VMS_MHD:
18337 if (maxlen <= 36)
18338 goto desc_size_fail;
18339
18340 int l = (int) strnlen (pnote->descdata + 34, maxlen - 34);
18341
18342 printf (_(" Creation date : %.17s\n"), pnote->descdata);
18343 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
18344 if (l + 34 < maxlen)
18345 {
18346 printf (_(" Module name : %s\n"), pnote->descdata + 34);
18347 if (l + 35 < maxlen)
18348 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
18349 else
18350 printf (_(" Module version : <missing>\n"));
18351 }
18352 else
18353 {
18354 printf (_(" Module name : <missing>\n"));
18355 printf (_(" Module version : <missing>\n"));
18356 }
18357 break;
18358
18359 case NT_VMS_LNM:
18360 printf (_(" Language: %.*s\n"), maxlen, pnote->descdata);
18361 break;
18362
18363#ifdef BFD64
18364 case NT_VMS_FPMODE:
18365 printf (_(" Floating Point mode: "));
18366 if (maxlen < 8)
18367 goto desc_size_fail;
18368 /* FIXME: Generate an error if descsz > 8 ? */
18369
18370 printf ("0x%016" BFD_VMA_FMT "x\n",
18371 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
18372 break;
18373
18374 case NT_VMS_LINKTIME:
18375 printf (_(" Link time: "));
18376 if (maxlen < 8)
18377 goto desc_size_fail;
18378 /* FIXME: Generate an error if descsz > 8 ? */
18379
18380 print_vms_time
18381 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
18382 printf ("\n");
18383 break;
18384
18385 case NT_VMS_PATCHTIME:
18386 printf (_(" Patch time: "));
18387 if (maxlen < 8)
18388 goto desc_size_fail;
18389 /* FIXME: Generate an error if descsz > 8 ? */
18390
18391 print_vms_time
18392 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
18393 printf ("\n");
18394 break;
18395
18396 case NT_VMS_ORIG_DYN:
18397 if (maxlen < 34)
18398 goto desc_size_fail;
18399
18400 printf (_(" Major id: %u, minor id: %u\n"),
18401 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
18402 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
18403 printf (_(" Last modified : "));
18404 print_vms_time
18405 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
18406 printf (_("\n Link flags : "));
18407 printf ("0x%016" BFD_VMA_FMT "x\n",
18408 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
18409 printf (_(" Header flags: 0x%08x\n"),
18410 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
18411 printf (_(" Image id : %.*s\n"), maxlen - 32, pnote->descdata + 32);
18412 break;
18413#endif
18414
18415 case NT_VMS_IMGNAM:
18416 printf (_(" Image name: %.*s\n"), maxlen, pnote->descdata);
18417 break;
18418
18419 case NT_VMS_GSTNAM:
18420 printf (_(" Global symbol table name: %.*s\n"), maxlen, pnote->descdata);
18421 break;
18422
18423 case NT_VMS_IMGID:
18424 printf (_(" Image id: %.*s\n"), maxlen, pnote->descdata);
18425 break;
18426
18427 case NT_VMS_LINKID:
18428 printf (_(" Linker id: %.*s\n"), maxlen, pnote->descdata);
18429 break;
18430
18431 default:
18432 return FALSE;
18433 }
18434
18435 return TRUE;
18436
18437 desc_size_fail:
18438 printf (_(" <corrupt - data size is too small>\n"));
18439 error (_("corrupt IA64 note: data size is too small\n"));
18440 return FALSE;
18441}
18442
18443/* Find the symbol associated with a build attribute that is attached
18444 to address OFFSET. If PNAME is non-NULL then store the name of
18445 the symbol (if found) in the provided pointer, Returns NULL if a
18446 symbol could not be found. */
18447
18448static Elf_Internal_Sym *
18449get_symbol_for_build_attribute (Filedata * filedata,
18450 unsigned long offset,
18451 bfd_boolean is_open_attr,
18452 const char ** pname)
18453{
18454 static Filedata * saved_filedata = NULL;
18455 static char * strtab;
18456 static unsigned long strtablen;
18457 static Elf_Internal_Sym * symtab;
18458 static unsigned long nsyms;
18459 Elf_Internal_Sym * saved_sym = NULL;
18460 Elf_Internal_Sym * sym;
18461
18462 if (filedata->section_headers != NULL
18463 && (saved_filedata == NULL || filedata != saved_filedata))
18464 {
18465 Elf_Internal_Shdr * symsec;
18466
18467 /* Load the symbol and string sections. */
18468 for (symsec = filedata->section_headers;
18469 symsec < filedata->section_headers + filedata->file_header.e_shnum;
18470 symsec ++)
18471 {
18472 if (symsec->sh_type == SHT_SYMTAB)
18473 {
18474 symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
18475
18476 if (symsec->sh_link < filedata->file_header.e_shnum)
18477 {
18478 Elf_Internal_Shdr * strtab_sec = filedata->section_headers + symsec->sh_link;
18479
18480 strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
18481 1, strtab_sec->sh_size,
18482 _("string table"));
18483 strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
18484 }
18485 }
18486 }
18487 saved_filedata = filedata;
18488 }
18489
18490 if (symtab == NULL || strtab == NULL)
18491 return NULL;
18492
18493 /* Find a symbol whose value matches offset. */
18494 for (sym = symtab; sym < symtab + nsyms; sym ++)
18495 if (sym->st_value == offset)
18496 {
18497 if (sym->st_name >= strtablen)
18498 /* Huh ? This should not happen. */
18499 continue;
18500
18501 if (strtab[sym->st_name] == 0)
18502 continue;
18503
18504 /* The AArch64 and ARM architectures define mapping symbols
18505 (eg $d, $x, $t) which we want to ignore. */
18506 if (strtab[sym->st_name] == '$'
18507 && strtab[sym->st_name + 1] != 0
18508 && strtab[sym->st_name + 2] == 0)
18509 continue;
18510
18511 if (is_open_attr)
18512 {
18513 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
18514 and FILE or OBJECT symbols over NOTYPE symbols. We skip
18515 FUNC symbols entirely. */
18516 switch (ELF_ST_TYPE (sym->st_info))
18517 {
18518 case STT_OBJECT:
18519 case STT_FILE:
18520 saved_sym = sym;
18521 if (sym->st_size)
18522 {
18523 /* If the symbol has a size associated
18524 with it then we can stop searching. */
18525 sym = symtab + nsyms;
18526 }
18527 continue;
18528
18529 case STT_FUNC:
18530 /* Ignore function symbols. */
18531 continue;
18532
18533 default:
18534 break;
18535 }
18536
18537 switch (ELF_ST_BIND (sym->st_info))
18538 {
18539 case STB_GLOBAL:
18540 if (saved_sym == NULL
18541 || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
18542 saved_sym = sym;
18543 break;
18544
18545 case STB_LOCAL:
18546 if (saved_sym == NULL)
18547 saved_sym = sym;
18548 break;
18549
18550 default:
18551 break;
18552 }
18553 }
18554 else
18555 {
18556 if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
18557 continue;
18558
18559 saved_sym = sym;
18560 break;
18561 }
18562 }
18563
18564 if (saved_sym && pname)
18565 * pname = strtab + saved_sym->st_name;
18566
18567 return saved_sym;
18568}
18569
18570/* Returns true iff addr1 and addr2 are in the same section. */
18571
18572static bfd_boolean
18573same_section (Filedata * filedata, unsigned long addr1, unsigned long addr2)
18574{
18575 Elf_Internal_Shdr * a1;
18576 Elf_Internal_Shdr * a2;
18577
18578 a1 = find_section_by_address (filedata, addr1);
18579 a2 = find_section_by_address (filedata, addr2);
18580
18581 return a1 == a2 && a1 != NULL;
18582}
18583
18584static bfd_boolean
18585print_gnu_build_attribute_description (Elf_Internal_Note * pnote,
18586 Filedata * filedata)
18587{
18588 static unsigned long global_offset = 0;
18589 static unsigned long global_end = 0;
18590 static unsigned long func_offset = 0;
18591 static unsigned long func_end = 0;
18592
18593 Elf_Internal_Sym * sym;
18594 const char * name;
18595 unsigned long start;
18596 unsigned long end;
18597 bfd_boolean is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
18598
18599 switch (pnote->descsz)
18600 {
18601 case 0:
18602 /* A zero-length description means that the range of
18603 the previous note of the same type should be used. */
18604 if (is_open_attr)
18605 {
18606 if (global_end > global_offset)
18607 printf (_(" Applies to region from %#lx to %#lx\n"),
18608 global_offset, global_end);
18609 else
18610 printf (_(" Applies to region from %#lx\n"), global_offset);
18611 }
18612 else
18613 {
18614 if (func_end > func_offset)
18615 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset, func_end);
18616 else
18617 printf (_(" Applies to region from %#lx\n"), func_offset);
18618 }
18619 return TRUE;
18620
18621 case 4:
18622 start = byte_get ((unsigned char *) pnote->descdata, 4);
18623 end = 0;
18624 break;
18625
18626 case 8:
18627 if (is_32bit_elf)
18628 {
18629 /* FIXME: We should check that version 3+ notes are being used here... */
18630 start = byte_get ((unsigned char *) pnote->descdata, 4);
18631 end = byte_get ((unsigned char *) pnote->descdata + 4, 4);
18632 }
18633 else
18634 {
18635 start = byte_get ((unsigned char *) pnote->descdata, 8);
18636 end = 0;
18637 }
18638 break;
18639
18640 case 16:
18641 start = byte_get ((unsigned char *) pnote->descdata, 8);
18642 end = byte_get ((unsigned char *) pnote->descdata + 8, 8);
18643 break;
18644
18645 default:
18646 error (_(" <invalid description size: %lx>\n"), pnote->descsz);
18647 printf (_(" <invalid descsz>"));
18648 return FALSE;
18649 }
18650
18651 name = NULL;
18652 sym = get_symbol_for_build_attribute (filedata, start, is_open_attr, & name);
18653 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
18654 in order to avoid them being confused with the start address of the
18655 first function in the file... */
18656 if (sym == NULL && is_open_attr)
18657 sym = get_symbol_for_build_attribute (filedata, start + 2, is_open_attr,
18658 & name);
18659
18660 if (end == 0 && sym != NULL && sym->st_size > 0)
18661 end = start + sym->st_size;
18662
18663 if (is_open_attr)
18664 {
18665 /* FIXME: Need to properly allow for section alignment.
18666 16 is just the alignment used on x86_64. */
18667 if (global_end > 0
18668 && start > BFD_ALIGN (global_end, 16)
18669 /* Build notes are not guaranteed to be organised in order of
18670 increasing address, but we should find the all of the notes
18671 for one section in the same place. */
18672 && same_section (filedata, start, global_end))
18673 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
18674 global_end + 1, start - 1);
18675
18676 printf (_(" Applies to region from %#lx"), start);
18677 global_offset = start;
18678
18679 if (end)
18680 {
18681 printf (_(" to %#lx"), end);
18682 global_end = end;
18683 }
18684 }
18685 else
18686 {
18687 printf (_(" Applies to region from %#lx"), start);
18688 func_offset = start;
18689
18690 if (end)
18691 {
18692 printf (_(" to %#lx"), end);
18693 func_end = end;
18694 }
18695 }
18696
18697 if (sym && name)
18698 printf (_(" (%s)"), name);
18699
18700 printf ("\n");
18701 return TRUE;
18702}
18703
18704static bfd_boolean
18705print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
18706{
18707 static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
18708 static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
18709 static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
18710 char name_type;
18711 char name_attribute;
18712 const char * expected_types;
18713 const char * name = pnote->namedata;
18714 const char * text;
18715 signed int left;
18716
18717 if (name == NULL || pnote->namesz < 2)
18718 {
18719 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18720 print_symbol (-20, _(" <corrupt name>"));
18721 return FALSE;
18722 }
18723
18724 if (do_wide)
18725 left = 28;
18726 else
18727 left = 20;
18728
18729 /* Version 2 of the spec adds a "GA" prefix to the name field. */
18730 if (name[0] == 'G' && name[1] == 'A')
18731 {
18732 if (pnote->namesz < 4)
18733 {
18734 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18735 print_symbol (-20, _(" <corrupt name>"));
18736 return FALSE;
18737 }
18738
18739 printf ("GA");
18740 name += 2;
18741 left -= 2;
18742 }
18743
18744 switch ((name_type = * name))
18745 {
18746 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
18747 case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
18748 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
18749 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
18750 printf ("%c", * name);
18751 left --;
18752 break;
18753 default:
18754 error (_("unrecognised attribute type in name field: %d\n"), name_type);
18755 print_symbol (-20, _("<unknown name type>"));
18756 return FALSE;
18757 }
18758
18759 ++ name;
18760 text = NULL;
18761
18762 switch ((name_attribute = * name))
18763 {
18764 case GNU_BUILD_ATTRIBUTE_VERSION:
18765 text = _("<version>");
18766 expected_types = string_expected;
18767 ++ name;
18768 break;
18769 case GNU_BUILD_ATTRIBUTE_STACK_PROT:
18770 text = _("<stack prot>");
18771 expected_types = "!+*";
18772 ++ name;
18773 break;
18774 case GNU_BUILD_ATTRIBUTE_RELRO:
18775 text = _("<relro>");
18776 expected_types = bool_expected;
18777 ++ name;
18778 break;
18779 case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
18780 text = _("<stack size>");
18781 expected_types = number_expected;
18782 ++ name;
18783 break;
18784 case GNU_BUILD_ATTRIBUTE_TOOL:
18785 text = _("<tool>");
18786 expected_types = string_expected;
18787 ++ name;
18788 break;
18789 case GNU_BUILD_ATTRIBUTE_ABI:
18790 text = _("<ABI>");
18791 expected_types = "$*";
18792 ++ name;
18793 break;
18794 case GNU_BUILD_ATTRIBUTE_PIC:
18795 text = _("<PIC>");
18796 expected_types = number_expected;
18797 ++ name;
18798 break;
18799 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
18800 text = _("<short enum>");
18801 expected_types = bool_expected;
18802 ++ name;
18803 break;
18804 default:
18805 if (ISPRINT (* name))
18806 {
18807 int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
18808
18809 if (len > left && ! do_wide)
18810 len = left;
18811 printf ("%.*s:", len, name);
18812 left -= len;
18813 name += len;
18814 }
18815 else
18816 {
18817 static char tmpbuf [128];
18818
18819 error (_("unrecognised byte in name field: %d\n"), * name);
18820 sprintf (tmpbuf, _("<unknown:_%d>"), * name);
18821 text = tmpbuf;
18822 name ++;
18823 }
18824 expected_types = "*$!+";
18825 break;
18826 }
18827
18828 if (text)
18829 left -= printf ("%s", text);
18830
18831 if (strchr (expected_types, name_type) == NULL)
18832 warn (_("attribute does not have an expected type (%c)\n"), name_type);
18833
18834 if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
18835 {
18836 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
18837 (unsigned long) pnote->namesz,
18838 (long) (name - pnote->namedata));
18839 return FALSE;
18840 }
18841
18842 if (left < 1 && ! do_wide)
18843 return TRUE;
18844
18845 switch (name_type)
18846 {
18847 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
18848 {
18849 unsigned int bytes;
18850 unsigned long long val = 0;
18851 unsigned int shift = 0;
18852 char * decoded = NULL;
18853
18854 bytes = pnote->namesz - (name - pnote->namedata);
18855 if (bytes > 0)
18856 /* The -1 is because the name field is always 0 terminated, and we
18857 want to be able to ensure that the shift in the while loop below
18858 will not overflow. */
18859 -- bytes;
18860
18861 if (bytes > sizeof (val))
18862 {
18863 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
18864 bytes);
18865 bytes = sizeof (val);
18866 }
18867 /* We do not bother to warn if bytes == 0 as this can
18868 happen with some early versions of the gcc plugin. */
18869
18870 while (bytes --)
18871 {
18872 unsigned long byte = (* name ++) & 0xff;
18873
18874 val |= byte << shift;
18875 shift += 8;
18876 }
18877
18878 switch (name_attribute)
18879 {
18880 case GNU_BUILD_ATTRIBUTE_PIC:
18881 switch (val)
18882 {
18883 case 0: decoded = "static"; break;
18884 case 1: decoded = "pic"; break;
18885 case 2: decoded = "PIC"; break;
18886 case 3: decoded = "pie"; break;
18887 case 4: decoded = "PIE"; break;
18888 default: break;
18889 }
18890 break;
18891 case GNU_BUILD_ATTRIBUTE_STACK_PROT:
18892 switch (val)
18893 {
18894 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
18895 case 0: decoded = "off"; break;
18896 case 1: decoded = "on"; break;
18897 case 2: decoded = "all"; break;
18898 case 3: decoded = "strong"; break;
18899 case 4: decoded = "explicit"; break;
18900 default: break;
18901 }
18902 break;
18903 default:
18904 break;
18905 }
18906
18907 if (decoded != NULL)
18908 {
18909 print_symbol (-left, decoded);
18910 left = 0;
18911 }
18912 else if (val == 0)
18913 {
18914 printf ("0x0");
18915 left -= 3;
18916 }
18917 else
18918 {
18919 if (do_wide)
18920 left -= printf ("0x%llx", val);
18921 else
18922 left -= printf ("0x%-.*llx", left, val);
18923 }
18924 }
18925 break;
18926 case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
18927 left -= print_symbol (- left, name);
18928 break;
18929 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
18930 left -= print_symbol (- left, "true");
18931 break;
18932 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
18933 left -= print_symbol (- left, "false");
18934 break;
18935 }
18936
18937 if (do_wide && left > 0)
18938 printf ("%-*s", left, " ");
18939
18940 return TRUE;
18941}
18942
18943/* Note that by the ELF standard, the name field is already null byte
18944 terminated, and namesz includes the terminating null byte.
18945 I.E. the value of namesz for the name "FSF" is 4.
18946
18947 If the value of namesz is zero, there is no name present. */
18948
18949static bfd_boolean
18950process_note (Elf_Internal_Note * pnote,
18951 Filedata * filedata)
18952{
18953 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
18954 const char * nt;
18955
18956 if (pnote->namesz == 0)
18957 /* If there is no note name, then use the default set of
18958 note type strings. */
18959 nt = get_note_type (filedata, pnote->type);
18960
18961 else if (const_strneq (pnote->namedata, "GNU"))
18962 /* GNU-specific object file notes. */
18963 nt = get_gnu_elf_note_type (pnote->type);
18964
18965 else if (const_strneq (pnote->namedata, "FreeBSD"))
18966 /* FreeBSD-specific core file notes. */
18967 nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
18968
18969 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
18970 /* NetBSD-specific core file notes. */
18971 nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
18972
18973 else if (const_strneq (pnote->namedata, "NetBSD"))
18974 /* NetBSD-specific core file notes. */
18975 return process_netbsd_elf_note (pnote);
18976
18977 else if (strneq (pnote->namedata, "SPU/", 4))
18978 {
18979 /* SPU-specific core file notes. */
18980 nt = pnote->namedata + 4;
18981 name = "SPU";
18982 }
18983
18984 else if (const_strneq (pnote->namedata, "IPF/VMS"))
18985 /* VMS/ia64-specific file notes. */
18986 nt = get_ia64_vms_note_type (pnote->type);
18987
18988 else if (const_strneq (pnote->namedata, "stapsdt"))
18989 nt = get_stapsdt_note_type (pnote->type);
18990
18991 else
18992 /* Don't recognize this note name; just use the default set of
18993 note type strings. */
18994 nt = get_note_type (filedata, pnote->type);
18995
18996 printf (" ");
18997
18998 if (((const_strneq (pnote->namedata, "GA")
18999 && strchr ("*$!+", pnote->namedata[2]) != NULL)
19000 || strchr ("*$!+", pnote->namedata[0]) != NULL)
19001 && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
19002 || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
19003 print_gnu_build_attribute_name (pnote);
19004 else
19005 print_symbol (-20, name);
19006
19007 if (do_wide)
19008 printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
19009 else
19010 printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
19011
19012 if (const_strneq (pnote->namedata, "IPF/VMS"))
19013 return print_ia64_vms_note (pnote);
19014 else if (const_strneq (pnote->namedata, "GNU"))
19015 return print_gnu_note (filedata, pnote);
19016 else if (const_strneq (pnote->namedata, "stapsdt"))
19017 return print_stapsdt_note (pnote);
19018 else if (const_strneq (pnote->namedata, "CORE"))
19019 return print_core_note (pnote);
19020 else if (((const_strneq (pnote->namedata, "GA")
19021 && strchr ("*$!+", pnote->namedata[2]) != NULL)
19022 || strchr ("*$!+", pnote->namedata[0]) != NULL)
19023 && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
19024 || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
19025 return print_gnu_build_attribute_description (pnote, filedata);
19026
19027 if (pnote->descsz)
19028 {
19029 unsigned long i;
19030
19031 printf (_(" description data: "));
19032 for (i = 0; i < pnote->descsz; i++)
19033 printf ("%02x ", pnote->descdata[i]);
19034 if (!do_wide)
19035 printf ("\n");
19036 }
19037
19038 if (do_wide)
19039 printf ("\n");
19040
19041 return TRUE;
19042}
19043
19044static bfd_boolean
19045process_notes_at (Filedata * filedata,
19046 Elf_Internal_Shdr * section,
19047 bfd_vma offset,
19048 bfd_vma length,
19049 bfd_vma align)
19050{
19051 Elf_External_Note * pnotes;
19052 Elf_External_Note * external;
19053 char * end;
19054 bfd_boolean res = TRUE;
19055
19056 if (length <= 0)
19057 return FALSE;
19058
19059 if (section)
19060 {
19061 pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
19062 if (pnotes)
19063 {
19064 if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
19065 return FALSE;
19066 }
19067 }
19068 else
19069 pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
19070 _("notes"));
19071
19072 if (pnotes == NULL)
19073 return FALSE;
19074
19075 external = pnotes;
19076
19077 if (section)
19078 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
19079 else
19080 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19081 (unsigned long) offset, (unsigned long) length);
19082
19083 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19084 specifies that notes should be aligned to 4 bytes in 32-bit
19085 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19086 we also support 4 byte alignment in 64-bit objects. If section
19087 alignment is less than 4, we treate alignment as 4 bytes. */
19088 if (align < 4)
19089 align = 4;
19090 else if (align != 4 && align != 8)
19091 {
19092 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19093 (long) align);
19094 return FALSE;
19095 }
19096
19097 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
19098
19099 end = (char *) pnotes + length;
19100 while ((char *) external < end)
19101 {
19102 Elf_Internal_Note inote;
19103 size_t min_notesz;
19104 char * next;
19105 char * temp = NULL;
19106 size_t data_remaining = end - (char *) external;
19107
19108 if (!is_ia64_vms (filedata))
19109 {
19110 /* PR binutils/15191
19111 Make sure that there is enough data to read. */
19112 min_notesz = offsetof (Elf_External_Note, name);
19113 if (data_remaining < min_notesz)
19114 {
19115 warn (ngettext ("Corrupt note: only %ld byte remains, "
19116 "not enough for a full note\n",
19117 "Corrupt note: only %ld bytes remain, "
19118 "not enough for a full note\n",
19119 data_remaining),
19120 (long) data_remaining);
19121 break;
19122 }
19123 data_remaining -= min_notesz;
19124
19125 inote.type = BYTE_GET (external->type);
19126 inote.namesz = BYTE_GET (external->namesz);
19127 inote.namedata = external->name;
19128 inote.descsz = BYTE_GET (external->descsz);
19129 inote.descdata = ((char *) external
19130 + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
19131 inote.descpos = offset + (inote.descdata - (char *) pnotes);
19132 next = ((char *) external
19133 + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
19134 }
19135 else
19136 {
19137 Elf64_External_VMS_Note *vms_external;
19138
19139 /* PR binutils/15191
19140 Make sure that there is enough data to read. */
19141 min_notesz = offsetof (Elf64_External_VMS_Note, name);
19142 if (data_remaining < min_notesz)
19143 {
19144 warn (ngettext ("Corrupt note: only %ld byte remains, "
19145 "not enough for a full note\n",
19146 "Corrupt note: only %ld bytes remain, "
19147 "not enough for a full note\n",
19148 data_remaining),
19149 (long) data_remaining);
19150 break;
19151 }
19152 data_remaining -= min_notesz;
19153
19154 vms_external = (Elf64_External_VMS_Note *) external;
19155 inote.type = BYTE_GET (vms_external->type);
19156 inote.namesz = BYTE_GET (vms_external->namesz);
19157 inote.namedata = vms_external->name;
19158 inote.descsz = BYTE_GET (vms_external->descsz);
19159 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
19160 inote.descpos = offset + (inote.descdata - (char *) pnotes);
19161 next = inote.descdata + align_power (inote.descsz, 3);
19162 }
19163
19164 /* PR 17531: file: 3443835e. */
19165 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19166 if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
19167 || (size_t) (inote.descdata - inote.namedata) > data_remaining
19168 || (size_t) (next - inote.descdata) < inote.descsz
19169 || ((size_t) (next - inote.descdata)
19170 > data_remaining - (size_t) (inote.descdata - inote.namedata)))
19171 {
19172 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19173 (unsigned long) ((char *) external - (char *) pnotes));
19174 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19175 inote.type, inote.namesz, inote.descsz, (int) align);
19176 break;
19177 }
19178
19179 external = (Elf_External_Note *) next;
19180
19181 /* Verify that name is null terminated. It appears that at least
19182 one version of Linux (RedHat 6.0) generates corefiles that don't
19183 comply with the ELF spec by failing to include the null byte in
19184 namesz. */
19185 if (inote.namesz > 0 && inote.namedata[inote.namesz - 1] != '\0')
19186 {
19187 if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
19188 {
19189 temp = (char *) malloc (inote.namesz + 1);
19190 if (temp == NULL)
19191 {
19192 error (_("Out of memory allocating space for inote name\n"));
19193 res = FALSE;
19194 break;
19195 }
19196
19197 memcpy (temp, inote.namedata, inote.namesz);
19198 inote.namedata = temp;
19199 }
19200 inote.namedata[inote.namesz] = 0;
19201 }
19202
19203 if (! process_note (& inote, filedata))
19204 res = FALSE;
19205
19206 if (temp != NULL)
19207 {
19208 free (temp);
19209 temp = NULL;
19210 }
19211 }
19212
19213 free (pnotes);
19214
19215 return res;
19216}
19217
19218static bfd_boolean
19219process_corefile_note_segments (Filedata * filedata)
19220{
19221 Elf_Internal_Phdr * segment;
19222 unsigned int i;
19223 bfd_boolean res = TRUE;
19224
19225 if (! get_program_headers (filedata))
19226 return TRUE;
19227
19228 for (i = 0, segment = filedata->program_headers;
19229 i < filedata->file_header.e_phnum;
19230 i++, segment++)
19231 {
19232 if (segment->p_type == PT_NOTE)
19233 if (! process_notes_at (filedata, NULL,
19234 (bfd_vma) segment->p_offset,
19235 (bfd_vma) segment->p_filesz,
19236 (bfd_vma) segment->p_align))
19237 res = FALSE;
19238 }
19239
19240 return res;
19241}
19242
19243static bfd_boolean
19244process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
19245{
19246 Elf_External_Note * pnotes;
19247 Elf_External_Note * external;
19248 char * end;
19249 bfd_boolean res = TRUE;
19250
19251 if (length <= 0)
19252 return FALSE;
19253
19254 pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
19255 _("v850 notes"));
19256 if (pnotes == NULL)
19257 return FALSE;
19258
19259 external = pnotes;
19260 end = (char*) pnotes + length;
19261
19262 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19263 (unsigned long) offset, (unsigned long) length);
19264
19265 while ((char *) external + sizeof (Elf_External_Note) < end)
19266 {
19267 Elf_External_Note * next;
19268 Elf_Internal_Note inote;
19269
19270 inote.type = BYTE_GET (external->type);
19271 inote.namesz = BYTE_GET (external->namesz);
19272 inote.namedata = external->name;
19273 inote.descsz = BYTE_GET (external->descsz);
19274 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
19275 inote.descpos = offset + (inote.descdata - (char *) pnotes);
19276
19277 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
19278 {
19279 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
19280 inote.descdata = inote.namedata;
19281 inote.namesz = 0;
19282 }
19283
19284 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
19285
19286 if ( ((char *) next > end)
19287 || ((char *) next < (char *) pnotes))
19288 {
19289 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19290 (unsigned long) ((char *) external - (char *) pnotes));
19291 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19292 inote.type, inote.namesz, inote.descsz);
19293 break;
19294 }
19295
19296 external = next;
19297
19298 /* Prevent out-of-bounds indexing. */
19299 if ( inote.namedata + inote.namesz > end
19300 || inote.namedata + inote.namesz < inote.namedata)
19301 {
19302 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19303 (unsigned long) ((char *) external - (char *) pnotes));
19304 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19305 inote.type, inote.namesz, inote.descsz);
19306 break;
19307 }
19308
19309 printf (" %s: ", get_v850_elf_note_type (inote.type));
19310
19311 if (! print_v850_note (& inote))
19312 {
19313 res = FALSE;
19314 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19315 inote.namesz, inote.descsz);
19316 }
19317 }
19318
19319 free (pnotes);
19320
19321 return res;
19322}
19323
19324static bfd_boolean
19325process_note_sections (Filedata * filedata)
19326{
19327 Elf_Internal_Shdr * section;
19328 unsigned long i;
19329 unsigned int n = 0;
19330 bfd_boolean res = TRUE;
19331
19332 for (i = 0, section = filedata->section_headers;
19333 i < filedata->file_header.e_shnum && section != NULL;
19334 i++, section++)
19335 {
19336 if (section->sh_type == SHT_NOTE)
19337 {
19338 if (! process_notes_at (filedata, section,
19339 (bfd_vma) section->sh_offset,
19340 (bfd_vma) section->sh_size,
19341 (bfd_vma) section->sh_addralign))
19342 res = FALSE;
19343 n++;
19344 }
19345
19346 if (( filedata->file_header.e_machine == EM_V800
19347 || filedata->file_header.e_machine == EM_V850
19348 || filedata->file_header.e_machine == EM_CYGNUS_V850)
19349 && section->sh_type == SHT_RENESAS_INFO)
19350 {
19351 if (! process_v850_notes (filedata,
19352 (bfd_vma) section->sh_offset,
19353 (bfd_vma) section->sh_size))
19354 res = FALSE;
19355 n++;
19356 }
19357 }
19358
19359 if (n == 0)
19360 /* Try processing NOTE segments instead. */
19361 return process_corefile_note_segments (filedata);
19362
19363 return res;
19364}
19365
19366static bfd_boolean
19367process_notes (Filedata * filedata)
19368{
19369 /* If we have not been asked to display the notes then do nothing. */
19370 if (! do_notes)
19371 return TRUE;
19372
19373 if (filedata->file_header.e_type != ET_CORE)
19374 return process_note_sections (filedata);
19375
19376 /* No program headers means no NOTE segment. */
19377 if (filedata->file_header.e_phnum > 0)
19378 return process_corefile_note_segments (filedata);
19379
19380 printf (_("No note segments present in the core file.\n"));
19381 return TRUE;
19382}
19383
19384static unsigned char *
19385display_public_gnu_attributes (unsigned char * start,
19386 const unsigned char * const end)
19387{
19388 printf (_(" Unknown GNU attribute: %s\n"), start);
19389
19390 start += strnlen ((char *) start, end - start);
19391 display_raw_attribute (start, end);
19392
19393 return (unsigned char *) end;
19394}
19395
19396static unsigned char *
19397display_generic_attribute (unsigned char * start,
19398 unsigned int tag,
19399 const unsigned char * const end)
19400{
19401 if (tag == 0)
19402 return (unsigned char *) end;
19403
19404 return display_tag_value (tag, start, end);
19405}
19406
19407static bfd_boolean
19408process_arch_specific (Filedata * filedata)
19409{
19410 if (! do_arch)
19411 return TRUE;
19412
19413 switch (filedata->file_header.e_machine)
19414 {
19415 case EM_ARC:
19416 case EM_ARC_COMPACT:
19417 case EM_ARC_COMPACT2:
19418 return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
19419 display_arc_attribute,
19420 display_generic_attribute);
19421 case EM_ARM:
19422 return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
19423 display_arm_attribute,
19424 display_generic_attribute);
19425
19426 case EM_MIPS:
19427 case EM_MIPS_RS3_LE:
19428 return process_mips_specific (filedata);
19429
19430 case EM_MSP430:
19431 return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
19432 display_msp430x_attribute,
19433 display_generic_attribute);
19434
19435 case EM_RISCV:
19436 return process_attributes (filedata, "riscv", SHT_RISCV_ATTRIBUTES,
19437 display_riscv_attribute,
19438 display_generic_attribute);
19439
19440 case EM_NDS32:
19441 return process_nds32_specific (filedata);
19442
19443 case EM_PPC:
19444 case EM_PPC64:
19445 return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19446 display_power_gnu_attribute);
19447
19448 case EM_S390:
19449 case EM_S390_OLD:
19450 return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19451 display_s390_gnu_attribute);
19452
19453 case EM_SPARC:
19454 case EM_SPARC32PLUS:
19455 case EM_SPARCV9:
19456 return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19457 display_sparc_gnu_attribute);
19458
19459 case EM_TI_C6000:
19460 return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
19461 display_tic6x_attribute,
19462 display_generic_attribute);
19463
19464 default:
19465 return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
19466 display_public_gnu_attributes,
19467 display_generic_attribute);
19468 }
19469}
19470
19471static bfd_boolean
19472get_file_header (Filedata * filedata)
19473{
19474 /* Read in the identity array. */
19475 if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
19476 return FALSE;
19477
19478 /* Determine how to read the rest of the header. */
19479 switch (filedata->file_header.e_ident[EI_DATA])
19480 {
19481 default:
19482 case ELFDATANONE:
19483 case ELFDATA2LSB:
19484 byte_get = byte_get_little_endian;
19485 byte_put = byte_put_little_endian;
19486 break;
19487 case ELFDATA2MSB:
19488 byte_get = byte_get_big_endian;
19489 byte_put = byte_put_big_endian;
19490 break;
19491 }
19492
19493 /* For now we only support 32 bit and 64 bit ELF files. */
19494 is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
19495
19496 /* Read in the rest of the header. */
19497 if (is_32bit_elf)
19498 {
19499 Elf32_External_Ehdr ehdr32;
19500
19501 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
19502 return FALSE;
19503
19504 filedata->file_header.e_type = BYTE_GET (ehdr32.e_type);
19505 filedata->file_header.e_machine = BYTE_GET (ehdr32.e_machine);
19506 filedata->file_header.e_version = BYTE_GET (ehdr32.e_version);
19507 filedata->file_header.e_entry = BYTE_GET (ehdr32.e_entry);
19508 filedata->file_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
19509 filedata->file_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
19510 filedata->file_header.e_flags = BYTE_GET (ehdr32.e_flags);
19511 filedata->file_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
19512 filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
19513 filedata->file_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
19514 filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
19515 filedata->file_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
19516 filedata->file_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
19517 }
19518 else
19519 {
19520 Elf64_External_Ehdr ehdr64;
19521
19522 /* If we have been compiled with sizeof (bfd_vma) == 4, then
19523 we will not be able to cope with the 64bit data found in
19524 64 ELF files. Detect this now and abort before we start
19525 overwriting things. */
19526 if (sizeof (bfd_vma) < 8)
19527 {
19528 error (_("This instance of readelf has been built without support for a\n\
1952964 bit data type and so it cannot read 64 bit ELF files.\n"));
19530 return FALSE;
19531 }
19532
19533 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
19534 return FALSE;
19535
19536 filedata->file_header.e_type = BYTE_GET (ehdr64.e_type);
19537 filedata->file_header.e_machine = BYTE_GET (ehdr64.e_machine);
19538 filedata->file_header.e_version = BYTE_GET (ehdr64.e_version);
19539 filedata->file_header.e_entry = BYTE_GET (ehdr64.e_entry);
19540 filedata->file_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
19541 filedata->file_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
19542 filedata->file_header.e_flags = BYTE_GET (ehdr64.e_flags);
19543 filedata->file_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
19544 filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
19545 filedata->file_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
19546 filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
19547 filedata->file_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
19548 filedata->file_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
19549 }
19550
19551 if (filedata->file_header.e_shoff)
19552 {
19553 /* There may be some extensions in the first section header. Don't
19554 bomb if we can't read it. */
19555 if (is_32bit_elf)
19556 get_32bit_section_headers (filedata, TRUE);
19557 else
19558 get_64bit_section_headers (filedata, TRUE);
19559 }
19560
19561 return TRUE;
19562}
19563
19564static void
19565close_file (Filedata * filedata)
19566{
19567 if (filedata)
19568 {
19569 if (filedata->handle)
19570 fclose (filedata->handle);
19571 free (filedata);
19572 }
19573}
19574
19575void
19576close_debug_file (void * data)
19577{
19578 close_file ((Filedata *) data);
19579}
19580
19581static Filedata *
19582open_file (const char * pathname)
19583{
19584 struct stat statbuf;
19585 Filedata * filedata = NULL;
19586
19587 if (stat (pathname, & statbuf) < 0
19588 || ! S_ISREG (statbuf.st_mode))
19589 goto fail;
19590
19591 filedata = calloc (1, sizeof * filedata);
19592 if (filedata == NULL)
19593 goto fail;
19594
19595 filedata->handle = fopen (pathname, "rb");
19596 if (filedata->handle == NULL)
19597 goto fail;
19598
19599 filedata->file_size = (bfd_size_type) statbuf.st_size;
19600 filedata->file_name = pathname;
19601
19602 if (! get_file_header (filedata))
19603 goto fail;
19604
19605 if (filedata->file_header.e_shoff)
19606 {
19607 bfd_boolean res;
19608
19609 /* Read the section headers again, this time for real. */
19610 if (is_32bit_elf)
19611 res = get_32bit_section_headers (filedata, FALSE);
19612 else
19613 res = get_64bit_section_headers (filedata, FALSE);
19614
19615 if (!res)
19616 goto fail;
19617 }
19618
19619 return filedata;
19620
19621 fail:
19622 if (filedata)
19623 {
19624 if (filedata->handle)
19625 fclose (filedata->handle);
19626 free (filedata);
19627 }
19628 return NULL;
19629}
19630
19631void *
19632open_debug_file (const char * pathname)
19633{
19634 return open_file (pathname);
19635}
19636
19637/* Process one ELF object file according to the command line options.
19638 This file may actually be stored in an archive. The file is
19639 positioned at the start of the ELF object. Returns TRUE if no
19640 problems were encountered, FALSE otherwise. */
19641
19642static bfd_boolean
19643process_object (Filedata * filedata)
19644{
19645 bfd_boolean have_separate_files;
19646 unsigned int i;
19647 bfd_boolean res = TRUE;
19648
19649 if (! get_file_header (filedata))
19650 {
19651 error (_("%s: Failed to read file header\n"), filedata->file_name);
19652 return FALSE;
19653 }
19654
19655 /* Initialise per file variables. */
19656 for (i = ARRAY_SIZE (version_info); i--;)
19657 version_info[i] = 0;
19658
19659 for (i = ARRAY_SIZE (dynamic_info); i--;)
19660 dynamic_info[i] = 0;
19661 dynamic_info_DT_GNU_HASH = 0;
19662
19663 /* Process the file. */
19664 if (show_name)
19665 printf (_("\nFile: %s\n"), filedata->file_name);
19666
19667 /* Initialise the dump_sects array from the cmdline_dump_sects array.
19668 Note we do this even if cmdline_dump_sects is empty because we
19669 must make sure that the dump_sets array is zeroed out before each
19670 object file is processed. */
19671 if (filedata->num_dump_sects > cmdline.num_dump_sects)
19672 memset (filedata->dump_sects, 0, filedata->num_dump_sects * sizeof (* filedata->dump_sects));
19673
19674 if (cmdline.num_dump_sects > 0)
19675 {
19676 if (filedata->num_dump_sects == 0)
19677 /* A sneaky way of allocating the dump_sects array. */
19678 request_dump_bynumber (filedata, cmdline.num_dump_sects, 0);
19679
19680 assert (filedata->num_dump_sects >= cmdline.num_dump_sects);
19681 memcpy (filedata->dump_sects, cmdline.dump_sects,
19682 cmdline.num_dump_sects * sizeof (* filedata->dump_sects));
19683 }
19684
19685 if (! process_file_header (filedata))
19686 return FALSE;
19687
19688 if (! process_section_headers (filedata))
19689 {
19690 /* Without loaded section headers we cannot process lots of things. */
19691 do_unwind = do_version = do_dump = do_arch = FALSE;
19692
19693 if (! do_using_dynamic)
19694 do_syms = do_dyn_syms = do_reloc = FALSE;
19695 }
19696
19697 if (! process_section_groups (filedata))
19698 /* Without loaded section groups we cannot process unwind. */
19699 do_unwind = FALSE;
19700
19701 if (process_program_headers (filedata))
19702 process_dynamic_section (filedata);
19703 else
19704 res = FALSE;
19705
19706 if (! process_relocs (filedata))
19707 res = FALSE;
19708
19709 if (! process_unwind (filedata))
19710 res = FALSE;
19711
19712 if (! process_symbol_table (filedata))
19713 res = FALSE;
19714
19715 if (! process_syminfo (filedata))
19716 res = FALSE;
19717
19718 if (! process_version_sections (filedata))
19719 res = FALSE;
19720
19721 if (filedata->file_header.e_shstrndx != SHN_UNDEF)
19722 have_separate_files = load_separate_debug_files (filedata, filedata->file_name);
19723 else
19724 have_separate_files = FALSE;
19725
19726 if (! process_section_contents (filedata))
19727 res = FALSE;
19728
19729 if (have_separate_files)
19730 {
19731 separate_info * d;
19732
19733 for (d = first_separate_info; d != NULL; d = d->next)
19734 {
19735 if (! process_section_headers (d->handle))
19736 res = FALSE;
19737 else if (! process_section_contents (d->handle))
19738 res = FALSE;
19739 }
19740
19741 /* The file handles are closed by the call to free_debug_memory() below. */
19742 }
19743
19744 if (! process_notes (filedata))
19745 res = FALSE;
19746
19747 if (! process_gnu_liblist (filedata))
19748 res = FALSE;
19749
19750 if (! process_arch_specific (filedata))
19751 res = FALSE;
19752
19753 free (filedata->program_headers);
19754 filedata->program_headers = NULL;
19755
19756 free (filedata->section_headers);
19757 filedata->section_headers = NULL;
19758
19759 free (filedata->string_table);
19760 filedata->string_table = NULL;
19761 filedata->string_table_length = 0;
19762
19763 if (dynamic_strings)
19764 {
19765 free (dynamic_strings);
19766 dynamic_strings = NULL;
19767 dynamic_strings_length = 0;
19768 }
19769
19770 if (dynamic_symbols)
19771 {
19772 free (dynamic_symbols);
19773 dynamic_symbols = NULL;
19774 num_dynamic_syms = 0;
19775 }
19776
19777 if (dynamic_syminfo)
19778 {
19779 free (dynamic_syminfo);
19780 dynamic_syminfo = NULL;
19781 }
19782
19783 if (dynamic_section)
19784 {
19785 free (dynamic_section);
19786 dynamic_section = NULL;
19787 }
19788
19789 if (section_headers_groups)
19790 {
19791 free (section_headers_groups);
19792 section_headers_groups = NULL;
19793 }
19794
19795 if (section_groups)
19796 {
19797 struct group_list * g;
19798 struct group_list * next;
19799
19800 for (i = 0; i < group_count; i++)
19801 {
19802 for (g = section_groups [i].root; g != NULL; g = next)
19803 {
19804 next = g->next;
19805 free (g);
19806 }
19807 }
19808
19809 free (section_groups);
19810 section_groups = NULL;
19811 }
19812
19813 free_debug_memory ();
19814
19815 return res;
19816}
19817
19818/* Process an ELF archive.
19819 On entry the file is positioned just after the ARMAG string.
19820 Returns TRUE upon success, FALSE otherwise. */
19821
19822static bfd_boolean
19823process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
19824{
19825 struct archive_info arch;
19826 struct archive_info nested_arch;
19827 size_t got;
19828 bfd_boolean ret = TRUE;
19829
19830 show_name = TRUE;
19831
19832 /* The ARCH structure is used to hold information about this archive. */
19833 arch.file_name = NULL;
19834 arch.file = NULL;
19835 arch.index_array = NULL;
19836 arch.sym_table = NULL;
19837 arch.longnames = NULL;
19838
19839 /* The NESTED_ARCH structure is used as a single-item cache of information
19840 about a nested archive (when members of a thin archive reside within
19841 another regular archive file). */
19842 nested_arch.file_name = NULL;
19843 nested_arch.file = NULL;
19844 nested_arch.index_array = NULL;
19845 nested_arch.sym_table = NULL;
19846 nested_arch.longnames = NULL;
19847
19848 if (setup_archive (&arch, filedata->file_name, filedata->handle,
19849 is_thin_archive, do_archive_index) != 0)
19850 {
19851 ret = FALSE;
19852 goto out;
19853 }
19854
19855 if (do_archive_index)
19856 {
19857 if (arch.sym_table == NULL)
19858 error (_("%s: unable to dump the index as none was found\n"), filedata->file_name);
19859 else
19860 {
19861 unsigned long i, l;
19862 unsigned long current_pos;
19863
19864 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
19865 filedata->file_name, (unsigned long) arch.index_num, arch.sym_size);
19866
19867 current_pos = ftell (filedata->handle);
19868
19869 for (i = l = 0; i < arch.index_num; i++)
19870 {
19871 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
19872 {
19873 char * member_name;
19874
19875 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
19876
19877 if (member_name != NULL)
19878 {
19879 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
19880
19881 if (qualified_name != NULL)
19882 {
19883 printf (_("Contents of binary %s at offset "), qualified_name);
19884 (void) print_vma (arch.index_array[i], PREFIX_HEX);
19885 putchar ('\n');
19886 free (qualified_name);
19887 }
19888 }
19889 }
19890
19891 if (l >= arch.sym_size)
19892 {
19893 error (_("%s: end of the symbol table reached before the end of the index\n"),
19894 filedata->file_name);
19895 ret = FALSE;
19896 break;
19897 }
19898 /* PR 17531: file: 0b6630b2. */
19899 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
19900 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
19901 }
19902
19903 if (arch.uses_64bit_indices)
19904 l = (l + 7) & ~ 7;
19905 else
19906 l += l & 1;
19907
19908 if (l < arch.sym_size)
19909 {
19910 error (ngettext ("%s: %ld byte remains in the symbol table, "
19911 "but without corresponding entries in "
19912 "the index table\n",
19913 "%s: %ld bytes remain in the symbol table, "
19914 "but without corresponding entries in "
19915 "the index table\n",
19916 arch.sym_size - l),
19917 filedata->file_name, arch.sym_size - l);
19918 ret = FALSE;
19919 }
19920
19921 if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
19922 {
19923 error (_("%s: failed to seek back to start of object files in the archive\n"),
19924 filedata->file_name);
19925 ret = FALSE;
19926 goto out;
19927 }
19928 }
19929
19930 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
19931 && !do_segments && !do_header && !do_dump && !do_version
19932 && !do_histogram && !do_debugging && !do_arch && !do_notes
19933 && !do_section_groups && !do_dyn_syms)
19934 {
19935 ret = TRUE; /* Archive index only. */
19936 goto out;
19937 }
19938 }
19939
19940 while (1)
19941 {
19942 char * name;
19943 size_t namelen;
19944 char * qualified_name;
19945
19946 /* Read the next archive header. */
19947 if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
19948 {
19949 error (_("%s: failed to seek to next archive header\n"), arch.file_name);
19950 return FALSE;
19951 }
19952 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
19953 if (got != sizeof arch.arhdr)
19954 {
19955 if (got == 0)
19956 break;
19957 /* PR 24049 - we cannot use filedata->file_name as this will
19958 have already been freed. */
19959 error (_("%s: failed to read archive header\n"), arch.file_name);
19960
19961 ret = FALSE;
19962 break;
19963 }
19964 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
19965 {
19966 error (_("%s: did not find a valid archive header\n"), arch.file_name);
19967 ret = FALSE;
19968 break;
19969 }
19970
19971 arch.next_arhdr_offset += sizeof arch.arhdr;
19972
19973 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
19974 if (archive_file_size & 01)
19975 ++archive_file_size;
19976
19977 name = get_archive_member_name (&arch, &nested_arch);
19978 if (name == NULL)
19979 {
19980 error (_("%s: bad archive file name\n"), arch.file_name);
19981 ret = FALSE;
19982 break;
19983 }
19984 namelen = strlen (name);
19985
19986 qualified_name = make_qualified_name (&arch, &nested_arch, name);
19987 if (qualified_name == NULL)
19988 {
19989 error (_("%s: bad archive file name\n"), arch.file_name);
19990 ret = FALSE;
19991 break;
19992 }
19993
19994 if (is_thin_archive && arch.nested_member_origin == 0)
19995 {
19996 /* This is a proxy for an external member of a thin archive. */
19997 Filedata * member_filedata;
19998 char * member_file_name = adjust_relative_path
19999 (filedata->file_name, name, namelen);
20000
20001 if (member_file_name == NULL)
20002 {
20003 ret = FALSE;
20004 break;
20005 }
20006
20007 member_filedata = open_file (member_file_name);
20008 if (member_filedata == NULL)
20009 {
20010 error (_("Input file '%s' is not readable.\n"), member_file_name);
20011 free (member_file_name);
20012 ret = FALSE;
20013 break;
20014 }
20015
20016 archive_file_offset = arch.nested_member_origin;
20017 member_filedata->file_name = qualified_name;
20018
20019 if (! process_object (member_filedata))
20020 ret = FALSE;
20021
20022 close_file (member_filedata);
20023 free (member_file_name);
20024 }
20025 else if (is_thin_archive)
20026 {
20027 Filedata thin_filedata;
20028
20029 memset (&thin_filedata, 0, sizeof (thin_filedata));
20030
20031 /* PR 15140: Allow for corrupt thin archives. */
20032 if (nested_arch.file == NULL)
20033 {
20034 error (_("%s: contains corrupt thin archive: %s\n"),
20035 qualified_name, name);
20036 ret = FALSE;
20037 break;
20038 }
20039
20040 /* This is a proxy for a member of a nested archive. */
20041 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
20042
20043 /* The nested archive file will have been opened and setup by
20044 get_archive_member_name. */
20045 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
20046 {
20047 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
20048 ret = FALSE;
20049 break;
20050 }
20051
20052 thin_filedata.handle = nested_arch.file;
20053 thin_filedata.file_name = qualified_name;
20054
20055 if (! process_object (& thin_filedata))
20056 ret = FALSE;
20057 }
20058 else
20059 {
20060 archive_file_offset = arch.next_arhdr_offset;
20061 arch.next_arhdr_offset += archive_file_size;
20062
20063 filedata->file_name = qualified_name;
20064 if (! process_object (filedata))
20065 ret = FALSE;
20066 }
20067
20068 if (filedata->dump_sects != NULL)
20069 {
20070 free (filedata->dump_sects);
20071 filedata->dump_sects = NULL;
20072 filedata->num_dump_sects = 0;
20073 }
20074
20075 free (qualified_name);
20076 }
20077
20078 out:
20079 if (nested_arch.file != NULL)
20080 fclose (nested_arch.file);
20081 release_archive (&nested_arch);
20082 release_archive (&arch);
20083
20084 return ret;
20085}
20086
20087static bfd_boolean
20088process_file (char * file_name)
20089{
20090 Filedata * filedata = NULL;
20091 struct stat statbuf;
20092 char armag[SARMAG];
20093 bfd_boolean ret = TRUE;
20094
20095 if (stat (file_name, &statbuf) < 0)
20096 {
20097 if (errno == ENOENT)
20098 error (_("'%s': No such file\n"), file_name);
20099 else
20100 error (_("Could not locate '%s'. System error message: %s\n"),
20101 file_name, strerror (errno));
20102 return FALSE;
20103 }
20104
20105 if (! S_ISREG (statbuf.st_mode))
20106 {
20107 error (_("'%s' is not an ordinary file\n"), file_name);
20108 return FALSE;
20109 }
20110
20111 filedata = calloc (1, sizeof * filedata);
20112 if (filedata == NULL)
20113 {
20114 error (_("Out of memory allocating file data structure\n"));
20115 return FALSE;
20116 }
20117
20118 filedata->file_name = file_name;
20119 filedata->handle = fopen (file_name, "rb");
20120 if (filedata->handle == NULL)
20121 {
20122 error (_("Input file '%s' is not readable.\n"), file_name);
20123 free (filedata);
20124 return FALSE;
20125 }
20126
20127 if (fread (armag, SARMAG, 1, filedata->handle) != 1)
20128 {
20129 error (_("%s: Failed to read file's magic number\n"), file_name);
20130 fclose (filedata->handle);
20131 free (filedata);
20132 return FALSE;
20133 }
20134
20135 filedata->file_size = (bfd_size_type) statbuf.st_size;
20136
20137 if (memcmp (armag, ARMAG, SARMAG) == 0)
20138 {
20139 if (! process_archive (filedata, FALSE))
20140 ret = FALSE;
20141 }
20142 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
20143 {
20144 if ( ! process_archive (filedata, TRUE))
20145 ret = FALSE;
20146 }
20147 else
20148 {
20149 if (do_archive_index)
20150 error (_("File %s is not an archive so its index cannot be displayed.\n"),
20151 file_name);
20152
20153 rewind (filedata->handle);
20154 archive_file_size = archive_file_offset = 0;
20155
20156 if (! process_object (filedata))
20157 ret = FALSE;
20158 }
20159
20160 fclose (filedata->handle);
20161 free (filedata);
20162
20163 return ret;
20164}
20165
20166#ifdef SUPPORT_DISASSEMBLY
20167/* Needed by the i386 disassembler. For extra credit, someone could
20168 fix this so that we insert symbolic addresses here, esp for GOT/PLT
20169 symbols. */
20170
20171void
20172print_address (unsigned int addr, FILE * outfile)
20173{
20174 fprintf (outfile,"0x%8.8x", addr);
20175}
20176
20177/* Needed by the i386 disassembler. */
20178
20179void
20180db_task_printsym (unsigned int addr)
20181{
20182 print_address (addr, stderr);
20183}
20184#endif
20185
20186int
20187main (int argc, char ** argv)
20188{
20189 int err;
20190
20191#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20192 setlocale (LC_MESSAGES, "");
20193#endif
20194#if defined (HAVE_SETLOCALE)
20195 setlocale (LC_CTYPE, "");
20196#endif
20197 bindtextdomain (PACKAGE, LOCALEDIR);
20198 textdomain (PACKAGE);
20199
20200 expandargv (&argc, &argv);
20201
20202 cmdline.file_name = "<cmdline>";
20203 parse_args (& cmdline, argc, argv);
20204
20205 if (optind < (argc - 1))
20206 show_name = TRUE;
20207 else if (optind >= argc)
20208 {
20209 warn (_("Nothing to do.\n"));
20210 usage (stderr);
20211 }
20212
20213 err = FALSE;
20214 while (optind < argc)
20215 if (! process_file (argv[optind++]))
20216 err = TRUE;
20217
20218 if (cmdline.dump_sects != NULL)
20219 free (cmdline.dump_sects);
20220
20221 free (dump_ctf_symtab_name);
20222 free (dump_ctf_strtab_name);
20223 free (dump_ctf_parent_name);
20224
20225 return err ? EXIT_FAILURE : EXIT_SUCCESS;
20226}
A mirror of the official binutils-gdb repository