projects / deliverable / binutils-gdb.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Automatic date update in version.in
[deliverable/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
200/* A dynamic array of flags indicating for which sections a dump
201 has been requested via command line switches. */
202struct dump_data {
203 dump_type * dump_sects;
204 unsigned int num_dump_sects;
205};
206
207static struct dump_data cmdline;
208
209static struct dump_list_entry * dump_sects_byname;
210
211char * program_name = "readelf";
212
213static bfd_boolean show_name = FALSE;
214static bfd_boolean do_dynamic = FALSE;
215static bfd_boolean do_syms = FALSE;
216static bfd_boolean do_dyn_syms = FALSE;
217static bfd_boolean do_reloc = FALSE;
218static bfd_boolean do_sections = FALSE;
219static bfd_boolean do_section_groups = FALSE;
220static bfd_boolean do_section_details = FALSE;
221static bfd_boolean do_segments = FALSE;
222static bfd_boolean do_unwind = FALSE;
223static bfd_boolean do_using_dynamic = FALSE;
224static bfd_boolean do_header = FALSE;
225static bfd_boolean do_dump = FALSE;
226static bfd_boolean do_version = FALSE;
227static bfd_boolean do_histogram = FALSE;
228static bfd_boolean do_debugging = FALSE;
229static bfd_boolean do_ctf = FALSE;
230static bfd_boolean do_arch = FALSE;
231static bfd_boolean do_notes = FALSE;
232static bfd_boolean do_archive_index = FALSE;
233static bfd_boolean is_32bit_elf = FALSE;
234static bfd_boolean decompress_dumps = FALSE;
235
236static char *dump_ctf_parent_name;
237static char *dump_ctf_symtab_name;
238static char *dump_ctf_strtab_name;
239
240struct group_list
241{
242 struct group_list * next;
243 unsigned int section_index;
244};
245
246struct group
247{
248 struct group_list * root;
249 unsigned int group_index;
250};
251
252typedef struct filedata
253{
254 const char * file_name;
255 FILE * handle;
256 bfd_size_type file_size;
257 Elf_Internal_Ehdr file_header;
258 Elf_Internal_Shdr * section_headers;
259 Elf_Internal_Phdr * program_headers;
260 char * string_table;
261 unsigned long string_table_length;
262 unsigned long archive_file_offset;
263 unsigned long archive_file_size;
264 unsigned long dynamic_addr;
265 bfd_size_type dynamic_size;
266 size_t dynamic_nent;
267 Elf_Internal_Dyn * dynamic_section;
268 char * dynamic_strings;
269 unsigned long dynamic_strings_length;
270 unsigned long num_dynamic_syms;
271 Elf_Internal_Sym * dynamic_symbols;
272 bfd_vma version_info[16];
273 unsigned int dynamic_syminfo_nent;
274 Elf_Internal_Syminfo * dynamic_syminfo;
275 unsigned long dynamic_syminfo_offset;
276 bfd_size_type nbuckets;
277 bfd_size_type nchains;
278 bfd_vma * buckets;
279 bfd_vma * chains;
280 bfd_size_type ngnubuckets;
281 bfd_size_type ngnuchains;
282 bfd_vma * gnubuckets;
283 bfd_vma * gnuchains;
284 bfd_vma * mipsxlat;
285 bfd_vma gnusymidx;
286 char program_interpreter[PATH_MAX];
287 bfd_vma dynamic_info[DT_ENCODING];
288 bfd_vma dynamic_info_DT_GNU_HASH;
289 bfd_vma dynamic_info_DT_MIPS_XHASH;
290 elf_section_list * symtab_shndx_list;
291 size_t group_count;
292 struct group * section_groups;
293 struct group ** section_headers_groups;
294 /* A dynamic array of flags indicating for which sections a dump of
295 some kind has been requested. It is reset on a per-object file
296 basis and then initialised from the cmdline_dump_sects array,
297 the results of interpreting the -w switch, and the
298 dump_sects_byname list. */
299 struct dump_data dump;
300} Filedata;
301
302/* How to print a vma value. */
303typedef enum print_mode
304{
305 HEX,
306 DEC,
307 DEC_5,
308 UNSIGNED,
309 PREFIX_HEX,
310 FULL_HEX,
311 LONG_HEX
312}
313print_mode;
314
315/* Versioned symbol info. */
316enum versioned_symbol_info
317{
318 symbol_undefined,
319 symbol_hidden,
320 symbol_public
321};
322
323static const char * get_symbol_version_string
324 (Filedata *, bfd_boolean, const char *, unsigned long, unsigned,
325 Elf_Internal_Sym *, enum versioned_symbol_info *, unsigned short *);
326
327#define UNKNOWN -1
328
329#define SECTION_NAME(X) \
330 ((X) == NULL ? _("<none>") \
331 : filedata->string_table == NULL ? _("<no-strings>") \
332 : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>") \
333 : filedata->string_table + (X)->sh_name))
334
335#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
336
337#define GET_ELF_SYMBOLS(file, section, sym_count) \
338 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
339 : get_64bit_elf_symbols (file, section, sym_count))
340
341#define VALID_SYMBOL_NAME(strtab, strtab_size, offset) \
342 (strtab != NULL && offset < strtab_size)
343#define VALID_DYNAMIC_NAME(filedata, offset) \
344 VALID_SYMBOL_NAME (filedata->dynamic_strings, \
345 filedata->dynamic_strings_length, offset)
346/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
347 already been called and verified that the string exists. */
348#define GET_DYNAMIC_NAME(filedata, offset) \
349 (filedata->dynamic_strings + offset)
350
351#define REMOVE_ARCH_BITS(ADDR) \
352 do \
353 { \
354 if (filedata->file_header.e_machine == EM_ARM) \
355 (ADDR) &= ~1; \
356 } \
357 while (0)
358
359/* Get the correct GNU hash section name. */
360#define GNU_HASH_SECTION_NAME(filedata) \
361 filedata->dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
362\f
363/* Print a BFD_VMA to an internal buffer, for use in error messages.
364 BFD_FMA_FMT can't be used in translated strings. */
365
366static const char *
367bfd_vmatoa (char *fmtch, bfd_vma value)
368{
369 /* bfd_vmatoa is used more then once in a printf call for output.
370 Cycle through an array of buffers. */
371 static int buf_pos = 0;
372 static struct bfd_vmatoa_buf
373 {
374 char place[64];
375 } buf[4];
376 char *ret;
377 char fmt[32];
378
379 ret = buf[buf_pos++].place;
380 buf_pos %= ARRAY_SIZE (buf);
381
382 sprintf (fmt, "%%%s%s", BFD_VMA_FMT, fmtch);
383 snprintf (ret, sizeof (buf[0].place), fmt, value);
384 return ret;
385}
386
387/* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
388 OFFSET + the offset of the current archive member, if we are examining an
389 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
390 allocate a buffer using malloc and fill that. In either case return the
391 pointer to the start of the retrieved data or NULL if something went wrong.
392 If something does go wrong and REASON is not NULL then emit an error
393 message using REASON as part of the context. */
394
395static void *
396get_data (void * var,
397 Filedata * filedata,
398 unsigned long offset,
399 bfd_size_type size,
400 bfd_size_type nmemb,
401 const char * reason)
402{
403 void * mvar;
404 bfd_size_type amt = size * nmemb;
405
406 if (size == 0 || nmemb == 0)
407 return NULL;
408
409 /* If the size_t type is smaller than the bfd_size_type, eg because
410 you are building a 32-bit tool on a 64-bit host, then make sure
411 that when the sizes are cast to (size_t) no information is lost. */
412 if ((size_t) size != size
413 || (size_t) nmemb != nmemb
414 || (size_t) amt != amt)
415 {
416 if (reason)
417 error (_("Size truncation prevents reading %s"
418 " elements of size %s for %s\n"),
419 bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
420 return NULL;
421 }
422
423 /* Check for size overflow. */
424 if (amt / size != nmemb || (size_t) amt + 1 == 0)
425 {
426 if (reason)
427 error (_("Size overflow prevents reading %s"
428 " elements of size %s for %s\n"),
429 bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
430 return NULL;
431 }
432
433 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
434 attempting to allocate memory when the read is bound to fail. */
435 if (filedata->archive_file_offset > filedata->file_size
436 || offset > filedata->file_size - filedata->archive_file_offset
437 || amt > filedata->file_size - filedata->archive_file_offset - offset)
438 {
439 if (reason)
440 error (_("Reading %s bytes extends past end of file for %s\n"),
441 bfd_vmatoa ("u", amt), reason);
442 return NULL;
443 }
444
445 if (fseek (filedata->handle, filedata->archive_file_offset + offset,
446 SEEK_SET))
447 {
448 if (reason)
449 error (_("Unable to seek to 0x%lx for %s\n"),
450 filedata->archive_file_offset + offset, reason);
451 return NULL;
452 }
453
454 mvar = var;
455 if (mvar == NULL)
456 {
457 /* + 1 so that we can '\0' terminate invalid string table sections. */
458 mvar = malloc ((size_t) amt + 1);
459
460 if (mvar == NULL)
461 {
462 if (reason)
463 error (_("Out of memory allocating %s bytes for %s\n"),
464 bfd_vmatoa ("u", amt), reason);
465 return NULL;
466 }
467
468 ((char *) mvar)[amt] = '\0';
469 }
470
471 if (fread (mvar, (size_t) size, (size_t) nmemb, filedata->handle) != nmemb)
472 {
473 if (reason)
474 error (_("Unable to read in %s bytes of %s\n"),
475 bfd_vmatoa ("u", amt), reason);
476 if (mvar != var)
477 free (mvar);
478 return NULL;
479 }
480
481 return mvar;
482}
483
484/* Print a VMA value in the MODE specified.
485 Returns the number of characters displayed. */
486
487static unsigned int
488print_vma (bfd_vma vma, print_mode mode)
489{
490 unsigned int nc = 0;
491
492 switch (mode)
493 {
494 case FULL_HEX:
495 nc = printf ("0x");
496 /* Fall through. */
497 case LONG_HEX:
498#ifdef BFD64
499 if (is_32bit_elf)
500 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
501#endif
502 printf_vma (vma);
503 return nc + 16;
504
505 case DEC_5:
506 if (vma <= 99999)
507 return printf ("%5" BFD_VMA_FMT "d", vma);
508 /* Fall through. */
509 case PREFIX_HEX:
510 nc = printf ("0x");
511 /* Fall through. */
512 case HEX:
513 return nc + printf ("%" BFD_VMA_FMT "x", vma);
514
515 case DEC:
516 return printf ("%" BFD_VMA_FMT "d", vma);
517
518 case UNSIGNED:
519 return printf ("%" BFD_VMA_FMT "u", vma);
520
521 default:
522 /* FIXME: Report unrecognised mode ? */
523 return 0;
524 }
525}
526
527/* Display a symbol on stdout. Handles the display of control characters and
528 multibye characters (assuming the host environment supports them).
529
530 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
531
532 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
533 padding as necessary.
534
535 Returns the number of emitted characters. */
536
537static unsigned int
538print_symbol (signed int width, const char *symbol)
539{
540 bfd_boolean extra_padding = FALSE;
541 signed int num_printed = 0;
542#ifdef HAVE_MBSTATE_T
543 mbstate_t state;
544#endif
545 unsigned int width_remaining;
546
547 if (width < 0)
548 {
549 /* Keep the width positive. This helps the code below. */
550 width = - width;
551 extra_padding = TRUE;
552 }
553 else if (width == 0)
554 return 0;
555
556 if (do_wide)
557 /* Set the remaining width to a very large value.
558 This simplifies the code below. */
559 width_remaining = INT_MAX;
560 else
561 width_remaining = width;
562
563#ifdef HAVE_MBSTATE_T
564 /* Initialise the multibyte conversion state. */
565 memset (& state, 0, sizeof (state));
566#endif
567
568 while (width_remaining)
569 {
570 size_t n;
571 const char c = *symbol++;
572
573 if (c == 0)
574 break;
575
576 /* Do not print control characters directly as they can affect terminal
577 settings. Such characters usually appear in the names generated
578 by the assembler for local labels. */
579 if (ISCNTRL (c))
580 {
581 if (width_remaining < 2)
582 break;
583
584 printf ("^%c", c + 0x40);
585 width_remaining -= 2;
586 num_printed += 2;
587 }
588 else if (ISPRINT (c))
589 {
590 putchar (c);
591 width_remaining --;
592 num_printed ++;
593 }
594 else
595 {
596#ifdef HAVE_MBSTATE_T
597 wchar_t w;
598#endif
599 /* Let printf do the hard work of displaying multibyte characters. */
600 printf ("%.1s", symbol - 1);
601 width_remaining --;
602 num_printed ++;
603
604#ifdef HAVE_MBSTATE_T
605 /* Try to find out how many bytes made up the character that was
606 just printed. Advance the symbol pointer past the bytes that
607 were displayed. */
608 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
609#else
610 n = 1;
611#endif
612 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
613 symbol += (n - 1);
614 }
615 }
616
617 if (extra_padding && num_printed < width)
618 {
619 /* Fill in the remaining spaces. */
620 printf ("%-*s", width - num_printed, " ");
621 num_printed = width;
622 }
623
624 return num_printed;
625}
626
627/* Returns a pointer to a static buffer containing a printable version of
628 the given section's name. Like print_symbol, except that it does not try
629 to print multibyte characters, it just interprets them as hex values. */
630
631static const char *
632printable_section_name (Filedata * filedata, const Elf_Internal_Shdr * sec)
633{
634#define MAX_PRINT_SEC_NAME_LEN 128
635 static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
636 const char * name = SECTION_NAME (sec);
637 char * buf = sec_name_buf;
638 char c;
639 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
640
641 while ((c = * name ++) != 0)
642 {
643 if (ISCNTRL (c))
644 {
645 if (remaining < 2)
646 break;
647
648 * buf ++ = '^';
649 * buf ++ = c + 0x40;
650 remaining -= 2;
651 }
652 else if (ISPRINT (c))
653 {
654 * buf ++ = c;
655 remaining -= 1;
656 }
657 else
658 {
659 static char hex[17] = "0123456789ABCDEF";
660
661 if (remaining < 4)
662 break;
663 * buf ++ = '<';
664 * buf ++ = hex[(c & 0xf0) >> 4];
665 * buf ++ = hex[c & 0x0f];
666 * buf ++ = '>';
667 remaining -= 4;
668 }
669
670 if (remaining == 0)
671 break;
672 }
673
674 * buf = 0;
675 return sec_name_buf;
676}
677
678static const char *
679printable_section_name_from_index (Filedata * filedata, unsigned long ndx)
680{
681 if (ndx >= filedata->file_header.e_shnum)
682 return _("<corrupt>");
683
684 return printable_section_name (filedata, filedata->section_headers + ndx);
685}
686
687/* Return a pointer to section NAME, or NULL if no such section exists. */
688
689static Elf_Internal_Shdr *
690find_section (Filedata * filedata, const char * name)
691{
692 unsigned int i;
693
694 if (filedata->section_headers == NULL)
695 return NULL;
696
697 for (i = 0; i < filedata->file_header.e_shnum; i++)
698 if (streq (SECTION_NAME (filedata->section_headers + i), name))
699 return filedata->section_headers + i;
700
701 return NULL;
702}
703
704/* Return a pointer to a section containing ADDR, or NULL if no such
705 section exists. */
706
707static Elf_Internal_Shdr *
708find_section_by_address (Filedata * filedata, bfd_vma addr)
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 (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
720 return sec;
721 }
722
723 return NULL;
724}
725
726static Elf_Internal_Shdr *
727find_section_by_type (Filedata * filedata, unsigned int type)
728{
729 unsigned int i;
730
731 if (filedata->section_headers == NULL)
732 return NULL;
733
734 for (i = 0; i < filedata->file_header.e_shnum; i++)
735 {
736 Elf_Internal_Shdr *sec = filedata->section_headers + i;
737
738 if (sec->sh_type == type)
739 return sec;
740 }
741
742 return NULL;
743}
744
745/* Return a pointer to section NAME, or NULL if no such section exists,
746 restricted to the list of sections given in SET. */
747
748static Elf_Internal_Shdr *
749find_section_in_set (Filedata * filedata, const char * name, unsigned int * set)
750{
751 unsigned int i;
752
753 if (filedata->section_headers == NULL)
754 return NULL;
755
756 if (set != NULL)
757 {
758 while ((i = *set++) > 0)
759 {
760 /* See PR 21156 for a reproducer. */
761 if (i >= filedata->file_header.e_shnum)
762 continue; /* FIXME: Should we issue an error message ? */
763
764 if (streq (SECTION_NAME (filedata->section_headers + i), name))
765 return filedata->section_headers + i;
766 }
767 }
768
769 return find_section (filedata, name);
770}
771
772/* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
773 This OS has so many departures from the ELF standard that we test it at
774 many places. */
775
776static inline bfd_boolean
777is_ia64_vms (Filedata * filedata)
778{
779 return filedata->file_header.e_machine == EM_IA_64
780 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
781}
782
783/* Guess the relocation size commonly used by the specific machines. */
784
785static bfd_boolean
786guess_is_rela (unsigned int e_machine)
787{
788 switch (e_machine)
789 {
790 /* Targets that use REL relocations. */
791 case EM_386:
792 case EM_IAMCU:
793 case EM_960:
794 case EM_ARM:
795 case EM_D10V:
796 case EM_CYGNUS_D10V:
797 case EM_DLX:
798 case EM_MIPS:
799 case EM_MIPS_RS3_LE:
800 case EM_CYGNUS_M32R:
801 case EM_SCORE:
802 case EM_XGATE:
803 case EM_NFP:
804 case EM_BPF:
805 return FALSE;
806
807 /* Targets that use RELA relocations. */
808 case EM_68K:
809 case EM_860:
810 case EM_AARCH64:
811 case EM_ADAPTEVA_EPIPHANY:
812 case EM_ALPHA:
813 case EM_ALTERA_NIOS2:
814 case EM_ARC:
815 case EM_ARC_COMPACT:
816 case EM_ARC_COMPACT2:
817 case EM_AVR:
818 case EM_AVR_OLD:
819 case EM_BLACKFIN:
820 case EM_CR16:
821 case EM_CRIS:
822 case EM_CRX:
823 case EM_CSKY:
824 case EM_D30V:
825 case EM_CYGNUS_D30V:
826 case EM_FR30:
827 case EM_FT32:
828 case EM_CYGNUS_FR30:
829 case EM_CYGNUS_FRV:
830 case EM_H8S:
831 case EM_H8_300:
832 case EM_H8_300H:
833 case EM_IA_64:
834 case EM_IP2K:
835 case EM_IP2K_OLD:
836 case EM_IQ2000:
837 case EM_LATTICEMICO32:
838 case EM_M32C_OLD:
839 case EM_M32C:
840 case EM_M32R:
841 case EM_MCORE:
842 case EM_CYGNUS_MEP:
843 case EM_METAG:
844 case EM_MMIX:
845 case EM_MN10200:
846 case EM_CYGNUS_MN10200:
847 case EM_MN10300:
848 case EM_CYGNUS_MN10300:
849 case EM_MOXIE:
850 case EM_MSP430:
851 case EM_MSP430_OLD:
852 case EM_MT:
853 case EM_NDS32:
854 case EM_NIOS32:
855 case EM_OR1K:
856 case EM_PPC64:
857 case EM_PPC:
858 case EM_TI_PRU:
859 case EM_RISCV:
860 case EM_RL78:
861 case EM_RX:
862 case EM_S390:
863 case EM_S390_OLD:
864 case EM_SH:
865 case EM_SPARC:
866 case EM_SPARC32PLUS:
867 case EM_SPARCV9:
868 case EM_SPU:
869 case EM_TI_C6000:
870 case EM_TILEGX:
871 case EM_TILEPRO:
872 case EM_V800:
873 case EM_V850:
874 case EM_CYGNUS_V850:
875 case EM_VAX:
876 case EM_VISIUM:
877 case EM_X86_64:
878 case EM_L1OM:
879 case EM_K1OM:
880 case EM_XSTORMY16:
881 case EM_XTENSA:
882 case EM_XTENSA_OLD:
883 case EM_MICROBLAZE:
884 case EM_MICROBLAZE_OLD:
885 case EM_WEBASSEMBLY:
886 return TRUE;
887
888 case EM_68HC05:
889 case EM_68HC08:
890 case EM_68HC11:
891 case EM_68HC16:
892 case EM_FX66:
893 case EM_ME16:
894 case EM_MMA:
895 case EM_NCPU:
896 case EM_NDR1:
897 case EM_PCP:
898 case EM_ST100:
899 case EM_ST19:
900 case EM_ST7:
901 case EM_ST9PLUS:
902 case EM_STARCORE:
903 case EM_SVX:
904 case EM_TINYJ:
905 default:
906 warn (_("Don't know about relocations on this machine architecture\n"));
907 return FALSE;
908 }
909}
910
911/* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
912 Returns TRUE upon success, FALSE otherwise. If successful then a
913 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
914 and the number of relocs loaded is placed in *NRELASP. It is the caller's
915 responsibility to free the allocated buffer. */
916
917static bfd_boolean
918slurp_rela_relocs (Filedata * filedata,
919 unsigned long rel_offset,
920 unsigned long rel_size,
921 Elf_Internal_Rela ** relasp,
922 unsigned long * nrelasp)
923{
924 Elf_Internal_Rela * relas;
925 size_t nrelas;
926 unsigned int i;
927
928 if (is_32bit_elf)
929 {
930 Elf32_External_Rela * erelas;
931
932 erelas = (Elf32_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
933 rel_size, _("32-bit relocation data"));
934 if (!erelas)
935 return FALSE;
936
937 nrelas = rel_size / sizeof (Elf32_External_Rela);
938
939 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
940 sizeof (Elf_Internal_Rela));
941
942 if (relas == NULL)
943 {
944 free (erelas);
945 error (_("out of memory parsing relocs\n"));
946 return FALSE;
947 }
948
949 for (i = 0; i < nrelas; i++)
950 {
951 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
952 relas[i].r_info = BYTE_GET (erelas[i].r_info);
953 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
954 }
955
956 free (erelas);
957 }
958 else
959 {
960 Elf64_External_Rela * erelas;
961
962 erelas = (Elf64_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
963 rel_size, _("64-bit relocation data"));
964 if (!erelas)
965 return FALSE;
966
967 nrelas = rel_size / sizeof (Elf64_External_Rela);
968
969 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
970 sizeof (Elf_Internal_Rela));
971
972 if (relas == NULL)
973 {
974 free (erelas);
975 error (_("out of memory parsing relocs\n"));
976 return FALSE;
977 }
978
979 for (i = 0; i < nrelas; i++)
980 {
981 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
982 relas[i].r_info = BYTE_GET (erelas[i].r_info);
983 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
984
985 /* The #ifdef BFD64 below is to prevent a compile time
986 warning. We know that if we do not have a 64 bit data
987 type that we will never execute this code anyway. */
988#ifdef BFD64
989 if (filedata->file_header.e_machine == EM_MIPS
990 && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
991 {
992 /* In little-endian objects, r_info isn't really a
993 64-bit little-endian value: it has a 32-bit
994 little-endian symbol index followed by four
995 individual byte fields. Reorder INFO
996 accordingly. */
997 bfd_vma inf = relas[i].r_info;
998 inf = (((inf & 0xffffffff) << 32)
999 | ((inf >> 56) & 0xff)
1000 | ((inf >> 40) & 0xff00)
1001 | ((inf >> 24) & 0xff0000)
1002 | ((inf >> 8) & 0xff000000));
1003 relas[i].r_info = inf;
1004 }
1005#endif /* BFD64 */
1006 }
1007
1008 free (erelas);
1009 }
1010
1011 *relasp = relas;
1012 *nrelasp = nrelas;
1013 return TRUE;
1014}
1015
1016/* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1017 Returns TRUE upon success, FALSE otherwise. If successful then a
1018 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1019 and the number of relocs loaded is placed in *NRELSP. It is the caller's
1020 responsibility to free the allocated buffer. */
1021
1022static bfd_boolean
1023slurp_rel_relocs (Filedata * filedata,
1024 unsigned long rel_offset,
1025 unsigned long rel_size,
1026 Elf_Internal_Rela ** relsp,
1027 unsigned long * nrelsp)
1028{
1029 Elf_Internal_Rela * rels;
1030 size_t nrels;
1031 unsigned int i;
1032
1033 if (is_32bit_elf)
1034 {
1035 Elf32_External_Rel * erels;
1036
1037 erels = (Elf32_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1038 rel_size, _("32-bit relocation data"));
1039 if (!erels)
1040 return FALSE;
1041
1042 nrels = rel_size / sizeof (Elf32_External_Rel);
1043
1044 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1045
1046 if (rels == NULL)
1047 {
1048 free (erels);
1049 error (_("out of memory parsing relocs\n"));
1050 return FALSE;
1051 }
1052
1053 for (i = 0; i < nrels; i++)
1054 {
1055 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1056 rels[i].r_info = BYTE_GET (erels[i].r_info);
1057 rels[i].r_addend = 0;
1058 }
1059
1060 free (erels);
1061 }
1062 else
1063 {
1064 Elf64_External_Rel * erels;
1065
1066 erels = (Elf64_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1067 rel_size, _("64-bit relocation data"));
1068 if (!erels)
1069 return FALSE;
1070
1071 nrels = rel_size / sizeof (Elf64_External_Rel);
1072
1073 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1074
1075 if (rels == NULL)
1076 {
1077 free (erels);
1078 error (_("out of memory parsing relocs\n"));
1079 return FALSE;
1080 }
1081
1082 for (i = 0; i < nrels; i++)
1083 {
1084 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1085 rels[i].r_info = BYTE_GET (erels[i].r_info);
1086 rels[i].r_addend = 0;
1087
1088 /* The #ifdef BFD64 below is to prevent a compile time
1089 warning. We know that if we do not have a 64 bit data
1090 type that we will never execute this code anyway. */
1091#ifdef BFD64
1092 if (filedata->file_header.e_machine == EM_MIPS
1093 && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
1094 {
1095 /* In little-endian objects, r_info isn't really a
1096 64-bit little-endian value: it has a 32-bit
1097 little-endian symbol index followed by four
1098 individual byte fields. Reorder INFO
1099 accordingly. */
1100 bfd_vma inf = rels[i].r_info;
1101 inf = (((inf & 0xffffffff) << 32)
1102 | ((inf >> 56) & 0xff)
1103 | ((inf >> 40) & 0xff00)
1104 | ((inf >> 24) & 0xff0000)
1105 | ((inf >> 8) & 0xff000000));
1106 rels[i].r_info = inf;
1107 }
1108#endif /* BFD64 */
1109 }
1110
1111 free (erels);
1112 }
1113
1114 *relsp = rels;
1115 *nrelsp = nrels;
1116 return TRUE;
1117}
1118
1119/* Returns the reloc type extracted from the reloc info field. */
1120
1121static unsigned int
1122get_reloc_type (Filedata * filedata, bfd_vma reloc_info)
1123{
1124 if (is_32bit_elf)
1125 return ELF32_R_TYPE (reloc_info);
1126
1127 switch (filedata->file_header.e_machine)
1128 {
1129 case EM_MIPS:
1130 /* Note: We assume that reloc_info has already been adjusted for us. */
1131 return ELF64_MIPS_R_TYPE (reloc_info);
1132
1133 case EM_SPARCV9:
1134 return ELF64_R_TYPE_ID (reloc_info);
1135
1136 default:
1137 return ELF64_R_TYPE (reloc_info);
1138 }
1139}
1140
1141/* Return the symbol index extracted from the reloc info field. */
1142
1143static bfd_vma
1144get_reloc_symindex (bfd_vma reloc_info)
1145{
1146 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1147}
1148
1149static inline bfd_boolean
1150uses_msp430x_relocs (Filedata * filedata)
1151{
1152 return
1153 filedata->file_header.e_machine == EM_MSP430 /* Paranoia. */
1154 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1155 && (((filedata->file_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1156 /* TI compiler uses ELFOSABI_NONE. */
1157 || (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1158}
1159
1160/* Display the contents of the relocation data found at the specified
1161 offset. */
1162
1163static bfd_boolean
1164dump_relocations (Filedata * filedata,
1165 unsigned long rel_offset,
1166 unsigned long rel_size,
1167 Elf_Internal_Sym * symtab,
1168 unsigned long nsyms,
1169 char * strtab,
1170 unsigned long strtablen,
1171 int is_rela,
1172 bfd_boolean is_dynsym)
1173{
1174 unsigned long i;
1175 Elf_Internal_Rela * rels;
1176 bfd_boolean res = TRUE;
1177
1178 if (is_rela == UNKNOWN)
1179 is_rela = guess_is_rela (filedata->file_header.e_machine);
1180
1181 if (is_rela)
1182 {
1183 if (!slurp_rela_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1184 return FALSE;
1185 }
1186 else
1187 {
1188 if (!slurp_rel_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1189 return FALSE;
1190 }
1191
1192 if (is_32bit_elf)
1193 {
1194 if (is_rela)
1195 {
1196 if (do_wide)
1197 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1198 else
1199 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1200 }
1201 else
1202 {
1203 if (do_wide)
1204 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1205 else
1206 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1207 }
1208 }
1209 else
1210 {
1211 if (is_rela)
1212 {
1213 if (do_wide)
1214 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1215 else
1216 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1217 }
1218 else
1219 {
1220 if (do_wide)
1221 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1222 else
1223 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1224 }
1225 }
1226
1227 for (i = 0; i < rel_size; i++)
1228 {
1229 const char * rtype;
1230 bfd_vma offset;
1231 bfd_vma inf;
1232 bfd_vma symtab_index;
1233 bfd_vma type;
1234
1235 offset = rels[i].r_offset;
1236 inf = rels[i].r_info;
1237
1238 type = get_reloc_type (filedata, inf);
1239 symtab_index = get_reloc_symindex (inf);
1240
1241 if (is_32bit_elf)
1242 {
1243 printf ("%8.8lx %8.8lx ",
1244 (unsigned long) offset & 0xffffffff,
1245 (unsigned long) inf & 0xffffffff);
1246 }
1247 else
1248 {
1249#if BFD_HOST_64BIT_LONG
1250 printf (do_wide
1251 ? "%16.16lx %16.16lx "
1252 : "%12.12lx %12.12lx ",
1253 offset, inf);
1254#elif BFD_HOST_64BIT_LONG_LONG
1255#ifndef __MSVCRT__
1256 printf (do_wide
1257 ? "%16.16llx %16.16llx "
1258 : "%12.12llx %12.12llx ",
1259 offset, inf);
1260#else
1261 printf (do_wide
1262 ? "%16.16I64x %16.16I64x "
1263 : "%12.12I64x %12.12I64x ",
1264 offset, inf);
1265#endif
1266#else
1267 printf (do_wide
1268 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1269 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1270 _bfd_int64_high (offset),
1271 _bfd_int64_low (offset),
1272 _bfd_int64_high (inf),
1273 _bfd_int64_low (inf));
1274#endif
1275 }
1276
1277 switch (filedata->file_header.e_machine)
1278 {
1279 default:
1280 rtype = NULL;
1281 break;
1282
1283 case EM_AARCH64:
1284 rtype = elf_aarch64_reloc_type (type);
1285 break;
1286
1287 case EM_M32R:
1288 case EM_CYGNUS_M32R:
1289 rtype = elf_m32r_reloc_type (type);
1290 break;
1291
1292 case EM_386:
1293 case EM_IAMCU:
1294 rtype = elf_i386_reloc_type (type);
1295 break;
1296
1297 case EM_68HC11:
1298 case EM_68HC12:
1299 rtype = elf_m68hc11_reloc_type (type);
1300 break;
1301
1302 case EM_S12Z:
1303 rtype = elf_s12z_reloc_type (type);
1304 break;
1305
1306 case EM_68K:
1307 rtype = elf_m68k_reloc_type (type);
1308 break;
1309
1310 case EM_960:
1311 rtype = elf_i960_reloc_type (type);
1312 break;
1313
1314 case EM_AVR:
1315 case EM_AVR_OLD:
1316 rtype = elf_avr_reloc_type (type);
1317 break;
1318
1319 case EM_OLD_SPARCV9:
1320 case EM_SPARC32PLUS:
1321 case EM_SPARCV9:
1322 case EM_SPARC:
1323 rtype = elf_sparc_reloc_type (type);
1324 break;
1325
1326 case EM_SPU:
1327 rtype = elf_spu_reloc_type (type);
1328 break;
1329
1330 case EM_V800:
1331 rtype = v800_reloc_type (type);
1332 break;
1333 case EM_V850:
1334 case EM_CYGNUS_V850:
1335 rtype = v850_reloc_type (type);
1336 break;
1337
1338 case EM_D10V:
1339 case EM_CYGNUS_D10V:
1340 rtype = elf_d10v_reloc_type (type);
1341 break;
1342
1343 case EM_D30V:
1344 case EM_CYGNUS_D30V:
1345 rtype = elf_d30v_reloc_type (type);
1346 break;
1347
1348 case EM_DLX:
1349 rtype = elf_dlx_reloc_type (type);
1350 break;
1351
1352 case EM_SH:
1353 rtype = elf_sh_reloc_type (type);
1354 break;
1355
1356 case EM_MN10300:
1357 case EM_CYGNUS_MN10300:
1358 rtype = elf_mn10300_reloc_type (type);
1359 break;
1360
1361 case EM_MN10200:
1362 case EM_CYGNUS_MN10200:
1363 rtype = elf_mn10200_reloc_type (type);
1364 break;
1365
1366 case EM_FR30:
1367 case EM_CYGNUS_FR30:
1368 rtype = elf_fr30_reloc_type (type);
1369 break;
1370
1371 case EM_CYGNUS_FRV:
1372 rtype = elf_frv_reloc_type (type);
1373 break;
1374
1375 case EM_CSKY:
1376 rtype = elf_csky_reloc_type (type);
1377 break;
1378
1379 case EM_FT32:
1380 rtype = elf_ft32_reloc_type (type);
1381 break;
1382
1383 case EM_MCORE:
1384 rtype = elf_mcore_reloc_type (type);
1385 break;
1386
1387 case EM_MMIX:
1388 rtype = elf_mmix_reloc_type (type);
1389 break;
1390
1391 case EM_MOXIE:
1392 rtype = elf_moxie_reloc_type (type);
1393 break;
1394
1395 case EM_MSP430:
1396 if (uses_msp430x_relocs (filedata))
1397 {
1398 rtype = elf_msp430x_reloc_type (type);
1399 break;
1400 }
1401 /* Fall through. */
1402 case EM_MSP430_OLD:
1403 rtype = elf_msp430_reloc_type (type);
1404 break;
1405
1406 case EM_NDS32:
1407 rtype = elf_nds32_reloc_type (type);
1408 break;
1409
1410 case EM_PPC:
1411 rtype = elf_ppc_reloc_type (type);
1412 break;
1413
1414 case EM_PPC64:
1415 rtype = elf_ppc64_reloc_type (type);
1416 break;
1417
1418 case EM_MIPS:
1419 case EM_MIPS_RS3_LE:
1420 rtype = elf_mips_reloc_type (type);
1421 break;
1422
1423 case EM_RISCV:
1424 rtype = elf_riscv_reloc_type (type);
1425 break;
1426
1427 case EM_ALPHA:
1428 rtype = elf_alpha_reloc_type (type);
1429 break;
1430
1431 case EM_ARM:
1432 rtype = elf_arm_reloc_type (type);
1433 break;
1434
1435 case EM_ARC:
1436 case EM_ARC_COMPACT:
1437 case EM_ARC_COMPACT2:
1438 rtype = elf_arc_reloc_type (type);
1439 break;
1440
1441 case EM_PARISC:
1442 rtype = elf_hppa_reloc_type (type);
1443 break;
1444
1445 case EM_H8_300:
1446 case EM_H8_300H:
1447 case EM_H8S:
1448 rtype = elf_h8_reloc_type (type);
1449 break;
1450
1451 case EM_OR1K:
1452 rtype = elf_or1k_reloc_type (type);
1453 break;
1454
1455 case EM_PJ:
1456 case EM_PJ_OLD:
1457 rtype = elf_pj_reloc_type (type);
1458 break;
1459 case EM_IA_64:
1460 rtype = elf_ia64_reloc_type (type);
1461 break;
1462
1463 case EM_CRIS:
1464 rtype = elf_cris_reloc_type (type);
1465 break;
1466
1467 case EM_860:
1468 rtype = elf_i860_reloc_type (type);
1469 break;
1470
1471 case EM_X86_64:
1472 case EM_L1OM:
1473 case EM_K1OM:
1474 rtype = elf_x86_64_reloc_type (type);
1475 break;
1476
1477 case EM_S370:
1478 rtype = i370_reloc_type (type);
1479 break;
1480
1481 case EM_S390_OLD:
1482 case EM_S390:
1483 rtype = elf_s390_reloc_type (type);
1484 break;
1485
1486 case EM_SCORE:
1487 rtype = elf_score_reloc_type (type);
1488 break;
1489
1490 case EM_XSTORMY16:
1491 rtype = elf_xstormy16_reloc_type (type);
1492 break;
1493
1494 case EM_CRX:
1495 rtype = elf_crx_reloc_type (type);
1496 break;
1497
1498 case EM_VAX:
1499 rtype = elf_vax_reloc_type (type);
1500 break;
1501
1502 case EM_VISIUM:
1503 rtype = elf_visium_reloc_type (type);
1504 break;
1505
1506 case EM_BPF:
1507 rtype = elf_bpf_reloc_type (type);
1508 break;
1509
1510 case EM_ADAPTEVA_EPIPHANY:
1511 rtype = elf_epiphany_reloc_type (type);
1512 break;
1513
1514 case EM_IP2K:
1515 case EM_IP2K_OLD:
1516 rtype = elf_ip2k_reloc_type (type);
1517 break;
1518
1519 case EM_IQ2000:
1520 rtype = elf_iq2000_reloc_type (type);
1521 break;
1522
1523 case EM_XTENSA_OLD:
1524 case EM_XTENSA:
1525 rtype = elf_xtensa_reloc_type (type);
1526 break;
1527
1528 case EM_LATTICEMICO32:
1529 rtype = elf_lm32_reloc_type (type);
1530 break;
1531
1532 case EM_M32C_OLD:
1533 case EM_M32C:
1534 rtype = elf_m32c_reloc_type (type);
1535 break;
1536
1537 case EM_MT:
1538 rtype = elf_mt_reloc_type (type);
1539 break;
1540
1541 case EM_BLACKFIN:
1542 rtype = elf_bfin_reloc_type (type);
1543 break;
1544
1545 case EM_CYGNUS_MEP:
1546 rtype = elf_mep_reloc_type (type);
1547 break;
1548
1549 case EM_CR16:
1550 rtype = elf_cr16_reloc_type (type);
1551 break;
1552
1553 case EM_MICROBLAZE:
1554 case EM_MICROBLAZE_OLD:
1555 rtype = elf_microblaze_reloc_type (type);
1556 break;
1557
1558 case EM_RL78:
1559 rtype = elf_rl78_reloc_type (type);
1560 break;
1561
1562 case EM_RX:
1563 rtype = elf_rx_reloc_type (type);
1564 break;
1565
1566 case EM_METAG:
1567 rtype = elf_metag_reloc_type (type);
1568 break;
1569
1570 case EM_XC16X:
1571 case EM_C166:
1572 rtype = elf_xc16x_reloc_type (type);
1573 break;
1574
1575 case EM_TI_C6000:
1576 rtype = elf_tic6x_reloc_type (type);
1577 break;
1578
1579 case EM_TILEGX:
1580 rtype = elf_tilegx_reloc_type (type);
1581 break;
1582
1583 case EM_TILEPRO:
1584 rtype = elf_tilepro_reloc_type (type);
1585 break;
1586
1587 case EM_WEBASSEMBLY:
1588 rtype = elf_wasm32_reloc_type (type);
1589 break;
1590
1591 case EM_XGATE:
1592 rtype = elf_xgate_reloc_type (type);
1593 break;
1594
1595 case EM_ALTERA_NIOS2:
1596 rtype = elf_nios2_reloc_type (type);
1597 break;
1598
1599 case EM_TI_PRU:
1600 rtype = elf_pru_reloc_type (type);
1601 break;
1602
1603 case EM_NFP:
1604 if (EF_NFP_MACH (filedata->file_header.e_flags) == E_NFP_MACH_3200)
1605 rtype = elf_nfp3200_reloc_type (type);
1606 else
1607 rtype = elf_nfp_reloc_type (type);
1608 break;
1609
1610 case EM_Z80:
1611 rtype = elf_z80_reloc_type (type);
1612 break;
1613 }
1614
1615 if (rtype == NULL)
1616 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1617 else
1618 printf (do_wide ? "%-22s" : "%-17.17s", rtype);
1619
1620 if (filedata->file_header.e_machine == EM_ALPHA
1621 && rtype != NULL
1622 && streq (rtype, "R_ALPHA_LITUSE")
1623 && is_rela)
1624 {
1625 switch (rels[i].r_addend)
1626 {
1627 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1628 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1629 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1630 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1631 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1632 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1633 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1634 default: rtype = NULL;
1635 }
1636
1637 if (rtype)
1638 printf (" (%s)", rtype);
1639 else
1640 {
1641 putchar (' ');
1642 printf (_("<unknown addend: %lx>"),
1643 (unsigned long) rels[i].r_addend);
1644 res = FALSE;
1645 }
1646 }
1647 else if (symtab_index)
1648 {
1649 if (symtab == NULL || symtab_index >= nsyms)
1650 {
1651 error (_(" bad symbol index: %08lx in reloc\n"),
1652 (unsigned long) symtab_index);
1653 res = FALSE;
1654 }
1655 else
1656 {
1657 Elf_Internal_Sym * psym;
1658 const char * version_string;
1659 enum versioned_symbol_info sym_info;
1660 unsigned short vna_other;
1661
1662 psym = symtab + symtab_index;
1663
1664 version_string
1665 = get_symbol_version_string (filedata, is_dynsym,
1666 strtab, strtablen,
1667 symtab_index,
1668 psym,
1669 &sym_info,
1670 &vna_other);
1671
1672 printf (" ");
1673
1674 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1675 {
1676 const char * name;
1677 unsigned int len;
1678 unsigned int width = is_32bit_elf ? 8 : 14;
1679
1680 /* Relocations against GNU_IFUNC symbols do not use the value
1681 of the symbol as the address to relocate against. Instead
1682 they invoke the function named by the symbol and use its
1683 result as the address for relocation.
1684
1685 To indicate this to the user, do not display the value of
1686 the symbol in the "Symbols's Value" field. Instead show
1687 its name followed by () as a hint that the symbol is
1688 invoked. */
1689
1690 if (strtab == NULL
1691 || psym->st_name == 0
1692 || psym->st_name >= strtablen)
1693 name = "??";
1694 else
1695 name = strtab + psym->st_name;
1696
1697 len = print_symbol (width, name);
1698 if (version_string)
1699 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1700 version_string);
1701 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1702 }
1703 else
1704 {
1705 print_vma (psym->st_value, LONG_HEX);
1706
1707 printf (is_32bit_elf ? " " : " ");
1708 }
1709
1710 if (psym->st_name == 0)
1711 {
1712 const char * sec_name = "<null>";
1713 char name_buf[40];
1714
1715 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1716 {
1717 if (psym->st_shndx < filedata->file_header.e_shnum)
1718 sec_name = SECTION_NAME (filedata->section_headers + psym->st_shndx);
1719 else if (psym->st_shndx == SHN_ABS)
1720 sec_name = "ABS";
1721 else if (psym->st_shndx == SHN_COMMON)
1722 sec_name = "COMMON";
1723 else if ((filedata->file_header.e_machine == EM_MIPS
1724 && psym->st_shndx == SHN_MIPS_SCOMMON)
1725 || (filedata->file_header.e_machine == EM_TI_C6000
1726 && psym->st_shndx == SHN_TIC6X_SCOMMON))
1727 sec_name = "SCOMMON";
1728 else if (filedata->file_header.e_machine == EM_MIPS
1729 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1730 sec_name = "SUNDEF";
1731 else if ((filedata->file_header.e_machine == EM_X86_64
1732 || filedata->file_header.e_machine == EM_L1OM
1733 || filedata->file_header.e_machine == EM_K1OM)
1734 && psym->st_shndx == SHN_X86_64_LCOMMON)
1735 sec_name = "LARGE_COMMON";
1736 else if (filedata->file_header.e_machine == EM_IA_64
1737 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1738 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1739 sec_name = "ANSI_COM";
1740 else if (is_ia64_vms (filedata)
1741 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1742 sec_name = "VMS_SYMVEC";
1743 else
1744 {
1745 sprintf (name_buf, "<section 0x%x>",
1746 (unsigned int) psym->st_shndx);
1747 sec_name = name_buf;
1748 }
1749 }
1750 print_symbol (22, sec_name);
1751 }
1752 else if (strtab == NULL)
1753 printf (_("<string table index: %3ld>"), psym->st_name);
1754 else if (psym->st_name >= strtablen)
1755 {
1756 error (_("<corrupt string table index: %3ld>\n"),
1757 psym->st_name);
1758 res = FALSE;
1759 }
1760 else
1761 {
1762 print_symbol (22, strtab + psym->st_name);
1763 if (version_string)
1764 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1765 version_string);
1766 }
1767
1768 if (is_rela)
1769 {
1770 bfd_vma off = rels[i].r_addend;
1771
1772 if ((bfd_signed_vma) off < 0)
1773 printf (" - %" BFD_VMA_FMT "x", - off);
1774 else
1775 printf (" + %" BFD_VMA_FMT "x", off);
1776 }
1777 }
1778 }
1779 else if (is_rela)
1780 {
1781 bfd_vma off = rels[i].r_addend;
1782
1783 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1784 if ((bfd_signed_vma) off < 0)
1785 printf ("-%" BFD_VMA_FMT "x", - off);
1786 else
1787 printf ("%" BFD_VMA_FMT "x", off);
1788 }
1789
1790 if (filedata->file_header.e_machine == EM_SPARCV9
1791 && rtype != NULL
1792 && streq (rtype, "R_SPARC_OLO10"))
1793 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1794
1795 putchar ('\n');
1796
1797#ifdef BFD64
1798 if (! is_32bit_elf && filedata->file_header.e_machine == EM_MIPS)
1799 {
1800 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1801 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1802 const char * rtype2 = elf_mips_reloc_type (type2);
1803 const char * rtype3 = elf_mips_reloc_type (type3);
1804
1805 printf (" Type2: ");
1806
1807 if (rtype2 == NULL)
1808 printf (_("unrecognized: %-7lx"),
1809 (unsigned long) type2 & 0xffffffff);
1810 else
1811 printf ("%-17.17s", rtype2);
1812
1813 printf ("\n Type3: ");
1814
1815 if (rtype3 == NULL)
1816 printf (_("unrecognized: %-7lx"),
1817 (unsigned long) type3 & 0xffffffff);
1818 else
1819 printf ("%-17.17s", rtype3);
1820
1821 putchar ('\n');
1822 }
1823#endif /* BFD64 */
1824 }
1825
1826 free (rels);
1827
1828 return res;
1829}
1830
1831static const char *
1832get_aarch64_dynamic_type (unsigned long type)
1833{
1834 switch (type)
1835 {
1836 case DT_AARCH64_BTI_PLT: return "AARCH64_BTI_PLT";
1837 case DT_AARCH64_PAC_PLT: return "AARCH64_PAC_PLT";
1838 case DT_AARCH64_VARIANT_PCS: return "AARCH64_VARIANT_PCS";
1839 default:
1840 return NULL;
1841 }
1842}
1843
1844static const char *
1845get_mips_dynamic_type (unsigned long type)
1846{
1847 switch (type)
1848 {
1849 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1850 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1851 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1852 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1853 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1854 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1855 case DT_MIPS_MSYM: return "MIPS_MSYM";
1856 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1857 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1858 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1859 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1860 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1861 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1862 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1863 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1864 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1865 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1866 case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
1867 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1868 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1869 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1870 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1871 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1872 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1873 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1874 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1875 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1876 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1877 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1878 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1879 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1880 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1881 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1882 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1883 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1884 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1885 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1886 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1887 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1888 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1889 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1890 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1891 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1892 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1893 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1894 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1895 case DT_MIPS_XHASH: return "MIPS_XHASH";
1896 default:
1897 return NULL;
1898 }
1899}
1900
1901static const char *
1902get_sparc64_dynamic_type (unsigned long type)
1903{
1904 switch (type)
1905 {
1906 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1907 default:
1908 return NULL;
1909 }
1910}
1911
1912static const char *
1913get_ppc_dynamic_type (unsigned long type)
1914{
1915 switch (type)
1916 {
1917 case DT_PPC_GOT: return "PPC_GOT";
1918 case DT_PPC_OPT: return "PPC_OPT";
1919 default:
1920 return NULL;
1921 }
1922}
1923
1924static const char *
1925get_ppc64_dynamic_type (unsigned long type)
1926{
1927 switch (type)
1928 {
1929 case DT_PPC64_GLINK: return "PPC64_GLINK";
1930 case DT_PPC64_OPD: return "PPC64_OPD";
1931 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1932 case DT_PPC64_OPT: return "PPC64_OPT";
1933 default:
1934 return NULL;
1935 }
1936}
1937
1938static const char *
1939get_parisc_dynamic_type (unsigned long type)
1940{
1941 switch (type)
1942 {
1943 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1944 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1945 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1946 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1947 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1948 case DT_HP_PREINIT: return "HP_PREINIT";
1949 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1950 case DT_HP_NEEDED: return "HP_NEEDED";
1951 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1952 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1953 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1954 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1955 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1956 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1957 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1958 case DT_HP_FILTERED: return "HP_FILTERED";
1959 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1960 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1961 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1962 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1963 case DT_PLT: return "PLT";
1964 case DT_PLT_SIZE: return "PLT_SIZE";
1965 case DT_DLT: return "DLT";
1966 case DT_DLT_SIZE: return "DLT_SIZE";
1967 default:
1968 return NULL;
1969 }
1970}
1971
1972static const char *
1973get_ia64_dynamic_type (unsigned long type)
1974{
1975 switch (type)
1976 {
1977 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1978 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1979 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1980 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1981 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1982 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1983 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1984 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1985 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1986 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1987 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1988 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1989 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1990 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1991 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1992 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1993 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1994 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1995 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1996 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1997 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1998 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1999 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
2000 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
2001 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
2002 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
2003 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
2004 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
2005 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
2006 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
2007 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
2008 default:
2009 return NULL;
2010 }
2011}
2012
2013static const char *
2014get_solaris_section_type (unsigned long type)
2015{
2016 switch (type)
2017 {
2018 case 0x6fffffee: return "SUNW_ancillary";
2019 case 0x6fffffef: return "SUNW_capchain";
2020 case 0x6ffffff0: return "SUNW_capinfo";
2021 case 0x6ffffff1: return "SUNW_symsort";
2022 case 0x6ffffff2: return "SUNW_tlssort";
2023 case 0x6ffffff3: return "SUNW_LDYNSYM";
2024 case 0x6ffffff4: return "SUNW_dof";
2025 case 0x6ffffff5: return "SUNW_cap";
2026 case 0x6ffffff6: return "SUNW_SIGNATURE";
2027 case 0x6ffffff7: return "SUNW_ANNOTATE";
2028 case 0x6ffffff8: return "SUNW_DEBUGSTR";
2029 case 0x6ffffff9: return "SUNW_DEBUG";
2030 case 0x6ffffffa: return "SUNW_move";
2031 case 0x6ffffffb: return "SUNW_COMDAT";
2032 case 0x6ffffffc: return "SUNW_syminfo";
2033 case 0x6ffffffd: return "SUNW_verdef";
2034 case 0x6ffffffe: return "SUNW_verneed";
2035 case 0x6fffffff: return "SUNW_versym";
2036 case 0x70000000: return "SPARC_GOTDATA";
2037 default: return NULL;
2038 }
2039}
2040
2041static const char *
2042get_alpha_dynamic_type (unsigned long type)
2043{
2044 switch (type)
2045 {
2046 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
2047 default: return NULL;
2048 }
2049}
2050
2051static const char *
2052get_score_dynamic_type (unsigned long type)
2053{
2054 switch (type)
2055 {
2056 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
2057 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
2058 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
2059 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
2060 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
2061 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
2062 default: return NULL;
2063 }
2064}
2065
2066static const char *
2067get_tic6x_dynamic_type (unsigned long type)
2068{
2069 switch (type)
2070 {
2071 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
2072 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
2073 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
2074 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
2075 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
2076 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
2077 default: return NULL;
2078 }
2079}
2080
2081static const char *
2082get_nios2_dynamic_type (unsigned long type)
2083{
2084 switch (type)
2085 {
2086 case DT_NIOS2_GP: return "NIOS2_GP";
2087 default: return NULL;
2088 }
2089}
2090
2091static const char *
2092get_solaris_dynamic_type (unsigned long type)
2093{
2094 switch (type)
2095 {
2096 case 0x6000000d: return "SUNW_AUXILIARY";
2097 case 0x6000000e: return "SUNW_RTLDINF";
2098 case 0x6000000f: return "SUNW_FILTER";
2099 case 0x60000010: return "SUNW_CAP";
2100 case 0x60000011: return "SUNW_SYMTAB";
2101 case 0x60000012: return "SUNW_SYMSZ";
2102 case 0x60000013: return "SUNW_SORTENT";
2103 case 0x60000014: return "SUNW_SYMSORT";
2104 case 0x60000015: return "SUNW_SYMSORTSZ";
2105 case 0x60000016: return "SUNW_TLSSORT";
2106 case 0x60000017: return "SUNW_TLSSORTSZ";
2107 case 0x60000018: return "SUNW_CAPINFO";
2108 case 0x60000019: return "SUNW_STRPAD";
2109 case 0x6000001a: return "SUNW_CAPCHAIN";
2110 case 0x6000001b: return "SUNW_LDMACH";
2111 case 0x6000001d: return "SUNW_CAPCHAINENT";
2112 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2113 case 0x60000021: return "SUNW_PARENT";
2114 case 0x60000023: return "SUNW_ASLR";
2115 case 0x60000025: return "SUNW_RELAX";
2116 case 0x60000029: return "SUNW_NXHEAP";
2117 case 0x6000002b: return "SUNW_NXSTACK";
2118
2119 case 0x70000001: return "SPARC_REGISTER";
2120 case 0x7ffffffd: return "AUXILIARY";
2121 case 0x7ffffffe: return "USED";
2122 case 0x7fffffff: return "FILTER";
2123
2124 default: return NULL;
2125 }
2126}
2127
2128static const char *
2129get_dynamic_type (Filedata * filedata, unsigned long type)
2130{
2131 static char buff[64];
2132
2133 switch (type)
2134 {
2135 case DT_NULL: return "NULL";
2136 case DT_NEEDED: return "NEEDED";
2137 case DT_PLTRELSZ: return "PLTRELSZ";
2138 case DT_PLTGOT: return "PLTGOT";
2139 case DT_HASH: return "HASH";
2140 case DT_STRTAB: return "STRTAB";
2141 case DT_SYMTAB: return "SYMTAB";
2142 case DT_RELA: return "RELA";
2143 case DT_RELASZ: return "RELASZ";
2144 case DT_RELAENT: return "RELAENT";
2145 case DT_STRSZ: return "STRSZ";
2146 case DT_SYMENT: return "SYMENT";
2147 case DT_INIT: return "INIT";
2148 case DT_FINI: return "FINI";
2149 case DT_SONAME: return "SONAME";
2150 case DT_RPATH: return "RPATH";
2151 case DT_SYMBOLIC: return "SYMBOLIC";
2152 case DT_REL: return "REL";
2153 case DT_RELSZ: return "RELSZ";
2154 case DT_RELENT: return "RELENT";
2155 case DT_PLTREL: return "PLTREL";
2156 case DT_DEBUG: return "DEBUG";
2157 case DT_TEXTREL: return "TEXTREL";
2158 case DT_JMPREL: return "JMPREL";
2159 case DT_BIND_NOW: return "BIND_NOW";
2160 case DT_INIT_ARRAY: return "INIT_ARRAY";
2161 case DT_FINI_ARRAY: return "FINI_ARRAY";
2162 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2163 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
2164 case DT_RUNPATH: return "RUNPATH";
2165 case DT_FLAGS: return "FLAGS";
2166
2167 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2168 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
2169 case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
2170
2171 case DT_CHECKSUM: return "CHECKSUM";
2172 case DT_PLTPADSZ: return "PLTPADSZ";
2173 case DT_MOVEENT: return "MOVEENT";
2174 case DT_MOVESZ: return "MOVESZ";
2175 case DT_FEATURE: return "FEATURE";
2176 case DT_POSFLAG_1: return "POSFLAG_1";
2177 case DT_SYMINSZ: return "SYMINSZ";
2178 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
2179
2180 case DT_ADDRRNGLO: return "ADDRRNGLO";
2181 case DT_CONFIG: return "CONFIG";
2182 case DT_DEPAUDIT: return "DEPAUDIT";
2183 case DT_AUDIT: return "AUDIT";
2184 case DT_PLTPAD: return "PLTPAD";
2185 case DT_MOVETAB: return "MOVETAB";
2186 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
2187
2188 case DT_VERSYM: return "VERSYM";
2189
2190 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2191 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
2192 case DT_RELACOUNT: return "RELACOUNT";
2193 case DT_RELCOUNT: return "RELCOUNT";
2194 case DT_FLAGS_1: return "FLAGS_1";
2195 case DT_VERDEF: return "VERDEF";
2196 case DT_VERDEFNUM: return "VERDEFNUM";
2197 case DT_VERNEED: return "VERNEED";
2198 case DT_VERNEEDNUM: return "VERNEEDNUM";
2199
2200 case DT_AUXILIARY: return "AUXILIARY";
2201 case DT_USED: return "USED";
2202 case DT_FILTER: return "FILTER";
2203
2204 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2205 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2206 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2207 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2208 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
2209 case DT_GNU_HASH: return "GNU_HASH";
2210
2211 default:
2212 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2213 {
2214 const char * result;
2215
2216 switch (filedata->file_header.e_machine)
2217 {
2218 case EM_AARCH64:
2219 result = get_aarch64_dynamic_type (type);
2220 break;
2221 case EM_MIPS:
2222 case EM_MIPS_RS3_LE:
2223 result = get_mips_dynamic_type (type);
2224 break;
2225 case EM_SPARCV9:
2226 result = get_sparc64_dynamic_type (type);
2227 break;
2228 case EM_PPC:
2229 result = get_ppc_dynamic_type (type);
2230 break;
2231 case EM_PPC64:
2232 result = get_ppc64_dynamic_type (type);
2233 break;
2234 case EM_IA_64:
2235 result = get_ia64_dynamic_type (type);
2236 break;
2237 case EM_ALPHA:
2238 result = get_alpha_dynamic_type (type);
2239 break;
2240 case EM_SCORE:
2241 result = get_score_dynamic_type (type);
2242 break;
2243 case EM_TI_C6000:
2244 result = get_tic6x_dynamic_type (type);
2245 break;
2246 case EM_ALTERA_NIOS2:
2247 result = get_nios2_dynamic_type (type);
2248 break;
2249 default:
2250 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2251 result = get_solaris_dynamic_type (type);
2252 else
2253 result = NULL;
2254 break;
2255 }
2256
2257 if (result != NULL)
2258 return result;
2259
2260 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2261 }
2262 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2263 || (filedata->file_header.e_machine == EM_PARISC
2264 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2265 {
2266 const char * result;
2267
2268 switch (filedata->file_header.e_machine)
2269 {
2270 case EM_PARISC:
2271 result = get_parisc_dynamic_type (type);
2272 break;
2273 case EM_IA_64:
2274 result = get_ia64_dynamic_type (type);
2275 break;
2276 default:
2277 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2278 result = get_solaris_dynamic_type (type);
2279 else
2280 result = NULL;
2281 break;
2282 }
2283
2284 if (result != NULL)
2285 return result;
2286
2287 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2288 type);
2289 }
2290 else
2291 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2292
2293 return buff;
2294 }
2295}
2296
2297static char *
2298get_file_type (unsigned e_type)
2299{
2300 static char buff[64];
2301
2302 switch (e_type)
2303 {
2304 case ET_NONE: return _("NONE (None)");
2305 case ET_REL: return _("REL (Relocatable file)");
2306 case ET_EXEC: return _("EXEC (Executable file)");
2307 case ET_DYN: return _("DYN (Shared object file)");
2308 case ET_CORE: return _("CORE (Core file)");
2309
2310 default:
2311 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2312 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2313 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2314 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2315 else
2316 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2317 return buff;
2318 }
2319}
2320
2321static char *
2322get_machine_name (unsigned e_machine)
2323{
2324 static char buff[64]; /* XXX */
2325
2326 switch (e_machine)
2327 {
2328 /* Please keep this switch table sorted by increasing EM_ value. */
2329 /* 0 */
2330 case EM_NONE: return _("None");
2331 case EM_M32: return "WE32100";
2332 case EM_SPARC: return "Sparc";
2333 case EM_386: return "Intel 80386";
2334 case EM_68K: return "MC68000";
2335 case EM_88K: return "MC88000";
2336 case EM_IAMCU: return "Intel MCU";
2337 case EM_860: return "Intel 80860";
2338 case EM_MIPS: return "MIPS R3000";
2339 case EM_S370: return "IBM System/370";
2340 /* 10 */
2341 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
2342 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
2343 case EM_PARISC: return "HPPA";
2344 case EM_VPP550: return "Fujitsu VPP500";
2345 case EM_SPARC32PLUS: return "Sparc v8+" ;
2346 case EM_960: return "Intel 80960";
2347 case EM_PPC: return "PowerPC";
2348 /* 20 */
2349 case EM_PPC64: return "PowerPC64";
2350 case EM_S390_OLD:
2351 case EM_S390: return "IBM S/390";
2352 case EM_SPU: return "SPU";
2353 /* 30 */
2354 case EM_V800: return "Renesas V850 (using RH850 ABI)";
2355 case EM_FR20: return "Fujitsu FR20";
2356 case EM_RH32: return "TRW RH32";
2357 case EM_MCORE: return "MCORE";
2358 /* 40 */
2359 case EM_ARM: return "ARM";
2360 case EM_OLD_ALPHA: return "Digital Alpha (old)";
2361 case EM_SH: return "Renesas / SuperH SH";
2362 case EM_SPARCV9: return "Sparc v9";
2363 case EM_TRICORE: return "Siemens Tricore";
2364 case EM_ARC: return "ARC";
2365 case EM_H8_300: return "Renesas H8/300";
2366 case EM_H8_300H: return "Renesas H8/300H";
2367 case EM_H8S: return "Renesas H8S";
2368 case EM_H8_500: return "Renesas H8/500";
2369 /* 50 */
2370 case EM_IA_64: return "Intel IA-64";
2371 case EM_MIPS_X: return "Stanford MIPS-X";
2372 case EM_COLDFIRE: return "Motorola Coldfire";
2373 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
2374 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2375 case EM_PCP: return "Siemens PCP";
2376 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2377 case EM_NDR1: return "Denso NDR1 microprocesspr";
2378 case EM_STARCORE: return "Motorola Star*Core processor";
2379 case EM_ME16: return "Toyota ME16 processor";
2380 /* 60 */
2381 case EM_ST100: return "STMicroelectronics ST100 processor";
2382 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
2383 case EM_X86_64: return "Advanced Micro Devices X86-64";
2384 case EM_PDSP: return "Sony DSP processor";
2385 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2386 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
2387 case EM_FX66: return "Siemens FX66 microcontroller";
2388 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2389 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2390 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
2391 /* 70 */
2392 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2393 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2394 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2395 case EM_SVX: return "Silicon Graphics SVx";
2396 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2397 case EM_VAX: return "Digital VAX";
2398 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
2399 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2400 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2401 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
2402 /* 80 */
2403 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
2404 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
2405 case EM_PRISM: return "Vitesse Prism";
2406 case EM_AVR_OLD:
2407 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
2408 case EM_CYGNUS_FR30:
2409 case EM_FR30: return "Fujitsu FR30";
2410 case EM_CYGNUS_D10V:
2411 case EM_D10V: return "d10v";
2412 case EM_CYGNUS_D30V:
2413 case EM_D30V: return "d30v";
2414 case EM_CYGNUS_V850:
2415 case EM_V850: return "Renesas V850";
2416 case EM_CYGNUS_M32R:
2417 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2418 case EM_CYGNUS_MN10300:
2419 case EM_MN10300: return "mn10300";
2420 /* 90 */
2421 case EM_CYGNUS_MN10200:
2422 case EM_MN10200: return "mn10200";
2423 case EM_PJ: return "picoJava";
2424 case EM_OR1K: return "OpenRISC 1000";
2425 case EM_ARC_COMPACT: return "ARCompact";
2426 case EM_XTENSA_OLD:
2427 case EM_XTENSA: return "Tensilica Xtensa Processor";
2428 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2429 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2430 case EM_NS32K: return "National Semiconductor 32000 series";
2431 case EM_TPC: return "Tenor Network TPC processor";
2432 case EM_SNP1K: return "Trebia SNP 1000 processor";
2433 /* 100 */
2434 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2435 case EM_IP2K_OLD:
2436 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
2437 case EM_MAX: return "MAX Processor";
2438 case EM_CR: return "National Semiconductor CompactRISC";
2439 case EM_F2MC16: return "Fujitsu F2MC16";
2440 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
2441 case EM_BLACKFIN: return "Analog Devices Blackfin";
2442 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2443 case EM_SEP: return "Sharp embedded microprocessor";
2444 case EM_ARCA: return "Arca RISC microprocessor";
2445 /* 110 */
2446 case EM_UNICORE: return "Unicore";
2447 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2448 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
2449 case EM_ALTERA_NIOS2: return "Altera Nios II";
2450 case EM_CRX: return "National Semiconductor CRX microprocessor";
2451 case EM_XGATE: return "Motorola XGATE embedded processor";
2452 case EM_C166:
2453 case EM_XC16X: return "Infineon Technologies xc16x";
2454 case EM_M16C: return "Renesas M16C series microprocessors";
2455 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2456 case EM_CE: return "Freescale Communication Engine RISC core";
2457 /* 120 */
2458 case EM_M32C: return "Renesas M32c";
2459 /* 130 */
2460 case EM_TSK3000: return "Altium TSK3000 core";
2461 case EM_RS08: return "Freescale RS08 embedded processor";
2462 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2463 case EM_SCORE: return "SUNPLUS S+Core";
2464 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2465 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2466 case EM_LATTICEMICO32: return "Lattice Mico32";
2467 case EM_SE_C17: return "Seiko Epson C17 family";
2468 /* 140 */
2469 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2470 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2471 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2472 case EM_TI_PRU: return "TI PRU I/O processor";
2473 /* 160 */
2474 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2475 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2476 case EM_R32C: return "Renesas R32C series microprocessors";
2477 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2478 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2479 case EM_8051: return "Intel 8051 and variants";
2480 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2481 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2482 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2483 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2484 /* 170 */
2485 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2486 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2487 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
2488 case EM_RX: return "Renesas RX";
2489 case EM_METAG: return "Imagination Technologies Meta processor architecture";
2490 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2491 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2492 case EM_CR16:
2493 case EM_MICROBLAZE:
2494 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
2495 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2496 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2497 /* 180 */
2498 case EM_L1OM: return "Intel L1OM";
2499 case EM_K1OM: return "Intel K1OM";
2500 case EM_INTEL182: return "Intel (reserved)";
2501 case EM_AARCH64: return "AArch64";
2502 case EM_ARM184: return "ARM (reserved)";
2503 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor";
2504 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2505 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2506 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
2507 /* 190 */
2508 case EM_CUDA: return "NVIDIA CUDA architecture";
2509 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
2510 case EM_CLOUDSHIELD: return "CloudShield architecture family";
2511 case EM_COREA_1ST: return "KIPO-KAIST Core-A 1st generation processor family";
2512 case EM_COREA_2ND: return "KIPO-KAIST Core-A 2nd generation processor family";
2513 case EM_ARC_COMPACT2: return "ARCv2";
2514 case EM_OPEN8: return "Open8 8-bit RISC soft processor core";
2515 case EM_RL78: return "Renesas RL78";
2516 case EM_VIDEOCORE5: return "Broadcom VideoCore V processor";
2517 case EM_78K0R: return "Renesas 78K0R";
2518 /* 200 */
2519 case EM_56800EX: return "Freescale 56800EX Digital Signal Controller (DSC)";
2520 case EM_BA1: return "Beyond BA1 CPU architecture";
2521 case EM_BA2: return "Beyond BA2 CPU architecture";
2522 case EM_XCORE: return "XMOS xCORE processor family";
2523 case EM_MCHP_PIC: return "Microchip 8-bit PIC(r) family";
2524 /* 210 */
2525 case EM_KM32: return "KM211 KM32 32-bit processor";
2526 case EM_KMX32: return "KM211 KMX32 32-bit processor";
2527 case EM_KMX16: return "KM211 KMX16 16-bit processor";
2528 case EM_KMX8: return "KM211 KMX8 8-bit processor";
2529 case EM_KVARC: return "KM211 KVARC processor";
2530 case EM_CDP: return "Paneve CDP architecture family";
2531 case EM_COGE: return "Cognitive Smart Memory Processor";
2532 case EM_COOL: return "Bluechip Systems CoolEngine";
2533 case EM_NORC: return "Nanoradio Optimized RISC";
2534 case EM_CSR_KALIMBA: return "CSR Kalimba architecture family";
2535 /* 220 */
2536 case EM_Z80: return "Zilog Z80";
2537 case EM_VISIUM: return "CDS VISIUMcore processor";
2538 case EM_FT32: return "FTDI Chip FT32";
2539 case EM_MOXIE: return "Moxie";
2540 case EM_AMDGPU: return "AMD GPU";
2541 case EM_RISCV: return "RISC-V";
2542 case EM_LANAI: return "Lanai 32-bit processor";
2543 case EM_BPF: return "Linux BPF";
2544 case EM_NFP: return "Netronome Flow Processor";
2545
2546 /* Large numbers... */
2547 case EM_MT: return "Morpho Techologies MT processor";
2548 case EM_ALPHA: return "Alpha";
2549 case EM_WEBASSEMBLY: return "Web Assembly";
2550 case EM_DLX: return "OpenDLX";
2551 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
2552 case EM_IQ2000: return "Vitesse IQ2000";
2553 case EM_M32C_OLD:
2554 case EM_NIOS32: return "Altera Nios";
2555 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
2556 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
2557 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2558 case EM_S12Z: return "Freescale S12Z";
2559 case EM_CSKY: return "C-SKY";
2560
2561 default:
2562 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2563 return buff;
2564 }
2565}
2566
2567static void
2568decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2569{
2570 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2571 other compilers don't a specific architecture type in the e_flags, and
2572 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2573 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2574 architectures.
2575
2576 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2577 but also sets a specific architecture type in the e_flags field.
2578
2579 However, when decoding the flags we don't worry if we see an
2580 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2581 ARCEM architecture type. */
2582
2583 switch (e_flags & EF_ARC_MACH_MSK)
2584 {
2585 /* We only expect these to occur for EM_ARC_COMPACT2. */
2586 case EF_ARC_CPU_ARCV2EM:
2587 strcat (buf, ", ARC EM");
2588 break;
2589 case EF_ARC_CPU_ARCV2HS:
2590 strcat (buf, ", ARC HS");
2591 break;
2592
2593 /* We only expect these to occur for EM_ARC_COMPACT. */
2594 case E_ARC_MACH_ARC600:
2595 strcat (buf, ", ARC600");
2596 break;
2597 case E_ARC_MACH_ARC601:
2598 strcat (buf, ", ARC601");
2599 break;
2600 case E_ARC_MACH_ARC700:
2601 strcat (buf, ", ARC700");
2602 break;
2603
2604 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2605 new ELF with new architecture being read by an old version of
2606 readelf, or (c) An ELF built with non-GNU compiler that does not
2607 set the architecture in the e_flags. */
2608 default:
2609 if (e_machine == EM_ARC_COMPACT)
2610 strcat (buf, ", Unknown ARCompact");
2611 else
2612 strcat (buf, ", Unknown ARC");
2613 break;
2614 }
2615
2616 switch (e_flags & EF_ARC_OSABI_MSK)
2617 {
2618 case E_ARC_OSABI_ORIG:
2619 strcat (buf, ", (ABI:legacy)");
2620 break;
2621 case E_ARC_OSABI_V2:
2622 strcat (buf, ", (ABI:v2)");
2623 break;
2624 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2625 case E_ARC_OSABI_V3:
2626 strcat (buf, ", v3 no-legacy-syscalls ABI");
2627 break;
2628 case E_ARC_OSABI_V4:
2629 strcat (buf, ", v4 ABI");
2630 break;
2631 default:
2632 strcat (buf, ", unrecognised ARC OSABI flag");
2633 break;
2634 }
2635}
2636
2637static void
2638decode_ARM_machine_flags (unsigned e_flags, char buf[])
2639{
2640 unsigned eabi;
2641 bfd_boolean unknown = FALSE;
2642
2643 eabi = EF_ARM_EABI_VERSION (e_flags);
2644 e_flags &= ~ EF_ARM_EABIMASK;
2645
2646 /* Handle "generic" ARM flags. */
2647 if (e_flags & EF_ARM_RELEXEC)
2648 {
2649 strcat (buf, ", relocatable executable");
2650 e_flags &= ~ EF_ARM_RELEXEC;
2651 }
2652
2653 if (e_flags & EF_ARM_PIC)
2654 {
2655 strcat (buf, ", position independent");
2656 e_flags &= ~ EF_ARM_PIC;
2657 }
2658
2659 /* Now handle EABI specific flags. */
2660 switch (eabi)
2661 {
2662 default:
2663 strcat (buf, ", <unrecognized EABI>");
2664 if (e_flags)
2665 unknown = TRUE;
2666 break;
2667
2668 case EF_ARM_EABI_VER1:
2669 strcat (buf, ", Version1 EABI");
2670 while (e_flags)
2671 {
2672 unsigned flag;
2673
2674 /* Process flags one bit at a time. */
2675 flag = e_flags & - e_flags;
2676 e_flags &= ~ flag;
2677
2678 switch (flag)
2679 {
2680 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2681 strcat (buf, ", sorted symbol tables");
2682 break;
2683
2684 default:
2685 unknown = TRUE;
2686 break;
2687 }
2688 }
2689 break;
2690
2691 case EF_ARM_EABI_VER2:
2692 strcat (buf, ", Version2 EABI");
2693 while (e_flags)
2694 {
2695 unsigned flag;
2696
2697 /* Process flags one bit at a time. */
2698 flag = e_flags & - e_flags;
2699 e_flags &= ~ flag;
2700
2701 switch (flag)
2702 {
2703 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2704 strcat (buf, ", sorted symbol tables");
2705 break;
2706
2707 case EF_ARM_DYNSYMSUSESEGIDX:
2708 strcat (buf, ", dynamic symbols use segment index");
2709 break;
2710
2711 case EF_ARM_MAPSYMSFIRST:
2712 strcat (buf, ", mapping symbols precede others");
2713 break;
2714
2715 default:
2716 unknown = TRUE;
2717 break;
2718 }
2719 }
2720 break;
2721
2722 case EF_ARM_EABI_VER3:
2723 strcat (buf, ", Version3 EABI");
2724 break;
2725
2726 case EF_ARM_EABI_VER4:
2727 strcat (buf, ", Version4 EABI");
2728 while (e_flags)
2729 {
2730 unsigned flag;
2731
2732 /* Process flags one bit at a time. */
2733 flag = e_flags & - e_flags;
2734 e_flags &= ~ flag;
2735
2736 switch (flag)
2737 {
2738 case EF_ARM_BE8:
2739 strcat (buf, ", BE8");
2740 break;
2741
2742 case EF_ARM_LE8:
2743 strcat (buf, ", LE8");
2744 break;
2745
2746 default:
2747 unknown = TRUE;
2748 break;
2749 }
2750 }
2751 break;
2752
2753 case EF_ARM_EABI_VER5:
2754 strcat (buf, ", Version5 EABI");
2755 while (e_flags)
2756 {
2757 unsigned flag;
2758
2759 /* Process flags one bit at a time. */
2760 flag = e_flags & - e_flags;
2761 e_flags &= ~ flag;
2762
2763 switch (flag)
2764 {
2765 case EF_ARM_BE8:
2766 strcat (buf, ", BE8");
2767 break;
2768
2769 case EF_ARM_LE8:
2770 strcat (buf, ", LE8");
2771 break;
2772
2773 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2774 strcat (buf, ", soft-float ABI");
2775 break;
2776
2777 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2778 strcat (buf, ", hard-float ABI");
2779 break;
2780
2781 default:
2782 unknown = TRUE;
2783 break;
2784 }
2785 }
2786 break;
2787
2788 case EF_ARM_EABI_UNKNOWN:
2789 strcat (buf, ", GNU EABI");
2790 while (e_flags)
2791 {
2792 unsigned flag;
2793
2794 /* Process flags one bit at a time. */
2795 flag = e_flags & - e_flags;
2796 e_flags &= ~ flag;
2797
2798 switch (flag)
2799 {
2800 case EF_ARM_INTERWORK:
2801 strcat (buf, ", interworking enabled");
2802 break;
2803
2804 case EF_ARM_APCS_26:
2805 strcat (buf, ", uses APCS/26");
2806 break;
2807
2808 case EF_ARM_APCS_FLOAT:
2809 strcat (buf, ", uses APCS/float");
2810 break;
2811
2812 case EF_ARM_PIC:
2813 strcat (buf, ", position independent");
2814 break;
2815
2816 case EF_ARM_ALIGN8:
2817 strcat (buf, ", 8 bit structure alignment");
2818 break;
2819
2820 case EF_ARM_NEW_ABI:
2821 strcat (buf, ", uses new ABI");
2822 break;
2823
2824 case EF_ARM_OLD_ABI:
2825 strcat (buf, ", uses old ABI");
2826 break;
2827
2828 case EF_ARM_SOFT_FLOAT:
2829 strcat (buf, ", software FP");
2830 break;
2831
2832 case EF_ARM_VFP_FLOAT:
2833 strcat (buf, ", VFP");
2834 break;
2835
2836 case EF_ARM_MAVERICK_FLOAT:
2837 strcat (buf, ", Maverick FP");
2838 break;
2839
2840 default:
2841 unknown = TRUE;
2842 break;
2843 }
2844 }
2845 }
2846
2847 if (unknown)
2848 strcat (buf,_(", <unknown>"));
2849}
2850
2851static void
2852decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2853{
2854 --size; /* Leave space for null terminator. */
2855
2856 switch (e_flags & EF_AVR_MACH)
2857 {
2858 case E_AVR_MACH_AVR1:
2859 strncat (buf, ", avr:1", size);
2860 break;
2861 case E_AVR_MACH_AVR2:
2862 strncat (buf, ", avr:2", size);
2863 break;
2864 case E_AVR_MACH_AVR25:
2865 strncat (buf, ", avr:25", size);
2866 break;
2867 case E_AVR_MACH_AVR3:
2868 strncat (buf, ", avr:3", size);
2869 break;
2870 case E_AVR_MACH_AVR31:
2871 strncat (buf, ", avr:31", size);
2872 break;
2873 case E_AVR_MACH_AVR35:
2874 strncat (buf, ", avr:35", size);
2875 break;
2876 case E_AVR_MACH_AVR4:
2877 strncat (buf, ", avr:4", size);
2878 break;
2879 case E_AVR_MACH_AVR5:
2880 strncat (buf, ", avr:5", size);
2881 break;
2882 case E_AVR_MACH_AVR51:
2883 strncat (buf, ", avr:51", size);
2884 break;
2885 case E_AVR_MACH_AVR6:
2886 strncat (buf, ", avr:6", size);
2887 break;
2888 case E_AVR_MACH_AVRTINY:
2889 strncat (buf, ", avr:100", size);
2890 break;
2891 case E_AVR_MACH_XMEGA1:
2892 strncat (buf, ", avr:101", size);
2893 break;
2894 case E_AVR_MACH_XMEGA2:
2895 strncat (buf, ", avr:102", size);
2896 break;
2897 case E_AVR_MACH_XMEGA3:
2898 strncat (buf, ", avr:103", size);
2899 break;
2900 case E_AVR_MACH_XMEGA4:
2901 strncat (buf, ", avr:104", size);
2902 break;
2903 case E_AVR_MACH_XMEGA5:
2904 strncat (buf, ", avr:105", size);
2905 break;
2906 case E_AVR_MACH_XMEGA6:
2907 strncat (buf, ", avr:106", size);
2908 break;
2909 case E_AVR_MACH_XMEGA7:
2910 strncat (buf, ", avr:107", size);
2911 break;
2912 default:
2913 strncat (buf, ", avr:<unknown>", size);
2914 break;
2915 }
2916
2917 size -= strlen (buf);
2918 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2919 strncat (buf, ", link-relax", size);
2920}
2921
2922static void
2923decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2924{
2925 unsigned abi;
2926 unsigned arch;
2927 unsigned config;
2928 unsigned version;
2929 bfd_boolean has_fpu = FALSE;
2930 unsigned int r = 0;
2931
2932 static const char *ABI_STRINGS[] =
2933 {
2934 "ABI v0", /* use r5 as return register; only used in N1213HC */
2935 "ABI v1", /* use r0 as return register */
2936 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2937 "ABI v2fp", /* for FPU */
2938 "AABI",
2939 "ABI2 FP+"
2940 };
2941 static const char *VER_STRINGS[] =
2942 {
2943 "Andes ELF V1.3 or older",
2944 "Andes ELF V1.3.1",
2945 "Andes ELF V1.4"
2946 };
2947 static const char *ARCH_STRINGS[] =
2948 {
2949 "",
2950 "Andes Star v1.0",
2951 "Andes Star v2.0",
2952 "Andes Star v3.0",
2953 "Andes Star v3.0m"
2954 };
2955
2956 abi = EF_NDS_ABI & e_flags;
2957 arch = EF_NDS_ARCH & e_flags;
2958 config = EF_NDS_INST & e_flags;
2959 version = EF_NDS32_ELF_VERSION & e_flags;
2960
2961 memset (buf, 0, size);
2962
2963 switch (abi)
2964 {
2965 case E_NDS_ABI_V0:
2966 case E_NDS_ABI_V1:
2967 case E_NDS_ABI_V2:
2968 case E_NDS_ABI_V2FP:
2969 case E_NDS_ABI_AABI:
2970 case E_NDS_ABI_V2FP_PLUS:
2971 /* In case there are holes in the array. */
2972 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2973 break;
2974
2975 default:
2976 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2977 break;
2978 }
2979
2980 switch (version)
2981 {
2982 case E_NDS32_ELF_VER_1_2:
2983 case E_NDS32_ELF_VER_1_3:
2984 case E_NDS32_ELF_VER_1_4:
2985 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2986 break;
2987
2988 default:
2989 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2990 break;
2991 }
2992
2993 if (E_NDS_ABI_V0 == abi)
2994 {
2995 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2996 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2997 if (arch == E_NDS_ARCH_STAR_V1_0)
2998 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2999 return;
3000 }
3001
3002 switch (arch)
3003 {
3004 case E_NDS_ARCH_STAR_V1_0:
3005 case E_NDS_ARCH_STAR_V2_0:
3006 case E_NDS_ARCH_STAR_V3_0:
3007 case E_NDS_ARCH_STAR_V3_M:
3008 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
3009 break;
3010
3011 default:
3012 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
3013 /* ARCH version determines how the e_flags are interpreted.
3014 If it is unknown, we cannot proceed. */
3015 return;
3016 }
3017
3018 /* Newer ABI; Now handle architecture specific flags. */
3019 if (arch == E_NDS_ARCH_STAR_V1_0)
3020 {
3021 if (config & E_NDS32_HAS_MFUSR_PC_INST)
3022 r += snprintf (buf + r, size -r, ", MFUSR_PC");
3023
3024 if (!(config & E_NDS32_HAS_NO_MAC_INST))
3025 r += snprintf (buf + r, size -r, ", MAC");
3026
3027 if (config & E_NDS32_HAS_DIV_INST)
3028 r += snprintf (buf + r, size -r, ", DIV");
3029
3030 if (config & E_NDS32_HAS_16BIT_INST)
3031 r += snprintf (buf + r, size -r, ", 16b");
3032 }
3033 else
3034 {
3035 if (config & E_NDS32_HAS_MFUSR_PC_INST)
3036 {
3037 if (version <= E_NDS32_ELF_VER_1_3)
3038 r += snprintf (buf + r, size -r, ", [B8]");
3039 else
3040 r += snprintf (buf + r, size -r, ", EX9");
3041 }
3042
3043 if (config & E_NDS32_HAS_MAC_DX_INST)
3044 r += snprintf (buf + r, size -r, ", MAC_DX");
3045
3046 if (config & E_NDS32_HAS_DIV_DX_INST)
3047 r += snprintf (buf + r, size -r, ", DIV_DX");
3048
3049 if (config & E_NDS32_HAS_16BIT_INST)
3050 {
3051 if (version <= E_NDS32_ELF_VER_1_3)
3052 r += snprintf (buf + r, size -r, ", 16b");
3053 else
3054 r += snprintf (buf + r, size -r, ", IFC");
3055 }
3056 }
3057
3058 if (config & E_NDS32_HAS_EXT_INST)
3059 r += snprintf (buf + r, size -r, ", PERF1");
3060
3061 if (config & E_NDS32_HAS_EXT2_INST)
3062 r += snprintf (buf + r, size -r, ", PERF2");
3063
3064 if (config & E_NDS32_HAS_FPU_INST)
3065 {
3066 has_fpu = TRUE;
3067 r += snprintf (buf + r, size -r, ", FPU_SP");
3068 }
3069
3070 if (config & E_NDS32_HAS_FPU_DP_INST)
3071 {
3072 has_fpu = TRUE;
3073 r += snprintf (buf + r, size -r, ", FPU_DP");
3074 }
3075
3076 if (config & E_NDS32_HAS_FPU_MAC_INST)
3077 {
3078 has_fpu = TRUE;
3079 r += snprintf (buf + r, size -r, ", FPU_MAC");
3080 }
3081
3082 if (has_fpu)
3083 {
3084 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
3085 {
3086 case E_NDS32_FPU_REG_8SP_4DP:
3087 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
3088 break;
3089 case E_NDS32_FPU_REG_16SP_8DP:
3090 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
3091 break;
3092 case E_NDS32_FPU_REG_32SP_16DP:
3093 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
3094 break;
3095 case E_NDS32_FPU_REG_32SP_32DP:
3096 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
3097 break;
3098 }
3099 }
3100
3101 if (config & E_NDS32_HAS_AUDIO_INST)
3102 r += snprintf (buf + r, size -r, ", AUDIO");
3103
3104 if (config & E_NDS32_HAS_STRING_INST)
3105 r += snprintf (buf + r, size -r, ", STR");
3106
3107 if (config & E_NDS32_HAS_REDUCED_REGS)
3108 r += snprintf (buf + r, size -r, ", 16REG");
3109
3110 if (config & E_NDS32_HAS_VIDEO_INST)
3111 {
3112 if (version <= E_NDS32_ELF_VER_1_3)
3113 r += snprintf (buf + r, size -r, ", VIDEO");
3114 else
3115 r += snprintf (buf + r, size -r, ", SATURATION");
3116 }
3117
3118 if (config & E_NDS32_HAS_ENCRIPT_INST)
3119 r += snprintf (buf + r, size -r, ", ENCRP");
3120
3121 if (config & E_NDS32_HAS_L2C_INST)
3122 r += snprintf (buf + r, size -r, ", L2C");
3123}
3124
3125static char *
3126get_machine_flags (Filedata * filedata, unsigned e_flags, unsigned e_machine)
3127{
3128 static char buf[1024];
3129
3130 buf[0] = '\0';
3131
3132 if (e_flags)
3133 {
3134 switch (e_machine)
3135 {
3136 default:
3137 break;
3138
3139 case EM_ARC_COMPACT2:
3140 case EM_ARC_COMPACT:
3141 decode_ARC_machine_flags (e_flags, e_machine, buf);
3142 break;
3143
3144 case EM_ARM:
3145 decode_ARM_machine_flags (e_flags, buf);
3146 break;
3147
3148 case EM_AVR:
3149 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
3150 break;
3151
3152 case EM_BLACKFIN:
3153 if (e_flags & EF_BFIN_PIC)
3154 strcat (buf, ", PIC");
3155
3156 if (e_flags & EF_BFIN_FDPIC)
3157 strcat (buf, ", FDPIC");
3158
3159 if (e_flags & EF_BFIN_CODE_IN_L1)
3160 strcat (buf, ", code in L1");
3161
3162 if (e_flags & EF_BFIN_DATA_IN_L1)
3163 strcat (buf, ", data in L1");
3164
3165 break;
3166
3167 case EM_CYGNUS_FRV:
3168 switch (e_flags & EF_FRV_CPU_MASK)
3169 {
3170 case EF_FRV_CPU_GENERIC:
3171 break;
3172
3173 default:
3174 strcat (buf, ", fr???");
3175 break;
3176
3177 case EF_FRV_CPU_FR300:
3178 strcat (buf, ", fr300");
3179 break;
3180
3181 case EF_FRV_CPU_FR400:
3182 strcat (buf, ", fr400");
3183 break;
3184 case EF_FRV_CPU_FR405:
3185 strcat (buf, ", fr405");
3186 break;
3187
3188 case EF_FRV_CPU_FR450:
3189 strcat (buf, ", fr450");
3190 break;
3191
3192 case EF_FRV_CPU_FR500:
3193 strcat (buf, ", fr500");
3194 break;
3195 case EF_FRV_CPU_FR550:
3196 strcat (buf, ", fr550");
3197 break;
3198
3199 case EF_FRV_CPU_SIMPLE:
3200 strcat (buf, ", simple");
3201 break;
3202 case EF_FRV_CPU_TOMCAT:
3203 strcat (buf, ", tomcat");
3204 break;
3205 }
3206 break;
3207
3208 case EM_68K:
3209 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
3210 strcat (buf, ", m68000");
3211 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3212 strcat (buf, ", cpu32");
3213 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3214 strcat (buf, ", fido_a");
3215 else
3216 {
3217 char const * isa = _("unknown");
3218 char const * mac = _("unknown mac");
3219 char const * additional = NULL;
3220
3221 switch (e_flags & EF_M68K_CF_ISA_MASK)
3222 {
3223 case EF_M68K_CF_ISA_A_NODIV:
3224 isa = "A";
3225 additional = ", nodiv";
3226 break;
3227 case EF_M68K_CF_ISA_A:
3228 isa = "A";
3229 break;
3230 case EF_M68K_CF_ISA_A_PLUS:
3231 isa = "A+";
3232 break;
3233 case EF_M68K_CF_ISA_B_NOUSP:
3234 isa = "B";
3235 additional = ", nousp";
3236 break;
3237 case EF_M68K_CF_ISA_B:
3238 isa = "B";
3239 break;
3240 case EF_M68K_CF_ISA_C:
3241 isa = "C";
3242 break;
3243 case EF_M68K_CF_ISA_C_NODIV:
3244 isa = "C";
3245 additional = ", nodiv";
3246 break;
3247 }
3248 strcat (buf, ", cf, isa ");
3249 strcat (buf, isa);
3250 if (additional)
3251 strcat (buf, additional);
3252 if (e_flags & EF_M68K_CF_FLOAT)
3253 strcat (buf, ", float");
3254 switch (e_flags & EF_M68K_CF_MAC_MASK)
3255 {
3256 case 0:
3257 mac = NULL;
3258 break;
3259 case EF_M68K_CF_MAC:
3260 mac = "mac";
3261 break;
3262 case EF_M68K_CF_EMAC:
3263 mac = "emac";
3264 break;
3265 case EF_M68K_CF_EMAC_B:
3266 mac = "emac_b";
3267 break;
3268 }
3269 if (mac)
3270 {
3271 strcat (buf, ", ");
3272 strcat (buf, mac);
3273 }
3274 }
3275 break;
3276
3277 case EM_CYGNUS_MEP:
3278 switch (e_flags & EF_MEP_CPU_MASK)
3279 {
3280 case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3281 case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3282 case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3283 case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3284 case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3285 case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3286 default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3287 }
3288
3289 switch (e_flags & EF_MEP_COP_MASK)
3290 {
3291 case EF_MEP_COP_NONE: break;
3292 case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3293 case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3294 case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3295 case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3296 default: strcat (buf, _("<unknown MeP copro type>")); break;
3297 }
3298
3299 if (e_flags & EF_MEP_LIBRARY)
3300 strcat (buf, ", Built for Library");
3301
3302 if (e_flags & EF_MEP_INDEX_MASK)
3303 sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3304 e_flags & EF_MEP_INDEX_MASK);
3305
3306 if (e_flags & ~ EF_MEP_ALL_FLAGS)
3307 sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3308 e_flags & ~ EF_MEP_ALL_FLAGS);
3309 break;
3310
3311 case EM_PPC:
3312 if (e_flags & EF_PPC_EMB)
3313 strcat (buf, ", emb");
3314
3315 if (e_flags & EF_PPC_RELOCATABLE)
3316 strcat (buf, _(", relocatable"));
3317
3318 if (e_flags & EF_PPC_RELOCATABLE_LIB)
3319 strcat (buf, _(", relocatable-lib"));
3320 break;
3321
3322 case EM_PPC64:
3323 if (e_flags & EF_PPC64_ABI)
3324 {
3325 char abi[] = ", abiv0";
3326
3327 abi[6] += e_flags & EF_PPC64_ABI;
3328 strcat (buf, abi);
3329 }
3330 break;
3331
3332 case EM_V800:
3333 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3334 strcat (buf, ", RH850 ABI");
3335
3336 if (e_flags & EF_V800_850E3)
3337 strcat (buf, ", V3 architecture");
3338
3339 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3340 strcat (buf, ", FPU not used");
3341
3342 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3343 strcat (buf, ", regmode: COMMON");
3344
3345 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3346 strcat (buf, ", r4 not used");
3347
3348 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3349 strcat (buf, ", r30 not used");
3350
3351 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3352 strcat (buf, ", r5 not used");
3353
3354 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3355 strcat (buf, ", r2 not used");
3356
3357 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3358 {
3359 switch (e_flags & - e_flags)
3360 {
3361 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3362 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3363 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3364 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3365 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3366 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3367 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3368 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3369 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3370 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3371 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3372 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3373 default: break;
3374 }
3375 }
3376 break;
3377
3378 case EM_V850:
3379 case EM_CYGNUS_V850:
3380 switch (e_flags & EF_V850_ARCH)
3381 {
3382 case E_V850E3V5_ARCH:
3383 strcat (buf, ", v850e3v5");
3384 break;
3385 case E_V850E2V3_ARCH:
3386 strcat (buf, ", v850e2v3");
3387 break;
3388 case E_V850E2_ARCH:
3389 strcat (buf, ", v850e2");
3390 break;
3391 case E_V850E1_ARCH:
3392 strcat (buf, ", v850e1");
3393 break;
3394 case E_V850E_ARCH:
3395 strcat (buf, ", v850e");
3396 break;
3397 case E_V850_ARCH:
3398 strcat (buf, ", v850");
3399 break;
3400 default:
3401 strcat (buf, _(", unknown v850 architecture variant"));
3402 break;
3403 }
3404 break;
3405
3406 case EM_M32R:
3407 case EM_CYGNUS_M32R:
3408 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3409 strcat (buf, ", m32r");
3410 break;
3411
3412 case EM_MIPS:
3413 case EM_MIPS_RS3_LE:
3414 if (e_flags & EF_MIPS_NOREORDER)
3415 strcat (buf, ", noreorder");
3416
3417 if (e_flags & EF_MIPS_PIC)
3418 strcat (buf, ", pic");
3419
3420 if (e_flags & EF_MIPS_CPIC)
3421 strcat (buf, ", cpic");
3422
3423 if (e_flags & EF_MIPS_UCODE)
3424 strcat (buf, ", ugen_reserved");
3425
3426 if (e_flags & EF_MIPS_ABI2)
3427 strcat (buf, ", abi2");
3428
3429 if (e_flags & EF_MIPS_OPTIONS_FIRST)
3430 strcat (buf, ", odk first");
3431
3432 if (e_flags & EF_MIPS_32BITMODE)
3433 strcat (buf, ", 32bitmode");
3434
3435 if (e_flags & EF_MIPS_NAN2008)
3436 strcat (buf, ", nan2008");
3437
3438 if (e_flags & EF_MIPS_FP64)
3439 strcat (buf, ", fp64");
3440
3441 switch ((e_flags & EF_MIPS_MACH))
3442 {
3443 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3444 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3445 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3446 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3447 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3448 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3449 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3450 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3451 case E_MIPS_MACH_5900: strcat (buf, ", 5900"); break;
3452 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
3453 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3454 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3455 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3456 case E_MIPS_MACH_GS464: strcat (buf, ", gs464"); break;
3457 case E_MIPS_MACH_GS464E: strcat (buf, ", gs464e"); break;
3458 case E_MIPS_MACH_GS264E: strcat (buf, ", gs264e"); break;
3459 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3460 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3461 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3462 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
3463 case E_MIPS_MACH_IAMR2: strcat (buf, ", interaptiv-mr2"); break;
3464 case 0:
3465 /* We simply ignore the field in this case to avoid confusion:
3466 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3467 extension. */
3468 break;
3469 default: strcat (buf, _(", unknown CPU")); break;
3470 }
3471
3472 switch ((e_flags & EF_MIPS_ABI))
3473 {
3474 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3475 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3476 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3477 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3478 case 0:
3479 /* We simply ignore the field in this case to avoid confusion:
3480 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3481 This means it is likely to be an o32 file, but not for
3482 sure. */
3483 break;
3484 default: strcat (buf, _(", unknown ABI")); break;
3485 }
3486
3487 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3488 strcat (buf, ", mdmx");
3489
3490 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3491 strcat (buf, ", mips16");
3492
3493 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3494 strcat (buf, ", micromips");
3495
3496 switch ((e_flags & EF_MIPS_ARCH))
3497 {
3498 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3499 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3500 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3501 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3502 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3503 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3504 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3505 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3506 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3507 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3508 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3509 default: strcat (buf, _(", unknown ISA")); break;
3510 }
3511 break;
3512
3513 case EM_NDS32:
3514 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3515 break;
3516
3517 case EM_NFP:
3518 switch (EF_NFP_MACH (e_flags))
3519 {
3520 case E_NFP_MACH_3200:
3521 strcat (buf, ", NFP-32xx");
3522 break;
3523 case E_NFP_MACH_6000:
3524 strcat (buf, ", NFP-6xxx");
3525 break;
3526 }
3527 break;
3528
3529 case EM_RISCV:
3530 if (e_flags & EF_RISCV_RVC)
3531 strcat (buf, ", RVC");
3532
3533 if (e_flags & EF_RISCV_RVE)
3534 strcat (buf, ", RVE");
3535
3536 switch (e_flags & EF_RISCV_FLOAT_ABI)
3537 {
3538 case EF_RISCV_FLOAT_ABI_SOFT:
3539 strcat (buf, ", soft-float ABI");
3540 break;
3541
3542 case EF_RISCV_FLOAT_ABI_SINGLE:
3543 strcat (buf, ", single-float ABI");
3544 break;
3545
3546 case EF_RISCV_FLOAT_ABI_DOUBLE:
3547 strcat (buf, ", double-float ABI");
3548 break;
3549
3550 case EF_RISCV_FLOAT_ABI_QUAD:
3551 strcat (buf, ", quad-float ABI");
3552 break;
3553 }
3554 break;
3555
3556 case EM_SH:
3557 switch ((e_flags & EF_SH_MACH_MASK))
3558 {
3559 case EF_SH1: strcat (buf, ", sh1"); break;
3560 case EF_SH2: strcat (buf, ", sh2"); break;
3561 case EF_SH3: strcat (buf, ", sh3"); break;
3562 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3563 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3564 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3565 case EF_SH3E: strcat (buf, ", sh3e"); break;
3566 case EF_SH4: strcat (buf, ", sh4"); break;
3567 case EF_SH5: strcat (buf, ", sh5"); break;
3568 case EF_SH2E: strcat (buf, ", sh2e"); break;
3569 case EF_SH4A: strcat (buf, ", sh4a"); break;
3570 case EF_SH2A: strcat (buf, ", sh2a"); break;
3571 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3572 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3573 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3574 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3575 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3576 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3577 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3578 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3579 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3580 default: strcat (buf, _(", unknown ISA")); break;
3581 }
3582
3583 if (e_flags & EF_SH_PIC)
3584 strcat (buf, ", pic");
3585
3586 if (e_flags & EF_SH_FDPIC)
3587 strcat (buf, ", fdpic");
3588 break;
3589
3590 case EM_OR1K:
3591 if (e_flags & EF_OR1K_NODELAY)
3592 strcat (buf, ", no delay");
3593 break;
3594
3595 case EM_SPARCV9:
3596 if (e_flags & EF_SPARC_32PLUS)
3597 strcat (buf, ", v8+");
3598
3599 if (e_flags & EF_SPARC_SUN_US1)
3600 strcat (buf, ", ultrasparcI");
3601
3602 if (e_flags & EF_SPARC_SUN_US3)
3603 strcat (buf, ", ultrasparcIII");
3604
3605 if (e_flags & EF_SPARC_HAL_R1)
3606 strcat (buf, ", halr1");
3607
3608 if (e_flags & EF_SPARC_LEDATA)
3609 strcat (buf, ", ledata");
3610
3611 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3612 strcat (buf, ", tso");
3613
3614 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3615 strcat (buf, ", pso");
3616
3617 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3618 strcat (buf, ", rmo");
3619 break;
3620
3621 case EM_PARISC:
3622 switch (e_flags & EF_PARISC_ARCH)
3623 {
3624 case EFA_PARISC_1_0:
3625 strcpy (buf, ", PA-RISC 1.0");
3626 break;
3627 case EFA_PARISC_1_1:
3628 strcpy (buf, ", PA-RISC 1.1");
3629 break;
3630 case EFA_PARISC_2_0:
3631 strcpy (buf, ", PA-RISC 2.0");
3632 break;
3633 default:
3634 break;
3635 }
3636 if (e_flags & EF_PARISC_TRAPNIL)
3637 strcat (buf, ", trapnil");
3638 if (e_flags & EF_PARISC_EXT)
3639 strcat (buf, ", ext");
3640 if (e_flags & EF_PARISC_LSB)
3641 strcat (buf, ", lsb");
3642 if (e_flags & EF_PARISC_WIDE)
3643 strcat (buf, ", wide");
3644 if (e_flags & EF_PARISC_NO_KABP)
3645 strcat (buf, ", no kabp");
3646 if (e_flags & EF_PARISC_LAZYSWAP)
3647 strcat (buf, ", lazyswap");
3648 break;
3649
3650 case EM_PJ:
3651 case EM_PJ_OLD:
3652 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3653 strcat (buf, ", new calling convention");
3654
3655 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3656 strcat (buf, ", gnu calling convention");
3657 break;
3658
3659 case EM_IA_64:
3660 if ((e_flags & EF_IA_64_ABI64))
3661 strcat (buf, ", 64-bit");
3662 else
3663 strcat (buf, ", 32-bit");
3664 if ((e_flags & EF_IA_64_REDUCEDFP))
3665 strcat (buf, ", reduced fp model");
3666 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3667 strcat (buf, ", no function descriptors, constant gp");
3668 else if ((e_flags & EF_IA_64_CONS_GP))
3669 strcat (buf, ", constant gp");
3670 if ((e_flags & EF_IA_64_ABSOLUTE))
3671 strcat (buf, ", absolute");
3672 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3673 {
3674 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3675 strcat (buf, ", vms_linkages");
3676 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3677 {
3678 case EF_IA_64_VMS_COMCOD_SUCCESS:
3679 break;
3680 case EF_IA_64_VMS_COMCOD_WARNING:
3681 strcat (buf, ", warning");
3682 break;
3683 case EF_IA_64_VMS_COMCOD_ERROR:
3684 strcat (buf, ", error");
3685 break;
3686 case EF_IA_64_VMS_COMCOD_ABORT:
3687 strcat (buf, ", abort");
3688 break;
3689 default:
3690 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3691 e_flags & EF_IA_64_VMS_COMCOD);
3692 strcat (buf, ", <unknown>");
3693 }
3694 }
3695 break;
3696
3697 case EM_VAX:
3698 if ((e_flags & EF_VAX_NONPIC))
3699 strcat (buf, ", non-PIC");
3700 if ((e_flags & EF_VAX_DFLOAT))
3701 strcat (buf, ", D-Float");
3702 if ((e_flags & EF_VAX_GFLOAT))
3703 strcat (buf, ", G-Float");
3704 break;
3705
3706 case EM_VISIUM:
3707 if (e_flags & EF_VISIUM_ARCH_MCM)
3708 strcat (buf, ", mcm");
3709 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3710 strcat (buf, ", mcm24");
3711 if (e_flags & EF_VISIUM_ARCH_GR6)
3712 strcat (buf, ", gr6");
3713 break;
3714
3715 case EM_RL78:
3716 switch (e_flags & E_FLAG_RL78_CPU_MASK)
3717 {
3718 case E_FLAG_RL78_ANY_CPU: break;
3719 case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3720 case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3721 case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3722 }
3723 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3724 strcat (buf, ", 64-bit doubles");
3725 break;
3726
3727 case EM_RX:
3728 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3729 strcat (buf, ", 64-bit doubles");
3730 if (e_flags & E_FLAG_RX_DSP)
3731 strcat (buf, ", dsp");
3732 if (e_flags & E_FLAG_RX_PID)
3733 strcat (buf, ", pid");
3734 if (e_flags & E_FLAG_RX_ABI)
3735 strcat (buf, ", RX ABI");
3736 if (e_flags & E_FLAG_RX_SINSNS_SET)
3737 strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3738 ? ", uses String instructions" : ", bans String instructions");
3739 if (e_flags & E_FLAG_RX_V2)
3740 strcat (buf, ", V2");
3741 if (e_flags & E_FLAG_RX_V3)
3742 strcat (buf, ", V3");
3743 break;
3744
3745 case EM_S390:
3746 if (e_flags & EF_S390_HIGH_GPRS)
3747 strcat (buf, ", highgprs");
3748 break;
3749
3750 case EM_TI_C6000:
3751 if ((e_flags & EF_C6000_REL))
3752 strcat (buf, ", relocatable module");
3753 break;
3754
3755 case EM_MSP430:
3756 strcat (buf, _(": architecture variant: "));
3757 switch (e_flags & EF_MSP430_MACH)
3758 {
3759 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3760 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3761 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3762 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3763 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3764 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3765 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3766 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3767 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3768 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3769 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3770 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3771 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3772 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3773 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3774 default:
3775 strcat (buf, _(": unknown")); break;
3776 }
3777
3778 if (e_flags & ~ EF_MSP430_MACH)
3779 strcat (buf, _(": unknown extra flag bits also present"));
3780 break;
3781
3782 case EM_Z80:
3783 switch (e_flags & EF_Z80_MACH_MSK)
3784 {
3785 case EF_Z80_MACH_Z80: strcat (buf, ", Z80"); break;
3786 case EF_Z80_MACH_Z180: strcat (buf, ", Z180"); break;
3787 case EF_Z80_MACH_R800: strcat (buf, ", R800"); break;
3788 case EF_Z80_MACH_EZ80_Z80: strcat (buf, ", EZ80"); break;
3789 case EF_Z80_MACH_EZ80_ADL: strcat (buf, ", EZ80, ADL"); break;
3790 case EF_Z80_MACH_GBZ80: strcat (buf, ", GBZ80"); break;
3791 case EF_Z80_MACH_Z80N: strcat (buf, ", Z80N"); break;
3792 default:
3793 strcat (buf, _(", unknown")); break;
3794 }
3795 break;
3796 }
3797 }
3798
3799 return buf;
3800}
3801
3802static const char *
3803get_osabi_name (Filedata * filedata, unsigned int osabi)
3804{
3805 static char buff[32];
3806
3807 switch (osabi)
3808 {
3809 case ELFOSABI_NONE: return "UNIX - System V";
3810 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3811 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
3812 case ELFOSABI_GNU: return "UNIX - GNU";
3813 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3814 case ELFOSABI_AIX: return "UNIX - AIX";
3815 case ELFOSABI_IRIX: return "UNIX - IRIX";
3816 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3817 case ELFOSABI_TRU64: return "UNIX - TRU64";
3818 case ELFOSABI_MODESTO: return "Novell - Modesto";
3819 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3820 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3821 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3822 case ELFOSABI_AROS: return "AROS";
3823 case ELFOSABI_FENIXOS: return "FenixOS";
3824 case ELFOSABI_CLOUDABI: return "Nuxi CloudABI";
3825 case ELFOSABI_OPENVOS: return "Stratus Technologies OpenVOS";
3826 default:
3827 if (osabi >= 64)
3828 switch (filedata->file_header.e_machine)
3829 {
3830 case EM_ARM:
3831 switch (osabi)
3832 {
3833 case ELFOSABI_ARM: return "ARM";
3834 case ELFOSABI_ARM_FDPIC: return "ARM FDPIC";
3835 default:
3836 break;
3837 }
3838 break;
3839
3840 case EM_MSP430:
3841 case EM_MSP430_OLD:
3842 case EM_VISIUM:
3843 switch (osabi)
3844 {
3845 case ELFOSABI_STANDALONE: return _("Standalone App");
3846 default:
3847 break;
3848 }
3849 break;
3850
3851 case EM_TI_C6000:
3852 switch (osabi)
3853 {
3854 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3855 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3856 default:
3857 break;
3858 }
3859 break;
3860
3861 default:
3862 break;
3863 }
3864 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3865 return buff;
3866 }
3867}
3868
3869static const char *
3870get_aarch64_segment_type (unsigned long type)
3871{
3872 switch (type)
3873 {
3874 case PT_AARCH64_ARCHEXT: return "AARCH64_ARCHEXT";
3875 default: return NULL;
3876 }
3877}
3878
3879static const char *
3880get_arm_segment_type (unsigned long type)
3881{
3882 switch (type)
3883 {
3884 case PT_ARM_EXIDX: return "EXIDX";
3885 default: return NULL;
3886 }
3887}
3888
3889static const char *
3890get_s390_segment_type (unsigned long type)
3891{
3892 switch (type)
3893 {
3894 case PT_S390_PGSTE: return "S390_PGSTE";
3895 default: return NULL;
3896 }
3897}
3898
3899static const char *
3900get_mips_segment_type (unsigned long type)
3901{
3902 switch (type)
3903 {
3904 case PT_MIPS_REGINFO: return "REGINFO";
3905 case PT_MIPS_RTPROC: return "RTPROC";
3906 case PT_MIPS_OPTIONS: return "OPTIONS";
3907 case PT_MIPS_ABIFLAGS: return "ABIFLAGS";
3908 default: return NULL;
3909 }
3910}
3911
3912static const char *
3913get_parisc_segment_type (unsigned long type)
3914{
3915 switch (type)
3916 {
3917 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3918 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
3919 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
3920 default: return NULL;
3921 }
3922}
3923
3924static const char *
3925get_ia64_segment_type (unsigned long type)
3926{
3927 switch (type)
3928 {
3929 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3930 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
3931 default: return NULL;
3932 }
3933}
3934
3935static const char *
3936get_tic6x_segment_type (unsigned long type)
3937{
3938 switch (type)
3939 {
3940 case PT_C6000_PHATTR: return "C6000_PHATTR";
3941 default: return NULL;
3942 }
3943}
3944
3945static const char *
3946get_hpux_segment_type (unsigned long type, unsigned e_machine)
3947{
3948 if (e_machine == EM_PARISC)
3949 switch (type)
3950 {
3951 case PT_HP_TLS: return "HP_TLS";
3952 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3953 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3954 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3955 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3956 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3957 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3958 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3959 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3960 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3961 case PT_HP_PARALLEL: return "HP_PARALLEL";
3962 case PT_HP_FASTBIND: return "HP_FASTBIND";
3963 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3964 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3965 case PT_HP_STACK: return "HP_STACK";
3966 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
3967 default: return NULL;
3968 }
3969
3970 if (e_machine == EM_IA_64)
3971 switch (type)
3972 {
3973 case PT_HP_TLS: return "HP_TLS";
3974 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3975 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3976 case PT_IA_64_HP_STACK: return "HP_STACK";
3977 default: return NULL;
3978 }
3979
3980 return NULL;
3981}
3982
3983static const char *
3984get_solaris_segment_type (unsigned long type)
3985{
3986 switch (type)
3987 {
3988 case 0x6464e550: return "PT_SUNW_UNWIND";
3989 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3990 case 0x6ffffff7: return "PT_LOSUNW";
3991 case 0x6ffffffa: return "PT_SUNWBSS";
3992 case 0x6ffffffb: return "PT_SUNWSTACK";
3993 case 0x6ffffffc: return "PT_SUNWDTRACE";
3994 case 0x6ffffffd: return "PT_SUNWCAP";
3995 case 0x6fffffff: return "PT_HISUNW";
3996 default: return NULL;
3997 }
3998}
3999
4000static const char *
4001get_segment_type (Filedata * filedata, unsigned long p_type)
4002{
4003 static char buff[32];
4004
4005 switch (p_type)
4006 {
4007 case PT_NULL: return "NULL";
4008 case PT_LOAD: return "LOAD";
4009 case PT_DYNAMIC: return "DYNAMIC";
4010 case PT_INTERP: return "INTERP";
4011 case PT_NOTE: return "NOTE";
4012 case PT_SHLIB: return "SHLIB";
4013 case PT_PHDR: return "PHDR";
4014 case PT_TLS: return "TLS";
4015 case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
4016 case PT_GNU_STACK: return "GNU_STACK";
4017 case PT_GNU_RELRO: return "GNU_RELRO";
4018 case PT_GNU_PROPERTY: return "GNU_PROPERTY";
4019
4020 default:
4021 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
4022 {
4023 const char * result;
4024
4025 switch (filedata->file_header.e_machine)
4026 {
4027 case EM_AARCH64:
4028 result = get_aarch64_segment_type (p_type);
4029 break;
4030 case EM_ARM:
4031 result = get_arm_segment_type (p_type);
4032 break;
4033 case EM_MIPS:
4034 case EM_MIPS_RS3_LE:
4035 result = get_mips_segment_type (p_type);
4036 break;
4037 case EM_PARISC:
4038 result = get_parisc_segment_type (p_type);
4039 break;
4040 case EM_IA_64:
4041 result = get_ia64_segment_type (p_type);
4042 break;
4043 case EM_TI_C6000:
4044 result = get_tic6x_segment_type (p_type);
4045 break;
4046 case EM_S390:
4047 case EM_S390_OLD:
4048 result = get_s390_segment_type (p_type);
4049 break;
4050 default:
4051 result = NULL;
4052 break;
4053 }
4054
4055 if (result != NULL)
4056 return result;
4057
4058 sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
4059 }
4060 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
4061 {
4062 const char * result = NULL;
4063
4064 switch (filedata->file_header.e_ident[EI_OSABI])
4065 {
4066 case ELFOSABI_GNU:
4067 case ELFOSABI_FREEBSD:
4068 if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
4069 {
4070 sprintf (buff, "GNU_MBIND+%#lx", p_type - PT_GNU_MBIND_LO);
4071 result = buff;
4072 }
4073 break;
4074 case ELFOSABI_HPUX:
4075 result = get_hpux_segment_type (p_type,
4076 filedata->file_header.e_machine);
4077 break;
4078 case ELFOSABI_SOLARIS:
4079 result = get_solaris_segment_type (p_type);
4080 break;
4081 default:
4082 break;
4083 }
4084 if (result != NULL)
4085 return result;
4086
4087 sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
4088 }
4089 else
4090 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
4091
4092 return buff;
4093 }
4094}
4095
4096static const char *
4097get_arc_section_type_name (unsigned int sh_type)
4098{
4099 switch (sh_type)
4100 {
4101 case SHT_ARC_ATTRIBUTES: return "ARC_ATTRIBUTES";
4102 default:
4103 break;
4104 }
4105 return NULL;
4106}
4107
4108static const char *
4109get_mips_section_type_name (unsigned int sh_type)
4110{
4111 switch (sh_type)
4112 {
4113 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
4114 case SHT_MIPS_MSYM: return "MIPS_MSYM";
4115 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
4116 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
4117 case SHT_MIPS_UCODE: return "MIPS_UCODE";
4118 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
4119 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
4120 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
4121 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
4122 case SHT_MIPS_RELD: return "MIPS_RELD";
4123 case SHT_MIPS_IFACE: return "MIPS_IFACE";
4124 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
4125 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
4126 case SHT_MIPS_SHDR: return "MIPS_SHDR";
4127 case SHT_MIPS_FDESC: return "MIPS_FDESC";
4128 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
4129 case SHT_MIPS_DENSE: return "MIPS_DENSE";
4130 case SHT_MIPS_PDESC: return "MIPS_PDESC";
4131 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
4132 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
4133 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
4134 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
4135 case SHT_MIPS_LINE: return "MIPS_LINE";
4136 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
4137 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
4138 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
4139 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
4140 case SHT_MIPS_DWARF: return "MIPS_DWARF";
4141 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
4142 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
4143 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
4144 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
4145 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
4146 case SHT_MIPS_XLATE: return "MIPS_XLATE";
4147 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
4148 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
4149 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
4150 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
4151 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
4152 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
4153 case SHT_MIPS_XHASH: return "MIPS_XHASH";
4154 default:
4155 break;
4156 }
4157 return NULL;
4158}
4159
4160static const char *
4161get_parisc_section_type_name (unsigned int sh_type)
4162{
4163 switch (sh_type)
4164 {
4165 case SHT_PARISC_EXT: return "PARISC_EXT";
4166 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
4167 case SHT_PARISC_DOC: return "PARISC_DOC";
4168 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
4169 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
4170 case SHT_PARISC_STUBS: return "PARISC_STUBS";
4171 case SHT_PARISC_DLKM: return "PARISC_DLKM";
4172 default: return NULL;
4173 }
4174}
4175
4176static const char *
4177get_ia64_section_type_name (Filedata * filedata, unsigned int sh_type)
4178{
4179 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4180 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
4181 return get_osabi_name (filedata, (sh_type & 0x00FF0000) >> 16);
4182
4183 switch (sh_type)
4184 {
4185 case SHT_IA_64_EXT: return "IA_64_EXT";
4186 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
4187 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
4188 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
4189 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
4190 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
4191 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
4192 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
4193 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
4194 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4195 default:
4196 break;
4197 }
4198 return NULL;
4199}
4200
4201static const char *
4202get_x86_64_section_type_name (unsigned int sh_type)
4203{
4204 switch (sh_type)
4205 {
4206 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
4207 default: return NULL;
4208 }
4209}
4210
4211static const char *
4212get_aarch64_section_type_name (unsigned int sh_type)
4213{
4214 switch (sh_type)
4215 {
4216 case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4217 default: return NULL;
4218 }
4219}
4220
4221static const char *
4222get_arm_section_type_name (unsigned int sh_type)
4223{
4224 switch (sh_type)
4225 {
4226 case SHT_ARM_EXIDX: return "ARM_EXIDX";
4227 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
4228 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
4229 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
4230 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
4231 default: return NULL;
4232 }
4233}
4234
4235static const char *
4236get_tic6x_section_type_name (unsigned int sh_type)
4237{
4238 switch (sh_type)
4239 {
4240 case SHT_C6000_UNWIND: return "C6000_UNWIND";
4241 case SHT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
4242 case SHT_C6000_ATTRIBUTES: return "C6000_ATTRIBUTES";
4243 case SHT_TI_ICODE: return "TI_ICODE";
4244 case SHT_TI_XREF: return "TI_XREF";
4245 case SHT_TI_HANDLER: return "TI_HANDLER";
4246 case SHT_TI_INITINFO: return "TI_INITINFO";
4247 case SHT_TI_PHATTRS: return "TI_PHATTRS";
4248 default: return NULL;
4249 }
4250}
4251
4252static const char *
4253get_msp430x_section_type_name (unsigned int sh_type)
4254{
4255 switch (sh_type)
4256 {
4257 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
4258 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
4259 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
4260 default: return NULL;
4261 }
4262}
4263
4264static const char *
4265get_nfp_section_type_name (unsigned int sh_type)
4266{
4267 switch (sh_type)
4268 {
4269 case SHT_NFP_MECONFIG: return "NFP_MECONFIG";
4270 case SHT_NFP_INITREG: return "NFP_INITREG";
4271 case SHT_NFP_UDEBUG: return "NFP_UDEBUG";
4272 default: return NULL;
4273 }
4274}
4275
4276static const char *
4277get_v850_section_type_name (unsigned int sh_type)
4278{
4279 switch (sh_type)
4280 {
4281 case SHT_V850_SCOMMON: return "V850 Small Common";
4282 case SHT_V850_TCOMMON: return "V850 Tiny Common";
4283 case SHT_V850_ZCOMMON: return "V850 Zero Common";
4284 case SHT_RENESAS_IOP: return "RENESAS IOP";
4285 case SHT_RENESAS_INFO: return "RENESAS INFO";
4286 default: return NULL;
4287 }
4288}
4289
4290static const char *
4291get_riscv_section_type_name (unsigned int sh_type)
4292{
4293 switch (sh_type)
4294 {
4295 case SHT_RISCV_ATTRIBUTES: return "RISCV_ATTRIBUTES";
4296 default: return NULL;
4297 }
4298}
4299
4300static const char *
4301get_section_type_name (Filedata * filedata, unsigned int sh_type)
4302{
4303 static char buff[32];
4304 const char * result;
4305
4306 switch (sh_type)
4307 {
4308 case SHT_NULL: return "NULL";
4309 case SHT_PROGBITS: return "PROGBITS";
4310 case SHT_SYMTAB: return "SYMTAB";
4311 case SHT_STRTAB: return "STRTAB";
4312 case SHT_RELA: return "RELA";
4313 case SHT_HASH: return "HASH";
4314 case SHT_DYNAMIC: return "DYNAMIC";
4315 case SHT_NOTE: return "NOTE";
4316 case SHT_NOBITS: return "NOBITS";
4317 case SHT_REL: return "REL";
4318 case SHT_SHLIB: return "SHLIB";
4319 case SHT_DYNSYM: return "DYNSYM";
4320 case SHT_INIT_ARRAY: return "INIT_ARRAY";
4321 case SHT_FINI_ARRAY: return "FINI_ARRAY";
4322 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
4323 case SHT_GNU_HASH: return "GNU_HASH";
4324 case SHT_GROUP: return "GROUP";
4325 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICES";
4326 case SHT_GNU_verdef: return "VERDEF";
4327 case SHT_GNU_verneed: return "VERNEED";
4328 case SHT_GNU_versym: return "VERSYM";
4329 case 0x6ffffff0: return "VERSYM";
4330 case 0x6ffffffc: return "VERDEF";
4331 case 0x7ffffffd: return "AUXILIARY";
4332 case 0x7fffffff: return "FILTER";
4333 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
4334
4335 default:
4336 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4337 {
4338 switch (filedata->file_header.e_machine)
4339 {
4340 case EM_ARC:
4341 case EM_ARC_COMPACT:
4342 case EM_ARC_COMPACT2:
4343 result = get_arc_section_type_name (sh_type);
4344 break;
4345 case EM_MIPS:
4346 case EM_MIPS_RS3_LE:
4347 result = get_mips_section_type_name (sh_type);
4348 break;
4349 case EM_PARISC:
4350 result = get_parisc_section_type_name (sh_type);
4351 break;
4352 case EM_IA_64:
4353 result = get_ia64_section_type_name (filedata, sh_type);
4354 break;
4355 case EM_X86_64:
4356 case EM_L1OM:
4357 case EM_K1OM:
4358 result = get_x86_64_section_type_name (sh_type);
4359 break;
4360 case EM_AARCH64:
4361 result = get_aarch64_section_type_name (sh_type);
4362 break;
4363 case EM_ARM:
4364 result = get_arm_section_type_name (sh_type);
4365 break;
4366 case EM_TI_C6000:
4367 result = get_tic6x_section_type_name (sh_type);
4368 break;
4369 case EM_MSP430:
4370 result = get_msp430x_section_type_name (sh_type);
4371 break;
4372 case EM_NFP:
4373 result = get_nfp_section_type_name (sh_type);
4374 break;
4375 case EM_V800:
4376 case EM_V850:
4377 case EM_CYGNUS_V850:
4378 result = get_v850_section_type_name (sh_type);
4379 break;
4380 case EM_RISCV:
4381 result = get_riscv_section_type_name (sh_type);
4382 break;
4383 default:
4384 result = NULL;
4385 break;
4386 }
4387
4388 if (result != NULL)
4389 return result;
4390
4391 sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4392 }
4393 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4394 {
4395 switch (filedata->file_header.e_machine)
4396 {
4397 case EM_IA_64:
4398 result = get_ia64_section_type_name (filedata, sh_type);
4399 break;
4400 default:
4401 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4402 result = get_solaris_section_type (sh_type);
4403 else
4404 {
4405 switch (sh_type)
4406 {
4407 case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4408 case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4409 case SHT_GNU_HASH: result = "GNU_HASH"; break;
4410 case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4411 default:
4412 result = NULL;
4413 break;
4414 }
4415 }
4416 break;
4417 }
4418
4419 if (result != NULL)
4420 return result;
4421
4422 sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4423 }
4424 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4425 {
4426 switch (filedata->file_header.e_machine)
4427 {
4428 case EM_V800:
4429 case EM_V850:
4430 case EM_CYGNUS_V850:
4431 result = get_v850_section_type_name (sh_type);
4432 break;
4433 default:
4434 result = NULL;
4435 break;
4436 }
4437
4438 if (result != NULL)
4439 return result;
4440
4441 sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4442 }
4443 else
4444 /* This message is probably going to be displayed in a 15
4445 character wide field, so put the hex value first. */
4446 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4447
4448 return buff;
4449 }
4450}
4451
4452#define OPTION_DEBUG_DUMP 512
4453#define OPTION_DYN_SYMS 513
4454#define OPTION_DWARF_DEPTH 514
4455#define OPTION_DWARF_START 515
4456#define OPTION_DWARF_CHECK 516
4457#define OPTION_CTF_DUMP 517
4458#define OPTION_CTF_PARENT 518
4459#define OPTION_CTF_SYMBOLS 519
4460#define OPTION_CTF_STRINGS 520
4461
4462static struct option options[] =
4463{
4464 {"all", no_argument, 0, 'a'},
4465 {"file-header", no_argument, 0, 'h'},
4466 {"program-headers", no_argument, 0, 'l'},
4467 {"headers", no_argument, 0, 'e'},
4468 {"histogram", no_argument, 0, 'I'},
4469 {"segments", no_argument, 0, 'l'},
4470 {"sections", no_argument, 0, 'S'},
4471 {"section-headers", no_argument, 0, 'S'},
4472 {"section-groups", no_argument, 0, 'g'},
4473 {"section-details", no_argument, 0, 't'},
4474 {"full-section-name",no_argument, 0, 'N'},
4475 {"symbols", no_argument, 0, 's'},
4476 {"syms", no_argument, 0, 's'},
4477 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
4478 {"relocs", no_argument, 0, 'r'},
4479 {"notes", no_argument, 0, 'n'},
4480 {"dynamic", no_argument, 0, 'd'},
4481 {"arch-specific", no_argument, 0, 'A'},
4482 {"version-info", no_argument, 0, 'V'},
4483 {"use-dynamic", no_argument, 0, 'D'},
4484 {"unwind", no_argument, 0, 'u'},
4485 {"archive-index", no_argument, 0, 'c'},
4486 {"hex-dump", required_argument, 0, 'x'},
4487 {"relocated-dump", required_argument, 0, 'R'},
4488 {"string-dump", required_argument, 0, 'p'},
4489 {"decompress", no_argument, 0, 'z'},
4490#ifdef SUPPORT_DISASSEMBLY
4491 {"instruction-dump", required_argument, 0, 'i'},
4492#endif
4493 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
4494
4495 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
4496 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4497 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
4498
4499 {"ctf", required_argument, 0, OPTION_CTF_DUMP},
4500
4501 {"ctf-symbols", required_argument, 0, OPTION_CTF_SYMBOLS},
4502 {"ctf-strings", required_argument, 0, OPTION_CTF_STRINGS},
4503 {"ctf-parent", required_argument, 0, OPTION_CTF_PARENT},
4504
4505 {"version", no_argument, 0, 'v'},
4506 {"wide", no_argument, 0, 'W'},
4507 {"help", no_argument, 0, 'H'},
4508 {0, no_argument, 0, 0}
4509};
4510
4511static void
4512usage (FILE * stream)
4513{
4514 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4515 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4516 fprintf (stream, _(" Options are:\n\
4517 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4518 -h --file-header Display the ELF file header\n\
4519 -l --program-headers Display the program headers\n\
4520 --segments An alias for --program-headers\n\
4521 -S --section-headers Display the sections' header\n\
4522 --sections An alias for --section-headers\n\
4523 -g --section-groups Display the section groups\n\
4524 -t --section-details Display the section details\n\
4525 -e --headers Equivalent to: -h -l -S\n\
4526 -s --syms Display the symbol table\n\
4527 --symbols An alias for --syms\n\
4528 --dyn-syms Display the dynamic symbol table\n\
4529 -n --notes Display the core notes (if present)\n\
4530 -r --relocs Display the relocations (if present)\n\
4531 -u --unwind Display the unwind info (if present)\n\
4532 -d --dynamic Display the dynamic section (if present)\n\
4533 -V --version-info Display the version sections (if present)\n\
4534 -A --arch-specific Display architecture specific information (if any)\n\
4535 -c --archive-index Display the symbol/file index in an archive\n\
4536 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4537 -x --hex-dump=<number|name>\n\
4538 Dump the contents of section <number|name> as bytes\n\
4539 -p --string-dump=<number|name>\n\
4540 Dump the contents of section <number|name> as strings\n\
4541 -R --relocated-dump=<number|name>\n\
4542 Dump the contents of section <number|name> as relocated bytes\n\
4543 -z --decompress Decompress section before dumping it\n\
4544 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4545 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4546 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4547 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4548 =addr,=cu_index,=links,=follow-links]\n\
4549 Display the contents of DWARF debug sections\n"));
4550 fprintf (stream, _("\
4551 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4552 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4553 or deeper\n"));
4554 fprintf (stream, _("\
4555 --ctf=<number|name> Display CTF info from section <number|name>\n\
4556 --ctf-parent=<number|name>\n\
4557 Use section <number|name> as the CTF parent\n\n\
4558 --ctf-symbols=<number|name>\n\
4559 Use section <number|name> as the CTF external symtab\n\n\
4560 --ctf-strings=<number|name>\n\
4561 Use section <number|name> as the CTF external strtab\n\n"));
4562
4563#ifdef SUPPORT_DISASSEMBLY
4564 fprintf (stream, _("\
4565 -i --instruction-dump=<number|name>\n\
4566 Disassemble the contents of section <number|name>\n"));
4567#endif
4568 fprintf (stream, _("\
4569 -I --histogram Display histogram of bucket list lengths\n\
4570 -W --wide Allow output width to exceed 80 characters\n\
4571 @<file> Read options from <file>\n\
4572 -H --help Display this information\n\
4573 -v --version Display the version number of readelf\n"));
4574
4575 if (REPORT_BUGS_TO[0] && stream == stdout)
4576 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4577
4578 exit (stream == stdout ? 0 : 1);
4579}
4580
4581/* Record the fact that the user wants the contents of section number
4582 SECTION to be displayed using the method(s) encoded as flags bits
4583 in TYPE. Note, TYPE can be zero if we are creating the array for
4584 the first time. */
4585
4586static void
4587request_dump_bynumber (struct dump_data *dumpdata,
4588 unsigned int section, dump_type type)
4589{
4590 if (section >= dumpdata->num_dump_sects)
4591 {
4592 dump_type * new_dump_sects;
4593
4594 new_dump_sects = (dump_type *) calloc (section + 1,
4595 sizeof (* new_dump_sects));
4596
4597 if (new_dump_sects == NULL)
4598 error (_("Out of memory allocating dump request table.\n"));
4599 else
4600 {
4601 if (dumpdata->dump_sects)
4602 {
4603 /* Copy current flag settings. */
4604 memcpy (new_dump_sects, dumpdata->dump_sects,
4605 dumpdata->num_dump_sects * sizeof (* new_dump_sects));
4606
4607 free (dumpdata->dump_sects);
4608 }
4609
4610 dumpdata->dump_sects = new_dump_sects;
4611 dumpdata->num_dump_sects = section + 1;
4612 }
4613 }
4614
4615 if (dumpdata->dump_sects)
4616 dumpdata->dump_sects[section] |= type;
4617}
4618
4619/* Request a dump by section name. */
4620
4621static void
4622request_dump_byname (const char * section, dump_type type)
4623{
4624 struct dump_list_entry * new_request;
4625
4626 new_request = (struct dump_list_entry *)
4627 malloc (sizeof (struct dump_list_entry));
4628 if (!new_request)
4629 error (_("Out of memory allocating dump request table.\n"));
4630
4631 new_request->name = strdup (section);
4632 if (!new_request->name)
4633 error (_("Out of memory allocating dump request table.\n"));
4634
4635 new_request->type = type;
4636
4637 new_request->next = dump_sects_byname;
4638 dump_sects_byname = new_request;
4639}
4640
4641static inline void
4642request_dump (struct dump_data *dumpdata, dump_type type)
4643{
4644 int section;
4645 char * cp;
4646
4647 do_dump++;
4648 section = strtoul (optarg, & cp, 0);
4649
4650 if (! *cp && section >= 0)
4651 request_dump_bynumber (dumpdata, section, type);
4652 else
4653 request_dump_byname (optarg, type);
4654}
4655
4656static void
4657parse_args (struct dump_data *dumpdata, int argc, char ** argv)
4658{
4659 int c;
4660
4661 if (argc < 2)
4662 usage (stderr);
4663
4664 while ((c = getopt_long
4665 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4666 {
4667 switch (c)
4668 {
4669 case 0:
4670 /* Long options. */
4671 break;
4672 case 'H':
4673 usage (stdout);
4674 break;
4675
4676 case 'a':
4677 do_syms = TRUE;
4678 do_reloc = TRUE;
4679 do_unwind = TRUE;
4680 do_dynamic = TRUE;
4681 do_header = TRUE;
4682 do_sections = TRUE;
4683 do_section_groups = TRUE;
4684 do_segments = TRUE;
4685 do_version = TRUE;
4686 do_histogram = TRUE;
4687 do_arch = TRUE;
4688 do_notes = TRUE;
4689 break;
4690 case 'g':
4691 do_section_groups = TRUE;
4692 break;
4693 case 't':
4694 case 'N':
4695 do_sections = TRUE;
4696 do_section_details = TRUE;
4697 break;
4698 case 'e':
4699 do_header = TRUE;
4700 do_sections = TRUE;
4701 do_segments = TRUE;
4702 break;
4703 case 'A':
4704 do_arch = TRUE;
4705 break;
4706 case 'D':
4707 do_using_dynamic = TRUE;
4708 break;
4709 case 'r':
4710 do_reloc = TRUE;
4711 break;
4712 case 'u':
4713 do_unwind = TRUE;
4714 break;
4715 case 'h':
4716 do_header = TRUE;
4717 break;
4718 case 'l':
4719 do_segments = TRUE;
4720 break;
4721 case 's':
4722 do_syms = TRUE;
4723 break;
4724 case 'S':
4725 do_sections = TRUE;
4726 break;
4727 case 'd':
4728 do_dynamic = TRUE;
4729 break;
4730 case 'I':
4731 do_histogram = TRUE;
4732 break;
4733 case 'n':
4734 do_notes = TRUE;
4735 break;
4736 case 'c':
4737 do_archive_index = TRUE;
4738 break;
4739 case 'x':
4740 request_dump (dumpdata, HEX_DUMP);
4741 break;
4742 case 'p':
4743 request_dump (dumpdata, STRING_DUMP);
4744 break;
4745 case 'R':
4746 request_dump (dumpdata, RELOC_DUMP);
4747 break;
4748 case 'z':
4749 decompress_dumps = TRUE;
4750 break;
4751 case 'w':
4752 do_dump = TRUE;
4753 if (optarg == 0)
4754 {
4755 do_debugging = TRUE;
4756 dwarf_select_sections_all ();
4757 }
4758 else
4759 {
4760 do_debugging = FALSE;
4761 dwarf_select_sections_by_letters (optarg);
4762 }
4763 break;
4764 case OPTION_DEBUG_DUMP:
4765 do_dump = TRUE;
4766 if (optarg == 0)
4767 do_debugging = TRUE;
4768 else
4769 {
4770 do_debugging = FALSE;
4771 dwarf_select_sections_by_names (optarg);
4772 }
4773 break;
4774 case OPTION_DWARF_DEPTH:
4775 {
4776 char *cp;
4777
4778 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4779 }
4780 break;
4781 case OPTION_DWARF_START:
4782 {
4783 char *cp;
4784
4785 dwarf_start_die = strtoul (optarg, & cp, 0);
4786 }
4787 break;
4788 case OPTION_DWARF_CHECK:
4789 dwarf_check = TRUE;
4790 break;
4791 case OPTION_CTF_DUMP:
4792 do_ctf = TRUE;
4793 request_dump (dumpdata, CTF_DUMP);
4794 break;
4795 case OPTION_CTF_SYMBOLS:
4796 dump_ctf_symtab_name = strdup (optarg);
4797 break;
4798 case OPTION_CTF_STRINGS:
4799 dump_ctf_strtab_name = strdup (optarg);
4800 break;
4801 case OPTION_CTF_PARENT:
4802 dump_ctf_parent_name = strdup (optarg);
4803 break;
4804 case OPTION_DYN_SYMS:
4805 do_dyn_syms = TRUE;
4806 break;
4807#ifdef SUPPORT_DISASSEMBLY
4808 case 'i':
4809 request_dump (dumpdata, DISASS_DUMP);
4810 break;
4811#endif
4812 case 'v':
4813 print_version (program_name);
4814 break;
4815 case 'V':
4816 do_version = TRUE;
4817 break;
4818 case 'W':
4819 do_wide = TRUE;
4820 break;
4821 default:
4822 /* xgettext:c-format */
4823 error (_("Invalid option '-%c'\n"), c);
4824 /* Fall through. */
4825 case '?':
4826 usage (stderr);
4827 }
4828 }
4829
4830 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4831 && !do_segments && !do_header && !do_dump && !do_version
4832 && !do_histogram && !do_debugging && !do_arch && !do_notes
4833 && !do_section_groups && !do_archive_index
4834 && !do_dyn_syms)
4835 usage (stderr);
4836}
4837
4838static const char *
4839get_elf_class (unsigned int elf_class)
4840{
4841 static char buff[32];
4842
4843 switch (elf_class)
4844 {
4845 case ELFCLASSNONE: return _("none");
4846 case ELFCLASS32: return "ELF32";
4847 case ELFCLASS64: return "ELF64";
4848 default:
4849 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4850 return buff;
4851 }
4852}
4853
4854static const char *
4855get_data_encoding (unsigned int encoding)
4856{
4857 static char buff[32];
4858
4859 switch (encoding)
4860 {
4861 case ELFDATANONE: return _("none");
4862 case ELFDATA2LSB: return _("2's complement, little endian");
4863 case ELFDATA2MSB: return _("2's complement, big endian");
4864 default:
4865 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4866 return buff;
4867 }
4868}
4869
4870/* Decode the data held in 'filedata->file_header'. */
4871
4872static bfd_boolean
4873process_file_header (Filedata * filedata)
4874{
4875 Elf_Internal_Ehdr * header = & filedata->file_header;
4876
4877 if ( header->e_ident[EI_MAG0] != ELFMAG0
4878 || header->e_ident[EI_MAG1] != ELFMAG1
4879 || header->e_ident[EI_MAG2] != ELFMAG2
4880 || header->e_ident[EI_MAG3] != ELFMAG3)
4881 {
4882 error
4883 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4884 return FALSE;
4885 }
4886
4887 init_dwarf_regnames_by_elf_machine_code (header->e_machine);
4888
4889 if (do_header)
4890 {
4891 unsigned i;
4892
4893 printf (_("ELF Header:\n"));
4894 printf (_(" Magic: "));
4895 for (i = 0; i < EI_NIDENT; i++)
4896 printf ("%2.2x ", header->e_ident[i]);
4897 printf ("\n");
4898 printf (_(" Class: %s\n"),
4899 get_elf_class (header->e_ident[EI_CLASS]));
4900 printf (_(" Data: %s\n"),
4901 get_data_encoding (header->e_ident[EI_DATA]));
4902 printf (_(" Version: %d%s\n"),
4903 header->e_ident[EI_VERSION],
4904 (header->e_ident[EI_VERSION] == EV_CURRENT
4905 ? _(" (current)")
4906 : (header->e_ident[EI_VERSION] != EV_NONE
4907 ? _(" <unknown>")
4908 : "")));
4909 printf (_(" OS/ABI: %s\n"),
4910 get_osabi_name (filedata, header->e_ident[EI_OSABI]));
4911 printf (_(" ABI Version: %d\n"),
4912 header->e_ident[EI_ABIVERSION]);
4913 printf (_(" Type: %s\n"),
4914 get_file_type (header->e_type));
4915 printf (_(" Machine: %s\n"),
4916 get_machine_name (header->e_machine));
4917 printf (_(" Version: 0x%lx\n"),
4918 header->e_version);
4919
4920 printf (_(" Entry point address: "));
4921 print_vma (header->e_entry, PREFIX_HEX);
4922 printf (_("\n Start of program headers: "));
4923 print_vma (header->e_phoff, DEC);
4924 printf (_(" (bytes into file)\n Start of section headers: "));
4925 print_vma (header->e_shoff, DEC);
4926 printf (_(" (bytes into file)\n"));
4927
4928 printf (_(" Flags: 0x%lx%s\n"),
4929 header->e_flags,
4930 get_machine_flags (filedata, header->e_flags, header->e_machine));
4931 printf (_(" Size of this header: %u (bytes)\n"),
4932 header->e_ehsize);
4933 printf (_(" Size of program headers: %u (bytes)\n"),
4934 header->e_phentsize);
4935 printf (_(" Number of program headers: %u"),
4936 header->e_phnum);
4937 if (filedata->section_headers != NULL
4938 && header->e_phnum == PN_XNUM
4939 && filedata->section_headers[0].sh_info != 0)
4940 {
4941 header->e_phnum = filedata->section_headers[0].sh_info;
4942 printf (" (%u)", header->e_phnum);
4943 }
4944 putc ('\n', stdout);
4945 printf (_(" Size of section headers: %u (bytes)\n"),
4946 header->e_shentsize);
4947 printf (_(" Number of section headers: %u"),
4948 header->e_shnum);
4949 if (filedata->section_headers != NULL && header->e_shnum == SHN_UNDEF)
4950 {
4951 header->e_shnum = filedata->section_headers[0].sh_size;
4952 printf (" (%u)", header->e_shnum);
4953 }
4954 putc ('\n', stdout);
4955 printf (_(" Section header string table index: %u"),
4956 header->e_shstrndx);
4957 if (filedata->section_headers != NULL
4958 && header->e_shstrndx == (SHN_XINDEX & 0xffff))
4959 {
4960 header->e_shstrndx = filedata->section_headers[0].sh_link;
4961 printf (" (%u)", header->e_shstrndx);
4962 }
4963 if (header->e_shstrndx != SHN_UNDEF
4964 && header->e_shstrndx >= header->e_shnum)
4965 {
4966 header->e_shstrndx = SHN_UNDEF;
4967 printf (_(" <corrupt: out of range>"));
4968 }
4969 putc ('\n', stdout);
4970 }
4971
4972 if (filedata->section_headers != NULL)
4973 {
4974 if (header->e_phnum == PN_XNUM
4975 && filedata->section_headers[0].sh_info != 0)
4976 header->e_phnum = filedata->section_headers[0].sh_info;
4977 if (header->e_shnum == SHN_UNDEF)
4978 header->e_shnum = filedata->section_headers[0].sh_size;
4979 if (header->e_shstrndx == (SHN_XINDEX & 0xffff))
4980 header->e_shstrndx = filedata->section_headers[0].sh_link;
4981 if (header->e_shstrndx >= header->e_shnum)
4982 header->e_shstrndx = SHN_UNDEF;
4983 free (filedata->section_headers);
4984 filedata->section_headers = NULL;
4985 }
4986
4987 return TRUE;
4988}
4989
4990/* Read in the program headers from FILEDATA and store them in PHEADERS.
4991 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
4992
4993static bfd_boolean
4994get_32bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4995{
4996 Elf32_External_Phdr * phdrs;
4997 Elf32_External_Phdr * external;
4998 Elf_Internal_Phdr * internal;
4999 unsigned int i;
5000 unsigned int size = filedata->file_header.e_phentsize;
5001 unsigned int num = filedata->file_header.e_phnum;
5002
5003 /* PR binutils/17531: Cope with unexpected section header sizes. */
5004 if (size == 0 || num == 0)
5005 return FALSE;
5006 if (size < sizeof * phdrs)
5007 {
5008 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5009 return FALSE;
5010 }
5011 if (size > sizeof * phdrs)
5012 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5013
5014 phdrs = (Elf32_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
5015 size, num, _("program headers"));
5016 if (phdrs == NULL)
5017 return FALSE;
5018
5019 for (i = 0, internal = pheaders, external = phdrs;
5020 i < filedata->file_header.e_phnum;
5021 i++, internal++, external++)
5022 {
5023 internal->p_type = BYTE_GET (external->p_type);
5024 internal->p_offset = BYTE_GET (external->p_offset);
5025 internal->p_vaddr = BYTE_GET (external->p_vaddr);
5026 internal->p_paddr = BYTE_GET (external->p_paddr);
5027 internal->p_filesz = BYTE_GET (external->p_filesz);
5028 internal->p_memsz = BYTE_GET (external->p_memsz);
5029 internal->p_flags = BYTE_GET (external->p_flags);
5030 internal->p_align = BYTE_GET (external->p_align);
5031 }
5032
5033 free (phdrs);
5034 return TRUE;
5035}
5036
5037/* Read in the program headers from FILEDATA and store them in PHEADERS.
5038 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5039
5040static bfd_boolean
5041get_64bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
5042{
5043 Elf64_External_Phdr * phdrs;
5044 Elf64_External_Phdr * external;
5045 Elf_Internal_Phdr * internal;
5046 unsigned int i;
5047 unsigned int size = filedata->file_header.e_phentsize;
5048 unsigned int num = filedata->file_header.e_phnum;
5049
5050 /* PR binutils/17531: Cope with unexpected section header sizes. */
5051 if (size == 0 || num == 0)
5052 return FALSE;
5053 if (size < sizeof * phdrs)
5054 {
5055 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5056 return FALSE;
5057 }
5058 if (size > sizeof * phdrs)
5059 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5060
5061 phdrs = (Elf64_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
5062 size, num, _("program headers"));
5063 if (!phdrs)
5064 return FALSE;
5065
5066 for (i = 0, internal = pheaders, external = phdrs;
5067 i < filedata->file_header.e_phnum;
5068 i++, internal++, external++)
5069 {
5070 internal->p_type = BYTE_GET (external->p_type);
5071 internal->p_flags = BYTE_GET (external->p_flags);
5072 internal->p_offset = BYTE_GET (external->p_offset);
5073 internal->p_vaddr = BYTE_GET (external->p_vaddr);
5074 internal->p_paddr = BYTE_GET (external->p_paddr);
5075 internal->p_filesz = BYTE_GET (external->p_filesz);
5076 internal->p_memsz = BYTE_GET (external->p_memsz);
5077 internal->p_align = BYTE_GET (external->p_align);
5078 }
5079
5080 free (phdrs);
5081 return TRUE;
5082}
5083
5084/* Returns TRUE if the program headers were read into `program_headers'. */
5085
5086static bfd_boolean
5087get_program_headers (Filedata * filedata)
5088{
5089 Elf_Internal_Phdr * phdrs;
5090
5091 /* Check cache of prior read. */
5092 if (filedata->program_headers != NULL)
5093 return TRUE;
5094
5095 /* Be kind to memory checkers by looking for
5096 e_phnum values which we know must be invalid. */
5097 if (filedata->file_header.e_phnum
5098 * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
5099 >= filedata->file_size)
5100 {
5101 error (_("Too many program headers - %#x - the file is not that big\n"),
5102 filedata->file_header.e_phnum);
5103 return FALSE;
5104 }
5105
5106 phdrs = (Elf_Internal_Phdr *) cmalloc (filedata->file_header.e_phnum,
5107 sizeof (Elf_Internal_Phdr));
5108 if (phdrs == NULL)
5109 {
5110 error (_("Out of memory reading %u program headers\n"),
5111 filedata->file_header.e_phnum);
5112 return FALSE;
5113 }
5114
5115 if (is_32bit_elf
5116 ? get_32bit_program_headers (filedata, phdrs)
5117 : get_64bit_program_headers (filedata, phdrs))
5118 {
5119 filedata->program_headers = phdrs;
5120 return TRUE;
5121 }
5122
5123 free (phdrs);
5124 return FALSE;
5125}
5126
5127/* Returns TRUE if the program headers were loaded. */
5128
5129static bfd_boolean
5130process_program_headers (Filedata * filedata)
5131{
5132 Elf_Internal_Phdr * segment;
5133 unsigned int i;
5134 Elf_Internal_Phdr * previous_load = NULL;
5135
5136 filedata->dynamic_addr = 0;
5137 filedata->dynamic_size = 0;
5138
5139 if (filedata->file_header.e_phnum == 0)
5140 {
5141 /* PR binutils/12467. */
5142 if (filedata->file_header.e_phoff != 0)
5143 {
5144 warn (_("possibly corrupt ELF header - it has a non-zero program"
5145 " header offset, but no program headers\n"));
5146 return FALSE;
5147 }
5148 else if (do_segments)
5149 printf (_("\nThere are no program headers in this file.\n"));
5150 return TRUE;
5151 }
5152
5153 if (do_segments && !do_header)
5154 {
5155 printf (_("\nElf file type is %s\n"), get_file_type (filedata->file_header.e_type));
5156 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata->file_header.e_entry));
5157 printf (ngettext ("There is %d program header, starting at offset %s\n",
5158 "There are %d program headers, starting at offset %s\n",
5159 filedata->file_header.e_phnum),
5160 filedata->file_header.e_phnum,
5161 bfd_vmatoa ("u", filedata->file_header.e_phoff));
5162 }
5163
5164 if (! get_program_headers (filedata))
5165 return TRUE;
5166
5167 if (do_segments)
5168 {
5169 if (filedata->file_header.e_phnum > 1)
5170 printf (_("\nProgram Headers:\n"));
5171 else
5172 printf (_("\nProgram Headers:\n"));
5173
5174 if (is_32bit_elf)
5175 printf
5176 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5177 else if (do_wide)
5178 printf
5179 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5180 else
5181 {
5182 printf
5183 (_(" Type Offset VirtAddr PhysAddr\n"));
5184 printf
5185 (_(" FileSiz MemSiz Flags Align\n"));
5186 }
5187 }
5188
5189 for (i = 0, segment = filedata->program_headers;
5190 i < filedata->file_header.e_phnum;
5191 i++, segment++)
5192 {
5193 if (do_segments)
5194 {
5195 printf (" %-14.14s ", get_segment_type (filedata, segment->p_type));
5196
5197 if (is_32bit_elf)
5198 {
5199 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5200 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
5201 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
5202 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
5203 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
5204 printf ("%c%c%c ",
5205 (segment->p_flags & PF_R ? 'R' : ' '),
5206 (segment->p_flags & PF_W ? 'W' : ' '),
5207 (segment->p_flags & PF_X ? 'E' : ' '));
5208 printf ("%#lx", (unsigned long) segment->p_align);
5209 }
5210 else if (do_wide)
5211 {
5212 if ((unsigned long) segment->p_offset == segment->p_offset)
5213 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5214 else
5215 {
5216 print_vma (segment->p_offset, FULL_HEX);
5217 putchar (' ');
5218 }
5219
5220 print_vma (segment->p_vaddr, FULL_HEX);
5221 putchar (' ');
5222 print_vma (segment->p_paddr, FULL_HEX);
5223 putchar (' ');
5224
5225 if ((unsigned long) segment->p_filesz == segment->p_filesz)
5226 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
5227 else
5228 {
5229 print_vma (segment->p_filesz, FULL_HEX);
5230 putchar (' ');
5231 }
5232
5233 if ((unsigned long) segment->p_memsz == segment->p_memsz)
5234 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
5235 else
5236 {
5237 print_vma (segment->p_memsz, FULL_HEX);
5238 }
5239
5240 printf (" %c%c%c ",
5241 (segment->p_flags & PF_R ? 'R' : ' '),
5242 (segment->p_flags & PF_W ? 'W' : ' '),
5243 (segment->p_flags & PF_X ? 'E' : ' '));
5244
5245 if ((unsigned long) segment->p_align == segment->p_align)
5246 printf ("%#lx", (unsigned long) segment->p_align);
5247 else
5248 {
5249 print_vma (segment->p_align, PREFIX_HEX);
5250 }
5251 }
5252 else
5253 {
5254 print_vma (segment->p_offset, FULL_HEX);
5255 putchar (' ');
5256 print_vma (segment->p_vaddr, FULL_HEX);
5257 putchar (' ');
5258 print_vma (segment->p_paddr, FULL_HEX);
5259 printf ("\n ");
5260 print_vma (segment->p_filesz, FULL_HEX);
5261 putchar (' ');
5262 print_vma (segment->p_memsz, FULL_HEX);
5263 printf (" %c%c%c ",
5264 (segment->p_flags & PF_R ? 'R' : ' '),
5265 (segment->p_flags & PF_W ? 'W' : ' '),
5266 (segment->p_flags & PF_X ? 'E' : ' '));
5267 print_vma (segment->p_align, PREFIX_HEX);
5268 }
5269
5270 putc ('\n', stdout);
5271 }
5272
5273 switch (segment->p_type)
5274 {
5275 case PT_LOAD:
5276#if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5277 required by the ELF standard, several programs, including the Linux
5278 kernel, make use of non-ordered segments. */
5279 if (previous_load
5280 && previous_load->p_vaddr > segment->p_vaddr)
5281 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5282#endif
5283 if (segment->p_memsz < segment->p_filesz)
5284 error (_("the segment's file size is larger than its memory size\n"));
5285 previous_load = segment;
5286 break;
5287
5288 case PT_PHDR:
5289 /* PR 20815 - Verify that the program header is loaded into memory. */
5290 if (i > 0 && previous_load != NULL)
5291 error (_("the PHDR segment must occur before any LOAD segment\n"));
5292 if (filedata->file_header.e_machine != EM_PARISC)
5293 {
5294 unsigned int j;
5295
5296 for (j = 1; j < filedata->file_header.e_phnum; j++)
5297 {
5298 Elf_Internal_Phdr *load = filedata->program_headers + j;
5299 if (load->p_type == PT_LOAD
5300 && load->p_offset <= segment->p_offset
5301 && (load->p_offset + load->p_filesz
5302 >= segment->p_offset + segment->p_filesz)
5303 && load->p_vaddr <= segment->p_vaddr
5304 && (load->p_vaddr + load->p_filesz
5305 >= segment->p_vaddr + segment->p_filesz))
5306 break;
5307 }
5308 if (j == filedata->file_header.e_phnum)
5309 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5310 }
5311 break;
5312
5313 case PT_DYNAMIC:
5314 if (filedata->dynamic_addr)
5315 error (_("more than one dynamic segment\n"));
5316
5317 /* By default, assume that the .dynamic section is the first
5318 section in the DYNAMIC segment. */
5319 filedata->dynamic_addr = segment->p_offset;
5320 filedata->dynamic_size = segment->p_filesz;
5321
5322 /* Try to locate the .dynamic section. If there is
5323 a section header table, we can easily locate it. */
5324 if (filedata->section_headers != NULL)
5325 {
5326 Elf_Internal_Shdr * sec;
5327
5328 sec = find_section (filedata, ".dynamic");
5329 if (sec == NULL || sec->sh_size == 0)
5330 {
5331 /* A corresponding .dynamic section is expected, but on
5332 IA-64/OpenVMS it is OK for it to be missing. */
5333 if (!is_ia64_vms (filedata))
5334 error (_("no .dynamic section in the dynamic segment\n"));
5335 break;
5336 }
5337
5338 if (sec->sh_type == SHT_NOBITS)
5339 {
5340 filedata->dynamic_size = 0;
5341 break;
5342 }
5343
5344 filedata->dynamic_addr = sec->sh_offset;
5345 filedata->dynamic_size = sec->sh_size;
5346
5347 if (filedata->dynamic_addr < segment->p_offset
5348 || filedata->dynamic_addr > segment->p_offset + segment->p_filesz)
5349 warn (_("the .dynamic section is not contained"
5350 " within the dynamic segment\n"));
5351 else if (filedata->dynamic_addr > segment->p_offset)
5352 warn (_("the .dynamic section is not the first section"
5353 " in the dynamic segment.\n"));
5354 }
5355
5356 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5357 segment. Check this after matching against the section headers
5358 so we don't warn on debuginfo file (which have NOBITS .dynamic
5359 sections). */
5360 if (filedata->dynamic_addr > filedata->file_size
5361 || (filedata->dynamic_size
5362 > filedata->file_size - filedata->dynamic_addr))
5363 {
5364 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5365 filedata->dynamic_addr = filedata->dynamic_size = 0;
5366 }
5367 break;
5368
5369 case PT_INTERP:
5370 if (fseek (filedata->handle,
5371 filedata->archive_file_offset + (long) segment->p_offset,
5372 SEEK_SET))
5373 error (_("Unable to find program interpreter name\n"));
5374 else
5375 {
5376 char fmt [32];
5377 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5378
5379 if (ret >= (int) sizeof (fmt) || ret < 0)
5380 error (_("Internal error: failed to create format string to display program interpreter\n"));
5381
5382 filedata->program_interpreter[0] = 0;
5383 if (fscanf (filedata->handle, fmt,
5384 filedata->program_interpreter) <= 0)
5385 error (_("Unable to read program interpreter name\n"));
5386
5387 if (do_segments)
5388 printf (_(" [Requesting program interpreter: %s]\n"),
5389 filedata->program_interpreter);
5390 }
5391 break;
5392 }
5393 }
5394
5395 if (do_segments
5396 && filedata->section_headers != NULL
5397 && filedata->string_table != NULL)
5398 {
5399 printf (_("\n Section to Segment mapping:\n"));
5400 printf (_(" Segment Sections...\n"));
5401
5402 for (i = 0; i < filedata->file_header.e_phnum; i++)
5403 {
5404 unsigned int j;
5405 Elf_Internal_Shdr * section;
5406
5407 segment = filedata->program_headers + i;
5408 section = filedata->section_headers + 1;
5409
5410 printf (" %2.2d ", i);
5411
5412 for (j = 1; j < filedata->file_header.e_shnum; j++, section++)
5413 {
5414 if (!ELF_TBSS_SPECIAL (section, segment)
5415 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5416 printf ("%s ", printable_section_name (filedata, section));
5417 }
5418
5419 putc ('\n',stdout);
5420 }
5421 }
5422
5423 return TRUE;
5424}
5425
5426
5427/* Find the file offset corresponding to VMA by using the program headers. */
5428
5429static long
5430offset_from_vma (Filedata * filedata, bfd_vma vma, bfd_size_type size)
5431{
5432 Elf_Internal_Phdr * seg;
5433
5434 if (! get_program_headers (filedata))
5435 {
5436 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5437 return (long) vma;
5438 }
5439
5440 for (seg = filedata->program_headers;
5441 seg < filedata->program_headers + filedata->file_header.e_phnum;
5442 ++seg)
5443 {
5444 if (seg->p_type != PT_LOAD)
5445 continue;
5446
5447 if (vma >= (seg->p_vaddr & -seg->p_align)
5448 && vma + size <= seg->p_vaddr + seg->p_filesz)
5449 return vma - seg->p_vaddr + seg->p_offset;
5450 }
5451
5452 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5453 (unsigned long) vma);
5454 return (long) vma;
5455}
5456
5457
5458/* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5459 If PROBE is true, this is just a probe and we do not generate any error
5460 messages if the load fails. */
5461
5462static bfd_boolean
5463get_32bit_section_headers (Filedata * filedata, bfd_boolean probe)
5464{
5465 Elf32_External_Shdr * shdrs;
5466 Elf_Internal_Shdr * internal;
5467 unsigned int i;
5468 unsigned int size = filedata->file_header.e_shentsize;
5469 unsigned int num = probe ? 1 : filedata->file_header.e_shnum;
5470
5471 /* PR binutils/17531: Cope with unexpected section header sizes. */
5472 if (size == 0 || num == 0)
5473 return FALSE;
5474 if (size < sizeof * shdrs)
5475 {
5476 if (! probe)
5477 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5478 return FALSE;
5479 }
5480 if (!probe && size > sizeof * shdrs)
5481 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5482
5483 shdrs = (Elf32_External_Shdr *) get_data (NULL, filedata, filedata->file_header.e_shoff,
5484 size, num,
5485 probe ? NULL : _("section headers"));
5486 if (shdrs == NULL)
5487 return FALSE;
5488
5489 free (filedata->section_headers);
5490 filedata->section_headers = (Elf_Internal_Shdr *)
5491 cmalloc (num, sizeof (Elf_Internal_Shdr));
5492 if (filedata->section_headers == NULL)
5493 {
5494 if (!probe)
5495 error (_("Out of memory reading %u section headers\n"), num);
5496 free (shdrs);
5497 return FALSE;
5498 }
5499
5500 for (i = 0, internal = filedata->section_headers;
5501 i < num;
5502 i++, internal++)
5503 {
5504 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5505 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5506 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5507 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5508 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5509 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5510 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5511 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5512 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5513 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
5514 if (!probe && internal->sh_link > num)
5515 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5516 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5517 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5518 }
5519
5520 free (shdrs);
5521 return TRUE;
5522}
5523
5524/* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5525
5526static bfd_boolean
5527get_64bit_section_headers (Filedata * filedata, bfd_boolean probe)
5528{
5529 Elf64_External_Shdr * shdrs;
5530 Elf_Internal_Shdr * internal;
5531 unsigned int i;
5532 unsigned int size = filedata->file_header.e_shentsize;
5533 unsigned int num = probe ? 1 : filedata->file_header.e_shnum;
5534
5535 /* PR binutils/17531: Cope with unexpected section header sizes. */
5536 if (size == 0 || num == 0)
5537 return FALSE;
5538
5539 if (size < sizeof * shdrs)
5540 {
5541 if (! probe)
5542 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5543 return FALSE;
5544 }
5545
5546 if (! probe && size > sizeof * shdrs)
5547 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5548
5549 shdrs = (Elf64_External_Shdr *) get_data (NULL, filedata,
5550 filedata->file_header.e_shoff,
5551 size, num,
5552 probe ? NULL : _("section headers"));
5553 if (shdrs == NULL)
5554 return FALSE;
5555
5556 free (filedata->section_headers);
5557 filedata->section_headers = (Elf_Internal_Shdr *)
5558 cmalloc (num, sizeof (Elf_Internal_Shdr));
5559 if (filedata->section_headers == NULL)
5560 {
5561 if (! probe)
5562 error (_("Out of memory reading %u section headers\n"), num);
5563 free (shdrs);
5564 return FALSE;
5565 }
5566
5567 for (i = 0, internal = filedata->section_headers;
5568 i < num;
5569 i++, internal++)
5570 {
5571 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5572 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5573 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5574 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5575 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5576 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
5577 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5578 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5579 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5580 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5581 if (!probe && internal->sh_link > num)
5582 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5583 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5584 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5585 }
5586
5587 free (shdrs);
5588 return TRUE;
5589}
5590
5591static Elf_Internal_Sym *
5592get_32bit_elf_symbols (Filedata * filedata,
5593 Elf_Internal_Shdr * section,
5594 unsigned long * num_syms_return)
5595{
5596 unsigned long number = 0;
5597 Elf32_External_Sym * esyms = NULL;
5598 Elf_External_Sym_Shndx * shndx = NULL;
5599 Elf_Internal_Sym * isyms = NULL;
5600 Elf_Internal_Sym * psym;
5601 unsigned int j;
5602 elf_section_list * entry;
5603
5604 if (section->sh_size == 0)
5605 {
5606 if (num_syms_return != NULL)
5607 * num_syms_return = 0;
5608 return NULL;
5609 }
5610
5611 /* Run some sanity checks first. */
5612 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5613 {
5614 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5615 printable_section_name (filedata, section),
5616 (unsigned long) section->sh_entsize);
5617 goto exit_point;
5618 }
5619
5620 if (section->sh_size > filedata->file_size)
5621 {
5622 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5623 printable_section_name (filedata, section),
5624 (unsigned long) section->sh_size);
5625 goto exit_point;
5626 }
5627
5628 number = section->sh_size / section->sh_entsize;
5629
5630 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5631 {
5632 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5633 (unsigned long) section->sh_size,
5634 printable_section_name (filedata, section),
5635 (unsigned long) section->sh_entsize);
5636 goto exit_point;
5637 }
5638
5639 esyms = (Elf32_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5640 section->sh_size, _("symbols"));
5641 if (esyms == NULL)
5642 goto exit_point;
5643
5644 shndx = NULL;
5645 for (entry = filedata->symtab_shndx_list; entry != NULL; entry = entry->next)
5646 {
5647 if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5648 continue;
5649
5650 if (shndx != NULL)
5651 {
5652 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5653 free (shndx);
5654 }
5655
5656 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5657 entry->hdr->sh_offset,
5658 1, entry->hdr->sh_size,
5659 _("symbol table section indices"));
5660 if (shndx == NULL)
5661 goto exit_point;
5662
5663 /* PR17531: file: heap-buffer-overflow */
5664 if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5665 {
5666 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5667 printable_section_name (filedata, entry->hdr),
5668 (unsigned long) entry->hdr->sh_size,
5669 (unsigned long) section->sh_size);
5670 goto exit_point;
5671 }
5672 }
5673
5674 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5675
5676 if (isyms == NULL)
5677 {
5678 error (_("Out of memory reading %lu symbols\n"),
5679 (unsigned long) number);
5680 goto exit_point;
5681 }
5682
5683 for (j = 0, psym = isyms; j < number; j++, psym++)
5684 {
5685 psym->st_name = BYTE_GET (esyms[j].st_name);
5686 psym->st_value = BYTE_GET (esyms[j].st_value);
5687 psym->st_size = BYTE_GET (esyms[j].st_size);
5688 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5689 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5690 psym->st_shndx
5691 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5692 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5693 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5694 psym->st_info = BYTE_GET (esyms[j].st_info);
5695 psym->st_other = BYTE_GET (esyms[j].st_other);
5696 }
5697
5698 exit_point:
5699 free (shndx);
5700 free (esyms);
5701
5702 if (num_syms_return != NULL)
5703 * num_syms_return = isyms == NULL ? 0 : number;
5704
5705 return isyms;
5706}
5707
5708static Elf_Internal_Sym *
5709get_64bit_elf_symbols (Filedata * filedata,
5710 Elf_Internal_Shdr * section,
5711 unsigned long * num_syms_return)
5712{
5713 unsigned long number = 0;
5714 Elf64_External_Sym * esyms = NULL;
5715 Elf_External_Sym_Shndx * shndx = NULL;
5716 Elf_Internal_Sym * isyms = NULL;
5717 Elf_Internal_Sym * psym;
5718 unsigned int j;
5719 elf_section_list * entry;
5720
5721 if (section->sh_size == 0)
5722 {
5723 if (num_syms_return != NULL)
5724 * num_syms_return = 0;
5725 return NULL;
5726 }
5727
5728 /* Run some sanity checks first. */
5729 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5730 {
5731 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5732 printable_section_name (filedata, section),
5733 (unsigned long) section->sh_entsize);
5734 goto exit_point;
5735 }
5736
5737 if (section->sh_size > filedata->file_size)
5738 {
5739 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5740 printable_section_name (filedata, section),
5741 (unsigned long) section->sh_size);
5742 goto exit_point;
5743 }
5744
5745 number = section->sh_size / section->sh_entsize;
5746
5747 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5748 {
5749 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5750 (unsigned long) section->sh_size,
5751 printable_section_name (filedata, section),
5752 (unsigned long) section->sh_entsize);
5753 goto exit_point;
5754 }
5755
5756 esyms = (Elf64_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5757 section->sh_size, _("symbols"));
5758 if (!esyms)
5759 goto exit_point;
5760
5761 shndx = NULL;
5762 for (entry = filedata->symtab_shndx_list; entry != NULL; entry = entry->next)
5763 {
5764 if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5765 continue;
5766
5767 if (shndx != NULL)
5768 {
5769 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5770 free (shndx);
5771 }
5772
5773 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5774 entry->hdr->sh_offset,
5775 1, entry->hdr->sh_size,
5776 _("symbol table section indices"));
5777 if (shndx == NULL)
5778 goto exit_point;
5779
5780 /* PR17531: file: heap-buffer-overflow */
5781 if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5782 {
5783 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5784 printable_section_name (filedata, entry->hdr),
5785 (unsigned long) entry->hdr->sh_size,
5786 (unsigned long) section->sh_size);
5787 goto exit_point;
5788 }
5789 }
5790
5791 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5792
5793 if (isyms == NULL)
5794 {
5795 error (_("Out of memory reading %lu symbols\n"),
5796 (unsigned long) number);
5797 goto exit_point;
5798 }
5799
5800 for (j = 0, psym = isyms; j < number; j++, psym++)
5801 {
5802 psym->st_name = BYTE_GET (esyms[j].st_name);
5803 psym->st_info = BYTE_GET (esyms[j].st_info);
5804 psym->st_other = BYTE_GET (esyms[j].st_other);
5805 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5806
5807 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5808 psym->st_shndx
5809 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5810 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5811 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5812
5813 psym->st_value = BYTE_GET (esyms[j].st_value);
5814 psym->st_size = BYTE_GET (esyms[j].st_size);
5815 }
5816
5817 exit_point:
5818 free (shndx);
5819 free (esyms);
5820
5821 if (num_syms_return != NULL)
5822 * num_syms_return = isyms == NULL ? 0 : number;
5823
5824 return isyms;
5825}
5826
5827static const char *
5828get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
5829{
5830 static char buff[1024];
5831 char * p = buff;
5832 unsigned int field_size = is_32bit_elf ? 8 : 16;
5833 signed int sindex;
5834 unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5835 bfd_vma os_flags = 0;
5836 bfd_vma proc_flags = 0;
5837 bfd_vma unknown_flags = 0;
5838 static const struct
5839 {
5840 const char * str;
5841 unsigned int len;
5842 }
5843 flags [] =
5844 {
5845 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5846 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5847 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5848 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5849 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5850 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5851 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5852 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5853 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5854 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5855 /* IA-64 specific. */
5856 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5857 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5858 /* IA-64 OpenVMS specific. */
5859 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5860 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5861 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5862 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5863 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5864 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5865 /* Generic. */
5866 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5867 /* SPARC specific. */
5868 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5869 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5870 /* ARM specific. */
5871 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5872 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5873 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5874 /* GNU specific. */
5875 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5876 /* VLE specific. */
5877 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5878 };
5879
5880 if (do_section_details)
5881 {
5882 sprintf (buff, "[%*.*lx]: ",
5883 field_size, field_size, (unsigned long) sh_flags);
5884 p += field_size + 4;
5885 }
5886
5887 while (sh_flags)
5888 {
5889 bfd_vma flag;
5890
5891 flag = sh_flags & - sh_flags;
5892 sh_flags &= ~ flag;
5893
5894 if (do_section_details)
5895 {
5896 switch (flag)
5897 {
5898 case SHF_WRITE: sindex = 0; break;
5899 case SHF_ALLOC: sindex = 1; break;
5900 case SHF_EXECINSTR: sindex = 2; break;
5901 case SHF_MERGE: sindex = 3; break;
5902 case SHF_STRINGS: sindex = 4; break;
5903 case SHF_INFO_LINK: sindex = 5; break;
5904 case SHF_LINK_ORDER: sindex = 6; break;
5905 case SHF_OS_NONCONFORMING: sindex = 7; break;
5906 case SHF_GROUP: sindex = 8; break;
5907 case SHF_TLS: sindex = 9; break;
5908 case SHF_EXCLUDE: sindex = 18; break;
5909 case SHF_COMPRESSED: sindex = 20; break;
5910 case SHF_GNU_MBIND: sindex = 24; break;
5911
5912 default:
5913 sindex = -1;
5914 switch (filedata->file_header.e_machine)
5915 {
5916 case EM_IA_64:
5917 if (flag == SHF_IA_64_SHORT)
5918 sindex = 10;
5919 else if (flag == SHF_IA_64_NORECOV)
5920 sindex = 11;
5921#ifdef BFD64
5922 else if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5923 switch (flag)
5924 {
5925 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5926 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5927 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5928 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5929 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5930 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
5931 default: break;
5932 }
5933#endif
5934 break;
5935
5936 case EM_386:
5937 case EM_IAMCU:
5938 case EM_X86_64:
5939 case EM_L1OM:
5940 case EM_K1OM:
5941 case EM_OLD_SPARCV9:
5942 case EM_SPARC32PLUS:
5943 case EM_SPARCV9:
5944 case EM_SPARC:
5945 if (flag == SHF_ORDERED)
5946 sindex = 19;
5947 break;
5948
5949 case EM_ARM:
5950 switch (flag)
5951 {
5952 case SHF_ENTRYSECT: sindex = 21; break;
5953 case SHF_ARM_PURECODE: sindex = 22; break;
5954 case SHF_COMDEF: sindex = 23; break;
5955 default: break;
5956 }
5957 break;
5958 case EM_PPC:
5959 if (flag == SHF_PPC_VLE)
5960 sindex = 25;
5961 break;
5962
5963 default:
5964 break;
5965 }
5966 }
5967
5968 if (sindex != -1)
5969 {
5970 if (p != buff + field_size + 4)
5971 {
5972 if (size < (10 + 2))
5973 {
5974 warn (_("Internal error: not enough buffer room for section flag info"));
5975 return _("<unknown>");
5976 }
5977 size -= 2;
5978 *p++ = ',';
5979 *p++ = ' ';
5980 }
5981
5982 size -= flags [sindex].len;
5983 p = stpcpy (p, flags [sindex].str);
5984 }
5985 else if (flag & SHF_MASKOS)
5986 os_flags |= flag;
5987 else if (flag & SHF_MASKPROC)
5988 proc_flags |= flag;
5989 else
5990 unknown_flags |= flag;
5991 }
5992 else
5993 {
5994 switch (flag)
5995 {
5996 case SHF_WRITE: *p = 'W'; break;
5997 case SHF_ALLOC: *p = 'A'; break;
5998 case SHF_EXECINSTR: *p = 'X'; break;
5999 case SHF_MERGE: *p = 'M'; break;
6000 case SHF_STRINGS: *p = 'S'; break;
6001 case SHF_INFO_LINK: *p = 'I'; break;
6002 case SHF_LINK_ORDER: *p = 'L'; break;
6003 case SHF_OS_NONCONFORMING: *p = 'O'; break;
6004 case SHF_GROUP: *p = 'G'; break;
6005 case SHF_TLS: *p = 'T'; break;
6006 case SHF_EXCLUDE: *p = 'E'; break;
6007 case SHF_COMPRESSED: *p = 'C'; break;
6008 case SHF_GNU_MBIND: *p = 'D'; break;
6009
6010 default:
6011 if ((filedata->file_header.e_machine == EM_X86_64
6012 || filedata->file_header.e_machine == EM_L1OM
6013 || filedata->file_header.e_machine == EM_K1OM)
6014 && flag == SHF_X86_64_LARGE)
6015 *p = 'l';
6016 else if (filedata->file_header.e_machine == EM_ARM
6017 && flag == SHF_ARM_PURECODE)
6018 *p = 'y';
6019 else if (filedata->file_header.e_machine == EM_PPC
6020 && flag == SHF_PPC_VLE)
6021 *p = 'v';
6022 else if (flag & SHF_MASKOS)
6023 {
6024 *p = 'o';
6025 sh_flags &= ~ SHF_MASKOS;
6026 }
6027 else if (flag & SHF_MASKPROC)
6028 {
6029 *p = 'p';
6030 sh_flags &= ~ SHF_MASKPROC;
6031 }
6032 else
6033 *p = 'x';
6034 break;
6035 }
6036 p++;
6037 }
6038 }
6039
6040 if (do_section_details)
6041 {
6042 if (os_flags)
6043 {
6044 size -= 5 + field_size;
6045 if (p != buff + field_size + 4)
6046 {
6047 if (size < (2 + 1))
6048 {
6049 warn (_("Internal error: not enough buffer room for section flag info"));
6050 return _("<unknown>");
6051 }
6052 size -= 2;
6053 *p++ = ',';
6054 *p++ = ' ';
6055 }
6056 sprintf (p, "OS (%*.*lx)", field_size, field_size,
6057 (unsigned long) os_flags);
6058 p += 5 + field_size;
6059 }
6060 if (proc_flags)
6061 {
6062 size -= 7 + field_size;
6063 if (p != buff + field_size + 4)
6064 {
6065 if (size < (2 + 1))
6066 {
6067 warn (_("Internal error: not enough buffer room for section flag info"));
6068 return _("<unknown>");
6069 }
6070 size -= 2;
6071 *p++ = ',';
6072 *p++ = ' ';
6073 }
6074 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
6075 (unsigned long) proc_flags);
6076 p += 7 + field_size;
6077 }
6078 if (unknown_flags)
6079 {
6080 size -= 10 + field_size;
6081 if (p != buff + field_size + 4)
6082 {
6083 if (size < (2 + 1))
6084 {
6085 warn (_("Internal error: not enough buffer room for section flag info"));
6086 return _("<unknown>");
6087 }
6088 size -= 2;
6089 *p++ = ',';
6090 *p++ = ' ';
6091 }
6092 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
6093 (unsigned long) unknown_flags);
6094 p += 10 + field_size;
6095 }
6096 }
6097
6098 *p = '\0';
6099 return buff;
6100}
6101
6102static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
6103get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
6104{
6105 if (is_32bit_elf)
6106 {
6107 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
6108
6109 if (size < sizeof (* echdr))
6110 {
6111 error (_("Compressed section is too small even for a compression header\n"));
6112 return 0;
6113 }
6114
6115 chdr->ch_type = BYTE_GET (echdr->ch_type);
6116 chdr->ch_size = BYTE_GET (echdr->ch_size);
6117 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
6118 return sizeof (*echdr);
6119 }
6120 else
6121 {
6122 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
6123
6124 if (size < sizeof (* echdr))
6125 {
6126 error (_("Compressed section is too small even for a compression header\n"));
6127 return 0;
6128 }
6129
6130 chdr->ch_type = BYTE_GET (echdr->ch_type);
6131 chdr->ch_size = BYTE_GET (echdr->ch_size);
6132 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
6133 return sizeof (*echdr);
6134 }
6135}
6136
6137static bfd_boolean
6138process_section_headers (Filedata * filedata)
6139{
6140 Elf_Internal_Shdr * section;
6141 unsigned int i;
6142
6143 free (filedata->section_headers);
6144 filedata->section_headers = NULL;
6145 free (filedata->dynamic_symbols);
6146 filedata->dynamic_symbols = NULL;
6147 filedata->num_dynamic_syms = 0;
6148 free (filedata->dynamic_strings);
6149 filedata->dynamic_strings = NULL;
6150 filedata->dynamic_strings_length = 0;
6151 free (filedata->dynamic_syminfo);
6152 filedata->dynamic_syminfo = NULL;
6153 while (filedata->symtab_shndx_list != NULL)
6154 {
6155 elf_section_list *next = filedata->symtab_shndx_list->next;
6156 free (filedata->symtab_shndx_list);
6157 filedata->symtab_shndx_list = next;
6158 }
6159
6160 if (filedata->file_header.e_shnum == 0)
6161 {
6162 /* PR binutils/12467. */
6163 if (filedata->file_header.e_shoff != 0)
6164 {
6165 warn (_("possibly corrupt ELF file header - it has a non-zero"
6166 " section header offset, but no section headers\n"));
6167 return FALSE;
6168 }
6169 else if (do_sections)
6170 printf (_("\nThere are no sections in this file.\n"));
6171
6172 return TRUE;
6173 }
6174
6175 if (do_sections && !do_header)
6176 printf (ngettext ("There is %d section header, "
6177 "starting at offset 0x%lx:\n",
6178 "There are %d section headers, "
6179 "starting at offset 0x%lx:\n",
6180 filedata->file_header.e_shnum),
6181 filedata->file_header.e_shnum,
6182 (unsigned long) filedata->file_header.e_shoff);
6183
6184 if (is_32bit_elf)
6185 {
6186 if (! get_32bit_section_headers (filedata, FALSE))
6187 return FALSE;
6188 }
6189 else
6190 {
6191 if (! get_64bit_section_headers (filedata, FALSE))
6192 return FALSE;
6193 }
6194
6195 /* Read in the string table, so that we have names to display. */
6196 if (filedata->file_header.e_shstrndx != SHN_UNDEF
6197 && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
6198 {
6199 section = filedata->section_headers + filedata->file_header.e_shstrndx;
6200
6201 if (section->sh_size != 0)
6202 {
6203 filedata->string_table = (char *) get_data (NULL, filedata, section->sh_offset,
6204 1, section->sh_size,
6205 _("string table"));
6206
6207 filedata->string_table_length = filedata->string_table != NULL ? section->sh_size : 0;
6208 }
6209 }
6210
6211 /* Scan the sections for the dynamic symbol table
6212 and dynamic string table and debug sections. */
6213 eh_addr_size = is_32bit_elf ? 4 : 8;
6214 switch (filedata->file_header.e_machine)
6215 {
6216 case EM_MIPS:
6217 case EM_MIPS_RS3_LE:
6218 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6219 FDE addresses. However, the ABI also has a semi-official ILP32
6220 variant for which the normal FDE address size rules apply.
6221
6222 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6223 section, where XX is the size of longs in bits. Unfortunately,
6224 earlier compilers provided no way of distinguishing ILP32 objects
6225 from LP64 objects, so if there's any doubt, we should assume that
6226 the official LP64 form is being used. */
6227 if ((filedata->file_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
6228 && find_section (filedata, ".gcc_compiled_long32") == NULL)
6229 eh_addr_size = 8;
6230 break;
6231
6232 case EM_H8_300:
6233 case EM_H8_300H:
6234 switch (filedata->file_header.e_flags & EF_H8_MACH)
6235 {
6236 case E_H8_MACH_H8300:
6237 case E_H8_MACH_H8300HN:
6238 case E_H8_MACH_H8300SN:
6239 case E_H8_MACH_H8300SXN:
6240 eh_addr_size = 2;
6241 break;
6242 case E_H8_MACH_H8300H:
6243 case E_H8_MACH_H8300S:
6244 case E_H8_MACH_H8300SX:
6245 eh_addr_size = 4;
6246 break;
6247 }
6248 break;
6249
6250 case EM_M32C_OLD:
6251 case EM_M32C:
6252 switch (filedata->file_header.e_flags & EF_M32C_CPU_MASK)
6253 {
6254 case EF_M32C_CPU_M16C:
6255 eh_addr_size = 2;
6256 break;
6257 }
6258 break;
6259 }
6260
6261#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6262 do \
6263 { \
6264 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6265 if (section->sh_entsize != expected_entsize) \
6266 { \
6267 char buf[40]; \
6268 sprintf_vma (buf, section->sh_entsize); \
6269 /* Note: coded this way so that there is a single string for \
6270 translation. */ \
6271 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6272 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6273 (unsigned) expected_entsize); \
6274 section->sh_entsize = expected_entsize; \
6275 } \
6276 } \
6277 while (0)
6278
6279#define CHECK_ENTSIZE(section, i, type) \
6280 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6281 sizeof (Elf64_External_##type))
6282
6283 for (i = 0, section = filedata->section_headers;
6284 i < filedata->file_header.e_shnum;
6285 i++, section++)
6286 {
6287 char * name = SECTION_NAME (section);
6288
6289 if (section->sh_type == SHT_DYNSYM)
6290 {
6291 if (filedata->dynamic_symbols != NULL)
6292 {
6293 error (_("File contains multiple dynamic symbol tables\n"));
6294 continue;
6295 }
6296
6297 CHECK_ENTSIZE (section, i, Sym);
6298 filedata->dynamic_symbols
6299 = GET_ELF_SYMBOLS (filedata, section, &filedata->num_dynamic_syms);
6300 }
6301 else if (section->sh_type == SHT_STRTAB
6302 && streq (name, ".dynstr"))
6303 {
6304 if (filedata->dynamic_strings != NULL)
6305 {
6306 error (_("File contains multiple dynamic string tables\n"));
6307 continue;
6308 }
6309
6310 filedata->dynamic_strings
6311 = (char *) get_data (NULL, filedata, section->sh_offset,
6312 1, section->sh_size, _("dynamic strings"));
6313 filedata->dynamic_strings_length
6314 = filedata->dynamic_strings == NULL ? 0 : section->sh_size;
6315 }
6316 else if (section->sh_type == SHT_SYMTAB_SHNDX)
6317 {
6318 elf_section_list * entry = xmalloc (sizeof * entry);
6319
6320 entry->hdr = section;
6321 entry->next = filedata->symtab_shndx_list;
6322 filedata->symtab_shndx_list = entry;
6323 }
6324 else if (section->sh_type == SHT_SYMTAB)
6325 CHECK_ENTSIZE (section, i, Sym);
6326 else if (section->sh_type == SHT_GROUP)
6327 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6328 else if (section->sh_type == SHT_REL)
6329 CHECK_ENTSIZE (section, i, Rel);
6330 else if (section->sh_type == SHT_RELA)
6331 CHECK_ENTSIZE (section, i, Rela);
6332 else if ((do_debugging || do_debug_info || do_debug_abbrevs
6333 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
6334 || do_debug_aranges || do_debug_frames || do_debug_macinfo
6335 || do_debug_str || do_debug_loc || do_debug_ranges
6336 || do_debug_addr || do_debug_cu_index || do_debug_links)
6337 && (const_strneq (name, ".debug_")
6338 || const_strneq (name, ".zdebug_")))
6339 {
6340 if (name[1] == 'z')
6341 name += sizeof (".zdebug_") - 1;
6342 else
6343 name += sizeof (".debug_") - 1;
6344
6345 if (do_debugging
6346 || (do_debug_info && const_strneq (name, "info"))
6347 || (do_debug_info && const_strneq (name, "types"))
6348 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
6349 || (do_debug_lines && strcmp (name, "line") == 0)
6350 || (do_debug_lines && const_strneq (name, "line."))
6351 || (do_debug_pubnames && const_strneq (name, "pubnames"))
6352 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6353 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6354 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6355 || (do_debug_aranges && const_strneq (name, "aranges"))
6356 || (do_debug_ranges && const_strneq (name, "ranges"))
6357 || (do_debug_ranges && const_strneq (name, "rnglists"))
6358 || (do_debug_frames && const_strneq (name, "frame"))
6359 || (do_debug_macinfo && const_strneq (name, "macinfo"))
6360 || (do_debug_macinfo && const_strneq (name, "macro"))
6361 || (do_debug_str && const_strneq (name, "str"))
6362 || (do_debug_loc && const_strneq (name, "loc"))
6363 || (do_debug_loc && const_strneq (name, "loclists"))
6364 || (do_debug_addr && const_strneq (name, "addr"))
6365 || (do_debug_cu_index && const_strneq (name, "cu_index"))
6366 || (do_debug_cu_index && const_strneq (name, "tu_index"))
6367 )
6368 request_dump_bynumber (&filedata->dump, i, DEBUG_DUMP);
6369 }
6370 /* Linkonce section to be combined with .debug_info at link time. */
6371 else if ((do_debugging || do_debug_info)
6372 && const_strneq (name, ".gnu.linkonce.wi."))
6373 request_dump_bynumber (&filedata->dump, i, DEBUG_DUMP);
6374 else if (do_debug_frames && streq (name, ".eh_frame"))
6375 request_dump_bynumber (&filedata->dump, i, DEBUG_DUMP);
6376 else if (do_gdb_index && (streq (name, ".gdb_index")
6377 || streq (name, ".debug_names")))
6378 request_dump_bynumber (&filedata->dump, i, DEBUG_DUMP);
6379 /* Trace sections for Itanium VMS. */
6380 else if ((do_debugging || do_trace_info || do_trace_abbrevs
6381 || do_trace_aranges)
6382 && const_strneq (name, ".trace_"))
6383 {
6384 name += sizeof (".trace_") - 1;
6385
6386 if (do_debugging
6387 || (do_trace_info && streq (name, "info"))
6388 || (do_trace_abbrevs && streq (name, "abbrev"))
6389 || (do_trace_aranges && streq (name, "aranges"))
6390 )
6391 request_dump_bynumber (&filedata->dump, i, DEBUG_DUMP);
6392 }
6393 else if ((do_debugging || do_debug_links)
6394 && (const_strneq (name, ".gnu_debuglink")
6395 || const_strneq (name, ".gnu_debugaltlink")))
6396 request_dump_bynumber (&filedata->dump, i, DEBUG_DUMP);
6397 }
6398
6399 if (! do_sections)
6400 return TRUE;
6401
6402 if (filedata->file_header.e_shnum > 1)
6403 printf (_("\nSection Headers:\n"));
6404 else
6405 printf (_("\nSection Header:\n"));
6406
6407 if (is_32bit_elf)
6408 {
6409 if (do_section_details)
6410 {
6411 printf (_(" [Nr] Name\n"));
6412 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6413 }
6414 else
6415 printf
6416 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6417 }
6418 else if (do_wide)
6419 {
6420 if (do_section_details)
6421 {
6422 printf (_(" [Nr] Name\n"));
6423 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6424 }
6425 else
6426 printf
6427 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6428 }
6429 else
6430 {
6431 if (do_section_details)
6432 {
6433 printf (_(" [Nr] Name\n"));
6434 printf (_(" Type Address Offset Link\n"));
6435 printf (_(" Size EntSize Info Align\n"));
6436 }
6437 else
6438 {
6439 printf (_(" [Nr] Name Type Address Offset\n"));
6440 printf (_(" Size EntSize Flags Link Info Align\n"));
6441 }
6442 }
6443
6444 if (do_section_details)
6445 printf (_(" Flags\n"));
6446
6447 for (i = 0, section = filedata->section_headers;
6448 i < filedata->file_header.e_shnum;
6449 i++, section++)
6450 {
6451 /* Run some sanity checks on the section header. */
6452
6453 /* Check the sh_link field. */
6454 switch (section->sh_type)
6455 {
6456 case SHT_REL:
6457 case SHT_RELA:
6458 if (section->sh_link == 0
6459 && (filedata->file_header.e_type == ET_EXEC
6460 || filedata->file_header.e_type == ET_DYN))
6461 /* A dynamic relocation section where all entries use a
6462 zero symbol index need not specify a symtab section. */
6463 break;
6464 /* Fall through. */
6465 case SHT_SYMTAB_SHNDX:
6466 case SHT_GROUP:
6467 case SHT_HASH:
6468 case SHT_GNU_HASH:
6469 case SHT_GNU_versym:
6470 if (section->sh_link == 0
6471 || section->sh_link >= filedata->file_header.e_shnum
6472 || (filedata->section_headers[section->sh_link].sh_type != SHT_SYMTAB
6473 && filedata->section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6474 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6475 i, section->sh_link);
6476 break;
6477
6478 case SHT_DYNAMIC:
6479 case SHT_SYMTAB:
6480 case SHT_DYNSYM:
6481 case SHT_GNU_verneed:
6482 case SHT_GNU_verdef:
6483 case SHT_GNU_LIBLIST:
6484 if (section->sh_link == 0
6485 || section->sh_link >= filedata->file_header.e_shnum
6486 || filedata->section_headers[section->sh_link].sh_type != SHT_STRTAB)
6487 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6488 i, section->sh_link);
6489 break;
6490
6491 case SHT_INIT_ARRAY:
6492 case SHT_FINI_ARRAY:
6493 case SHT_PREINIT_ARRAY:
6494 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6495 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6496 i, section->sh_link);
6497 break;
6498
6499 default:
6500 /* FIXME: Add support for target specific section types. */
6501#if 0 /* Currently we do not check other section types as there are too
6502 many special cases. Stab sections for example have a type
6503 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6504 section. */
6505 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6506 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6507 i, section->sh_link);
6508#endif
6509 break;
6510 }
6511
6512 /* Check the sh_info field. */
6513 switch (section->sh_type)
6514 {
6515 case SHT_REL:
6516 case SHT_RELA:
6517 if (section->sh_info == 0
6518 && (filedata->file_header.e_type == ET_EXEC
6519 || filedata->file_header.e_type == ET_DYN))
6520 /* Dynamic relocations apply to segments, so they do not
6521 need to specify the section they relocate. */
6522 break;
6523 if (section->sh_info == 0
6524 || section->sh_info >= filedata->file_header.e_shnum
6525 || (filedata->section_headers[section->sh_info].sh_type != SHT_PROGBITS
6526 && filedata->section_headers[section->sh_info].sh_type != SHT_NOBITS
6527 && filedata->section_headers[section->sh_info].sh_type != SHT_NOTE
6528 && filedata->section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6529 && filedata->section_headers[section->sh_info].sh_type != SHT_FINI_ARRAY
6530 && filedata->section_headers[section->sh_info].sh_type != SHT_PREINIT_ARRAY
6531 /* FIXME: Are other section types valid ? */
6532 && filedata->section_headers[section->sh_info].sh_type < SHT_LOOS))
6533 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6534 i, section->sh_info);
6535 break;
6536
6537 case SHT_DYNAMIC:
6538 case SHT_HASH:
6539 case SHT_SYMTAB_SHNDX:
6540 case SHT_INIT_ARRAY:
6541 case SHT_FINI_ARRAY:
6542 case SHT_PREINIT_ARRAY:
6543 if (section->sh_info != 0)
6544 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6545 i, section->sh_info);
6546 break;
6547
6548 case SHT_GROUP:
6549 case SHT_SYMTAB:
6550 case SHT_DYNSYM:
6551 /* A symbol index - we assume that it is valid. */
6552 break;
6553
6554 default:
6555 /* FIXME: Add support for target specific section types. */
6556 if (section->sh_type == SHT_NOBITS)
6557 /* NOBITS section headers with non-zero sh_info fields can be
6558 created when a binary is stripped of everything but its debug
6559 information. The stripped sections have their headers
6560 preserved but their types set to SHT_NOBITS. So do not check
6561 this type of section. */
6562 ;
6563 else if (section->sh_flags & SHF_INFO_LINK)
6564 {
6565 if (section->sh_info < 1 || section->sh_info >= filedata->file_header.e_shnum)
6566 warn (_("[%2u]: Expected link to another section in info field"), i);
6567 }
6568 else if (section->sh_type < SHT_LOOS
6569 && (section->sh_flags & SHF_GNU_MBIND) == 0
6570 && section->sh_info != 0)
6571 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6572 i, section->sh_info);
6573 break;
6574 }
6575
6576 /* Check the sh_size field. */
6577 if (section->sh_size > filedata->file_size
6578 && section->sh_type != SHT_NOBITS
6579 && section->sh_type != SHT_NULL
6580 && section->sh_type < SHT_LOOS)
6581 warn (_("Size of section %u is larger than the entire file!\n"), i);
6582
6583 printf (" [%2u] ", i);
6584 if (do_section_details)
6585 printf ("%s\n ", printable_section_name (filedata, section));
6586 else
6587 print_symbol (-17, SECTION_NAME (section));
6588
6589 printf (do_wide ? " %-15s " : " %-15.15s ",
6590 get_section_type_name (filedata, section->sh_type));
6591
6592 if (is_32bit_elf)
6593 {
6594 const char * link_too_big = NULL;
6595
6596 print_vma (section->sh_addr, LONG_HEX);
6597
6598 printf ( " %6.6lx %6.6lx %2.2lx",
6599 (unsigned long) section->sh_offset,
6600 (unsigned long) section->sh_size,
6601 (unsigned long) section->sh_entsize);
6602
6603 if (do_section_details)
6604 fputs (" ", stdout);
6605 else
6606 printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6607
6608 if (section->sh_link >= filedata->file_header.e_shnum)
6609 {
6610 link_too_big = "";
6611 /* The sh_link value is out of range. Normally this indicates
6612 an error but it can have special values in Solaris binaries. */
6613 switch (filedata->file_header.e_machine)
6614 {
6615 case EM_386:
6616 case EM_IAMCU:
6617 case EM_X86_64:
6618 case EM_L1OM:
6619 case EM_K1OM:
6620 case EM_OLD_SPARCV9:
6621 case EM_SPARC32PLUS:
6622 case EM_SPARCV9:
6623 case EM_SPARC:
6624 if (section->sh_link == (SHN_BEFORE & 0xffff))
6625 link_too_big = "BEFORE";
6626 else if (section->sh_link == (SHN_AFTER & 0xffff))
6627 link_too_big = "AFTER";
6628 break;
6629 default:
6630 break;
6631 }
6632 }
6633
6634 if (do_section_details)
6635 {
6636 if (link_too_big != NULL && * link_too_big)
6637 printf ("<%s> ", link_too_big);
6638 else
6639 printf ("%2u ", section->sh_link);
6640 printf ("%3u %2lu\n", section->sh_info,
6641 (unsigned long) section->sh_addralign);
6642 }
6643 else
6644 printf ("%2u %3u %2lu\n",
6645 section->sh_link,
6646 section->sh_info,
6647 (unsigned long) section->sh_addralign);
6648
6649 if (link_too_big && ! * link_too_big)
6650 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6651 i, section->sh_link);
6652 }
6653 else if (do_wide)
6654 {
6655 print_vma (section->sh_addr, LONG_HEX);
6656
6657 if ((long) section->sh_offset == section->sh_offset)
6658 printf (" %6.6lx", (unsigned long) section->sh_offset);
6659 else
6660 {
6661 putchar (' ');
6662 print_vma (section->sh_offset, LONG_HEX);
6663 }
6664
6665 if ((unsigned long) section->sh_size == section->sh_size)
6666 printf (" %6.6lx", (unsigned long) section->sh_size);
6667 else
6668 {
6669 putchar (' ');
6670 print_vma (section->sh_size, LONG_HEX);
6671 }
6672
6673 if ((unsigned long) section->sh_entsize == section->sh_entsize)
6674 printf (" %2.2lx", (unsigned long) section->sh_entsize);
6675 else
6676 {
6677 putchar (' ');
6678 print_vma (section->sh_entsize, LONG_HEX);
6679 }
6680
6681 if (do_section_details)
6682 fputs (" ", stdout);
6683 else
6684 printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6685
6686 printf ("%2u %3u ", section->sh_link, section->sh_info);
6687
6688 if ((unsigned long) section->sh_addralign == section->sh_addralign)
6689 printf ("%2lu\n", (unsigned long) section->sh_addralign);
6690 else
6691 {
6692 print_vma (section->sh_addralign, DEC);
6693 putchar ('\n');
6694 }
6695 }
6696 else if (do_section_details)
6697 {
6698 putchar (' ');
6699 print_vma (section->sh_addr, LONG_HEX);
6700 if ((long) section->sh_offset == section->sh_offset)
6701 printf (" %16.16lx", (unsigned long) section->sh_offset);
6702 else
6703 {
6704 printf (" ");
6705 print_vma (section->sh_offset, LONG_HEX);
6706 }
6707 printf (" %u\n ", section->sh_link);
6708 print_vma (section->sh_size, LONG_HEX);
6709 putchar (' ');
6710 print_vma (section->sh_entsize, LONG_HEX);
6711
6712 printf (" %-16u %lu\n",
6713 section->sh_info,
6714 (unsigned long) section->sh_addralign);
6715 }
6716 else
6717 {
6718 putchar (' ');
6719 print_vma (section->sh_addr, LONG_HEX);
6720 if ((long) section->sh_offset == section->sh_offset)
6721 printf (" %8.8lx", (unsigned long) section->sh_offset);
6722 else
6723 {
6724 printf (" ");
6725 print_vma (section->sh_offset, LONG_HEX);
6726 }
6727 printf ("\n ");
6728 print_vma (section->sh_size, LONG_HEX);
6729 printf (" ");
6730 print_vma (section->sh_entsize, LONG_HEX);
6731
6732 printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6733
6734 printf (" %2u %3u %lu\n",
6735 section->sh_link,
6736 section->sh_info,
6737 (unsigned long) section->sh_addralign);
6738 }
6739
6740 if (do_section_details)
6741 {
6742 printf (" %s\n", get_elf_section_flags (filedata, section->sh_flags));
6743 if ((section->sh_flags & SHF_COMPRESSED) != 0)
6744 {
6745 /* Minimum section size is 12 bytes for 32-bit compression
6746 header + 12 bytes for compressed data header. */
6747 unsigned char buf[24];
6748
6749 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6750 if (get_data (&buf, filedata, section->sh_offset, 1,
6751 sizeof (buf), _("compression header")))
6752 {
6753 Elf_Internal_Chdr chdr;
6754
6755 if (get_compression_header (&chdr, buf, sizeof (buf)) == 0)
6756 printf (_(" [<corrupt>]\n"));
6757 else
6758 {
6759 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6760 printf (" ZLIB, ");
6761 else
6762 printf (_(" [<unknown>: 0x%x], "),
6763 chdr.ch_type);
6764 print_vma (chdr.ch_size, LONG_HEX);
6765 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6766 }
6767 }
6768 }
6769 }
6770 }
6771
6772 if (!do_section_details)
6773 {
6774 /* The ordering of the letters shown here matches the ordering of the
6775 corresponding SHF_xxx values, and hence the order in which these
6776 letters will be displayed to the user. */
6777 printf (_("Key to Flags:\n\
6778 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6779 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6780 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6781 if (filedata->file_header.e_machine == EM_X86_64
6782 || filedata->file_header.e_machine == EM_L1OM
6783 || filedata->file_header.e_machine == EM_K1OM)
6784 printf (_("l (large), "));
6785 else if (filedata->file_header.e_machine == EM_ARM)
6786 printf (_("y (purecode), "));
6787 else if (filedata->file_header.e_machine == EM_PPC)
6788 printf (_("v (VLE), "));
6789 printf ("p (processor specific)\n");
6790 }
6791
6792 return TRUE;
6793}
6794
6795static bfd_boolean
6796get_symtab (Filedata *filedata, Elf_Internal_Shdr *symsec,
6797 Elf_Internal_Sym **symtab, unsigned long *nsyms,
6798 char **strtab, unsigned long *strtablen)
6799{
6800 *strtab = NULL;
6801 *strtablen = 0;
6802 *symtab = GET_ELF_SYMBOLS (filedata, symsec, nsyms);
6803
6804 if (*symtab == NULL)
6805 return FALSE;
6806
6807 if (symsec->sh_link != 0)
6808 {
6809 Elf_Internal_Shdr *strsec;
6810
6811 if (symsec->sh_link >= filedata->file_header.e_shnum)
6812 {
6813 error (_("Bad sh_link in symbol table section\n"));
6814 free (*symtab);
6815 *symtab = NULL;
6816 *nsyms = 0;
6817 return FALSE;
6818 }
6819
6820 strsec = filedata->section_headers + symsec->sh_link;
6821
6822 *strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
6823 1, strsec->sh_size, _("string table"));
6824 if (*strtab == NULL)
6825 {
6826 free (*symtab);
6827 *symtab = NULL;
6828 *nsyms = 0;
6829 return FALSE;
6830 }
6831 *strtablen = strsec->sh_size;
6832 }
6833 return TRUE;
6834}
6835
6836static const char *
6837get_group_flags (unsigned int flags)
6838{
6839 static char buff[128];
6840
6841 if (flags == 0)
6842 return "";
6843 else if (flags == GRP_COMDAT)
6844 return "COMDAT ";
6845
6846 snprintf (buff, sizeof buff, "[0x%x: %s%s%s]",
6847 flags,
6848 flags & GRP_MASKOS ? _("<OS specific>") : "",
6849 flags & GRP_MASKPROC ? _("<PROC specific>") : "",
6850 (flags & ~(GRP_COMDAT | GRP_MASKOS | GRP_MASKPROC)
6851 ? _("<unknown>") : ""));
6852
6853 return buff;
6854}
6855
6856static bfd_boolean
6857process_section_groups (Filedata * filedata)
6858{
6859 Elf_Internal_Shdr * section;
6860 unsigned int i;
6861 struct group * group;
6862 Elf_Internal_Shdr * symtab_sec;
6863 Elf_Internal_Shdr * strtab_sec;
6864 Elf_Internal_Sym * symtab;
6865 unsigned long num_syms;
6866 char * strtab;
6867 size_t strtab_size;
6868
6869 /* Don't process section groups unless needed. */
6870 if (!do_unwind && !do_section_groups)
6871 return TRUE;
6872
6873 if (filedata->file_header.e_shnum == 0)
6874 {
6875 if (do_section_groups)
6876 printf (_("\nThere are no sections to group in this file.\n"));
6877
6878 return TRUE;
6879 }
6880
6881 if (filedata->section_headers == NULL)
6882 {
6883 error (_("Section headers are not available!\n"));
6884 /* PR 13622: This can happen with a corrupt ELF header. */
6885 return FALSE;
6886 }
6887
6888 filedata->section_headers_groups
6889 = (struct group **) calloc (filedata->file_header.e_shnum,
6890 sizeof (struct group *));
6891
6892 if (filedata->section_headers_groups == NULL)
6893 {
6894 error (_("Out of memory reading %u section group headers\n"),
6895 filedata->file_header.e_shnum);
6896 return FALSE;
6897 }
6898
6899 /* Scan the sections for the group section. */
6900 filedata->group_count = 0;
6901 for (i = 0, section = filedata->section_headers;
6902 i < filedata->file_header.e_shnum;
6903 i++, section++)
6904 if (section->sh_type == SHT_GROUP)
6905 filedata->group_count++;
6906
6907 if (filedata->group_count == 0)
6908 {
6909 if (do_section_groups)
6910 printf (_("\nThere are no section groups in this file.\n"));
6911
6912 return TRUE;
6913 }
6914
6915 filedata->section_groups = (struct group *) calloc (filedata->group_count,
6916 sizeof (struct group));
6917
6918 if (filedata->section_groups == NULL)
6919 {
6920 error (_("Out of memory reading %lu groups\n"),
6921 (unsigned long) filedata->group_count);
6922 return FALSE;
6923 }
6924
6925 symtab_sec = NULL;
6926 strtab_sec = NULL;
6927 symtab = NULL;
6928 num_syms = 0;
6929 strtab = NULL;
6930 strtab_size = 0;
6931 for (i = 0, section = filedata->section_headers, group = filedata->section_groups;
6932 i < filedata->file_header.e_shnum;
6933 i++, section++)
6934 {
6935 if (section->sh_type == SHT_GROUP)
6936 {
6937 const char * name = printable_section_name (filedata, section);
6938 const char * group_name;
6939 unsigned char * start;
6940 unsigned char * indices;
6941 unsigned int entry, j, size;
6942 Elf_Internal_Shdr * sec;
6943 Elf_Internal_Sym * sym;
6944
6945 /* Get the symbol table. */
6946 if (section->sh_link >= filedata->file_header.e_shnum
6947 || ((sec = filedata->section_headers + section->sh_link)->sh_type
6948 != SHT_SYMTAB))
6949 {
6950 error (_("Bad sh_link in group section `%s'\n"), name);
6951 continue;
6952 }
6953
6954 if (symtab_sec != sec)
6955 {
6956 symtab_sec = sec;
6957 if (symtab)
6958 free (symtab);
6959 symtab = GET_ELF_SYMBOLS (filedata, symtab_sec, & num_syms);
6960 }
6961
6962 if (symtab == NULL)
6963 {
6964 error (_("Corrupt header in group section `%s'\n"), name);
6965 continue;
6966 }
6967
6968 if (section->sh_info >= num_syms)
6969 {
6970 error (_("Bad sh_info in group section `%s'\n"), name);
6971 continue;
6972 }
6973
6974 sym = symtab + section->sh_info;
6975
6976 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6977 {
6978 if (sym->st_shndx == 0
6979 || sym->st_shndx >= filedata->file_header.e_shnum)
6980 {
6981 error (_("Bad sh_info in group section `%s'\n"), name);
6982 continue;
6983 }
6984
6985 group_name = SECTION_NAME (filedata->section_headers + sym->st_shndx);
6986 strtab_sec = NULL;
6987 if (strtab)
6988 free (strtab);
6989 strtab = NULL;
6990 strtab_size = 0;
6991 }
6992 else
6993 {
6994 /* Get the string table. */
6995 if (symtab_sec->sh_link >= filedata->file_header.e_shnum)
6996 {
6997 strtab_sec = NULL;
6998 if (strtab)
6999 free (strtab);
7000 strtab = NULL;
7001 strtab_size = 0;
7002 }
7003 else if (strtab_sec
7004 != (sec = filedata->section_headers + symtab_sec->sh_link))
7005 {
7006 strtab_sec = sec;
7007 if (strtab)
7008 free (strtab);
7009
7010 strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
7011 1, strtab_sec->sh_size,
7012 _("string table"));
7013 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
7014 }
7015 group_name = sym->st_name < strtab_size
7016 ? strtab + sym->st_name : _("<corrupt>");
7017 }
7018
7019 /* PR 17531: file: loop. */
7020 if (section->sh_entsize > section->sh_size)
7021 {
7022 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
7023 printable_section_name (filedata, section),
7024 (unsigned long) section->sh_entsize,
7025 (unsigned long) section->sh_size);
7026 continue;
7027 }
7028
7029 start = (unsigned char *) get_data (NULL, filedata, section->sh_offset,
7030 1, section->sh_size,
7031 _("section data"));
7032 if (start == NULL)
7033 continue;
7034
7035 indices = start;
7036 size = (section->sh_size / section->sh_entsize) - 1;
7037 entry = byte_get (indices, 4);
7038 indices += 4;
7039
7040 if (do_section_groups)
7041 {
7042 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
7043 get_group_flags (entry), i, name, group_name, size);
7044
7045 printf (_(" [Index] Name\n"));
7046 }
7047
7048 group->group_index = i;
7049
7050 for (j = 0; j < size; j++)
7051 {
7052 struct group_list * g;
7053
7054 entry = byte_get (indices, 4);
7055 indices += 4;
7056
7057 if (entry >= filedata->file_header.e_shnum)
7058 {
7059 static unsigned num_group_errors = 0;
7060
7061 if (num_group_errors ++ < 10)
7062 {
7063 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
7064 entry, i, filedata->file_header.e_shnum - 1);
7065 if (num_group_errors == 10)
7066 warn (_("Further error messages about overlarge group section indices suppressed\n"));
7067 }
7068 continue;
7069 }
7070
7071 if (filedata->section_headers_groups [entry] != NULL)
7072 {
7073 if (entry)
7074 {
7075 static unsigned num_errs = 0;
7076
7077 if (num_errs ++ < 10)
7078 {
7079 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7080 entry, i,
7081 filedata->section_headers_groups [entry]->group_index);
7082 if (num_errs == 10)
7083 warn (_("Further error messages about already contained group sections suppressed\n"));
7084 }
7085 continue;
7086 }
7087 else
7088 {
7089 /* Intel C/C++ compiler may put section 0 in a
7090 section group. We just warn it the first time
7091 and ignore it afterwards. */
7092 static bfd_boolean warned = FALSE;
7093 if (!warned)
7094 {
7095 error (_("section 0 in group section [%5u]\n"),
7096 filedata->section_headers_groups [entry]->group_index);
7097 warned = TRUE;
7098 }
7099 }
7100 }
7101
7102 filedata->section_headers_groups [entry] = group;
7103
7104 if (do_section_groups)
7105 {
7106 sec = filedata->section_headers + entry;
7107 printf (" [%5u] %s\n", entry, printable_section_name (filedata, sec));
7108 }
7109
7110 g = (struct group_list *) xmalloc (sizeof (struct group_list));
7111 g->section_index = entry;
7112 g->next = group->root;
7113 group->root = g;
7114 }
7115
7116 if (start)
7117 free (start);
7118
7119 group++;
7120 }
7121 }
7122
7123 if (symtab)
7124 free (symtab);
7125 if (strtab)
7126 free (strtab);
7127 return TRUE;
7128}
7129
7130/* Data used to display dynamic fixups. */
7131
7132struct ia64_vms_dynfixup
7133{
7134 bfd_vma needed_ident; /* Library ident number. */
7135 bfd_vma needed; /* Index in the dstrtab of the library name. */
7136 bfd_vma fixup_needed; /* Index of the library. */
7137 bfd_vma fixup_rela_cnt; /* Number of fixups. */
7138 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
7139};
7140
7141/* Data used to display dynamic relocations. */
7142
7143struct ia64_vms_dynimgrela
7144{
7145 bfd_vma img_rela_cnt; /* Number of relocations. */
7146 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
7147};
7148
7149/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7150 library). */
7151
7152static bfd_boolean
7153dump_ia64_vms_dynamic_fixups (Filedata * filedata,
7154 struct ia64_vms_dynfixup * fixup,
7155 const char * strtab,
7156 unsigned int strtab_sz)
7157{
7158 Elf64_External_VMS_IMAGE_FIXUP * imfs;
7159 long i;
7160 const char * lib_name;
7161
7162 imfs = get_data (NULL, filedata,
7163 filedata->dynamic_addr + fixup->fixup_rela_off,
7164 sizeof (*imfs), fixup->fixup_rela_cnt,
7165 _("dynamic section image fixups"));
7166 if (!imfs)
7167 return FALSE;
7168
7169 if (fixup->needed < strtab_sz)
7170 lib_name = strtab + fixup->needed;
7171 else
7172 {
7173 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7174 (unsigned long) fixup->needed);
7175 lib_name = "???";
7176 }
7177
7178 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7179 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
7180 printf
7181 (_("Seg Offset Type SymVec DataType\n"));
7182
7183 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
7184 {
7185 unsigned int type;
7186 const char *rtype;
7187
7188 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
7189 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
7190 type = BYTE_GET (imfs [i].type);
7191 rtype = elf_ia64_reloc_type (type);
7192 if (rtype == NULL)
7193 printf (" 0x%08x ", type);
7194 else
7195 printf (" %-32s ", rtype);
7196 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
7197 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
7198 }
7199
7200 free (imfs);
7201 return TRUE;
7202}
7203
7204/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7205
7206static bfd_boolean
7207dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *imgrela)
7208{
7209 Elf64_External_VMS_IMAGE_RELA *imrs;
7210 long i;
7211
7212 imrs = get_data (NULL, filedata,
7213 filedata->dynamic_addr + imgrela->img_rela_off,
7214 sizeof (*imrs), imgrela->img_rela_cnt,
7215 _("dynamic section image relocations"));
7216 if (!imrs)
7217 return FALSE;
7218
7219 printf (_("\nImage relocs\n"));
7220 printf
7221 (_("Seg Offset Type Addend Seg Sym Off\n"));
7222
7223 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
7224 {
7225 unsigned int type;
7226 const char *rtype;
7227
7228 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
7229 printf ("%08" BFD_VMA_FMT "x ",
7230 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
7231 type = BYTE_GET (imrs [i].type);
7232 rtype = elf_ia64_reloc_type (type);
7233 if (rtype == NULL)
7234 printf ("0x%08x ", type);
7235 else
7236 printf ("%-31s ", rtype);
7237 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
7238 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
7239 printf ("%08" BFD_VMA_FMT "x\n",
7240 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
7241 }
7242
7243 free (imrs);
7244 return TRUE;
7245}
7246
7247/* Display IA-64 OpenVMS dynamic relocations and fixups. */
7248
7249static bfd_boolean
7250process_ia64_vms_dynamic_relocs (Filedata * filedata)
7251{
7252 struct ia64_vms_dynfixup fixup;
7253 struct ia64_vms_dynimgrela imgrela;
7254 Elf_Internal_Dyn *entry;
7255 bfd_vma strtab_off = 0;
7256 bfd_vma strtab_sz = 0;
7257 char *strtab = NULL;
7258 bfd_boolean res = TRUE;
7259
7260 memset (&fixup, 0, sizeof (fixup));
7261 memset (&imgrela, 0, sizeof (imgrela));
7262
7263 /* Note: the order of the entries is specified by the OpenVMS specs. */
7264 for (entry = filedata->dynamic_section;
7265 entry < filedata->dynamic_section + filedata->dynamic_nent;
7266 entry++)
7267 {
7268 switch (entry->d_tag)
7269 {
7270 case DT_IA_64_VMS_STRTAB_OFFSET:
7271 strtab_off = entry->d_un.d_val;
7272 break;
7273 case DT_STRSZ:
7274 strtab_sz = entry->d_un.d_val;
7275 if (strtab == NULL)
7276 strtab = get_data (NULL, filedata,
7277 filedata->dynamic_addr + strtab_off,
7278 1, strtab_sz, _("dynamic string section"));
7279 if (strtab == NULL)
7280 strtab_sz = 0;
7281 break;
7282
7283 case DT_IA_64_VMS_NEEDED_IDENT:
7284 fixup.needed_ident = entry->d_un.d_val;
7285 break;
7286 case DT_NEEDED:
7287 fixup.needed = entry->d_un.d_val;
7288 break;
7289 case DT_IA_64_VMS_FIXUP_NEEDED:
7290 fixup.fixup_needed = entry->d_un.d_val;
7291 break;
7292 case DT_IA_64_VMS_FIXUP_RELA_CNT:
7293 fixup.fixup_rela_cnt = entry->d_un.d_val;
7294 break;
7295 case DT_IA_64_VMS_FIXUP_RELA_OFF:
7296 fixup.fixup_rela_off = entry->d_un.d_val;
7297 if (! dump_ia64_vms_dynamic_fixups (filedata, &fixup, strtab, strtab_sz))
7298 res = FALSE;
7299 break;
7300 case DT_IA_64_VMS_IMG_RELA_CNT:
7301 imgrela.img_rela_cnt = entry->d_un.d_val;
7302 break;
7303 case DT_IA_64_VMS_IMG_RELA_OFF:
7304 imgrela.img_rela_off = entry->d_un.d_val;
7305 if (! dump_ia64_vms_dynamic_relocs (filedata, &imgrela))
7306 res = FALSE;
7307 break;
7308
7309 default:
7310 break;
7311 }
7312 }
7313
7314 if (strtab != NULL)
7315 free (strtab);
7316
7317 return res;
7318}
7319
7320static struct
7321{
7322 const char * name;
7323 int reloc;
7324 int size;
7325 int rela;
7326}
7327 dynamic_relocations [] =
7328{
7329 { "REL", DT_REL, DT_RELSZ, FALSE },
7330 { "RELA", DT_RELA, DT_RELASZ, TRUE },
7331 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
7332};
7333
7334/* Process the reloc section. */
7335
7336static bfd_boolean
7337process_relocs (Filedata * filedata)
7338{
7339 unsigned long rel_size;
7340 unsigned long rel_offset;
7341
7342 if (!do_reloc)
7343 return TRUE;
7344
7345 if (do_using_dynamic)
7346 {
7347 int is_rela;
7348 const char * name;
7349 bfd_boolean has_dynamic_reloc;
7350 unsigned int i;
7351
7352 has_dynamic_reloc = FALSE;
7353
7354 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7355 {
7356 is_rela = dynamic_relocations [i].rela;
7357 name = dynamic_relocations [i].name;
7358 rel_size = filedata->dynamic_info[dynamic_relocations [i].size];
7359 rel_offset = filedata->dynamic_info[dynamic_relocations [i].reloc];
7360
7361 if (rel_size)
7362 has_dynamic_reloc = TRUE;
7363
7364 if (is_rela == UNKNOWN)
7365 {
7366 if (dynamic_relocations [i].reloc == DT_JMPREL)
7367 switch (filedata->dynamic_info[DT_PLTREL])
7368 {
7369 case DT_REL:
7370 is_rela = FALSE;
7371 break;
7372 case DT_RELA:
7373 is_rela = TRUE;
7374 break;
7375 }
7376 }
7377
7378 if (rel_size)
7379 {
7380 printf
7381 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7382 name, rel_offset, rel_size);
7383
7384 dump_relocations (filedata,
7385 offset_from_vma (filedata, rel_offset, rel_size),
7386 rel_size,
7387 filedata->dynamic_symbols,
7388 filedata->num_dynamic_syms,
7389 filedata->dynamic_strings,
7390 filedata->dynamic_strings_length,
7391 is_rela, TRUE /* is_dynamic */);
7392 }
7393 }
7394
7395 if (is_ia64_vms (filedata))
7396 if (process_ia64_vms_dynamic_relocs (filedata))
7397 has_dynamic_reloc = TRUE;
7398
7399 if (! has_dynamic_reloc)
7400 printf (_("\nThere are no dynamic relocations in this file.\n"));
7401 }
7402 else
7403 {
7404 Elf_Internal_Shdr * section;
7405 unsigned long i;
7406 bfd_boolean found = FALSE;
7407
7408 for (i = 0, section = filedata->section_headers;
7409 i < filedata->file_header.e_shnum;
7410 i++, section++)
7411 {
7412 if ( section->sh_type != SHT_RELA
7413 && section->sh_type != SHT_REL)
7414 continue;
7415
7416 rel_offset = section->sh_offset;
7417 rel_size = section->sh_size;
7418
7419 if (rel_size)
7420 {
7421 int is_rela;
7422 unsigned long num_rela;
7423
7424 printf (_("\nRelocation section "));
7425
7426 if (filedata->string_table == NULL)
7427 printf ("%d", section->sh_name);
7428 else
7429 printf ("'%s'", printable_section_name (filedata, section));
7430
7431 num_rela = rel_size / section->sh_entsize;
7432 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7433 " at offset 0x%lx contains %lu entries:\n",
7434 num_rela),
7435 rel_offset, num_rela);
7436
7437 is_rela = section->sh_type == SHT_RELA;
7438
7439 if (section->sh_link != 0
7440 && section->sh_link < filedata->file_header.e_shnum)
7441 {
7442 Elf_Internal_Shdr * symsec;
7443 Elf_Internal_Sym * symtab;
7444 unsigned long nsyms;
7445 unsigned long strtablen = 0;
7446 char * strtab = NULL;
7447
7448 symsec = filedata->section_headers + section->sh_link;
7449 if (symsec->sh_type != SHT_SYMTAB
7450 && symsec->sh_type != SHT_DYNSYM)
7451 continue;
7452
7453 if (!get_symtab (filedata, symsec,
7454 &symtab, &nsyms, &strtab, &strtablen))
7455 continue;
7456
7457 dump_relocations (filedata, rel_offset, rel_size,
7458 symtab, nsyms, strtab, strtablen,
7459 is_rela,
7460 symsec->sh_type == SHT_DYNSYM);
7461 if (strtab)
7462 free (strtab);
7463 free (symtab);
7464 }
7465 else
7466 dump_relocations (filedata, rel_offset, rel_size,
7467 NULL, 0, NULL, 0, is_rela,
7468 FALSE /* is_dynamic */);
7469
7470 found = TRUE;
7471 }
7472 }
7473
7474 if (! found)
7475 {
7476 /* Users sometimes forget the -D option, so try to be helpful. */
7477 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7478 {
7479 if (filedata->dynamic_info[dynamic_relocations [i].size])
7480 {
7481 printf (_("\nThere are no static relocations in this file."));
7482 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7483
7484 break;
7485 }
7486 }
7487 if (i == ARRAY_SIZE (dynamic_relocations))
7488 printf (_("\nThere are no relocations in this file.\n"));
7489 }
7490 }
7491
7492 return TRUE;
7493}
7494
7495/* An absolute address consists of a section and an offset. If the
7496 section is NULL, the offset itself is the address, otherwise, the
7497 address equals to LOAD_ADDRESS(section) + offset. */
7498
7499struct absaddr
7500{
7501 unsigned short section;
7502 bfd_vma offset;
7503};
7504
7505/* Find the nearest symbol at or below ADDR. Returns the symbol
7506 name, if found, and the offset from the symbol to ADDR. */
7507
7508static void
7509find_symbol_for_address (Filedata * filedata,
7510 Elf_Internal_Sym * symtab,
7511 unsigned long nsyms,
7512 const char * strtab,
7513 unsigned long strtab_size,
7514 struct absaddr addr,
7515 const char ** symname,
7516 bfd_vma * offset)
7517{
7518 bfd_vma dist = 0x100000;
7519 Elf_Internal_Sym * sym;
7520 Elf_Internal_Sym * beg;
7521 Elf_Internal_Sym * end;
7522 Elf_Internal_Sym * best = NULL;
7523
7524 REMOVE_ARCH_BITS (addr.offset);
7525 beg = symtab;
7526 end = symtab + nsyms;
7527
7528 while (beg < end)
7529 {
7530 bfd_vma value;
7531
7532 sym = beg + (end - beg) / 2;
7533
7534 value = sym->st_value;
7535 REMOVE_ARCH_BITS (value);
7536
7537 if (sym->st_name != 0
7538 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7539 && addr.offset >= value
7540 && addr.offset - value < dist)
7541 {
7542 best = sym;
7543 dist = addr.offset - value;
7544 if (!dist)
7545 break;
7546 }
7547
7548 if (addr.offset < value)
7549 end = sym;
7550 else
7551 beg = sym + 1;
7552 }
7553
7554 if (best)
7555 {
7556 *symname = (best->st_name >= strtab_size
7557 ? _("<corrupt>") : strtab + best->st_name);
7558 *offset = dist;
7559 return;
7560 }
7561
7562 *symname = NULL;
7563 *offset = addr.offset;
7564}
7565
7566static /* signed */ int
7567symcmp (const void *p, const void *q)
7568{
7569 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7570 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7571
7572 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7573}
7574
7575/* Process the unwind section. */
7576
7577#include "unwind-ia64.h"
7578
7579struct ia64_unw_table_entry
7580{
7581 struct absaddr start;
7582 struct absaddr end;
7583 struct absaddr info;
7584};
7585
7586struct ia64_unw_aux_info
7587{
7588 struct ia64_unw_table_entry * table; /* Unwind table. */
7589 unsigned long table_len; /* Length of unwind table. */
7590 unsigned char * info; /* Unwind info. */
7591 unsigned long info_size; /* Size of unwind info. */
7592 bfd_vma info_addr; /* Starting address of unwind info. */
7593 bfd_vma seg_base; /* Starting address of segment. */
7594 Elf_Internal_Sym * symtab; /* The symbol table. */
7595 unsigned long nsyms; /* Number of symbols. */
7596 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7597 unsigned long nfuns; /* Number of entries in funtab. */
7598 char * strtab; /* The string table. */
7599 unsigned long strtab_size; /* Size of string table. */
7600};
7601
7602static bfd_boolean
7603dump_ia64_unwind (Filedata * filedata, struct ia64_unw_aux_info * aux)
7604{
7605 struct ia64_unw_table_entry * tp;
7606 unsigned long j, nfuns;
7607 int in_body;
7608 bfd_boolean res = TRUE;
7609
7610 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7611 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7612 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7613 aux->funtab[nfuns++] = aux->symtab[j];
7614 aux->nfuns = nfuns;
7615 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7616
7617 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7618 {
7619 bfd_vma stamp;
7620 bfd_vma offset;
7621 const unsigned char * dp;
7622 const unsigned char * head;
7623 const unsigned char * end;
7624 const char * procname;
7625
7626 find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7627 aux->strtab_size, tp->start, &procname, &offset);
7628
7629 fputs ("\n<", stdout);
7630
7631 if (procname)
7632 {
7633 fputs (procname, stdout);
7634
7635 if (offset)
7636 printf ("+%lx", (unsigned long) offset);
7637 }
7638
7639 fputs (">: [", stdout);
7640 print_vma (tp->start.offset, PREFIX_HEX);
7641 fputc ('-', stdout);
7642 print_vma (tp->end.offset, PREFIX_HEX);
7643 printf ("], info at +0x%lx\n",
7644 (unsigned long) (tp->info.offset - aux->seg_base));
7645
7646 /* PR 17531: file: 86232b32. */
7647 if (aux->info == NULL)
7648 continue;
7649
7650 offset = tp->info.offset;
7651 if (tp->info.section)
7652 {
7653 if (tp->info.section >= filedata->file_header.e_shnum)
7654 {
7655 warn (_("Invalid section %u in table entry %ld\n"),
7656 tp->info.section, (long) (tp - aux->table));
7657 res = FALSE;
7658 continue;
7659 }
7660 offset += filedata->section_headers[tp->info.section].sh_addr;
7661 }
7662 offset -= aux->info_addr;
7663 /* PR 17531: file: 0997b4d1. */
7664 if (offset >= aux->info_size
7665 || aux->info_size - offset < 8)
7666 {
7667 warn (_("Invalid offset %lx in table entry %ld\n"),
7668 (long) tp->info.offset, (long) (tp - aux->table));
7669 res = FALSE;
7670 continue;
7671 }
7672
7673 head = aux->info + offset;
7674 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7675
7676 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7677 (unsigned) UNW_VER (stamp),
7678 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7679 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7680 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7681 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7682
7683 if (UNW_VER (stamp) != 1)
7684 {
7685 printf (_("\tUnknown version.\n"));
7686 continue;
7687 }
7688
7689 in_body = 0;
7690 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7691 /* PR 17531: file: 16ceda89. */
7692 if (end > aux->info + aux->info_size)
7693 end = aux->info + aux->info_size;
7694 for (dp = head + 8; dp < end;)
7695 dp = unw_decode (dp, in_body, & in_body, end);
7696 }
7697
7698 free (aux->funtab);
7699
7700 return res;
7701}
7702
7703static bfd_boolean
7704slurp_ia64_unwind_table (Filedata * filedata,
7705 struct ia64_unw_aux_info * aux,
7706 Elf_Internal_Shdr * sec)
7707{
7708 unsigned long size, nrelas, i;
7709 Elf_Internal_Phdr * seg;
7710 struct ia64_unw_table_entry * tep;
7711 Elf_Internal_Shdr * relsec;
7712 Elf_Internal_Rela * rela;
7713 Elf_Internal_Rela * rp;
7714 unsigned char * table;
7715 unsigned char * tp;
7716 Elf_Internal_Sym * sym;
7717 const char * relname;
7718
7719 aux->table_len = 0;
7720
7721 /* First, find the starting address of the segment that includes
7722 this section: */
7723
7724 if (filedata->file_header.e_phnum)
7725 {
7726 if (! get_program_headers (filedata))
7727 return FALSE;
7728
7729 for (seg = filedata->program_headers;
7730 seg < filedata->program_headers + filedata->file_header.e_phnum;
7731 ++seg)
7732 {
7733 if (seg->p_type != PT_LOAD)
7734 continue;
7735
7736 if (sec->sh_addr >= seg->p_vaddr
7737 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7738 {
7739 aux->seg_base = seg->p_vaddr;
7740 break;
7741 }
7742 }
7743 }
7744
7745 /* Second, build the unwind table from the contents of the unwind section: */
7746 size = sec->sh_size;
7747 table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7748 _("unwind table"));
7749 if (!table)
7750 return FALSE;
7751
7752 aux->table_len = size / (3 * eh_addr_size);
7753 aux->table = (struct ia64_unw_table_entry *)
7754 xcmalloc (aux->table_len, sizeof (aux->table[0]));
7755 tep = aux->table;
7756
7757 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7758 {
7759 tep->start.section = SHN_UNDEF;
7760 tep->end.section = SHN_UNDEF;
7761 tep->info.section = SHN_UNDEF;
7762 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7763 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7764 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7765 tep->start.offset += aux->seg_base;
7766 tep->end.offset += aux->seg_base;
7767 tep->info.offset += aux->seg_base;
7768 }
7769 free (table);
7770
7771 /* Third, apply any relocations to the unwind table: */
7772 for (relsec = filedata->section_headers;
7773 relsec < filedata->section_headers + filedata->file_header.e_shnum;
7774 ++relsec)
7775 {
7776 if (relsec->sh_type != SHT_RELA
7777 || relsec->sh_info >= filedata->file_header.e_shnum
7778 || filedata->section_headers + relsec->sh_info != sec)
7779 continue;
7780
7781 if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7782 & rela, & nrelas))
7783 {
7784 free (aux->table);
7785 aux->table = NULL;
7786 aux->table_len = 0;
7787 return FALSE;
7788 }
7789
7790 for (rp = rela; rp < rela + nrelas; ++rp)
7791 {
7792 unsigned int sym_ndx;
7793 unsigned int r_type = get_reloc_type (filedata, rp->r_info);
7794 relname = elf_ia64_reloc_type (r_type);
7795
7796 /* PR 17531: file: 9fa67536. */
7797 if (relname == NULL)
7798 {
7799 warn (_("Skipping unknown relocation type: %u\n"), r_type);
7800 continue;
7801 }
7802
7803 if (! const_strneq (relname, "R_IA64_SEGREL"))
7804 {
7805 warn (_("Skipping unexpected relocation type: %s\n"), relname);
7806 continue;
7807 }
7808
7809 i = rp->r_offset / (3 * eh_addr_size);
7810
7811 /* PR 17531: file: 5bc8d9bf. */
7812 if (i >= aux->table_len)
7813 {
7814 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7815 continue;
7816 }
7817
7818 sym_ndx = get_reloc_symindex (rp->r_info);
7819 if (sym_ndx >= aux->nsyms)
7820 {
7821 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7822 sym_ndx);
7823 continue;
7824 }
7825 sym = aux->symtab + sym_ndx;
7826
7827 switch (rp->r_offset / eh_addr_size % 3)
7828 {
7829 case 0:
7830 aux->table[i].start.section = sym->st_shndx;
7831 aux->table[i].start.offset = rp->r_addend + sym->st_value;
7832 break;
7833 case 1:
7834 aux->table[i].end.section = sym->st_shndx;
7835 aux->table[i].end.offset = rp->r_addend + sym->st_value;
7836 break;
7837 case 2:
7838 aux->table[i].info.section = sym->st_shndx;
7839 aux->table[i].info.offset = rp->r_addend + sym->st_value;
7840 break;
7841 default:
7842 break;
7843 }
7844 }
7845
7846 free (rela);
7847 }
7848
7849 return TRUE;
7850}
7851
7852static bfd_boolean
7853ia64_process_unwind (Filedata * filedata)
7854{
7855 Elf_Internal_Shdr * sec;
7856 Elf_Internal_Shdr * unwsec = NULL;
7857 unsigned long i, unwcount = 0, unwstart = 0;
7858 struct ia64_unw_aux_info aux;
7859 bfd_boolean res = TRUE;
7860
7861 memset (& aux, 0, sizeof (aux));
7862
7863 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
7864 {
7865 if (sec->sh_type == SHT_SYMTAB)
7866 {
7867 if (aux.symtab)
7868 {
7869 error (_("Multiple symbol tables encountered\n"));
7870 free (aux.symtab);
7871 aux.symtab = NULL;
7872 free (aux.strtab);
7873 aux.strtab = NULL;
7874 }
7875 if (!get_symtab (filedata, sec, &aux.symtab, &aux.nsyms,
7876 &aux.strtab, &aux.strtab_size))
7877 return FALSE;
7878 }
7879 else if (sec->sh_type == SHT_IA_64_UNWIND)
7880 unwcount++;
7881 }
7882
7883 if (!unwcount)
7884 printf (_("\nThere are no unwind sections in this file.\n"));
7885
7886 while (unwcount-- > 0)
7887 {
7888 char * suffix;
7889 size_t len, len2;
7890
7891 for (i = unwstart, sec = filedata->section_headers + unwstart, unwsec = NULL;
7892 i < filedata->file_header.e_shnum; ++i, ++sec)
7893 if (sec->sh_type == SHT_IA_64_UNWIND)
7894 {
7895 unwsec = sec;
7896 break;
7897 }
7898 /* We have already counted the number of SHT_IA64_UNWIND
7899 sections so the loop above should never fail. */
7900 assert (unwsec != NULL);
7901
7902 unwstart = i + 1;
7903 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7904
7905 if ((unwsec->sh_flags & SHF_GROUP) != 0)
7906 {
7907 /* We need to find which section group it is in. */
7908 struct group_list * g;
7909
7910 if (filedata->section_headers_groups == NULL
7911 || filedata->section_headers_groups[i] == NULL)
7912 i = filedata->file_header.e_shnum;
7913 else
7914 {
7915 g = filedata->section_headers_groups[i]->root;
7916
7917 for (; g != NULL; g = g->next)
7918 {
7919 sec = filedata->section_headers + g->section_index;
7920
7921 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7922 break;
7923 }
7924
7925 if (g == NULL)
7926 i = filedata->file_header.e_shnum;
7927 }
7928 }
7929 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7930 {
7931 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7932 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7933 suffix = SECTION_NAME (unwsec) + len;
7934 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7935 ++i, ++sec)
7936 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7937 && streq (SECTION_NAME (sec) + len2, suffix))
7938 break;
7939 }
7940 else
7941 {
7942 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7943 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7944 len = sizeof (ELF_STRING_ia64_unwind) - 1;
7945 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7946 suffix = "";
7947 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7948 suffix = SECTION_NAME (unwsec) + len;
7949 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7950 ++i, ++sec)
7951 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7952 && streq (SECTION_NAME (sec) + len2, suffix))
7953 break;
7954 }
7955
7956 if (i == filedata->file_header.e_shnum)
7957 {
7958 printf (_("\nCould not find unwind info section for "));
7959
7960 if (filedata->string_table == NULL)
7961 printf ("%d", unwsec->sh_name);
7962 else
7963 printf ("'%s'", printable_section_name (filedata, unwsec));
7964 }
7965 else
7966 {
7967 aux.info_addr = sec->sh_addr;
7968 aux.info = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1,
7969 sec->sh_size,
7970 _("unwind info"));
7971 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7972
7973 printf (_("\nUnwind section "));
7974
7975 if (filedata->string_table == NULL)
7976 printf ("%d", unwsec->sh_name);
7977 else
7978 printf ("'%s'", printable_section_name (filedata, unwsec));
7979
7980 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7981 (unsigned long) unwsec->sh_offset,
7982 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7983
7984 if (slurp_ia64_unwind_table (filedata, & aux, unwsec)
7985 && aux.table_len > 0)
7986 dump_ia64_unwind (filedata, & aux);
7987
7988 if (aux.table)
7989 free ((char *) aux.table);
7990 if (aux.info)
7991 free ((char *) aux.info);
7992 aux.table = NULL;
7993 aux.info = NULL;
7994 }
7995 }
7996
7997 if (aux.symtab)
7998 free (aux.symtab);
7999 if (aux.strtab)
8000 free ((char *) aux.strtab);
8001
8002 return res;
8003}
8004
8005struct hppa_unw_table_entry
8006{
8007 struct absaddr start;
8008 struct absaddr end;
8009 unsigned int Cannot_unwind:1; /* 0 */
8010 unsigned int Millicode:1; /* 1 */
8011 unsigned int Millicode_save_sr0:1; /* 2 */
8012 unsigned int Region_description:2; /* 3..4 */
8013 unsigned int reserved1:1; /* 5 */
8014 unsigned int Entry_SR:1; /* 6 */
8015 unsigned int Entry_FR:4; /* Number saved 7..10 */
8016 unsigned int Entry_GR:5; /* Number saved 11..15 */
8017 unsigned int Args_stored:1; /* 16 */
8018 unsigned int Variable_Frame:1; /* 17 */
8019 unsigned int Separate_Package_Body:1; /* 18 */
8020 unsigned int Frame_Extension_Millicode:1; /* 19 */
8021 unsigned int Stack_Overflow_Check:1; /* 20 */
8022 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
8023 unsigned int Ada_Region:1; /* 22 */
8024 unsigned int cxx_info:1; /* 23 */
8025 unsigned int cxx_try_catch:1; /* 24 */
8026 unsigned int sched_entry_seq:1; /* 25 */
8027 unsigned int reserved2:1; /* 26 */
8028 unsigned int Save_SP:1; /* 27 */
8029 unsigned int Save_RP:1; /* 28 */
8030 unsigned int Save_MRP_in_frame:1; /* 29 */
8031 unsigned int extn_ptr_defined:1; /* 30 */
8032 unsigned int Cleanup_defined:1; /* 31 */
8033
8034 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
8035 unsigned int HP_UX_interrupt_marker:1; /* 1 */
8036 unsigned int Large_frame:1; /* 2 */
8037 unsigned int Pseudo_SP_Set:1; /* 3 */
8038 unsigned int reserved4:1; /* 4 */
8039 unsigned int Total_frame_size:27; /* 5..31 */
8040};
8041
8042struct hppa_unw_aux_info
8043{
8044 struct hppa_unw_table_entry * table; /* Unwind table. */
8045 unsigned long table_len; /* Length of unwind table. */
8046 bfd_vma seg_base; /* Starting address of segment. */
8047 Elf_Internal_Sym * symtab; /* The symbol table. */
8048 unsigned long nsyms; /* Number of symbols. */
8049 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
8050 unsigned long nfuns; /* Number of entries in funtab. */
8051 char * strtab; /* The string table. */
8052 unsigned long strtab_size; /* Size of string table. */
8053};
8054
8055static bfd_boolean
8056dump_hppa_unwind (Filedata * filedata, struct hppa_unw_aux_info * aux)
8057{
8058 struct hppa_unw_table_entry * tp;
8059 unsigned long j, nfuns;
8060 bfd_boolean res = TRUE;
8061
8062 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8063 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8064 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8065 aux->funtab[nfuns++] = aux->symtab[j];
8066 aux->nfuns = nfuns;
8067 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8068
8069 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
8070 {
8071 bfd_vma offset;
8072 const char * procname;
8073
8074 find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8075 aux->strtab_size, tp->start, &procname,
8076 &offset);
8077
8078 fputs ("\n<", stdout);
8079
8080 if (procname)
8081 {
8082 fputs (procname, stdout);
8083
8084 if (offset)
8085 printf ("+%lx", (unsigned long) offset);
8086 }
8087
8088 fputs (">: [", stdout);
8089 print_vma (tp->start.offset, PREFIX_HEX);
8090 fputc ('-', stdout);
8091 print_vma (tp->end.offset, PREFIX_HEX);
8092 printf ("]\n\t");
8093
8094#define PF(_m) if (tp->_m) printf (#_m " ");
8095#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8096 PF(Cannot_unwind);
8097 PF(Millicode);
8098 PF(Millicode_save_sr0);
8099 /* PV(Region_description); */
8100 PF(Entry_SR);
8101 PV(Entry_FR);
8102 PV(Entry_GR);
8103 PF(Args_stored);
8104 PF(Variable_Frame);
8105 PF(Separate_Package_Body);
8106 PF(Frame_Extension_Millicode);
8107 PF(Stack_Overflow_Check);
8108 PF(Two_Instruction_SP_Increment);
8109 PF(Ada_Region);
8110 PF(cxx_info);
8111 PF(cxx_try_catch);
8112 PF(sched_entry_seq);
8113 PF(Save_SP);
8114 PF(Save_RP);
8115 PF(Save_MRP_in_frame);
8116 PF(extn_ptr_defined);
8117 PF(Cleanup_defined);
8118 PF(MPE_XL_interrupt_marker);
8119 PF(HP_UX_interrupt_marker);
8120 PF(Large_frame);
8121 PF(Pseudo_SP_Set);
8122 PV(Total_frame_size);
8123#undef PF
8124#undef PV
8125 }
8126
8127 printf ("\n");
8128
8129 free (aux->funtab);
8130
8131 return res;
8132}
8133
8134static bfd_boolean
8135slurp_hppa_unwind_table (Filedata * filedata,
8136 struct hppa_unw_aux_info * aux,
8137 Elf_Internal_Shdr * sec)
8138{
8139 unsigned long size, unw_ent_size, nentries, nrelas, i;
8140 Elf_Internal_Phdr * seg;
8141 struct hppa_unw_table_entry * tep;
8142 Elf_Internal_Shdr * relsec;
8143 Elf_Internal_Rela * rela;
8144 Elf_Internal_Rela * rp;
8145 unsigned char * table;
8146 unsigned char * tp;
8147 Elf_Internal_Sym * sym;
8148 const char * relname;
8149
8150 /* First, find the starting address of the segment that includes
8151 this section. */
8152 if (filedata->file_header.e_phnum)
8153 {
8154 if (! get_program_headers (filedata))
8155 return FALSE;
8156
8157 for (seg = filedata->program_headers;
8158 seg < filedata->program_headers + filedata->file_header.e_phnum;
8159 ++seg)
8160 {
8161 if (seg->p_type != PT_LOAD)
8162 continue;
8163
8164 if (sec->sh_addr >= seg->p_vaddr
8165 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
8166 {
8167 aux->seg_base = seg->p_vaddr;
8168 break;
8169 }
8170 }
8171 }
8172
8173 /* Second, build the unwind table from the contents of the unwind
8174 section. */
8175 size = sec->sh_size;
8176 table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
8177 _("unwind table"));
8178 if (!table)
8179 return FALSE;
8180
8181 unw_ent_size = 16;
8182 nentries = size / unw_ent_size;
8183 size = unw_ent_size * nentries;
8184
8185 tep = aux->table = (struct hppa_unw_table_entry *)
8186 xcmalloc (nentries, sizeof (aux->table[0]));
8187
8188 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
8189 {
8190 unsigned int tmp1, tmp2;
8191
8192 tep->start.section = SHN_UNDEF;
8193 tep->end.section = SHN_UNDEF;
8194
8195 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
8196 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
8197 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
8198 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
8199
8200 tep->start.offset += aux->seg_base;
8201 tep->end.offset += aux->seg_base;
8202
8203 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
8204 tep->Millicode = (tmp1 >> 30) & 0x1;
8205 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
8206 tep->Region_description = (tmp1 >> 27) & 0x3;
8207 tep->reserved1 = (tmp1 >> 26) & 0x1;
8208 tep->Entry_SR = (tmp1 >> 25) & 0x1;
8209 tep->Entry_FR = (tmp1 >> 21) & 0xf;
8210 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
8211 tep->Args_stored = (tmp1 >> 15) & 0x1;
8212 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
8213 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
8214 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
8215 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
8216 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
8217 tep->Ada_Region = (tmp1 >> 9) & 0x1;
8218 tep->cxx_info = (tmp1 >> 8) & 0x1;
8219 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
8220 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
8221 tep->reserved2 = (tmp1 >> 5) & 0x1;
8222 tep->Save_SP = (tmp1 >> 4) & 0x1;
8223 tep->Save_RP = (tmp1 >> 3) & 0x1;
8224 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
8225 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
8226 tep->Cleanup_defined = tmp1 & 0x1;
8227
8228 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
8229 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
8230 tep->Large_frame = (tmp2 >> 29) & 0x1;
8231 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
8232 tep->reserved4 = (tmp2 >> 27) & 0x1;
8233 tep->Total_frame_size = tmp2 & 0x7ffffff;
8234 }
8235 free (table);
8236
8237 /* Third, apply any relocations to the unwind table. */
8238 for (relsec = filedata->section_headers;
8239 relsec < filedata->section_headers + filedata->file_header.e_shnum;
8240 ++relsec)
8241 {
8242 if (relsec->sh_type != SHT_RELA
8243 || relsec->sh_info >= filedata->file_header.e_shnum
8244 || filedata->section_headers + relsec->sh_info != sec)
8245 continue;
8246
8247 if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
8248 & rela, & nrelas))
8249 return FALSE;
8250
8251 for (rp = rela; rp < rela + nrelas; ++rp)
8252 {
8253 unsigned int sym_ndx;
8254 unsigned int r_type = get_reloc_type (filedata, rp->r_info);
8255 relname = elf_hppa_reloc_type (r_type);
8256
8257 if (relname == NULL)
8258 {
8259 warn (_("Skipping unknown relocation type: %u\n"), r_type);
8260 continue;
8261 }
8262
8263 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8264 if (! const_strneq (relname, "R_PARISC_SEGREL"))
8265 {
8266 warn (_("Skipping unexpected relocation type: %s\n"), relname);
8267 continue;
8268 }
8269
8270 i = rp->r_offset / unw_ent_size;
8271 if (i >= aux->table_len)
8272 {
8273 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
8274 continue;
8275 }
8276
8277 sym_ndx = get_reloc_symindex (rp->r_info);
8278 if (sym_ndx >= aux->nsyms)
8279 {
8280 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8281 sym_ndx);
8282 continue;
8283 }
8284 sym = aux->symtab + sym_ndx;
8285
8286 switch ((rp->r_offset % unw_ent_size) / 4)
8287 {
8288 case 0:
8289 aux->table[i].start.section = sym->st_shndx;
8290 aux->table[i].start.offset = sym->st_value + rp->r_addend;
8291 break;
8292 case 1:
8293 aux->table[i].end.section = sym->st_shndx;
8294 aux->table[i].end.offset = sym->st_value + rp->r_addend;
8295 break;
8296 default:
8297 break;
8298 }
8299 }
8300
8301 free (rela);
8302 }
8303
8304 aux->table_len = nentries;
8305
8306 return TRUE;
8307}
8308
8309static bfd_boolean
8310hppa_process_unwind (Filedata * filedata)
8311{
8312 struct hppa_unw_aux_info aux;
8313 Elf_Internal_Shdr * unwsec = NULL;
8314 Elf_Internal_Shdr * sec;
8315 unsigned long i;
8316 bfd_boolean res = TRUE;
8317
8318 if (filedata->string_table == NULL)
8319 return FALSE;
8320
8321 memset (& aux, 0, sizeof (aux));
8322
8323 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8324 {
8325 if (sec->sh_type == SHT_SYMTAB)
8326 {
8327 if (aux.symtab)
8328 {
8329 error (_("Multiple symbol tables encountered\n"));
8330 free (aux.symtab);
8331 aux.symtab = NULL;
8332 free (aux.strtab);
8333 aux.strtab = NULL;
8334 }
8335 if (!get_symtab (filedata, sec, &aux.symtab, &aux.nsyms,
8336 &aux.strtab, &aux.strtab_size))
8337 return FALSE;
8338 }
8339 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8340 unwsec = sec;
8341 }
8342
8343 if (!unwsec)
8344 printf (_("\nThere are no unwind sections in this file.\n"));
8345
8346 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8347 {
8348 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8349 {
8350 unsigned long num_unwind = sec->sh_size / 16;
8351
8352 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8353 "contains %lu entry:\n",
8354 "\nUnwind section '%s' at offset 0x%lx "
8355 "contains %lu entries:\n",
8356 num_unwind),
8357 printable_section_name (filedata, sec),
8358 (unsigned long) sec->sh_offset,
8359 num_unwind);
8360
8361 if (! slurp_hppa_unwind_table (filedata, &aux, sec))
8362 res = FALSE;
8363
8364 if (res && aux.table_len > 0)
8365 {
8366 if (! dump_hppa_unwind (filedata, &aux))
8367 res = FALSE;
8368 }
8369
8370 if (aux.table)
8371 free ((char *) aux.table);
8372 aux.table = NULL;
8373 }
8374 }
8375
8376 if (aux.symtab)
8377 free (aux.symtab);
8378 if (aux.strtab)
8379 free ((char *) aux.strtab);
8380
8381 return res;
8382}
8383
8384struct arm_section
8385{
8386 unsigned char * data; /* The unwind data. */
8387 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
8388 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
8389 unsigned long nrelas; /* The number of relocations. */
8390 unsigned int rel_type; /* REL or RELA ? */
8391 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
8392};
8393
8394struct arm_unw_aux_info
8395{
8396 Filedata * filedata; /* The file containing the unwind sections. */
8397 Elf_Internal_Sym * symtab; /* The file's symbol table. */
8398 unsigned long nsyms; /* Number of symbols. */
8399 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
8400 unsigned long nfuns; /* Number of these symbols. */
8401 char * strtab; /* The file's string table. */
8402 unsigned long strtab_size; /* Size of string table. */
8403};
8404
8405static const char *
8406arm_print_vma_and_name (Filedata * filedata,
8407 struct arm_unw_aux_info * aux,
8408 bfd_vma fn,
8409 struct absaddr addr)
8410{
8411 const char *procname;
8412 bfd_vma sym_offset;
8413
8414 if (addr.section == SHN_UNDEF)
8415 addr.offset = fn;
8416
8417 find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8418 aux->strtab_size, addr, &procname,
8419 &sym_offset);
8420
8421 print_vma (fn, PREFIX_HEX);
8422
8423 if (procname)
8424 {
8425 fputs (" <", stdout);
8426 fputs (procname, stdout);
8427
8428 if (sym_offset)
8429 printf ("+0x%lx", (unsigned long) sym_offset);
8430 fputc ('>', stdout);
8431 }
8432
8433 return procname;
8434}
8435
8436static void
8437arm_free_section (struct arm_section *arm_sec)
8438{
8439 if (arm_sec->data != NULL)
8440 free (arm_sec->data);
8441
8442 if (arm_sec->rela != NULL)
8443 free (arm_sec->rela);
8444}
8445
8446/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8447 cached section and install SEC instead.
8448 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8449 and return its valued in * WORDP, relocating if necessary.
8450 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8451 relocation's offset in ADDR.
8452 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8453 into the string table of the symbol associated with the reloc. If no
8454 reloc was applied store -1 there.
8455 5) Return TRUE upon success, FALSE otherwise. */
8456
8457static bfd_boolean
8458get_unwind_section_word (Filedata * filedata,
8459 struct arm_unw_aux_info * aux,
8460 struct arm_section * arm_sec,
8461 Elf_Internal_Shdr * sec,
8462 bfd_vma word_offset,
8463 unsigned int * wordp,
8464 struct absaddr * addr,
8465 bfd_vma * sym_name)
8466{
8467 Elf_Internal_Rela *rp;
8468 Elf_Internal_Sym *sym;
8469 const char * relname;
8470 unsigned int word;
8471 bfd_boolean wrapped;
8472
8473 if (sec == NULL || arm_sec == NULL)
8474 return FALSE;
8475
8476 addr->section = SHN_UNDEF;
8477 addr->offset = 0;
8478
8479 if (sym_name != NULL)
8480 *sym_name = (bfd_vma) -1;
8481
8482 /* If necessary, update the section cache. */
8483 if (sec != arm_sec->sec)
8484 {
8485 Elf_Internal_Shdr *relsec;
8486
8487 arm_free_section (arm_sec);
8488
8489 arm_sec->sec = sec;
8490 arm_sec->data = get_data (NULL, aux->filedata, sec->sh_offset, 1,
8491 sec->sh_size, _("unwind data"));
8492 arm_sec->rela = NULL;
8493 arm_sec->nrelas = 0;
8494
8495 for (relsec = filedata->section_headers;
8496 relsec < filedata->section_headers + filedata->file_header.e_shnum;
8497 ++relsec)
8498 {
8499 if (relsec->sh_info >= filedata->file_header.e_shnum
8500 || filedata->section_headers + relsec->sh_info != sec
8501 /* PR 15745: Check the section type as well. */
8502 || (relsec->sh_type != SHT_REL
8503 && relsec->sh_type != SHT_RELA))
8504 continue;
8505
8506 arm_sec->rel_type = relsec->sh_type;
8507 if (relsec->sh_type == SHT_REL)
8508 {
8509 if (!slurp_rel_relocs (aux->filedata, relsec->sh_offset,
8510 relsec->sh_size,
8511 & arm_sec->rela, & arm_sec->nrelas))
8512 return FALSE;
8513 }
8514 else /* relsec->sh_type == SHT_RELA */
8515 {
8516 if (!slurp_rela_relocs (aux->filedata, relsec->sh_offset,
8517 relsec->sh_size,
8518 & arm_sec->rela, & arm_sec->nrelas))
8519 return FALSE;
8520 }
8521 break;
8522 }
8523
8524 arm_sec->next_rela = arm_sec->rela;
8525 }
8526
8527 /* If there is no unwind data we can do nothing. */
8528 if (arm_sec->data == NULL)
8529 return FALSE;
8530
8531 /* If the offset is invalid then fail. */
8532 if (/* PR 21343 *//* PR 18879 */
8533 sec->sh_size < 4
8534 || word_offset > (sec->sh_size - 4)
8535 || ((bfd_signed_vma) word_offset) < 0)
8536 return FALSE;
8537
8538 /* Get the word at the required offset. */
8539 word = byte_get (arm_sec->data + word_offset, 4);
8540
8541 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8542 if (arm_sec->rela == NULL)
8543 {
8544 * wordp = word;
8545 return TRUE;
8546 }
8547
8548 /* Look through the relocs to find the one that applies to the provided offset. */
8549 wrapped = FALSE;
8550 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8551 {
8552 bfd_vma prelval, offset;
8553
8554 if (rp->r_offset > word_offset && !wrapped)
8555 {
8556 rp = arm_sec->rela;
8557 wrapped = TRUE;
8558 }
8559 if (rp->r_offset > word_offset)
8560 break;
8561
8562 if (rp->r_offset & 3)
8563 {
8564 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8565 (unsigned long) rp->r_offset);
8566 continue;
8567 }
8568
8569 if (rp->r_offset < word_offset)
8570 continue;
8571
8572 /* PR 17531: file: 027-161405-0.004 */
8573 if (aux->symtab == NULL)
8574 continue;
8575
8576 if (arm_sec->rel_type == SHT_REL)
8577 {
8578 offset = word & 0x7fffffff;
8579 if (offset & 0x40000000)
8580 offset |= ~ (bfd_vma) 0x7fffffff;
8581 }
8582 else if (arm_sec->rel_type == SHT_RELA)
8583 offset = rp->r_addend;
8584 else
8585 {
8586 error (_("Unknown section relocation type %d encountered\n"),
8587 arm_sec->rel_type);
8588 break;
8589 }
8590
8591 /* PR 17531 file: 027-1241568-0.004. */
8592 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8593 {
8594 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8595 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8596 break;
8597 }
8598
8599 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8600 offset += sym->st_value;
8601 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8602
8603 /* Check that we are processing the expected reloc type. */
8604 if (filedata->file_header.e_machine == EM_ARM)
8605 {
8606 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8607 if (relname == NULL)
8608 {
8609 warn (_("Skipping unknown ARM relocation type: %d\n"),
8610 (int) ELF32_R_TYPE (rp->r_info));
8611 continue;
8612 }
8613
8614 if (streq (relname, "R_ARM_NONE"))
8615 continue;
8616
8617 if (! streq (relname, "R_ARM_PREL31"))
8618 {
8619 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8620 continue;
8621 }
8622 }
8623 else if (filedata->file_header.e_machine == EM_TI_C6000)
8624 {
8625 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8626 if (relname == NULL)
8627 {
8628 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8629 (int) ELF32_R_TYPE (rp->r_info));
8630 continue;
8631 }
8632
8633 if (streq (relname, "R_C6000_NONE"))
8634 continue;
8635
8636 if (! streq (relname, "R_C6000_PREL31"))
8637 {
8638 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8639 continue;
8640 }
8641
8642 prelval >>= 1;
8643 }
8644 else
8645 {
8646 /* This function currently only supports ARM and TI unwinders. */
8647 warn (_("Only TI and ARM unwinders are currently supported\n"));
8648 break;
8649 }
8650
8651 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8652 addr->section = sym->st_shndx;
8653 addr->offset = offset;
8654
8655 if (sym_name)
8656 * sym_name = sym->st_name;
8657 break;
8658 }
8659
8660 *wordp = word;
8661 arm_sec->next_rela = rp;
8662
8663 return TRUE;
8664}
8665
8666static const char *tic6x_unwind_regnames[16] =
8667{
8668 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8669 "A14", "A13", "A12", "A11", "A10",
8670 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8671};
8672
8673static void
8674decode_tic6x_unwind_regmask (unsigned int mask)
8675{
8676 int i;
8677
8678 for (i = 12; mask; mask >>= 1, i--)
8679 {
8680 if (mask & 1)
8681 {
8682 fputs (tic6x_unwind_regnames[i], stdout);
8683 if (mask > 1)
8684 fputs (", ", stdout);
8685 }
8686 }
8687}
8688
8689#define ADVANCE \
8690 if (remaining == 0 && more_words) \
8691 { \
8692 data_offset += 4; \
8693 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8694 data_offset, & word, & addr, NULL)) \
8695 return FALSE; \
8696 remaining = 4; \
8697 more_words--; \
8698 } \
8699
8700#define GET_OP(OP) \
8701 ADVANCE; \
8702 if (remaining) \
8703 { \
8704 remaining--; \
8705 (OP) = word >> 24; \
8706 word <<= 8; \
8707 } \
8708 else \
8709 { \
8710 printf (_("[Truncated opcode]\n")); \
8711 return FALSE; \
8712 } \
8713 printf ("0x%02x ", OP)
8714
8715static bfd_boolean
8716decode_arm_unwind_bytecode (Filedata * filedata,
8717 struct arm_unw_aux_info * aux,
8718 unsigned int word,
8719 unsigned int remaining,
8720 unsigned int more_words,
8721 bfd_vma data_offset,
8722 Elf_Internal_Shdr * data_sec,
8723 struct arm_section * data_arm_sec)
8724{
8725 struct absaddr addr;
8726 bfd_boolean res = TRUE;
8727
8728 /* Decode the unwinding instructions. */
8729 while (1)
8730 {
8731 unsigned int op, op2;
8732
8733 ADVANCE;
8734 if (remaining == 0)
8735 break;
8736 remaining--;
8737 op = word >> 24;
8738 word <<= 8;
8739
8740 printf (" 0x%02x ", op);
8741
8742 if ((op & 0xc0) == 0x00)
8743 {
8744 int offset = ((op & 0x3f) << 2) + 4;
8745
8746 printf (" vsp = vsp + %d", offset);
8747 }
8748 else if ((op & 0xc0) == 0x40)
8749 {
8750 int offset = ((op & 0x3f) << 2) + 4;
8751
8752 printf (" vsp = vsp - %d", offset);
8753 }
8754 else if ((op & 0xf0) == 0x80)
8755 {
8756 GET_OP (op2);
8757 if (op == 0x80 && op2 == 0)
8758 printf (_("Refuse to unwind"));
8759 else
8760 {
8761 unsigned int mask = ((op & 0x0f) << 8) | op2;
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", 4 + i);
8774 }
8775 printf ("}");
8776 }
8777 }
8778 else if ((op & 0xf0) == 0x90)
8779 {
8780 if (op == 0x9d || op == 0x9f)
8781 printf (_(" [Reserved]"));
8782 else
8783 printf (" vsp = r%d", op & 0x0f);
8784 }
8785 else if ((op & 0xf0) == 0xa0)
8786 {
8787 int end = 4 + (op & 0x07);
8788 bfd_boolean first = TRUE;
8789 int i;
8790
8791 printf (" pop {");
8792 for (i = 4; i <= end; i++)
8793 {
8794 if (first)
8795 first = FALSE;
8796 else
8797 printf (", ");
8798 printf ("r%d", i);
8799 }
8800 if (op & 0x08)
8801 {
8802 if (!first)
8803 printf (", ");
8804 printf ("r14");
8805 }
8806 printf ("}");
8807 }
8808 else if (op == 0xb0)
8809 printf (_(" finish"));
8810 else if (op == 0xb1)
8811 {
8812 GET_OP (op2);
8813 if (op2 == 0 || (op2 & 0xf0) != 0)
8814 printf (_("[Spare]"));
8815 else
8816 {
8817 unsigned int mask = op2 & 0x0f;
8818 bfd_boolean first = TRUE;
8819 int i;
8820
8821 printf ("pop {");
8822 for (i = 0; i < 12; i++)
8823 if (mask & (1 << i))
8824 {
8825 if (first)
8826 first = FALSE;
8827 else
8828 printf (", ");
8829 printf ("r%d", i);
8830 }
8831 printf ("}");
8832 }
8833 }
8834 else if (op == 0xb2)
8835 {
8836 unsigned char buf[9];
8837 unsigned int i, len;
8838 unsigned long offset;
8839
8840 for (i = 0; i < sizeof (buf); i++)
8841 {
8842 GET_OP (buf[i]);
8843 if ((buf[i] & 0x80) == 0)
8844 break;
8845 }
8846 if (i == sizeof (buf))
8847 {
8848 error (_("corrupt change to vsp\n"));
8849 res = FALSE;
8850 }
8851 else
8852 {
8853 offset = read_leb128 (buf, buf + i + 1, FALSE, &len, NULL);
8854 assert (len == i + 1);
8855 offset = offset * 4 + 0x204;
8856 printf ("vsp = vsp + %ld", offset);
8857 }
8858 }
8859 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8860 {
8861 unsigned int first, last;
8862
8863 GET_OP (op2);
8864 first = op2 >> 4;
8865 last = op2 & 0x0f;
8866 if (op == 0xc8)
8867 first = first + 16;
8868 printf ("pop {D%d", first);
8869 if (last)
8870 printf ("-D%d", first + last);
8871 printf ("}");
8872 }
8873 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8874 {
8875 unsigned int count = op & 0x07;
8876
8877 printf ("pop {D8");
8878 if (count)
8879 printf ("-D%d", 8 + count);
8880 printf ("}");
8881 }
8882 else if (op >= 0xc0 && op <= 0xc5)
8883 {
8884 unsigned int count = op & 0x07;
8885
8886 printf (" pop {wR10");
8887 if (count)
8888 printf ("-wR%d", 10 + count);
8889 printf ("}");
8890 }
8891 else if (op == 0xc6)
8892 {
8893 unsigned int first, last;
8894
8895 GET_OP (op2);
8896 first = op2 >> 4;
8897 last = op2 & 0x0f;
8898 printf ("pop {wR%d", first);
8899 if (last)
8900 printf ("-wR%d", first + last);
8901 printf ("}");
8902 }
8903 else if (op == 0xc7)
8904 {
8905 GET_OP (op2);
8906 if (op2 == 0 || (op2 & 0xf0) != 0)
8907 printf (_("[Spare]"));
8908 else
8909 {
8910 unsigned int mask = op2 & 0x0f;
8911 bfd_boolean first = TRUE;
8912 int i;
8913
8914 printf ("pop {");
8915 for (i = 0; i < 4; i++)
8916 if (mask & (1 << i))
8917 {
8918 if (first)
8919 first = FALSE;
8920 else
8921 printf (", ");
8922 printf ("wCGR%d", i);
8923 }
8924 printf ("}");
8925 }
8926 }
8927 else
8928 {
8929 printf (_(" [unsupported opcode]"));
8930 res = FALSE;
8931 }
8932
8933 printf ("\n");
8934 }
8935
8936 return res;
8937}
8938
8939static bfd_boolean
8940decode_tic6x_unwind_bytecode (Filedata * filedata,
8941 struct arm_unw_aux_info * aux,
8942 unsigned int word,
8943 unsigned int remaining,
8944 unsigned int more_words,
8945 bfd_vma data_offset,
8946 Elf_Internal_Shdr * data_sec,
8947 struct arm_section * data_arm_sec)
8948{
8949 struct absaddr addr;
8950
8951 /* Decode the unwinding instructions. */
8952 while (1)
8953 {
8954 unsigned int op, op2;
8955
8956 ADVANCE;
8957 if (remaining == 0)
8958 break;
8959 remaining--;
8960 op = word >> 24;
8961 word <<= 8;
8962
8963 printf (" 0x%02x ", op);
8964
8965 if ((op & 0xc0) == 0x00)
8966 {
8967 int offset = ((op & 0x3f) << 3) + 8;
8968 printf (" sp = sp + %d", offset);
8969 }
8970 else if ((op & 0xc0) == 0x80)
8971 {
8972 GET_OP (op2);
8973 if (op == 0x80 && op2 == 0)
8974 printf (_("Refuse to unwind"));
8975 else
8976 {
8977 unsigned int mask = ((op & 0x1f) << 8) | op2;
8978 if (op & 0x20)
8979 printf ("pop compact {");
8980 else
8981 printf ("pop {");
8982
8983 decode_tic6x_unwind_regmask (mask);
8984 printf("}");
8985 }
8986 }
8987 else if ((op & 0xf0) == 0xc0)
8988 {
8989 unsigned int reg;
8990 unsigned int nregs;
8991 unsigned int i;
8992 const char *name;
8993 struct
8994 {
8995 unsigned int offset;
8996 unsigned int reg;
8997 } regpos[16];
8998
8999 /* Scan entire instruction first so that GET_OP output is not
9000 interleaved with disassembly. */
9001 nregs = 0;
9002 for (i = 0; nregs < (op & 0xf); i++)
9003 {
9004 GET_OP (op2);
9005 reg = op2 >> 4;
9006 if (reg != 0xf)
9007 {
9008 regpos[nregs].offset = i * 2;
9009 regpos[nregs].reg = reg;
9010 nregs++;
9011 }
9012
9013 reg = op2 & 0xf;
9014 if (reg != 0xf)
9015 {
9016 regpos[nregs].offset = i * 2 + 1;
9017 regpos[nregs].reg = reg;
9018 nregs++;
9019 }
9020 }
9021
9022 printf (_("pop frame {"));
9023 if (nregs == 0)
9024 {
9025 printf (_("*corrupt* - no registers specified"));
9026 }
9027 else
9028 {
9029 reg = nregs - 1;
9030 for (i = i * 2; i > 0; i--)
9031 {
9032 if (regpos[reg].offset == i - 1)
9033 {
9034 name = tic6x_unwind_regnames[regpos[reg].reg];
9035 if (reg > 0)
9036 reg--;
9037 }
9038 else
9039 name = _("[pad]");
9040
9041 fputs (name, stdout);
9042 if (i > 1)
9043 printf (", ");
9044 }
9045 }
9046
9047 printf ("}");
9048 }
9049 else if (op == 0xd0)
9050 printf (" MOV FP, SP");
9051 else if (op == 0xd1)
9052 printf (" __c6xabi_pop_rts");
9053 else if (op == 0xd2)
9054 {
9055 unsigned char buf[9];
9056 unsigned int i, len;
9057 unsigned long offset;
9058
9059 for (i = 0; i < sizeof (buf); i++)
9060 {
9061 GET_OP (buf[i]);
9062 if ((buf[i] & 0x80) == 0)
9063 break;
9064 }
9065 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9066 if (i == sizeof (buf))
9067 {
9068 warn (_("Corrupt stack pointer adjustment detected\n"));
9069 return FALSE;
9070 }
9071
9072 offset = read_leb128 (buf, buf + i + 1, FALSE, &len, NULL);
9073 assert (len == i + 1);
9074 offset = offset * 8 + 0x408;
9075 printf (_("sp = sp + %ld"), offset);
9076 }
9077 else if ((op & 0xf0) == 0xe0)
9078 {
9079 if ((op & 0x0f) == 7)
9080 printf (" RETURN");
9081 else
9082 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
9083 }
9084 else
9085 {
9086 printf (_(" [unsupported opcode]"));
9087 }
9088 putchar ('\n');
9089 }
9090
9091 return TRUE;
9092}
9093
9094static bfd_vma
9095arm_expand_prel31 (Filedata * filedata, bfd_vma word, bfd_vma where)
9096{
9097 bfd_vma offset;
9098
9099 offset = word & 0x7fffffff;
9100 if (offset & 0x40000000)
9101 offset |= ~ (bfd_vma) 0x7fffffff;
9102
9103 if (filedata->file_header.e_machine == EM_TI_C6000)
9104 offset <<= 1;
9105
9106 return offset + where;
9107}
9108
9109static bfd_boolean
9110decode_arm_unwind (Filedata * filedata,
9111 struct arm_unw_aux_info * aux,
9112 unsigned int word,
9113 unsigned int remaining,
9114 bfd_vma data_offset,
9115 Elf_Internal_Shdr * data_sec,
9116 struct arm_section * data_arm_sec)
9117{
9118 int per_index;
9119 unsigned int more_words = 0;
9120 struct absaddr addr;
9121 bfd_vma sym_name = (bfd_vma) -1;
9122 bfd_boolean res = TRUE;
9123
9124 if (remaining == 0)
9125 {
9126 /* Fetch the first word.
9127 Note - when decoding an object file the address extracted
9128 here will always be 0. So we also pass in the sym_name
9129 parameter so that we can find the symbol associated with
9130 the personality routine. */
9131 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, data_offset,
9132 & word, & addr, & sym_name))
9133 return FALSE;
9134
9135 remaining = 4;
9136 }
9137 else
9138 {
9139 addr.section = SHN_UNDEF;
9140 addr.offset = 0;
9141 }
9142
9143 if ((word & 0x80000000) == 0)
9144 {
9145 /* Expand prel31 for personality routine. */
9146 bfd_vma fn;
9147 const char *procname;
9148
9149 fn = arm_expand_prel31 (filedata, word, data_sec->sh_addr + data_offset);
9150 printf (_(" Personality routine: "));
9151 if (fn == 0
9152 && addr.section == SHN_UNDEF && addr.offset == 0
9153 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
9154 {
9155 procname = aux->strtab + sym_name;
9156 print_vma (fn, PREFIX_HEX);
9157 if (procname)
9158 {
9159 fputs (" <", stdout);
9160 fputs (procname, stdout);
9161 fputc ('>', stdout);
9162 }
9163 }
9164 else
9165 procname = arm_print_vma_and_name (filedata, aux, fn, addr);
9166 fputc ('\n', stdout);
9167
9168 /* The GCC personality routines use the standard compact
9169 encoding, starting with one byte giving the number of
9170 words. */
9171 if (procname != NULL
9172 && (const_strneq (procname, "__gcc_personality_v0")
9173 || const_strneq (procname, "__gxx_personality_v0")
9174 || const_strneq (procname, "__gcj_personality_v0")
9175 || const_strneq (procname, "__gnu_objc_personality_v0")))
9176 {
9177 remaining = 0;
9178 more_words = 1;
9179 ADVANCE;
9180 if (!remaining)
9181 {
9182 printf (_(" [Truncated data]\n"));
9183 return FALSE;
9184 }
9185 more_words = word >> 24;
9186 word <<= 8;
9187 remaining--;
9188 per_index = -1;
9189 }
9190 else
9191 return TRUE;
9192 }
9193 else
9194 {
9195 /* ARM EHABI Section 6.3:
9196
9197 An exception-handling table entry for the compact model looks like:
9198
9199 31 30-28 27-24 23-0
9200 -- ----- ----- ----
9201 1 0 index Data for personalityRoutine[index] */
9202
9203 if (filedata->file_header.e_machine == EM_ARM
9204 && (word & 0x70000000))
9205 {
9206 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
9207 res = FALSE;
9208 }
9209
9210 per_index = (word >> 24) & 0x7f;
9211 printf (_(" Compact model index: %d\n"), per_index);
9212 if (per_index == 0)
9213 {
9214 more_words = 0;
9215 word <<= 8;
9216 remaining--;
9217 }
9218 else if (per_index < 3)
9219 {
9220 more_words = (word >> 16) & 0xff;
9221 word <<= 16;
9222 remaining -= 2;
9223 }
9224 }
9225
9226 switch (filedata->file_header.e_machine)
9227 {
9228 case EM_ARM:
9229 if (per_index < 3)
9230 {
9231 if (! decode_arm_unwind_bytecode (filedata, aux, word, remaining, more_words,
9232 data_offset, data_sec, data_arm_sec))
9233 res = FALSE;
9234 }
9235 else
9236 {
9237 warn (_("Unknown ARM compact model index encountered\n"));
9238 printf (_(" [reserved]\n"));
9239 res = FALSE;
9240 }
9241 break;
9242
9243 case EM_TI_C6000:
9244 if (per_index < 3)
9245 {
9246 if (! decode_tic6x_unwind_bytecode (filedata, aux, word, remaining, more_words,
9247 data_offset, data_sec, data_arm_sec))
9248 res = FALSE;
9249 }
9250 else if (per_index < 5)
9251 {
9252 if (((word >> 17) & 0x7f) == 0x7f)
9253 printf (_(" Restore stack from frame pointer\n"));
9254 else
9255 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
9256 printf (_(" Registers restored: "));
9257 if (per_index == 4)
9258 printf (" (compact) ");
9259 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
9260 putchar ('\n');
9261 printf (_(" Return register: %s\n"),
9262 tic6x_unwind_regnames[word & 0xf]);
9263 }
9264 else
9265 printf (_(" [reserved (%d)]\n"), per_index);
9266 break;
9267
9268 default:
9269 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9270 filedata->file_header.e_machine);
9271 res = FALSE;
9272 }
9273
9274 /* Decode the descriptors. Not implemented. */
9275
9276 return res;
9277}
9278
9279static bfd_boolean
9280dump_arm_unwind (Filedata * filedata,
9281 struct arm_unw_aux_info * aux,
9282 Elf_Internal_Shdr * exidx_sec)
9283{
9284 struct arm_section exidx_arm_sec, extab_arm_sec;
9285 unsigned int i, exidx_len;
9286 unsigned long j, nfuns;
9287 bfd_boolean res = TRUE;
9288
9289 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
9290 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
9291 exidx_len = exidx_sec->sh_size / 8;
9292
9293 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
9294 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
9295 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
9296 aux->funtab[nfuns++] = aux->symtab[j];
9297 aux->nfuns = nfuns;
9298 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
9299
9300 for (i = 0; i < exidx_len; i++)
9301 {
9302 unsigned int exidx_fn, exidx_entry;
9303 struct absaddr fn_addr, entry_addr;
9304 bfd_vma fn;
9305
9306 fputc ('\n', stdout);
9307
9308 if (! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9309 8 * i, & exidx_fn, & fn_addr, NULL)
9310 || ! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9311 8 * i + 4, & exidx_entry, & entry_addr, NULL))
9312 {
9313 free (aux->funtab);
9314 arm_free_section (& exidx_arm_sec);
9315 arm_free_section (& extab_arm_sec);
9316 return FALSE;
9317 }
9318
9319 /* ARM EHABI, Section 5:
9320 An index table entry consists of 2 words.
9321 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9322 if (exidx_fn & 0x80000000)
9323 {
9324 warn (_("corrupt index table entry: %x\n"), exidx_fn);
9325 res = FALSE;
9326 }
9327
9328 fn = arm_expand_prel31 (filedata, exidx_fn, exidx_sec->sh_addr + 8 * i);
9329
9330 arm_print_vma_and_name (filedata, aux, fn, fn_addr);
9331 fputs (": ", stdout);
9332
9333 if (exidx_entry == 1)
9334 {
9335 print_vma (exidx_entry, PREFIX_HEX);
9336 fputs (" [cantunwind]\n", stdout);
9337 }
9338 else if (exidx_entry & 0x80000000)
9339 {
9340 print_vma (exidx_entry, PREFIX_HEX);
9341 fputc ('\n', stdout);
9342 decode_arm_unwind (filedata, aux, exidx_entry, 4, 0, NULL, NULL);
9343 }
9344 else
9345 {
9346 bfd_vma table, table_offset = 0;
9347 Elf_Internal_Shdr *table_sec;
9348
9349 fputs ("@", stdout);
9350 table = arm_expand_prel31 (filedata, exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
9351 print_vma (table, PREFIX_HEX);
9352 printf ("\n");
9353
9354 /* Locate the matching .ARM.extab. */
9355 if (entry_addr.section != SHN_UNDEF
9356 && entry_addr.section < filedata->file_header.e_shnum)
9357 {
9358 table_sec = filedata->section_headers + entry_addr.section;
9359 table_offset = entry_addr.offset;
9360 /* PR 18879 */
9361 if (table_offset > table_sec->sh_size
9362 || ((bfd_signed_vma) table_offset) < 0)
9363 {
9364 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9365 (unsigned long) table_offset,
9366 printable_section_name (filedata, table_sec));
9367 res = FALSE;
9368 continue;
9369 }
9370 }
9371 else
9372 {
9373 table_sec = find_section_by_address (filedata, table);
9374 if (table_sec != NULL)
9375 table_offset = table - table_sec->sh_addr;
9376 }
9377
9378 if (table_sec == NULL)
9379 {
9380 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9381 (unsigned long) table);
9382 res = FALSE;
9383 continue;
9384 }
9385
9386 if (! decode_arm_unwind (filedata, aux, 0, 0, table_offset, table_sec,
9387 &extab_arm_sec))
9388 res = FALSE;
9389 }
9390 }
9391
9392 printf ("\n");
9393
9394 free (aux->funtab);
9395 arm_free_section (&exidx_arm_sec);
9396 arm_free_section (&extab_arm_sec);
9397
9398 return res;
9399}
9400
9401/* Used for both ARM and C6X unwinding tables. */
9402
9403static bfd_boolean
9404arm_process_unwind (Filedata * filedata)
9405{
9406 struct arm_unw_aux_info aux;
9407 Elf_Internal_Shdr *unwsec = NULL;
9408 Elf_Internal_Shdr *sec;
9409 unsigned long i;
9410 unsigned int sec_type;
9411 bfd_boolean res = TRUE;
9412
9413 switch (filedata->file_header.e_machine)
9414 {
9415 case EM_ARM:
9416 sec_type = SHT_ARM_EXIDX;
9417 break;
9418
9419 case EM_TI_C6000:
9420 sec_type = SHT_C6000_UNWIND;
9421 break;
9422
9423 default:
9424 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9425 filedata->file_header.e_machine);
9426 return FALSE;
9427 }
9428
9429 if (filedata->string_table == NULL)
9430 return FALSE;
9431
9432 memset (& aux, 0, sizeof (aux));
9433 aux.filedata = filedata;
9434
9435 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9436 {
9437 if (sec->sh_type == SHT_SYMTAB)
9438 {
9439 if (aux.symtab)
9440 {
9441 error (_("Multiple symbol tables encountered\n"));
9442 free (aux.symtab);
9443 aux.symtab = NULL;
9444 free (aux.strtab);
9445 aux.strtab = NULL;
9446 }
9447 if (!get_symtab (filedata, sec, &aux.symtab, &aux.nsyms,
9448 &aux.strtab, &aux.strtab_size))
9449 return FALSE;
9450 }
9451 else if (sec->sh_type == sec_type)
9452 unwsec = sec;
9453 }
9454
9455 if (unwsec == NULL)
9456 printf (_("\nThere are no unwind sections in this file.\n"));
9457 else
9458 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9459 {
9460 if (sec->sh_type == sec_type)
9461 {
9462 unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size);
9463 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9464 "contains %lu entry:\n",
9465 "\nUnwind section '%s' at offset 0x%lx "
9466 "contains %lu entries:\n",
9467 num_unwind),
9468 printable_section_name (filedata, sec),
9469 (unsigned long) sec->sh_offset,
9470 num_unwind);
9471
9472 if (! dump_arm_unwind (filedata, &aux, sec))
9473 res = FALSE;
9474 }
9475 }
9476
9477 if (aux.symtab)
9478 free (aux.symtab);
9479 if (aux.strtab)
9480 free ((char *) aux.strtab);
9481
9482 return res;
9483}
9484
9485static bfd_boolean
9486process_unwind (Filedata * filedata)
9487{
9488 struct unwind_handler
9489 {
9490 unsigned int machtype;
9491 bfd_boolean (* handler)(Filedata *);
9492 } handlers[] =
9493 {
9494 { EM_ARM, arm_process_unwind },
9495 { EM_IA_64, ia64_process_unwind },
9496 { EM_PARISC, hppa_process_unwind },
9497 { EM_TI_C6000, arm_process_unwind },
9498 { 0, NULL }
9499 };
9500 int i;
9501
9502 if (!do_unwind)
9503 return TRUE;
9504
9505 for (i = 0; handlers[i].handler != NULL; i++)
9506 if (filedata->file_header.e_machine == handlers[i].machtype)
9507 return handlers[i].handler (filedata);
9508
9509 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9510 get_machine_name (filedata->file_header.e_machine));
9511 return TRUE;
9512}
9513
9514static void
9515dynamic_section_aarch64_val (Elf_Internal_Dyn * entry)
9516{
9517 switch (entry->d_tag)
9518 {
9519 case DT_AARCH64_BTI_PLT:
9520 case DT_AARCH64_PAC_PLT:
9521 break;
9522 default:
9523 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9524 break;
9525 }
9526 putchar ('\n');
9527}
9528
9529static void
9530dynamic_section_mips_val (Filedata * filedata, Elf_Internal_Dyn * entry)
9531{
9532 switch (entry->d_tag)
9533 {
9534 case DT_MIPS_FLAGS:
9535 if (entry->d_un.d_val == 0)
9536 printf (_("NONE"));
9537 else
9538 {
9539 static const char * opts[] =
9540 {
9541 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9542 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9543 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9544 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9545 "RLD_ORDER_SAFE"
9546 };
9547 unsigned int cnt;
9548 bfd_boolean first = TRUE;
9549
9550 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9551 if (entry->d_un.d_val & (1 << cnt))
9552 {
9553 printf ("%s%s", first ? "" : " ", opts[cnt]);
9554 first = FALSE;
9555 }
9556 }
9557 break;
9558
9559 case DT_MIPS_IVERSION:
9560 if (VALID_DYNAMIC_NAME (filedata, entry->d_un.d_val))
9561 printf (_("Interface Version: %s"),
9562 GET_DYNAMIC_NAME (filedata, entry->d_un.d_val));
9563 else
9564 {
9565 char buf[40];
9566 sprintf_vma (buf, entry->d_un.d_ptr);
9567 /* Note: coded this way so that there is a single string for translation. */
9568 printf (_("<corrupt: %s>"), buf);
9569 }
9570 break;
9571
9572 case DT_MIPS_TIME_STAMP:
9573 {
9574 char timebuf[128];
9575 struct tm * tmp;
9576 time_t atime = entry->d_un.d_val;
9577
9578 tmp = gmtime (&atime);
9579 /* PR 17531: file: 6accc532. */
9580 if (tmp == NULL)
9581 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9582 else
9583 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9584 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9585 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9586 printf (_("Time Stamp: %s"), timebuf);
9587 }
9588 break;
9589
9590 case DT_MIPS_RLD_VERSION:
9591 case DT_MIPS_LOCAL_GOTNO:
9592 case DT_MIPS_CONFLICTNO:
9593 case DT_MIPS_LIBLISTNO:
9594 case DT_MIPS_SYMTABNO:
9595 case DT_MIPS_UNREFEXTNO:
9596 case DT_MIPS_HIPAGENO:
9597 case DT_MIPS_DELTA_CLASS_NO:
9598 case DT_MIPS_DELTA_INSTANCE_NO:
9599 case DT_MIPS_DELTA_RELOC_NO:
9600 case DT_MIPS_DELTA_SYM_NO:
9601 case DT_MIPS_DELTA_CLASSSYM_NO:
9602 case DT_MIPS_COMPACT_SIZE:
9603 print_vma (entry->d_un.d_val, DEC);
9604 break;
9605
9606 case DT_MIPS_XHASH:
9607 filedata->dynamic_info_DT_MIPS_XHASH = entry->d_un.d_val;
9608 filedata->dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9609 /* Falls through. */
9610
9611 default:
9612 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9613 }
9614 putchar ('\n');
9615}
9616
9617static void
9618dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9619{
9620 switch (entry->d_tag)
9621 {
9622 case DT_HP_DLD_FLAGS:
9623 {
9624 static struct
9625 {
9626 long int bit;
9627 const char * str;
9628 }
9629 flags[] =
9630 {
9631 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9632 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9633 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9634 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9635 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9636 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9637 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9638 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9639 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9640 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9641 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9642 { DT_HP_GST, "HP_GST" },
9643 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9644 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9645 { DT_HP_NODELETE, "HP_NODELETE" },
9646 { DT_HP_GROUP, "HP_GROUP" },
9647 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9648 };
9649 bfd_boolean first = TRUE;
9650 size_t cnt;
9651 bfd_vma val = entry->d_un.d_val;
9652
9653 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9654 if (val & flags[cnt].bit)
9655 {
9656 if (! first)
9657 putchar (' ');
9658 fputs (flags[cnt].str, stdout);
9659 first = FALSE;
9660 val ^= flags[cnt].bit;
9661 }
9662
9663 if (val != 0 || first)
9664 {
9665 if (! first)
9666 putchar (' ');
9667 print_vma (val, HEX);
9668 }
9669 }
9670 break;
9671
9672 default:
9673 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9674 break;
9675 }
9676 putchar ('\n');
9677}
9678
9679#ifdef BFD64
9680
9681/* VMS vs Unix time offset and factor. */
9682
9683#define VMS_EPOCH_OFFSET 35067168000000000LL
9684#define VMS_GRANULARITY_FACTOR 10000000
9685
9686/* Display a VMS time in a human readable format. */
9687
9688static void
9689print_vms_time (bfd_int64_t vmstime)
9690{
9691 struct tm *tm;
9692 time_t unxtime;
9693
9694 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9695 tm = gmtime (&unxtime);
9696 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9697 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9698 tm->tm_hour, tm->tm_min, tm->tm_sec);
9699}
9700#endif /* BFD64 */
9701
9702static void
9703dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9704{
9705 switch (entry->d_tag)
9706 {
9707 case DT_IA_64_PLT_RESERVE:
9708 /* First 3 slots reserved. */
9709 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9710 printf (" -- ");
9711 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9712 break;
9713
9714 case DT_IA_64_VMS_LINKTIME:
9715#ifdef BFD64
9716 print_vms_time (entry->d_un.d_val);
9717#endif
9718 break;
9719
9720 case DT_IA_64_VMS_LNKFLAGS:
9721 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9722 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9723 printf (" CALL_DEBUG");
9724 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9725 printf (" NOP0BUFS");
9726 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9727 printf (" P0IMAGE");
9728 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9729 printf (" MKTHREADS");
9730 if (entry->d_un.d_val & VMS_LF_UPCALLS)
9731 printf (" UPCALLS");
9732 if (entry->d_un.d_val & VMS_LF_IMGSTA)
9733 printf (" IMGSTA");
9734 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9735 printf (" INITIALIZE");
9736 if (entry->d_un.d_val & VMS_LF_MAIN)
9737 printf (" MAIN");
9738 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9739 printf (" EXE_INIT");
9740 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9741 printf (" TBK_IN_IMG");
9742 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9743 printf (" DBG_IN_IMG");
9744 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9745 printf (" TBK_IN_DSF");
9746 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9747 printf (" DBG_IN_DSF");
9748 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9749 printf (" SIGNATURES");
9750 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9751 printf (" REL_SEG_OFF");
9752 break;
9753
9754 default:
9755 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9756 break;
9757 }
9758 putchar ('\n');
9759}
9760
9761static bfd_boolean
9762get_32bit_dynamic_section (Filedata * filedata)
9763{
9764 Elf32_External_Dyn * edyn;
9765 Elf32_External_Dyn * ext;
9766 Elf_Internal_Dyn * entry;
9767
9768 edyn = (Elf32_External_Dyn *) get_data (NULL, filedata,
9769 filedata->dynamic_addr, 1,
9770 filedata->dynamic_size,
9771 _("dynamic section"));
9772 if (!edyn)
9773 return FALSE;
9774
9775 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9776 might not have the luxury of section headers. Look for the DT_NULL
9777 terminator to determine the number of entries. */
9778 for (ext = edyn, filedata->dynamic_nent = 0;
9779 (char *) (ext + 1) <= (char *) edyn + filedata->dynamic_size;
9780 ext++)
9781 {
9782 filedata->dynamic_nent++;
9783 if (BYTE_GET (ext->d_tag) == DT_NULL)
9784 break;
9785 }
9786
9787 filedata->dynamic_section
9788 = (Elf_Internal_Dyn *) cmalloc (filedata->dynamic_nent, sizeof (* entry));
9789 if (filedata->dynamic_section == NULL)
9790 {
9791 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9792 (unsigned long) filedata->dynamic_nent);
9793 free (edyn);
9794 return FALSE;
9795 }
9796
9797 for (ext = edyn, entry = filedata->dynamic_section;
9798 entry < filedata->dynamic_section + filedata->dynamic_nent;
9799 ext++, entry++)
9800 {
9801 entry->d_tag = BYTE_GET (ext->d_tag);
9802 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9803 }
9804
9805 free (edyn);
9806
9807 return TRUE;
9808}
9809
9810static bfd_boolean
9811get_64bit_dynamic_section (Filedata * filedata)
9812{
9813 Elf64_External_Dyn * edyn;
9814 Elf64_External_Dyn * ext;
9815 Elf_Internal_Dyn * entry;
9816
9817 /* Read in the data. */
9818 edyn = (Elf64_External_Dyn *) get_data (NULL, filedata,
9819 filedata->dynamic_addr, 1,
9820 filedata->dynamic_size,
9821 _("dynamic section"));
9822 if (!edyn)
9823 return FALSE;
9824
9825 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9826 might not have the luxury of section headers. Look for the DT_NULL
9827 terminator to determine the number of entries. */
9828 for (ext = edyn, filedata->dynamic_nent = 0;
9829 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9830 (char *) (ext + 1) <= (char *) edyn + filedata->dynamic_size;
9831 ext++)
9832 {
9833 filedata->dynamic_nent++;
9834 if (BYTE_GET (ext->d_tag) == DT_NULL)
9835 break;
9836 }
9837
9838 filedata->dynamic_section
9839 = (Elf_Internal_Dyn *) cmalloc (filedata->dynamic_nent, sizeof (* entry));
9840 if (filedata->dynamic_section == NULL)
9841 {
9842 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9843 (unsigned long) filedata->dynamic_nent);
9844 free (edyn);
9845 return FALSE;
9846 }
9847
9848 /* Convert from external to internal formats. */
9849 for (ext = edyn, entry = filedata->dynamic_section;
9850 entry < filedata->dynamic_section + filedata->dynamic_nent;
9851 ext++, entry++)
9852 {
9853 entry->d_tag = BYTE_GET (ext->d_tag);
9854 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9855 }
9856
9857 free (edyn);
9858
9859 return TRUE;
9860}
9861
9862static void
9863print_dynamic_flags (bfd_vma flags)
9864{
9865 bfd_boolean first = TRUE;
9866
9867 while (flags)
9868 {
9869 bfd_vma flag;
9870
9871 flag = flags & - flags;
9872 flags &= ~ flag;
9873
9874 if (first)
9875 first = FALSE;
9876 else
9877 putc (' ', stdout);
9878
9879 switch (flag)
9880 {
9881 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
9882 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
9883 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
9884 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
9885 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
9886 default: fputs (_("unknown"), stdout); break;
9887 }
9888 }
9889 puts ("");
9890}
9891
9892static bfd_vma *
9893get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_size)
9894{
9895 unsigned char * e_data;
9896 bfd_vma * i_data;
9897
9898 /* If the size_t type is smaller than the bfd_size_type, eg because
9899 you are building a 32-bit tool on a 64-bit host, then make sure
9900 that when (number) is cast to (size_t) no information is lost. */
9901 if (sizeof (size_t) < sizeof (bfd_size_type)
9902 && (bfd_size_type) ((size_t) number) != number)
9903 {
9904 error (_("Size truncation prevents reading %s elements of size %u\n"),
9905 bfd_vmatoa ("u", number), ent_size);
9906 return NULL;
9907 }
9908
9909 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
9910 attempting to allocate memory when the read is bound to fail. */
9911 if (ent_size * number > filedata->file_size)
9912 {
9913 error (_("Invalid number of dynamic entries: %s\n"),
9914 bfd_vmatoa ("u", number));
9915 return NULL;
9916 }
9917
9918 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
9919 if (e_data == NULL)
9920 {
9921 error (_("Out of memory reading %s dynamic entries\n"),
9922 bfd_vmatoa ("u", number));
9923 return NULL;
9924 }
9925
9926 if (fread (e_data, ent_size, (size_t) number, filedata->handle) != number)
9927 {
9928 error (_("Unable to read in %s bytes of dynamic data\n"),
9929 bfd_vmatoa ("u", number * ent_size));
9930 free (e_data);
9931 return NULL;
9932 }
9933
9934 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
9935 if (i_data == NULL)
9936 {
9937 error (_("Out of memory allocating space for %s dynamic entries\n"),
9938 bfd_vmatoa ("u", number));
9939 free (e_data);
9940 return NULL;
9941 }
9942
9943 while (number--)
9944 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
9945
9946 free (e_data);
9947
9948 return i_data;
9949}
9950
9951static unsigned long
9952get_num_dynamic_syms (Filedata * filedata)
9953{
9954 unsigned long num_of_syms = 0;
9955
9956 if (!do_histogram && (!do_using_dynamic || do_dyn_syms))
9957 return num_of_syms;
9958
9959 if (filedata->dynamic_info[DT_HASH])
9960 {
9961 unsigned char nb[8];
9962 unsigned char nc[8];
9963 unsigned int hash_ent_size = 4;
9964
9965 if ((filedata->file_header.e_machine == EM_ALPHA
9966 || filedata->file_header.e_machine == EM_S390
9967 || filedata->file_header.e_machine == EM_S390_OLD)
9968 && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
9969 hash_ent_size = 8;
9970
9971 if (fseek (filedata->handle,
9972 (filedata->archive_file_offset
9973 + offset_from_vma (filedata, filedata->dynamic_info[DT_HASH],
9974 sizeof nb + sizeof nc)),
9975 SEEK_SET))
9976 {
9977 error (_("Unable to seek to start of dynamic information\n"));
9978 goto no_hash;
9979 }
9980
9981 if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
9982 {
9983 error (_("Failed to read in number of buckets\n"));
9984 goto no_hash;
9985 }
9986
9987 if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
9988 {
9989 error (_("Failed to read in number of chains\n"));
9990 goto no_hash;
9991 }
9992
9993 filedata->nbuckets = byte_get (nb, hash_ent_size);
9994 filedata->nchains = byte_get (nc, hash_ent_size);
9995
9996 filedata->buckets = get_dynamic_data (filedata, filedata->nbuckets,
9997 hash_ent_size);
9998 filedata->chains = get_dynamic_data (filedata, filedata->nchains,
9999 hash_ent_size);
10000
10001 if (filedata->buckets != NULL && filedata->chains != NULL)
10002 num_of_syms = filedata->nchains;
10003
10004 no_hash:
10005 if (num_of_syms == 0)
10006 {
10007 if (filedata->buckets)
10008 {
10009 free (filedata->buckets);
10010 filedata->buckets = NULL;
10011 }
10012 if (filedata->chains)
10013 {
10014 free (filedata->chains);
10015 filedata->chains = NULL;
10016 }
10017 filedata->nbuckets = 0;
10018 }
10019 }
10020
10021 if (filedata->dynamic_info_DT_GNU_HASH)
10022 {
10023 unsigned char nb[16];
10024 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10025 bfd_vma buckets_vma;
10026 unsigned long hn;
10027 bfd_boolean gnu_hash_error = FALSE;
10028
10029 if (fseek (filedata->handle,
10030 (filedata->archive_file_offset
10031 + offset_from_vma (filedata,
10032 filedata->dynamic_info_DT_GNU_HASH,
10033 sizeof nb)),
10034 SEEK_SET))
10035 {
10036 error (_("Unable to seek to start of dynamic information\n"));
10037 gnu_hash_error = TRUE;
10038 goto no_gnu_hash;
10039 }
10040
10041 if (fread (nb, 16, 1, filedata->handle) != 1)
10042 {
10043 error (_("Failed to read in number of buckets\n"));
10044 gnu_hash_error = TRUE;
10045 goto no_gnu_hash;
10046 }
10047
10048 filedata->ngnubuckets = byte_get (nb, 4);
10049 filedata->gnusymidx = byte_get (nb + 4, 4);
10050 bitmaskwords = byte_get (nb + 8, 4);
10051 buckets_vma = filedata->dynamic_info_DT_GNU_HASH + 16;
10052 if (is_32bit_elf)
10053 buckets_vma += bitmaskwords * 4;
10054 else
10055 buckets_vma += bitmaskwords * 8;
10056
10057 if (fseek (filedata->handle,
10058 (filedata->archive_file_offset
10059 + offset_from_vma (filedata, buckets_vma, 4)),
10060 SEEK_SET))
10061 {
10062 error (_("Unable to seek to start of dynamic information\n"));
10063 gnu_hash_error = TRUE;
10064 goto no_gnu_hash;
10065 }
10066
10067 filedata->gnubuckets
10068 = get_dynamic_data (filedata, filedata->ngnubuckets, 4);
10069
10070 if (filedata->gnubuckets == NULL)
10071 {
10072 gnu_hash_error = TRUE;
10073 goto no_gnu_hash;
10074 }
10075
10076 for (i = 0; i < filedata->ngnubuckets; i++)
10077 if (filedata->gnubuckets[i] != 0)
10078 {
10079 if (filedata->gnubuckets[i] < filedata->gnusymidx)
10080 {
10081 gnu_hash_error = TRUE;
10082 goto no_gnu_hash;
10083 }
10084
10085 if (maxchain == 0xffffffff || filedata->gnubuckets[i] > maxchain)
10086 maxchain = filedata->gnubuckets[i];
10087 }
10088
10089 if (maxchain == 0xffffffff)
10090 {
10091 gnu_hash_error = TRUE;
10092 goto no_gnu_hash;
10093 }
10094
10095 maxchain -= filedata->gnusymidx;
10096
10097 if (fseek (filedata->handle,
10098 (filedata->archive_file_offset
10099 + offset_from_vma (filedata,
10100 buckets_vma + 4 * (filedata->ngnubuckets
10101 + maxchain),
10102 4)),
10103 SEEK_SET))
10104 {
10105 error (_("Unable to seek to start of dynamic information\n"));
10106 gnu_hash_error = TRUE;
10107 goto no_gnu_hash;
10108 }
10109
10110 do
10111 {
10112 if (fread (nb, 4, 1, filedata->handle) != 1)
10113 {
10114 error (_("Failed to determine last chain length\n"));
10115 gnu_hash_error = TRUE;
10116 goto no_gnu_hash;
10117 }
10118
10119 if (maxchain + 1 == 0)
10120 {
10121 gnu_hash_error = TRUE;
10122 goto no_gnu_hash;
10123 }
10124
10125 ++maxchain;
10126 }
10127 while ((byte_get (nb, 4) & 1) == 0);
10128
10129 if (fseek (filedata->handle,
10130 (filedata->archive_file_offset
10131 + offset_from_vma (filedata, (buckets_vma
10132 + 4 * filedata->ngnubuckets),
10133 4)),
10134 SEEK_SET))
10135 {
10136 error (_("Unable to seek to start of dynamic information\n"));
10137 gnu_hash_error = TRUE;
10138 goto no_gnu_hash;
10139 }
10140
10141 filedata->gnuchains = get_dynamic_data (filedata, maxchain, 4);
10142 filedata->ngnuchains = maxchain;
10143
10144 if (filedata->gnuchains == NULL)
10145 {
10146 gnu_hash_error = TRUE;
10147 goto no_gnu_hash;
10148 }
10149
10150 if (filedata->dynamic_info_DT_MIPS_XHASH)
10151 {
10152 if (fseek (filedata->handle,
10153 (filedata->archive_file_offset
10154 + offset_from_vma (filedata, (buckets_vma
10155 + 4 * (filedata->ngnubuckets
10156 + maxchain)), 4)),
10157 SEEK_SET))
10158 {
10159 error (_("Unable to seek to start of dynamic information\n"));
10160 gnu_hash_error = TRUE;
10161 goto no_gnu_hash;
10162 }
10163
10164 filedata->mipsxlat = get_dynamic_data (filedata, maxchain, 4);
10165 }
10166
10167 for (hn = 0; hn < filedata->ngnubuckets; ++hn)
10168 if (filedata->gnubuckets[hn] != 0)
10169 {
10170 bfd_vma si = filedata->gnubuckets[hn];
10171 bfd_vma off = si - filedata->gnusymidx;
10172
10173 do
10174 {
10175 if (filedata->dynamic_info_DT_MIPS_XHASH)
10176 {
10177 if (filedata->mipsxlat[off] >= num_of_syms)
10178 num_of_syms = filedata->mipsxlat[off] + 1;
10179 }
10180 else
10181 {
10182 if (si >= num_of_syms)
10183 num_of_syms = si + 1;
10184 }
10185 si++;
10186 }
10187 while (off < filedata->ngnuchains
10188 && (filedata->gnuchains[off++] & 1) == 0);
10189 }
10190
10191 no_gnu_hash:
10192 if (gnu_hash_error)
10193 {
10194 if (filedata->mipsxlat)
10195 {
10196 free (filedata->mipsxlat);
10197 filedata->mipsxlat = NULL;
10198 }
10199 if (filedata->gnuchains)
10200 {
10201 free (filedata->gnuchains);
10202 filedata->gnuchains = NULL;
10203 }
10204 if (filedata->gnubuckets)
10205 {
10206 free (filedata->gnubuckets);
10207 filedata->gnubuckets = NULL;
10208 }
10209 filedata->ngnubuckets = 0;
10210 filedata->ngnuchains = 0;
10211 }
10212 }
10213
10214 return num_of_syms;
10215}
10216
10217/* Parse and display the contents of the dynamic section. */
10218
10219static bfd_boolean
10220process_dynamic_section (Filedata * filedata)
10221{
10222 Elf_Internal_Dyn * entry;
10223
10224 if (filedata->dynamic_size == 0)
10225 {
10226 if (do_dynamic)
10227 printf (_("\nThere is no dynamic section in this file.\n"));
10228
10229 return TRUE;
10230 }
10231
10232 if (is_32bit_elf)
10233 {
10234 if (! get_32bit_dynamic_section (filedata))
10235 return FALSE;
10236 }
10237 else
10238 {
10239 if (! get_64bit_dynamic_section (filedata))
10240 return FALSE;
10241 }
10242
10243 /* Find the appropriate symbol table. */
10244 if (filedata->dynamic_symbols == NULL || do_histogram)
10245 {
10246 for (entry = filedata->dynamic_section;
10247 entry < filedata->dynamic_section + filedata->dynamic_nent;
10248 ++entry)
10249 if (entry->d_tag == DT_SYMTAB)
10250 filedata->dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
10251 else if (entry->d_tag == DT_SYMENT)
10252 filedata->dynamic_info[DT_SYMENT] = entry->d_un.d_val;
10253 else if (entry->d_tag == DT_HASH)
10254 filedata->dynamic_info[DT_HASH] = entry->d_un.d_val;
10255 else if (entry->d_tag == DT_GNU_HASH)
10256 filedata->dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10257 else if ((filedata->file_header.e_machine == EM_MIPS
10258 || filedata->file_header.e_machine == EM_MIPS_RS3_LE)
10259 && entry->d_tag == DT_MIPS_XHASH)
10260 {
10261 filedata->dynamic_info_DT_MIPS_XHASH = entry->d_un.d_val;
10262 filedata->dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10263 }
10264
10265 if (filedata->dynamic_info[DT_SYMTAB]
10266 && filedata->dynamic_info[DT_SYMENT])
10267 {
10268 Elf_Internal_Phdr *seg;
10269 bfd_vma vma = filedata->dynamic_info[DT_SYMTAB];
10270
10271 if (! get_program_headers (filedata))
10272 {
10273 error (_("Cannot interpret virtual addresses without program headers.\n"));
10274 return FALSE;
10275 }
10276
10277 for (seg = filedata->program_headers;
10278 seg < filedata->program_headers + filedata->file_header.e_phnum;
10279 ++seg)
10280 {
10281 unsigned long num_of_syms;
10282
10283 if (seg->p_type != PT_LOAD)
10284 continue;
10285
10286 if ((seg->p_offset + seg->p_filesz)
10287 > filedata->file_size)
10288 {
10289 /* See PR 21379 for a reproducer. */
10290 error (_("Invalid PT_LOAD entry\n"));
10291 return FALSE;
10292 }
10293
10294 if (vma >= (seg->p_vaddr & -seg->p_align)
10295 && vma <= seg->p_vaddr + seg->p_filesz
10296 && (num_of_syms = get_num_dynamic_syms (filedata)) != 0
10297 && filedata->dynamic_symbols == NULL)
10298 {
10299 /* Since we do not know how big the symbol table is,
10300 we default to reading in up to the end of PT_LOAD
10301 segment and processing that. This is overkill, I
10302 know, but it should work. */
10303 Elf_Internal_Shdr section;
10304 section.sh_offset = (vma - seg->p_vaddr
10305 + seg->p_offset);
10306 section.sh_size = (num_of_syms
10307 * filedata->dynamic_info[DT_SYMENT]);
10308 section.sh_entsize = filedata->dynamic_info[DT_SYMENT];
10309 section.sh_name = filedata->string_table_length;
10310 filedata->dynamic_symbols
10311 = GET_ELF_SYMBOLS (filedata, &section,
10312 &filedata->num_dynamic_syms);
10313 if (filedata->dynamic_symbols == NULL
10314 || filedata->num_dynamic_syms != num_of_syms)
10315 {
10316 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
10317 return FALSE;
10318 }
10319 }
10320 }
10321 }
10322 }
10323
10324 /* Similarly find a string table. */
10325 if (filedata->dynamic_strings == NULL)
10326 for (entry = filedata->dynamic_section;
10327 entry < filedata->dynamic_section + filedata->dynamic_nent;
10328 ++entry)
10329 {
10330 if (entry->d_tag == DT_STRTAB)
10331 filedata->dynamic_info[DT_STRTAB] = entry->d_un.d_val;
10332
10333 if (entry->d_tag == DT_STRSZ)
10334 filedata->dynamic_info[DT_STRSZ] = entry->d_un.d_val;
10335
10336 if (filedata->dynamic_info[DT_STRTAB]
10337 && filedata->dynamic_info[DT_STRSZ])
10338 {
10339 unsigned long offset;
10340 bfd_size_type str_tab_len = filedata->dynamic_info[DT_STRSZ];
10341
10342 offset = offset_from_vma (filedata,
10343 filedata->dynamic_info[DT_STRTAB],
10344 str_tab_len);
10345 filedata->dynamic_strings
10346 = (char *) get_data (NULL, filedata, offset, 1, str_tab_len,
10347 _("dynamic string table"));
10348 if (filedata->dynamic_strings == NULL)
10349 {
10350 error (_("Corrupt DT_STRTAB dynamic entry\n"));
10351 break;
10352 }
10353
10354 filedata->dynamic_strings_length = str_tab_len;
10355 break;
10356 }
10357 }
10358
10359 /* And find the syminfo section if available. */
10360 if (filedata->dynamic_syminfo == NULL)
10361 {
10362 unsigned long syminsz = 0;
10363
10364 for (entry = filedata->dynamic_section;
10365 entry < filedata->dynamic_section + filedata->dynamic_nent;
10366 ++entry)
10367 {
10368 if (entry->d_tag == DT_SYMINENT)
10369 {
10370 /* Note: these braces are necessary to avoid a syntax
10371 error from the SunOS4 C compiler. */
10372 /* PR binutils/17531: A corrupt file can trigger this test.
10373 So do not use an assert, instead generate an error message. */
10374 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
10375 error (_("Bad value (%d) for SYMINENT entry\n"),
10376 (int) entry->d_un.d_val);
10377 }
10378 else if (entry->d_tag == DT_SYMINSZ)
10379 syminsz = entry->d_un.d_val;
10380 else if (entry->d_tag == DT_SYMINFO)
10381 filedata->dynamic_syminfo_offset
10382 = offset_from_vma (filedata, entry->d_un.d_val, syminsz);
10383 }
10384
10385 if (filedata->dynamic_syminfo_offset != 0 && syminsz != 0)
10386 {
10387 Elf_External_Syminfo * extsyminfo;
10388 Elf_External_Syminfo * extsym;
10389 Elf_Internal_Syminfo * syminfo;
10390
10391 /* There is a syminfo section. Read the data. */
10392 extsyminfo = (Elf_External_Syminfo *)
10393 get_data (NULL, filedata, filedata->dynamic_syminfo_offset,
10394 1, syminsz, _("symbol information"));
10395 if (!extsyminfo)
10396 return FALSE;
10397
10398 if (filedata->dynamic_syminfo != NULL)
10399 {
10400 error (_("Multiple dynamic symbol information sections found\n"));
10401 free (filedata->dynamic_syminfo);
10402 }
10403 filedata->dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
10404 if (filedata->dynamic_syminfo == NULL)
10405 {
10406 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
10407 (unsigned long) syminsz);
10408 return FALSE;
10409 }
10410
10411 filedata->dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
10412 for (syminfo = filedata->dynamic_syminfo, extsym = extsyminfo;
10413 syminfo < filedata->dynamic_syminfo + filedata->dynamic_syminfo_nent;
10414 ++syminfo, ++extsym)
10415 {
10416 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
10417 syminfo->si_flags = BYTE_GET (extsym->si_flags);
10418 }
10419
10420 free (extsyminfo);
10421 }
10422 }
10423
10424 if (do_dynamic && filedata->dynamic_addr)
10425 printf (ngettext ("\nDynamic section at offset 0x%lx "
10426 "contains %lu entry:\n",
10427 "\nDynamic section at offset 0x%lx "
10428 "contains %lu entries:\n",
10429 filedata->dynamic_nent),
10430 filedata->dynamic_addr, (unsigned long) filedata->dynamic_nent);
10431 if (do_dynamic)
10432 printf (_(" Tag Type Name/Value\n"));
10433
10434 for (entry = filedata->dynamic_section;
10435 entry < filedata->dynamic_section + filedata->dynamic_nent;
10436 entry++)
10437 {
10438 if (do_dynamic)
10439 {
10440 const char * dtype;
10441
10442 putchar (' ');
10443 print_vma (entry->d_tag, FULL_HEX);
10444 dtype = get_dynamic_type (filedata, entry->d_tag);
10445 printf (" (%s)%*s", dtype,
10446 ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
10447 }
10448
10449 switch (entry->d_tag)
10450 {
10451 case DT_FLAGS:
10452 if (do_dynamic)
10453 print_dynamic_flags (entry->d_un.d_val);
10454 break;
10455
10456 case DT_AUXILIARY:
10457 case DT_FILTER:
10458 case DT_CONFIG:
10459 case DT_DEPAUDIT:
10460 case DT_AUDIT:
10461 if (do_dynamic)
10462 {
10463 switch (entry->d_tag)
10464 {
10465 case DT_AUXILIARY:
10466 printf (_("Auxiliary library"));
10467 break;
10468
10469 case DT_FILTER:
10470 printf (_("Filter library"));
10471 break;
10472
10473 case DT_CONFIG:
10474 printf (_("Configuration file"));
10475 break;
10476
10477 case DT_DEPAUDIT:
10478 printf (_("Dependency audit library"));
10479 break;
10480
10481 case DT_AUDIT:
10482 printf (_("Audit library"));
10483 break;
10484 }
10485
10486 if (VALID_DYNAMIC_NAME (filedata, entry->d_un.d_val))
10487 printf (": [%s]\n",
10488 GET_DYNAMIC_NAME (filedata, entry->d_un.d_val));
10489 else
10490 {
10491 printf (": ");
10492 print_vma (entry->d_un.d_val, PREFIX_HEX);
10493 putchar ('\n');
10494 }
10495 }
10496 break;
10497
10498 case DT_FEATURE:
10499 if (do_dynamic)
10500 {
10501 printf (_("Flags:"));
10502
10503 if (entry->d_un.d_val == 0)
10504 printf (_(" None\n"));
10505 else
10506 {
10507 unsigned long int val = entry->d_un.d_val;
10508
10509 if (val & DTF_1_PARINIT)
10510 {
10511 printf (" PARINIT");
10512 val ^= DTF_1_PARINIT;
10513 }
10514 if (val & DTF_1_CONFEXP)
10515 {
10516 printf (" CONFEXP");
10517 val ^= DTF_1_CONFEXP;
10518 }
10519 if (val != 0)
10520 printf (" %lx", val);
10521 puts ("");
10522 }
10523 }
10524 break;
10525
10526 case DT_POSFLAG_1:
10527 if (do_dynamic)
10528 {
10529 printf (_("Flags:"));
10530
10531 if (entry->d_un.d_val == 0)
10532 printf (_(" None\n"));
10533 else
10534 {
10535 unsigned long int val = entry->d_un.d_val;
10536
10537 if (val & DF_P1_LAZYLOAD)
10538 {
10539 printf (" LAZYLOAD");
10540 val ^= DF_P1_LAZYLOAD;
10541 }
10542 if (val & DF_P1_GROUPPERM)
10543 {
10544 printf (" GROUPPERM");
10545 val ^= DF_P1_GROUPPERM;
10546 }
10547 if (val != 0)
10548 printf (" %lx", val);
10549 puts ("");
10550 }
10551 }
10552 break;
10553
10554 case DT_FLAGS_1:
10555 if (do_dynamic)
10556 {
10557 printf (_("Flags:"));
10558 if (entry->d_un.d_val == 0)
10559 printf (_(" None\n"));
10560 else
10561 {
10562 unsigned long int val = entry->d_un.d_val;
10563
10564 if (val & DF_1_NOW)
10565 {
10566 printf (" NOW");
10567 val ^= DF_1_NOW;
10568 }
10569 if (val & DF_1_GLOBAL)
10570 {
10571 printf (" GLOBAL");
10572 val ^= DF_1_GLOBAL;
10573 }
10574 if (val & DF_1_GROUP)
10575 {
10576 printf (" GROUP");
10577 val ^= DF_1_GROUP;
10578 }
10579 if (val & DF_1_NODELETE)
10580 {
10581 printf (" NODELETE");
10582 val ^= DF_1_NODELETE;
10583 }
10584 if (val & DF_1_LOADFLTR)
10585 {
10586 printf (" LOADFLTR");
10587 val ^= DF_1_LOADFLTR;
10588 }
10589 if (val & DF_1_INITFIRST)
10590 {
10591 printf (" INITFIRST");
10592 val ^= DF_1_INITFIRST;
10593 }
10594 if (val & DF_1_NOOPEN)
10595 {
10596 printf (" NOOPEN");
10597 val ^= DF_1_NOOPEN;
10598 }
10599 if (val & DF_1_ORIGIN)
10600 {
10601 printf (" ORIGIN");
10602 val ^= DF_1_ORIGIN;
10603 }
10604 if (val & DF_1_DIRECT)
10605 {
10606 printf (" DIRECT");
10607 val ^= DF_1_DIRECT;
10608 }
10609 if (val & DF_1_TRANS)
10610 {
10611 printf (" TRANS");
10612 val ^= DF_1_TRANS;
10613 }
10614 if (val & DF_1_INTERPOSE)
10615 {
10616 printf (" INTERPOSE");
10617 val ^= DF_1_INTERPOSE;
10618 }
10619 if (val & DF_1_NODEFLIB)
10620 {
10621 printf (" NODEFLIB");
10622 val ^= DF_1_NODEFLIB;
10623 }
10624 if (val & DF_1_NODUMP)
10625 {
10626 printf (" NODUMP");
10627 val ^= DF_1_NODUMP;
10628 }
10629 if (val & DF_1_CONFALT)
10630 {
10631 printf (" CONFALT");
10632 val ^= DF_1_CONFALT;
10633 }
10634 if (val & DF_1_ENDFILTEE)
10635 {
10636 printf (" ENDFILTEE");
10637 val ^= DF_1_ENDFILTEE;
10638 }
10639 if (val & DF_1_DISPRELDNE)
10640 {
10641 printf (" DISPRELDNE");
10642 val ^= DF_1_DISPRELDNE;
10643 }
10644 if (val & DF_1_DISPRELPND)
10645 {
10646 printf (" DISPRELPND");
10647 val ^= DF_1_DISPRELPND;
10648 }
10649 if (val & DF_1_NODIRECT)
10650 {
10651 printf (" NODIRECT");
10652 val ^= DF_1_NODIRECT;
10653 }
10654 if (val & DF_1_IGNMULDEF)
10655 {
10656 printf (" IGNMULDEF");
10657 val ^= DF_1_IGNMULDEF;
10658 }
10659 if (val & DF_1_NOKSYMS)
10660 {
10661 printf (" NOKSYMS");
10662 val ^= DF_1_NOKSYMS;
10663 }
10664 if (val & DF_1_NOHDR)
10665 {
10666 printf (" NOHDR");
10667 val ^= DF_1_NOHDR;
10668 }
10669 if (val & DF_1_EDITED)
10670 {
10671 printf (" EDITED");
10672 val ^= DF_1_EDITED;
10673 }
10674 if (val & DF_1_NORELOC)
10675 {
10676 printf (" NORELOC");
10677 val ^= DF_1_NORELOC;
10678 }
10679 if (val & DF_1_SYMINTPOSE)
10680 {
10681 printf (" SYMINTPOSE");
10682 val ^= DF_1_SYMINTPOSE;
10683 }
10684 if (val & DF_1_GLOBAUDIT)
10685 {
10686 printf (" GLOBAUDIT");
10687 val ^= DF_1_GLOBAUDIT;
10688 }
10689 if (val & DF_1_SINGLETON)
10690 {
10691 printf (" SINGLETON");
10692 val ^= DF_1_SINGLETON;
10693 }
10694 if (val & DF_1_STUB)
10695 {
10696 printf (" STUB");
10697 val ^= DF_1_STUB;
10698 }
10699 if (val & DF_1_PIE)
10700 {
10701 printf (" PIE");
10702 val ^= DF_1_PIE;
10703 }
10704 if (val & DF_1_KMOD)
10705 {
10706 printf (" KMOD");
10707 val ^= DF_1_KMOD;
10708 }
10709 if (val & DF_1_WEAKFILTER)
10710 {
10711 printf (" WEAKFILTER");
10712 val ^= DF_1_WEAKFILTER;
10713 }
10714 if (val & DF_1_NOCOMMON)
10715 {
10716 printf (" NOCOMMON");
10717 val ^= DF_1_NOCOMMON;
10718 }
10719 if (val != 0)
10720 printf (" %lx", val);
10721 puts ("");
10722 }
10723 }
10724 break;
10725
10726 case DT_PLTREL:
10727 filedata->dynamic_info[entry->d_tag] = entry->d_un.d_val;
10728 if (do_dynamic)
10729 puts (get_dynamic_type (filedata, entry->d_un.d_val));
10730 break;
10731
10732 case DT_NULL :
10733 case DT_NEEDED :
10734 case DT_PLTGOT :
10735 case DT_HASH :
10736 case DT_STRTAB :
10737 case DT_SYMTAB :
10738 case DT_RELA :
10739 case DT_INIT :
10740 case DT_FINI :
10741 case DT_SONAME :
10742 case DT_RPATH :
10743 case DT_SYMBOLIC:
10744 case DT_REL :
10745 case DT_DEBUG :
10746 case DT_TEXTREL :
10747 case DT_JMPREL :
10748 case DT_RUNPATH :
10749 filedata->dynamic_info[entry->d_tag] = entry->d_un.d_val;
10750
10751 if (do_dynamic)
10752 {
10753 char * name;
10754
10755 if (VALID_DYNAMIC_NAME (filedata, entry->d_un.d_val))
10756 name = GET_DYNAMIC_NAME (filedata, entry->d_un.d_val);
10757 else
10758 name = NULL;
10759
10760 if (name)
10761 {
10762 switch (entry->d_tag)
10763 {
10764 case DT_NEEDED:
10765 printf (_("Shared library: [%s]"), name);
10766
10767 if (streq (name, filedata->program_interpreter))
10768 printf (_(" program interpreter"));
10769 break;
10770
10771 case DT_SONAME:
10772 printf (_("Library soname: [%s]"), name);
10773 break;
10774
10775 case DT_RPATH:
10776 printf (_("Library rpath: [%s]"), name);
10777 break;
10778
10779 case DT_RUNPATH:
10780 printf (_("Library runpath: [%s]"), name);
10781 break;
10782
10783 default:
10784 print_vma (entry->d_un.d_val, PREFIX_HEX);
10785 break;
10786 }
10787 }
10788 else
10789 print_vma (entry->d_un.d_val, PREFIX_HEX);
10790
10791 putchar ('\n');
10792 }
10793 break;
10794
10795 case DT_PLTRELSZ:
10796 case DT_RELASZ :
10797 case DT_STRSZ :
10798 case DT_RELSZ :
10799 case DT_RELAENT :
10800 case DT_SYMENT :
10801 case DT_RELENT :
10802 filedata->dynamic_info[entry->d_tag] = entry->d_un.d_val;
10803 /* Fall through. */
10804 case DT_PLTPADSZ:
10805 case DT_MOVEENT :
10806 case DT_MOVESZ :
10807 case DT_INIT_ARRAYSZ:
10808 case DT_FINI_ARRAYSZ:
10809 case DT_GNU_CONFLICTSZ:
10810 case DT_GNU_LIBLISTSZ:
10811 if (do_dynamic)
10812 {
10813 print_vma (entry->d_un.d_val, UNSIGNED);
10814 printf (_(" (bytes)\n"));
10815 }
10816 break;
10817
10818 case DT_VERDEFNUM:
10819 case DT_VERNEEDNUM:
10820 case DT_RELACOUNT:
10821 case DT_RELCOUNT:
10822 if (do_dynamic)
10823 {
10824 print_vma (entry->d_un.d_val, UNSIGNED);
10825 putchar ('\n');
10826 }
10827 break;
10828
10829 case DT_SYMINSZ:
10830 case DT_SYMINENT:
10831 case DT_SYMINFO:
10832 case DT_USED:
10833 case DT_INIT_ARRAY:
10834 case DT_FINI_ARRAY:
10835 if (do_dynamic)
10836 {
10837 if (entry->d_tag == DT_USED
10838 && VALID_DYNAMIC_NAME (filedata, entry->d_un.d_val))
10839 {
10840 char * name = GET_DYNAMIC_NAME (filedata, entry->d_un.d_val);
10841
10842 if (*name)
10843 {
10844 printf (_("Not needed object: [%s]\n"), name);
10845 break;
10846 }
10847 }
10848
10849 print_vma (entry->d_un.d_val, PREFIX_HEX);
10850 putchar ('\n');
10851 }
10852 break;
10853
10854 case DT_BIND_NOW:
10855 /* The value of this entry is ignored. */
10856 if (do_dynamic)
10857 putchar ('\n');
10858 break;
10859
10860 case DT_GNU_PRELINKED:
10861 if (do_dynamic)
10862 {
10863 struct tm * tmp;
10864 time_t atime = entry->d_un.d_val;
10865
10866 tmp = gmtime (&atime);
10867 /* PR 17533 file: 041-1244816-0.004. */
10868 if (tmp == NULL)
10869 printf (_("<corrupt time val: %lx"),
10870 (unsigned long) atime);
10871 else
10872 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10873 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10874 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10875
10876 }
10877 break;
10878
10879 case DT_GNU_HASH:
10880 filedata->dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10881 if (do_dynamic)
10882 {
10883 print_vma (entry->d_un.d_val, PREFIX_HEX);
10884 putchar ('\n');
10885 }
10886 break;
10887
10888 default:
10889 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10890 filedata->version_info[DT_VERSIONTAGIDX (entry->d_tag)]
10891 = entry->d_un.d_val;
10892
10893 if (do_dynamic)
10894 {
10895 switch (filedata->file_header.e_machine)
10896 {
10897 case EM_AARCH64:
10898 dynamic_section_aarch64_val (entry);
10899 break;
10900 case EM_MIPS:
10901 case EM_MIPS_RS3_LE:
10902 dynamic_section_mips_val (filedata, entry);
10903 break;
10904 case EM_PARISC:
10905 dynamic_section_parisc_val (entry);
10906 break;
10907 case EM_IA_64:
10908 dynamic_section_ia64_val (entry);
10909 break;
10910 default:
10911 print_vma (entry->d_un.d_val, PREFIX_HEX);
10912 putchar ('\n');
10913 }
10914 }
10915 break;
10916 }
10917 }
10918
10919 return TRUE;
10920}
10921
10922static char *
10923get_ver_flags (unsigned int flags)
10924{
10925 static char buff[128];
10926
10927 buff[0] = 0;
10928
10929 if (flags == 0)
10930 return _("none");
10931
10932 if (flags & VER_FLG_BASE)
10933 strcat (buff, "BASE");
10934
10935 if (flags & VER_FLG_WEAK)
10936 {
10937 if (flags & VER_FLG_BASE)
10938 strcat (buff, " | ");
10939
10940 strcat (buff, "WEAK");
10941 }
10942
10943 if (flags & VER_FLG_INFO)
10944 {
10945 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10946 strcat (buff, " | ");
10947
10948 strcat (buff, "INFO");
10949 }
10950
10951 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10952 {
10953 if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10954 strcat (buff, " | ");
10955
10956 strcat (buff, _("<unknown>"));
10957 }
10958
10959 return buff;
10960}
10961
10962/* Display the contents of the version sections. */
10963
10964static bfd_boolean
10965process_version_sections (Filedata * filedata)
10966{
10967 Elf_Internal_Shdr * section;
10968 unsigned i;
10969 bfd_boolean found = FALSE;
10970
10971 if (! do_version)
10972 return TRUE;
10973
10974 for (i = 0, section = filedata->section_headers;
10975 i < filedata->file_header.e_shnum;
10976 i++, section++)
10977 {
10978 switch (section->sh_type)
10979 {
10980 case SHT_GNU_verdef:
10981 {
10982 Elf_External_Verdef * edefs;
10983 unsigned long idx;
10984 unsigned long cnt;
10985 char * endbuf;
10986
10987 found = TRUE;
10988
10989 printf (ngettext ("\nVersion definition section '%s' "
10990 "contains %u entry:\n",
10991 "\nVersion definition section '%s' "
10992 "contains %u entries:\n",
10993 section->sh_info),
10994 printable_section_name (filedata, section),
10995 section->sh_info);
10996
10997 printf (_(" Addr: 0x"));
10998 printf_vma (section->sh_addr);
10999 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11000 (unsigned long) section->sh_offset, section->sh_link,
11001 printable_section_name_from_index (filedata, section->sh_link));
11002
11003 edefs = (Elf_External_Verdef *)
11004 get_data (NULL, filedata, section->sh_offset, 1,section->sh_size,
11005 _("version definition section"));
11006 if (!edefs)
11007 break;
11008 endbuf = (char *) edefs + section->sh_size;
11009
11010 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
11011 {
11012 char * vstart;
11013 Elf_External_Verdef * edef;
11014 Elf_Internal_Verdef ent;
11015 Elf_External_Verdaux * eaux;
11016 Elf_Internal_Verdaux aux;
11017 unsigned long isum;
11018 int j;
11019
11020 vstart = ((char *) edefs) + idx;
11021 if (vstart + sizeof (*edef) > endbuf)
11022 break;
11023
11024 edef = (Elf_External_Verdef *) vstart;
11025
11026 ent.vd_version = BYTE_GET (edef->vd_version);
11027 ent.vd_flags = BYTE_GET (edef->vd_flags);
11028 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
11029 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
11030 ent.vd_hash = BYTE_GET (edef->vd_hash);
11031 ent.vd_aux = BYTE_GET (edef->vd_aux);
11032 ent.vd_next = BYTE_GET (edef->vd_next);
11033
11034 printf (_(" %#06lx: Rev: %d Flags: %s"),
11035 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
11036
11037 printf (_(" Index: %d Cnt: %d "),
11038 ent.vd_ndx, ent.vd_cnt);
11039
11040 /* Check for overflow. */
11041 if (ent.vd_aux > (size_t) (endbuf - vstart))
11042 break;
11043
11044 vstart += ent.vd_aux;
11045
11046 if (vstart + sizeof (*eaux) > endbuf)
11047 break;
11048 eaux = (Elf_External_Verdaux *) vstart;
11049
11050 aux.vda_name = BYTE_GET (eaux->vda_name);
11051 aux.vda_next = BYTE_GET (eaux->vda_next);
11052
11053 if (VALID_DYNAMIC_NAME (filedata, aux.vda_name))
11054 printf (_("Name: %s\n"),
11055 GET_DYNAMIC_NAME (filedata, aux.vda_name));
11056 else
11057 printf (_("Name index: %ld\n"), aux.vda_name);
11058
11059 isum = idx + ent.vd_aux;
11060
11061 for (j = 1; j < ent.vd_cnt; j++)
11062 {
11063 if (aux.vda_next < sizeof (*eaux)
11064 && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
11065 {
11066 warn (_("Invalid vda_next field of %lx\n"),
11067 aux.vda_next);
11068 j = ent.vd_cnt;
11069 break;
11070 }
11071 /* Check for overflow. */
11072 if (aux.vda_next > (size_t) (endbuf - vstart))
11073 break;
11074
11075 isum += aux.vda_next;
11076 vstart += aux.vda_next;
11077
11078 if (vstart + sizeof (*eaux) > endbuf)
11079 break;
11080 eaux = (Elf_External_Verdaux *) vstart;
11081
11082 aux.vda_name = BYTE_GET (eaux->vda_name);
11083 aux.vda_next = BYTE_GET (eaux->vda_next);
11084
11085 if (VALID_DYNAMIC_NAME (filedata, aux.vda_name))
11086 printf (_(" %#06lx: Parent %d: %s\n"),
11087 isum, j,
11088 GET_DYNAMIC_NAME (filedata, aux.vda_name));
11089 else
11090 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
11091 isum, j, aux.vda_name);
11092 }
11093
11094 if (j < ent.vd_cnt)
11095 printf (_(" Version def aux past end of section\n"));
11096
11097 /* PR 17531:
11098 file: id:000001,src:000172+005151,op:splice,rep:2. */
11099 if (ent.vd_next < sizeof (*edef)
11100 && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
11101 {
11102 warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
11103 cnt = section->sh_info;
11104 break;
11105 }
11106 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
11107 break;
11108
11109 idx += ent.vd_next;
11110 }
11111
11112 if (cnt < section->sh_info)
11113 printf (_(" Version definition past end of section\n"));
11114
11115 free (edefs);
11116 }
11117 break;
11118
11119 case SHT_GNU_verneed:
11120 {
11121 Elf_External_Verneed * eneed;
11122 unsigned long idx;
11123 unsigned long cnt;
11124 char * endbuf;
11125
11126 found = TRUE;
11127
11128 printf (ngettext ("\nVersion needs section '%s' "
11129 "contains %u entry:\n",
11130 "\nVersion needs section '%s' "
11131 "contains %u entries:\n",
11132 section->sh_info),
11133 printable_section_name (filedata, section), section->sh_info);
11134
11135 printf (_(" Addr: 0x"));
11136 printf_vma (section->sh_addr);
11137 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11138 (unsigned long) section->sh_offset, section->sh_link,
11139 printable_section_name_from_index (filedata, section->sh_link));
11140
11141 eneed = (Elf_External_Verneed *) get_data (NULL, filedata,
11142 section->sh_offset, 1,
11143 section->sh_size,
11144 _("Version Needs section"));
11145 if (!eneed)
11146 break;
11147 endbuf = (char *) eneed + section->sh_size;
11148
11149 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
11150 {
11151 Elf_External_Verneed * entry;
11152 Elf_Internal_Verneed ent;
11153 unsigned long isum;
11154 int j;
11155 char * vstart;
11156
11157 vstart = ((char *) eneed) + idx;
11158 if (vstart + sizeof (*entry) > endbuf)
11159 break;
11160
11161 entry = (Elf_External_Verneed *) vstart;
11162
11163 ent.vn_version = BYTE_GET (entry->vn_version);
11164 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
11165 ent.vn_file = BYTE_GET (entry->vn_file);
11166 ent.vn_aux = BYTE_GET (entry->vn_aux);
11167 ent.vn_next = BYTE_GET (entry->vn_next);
11168
11169 printf (_(" %#06lx: Version: %d"), idx, ent.vn_version);
11170
11171 if (VALID_DYNAMIC_NAME (filedata, ent.vn_file))
11172 printf (_(" File: %s"),
11173 GET_DYNAMIC_NAME (filedata, ent.vn_file));
11174 else
11175 printf (_(" File: %lx"), ent.vn_file);
11176
11177 printf (_(" Cnt: %d\n"), ent.vn_cnt);
11178
11179 /* Check for overflow. */
11180 if (ent.vn_aux > (size_t) (endbuf - vstart))
11181 break;
11182 vstart += ent.vn_aux;
11183
11184 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
11185 {
11186 Elf_External_Vernaux * eaux;
11187 Elf_Internal_Vernaux aux;
11188
11189 if (vstart + sizeof (*eaux) > endbuf)
11190 break;
11191 eaux = (Elf_External_Vernaux *) vstart;
11192
11193 aux.vna_hash = BYTE_GET (eaux->vna_hash);
11194 aux.vna_flags = BYTE_GET (eaux->vna_flags);
11195 aux.vna_other = BYTE_GET (eaux->vna_other);
11196 aux.vna_name = BYTE_GET (eaux->vna_name);
11197 aux.vna_next = BYTE_GET (eaux->vna_next);
11198
11199 if (VALID_DYNAMIC_NAME (filedata, aux.vna_name))
11200 printf (_(" %#06lx: Name: %s"),
11201 isum, GET_DYNAMIC_NAME (filedata, aux.vna_name));
11202 else
11203 printf (_(" %#06lx: Name index: %lx"),
11204 isum, aux.vna_name);
11205
11206 printf (_(" Flags: %s Version: %d\n"),
11207 get_ver_flags (aux.vna_flags), aux.vna_other);
11208
11209 if (aux.vna_next < sizeof (*eaux)
11210 && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
11211 {
11212 warn (_("Invalid vna_next field of %lx\n"),
11213 aux.vna_next);
11214 j = ent.vn_cnt;
11215 break;
11216 }
11217 /* Check for overflow. */
11218 if (aux.vna_next > (size_t) (endbuf - vstart))
11219 break;
11220 isum += aux.vna_next;
11221 vstart += aux.vna_next;
11222 }
11223
11224 if (j < ent.vn_cnt)
11225 warn (_("Missing Version Needs auxillary information\n"));
11226
11227 if (ent.vn_next < sizeof (*entry)
11228 && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
11229 {
11230 warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
11231 cnt = section->sh_info;
11232 break;
11233 }
11234 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
11235 break;
11236 idx += ent.vn_next;
11237 }
11238
11239 if (cnt < section->sh_info)
11240 warn (_("Missing Version Needs information\n"));
11241
11242 free (eneed);
11243 }
11244 break;
11245
11246 case SHT_GNU_versym:
11247 {
11248 Elf_Internal_Shdr * link_section;
11249 size_t total;
11250 unsigned int cnt;
11251 unsigned char * edata;
11252 unsigned short * data;
11253 char * strtab;
11254 Elf_Internal_Sym * symbols;
11255 Elf_Internal_Shdr * string_sec;
11256 unsigned long num_syms;
11257 long off;
11258
11259 if (section->sh_link >= filedata->file_header.e_shnum)
11260 break;
11261
11262 link_section = filedata->section_headers + section->sh_link;
11263 total = section->sh_size / sizeof (Elf_External_Versym);
11264
11265 if (link_section->sh_link >= filedata->file_header.e_shnum)
11266 break;
11267
11268 found = TRUE;
11269
11270 symbols = GET_ELF_SYMBOLS (filedata, link_section, & num_syms);
11271 if (symbols == NULL)
11272 break;
11273
11274 string_sec = filedata->section_headers + link_section->sh_link;
11275
11276 strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
11277 string_sec->sh_size,
11278 _("version string table"));
11279 if (!strtab)
11280 {
11281 free (symbols);
11282 break;
11283 }
11284
11285 printf (ngettext ("\nVersion symbols section '%s' "
11286 "contains %lu entry:\n",
11287 "\nVersion symbols section '%s' "
11288 "contains %lu entries:\n",
11289 total),
11290 printable_section_name (filedata, section), (unsigned long) total);
11291
11292 printf (_(" Addr: 0x"));
11293 printf_vma (section->sh_addr);
11294 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11295 (unsigned long) section->sh_offset, section->sh_link,
11296 printable_section_name (filedata, link_section));
11297
11298 off = offset_from_vma (filedata,
11299 filedata->version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11300 total * sizeof (short));
11301 edata = (unsigned char *) get_data (NULL, filedata, off,
11302 sizeof (short), total,
11303 _("version symbol data"));
11304 if (!edata)
11305 {
11306 free (strtab);
11307 free (symbols);
11308 break;
11309 }
11310
11311 data = (short unsigned int *) cmalloc (total, sizeof (short));
11312
11313 for (cnt = total; cnt --;)
11314 data[cnt] = byte_get (edata + cnt * sizeof (short),
11315 sizeof (short));
11316
11317 free (edata);
11318
11319 for (cnt = 0; cnt < total; cnt += 4)
11320 {
11321 int j, nn;
11322 char *name;
11323 char *invalid = _("*invalid*");
11324
11325 printf (" %03x:", cnt);
11326
11327 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
11328 switch (data[cnt + j])
11329 {
11330 case 0:
11331 fputs (_(" 0 (*local*) "), stdout);
11332 break;
11333
11334 case 1:
11335 fputs (_(" 1 (*global*) "), stdout);
11336 break;
11337
11338 default:
11339 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
11340 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
11341
11342 /* If this index value is greater than the size of the symbols
11343 array, break to avoid an out-of-bounds read. */
11344 if ((unsigned long)(cnt + j) >= num_syms)
11345 {
11346 warn (_("invalid index into symbol array\n"));
11347 break;
11348 }
11349
11350 name = NULL;
11351 if (filedata->version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11352 {
11353 Elf_Internal_Verneed ivn;
11354 unsigned long offset;
11355
11356 offset = offset_from_vma
11357 (filedata,
11358 filedata->version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11359 sizeof (Elf_External_Verneed));
11360
11361 do
11362 {
11363 Elf_Internal_Vernaux ivna;
11364 Elf_External_Verneed evn;
11365 Elf_External_Vernaux evna;
11366 unsigned long a_off;
11367
11368 if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11369 _("version need")) == NULL)
11370 break;
11371
11372 ivn.vn_aux = BYTE_GET (evn.vn_aux);
11373 ivn.vn_next = BYTE_GET (evn.vn_next);
11374
11375 a_off = offset + ivn.vn_aux;
11376
11377 do
11378 {
11379 if (get_data (&evna, filedata, a_off, sizeof (evna),
11380 1, _("version need aux (2)")) == NULL)
11381 {
11382 ivna.vna_next = 0;
11383 ivna.vna_other = 0;
11384 }
11385 else
11386 {
11387 ivna.vna_next = BYTE_GET (evna.vna_next);
11388 ivna.vna_other = BYTE_GET (evna.vna_other);
11389 }
11390
11391 a_off += ivna.vna_next;
11392 }
11393 while (ivna.vna_other != data[cnt + j]
11394 && ivna.vna_next != 0);
11395
11396 if (ivna.vna_other == data[cnt + j])
11397 {
11398 ivna.vna_name = BYTE_GET (evna.vna_name);
11399
11400 if (ivna.vna_name >= string_sec->sh_size)
11401 name = invalid;
11402 else
11403 name = strtab + ivna.vna_name;
11404 break;
11405 }
11406
11407 offset += ivn.vn_next;
11408 }
11409 while (ivn.vn_next);
11410 }
11411
11412 if (data[cnt + j] != 0x8001
11413 && filedata->version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11414 {
11415 Elf_Internal_Verdef ivd;
11416 Elf_External_Verdef evd;
11417 unsigned long offset;
11418
11419 offset = offset_from_vma
11420 (filedata,
11421 filedata->version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11422 sizeof evd);
11423
11424 do
11425 {
11426 if (get_data (&evd, filedata, offset, sizeof (evd), 1,
11427 _("version def")) == NULL)
11428 {
11429 ivd.vd_next = 0;
11430 /* PR 17531: file: 046-1082287-0.004. */
11431 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
11432 break;
11433 }
11434 else
11435 {
11436 ivd.vd_next = BYTE_GET (evd.vd_next);
11437 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11438 }
11439
11440 offset += ivd.vd_next;
11441 }
11442 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
11443 && ivd.vd_next != 0);
11444
11445 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
11446 {
11447 Elf_External_Verdaux evda;
11448 Elf_Internal_Verdaux ivda;
11449
11450 ivd.vd_aux = BYTE_GET (evd.vd_aux);
11451
11452 if (get_data (&evda, filedata,
11453 offset - ivd.vd_next + ivd.vd_aux,
11454 sizeof (evda), 1,
11455 _("version def aux")) == NULL)
11456 break;
11457
11458 ivda.vda_name = BYTE_GET (evda.vda_name);
11459
11460 if (ivda.vda_name >= string_sec->sh_size)
11461 name = invalid;
11462 else if (name != NULL && name != invalid)
11463 name = _("*both*");
11464 else
11465 name = strtab + ivda.vda_name;
11466 }
11467 }
11468 if (name != NULL)
11469 nn += printf ("(%s%-*s",
11470 name,
11471 12 - (int) strlen (name),
11472 ")");
11473
11474 if (nn < 18)
11475 printf ("%*c", 18 - nn, ' ');
11476 }
11477
11478 putchar ('\n');
11479 }
11480
11481 free (data);
11482 free (strtab);
11483 free (symbols);
11484 }
11485 break;
11486
11487 default:
11488 break;
11489 }
11490 }
11491
11492 if (! found)
11493 printf (_("\nNo version information found in this file.\n"));
11494
11495 return TRUE;
11496}
11497
11498static const char *
11499get_symbol_binding (Filedata * filedata, unsigned int binding)
11500{
11501 static char buff[64];
11502
11503 switch (binding)
11504 {
11505 case STB_LOCAL: return "LOCAL";
11506 case STB_GLOBAL: return "GLOBAL";
11507 case STB_WEAK: return "WEAK";
11508 default:
11509 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
11510 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
11511 binding);
11512 else if (binding >= STB_LOOS && binding <= STB_HIOS)
11513 {
11514 if (binding == STB_GNU_UNIQUE
11515 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU)
11516 return "UNIQUE";
11517 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
11518 }
11519 else
11520 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
11521 return buff;
11522 }
11523}
11524
11525static const char *
11526get_symbol_type (Filedata * filedata, unsigned int type)
11527{
11528 static char buff[64];
11529
11530 switch (type)
11531 {
11532 case STT_NOTYPE: return "NOTYPE";
11533 case STT_OBJECT: return "OBJECT";
11534 case STT_FUNC: return "FUNC";
11535 case STT_SECTION: return "SECTION";
11536 case STT_FILE: return "FILE";
11537 case STT_COMMON: return "COMMON";
11538 case STT_TLS: return "TLS";
11539 case STT_RELC: return "RELC";
11540 case STT_SRELC: return "SRELC";
11541 default:
11542 if (type >= STT_LOPROC && type <= STT_HIPROC)
11543 {
11544 if (filedata->file_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
11545 return "THUMB_FUNC";
11546
11547 if (filedata->file_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
11548 return "REGISTER";
11549
11550 if (filedata->file_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
11551 return "PARISC_MILLI";
11552
11553 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
11554 }
11555 else if (type >= STT_LOOS && type <= STT_HIOS)
11556 {
11557 if (filedata->file_header.e_machine == EM_PARISC)
11558 {
11559 if (type == STT_HP_OPAQUE)
11560 return "HP_OPAQUE";
11561 if (type == STT_HP_STUB)
11562 return "HP_STUB";
11563 }
11564
11565 if (type == STT_GNU_IFUNC
11566 && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
11567 || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD))
11568 return "IFUNC";
11569
11570 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
11571 }
11572 else
11573 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
11574 return buff;
11575 }
11576}
11577
11578static const char *
11579get_symbol_visibility (unsigned int visibility)
11580{
11581 switch (visibility)
11582 {
11583 case STV_DEFAULT: return "DEFAULT";
11584 case STV_INTERNAL: return "INTERNAL";
11585 case STV_HIDDEN: return "HIDDEN";
11586 case STV_PROTECTED: return "PROTECTED";
11587 default:
11588 error (_("Unrecognized visibility value: %u\n"), visibility);
11589 return _("<unknown>");
11590 }
11591}
11592
11593static const char *
11594get_alpha_symbol_other (unsigned int other)
11595{
11596 switch (other)
11597 {
11598 case STO_ALPHA_NOPV: return "NOPV";
11599 case STO_ALPHA_STD_GPLOAD: return "STD GPLOAD";
11600 default:
11601 error (_("Unrecognized alpha specific other value: %u\n"), other);
11602 return _("<unknown>");
11603 }
11604}
11605
11606static const char *
11607get_solaris_symbol_visibility (unsigned int visibility)
11608{
11609 switch (visibility)
11610 {
11611 case 4: return "EXPORTED";
11612 case 5: return "SINGLETON";
11613 case 6: return "ELIMINATE";
11614 default: return get_symbol_visibility (visibility);
11615 }
11616}
11617
11618static const char *
11619get_aarch64_symbol_other (unsigned int other)
11620{
11621 static char buf[32];
11622
11623 if (other & STO_AARCH64_VARIANT_PCS)
11624 {
11625 other &= ~STO_AARCH64_VARIANT_PCS;
11626 if (other == 0)
11627 return "VARIANT_PCS";
11628 snprintf (buf, sizeof buf, "VARIANT_PCS | %x", other);
11629 return buf;
11630 }
11631 return NULL;
11632}
11633
11634static const char *
11635get_mips_symbol_other (unsigned int other)
11636{
11637 switch (other)
11638 {
11639 case STO_OPTIONAL: return "OPTIONAL";
11640 case STO_MIPS_PLT: return "MIPS PLT";
11641 case STO_MIPS_PIC: return "MIPS PIC";
11642 case STO_MICROMIPS: return "MICROMIPS";
11643 case STO_MICROMIPS | STO_MIPS_PIC: return "MICROMIPS, MIPS PIC";
11644 case STO_MIPS16: return "MIPS16";
11645 default: return NULL;
11646 }
11647}
11648
11649static const char *
11650get_ia64_symbol_other (Filedata * filedata, unsigned int other)
11651{
11652 if (is_ia64_vms (filedata))
11653 {
11654 static char res[32];
11655
11656 res[0] = 0;
11657
11658 /* Function types is for images and .STB files only. */
11659 switch (filedata->file_header.e_type)
11660 {
11661 case ET_DYN:
11662 case ET_EXEC:
11663 switch (VMS_ST_FUNC_TYPE (other))
11664 {
11665 case VMS_SFT_CODE_ADDR:
11666 strcat (res, " CA");
11667 break;
11668 case VMS_SFT_SYMV_IDX:
11669 strcat (res, " VEC");
11670 break;
11671 case VMS_SFT_FD:
11672 strcat (res, " FD");
11673 break;
11674 case VMS_SFT_RESERVE:
11675 strcat (res, " RSV");
11676 break;
11677 default:
11678 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11679 VMS_ST_FUNC_TYPE (other));
11680 strcat (res, " <unknown>");
11681 break;
11682 }
11683 break;
11684 default:
11685 break;
11686 }
11687 switch (VMS_ST_LINKAGE (other))
11688 {
11689 case VMS_STL_IGNORE:
11690 strcat (res, " IGN");
11691 break;
11692 case VMS_STL_RESERVE:
11693 strcat (res, " RSV");
11694 break;
11695 case VMS_STL_STD:
11696 strcat (res, " STD");
11697 break;
11698 case VMS_STL_LNK:
11699 strcat (res, " LNK");
11700 break;
11701 default:
11702 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11703 VMS_ST_LINKAGE (other));
11704 strcat (res, " <unknown>");
11705 break;
11706 }
11707
11708 if (res[0] != 0)
11709 return res + 1;
11710 else
11711 return res;
11712 }
11713 return NULL;
11714}
11715
11716static const char *
11717get_ppc64_symbol_other (unsigned int other)
11718{
11719 if ((other & ~STO_PPC64_LOCAL_MASK) != 0)
11720 return NULL;
11721
11722 other >>= STO_PPC64_LOCAL_BIT;
11723 if (other <= 6)
11724 {
11725 static char buf[64];
11726 if (other >= 2)
11727 other = ppc64_decode_local_entry (other);
11728 snprintf (buf, sizeof buf, _("<localentry>: %d"), other);
11729 return buf;
11730 }
11731 return NULL;
11732}
11733
11734static const char *
11735get_symbol_other (Filedata * filedata, unsigned int other)
11736{
11737 const char * result = NULL;
11738 static char buff [64];
11739
11740 if (other == 0)
11741 return "";
11742
11743 switch (filedata->file_header.e_machine)
11744 {
11745 case EM_ALPHA:
11746 result = get_alpha_symbol_other (other);
11747 break;
11748 case EM_AARCH64:
11749 result = get_aarch64_symbol_other (other);
11750 break;
11751 case EM_MIPS:
11752 result = get_mips_symbol_other (other);
11753 break;
11754 case EM_IA_64:
11755 result = get_ia64_symbol_other (filedata, other);
11756 break;
11757 case EM_PPC64:
11758 result = get_ppc64_symbol_other (other);
11759 break;
11760 default:
11761 result = NULL;
11762 break;
11763 }
11764
11765 if (result)
11766 return result;
11767
11768 snprintf (buff, sizeof buff, _("<other>: %x"), other);
11769 return buff;
11770}
11771
11772static const char *
11773get_symbol_index_type (Filedata * filedata, unsigned int type)
11774{
11775 static char buff[32];
11776
11777 switch (type)
11778 {
11779 case SHN_UNDEF: return "UND";
11780 case SHN_ABS: return "ABS";
11781 case SHN_COMMON: return "COM";
11782 default:
11783 if (type == SHN_IA_64_ANSI_COMMON
11784 && filedata->file_header.e_machine == EM_IA_64
11785 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
11786 return "ANSI_COM";
11787 else if ((filedata->file_header.e_machine == EM_X86_64
11788 || filedata->file_header.e_machine == EM_L1OM
11789 || filedata->file_header.e_machine == EM_K1OM)
11790 && type == SHN_X86_64_LCOMMON)
11791 return "LARGE_COM";
11792 else if ((type == SHN_MIPS_SCOMMON
11793 && filedata->file_header.e_machine == EM_MIPS)
11794 || (type == SHN_TIC6X_SCOMMON
11795 && filedata->file_header.e_machine == EM_TI_C6000))
11796 return "SCOM";
11797 else if (type == SHN_MIPS_SUNDEFINED
11798 && filedata->file_header.e_machine == EM_MIPS)
11799 return "SUND";
11800 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
11801 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
11802 else if (type >= SHN_LOOS && type <= SHN_HIOS)
11803 sprintf (buff, "OS [0x%04x]", type & 0xffff);
11804 else if (type >= SHN_LORESERVE)
11805 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
11806 else if (filedata->file_header.e_shnum != 0
11807 && type >= filedata->file_header.e_shnum)
11808 sprintf (buff, _("bad section index[%3d]"), type);
11809 else
11810 sprintf (buff, "%3d", type);
11811 break;
11812 }
11813
11814 return buff;
11815}
11816
11817static const char *
11818get_symbol_version_string (Filedata * filedata,
11819 bfd_boolean is_dynsym,
11820 const char * strtab,
11821 unsigned long int strtab_size,
11822 unsigned int si,
11823 Elf_Internal_Sym * psym,
11824 enum versioned_symbol_info * sym_info,
11825 unsigned short * vna_other)
11826{
11827 unsigned char data[2];
11828 unsigned short vers_data;
11829 unsigned long offset;
11830 unsigned short max_vd_ndx;
11831
11832 if (!is_dynsym
11833 || filedata->version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11834 return NULL;
11835
11836 offset = offset_from_vma (filedata,
11837 filedata->version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11838 sizeof data + si * sizeof (vers_data));
11839
11840 if (get_data (&data, filedata, offset + si * sizeof (vers_data),
11841 sizeof (data), 1, _("version data")) == NULL)
11842 return NULL;
11843
11844 vers_data = byte_get (data, 2);
11845
11846 if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data == 0)
11847 return NULL;
11848
11849 *sym_info = (vers_data & VERSYM_HIDDEN) != 0 ? symbol_hidden : symbol_public;
11850 max_vd_ndx = 0;
11851
11852 /* Usually we'd only see verdef for defined symbols, and verneed for
11853 undefined symbols. However, symbols defined by the linker in
11854 .dynbss for variables copied from a shared library in order to
11855 avoid text relocations are defined yet have verneed. We could
11856 use a heuristic to detect the special case, for example, check
11857 for verneed first on symbols defined in SHT_NOBITS sections, but
11858 it is simpler and more reliable to just look for both verdef and
11859 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11860
11861 if (psym->st_shndx != SHN_UNDEF
11862 && vers_data != 0x8001
11863 && filedata->version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11864 {
11865 Elf_Internal_Verdef ivd;
11866 Elf_Internal_Verdaux ivda;
11867 Elf_External_Verdaux evda;
11868 unsigned long off;
11869
11870 off = offset_from_vma (filedata,
11871 filedata->version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11872 sizeof (Elf_External_Verdef));
11873
11874 do
11875 {
11876 Elf_External_Verdef evd;
11877
11878 if (get_data (&evd, filedata, off, sizeof (evd), 1,
11879 _("version def")) == NULL)
11880 {
11881 ivd.vd_ndx = 0;
11882 ivd.vd_aux = 0;
11883 ivd.vd_next = 0;
11884 ivd.vd_flags = 0;
11885 }
11886 else
11887 {
11888 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11889 ivd.vd_aux = BYTE_GET (evd.vd_aux);
11890 ivd.vd_next = BYTE_GET (evd.vd_next);
11891 ivd.vd_flags = BYTE_GET (evd.vd_flags);
11892 }
11893
11894 if ((ivd.vd_ndx & VERSYM_VERSION) > max_vd_ndx)
11895 max_vd_ndx = ivd.vd_ndx & VERSYM_VERSION;
11896
11897 off += ivd.vd_next;
11898 }
11899 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11900
11901 if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11902 {
11903 if (ivd.vd_ndx == 1 && ivd.vd_flags == VER_FLG_BASE)
11904 return NULL;
11905
11906 off -= ivd.vd_next;
11907 off += ivd.vd_aux;
11908
11909 if (get_data (&evda, filedata, off, sizeof (evda), 1,
11910 _("version def aux")) != NULL)
11911 {
11912 ivda.vda_name = BYTE_GET (evda.vda_name);
11913
11914 if (psym->st_name != ivda.vda_name)
11915 return (ivda.vda_name < strtab_size
11916 ? strtab + ivda.vda_name : _("<corrupt>"));
11917 }
11918 }
11919 }
11920
11921 if (filedata->version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11922 {
11923 Elf_External_Verneed evn;
11924 Elf_Internal_Verneed ivn;
11925 Elf_Internal_Vernaux ivna;
11926
11927 offset = offset_from_vma (filedata,
11928 filedata->version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11929 sizeof evn);
11930 do
11931 {
11932 unsigned long vna_off;
11933
11934 if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11935 _("version need")) == NULL)
11936 {
11937 ivna.vna_next = 0;
11938 ivna.vna_other = 0;
11939 ivna.vna_name = 0;
11940 break;
11941 }
11942
11943 ivn.vn_aux = BYTE_GET (evn.vn_aux);
11944 ivn.vn_next = BYTE_GET (evn.vn_next);
11945
11946 vna_off = offset + ivn.vn_aux;
11947
11948 do
11949 {
11950 Elf_External_Vernaux evna;
11951
11952 if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
11953 _("version need aux (3)")) == NULL)
11954 {
11955 ivna.vna_next = 0;
11956 ivna.vna_other = 0;
11957 ivna.vna_name = 0;
11958 }
11959 else
11960 {
11961 ivna.vna_other = BYTE_GET (evna.vna_other);
11962 ivna.vna_next = BYTE_GET (evna.vna_next);
11963 ivna.vna_name = BYTE_GET (evna.vna_name);
11964 }
11965
11966 vna_off += ivna.vna_next;
11967 }
11968 while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11969
11970 if (ivna.vna_other == vers_data)
11971 break;
11972
11973 offset += ivn.vn_next;
11974 }
11975 while (ivn.vn_next != 0);
11976
11977 if (ivna.vna_other == vers_data)
11978 {
11979 *sym_info = symbol_undefined;
11980 *vna_other = ivna.vna_other;
11981 return (ivna.vna_name < strtab_size
11982 ? strtab + ivna.vna_name : _("<corrupt>"));
11983 }
11984 else if ((max_vd_ndx || (vers_data & VERSYM_VERSION) != 1)
11985 && (vers_data & VERSYM_VERSION) > max_vd_ndx)
11986 return _("<corrupt>");
11987 }
11988 return NULL;
11989}
11990
11991static void
11992print_dynamic_symbol (Filedata *filedata, unsigned long si,
11993 Elf_Internal_Sym *symtab,
11994 Elf_Internal_Shdr *section,
11995 char *strtab, size_t strtab_size)
11996{
11997 const char *version_string;
11998 enum versioned_symbol_info sym_info;
11999 unsigned short vna_other;
12000 Elf_Internal_Sym *psym = symtab + si;
12001
12002 printf ("%6ld: ", si);
12003 print_vma (psym->st_value, LONG_HEX);
12004 putchar (' ');
12005 print_vma (psym->st_size, DEC_5);
12006 printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
12007 printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
12008 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
12009 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
12010 else
12011 {
12012 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
12013
12014 printf (" %-7s", get_symbol_visibility (vis));
12015 /* Check to see if any other bits in the st_other field are set.
12016 Note - displaying this information disrupts the layout of the
12017 table being generated, but for the moment this case is very rare. */
12018 if (psym->st_other ^ vis)
12019 printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
12020 }
12021 printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
12022 print_symbol (25, VALID_SYMBOL_NAME (strtab, strtab_size,
12023 psym->st_name)
12024 ? strtab + psym->st_name : _("<corrupt>"));
12025
12026 version_string
12027 = get_symbol_version_string (filedata,
12028 (section == NULL
12029 || section->sh_type == SHT_DYNSYM),
12030 strtab, strtab_size, si,
12031 psym, &sym_info, &vna_other);
12032 if (version_string)
12033 {
12034 if (sym_info == symbol_undefined)
12035 printf ("@%s (%d)", version_string, vna_other);
12036 else
12037 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
12038 version_string);
12039 }
12040
12041 putchar ('\n');
12042
12043 if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
12044 && section != NULL
12045 && si >= section->sh_info
12046 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12047 && filedata->file_header.e_machine != EM_MIPS
12048 /* Solaris binaries have been found to violate this requirement as
12049 well. Not sure if this is a bug or an ABI requirement. */
12050 && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
12051 warn (_("local symbol %lu found at index >= %s's sh_info value of %u\n"),
12052 si, printable_section_name (filedata, section), section->sh_info);
12053}
12054
12055/* Dump the symbol table. */
12056static bfd_boolean
12057process_symbol_table (Filedata * filedata)
12058{
12059 Elf_Internal_Shdr * section;
12060
12061 if (!do_syms && !do_dyn_syms && !do_histogram)
12062 return TRUE;
12063
12064 if ((filedata->dynamic_info[DT_HASH] || filedata->dynamic_info_DT_GNU_HASH)
12065 && do_syms
12066 && do_using_dynamic
12067 && filedata->dynamic_strings != NULL
12068 && filedata->dynamic_symbols != NULL)
12069 {
12070 unsigned long si;
12071
12072 printf (ngettext ("\nSymbol table for image contains %lu entry:\n",
12073 "\nSymbol table for image contains %lu entries:\n",
12074 filedata->num_dynamic_syms),
12075 filedata->num_dynamic_syms);
12076 if (is_32bit_elf)
12077 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12078 else
12079 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12080
12081 for (si = 0; si < filedata->num_dynamic_syms; si++)
12082 print_dynamic_symbol (filedata, si, filedata->dynamic_symbols, NULL,
12083 filedata->dynamic_strings,
12084 filedata->dynamic_strings_length);
12085 }
12086 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
12087 && filedata->section_headers != NULL)
12088 {
12089 unsigned int i;
12090
12091 for (i = 0, section = filedata->section_headers;
12092 i < filedata->file_header.e_shnum;
12093 i++, section++)
12094 {
12095 char * strtab = NULL;
12096 unsigned long int strtab_size = 0;
12097 Elf_Internal_Sym * symtab;
12098 unsigned long si, num_syms;
12099
12100 if ((section->sh_type != SHT_SYMTAB
12101 && section->sh_type != SHT_DYNSYM)
12102 || (!do_syms
12103 && section->sh_type == SHT_SYMTAB))
12104 continue;
12105
12106 if (section->sh_entsize == 0)
12107 {
12108 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
12109 printable_section_name (filedata, section));
12110 continue;
12111 }
12112
12113 num_syms = section->sh_size / section->sh_entsize;
12114 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
12115 "\nSymbol table '%s' contains %lu entries:\n",
12116 num_syms),
12117 printable_section_name (filedata, section),
12118 num_syms);
12119
12120 if (is_32bit_elf)
12121 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12122 else
12123 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12124
12125 symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
12126 if (symtab == NULL)
12127 continue;
12128
12129 if (section->sh_link == filedata->file_header.e_shstrndx)
12130 {
12131 strtab = filedata->string_table;
12132 strtab_size = filedata->string_table_length;
12133 }
12134 else if (section->sh_link < filedata->file_header.e_shnum)
12135 {
12136 Elf_Internal_Shdr * string_sec;
12137
12138 string_sec = filedata->section_headers + section->sh_link;
12139
12140 strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
12141 1, string_sec->sh_size,
12142 _("string table"));
12143 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
12144 }
12145
12146 for (si = 0; si < num_syms; si++)
12147 print_dynamic_symbol (filedata, si, symtab, section,
12148 strtab, strtab_size);
12149
12150 free (symtab);
12151 if (strtab != filedata->string_table)
12152 free (strtab);
12153 }
12154 }
12155 else if (do_syms)
12156 printf
12157 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12158
12159 if (do_histogram && filedata->buckets != NULL)
12160 {
12161 unsigned long * lengths;
12162 unsigned long * counts;
12163 unsigned long hn;
12164 bfd_vma si;
12165 unsigned long maxlength = 0;
12166 unsigned long nzero_counts = 0;
12167 unsigned long nsyms = 0;
12168 char *visited;
12169
12170 printf (ngettext ("\nHistogram for bucket list length "
12171 "(total of %lu bucket):\n",
12172 "\nHistogram for bucket list length "
12173 "(total of %lu buckets):\n",
12174 (unsigned long) filedata->nbuckets),
12175 (unsigned long) filedata->nbuckets);
12176
12177 lengths = (unsigned long *) calloc (filedata->nbuckets,
12178 sizeof (*lengths));
12179 if (lengths == NULL)
12180 {
12181 error (_("Out of memory allocating space for histogram buckets\n"));
12182 goto err_out;
12183 }
12184 visited = xcmalloc (filedata->nchains, 1);
12185 memset (visited, 0, filedata->nchains);
12186
12187 printf (_(" Length Number %% of total Coverage\n"));
12188 for (hn = 0; hn < filedata->nbuckets; ++hn)
12189 {
12190 for (si = filedata->buckets[hn]; si > 0; si = filedata->chains[si])
12191 {
12192 ++nsyms;
12193 if (maxlength < ++lengths[hn])
12194 ++maxlength;
12195 if (si >= filedata->nchains || visited[si])
12196 {
12197 error (_("histogram chain is corrupt\n"));
12198 break;
12199 }
12200 visited[si] = 1;
12201 }
12202 }
12203 free (visited);
12204
12205 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
12206 if (counts == NULL)
12207 {
12208 free (lengths);
12209 error (_("Out of memory allocating space for histogram counts\n"));
12210 goto err_out;
12211 }
12212
12213 for (hn = 0; hn < filedata->nbuckets; ++hn)
12214 ++counts[lengths[hn]];
12215
12216 if (filedata->nbuckets > 0)
12217 {
12218 unsigned long i;
12219 printf (" 0 %-10lu (%5.1f%%)\n",
12220 counts[0], (counts[0] * 100.0) / filedata->nbuckets);
12221 for (i = 1; i <= maxlength; ++i)
12222 {
12223 nzero_counts += counts[i] * i;
12224 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12225 i, counts[i], (counts[i] * 100.0) / filedata->nbuckets,
12226 (nzero_counts * 100.0) / nsyms);
12227 }
12228 }
12229
12230 free (counts);
12231 free (lengths);
12232 }
12233
12234 free (filedata->buckets);
12235 filedata->buckets = NULL;
12236 filedata->nbuckets = 0;
12237 free (filedata->chains);
12238 filedata->chains = NULL;
12239
12240 if (do_histogram && filedata->gnubuckets != NULL)
12241 {
12242 unsigned long * lengths;
12243 unsigned long * counts;
12244 unsigned long hn;
12245 unsigned long maxlength = 0;
12246 unsigned long nzero_counts = 0;
12247 unsigned long nsyms = 0;
12248
12249 printf (ngettext ("\nHistogram for `%s' bucket list length "
12250 "(total of %lu bucket):\n",
12251 "\nHistogram for `%s' bucket list length "
12252 "(total of %lu buckets):\n",
12253 (unsigned long) filedata->ngnubuckets),
12254 GNU_HASH_SECTION_NAME (filedata),
12255 (unsigned long) filedata->ngnubuckets);
12256
12257 lengths = (unsigned long *) calloc (filedata->ngnubuckets,
12258 sizeof (*lengths));
12259 if (lengths == NULL)
12260 {
12261 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12262 goto err_out;
12263 }
12264
12265 printf (_(" Length Number %% of total Coverage\n"));
12266
12267 for (hn = 0; hn < filedata->ngnubuckets; ++hn)
12268 if (filedata->gnubuckets[hn] != 0)
12269 {
12270 bfd_vma off, length = 1;
12271
12272 for (off = filedata->gnubuckets[hn] - filedata->gnusymidx;
12273 /* PR 17531 file: 010-77222-0.004. */
12274 off < filedata->ngnuchains
12275 && (filedata->gnuchains[off] & 1) == 0;
12276 ++off)
12277 ++length;
12278 lengths[hn] = length;
12279 if (length > maxlength)
12280 maxlength = length;
12281 nsyms += length;
12282 }
12283
12284 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
12285 if (counts == NULL)
12286 {
12287 free (lengths);
12288 error (_("Out of memory allocating space for gnu histogram counts\n"));
12289 goto err_out;
12290 }
12291
12292 for (hn = 0; hn < filedata->ngnubuckets; ++hn)
12293 ++counts[lengths[hn]];
12294
12295 if (filedata->ngnubuckets > 0)
12296 {
12297 unsigned long j;
12298 printf (" 0 %-10lu (%5.1f%%)\n",
12299 counts[0], (counts[0] * 100.0) / filedata->ngnubuckets);
12300 for (j = 1; j <= maxlength; ++j)
12301 {
12302 nzero_counts += counts[j] * j;
12303 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12304 j, counts[j], (counts[j] * 100.0) / filedata->ngnubuckets,
12305 (nzero_counts * 100.0) / nsyms);
12306 }
12307 }
12308
12309 free (counts);
12310 free (lengths);
12311 }
12312 free (filedata->gnubuckets);
12313 filedata->gnubuckets = NULL;
12314 filedata->ngnubuckets = 0;
12315 free (filedata->gnuchains);
12316 filedata->gnuchains = NULL;
12317 filedata->ngnuchains = 0;
12318 free (filedata->mipsxlat);
12319 filedata->mipsxlat = NULL;
12320 return TRUE;
12321
12322 err_out:
12323 free (filedata->gnubuckets);
12324 filedata->gnubuckets = NULL;
12325 filedata->ngnubuckets = 0;
12326 free (filedata->gnuchains);
12327 filedata->gnuchains = NULL;
12328 filedata->ngnuchains = 0;
12329 free (filedata->mipsxlat);
12330 filedata->mipsxlat = NULL;
12331 free (filedata->buckets);
12332 filedata->buckets = NULL;
12333 filedata->nbuckets = 0;
12334 free (filedata->chains);
12335 filedata->chains = NULL;
12336 return FALSE;
12337}
12338
12339static bfd_boolean
12340process_syminfo (Filedata * filedata ATTRIBUTE_UNUSED)
12341{
12342 unsigned int i;
12343
12344 if (filedata->dynamic_syminfo == NULL
12345 || !do_dynamic)
12346 /* No syminfo, this is ok. */
12347 return TRUE;
12348
12349 /* There better should be a dynamic symbol section. */
12350 if (filedata->dynamic_symbols == NULL || filedata->dynamic_strings == NULL)
12351 return FALSE;
12352
12353 if (filedata->dynamic_addr)
12354 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12355 "contains %d entry:\n",
12356 "\nDynamic info segment at offset 0x%lx "
12357 "contains %d entries:\n",
12358 filedata->dynamic_syminfo_nent),
12359 filedata->dynamic_syminfo_offset, filedata->dynamic_syminfo_nent);
12360
12361 printf (_(" Num: Name BoundTo Flags\n"));
12362 for (i = 0; i < filedata->dynamic_syminfo_nent; ++i)
12363 {
12364 unsigned short int flags = filedata->dynamic_syminfo[i].si_flags;
12365
12366 printf ("%4d: ", i);
12367 if (i >= filedata->num_dynamic_syms)
12368 printf (_("<corrupt index>"));
12369 else if (VALID_DYNAMIC_NAME (filedata, filedata->dynamic_symbols[i].st_name))
12370 print_symbol (30, GET_DYNAMIC_NAME (filedata,
12371 filedata->dynamic_symbols[i].st_name));
12372 else
12373 printf (_("<corrupt: %19ld>"), filedata->dynamic_symbols[i].st_name);
12374 putchar (' ');
12375
12376 switch (filedata->dynamic_syminfo[i].si_boundto)
12377 {
12378 case SYMINFO_BT_SELF:
12379 fputs ("SELF ", stdout);
12380 break;
12381 case SYMINFO_BT_PARENT:
12382 fputs ("PARENT ", stdout);
12383 break;
12384 default:
12385 if (filedata->dynamic_syminfo[i].si_boundto > 0
12386 && filedata->dynamic_syminfo[i].si_boundto < filedata->dynamic_nent
12387 && VALID_DYNAMIC_NAME (filedata,
12388 filedata->dynamic_section[filedata->dynamic_syminfo[i].si_boundto].d_un.d_val))
12389 {
12390 print_symbol (10, GET_DYNAMIC_NAME (filedata,
12391 filedata->dynamic_section[filedata->dynamic_syminfo[i].si_boundto].d_un.d_val));
12392 putchar (' ' );
12393 }
12394 else
12395 printf ("%-10d ", filedata->dynamic_syminfo[i].si_boundto);
12396 break;
12397 }
12398
12399 if (flags & SYMINFO_FLG_DIRECT)
12400 printf (" DIRECT");
12401 if (flags & SYMINFO_FLG_PASSTHRU)
12402 printf (" PASSTHRU");
12403 if (flags & SYMINFO_FLG_COPY)
12404 printf (" COPY");
12405 if (flags & SYMINFO_FLG_LAZYLOAD)
12406 printf (" LAZYLOAD");
12407
12408 puts ("");
12409 }
12410
12411 return TRUE;
12412}
12413
12414/* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
12415 is contained by the region START .. END. The types of ADDR, START
12416 and END should all be the same. Note both ADDR + NELEM and END
12417 point to just beyond the end of the regions that are being tested. */
12418#define IN_RANGE(START,END,ADDR,NELEM) \
12419 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
12420
12421/* Check to see if the given reloc needs to be handled in a target specific
12422 manner. If so then process the reloc and return TRUE otherwise return
12423 FALSE.
12424
12425 If called with reloc == NULL, then this is a signal that reloc processing
12426 for the current section has finished, and any saved state should be
12427 discarded. */
12428
12429static bfd_boolean
12430target_specific_reloc_handling (Filedata * filedata,
12431 Elf_Internal_Rela * reloc,
12432 unsigned char * start,
12433 unsigned char * end,
12434 Elf_Internal_Sym * symtab,
12435 unsigned long num_syms)
12436{
12437 unsigned int reloc_type = 0;
12438 unsigned long sym_index = 0;
12439
12440 if (reloc)
12441 {
12442 reloc_type = get_reloc_type (filedata, reloc->r_info);
12443 sym_index = get_reloc_symindex (reloc->r_info);
12444 }
12445
12446 switch (filedata->file_header.e_machine)
12447 {
12448 case EM_MSP430:
12449 case EM_MSP430_OLD:
12450 {
12451 static Elf_Internal_Sym * saved_sym = NULL;
12452
12453 if (reloc == NULL)
12454 {
12455 saved_sym = NULL;
12456 return TRUE;
12457 }
12458
12459 switch (reloc_type)
12460 {
12461 case 10: /* R_MSP430_SYM_DIFF */
12462 if (uses_msp430x_relocs (filedata))
12463 break;
12464 /* Fall through. */
12465 case 21: /* R_MSP430X_SYM_DIFF */
12466 /* PR 21139. */
12467 if (sym_index >= num_syms)
12468 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12469 sym_index);
12470 else
12471 saved_sym = symtab + sym_index;
12472 return TRUE;
12473
12474 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12475 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12476 goto handle_sym_diff;
12477
12478 case 5: /* R_MSP430_16_BYTE */
12479 case 9: /* R_MSP430_8 */
12480 if (uses_msp430x_relocs (filedata))
12481 break;
12482 goto handle_sym_diff;
12483
12484 case 2: /* R_MSP430_ABS16 */
12485 case 15: /* R_MSP430X_ABS16 */
12486 if (! uses_msp430x_relocs (filedata))
12487 break;
12488 goto handle_sym_diff;
12489
12490 handle_sym_diff:
12491 if (saved_sym != NULL)
12492 {
12493 int reloc_size = reloc_type == 1 ? 4 : 2;
12494 bfd_vma value;
12495
12496 if (sym_index >= num_syms)
12497 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12498 sym_index);
12499 else
12500 {
12501 value = reloc->r_addend + (symtab[sym_index].st_value
12502 - saved_sym->st_value);
12503
12504 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12505 byte_put (start + reloc->r_offset, value, reloc_size);
12506 else
12507 /* PR 21137 */
12508 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12509 (long) reloc->r_offset);
12510 }
12511
12512 saved_sym = NULL;
12513 return TRUE;
12514 }
12515 break;
12516
12517 default:
12518 if (saved_sym != NULL)
12519 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12520 break;
12521 }
12522 break;
12523 }
12524
12525 case EM_MN10300:
12526 case EM_CYGNUS_MN10300:
12527 {
12528 static Elf_Internal_Sym * saved_sym = NULL;
12529
12530 if (reloc == NULL)
12531 {
12532 saved_sym = NULL;
12533 return TRUE;
12534 }
12535
12536 switch (reloc_type)
12537 {
12538 case 34: /* R_MN10300_ALIGN */
12539 return TRUE;
12540 case 33: /* R_MN10300_SYM_DIFF */
12541 if (sym_index >= num_syms)
12542 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12543 sym_index);
12544 else
12545 saved_sym = symtab + sym_index;
12546 return TRUE;
12547
12548 case 1: /* R_MN10300_32 */
12549 case 2: /* R_MN10300_16 */
12550 if (saved_sym != NULL)
12551 {
12552 int reloc_size = reloc_type == 1 ? 4 : 2;
12553 bfd_vma value;
12554
12555 if (sym_index >= num_syms)
12556 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12557 sym_index);
12558 else
12559 {
12560 value = reloc->r_addend + (symtab[sym_index].st_value
12561 - saved_sym->st_value);
12562
12563 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12564 byte_put (start + reloc->r_offset, value, reloc_size);
12565 else
12566 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12567 (long) reloc->r_offset);
12568 }
12569
12570 saved_sym = NULL;
12571 return TRUE;
12572 }
12573 break;
12574 default:
12575 if (saved_sym != NULL)
12576 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12577 break;
12578 }
12579 break;
12580 }
12581
12582 case EM_RL78:
12583 {
12584 static bfd_vma saved_sym1 = 0;
12585 static bfd_vma saved_sym2 = 0;
12586 static bfd_vma value;
12587
12588 if (reloc == NULL)
12589 {
12590 saved_sym1 = saved_sym2 = 0;
12591 return TRUE;
12592 }
12593
12594 switch (reloc_type)
12595 {
12596 case 0x80: /* R_RL78_SYM. */
12597 saved_sym1 = saved_sym2;
12598 if (sym_index >= num_syms)
12599 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12600 sym_index);
12601 else
12602 {
12603 saved_sym2 = symtab[sym_index].st_value;
12604 saved_sym2 += reloc->r_addend;
12605 }
12606 return TRUE;
12607
12608 case 0x83: /* R_RL78_OPsub. */
12609 value = saved_sym1 - saved_sym2;
12610 saved_sym2 = saved_sym1 = 0;
12611 return TRUE;
12612 break;
12613
12614 case 0x41: /* R_RL78_ABS32. */
12615 if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12616 byte_put (start + reloc->r_offset, value, 4);
12617 else
12618 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12619 (long) reloc->r_offset);
12620 value = 0;
12621 return TRUE;
12622
12623 case 0x43: /* R_RL78_ABS16. */
12624 if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12625 byte_put (start + reloc->r_offset, value, 2);
12626 else
12627 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12628 (long) reloc->r_offset);
12629 value = 0;
12630 return TRUE;
12631
12632 default:
12633 break;
12634 }
12635 break;
12636 }
12637 }
12638
12639 return FALSE;
12640}
12641
12642/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12643 DWARF debug sections. This is a target specific test. Note - we do not
12644 go through the whole including-target-headers-multiple-times route, (as
12645 we have already done with <elf/h8.h>) because this would become very
12646 messy and even then this function would have to contain target specific
12647 information (the names of the relocs instead of their numeric values).
12648 FIXME: This is not the correct way to solve this problem. The proper way
12649 is to have target specific reloc sizing and typing functions created by
12650 the reloc-macros.h header, in the same way that it already creates the
12651 reloc naming functions. */
12652
12653static bfd_boolean
12654is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12655{
12656 /* Please keep this table alpha-sorted for ease of visual lookup. */
12657 switch (filedata->file_header.e_machine)
12658 {
12659 case EM_386:
12660 case EM_IAMCU:
12661 return reloc_type == 1; /* R_386_32. */
12662 case EM_68K:
12663 return reloc_type == 1; /* R_68K_32. */
12664 case EM_860:
12665 return reloc_type == 1; /* R_860_32. */
12666 case EM_960:
12667 return reloc_type == 2; /* R_960_32. */
12668 case EM_AARCH64:
12669 return (reloc_type == 258
12670 || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12671 case EM_BPF:
12672 return reloc_type == 11; /* R_BPF_DATA_32 */
12673 case EM_ADAPTEVA_EPIPHANY:
12674 return reloc_type == 3;
12675 case EM_ALPHA:
12676 return reloc_type == 1; /* R_ALPHA_REFLONG. */
12677 case EM_ARC:
12678 return reloc_type == 1; /* R_ARC_32. */
12679 case EM_ARC_COMPACT:
12680 case EM_ARC_COMPACT2:
12681 return reloc_type == 4; /* R_ARC_32. */
12682 case EM_ARM:
12683 return reloc_type == 2; /* R_ARM_ABS32 */
12684 case EM_AVR_OLD:
12685 case EM_AVR:
12686 return reloc_type == 1;
12687 case EM_BLACKFIN:
12688 return reloc_type == 0x12; /* R_byte4_data. */
12689 case EM_CRIS:
12690 return reloc_type == 3; /* R_CRIS_32. */
12691 case EM_CR16:
12692 return reloc_type == 3; /* R_CR16_NUM32. */
12693 case EM_CRX:
12694 return reloc_type == 15; /* R_CRX_NUM32. */
12695 case EM_CSKY:
12696 return reloc_type == 1; /* R_CKCORE_ADDR32. */
12697 case EM_CYGNUS_FRV:
12698 return reloc_type == 1;
12699 case EM_CYGNUS_D10V:
12700 case EM_D10V:
12701 return reloc_type == 6; /* R_D10V_32. */
12702 case EM_CYGNUS_D30V:
12703 case EM_D30V:
12704 return reloc_type == 12; /* R_D30V_32_NORMAL. */
12705 case EM_DLX:
12706 return reloc_type == 3; /* R_DLX_RELOC_32. */
12707 case EM_CYGNUS_FR30:
12708 case EM_FR30:
12709 return reloc_type == 3; /* R_FR30_32. */
12710 case EM_FT32:
12711 return reloc_type == 1; /* R_FT32_32. */
12712 case EM_H8S:
12713 case EM_H8_300:
12714 case EM_H8_300H:
12715 return reloc_type == 1; /* R_H8_DIR32. */
12716 case EM_IA_64:
12717 return (reloc_type == 0x64 /* R_IA64_SECREL32MSB. */
12718 || reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
12719 || reloc_type == 0x24 /* R_IA64_DIR32MSB. */
12720 || reloc_type == 0x25 /* R_IA64_DIR32LSB. */);
12721 case EM_IP2K_OLD:
12722 case EM_IP2K:
12723 return reloc_type == 2; /* R_IP2K_32. */
12724 case EM_IQ2000:
12725 return reloc_type == 2; /* R_IQ2000_32. */
12726 case EM_LATTICEMICO32:
12727 return reloc_type == 3; /* R_LM32_32. */
12728 case EM_M32C_OLD:
12729 case EM_M32C:
12730 return reloc_type == 3; /* R_M32C_32. */
12731 case EM_M32R:
12732 return reloc_type == 34; /* R_M32R_32_RELA. */
12733 case EM_68HC11:
12734 case EM_68HC12:
12735 return reloc_type == 6; /* R_M68HC11_32. */
12736 case EM_S12Z:
12737 return reloc_type == 7 || /* R_S12Z_EXT32 */
12738 reloc_type == 6; /* R_S12Z_CW32. */
12739 case EM_MCORE:
12740 return reloc_type == 1; /* R_MCORE_ADDR32. */
12741 case EM_CYGNUS_MEP:
12742 return reloc_type == 4; /* R_MEP_32. */
12743 case EM_METAG:
12744 return reloc_type == 2; /* R_METAG_ADDR32. */
12745 case EM_MICROBLAZE:
12746 return reloc_type == 1; /* R_MICROBLAZE_32. */
12747 case EM_MIPS:
12748 return reloc_type == 2; /* R_MIPS_32. */
12749 case EM_MMIX:
12750 return reloc_type == 4; /* R_MMIX_32. */
12751 case EM_CYGNUS_MN10200:
12752 case EM_MN10200:
12753 return reloc_type == 1; /* R_MN10200_32. */
12754 case EM_CYGNUS_MN10300:
12755 case EM_MN10300:
12756 return reloc_type == 1; /* R_MN10300_32. */
12757 case EM_MOXIE:
12758 return reloc_type == 1; /* R_MOXIE_32. */
12759 case EM_MSP430_OLD:
12760 case EM_MSP430:
12761 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12762 case EM_MT:
12763 return reloc_type == 2; /* R_MT_32. */
12764 case EM_NDS32:
12765 return reloc_type == 20; /* R_NDS32_RELA. */
12766 case EM_ALTERA_NIOS2:
12767 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
12768 case EM_NIOS32:
12769 return reloc_type == 1; /* R_NIOS_32. */
12770 case EM_OR1K:
12771 return reloc_type == 1; /* R_OR1K_32. */
12772 case EM_PARISC:
12773 return (reloc_type == 1 /* R_PARISC_DIR32. */
12774 || reloc_type == 2 /* R_PARISC_DIR21L. */
12775 || reloc_type == 41); /* R_PARISC_SECREL32. */
12776 case EM_PJ:
12777 case EM_PJ_OLD:
12778 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
12779 case EM_PPC64:
12780 return reloc_type == 1; /* R_PPC64_ADDR32. */
12781 case EM_PPC:
12782 return reloc_type == 1; /* R_PPC_ADDR32. */
12783 case EM_TI_PRU:
12784 return reloc_type == 11; /* R_PRU_BFD_RELOC_32. */
12785 case EM_RISCV:
12786 return reloc_type == 1; /* R_RISCV_32. */
12787 case EM_RL78:
12788 return reloc_type == 1; /* R_RL78_DIR32. */
12789 case EM_RX:
12790 return reloc_type == 1; /* R_RX_DIR32. */
12791 case EM_S370:
12792 return reloc_type == 1; /* R_I370_ADDR31. */
12793 case EM_S390_OLD:
12794 case EM_S390:
12795 return reloc_type == 4; /* R_S390_32. */
12796 case EM_SCORE:
12797 return reloc_type == 8; /* R_SCORE_ABS32. */
12798 case EM_SH:
12799 return reloc_type == 1; /* R_SH_DIR32. */
12800 case EM_SPARC32PLUS:
12801 case EM_SPARCV9:
12802 case EM_SPARC:
12803 return reloc_type == 3 /* R_SPARC_32. */
12804 || reloc_type == 23; /* R_SPARC_UA32. */
12805 case EM_SPU:
12806 return reloc_type == 6; /* R_SPU_ADDR32 */
12807 case EM_TI_C6000:
12808 return reloc_type == 1; /* R_C6000_ABS32. */
12809 case EM_TILEGX:
12810 return reloc_type == 2; /* R_TILEGX_32. */
12811 case EM_TILEPRO:
12812 return reloc_type == 1; /* R_TILEPRO_32. */
12813 case EM_CYGNUS_V850:
12814 case EM_V850:
12815 return reloc_type == 6; /* R_V850_ABS32. */
12816 case EM_V800:
12817 return reloc_type == 0x33; /* R_V810_WORD. */
12818 case EM_VAX:
12819 return reloc_type == 1; /* R_VAX_32. */
12820 case EM_VISIUM:
12821 return reloc_type == 3; /* R_VISIUM_32. */
12822 case EM_WEBASSEMBLY:
12823 return reloc_type == 1; /* R_WASM32_32. */
12824 case EM_X86_64:
12825 case EM_L1OM:
12826 case EM_K1OM:
12827 return reloc_type == 10; /* R_X86_64_32. */
12828 case EM_XC16X:
12829 case EM_C166:
12830 return reloc_type == 3; /* R_XC16C_ABS_32. */
12831 case EM_XGATE:
12832 return reloc_type == 4; /* R_XGATE_32. */
12833 case EM_XSTORMY16:
12834 return reloc_type == 1; /* R_XSTROMY16_32. */
12835 case EM_XTENSA_OLD:
12836 case EM_XTENSA:
12837 return reloc_type == 1; /* R_XTENSA_32. */
12838 case EM_Z80:
12839 return reloc_type == 6; /* R_Z80_32. */
12840 default:
12841 {
12842 static unsigned int prev_warn = 0;
12843
12844 /* Avoid repeating the same warning multiple times. */
12845 if (prev_warn != filedata->file_header.e_machine)
12846 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12847 filedata->file_header.e_machine);
12848 prev_warn = filedata->file_header.e_machine;
12849 return FALSE;
12850 }
12851 }
12852}
12853
12854/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12855 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12856
12857static bfd_boolean
12858is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12859{
12860 switch (filedata->file_header.e_machine)
12861 /* Please keep this table alpha-sorted for ease of visual lookup. */
12862 {
12863 case EM_386:
12864 case EM_IAMCU:
12865 return reloc_type == 2; /* R_386_PC32. */
12866 case EM_68K:
12867 return reloc_type == 4; /* R_68K_PC32. */
12868 case EM_AARCH64:
12869 return reloc_type == 261; /* R_AARCH64_PREL32 */
12870 case EM_ADAPTEVA_EPIPHANY:
12871 return reloc_type == 6;
12872 case EM_ALPHA:
12873 return reloc_type == 10; /* R_ALPHA_SREL32. */
12874 case EM_ARC_COMPACT:
12875 case EM_ARC_COMPACT2:
12876 return reloc_type == 49; /* R_ARC_32_PCREL. */
12877 case EM_ARM:
12878 return reloc_type == 3; /* R_ARM_REL32 */
12879 case EM_AVR_OLD:
12880 case EM_AVR:
12881 return reloc_type == 36; /* R_AVR_32_PCREL. */
12882 case EM_MICROBLAZE:
12883 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
12884 case EM_OR1K:
12885 return reloc_type == 9; /* R_OR1K_32_PCREL. */
12886 case EM_PARISC:
12887 return reloc_type == 9; /* R_PARISC_PCREL32. */
12888 case EM_PPC:
12889 return reloc_type == 26; /* R_PPC_REL32. */
12890 case EM_PPC64:
12891 return reloc_type == 26; /* R_PPC64_REL32. */
12892 case EM_RISCV:
12893 return reloc_type == 57; /* R_RISCV_32_PCREL. */
12894 case EM_S390_OLD:
12895 case EM_S390:
12896 return reloc_type == 5; /* R_390_PC32. */
12897 case EM_SH:
12898 return reloc_type == 2; /* R_SH_REL32. */
12899 case EM_SPARC32PLUS:
12900 case EM_SPARCV9:
12901 case EM_SPARC:
12902 return reloc_type == 6; /* R_SPARC_DISP32. */
12903 case EM_SPU:
12904 return reloc_type == 13; /* R_SPU_REL32. */
12905 case EM_TILEGX:
12906 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
12907 case EM_TILEPRO:
12908 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
12909 case EM_VISIUM:
12910 return reloc_type == 6; /* R_VISIUM_32_PCREL */
12911 case EM_X86_64:
12912 case EM_L1OM:
12913 case EM_K1OM:
12914 return reloc_type == 2; /* R_X86_64_PC32. */
12915 case EM_VAX:
12916 return reloc_type == 4; /* R_VAX_PCREL32. */
12917 case EM_XTENSA_OLD:
12918 case EM_XTENSA:
12919 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
12920 default:
12921 /* Do not abort or issue an error message here. Not all targets use
12922 pc-relative 32-bit relocs in their DWARF debug information and we
12923 have already tested for target coverage in is_32bit_abs_reloc. A
12924 more helpful warning message will be generated by apply_relocations
12925 anyway, so just return. */
12926 return FALSE;
12927 }
12928}
12929
12930/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12931 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12932
12933static bfd_boolean
12934is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12935{
12936 switch (filedata->file_header.e_machine)
12937 {
12938 case EM_AARCH64:
12939 return reloc_type == 257; /* R_AARCH64_ABS64. */
12940 case EM_ALPHA:
12941 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
12942 case EM_IA_64:
12943 return (reloc_type == 0x26 /* R_IA64_DIR64MSB. */
12944 || reloc_type == 0x27 /* R_IA64_DIR64LSB. */);
12945 case EM_PARISC:
12946 return reloc_type == 80; /* R_PARISC_DIR64. */
12947 case EM_PPC64:
12948 return reloc_type == 38; /* R_PPC64_ADDR64. */
12949 case EM_RISCV:
12950 return reloc_type == 2; /* R_RISCV_64. */
12951 case EM_SPARC32PLUS:
12952 case EM_SPARCV9:
12953 case EM_SPARC:
12954 return reloc_type == 32 /* R_SPARC_64. */
12955 || reloc_type == 54; /* R_SPARC_UA64. */
12956 case EM_X86_64:
12957 case EM_L1OM:
12958 case EM_K1OM:
12959 return reloc_type == 1; /* R_X86_64_64. */
12960 case EM_S390_OLD:
12961 case EM_S390:
12962 return reloc_type == 22; /* R_S390_64. */
12963 case EM_TILEGX:
12964 return reloc_type == 1; /* R_TILEGX_64. */
12965 case EM_MIPS:
12966 return reloc_type == 18; /* R_MIPS_64. */
12967 default:
12968 return FALSE;
12969 }
12970}
12971
12972/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12973 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12974
12975static bfd_boolean
12976is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12977{
12978 switch (filedata->file_header.e_machine)
12979 {
12980 case EM_AARCH64:
12981 return reloc_type == 260; /* R_AARCH64_PREL64. */
12982 case EM_ALPHA:
12983 return reloc_type == 11; /* R_ALPHA_SREL64. */
12984 case EM_IA_64:
12985 return (reloc_type == 0x4e /* R_IA64_PCREL64MSB. */
12986 || reloc_type == 0x4f /* R_IA64_PCREL64LSB. */);
12987 case EM_PARISC:
12988 return reloc_type == 72; /* R_PARISC_PCREL64. */
12989 case EM_PPC64:
12990 return reloc_type == 44; /* R_PPC64_REL64. */
12991 case EM_SPARC32PLUS:
12992 case EM_SPARCV9:
12993 case EM_SPARC:
12994 return reloc_type == 46; /* R_SPARC_DISP64. */
12995 case EM_X86_64:
12996 case EM_L1OM:
12997 case EM_K1OM:
12998 return reloc_type == 24; /* R_X86_64_PC64. */
12999 case EM_S390_OLD:
13000 case EM_S390:
13001 return reloc_type == 23; /* R_S390_PC64. */
13002 case EM_TILEGX:
13003 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
13004 default:
13005 return FALSE;
13006 }
13007}
13008
13009/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13010 a 24-bit absolute RELA relocation used in DWARF debug sections. */
13011
13012static bfd_boolean
13013is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
13014{
13015 switch (filedata->file_header.e_machine)
13016 {
13017 case EM_CYGNUS_MN10200:
13018 case EM_MN10200:
13019 return reloc_type == 4; /* R_MN10200_24. */
13020 case EM_FT32:
13021 return reloc_type == 5; /* R_FT32_20. */
13022 case EM_Z80:
13023 return reloc_type == 5; /* R_Z80_24. */
13024 default:
13025 return FALSE;
13026 }
13027}
13028
13029/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13030 a 16-bit absolute RELA relocation used in DWARF debug sections. */
13031
13032static bfd_boolean
13033is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
13034{
13035 /* Please keep this table alpha-sorted for ease of visual lookup. */
13036 switch (filedata->file_header.e_machine)
13037 {
13038 case EM_ARC:
13039 case EM_ARC_COMPACT:
13040 case EM_ARC_COMPACT2:
13041 return reloc_type == 2; /* R_ARC_16. */
13042 case EM_ADAPTEVA_EPIPHANY:
13043 return reloc_type == 5;
13044 case EM_AVR_OLD:
13045 case EM_AVR:
13046 return reloc_type == 4; /* R_AVR_16. */
13047 case EM_CYGNUS_D10V:
13048 case EM_D10V:
13049 return reloc_type == 3; /* R_D10V_16. */
13050 case EM_FT32:
13051 return reloc_type == 2; /* R_FT32_16. */
13052 case EM_H8S:
13053 case EM_H8_300:
13054 case EM_H8_300H:
13055 return reloc_type == R_H8_DIR16;
13056 case EM_IP2K_OLD:
13057 case EM_IP2K:
13058 return reloc_type == 1; /* R_IP2K_16. */
13059 case EM_M32C_OLD:
13060 case EM_M32C:
13061 return reloc_type == 1; /* R_M32C_16 */
13062 case EM_CYGNUS_MN10200:
13063 case EM_MN10200:
13064 return reloc_type == 2; /* R_MN10200_16. */
13065 case EM_CYGNUS_MN10300:
13066 case EM_MN10300:
13067 return reloc_type == 2; /* R_MN10300_16. */
13068 case EM_MSP430:
13069 if (uses_msp430x_relocs (filedata))
13070 return reloc_type == 2; /* R_MSP430_ABS16. */
13071 /* Fall through. */
13072 case EM_MSP430_OLD:
13073 return reloc_type == 5; /* R_MSP430_16_BYTE. */
13074 case EM_NDS32:
13075 return reloc_type == 19; /* R_NDS32_RELA. */
13076 case EM_ALTERA_NIOS2:
13077 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
13078 case EM_NIOS32:
13079 return reloc_type == 9; /* R_NIOS_16. */
13080 case EM_OR1K:
13081 return reloc_type == 2; /* R_OR1K_16. */
13082 case EM_RISCV:
13083 return reloc_type == 55; /* R_RISCV_SET16. */
13084 case EM_TI_PRU:
13085 return reloc_type == 8; /* R_PRU_BFD_RELOC_16. */
13086 case EM_TI_C6000:
13087 return reloc_type == 2; /* R_C6000_ABS16. */
13088 case EM_VISIUM:
13089 return reloc_type == 2; /* R_VISIUM_16. */
13090 case EM_XC16X:
13091 case EM_C166:
13092 return reloc_type == 2; /* R_XC16C_ABS_16. */
13093 case EM_XGATE:
13094 return reloc_type == 3; /* R_XGATE_16. */
13095 case EM_Z80:
13096 return reloc_type == 4; /* R_Z80_16. */
13097 default:
13098 return FALSE;
13099 }
13100}
13101
13102/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13103 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13104
13105static bfd_boolean
13106is_8bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
13107{
13108 switch (filedata->file_header.e_machine)
13109 {
13110 case EM_RISCV:
13111 return reloc_type == 54; /* R_RISCV_SET8. */
13112 case EM_Z80:
13113 return reloc_type == 1; /* R_Z80_8. */
13114 default:
13115 return FALSE;
13116 }
13117}
13118
13119/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13120 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13121
13122static bfd_boolean
13123is_6bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
13124{
13125 switch (filedata->file_header.e_machine)
13126 {
13127 case EM_RISCV:
13128 return reloc_type == 53; /* R_RISCV_SET6. */
13129 default:
13130 return FALSE;
13131 }
13132}
13133
13134/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13135 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13136
13137static bfd_boolean
13138is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13139{
13140 /* Please keep this table alpha-sorted for ease of visual lookup. */
13141 switch (filedata->file_header.e_machine)
13142 {
13143 case EM_RISCV:
13144 return reloc_type == 35; /* R_RISCV_ADD32. */
13145 default:
13146 return FALSE;
13147 }
13148}
13149
13150/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13151 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13152
13153static bfd_boolean
13154is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13155{
13156 /* Please keep this table alpha-sorted for ease of visual lookup. */
13157 switch (filedata->file_header.e_machine)
13158 {
13159 case EM_RISCV:
13160 return reloc_type == 39; /* R_RISCV_SUB32. */
13161 default:
13162 return FALSE;
13163 }
13164}
13165
13166/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13167 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13168
13169static bfd_boolean
13170is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13171{
13172 /* Please keep this table alpha-sorted for ease of visual lookup. */
13173 switch (filedata->file_header.e_machine)
13174 {
13175 case EM_RISCV:
13176 return reloc_type == 36; /* R_RISCV_ADD64. */
13177 default:
13178 return FALSE;
13179 }
13180}
13181
13182/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13183 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13184
13185static bfd_boolean
13186is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13187{
13188 /* Please keep this table alpha-sorted for ease of visual lookup. */
13189 switch (filedata->file_header.e_machine)
13190 {
13191 case EM_RISCV:
13192 return reloc_type == 40; /* R_RISCV_SUB64. */
13193 default:
13194 return FALSE;
13195 }
13196}
13197
13198/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13199 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13200
13201static bfd_boolean
13202is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13203{
13204 /* Please keep this table alpha-sorted for ease of visual lookup. */
13205 switch (filedata->file_header.e_machine)
13206 {
13207 case EM_RISCV:
13208 return reloc_type == 34; /* R_RISCV_ADD16. */
13209 default:
13210 return FALSE;
13211 }
13212}
13213
13214/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13215 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13216
13217static bfd_boolean
13218is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13219{
13220 /* Please keep this table alpha-sorted for ease of visual lookup. */
13221 switch (filedata->file_header.e_machine)
13222 {
13223 case EM_RISCV:
13224 return reloc_type == 38; /* R_RISCV_SUB16. */
13225 default:
13226 return FALSE;
13227 }
13228}
13229
13230/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13231 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13232
13233static bfd_boolean
13234is_8bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13235{
13236 /* Please keep this table alpha-sorted for ease of visual lookup. */
13237 switch (filedata->file_header.e_machine)
13238 {
13239 case EM_RISCV:
13240 return reloc_type == 33; /* R_RISCV_ADD8. */
13241 default:
13242 return FALSE;
13243 }
13244}
13245
13246/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13247 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13248
13249static bfd_boolean
13250is_8bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13251{
13252 /* Please keep this table alpha-sorted for ease of visual lookup. */
13253 switch (filedata->file_header.e_machine)
13254 {
13255 case EM_RISCV:
13256 return reloc_type == 37; /* R_RISCV_SUB8. */
13257 default:
13258 return FALSE;
13259 }
13260}
13261
13262/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13263 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13264
13265static bfd_boolean
13266is_6bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13267{
13268 switch (filedata->file_header.e_machine)
13269 {
13270 case EM_RISCV:
13271 return reloc_type == 52; /* R_RISCV_SUB6. */
13272 default:
13273 return FALSE;
13274 }
13275}
13276
13277/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13278 relocation entries (possibly formerly used for SHT_GROUP sections). */
13279
13280static bfd_boolean
13281is_none_reloc (Filedata * filedata, unsigned int reloc_type)
13282{
13283 switch (filedata->file_header.e_machine)
13284 {
13285 case EM_386: /* R_386_NONE. */
13286 case EM_68K: /* R_68K_NONE. */
13287 case EM_ADAPTEVA_EPIPHANY:
13288 case EM_ALPHA: /* R_ALPHA_NONE. */
13289 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
13290 case EM_ARC: /* R_ARC_NONE. */
13291 case EM_ARC_COMPACT2: /* R_ARC_NONE. */
13292 case EM_ARC_COMPACT: /* R_ARC_NONE. */
13293 case EM_ARM: /* R_ARM_NONE. */
13294 case EM_C166: /* R_XC16X_NONE. */
13295 case EM_CRIS: /* R_CRIS_NONE. */
13296 case EM_FT32: /* R_FT32_NONE. */
13297 case EM_IA_64: /* R_IA64_NONE. */
13298 case EM_K1OM: /* R_X86_64_NONE. */
13299 case EM_L1OM: /* R_X86_64_NONE. */
13300 case EM_M32R: /* R_M32R_NONE. */
13301 case EM_MIPS: /* R_MIPS_NONE. */
13302 case EM_MN10300: /* R_MN10300_NONE. */
13303 case EM_MOXIE: /* R_MOXIE_NONE. */
13304 case EM_NIOS32: /* R_NIOS_NONE. */
13305 case EM_OR1K: /* R_OR1K_NONE. */
13306 case EM_PARISC: /* R_PARISC_NONE. */
13307 case EM_PPC64: /* R_PPC64_NONE. */
13308 case EM_PPC: /* R_PPC_NONE. */
13309 case EM_RISCV: /* R_RISCV_NONE. */
13310 case EM_S390: /* R_390_NONE. */
13311 case EM_S390_OLD:
13312 case EM_SH: /* R_SH_NONE. */
13313 case EM_SPARC32PLUS:
13314 case EM_SPARC: /* R_SPARC_NONE. */
13315 case EM_SPARCV9:
13316 case EM_TILEGX: /* R_TILEGX_NONE. */
13317 case EM_TILEPRO: /* R_TILEPRO_NONE. */
13318 case EM_TI_C6000:/* R_C6000_NONE. */
13319 case EM_X86_64: /* R_X86_64_NONE. */
13320 case EM_XC16X:
13321 case EM_Z80: /* R_Z80_NONE. */
13322 case EM_WEBASSEMBLY: /* R_WASM32_NONE. */
13323 return reloc_type == 0;
13324
13325 case EM_AARCH64:
13326 return reloc_type == 0 || reloc_type == 256;
13327 case EM_AVR_OLD:
13328 case EM_AVR:
13329 return (reloc_type == 0 /* R_AVR_NONE. */
13330 || reloc_type == 30 /* R_AVR_DIFF8. */
13331 || reloc_type == 31 /* R_AVR_DIFF16. */
13332 || reloc_type == 32 /* R_AVR_DIFF32. */);
13333 case EM_METAG:
13334 return reloc_type == 3; /* R_METAG_NONE. */
13335 case EM_NDS32:
13336 return (reloc_type == 0 /* R_XTENSA_NONE. */
13337 || reloc_type == 204 /* R_NDS32_DIFF8. */
13338 || reloc_type == 205 /* R_NDS32_DIFF16. */
13339 || reloc_type == 206 /* R_NDS32_DIFF32. */
13340 || reloc_type == 207 /* R_NDS32_ULEB128. */);
13341 case EM_TI_PRU:
13342 return (reloc_type == 0 /* R_PRU_NONE. */
13343 || reloc_type == 65 /* R_PRU_DIFF8. */
13344 || reloc_type == 66 /* R_PRU_DIFF16. */
13345 || reloc_type == 67 /* R_PRU_DIFF32. */);
13346 case EM_XTENSA_OLD:
13347 case EM_XTENSA:
13348 return (reloc_type == 0 /* R_XTENSA_NONE. */
13349 || reloc_type == 17 /* R_XTENSA_DIFF8. */
13350 || reloc_type == 18 /* R_XTENSA_DIFF16. */
13351 || reloc_type == 19 /* R_XTENSA_DIFF32. */
13352 || reloc_type == 57 /* R_XTENSA_PDIFF8. */
13353 || reloc_type == 58 /* R_XTENSA_PDIFF16. */
13354 || reloc_type == 59 /* R_XTENSA_PDIFF32. */
13355 || reloc_type == 60 /* R_XTENSA_NDIFF8. */
13356 || reloc_type == 61 /* R_XTENSA_NDIFF16. */
13357 || reloc_type == 62 /* R_XTENSA_NDIFF32. */);
13358 }
13359 return FALSE;
13360}
13361
13362/* Returns TRUE if there is a relocation against
13363 section NAME at OFFSET bytes. */
13364
13365bfd_boolean
13366reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
13367{
13368 Elf_Internal_Rela * relocs;
13369 Elf_Internal_Rela * rp;
13370
13371 if (dsec == NULL || dsec->reloc_info == NULL)
13372 return FALSE;
13373
13374 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
13375
13376 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
13377 if (rp->r_offset == offset)
13378 return TRUE;
13379
13380 return FALSE;
13381}
13382
13383/* Apply relocations to a section.
13384 Returns TRUE upon success, FALSE otherwise.
13385 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13386 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13387 will be set to the number of relocs loaded.
13388
13389 Note: So far support has been added only for those relocations
13390 which can be found in debug sections. FIXME: Add support for
13391 more relocations ? */
13392
13393static bfd_boolean
13394apply_relocations (Filedata * filedata,
13395 const Elf_Internal_Shdr * section,
13396 unsigned char * start,
13397 bfd_size_type size,
13398 void ** relocs_return,
13399 unsigned long * num_relocs_return)
13400{
13401 Elf_Internal_Shdr * relsec;
13402 unsigned char * end = start + size;
13403
13404 if (relocs_return != NULL)
13405 {
13406 * (Elf_Internal_Rela **) relocs_return = NULL;
13407 * num_relocs_return = 0;
13408 }
13409
13410 if (filedata->file_header.e_type != ET_REL)
13411 /* No relocs to apply. */
13412 return TRUE;
13413
13414 /* Find the reloc section associated with the section. */
13415 for (relsec = filedata->section_headers;
13416 relsec < filedata->section_headers + filedata->file_header.e_shnum;
13417 ++relsec)
13418 {
13419 bfd_boolean is_rela;
13420 unsigned long num_relocs;
13421 Elf_Internal_Rela * relocs;
13422 Elf_Internal_Rela * rp;
13423 Elf_Internal_Shdr * symsec;
13424 Elf_Internal_Sym * symtab;
13425 unsigned long num_syms;
13426 Elf_Internal_Sym * sym;
13427
13428 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13429 || relsec->sh_info >= filedata->file_header.e_shnum
13430 || filedata->section_headers + relsec->sh_info != section
13431 || relsec->sh_size == 0
13432 || relsec->sh_link >= filedata->file_header.e_shnum)
13433 continue;
13434
13435 symsec = filedata->section_headers + relsec->sh_link;
13436 if (symsec->sh_type != SHT_SYMTAB
13437 && symsec->sh_type != SHT_DYNSYM)
13438 return FALSE;
13439
13440 is_rela = relsec->sh_type == SHT_RELA;
13441
13442 if (is_rela)
13443 {
13444 if (!slurp_rela_relocs (filedata, relsec->sh_offset,
13445 relsec->sh_size, & relocs, & num_relocs))
13446 return FALSE;
13447 }
13448 else
13449 {
13450 if (!slurp_rel_relocs (filedata, relsec->sh_offset,
13451 relsec->sh_size, & relocs, & num_relocs))
13452 return FALSE;
13453 }
13454
13455 /* SH uses RELA but uses in place value instead of the addend field. */
13456 if (filedata->file_header.e_machine == EM_SH)
13457 is_rela = FALSE;
13458
13459 symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
13460
13461 for (rp = relocs; rp < relocs + num_relocs; ++rp)
13462 {
13463 bfd_vma addend;
13464 unsigned int reloc_type;
13465 unsigned int reloc_size;
13466 bfd_boolean reloc_inplace = FALSE;
13467 bfd_boolean reloc_subtract = FALSE;
13468 unsigned char * rloc;
13469 unsigned long sym_index;
13470
13471 reloc_type = get_reloc_type (filedata, rp->r_info);
13472
13473 if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
13474 continue;
13475 else if (is_none_reloc (filedata, reloc_type))
13476 continue;
13477 else if (is_32bit_abs_reloc (filedata, reloc_type)
13478 || is_32bit_pcrel_reloc (filedata, reloc_type))
13479 reloc_size = 4;
13480 else if (is_64bit_abs_reloc (filedata, reloc_type)
13481 || is_64bit_pcrel_reloc (filedata, reloc_type))
13482 reloc_size = 8;
13483 else if (is_24bit_abs_reloc (filedata, reloc_type))
13484 reloc_size = 3;
13485 else if (is_16bit_abs_reloc (filedata, reloc_type))
13486 reloc_size = 2;
13487 else if (is_8bit_abs_reloc (filedata, reloc_type)
13488 || is_6bit_abs_reloc (filedata, reloc_type))
13489 reloc_size = 1;
13490 else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
13491 reloc_type))
13492 || is_32bit_inplace_add_reloc (filedata, reloc_type))
13493 {
13494 reloc_size = 4;
13495 reloc_inplace = TRUE;
13496 }
13497 else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
13498 reloc_type))
13499 || is_64bit_inplace_add_reloc (filedata, reloc_type))
13500 {
13501 reloc_size = 8;
13502 reloc_inplace = TRUE;
13503 }
13504 else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
13505 reloc_type))
13506 || is_16bit_inplace_add_reloc (filedata, reloc_type))
13507 {
13508 reloc_size = 2;
13509 reloc_inplace = TRUE;
13510 }
13511 else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
13512 reloc_type))
13513 || is_8bit_inplace_add_reloc (filedata, reloc_type))
13514 {
13515 reloc_size = 1;
13516 reloc_inplace = TRUE;
13517 }
13518 else if ((reloc_subtract = is_6bit_inplace_sub_reloc (filedata,
13519 reloc_type)))
13520 {
13521 reloc_size = 1;
13522 reloc_inplace = TRUE;
13523 }
13524 else
13525 {
13526 static unsigned int prev_reloc = 0;
13527
13528 if (reloc_type != prev_reloc)
13529 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13530 reloc_type, printable_section_name (filedata, section));
13531 prev_reloc = reloc_type;
13532 continue;
13533 }
13534
13535 rloc = start + rp->r_offset;
13536 if (!IN_RANGE (start, end, rloc, reloc_size))
13537 {
13538 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13539 (unsigned long) rp->r_offset,
13540 printable_section_name (filedata, section));
13541 continue;
13542 }
13543
13544 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
13545 if (sym_index >= num_syms)
13546 {
13547 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13548 sym_index, printable_section_name (filedata, section));
13549 continue;
13550 }
13551 sym = symtab + sym_index;
13552
13553 /* If the reloc has a symbol associated with it,
13554 make sure that it is of an appropriate type.
13555
13556 Relocations against symbols without type can happen.
13557 Gcc -feliminate-dwarf2-dups may generate symbols
13558 without type for debug info.
13559
13560 Icc generates relocations against function symbols
13561 instead of local labels.
13562
13563 Relocations against object symbols can happen, eg when
13564 referencing a global array. For an example of this see
13565 the _clz.o binary in libgcc.a. */
13566 if (sym != symtab
13567 && ELF_ST_TYPE (sym->st_info) != STT_COMMON
13568 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
13569 {
13570 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13571 get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
13572 printable_section_name (filedata, relsec),
13573 (long int)(rp - relocs));
13574 continue;
13575 }
13576
13577 addend = 0;
13578 if (is_rela)
13579 addend += rp->r_addend;
13580 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13581 partial_inplace. */
13582 if (!is_rela
13583 || (filedata->file_header.e_machine == EM_XTENSA
13584 && reloc_type == 1)
13585 || ((filedata->file_header.e_machine == EM_PJ
13586 || filedata->file_header.e_machine == EM_PJ_OLD)
13587 && reloc_type == 1)
13588 || ((filedata->file_header.e_machine == EM_D30V
13589 || filedata->file_header.e_machine == EM_CYGNUS_D30V)
13590 && reloc_type == 12)
13591 || reloc_inplace)
13592 {
13593 if (is_6bit_inplace_sub_reloc (filedata, reloc_type))
13594 addend += byte_get (rloc, reloc_size) & 0x3f;
13595 else
13596 addend += byte_get (rloc, reloc_size);
13597 }
13598
13599 if (is_32bit_pcrel_reloc (filedata, reloc_type)
13600 || is_64bit_pcrel_reloc (filedata, reloc_type))
13601 {
13602 /* On HPPA, all pc-relative relocations are biased by 8. */
13603 if (filedata->file_header.e_machine == EM_PARISC)
13604 addend -= 8;
13605 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
13606 reloc_size);
13607 }
13608 else if (is_6bit_abs_reloc (filedata, reloc_type)
13609 || is_6bit_inplace_sub_reloc (filedata, reloc_type))
13610 {
13611 if (reloc_subtract)
13612 addend -= sym->st_value;
13613 else
13614 addend += sym->st_value;
13615 addend = (addend & 0x3f) | (byte_get (rloc, reloc_size) & 0xc0);
13616 byte_put (rloc, addend, reloc_size);
13617 }
13618 else if (reloc_subtract)
13619 byte_put (rloc, addend - sym->st_value, reloc_size);
13620 else
13621 byte_put (rloc, addend + sym->st_value, reloc_size);
13622 }
13623
13624 free (symtab);
13625 /* Let the target specific reloc processing code know that
13626 we have finished with these relocs. */
13627 target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
13628
13629 if (relocs_return)
13630 {
13631 * (Elf_Internal_Rela **) relocs_return = relocs;
13632 * num_relocs_return = num_relocs;
13633 }
13634 else
13635 free (relocs);
13636
13637 break;
13638 }
13639
13640 return TRUE;
13641}
13642
13643#ifdef SUPPORT_DISASSEMBLY
13644static bfd_boolean
13645disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
13646{
13647 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
13648
13649 /* FIXME: XXX -- to be done --- XXX */
13650
13651 return TRUE;
13652}
13653#endif
13654
13655/* Reads in the contents of SECTION from FILE, returning a pointer
13656 to a malloc'ed buffer or NULL if something went wrong. */
13657
13658static char *
13659get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
13660{
13661 bfd_size_type num_bytes = section->sh_size;
13662
13663 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
13664 {
13665 printf (_("Section '%s' has no data to dump.\n"),
13666 printable_section_name (filedata, section));
13667 return NULL;
13668 }
13669
13670 return (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
13671 _("section contents"));
13672}
13673
13674/* Uncompresses a section that was compressed using zlib, in place. */
13675
13676static bfd_boolean
13677uncompress_section_contents (unsigned char ** buffer,
13678 dwarf_size_type uncompressed_size,
13679 dwarf_size_type * size)
13680{
13681 dwarf_size_type compressed_size = *size;
13682 unsigned char * compressed_buffer = *buffer;
13683 unsigned char * uncompressed_buffer;
13684 z_stream strm;
13685 int rc;
13686
13687 /* It is possible the section consists of several compressed
13688 buffers concatenated together, so we uncompress in a loop. */
13689 /* PR 18313: The state field in the z_stream structure is supposed
13690 to be invisible to the user (ie us), but some compilers will
13691 still complain about it being used without initialisation. So
13692 we first zero the entire z_stream structure and then set the fields
13693 that we need. */
13694 memset (& strm, 0, sizeof strm);
13695 strm.avail_in = compressed_size;
13696 strm.next_in = (Bytef *) compressed_buffer;
13697 strm.avail_out = uncompressed_size;
13698 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
13699
13700 rc = inflateInit (& strm);
13701 while (strm.avail_in > 0)
13702 {
13703 if (rc != Z_OK)
13704 goto fail;
13705 strm.next_out = ((Bytef *) uncompressed_buffer
13706 + (uncompressed_size - strm.avail_out));
13707 rc = inflate (&strm, Z_FINISH);
13708 if (rc != Z_STREAM_END)
13709 goto fail;
13710 rc = inflateReset (& strm);
13711 }
13712 rc = inflateEnd (& strm);
13713 if (rc != Z_OK
13714 || strm.avail_out != 0)
13715 goto fail;
13716
13717 *buffer = uncompressed_buffer;
13718 *size = uncompressed_size;
13719 return TRUE;
13720
13721 fail:
13722 free (uncompressed_buffer);
13723 /* Indicate decompression failure. */
13724 *buffer = NULL;
13725 return FALSE;
13726}
13727
13728static bfd_boolean
13729dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
13730{
13731 Elf_Internal_Shdr * relsec;
13732 bfd_size_type num_bytes;
13733 unsigned char * data;
13734 unsigned char * end;
13735 unsigned char * real_start;
13736 unsigned char * start;
13737 bfd_boolean some_strings_shown;
13738
13739 real_start = start = (unsigned char *) get_section_contents (section, filedata);
13740 if (start == NULL)
13741 /* PR 21820: Do not fail if the section was empty. */
13742 return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13743
13744 num_bytes = section->sh_size;
13745
13746 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
13747
13748 if (decompress_dumps)
13749 {
13750 dwarf_size_type new_size = num_bytes;
13751 dwarf_size_type uncompressed_size = 0;
13752
13753 if ((section->sh_flags & SHF_COMPRESSED) != 0)
13754 {
13755 Elf_Internal_Chdr chdr;
13756 unsigned int compression_header_size
13757 = get_compression_header (& chdr, (unsigned char *) start,
13758 num_bytes);
13759 if (compression_header_size == 0)
13760 /* An error message will have already been generated
13761 by get_compression_header. */
13762 goto error_out;
13763
13764 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13765 {
13766 warn (_("section '%s' has unsupported compress type: %d\n"),
13767 printable_section_name (filedata, section), chdr.ch_type);
13768 goto error_out;
13769 }
13770 uncompressed_size = chdr.ch_size;
13771 start += compression_header_size;
13772 new_size -= compression_header_size;
13773 }
13774 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13775 {
13776 /* Read the zlib header. In this case, it should be "ZLIB"
13777 followed by the uncompressed section size, 8 bytes in
13778 big-endian order. */
13779 uncompressed_size = start[4]; uncompressed_size <<= 8;
13780 uncompressed_size += start[5]; uncompressed_size <<= 8;
13781 uncompressed_size += start[6]; uncompressed_size <<= 8;
13782 uncompressed_size += start[7]; uncompressed_size <<= 8;
13783 uncompressed_size += start[8]; uncompressed_size <<= 8;
13784 uncompressed_size += start[9]; uncompressed_size <<= 8;
13785 uncompressed_size += start[10]; uncompressed_size <<= 8;
13786 uncompressed_size += start[11];
13787 start += 12;
13788 new_size -= 12;
13789 }
13790
13791 if (uncompressed_size)
13792 {
13793 if (uncompress_section_contents (& start,
13794 uncompressed_size, & new_size))
13795 num_bytes = new_size;
13796 else
13797 {
13798 error (_("Unable to decompress section %s\n"),
13799 printable_section_name (filedata, section));
13800 goto error_out;
13801 }
13802 }
13803 else
13804 start = real_start;
13805 }
13806
13807 /* If the section being dumped has relocations against it the user might
13808 be expecting these relocations to have been applied. Check for this
13809 case and issue a warning message in order to avoid confusion.
13810 FIXME: Maybe we ought to have an option that dumps a section with
13811 relocs applied ? */
13812 for (relsec = filedata->section_headers;
13813 relsec < filedata->section_headers + filedata->file_header.e_shnum;
13814 ++relsec)
13815 {
13816 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13817 || relsec->sh_info >= filedata->file_header.e_shnum
13818 || filedata->section_headers + relsec->sh_info != section
13819 || relsec->sh_size == 0
13820 || relsec->sh_link >= filedata->file_header.e_shnum)
13821 continue;
13822
13823 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13824 break;
13825 }
13826
13827 data = start;
13828 end = start + num_bytes;
13829 some_strings_shown = FALSE;
13830
13831#ifdef HAVE_MBSTATE_T
13832 mbstate_t state;
13833 /* Initialise the multibyte conversion state. */
13834 memset (& state, 0, sizeof (state));
13835#endif
13836
13837 bfd_boolean continuing = FALSE;
13838
13839 while (data < end)
13840 {
13841 while (!ISPRINT (* data))
13842 if (++ data >= end)
13843 break;
13844
13845 if (data < end)
13846 {
13847 size_t maxlen = end - data;
13848
13849 if (continuing)
13850 {
13851 printf (" ");
13852 continuing = FALSE;
13853 }
13854 else
13855 {
13856#ifndef __MSVCRT__
13857 /* PR 11128: Use two separate invocations in order to work
13858 around bugs in the Solaris 8 implementation of printf. */
13859 printf (" [%6tx] ", data - start);
13860#else
13861 printf (" [%6Ix] ", (size_t) (data - start));
13862#endif
13863 }
13864
13865 if (maxlen > 0)
13866 {
13867 char c;
13868
13869 while (maxlen)
13870 {
13871 c = *data++;
13872
13873 if (c == 0)
13874 break;
13875
13876 /* PR 25543: Treat new-lines as string-ending characters. */
13877 if (c == '\n')
13878 {
13879 printf ("\\n\n");
13880 if (*data != 0)
13881 continuing = TRUE;
13882 break;
13883 }
13884
13885 /* Do not print control characters directly as they can affect terminal
13886 settings. Such characters usually appear in the names generated
13887 by the assembler for local labels. */
13888 if (ISCNTRL (c))
13889 {
13890 printf ("^%c", c + 0x40);
13891 }
13892 else if (ISPRINT (c))
13893 {
13894 putchar (c);
13895 }
13896 else
13897 {
13898 size_t n;
13899#ifdef HAVE_MBSTATE_T
13900 wchar_t w;
13901#endif
13902 /* Let printf do the hard work of displaying multibyte characters. */
13903 printf ("%.1s", data - 1);
13904#ifdef HAVE_MBSTATE_T
13905 /* Try to find out how many bytes made up the character that was
13906 just printed. Advance the symbol pointer past the bytes that
13907 were displayed. */
13908 n = mbrtowc (& w, (char *)(data - 1), MB_CUR_MAX, & state);
13909#else
13910 n = 1;
13911#endif
13912 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
13913 data += (n - 1);
13914 }
13915 }
13916
13917 if (c != '\n')
13918 putchar ('\n');
13919 }
13920 else
13921 {
13922 printf (_("<corrupt>\n"));
13923 data = end;
13924 }
13925 some_strings_shown = TRUE;
13926 }
13927 }
13928
13929 if (! some_strings_shown)
13930 printf (_(" No strings found in this section."));
13931
13932 free (real_start);
13933
13934 putchar ('\n');
13935 return TRUE;
13936
13937error_out:
13938 free (real_start);
13939 return FALSE;
13940}
13941
13942static bfd_boolean
13943dump_section_as_bytes (Elf_Internal_Shdr * section,
13944 Filedata * filedata,
13945 bfd_boolean relocate)
13946{
13947 Elf_Internal_Shdr * relsec;
13948 bfd_size_type bytes;
13949 bfd_size_type section_size;
13950 bfd_vma addr;
13951 unsigned char * data;
13952 unsigned char * real_start;
13953 unsigned char * start;
13954
13955 real_start = start = (unsigned char *) get_section_contents (section, filedata);
13956 if (start == NULL)
13957 /* PR 21820: Do not fail if the section was empty. */
13958 return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13959
13960 section_size = section->sh_size;
13961
13962 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
13963
13964 if (decompress_dumps)
13965 {
13966 dwarf_size_type new_size = section_size;
13967 dwarf_size_type uncompressed_size = 0;
13968
13969 if ((section->sh_flags & SHF_COMPRESSED) != 0)
13970 {
13971 Elf_Internal_Chdr chdr;
13972 unsigned int compression_header_size
13973 = get_compression_header (& chdr, start, section_size);
13974
13975 if (compression_header_size == 0)
13976 /* An error message will have already been generated
13977 by get_compression_header. */
13978 goto error_out;
13979
13980 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13981 {
13982 warn (_("section '%s' has unsupported compress type: %d\n"),
13983 printable_section_name (filedata, section), chdr.ch_type);
13984 goto error_out;
13985 }
13986 uncompressed_size = chdr.ch_size;
13987 start += compression_header_size;
13988 new_size -= compression_header_size;
13989 }
13990 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13991 {
13992 /* Read the zlib header. In this case, it should be "ZLIB"
13993 followed by the uncompressed section size, 8 bytes in
13994 big-endian order. */
13995 uncompressed_size = start[4]; uncompressed_size <<= 8;
13996 uncompressed_size += start[5]; uncompressed_size <<= 8;
13997 uncompressed_size += start[6]; uncompressed_size <<= 8;
13998 uncompressed_size += start[7]; uncompressed_size <<= 8;
13999 uncompressed_size += start[8]; uncompressed_size <<= 8;
14000 uncompressed_size += start[9]; uncompressed_size <<= 8;
14001 uncompressed_size += start[10]; uncompressed_size <<= 8;
14002 uncompressed_size += start[11];
14003 start += 12;
14004 new_size -= 12;
14005 }
14006
14007 if (uncompressed_size)
14008 {
14009 if (uncompress_section_contents (& start, uncompressed_size,
14010 & new_size))
14011 {
14012 section_size = new_size;
14013 }
14014 else
14015 {
14016 error (_("Unable to decompress section %s\n"),
14017 printable_section_name (filedata, section));
14018 /* FIXME: Print the section anyway ? */
14019 goto error_out;
14020 }
14021 }
14022 else
14023 start = real_start;
14024 }
14025
14026 if (relocate)
14027 {
14028 if (! apply_relocations (filedata, section, start, section_size, NULL, NULL))
14029 goto error_out;
14030 }
14031 else
14032 {
14033 /* If the section being dumped has relocations against it the user might
14034 be expecting these relocations to have been applied. Check for this
14035 case and issue a warning message in order to avoid confusion.
14036 FIXME: Maybe we ought to have an option that dumps a section with
14037 relocs applied ? */
14038 for (relsec = filedata->section_headers;
14039 relsec < filedata->section_headers + filedata->file_header.e_shnum;
14040 ++relsec)
14041 {
14042 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
14043 || relsec->sh_info >= filedata->file_header.e_shnum
14044 || filedata->section_headers + relsec->sh_info != section
14045 || relsec->sh_size == 0
14046 || relsec->sh_link >= filedata->file_header.e_shnum)
14047 continue;
14048
14049 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14050 break;
14051 }
14052 }
14053
14054 addr = section->sh_addr;
14055 bytes = section_size;
14056 data = start;
14057
14058 while (bytes)
14059 {
14060 int j;
14061 int k;
14062 int lbytes;
14063
14064 lbytes = (bytes > 16 ? 16 : bytes);
14065
14066 printf (" 0x%8.8lx ", (unsigned long) addr);
14067
14068 for (j = 0; j < 16; j++)
14069 {
14070 if (j < lbytes)
14071 printf ("%2.2x", data[j]);
14072 else
14073 printf (" ");
14074
14075 if ((j & 3) == 3)
14076 printf (" ");
14077 }
14078
14079 for (j = 0; j < lbytes; j++)
14080 {
14081 k = data[j];
14082 if (k >= ' ' && k < 0x7f)
14083 printf ("%c", k);
14084 else
14085 printf (".");
14086 }
14087
14088 putchar ('\n');
14089
14090 data += lbytes;
14091 addr += lbytes;
14092 bytes -= lbytes;
14093 }
14094
14095 free (real_start);
14096
14097 putchar ('\n');
14098 return TRUE;
14099
14100 error_out:
14101 free (real_start);
14102 return FALSE;
14103}
14104
14105static ctf_sect_t *
14106shdr_to_ctf_sect (ctf_sect_t *buf, Elf_Internal_Shdr *shdr, Filedata *filedata)
14107{
14108 buf->cts_name = SECTION_NAME (shdr);
14109 buf->cts_size = shdr->sh_size;
14110 buf->cts_entsize = shdr->sh_entsize;
14111
14112 return buf;
14113}
14114
14115/* Formatting callback function passed to ctf_dump. Returns either the pointer
14116 it is passed, or a pointer to newly-allocated storage, in which case
14117 dump_ctf() will free it when it no longer needs it. */
14118
14119static char *dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED,
14120 char *s, void *arg)
14121{
14122 const char *blanks = arg;
14123 char *new_s;
14124
14125 if (asprintf (&new_s, "%s%s", blanks, s) < 0)
14126 return s;
14127 return new_s;
14128}
14129
14130static bfd_boolean
14131dump_section_as_ctf (Elf_Internal_Shdr * section, Filedata * filedata)
14132{
14133 Elf_Internal_Shdr * parent_sec = NULL;
14134 Elf_Internal_Shdr * symtab_sec = NULL;
14135 Elf_Internal_Shdr * strtab_sec = NULL;
14136 void * data = NULL;
14137 void * symdata = NULL;
14138 void * strdata = NULL;
14139 void * parentdata = NULL;
14140 ctf_sect_t ctfsect, symsect, strsect, parentsect;
14141 ctf_sect_t * symsectp = NULL;
14142 ctf_sect_t * strsectp = NULL;
14143 ctf_file_t * ctf = NULL;
14144 ctf_file_t * parent = NULL;
14145
14146 const char *things[] = {"Header", "Labels", "Data objects",
14147 "Function objects", "Variables", "Types", "Strings",
14148 ""};
14149 const char **thing;
14150 int err;
14151 bfd_boolean ret = FALSE;
14152 size_t i;
14153
14154 shdr_to_ctf_sect (&ctfsect, section, filedata);
14155 data = get_section_contents (section, filedata);
14156 ctfsect.cts_data = data;
14157
14158 if (!dump_ctf_symtab_name)
14159 dump_ctf_symtab_name = strdup (".symtab");
14160
14161 if (!dump_ctf_strtab_name)
14162 dump_ctf_strtab_name = strdup (".strtab");
14163
14164 if (dump_ctf_symtab_name && dump_ctf_symtab_name[0] != 0)
14165 {
14166 if ((symtab_sec = find_section (filedata, dump_ctf_symtab_name)) == NULL)
14167 {
14168 error (_("No symbol section named %s\n"), dump_ctf_symtab_name);
14169 goto fail;
14170 }
14171 if ((symdata = (void *) get_data (NULL, filedata,
14172 symtab_sec->sh_offset, 1,
14173 symtab_sec->sh_size,
14174 _("symbols"))) == NULL)
14175 goto fail;
14176 symsectp = shdr_to_ctf_sect (&symsect, symtab_sec, filedata);
14177 symsect.cts_data = symdata;
14178 }
14179 if (dump_ctf_strtab_name && dump_ctf_symtab_name[0] != 0)
14180 {
14181 if ((strtab_sec = find_section (filedata, dump_ctf_strtab_name)) == NULL)
14182 {
14183 error (_("No string table section named %s\n"),
14184 dump_ctf_strtab_name);
14185 goto fail;
14186 }
14187 if ((strdata = (void *) get_data (NULL, filedata,
14188 strtab_sec->sh_offset, 1,
14189 strtab_sec->sh_size,
14190 _("strings"))) == NULL)
14191 goto fail;
14192 strsectp = shdr_to_ctf_sect (&strsect, strtab_sec, filedata);
14193 strsect.cts_data = strdata;
14194 }
14195 if (dump_ctf_parent_name)
14196 {
14197 if ((parent_sec = find_section (filedata, dump_ctf_parent_name)) == NULL)
14198 {
14199 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name);
14200 goto fail;
14201 }
14202 if ((parentdata = (void *) get_data (NULL, filedata,
14203 parent_sec->sh_offset, 1,
14204 parent_sec->sh_size,
14205 _("CTF parent"))) == NULL)
14206 goto fail;
14207 shdr_to_ctf_sect (&parentsect, parent_sec, filedata);
14208 parentsect.cts_data = parentdata;
14209 }
14210
14211 /* Load the CTF file and dump it. */
14212
14213 if ((ctf = ctf_bufopen (&ctfsect, symsectp, strsectp, &err)) == NULL)
14214 {
14215 error (_("CTF open failure: %s\n"), ctf_errmsg (err));
14216 goto fail;
14217 }
14218
14219 if (parentdata)
14220 {
14221 if ((parent = ctf_bufopen (&parentsect, symsectp, strsectp, &err)) == NULL)
14222 {
14223 error (_("CTF open failure: %s\n"), ctf_errmsg (err));
14224 goto fail;
14225 }
14226
14227 ctf_import (ctf, parent);
14228 }
14229
14230 ret = TRUE;
14231
14232 printf (_("\nDump of CTF section '%s':\n"),
14233 printable_section_name (filedata, section));
14234
14235 for (i = 0, thing = things; *thing[0]; thing++, i++)
14236 {
14237 ctf_dump_state_t *s = NULL;
14238 char *item;
14239
14240 printf ("\n %s:\n", *thing);
14241 while ((item = ctf_dump (ctf, &s, i, dump_ctf_indent_lines,
14242 (void *) " ")) != NULL)
14243 {
14244 printf ("%s\n", item);
14245 free (item);
14246 }
14247
14248 if (ctf_errno (ctf))
14249 {
14250 error (_("Iteration failed: %s, %s\n"), *thing,
14251 ctf_errmsg (ctf_errno (ctf)));
14252 ret = FALSE;
14253 }
14254 }
14255
14256 fail:
14257 ctf_file_close (ctf);
14258 ctf_file_close (parent);
14259 free (parentdata);
14260 free (data);
14261 free (symdata);
14262 free (strdata);
14263 return ret;
14264}
14265
14266static bfd_boolean
14267load_specific_debug_section (enum dwarf_section_display_enum debug,
14268 const Elf_Internal_Shdr * sec,
14269 void * data)
14270{
14271 struct dwarf_section * section = &debug_displays [debug].section;
14272 char buf [64];
14273 Filedata * filedata = (Filedata *) data;
14274
14275 if (section->start != NULL)
14276 {
14277 /* If it is already loaded, do nothing. */
14278 if (streq (section->filename, filedata->file_name))
14279 return TRUE;
14280 free (section->start);
14281 }
14282
14283 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
14284 section->address = sec->sh_addr;
14285 section->user_data = NULL;
14286 section->filename = filedata->file_name;
14287 section->start = (unsigned char *) get_data (NULL, filedata,
14288 sec->sh_offset, 1,
14289 sec->sh_size, buf);
14290 if (section->start == NULL)
14291 section->size = 0;
14292 else
14293 {
14294 unsigned char *start = section->start;
14295 dwarf_size_type size = sec->sh_size;
14296 dwarf_size_type uncompressed_size = 0;
14297
14298 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
14299 {
14300 Elf_Internal_Chdr chdr;
14301 unsigned int compression_header_size;
14302
14303 if (size < (is_32bit_elf
14304 ? sizeof (Elf32_External_Chdr)
14305 : sizeof (Elf64_External_Chdr)))
14306 {
14307 warn (_("compressed section %s is too small to contain a compression header\n"),
14308 section->name);
14309 return FALSE;
14310 }
14311
14312 compression_header_size = get_compression_header (&chdr, start, size);
14313 if (compression_header_size == 0)
14314 /* An error message will have already been generated
14315 by get_compression_header. */
14316 return FALSE;
14317
14318 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
14319 {
14320 warn (_("section '%s' has unsupported compress type: %d\n"),
14321 section->name, chdr.ch_type);
14322 return FALSE;
14323 }
14324 uncompressed_size = chdr.ch_size;
14325 start += compression_header_size;
14326 size -= compression_header_size;
14327 }
14328 else if (size > 12 && streq ((char *) start, "ZLIB"))
14329 {
14330 /* Read the zlib header. In this case, it should be "ZLIB"
14331 followed by the uncompressed section size, 8 bytes in
14332 big-endian order. */
14333 uncompressed_size = start[4]; uncompressed_size <<= 8;
14334 uncompressed_size += start[5]; uncompressed_size <<= 8;
14335 uncompressed_size += start[6]; uncompressed_size <<= 8;
14336 uncompressed_size += start[7]; uncompressed_size <<= 8;
14337 uncompressed_size += start[8]; uncompressed_size <<= 8;
14338 uncompressed_size += start[9]; uncompressed_size <<= 8;
14339 uncompressed_size += start[10]; uncompressed_size <<= 8;
14340 uncompressed_size += start[11];
14341 start += 12;
14342 size -= 12;
14343 }
14344
14345 if (uncompressed_size)
14346 {
14347 if (uncompress_section_contents (&start, uncompressed_size,
14348 &size))
14349 {
14350 /* Free the compressed buffer, update the section buffer
14351 and the section size if uncompress is successful. */
14352 free (section->start);
14353 section->start = start;
14354 }
14355 else
14356 {
14357 error (_("Unable to decompress section %s\n"),
14358 printable_section_name (filedata, sec));
14359 return FALSE;
14360 }
14361 }
14362
14363 section->size = size;
14364 }
14365
14366 if (section->start == NULL)
14367 return FALSE;
14368
14369 if (debug_displays [debug].relocate)
14370 {
14371 if (! apply_relocations (filedata, sec, section->start, section->size,
14372 & section->reloc_info, & section->num_relocs))
14373 return FALSE;
14374 }
14375 else
14376 {
14377 section->reloc_info = NULL;
14378 section->num_relocs = 0;
14379 }
14380
14381 return TRUE;
14382}
14383
14384#if HAVE_LIBDEBUGINFOD
14385/* Return a hex string representation of the build-id. */
14386unsigned char *
14387get_build_id (void * data)
14388{
14389 Filedata * filedata = (Filedata *)data;
14390 Elf_Internal_Shdr * shdr;
14391 unsigned long i;
14392
14393 /* Iterate through notes to find note.gnu.build-id.
14394 FIXME: Only the first note in any note section is examined. */
14395 for (i = 0, shdr = filedata->section_headers;
14396 i < filedata->file_header.e_shnum && shdr != NULL;
14397 i++, shdr++)
14398 {
14399 if (shdr->sh_type != SHT_NOTE)
14400 continue;
14401
14402 char * next;
14403 char * end;
14404 size_t data_remaining;
14405 size_t min_notesz;
14406 Elf_External_Note * enote;
14407 Elf_Internal_Note inote;
14408
14409 bfd_vma offset = shdr->sh_offset;
14410 bfd_vma align = shdr->sh_addralign;
14411 bfd_vma length = shdr->sh_size;
14412
14413 enote = (Elf_External_Note *) get_section_contents (shdr, filedata);
14414 if (enote == NULL)
14415 continue;
14416
14417 if (align < 4)
14418 align = 4;
14419 else if (align != 4 && align != 8)
14420 {
14421 free (enote);
14422 continue;
14423 }
14424
14425 end = (char *) enote + length;
14426 data_remaining = end - (char *) enote;
14427
14428 if (!is_ia64_vms (filedata))
14429 {
14430 min_notesz = offsetof (Elf_External_Note, name);
14431 if (data_remaining < min_notesz)
14432 {
14433 warn (_("\
14434malformed note encountered in section %s whilst scanning for build-id note\n"),
14435 printable_section_name (filedata, shdr));
14436 free (enote);
14437 continue;
14438 }
14439 data_remaining -= min_notesz;
14440
14441 inote.type = BYTE_GET (enote->type);
14442 inote.namesz = BYTE_GET (enote->namesz);
14443 inote.namedata = enote->name;
14444 inote.descsz = BYTE_GET (enote->descsz);
14445 inote.descdata = ((char *) enote
14446 + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
14447 inote.descpos = offset + (inote.descdata - (char *) enote);
14448 next = ((char *) enote
14449 + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
14450 }
14451 else
14452 {
14453 Elf64_External_VMS_Note *vms_enote;
14454
14455 /* PR binutils/15191
14456 Make sure that there is enough data to read. */
14457 min_notesz = offsetof (Elf64_External_VMS_Note, name);
14458 if (data_remaining < min_notesz)
14459 {
14460 warn (_("\
14461malformed note encountered in section %s whilst scanning for build-id note\n"),
14462 printable_section_name (filedata, shdr));
14463 free (enote);
14464 continue;
14465 }
14466 data_remaining -= min_notesz;
14467
14468 vms_enote = (Elf64_External_VMS_Note *) enote;
14469 inote.type = BYTE_GET (vms_enote->type);
14470 inote.namesz = BYTE_GET (vms_enote->namesz);
14471 inote.namedata = vms_enote->name;
14472 inote.descsz = BYTE_GET (vms_enote->descsz);
14473 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
14474 inote.descpos = offset + (inote.descdata - (char *) enote);
14475 next = inote.descdata + align_power (inote.descsz, 3);
14476 }
14477
14478 /* Skip malformed notes. */
14479 if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
14480 || (size_t) (inote.descdata - inote.namedata) > data_remaining
14481 || (size_t) (next - inote.descdata) < inote.descsz
14482 || ((size_t) (next - inote.descdata)
14483 > data_remaining - (size_t) (inote.descdata - inote.namedata)))
14484 {
14485 warn (_("\
14486malformed note encountered in section %s whilst scanning for build-id note\n"),
14487 printable_section_name (filedata, shdr));
14488 free (enote);
14489 continue;
14490 }
14491
14492 /* Check if this is the build-id note. If so then convert the build-id
14493 bytes to a hex string. */
14494 if (inote.namesz > 0
14495 && const_strneq (inote.namedata, "GNU")
14496 && inote.type == NT_GNU_BUILD_ID)
14497 {
14498 unsigned long j;
14499 char * build_id;
14500
14501 build_id = malloc (inote.descsz * 2 + 1);
14502 if (build_id == NULL)
14503 {
14504 free (enote);
14505 return NULL;
14506 }
14507
14508 for (j = 0; j < inote.descsz; ++j)
14509 sprintf (build_id + (j * 2), "%02x", inote.descdata[j] & 0xff);
14510 build_id[inote.descsz * 2] = '\0';
14511 free (enote);
14512
14513 return (unsigned char *) build_id;
14514 }
14515 free (enote);
14516 }
14517
14518 return NULL;
14519}
14520#endif /* HAVE_LIBDEBUGINFOD */
14521
14522/* If this is not NULL, load_debug_section will only look for sections
14523 within the list of sections given here. */
14524static unsigned int * section_subset = NULL;
14525
14526bfd_boolean
14527load_debug_section (enum dwarf_section_display_enum debug, void * data)
14528{
14529 struct dwarf_section * section = &debug_displays [debug].section;
14530 Elf_Internal_Shdr * sec;
14531 Filedata * filedata = (Filedata *) data;
14532
14533 /* Without section headers we cannot find any sections. */
14534 if (filedata->section_headers == NULL)
14535 return FALSE;
14536
14537 if (filedata->string_table == NULL
14538 && filedata->file_header.e_shstrndx != SHN_UNDEF
14539 && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
14540 {
14541 Elf_Internal_Shdr * strs;
14542
14543 /* Read in the string table, so that we have section names to scan. */
14544 strs = filedata->section_headers + filedata->file_header.e_shstrndx;
14545
14546 if (strs != NULL && strs->sh_size != 0)
14547 {
14548 filedata->string_table
14549 = (char *) get_data (NULL, filedata, strs->sh_offset,
14550 1, strs->sh_size, _("string table"));
14551
14552 filedata->string_table_length
14553 = filedata->string_table != NULL ? strs->sh_size : 0;
14554 }
14555 }
14556
14557 /* Locate the debug section. */
14558 sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
14559 if (sec != NULL)
14560 section->name = section->uncompressed_name;
14561 else
14562 {
14563 sec = find_section_in_set (filedata, section->compressed_name, section_subset);
14564 if (sec != NULL)
14565 section->name = section->compressed_name;
14566 }
14567 if (sec == NULL)
14568 return FALSE;
14569
14570 /* If we're loading from a subset of sections, and we've loaded
14571 a section matching this name before, it's likely that it's a
14572 different one. */
14573 if (section_subset != NULL)
14574 free_debug_section (debug);
14575
14576 return load_specific_debug_section (debug, sec, data);
14577}
14578
14579void
14580free_debug_section (enum dwarf_section_display_enum debug)
14581{
14582 struct dwarf_section * section = &debug_displays [debug].section;
14583
14584 if (section->start == NULL)
14585 return;
14586
14587 free ((char *) section->start);
14588 section->start = NULL;
14589 section->address = 0;
14590 section->size = 0;
14591
14592 if (section->reloc_info != NULL)
14593 {
14594 free (section->reloc_info);
14595 section->reloc_info = NULL;
14596 section->num_relocs = 0;
14597 }
14598}
14599
14600static bfd_boolean
14601display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
14602{
14603 char * name = SECTION_NAME (section);
14604 const char * print_name = printable_section_name (filedata, section);
14605 bfd_size_type length;
14606 bfd_boolean result = TRUE;
14607 int i;
14608
14609 length = section->sh_size;
14610 if (length == 0)
14611 {
14612 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
14613 return TRUE;
14614 }
14615 if (section->sh_type == SHT_NOBITS)
14616 {
14617 /* There is no point in dumping the contents of a debugging section
14618 which has the NOBITS type - the bits in the file will be random.
14619 This can happen when a file containing a .eh_frame section is
14620 stripped with the --only-keep-debug command line option. */
14621 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14622 print_name);
14623 return FALSE;
14624 }
14625
14626 if (const_strneq (name, ".gnu.linkonce.wi."))
14627 name = ".debug_info";
14628
14629 /* See if we know how to display the contents of this section. */
14630 for (i = 0; i < max; i++)
14631 {
14632 enum dwarf_section_display_enum id = (enum dwarf_section_display_enum) i;
14633 struct dwarf_section_display * display = debug_displays + i;
14634 struct dwarf_section * sec = & display->section;
14635
14636 if (streq (sec->uncompressed_name, name)
14637 || (id == line && const_strneq (name, ".debug_line."))
14638 || streq (sec->compressed_name, name))
14639 {
14640 bfd_boolean secondary = (section != find_section (filedata, name));
14641
14642 if (secondary)
14643 free_debug_section (id);
14644
14645 if (i == line && const_strneq (name, ".debug_line."))
14646 sec->name = name;
14647 else if (streq (sec->uncompressed_name, name))
14648 sec->name = sec->uncompressed_name;
14649 else
14650 sec->name = sec->compressed_name;
14651
14652 if (load_specific_debug_section (id, section, filedata))
14653 {
14654 /* If this debug section is part of a CU/TU set in a .dwp file,
14655 restrict load_debug_section to the sections in that set. */
14656 section_subset = find_cu_tu_set (filedata, shndx);
14657
14658 result &= display->display (sec, filedata);
14659
14660 section_subset = NULL;
14661
14662 if (secondary || (id != info && id != abbrev))
14663 free_debug_section (id);
14664 }
14665 break;
14666 }
14667 }
14668
14669 if (i == max)
14670 {
14671 printf (_("Unrecognized debug section: %s\n"), print_name);
14672 result = FALSE;
14673 }
14674
14675 return result;
14676}
14677
14678/* Set DUMP_SECTS for all sections where dumps were requested
14679 based on section name. */
14680
14681static void
14682initialise_dumps_byname (Filedata * filedata)
14683{
14684 struct dump_list_entry * cur;
14685
14686 for (cur = dump_sects_byname; cur; cur = cur->next)
14687 {
14688 unsigned int i;
14689 bfd_boolean any = FALSE;
14690
14691 for (i = 0; i < filedata->file_header.e_shnum; i++)
14692 if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
14693 {
14694 request_dump_bynumber (&filedata->dump, i, cur->type);
14695 any = TRUE;
14696 }
14697
14698 if (!any)
14699 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14700 cur->name);
14701 }
14702}
14703
14704static bfd_boolean
14705process_section_contents (Filedata * filedata)
14706{
14707 Elf_Internal_Shdr * section;
14708 unsigned int i;
14709 bfd_boolean res = TRUE;
14710
14711 if (! do_dump)
14712 return TRUE;
14713
14714 initialise_dumps_byname (filedata);
14715
14716 for (i = 0, section = filedata->section_headers;
14717 i < filedata->file_header.e_shnum && i < filedata->dump.num_dump_sects;
14718 i++, section++)
14719 {
14720 dump_type dump = filedata->dump.dump_sects[i];
14721
14722#ifdef SUPPORT_DISASSEMBLY
14723 if (dump & DISASS_DUMP)
14724 {
14725 if (! disassemble_section (section, filedata))
14726 res = FALSE;
14727 }
14728#endif
14729 if (dump & HEX_DUMP)
14730 {
14731 if (! dump_section_as_bytes (section, filedata, FALSE))
14732 res = FALSE;
14733 }
14734
14735 if (dump & RELOC_DUMP)
14736 {
14737 if (! dump_section_as_bytes (section, filedata, TRUE))
14738 res = FALSE;
14739 }
14740
14741 if (dump & STRING_DUMP)
14742 {
14743 if (! dump_section_as_strings (section, filedata))
14744 res = FALSE;
14745 }
14746
14747 if (dump & DEBUG_DUMP)
14748 {
14749 if (! display_debug_section (i, section, filedata))
14750 res = FALSE;
14751 }
14752
14753 if (dump & CTF_DUMP)
14754 {
14755 if (! dump_section_as_ctf (section, filedata))
14756 res = FALSE;
14757 }
14758 }
14759
14760 /* Check to see if the user requested a
14761 dump of a section that does not exist. */
14762 while (i < filedata->dump.num_dump_sects)
14763 {
14764 if (filedata->dump.dump_sects[i])
14765 {
14766 warn (_("Section %d was not dumped because it does not exist!\n"), i);
14767 res = FALSE;
14768 }
14769 i++;
14770 }
14771
14772 return res;
14773}
14774
14775static void
14776process_mips_fpe_exception (int mask)
14777{
14778 if (mask)
14779 {
14780 bfd_boolean first = TRUE;
14781
14782 if (mask & OEX_FPU_INEX)
14783 fputs ("INEX", stdout), first = FALSE;
14784 if (mask & OEX_FPU_UFLO)
14785 printf ("%sUFLO", first ? "" : "|"), first = FALSE;
14786 if (mask & OEX_FPU_OFLO)
14787 printf ("%sOFLO", first ? "" : "|"), first = FALSE;
14788 if (mask & OEX_FPU_DIV0)
14789 printf ("%sDIV0", first ? "" : "|"), first = FALSE;
14790 if (mask & OEX_FPU_INVAL)
14791 printf ("%sINVAL", first ? "" : "|");
14792 }
14793 else
14794 fputs ("0", stdout);
14795}
14796
14797/* Display's the value of TAG at location P. If TAG is
14798 greater than 0 it is assumed to be an unknown tag, and
14799 a message is printed to this effect. Otherwise it is
14800 assumed that a message has already been printed.
14801
14802 If the bottom bit of TAG is set it assumed to have a
14803 string value, otherwise it is assumed to have an integer
14804 value.
14805
14806 Returns an updated P pointing to the first unread byte
14807 beyond the end of TAG's value.
14808
14809 Reads at or beyond END will not be made. */
14810
14811static unsigned char *
14812display_tag_value (signed int tag,
14813 unsigned char * p,
14814 const unsigned char * const end)
14815{
14816 unsigned long val;
14817
14818 if (tag > 0)
14819 printf (" Tag_unknown_%d: ", tag);
14820
14821 if (p >= end)
14822 {
14823 warn (_("<corrupt tag>\n"));
14824 }
14825 else if (tag & 1)
14826 {
14827 /* PR 17531 file: 027-19978-0.004. */
14828 size_t maxlen = (end - p) - 1;
14829
14830 putchar ('"');
14831 if (maxlen > 0)
14832 {
14833 print_symbol ((int) maxlen, (const char *) p);
14834 p += strnlen ((char *) p, maxlen) + 1;
14835 }
14836 else
14837 {
14838 printf (_("<corrupt string tag>"));
14839 p = (unsigned char *) end;
14840 }
14841 printf ("\"\n");
14842 }
14843 else
14844 {
14845 READ_ULEB (val, p, end);
14846 printf ("%ld (0x%lx)\n", val, val);
14847 }
14848
14849 assert (p <= end);
14850 return p;
14851}
14852
14853/* ARC ABI attributes section. */
14854
14855static unsigned char *
14856display_arc_attribute (unsigned char * p,
14857 const unsigned char * const end)
14858{
14859 unsigned int tag;
14860 unsigned int val;
14861
14862 READ_ULEB (tag, p, end);
14863
14864 switch (tag)
14865 {
14866 case Tag_ARC_PCS_config:
14867 READ_ULEB (val, p, end);
14868 printf (" Tag_ARC_PCS_config: ");
14869 switch (val)
14870 {
14871 case 0:
14872 printf (_("Absent/Non standard\n"));
14873 break;
14874 case 1:
14875 printf (_("Bare metal/mwdt\n"));
14876 break;
14877 case 2:
14878 printf (_("Bare metal/newlib\n"));
14879 break;
14880 case 3:
14881 printf (_("Linux/uclibc\n"));
14882 break;
14883 case 4:
14884 printf (_("Linux/glibc\n"));
14885 break;
14886 default:
14887 printf (_("Unknown\n"));
14888 break;
14889 }
14890 break;
14891
14892 case Tag_ARC_CPU_base:
14893 READ_ULEB (val, p, end);
14894 printf (" Tag_ARC_CPU_base: ");
14895 switch (val)
14896 {
14897 default:
14898 case TAG_CPU_NONE:
14899 printf (_("Absent\n"));
14900 break;
14901 case TAG_CPU_ARC6xx:
14902 printf ("ARC6xx\n");
14903 break;
14904 case TAG_CPU_ARC7xx:
14905 printf ("ARC7xx\n");
14906 break;
14907 case TAG_CPU_ARCEM:
14908 printf ("ARCEM\n");
14909 break;
14910 case TAG_CPU_ARCHS:
14911 printf ("ARCHS\n");
14912 break;
14913 }
14914 break;
14915
14916 case Tag_ARC_CPU_variation:
14917 READ_ULEB (val, p, end);
14918 printf (" Tag_ARC_CPU_variation: ");
14919 switch (val)
14920 {
14921 default:
14922 if (val > 0 && val < 16)
14923 printf ("Core%d\n", val);
14924 else
14925 printf ("Unknown\n");
14926 break;
14927
14928 case 0:
14929 printf (_("Absent\n"));
14930 break;
14931 }
14932 break;
14933
14934 case Tag_ARC_CPU_name:
14935 printf (" Tag_ARC_CPU_name: ");
14936 p = display_tag_value (-1, p, end);
14937 break;
14938
14939 case Tag_ARC_ABI_rf16:
14940 READ_ULEB (val, p, end);
14941 printf (" Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
14942 break;
14943
14944 case Tag_ARC_ABI_osver:
14945 READ_ULEB (val, p, end);
14946 printf (" Tag_ARC_ABI_osver: v%d\n", val);
14947 break;
14948
14949 case Tag_ARC_ABI_pic:
14950 case Tag_ARC_ABI_sda:
14951 READ_ULEB (val, p, end);
14952 printf (tag == Tag_ARC_ABI_sda ? " Tag_ARC_ABI_sda: "
14953 : " Tag_ARC_ABI_pic: ");
14954 switch (val)
14955 {
14956 case 0:
14957 printf (_("Absent\n"));
14958 break;
14959 case 1:
14960 printf ("MWDT\n");
14961 break;
14962 case 2:
14963 printf ("GNU\n");
14964 break;
14965 default:
14966 printf (_("Unknown\n"));
14967 break;
14968 }
14969 break;
14970
14971 case Tag_ARC_ABI_tls:
14972 READ_ULEB (val, p, end);
14973 printf (" Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
14974 break;
14975
14976 case Tag_ARC_ABI_enumsize:
14977 READ_ULEB (val, p, end);
14978 printf (" Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
14979 _("smallest"));
14980 break;
14981
14982 case Tag_ARC_ABI_exceptions:
14983 READ_ULEB (val, p, end);
14984 printf (" Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
14985 : _("default"));
14986 break;
14987
14988 case Tag_ARC_ABI_double_size:
14989 READ_ULEB (val, p, end);
14990 printf (" Tag_ARC_ABI_double_size: %d\n", val);
14991 break;
14992
14993 case Tag_ARC_ISA_config:
14994 printf (" Tag_ARC_ISA_config: ");
14995 p = display_tag_value (-1, p, end);
14996 break;
14997
14998 case Tag_ARC_ISA_apex:
14999 printf (" Tag_ARC_ISA_apex: ");
15000 p = display_tag_value (-1, p, end);
15001 break;
15002
15003 case Tag_ARC_ISA_mpy_option:
15004 READ_ULEB (val, p, end);
15005 printf (" Tag_ARC_ISA_mpy_option: %d\n", val);
15006 break;
15007
15008 case Tag_ARC_ATR_version:
15009 READ_ULEB (val, p, end);
15010 printf (" Tag_ARC_ATR_version: %d\n", val);
15011 break;
15012
15013 default:
15014 return display_tag_value (tag & 1, p, end);
15015 }
15016
15017 return p;
15018}
15019
15020/* ARM EABI attributes section. */
15021typedef struct
15022{
15023 unsigned int tag;
15024 const char * name;
15025 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
15026 unsigned int type;
15027 const char ** table;
15028} arm_attr_public_tag;
15029
15030static const char * arm_attr_tag_CPU_arch[] =
15031 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
15032 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
15033 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
15034static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
15035static const char * arm_attr_tag_THUMB_ISA_use[] =
15036 {"No", "Thumb-1", "Thumb-2", "Yes"};
15037static const char * arm_attr_tag_FP_arch[] =
15038 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
15039 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
15040static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
15041static const char * arm_attr_tag_Advanced_SIMD_arch[] =
15042 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
15043 "NEON for ARMv8.1"};
15044static const char * arm_attr_tag_PCS_config[] =
15045 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
15046 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
15047static const char * arm_attr_tag_ABI_PCS_R9_use[] =
15048 {"V6", "SB", "TLS", "Unused"};
15049static const char * arm_attr_tag_ABI_PCS_RW_data[] =
15050 {"Absolute", "PC-relative", "SB-relative", "None"};
15051static const char * arm_attr_tag_ABI_PCS_RO_data[] =
15052 {"Absolute", "PC-relative", "None"};
15053static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
15054 {"None", "direct", "GOT-indirect"};
15055static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
15056 {"None", "??? 1", "2", "??? 3", "4"};
15057static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
15058static const char * arm_attr_tag_ABI_FP_denormal[] =
15059 {"Unused", "Needed", "Sign only"};
15060static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
15061static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
15062static const char * arm_attr_tag_ABI_FP_number_model[] =
15063 {"Unused", "Finite", "RTABI", "IEEE 754"};
15064static const char * arm_attr_tag_ABI_enum_size[] =
15065 {"Unused", "small", "int", "forced to int"};
15066static const char * arm_attr_tag_ABI_HardFP_use[] =
15067 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
15068static const char * arm_attr_tag_ABI_VFP_args[] =
15069 {"AAPCS", "VFP registers", "custom", "compatible"};
15070static const char * arm_attr_tag_ABI_WMMX_args[] =
15071 {"AAPCS", "WMMX registers", "custom"};
15072static const char * arm_attr_tag_ABI_optimization_goals[] =
15073 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15074 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
15075static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
15076 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15077 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
15078static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
15079static const char * arm_attr_tag_FP_HP_extension[] =
15080 {"Not Allowed", "Allowed"};
15081static const char * arm_attr_tag_ABI_FP_16bit_format[] =
15082 {"None", "IEEE 754", "Alternative Format"};
15083static const char * arm_attr_tag_DSP_extension[] =
15084 {"Follow architecture", "Allowed"};
15085static const char * arm_attr_tag_MPextension_use[] =
15086 {"Not Allowed", "Allowed"};
15087static const char * arm_attr_tag_DIV_use[] =
15088 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
15089 "Allowed in v7-A with integer division extension"};
15090static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
15091static const char * arm_attr_tag_Virtualization_use[] =
15092 {"Not Allowed", "TrustZone", "Virtualization Extensions",
15093 "TrustZone and Virtualization Extensions"};
15094static const char * arm_attr_tag_MPextension_use_legacy[] =
15095 {"Not Allowed", "Allowed"};
15096
15097static const char * arm_attr_tag_MVE_arch[] =
15098 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
15099
15100#define LOOKUP(id, name) \
15101 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
15102static arm_attr_public_tag arm_attr_public_tags[] =
15103{
15104 {4, "CPU_raw_name", 1, NULL},
15105 {5, "CPU_name", 1, NULL},
15106 LOOKUP(6, CPU_arch),
15107 {7, "CPU_arch_profile", 0, NULL},
15108 LOOKUP(8, ARM_ISA_use),
15109 LOOKUP(9, THUMB_ISA_use),
15110 LOOKUP(10, FP_arch),
15111 LOOKUP(11, WMMX_arch),
15112 LOOKUP(12, Advanced_SIMD_arch),
15113 LOOKUP(13, PCS_config),
15114 LOOKUP(14, ABI_PCS_R9_use),
15115 LOOKUP(15, ABI_PCS_RW_data),
15116 LOOKUP(16, ABI_PCS_RO_data),
15117 LOOKUP(17, ABI_PCS_GOT_use),
15118 LOOKUP(18, ABI_PCS_wchar_t),
15119 LOOKUP(19, ABI_FP_rounding),
15120 LOOKUP(20, ABI_FP_denormal),
15121 LOOKUP(21, ABI_FP_exceptions),
15122 LOOKUP(22, ABI_FP_user_exceptions),
15123 LOOKUP(23, ABI_FP_number_model),
15124 {24, "ABI_align_needed", 0, NULL},
15125 {25, "ABI_align_preserved", 0, NULL},
15126 LOOKUP(26, ABI_enum_size),
15127 LOOKUP(27, ABI_HardFP_use),
15128 LOOKUP(28, ABI_VFP_args),
15129 LOOKUP(29, ABI_WMMX_args),
15130 LOOKUP(30, ABI_optimization_goals),
15131 LOOKUP(31, ABI_FP_optimization_goals),
15132 {32, "compatibility", 0, NULL},
15133 LOOKUP(34, CPU_unaligned_access),
15134 LOOKUP(36, FP_HP_extension),
15135 LOOKUP(38, ABI_FP_16bit_format),
15136 LOOKUP(42, MPextension_use),
15137 LOOKUP(44, DIV_use),
15138 LOOKUP(46, DSP_extension),
15139 LOOKUP(48, MVE_arch),
15140 {64, "nodefaults", 0, NULL},
15141 {65, "also_compatible_with", 0, NULL},
15142 LOOKUP(66, T2EE_use),
15143 {67, "conformance", 1, NULL},
15144 LOOKUP(68, Virtualization_use),
15145 LOOKUP(70, MPextension_use_legacy)
15146};
15147#undef LOOKUP
15148
15149static unsigned char *
15150display_arm_attribute (unsigned char * p,
15151 const unsigned char * const end)
15152{
15153 unsigned int tag;
15154 unsigned int val;
15155 arm_attr_public_tag * attr;
15156 unsigned i;
15157 unsigned int type;
15158
15159 READ_ULEB (tag, p, end);
15160 attr = NULL;
15161 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
15162 {
15163 if (arm_attr_public_tags[i].tag == tag)
15164 {
15165 attr = &arm_attr_public_tags[i];
15166 break;
15167 }
15168 }
15169
15170 if (attr)
15171 {
15172 printf (" Tag_%s: ", attr->name);
15173 switch (attr->type)
15174 {
15175 case 0:
15176 switch (tag)
15177 {
15178 case 7: /* Tag_CPU_arch_profile. */
15179 READ_ULEB (val, p, end);
15180 switch (val)
15181 {
15182 case 0: printf (_("None\n")); break;
15183 case 'A': printf (_("Application\n")); break;
15184 case 'R': printf (_("Realtime\n")); break;
15185 case 'M': printf (_("Microcontroller\n")); break;
15186 case 'S': printf (_("Application or Realtime\n")); break;
15187 default: printf ("??? (%d)\n", val); break;
15188 }
15189 break;
15190
15191 case 24: /* Tag_align_needed. */
15192 READ_ULEB (val, p, end);
15193 switch (val)
15194 {
15195 case 0: printf (_("None\n")); break;
15196 case 1: printf (_("8-byte\n")); break;
15197 case 2: printf (_("4-byte\n")); break;
15198 case 3: printf ("??? 3\n"); break;
15199 default:
15200 if (val <= 12)
15201 printf (_("8-byte and up to %d-byte extended\n"),
15202 1 << val);
15203 else
15204 printf ("??? (%d)\n", val);
15205 break;
15206 }
15207 break;
15208
15209 case 25: /* Tag_align_preserved. */
15210 READ_ULEB (val, p, end);
15211 switch (val)
15212 {
15213 case 0: printf (_("None\n")); break;
15214 case 1: printf (_("8-byte, except leaf SP\n")); break;
15215 case 2: printf (_("8-byte\n")); break;
15216 case 3: printf ("??? 3\n"); break;
15217 default:
15218 if (val <= 12)
15219 printf (_("8-byte and up to %d-byte extended\n"),
15220 1 << val);
15221 else
15222 printf ("??? (%d)\n", val);
15223 break;
15224 }
15225 break;
15226
15227 case 32: /* Tag_compatibility. */
15228 {
15229 READ_ULEB (val, p, end);
15230 printf (_("flag = %d, vendor = "), val);
15231 if (p < end - 1)
15232 {
15233 size_t maxlen = (end - p) - 1;
15234
15235 print_symbol ((int) maxlen, (const char *) p);
15236 p += strnlen ((char *) p, maxlen) + 1;
15237 }
15238 else
15239 {
15240 printf (_("<corrupt>"));
15241 p = (unsigned char *) end;
15242 }
15243 putchar ('\n');
15244 }
15245 break;
15246
15247 case 64: /* Tag_nodefaults. */
15248 /* PR 17531: file: 001-505008-0.01. */
15249 if (p < end)
15250 p++;
15251 printf (_("True\n"));
15252 break;
15253
15254 case 65: /* Tag_also_compatible_with. */
15255 READ_ULEB (val, p, end);
15256 if (val == 6 /* Tag_CPU_arch. */)
15257 {
15258 READ_ULEB (val, p, end);
15259 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
15260 printf ("??? (%d)\n", val);
15261 else
15262 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
15263 }
15264 else
15265 printf ("???\n");
15266 while (p < end && *(p++) != '\0' /* NUL terminator. */)
15267 ;
15268 break;
15269
15270 default:
15271 printf (_("<unknown: %d>\n"), tag);
15272 break;
15273 }
15274 return p;
15275
15276 case 1:
15277 return display_tag_value (-1, p, end);
15278 case 2:
15279 return display_tag_value (0, p, end);
15280
15281 default:
15282 assert (attr->type & 0x80);
15283 READ_ULEB (val, p, end);
15284 type = attr->type & 0x7f;
15285 if (val >= type)
15286 printf ("??? (%d)\n", val);
15287 else
15288 printf ("%s\n", attr->table[val]);
15289 return p;
15290 }
15291 }
15292
15293 return display_tag_value (tag, p, end);
15294}
15295
15296static unsigned char *
15297display_gnu_attribute (unsigned char * p,
15298 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
15299 const unsigned char * const end)
15300{
15301 unsigned int tag;
15302 unsigned int val;
15303
15304 READ_ULEB (tag, p, end);
15305
15306 /* Tag_compatibility is the only generic GNU attribute defined at
15307 present. */
15308 if (tag == 32)
15309 {
15310 READ_ULEB (val, p, end);
15311
15312 printf (_("flag = %d, vendor = "), val);
15313 if (p == end)
15314 {
15315 printf (_("<corrupt>\n"));
15316 warn (_("corrupt vendor attribute\n"));
15317 }
15318 else
15319 {
15320 if (p < end - 1)
15321 {
15322 size_t maxlen = (end - p) - 1;
15323
15324 print_symbol ((int) maxlen, (const char *) p);
15325 p += strnlen ((char *) p, maxlen) + 1;
15326 }
15327 else
15328 {
15329 printf (_("<corrupt>"));
15330 p = (unsigned char *) end;
15331 }
15332 putchar ('\n');
15333 }
15334 return p;
15335 }
15336
15337 if ((tag & 2) == 0 && display_proc_gnu_attribute)
15338 return display_proc_gnu_attribute (p, tag, end);
15339
15340 return display_tag_value (tag, p, end);
15341}
15342
15343static unsigned char *
15344display_power_gnu_attribute (unsigned char * p,
15345 unsigned int tag,
15346 const unsigned char * const end)
15347{
15348 unsigned int val;
15349
15350 if (tag == Tag_GNU_Power_ABI_FP)
15351 {
15352 printf (" Tag_GNU_Power_ABI_FP: ");
15353 if (p == end)
15354 {
15355 printf (_("<corrupt>\n"));
15356 return p;
15357 }
15358 READ_ULEB (val, p, end);
15359
15360 if (val > 15)
15361 printf ("(%#x), ", val);
15362
15363 switch (val & 3)
15364 {
15365 case 0:
15366 printf (_("unspecified hard/soft float, "));
15367 break;
15368 case 1:
15369 printf (_("hard float, "));
15370 break;
15371 case 2:
15372 printf (_("soft float, "));
15373 break;
15374 case 3:
15375 printf (_("single-precision hard float, "));
15376 break;
15377 }
15378
15379 switch (val & 0xC)
15380 {
15381 case 0:
15382 printf (_("unspecified long double\n"));
15383 break;
15384 case 4:
15385 printf (_("128-bit IBM long double\n"));
15386 break;
15387 case 8:
15388 printf (_("64-bit long double\n"));
15389 break;
15390 case 12:
15391 printf (_("128-bit IEEE long double\n"));
15392 break;
15393 }
15394 return p;
15395 }
15396
15397 if (tag == Tag_GNU_Power_ABI_Vector)
15398 {
15399 printf (" Tag_GNU_Power_ABI_Vector: ");
15400 if (p == end)
15401 {
15402 printf (_("<corrupt>\n"));
15403 return p;
15404 }
15405 READ_ULEB (val, p, end);
15406
15407 if (val > 3)
15408 printf ("(%#x), ", val);
15409
15410 switch (val & 3)
15411 {
15412 case 0:
15413 printf (_("unspecified\n"));
15414 break;
15415 case 1:
15416 printf (_("generic\n"));
15417 break;
15418 case 2:
15419 printf ("AltiVec\n");
15420 break;
15421 case 3:
15422 printf ("SPE\n");
15423 break;
15424 }
15425 return p;
15426 }
15427
15428 if (tag == Tag_GNU_Power_ABI_Struct_Return)
15429 {
15430 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15431 if (p == end)
15432 {
15433 printf (_("<corrupt>\n"));
15434 return p;
15435 }
15436 READ_ULEB (val, p, end);
15437
15438 if (val > 2)
15439 printf ("(%#x), ", val);
15440
15441 switch (val & 3)
15442 {
15443 case 0:
15444 printf (_("unspecified\n"));
15445 break;
15446 case 1:
15447 printf ("r3/r4\n");
15448 break;
15449 case 2:
15450 printf (_("memory\n"));
15451 break;
15452 case 3:
15453 printf ("???\n");
15454 break;
15455 }
15456 return p;
15457 }
15458
15459 return display_tag_value (tag & 1, p, end);
15460}
15461
15462static unsigned char *
15463display_s390_gnu_attribute (unsigned char * p,
15464 unsigned int tag,
15465 const unsigned char * const end)
15466{
15467 unsigned int val;
15468
15469 if (tag == Tag_GNU_S390_ABI_Vector)
15470 {
15471 printf (" Tag_GNU_S390_ABI_Vector: ");
15472 READ_ULEB (val, p, end);
15473
15474 switch (val)
15475 {
15476 case 0:
15477 printf (_("any\n"));
15478 break;
15479 case 1:
15480 printf (_("software\n"));
15481 break;
15482 case 2:
15483 printf (_("hardware\n"));
15484 break;
15485 default:
15486 printf ("??? (%d)\n", val);
15487 break;
15488 }
15489 return p;
15490 }
15491
15492 return display_tag_value (tag & 1, p, end);
15493}
15494
15495static void
15496display_sparc_hwcaps (unsigned int mask)
15497{
15498 if (mask)
15499 {
15500 bfd_boolean first = TRUE;
15501
15502 if (mask & ELF_SPARC_HWCAP_MUL32)
15503 fputs ("mul32", stdout), first = FALSE;
15504 if (mask & ELF_SPARC_HWCAP_DIV32)
15505 printf ("%sdiv32", first ? "" : "|"), first = FALSE;
15506 if (mask & ELF_SPARC_HWCAP_FSMULD)
15507 printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
15508 if (mask & ELF_SPARC_HWCAP_V8PLUS)
15509 printf ("%sv8plus", first ? "" : "|"), first = FALSE;
15510 if (mask & ELF_SPARC_HWCAP_POPC)
15511 printf ("%spopc", first ? "" : "|"), first = FALSE;
15512 if (mask & ELF_SPARC_HWCAP_VIS)
15513 printf ("%svis", first ? "" : "|"), first = FALSE;
15514 if (mask & ELF_SPARC_HWCAP_VIS2)
15515 printf ("%svis2", first ? "" : "|"), first = FALSE;
15516 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
15517 printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
15518 if (mask & ELF_SPARC_HWCAP_FMAF)
15519 printf ("%sfmaf", first ? "" : "|"), first = FALSE;
15520 if (mask & ELF_SPARC_HWCAP_VIS3)
15521 printf ("%svis3", first ? "" : "|"), first = FALSE;
15522 if (mask & ELF_SPARC_HWCAP_HPC)
15523 printf ("%shpc", first ? "" : "|"), first = FALSE;
15524 if (mask & ELF_SPARC_HWCAP_RANDOM)
15525 printf ("%srandom", first ? "" : "|"), first = FALSE;
15526 if (mask & ELF_SPARC_HWCAP_TRANS)
15527 printf ("%strans", first ? "" : "|"), first = FALSE;
15528 if (mask & ELF_SPARC_HWCAP_FJFMAU)
15529 printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
15530 if (mask & ELF_SPARC_HWCAP_IMA)
15531 printf ("%sima", first ? "" : "|"), first = FALSE;
15532 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
15533 printf ("%scspare", first ? "" : "|"), first = FALSE;
15534 }
15535 else
15536 fputc ('0', stdout);
15537 fputc ('\n', stdout);
15538}
15539
15540static void
15541display_sparc_hwcaps2 (unsigned int mask)
15542{
15543 if (mask)
15544 {
15545 bfd_boolean first = TRUE;
15546
15547 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
15548 fputs ("fjathplus", stdout), first = FALSE;
15549 if (mask & ELF_SPARC_HWCAP2_VIS3B)
15550 printf ("%svis3b", first ? "" : "|"), first = FALSE;
15551 if (mask & ELF_SPARC_HWCAP2_ADP)
15552 printf ("%sadp", first ? "" : "|"), first = FALSE;
15553 if (mask & ELF_SPARC_HWCAP2_SPARC5)
15554 printf ("%ssparc5", first ? "" : "|"), first = FALSE;
15555 if (mask & ELF_SPARC_HWCAP2_MWAIT)
15556 printf ("%smwait", first ? "" : "|"), first = FALSE;
15557 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
15558 printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
15559 if (mask & ELF_SPARC_HWCAP2_XMONT)
15560 printf ("%sxmont2", first ? "" : "|"), first = FALSE;
15561 if (mask & ELF_SPARC_HWCAP2_NSEC)
15562 printf ("%snsec", first ? "" : "|"), first = FALSE;
15563 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
15564 printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
15565 if (mask & ELF_SPARC_HWCAP2_FJDES)
15566 printf ("%sfjdes", first ? "" : "|"), first = FALSE;
15567 if (mask & ELF_SPARC_HWCAP2_FJAES)
15568 printf ("%sfjaes", first ? "" : "|"), first = FALSE;
15569 }
15570 else
15571 fputc ('0', stdout);
15572 fputc ('\n', stdout);
15573}
15574
15575static unsigned char *
15576display_sparc_gnu_attribute (unsigned char * p,
15577 unsigned int tag,
15578 const unsigned char * const end)
15579{
15580 unsigned int val;
15581
15582 if (tag == Tag_GNU_Sparc_HWCAPS)
15583 {
15584 READ_ULEB (val, p, end);
15585 printf (" Tag_GNU_Sparc_HWCAPS: ");
15586 display_sparc_hwcaps (val);
15587 return p;
15588 }
15589 if (tag == Tag_GNU_Sparc_HWCAPS2)
15590 {
15591 READ_ULEB (val, p, end);
15592 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15593 display_sparc_hwcaps2 (val);
15594 return p;
15595 }
15596
15597 return display_tag_value (tag, p, end);
15598}
15599
15600static void
15601print_mips_fp_abi_value (unsigned int val)
15602{
15603 switch (val)
15604 {
15605 case Val_GNU_MIPS_ABI_FP_ANY:
15606 printf (_("Hard or soft float\n"));
15607 break;
15608 case Val_GNU_MIPS_ABI_FP_DOUBLE:
15609 printf (_("Hard float (double precision)\n"));
15610 break;
15611 case Val_GNU_MIPS_ABI_FP_SINGLE:
15612 printf (_("Hard float (single precision)\n"));
15613 break;
15614 case Val_GNU_MIPS_ABI_FP_SOFT:
15615 printf (_("Soft float\n"));
15616 break;
15617 case Val_GNU_MIPS_ABI_FP_OLD_64:
15618 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15619 break;
15620 case Val_GNU_MIPS_ABI_FP_XX:
15621 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15622 break;
15623 case Val_GNU_MIPS_ABI_FP_64:
15624 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15625 break;
15626 case Val_GNU_MIPS_ABI_FP_64A:
15627 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15628 break;
15629 case Val_GNU_MIPS_ABI_FP_NAN2008:
15630 printf (_("NaN 2008 compatibility\n"));
15631 break;
15632 default:
15633 printf ("??? (%d)\n", val);
15634 break;
15635 }
15636}
15637
15638static unsigned char *
15639display_mips_gnu_attribute (unsigned char * p,
15640 unsigned int tag,
15641 const unsigned char * const end)
15642{
15643 if (tag == Tag_GNU_MIPS_ABI_FP)
15644 {
15645 unsigned int val;
15646
15647 printf (" Tag_GNU_MIPS_ABI_FP: ");
15648 READ_ULEB (val, p, end);
15649 print_mips_fp_abi_value (val);
15650 return p;
15651 }
15652
15653 if (tag == Tag_GNU_MIPS_ABI_MSA)
15654 {
15655 unsigned int val;
15656
15657 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15658 READ_ULEB (val, p, end);
15659
15660 switch (val)
15661 {
15662 case Val_GNU_MIPS_ABI_MSA_ANY:
15663 printf (_("Any MSA or not\n"));
15664 break;
15665 case Val_GNU_MIPS_ABI_MSA_128:
15666 printf (_("128-bit MSA\n"));
15667 break;
15668 default:
15669 printf ("??? (%d)\n", val);
15670 break;
15671 }
15672 return p;
15673 }
15674
15675 return display_tag_value (tag & 1, p, end);
15676}
15677
15678static unsigned char *
15679display_tic6x_attribute (unsigned char * p,
15680 const unsigned char * const end)
15681{
15682 unsigned int tag;
15683 unsigned int val;
15684
15685 READ_ULEB (tag, p, end);
15686
15687 switch (tag)
15688 {
15689 case Tag_ISA:
15690 printf (" Tag_ISA: ");
15691 READ_ULEB (val, p, end);
15692
15693 switch (val)
15694 {
15695 case C6XABI_Tag_ISA_none:
15696 printf (_("None\n"));
15697 break;
15698 case C6XABI_Tag_ISA_C62X:
15699 printf ("C62x\n");
15700 break;
15701 case C6XABI_Tag_ISA_C67X:
15702 printf ("C67x\n");
15703 break;
15704 case C6XABI_Tag_ISA_C67XP:
15705 printf ("C67x+\n");
15706 break;
15707 case C6XABI_Tag_ISA_C64X:
15708 printf ("C64x\n");
15709 break;
15710 case C6XABI_Tag_ISA_C64XP:
15711 printf ("C64x+\n");
15712 break;
15713 case C6XABI_Tag_ISA_C674X:
15714 printf ("C674x\n");
15715 break;
15716 default:
15717 printf ("??? (%d)\n", val);
15718 break;
15719 }
15720 return p;
15721
15722 case Tag_ABI_wchar_t:
15723 printf (" Tag_ABI_wchar_t: ");
15724 READ_ULEB (val, p, end);
15725 switch (val)
15726 {
15727 case 0:
15728 printf (_("Not used\n"));
15729 break;
15730 case 1:
15731 printf (_("2 bytes\n"));
15732 break;
15733 case 2:
15734 printf (_("4 bytes\n"));
15735 break;
15736 default:
15737 printf ("??? (%d)\n", val);
15738 break;
15739 }
15740 return p;
15741
15742 case Tag_ABI_stack_align_needed:
15743 printf (" Tag_ABI_stack_align_needed: ");
15744 READ_ULEB (val, p, end);
15745 switch (val)
15746 {
15747 case 0:
15748 printf (_("8-byte\n"));
15749 break;
15750 case 1:
15751 printf (_("16-byte\n"));
15752 break;
15753 default:
15754 printf ("??? (%d)\n", val);
15755 break;
15756 }
15757 return p;
15758
15759 case Tag_ABI_stack_align_preserved:
15760 READ_ULEB (val, p, end);
15761 printf (" Tag_ABI_stack_align_preserved: ");
15762 switch (val)
15763 {
15764 case 0:
15765 printf (_("8-byte\n"));
15766 break;
15767 case 1:
15768 printf (_("16-byte\n"));
15769 break;
15770 default:
15771 printf ("??? (%d)\n", val);
15772 break;
15773 }
15774 return p;
15775
15776 case Tag_ABI_DSBT:
15777 READ_ULEB (val, p, end);
15778 printf (" Tag_ABI_DSBT: ");
15779 switch (val)
15780 {
15781 case 0:
15782 printf (_("DSBT addressing not used\n"));
15783 break;
15784 case 1:
15785 printf (_("DSBT addressing used\n"));
15786 break;
15787 default:
15788 printf ("??? (%d)\n", val);
15789 break;
15790 }
15791 return p;
15792
15793 case Tag_ABI_PID:
15794 READ_ULEB (val, p, end);
15795 printf (" Tag_ABI_PID: ");
15796 switch (val)
15797 {
15798 case 0:
15799 printf (_("Data addressing position-dependent\n"));
15800 break;
15801 case 1:
15802 printf (_("Data addressing position-independent, GOT near DP\n"));
15803 break;
15804 case 2:
15805 printf (_("Data addressing position-independent, GOT far from DP\n"));
15806 break;
15807 default:
15808 printf ("??? (%d)\n", val);
15809 break;
15810 }
15811 return p;
15812
15813 case Tag_ABI_PIC:
15814 READ_ULEB (val, p, end);
15815 printf (" Tag_ABI_PIC: ");
15816 switch (val)
15817 {
15818 case 0:
15819 printf (_("Code addressing position-dependent\n"));
15820 break;
15821 case 1:
15822 printf (_("Code addressing position-independent\n"));
15823 break;
15824 default:
15825 printf ("??? (%d)\n", val);
15826 break;
15827 }
15828 return p;
15829
15830 case Tag_ABI_array_object_alignment:
15831 READ_ULEB (val, p, end);
15832 printf (" Tag_ABI_array_object_alignment: ");
15833 switch (val)
15834 {
15835 case 0:
15836 printf (_("8-byte\n"));
15837 break;
15838 case 1:
15839 printf (_("4-byte\n"));
15840 break;
15841 case 2:
15842 printf (_("16-byte\n"));
15843 break;
15844 default:
15845 printf ("??? (%d)\n", val);
15846 break;
15847 }
15848 return p;
15849
15850 case Tag_ABI_array_object_align_expected:
15851 READ_ULEB (val, p, end);
15852 printf (" Tag_ABI_array_object_align_expected: ");
15853 switch (val)
15854 {
15855 case 0:
15856 printf (_("8-byte\n"));
15857 break;
15858 case 1:
15859 printf (_("4-byte\n"));
15860 break;
15861 case 2:
15862 printf (_("16-byte\n"));
15863 break;
15864 default:
15865 printf ("??? (%d)\n", val);
15866 break;
15867 }
15868 return p;
15869
15870 case Tag_ABI_compatibility:
15871 {
15872 READ_ULEB (val, p, end);
15873 printf (" Tag_ABI_compatibility: ");
15874 printf (_("flag = %d, vendor = "), val);
15875 if (p < end - 1)
15876 {
15877 size_t maxlen = (end - p) - 1;
15878
15879 print_symbol ((int) maxlen, (const char *) p);
15880 p += strnlen ((char *) p, maxlen) + 1;
15881 }
15882 else
15883 {
15884 printf (_("<corrupt>"));
15885 p = (unsigned char *) end;
15886 }
15887 putchar ('\n');
15888 return p;
15889 }
15890
15891 case Tag_ABI_conformance:
15892 {
15893 printf (" Tag_ABI_conformance: \"");
15894 if (p < end - 1)
15895 {
15896 size_t maxlen = (end - p) - 1;
15897
15898 print_symbol ((int) maxlen, (const char *) p);
15899 p += strnlen ((char *) p, maxlen) + 1;
15900 }
15901 else
15902 {
15903 printf (_("<corrupt>"));
15904 p = (unsigned char *) end;
15905 }
15906 printf ("\"\n");
15907 return p;
15908 }
15909 }
15910
15911 return display_tag_value (tag, p, end);
15912}
15913
15914static void
15915display_raw_attribute (unsigned char * p, unsigned char const * const end)
15916{
15917 unsigned long addr = 0;
15918 size_t bytes = end - p;
15919
15920 assert (end >= p);
15921 while (bytes)
15922 {
15923 int j;
15924 int k;
15925 int lbytes = (bytes > 16 ? 16 : bytes);
15926
15927 printf (" 0x%8.8lx ", addr);
15928
15929 for (j = 0; j < 16; j++)
15930 {
15931 if (j < lbytes)
15932 printf ("%2.2x", p[j]);
15933 else
15934 printf (" ");
15935
15936 if ((j & 3) == 3)
15937 printf (" ");
15938 }
15939
15940 for (j = 0; j < lbytes; j++)
15941 {
15942 k = p[j];
15943 if (k >= ' ' && k < 0x7f)
15944 printf ("%c", k);
15945 else
15946 printf (".");
15947 }
15948
15949 putchar ('\n');
15950
15951 p += lbytes;
15952 bytes -= lbytes;
15953 addr += lbytes;
15954 }
15955
15956 putchar ('\n');
15957}
15958
15959static unsigned char *
15960display_msp430x_attribute (unsigned char * p,
15961 const unsigned char * const end)
15962{
15963 unsigned int val;
15964 unsigned int tag;
15965
15966 READ_ULEB (tag, p, end);
15967
15968 switch (tag)
15969 {
15970 case OFBA_MSPABI_Tag_ISA:
15971 printf (" Tag_ISA: ");
15972 READ_ULEB (val, p, end);
15973 switch (val)
15974 {
15975 case 0: printf (_("None\n")); break;
15976 case 1: printf (_("MSP430\n")); break;
15977 case 2: printf (_("MSP430X\n")); break;
15978 default: printf ("??? (%d)\n", val); break;
15979 }
15980 break;
15981
15982 case OFBA_MSPABI_Tag_Code_Model:
15983 printf (" Tag_Code_Model: ");
15984 READ_ULEB (val, p, end);
15985 switch (val)
15986 {
15987 case 0: printf (_("None\n")); break;
15988 case 1: printf (_("Small\n")); break;
15989 case 2: printf (_("Large\n")); break;
15990 default: printf ("??? (%d)\n", val); break;
15991 }
15992 break;
15993
15994 case OFBA_MSPABI_Tag_Data_Model:
15995 printf (" Tag_Data_Model: ");
15996 READ_ULEB (val, p, end);
15997 switch (val)
15998 {
15999 case 0: printf (_("None\n")); break;
16000 case 1: printf (_("Small\n")); break;
16001 case 2: printf (_("Large\n")); break;
16002 case 3: printf (_("Restricted Large\n")); break;
16003 default: printf ("??? (%d)\n", val); break;
16004 }
16005 break;
16006
16007 default:
16008 printf (_(" <unknown tag %d>: "), tag);
16009
16010 if (tag & 1)
16011 {
16012 putchar ('"');
16013 if (p < end - 1)
16014 {
16015 size_t maxlen = (end - p) - 1;
16016
16017 print_symbol ((int) maxlen, (const char *) p);
16018 p += strnlen ((char *) p, maxlen) + 1;
16019 }
16020 else
16021 {
16022 printf (_("<corrupt>"));
16023 p = (unsigned char *) end;
16024 }
16025 printf ("\"\n");
16026 }
16027 else
16028 {
16029 READ_ULEB (val, p, end);
16030 printf ("%d (0x%x)\n", val, val);
16031 }
16032 break;
16033 }
16034
16035 assert (p <= end);
16036 return p;
16037}
16038
16039static unsigned char *
16040display_msp430_gnu_attribute (unsigned char * p,
16041 unsigned int tag,
16042 const unsigned char * const end)
16043{
16044 if (tag == Tag_GNU_MSP430_Data_Region)
16045 {
16046 unsigned int val;
16047
16048 printf (" Tag_GNU_MSP430_Data_Region: ");
16049 READ_ULEB (val, p, end);
16050
16051 switch (val)
16052 {
16053 case Val_GNU_MSP430_Data_Region_Any:
16054 printf (_("Any Region\n"));
16055 break;
16056 case Val_GNU_MSP430_Data_Region_Lower:
16057 printf (_("Lower Region Only\n"));
16058 break;
16059 default:
16060 printf ("??? (%u)\n", val);
16061 }
16062 return p;
16063 }
16064 return display_tag_value (tag & 1, p, end);
16065}
16066
16067struct riscv_attr_tag_t {
16068 const char *name;
16069 unsigned int tag;
16070};
16071
16072static struct riscv_attr_tag_t riscv_attr_tag[] =
16073{
16074#define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
16075 T(arch),
16076 T(priv_spec),
16077 T(priv_spec_minor),
16078 T(priv_spec_revision),
16079 T(unaligned_access),
16080 T(stack_align),
16081#undef T
16082};
16083
16084static unsigned char *
16085display_riscv_attribute (unsigned char *p,
16086 const unsigned char * const end)
16087{
16088 unsigned int val;
16089 unsigned int tag;
16090 struct riscv_attr_tag_t *attr = NULL;
16091 unsigned i;
16092
16093 READ_ULEB (tag, p, end);
16094
16095 /* Find the name of attribute. */
16096 for (i = 0; i < ARRAY_SIZE (riscv_attr_tag); i++)
16097 {
16098 if (riscv_attr_tag[i].tag == tag)
16099 {
16100 attr = &riscv_attr_tag[i];
16101 break;
16102 }
16103 }
16104
16105 if (attr)
16106 printf (" %s: ", attr->name);
16107 else
16108 return display_tag_value (tag, p, end);
16109
16110 switch (tag)
16111 {
16112 case Tag_RISCV_priv_spec:
16113 case Tag_RISCV_priv_spec_minor:
16114 case Tag_RISCV_priv_spec_revision:
16115 READ_ULEB (val, p, end);
16116 printf (_("%u\n"), val);
16117 break;
16118 case Tag_RISCV_unaligned_access:
16119 READ_ULEB (val, p, end);
16120 switch (val)
16121 {
16122 case 0:
16123 printf (_("No unaligned access\n"));
16124 break;
16125 case 1:
16126 printf (_("Unaligned access\n"));
16127 break;
16128 }
16129 break;
16130 case Tag_RISCV_stack_align:
16131 READ_ULEB (val, p, end);
16132 printf (_("%u-bytes\n"), val);
16133 break;
16134 case Tag_RISCV_arch:
16135 p = display_tag_value (-1, p, end);
16136 break;
16137 default:
16138 return display_tag_value (tag, p, end);
16139 }
16140
16141 return p;
16142}
16143
16144static bfd_boolean
16145process_attributes (Filedata * filedata,
16146 const char * public_name,
16147 unsigned int proc_type,
16148 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
16149 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
16150{
16151 Elf_Internal_Shdr * sect;
16152 unsigned i;
16153 bfd_boolean res = TRUE;
16154
16155 /* Find the section header so that we get the size. */
16156 for (i = 0, sect = filedata->section_headers;
16157 i < filedata->file_header.e_shnum;
16158 i++, sect++)
16159 {
16160 unsigned char * contents;
16161 unsigned char * p;
16162
16163 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
16164 continue;
16165
16166 contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
16167 sect->sh_size, _("attributes"));
16168 if (contents == NULL)
16169 {
16170 res = FALSE;
16171 continue;
16172 }
16173
16174 p = contents;
16175 /* The first character is the version of the attributes.
16176 Currently only version 1, (aka 'A') is recognised here. */
16177 if (*p != 'A')
16178 {
16179 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
16180 res = FALSE;
16181 }
16182 else
16183 {
16184 bfd_vma section_len;
16185
16186 section_len = sect->sh_size - 1;
16187 p++;
16188
16189 while (section_len > 0)
16190 {
16191 bfd_vma attr_len;
16192 unsigned int namelen;
16193 bfd_boolean public_section;
16194 bfd_boolean gnu_section;
16195
16196 if (section_len <= 4)
16197 {
16198 error (_("Tag section ends prematurely\n"));
16199 res = FALSE;
16200 break;
16201 }
16202 attr_len = byte_get (p, 4);
16203 p += 4;
16204
16205 if (attr_len > section_len)
16206 {
16207 error (_("Bad attribute length (%u > %u)\n"),
16208 (unsigned) attr_len, (unsigned) section_len);
16209 attr_len = section_len;
16210 res = FALSE;
16211 }
16212 /* PR 17531: file: 001-101425-0.004 */
16213 else if (attr_len < 5)
16214 {
16215 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
16216 res = FALSE;
16217 break;
16218 }
16219
16220 section_len -= attr_len;
16221 attr_len -= 4;
16222
16223 namelen = strnlen ((char *) p, attr_len) + 1;
16224 if (namelen == 0 || namelen >= attr_len)
16225 {
16226 error (_("Corrupt attribute section name\n"));
16227 res = FALSE;
16228 break;
16229 }
16230
16231 printf (_("Attribute Section: "));
16232 print_symbol (INT_MAX, (const char *) p);
16233 putchar ('\n');
16234
16235 if (public_name && streq ((char *) p, public_name))
16236 public_section = TRUE;
16237 else
16238 public_section = FALSE;
16239
16240 if (streq ((char *) p, "gnu"))
16241 gnu_section = TRUE;
16242 else
16243 gnu_section = FALSE;
16244
16245 p += namelen;
16246 attr_len -= namelen;
16247
16248 while (attr_len > 0 && p < contents + sect->sh_size)
16249 {
16250 int tag;
16251 unsigned int val;
16252 bfd_vma size;
16253 unsigned char * end;
16254
16255 /* PR binutils/17531: Safe handling of corrupt files. */
16256 if (attr_len < 6)
16257 {
16258 error (_("Unused bytes at end of section\n"));
16259 res = FALSE;
16260 section_len = 0;
16261 break;
16262 }
16263
16264 tag = *(p++);
16265 size = byte_get (p, 4);
16266 if (size > attr_len)
16267 {
16268 error (_("Bad subsection length (%u > %u)\n"),
16269 (unsigned) size, (unsigned) attr_len);
16270 res = FALSE;
16271 size = attr_len;
16272 }
16273 /* PR binutils/17531: Safe handling of corrupt files. */
16274 if (size < 6)
16275 {
16276 error (_("Bad subsection length (%u < 6)\n"),
16277 (unsigned) size);
16278 res = FALSE;
16279 section_len = 0;
16280 break;
16281 }
16282
16283 attr_len -= size;
16284 end = p + size - 1;
16285 assert (end <= contents + sect->sh_size);
16286 p += 4;
16287
16288 switch (tag)
16289 {
16290 case 1:
16291 printf (_("File Attributes\n"));
16292 break;
16293 case 2:
16294 printf (_("Section Attributes:"));
16295 goto do_numlist;
16296 case 3:
16297 printf (_("Symbol Attributes:"));
16298 /* Fall through. */
16299 do_numlist:
16300 for (;;)
16301 {
16302 READ_ULEB (val, p, end);
16303 if (val == 0)
16304 break;
16305 printf (" %d", val);
16306 }
16307 printf ("\n");
16308 break;
16309 default:
16310 printf (_("Unknown tag: %d\n"), tag);
16311 public_section = FALSE;
16312 break;
16313 }
16314
16315 if (public_section && display_pub_attribute != NULL)
16316 {
16317 while (p < end)
16318 p = display_pub_attribute (p, end);
16319 assert (p == end);
16320 }
16321 else if (gnu_section && display_proc_gnu_attribute != NULL)
16322 {
16323 while (p < end)
16324 p = display_gnu_attribute (p,
16325 display_proc_gnu_attribute,
16326 end);
16327 assert (p == end);
16328 }
16329 else if (p < end)
16330 {
16331 printf (_(" Unknown attribute:\n"));
16332 display_raw_attribute (p, end);
16333 p = end;
16334 }
16335 else
16336 attr_len = 0;
16337 }
16338 }
16339 }
16340
16341 free (contents);
16342 }
16343
16344 return res;
16345}
16346
16347/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16348 Print the Address, Access and Initial fields of an entry at VMA ADDR
16349 and return the VMA of the next entry, or -1 if there was a problem.
16350 Does not read from DATA_END or beyond. */
16351
16352static bfd_vma
16353print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
16354 unsigned char * data_end)
16355{
16356 printf (" ");
16357 print_vma (addr, LONG_HEX);
16358 printf (" ");
16359 if (addr < pltgot + 0xfff0)
16360 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
16361 else
16362 printf ("%10s", "");
16363 printf (" ");
16364 if (data == NULL)
16365 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
16366 else
16367 {
16368 bfd_vma entry;
16369 unsigned char * from = data + addr - pltgot;
16370
16371 if (from + (is_32bit_elf ? 4 : 8) > data_end)
16372 {
16373 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16374 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
16375 return (bfd_vma) -1;
16376 }
16377 else
16378 {
16379 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
16380 print_vma (entry, LONG_HEX);
16381 }
16382 }
16383 return addr + (is_32bit_elf ? 4 : 8);
16384}
16385
16386/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16387 PLTGOT. Print the Address and Initial fields of an entry at VMA
16388 ADDR and return the VMA of the next entry. */
16389
16390static bfd_vma
16391print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
16392{
16393 printf (" ");
16394 print_vma (addr, LONG_HEX);
16395 printf (" ");
16396 if (data == NULL)
16397 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
16398 else
16399 {
16400 bfd_vma entry;
16401
16402 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
16403 print_vma (entry, LONG_HEX);
16404 }
16405 return addr + (is_32bit_elf ? 4 : 8);
16406}
16407
16408static void
16409print_mips_ases (unsigned int mask)
16410{
16411 if (mask & AFL_ASE_DSP)
16412 fputs ("\n\tDSP ASE", stdout);
16413 if (mask & AFL_ASE_DSPR2)
16414 fputs ("\n\tDSP R2 ASE", stdout);
16415 if (mask & AFL_ASE_DSPR3)
16416 fputs ("\n\tDSP R3 ASE", stdout);
16417 if (mask & AFL_ASE_EVA)
16418 fputs ("\n\tEnhanced VA Scheme", stdout);
16419 if (mask & AFL_ASE_MCU)
16420 fputs ("\n\tMCU (MicroController) ASE", stdout);
16421 if (mask & AFL_ASE_MDMX)
16422 fputs ("\n\tMDMX ASE", stdout);
16423 if (mask & AFL_ASE_MIPS3D)
16424 fputs ("\n\tMIPS-3D ASE", stdout);
16425 if (mask & AFL_ASE_MT)
16426 fputs ("\n\tMT ASE", stdout);
16427 if (mask & AFL_ASE_SMARTMIPS)
16428 fputs ("\n\tSmartMIPS ASE", stdout);
16429 if (mask & AFL_ASE_VIRT)
16430 fputs ("\n\tVZ ASE", stdout);
16431 if (mask & AFL_ASE_MSA)
16432 fputs ("\n\tMSA ASE", stdout);
16433 if (mask & AFL_ASE_MIPS16)
16434 fputs ("\n\tMIPS16 ASE", stdout);
16435 if (mask & AFL_ASE_MICROMIPS)
16436 fputs ("\n\tMICROMIPS ASE", stdout);
16437 if (mask & AFL_ASE_XPA)
16438 fputs ("\n\tXPA ASE", stdout);
16439 if (mask & AFL_ASE_MIPS16E2)
16440 fputs ("\n\tMIPS16e2 ASE", stdout);
16441 if (mask & AFL_ASE_CRC)
16442 fputs ("\n\tCRC ASE", stdout);
16443 if (mask & AFL_ASE_GINV)
16444 fputs ("\n\tGINV ASE", stdout);
16445 if (mask & AFL_ASE_LOONGSON_MMI)
16446 fputs ("\n\tLoongson MMI ASE", stdout);
16447 if (mask & AFL_ASE_LOONGSON_CAM)
16448 fputs ("\n\tLoongson CAM ASE", stdout);
16449 if (mask & AFL_ASE_LOONGSON_EXT)
16450 fputs ("\n\tLoongson EXT ASE", stdout);
16451 if (mask & AFL_ASE_LOONGSON_EXT2)
16452 fputs ("\n\tLoongson EXT2 ASE", stdout);
16453 if (mask == 0)
16454 fprintf (stdout, "\n\t%s", _("None"));
16455 else if ((mask & ~AFL_ASE_MASK) != 0)
16456 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
16457}
16458
16459static void
16460print_mips_isa_ext (unsigned int isa_ext)
16461{
16462 switch (isa_ext)
16463 {
16464 case 0:
16465 fputs (_("None"), stdout);
16466 break;
16467 case AFL_EXT_XLR:
16468 fputs ("RMI XLR", stdout);
16469 break;
16470 case AFL_EXT_OCTEON3:
16471 fputs ("Cavium Networks Octeon3", stdout);
16472 break;
16473 case AFL_EXT_OCTEON2:
16474 fputs ("Cavium Networks Octeon2", stdout);
16475 break;
16476 case AFL_EXT_OCTEONP:
16477 fputs ("Cavium Networks OcteonP", stdout);
16478 break;
16479 case AFL_EXT_OCTEON:
16480 fputs ("Cavium Networks Octeon", stdout);
16481 break;
16482 case AFL_EXT_5900:
16483 fputs ("Toshiba R5900", stdout);
16484 break;
16485 case AFL_EXT_4650:
16486 fputs ("MIPS R4650", stdout);
16487 break;
16488 case AFL_EXT_4010:
16489 fputs ("LSI R4010", stdout);
16490 break;
16491 case AFL_EXT_4100:
16492 fputs ("NEC VR4100", stdout);
16493 break;
16494 case AFL_EXT_3900:
16495 fputs ("Toshiba R3900", stdout);
16496 break;
16497 case AFL_EXT_10000:
16498 fputs ("MIPS R10000", stdout);
16499 break;
16500 case AFL_EXT_SB1:
16501 fputs ("Broadcom SB-1", stdout);
16502 break;
16503 case AFL_EXT_4111:
16504 fputs ("NEC VR4111/VR4181", stdout);
16505 break;
16506 case AFL_EXT_4120:
16507 fputs ("NEC VR4120", stdout);
16508 break;
16509 case AFL_EXT_5400:
16510 fputs ("NEC VR5400", stdout);
16511 break;
16512 case AFL_EXT_5500:
16513 fputs ("NEC VR5500", stdout);
16514 break;
16515 case AFL_EXT_LOONGSON_2E:
16516 fputs ("ST Microelectronics Loongson 2E", stdout);
16517 break;
16518 case AFL_EXT_LOONGSON_2F:
16519 fputs ("ST Microelectronics Loongson 2F", stdout);
16520 break;
16521 case AFL_EXT_INTERAPTIV_MR2:
16522 fputs ("Imagination interAptiv MR2", stdout);
16523 break;
16524 default:
16525 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
16526 }
16527}
16528
16529static signed int
16530get_mips_reg_size (int reg_size)
16531{
16532 return (reg_size == AFL_REG_NONE) ? 0
16533 : (reg_size == AFL_REG_32) ? 32
16534 : (reg_size == AFL_REG_64) ? 64
16535 : (reg_size == AFL_REG_128) ? 128
16536 : -1;
16537}
16538
16539static bfd_boolean
16540process_mips_specific (Filedata * filedata)
16541{
16542 Elf_Internal_Dyn * entry;
16543 Elf_Internal_Shdr *sect = NULL;
16544 size_t liblist_offset = 0;
16545 size_t liblistno = 0;
16546 size_t conflictsno = 0;
16547 size_t options_offset = 0;
16548 size_t conflicts_offset = 0;
16549 size_t pltrelsz = 0;
16550 size_t pltrel = 0;
16551 bfd_vma pltgot = 0;
16552 bfd_vma mips_pltgot = 0;
16553 bfd_vma jmprel = 0;
16554 bfd_vma local_gotno = 0;
16555 bfd_vma gotsym = 0;
16556 bfd_vma symtabno = 0;
16557 bfd_boolean res = TRUE;
16558
16559 if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
16560 display_mips_gnu_attribute))
16561 res = FALSE;
16562
16563 sect = find_section (filedata, ".MIPS.abiflags");
16564
16565 if (sect != NULL)
16566 {
16567 Elf_External_ABIFlags_v0 *abiflags_ext;
16568 Elf_Internal_ABIFlags_v0 abiflags_in;
16569
16570 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
16571 {
16572 error (_("Corrupt MIPS ABI Flags section.\n"));
16573 res = FALSE;
16574 }
16575 else
16576 {
16577 abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
16578 sect->sh_size, _("MIPS ABI Flags section"));
16579 if (abiflags_ext)
16580 {
16581 abiflags_in.version = BYTE_GET (abiflags_ext->version);
16582 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
16583 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
16584 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
16585 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
16586 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
16587 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
16588 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
16589 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
16590 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
16591 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
16592
16593 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
16594 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
16595 if (abiflags_in.isa_rev > 1)
16596 printf ("r%d", abiflags_in.isa_rev);
16597 printf ("\nGPR size: %d",
16598 get_mips_reg_size (abiflags_in.gpr_size));
16599 printf ("\nCPR1 size: %d",
16600 get_mips_reg_size (abiflags_in.cpr1_size));
16601 printf ("\nCPR2 size: %d",
16602 get_mips_reg_size (abiflags_in.cpr2_size));
16603 fputs ("\nFP ABI: ", stdout);
16604 print_mips_fp_abi_value (abiflags_in.fp_abi);
16605 fputs ("ISA Extension: ", stdout);
16606 print_mips_isa_ext (abiflags_in.isa_ext);
16607 fputs ("\nASEs:", stdout);
16608 print_mips_ases (abiflags_in.ases);
16609 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
16610 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
16611 fputc ('\n', stdout);
16612 free (abiflags_ext);
16613 }
16614 }
16615 }
16616
16617 /* We have a lot of special sections. Thanks SGI! */
16618 if (filedata->dynamic_section == NULL)
16619 {
16620 /* No dynamic information available. See if there is static GOT. */
16621 sect = find_section (filedata, ".got");
16622 if (sect != NULL)
16623 {
16624 unsigned char *data_end;
16625 unsigned char *data;
16626 bfd_vma ent, end;
16627 int addr_size;
16628
16629 pltgot = sect->sh_addr;
16630
16631 ent = pltgot;
16632 addr_size = (is_32bit_elf ? 4 : 8);
16633 end = pltgot + sect->sh_size;
16634
16635 data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
16636 end - pltgot, 1,
16637 _("Global Offset Table data"));
16638 /* PR 12855: Null data is handled gracefully throughout. */
16639 data_end = data + (end - pltgot);
16640
16641 printf (_("\nStatic GOT:\n"));
16642 printf (_(" Canonical gp value: "));
16643 print_vma (ent + 0x7ff0, LONG_HEX);
16644 printf ("\n\n");
16645
16646 /* In a dynamic binary GOT[0] is reserved for the dynamic
16647 loader to store the lazy resolver pointer, however in
16648 a static binary it may well have been omitted and GOT
16649 reduced to a table of addresses.
16650 PR 21344: Check for the entry being fully available
16651 before fetching it. */
16652 if (data
16653 && data + ent - pltgot + addr_size <= data_end
16654 && byte_get (data + ent - pltgot, addr_size) == 0)
16655 {
16656 printf (_(" Reserved entries:\n"));
16657 printf (_(" %*s %10s %*s\n"),
16658 addr_size * 2, _("Address"), _("Access"),
16659 addr_size * 2, _("Value"));
16660 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16661 printf ("\n");
16662 if (ent == (bfd_vma) -1)
16663 goto sgot_print_fail;
16664
16665 /* Check for the MSB of GOT[1] being set, identifying a
16666 GNU object. This entry will be used by some runtime
16667 loaders, to store the module pointer. Otherwise this
16668 is an ordinary local entry.
16669 PR 21344: Check for the entry being fully available
16670 before fetching it. */
16671 if (data
16672 && data + ent - pltgot + addr_size <= data_end
16673 && (byte_get (data + ent - pltgot, addr_size)
16674 >> (addr_size * 8 - 1)) != 0)
16675 {
16676 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16677 printf ("\n");
16678 if (ent == (bfd_vma) -1)
16679 goto sgot_print_fail;
16680 }
16681 printf ("\n");
16682 }
16683
16684 if (data != NULL && ent < end)
16685 {
16686 printf (_(" Local entries:\n"));
16687 printf (" %*s %10s %*s\n",
16688 addr_size * 2, _("Address"), _("Access"),
16689 addr_size * 2, _("Value"));
16690 while (ent < end)
16691 {
16692 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16693 printf ("\n");
16694 if (ent == (bfd_vma) -1)
16695 goto sgot_print_fail;
16696 }
16697 printf ("\n");
16698 }
16699
16700 sgot_print_fail:
16701 if (data)
16702 free (data);
16703 }
16704 return res;
16705 }
16706
16707 for (entry = filedata->dynamic_section;
16708 /* PR 17531 file: 012-50589-0.004. */
16709 (entry < filedata->dynamic_section + filedata->dynamic_nent
16710 && entry->d_tag != DT_NULL);
16711 ++entry)
16712 switch (entry->d_tag)
16713 {
16714 case DT_MIPS_LIBLIST:
16715 liblist_offset
16716 = offset_from_vma (filedata, entry->d_un.d_val,
16717 liblistno * sizeof (Elf32_External_Lib));
16718 break;
16719 case DT_MIPS_LIBLISTNO:
16720 liblistno = entry->d_un.d_val;
16721 break;
16722 case DT_MIPS_OPTIONS:
16723 options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
16724 break;
16725 case DT_MIPS_CONFLICT:
16726 conflicts_offset
16727 = offset_from_vma (filedata, entry->d_un.d_val,
16728 conflictsno * sizeof (Elf32_External_Conflict));
16729 break;
16730 case DT_MIPS_CONFLICTNO:
16731 conflictsno = entry->d_un.d_val;
16732 break;
16733 case DT_PLTGOT:
16734 pltgot = entry->d_un.d_ptr;
16735 break;
16736 case DT_MIPS_LOCAL_GOTNO:
16737 local_gotno = entry->d_un.d_val;
16738 break;
16739 case DT_MIPS_GOTSYM:
16740 gotsym = entry->d_un.d_val;
16741 break;
16742 case DT_MIPS_SYMTABNO:
16743 symtabno = entry->d_un.d_val;
16744 break;
16745 case DT_MIPS_PLTGOT:
16746 mips_pltgot = entry->d_un.d_ptr;
16747 break;
16748 case DT_PLTREL:
16749 pltrel = entry->d_un.d_val;
16750 break;
16751 case DT_PLTRELSZ:
16752 pltrelsz = entry->d_un.d_val;
16753 break;
16754 case DT_JMPREL:
16755 jmprel = entry->d_un.d_ptr;
16756 break;
16757 default:
16758 break;
16759 }
16760
16761 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
16762 {
16763 Elf32_External_Lib * elib;
16764 size_t cnt;
16765
16766 elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
16767 sizeof (Elf32_External_Lib),
16768 liblistno,
16769 _("liblist section data"));
16770 if (elib)
16771 {
16772 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16773 "\nSection '.liblist' contains %lu entries:\n",
16774 (unsigned long) liblistno),
16775 (unsigned long) liblistno);
16776 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16777 stdout);
16778
16779 for (cnt = 0; cnt < liblistno; ++cnt)
16780 {
16781 Elf32_Lib liblist;
16782 time_t atime;
16783 char timebuf[128];
16784 struct tm * tmp;
16785
16786 liblist.l_name = BYTE_GET (elib[cnt].l_name);
16787 atime = BYTE_GET (elib[cnt].l_time_stamp);
16788 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16789 liblist.l_version = BYTE_GET (elib[cnt].l_version);
16790 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16791
16792 tmp = gmtime (&atime);
16793 snprintf (timebuf, sizeof (timebuf),
16794 "%04u-%02u-%02uT%02u:%02u:%02u",
16795 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16796 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16797
16798 printf ("%3lu: ", (unsigned long) cnt);
16799 if (VALID_DYNAMIC_NAME (filedata, liblist.l_name))
16800 print_symbol (20, GET_DYNAMIC_NAME (filedata, liblist.l_name));
16801 else
16802 printf (_("<corrupt: %9ld>"), liblist.l_name);
16803 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
16804 liblist.l_version);
16805
16806 if (liblist.l_flags == 0)
16807 puts (_(" NONE"));
16808 else
16809 {
16810 static const struct
16811 {
16812 const char * name;
16813 int bit;
16814 }
16815 l_flags_vals[] =
16816 {
16817 { " EXACT_MATCH", LL_EXACT_MATCH },
16818 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
16819 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
16820 { " EXPORTS", LL_EXPORTS },
16821 { " DELAY_LOAD", LL_DELAY_LOAD },
16822 { " DELTA", LL_DELTA }
16823 };
16824 int flags = liblist.l_flags;
16825 size_t fcnt;
16826
16827 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
16828 if ((flags & l_flags_vals[fcnt].bit) != 0)
16829 {
16830 fputs (l_flags_vals[fcnt].name, stdout);
16831 flags ^= l_flags_vals[fcnt].bit;
16832 }
16833 if (flags != 0)
16834 printf (" %#x", (unsigned int) flags);
16835
16836 puts ("");
16837 }
16838 }
16839
16840 free (elib);
16841 }
16842 else
16843 res = FALSE;
16844 }
16845
16846 if (options_offset != 0)
16847 {
16848 Elf_External_Options * eopt;
16849 size_t offset;
16850 int cnt;
16851 sect = filedata->section_headers;
16852
16853 /* Find the section header so that we get the size. */
16854 sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
16855 /* PR 17533 file: 012-277276-0.004. */
16856 if (sect == NULL)
16857 {
16858 error (_("No MIPS_OPTIONS header found\n"));
16859 return FALSE;
16860 }
16861 /* PR 24243 */
16862 if (sect->sh_size < sizeof (* eopt))
16863 {
16864 error (_("The MIPS options section is too small.\n"));
16865 return FALSE;
16866 }
16867
16868 eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
16869 sect->sh_size, _("options"));
16870 if (eopt)
16871 {
16872 Elf_Internal_Options * iopt;
16873 Elf_Internal_Options * option;
16874 Elf_Internal_Options * iopt_end;
16875
16876 iopt = (Elf_Internal_Options *)
16877 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
16878 if (iopt == NULL)
16879 {
16880 error (_("Out of memory allocating space for MIPS options\n"));
16881 free (eopt);
16882 return FALSE;
16883 }
16884
16885 offset = cnt = 0;
16886 option = iopt;
16887 iopt_end = iopt + (sect->sh_size / sizeof (eopt));
16888
16889 while (offset <= sect->sh_size - sizeof (* eopt))
16890 {
16891 Elf_External_Options * eoption;
16892
16893 eoption = (Elf_External_Options *) ((char *) eopt + offset);
16894
16895 option->kind = BYTE_GET (eoption->kind);
16896 option->size = BYTE_GET (eoption->size);
16897 option->section = BYTE_GET (eoption->section);
16898 option->info = BYTE_GET (eoption->info);
16899
16900 /* PR 17531: file: ffa0fa3b. */
16901 if (option->size < sizeof (* eopt)
16902 || offset + option->size > sect->sh_size)
16903 {
16904 error (_("Invalid size (%u) for MIPS option\n"),
16905 option->size);
16906 free (iopt);
16907 free (eopt);
16908 return FALSE;
16909 }
16910 offset += option->size;
16911
16912 ++option;
16913 ++cnt;
16914 }
16915
16916 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16917 "\nSection '%s' contains %d entries:\n",
16918 cnt),
16919 printable_section_name (filedata, sect), cnt);
16920
16921 option = iopt;
16922 offset = 0;
16923
16924 while (cnt-- > 0)
16925 {
16926 size_t len;
16927
16928 switch (option->kind)
16929 {
16930 case ODK_NULL:
16931 /* This shouldn't happen. */
16932 printf (" NULL %d %lx", option->section, option->info);
16933 break;
16934
16935 case ODK_REGINFO:
16936 printf (" REGINFO ");
16937 if (filedata->file_header.e_machine == EM_MIPS)
16938 {
16939 Elf32_External_RegInfo * ereg;
16940 Elf32_RegInfo reginfo;
16941
16942 /* 32bit form. */
16943 if (option + 2 > iopt_end)
16944 {
16945 printf (_("<corrupt>\n"));
16946 error (_("Truncated MIPS REGINFO option\n"));
16947 cnt = 0;
16948 break;
16949 }
16950
16951 ereg = (Elf32_External_RegInfo *) (option + 1);
16952
16953 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
16954 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16955 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16956 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16957 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16958 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
16959
16960 printf ("GPR %08lx GP 0x%lx\n",
16961 reginfo.ri_gprmask,
16962 (unsigned long) reginfo.ri_gp_value);
16963 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16964 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16965 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16966 }
16967 else
16968 {
16969 /* 64 bit form. */
16970 Elf64_External_RegInfo * ereg;
16971 Elf64_Internal_RegInfo reginfo;
16972
16973 if (option + 2 > iopt_end)
16974 {
16975 printf (_("<corrupt>\n"));
16976 error (_("Truncated MIPS REGINFO option\n"));
16977 cnt = 0;
16978 break;
16979 }
16980
16981 ereg = (Elf64_External_RegInfo *) (option + 1);
16982 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
16983 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16984 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16985 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16986 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16987 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
16988
16989 printf ("GPR %08lx GP 0x",
16990 reginfo.ri_gprmask);
16991 printf_vma (reginfo.ri_gp_value);
16992 printf ("\n");
16993
16994 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16995 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16996 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16997 }
16998 ++option;
16999 continue;
17000
17001 case ODK_EXCEPTIONS:
17002 fputs (" EXCEPTIONS fpe_min(", stdout);
17003 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
17004 fputs (") fpe_max(", stdout);
17005 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
17006 fputs (")", stdout);
17007
17008 if (option->info & OEX_PAGE0)
17009 fputs (" PAGE0", stdout);
17010 if (option->info & OEX_SMM)
17011 fputs (" SMM", stdout);
17012 if (option->info & OEX_FPDBUG)
17013 fputs (" FPDBUG", stdout);
17014 if (option->info & OEX_DISMISS)
17015 fputs (" DISMISS", stdout);
17016 break;
17017
17018 case ODK_PAD:
17019 fputs (" PAD ", stdout);
17020 if (option->info & OPAD_PREFIX)
17021 fputs (" PREFIX", stdout);
17022 if (option->info & OPAD_POSTFIX)
17023 fputs (" POSTFIX", stdout);
17024 if (option->info & OPAD_SYMBOL)
17025 fputs (" SYMBOL", stdout);
17026 break;
17027
17028 case ODK_HWPATCH:
17029 fputs (" HWPATCH ", stdout);
17030 if (option->info & OHW_R4KEOP)
17031 fputs (" R4KEOP", stdout);
17032 if (option->info & OHW_R8KPFETCH)
17033 fputs (" R8KPFETCH", stdout);
17034 if (option->info & OHW_R5KEOP)
17035 fputs (" R5KEOP", stdout);
17036 if (option->info & OHW_R5KCVTL)
17037 fputs (" R5KCVTL", stdout);
17038 break;
17039
17040 case ODK_FILL:
17041 fputs (" FILL ", stdout);
17042 /* XXX Print content of info word? */
17043 break;
17044
17045 case ODK_TAGS:
17046 fputs (" TAGS ", stdout);
17047 /* XXX Print content of info word? */
17048 break;
17049
17050 case ODK_HWAND:
17051 fputs (" HWAND ", stdout);
17052 if (option->info & OHWA0_R4KEOP_CHECKED)
17053 fputs (" R4KEOP_CHECKED", stdout);
17054 if (option->info & OHWA0_R4KEOP_CLEAN)
17055 fputs (" R4KEOP_CLEAN", stdout);
17056 break;
17057
17058 case ODK_HWOR:
17059 fputs (" HWOR ", stdout);
17060 if (option->info & OHWA0_R4KEOP_CHECKED)
17061 fputs (" R4KEOP_CHECKED", stdout);
17062 if (option->info & OHWA0_R4KEOP_CLEAN)
17063 fputs (" R4KEOP_CLEAN", stdout);
17064 break;
17065
17066 case ODK_GP_GROUP:
17067 printf (" GP_GROUP %#06lx self-contained %#06lx",
17068 option->info & OGP_GROUP,
17069 (option->info & OGP_SELF) >> 16);
17070 break;
17071
17072 case ODK_IDENT:
17073 printf (" IDENT %#06lx self-contained %#06lx",
17074 option->info & OGP_GROUP,
17075 (option->info & OGP_SELF) >> 16);
17076 break;
17077
17078 default:
17079 /* This shouldn't happen. */
17080 printf (" %3d ??? %d %lx",
17081 option->kind, option->section, option->info);
17082 break;
17083 }
17084
17085 len = sizeof (* eopt);
17086 while (len < option->size)
17087 {
17088 unsigned char datum = * ((unsigned char *) eopt + offset + len);
17089
17090 if (ISPRINT (datum))
17091 printf ("%c", datum);
17092 else
17093 printf ("\\%03o", datum);
17094 len ++;
17095 }
17096 fputs ("\n", stdout);
17097
17098 offset += option->size;
17099 ++option;
17100 }
17101 free (iopt);
17102 free (eopt);
17103 }
17104 else
17105 res = FALSE;
17106 }
17107
17108 if (conflicts_offset != 0 && conflictsno != 0)
17109 {
17110 Elf32_Conflict * iconf;
17111 size_t cnt;
17112
17113 if (filedata->dynamic_symbols == NULL)
17114 {
17115 error (_("conflict list found without a dynamic symbol table\n"));
17116 return FALSE;
17117 }
17118
17119 /* PR 21345 - print a slightly more helpful error message
17120 if we are sure that the cmalloc will fail. */
17121 if (conflictsno > filedata->file_size / sizeof (* iconf))
17122 {
17123 error (_("Overlarge number of conflicts detected: %lx\n"),
17124 (long) conflictsno);
17125 return FALSE;
17126 }
17127
17128 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
17129 if (iconf == NULL)
17130 {
17131 error (_("Out of memory allocating space for dynamic conflicts\n"));
17132 return FALSE;
17133 }
17134
17135 if (is_32bit_elf)
17136 {
17137 Elf32_External_Conflict * econf32;
17138
17139 econf32 = (Elf32_External_Conflict *)
17140 get_data (NULL, filedata, conflicts_offset,
17141 sizeof (*econf32), conflictsno, _("conflict"));
17142 if (!econf32)
17143 {
17144 free (iconf);
17145 return FALSE;
17146 }
17147
17148 for (cnt = 0; cnt < conflictsno; ++cnt)
17149 iconf[cnt] = BYTE_GET (econf32[cnt]);
17150
17151 free (econf32);
17152 }
17153 else
17154 {
17155 Elf64_External_Conflict * econf64;
17156
17157 econf64 = (Elf64_External_Conflict *)
17158 get_data (NULL, filedata, conflicts_offset,
17159 sizeof (*econf64), conflictsno, _("conflict"));
17160 if (!econf64)
17161 {
17162 free (iconf);
17163 return FALSE;
17164 }
17165
17166 for (cnt = 0; cnt < conflictsno; ++cnt)
17167 iconf[cnt] = BYTE_GET (econf64[cnt]);
17168
17169 free (econf64);
17170 }
17171
17172 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
17173 "\nSection '.conflict' contains %lu entries:\n",
17174 (unsigned long) conflictsno),
17175 (unsigned long) conflictsno);
17176 puts (_(" Num: Index Value Name"));
17177
17178 for (cnt = 0; cnt < conflictsno; ++cnt)
17179 {
17180 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
17181
17182 if (iconf[cnt] >= filedata->num_dynamic_syms)
17183 printf (_("<corrupt symbol index>"));
17184 else
17185 {
17186 Elf_Internal_Sym * psym;
17187
17188 psym = & filedata->dynamic_symbols[iconf[cnt]];
17189 print_vma (psym->st_value, FULL_HEX);
17190 putchar (' ');
17191 if (VALID_DYNAMIC_NAME (filedata, psym->st_name))
17192 print_symbol (25, GET_DYNAMIC_NAME (filedata, psym->st_name));
17193 else
17194 printf (_("<corrupt: %14ld>"), psym->st_name);
17195 }
17196 putchar ('\n');
17197 }
17198
17199 free (iconf);
17200 }
17201
17202 if (pltgot != 0 && local_gotno != 0)
17203 {
17204 bfd_vma ent, local_end, global_end;
17205 size_t i, offset;
17206 unsigned char * data;
17207 unsigned char * data_end;
17208 int addr_size;
17209
17210 ent = pltgot;
17211 addr_size = (is_32bit_elf ? 4 : 8);
17212 local_end = pltgot + local_gotno * addr_size;
17213
17214 /* PR binutils/17533 file: 012-111227-0.004 */
17215 if (symtabno < gotsym)
17216 {
17217 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
17218 (unsigned long) gotsym, (unsigned long) symtabno);
17219 return FALSE;
17220 }
17221
17222 global_end = local_end + (symtabno - gotsym) * addr_size;
17223 /* PR 17531: file: 54c91a34. */
17224 if (global_end < local_end)
17225 {
17226 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
17227 return FALSE;
17228 }
17229
17230 offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
17231 data = (unsigned char *) get_data (NULL, filedata, offset,
17232 global_end - pltgot, 1,
17233 _("Global Offset Table data"));
17234 /* PR 12855: Null data is handled gracefully throughout. */
17235 data_end = data + (global_end - pltgot);
17236
17237 printf (_("\nPrimary GOT:\n"));
17238 printf (_(" Canonical gp value: "));
17239 print_vma (pltgot + 0x7ff0, LONG_HEX);
17240 printf ("\n\n");
17241
17242 printf (_(" Reserved entries:\n"));
17243 printf (_(" %*s %10s %*s Purpose\n"),
17244 addr_size * 2, _("Address"), _("Access"),
17245 addr_size * 2, _("Initial"));
17246 ent = print_mips_got_entry (data, pltgot, ent, data_end);
17247 printf (_(" Lazy resolver\n"));
17248 if (ent == (bfd_vma) -1)
17249 goto got_print_fail;
17250
17251 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
17252 This entry will be used by some runtime loaders, to store the
17253 module pointer. Otherwise this is an ordinary local entry.
17254 PR 21344: Check for the entry being fully available before
17255 fetching it. */
17256 if (data
17257 && data + ent - pltgot + addr_size <= data_end
17258 && (byte_get (data + ent - pltgot, addr_size)
17259 >> (addr_size * 8 - 1)) != 0)
17260 {
17261 ent = print_mips_got_entry (data, pltgot, ent, data_end);
17262 printf (_(" Module pointer (GNU extension)\n"));
17263 if (ent == (bfd_vma) -1)
17264 goto got_print_fail;
17265 }
17266 printf ("\n");
17267
17268 if (data != NULL && ent < local_end)
17269 {
17270 printf (_(" Local entries:\n"));
17271 printf (" %*s %10s %*s\n",
17272 addr_size * 2, _("Address"), _("Access"),
17273 addr_size * 2, _("Initial"));
17274 while (ent < local_end)
17275 {
17276 ent = print_mips_got_entry (data, pltgot, ent, data_end);
17277 printf ("\n");
17278 if (ent == (bfd_vma) -1)
17279 goto got_print_fail;
17280 }
17281 printf ("\n");
17282 }
17283
17284 if (data != NULL && gotsym < symtabno)
17285 {
17286 int sym_width;
17287
17288 printf (_(" Global entries:\n"));
17289 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
17290 addr_size * 2, _("Address"),
17291 _("Access"),
17292 addr_size * 2, _("Initial"),
17293 addr_size * 2, _("Sym.Val."),
17294 _("Type"),
17295 /* Note for translators: "Ndx" = abbreviated form of "Index". */
17296 _("Ndx"), _("Name"));
17297
17298 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
17299
17300 for (i = gotsym; i < symtabno; i++)
17301 {
17302 ent = print_mips_got_entry (data, pltgot, ent, data_end);
17303 printf (" ");
17304
17305 if (filedata->dynamic_symbols == NULL)
17306 printf (_("<no dynamic symbols>"));
17307 else if (i < filedata->num_dynamic_syms)
17308 {
17309 Elf_Internal_Sym * psym = filedata->dynamic_symbols + i;
17310
17311 print_vma (psym->st_value, LONG_HEX);
17312 printf (" %-7s %3s ",
17313 get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
17314 get_symbol_index_type (filedata, psym->st_shndx));
17315
17316 if (VALID_DYNAMIC_NAME (filedata, psym->st_name))
17317 print_symbol (sym_width,
17318 GET_DYNAMIC_NAME (filedata, psym->st_name));
17319 else
17320 printf (_("<corrupt: %14ld>"), psym->st_name);
17321 }
17322 else
17323 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
17324 (unsigned long) i);
17325
17326 printf ("\n");
17327 if (ent == (bfd_vma) -1)
17328 break;
17329 }
17330 printf ("\n");
17331 }
17332
17333 got_print_fail:
17334 if (data)
17335 free (data);
17336 }
17337
17338 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
17339 {
17340 bfd_vma ent, end;
17341 size_t offset, rel_offset;
17342 unsigned long count, i;
17343 unsigned char * data;
17344 int addr_size, sym_width;
17345 Elf_Internal_Rela * rels;
17346
17347 rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
17348 if (pltrel == DT_RELA)
17349 {
17350 if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
17351 return FALSE;
17352 }
17353 else
17354 {
17355 if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
17356 return FALSE;
17357 }
17358
17359 ent = mips_pltgot;
17360 addr_size = (is_32bit_elf ? 4 : 8);
17361 end = mips_pltgot + (2 + count) * addr_size;
17362
17363 offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
17364 data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
17365 1, _("Procedure Linkage Table data"));
17366 if (data == NULL)
17367 return FALSE;
17368
17369 printf ("\nPLT GOT:\n\n");
17370 printf (_(" Reserved entries:\n"));
17371 printf (_(" %*s %*s Purpose\n"),
17372 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
17373 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
17374 printf (_(" PLT lazy resolver\n"));
17375 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
17376 printf (_(" Module pointer\n"));
17377 printf ("\n");
17378
17379 printf (_(" Entries:\n"));
17380 printf (" %*s %*s %*s %-7s %3s %s\n",
17381 addr_size * 2, _("Address"),
17382 addr_size * 2, _("Initial"),
17383 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17384 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
17385 for (i = 0; i < count; i++)
17386 {
17387 unsigned long idx = get_reloc_symindex (rels[i].r_info);
17388
17389 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
17390 printf (" ");
17391
17392 if (idx >= filedata->num_dynamic_syms)
17393 printf (_("<corrupt symbol index: %lu>"), idx);
17394 else
17395 {
17396 Elf_Internal_Sym * psym = filedata->dynamic_symbols + idx;
17397
17398 print_vma (psym->st_value, LONG_HEX);
17399 printf (" %-7s %3s ",
17400 get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
17401 get_symbol_index_type (filedata, psym->st_shndx));
17402 if (VALID_DYNAMIC_NAME (filedata, psym->st_name))
17403 print_symbol (sym_width,
17404 GET_DYNAMIC_NAME (filedata, psym->st_name));
17405 else
17406 printf (_("<corrupt: %14ld>"), psym->st_name);
17407 }
17408 printf ("\n");
17409 }
17410 printf ("\n");
17411
17412 if (data)
17413 free (data);
17414 free (rels);
17415 }
17416
17417 return res;
17418}
17419
17420static bfd_boolean
17421process_nds32_specific (Filedata * filedata)
17422{
17423 Elf_Internal_Shdr *sect = NULL;
17424
17425 sect = find_section (filedata, ".nds32_e_flags");
17426 if (sect != NULL)
17427 {
17428 unsigned int *flag;
17429
17430 printf ("\nNDS32 elf flags section:\n");
17431 flag = get_data (NULL, filedata, sect->sh_offset, 1,
17432 sect->sh_size, _("NDS32 elf flags section"));
17433
17434 if (! flag)
17435 return FALSE;
17436
17437 switch ((*flag) & 0x3)
17438 {
17439 case 0:
17440 printf ("(VEC_SIZE):\tNo entry.\n");
17441 break;
17442 case 1:
17443 printf ("(VEC_SIZE):\t4 bytes\n");
17444 break;
17445 case 2:
17446 printf ("(VEC_SIZE):\t16 bytes\n");
17447 break;
17448 case 3:
17449 printf ("(VEC_SIZE):\treserved\n");
17450 break;
17451 }
17452 }
17453
17454 return TRUE;
17455}
17456
17457static bfd_boolean
17458process_gnu_liblist (Filedata * filedata)
17459{
17460 Elf_Internal_Shdr * section;
17461 Elf_Internal_Shdr * string_sec;
17462 Elf32_External_Lib * elib;
17463 char * strtab;
17464 size_t strtab_size;
17465 size_t cnt;
17466 unsigned long num_liblist;
17467 unsigned i;
17468 bfd_boolean res = TRUE;
17469
17470 if (! do_arch)
17471 return TRUE;
17472
17473 for (i = 0, section = filedata->section_headers;
17474 i < filedata->file_header.e_shnum;
17475 i++, section++)
17476 {
17477 switch (section->sh_type)
17478 {
17479 case SHT_GNU_LIBLIST:
17480 if (section->sh_link >= filedata->file_header.e_shnum)
17481 break;
17482
17483 elib = (Elf32_External_Lib *)
17484 get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
17485 _("liblist section data"));
17486
17487 if (elib == NULL)
17488 {
17489 res = FALSE;
17490 break;
17491 }
17492
17493 string_sec = filedata->section_headers + section->sh_link;
17494 strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
17495 string_sec->sh_size,
17496 _("liblist string table"));
17497 if (strtab == NULL
17498 || section->sh_entsize != sizeof (Elf32_External_Lib))
17499 {
17500 free (elib);
17501 free (strtab);
17502 res = FALSE;
17503 break;
17504 }
17505 strtab_size = string_sec->sh_size;
17506
17507 num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
17508 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17509 "\nLibrary list section '%s' contains %lu entries:\n",
17510 num_liblist),
17511 printable_section_name (filedata, section),
17512 num_liblist);
17513
17514 puts (_(" Library Time Stamp Checksum Version Flags"));
17515
17516 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
17517 ++cnt)
17518 {
17519 Elf32_Lib liblist;
17520 time_t atime;
17521 char timebuf[128];
17522 struct tm * tmp;
17523
17524 liblist.l_name = BYTE_GET (elib[cnt].l_name);
17525 atime = BYTE_GET (elib[cnt].l_time_stamp);
17526 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
17527 liblist.l_version = BYTE_GET (elib[cnt].l_version);
17528 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
17529
17530 tmp = gmtime (&atime);
17531 snprintf (timebuf, sizeof (timebuf),
17532 "%04u-%02u-%02uT%02u:%02u:%02u",
17533 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
17534 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
17535
17536 printf ("%3lu: ", (unsigned long) cnt);
17537 if (do_wide)
17538 printf ("%-20s", liblist.l_name < strtab_size
17539 ? strtab + liblist.l_name : _("<corrupt>"));
17540 else
17541 printf ("%-20.20s", liblist.l_name < strtab_size
17542 ? strtab + liblist.l_name : _("<corrupt>"));
17543 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
17544 liblist.l_version, liblist.l_flags);
17545 }
17546
17547 free (elib);
17548 free (strtab);
17549 }
17550 }
17551
17552 return res;
17553}
17554
17555static const char *
17556get_note_type (Filedata * filedata, unsigned e_type)
17557{
17558 static char buff[64];
17559
17560 if (filedata->file_header.e_type == ET_CORE)
17561 switch (e_type)
17562 {
17563 case NT_AUXV:
17564 return _("NT_AUXV (auxiliary vector)");
17565 case NT_PRSTATUS:
17566 return _("NT_PRSTATUS (prstatus structure)");
17567 case NT_FPREGSET:
17568 return _("NT_FPREGSET (floating point registers)");
17569 case NT_PRPSINFO:
17570 return _("NT_PRPSINFO (prpsinfo structure)");
17571 case NT_TASKSTRUCT:
17572 return _("NT_TASKSTRUCT (task structure)");
17573 case NT_PRXFPREG:
17574 return _("NT_PRXFPREG (user_xfpregs structure)");
17575 case NT_PPC_VMX:
17576 return _("NT_PPC_VMX (ppc Altivec registers)");
17577 case NT_PPC_VSX:
17578 return _("NT_PPC_VSX (ppc VSX registers)");
17579 case NT_PPC_TAR:
17580 return _("NT_PPC_TAR (ppc TAR register)");
17581 case NT_PPC_PPR:
17582 return _("NT_PPC_PPR (ppc PPR register)");
17583 case NT_PPC_DSCR:
17584 return _("NT_PPC_DSCR (ppc DSCR register)");
17585 case NT_PPC_EBB:
17586 return _("NT_PPC_EBB (ppc EBB registers)");
17587 case NT_PPC_PMU:
17588 return _("NT_PPC_PMU (ppc PMU registers)");
17589 case NT_PPC_TM_CGPR:
17590 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17591 case NT_PPC_TM_CFPR:
17592 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17593 case NT_PPC_TM_CVMX:
17594 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17595 case NT_PPC_TM_CVSX:
17596 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17597 case NT_PPC_TM_SPR:
17598 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17599 case NT_PPC_TM_CTAR:
17600 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17601 case NT_PPC_TM_CPPR:
17602 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17603 case NT_PPC_TM_CDSCR:
17604 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17605 case NT_386_TLS:
17606 return _("NT_386_TLS (x86 TLS information)");
17607 case NT_386_IOPERM:
17608 return _("NT_386_IOPERM (x86 I/O permissions)");
17609 case NT_X86_XSTATE:
17610 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17611 case NT_S390_HIGH_GPRS:
17612 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17613 case NT_S390_TIMER:
17614 return _("NT_S390_TIMER (s390 timer register)");
17615 case NT_S390_TODCMP:
17616 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17617 case NT_S390_TODPREG:
17618 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17619 case NT_S390_CTRS:
17620 return _("NT_S390_CTRS (s390 control registers)");
17621 case NT_S390_PREFIX:
17622 return _("NT_S390_PREFIX (s390 prefix register)");
17623 case NT_S390_LAST_BREAK:
17624 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17625 case NT_S390_SYSTEM_CALL:
17626 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17627 case NT_S390_TDB:
17628 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17629 case NT_S390_VXRS_LOW:
17630 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17631 case NT_S390_VXRS_HIGH:
17632 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17633 case NT_S390_GS_CB:
17634 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17635 case NT_S390_GS_BC:
17636 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17637 case NT_ARM_VFP:
17638 return _("NT_ARM_VFP (arm VFP registers)");
17639 case NT_ARM_TLS:
17640 return _("NT_ARM_TLS (AArch TLS registers)");
17641 case NT_ARM_HW_BREAK:
17642 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17643 case NT_ARM_HW_WATCH:
17644 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17645 case NT_ARC_V2:
17646 return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
17647 case NT_PSTATUS:
17648 return _("NT_PSTATUS (pstatus structure)");
17649 case NT_FPREGS:
17650 return _("NT_FPREGS (floating point registers)");
17651 case NT_PSINFO:
17652 return _("NT_PSINFO (psinfo structure)");
17653 case NT_LWPSTATUS:
17654 return _("NT_LWPSTATUS (lwpstatus_t structure)");
17655 case NT_LWPSINFO:
17656 return _("NT_LWPSINFO (lwpsinfo_t structure)");
17657 case NT_WIN32PSTATUS:
17658 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17659 case NT_SIGINFO:
17660 return _("NT_SIGINFO (siginfo_t data)");
17661 case NT_FILE:
17662 return _("NT_FILE (mapped files)");
17663 default:
17664 break;
17665 }
17666 else
17667 switch (e_type)
17668 {
17669 case NT_VERSION:
17670 return _("NT_VERSION (version)");
17671 case NT_ARCH:
17672 return _("NT_ARCH (architecture)");
17673 case NT_GNU_BUILD_ATTRIBUTE_OPEN:
17674 return _("OPEN");
17675 case NT_GNU_BUILD_ATTRIBUTE_FUNC:
17676 return _("func");
17677 default:
17678 break;
17679 }
17680
17681 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17682 return buff;
17683}
17684
17685static bfd_boolean
17686print_core_note (Elf_Internal_Note *pnote)
17687{
17688 unsigned int addr_size = is_32bit_elf ? 4 : 8;
17689 bfd_vma count, page_size;
17690 unsigned char *descdata, *filenames, *descend;
17691
17692 if (pnote->type != NT_FILE)
17693 {
17694 if (do_wide)
17695 printf ("\n");
17696 return TRUE;
17697 }
17698
17699#ifndef BFD64
17700 if (!is_32bit_elf)
17701 {
17702 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
17703 /* Still "successful". */
17704 return TRUE;
17705 }
17706#endif
17707
17708 if (pnote->descsz < 2 * addr_size)
17709 {
17710 error (_(" Malformed note - too short for header\n"));
17711 return FALSE;
17712 }
17713
17714 descdata = (unsigned char *) pnote->descdata;
17715 descend = descdata + pnote->descsz;
17716
17717 if (descdata[pnote->descsz - 1] != '\0')
17718 {
17719 error (_(" Malformed note - does not end with \\0\n"));
17720 return FALSE;
17721 }
17722
17723 count = byte_get (descdata, addr_size);
17724 descdata += addr_size;
17725
17726 page_size = byte_get (descdata, addr_size);
17727 descdata += addr_size;
17728
17729 if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
17730 || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
17731 {
17732 error (_(" Malformed note - too short for supplied file count\n"));
17733 return FALSE;
17734 }
17735
17736 printf (_(" Page size: "));
17737 print_vma (page_size, DEC);
17738 printf ("\n");
17739
17740 printf (_(" %*s%*s%*s\n"),
17741 (int) (2 + 2 * addr_size), _("Start"),
17742 (int) (4 + 2 * addr_size), _("End"),
17743 (int) (4 + 2 * addr_size), _("Page Offset"));
17744 filenames = descdata + count * 3 * addr_size;
17745 while (count-- > 0)
17746 {
17747 bfd_vma start, end, file_ofs;
17748
17749 if (filenames == descend)
17750 {
17751 error (_(" Malformed note - filenames end too early\n"));
17752 return FALSE;
17753 }
17754
17755 start = byte_get (descdata, addr_size);
17756 descdata += addr_size;
17757 end = byte_get (descdata, addr_size);
17758 descdata += addr_size;
17759 file_ofs = byte_get (descdata, addr_size);
17760 descdata += addr_size;
17761
17762 printf (" ");
17763 print_vma (start, FULL_HEX);
17764 printf (" ");
17765 print_vma (end, FULL_HEX);
17766 printf (" ");
17767 print_vma (file_ofs, FULL_HEX);
17768 printf ("\n %s\n", filenames);
17769
17770 filenames += 1 + strlen ((char *) filenames);
17771 }
17772
17773 return TRUE;
17774}
17775
17776static const char *
17777get_gnu_elf_note_type (unsigned e_type)
17778{
17779 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17780 switch (e_type)
17781 {
17782 case NT_GNU_ABI_TAG:
17783 return _("NT_GNU_ABI_TAG (ABI version tag)");
17784 case NT_GNU_HWCAP:
17785 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17786 case NT_GNU_BUILD_ID:
17787 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17788 case NT_GNU_GOLD_VERSION:
17789 return _("NT_GNU_GOLD_VERSION (gold version)");
17790 case NT_GNU_PROPERTY_TYPE_0:
17791 return _("NT_GNU_PROPERTY_TYPE_0");
17792 case NT_GNU_BUILD_ATTRIBUTE_OPEN:
17793 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17794 case NT_GNU_BUILD_ATTRIBUTE_FUNC:
17795 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17796 default:
17797 {
17798 static char buff[64];
17799
17800 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17801 return buff;
17802 }
17803 }
17804}
17805
17806static void
17807decode_x86_compat_isa (unsigned int bitmask)
17808{
17809 while (bitmask)
17810 {
17811 unsigned int bit = bitmask & (- bitmask);
17812
17813 bitmask &= ~ bit;
17814 switch (bit)
17815 {
17816 case GNU_PROPERTY_X86_COMPAT_ISA_1_486:
17817 printf ("i486");
17818 break;
17819 case GNU_PROPERTY_X86_COMPAT_ISA_1_586:
17820 printf ("586");
17821 break;
17822 case GNU_PROPERTY_X86_COMPAT_ISA_1_686:
17823 printf ("686");
17824 break;
17825 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE:
17826 printf ("SSE");
17827 break;
17828 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2:
17829 printf ("SSE2");
17830 break;
17831 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3:
17832 printf ("SSE3");
17833 break;
17834 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3:
17835 printf ("SSSE3");
17836 break;
17837 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1:
17838 printf ("SSE4_1");
17839 break;
17840 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2:
17841 printf ("SSE4_2");
17842 break;
17843 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX:
17844 printf ("AVX");
17845 break;
17846 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2:
17847 printf ("AVX2");
17848 break;
17849 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F:
17850 printf ("AVX512F");
17851 break;
17852 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD:
17853 printf ("AVX512CD");
17854 break;
17855 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER:
17856 printf ("AVX512ER");
17857 break;
17858 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF:
17859 printf ("AVX512PF");
17860 break;
17861 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL:
17862 printf ("AVX512VL");
17863 break;
17864 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ:
17865 printf ("AVX512DQ");
17866 break;
17867 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW:
17868 printf ("AVX512BW");
17869 break;
17870 default:
17871 printf (_("<unknown: %x>"), bit);
17872 break;
17873 }
17874 if (bitmask)
17875 printf (", ");
17876 }
17877}
17878
17879static void
17880decode_x86_isa (unsigned int bitmask)
17881{
17882 if (!bitmask)
17883 {
17884 printf (_("<None>"));
17885 return;
17886 }
17887
17888 while (bitmask)
17889 {
17890 unsigned int bit = bitmask & (- bitmask);
17891
17892 bitmask &= ~ bit;
17893 switch (bit)
17894 {
17895 case GNU_PROPERTY_X86_ISA_1_CMOV:
17896 printf ("CMOV");
17897 break;
17898 case GNU_PROPERTY_X86_ISA_1_SSE:
17899 printf ("SSE");
17900 break;
17901 case GNU_PROPERTY_X86_ISA_1_SSE2:
17902 printf ("SSE2");
17903 break;
17904 case GNU_PROPERTY_X86_ISA_1_SSE3:
17905 printf ("SSE3");
17906 break;
17907 case GNU_PROPERTY_X86_ISA_1_SSSE3:
17908 printf ("SSSE3");
17909 break;
17910 case GNU_PROPERTY_X86_ISA_1_SSE4_1:
17911 printf ("SSE4_1");
17912 break;
17913 case GNU_PROPERTY_X86_ISA_1_SSE4_2:
17914 printf ("SSE4_2");
17915 break;
17916 case GNU_PROPERTY_X86_ISA_1_AVX:
17917 printf ("AVX");
17918 break;
17919 case GNU_PROPERTY_X86_ISA_1_AVX2:
17920 printf ("AVX2");
17921 break;
17922 case GNU_PROPERTY_X86_ISA_1_FMA:
17923 printf ("FMA");
17924 break;
17925 case GNU_PROPERTY_X86_ISA_1_AVX512F:
17926 printf ("AVX512F");
17927 break;
17928 case GNU_PROPERTY_X86_ISA_1_AVX512CD:
17929 printf ("AVX512CD");
17930 break;
17931 case GNU_PROPERTY_X86_ISA_1_AVX512ER:
17932 printf ("AVX512ER");
17933 break;
17934 case GNU_PROPERTY_X86_ISA_1_AVX512PF:
17935 printf ("AVX512PF");
17936 break;
17937 case GNU_PROPERTY_X86_ISA_1_AVX512VL:
17938 printf ("AVX512VL");
17939 break;
17940 case GNU_PROPERTY_X86_ISA_1_AVX512DQ:
17941 printf ("AVX512DQ");
17942 break;
17943 case GNU_PROPERTY_X86_ISA_1_AVX512BW:
17944 printf ("AVX512BW");
17945 break;
17946 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS:
17947 printf ("AVX512_4FMAPS");
17948 break;
17949 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW:
17950 printf ("AVX512_4VNNIW");
17951 break;
17952 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG:
17953 printf ("AVX512_BITALG");
17954 break;
17955 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA:
17956 printf ("AVX512_IFMA");
17957 break;
17958 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI:
17959 printf ("AVX512_VBMI");
17960 break;
17961 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2:
17962 printf ("AVX512_VBMI2");
17963 break;
17964 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI:
17965 printf ("AVX512_VNNI");
17966 break;
17967 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16:
17968 printf ("AVX512_BF16");
17969 break;
17970 default:
17971 printf (_("<unknown: %x>"), bit);
17972 break;
17973 }
17974 if (bitmask)
17975 printf (", ");
17976 }
17977}
17978
17979static void
17980decode_x86_feature_1 (unsigned int bitmask)
17981{
17982 if (!bitmask)
17983 {
17984 printf (_("<None>"));
17985 return;
17986 }
17987
17988 while (bitmask)
17989 {
17990 unsigned int bit = bitmask & (- bitmask);
17991
17992 bitmask &= ~ bit;
17993 switch (bit)
17994 {
17995 case GNU_PROPERTY_X86_FEATURE_1_IBT:
17996 printf ("IBT");
17997 break;
17998 case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
17999 printf ("SHSTK");
18000 break;
18001 default:
18002 printf (_("<unknown: %x>"), bit);
18003 break;
18004 }
18005 if (bitmask)
18006 printf (", ");
18007 }
18008}
18009
18010static void
18011decode_x86_feature_2 (unsigned int bitmask)
18012{
18013 if (!bitmask)
18014 {
18015 printf (_("<None>"));
18016 return;
18017 }
18018
18019 while (bitmask)
18020 {
18021 unsigned int bit = bitmask & (- bitmask);
18022
18023 bitmask &= ~ bit;
18024 switch (bit)
18025 {
18026 case GNU_PROPERTY_X86_FEATURE_2_X86:
18027 printf ("x86");
18028 break;
18029 case GNU_PROPERTY_X86_FEATURE_2_X87:
18030 printf ("x87");
18031 break;
18032 case GNU_PROPERTY_X86_FEATURE_2_MMX:
18033 printf ("MMX");
18034 break;
18035 case GNU_PROPERTY_X86_FEATURE_2_XMM:
18036 printf ("XMM");
18037 break;
18038 case GNU_PROPERTY_X86_FEATURE_2_YMM:
18039 printf ("YMM");
18040 break;
18041 case GNU_PROPERTY_X86_FEATURE_2_ZMM:
18042 printf ("ZMM");
18043 break;
18044 case GNU_PROPERTY_X86_FEATURE_2_FXSR:
18045 printf ("FXSR");
18046 break;
18047 case GNU_PROPERTY_X86_FEATURE_2_XSAVE:
18048 printf ("XSAVE");
18049 break;
18050 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT:
18051 printf ("XSAVEOPT");
18052 break;
18053 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC:
18054 printf ("XSAVEC");
18055 break;
18056 default:
18057 printf (_("<unknown: %x>"), bit);
18058 break;
18059 }
18060 if (bitmask)
18061 printf (", ");
18062 }
18063}
18064
18065static void
18066decode_aarch64_feature_1_and (unsigned int bitmask)
18067{
18068 while (bitmask)
18069 {
18070 unsigned int bit = bitmask & (- bitmask);
18071
18072 bitmask &= ~ bit;
18073 switch (bit)
18074 {
18075 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI:
18076 printf ("BTI");
18077 break;
18078
18079 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC:
18080 printf ("PAC");
18081 break;
18082
18083 default:
18084 printf (_("<unknown: %x>"), bit);
18085 break;
18086 }
18087 if (bitmask)
18088 printf (", ");
18089 }
18090}
18091
18092static void
18093print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
18094{
18095 unsigned char * ptr = (unsigned char *) pnote->descdata;
18096 unsigned char * ptr_end = ptr + pnote->descsz;
18097 unsigned int size = is_32bit_elf ? 4 : 8;
18098
18099 printf (_(" Properties: "));
18100
18101 if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
18102 {
18103 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
18104 return;
18105 }
18106
18107 while (ptr < ptr_end)
18108 {
18109 unsigned int j;
18110 unsigned int type;
18111 unsigned int datasz;
18112
18113 if ((size_t) (ptr_end - ptr) < 8)
18114 {
18115 printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
18116 break;
18117 }
18118
18119 type = byte_get (ptr, 4);
18120 datasz = byte_get (ptr + 4, 4);
18121
18122 ptr += 8;
18123
18124 if (datasz > (size_t) (ptr_end - ptr))
18125 {
18126 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
18127 type, datasz);
18128 break;
18129 }
18130
18131 if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
18132 {
18133 if (filedata->file_header.e_machine == EM_X86_64
18134 || filedata->file_header.e_machine == EM_IAMCU
18135 || filedata->file_header.e_machine == EM_386)
18136 {
18137 unsigned int bitmask;
18138
18139 if (datasz == 4)
18140 bitmask = byte_get (ptr, 4);
18141 else
18142 bitmask = 0;
18143
18144 switch (type)
18145 {
18146 case GNU_PROPERTY_X86_ISA_1_USED:
18147 if (datasz != 4)
18148 printf (_("x86 ISA used: <corrupt length: %#x> "),
18149 datasz);
18150 else
18151 {
18152 printf ("x86 ISA used: ");
18153 decode_x86_isa (bitmask);
18154 }
18155 goto next;
18156
18157 case GNU_PROPERTY_X86_ISA_1_NEEDED:
18158 if (datasz != 4)
18159 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18160 datasz);
18161 else
18162 {
18163 printf ("x86 ISA needed: ");
18164 decode_x86_isa (bitmask);
18165 }
18166 goto next;
18167
18168 case GNU_PROPERTY_X86_FEATURE_1_AND:
18169 if (datasz != 4)
18170 printf (_("x86 feature: <corrupt length: %#x> "),
18171 datasz);
18172 else
18173 {
18174 printf ("x86 feature: ");
18175 decode_x86_feature_1 (bitmask);
18176 }
18177 goto next;
18178
18179 case GNU_PROPERTY_X86_FEATURE_2_USED:
18180 if (datasz != 4)
18181 printf (_("x86 feature used: <corrupt length: %#x> "),
18182 datasz);
18183 else
18184 {
18185 printf ("x86 feature used: ");
18186 decode_x86_feature_2 (bitmask);
18187 }
18188 goto next;
18189
18190 case GNU_PROPERTY_X86_FEATURE_2_NEEDED:
18191 if (datasz != 4)
18192 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz);
18193 else
18194 {
18195 printf ("x86 feature needed: ");
18196 decode_x86_feature_2 (bitmask);
18197 }
18198 goto next;
18199
18200 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED:
18201 if (datasz != 4)
18202 printf (_("x86 ISA used: <corrupt length: %#x> "),
18203 datasz);
18204 else
18205 {
18206 printf ("x86 ISA used: ");
18207 decode_x86_compat_isa (bitmask);
18208 }
18209 goto next;
18210
18211 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED:
18212 if (datasz != 4)
18213 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18214 datasz);
18215 else
18216 {
18217 printf ("x86 ISA needed: ");
18218 decode_x86_compat_isa (bitmask);
18219 }
18220 goto next;
18221
18222 default:
18223 break;
18224 }
18225 }
18226 else if (filedata->file_header.e_machine == EM_AARCH64)
18227 {
18228 if (type == GNU_PROPERTY_AARCH64_FEATURE_1_AND)
18229 {
18230 printf ("AArch64 feature: ");
18231 if (datasz != 4)
18232 printf (_("<corrupt length: %#x> "), datasz);
18233 else
18234 decode_aarch64_feature_1_and (byte_get (ptr, 4));
18235 goto next;
18236 }
18237 }
18238 }
18239 else
18240 {
18241 switch (type)
18242 {
18243 case GNU_PROPERTY_STACK_SIZE:
18244 printf (_("stack size: "));
18245 if (datasz != size)
18246 printf (_("<corrupt length: %#x> "), datasz);
18247 else
18248 printf ("%#lx", (unsigned long) byte_get (ptr, size));
18249 goto next;
18250
18251 case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
18252 printf ("no copy on protected ");
18253 if (datasz)
18254 printf (_("<corrupt length: %#x> "), datasz);
18255 goto next;
18256
18257 default:
18258 break;
18259 }
18260 }
18261
18262 if (type < GNU_PROPERTY_LOPROC)
18263 printf (_("<unknown type %#x data: "), type);
18264 else if (type < GNU_PROPERTY_LOUSER)
18265 printf (_("<procesor-specific type %#x data: "), type);
18266 else
18267 printf (_("<application-specific type %#x data: "), type);
18268 for (j = 0; j < datasz; ++j)
18269 printf ("%02x ", ptr[j] & 0xff);
18270 printf (">");
18271
18272 next:
18273 ptr += ((datasz + (size - 1)) & ~ (size - 1));
18274 if (ptr == ptr_end)
18275 break;
18276
18277 if (do_wide)
18278 printf (", ");
18279 else
18280 printf ("\n\t");
18281 }
18282
18283 printf ("\n");
18284}
18285
18286static bfd_boolean
18287print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
18288{
18289 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
18290 switch (pnote->type)
18291 {
18292 case NT_GNU_BUILD_ID:
18293 {
18294 unsigned long i;
18295
18296 printf (_(" Build ID: "));
18297 for (i = 0; i < pnote->descsz; ++i)
18298 printf ("%02x", pnote->descdata[i] & 0xff);
18299 printf ("\n");
18300 }
18301 break;
18302
18303 case NT_GNU_ABI_TAG:
18304 {
18305 unsigned long os, major, minor, subminor;
18306 const char *osname;
18307
18308 /* PR 17531: file: 030-599401-0.004. */
18309 if (pnote->descsz < 16)
18310 {
18311 printf (_(" <corrupt GNU_ABI_TAG>\n"));
18312 break;
18313 }
18314
18315 os = byte_get ((unsigned char *) pnote->descdata, 4);
18316 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
18317 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
18318 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
18319
18320 switch (os)
18321 {
18322 case GNU_ABI_TAG_LINUX:
18323 osname = "Linux";
18324 break;
18325 case GNU_ABI_TAG_HURD:
18326 osname = "Hurd";
18327 break;
18328 case GNU_ABI_TAG_SOLARIS:
18329 osname = "Solaris";
18330 break;
18331 case GNU_ABI_TAG_FREEBSD:
18332 osname = "FreeBSD";
18333 break;
18334 case GNU_ABI_TAG_NETBSD:
18335 osname = "NetBSD";
18336 break;
18337 case GNU_ABI_TAG_SYLLABLE:
18338 osname = "Syllable";
18339 break;
18340 case GNU_ABI_TAG_NACL:
18341 osname = "NaCl";
18342 break;
18343 default:
18344 osname = "Unknown";
18345 break;
18346 }
18347
18348 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
18349 major, minor, subminor);
18350 }
18351 break;
18352
18353 case NT_GNU_GOLD_VERSION:
18354 {
18355 unsigned long i;
18356
18357 printf (_(" Version: "));
18358 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
18359 printf ("%c", pnote->descdata[i]);
18360 printf ("\n");
18361 }
18362 break;
18363
18364 case NT_GNU_HWCAP:
18365 {
18366 unsigned long num_entries, mask;
18367
18368 /* Hardware capabilities information. Word 0 is the number of entries.
18369 Word 1 is a bitmask of enabled entries. The rest of the descriptor
18370 is a series of entries, where each entry is a single byte followed
18371 by a nul terminated string. The byte gives the bit number to test
18372 if enabled in the bitmask. */
18373 printf (_(" Hardware Capabilities: "));
18374 if (pnote->descsz < 8)
18375 {
18376 error (_("<corrupt GNU_HWCAP>\n"));
18377 return FALSE;
18378 }
18379 num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
18380 mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
18381 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
18382 /* FIXME: Add code to display the entries... */
18383 }
18384 break;
18385
18386 case NT_GNU_PROPERTY_TYPE_0:
18387 print_gnu_property_note (filedata, pnote);
18388 break;
18389
18390 default:
18391 /* Handle unrecognised types. An error message should have already been
18392 created by get_gnu_elf_note_type(), so all that we need to do is to
18393 display the data. */
18394 {
18395 unsigned long i;
18396
18397 printf (_(" Description data: "));
18398 for (i = 0; i < pnote->descsz; ++i)
18399 printf ("%02x ", pnote->descdata[i] & 0xff);
18400 printf ("\n");
18401 }
18402 break;
18403 }
18404
18405 return TRUE;
18406}
18407
18408static const char *
18409get_v850_elf_note_type (enum v850_notes n_type)
18410{
18411 static char buff[64];
18412
18413 switch (n_type)
18414 {
18415 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
18416 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
18417 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
18418 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
18419 case V850_NOTE_CACHE_INFO: return _("Use of cache");
18420 case V850_NOTE_MMU_INFO: return _("Use of MMU");
18421 default:
18422 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
18423 return buff;
18424 }
18425}
18426
18427static bfd_boolean
18428print_v850_note (Elf_Internal_Note * pnote)
18429{
18430 unsigned int val;
18431
18432 if (pnote->descsz != 4)
18433 return FALSE;
18434
18435 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
18436
18437 if (val == 0)
18438 {
18439 printf (_("not set\n"));
18440 return TRUE;
18441 }
18442
18443 switch (pnote->type)
18444 {
18445 case V850_NOTE_ALIGNMENT:
18446 switch (val)
18447 {
18448 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
18449 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
18450 }
18451 break;
18452
18453 case V850_NOTE_DATA_SIZE:
18454 switch (val)
18455 {
18456 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
18457 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
18458 }
18459 break;
18460
18461 case V850_NOTE_FPU_INFO:
18462 switch (val)
18463 {
18464 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
18465 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
18466 }
18467 break;
18468
18469 case V850_NOTE_MMU_INFO:
18470 case V850_NOTE_CACHE_INFO:
18471 case V850_NOTE_SIMD_INFO:
18472 if (val == EF_RH850_SIMD)
18473 {
18474 printf (_("yes\n"));
18475 return TRUE;
18476 }
18477 break;
18478
18479 default:
18480 /* An 'unknown note type' message will already have been displayed. */
18481 break;
18482 }
18483
18484 printf (_("unknown value: %x\n"), val);
18485 return FALSE;
18486}
18487
18488static bfd_boolean
18489process_netbsd_elf_note (Elf_Internal_Note * pnote)
18490{
18491 unsigned int version;
18492
18493 switch (pnote->type)
18494 {
18495 case NT_NETBSD_IDENT:
18496 if (pnote->descsz < 1)
18497 break;
18498 version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
18499 if ((version / 10000) % 100)
18500 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
18501 version, version / 100000000, (version / 1000000) % 100,
18502 (version / 10000) % 100 > 26 ? "Z" : "",
18503 'A' + (version / 10000) % 26);
18504 else
18505 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
18506 version, version / 100000000, (version / 1000000) % 100,
18507 (version / 100) % 100);
18508 return TRUE;
18509
18510 case NT_NETBSD_MARCH:
18511 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
18512 pnote->descdata);
18513 return TRUE;
18514
18515#ifdef NT_NETBSD_PAX
18516 case NT_NETBSD_PAX:
18517 if (pnote->descsz < 1)
18518 break;
18519 version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
18520 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote->descsz,
18521 ((version & NT_NETBSD_PAX_MPROTECT) ? "+mprotect" : ""),
18522 ((version & NT_NETBSD_PAX_NOMPROTECT) ? "-mprotect" : ""),
18523 ((version & NT_NETBSD_PAX_GUARD) ? "+guard" : ""),
18524 ((version & NT_NETBSD_PAX_NOGUARD) ? "-guard" : ""),
18525 ((version & NT_NETBSD_PAX_ASLR) ? "+ASLR" : ""),
18526 ((version & NT_NETBSD_PAX_NOASLR) ? "-ASLR" : ""));
18527 return TRUE;
18528#endif
18529 }
18530
18531 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
18532 pnote->descsz, pnote->type);
18533 return FALSE;
18534}
18535
18536static const char *
18537get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
18538{
18539 switch (e_type)
18540 {
18541 case NT_FREEBSD_THRMISC:
18542 return _("NT_THRMISC (thrmisc structure)");
18543 case NT_FREEBSD_PROCSTAT_PROC:
18544 return _("NT_PROCSTAT_PROC (proc data)");
18545 case NT_FREEBSD_PROCSTAT_FILES:
18546 return _("NT_PROCSTAT_FILES (files data)");
18547 case NT_FREEBSD_PROCSTAT_VMMAP:
18548 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18549 case NT_FREEBSD_PROCSTAT_GROUPS:
18550 return _("NT_PROCSTAT_GROUPS (groups data)");
18551 case NT_FREEBSD_PROCSTAT_UMASK:
18552 return _("NT_PROCSTAT_UMASK (umask data)");
18553 case NT_FREEBSD_PROCSTAT_RLIMIT:
18554 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18555 case NT_FREEBSD_PROCSTAT_OSREL:
18556 return _("NT_PROCSTAT_OSREL (osreldate data)");
18557 case NT_FREEBSD_PROCSTAT_PSSTRINGS:
18558 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18559 case NT_FREEBSD_PROCSTAT_AUXV:
18560 return _("NT_PROCSTAT_AUXV (auxv data)");
18561 case NT_FREEBSD_PTLWPINFO:
18562 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18563 }
18564 return get_note_type (filedata, e_type);
18565}
18566
18567static const char *
18568get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
18569{
18570 static char buff[64];
18571
18572 switch (e_type)
18573 {
18574 case NT_NETBSDCORE_PROCINFO:
18575 /* NetBSD core "procinfo" structure. */
18576 return _("NetBSD procinfo structure");
18577
18578#ifdef NT_NETBSDCORE_AUXV
18579 case NT_NETBSDCORE_AUXV:
18580 return _("NetBSD ELF auxiliary vector data");
18581#endif
18582
18583#ifdef NT_NETBSDCORE_LWPSTATUS
18584 case NT_NETBSDCORE_LWPSTATUS:
18585 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
18586#endif
18587
18588 default:
18589 /* As of Jan 2020 there are no other machine-independent notes
18590 defined for NetBSD core files. If the note type is less
18591 than the start of the machine-dependent note types, we don't
18592 understand it. */
18593
18594 if (e_type < NT_NETBSDCORE_FIRSTMACH)
18595 {
18596 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18597 return buff;
18598 }
18599 break;
18600 }
18601
18602 switch (filedata->file_header.e_machine)
18603 {
18604 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18605 and PT_GETFPREGS == mach+2. */
18606
18607 case EM_OLD_ALPHA:
18608 case EM_ALPHA:
18609 case EM_SPARC:
18610 case EM_SPARC32PLUS:
18611 case EM_SPARCV9:
18612 switch (e_type)
18613 {
18614 case NT_NETBSDCORE_FIRSTMACH + 0:
18615 return _("PT_GETREGS (reg structure)");
18616 case NT_NETBSDCORE_FIRSTMACH + 2:
18617 return _("PT_GETFPREGS (fpreg structure)");
18618 default:
18619 break;
18620 }
18621 break;
18622
18623 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18624 There's also old PT___GETREGS40 == mach + 1 for old reg
18625 structure which lacks GBR. */
18626 case EM_SH:
18627 switch (e_type)
18628 {
18629 case NT_NETBSDCORE_FIRSTMACH + 1:
18630 return _("PT___GETREGS40 (old reg structure)");
18631 case NT_NETBSDCORE_FIRSTMACH + 3:
18632 return _("PT_GETREGS (reg structure)");
18633 case NT_NETBSDCORE_FIRSTMACH + 5:
18634 return _("PT_GETFPREGS (fpreg structure)");
18635 default:
18636 break;
18637 }
18638 break;
18639
18640 /* On all other arch's, PT_GETREGS == mach+1 and
18641 PT_GETFPREGS == mach+3. */
18642 default:
18643 switch (e_type)
18644 {
18645 case NT_NETBSDCORE_FIRSTMACH + 1:
18646 return _("PT_GETREGS (reg structure)");
18647 case NT_NETBSDCORE_FIRSTMACH + 3:
18648 return _("PT_GETFPREGS (fpreg structure)");
18649 default:
18650 break;
18651 }
18652 }
18653
18654 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
18655 e_type - NT_NETBSDCORE_FIRSTMACH);
18656 return buff;
18657}
18658
18659static const char *
18660get_stapsdt_note_type (unsigned e_type)
18661{
18662 static char buff[64];
18663
18664 switch (e_type)
18665 {
18666 case NT_STAPSDT:
18667 return _("NT_STAPSDT (SystemTap probe descriptors)");
18668
18669 default:
18670 break;
18671 }
18672
18673 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18674 return buff;
18675}
18676
18677static bfd_boolean
18678print_stapsdt_note (Elf_Internal_Note *pnote)
18679{
18680 size_t len, maxlen;
18681 unsigned long addr_size = is_32bit_elf ? 4 : 8;
18682 char *data = pnote->descdata;
18683 char *data_end = pnote->descdata + pnote->descsz;
18684 bfd_vma pc, base_addr, semaphore;
18685 char *provider, *probe, *arg_fmt;
18686
18687 if (pnote->descsz < (addr_size * 3))
18688 goto stapdt_note_too_small;
18689
18690 pc = byte_get ((unsigned char *) data, addr_size);
18691 data += addr_size;
18692
18693 base_addr = byte_get ((unsigned char *) data, addr_size);
18694 data += addr_size;
18695
18696 semaphore = byte_get ((unsigned char *) data, addr_size);
18697 data += addr_size;
18698
18699 if (data >= data_end)
18700 goto stapdt_note_too_small;
18701 maxlen = data_end - data;
18702 len = strnlen (data, maxlen);
18703 if (len < maxlen)
18704 {
18705 provider = data;
18706 data += len + 1;
18707 }
18708 else
18709 goto stapdt_note_too_small;
18710
18711 if (data >= data_end)
18712 goto stapdt_note_too_small;
18713 maxlen = data_end - data;
18714 len = strnlen (data, maxlen);
18715 if (len < maxlen)
18716 {
18717 probe = data;
18718 data += len + 1;
18719 }
18720 else
18721 goto stapdt_note_too_small;
18722
18723 if (data >= data_end)
18724 goto stapdt_note_too_small;
18725 maxlen = data_end - data;
18726 len = strnlen (data, maxlen);
18727 if (len < maxlen)
18728 {
18729 arg_fmt = data;
18730 data += len + 1;
18731 }
18732 else
18733 goto stapdt_note_too_small;
18734
18735 printf (_(" Provider: %s\n"), provider);
18736 printf (_(" Name: %s\n"), probe);
18737 printf (_(" Location: "));
18738 print_vma (pc, FULL_HEX);
18739 printf (_(", Base: "));
18740 print_vma (base_addr, FULL_HEX);
18741 printf (_(", Semaphore: "));
18742 print_vma (semaphore, FULL_HEX);
18743 printf ("\n");
18744 printf (_(" Arguments: %s\n"), arg_fmt);
18745
18746 return data == data_end;
18747
18748 stapdt_note_too_small:
18749 printf (_(" <corrupt - note is too small>\n"));
18750 error (_("corrupt stapdt note - the data size is too small\n"));
18751 return FALSE;
18752}
18753
18754static const char *
18755get_ia64_vms_note_type (unsigned e_type)
18756{
18757 static char buff[64];
18758
18759 switch (e_type)
18760 {
18761 case NT_VMS_MHD:
18762 return _("NT_VMS_MHD (module header)");
18763 case NT_VMS_LNM:
18764 return _("NT_VMS_LNM (language name)");
18765 case NT_VMS_SRC:
18766 return _("NT_VMS_SRC (source files)");
18767 case NT_VMS_TITLE:
18768 return "NT_VMS_TITLE";
18769 case NT_VMS_EIDC:
18770 return _("NT_VMS_EIDC (consistency check)");
18771 case NT_VMS_FPMODE:
18772 return _("NT_VMS_FPMODE (FP mode)");
18773 case NT_VMS_LINKTIME:
18774 return "NT_VMS_LINKTIME";
18775 case NT_VMS_IMGNAM:
18776 return _("NT_VMS_IMGNAM (image name)");
18777 case NT_VMS_IMGID:
18778 return _("NT_VMS_IMGID (image id)");
18779 case NT_VMS_LINKID:
18780 return _("NT_VMS_LINKID (link id)");
18781 case NT_VMS_IMGBID:
18782 return _("NT_VMS_IMGBID (build id)");
18783 case NT_VMS_GSTNAM:
18784 return _("NT_VMS_GSTNAM (sym table name)");
18785 case NT_VMS_ORIG_DYN:
18786 return "NT_VMS_ORIG_DYN";
18787 case NT_VMS_PATCHTIME:
18788 return "NT_VMS_PATCHTIME";
18789 default:
18790 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18791 return buff;
18792 }
18793}
18794
18795static bfd_boolean
18796print_ia64_vms_note (Elf_Internal_Note * pnote)
18797{
18798 int maxlen = pnote->descsz;
18799
18800 if (maxlen < 2 || (unsigned long) maxlen != pnote->descsz)
18801 goto desc_size_fail;
18802
18803 switch (pnote->type)
18804 {
18805 case NT_VMS_MHD:
18806 if (maxlen <= 36)
18807 goto desc_size_fail;
18808
18809 int l = (int) strnlen (pnote->descdata + 34, maxlen - 34);
18810
18811 printf (_(" Creation date : %.17s\n"), pnote->descdata);
18812 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
18813 if (l + 34 < maxlen)
18814 {
18815 printf (_(" Module name : %s\n"), pnote->descdata + 34);
18816 if (l + 35 < maxlen)
18817 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
18818 else
18819 printf (_(" Module version : <missing>\n"));
18820 }
18821 else
18822 {
18823 printf (_(" Module name : <missing>\n"));
18824 printf (_(" Module version : <missing>\n"));
18825 }
18826 break;
18827
18828 case NT_VMS_LNM:
18829 printf (_(" Language: %.*s\n"), maxlen, pnote->descdata);
18830 break;
18831
18832#ifdef BFD64
18833 case NT_VMS_FPMODE:
18834 printf (_(" Floating Point mode: "));
18835 if (maxlen < 8)
18836 goto desc_size_fail;
18837 /* FIXME: Generate an error if descsz > 8 ? */
18838
18839 printf ("0x%016" BFD_VMA_FMT "x\n",
18840 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
18841 break;
18842
18843 case NT_VMS_LINKTIME:
18844 printf (_(" Link time: "));
18845 if (maxlen < 8)
18846 goto desc_size_fail;
18847 /* FIXME: Generate an error if descsz > 8 ? */
18848
18849 print_vms_time
18850 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
18851 printf ("\n");
18852 break;
18853
18854 case NT_VMS_PATCHTIME:
18855 printf (_(" Patch time: "));
18856 if (maxlen < 8)
18857 goto desc_size_fail;
18858 /* FIXME: Generate an error if descsz > 8 ? */
18859
18860 print_vms_time
18861 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
18862 printf ("\n");
18863 break;
18864
18865 case NT_VMS_ORIG_DYN:
18866 if (maxlen < 34)
18867 goto desc_size_fail;
18868
18869 printf (_(" Major id: %u, minor id: %u\n"),
18870 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
18871 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
18872 printf (_(" Last modified : "));
18873 print_vms_time
18874 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
18875 printf (_("\n Link flags : "));
18876 printf ("0x%016" BFD_VMA_FMT "x\n",
18877 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
18878 printf (_(" Header flags: 0x%08x\n"),
18879 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
18880 printf (_(" Image id : %.*s\n"), maxlen - 32, pnote->descdata + 32);
18881 break;
18882#endif
18883
18884 case NT_VMS_IMGNAM:
18885 printf (_(" Image name: %.*s\n"), maxlen, pnote->descdata);
18886 break;
18887
18888 case NT_VMS_GSTNAM:
18889 printf (_(" Global symbol table name: %.*s\n"), maxlen, pnote->descdata);
18890 break;
18891
18892 case NT_VMS_IMGID:
18893 printf (_(" Image id: %.*s\n"), maxlen, pnote->descdata);
18894 break;
18895
18896 case NT_VMS_LINKID:
18897 printf (_(" Linker id: %.*s\n"), maxlen, pnote->descdata);
18898 break;
18899
18900 default:
18901 return FALSE;
18902 }
18903
18904 return TRUE;
18905
18906 desc_size_fail:
18907 printf (_(" <corrupt - data size is too small>\n"));
18908 error (_("corrupt IA64 note: data size is too small\n"));
18909 return FALSE;
18910}
18911
18912struct build_attr_cache {
18913 Filedata *filedata;
18914 char *strtab;
18915 unsigned long strtablen;
18916 Elf_Internal_Sym *symtab;
18917 unsigned long nsyms;
18918} ba_cache;
18919
18920/* Find the symbol associated with a build attribute that is attached
18921 to address OFFSET. If PNAME is non-NULL then store the name of
18922 the symbol (if found) in the provided pointer, Returns NULL if a
18923 symbol could not be found. */
18924
18925static Elf_Internal_Sym *
18926get_symbol_for_build_attribute (Filedata * filedata,
18927 unsigned long offset,
18928 bfd_boolean is_open_attr,
18929 const char ** pname)
18930{
18931 Elf_Internal_Sym *saved_sym = NULL;
18932 Elf_Internal_Sym *sym;
18933
18934 if (filedata->section_headers != NULL
18935 && (ba_cache.filedata == NULL || filedata != ba_cache.filedata))
18936 {
18937 Elf_Internal_Shdr * symsec;
18938
18939 free (ba_cache.strtab);
18940 ba_cache.strtab = NULL;
18941 free (ba_cache.symtab);
18942 ba_cache.symtab = NULL;
18943
18944 /* Load the symbol and string sections. */
18945 for (symsec = filedata->section_headers;
18946 symsec < filedata->section_headers + filedata->file_header.e_shnum;
18947 symsec ++)
18948 {
18949 if (symsec->sh_type == SHT_SYMTAB
18950 && get_symtab (filedata, symsec,
18951 &ba_cache.symtab, &ba_cache.nsyms,
18952 &ba_cache.strtab, &ba_cache.strtablen))
18953 break;
18954 }
18955 ba_cache.filedata = filedata;
18956 }
18957
18958 if (ba_cache.symtab == NULL)
18959 return NULL;
18960
18961 /* Find a symbol whose value matches offset. */
18962 for (sym = ba_cache.symtab; sym < ba_cache.symtab + ba_cache.nsyms; sym ++)
18963 if (sym->st_value == offset)
18964 {
18965 if (sym->st_name >= ba_cache.strtablen)
18966 /* Huh ? This should not happen. */
18967 continue;
18968
18969 if (ba_cache.strtab[sym->st_name] == 0)
18970 continue;
18971
18972 /* The AArch64 and ARM architectures define mapping symbols
18973 (eg $d, $x, $t) which we want to ignore. */
18974 if (ba_cache.strtab[sym->st_name] == '$'
18975 && ba_cache.strtab[sym->st_name + 1] != 0
18976 && ba_cache.strtab[sym->st_name + 2] == 0)
18977 continue;
18978
18979 if (is_open_attr)
18980 {
18981 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
18982 and FILE or OBJECT symbols over NOTYPE symbols. We skip
18983 FUNC symbols entirely. */
18984 switch (ELF_ST_TYPE (sym->st_info))
18985 {
18986 case STT_OBJECT:
18987 case STT_FILE:
18988 saved_sym = sym;
18989 if (sym->st_size)
18990 {
18991 /* If the symbol has a size associated
18992 with it then we can stop searching. */
18993 sym = ba_cache.symtab + ba_cache.nsyms;
18994 }
18995 continue;
18996
18997 case STT_FUNC:
18998 /* Ignore function symbols. */
18999 continue;
19000
19001 default:
19002 break;
19003 }
19004
19005 switch (ELF_ST_BIND (sym->st_info))
19006 {
19007 case STB_GLOBAL:
19008 if (saved_sym == NULL
19009 || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
19010 saved_sym = sym;
19011 break;
19012
19013 case STB_LOCAL:
19014 if (saved_sym == NULL)
19015 saved_sym = sym;
19016 break;
19017
19018 default:
19019 break;
19020 }
19021 }
19022 else
19023 {
19024 if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
19025 continue;
19026
19027 saved_sym = sym;
19028 break;
19029 }
19030 }
19031
19032 if (saved_sym && pname)
19033 * pname = ba_cache.strtab + saved_sym->st_name;
19034
19035 return saved_sym;
19036}
19037
19038/* Returns true iff addr1 and addr2 are in the same section. */
19039
19040static bfd_boolean
19041same_section (Filedata * filedata, unsigned long addr1, unsigned long addr2)
19042{
19043 Elf_Internal_Shdr * a1;
19044 Elf_Internal_Shdr * a2;
19045
19046 a1 = find_section_by_address (filedata, addr1);
19047 a2 = find_section_by_address (filedata, addr2);
19048
19049 return a1 == a2 && a1 != NULL;
19050}
19051
19052static bfd_boolean
19053print_gnu_build_attribute_description (Elf_Internal_Note * pnote,
19054 Filedata * filedata)
19055{
19056 static unsigned long global_offset = 0;
19057 static unsigned long global_end = 0;
19058 static unsigned long func_offset = 0;
19059 static unsigned long func_end = 0;
19060
19061 Elf_Internal_Sym * sym;
19062 const char * name;
19063 unsigned long start;
19064 unsigned long end;
19065 bfd_boolean is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
19066
19067 switch (pnote->descsz)
19068 {
19069 case 0:
19070 /* A zero-length description means that the range of
19071 the previous note of the same type should be used. */
19072 if (is_open_attr)
19073 {
19074 if (global_end > global_offset)
19075 printf (_(" Applies to region from %#lx to %#lx\n"),
19076 global_offset, global_end);
19077 else
19078 printf (_(" Applies to region from %#lx\n"), global_offset);
19079 }
19080 else
19081 {
19082 if (func_end > func_offset)
19083 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset, func_end);
19084 else
19085 printf (_(" Applies to region from %#lx\n"), func_offset);
19086 }
19087 return TRUE;
19088
19089 case 4:
19090 start = byte_get ((unsigned char *) pnote->descdata, 4);
19091 end = 0;
19092 break;
19093
19094 case 8:
19095 if (is_32bit_elf)
19096 {
19097 /* FIXME: We should check that version 3+ notes are being used here... */
19098 start = byte_get ((unsigned char *) pnote->descdata, 4);
19099 end = byte_get ((unsigned char *) pnote->descdata + 4, 4);
19100 }
19101 else
19102 {
19103 start = byte_get ((unsigned char *) pnote->descdata, 8);
19104 end = 0;
19105 }
19106 break;
19107
19108 case 16:
19109 start = byte_get ((unsigned char *) pnote->descdata, 8);
19110 end = byte_get ((unsigned char *) pnote->descdata + 8, 8);
19111 break;
19112
19113 default:
19114 error (_(" <invalid description size: %lx>\n"), pnote->descsz);
19115 printf (_(" <invalid descsz>"));
19116 return FALSE;
19117 }
19118
19119 name = NULL;
19120 sym = get_symbol_for_build_attribute (filedata, start, is_open_attr, & name);
19121 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
19122 in order to avoid them being confused with the start address of the
19123 first function in the file... */
19124 if (sym == NULL && is_open_attr)
19125 sym = get_symbol_for_build_attribute (filedata, start + 2, is_open_attr,
19126 & name);
19127
19128 if (end == 0 && sym != NULL && sym->st_size > 0)
19129 end = start + sym->st_size;
19130
19131 if (is_open_attr)
19132 {
19133 /* FIXME: Need to properly allow for section alignment.
19134 16 is just the alignment used on x86_64. */
19135 if (global_end > 0
19136 && start > BFD_ALIGN (global_end, 16)
19137 /* Build notes are not guaranteed to be organised in order of
19138 increasing address, but we should find the all of the notes
19139 for one section in the same place. */
19140 && same_section (filedata, start, global_end))
19141 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
19142 global_end + 1, start - 1);
19143
19144 printf (_(" Applies to region from %#lx"), start);
19145 global_offset = start;
19146
19147 if (end)
19148 {
19149 printf (_(" to %#lx"), end);
19150 global_end = end;
19151 }
19152 }
19153 else
19154 {
19155 printf (_(" Applies to region from %#lx"), start);
19156 func_offset = start;
19157
19158 if (end)
19159 {
19160 printf (_(" to %#lx"), end);
19161 func_end = end;
19162 }
19163 }
19164
19165 if (sym && name)
19166 printf (_(" (%s)"), name);
19167
19168 printf ("\n");
19169 return TRUE;
19170}
19171
19172static bfd_boolean
19173print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
19174{
19175 static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
19176 static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
19177 static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
19178 char name_type;
19179 char name_attribute;
19180 const char * expected_types;
19181 const char * name = pnote->namedata;
19182 const char * text;
19183 signed int left;
19184
19185 if (name == NULL || pnote->namesz < 2)
19186 {
19187 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
19188 print_symbol (-20, _(" <corrupt name>"));
19189 return FALSE;
19190 }
19191
19192 if (do_wide)
19193 left = 28;
19194 else
19195 left = 20;
19196
19197 /* Version 2 of the spec adds a "GA" prefix to the name field. */
19198 if (name[0] == 'G' && name[1] == 'A')
19199 {
19200 if (pnote->namesz < 4)
19201 {
19202 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
19203 print_symbol (-20, _(" <corrupt name>"));
19204 return FALSE;
19205 }
19206
19207 printf ("GA");
19208 name += 2;
19209 left -= 2;
19210 }
19211
19212 switch ((name_type = * name))
19213 {
19214 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
19215 case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
19216 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
19217 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
19218 printf ("%c", * name);
19219 left --;
19220 break;
19221 default:
19222 error (_("unrecognised attribute type in name field: %d\n"), name_type);
19223 print_symbol (-20, _("<unknown name type>"));
19224 return FALSE;
19225 }
19226
19227 ++ name;
19228 text = NULL;
19229
19230 switch ((name_attribute = * name))
19231 {
19232 case GNU_BUILD_ATTRIBUTE_VERSION:
19233 text = _("<version>");
19234 expected_types = string_expected;
19235 ++ name;
19236 break;
19237 case GNU_BUILD_ATTRIBUTE_STACK_PROT:
19238 text = _("<stack prot>");
19239 expected_types = "!+*";
19240 ++ name;
19241 break;
19242 case GNU_BUILD_ATTRIBUTE_RELRO:
19243 text = _("<relro>");
19244 expected_types = bool_expected;
19245 ++ name;
19246 break;
19247 case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
19248 text = _("<stack size>");
19249 expected_types = number_expected;
19250 ++ name;
19251 break;
19252 case GNU_BUILD_ATTRIBUTE_TOOL:
19253 text = _("<tool>");
19254 expected_types = string_expected;
19255 ++ name;
19256 break;
19257 case GNU_BUILD_ATTRIBUTE_ABI:
19258 text = _("<ABI>");
19259 expected_types = "$*";
19260 ++ name;
19261 break;
19262 case GNU_BUILD_ATTRIBUTE_PIC:
19263 text = _("<PIC>");
19264 expected_types = number_expected;
19265 ++ name;
19266 break;
19267 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
19268 text = _("<short enum>");
19269 expected_types = bool_expected;
19270 ++ name;
19271 break;
19272 default:
19273 if (ISPRINT (* name))
19274 {
19275 int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
19276
19277 if (len > left && ! do_wide)
19278 len = left;
19279 printf ("%.*s:", len, name);
19280 left -= len;
19281 name += len;
19282 }
19283 else
19284 {
19285 static char tmpbuf [128];
19286
19287 error (_("unrecognised byte in name field: %d\n"), * name);
19288 sprintf (tmpbuf, _("<unknown:_%d>"), * name);
19289 text = tmpbuf;
19290 name ++;
19291 }
19292 expected_types = "*$!+";
19293 break;
19294 }
19295
19296 if (text)
19297 left -= printf ("%s", text);
19298
19299 if (strchr (expected_types, name_type) == NULL)
19300 warn (_("attribute does not have an expected type (%c)\n"), name_type);
19301
19302 if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
19303 {
19304 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
19305 (unsigned long) pnote->namesz,
19306 (long) (name - pnote->namedata));
19307 return FALSE;
19308 }
19309
19310 if (left < 1 && ! do_wide)
19311 return TRUE;
19312
19313 switch (name_type)
19314 {
19315 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
19316 {
19317 unsigned int bytes;
19318 unsigned long long val = 0;
19319 unsigned int shift = 0;
19320 char * decoded = NULL;
19321
19322 bytes = pnote->namesz - (name - pnote->namedata);
19323 if (bytes > 0)
19324 /* The -1 is because the name field is always 0 terminated, and we
19325 want to be able to ensure that the shift in the while loop below
19326 will not overflow. */
19327 -- bytes;
19328
19329 if (bytes > sizeof (val))
19330 {
19331 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
19332 bytes);
19333 bytes = sizeof (val);
19334 }
19335 /* We do not bother to warn if bytes == 0 as this can
19336 happen with some early versions of the gcc plugin. */
19337
19338 while (bytes --)
19339 {
19340 unsigned long byte = (* name ++) & 0xff;
19341
19342 val |= byte << shift;
19343 shift += 8;
19344 }
19345
19346 switch (name_attribute)
19347 {
19348 case GNU_BUILD_ATTRIBUTE_PIC:
19349 switch (val)
19350 {
19351 case 0: decoded = "static"; break;
19352 case 1: decoded = "pic"; break;
19353 case 2: decoded = "PIC"; break;
19354 case 3: decoded = "pie"; break;
19355 case 4: decoded = "PIE"; break;
19356 default: break;
19357 }
19358 break;
19359 case GNU_BUILD_ATTRIBUTE_STACK_PROT:
19360 switch (val)
19361 {
19362 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
19363 case 0: decoded = "off"; break;
19364 case 1: decoded = "on"; break;
19365 case 2: decoded = "all"; break;
19366 case 3: decoded = "strong"; break;
19367 case 4: decoded = "explicit"; break;
19368 default: break;
19369 }
19370 break;
19371 default:
19372 break;
19373 }
19374
19375 if (decoded != NULL)
19376 {
19377 print_symbol (-left, decoded);
19378 left = 0;
19379 }
19380 else if (val == 0)
19381 {
19382 printf ("0x0");
19383 left -= 3;
19384 }
19385 else
19386 {
19387 if (do_wide)
19388 left -= printf ("0x%llx", val);
19389 else
19390 left -= printf ("0x%-.*llx", left, val);
19391 }
19392 }
19393 break;
19394 case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
19395 left -= print_symbol (- left, name);
19396 break;
19397 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
19398 left -= print_symbol (- left, "true");
19399 break;
19400 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
19401 left -= print_symbol (- left, "false");
19402 break;
19403 }
19404
19405 if (do_wide && left > 0)
19406 printf ("%-*s", left, " ");
19407
19408 return TRUE;
19409}
19410
19411/* Note that by the ELF standard, the name field is already null byte
19412 terminated, and namesz includes the terminating null byte.
19413 I.E. the value of namesz for the name "FSF" is 4.
19414
19415 If the value of namesz is zero, there is no name present. */
19416
19417static bfd_boolean
19418process_note (Elf_Internal_Note * pnote,
19419 Filedata * filedata)
19420{
19421 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
19422 const char * nt;
19423
19424 if (pnote->namesz == 0)
19425 /* If there is no note name, then use the default set of
19426 note type strings. */
19427 nt = get_note_type (filedata, pnote->type);
19428
19429 else if (const_strneq (pnote->namedata, "GNU"))
19430 /* GNU-specific object file notes. */
19431 nt = get_gnu_elf_note_type (pnote->type);
19432
19433 else if (const_strneq (pnote->namedata, "FreeBSD"))
19434 /* FreeBSD-specific core file notes. */
19435 nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
19436
19437 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
19438 /* NetBSD-specific core file notes. */
19439 nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
19440
19441 else if (const_strneq (pnote->namedata, "NetBSD"))
19442 /* NetBSD-specific core file notes. */
19443 return process_netbsd_elf_note (pnote);
19444
19445 else if (const_strneq (pnote->namedata, "PaX"))
19446 /* NetBSD-specific core file notes. */
19447 return process_netbsd_elf_note (pnote);
19448
19449 else if (strneq (pnote->namedata, "SPU/", 4))
19450 {
19451 /* SPU-specific core file notes. */
19452 nt = pnote->namedata + 4;
19453 name = "SPU";
19454 }
19455
19456 else if (const_strneq (pnote->namedata, "IPF/VMS"))
19457 /* VMS/ia64-specific file notes. */
19458 nt = get_ia64_vms_note_type (pnote->type);
19459
19460 else if (const_strneq (pnote->namedata, "stapsdt"))
19461 nt = get_stapsdt_note_type (pnote->type);
19462
19463 else
19464 /* Don't recognize this note name; just use the default set of
19465 note type strings. */
19466 nt = get_note_type (filedata, pnote->type);
19467
19468 printf (" ");
19469
19470 if (((const_strneq (pnote->namedata, "GA")
19471 && strchr ("*$!+", pnote->namedata[2]) != NULL)
19472 || strchr ("*$!+", pnote->namedata[0]) != NULL)
19473 && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
19474 || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
19475 print_gnu_build_attribute_name (pnote);
19476 else
19477 print_symbol (-20, name);
19478
19479 if (do_wide)
19480 printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
19481 else
19482 printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
19483
19484 if (const_strneq (pnote->namedata, "IPF/VMS"))
19485 return print_ia64_vms_note (pnote);
19486 else if (const_strneq (pnote->namedata, "GNU"))
19487 return print_gnu_note (filedata, pnote);
19488 else if (const_strneq (pnote->namedata, "stapsdt"))
19489 return print_stapsdt_note (pnote);
19490 else if (const_strneq (pnote->namedata, "CORE"))
19491 return print_core_note (pnote);
19492 else if (((const_strneq (pnote->namedata, "GA")
19493 && strchr ("*$!+", pnote->namedata[2]) != NULL)
19494 || strchr ("*$!+", pnote->namedata[0]) != NULL)
19495 && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
19496 || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
19497 return print_gnu_build_attribute_description (pnote, filedata);
19498
19499 if (pnote->descsz)
19500 {
19501 unsigned long i;
19502
19503 printf (_(" description data: "));
19504 for (i = 0; i < pnote->descsz; i++)
19505 printf ("%02x ", pnote->descdata[i] & 0xff);
19506 if (!do_wide)
19507 printf ("\n");
19508 }
19509
19510 if (do_wide)
19511 printf ("\n");
19512
19513 return TRUE;
19514}
19515
19516static bfd_boolean
19517process_notes_at (Filedata * filedata,
19518 Elf_Internal_Shdr * section,
19519 bfd_vma offset,
19520 bfd_vma length,
19521 bfd_vma align)
19522{
19523 Elf_External_Note * pnotes;
19524 Elf_External_Note * external;
19525 char * end;
19526 bfd_boolean res = TRUE;
19527
19528 if (length <= 0)
19529 return FALSE;
19530
19531 if (section)
19532 {
19533 pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
19534 if (pnotes)
19535 {
19536 if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
19537 {
19538 free (pnotes);
19539 return FALSE;
19540 }
19541 }
19542 }
19543 else
19544 pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
19545 _("notes"));
19546
19547 if (pnotes == NULL)
19548 return FALSE;
19549
19550 external = pnotes;
19551
19552 if (section)
19553 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
19554 else
19555 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19556 (unsigned long) offset, (unsigned long) length);
19557
19558 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19559 specifies that notes should be aligned to 4 bytes in 32-bit
19560 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19561 we also support 4 byte alignment in 64-bit objects. If section
19562 alignment is less than 4, we treate alignment as 4 bytes. */
19563 if (align < 4)
19564 align = 4;
19565 else if (align != 4 && align != 8)
19566 {
19567 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19568 (long) align);
19569 free (pnotes);
19570 return FALSE;
19571 }
19572
19573 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19574
19575 end = (char *) pnotes + length;
19576 while ((char *) external < end)
19577 {
19578 Elf_Internal_Note inote;
19579 size_t min_notesz;
19580 char * next;
19581 char * temp = NULL;
19582 size_t data_remaining = end - (char *) external;
19583
19584 if (!is_ia64_vms (filedata))
19585 {
19586 /* PR binutils/15191
19587 Make sure that there is enough data to read. */
19588 min_notesz = offsetof (Elf_External_Note, name);
19589 if (data_remaining < min_notesz)
19590 {
19591 warn (ngettext ("Corrupt note: only %ld byte remains, "
19592 "not enough for a full note\n",
19593 "Corrupt note: only %ld bytes remain, "
19594 "not enough for a full note\n",
19595 data_remaining),
19596 (long) data_remaining);
19597 break;
19598 }
19599 data_remaining -= min_notesz;
19600
19601 inote.type = BYTE_GET (external->type);
19602 inote.namesz = BYTE_GET (external->namesz);
19603 inote.namedata = external->name;
19604 inote.descsz = BYTE_GET (external->descsz);
19605 inote.descdata = ((char *) external
19606 + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
19607 inote.descpos = offset + (inote.descdata - (char *) pnotes);
19608 next = ((char *) external
19609 + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
19610 }
19611 else
19612 {
19613 Elf64_External_VMS_Note *vms_external;
19614
19615 /* PR binutils/15191
19616 Make sure that there is enough data to read. */
19617 min_notesz = offsetof (Elf64_External_VMS_Note, name);
19618 if (data_remaining < min_notesz)
19619 {
19620 warn (ngettext ("Corrupt note: only %ld byte remains, "
19621 "not enough for a full note\n",
19622 "Corrupt note: only %ld bytes remain, "
19623 "not enough for a full note\n",
19624 data_remaining),
19625 (long) data_remaining);
19626 break;
19627 }
19628 data_remaining -= min_notesz;
19629
19630 vms_external = (Elf64_External_VMS_Note *) external;
19631 inote.type = BYTE_GET (vms_external->type);
19632 inote.namesz = BYTE_GET (vms_external->namesz);
19633 inote.namedata = vms_external->name;
19634 inote.descsz = BYTE_GET (vms_external->descsz);
19635 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
19636 inote.descpos = offset + (inote.descdata - (char *) pnotes);
19637 next = inote.descdata + align_power (inote.descsz, 3);
19638 }
19639
19640 /* PR 17531: file: 3443835e. */
19641 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19642 if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
19643 || (size_t) (inote.descdata - inote.namedata) > data_remaining
19644 || (size_t) (next - inote.descdata) < inote.descsz
19645 || ((size_t) (next - inote.descdata)
19646 > data_remaining - (size_t) (inote.descdata - inote.namedata)))
19647 {
19648 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19649 (unsigned long) ((char *) external - (char *) pnotes));
19650 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19651 inote.type, inote.namesz, inote.descsz, (int) align);
19652 break;
19653 }
19654
19655 external = (Elf_External_Note *) next;
19656
19657 /* Verify that name is null terminated. It appears that at least
19658 one version of Linux (RedHat 6.0) generates corefiles that don't
19659 comply with the ELF spec by failing to include the null byte in
19660 namesz. */
19661 if (inote.namesz > 0 && inote.namedata[inote.namesz - 1] != '\0')
19662 {
19663 if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
19664 {
19665 temp = (char *) malloc (inote.namesz + 1);
19666 if (temp == NULL)
19667 {
19668 error (_("Out of memory allocating space for inote name\n"));
19669 res = FALSE;
19670 break;
19671 }
19672
19673 memcpy (temp, inote.namedata, inote.namesz);
19674 inote.namedata = temp;
19675 }
19676 inote.namedata[inote.namesz] = 0;
19677 }
19678
19679 if (! process_note (& inote, filedata))
19680 res = FALSE;
19681
19682 if (temp != NULL)
19683 {
19684 free (temp);
19685 temp = NULL;
19686 }
19687 }
19688
19689 free (pnotes);
19690
19691 return res;
19692}
19693
19694static bfd_boolean
19695process_corefile_note_segments (Filedata * filedata)
19696{
19697 Elf_Internal_Phdr * segment;
19698 unsigned int i;
19699 bfd_boolean res = TRUE;
19700
19701 if (! get_program_headers (filedata))
19702 return TRUE;
19703
19704 for (i = 0, segment = filedata->program_headers;
19705 i < filedata->file_header.e_phnum;
19706 i++, segment++)
19707 {
19708 if (segment->p_type == PT_NOTE)
19709 if (! process_notes_at (filedata, NULL,
19710 (bfd_vma) segment->p_offset,
19711 (bfd_vma) segment->p_filesz,
19712 (bfd_vma) segment->p_align))
19713 res = FALSE;
19714 }
19715
19716 return res;
19717}
19718
19719static bfd_boolean
19720process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
19721{
19722 Elf_External_Note * pnotes;
19723 Elf_External_Note * external;
19724 char * end;
19725 bfd_boolean res = TRUE;
19726
19727 if (length <= 0)
19728 return FALSE;
19729
19730 pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
19731 _("v850 notes"));
19732 if (pnotes == NULL)
19733 return FALSE;
19734
19735 external = pnotes;
19736 end = (char*) pnotes + length;
19737
19738 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19739 (unsigned long) offset, (unsigned long) length);
19740
19741 while ((char *) external + sizeof (Elf_External_Note) < end)
19742 {
19743 Elf_External_Note * next;
19744 Elf_Internal_Note inote;
19745
19746 inote.type = BYTE_GET (external->type);
19747 inote.namesz = BYTE_GET (external->namesz);
19748 inote.namedata = external->name;
19749 inote.descsz = BYTE_GET (external->descsz);
19750 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
19751 inote.descpos = offset + (inote.descdata - (char *) pnotes);
19752
19753 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
19754 {
19755 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
19756 inote.descdata = inote.namedata;
19757 inote.namesz = 0;
19758 }
19759
19760 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
19761
19762 if ( ((char *) next > end)
19763 || ((char *) next < (char *) pnotes))
19764 {
19765 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19766 (unsigned long) ((char *) external - (char *) pnotes));
19767 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19768 inote.type, inote.namesz, inote.descsz);
19769 break;
19770 }
19771
19772 external = next;
19773
19774 /* Prevent out-of-bounds indexing. */
19775 if ( inote.namedata + inote.namesz > end
19776 || inote.namedata + inote.namesz < inote.namedata)
19777 {
19778 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19779 (unsigned long) ((char *) external - (char *) pnotes));
19780 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19781 inote.type, inote.namesz, inote.descsz);
19782 break;
19783 }
19784
19785 printf (" %s: ", get_v850_elf_note_type (inote.type));
19786
19787 if (! print_v850_note (& inote))
19788 {
19789 res = FALSE;
19790 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19791 inote.namesz, inote.descsz);
19792 }
19793 }
19794
19795 free (pnotes);
19796
19797 return res;
19798}
19799
19800static bfd_boolean
19801process_note_sections (Filedata * filedata)
19802{
19803 Elf_Internal_Shdr * section;
19804 unsigned long i;
19805 unsigned int n = 0;
19806 bfd_boolean res = TRUE;
19807
19808 for (i = 0, section = filedata->section_headers;
19809 i < filedata->file_header.e_shnum && section != NULL;
19810 i++, section++)
19811 {
19812 if (section->sh_type == SHT_NOTE)
19813 {
19814 if (! process_notes_at (filedata, section,
19815 (bfd_vma) section->sh_offset,
19816 (bfd_vma) section->sh_size,
19817 (bfd_vma) section->sh_addralign))
19818 res = FALSE;
19819 n++;
19820 }
19821
19822 if (( filedata->file_header.e_machine == EM_V800
19823 || filedata->file_header.e_machine == EM_V850
19824 || filedata->file_header.e_machine == EM_CYGNUS_V850)
19825 && section->sh_type == SHT_RENESAS_INFO)
19826 {
19827 if (! process_v850_notes (filedata,
19828 (bfd_vma) section->sh_offset,
19829 (bfd_vma) section->sh_size))
19830 res = FALSE;
19831 n++;
19832 }
19833 }
19834
19835 if (n == 0)
19836 /* Try processing NOTE segments instead. */
19837 return process_corefile_note_segments (filedata);
19838
19839 return res;
19840}
19841
19842static bfd_boolean
19843process_notes (Filedata * filedata)
19844{
19845 /* If we have not been asked to display the notes then do nothing. */
19846 if (! do_notes)
19847 return TRUE;
19848
19849 if (filedata->file_header.e_type != ET_CORE)
19850 return process_note_sections (filedata);
19851
19852 /* No program headers means no NOTE segment. */
19853 if (filedata->file_header.e_phnum > 0)
19854 return process_corefile_note_segments (filedata);
19855
19856 printf (_("No note segments present in the core file.\n"));
19857 return TRUE;
19858}
19859
19860static unsigned char *
19861display_public_gnu_attributes (unsigned char * start,
19862 const unsigned char * const end)
19863{
19864 printf (_(" Unknown GNU attribute: %s\n"), start);
19865
19866 start += strnlen ((char *) start, end - start);
19867 display_raw_attribute (start, end);
19868
19869 return (unsigned char *) end;
19870}
19871
19872static unsigned char *
19873display_generic_attribute (unsigned char * start,
19874 unsigned int tag,
19875 const unsigned char * const end)
19876{
19877 if (tag == 0)
19878 return (unsigned char *) end;
19879
19880 return display_tag_value (tag, start, end);
19881}
19882
19883static bfd_boolean
19884process_arch_specific (Filedata * filedata)
19885{
19886 if (! do_arch)
19887 return TRUE;
19888
19889 switch (filedata->file_header.e_machine)
19890 {
19891 case EM_ARC:
19892 case EM_ARC_COMPACT:
19893 case EM_ARC_COMPACT2:
19894 return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
19895 display_arc_attribute,
19896 display_generic_attribute);
19897 case EM_ARM:
19898 return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
19899 display_arm_attribute,
19900 display_generic_attribute);
19901
19902 case EM_MIPS:
19903 case EM_MIPS_RS3_LE:
19904 return process_mips_specific (filedata);
19905
19906 case EM_MSP430:
19907 return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
19908 display_msp430x_attribute,
19909 display_msp430_gnu_attribute);
19910
19911 case EM_RISCV:
19912 return process_attributes (filedata, "riscv", SHT_RISCV_ATTRIBUTES,
19913 display_riscv_attribute,
19914 display_generic_attribute);
19915
19916 case EM_NDS32:
19917 return process_nds32_specific (filedata);
19918
19919 case EM_PPC:
19920 case EM_PPC64:
19921 return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19922 display_power_gnu_attribute);
19923
19924 case EM_S390:
19925 case EM_S390_OLD:
19926 return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19927 display_s390_gnu_attribute);
19928
19929 case EM_SPARC:
19930 case EM_SPARC32PLUS:
19931 case EM_SPARCV9:
19932 return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19933 display_sparc_gnu_attribute);
19934
19935 case EM_TI_C6000:
19936 return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
19937 display_tic6x_attribute,
19938 display_generic_attribute);
19939
19940 default:
19941 return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
19942 display_public_gnu_attributes,
19943 display_generic_attribute);
19944 }
19945}
19946
19947static bfd_boolean
19948get_file_header (Filedata * filedata)
19949{
19950 /* Read in the identity array. */
19951 if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
19952 return FALSE;
19953
19954 /* Determine how to read the rest of the header. */
19955 switch (filedata->file_header.e_ident[EI_DATA])
19956 {
19957 default:
19958 case ELFDATANONE:
19959 case ELFDATA2LSB:
19960 byte_get = byte_get_little_endian;
19961 byte_put = byte_put_little_endian;
19962 break;
19963 case ELFDATA2MSB:
19964 byte_get = byte_get_big_endian;
19965 byte_put = byte_put_big_endian;
19966 break;
19967 }
19968
19969 /* For now we only support 32 bit and 64 bit ELF files. */
19970 is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
19971
19972 /* Read in the rest of the header. */
19973 if (is_32bit_elf)
19974 {
19975 Elf32_External_Ehdr ehdr32;
19976
19977 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
19978 return FALSE;
19979
19980 filedata->file_header.e_type = BYTE_GET (ehdr32.e_type);
19981 filedata->file_header.e_machine = BYTE_GET (ehdr32.e_machine);
19982 filedata->file_header.e_version = BYTE_GET (ehdr32.e_version);
19983 filedata->file_header.e_entry = BYTE_GET (ehdr32.e_entry);
19984 filedata->file_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
19985 filedata->file_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
19986 filedata->file_header.e_flags = BYTE_GET (ehdr32.e_flags);
19987 filedata->file_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
19988 filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
19989 filedata->file_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
19990 filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
19991 filedata->file_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
19992 filedata->file_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
19993 }
19994 else
19995 {
19996 Elf64_External_Ehdr ehdr64;
19997
19998 /* If we have been compiled with sizeof (bfd_vma) == 4, then
19999 we will not be able to cope with the 64bit data found in
20000 64 ELF files. Detect this now and abort before we start
20001 overwriting things. */
20002 if (sizeof (bfd_vma) < 8)
20003 {
20004 error (_("This instance of readelf has been built without support for a\n\
2000564 bit data type and so it cannot read 64 bit ELF files.\n"));
20006 return FALSE;
20007 }
20008
20009 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
20010 return FALSE;
20011
20012 filedata->file_header.e_type = BYTE_GET (ehdr64.e_type);
20013 filedata->file_header.e_machine = BYTE_GET (ehdr64.e_machine);
20014 filedata->file_header.e_version = BYTE_GET (ehdr64.e_version);
20015 filedata->file_header.e_entry = BYTE_GET (ehdr64.e_entry);
20016 filedata->file_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
20017 filedata->file_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
20018 filedata->file_header.e_flags = BYTE_GET (ehdr64.e_flags);
20019 filedata->file_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
20020 filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
20021 filedata->file_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
20022 filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
20023 filedata->file_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
20024 filedata->file_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
20025 }
20026
20027 if (filedata->file_header.e_shoff)
20028 {
20029 /* There may be some extensions in the first section header. Don't
20030 bomb if we can't read it. */
20031 if (is_32bit_elf)
20032 get_32bit_section_headers (filedata, TRUE);
20033 else
20034 get_64bit_section_headers (filedata, TRUE);
20035 }
20036
20037 return TRUE;
20038}
20039
20040static void
20041close_file (Filedata * filedata)
20042{
20043 if (filedata)
20044 {
20045 if (filedata->handle)
20046 fclose (filedata->handle);
20047 free (filedata);
20048 }
20049}
20050
20051void
20052close_debug_file (void * data)
20053{
20054 close_file ((Filedata *) data);
20055}
20056
20057static Filedata *
20058open_file (const char * pathname)
20059{
20060 struct stat statbuf;
20061 Filedata * filedata = NULL;
20062
20063 if (stat (pathname, & statbuf) < 0
20064 || ! S_ISREG (statbuf.st_mode))
20065 goto fail;
20066
20067 filedata = calloc (1, sizeof * filedata);
20068 if (filedata == NULL)
20069 goto fail;
20070
20071 filedata->handle = fopen (pathname, "rb");
20072 if (filedata->handle == NULL)
20073 goto fail;
20074
20075 filedata->file_size = (bfd_size_type) statbuf.st_size;
20076 filedata->file_name = pathname;
20077
20078 if (! get_file_header (filedata))
20079 goto fail;
20080
20081 if (filedata->file_header.e_shoff)
20082 {
20083 bfd_boolean res;
20084
20085 /* Read the section headers again, this time for real. */
20086 if (is_32bit_elf)
20087 res = get_32bit_section_headers (filedata, FALSE);
20088 else
20089 res = get_64bit_section_headers (filedata, FALSE);
20090
20091 if (!res)
20092 goto fail;
20093 }
20094
20095 return filedata;
20096
20097 fail:
20098 if (filedata)
20099 {
20100 if (filedata->handle)
20101 fclose (filedata->handle);
20102 free (filedata);
20103 }
20104 return NULL;
20105}
20106
20107void *
20108open_debug_file (const char * pathname)
20109{
20110 return open_file (pathname);
20111}
20112
20113/* Process one ELF object file according to the command line options.
20114 This file may actually be stored in an archive. The file is
20115 positioned at the start of the ELF object. Returns TRUE if no
20116 problems were encountered, FALSE otherwise. */
20117
20118static bfd_boolean
20119process_object (Filedata * filedata)
20120{
20121 bfd_boolean have_separate_files;
20122 unsigned int i;
20123 bfd_boolean res = TRUE;
20124
20125 if (! get_file_header (filedata))
20126 {
20127 error (_("%s: Failed to read file header\n"), filedata->file_name);
20128 return FALSE;
20129 }
20130
20131 /* Initialise per file variables. */
20132 for (i = ARRAY_SIZE (filedata->version_info); i--;)
20133 filedata->version_info[i] = 0;
20134
20135 for (i = ARRAY_SIZE (filedata->dynamic_info); i--;)
20136 filedata->dynamic_info[i] = 0;
20137 filedata->dynamic_info_DT_GNU_HASH = 0;
20138 filedata->dynamic_info_DT_MIPS_XHASH = 0;
20139
20140 /* Process the file. */
20141 if (show_name)
20142 printf (_("\nFile: %s\n"), filedata->file_name);
20143
20144 /* Initialise the dump_sects array from the cmdline_dump_sects array.
20145 Note we do this even if cmdline_dump_sects is empty because we
20146 must make sure that the dump_sets array is zeroed out before each
20147 object file is processed. */
20148 if (filedata->dump.num_dump_sects > cmdline.num_dump_sects)
20149 memset (filedata->dump.dump_sects, 0,
20150 filedata->dump.num_dump_sects * sizeof (*filedata->dump.dump_sects));
20151
20152 if (cmdline.num_dump_sects > 0)
20153 {
20154 if (filedata->dump.num_dump_sects == 0)
20155 /* A sneaky way of allocating the dump_sects array. */
20156 request_dump_bynumber (&filedata->dump, cmdline.num_dump_sects, 0);
20157
20158 assert (filedata->dump.num_dump_sects >= cmdline.num_dump_sects);
20159 memcpy (filedata->dump.dump_sects, cmdline.dump_sects,
20160 cmdline.num_dump_sects * sizeof (*filedata->dump.dump_sects));
20161 }
20162
20163 if (! process_file_header (filedata))
20164 return FALSE;
20165
20166 if (! process_section_headers (filedata))
20167 {
20168 /* Without loaded section headers we cannot process lots of things. */
20169 do_unwind = do_version = do_dump = do_arch = FALSE;
20170
20171 if (! do_using_dynamic)
20172 do_syms = do_dyn_syms = do_reloc = FALSE;
20173 }
20174
20175 if (! process_section_groups (filedata))
20176 /* Without loaded section groups we cannot process unwind. */
20177 do_unwind = FALSE;
20178
20179 if (process_program_headers (filedata))
20180 process_dynamic_section (filedata);
20181 else
20182 res = FALSE;
20183
20184 if (! process_relocs (filedata))
20185 res = FALSE;
20186
20187 if (! process_unwind (filedata))
20188 res = FALSE;
20189
20190 if (! process_symbol_table (filedata))
20191 res = FALSE;
20192
20193 if (! process_syminfo (filedata))
20194 res = FALSE;
20195
20196 if (! process_version_sections (filedata))
20197 res = FALSE;
20198
20199 if (filedata->file_header.e_shstrndx != SHN_UNDEF)
20200 have_separate_files = load_separate_debug_files (filedata, filedata->file_name);
20201 else
20202 have_separate_files = FALSE;
20203
20204 if (! process_section_contents (filedata))
20205 res = FALSE;
20206
20207 if (have_separate_files)
20208 {
20209 separate_info * d;
20210
20211 for (d = first_separate_info; d != NULL; d = d->next)
20212 {
20213 if (! process_section_headers (d->handle))
20214 res = FALSE;
20215 else if (! process_section_contents (d->handle))
20216 res = FALSE;
20217 }
20218
20219 /* The file handles are closed by the call to free_debug_memory() below. */
20220 }
20221
20222 if (! process_notes (filedata))
20223 res = FALSE;
20224
20225 if (! process_gnu_liblist (filedata))
20226 res = FALSE;
20227
20228 if (! process_arch_specific (filedata))
20229 res = FALSE;
20230
20231 free (filedata->program_headers);
20232 filedata->program_headers = NULL;
20233
20234 free (filedata->section_headers);
20235 filedata->section_headers = NULL;
20236
20237 free (filedata->string_table);
20238 filedata->string_table = NULL;
20239 filedata->string_table_length = 0;
20240
20241 if (filedata->dump.dump_sects != NULL)
20242 {
20243 free (filedata->dump.dump_sects);
20244 filedata->dump.dump_sects = NULL;
20245 filedata->dump.num_dump_sects = 0;
20246 }
20247
20248 if (filedata->dynamic_strings)
20249 {
20250 free (filedata->dynamic_strings);
20251 filedata->dynamic_strings = NULL;
20252 filedata->dynamic_strings_length = 0;
20253 }
20254
20255 if (filedata->dynamic_symbols)
20256 {
20257 free (filedata->dynamic_symbols);
20258 filedata->dynamic_symbols = NULL;
20259 filedata->num_dynamic_syms = 0;
20260 }
20261
20262 if (filedata->dynamic_syminfo)
20263 {
20264 free (filedata->dynamic_syminfo);
20265 filedata->dynamic_syminfo = NULL;
20266 }
20267
20268 if (filedata->dynamic_section)
20269 {
20270 free (filedata->dynamic_section);
20271 filedata->dynamic_section = NULL;
20272 }
20273
20274 while (filedata->symtab_shndx_list != NULL)
20275 {
20276 elf_section_list *next = filedata->symtab_shndx_list->next;
20277 free (filedata->symtab_shndx_list);
20278 filedata->symtab_shndx_list = next;
20279 }
20280
20281 if (filedata->section_headers_groups)
20282 {
20283 free (filedata->section_headers_groups);
20284 filedata->section_headers_groups = NULL;
20285 }
20286
20287 if (filedata->section_groups)
20288 {
20289 struct group_list * g;
20290 struct group_list * next;
20291
20292 for (i = 0; i < filedata->group_count; i++)
20293 {
20294 for (g = filedata->section_groups [i].root; g != NULL; g = next)
20295 {
20296 next = g->next;
20297 free (g);
20298 }
20299 }
20300
20301 free (filedata->section_groups);
20302 filedata->section_groups = NULL;
20303 }
20304
20305 free_debug_memory ();
20306
20307 return res;
20308}
20309
20310/* Process an ELF archive.
20311 On entry the file is positioned just after the ARMAG string.
20312 Returns TRUE upon success, FALSE otherwise. */
20313
20314static bfd_boolean
20315process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
20316{
20317 struct archive_info arch;
20318 struct archive_info nested_arch;
20319 size_t got;
20320 bfd_boolean ret = TRUE;
20321
20322 show_name = TRUE;
20323
20324 /* The ARCH structure is used to hold information about this archive. */
20325 arch.file_name = NULL;
20326 arch.file = NULL;
20327 arch.index_array = NULL;
20328 arch.sym_table = NULL;
20329 arch.longnames = NULL;
20330
20331 /* The NESTED_ARCH structure is used as a single-item cache of information
20332 about a nested archive (when members of a thin archive reside within
20333 another regular archive file). */
20334 nested_arch.file_name = NULL;
20335 nested_arch.file = NULL;
20336 nested_arch.index_array = NULL;
20337 nested_arch.sym_table = NULL;
20338 nested_arch.longnames = NULL;
20339
20340 if (setup_archive (&arch, filedata->file_name, filedata->handle,
20341 filedata->file_size, is_thin_archive,
20342 do_archive_index) != 0)
20343 {
20344 ret = FALSE;
20345 goto out;
20346 }
20347
20348 if (do_archive_index)
20349 {
20350 if (arch.sym_table == NULL)
20351 error (_("%s: unable to dump the index as none was found\n"),
20352 filedata->file_name);
20353 else
20354 {
20355 unsigned long i, l;
20356 unsigned long current_pos;
20357
20358 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes "
20359 "in the symbol table)\n"),
20360 filedata->file_name, (unsigned long) arch.index_num,
20361 arch.sym_size);
20362
20363 current_pos = ftell (filedata->handle);
20364
20365 for (i = l = 0; i < arch.index_num; i++)
20366 {
20367 if (i == 0
20368 || (i > 0 && arch.index_array[i] != arch.index_array[i - 1]))
20369 {
20370 char * member_name
20371 = get_archive_member_name_at (&arch, arch.index_array[i],
20372 &nested_arch);
20373
20374 if (member_name != NULL)
20375 {
20376 char * qualified_name
20377 = make_qualified_name (&arch, &nested_arch,
20378 member_name);
20379
20380 if (qualified_name != NULL)
20381 {
20382 printf (_("Contents of binary %s at offset "),
20383 qualified_name);
20384 (void) print_vma (arch.index_array[i], PREFIX_HEX);
20385 putchar ('\n');
20386 free (qualified_name);
20387 }
20388 free (member_name);
20389 }
20390 }
20391
20392 if (l >= arch.sym_size)
20393 {
20394 error (_("%s: end of the symbol table reached "
20395 "before the end of the index\n"),
20396 filedata->file_name);
20397 ret = FALSE;
20398 break;
20399 }
20400 /* PR 17531: file: 0b6630b2. */
20401 printf ("\t%.*s\n",
20402 (int) (arch.sym_size - l), arch.sym_table + l);
20403 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
20404 }
20405
20406 if (arch.uses_64bit_indices)
20407 l = (l + 7) & ~ 7;
20408 else
20409 l += l & 1;
20410
20411 if (l < arch.sym_size)
20412 {
20413 error (ngettext ("%s: %ld byte remains in the symbol table, "
20414 "but without corresponding entries in "
20415 "the index table\n",
20416 "%s: %ld bytes remain in the symbol table, "
20417 "but without corresponding entries in "
20418 "the index table\n",
20419 arch.sym_size - l),
20420 filedata->file_name, arch.sym_size - l);
20421 ret = FALSE;
20422 }
20423
20424 if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
20425 {
20426 error (_("%s: failed to seek back to start of object files "
20427 "in the archive\n"),
20428 filedata->file_name);
20429 ret = FALSE;
20430 goto out;
20431 }
20432 }
20433
20434 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
20435 && !do_segments && !do_header && !do_dump && !do_version
20436 && !do_histogram && !do_debugging && !do_arch && !do_notes
20437 && !do_section_groups && !do_dyn_syms)
20438 {
20439 ret = TRUE; /* Archive index only. */
20440 goto out;
20441 }
20442 }
20443
20444 while (1)
20445 {
20446 char * name;
20447 size_t namelen;
20448 char * qualified_name;
20449
20450 /* Read the next archive header. */
20451 if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
20452 {
20453 error (_("%s: failed to seek to next archive header\n"),
20454 arch.file_name);
20455 ret = FALSE;
20456 break;
20457 }
20458 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
20459 if (got != sizeof arch.arhdr)
20460 {
20461 if (got == 0)
20462 break;
20463 /* PR 24049 - we cannot use filedata->file_name as this will
20464 have already been freed. */
20465 error (_("%s: failed to read archive header\n"), arch.file_name);
20466
20467 ret = FALSE;
20468 break;
20469 }
20470 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
20471 {
20472 error (_("%s: did not find a valid archive header\n"),
20473 arch.file_name);
20474 ret = FALSE;
20475 break;
20476 }
20477
20478 arch.next_arhdr_offset += sizeof arch.arhdr;
20479
20480 filedata->archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
20481 if (filedata->archive_file_size & 01)
20482 ++filedata->archive_file_size;
20483
20484 name = get_archive_member_name (&arch, &nested_arch);
20485 if (name == NULL)
20486 {
20487 error (_("%s: bad archive file name\n"), arch.file_name);
20488 ret = FALSE;
20489 break;
20490 }
20491 namelen = strlen (name);
20492
20493 qualified_name = make_qualified_name (&arch, &nested_arch, name);
20494 if (qualified_name == NULL)
20495 {
20496 error (_("%s: bad archive file name\n"), arch.file_name);
20497 free (name);
20498 ret = FALSE;
20499 break;
20500 }
20501
20502 if (is_thin_archive && arch.nested_member_origin == 0)
20503 {
20504 /* This is a proxy for an external member of a thin archive. */
20505 Filedata * member_filedata;
20506 char * member_file_name = adjust_relative_path
20507 (filedata->file_name, name, namelen);
20508
20509 free (name);
20510 if (member_file_name == NULL)
20511 {
20512 free (qualified_name);
20513 ret = FALSE;
20514 break;
20515 }
20516
20517 member_filedata = open_file (member_file_name);
20518 if (member_filedata == NULL)
20519 {
20520 error (_("Input file '%s' is not readable.\n"), member_file_name);
20521 free (member_file_name);
20522 free (qualified_name);
20523 ret = FALSE;
20524 break;
20525 }
20526
20527 filedata->archive_file_offset = arch.nested_member_origin;
20528 member_filedata->file_name = qualified_name;
20529
20530 if (! process_object (member_filedata))
20531 ret = FALSE;
20532
20533 close_file (member_filedata);
20534 free (member_file_name);
20535 }
20536 else if (is_thin_archive)
20537 {
20538 Filedata thin_filedata;
20539
20540 memset (&thin_filedata, 0, sizeof (thin_filedata));
20541
20542 /* PR 15140: Allow for corrupt thin archives. */
20543 if (nested_arch.file == NULL)
20544 {
20545 error (_("%s: contains corrupt thin archive: %s\n"),
20546 qualified_name, name);
20547 free (qualified_name);
20548 free (name);
20549 ret = FALSE;
20550 break;
20551 }
20552 free (name);
20553
20554 /* This is a proxy for a member of a nested archive. */
20555 filedata->archive_file_offset
20556 = arch.nested_member_origin + sizeof arch.arhdr;
20557
20558 /* The nested archive file will have been opened and setup by
20559 get_archive_member_name. */
20560 if (fseek (nested_arch.file, filedata->archive_file_offset,
20561 SEEK_SET) != 0)
20562 {
20563 error (_("%s: failed to seek to archive member.\n"),
20564 nested_arch.file_name);
20565 free (qualified_name);
20566 ret = FALSE;
20567 break;
20568 }
20569
20570 thin_filedata.handle = nested_arch.file;
20571 thin_filedata.file_name = qualified_name;
20572
20573 if (! process_object (& thin_filedata))
20574 ret = FALSE;
20575 }
20576 else
20577 {
20578 free (name);
20579 filedata->archive_file_offset = arch.next_arhdr_offset;
20580 filedata->file_name = qualified_name;
20581 if (! process_object (filedata))
20582 ret = FALSE;
20583 arch.next_arhdr_offset += filedata->archive_file_size;
20584 /* Stop looping with "negative" archive_file_size. */
20585 if (arch.next_arhdr_offset < filedata->archive_file_size)
20586 arch.next_arhdr_offset = -1ul;
20587 }
20588
20589 free (qualified_name);
20590 }
20591
20592 out:
20593 if (nested_arch.file != NULL)
20594 fclose (nested_arch.file);
20595 release_archive (&nested_arch);
20596 release_archive (&arch);
20597
20598 return ret;
20599}
20600
20601static bfd_boolean
20602process_file (char * file_name)
20603{
20604 Filedata * filedata = NULL;
20605 struct stat statbuf;
20606 char armag[SARMAG];
20607 bfd_boolean ret = TRUE;
20608
20609 if (stat (file_name, &statbuf) < 0)
20610 {
20611 if (errno == ENOENT)
20612 error (_("'%s': No such file\n"), file_name);
20613 else
20614 error (_("Could not locate '%s'. System error message: %s\n"),
20615 file_name, strerror (errno));
20616 return FALSE;
20617 }
20618
20619 if (! S_ISREG (statbuf.st_mode))
20620 {
20621 error (_("'%s' is not an ordinary file\n"), file_name);
20622 return FALSE;
20623 }
20624
20625 filedata = calloc (1, sizeof * filedata);
20626 if (filedata == NULL)
20627 {
20628 error (_("Out of memory allocating file data structure\n"));
20629 return FALSE;
20630 }
20631
20632 filedata->file_name = file_name;
20633 filedata->handle = fopen (file_name, "rb");
20634 if (filedata->handle == NULL)
20635 {
20636 error (_("Input file '%s' is not readable.\n"), file_name);
20637 free (filedata);
20638 return FALSE;
20639 }
20640
20641 if (fread (armag, SARMAG, 1, filedata->handle) != 1)
20642 {
20643 error (_("%s: Failed to read file's magic number\n"), file_name);
20644 fclose (filedata->handle);
20645 free (filedata);
20646 return FALSE;
20647 }
20648
20649 filedata->file_size = (bfd_size_type) statbuf.st_size;
20650
20651 if (memcmp (armag, ARMAG, SARMAG) == 0)
20652 {
20653 if (! process_archive (filedata, FALSE))
20654 ret = FALSE;
20655 }
20656 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
20657 {
20658 if ( ! process_archive (filedata, TRUE))
20659 ret = FALSE;
20660 }
20661 else
20662 {
20663 if (do_archive_index)
20664 error (_("File %s is not an archive so its index cannot be displayed.\n"),
20665 file_name);
20666
20667 rewind (filedata->handle);
20668 filedata->archive_file_size = filedata->archive_file_offset = 0;
20669
20670 if (! process_object (filedata))
20671 ret = FALSE;
20672 }
20673
20674 fclose (filedata->handle);
20675 free (filedata->section_headers);
20676 free (filedata->program_headers);
20677 free (filedata->string_table);
20678 free (filedata->dump.dump_sects);
20679 free (filedata);
20680
20681 free (ba_cache.strtab);
20682 ba_cache.strtab = NULL;
20683 free (ba_cache.symtab);
20684 ba_cache.symtab = NULL;
20685 ba_cache.filedata = NULL;
20686
20687 return ret;
20688}
20689
20690#ifdef SUPPORT_DISASSEMBLY
20691/* Needed by the i386 disassembler. For extra credit, someone could
20692 fix this so that we insert symbolic addresses here, esp for GOT/PLT
20693 symbols. */
20694
20695void
20696print_address (unsigned int addr, FILE * outfile)
20697{
20698 fprintf (outfile,"0x%8.8x", addr);
20699}
20700
20701/* Needed by the i386 disassembler. */
20702
20703void
20704db_task_printsym (unsigned int addr)
20705{
20706 print_address (addr, stderr);
20707}
20708#endif
20709
20710int
20711main (int argc, char ** argv)
20712{
20713 int err;
20714
20715#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20716 setlocale (LC_MESSAGES, "");
20717#endif
20718#if defined (HAVE_SETLOCALE)
20719 setlocale (LC_CTYPE, "");
20720#endif
20721 bindtextdomain (PACKAGE, LOCALEDIR);
20722 textdomain (PACKAGE);
20723
20724 expandargv (&argc, &argv);
20725
20726 parse_args (& cmdline, argc, argv);
20727
20728 if (optind < (argc - 1))
20729 show_name = TRUE;
20730 else if (optind >= argc)
20731 {
20732 warn (_("Nothing to do.\n"));
20733 usage (stderr);
20734 }
20735
20736 err = FALSE;
20737 while (optind < argc)
20738 if (! process_file (argv[optind++]))
20739 err = TRUE;
20740
20741 if (cmdline.dump_sects != NULL)
20742 free (cmdline.dump_sects);
20743
20744 free (dump_ctf_symtab_name);
20745 free (dump_ctf_strtab_name);
20746 free (dump_ctf_parent_name);
20747
20748 return err ? EXIT_FAILURE : EXIT_SUCCESS;
20749}
GDB Binutils - Deliverables
This page took 0.111513 seconds and 4 git commands to generate.