]> 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
PR25593, --as-needed breaks DT_NEEDED order with linker plugin
[thirdparty/binutils-gdb.git] / binutils / readelf.c
... / ...
CommitLineData
1/* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2020 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#include "elf/z80.h"
166
167#include "getopt.h"
168#include "libiberty.h"
169#include "safe-ctype.h"
170#include "filenames.h"
171
172#ifndef offsetof
173#define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
174#endif
175
176typedef struct elf_section_list
177{
178 Elf_Internal_Shdr * hdr;
179 struct elf_section_list * next;
180} elf_section_list;
181
182/* Flag bits indicating particular types of dump. */
183#define HEX_DUMP (1 << 0) /* The -x command line switch. */
184#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
185#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
186#define STRING_DUMP (1 << 3) /* The -p command line switch. */
187#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
188#define CTF_DUMP (1 << 5) /* The --ctf command line switch. */
189
190typedef unsigned char dump_type;
191
192/* A linked list of the section names for which dumps were requested. */
193struct dump_list_entry
194{
195 char * name;
196 dump_type type;
197 struct dump_list_entry * next;
198};
199
200typedef struct filedata
201{
202 const char * file_name;
203 FILE * handle;
204 bfd_size_type file_size;
205 Elf_Internal_Ehdr file_header;
206 Elf_Internal_Shdr * section_headers;
207 Elf_Internal_Phdr * program_headers;
208 char * string_table;
209 unsigned long string_table_length;
210 /* A dynamic array of flags indicating for which sections a dump of
211 some kind has been requested. It is reset on a per-object file
212 basis and then initialised from the cmdline_dump_sects array,
213 the results of interpreting the -w switch, and the
214 dump_sects_byname list. */
215 dump_type * dump_sects;
216 unsigned int num_dump_sects;
217} Filedata;
218
219char * program_name = "readelf";
220
221static unsigned long archive_file_offset;
222static unsigned long archive_file_size;
223static unsigned long dynamic_addr;
224static bfd_size_type dynamic_size;
225static size_t dynamic_nent;
226static char * dynamic_strings;
227static unsigned long dynamic_strings_length;
228static unsigned long num_dynamic_syms;
229static Elf_Internal_Sym * dynamic_symbols;
230static Elf_Internal_Syminfo * dynamic_syminfo;
231static unsigned long dynamic_syminfo_offset;
232static unsigned int dynamic_syminfo_nent;
233static char program_interpreter[PATH_MAX];
234static bfd_vma dynamic_info[DT_ENCODING];
235static bfd_vma dynamic_info_DT_GNU_HASH;
236static bfd_vma dynamic_info_DT_MIPS_XHASH;
237static bfd_vma version_info[16];
238static Elf_Internal_Dyn * dynamic_section;
239static elf_section_list * symtab_shndx_list;
240static bfd_boolean show_name = FALSE;
241static bfd_boolean do_dynamic = FALSE;
242static bfd_boolean do_syms = FALSE;
243static bfd_boolean do_dyn_syms = FALSE;
244static bfd_boolean do_reloc = FALSE;
245static bfd_boolean do_sections = FALSE;
246static bfd_boolean do_section_groups = FALSE;
247static bfd_boolean do_section_details = FALSE;
248static bfd_boolean do_segments = FALSE;
249static bfd_boolean do_unwind = FALSE;
250static bfd_boolean do_using_dynamic = FALSE;
251static bfd_boolean do_header = FALSE;
252static bfd_boolean do_dump = FALSE;
253static bfd_boolean do_version = FALSE;
254static bfd_boolean do_histogram = FALSE;
255static bfd_boolean do_debugging = FALSE;
256static bfd_boolean do_ctf = FALSE;
257static bfd_boolean do_arch = FALSE;
258static bfd_boolean do_notes = FALSE;
259static bfd_boolean do_archive_index = FALSE;
260static bfd_boolean is_32bit_elf = FALSE;
261static bfd_boolean decompress_dumps = FALSE;
262
263static char *dump_ctf_parent_name;
264static char *dump_ctf_symtab_name;
265static char *dump_ctf_strtab_name;
266
267struct group_list
268{
269 struct group_list * next;
270 unsigned int section_index;
271};
272
273struct group
274{
275 struct group_list * root;
276 unsigned int group_index;
277};
278
279static size_t group_count;
280static struct group * section_groups;
281static struct group ** section_headers_groups;
282
283/* A dynamic array of flags indicating for which sections a dump
284 has been requested via command line switches. */
285static Filedata cmdline;
286
287static struct dump_list_entry * dump_sects_byname;
288
289/* How to print a vma value. */
290typedef enum print_mode
291{
292 HEX,
293 DEC,
294 DEC_5,
295 UNSIGNED,
296 PREFIX_HEX,
297 FULL_HEX,
298 LONG_HEX
299}
300print_mode;
301
302/* Versioned symbol info. */
303enum versioned_symbol_info
304{
305 symbol_undefined,
306 symbol_hidden,
307 symbol_public
308};
309
310static const char * get_symbol_version_string
311 (Filedata *, bfd_boolean, const char *, unsigned long, unsigned,
312 Elf_Internal_Sym *, enum versioned_symbol_info *, unsigned short *);
313
314#define UNKNOWN -1
315
316#define SECTION_NAME(X) \
317 ((X) == NULL ? _("<none>") \
318 : filedata->string_table == NULL ? _("<no-strings>") \
319 : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>") \
320 : filedata->string_table + (X)->sh_name))
321
322#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
323
324#define GET_ELF_SYMBOLS(file, section, sym_count) \
325 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
326 : get_64bit_elf_symbols (file, section, sym_count))
327
328#define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
329/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
330 already been called and verified that the string exists. */
331#define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
332
333#define REMOVE_ARCH_BITS(ADDR) \
334 do \
335 { \
336 if (filedata->file_header.e_machine == EM_ARM) \
337 (ADDR) &= ~1; \
338 } \
339 while (0)
340
341/* Get the correct GNU hash section name. */
342#define GNU_HASH_SECTION_NAME \
343 dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
344\f
345/* Print a BFD_VMA to an internal buffer, for use in error messages.
346 BFD_FMA_FMT can't be used in translated strings. */
347
348static const char *
349bfd_vmatoa (char *fmtch, bfd_vma value)
350{
351 /* bfd_vmatoa is used more then once in a printf call for output.
352 Cycle through an array of buffers. */
353 static int buf_pos = 0;
354 static struct bfd_vmatoa_buf
355 {
356 char place[64];
357 } buf[4];
358 char *ret;
359 char fmt[32];
360
361 ret = buf[buf_pos++].place;
362 buf_pos %= ARRAY_SIZE (buf);
363
364 sprintf (fmt, "%%%s%s", BFD_VMA_FMT, fmtch);
365 snprintf (ret, sizeof (buf[0].place), fmt, value);
366 return ret;
367}
368
369/* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
370 OFFSET + the offset of the current archive member, if we are examining an
371 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
372 allocate a buffer using malloc and fill that. In either case return the
373 pointer to the start of the retrieved data or NULL if something went wrong.
374 If something does go wrong and REASON is not NULL then emit an error
375 message using REASON as part of the context. */
376
377static void *
378get_data (void * var,
379 Filedata * filedata,
380 unsigned long offset,
381 bfd_size_type size,
382 bfd_size_type nmemb,
383 const char * reason)
384{
385 void * mvar;
386 bfd_size_type amt = size * nmemb;
387
388 if (size == 0 || nmemb == 0)
389 return NULL;
390
391 /* If the size_t type is smaller than the bfd_size_type, eg because
392 you are building a 32-bit tool on a 64-bit host, then make sure
393 that when the sizes are cast to (size_t) no information is lost. */
394 if ((size_t) size != size
395 || (size_t) nmemb != nmemb
396 || (size_t) amt != amt)
397 {
398 if (reason)
399 error (_("Size truncation prevents reading %s"
400 " elements of size %s for %s\n"),
401 bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
402 return NULL;
403 }
404
405 /* Check for size overflow. */
406 if (amt / size != nmemb || (size_t) amt + 1 == 0)
407 {
408 if (reason)
409 error (_("Size overflow prevents reading %s"
410 " elements of size %s for %s\n"),
411 bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
412 return NULL;
413 }
414
415 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
416 attempting to allocate memory when the read is bound to fail. */
417 if (archive_file_offset > filedata->file_size
418 || offset > filedata->file_size - archive_file_offset
419 || amt > filedata->file_size - archive_file_offset - offset)
420 {
421 if (reason)
422 error (_("Reading %s bytes extends past end of file for %s\n"),
423 bfd_vmatoa ("u", amt), reason);
424 return NULL;
425 }
426
427 if (fseek (filedata->handle, archive_file_offset + offset, SEEK_SET))
428 {
429 if (reason)
430 error (_("Unable to seek to 0x%lx for %s\n"),
431 archive_file_offset + offset, reason);
432 return NULL;
433 }
434
435 mvar = var;
436 if (mvar == NULL)
437 {
438 /* + 1 so that we can '\0' terminate invalid string table sections. */
439 mvar = malloc ((size_t) amt + 1);
440
441 if (mvar == NULL)
442 {
443 if (reason)
444 error (_("Out of memory allocating %s bytes for %s\n"),
445 bfd_vmatoa ("u", amt), reason);
446 return NULL;
447 }
448
449 ((char *) mvar)[amt] = '\0';
450 }
451
452 if (fread (mvar, (size_t) size, (size_t) nmemb, filedata->handle) != nmemb)
453 {
454 if (reason)
455 error (_("Unable to read in %s bytes of %s\n"),
456 bfd_vmatoa ("u", amt), reason);
457 if (mvar != var)
458 free (mvar);
459 return NULL;
460 }
461
462 return mvar;
463}
464
465/* Print a VMA value in the MODE specified.
466 Returns the number of characters displayed. */
467
468static unsigned int
469print_vma (bfd_vma vma, print_mode mode)
470{
471 unsigned int nc = 0;
472
473 switch (mode)
474 {
475 case FULL_HEX:
476 nc = printf ("0x");
477 /* Fall through. */
478 case LONG_HEX:
479#ifdef BFD64
480 if (is_32bit_elf)
481 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
482#endif
483 printf_vma (vma);
484 return nc + 16;
485
486 case DEC_5:
487 if (vma <= 99999)
488 return printf ("%5" BFD_VMA_FMT "d", vma);
489 /* Fall through. */
490 case PREFIX_HEX:
491 nc = printf ("0x");
492 /* Fall through. */
493 case HEX:
494 return nc + printf ("%" BFD_VMA_FMT "x", vma);
495
496 case DEC:
497 return printf ("%" BFD_VMA_FMT "d", vma);
498
499 case UNSIGNED:
500 return printf ("%" BFD_VMA_FMT "u", vma);
501
502 default:
503 /* FIXME: Report unrecognised mode ? */
504 return 0;
505 }
506}
507
508/* Display a symbol on stdout. Handles the display of control characters and
509 multibye characters (assuming the host environment supports them).
510
511 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
512
513 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
514 padding as necessary.
515
516 Returns the number of emitted characters. */
517
518static unsigned int
519print_symbol (signed int width, const char *symbol)
520{
521 bfd_boolean extra_padding = FALSE;
522 signed int num_printed = 0;
523#ifdef HAVE_MBSTATE_T
524 mbstate_t state;
525#endif
526 unsigned int width_remaining;
527
528 if (width < 0)
529 {
530 /* Keep the width positive. This helps the code below. */
531 width = - width;
532 extra_padding = TRUE;
533 }
534 else if (width == 0)
535 return 0;
536
537 if (do_wide)
538 /* Set the remaining width to a very large value.
539 This simplifies the code below. */
540 width_remaining = INT_MAX;
541 else
542 width_remaining = width;
543
544#ifdef HAVE_MBSTATE_T
545 /* Initialise the multibyte conversion state. */
546 memset (& state, 0, sizeof (state));
547#endif
548
549 while (width_remaining)
550 {
551 size_t n;
552 const char c = *symbol++;
553
554 if (c == 0)
555 break;
556
557 /* Do not print control characters directly as they can affect terminal
558 settings. Such characters usually appear in the names generated
559 by the assembler for local labels. */
560 if (ISCNTRL (c))
561 {
562 if (width_remaining < 2)
563 break;
564
565 printf ("^%c", c + 0x40);
566 width_remaining -= 2;
567 num_printed += 2;
568 }
569 else if (ISPRINT (c))
570 {
571 putchar (c);
572 width_remaining --;
573 num_printed ++;
574 }
575 else
576 {
577#ifdef HAVE_MBSTATE_T
578 wchar_t w;
579#endif
580 /* Let printf do the hard work of displaying multibyte characters. */
581 printf ("%.1s", symbol - 1);
582 width_remaining --;
583 num_printed ++;
584
585#ifdef HAVE_MBSTATE_T
586 /* Try to find out how many bytes made up the character that was
587 just printed. Advance the symbol pointer past the bytes that
588 were displayed. */
589 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
590#else
591 n = 1;
592#endif
593 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
594 symbol += (n - 1);
595 }
596 }
597
598 if (extra_padding && num_printed < width)
599 {
600 /* Fill in the remaining spaces. */
601 printf ("%-*s", width - num_printed, " ");
602 num_printed = width;
603 }
604
605 return num_printed;
606}
607
608/* Returns a pointer to a static buffer containing a printable version of
609 the given section's name. Like print_symbol, except that it does not try
610 to print multibyte characters, it just interprets them as hex values. */
611
612static const char *
613printable_section_name (Filedata * filedata, const Elf_Internal_Shdr * sec)
614{
615#define MAX_PRINT_SEC_NAME_LEN 128
616 static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
617 const char * name = SECTION_NAME (sec);
618 char * buf = sec_name_buf;
619 char c;
620 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
621
622 while ((c = * name ++) != 0)
623 {
624 if (ISCNTRL (c))
625 {
626 if (remaining < 2)
627 break;
628
629 * buf ++ = '^';
630 * buf ++ = c + 0x40;
631 remaining -= 2;
632 }
633 else if (ISPRINT (c))
634 {
635 * buf ++ = c;
636 remaining -= 1;
637 }
638 else
639 {
640 static char hex[17] = "0123456789ABCDEF";
641
642 if (remaining < 4)
643 break;
644 * buf ++ = '<';
645 * buf ++ = hex[(c & 0xf0) >> 4];
646 * buf ++ = hex[c & 0x0f];
647 * buf ++ = '>';
648 remaining -= 4;
649 }
650
651 if (remaining == 0)
652 break;
653 }
654
655 * buf = 0;
656 return sec_name_buf;
657}
658
659static const char *
660printable_section_name_from_index (Filedata * filedata, unsigned long ndx)
661{
662 if (ndx >= filedata->file_header.e_shnum)
663 return _("<corrupt>");
664
665 return printable_section_name (filedata, filedata->section_headers + ndx);
666}
667
668/* Return a pointer to section NAME, or NULL if no such section exists. */
669
670static Elf_Internal_Shdr *
671find_section (Filedata * filedata, const char * name)
672{
673 unsigned int i;
674
675 if (filedata->section_headers == NULL)
676 return NULL;
677
678 for (i = 0; i < filedata->file_header.e_shnum; i++)
679 if (streq (SECTION_NAME (filedata->section_headers + i), name))
680 return filedata->section_headers + i;
681
682 return NULL;
683}
684
685/* Return a pointer to a section containing ADDR, or NULL if no such
686 section exists. */
687
688static Elf_Internal_Shdr *
689find_section_by_address (Filedata * filedata, bfd_vma addr)
690{
691 unsigned int i;
692
693 if (filedata->section_headers == NULL)
694 return NULL;
695
696 for (i = 0; i < filedata->file_header.e_shnum; i++)
697 {
698 Elf_Internal_Shdr *sec = filedata->section_headers + i;
699
700 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
701 return sec;
702 }
703
704 return NULL;
705}
706
707static Elf_Internal_Shdr *
708find_section_by_type (Filedata * filedata, unsigned int type)
709{
710 unsigned int i;
711
712 if (filedata->section_headers == NULL)
713 return NULL;
714
715 for (i = 0; i < filedata->file_header.e_shnum; i++)
716 {
717 Elf_Internal_Shdr *sec = filedata->section_headers + i;
718
719 if (sec->sh_type == type)
720 return sec;
721 }
722
723 return NULL;
724}
725
726/* Return a pointer to section NAME, or NULL if no such section exists,
727 restricted to the list of sections given in SET. */
728
729static Elf_Internal_Shdr *
730find_section_in_set (Filedata * filedata, const char * name, unsigned int * set)
731{
732 unsigned int i;
733
734 if (filedata->section_headers == NULL)
735 return NULL;
736
737 if (set != NULL)
738 {
739 while ((i = *set++) > 0)
740 {
741 /* See PR 21156 for a reproducer. */
742 if (i >= filedata->file_header.e_shnum)
743 continue; /* FIXME: Should we issue an error message ? */
744
745 if (streq (SECTION_NAME (filedata->section_headers + i), name))
746 return filedata->section_headers + i;
747 }
748 }
749
750 return find_section (filedata, name);
751}
752
753/* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
754 This OS has so many departures from the ELF standard that we test it at
755 many places. */
756
757static inline bfd_boolean
758is_ia64_vms (Filedata * filedata)
759{
760 return filedata->file_header.e_machine == EM_IA_64
761 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
762}
763
764/* Guess the relocation size commonly used by the specific machines. */
765
766static bfd_boolean
767guess_is_rela (unsigned int e_machine)
768{
769 switch (e_machine)
770 {
771 /* Targets that use REL relocations. */
772 case EM_386:
773 case EM_IAMCU:
774 case EM_960:
775 case EM_ARM:
776 case EM_D10V:
777 case EM_CYGNUS_D10V:
778 case EM_DLX:
779 case EM_MIPS:
780 case EM_MIPS_RS3_LE:
781 case EM_CYGNUS_M32R:
782 case EM_SCORE:
783 case EM_XGATE:
784 case EM_NFP:
785 case EM_BPF:
786 return FALSE;
787
788 /* Targets that use RELA relocations. */
789 case EM_68K:
790 case EM_860:
791 case EM_AARCH64:
792 case EM_ADAPTEVA_EPIPHANY:
793 case EM_ALPHA:
794 case EM_ALTERA_NIOS2:
795 case EM_ARC:
796 case EM_ARC_COMPACT:
797 case EM_ARC_COMPACT2:
798 case EM_AVR:
799 case EM_AVR_OLD:
800 case EM_BLACKFIN:
801 case EM_CR16:
802 case EM_CRIS:
803 case EM_CRX:
804 case EM_CSKY:
805 case EM_D30V:
806 case EM_CYGNUS_D30V:
807 case EM_FR30:
808 case EM_FT32:
809 case EM_CYGNUS_FR30:
810 case EM_CYGNUS_FRV:
811 case EM_H8S:
812 case EM_H8_300:
813 case EM_H8_300H:
814 case EM_IA_64:
815 case EM_IP2K:
816 case EM_IP2K_OLD:
817 case EM_IQ2000:
818 case EM_LATTICEMICO32:
819 case EM_M32C_OLD:
820 case EM_M32C:
821 case EM_M32R:
822 case EM_MCORE:
823 case EM_CYGNUS_MEP:
824 case EM_METAG:
825 case EM_MMIX:
826 case EM_MN10200:
827 case EM_CYGNUS_MN10200:
828 case EM_MN10300:
829 case EM_CYGNUS_MN10300:
830 case EM_MOXIE:
831 case EM_MSP430:
832 case EM_MSP430_OLD:
833 case EM_MT:
834 case EM_NDS32:
835 case EM_NIOS32:
836 case EM_OR1K:
837 case EM_PPC64:
838 case EM_PPC:
839 case EM_TI_PRU:
840 case EM_RISCV:
841 case EM_RL78:
842 case EM_RX:
843 case EM_S390:
844 case EM_S390_OLD:
845 case EM_SH:
846 case EM_SPARC:
847 case EM_SPARC32PLUS:
848 case EM_SPARCV9:
849 case EM_SPU:
850 case EM_TI_C6000:
851 case EM_TILEGX:
852 case EM_TILEPRO:
853 case EM_V800:
854 case EM_V850:
855 case EM_CYGNUS_V850:
856 case EM_VAX:
857 case EM_VISIUM:
858 case EM_X86_64:
859 case EM_L1OM:
860 case EM_K1OM:
861 case EM_XSTORMY16:
862 case EM_XTENSA:
863 case EM_XTENSA_OLD:
864 case EM_MICROBLAZE:
865 case EM_MICROBLAZE_OLD:
866 case EM_WEBASSEMBLY:
867 return TRUE;
868
869 case EM_68HC05:
870 case EM_68HC08:
871 case EM_68HC11:
872 case EM_68HC16:
873 case EM_FX66:
874 case EM_ME16:
875 case EM_MMA:
876 case EM_NCPU:
877 case EM_NDR1:
878 case EM_PCP:
879 case EM_ST100:
880 case EM_ST19:
881 case EM_ST7:
882 case EM_ST9PLUS:
883 case EM_STARCORE:
884 case EM_SVX:
885 case EM_TINYJ:
886 default:
887 warn (_("Don't know about relocations on this machine architecture\n"));
888 return FALSE;
889 }
890}
891
892/* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
893 Returns TRUE upon success, FALSE otherwise. If successful then a
894 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
895 and the number of relocs loaded is placed in *NRELASP. It is the caller's
896 responsibility to free the allocated buffer. */
897
898static bfd_boolean
899slurp_rela_relocs (Filedata * filedata,
900 unsigned long rel_offset,
901 unsigned long rel_size,
902 Elf_Internal_Rela ** relasp,
903 unsigned long * nrelasp)
904{
905 Elf_Internal_Rela * relas;
906 size_t nrelas;
907 unsigned int i;
908
909 if (is_32bit_elf)
910 {
911 Elf32_External_Rela * erelas;
912
913 erelas = (Elf32_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
914 rel_size, _("32-bit relocation data"));
915 if (!erelas)
916 return FALSE;
917
918 nrelas = rel_size / sizeof (Elf32_External_Rela);
919
920 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
921 sizeof (Elf_Internal_Rela));
922
923 if (relas == NULL)
924 {
925 free (erelas);
926 error (_("out of memory parsing relocs\n"));
927 return FALSE;
928 }
929
930 for (i = 0; i < nrelas; i++)
931 {
932 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
933 relas[i].r_info = BYTE_GET (erelas[i].r_info);
934 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
935 }
936
937 free (erelas);
938 }
939 else
940 {
941 Elf64_External_Rela * erelas;
942
943 erelas = (Elf64_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
944 rel_size, _("64-bit relocation data"));
945 if (!erelas)
946 return FALSE;
947
948 nrelas = rel_size / sizeof (Elf64_External_Rela);
949
950 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
951 sizeof (Elf_Internal_Rela));
952
953 if (relas == NULL)
954 {
955 free (erelas);
956 error (_("out of memory parsing relocs\n"));
957 return FALSE;
958 }
959
960 for (i = 0; i < nrelas; i++)
961 {
962 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
963 relas[i].r_info = BYTE_GET (erelas[i].r_info);
964 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
965
966 /* The #ifdef BFD64 below is to prevent a compile time
967 warning. We know that if we do not have a 64 bit data
968 type that we will never execute this code anyway. */
969#ifdef BFD64
970 if (filedata->file_header.e_machine == EM_MIPS
971 && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
972 {
973 /* In little-endian objects, r_info isn't really a
974 64-bit little-endian value: it has a 32-bit
975 little-endian symbol index followed by four
976 individual byte fields. Reorder INFO
977 accordingly. */
978 bfd_vma inf = relas[i].r_info;
979 inf = (((inf & 0xffffffff) << 32)
980 | ((inf >> 56) & 0xff)
981 | ((inf >> 40) & 0xff00)
982 | ((inf >> 24) & 0xff0000)
983 | ((inf >> 8) & 0xff000000));
984 relas[i].r_info = inf;
985 }
986#endif /* BFD64 */
987 }
988
989 free (erelas);
990 }
991
992 *relasp = relas;
993 *nrelasp = nrelas;
994 return TRUE;
995}
996
997/* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
998 Returns TRUE upon success, FALSE otherwise. If successful then a
999 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1000 and the number of relocs loaded is placed in *NRELSP. It is the caller's
1001 responsibility to free the allocated buffer. */
1002
1003static bfd_boolean
1004slurp_rel_relocs (Filedata * filedata,
1005 unsigned long rel_offset,
1006 unsigned long rel_size,
1007 Elf_Internal_Rela ** relsp,
1008 unsigned long * nrelsp)
1009{
1010 Elf_Internal_Rela * rels;
1011 size_t nrels;
1012 unsigned int i;
1013
1014 if (is_32bit_elf)
1015 {
1016 Elf32_External_Rel * erels;
1017
1018 erels = (Elf32_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1019 rel_size, _("32-bit relocation data"));
1020 if (!erels)
1021 return FALSE;
1022
1023 nrels = rel_size / sizeof (Elf32_External_Rel);
1024
1025 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1026
1027 if (rels == NULL)
1028 {
1029 free (erels);
1030 error (_("out of memory parsing relocs\n"));
1031 return FALSE;
1032 }
1033
1034 for (i = 0; i < nrels; i++)
1035 {
1036 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1037 rels[i].r_info = BYTE_GET (erels[i].r_info);
1038 rels[i].r_addend = 0;
1039 }
1040
1041 free (erels);
1042 }
1043 else
1044 {
1045 Elf64_External_Rel * erels;
1046
1047 erels = (Elf64_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1048 rel_size, _("64-bit relocation data"));
1049 if (!erels)
1050 return FALSE;
1051
1052 nrels = rel_size / sizeof (Elf64_External_Rel);
1053
1054 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1055
1056 if (rels == NULL)
1057 {
1058 free (erels);
1059 error (_("out of memory parsing relocs\n"));
1060 return FALSE;
1061 }
1062
1063 for (i = 0; i < nrels; i++)
1064 {
1065 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1066 rels[i].r_info = BYTE_GET (erels[i].r_info);
1067 rels[i].r_addend = 0;
1068
1069 /* The #ifdef BFD64 below is to prevent a compile time
1070 warning. We know that if we do not have a 64 bit data
1071 type that we will never execute this code anyway. */
1072#ifdef BFD64
1073 if (filedata->file_header.e_machine == EM_MIPS
1074 && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
1075 {
1076 /* In little-endian objects, r_info isn't really a
1077 64-bit little-endian value: it has a 32-bit
1078 little-endian symbol index followed by four
1079 individual byte fields. Reorder INFO
1080 accordingly. */
1081 bfd_vma inf = rels[i].r_info;
1082 inf = (((inf & 0xffffffff) << 32)
1083 | ((inf >> 56) & 0xff)
1084 | ((inf >> 40) & 0xff00)
1085 | ((inf >> 24) & 0xff0000)
1086 | ((inf >> 8) & 0xff000000));
1087 rels[i].r_info = inf;
1088 }
1089#endif /* BFD64 */
1090 }
1091
1092 free (erels);
1093 }
1094
1095 *relsp = rels;
1096 *nrelsp = nrels;
1097 return TRUE;
1098}
1099
1100/* Returns the reloc type extracted from the reloc info field. */
1101
1102static unsigned int
1103get_reloc_type (Filedata * filedata, bfd_vma reloc_info)
1104{
1105 if (is_32bit_elf)
1106 return ELF32_R_TYPE (reloc_info);
1107
1108 switch (filedata->file_header.e_machine)
1109 {
1110 case EM_MIPS:
1111 /* Note: We assume that reloc_info has already been adjusted for us. */
1112 return ELF64_MIPS_R_TYPE (reloc_info);
1113
1114 case EM_SPARCV9:
1115 return ELF64_R_TYPE_ID (reloc_info);
1116
1117 default:
1118 return ELF64_R_TYPE (reloc_info);
1119 }
1120}
1121
1122/* Return the symbol index extracted from the reloc info field. */
1123
1124static bfd_vma
1125get_reloc_symindex (bfd_vma reloc_info)
1126{
1127 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1128}
1129
1130static inline bfd_boolean
1131uses_msp430x_relocs (Filedata * filedata)
1132{
1133 return
1134 filedata->file_header.e_machine == EM_MSP430 /* Paranoia. */
1135 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1136 && (((filedata->file_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1137 /* TI compiler uses ELFOSABI_NONE. */
1138 || (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1139}
1140
1141/* Display the contents of the relocation data found at the specified
1142 offset. */
1143
1144static bfd_boolean
1145dump_relocations (Filedata * filedata,
1146 unsigned long rel_offset,
1147 unsigned long rel_size,
1148 Elf_Internal_Sym * symtab,
1149 unsigned long nsyms,
1150 char * strtab,
1151 unsigned long strtablen,
1152 int is_rela,
1153 bfd_boolean is_dynsym)
1154{
1155 unsigned long i;
1156 Elf_Internal_Rela * rels;
1157 bfd_boolean res = TRUE;
1158
1159 if (is_rela == UNKNOWN)
1160 is_rela = guess_is_rela (filedata->file_header.e_machine);
1161
1162 if (is_rela)
1163 {
1164 if (!slurp_rela_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1165 return FALSE;
1166 }
1167 else
1168 {
1169 if (!slurp_rel_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1170 return FALSE;
1171 }
1172
1173 if (is_32bit_elf)
1174 {
1175 if (is_rela)
1176 {
1177 if (do_wide)
1178 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1179 else
1180 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1181 }
1182 else
1183 {
1184 if (do_wide)
1185 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1186 else
1187 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1188 }
1189 }
1190 else
1191 {
1192 if (is_rela)
1193 {
1194 if (do_wide)
1195 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1196 else
1197 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1198 }
1199 else
1200 {
1201 if (do_wide)
1202 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1203 else
1204 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1205 }
1206 }
1207
1208 for (i = 0; i < rel_size; i++)
1209 {
1210 const char * rtype;
1211 bfd_vma offset;
1212 bfd_vma inf;
1213 bfd_vma symtab_index;
1214 bfd_vma type;
1215
1216 offset = rels[i].r_offset;
1217 inf = rels[i].r_info;
1218
1219 type = get_reloc_type (filedata, inf);
1220 symtab_index = get_reloc_symindex (inf);
1221
1222 if (is_32bit_elf)
1223 {
1224 printf ("%8.8lx %8.8lx ",
1225 (unsigned long) offset & 0xffffffff,
1226 (unsigned long) inf & 0xffffffff);
1227 }
1228 else
1229 {
1230#if BFD_HOST_64BIT_LONG
1231 printf (do_wide
1232 ? "%16.16lx %16.16lx "
1233 : "%12.12lx %12.12lx ",
1234 offset, inf);
1235#elif BFD_HOST_64BIT_LONG_LONG
1236#ifndef __MSVCRT__
1237 printf (do_wide
1238 ? "%16.16llx %16.16llx "
1239 : "%12.12llx %12.12llx ",
1240 offset, inf);
1241#else
1242 printf (do_wide
1243 ? "%16.16I64x %16.16I64x "
1244 : "%12.12I64x %12.12I64x ",
1245 offset, inf);
1246#endif
1247#else
1248 printf (do_wide
1249 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1250 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1251 _bfd_int64_high (offset),
1252 _bfd_int64_low (offset),
1253 _bfd_int64_high (inf),
1254 _bfd_int64_low (inf));
1255#endif
1256 }
1257
1258 switch (filedata->file_header.e_machine)
1259 {
1260 default:
1261 rtype = NULL;
1262 break;
1263
1264 case EM_AARCH64:
1265 rtype = elf_aarch64_reloc_type (type);
1266 break;
1267
1268 case EM_M32R:
1269 case EM_CYGNUS_M32R:
1270 rtype = elf_m32r_reloc_type (type);
1271 break;
1272
1273 case EM_386:
1274 case EM_IAMCU:
1275 rtype = elf_i386_reloc_type (type);
1276 break;
1277
1278 case EM_68HC11:
1279 case EM_68HC12:
1280 rtype = elf_m68hc11_reloc_type (type);
1281 break;
1282
1283 case EM_S12Z:
1284 rtype = elf_s12z_reloc_type (type);
1285 break;
1286
1287 case EM_68K:
1288 rtype = elf_m68k_reloc_type (type);
1289 break;
1290
1291 case EM_960:
1292 rtype = elf_i960_reloc_type (type);
1293 break;
1294
1295 case EM_AVR:
1296 case EM_AVR_OLD:
1297 rtype = elf_avr_reloc_type (type);
1298 break;
1299
1300 case EM_OLD_SPARCV9:
1301 case EM_SPARC32PLUS:
1302 case EM_SPARCV9:
1303 case EM_SPARC:
1304 rtype = elf_sparc_reloc_type (type);
1305 break;
1306
1307 case EM_SPU:
1308 rtype = elf_spu_reloc_type (type);
1309 break;
1310
1311 case EM_V800:
1312 rtype = v800_reloc_type (type);
1313 break;
1314 case EM_V850:
1315 case EM_CYGNUS_V850:
1316 rtype = v850_reloc_type (type);
1317 break;
1318
1319 case EM_D10V:
1320 case EM_CYGNUS_D10V:
1321 rtype = elf_d10v_reloc_type (type);
1322 break;
1323
1324 case EM_D30V:
1325 case EM_CYGNUS_D30V:
1326 rtype = elf_d30v_reloc_type (type);
1327 break;
1328
1329 case EM_DLX:
1330 rtype = elf_dlx_reloc_type (type);
1331 break;
1332
1333 case EM_SH:
1334 rtype = elf_sh_reloc_type (type);
1335 break;
1336
1337 case EM_MN10300:
1338 case EM_CYGNUS_MN10300:
1339 rtype = elf_mn10300_reloc_type (type);
1340 break;
1341
1342 case EM_MN10200:
1343 case EM_CYGNUS_MN10200:
1344 rtype = elf_mn10200_reloc_type (type);
1345 break;
1346
1347 case EM_FR30:
1348 case EM_CYGNUS_FR30:
1349 rtype = elf_fr30_reloc_type (type);
1350 break;
1351
1352 case EM_CYGNUS_FRV:
1353 rtype = elf_frv_reloc_type (type);
1354 break;
1355
1356 case EM_CSKY:
1357 rtype = elf_csky_reloc_type (type);
1358 break;
1359
1360 case EM_FT32:
1361 rtype = elf_ft32_reloc_type (type);
1362 break;
1363
1364 case EM_MCORE:
1365 rtype = elf_mcore_reloc_type (type);
1366 break;
1367
1368 case EM_MMIX:
1369 rtype = elf_mmix_reloc_type (type);
1370 break;
1371
1372 case EM_MOXIE:
1373 rtype = elf_moxie_reloc_type (type);
1374 break;
1375
1376 case EM_MSP430:
1377 if (uses_msp430x_relocs (filedata))
1378 {
1379 rtype = elf_msp430x_reloc_type (type);
1380 break;
1381 }
1382 /* Fall through. */
1383 case EM_MSP430_OLD:
1384 rtype = elf_msp430_reloc_type (type);
1385 break;
1386
1387 case EM_NDS32:
1388 rtype = elf_nds32_reloc_type (type);
1389 break;
1390
1391 case EM_PPC:
1392 rtype = elf_ppc_reloc_type (type);
1393 break;
1394
1395 case EM_PPC64:
1396 rtype = elf_ppc64_reloc_type (type);
1397 break;
1398
1399 case EM_MIPS:
1400 case EM_MIPS_RS3_LE:
1401 rtype = elf_mips_reloc_type (type);
1402 break;
1403
1404 case EM_RISCV:
1405 rtype = elf_riscv_reloc_type (type);
1406 break;
1407
1408 case EM_ALPHA:
1409 rtype = elf_alpha_reloc_type (type);
1410 break;
1411
1412 case EM_ARM:
1413 rtype = elf_arm_reloc_type (type);
1414 break;
1415
1416 case EM_ARC:
1417 case EM_ARC_COMPACT:
1418 case EM_ARC_COMPACT2:
1419 rtype = elf_arc_reloc_type (type);
1420 break;
1421
1422 case EM_PARISC:
1423 rtype = elf_hppa_reloc_type (type);
1424 break;
1425
1426 case EM_H8_300:
1427 case EM_H8_300H:
1428 case EM_H8S:
1429 rtype = elf_h8_reloc_type (type);
1430 break;
1431
1432 case EM_OR1K:
1433 rtype = elf_or1k_reloc_type (type);
1434 break;
1435
1436 case EM_PJ:
1437 case EM_PJ_OLD:
1438 rtype = elf_pj_reloc_type (type);
1439 break;
1440 case EM_IA_64:
1441 rtype = elf_ia64_reloc_type (type);
1442 break;
1443
1444 case EM_CRIS:
1445 rtype = elf_cris_reloc_type (type);
1446 break;
1447
1448 case EM_860:
1449 rtype = elf_i860_reloc_type (type);
1450 break;
1451
1452 case EM_X86_64:
1453 case EM_L1OM:
1454 case EM_K1OM:
1455 rtype = elf_x86_64_reloc_type (type);
1456 break;
1457
1458 case EM_S370:
1459 rtype = i370_reloc_type (type);
1460 break;
1461
1462 case EM_S390_OLD:
1463 case EM_S390:
1464 rtype = elf_s390_reloc_type (type);
1465 break;
1466
1467 case EM_SCORE:
1468 rtype = elf_score_reloc_type (type);
1469 break;
1470
1471 case EM_XSTORMY16:
1472 rtype = elf_xstormy16_reloc_type (type);
1473 break;
1474
1475 case EM_CRX:
1476 rtype = elf_crx_reloc_type (type);
1477 break;
1478
1479 case EM_VAX:
1480 rtype = elf_vax_reloc_type (type);
1481 break;
1482
1483 case EM_VISIUM:
1484 rtype = elf_visium_reloc_type (type);
1485 break;
1486
1487 case EM_BPF:
1488 rtype = elf_bpf_reloc_type (type);
1489 break;
1490
1491 case EM_ADAPTEVA_EPIPHANY:
1492 rtype = elf_epiphany_reloc_type (type);
1493 break;
1494
1495 case EM_IP2K:
1496 case EM_IP2K_OLD:
1497 rtype = elf_ip2k_reloc_type (type);
1498 break;
1499
1500 case EM_IQ2000:
1501 rtype = elf_iq2000_reloc_type (type);
1502 break;
1503
1504 case EM_XTENSA_OLD:
1505 case EM_XTENSA:
1506 rtype = elf_xtensa_reloc_type (type);
1507 break;
1508
1509 case EM_LATTICEMICO32:
1510 rtype = elf_lm32_reloc_type (type);
1511 break;
1512
1513 case EM_M32C_OLD:
1514 case EM_M32C:
1515 rtype = elf_m32c_reloc_type (type);
1516 break;
1517
1518 case EM_MT:
1519 rtype = elf_mt_reloc_type (type);
1520 break;
1521
1522 case EM_BLACKFIN:
1523 rtype = elf_bfin_reloc_type (type);
1524 break;
1525
1526 case EM_CYGNUS_MEP:
1527 rtype = elf_mep_reloc_type (type);
1528 break;
1529
1530 case EM_CR16:
1531 rtype = elf_cr16_reloc_type (type);
1532 break;
1533
1534 case EM_MICROBLAZE:
1535 case EM_MICROBLAZE_OLD:
1536 rtype = elf_microblaze_reloc_type (type);
1537 break;
1538
1539 case EM_RL78:
1540 rtype = elf_rl78_reloc_type (type);
1541 break;
1542
1543 case EM_RX:
1544 rtype = elf_rx_reloc_type (type);
1545 break;
1546
1547 case EM_METAG:
1548 rtype = elf_metag_reloc_type (type);
1549 break;
1550
1551 case EM_XC16X:
1552 case EM_C166:
1553 rtype = elf_xc16x_reloc_type (type);
1554 break;
1555
1556 case EM_TI_C6000:
1557 rtype = elf_tic6x_reloc_type (type);
1558 break;
1559
1560 case EM_TILEGX:
1561 rtype = elf_tilegx_reloc_type (type);
1562 break;
1563
1564 case EM_TILEPRO:
1565 rtype = elf_tilepro_reloc_type (type);
1566 break;
1567
1568 case EM_WEBASSEMBLY:
1569 rtype = elf_wasm32_reloc_type (type);
1570 break;
1571
1572 case EM_XGATE:
1573 rtype = elf_xgate_reloc_type (type);
1574 break;
1575
1576 case EM_ALTERA_NIOS2:
1577 rtype = elf_nios2_reloc_type (type);
1578 break;
1579
1580 case EM_TI_PRU:
1581 rtype = elf_pru_reloc_type (type);
1582 break;
1583
1584 case EM_NFP:
1585 if (EF_NFP_MACH (filedata->file_header.e_flags) == E_NFP_MACH_3200)
1586 rtype = elf_nfp3200_reloc_type (type);
1587 else
1588 rtype = elf_nfp_reloc_type (type);
1589 break;
1590
1591 case EM_Z80:
1592 rtype = elf_z80_reloc_type (type);
1593 break;
1594 }
1595
1596 if (rtype == NULL)
1597 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1598 else
1599 printf (do_wide ? "%-22s" : "%-17.17s", rtype);
1600
1601 if (filedata->file_header.e_machine == EM_ALPHA
1602 && rtype != NULL
1603 && streq (rtype, "R_ALPHA_LITUSE")
1604 && is_rela)
1605 {
1606 switch (rels[i].r_addend)
1607 {
1608 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1609 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1610 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1611 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1612 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1613 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1614 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1615 default: rtype = NULL;
1616 }
1617
1618 if (rtype)
1619 printf (" (%s)", rtype);
1620 else
1621 {
1622 putchar (' ');
1623 printf (_("<unknown addend: %lx>"),
1624 (unsigned long) rels[i].r_addend);
1625 res = FALSE;
1626 }
1627 }
1628 else if (symtab_index)
1629 {
1630 if (symtab == NULL || symtab_index >= nsyms)
1631 {
1632 error (_(" bad symbol index: %08lx in reloc\n"),
1633 (unsigned long) symtab_index);
1634 res = FALSE;
1635 }
1636 else
1637 {
1638 Elf_Internal_Sym * psym;
1639 const char * version_string;
1640 enum versioned_symbol_info sym_info;
1641 unsigned short vna_other;
1642
1643 psym = symtab + symtab_index;
1644
1645 version_string
1646 = get_symbol_version_string (filedata, is_dynsym,
1647 strtab, strtablen,
1648 symtab_index,
1649 psym,
1650 &sym_info,
1651 &vna_other);
1652
1653 printf (" ");
1654
1655 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1656 {
1657 const char * name;
1658 unsigned int len;
1659 unsigned int width = is_32bit_elf ? 8 : 14;
1660
1661 /* Relocations against GNU_IFUNC symbols do not use the value
1662 of the symbol as the address to relocate against. Instead
1663 they invoke the function named by the symbol and use its
1664 result as the address for relocation.
1665
1666 To indicate this to the user, do not display the value of
1667 the symbol in the "Symbols's Value" field. Instead show
1668 its name followed by () as a hint that the symbol is
1669 invoked. */
1670
1671 if (strtab == NULL
1672 || psym->st_name == 0
1673 || psym->st_name >= strtablen)
1674 name = "??";
1675 else
1676 name = strtab + psym->st_name;
1677
1678 len = print_symbol (width, name);
1679 if (version_string)
1680 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1681 version_string);
1682 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1683 }
1684 else
1685 {
1686 print_vma (psym->st_value, LONG_HEX);
1687
1688 printf (is_32bit_elf ? " " : " ");
1689 }
1690
1691 if (psym->st_name == 0)
1692 {
1693 const char * sec_name = "<null>";
1694 char name_buf[40];
1695
1696 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1697 {
1698 if (psym->st_shndx < filedata->file_header.e_shnum)
1699 sec_name = SECTION_NAME (filedata->section_headers + psym->st_shndx);
1700 else if (psym->st_shndx == SHN_ABS)
1701 sec_name = "ABS";
1702 else if (psym->st_shndx == SHN_COMMON)
1703 sec_name = "COMMON";
1704 else if ((filedata->file_header.e_machine == EM_MIPS
1705 && psym->st_shndx == SHN_MIPS_SCOMMON)
1706 || (filedata->file_header.e_machine == EM_TI_C6000
1707 && psym->st_shndx == SHN_TIC6X_SCOMMON))
1708 sec_name = "SCOMMON";
1709 else if (filedata->file_header.e_machine == EM_MIPS
1710 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1711 sec_name = "SUNDEF";
1712 else if ((filedata->file_header.e_machine == EM_X86_64
1713 || filedata->file_header.e_machine == EM_L1OM
1714 || filedata->file_header.e_machine == EM_K1OM)
1715 && psym->st_shndx == SHN_X86_64_LCOMMON)
1716 sec_name = "LARGE_COMMON";
1717 else if (filedata->file_header.e_machine == EM_IA_64
1718 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1719 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1720 sec_name = "ANSI_COM";
1721 else if (is_ia64_vms (filedata)
1722 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1723 sec_name = "VMS_SYMVEC";
1724 else
1725 {
1726 sprintf (name_buf, "<section 0x%x>",
1727 (unsigned int) psym->st_shndx);
1728 sec_name = name_buf;
1729 }
1730 }
1731 print_symbol (22, sec_name);
1732 }
1733 else if (strtab == NULL)
1734 printf (_("<string table index: %3ld>"), psym->st_name);
1735 else if (psym->st_name >= strtablen)
1736 {
1737 error (_("<corrupt string table index: %3ld>\n"),
1738 psym->st_name);
1739 res = FALSE;
1740 }
1741 else
1742 {
1743 print_symbol (22, strtab + psym->st_name);
1744 if (version_string)
1745 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1746 version_string);
1747 }
1748
1749 if (is_rela)
1750 {
1751 bfd_vma off = rels[i].r_addend;
1752
1753 if ((bfd_signed_vma) off < 0)
1754 printf (" - %" BFD_VMA_FMT "x", - off);
1755 else
1756 printf (" + %" BFD_VMA_FMT "x", off);
1757 }
1758 }
1759 }
1760 else if (is_rela)
1761 {
1762 bfd_vma off = rels[i].r_addend;
1763
1764 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1765 if ((bfd_signed_vma) off < 0)
1766 printf ("-%" BFD_VMA_FMT "x", - off);
1767 else
1768 printf ("%" BFD_VMA_FMT "x", off);
1769 }
1770
1771 if (filedata->file_header.e_machine == EM_SPARCV9
1772 && rtype != NULL
1773 && streq (rtype, "R_SPARC_OLO10"))
1774 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1775
1776 putchar ('\n');
1777
1778#ifdef BFD64
1779 if (! is_32bit_elf && filedata->file_header.e_machine == EM_MIPS)
1780 {
1781 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1782 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1783 const char * rtype2 = elf_mips_reloc_type (type2);
1784 const char * rtype3 = elf_mips_reloc_type (type3);
1785
1786 printf (" Type2: ");
1787
1788 if (rtype2 == NULL)
1789 printf (_("unrecognized: %-7lx"),
1790 (unsigned long) type2 & 0xffffffff);
1791 else
1792 printf ("%-17.17s", rtype2);
1793
1794 printf ("\n Type3: ");
1795
1796 if (rtype3 == NULL)
1797 printf (_("unrecognized: %-7lx"),
1798 (unsigned long) type3 & 0xffffffff);
1799 else
1800 printf ("%-17.17s", rtype3);
1801
1802 putchar ('\n');
1803 }
1804#endif /* BFD64 */
1805 }
1806
1807 free (rels);
1808
1809 return res;
1810}
1811
1812static const char *
1813get_aarch64_dynamic_type (unsigned long type)
1814{
1815 switch (type)
1816 {
1817 case DT_AARCH64_BTI_PLT: return "AARCH64_BTI_PLT";
1818 case DT_AARCH64_PAC_PLT: return "AARCH64_PAC_PLT";
1819 case DT_AARCH64_VARIANT_PCS: return "AARCH64_VARIANT_PCS";
1820 default:
1821 return NULL;
1822 }
1823}
1824
1825static const char *
1826get_mips_dynamic_type (unsigned long type)
1827{
1828 switch (type)
1829 {
1830 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1831 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1832 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1833 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1834 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1835 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1836 case DT_MIPS_MSYM: return "MIPS_MSYM";
1837 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1838 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1839 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1840 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1841 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1842 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1843 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1844 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1845 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1846 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1847 case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
1848 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1849 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1850 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1851 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1852 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1853 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1854 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1855 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1856 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1857 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1858 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1859 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1860 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1861 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1862 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1863 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1864 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1865 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1866 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1867 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1868 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1869 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1870 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1871 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1872 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1873 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1874 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1875 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1876 case DT_MIPS_XHASH: return "MIPS_XHASH";
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 break;
3762
3763 case EM_Z80:
3764 switch (e_flags & EF_Z80_MACH_MSK)
3765 {
3766 case EF_Z80_MACH_Z80: strcat (buf, ", Z80"); break;
3767 case EF_Z80_MACH_Z180: strcat (buf, ", Z180"); break;
3768 case EF_Z80_MACH_R800: strcat (buf, ", R800"); break;
3769 case EF_Z80_MACH_EZ80_Z80: strcat (buf, ", EZ80"); break;
3770 case EF_Z80_MACH_EZ80_ADL: strcat (buf, ", EZ80, ADL"); break;
3771 case EF_Z80_MACH_GBZ80: strcat (buf, ", GBZ80"); break;
3772 case EF_Z80_MACH_Z80N: strcat (buf, ", Z80N"); break;
3773 default:
3774 strcat (buf, _(", unknown")); break;
3775 }
3776 break;
3777 }
3778 }
3779
3780 return buf;
3781}
3782
3783static const char *
3784get_osabi_name (Filedata * filedata, unsigned int osabi)
3785{
3786 static char buff[32];
3787
3788 switch (osabi)
3789 {
3790 case ELFOSABI_NONE: return "UNIX - System V";
3791 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3792 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
3793 case ELFOSABI_GNU: return "UNIX - GNU";
3794 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3795 case ELFOSABI_AIX: return "UNIX - AIX";
3796 case ELFOSABI_IRIX: return "UNIX - IRIX";
3797 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3798 case ELFOSABI_TRU64: return "UNIX - TRU64";
3799 case ELFOSABI_MODESTO: return "Novell - Modesto";
3800 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3801 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3802 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3803 case ELFOSABI_AROS: return "AROS";
3804 case ELFOSABI_FENIXOS: return "FenixOS";
3805 case ELFOSABI_CLOUDABI: return "Nuxi CloudABI";
3806 case ELFOSABI_OPENVOS: return "Stratus Technologies OpenVOS";
3807 default:
3808 if (osabi >= 64)
3809 switch (filedata->file_header.e_machine)
3810 {
3811 case EM_ARM:
3812 switch (osabi)
3813 {
3814 case ELFOSABI_ARM: return "ARM";
3815 case ELFOSABI_ARM_FDPIC: return "ARM FDPIC";
3816 default:
3817 break;
3818 }
3819 break;
3820
3821 case EM_MSP430:
3822 case EM_MSP430_OLD:
3823 case EM_VISIUM:
3824 switch (osabi)
3825 {
3826 case ELFOSABI_STANDALONE: return _("Standalone App");
3827 default:
3828 break;
3829 }
3830 break;
3831
3832 case EM_TI_C6000:
3833 switch (osabi)
3834 {
3835 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3836 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3837 default:
3838 break;
3839 }
3840 break;
3841
3842 default:
3843 break;
3844 }
3845 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3846 return buff;
3847 }
3848}
3849
3850static const char *
3851get_aarch64_segment_type (unsigned long type)
3852{
3853 switch (type)
3854 {
3855 case PT_AARCH64_ARCHEXT: return "AARCH64_ARCHEXT";
3856 default: return NULL;
3857 }
3858}
3859
3860static const char *
3861get_arm_segment_type (unsigned long type)
3862{
3863 switch (type)
3864 {
3865 case PT_ARM_EXIDX: return "EXIDX";
3866 default: return NULL;
3867 }
3868}
3869
3870static const char *
3871get_s390_segment_type (unsigned long type)
3872{
3873 switch (type)
3874 {
3875 case PT_S390_PGSTE: return "S390_PGSTE";
3876 default: return NULL;
3877 }
3878}
3879
3880static const char *
3881get_mips_segment_type (unsigned long type)
3882{
3883 switch (type)
3884 {
3885 case PT_MIPS_REGINFO: return "REGINFO";
3886 case PT_MIPS_RTPROC: return "RTPROC";
3887 case PT_MIPS_OPTIONS: return "OPTIONS";
3888 case PT_MIPS_ABIFLAGS: return "ABIFLAGS";
3889 default: return NULL;
3890 }
3891}
3892
3893static const char *
3894get_parisc_segment_type (unsigned long type)
3895{
3896 switch (type)
3897 {
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 default: return NULL;
3913 }
3914}
3915
3916static const char *
3917get_tic6x_segment_type (unsigned long type)
3918{
3919 switch (type)
3920 {
3921 case PT_C6000_PHATTR: return "C6000_PHATTR";
3922 default: return NULL;
3923 }
3924}
3925
3926static const char *
3927get_hpux_segment_type (unsigned long type, unsigned e_machine)
3928{
3929 if (e_machine == EM_PARISC)
3930 switch (type)
3931 {
3932 case PT_HP_TLS: return "HP_TLS";
3933 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3934 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3935 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3936 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3937 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3938 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3939 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3940 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3941 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3942 case PT_HP_PARALLEL: return "HP_PARALLEL";
3943 case PT_HP_FASTBIND: return "HP_FASTBIND";
3944 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3945 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3946 case PT_HP_STACK: return "HP_STACK";
3947 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
3948 default: return NULL;
3949 }
3950
3951 if (e_machine == EM_IA_64)
3952 switch (type)
3953 {
3954 case PT_HP_TLS: return "HP_TLS";
3955 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3956 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3957 case PT_IA_64_HP_STACK: return "HP_STACK";
3958 default: return NULL;
3959 }
3960
3961 return NULL;
3962}
3963
3964static const char *
3965get_solaris_segment_type (unsigned long type)
3966{
3967 switch (type)
3968 {
3969 case 0x6464e550: return "PT_SUNW_UNWIND";
3970 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3971 case 0x6ffffff7: return "PT_LOSUNW";
3972 case 0x6ffffffa: return "PT_SUNWBSS";
3973 case 0x6ffffffb: return "PT_SUNWSTACK";
3974 case 0x6ffffffc: return "PT_SUNWDTRACE";
3975 case 0x6ffffffd: return "PT_SUNWCAP";
3976 case 0x6fffffff: return "PT_HISUNW";
3977 default: return NULL;
3978 }
3979}
3980
3981static const char *
3982get_segment_type (Filedata * filedata, unsigned long p_type)
3983{
3984 static char buff[32];
3985
3986 switch (p_type)
3987 {
3988 case PT_NULL: return "NULL";
3989 case PT_LOAD: return "LOAD";
3990 case PT_DYNAMIC: return "DYNAMIC";
3991 case PT_INTERP: return "INTERP";
3992 case PT_NOTE: return "NOTE";
3993 case PT_SHLIB: return "SHLIB";
3994 case PT_PHDR: return "PHDR";
3995 case PT_TLS: return "TLS";
3996 case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
3997 case PT_GNU_STACK: return "GNU_STACK";
3998 case PT_GNU_RELRO: return "GNU_RELRO";
3999 case PT_GNU_PROPERTY: return "GNU_PROPERTY";
4000
4001 default:
4002 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
4003 {
4004 const char * result;
4005
4006 switch (filedata->file_header.e_machine)
4007 {
4008 case EM_AARCH64:
4009 result = get_aarch64_segment_type (p_type);
4010 break;
4011 case EM_ARM:
4012 result = get_arm_segment_type (p_type);
4013 break;
4014 case EM_MIPS:
4015 case EM_MIPS_RS3_LE:
4016 result = get_mips_segment_type (p_type);
4017 break;
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 case EM_TI_C6000:
4025 result = get_tic6x_segment_type (p_type);
4026 break;
4027 case EM_S390:
4028 case EM_S390_OLD:
4029 result = get_s390_segment_type (p_type);
4030 break;
4031 default:
4032 result = NULL;
4033 break;
4034 }
4035
4036 if (result != NULL)
4037 return result;
4038
4039 sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
4040 }
4041 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
4042 {
4043 const char * result = NULL;
4044
4045 switch (filedata->file_header.e_ident[EI_OSABI])
4046 {
4047 case ELFOSABI_GNU:
4048 case ELFOSABI_FREEBSD:
4049 if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
4050 {
4051 sprintf (buff, "GNU_MBIND+%#lx", p_type - PT_GNU_MBIND_LO);
4052 result = buff;
4053 }
4054 break;
4055 case ELFOSABI_HPUX:
4056 result = get_hpux_segment_type (p_type,
4057 filedata->file_header.e_machine);
4058 break;
4059 case ELFOSABI_SOLARIS:
4060 result = get_solaris_segment_type (p_type);
4061 break;
4062 default:
4063 break;
4064 }
4065 if (result != NULL)
4066 return result;
4067
4068 sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
4069 }
4070 else
4071 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
4072
4073 return buff;
4074 }
4075}
4076
4077static const char *
4078get_arc_section_type_name (unsigned int sh_type)
4079{
4080 switch (sh_type)
4081 {
4082 case SHT_ARC_ATTRIBUTES: return "ARC_ATTRIBUTES";
4083 default:
4084 break;
4085 }
4086 return NULL;
4087}
4088
4089static const char *
4090get_mips_section_type_name (unsigned int sh_type)
4091{
4092 switch (sh_type)
4093 {
4094 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
4095 case SHT_MIPS_MSYM: return "MIPS_MSYM";
4096 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
4097 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
4098 case SHT_MIPS_UCODE: return "MIPS_UCODE";
4099 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
4100 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
4101 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
4102 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
4103 case SHT_MIPS_RELD: return "MIPS_RELD";
4104 case SHT_MIPS_IFACE: return "MIPS_IFACE";
4105 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
4106 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
4107 case SHT_MIPS_SHDR: return "MIPS_SHDR";
4108 case SHT_MIPS_FDESC: return "MIPS_FDESC";
4109 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
4110 case SHT_MIPS_DENSE: return "MIPS_DENSE";
4111 case SHT_MIPS_PDESC: return "MIPS_PDESC";
4112 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
4113 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
4114 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
4115 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
4116 case SHT_MIPS_LINE: return "MIPS_LINE";
4117 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
4118 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
4119 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
4120 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
4121 case SHT_MIPS_DWARF: return "MIPS_DWARF";
4122 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
4123 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
4124 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
4125 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
4126 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
4127 case SHT_MIPS_XLATE: return "MIPS_XLATE";
4128 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
4129 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
4130 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
4131 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
4132 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
4133 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
4134 case SHT_MIPS_XHASH: return "MIPS_XHASH";
4135 default:
4136 break;
4137 }
4138 return NULL;
4139}
4140
4141static const char *
4142get_parisc_section_type_name (unsigned int sh_type)
4143{
4144 switch (sh_type)
4145 {
4146 case SHT_PARISC_EXT: return "PARISC_EXT";
4147 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
4148 case SHT_PARISC_DOC: return "PARISC_DOC";
4149 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
4150 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
4151 case SHT_PARISC_STUBS: return "PARISC_STUBS";
4152 case SHT_PARISC_DLKM: return "PARISC_DLKM";
4153 default: return NULL;
4154 }
4155}
4156
4157static const char *
4158get_ia64_section_type_name (Filedata * filedata, unsigned int sh_type)
4159{
4160 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4161 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
4162 return get_osabi_name (filedata, (sh_type & 0x00FF0000) >> 16);
4163
4164 switch (sh_type)
4165 {
4166 case SHT_IA_64_EXT: return "IA_64_EXT";
4167 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
4168 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
4169 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
4170 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
4171 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
4172 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
4173 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
4174 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
4175 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4176 default:
4177 break;
4178 }
4179 return NULL;
4180}
4181
4182static const char *
4183get_x86_64_section_type_name (unsigned int sh_type)
4184{
4185 switch (sh_type)
4186 {
4187 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
4188 default: return NULL;
4189 }
4190}
4191
4192static const char *
4193get_aarch64_section_type_name (unsigned int sh_type)
4194{
4195 switch (sh_type)
4196 {
4197 case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4198 default: return NULL;
4199 }
4200}
4201
4202static const char *
4203get_arm_section_type_name (unsigned int sh_type)
4204{
4205 switch (sh_type)
4206 {
4207 case SHT_ARM_EXIDX: return "ARM_EXIDX";
4208 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
4209 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
4210 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
4211 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
4212 default: return NULL;
4213 }
4214}
4215
4216static const char *
4217get_tic6x_section_type_name (unsigned int sh_type)
4218{
4219 switch (sh_type)
4220 {
4221 case SHT_C6000_UNWIND: return "C6000_UNWIND";
4222 case SHT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
4223 case SHT_C6000_ATTRIBUTES: return "C6000_ATTRIBUTES";
4224 case SHT_TI_ICODE: return "TI_ICODE";
4225 case SHT_TI_XREF: return "TI_XREF";
4226 case SHT_TI_HANDLER: return "TI_HANDLER";
4227 case SHT_TI_INITINFO: return "TI_INITINFO";
4228 case SHT_TI_PHATTRS: return "TI_PHATTRS";
4229 default: return NULL;
4230 }
4231}
4232
4233static const char *
4234get_msp430x_section_type_name (unsigned int sh_type)
4235{
4236 switch (sh_type)
4237 {
4238 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
4239 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
4240 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
4241 default: return NULL;
4242 }
4243}
4244
4245static const char *
4246get_nfp_section_type_name (unsigned int sh_type)
4247{
4248 switch (sh_type)
4249 {
4250 case SHT_NFP_MECONFIG: return "NFP_MECONFIG";
4251 case SHT_NFP_INITREG: return "NFP_INITREG";
4252 case SHT_NFP_UDEBUG: return "NFP_UDEBUG";
4253 default: return NULL;
4254 }
4255}
4256
4257static const char *
4258get_v850_section_type_name (unsigned int sh_type)
4259{
4260 switch (sh_type)
4261 {
4262 case SHT_V850_SCOMMON: return "V850 Small Common";
4263 case SHT_V850_TCOMMON: return "V850 Tiny Common";
4264 case SHT_V850_ZCOMMON: return "V850 Zero Common";
4265 case SHT_RENESAS_IOP: return "RENESAS IOP";
4266 case SHT_RENESAS_INFO: return "RENESAS INFO";
4267 default: return NULL;
4268 }
4269}
4270
4271static const char *
4272get_riscv_section_type_name (unsigned int sh_type)
4273{
4274 switch (sh_type)
4275 {
4276 case SHT_RISCV_ATTRIBUTES: return "RISCV_ATTRIBUTES";
4277 default: return NULL;
4278 }
4279}
4280
4281static const char *
4282get_section_type_name (Filedata * filedata, unsigned int sh_type)
4283{
4284 static char buff[32];
4285 const char * result;
4286
4287 switch (sh_type)
4288 {
4289 case SHT_NULL: return "NULL";
4290 case SHT_PROGBITS: return "PROGBITS";
4291 case SHT_SYMTAB: return "SYMTAB";
4292 case SHT_STRTAB: return "STRTAB";
4293 case SHT_RELA: return "RELA";
4294 case SHT_HASH: return "HASH";
4295 case SHT_DYNAMIC: return "DYNAMIC";
4296 case SHT_NOTE: return "NOTE";
4297 case SHT_NOBITS: return "NOBITS";
4298 case SHT_REL: return "REL";
4299 case SHT_SHLIB: return "SHLIB";
4300 case SHT_DYNSYM: return "DYNSYM";
4301 case SHT_INIT_ARRAY: return "INIT_ARRAY";
4302 case SHT_FINI_ARRAY: return "FINI_ARRAY";
4303 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
4304 case SHT_GNU_HASH: return "GNU_HASH";
4305 case SHT_GROUP: return "GROUP";
4306 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICES";
4307 case SHT_GNU_verdef: return "VERDEF";
4308 case SHT_GNU_verneed: return "VERNEED";
4309 case SHT_GNU_versym: return "VERSYM";
4310 case 0x6ffffff0: return "VERSYM";
4311 case 0x6ffffffc: return "VERDEF";
4312 case 0x7ffffffd: return "AUXILIARY";
4313 case 0x7fffffff: return "FILTER";
4314 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
4315
4316 default:
4317 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4318 {
4319 switch (filedata->file_header.e_machine)
4320 {
4321 case EM_ARC:
4322 case EM_ARC_COMPACT:
4323 case EM_ARC_COMPACT2:
4324 result = get_arc_section_type_name (sh_type);
4325 break;
4326 case EM_MIPS:
4327 case EM_MIPS_RS3_LE:
4328 result = get_mips_section_type_name (sh_type);
4329 break;
4330 case EM_PARISC:
4331 result = get_parisc_section_type_name (sh_type);
4332 break;
4333 case EM_IA_64:
4334 result = get_ia64_section_type_name (filedata, sh_type);
4335 break;
4336 case EM_X86_64:
4337 case EM_L1OM:
4338 case EM_K1OM:
4339 result = get_x86_64_section_type_name (sh_type);
4340 break;
4341 case EM_AARCH64:
4342 result = get_aarch64_section_type_name (sh_type);
4343 break;
4344 case EM_ARM:
4345 result = get_arm_section_type_name (sh_type);
4346 break;
4347 case EM_TI_C6000:
4348 result = get_tic6x_section_type_name (sh_type);
4349 break;
4350 case EM_MSP430:
4351 result = get_msp430x_section_type_name (sh_type);
4352 break;
4353 case EM_NFP:
4354 result = get_nfp_section_type_name (sh_type);
4355 break;
4356 case EM_V800:
4357 case EM_V850:
4358 case EM_CYGNUS_V850:
4359 result = get_v850_section_type_name (sh_type);
4360 break;
4361 case EM_RISCV:
4362 result = get_riscv_section_type_name (sh_type);
4363 break;
4364 default:
4365 result = NULL;
4366 break;
4367 }
4368
4369 if (result != NULL)
4370 return result;
4371
4372 sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4373 }
4374 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4375 {
4376 switch (filedata->file_header.e_machine)
4377 {
4378 case EM_IA_64:
4379 result = get_ia64_section_type_name (filedata, sh_type);
4380 break;
4381 default:
4382 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4383 result = get_solaris_section_type (sh_type);
4384 else
4385 {
4386 switch (sh_type)
4387 {
4388 case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4389 case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4390 case SHT_GNU_HASH: result = "GNU_HASH"; break;
4391 case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4392 default:
4393 result = NULL;
4394 break;
4395 }
4396 }
4397 break;
4398 }
4399
4400 if (result != NULL)
4401 return result;
4402
4403 sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4404 }
4405 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4406 {
4407 switch (filedata->file_header.e_machine)
4408 {
4409 case EM_V800:
4410 case EM_V850:
4411 case EM_CYGNUS_V850:
4412 result = get_v850_section_type_name (sh_type);
4413 break;
4414 default:
4415 result = NULL;
4416 break;
4417 }
4418
4419 if (result != NULL)
4420 return result;
4421
4422 sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4423 }
4424 else
4425 /* This message is probably going to be displayed in a 15
4426 character wide field, so put the hex value first. */
4427 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4428
4429 return buff;
4430 }
4431}
4432
4433#define OPTION_DEBUG_DUMP 512
4434#define OPTION_DYN_SYMS 513
4435#define OPTION_DWARF_DEPTH 514
4436#define OPTION_DWARF_START 515
4437#define OPTION_DWARF_CHECK 516
4438#define OPTION_CTF_DUMP 517
4439#define OPTION_CTF_PARENT 518
4440#define OPTION_CTF_SYMBOLS 519
4441#define OPTION_CTF_STRINGS 520
4442
4443static struct option options[] =
4444{
4445 {"all", no_argument, 0, 'a'},
4446 {"file-header", no_argument, 0, 'h'},
4447 {"program-headers", no_argument, 0, 'l'},
4448 {"headers", no_argument, 0, 'e'},
4449 {"histogram", no_argument, 0, 'I'},
4450 {"segments", no_argument, 0, 'l'},
4451 {"sections", no_argument, 0, 'S'},
4452 {"section-headers", no_argument, 0, 'S'},
4453 {"section-groups", no_argument, 0, 'g'},
4454 {"section-details", no_argument, 0, 't'},
4455 {"full-section-name",no_argument, 0, 'N'},
4456 {"symbols", no_argument, 0, 's'},
4457 {"syms", no_argument, 0, 's'},
4458 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
4459 {"relocs", no_argument, 0, 'r'},
4460 {"notes", no_argument, 0, 'n'},
4461 {"dynamic", no_argument, 0, 'd'},
4462 {"arch-specific", no_argument, 0, 'A'},
4463 {"version-info", no_argument, 0, 'V'},
4464 {"use-dynamic", no_argument, 0, 'D'},
4465 {"unwind", no_argument, 0, 'u'},
4466 {"archive-index", no_argument, 0, 'c'},
4467 {"hex-dump", required_argument, 0, 'x'},
4468 {"relocated-dump", required_argument, 0, 'R'},
4469 {"string-dump", required_argument, 0, 'p'},
4470 {"decompress", no_argument, 0, 'z'},
4471#ifdef SUPPORT_DISASSEMBLY
4472 {"instruction-dump", required_argument, 0, 'i'},
4473#endif
4474 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
4475
4476 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
4477 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4478 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
4479
4480 {"ctf", required_argument, 0, OPTION_CTF_DUMP},
4481
4482 {"ctf-symbols", required_argument, 0, OPTION_CTF_SYMBOLS},
4483 {"ctf-strings", required_argument, 0, OPTION_CTF_STRINGS},
4484 {"ctf-parent", required_argument, 0, OPTION_CTF_PARENT},
4485
4486 {"version", no_argument, 0, 'v'},
4487 {"wide", no_argument, 0, 'W'},
4488 {"help", no_argument, 0, 'H'},
4489 {0, no_argument, 0, 0}
4490};
4491
4492static void
4493usage (FILE * stream)
4494{
4495 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4496 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4497 fprintf (stream, _(" Options are:\n\
4498 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4499 -h --file-header Display the ELF file header\n\
4500 -l --program-headers Display the program headers\n\
4501 --segments An alias for --program-headers\n\
4502 -S --section-headers Display the sections' header\n\
4503 --sections An alias for --section-headers\n\
4504 -g --section-groups Display the section groups\n\
4505 -t --section-details Display the section details\n\
4506 -e --headers Equivalent to: -h -l -S\n\
4507 -s --syms Display the symbol table\n\
4508 --symbols An alias for --syms\n\
4509 --dyn-syms Display the dynamic symbol table\n\
4510 -n --notes Display the core notes (if present)\n\
4511 -r --relocs Display the relocations (if present)\n\
4512 -u --unwind Display the unwind info (if present)\n\
4513 -d --dynamic Display the dynamic section (if present)\n\
4514 -V --version-info Display the version sections (if present)\n\
4515 -A --arch-specific Display architecture specific information (if any)\n\
4516 -c --archive-index Display the symbol/file index in an archive\n\
4517 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4518 -x --hex-dump=<number|name>\n\
4519 Dump the contents of section <number|name> as bytes\n\
4520 -p --string-dump=<number|name>\n\
4521 Dump the contents of section <number|name> as strings\n\
4522 -R --relocated-dump=<number|name>\n\
4523 Dump the contents of section <number|name> as relocated bytes\n\
4524 -z --decompress Decompress section before dumping it\n\
4525 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4526 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4527 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4528 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4529 =addr,=cu_index,=links,=follow-links]\n\
4530 Display the contents of DWARF debug sections\n"));
4531 fprintf (stream, _("\
4532 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4533 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4534 or deeper\n"));
4535 fprintf (stream, _("\
4536 --ctf=<number|name> Display CTF info from section <number|name>\n\
4537 --ctf-parent=<number|name>\n\
4538 Use section <number|name> as the CTF parent\n\n\
4539 --ctf-symbols=<number|name>\n\
4540 Use section <number|name> as the CTF external symtab\n\n\
4541 --ctf-strings=<number|name>\n\
4542 Use section <number|name> as the CTF external strtab\n\n"));
4543
4544#ifdef SUPPORT_DISASSEMBLY
4545 fprintf (stream, _("\
4546 -i --instruction-dump=<number|name>\n\
4547 Disassemble the contents of section <number|name>\n"));
4548#endif
4549 fprintf (stream, _("\
4550 -I --histogram Display histogram of bucket list lengths\n\
4551 -W --wide Allow output width to exceed 80 characters\n\
4552 @<file> Read options from <file>\n\
4553 -H --help Display this information\n\
4554 -v --version Display the version number of readelf\n"));
4555
4556 if (REPORT_BUGS_TO[0] && stream == stdout)
4557 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4558
4559 exit (stream == stdout ? 0 : 1);
4560}
4561
4562/* Record the fact that the user wants the contents of section number
4563 SECTION to be displayed using the method(s) encoded as flags bits
4564 in TYPE. Note, TYPE can be zero if we are creating the array for
4565 the first time. */
4566
4567static void
4568request_dump_bynumber (Filedata * filedata, unsigned int section, dump_type type)
4569{
4570 if (section >= filedata->num_dump_sects)
4571 {
4572 dump_type * new_dump_sects;
4573
4574 new_dump_sects = (dump_type *) calloc (section + 1,
4575 sizeof (* new_dump_sects));
4576
4577 if (new_dump_sects == NULL)
4578 error (_("Out of memory allocating dump request table.\n"));
4579 else
4580 {
4581 if (filedata->dump_sects)
4582 {
4583 /* Copy current flag settings. */
4584 memcpy (new_dump_sects, filedata->dump_sects,
4585 filedata->num_dump_sects * sizeof (* new_dump_sects));
4586
4587 free (filedata->dump_sects);
4588 }
4589
4590 filedata->dump_sects = new_dump_sects;
4591 filedata->num_dump_sects = section + 1;
4592 }
4593 }
4594
4595 if (filedata->dump_sects)
4596 filedata->dump_sects[section] |= type;
4597}
4598
4599/* Request a dump by section name. */
4600
4601static void
4602request_dump_byname (const char * section, dump_type type)
4603{
4604 struct dump_list_entry * new_request;
4605
4606 new_request = (struct dump_list_entry *)
4607 malloc (sizeof (struct dump_list_entry));
4608 if (!new_request)
4609 error (_("Out of memory allocating dump request table.\n"));
4610
4611 new_request->name = strdup (section);
4612 if (!new_request->name)
4613 error (_("Out of memory allocating dump request table.\n"));
4614
4615 new_request->type = type;
4616
4617 new_request->next = dump_sects_byname;
4618 dump_sects_byname = new_request;
4619}
4620
4621static inline void
4622request_dump (Filedata * filedata, dump_type type)
4623{
4624 int section;
4625 char * cp;
4626
4627 do_dump++;
4628 section = strtoul (optarg, & cp, 0);
4629
4630 if (! *cp && section >= 0)
4631 request_dump_bynumber (filedata, section, type);
4632 else
4633 request_dump_byname (optarg, type);
4634}
4635
4636static void
4637parse_args (Filedata * filedata, int argc, char ** argv)
4638{
4639 int c;
4640
4641 if (argc < 2)
4642 usage (stderr);
4643
4644 while ((c = getopt_long
4645 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4646 {
4647 switch (c)
4648 {
4649 case 0:
4650 /* Long options. */
4651 break;
4652 case 'H':
4653 usage (stdout);
4654 break;
4655
4656 case 'a':
4657 do_syms = TRUE;
4658 do_reloc = TRUE;
4659 do_unwind = TRUE;
4660 do_dynamic = TRUE;
4661 do_header = TRUE;
4662 do_sections = TRUE;
4663 do_section_groups = TRUE;
4664 do_segments = TRUE;
4665 do_version = TRUE;
4666 do_histogram = TRUE;
4667 do_arch = TRUE;
4668 do_notes = TRUE;
4669 break;
4670 case 'g':
4671 do_section_groups = TRUE;
4672 break;
4673 case 't':
4674 case 'N':
4675 do_sections = TRUE;
4676 do_section_details = TRUE;
4677 break;
4678 case 'e':
4679 do_header = TRUE;
4680 do_sections = TRUE;
4681 do_segments = TRUE;
4682 break;
4683 case 'A':
4684 do_arch = TRUE;
4685 break;
4686 case 'D':
4687 do_using_dynamic = TRUE;
4688 break;
4689 case 'r':
4690 do_reloc = TRUE;
4691 break;
4692 case 'u':
4693 do_unwind = TRUE;
4694 break;
4695 case 'h':
4696 do_header = TRUE;
4697 break;
4698 case 'l':
4699 do_segments = TRUE;
4700 break;
4701 case 's':
4702 do_syms = TRUE;
4703 break;
4704 case 'S':
4705 do_sections = TRUE;
4706 break;
4707 case 'd':
4708 do_dynamic = TRUE;
4709 break;
4710 case 'I':
4711 do_histogram = TRUE;
4712 break;
4713 case 'n':
4714 do_notes = TRUE;
4715 break;
4716 case 'c':
4717 do_archive_index = TRUE;
4718 break;
4719 case 'x':
4720 request_dump (filedata, HEX_DUMP);
4721 break;
4722 case 'p':
4723 request_dump (filedata, STRING_DUMP);
4724 break;
4725 case 'R':
4726 request_dump (filedata, RELOC_DUMP);
4727 break;
4728 case 'z':
4729 decompress_dumps = TRUE;
4730 break;
4731 case 'w':
4732 do_dump = TRUE;
4733 if (optarg == 0)
4734 {
4735 do_debugging = TRUE;
4736 dwarf_select_sections_all ();
4737 }
4738 else
4739 {
4740 do_debugging = FALSE;
4741 dwarf_select_sections_by_letters (optarg);
4742 }
4743 break;
4744 case OPTION_DEBUG_DUMP:
4745 do_dump = TRUE;
4746 if (optarg == 0)
4747 do_debugging = TRUE;
4748 else
4749 {
4750 do_debugging = FALSE;
4751 dwarf_select_sections_by_names (optarg);
4752 }
4753 break;
4754 case OPTION_DWARF_DEPTH:
4755 {
4756 char *cp;
4757
4758 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4759 }
4760 break;
4761 case OPTION_DWARF_START:
4762 {
4763 char *cp;
4764
4765 dwarf_start_die = strtoul (optarg, & cp, 0);
4766 }
4767 break;
4768 case OPTION_DWARF_CHECK:
4769 dwarf_check = TRUE;
4770 break;
4771 case OPTION_CTF_DUMP:
4772 do_ctf = TRUE;
4773 request_dump (filedata, CTF_DUMP);
4774 break;
4775 case OPTION_CTF_SYMBOLS:
4776 dump_ctf_symtab_name = strdup (optarg);
4777 break;
4778 case OPTION_CTF_STRINGS:
4779 dump_ctf_strtab_name = strdup (optarg);
4780 break;
4781 case OPTION_CTF_PARENT:
4782 dump_ctf_parent_name = strdup (optarg);
4783 break;
4784 case OPTION_DYN_SYMS:
4785 do_dyn_syms = TRUE;
4786 break;
4787#ifdef SUPPORT_DISASSEMBLY
4788 case 'i':
4789 request_dump (filedata, DISASS_DUMP);
4790 break;
4791#endif
4792 case 'v':
4793 print_version (program_name);
4794 break;
4795 case 'V':
4796 do_version = TRUE;
4797 break;
4798 case 'W':
4799 do_wide = TRUE;
4800 break;
4801 default:
4802 /* xgettext:c-format */
4803 error (_("Invalid option '-%c'\n"), c);
4804 /* Fall through. */
4805 case '?':
4806 usage (stderr);
4807 }
4808 }
4809
4810 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4811 && !do_segments && !do_header && !do_dump && !do_version
4812 && !do_histogram && !do_debugging && !do_arch && !do_notes
4813 && !do_section_groups && !do_archive_index
4814 && !do_dyn_syms)
4815 usage (stderr);
4816}
4817
4818static const char *
4819get_elf_class (unsigned int elf_class)
4820{
4821 static char buff[32];
4822
4823 switch (elf_class)
4824 {
4825 case ELFCLASSNONE: return _("none");
4826 case ELFCLASS32: return "ELF32";
4827 case ELFCLASS64: return "ELF64";
4828 default:
4829 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4830 return buff;
4831 }
4832}
4833
4834static const char *
4835get_data_encoding (unsigned int encoding)
4836{
4837 static char buff[32];
4838
4839 switch (encoding)
4840 {
4841 case ELFDATANONE: return _("none");
4842 case ELFDATA2LSB: return _("2's complement, little endian");
4843 case ELFDATA2MSB: return _("2's complement, big endian");
4844 default:
4845 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4846 return buff;
4847 }
4848}
4849
4850/* Decode the data held in 'filedata->file_header'. */
4851
4852static bfd_boolean
4853process_file_header (Filedata * filedata)
4854{
4855 Elf_Internal_Ehdr * header = & filedata->file_header;
4856
4857 if ( header->e_ident[EI_MAG0] != ELFMAG0
4858 || header->e_ident[EI_MAG1] != ELFMAG1
4859 || header->e_ident[EI_MAG2] != ELFMAG2
4860 || header->e_ident[EI_MAG3] != ELFMAG3)
4861 {
4862 error
4863 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4864 return FALSE;
4865 }
4866
4867 init_dwarf_regnames_by_elf_machine_code (header->e_machine);
4868
4869 if (do_header)
4870 {
4871 unsigned i;
4872
4873 printf (_("ELF Header:\n"));
4874 printf (_(" Magic: "));
4875 for (i = 0; i < EI_NIDENT; i++)
4876 printf ("%2.2x ", header->e_ident[i]);
4877 printf ("\n");
4878 printf (_(" Class: %s\n"),
4879 get_elf_class (header->e_ident[EI_CLASS]));
4880 printf (_(" Data: %s\n"),
4881 get_data_encoding (header->e_ident[EI_DATA]));
4882 printf (_(" Version: %d%s\n"),
4883 header->e_ident[EI_VERSION],
4884 (header->e_ident[EI_VERSION] == EV_CURRENT
4885 ? _(" (current)")
4886 : (header->e_ident[EI_VERSION] != EV_NONE
4887 ? _(" <unknown>")
4888 : "")));
4889 printf (_(" OS/ABI: %s\n"),
4890 get_osabi_name (filedata, header->e_ident[EI_OSABI]));
4891 printf (_(" ABI Version: %d\n"),
4892 header->e_ident[EI_ABIVERSION]);
4893 printf (_(" Type: %s\n"),
4894 get_file_type (header->e_type));
4895 printf (_(" Machine: %s\n"),
4896 get_machine_name (header->e_machine));
4897 printf (_(" Version: 0x%lx\n"),
4898 header->e_version);
4899
4900 printf (_(" Entry point address: "));
4901 print_vma (header->e_entry, PREFIX_HEX);
4902 printf (_("\n Start of program headers: "));
4903 print_vma (header->e_phoff, DEC);
4904 printf (_(" (bytes into file)\n Start of section headers: "));
4905 print_vma (header->e_shoff, DEC);
4906 printf (_(" (bytes into file)\n"));
4907
4908 printf (_(" Flags: 0x%lx%s\n"),
4909 header->e_flags,
4910 get_machine_flags (filedata, header->e_flags, header->e_machine));
4911 printf (_(" Size of this header: %u (bytes)\n"),
4912 header->e_ehsize);
4913 printf (_(" Size of program headers: %u (bytes)\n"),
4914 header->e_phentsize);
4915 printf (_(" Number of program headers: %u"),
4916 header->e_phnum);
4917 if (filedata->section_headers != NULL
4918 && header->e_phnum == PN_XNUM
4919 && filedata->section_headers[0].sh_info != 0)
4920 {
4921 header->e_phnum = filedata->section_headers[0].sh_info;
4922 printf (" (%u)", header->e_phnum);
4923 }
4924 putc ('\n', stdout);
4925 printf (_(" Size of section headers: %u (bytes)\n"),
4926 header->e_shentsize);
4927 printf (_(" Number of section headers: %u"),
4928 header->e_shnum);
4929 if (filedata->section_headers != NULL && header->e_shnum == SHN_UNDEF)
4930 {
4931 header->e_shnum = filedata->section_headers[0].sh_size;
4932 printf (" (%u)", header->e_shnum);
4933 }
4934 putc ('\n', stdout);
4935 printf (_(" Section header string table index: %u"),
4936 header->e_shstrndx);
4937 if (filedata->section_headers != NULL
4938 && header->e_shstrndx == (SHN_XINDEX & 0xffff))
4939 {
4940 header->e_shstrndx = filedata->section_headers[0].sh_link;
4941 printf (" (%u)", header->e_shstrndx);
4942 }
4943 if (header->e_shstrndx != SHN_UNDEF
4944 && header->e_shstrndx >= header->e_shnum)
4945 {
4946 header->e_shstrndx = SHN_UNDEF;
4947 printf (_(" <corrupt: out of range>"));
4948 }
4949 putc ('\n', stdout);
4950 }
4951
4952 if (filedata->section_headers != NULL)
4953 {
4954 if (header->e_phnum == PN_XNUM
4955 && filedata->section_headers[0].sh_info != 0)
4956 header->e_phnum = filedata->section_headers[0].sh_info;
4957 if (header->e_shnum == SHN_UNDEF)
4958 header->e_shnum = filedata->section_headers[0].sh_size;
4959 if (header->e_shstrndx == (SHN_XINDEX & 0xffff))
4960 header->e_shstrndx = filedata->section_headers[0].sh_link;
4961 if (header->e_shstrndx >= header->e_shnum)
4962 header->e_shstrndx = SHN_UNDEF;
4963 free (filedata->section_headers);
4964 filedata->section_headers = NULL;
4965 }
4966
4967 return TRUE;
4968}
4969
4970/* Read in the program headers from FILEDATA and store them in PHEADERS.
4971 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
4972
4973static bfd_boolean
4974get_32bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4975{
4976 Elf32_External_Phdr * phdrs;
4977 Elf32_External_Phdr * external;
4978 Elf_Internal_Phdr * internal;
4979 unsigned int i;
4980 unsigned int size = filedata->file_header.e_phentsize;
4981 unsigned int num = filedata->file_header.e_phnum;
4982
4983 /* PR binutils/17531: Cope with unexpected section header sizes. */
4984 if (size == 0 || num == 0)
4985 return FALSE;
4986 if (size < sizeof * phdrs)
4987 {
4988 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4989 return FALSE;
4990 }
4991 if (size > sizeof * phdrs)
4992 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4993
4994 phdrs = (Elf32_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4995 size, num, _("program headers"));
4996 if (phdrs == NULL)
4997 return FALSE;
4998
4999 for (i = 0, internal = pheaders, external = phdrs;
5000 i < filedata->file_header.e_phnum;
5001 i++, internal++, external++)
5002 {
5003 internal->p_type = BYTE_GET (external->p_type);
5004 internal->p_offset = BYTE_GET (external->p_offset);
5005 internal->p_vaddr = BYTE_GET (external->p_vaddr);
5006 internal->p_paddr = BYTE_GET (external->p_paddr);
5007 internal->p_filesz = BYTE_GET (external->p_filesz);
5008 internal->p_memsz = BYTE_GET (external->p_memsz);
5009 internal->p_flags = BYTE_GET (external->p_flags);
5010 internal->p_align = BYTE_GET (external->p_align);
5011 }
5012
5013 free (phdrs);
5014 return TRUE;
5015}
5016
5017/* Read in the program headers from FILEDATA and store them in PHEADERS.
5018 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5019
5020static bfd_boolean
5021get_64bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
5022{
5023 Elf64_External_Phdr * phdrs;
5024 Elf64_External_Phdr * external;
5025 Elf_Internal_Phdr * internal;
5026 unsigned int i;
5027 unsigned int size = filedata->file_header.e_phentsize;
5028 unsigned int num = filedata->file_header.e_phnum;
5029
5030 /* PR binutils/17531: Cope with unexpected section header sizes. */
5031 if (size == 0 || num == 0)
5032 return FALSE;
5033 if (size < sizeof * phdrs)
5034 {
5035 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5036 return FALSE;
5037 }
5038 if (size > sizeof * phdrs)
5039 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5040
5041 phdrs = (Elf64_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
5042 size, num, _("program headers"));
5043 if (!phdrs)
5044 return FALSE;
5045
5046 for (i = 0, internal = pheaders, external = phdrs;
5047 i < filedata->file_header.e_phnum;
5048 i++, internal++, external++)
5049 {
5050 internal->p_type = BYTE_GET (external->p_type);
5051 internal->p_flags = BYTE_GET (external->p_flags);
5052 internal->p_offset = BYTE_GET (external->p_offset);
5053 internal->p_vaddr = BYTE_GET (external->p_vaddr);
5054 internal->p_paddr = BYTE_GET (external->p_paddr);
5055 internal->p_filesz = BYTE_GET (external->p_filesz);
5056 internal->p_memsz = BYTE_GET (external->p_memsz);
5057 internal->p_align = BYTE_GET (external->p_align);
5058 }
5059
5060 free (phdrs);
5061 return TRUE;
5062}
5063
5064/* Returns TRUE if the program headers were read into `program_headers'. */
5065
5066static bfd_boolean
5067get_program_headers (Filedata * filedata)
5068{
5069 Elf_Internal_Phdr * phdrs;
5070
5071 /* Check cache of prior read. */
5072 if (filedata->program_headers != NULL)
5073 return TRUE;
5074
5075 /* Be kind to memory checkers by looking for
5076 e_phnum values which we know must be invalid. */
5077 if (filedata->file_header.e_phnum
5078 * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
5079 >= filedata->file_size)
5080 {
5081 error (_("Too many program headers - %#x - the file is not that big\n"),
5082 filedata->file_header.e_phnum);
5083 return FALSE;
5084 }
5085
5086 phdrs = (Elf_Internal_Phdr *) cmalloc (filedata->file_header.e_phnum,
5087 sizeof (Elf_Internal_Phdr));
5088 if (phdrs == NULL)
5089 {
5090 error (_("Out of memory reading %u program headers\n"),
5091 filedata->file_header.e_phnum);
5092 return FALSE;
5093 }
5094
5095 if (is_32bit_elf
5096 ? get_32bit_program_headers (filedata, phdrs)
5097 : get_64bit_program_headers (filedata, phdrs))
5098 {
5099 filedata->program_headers = phdrs;
5100 return TRUE;
5101 }
5102
5103 free (phdrs);
5104 return FALSE;
5105}
5106
5107/* Returns TRUE if the program headers were loaded. */
5108
5109static bfd_boolean
5110process_program_headers (Filedata * filedata)
5111{
5112 Elf_Internal_Phdr * segment;
5113 unsigned int i;
5114 Elf_Internal_Phdr * previous_load = NULL;
5115
5116 dynamic_addr = 0;
5117 dynamic_size = 0;
5118
5119 if (filedata->file_header.e_phnum == 0)
5120 {
5121 /* PR binutils/12467. */
5122 if (filedata->file_header.e_phoff != 0)
5123 {
5124 warn (_("possibly corrupt ELF header - it has a non-zero program"
5125 " header offset, but no program headers\n"));
5126 return FALSE;
5127 }
5128 else if (do_segments)
5129 printf (_("\nThere are no program headers in this file.\n"));
5130 return TRUE;
5131 }
5132
5133 if (do_segments && !do_header)
5134 {
5135 printf (_("\nElf file type is %s\n"), get_file_type (filedata->file_header.e_type));
5136 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata->file_header.e_entry));
5137 printf (ngettext ("There is %d program header, starting at offset %s\n",
5138 "There are %d program headers, starting at offset %s\n",
5139 filedata->file_header.e_phnum),
5140 filedata->file_header.e_phnum,
5141 bfd_vmatoa ("u", filedata->file_header.e_phoff));
5142 }
5143
5144 if (! get_program_headers (filedata))
5145 return TRUE;
5146
5147 if (do_segments)
5148 {
5149 if (filedata->file_header.e_phnum > 1)
5150 printf (_("\nProgram Headers:\n"));
5151 else
5152 printf (_("\nProgram Headers:\n"));
5153
5154 if (is_32bit_elf)
5155 printf
5156 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5157 else if (do_wide)
5158 printf
5159 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5160 else
5161 {
5162 printf
5163 (_(" Type Offset VirtAddr PhysAddr\n"));
5164 printf
5165 (_(" FileSiz MemSiz Flags Align\n"));
5166 }
5167 }
5168
5169 for (i = 0, segment = filedata->program_headers;
5170 i < filedata->file_header.e_phnum;
5171 i++, segment++)
5172 {
5173 if (do_segments)
5174 {
5175 printf (" %-14.14s ", get_segment_type (filedata, segment->p_type));
5176
5177 if (is_32bit_elf)
5178 {
5179 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5180 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
5181 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
5182 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
5183 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
5184 printf ("%c%c%c ",
5185 (segment->p_flags & PF_R ? 'R' : ' '),
5186 (segment->p_flags & PF_W ? 'W' : ' '),
5187 (segment->p_flags & PF_X ? 'E' : ' '));
5188 printf ("%#lx", (unsigned long) segment->p_align);
5189 }
5190 else if (do_wide)
5191 {
5192 if ((unsigned long) segment->p_offset == segment->p_offset)
5193 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5194 else
5195 {
5196 print_vma (segment->p_offset, FULL_HEX);
5197 putchar (' ');
5198 }
5199
5200 print_vma (segment->p_vaddr, FULL_HEX);
5201 putchar (' ');
5202 print_vma (segment->p_paddr, FULL_HEX);
5203 putchar (' ');
5204
5205 if ((unsigned long) segment->p_filesz == segment->p_filesz)
5206 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
5207 else
5208 {
5209 print_vma (segment->p_filesz, FULL_HEX);
5210 putchar (' ');
5211 }
5212
5213 if ((unsigned long) segment->p_memsz == segment->p_memsz)
5214 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
5215 else
5216 {
5217 print_vma (segment->p_memsz, FULL_HEX);
5218 }
5219
5220 printf (" %c%c%c ",
5221 (segment->p_flags & PF_R ? 'R' : ' '),
5222 (segment->p_flags & PF_W ? 'W' : ' '),
5223 (segment->p_flags & PF_X ? 'E' : ' '));
5224
5225 if ((unsigned long) segment->p_align == segment->p_align)
5226 printf ("%#lx", (unsigned long) segment->p_align);
5227 else
5228 {
5229 print_vma (segment->p_align, PREFIX_HEX);
5230 }
5231 }
5232 else
5233 {
5234 print_vma (segment->p_offset, FULL_HEX);
5235 putchar (' ');
5236 print_vma (segment->p_vaddr, FULL_HEX);
5237 putchar (' ');
5238 print_vma (segment->p_paddr, FULL_HEX);
5239 printf ("\n ");
5240 print_vma (segment->p_filesz, FULL_HEX);
5241 putchar (' ');
5242 print_vma (segment->p_memsz, FULL_HEX);
5243 printf (" %c%c%c ",
5244 (segment->p_flags & PF_R ? 'R' : ' '),
5245 (segment->p_flags & PF_W ? 'W' : ' '),
5246 (segment->p_flags & PF_X ? 'E' : ' '));
5247 print_vma (segment->p_align, PREFIX_HEX);
5248 }
5249
5250 putc ('\n', stdout);
5251 }
5252
5253 switch (segment->p_type)
5254 {
5255 case PT_LOAD:
5256#if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5257 required by the ELF standard, several programs, including the Linux
5258 kernel, make use of non-ordered segments. */
5259 if (previous_load
5260 && previous_load->p_vaddr > segment->p_vaddr)
5261 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5262#endif
5263 if (segment->p_memsz < segment->p_filesz)
5264 error (_("the segment's file size is larger than its memory size\n"));
5265 previous_load = segment;
5266 break;
5267
5268 case PT_PHDR:
5269 /* PR 20815 - Verify that the program header is loaded into memory. */
5270 if (i > 0 && previous_load != NULL)
5271 error (_("the PHDR segment must occur before any LOAD segment\n"));
5272 if (filedata->file_header.e_machine != EM_PARISC)
5273 {
5274 unsigned int j;
5275
5276 for (j = 1; j < filedata->file_header.e_phnum; j++)
5277 {
5278 Elf_Internal_Phdr *load = filedata->program_headers + j;
5279 if (load->p_type == PT_LOAD
5280 && load->p_offset <= segment->p_offset
5281 && (load->p_offset + load->p_filesz
5282 >= segment->p_offset + segment->p_filesz)
5283 && load->p_vaddr <= segment->p_vaddr
5284 && (load->p_vaddr + load->p_filesz
5285 >= segment->p_vaddr + segment->p_filesz))
5286 break;
5287 }
5288 if (j == filedata->file_header.e_phnum)
5289 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5290 }
5291 break;
5292
5293 case PT_DYNAMIC:
5294 if (dynamic_addr)
5295 error (_("more than one dynamic segment\n"));
5296
5297 /* By default, assume that the .dynamic section is the first
5298 section in the DYNAMIC segment. */
5299 dynamic_addr = segment->p_offset;
5300 dynamic_size = segment->p_filesz;
5301
5302 /* Try to locate the .dynamic section. If there is
5303 a section header table, we can easily locate it. */
5304 if (filedata->section_headers != NULL)
5305 {
5306 Elf_Internal_Shdr * sec;
5307
5308 sec = find_section (filedata, ".dynamic");
5309 if (sec == NULL || sec->sh_size == 0)
5310 {
5311 /* A corresponding .dynamic section is expected, but on
5312 IA-64/OpenVMS it is OK for it to be missing. */
5313 if (!is_ia64_vms (filedata))
5314 error (_("no .dynamic section in the dynamic segment\n"));
5315 break;
5316 }
5317
5318 if (sec->sh_type == SHT_NOBITS)
5319 {
5320 dynamic_size = 0;
5321 break;
5322 }
5323
5324 dynamic_addr = sec->sh_offset;
5325 dynamic_size = sec->sh_size;
5326
5327 if (dynamic_addr < segment->p_offset
5328 || dynamic_addr > segment->p_offset + segment->p_filesz)
5329 warn (_("the .dynamic section is not contained"
5330 " within the dynamic segment\n"));
5331 else if (dynamic_addr > segment->p_offset)
5332 warn (_("the .dynamic section is not the first section"
5333 " in the dynamic segment.\n"));
5334 }
5335
5336 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5337 segment. Check this after matching against the section headers
5338 so we don't warn on debuginfo file (which have NOBITS .dynamic
5339 sections). */
5340 if (dynamic_addr > filedata->file_size
5341 || dynamic_size > filedata->file_size - dynamic_addr)
5342 {
5343 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5344 dynamic_addr = dynamic_size = 0;
5345 }
5346 break;
5347
5348 case PT_INTERP:
5349 if (fseek (filedata->handle, archive_file_offset + (long) segment->p_offset,
5350 SEEK_SET))
5351 error (_("Unable to find program interpreter name\n"));
5352 else
5353 {
5354 char fmt [32];
5355 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5356
5357 if (ret >= (int) sizeof (fmt) || ret < 0)
5358 error (_("Internal error: failed to create format string to display program interpreter\n"));
5359
5360 program_interpreter[0] = 0;
5361 if (fscanf (filedata->handle, fmt, program_interpreter) <= 0)
5362 error (_("Unable to read program interpreter name\n"));
5363
5364 if (do_segments)
5365 printf (_(" [Requesting program interpreter: %s]\n"),
5366 program_interpreter);
5367 }
5368 break;
5369 }
5370 }
5371
5372 if (do_segments
5373 && filedata->section_headers != NULL
5374 && filedata->string_table != NULL)
5375 {
5376 printf (_("\n Section to Segment mapping:\n"));
5377 printf (_(" Segment Sections...\n"));
5378
5379 for (i = 0; i < filedata->file_header.e_phnum; i++)
5380 {
5381 unsigned int j;
5382 Elf_Internal_Shdr * section;
5383
5384 segment = filedata->program_headers + i;
5385 section = filedata->section_headers + 1;
5386
5387 printf (" %2.2d ", i);
5388
5389 for (j = 1; j < filedata->file_header.e_shnum; j++, section++)
5390 {
5391 if (!ELF_TBSS_SPECIAL (section, segment)
5392 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5393 printf ("%s ", printable_section_name (filedata, section));
5394 }
5395
5396 putc ('\n',stdout);
5397 }
5398 }
5399
5400 return TRUE;
5401}
5402
5403
5404/* Find the file offset corresponding to VMA by using the program headers. */
5405
5406static long
5407offset_from_vma (Filedata * filedata, bfd_vma vma, bfd_size_type size)
5408{
5409 Elf_Internal_Phdr * seg;
5410
5411 if (! get_program_headers (filedata))
5412 {
5413 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5414 return (long) vma;
5415 }
5416
5417 for (seg = filedata->program_headers;
5418 seg < filedata->program_headers + filedata->file_header.e_phnum;
5419 ++seg)
5420 {
5421 if (seg->p_type != PT_LOAD)
5422 continue;
5423
5424 if (vma >= (seg->p_vaddr & -seg->p_align)
5425 && vma + size <= seg->p_vaddr + seg->p_filesz)
5426 return vma - seg->p_vaddr + seg->p_offset;
5427 }
5428
5429 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5430 (unsigned long) vma);
5431 return (long) vma;
5432}
5433
5434
5435/* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5436 If PROBE is true, this is just a probe and we do not generate any error
5437 messages if the load fails. */
5438
5439static bfd_boolean
5440get_32bit_section_headers (Filedata * filedata, bfd_boolean probe)
5441{
5442 Elf32_External_Shdr * shdrs;
5443 Elf_Internal_Shdr * internal;
5444 unsigned int i;
5445 unsigned int size = filedata->file_header.e_shentsize;
5446 unsigned int num = probe ? 1 : filedata->file_header.e_shnum;
5447
5448 /* PR binutils/17531: Cope with unexpected section header sizes. */
5449 if (size == 0 || num == 0)
5450 return FALSE;
5451 if (size < sizeof * shdrs)
5452 {
5453 if (! probe)
5454 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5455 return FALSE;
5456 }
5457 if (!probe && size > sizeof * shdrs)
5458 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5459
5460 shdrs = (Elf32_External_Shdr *) get_data (NULL, filedata, filedata->file_header.e_shoff,
5461 size, num,
5462 probe ? NULL : _("section headers"));
5463 if (shdrs == NULL)
5464 return FALSE;
5465
5466 free (filedata->section_headers);
5467 filedata->section_headers = (Elf_Internal_Shdr *)
5468 cmalloc (num, sizeof (Elf_Internal_Shdr));
5469 if (filedata->section_headers == NULL)
5470 {
5471 if (!probe)
5472 error (_("Out of memory reading %u section headers\n"), num);
5473 free (shdrs);
5474 return FALSE;
5475 }
5476
5477 for (i = 0, internal = filedata->section_headers;
5478 i < num;
5479 i++, internal++)
5480 {
5481 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5482 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5483 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5484 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5485 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5486 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5487 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5488 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5489 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5490 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
5491 if (!probe && internal->sh_link > num)
5492 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5493 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5494 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5495 }
5496
5497 free (shdrs);
5498 return TRUE;
5499}
5500
5501/* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5502
5503static bfd_boolean
5504get_64bit_section_headers (Filedata * filedata, bfd_boolean probe)
5505{
5506 Elf64_External_Shdr * shdrs;
5507 Elf_Internal_Shdr * internal;
5508 unsigned int i;
5509 unsigned int size = filedata->file_header.e_shentsize;
5510 unsigned int num = probe ? 1 : filedata->file_header.e_shnum;
5511
5512 /* PR binutils/17531: Cope with unexpected section header sizes. */
5513 if (size == 0 || num == 0)
5514 return FALSE;
5515
5516 if (size < sizeof * shdrs)
5517 {
5518 if (! probe)
5519 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5520 return FALSE;
5521 }
5522
5523 if (! probe && size > sizeof * shdrs)
5524 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5525
5526 shdrs = (Elf64_External_Shdr *) get_data (NULL, filedata,
5527 filedata->file_header.e_shoff,
5528 size, num,
5529 probe ? NULL : _("section headers"));
5530 if (shdrs == NULL)
5531 return FALSE;
5532
5533 free (filedata->section_headers);
5534 filedata->section_headers = (Elf_Internal_Shdr *)
5535 cmalloc (num, sizeof (Elf_Internal_Shdr));
5536 if (filedata->section_headers == NULL)
5537 {
5538 if (! probe)
5539 error (_("Out of memory reading %u section headers\n"), num);
5540 free (shdrs);
5541 return FALSE;
5542 }
5543
5544 for (i = 0, internal = filedata->section_headers;
5545 i < num;
5546 i++, internal++)
5547 {
5548 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5549 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5550 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5551 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5552 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5553 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
5554 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5555 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5556 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5557 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5558 if (!probe && internal->sh_link > num)
5559 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5560 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5561 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5562 }
5563
5564 free (shdrs);
5565 return TRUE;
5566}
5567
5568static Elf_Internal_Sym *
5569get_32bit_elf_symbols (Filedata * filedata,
5570 Elf_Internal_Shdr * section,
5571 unsigned long * num_syms_return)
5572{
5573 unsigned long number = 0;
5574 Elf32_External_Sym * esyms = NULL;
5575 Elf_External_Sym_Shndx * shndx = NULL;
5576 Elf_Internal_Sym * isyms = NULL;
5577 Elf_Internal_Sym * psym;
5578 unsigned int j;
5579 elf_section_list * entry;
5580
5581 if (section->sh_size == 0)
5582 {
5583 if (num_syms_return != NULL)
5584 * num_syms_return = 0;
5585 return NULL;
5586 }
5587
5588 /* Run some sanity checks first. */
5589 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5590 {
5591 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5592 printable_section_name (filedata, section),
5593 (unsigned long) section->sh_entsize);
5594 goto exit_point;
5595 }
5596
5597 if (section->sh_size > filedata->file_size)
5598 {
5599 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5600 printable_section_name (filedata, section),
5601 (unsigned long) section->sh_size);
5602 goto exit_point;
5603 }
5604
5605 number = section->sh_size / section->sh_entsize;
5606
5607 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5608 {
5609 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5610 (unsigned long) section->sh_size,
5611 printable_section_name (filedata, section),
5612 (unsigned long) section->sh_entsize);
5613 goto exit_point;
5614 }
5615
5616 esyms = (Elf32_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5617 section->sh_size, _("symbols"));
5618 if (esyms == NULL)
5619 goto exit_point;
5620
5621 shndx = NULL;
5622 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5623 {
5624 if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5625 continue;
5626
5627 if (shndx != NULL)
5628 {
5629 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5630 free (shndx);
5631 }
5632
5633 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5634 entry->hdr->sh_offset,
5635 1, entry->hdr->sh_size,
5636 _("symbol table section indices"));
5637 if (shndx == NULL)
5638 goto exit_point;
5639
5640 /* PR17531: file: heap-buffer-overflow */
5641 if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5642 {
5643 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5644 printable_section_name (filedata, entry->hdr),
5645 (unsigned long) entry->hdr->sh_size,
5646 (unsigned long) section->sh_size);
5647 goto exit_point;
5648 }
5649 }
5650
5651 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5652
5653 if (isyms == NULL)
5654 {
5655 error (_("Out of memory reading %lu symbols\n"),
5656 (unsigned long) number);
5657 goto exit_point;
5658 }
5659
5660 for (j = 0, psym = isyms; j < number; j++, psym++)
5661 {
5662 psym->st_name = BYTE_GET (esyms[j].st_name);
5663 psym->st_value = BYTE_GET (esyms[j].st_value);
5664 psym->st_size = BYTE_GET (esyms[j].st_size);
5665 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5666 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5667 psym->st_shndx
5668 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5669 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5670 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5671 psym->st_info = BYTE_GET (esyms[j].st_info);
5672 psym->st_other = BYTE_GET (esyms[j].st_other);
5673 }
5674
5675 exit_point:
5676 free (shndx);
5677 free (esyms);
5678
5679 if (num_syms_return != NULL)
5680 * num_syms_return = isyms == NULL ? 0 : number;
5681
5682 return isyms;
5683}
5684
5685static Elf_Internal_Sym *
5686get_64bit_elf_symbols (Filedata * filedata,
5687 Elf_Internal_Shdr * section,
5688 unsigned long * num_syms_return)
5689{
5690 unsigned long number = 0;
5691 Elf64_External_Sym * esyms = NULL;
5692 Elf_External_Sym_Shndx * shndx = NULL;
5693 Elf_Internal_Sym * isyms = NULL;
5694 Elf_Internal_Sym * psym;
5695 unsigned int j;
5696 elf_section_list * entry;
5697
5698 if (section->sh_size == 0)
5699 {
5700 if (num_syms_return != NULL)
5701 * num_syms_return = 0;
5702 return NULL;
5703 }
5704
5705 /* Run some sanity checks first. */
5706 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5707 {
5708 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5709 printable_section_name (filedata, section),
5710 (unsigned long) section->sh_entsize);
5711 goto exit_point;
5712 }
5713
5714 if (section->sh_size > filedata->file_size)
5715 {
5716 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5717 printable_section_name (filedata, section),
5718 (unsigned long) section->sh_size);
5719 goto exit_point;
5720 }
5721
5722 number = section->sh_size / section->sh_entsize;
5723
5724 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5725 {
5726 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5727 (unsigned long) section->sh_size,
5728 printable_section_name (filedata, section),
5729 (unsigned long) section->sh_entsize);
5730 goto exit_point;
5731 }
5732
5733 esyms = (Elf64_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5734 section->sh_size, _("symbols"));
5735 if (!esyms)
5736 goto exit_point;
5737
5738 shndx = NULL;
5739 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5740 {
5741 if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5742 continue;
5743
5744 if (shndx != NULL)
5745 {
5746 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5747 free (shndx);
5748 }
5749
5750 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5751 entry->hdr->sh_offset,
5752 1, entry->hdr->sh_size,
5753 _("symbol table section indices"));
5754 if (shndx == NULL)
5755 goto exit_point;
5756
5757 /* PR17531: file: heap-buffer-overflow */
5758 if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5759 {
5760 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5761 printable_section_name (filedata, entry->hdr),
5762 (unsigned long) entry->hdr->sh_size,
5763 (unsigned long) section->sh_size);
5764 goto exit_point;
5765 }
5766 }
5767
5768 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5769
5770 if (isyms == NULL)
5771 {
5772 error (_("Out of memory reading %lu symbols\n"),
5773 (unsigned long) number);
5774 goto exit_point;
5775 }
5776
5777 for (j = 0, psym = isyms; j < number; j++, psym++)
5778 {
5779 psym->st_name = BYTE_GET (esyms[j].st_name);
5780 psym->st_info = BYTE_GET (esyms[j].st_info);
5781 psym->st_other = BYTE_GET (esyms[j].st_other);
5782 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5783
5784 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5785 psym->st_shndx
5786 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5787 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5788 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5789
5790 psym->st_value = BYTE_GET (esyms[j].st_value);
5791 psym->st_size = BYTE_GET (esyms[j].st_size);
5792 }
5793
5794 exit_point:
5795 free (shndx);
5796 free (esyms);
5797
5798 if (num_syms_return != NULL)
5799 * num_syms_return = isyms == NULL ? 0 : number;
5800
5801 return isyms;
5802}
5803
5804static const char *
5805get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
5806{
5807 static char buff[1024];
5808 char * p = buff;
5809 unsigned int field_size = is_32bit_elf ? 8 : 16;
5810 signed int sindex;
5811 unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5812 bfd_vma os_flags = 0;
5813 bfd_vma proc_flags = 0;
5814 bfd_vma unknown_flags = 0;
5815 static const struct
5816 {
5817 const char * str;
5818 unsigned int len;
5819 }
5820 flags [] =
5821 {
5822 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5823 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5824 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5825 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5826 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5827 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5828 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5829 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5830 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5831 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5832 /* IA-64 specific. */
5833 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5834 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5835 /* IA-64 OpenVMS specific. */
5836 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5837 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5838 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5839 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5840 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5841 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5842 /* Generic. */
5843 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5844 /* SPARC specific. */
5845 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5846 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5847 /* ARM specific. */
5848 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5849 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5850 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5851 /* GNU specific. */
5852 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5853 /* VLE specific. */
5854 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5855 };
5856
5857 if (do_section_details)
5858 {
5859 sprintf (buff, "[%*.*lx]: ",
5860 field_size, field_size, (unsigned long) sh_flags);
5861 p += field_size + 4;
5862 }
5863
5864 while (sh_flags)
5865 {
5866 bfd_vma flag;
5867
5868 flag = sh_flags & - sh_flags;
5869 sh_flags &= ~ flag;
5870
5871 if (do_section_details)
5872 {
5873 switch (flag)
5874 {
5875 case SHF_WRITE: sindex = 0; break;
5876 case SHF_ALLOC: sindex = 1; break;
5877 case SHF_EXECINSTR: sindex = 2; break;
5878 case SHF_MERGE: sindex = 3; break;
5879 case SHF_STRINGS: sindex = 4; break;
5880 case SHF_INFO_LINK: sindex = 5; break;
5881 case SHF_LINK_ORDER: sindex = 6; break;
5882 case SHF_OS_NONCONFORMING: sindex = 7; break;
5883 case SHF_GROUP: sindex = 8; break;
5884 case SHF_TLS: sindex = 9; break;
5885 case SHF_EXCLUDE: sindex = 18; break;
5886 case SHF_COMPRESSED: sindex = 20; break;
5887 case SHF_GNU_MBIND: sindex = 24; break;
5888
5889 default:
5890 sindex = -1;
5891 switch (filedata->file_header.e_machine)
5892 {
5893 case EM_IA_64:
5894 if (flag == SHF_IA_64_SHORT)
5895 sindex = 10;
5896 else if (flag == SHF_IA_64_NORECOV)
5897 sindex = 11;
5898#ifdef BFD64
5899 else if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5900 switch (flag)
5901 {
5902 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5903 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5904 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5905 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5906 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5907 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
5908 default: break;
5909 }
5910#endif
5911 break;
5912
5913 case EM_386:
5914 case EM_IAMCU:
5915 case EM_X86_64:
5916 case EM_L1OM:
5917 case EM_K1OM:
5918 case EM_OLD_SPARCV9:
5919 case EM_SPARC32PLUS:
5920 case EM_SPARCV9:
5921 case EM_SPARC:
5922 if (flag == SHF_ORDERED)
5923 sindex = 19;
5924 break;
5925
5926 case EM_ARM:
5927 switch (flag)
5928 {
5929 case SHF_ENTRYSECT: sindex = 21; break;
5930 case SHF_ARM_PURECODE: sindex = 22; break;
5931 case SHF_COMDEF: sindex = 23; break;
5932 default: break;
5933 }
5934 break;
5935 case EM_PPC:
5936 if (flag == SHF_PPC_VLE)
5937 sindex = 25;
5938 break;
5939
5940 default:
5941 break;
5942 }
5943 }
5944
5945 if (sindex != -1)
5946 {
5947 if (p != buff + field_size + 4)
5948 {
5949 if (size < (10 + 2))
5950 {
5951 warn (_("Internal error: not enough buffer room for section flag info"));
5952 return _("<unknown>");
5953 }
5954 size -= 2;
5955 *p++ = ',';
5956 *p++ = ' ';
5957 }
5958
5959 size -= flags [sindex].len;
5960 p = stpcpy (p, flags [sindex].str);
5961 }
5962 else if (flag & SHF_MASKOS)
5963 os_flags |= flag;
5964 else if (flag & SHF_MASKPROC)
5965 proc_flags |= flag;
5966 else
5967 unknown_flags |= flag;
5968 }
5969 else
5970 {
5971 switch (flag)
5972 {
5973 case SHF_WRITE: *p = 'W'; break;
5974 case SHF_ALLOC: *p = 'A'; break;
5975 case SHF_EXECINSTR: *p = 'X'; break;
5976 case SHF_MERGE: *p = 'M'; break;
5977 case SHF_STRINGS: *p = 'S'; break;
5978 case SHF_INFO_LINK: *p = 'I'; break;
5979 case SHF_LINK_ORDER: *p = 'L'; break;
5980 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5981 case SHF_GROUP: *p = 'G'; break;
5982 case SHF_TLS: *p = 'T'; break;
5983 case SHF_EXCLUDE: *p = 'E'; break;
5984 case SHF_COMPRESSED: *p = 'C'; break;
5985 case SHF_GNU_MBIND: *p = 'D'; break;
5986
5987 default:
5988 if ((filedata->file_header.e_machine == EM_X86_64
5989 || filedata->file_header.e_machine == EM_L1OM
5990 || filedata->file_header.e_machine == EM_K1OM)
5991 && flag == SHF_X86_64_LARGE)
5992 *p = 'l';
5993 else if (filedata->file_header.e_machine == EM_ARM
5994 && flag == SHF_ARM_PURECODE)
5995 *p = 'y';
5996 else if (filedata->file_header.e_machine == EM_PPC
5997 && flag == SHF_PPC_VLE)
5998 *p = 'v';
5999 else if (flag & SHF_MASKOS)
6000 {
6001 *p = 'o';
6002 sh_flags &= ~ SHF_MASKOS;
6003 }
6004 else if (flag & SHF_MASKPROC)
6005 {
6006 *p = 'p';
6007 sh_flags &= ~ SHF_MASKPROC;
6008 }
6009 else
6010 *p = 'x';
6011 break;
6012 }
6013 p++;
6014 }
6015 }
6016
6017 if (do_section_details)
6018 {
6019 if (os_flags)
6020 {
6021 size -= 5 + field_size;
6022 if (p != buff + field_size + 4)
6023 {
6024 if (size < (2 + 1))
6025 {
6026 warn (_("Internal error: not enough buffer room for section flag info"));
6027 return _("<unknown>");
6028 }
6029 size -= 2;
6030 *p++ = ',';
6031 *p++ = ' ';
6032 }
6033 sprintf (p, "OS (%*.*lx)", field_size, field_size,
6034 (unsigned long) os_flags);
6035 p += 5 + field_size;
6036 }
6037 if (proc_flags)
6038 {
6039 size -= 7 + field_size;
6040 if (p != buff + field_size + 4)
6041 {
6042 if (size < (2 + 1))
6043 {
6044 warn (_("Internal error: not enough buffer room for section flag info"));
6045 return _("<unknown>");
6046 }
6047 size -= 2;
6048 *p++ = ',';
6049 *p++ = ' ';
6050 }
6051 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
6052 (unsigned long) proc_flags);
6053 p += 7 + field_size;
6054 }
6055 if (unknown_flags)
6056 {
6057 size -= 10 + field_size;
6058 if (p != buff + field_size + 4)
6059 {
6060 if (size < (2 + 1))
6061 {
6062 warn (_("Internal error: not enough buffer room for section flag info"));
6063 return _("<unknown>");
6064 }
6065 size -= 2;
6066 *p++ = ',';
6067 *p++ = ' ';
6068 }
6069 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
6070 (unsigned long) unknown_flags);
6071 p += 10 + field_size;
6072 }
6073 }
6074
6075 *p = '\0';
6076 return buff;
6077}
6078
6079static unsigned int
6080get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
6081{
6082 if (is_32bit_elf)
6083 {
6084 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
6085
6086 if (size < sizeof (* echdr))
6087 {
6088 error (_("Compressed section is too small even for a compression header\n"));
6089 return 0;
6090 }
6091
6092 chdr->ch_type = BYTE_GET (echdr->ch_type);
6093 chdr->ch_size = BYTE_GET (echdr->ch_size);
6094 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
6095 return sizeof (*echdr);
6096 }
6097 else
6098 {
6099 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
6100
6101 if (size < sizeof (* echdr))
6102 {
6103 error (_("Compressed section is too small even for a compression header\n"));
6104 return 0;
6105 }
6106
6107 chdr->ch_type = BYTE_GET (echdr->ch_type);
6108 chdr->ch_size = BYTE_GET (echdr->ch_size);
6109 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
6110 return sizeof (*echdr);
6111 }
6112}
6113
6114static bfd_boolean
6115process_section_headers (Filedata * filedata)
6116{
6117 Elf_Internal_Shdr * section;
6118 unsigned int i;
6119
6120 filedata->section_headers = NULL;
6121
6122 if (filedata->file_header.e_shnum == 0)
6123 {
6124 /* PR binutils/12467. */
6125 if (filedata->file_header.e_shoff != 0)
6126 {
6127 warn (_("possibly corrupt ELF file header - it has a non-zero"
6128 " section header offset, but no section headers\n"));
6129 return FALSE;
6130 }
6131 else if (do_sections)
6132 printf (_("\nThere are no sections in this file.\n"));
6133
6134 return TRUE;
6135 }
6136
6137 if (do_sections && !do_header)
6138 printf (ngettext ("There is %d section header, "
6139 "starting at offset 0x%lx:\n",
6140 "There are %d section headers, "
6141 "starting at offset 0x%lx:\n",
6142 filedata->file_header.e_shnum),
6143 filedata->file_header.e_shnum,
6144 (unsigned long) filedata->file_header.e_shoff);
6145
6146 if (is_32bit_elf)
6147 {
6148 if (! get_32bit_section_headers (filedata, FALSE))
6149 return FALSE;
6150 }
6151 else
6152 {
6153 if (! get_64bit_section_headers (filedata, FALSE))
6154 return FALSE;
6155 }
6156
6157 /* Read in the string table, so that we have names to display. */
6158 if (filedata->file_header.e_shstrndx != SHN_UNDEF
6159 && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
6160 {
6161 section = filedata->section_headers + filedata->file_header.e_shstrndx;
6162
6163 if (section->sh_size != 0)
6164 {
6165 filedata->string_table = (char *) get_data (NULL, filedata, section->sh_offset,
6166 1, section->sh_size,
6167 _("string table"));
6168
6169 filedata->string_table_length = filedata->string_table != NULL ? section->sh_size : 0;
6170 }
6171 }
6172
6173 /* Scan the sections for the dynamic symbol table
6174 and dynamic string table and debug sections. */
6175 dynamic_symbols = NULL;
6176 dynamic_strings = NULL;
6177 dynamic_syminfo = NULL;
6178 symtab_shndx_list = NULL;
6179
6180 eh_addr_size = is_32bit_elf ? 4 : 8;
6181 switch (filedata->file_header.e_machine)
6182 {
6183 case EM_MIPS:
6184 case EM_MIPS_RS3_LE:
6185 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6186 FDE addresses. However, the ABI also has a semi-official ILP32
6187 variant for which the normal FDE address size rules apply.
6188
6189 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6190 section, where XX is the size of longs in bits. Unfortunately,
6191 earlier compilers provided no way of distinguishing ILP32 objects
6192 from LP64 objects, so if there's any doubt, we should assume that
6193 the official LP64 form is being used. */
6194 if ((filedata->file_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
6195 && find_section (filedata, ".gcc_compiled_long32") == NULL)
6196 eh_addr_size = 8;
6197 break;
6198
6199 case EM_H8_300:
6200 case EM_H8_300H:
6201 switch (filedata->file_header.e_flags & EF_H8_MACH)
6202 {
6203 case E_H8_MACH_H8300:
6204 case E_H8_MACH_H8300HN:
6205 case E_H8_MACH_H8300SN:
6206 case E_H8_MACH_H8300SXN:
6207 eh_addr_size = 2;
6208 break;
6209 case E_H8_MACH_H8300H:
6210 case E_H8_MACH_H8300S:
6211 case E_H8_MACH_H8300SX:
6212 eh_addr_size = 4;
6213 break;
6214 }
6215 break;
6216
6217 case EM_M32C_OLD:
6218 case EM_M32C:
6219 switch (filedata->file_header.e_flags & EF_M32C_CPU_MASK)
6220 {
6221 case EF_M32C_CPU_M16C:
6222 eh_addr_size = 2;
6223 break;
6224 }
6225 break;
6226 }
6227
6228#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6229 do \
6230 { \
6231 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6232 if (section->sh_entsize != expected_entsize) \
6233 { \
6234 char buf[40]; \
6235 sprintf_vma (buf, section->sh_entsize); \
6236 /* Note: coded this way so that there is a single string for \
6237 translation. */ \
6238 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6239 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6240 (unsigned) expected_entsize); \
6241 section->sh_entsize = expected_entsize; \
6242 } \
6243 } \
6244 while (0)
6245
6246#define CHECK_ENTSIZE(section, i, type) \
6247 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6248 sizeof (Elf64_External_##type))
6249
6250 for (i = 0, section = filedata->section_headers;
6251 i < filedata->file_header.e_shnum;
6252 i++, section++)
6253 {
6254 char * name = SECTION_NAME (section);
6255
6256 if (section->sh_type == SHT_DYNSYM)
6257 {
6258 if (dynamic_symbols != NULL)
6259 {
6260 error (_("File contains multiple dynamic symbol tables\n"));
6261 continue;
6262 }
6263
6264 CHECK_ENTSIZE (section, i, Sym);
6265 dynamic_symbols = GET_ELF_SYMBOLS (filedata, section, & num_dynamic_syms);
6266 }
6267 else if (section->sh_type == SHT_STRTAB
6268 && streq (name, ".dynstr"))
6269 {
6270 if (dynamic_strings != NULL)
6271 {
6272 error (_("File contains multiple dynamic string tables\n"));
6273 continue;
6274 }
6275
6276 dynamic_strings = (char *) get_data (NULL, filedata, section->sh_offset,
6277 1, section->sh_size,
6278 _("dynamic strings"));
6279 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
6280 }
6281 else if (section->sh_type == SHT_SYMTAB_SHNDX)
6282 {
6283 elf_section_list * entry = xmalloc (sizeof * entry);
6284
6285 entry->hdr = section;
6286 entry->next = symtab_shndx_list;
6287 symtab_shndx_list = entry;
6288 }
6289 else if (section->sh_type == SHT_SYMTAB)
6290 CHECK_ENTSIZE (section, i, Sym);
6291 else if (section->sh_type == SHT_GROUP)
6292 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6293 else if (section->sh_type == SHT_REL)
6294 CHECK_ENTSIZE (section, i, Rel);
6295 else if (section->sh_type == SHT_RELA)
6296 CHECK_ENTSIZE (section, i, Rela);
6297 else if ((do_debugging || do_debug_info || do_debug_abbrevs
6298 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
6299 || do_debug_aranges || do_debug_frames || do_debug_macinfo
6300 || do_debug_str || do_debug_loc || do_debug_ranges
6301 || do_debug_addr || do_debug_cu_index || do_debug_links)
6302 && (const_strneq (name, ".debug_")
6303 || const_strneq (name, ".zdebug_")))
6304 {
6305 if (name[1] == 'z')
6306 name += sizeof (".zdebug_") - 1;
6307 else
6308 name += sizeof (".debug_") - 1;
6309
6310 if (do_debugging
6311 || (do_debug_info && const_strneq (name, "info"))
6312 || (do_debug_info && const_strneq (name, "types"))
6313 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
6314 || (do_debug_lines && strcmp (name, "line") == 0)
6315 || (do_debug_lines && const_strneq (name, "line."))
6316 || (do_debug_pubnames && const_strneq (name, "pubnames"))
6317 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6318 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6319 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6320 || (do_debug_aranges && const_strneq (name, "aranges"))
6321 || (do_debug_ranges && const_strneq (name, "ranges"))
6322 || (do_debug_ranges && const_strneq (name, "rnglists"))
6323 || (do_debug_frames && const_strneq (name, "frame"))
6324 || (do_debug_macinfo && const_strneq (name, "macinfo"))
6325 || (do_debug_macinfo && const_strneq (name, "macro"))
6326 || (do_debug_str && const_strneq (name, "str"))
6327 || (do_debug_loc && const_strneq (name, "loc"))
6328 || (do_debug_loc && const_strneq (name, "loclists"))
6329 || (do_debug_addr && const_strneq (name, "addr"))
6330 || (do_debug_cu_index && const_strneq (name, "cu_index"))
6331 || (do_debug_cu_index && const_strneq (name, "tu_index"))
6332 )
6333 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6334 }
6335 /* Linkonce section to be combined with .debug_info at link time. */
6336 else if ((do_debugging || do_debug_info)
6337 && const_strneq (name, ".gnu.linkonce.wi."))
6338 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6339 else if (do_debug_frames && streq (name, ".eh_frame"))
6340 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6341 else if (do_gdb_index && (streq (name, ".gdb_index")
6342 || streq (name, ".debug_names")))
6343 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6344 /* Trace sections for Itanium VMS. */
6345 else if ((do_debugging || do_trace_info || do_trace_abbrevs
6346 || do_trace_aranges)
6347 && const_strneq (name, ".trace_"))
6348 {
6349 name += sizeof (".trace_") - 1;
6350
6351 if (do_debugging
6352 || (do_trace_info && streq (name, "info"))
6353 || (do_trace_abbrevs && streq (name, "abbrev"))
6354 || (do_trace_aranges && streq (name, "aranges"))
6355 )
6356 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6357 }
6358 else if ((do_debugging || do_debug_links)
6359 && (const_strneq (name, ".gnu_debuglink")
6360 || const_strneq (name, ".gnu_debugaltlink")))
6361 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6362 }
6363
6364 if (! do_sections)
6365 return TRUE;
6366
6367 if (filedata->file_header.e_shnum > 1)
6368 printf (_("\nSection Headers:\n"));
6369 else
6370 printf (_("\nSection Header:\n"));
6371
6372 if (is_32bit_elf)
6373 {
6374 if (do_section_details)
6375 {
6376 printf (_(" [Nr] Name\n"));
6377 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6378 }
6379 else
6380 printf
6381 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6382 }
6383 else if (do_wide)
6384 {
6385 if (do_section_details)
6386 {
6387 printf (_(" [Nr] Name\n"));
6388 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6389 }
6390 else
6391 printf
6392 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6393 }
6394 else
6395 {
6396 if (do_section_details)
6397 {
6398 printf (_(" [Nr] Name\n"));
6399 printf (_(" Type Address Offset Link\n"));
6400 printf (_(" Size EntSize Info Align\n"));
6401 }
6402 else
6403 {
6404 printf (_(" [Nr] Name Type Address Offset\n"));
6405 printf (_(" Size EntSize Flags Link Info Align\n"));
6406 }
6407 }
6408
6409 if (do_section_details)
6410 printf (_(" Flags\n"));
6411
6412 for (i = 0, section = filedata->section_headers;
6413 i < filedata->file_header.e_shnum;
6414 i++, section++)
6415 {
6416 /* Run some sanity checks on the section header. */
6417
6418 /* Check the sh_link field. */
6419 switch (section->sh_type)
6420 {
6421 case SHT_REL:
6422 case SHT_RELA:
6423 if (section->sh_link == 0
6424 && (filedata->file_header.e_type == ET_EXEC
6425 || filedata->file_header.e_type == ET_DYN))
6426 /* A dynamic relocation section where all entries use a
6427 zero symbol index need not specify a symtab section. */
6428 break;
6429 /* Fall through. */
6430 case SHT_SYMTAB_SHNDX:
6431 case SHT_GROUP:
6432 case SHT_HASH:
6433 case SHT_GNU_HASH:
6434 case SHT_GNU_versym:
6435 if (section->sh_link == 0
6436 || section->sh_link >= filedata->file_header.e_shnum
6437 || (filedata->section_headers[section->sh_link].sh_type != SHT_SYMTAB
6438 && filedata->section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6439 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6440 i, section->sh_link);
6441 break;
6442
6443 case SHT_DYNAMIC:
6444 case SHT_SYMTAB:
6445 case SHT_DYNSYM:
6446 case SHT_GNU_verneed:
6447 case SHT_GNU_verdef:
6448 case SHT_GNU_LIBLIST:
6449 if (section->sh_link == 0
6450 || section->sh_link >= filedata->file_header.e_shnum
6451 || filedata->section_headers[section->sh_link].sh_type != SHT_STRTAB)
6452 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6453 i, section->sh_link);
6454 break;
6455
6456 case SHT_INIT_ARRAY:
6457 case SHT_FINI_ARRAY:
6458 case SHT_PREINIT_ARRAY:
6459 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6460 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6461 i, section->sh_link);
6462 break;
6463
6464 default:
6465 /* FIXME: Add support for target specific section types. */
6466#if 0 /* Currently we do not check other section types as there are too
6467 many special cases. Stab sections for example have a type
6468 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6469 section. */
6470 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6471 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6472 i, section->sh_link);
6473#endif
6474 break;
6475 }
6476
6477 /* Check the sh_info field. */
6478 switch (section->sh_type)
6479 {
6480 case SHT_REL:
6481 case SHT_RELA:
6482 if (section->sh_info == 0
6483 && (filedata->file_header.e_type == ET_EXEC
6484 || filedata->file_header.e_type == ET_DYN))
6485 /* Dynamic relocations apply to segments, so they do not
6486 need to specify the section they relocate. */
6487 break;
6488 if (section->sh_info == 0
6489 || section->sh_info >= filedata->file_header.e_shnum
6490 || (filedata->section_headers[section->sh_info].sh_type != SHT_PROGBITS
6491 && filedata->section_headers[section->sh_info].sh_type != SHT_NOBITS
6492 && filedata->section_headers[section->sh_info].sh_type != SHT_NOTE
6493 && filedata->section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6494 && filedata->section_headers[section->sh_info].sh_type != SHT_FINI_ARRAY
6495 && filedata->section_headers[section->sh_info].sh_type != SHT_PREINIT_ARRAY
6496 /* FIXME: Are other section types valid ? */
6497 && filedata->section_headers[section->sh_info].sh_type < SHT_LOOS))
6498 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6499 i, section->sh_info);
6500 break;
6501
6502 case SHT_DYNAMIC:
6503 case SHT_HASH:
6504 case SHT_SYMTAB_SHNDX:
6505 case SHT_INIT_ARRAY:
6506 case SHT_FINI_ARRAY:
6507 case SHT_PREINIT_ARRAY:
6508 if (section->sh_info != 0)
6509 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6510 i, section->sh_info);
6511 break;
6512
6513 case SHT_GROUP:
6514 case SHT_SYMTAB:
6515 case SHT_DYNSYM:
6516 /* A symbol index - we assume that it is valid. */
6517 break;
6518
6519 default:
6520 /* FIXME: Add support for target specific section types. */
6521 if (section->sh_type == SHT_NOBITS)
6522 /* NOBITS section headers with non-zero sh_info fields can be
6523 created when a binary is stripped of everything but its debug
6524 information. The stripped sections have their headers
6525 preserved but their types set to SHT_NOBITS. So do not check
6526 this type of section. */
6527 ;
6528 else if (section->sh_flags & SHF_INFO_LINK)
6529 {
6530 if (section->sh_info < 1 || section->sh_info >= filedata->file_header.e_shnum)
6531 warn (_("[%2u]: Expected link to another section in info field"), i);
6532 }
6533 else if (section->sh_type < SHT_LOOS
6534 && (section->sh_flags & SHF_GNU_MBIND) == 0
6535 && section->sh_info != 0)
6536 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6537 i, section->sh_info);
6538 break;
6539 }
6540
6541 /* Check the sh_size field. */
6542 if (section->sh_size > filedata->file_size
6543 && section->sh_type != SHT_NOBITS
6544 && section->sh_type != SHT_NULL
6545 && section->sh_type < SHT_LOOS)
6546 warn (_("Size of section %u is larger than the entire file!\n"), i);
6547
6548 printf (" [%2u] ", i);
6549 if (do_section_details)
6550 printf ("%s\n ", printable_section_name (filedata, section));
6551 else
6552 print_symbol (-17, SECTION_NAME (section));
6553
6554 printf (do_wide ? " %-15s " : " %-15.15s ",
6555 get_section_type_name (filedata, section->sh_type));
6556
6557 if (is_32bit_elf)
6558 {
6559 const char * link_too_big = NULL;
6560
6561 print_vma (section->sh_addr, LONG_HEX);
6562
6563 printf ( " %6.6lx %6.6lx %2.2lx",
6564 (unsigned long) section->sh_offset,
6565 (unsigned long) section->sh_size,
6566 (unsigned long) section->sh_entsize);
6567
6568 if (do_section_details)
6569 fputs (" ", stdout);
6570 else
6571 printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6572
6573 if (section->sh_link >= filedata->file_header.e_shnum)
6574 {
6575 link_too_big = "";
6576 /* The sh_link value is out of range. Normally this indicates
6577 an error but it can have special values in Solaris binaries. */
6578 switch (filedata->file_header.e_machine)
6579 {
6580 case EM_386:
6581 case EM_IAMCU:
6582 case EM_X86_64:
6583 case EM_L1OM:
6584 case EM_K1OM:
6585 case EM_OLD_SPARCV9:
6586 case EM_SPARC32PLUS:
6587 case EM_SPARCV9:
6588 case EM_SPARC:
6589 if (section->sh_link == (SHN_BEFORE & 0xffff))
6590 link_too_big = "BEFORE";
6591 else if (section->sh_link == (SHN_AFTER & 0xffff))
6592 link_too_big = "AFTER";
6593 break;
6594 default:
6595 break;
6596 }
6597 }
6598
6599 if (do_section_details)
6600 {
6601 if (link_too_big != NULL && * link_too_big)
6602 printf ("<%s> ", link_too_big);
6603 else
6604 printf ("%2u ", section->sh_link);
6605 printf ("%3u %2lu\n", section->sh_info,
6606 (unsigned long) section->sh_addralign);
6607 }
6608 else
6609 printf ("%2u %3u %2lu\n",
6610 section->sh_link,
6611 section->sh_info,
6612 (unsigned long) section->sh_addralign);
6613
6614 if (link_too_big && ! * link_too_big)
6615 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6616 i, section->sh_link);
6617 }
6618 else if (do_wide)
6619 {
6620 print_vma (section->sh_addr, LONG_HEX);
6621
6622 if ((long) section->sh_offset == section->sh_offset)
6623 printf (" %6.6lx", (unsigned long) section->sh_offset);
6624 else
6625 {
6626 putchar (' ');
6627 print_vma (section->sh_offset, LONG_HEX);
6628 }
6629
6630 if ((unsigned long) section->sh_size == section->sh_size)
6631 printf (" %6.6lx", (unsigned long) section->sh_size);
6632 else
6633 {
6634 putchar (' ');
6635 print_vma (section->sh_size, LONG_HEX);
6636 }
6637
6638 if ((unsigned long) section->sh_entsize == section->sh_entsize)
6639 printf (" %2.2lx", (unsigned long) section->sh_entsize);
6640 else
6641 {
6642 putchar (' ');
6643 print_vma (section->sh_entsize, LONG_HEX);
6644 }
6645
6646 if (do_section_details)
6647 fputs (" ", stdout);
6648 else
6649 printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6650
6651 printf ("%2u %3u ", section->sh_link, section->sh_info);
6652
6653 if ((unsigned long) section->sh_addralign == section->sh_addralign)
6654 printf ("%2lu\n", (unsigned long) section->sh_addralign);
6655 else
6656 {
6657 print_vma (section->sh_addralign, DEC);
6658 putchar ('\n');
6659 }
6660 }
6661 else if (do_section_details)
6662 {
6663 putchar (' ');
6664 print_vma (section->sh_addr, LONG_HEX);
6665 if ((long) section->sh_offset == section->sh_offset)
6666 printf (" %16.16lx", (unsigned long) section->sh_offset);
6667 else
6668 {
6669 printf (" ");
6670 print_vma (section->sh_offset, LONG_HEX);
6671 }
6672 printf (" %u\n ", section->sh_link);
6673 print_vma (section->sh_size, LONG_HEX);
6674 putchar (' ');
6675 print_vma (section->sh_entsize, LONG_HEX);
6676
6677 printf (" %-16u %lu\n",
6678 section->sh_info,
6679 (unsigned long) section->sh_addralign);
6680 }
6681 else
6682 {
6683 putchar (' ');
6684 print_vma (section->sh_addr, LONG_HEX);
6685 if ((long) section->sh_offset == section->sh_offset)
6686 printf (" %8.8lx", (unsigned long) section->sh_offset);
6687 else
6688 {
6689 printf (" ");
6690 print_vma (section->sh_offset, LONG_HEX);
6691 }
6692 printf ("\n ");
6693 print_vma (section->sh_size, LONG_HEX);
6694 printf (" ");
6695 print_vma (section->sh_entsize, LONG_HEX);
6696
6697 printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6698
6699 printf (" %2u %3u %lu\n",
6700 section->sh_link,
6701 section->sh_info,
6702 (unsigned long) section->sh_addralign);
6703 }
6704
6705 if (do_section_details)
6706 {
6707 printf (" %s\n", get_elf_section_flags (filedata, section->sh_flags));
6708 if ((section->sh_flags & SHF_COMPRESSED) != 0)
6709 {
6710 /* Minimum section size is 12 bytes for 32-bit compression
6711 header + 12 bytes for compressed data header. */
6712 unsigned char buf[24];
6713
6714 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6715 if (get_data (&buf, filedata, section->sh_offset, 1,
6716 sizeof (buf), _("compression header")))
6717 {
6718 Elf_Internal_Chdr chdr;
6719
6720 (void) get_compression_header (&chdr, buf, sizeof (buf));
6721
6722 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6723 printf (" ZLIB, ");
6724 else
6725 printf (_(" [<unknown>: 0x%x], "),
6726 chdr.ch_type);
6727 print_vma (chdr.ch_size, LONG_HEX);
6728 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6729 }
6730 }
6731 }
6732 }
6733
6734 if (!do_section_details)
6735 {
6736 /* The ordering of the letters shown here matches the ordering of the
6737 corresponding SHF_xxx values, and hence the order in which these
6738 letters will be displayed to the user. */
6739 printf (_("Key to Flags:\n\
6740 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6741 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6742 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6743 if (filedata->file_header.e_machine == EM_X86_64
6744 || filedata->file_header.e_machine == EM_L1OM
6745 || filedata->file_header.e_machine == EM_K1OM)
6746 printf (_("l (large), "));
6747 else if (filedata->file_header.e_machine == EM_ARM)
6748 printf (_("y (purecode), "));
6749 else if (filedata->file_header.e_machine == EM_PPC)
6750 printf (_("v (VLE), "));
6751 printf ("p (processor specific)\n");
6752 }
6753
6754 return TRUE;
6755}
6756
6757static const char *
6758get_group_flags (unsigned int flags)
6759{
6760 static char buff[128];
6761
6762 if (flags == 0)
6763 return "";
6764 else if (flags == GRP_COMDAT)
6765 return "COMDAT ";
6766
6767 snprintf (buff, 14, _("[0x%x: "), flags);
6768
6769 flags &= ~ GRP_COMDAT;
6770 if (flags & GRP_MASKOS)
6771 {
6772 strcat (buff, "<OS specific>");
6773 flags &= ~ GRP_MASKOS;
6774 }
6775
6776 if (flags & GRP_MASKPROC)
6777 {
6778 strcat (buff, "<PROC specific>");
6779 flags &= ~ GRP_MASKPROC;
6780 }
6781
6782 if (flags)
6783 strcat (buff, "<unknown>");
6784
6785 strcat (buff, "]");
6786 return buff;
6787}
6788
6789static bfd_boolean
6790process_section_groups (Filedata * filedata)
6791{
6792 Elf_Internal_Shdr * section;
6793 unsigned int i;
6794 struct group * group;
6795 Elf_Internal_Shdr * symtab_sec;
6796 Elf_Internal_Shdr * strtab_sec;
6797 Elf_Internal_Sym * symtab;
6798 unsigned long num_syms;
6799 char * strtab;
6800 size_t strtab_size;
6801
6802 /* Don't process section groups unless needed. */
6803 if (!do_unwind && !do_section_groups)
6804 return TRUE;
6805
6806 if (filedata->file_header.e_shnum == 0)
6807 {
6808 if (do_section_groups)
6809 printf (_("\nThere are no sections to group in this file.\n"));
6810
6811 return TRUE;
6812 }
6813
6814 if (filedata->section_headers == NULL)
6815 {
6816 error (_("Section headers are not available!\n"));
6817 /* PR 13622: This can happen with a corrupt ELF header. */
6818 return FALSE;
6819 }
6820
6821 section_headers_groups = (struct group **) calloc (filedata->file_header.e_shnum,
6822 sizeof (struct group *));
6823
6824 if (section_headers_groups == NULL)
6825 {
6826 error (_("Out of memory reading %u section group headers\n"),
6827 filedata->file_header.e_shnum);
6828 return FALSE;
6829 }
6830
6831 /* Scan the sections for the group section. */
6832 group_count = 0;
6833 for (i = 0, section = filedata->section_headers;
6834 i < filedata->file_header.e_shnum;
6835 i++, section++)
6836 if (section->sh_type == SHT_GROUP)
6837 group_count++;
6838
6839 if (group_count == 0)
6840 {
6841 if (do_section_groups)
6842 printf (_("\nThere are no section groups in this file.\n"));
6843
6844 return TRUE;
6845 }
6846
6847 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6848
6849 if (section_groups == NULL)
6850 {
6851 error (_("Out of memory reading %lu groups\n"),
6852 (unsigned long) group_count);
6853 return FALSE;
6854 }
6855
6856 symtab_sec = NULL;
6857 strtab_sec = NULL;
6858 symtab = NULL;
6859 num_syms = 0;
6860 strtab = NULL;
6861 strtab_size = 0;
6862 for (i = 0, section = filedata->section_headers, group = section_groups;
6863 i < filedata->file_header.e_shnum;
6864 i++, section++)
6865 {
6866 if (section->sh_type == SHT_GROUP)
6867 {
6868 const char * name = printable_section_name (filedata, section);
6869 const char * group_name;
6870 unsigned char * start;
6871 unsigned char * indices;
6872 unsigned int entry, j, size;
6873 Elf_Internal_Shdr * sec;
6874 Elf_Internal_Sym * sym;
6875
6876 /* Get the symbol table. */
6877 if (section->sh_link >= filedata->file_header.e_shnum
6878 || ((sec = filedata->section_headers + section->sh_link)->sh_type
6879 != SHT_SYMTAB))
6880 {
6881 error (_("Bad sh_link in group section `%s'\n"), name);
6882 continue;
6883 }
6884
6885 if (symtab_sec != sec)
6886 {
6887 symtab_sec = sec;
6888 if (symtab)
6889 free (symtab);
6890 symtab = GET_ELF_SYMBOLS (filedata, symtab_sec, & num_syms);
6891 }
6892
6893 if (symtab == NULL)
6894 {
6895 error (_("Corrupt header in group section `%s'\n"), name);
6896 continue;
6897 }
6898
6899 if (section->sh_info >= num_syms)
6900 {
6901 error (_("Bad sh_info in group section `%s'\n"), name);
6902 continue;
6903 }
6904
6905 sym = symtab + section->sh_info;
6906
6907 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6908 {
6909 if (sym->st_shndx == 0
6910 || sym->st_shndx >= filedata->file_header.e_shnum)
6911 {
6912 error (_("Bad sh_info in group section `%s'\n"), name);
6913 continue;
6914 }
6915
6916 group_name = SECTION_NAME (filedata->section_headers + sym->st_shndx);
6917 strtab_sec = NULL;
6918 if (strtab)
6919 free (strtab);
6920 strtab = NULL;
6921 strtab_size = 0;
6922 }
6923 else
6924 {
6925 /* Get the string table. */
6926 if (symtab_sec->sh_link >= filedata->file_header.e_shnum)
6927 {
6928 strtab_sec = NULL;
6929 if (strtab)
6930 free (strtab);
6931 strtab = NULL;
6932 strtab_size = 0;
6933 }
6934 else if (strtab_sec
6935 != (sec = filedata->section_headers + symtab_sec->sh_link))
6936 {
6937 strtab_sec = sec;
6938 if (strtab)
6939 free (strtab);
6940
6941 strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
6942 1, strtab_sec->sh_size,
6943 _("string table"));
6944 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6945 }
6946 group_name = sym->st_name < strtab_size
6947 ? strtab + sym->st_name : _("<corrupt>");
6948 }
6949
6950 /* PR 17531: file: loop. */
6951 if (section->sh_entsize > section->sh_size)
6952 {
6953 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6954 printable_section_name (filedata, section),
6955 (unsigned long) section->sh_entsize,
6956 (unsigned long) section->sh_size);
6957 continue;
6958 }
6959
6960 start = (unsigned char *) get_data (NULL, filedata, section->sh_offset,
6961 1, section->sh_size,
6962 _("section data"));
6963 if (start == NULL)
6964 continue;
6965
6966 indices = start;
6967 size = (section->sh_size / section->sh_entsize) - 1;
6968 entry = byte_get (indices, 4);
6969 indices += 4;
6970
6971 if (do_section_groups)
6972 {
6973 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6974 get_group_flags (entry), i, name, group_name, size);
6975
6976 printf (_(" [Index] Name\n"));
6977 }
6978
6979 group->group_index = i;
6980
6981 for (j = 0; j < size; j++)
6982 {
6983 struct group_list * g;
6984
6985 entry = byte_get (indices, 4);
6986 indices += 4;
6987
6988 if (entry >= filedata->file_header.e_shnum)
6989 {
6990 static unsigned num_group_errors = 0;
6991
6992 if (num_group_errors ++ < 10)
6993 {
6994 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6995 entry, i, filedata->file_header.e_shnum - 1);
6996 if (num_group_errors == 10)
6997 warn (_("Further error messages about overlarge group section indices suppressed\n"));
6998 }
6999 continue;
7000 }
7001
7002 if (section_headers_groups [entry] != NULL)
7003 {
7004 if (entry)
7005 {
7006 static unsigned num_errs = 0;
7007
7008 if (num_errs ++ < 10)
7009 {
7010 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7011 entry, i,
7012 section_headers_groups [entry]->group_index);
7013 if (num_errs == 10)
7014 warn (_("Further error messages about already contained group sections suppressed\n"));
7015 }
7016 continue;
7017 }
7018 else
7019 {
7020 /* Intel C/C++ compiler may put section 0 in a
7021 section group. We just warn it the first time
7022 and ignore it afterwards. */
7023 static bfd_boolean warned = FALSE;
7024 if (!warned)
7025 {
7026 error (_("section 0 in group section [%5u]\n"),
7027 section_headers_groups [entry]->group_index);
7028 warned = TRUE;
7029 }
7030 }
7031 }
7032
7033 section_headers_groups [entry] = group;
7034
7035 if (do_section_groups)
7036 {
7037 sec = filedata->section_headers + entry;
7038 printf (" [%5u] %s\n", entry, printable_section_name (filedata, sec));
7039 }
7040
7041 g = (struct group_list *) xmalloc (sizeof (struct group_list));
7042 g->section_index = entry;
7043 g->next = group->root;
7044 group->root = g;
7045 }
7046
7047 if (start)
7048 free (start);
7049
7050 group++;
7051 }
7052 }
7053
7054 if (symtab)
7055 free (symtab);
7056 if (strtab)
7057 free (strtab);
7058 return TRUE;
7059}
7060
7061/* Data used to display dynamic fixups. */
7062
7063struct ia64_vms_dynfixup
7064{
7065 bfd_vma needed_ident; /* Library ident number. */
7066 bfd_vma needed; /* Index in the dstrtab of the library name. */
7067 bfd_vma fixup_needed; /* Index of the library. */
7068 bfd_vma fixup_rela_cnt; /* Number of fixups. */
7069 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
7070};
7071
7072/* Data used to display dynamic relocations. */
7073
7074struct ia64_vms_dynimgrela
7075{
7076 bfd_vma img_rela_cnt; /* Number of relocations. */
7077 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
7078};
7079
7080/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7081 library). */
7082
7083static bfd_boolean
7084dump_ia64_vms_dynamic_fixups (Filedata * filedata,
7085 struct ia64_vms_dynfixup * fixup,
7086 const char * strtab,
7087 unsigned int strtab_sz)
7088{
7089 Elf64_External_VMS_IMAGE_FIXUP * imfs;
7090 long i;
7091 const char * lib_name;
7092
7093 imfs = get_data (NULL, filedata, dynamic_addr + fixup->fixup_rela_off,
7094 1, fixup->fixup_rela_cnt * sizeof (*imfs),
7095 _("dynamic section image fixups"));
7096 if (!imfs)
7097 return FALSE;
7098
7099 if (fixup->needed < strtab_sz)
7100 lib_name = strtab + fixup->needed;
7101 else
7102 {
7103 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7104 (unsigned long) fixup->needed);
7105 lib_name = "???";
7106 }
7107 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7108 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
7109 printf
7110 (_("Seg Offset Type SymVec DataType\n"));
7111
7112 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
7113 {
7114 unsigned int type;
7115 const char *rtype;
7116
7117 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
7118 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
7119 type = BYTE_GET (imfs [i].type);
7120 rtype = elf_ia64_reloc_type (type);
7121 if (rtype == NULL)
7122 printf (" 0x%08x ", type);
7123 else
7124 printf (" %-32s ", rtype);
7125 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
7126 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
7127 }
7128
7129 free (imfs);
7130 return TRUE;
7131}
7132
7133/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7134
7135static bfd_boolean
7136dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *imgrela)
7137{
7138 Elf64_External_VMS_IMAGE_RELA *imrs;
7139 long i;
7140
7141 imrs = get_data (NULL, filedata, dynamic_addr + imgrela->img_rela_off,
7142 1, imgrela->img_rela_cnt * sizeof (*imrs),
7143 _("dynamic section image relocations"));
7144 if (!imrs)
7145 return FALSE;
7146
7147 printf (_("\nImage relocs\n"));
7148 printf
7149 (_("Seg Offset Type Addend Seg Sym Off\n"));
7150
7151 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
7152 {
7153 unsigned int type;
7154 const char *rtype;
7155
7156 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
7157 printf ("%08" BFD_VMA_FMT "x ",
7158 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
7159 type = BYTE_GET (imrs [i].type);
7160 rtype = elf_ia64_reloc_type (type);
7161 if (rtype == NULL)
7162 printf ("0x%08x ", type);
7163 else
7164 printf ("%-31s ", rtype);
7165 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
7166 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
7167 printf ("%08" BFD_VMA_FMT "x\n",
7168 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
7169 }
7170
7171 free (imrs);
7172 return TRUE;
7173}
7174
7175/* Display IA-64 OpenVMS dynamic relocations and fixups. */
7176
7177static bfd_boolean
7178process_ia64_vms_dynamic_relocs (Filedata * filedata)
7179{
7180 struct ia64_vms_dynfixup fixup;
7181 struct ia64_vms_dynimgrela imgrela;
7182 Elf_Internal_Dyn *entry;
7183 bfd_vma strtab_off = 0;
7184 bfd_vma strtab_sz = 0;
7185 char *strtab = NULL;
7186 bfd_boolean res = TRUE;
7187
7188 memset (&fixup, 0, sizeof (fixup));
7189 memset (&imgrela, 0, sizeof (imgrela));
7190
7191 /* Note: the order of the entries is specified by the OpenVMS specs. */
7192 for (entry = dynamic_section;
7193 entry < dynamic_section + dynamic_nent;
7194 entry++)
7195 {
7196 switch (entry->d_tag)
7197 {
7198 case DT_IA_64_VMS_STRTAB_OFFSET:
7199 strtab_off = entry->d_un.d_val;
7200 break;
7201 case DT_STRSZ:
7202 strtab_sz = entry->d_un.d_val;
7203 if (strtab == NULL)
7204 strtab = get_data (NULL, filedata, dynamic_addr + strtab_off,
7205 1, strtab_sz, _("dynamic string section"));
7206 break;
7207
7208 case DT_IA_64_VMS_NEEDED_IDENT:
7209 fixup.needed_ident = entry->d_un.d_val;
7210 break;
7211 case DT_NEEDED:
7212 fixup.needed = entry->d_un.d_val;
7213 break;
7214 case DT_IA_64_VMS_FIXUP_NEEDED:
7215 fixup.fixup_needed = entry->d_un.d_val;
7216 break;
7217 case DT_IA_64_VMS_FIXUP_RELA_CNT:
7218 fixup.fixup_rela_cnt = entry->d_un.d_val;
7219 break;
7220 case DT_IA_64_VMS_FIXUP_RELA_OFF:
7221 fixup.fixup_rela_off = entry->d_un.d_val;
7222 if (! dump_ia64_vms_dynamic_fixups (filedata, &fixup, strtab, strtab_sz))
7223 res = FALSE;
7224 break;
7225 case DT_IA_64_VMS_IMG_RELA_CNT:
7226 imgrela.img_rela_cnt = entry->d_un.d_val;
7227 break;
7228 case DT_IA_64_VMS_IMG_RELA_OFF:
7229 imgrela.img_rela_off = entry->d_un.d_val;
7230 if (! dump_ia64_vms_dynamic_relocs (filedata, &imgrela))
7231 res = FALSE;
7232 break;
7233
7234 default:
7235 break;
7236 }
7237 }
7238
7239 if (strtab != NULL)
7240 free (strtab);
7241
7242 return res;
7243}
7244
7245static struct
7246{
7247 const char * name;
7248 int reloc;
7249 int size;
7250 int rela;
7251}
7252 dynamic_relocations [] =
7253{
7254 { "REL", DT_REL, DT_RELSZ, FALSE },
7255 { "RELA", DT_RELA, DT_RELASZ, TRUE },
7256 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
7257};
7258
7259/* Process the reloc section. */
7260
7261static bfd_boolean
7262process_relocs (Filedata * filedata)
7263{
7264 unsigned long rel_size;
7265 unsigned long rel_offset;
7266
7267 if (!do_reloc)
7268 return TRUE;
7269
7270 if (do_using_dynamic)
7271 {
7272 int is_rela;
7273 const char * name;
7274 bfd_boolean has_dynamic_reloc;
7275 unsigned int i;
7276
7277 has_dynamic_reloc = FALSE;
7278
7279 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7280 {
7281 is_rela = dynamic_relocations [i].rela;
7282 name = dynamic_relocations [i].name;
7283 rel_size = dynamic_info [dynamic_relocations [i].size];
7284 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
7285
7286 if (rel_size)
7287 has_dynamic_reloc = TRUE;
7288
7289 if (is_rela == UNKNOWN)
7290 {
7291 if (dynamic_relocations [i].reloc == DT_JMPREL)
7292 switch (dynamic_info[DT_PLTREL])
7293 {
7294 case DT_REL:
7295 is_rela = FALSE;
7296 break;
7297 case DT_RELA:
7298 is_rela = TRUE;
7299 break;
7300 }
7301 }
7302
7303 if (rel_size)
7304 {
7305 printf
7306 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7307 name, rel_offset, rel_size);
7308
7309 dump_relocations (filedata,
7310 offset_from_vma (filedata, rel_offset, rel_size),
7311 rel_size,
7312 dynamic_symbols, num_dynamic_syms,
7313 dynamic_strings, dynamic_strings_length,
7314 is_rela, TRUE /* is_dynamic */);
7315 }
7316 }
7317
7318 if (is_ia64_vms (filedata))
7319 if (process_ia64_vms_dynamic_relocs (filedata))
7320 has_dynamic_reloc = TRUE;
7321
7322 if (! has_dynamic_reloc)
7323 printf (_("\nThere are no dynamic relocations in this file.\n"));
7324 }
7325 else
7326 {
7327 Elf_Internal_Shdr * section;
7328 unsigned long i;
7329 bfd_boolean found = FALSE;
7330
7331 for (i = 0, section = filedata->section_headers;
7332 i < filedata->file_header.e_shnum;
7333 i++, section++)
7334 {
7335 if ( section->sh_type != SHT_RELA
7336 && section->sh_type != SHT_REL)
7337 continue;
7338
7339 rel_offset = section->sh_offset;
7340 rel_size = section->sh_size;
7341
7342 if (rel_size)
7343 {
7344 Elf_Internal_Shdr * strsec;
7345 int is_rela;
7346 unsigned long num_rela;
7347
7348 printf (_("\nRelocation section "));
7349
7350 if (filedata->string_table == NULL)
7351 printf ("%d", section->sh_name);
7352 else
7353 printf ("'%s'", printable_section_name (filedata, section));
7354
7355 num_rela = rel_size / section->sh_entsize;
7356 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7357 " at offset 0x%lx contains %lu entries:\n",
7358 num_rela),
7359 rel_offset, num_rela);
7360
7361 is_rela = section->sh_type == SHT_RELA;
7362
7363 if (section->sh_link != 0
7364 && section->sh_link < filedata->file_header.e_shnum)
7365 {
7366 Elf_Internal_Shdr * symsec;
7367 Elf_Internal_Sym * symtab;
7368 unsigned long nsyms;
7369 unsigned long strtablen = 0;
7370 char * strtab = NULL;
7371
7372 symsec = filedata->section_headers + section->sh_link;
7373 if (symsec->sh_type != SHT_SYMTAB
7374 && symsec->sh_type != SHT_DYNSYM)
7375 continue;
7376
7377 symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
7378
7379 if (symtab == NULL)
7380 continue;
7381
7382 if (symsec->sh_link != 0
7383 && symsec->sh_link < filedata->file_header.e_shnum)
7384 {
7385 strsec = filedata->section_headers + symsec->sh_link;
7386
7387 strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7388 1, strsec->sh_size,
7389 _("string table"));
7390 strtablen = strtab == NULL ? 0 : strsec->sh_size;
7391 }
7392
7393 dump_relocations (filedata, rel_offset, rel_size,
7394 symtab, nsyms, strtab, strtablen,
7395 is_rela,
7396 symsec->sh_type == SHT_DYNSYM);
7397 if (strtab)
7398 free (strtab);
7399 free (symtab);
7400 }
7401 else
7402 dump_relocations (filedata, rel_offset, rel_size,
7403 NULL, 0, NULL, 0, is_rela,
7404 FALSE /* is_dynamic */);
7405
7406 found = TRUE;
7407 }
7408 }
7409
7410 if (! found)
7411 {
7412 /* Users sometimes forget the -D option, so try to be helpful. */
7413 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7414 {
7415 if (dynamic_info [dynamic_relocations [i].size])
7416 {
7417 printf (_("\nThere are no static relocations in this file."));
7418 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7419
7420 break;
7421 }
7422 }
7423 if (i == ARRAY_SIZE (dynamic_relocations))
7424 printf (_("\nThere are no relocations in this file.\n"));
7425 }
7426 }
7427
7428 return TRUE;
7429}
7430
7431/* An absolute address consists of a section and an offset. If the
7432 section is NULL, the offset itself is the address, otherwise, the
7433 address equals to LOAD_ADDRESS(section) + offset. */
7434
7435struct absaddr
7436{
7437 unsigned short section;
7438 bfd_vma offset;
7439};
7440
7441/* Find the nearest symbol at or below ADDR. Returns the symbol
7442 name, if found, and the offset from the symbol to ADDR. */
7443
7444static void
7445find_symbol_for_address (Filedata * filedata,
7446 Elf_Internal_Sym * symtab,
7447 unsigned long nsyms,
7448 const char * strtab,
7449 unsigned long strtab_size,
7450 struct absaddr addr,
7451 const char ** symname,
7452 bfd_vma * offset)
7453{
7454 bfd_vma dist = 0x100000;
7455 Elf_Internal_Sym * sym;
7456 Elf_Internal_Sym * beg;
7457 Elf_Internal_Sym * end;
7458 Elf_Internal_Sym * best = NULL;
7459
7460 REMOVE_ARCH_BITS (addr.offset);
7461 beg = symtab;
7462 end = symtab + nsyms;
7463
7464 while (beg < end)
7465 {
7466 bfd_vma value;
7467
7468 sym = beg + (end - beg) / 2;
7469
7470 value = sym->st_value;
7471 REMOVE_ARCH_BITS (value);
7472
7473 if (sym->st_name != 0
7474 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7475 && addr.offset >= value
7476 && addr.offset - value < dist)
7477 {
7478 best = sym;
7479 dist = addr.offset - value;
7480 if (!dist)
7481 break;
7482 }
7483
7484 if (addr.offset < value)
7485 end = sym;
7486 else
7487 beg = sym + 1;
7488 }
7489
7490 if (best)
7491 {
7492 *symname = (best->st_name >= strtab_size
7493 ? _("<corrupt>") : strtab + best->st_name);
7494 *offset = dist;
7495 return;
7496 }
7497
7498 *symname = NULL;
7499 *offset = addr.offset;
7500}
7501
7502static /* signed */ int
7503symcmp (const void *p, const void *q)
7504{
7505 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7506 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7507
7508 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7509}
7510
7511/* Process the unwind section. */
7512
7513#include "unwind-ia64.h"
7514
7515struct ia64_unw_table_entry
7516{
7517 struct absaddr start;
7518 struct absaddr end;
7519 struct absaddr info;
7520};
7521
7522struct ia64_unw_aux_info
7523{
7524 struct ia64_unw_table_entry * table; /* Unwind table. */
7525 unsigned long table_len; /* Length of unwind table. */
7526 unsigned char * info; /* Unwind info. */
7527 unsigned long info_size; /* Size of unwind info. */
7528 bfd_vma info_addr; /* Starting address of unwind info. */
7529 bfd_vma seg_base; /* Starting address of segment. */
7530 Elf_Internal_Sym * symtab; /* The symbol table. */
7531 unsigned long nsyms; /* Number of symbols. */
7532 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7533 unsigned long nfuns; /* Number of entries in funtab. */
7534 char * strtab; /* The string table. */
7535 unsigned long strtab_size; /* Size of string table. */
7536};
7537
7538static bfd_boolean
7539dump_ia64_unwind (Filedata * filedata, struct ia64_unw_aux_info * aux)
7540{
7541 struct ia64_unw_table_entry * tp;
7542 unsigned long j, nfuns;
7543 int in_body;
7544 bfd_boolean res = TRUE;
7545
7546 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7547 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7548 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7549 aux->funtab[nfuns++] = aux->symtab[j];
7550 aux->nfuns = nfuns;
7551 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7552
7553 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7554 {
7555 bfd_vma stamp;
7556 bfd_vma offset;
7557 const unsigned char * dp;
7558 const unsigned char * head;
7559 const unsigned char * end;
7560 const char * procname;
7561
7562 find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7563 aux->strtab_size, tp->start, &procname, &offset);
7564
7565 fputs ("\n<", stdout);
7566
7567 if (procname)
7568 {
7569 fputs (procname, stdout);
7570
7571 if (offset)
7572 printf ("+%lx", (unsigned long) offset);
7573 }
7574
7575 fputs (">: [", stdout);
7576 print_vma (tp->start.offset, PREFIX_HEX);
7577 fputc ('-', stdout);
7578 print_vma (tp->end.offset, PREFIX_HEX);
7579 printf ("], info at +0x%lx\n",
7580 (unsigned long) (tp->info.offset - aux->seg_base));
7581
7582 /* PR 17531: file: 86232b32. */
7583 if (aux->info == NULL)
7584 continue;
7585
7586 offset = tp->info.offset;
7587 if (tp->info.section)
7588 {
7589 if (tp->info.section >= filedata->file_header.e_shnum)
7590 {
7591 warn (_("Invalid section %u in table entry %ld\n"),
7592 tp->info.section, (long) (tp - aux->table));
7593 res = FALSE;
7594 continue;
7595 }
7596 offset += filedata->section_headers[tp->info.section].sh_addr;
7597 }
7598 offset -= aux->info_addr;
7599 /* PR 17531: file: 0997b4d1. */
7600 if (offset >= aux->info_size
7601 || aux->info_size - offset < 8)
7602 {
7603 warn (_("Invalid offset %lx in table entry %ld\n"),
7604 (long) tp->info.offset, (long) (tp - aux->table));
7605 res = FALSE;
7606 continue;
7607 }
7608
7609 head = aux->info + offset;
7610 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7611
7612 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7613 (unsigned) UNW_VER (stamp),
7614 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7615 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7616 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7617 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7618
7619 if (UNW_VER (stamp) != 1)
7620 {
7621 printf (_("\tUnknown version.\n"));
7622 continue;
7623 }
7624
7625 in_body = 0;
7626 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7627 /* PR 17531: file: 16ceda89. */
7628 if (end > aux->info + aux->info_size)
7629 end = aux->info + aux->info_size;
7630 for (dp = head + 8; dp < end;)
7631 dp = unw_decode (dp, in_body, & in_body, end);
7632 }
7633
7634 free (aux->funtab);
7635
7636 return res;
7637}
7638
7639static bfd_boolean
7640slurp_ia64_unwind_table (Filedata * filedata,
7641 struct ia64_unw_aux_info * aux,
7642 Elf_Internal_Shdr * sec)
7643{
7644 unsigned long size, nrelas, i;
7645 Elf_Internal_Phdr * seg;
7646 struct ia64_unw_table_entry * tep;
7647 Elf_Internal_Shdr * relsec;
7648 Elf_Internal_Rela * rela;
7649 Elf_Internal_Rela * rp;
7650 unsigned char * table;
7651 unsigned char * tp;
7652 Elf_Internal_Sym * sym;
7653 const char * relname;
7654
7655 aux->table_len = 0;
7656
7657 /* First, find the starting address of the segment that includes
7658 this section: */
7659
7660 if (filedata->file_header.e_phnum)
7661 {
7662 if (! get_program_headers (filedata))
7663 return FALSE;
7664
7665 for (seg = filedata->program_headers;
7666 seg < filedata->program_headers + filedata->file_header.e_phnum;
7667 ++seg)
7668 {
7669 if (seg->p_type != PT_LOAD)
7670 continue;
7671
7672 if (sec->sh_addr >= seg->p_vaddr
7673 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7674 {
7675 aux->seg_base = seg->p_vaddr;
7676 break;
7677 }
7678 }
7679 }
7680
7681 /* Second, build the unwind table from the contents of the unwind section: */
7682 size = sec->sh_size;
7683 table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7684 _("unwind table"));
7685 if (!table)
7686 return FALSE;
7687
7688 aux->table_len = size / (3 * eh_addr_size);
7689 aux->table = (struct ia64_unw_table_entry *)
7690 xcmalloc (aux->table_len, sizeof (aux->table[0]));
7691 tep = aux->table;
7692
7693 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7694 {
7695 tep->start.section = SHN_UNDEF;
7696 tep->end.section = SHN_UNDEF;
7697 tep->info.section = SHN_UNDEF;
7698 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7699 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7700 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7701 tep->start.offset += aux->seg_base;
7702 tep->end.offset += aux->seg_base;
7703 tep->info.offset += aux->seg_base;
7704 }
7705 free (table);
7706
7707 /* Third, apply any relocations to the unwind table: */
7708 for (relsec = filedata->section_headers;
7709 relsec < filedata->section_headers + filedata->file_header.e_shnum;
7710 ++relsec)
7711 {
7712 if (relsec->sh_type != SHT_RELA
7713 || relsec->sh_info >= filedata->file_header.e_shnum
7714 || filedata->section_headers + relsec->sh_info != sec)
7715 continue;
7716
7717 if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7718 & rela, & nrelas))
7719 {
7720 free (aux->table);
7721 aux->table = NULL;
7722 aux->table_len = 0;
7723 return FALSE;
7724 }
7725
7726 for (rp = rela; rp < rela + nrelas; ++rp)
7727 {
7728 unsigned int sym_ndx;
7729 unsigned int r_type = get_reloc_type (filedata, rp->r_info);
7730 relname = elf_ia64_reloc_type (r_type);
7731
7732 /* PR 17531: file: 9fa67536. */
7733 if (relname == NULL)
7734 {
7735 warn (_("Skipping unknown relocation type: %u\n"), r_type);
7736 continue;
7737 }
7738
7739 if (! const_strneq (relname, "R_IA64_SEGREL"))
7740 {
7741 warn (_("Skipping unexpected relocation type: %s\n"), relname);
7742 continue;
7743 }
7744
7745 i = rp->r_offset / (3 * eh_addr_size);
7746
7747 /* PR 17531: file: 5bc8d9bf. */
7748 if (i >= aux->table_len)
7749 {
7750 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7751 continue;
7752 }
7753
7754 sym_ndx = get_reloc_symindex (rp->r_info);
7755 if (sym_ndx >= aux->nsyms)
7756 {
7757 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7758 sym_ndx);
7759 continue;
7760 }
7761 sym = aux->symtab + sym_ndx;
7762
7763 switch (rp->r_offset / eh_addr_size % 3)
7764 {
7765 case 0:
7766 aux->table[i].start.section = sym->st_shndx;
7767 aux->table[i].start.offset = rp->r_addend + sym->st_value;
7768 break;
7769 case 1:
7770 aux->table[i].end.section = sym->st_shndx;
7771 aux->table[i].end.offset = rp->r_addend + sym->st_value;
7772 break;
7773 case 2:
7774 aux->table[i].info.section = sym->st_shndx;
7775 aux->table[i].info.offset = rp->r_addend + sym->st_value;
7776 break;
7777 default:
7778 break;
7779 }
7780 }
7781
7782 free (rela);
7783 }
7784
7785 return TRUE;
7786}
7787
7788static bfd_boolean
7789ia64_process_unwind (Filedata * filedata)
7790{
7791 Elf_Internal_Shdr * sec;
7792 Elf_Internal_Shdr * unwsec = NULL;
7793 Elf_Internal_Shdr * strsec;
7794 unsigned long i, unwcount = 0, unwstart = 0;
7795 struct ia64_unw_aux_info aux;
7796 bfd_boolean res = TRUE;
7797
7798 memset (& aux, 0, sizeof (aux));
7799
7800 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
7801 {
7802 if (sec->sh_type == SHT_SYMTAB
7803 && sec->sh_link < filedata->file_header.e_shnum)
7804 {
7805 aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
7806
7807 strsec = filedata->section_headers + sec->sh_link;
7808 if (aux.strtab != NULL)
7809 {
7810 error (_("Multiple auxillary string tables encountered\n"));
7811 free (aux.strtab);
7812 res = FALSE;
7813 }
7814 aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7815 1, strsec->sh_size,
7816 _("string table"));
7817 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7818 }
7819 else if (sec->sh_type == SHT_IA_64_UNWIND)
7820 unwcount++;
7821 }
7822
7823 if (!unwcount)
7824 printf (_("\nThere are no unwind sections in this file.\n"));
7825
7826 while (unwcount-- > 0)
7827 {
7828 char * suffix;
7829 size_t len, len2;
7830
7831 for (i = unwstart, sec = filedata->section_headers + unwstart, unwsec = NULL;
7832 i < filedata->file_header.e_shnum; ++i, ++sec)
7833 if (sec->sh_type == SHT_IA_64_UNWIND)
7834 {
7835 unwsec = sec;
7836 break;
7837 }
7838 /* We have already counted the number of SHT_IA64_UNWIND
7839 sections so the loop above should never fail. */
7840 assert (unwsec != NULL);
7841
7842 unwstart = i + 1;
7843 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7844
7845 if ((unwsec->sh_flags & SHF_GROUP) != 0)
7846 {
7847 /* We need to find which section group it is in. */
7848 struct group_list * g;
7849
7850 if (section_headers_groups == NULL
7851 || section_headers_groups [i] == NULL)
7852 i = filedata->file_header.e_shnum;
7853 else
7854 {
7855 g = section_headers_groups [i]->root;
7856
7857 for (; g != NULL; g = g->next)
7858 {
7859 sec = filedata->section_headers + g->section_index;
7860
7861 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7862 break;
7863 }
7864
7865 if (g == NULL)
7866 i = filedata->file_header.e_shnum;
7867 }
7868 }
7869 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7870 {
7871 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7872 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7873 suffix = SECTION_NAME (unwsec) + len;
7874 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7875 ++i, ++sec)
7876 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7877 && streq (SECTION_NAME (sec) + len2, suffix))
7878 break;
7879 }
7880 else
7881 {
7882 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7883 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7884 len = sizeof (ELF_STRING_ia64_unwind) - 1;
7885 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7886 suffix = "";
7887 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7888 suffix = SECTION_NAME (unwsec) + len;
7889 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7890 ++i, ++sec)
7891 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7892 && streq (SECTION_NAME (sec) + len2, suffix))
7893 break;
7894 }
7895
7896 if (i == filedata->file_header.e_shnum)
7897 {
7898 printf (_("\nCould not find unwind info section for "));
7899
7900 if (filedata->string_table == NULL)
7901 printf ("%d", unwsec->sh_name);
7902 else
7903 printf ("'%s'", printable_section_name (filedata, unwsec));
7904 }
7905 else
7906 {
7907 aux.info_addr = sec->sh_addr;
7908 aux.info = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1,
7909 sec->sh_size,
7910 _("unwind info"));
7911 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7912
7913 printf (_("\nUnwind section "));
7914
7915 if (filedata->string_table == NULL)
7916 printf ("%d", unwsec->sh_name);
7917 else
7918 printf ("'%s'", printable_section_name (filedata, unwsec));
7919
7920 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7921 (unsigned long) unwsec->sh_offset,
7922 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7923
7924 if (slurp_ia64_unwind_table (filedata, & aux, unwsec)
7925 && aux.table_len > 0)
7926 dump_ia64_unwind (filedata, & aux);
7927
7928 if (aux.table)
7929 free ((char *) aux.table);
7930 if (aux.info)
7931 free ((char *) aux.info);
7932 aux.table = NULL;
7933 aux.info = NULL;
7934 }
7935 }
7936
7937 if (aux.symtab)
7938 free (aux.symtab);
7939 if (aux.strtab)
7940 free ((char *) aux.strtab);
7941
7942 return res;
7943}
7944
7945struct hppa_unw_table_entry
7946{
7947 struct absaddr start;
7948 struct absaddr end;
7949 unsigned int Cannot_unwind:1; /* 0 */
7950 unsigned int Millicode:1; /* 1 */
7951 unsigned int Millicode_save_sr0:1; /* 2 */
7952 unsigned int Region_description:2; /* 3..4 */
7953 unsigned int reserved1:1; /* 5 */
7954 unsigned int Entry_SR:1; /* 6 */
7955 unsigned int Entry_FR:4; /* Number saved 7..10 */
7956 unsigned int Entry_GR:5; /* Number saved 11..15 */
7957 unsigned int Args_stored:1; /* 16 */
7958 unsigned int Variable_Frame:1; /* 17 */
7959 unsigned int Separate_Package_Body:1; /* 18 */
7960 unsigned int Frame_Extension_Millicode:1; /* 19 */
7961 unsigned int Stack_Overflow_Check:1; /* 20 */
7962 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
7963 unsigned int Ada_Region:1; /* 22 */
7964 unsigned int cxx_info:1; /* 23 */
7965 unsigned int cxx_try_catch:1; /* 24 */
7966 unsigned int sched_entry_seq:1; /* 25 */
7967 unsigned int reserved2:1; /* 26 */
7968 unsigned int Save_SP:1; /* 27 */
7969 unsigned int Save_RP:1; /* 28 */
7970 unsigned int Save_MRP_in_frame:1; /* 29 */
7971 unsigned int extn_ptr_defined:1; /* 30 */
7972 unsigned int Cleanup_defined:1; /* 31 */
7973
7974 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
7975 unsigned int HP_UX_interrupt_marker:1; /* 1 */
7976 unsigned int Large_frame:1; /* 2 */
7977 unsigned int Pseudo_SP_Set:1; /* 3 */
7978 unsigned int reserved4:1; /* 4 */
7979 unsigned int Total_frame_size:27; /* 5..31 */
7980};
7981
7982struct hppa_unw_aux_info
7983{
7984 struct hppa_unw_table_entry * table; /* Unwind table. */
7985 unsigned long table_len; /* Length of unwind table. */
7986 bfd_vma seg_base; /* Starting address of segment. */
7987 Elf_Internal_Sym * symtab; /* The symbol table. */
7988 unsigned long nsyms; /* Number of symbols. */
7989 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7990 unsigned long nfuns; /* Number of entries in funtab. */
7991 char * strtab; /* The string table. */
7992 unsigned long strtab_size; /* Size of string table. */
7993};
7994
7995static bfd_boolean
7996dump_hppa_unwind (Filedata * filedata, struct hppa_unw_aux_info * aux)
7997{
7998 struct hppa_unw_table_entry * tp;
7999 unsigned long j, nfuns;
8000 bfd_boolean res = TRUE;
8001
8002 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8003 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8004 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8005 aux->funtab[nfuns++] = aux->symtab[j];
8006 aux->nfuns = nfuns;
8007 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8008
8009 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
8010 {
8011 bfd_vma offset;
8012 const char * procname;
8013
8014 find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8015 aux->strtab_size, tp->start, &procname,
8016 &offset);
8017
8018 fputs ("\n<", stdout);
8019
8020 if (procname)
8021 {
8022 fputs (procname, stdout);
8023
8024 if (offset)
8025 printf ("+%lx", (unsigned long) offset);
8026 }
8027
8028 fputs (">: [", stdout);
8029 print_vma (tp->start.offset, PREFIX_HEX);
8030 fputc ('-', stdout);
8031 print_vma (tp->end.offset, PREFIX_HEX);
8032 printf ("]\n\t");
8033
8034#define PF(_m) if (tp->_m) printf (#_m " ");
8035#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8036 PF(Cannot_unwind);
8037 PF(Millicode);
8038 PF(Millicode_save_sr0);
8039 /* PV(Region_description); */
8040 PF(Entry_SR);
8041 PV(Entry_FR);
8042 PV(Entry_GR);
8043 PF(Args_stored);
8044 PF(Variable_Frame);
8045 PF(Separate_Package_Body);
8046 PF(Frame_Extension_Millicode);
8047 PF(Stack_Overflow_Check);
8048 PF(Two_Instruction_SP_Increment);
8049 PF(Ada_Region);
8050 PF(cxx_info);
8051 PF(cxx_try_catch);
8052 PF(sched_entry_seq);
8053 PF(Save_SP);
8054 PF(Save_RP);
8055 PF(Save_MRP_in_frame);
8056 PF(extn_ptr_defined);
8057 PF(Cleanup_defined);
8058 PF(MPE_XL_interrupt_marker);
8059 PF(HP_UX_interrupt_marker);
8060 PF(Large_frame);
8061 PF(Pseudo_SP_Set);
8062 PV(Total_frame_size);
8063#undef PF
8064#undef PV
8065 }
8066
8067 printf ("\n");
8068
8069 free (aux->funtab);
8070
8071 return res;
8072}
8073
8074static bfd_boolean
8075slurp_hppa_unwind_table (Filedata * filedata,
8076 struct hppa_unw_aux_info * aux,
8077 Elf_Internal_Shdr * sec)
8078{
8079 unsigned long size, unw_ent_size, nentries, nrelas, i;
8080 Elf_Internal_Phdr * seg;
8081 struct hppa_unw_table_entry * tep;
8082 Elf_Internal_Shdr * relsec;
8083 Elf_Internal_Rela * rela;
8084 Elf_Internal_Rela * rp;
8085 unsigned char * table;
8086 unsigned char * tp;
8087 Elf_Internal_Sym * sym;
8088 const char * relname;
8089
8090 /* First, find the starting address of the segment that includes
8091 this section. */
8092 if (filedata->file_header.e_phnum)
8093 {
8094 if (! get_program_headers (filedata))
8095 return FALSE;
8096
8097 for (seg = filedata->program_headers;
8098 seg < filedata->program_headers + filedata->file_header.e_phnum;
8099 ++seg)
8100 {
8101 if (seg->p_type != PT_LOAD)
8102 continue;
8103
8104 if (sec->sh_addr >= seg->p_vaddr
8105 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
8106 {
8107 aux->seg_base = seg->p_vaddr;
8108 break;
8109 }
8110 }
8111 }
8112
8113 /* Second, build the unwind table from the contents of the unwind
8114 section. */
8115 size = sec->sh_size;
8116 table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
8117 _("unwind table"));
8118 if (!table)
8119 return FALSE;
8120
8121 unw_ent_size = 16;
8122 nentries = size / unw_ent_size;
8123 size = unw_ent_size * nentries;
8124
8125 tep = aux->table = (struct hppa_unw_table_entry *)
8126 xcmalloc (nentries, sizeof (aux->table[0]));
8127
8128 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
8129 {
8130 unsigned int tmp1, tmp2;
8131
8132 tep->start.section = SHN_UNDEF;
8133 tep->end.section = SHN_UNDEF;
8134
8135 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
8136 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
8137 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
8138 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
8139
8140 tep->start.offset += aux->seg_base;
8141 tep->end.offset += aux->seg_base;
8142
8143 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
8144 tep->Millicode = (tmp1 >> 30) & 0x1;
8145 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
8146 tep->Region_description = (tmp1 >> 27) & 0x3;
8147 tep->reserved1 = (tmp1 >> 26) & 0x1;
8148 tep->Entry_SR = (tmp1 >> 25) & 0x1;
8149 tep->Entry_FR = (tmp1 >> 21) & 0xf;
8150 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
8151 tep->Args_stored = (tmp1 >> 15) & 0x1;
8152 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
8153 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
8154 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
8155 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
8156 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
8157 tep->Ada_Region = (tmp1 >> 9) & 0x1;
8158 tep->cxx_info = (tmp1 >> 8) & 0x1;
8159 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
8160 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
8161 tep->reserved2 = (tmp1 >> 5) & 0x1;
8162 tep->Save_SP = (tmp1 >> 4) & 0x1;
8163 tep->Save_RP = (tmp1 >> 3) & 0x1;
8164 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
8165 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
8166 tep->Cleanup_defined = tmp1 & 0x1;
8167
8168 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
8169 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
8170 tep->Large_frame = (tmp2 >> 29) & 0x1;
8171 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
8172 tep->reserved4 = (tmp2 >> 27) & 0x1;
8173 tep->Total_frame_size = tmp2 & 0x7ffffff;
8174 }
8175 free (table);
8176
8177 /* Third, apply any relocations to the unwind table. */
8178 for (relsec = filedata->section_headers;
8179 relsec < filedata->section_headers + filedata->file_header.e_shnum;
8180 ++relsec)
8181 {
8182 if (relsec->sh_type != SHT_RELA
8183 || relsec->sh_info >= filedata->file_header.e_shnum
8184 || filedata->section_headers + relsec->sh_info != sec)
8185 continue;
8186
8187 if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
8188 & rela, & nrelas))
8189 return FALSE;
8190
8191 for (rp = rela; rp < rela + nrelas; ++rp)
8192 {
8193 unsigned int sym_ndx;
8194 unsigned int r_type = get_reloc_type (filedata, rp->r_info);
8195 relname = elf_hppa_reloc_type (r_type);
8196
8197 if (relname == NULL)
8198 {
8199 warn (_("Skipping unknown relocation type: %u\n"), r_type);
8200 continue;
8201 }
8202
8203 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8204 if (! const_strneq (relname, "R_PARISC_SEGREL"))
8205 {
8206 warn (_("Skipping unexpected relocation type: %s\n"), relname);
8207 continue;
8208 }
8209
8210 i = rp->r_offset / unw_ent_size;
8211 if (i >= aux->table_len)
8212 {
8213 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
8214 continue;
8215 }
8216
8217 sym_ndx = get_reloc_symindex (rp->r_info);
8218 if (sym_ndx >= aux->nsyms)
8219 {
8220 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8221 sym_ndx);
8222 continue;
8223 }
8224 sym = aux->symtab + sym_ndx;
8225
8226 switch ((rp->r_offset % unw_ent_size) / 4)
8227 {
8228 case 0:
8229 aux->table[i].start.section = sym->st_shndx;
8230 aux->table[i].start.offset = sym->st_value + rp->r_addend;
8231 break;
8232 case 1:
8233 aux->table[i].end.section = sym->st_shndx;
8234 aux->table[i].end.offset = sym->st_value + rp->r_addend;
8235 break;
8236 default:
8237 break;
8238 }
8239 }
8240
8241 free (rela);
8242 }
8243
8244 aux->table_len = nentries;
8245
8246 return TRUE;
8247}
8248
8249static bfd_boolean
8250hppa_process_unwind (Filedata * filedata)
8251{
8252 struct hppa_unw_aux_info aux;
8253 Elf_Internal_Shdr * unwsec = NULL;
8254 Elf_Internal_Shdr * strsec;
8255 Elf_Internal_Shdr * sec;
8256 unsigned long i;
8257 bfd_boolean res = TRUE;
8258
8259 if (filedata->string_table == NULL)
8260 return FALSE;
8261
8262 memset (& aux, 0, sizeof (aux));
8263
8264 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8265 {
8266 if (sec->sh_type == SHT_SYMTAB
8267 && sec->sh_link < filedata->file_header.e_shnum)
8268 {
8269 aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
8270
8271 strsec = filedata->section_headers + sec->sh_link;
8272 if (aux.strtab != NULL)
8273 {
8274 error (_("Multiple auxillary string tables encountered\n"));
8275 free (aux.strtab);
8276 res = FALSE;
8277 }
8278 aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
8279 1, strsec->sh_size,
8280 _("string table"));
8281 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8282 }
8283 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8284 unwsec = sec;
8285 }
8286
8287 if (!unwsec)
8288 printf (_("\nThere are no unwind sections in this file.\n"));
8289
8290 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8291 {
8292 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8293 {
8294 unsigned long num_unwind = sec->sh_size / 16;
8295
8296 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8297 "contains %lu entry:\n",
8298 "\nUnwind section '%s' at offset 0x%lx "
8299 "contains %lu entries:\n",
8300 num_unwind),
8301 printable_section_name (filedata, sec),
8302 (unsigned long) sec->sh_offset,
8303 num_unwind);
8304
8305 if (! slurp_hppa_unwind_table (filedata, &aux, sec))
8306 res = FALSE;
8307
8308 if (res && aux.table_len > 0)
8309 {
8310 if (! dump_hppa_unwind (filedata, &aux))
8311 res = FALSE;
8312 }
8313
8314 if (aux.table)
8315 free ((char *) aux.table);
8316 aux.table = NULL;
8317 }
8318 }
8319
8320 if (aux.symtab)
8321 free (aux.symtab);
8322 if (aux.strtab)
8323 free ((char *) aux.strtab);
8324
8325 return res;
8326}
8327
8328struct arm_section
8329{
8330 unsigned char * data; /* The unwind data. */
8331 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
8332 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
8333 unsigned long nrelas; /* The number of relocations. */
8334 unsigned int rel_type; /* REL or RELA ? */
8335 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
8336};
8337
8338struct arm_unw_aux_info
8339{
8340 Filedata * filedata; /* The file containing the unwind sections. */
8341 Elf_Internal_Sym * symtab; /* The file's symbol table. */
8342 unsigned long nsyms; /* Number of symbols. */
8343 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
8344 unsigned long nfuns; /* Number of these symbols. */
8345 char * strtab; /* The file's string table. */
8346 unsigned long strtab_size; /* Size of string table. */
8347};
8348
8349static const char *
8350arm_print_vma_and_name (Filedata * filedata,
8351 struct arm_unw_aux_info * aux,
8352 bfd_vma fn,
8353 struct absaddr addr)
8354{
8355 const char *procname;
8356 bfd_vma sym_offset;
8357
8358 if (addr.section == SHN_UNDEF)
8359 addr.offset = fn;
8360
8361 find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8362 aux->strtab_size, addr, &procname,
8363 &sym_offset);
8364
8365 print_vma (fn, PREFIX_HEX);
8366
8367 if (procname)
8368 {
8369 fputs (" <", stdout);
8370 fputs (procname, stdout);
8371
8372 if (sym_offset)
8373 printf ("+0x%lx", (unsigned long) sym_offset);
8374 fputc ('>', stdout);
8375 }
8376
8377 return procname;
8378}
8379
8380static void
8381arm_free_section (struct arm_section *arm_sec)
8382{
8383 if (arm_sec->data != NULL)
8384 free (arm_sec->data);
8385
8386 if (arm_sec->rela != NULL)
8387 free (arm_sec->rela);
8388}
8389
8390/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8391 cached section and install SEC instead.
8392 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8393 and return its valued in * WORDP, relocating if necessary.
8394 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8395 relocation's offset in ADDR.
8396 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8397 into the string table of the symbol associated with the reloc. If no
8398 reloc was applied store -1 there.
8399 5) Return TRUE upon success, FALSE otherwise. */
8400
8401static bfd_boolean
8402get_unwind_section_word (Filedata * filedata,
8403 struct arm_unw_aux_info * aux,
8404 struct arm_section * arm_sec,
8405 Elf_Internal_Shdr * sec,
8406 bfd_vma word_offset,
8407 unsigned int * wordp,
8408 struct absaddr * addr,
8409 bfd_vma * sym_name)
8410{
8411 Elf_Internal_Rela *rp;
8412 Elf_Internal_Sym *sym;
8413 const char * relname;
8414 unsigned int word;
8415 bfd_boolean wrapped;
8416
8417 if (sec == NULL || arm_sec == NULL)
8418 return FALSE;
8419
8420 addr->section = SHN_UNDEF;
8421 addr->offset = 0;
8422
8423 if (sym_name != NULL)
8424 *sym_name = (bfd_vma) -1;
8425
8426 /* If necessary, update the section cache. */
8427 if (sec != arm_sec->sec)
8428 {
8429 Elf_Internal_Shdr *relsec;
8430
8431 arm_free_section (arm_sec);
8432
8433 arm_sec->sec = sec;
8434 arm_sec->data = get_data (NULL, aux->filedata, sec->sh_offset, 1,
8435 sec->sh_size, _("unwind data"));
8436 arm_sec->rela = NULL;
8437 arm_sec->nrelas = 0;
8438
8439 for (relsec = filedata->section_headers;
8440 relsec < filedata->section_headers + filedata->file_header.e_shnum;
8441 ++relsec)
8442 {
8443 if (relsec->sh_info >= filedata->file_header.e_shnum
8444 || filedata->section_headers + relsec->sh_info != sec
8445 /* PR 15745: Check the section type as well. */
8446 || (relsec->sh_type != SHT_REL
8447 && relsec->sh_type != SHT_RELA))
8448 continue;
8449
8450 arm_sec->rel_type = relsec->sh_type;
8451 if (relsec->sh_type == SHT_REL)
8452 {
8453 if (!slurp_rel_relocs (aux->filedata, relsec->sh_offset,
8454 relsec->sh_size,
8455 & arm_sec->rela, & arm_sec->nrelas))
8456 return FALSE;
8457 }
8458 else /* relsec->sh_type == SHT_RELA */
8459 {
8460 if (!slurp_rela_relocs (aux->filedata, relsec->sh_offset,
8461 relsec->sh_size,
8462 & arm_sec->rela, & arm_sec->nrelas))
8463 return FALSE;
8464 }
8465 break;
8466 }
8467
8468 arm_sec->next_rela = arm_sec->rela;
8469 }
8470
8471 /* If there is no unwind data we can do nothing. */
8472 if (arm_sec->data == NULL)
8473 return FALSE;
8474
8475 /* If the offset is invalid then fail. */
8476 if (/* PR 21343 *//* PR 18879 */
8477 sec->sh_size < 4
8478 || word_offset > (sec->sh_size - 4)
8479 || ((bfd_signed_vma) word_offset) < 0)
8480 return FALSE;
8481
8482 /* Get the word at the required offset. */
8483 word = byte_get (arm_sec->data + word_offset, 4);
8484
8485 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8486 if (arm_sec->rela == NULL)
8487 {
8488 * wordp = word;
8489 return TRUE;
8490 }
8491
8492 /* Look through the relocs to find the one that applies to the provided offset. */
8493 wrapped = FALSE;
8494 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8495 {
8496 bfd_vma prelval, offset;
8497
8498 if (rp->r_offset > word_offset && !wrapped)
8499 {
8500 rp = arm_sec->rela;
8501 wrapped = TRUE;
8502 }
8503 if (rp->r_offset > word_offset)
8504 break;
8505
8506 if (rp->r_offset & 3)
8507 {
8508 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8509 (unsigned long) rp->r_offset);
8510 continue;
8511 }
8512
8513 if (rp->r_offset < word_offset)
8514 continue;
8515
8516 /* PR 17531: file: 027-161405-0.004 */
8517 if (aux->symtab == NULL)
8518 continue;
8519
8520 if (arm_sec->rel_type == SHT_REL)
8521 {
8522 offset = word & 0x7fffffff;
8523 if (offset & 0x40000000)
8524 offset |= ~ (bfd_vma) 0x7fffffff;
8525 }
8526 else if (arm_sec->rel_type == SHT_RELA)
8527 offset = rp->r_addend;
8528 else
8529 {
8530 error (_("Unknown section relocation type %d encountered\n"),
8531 arm_sec->rel_type);
8532 break;
8533 }
8534
8535 /* PR 17531 file: 027-1241568-0.004. */
8536 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8537 {
8538 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8539 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8540 break;
8541 }
8542
8543 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8544 offset += sym->st_value;
8545 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8546
8547 /* Check that we are processing the expected reloc type. */
8548 if (filedata->file_header.e_machine == EM_ARM)
8549 {
8550 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8551 if (relname == NULL)
8552 {
8553 warn (_("Skipping unknown ARM relocation type: %d\n"),
8554 (int) ELF32_R_TYPE (rp->r_info));
8555 continue;
8556 }
8557
8558 if (streq (relname, "R_ARM_NONE"))
8559 continue;
8560
8561 if (! streq (relname, "R_ARM_PREL31"))
8562 {
8563 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8564 continue;
8565 }
8566 }
8567 else if (filedata->file_header.e_machine == EM_TI_C6000)
8568 {
8569 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8570 if (relname == NULL)
8571 {
8572 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8573 (int) ELF32_R_TYPE (rp->r_info));
8574 continue;
8575 }
8576
8577 if (streq (relname, "R_C6000_NONE"))
8578 continue;
8579
8580 if (! streq (relname, "R_C6000_PREL31"))
8581 {
8582 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8583 continue;
8584 }
8585
8586 prelval >>= 1;
8587 }
8588 else
8589 {
8590 /* This function currently only supports ARM and TI unwinders. */
8591 warn (_("Only TI and ARM unwinders are currently supported\n"));
8592 break;
8593 }
8594
8595 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8596 addr->section = sym->st_shndx;
8597 addr->offset = offset;
8598
8599 if (sym_name)
8600 * sym_name = sym->st_name;
8601 break;
8602 }
8603
8604 *wordp = word;
8605 arm_sec->next_rela = rp;
8606
8607 return TRUE;
8608}
8609
8610static const char *tic6x_unwind_regnames[16] =
8611{
8612 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8613 "A14", "A13", "A12", "A11", "A10",
8614 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8615};
8616
8617static void
8618decode_tic6x_unwind_regmask (unsigned int mask)
8619{
8620 int i;
8621
8622 for (i = 12; mask; mask >>= 1, i--)
8623 {
8624 if (mask & 1)
8625 {
8626 fputs (tic6x_unwind_regnames[i], stdout);
8627 if (mask > 1)
8628 fputs (", ", stdout);
8629 }
8630 }
8631}
8632
8633#define ADVANCE \
8634 if (remaining == 0 && more_words) \
8635 { \
8636 data_offset += 4; \
8637 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8638 data_offset, & word, & addr, NULL)) \
8639 return FALSE; \
8640 remaining = 4; \
8641 more_words--; \
8642 } \
8643
8644#define GET_OP(OP) \
8645 ADVANCE; \
8646 if (remaining) \
8647 { \
8648 remaining--; \
8649 (OP) = word >> 24; \
8650 word <<= 8; \
8651 } \
8652 else \
8653 { \
8654 printf (_("[Truncated opcode]\n")); \
8655 return FALSE; \
8656 } \
8657 printf ("0x%02x ", OP)
8658
8659static bfd_boolean
8660decode_arm_unwind_bytecode (Filedata * filedata,
8661 struct arm_unw_aux_info * aux,
8662 unsigned int word,
8663 unsigned int remaining,
8664 unsigned int more_words,
8665 bfd_vma data_offset,
8666 Elf_Internal_Shdr * data_sec,
8667 struct arm_section * data_arm_sec)
8668{
8669 struct absaddr addr;
8670 bfd_boolean res = TRUE;
8671
8672 /* Decode the unwinding instructions. */
8673 while (1)
8674 {
8675 unsigned int op, op2;
8676
8677 ADVANCE;
8678 if (remaining == 0)
8679 break;
8680 remaining--;
8681 op = word >> 24;
8682 word <<= 8;
8683
8684 printf (" 0x%02x ", op);
8685
8686 if ((op & 0xc0) == 0x00)
8687 {
8688 int offset = ((op & 0x3f) << 2) + 4;
8689
8690 printf (" vsp = vsp + %d", offset);
8691 }
8692 else if ((op & 0xc0) == 0x40)
8693 {
8694 int offset = ((op & 0x3f) << 2) + 4;
8695
8696 printf (" vsp = vsp - %d", offset);
8697 }
8698 else if ((op & 0xf0) == 0x80)
8699 {
8700 GET_OP (op2);
8701 if (op == 0x80 && op2 == 0)
8702 printf (_("Refuse to unwind"));
8703 else
8704 {
8705 unsigned int mask = ((op & 0x0f) << 8) | op2;
8706 bfd_boolean first = TRUE;
8707 int i;
8708
8709 printf ("pop {");
8710 for (i = 0; i < 12; i++)
8711 if (mask & (1 << i))
8712 {
8713 if (first)
8714 first = FALSE;
8715 else
8716 printf (", ");
8717 printf ("r%d", 4 + i);
8718 }
8719 printf ("}");
8720 }
8721 }
8722 else if ((op & 0xf0) == 0x90)
8723 {
8724 if (op == 0x9d || op == 0x9f)
8725 printf (_(" [Reserved]"));
8726 else
8727 printf (" vsp = r%d", op & 0x0f);
8728 }
8729 else if ((op & 0xf0) == 0xa0)
8730 {
8731 int end = 4 + (op & 0x07);
8732 bfd_boolean first = TRUE;
8733 int i;
8734
8735 printf (" pop {");
8736 for (i = 4; i <= end; i++)
8737 {
8738 if (first)
8739 first = FALSE;
8740 else
8741 printf (", ");
8742 printf ("r%d", i);
8743 }
8744 if (op & 0x08)
8745 {
8746 if (!first)
8747 printf (", ");
8748 printf ("r14");
8749 }
8750 printf ("}");
8751 }
8752 else if (op == 0xb0)
8753 printf (_(" finish"));
8754 else if (op == 0xb1)
8755 {
8756 GET_OP (op2);
8757 if (op2 == 0 || (op2 & 0xf0) != 0)
8758 printf (_("[Spare]"));
8759 else
8760 {
8761 unsigned int mask = op2 & 0x0f;
8762 bfd_boolean first = TRUE;
8763 int i;
8764
8765 printf ("pop {");
8766 for (i = 0; i < 12; i++)
8767 if (mask & (1 << i))
8768 {
8769 if (first)
8770 first = FALSE;
8771 else
8772 printf (", ");
8773 printf ("r%d", i);
8774 }
8775 printf ("}");
8776 }
8777 }
8778 else if (op == 0xb2)
8779 {
8780 unsigned char buf[9];
8781 unsigned int i, len;
8782 unsigned long offset;
8783
8784 for (i = 0; i < sizeof (buf); i++)
8785 {
8786 GET_OP (buf[i]);
8787 if ((buf[i] & 0x80) == 0)
8788 break;
8789 }
8790 if (i == sizeof (buf))
8791 {
8792 error (_("corrupt change to vsp\n"));
8793 res = FALSE;
8794 }
8795 else
8796 {
8797 offset = read_leb128 (buf, buf + i + 1, FALSE, &len, NULL);
8798 assert (len == i + 1);
8799 offset = offset * 4 + 0x204;
8800 printf ("vsp = vsp + %ld", offset);
8801 }
8802 }
8803 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8804 {
8805 unsigned int first, last;
8806
8807 GET_OP (op2);
8808 first = op2 >> 4;
8809 last = op2 & 0x0f;
8810 if (op == 0xc8)
8811 first = first + 16;
8812 printf ("pop {D%d", first);
8813 if (last)
8814 printf ("-D%d", first + last);
8815 printf ("}");
8816 }
8817 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8818 {
8819 unsigned int count = op & 0x07;
8820
8821 printf ("pop {D8");
8822 if (count)
8823 printf ("-D%d", 8 + count);
8824 printf ("}");
8825 }
8826 else if (op >= 0xc0 && op <= 0xc5)
8827 {
8828 unsigned int count = op & 0x07;
8829
8830 printf (" pop {wR10");
8831 if (count)
8832 printf ("-wR%d", 10 + count);
8833 printf ("}");
8834 }
8835 else if (op == 0xc6)
8836 {
8837 unsigned int first, last;
8838
8839 GET_OP (op2);
8840 first = op2 >> 4;
8841 last = op2 & 0x0f;
8842 printf ("pop {wR%d", first);
8843 if (last)
8844 printf ("-wR%d", first + last);
8845 printf ("}");
8846 }
8847 else if (op == 0xc7)
8848 {
8849 GET_OP (op2);
8850 if (op2 == 0 || (op2 & 0xf0) != 0)
8851 printf (_("[Spare]"));
8852 else
8853 {
8854 unsigned int mask = op2 & 0x0f;
8855 bfd_boolean first = TRUE;
8856 int i;
8857
8858 printf ("pop {");
8859 for (i = 0; i < 4; i++)
8860 if (mask & (1 << i))
8861 {
8862 if (first)
8863 first = FALSE;
8864 else
8865 printf (", ");
8866 printf ("wCGR%d", i);
8867 }
8868 printf ("}");
8869 }
8870 }
8871 else
8872 {
8873 printf (_(" [unsupported opcode]"));
8874 res = FALSE;
8875 }
8876
8877 printf ("\n");
8878 }
8879
8880 return res;
8881}
8882
8883static bfd_boolean
8884decode_tic6x_unwind_bytecode (Filedata * filedata,
8885 struct arm_unw_aux_info * aux,
8886 unsigned int word,
8887 unsigned int remaining,
8888 unsigned int more_words,
8889 bfd_vma data_offset,
8890 Elf_Internal_Shdr * data_sec,
8891 struct arm_section * data_arm_sec)
8892{
8893 struct absaddr addr;
8894
8895 /* Decode the unwinding instructions. */
8896 while (1)
8897 {
8898 unsigned int op, op2;
8899
8900 ADVANCE;
8901 if (remaining == 0)
8902 break;
8903 remaining--;
8904 op = word >> 24;
8905 word <<= 8;
8906
8907 printf (" 0x%02x ", op);
8908
8909 if ((op & 0xc0) == 0x00)
8910 {
8911 int offset = ((op & 0x3f) << 3) + 8;
8912 printf (" sp = sp + %d", offset);
8913 }
8914 else if ((op & 0xc0) == 0x80)
8915 {
8916 GET_OP (op2);
8917 if (op == 0x80 && op2 == 0)
8918 printf (_("Refuse to unwind"));
8919 else
8920 {
8921 unsigned int mask = ((op & 0x1f) << 8) | op2;
8922 if (op & 0x20)
8923 printf ("pop compact {");
8924 else
8925 printf ("pop {");
8926
8927 decode_tic6x_unwind_regmask (mask);
8928 printf("}");
8929 }
8930 }
8931 else if ((op & 0xf0) == 0xc0)
8932 {
8933 unsigned int reg;
8934 unsigned int nregs;
8935 unsigned int i;
8936 const char *name;
8937 struct
8938 {
8939 unsigned int offset;
8940 unsigned int reg;
8941 } regpos[16];
8942
8943 /* Scan entire instruction first so that GET_OP output is not
8944 interleaved with disassembly. */
8945 nregs = 0;
8946 for (i = 0; nregs < (op & 0xf); i++)
8947 {
8948 GET_OP (op2);
8949 reg = op2 >> 4;
8950 if (reg != 0xf)
8951 {
8952 regpos[nregs].offset = i * 2;
8953 regpos[nregs].reg = reg;
8954 nregs++;
8955 }
8956
8957 reg = op2 & 0xf;
8958 if (reg != 0xf)
8959 {
8960 regpos[nregs].offset = i * 2 + 1;
8961 regpos[nregs].reg = reg;
8962 nregs++;
8963 }
8964 }
8965
8966 printf (_("pop frame {"));
8967 if (nregs == 0)
8968 {
8969 printf (_("*corrupt* - no registers specified"));
8970 }
8971 else
8972 {
8973 reg = nregs - 1;
8974 for (i = i * 2; i > 0; i--)
8975 {
8976 if (regpos[reg].offset == i - 1)
8977 {
8978 name = tic6x_unwind_regnames[regpos[reg].reg];
8979 if (reg > 0)
8980 reg--;
8981 }
8982 else
8983 name = _("[pad]");
8984
8985 fputs (name, stdout);
8986 if (i > 1)
8987 printf (", ");
8988 }
8989 }
8990
8991 printf ("}");
8992 }
8993 else if (op == 0xd0)
8994 printf (" MOV FP, SP");
8995 else if (op == 0xd1)
8996 printf (" __c6xabi_pop_rts");
8997 else if (op == 0xd2)
8998 {
8999 unsigned char buf[9];
9000 unsigned int i, len;
9001 unsigned long offset;
9002
9003 for (i = 0; i < sizeof (buf); i++)
9004 {
9005 GET_OP (buf[i]);
9006 if ((buf[i] & 0x80) == 0)
9007 break;
9008 }
9009 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9010 if (i == sizeof (buf))
9011 {
9012 warn (_("Corrupt stack pointer adjustment detected\n"));
9013 return FALSE;
9014 }
9015
9016 offset = read_leb128 (buf, buf + i + 1, FALSE, &len, NULL);
9017 assert (len == i + 1);
9018 offset = offset * 8 + 0x408;
9019 printf (_("sp = sp + %ld"), offset);
9020 }
9021 else if ((op & 0xf0) == 0xe0)
9022 {
9023 if ((op & 0x0f) == 7)
9024 printf (" RETURN");
9025 else
9026 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
9027 }
9028 else
9029 {
9030 printf (_(" [unsupported opcode]"));
9031 }
9032 putchar ('\n');
9033 }
9034
9035 return TRUE;
9036}
9037
9038static bfd_vma
9039arm_expand_prel31 (Filedata * filedata, bfd_vma word, bfd_vma where)
9040{
9041 bfd_vma offset;
9042
9043 offset = word & 0x7fffffff;
9044 if (offset & 0x40000000)
9045 offset |= ~ (bfd_vma) 0x7fffffff;
9046
9047 if (filedata->file_header.e_machine == EM_TI_C6000)
9048 offset <<= 1;
9049
9050 return offset + where;
9051}
9052
9053static bfd_boolean
9054decode_arm_unwind (Filedata * filedata,
9055 struct arm_unw_aux_info * aux,
9056 unsigned int word,
9057 unsigned int remaining,
9058 bfd_vma data_offset,
9059 Elf_Internal_Shdr * data_sec,
9060 struct arm_section * data_arm_sec)
9061{
9062 int per_index;
9063 unsigned int more_words = 0;
9064 struct absaddr addr;
9065 bfd_vma sym_name = (bfd_vma) -1;
9066 bfd_boolean res = TRUE;
9067
9068 if (remaining == 0)
9069 {
9070 /* Fetch the first word.
9071 Note - when decoding an object file the address extracted
9072 here will always be 0. So we also pass in the sym_name
9073 parameter so that we can find the symbol associated with
9074 the personality routine. */
9075 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, data_offset,
9076 & word, & addr, & sym_name))
9077 return FALSE;
9078
9079 remaining = 4;
9080 }
9081 else
9082 {
9083 addr.section = SHN_UNDEF;
9084 addr.offset = 0;
9085 }
9086
9087 if ((word & 0x80000000) == 0)
9088 {
9089 /* Expand prel31 for personality routine. */
9090 bfd_vma fn;
9091 const char *procname;
9092
9093 fn = arm_expand_prel31 (filedata, word, data_sec->sh_addr + data_offset);
9094 printf (_(" Personality routine: "));
9095 if (fn == 0
9096 && addr.section == SHN_UNDEF && addr.offset == 0
9097 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
9098 {
9099 procname = aux->strtab + sym_name;
9100 print_vma (fn, PREFIX_HEX);
9101 if (procname)
9102 {
9103 fputs (" <", stdout);
9104 fputs (procname, stdout);
9105 fputc ('>', stdout);
9106 }
9107 }
9108 else
9109 procname = arm_print_vma_and_name (filedata, aux, fn, addr);
9110 fputc ('\n', stdout);
9111
9112 /* The GCC personality routines use the standard compact
9113 encoding, starting with one byte giving the number of
9114 words. */
9115 if (procname != NULL
9116 && (const_strneq (procname, "__gcc_personality_v0")
9117 || const_strneq (procname, "__gxx_personality_v0")
9118 || const_strneq (procname, "__gcj_personality_v0")
9119 || const_strneq (procname, "__gnu_objc_personality_v0")))
9120 {
9121 remaining = 0;
9122 more_words = 1;
9123 ADVANCE;
9124 if (!remaining)
9125 {
9126 printf (_(" [Truncated data]\n"));
9127 return FALSE;
9128 }
9129 more_words = word >> 24;
9130 word <<= 8;
9131 remaining--;
9132 per_index = -1;
9133 }
9134 else
9135 return TRUE;
9136 }
9137 else
9138 {
9139 /* ARM EHABI Section 6.3:
9140
9141 An exception-handling table entry for the compact model looks like:
9142
9143 31 30-28 27-24 23-0
9144 -- ----- ----- ----
9145 1 0 index Data for personalityRoutine[index] */
9146
9147 if (filedata->file_header.e_machine == EM_ARM
9148 && (word & 0x70000000))
9149 {
9150 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
9151 res = FALSE;
9152 }
9153
9154 per_index = (word >> 24) & 0x7f;
9155 printf (_(" Compact model index: %d\n"), per_index);
9156 if (per_index == 0)
9157 {
9158 more_words = 0;
9159 word <<= 8;
9160 remaining--;
9161 }
9162 else if (per_index < 3)
9163 {
9164 more_words = (word >> 16) & 0xff;
9165 word <<= 16;
9166 remaining -= 2;
9167 }
9168 }
9169
9170 switch (filedata->file_header.e_machine)
9171 {
9172 case EM_ARM:
9173 if (per_index < 3)
9174 {
9175 if (! decode_arm_unwind_bytecode (filedata, aux, word, remaining, more_words,
9176 data_offset, data_sec, data_arm_sec))
9177 res = FALSE;
9178 }
9179 else
9180 {
9181 warn (_("Unknown ARM compact model index encountered\n"));
9182 printf (_(" [reserved]\n"));
9183 res = FALSE;
9184 }
9185 break;
9186
9187 case EM_TI_C6000:
9188 if (per_index < 3)
9189 {
9190 if (! decode_tic6x_unwind_bytecode (filedata, aux, word, remaining, more_words,
9191 data_offset, data_sec, data_arm_sec))
9192 res = FALSE;
9193 }
9194 else if (per_index < 5)
9195 {
9196 if (((word >> 17) & 0x7f) == 0x7f)
9197 printf (_(" Restore stack from frame pointer\n"));
9198 else
9199 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
9200 printf (_(" Registers restored: "));
9201 if (per_index == 4)
9202 printf (" (compact) ");
9203 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
9204 putchar ('\n');
9205 printf (_(" Return register: %s\n"),
9206 tic6x_unwind_regnames[word & 0xf]);
9207 }
9208 else
9209 printf (_(" [reserved (%d)]\n"), per_index);
9210 break;
9211
9212 default:
9213 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9214 filedata->file_header.e_machine);
9215 res = FALSE;
9216 }
9217
9218 /* Decode the descriptors. Not implemented. */
9219
9220 return res;
9221}
9222
9223static bfd_boolean
9224dump_arm_unwind (Filedata * filedata,
9225 struct arm_unw_aux_info * aux,
9226 Elf_Internal_Shdr * exidx_sec)
9227{
9228 struct arm_section exidx_arm_sec, extab_arm_sec;
9229 unsigned int i, exidx_len;
9230 unsigned long j, nfuns;
9231 bfd_boolean res = TRUE;
9232
9233 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
9234 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
9235 exidx_len = exidx_sec->sh_size / 8;
9236
9237 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
9238 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
9239 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
9240 aux->funtab[nfuns++] = aux->symtab[j];
9241 aux->nfuns = nfuns;
9242 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
9243
9244 for (i = 0; i < exidx_len; i++)
9245 {
9246 unsigned int exidx_fn, exidx_entry;
9247 struct absaddr fn_addr, entry_addr;
9248 bfd_vma fn;
9249
9250 fputc ('\n', stdout);
9251
9252 if (! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9253 8 * i, & exidx_fn, & fn_addr, NULL)
9254 || ! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9255 8 * i + 4, & exidx_entry, & entry_addr, NULL))
9256 {
9257 free (aux->funtab);
9258 arm_free_section (& exidx_arm_sec);
9259 arm_free_section (& extab_arm_sec);
9260 return FALSE;
9261 }
9262
9263 /* ARM EHABI, Section 5:
9264 An index table entry consists of 2 words.
9265 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9266 if (exidx_fn & 0x80000000)
9267 {
9268 warn (_("corrupt index table entry: %x\n"), exidx_fn);
9269 res = FALSE;
9270 }
9271
9272 fn = arm_expand_prel31 (filedata, exidx_fn, exidx_sec->sh_addr + 8 * i);
9273
9274 arm_print_vma_and_name (filedata, aux, fn, fn_addr);
9275 fputs (": ", stdout);
9276
9277 if (exidx_entry == 1)
9278 {
9279 print_vma (exidx_entry, PREFIX_HEX);
9280 fputs (" [cantunwind]\n", stdout);
9281 }
9282 else if (exidx_entry & 0x80000000)
9283 {
9284 print_vma (exidx_entry, PREFIX_HEX);
9285 fputc ('\n', stdout);
9286 decode_arm_unwind (filedata, aux, exidx_entry, 4, 0, NULL, NULL);
9287 }
9288 else
9289 {
9290 bfd_vma table, table_offset = 0;
9291 Elf_Internal_Shdr *table_sec;
9292
9293 fputs ("@", stdout);
9294 table = arm_expand_prel31 (filedata, exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
9295 print_vma (table, PREFIX_HEX);
9296 printf ("\n");
9297
9298 /* Locate the matching .ARM.extab. */
9299 if (entry_addr.section != SHN_UNDEF
9300 && entry_addr.section < filedata->file_header.e_shnum)
9301 {
9302 table_sec = filedata->section_headers + entry_addr.section;
9303 table_offset = entry_addr.offset;
9304 /* PR 18879 */
9305 if (table_offset > table_sec->sh_size
9306 || ((bfd_signed_vma) table_offset) < 0)
9307 {
9308 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9309 (unsigned long) table_offset,
9310 printable_section_name (filedata, table_sec));
9311 res = FALSE;
9312 continue;
9313 }
9314 }
9315 else
9316 {
9317 table_sec = find_section_by_address (filedata, table);
9318 if (table_sec != NULL)
9319 table_offset = table - table_sec->sh_addr;
9320 }
9321
9322 if (table_sec == NULL)
9323 {
9324 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9325 (unsigned long) table);
9326 res = FALSE;
9327 continue;
9328 }
9329
9330 if (! decode_arm_unwind (filedata, aux, 0, 0, table_offset, table_sec,
9331 &extab_arm_sec))
9332 res = FALSE;
9333 }
9334 }
9335
9336 printf ("\n");
9337
9338 free (aux->funtab);
9339 arm_free_section (&exidx_arm_sec);
9340 arm_free_section (&extab_arm_sec);
9341
9342 return res;
9343}
9344
9345/* Used for both ARM and C6X unwinding tables. */
9346
9347static bfd_boolean
9348arm_process_unwind (Filedata * filedata)
9349{
9350 struct arm_unw_aux_info aux;
9351 Elf_Internal_Shdr *unwsec = NULL;
9352 Elf_Internal_Shdr *strsec;
9353 Elf_Internal_Shdr *sec;
9354 unsigned long i;
9355 unsigned int sec_type;
9356 bfd_boolean res = TRUE;
9357
9358 switch (filedata->file_header.e_machine)
9359 {
9360 case EM_ARM:
9361 sec_type = SHT_ARM_EXIDX;
9362 break;
9363
9364 case EM_TI_C6000:
9365 sec_type = SHT_C6000_UNWIND;
9366 break;
9367
9368 default:
9369 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9370 filedata->file_header.e_machine);
9371 return FALSE;
9372 }
9373
9374 if (filedata->string_table == NULL)
9375 return FALSE;
9376
9377 memset (& aux, 0, sizeof (aux));
9378 aux.filedata = filedata;
9379
9380 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9381 {
9382 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < filedata->file_header.e_shnum)
9383 {
9384 aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
9385
9386 strsec = filedata->section_headers + sec->sh_link;
9387
9388 /* PR binutils/17531 file: 011-12666-0.004. */
9389 if (aux.strtab != NULL)
9390 {
9391 error (_("Multiple string tables found in file.\n"));
9392 free (aux.strtab);
9393 res = FALSE;
9394 }
9395 aux.strtab = get_data (NULL, filedata, strsec->sh_offset,
9396 1, strsec->sh_size, _("string table"));
9397 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9398 }
9399 else if (sec->sh_type == sec_type)
9400 unwsec = sec;
9401 }
9402
9403 if (unwsec == NULL)
9404 printf (_("\nThere are no unwind sections in this file.\n"));
9405 else
9406 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9407 {
9408 if (sec->sh_type == sec_type)
9409 {
9410 unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size);
9411 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9412 "contains %lu entry:\n",
9413 "\nUnwind section '%s' at offset 0x%lx "
9414 "contains %lu entries:\n",
9415 num_unwind),
9416 printable_section_name (filedata, sec),
9417 (unsigned long) sec->sh_offset,
9418 num_unwind);
9419
9420 if (! dump_arm_unwind (filedata, &aux, sec))
9421 res = FALSE;
9422 }
9423 }
9424
9425 if (aux.symtab)
9426 free (aux.symtab);
9427 if (aux.strtab)
9428 free ((char *) aux.strtab);
9429
9430 return res;
9431}
9432
9433static bfd_boolean
9434process_unwind (Filedata * filedata)
9435{
9436 struct unwind_handler
9437 {
9438 unsigned int machtype;
9439 bfd_boolean (* handler)(Filedata *);
9440 } handlers[] =
9441 {
9442 { EM_ARM, arm_process_unwind },
9443 { EM_IA_64, ia64_process_unwind },
9444 { EM_PARISC, hppa_process_unwind },
9445 { EM_TI_C6000, arm_process_unwind },
9446 { 0, NULL }
9447 };
9448 int i;
9449
9450 if (!do_unwind)
9451 return TRUE;
9452
9453 for (i = 0; handlers[i].handler != NULL; i++)
9454 if (filedata->file_header.e_machine == handlers[i].machtype)
9455 return handlers[i].handler (filedata);
9456
9457 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9458 get_machine_name (filedata->file_header.e_machine));
9459 return TRUE;
9460}
9461
9462static void
9463dynamic_section_aarch64_val (Elf_Internal_Dyn * entry)
9464{
9465 switch (entry->d_tag)
9466 {
9467 case DT_AARCH64_BTI_PLT:
9468 case DT_AARCH64_PAC_PLT:
9469 break;
9470 default:
9471 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9472 break;
9473 }
9474 putchar ('\n');
9475}
9476
9477static void
9478dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9479{
9480 switch (entry->d_tag)
9481 {
9482 case DT_MIPS_FLAGS:
9483 if (entry->d_un.d_val == 0)
9484 printf (_("NONE"));
9485 else
9486 {
9487 static const char * opts[] =
9488 {
9489 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9490 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9491 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9492 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9493 "RLD_ORDER_SAFE"
9494 };
9495 unsigned int cnt;
9496 bfd_boolean first = TRUE;
9497
9498 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9499 if (entry->d_un.d_val & (1 << cnt))
9500 {
9501 printf ("%s%s", first ? "" : " ", opts[cnt]);
9502 first = FALSE;
9503 }
9504 }
9505 break;
9506
9507 case DT_MIPS_IVERSION:
9508 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9509 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9510 else
9511 {
9512 char buf[40];
9513 sprintf_vma (buf, entry->d_un.d_ptr);
9514 /* Note: coded this way so that there is a single string for translation. */
9515 printf (_("<corrupt: %s>"), buf);
9516 }
9517 break;
9518
9519 case DT_MIPS_TIME_STAMP:
9520 {
9521 char timebuf[128];
9522 struct tm * tmp;
9523 time_t atime = entry->d_un.d_val;
9524
9525 tmp = gmtime (&atime);
9526 /* PR 17531: file: 6accc532. */
9527 if (tmp == NULL)
9528 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9529 else
9530 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9531 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9532 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9533 printf (_("Time Stamp: %s"), timebuf);
9534 }
9535 break;
9536
9537 case DT_MIPS_RLD_VERSION:
9538 case DT_MIPS_LOCAL_GOTNO:
9539 case DT_MIPS_CONFLICTNO:
9540 case DT_MIPS_LIBLISTNO:
9541 case DT_MIPS_SYMTABNO:
9542 case DT_MIPS_UNREFEXTNO:
9543 case DT_MIPS_HIPAGENO:
9544 case DT_MIPS_DELTA_CLASS_NO:
9545 case DT_MIPS_DELTA_INSTANCE_NO:
9546 case DT_MIPS_DELTA_RELOC_NO:
9547 case DT_MIPS_DELTA_SYM_NO:
9548 case DT_MIPS_DELTA_CLASSSYM_NO:
9549 case DT_MIPS_COMPACT_SIZE:
9550 print_vma (entry->d_un.d_val, DEC);
9551 break;
9552
9553 case DT_MIPS_XHASH:
9554 dynamic_info_DT_MIPS_XHASH = entry->d_un.d_val;
9555 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9556 /* Falls through. */
9557
9558 default:
9559 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9560 }
9561 putchar ('\n');
9562}
9563
9564static void
9565dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9566{
9567 switch (entry->d_tag)
9568 {
9569 case DT_HP_DLD_FLAGS:
9570 {
9571 static struct
9572 {
9573 long int bit;
9574 const char * str;
9575 }
9576 flags[] =
9577 {
9578 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9579 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9580 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9581 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9582 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9583 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9584 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9585 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9586 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9587 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9588 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9589 { DT_HP_GST, "HP_GST" },
9590 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9591 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9592 { DT_HP_NODELETE, "HP_NODELETE" },
9593 { DT_HP_GROUP, "HP_GROUP" },
9594 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9595 };
9596 bfd_boolean first = TRUE;
9597 size_t cnt;
9598 bfd_vma val = entry->d_un.d_val;
9599
9600 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9601 if (val & flags[cnt].bit)
9602 {
9603 if (! first)
9604 putchar (' ');
9605 fputs (flags[cnt].str, stdout);
9606 first = FALSE;
9607 val ^= flags[cnt].bit;
9608 }
9609
9610 if (val != 0 || first)
9611 {
9612 if (! first)
9613 putchar (' ');
9614 print_vma (val, HEX);
9615 }
9616 }
9617 break;
9618
9619 default:
9620 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9621 break;
9622 }
9623 putchar ('\n');
9624}
9625
9626#ifdef BFD64
9627
9628/* VMS vs Unix time offset and factor. */
9629
9630#define VMS_EPOCH_OFFSET 35067168000000000LL
9631#define VMS_GRANULARITY_FACTOR 10000000
9632
9633/* Display a VMS time in a human readable format. */
9634
9635static void
9636print_vms_time (bfd_int64_t vmstime)
9637{
9638 struct tm *tm;
9639 time_t unxtime;
9640
9641 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9642 tm = gmtime (&unxtime);
9643 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9644 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9645 tm->tm_hour, tm->tm_min, tm->tm_sec);
9646}
9647#endif /* BFD64 */
9648
9649static void
9650dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9651{
9652 switch (entry->d_tag)
9653 {
9654 case DT_IA_64_PLT_RESERVE:
9655 /* First 3 slots reserved. */
9656 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9657 printf (" -- ");
9658 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9659 break;
9660
9661 case DT_IA_64_VMS_LINKTIME:
9662#ifdef BFD64
9663 print_vms_time (entry->d_un.d_val);
9664#endif
9665 break;
9666
9667 case DT_IA_64_VMS_LNKFLAGS:
9668 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9669 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9670 printf (" CALL_DEBUG");
9671 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9672 printf (" NOP0BUFS");
9673 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9674 printf (" P0IMAGE");
9675 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9676 printf (" MKTHREADS");
9677 if (entry->d_un.d_val & VMS_LF_UPCALLS)
9678 printf (" UPCALLS");
9679 if (entry->d_un.d_val & VMS_LF_IMGSTA)
9680 printf (" IMGSTA");
9681 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9682 printf (" INITIALIZE");
9683 if (entry->d_un.d_val & VMS_LF_MAIN)
9684 printf (" MAIN");
9685 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9686 printf (" EXE_INIT");
9687 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9688 printf (" TBK_IN_IMG");
9689 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9690 printf (" DBG_IN_IMG");
9691 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9692 printf (" TBK_IN_DSF");
9693 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9694 printf (" DBG_IN_DSF");
9695 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9696 printf (" SIGNATURES");
9697 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9698 printf (" REL_SEG_OFF");
9699 break;
9700
9701 default:
9702 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9703 break;
9704 }
9705 putchar ('\n');
9706}
9707
9708static bfd_boolean
9709get_32bit_dynamic_section (Filedata * filedata)
9710{
9711 Elf32_External_Dyn * edyn;
9712 Elf32_External_Dyn * ext;
9713 Elf_Internal_Dyn * entry;
9714
9715 edyn = (Elf32_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9716 dynamic_size, _("dynamic section"));
9717 if (!edyn)
9718 return FALSE;
9719
9720 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9721 might not have the luxury of section headers. Look for the DT_NULL
9722 terminator to determine the number of entries. */
9723 for (ext = edyn, dynamic_nent = 0;
9724 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9725 ext++)
9726 {
9727 dynamic_nent++;
9728 if (BYTE_GET (ext->d_tag) == DT_NULL)
9729 break;
9730 }
9731
9732 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9733 sizeof (* entry));
9734 if (dynamic_section == NULL)
9735 {
9736 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9737 (unsigned long) dynamic_nent);
9738 free (edyn);
9739 return FALSE;
9740 }
9741
9742 for (ext = edyn, entry = dynamic_section;
9743 entry < dynamic_section + dynamic_nent;
9744 ext++, entry++)
9745 {
9746 entry->d_tag = BYTE_GET (ext->d_tag);
9747 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9748 }
9749
9750 free (edyn);
9751
9752 return TRUE;
9753}
9754
9755static bfd_boolean
9756get_64bit_dynamic_section (Filedata * filedata)
9757{
9758 Elf64_External_Dyn * edyn;
9759 Elf64_External_Dyn * ext;
9760 Elf_Internal_Dyn * entry;
9761
9762 /* Read in the data. */
9763 edyn = (Elf64_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9764 dynamic_size, _("dynamic section"));
9765 if (!edyn)
9766 return FALSE;
9767
9768 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9769 might not have the luxury of section headers. Look for the DT_NULL
9770 terminator to determine the number of entries. */
9771 for (ext = edyn, dynamic_nent = 0;
9772 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9773 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9774 ext++)
9775 {
9776 dynamic_nent++;
9777 if (BYTE_GET (ext->d_tag) == DT_NULL)
9778 break;
9779 }
9780
9781 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9782 sizeof (* entry));
9783 if (dynamic_section == NULL)
9784 {
9785 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9786 (unsigned long) dynamic_nent);
9787 free (edyn);
9788 return FALSE;
9789 }
9790
9791 /* Convert from external to internal formats. */
9792 for (ext = edyn, entry = dynamic_section;
9793 entry < dynamic_section + dynamic_nent;
9794 ext++, entry++)
9795 {
9796 entry->d_tag = BYTE_GET (ext->d_tag);
9797 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9798 }
9799
9800 free (edyn);
9801
9802 return TRUE;
9803}
9804
9805static void
9806print_dynamic_flags (bfd_vma flags)
9807{
9808 bfd_boolean first = TRUE;
9809
9810 while (flags)
9811 {
9812 bfd_vma flag;
9813
9814 flag = flags & - flags;
9815 flags &= ~ flag;
9816
9817 if (first)
9818 first = FALSE;
9819 else
9820 putc (' ', stdout);
9821
9822 switch (flag)
9823 {
9824 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
9825 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
9826 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
9827 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
9828 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
9829 default: fputs (_("unknown"), stdout); break;
9830 }
9831 }
9832 puts ("");
9833}
9834
9835/* Parse and display the contents of the dynamic section. */
9836
9837static bfd_boolean
9838process_dynamic_section (Filedata * filedata)
9839{
9840 Elf_Internal_Dyn * entry;
9841
9842 if (dynamic_size == 0)
9843 {
9844 if (do_dynamic)
9845 printf (_("\nThere is no dynamic section in this file.\n"));
9846
9847 return TRUE;
9848 }
9849
9850 if (is_32bit_elf)
9851 {
9852 if (! get_32bit_dynamic_section (filedata))
9853 return FALSE;
9854 }
9855 else
9856 {
9857 if (! get_64bit_dynamic_section (filedata))
9858 return FALSE;
9859 }
9860
9861 /* Find the appropriate symbol table. */
9862 if (dynamic_symbols == NULL)
9863 {
9864 for (entry = dynamic_section;
9865 entry < dynamic_section + dynamic_nent;
9866 ++entry)
9867 {
9868 Elf_Internal_Shdr section;
9869
9870 if (entry->d_tag != DT_SYMTAB)
9871 continue;
9872
9873 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9874
9875 /* Since we do not know how big the symbol table is,
9876 we default to reading in the entire file (!) and
9877 processing that. This is overkill, I know, but it
9878 should work. */
9879 section.sh_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9880 if ((bfd_size_type) section.sh_offset > filedata->file_size)
9881 {
9882 /* See PR 21379 for a reproducer. */
9883 error (_("Invalid DT_SYMTAB entry: %lx\n"),
9884 (long) section.sh_offset);
9885 return FALSE;
9886 }
9887
9888 if (archive_file_offset != 0)
9889 section.sh_size = archive_file_size - section.sh_offset;
9890 else
9891 section.sh_size = filedata->file_size - section.sh_offset;
9892
9893 if (is_32bit_elf)
9894 section.sh_entsize = sizeof (Elf32_External_Sym);
9895 else
9896 section.sh_entsize = sizeof (Elf64_External_Sym);
9897 section.sh_name = filedata->string_table_length;
9898
9899 if (dynamic_symbols != NULL)
9900 {
9901 error (_("Multiple dynamic symbol table sections found\n"));
9902 free (dynamic_symbols);
9903 }
9904 dynamic_symbols = GET_ELF_SYMBOLS (filedata, &section, & num_dynamic_syms);
9905 if (num_dynamic_syms < 1)
9906 {
9907 error (_("Unable to determine the number of symbols to load\n"));
9908 continue;
9909 }
9910 }
9911 }
9912
9913 /* Similarly find a string table. */
9914 if (dynamic_strings == NULL)
9915 {
9916 for (entry = dynamic_section;
9917 entry < dynamic_section + dynamic_nent;
9918 ++entry)
9919 {
9920 unsigned long offset;
9921 long str_tab_len;
9922
9923 if (entry->d_tag != DT_STRTAB)
9924 continue;
9925
9926 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9927
9928 /* Since we do not know how big the string table is,
9929 we default to reading in the entire file (!) and
9930 processing that. This is overkill, I know, but it
9931 should work. */
9932
9933 offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9934
9935 if (archive_file_offset != 0)
9936 str_tab_len = archive_file_size - offset;
9937 else
9938 str_tab_len = filedata->file_size - offset;
9939
9940 if (str_tab_len < 1)
9941 {
9942 error
9943 (_("Unable to determine the length of the dynamic string table\n"));
9944 continue;
9945 }
9946
9947 if (dynamic_strings != NULL)
9948 {
9949 error (_("Multiple dynamic string tables found\n"));
9950 free (dynamic_strings);
9951 }
9952
9953 dynamic_strings = (char *) get_data (NULL, filedata, offset, 1,
9954 str_tab_len,
9955 _("dynamic string table"));
9956 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9957 }
9958 }
9959
9960 /* And find the syminfo section if available. */
9961 if (dynamic_syminfo == NULL)
9962 {
9963 unsigned long syminsz = 0;
9964
9965 for (entry = dynamic_section;
9966 entry < dynamic_section + dynamic_nent;
9967 ++entry)
9968 {
9969 if (entry->d_tag == DT_SYMINENT)
9970 {
9971 /* Note: these braces are necessary to avoid a syntax
9972 error from the SunOS4 C compiler. */
9973 /* PR binutils/17531: A corrupt file can trigger this test.
9974 So do not use an assert, instead generate an error message. */
9975 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9976 error (_("Bad value (%d) for SYMINENT entry\n"),
9977 (int) entry->d_un.d_val);
9978 }
9979 else if (entry->d_tag == DT_SYMINSZ)
9980 syminsz = entry->d_un.d_val;
9981 else if (entry->d_tag == DT_SYMINFO)
9982 dynamic_syminfo_offset = offset_from_vma (filedata, entry->d_un.d_val,
9983 syminsz);
9984 }
9985
9986 if (dynamic_syminfo_offset != 0 && syminsz != 0)
9987 {
9988 Elf_External_Syminfo * extsyminfo;
9989 Elf_External_Syminfo * extsym;
9990 Elf_Internal_Syminfo * syminfo;
9991
9992 /* There is a syminfo section. Read the data. */
9993 extsyminfo = (Elf_External_Syminfo *)
9994 get_data (NULL, filedata, dynamic_syminfo_offset, 1, syminsz,
9995 _("symbol information"));
9996 if (!extsyminfo)
9997 return FALSE;
9998
9999 if (dynamic_syminfo != NULL)
10000 {
10001 error (_("Multiple dynamic symbol information sections found\n"));
10002 free (dynamic_syminfo);
10003 }
10004 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
10005 if (dynamic_syminfo == NULL)
10006 {
10007 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
10008 (unsigned long) syminsz);
10009 return FALSE;
10010 }
10011
10012 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
10013 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
10014 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
10015 ++syminfo, ++extsym)
10016 {
10017 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
10018 syminfo->si_flags = BYTE_GET (extsym->si_flags);
10019 }
10020
10021 free (extsyminfo);
10022 }
10023 }
10024
10025 if (do_dynamic && dynamic_addr)
10026 printf (ngettext ("\nDynamic section at offset 0x%lx "
10027 "contains %lu entry:\n",
10028 "\nDynamic section at offset 0x%lx "
10029 "contains %lu entries:\n",
10030 dynamic_nent),
10031 dynamic_addr, (unsigned long) dynamic_nent);
10032 if (do_dynamic)
10033 printf (_(" Tag Type Name/Value\n"));
10034
10035 for (entry = dynamic_section;
10036 entry < dynamic_section + dynamic_nent;
10037 entry++)
10038 {
10039 if (do_dynamic)
10040 {
10041 const char * dtype;
10042
10043 putchar (' ');
10044 print_vma (entry->d_tag, FULL_HEX);
10045 dtype = get_dynamic_type (filedata, entry->d_tag);
10046 printf (" (%s)%*s", dtype,
10047 ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
10048 }
10049
10050 switch (entry->d_tag)
10051 {
10052 case DT_FLAGS:
10053 if (do_dynamic)
10054 print_dynamic_flags (entry->d_un.d_val);
10055 break;
10056
10057 case DT_AUXILIARY:
10058 case DT_FILTER:
10059 case DT_CONFIG:
10060 case DT_DEPAUDIT:
10061 case DT_AUDIT:
10062 if (do_dynamic)
10063 {
10064 switch (entry->d_tag)
10065 {
10066 case DT_AUXILIARY:
10067 printf (_("Auxiliary library"));
10068 break;
10069
10070 case DT_FILTER:
10071 printf (_("Filter library"));
10072 break;
10073
10074 case DT_CONFIG:
10075 printf (_("Configuration file"));
10076 break;
10077
10078 case DT_DEPAUDIT:
10079 printf (_("Dependency audit library"));
10080 break;
10081
10082 case DT_AUDIT:
10083 printf (_("Audit library"));
10084 break;
10085 }
10086
10087 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10088 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
10089 else
10090 {
10091 printf (": ");
10092 print_vma (entry->d_un.d_val, PREFIX_HEX);
10093 putchar ('\n');
10094 }
10095 }
10096 break;
10097
10098 case DT_FEATURE:
10099 if (do_dynamic)
10100 {
10101 printf (_("Flags:"));
10102
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 & DTF_1_PARINIT)
10110 {
10111 printf (" PARINIT");
10112 val ^= DTF_1_PARINIT;
10113 }
10114 if (val & DTF_1_CONFEXP)
10115 {
10116 printf (" CONFEXP");
10117 val ^= DTF_1_CONFEXP;
10118 }
10119 if (val != 0)
10120 printf (" %lx", val);
10121 puts ("");
10122 }
10123 }
10124 break;
10125
10126 case DT_POSFLAG_1:
10127 if (do_dynamic)
10128 {
10129 printf (_("Flags:"));
10130
10131 if (entry->d_un.d_val == 0)
10132 printf (_(" None\n"));
10133 else
10134 {
10135 unsigned long int val = entry->d_un.d_val;
10136
10137 if (val & DF_P1_LAZYLOAD)
10138 {
10139 printf (" LAZYLOAD");
10140 val ^= DF_P1_LAZYLOAD;
10141 }
10142 if (val & DF_P1_GROUPPERM)
10143 {
10144 printf (" GROUPPERM");
10145 val ^= DF_P1_GROUPPERM;
10146 }
10147 if (val != 0)
10148 printf (" %lx", val);
10149 puts ("");
10150 }
10151 }
10152 break;
10153
10154 case DT_FLAGS_1:
10155 if (do_dynamic)
10156 {
10157 printf (_("Flags:"));
10158 if (entry->d_un.d_val == 0)
10159 printf (_(" None\n"));
10160 else
10161 {
10162 unsigned long int val = entry->d_un.d_val;
10163
10164 if (val & DF_1_NOW)
10165 {
10166 printf (" NOW");
10167 val ^= DF_1_NOW;
10168 }
10169 if (val & DF_1_GLOBAL)
10170 {
10171 printf (" GLOBAL");
10172 val ^= DF_1_GLOBAL;
10173 }
10174 if (val & DF_1_GROUP)
10175 {
10176 printf (" GROUP");
10177 val ^= DF_1_GROUP;
10178 }
10179 if (val & DF_1_NODELETE)
10180 {
10181 printf (" NODELETE");
10182 val ^= DF_1_NODELETE;
10183 }
10184 if (val & DF_1_LOADFLTR)
10185 {
10186 printf (" LOADFLTR");
10187 val ^= DF_1_LOADFLTR;
10188 }
10189 if (val & DF_1_INITFIRST)
10190 {
10191 printf (" INITFIRST");
10192 val ^= DF_1_INITFIRST;
10193 }
10194 if (val & DF_1_NOOPEN)
10195 {
10196 printf (" NOOPEN");
10197 val ^= DF_1_NOOPEN;
10198 }
10199 if (val & DF_1_ORIGIN)
10200 {
10201 printf (" ORIGIN");
10202 val ^= DF_1_ORIGIN;
10203 }
10204 if (val & DF_1_DIRECT)
10205 {
10206 printf (" DIRECT");
10207 val ^= DF_1_DIRECT;
10208 }
10209 if (val & DF_1_TRANS)
10210 {
10211 printf (" TRANS");
10212 val ^= DF_1_TRANS;
10213 }
10214 if (val & DF_1_INTERPOSE)
10215 {
10216 printf (" INTERPOSE");
10217 val ^= DF_1_INTERPOSE;
10218 }
10219 if (val & DF_1_NODEFLIB)
10220 {
10221 printf (" NODEFLIB");
10222 val ^= DF_1_NODEFLIB;
10223 }
10224 if (val & DF_1_NODUMP)
10225 {
10226 printf (" NODUMP");
10227 val ^= DF_1_NODUMP;
10228 }
10229 if (val & DF_1_CONFALT)
10230 {
10231 printf (" CONFALT");
10232 val ^= DF_1_CONFALT;
10233 }
10234 if (val & DF_1_ENDFILTEE)
10235 {
10236 printf (" ENDFILTEE");
10237 val ^= DF_1_ENDFILTEE;
10238 }
10239 if (val & DF_1_DISPRELDNE)
10240 {
10241 printf (" DISPRELDNE");
10242 val ^= DF_1_DISPRELDNE;
10243 }
10244 if (val & DF_1_DISPRELPND)
10245 {
10246 printf (" DISPRELPND");
10247 val ^= DF_1_DISPRELPND;
10248 }
10249 if (val & DF_1_NODIRECT)
10250 {
10251 printf (" NODIRECT");
10252 val ^= DF_1_NODIRECT;
10253 }
10254 if (val & DF_1_IGNMULDEF)
10255 {
10256 printf (" IGNMULDEF");
10257 val ^= DF_1_IGNMULDEF;
10258 }
10259 if (val & DF_1_NOKSYMS)
10260 {
10261 printf (" NOKSYMS");
10262 val ^= DF_1_NOKSYMS;
10263 }
10264 if (val & DF_1_NOHDR)
10265 {
10266 printf (" NOHDR");
10267 val ^= DF_1_NOHDR;
10268 }
10269 if (val & DF_1_EDITED)
10270 {
10271 printf (" EDITED");
10272 val ^= DF_1_EDITED;
10273 }
10274 if (val & DF_1_NORELOC)
10275 {
10276 printf (" NORELOC");
10277 val ^= DF_1_NORELOC;
10278 }
10279 if (val & DF_1_SYMINTPOSE)
10280 {
10281 printf (" SYMINTPOSE");
10282 val ^= DF_1_SYMINTPOSE;
10283 }
10284 if (val & DF_1_GLOBAUDIT)
10285 {
10286 printf (" GLOBAUDIT");
10287 val ^= DF_1_GLOBAUDIT;
10288 }
10289 if (val & DF_1_SINGLETON)
10290 {
10291 printf (" SINGLETON");
10292 val ^= DF_1_SINGLETON;
10293 }
10294 if (val & DF_1_STUB)
10295 {
10296 printf (" STUB");
10297 val ^= DF_1_STUB;
10298 }
10299 if (val & DF_1_PIE)
10300 {
10301 printf (" PIE");
10302 val ^= DF_1_PIE;
10303 }
10304 if (val & DF_1_KMOD)
10305 {
10306 printf (" KMOD");
10307 val ^= DF_1_KMOD;
10308 }
10309 if (val & DF_1_WEAKFILTER)
10310 {
10311 printf (" WEAKFILTER");
10312 val ^= DF_1_WEAKFILTER;
10313 }
10314 if (val & DF_1_NOCOMMON)
10315 {
10316 printf (" NOCOMMON");
10317 val ^= DF_1_NOCOMMON;
10318 }
10319 if (val != 0)
10320 printf (" %lx", val);
10321 puts ("");
10322 }
10323 }
10324 break;
10325
10326 case DT_PLTREL:
10327 dynamic_info[entry->d_tag] = entry->d_un.d_val;
10328 if (do_dynamic)
10329 puts (get_dynamic_type (filedata, entry->d_un.d_val));
10330 break;
10331
10332 case DT_NULL :
10333 case DT_NEEDED :
10334 case DT_PLTGOT :
10335 case DT_HASH :
10336 case DT_STRTAB :
10337 case DT_SYMTAB :
10338 case DT_RELA :
10339 case DT_INIT :
10340 case DT_FINI :
10341 case DT_SONAME :
10342 case DT_RPATH :
10343 case DT_SYMBOLIC:
10344 case DT_REL :
10345 case DT_DEBUG :
10346 case DT_TEXTREL :
10347 case DT_JMPREL :
10348 case DT_RUNPATH :
10349 dynamic_info[entry->d_tag] = entry->d_un.d_val;
10350
10351 if (do_dynamic)
10352 {
10353 char * name;
10354
10355 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10356 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10357 else
10358 name = NULL;
10359
10360 if (name)
10361 {
10362 switch (entry->d_tag)
10363 {
10364 case DT_NEEDED:
10365 printf (_("Shared library: [%s]"), name);
10366
10367 if (streq (name, program_interpreter))
10368 printf (_(" program interpreter"));
10369 break;
10370
10371 case DT_SONAME:
10372 printf (_("Library soname: [%s]"), name);
10373 break;
10374
10375 case DT_RPATH:
10376 printf (_("Library rpath: [%s]"), name);
10377 break;
10378
10379 case DT_RUNPATH:
10380 printf (_("Library runpath: [%s]"), name);
10381 break;
10382
10383 default:
10384 print_vma (entry->d_un.d_val, PREFIX_HEX);
10385 break;
10386 }
10387 }
10388 else
10389 print_vma (entry->d_un.d_val, PREFIX_HEX);
10390
10391 putchar ('\n');
10392 }
10393 break;
10394
10395 case DT_PLTRELSZ:
10396 case DT_RELASZ :
10397 case DT_STRSZ :
10398 case DT_RELSZ :
10399 case DT_RELAENT :
10400 case DT_SYMENT :
10401 case DT_RELENT :
10402 dynamic_info[entry->d_tag] = entry->d_un.d_val;
10403 /* Fall through. */
10404 case DT_PLTPADSZ:
10405 case DT_MOVEENT :
10406 case DT_MOVESZ :
10407 case DT_INIT_ARRAYSZ:
10408 case DT_FINI_ARRAYSZ:
10409 case DT_GNU_CONFLICTSZ:
10410 case DT_GNU_LIBLISTSZ:
10411 if (do_dynamic)
10412 {
10413 print_vma (entry->d_un.d_val, UNSIGNED);
10414 printf (_(" (bytes)\n"));
10415 }
10416 break;
10417
10418 case DT_VERDEFNUM:
10419 case DT_VERNEEDNUM:
10420 case DT_RELACOUNT:
10421 case DT_RELCOUNT:
10422 if (do_dynamic)
10423 {
10424 print_vma (entry->d_un.d_val, UNSIGNED);
10425 putchar ('\n');
10426 }
10427 break;
10428
10429 case DT_SYMINSZ:
10430 case DT_SYMINENT:
10431 case DT_SYMINFO:
10432 case DT_USED:
10433 case DT_INIT_ARRAY:
10434 case DT_FINI_ARRAY:
10435 if (do_dynamic)
10436 {
10437 if (entry->d_tag == DT_USED
10438 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
10439 {
10440 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10441
10442 if (*name)
10443 {
10444 printf (_("Not needed object: [%s]\n"), name);
10445 break;
10446 }
10447 }
10448
10449 print_vma (entry->d_un.d_val, PREFIX_HEX);
10450 putchar ('\n');
10451 }
10452 break;
10453
10454 case DT_BIND_NOW:
10455 /* The value of this entry is ignored. */
10456 if (do_dynamic)
10457 putchar ('\n');
10458 break;
10459
10460 case DT_GNU_PRELINKED:
10461 if (do_dynamic)
10462 {
10463 struct tm * tmp;
10464 time_t atime = entry->d_un.d_val;
10465
10466 tmp = gmtime (&atime);
10467 /* PR 17533 file: 041-1244816-0.004. */
10468 if (tmp == NULL)
10469 printf (_("<corrupt time val: %lx"),
10470 (unsigned long) atime);
10471 else
10472 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10473 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10474 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10475
10476 }
10477 break;
10478
10479 case DT_GNU_HASH:
10480 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10481 if (do_dynamic)
10482 {
10483 print_vma (entry->d_un.d_val, PREFIX_HEX);
10484 putchar ('\n');
10485 }
10486 break;
10487
10488 default:
10489 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10490 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10491 entry->d_un.d_val;
10492
10493 if (do_dynamic)
10494 {
10495 switch (filedata->file_header.e_machine)
10496 {
10497 case EM_AARCH64:
10498 dynamic_section_aarch64_val (entry);
10499 break;
10500 case EM_MIPS:
10501 case EM_MIPS_RS3_LE:
10502 dynamic_section_mips_val (entry);
10503 break;
10504 case EM_PARISC:
10505 dynamic_section_parisc_val (entry);
10506 break;
10507 case EM_IA_64:
10508 dynamic_section_ia64_val (entry);
10509 break;
10510 default:
10511 print_vma (entry->d_un.d_val, PREFIX_HEX);
10512 putchar ('\n');
10513 }
10514 }
10515 break;
10516 }
10517 }
10518
10519 return TRUE;
10520}
10521
10522static char *
10523get_ver_flags (unsigned int flags)
10524{
10525 static char buff[128];
10526
10527 buff[0] = 0;
10528
10529 if (flags == 0)
10530 return _("none");
10531
10532 if (flags & VER_FLG_BASE)
10533 strcat (buff, "BASE");
10534
10535 if (flags & VER_FLG_WEAK)
10536 {
10537 if (flags & VER_FLG_BASE)
10538 strcat (buff, " | ");
10539
10540 strcat (buff, "WEAK");
10541 }
10542
10543 if (flags & VER_FLG_INFO)
10544 {
10545 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10546 strcat (buff, " | ");
10547
10548 strcat (buff, "INFO");
10549 }
10550
10551 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10552 {
10553 if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10554 strcat (buff, " | ");
10555
10556 strcat (buff, _("<unknown>"));
10557 }
10558
10559 return buff;
10560}
10561
10562/* Display the contents of the version sections. */
10563
10564static bfd_boolean
10565process_version_sections (Filedata * filedata)
10566{
10567 Elf_Internal_Shdr * section;
10568 unsigned i;
10569 bfd_boolean found = FALSE;
10570
10571 if (! do_version)
10572 return TRUE;
10573
10574 for (i = 0, section = filedata->section_headers;
10575 i < filedata->file_header.e_shnum;
10576 i++, section++)
10577 {
10578 switch (section->sh_type)
10579 {
10580 case SHT_GNU_verdef:
10581 {
10582 Elf_External_Verdef * edefs;
10583 unsigned long idx;
10584 unsigned long cnt;
10585 char * endbuf;
10586
10587 found = TRUE;
10588
10589 printf (ngettext ("\nVersion definition section '%s' "
10590 "contains %u entry:\n",
10591 "\nVersion definition section '%s' "
10592 "contains %u entries:\n",
10593 section->sh_info),
10594 printable_section_name (filedata, section),
10595 section->sh_info);
10596
10597 printf (_(" Addr: 0x"));
10598 printf_vma (section->sh_addr);
10599 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10600 (unsigned long) section->sh_offset, section->sh_link,
10601 printable_section_name_from_index (filedata, section->sh_link));
10602
10603 edefs = (Elf_External_Verdef *)
10604 get_data (NULL, filedata, section->sh_offset, 1,section->sh_size,
10605 _("version definition section"));
10606 if (!edefs)
10607 break;
10608 endbuf = (char *) edefs + section->sh_size;
10609
10610 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10611 {
10612 char * vstart;
10613 Elf_External_Verdef * edef;
10614 Elf_Internal_Verdef ent;
10615 Elf_External_Verdaux * eaux;
10616 Elf_Internal_Verdaux aux;
10617 unsigned long isum;
10618 int j;
10619
10620 vstart = ((char *) edefs) + idx;
10621 if (vstart + sizeof (*edef) > endbuf)
10622 break;
10623
10624 edef = (Elf_External_Verdef *) vstart;
10625
10626 ent.vd_version = BYTE_GET (edef->vd_version);
10627 ent.vd_flags = BYTE_GET (edef->vd_flags);
10628 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
10629 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
10630 ent.vd_hash = BYTE_GET (edef->vd_hash);
10631 ent.vd_aux = BYTE_GET (edef->vd_aux);
10632 ent.vd_next = BYTE_GET (edef->vd_next);
10633
10634 printf (_(" %#06lx: Rev: %d Flags: %s"),
10635 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10636
10637 printf (_(" Index: %d Cnt: %d "),
10638 ent.vd_ndx, ent.vd_cnt);
10639
10640 /* Check for overflow. */
10641 if (ent.vd_aux > (size_t) (endbuf - vstart))
10642 break;
10643
10644 vstart += ent.vd_aux;
10645
10646 if (vstart + sizeof (*eaux) > endbuf)
10647 break;
10648 eaux = (Elf_External_Verdaux *) vstart;
10649
10650 aux.vda_name = BYTE_GET (eaux->vda_name);
10651 aux.vda_next = BYTE_GET (eaux->vda_next);
10652
10653 if (VALID_DYNAMIC_NAME (aux.vda_name))
10654 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10655 else
10656 printf (_("Name index: %ld\n"), aux.vda_name);
10657
10658 isum = idx + ent.vd_aux;
10659
10660 for (j = 1; j < ent.vd_cnt; j++)
10661 {
10662 if (aux.vda_next < sizeof (*eaux)
10663 && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
10664 {
10665 warn (_("Invalid vda_next field of %lx\n"),
10666 aux.vda_next);
10667 j = ent.vd_cnt;
10668 break;
10669 }
10670 /* Check for overflow. */
10671 if (aux.vda_next > (size_t) (endbuf - vstart))
10672 break;
10673
10674 isum += aux.vda_next;
10675 vstart += aux.vda_next;
10676
10677 if (vstart + sizeof (*eaux) > endbuf)
10678 break;
10679 eaux = (Elf_External_Verdaux *) vstart;
10680
10681 aux.vda_name = BYTE_GET (eaux->vda_name);
10682 aux.vda_next = BYTE_GET (eaux->vda_next);
10683
10684 if (VALID_DYNAMIC_NAME (aux.vda_name))
10685 printf (_(" %#06lx: Parent %d: %s\n"),
10686 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10687 else
10688 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10689 isum, j, aux.vda_name);
10690 }
10691
10692 if (j < ent.vd_cnt)
10693 printf (_(" Version def aux past end of section\n"));
10694
10695 /* PR 17531:
10696 file: id:000001,src:000172+005151,op:splice,rep:2. */
10697 if (ent.vd_next < sizeof (*edef)
10698 && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
10699 {
10700 warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
10701 cnt = section->sh_info;
10702 break;
10703 }
10704 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
10705 break;
10706
10707 idx += ent.vd_next;
10708 }
10709
10710 if (cnt < section->sh_info)
10711 printf (_(" Version definition past end of section\n"));
10712
10713 free (edefs);
10714 }
10715 break;
10716
10717 case SHT_GNU_verneed:
10718 {
10719 Elf_External_Verneed * eneed;
10720 unsigned long idx;
10721 unsigned long cnt;
10722 char * endbuf;
10723
10724 found = TRUE;
10725
10726 printf (ngettext ("\nVersion needs section '%s' "
10727 "contains %u entry:\n",
10728 "\nVersion needs section '%s' "
10729 "contains %u entries:\n",
10730 section->sh_info),
10731 printable_section_name (filedata, section), section->sh_info);
10732
10733 printf (_(" Addr: 0x"));
10734 printf_vma (section->sh_addr);
10735 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10736 (unsigned long) section->sh_offset, section->sh_link,
10737 printable_section_name_from_index (filedata, section->sh_link));
10738
10739 eneed = (Elf_External_Verneed *) get_data (NULL, filedata,
10740 section->sh_offset, 1,
10741 section->sh_size,
10742 _("Version Needs section"));
10743 if (!eneed)
10744 break;
10745 endbuf = (char *) eneed + section->sh_size;
10746
10747 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10748 {
10749 Elf_External_Verneed * entry;
10750 Elf_Internal_Verneed ent;
10751 unsigned long isum;
10752 int j;
10753 char * vstart;
10754
10755 vstart = ((char *) eneed) + idx;
10756 if (vstart + sizeof (*entry) > endbuf)
10757 break;
10758
10759 entry = (Elf_External_Verneed *) vstart;
10760
10761 ent.vn_version = BYTE_GET (entry->vn_version);
10762 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
10763 ent.vn_file = BYTE_GET (entry->vn_file);
10764 ent.vn_aux = BYTE_GET (entry->vn_aux);
10765 ent.vn_next = BYTE_GET (entry->vn_next);
10766
10767 printf (_(" %#06lx: Version: %d"), idx, ent.vn_version);
10768
10769 if (VALID_DYNAMIC_NAME (ent.vn_file))
10770 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10771 else
10772 printf (_(" File: %lx"), ent.vn_file);
10773
10774 printf (_(" Cnt: %d\n"), ent.vn_cnt);
10775
10776 /* Check for overflow. */
10777 if (ent.vn_aux > (size_t) (endbuf - vstart))
10778 break;
10779 vstart += ent.vn_aux;
10780
10781 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10782 {
10783 Elf_External_Vernaux * eaux;
10784 Elf_Internal_Vernaux aux;
10785
10786 if (vstart + sizeof (*eaux) > endbuf)
10787 break;
10788 eaux = (Elf_External_Vernaux *) vstart;
10789
10790 aux.vna_hash = BYTE_GET (eaux->vna_hash);
10791 aux.vna_flags = BYTE_GET (eaux->vna_flags);
10792 aux.vna_other = BYTE_GET (eaux->vna_other);
10793 aux.vna_name = BYTE_GET (eaux->vna_name);
10794 aux.vna_next = BYTE_GET (eaux->vna_next);
10795
10796 if (VALID_DYNAMIC_NAME (aux.vna_name))
10797 printf (_(" %#06lx: Name: %s"),
10798 isum, GET_DYNAMIC_NAME (aux.vna_name));
10799 else
10800 printf (_(" %#06lx: Name index: %lx"),
10801 isum, aux.vna_name);
10802
10803 printf (_(" Flags: %s Version: %d\n"),
10804 get_ver_flags (aux.vna_flags), aux.vna_other);
10805
10806 if (aux.vna_next < sizeof (*eaux)
10807 && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
10808 {
10809 warn (_("Invalid vna_next field of %lx\n"),
10810 aux.vna_next);
10811 j = ent.vn_cnt;
10812 break;
10813 }
10814 /* Check for overflow. */
10815 if (aux.vna_next > (size_t) (endbuf - vstart))
10816 break;
10817 isum += aux.vna_next;
10818 vstart += aux.vna_next;
10819 }
10820
10821 if (j < ent.vn_cnt)
10822 warn (_("Missing Version Needs auxillary information\n"));
10823
10824 if (ent.vn_next < sizeof (*entry)
10825 && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
10826 {
10827 warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
10828 cnt = section->sh_info;
10829 break;
10830 }
10831 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
10832 break;
10833 idx += ent.vn_next;
10834 }
10835
10836 if (cnt < section->sh_info)
10837 warn (_("Missing Version Needs information\n"));
10838
10839 free (eneed);
10840 }
10841 break;
10842
10843 case SHT_GNU_versym:
10844 {
10845 Elf_Internal_Shdr * link_section;
10846 size_t total;
10847 unsigned int cnt;
10848 unsigned char * edata;
10849 unsigned short * data;
10850 char * strtab;
10851 Elf_Internal_Sym * symbols;
10852 Elf_Internal_Shdr * string_sec;
10853 unsigned long num_syms;
10854 long off;
10855
10856 if (section->sh_link >= filedata->file_header.e_shnum)
10857 break;
10858
10859 link_section = filedata->section_headers + section->sh_link;
10860 total = section->sh_size / sizeof (Elf_External_Versym);
10861
10862 if (link_section->sh_link >= filedata->file_header.e_shnum)
10863 break;
10864
10865 found = TRUE;
10866
10867 symbols = GET_ELF_SYMBOLS (filedata, link_section, & num_syms);
10868 if (symbols == NULL)
10869 break;
10870
10871 string_sec = filedata->section_headers + link_section->sh_link;
10872
10873 strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
10874 string_sec->sh_size,
10875 _("version string table"));
10876 if (!strtab)
10877 {
10878 free (symbols);
10879 break;
10880 }
10881
10882 printf (ngettext ("\nVersion symbols section '%s' "
10883 "contains %lu entry:\n",
10884 "\nVersion symbols section '%s' "
10885 "contains %lu entries:\n",
10886 total),
10887 printable_section_name (filedata, section), (unsigned long) total);
10888
10889 printf (_(" Addr: 0x"));
10890 printf_vma (section->sh_addr);
10891 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10892 (unsigned long) section->sh_offset, section->sh_link,
10893 printable_section_name (filedata, link_section));
10894
10895 off = offset_from_vma (filedata,
10896 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10897 total * sizeof (short));
10898 edata = (unsigned char *) get_data (NULL, filedata, off, total,
10899 sizeof (short),
10900 _("version symbol data"));
10901 if (!edata)
10902 {
10903 free (strtab);
10904 free (symbols);
10905 break;
10906 }
10907
10908 data = (short unsigned int *) cmalloc (total, sizeof (short));
10909
10910 for (cnt = total; cnt --;)
10911 data[cnt] = byte_get (edata + cnt * sizeof (short),
10912 sizeof (short));
10913
10914 free (edata);
10915
10916 for (cnt = 0; cnt < total; cnt += 4)
10917 {
10918 int j, nn;
10919 char *name;
10920 char *invalid = _("*invalid*");
10921
10922 printf (" %03x:", cnt);
10923
10924 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10925 switch (data[cnt + j])
10926 {
10927 case 0:
10928 fputs (_(" 0 (*local*) "), stdout);
10929 break;
10930
10931 case 1:
10932 fputs (_(" 1 (*global*) "), stdout);
10933 break;
10934
10935 default:
10936 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10937 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10938
10939 /* If this index value is greater than the size of the symbols
10940 array, break to avoid an out-of-bounds read. */
10941 if ((unsigned long)(cnt + j) >= num_syms)
10942 {
10943 warn (_("invalid index into symbol array\n"));
10944 break;
10945 }
10946
10947 name = NULL;
10948 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10949 {
10950 Elf_Internal_Verneed ivn;
10951 unsigned long offset;
10952
10953 offset = offset_from_vma
10954 (filedata, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10955 sizeof (Elf_External_Verneed));
10956
10957 do
10958 {
10959 Elf_Internal_Vernaux ivna;
10960 Elf_External_Verneed evn;
10961 Elf_External_Vernaux evna;
10962 unsigned long a_off;
10963
10964 if (get_data (&evn, filedata, offset, sizeof (evn), 1,
10965 _("version need")) == NULL)
10966 break;
10967
10968 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10969 ivn.vn_next = BYTE_GET (evn.vn_next);
10970
10971 a_off = offset + ivn.vn_aux;
10972
10973 do
10974 {
10975 if (get_data (&evna, filedata, a_off, sizeof (evna),
10976 1, _("version need aux (2)")) == NULL)
10977 {
10978 ivna.vna_next = 0;
10979 ivna.vna_other = 0;
10980 }
10981 else
10982 {
10983 ivna.vna_next = BYTE_GET (evna.vna_next);
10984 ivna.vna_other = BYTE_GET (evna.vna_other);
10985 }
10986
10987 a_off += ivna.vna_next;
10988 }
10989 while (ivna.vna_other != data[cnt + j]
10990 && ivna.vna_next != 0);
10991
10992 if (ivna.vna_other == data[cnt + j])
10993 {
10994 ivna.vna_name = BYTE_GET (evna.vna_name);
10995
10996 if (ivna.vna_name >= string_sec->sh_size)
10997 name = invalid;
10998 else
10999 name = strtab + ivna.vna_name;
11000 break;
11001 }
11002
11003 offset += ivn.vn_next;
11004 }
11005 while (ivn.vn_next);
11006 }
11007
11008 if (data[cnt + j] != 0x8001
11009 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11010 {
11011 Elf_Internal_Verdef ivd;
11012 Elf_External_Verdef evd;
11013 unsigned long offset;
11014
11015 offset = offset_from_vma
11016 (filedata, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11017 sizeof evd);
11018
11019 do
11020 {
11021 if (get_data (&evd, filedata, offset, sizeof (evd), 1,
11022 _("version def")) == NULL)
11023 {
11024 ivd.vd_next = 0;
11025 /* PR 17531: file: 046-1082287-0.004. */
11026 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
11027 break;
11028 }
11029 else
11030 {
11031 ivd.vd_next = BYTE_GET (evd.vd_next);
11032 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11033 }
11034
11035 offset += ivd.vd_next;
11036 }
11037 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
11038 && ivd.vd_next != 0);
11039
11040 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
11041 {
11042 Elf_External_Verdaux evda;
11043 Elf_Internal_Verdaux ivda;
11044
11045 ivd.vd_aux = BYTE_GET (evd.vd_aux);
11046
11047 if (get_data (&evda, filedata,
11048 offset - ivd.vd_next + ivd.vd_aux,
11049 sizeof (evda), 1,
11050 _("version def aux")) == NULL)
11051 break;
11052
11053 ivda.vda_name = BYTE_GET (evda.vda_name);
11054
11055 if (ivda.vda_name >= string_sec->sh_size)
11056 name = invalid;
11057 else if (name != NULL && name != invalid)
11058 name = _("*both*");
11059 else
11060 name = strtab + ivda.vda_name;
11061 }
11062 }
11063 if (name != NULL)
11064 nn += printf ("(%s%-*s",
11065 name,
11066 12 - (int) strlen (name),
11067 ")");
11068
11069 if (nn < 18)
11070 printf ("%*c", 18 - nn, ' ');
11071 }
11072
11073 putchar ('\n');
11074 }
11075
11076 free (data);
11077 free (strtab);
11078 free (symbols);
11079 }
11080 break;
11081
11082 default:
11083 break;
11084 }
11085 }
11086
11087 if (! found)
11088 printf (_("\nNo version information found in this file.\n"));
11089
11090 return TRUE;
11091}
11092
11093static const char *
11094get_symbol_binding (Filedata * filedata, unsigned int binding)
11095{
11096 static char buff[32];
11097
11098 switch (binding)
11099 {
11100 case STB_LOCAL: return "LOCAL";
11101 case STB_GLOBAL: return "GLOBAL";
11102 case STB_WEAK: return "WEAK";
11103 default:
11104 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
11105 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
11106 binding);
11107 else if (binding >= STB_LOOS && binding <= STB_HIOS)
11108 {
11109 if (binding == STB_GNU_UNIQUE
11110 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU)
11111 return "UNIQUE";
11112 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
11113 }
11114 else
11115 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
11116 return buff;
11117 }
11118}
11119
11120static const char *
11121get_symbol_type (Filedata * filedata, unsigned int type)
11122{
11123 static char buff[32];
11124
11125 switch (type)
11126 {
11127 case STT_NOTYPE: return "NOTYPE";
11128 case STT_OBJECT: return "OBJECT";
11129 case STT_FUNC: return "FUNC";
11130 case STT_SECTION: return "SECTION";
11131 case STT_FILE: return "FILE";
11132 case STT_COMMON: return "COMMON";
11133 case STT_TLS: return "TLS";
11134 case STT_RELC: return "RELC";
11135 case STT_SRELC: return "SRELC";
11136 default:
11137 if (type >= STT_LOPROC && type <= STT_HIPROC)
11138 {
11139 if (filedata->file_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
11140 return "THUMB_FUNC";
11141
11142 if (filedata->file_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
11143 return "REGISTER";
11144
11145 if (filedata->file_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
11146 return "PARISC_MILLI";
11147
11148 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
11149 }
11150 else if (type >= STT_LOOS && type <= STT_HIOS)
11151 {
11152 if (filedata->file_header.e_machine == EM_PARISC)
11153 {
11154 if (type == STT_HP_OPAQUE)
11155 return "HP_OPAQUE";
11156 if (type == STT_HP_STUB)
11157 return "HP_STUB";
11158 }
11159
11160 if (type == STT_GNU_IFUNC
11161 && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
11162 || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD))
11163 return "IFUNC";
11164
11165 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
11166 }
11167 else
11168 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
11169 return buff;
11170 }
11171}
11172
11173static const char *
11174get_symbol_visibility (unsigned int visibility)
11175{
11176 switch (visibility)
11177 {
11178 case STV_DEFAULT: return "DEFAULT";
11179 case STV_INTERNAL: return "INTERNAL";
11180 case STV_HIDDEN: return "HIDDEN";
11181 case STV_PROTECTED: return "PROTECTED";
11182 default:
11183 error (_("Unrecognized visibility value: %u\n"), visibility);
11184 return _("<unknown>");
11185 }
11186}
11187
11188static const char *
11189get_alpha_symbol_other (unsigned int other)
11190{
11191 switch (other)
11192 {
11193 case STO_ALPHA_NOPV: return "NOPV";
11194 case STO_ALPHA_STD_GPLOAD: return "STD GPLOAD";
11195 default:
11196 error (_("Unrecognized alpha specific other value: %u\n"), other);
11197 return _("<unknown>");
11198 }
11199}
11200
11201static const char *
11202get_solaris_symbol_visibility (unsigned int visibility)
11203{
11204 switch (visibility)
11205 {
11206 case 4: return "EXPORTED";
11207 case 5: return "SINGLETON";
11208 case 6: return "ELIMINATE";
11209 default: return get_symbol_visibility (visibility);
11210 }
11211}
11212
11213static const char *
11214get_aarch64_symbol_other (unsigned int other)
11215{
11216 static char buf[32];
11217
11218 if (other & STO_AARCH64_VARIANT_PCS)
11219 {
11220 other &= ~STO_AARCH64_VARIANT_PCS;
11221 if (other == 0)
11222 return "VARIANT_PCS";
11223 snprintf (buf, sizeof buf, "VARIANT_PCS | %x", other);
11224 return buf;
11225 }
11226 return NULL;
11227}
11228
11229static const char *
11230get_mips_symbol_other (unsigned int other)
11231{
11232 switch (other)
11233 {
11234 case STO_OPTIONAL: return "OPTIONAL";
11235 case STO_MIPS_PLT: return "MIPS PLT";
11236 case STO_MIPS_PIC: return "MIPS PIC";
11237 case STO_MICROMIPS: return "MICROMIPS";
11238 case STO_MICROMIPS | STO_MIPS_PIC: return "MICROMIPS, MIPS PIC";
11239 case STO_MIPS16: return "MIPS16";
11240 default: return NULL;
11241 }
11242}
11243
11244static const char *
11245get_ia64_symbol_other (Filedata * filedata, unsigned int other)
11246{
11247 if (is_ia64_vms (filedata))
11248 {
11249 static char res[32];
11250
11251 res[0] = 0;
11252
11253 /* Function types is for images and .STB files only. */
11254 switch (filedata->file_header.e_type)
11255 {
11256 case ET_DYN:
11257 case ET_EXEC:
11258 switch (VMS_ST_FUNC_TYPE (other))
11259 {
11260 case VMS_SFT_CODE_ADDR:
11261 strcat (res, " CA");
11262 break;
11263 case VMS_SFT_SYMV_IDX:
11264 strcat (res, " VEC");
11265 break;
11266 case VMS_SFT_FD:
11267 strcat (res, " FD");
11268 break;
11269 case VMS_SFT_RESERVE:
11270 strcat (res, " RSV");
11271 break;
11272 default:
11273 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11274 VMS_ST_FUNC_TYPE (other));
11275 strcat (res, " <unknown>");
11276 break;
11277 }
11278 break;
11279 default:
11280 break;
11281 }
11282 switch (VMS_ST_LINKAGE (other))
11283 {
11284 case VMS_STL_IGNORE:
11285 strcat (res, " IGN");
11286 break;
11287 case VMS_STL_RESERVE:
11288 strcat (res, " RSV");
11289 break;
11290 case VMS_STL_STD:
11291 strcat (res, " STD");
11292 break;
11293 case VMS_STL_LNK:
11294 strcat (res, " LNK");
11295 break;
11296 default:
11297 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11298 VMS_ST_LINKAGE (other));
11299 strcat (res, " <unknown>");
11300 break;
11301 }
11302
11303 if (res[0] != 0)
11304 return res + 1;
11305 else
11306 return res;
11307 }
11308 return NULL;
11309}
11310
11311static const char *
11312get_ppc64_symbol_other (unsigned int other)
11313{
11314 if ((other & ~STO_PPC64_LOCAL_MASK) != 0)
11315 return NULL;
11316
11317 other >>= STO_PPC64_LOCAL_BIT;
11318 if (other <= 6)
11319 {
11320 static char buf[32];
11321 if (other >= 2)
11322 other = ppc64_decode_local_entry (other);
11323 snprintf (buf, sizeof buf, _("<localentry>: %d"), other);
11324 return buf;
11325 }
11326 return NULL;
11327}
11328
11329static const char *
11330get_symbol_other (Filedata * filedata, unsigned int other)
11331{
11332 const char * result = NULL;
11333 static char buff [32];
11334
11335 if (other == 0)
11336 return "";
11337
11338 switch (filedata->file_header.e_machine)
11339 {
11340 case EM_ALPHA:
11341 result = get_alpha_symbol_other (other);
11342 break;
11343 case EM_AARCH64:
11344 result = get_aarch64_symbol_other (other);
11345 break;
11346 case EM_MIPS:
11347 result = get_mips_symbol_other (other);
11348 break;
11349 case EM_IA_64:
11350 result = get_ia64_symbol_other (filedata, other);
11351 break;
11352 case EM_PPC64:
11353 result = get_ppc64_symbol_other (other);
11354 break;
11355 default:
11356 result = NULL;
11357 break;
11358 }
11359
11360 if (result)
11361 return result;
11362
11363 snprintf (buff, sizeof buff, _("<other>: %x"), other);
11364 return buff;
11365}
11366
11367static const char *
11368get_symbol_index_type (Filedata * filedata, unsigned int type)
11369{
11370 static char buff[32];
11371
11372 switch (type)
11373 {
11374 case SHN_UNDEF: return "UND";
11375 case SHN_ABS: return "ABS";
11376 case SHN_COMMON: return "COM";
11377 default:
11378 if (type == SHN_IA_64_ANSI_COMMON
11379 && filedata->file_header.e_machine == EM_IA_64
11380 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
11381 return "ANSI_COM";
11382 else if ((filedata->file_header.e_machine == EM_X86_64
11383 || filedata->file_header.e_machine == EM_L1OM
11384 || filedata->file_header.e_machine == EM_K1OM)
11385 && type == SHN_X86_64_LCOMMON)
11386 return "LARGE_COM";
11387 else if ((type == SHN_MIPS_SCOMMON
11388 && filedata->file_header.e_machine == EM_MIPS)
11389 || (type == SHN_TIC6X_SCOMMON
11390 && filedata->file_header.e_machine == EM_TI_C6000))
11391 return "SCOM";
11392 else if (type == SHN_MIPS_SUNDEFINED
11393 && filedata->file_header.e_machine == EM_MIPS)
11394 return "SUND";
11395 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
11396 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
11397 else if (type >= SHN_LOOS && type <= SHN_HIOS)
11398 sprintf (buff, "OS [0x%04x]", type & 0xffff);
11399 else if (type >= SHN_LORESERVE)
11400 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
11401 else if (type >= filedata->file_header.e_shnum)
11402 sprintf (buff, _("bad section index[%3d]"), type);
11403 else
11404 sprintf (buff, "%3d", type);
11405 break;
11406 }
11407
11408 return buff;
11409}
11410
11411static bfd_vma *
11412get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_size)
11413{
11414 unsigned char * e_data;
11415 bfd_vma * i_data;
11416
11417 /* If the size_t type is smaller than the bfd_size_type, eg because
11418 you are building a 32-bit tool on a 64-bit host, then make sure
11419 that when (number) is cast to (size_t) no information is lost. */
11420 if (sizeof (size_t) < sizeof (bfd_size_type)
11421 && (bfd_size_type) ((size_t) number) != number)
11422 {
11423 error (_("Size truncation prevents reading %s elements of size %u\n"),
11424 bfd_vmatoa ("u", number), ent_size);
11425 return NULL;
11426 }
11427
11428 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11429 attempting to allocate memory when the read is bound to fail. */
11430 if (ent_size * number > filedata->file_size)
11431 {
11432 error (_("Invalid number of dynamic entries: %s\n"),
11433 bfd_vmatoa ("u", number));
11434 return NULL;
11435 }
11436
11437 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
11438 if (e_data == NULL)
11439 {
11440 error (_("Out of memory reading %s dynamic entries\n"),
11441 bfd_vmatoa ("u", number));
11442 return NULL;
11443 }
11444
11445 if (fread (e_data, ent_size, (size_t) number, filedata->handle) != number)
11446 {
11447 error (_("Unable to read in %s bytes of dynamic data\n"),
11448 bfd_vmatoa ("u", number * ent_size));
11449 free (e_data);
11450 return NULL;
11451 }
11452
11453 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
11454 if (i_data == NULL)
11455 {
11456 error (_("Out of memory allocating space for %s dynamic entries\n"),
11457 bfd_vmatoa ("u", number));
11458 free (e_data);
11459 return NULL;
11460 }
11461
11462 while (number--)
11463 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
11464
11465 free (e_data);
11466
11467 return i_data;
11468}
11469
11470static void
11471print_dynamic_symbol (Filedata * filedata, bfd_vma si, unsigned long hn)
11472{
11473 Elf_Internal_Sym * psym;
11474 int n;
11475
11476 n = print_vma (si, DEC_5);
11477 if (n < 5)
11478 fputs (&" "[n], stdout);
11479 printf (" %3lu: ", hn);
11480
11481 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
11482 {
11483 printf (_("<No info available for dynamic symbol number %lu>\n"),
11484 (unsigned long) si);
11485 return;
11486 }
11487
11488 psym = dynamic_symbols + si;
11489 print_vma (psym->st_value, LONG_HEX);
11490 putchar (' ');
11491 print_vma (psym->st_size, DEC_5);
11492
11493 printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11494 printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11495
11496 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11497 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
11498 else
11499 {
11500 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11501
11502 printf (" %-7s", get_symbol_visibility (vis));
11503 /* Check to see if any other bits in the st_other field are set.
11504 Note - displaying this information disrupts the layout of the
11505 table being generated, but for the moment this case is very
11506 rare. */
11507 if (psym->st_other ^ vis)
11508 printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11509 }
11510
11511 printf (" %3.3s ", get_symbol_index_type (filedata, psym->st_shndx));
11512 if (VALID_DYNAMIC_NAME (psym->st_name))
11513 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11514 else
11515 printf (_(" <corrupt: %14ld>"), psym->st_name);
11516 putchar ('\n');
11517}
11518
11519static const char *
11520get_symbol_version_string (Filedata * filedata,
11521 bfd_boolean is_dynsym,
11522 const char * strtab,
11523 unsigned long int strtab_size,
11524 unsigned int si,
11525 Elf_Internal_Sym * psym,
11526 enum versioned_symbol_info * sym_info,
11527 unsigned short * vna_other)
11528{
11529 unsigned char data[2];
11530 unsigned short vers_data;
11531 unsigned long offset;
11532 unsigned short max_vd_ndx;
11533
11534 if (!is_dynsym
11535 || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11536 return NULL;
11537
11538 offset = offset_from_vma (filedata, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11539 sizeof data + si * sizeof (vers_data));
11540
11541 if (get_data (&data, filedata, offset + si * sizeof (vers_data),
11542 sizeof (data), 1, _("version data")) == NULL)
11543 return NULL;
11544
11545 vers_data = byte_get (data, 2);
11546
11547 if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data == 0)
11548 return NULL;
11549
11550 *sym_info = (vers_data & VERSYM_HIDDEN) != 0 ? symbol_hidden : symbol_public;
11551 max_vd_ndx = 0;
11552
11553 /* Usually we'd only see verdef for defined symbols, and verneed for
11554 undefined symbols. However, symbols defined by the linker in
11555 .dynbss for variables copied from a shared library in order to
11556 avoid text relocations are defined yet have verneed. We could
11557 use a heuristic to detect the special case, for example, check
11558 for verneed first on symbols defined in SHT_NOBITS sections, but
11559 it is simpler and more reliable to just look for both verdef and
11560 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11561
11562 if (psym->st_shndx != SHN_UNDEF
11563 && vers_data != 0x8001
11564 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11565 {
11566 Elf_Internal_Verdef ivd;
11567 Elf_Internal_Verdaux ivda;
11568 Elf_External_Verdaux evda;
11569 unsigned long off;
11570
11571 off = offset_from_vma (filedata,
11572 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11573 sizeof (Elf_External_Verdef));
11574
11575 do
11576 {
11577 Elf_External_Verdef evd;
11578
11579 if (get_data (&evd, filedata, off, sizeof (evd), 1,
11580 _("version def")) == NULL)
11581 {
11582 ivd.vd_ndx = 0;
11583 ivd.vd_aux = 0;
11584 ivd.vd_next = 0;
11585 ivd.vd_flags = 0;
11586 }
11587 else
11588 {
11589 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11590 ivd.vd_aux = BYTE_GET (evd.vd_aux);
11591 ivd.vd_next = BYTE_GET (evd.vd_next);
11592 ivd.vd_flags = BYTE_GET (evd.vd_flags);
11593 }
11594
11595 if ((ivd.vd_ndx & VERSYM_VERSION) > max_vd_ndx)
11596 max_vd_ndx = ivd.vd_ndx & VERSYM_VERSION;
11597
11598 off += ivd.vd_next;
11599 }
11600 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11601
11602 if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11603 {
11604 if (ivd.vd_ndx == 1 && ivd.vd_flags == VER_FLG_BASE)
11605 return NULL;
11606
11607 off -= ivd.vd_next;
11608 off += ivd.vd_aux;
11609
11610 if (get_data (&evda, filedata, off, sizeof (evda), 1,
11611 _("version def aux")) != NULL)
11612 {
11613 ivda.vda_name = BYTE_GET (evda.vda_name);
11614
11615 if (psym->st_name != ivda.vda_name)
11616 return (ivda.vda_name < strtab_size
11617 ? strtab + ivda.vda_name : _("<corrupt>"));
11618 }
11619 }
11620 }
11621
11622 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11623 {
11624 Elf_External_Verneed evn;
11625 Elf_Internal_Verneed ivn;
11626 Elf_Internal_Vernaux ivna;
11627
11628 offset = offset_from_vma (filedata,
11629 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11630 sizeof evn);
11631 do
11632 {
11633 unsigned long vna_off;
11634
11635 if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11636 _("version need")) == NULL)
11637 {
11638 ivna.vna_next = 0;
11639 ivna.vna_other = 0;
11640 ivna.vna_name = 0;
11641 break;
11642 }
11643
11644 ivn.vn_aux = BYTE_GET (evn.vn_aux);
11645 ivn.vn_next = BYTE_GET (evn.vn_next);
11646
11647 vna_off = offset + ivn.vn_aux;
11648
11649 do
11650 {
11651 Elf_External_Vernaux evna;
11652
11653 if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
11654 _("version need aux (3)")) == NULL)
11655 {
11656 ivna.vna_next = 0;
11657 ivna.vna_other = 0;
11658 ivna.vna_name = 0;
11659 }
11660 else
11661 {
11662 ivna.vna_other = BYTE_GET (evna.vna_other);
11663 ivna.vna_next = BYTE_GET (evna.vna_next);
11664 ivna.vna_name = BYTE_GET (evna.vna_name);
11665 }
11666
11667 vna_off += ivna.vna_next;
11668 }
11669 while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11670
11671 if (ivna.vna_other == vers_data)
11672 break;
11673
11674 offset += ivn.vn_next;
11675 }
11676 while (ivn.vn_next != 0);
11677
11678 if (ivna.vna_other == vers_data)
11679 {
11680 *sym_info = symbol_undefined;
11681 *vna_other = ivna.vna_other;
11682 return (ivna.vna_name < strtab_size
11683 ? strtab + ivna.vna_name : _("<corrupt>"));
11684 }
11685 else if ((max_vd_ndx || (vers_data & VERSYM_VERSION) != 1)
11686 && (vers_data & VERSYM_VERSION) > max_vd_ndx)
11687 return _("<corrupt>");
11688 }
11689 return NULL;
11690}
11691
11692/* Dump the symbol table. */
11693static bfd_boolean
11694process_symbol_table (Filedata * filedata)
11695{
11696 Elf_Internal_Shdr * section;
11697 bfd_size_type nbuckets = 0;
11698 bfd_size_type nchains = 0;
11699 bfd_vma * buckets = NULL;
11700 bfd_vma * chains = NULL;
11701 bfd_vma ngnubuckets = 0;
11702 bfd_vma * gnubuckets = NULL;
11703 bfd_vma * gnuchains = NULL;
11704 bfd_vma * mipsxlat = NULL;
11705 bfd_vma gnusymidx = 0;
11706 bfd_size_type ngnuchains = 0;
11707
11708 if (!do_syms && !do_dyn_syms && !do_histogram)
11709 return TRUE;
11710
11711 if (dynamic_info[DT_HASH]
11712 && (do_histogram
11713 || (do_using_dynamic
11714 && !do_dyn_syms
11715 && dynamic_strings != NULL)))
11716 {
11717 unsigned char nb[8];
11718 unsigned char nc[8];
11719 unsigned int hash_ent_size = 4;
11720
11721 if ((filedata->file_header.e_machine == EM_ALPHA
11722 || filedata->file_header.e_machine == EM_S390
11723 || filedata->file_header.e_machine == EM_S390_OLD)
11724 && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
11725 hash_ent_size = 8;
11726
11727 if (fseek (filedata->handle,
11728 (archive_file_offset
11729 + offset_from_vma (filedata, dynamic_info[DT_HASH],
11730 sizeof nb + sizeof nc)),
11731 SEEK_SET))
11732 {
11733 error (_("Unable to seek to start of dynamic information\n"));
11734 goto no_hash;
11735 }
11736
11737 if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
11738 {
11739 error (_("Failed to read in number of buckets\n"));
11740 goto no_hash;
11741 }
11742
11743 if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
11744 {
11745 error (_("Failed to read in number of chains\n"));
11746 goto no_hash;
11747 }
11748
11749 nbuckets = byte_get (nb, hash_ent_size);
11750 nchains = byte_get (nc, hash_ent_size);
11751
11752 buckets = get_dynamic_data (filedata, nbuckets, hash_ent_size);
11753 chains = get_dynamic_data (filedata, nchains, hash_ent_size);
11754
11755 no_hash:
11756 if (buckets == NULL || chains == NULL)
11757 {
11758 if (do_using_dynamic)
11759 return FALSE;
11760 free (buckets);
11761 free (chains);
11762 buckets = NULL;
11763 chains = NULL;
11764 nbuckets = 0;
11765 nchains = 0;
11766 }
11767 }
11768
11769 if (dynamic_info_DT_GNU_HASH
11770 && (do_histogram
11771 || (do_using_dynamic
11772 && !do_dyn_syms
11773 && dynamic_strings != NULL)))
11774 {
11775 unsigned char nb[16];
11776 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11777 bfd_vma buckets_vma;
11778
11779 if (fseek (filedata->handle,
11780 (archive_file_offset
11781 + offset_from_vma (filedata, dynamic_info_DT_GNU_HASH,
11782 sizeof nb)),
11783 SEEK_SET))
11784 {
11785 error (_("Unable to seek to start of dynamic information\n"));
11786 goto no_gnu_hash;
11787 }
11788
11789 if (fread (nb, 16, 1, filedata->handle) != 1)
11790 {
11791 error (_("Failed to read in number of buckets\n"));
11792 goto no_gnu_hash;
11793 }
11794
11795 ngnubuckets = byte_get (nb, 4);
11796 gnusymidx = byte_get (nb + 4, 4);
11797 bitmaskwords = byte_get (nb + 8, 4);
11798 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11799 if (is_32bit_elf)
11800 buckets_vma += bitmaskwords * 4;
11801 else
11802 buckets_vma += bitmaskwords * 8;
11803
11804 if (fseek (filedata->handle,
11805 (archive_file_offset
11806 + offset_from_vma (filedata, buckets_vma, 4)),
11807 SEEK_SET))
11808 {
11809 error (_("Unable to seek to start of dynamic information\n"));
11810 goto no_gnu_hash;
11811 }
11812
11813 gnubuckets = get_dynamic_data (filedata, ngnubuckets, 4);
11814
11815 if (gnubuckets == NULL)
11816 goto no_gnu_hash;
11817
11818 for (i = 0; i < ngnubuckets; i++)
11819 if (gnubuckets[i] != 0)
11820 {
11821 if (gnubuckets[i] < gnusymidx)
11822 return FALSE;
11823
11824 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11825 maxchain = gnubuckets[i];
11826 }
11827
11828 if (maxchain == 0xffffffff)
11829 goto no_gnu_hash;
11830
11831 maxchain -= gnusymidx;
11832
11833 if (fseek (filedata->handle,
11834 (archive_file_offset
11835 + offset_from_vma (filedata, buckets_vma
11836 + 4 * (ngnubuckets + maxchain), 4)),
11837 SEEK_SET))
11838 {
11839 error (_("Unable to seek to start of dynamic information\n"));
11840 goto no_gnu_hash;
11841 }
11842
11843 do
11844 {
11845 if (fread (nb, 4, 1, filedata->handle) != 1)
11846 {
11847 error (_("Failed to determine last chain length\n"));
11848 goto no_gnu_hash;
11849 }
11850
11851 if (maxchain + 1 == 0)
11852 goto no_gnu_hash;
11853
11854 ++maxchain;
11855 }
11856 while ((byte_get (nb, 4) & 1) == 0);
11857
11858 if (fseek (filedata->handle,
11859 (archive_file_offset
11860 + offset_from_vma (filedata, buckets_vma + 4 * ngnubuckets, 4)),
11861 SEEK_SET))
11862 {
11863 error (_("Unable to seek to start of dynamic information\n"));
11864 goto no_gnu_hash;
11865 }
11866
11867 gnuchains = get_dynamic_data (filedata, maxchain, 4);
11868 ngnuchains = maxchain;
11869
11870 if (gnuchains == NULL)
11871 goto no_gnu_hash;
11872
11873 if (dynamic_info_DT_MIPS_XHASH)
11874 {
11875 if (fseek (filedata->handle,
11876 (archive_file_offset
11877 + offset_from_vma (filedata, (buckets_vma
11878 + 4 * (ngnubuckets
11879 + maxchain)), 4)),
11880 SEEK_SET))
11881 {
11882 error (_("Unable to seek to start of dynamic information\n"));
11883 goto no_gnu_hash;
11884 }
11885
11886 mipsxlat = get_dynamic_data (filedata, maxchain, 4);
11887 }
11888
11889 no_gnu_hash:
11890 if (dynamic_info_DT_MIPS_XHASH && mipsxlat == NULL)
11891 {
11892 free (gnuchains);
11893 gnuchains = NULL;
11894 }
11895 if (gnuchains == NULL)
11896 {
11897 free (gnubuckets);
11898 gnubuckets = NULL;
11899 ngnubuckets = 0;
11900 if (do_using_dynamic)
11901 return FALSE;
11902 }
11903 }
11904
11905 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11906 && do_syms
11907 && do_using_dynamic
11908 && dynamic_strings != NULL
11909 && dynamic_symbols != NULL)
11910 {
11911 unsigned long hn;
11912
11913 if (dynamic_info[DT_HASH])
11914 {
11915 bfd_vma si;
11916 char *visited;
11917
11918 printf (_("\nSymbol table for image:\n"));
11919 if (is_32bit_elf)
11920 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11921 else
11922 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11923
11924 visited = xcmalloc (nchains, 1);
11925 memset (visited, 0, nchains);
11926 for (hn = 0; hn < nbuckets; hn++)
11927 {
11928 for (si = buckets[hn]; si > 0; si = chains[si])
11929 {
11930 print_dynamic_symbol (filedata, si, hn);
11931 if (si >= nchains || visited[si])
11932 {
11933 error (_("histogram chain is corrupt\n"));
11934 break;
11935 }
11936 visited[si] = 1;
11937 }
11938 }
11939 free (visited);
11940 }
11941
11942 if (dynamic_info_DT_GNU_HASH)
11943 {
11944 printf (_("\nSymbol table of `%s' for image:\n"),
11945 GNU_HASH_SECTION_NAME);
11946 if (is_32bit_elf)
11947 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11948 else
11949 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11950
11951 for (hn = 0; hn < ngnubuckets; ++hn)
11952 if (gnubuckets[hn] != 0)
11953 {
11954 bfd_vma si = gnubuckets[hn];
11955 bfd_vma off = si - gnusymidx;
11956
11957 do
11958 {
11959 if (dynamic_info_DT_MIPS_XHASH)
11960 print_dynamic_symbol (filedata, mipsxlat[off], hn);
11961 else
11962 print_dynamic_symbol (filedata, si, hn);
11963 si++;
11964 }
11965 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11966 }
11967 }
11968 }
11969 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11970 && filedata->section_headers != NULL)
11971 {
11972 unsigned int i;
11973
11974 for (i = 0, section = filedata->section_headers;
11975 i < filedata->file_header.e_shnum;
11976 i++, section++)
11977 {
11978 unsigned int si;
11979 char * strtab = NULL;
11980 unsigned long int strtab_size = 0;
11981 Elf_Internal_Sym * symtab;
11982 Elf_Internal_Sym * psym;
11983 unsigned long num_syms;
11984
11985 if ((section->sh_type != SHT_SYMTAB
11986 && section->sh_type != SHT_DYNSYM)
11987 || (!do_syms
11988 && section->sh_type == SHT_SYMTAB))
11989 continue;
11990
11991 if (section->sh_entsize == 0)
11992 {
11993 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11994 printable_section_name (filedata, section));
11995 continue;
11996 }
11997
11998 num_syms = section->sh_size / section->sh_entsize;
11999 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
12000 "\nSymbol table '%s' contains %lu entries:\n",
12001 num_syms),
12002 printable_section_name (filedata, section),
12003 num_syms);
12004
12005 if (is_32bit_elf)
12006 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12007 else
12008 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12009
12010 symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
12011 if (symtab == NULL)
12012 continue;
12013
12014 if (section->sh_link == filedata->file_header.e_shstrndx)
12015 {
12016 strtab = filedata->string_table;
12017 strtab_size = filedata->string_table_length;
12018 }
12019 else if (section->sh_link < filedata->file_header.e_shnum)
12020 {
12021 Elf_Internal_Shdr * string_sec;
12022
12023 string_sec = filedata->section_headers + section->sh_link;
12024
12025 strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
12026 1, string_sec->sh_size,
12027 _("string table"));
12028 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
12029 }
12030
12031 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
12032 {
12033 const char *version_string;
12034 enum versioned_symbol_info sym_info;
12035 unsigned short vna_other;
12036
12037 printf ("%6d: ", si);
12038 print_vma (psym->st_value, LONG_HEX);
12039 putchar (' ');
12040 print_vma (psym->st_size, DEC_5);
12041 printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
12042 printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
12043 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
12044 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
12045 else
12046 {
12047 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
12048
12049 printf (" %-7s", get_symbol_visibility (vis));
12050 /* Check to see if any other bits in the st_other field are set.
12051 Note - displaying this information disrupts the layout of the
12052 table being generated, but for the moment this case is very rare. */
12053 if (psym->st_other ^ vis)
12054 printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
12055 }
12056 printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
12057 print_symbol (25, psym->st_name < strtab_size
12058 ? strtab + psym->st_name : _("<corrupt>"));
12059
12060 version_string
12061 = get_symbol_version_string (filedata,
12062 section->sh_type == SHT_DYNSYM,
12063 strtab, strtab_size, si,
12064 psym, &sym_info, &vna_other);
12065 if (version_string)
12066 {
12067 if (sym_info == symbol_undefined)
12068 printf ("@%s (%d)", version_string, vna_other);
12069 else
12070 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
12071 version_string);
12072 }
12073
12074 putchar ('\n');
12075
12076 if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
12077 && si >= section->sh_info
12078 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12079 && filedata->file_header.e_machine != EM_MIPS
12080 /* Solaris binaries have been found to violate this requirement as
12081 well. Not sure if this is a bug or an ABI requirement. */
12082 && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
12083 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
12084 si, printable_section_name (filedata, section), section->sh_info);
12085 }
12086
12087 free (symtab);
12088 if (strtab != filedata->string_table)
12089 free (strtab);
12090 }
12091 }
12092 else if (do_syms)
12093 printf
12094 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12095
12096 if (do_histogram && buckets != NULL)
12097 {
12098 unsigned long * lengths;
12099 unsigned long * counts;
12100 unsigned long hn;
12101 bfd_vma si;
12102 unsigned long maxlength = 0;
12103 unsigned long nzero_counts = 0;
12104 unsigned long nsyms = 0;
12105 char *visited;
12106
12107 printf (ngettext ("\nHistogram for bucket list length "
12108 "(total of %lu bucket):\n",
12109 "\nHistogram for bucket list length "
12110 "(total of %lu buckets):\n",
12111 (unsigned long) nbuckets),
12112 (unsigned long) nbuckets);
12113
12114 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
12115 if (lengths == NULL)
12116 {
12117 error (_("Out of memory allocating space for histogram buckets\n"));
12118 return FALSE;
12119 }
12120 visited = xcmalloc (nchains, 1);
12121 memset (visited, 0, nchains);
12122
12123 printf (_(" Length Number %% of total Coverage\n"));
12124 for (hn = 0; hn < nbuckets; ++hn)
12125 {
12126 for (si = buckets[hn]; si > 0; si = chains[si])
12127 {
12128 ++nsyms;
12129 if (maxlength < ++lengths[hn])
12130 ++maxlength;
12131 if (si >= nchains || visited[si])
12132 {
12133 error (_("histogram chain is corrupt\n"));
12134 break;
12135 }
12136 visited[si] = 1;
12137 }
12138 }
12139 free (visited);
12140
12141 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
12142 if (counts == NULL)
12143 {
12144 free (lengths);
12145 error (_("Out of memory allocating space for histogram counts\n"));
12146 return FALSE;
12147 }
12148
12149 for (hn = 0; hn < nbuckets; ++hn)
12150 ++counts[lengths[hn]];
12151
12152 if (nbuckets > 0)
12153 {
12154 unsigned long i;
12155 printf (" 0 %-10lu (%5.1f%%)\n",
12156 counts[0], (counts[0] * 100.0) / nbuckets);
12157 for (i = 1; i <= maxlength; ++i)
12158 {
12159 nzero_counts += counts[i] * i;
12160 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12161 i, counts[i], (counts[i] * 100.0) / nbuckets,
12162 (nzero_counts * 100.0) / nsyms);
12163 }
12164 }
12165
12166 free (counts);
12167 free (lengths);
12168 }
12169
12170 if (buckets != NULL)
12171 {
12172 free (buckets);
12173 free (chains);
12174 }
12175
12176 if (do_histogram && gnubuckets != NULL)
12177 {
12178 unsigned long * lengths;
12179 unsigned long * counts;
12180 unsigned long hn;
12181 unsigned long maxlength = 0;
12182 unsigned long nzero_counts = 0;
12183 unsigned long nsyms = 0;
12184
12185 printf (ngettext ("\nHistogram for `%s' bucket list length "
12186 "(total of %lu bucket):\n",
12187 "\nHistogram for `%s' bucket list length "
12188 "(total of %lu buckets):\n",
12189 (unsigned long) ngnubuckets),
12190 GNU_HASH_SECTION_NAME,
12191 (unsigned long) ngnubuckets);
12192
12193 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
12194 if (lengths == NULL)
12195 {
12196 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12197 return FALSE;
12198 }
12199
12200 printf (_(" Length Number %% of total Coverage\n"));
12201
12202 for (hn = 0; hn < ngnubuckets; ++hn)
12203 if (gnubuckets[hn] != 0)
12204 {
12205 bfd_vma off, length = 1;
12206
12207 for (off = gnubuckets[hn] - gnusymidx;
12208 /* PR 17531 file: 010-77222-0.004. */
12209 off < ngnuchains && (gnuchains[off] & 1) == 0;
12210 ++off)
12211 ++length;
12212 lengths[hn] = length;
12213 if (length > maxlength)
12214 maxlength = length;
12215 nsyms += length;
12216 }
12217
12218 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
12219 if (counts == NULL)
12220 {
12221 free (lengths);
12222 error (_("Out of memory allocating space for gnu histogram counts\n"));
12223 return FALSE;
12224 }
12225
12226 for (hn = 0; hn < ngnubuckets; ++hn)
12227 ++counts[lengths[hn]];
12228
12229 if (ngnubuckets > 0)
12230 {
12231 unsigned long j;
12232 printf (" 0 %-10lu (%5.1f%%)\n",
12233 counts[0], (counts[0] * 100.0) / ngnubuckets);
12234 for (j = 1; j <= maxlength; ++j)
12235 {
12236 nzero_counts += counts[j] * j;
12237 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12238 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
12239 (nzero_counts * 100.0) / nsyms);
12240 }
12241 }
12242
12243 free (counts);
12244 free (lengths);
12245 free (gnubuckets);
12246 free (gnuchains);
12247 free (mipsxlat);
12248 }
12249
12250 return TRUE;
12251}
12252
12253static bfd_boolean
12254process_syminfo (Filedata * filedata ATTRIBUTE_UNUSED)
12255{
12256 unsigned int i;
12257
12258 if (dynamic_syminfo == NULL
12259 || !do_dynamic)
12260 /* No syminfo, this is ok. */
12261 return TRUE;
12262
12263 /* There better should be a dynamic symbol section. */
12264 if (dynamic_symbols == NULL || dynamic_strings == NULL)
12265 return FALSE;
12266
12267 if (dynamic_addr)
12268 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12269 "contains %d entry:\n",
12270 "\nDynamic info segment at offset 0x%lx "
12271 "contains %d entries:\n",
12272 dynamic_syminfo_nent),
12273 dynamic_syminfo_offset, dynamic_syminfo_nent);
12274
12275 printf (_(" Num: Name BoundTo Flags\n"));
12276 for (i = 0; i < dynamic_syminfo_nent; ++i)
12277 {
12278 unsigned short int flags = dynamic_syminfo[i].si_flags;
12279
12280 printf ("%4d: ", i);
12281 if (i >= num_dynamic_syms)
12282 printf (_("<corrupt index>"));
12283 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
12284 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
12285 else
12286 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
12287 putchar (' ');
12288
12289 switch (dynamic_syminfo[i].si_boundto)
12290 {
12291 case SYMINFO_BT_SELF:
12292 fputs ("SELF ", stdout);
12293 break;
12294 case SYMINFO_BT_PARENT:
12295 fputs ("PARENT ", stdout);
12296 break;
12297 default:
12298 if (dynamic_syminfo[i].si_boundto > 0
12299 && dynamic_syminfo[i].si_boundto < dynamic_nent
12300 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
12301 {
12302 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
12303 putchar (' ' );
12304 }
12305 else
12306 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
12307 break;
12308 }
12309
12310 if (flags & SYMINFO_FLG_DIRECT)
12311 printf (" DIRECT");
12312 if (flags & SYMINFO_FLG_PASSTHRU)
12313 printf (" PASSTHRU");
12314 if (flags & SYMINFO_FLG_COPY)
12315 printf (" COPY");
12316 if (flags & SYMINFO_FLG_LAZYLOAD)
12317 printf (" LAZYLOAD");
12318
12319 puts ("");
12320 }
12321
12322 return TRUE;
12323}
12324
12325/* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
12326 is contained by the region START .. END. The types of ADDR, START
12327 and END should all be the same. Note both ADDR + NELEM and END
12328 point to just beyond the end of the regions that are being tested. */
12329#define IN_RANGE(START,END,ADDR,NELEM) \
12330 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
12331
12332/* Check to see if the given reloc needs to be handled in a target specific
12333 manner. If so then process the reloc and return TRUE otherwise return
12334 FALSE.
12335
12336 If called with reloc == NULL, then this is a signal that reloc processing
12337 for the current section has finished, and any saved state should be
12338 discarded. */
12339
12340static bfd_boolean
12341target_specific_reloc_handling (Filedata * filedata,
12342 Elf_Internal_Rela * reloc,
12343 unsigned char * start,
12344 unsigned char * end,
12345 Elf_Internal_Sym * symtab,
12346 unsigned long num_syms)
12347{
12348 unsigned int reloc_type = 0;
12349 unsigned long sym_index = 0;
12350
12351 if (reloc)
12352 {
12353 reloc_type = get_reloc_type (filedata, reloc->r_info);
12354 sym_index = get_reloc_symindex (reloc->r_info);
12355 }
12356
12357 switch (filedata->file_header.e_machine)
12358 {
12359 case EM_MSP430:
12360 case EM_MSP430_OLD:
12361 {
12362 static Elf_Internal_Sym * saved_sym = NULL;
12363
12364 if (reloc == NULL)
12365 {
12366 saved_sym = NULL;
12367 return TRUE;
12368 }
12369
12370 switch (reloc_type)
12371 {
12372 case 10: /* R_MSP430_SYM_DIFF */
12373 if (uses_msp430x_relocs (filedata))
12374 break;
12375 /* Fall through. */
12376 case 21: /* R_MSP430X_SYM_DIFF */
12377 /* PR 21139. */
12378 if (sym_index >= num_syms)
12379 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12380 sym_index);
12381 else
12382 saved_sym = symtab + sym_index;
12383 return TRUE;
12384
12385 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12386 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12387 goto handle_sym_diff;
12388
12389 case 5: /* R_MSP430_16_BYTE */
12390 case 9: /* R_MSP430_8 */
12391 if (uses_msp430x_relocs (filedata))
12392 break;
12393 goto handle_sym_diff;
12394
12395 case 2: /* R_MSP430_ABS16 */
12396 case 15: /* R_MSP430X_ABS16 */
12397 if (! uses_msp430x_relocs (filedata))
12398 break;
12399 goto handle_sym_diff;
12400
12401 handle_sym_diff:
12402 if (saved_sym != NULL)
12403 {
12404 int reloc_size = reloc_type == 1 ? 4 : 2;
12405 bfd_vma value;
12406
12407 if (sym_index >= num_syms)
12408 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12409 sym_index);
12410 else
12411 {
12412 value = reloc->r_addend + (symtab[sym_index].st_value
12413 - saved_sym->st_value);
12414
12415 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12416 byte_put (start + reloc->r_offset, value, reloc_size);
12417 else
12418 /* PR 21137 */
12419 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12420 (long) reloc->r_offset);
12421 }
12422
12423 saved_sym = NULL;
12424 return TRUE;
12425 }
12426 break;
12427
12428 default:
12429 if (saved_sym != NULL)
12430 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12431 break;
12432 }
12433 break;
12434 }
12435
12436 case EM_MN10300:
12437 case EM_CYGNUS_MN10300:
12438 {
12439 static Elf_Internal_Sym * saved_sym = NULL;
12440
12441 if (reloc == NULL)
12442 {
12443 saved_sym = NULL;
12444 return TRUE;
12445 }
12446
12447 switch (reloc_type)
12448 {
12449 case 34: /* R_MN10300_ALIGN */
12450 return TRUE;
12451 case 33: /* R_MN10300_SYM_DIFF */
12452 if (sym_index >= num_syms)
12453 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12454 sym_index);
12455 else
12456 saved_sym = symtab + sym_index;
12457 return TRUE;
12458
12459 case 1: /* R_MN10300_32 */
12460 case 2: /* R_MN10300_16 */
12461 if (saved_sym != NULL)
12462 {
12463 int reloc_size = reloc_type == 1 ? 4 : 2;
12464 bfd_vma value;
12465
12466 if (sym_index >= num_syms)
12467 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12468 sym_index);
12469 else
12470 {
12471 value = reloc->r_addend + (symtab[sym_index].st_value
12472 - saved_sym->st_value);
12473
12474 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12475 byte_put (start + reloc->r_offset, value, reloc_size);
12476 else
12477 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12478 (long) reloc->r_offset);
12479 }
12480
12481 saved_sym = NULL;
12482 return TRUE;
12483 }
12484 break;
12485 default:
12486 if (saved_sym != NULL)
12487 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12488 break;
12489 }
12490 break;
12491 }
12492
12493 case EM_RL78:
12494 {
12495 static bfd_vma saved_sym1 = 0;
12496 static bfd_vma saved_sym2 = 0;
12497 static bfd_vma value;
12498
12499 if (reloc == NULL)
12500 {
12501 saved_sym1 = saved_sym2 = 0;
12502 return TRUE;
12503 }
12504
12505 switch (reloc_type)
12506 {
12507 case 0x80: /* R_RL78_SYM. */
12508 saved_sym1 = saved_sym2;
12509 if (sym_index >= num_syms)
12510 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12511 sym_index);
12512 else
12513 {
12514 saved_sym2 = symtab[sym_index].st_value;
12515 saved_sym2 += reloc->r_addend;
12516 }
12517 return TRUE;
12518
12519 case 0x83: /* R_RL78_OPsub. */
12520 value = saved_sym1 - saved_sym2;
12521 saved_sym2 = saved_sym1 = 0;
12522 return TRUE;
12523 break;
12524
12525 case 0x41: /* R_RL78_ABS32. */
12526 if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12527 byte_put (start + reloc->r_offset, value, 4);
12528 else
12529 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12530 (long) reloc->r_offset);
12531 value = 0;
12532 return TRUE;
12533
12534 case 0x43: /* R_RL78_ABS16. */
12535 if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12536 byte_put (start + reloc->r_offset, value, 2);
12537 else
12538 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12539 (long) reloc->r_offset);
12540 value = 0;
12541 return TRUE;
12542
12543 default:
12544 break;
12545 }
12546 break;
12547 }
12548 }
12549
12550 return FALSE;
12551}
12552
12553/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12554 DWARF debug sections. This is a target specific test. Note - we do not
12555 go through the whole including-target-headers-multiple-times route, (as
12556 we have already done with <elf/h8.h>) because this would become very
12557 messy and even then this function would have to contain target specific
12558 information (the names of the relocs instead of their numeric values).
12559 FIXME: This is not the correct way to solve this problem. The proper way
12560 is to have target specific reloc sizing and typing functions created by
12561 the reloc-macros.h header, in the same way that it already creates the
12562 reloc naming functions. */
12563
12564static bfd_boolean
12565is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12566{
12567 /* Please keep this table alpha-sorted for ease of visual lookup. */
12568 switch (filedata->file_header.e_machine)
12569 {
12570 case EM_386:
12571 case EM_IAMCU:
12572 return reloc_type == 1; /* R_386_32. */
12573 case EM_68K:
12574 return reloc_type == 1; /* R_68K_32. */
12575 case EM_860:
12576 return reloc_type == 1; /* R_860_32. */
12577 case EM_960:
12578 return reloc_type == 2; /* R_960_32. */
12579 case EM_AARCH64:
12580 return (reloc_type == 258
12581 || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12582 case EM_BPF:
12583 return reloc_type == 11; /* R_BPF_DATA_32 */
12584 case EM_ADAPTEVA_EPIPHANY:
12585 return reloc_type == 3;
12586 case EM_ALPHA:
12587 return reloc_type == 1; /* R_ALPHA_REFLONG. */
12588 case EM_ARC:
12589 return reloc_type == 1; /* R_ARC_32. */
12590 case EM_ARC_COMPACT:
12591 case EM_ARC_COMPACT2:
12592 return reloc_type == 4; /* R_ARC_32. */
12593 case EM_ARM:
12594 return reloc_type == 2; /* R_ARM_ABS32 */
12595 case EM_AVR_OLD:
12596 case EM_AVR:
12597 return reloc_type == 1;
12598 case EM_BLACKFIN:
12599 return reloc_type == 0x12; /* R_byte4_data. */
12600 case EM_CRIS:
12601 return reloc_type == 3; /* R_CRIS_32. */
12602 case EM_CR16:
12603 return reloc_type == 3; /* R_CR16_NUM32. */
12604 case EM_CRX:
12605 return reloc_type == 15; /* R_CRX_NUM32. */
12606 case EM_CSKY:
12607 return reloc_type == 1; /* R_CKCORE_ADDR32. */
12608 case EM_CYGNUS_FRV:
12609 return reloc_type == 1;
12610 case EM_CYGNUS_D10V:
12611 case EM_D10V:
12612 return reloc_type == 6; /* R_D10V_32. */
12613 case EM_CYGNUS_D30V:
12614 case EM_D30V:
12615 return reloc_type == 12; /* R_D30V_32_NORMAL. */
12616 case EM_DLX:
12617 return reloc_type == 3; /* R_DLX_RELOC_32. */
12618 case EM_CYGNUS_FR30:
12619 case EM_FR30:
12620 return reloc_type == 3; /* R_FR30_32. */
12621 case EM_FT32:
12622 return reloc_type == 1; /* R_FT32_32. */
12623 case EM_H8S:
12624 case EM_H8_300:
12625 case EM_H8_300H:
12626 return reloc_type == 1; /* R_H8_DIR32. */
12627 case EM_IA_64:
12628 return (reloc_type == 0x64 /* R_IA64_SECREL32MSB. */
12629 || reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
12630 || reloc_type == 0x24 /* R_IA64_DIR32MSB. */
12631 || reloc_type == 0x25 /* R_IA64_DIR32LSB. */);
12632 case EM_IP2K_OLD:
12633 case EM_IP2K:
12634 return reloc_type == 2; /* R_IP2K_32. */
12635 case EM_IQ2000:
12636 return reloc_type == 2; /* R_IQ2000_32. */
12637 case EM_LATTICEMICO32:
12638 return reloc_type == 3; /* R_LM32_32. */
12639 case EM_M32C_OLD:
12640 case EM_M32C:
12641 return reloc_type == 3; /* R_M32C_32. */
12642 case EM_M32R:
12643 return reloc_type == 34; /* R_M32R_32_RELA. */
12644 case EM_68HC11:
12645 case EM_68HC12:
12646 return reloc_type == 6; /* R_M68HC11_32. */
12647 case EM_S12Z:
12648 return reloc_type == 7 || /* R_S12Z_EXT32 */
12649 reloc_type == 6; /* R_S12Z_CW32. */
12650 case EM_MCORE:
12651 return reloc_type == 1; /* R_MCORE_ADDR32. */
12652 case EM_CYGNUS_MEP:
12653 return reloc_type == 4; /* R_MEP_32. */
12654 case EM_METAG:
12655 return reloc_type == 2; /* R_METAG_ADDR32. */
12656 case EM_MICROBLAZE:
12657 return reloc_type == 1; /* R_MICROBLAZE_32. */
12658 case EM_MIPS:
12659 return reloc_type == 2; /* R_MIPS_32. */
12660 case EM_MMIX:
12661 return reloc_type == 4; /* R_MMIX_32. */
12662 case EM_CYGNUS_MN10200:
12663 case EM_MN10200:
12664 return reloc_type == 1; /* R_MN10200_32. */
12665 case EM_CYGNUS_MN10300:
12666 case EM_MN10300:
12667 return reloc_type == 1; /* R_MN10300_32. */
12668 case EM_MOXIE:
12669 return reloc_type == 1; /* R_MOXIE_32. */
12670 case EM_MSP430_OLD:
12671 case EM_MSP430:
12672 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12673 case EM_MT:
12674 return reloc_type == 2; /* R_MT_32. */
12675 case EM_NDS32:
12676 return reloc_type == 20; /* R_NDS32_RELA. */
12677 case EM_ALTERA_NIOS2:
12678 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
12679 case EM_NIOS32:
12680 return reloc_type == 1; /* R_NIOS_32. */
12681 case EM_OR1K:
12682 return reloc_type == 1; /* R_OR1K_32. */
12683 case EM_PARISC:
12684 return (reloc_type == 1 /* R_PARISC_DIR32. */
12685 || reloc_type == 2 /* R_PARISC_DIR21L. */
12686 || reloc_type == 41); /* R_PARISC_SECREL32. */
12687 case EM_PJ:
12688 case EM_PJ_OLD:
12689 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
12690 case EM_PPC64:
12691 return reloc_type == 1; /* R_PPC64_ADDR32. */
12692 case EM_PPC:
12693 return reloc_type == 1; /* R_PPC_ADDR32. */
12694 case EM_TI_PRU:
12695 return reloc_type == 11; /* R_PRU_BFD_RELOC_32. */
12696 case EM_RISCV:
12697 return reloc_type == 1; /* R_RISCV_32. */
12698 case EM_RL78:
12699 return reloc_type == 1; /* R_RL78_DIR32. */
12700 case EM_RX:
12701 return reloc_type == 1; /* R_RX_DIR32. */
12702 case EM_S370:
12703 return reloc_type == 1; /* R_I370_ADDR31. */
12704 case EM_S390_OLD:
12705 case EM_S390:
12706 return reloc_type == 4; /* R_S390_32. */
12707 case EM_SCORE:
12708 return reloc_type == 8; /* R_SCORE_ABS32. */
12709 case EM_SH:
12710 return reloc_type == 1; /* R_SH_DIR32. */
12711 case EM_SPARC32PLUS:
12712 case EM_SPARCV9:
12713 case EM_SPARC:
12714 return reloc_type == 3 /* R_SPARC_32. */
12715 || reloc_type == 23; /* R_SPARC_UA32. */
12716 case EM_SPU:
12717 return reloc_type == 6; /* R_SPU_ADDR32 */
12718 case EM_TI_C6000:
12719 return reloc_type == 1; /* R_C6000_ABS32. */
12720 case EM_TILEGX:
12721 return reloc_type == 2; /* R_TILEGX_32. */
12722 case EM_TILEPRO:
12723 return reloc_type == 1; /* R_TILEPRO_32. */
12724 case EM_CYGNUS_V850:
12725 case EM_V850:
12726 return reloc_type == 6; /* R_V850_ABS32. */
12727 case EM_V800:
12728 return reloc_type == 0x33; /* R_V810_WORD. */
12729 case EM_VAX:
12730 return reloc_type == 1; /* R_VAX_32. */
12731 case EM_VISIUM:
12732 return reloc_type == 3; /* R_VISIUM_32. */
12733 case EM_WEBASSEMBLY:
12734 return reloc_type == 1; /* R_WASM32_32. */
12735 case EM_X86_64:
12736 case EM_L1OM:
12737 case EM_K1OM:
12738 return reloc_type == 10; /* R_X86_64_32. */
12739 case EM_XC16X:
12740 case EM_C166:
12741 return reloc_type == 3; /* R_XC16C_ABS_32. */
12742 case EM_XGATE:
12743 return reloc_type == 4; /* R_XGATE_32. */
12744 case EM_XSTORMY16:
12745 return reloc_type == 1; /* R_XSTROMY16_32. */
12746 case EM_XTENSA_OLD:
12747 case EM_XTENSA:
12748 return reloc_type == 1; /* R_XTENSA_32. */
12749 case EM_Z80:
12750 return reloc_type == 6; /* R_Z80_32. */
12751 default:
12752 {
12753 static unsigned int prev_warn = 0;
12754
12755 /* Avoid repeating the same warning multiple times. */
12756 if (prev_warn != filedata->file_header.e_machine)
12757 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12758 filedata->file_header.e_machine);
12759 prev_warn = filedata->file_header.e_machine;
12760 return FALSE;
12761 }
12762 }
12763}
12764
12765/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12766 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12767
12768static bfd_boolean
12769is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12770{
12771 switch (filedata->file_header.e_machine)
12772 /* Please keep this table alpha-sorted for ease of visual lookup. */
12773 {
12774 case EM_386:
12775 case EM_IAMCU:
12776 return reloc_type == 2; /* R_386_PC32. */
12777 case EM_68K:
12778 return reloc_type == 4; /* R_68K_PC32. */
12779 case EM_AARCH64:
12780 return reloc_type == 261; /* R_AARCH64_PREL32 */
12781 case EM_ADAPTEVA_EPIPHANY:
12782 return reloc_type == 6;
12783 case EM_ALPHA:
12784 return reloc_type == 10; /* R_ALPHA_SREL32. */
12785 case EM_ARC_COMPACT:
12786 case EM_ARC_COMPACT2:
12787 return reloc_type == 49; /* R_ARC_32_PCREL. */
12788 case EM_ARM:
12789 return reloc_type == 3; /* R_ARM_REL32 */
12790 case EM_AVR_OLD:
12791 case EM_AVR:
12792 return reloc_type == 36; /* R_AVR_32_PCREL. */
12793 case EM_MICROBLAZE:
12794 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
12795 case EM_OR1K:
12796 return reloc_type == 9; /* R_OR1K_32_PCREL. */
12797 case EM_PARISC:
12798 return reloc_type == 9; /* R_PARISC_PCREL32. */
12799 case EM_PPC:
12800 return reloc_type == 26; /* R_PPC_REL32. */
12801 case EM_PPC64:
12802 return reloc_type == 26; /* R_PPC64_REL32. */
12803 case EM_RISCV:
12804 return reloc_type == 57; /* R_RISCV_32_PCREL. */
12805 case EM_S390_OLD:
12806 case EM_S390:
12807 return reloc_type == 5; /* R_390_PC32. */
12808 case EM_SH:
12809 return reloc_type == 2; /* R_SH_REL32. */
12810 case EM_SPARC32PLUS:
12811 case EM_SPARCV9:
12812 case EM_SPARC:
12813 return reloc_type == 6; /* R_SPARC_DISP32. */
12814 case EM_SPU:
12815 return reloc_type == 13; /* R_SPU_REL32. */
12816 case EM_TILEGX:
12817 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
12818 case EM_TILEPRO:
12819 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
12820 case EM_VISIUM:
12821 return reloc_type == 6; /* R_VISIUM_32_PCREL */
12822 case EM_X86_64:
12823 case EM_L1OM:
12824 case EM_K1OM:
12825 return reloc_type == 2; /* R_X86_64_PC32. */
12826 case EM_VAX:
12827 return reloc_type == 4; /* R_VAX_PCREL32. */
12828 case EM_XTENSA_OLD:
12829 case EM_XTENSA:
12830 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
12831 default:
12832 /* Do not abort or issue an error message here. Not all targets use
12833 pc-relative 32-bit relocs in their DWARF debug information and we
12834 have already tested for target coverage in is_32bit_abs_reloc. A
12835 more helpful warning message will be generated by apply_relocations
12836 anyway, so just return. */
12837 return FALSE;
12838 }
12839}
12840
12841/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12842 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12843
12844static bfd_boolean
12845is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12846{
12847 switch (filedata->file_header.e_machine)
12848 {
12849 case EM_AARCH64:
12850 return reloc_type == 257; /* R_AARCH64_ABS64. */
12851 case EM_ALPHA:
12852 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
12853 case EM_IA_64:
12854 return (reloc_type == 0x26 /* R_IA64_DIR64MSB. */
12855 || reloc_type == 0x27 /* R_IA64_DIR64LSB. */);
12856 case EM_PARISC:
12857 return reloc_type == 80; /* R_PARISC_DIR64. */
12858 case EM_PPC64:
12859 return reloc_type == 38; /* R_PPC64_ADDR64. */
12860 case EM_RISCV:
12861 return reloc_type == 2; /* R_RISCV_64. */
12862 case EM_SPARC32PLUS:
12863 case EM_SPARCV9:
12864 case EM_SPARC:
12865 return reloc_type == 32 /* R_SPARC_64. */
12866 || reloc_type == 54; /* R_SPARC_UA64. */
12867 case EM_X86_64:
12868 case EM_L1OM:
12869 case EM_K1OM:
12870 return reloc_type == 1; /* R_X86_64_64. */
12871 case EM_S390_OLD:
12872 case EM_S390:
12873 return reloc_type == 22; /* R_S390_64. */
12874 case EM_TILEGX:
12875 return reloc_type == 1; /* R_TILEGX_64. */
12876 case EM_MIPS:
12877 return reloc_type == 18; /* R_MIPS_64. */
12878 default:
12879 return FALSE;
12880 }
12881}
12882
12883/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12884 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12885
12886static bfd_boolean
12887is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12888{
12889 switch (filedata->file_header.e_machine)
12890 {
12891 case EM_AARCH64:
12892 return reloc_type == 260; /* R_AARCH64_PREL64. */
12893 case EM_ALPHA:
12894 return reloc_type == 11; /* R_ALPHA_SREL64. */
12895 case EM_IA_64:
12896 return (reloc_type == 0x4e /* R_IA64_PCREL64MSB. */
12897 || reloc_type == 0x4f /* R_IA64_PCREL64LSB. */);
12898 case EM_PARISC:
12899 return reloc_type == 72; /* R_PARISC_PCREL64. */
12900 case EM_PPC64:
12901 return reloc_type == 44; /* R_PPC64_REL64. */
12902 case EM_SPARC32PLUS:
12903 case EM_SPARCV9:
12904 case EM_SPARC:
12905 return reloc_type == 46; /* R_SPARC_DISP64. */
12906 case EM_X86_64:
12907 case EM_L1OM:
12908 case EM_K1OM:
12909 return reloc_type == 24; /* R_X86_64_PC64. */
12910 case EM_S390_OLD:
12911 case EM_S390:
12912 return reloc_type == 23; /* R_S390_PC64. */
12913 case EM_TILEGX:
12914 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
12915 default:
12916 return FALSE;
12917 }
12918}
12919
12920/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12921 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12922
12923static bfd_boolean
12924is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12925{
12926 switch (filedata->file_header.e_machine)
12927 {
12928 case EM_CYGNUS_MN10200:
12929 case EM_MN10200:
12930 return reloc_type == 4; /* R_MN10200_24. */
12931 case EM_FT32:
12932 return reloc_type == 5; /* R_FT32_20. */
12933 case EM_Z80:
12934 return reloc_type == 5; /* R_Z80_24. */
12935 default:
12936 return FALSE;
12937 }
12938}
12939
12940/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12941 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12942
12943static bfd_boolean
12944is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12945{
12946 /* Please keep this table alpha-sorted for ease of visual lookup. */
12947 switch (filedata->file_header.e_machine)
12948 {
12949 case EM_ARC:
12950 case EM_ARC_COMPACT:
12951 case EM_ARC_COMPACT2:
12952 return reloc_type == 2; /* R_ARC_16. */
12953 case EM_ADAPTEVA_EPIPHANY:
12954 return reloc_type == 5;
12955 case EM_AVR_OLD:
12956 case EM_AVR:
12957 return reloc_type == 4; /* R_AVR_16. */
12958 case EM_CYGNUS_D10V:
12959 case EM_D10V:
12960 return reloc_type == 3; /* R_D10V_16. */
12961 case EM_FT32:
12962 return reloc_type == 2; /* R_FT32_16. */
12963 case EM_H8S:
12964 case EM_H8_300:
12965 case EM_H8_300H:
12966 return reloc_type == R_H8_DIR16;
12967 case EM_IP2K_OLD:
12968 case EM_IP2K:
12969 return reloc_type == 1; /* R_IP2K_16. */
12970 case EM_M32C_OLD:
12971 case EM_M32C:
12972 return reloc_type == 1; /* R_M32C_16 */
12973 case EM_CYGNUS_MN10200:
12974 case EM_MN10200:
12975 return reloc_type == 2; /* R_MN10200_16. */
12976 case EM_CYGNUS_MN10300:
12977 case EM_MN10300:
12978 return reloc_type == 2; /* R_MN10300_16. */
12979 case EM_MSP430:
12980 if (uses_msp430x_relocs (filedata))
12981 return reloc_type == 2; /* R_MSP430_ABS16. */
12982 /* Fall through. */
12983 case EM_MSP430_OLD:
12984 return reloc_type == 5; /* R_MSP430_16_BYTE. */
12985 case EM_NDS32:
12986 return reloc_type == 19; /* R_NDS32_RELA. */
12987 case EM_ALTERA_NIOS2:
12988 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
12989 case EM_NIOS32:
12990 return reloc_type == 9; /* R_NIOS_16. */
12991 case EM_OR1K:
12992 return reloc_type == 2; /* R_OR1K_16. */
12993 case EM_RISCV:
12994 return reloc_type == 55; /* R_RISCV_SET16. */
12995 case EM_TI_PRU:
12996 return reloc_type == 8; /* R_PRU_BFD_RELOC_16. */
12997 case EM_TI_C6000:
12998 return reloc_type == 2; /* R_C6000_ABS16. */
12999 case EM_VISIUM:
13000 return reloc_type == 2; /* R_VISIUM_16. */
13001 case EM_XC16X:
13002 case EM_C166:
13003 return reloc_type == 2; /* R_XC16C_ABS_16. */
13004 case EM_XGATE:
13005 return reloc_type == 3; /* R_XGATE_16. */
13006 case EM_Z80:
13007 return reloc_type == 4; /* R_Z80_16. */
13008 default:
13009 return FALSE;
13010 }
13011}
13012
13013/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13014 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13015
13016static bfd_boolean
13017is_8bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
13018{
13019 switch (filedata->file_header.e_machine)
13020 {
13021 case EM_RISCV:
13022 return reloc_type == 54; /* R_RISCV_SET8. */
13023 case EM_Z80:
13024 return reloc_type == 1; /* R_Z80_8. */
13025 default:
13026 return FALSE;
13027 }
13028}
13029
13030/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13031 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13032
13033static bfd_boolean
13034is_6bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
13035{
13036 switch (filedata->file_header.e_machine)
13037 {
13038 case EM_RISCV:
13039 return reloc_type == 53; /* R_RISCV_SET6. */
13040 default:
13041 return FALSE;
13042 }
13043}
13044
13045/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13046 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13047
13048static bfd_boolean
13049is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13050{
13051 /* Please keep this table alpha-sorted for ease of visual lookup. */
13052 switch (filedata->file_header.e_machine)
13053 {
13054 case EM_RISCV:
13055 return reloc_type == 35; /* R_RISCV_ADD32. */
13056 default:
13057 return FALSE;
13058 }
13059}
13060
13061/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13062 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13063
13064static bfd_boolean
13065is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13066{
13067 /* Please keep this table alpha-sorted for ease of visual lookup. */
13068 switch (filedata->file_header.e_machine)
13069 {
13070 case EM_RISCV:
13071 return reloc_type == 39; /* R_RISCV_SUB32. */
13072 default:
13073 return FALSE;
13074 }
13075}
13076
13077/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13078 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13079
13080static bfd_boolean
13081is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13082{
13083 /* Please keep this table alpha-sorted for ease of visual lookup. */
13084 switch (filedata->file_header.e_machine)
13085 {
13086 case EM_RISCV:
13087 return reloc_type == 36; /* R_RISCV_ADD64. */
13088 default:
13089 return FALSE;
13090 }
13091}
13092
13093/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13094 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13095
13096static bfd_boolean
13097is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13098{
13099 /* Please keep this table alpha-sorted for ease of visual lookup. */
13100 switch (filedata->file_header.e_machine)
13101 {
13102 case EM_RISCV:
13103 return reloc_type == 40; /* R_RISCV_SUB64. */
13104 default:
13105 return FALSE;
13106 }
13107}
13108
13109/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13110 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13111
13112static bfd_boolean
13113is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13114{
13115 /* Please keep this table alpha-sorted for ease of visual lookup. */
13116 switch (filedata->file_header.e_machine)
13117 {
13118 case EM_RISCV:
13119 return reloc_type == 34; /* R_RISCV_ADD16. */
13120 default:
13121 return FALSE;
13122 }
13123}
13124
13125/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13126 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13127
13128static bfd_boolean
13129is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13130{
13131 /* Please keep this table alpha-sorted for ease of visual lookup. */
13132 switch (filedata->file_header.e_machine)
13133 {
13134 case EM_RISCV:
13135 return reloc_type == 38; /* R_RISCV_SUB16. */
13136 default:
13137 return FALSE;
13138 }
13139}
13140
13141/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13142 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13143
13144static bfd_boolean
13145is_8bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13146{
13147 /* Please keep this table alpha-sorted for ease of visual lookup. */
13148 switch (filedata->file_header.e_machine)
13149 {
13150 case EM_RISCV:
13151 return reloc_type == 33; /* R_RISCV_ADD8. */
13152 default:
13153 return FALSE;
13154 }
13155}
13156
13157/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13158 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13159
13160static bfd_boolean
13161is_8bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13162{
13163 /* Please keep this table alpha-sorted for ease of visual lookup. */
13164 switch (filedata->file_header.e_machine)
13165 {
13166 case EM_RISCV:
13167 return reloc_type == 37; /* R_RISCV_SUB8. */
13168 default:
13169 return FALSE;
13170 }
13171}
13172
13173/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13174 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13175
13176static bfd_boolean
13177is_6bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13178{
13179 switch (filedata->file_header.e_machine)
13180 {
13181 case EM_RISCV:
13182 return reloc_type == 52; /* R_RISCV_SUB6. */
13183 default:
13184 return FALSE;
13185 }
13186}
13187
13188/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13189 relocation entries (possibly formerly used for SHT_GROUP sections). */
13190
13191static bfd_boolean
13192is_none_reloc (Filedata * filedata, unsigned int reloc_type)
13193{
13194 switch (filedata->file_header.e_machine)
13195 {
13196 case EM_386: /* R_386_NONE. */
13197 case EM_68K: /* R_68K_NONE. */
13198 case EM_ADAPTEVA_EPIPHANY:
13199 case EM_ALPHA: /* R_ALPHA_NONE. */
13200 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
13201 case EM_ARC: /* R_ARC_NONE. */
13202 case EM_ARC_COMPACT2: /* R_ARC_NONE. */
13203 case EM_ARC_COMPACT: /* R_ARC_NONE. */
13204 case EM_ARM: /* R_ARM_NONE. */
13205 case EM_C166: /* R_XC16X_NONE. */
13206 case EM_CRIS: /* R_CRIS_NONE. */
13207 case EM_FT32: /* R_FT32_NONE. */
13208 case EM_IA_64: /* R_IA64_NONE. */
13209 case EM_K1OM: /* R_X86_64_NONE. */
13210 case EM_L1OM: /* R_X86_64_NONE. */
13211 case EM_M32R: /* R_M32R_NONE. */
13212 case EM_MIPS: /* R_MIPS_NONE. */
13213 case EM_MN10300: /* R_MN10300_NONE. */
13214 case EM_MOXIE: /* R_MOXIE_NONE. */
13215 case EM_NIOS32: /* R_NIOS_NONE. */
13216 case EM_OR1K: /* R_OR1K_NONE. */
13217 case EM_PARISC: /* R_PARISC_NONE. */
13218 case EM_PPC64: /* R_PPC64_NONE. */
13219 case EM_PPC: /* R_PPC_NONE. */
13220 case EM_RISCV: /* R_RISCV_NONE. */
13221 case EM_S390: /* R_390_NONE. */
13222 case EM_S390_OLD:
13223 case EM_SH: /* R_SH_NONE. */
13224 case EM_SPARC32PLUS:
13225 case EM_SPARC: /* R_SPARC_NONE. */
13226 case EM_SPARCV9:
13227 case EM_TILEGX: /* R_TILEGX_NONE. */
13228 case EM_TILEPRO: /* R_TILEPRO_NONE. */
13229 case EM_TI_C6000:/* R_C6000_NONE. */
13230 case EM_X86_64: /* R_X86_64_NONE. */
13231 case EM_XC16X:
13232 case EM_Z80: /* R_Z80_NONE. */
13233 case EM_WEBASSEMBLY: /* R_WASM32_NONE. */
13234 return reloc_type == 0;
13235
13236 case EM_AARCH64:
13237 return reloc_type == 0 || reloc_type == 256;
13238 case EM_AVR_OLD:
13239 case EM_AVR:
13240 return (reloc_type == 0 /* R_AVR_NONE. */
13241 || reloc_type == 30 /* R_AVR_DIFF8. */
13242 || reloc_type == 31 /* R_AVR_DIFF16. */
13243 || reloc_type == 32 /* R_AVR_DIFF32. */);
13244 case EM_METAG:
13245 return reloc_type == 3; /* R_METAG_NONE. */
13246 case EM_NDS32:
13247 return (reloc_type == 0 /* R_XTENSA_NONE. */
13248 || reloc_type == 204 /* R_NDS32_DIFF8. */
13249 || reloc_type == 205 /* R_NDS32_DIFF16. */
13250 || reloc_type == 206 /* R_NDS32_DIFF32. */
13251 || reloc_type == 207 /* R_NDS32_ULEB128. */);
13252 case EM_TI_PRU:
13253 return (reloc_type == 0 /* R_PRU_NONE. */
13254 || reloc_type == 65 /* R_PRU_DIFF8. */
13255 || reloc_type == 66 /* R_PRU_DIFF16. */
13256 || reloc_type == 67 /* R_PRU_DIFF32. */);
13257 case EM_XTENSA_OLD:
13258 case EM_XTENSA:
13259 return (reloc_type == 0 /* R_XTENSA_NONE. */
13260 || reloc_type == 17 /* R_XTENSA_DIFF8. */
13261 || reloc_type == 18 /* R_XTENSA_DIFF16. */
13262 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
13263 }
13264 return FALSE;
13265}
13266
13267/* Returns TRUE if there is a relocation against
13268 section NAME at OFFSET bytes. */
13269
13270bfd_boolean
13271reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
13272{
13273 Elf_Internal_Rela * relocs;
13274 Elf_Internal_Rela * rp;
13275
13276 if (dsec == NULL || dsec->reloc_info == NULL)
13277 return FALSE;
13278
13279 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
13280
13281 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
13282 if (rp->r_offset == offset)
13283 return TRUE;
13284
13285 return FALSE;
13286}
13287
13288/* Apply relocations to a section.
13289 Returns TRUE upon success, FALSE otherwise.
13290 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13291 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13292 will be set to the number of relocs loaded.
13293
13294 Note: So far support has been added only for those relocations
13295 which can be found in debug sections. FIXME: Add support for
13296 more relocations ? */
13297
13298static bfd_boolean
13299apply_relocations (Filedata * filedata,
13300 const Elf_Internal_Shdr * section,
13301 unsigned char * start,
13302 bfd_size_type size,
13303 void ** relocs_return,
13304 unsigned long * num_relocs_return)
13305{
13306 Elf_Internal_Shdr * relsec;
13307 unsigned char * end = start + size;
13308
13309 if (relocs_return != NULL)
13310 {
13311 * (Elf_Internal_Rela **) relocs_return = NULL;
13312 * num_relocs_return = 0;
13313 }
13314
13315 if (filedata->file_header.e_type != ET_REL)
13316 /* No relocs to apply. */
13317 return TRUE;
13318
13319 /* Find the reloc section associated with the section. */
13320 for (relsec = filedata->section_headers;
13321 relsec < filedata->section_headers + filedata->file_header.e_shnum;
13322 ++relsec)
13323 {
13324 bfd_boolean is_rela;
13325 unsigned long num_relocs;
13326 Elf_Internal_Rela * relocs;
13327 Elf_Internal_Rela * rp;
13328 Elf_Internal_Shdr * symsec;
13329 Elf_Internal_Sym * symtab;
13330 unsigned long num_syms;
13331 Elf_Internal_Sym * sym;
13332
13333 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13334 || relsec->sh_info >= filedata->file_header.e_shnum
13335 || filedata->section_headers + relsec->sh_info != section
13336 || relsec->sh_size == 0
13337 || relsec->sh_link >= filedata->file_header.e_shnum)
13338 continue;
13339
13340 symsec = filedata->section_headers + relsec->sh_link;
13341 if (symsec->sh_type != SHT_SYMTAB
13342 && symsec->sh_type != SHT_DYNSYM)
13343 return FALSE;
13344
13345 is_rela = relsec->sh_type == SHT_RELA;
13346
13347 if (is_rela)
13348 {
13349 if (!slurp_rela_relocs (filedata, relsec->sh_offset,
13350 relsec->sh_size, & relocs, & num_relocs))
13351 return FALSE;
13352 }
13353 else
13354 {
13355 if (!slurp_rel_relocs (filedata, relsec->sh_offset,
13356 relsec->sh_size, & relocs, & num_relocs))
13357 return FALSE;
13358 }
13359
13360 /* SH uses RELA but uses in place value instead of the addend field. */
13361 if (filedata->file_header.e_machine == EM_SH)
13362 is_rela = FALSE;
13363
13364 symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
13365
13366 for (rp = relocs; rp < relocs + num_relocs; ++rp)
13367 {
13368 bfd_vma addend;
13369 unsigned int reloc_type;
13370 unsigned int reloc_size;
13371 bfd_boolean reloc_inplace = FALSE;
13372 bfd_boolean reloc_subtract = FALSE;
13373 unsigned char * rloc;
13374 unsigned long sym_index;
13375
13376 reloc_type = get_reloc_type (filedata, rp->r_info);
13377
13378 if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
13379 continue;
13380 else if (is_none_reloc (filedata, reloc_type))
13381 continue;
13382 else if (is_32bit_abs_reloc (filedata, reloc_type)
13383 || is_32bit_pcrel_reloc (filedata, reloc_type))
13384 reloc_size = 4;
13385 else if (is_64bit_abs_reloc (filedata, reloc_type)
13386 || is_64bit_pcrel_reloc (filedata, reloc_type))
13387 reloc_size = 8;
13388 else if (is_24bit_abs_reloc (filedata, reloc_type))
13389 reloc_size = 3;
13390 else if (is_16bit_abs_reloc (filedata, reloc_type))
13391 reloc_size = 2;
13392 else if (is_8bit_abs_reloc (filedata, reloc_type)
13393 || is_6bit_abs_reloc (filedata, reloc_type))
13394 reloc_size = 1;
13395 else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
13396 reloc_type))
13397 || is_32bit_inplace_add_reloc (filedata, reloc_type))
13398 {
13399 reloc_size = 4;
13400 reloc_inplace = TRUE;
13401 }
13402 else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
13403 reloc_type))
13404 || is_64bit_inplace_add_reloc (filedata, reloc_type))
13405 {
13406 reloc_size = 8;
13407 reloc_inplace = TRUE;
13408 }
13409 else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
13410 reloc_type))
13411 || is_16bit_inplace_add_reloc (filedata, reloc_type))
13412 {
13413 reloc_size = 2;
13414 reloc_inplace = TRUE;
13415 }
13416 else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
13417 reloc_type))
13418 || is_8bit_inplace_add_reloc (filedata, reloc_type))
13419 {
13420 reloc_size = 1;
13421 reloc_inplace = TRUE;
13422 }
13423 else if ((reloc_subtract = is_6bit_inplace_sub_reloc (filedata,
13424 reloc_type)))
13425 {
13426 reloc_size = 1;
13427 reloc_inplace = TRUE;
13428 }
13429 else
13430 {
13431 static unsigned int prev_reloc = 0;
13432
13433 if (reloc_type != prev_reloc)
13434 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13435 reloc_type, printable_section_name (filedata, section));
13436 prev_reloc = reloc_type;
13437 continue;
13438 }
13439
13440 rloc = start + rp->r_offset;
13441 if (!IN_RANGE (start, end, rloc, reloc_size))
13442 {
13443 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13444 (unsigned long) rp->r_offset,
13445 printable_section_name (filedata, section));
13446 continue;
13447 }
13448
13449 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
13450 if (sym_index >= num_syms)
13451 {
13452 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13453 sym_index, printable_section_name (filedata, section));
13454 continue;
13455 }
13456 sym = symtab + sym_index;
13457
13458 /* If the reloc has a symbol associated with it,
13459 make sure that it is of an appropriate type.
13460
13461 Relocations against symbols without type can happen.
13462 Gcc -feliminate-dwarf2-dups may generate symbols
13463 without type for debug info.
13464
13465 Icc generates relocations against function symbols
13466 instead of local labels.
13467
13468 Relocations against object symbols can happen, eg when
13469 referencing a global array. For an example of this see
13470 the _clz.o binary in libgcc.a. */
13471 if (sym != symtab
13472 && ELF_ST_TYPE (sym->st_info) != STT_COMMON
13473 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
13474 {
13475 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13476 get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
13477 printable_section_name (filedata, relsec),
13478 (long int)(rp - relocs));
13479 continue;
13480 }
13481
13482 addend = 0;
13483 if (is_rela)
13484 addend += rp->r_addend;
13485 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13486 partial_inplace. */
13487 if (!is_rela
13488 || (filedata->file_header.e_machine == EM_XTENSA
13489 && reloc_type == 1)
13490 || ((filedata->file_header.e_machine == EM_PJ
13491 || filedata->file_header.e_machine == EM_PJ_OLD)
13492 && reloc_type == 1)
13493 || ((filedata->file_header.e_machine == EM_D30V
13494 || filedata->file_header.e_machine == EM_CYGNUS_D30V)
13495 && reloc_type == 12)
13496 || reloc_inplace)
13497 {
13498 if (is_6bit_inplace_sub_reloc (filedata, reloc_type))
13499 addend += byte_get (rloc, reloc_size) & 0x3f;
13500 else
13501 addend += byte_get (rloc, reloc_size);
13502 }
13503
13504 if (is_32bit_pcrel_reloc (filedata, reloc_type)
13505 || is_64bit_pcrel_reloc (filedata, reloc_type))
13506 {
13507 /* On HPPA, all pc-relative relocations are biased by 8. */
13508 if (filedata->file_header.e_machine == EM_PARISC)
13509 addend -= 8;
13510 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
13511 reloc_size);
13512 }
13513 else if (is_6bit_abs_reloc (filedata, reloc_type)
13514 || is_6bit_inplace_sub_reloc (filedata, reloc_type))
13515 {
13516 if (reloc_subtract)
13517 addend -= sym->st_value;
13518 else
13519 addend += sym->st_value;
13520 addend = (addend & 0x3f) | (byte_get (rloc, reloc_size) & 0xc0);
13521 byte_put (rloc, addend, reloc_size);
13522 }
13523 else if (reloc_subtract)
13524 byte_put (rloc, addend - sym->st_value, reloc_size);
13525 else
13526 byte_put (rloc, addend + sym->st_value, reloc_size);
13527 }
13528
13529 free (symtab);
13530 /* Let the target specific reloc processing code know that
13531 we have finished with these relocs. */
13532 target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
13533
13534 if (relocs_return)
13535 {
13536 * (Elf_Internal_Rela **) relocs_return = relocs;
13537 * num_relocs_return = num_relocs;
13538 }
13539 else
13540 free (relocs);
13541
13542 break;
13543 }
13544
13545 return TRUE;
13546}
13547
13548#ifdef SUPPORT_DISASSEMBLY
13549static bfd_boolean
13550disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
13551{
13552 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
13553
13554 /* FIXME: XXX -- to be done --- XXX */
13555
13556 return TRUE;
13557}
13558#endif
13559
13560/* Reads in the contents of SECTION from FILE, returning a pointer
13561 to a malloc'ed buffer or NULL if something went wrong. */
13562
13563static char *
13564get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
13565{
13566 bfd_size_type num_bytes = section->sh_size;
13567
13568 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
13569 {
13570 printf (_("Section '%s' has no data to dump.\n"),
13571 printable_section_name (filedata, section));
13572 return NULL;
13573 }
13574
13575 return (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
13576 _("section contents"));
13577}
13578
13579/* Uncompresses a section that was compressed using zlib, in place. */
13580
13581static bfd_boolean
13582uncompress_section_contents (unsigned char ** buffer,
13583 dwarf_size_type uncompressed_size,
13584 dwarf_size_type * size)
13585{
13586 dwarf_size_type compressed_size = *size;
13587 unsigned char * compressed_buffer = *buffer;
13588 unsigned char * uncompressed_buffer;
13589 z_stream strm;
13590 int rc;
13591
13592 /* It is possible the section consists of several compressed
13593 buffers concatenated together, so we uncompress in a loop. */
13594 /* PR 18313: The state field in the z_stream structure is supposed
13595 to be invisible to the user (ie us), but some compilers will
13596 still complain about it being used without initialisation. So
13597 we first zero the entire z_stream structure and then set the fields
13598 that we need. */
13599 memset (& strm, 0, sizeof strm);
13600 strm.avail_in = compressed_size;
13601 strm.next_in = (Bytef *) compressed_buffer;
13602 strm.avail_out = uncompressed_size;
13603 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
13604
13605 rc = inflateInit (& strm);
13606 while (strm.avail_in > 0)
13607 {
13608 if (rc != Z_OK)
13609 goto fail;
13610 strm.next_out = ((Bytef *) uncompressed_buffer
13611 + (uncompressed_size - strm.avail_out));
13612 rc = inflate (&strm, Z_FINISH);
13613 if (rc != Z_STREAM_END)
13614 goto fail;
13615 rc = inflateReset (& strm);
13616 }
13617 rc = inflateEnd (& strm);
13618 if (rc != Z_OK
13619 || strm.avail_out != 0)
13620 goto fail;
13621
13622 *buffer = uncompressed_buffer;
13623 *size = uncompressed_size;
13624 return TRUE;
13625
13626 fail:
13627 free (uncompressed_buffer);
13628 /* Indicate decompression failure. */
13629 *buffer = NULL;
13630 return FALSE;
13631}
13632
13633static bfd_boolean
13634dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
13635{
13636 Elf_Internal_Shdr * relsec;
13637 bfd_size_type num_bytes;
13638 unsigned char * data;
13639 unsigned char * end;
13640 unsigned char * real_start;
13641 unsigned char * start;
13642 bfd_boolean some_strings_shown;
13643
13644 real_start = start = (unsigned char *) get_section_contents (section, filedata);
13645 if (start == NULL)
13646 /* PR 21820: Do not fail if the section was empty. */
13647 return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13648
13649 num_bytes = section->sh_size;
13650
13651 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
13652
13653 if (decompress_dumps)
13654 {
13655 dwarf_size_type new_size = num_bytes;
13656 dwarf_size_type uncompressed_size = 0;
13657
13658 if ((section->sh_flags & SHF_COMPRESSED) != 0)
13659 {
13660 Elf_Internal_Chdr chdr;
13661 unsigned int compression_header_size
13662 = get_compression_header (& chdr, (unsigned char *) start,
13663 num_bytes);
13664
13665 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13666 {
13667 warn (_("section '%s' has unsupported compress type: %d\n"),
13668 printable_section_name (filedata, section), chdr.ch_type);
13669 return FALSE;
13670 }
13671 uncompressed_size = chdr.ch_size;
13672 start += compression_header_size;
13673 new_size -= compression_header_size;
13674 }
13675 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13676 {
13677 /* Read the zlib header. In this case, it should be "ZLIB"
13678 followed by the uncompressed section size, 8 bytes in
13679 big-endian order. */
13680 uncompressed_size = start[4]; uncompressed_size <<= 8;
13681 uncompressed_size += start[5]; uncompressed_size <<= 8;
13682 uncompressed_size += start[6]; uncompressed_size <<= 8;
13683 uncompressed_size += start[7]; uncompressed_size <<= 8;
13684 uncompressed_size += start[8]; uncompressed_size <<= 8;
13685 uncompressed_size += start[9]; uncompressed_size <<= 8;
13686 uncompressed_size += start[10]; uncompressed_size <<= 8;
13687 uncompressed_size += start[11];
13688 start += 12;
13689 new_size -= 12;
13690 }
13691
13692 if (uncompressed_size)
13693 {
13694 if (uncompress_section_contents (& start,
13695 uncompressed_size, & new_size))
13696 num_bytes = new_size;
13697 else
13698 {
13699 error (_("Unable to decompress section %s\n"),
13700 printable_section_name (filedata, section));
13701 return FALSE;
13702 }
13703 }
13704 else
13705 start = real_start;
13706 }
13707
13708 /* If the section being dumped has relocations against it the user might
13709 be expecting these relocations to have been applied. Check for this
13710 case and issue a warning message in order to avoid confusion.
13711 FIXME: Maybe we ought to have an option that dumps a section with
13712 relocs applied ? */
13713 for (relsec = filedata->section_headers;
13714 relsec < filedata->section_headers + filedata->file_header.e_shnum;
13715 ++relsec)
13716 {
13717 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13718 || relsec->sh_info >= filedata->file_header.e_shnum
13719 || filedata->section_headers + relsec->sh_info != section
13720 || relsec->sh_size == 0
13721 || relsec->sh_link >= filedata->file_header.e_shnum)
13722 continue;
13723
13724 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13725 break;
13726 }
13727
13728 data = start;
13729 end = start + num_bytes;
13730 some_strings_shown = FALSE;
13731
13732 while (data < end)
13733 {
13734 while (!ISPRINT (* data))
13735 if (++ data >= end)
13736 break;
13737
13738 if (data < end)
13739 {
13740 size_t maxlen = end - data;
13741
13742#ifndef __MSVCRT__
13743 /* PR 11128: Use two separate invocations in order to work
13744 around bugs in the Solaris 8 implementation of printf. */
13745 printf (" [%6tx] ", data - start);
13746#else
13747 printf (" [%6Ix] ", (size_t) (data - start));
13748#endif
13749 if (maxlen > 0)
13750 {
13751 print_symbol ((int) maxlen, (const char *) data);
13752 putchar ('\n');
13753 data += strnlen ((const char *) data, maxlen);
13754 }
13755 else
13756 {
13757 printf (_("<corrupt>\n"));
13758 data = end;
13759 }
13760 some_strings_shown = TRUE;
13761 }
13762 }
13763
13764 if (! some_strings_shown)
13765 printf (_(" No strings found in this section."));
13766
13767 free (real_start);
13768
13769 putchar ('\n');
13770 return TRUE;
13771}
13772
13773static bfd_boolean
13774dump_section_as_bytes (Elf_Internal_Shdr * section,
13775 Filedata * filedata,
13776 bfd_boolean relocate)
13777{
13778 Elf_Internal_Shdr * relsec;
13779 bfd_size_type bytes;
13780 bfd_size_type section_size;
13781 bfd_vma addr;
13782 unsigned char * data;
13783 unsigned char * real_start;
13784 unsigned char * start;
13785
13786 real_start = start = (unsigned char *) get_section_contents (section, filedata);
13787 if (start == NULL)
13788 /* PR 21820: Do not fail if the section was empty. */
13789 return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13790
13791 section_size = section->sh_size;
13792
13793 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
13794
13795 if (decompress_dumps)
13796 {
13797 dwarf_size_type new_size = section_size;
13798 dwarf_size_type uncompressed_size = 0;
13799
13800 if ((section->sh_flags & SHF_COMPRESSED) != 0)
13801 {
13802 Elf_Internal_Chdr chdr;
13803 unsigned int compression_header_size
13804 = get_compression_header (& chdr, start, section_size);
13805
13806 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13807 {
13808 warn (_("section '%s' has unsupported compress type: %d\n"),
13809 printable_section_name (filedata, section), chdr.ch_type);
13810 return FALSE;
13811 }
13812 uncompressed_size = chdr.ch_size;
13813 start += compression_header_size;
13814 new_size -= compression_header_size;
13815 }
13816 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13817 {
13818 /* Read the zlib header. In this case, it should be "ZLIB"
13819 followed by the uncompressed section size, 8 bytes in
13820 big-endian order. */
13821 uncompressed_size = start[4]; uncompressed_size <<= 8;
13822 uncompressed_size += start[5]; uncompressed_size <<= 8;
13823 uncompressed_size += start[6]; uncompressed_size <<= 8;
13824 uncompressed_size += start[7]; uncompressed_size <<= 8;
13825 uncompressed_size += start[8]; uncompressed_size <<= 8;
13826 uncompressed_size += start[9]; uncompressed_size <<= 8;
13827 uncompressed_size += start[10]; uncompressed_size <<= 8;
13828 uncompressed_size += start[11];
13829 start += 12;
13830 new_size -= 12;
13831 }
13832
13833 if (uncompressed_size)
13834 {
13835 if (uncompress_section_contents (& start, uncompressed_size,
13836 & new_size))
13837 {
13838 section_size = new_size;
13839 }
13840 else
13841 {
13842 error (_("Unable to decompress section %s\n"),
13843 printable_section_name (filedata, section));
13844 /* FIXME: Print the section anyway ? */
13845 return FALSE;
13846 }
13847 }
13848 else
13849 start = real_start;
13850 }
13851
13852 if (relocate)
13853 {
13854 if (! apply_relocations (filedata, section, start, section_size, NULL, NULL))
13855 return FALSE;
13856 }
13857 else
13858 {
13859 /* If the section being dumped has relocations against it the user might
13860 be expecting these relocations to have been applied. Check for this
13861 case and issue a warning message in order to avoid confusion.
13862 FIXME: Maybe we ought to have an option that dumps a section with
13863 relocs applied ? */
13864 for (relsec = filedata->section_headers;
13865 relsec < filedata->section_headers + filedata->file_header.e_shnum;
13866 ++relsec)
13867 {
13868 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13869 || relsec->sh_info >= filedata->file_header.e_shnum
13870 || filedata->section_headers + relsec->sh_info != section
13871 || relsec->sh_size == 0
13872 || relsec->sh_link >= filedata->file_header.e_shnum)
13873 continue;
13874
13875 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13876 break;
13877 }
13878 }
13879
13880 addr = section->sh_addr;
13881 bytes = section_size;
13882 data = start;
13883
13884 while (bytes)
13885 {
13886 int j;
13887 int k;
13888 int lbytes;
13889
13890 lbytes = (bytes > 16 ? 16 : bytes);
13891
13892 printf (" 0x%8.8lx ", (unsigned long) addr);
13893
13894 for (j = 0; j < 16; j++)
13895 {
13896 if (j < lbytes)
13897 printf ("%2.2x", data[j]);
13898 else
13899 printf (" ");
13900
13901 if ((j & 3) == 3)
13902 printf (" ");
13903 }
13904
13905 for (j = 0; j < lbytes; j++)
13906 {
13907 k = data[j];
13908 if (k >= ' ' && k < 0x7f)
13909 printf ("%c", k);
13910 else
13911 printf (".");
13912 }
13913
13914 putchar ('\n');
13915
13916 data += lbytes;
13917 addr += lbytes;
13918 bytes -= lbytes;
13919 }
13920
13921 free (real_start);
13922
13923 putchar ('\n');
13924 return TRUE;
13925}
13926
13927static ctf_sect_t *
13928shdr_to_ctf_sect (ctf_sect_t *buf, Elf_Internal_Shdr *shdr, Filedata *filedata)
13929{
13930 buf->cts_name = SECTION_NAME (shdr);
13931 buf->cts_size = shdr->sh_size;
13932 buf->cts_entsize = shdr->sh_entsize;
13933
13934 return buf;
13935}
13936
13937/* Formatting callback function passed to ctf_dump. Returns either the pointer
13938 it is passed, or a pointer to newly-allocated storage, in which case
13939 dump_ctf() will free it when it no longer needs it. */
13940
13941static char *dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED,
13942 char *s, void *arg)
13943{
13944 const char *blanks = arg;
13945 char *new_s;
13946
13947 if (asprintf (&new_s, "%s%s", blanks, s) < 0)
13948 return s;
13949 return new_s;
13950}
13951
13952static bfd_boolean
13953dump_section_as_ctf (Elf_Internal_Shdr * section, Filedata * filedata)
13954{
13955 Elf_Internal_Shdr * parent_sec = NULL;
13956 Elf_Internal_Shdr * symtab_sec = NULL;
13957 Elf_Internal_Shdr * strtab_sec = NULL;
13958 void * data = NULL;
13959 void * symdata = NULL;
13960 void * strdata = NULL;
13961 void * parentdata = NULL;
13962 ctf_sect_t ctfsect, symsect, strsect, parentsect;
13963 ctf_sect_t * symsectp = NULL;
13964 ctf_sect_t * strsectp = NULL;
13965 ctf_file_t * ctf = NULL;
13966 ctf_file_t * parent = NULL;
13967
13968 const char *things[] = {"Header", "Labels", "Data objects",
13969 "Function objects", "Variables", "Types", "Strings",
13970 ""};
13971 const char **thing;
13972 int err;
13973 bfd_boolean ret = FALSE;
13974 size_t i;
13975
13976 shdr_to_ctf_sect (&ctfsect, section, filedata);
13977 data = get_section_contents (section, filedata);
13978 ctfsect.cts_data = data;
13979
13980 if (!dump_ctf_symtab_name)
13981 dump_ctf_symtab_name = strdup (".symtab");
13982
13983 if (!dump_ctf_strtab_name)
13984 dump_ctf_strtab_name = strdup (".strtab");
13985
13986 if (dump_ctf_symtab_name && dump_ctf_symtab_name[0] != 0)
13987 {
13988 if ((symtab_sec = find_section (filedata, dump_ctf_symtab_name)) == NULL)
13989 {
13990 error (_("No symbol section named %s\n"), dump_ctf_symtab_name);
13991 goto fail;
13992 }
13993 if ((symdata = (void *) get_data (NULL, filedata,
13994 symtab_sec->sh_offset, 1,
13995 symtab_sec->sh_size,
13996 _("symbols"))) == NULL)
13997 goto fail;
13998 symsectp = shdr_to_ctf_sect (&symsect, symtab_sec, filedata);
13999 symsect.cts_data = symdata;
14000 }
14001 if (dump_ctf_strtab_name && dump_ctf_symtab_name[0] != 0)
14002 {
14003 if ((strtab_sec = find_section (filedata, dump_ctf_strtab_name)) == NULL)
14004 {
14005 error (_("No string table section named %s\n"),
14006 dump_ctf_strtab_name);
14007 goto fail;
14008 }
14009 if ((strdata = (void *) get_data (NULL, filedata,
14010 strtab_sec->sh_offset, 1,
14011 strtab_sec->sh_size,
14012 _("strings"))) == NULL)
14013 goto fail;
14014 strsectp = shdr_to_ctf_sect (&strsect, strtab_sec, filedata);
14015 strsect.cts_data = strdata;
14016 }
14017 if (dump_ctf_parent_name)
14018 {
14019 if ((parent_sec = find_section (filedata, dump_ctf_parent_name)) == NULL)
14020 {
14021 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name);
14022 goto fail;
14023 }
14024 if ((parentdata = (void *) get_data (NULL, filedata,
14025 parent_sec->sh_offset, 1,
14026 parent_sec->sh_size,
14027 _("CTF parent"))) == NULL)
14028 goto fail;
14029 shdr_to_ctf_sect (&parentsect, parent_sec, filedata);
14030 parentsect.cts_data = parentdata;
14031 }
14032
14033 /* Load the CTF file and dump it. */
14034
14035 if ((ctf = ctf_bufopen (&ctfsect, symsectp, strsectp, &err)) == NULL)
14036 {
14037 error (_("CTF open failure: %s\n"), ctf_errmsg (err));
14038 goto fail;
14039 }
14040
14041 if (parentdata)
14042 {
14043 if ((parent = ctf_bufopen (&parentsect, symsectp, strsectp, &err)) == NULL)
14044 {
14045 error (_("CTF open failure: %s\n"), ctf_errmsg (err));
14046 goto fail;
14047 }
14048
14049 ctf_import (ctf, parent);
14050 }
14051
14052 ret = TRUE;
14053
14054 printf (_("\nDump of CTF section '%s':\n"),
14055 printable_section_name (filedata, section));
14056
14057 for (i = 0, thing = things; *thing[0]; thing++, i++)
14058 {
14059 ctf_dump_state_t *s = NULL;
14060 char *item;
14061
14062 printf ("\n %s:\n", *thing);
14063 while ((item = ctf_dump (ctf, &s, i, dump_ctf_indent_lines,
14064 (void *) " ")) != NULL)
14065 {
14066 printf ("%s\n", item);
14067 free (item);
14068 }
14069
14070 if (ctf_errno (ctf))
14071 {
14072 error (_("Iteration failed: %s, %s\n"), *thing,
14073 ctf_errmsg (ctf_errno (ctf)));
14074 ret = FALSE;
14075 }
14076 }
14077
14078 fail:
14079 ctf_file_close (ctf);
14080 ctf_file_close (parent);
14081 free (parentdata);
14082 free (data);
14083 free (symdata);
14084 free (strdata);
14085 return ret;
14086}
14087
14088static bfd_boolean
14089load_specific_debug_section (enum dwarf_section_display_enum debug,
14090 const Elf_Internal_Shdr * sec,
14091 void * data)
14092{
14093 struct dwarf_section * section = &debug_displays [debug].section;
14094 char buf [64];
14095 Filedata * filedata = (Filedata *) data;
14096
14097 if (section->start != NULL)
14098 {
14099 /* If it is already loaded, do nothing. */
14100 if (streq (section->filename, filedata->file_name))
14101 return TRUE;
14102 free (section->start);
14103 }
14104
14105 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
14106 section->address = sec->sh_addr;
14107 section->user_data = NULL;
14108 section->filename = filedata->file_name;
14109 section->start = (unsigned char *) get_data (NULL, filedata,
14110 sec->sh_offset, 1,
14111 sec->sh_size, buf);
14112 if (section->start == NULL)
14113 section->size = 0;
14114 else
14115 {
14116 unsigned char *start = section->start;
14117 dwarf_size_type size = sec->sh_size;
14118 dwarf_size_type uncompressed_size = 0;
14119
14120 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
14121 {
14122 Elf_Internal_Chdr chdr;
14123 unsigned int compression_header_size;
14124
14125 if (size < (is_32bit_elf
14126 ? sizeof (Elf32_External_Chdr)
14127 : sizeof (Elf64_External_Chdr)))
14128 {
14129 warn (_("compressed section %s is too small to contain a compression header\n"),
14130 section->name);
14131 return FALSE;
14132 }
14133
14134 compression_header_size = get_compression_header (&chdr, start, size);
14135
14136 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
14137 {
14138 warn (_("section '%s' has unsupported compress type: %d\n"),
14139 section->name, chdr.ch_type);
14140 return FALSE;
14141 }
14142 uncompressed_size = chdr.ch_size;
14143 start += compression_header_size;
14144 size -= compression_header_size;
14145 }
14146 else if (size > 12 && streq ((char *) start, "ZLIB"))
14147 {
14148 /* Read the zlib header. In this case, it should be "ZLIB"
14149 followed by the uncompressed section size, 8 bytes in
14150 big-endian order. */
14151 uncompressed_size = start[4]; uncompressed_size <<= 8;
14152 uncompressed_size += start[5]; uncompressed_size <<= 8;
14153 uncompressed_size += start[6]; uncompressed_size <<= 8;
14154 uncompressed_size += start[7]; uncompressed_size <<= 8;
14155 uncompressed_size += start[8]; uncompressed_size <<= 8;
14156 uncompressed_size += start[9]; uncompressed_size <<= 8;
14157 uncompressed_size += start[10]; uncompressed_size <<= 8;
14158 uncompressed_size += start[11];
14159 start += 12;
14160 size -= 12;
14161 }
14162
14163 if (uncompressed_size)
14164 {
14165 if (uncompress_section_contents (&start, uncompressed_size,
14166 &size))
14167 {
14168 /* Free the compressed buffer, update the section buffer
14169 and the section size if uncompress is successful. */
14170 free (section->start);
14171 section->start = start;
14172 }
14173 else
14174 {
14175 error (_("Unable to decompress section %s\n"),
14176 printable_section_name (filedata, sec));
14177 return FALSE;
14178 }
14179 }
14180
14181 section->size = size;
14182 }
14183
14184 if (section->start == NULL)
14185 return FALSE;
14186
14187 if (debug_displays [debug].relocate)
14188 {
14189 if (! apply_relocations (filedata, sec, section->start, section->size,
14190 & section->reloc_info, & section->num_relocs))
14191 return FALSE;
14192 }
14193 else
14194 {
14195 section->reloc_info = NULL;
14196 section->num_relocs = 0;
14197 }
14198
14199 return TRUE;
14200}
14201
14202#if HAVE_LIBDEBUGINFOD
14203/* Return a hex string representation of the build-id. */
14204unsigned char *
14205get_build_id (void * data)
14206{
14207 Filedata * filedata = (Filedata *)data;
14208 Elf_Internal_Shdr * shdr;
14209 unsigned long i;
14210
14211 /* Iterate through notes to find note.gnu.build-id.
14212 FIXME: Only the first note in any note section is examined. */
14213 for (i = 0, shdr = filedata->section_headers;
14214 i < filedata->file_header.e_shnum && shdr != NULL;
14215 i++, shdr++)
14216 {
14217 if (shdr->sh_type != SHT_NOTE)
14218 continue;
14219
14220 char * next;
14221 char * end;
14222 size_t data_remaining;
14223 size_t min_notesz;
14224 Elf_External_Note * enote;
14225 Elf_Internal_Note inote;
14226
14227 bfd_vma offset = shdr->sh_offset;
14228 bfd_vma align = shdr->sh_addralign;
14229 bfd_vma length = shdr->sh_size;
14230
14231 enote = (Elf_External_Note *) get_section_contents (shdr, filedata);
14232 if (enote == NULL)
14233 continue;
14234
14235 if (align < 4)
14236 align = 4;
14237 else if (align != 4 && align != 8)
14238 continue;
14239
14240 end = (char *) enote + length;
14241 data_remaining = end - (char *) enote;
14242
14243 if (!is_ia64_vms (filedata))
14244 {
14245 min_notesz = offsetof (Elf_External_Note, name);
14246 if (data_remaining < min_notesz)
14247 {
14248 warn (_("\
14249malformed note encountered in section %s whilst scanning for build-id note\n"),
14250 printable_section_name (filedata, shdr));
14251 continue;
14252 }
14253 data_remaining -= min_notesz;
14254
14255 inote.type = BYTE_GET (enote->type);
14256 inote.namesz = BYTE_GET (enote->namesz);
14257 inote.namedata = enote->name;
14258 inote.descsz = BYTE_GET (enote->descsz);
14259 inote.descdata = ((char *) enote
14260 + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
14261 inote.descpos = offset + (inote.descdata - (char *) enote);
14262 next = ((char *) enote
14263 + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
14264 }
14265 else
14266 {
14267 Elf64_External_VMS_Note *vms_enote;
14268
14269 /* PR binutils/15191
14270 Make sure that there is enough data to read. */
14271 min_notesz = offsetof (Elf64_External_VMS_Note, name);
14272 if (data_remaining < min_notesz)
14273 {
14274 warn (_("\
14275malformed note encountered in section %s whilst scanning for build-id note\n"),
14276 printable_section_name (filedata, shdr));
14277 continue;
14278 }
14279 data_remaining -= min_notesz;
14280
14281 vms_enote = (Elf64_External_VMS_Note *) enote;
14282 inote.type = BYTE_GET (vms_enote->type);
14283 inote.namesz = BYTE_GET (vms_enote->namesz);
14284 inote.namedata = vms_enote->name;
14285 inote.descsz = BYTE_GET (vms_enote->descsz);
14286 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
14287 inote.descpos = offset + (inote.descdata - (char *) enote);
14288 next = inote.descdata + align_power (inote.descsz, 3);
14289 }
14290
14291 /* Skip malformed notes. */
14292 if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
14293 || (size_t) (inote.descdata - inote.namedata) > data_remaining
14294 || (size_t) (next - inote.descdata) < inote.descsz
14295 || ((size_t) (next - inote.descdata)
14296 > data_remaining - (size_t) (inote.descdata - inote.namedata)))
14297 {
14298 warn (_("\
14299malformed note encountered in section %s whilst scanning for build-id note\n"),
14300 printable_section_name (filedata, shdr));
14301 continue;
14302 }
14303
14304 /* Check if this is the build-id note. If so then convert the build-id
14305 bytes to a hex string. */
14306 if (inote.namesz > 0
14307 && const_strneq (inote.namedata, "GNU")
14308 && inote.type == NT_GNU_BUILD_ID)
14309 {
14310 unsigned long j;
14311 char * build_id;
14312
14313 build_id = malloc (inote.descsz * 2 + 1);
14314 if (build_id == NULL)
14315 return NULL;
14316
14317 for (j = 0; j < inote.descsz; ++j)
14318 sprintf (build_id + (j * 2), "%02x", inote.descdata[j] & 0xff);
14319 build_id[inote.descsz * 2] = '\0';
14320
14321 return (unsigned char *) build_id;
14322 }
14323 }
14324
14325 return NULL;
14326}
14327#endif /* HAVE_LIBDEBUGINFOD */
14328
14329/* If this is not NULL, load_debug_section will only look for sections
14330 within the list of sections given here. */
14331static unsigned int * section_subset = NULL;
14332
14333bfd_boolean
14334load_debug_section (enum dwarf_section_display_enum debug, void * data)
14335{
14336 struct dwarf_section * section = &debug_displays [debug].section;
14337 Elf_Internal_Shdr * sec;
14338 Filedata * filedata = (Filedata *) data;
14339
14340 /* Without section headers we cannot find any sections. */
14341 if (filedata->section_headers == NULL)
14342 return FALSE;
14343
14344 if (filedata->string_table == NULL
14345 && filedata->file_header.e_shstrndx != SHN_UNDEF
14346 && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
14347 {
14348 Elf_Internal_Shdr * strs;
14349
14350 /* Read in the string table, so that we have section names to scan. */
14351 strs = filedata->section_headers + filedata->file_header.e_shstrndx;
14352
14353 if (strs != NULL && strs->sh_size != 0)
14354 {
14355 filedata->string_table
14356 = (char *) get_data (NULL, filedata, strs->sh_offset,
14357 1, strs->sh_size, _("string table"));
14358
14359 filedata->string_table_length
14360 = filedata->string_table != NULL ? strs->sh_size : 0;
14361 }
14362 }
14363
14364 /* Locate the debug section. */
14365 sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
14366 if (sec != NULL)
14367 section->name = section->uncompressed_name;
14368 else
14369 {
14370 sec = find_section_in_set (filedata, section->compressed_name, section_subset);
14371 if (sec != NULL)
14372 section->name = section->compressed_name;
14373 }
14374 if (sec == NULL)
14375 return FALSE;
14376
14377 /* If we're loading from a subset of sections, and we've loaded
14378 a section matching this name before, it's likely that it's a
14379 different one. */
14380 if (section_subset != NULL)
14381 free_debug_section (debug);
14382
14383 return load_specific_debug_section (debug, sec, data);
14384}
14385
14386void
14387free_debug_section (enum dwarf_section_display_enum debug)
14388{
14389 struct dwarf_section * section = &debug_displays [debug].section;
14390
14391 if (section->start == NULL)
14392 return;
14393
14394 free ((char *) section->start);
14395 section->start = NULL;
14396 section->address = 0;
14397 section->size = 0;
14398
14399 if (section->reloc_info != NULL)
14400 {
14401 free (section->reloc_info);
14402 section->reloc_info = NULL;
14403 section->num_relocs = 0;
14404 }
14405}
14406
14407static bfd_boolean
14408display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
14409{
14410 char * name = SECTION_NAME (section);
14411 const char * print_name = printable_section_name (filedata, section);
14412 bfd_size_type length;
14413 bfd_boolean result = TRUE;
14414 int i;
14415
14416 length = section->sh_size;
14417 if (length == 0)
14418 {
14419 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
14420 return TRUE;
14421 }
14422 if (section->sh_type == SHT_NOBITS)
14423 {
14424 /* There is no point in dumping the contents of a debugging section
14425 which has the NOBITS type - the bits in the file will be random.
14426 This can happen when a file containing a .eh_frame section is
14427 stripped with the --only-keep-debug command line option. */
14428 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14429 print_name);
14430 return FALSE;
14431 }
14432
14433 if (const_strneq (name, ".gnu.linkonce.wi."))
14434 name = ".debug_info";
14435
14436 /* See if we know how to display the contents of this section. */
14437 for (i = 0; i < max; i++)
14438 {
14439 enum dwarf_section_display_enum id = (enum dwarf_section_display_enum) i;
14440 struct dwarf_section_display * display = debug_displays + i;
14441 struct dwarf_section * sec = & display->section;
14442
14443 if (streq (sec->uncompressed_name, name)
14444 || (id == line && const_strneq (name, ".debug_line."))
14445 || streq (sec->compressed_name, name))
14446 {
14447 bfd_boolean secondary = (section != find_section (filedata, name));
14448
14449 if (secondary)
14450 free_debug_section (id);
14451
14452 if (i == line && const_strneq (name, ".debug_line."))
14453 sec->name = name;
14454 else if (streq (sec->uncompressed_name, name))
14455 sec->name = sec->uncompressed_name;
14456 else
14457 sec->name = sec->compressed_name;
14458
14459 if (load_specific_debug_section (id, section, filedata))
14460 {
14461 /* If this debug section is part of a CU/TU set in a .dwp file,
14462 restrict load_debug_section to the sections in that set. */
14463 section_subset = find_cu_tu_set (filedata, shndx);
14464
14465 result &= display->display (sec, filedata);
14466
14467 section_subset = NULL;
14468
14469 if (secondary || (id != info && id != abbrev))
14470 free_debug_section (id);
14471 }
14472 break;
14473 }
14474 }
14475
14476 if (i == max)
14477 {
14478 printf (_("Unrecognized debug section: %s\n"), print_name);
14479 result = FALSE;
14480 }
14481
14482 return result;
14483}
14484
14485/* Set DUMP_SECTS for all sections where dumps were requested
14486 based on section name. */
14487
14488static void
14489initialise_dumps_byname (Filedata * filedata)
14490{
14491 struct dump_list_entry * cur;
14492
14493 for (cur = dump_sects_byname; cur; cur = cur->next)
14494 {
14495 unsigned int i;
14496 bfd_boolean any = FALSE;
14497
14498 for (i = 0; i < filedata->file_header.e_shnum; i++)
14499 if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
14500 {
14501 request_dump_bynumber (filedata, i, cur->type);
14502 any = TRUE;
14503 }
14504
14505 if (!any)
14506 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14507 cur->name);
14508 }
14509}
14510
14511static bfd_boolean
14512process_section_contents (Filedata * filedata)
14513{
14514 Elf_Internal_Shdr * section;
14515 unsigned int i;
14516 bfd_boolean res = TRUE;
14517
14518 if (! do_dump)
14519 return TRUE;
14520
14521 initialise_dumps_byname (filedata);
14522
14523 for (i = 0, section = filedata->section_headers;
14524 i < filedata->file_header.e_shnum && i < filedata->num_dump_sects;
14525 i++, section++)
14526 {
14527 dump_type dump = filedata->dump_sects[i];
14528
14529#ifdef SUPPORT_DISASSEMBLY
14530 if (dump & DISASS_DUMP)
14531 {
14532 if (! disassemble_section (section, filedata))
14533 res = FALSE;
14534 }
14535#endif
14536 if (dump & HEX_DUMP)
14537 {
14538 if (! dump_section_as_bytes (section, filedata, FALSE))
14539 res = FALSE;
14540 }
14541
14542 if (dump & RELOC_DUMP)
14543 {
14544 if (! dump_section_as_bytes (section, filedata, TRUE))
14545 res = FALSE;
14546 }
14547
14548 if (dump & STRING_DUMP)
14549 {
14550 if (! dump_section_as_strings (section, filedata))
14551 res = FALSE;
14552 }
14553
14554 if (dump & DEBUG_DUMP)
14555 {
14556 if (! display_debug_section (i, section, filedata))
14557 res = FALSE;
14558 }
14559
14560 if (dump & CTF_DUMP)
14561 {
14562 if (! dump_section_as_ctf (section, filedata))
14563 res = FALSE;
14564 }
14565 }
14566
14567 /* Check to see if the user requested a
14568 dump of a section that does not exist. */
14569 while (i < filedata->num_dump_sects)
14570 {
14571 if (filedata->dump_sects[i])
14572 {
14573 warn (_("Section %d was not dumped because it does not exist!\n"), i);
14574 res = FALSE;
14575 }
14576 i++;
14577 }
14578
14579 return res;
14580}
14581
14582static void
14583process_mips_fpe_exception (int mask)
14584{
14585 if (mask)
14586 {
14587 bfd_boolean first = TRUE;
14588
14589 if (mask & OEX_FPU_INEX)
14590 fputs ("INEX", stdout), first = FALSE;
14591 if (mask & OEX_FPU_UFLO)
14592 printf ("%sUFLO", first ? "" : "|"), first = FALSE;
14593 if (mask & OEX_FPU_OFLO)
14594 printf ("%sOFLO", first ? "" : "|"), first = FALSE;
14595 if (mask & OEX_FPU_DIV0)
14596 printf ("%sDIV0", first ? "" : "|"), first = FALSE;
14597 if (mask & OEX_FPU_INVAL)
14598 printf ("%sINVAL", first ? "" : "|");
14599 }
14600 else
14601 fputs ("0", stdout);
14602}
14603
14604/* Display's the value of TAG at location P. If TAG is
14605 greater than 0 it is assumed to be an unknown tag, and
14606 a message is printed to this effect. Otherwise it is
14607 assumed that a message has already been printed.
14608
14609 If the bottom bit of TAG is set it assumed to have a
14610 string value, otherwise it is assumed to have an integer
14611 value.
14612
14613 Returns an updated P pointing to the first unread byte
14614 beyond the end of TAG's value.
14615
14616 Reads at or beyond END will not be made. */
14617
14618static unsigned char *
14619display_tag_value (signed int tag,
14620 unsigned char * p,
14621 const unsigned char * const end)
14622{
14623 unsigned long val;
14624
14625 if (tag > 0)
14626 printf (" Tag_unknown_%d: ", tag);
14627
14628 if (p >= end)
14629 {
14630 warn (_("<corrupt tag>\n"));
14631 }
14632 else if (tag & 1)
14633 {
14634 /* PR 17531 file: 027-19978-0.004. */
14635 size_t maxlen = (end - p) - 1;
14636
14637 putchar ('"');
14638 if (maxlen > 0)
14639 {
14640 print_symbol ((int) maxlen, (const char *) p);
14641 p += strnlen ((char *) p, maxlen) + 1;
14642 }
14643 else
14644 {
14645 printf (_("<corrupt string tag>"));
14646 p = (unsigned char *) end;
14647 }
14648 printf ("\"\n");
14649 }
14650 else
14651 {
14652 READ_ULEB (val, p, end);
14653 printf ("%ld (0x%lx)\n", val, val);
14654 }
14655
14656 assert (p <= end);
14657 return p;
14658}
14659
14660/* ARC ABI attributes section. */
14661
14662static unsigned char *
14663display_arc_attribute (unsigned char * p,
14664 const unsigned char * const end)
14665{
14666 unsigned int tag;
14667 unsigned int val;
14668
14669 READ_ULEB (tag, p, end);
14670
14671 switch (tag)
14672 {
14673 case Tag_ARC_PCS_config:
14674 READ_ULEB (val, p, end);
14675 printf (" Tag_ARC_PCS_config: ");
14676 switch (val)
14677 {
14678 case 0:
14679 printf (_("Absent/Non standard\n"));
14680 break;
14681 case 1:
14682 printf (_("Bare metal/mwdt\n"));
14683 break;
14684 case 2:
14685 printf (_("Bare metal/newlib\n"));
14686 break;
14687 case 3:
14688 printf (_("Linux/uclibc\n"));
14689 break;
14690 case 4:
14691 printf (_("Linux/glibc\n"));
14692 break;
14693 default:
14694 printf (_("Unknown\n"));
14695 break;
14696 }
14697 break;
14698
14699 case Tag_ARC_CPU_base:
14700 READ_ULEB (val, p, end);
14701 printf (" Tag_ARC_CPU_base: ");
14702 switch (val)
14703 {
14704 default:
14705 case TAG_CPU_NONE:
14706 printf (_("Absent\n"));
14707 break;
14708 case TAG_CPU_ARC6xx:
14709 printf ("ARC6xx\n");
14710 break;
14711 case TAG_CPU_ARC7xx:
14712 printf ("ARC7xx\n");
14713 break;
14714 case TAG_CPU_ARCEM:
14715 printf ("ARCEM\n");
14716 break;
14717 case TAG_CPU_ARCHS:
14718 printf ("ARCHS\n");
14719 break;
14720 }
14721 break;
14722
14723 case Tag_ARC_CPU_variation:
14724 READ_ULEB (val, p, end);
14725 printf (" Tag_ARC_CPU_variation: ");
14726 switch (val)
14727 {
14728 default:
14729 if (val > 0 && val < 16)
14730 printf ("Core%d\n", val);
14731 else
14732 printf ("Unknown\n");
14733 break;
14734
14735 case 0:
14736 printf (_("Absent\n"));
14737 break;
14738 }
14739 break;
14740
14741 case Tag_ARC_CPU_name:
14742 printf (" Tag_ARC_CPU_name: ");
14743 p = display_tag_value (-1, p, end);
14744 break;
14745
14746 case Tag_ARC_ABI_rf16:
14747 READ_ULEB (val, p, end);
14748 printf (" Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
14749 break;
14750
14751 case Tag_ARC_ABI_osver:
14752 READ_ULEB (val, p, end);
14753 printf (" Tag_ARC_ABI_osver: v%d\n", val);
14754 break;
14755
14756 case Tag_ARC_ABI_pic:
14757 case Tag_ARC_ABI_sda:
14758 READ_ULEB (val, p, end);
14759 printf (tag == Tag_ARC_ABI_sda ? " Tag_ARC_ABI_sda: "
14760 : " Tag_ARC_ABI_pic: ");
14761 switch (val)
14762 {
14763 case 0:
14764 printf (_("Absent\n"));
14765 break;
14766 case 1:
14767 printf ("MWDT\n");
14768 break;
14769 case 2:
14770 printf ("GNU\n");
14771 break;
14772 default:
14773 printf (_("Unknown\n"));
14774 break;
14775 }
14776 break;
14777
14778 case Tag_ARC_ABI_tls:
14779 READ_ULEB (val, p, end);
14780 printf (" Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
14781 break;
14782
14783 case Tag_ARC_ABI_enumsize:
14784 READ_ULEB (val, p, end);
14785 printf (" Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
14786 _("smallest"));
14787 break;
14788
14789 case Tag_ARC_ABI_exceptions:
14790 READ_ULEB (val, p, end);
14791 printf (" Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
14792 : _("default"));
14793 break;
14794
14795 case Tag_ARC_ABI_double_size:
14796 READ_ULEB (val, p, end);
14797 printf (" Tag_ARC_ABI_double_size: %d\n", val);
14798 break;
14799
14800 case Tag_ARC_ISA_config:
14801 printf (" Tag_ARC_ISA_config: ");
14802 p = display_tag_value (-1, p, end);
14803 break;
14804
14805 case Tag_ARC_ISA_apex:
14806 printf (" Tag_ARC_ISA_apex: ");
14807 p = display_tag_value (-1, p, end);
14808 break;
14809
14810 case Tag_ARC_ISA_mpy_option:
14811 READ_ULEB (val, p, end);
14812 printf (" Tag_ARC_ISA_mpy_option: %d\n", val);
14813 break;
14814
14815 case Tag_ARC_ATR_version:
14816 READ_ULEB (val, p, end);
14817 printf (" Tag_ARC_ATR_version: %d\n", val);
14818 break;
14819
14820 default:
14821 return display_tag_value (tag & 1, p, end);
14822 }
14823
14824 return p;
14825}
14826
14827/* ARM EABI attributes section. */
14828typedef struct
14829{
14830 unsigned int tag;
14831 const char * name;
14832 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14833 unsigned int type;
14834 const char ** table;
14835} arm_attr_public_tag;
14836
14837static const char * arm_attr_tag_CPU_arch[] =
14838 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14839 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14840 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
14841static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
14842static const char * arm_attr_tag_THUMB_ISA_use[] =
14843 {"No", "Thumb-1", "Thumb-2", "Yes"};
14844static const char * arm_attr_tag_FP_arch[] =
14845 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14846 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14847static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
14848static const char * arm_attr_tag_Advanced_SIMD_arch[] =
14849 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14850 "NEON for ARMv8.1"};
14851static const char * arm_attr_tag_PCS_config[] =
14852 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14853 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14854static const char * arm_attr_tag_ABI_PCS_R9_use[] =
14855 {"V6", "SB", "TLS", "Unused"};
14856static const char * arm_attr_tag_ABI_PCS_RW_data[] =
14857 {"Absolute", "PC-relative", "SB-relative", "None"};
14858static const char * arm_attr_tag_ABI_PCS_RO_data[] =
14859 {"Absolute", "PC-relative", "None"};
14860static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
14861 {"None", "direct", "GOT-indirect"};
14862static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
14863 {"None", "??? 1", "2", "??? 3", "4"};
14864static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
14865static const char * arm_attr_tag_ABI_FP_denormal[] =
14866 {"Unused", "Needed", "Sign only"};
14867static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
14868static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
14869static const char * arm_attr_tag_ABI_FP_number_model[] =
14870 {"Unused", "Finite", "RTABI", "IEEE 754"};
14871static const char * arm_attr_tag_ABI_enum_size[] =
14872 {"Unused", "small", "int", "forced to int"};
14873static const char * arm_attr_tag_ABI_HardFP_use[] =
14874 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14875static const char * arm_attr_tag_ABI_VFP_args[] =
14876 {"AAPCS", "VFP registers", "custom", "compatible"};
14877static const char * arm_attr_tag_ABI_WMMX_args[] =
14878 {"AAPCS", "WMMX registers", "custom"};
14879static const char * arm_attr_tag_ABI_optimization_goals[] =
14880 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14881 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14882static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
14883 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14884 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14885static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
14886static const char * arm_attr_tag_FP_HP_extension[] =
14887 {"Not Allowed", "Allowed"};
14888static const char * arm_attr_tag_ABI_FP_16bit_format[] =
14889 {"None", "IEEE 754", "Alternative Format"};
14890static const char * arm_attr_tag_DSP_extension[] =
14891 {"Follow architecture", "Allowed"};
14892static const char * arm_attr_tag_MPextension_use[] =
14893 {"Not Allowed", "Allowed"};
14894static const char * arm_attr_tag_DIV_use[] =
14895 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14896 "Allowed in v7-A with integer division extension"};
14897static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
14898static const char * arm_attr_tag_Virtualization_use[] =
14899 {"Not Allowed", "TrustZone", "Virtualization Extensions",
14900 "TrustZone and Virtualization Extensions"};
14901static const char * arm_attr_tag_MPextension_use_legacy[] =
14902 {"Not Allowed", "Allowed"};
14903
14904static const char * arm_attr_tag_MVE_arch[] =
14905 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
14906
14907#define LOOKUP(id, name) \
14908 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14909static arm_attr_public_tag arm_attr_public_tags[] =
14910{
14911 {4, "CPU_raw_name", 1, NULL},
14912 {5, "CPU_name", 1, NULL},
14913 LOOKUP(6, CPU_arch),
14914 {7, "CPU_arch_profile", 0, NULL},
14915 LOOKUP(8, ARM_ISA_use),
14916 LOOKUP(9, THUMB_ISA_use),
14917 LOOKUP(10, FP_arch),
14918 LOOKUP(11, WMMX_arch),
14919 LOOKUP(12, Advanced_SIMD_arch),
14920 LOOKUP(13, PCS_config),
14921 LOOKUP(14, ABI_PCS_R9_use),
14922 LOOKUP(15, ABI_PCS_RW_data),
14923 LOOKUP(16, ABI_PCS_RO_data),
14924 LOOKUP(17, ABI_PCS_GOT_use),
14925 LOOKUP(18, ABI_PCS_wchar_t),
14926 LOOKUP(19, ABI_FP_rounding),
14927 LOOKUP(20, ABI_FP_denormal),
14928 LOOKUP(21, ABI_FP_exceptions),
14929 LOOKUP(22, ABI_FP_user_exceptions),
14930 LOOKUP(23, ABI_FP_number_model),
14931 {24, "ABI_align_needed", 0, NULL},
14932 {25, "ABI_align_preserved", 0, NULL},
14933 LOOKUP(26, ABI_enum_size),
14934 LOOKUP(27, ABI_HardFP_use),
14935 LOOKUP(28, ABI_VFP_args),
14936 LOOKUP(29, ABI_WMMX_args),
14937 LOOKUP(30, ABI_optimization_goals),
14938 LOOKUP(31, ABI_FP_optimization_goals),
14939 {32, "compatibility", 0, NULL},
14940 LOOKUP(34, CPU_unaligned_access),
14941 LOOKUP(36, FP_HP_extension),
14942 LOOKUP(38, ABI_FP_16bit_format),
14943 LOOKUP(42, MPextension_use),
14944 LOOKUP(44, DIV_use),
14945 LOOKUP(46, DSP_extension),
14946 LOOKUP(48, MVE_arch),
14947 {64, "nodefaults", 0, NULL},
14948 {65, "also_compatible_with", 0, NULL},
14949 LOOKUP(66, T2EE_use),
14950 {67, "conformance", 1, NULL},
14951 LOOKUP(68, Virtualization_use),
14952 LOOKUP(70, MPextension_use_legacy)
14953};
14954#undef LOOKUP
14955
14956static unsigned char *
14957display_arm_attribute (unsigned char * p,
14958 const unsigned char * const end)
14959{
14960 unsigned int tag;
14961 unsigned int val;
14962 arm_attr_public_tag * attr;
14963 unsigned i;
14964 unsigned int type;
14965
14966 READ_ULEB (tag, p, end);
14967 attr = NULL;
14968 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
14969 {
14970 if (arm_attr_public_tags[i].tag == tag)
14971 {
14972 attr = &arm_attr_public_tags[i];
14973 break;
14974 }
14975 }
14976
14977 if (attr)
14978 {
14979 printf (" Tag_%s: ", attr->name);
14980 switch (attr->type)
14981 {
14982 case 0:
14983 switch (tag)
14984 {
14985 case 7: /* Tag_CPU_arch_profile. */
14986 READ_ULEB (val, p, end);
14987 switch (val)
14988 {
14989 case 0: printf (_("None\n")); break;
14990 case 'A': printf (_("Application\n")); break;
14991 case 'R': printf (_("Realtime\n")); break;
14992 case 'M': printf (_("Microcontroller\n")); break;
14993 case 'S': printf (_("Application or Realtime\n")); break;
14994 default: printf ("??? (%d)\n", val); break;
14995 }
14996 break;
14997
14998 case 24: /* Tag_align_needed. */
14999 READ_ULEB (val, p, end);
15000 switch (val)
15001 {
15002 case 0: printf (_("None\n")); break;
15003 case 1: printf (_("8-byte\n")); break;
15004 case 2: printf (_("4-byte\n")); break;
15005 case 3: printf ("??? 3\n"); break;
15006 default:
15007 if (val <= 12)
15008 printf (_("8-byte and up to %d-byte extended\n"),
15009 1 << val);
15010 else
15011 printf ("??? (%d)\n", val);
15012 break;
15013 }
15014 break;
15015
15016 case 25: /* Tag_align_preserved. */
15017 READ_ULEB (val, p, end);
15018 switch (val)
15019 {
15020 case 0: printf (_("None\n")); break;
15021 case 1: printf (_("8-byte, except leaf SP\n")); break;
15022 case 2: printf (_("8-byte\n")); break;
15023 case 3: printf ("??? 3\n"); break;
15024 default:
15025 if (val <= 12)
15026 printf (_("8-byte and up to %d-byte extended\n"),
15027 1 << val);
15028 else
15029 printf ("??? (%d)\n", val);
15030 break;
15031 }
15032 break;
15033
15034 case 32: /* Tag_compatibility. */
15035 {
15036 READ_ULEB (val, p, end);
15037 printf (_("flag = %d, vendor = "), val);
15038 if (p < end - 1)
15039 {
15040 size_t maxlen = (end - p) - 1;
15041
15042 print_symbol ((int) maxlen, (const char *) p);
15043 p += strnlen ((char *) p, maxlen) + 1;
15044 }
15045 else
15046 {
15047 printf (_("<corrupt>"));
15048 p = (unsigned char *) end;
15049 }
15050 putchar ('\n');
15051 }
15052 break;
15053
15054 case 64: /* Tag_nodefaults. */
15055 /* PR 17531: file: 001-505008-0.01. */
15056 if (p < end)
15057 p++;
15058 printf (_("True\n"));
15059 break;
15060
15061 case 65: /* Tag_also_compatible_with. */
15062 READ_ULEB (val, p, end);
15063 if (val == 6 /* Tag_CPU_arch. */)
15064 {
15065 READ_ULEB (val, p, end);
15066 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
15067 printf ("??? (%d)\n", val);
15068 else
15069 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
15070 }
15071 else
15072 printf ("???\n");
15073 while (p < end && *(p++) != '\0' /* NUL terminator. */)
15074 ;
15075 break;
15076
15077 default:
15078 printf (_("<unknown: %d>\n"), tag);
15079 break;
15080 }
15081 return p;
15082
15083 case 1:
15084 return display_tag_value (-1, p, end);
15085 case 2:
15086 return display_tag_value (0, p, end);
15087
15088 default:
15089 assert (attr->type & 0x80);
15090 READ_ULEB (val, p, end);
15091 type = attr->type & 0x7f;
15092 if (val >= type)
15093 printf ("??? (%d)\n", val);
15094 else
15095 printf ("%s\n", attr->table[val]);
15096 return p;
15097 }
15098 }
15099
15100 return display_tag_value (tag, p, end);
15101}
15102
15103static unsigned char *
15104display_gnu_attribute (unsigned char * p,
15105 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
15106 const unsigned char * const end)
15107{
15108 unsigned int tag;
15109 unsigned int val;
15110
15111 READ_ULEB (tag, p, end);
15112
15113 /* Tag_compatibility is the only generic GNU attribute defined at
15114 present. */
15115 if (tag == 32)
15116 {
15117 READ_ULEB (val, p, end);
15118
15119 printf (_("flag = %d, vendor = "), val);
15120 if (p == end)
15121 {
15122 printf (_("<corrupt>\n"));
15123 warn (_("corrupt vendor attribute\n"));
15124 }
15125 else
15126 {
15127 if (p < end - 1)
15128 {
15129 size_t maxlen = (end - p) - 1;
15130
15131 print_symbol ((int) maxlen, (const char *) p);
15132 p += strnlen ((char *) p, maxlen) + 1;
15133 }
15134 else
15135 {
15136 printf (_("<corrupt>"));
15137 p = (unsigned char *) end;
15138 }
15139 putchar ('\n');
15140 }
15141 return p;
15142 }
15143
15144 if ((tag & 2) == 0 && display_proc_gnu_attribute)
15145 return display_proc_gnu_attribute (p, tag, end);
15146
15147 return display_tag_value (tag, p, end);
15148}
15149
15150static unsigned char *
15151display_power_gnu_attribute (unsigned char * p,
15152 unsigned int tag,
15153 const unsigned char * const end)
15154{
15155 unsigned int val;
15156
15157 if (tag == Tag_GNU_Power_ABI_FP)
15158 {
15159 printf (" Tag_GNU_Power_ABI_FP: ");
15160 if (p == end)
15161 {
15162 printf (_("<corrupt>\n"));
15163 return p;
15164 }
15165 READ_ULEB (val, p, end);
15166
15167 if (val > 15)
15168 printf ("(%#x), ", val);
15169
15170 switch (val & 3)
15171 {
15172 case 0:
15173 printf (_("unspecified hard/soft float, "));
15174 break;
15175 case 1:
15176 printf (_("hard float, "));
15177 break;
15178 case 2:
15179 printf (_("soft float, "));
15180 break;
15181 case 3:
15182 printf (_("single-precision hard float, "));
15183 break;
15184 }
15185
15186 switch (val & 0xC)
15187 {
15188 case 0:
15189 printf (_("unspecified long double\n"));
15190 break;
15191 case 4:
15192 printf (_("128-bit IBM long double\n"));
15193 break;
15194 case 8:
15195 printf (_("64-bit long double\n"));
15196 break;
15197 case 12:
15198 printf (_("128-bit IEEE long double\n"));
15199 break;
15200 }
15201 return p;
15202 }
15203
15204 if (tag == Tag_GNU_Power_ABI_Vector)
15205 {
15206 printf (" Tag_GNU_Power_ABI_Vector: ");
15207 if (p == end)
15208 {
15209 printf (_("<corrupt>\n"));
15210 return p;
15211 }
15212 READ_ULEB (val, p, end);
15213
15214 if (val > 3)
15215 printf ("(%#x), ", val);
15216
15217 switch (val & 3)
15218 {
15219 case 0:
15220 printf (_("unspecified\n"));
15221 break;
15222 case 1:
15223 printf (_("generic\n"));
15224 break;
15225 case 2:
15226 printf ("AltiVec\n");
15227 break;
15228 case 3:
15229 printf ("SPE\n");
15230 break;
15231 }
15232 return p;
15233 }
15234
15235 if (tag == Tag_GNU_Power_ABI_Struct_Return)
15236 {
15237 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15238 if (p == end)
15239 {
15240 printf (_("<corrupt>\n"));
15241 return p;
15242 }
15243 READ_ULEB (val, p, end);
15244
15245 if (val > 2)
15246 printf ("(%#x), ", val);
15247
15248 switch (val & 3)
15249 {
15250 case 0:
15251 printf (_("unspecified\n"));
15252 break;
15253 case 1:
15254 printf ("r3/r4\n");
15255 break;
15256 case 2:
15257 printf (_("memory\n"));
15258 break;
15259 case 3:
15260 printf ("???\n");
15261 break;
15262 }
15263 return p;
15264 }
15265
15266 return display_tag_value (tag & 1, p, end);
15267}
15268
15269static unsigned char *
15270display_s390_gnu_attribute (unsigned char * p,
15271 unsigned int tag,
15272 const unsigned char * const end)
15273{
15274 unsigned int val;
15275
15276 if (tag == Tag_GNU_S390_ABI_Vector)
15277 {
15278 printf (" Tag_GNU_S390_ABI_Vector: ");
15279 READ_ULEB (val, p, end);
15280
15281 switch (val)
15282 {
15283 case 0:
15284 printf (_("any\n"));
15285 break;
15286 case 1:
15287 printf (_("software\n"));
15288 break;
15289 case 2:
15290 printf (_("hardware\n"));
15291 break;
15292 default:
15293 printf ("??? (%d)\n", val);
15294 break;
15295 }
15296 return p;
15297 }
15298
15299 return display_tag_value (tag & 1, p, end);
15300}
15301
15302static void
15303display_sparc_hwcaps (unsigned int mask)
15304{
15305 if (mask)
15306 {
15307 bfd_boolean first = TRUE;
15308
15309 if (mask & ELF_SPARC_HWCAP_MUL32)
15310 fputs ("mul32", stdout), first = FALSE;
15311 if (mask & ELF_SPARC_HWCAP_DIV32)
15312 printf ("%sdiv32", first ? "" : "|"), first = FALSE;
15313 if (mask & ELF_SPARC_HWCAP_FSMULD)
15314 printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
15315 if (mask & ELF_SPARC_HWCAP_V8PLUS)
15316 printf ("%sv8plus", first ? "" : "|"), first = FALSE;
15317 if (mask & ELF_SPARC_HWCAP_POPC)
15318 printf ("%spopc", first ? "" : "|"), first = FALSE;
15319 if (mask & ELF_SPARC_HWCAP_VIS)
15320 printf ("%svis", first ? "" : "|"), first = FALSE;
15321 if (mask & ELF_SPARC_HWCAP_VIS2)
15322 printf ("%svis2", first ? "" : "|"), first = FALSE;
15323 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
15324 printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
15325 if (mask & ELF_SPARC_HWCAP_FMAF)
15326 printf ("%sfmaf", first ? "" : "|"), first = FALSE;
15327 if (mask & ELF_SPARC_HWCAP_VIS3)
15328 printf ("%svis3", first ? "" : "|"), first = FALSE;
15329 if (mask & ELF_SPARC_HWCAP_HPC)
15330 printf ("%shpc", first ? "" : "|"), first = FALSE;
15331 if (mask & ELF_SPARC_HWCAP_RANDOM)
15332 printf ("%srandom", first ? "" : "|"), first = FALSE;
15333 if (mask & ELF_SPARC_HWCAP_TRANS)
15334 printf ("%strans", first ? "" : "|"), first = FALSE;
15335 if (mask & ELF_SPARC_HWCAP_FJFMAU)
15336 printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
15337 if (mask & ELF_SPARC_HWCAP_IMA)
15338 printf ("%sima", first ? "" : "|"), first = FALSE;
15339 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
15340 printf ("%scspare", first ? "" : "|"), first = FALSE;
15341 }
15342 else
15343 fputc ('0', stdout);
15344 fputc ('\n', stdout);
15345}
15346
15347static void
15348display_sparc_hwcaps2 (unsigned int mask)
15349{
15350 if (mask)
15351 {
15352 bfd_boolean first = TRUE;
15353
15354 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
15355 fputs ("fjathplus", stdout), first = FALSE;
15356 if (mask & ELF_SPARC_HWCAP2_VIS3B)
15357 printf ("%svis3b", first ? "" : "|"), first = FALSE;
15358 if (mask & ELF_SPARC_HWCAP2_ADP)
15359 printf ("%sadp", first ? "" : "|"), first = FALSE;
15360 if (mask & ELF_SPARC_HWCAP2_SPARC5)
15361 printf ("%ssparc5", first ? "" : "|"), first = FALSE;
15362 if (mask & ELF_SPARC_HWCAP2_MWAIT)
15363 printf ("%smwait", first ? "" : "|"), first = FALSE;
15364 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
15365 printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
15366 if (mask & ELF_SPARC_HWCAP2_XMONT)
15367 printf ("%sxmont2", first ? "" : "|"), first = FALSE;
15368 if (mask & ELF_SPARC_HWCAP2_NSEC)
15369 printf ("%snsec", first ? "" : "|"), first = FALSE;
15370 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
15371 printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
15372 if (mask & ELF_SPARC_HWCAP2_FJDES)
15373 printf ("%sfjdes", first ? "" : "|"), first = FALSE;
15374 if (mask & ELF_SPARC_HWCAP2_FJAES)
15375 printf ("%sfjaes", first ? "" : "|"), first = FALSE;
15376 }
15377 else
15378 fputc ('0', stdout);
15379 fputc ('\n', stdout);
15380}
15381
15382static unsigned char *
15383display_sparc_gnu_attribute (unsigned char * p,
15384 unsigned int tag,
15385 const unsigned char * const end)
15386{
15387 unsigned int val;
15388
15389 if (tag == Tag_GNU_Sparc_HWCAPS)
15390 {
15391 READ_ULEB (val, p, end);
15392 printf (" Tag_GNU_Sparc_HWCAPS: ");
15393 display_sparc_hwcaps (val);
15394 return p;
15395 }
15396 if (tag == Tag_GNU_Sparc_HWCAPS2)
15397 {
15398 READ_ULEB (val, p, end);
15399 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15400 display_sparc_hwcaps2 (val);
15401 return p;
15402 }
15403
15404 return display_tag_value (tag, p, end);
15405}
15406
15407static void
15408print_mips_fp_abi_value (unsigned int val)
15409{
15410 switch (val)
15411 {
15412 case Val_GNU_MIPS_ABI_FP_ANY:
15413 printf (_("Hard or soft float\n"));
15414 break;
15415 case Val_GNU_MIPS_ABI_FP_DOUBLE:
15416 printf (_("Hard float (double precision)\n"));
15417 break;
15418 case Val_GNU_MIPS_ABI_FP_SINGLE:
15419 printf (_("Hard float (single precision)\n"));
15420 break;
15421 case Val_GNU_MIPS_ABI_FP_SOFT:
15422 printf (_("Soft float\n"));
15423 break;
15424 case Val_GNU_MIPS_ABI_FP_OLD_64:
15425 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15426 break;
15427 case Val_GNU_MIPS_ABI_FP_XX:
15428 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15429 break;
15430 case Val_GNU_MIPS_ABI_FP_64:
15431 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15432 break;
15433 case Val_GNU_MIPS_ABI_FP_64A:
15434 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15435 break;
15436 case Val_GNU_MIPS_ABI_FP_NAN2008:
15437 printf (_("NaN 2008 compatibility\n"));
15438 break;
15439 default:
15440 printf ("??? (%d)\n", val);
15441 break;
15442 }
15443}
15444
15445static unsigned char *
15446display_mips_gnu_attribute (unsigned char * p,
15447 unsigned int tag,
15448 const unsigned char * const end)
15449{
15450 if (tag == Tag_GNU_MIPS_ABI_FP)
15451 {
15452 unsigned int val;
15453
15454 printf (" Tag_GNU_MIPS_ABI_FP: ");
15455 READ_ULEB (val, p, end);
15456 print_mips_fp_abi_value (val);
15457 return p;
15458 }
15459
15460 if (tag == Tag_GNU_MIPS_ABI_MSA)
15461 {
15462 unsigned int val;
15463
15464 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15465 READ_ULEB (val, p, end);
15466
15467 switch (val)
15468 {
15469 case Val_GNU_MIPS_ABI_MSA_ANY:
15470 printf (_("Any MSA or not\n"));
15471 break;
15472 case Val_GNU_MIPS_ABI_MSA_128:
15473 printf (_("128-bit MSA\n"));
15474 break;
15475 default:
15476 printf ("??? (%d)\n", val);
15477 break;
15478 }
15479 return p;
15480 }
15481
15482 return display_tag_value (tag & 1, p, end);
15483}
15484
15485static unsigned char *
15486display_tic6x_attribute (unsigned char * p,
15487 const unsigned char * const end)
15488{
15489 unsigned int tag;
15490 unsigned int val;
15491
15492 READ_ULEB (tag, p, end);
15493
15494 switch (tag)
15495 {
15496 case Tag_ISA:
15497 printf (" Tag_ISA: ");
15498 READ_ULEB (val, p, end);
15499
15500 switch (val)
15501 {
15502 case C6XABI_Tag_ISA_none:
15503 printf (_("None\n"));
15504 break;
15505 case C6XABI_Tag_ISA_C62X:
15506 printf ("C62x\n");
15507 break;
15508 case C6XABI_Tag_ISA_C67X:
15509 printf ("C67x\n");
15510 break;
15511 case C6XABI_Tag_ISA_C67XP:
15512 printf ("C67x+\n");
15513 break;
15514 case C6XABI_Tag_ISA_C64X:
15515 printf ("C64x\n");
15516 break;
15517 case C6XABI_Tag_ISA_C64XP:
15518 printf ("C64x+\n");
15519 break;
15520 case C6XABI_Tag_ISA_C674X:
15521 printf ("C674x\n");
15522 break;
15523 default:
15524 printf ("??? (%d)\n", val);
15525 break;
15526 }
15527 return p;
15528
15529 case Tag_ABI_wchar_t:
15530 printf (" Tag_ABI_wchar_t: ");
15531 READ_ULEB (val, p, end);
15532 switch (val)
15533 {
15534 case 0:
15535 printf (_("Not used\n"));
15536 break;
15537 case 1:
15538 printf (_("2 bytes\n"));
15539 break;
15540 case 2:
15541 printf (_("4 bytes\n"));
15542 break;
15543 default:
15544 printf ("??? (%d)\n", val);
15545 break;
15546 }
15547 return p;
15548
15549 case Tag_ABI_stack_align_needed:
15550 printf (" Tag_ABI_stack_align_needed: ");
15551 READ_ULEB (val, p, end);
15552 switch (val)
15553 {
15554 case 0:
15555 printf (_("8-byte\n"));
15556 break;
15557 case 1:
15558 printf (_("16-byte\n"));
15559 break;
15560 default:
15561 printf ("??? (%d)\n", val);
15562 break;
15563 }
15564 return p;
15565
15566 case Tag_ABI_stack_align_preserved:
15567 READ_ULEB (val, p, end);
15568 printf (" Tag_ABI_stack_align_preserved: ");
15569 switch (val)
15570 {
15571 case 0:
15572 printf (_("8-byte\n"));
15573 break;
15574 case 1:
15575 printf (_("16-byte\n"));
15576 break;
15577 default:
15578 printf ("??? (%d)\n", val);
15579 break;
15580 }
15581 return p;
15582
15583 case Tag_ABI_DSBT:
15584 READ_ULEB (val, p, end);
15585 printf (" Tag_ABI_DSBT: ");
15586 switch (val)
15587 {
15588 case 0:
15589 printf (_("DSBT addressing not used\n"));
15590 break;
15591 case 1:
15592 printf (_("DSBT addressing used\n"));
15593 break;
15594 default:
15595 printf ("??? (%d)\n", val);
15596 break;
15597 }
15598 return p;
15599
15600 case Tag_ABI_PID:
15601 READ_ULEB (val, p, end);
15602 printf (" Tag_ABI_PID: ");
15603 switch (val)
15604 {
15605 case 0:
15606 printf (_("Data addressing position-dependent\n"));
15607 break;
15608 case 1:
15609 printf (_("Data addressing position-independent, GOT near DP\n"));
15610 break;
15611 case 2:
15612 printf (_("Data addressing position-independent, GOT far from DP\n"));
15613 break;
15614 default:
15615 printf ("??? (%d)\n", val);
15616 break;
15617 }
15618 return p;
15619
15620 case Tag_ABI_PIC:
15621 READ_ULEB (val, p, end);
15622 printf (" Tag_ABI_PIC: ");
15623 switch (val)
15624 {
15625 case 0:
15626 printf (_("Code addressing position-dependent\n"));
15627 break;
15628 case 1:
15629 printf (_("Code addressing position-independent\n"));
15630 break;
15631 default:
15632 printf ("??? (%d)\n", val);
15633 break;
15634 }
15635 return p;
15636
15637 case Tag_ABI_array_object_alignment:
15638 READ_ULEB (val, p, end);
15639 printf (" Tag_ABI_array_object_alignment: ");
15640 switch (val)
15641 {
15642 case 0:
15643 printf (_("8-byte\n"));
15644 break;
15645 case 1:
15646 printf (_("4-byte\n"));
15647 break;
15648 case 2:
15649 printf (_("16-byte\n"));
15650 break;
15651 default:
15652 printf ("??? (%d)\n", val);
15653 break;
15654 }
15655 return p;
15656
15657 case Tag_ABI_array_object_align_expected:
15658 READ_ULEB (val, p, end);
15659 printf (" Tag_ABI_array_object_align_expected: ");
15660 switch (val)
15661 {
15662 case 0:
15663 printf (_("8-byte\n"));
15664 break;
15665 case 1:
15666 printf (_("4-byte\n"));
15667 break;
15668 case 2:
15669 printf (_("16-byte\n"));
15670 break;
15671 default:
15672 printf ("??? (%d)\n", val);
15673 break;
15674 }
15675 return p;
15676
15677 case Tag_ABI_compatibility:
15678 {
15679 READ_ULEB (val, p, end);
15680 printf (" Tag_ABI_compatibility: ");
15681 printf (_("flag = %d, vendor = "), val);
15682 if (p < end - 1)
15683 {
15684 size_t maxlen = (end - p) - 1;
15685
15686 print_symbol ((int) maxlen, (const char *) p);
15687 p += strnlen ((char *) p, maxlen) + 1;
15688 }
15689 else
15690 {
15691 printf (_("<corrupt>"));
15692 p = (unsigned char *) end;
15693 }
15694 putchar ('\n');
15695 return p;
15696 }
15697
15698 case Tag_ABI_conformance:
15699 {
15700 printf (" Tag_ABI_conformance: \"");
15701 if (p < end - 1)
15702 {
15703 size_t maxlen = (end - p) - 1;
15704
15705 print_symbol ((int) maxlen, (const char *) p);
15706 p += strnlen ((char *) p, maxlen) + 1;
15707 }
15708 else
15709 {
15710 printf (_("<corrupt>"));
15711 p = (unsigned char *) end;
15712 }
15713 printf ("\"\n");
15714 return p;
15715 }
15716 }
15717
15718 return display_tag_value (tag, p, end);
15719}
15720
15721static void
15722display_raw_attribute (unsigned char * p, unsigned char const * const end)
15723{
15724 unsigned long addr = 0;
15725 size_t bytes = end - p;
15726
15727 assert (end >= p);
15728 while (bytes)
15729 {
15730 int j;
15731 int k;
15732 int lbytes = (bytes > 16 ? 16 : bytes);
15733
15734 printf (" 0x%8.8lx ", addr);
15735
15736 for (j = 0; j < 16; j++)
15737 {
15738 if (j < lbytes)
15739 printf ("%2.2x", p[j]);
15740 else
15741 printf (" ");
15742
15743 if ((j & 3) == 3)
15744 printf (" ");
15745 }
15746
15747 for (j = 0; j < lbytes; j++)
15748 {
15749 k = p[j];
15750 if (k >= ' ' && k < 0x7f)
15751 printf ("%c", k);
15752 else
15753 printf (".");
15754 }
15755
15756 putchar ('\n');
15757
15758 p += lbytes;
15759 bytes -= lbytes;
15760 addr += lbytes;
15761 }
15762
15763 putchar ('\n');
15764}
15765
15766static unsigned char *
15767display_msp430x_attribute (unsigned char * p,
15768 const unsigned char * const end)
15769{
15770 unsigned int val;
15771 unsigned int tag;
15772
15773 READ_ULEB (tag, p, end);
15774
15775 switch (tag)
15776 {
15777 case OFBA_MSPABI_Tag_ISA:
15778 printf (" Tag_ISA: ");
15779 READ_ULEB (val, p, end);
15780 switch (val)
15781 {
15782 case 0: printf (_("None\n")); break;
15783 case 1: printf (_("MSP430\n")); break;
15784 case 2: printf (_("MSP430X\n")); break;
15785 default: printf ("??? (%d)\n", val); break;
15786 }
15787 break;
15788
15789 case OFBA_MSPABI_Tag_Code_Model:
15790 printf (" Tag_Code_Model: ");
15791 READ_ULEB (val, p, end);
15792 switch (val)
15793 {
15794 case 0: printf (_("None\n")); break;
15795 case 1: printf (_("Small\n")); break;
15796 case 2: printf (_("Large\n")); break;
15797 default: printf ("??? (%d)\n", val); break;
15798 }
15799 break;
15800
15801 case OFBA_MSPABI_Tag_Data_Model:
15802 printf (" Tag_Data_Model: ");
15803 READ_ULEB (val, p, end);
15804 switch (val)
15805 {
15806 case 0: printf (_("None\n")); break;
15807 case 1: printf (_("Small\n")); break;
15808 case 2: printf (_("Large\n")); break;
15809 case 3: printf (_("Restricted Large\n")); break;
15810 default: printf ("??? (%d)\n", val); break;
15811 }
15812 break;
15813
15814 default:
15815 printf (_(" <unknown tag %d>: "), tag);
15816
15817 if (tag & 1)
15818 {
15819 putchar ('"');
15820 if (p < end - 1)
15821 {
15822 size_t maxlen = (end - p) - 1;
15823
15824 print_symbol ((int) maxlen, (const char *) p);
15825 p += strnlen ((char *) p, maxlen) + 1;
15826 }
15827 else
15828 {
15829 printf (_("<corrupt>"));
15830 p = (unsigned char *) end;
15831 }
15832 printf ("\"\n");
15833 }
15834 else
15835 {
15836 READ_ULEB (val, p, end);
15837 printf ("%d (0x%x)\n", val, val);
15838 }
15839 break;
15840 }
15841
15842 assert (p <= end);
15843 return p;
15844}
15845
15846static unsigned char *
15847display_msp430_gnu_attribute (unsigned char * p,
15848 unsigned int tag,
15849 const unsigned char * const end)
15850{
15851 if (tag == Tag_GNU_MSP430_Data_Region)
15852 {
15853 unsigned int val;
15854
15855 printf (" Tag_GNU_MSP430_Data_Region: ");
15856 READ_ULEB (val, p, end);
15857
15858 switch (val)
15859 {
15860 case Val_GNU_MSP430_Data_Region_Any:
15861 printf (_("Any Region\n"));
15862 break;
15863 case Val_GNU_MSP430_Data_Region_Lower:
15864 printf (_("Lower Region Only\n"));
15865 break;
15866 default:
15867 printf ("??? (%u)\n", val);
15868 }
15869 return p;
15870 }
15871 return display_tag_value (tag & 1, p, end);
15872}
15873
15874struct riscv_attr_tag_t {
15875 const char *name;
15876 unsigned int tag;
15877};
15878
15879static struct riscv_attr_tag_t riscv_attr_tag[] =
15880{
15881#define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
15882 T(arch),
15883 T(priv_spec),
15884 T(priv_spec_minor),
15885 T(priv_spec_revision),
15886 T(unaligned_access),
15887 T(stack_align),
15888#undef T
15889};
15890
15891static unsigned char *
15892display_riscv_attribute (unsigned char *p,
15893 const unsigned char * const end)
15894{
15895 unsigned int val;
15896 unsigned int tag;
15897 struct riscv_attr_tag_t *attr = NULL;
15898 unsigned i;
15899
15900 READ_ULEB (tag, p, end);
15901
15902 /* Find the name of attribute. */
15903 for (i = 0; i < ARRAY_SIZE (riscv_attr_tag); i++)
15904 {
15905 if (riscv_attr_tag[i].tag == tag)
15906 {
15907 attr = &riscv_attr_tag[i];
15908 break;
15909 }
15910 }
15911
15912 if (attr)
15913 printf (" %s: ", attr->name);
15914 else
15915 return display_tag_value (tag, p, end);
15916
15917 switch (tag)
15918 {
15919 case Tag_RISCV_priv_spec:
15920 case Tag_RISCV_priv_spec_minor:
15921 case Tag_RISCV_priv_spec_revision:
15922 READ_ULEB (val, p, end);
15923 printf (_("%u\n"), val);
15924 break;
15925 case Tag_RISCV_unaligned_access:
15926 READ_ULEB (val, p, end);
15927 switch (val)
15928 {
15929 case 0:
15930 printf (_("No unaligned access\n"));
15931 break;
15932 case 1:
15933 printf (_("Unaligned access\n"));
15934 break;
15935 }
15936 break;
15937 case Tag_RISCV_stack_align:
15938 READ_ULEB (val, p, end);
15939 printf (_("%u-bytes\n"), val);
15940 break;
15941 case Tag_RISCV_arch:
15942 p = display_tag_value (-1, p, end);
15943 break;
15944 default:
15945 return display_tag_value (tag, p, end);
15946 }
15947
15948 return p;
15949}
15950
15951static bfd_boolean
15952process_attributes (Filedata * filedata,
15953 const char * public_name,
15954 unsigned int proc_type,
15955 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
15956 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
15957{
15958 Elf_Internal_Shdr * sect;
15959 unsigned i;
15960 bfd_boolean res = TRUE;
15961
15962 /* Find the section header so that we get the size. */
15963 for (i = 0, sect = filedata->section_headers;
15964 i < filedata->file_header.e_shnum;
15965 i++, sect++)
15966 {
15967 unsigned char * contents;
15968 unsigned char * p;
15969
15970 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
15971 continue;
15972
15973 contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
15974 sect->sh_size, _("attributes"));
15975 if (contents == NULL)
15976 {
15977 res = FALSE;
15978 continue;
15979 }
15980
15981 p = contents;
15982 /* The first character is the version of the attributes.
15983 Currently only version 1, (aka 'A') is recognised here. */
15984 if (*p != 'A')
15985 {
15986 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
15987 res = FALSE;
15988 }
15989 else
15990 {
15991 bfd_vma section_len;
15992
15993 section_len = sect->sh_size - 1;
15994 p++;
15995
15996 while (section_len > 0)
15997 {
15998 bfd_vma attr_len;
15999 unsigned int namelen;
16000 bfd_boolean public_section;
16001 bfd_boolean gnu_section;
16002
16003 if (section_len <= 4)
16004 {
16005 error (_("Tag section ends prematurely\n"));
16006 res = FALSE;
16007 break;
16008 }
16009 attr_len = byte_get (p, 4);
16010 p += 4;
16011
16012 if (attr_len > section_len)
16013 {
16014 error (_("Bad attribute length (%u > %u)\n"),
16015 (unsigned) attr_len, (unsigned) section_len);
16016 attr_len = section_len;
16017 res = FALSE;
16018 }
16019 /* PR 17531: file: 001-101425-0.004 */
16020 else if (attr_len < 5)
16021 {
16022 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
16023 res = FALSE;
16024 break;
16025 }
16026
16027 section_len -= attr_len;
16028 attr_len -= 4;
16029
16030 namelen = strnlen ((char *) p, attr_len) + 1;
16031 if (namelen == 0 || namelen >= attr_len)
16032 {
16033 error (_("Corrupt attribute section name\n"));
16034 res = FALSE;
16035 break;
16036 }
16037
16038 printf (_("Attribute Section: "));
16039 print_symbol (INT_MAX, (const char *) p);
16040 putchar ('\n');
16041
16042 if (public_name && streq ((char *) p, public_name))
16043 public_section = TRUE;
16044 else
16045 public_section = FALSE;
16046
16047 if (streq ((char *) p, "gnu"))
16048 gnu_section = TRUE;
16049 else
16050 gnu_section = FALSE;
16051
16052 p += namelen;
16053 attr_len -= namelen;
16054
16055 while (attr_len > 0 && p < contents + sect->sh_size)
16056 {
16057 int tag;
16058 unsigned int val;
16059 bfd_vma size;
16060 unsigned char * end;
16061
16062 /* PR binutils/17531: Safe handling of corrupt files. */
16063 if (attr_len < 6)
16064 {
16065 error (_("Unused bytes at end of section\n"));
16066 res = FALSE;
16067 section_len = 0;
16068 break;
16069 }
16070
16071 tag = *(p++);
16072 size = byte_get (p, 4);
16073 if (size > attr_len)
16074 {
16075 error (_("Bad subsection length (%u > %u)\n"),
16076 (unsigned) size, (unsigned) attr_len);
16077 res = FALSE;
16078 size = attr_len;
16079 }
16080 /* PR binutils/17531: Safe handling of corrupt files. */
16081 if (size < 6)
16082 {
16083 error (_("Bad subsection length (%u < 6)\n"),
16084 (unsigned) size);
16085 res = FALSE;
16086 section_len = 0;
16087 break;
16088 }
16089
16090 attr_len -= size;
16091 end = p + size - 1;
16092 assert (end <= contents + sect->sh_size);
16093 p += 4;
16094
16095 switch (tag)
16096 {
16097 case 1:
16098 printf (_("File Attributes\n"));
16099 break;
16100 case 2:
16101 printf (_("Section Attributes:"));
16102 goto do_numlist;
16103 case 3:
16104 printf (_("Symbol Attributes:"));
16105 /* Fall through. */
16106 do_numlist:
16107 for (;;)
16108 {
16109 READ_ULEB (val, p, end);
16110 if (val == 0)
16111 break;
16112 printf (" %d", val);
16113 }
16114 printf ("\n");
16115 break;
16116 default:
16117 printf (_("Unknown tag: %d\n"), tag);
16118 public_section = FALSE;
16119 break;
16120 }
16121
16122 if (public_section && display_pub_attribute != NULL)
16123 {
16124 while (p < end)
16125 p = display_pub_attribute (p, end);
16126 assert (p == end);
16127 }
16128 else if (gnu_section && display_proc_gnu_attribute != NULL)
16129 {
16130 while (p < end)
16131 p = display_gnu_attribute (p,
16132 display_proc_gnu_attribute,
16133 end);
16134 assert (p == end);
16135 }
16136 else if (p < end)
16137 {
16138 printf (_(" Unknown attribute:\n"));
16139 display_raw_attribute (p, end);
16140 p = end;
16141 }
16142 else
16143 attr_len = 0;
16144 }
16145 }
16146 }
16147
16148 free (contents);
16149 }
16150
16151 return res;
16152}
16153
16154/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16155 Print the Address, Access and Initial fields of an entry at VMA ADDR
16156 and return the VMA of the next entry, or -1 if there was a problem.
16157 Does not read from DATA_END or beyond. */
16158
16159static bfd_vma
16160print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
16161 unsigned char * data_end)
16162{
16163 printf (" ");
16164 print_vma (addr, LONG_HEX);
16165 printf (" ");
16166 if (addr < pltgot + 0xfff0)
16167 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
16168 else
16169 printf ("%10s", "");
16170 printf (" ");
16171 if (data == NULL)
16172 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
16173 else
16174 {
16175 bfd_vma entry;
16176 unsigned char * from = data + addr - pltgot;
16177
16178 if (from + (is_32bit_elf ? 4 : 8) > data_end)
16179 {
16180 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16181 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
16182 return (bfd_vma) -1;
16183 }
16184 else
16185 {
16186 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
16187 print_vma (entry, LONG_HEX);
16188 }
16189 }
16190 return addr + (is_32bit_elf ? 4 : 8);
16191}
16192
16193/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16194 PLTGOT. Print the Address and Initial fields of an entry at VMA
16195 ADDR and return the VMA of the next entry. */
16196
16197static bfd_vma
16198print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
16199{
16200 printf (" ");
16201 print_vma (addr, LONG_HEX);
16202 printf (" ");
16203 if (data == NULL)
16204 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
16205 else
16206 {
16207 bfd_vma entry;
16208
16209 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
16210 print_vma (entry, LONG_HEX);
16211 }
16212 return addr + (is_32bit_elf ? 4 : 8);
16213}
16214
16215static void
16216print_mips_ases (unsigned int mask)
16217{
16218 if (mask & AFL_ASE_DSP)
16219 fputs ("\n\tDSP ASE", stdout);
16220 if (mask & AFL_ASE_DSPR2)
16221 fputs ("\n\tDSP R2 ASE", stdout);
16222 if (mask & AFL_ASE_DSPR3)
16223 fputs ("\n\tDSP R3 ASE", stdout);
16224 if (mask & AFL_ASE_EVA)
16225 fputs ("\n\tEnhanced VA Scheme", stdout);
16226 if (mask & AFL_ASE_MCU)
16227 fputs ("\n\tMCU (MicroController) ASE", stdout);
16228 if (mask & AFL_ASE_MDMX)
16229 fputs ("\n\tMDMX ASE", stdout);
16230 if (mask & AFL_ASE_MIPS3D)
16231 fputs ("\n\tMIPS-3D ASE", stdout);
16232 if (mask & AFL_ASE_MT)
16233 fputs ("\n\tMT ASE", stdout);
16234 if (mask & AFL_ASE_SMARTMIPS)
16235 fputs ("\n\tSmartMIPS ASE", stdout);
16236 if (mask & AFL_ASE_VIRT)
16237 fputs ("\n\tVZ ASE", stdout);
16238 if (mask & AFL_ASE_MSA)
16239 fputs ("\n\tMSA ASE", stdout);
16240 if (mask & AFL_ASE_MIPS16)
16241 fputs ("\n\tMIPS16 ASE", stdout);
16242 if (mask & AFL_ASE_MICROMIPS)
16243 fputs ("\n\tMICROMIPS ASE", stdout);
16244 if (mask & AFL_ASE_XPA)
16245 fputs ("\n\tXPA ASE", stdout);
16246 if (mask & AFL_ASE_MIPS16E2)
16247 fputs ("\n\tMIPS16e2 ASE", stdout);
16248 if (mask & AFL_ASE_CRC)
16249 fputs ("\n\tCRC ASE", stdout);
16250 if (mask & AFL_ASE_GINV)
16251 fputs ("\n\tGINV ASE", stdout);
16252 if (mask & AFL_ASE_LOONGSON_MMI)
16253 fputs ("\n\tLoongson MMI ASE", stdout);
16254 if (mask & AFL_ASE_LOONGSON_CAM)
16255 fputs ("\n\tLoongson CAM ASE", stdout);
16256 if (mask & AFL_ASE_LOONGSON_EXT)
16257 fputs ("\n\tLoongson EXT ASE", stdout);
16258 if (mask & AFL_ASE_LOONGSON_EXT2)
16259 fputs ("\n\tLoongson EXT2 ASE", stdout);
16260 if (mask == 0)
16261 fprintf (stdout, "\n\t%s", _("None"));
16262 else if ((mask & ~AFL_ASE_MASK) != 0)
16263 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
16264}
16265
16266static void
16267print_mips_isa_ext (unsigned int isa_ext)
16268{
16269 switch (isa_ext)
16270 {
16271 case 0:
16272 fputs (_("None"), stdout);
16273 break;
16274 case AFL_EXT_XLR:
16275 fputs ("RMI XLR", stdout);
16276 break;
16277 case AFL_EXT_OCTEON3:
16278 fputs ("Cavium Networks Octeon3", stdout);
16279 break;
16280 case AFL_EXT_OCTEON2:
16281 fputs ("Cavium Networks Octeon2", stdout);
16282 break;
16283 case AFL_EXT_OCTEONP:
16284 fputs ("Cavium Networks OcteonP", stdout);
16285 break;
16286 case AFL_EXT_OCTEON:
16287 fputs ("Cavium Networks Octeon", stdout);
16288 break;
16289 case AFL_EXT_5900:
16290 fputs ("Toshiba R5900", stdout);
16291 break;
16292 case AFL_EXT_4650:
16293 fputs ("MIPS R4650", stdout);
16294 break;
16295 case AFL_EXT_4010:
16296 fputs ("LSI R4010", stdout);
16297 break;
16298 case AFL_EXT_4100:
16299 fputs ("NEC VR4100", stdout);
16300 break;
16301 case AFL_EXT_3900:
16302 fputs ("Toshiba R3900", stdout);
16303 break;
16304 case AFL_EXT_10000:
16305 fputs ("MIPS R10000", stdout);
16306 break;
16307 case AFL_EXT_SB1:
16308 fputs ("Broadcom SB-1", stdout);
16309 break;
16310 case AFL_EXT_4111:
16311 fputs ("NEC VR4111/VR4181", stdout);
16312 break;
16313 case AFL_EXT_4120:
16314 fputs ("NEC VR4120", stdout);
16315 break;
16316 case AFL_EXT_5400:
16317 fputs ("NEC VR5400", stdout);
16318 break;
16319 case AFL_EXT_5500:
16320 fputs ("NEC VR5500", stdout);
16321 break;
16322 case AFL_EXT_LOONGSON_2E:
16323 fputs ("ST Microelectronics Loongson 2E", stdout);
16324 break;
16325 case AFL_EXT_LOONGSON_2F:
16326 fputs ("ST Microelectronics Loongson 2F", stdout);
16327 break;
16328 case AFL_EXT_INTERAPTIV_MR2:
16329 fputs ("Imagination interAptiv MR2", stdout);
16330 break;
16331 default:
16332 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
16333 }
16334}
16335
16336static signed int
16337get_mips_reg_size (int reg_size)
16338{
16339 return (reg_size == AFL_REG_NONE) ? 0
16340 : (reg_size == AFL_REG_32) ? 32
16341 : (reg_size == AFL_REG_64) ? 64
16342 : (reg_size == AFL_REG_128) ? 128
16343 : -1;
16344}
16345
16346static bfd_boolean
16347process_mips_specific (Filedata * filedata)
16348{
16349 Elf_Internal_Dyn * entry;
16350 Elf_Internal_Shdr *sect = NULL;
16351 size_t liblist_offset = 0;
16352 size_t liblistno = 0;
16353 size_t conflictsno = 0;
16354 size_t options_offset = 0;
16355 size_t conflicts_offset = 0;
16356 size_t pltrelsz = 0;
16357 size_t pltrel = 0;
16358 bfd_vma pltgot = 0;
16359 bfd_vma mips_pltgot = 0;
16360 bfd_vma jmprel = 0;
16361 bfd_vma local_gotno = 0;
16362 bfd_vma gotsym = 0;
16363 bfd_vma symtabno = 0;
16364 bfd_boolean res = TRUE;
16365
16366 if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
16367 display_mips_gnu_attribute))
16368 res = FALSE;
16369
16370 sect = find_section (filedata, ".MIPS.abiflags");
16371
16372 if (sect != NULL)
16373 {
16374 Elf_External_ABIFlags_v0 *abiflags_ext;
16375 Elf_Internal_ABIFlags_v0 abiflags_in;
16376
16377 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
16378 {
16379 error (_("Corrupt MIPS ABI Flags section.\n"));
16380 res = FALSE;
16381 }
16382 else
16383 {
16384 abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
16385 sect->sh_size, _("MIPS ABI Flags section"));
16386 if (abiflags_ext)
16387 {
16388 abiflags_in.version = BYTE_GET (abiflags_ext->version);
16389 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
16390 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
16391 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
16392 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
16393 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
16394 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
16395 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
16396 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
16397 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
16398 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
16399
16400 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
16401 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
16402 if (abiflags_in.isa_rev > 1)
16403 printf ("r%d", abiflags_in.isa_rev);
16404 printf ("\nGPR size: %d",
16405 get_mips_reg_size (abiflags_in.gpr_size));
16406 printf ("\nCPR1 size: %d",
16407 get_mips_reg_size (abiflags_in.cpr1_size));
16408 printf ("\nCPR2 size: %d",
16409 get_mips_reg_size (abiflags_in.cpr2_size));
16410 fputs ("\nFP ABI: ", stdout);
16411 print_mips_fp_abi_value (abiflags_in.fp_abi);
16412 fputs ("ISA Extension: ", stdout);
16413 print_mips_isa_ext (abiflags_in.isa_ext);
16414 fputs ("\nASEs:", stdout);
16415 print_mips_ases (abiflags_in.ases);
16416 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
16417 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
16418 fputc ('\n', stdout);
16419 free (abiflags_ext);
16420 }
16421 }
16422 }
16423
16424 /* We have a lot of special sections. Thanks SGI! */
16425 if (dynamic_section == NULL)
16426 {
16427 /* No dynamic information available. See if there is static GOT. */
16428 sect = find_section (filedata, ".got");
16429 if (sect != NULL)
16430 {
16431 unsigned char *data_end;
16432 unsigned char *data;
16433 bfd_vma ent, end;
16434 int addr_size;
16435
16436 pltgot = sect->sh_addr;
16437
16438 ent = pltgot;
16439 addr_size = (is_32bit_elf ? 4 : 8);
16440 end = pltgot + sect->sh_size;
16441
16442 data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
16443 end - pltgot, 1,
16444 _("Global Offset Table data"));
16445 /* PR 12855: Null data is handled gracefully throughout. */
16446 data_end = data + (end - pltgot);
16447
16448 printf (_("\nStatic GOT:\n"));
16449 printf (_(" Canonical gp value: "));
16450 print_vma (ent + 0x7ff0, LONG_HEX);
16451 printf ("\n\n");
16452
16453 /* In a dynamic binary GOT[0] is reserved for the dynamic
16454 loader to store the lazy resolver pointer, however in
16455 a static binary it may well have been omitted and GOT
16456 reduced to a table of addresses.
16457 PR 21344: Check for the entry being fully available
16458 before fetching it. */
16459 if (data
16460 && data + ent - pltgot + addr_size <= data_end
16461 && byte_get (data + ent - pltgot, addr_size) == 0)
16462 {
16463 printf (_(" Reserved entries:\n"));
16464 printf (_(" %*s %10s %*s\n"),
16465 addr_size * 2, _("Address"), _("Access"),
16466 addr_size * 2, _("Value"));
16467 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16468 printf ("\n");
16469 if (ent == (bfd_vma) -1)
16470 goto sgot_print_fail;
16471
16472 /* Check for the MSB of GOT[1] being set, identifying a
16473 GNU object. This entry will be used by some runtime
16474 loaders, to store the module pointer. Otherwise this
16475 is an ordinary local entry.
16476 PR 21344: Check for the entry being fully available
16477 before fetching it. */
16478 if (data
16479 && data + ent - pltgot + addr_size <= data_end
16480 && (byte_get (data + ent - pltgot, addr_size)
16481 >> (addr_size * 8 - 1)) != 0)
16482 {
16483 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16484 printf ("\n");
16485 if (ent == (bfd_vma) -1)
16486 goto sgot_print_fail;
16487 }
16488 printf ("\n");
16489 }
16490
16491 if (data != NULL && ent < end)
16492 {
16493 printf (_(" Local entries:\n"));
16494 printf (" %*s %10s %*s\n",
16495 addr_size * 2, _("Address"), _("Access"),
16496 addr_size * 2, _("Value"));
16497 while (ent < end)
16498 {
16499 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16500 printf ("\n");
16501 if (ent == (bfd_vma) -1)
16502 goto sgot_print_fail;
16503 }
16504 printf ("\n");
16505 }
16506
16507 sgot_print_fail:
16508 if (data)
16509 free (data);
16510 }
16511 return res;
16512 }
16513
16514 for (entry = dynamic_section;
16515 /* PR 17531 file: 012-50589-0.004. */
16516 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
16517 ++entry)
16518 switch (entry->d_tag)
16519 {
16520 case DT_MIPS_LIBLIST:
16521 liblist_offset
16522 = offset_from_vma (filedata, entry->d_un.d_val,
16523 liblistno * sizeof (Elf32_External_Lib));
16524 break;
16525 case DT_MIPS_LIBLISTNO:
16526 liblistno = entry->d_un.d_val;
16527 break;
16528 case DT_MIPS_OPTIONS:
16529 options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
16530 break;
16531 case DT_MIPS_CONFLICT:
16532 conflicts_offset
16533 = offset_from_vma (filedata, entry->d_un.d_val,
16534 conflictsno * sizeof (Elf32_External_Conflict));
16535 break;
16536 case DT_MIPS_CONFLICTNO:
16537 conflictsno = entry->d_un.d_val;
16538 break;
16539 case DT_PLTGOT:
16540 pltgot = entry->d_un.d_ptr;
16541 break;
16542 case DT_MIPS_LOCAL_GOTNO:
16543 local_gotno = entry->d_un.d_val;
16544 break;
16545 case DT_MIPS_GOTSYM:
16546 gotsym = entry->d_un.d_val;
16547 break;
16548 case DT_MIPS_SYMTABNO:
16549 symtabno = entry->d_un.d_val;
16550 break;
16551 case DT_MIPS_PLTGOT:
16552 mips_pltgot = entry->d_un.d_ptr;
16553 break;
16554 case DT_PLTREL:
16555 pltrel = entry->d_un.d_val;
16556 break;
16557 case DT_PLTRELSZ:
16558 pltrelsz = entry->d_un.d_val;
16559 break;
16560 case DT_JMPREL:
16561 jmprel = entry->d_un.d_ptr;
16562 break;
16563 default:
16564 break;
16565 }
16566
16567 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
16568 {
16569 Elf32_External_Lib * elib;
16570 size_t cnt;
16571
16572 elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
16573 liblistno,
16574 sizeof (Elf32_External_Lib),
16575 _("liblist section data"));
16576 if (elib)
16577 {
16578 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16579 "\nSection '.liblist' contains %lu entries:\n",
16580 (unsigned long) liblistno),
16581 (unsigned long) liblistno);
16582 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16583 stdout);
16584
16585 for (cnt = 0; cnt < liblistno; ++cnt)
16586 {
16587 Elf32_Lib liblist;
16588 time_t atime;
16589 char timebuf[128];
16590 struct tm * tmp;
16591
16592 liblist.l_name = BYTE_GET (elib[cnt].l_name);
16593 atime = BYTE_GET (elib[cnt].l_time_stamp);
16594 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16595 liblist.l_version = BYTE_GET (elib[cnt].l_version);
16596 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16597
16598 tmp = gmtime (&atime);
16599 snprintf (timebuf, sizeof (timebuf),
16600 "%04u-%02u-%02uT%02u:%02u:%02u",
16601 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16602 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16603
16604 printf ("%3lu: ", (unsigned long) cnt);
16605 if (VALID_DYNAMIC_NAME (liblist.l_name))
16606 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
16607 else
16608 printf (_("<corrupt: %9ld>"), liblist.l_name);
16609 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
16610 liblist.l_version);
16611
16612 if (liblist.l_flags == 0)
16613 puts (_(" NONE"));
16614 else
16615 {
16616 static const struct
16617 {
16618 const char * name;
16619 int bit;
16620 }
16621 l_flags_vals[] =
16622 {
16623 { " EXACT_MATCH", LL_EXACT_MATCH },
16624 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
16625 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
16626 { " EXPORTS", LL_EXPORTS },
16627 { " DELAY_LOAD", LL_DELAY_LOAD },
16628 { " DELTA", LL_DELTA }
16629 };
16630 int flags = liblist.l_flags;
16631 size_t fcnt;
16632
16633 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
16634 if ((flags & l_flags_vals[fcnt].bit) != 0)
16635 {
16636 fputs (l_flags_vals[fcnt].name, stdout);
16637 flags ^= l_flags_vals[fcnt].bit;
16638 }
16639 if (flags != 0)
16640 printf (" %#x", (unsigned int) flags);
16641
16642 puts ("");
16643 }
16644 }
16645
16646 free (elib);
16647 }
16648 else
16649 res = FALSE;
16650 }
16651
16652 if (options_offset != 0)
16653 {
16654 Elf_External_Options * eopt;
16655 size_t offset;
16656 int cnt;
16657 sect = filedata->section_headers;
16658
16659 /* Find the section header so that we get the size. */
16660 sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
16661 /* PR 17533 file: 012-277276-0.004. */
16662 if (sect == NULL)
16663 {
16664 error (_("No MIPS_OPTIONS header found\n"));
16665 return FALSE;
16666 }
16667 /* PR 24243 */
16668 if (sect->sh_size < sizeof (* eopt))
16669 {
16670 error (_("The MIPS options section is too small.\n"));
16671 return FALSE;
16672 }
16673
16674 eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
16675 sect->sh_size, _("options"));
16676 if (eopt)
16677 {
16678 Elf_Internal_Options * iopt;
16679 Elf_Internal_Options * option;
16680 Elf_Internal_Options * iopt_end;
16681
16682 iopt = (Elf_Internal_Options *)
16683 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
16684 if (iopt == NULL)
16685 {
16686 error (_("Out of memory allocating space for MIPS options\n"));
16687 return FALSE;
16688 }
16689
16690 offset = cnt = 0;
16691 option = iopt;
16692 iopt_end = iopt + (sect->sh_size / sizeof (eopt));
16693
16694 while (offset <= sect->sh_size - sizeof (* eopt))
16695 {
16696 Elf_External_Options * eoption;
16697
16698 eoption = (Elf_External_Options *) ((char *) eopt + offset);
16699
16700 option->kind = BYTE_GET (eoption->kind);
16701 option->size = BYTE_GET (eoption->size);
16702 option->section = BYTE_GET (eoption->section);
16703 option->info = BYTE_GET (eoption->info);
16704
16705 /* PR 17531: file: ffa0fa3b. */
16706 if (option->size < sizeof (* eopt)
16707 || offset + option->size > sect->sh_size)
16708 {
16709 error (_("Invalid size (%u) for MIPS option\n"), option->size);
16710 return FALSE;
16711 }
16712 offset += option->size;
16713
16714 ++option;
16715 ++cnt;
16716 }
16717
16718 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16719 "\nSection '%s' contains %d entries:\n",
16720 cnt),
16721 printable_section_name (filedata, sect), cnt);
16722
16723 option = iopt;
16724 offset = 0;
16725
16726 while (cnt-- > 0)
16727 {
16728 size_t len;
16729
16730 switch (option->kind)
16731 {
16732 case ODK_NULL:
16733 /* This shouldn't happen. */
16734 printf (" NULL %d %lx", option->section, option->info);
16735 break;
16736
16737 case ODK_REGINFO:
16738 printf (" REGINFO ");
16739 if (filedata->file_header.e_machine == EM_MIPS)
16740 {
16741 Elf32_External_RegInfo * ereg;
16742 Elf32_RegInfo reginfo;
16743
16744 /* 32bit form. */
16745 if (option + 2 > iopt_end)
16746 {
16747 printf (_("<corrupt>\n"));
16748 error (_("Truncated MIPS REGINFO option\n"));
16749 cnt = 0;
16750 break;
16751 }
16752
16753 ereg = (Elf32_External_RegInfo *) (option + 1);
16754
16755 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
16756 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16757 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16758 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16759 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16760 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
16761
16762 printf ("GPR %08lx GP 0x%lx\n",
16763 reginfo.ri_gprmask,
16764 (unsigned long) reginfo.ri_gp_value);
16765 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16766 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16767 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16768 }
16769 else
16770 {
16771 /* 64 bit form. */
16772 Elf64_External_RegInfo * ereg;
16773 Elf64_Internal_RegInfo reginfo;
16774
16775 if (option + 2 > iopt_end)
16776 {
16777 printf (_("<corrupt>\n"));
16778 error (_("Truncated MIPS REGINFO option\n"));
16779 cnt = 0;
16780 break;
16781 }
16782
16783 ereg = (Elf64_External_RegInfo *) (option + 1);
16784 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
16785 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16786 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16787 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16788 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16789 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
16790
16791 printf ("GPR %08lx GP 0x",
16792 reginfo.ri_gprmask);
16793 printf_vma (reginfo.ri_gp_value);
16794 printf ("\n");
16795
16796 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16797 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16798 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16799 }
16800 ++option;
16801 continue;
16802
16803 case ODK_EXCEPTIONS:
16804 fputs (" EXCEPTIONS fpe_min(", stdout);
16805 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
16806 fputs (") fpe_max(", stdout);
16807 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
16808 fputs (")", stdout);
16809
16810 if (option->info & OEX_PAGE0)
16811 fputs (" PAGE0", stdout);
16812 if (option->info & OEX_SMM)
16813 fputs (" SMM", stdout);
16814 if (option->info & OEX_FPDBUG)
16815 fputs (" FPDBUG", stdout);
16816 if (option->info & OEX_DISMISS)
16817 fputs (" DISMISS", stdout);
16818 break;
16819
16820 case ODK_PAD:
16821 fputs (" PAD ", stdout);
16822 if (option->info & OPAD_PREFIX)
16823 fputs (" PREFIX", stdout);
16824 if (option->info & OPAD_POSTFIX)
16825 fputs (" POSTFIX", stdout);
16826 if (option->info & OPAD_SYMBOL)
16827 fputs (" SYMBOL", stdout);
16828 break;
16829
16830 case ODK_HWPATCH:
16831 fputs (" HWPATCH ", stdout);
16832 if (option->info & OHW_R4KEOP)
16833 fputs (" R4KEOP", stdout);
16834 if (option->info & OHW_R8KPFETCH)
16835 fputs (" R8KPFETCH", stdout);
16836 if (option->info & OHW_R5KEOP)
16837 fputs (" R5KEOP", stdout);
16838 if (option->info & OHW_R5KCVTL)
16839 fputs (" R5KCVTL", stdout);
16840 break;
16841
16842 case ODK_FILL:
16843 fputs (" FILL ", stdout);
16844 /* XXX Print content of info word? */
16845 break;
16846
16847 case ODK_TAGS:
16848 fputs (" TAGS ", stdout);
16849 /* XXX Print content of info word? */
16850 break;
16851
16852 case ODK_HWAND:
16853 fputs (" HWAND ", stdout);
16854 if (option->info & OHWA0_R4KEOP_CHECKED)
16855 fputs (" R4KEOP_CHECKED", stdout);
16856 if (option->info & OHWA0_R4KEOP_CLEAN)
16857 fputs (" R4KEOP_CLEAN", stdout);
16858 break;
16859
16860 case ODK_HWOR:
16861 fputs (" HWOR ", stdout);
16862 if (option->info & OHWA0_R4KEOP_CHECKED)
16863 fputs (" R4KEOP_CHECKED", stdout);
16864 if (option->info & OHWA0_R4KEOP_CLEAN)
16865 fputs (" R4KEOP_CLEAN", stdout);
16866 break;
16867
16868 case ODK_GP_GROUP:
16869 printf (" GP_GROUP %#06lx self-contained %#06lx",
16870 option->info & OGP_GROUP,
16871 (option->info & OGP_SELF) >> 16);
16872 break;
16873
16874 case ODK_IDENT:
16875 printf (" IDENT %#06lx self-contained %#06lx",
16876 option->info & OGP_GROUP,
16877 (option->info & OGP_SELF) >> 16);
16878 break;
16879
16880 default:
16881 /* This shouldn't happen. */
16882 printf (" %3d ??? %d %lx",
16883 option->kind, option->section, option->info);
16884 break;
16885 }
16886
16887 len = sizeof (* eopt);
16888 while (len < option->size)
16889 {
16890 unsigned char datum = * ((unsigned char *) eopt + offset + len);
16891
16892 if (ISPRINT (datum))
16893 printf ("%c", datum);
16894 else
16895 printf ("\\%03o", datum);
16896 len ++;
16897 }
16898 fputs ("\n", stdout);
16899
16900 offset += option->size;
16901 ++option;
16902 }
16903
16904 free (eopt);
16905 }
16906 else
16907 res = FALSE;
16908 }
16909
16910 if (conflicts_offset != 0 && conflictsno != 0)
16911 {
16912 Elf32_Conflict * iconf;
16913 size_t cnt;
16914
16915 if (dynamic_symbols == NULL)
16916 {
16917 error (_("conflict list found without a dynamic symbol table\n"));
16918 return FALSE;
16919 }
16920
16921 /* PR 21345 - print a slightly more helpful error message
16922 if we are sure that the cmalloc will fail. */
16923 if (conflictsno * sizeof (* iconf) > filedata->file_size)
16924 {
16925 error (_("Overlarge number of conflicts detected: %lx\n"),
16926 (long) conflictsno);
16927 return FALSE;
16928 }
16929
16930 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
16931 if (iconf == NULL)
16932 {
16933 error (_("Out of memory allocating space for dynamic conflicts\n"));
16934 return FALSE;
16935 }
16936
16937 if (is_32bit_elf)
16938 {
16939 Elf32_External_Conflict * econf32;
16940
16941 econf32 = (Elf32_External_Conflict *)
16942 get_data (NULL, filedata, conflicts_offset, conflictsno,
16943 sizeof (* econf32), _("conflict"));
16944 if (!econf32)
16945 return FALSE;
16946
16947 for (cnt = 0; cnt < conflictsno; ++cnt)
16948 iconf[cnt] = BYTE_GET (econf32[cnt]);
16949
16950 free (econf32);
16951 }
16952 else
16953 {
16954 Elf64_External_Conflict * econf64;
16955
16956 econf64 = (Elf64_External_Conflict *)
16957 get_data (NULL, filedata, conflicts_offset, conflictsno,
16958 sizeof (* econf64), _("conflict"));
16959 if (!econf64)
16960 return FALSE;
16961
16962 for (cnt = 0; cnt < conflictsno; ++cnt)
16963 iconf[cnt] = BYTE_GET (econf64[cnt]);
16964
16965 free (econf64);
16966 }
16967
16968 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16969 "\nSection '.conflict' contains %lu entries:\n",
16970 (unsigned long) conflictsno),
16971 (unsigned long) conflictsno);
16972 puts (_(" Num: Index Value Name"));
16973
16974 for (cnt = 0; cnt < conflictsno; ++cnt)
16975 {
16976 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
16977
16978 if (iconf[cnt] >= num_dynamic_syms)
16979 printf (_("<corrupt symbol index>"));
16980 else
16981 {
16982 Elf_Internal_Sym * psym;
16983
16984 psym = & dynamic_symbols[iconf[cnt]];
16985 print_vma (psym->st_value, FULL_HEX);
16986 putchar (' ');
16987 if (VALID_DYNAMIC_NAME (psym->st_name))
16988 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
16989 else
16990 printf (_("<corrupt: %14ld>"), psym->st_name);
16991 }
16992 putchar ('\n');
16993 }
16994
16995 free (iconf);
16996 }
16997
16998 if (pltgot != 0 && local_gotno != 0)
16999 {
17000 bfd_vma ent, local_end, global_end;
17001 size_t i, offset;
17002 unsigned char * data;
17003 unsigned char * data_end;
17004 int addr_size;
17005
17006 ent = pltgot;
17007 addr_size = (is_32bit_elf ? 4 : 8);
17008 local_end = pltgot + local_gotno * addr_size;
17009
17010 /* PR binutils/17533 file: 012-111227-0.004 */
17011 if (symtabno < gotsym)
17012 {
17013 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
17014 (unsigned long) gotsym, (unsigned long) symtabno);
17015 return FALSE;
17016 }
17017
17018 global_end = local_end + (symtabno - gotsym) * addr_size;
17019 /* PR 17531: file: 54c91a34. */
17020 if (global_end < local_end)
17021 {
17022 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
17023 return FALSE;
17024 }
17025
17026 offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
17027 data = (unsigned char *) get_data (NULL, filedata, offset,
17028 global_end - pltgot, 1,
17029 _("Global Offset Table data"));
17030 /* PR 12855: Null data is handled gracefully throughout. */
17031 data_end = data + (global_end - pltgot);
17032
17033 printf (_("\nPrimary GOT:\n"));
17034 printf (_(" Canonical gp value: "));
17035 print_vma (pltgot + 0x7ff0, LONG_HEX);
17036 printf ("\n\n");
17037
17038 printf (_(" Reserved entries:\n"));
17039 printf (_(" %*s %10s %*s Purpose\n"),
17040 addr_size * 2, _("Address"), _("Access"),
17041 addr_size * 2, _("Initial"));
17042 ent = print_mips_got_entry (data, pltgot, ent, data_end);
17043 printf (_(" Lazy resolver\n"));
17044 if (ent == (bfd_vma) -1)
17045 goto got_print_fail;
17046
17047 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
17048 This entry will be used by some runtime loaders, to store the
17049 module pointer. Otherwise this is an ordinary local entry.
17050 PR 21344: Check for the entry being fully available before
17051 fetching it. */
17052 if (data
17053 && data + ent - pltgot + addr_size <= data_end
17054 && (byte_get (data + ent - pltgot, addr_size)
17055 >> (addr_size * 8 - 1)) != 0)
17056 {
17057 ent = print_mips_got_entry (data, pltgot, ent, data_end);
17058 printf (_(" Module pointer (GNU extension)\n"));
17059 if (ent == (bfd_vma) -1)
17060 goto got_print_fail;
17061 }
17062 printf ("\n");
17063
17064 if (data != NULL && ent < local_end)
17065 {
17066 printf (_(" Local entries:\n"));
17067 printf (" %*s %10s %*s\n",
17068 addr_size * 2, _("Address"), _("Access"),
17069 addr_size * 2, _("Initial"));
17070 while (ent < local_end)
17071 {
17072 ent = print_mips_got_entry (data, pltgot, ent, data_end);
17073 printf ("\n");
17074 if (ent == (bfd_vma) -1)
17075 goto got_print_fail;
17076 }
17077 printf ("\n");
17078 }
17079
17080 if (data != NULL && gotsym < symtabno)
17081 {
17082 int sym_width;
17083
17084 printf (_(" Global entries:\n"));
17085 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
17086 addr_size * 2, _("Address"),
17087 _("Access"),
17088 addr_size * 2, _("Initial"),
17089 addr_size * 2, _("Sym.Val."),
17090 _("Type"),
17091 /* Note for translators: "Ndx" = abbreviated form of "Index". */
17092 _("Ndx"), _("Name"));
17093
17094 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
17095
17096 for (i = gotsym; i < symtabno; i++)
17097 {
17098 ent = print_mips_got_entry (data, pltgot, ent, data_end);
17099 printf (" ");
17100
17101 if (dynamic_symbols == NULL)
17102 printf (_("<no dynamic symbols>"));
17103 else if (i < num_dynamic_syms)
17104 {
17105 Elf_Internal_Sym * psym = dynamic_symbols + i;
17106
17107 print_vma (psym->st_value, LONG_HEX);
17108 printf (" %-7s %3s ",
17109 get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
17110 get_symbol_index_type (filedata, psym->st_shndx));
17111
17112 if (VALID_DYNAMIC_NAME (psym->st_name))
17113 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
17114 else
17115 printf (_("<corrupt: %14ld>"), psym->st_name);
17116 }
17117 else
17118 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
17119 (unsigned long) i);
17120
17121 printf ("\n");
17122 if (ent == (bfd_vma) -1)
17123 break;
17124 }
17125 printf ("\n");
17126 }
17127
17128 got_print_fail:
17129 if (data)
17130 free (data);
17131 }
17132
17133 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
17134 {
17135 bfd_vma ent, end;
17136 size_t offset, rel_offset;
17137 unsigned long count, i;
17138 unsigned char * data;
17139 int addr_size, sym_width;
17140 Elf_Internal_Rela * rels;
17141
17142 rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
17143 if (pltrel == DT_RELA)
17144 {
17145 if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
17146 return FALSE;
17147 }
17148 else
17149 {
17150 if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
17151 return FALSE;
17152 }
17153
17154 ent = mips_pltgot;
17155 addr_size = (is_32bit_elf ? 4 : 8);
17156 end = mips_pltgot + (2 + count) * addr_size;
17157
17158 offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
17159 data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
17160 1, _("Procedure Linkage Table data"));
17161 if (data == NULL)
17162 return FALSE;
17163
17164 printf ("\nPLT GOT:\n\n");
17165 printf (_(" Reserved entries:\n"));
17166 printf (_(" %*s %*s Purpose\n"),
17167 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
17168 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
17169 printf (_(" PLT lazy resolver\n"));
17170 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
17171 printf (_(" Module pointer\n"));
17172 printf ("\n");
17173
17174 printf (_(" Entries:\n"));
17175 printf (" %*s %*s %*s %-7s %3s %s\n",
17176 addr_size * 2, _("Address"),
17177 addr_size * 2, _("Initial"),
17178 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17179 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
17180 for (i = 0; i < count; i++)
17181 {
17182 unsigned long idx = get_reloc_symindex (rels[i].r_info);
17183
17184 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
17185 printf (" ");
17186
17187 if (idx >= num_dynamic_syms)
17188 printf (_("<corrupt symbol index: %lu>"), idx);
17189 else
17190 {
17191 Elf_Internal_Sym * psym = dynamic_symbols + idx;
17192
17193 print_vma (psym->st_value, LONG_HEX);
17194 printf (" %-7s %3s ",
17195 get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
17196 get_symbol_index_type (filedata, psym->st_shndx));
17197 if (VALID_DYNAMIC_NAME (psym->st_name))
17198 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
17199 else
17200 printf (_("<corrupt: %14ld>"), psym->st_name);
17201 }
17202 printf ("\n");
17203 }
17204 printf ("\n");
17205
17206 if (data)
17207 free (data);
17208 free (rels);
17209 }
17210
17211 return res;
17212}
17213
17214static bfd_boolean
17215process_nds32_specific (Filedata * filedata)
17216{
17217 Elf_Internal_Shdr *sect = NULL;
17218
17219 sect = find_section (filedata, ".nds32_e_flags");
17220 if (sect != NULL)
17221 {
17222 unsigned int *flag;
17223
17224 printf ("\nNDS32 elf flags section:\n");
17225 flag = get_data (NULL, filedata, sect->sh_offset, 1,
17226 sect->sh_size, _("NDS32 elf flags section"));
17227
17228 if (! flag)
17229 return FALSE;
17230
17231 switch ((*flag) & 0x3)
17232 {
17233 case 0:
17234 printf ("(VEC_SIZE):\tNo entry.\n");
17235 break;
17236 case 1:
17237 printf ("(VEC_SIZE):\t4 bytes\n");
17238 break;
17239 case 2:
17240 printf ("(VEC_SIZE):\t16 bytes\n");
17241 break;
17242 case 3:
17243 printf ("(VEC_SIZE):\treserved\n");
17244 break;
17245 }
17246 }
17247
17248 return TRUE;
17249}
17250
17251static bfd_boolean
17252process_gnu_liblist (Filedata * filedata)
17253{
17254 Elf_Internal_Shdr * section;
17255 Elf_Internal_Shdr * string_sec;
17256 Elf32_External_Lib * elib;
17257 char * strtab;
17258 size_t strtab_size;
17259 size_t cnt;
17260 unsigned long num_liblist;
17261 unsigned i;
17262 bfd_boolean res = TRUE;
17263
17264 if (! do_arch)
17265 return TRUE;
17266
17267 for (i = 0, section = filedata->section_headers;
17268 i < filedata->file_header.e_shnum;
17269 i++, section++)
17270 {
17271 switch (section->sh_type)
17272 {
17273 case SHT_GNU_LIBLIST:
17274 if (section->sh_link >= filedata->file_header.e_shnum)
17275 break;
17276
17277 elib = (Elf32_External_Lib *)
17278 get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
17279 _("liblist section data"));
17280
17281 if (elib == NULL)
17282 {
17283 res = FALSE;
17284 break;
17285 }
17286
17287 string_sec = filedata->section_headers + section->sh_link;
17288 strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
17289 string_sec->sh_size,
17290 _("liblist string table"));
17291 if (strtab == NULL
17292 || section->sh_entsize != sizeof (Elf32_External_Lib))
17293 {
17294 free (elib);
17295 free (strtab);
17296 res = FALSE;
17297 break;
17298 }
17299 strtab_size = string_sec->sh_size;
17300
17301 num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
17302 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17303 "\nLibrary list section '%s' contains %lu entries:\n",
17304 num_liblist),
17305 printable_section_name (filedata, section),
17306 num_liblist);
17307
17308 puts (_(" Library Time Stamp Checksum Version Flags"));
17309
17310 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
17311 ++cnt)
17312 {
17313 Elf32_Lib liblist;
17314 time_t atime;
17315 char timebuf[128];
17316 struct tm * tmp;
17317
17318 liblist.l_name = BYTE_GET (elib[cnt].l_name);
17319 atime = BYTE_GET (elib[cnt].l_time_stamp);
17320 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
17321 liblist.l_version = BYTE_GET (elib[cnt].l_version);
17322 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
17323
17324 tmp = gmtime (&atime);
17325 snprintf (timebuf, sizeof (timebuf),
17326 "%04u-%02u-%02uT%02u:%02u:%02u",
17327 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
17328 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
17329
17330 printf ("%3lu: ", (unsigned long) cnt);
17331 if (do_wide)
17332 printf ("%-20s", liblist.l_name < strtab_size
17333 ? strtab + liblist.l_name : _("<corrupt>"));
17334 else
17335 printf ("%-20.20s", liblist.l_name < strtab_size
17336 ? strtab + liblist.l_name : _("<corrupt>"));
17337 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
17338 liblist.l_version, liblist.l_flags);
17339 }
17340
17341 free (elib);
17342 free (strtab);
17343 }
17344 }
17345
17346 return res;
17347}
17348
17349static const char *
17350get_note_type (Filedata * filedata, unsigned e_type)
17351{
17352 static char buff[64];
17353
17354 if (filedata->file_header.e_type == ET_CORE)
17355 switch (e_type)
17356 {
17357 case NT_AUXV:
17358 return _("NT_AUXV (auxiliary vector)");
17359 case NT_PRSTATUS:
17360 return _("NT_PRSTATUS (prstatus structure)");
17361 case NT_FPREGSET:
17362 return _("NT_FPREGSET (floating point registers)");
17363 case NT_PRPSINFO:
17364 return _("NT_PRPSINFO (prpsinfo structure)");
17365 case NT_TASKSTRUCT:
17366 return _("NT_TASKSTRUCT (task structure)");
17367 case NT_PRXFPREG:
17368 return _("NT_PRXFPREG (user_xfpregs structure)");
17369 case NT_PPC_VMX:
17370 return _("NT_PPC_VMX (ppc Altivec registers)");
17371 case NT_PPC_VSX:
17372 return _("NT_PPC_VSX (ppc VSX registers)");
17373 case NT_PPC_TAR:
17374 return _("NT_PPC_TAR (ppc TAR register)");
17375 case NT_PPC_PPR:
17376 return _("NT_PPC_PPR (ppc PPR register)");
17377 case NT_PPC_DSCR:
17378 return _("NT_PPC_DSCR (ppc DSCR register)");
17379 case NT_PPC_EBB:
17380 return _("NT_PPC_EBB (ppc EBB registers)");
17381 case NT_PPC_PMU:
17382 return _("NT_PPC_PMU (ppc PMU registers)");
17383 case NT_PPC_TM_CGPR:
17384 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17385 case NT_PPC_TM_CFPR:
17386 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17387 case NT_PPC_TM_CVMX:
17388 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17389 case NT_PPC_TM_CVSX:
17390 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17391 case NT_PPC_TM_SPR:
17392 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17393 case NT_PPC_TM_CTAR:
17394 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17395 case NT_PPC_TM_CPPR:
17396 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17397 case NT_PPC_TM_CDSCR:
17398 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17399 case NT_386_TLS:
17400 return _("NT_386_TLS (x86 TLS information)");
17401 case NT_386_IOPERM:
17402 return _("NT_386_IOPERM (x86 I/O permissions)");
17403 case NT_X86_XSTATE:
17404 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17405 case NT_S390_HIGH_GPRS:
17406 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17407 case NT_S390_TIMER:
17408 return _("NT_S390_TIMER (s390 timer register)");
17409 case NT_S390_TODCMP:
17410 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17411 case NT_S390_TODPREG:
17412 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17413 case NT_S390_CTRS:
17414 return _("NT_S390_CTRS (s390 control registers)");
17415 case NT_S390_PREFIX:
17416 return _("NT_S390_PREFIX (s390 prefix register)");
17417 case NT_S390_LAST_BREAK:
17418 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17419 case NT_S390_SYSTEM_CALL:
17420 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17421 case NT_S390_TDB:
17422 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17423 case NT_S390_VXRS_LOW:
17424 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17425 case NT_S390_VXRS_HIGH:
17426 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17427 case NT_S390_GS_CB:
17428 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17429 case NT_S390_GS_BC:
17430 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17431 case NT_ARM_VFP:
17432 return _("NT_ARM_VFP (arm VFP registers)");
17433 case NT_ARM_TLS:
17434 return _("NT_ARM_TLS (AArch TLS registers)");
17435 case NT_ARM_HW_BREAK:
17436 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17437 case NT_ARM_HW_WATCH:
17438 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17439 case NT_PSTATUS:
17440 return _("NT_PSTATUS (pstatus structure)");
17441 case NT_FPREGS:
17442 return _("NT_FPREGS (floating point registers)");
17443 case NT_PSINFO:
17444 return _("NT_PSINFO (psinfo structure)");
17445 case NT_LWPSTATUS:
17446 return _("NT_LWPSTATUS (lwpstatus_t structure)");
17447 case NT_LWPSINFO:
17448 return _("NT_LWPSINFO (lwpsinfo_t structure)");
17449 case NT_WIN32PSTATUS:
17450 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17451 case NT_SIGINFO:
17452 return _("NT_SIGINFO (siginfo_t data)");
17453 case NT_FILE:
17454 return _("NT_FILE (mapped files)");
17455 default:
17456 break;
17457 }
17458 else
17459 switch (e_type)
17460 {
17461 case NT_VERSION:
17462 return _("NT_VERSION (version)");
17463 case NT_ARCH:
17464 return _("NT_ARCH (architecture)");
17465 case NT_GNU_BUILD_ATTRIBUTE_OPEN:
17466 return _("OPEN");
17467 case NT_GNU_BUILD_ATTRIBUTE_FUNC:
17468 return _("func");
17469 default:
17470 break;
17471 }
17472
17473 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17474 return buff;
17475}
17476
17477static bfd_boolean
17478print_core_note (Elf_Internal_Note *pnote)
17479{
17480 unsigned int addr_size = is_32bit_elf ? 4 : 8;
17481 bfd_vma count, page_size;
17482 unsigned char *descdata, *filenames, *descend;
17483
17484 if (pnote->type != NT_FILE)
17485 {
17486 if (do_wide)
17487 printf ("\n");
17488 return TRUE;
17489 }
17490
17491#ifndef BFD64
17492 if (!is_32bit_elf)
17493 {
17494 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
17495 /* Still "successful". */
17496 return TRUE;
17497 }
17498#endif
17499
17500 if (pnote->descsz < 2 * addr_size)
17501 {
17502 error (_(" Malformed note - too short for header\n"));
17503 return FALSE;
17504 }
17505
17506 descdata = (unsigned char *) pnote->descdata;
17507 descend = descdata + pnote->descsz;
17508
17509 if (descdata[pnote->descsz - 1] != '\0')
17510 {
17511 error (_(" Malformed note - does not end with \\0\n"));
17512 return FALSE;
17513 }
17514
17515 count = byte_get (descdata, addr_size);
17516 descdata += addr_size;
17517
17518 page_size = byte_get (descdata, addr_size);
17519 descdata += addr_size;
17520
17521 if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
17522 || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
17523 {
17524 error (_(" Malformed note - too short for supplied file count\n"));
17525 return FALSE;
17526 }
17527
17528 printf (_(" Page size: "));
17529 print_vma (page_size, DEC);
17530 printf ("\n");
17531
17532 printf (_(" %*s%*s%*s\n"),
17533 (int) (2 + 2 * addr_size), _("Start"),
17534 (int) (4 + 2 * addr_size), _("End"),
17535 (int) (4 + 2 * addr_size), _("Page Offset"));
17536 filenames = descdata + count * 3 * addr_size;
17537 while (count-- > 0)
17538 {
17539 bfd_vma start, end, file_ofs;
17540
17541 if (filenames == descend)
17542 {
17543 error (_(" Malformed note - filenames end too early\n"));
17544 return FALSE;
17545 }
17546
17547 start = byte_get (descdata, addr_size);
17548 descdata += addr_size;
17549 end = byte_get (descdata, addr_size);
17550 descdata += addr_size;
17551 file_ofs = byte_get (descdata, addr_size);
17552 descdata += addr_size;
17553
17554 printf (" ");
17555 print_vma (start, FULL_HEX);
17556 printf (" ");
17557 print_vma (end, FULL_HEX);
17558 printf (" ");
17559 print_vma (file_ofs, FULL_HEX);
17560 printf ("\n %s\n", filenames);
17561
17562 filenames += 1 + strlen ((char *) filenames);
17563 }
17564
17565 return TRUE;
17566}
17567
17568static const char *
17569get_gnu_elf_note_type (unsigned e_type)
17570{
17571 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17572 switch (e_type)
17573 {
17574 case NT_GNU_ABI_TAG:
17575 return _("NT_GNU_ABI_TAG (ABI version tag)");
17576 case NT_GNU_HWCAP:
17577 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17578 case NT_GNU_BUILD_ID:
17579 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17580 case NT_GNU_GOLD_VERSION:
17581 return _("NT_GNU_GOLD_VERSION (gold version)");
17582 case NT_GNU_PROPERTY_TYPE_0:
17583 return _("NT_GNU_PROPERTY_TYPE_0");
17584 case NT_GNU_BUILD_ATTRIBUTE_OPEN:
17585 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17586 case NT_GNU_BUILD_ATTRIBUTE_FUNC:
17587 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17588 default:
17589 {
17590 static char buff[64];
17591
17592 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17593 return buff;
17594 }
17595 }
17596}
17597
17598static void
17599decode_x86_compat_isa (unsigned int bitmask)
17600{
17601 while (bitmask)
17602 {
17603 unsigned int bit = bitmask & (- bitmask);
17604
17605 bitmask &= ~ bit;
17606 switch (bit)
17607 {
17608 case GNU_PROPERTY_X86_COMPAT_ISA_1_486:
17609 printf ("i486");
17610 break;
17611 case GNU_PROPERTY_X86_COMPAT_ISA_1_586:
17612 printf ("586");
17613 break;
17614 case GNU_PROPERTY_X86_COMPAT_ISA_1_686:
17615 printf ("686");
17616 break;
17617 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE:
17618 printf ("SSE");
17619 break;
17620 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2:
17621 printf ("SSE2");
17622 break;
17623 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3:
17624 printf ("SSE3");
17625 break;
17626 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3:
17627 printf ("SSSE3");
17628 break;
17629 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1:
17630 printf ("SSE4_1");
17631 break;
17632 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2:
17633 printf ("SSE4_2");
17634 break;
17635 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX:
17636 printf ("AVX");
17637 break;
17638 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2:
17639 printf ("AVX2");
17640 break;
17641 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F:
17642 printf ("AVX512F");
17643 break;
17644 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD:
17645 printf ("AVX512CD");
17646 break;
17647 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER:
17648 printf ("AVX512ER");
17649 break;
17650 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF:
17651 printf ("AVX512PF");
17652 break;
17653 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL:
17654 printf ("AVX512VL");
17655 break;
17656 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ:
17657 printf ("AVX512DQ");
17658 break;
17659 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW:
17660 printf ("AVX512BW");
17661 break;
17662 default:
17663 printf (_("<unknown: %x>"), bit);
17664 break;
17665 }
17666 if (bitmask)
17667 printf (", ");
17668 }
17669}
17670
17671static void
17672decode_x86_isa (unsigned int bitmask)
17673{
17674 if (!bitmask)
17675 {
17676 printf (_("<None>"));
17677 return;
17678 }
17679
17680 while (bitmask)
17681 {
17682 unsigned int bit = bitmask & (- bitmask);
17683
17684 bitmask &= ~ bit;
17685 switch (bit)
17686 {
17687 case GNU_PROPERTY_X86_ISA_1_CMOV:
17688 printf ("CMOV");
17689 break;
17690 case GNU_PROPERTY_X86_ISA_1_SSE:
17691 printf ("SSE");
17692 break;
17693 case GNU_PROPERTY_X86_ISA_1_SSE2:
17694 printf ("SSE2");
17695 break;
17696 case GNU_PROPERTY_X86_ISA_1_SSE3:
17697 printf ("SSE3");
17698 break;
17699 case GNU_PROPERTY_X86_ISA_1_SSSE3:
17700 printf ("SSSE3");
17701 break;
17702 case GNU_PROPERTY_X86_ISA_1_SSE4_1:
17703 printf ("SSE4_1");
17704 break;
17705 case GNU_PROPERTY_X86_ISA_1_SSE4_2:
17706 printf ("SSE4_2");
17707 break;
17708 case GNU_PROPERTY_X86_ISA_1_AVX:
17709 printf ("AVX");
17710 break;
17711 case GNU_PROPERTY_X86_ISA_1_AVX2:
17712 printf ("AVX2");
17713 break;
17714 case GNU_PROPERTY_X86_ISA_1_FMA:
17715 printf ("FMA");
17716 break;
17717 case GNU_PROPERTY_X86_ISA_1_AVX512F:
17718 printf ("AVX512F");
17719 break;
17720 case GNU_PROPERTY_X86_ISA_1_AVX512CD:
17721 printf ("AVX512CD");
17722 break;
17723 case GNU_PROPERTY_X86_ISA_1_AVX512ER:
17724 printf ("AVX512ER");
17725 break;
17726 case GNU_PROPERTY_X86_ISA_1_AVX512PF:
17727 printf ("AVX512PF");
17728 break;
17729 case GNU_PROPERTY_X86_ISA_1_AVX512VL:
17730 printf ("AVX512VL");
17731 break;
17732 case GNU_PROPERTY_X86_ISA_1_AVX512DQ:
17733 printf ("AVX512DQ");
17734 break;
17735 case GNU_PROPERTY_X86_ISA_1_AVX512BW:
17736 printf ("AVX512BW");
17737 break;
17738 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS:
17739 printf ("AVX512_4FMAPS");
17740 break;
17741 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW:
17742 printf ("AVX512_4VNNIW");
17743 break;
17744 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG:
17745 printf ("AVX512_BITALG");
17746 break;
17747 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA:
17748 printf ("AVX512_IFMA");
17749 break;
17750 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI:
17751 printf ("AVX512_VBMI");
17752 break;
17753 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2:
17754 printf ("AVX512_VBMI2");
17755 break;
17756 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI:
17757 printf ("AVX512_VNNI");
17758 break;
17759 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16:
17760 printf ("AVX512_BF16");
17761 break;
17762 default:
17763 printf (_("<unknown: %x>"), bit);
17764 break;
17765 }
17766 if (bitmask)
17767 printf (", ");
17768 }
17769}
17770
17771static void
17772decode_x86_feature_1 (unsigned int bitmask)
17773{
17774 if (!bitmask)
17775 {
17776 printf (_("<None>"));
17777 return;
17778 }
17779
17780 while (bitmask)
17781 {
17782 unsigned int bit = bitmask & (- bitmask);
17783
17784 bitmask &= ~ bit;
17785 switch (bit)
17786 {
17787 case GNU_PROPERTY_X86_FEATURE_1_IBT:
17788 printf ("IBT");
17789 break;
17790 case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
17791 printf ("SHSTK");
17792 break;
17793 default:
17794 printf (_("<unknown: %x>"), bit);
17795 break;
17796 }
17797 if (bitmask)
17798 printf (", ");
17799 }
17800}
17801
17802static void
17803decode_x86_feature_2 (unsigned int bitmask)
17804{
17805 if (!bitmask)
17806 {
17807 printf (_("<None>"));
17808 return;
17809 }
17810
17811 while (bitmask)
17812 {
17813 unsigned int bit = bitmask & (- bitmask);
17814
17815 bitmask &= ~ bit;
17816 switch (bit)
17817 {
17818 case GNU_PROPERTY_X86_FEATURE_2_X86:
17819 printf ("x86");
17820 break;
17821 case GNU_PROPERTY_X86_FEATURE_2_X87:
17822 printf ("x87");
17823 break;
17824 case GNU_PROPERTY_X86_FEATURE_2_MMX:
17825 printf ("MMX");
17826 break;
17827 case GNU_PROPERTY_X86_FEATURE_2_XMM:
17828 printf ("XMM");
17829 break;
17830 case GNU_PROPERTY_X86_FEATURE_2_YMM:
17831 printf ("YMM");
17832 break;
17833 case GNU_PROPERTY_X86_FEATURE_2_ZMM:
17834 printf ("ZMM");
17835 break;
17836 case GNU_PROPERTY_X86_FEATURE_2_FXSR:
17837 printf ("FXSR");
17838 break;
17839 case GNU_PROPERTY_X86_FEATURE_2_XSAVE:
17840 printf ("XSAVE");
17841 break;
17842 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT:
17843 printf ("XSAVEOPT");
17844 break;
17845 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC:
17846 printf ("XSAVEC");
17847 break;
17848 default:
17849 printf (_("<unknown: %x>"), bit);
17850 break;
17851 }
17852 if (bitmask)
17853 printf (", ");
17854 }
17855}
17856
17857static void
17858decode_aarch64_feature_1_and (unsigned int bitmask)
17859{
17860 while (bitmask)
17861 {
17862 unsigned int bit = bitmask & (- bitmask);
17863
17864 bitmask &= ~ bit;
17865 switch (bit)
17866 {
17867 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI:
17868 printf ("BTI");
17869 break;
17870
17871 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC:
17872 printf ("PAC");
17873 break;
17874
17875 default:
17876 printf (_("<unknown: %x>"), bit);
17877 break;
17878 }
17879 if (bitmask)
17880 printf (", ");
17881 }
17882}
17883
17884static void
17885print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
17886{
17887 unsigned char * ptr = (unsigned char *) pnote->descdata;
17888 unsigned char * ptr_end = ptr + pnote->descsz;
17889 unsigned int size = is_32bit_elf ? 4 : 8;
17890
17891 printf (_(" Properties: "));
17892
17893 if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
17894 {
17895 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
17896 return;
17897 }
17898
17899 while (ptr < ptr_end)
17900 {
17901 unsigned int j;
17902 unsigned int type;
17903 unsigned int datasz;
17904
17905 if ((size_t) (ptr_end - ptr) < 8)
17906 {
17907 printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
17908 break;
17909 }
17910
17911 type = byte_get (ptr, 4);
17912 datasz = byte_get (ptr + 4, 4);
17913
17914 ptr += 8;
17915
17916 if (datasz > (size_t) (ptr_end - ptr))
17917 {
17918 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17919 type, datasz);
17920 break;
17921 }
17922
17923 if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
17924 {
17925 if (filedata->file_header.e_machine == EM_X86_64
17926 || filedata->file_header.e_machine == EM_IAMCU
17927 || filedata->file_header.e_machine == EM_386)
17928 {
17929 unsigned int bitmask;
17930
17931 if (datasz == 4)
17932 bitmask = byte_get (ptr, 4);
17933 else
17934 bitmask = 0;
17935
17936 switch (type)
17937 {
17938 case GNU_PROPERTY_X86_ISA_1_USED:
17939 if (datasz != 4)
17940 printf (_("x86 ISA used: <corrupt length: %#x> "),
17941 datasz);
17942 else
17943 {
17944 printf ("x86 ISA used: ");
17945 decode_x86_isa (bitmask);
17946 }
17947 goto next;
17948
17949 case GNU_PROPERTY_X86_ISA_1_NEEDED:
17950 if (datasz != 4)
17951 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17952 datasz);
17953 else
17954 {
17955 printf ("x86 ISA needed: ");
17956 decode_x86_isa (bitmask);
17957 }
17958 goto next;
17959
17960 case GNU_PROPERTY_X86_FEATURE_1_AND:
17961 if (datasz != 4)
17962 printf (_("x86 feature: <corrupt length: %#x> "),
17963 datasz);
17964 else
17965 {
17966 printf ("x86 feature: ");
17967 decode_x86_feature_1 (bitmask);
17968 }
17969 goto next;
17970
17971 case GNU_PROPERTY_X86_FEATURE_2_USED:
17972 if (datasz != 4)
17973 printf (_("x86 feature used: <corrupt length: %#x> "),
17974 datasz);
17975 else
17976 {
17977 printf ("x86 feature used: ");
17978 decode_x86_feature_2 (bitmask);
17979 }
17980 goto next;
17981
17982 case GNU_PROPERTY_X86_FEATURE_2_NEEDED:
17983 if (datasz != 4)
17984 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz);
17985 else
17986 {
17987 printf ("x86 feature needed: ");
17988 decode_x86_feature_2 (bitmask);
17989 }
17990 goto next;
17991
17992 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED:
17993 if (datasz != 4)
17994 printf (_("x86 ISA used: <corrupt length: %#x> "),
17995 datasz);
17996 else
17997 {
17998 printf ("x86 ISA used: ");
17999 decode_x86_compat_isa (bitmask);
18000 }
18001 goto next;
18002
18003 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED:
18004 if (datasz != 4)
18005 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18006 datasz);
18007 else
18008 {
18009 printf ("x86 ISA needed: ");
18010 decode_x86_compat_isa (bitmask);
18011 }
18012 goto next;
18013
18014 default:
18015 break;
18016 }
18017 }
18018 else if (filedata->file_header.e_machine == EM_AARCH64)
18019 {
18020 if (type == GNU_PROPERTY_AARCH64_FEATURE_1_AND)
18021 {
18022 printf ("AArch64 feature: ");
18023 if (datasz != 4)
18024 printf (_("<corrupt length: %#x> "), datasz);
18025 else
18026 decode_aarch64_feature_1_and (byte_get (ptr, 4));
18027 goto next;
18028 }
18029 }
18030 }
18031 else
18032 {
18033 switch (type)
18034 {
18035 case GNU_PROPERTY_STACK_SIZE:
18036 printf (_("stack size: "));
18037 if (datasz != size)
18038 printf (_("<corrupt length: %#x> "), datasz);
18039 else
18040 printf ("%#lx", (unsigned long) byte_get (ptr, size));
18041 goto next;
18042
18043 case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
18044 printf ("no copy on protected ");
18045 if (datasz)
18046 printf (_("<corrupt length: %#x> "), datasz);
18047 goto next;
18048
18049 default:
18050 break;
18051 }
18052 }
18053
18054 if (type < GNU_PROPERTY_LOPROC)
18055 printf (_("<unknown type %#x data: "), type);
18056 else if (type < GNU_PROPERTY_LOUSER)
18057 printf (_("<procesor-specific type %#x data: "), type);
18058 else
18059 printf (_("<application-specific type %#x data: "), type);
18060 for (j = 0; j < datasz; ++j)
18061 printf ("%02x ", ptr[j] & 0xff);
18062 printf (">");
18063
18064next:
18065 ptr += ((datasz + (size - 1)) & ~ (size - 1));
18066 if (ptr == ptr_end)
18067 break;
18068
18069 if (do_wide)
18070 printf (", ");
18071 else
18072 printf ("\n\t");
18073 }
18074
18075 printf ("\n");
18076}
18077
18078static bfd_boolean
18079print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
18080{
18081 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
18082 switch (pnote->type)
18083 {
18084 case NT_GNU_BUILD_ID:
18085 {
18086 unsigned long i;
18087
18088 printf (_(" Build ID: "));
18089 for (i = 0; i < pnote->descsz; ++i)
18090 printf ("%02x", pnote->descdata[i] & 0xff);
18091 printf ("\n");
18092 }
18093 break;
18094
18095 case NT_GNU_ABI_TAG:
18096 {
18097 unsigned long os, major, minor, subminor;
18098 const char *osname;
18099
18100 /* PR 17531: file: 030-599401-0.004. */
18101 if (pnote->descsz < 16)
18102 {
18103 printf (_(" <corrupt GNU_ABI_TAG>\n"));
18104 break;
18105 }
18106
18107 os = byte_get ((unsigned char *) pnote->descdata, 4);
18108 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
18109 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
18110 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
18111
18112 switch (os)
18113 {
18114 case GNU_ABI_TAG_LINUX:
18115 osname = "Linux";
18116 break;
18117 case GNU_ABI_TAG_HURD:
18118 osname = "Hurd";
18119 break;
18120 case GNU_ABI_TAG_SOLARIS:
18121 osname = "Solaris";
18122 break;
18123 case GNU_ABI_TAG_FREEBSD:
18124 osname = "FreeBSD";
18125 break;
18126 case GNU_ABI_TAG_NETBSD:
18127 osname = "NetBSD";
18128 break;
18129 case GNU_ABI_TAG_SYLLABLE:
18130 osname = "Syllable";
18131 break;
18132 case GNU_ABI_TAG_NACL:
18133 osname = "NaCl";
18134 break;
18135 default:
18136 osname = "Unknown";
18137 break;
18138 }
18139
18140 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
18141 major, minor, subminor);
18142 }
18143 break;
18144
18145 case NT_GNU_GOLD_VERSION:
18146 {
18147 unsigned long i;
18148
18149 printf (_(" Version: "));
18150 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
18151 printf ("%c", pnote->descdata[i]);
18152 printf ("\n");
18153 }
18154 break;
18155
18156 case NT_GNU_HWCAP:
18157 {
18158 unsigned long num_entries, mask;
18159
18160 /* Hardware capabilities information. Word 0 is the number of entries.
18161 Word 1 is a bitmask of enabled entries. The rest of the descriptor
18162 is a series of entries, where each entry is a single byte followed
18163 by a nul terminated string. The byte gives the bit number to test
18164 if enabled in the bitmask. */
18165 printf (_(" Hardware Capabilities: "));
18166 if (pnote->descsz < 8)
18167 {
18168 error (_("<corrupt GNU_HWCAP>\n"));
18169 return FALSE;
18170 }
18171 num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
18172 mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
18173 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
18174 /* FIXME: Add code to display the entries... */
18175 }
18176 break;
18177
18178 case NT_GNU_PROPERTY_TYPE_0:
18179 print_gnu_property_note (filedata, pnote);
18180 break;
18181
18182 default:
18183 /* Handle unrecognised types. An error message should have already been
18184 created by get_gnu_elf_note_type(), so all that we need to do is to
18185 display the data. */
18186 {
18187 unsigned long i;
18188
18189 printf (_(" Description data: "));
18190 for (i = 0; i < pnote->descsz; ++i)
18191 printf ("%02x ", pnote->descdata[i] & 0xff);
18192 printf ("\n");
18193 }
18194 break;
18195 }
18196
18197 return TRUE;
18198}
18199
18200static const char *
18201get_v850_elf_note_type (enum v850_notes n_type)
18202{
18203 static char buff[64];
18204
18205 switch (n_type)
18206 {
18207 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
18208 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
18209 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
18210 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
18211 case V850_NOTE_CACHE_INFO: return _("Use of cache");
18212 case V850_NOTE_MMU_INFO: return _("Use of MMU");
18213 default:
18214 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
18215 return buff;
18216 }
18217}
18218
18219static bfd_boolean
18220print_v850_note (Elf_Internal_Note * pnote)
18221{
18222 unsigned int val;
18223
18224 if (pnote->descsz != 4)
18225 return FALSE;
18226
18227 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
18228
18229 if (val == 0)
18230 {
18231 printf (_("not set\n"));
18232 return TRUE;
18233 }
18234
18235 switch (pnote->type)
18236 {
18237 case V850_NOTE_ALIGNMENT:
18238 switch (val)
18239 {
18240 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
18241 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
18242 }
18243 break;
18244
18245 case V850_NOTE_DATA_SIZE:
18246 switch (val)
18247 {
18248 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
18249 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
18250 }
18251 break;
18252
18253 case V850_NOTE_FPU_INFO:
18254 switch (val)
18255 {
18256 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
18257 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
18258 }
18259 break;
18260
18261 case V850_NOTE_MMU_INFO:
18262 case V850_NOTE_CACHE_INFO:
18263 case V850_NOTE_SIMD_INFO:
18264 if (val == EF_RH850_SIMD)
18265 {
18266 printf (_("yes\n"));
18267 return TRUE;
18268 }
18269 break;
18270
18271 default:
18272 /* An 'unknown note type' message will already have been displayed. */
18273 break;
18274 }
18275
18276 printf (_("unknown value: %x\n"), val);
18277 return FALSE;
18278}
18279
18280static bfd_boolean
18281process_netbsd_elf_note (Elf_Internal_Note * pnote)
18282{
18283 unsigned int version;
18284
18285 switch (pnote->type)
18286 {
18287 case NT_NETBSD_IDENT:
18288 version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
18289 if ((version / 10000) % 100)
18290 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
18291 version, version / 100000000, (version / 1000000) % 100,
18292 (version / 10000) % 100 > 26 ? "Z" : "",
18293 'A' + (version / 10000) % 26);
18294 else
18295 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
18296 version, version / 100000000, (version / 1000000) % 100,
18297 (version / 100) % 100);
18298 return TRUE;
18299
18300 case NT_NETBSD_MARCH:
18301 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
18302 pnote->descdata);
18303 return TRUE;
18304
18305#ifdef NT_NETBSD_PAX
18306 case NT_NETBSD_PAX:
18307 version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
18308 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote->descsz,
18309 ((version & NT_NETBSD_PAX_MPROTECT) ? "+mprotect" : ""),
18310 ((version & NT_NETBSD_PAX_NOMPROTECT) ? "-mprotect" : ""),
18311 ((version & NT_NETBSD_PAX_GUARD) ? "+guard" : ""),
18312 ((version & NT_NETBSD_PAX_NOGUARD) ? "-guard" : ""),
18313 ((version & NT_NETBSD_PAX_ASLR) ? "+ASLR" : ""),
18314 ((version & NT_NETBSD_PAX_NOASLR) ? "-ASLR" : ""));
18315 return TRUE;
18316#endif
18317
18318 default:
18319 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
18320 pnote->type);
18321 return FALSE;
18322 }
18323}
18324
18325static const char *
18326get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
18327{
18328 switch (e_type)
18329 {
18330 case NT_FREEBSD_THRMISC:
18331 return _("NT_THRMISC (thrmisc structure)");
18332 case NT_FREEBSD_PROCSTAT_PROC:
18333 return _("NT_PROCSTAT_PROC (proc data)");
18334 case NT_FREEBSD_PROCSTAT_FILES:
18335 return _("NT_PROCSTAT_FILES (files data)");
18336 case NT_FREEBSD_PROCSTAT_VMMAP:
18337 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18338 case NT_FREEBSD_PROCSTAT_GROUPS:
18339 return _("NT_PROCSTAT_GROUPS (groups data)");
18340 case NT_FREEBSD_PROCSTAT_UMASK:
18341 return _("NT_PROCSTAT_UMASK (umask data)");
18342 case NT_FREEBSD_PROCSTAT_RLIMIT:
18343 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18344 case NT_FREEBSD_PROCSTAT_OSREL:
18345 return _("NT_PROCSTAT_OSREL (osreldate data)");
18346 case NT_FREEBSD_PROCSTAT_PSSTRINGS:
18347 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18348 case NT_FREEBSD_PROCSTAT_AUXV:
18349 return _("NT_PROCSTAT_AUXV (auxv data)");
18350 case NT_FREEBSD_PTLWPINFO:
18351 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18352 }
18353 return get_note_type (filedata, e_type);
18354}
18355
18356static const char *
18357get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
18358{
18359 static char buff[64];
18360
18361 switch (e_type)
18362 {
18363 case NT_NETBSDCORE_PROCINFO:
18364 /* NetBSD core "procinfo" structure. */
18365 return _("NetBSD procinfo structure");
18366
18367#ifdef NT_NETBSDCORE_AUXV
18368 case NT_NETBSDCORE_AUXV:
18369 return _("NetBSD ELF auxiliary vector data");
18370#endif
18371
18372 default:
18373 /* As of Jan 2002 there are no other machine-independent notes
18374 defined for NetBSD core files. If the note type is less
18375 than the start of the machine-dependent note types, we don't
18376 understand it. */
18377
18378 if (e_type < NT_NETBSDCORE_FIRSTMACH)
18379 {
18380 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18381 return buff;
18382 }
18383 break;
18384 }
18385
18386 switch (filedata->file_header.e_machine)
18387 {
18388 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18389 and PT_GETFPREGS == mach+2. */
18390
18391 case EM_OLD_ALPHA:
18392 case EM_ALPHA:
18393 case EM_SPARC:
18394 case EM_SPARC32PLUS:
18395 case EM_SPARCV9:
18396 switch (e_type)
18397 {
18398 case NT_NETBSDCORE_FIRSTMACH + 0:
18399 return _("PT_GETREGS (reg structure)");
18400 case NT_NETBSDCORE_FIRSTMACH + 2:
18401 return _("PT_GETFPREGS (fpreg structure)");
18402 default:
18403 break;
18404 }
18405 break;
18406
18407 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18408 There's also old PT___GETREGS40 == mach + 1 for old reg
18409 structure which lacks GBR. */
18410 case EM_SH:
18411 switch (e_type)
18412 {
18413 case NT_NETBSDCORE_FIRSTMACH + 1:
18414 return _("PT___GETREGS40 (old reg structure)");
18415 case NT_NETBSDCORE_FIRSTMACH + 3:
18416 return _("PT_GETREGS (reg structure)");
18417 case NT_NETBSDCORE_FIRSTMACH + 5:
18418 return _("PT_GETFPREGS (fpreg structure)");
18419 default:
18420 break;
18421 }
18422 break;
18423
18424 /* On all other arch's, PT_GETREGS == mach+1 and
18425 PT_GETFPREGS == mach+3. */
18426 default:
18427 switch (e_type)
18428 {
18429 case NT_NETBSDCORE_FIRSTMACH + 1:
18430 return _("PT_GETREGS (reg structure)");
18431 case NT_NETBSDCORE_FIRSTMACH + 3:
18432 return _("PT_GETFPREGS (fpreg structure)");
18433 default:
18434 break;
18435 }
18436 }
18437
18438 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
18439 e_type - NT_NETBSDCORE_FIRSTMACH);
18440 return buff;
18441}
18442
18443static const char *
18444get_stapsdt_note_type (unsigned e_type)
18445{
18446 static char buff[64];
18447
18448 switch (e_type)
18449 {
18450 case NT_STAPSDT:
18451 return _("NT_STAPSDT (SystemTap probe descriptors)");
18452
18453 default:
18454 break;
18455 }
18456
18457 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18458 return buff;
18459}
18460
18461static bfd_boolean
18462print_stapsdt_note (Elf_Internal_Note *pnote)
18463{
18464 size_t len, maxlen;
18465 unsigned long addr_size = is_32bit_elf ? 4 : 8;
18466 char *data = pnote->descdata;
18467 char *data_end = pnote->descdata + pnote->descsz;
18468 bfd_vma pc, base_addr, semaphore;
18469 char *provider, *probe, *arg_fmt;
18470
18471 if (pnote->descsz < (addr_size * 3))
18472 goto stapdt_note_too_small;
18473
18474 pc = byte_get ((unsigned char *) data, addr_size);
18475 data += addr_size;
18476
18477 base_addr = byte_get ((unsigned char *) data, addr_size);
18478 data += addr_size;
18479
18480 semaphore = byte_get ((unsigned char *) data, addr_size);
18481 data += addr_size;
18482
18483 if (data >= data_end)
18484 goto stapdt_note_too_small;
18485 maxlen = data_end - data;
18486 len = strnlen (data, maxlen);
18487 if (len < maxlen)
18488 {
18489 provider = data;
18490 data += len + 1;
18491 }
18492 else
18493 goto stapdt_note_too_small;
18494
18495 if (data >= data_end)
18496 goto stapdt_note_too_small;
18497 maxlen = data_end - data;
18498 len = strnlen (data, maxlen);
18499 if (len < maxlen)
18500 {
18501 probe = data;
18502 data += len + 1;
18503 }
18504 else
18505 goto stapdt_note_too_small;
18506
18507 if (data >= data_end)
18508 goto stapdt_note_too_small;
18509 maxlen = data_end - data;
18510 len = strnlen (data, maxlen);
18511 if (len < maxlen)
18512 {
18513 arg_fmt = data;
18514 data += len + 1;
18515 }
18516 else
18517 goto stapdt_note_too_small;
18518
18519 printf (_(" Provider: %s\n"), provider);
18520 printf (_(" Name: %s\n"), probe);
18521 printf (_(" Location: "));
18522 print_vma (pc, FULL_HEX);
18523 printf (_(", Base: "));
18524 print_vma (base_addr, FULL_HEX);
18525 printf (_(", Semaphore: "));
18526 print_vma (semaphore, FULL_HEX);
18527 printf ("\n");
18528 printf (_(" Arguments: %s\n"), arg_fmt);
18529
18530 return data == data_end;
18531
18532 stapdt_note_too_small:
18533 printf (_(" <corrupt - note is too small>\n"));
18534 error (_("corrupt stapdt note - the data size is too small\n"));
18535 return FALSE;
18536}
18537
18538static const char *
18539get_ia64_vms_note_type (unsigned e_type)
18540{
18541 static char buff[64];
18542
18543 switch (e_type)
18544 {
18545 case NT_VMS_MHD:
18546 return _("NT_VMS_MHD (module header)");
18547 case NT_VMS_LNM:
18548 return _("NT_VMS_LNM (language name)");
18549 case NT_VMS_SRC:
18550 return _("NT_VMS_SRC (source files)");
18551 case NT_VMS_TITLE:
18552 return "NT_VMS_TITLE";
18553 case NT_VMS_EIDC:
18554 return _("NT_VMS_EIDC (consistency check)");
18555 case NT_VMS_FPMODE:
18556 return _("NT_VMS_FPMODE (FP mode)");
18557 case NT_VMS_LINKTIME:
18558 return "NT_VMS_LINKTIME";
18559 case NT_VMS_IMGNAM:
18560 return _("NT_VMS_IMGNAM (image name)");
18561 case NT_VMS_IMGID:
18562 return _("NT_VMS_IMGID (image id)");
18563 case NT_VMS_LINKID:
18564 return _("NT_VMS_LINKID (link id)");
18565 case NT_VMS_IMGBID:
18566 return _("NT_VMS_IMGBID (build id)");
18567 case NT_VMS_GSTNAM:
18568 return _("NT_VMS_GSTNAM (sym table name)");
18569 case NT_VMS_ORIG_DYN:
18570 return "NT_VMS_ORIG_DYN";
18571 case NT_VMS_PATCHTIME:
18572 return "NT_VMS_PATCHTIME";
18573 default:
18574 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18575 return buff;
18576 }
18577}
18578
18579static bfd_boolean
18580print_ia64_vms_note (Elf_Internal_Note * pnote)
18581{
18582 int maxlen = pnote->descsz;
18583
18584 if (maxlen < 2 || (unsigned long) maxlen != pnote->descsz)
18585 goto desc_size_fail;
18586
18587 switch (pnote->type)
18588 {
18589 case NT_VMS_MHD:
18590 if (maxlen <= 36)
18591 goto desc_size_fail;
18592
18593 int l = (int) strnlen (pnote->descdata + 34, maxlen - 34);
18594
18595 printf (_(" Creation date : %.17s\n"), pnote->descdata);
18596 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
18597 if (l + 34 < maxlen)
18598 {
18599 printf (_(" Module name : %s\n"), pnote->descdata + 34);
18600 if (l + 35 < maxlen)
18601 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
18602 else
18603 printf (_(" Module version : <missing>\n"));
18604 }
18605 else
18606 {
18607 printf (_(" Module name : <missing>\n"));
18608 printf (_(" Module version : <missing>\n"));
18609 }
18610 break;
18611
18612 case NT_VMS_LNM:
18613 printf (_(" Language: %.*s\n"), maxlen, pnote->descdata);
18614 break;
18615
18616#ifdef BFD64
18617 case NT_VMS_FPMODE:
18618 printf (_(" Floating Point mode: "));
18619 if (maxlen < 8)
18620 goto desc_size_fail;
18621 /* FIXME: Generate an error if descsz > 8 ? */
18622
18623 printf ("0x%016" BFD_VMA_FMT "x\n",
18624 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
18625 break;
18626
18627 case NT_VMS_LINKTIME:
18628 printf (_(" Link time: "));
18629 if (maxlen < 8)
18630 goto desc_size_fail;
18631 /* FIXME: Generate an error if descsz > 8 ? */
18632
18633 print_vms_time
18634 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
18635 printf ("\n");
18636 break;
18637
18638 case NT_VMS_PATCHTIME:
18639 printf (_(" Patch time: "));
18640 if (maxlen < 8)
18641 goto desc_size_fail;
18642 /* FIXME: Generate an error if descsz > 8 ? */
18643
18644 print_vms_time
18645 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
18646 printf ("\n");
18647 break;
18648
18649 case NT_VMS_ORIG_DYN:
18650 if (maxlen < 34)
18651 goto desc_size_fail;
18652
18653 printf (_(" Major id: %u, minor id: %u\n"),
18654 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
18655 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
18656 printf (_(" Last modified : "));
18657 print_vms_time
18658 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
18659 printf (_("\n Link flags : "));
18660 printf ("0x%016" BFD_VMA_FMT "x\n",
18661 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
18662 printf (_(" Header flags: 0x%08x\n"),
18663 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
18664 printf (_(" Image id : %.*s\n"), maxlen - 32, pnote->descdata + 32);
18665 break;
18666#endif
18667
18668 case NT_VMS_IMGNAM:
18669 printf (_(" Image name: %.*s\n"), maxlen, pnote->descdata);
18670 break;
18671
18672 case NT_VMS_GSTNAM:
18673 printf (_(" Global symbol table name: %.*s\n"), maxlen, pnote->descdata);
18674 break;
18675
18676 case NT_VMS_IMGID:
18677 printf (_(" Image id: %.*s\n"), maxlen, pnote->descdata);
18678 break;
18679
18680 case NT_VMS_LINKID:
18681 printf (_(" Linker id: %.*s\n"), maxlen, pnote->descdata);
18682 break;
18683
18684 default:
18685 return FALSE;
18686 }
18687
18688 return TRUE;
18689
18690 desc_size_fail:
18691 printf (_(" <corrupt - data size is too small>\n"));
18692 error (_("corrupt IA64 note: data size is too small\n"));
18693 return FALSE;
18694}
18695
18696/* Find the symbol associated with a build attribute that is attached
18697 to address OFFSET. If PNAME is non-NULL then store the name of
18698 the symbol (if found) in the provided pointer, Returns NULL if a
18699 symbol could not be found. */
18700
18701static Elf_Internal_Sym *
18702get_symbol_for_build_attribute (Filedata * filedata,
18703 unsigned long offset,
18704 bfd_boolean is_open_attr,
18705 const char ** pname)
18706{
18707 static Filedata * saved_filedata = NULL;
18708 static char * strtab;
18709 static unsigned long strtablen;
18710 static Elf_Internal_Sym * symtab;
18711 static unsigned long nsyms;
18712 Elf_Internal_Sym * saved_sym = NULL;
18713 Elf_Internal_Sym * sym;
18714
18715 if (filedata->section_headers != NULL
18716 && (saved_filedata == NULL || filedata != saved_filedata))
18717 {
18718 Elf_Internal_Shdr * symsec;
18719
18720 /* Load the symbol and string sections. */
18721 for (symsec = filedata->section_headers;
18722 symsec < filedata->section_headers + filedata->file_header.e_shnum;
18723 symsec ++)
18724 {
18725 if (symsec->sh_type == SHT_SYMTAB)
18726 {
18727 symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
18728
18729 if (symsec->sh_link < filedata->file_header.e_shnum)
18730 {
18731 Elf_Internal_Shdr * strtab_sec = filedata->section_headers + symsec->sh_link;
18732
18733 strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
18734 1, strtab_sec->sh_size,
18735 _("string table"));
18736 strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
18737 }
18738 }
18739 }
18740 saved_filedata = filedata;
18741 }
18742
18743 if (symtab == NULL || strtab == NULL)
18744 return NULL;
18745
18746 /* Find a symbol whose value matches offset. */
18747 for (sym = symtab; sym < symtab + nsyms; sym ++)
18748 if (sym->st_value == offset)
18749 {
18750 if (sym->st_name >= strtablen)
18751 /* Huh ? This should not happen. */
18752 continue;
18753
18754 if (strtab[sym->st_name] == 0)
18755 continue;
18756
18757 /* The AArch64 and ARM architectures define mapping symbols
18758 (eg $d, $x, $t) which we want to ignore. */
18759 if (strtab[sym->st_name] == '$'
18760 && strtab[sym->st_name + 1] != 0
18761 && strtab[sym->st_name + 2] == 0)
18762 continue;
18763
18764 if (is_open_attr)
18765 {
18766 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
18767 and FILE or OBJECT symbols over NOTYPE symbols. We skip
18768 FUNC symbols entirely. */
18769 switch (ELF_ST_TYPE (sym->st_info))
18770 {
18771 case STT_OBJECT:
18772 case STT_FILE:
18773 saved_sym = sym;
18774 if (sym->st_size)
18775 {
18776 /* If the symbol has a size associated
18777 with it then we can stop searching. */
18778 sym = symtab + nsyms;
18779 }
18780 continue;
18781
18782 case STT_FUNC:
18783 /* Ignore function symbols. */
18784 continue;
18785
18786 default:
18787 break;
18788 }
18789
18790 switch (ELF_ST_BIND (sym->st_info))
18791 {
18792 case STB_GLOBAL:
18793 if (saved_sym == NULL
18794 || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
18795 saved_sym = sym;
18796 break;
18797
18798 case STB_LOCAL:
18799 if (saved_sym == NULL)
18800 saved_sym = sym;
18801 break;
18802
18803 default:
18804 break;
18805 }
18806 }
18807 else
18808 {
18809 if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
18810 continue;
18811
18812 saved_sym = sym;
18813 break;
18814 }
18815 }
18816
18817 if (saved_sym && pname)
18818 * pname = strtab + saved_sym->st_name;
18819
18820 return saved_sym;
18821}
18822
18823/* Returns true iff addr1 and addr2 are in the same section. */
18824
18825static bfd_boolean
18826same_section (Filedata * filedata, unsigned long addr1, unsigned long addr2)
18827{
18828 Elf_Internal_Shdr * a1;
18829 Elf_Internal_Shdr * a2;
18830
18831 a1 = find_section_by_address (filedata, addr1);
18832 a2 = find_section_by_address (filedata, addr2);
18833
18834 return a1 == a2 && a1 != NULL;
18835}
18836
18837static bfd_boolean
18838print_gnu_build_attribute_description (Elf_Internal_Note * pnote,
18839 Filedata * filedata)
18840{
18841 static unsigned long global_offset = 0;
18842 static unsigned long global_end = 0;
18843 static unsigned long func_offset = 0;
18844 static unsigned long func_end = 0;
18845
18846 Elf_Internal_Sym * sym;
18847 const char * name;
18848 unsigned long start;
18849 unsigned long end;
18850 bfd_boolean is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
18851
18852 switch (pnote->descsz)
18853 {
18854 case 0:
18855 /* A zero-length description means that the range of
18856 the previous note of the same type should be used. */
18857 if (is_open_attr)
18858 {
18859 if (global_end > global_offset)
18860 printf (_(" Applies to region from %#lx to %#lx\n"),
18861 global_offset, global_end);
18862 else
18863 printf (_(" Applies to region from %#lx\n"), global_offset);
18864 }
18865 else
18866 {
18867 if (func_end > func_offset)
18868 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset, func_end);
18869 else
18870 printf (_(" Applies to region from %#lx\n"), func_offset);
18871 }
18872 return TRUE;
18873
18874 case 4:
18875 start = byte_get ((unsigned char *) pnote->descdata, 4);
18876 end = 0;
18877 break;
18878
18879 case 8:
18880 if (is_32bit_elf)
18881 {
18882 /* FIXME: We should check that version 3+ notes are being used here... */
18883 start = byte_get ((unsigned char *) pnote->descdata, 4);
18884 end = byte_get ((unsigned char *) pnote->descdata + 4, 4);
18885 }
18886 else
18887 {
18888 start = byte_get ((unsigned char *) pnote->descdata, 8);
18889 end = 0;
18890 }
18891 break;
18892
18893 case 16:
18894 start = byte_get ((unsigned char *) pnote->descdata, 8);
18895 end = byte_get ((unsigned char *) pnote->descdata + 8, 8);
18896 break;
18897
18898 default:
18899 error (_(" <invalid description size: %lx>\n"), pnote->descsz);
18900 printf (_(" <invalid descsz>"));
18901 return FALSE;
18902 }
18903
18904 name = NULL;
18905 sym = get_symbol_for_build_attribute (filedata, start, is_open_attr, & name);
18906 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
18907 in order to avoid them being confused with the start address of the
18908 first function in the file... */
18909 if (sym == NULL && is_open_attr)
18910 sym = get_symbol_for_build_attribute (filedata, start + 2, is_open_attr,
18911 & name);
18912
18913 if (end == 0 && sym != NULL && sym->st_size > 0)
18914 end = start + sym->st_size;
18915
18916 if (is_open_attr)
18917 {
18918 /* FIXME: Need to properly allow for section alignment.
18919 16 is just the alignment used on x86_64. */
18920 if (global_end > 0
18921 && start > BFD_ALIGN (global_end, 16)
18922 /* Build notes are not guaranteed to be organised in order of
18923 increasing address, but we should find the all of the notes
18924 for one section in the same place. */
18925 && same_section (filedata, start, global_end))
18926 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
18927 global_end + 1, start - 1);
18928
18929 printf (_(" Applies to region from %#lx"), start);
18930 global_offset = start;
18931
18932 if (end)
18933 {
18934 printf (_(" to %#lx"), end);
18935 global_end = end;
18936 }
18937 }
18938 else
18939 {
18940 printf (_(" Applies to region from %#lx"), start);
18941 func_offset = start;
18942
18943 if (end)
18944 {
18945 printf (_(" to %#lx"), end);
18946 func_end = end;
18947 }
18948 }
18949
18950 if (sym && name)
18951 printf (_(" (%s)"), name);
18952
18953 printf ("\n");
18954 return TRUE;
18955}
18956
18957static bfd_boolean
18958print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
18959{
18960 static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
18961 static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
18962 static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
18963 char name_type;
18964 char name_attribute;
18965 const char * expected_types;
18966 const char * name = pnote->namedata;
18967 const char * text;
18968 signed int left;
18969
18970 if (name == NULL || pnote->namesz < 2)
18971 {
18972 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18973 print_symbol (-20, _(" <corrupt name>"));
18974 return FALSE;
18975 }
18976
18977 if (do_wide)
18978 left = 28;
18979 else
18980 left = 20;
18981
18982 /* Version 2 of the spec adds a "GA" prefix to the name field. */
18983 if (name[0] == 'G' && name[1] == 'A')
18984 {
18985 if (pnote->namesz < 4)
18986 {
18987 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18988 print_symbol (-20, _(" <corrupt name>"));
18989 return FALSE;
18990 }
18991
18992 printf ("GA");
18993 name += 2;
18994 left -= 2;
18995 }
18996
18997 switch ((name_type = * name))
18998 {
18999 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
19000 case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
19001 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
19002 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
19003 printf ("%c", * name);
19004 left --;
19005 break;
19006 default:
19007 error (_("unrecognised attribute type in name field: %d\n"), name_type);
19008 print_symbol (-20, _("<unknown name type>"));
19009 return FALSE;
19010 }
19011
19012 ++ name;
19013 text = NULL;
19014
19015 switch ((name_attribute = * name))
19016 {
19017 case GNU_BUILD_ATTRIBUTE_VERSION:
19018 text = _("<version>");
19019 expected_types = string_expected;
19020 ++ name;
19021 break;
19022 case GNU_BUILD_ATTRIBUTE_STACK_PROT:
19023 text = _("<stack prot>");
19024 expected_types = "!+*";
19025 ++ name;
19026 break;
19027 case GNU_BUILD_ATTRIBUTE_RELRO:
19028 text = _("<relro>");
19029 expected_types = bool_expected;
19030 ++ name;
19031 break;
19032 case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
19033 text = _("<stack size>");
19034 expected_types = number_expected;
19035 ++ name;
19036 break;
19037 case GNU_BUILD_ATTRIBUTE_TOOL:
19038 text = _("<tool>");
19039 expected_types = string_expected;
19040 ++ name;
19041 break;
19042 case GNU_BUILD_ATTRIBUTE_ABI:
19043 text = _("<ABI>");
19044 expected_types = "$*";
19045 ++ name;
19046 break;
19047 case GNU_BUILD_ATTRIBUTE_PIC:
19048 text = _("<PIC>");
19049 expected_types = number_expected;
19050 ++ name;
19051 break;
19052 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
19053 text = _("<short enum>");
19054 expected_types = bool_expected;
19055 ++ name;
19056 break;
19057 default:
19058 if (ISPRINT (* name))
19059 {
19060 int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
19061
19062 if (len > left && ! do_wide)
19063 len = left;
19064 printf ("%.*s:", len, name);
19065 left -= len;
19066 name += len;
19067 }
19068 else
19069 {
19070 static char tmpbuf [128];
19071
19072 error (_("unrecognised byte in name field: %d\n"), * name);
19073 sprintf (tmpbuf, _("<unknown:_%d>"), * name);
19074 text = tmpbuf;
19075 name ++;
19076 }
19077 expected_types = "*$!+";
19078 break;
19079 }
19080
19081 if (text)
19082 left -= printf ("%s", text);
19083
19084 if (strchr (expected_types, name_type) == NULL)
19085 warn (_("attribute does not have an expected type (%c)\n"), name_type);
19086
19087 if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
19088 {
19089 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
19090 (unsigned long) pnote->namesz,
19091 (long) (name - pnote->namedata));
19092 return FALSE;
19093 }
19094
19095 if (left < 1 && ! do_wide)
19096 return TRUE;
19097
19098 switch (name_type)
19099 {
19100 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
19101 {
19102 unsigned int bytes;
19103 unsigned long long val = 0;
19104 unsigned int shift = 0;
19105 char * decoded = NULL;
19106
19107 bytes = pnote->namesz - (name - pnote->namedata);
19108 if (bytes > 0)
19109 /* The -1 is because the name field is always 0 terminated, and we
19110 want to be able to ensure that the shift in the while loop below
19111 will not overflow. */
19112 -- bytes;
19113
19114 if (bytes > sizeof (val))
19115 {
19116 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
19117 bytes);
19118 bytes = sizeof (val);
19119 }
19120 /* We do not bother to warn if bytes == 0 as this can
19121 happen with some early versions of the gcc plugin. */
19122
19123 while (bytes --)
19124 {
19125 unsigned long byte = (* name ++) & 0xff;
19126
19127 val |= byte << shift;
19128 shift += 8;
19129 }
19130
19131 switch (name_attribute)
19132 {
19133 case GNU_BUILD_ATTRIBUTE_PIC:
19134 switch (val)
19135 {
19136 case 0: decoded = "static"; break;
19137 case 1: decoded = "pic"; break;
19138 case 2: decoded = "PIC"; break;
19139 case 3: decoded = "pie"; break;
19140 case 4: decoded = "PIE"; break;
19141 default: break;
19142 }
19143 break;
19144 case GNU_BUILD_ATTRIBUTE_STACK_PROT:
19145 switch (val)
19146 {
19147 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
19148 case 0: decoded = "off"; break;
19149 case 1: decoded = "on"; break;
19150 case 2: decoded = "all"; break;
19151 case 3: decoded = "strong"; break;
19152 case 4: decoded = "explicit"; break;
19153 default: break;
19154 }
19155 break;
19156 default:
19157 break;
19158 }
19159
19160 if (decoded != NULL)
19161 {
19162 print_symbol (-left, decoded);
19163 left = 0;
19164 }
19165 else if (val == 0)
19166 {
19167 printf ("0x0");
19168 left -= 3;
19169 }
19170 else
19171 {
19172 if (do_wide)
19173 left -= printf ("0x%llx", val);
19174 else
19175 left -= printf ("0x%-.*llx", left, val);
19176 }
19177 }
19178 break;
19179 case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
19180 left -= print_symbol (- left, name);
19181 break;
19182 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
19183 left -= print_symbol (- left, "true");
19184 break;
19185 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
19186 left -= print_symbol (- left, "false");
19187 break;
19188 }
19189
19190 if (do_wide && left > 0)
19191 printf ("%-*s", left, " ");
19192
19193 return TRUE;
19194}
19195
19196/* Note that by the ELF standard, the name field is already null byte
19197 terminated, and namesz includes the terminating null byte.
19198 I.E. the value of namesz for the name "FSF" is 4.
19199
19200 If the value of namesz is zero, there is no name present. */
19201
19202static bfd_boolean
19203process_note (Elf_Internal_Note * pnote,
19204 Filedata * filedata)
19205{
19206 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
19207 const char * nt;
19208
19209 if (pnote->namesz == 0)
19210 /* If there is no note name, then use the default set of
19211 note type strings. */
19212 nt = get_note_type (filedata, pnote->type);
19213
19214 else if (const_strneq (pnote->namedata, "GNU"))
19215 /* GNU-specific object file notes. */
19216 nt = get_gnu_elf_note_type (pnote->type);
19217
19218 else if (const_strneq (pnote->namedata, "FreeBSD"))
19219 /* FreeBSD-specific core file notes. */
19220 nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
19221
19222 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
19223 /* NetBSD-specific core file notes. */
19224 nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
19225
19226 else if (const_strneq (pnote->namedata, "NetBSD"))
19227 /* NetBSD-specific core file notes. */
19228 return process_netbsd_elf_note (pnote);
19229
19230 else if (const_strneq (pnote->namedata, "PaX"))
19231 /* NetBSD-specific core file notes. */
19232 return process_netbsd_elf_note (pnote);
19233
19234 else if (strneq (pnote->namedata, "SPU/", 4))
19235 {
19236 /* SPU-specific core file notes. */
19237 nt = pnote->namedata + 4;
19238 name = "SPU";
19239 }
19240
19241 else if (const_strneq (pnote->namedata, "IPF/VMS"))
19242 /* VMS/ia64-specific file notes. */
19243 nt = get_ia64_vms_note_type (pnote->type);
19244
19245 else if (const_strneq (pnote->namedata, "stapsdt"))
19246 nt = get_stapsdt_note_type (pnote->type);
19247
19248 else
19249 /* Don't recognize this note name; just use the default set of
19250 note type strings. */
19251 nt = get_note_type (filedata, pnote->type);
19252
19253 printf (" ");
19254
19255 if (((const_strneq (pnote->namedata, "GA")
19256 && strchr ("*$!+", pnote->namedata[2]) != NULL)
19257 || strchr ("*$!+", pnote->namedata[0]) != NULL)
19258 && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
19259 || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
19260 print_gnu_build_attribute_name (pnote);
19261 else
19262 print_symbol (-20, name);
19263
19264 if (do_wide)
19265 printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
19266 else
19267 printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
19268
19269 if (const_strneq (pnote->namedata, "IPF/VMS"))
19270 return print_ia64_vms_note (pnote);
19271 else if (const_strneq (pnote->namedata, "GNU"))
19272 return print_gnu_note (filedata, pnote);
19273 else if (const_strneq (pnote->namedata, "stapsdt"))
19274 return print_stapsdt_note (pnote);
19275 else if (const_strneq (pnote->namedata, "CORE"))
19276 return print_core_note (pnote);
19277 else if (((const_strneq (pnote->namedata, "GA")
19278 && strchr ("*$!+", pnote->namedata[2]) != NULL)
19279 || strchr ("*$!+", pnote->namedata[0]) != NULL)
19280 && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
19281 || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
19282 return print_gnu_build_attribute_description (pnote, filedata);
19283
19284 if (pnote->descsz)
19285 {
19286 unsigned long i;
19287
19288 printf (_(" description data: "));
19289 for (i = 0; i < pnote->descsz; i++)
19290 printf ("%02x ", pnote->descdata[i] & 0xff);
19291 if (!do_wide)
19292 printf ("\n");
19293 }
19294
19295 if (do_wide)
19296 printf ("\n");
19297
19298 return TRUE;
19299}
19300
19301static bfd_boolean
19302process_notes_at (Filedata * filedata,
19303 Elf_Internal_Shdr * section,
19304 bfd_vma offset,
19305 bfd_vma length,
19306 bfd_vma align)
19307{
19308 Elf_External_Note * pnotes;
19309 Elf_External_Note * external;
19310 char * end;
19311 bfd_boolean res = TRUE;
19312
19313 if (length <= 0)
19314 return FALSE;
19315
19316 if (section)
19317 {
19318 pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
19319 if (pnotes)
19320 {
19321 if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
19322 return FALSE;
19323 }
19324 }
19325 else
19326 pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
19327 _("notes"));
19328
19329 if (pnotes == NULL)
19330 return FALSE;
19331
19332 external = pnotes;
19333
19334 if (section)
19335 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
19336 else
19337 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19338 (unsigned long) offset, (unsigned long) length);
19339
19340 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19341 specifies that notes should be aligned to 4 bytes in 32-bit
19342 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19343 we also support 4 byte alignment in 64-bit objects. If section
19344 alignment is less than 4, we treate alignment as 4 bytes. */
19345 if (align < 4)
19346 align = 4;
19347 else if (align != 4 && align != 8)
19348 {
19349 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19350 (long) align);
19351 free (pnotes);
19352 return FALSE;
19353 }
19354
19355 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19356
19357 end = (char *) pnotes + length;
19358 while ((char *) external < end)
19359 {
19360 Elf_Internal_Note inote;
19361 size_t min_notesz;
19362 char * next;
19363 char * temp = NULL;
19364 size_t data_remaining = end - (char *) external;
19365
19366 if (!is_ia64_vms (filedata))
19367 {
19368 /* PR binutils/15191
19369 Make sure that there is enough data to read. */
19370 min_notesz = offsetof (Elf_External_Note, name);
19371 if (data_remaining < min_notesz)
19372 {
19373 warn (ngettext ("Corrupt note: only %ld byte remains, "
19374 "not enough for a full note\n",
19375 "Corrupt note: only %ld bytes remain, "
19376 "not enough for a full note\n",
19377 data_remaining),
19378 (long) data_remaining);
19379 break;
19380 }
19381 data_remaining -= min_notesz;
19382
19383 inote.type = BYTE_GET (external->type);
19384 inote.namesz = BYTE_GET (external->namesz);
19385 inote.namedata = external->name;
19386 inote.descsz = BYTE_GET (external->descsz);
19387 inote.descdata = ((char *) external
19388 + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
19389 inote.descpos = offset + (inote.descdata - (char *) pnotes);
19390 next = ((char *) external
19391 + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
19392 }
19393 else
19394 {
19395 Elf64_External_VMS_Note *vms_external;
19396
19397 /* PR binutils/15191
19398 Make sure that there is enough data to read. */
19399 min_notesz = offsetof (Elf64_External_VMS_Note, name);
19400 if (data_remaining < min_notesz)
19401 {
19402 warn (ngettext ("Corrupt note: only %ld byte remains, "
19403 "not enough for a full note\n",
19404 "Corrupt note: only %ld bytes remain, "
19405 "not enough for a full note\n",
19406 data_remaining),
19407 (long) data_remaining);
19408 break;
19409 }
19410 data_remaining -= min_notesz;
19411
19412 vms_external = (Elf64_External_VMS_Note *) external;
19413 inote.type = BYTE_GET (vms_external->type);
19414 inote.namesz = BYTE_GET (vms_external->namesz);
19415 inote.namedata = vms_external->name;
19416 inote.descsz = BYTE_GET (vms_external->descsz);
19417 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
19418 inote.descpos = offset + (inote.descdata - (char *) pnotes);
19419 next = inote.descdata + align_power (inote.descsz, 3);
19420 }
19421
19422 /* PR 17531: file: 3443835e. */
19423 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19424 if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
19425 || (size_t) (inote.descdata - inote.namedata) > data_remaining
19426 || (size_t) (next - inote.descdata) < inote.descsz
19427 || ((size_t) (next - inote.descdata)
19428 > data_remaining - (size_t) (inote.descdata - inote.namedata)))
19429 {
19430 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19431 (unsigned long) ((char *) external - (char *) pnotes));
19432 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19433 inote.type, inote.namesz, inote.descsz, (int) align);
19434 break;
19435 }
19436
19437 external = (Elf_External_Note *) next;
19438
19439 /* Verify that name is null terminated. It appears that at least
19440 one version of Linux (RedHat 6.0) generates corefiles that don't
19441 comply with the ELF spec by failing to include the null byte in
19442 namesz. */
19443 if (inote.namesz > 0 && inote.namedata[inote.namesz - 1] != '\0')
19444 {
19445 if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
19446 {
19447 temp = (char *) malloc (inote.namesz + 1);
19448 if (temp == NULL)
19449 {
19450 error (_("Out of memory allocating space for inote name\n"));
19451 res = FALSE;
19452 break;
19453 }
19454
19455 memcpy (temp, inote.namedata, inote.namesz);
19456 inote.namedata = temp;
19457 }
19458 inote.namedata[inote.namesz] = 0;
19459 }
19460
19461 if (! process_note (& inote, filedata))
19462 res = FALSE;
19463
19464 if (temp != NULL)
19465 {
19466 free (temp);
19467 temp = NULL;
19468 }
19469 }
19470
19471 free (pnotes);
19472
19473 return res;
19474}
19475
19476static bfd_boolean
19477process_corefile_note_segments (Filedata * filedata)
19478{
19479 Elf_Internal_Phdr * segment;
19480 unsigned int i;
19481 bfd_boolean res = TRUE;
19482
19483 if (! get_program_headers (filedata))
19484 return TRUE;
19485
19486 for (i = 0, segment = filedata->program_headers;
19487 i < filedata->file_header.e_phnum;
19488 i++, segment++)
19489 {
19490 if (segment->p_type == PT_NOTE)
19491 if (! process_notes_at (filedata, NULL,
19492 (bfd_vma) segment->p_offset,
19493 (bfd_vma) segment->p_filesz,
19494 (bfd_vma) segment->p_align))
19495 res = FALSE;
19496 }
19497
19498 return res;
19499}
19500
19501static bfd_boolean
19502process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
19503{
19504 Elf_External_Note * pnotes;
19505 Elf_External_Note * external;
19506 char * end;
19507 bfd_boolean res = TRUE;
19508
19509 if (length <= 0)
19510 return FALSE;
19511
19512 pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
19513 _("v850 notes"));
19514 if (pnotes == NULL)
19515 return FALSE;
19516
19517 external = pnotes;
19518 end = (char*) pnotes + length;
19519
19520 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19521 (unsigned long) offset, (unsigned long) length);
19522
19523 while ((char *) external + sizeof (Elf_External_Note) < end)
19524 {
19525 Elf_External_Note * next;
19526 Elf_Internal_Note inote;
19527
19528 inote.type = BYTE_GET (external->type);
19529 inote.namesz = BYTE_GET (external->namesz);
19530 inote.namedata = external->name;
19531 inote.descsz = BYTE_GET (external->descsz);
19532 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
19533 inote.descpos = offset + (inote.descdata - (char *) pnotes);
19534
19535 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
19536 {
19537 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
19538 inote.descdata = inote.namedata;
19539 inote.namesz = 0;
19540 }
19541
19542 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
19543
19544 if ( ((char *) next > end)
19545 || ((char *) next < (char *) pnotes))
19546 {
19547 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19548 (unsigned long) ((char *) external - (char *) pnotes));
19549 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19550 inote.type, inote.namesz, inote.descsz);
19551 break;
19552 }
19553
19554 external = next;
19555
19556 /* Prevent out-of-bounds indexing. */
19557 if ( inote.namedata + inote.namesz > end
19558 || inote.namedata + inote.namesz < inote.namedata)
19559 {
19560 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19561 (unsigned long) ((char *) external - (char *) pnotes));
19562 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19563 inote.type, inote.namesz, inote.descsz);
19564 break;
19565 }
19566
19567 printf (" %s: ", get_v850_elf_note_type (inote.type));
19568
19569 if (! print_v850_note (& inote))
19570 {
19571 res = FALSE;
19572 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19573 inote.namesz, inote.descsz);
19574 }
19575 }
19576
19577 free (pnotes);
19578
19579 return res;
19580}
19581
19582static bfd_boolean
19583process_note_sections (Filedata * filedata)
19584{
19585 Elf_Internal_Shdr * section;
19586 unsigned long i;
19587 unsigned int n = 0;
19588 bfd_boolean res = TRUE;
19589
19590 for (i = 0, section = filedata->section_headers;
19591 i < filedata->file_header.e_shnum && section != NULL;
19592 i++, section++)
19593 {
19594 if (section->sh_type == SHT_NOTE)
19595 {
19596 if (! process_notes_at (filedata, section,
19597 (bfd_vma) section->sh_offset,
19598 (bfd_vma) section->sh_size,
19599 (bfd_vma) section->sh_addralign))
19600 res = FALSE;
19601 n++;
19602 }
19603
19604 if (( filedata->file_header.e_machine == EM_V800
19605 || filedata->file_header.e_machine == EM_V850
19606 || filedata->file_header.e_machine == EM_CYGNUS_V850)
19607 && section->sh_type == SHT_RENESAS_INFO)
19608 {
19609 if (! process_v850_notes (filedata,
19610 (bfd_vma) section->sh_offset,
19611 (bfd_vma) section->sh_size))
19612 res = FALSE;
19613 n++;
19614 }
19615 }
19616
19617 if (n == 0)
19618 /* Try processing NOTE segments instead. */
19619 return process_corefile_note_segments (filedata);
19620
19621 return res;
19622}
19623
19624static bfd_boolean
19625process_notes (Filedata * filedata)
19626{
19627 /* If we have not been asked to display the notes then do nothing. */
19628 if (! do_notes)
19629 return TRUE;
19630
19631 if (filedata->file_header.e_type != ET_CORE)
19632 return process_note_sections (filedata);
19633
19634 /* No program headers means no NOTE segment. */
19635 if (filedata->file_header.e_phnum > 0)
19636 return process_corefile_note_segments (filedata);
19637
19638 printf (_("No note segments present in the core file.\n"));
19639 return TRUE;
19640}
19641
19642static unsigned char *
19643display_public_gnu_attributes (unsigned char * start,
19644 const unsigned char * const end)
19645{
19646 printf (_(" Unknown GNU attribute: %s\n"), start);
19647
19648 start += strnlen ((char *) start, end - start);
19649 display_raw_attribute (start, end);
19650
19651 return (unsigned char *) end;
19652}
19653
19654static unsigned char *
19655display_generic_attribute (unsigned char * start,
19656 unsigned int tag,
19657 const unsigned char * const end)
19658{
19659 if (tag == 0)
19660 return (unsigned char *) end;
19661
19662 return display_tag_value (tag, start, end);
19663}
19664
19665static bfd_boolean
19666process_arch_specific (Filedata * filedata)
19667{
19668 if (! do_arch)
19669 return TRUE;
19670
19671 switch (filedata->file_header.e_machine)
19672 {
19673 case EM_ARC:
19674 case EM_ARC_COMPACT:
19675 case EM_ARC_COMPACT2:
19676 return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
19677 display_arc_attribute,
19678 display_generic_attribute);
19679 case EM_ARM:
19680 return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
19681 display_arm_attribute,
19682 display_generic_attribute);
19683
19684 case EM_MIPS:
19685 case EM_MIPS_RS3_LE:
19686 return process_mips_specific (filedata);
19687
19688 case EM_MSP430:
19689 return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
19690 display_msp430x_attribute,
19691 display_msp430_gnu_attribute);
19692
19693 case EM_RISCV:
19694 return process_attributes (filedata, "riscv", SHT_RISCV_ATTRIBUTES,
19695 display_riscv_attribute,
19696 display_generic_attribute);
19697
19698 case EM_NDS32:
19699 return process_nds32_specific (filedata);
19700
19701 case EM_PPC:
19702 case EM_PPC64:
19703 return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19704 display_power_gnu_attribute);
19705
19706 case EM_S390:
19707 case EM_S390_OLD:
19708 return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19709 display_s390_gnu_attribute);
19710
19711 case EM_SPARC:
19712 case EM_SPARC32PLUS:
19713 case EM_SPARCV9:
19714 return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19715 display_sparc_gnu_attribute);
19716
19717 case EM_TI_C6000:
19718 return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
19719 display_tic6x_attribute,
19720 display_generic_attribute);
19721
19722 default:
19723 return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
19724 display_public_gnu_attributes,
19725 display_generic_attribute);
19726 }
19727}
19728
19729static bfd_boolean
19730get_file_header (Filedata * filedata)
19731{
19732 /* Read in the identity array. */
19733 if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
19734 return FALSE;
19735
19736 /* Determine how to read the rest of the header. */
19737 switch (filedata->file_header.e_ident[EI_DATA])
19738 {
19739 default:
19740 case ELFDATANONE:
19741 case ELFDATA2LSB:
19742 byte_get = byte_get_little_endian;
19743 byte_put = byte_put_little_endian;
19744 break;
19745 case ELFDATA2MSB:
19746 byte_get = byte_get_big_endian;
19747 byte_put = byte_put_big_endian;
19748 break;
19749 }
19750
19751 /* For now we only support 32 bit and 64 bit ELF files. */
19752 is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
19753
19754 /* Read in the rest of the header. */
19755 if (is_32bit_elf)
19756 {
19757 Elf32_External_Ehdr ehdr32;
19758
19759 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
19760 return FALSE;
19761
19762 filedata->file_header.e_type = BYTE_GET (ehdr32.e_type);
19763 filedata->file_header.e_machine = BYTE_GET (ehdr32.e_machine);
19764 filedata->file_header.e_version = BYTE_GET (ehdr32.e_version);
19765 filedata->file_header.e_entry = BYTE_GET (ehdr32.e_entry);
19766 filedata->file_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
19767 filedata->file_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
19768 filedata->file_header.e_flags = BYTE_GET (ehdr32.e_flags);
19769 filedata->file_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
19770 filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
19771 filedata->file_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
19772 filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
19773 filedata->file_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
19774 filedata->file_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
19775 }
19776 else
19777 {
19778 Elf64_External_Ehdr ehdr64;
19779
19780 /* If we have been compiled with sizeof (bfd_vma) == 4, then
19781 we will not be able to cope with the 64bit data found in
19782 64 ELF files. Detect this now and abort before we start
19783 overwriting things. */
19784 if (sizeof (bfd_vma) < 8)
19785 {
19786 error (_("This instance of readelf has been built without support for a\n\
1978764 bit data type and so it cannot read 64 bit ELF files.\n"));
19788 return FALSE;
19789 }
19790
19791 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
19792 return FALSE;
19793
19794 filedata->file_header.e_type = BYTE_GET (ehdr64.e_type);
19795 filedata->file_header.e_machine = BYTE_GET (ehdr64.e_machine);
19796 filedata->file_header.e_version = BYTE_GET (ehdr64.e_version);
19797 filedata->file_header.e_entry = BYTE_GET (ehdr64.e_entry);
19798 filedata->file_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
19799 filedata->file_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
19800 filedata->file_header.e_flags = BYTE_GET (ehdr64.e_flags);
19801 filedata->file_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
19802 filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
19803 filedata->file_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
19804 filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
19805 filedata->file_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
19806 filedata->file_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
19807 }
19808
19809 if (filedata->file_header.e_shoff)
19810 {
19811 /* There may be some extensions in the first section header. Don't
19812 bomb if we can't read it. */
19813 if (is_32bit_elf)
19814 get_32bit_section_headers (filedata, TRUE);
19815 else
19816 get_64bit_section_headers (filedata, TRUE);
19817 }
19818
19819 return TRUE;
19820}
19821
19822static void
19823close_file (Filedata * filedata)
19824{
19825 if (filedata)
19826 {
19827 if (filedata->handle)
19828 fclose (filedata->handle);
19829 free (filedata);
19830 }
19831}
19832
19833void
19834close_debug_file (void * data)
19835{
19836 close_file ((Filedata *) data);
19837}
19838
19839static Filedata *
19840open_file (const char * pathname)
19841{
19842 struct stat statbuf;
19843 Filedata * filedata = NULL;
19844
19845 if (stat (pathname, & statbuf) < 0
19846 || ! S_ISREG (statbuf.st_mode))
19847 goto fail;
19848
19849 filedata = calloc (1, sizeof * filedata);
19850 if (filedata == NULL)
19851 goto fail;
19852
19853 filedata->handle = fopen (pathname, "rb");
19854 if (filedata->handle == NULL)
19855 goto fail;
19856
19857 filedata->file_size = (bfd_size_type) statbuf.st_size;
19858 filedata->file_name = pathname;
19859
19860 if (! get_file_header (filedata))
19861 goto fail;
19862
19863 if (filedata->file_header.e_shoff)
19864 {
19865 bfd_boolean res;
19866
19867 /* Read the section headers again, this time for real. */
19868 if (is_32bit_elf)
19869 res = get_32bit_section_headers (filedata, FALSE);
19870 else
19871 res = get_64bit_section_headers (filedata, FALSE);
19872
19873 if (!res)
19874 goto fail;
19875 }
19876
19877 return filedata;
19878
19879 fail:
19880 if (filedata)
19881 {
19882 if (filedata->handle)
19883 fclose (filedata->handle);
19884 free (filedata);
19885 }
19886 return NULL;
19887}
19888
19889void *
19890open_debug_file (const char * pathname)
19891{
19892 return open_file (pathname);
19893}
19894
19895/* Process one ELF object file according to the command line options.
19896 This file may actually be stored in an archive. The file is
19897 positioned at the start of the ELF object. Returns TRUE if no
19898 problems were encountered, FALSE otherwise. */
19899
19900static bfd_boolean
19901process_object (Filedata * filedata)
19902{
19903 bfd_boolean have_separate_files;
19904 unsigned int i;
19905 bfd_boolean res = TRUE;
19906
19907 if (! get_file_header (filedata))
19908 {
19909 error (_("%s: Failed to read file header\n"), filedata->file_name);
19910 return FALSE;
19911 }
19912
19913 /* Initialise per file variables. */
19914 for (i = ARRAY_SIZE (version_info); i--;)
19915 version_info[i] = 0;
19916
19917 for (i = ARRAY_SIZE (dynamic_info); i--;)
19918 dynamic_info[i] = 0;
19919 dynamic_info_DT_GNU_HASH = 0;
19920 dynamic_info_DT_MIPS_XHASH = 0;
19921
19922 /* Process the file. */
19923 if (show_name)
19924 printf (_("\nFile: %s\n"), filedata->file_name);
19925
19926 /* Initialise the dump_sects array from the cmdline_dump_sects array.
19927 Note we do this even if cmdline_dump_sects is empty because we
19928 must make sure that the dump_sets array is zeroed out before each
19929 object file is processed. */
19930 if (filedata->num_dump_sects > cmdline.num_dump_sects)
19931 memset (filedata->dump_sects, 0, filedata->num_dump_sects * sizeof (* filedata->dump_sects));
19932
19933 if (cmdline.num_dump_sects > 0)
19934 {
19935 if (filedata->num_dump_sects == 0)
19936 /* A sneaky way of allocating the dump_sects array. */
19937 request_dump_bynumber (filedata, cmdline.num_dump_sects, 0);
19938
19939 assert (filedata->num_dump_sects >= cmdline.num_dump_sects);
19940 memcpy (filedata->dump_sects, cmdline.dump_sects,
19941 cmdline.num_dump_sects * sizeof (* filedata->dump_sects));
19942 }
19943
19944 if (! process_file_header (filedata))
19945 return FALSE;
19946
19947 if (! process_section_headers (filedata))
19948 {
19949 /* Without loaded section headers we cannot process lots of things. */
19950 do_unwind = do_version = do_dump = do_arch = FALSE;
19951
19952 if (! do_using_dynamic)
19953 do_syms = do_dyn_syms = do_reloc = FALSE;
19954 }
19955
19956 if (! process_section_groups (filedata))
19957 /* Without loaded section groups we cannot process unwind. */
19958 do_unwind = FALSE;
19959
19960 if (process_program_headers (filedata))
19961 process_dynamic_section (filedata);
19962 else
19963 res = FALSE;
19964
19965 if (! process_relocs (filedata))
19966 res = FALSE;
19967
19968 if (! process_unwind (filedata))
19969 res = FALSE;
19970
19971 if (! process_symbol_table (filedata))
19972 res = FALSE;
19973
19974 if (! process_syminfo (filedata))
19975 res = FALSE;
19976
19977 if (! process_version_sections (filedata))
19978 res = FALSE;
19979
19980 if (filedata->file_header.e_shstrndx != SHN_UNDEF)
19981 have_separate_files = load_separate_debug_files (filedata, filedata->file_name);
19982 else
19983 have_separate_files = FALSE;
19984
19985 if (! process_section_contents (filedata))
19986 res = FALSE;
19987
19988 if (have_separate_files)
19989 {
19990 separate_info * d;
19991
19992 for (d = first_separate_info; d != NULL; d = d->next)
19993 {
19994 if (! process_section_headers (d->handle))
19995 res = FALSE;
19996 else if (! process_section_contents (d->handle))
19997 res = FALSE;
19998 }
19999
20000 /* The file handles are closed by the call to free_debug_memory() below. */
20001 }
20002
20003 if (! process_notes (filedata))
20004 res = FALSE;
20005
20006 if (! process_gnu_liblist (filedata))
20007 res = FALSE;
20008
20009 if (! process_arch_specific (filedata))
20010 res = FALSE;
20011
20012 free (filedata->program_headers);
20013 filedata->program_headers = NULL;
20014
20015 free (filedata->section_headers);
20016 filedata->section_headers = NULL;
20017
20018 free (filedata->string_table);
20019 filedata->string_table = NULL;
20020 filedata->string_table_length = 0;
20021
20022 if (filedata->dump_sects != NULL)
20023 {
20024 free (filedata->dump_sects);
20025 filedata->dump_sects = NULL;
20026 filedata->num_dump_sects = 0;
20027 }
20028
20029 if (dynamic_strings)
20030 {
20031 free (dynamic_strings);
20032 dynamic_strings = NULL;
20033 dynamic_strings_length = 0;
20034 }
20035
20036 if (dynamic_symbols)
20037 {
20038 free (dynamic_symbols);
20039 dynamic_symbols = NULL;
20040 num_dynamic_syms = 0;
20041 }
20042
20043 if (dynamic_syminfo)
20044 {
20045 free (dynamic_syminfo);
20046 dynamic_syminfo = NULL;
20047 }
20048
20049 if (dynamic_section)
20050 {
20051 free (dynamic_section);
20052 dynamic_section = NULL;
20053 }
20054
20055 if (section_headers_groups)
20056 {
20057 free (section_headers_groups);
20058 section_headers_groups = NULL;
20059 }
20060
20061 if (section_groups)
20062 {
20063 struct group_list * g;
20064 struct group_list * next;
20065
20066 for (i = 0; i < group_count; i++)
20067 {
20068 for (g = section_groups [i].root; g != NULL; g = next)
20069 {
20070 next = g->next;
20071 free (g);
20072 }
20073 }
20074
20075 free (section_groups);
20076 section_groups = NULL;
20077 }
20078
20079 free_debug_memory ();
20080
20081 return res;
20082}
20083
20084/* Process an ELF archive.
20085 On entry the file is positioned just after the ARMAG string.
20086 Returns TRUE upon success, FALSE otherwise. */
20087
20088static bfd_boolean
20089process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
20090{
20091 struct archive_info arch;
20092 struct archive_info nested_arch;
20093 size_t got;
20094 bfd_boolean ret = TRUE;
20095
20096 show_name = TRUE;
20097
20098 /* The ARCH structure is used to hold information about this archive. */
20099 arch.file_name = NULL;
20100 arch.file = NULL;
20101 arch.index_array = NULL;
20102 arch.sym_table = NULL;
20103 arch.longnames = NULL;
20104
20105 /* The NESTED_ARCH structure is used as a single-item cache of information
20106 about a nested archive (when members of a thin archive reside within
20107 another regular archive file). */
20108 nested_arch.file_name = NULL;
20109 nested_arch.file = NULL;
20110 nested_arch.index_array = NULL;
20111 nested_arch.sym_table = NULL;
20112 nested_arch.longnames = NULL;
20113
20114 if (setup_archive (&arch, filedata->file_name, filedata->handle,
20115 is_thin_archive, do_archive_index) != 0)
20116 {
20117 ret = FALSE;
20118 goto out;
20119 }
20120
20121 if (do_archive_index)
20122 {
20123 if (arch.sym_table == NULL)
20124 error (_("%s: unable to dump the index as none was found\n"), filedata->file_name);
20125 else
20126 {
20127 unsigned long i, l;
20128 unsigned long current_pos;
20129
20130 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
20131 filedata->file_name, (unsigned long) arch.index_num, arch.sym_size);
20132
20133 current_pos = ftell (filedata->handle);
20134
20135 for (i = l = 0; i < arch.index_num; i++)
20136 {
20137 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
20138 {
20139 char * member_name;
20140
20141 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
20142
20143 if (member_name != NULL)
20144 {
20145 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
20146
20147 if (qualified_name != NULL)
20148 {
20149 printf (_("Contents of binary %s at offset "), qualified_name);
20150 (void) print_vma (arch.index_array[i], PREFIX_HEX);
20151 putchar ('\n');
20152 free (qualified_name);
20153 }
20154 }
20155 }
20156
20157 if (l >= arch.sym_size)
20158 {
20159 error (_("%s: end of the symbol table reached before the end of the index\n"),
20160 filedata->file_name);
20161 ret = FALSE;
20162 break;
20163 }
20164 /* PR 17531: file: 0b6630b2. */
20165 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
20166 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
20167 }
20168
20169 if (arch.uses_64bit_indices)
20170 l = (l + 7) & ~ 7;
20171 else
20172 l += l & 1;
20173
20174 if (l < arch.sym_size)
20175 {
20176 error (ngettext ("%s: %ld byte remains in the symbol table, "
20177 "but without corresponding entries in "
20178 "the index table\n",
20179 "%s: %ld bytes remain in the symbol table, "
20180 "but without corresponding entries in "
20181 "the index table\n",
20182 arch.sym_size - l),
20183 filedata->file_name, arch.sym_size - l);
20184 ret = FALSE;
20185 }
20186
20187 if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
20188 {
20189 error (_("%s: failed to seek back to start of object files in the archive\n"),
20190 filedata->file_name);
20191 ret = FALSE;
20192 goto out;
20193 }
20194 }
20195
20196 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
20197 && !do_segments && !do_header && !do_dump && !do_version
20198 && !do_histogram && !do_debugging && !do_arch && !do_notes
20199 && !do_section_groups && !do_dyn_syms)
20200 {
20201 ret = TRUE; /* Archive index only. */
20202 goto out;
20203 }
20204 }
20205
20206 while (1)
20207 {
20208 char * name;
20209 size_t namelen;
20210 char * qualified_name;
20211
20212 /* Read the next archive header. */
20213 if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
20214 {
20215 error (_("%s: failed to seek to next archive header\n"), arch.file_name);
20216 return FALSE;
20217 }
20218 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
20219 if (got != sizeof arch.arhdr)
20220 {
20221 if (got == 0)
20222 break;
20223 /* PR 24049 - we cannot use filedata->file_name as this will
20224 have already been freed. */
20225 error (_("%s: failed to read archive header\n"), arch.file_name);
20226
20227 ret = FALSE;
20228 break;
20229 }
20230 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
20231 {
20232 error (_("%s: did not find a valid archive header\n"), arch.file_name);
20233 ret = FALSE;
20234 break;
20235 }
20236
20237 arch.next_arhdr_offset += sizeof arch.arhdr;
20238
20239 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
20240 if (archive_file_size & 01)
20241 ++archive_file_size;
20242
20243 name = get_archive_member_name (&arch, &nested_arch);
20244 if (name == NULL)
20245 {
20246 error (_("%s: bad archive file name\n"), arch.file_name);
20247 ret = FALSE;
20248 break;
20249 }
20250 namelen = strlen (name);
20251
20252 qualified_name = make_qualified_name (&arch, &nested_arch, name);
20253 if (qualified_name == NULL)
20254 {
20255 error (_("%s: bad archive file name\n"), arch.file_name);
20256 ret = FALSE;
20257 break;
20258 }
20259
20260 if (is_thin_archive && arch.nested_member_origin == 0)
20261 {
20262 /* This is a proxy for an external member of a thin archive. */
20263 Filedata * member_filedata;
20264 char * member_file_name = adjust_relative_path
20265 (filedata->file_name, name, namelen);
20266
20267 if (member_file_name == NULL)
20268 {
20269 ret = FALSE;
20270 break;
20271 }
20272
20273 member_filedata = open_file (member_file_name);
20274 if (member_filedata == NULL)
20275 {
20276 error (_("Input file '%s' is not readable.\n"), member_file_name);
20277 free (member_file_name);
20278 ret = FALSE;
20279 break;
20280 }
20281
20282 archive_file_offset = arch.nested_member_origin;
20283 member_filedata->file_name = qualified_name;
20284
20285 if (! process_object (member_filedata))
20286 ret = FALSE;
20287
20288 close_file (member_filedata);
20289 free (member_file_name);
20290 }
20291 else if (is_thin_archive)
20292 {
20293 Filedata thin_filedata;
20294
20295 memset (&thin_filedata, 0, sizeof (thin_filedata));
20296
20297 /* PR 15140: Allow for corrupt thin archives. */
20298 if (nested_arch.file == NULL)
20299 {
20300 error (_("%s: contains corrupt thin archive: %s\n"),
20301 qualified_name, name);
20302 ret = FALSE;
20303 break;
20304 }
20305
20306 /* This is a proxy for a member of a nested archive. */
20307 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
20308
20309 /* The nested archive file will have been opened and setup by
20310 get_archive_member_name. */
20311 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
20312 {
20313 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
20314 ret = FALSE;
20315 break;
20316 }
20317
20318 thin_filedata.handle = nested_arch.file;
20319 thin_filedata.file_name = qualified_name;
20320
20321 if (! process_object (& thin_filedata))
20322 ret = FALSE;
20323 }
20324 else
20325 {
20326 archive_file_offset = arch.next_arhdr_offset;
20327 arch.next_arhdr_offset += archive_file_size;
20328
20329 filedata->file_name = qualified_name;
20330 if (! process_object (filedata))
20331 ret = FALSE;
20332 }
20333
20334 free (qualified_name);
20335 }
20336
20337 out:
20338 if (nested_arch.file != NULL)
20339 fclose (nested_arch.file);
20340 release_archive (&nested_arch);
20341 release_archive (&arch);
20342
20343 return ret;
20344}
20345
20346static bfd_boolean
20347process_file (char * file_name)
20348{
20349 Filedata * filedata = NULL;
20350 struct stat statbuf;
20351 char armag[SARMAG];
20352 bfd_boolean ret = TRUE;
20353
20354 if (stat (file_name, &statbuf) < 0)
20355 {
20356 if (errno == ENOENT)
20357 error (_("'%s': No such file\n"), file_name);
20358 else
20359 error (_("Could not locate '%s'. System error message: %s\n"),
20360 file_name, strerror (errno));
20361 return FALSE;
20362 }
20363
20364 if (! S_ISREG (statbuf.st_mode))
20365 {
20366 error (_("'%s' is not an ordinary file\n"), file_name);
20367 return FALSE;
20368 }
20369
20370 filedata = calloc (1, sizeof * filedata);
20371 if (filedata == NULL)
20372 {
20373 error (_("Out of memory allocating file data structure\n"));
20374 return FALSE;
20375 }
20376
20377 filedata->file_name = file_name;
20378 filedata->handle = fopen (file_name, "rb");
20379 if (filedata->handle == NULL)
20380 {
20381 error (_("Input file '%s' is not readable.\n"), file_name);
20382 free (filedata);
20383 return FALSE;
20384 }
20385
20386 if (fread (armag, SARMAG, 1, filedata->handle) != 1)
20387 {
20388 error (_("%s: Failed to read file's magic number\n"), file_name);
20389 fclose (filedata->handle);
20390 free (filedata);
20391 return FALSE;
20392 }
20393
20394 filedata->file_size = (bfd_size_type) statbuf.st_size;
20395
20396 if (memcmp (armag, ARMAG, SARMAG) == 0)
20397 {
20398 if (! process_archive (filedata, FALSE))
20399 ret = FALSE;
20400 }
20401 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
20402 {
20403 if ( ! process_archive (filedata, TRUE))
20404 ret = FALSE;
20405 }
20406 else
20407 {
20408 if (do_archive_index)
20409 error (_("File %s is not an archive so its index cannot be displayed.\n"),
20410 file_name);
20411
20412 rewind (filedata->handle);
20413 archive_file_size = archive_file_offset = 0;
20414
20415 if (! process_object (filedata))
20416 ret = FALSE;
20417 }
20418
20419 fclose (filedata->handle);
20420 free (filedata);
20421
20422 return ret;
20423}
20424
20425#ifdef SUPPORT_DISASSEMBLY
20426/* Needed by the i386 disassembler. For extra credit, someone could
20427 fix this so that we insert symbolic addresses here, esp for GOT/PLT
20428 symbols. */
20429
20430void
20431print_address (unsigned int addr, FILE * outfile)
20432{
20433 fprintf (outfile,"0x%8.8x", addr);
20434}
20435
20436/* Needed by the i386 disassembler. */
20437
20438void
20439db_task_printsym (unsigned int addr)
20440{
20441 print_address (addr, stderr);
20442}
20443#endif
20444
20445int
20446main (int argc, char ** argv)
20447{
20448 int err;
20449
20450#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20451 setlocale (LC_MESSAGES, "");
20452#endif
20453#if defined (HAVE_SETLOCALE)
20454 setlocale (LC_CTYPE, "");
20455#endif
20456 bindtextdomain (PACKAGE, LOCALEDIR);
20457 textdomain (PACKAGE);
20458
20459 expandargv (&argc, &argv);
20460
20461 cmdline.file_name = "<cmdline>";
20462 parse_args (& cmdline, argc, argv);
20463
20464 if (optind < (argc - 1))
20465 show_name = TRUE;
20466 else if (optind >= argc)
20467 {
20468 warn (_("Nothing to do.\n"));
20469 usage (stderr);
20470 }
20471
20472 err = FALSE;
20473 while (optind < argc)
20474 if (! process_file (argv[optind++]))
20475 err = TRUE;
20476
20477 if (cmdline.dump_sects != NULL)
20478 free (cmdline.dump_sects);
20479
20480 free (dump_ctf_symtab_name);
20481 free (dump_ctf_strtab_name);
20482 free (dump_ctf_parent_name);
20483
20484 return err ? EXIT_FAILURE : EXIT_SUCCESS;
20485}
A mirror of the official binutils-gdb repository