]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame_incremental - binutils/readelf.c
projects / thirdparty / binutils-gdb.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
RISCV changes broke 32-bit --enable-targets=all
[thirdparty/binutils-gdb.git] / binutils / readelf.c
... / ...
CommitLineData
1/* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2020 Free Software Foundation, Inc.
3
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
6
7 This file is part of GNU Binutils.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 02110-1301, USA. */
23\f
24/* The difference between readelf and objdump:
25
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
28
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
35
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
38
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
42\f
43#include "sysdep.h"
44#include <assert.h>
45#include <time.h>
46#include <zlib.h>
47#ifdef HAVE_WCHAR_H
48#include <wchar.h>
49#endif
50
51#if __GNUC__ >= 2
52/* Define BFD64 here, even if our default architecture is 32 bit ELF
53 as this will allow us to read in and parse 64bit and 32bit ELF files.
54 Only do this if we believe that the compiler can support a 64 bit
55 data type. For now we only rely on GCC being able to do this. */
56#define BFD64
57#endif
58
59#include "bfd.h"
60#include "bucomm.h"
61#include "elfcomm.h"
62#include "dwarf.h"
63#include "ctf-api.h"
64
65#include "elf/common.h"
66#include "elf/external.h"
67#include "elf/internal.h"
68
69
70/* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
71 we can obtain the H8 reloc numbers. We need these for the
72 get_reloc_size() function. We include h8.h again after defining
73 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
74
75#include "elf/h8.h"
76#undef _ELF_H8_H
77
78/* Undo the effects of #including reloc-macros.h. */
79
80#undef START_RELOC_NUMBERS
81#undef RELOC_NUMBER
82#undef FAKE_RELOC
83#undef EMPTY_RELOC
84#undef END_RELOC_NUMBERS
85#undef _RELOC_MACROS_H
86
87/* The following headers use the elf/reloc-macros.h file to
88 automatically generate relocation recognition functions
89 such as elf_mips_reloc_type() */
90
91#define RELOC_MACROS_GEN_FUNC
92
93#include "elf/aarch64.h"
94#include "elf/alpha.h"
95#include "elf/arc.h"
96#include "elf/arm.h"
97#include "elf/avr.h"
98#include "elf/bfin.h"
99#include "elf/cr16.h"
100#include "elf/cris.h"
101#include "elf/crx.h"
102#include "elf/csky.h"
103#include "elf/d10v.h"
104#include "elf/d30v.h"
105#include "elf/dlx.h"
106#include "elf/bpf.h"
107#include "elf/epiphany.h"
108#include "elf/fr30.h"
109#include "elf/frv.h"
110#include "elf/ft32.h"
111#include "elf/h8.h"
112#include "elf/hppa.h"
113#include "elf/i386.h"
114#include "elf/i370.h"
115#include "elf/i860.h"
116#include "elf/i960.h"
117#include "elf/ia64.h"
118#include "elf/ip2k.h"
119#include "elf/lm32.h"
120#include "elf/iq2000.h"
121#include "elf/m32c.h"
122#include "elf/m32r.h"
123#include "elf/m68k.h"
124#include "elf/m68hc11.h"
125#include "elf/s12z.h"
126#include "elf/mcore.h"
127#include "elf/mep.h"
128#include "elf/metag.h"
129#include "elf/microblaze.h"
130#include "elf/mips.h"
131#include "elf/mmix.h"
132#include "elf/mn10200.h"
133#include "elf/mn10300.h"
134#include "elf/moxie.h"
135#include "elf/mt.h"
136#include "elf/msp430.h"
137#include "elf/nds32.h"
138#include "elf/nfp.h"
139#include "elf/nios2.h"
140#include "elf/or1k.h"
141#include "elf/pj.h"
142#include "elf/ppc.h"
143#include "elf/ppc64.h"
144#include "elf/pru.h"
145#include "elf/riscv.h"
146#include "elf/rl78.h"
147#include "elf/rx.h"
148#include "elf/s390.h"
149#include "elf/score.h"
150#include "elf/sh.h"
151#include "elf/sparc.h"
152#include "elf/spu.h"
153#include "elf/tic6x.h"
154#include "elf/tilegx.h"
155#include "elf/tilepro.h"
156#include "elf/v850.h"
157#include "elf/vax.h"
158#include "elf/visium.h"
159#include "elf/wasm32.h"
160#include "elf/x86-64.h"
161#include "elf/xc16x.h"
162#include "elf/xgate.h"
163#include "elf/xstormy16.h"
164#include "elf/xtensa.h"
165#include "elf/z80.h"
166
167#include "getopt.h"
168#include "libiberty.h"
169#include "safe-ctype.h"
170#include "filenames.h"
171
172#ifndef offsetof
173#define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
174#endif
175
176typedef struct elf_section_list
177{
178 Elf_Internal_Shdr * hdr;
179 struct elf_section_list * next;
180} elf_section_list;
181
182/* Flag bits indicating particular types of dump. */
183#define HEX_DUMP (1 << 0) /* The -x command line switch. */
184#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
185#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
186#define STRING_DUMP (1 << 3) /* The -p command line switch. */
187#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
188#define CTF_DUMP (1 << 5) /* The --ctf command line switch. */
189
190typedef unsigned char dump_type;
191
192/* A linked list of the section names for which dumps were requested. */
193struct dump_list_entry
194{
195 char * name;
196 dump_type type;
197 struct dump_list_entry * next;
198};
199
200/* A dynamic array of flags indicating for which sections a dump
201 has been requested via command line switches. */
202struct dump_data
203{
204 dump_type * dump_sects;
205 unsigned int num_dump_sects;
206};
207
208static struct dump_data cmdline;
209
210static struct dump_list_entry * dump_sects_byname;
211
212char * program_name = "readelf";
213
214static bfd_boolean show_name = FALSE;
215static bfd_boolean do_dynamic = FALSE;
216static bfd_boolean do_syms = FALSE;
217static bfd_boolean do_dyn_syms = FALSE;
218static bfd_boolean do_reloc = FALSE;
219static bfd_boolean do_sections = FALSE;
220static bfd_boolean do_section_groups = FALSE;
221static bfd_boolean do_section_details = FALSE;
222static bfd_boolean do_segments = FALSE;
223static bfd_boolean do_unwind = FALSE;
224static bfd_boolean do_using_dynamic = FALSE;
225static bfd_boolean do_header = FALSE;
226static bfd_boolean do_dump = FALSE;
227static bfd_boolean do_version = FALSE;
228static bfd_boolean do_histogram = FALSE;
229static bfd_boolean do_debugging = FALSE;
230static bfd_boolean do_ctf = FALSE;
231static bfd_boolean do_arch = FALSE;
232static bfd_boolean do_notes = FALSE;
233static bfd_boolean do_archive_index = FALSE;
234static bfd_boolean check_all = FALSE;
235static bfd_boolean is_32bit_elf = FALSE;
236static bfd_boolean decompress_dumps = FALSE;
237
238static char *dump_ctf_parent_name;
239static char *dump_ctf_symtab_name;
240static char *dump_ctf_strtab_name;
241
242struct group_list
243{
244 struct group_list * next;
245 unsigned int section_index;
246};
247
248struct group
249{
250 struct group_list * root;
251 unsigned int group_index;
252};
253
254typedef struct filedata
255{
256 const char * file_name;
257 FILE * handle;
258 bfd_size_type file_size;
259 Elf_Internal_Ehdr file_header;
260 Elf_Internal_Shdr * section_headers;
261 Elf_Internal_Phdr * program_headers;
262 char * string_table;
263 unsigned long string_table_length;
264 unsigned long archive_file_offset;
265 unsigned long archive_file_size;
266 unsigned long dynamic_addr;
267 bfd_size_type dynamic_size;
268 size_t dynamic_nent;
269 Elf_Internal_Dyn * dynamic_section;
270 Elf_Internal_Shdr * dynamic_strtab_section;
271 char * dynamic_strings;
272 unsigned long dynamic_strings_length;
273 Elf_Internal_Shdr * dynamic_symtab_section;
274 unsigned long num_dynamic_syms;
275 Elf_Internal_Sym * dynamic_symbols;
276 bfd_vma version_info[16];
277 unsigned int dynamic_syminfo_nent;
278 Elf_Internal_Syminfo * dynamic_syminfo;
279 unsigned long dynamic_syminfo_offset;
280 bfd_size_type nbuckets;
281 bfd_size_type nchains;
282 bfd_vma * buckets;
283 bfd_vma * chains;
284 bfd_size_type ngnubuckets;
285 bfd_size_type ngnuchains;
286 bfd_vma * gnubuckets;
287 bfd_vma * gnuchains;
288 bfd_vma * mipsxlat;
289 bfd_vma gnusymidx;
290 char program_interpreter[PATH_MAX];
291 bfd_vma dynamic_info[DT_ENCODING];
292 bfd_vma dynamic_info_DT_GNU_HASH;
293 bfd_vma dynamic_info_DT_MIPS_XHASH;
294 elf_section_list * symtab_shndx_list;
295 size_t group_count;
296 struct group * section_groups;
297 struct group ** section_headers_groups;
298 /* A dynamic array of flags indicating for which sections a dump of
299 some kind has been requested. It is reset on a per-object file
300 basis and then initialised from the cmdline_dump_sects array,
301 the results of interpreting the -w switch, and the
302 dump_sects_byname list. */
303 struct dump_data dump;
304} Filedata;
305
306/* How to print a vma value. */
307typedef enum print_mode
308{
309 HEX,
310 DEC,
311 DEC_5,
312 UNSIGNED,
313 PREFIX_HEX,
314 FULL_HEX,
315 LONG_HEX
316}
317print_mode;
318
319/* Versioned symbol info. */
320enum versioned_symbol_info
321{
322 symbol_undefined,
323 symbol_hidden,
324 symbol_public
325};
326
327static const char * get_symbol_version_string
328 (Filedata *, bfd_boolean, const char *, unsigned long, unsigned,
329 Elf_Internal_Sym *, enum versioned_symbol_info *, unsigned short *);
330
331#define UNKNOWN -1
332
333#define SECTION_NAME(X) \
334 ((X) == NULL ? _("<none>") \
335 : filedata->string_table == NULL ? _("<no-strings>") \
336 : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>") \
337 : filedata->string_table + (X)->sh_name))
338
339#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
340
341#define GET_ELF_SYMBOLS(file, section, sym_count) \
342 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
343 : get_64bit_elf_symbols (file, section, sym_count))
344
345#define VALID_SYMBOL_NAME(strtab, strtab_size, offset) \
346 (strtab != NULL && offset < strtab_size)
347#define VALID_DYNAMIC_NAME(filedata, offset) \
348 VALID_SYMBOL_NAME (filedata->dynamic_strings, \
349 filedata->dynamic_strings_length, offset)
350/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
351 already been called and verified that the string exists. */
352#define GET_DYNAMIC_NAME(filedata, offset) \
353 (filedata->dynamic_strings + offset)
354
355#define REMOVE_ARCH_BITS(ADDR) \
356 do \
357 { \
358 if (filedata->file_header.e_machine == EM_ARM) \
359 (ADDR) &= ~1; \
360 } \
361 while (0)
362
363/* Get the correct GNU hash section name. */
364#define GNU_HASH_SECTION_NAME(filedata) \
365 filedata->dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
366\f
367/* Print a BFD_VMA to an internal buffer, for use in error messages.
368 BFD_FMA_FMT can't be used in translated strings. */
369
370static const char *
371bfd_vmatoa (char *fmtch, bfd_vma value)
372{
373 /* bfd_vmatoa is used more then once in a printf call for output.
374 Cycle through an array of buffers. */
375 static int buf_pos = 0;
376 static struct bfd_vmatoa_buf
377 {
378 char place[64];
379 } buf[4];
380 char *ret;
381 char fmt[32];
382
383 ret = buf[buf_pos++].place;
384 buf_pos %= ARRAY_SIZE (buf);
385
386 sprintf (fmt, "%%%s%s", BFD_VMA_FMT, fmtch);
387 snprintf (ret, sizeof (buf[0].place), fmt, value);
388 return ret;
389}
390
391/* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
392 OFFSET + the offset of the current archive member, if we are examining an
393 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
394 allocate a buffer using malloc and fill that. In either case return the
395 pointer to the start of the retrieved data or NULL if something went wrong.
396 If something does go wrong and REASON is not NULL then emit an error
397 message using REASON as part of the context. */
398
399static void *
400get_data (void * var,
401 Filedata * filedata,
402 unsigned long offset,
403 bfd_size_type size,
404 bfd_size_type nmemb,
405 const char * reason)
406{
407 void * mvar;
408 bfd_size_type amt = size * nmemb;
409
410 if (size == 0 || nmemb == 0)
411 return NULL;
412
413 /* If the size_t type is smaller than the bfd_size_type, eg because
414 you are building a 32-bit tool on a 64-bit host, then make sure
415 that when the sizes are cast to (size_t) no information is lost. */
416 if ((size_t) size != size
417 || (size_t) nmemb != nmemb
418 || (size_t) amt != amt)
419 {
420 if (reason)
421 error (_("Size truncation prevents reading %s"
422 " elements of size %s for %s\n"),
423 bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
424 return NULL;
425 }
426
427 /* Check for size overflow. */
428 if (amt / size != nmemb || (size_t) amt + 1 == 0)
429 {
430 if (reason)
431 error (_("Size overflow prevents reading %s"
432 " elements of size %s for %s\n"),
433 bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
434 return NULL;
435 }
436
437 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
438 attempting to allocate memory when the read is bound to fail. */
439 if (filedata->archive_file_offset > filedata->file_size
440 || offset > filedata->file_size - filedata->archive_file_offset
441 || amt > filedata->file_size - filedata->archive_file_offset - offset)
442 {
443 if (reason)
444 error (_("Reading %s bytes extends past end of file for %s\n"),
445 bfd_vmatoa ("u", amt), reason);
446 return NULL;
447 }
448
449 if (fseek (filedata->handle, filedata->archive_file_offset + offset,
450 SEEK_SET))
451 {
452 if (reason)
453 error (_("Unable to seek to 0x%lx for %s\n"),
454 filedata->archive_file_offset + offset, reason);
455 return NULL;
456 }
457
458 mvar = var;
459 if (mvar == NULL)
460 {
461 /* + 1 so that we can '\0' terminate invalid string table sections. */
462 mvar = malloc ((size_t) amt + 1);
463
464 if (mvar == NULL)
465 {
466 if (reason)
467 error (_("Out of memory allocating %s bytes for %s\n"),
468 bfd_vmatoa ("u", amt), reason);
469 return NULL;
470 }
471
472 ((char *) mvar)[amt] = '\0';
473 }
474
475 if (fread (mvar, (size_t) size, (size_t) nmemb, filedata->handle) != nmemb)
476 {
477 if (reason)
478 error (_("Unable to read in %s bytes of %s\n"),
479 bfd_vmatoa ("u", amt), reason);
480 if (mvar != var)
481 free (mvar);
482 return NULL;
483 }
484
485 return mvar;
486}
487
488/* Print a VMA value in the MODE specified.
489 Returns the number of characters displayed. */
490
491static unsigned int
492print_vma (bfd_vma vma, print_mode mode)
493{
494 unsigned int nc = 0;
495
496 switch (mode)
497 {
498 case FULL_HEX:
499 nc = printf ("0x");
500 /* Fall through. */
501 case LONG_HEX:
502#ifdef BFD64
503 if (is_32bit_elf)
504 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
505#endif
506 printf_vma (vma);
507 return nc + 16;
508
509 case DEC_5:
510 if (vma <= 99999)
511 return printf ("%5" BFD_VMA_FMT "d", vma);
512 /* Fall through. */
513 case PREFIX_HEX:
514 nc = printf ("0x");
515 /* Fall through. */
516 case HEX:
517 return nc + printf ("%" BFD_VMA_FMT "x", vma);
518
519 case DEC:
520 return printf ("%" BFD_VMA_FMT "d", vma);
521
522 case UNSIGNED:
523 return printf ("%" BFD_VMA_FMT "u", vma);
524
525 default:
526 /* FIXME: Report unrecognised mode ? */
527 return 0;
528 }
529}
530
531/* Display a symbol on stdout. Handles the display of control characters and
532 multibye characters (assuming the host environment supports them).
533
534 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
535
536 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
537 padding as necessary.
538
539 Returns the number of emitted characters. */
540
541static unsigned int
542print_symbol (signed int width, const char *symbol)
543{
544 bfd_boolean extra_padding = FALSE;
545 signed int num_printed = 0;
546#ifdef HAVE_MBSTATE_T
547 mbstate_t state;
548#endif
549 unsigned int width_remaining;
550
551 if (width < 0)
552 {
553 /* Keep the width positive. This helps the code below. */
554 width = - width;
555 extra_padding = TRUE;
556 }
557 else if (width == 0)
558 return 0;
559
560 if (do_wide)
561 /* Set the remaining width to a very large value.
562 This simplifies the code below. */
563 width_remaining = INT_MAX;
564 else
565 width_remaining = width;
566
567#ifdef HAVE_MBSTATE_T
568 /* Initialise the multibyte conversion state. */
569 memset (& state, 0, sizeof (state));
570#endif
571
572 while (width_remaining)
573 {
574 size_t n;
575 const char c = *symbol++;
576
577 if (c == 0)
578 break;
579
580 /* Do not print control characters directly as they can affect terminal
581 settings. Such characters usually appear in the names generated
582 by the assembler for local labels. */
583 if (ISCNTRL (c))
584 {
585 if (width_remaining < 2)
586 break;
587
588 printf ("^%c", c + 0x40);
589 width_remaining -= 2;
590 num_printed += 2;
591 }
592 else if (ISPRINT (c))
593 {
594 putchar (c);
595 width_remaining --;
596 num_printed ++;
597 }
598 else
599 {
600#ifdef HAVE_MBSTATE_T
601 wchar_t w;
602#endif
603 /* Let printf do the hard work of displaying multibyte characters. */
604 printf ("%.1s", symbol - 1);
605 width_remaining --;
606 num_printed ++;
607
608#ifdef HAVE_MBSTATE_T
609 /* Try to find out how many bytes made up the character that was
610 just printed. Advance the symbol pointer past the bytes that
611 were displayed. */
612 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
613#else
614 n = 1;
615#endif
616 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
617 symbol += (n - 1);
618 }
619 }
620
621 if (extra_padding && num_printed < width)
622 {
623 /* Fill in the remaining spaces. */
624 printf ("%-*s", width - num_printed, " ");
625 num_printed = width;
626 }
627
628 return num_printed;
629}
630
631/* Returns a pointer to a static buffer containing a printable version of
632 the given section's name. Like print_symbol, except that it does not try
633 to print multibyte characters, it just interprets them as hex values. */
634
635static const char *
636printable_section_name (Filedata * filedata, const Elf_Internal_Shdr * sec)
637{
638#define MAX_PRINT_SEC_NAME_LEN 128
639 static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
640 const char * name = SECTION_NAME (sec);
641 char * buf = sec_name_buf;
642 char c;
643 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
644
645 while ((c = * name ++) != 0)
646 {
647 if (ISCNTRL (c))
648 {
649 if (remaining < 2)
650 break;
651
652 * buf ++ = '^';
653 * buf ++ = c + 0x40;
654 remaining -= 2;
655 }
656 else if (ISPRINT (c))
657 {
658 * buf ++ = c;
659 remaining -= 1;
660 }
661 else
662 {
663 static char hex[17] = "0123456789ABCDEF";
664
665 if (remaining < 4)
666 break;
667 * buf ++ = '<';
668 * buf ++ = hex[(c & 0xf0) >> 4];
669 * buf ++ = hex[c & 0x0f];
670 * buf ++ = '>';
671 remaining -= 4;
672 }
673
674 if (remaining == 0)
675 break;
676 }
677
678 * buf = 0;
679 return sec_name_buf;
680}
681
682static const char *
683printable_section_name_from_index (Filedata * filedata, unsigned long ndx)
684{
685 if (ndx >= filedata->file_header.e_shnum)
686 return _("<corrupt>");
687
688 return printable_section_name (filedata, filedata->section_headers + ndx);
689}
690
691/* Return a pointer to section NAME, or NULL if no such section exists. */
692
693static Elf_Internal_Shdr *
694find_section (Filedata * filedata, const char * name)
695{
696 unsigned int i;
697
698 if (filedata->section_headers == NULL)
699 return NULL;
700
701 for (i = 0; i < filedata->file_header.e_shnum; i++)
702 if (streq (SECTION_NAME (filedata->section_headers + i), name))
703 return filedata->section_headers + i;
704
705 return NULL;
706}
707
708/* Return a pointer to a section containing ADDR, or NULL if no such
709 section exists. */
710
711static Elf_Internal_Shdr *
712find_section_by_address (Filedata * filedata, bfd_vma addr)
713{
714 unsigned int i;
715
716 if (filedata->section_headers == NULL)
717 return NULL;
718
719 for (i = 0; i < filedata->file_header.e_shnum; i++)
720 {
721 Elf_Internal_Shdr *sec = filedata->section_headers + i;
722
723 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
724 return sec;
725 }
726
727 return NULL;
728}
729
730static Elf_Internal_Shdr *
731find_section_by_type (Filedata * filedata, unsigned int type)
732{
733 unsigned int i;
734
735 if (filedata->section_headers == NULL)
736 return NULL;
737
738 for (i = 0; i < filedata->file_header.e_shnum; i++)
739 {
740 Elf_Internal_Shdr *sec = filedata->section_headers + i;
741
742 if (sec->sh_type == type)
743 return sec;
744 }
745
746 return NULL;
747}
748
749/* Return a pointer to section NAME, or NULL if no such section exists,
750 restricted to the list of sections given in SET. */
751
752static Elf_Internal_Shdr *
753find_section_in_set (Filedata * filedata, const char * name, unsigned int * set)
754{
755 unsigned int i;
756
757 if (filedata->section_headers == NULL)
758 return NULL;
759
760 if (set != NULL)
761 {
762 while ((i = *set++) > 0)
763 {
764 /* See PR 21156 for a reproducer. */
765 if (i >= filedata->file_header.e_shnum)
766 continue; /* FIXME: Should we issue an error message ? */
767
768 if (streq (SECTION_NAME (filedata->section_headers + i), name))
769 return filedata->section_headers + i;
770 }
771 }
772
773 return find_section (filedata, name);
774}
775
776/* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
777 This OS has so many departures from the ELF standard that we test it at
778 many places. */
779
780static inline bfd_boolean
781is_ia64_vms (Filedata * filedata)
782{
783 return filedata->file_header.e_machine == EM_IA_64
784 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
785}
786
787/* Guess the relocation size commonly used by the specific machines. */
788
789static bfd_boolean
790guess_is_rela (unsigned int e_machine)
791{
792 switch (e_machine)
793 {
794 /* Targets that use REL relocations. */
795 case EM_386:
796 case EM_IAMCU:
797 case EM_960:
798 case EM_ARM:
799 case EM_D10V:
800 case EM_CYGNUS_D10V:
801 case EM_DLX:
802 case EM_MIPS:
803 case EM_MIPS_RS3_LE:
804 case EM_CYGNUS_M32R:
805 case EM_SCORE:
806 case EM_XGATE:
807 case EM_NFP:
808 case EM_BPF:
809 return FALSE;
810
811 /* Targets that use RELA relocations. */
812 case EM_68K:
813 case EM_860:
814 case EM_AARCH64:
815 case EM_ADAPTEVA_EPIPHANY:
816 case EM_ALPHA:
817 case EM_ALTERA_NIOS2:
818 case EM_ARC:
819 case EM_ARC_COMPACT:
820 case EM_ARC_COMPACT2:
821 case EM_AVR:
822 case EM_AVR_OLD:
823 case EM_BLACKFIN:
824 case EM_CR16:
825 case EM_CRIS:
826 case EM_CRX:
827 case EM_CSKY:
828 case EM_D30V:
829 case EM_CYGNUS_D30V:
830 case EM_FR30:
831 case EM_FT32:
832 case EM_CYGNUS_FR30:
833 case EM_CYGNUS_FRV:
834 case EM_H8S:
835 case EM_H8_300:
836 case EM_H8_300H:
837 case EM_IA_64:
838 case EM_IP2K:
839 case EM_IP2K_OLD:
840 case EM_IQ2000:
841 case EM_LATTICEMICO32:
842 case EM_M32C_OLD:
843 case EM_M32C:
844 case EM_M32R:
845 case EM_MCORE:
846 case EM_CYGNUS_MEP:
847 case EM_METAG:
848 case EM_MMIX:
849 case EM_MN10200:
850 case EM_CYGNUS_MN10200:
851 case EM_MN10300:
852 case EM_CYGNUS_MN10300:
853 case EM_MOXIE:
854 case EM_MSP430:
855 case EM_MSP430_OLD:
856 case EM_MT:
857 case EM_NDS32:
858 case EM_NIOS32:
859 case EM_OR1K:
860 case EM_PPC64:
861 case EM_PPC:
862 case EM_TI_PRU:
863 case EM_RISCV:
864 case EM_RL78:
865 case EM_RX:
866 case EM_S390:
867 case EM_S390_OLD:
868 case EM_SH:
869 case EM_SPARC:
870 case EM_SPARC32PLUS:
871 case EM_SPARCV9:
872 case EM_SPU:
873 case EM_TI_C6000:
874 case EM_TILEGX:
875 case EM_TILEPRO:
876 case EM_V800:
877 case EM_V850:
878 case EM_CYGNUS_V850:
879 case EM_VAX:
880 case EM_VISIUM:
881 case EM_X86_64:
882 case EM_L1OM:
883 case EM_K1OM:
884 case EM_XSTORMY16:
885 case EM_XTENSA:
886 case EM_XTENSA_OLD:
887 case EM_MICROBLAZE:
888 case EM_MICROBLAZE_OLD:
889 case EM_WEBASSEMBLY:
890 return TRUE;
891
892 case EM_68HC05:
893 case EM_68HC08:
894 case EM_68HC11:
895 case EM_68HC16:
896 case EM_FX66:
897 case EM_ME16:
898 case EM_MMA:
899 case EM_NCPU:
900 case EM_NDR1:
901 case EM_PCP:
902 case EM_ST100:
903 case EM_ST19:
904 case EM_ST7:
905 case EM_ST9PLUS:
906 case EM_STARCORE:
907 case EM_SVX:
908 case EM_TINYJ:
909 default:
910 warn (_("Don't know about relocations on this machine architecture\n"));
911 return FALSE;
912 }
913}
914
915/* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
916 Returns TRUE upon success, FALSE otherwise. If successful then a
917 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
918 and the number of relocs loaded is placed in *NRELASP. It is the caller's
919 responsibility to free the allocated buffer. */
920
921static bfd_boolean
922slurp_rela_relocs (Filedata * filedata,
923 unsigned long rel_offset,
924 unsigned long rel_size,
925 Elf_Internal_Rela ** relasp,
926 unsigned long * nrelasp)
927{
928 Elf_Internal_Rela * relas;
929 size_t nrelas;
930 unsigned int i;
931
932 if (is_32bit_elf)
933 {
934 Elf32_External_Rela * erelas;
935
936 erelas = (Elf32_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
937 rel_size, _("32-bit relocation data"));
938 if (!erelas)
939 return FALSE;
940
941 nrelas = rel_size / sizeof (Elf32_External_Rela);
942
943 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
944 sizeof (Elf_Internal_Rela));
945
946 if (relas == NULL)
947 {
948 free (erelas);
949 error (_("out of memory parsing relocs\n"));
950 return FALSE;
951 }
952
953 for (i = 0; i < nrelas; i++)
954 {
955 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
956 relas[i].r_info = BYTE_GET (erelas[i].r_info);
957 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
958 }
959
960 free (erelas);
961 }
962 else
963 {
964 Elf64_External_Rela * erelas;
965
966 erelas = (Elf64_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
967 rel_size, _("64-bit relocation data"));
968 if (!erelas)
969 return FALSE;
970
971 nrelas = rel_size / sizeof (Elf64_External_Rela);
972
973 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
974 sizeof (Elf_Internal_Rela));
975
976 if (relas == NULL)
977 {
978 free (erelas);
979 error (_("out of memory parsing relocs\n"));
980 return FALSE;
981 }
982
983 for (i = 0; i < nrelas; i++)
984 {
985 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
986 relas[i].r_info = BYTE_GET (erelas[i].r_info);
987 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
988
989 /* The #ifdef BFD64 below is to prevent a compile time
990 warning. We know that if we do not have a 64 bit data
991 type that we will never execute this code anyway. */
992#ifdef BFD64
993 if (filedata->file_header.e_machine == EM_MIPS
994 && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
995 {
996 /* In little-endian objects, r_info isn't really a
997 64-bit little-endian value: it has a 32-bit
998 little-endian symbol index followed by four
999 individual byte fields. Reorder INFO
1000 accordingly. */
1001 bfd_vma inf = relas[i].r_info;
1002 inf = (((inf & 0xffffffff) << 32)
1003 | ((inf >> 56) & 0xff)
1004 | ((inf >> 40) & 0xff00)
1005 | ((inf >> 24) & 0xff0000)
1006 | ((inf >> 8) & 0xff000000));
1007 relas[i].r_info = inf;
1008 }
1009#endif /* BFD64 */
1010 }
1011
1012 free (erelas);
1013 }
1014
1015 *relasp = relas;
1016 *nrelasp = nrelas;
1017 return TRUE;
1018}
1019
1020/* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1021 Returns TRUE upon success, FALSE otherwise. If successful then a
1022 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1023 and the number of relocs loaded is placed in *NRELSP. It is the caller's
1024 responsibility to free the allocated buffer. */
1025
1026static bfd_boolean
1027slurp_rel_relocs (Filedata * filedata,
1028 unsigned long rel_offset,
1029 unsigned long rel_size,
1030 Elf_Internal_Rela ** relsp,
1031 unsigned long * nrelsp)
1032{
1033 Elf_Internal_Rela * rels;
1034 size_t nrels;
1035 unsigned int i;
1036
1037 if (is_32bit_elf)
1038 {
1039 Elf32_External_Rel * erels;
1040
1041 erels = (Elf32_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1042 rel_size, _("32-bit relocation data"));
1043 if (!erels)
1044 return FALSE;
1045
1046 nrels = rel_size / sizeof (Elf32_External_Rel);
1047
1048 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1049
1050 if (rels == NULL)
1051 {
1052 free (erels);
1053 error (_("out of memory parsing relocs\n"));
1054 return FALSE;
1055 }
1056
1057 for (i = 0; i < nrels; i++)
1058 {
1059 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1060 rels[i].r_info = BYTE_GET (erels[i].r_info);
1061 rels[i].r_addend = 0;
1062 }
1063
1064 free (erels);
1065 }
1066 else
1067 {
1068 Elf64_External_Rel * erels;
1069
1070 erels = (Elf64_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1071 rel_size, _("64-bit relocation data"));
1072 if (!erels)
1073 return FALSE;
1074
1075 nrels = rel_size / sizeof (Elf64_External_Rel);
1076
1077 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1078
1079 if (rels == NULL)
1080 {
1081 free (erels);
1082 error (_("out of memory parsing relocs\n"));
1083 return FALSE;
1084 }
1085
1086 for (i = 0; i < nrels; i++)
1087 {
1088 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1089 rels[i].r_info = BYTE_GET (erels[i].r_info);
1090 rels[i].r_addend = 0;
1091
1092 /* The #ifdef BFD64 below is to prevent a compile time
1093 warning. We know that if we do not have a 64 bit data
1094 type that we will never execute this code anyway. */
1095#ifdef BFD64
1096 if (filedata->file_header.e_machine == EM_MIPS
1097 && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
1098 {
1099 /* In little-endian objects, r_info isn't really a
1100 64-bit little-endian value: it has a 32-bit
1101 little-endian symbol index followed by four
1102 individual byte fields. Reorder INFO
1103 accordingly. */
1104 bfd_vma inf = rels[i].r_info;
1105 inf = (((inf & 0xffffffff) << 32)
1106 | ((inf >> 56) & 0xff)
1107 | ((inf >> 40) & 0xff00)
1108 | ((inf >> 24) & 0xff0000)
1109 | ((inf >> 8) & 0xff000000));
1110 rels[i].r_info = inf;
1111 }
1112#endif /* BFD64 */
1113 }
1114
1115 free (erels);
1116 }
1117
1118 *relsp = rels;
1119 *nrelsp = nrels;
1120 return TRUE;
1121}
1122
1123/* Returns the reloc type extracted from the reloc info field. */
1124
1125static unsigned int
1126get_reloc_type (Filedata * filedata, bfd_vma reloc_info)
1127{
1128 if (is_32bit_elf)
1129 return ELF32_R_TYPE (reloc_info);
1130
1131 switch (filedata->file_header.e_machine)
1132 {
1133 case EM_MIPS:
1134 /* Note: We assume that reloc_info has already been adjusted for us. */
1135 return ELF64_MIPS_R_TYPE (reloc_info);
1136
1137 case EM_SPARCV9:
1138 return ELF64_R_TYPE_ID (reloc_info);
1139
1140 default:
1141 return ELF64_R_TYPE (reloc_info);
1142 }
1143}
1144
1145/* Return the symbol index extracted from the reloc info field. */
1146
1147static bfd_vma
1148get_reloc_symindex (bfd_vma reloc_info)
1149{
1150 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1151}
1152
1153static inline bfd_boolean
1154uses_msp430x_relocs (Filedata * filedata)
1155{
1156 return
1157 filedata->file_header.e_machine == EM_MSP430 /* Paranoia. */
1158 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1159 && (((filedata->file_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1160 /* TI compiler uses ELFOSABI_NONE. */
1161 || (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1162}
1163
1164/* Display the contents of the relocation data found at the specified
1165 offset. */
1166
1167static bfd_boolean
1168dump_relocations (Filedata * filedata,
1169 unsigned long rel_offset,
1170 unsigned long rel_size,
1171 Elf_Internal_Sym * symtab,
1172 unsigned long nsyms,
1173 char * strtab,
1174 unsigned long strtablen,
1175 int is_rela,
1176 bfd_boolean is_dynsym)
1177{
1178 unsigned long i;
1179 Elf_Internal_Rela * rels;
1180 bfd_boolean res = TRUE;
1181
1182 if (is_rela == UNKNOWN)
1183 is_rela = guess_is_rela (filedata->file_header.e_machine);
1184
1185 if (is_rela)
1186 {
1187 if (!slurp_rela_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1188 return FALSE;
1189 }
1190 else
1191 {
1192 if (!slurp_rel_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1193 return FALSE;
1194 }
1195
1196 if (is_32bit_elf)
1197 {
1198 if (is_rela)
1199 {
1200 if (do_wide)
1201 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1202 else
1203 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1204 }
1205 else
1206 {
1207 if (do_wide)
1208 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1209 else
1210 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1211 }
1212 }
1213 else
1214 {
1215 if (is_rela)
1216 {
1217 if (do_wide)
1218 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1219 else
1220 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1221 }
1222 else
1223 {
1224 if (do_wide)
1225 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1226 else
1227 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1228 }
1229 }
1230
1231 for (i = 0; i < rel_size; i++)
1232 {
1233 const char * rtype;
1234 bfd_vma offset;
1235 bfd_vma inf;
1236 bfd_vma symtab_index;
1237 bfd_vma type;
1238
1239 offset = rels[i].r_offset;
1240 inf = rels[i].r_info;
1241
1242 type = get_reloc_type (filedata, inf);
1243 symtab_index = get_reloc_symindex (inf);
1244
1245 if (is_32bit_elf)
1246 {
1247 printf ("%8.8lx %8.8lx ",
1248 (unsigned long) offset & 0xffffffff,
1249 (unsigned long) inf & 0xffffffff);
1250 }
1251 else
1252 {
1253#if BFD_HOST_64BIT_LONG
1254 printf (do_wide
1255 ? "%16.16lx %16.16lx "
1256 : "%12.12lx %12.12lx ",
1257 offset, inf);
1258#elif BFD_HOST_64BIT_LONG_LONG
1259#ifndef __MSVCRT__
1260 printf (do_wide
1261 ? "%16.16llx %16.16llx "
1262 : "%12.12llx %12.12llx ",
1263 offset, inf);
1264#else
1265 printf (do_wide
1266 ? "%16.16I64x %16.16I64x "
1267 : "%12.12I64x %12.12I64x ",
1268 offset, inf);
1269#endif
1270#else
1271 printf (do_wide
1272 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1273 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1274 _bfd_int64_high (offset),
1275 _bfd_int64_low (offset),
1276 _bfd_int64_high (inf),
1277 _bfd_int64_low (inf));
1278#endif
1279 }
1280
1281 switch (filedata->file_header.e_machine)
1282 {
1283 default:
1284 rtype = NULL;
1285 break;
1286
1287 case EM_AARCH64:
1288 rtype = elf_aarch64_reloc_type (type);
1289 break;
1290
1291 case EM_M32R:
1292 case EM_CYGNUS_M32R:
1293 rtype = elf_m32r_reloc_type (type);
1294 break;
1295
1296 case EM_386:
1297 case EM_IAMCU:
1298 rtype = elf_i386_reloc_type (type);
1299 break;
1300
1301 case EM_68HC11:
1302 case EM_68HC12:
1303 rtype = elf_m68hc11_reloc_type (type);
1304 break;
1305
1306 case EM_S12Z:
1307 rtype = elf_s12z_reloc_type (type);
1308 break;
1309
1310 case EM_68K:
1311 rtype = elf_m68k_reloc_type (type);
1312 break;
1313
1314 case EM_960:
1315 rtype = elf_i960_reloc_type (type);
1316 break;
1317
1318 case EM_AVR:
1319 case EM_AVR_OLD:
1320 rtype = elf_avr_reloc_type (type);
1321 break;
1322
1323 case EM_OLD_SPARCV9:
1324 case EM_SPARC32PLUS:
1325 case EM_SPARCV9:
1326 case EM_SPARC:
1327 rtype = elf_sparc_reloc_type (type);
1328 break;
1329
1330 case EM_SPU:
1331 rtype = elf_spu_reloc_type (type);
1332 break;
1333
1334 case EM_V800:
1335 rtype = v800_reloc_type (type);
1336 break;
1337 case EM_V850:
1338 case EM_CYGNUS_V850:
1339 rtype = v850_reloc_type (type);
1340 break;
1341
1342 case EM_D10V:
1343 case EM_CYGNUS_D10V:
1344 rtype = elf_d10v_reloc_type (type);
1345 break;
1346
1347 case EM_D30V:
1348 case EM_CYGNUS_D30V:
1349 rtype = elf_d30v_reloc_type (type);
1350 break;
1351
1352 case EM_DLX:
1353 rtype = elf_dlx_reloc_type (type);
1354 break;
1355
1356 case EM_SH:
1357 rtype = elf_sh_reloc_type (type);
1358 break;
1359
1360 case EM_MN10300:
1361 case EM_CYGNUS_MN10300:
1362 rtype = elf_mn10300_reloc_type (type);
1363 break;
1364
1365 case EM_MN10200:
1366 case EM_CYGNUS_MN10200:
1367 rtype = elf_mn10200_reloc_type (type);
1368 break;
1369
1370 case EM_FR30:
1371 case EM_CYGNUS_FR30:
1372 rtype = elf_fr30_reloc_type (type);
1373 break;
1374
1375 case EM_CYGNUS_FRV:
1376 rtype = elf_frv_reloc_type (type);
1377 break;
1378
1379 case EM_CSKY:
1380 rtype = elf_csky_reloc_type (type);
1381 break;
1382
1383 case EM_FT32:
1384 rtype = elf_ft32_reloc_type (type);
1385 break;
1386
1387 case EM_MCORE:
1388 rtype = elf_mcore_reloc_type (type);
1389 break;
1390
1391 case EM_MMIX:
1392 rtype = elf_mmix_reloc_type (type);
1393 break;
1394
1395 case EM_MOXIE:
1396 rtype = elf_moxie_reloc_type (type);
1397 break;
1398
1399 case EM_MSP430:
1400 if (uses_msp430x_relocs (filedata))
1401 {
1402 rtype = elf_msp430x_reloc_type (type);
1403 break;
1404 }
1405 /* Fall through. */
1406 case EM_MSP430_OLD:
1407 rtype = elf_msp430_reloc_type (type);
1408 break;
1409
1410 case EM_NDS32:
1411 rtype = elf_nds32_reloc_type (type);
1412 break;
1413
1414 case EM_PPC:
1415 rtype = elf_ppc_reloc_type (type);
1416 break;
1417
1418 case EM_PPC64:
1419 rtype = elf_ppc64_reloc_type (type);
1420 break;
1421
1422 case EM_MIPS:
1423 case EM_MIPS_RS3_LE:
1424 rtype = elf_mips_reloc_type (type);
1425 break;
1426
1427 case EM_RISCV:
1428 rtype = elf_riscv_reloc_type (type);
1429 break;
1430
1431 case EM_ALPHA:
1432 rtype = elf_alpha_reloc_type (type);
1433 break;
1434
1435 case EM_ARM:
1436 rtype = elf_arm_reloc_type (type);
1437 break;
1438
1439 case EM_ARC:
1440 case EM_ARC_COMPACT:
1441 case EM_ARC_COMPACT2:
1442 rtype = elf_arc_reloc_type (type);
1443 break;
1444
1445 case EM_PARISC:
1446 rtype = elf_hppa_reloc_type (type);
1447 break;
1448
1449 case EM_H8_300:
1450 case EM_H8_300H:
1451 case EM_H8S:
1452 rtype = elf_h8_reloc_type (type);
1453 break;
1454
1455 case EM_OR1K:
1456 rtype = elf_or1k_reloc_type (type);
1457 break;
1458
1459 case EM_PJ:
1460 case EM_PJ_OLD:
1461 rtype = elf_pj_reloc_type (type);
1462 break;
1463 case EM_IA_64:
1464 rtype = elf_ia64_reloc_type (type);
1465 break;
1466
1467 case EM_CRIS:
1468 rtype = elf_cris_reloc_type (type);
1469 break;
1470
1471 case EM_860:
1472 rtype = elf_i860_reloc_type (type);
1473 break;
1474
1475 case EM_X86_64:
1476 case EM_L1OM:
1477 case EM_K1OM:
1478 rtype = elf_x86_64_reloc_type (type);
1479 break;
1480
1481 case EM_S370:
1482 rtype = i370_reloc_type (type);
1483 break;
1484
1485 case EM_S390_OLD:
1486 case EM_S390:
1487 rtype = elf_s390_reloc_type (type);
1488 break;
1489
1490 case EM_SCORE:
1491 rtype = elf_score_reloc_type (type);
1492 break;
1493
1494 case EM_XSTORMY16:
1495 rtype = elf_xstormy16_reloc_type (type);
1496 break;
1497
1498 case EM_CRX:
1499 rtype = elf_crx_reloc_type (type);
1500 break;
1501
1502 case EM_VAX:
1503 rtype = elf_vax_reloc_type (type);
1504 break;
1505
1506 case EM_VISIUM:
1507 rtype = elf_visium_reloc_type (type);
1508 break;
1509
1510 case EM_BPF:
1511 rtype = elf_bpf_reloc_type (type);
1512 break;
1513
1514 case EM_ADAPTEVA_EPIPHANY:
1515 rtype = elf_epiphany_reloc_type (type);
1516 break;
1517
1518 case EM_IP2K:
1519 case EM_IP2K_OLD:
1520 rtype = elf_ip2k_reloc_type (type);
1521 break;
1522
1523 case EM_IQ2000:
1524 rtype = elf_iq2000_reloc_type (type);
1525 break;
1526
1527 case EM_XTENSA_OLD:
1528 case EM_XTENSA:
1529 rtype = elf_xtensa_reloc_type (type);
1530 break;
1531
1532 case EM_LATTICEMICO32:
1533 rtype = elf_lm32_reloc_type (type);
1534 break;
1535
1536 case EM_M32C_OLD:
1537 case EM_M32C:
1538 rtype = elf_m32c_reloc_type (type);
1539 break;
1540
1541 case EM_MT:
1542 rtype = elf_mt_reloc_type (type);
1543 break;
1544
1545 case EM_BLACKFIN:
1546 rtype = elf_bfin_reloc_type (type);
1547 break;
1548
1549 case EM_CYGNUS_MEP:
1550 rtype = elf_mep_reloc_type (type);
1551 break;
1552
1553 case EM_CR16:
1554 rtype = elf_cr16_reloc_type (type);
1555 break;
1556
1557 case EM_MICROBLAZE:
1558 case EM_MICROBLAZE_OLD:
1559 rtype = elf_microblaze_reloc_type (type);
1560 break;
1561
1562 case EM_RL78:
1563 rtype = elf_rl78_reloc_type (type);
1564 break;
1565
1566 case EM_RX:
1567 rtype = elf_rx_reloc_type (type);
1568 break;
1569
1570 case EM_METAG:
1571 rtype = elf_metag_reloc_type (type);
1572 break;
1573
1574 case EM_XC16X:
1575 case EM_C166:
1576 rtype = elf_xc16x_reloc_type (type);
1577 break;
1578
1579 case EM_TI_C6000:
1580 rtype = elf_tic6x_reloc_type (type);
1581 break;
1582
1583 case EM_TILEGX:
1584 rtype = elf_tilegx_reloc_type (type);
1585 break;
1586
1587 case EM_TILEPRO:
1588 rtype = elf_tilepro_reloc_type (type);
1589 break;
1590
1591 case EM_WEBASSEMBLY:
1592 rtype = elf_wasm32_reloc_type (type);
1593 break;
1594
1595 case EM_XGATE:
1596 rtype = elf_xgate_reloc_type (type);
1597 break;
1598
1599 case EM_ALTERA_NIOS2:
1600 rtype = elf_nios2_reloc_type (type);
1601 break;
1602
1603 case EM_TI_PRU:
1604 rtype = elf_pru_reloc_type (type);
1605 break;
1606
1607 case EM_NFP:
1608 if (EF_NFP_MACH (filedata->file_header.e_flags) == E_NFP_MACH_3200)
1609 rtype = elf_nfp3200_reloc_type (type);
1610 else
1611 rtype = elf_nfp_reloc_type (type);
1612 break;
1613
1614 case EM_Z80:
1615 rtype = elf_z80_reloc_type (type);
1616 break;
1617 }
1618
1619 if (rtype == NULL)
1620 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1621 else
1622 printf (do_wide ? "%-22s" : "%-17.17s", rtype);
1623
1624 if (filedata->file_header.e_machine == EM_ALPHA
1625 && rtype != NULL
1626 && streq (rtype, "R_ALPHA_LITUSE")
1627 && is_rela)
1628 {
1629 switch (rels[i].r_addend)
1630 {
1631 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1632 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1633 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1634 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1635 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1636 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1637 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1638 default: rtype = NULL;
1639 }
1640
1641 if (rtype)
1642 printf (" (%s)", rtype);
1643 else
1644 {
1645 putchar (' ');
1646 printf (_("<unknown addend: %lx>"),
1647 (unsigned long) rels[i].r_addend);
1648 res = FALSE;
1649 }
1650 }
1651 else if (symtab_index)
1652 {
1653 if (symtab == NULL || symtab_index >= nsyms)
1654 {
1655 error (_(" bad symbol index: %08lx in reloc\n"),
1656 (unsigned long) symtab_index);
1657 res = FALSE;
1658 }
1659 else
1660 {
1661 Elf_Internal_Sym * psym;
1662 const char * version_string;
1663 enum versioned_symbol_info sym_info;
1664 unsigned short vna_other;
1665
1666 psym = symtab + symtab_index;
1667
1668 version_string
1669 = get_symbol_version_string (filedata, is_dynsym,
1670 strtab, strtablen,
1671 symtab_index,
1672 psym,
1673 &sym_info,
1674 &vna_other);
1675
1676 printf (" ");
1677
1678 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1679 {
1680 const char * name;
1681 unsigned int len;
1682 unsigned int width = is_32bit_elf ? 8 : 14;
1683
1684 /* Relocations against GNU_IFUNC symbols do not use the value
1685 of the symbol as the address to relocate against. Instead
1686 they invoke the function named by the symbol and use its
1687 result as the address for relocation.
1688
1689 To indicate this to the user, do not display the value of
1690 the symbol in the "Symbols's Value" field. Instead show
1691 its name followed by () as a hint that the symbol is
1692 invoked. */
1693
1694 if (strtab == NULL
1695 || psym->st_name == 0
1696 || psym->st_name >= strtablen)
1697 name = "??";
1698 else
1699 name = strtab + psym->st_name;
1700
1701 len = print_symbol (width, name);
1702 if (version_string)
1703 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1704 version_string);
1705 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1706 }
1707 else
1708 {
1709 print_vma (psym->st_value, LONG_HEX);
1710
1711 printf (is_32bit_elf ? " " : " ");
1712 }
1713
1714 if (psym->st_name == 0)
1715 {
1716 const char * sec_name = "<null>";
1717 char name_buf[40];
1718
1719 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1720 {
1721 if (psym->st_shndx < filedata->file_header.e_shnum)
1722 sec_name = SECTION_NAME (filedata->section_headers + psym->st_shndx);
1723 else if (psym->st_shndx == SHN_ABS)
1724 sec_name = "ABS";
1725 else if (psym->st_shndx == SHN_COMMON)
1726 sec_name = "COMMON";
1727 else if ((filedata->file_header.e_machine == EM_MIPS
1728 && psym->st_shndx == SHN_MIPS_SCOMMON)
1729 || (filedata->file_header.e_machine == EM_TI_C6000
1730 && psym->st_shndx == SHN_TIC6X_SCOMMON))
1731 sec_name = "SCOMMON";
1732 else if (filedata->file_header.e_machine == EM_MIPS
1733 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1734 sec_name = "SUNDEF";
1735 else if ((filedata->file_header.e_machine == EM_X86_64
1736 || filedata->file_header.e_machine == EM_L1OM
1737 || filedata->file_header.e_machine == EM_K1OM)
1738 && psym->st_shndx == SHN_X86_64_LCOMMON)
1739 sec_name = "LARGE_COMMON";
1740 else if (filedata->file_header.e_machine == EM_IA_64
1741 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1742 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1743 sec_name = "ANSI_COM";
1744 else if (is_ia64_vms (filedata)
1745 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1746 sec_name = "VMS_SYMVEC";
1747 else
1748 {
1749 sprintf (name_buf, "<section 0x%x>",
1750 (unsigned int) psym->st_shndx);
1751 sec_name = name_buf;
1752 }
1753 }
1754 print_symbol (22, sec_name);
1755 }
1756 else if (strtab == NULL)
1757 printf (_("<string table index: %3ld>"), psym->st_name);
1758 else if (psym->st_name >= strtablen)
1759 {
1760 error (_("<corrupt string table index: %3ld>\n"),
1761 psym->st_name);
1762 res = FALSE;
1763 }
1764 else
1765 {
1766 print_symbol (22, strtab + psym->st_name);
1767 if (version_string)
1768 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1769 version_string);
1770 }
1771
1772 if (is_rela)
1773 {
1774 bfd_vma off = rels[i].r_addend;
1775
1776 if ((bfd_signed_vma) off < 0)
1777 printf (" - %" BFD_VMA_FMT "x", - off);
1778 else
1779 printf (" + %" BFD_VMA_FMT "x", off);
1780 }
1781 }
1782 }
1783 else if (is_rela)
1784 {
1785 bfd_vma off = rels[i].r_addend;
1786
1787 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1788 if ((bfd_signed_vma) off < 0)
1789 printf ("-%" BFD_VMA_FMT "x", - off);
1790 else
1791 printf ("%" BFD_VMA_FMT "x", off);
1792 }
1793
1794 if (filedata->file_header.e_machine == EM_SPARCV9
1795 && rtype != NULL
1796 && streq (rtype, "R_SPARC_OLO10"))
1797 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1798
1799 putchar ('\n');
1800
1801#ifdef BFD64
1802 if (! is_32bit_elf && filedata->file_header.e_machine == EM_MIPS)
1803 {
1804 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1805 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1806 const char * rtype2 = elf_mips_reloc_type (type2);
1807 const char * rtype3 = elf_mips_reloc_type (type3);
1808
1809 printf (" Type2: ");
1810
1811 if (rtype2 == NULL)
1812 printf (_("unrecognized: %-7lx"),
1813 (unsigned long) type2 & 0xffffffff);
1814 else
1815 printf ("%-17.17s", rtype2);
1816
1817 printf ("\n Type3: ");
1818
1819 if (rtype3 == NULL)
1820 printf (_("unrecognized: %-7lx"),
1821 (unsigned long) type3 & 0xffffffff);
1822 else
1823 printf ("%-17.17s", rtype3);
1824
1825 putchar ('\n');
1826 }
1827#endif /* BFD64 */
1828 }
1829
1830 free (rels);
1831
1832 return res;
1833}
1834
1835static const char *
1836get_aarch64_dynamic_type (unsigned long type)
1837{
1838 switch (type)
1839 {
1840 case DT_AARCH64_BTI_PLT: return "AARCH64_BTI_PLT";
1841 case DT_AARCH64_PAC_PLT: return "AARCH64_PAC_PLT";
1842 case DT_AARCH64_VARIANT_PCS: return "AARCH64_VARIANT_PCS";
1843 default:
1844 return NULL;
1845 }
1846}
1847
1848static const char *
1849get_mips_dynamic_type (unsigned long type)
1850{
1851 switch (type)
1852 {
1853 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1854 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1855 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1856 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1857 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1858 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1859 case DT_MIPS_MSYM: return "MIPS_MSYM";
1860 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1861 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1862 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1863 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1864 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1865 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1866 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1867 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1868 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1869 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1870 case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
1871 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1872 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1873 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1874 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1875 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1876 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1877 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1878 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1879 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1880 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1881 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1882 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1883 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1884 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1885 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1886 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1887 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1888 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1889 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1890 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1891 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1892 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1893 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1894 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1895 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1896 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1897 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1898 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1899 case DT_MIPS_XHASH: return "MIPS_XHASH";
1900 default:
1901 return NULL;
1902 }
1903}
1904
1905static const char *
1906get_sparc64_dynamic_type (unsigned long type)
1907{
1908 switch (type)
1909 {
1910 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1911 default:
1912 return NULL;
1913 }
1914}
1915
1916static const char *
1917get_ppc_dynamic_type (unsigned long type)
1918{
1919 switch (type)
1920 {
1921 case DT_PPC_GOT: return "PPC_GOT";
1922 case DT_PPC_OPT: return "PPC_OPT";
1923 default:
1924 return NULL;
1925 }
1926}
1927
1928static const char *
1929get_ppc64_dynamic_type (unsigned long type)
1930{
1931 switch (type)
1932 {
1933 case DT_PPC64_GLINK: return "PPC64_GLINK";
1934 case DT_PPC64_OPD: return "PPC64_OPD";
1935 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1936 case DT_PPC64_OPT: return "PPC64_OPT";
1937 default:
1938 return NULL;
1939 }
1940}
1941
1942static const char *
1943get_parisc_dynamic_type (unsigned long type)
1944{
1945 switch (type)
1946 {
1947 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1948 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1949 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1950 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1951 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1952 case DT_HP_PREINIT: return "HP_PREINIT";
1953 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1954 case DT_HP_NEEDED: return "HP_NEEDED";
1955 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1956 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1957 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1958 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1959 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1960 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1961 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1962 case DT_HP_FILTERED: return "HP_FILTERED";
1963 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1964 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1965 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1966 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1967 case DT_PLT: return "PLT";
1968 case DT_PLT_SIZE: return "PLT_SIZE";
1969 case DT_DLT: return "DLT";
1970 case DT_DLT_SIZE: return "DLT_SIZE";
1971 default:
1972 return NULL;
1973 }
1974}
1975
1976static const char *
1977get_ia64_dynamic_type (unsigned long type)
1978{
1979 switch (type)
1980 {
1981 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1982 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1983 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1984 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1985 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1986 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1987 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1988 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1989 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1990 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1991 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1992 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1993 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1994 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1995 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1996 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1997 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1998 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1999 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
2000 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
2001 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
2002 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
2003 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
2004 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
2005 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
2006 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
2007 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
2008 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
2009 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
2010 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
2011 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
2012 default:
2013 return NULL;
2014 }
2015}
2016
2017static const char *
2018get_solaris_section_type (unsigned long type)
2019{
2020 switch (type)
2021 {
2022 case 0x6fffffee: return "SUNW_ancillary";
2023 case 0x6fffffef: return "SUNW_capchain";
2024 case 0x6ffffff0: return "SUNW_capinfo";
2025 case 0x6ffffff1: return "SUNW_symsort";
2026 case 0x6ffffff2: return "SUNW_tlssort";
2027 case 0x6ffffff3: return "SUNW_LDYNSYM";
2028 case 0x6ffffff4: return "SUNW_dof";
2029 case 0x6ffffff5: return "SUNW_cap";
2030 case 0x6ffffff6: return "SUNW_SIGNATURE";
2031 case 0x6ffffff7: return "SUNW_ANNOTATE";
2032 case 0x6ffffff8: return "SUNW_DEBUGSTR";
2033 case 0x6ffffff9: return "SUNW_DEBUG";
2034 case 0x6ffffffa: return "SUNW_move";
2035 case 0x6ffffffb: return "SUNW_COMDAT";
2036 case 0x6ffffffc: return "SUNW_syminfo";
2037 case 0x6ffffffd: return "SUNW_verdef";
2038 case 0x6ffffffe: return "SUNW_verneed";
2039 case 0x6fffffff: return "SUNW_versym";
2040 case 0x70000000: return "SPARC_GOTDATA";
2041 default: return NULL;
2042 }
2043}
2044
2045static const char *
2046get_alpha_dynamic_type (unsigned long type)
2047{
2048 switch (type)
2049 {
2050 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
2051 default: return NULL;
2052 }
2053}
2054
2055static const char *
2056get_score_dynamic_type (unsigned long type)
2057{
2058 switch (type)
2059 {
2060 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
2061 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
2062 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
2063 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
2064 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
2065 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
2066 default: return NULL;
2067 }
2068}
2069
2070static const char *
2071get_tic6x_dynamic_type (unsigned long type)
2072{
2073 switch (type)
2074 {
2075 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
2076 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
2077 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
2078 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
2079 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
2080 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
2081 default: return NULL;
2082 }
2083}
2084
2085static const char *
2086get_nios2_dynamic_type (unsigned long type)
2087{
2088 switch (type)
2089 {
2090 case DT_NIOS2_GP: return "NIOS2_GP";
2091 default: return NULL;
2092 }
2093}
2094
2095static const char *
2096get_solaris_dynamic_type (unsigned long type)
2097{
2098 switch (type)
2099 {
2100 case 0x6000000d: return "SUNW_AUXILIARY";
2101 case 0x6000000e: return "SUNW_RTLDINF";
2102 case 0x6000000f: return "SUNW_FILTER";
2103 case 0x60000010: return "SUNW_CAP";
2104 case 0x60000011: return "SUNW_SYMTAB";
2105 case 0x60000012: return "SUNW_SYMSZ";
2106 case 0x60000013: return "SUNW_SORTENT";
2107 case 0x60000014: return "SUNW_SYMSORT";
2108 case 0x60000015: return "SUNW_SYMSORTSZ";
2109 case 0x60000016: return "SUNW_TLSSORT";
2110 case 0x60000017: return "SUNW_TLSSORTSZ";
2111 case 0x60000018: return "SUNW_CAPINFO";
2112 case 0x60000019: return "SUNW_STRPAD";
2113 case 0x6000001a: return "SUNW_CAPCHAIN";
2114 case 0x6000001b: return "SUNW_LDMACH";
2115 case 0x6000001d: return "SUNW_CAPCHAINENT";
2116 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2117 case 0x60000021: return "SUNW_PARENT";
2118 case 0x60000023: return "SUNW_ASLR";
2119 case 0x60000025: return "SUNW_RELAX";
2120 case 0x60000029: return "SUNW_NXHEAP";
2121 case 0x6000002b: return "SUNW_NXSTACK";
2122
2123 case 0x70000001: return "SPARC_REGISTER";
2124 case 0x7ffffffd: return "AUXILIARY";
2125 case 0x7ffffffe: return "USED";
2126 case 0x7fffffff: return "FILTER";
2127
2128 default: return NULL;
2129 }
2130}
2131
2132static const char *
2133get_dynamic_type (Filedata * filedata, unsigned long type)
2134{
2135 static char buff[64];
2136
2137 switch (type)
2138 {
2139 case DT_NULL: return "NULL";
2140 case DT_NEEDED: return "NEEDED";
2141 case DT_PLTRELSZ: return "PLTRELSZ";
2142 case DT_PLTGOT: return "PLTGOT";
2143 case DT_HASH: return "HASH";
2144 case DT_STRTAB: return "STRTAB";
2145 case DT_SYMTAB: return "SYMTAB";
2146 case DT_RELA: return "RELA";
2147 case DT_RELASZ: return "RELASZ";
2148 case DT_RELAENT: return "RELAENT";
2149 case DT_STRSZ: return "STRSZ";
2150 case DT_SYMENT: return "SYMENT";
2151 case DT_INIT: return "INIT";
2152 case DT_FINI: return "FINI";
2153 case DT_SONAME: return "SONAME";
2154 case DT_RPATH: return "RPATH";
2155 case DT_SYMBOLIC: return "SYMBOLIC";
2156 case DT_REL: return "REL";
2157 case DT_RELSZ: return "RELSZ";
2158 case DT_RELENT: return "RELENT";
2159 case DT_PLTREL: return "PLTREL";
2160 case DT_DEBUG: return "DEBUG";
2161 case DT_TEXTREL: return "TEXTREL";
2162 case DT_JMPREL: return "JMPREL";
2163 case DT_BIND_NOW: return "BIND_NOW";
2164 case DT_INIT_ARRAY: return "INIT_ARRAY";
2165 case DT_FINI_ARRAY: return "FINI_ARRAY";
2166 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2167 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
2168 case DT_RUNPATH: return "RUNPATH";
2169 case DT_FLAGS: return "FLAGS";
2170
2171 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2172 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
2173 case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
2174
2175 case DT_CHECKSUM: return "CHECKSUM";
2176 case DT_PLTPADSZ: return "PLTPADSZ";
2177 case DT_MOVEENT: return "MOVEENT";
2178 case DT_MOVESZ: return "MOVESZ";
2179 case DT_FEATURE: return "FEATURE";
2180 case DT_POSFLAG_1: return "POSFLAG_1";
2181 case DT_SYMINSZ: return "SYMINSZ";
2182 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
2183
2184 case DT_ADDRRNGLO: return "ADDRRNGLO";
2185 case DT_CONFIG: return "CONFIG";
2186 case DT_DEPAUDIT: return "DEPAUDIT";
2187 case DT_AUDIT: return "AUDIT";
2188 case DT_PLTPAD: return "PLTPAD";
2189 case DT_MOVETAB: return "MOVETAB";
2190 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
2191
2192 case DT_VERSYM: return "VERSYM";
2193
2194 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2195 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
2196 case DT_RELACOUNT: return "RELACOUNT";
2197 case DT_RELCOUNT: return "RELCOUNT";
2198 case DT_FLAGS_1: return "FLAGS_1";
2199 case DT_VERDEF: return "VERDEF";
2200 case DT_VERDEFNUM: return "VERDEFNUM";
2201 case DT_VERNEED: return "VERNEED";
2202 case DT_VERNEEDNUM: return "VERNEEDNUM";
2203
2204 case DT_AUXILIARY: return "AUXILIARY";
2205 case DT_USED: return "USED";
2206 case DT_FILTER: return "FILTER";
2207
2208 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2209 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2210 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2211 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2212 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
2213 case DT_GNU_HASH: return "GNU_HASH";
2214
2215 default:
2216 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2217 {
2218 const char * result;
2219
2220 switch (filedata->file_header.e_machine)
2221 {
2222 case EM_AARCH64:
2223 result = get_aarch64_dynamic_type (type);
2224 break;
2225 case EM_MIPS:
2226 case EM_MIPS_RS3_LE:
2227 result = get_mips_dynamic_type (type);
2228 break;
2229 case EM_SPARCV9:
2230 result = get_sparc64_dynamic_type (type);
2231 break;
2232 case EM_PPC:
2233 result = get_ppc_dynamic_type (type);
2234 break;
2235 case EM_PPC64:
2236 result = get_ppc64_dynamic_type (type);
2237 break;
2238 case EM_IA_64:
2239 result = get_ia64_dynamic_type (type);
2240 break;
2241 case EM_ALPHA:
2242 result = get_alpha_dynamic_type (type);
2243 break;
2244 case EM_SCORE:
2245 result = get_score_dynamic_type (type);
2246 break;
2247 case EM_TI_C6000:
2248 result = get_tic6x_dynamic_type (type);
2249 break;
2250 case EM_ALTERA_NIOS2:
2251 result = get_nios2_dynamic_type (type);
2252 break;
2253 default:
2254 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2255 result = get_solaris_dynamic_type (type);
2256 else
2257 result = NULL;
2258 break;
2259 }
2260
2261 if (result != NULL)
2262 return result;
2263
2264 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2265 }
2266 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2267 || (filedata->file_header.e_machine == EM_PARISC
2268 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2269 {
2270 const char * result;
2271
2272 switch (filedata->file_header.e_machine)
2273 {
2274 case EM_PARISC:
2275 result = get_parisc_dynamic_type (type);
2276 break;
2277 case EM_IA_64:
2278 result = get_ia64_dynamic_type (type);
2279 break;
2280 default:
2281 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2282 result = get_solaris_dynamic_type (type);
2283 else
2284 result = NULL;
2285 break;
2286 }
2287
2288 if (result != NULL)
2289 return result;
2290
2291 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2292 type);
2293 }
2294 else
2295 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2296
2297 return buff;
2298 }
2299}
2300
2301static char *
2302get_file_type (unsigned e_type)
2303{
2304 static char buff[64];
2305
2306 switch (e_type)
2307 {
2308 case ET_NONE: return _("NONE (None)");
2309 case ET_REL: return _("REL (Relocatable file)");
2310 case ET_EXEC: return _("EXEC (Executable file)");
2311 case ET_DYN: return _("DYN (Shared object file)");
2312 case ET_CORE: return _("CORE (Core file)");
2313
2314 default:
2315 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2316 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2317 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2318 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2319 else
2320 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2321 return buff;
2322 }
2323}
2324
2325static char *
2326get_machine_name (unsigned e_machine)
2327{
2328 static char buff[64]; /* XXX */
2329
2330 switch (e_machine)
2331 {
2332 /* Please keep this switch table sorted by increasing EM_ value. */
2333 /* 0 */
2334 case EM_NONE: return _("None");
2335 case EM_M32: return "WE32100";
2336 case EM_SPARC: return "Sparc";
2337 case EM_386: return "Intel 80386";
2338 case EM_68K: return "MC68000";
2339 case EM_88K: return "MC88000";
2340 case EM_IAMCU: return "Intel MCU";
2341 case EM_860: return "Intel 80860";
2342 case EM_MIPS: return "MIPS R3000";
2343 case EM_S370: return "IBM System/370";
2344 /* 10 */
2345 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
2346 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
2347 case EM_PARISC: return "HPPA";
2348 case EM_VPP550: return "Fujitsu VPP500";
2349 case EM_SPARC32PLUS: return "Sparc v8+" ;
2350 case EM_960: return "Intel 80960";
2351 case EM_PPC: return "PowerPC";
2352 /* 20 */
2353 case EM_PPC64: return "PowerPC64";
2354 case EM_S390_OLD:
2355 case EM_S390: return "IBM S/390";
2356 case EM_SPU: return "SPU";
2357 /* 30 */
2358 case EM_V800: return "Renesas V850 (using RH850 ABI)";
2359 case EM_FR20: return "Fujitsu FR20";
2360 case EM_RH32: return "TRW RH32";
2361 case EM_MCORE: return "MCORE";
2362 /* 40 */
2363 case EM_ARM: return "ARM";
2364 case EM_OLD_ALPHA: return "Digital Alpha (old)";
2365 case EM_SH: return "Renesas / SuperH SH";
2366 case EM_SPARCV9: return "Sparc v9";
2367 case EM_TRICORE: return "Siemens Tricore";
2368 case EM_ARC: return "ARC";
2369 case EM_H8_300: return "Renesas H8/300";
2370 case EM_H8_300H: return "Renesas H8/300H";
2371 case EM_H8S: return "Renesas H8S";
2372 case EM_H8_500: return "Renesas H8/500";
2373 /* 50 */
2374 case EM_IA_64: return "Intel IA-64";
2375 case EM_MIPS_X: return "Stanford MIPS-X";
2376 case EM_COLDFIRE: return "Motorola Coldfire";
2377 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
2378 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2379 case EM_PCP: return "Siemens PCP";
2380 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2381 case EM_NDR1: return "Denso NDR1 microprocesspr";
2382 case EM_STARCORE: return "Motorola Star*Core processor";
2383 case EM_ME16: return "Toyota ME16 processor";
2384 /* 60 */
2385 case EM_ST100: return "STMicroelectronics ST100 processor";
2386 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
2387 case EM_X86_64: return "Advanced Micro Devices X86-64";
2388 case EM_PDSP: return "Sony DSP processor";
2389 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2390 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
2391 case EM_FX66: return "Siemens FX66 microcontroller";
2392 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2393 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2394 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
2395 /* 70 */
2396 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2397 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2398 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2399 case EM_SVX: return "Silicon Graphics SVx";
2400 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2401 case EM_VAX: return "Digital VAX";
2402 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
2403 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2404 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2405 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
2406 /* 80 */
2407 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
2408 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
2409 case EM_PRISM: return "Vitesse Prism";
2410 case EM_AVR_OLD:
2411 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
2412 case EM_CYGNUS_FR30:
2413 case EM_FR30: return "Fujitsu FR30";
2414 case EM_CYGNUS_D10V:
2415 case EM_D10V: return "d10v";
2416 case EM_CYGNUS_D30V:
2417 case EM_D30V: return "d30v";
2418 case EM_CYGNUS_V850:
2419 case EM_V850: return "Renesas V850";
2420 case EM_CYGNUS_M32R:
2421 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2422 case EM_CYGNUS_MN10300:
2423 case EM_MN10300: return "mn10300";
2424 /* 90 */
2425 case EM_CYGNUS_MN10200:
2426 case EM_MN10200: return "mn10200";
2427 case EM_PJ: return "picoJava";
2428 case EM_OR1K: return "OpenRISC 1000";
2429 case EM_ARC_COMPACT: return "ARCompact";
2430 case EM_XTENSA_OLD:
2431 case EM_XTENSA: return "Tensilica Xtensa Processor";
2432 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2433 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2434 case EM_NS32K: return "National Semiconductor 32000 series";
2435 case EM_TPC: return "Tenor Network TPC processor";
2436 case EM_SNP1K: return "Trebia SNP 1000 processor";
2437 /* 100 */
2438 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2439 case EM_IP2K_OLD:
2440 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
2441 case EM_MAX: return "MAX Processor";
2442 case EM_CR: return "National Semiconductor CompactRISC";
2443 case EM_F2MC16: return "Fujitsu F2MC16";
2444 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
2445 case EM_BLACKFIN: return "Analog Devices Blackfin";
2446 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2447 case EM_SEP: return "Sharp embedded microprocessor";
2448 case EM_ARCA: return "Arca RISC microprocessor";
2449 /* 110 */
2450 case EM_UNICORE: return "Unicore";
2451 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2452 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
2453 case EM_ALTERA_NIOS2: return "Altera Nios II";
2454 case EM_CRX: return "National Semiconductor CRX microprocessor";
2455 case EM_XGATE: return "Motorola XGATE embedded processor";
2456 case EM_C166:
2457 case EM_XC16X: return "Infineon Technologies xc16x";
2458 case EM_M16C: return "Renesas M16C series microprocessors";
2459 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2460 case EM_CE: return "Freescale Communication Engine RISC core";
2461 /* 120 */
2462 case EM_M32C: return "Renesas M32c";
2463 /* 130 */
2464 case EM_TSK3000: return "Altium TSK3000 core";
2465 case EM_RS08: return "Freescale RS08 embedded processor";
2466 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2467 case EM_SCORE: return "SUNPLUS S+Core";
2468 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2469 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2470 case EM_LATTICEMICO32: return "Lattice Mico32";
2471 case EM_SE_C17: return "Seiko Epson C17 family";
2472 /* 140 */
2473 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2474 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2475 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2476 case EM_TI_PRU: return "TI PRU I/O processor";
2477 /* 160 */
2478 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2479 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2480 case EM_R32C: return "Renesas R32C series microprocessors";
2481 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2482 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2483 case EM_8051: return "Intel 8051 and variants";
2484 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2485 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2486 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2487 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2488 /* 170 */
2489 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2490 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2491 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
2492 case EM_RX: return "Renesas RX";
2493 case EM_METAG: return "Imagination Technologies Meta processor architecture";
2494 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2495 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2496 case EM_CR16:
2497 case EM_MICROBLAZE:
2498 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
2499 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2500 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2501 /* 180 */
2502 case EM_L1OM: return "Intel L1OM";
2503 case EM_K1OM: return "Intel K1OM";
2504 case EM_INTEL182: return "Intel (reserved)";
2505 case EM_AARCH64: return "AArch64";
2506 case EM_ARM184: return "ARM (reserved)";
2507 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor";
2508 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2509 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2510 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
2511 /* 190 */
2512 case EM_CUDA: return "NVIDIA CUDA architecture";
2513 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
2514 case EM_CLOUDSHIELD: return "CloudShield architecture family";
2515 case EM_COREA_1ST: return "KIPO-KAIST Core-A 1st generation processor family";
2516 case EM_COREA_2ND: return "KIPO-KAIST Core-A 2nd generation processor family";
2517 case EM_ARC_COMPACT2: return "ARCv2";
2518 case EM_OPEN8: return "Open8 8-bit RISC soft processor core";
2519 case EM_RL78: return "Renesas RL78";
2520 case EM_VIDEOCORE5: return "Broadcom VideoCore V processor";
2521 case EM_78K0R: return "Renesas 78K0R";
2522 /* 200 */
2523 case EM_56800EX: return "Freescale 56800EX Digital Signal Controller (DSC)";
2524 case EM_BA1: return "Beyond BA1 CPU architecture";
2525 case EM_BA2: return "Beyond BA2 CPU architecture";
2526 case EM_XCORE: return "XMOS xCORE processor family";
2527 case EM_MCHP_PIC: return "Microchip 8-bit PIC(r) family";
2528 /* 210 */
2529 case EM_KM32: return "KM211 KM32 32-bit processor";
2530 case EM_KMX32: return "KM211 KMX32 32-bit processor";
2531 case EM_KMX16: return "KM211 KMX16 16-bit processor";
2532 case EM_KMX8: return "KM211 KMX8 8-bit processor";
2533 case EM_KVARC: return "KM211 KVARC processor";
2534 case EM_CDP: return "Paneve CDP architecture family";
2535 case EM_COGE: return "Cognitive Smart Memory Processor";
2536 case EM_COOL: return "Bluechip Systems CoolEngine";
2537 case EM_NORC: return "Nanoradio Optimized RISC";
2538 case EM_CSR_KALIMBA: return "CSR Kalimba architecture family";
2539 /* 220 */
2540 case EM_Z80: return "Zilog Z80";
2541 case EM_VISIUM: return "CDS VISIUMcore processor";
2542 case EM_FT32: return "FTDI Chip FT32";
2543 case EM_MOXIE: return "Moxie";
2544 case EM_AMDGPU: return "AMD GPU";
2545 case EM_RISCV: return "RISC-V";
2546 case EM_LANAI: return "Lanai 32-bit processor";
2547 case EM_BPF: return "Linux BPF";
2548 case EM_NFP: return "Netronome Flow Processor";
2549
2550 /* Large numbers... */
2551 case EM_MT: return "Morpho Techologies MT processor";
2552 case EM_ALPHA: return "Alpha";
2553 case EM_WEBASSEMBLY: return "Web Assembly";
2554 case EM_DLX: return "OpenDLX";
2555 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
2556 case EM_IQ2000: return "Vitesse IQ2000";
2557 case EM_M32C_OLD:
2558 case EM_NIOS32: return "Altera Nios";
2559 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
2560 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
2561 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2562 case EM_S12Z: return "Freescale S12Z";
2563 case EM_CSKY: return "C-SKY";
2564
2565 default:
2566 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2567 return buff;
2568 }
2569}
2570
2571static void
2572decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2573{
2574 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2575 other compilers don't a specific architecture type in the e_flags, and
2576 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2577 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2578 architectures.
2579
2580 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2581 but also sets a specific architecture type in the e_flags field.
2582
2583 However, when decoding the flags we don't worry if we see an
2584 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2585 ARCEM architecture type. */
2586
2587 switch (e_flags & EF_ARC_MACH_MSK)
2588 {
2589 /* We only expect these to occur for EM_ARC_COMPACT2. */
2590 case EF_ARC_CPU_ARCV2EM:
2591 strcat (buf, ", ARC EM");
2592 break;
2593 case EF_ARC_CPU_ARCV2HS:
2594 strcat (buf, ", ARC HS");
2595 break;
2596
2597 /* We only expect these to occur for EM_ARC_COMPACT. */
2598 case E_ARC_MACH_ARC600:
2599 strcat (buf, ", ARC600");
2600 break;
2601 case E_ARC_MACH_ARC601:
2602 strcat (buf, ", ARC601");
2603 break;
2604 case E_ARC_MACH_ARC700:
2605 strcat (buf, ", ARC700");
2606 break;
2607
2608 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2609 new ELF with new architecture being read by an old version of
2610 readelf, or (c) An ELF built with non-GNU compiler that does not
2611 set the architecture in the e_flags. */
2612 default:
2613 if (e_machine == EM_ARC_COMPACT)
2614 strcat (buf, ", Unknown ARCompact");
2615 else
2616 strcat (buf, ", Unknown ARC");
2617 break;
2618 }
2619
2620 switch (e_flags & EF_ARC_OSABI_MSK)
2621 {
2622 case E_ARC_OSABI_ORIG:
2623 strcat (buf, ", (ABI:legacy)");
2624 break;
2625 case E_ARC_OSABI_V2:
2626 strcat (buf, ", (ABI:v2)");
2627 break;
2628 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2629 case E_ARC_OSABI_V3:
2630 strcat (buf, ", v3 no-legacy-syscalls ABI");
2631 break;
2632 case E_ARC_OSABI_V4:
2633 strcat (buf, ", v4 ABI");
2634 break;
2635 default:
2636 strcat (buf, ", unrecognised ARC OSABI flag");
2637 break;
2638 }
2639}
2640
2641static void
2642decode_ARM_machine_flags (unsigned e_flags, char buf[])
2643{
2644 unsigned eabi;
2645 bfd_boolean unknown = FALSE;
2646
2647 eabi = EF_ARM_EABI_VERSION (e_flags);
2648 e_flags &= ~ EF_ARM_EABIMASK;
2649
2650 /* Handle "generic" ARM flags. */
2651 if (e_flags & EF_ARM_RELEXEC)
2652 {
2653 strcat (buf, ", relocatable executable");
2654 e_flags &= ~ EF_ARM_RELEXEC;
2655 }
2656
2657 if (e_flags & EF_ARM_PIC)
2658 {
2659 strcat (buf, ", position independent");
2660 e_flags &= ~ EF_ARM_PIC;
2661 }
2662
2663 /* Now handle EABI specific flags. */
2664 switch (eabi)
2665 {
2666 default:
2667 strcat (buf, ", <unrecognized EABI>");
2668 if (e_flags)
2669 unknown = TRUE;
2670 break;
2671
2672 case EF_ARM_EABI_VER1:
2673 strcat (buf, ", Version1 EABI");
2674 while (e_flags)
2675 {
2676 unsigned flag;
2677
2678 /* Process flags one bit at a time. */
2679 flag = e_flags & - e_flags;
2680 e_flags &= ~ flag;
2681
2682 switch (flag)
2683 {
2684 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2685 strcat (buf, ", sorted symbol tables");
2686 break;
2687
2688 default:
2689 unknown = TRUE;
2690 break;
2691 }
2692 }
2693 break;
2694
2695 case EF_ARM_EABI_VER2:
2696 strcat (buf, ", Version2 EABI");
2697 while (e_flags)
2698 {
2699 unsigned flag;
2700
2701 /* Process flags one bit at a time. */
2702 flag = e_flags & - e_flags;
2703 e_flags &= ~ flag;
2704
2705 switch (flag)
2706 {
2707 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2708 strcat (buf, ", sorted symbol tables");
2709 break;
2710
2711 case EF_ARM_DYNSYMSUSESEGIDX:
2712 strcat (buf, ", dynamic symbols use segment index");
2713 break;
2714
2715 case EF_ARM_MAPSYMSFIRST:
2716 strcat (buf, ", mapping symbols precede others");
2717 break;
2718
2719 default:
2720 unknown = TRUE;
2721 break;
2722 }
2723 }
2724 break;
2725
2726 case EF_ARM_EABI_VER3:
2727 strcat (buf, ", Version3 EABI");
2728 break;
2729
2730 case EF_ARM_EABI_VER4:
2731 strcat (buf, ", Version4 EABI");
2732 while (e_flags)
2733 {
2734 unsigned flag;
2735
2736 /* Process flags one bit at a time. */
2737 flag = e_flags & - e_flags;
2738 e_flags &= ~ flag;
2739
2740 switch (flag)
2741 {
2742 case EF_ARM_BE8:
2743 strcat (buf, ", BE8");
2744 break;
2745
2746 case EF_ARM_LE8:
2747 strcat (buf, ", LE8");
2748 break;
2749
2750 default:
2751 unknown = TRUE;
2752 break;
2753 }
2754 }
2755 break;
2756
2757 case EF_ARM_EABI_VER5:
2758 strcat (buf, ", Version5 EABI");
2759 while (e_flags)
2760 {
2761 unsigned flag;
2762
2763 /* Process flags one bit at a time. */
2764 flag = e_flags & - e_flags;
2765 e_flags &= ~ flag;
2766
2767 switch (flag)
2768 {
2769 case EF_ARM_BE8:
2770 strcat (buf, ", BE8");
2771 break;
2772
2773 case EF_ARM_LE8:
2774 strcat (buf, ", LE8");
2775 break;
2776
2777 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2778 strcat (buf, ", soft-float ABI");
2779 break;
2780
2781 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2782 strcat (buf, ", hard-float ABI");
2783 break;
2784
2785 default:
2786 unknown = TRUE;
2787 break;
2788 }
2789 }
2790 break;
2791
2792 case EF_ARM_EABI_UNKNOWN:
2793 strcat (buf, ", GNU EABI");
2794 while (e_flags)
2795 {
2796 unsigned flag;
2797
2798 /* Process flags one bit at a time. */
2799 flag = e_flags & - e_flags;
2800 e_flags &= ~ flag;
2801
2802 switch (flag)
2803 {
2804 case EF_ARM_INTERWORK:
2805 strcat (buf, ", interworking enabled");
2806 break;
2807
2808 case EF_ARM_APCS_26:
2809 strcat (buf, ", uses APCS/26");
2810 break;
2811
2812 case EF_ARM_APCS_FLOAT:
2813 strcat (buf, ", uses APCS/float");
2814 break;
2815
2816 case EF_ARM_PIC:
2817 strcat (buf, ", position independent");
2818 break;
2819
2820 case EF_ARM_ALIGN8:
2821 strcat (buf, ", 8 bit structure alignment");
2822 break;
2823
2824 case EF_ARM_NEW_ABI:
2825 strcat (buf, ", uses new ABI");
2826 break;
2827
2828 case EF_ARM_OLD_ABI:
2829 strcat (buf, ", uses old ABI");
2830 break;
2831
2832 case EF_ARM_SOFT_FLOAT:
2833 strcat (buf, ", software FP");
2834 break;
2835
2836 case EF_ARM_VFP_FLOAT:
2837 strcat (buf, ", VFP");
2838 break;
2839
2840 case EF_ARM_MAVERICK_FLOAT:
2841 strcat (buf, ", Maverick FP");
2842 break;
2843
2844 default:
2845 unknown = TRUE;
2846 break;
2847 }
2848 }
2849 }
2850
2851 if (unknown)
2852 strcat (buf,_(", <unknown>"));
2853}
2854
2855static void
2856decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2857{
2858 --size; /* Leave space for null terminator. */
2859
2860 switch (e_flags & EF_AVR_MACH)
2861 {
2862 case E_AVR_MACH_AVR1:
2863 strncat (buf, ", avr:1", size);
2864 break;
2865 case E_AVR_MACH_AVR2:
2866 strncat (buf, ", avr:2", size);
2867 break;
2868 case E_AVR_MACH_AVR25:
2869 strncat (buf, ", avr:25", size);
2870 break;
2871 case E_AVR_MACH_AVR3:
2872 strncat (buf, ", avr:3", size);
2873 break;
2874 case E_AVR_MACH_AVR31:
2875 strncat (buf, ", avr:31", size);
2876 break;
2877 case E_AVR_MACH_AVR35:
2878 strncat (buf, ", avr:35", size);
2879 break;
2880 case E_AVR_MACH_AVR4:
2881 strncat (buf, ", avr:4", size);
2882 break;
2883 case E_AVR_MACH_AVR5:
2884 strncat (buf, ", avr:5", size);
2885 break;
2886 case E_AVR_MACH_AVR51:
2887 strncat (buf, ", avr:51", size);
2888 break;
2889 case E_AVR_MACH_AVR6:
2890 strncat (buf, ", avr:6", size);
2891 break;
2892 case E_AVR_MACH_AVRTINY:
2893 strncat (buf, ", avr:100", size);
2894 break;
2895 case E_AVR_MACH_XMEGA1:
2896 strncat (buf, ", avr:101", size);
2897 break;
2898 case E_AVR_MACH_XMEGA2:
2899 strncat (buf, ", avr:102", size);
2900 break;
2901 case E_AVR_MACH_XMEGA3:
2902 strncat (buf, ", avr:103", size);
2903 break;
2904 case E_AVR_MACH_XMEGA4:
2905 strncat (buf, ", avr:104", size);
2906 break;
2907 case E_AVR_MACH_XMEGA5:
2908 strncat (buf, ", avr:105", size);
2909 break;
2910 case E_AVR_MACH_XMEGA6:
2911 strncat (buf, ", avr:106", size);
2912 break;
2913 case E_AVR_MACH_XMEGA7:
2914 strncat (buf, ", avr:107", size);
2915 break;
2916 default:
2917 strncat (buf, ", avr:<unknown>", size);
2918 break;
2919 }
2920
2921 size -= strlen (buf);
2922 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2923 strncat (buf, ", link-relax", size);
2924}
2925
2926static void
2927decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2928{
2929 unsigned abi;
2930 unsigned arch;
2931 unsigned config;
2932 unsigned version;
2933 bfd_boolean has_fpu = FALSE;
2934 unsigned int r = 0;
2935
2936 static const char *ABI_STRINGS[] =
2937 {
2938 "ABI v0", /* use r5 as return register; only used in N1213HC */
2939 "ABI v1", /* use r0 as return register */
2940 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2941 "ABI v2fp", /* for FPU */
2942 "AABI",
2943 "ABI2 FP+"
2944 };
2945 static const char *VER_STRINGS[] =
2946 {
2947 "Andes ELF V1.3 or older",
2948 "Andes ELF V1.3.1",
2949 "Andes ELF V1.4"
2950 };
2951 static const char *ARCH_STRINGS[] =
2952 {
2953 "",
2954 "Andes Star v1.0",
2955 "Andes Star v2.0",
2956 "Andes Star v3.0",
2957 "Andes Star v3.0m"
2958 };
2959
2960 abi = EF_NDS_ABI & e_flags;
2961 arch = EF_NDS_ARCH & e_flags;
2962 config = EF_NDS_INST & e_flags;
2963 version = EF_NDS32_ELF_VERSION & e_flags;
2964
2965 memset (buf, 0, size);
2966
2967 switch (abi)
2968 {
2969 case E_NDS_ABI_V0:
2970 case E_NDS_ABI_V1:
2971 case E_NDS_ABI_V2:
2972 case E_NDS_ABI_V2FP:
2973 case E_NDS_ABI_AABI:
2974 case E_NDS_ABI_V2FP_PLUS:
2975 /* In case there are holes in the array. */
2976 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2977 break;
2978
2979 default:
2980 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2981 break;
2982 }
2983
2984 switch (version)
2985 {
2986 case E_NDS32_ELF_VER_1_2:
2987 case E_NDS32_ELF_VER_1_3:
2988 case E_NDS32_ELF_VER_1_4:
2989 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2990 break;
2991
2992 default:
2993 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2994 break;
2995 }
2996
2997 if (E_NDS_ABI_V0 == abi)
2998 {
2999 /* OLD ABI; only used in N1213HC, has performance extension 1. */
3000 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
3001 if (arch == E_NDS_ARCH_STAR_V1_0)
3002 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
3003 return;
3004 }
3005
3006 switch (arch)
3007 {
3008 case E_NDS_ARCH_STAR_V1_0:
3009 case E_NDS_ARCH_STAR_V2_0:
3010 case E_NDS_ARCH_STAR_V3_0:
3011 case E_NDS_ARCH_STAR_V3_M:
3012 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
3013 break;
3014
3015 default:
3016 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
3017 /* ARCH version determines how the e_flags are interpreted.
3018 If it is unknown, we cannot proceed. */
3019 return;
3020 }
3021
3022 /* Newer ABI; Now handle architecture specific flags. */
3023 if (arch == E_NDS_ARCH_STAR_V1_0)
3024 {
3025 if (config & E_NDS32_HAS_MFUSR_PC_INST)
3026 r += snprintf (buf + r, size -r, ", MFUSR_PC");
3027
3028 if (!(config & E_NDS32_HAS_NO_MAC_INST))
3029 r += snprintf (buf + r, size -r, ", MAC");
3030
3031 if (config & E_NDS32_HAS_DIV_INST)
3032 r += snprintf (buf + r, size -r, ", DIV");
3033
3034 if (config & E_NDS32_HAS_16BIT_INST)
3035 r += snprintf (buf + r, size -r, ", 16b");
3036 }
3037 else
3038 {
3039 if (config & E_NDS32_HAS_MFUSR_PC_INST)
3040 {
3041 if (version <= E_NDS32_ELF_VER_1_3)
3042 r += snprintf (buf + r, size -r, ", [B8]");
3043 else
3044 r += snprintf (buf + r, size -r, ", EX9");
3045 }
3046
3047 if (config & E_NDS32_HAS_MAC_DX_INST)
3048 r += snprintf (buf + r, size -r, ", MAC_DX");
3049
3050 if (config & E_NDS32_HAS_DIV_DX_INST)
3051 r += snprintf (buf + r, size -r, ", DIV_DX");
3052
3053 if (config & E_NDS32_HAS_16BIT_INST)
3054 {
3055 if (version <= E_NDS32_ELF_VER_1_3)
3056 r += snprintf (buf + r, size -r, ", 16b");
3057 else
3058 r += snprintf (buf + r, size -r, ", IFC");
3059 }
3060 }
3061
3062 if (config & E_NDS32_HAS_EXT_INST)
3063 r += snprintf (buf + r, size -r, ", PERF1");
3064
3065 if (config & E_NDS32_HAS_EXT2_INST)
3066 r += snprintf (buf + r, size -r, ", PERF2");
3067
3068 if (config & E_NDS32_HAS_FPU_INST)
3069 {
3070 has_fpu = TRUE;
3071 r += snprintf (buf + r, size -r, ", FPU_SP");
3072 }
3073
3074 if (config & E_NDS32_HAS_FPU_DP_INST)
3075 {
3076 has_fpu = TRUE;
3077 r += snprintf (buf + r, size -r, ", FPU_DP");
3078 }
3079
3080 if (config & E_NDS32_HAS_FPU_MAC_INST)
3081 {
3082 has_fpu = TRUE;
3083 r += snprintf (buf + r, size -r, ", FPU_MAC");
3084 }
3085
3086 if (has_fpu)
3087 {
3088 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
3089 {
3090 case E_NDS32_FPU_REG_8SP_4DP:
3091 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
3092 break;
3093 case E_NDS32_FPU_REG_16SP_8DP:
3094 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
3095 break;
3096 case E_NDS32_FPU_REG_32SP_16DP:
3097 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
3098 break;
3099 case E_NDS32_FPU_REG_32SP_32DP:
3100 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
3101 break;
3102 }
3103 }
3104
3105 if (config & E_NDS32_HAS_AUDIO_INST)
3106 r += snprintf (buf + r, size -r, ", AUDIO");
3107
3108 if (config & E_NDS32_HAS_STRING_INST)
3109 r += snprintf (buf + r, size -r, ", STR");
3110
3111 if (config & E_NDS32_HAS_REDUCED_REGS)
3112 r += snprintf (buf + r, size -r, ", 16REG");
3113
3114 if (config & E_NDS32_HAS_VIDEO_INST)
3115 {
3116 if (version <= E_NDS32_ELF_VER_1_3)
3117 r += snprintf (buf + r, size -r, ", VIDEO");
3118 else
3119 r += snprintf (buf + r, size -r, ", SATURATION");
3120 }
3121
3122 if (config & E_NDS32_HAS_ENCRIPT_INST)
3123 r += snprintf (buf + r, size -r, ", ENCRP");
3124
3125 if (config & E_NDS32_HAS_L2C_INST)
3126 r += snprintf (buf + r, size -r, ", L2C");
3127}
3128
3129static char *
3130get_machine_flags (Filedata * filedata, unsigned e_flags, unsigned e_machine)
3131{
3132 static char buf[1024];
3133
3134 buf[0] = '\0';
3135
3136 if (e_flags)
3137 {
3138 switch (e_machine)
3139 {
3140 default:
3141 break;
3142
3143 case EM_ARC_COMPACT2:
3144 case EM_ARC_COMPACT:
3145 decode_ARC_machine_flags (e_flags, e_machine, buf);
3146 break;
3147
3148 case EM_ARM:
3149 decode_ARM_machine_flags (e_flags, buf);
3150 break;
3151
3152 case EM_AVR:
3153 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
3154 break;
3155
3156 case EM_BLACKFIN:
3157 if (e_flags & EF_BFIN_PIC)
3158 strcat (buf, ", PIC");
3159
3160 if (e_flags & EF_BFIN_FDPIC)
3161 strcat (buf, ", FDPIC");
3162
3163 if (e_flags & EF_BFIN_CODE_IN_L1)
3164 strcat (buf, ", code in L1");
3165
3166 if (e_flags & EF_BFIN_DATA_IN_L1)
3167 strcat (buf, ", data in L1");
3168
3169 break;
3170
3171 case EM_CYGNUS_FRV:
3172 switch (e_flags & EF_FRV_CPU_MASK)
3173 {
3174 case EF_FRV_CPU_GENERIC:
3175 break;
3176
3177 default:
3178 strcat (buf, ", fr???");
3179 break;
3180
3181 case EF_FRV_CPU_FR300:
3182 strcat (buf, ", fr300");
3183 break;
3184
3185 case EF_FRV_CPU_FR400:
3186 strcat (buf, ", fr400");
3187 break;
3188 case EF_FRV_CPU_FR405:
3189 strcat (buf, ", fr405");
3190 break;
3191
3192 case EF_FRV_CPU_FR450:
3193 strcat (buf, ", fr450");
3194 break;
3195
3196 case EF_FRV_CPU_FR500:
3197 strcat (buf, ", fr500");
3198 break;
3199 case EF_FRV_CPU_FR550:
3200 strcat (buf, ", fr550");
3201 break;
3202
3203 case EF_FRV_CPU_SIMPLE:
3204 strcat (buf, ", simple");
3205 break;
3206 case EF_FRV_CPU_TOMCAT:
3207 strcat (buf, ", tomcat");
3208 break;
3209 }
3210 break;
3211
3212 case EM_68K:
3213 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
3214 strcat (buf, ", m68000");
3215 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3216 strcat (buf, ", cpu32");
3217 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3218 strcat (buf, ", fido_a");
3219 else
3220 {
3221 char const * isa = _("unknown");
3222 char const * mac = _("unknown mac");
3223 char const * additional = NULL;
3224
3225 switch (e_flags & EF_M68K_CF_ISA_MASK)
3226 {
3227 case EF_M68K_CF_ISA_A_NODIV:
3228 isa = "A";
3229 additional = ", nodiv";
3230 break;
3231 case EF_M68K_CF_ISA_A:
3232 isa = "A";
3233 break;
3234 case EF_M68K_CF_ISA_A_PLUS:
3235 isa = "A+";
3236 break;
3237 case EF_M68K_CF_ISA_B_NOUSP:
3238 isa = "B";
3239 additional = ", nousp";
3240 break;
3241 case EF_M68K_CF_ISA_B:
3242 isa = "B";
3243 break;
3244 case EF_M68K_CF_ISA_C:
3245 isa = "C";
3246 break;
3247 case EF_M68K_CF_ISA_C_NODIV:
3248 isa = "C";
3249 additional = ", nodiv";
3250 break;
3251 }
3252 strcat (buf, ", cf, isa ");
3253 strcat (buf, isa);
3254 if (additional)
3255 strcat (buf, additional);
3256 if (e_flags & EF_M68K_CF_FLOAT)
3257 strcat (buf, ", float");
3258 switch (e_flags & EF_M68K_CF_MAC_MASK)
3259 {
3260 case 0:
3261 mac = NULL;
3262 break;
3263 case EF_M68K_CF_MAC:
3264 mac = "mac";
3265 break;
3266 case EF_M68K_CF_EMAC:
3267 mac = "emac";
3268 break;
3269 case EF_M68K_CF_EMAC_B:
3270 mac = "emac_b";
3271 break;
3272 }
3273 if (mac)
3274 {
3275 strcat (buf, ", ");
3276 strcat (buf, mac);
3277 }
3278 }
3279 break;
3280
3281 case EM_CYGNUS_MEP:
3282 switch (e_flags & EF_MEP_CPU_MASK)
3283 {
3284 case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3285 case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3286 case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3287 case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3288 case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3289 case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3290 default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3291 }
3292
3293 switch (e_flags & EF_MEP_COP_MASK)
3294 {
3295 case EF_MEP_COP_NONE: break;
3296 case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3297 case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3298 case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3299 case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3300 default: strcat (buf, _("<unknown MeP copro type>")); break;
3301 }
3302
3303 if (e_flags & EF_MEP_LIBRARY)
3304 strcat (buf, ", Built for Library");
3305
3306 if (e_flags & EF_MEP_INDEX_MASK)
3307 sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3308 e_flags & EF_MEP_INDEX_MASK);
3309
3310 if (e_flags & ~ EF_MEP_ALL_FLAGS)
3311 sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3312 e_flags & ~ EF_MEP_ALL_FLAGS);
3313 break;
3314
3315 case EM_PPC:
3316 if (e_flags & EF_PPC_EMB)
3317 strcat (buf, ", emb");
3318
3319 if (e_flags & EF_PPC_RELOCATABLE)
3320 strcat (buf, _(", relocatable"));
3321
3322 if (e_flags & EF_PPC_RELOCATABLE_LIB)
3323 strcat (buf, _(", relocatable-lib"));
3324 break;
3325
3326 case EM_PPC64:
3327 if (e_flags & EF_PPC64_ABI)
3328 {
3329 char abi[] = ", abiv0";
3330
3331 abi[6] += e_flags & EF_PPC64_ABI;
3332 strcat (buf, abi);
3333 }
3334 break;
3335
3336 case EM_V800:
3337 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3338 strcat (buf, ", RH850 ABI");
3339
3340 if (e_flags & EF_V800_850E3)
3341 strcat (buf, ", V3 architecture");
3342
3343 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3344 strcat (buf, ", FPU not used");
3345
3346 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3347 strcat (buf, ", regmode: COMMON");
3348
3349 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3350 strcat (buf, ", r4 not used");
3351
3352 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3353 strcat (buf, ", r30 not used");
3354
3355 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3356 strcat (buf, ", r5 not used");
3357
3358 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3359 strcat (buf, ", r2 not used");
3360
3361 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3362 {
3363 switch (e_flags & - e_flags)
3364 {
3365 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3366 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3367 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3368 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3369 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3370 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3371 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3372 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3373 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3374 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3375 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3376 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3377 default: break;
3378 }
3379 }
3380 break;
3381
3382 case EM_V850:
3383 case EM_CYGNUS_V850:
3384 switch (e_flags & EF_V850_ARCH)
3385 {
3386 case E_V850E3V5_ARCH:
3387 strcat (buf, ", v850e3v5");
3388 break;
3389 case E_V850E2V3_ARCH:
3390 strcat (buf, ", v850e2v3");
3391 break;
3392 case E_V850E2_ARCH:
3393 strcat (buf, ", v850e2");
3394 break;
3395 case E_V850E1_ARCH:
3396 strcat (buf, ", v850e1");
3397 break;
3398 case E_V850E_ARCH:
3399 strcat (buf, ", v850e");
3400 break;
3401 case E_V850_ARCH:
3402 strcat (buf, ", v850");
3403 break;
3404 default:
3405 strcat (buf, _(", unknown v850 architecture variant"));
3406 break;
3407 }
3408 break;
3409
3410 case EM_M32R:
3411 case EM_CYGNUS_M32R:
3412 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3413 strcat (buf, ", m32r");
3414 break;
3415
3416 case EM_MIPS:
3417 case EM_MIPS_RS3_LE:
3418 if (e_flags & EF_MIPS_NOREORDER)
3419 strcat (buf, ", noreorder");
3420
3421 if (e_flags & EF_MIPS_PIC)
3422 strcat (buf, ", pic");
3423
3424 if (e_flags & EF_MIPS_CPIC)
3425 strcat (buf, ", cpic");
3426
3427 if (e_flags & EF_MIPS_UCODE)
3428 strcat (buf, ", ugen_reserved");
3429
3430 if (e_flags & EF_MIPS_ABI2)
3431 strcat (buf, ", abi2");
3432
3433 if (e_flags & EF_MIPS_OPTIONS_FIRST)
3434 strcat (buf, ", odk first");
3435
3436 if (e_flags & EF_MIPS_32BITMODE)
3437 strcat (buf, ", 32bitmode");
3438
3439 if (e_flags & EF_MIPS_NAN2008)
3440 strcat (buf, ", nan2008");
3441
3442 if (e_flags & EF_MIPS_FP64)
3443 strcat (buf, ", fp64");
3444
3445 switch ((e_flags & EF_MIPS_MACH))
3446 {
3447 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3448 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3449 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3450 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3451 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3452 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3453 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3454 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3455 case E_MIPS_MACH_5900: strcat (buf, ", 5900"); break;
3456 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
3457 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3458 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3459 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3460 case E_MIPS_MACH_GS464: strcat (buf, ", gs464"); break;
3461 case E_MIPS_MACH_GS464E: strcat (buf, ", gs464e"); break;
3462 case E_MIPS_MACH_GS264E: strcat (buf, ", gs264e"); break;
3463 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3464 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3465 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3466 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
3467 case E_MIPS_MACH_IAMR2: strcat (buf, ", interaptiv-mr2"); break;
3468 case 0:
3469 /* We simply ignore the field in this case to avoid confusion:
3470 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3471 extension. */
3472 break;
3473 default: strcat (buf, _(", unknown CPU")); break;
3474 }
3475
3476 switch ((e_flags & EF_MIPS_ABI))
3477 {
3478 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3479 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3480 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3481 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3482 case 0:
3483 /* We simply ignore the field in this case to avoid confusion:
3484 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3485 This means it is likely to be an o32 file, but not for
3486 sure. */
3487 break;
3488 default: strcat (buf, _(", unknown ABI")); break;
3489 }
3490
3491 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3492 strcat (buf, ", mdmx");
3493
3494 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3495 strcat (buf, ", mips16");
3496
3497 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3498 strcat (buf, ", micromips");
3499
3500 switch ((e_flags & EF_MIPS_ARCH))
3501 {
3502 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3503 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3504 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3505 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3506 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3507 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3508 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3509 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3510 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3511 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3512 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3513 default: strcat (buf, _(", unknown ISA")); break;
3514 }
3515 break;
3516
3517 case EM_NDS32:
3518 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3519 break;
3520
3521 case EM_NFP:
3522 switch (EF_NFP_MACH (e_flags))
3523 {
3524 case E_NFP_MACH_3200:
3525 strcat (buf, ", NFP-32xx");
3526 break;
3527 case E_NFP_MACH_6000:
3528 strcat (buf, ", NFP-6xxx");
3529 break;
3530 }
3531 break;
3532
3533 case EM_RISCV:
3534 if (e_flags & EF_RISCV_RVC)
3535 strcat (buf, ", RVC");
3536
3537 if (e_flags & EF_RISCV_RVE)
3538 strcat (buf, ", RVE");
3539
3540 switch (e_flags & EF_RISCV_FLOAT_ABI)
3541 {
3542 case EF_RISCV_FLOAT_ABI_SOFT:
3543 strcat (buf, ", soft-float ABI");
3544 break;
3545
3546 case EF_RISCV_FLOAT_ABI_SINGLE:
3547 strcat (buf, ", single-float ABI");
3548 break;
3549
3550 case EF_RISCV_FLOAT_ABI_DOUBLE:
3551 strcat (buf, ", double-float ABI");
3552 break;
3553
3554 case EF_RISCV_FLOAT_ABI_QUAD:
3555 strcat (buf, ", quad-float ABI");
3556 break;
3557 }
3558 break;
3559
3560 case EM_SH:
3561 switch ((e_flags & EF_SH_MACH_MASK))
3562 {
3563 case EF_SH1: strcat (buf, ", sh1"); break;
3564 case EF_SH2: strcat (buf, ", sh2"); break;
3565 case EF_SH3: strcat (buf, ", sh3"); break;
3566 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3567 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3568 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3569 case EF_SH3E: strcat (buf, ", sh3e"); break;
3570 case EF_SH4: strcat (buf, ", sh4"); break;
3571 case EF_SH5: strcat (buf, ", sh5"); break;
3572 case EF_SH2E: strcat (buf, ", sh2e"); break;
3573 case EF_SH4A: strcat (buf, ", sh4a"); break;
3574 case EF_SH2A: strcat (buf, ", sh2a"); break;
3575 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3576 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3577 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3578 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3579 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3580 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3581 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3582 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3583 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3584 default: strcat (buf, _(", unknown ISA")); break;
3585 }
3586
3587 if (e_flags & EF_SH_PIC)
3588 strcat (buf, ", pic");
3589
3590 if (e_flags & EF_SH_FDPIC)
3591 strcat (buf, ", fdpic");
3592 break;
3593
3594 case EM_OR1K:
3595 if (e_flags & EF_OR1K_NODELAY)
3596 strcat (buf, ", no delay");
3597 break;
3598
3599 case EM_SPARCV9:
3600 if (e_flags & EF_SPARC_32PLUS)
3601 strcat (buf, ", v8+");
3602
3603 if (e_flags & EF_SPARC_SUN_US1)
3604 strcat (buf, ", ultrasparcI");
3605
3606 if (e_flags & EF_SPARC_SUN_US3)
3607 strcat (buf, ", ultrasparcIII");
3608
3609 if (e_flags & EF_SPARC_HAL_R1)
3610 strcat (buf, ", halr1");
3611
3612 if (e_flags & EF_SPARC_LEDATA)
3613 strcat (buf, ", ledata");
3614
3615 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3616 strcat (buf, ", tso");
3617
3618 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3619 strcat (buf, ", pso");
3620
3621 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3622 strcat (buf, ", rmo");
3623 break;
3624
3625 case EM_PARISC:
3626 switch (e_flags & EF_PARISC_ARCH)
3627 {
3628 case EFA_PARISC_1_0:
3629 strcpy (buf, ", PA-RISC 1.0");
3630 break;
3631 case EFA_PARISC_1_1:
3632 strcpy (buf, ", PA-RISC 1.1");
3633 break;
3634 case EFA_PARISC_2_0:
3635 strcpy (buf, ", PA-RISC 2.0");
3636 break;
3637 default:
3638 break;
3639 }
3640 if (e_flags & EF_PARISC_TRAPNIL)
3641 strcat (buf, ", trapnil");
3642 if (e_flags & EF_PARISC_EXT)
3643 strcat (buf, ", ext");
3644 if (e_flags & EF_PARISC_LSB)
3645 strcat (buf, ", lsb");
3646 if (e_flags & EF_PARISC_WIDE)
3647 strcat (buf, ", wide");
3648 if (e_flags & EF_PARISC_NO_KABP)
3649 strcat (buf, ", no kabp");
3650 if (e_flags & EF_PARISC_LAZYSWAP)
3651 strcat (buf, ", lazyswap");
3652 break;
3653
3654 case EM_PJ:
3655 case EM_PJ_OLD:
3656 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3657 strcat (buf, ", new calling convention");
3658
3659 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3660 strcat (buf, ", gnu calling convention");
3661 break;
3662
3663 case EM_IA_64:
3664 if ((e_flags & EF_IA_64_ABI64))
3665 strcat (buf, ", 64-bit");
3666 else
3667 strcat (buf, ", 32-bit");
3668 if ((e_flags & EF_IA_64_REDUCEDFP))
3669 strcat (buf, ", reduced fp model");
3670 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3671 strcat (buf, ", no function descriptors, constant gp");
3672 else if ((e_flags & EF_IA_64_CONS_GP))
3673 strcat (buf, ", constant gp");
3674 if ((e_flags & EF_IA_64_ABSOLUTE))
3675 strcat (buf, ", absolute");
3676 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3677 {
3678 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3679 strcat (buf, ", vms_linkages");
3680 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3681 {
3682 case EF_IA_64_VMS_COMCOD_SUCCESS:
3683 break;
3684 case EF_IA_64_VMS_COMCOD_WARNING:
3685 strcat (buf, ", warning");
3686 break;
3687 case EF_IA_64_VMS_COMCOD_ERROR:
3688 strcat (buf, ", error");
3689 break;
3690 case EF_IA_64_VMS_COMCOD_ABORT:
3691 strcat (buf, ", abort");
3692 break;
3693 default:
3694 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3695 e_flags & EF_IA_64_VMS_COMCOD);
3696 strcat (buf, ", <unknown>");
3697 }
3698 }
3699 break;
3700
3701 case EM_VAX:
3702 if ((e_flags & EF_VAX_NONPIC))
3703 strcat (buf, ", non-PIC");
3704 if ((e_flags & EF_VAX_DFLOAT))
3705 strcat (buf, ", D-Float");
3706 if ((e_flags & EF_VAX_GFLOAT))
3707 strcat (buf, ", G-Float");
3708 break;
3709
3710 case EM_VISIUM:
3711 if (e_flags & EF_VISIUM_ARCH_MCM)
3712 strcat (buf, ", mcm");
3713 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3714 strcat (buf, ", mcm24");
3715 if (e_flags & EF_VISIUM_ARCH_GR6)
3716 strcat (buf, ", gr6");
3717 break;
3718
3719 case EM_RL78:
3720 switch (e_flags & E_FLAG_RL78_CPU_MASK)
3721 {
3722 case E_FLAG_RL78_ANY_CPU: break;
3723 case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3724 case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3725 case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3726 }
3727 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3728 strcat (buf, ", 64-bit doubles");
3729 break;
3730
3731 case EM_RX:
3732 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3733 strcat (buf, ", 64-bit doubles");
3734 if (e_flags & E_FLAG_RX_DSP)
3735 strcat (buf, ", dsp");
3736 if (e_flags & E_FLAG_RX_PID)
3737 strcat (buf, ", pid");
3738 if (e_flags & E_FLAG_RX_ABI)
3739 strcat (buf, ", RX ABI");
3740 if (e_flags & E_FLAG_RX_SINSNS_SET)
3741 strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3742 ? ", uses String instructions" : ", bans String instructions");
3743 if (e_flags & E_FLAG_RX_V2)
3744 strcat (buf, ", V2");
3745 if (e_flags & E_FLAG_RX_V3)
3746 strcat (buf, ", V3");
3747 break;
3748
3749 case EM_S390:
3750 if (e_flags & EF_S390_HIGH_GPRS)
3751 strcat (buf, ", highgprs");
3752 break;
3753
3754 case EM_TI_C6000:
3755 if ((e_flags & EF_C6000_REL))
3756 strcat (buf, ", relocatable module");
3757 break;
3758
3759 case EM_MSP430:
3760 strcat (buf, _(": architecture variant: "));
3761 switch (e_flags & EF_MSP430_MACH)
3762 {
3763 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3764 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3765 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3766 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3767 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3768 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3769 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3770 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3771 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3772 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3773 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3774 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3775 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3776 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3777 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3778 default:
3779 strcat (buf, _(": unknown")); break;
3780 }
3781
3782 if (e_flags & ~ EF_MSP430_MACH)
3783 strcat (buf, _(": unknown extra flag bits also present"));
3784 break;
3785
3786 case EM_Z80:
3787 switch (e_flags & EF_Z80_MACH_MSK)
3788 {
3789 case EF_Z80_MACH_Z80: strcat (buf, ", Z80"); break;
3790 case EF_Z80_MACH_Z180: strcat (buf, ", Z180"); break;
3791 case EF_Z80_MACH_R800: strcat (buf, ", R800"); break;
3792 case EF_Z80_MACH_EZ80_Z80: strcat (buf, ", EZ80"); break;
3793 case EF_Z80_MACH_EZ80_ADL: strcat (buf, ", EZ80, ADL"); break;
3794 case EF_Z80_MACH_GBZ80: strcat (buf, ", GBZ80"); break;
3795 case EF_Z80_MACH_Z80N: strcat (buf, ", Z80N"); break;
3796 default:
3797 strcat (buf, _(", unknown")); break;
3798 }
3799 break;
3800 }
3801 }
3802
3803 return buf;
3804}
3805
3806static const char *
3807get_osabi_name (Filedata * filedata, unsigned int osabi)
3808{
3809 static char buff[32];
3810
3811 switch (osabi)
3812 {
3813 case ELFOSABI_NONE: return "UNIX - System V";
3814 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3815 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
3816 case ELFOSABI_GNU: return "UNIX - GNU";
3817 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3818 case ELFOSABI_AIX: return "UNIX - AIX";
3819 case ELFOSABI_IRIX: return "UNIX - IRIX";
3820 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3821 case ELFOSABI_TRU64: return "UNIX - TRU64";
3822 case ELFOSABI_MODESTO: return "Novell - Modesto";
3823 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3824 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3825 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3826 case ELFOSABI_AROS: return "AROS";
3827 case ELFOSABI_FENIXOS: return "FenixOS";
3828 case ELFOSABI_CLOUDABI: return "Nuxi CloudABI";
3829 case ELFOSABI_OPENVOS: return "Stratus Technologies OpenVOS";
3830 default:
3831 if (osabi >= 64)
3832 switch (filedata->file_header.e_machine)
3833 {
3834 case EM_ARM:
3835 switch (osabi)
3836 {
3837 case ELFOSABI_ARM: return "ARM";
3838 case ELFOSABI_ARM_FDPIC: return "ARM FDPIC";
3839 default:
3840 break;
3841 }
3842 break;
3843
3844 case EM_MSP430:
3845 case EM_MSP430_OLD:
3846 case EM_VISIUM:
3847 switch (osabi)
3848 {
3849 case ELFOSABI_STANDALONE: return _("Standalone App");
3850 default:
3851 break;
3852 }
3853 break;
3854
3855 case EM_TI_C6000:
3856 switch (osabi)
3857 {
3858 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3859 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3860 default:
3861 break;
3862 }
3863 break;
3864
3865 default:
3866 break;
3867 }
3868 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3869 return buff;
3870 }
3871}
3872
3873static const char *
3874get_aarch64_segment_type (unsigned long type)
3875{
3876 switch (type)
3877 {
3878 case PT_AARCH64_ARCHEXT: return "AARCH64_ARCHEXT";
3879 default: return NULL;
3880 }
3881}
3882
3883static const char *
3884get_arm_segment_type (unsigned long type)
3885{
3886 switch (type)
3887 {
3888 case PT_ARM_EXIDX: return "EXIDX";
3889 default: return NULL;
3890 }
3891}
3892
3893static const char *
3894get_s390_segment_type (unsigned long type)
3895{
3896 switch (type)
3897 {
3898 case PT_S390_PGSTE: return "S390_PGSTE";
3899 default: return NULL;
3900 }
3901}
3902
3903static const char *
3904get_mips_segment_type (unsigned long type)
3905{
3906 switch (type)
3907 {
3908 case PT_MIPS_REGINFO: return "REGINFO";
3909 case PT_MIPS_RTPROC: return "RTPROC";
3910 case PT_MIPS_OPTIONS: return "OPTIONS";
3911 case PT_MIPS_ABIFLAGS: return "ABIFLAGS";
3912 default: return NULL;
3913 }
3914}
3915
3916static const char *
3917get_parisc_segment_type (unsigned long type)
3918{
3919 switch (type)
3920 {
3921 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3922 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
3923 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
3924 default: return NULL;
3925 }
3926}
3927
3928static const char *
3929get_ia64_segment_type (unsigned long type)
3930{
3931 switch (type)
3932 {
3933 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3934 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
3935 default: return NULL;
3936 }
3937}
3938
3939static const char *
3940get_tic6x_segment_type (unsigned long type)
3941{
3942 switch (type)
3943 {
3944 case PT_C6000_PHATTR: return "C6000_PHATTR";
3945 default: return NULL;
3946 }
3947}
3948
3949static const char *
3950get_hpux_segment_type (unsigned long type, unsigned e_machine)
3951{
3952 if (e_machine == EM_PARISC)
3953 switch (type)
3954 {
3955 case PT_HP_TLS: return "HP_TLS";
3956 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3957 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3958 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3959 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3960 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3961 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3962 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3963 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3964 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3965 case PT_HP_PARALLEL: return "HP_PARALLEL";
3966 case PT_HP_FASTBIND: return "HP_FASTBIND";
3967 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3968 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3969 case PT_HP_STACK: return "HP_STACK";
3970 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
3971 default: return NULL;
3972 }
3973
3974 if (e_machine == EM_IA_64)
3975 switch (type)
3976 {
3977 case PT_HP_TLS: return "HP_TLS";
3978 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3979 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3980 case PT_IA_64_HP_STACK: return "HP_STACK";
3981 default: return NULL;
3982 }
3983
3984 return NULL;
3985}
3986
3987static const char *
3988get_solaris_segment_type (unsigned long type)
3989{
3990 switch (type)
3991 {
3992 case 0x6464e550: return "PT_SUNW_UNWIND";
3993 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3994 case 0x6ffffff7: return "PT_LOSUNW";
3995 case 0x6ffffffa: return "PT_SUNWBSS";
3996 case 0x6ffffffb: return "PT_SUNWSTACK";
3997 case 0x6ffffffc: return "PT_SUNWDTRACE";
3998 case 0x6ffffffd: return "PT_SUNWCAP";
3999 case 0x6fffffff: return "PT_HISUNW";
4000 default: return NULL;
4001 }
4002}
4003
4004static const char *
4005get_segment_type (Filedata * filedata, unsigned long p_type)
4006{
4007 static char buff[32];
4008
4009 switch (p_type)
4010 {
4011 case PT_NULL: return "NULL";
4012 case PT_LOAD: return "LOAD";
4013 case PT_DYNAMIC: return "DYNAMIC";
4014 case PT_INTERP: return "INTERP";
4015 case PT_NOTE: return "NOTE";
4016 case PT_SHLIB: return "SHLIB";
4017 case PT_PHDR: return "PHDR";
4018 case PT_TLS: return "TLS";
4019 case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
4020 case PT_GNU_STACK: return "GNU_STACK";
4021 case PT_GNU_RELRO: return "GNU_RELRO";
4022 case PT_GNU_PROPERTY: return "GNU_PROPERTY";
4023
4024 default:
4025 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
4026 {
4027 const char * result;
4028
4029 switch (filedata->file_header.e_machine)
4030 {
4031 case EM_AARCH64:
4032 result = get_aarch64_segment_type (p_type);
4033 break;
4034 case EM_ARM:
4035 result = get_arm_segment_type (p_type);
4036 break;
4037 case EM_MIPS:
4038 case EM_MIPS_RS3_LE:
4039 result = get_mips_segment_type (p_type);
4040 break;
4041 case EM_PARISC:
4042 result = get_parisc_segment_type (p_type);
4043 break;
4044 case EM_IA_64:
4045 result = get_ia64_segment_type (p_type);
4046 break;
4047 case EM_TI_C6000:
4048 result = get_tic6x_segment_type (p_type);
4049 break;
4050 case EM_S390:
4051 case EM_S390_OLD:
4052 result = get_s390_segment_type (p_type);
4053 break;
4054 default:
4055 result = NULL;
4056 break;
4057 }
4058
4059 if (result != NULL)
4060 return result;
4061
4062 sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
4063 }
4064 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
4065 {
4066 const char * result = NULL;
4067
4068 switch (filedata->file_header.e_ident[EI_OSABI])
4069 {
4070 case ELFOSABI_GNU:
4071 case ELFOSABI_FREEBSD:
4072 if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
4073 {
4074 sprintf (buff, "GNU_MBIND+%#lx", p_type - PT_GNU_MBIND_LO);
4075 result = buff;
4076 }
4077 break;
4078 case ELFOSABI_HPUX:
4079 result = get_hpux_segment_type (p_type,
4080 filedata->file_header.e_machine);
4081 break;
4082 case ELFOSABI_SOLARIS:
4083 result = get_solaris_segment_type (p_type);
4084 break;
4085 default:
4086 break;
4087 }
4088 if (result != NULL)
4089 return result;
4090
4091 sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
4092 }
4093 else
4094 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
4095
4096 return buff;
4097 }
4098}
4099
4100static const char *
4101get_arc_section_type_name (unsigned int sh_type)
4102{
4103 switch (sh_type)
4104 {
4105 case SHT_ARC_ATTRIBUTES: return "ARC_ATTRIBUTES";
4106 default:
4107 break;
4108 }
4109 return NULL;
4110}
4111
4112static const char *
4113get_mips_section_type_name (unsigned int sh_type)
4114{
4115 switch (sh_type)
4116 {
4117 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
4118 case SHT_MIPS_MSYM: return "MIPS_MSYM";
4119 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
4120 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
4121 case SHT_MIPS_UCODE: return "MIPS_UCODE";
4122 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
4123 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
4124 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
4125 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
4126 case SHT_MIPS_RELD: return "MIPS_RELD";
4127 case SHT_MIPS_IFACE: return "MIPS_IFACE";
4128 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
4129 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
4130 case SHT_MIPS_SHDR: return "MIPS_SHDR";
4131 case SHT_MIPS_FDESC: return "MIPS_FDESC";
4132 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
4133 case SHT_MIPS_DENSE: return "MIPS_DENSE";
4134 case SHT_MIPS_PDESC: return "MIPS_PDESC";
4135 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
4136 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
4137 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
4138 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
4139 case SHT_MIPS_LINE: return "MIPS_LINE";
4140 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
4141 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
4142 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
4143 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
4144 case SHT_MIPS_DWARF: return "MIPS_DWARF";
4145 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
4146 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
4147 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
4148 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
4149 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
4150 case SHT_MIPS_XLATE: return "MIPS_XLATE";
4151 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
4152 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
4153 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
4154 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
4155 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
4156 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
4157 case SHT_MIPS_XHASH: return "MIPS_XHASH";
4158 default:
4159 break;
4160 }
4161 return NULL;
4162}
4163
4164static const char *
4165get_parisc_section_type_name (unsigned int sh_type)
4166{
4167 switch (sh_type)
4168 {
4169 case SHT_PARISC_EXT: return "PARISC_EXT";
4170 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
4171 case SHT_PARISC_DOC: return "PARISC_DOC";
4172 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
4173 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
4174 case SHT_PARISC_STUBS: return "PARISC_STUBS";
4175 case SHT_PARISC_DLKM: return "PARISC_DLKM";
4176 default: return NULL;
4177 }
4178}
4179
4180static const char *
4181get_ia64_section_type_name (Filedata * filedata, unsigned int sh_type)
4182{
4183 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4184 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
4185 return get_osabi_name (filedata, (sh_type & 0x00FF0000) >> 16);
4186
4187 switch (sh_type)
4188 {
4189 case SHT_IA_64_EXT: return "IA_64_EXT";
4190 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
4191 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
4192 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
4193 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
4194 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
4195 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
4196 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
4197 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
4198 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4199 default:
4200 break;
4201 }
4202 return NULL;
4203}
4204
4205static const char *
4206get_x86_64_section_type_name (unsigned int sh_type)
4207{
4208 switch (sh_type)
4209 {
4210 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
4211 default: return NULL;
4212 }
4213}
4214
4215static const char *
4216get_aarch64_section_type_name (unsigned int sh_type)
4217{
4218 switch (sh_type)
4219 {
4220 case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4221 default: return NULL;
4222 }
4223}
4224
4225static const char *
4226get_arm_section_type_name (unsigned int sh_type)
4227{
4228 switch (sh_type)
4229 {
4230 case SHT_ARM_EXIDX: return "ARM_EXIDX";
4231 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
4232 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
4233 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
4234 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
4235 default: return NULL;
4236 }
4237}
4238
4239static const char *
4240get_tic6x_section_type_name (unsigned int sh_type)
4241{
4242 switch (sh_type)
4243 {
4244 case SHT_C6000_UNWIND: return "C6000_UNWIND";
4245 case SHT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
4246 case SHT_C6000_ATTRIBUTES: return "C6000_ATTRIBUTES";
4247 case SHT_TI_ICODE: return "TI_ICODE";
4248 case SHT_TI_XREF: return "TI_XREF";
4249 case SHT_TI_HANDLER: return "TI_HANDLER";
4250 case SHT_TI_INITINFO: return "TI_INITINFO";
4251 case SHT_TI_PHATTRS: return "TI_PHATTRS";
4252 default: return NULL;
4253 }
4254}
4255
4256static const char *
4257get_msp430x_section_type_name (unsigned int sh_type)
4258{
4259 switch (sh_type)
4260 {
4261 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
4262 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
4263 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
4264 default: return NULL;
4265 }
4266}
4267
4268static const char *
4269get_nfp_section_type_name (unsigned int sh_type)
4270{
4271 switch (sh_type)
4272 {
4273 case SHT_NFP_MECONFIG: return "NFP_MECONFIG";
4274 case SHT_NFP_INITREG: return "NFP_INITREG";
4275 case SHT_NFP_UDEBUG: return "NFP_UDEBUG";
4276 default: return NULL;
4277 }
4278}
4279
4280static const char *
4281get_v850_section_type_name (unsigned int sh_type)
4282{
4283 switch (sh_type)
4284 {
4285 case SHT_V850_SCOMMON: return "V850 Small Common";
4286 case SHT_V850_TCOMMON: return "V850 Tiny Common";
4287 case SHT_V850_ZCOMMON: return "V850 Zero Common";
4288 case SHT_RENESAS_IOP: return "RENESAS IOP";
4289 case SHT_RENESAS_INFO: return "RENESAS INFO";
4290 default: return NULL;
4291 }
4292}
4293
4294static const char *
4295get_riscv_section_type_name (unsigned int sh_type)
4296{
4297 switch (sh_type)
4298 {
4299 case SHT_RISCV_ATTRIBUTES: return "RISCV_ATTRIBUTES";
4300 default: return NULL;
4301 }
4302}
4303
4304static const char *
4305get_section_type_name (Filedata * filedata, unsigned int sh_type)
4306{
4307 static char buff[32];
4308 const char * result;
4309
4310 switch (sh_type)
4311 {
4312 case SHT_NULL: return "NULL";
4313 case SHT_PROGBITS: return "PROGBITS";
4314 case SHT_SYMTAB: return "SYMTAB";
4315 case SHT_STRTAB: return "STRTAB";
4316 case SHT_RELA: return "RELA";
4317 case SHT_HASH: return "HASH";
4318 case SHT_DYNAMIC: return "DYNAMIC";
4319 case SHT_NOTE: return "NOTE";
4320 case SHT_NOBITS: return "NOBITS";
4321 case SHT_REL: return "REL";
4322 case SHT_SHLIB: return "SHLIB";
4323 case SHT_DYNSYM: return "DYNSYM";
4324 case SHT_INIT_ARRAY: return "INIT_ARRAY";
4325 case SHT_FINI_ARRAY: return "FINI_ARRAY";
4326 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
4327 case SHT_GNU_HASH: return "GNU_HASH";
4328 case SHT_GROUP: return "GROUP";
4329 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICES";
4330 case SHT_GNU_verdef: return "VERDEF";
4331 case SHT_GNU_verneed: return "VERNEED";
4332 case SHT_GNU_versym: return "VERSYM";
4333 case 0x6ffffff0: return "VERSYM";
4334 case 0x6ffffffc: return "VERDEF";
4335 case 0x7ffffffd: return "AUXILIARY";
4336 case 0x7fffffff: return "FILTER";
4337 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
4338
4339 default:
4340 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4341 {
4342 switch (filedata->file_header.e_machine)
4343 {
4344 case EM_ARC:
4345 case EM_ARC_COMPACT:
4346 case EM_ARC_COMPACT2:
4347 result = get_arc_section_type_name (sh_type);
4348 break;
4349 case EM_MIPS:
4350 case EM_MIPS_RS3_LE:
4351 result = get_mips_section_type_name (sh_type);
4352 break;
4353 case EM_PARISC:
4354 result = get_parisc_section_type_name (sh_type);
4355 break;
4356 case EM_IA_64:
4357 result = get_ia64_section_type_name (filedata, sh_type);
4358 break;
4359 case EM_X86_64:
4360 case EM_L1OM:
4361 case EM_K1OM:
4362 result = get_x86_64_section_type_name (sh_type);
4363 break;
4364 case EM_AARCH64:
4365 result = get_aarch64_section_type_name (sh_type);
4366 break;
4367 case EM_ARM:
4368 result = get_arm_section_type_name (sh_type);
4369 break;
4370 case EM_TI_C6000:
4371 result = get_tic6x_section_type_name (sh_type);
4372 break;
4373 case EM_MSP430:
4374 result = get_msp430x_section_type_name (sh_type);
4375 break;
4376 case EM_NFP:
4377 result = get_nfp_section_type_name (sh_type);
4378 break;
4379 case EM_V800:
4380 case EM_V850:
4381 case EM_CYGNUS_V850:
4382 result = get_v850_section_type_name (sh_type);
4383 break;
4384 case EM_RISCV:
4385 result = get_riscv_section_type_name (sh_type);
4386 break;
4387 default:
4388 result = NULL;
4389 break;
4390 }
4391
4392 if (result != NULL)
4393 return result;
4394
4395 sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4396 }
4397 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4398 {
4399 switch (filedata->file_header.e_machine)
4400 {
4401 case EM_IA_64:
4402 result = get_ia64_section_type_name (filedata, sh_type);
4403 break;
4404 default:
4405 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4406 result = get_solaris_section_type (sh_type);
4407 else
4408 {
4409 switch (sh_type)
4410 {
4411 case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4412 case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4413 case SHT_GNU_HASH: result = "GNU_HASH"; break;
4414 case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4415 default:
4416 result = NULL;
4417 break;
4418 }
4419 }
4420 break;
4421 }
4422
4423 if (result != NULL)
4424 return result;
4425
4426 sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4427 }
4428 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4429 {
4430 switch (filedata->file_header.e_machine)
4431 {
4432 case EM_V800:
4433 case EM_V850:
4434 case EM_CYGNUS_V850:
4435 result = get_v850_section_type_name (sh_type);
4436 break;
4437 default:
4438 result = NULL;
4439 break;
4440 }
4441
4442 if (result != NULL)
4443 return result;
4444
4445 sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4446 }
4447 else
4448 /* This message is probably going to be displayed in a 15
4449 character wide field, so put the hex value first. */
4450 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4451
4452 return buff;
4453 }
4454}
4455
4456#define OPTION_DEBUG_DUMP 512
4457#define OPTION_DYN_SYMS 513
4458#define OPTION_DWARF_DEPTH 514
4459#define OPTION_DWARF_START 515
4460#define OPTION_DWARF_CHECK 516
4461#define OPTION_CTF_DUMP 517
4462#define OPTION_CTF_PARENT 518
4463#define OPTION_CTF_SYMBOLS 519
4464#define OPTION_CTF_STRINGS 520
4465
4466static struct option options[] =
4467{
4468 {"all", no_argument, 0, 'a'},
4469 {"file-header", no_argument, 0, 'h'},
4470 {"program-headers", no_argument, 0, 'l'},
4471 {"headers", no_argument, 0, 'e'},
4472 {"histogram", no_argument, 0, 'I'},
4473 {"segments", no_argument, 0, 'l'},
4474 {"sections", no_argument, 0, 'S'},
4475 {"section-headers", no_argument, 0, 'S'},
4476 {"section-groups", no_argument, 0, 'g'},
4477 {"section-details", no_argument, 0, 't'},
4478 {"full-section-name",no_argument, 0, 'N'},
4479 {"symbols", no_argument, 0, 's'},
4480 {"syms", no_argument, 0, 's'},
4481 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
4482 {"relocs", no_argument, 0, 'r'},
4483 {"notes", no_argument, 0, 'n'},
4484 {"dynamic", no_argument, 0, 'd'},
4485 {"lint", no_argument, 0, 'L'},
4486 {"enable-checks", no_argument, 0, 'L'},
4487 {"arch-specific", no_argument, 0, 'A'},
4488 {"version-info", no_argument, 0, 'V'},
4489 {"use-dynamic", no_argument, 0, 'D'},
4490 {"unwind", no_argument, 0, 'u'},
4491 {"archive-index", no_argument, 0, 'c'},
4492 {"hex-dump", required_argument, 0, 'x'},
4493 {"relocated-dump", required_argument, 0, 'R'},
4494 {"string-dump", required_argument, 0, 'p'},
4495 {"decompress", no_argument, 0, 'z'},
4496#ifdef SUPPORT_DISASSEMBLY
4497 {"instruction-dump", required_argument, 0, 'i'},
4498#endif
4499 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
4500
4501 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
4502 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4503 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
4504
4505 {"ctf", required_argument, 0, OPTION_CTF_DUMP},
4506
4507 {"ctf-symbols", required_argument, 0, OPTION_CTF_SYMBOLS},
4508 {"ctf-strings", required_argument, 0, OPTION_CTF_STRINGS},
4509 {"ctf-parent", required_argument, 0, OPTION_CTF_PARENT},
4510
4511 {"version", no_argument, 0, 'v'},
4512 {"wide", no_argument, 0, 'W'},
4513 {"help", no_argument, 0, 'H'},
4514 {0, no_argument, 0, 0}
4515};
4516
4517static void
4518usage (FILE * stream)
4519{
4520 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4521 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4522 fprintf (stream, _(" Options are:\n\
4523 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4524 -h --file-header Display the ELF file header\n\
4525 -l --program-headers Display the program headers\n\
4526 --segments An alias for --program-headers\n\
4527 -S --section-headers Display the sections' header\n\
4528 --sections An alias for --section-headers\n\
4529 -g --section-groups Display the section groups\n\
4530 -t --section-details Display the section details\n\
4531 -e --headers Equivalent to: -h -l -S\n\
4532 -s --syms Display the symbol table\n\
4533 --symbols An alias for --syms\n\
4534 --dyn-syms Display the dynamic symbol table\n\
4535 -n --notes Display the core notes (if present)\n\
4536 -r --relocs Display the relocations (if present)\n\
4537 -u --unwind Display the unwind info (if present)\n\
4538 -d --dynamic Display the dynamic section (if present)\n\
4539 -V --version-info Display the version sections (if present)\n\
4540 -A --arch-specific Display architecture specific information (if any)\n\
4541 -c --archive-index Display the symbol/file index in an archive\n\
4542 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4543 -L --lint|--enable-checks Display warning messages for possible problems\n\
4544 -x --hex-dump=<number|name>\n\
4545 Dump the contents of section <number|name> as bytes\n\
4546 -p --string-dump=<number|name>\n\
4547 Dump the contents of section <number|name> as strings\n\
4548 -R --relocated-dump=<number|name>\n\
4549 Dump the contents of section <number|name> as relocated bytes\n\
4550 -z --decompress Decompress section before dumping it\n\
4551 -w[lLiaprmfFsoORtUuTgAckK] or\n\
4552 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4553 =frames-interp,=str,=str-offsets,=loc,=Ranges,=pubtypes,\n\
4554 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4555 =addr,=cu_index,=links,=follow-links]\n\
4556 Display the contents of DWARF debug sections\n"));
4557 fprintf (stream, _("\
4558 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4559 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4560 or deeper\n"));
4561 fprintf (stream, _("\
4562 --ctf=<number|name> Display CTF info from section <number|name>\n\
4563 --ctf-parent=<number|name>\n\
4564 Use section <number|name> as the CTF parent\n\n\
4565 --ctf-symbols=<number|name>\n\
4566 Use section <number|name> as the CTF external symtab\n\n\
4567 --ctf-strings=<number|name>\n\
4568 Use section <number|name> as the CTF external strtab\n\n"));
4569
4570#ifdef SUPPORT_DISASSEMBLY
4571 fprintf (stream, _("\
4572 -i --instruction-dump=<number|name>\n\
4573 Disassemble the contents of section <number|name>\n"));
4574#endif
4575 fprintf (stream, _("\
4576 -I --histogram Display histogram of bucket list lengths\n\
4577 -W --wide Allow output width to exceed 80 characters\n\
4578 @<file> Read options from <file>\n\
4579 -H --help Display this information\n\
4580 -v --version Display the version number of readelf\n"));
4581
4582 if (REPORT_BUGS_TO[0] && stream == stdout)
4583 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4584
4585 exit (stream == stdout ? 0 : 1);
4586}
4587
4588/* Record the fact that the user wants the contents of section number
4589 SECTION to be displayed using the method(s) encoded as flags bits
4590 in TYPE. Note, TYPE can be zero if we are creating the array for
4591 the first time. */
4592
4593static void
4594request_dump_bynumber (struct dump_data *dumpdata,
4595 unsigned int section, dump_type type)
4596{
4597 if (section >= dumpdata->num_dump_sects)
4598 {
4599 dump_type * new_dump_sects;
4600
4601 new_dump_sects = (dump_type *) calloc (section + 1,
4602 sizeof (* new_dump_sects));
4603
4604 if (new_dump_sects == NULL)
4605 error (_("Out of memory allocating dump request table.\n"));
4606 else
4607 {
4608 if (dumpdata->dump_sects)
4609 {
4610 /* Copy current flag settings. */
4611 memcpy (new_dump_sects, dumpdata->dump_sects,
4612 dumpdata->num_dump_sects * sizeof (* new_dump_sects));
4613
4614 free (dumpdata->dump_sects);
4615 }
4616
4617 dumpdata->dump_sects = new_dump_sects;
4618 dumpdata->num_dump_sects = section + 1;
4619 }
4620 }
4621
4622 if (dumpdata->dump_sects)
4623 dumpdata->dump_sects[section] |= type;
4624}
4625
4626/* Request a dump by section name. */
4627
4628static void
4629request_dump_byname (const char * section, dump_type type)
4630{
4631 struct dump_list_entry * new_request;
4632
4633 new_request = (struct dump_list_entry *)
4634 malloc (sizeof (struct dump_list_entry));
4635 if (!new_request)
4636 error (_("Out of memory allocating dump request table.\n"));
4637
4638 new_request->name = strdup (section);
4639 if (!new_request->name)
4640 error (_("Out of memory allocating dump request table.\n"));
4641
4642 new_request->type = type;
4643
4644 new_request->next = dump_sects_byname;
4645 dump_sects_byname = new_request;
4646}
4647
4648static inline void
4649request_dump (struct dump_data *dumpdata, dump_type type)
4650{
4651 int section;
4652 char * cp;
4653
4654 do_dump++;
4655 section = strtoul (optarg, & cp, 0);
4656
4657 if (! *cp && section >= 0)
4658 request_dump_bynumber (dumpdata, section, type);
4659 else
4660 request_dump_byname (optarg, type);
4661}
4662
4663static void
4664parse_args (struct dump_data *dumpdata, int argc, char ** argv)
4665{
4666 int c;
4667
4668 if (argc < 2)
4669 usage (stderr);
4670
4671 while ((c = getopt_long
4672 (argc, argv, "ADHILNR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4673 {
4674 switch (c)
4675 {
4676 case 0:
4677 /* Long options. */
4678 break;
4679 case 'H':
4680 usage (stdout);
4681 break;
4682
4683 case 'a':
4684 do_syms = TRUE;
4685 do_reloc = TRUE;
4686 do_unwind = TRUE;
4687 do_dynamic = TRUE;
4688 do_header = TRUE;
4689 do_sections = TRUE;
4690 do_section_groups = TRUE;
4691 do_segments = TRUE;
4692 do_version = TRUE;
4693 do_histogram = TRUE;
4694 do_arch = TRUE;
4695 do_notes = TRUE;
4696 break;
4697 case 'g':
4698 do_section_groups = TRUE;
4699 break;
4700 case 't':
4701 case 'N':
4702 do_sections = TRUE;
4703 do_section_details = TRUE;
4704 break;
4705 case 'e':
4706 do_header = TRUE;
4707 do_sections = TRUE;
4708 do_segments = TRUE;
4709 break;
4710 case 'A':
4711 do_arch = TRUE;
4712 break;
4713 case 'D':
4714 do_using_dynamic = TRUE;
4715 break;
4716 case 'r':
4717 do_reloc = TRUE;
4718 break;
4719 case 'u':
4720 do_unwind = TRUE;
4721 break;
4722 case 'h':
4723 do_header = TRUE;
4724 break;
4725 case 'l':
4726 do_segments = TRUE;
4727 break;
4728 case 's':
4729 do_syms = TRUE;
4730 break;
4731 case 'S':
4732 do_sections = TRUE;
4733 break;
4734 case 'd':
4735 do_dynamic = TRUE;
4736 break;
4737 case 'I':
4738 do_histogram = TRUE;
4739 break;
4740 case 'n':
4741 do_notes = TRUE;
4742 break;
4743 case 'c':
4744 do_archive_index = TRUE;
4745 break;
4746 case 'L':
4747 do_checks = TRUE;
4748 break;
4749 case 'x':
4750 request_dump (dumpdata, HEX_DUMP);
4751 break;
4752 case 'p':
4753 request_dump (dumpdata, STRING_DUMP);
4754 break;
4755 case 'R':
4756 request_dump (dumpdata, RELOC_DUMP);
4757 break;
4758 case 'z':
4759 decompress_dumps = TRUE;
4760 break;
4761 case 'w':
4762 do_dump = TRUE;
4763 if (optarg == 0)
4764 {
4765 do_debugging = TRUE;
4766 dwarf_select_sections_all ();
4767 }
4768 else
4769 {
4770 do_debugging = FALSE;
4771 dwarf_select_sections_by_letters (optarg);
4772 }
4773 break;
4774 case OPTION_DEBUG_DUMP:
4775 do_dump = TRUE;
4776 if (optarg == 0)
4777 do_debugging = TRUE;
4778 else
4779 {
4780 do_debugging = FALSE;
4781 dwarf_select_sections_by_names (optarg);
4782 }
4783 break;
4784 case OPTION_DWARF_DEPTH:
4785 {
4786 char *cp;
4787
4788 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4789 }
4790 break;
4791 case OPTION_DWARF_START:
4792 {
4793 char *cp;
4794
4795 dwarf_start_die = strtoul (optarg, & cp, 0);
4796 }
4797 break;
4798 case OPTION_DWARF_CHECK:
4799 dwarf_check = TRUE;
4800 break;
4801 case OPTION_CTF_DUMP:
4802 do_ctf = TRUE;
4803 request_dump (dumpdata, CTF_DUMP);
4804 break;
4805 case OPTION_CTF_SYMBOLS:
4806 dump_ctf_symtab_name = strdup (optarg);
4807 break;
4808 case OPTION_CTF_STRINGS:
4809 dump_ctf_strtab_name = strdup (optarg);
4810 break;
4811 case OPTION_CTF_PARENT:
4812 dump_ctf_parent_name = strdup (optarg);
4813 break;
4814 case OPTION_DYN_SYMS:
4815 do_dyn_syms = TRUE;
4816 break;
4817#ifdef SUPPORT_DISASSEMBLY
4818 case 'i':
4819 request_dump (dumpdata, DISASS_DUMP);
4820 break;
4821#endif
4822 case 'v':
4823 print_version (program_name);
4824 break;
4825 case 'V':
4826 do_version = TRUE;
4827 break;
4828 case 'W':
4829 do_wide = TRUE;
4830 break;
4831 default:
4832 /* xgettext:c-format */
4833 error (_("Invalid option '-%c'\n"), c);
4834 /* Fall through. */
4835 case '?':
4836 usage (stderr);
4837 }
4838 }
4839
4840 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4841 && !do_segments && !do_header && !do_dump && !do_version
4842 && !do_histogram && !do_debugging && !do_arch && !do_notes
4843 && !do_section_groups && !do_archive_index
4844 && !do_dyn_syms)
4845 {
4846 if (do_checks)
4847 {
4848 check_all = TRUE;
4849 do_dynamic = do_syms = do_reloc = do_unwind = do_sections = TRUE;
4850 do_segments = do_header = do_dump = do_version = TRUE;
4851 do_histogram = do_debugging = do_arch = do_notes = TRUE;
4852 do_section_groups = do_archive_index = do_dyn_syms = TRUE;
4853 }
4854 else
4855 usage (stderr);
4856 }
4857}
4858
4859static const char *
4860get_elf_class (unsigned int elf_class)
4861{
4862 static char buff[32];
4863
4864 switch (elf_class)
4865 {
4866 case ELFCLASSNONE: return _("none");
4867 case ELFCLASS32: return "ELF32";
4868 case ELFCLASS64: return "ELF64";
4869 default:
4870 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4871 return buff;
4872 }
4873}
4874
4875static const char *
4876get_data_encoding (unsigned int encoding)
4877{
4878 static char buff[32];
4879
4880 switch (encoding)
4881 {
4882 case ELFDATANONE: return _("none");
4883 case ELFDATA2LSB: return _("2's complement, little endian");
4884 case ELFDATA2MSB: return _("2's complement, big endian");
4885 default:
4886 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4887 return buff;
4888 }
4889}
4890
4891/* Decode the data held in 'filedata->file_header'. */
4892
4893static bfd_boolean
4894process_file_header (Filedata * filedata)
4895{
4896 Elf_Internal_Ehdr * header = & filedata->file_header;
4897
4898 if ( header->e_ident[EI_MAG0] != ELFMAG0
4899 || header->e_ident[EI_MAG1] != ELFMAG1
4900 || header->e_ident[EI_MAG2] != ELFMAG2
4901 || header->e_ident[EI_MAG3] != ELFMAG3)
4902 {
4903 error
4904 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4905 return FALSE;
4906 }
4907
4908 init_dwarf_regnames_by_elf_machine_code (header->e_machine);
4909
4910 if (do_header)
4911 {
4912 unsigned i;
4913
4914 printf (_("ELF Header:\n"));
4915 printf (_(" Magic: "));
4916 for (i = 0; i < EI_NIDENT; i++)
4917 printf ("%2.2x ", header->e_ident[i]);
4918 printf ("\n");
4919 printf (_(" Class: %s\n"),
4920 get_elf_class (header->e_ident[EI_CLASS]));
4921 printf (_(" Data: %s\n"),
4922 get_data_encoding (header->e_ident[EI_DATA]));
4923 printf (_(" Version: %d%s\n"),
4924 header->e_ident[EI_VERSION],
4925 (header->e_ident[EI_VERSION] == EV_CURRENT
4926 ? _(" (current)")
4927 : (header->e_ident[EI_VERSION] != EV_NONE
4928 ? _(" <unknown>")
4929 : "")));
4930 printf (_(" OS/ABI: %s\n"),
4931 get_osabi_name (filedata, header->e_ident[EI_OSABI]));
4932 printf (_(" ABI Version: %d\n"),
4933 header->e_ident[EI_ABIVERSION]);
4934 printf (_(" Type: %s\n"),
4935 get_file_type (header->e_type));
4936 printf (_(" Machine: %s\n"),
4937 get_machine_name (header->e_machine));
4938 printf (_(" Version: 0x%lx\n"),
4939 header->e_version);
4940
4941 printf (_(" Entry point address: "));
4942 print_vma (header->e_entry, PREFIX_HEX);
4943 printf (_("\n Start of program headers: "));
4944 print_vma (header->e_phoff, DEC);
4945 printf (_(" (bytes into file)\n Start of section headers: "));
4946 print_vma (header->e_shoff, DEC);
4947 printf (_(" (bytes into file)\n"));
4948
4949 printf (_(" Flags: 0x%lx%s\n"),
4950 header->e_flags,
4951 get_machine_flags (filedata, header->e_flags, header->e_machine));
4952 printf (_(" Size of this header: %u (bytes)\n"),
4953 header->e_ehsize);
4954 printf (_(" Size of program headers: %u (bytes)\n"),
4955 header->e_phentsize);
4956 printf (_(" Number of program headers: %u"),
4957 header->e_phnum);
4958 if (filedata->section_headers != NULL
4959 && header->e_phnum == PN_XNUM
4960 && filedata->section_headers[0].sh_info != 0)
4961 {
4962 header->e_phnum = filedata->section_headers[0].sh_info;
4963 printf (" (%u)", header->e_phnum);
4964 }
4965 putc ('\n', stdout);
4966 printf (_(" Size of section headers: %u (bytes)\n"),
4967 header->e_shentsize);
4968 printf (_(" Number of section headers: %u"),
4969 header->e_shnum);
4970 if (filedata->section_headers != NULL && header->e_shnum == SHN_UNDEF)
4971 {
4972 header->e_shnum = filedata->section_headers[0].sh_size;
4973 printf (" (%u)", header->e_shnum);
4974 }
4975 putc ('\n', stdout);
4976 printf (_(" Section header string table index: %u"),
4977 header->e_shstrndx);
4978 if (filedata->section_headers != NULL
4979 && header->e_shstrndx == (SHN_XINDEX & 0xffff))
4980 {
4981 header->e_shstrndx = filedata->section_headers[0].sh_link;
4982 printf (" (%u)", header->e_shstrndx);
4983 }
4984 if (header->e_shstrndx != SHN_UNDEF
4985 && header->e_shstrndx >= header->e_shnum)
4986 {
4987 header->e_shstrndx = SHN_UNDEF;
4988 printf (_(" <corrupt: out of range>"));
4989 }
4990 putc ('\n', stdout);
4991 }
4992
4993 if (filedata->section_headers != NULL)
4994 {
4995 if (header->e_phnum == PN_XNUM
4996 && filedata->section_headers[0].sh_info != 0)
4997 header->e_phnum = filedata->section_headers[0].sh_info;
4998 if (header->e_shnum == SHN_UNDEF)
4999 header->e_shnum = filedata->section_headers[0].sh_size;
5000 if (header->e_shstrndx == (SHN_XINDEX & 0xffff))
5001 header->e_shstrndx = filedata->section_headers[0].sh_link;
5002 if (header->e_shstrndx >= header->e_shnum)
5003 header->e_shstrndx = SHN_UNDEF;
5004 free (filedata->section_headers);
5005 filedata->section_headers = NULL;
5006 }
5007
5008 return TRUE;
5009}
5010
5011/* Read in the program headers from FILEDATA and store them in PHEADERS.
5012 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
5013
5014static bfd_boolean
5015get_32bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
5016{
5017 Elf32_External_Phdr * phdrs;
5018 Elf32_External_Phdr * external;
5019 Elf_Internal_Phdr * internal;
5020 unsigned int i;
5021 unsigned int size = filedata->file_header.e_phentsize;
5022 unsigned int num = filedata->file_header.e_phnum;
5023
5024 /* PR binutils/17531: Cope with unexpected section header sizes. */
5025 if (size == 0 || num == 0)
5026 return FALSE;
5027 if (size < sizeof * phdrs)
5028 {
5029 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5030 return FALSE;
5031 }
5032 if (size > sizeof * phdrs)
5033 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5034
5035 phdrs = (Elf32_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
5036 size, num, _("program headers"));
5037 if (phdrs == NULL)
5038 return FALSE;
5039
5040 for (i = 0, internal = pheaders, external = phdrs;
5041 i < filedata->file_header.e_phnum;
5042 i++, internal++, external++)
5043 {
5044 internal->p_type = BYTE_GET (external->p_type);
5045 internal->p_offset = BYTE_GET (external->p_offset);
5046 internal->p_vaddr = BYTE_GET (external->p_vaddr);
5047 internal->p_paddr = BYTE_GET (external->p_paddr);
5048 internal->p_filesz = BYTE_GET (external->p_filesz);
5049 internal->p_memsz = BYTE_GET (external->p_memsz);
5050 internal->p_flags = BYTE_GET (external->p_flags);
5051 internal->p_align = BYTE_GET (external->p_align);
5052 }
5053
5054 free (phdrs);
5055 return TRUE;
5056}
5057
5058/* Read in the program headers from FILEDATA and store them in PHEADERS.
5059 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5060
5061static bfd_boolean
5062get_64bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
5063{
5064 Elf64_External_Phdr * phdrs;
5065 Elf64_External_Phdr * external;
5066 Elf_Internal_Phdr * internal;
5067 unsigned int i;
5068 unsigned int size = filedata->file_header.e_phentsize;
5069 unsigned int num = filedata->file_header.e_phnum;
5070
5071 /* PR binutils/17531: Cope with unexpected section header sizes. */
5072 if (size == 0 || num == 0)
5073 return FALSE;
5074 if (size < sizeof * phdrs)
5075 {
5076 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5077 return FALSE;
5078 }
5079 if (size > sizeof * phdrs)
5080 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5081
5082 phdrs = (Elf64_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
5083 size, num, _("program headers"));
5084 if (!phdrs)
5085 return FALSE;
5086
5087 for (i = 0, internal = pheaders, external = phdrs;
5088 i < filedata->file_header.e_phnum;
5089 i++, internal++, external++)
5090 {
5091 internal->p_type = BYTE_GET (external->p_type);
5092 internal->p_flags = BYTE_GET (external->p_flags);
5093 internal->p_offset = BYTE_GET (external->p_offset);
5094 internal->p_vaddr = BYTE_GET (external->p_vaddr);
5095 internal->p_paddr = BYTE_GET (external->p_paddr);
5096 internal->p_filesz = BYTE_GET (external->p_filesz);
5097 internal->p_memsz = BYTE_GET (external->p_memsz);
5098 internal->p_align = BYTE_GET (external->p_align);
5099 }
5100
5101 free (phdrs);
5102 return TRUE;
5103}
5104
5105/* Returns TRUE if the program headers were read into `program_headers'. */
5106
5107static bfd_boolean
5108get_program_headers (Filedata * filedata)
5109{
5110 Elf_Internal_Phdr * phdrs;
5111
5112 /* Check cache of prior read. */
5113 if (filedata->program_headers != NULL)
5114 return TRUE;
5115
5116 /* Be kind to memory checkers by looking for
5117 e_phnum values which we know must be invalid. */
5118 if (filedata->file_header.e_phnum
5119 * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
5120 >= filedata->file_size)
5121 {
5122 error (_("Too many program headers - %#x - the file is not that big\n"),
5123 filedata->file_header.e_phnum);
5124 return FALSE;
5125 }
5126
5127 phdrs = (Elf_Internal_Phdr *) cmalloc (filedata->file_header.e_phnum,
5128 sizeof (Elf_Internal_Phdr));
5129 if (phdrs == NULL)
5130 {
5131 error (_("Out of memory reading %u program headers\n"),
5132 filedata->file_header.e_phnum);
5133 return FALSE;
5134 }
5135
5136 if (is_32bit_elf
5137 ? get_32bit_program_headers (filedata, phdrs)
5138 : get_64bit_program_headers (filedata, phdrs))
5139 {
5140 filedata->program_headers = phdrs;
5141 return TRUE;
5142 }
5143
5144 free (phdrs);
5145 return FALSE;
5146}
5147
5148/* Returns TRUE if the program headers were loaded. */
5149
5150static bfd_boolean
5151process_program_headers (Filedata * filedata)
5152{
5153 Elf_Internal_Phdr * segment;
5154 unsigned int i;
5155 Elf_Internal_Phdr * previous_load = NULL;
5156
5157 filedata->dynamic_addr = 0;
5158 filedata->dynamic_size = 0;
5159
5160 if (filedata->file_header.e_phnum == 0)
5161 {
5162 /* PR binutils/12467. */
5163 if (filedata->file_header.e_phoff != 0)
5164 {
5165 warn (_("possibly corrupt ELF header - it has a non-zero program"
5166 " header offset, but no program headers\n"));
5167 return FALSE;
5168 }
5169 else if (do_segments)
5170 printf (_("\nThere are no program headers in this file.\n"));
5171 return TRUE;
5172 }
5173
5174 if (do_segments && !do_header)
5175 {
5176 printf (_("\nElf file type is %s\n"), get_file_type (filedata->file_header.e_type));
5177 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata->file_header.e_entry));
5178 printf (ngettext ("There is %d program header, starting at offset %s\n",
5179 "There are %d program headers, starting at offset %s\n",
5180 filedata->file_header.e_phnum),
5181 filedata->file_header.e_phnum,
5182 bfd_vmatoa ("u", filedata->file_header.e_phoff));
5183 }
5184
5185 if (! get_program_headers (filedata))
5186 return TRUE;
5187
5188 if (do_segments)
5189 {
5190 if (filedata->file_header.e_phnum > 1)
5191 printf (_("\nProgram Headers:\n"));
5192 else
5193 printf (_("\nProgram Headers:\n"));
5194
5195 if (is_32bit_elf)
5196 printf
5197 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5198 else if (do_wide)
5199 printf
5200 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5201 else
5202 {
5203 printf
5204 (_(" Type Offset VirtAddr PhysAddr\n"));
5205 printf
5206 (_(" FileSiz MemSiz Flags Align\n"));
5207 }
5208 }
5209
5210 for (i = 0, segment = filedata->program_headers;
5211 i < filedata->file_header.e_phnum;
5212 i++, segment++)
5213 {
5214 if (do_segments)
5215 {
5216 printf (" %-14.14s ", get_segment_type (filedata, segment->p_type));
5217
5218 if (is_32bit_elf)
5219 {
5220 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5221 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
5222 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
5223 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
5224 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
5225 printf ("%c%c%c ",
5226 (segment->p_flags & PF_R ? 'R' : ' '),
5227 (segment->p_flags & PF_W ? 'W' : ' '),
5228 (segment->p_flags & PF_X ? 'E' : ' '));
5229 printf ("%#lx", (unsigned long) segment->p_align);
5230 }
5231 else if (do_wide)
5232 {
5233 if ((unsigned long) segment->p_offset == segment->p_offset)
5234 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5235 else
5236 {
5237 print_vma (segment->p_offset, FULL_HEX);
5238 putchar (' ');
5239 }
5240
5241 print_vma (segment->p_vaddr, FULL_HEX);
5242 putchar (' ');
5243 print_vma (segment->p_paddr, FULL_HEX);
5244 putchar (' ');
5245
5246 if ((unsigned long) segment->p_filesz == segment->p_filesz)
5247 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
5248 else
5249 {
5250 print_vma (segment->p_filesz, FULL_HEX);
5251 putchar (' ');
5252 }
5253
5254 if ((unsigned long) segment->p_memsz == segment->p_memsz)
5255 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
5256 else
5257 {
5258 print_vma (segment->p_memsz, FULL_HEX);
5259 }
5260
5261 printf (" %c%c%c ",
5262 (segment->p_flags & PF_R ? 'R' : ' '),
5263 (segment->p_flags & PF_W ? 'W' : ' '),
5264 (segment->p_flags & PF_X ? 'E' : ' '));
5265
5266 if ((unsigned long) segment->p_align == segment->p_align)
5267 printf ("%#lx", (unsigned long) segment->p_align);
5268 else
5269 {
5270 print_vma (segment->p_align, PREFIX_HEX);
5271 }
5272 }
5273 else
5274 {
5275 print_vma (segment->p_offset, FULL_HEX);
5276 putchar (' ');
5277 print_vma (segment->p_vaddr, FULL_HEX);
5278 putchar (' ');
5279 print_vma (segment->p_paddr, FULL_HEX);
5280 printf ("\n ");
5281 print_vma (segment->p_filesz, FULL_HEX);
5282 putchar (' ');
5283 print_vma (segment->p_memsz, FULL_HEX);
5284 printf (" %c%c%c ",
5285 (segment->p_flags & PF_R ? 'R' : ' '),
5286 (segment->p_flags & PF_W ? 'W' : ' '),
5287 (segment->p_flags & PF_X ? 'E' : ' '));
5288 print_vma (segment->p_align, PREFIX_HEX);
5289 }
5290
5291 putc ('\n', stdout);
5292 }
5293
5294 switch (segment->p_type)
5295 {
5296 case PT_LOAD:
5297#if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5298 required by the ELF standard, several programs, including the Linux
5299 kernel, make use of non-ordered segments. */
5300 if (previous_load
5301 && previous_load->p_vaddr > segment->p_vaddr)
5302 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5303#endif
5304 if (segment->p_memsz < segment->p_filesz)
5305 error (_("the segment's file size is larger than its memory size\n"));
5306 previous_load = segment;
5307 break;
5308
5309 case PT_PHDR:
5310 /* PR 20815 - Verify that the program header is loaded into memory. */
5311 if (i > 0 && previous_load != NULL)
5312 error (_("the PHDR segment must occur before any LOAD segment\n"));
5313 if (filedata->file_header.e_machine != EM_PARISC)
5314 {
5315 unsigned int j;
5316
5317 for (j = 1; j < filedata->file_header.e_phnum; j++)
5318 {
5319 Elf_Internal_Phdr *load = filedata->program_headers + j;
5320 if (load->p_type == PT_LOAD
5321 && load->p_offset <= segment->p_offset
5322 && (load->p_offset + load->p_filesz
5323 >= segment->p_offset + segment->p_filesz)
5324 && load->p_vaddr <= segment->p_vaddr
5325 && (load->p_vaddr + load->p_filesz
5326 >= segment->p_vaddr + segment->p_filesz))
5327 break;
5328 }
5329 if (j == filedata->file_header.e_phnum)
5330 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5331 }
5332 break;
5333
5334 case PT_DYNAMIC:
5335 if (filedata->dynamic_addr)
5336 error (_("more than one dynamic segment\n"));
5337
5338 /* By default, assume that the .dynamic section is the first
5339 section in the DYNAMIC segment. */
5340 filedata->dynamic_addr = segment->p_offset;
5341 filedata->dynamic_size = segment->p_filesz;
5342
5343 /* Try to locate the .dynamic section. If there is
5344 a section header table, we can easily locate it. */
5345 if (filedata->section_headers != NULL)
5346 {
5347 Elf_Internal_Shdr * sec;
5348
5349 sec = find_section (filedata, ".dynamic");
5350 if (sec == NULL || sec->sh_size == 0)
5351 {
5352 /* A corresponding .dynamic section is expected, but on
5353 IA-64/OpenVMS it is OK for it to be missing. */
5354 if (!is_ia64_vms (filedata))
5355 error (_("no .dynamic section in the dynamic segment\n"));
5356 break;
5357 }
5358
5359 if (sec->sh_type == SHT_NOBITS)
5360 {
5361 filedata->dynamic_size = 0;
5362 break;
5363 }
5364
5365 filedata->dynamic_addr = sec->sh_offset;
5366 filedata->dynamic_size = sec->sh_size;
5367
5368 /* The PT_DYNAMIC segment, which is used by the run-time
5369 loader, should exactly match the .dynamic section. */
5370 if (do_checks
5371 && (filedata->dynamic_addr != segment->p_offset
5372 || filedata->dynamic_size != segment->p_filesz))
5373 warn (_("\
5374the .dynamic section is not the same as the dynamic segment\n"));
5375 }
5376
5377 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5378 segment. Check this after matching against the section headers
5379 so we don't warn on debuginfo file (which have NOBITS .dynamic
5380 sections). */
5381 if (filedata->dynamic_addr > filedata->file_size
5382 || (filedata->dynamic_size
5383 > filedata->file_size - filedata->dynamic_addr))
5384 {
5385 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5386 filedata->dynamic_addr = filedata->dynamic_size = 0;
5387 }
5388 break;
5389
5390 case PT_INTERP:
5391 if (fseek (filedata->handle,
5392 filedata->archive_file_offset + (long) segment->p_offset,
5393 SEEK_SET))
5394 error (_("Unable to find program interpreter name\n"));
5395 else
5396 {
5397 char fmt [32];
5398 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5399
5400 if (ret >= (int) sizeof (fmt) || ret < 0)
5401 error (_("Internal error: failed to create format string to display program interpreter\n"));
5402
5403 filedata->program_interpreter[0] = 0;
5404 if (fscanf (filedata->handle, fmt,
5405 filedata->program_interpreter) <= 0)
5406 error (_("Unable to read program interpreter name\n"));
5407
5408 if (do_segments)
5409 printf (_(" [Requesting program interpreter: %s]\n"),
5410 filedata->program_interpreter);
5411 }
5412 break;
5413 }
5414 }
5415
5416 if (do_segments
5417 && filedata->section_headers != NULL
5418 && filedata->string_table != NULL)
5419 {
5420 printf (_("\n Section to Segment mapping:\n"));
5421 printf (_(" Segment Sections...\n"));
5422
5423 for (i = 0; i < filedata->file_header.e_phnum; i++)
5424 {
5425 unsigned int j;
5426 Elf_Internal_Shdr * section;
5427
5428 segment = filedata->program_headers + i;
5429 section = filedata->section_headers + 1;
5430
5431 printf (" %2.2d ", i);
5432
5433 for (j = 1; j < filedata->file_header.e_shnum; j++, section++)
5434 {
5435 if (!ELF_TBSS_SPECIAL (section, segment)
5436 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5437 printf ("%s ", printable_section_name (filedata, section));
5438 }
5439
5440 putc ('\n',stdout);
5441 }
5442 }
5443
5444 return TRUE;
5445}
5446
5447
5448/* Find the file offset corresponding to VMA by using the program headers. */
5449
5450static long
5451offset_from_vma (Filedata * filedata, bfd_vma vma, bfd_size_type size)
5452{
5453 Elf_Internal_Phdr * seg;
5454
5455 if (! get_program_headers (filedata))
5456 {
5457 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5458 return (long) vma;
5459 }
5460
5461 for (seg = filedata->program_headers;
5462 seg < filedata->program_headers + filedata->file_header.e_phnum;
5463 ++seg)
5464 {
5465 if (seg->p_type != PT_LOAD)
5466 continue;
5467
5468 if (vma >= (seg->p_vaddr & -seg->p_align)
5469 && vma + size <= seg->p_vaddr + seg->p_filesz)
5470 return vma - seg->p_vaddr + seg->p_offset;
5471 }
5472
5473 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5474 (unsigned long) vma);
5475 return (long) vma;
5476}
5477
5478
5479/* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5480 If PROBE is true, this is just a probe and we do not generate any error
5481 messages if the load fails. */
5482
5483static bfd_boolean
5484get_32bit_section_headers (Filedata * filedata, bfd_boolean probe)
5485{
5486 Elf32_External_Shdr * shdrs;
5487 Elf_Internal_Shdr * internal;
5488 unsigned int i;
5489 unsigned int size = filedata->file_header.e_shentsize;
5490 unsigned int num = probe ? 1 : filedata->file_header.e_shnum;
5491
5492 /* PR binutils/17531: Cope with unexpected section header sizes. */
5493 if (size == 0 || num == 0)
5494 return FALSE;
5495 if (size < sizeof * shdrs)
5496 {
5497 if (! probe)
5498 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5499 return FALSE;
5500 }
5501 if (!probe && size > sizeof * shdrs)
5502 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5503
5504 shdrs = (Elf32_External_Shdr *) get_data (NULL, filedata, filedata->file_header.e_shoff,
5505 size, num,
5506 probe ? NULL : _("section headers"));
5507 if (shdrs == NULL)
5508 return FALSE;
5509
5510 free (filedata->section_headers);
5511 filedata->section_headers = (Elf_Internal_Shdr *)
5512 cmalloc (num, sizeof (Elf_Internal_Shdr));
5513 if (filedata->section_headers == NULL)
5514 {
5515 if (!probe)
5516 error (_("Out of memory reading %u section headers\n"), num);
5517 free (shdrs);
5518 return FALSE;
5519 }
5520
5521 for (i = 0, internal = filedata->section_headers;
5522 i < num;
5523 i++, internal++)
5524 {
5525 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5526 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5527 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5528 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5529 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5530 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5531 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5532 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5533 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5534 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
5535 if (!probe && internal->sh_link > num)
5536 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5537 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5538 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5539 }
5540
5541 free (shdrs);
5542 return TRUE;
5543}
5544
5545/* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5546
5547static bfd_boolean
5548get_64bit_section_headers (Filedata * filedata, bfd_boolean probe)
5549{
5550 Elf64_External_Shdr * shdrs;
5551 Elf_Internal_Shdr * internal;
5552 unsigned int i;
5553 unsigned int size = filedata->file_header.e_shentsize;
5554 unsigned int num = probe ? 1 : filedata->file_header.e_shnum;
5555
5556 /* PR binutils/17531: Cope with unexpected section header sizes. */
5557 if (size == 0 || num == 0)
5558 return FALSE;
5559
5560 if (size < sizeof * shdrs)
5561 {
5562 if (! probe)
5563 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5564 return FALSE;
5565 }
5566
5567 if (! probe && size > sizeof * shdrs)
5568 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5569
5570 shdrs = (Elf64_External_Shdr *) get_data (NULL, filedata,
5571 filedata->file_header.e_shoff,
5572 size, num,
5573 probe ? NULL : _("section headers"));
5574 if (shdrs == NULL)
5575 return FALSE;
5576
5577 free (filedata->section_headers);
5578 filedata->section_headers = (Elf_Internal_Shdr *)
5579 cmalloc (num, sizeof (Elf_Internal_Shdr));
5580 if (filedata->section_headers == NULL)
5581 {
5582 if (! probe)
5583 error (_("Out of memory reading %u section headers\n"), num);
5584 free (shdrs);
5585 return FALSE;
5586 }
5587
5588 for (i = 0, internal = filedata->section_headers;
5589 i < num;
5590 i++, internal++)
5591 {
5592 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5593 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5594 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5595 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5596 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5597 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
5598 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5599 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5600 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5601 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5602 if (!probe && internal->sh_link > num)
5603 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5604 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5605 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5606 }
5607
5608 free (shdrs);
5609 return TRUE;
5610}
5611
5612static Elf_Internal_Sym *
5613get_32bit_elf_symbols (Filedata * filedata,
5614 Elf_Internal_Shdr * section,
5615 unsigned long * num_syms_return)
5616{
5617 unsigned long number = 0;
5618 Elf32_External_Sym * esyms = NULL;
5619 Elf_External_Sym_Shndx * shndx = NULL;
5620 Elf_Internal_Sym * isyms = NULL;
5621 Elf_Internal_Sym * psym;
5622 unsigned int j;
5623 elf_section_list * entry;
5624
5625 if (section->sh_size == 0)
5626 {
5627 if (num_syms_return != NULL)
5628 * num_syms_return = 0;
5629 return NULL;
5630 }
5631
5632 /* Run some sanity checks first. */
5633 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5634 {
5635 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5636 printable_section_name (filedata, section),
5637 (unsigned long) section->sh_entsize);
5638 goto exit_point;
5639 }
5640
5641 if (section->sh_size > filedata->file_size)
5642 {
5643 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5644 printable_section_name (filedata, section),
5645 (unsigned long) section->sh_size);
5646 goto exit_point;
5647 }
5648
5649 number = section->sh_size / section->sh_entsize;
5650
5651 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5652 {
5653 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5654 (unsigned long) section->sh_size,
5655 printable_section_name (filedata, section),
5656 (unsigned long) section->sh_entsize);
5657 goto exit_point;
5658 }
5659
5660 esyms = (Elf32_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5661 section->sh_size, _("symbols"));
5662 if (esyms == NULL)
5663 goto exit_point;
5664
5665 shndx = NULL;
5666 for (entry = filedata->symtab_shndx_list; entry != NULL; entry = entry->next)
5667 {
5668 if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5669 continue;
5670
5671 if (shndx != NULL)
5672 {
5673 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5674 free (shndx);
5675 }
5676
5677 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5678 entry->hdr->sh_offset,
5679 1, entry->hdr->sh_size,
5680 _("symbol table section indices"));
5681 if (shndx == NULL)
5682 goto exit_point;
5683
5684 /* PR17531: file: heap-buffer-overflow */
5685 if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5686 {
5687 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5688 printable_section_name (filedata, entry->hdr),
5689 (unsigned long) entry->hdr->sh_size,
5690 (unsigned long) section->sh_size);
5691 goto exit_point;
5692 }
5693 }
5694
5695 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5696
5697 if (isyms == NULL)
5698 {
5699 error (_("Out of memory reading %lu symbols\n"),
5700 (unsigned long) number);
5701 goto exit_point;
5702 }
5703
5704 for (j = 0, psym = isyms; j < number; j++, psym++)
5705 {
5706 psym->st_name = BYTE_GET (esyms[j].st_name);
5707 psym->st_value = BYTE_GET (esyms[j].st_value);
5708 psym->st_size = BYTE_GET (esyms[j].st_size);
5709 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5710 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5711 psym->st_shndx
5712 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5713 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5714 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5715 psym->st_info = BYTE_GET (esyms[j].st_info);
5716 psym->st_other = BYTE_GET (esyms[j].st_other);
5717 }
5718
5719 exit_point:
5720 free (shndx);
5721 free (esyms);
5722
5723 if (num_syms_return != NULL)
5724 * num_syms_return = isyms == NULL ? 0 : number;
5725
5726 return isyms;
5727}
5728
5729static Elf_Internal_Sym *
5730get_64bit_elf_symbols (Filedata * filedata,
5731 Elf_Internal_Shdr * section,
5732 unsigned long * num_syms_return)
5733{
5734 unsigned long number = 0;
5735 Elf64_External_Sym * esyms = NULL;
5736 Elf_External_Sym_Shndx * shndx = NULL;
5737 Elf_Internal_Sym * isyms = NULL;
5738 Elf_Internal_Sym * psym;
5739 unsigned int j;
5740 elf_section_list * entry;
5741
5742 if (section->sh_size == 0)
5743 {
5744 if (num_syms_return != NULL)
5745 * num_syms_return = 0;
5746 return NULL;
5747 }
5748
5749 /* Run some sanity checks first. */
5750 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5751 {
5752 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5753 printable_section_name (filedata, section),
5754 (unsigned long) section->sh_entsize);
5755 goto exit_point;
5756 }
5757
5758 if (section->sh_size > filedata->file_size)
5759 {
5760 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5761 printable_section_name (filedata, section),
5762 (unsigned long) section->sh_size);
5763 goto exit_point;
5764 }
5765
5766 number = section->sh_size / section->sh_entsize;
5767
5768 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5769 {
5770 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5771 (unsigned long) section->sh_size,
5772 printable_section_name (filedata, section),
5773 (unsigned long) section->sh_entsize);
5774 goto exit_point;
5775 }
5776
5777 esyms = (Elf64_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5778 section->sh_size, _("symbols"));
5779 if (!esyms)
5780 goto exit_point;
5781
5782 shndx = NULL;
5783 for (entry = filedata->symtab_shndx_list; entry != NULL; entry = entry->next)
5784 {
5785 if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5786 continue;
5787
5788 if (shndx != NULL)
5789 {
5790 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5791 free (shndx);
5792 }
5793
5794 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5795 entry->hdr->sh_offset,
5796 1, entry->hdr->sh_size,
5797 _("symbol table section indices"));
5798 if (shndx == NULL)
5799 goto exit_point;
5800
5801 /* PR17531: file: heap-buffer-overflow */
5802 if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5803 {
5804 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5805 printable_section_name (filedata, entry->hdr),
5806 (unsigned long) entry->hdr->sh_size,
5807 (unsigned long) section->sh_size);
5808 goto exit_point;
5809 }
5810 }
5811
5812 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5813
5814 if (isyms == NULL)
5815 {
5816 error (_("Out of memory reading %lu symbols\n"),
5817 (unsigned long) number);
5818 goto exit_point;
5819 }
5820
5821 for (j = 0, psym = isyms; j < number; j++, psym++)
5822 {
5823 psym->st_name = BYTE_GET (esyms[j].st_name);
5824 psym->st_info = BYTE_GET (esyms[j].st_info);
5825 psym->st_other = BYTE_GET (esyms[j].st_other);
5826 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5827
5828 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5829 psym->st_shndx
5830 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5831 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5832 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5833
5834 psym->st_value = BYTE_GET (esyms[j].st_value);
5835 psym->st_size = BYTE_GET (esyms[j].st_size);
5836 }
5837
5838 exit_point:
5839 free (shndx);
5840 free (esyms);
5841
5842 if (num_syms_return != NULL)
5843 * num_syms_return = isyms == NULL ? 0 : number;
5844
5845 return isyms;
5846}
5847
5848static const char *
5849get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
5850{
5851 static char buff[1024];
5852 char * p = buff;
5853 unsigned int field_size = is_32bit_elf ? 8 : 16;
5854 signed int sindex;
5855 unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5856 bfd_vma os_flags = 0;
5857 bfd_vma proc_flags = 0;
5858 bfd_vma unknown_flags = 0;
5859 static const struct
5860 {
5861 const char * str;
5862 unsigned int len;
5863 }
5864 flags [] =
5865 {
5866 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5867 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5868 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5869 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5870 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5871 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5872 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5873 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5874 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5875 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5876 /* IA-64 specific. */
5877 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5878 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5879 /* IA-64 OpenVMS specific. */
5880 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5881 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5882 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5883 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5884 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5885 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5886 /* Generic. */
5887 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5888 /* SPARC specific. */
5889 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5890 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5891 /* ARM specific. */
5892 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5893 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5894 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5895 /* GNU specific. */
5896 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5897 /* VLE specific. */
5898 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5899 };
5900
5901 if (do_section_details)
5902 {
5903 sprintf (buff, "[%*.*lx]: ",
5904 field_size, field_size, (unsigned long) sh_flags);
5905 p += field_size + 4;
5906 }
5907
5908 while (sh_flags)
5909 {
5910 bfd_vma flag;
5911
5912 flag = sh_flags & - sh_flags;
5913 sh_flags &= ~ flag;
5914
5915 if (do_section_details)
5916 {
5917 switch (flag)
5918 {
5919 case SHF_WRITE: sindex = 0; break;
5920 case SHF_ALLOC: sindex = 1; break;
5921 case SHF_EXECINSTR: sindex = 2; break;
5922 case SHF_MERGE: sindex = 3; break;
5923 case SHF_STRINGS: sindex = 4; break;
5924 case SHF_INFO_LINK: sindex = 5; break;
5925 case SHF_LINK_ORDER: sindex = 6; break;
5926 case SHF_OS_NONCONFORMING: sindex = 7; break;
5927 case SHF_GROUP: sindex = 8; break;
5928 case SHF_TLS: sindex = 9; break;
5929 case SHF_EXCLUDE: sindex = 18; break;
5930 case SHF_COMPRESSED: sindex = 20; break;
5931 case SHF_GNU_MBIND: sindex = 24; break;
5932
5933 default:
5934 sindex = -1;
5935 switch (filedata->file_header.e_machine)
5936 {
5937 case EM_IA_64:
5938 if (flag == SHF_IA_64_SHORT)
5939 sindex = 10;
5940 else if (flag == SHF_IA_64_NORECOV)
5941 sindex = 11;
5942#ifdef BFD64
5943 else if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5944 switch (flag)
5945 {
5946 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5947 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5948 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5949 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5950 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5951 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
5952 default: break;
5953 }
5954#endif
5955 break;
5956
5957 case EM_386:
5958 case EM_IAMCU:
5959 case EM_X86_64:
5960 case EM_L1OM:
5961 case EM_K1OM:
5962 case EM_OLD_SPARCV9:
5963 case EM_SPARC32PLUS:
5964 case EM_SPARCV9:
5965 case EM_SPARC:
5966 if (flag == SHF_ORDERED)
5967 sindex = 19;
5968 break;
5969
5970 case EM_ARM:
5971 switch (flag)
5972 {
5973 case SHF_ENTRYSECT: sindex = 21; break;
5974 case SHF_ARM_PURECODE: sindex = 22; break;
5975 case SHF_COMDEF: sindex = 23; break;
5976 default: break;
5977 }
5978 break;
5979 case EM_PPC:
5980 if (flag == SHF_PPC_VLE)
5981 sindex = 25;
5982 break;
5983
5984 default:
5985 break;
5986 }
5987 }
5988
5989 if (sindex != -1)
5990 {
5991 if (p != buff + field_size + 4)
5992 {
5993 if (size < (10 + 2))
5994 {
5995 warn (_("Internal error: not enough buffer room for section flag info"));
5996 return _("<unknown>");
5997 }
5998 size -= 2;
5999 *p++ = ',';
6000 *p++ = ' ';
6001 }
6002
6003 size -= flags [sindex].len;
6004 p = stpcpy (p, flags [sindex].str);
6005 }
6006 else if (flag & SHF_MASKOS)
6007 os_flags |= flag;
6008 else if (flag & SHF_MASKPROC)
6009 proc_flags |= flag;
6010 else
6011 unknown_flags |= flag;
6012 }
6013 else
6014 {
6015 switch (flag)
6016 {
6017 case SHF_WRITE: *p = 'W'; break;
6018 case SHF_ALLOC: *p = 'A'; break;
6019 case SHF_EXECINSTR: *p = 'X'; break;
6020 case SHF_MERGE: *p = 'M'; break;
6021 case SHF_STRINGS: *p = 'S'; break;
6022 case SHF_INFO_LINK: *p = 'I'; break;
6023 case SHF_LINK_ORDER: *p = 'L'; break;
6024 case SHF_OS_NONCONFORMING: *p = 'O'; break;
6025 case SHF_GROUP: *p = 'G'; break;
6026 case SHF_TLS: *p = 'T'; break;
6027 case SHF_EXCLUDE: *p = 'E'; break;
6028 case SHF_COMPRESSED: *p = 'C'; break;
6029 case SHF_GNU_MBIND: *p = 'D'; break;
6030
6031 default:
6032 if ((filedata->file_header.e_machine == EM_X86_64
6033 || filedata->file_header.e_machine == EM_L1OM
6034 || filedata->file_header.e_machine == EM_K1OM)
6035 && flag == SHF_X86_64_LARGE)
6036 *p = 'l';
6037 else if (filedata->file_header.e_machine == EM_ARM
6038 && flag == SHF_ARM_PURECODE)
6039 *p = 'y';
6040 else if (filedata->file_header.e_machine == EM_PPC
6041 && flag == SHF_PPC_VLE)
6042 *p = 'v';
6043 else if (flag & SHF_MASKOS)
6044 {
6045 *p = 'o';
6046 sh_flags &= ~ SHF_MASKOS;
6047 }
6048 else if (flag & SHF_MASKPROC)
6049 {
6050 *p = 'p';
6051 sh_flags &= ~ SHF_MASKPROC;
6052 }
6053 else
6054 *p = 'x';
6055 break;
6056 }
6057 p++;
6058 }
6059 }
6060
6061 if (do_section_details)
6062 {
6063 if (os_flags)
6064 {
6065 size -= 5 + field_size;
6066 if (p != buff + field_size + 4)
6067 {
6068 if (size < (2 + 1))
6069 {
6070 warn (_("Internal error: not enough buffer room for section flag info"));
6071 return _("<unknown>");
6072 }
6073 size -= 2;
6074 *p++ = ',';
6075 *p++ = ' ';
6076 }
6077 sprintf (p, "OS (%*.*lx)", field_size, field_size,
6078 (unsigned long) os_flags);
6079 p += 5 + field_size;
6080 }
6081 if (proc_flags)
6082 {
6083 size -= 7 + field_size;
6084 if (p != buff + field_size + 4)
6085 {
6086 if (size < (2 + 1))
6087 {
6088 warn (_("Internal error: not enough buffer room for section flag info"));
6089 return _("<unknown>");
6090 }
6091 size -= 2;
6092 *p++ = ',';
6093 *p++ = ' ';
6094 }
6095 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
6096 (unsigned long) proc_flags);
6097 p += 7 + field_size;
6098 }
6099 if (unknown_flags)
6100 {
6101 size -= 10 + field_size;
6102 if (p != buff + field_size + 4)
6103 {
6104 if (size < (2 + 1))
6105 {
6106 warn (_("Internal error: not enough buffer room for section flag info"));
6107 return _("<unknown>");
6108 }
6109 size -= 2;
6110 *p++ = ',';
6111 *p++ = ' ';
6112 }
6113 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
6114 (unsigned long) unknown_flags);
6115 p += 10 + field_size;
6116 }
6117 }
6118
6119 *p = '\0';
6120 return buff;
6121}
6122
6123static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
6124get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
6125{
6126 if (is_32bit_elf)
6127 {
6128 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
6129
6130 if (size < sizeof (* echdr))
6131 {
6132 error (_("Compressed section is too small even for a compression header\n"));
6133 return 0;
6134 }
6135
6136 chdr->ch_type = BYTE_GET (echdr->ch_type);
6137 chdr->ch_size = BYTE_GET (echdr->ch_size);
6138 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
6139 return sizeof (*echdr);
6140 }
6141 else
6142 {
6143 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
6144
6145 if (size < sizeof (* echdr))
6146 {
6147 error (_("Compressed section is too small even for a compression header\n"));
6148 return 0;
6149 }
6150
6151 chdr->ch_type = BYTE_GET (echdr->ch_type);
6152 chdr->ch_size = BYTE_GET (echdr->ch_size);
6153 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
6154 return sizeof (*echdr);
6155 }
6156}
6157
6158static bfd_boolean
6159process_section_headers (Filedata * filedata)
6160{
6161 Elf_Internal_Shdr * section;
6162 unsigned int i;
6163
6164 free (filedata->section_headers);
6165 filedata->section_headers = NULL;
6166 free (filedata->dynamic_symbols);
6167 filedata->dynamic_symbols = NULL;
6168 filedata->num_dynamic_syms = 0;
6169 free (filedata->dynamic_strings);
6170 filedata->dynamic_strings = NULL;
6171 filedata->dynamic_strings_length = 0;
6172 free (filedata->dynamic_syminfo);
6173 filedata->dynamic_syminfo = NULL;
6174 while (filedata->symtab_shndx_list != NULL)
6175 {
6176 elf_section_list *next = filedata->symtab_shndx_list->next;
6177 free (filedata->symtab_shndx_list);
6178 filedata->symtab_shndx_list = next;
6179 }
6180
6181 if (filedata->file_header.e_shnum == 0)
6182 {
6183 /* PR binutils/12467. */
6184 if (filedata->file_header.e_shoff != 0)
6185 {
6186 warn (_("possibly corrupt ELF file header - it has a non-zero"
6187 " section header offset, but no section headers\n"));
6188 return FALSE;
6189 }
6190 else if (do_sections)
6191 printf (_("\nThere are no sections in this file.\n"));
6192
6193 return TRUE;
6194 }
6195
6196 if (do_sections && !do_header)
6197 printf (ngettext ("There is %d section header, "
6198 "starting at offset 0x%lx:\n",
6199 "There are %d section headers, "
6200 "starting at offset 0x%lx:\n",
6201 filedata->file_header.e_shnum),
6202 filedata->file_header.e_shnum,
6203 (unsigned long) filedata->file_header.e_shoff);
6204
6205 if (is_32bit_elf)
6206 {
6207 if (! get_32bit_section_headers (filedata, FALSE))
6208 return FALSE;
6209 }
6210 else
6211 {
6212 if (! get_64bit_section_headers (filedata, FALSE))
6213 return FALSE;
6214 }
6215
6216 /* Read in the string table, so that we have names to display. */
6217 if (filedata->file_header.e_shstrndx != SHN_UNDEF
6218 && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
6219 {
6220 section = filedata->section_headers + filedata->file_header.e_shstrndx;
6221
6222 if (section->sh_size != 0)
6223 {
6224 filedata->string_table = (char *) get_data (NULL, filedata, section->sh_offset,
6225 1, section->sh_size,
6226 _("string table"));
6227
6228 filedata->string_table_length = filedata->string_table != NULL ? section->sh_size : 0;
6229 }
6230 }
6231
6232 /* Scan the sections for the dynamic symbol table
6233 and dynamic string table and debug sections. */
6234 eh_addr_size = is_32bit_elf ? 4 : 8;
6235 switch (filedata->file_header.e_machine)
6236 {
6237 case EM_MIPS:
6238 case EM_MIPS_RS3_LE:
6239 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6240 FDE addresses. However, the ABI also has a semi-official ILP32
6241 variant for which the normal FDE address size rules apply.
6242
6243 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6244 section, where XX is the size of longs in bits. Unfortunately,
6245 earlier compilers provided no way of distinguishing ILP32 objects
6246 from LP64 objects, so if there's any doubt, we should assume that
6247 the official LP64 form is being used. */
6248 if ((filedata->file_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
6249 && find_section (filedata, ".gcc_compiled_long32") == NULL)
6250 eh_addr_size = 8;
6251 break;
6252
6253 case EM_H8_300:
6254 case EM_H8_300H:
6255 switch (filedata->file_header.e_flags & EF_H8_MACH)
6256 {
6257 case E_H8_MACH_H8300:
6258 case E_H8_MACH_H8300HN:
6259 case E_H8_MACH_H8300SN:
6260 case E_H8_MACH_H8300SXN:
6261 eh_addr_size = 2;
6262 break;
6263 case E_H8_MACH_H8300H:
6264 case E_H8_MACH_H8300S:
6265 case E_H8_MACH_H8300SX:
6266 eh_addr_size = 4;
6267 break;
6268 }
6269 break;
6270
6271 case EM_M32C_OLD:
6272 case EM_M32C:
6273 switch (filedata->file_header.e_flags & EF_M32C_CPU_MASK)
6274 {
6275 case EF_M32C_CPU_M16C:
6276 eh_addr_size = 2;
6277 break;
6278 }
6279 break;
6280 }
6281
6282#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6283 do \
6284 { \
6285 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6286 if (section->sh_entsize != expected_entsize) \
6287 { \
6288 char buf[40]; \
6289 sprintf_vma (buf, section->sh_entsize); \
6290 /* Note: coded this way so that there is a single string for \
6291 translation. */ \
6292 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6293 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6294 (unsigned) expected_entsize); \
6295 section->sh_entsize = expected_entsize; \
6296 } \
6297 } \
6298 while (0)
6299
6300#define CHECK_ENTSIZE(section, i, type) \
6301 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6302 sizeof (Elf64_External_##type))
6303
6304 for (i = 0, section = filedata->section_headers;
6305 i < filedata->file_header.e_shnum;
6306 i++, section++)
6307 {
6308 char * name = SECTION_NAME (section);
6309
6310 /* Run some sanity checks on the headers and
6311 possibly fill in some file data as well. */
6312 switch (section->sh_type)
6313 {
6314 case SHT_DYNSYM:
6315 if (filedata->dynamic_symbols != NULL)
6316 {
6317 error (_("File contains multiple dynamic symbol tables\n"));
6318 continue;
6319 }
6320
6321 CHECK_ENTSIZE (section, i, Sym);
6322 filedata->dynamic_symbols
6323 = GET_ELF_SYMBOLS (filedata, section, &filedata->num_dynamic_syms);
6324 filedata->dynamic_symtab_section = section;
6325 break;
6326
6327 case SHT_STRTAB:
6328 if (streq (name, ".dynstr"))
6329 {
6330 if (filedata->dynamic_strings != NULL)
6331 {
6332 error (_("File contains multiple dynamic string tables\n"));
6333 continue;
6334 }
6335
6336 filedata->dynamic_strings
6337 = (char *) get_data (NULL, filedata, section->sh_offset,
6338 1, section->sh_size, _("dynamic strings"));
6339 filedata->dynamic_strings_length
6340 = filedata->dynamic_strings == NULL ? 0 : section->sh_size;
6341 filedata->dynamic_strtab_section = section;
6342 }
6343 break;
6344
6345 case SHT_SYMTAB_SHNDX:
6346 {
6347 elf_section_list * entry = xmalloc (sizeof * entry);
6348
6349 entry->hdr = section;
6350 entry->next = filedata->symtab_shndx_list;
6351 filedata->symtab_shndx_list = entry;
6352 }
6353 break;
6354
6355 case SHT_SYMTAB:
6356 CHECK_ENTSIZE (section, i, Sym);
6357 break;
6358
6359 case SHT_GROUP:
6360 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6361 break;
6362
6363 case SHT_REL:
6364 CHECK_ENTSIZE (section, i, Rel);
6365 if (do_checks && section->sh_size == 0)
6366 warn (_("Section '%s': zero-sized relocation section\n"), name);
6367 break;
6368
6369 case SHT_RELA:
6370 CHECK_ENTSIZE (section, i, Rela);
6371 if (do_checks && section->sh_size == 0)
6372 warn (_("Section '%s': zero-sized relocation section\n"), name);
6373 break;
6374
6375 case SHT_NOTE:
6376 case SHT_PROGBITS:
6377 /* Having a zero sized section is not illegal according to the
6378 ELF standard, but it might be an indication that something
6379 is wrong. So issue a warning if we are running in lint mode. */
6380 if (do_checks && section->sh_size == 0)
6381 warn (_("Section '%s': has a size of zero - is this intended ?\n"), name);
6382 break;
6383
6384 default:
6385 break;
6386 }
6387
6388 if ((do_debugging || do_debug_info || do_debug_abbrevs
6389 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
6390 || do_debug_aranges || do_debug_frames || do_debug_macinfo
6391 || do_debug_str || do_debug_str_offsets || do_debug_loc || do_debug_ranges
6392 || do_debug_addr || do_debug_cu_index || do_debug_links)
6393 && (const_strneq (name, ".debug_")
6394 || const_strneq (name, ".zdebug_")))
6395 {
6396 if (name[1] == 'z')
6397 name += sizeof (".zdebug_") - 1;
6398 else
6399 name += sizeof (".debug_") - 1;
6400
6401 if (do_debugging
6402 || (do_debug_info && const_strneq (name, "info"))
6403 || (do_debug_info && const_strneq (name, "types"))
6404 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
6405 || (do_debug_lines && strcmp (name, "line") == 0)
6406 || (do_debug_lines && const_strneq (name, "line."))
6407 || (do_debug_pubnames && const_strneq (name, "pubnames"))
6408 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6409 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6410 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6411 || (do_debug_aranges && const_strneq (name, "aranges"))
6412 || (do_debug_ranges && const_strneq (name, "ranges"))
6413 || (do_debug_ranges && const_strneq (name, "rnglists"))
6414 || (do_debug_frames && const_strneq (name, "frame"))
6415 || (do_debug_macinfo && const_strneq (name, "macinfo"))
6416 || (do_debug_macinfo && const_strneq (name, "macro"))
6417 || (do_debug_str && const_strneq (name, "str"))
6418 || (do_debug_str_offsets && const_strneq (name, "str_offsets"))
6419 || (do_debug_loc && const_strneq (name, "loc"))
6420 || (do_debug_loc && const_strneq (name, "loclists"))
6421 || (do_debug_addr && const_strneq (name, "addr"))
6422 || (do_debug_cu_index && const_strneq (name, "cu_index"))
6423 || (do_debug_cu_index && const_strneq (name, "tu_index"))
6424 )
6425 request_dump_bynumber (&filedata->dump, i, DEBUG_DUMP);
6426 }
6427 /* Linkonce section to be combined with .debug_info at link time. */
6428 else if ((do_debugging || do_debug_info)
6429 && const_strneq (name, ".gnu.linkonce.wi."))
6430 request_dump_bynumber (&filedata->dump, i, DEBUG_DUMP);
6431 else if (do_debug_frames && streq (name, ".eh_frame"))
6432 request_dump_bynumber (&filedata->dump, i, DEBUG_DUMP);
6433 else if (do_gdb_index && (streq (name, ".gdb_index")
6434 || streq (name, ".debug_names")))
6435 request_dump_bynumber (&filedata->dump, i, DEBUG_DUMP);
6436 /* Trace sections for Itanium VMS. */
6437 else if ((do_debugging || do_trace_info || do_trace_abbrevs
6438 || do_trace_aranges)
6439 && const_strneq (name, ".trace_"))
6440 {
6441 name += sizeof (".trace_") - 1;
6442
6443 if (do_debugging
6444 || (do_trace_info && streq (name, "info"))
6445 || (do_trace_abbrevs && streq (name, "abbrev"))
6446 || (do_trace_aranges && streq (name, "aranges"))
6447 )
6448 request_dump_bynumber (&filedata->dump, i, DEBUG_DUMP);
6449 }
6450 else if ((do_debugging || do_debug_links)
6451 && (const_strneq (name, ".gnu_debuglink")
6452 || const_strneq (name, ".gnu_debugaltlink")))
6453 request_dump_bynumber (&filedata->dump, i, DEBUG_DUMP);
6454 }
6455
6456 if (! do_sections)
6457 return TRUE;
6458
6459 if (filedata->file_header.e_shnum > 1)
6460 printf (_("\nSection Headers:\n"));
6461 else
6462 printf (_("\nSection Header:\n"));
6463
6464 if (is_32bit_elf)
6465 {
6466 if (do_section_details)
6467 {
6468 printf (_(" [Nr] Name\n"));
6469 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6470 }
6471 else
6472 printf
6473 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6474 }
6475 else if (do_wide)
6476 {
6477 if (do_section_details)
6478 {
6479 printf (_(" [Nr] Name\n"));
6480 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6481 }
6482 else
6483 printf
6484 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6485 }
6486 else
6487 {
6488 if (do_section_details)
6489 {
6490 printf (_(" [Nr] Name\n"));
6491 printf (_(" Type Address Offset Link\n"));
6492 printf (_(" Size EntSize Info Align\n"));
6493 }
6494 else
6495 {
6496 printf (_(" [Nr] Name Type Address Offset\n"));
6497 printf (_(" Size EntSize Flags Link Info Align\n"));
6498 }
6499 }
6500
6501 if (do_section_details)
6502 printf (_(" Flags\n"));
6503
6504 for (i = 0, section = filedata->section_headers;
6505 i < filedata->file_header.e_shnum;
6506 i++, section++)
6507 {
6508 /* Run some sanity checks on the section header. */
6509
6510 /* Check the sh_link field. */
6511 switch (section->sh_type)
6512 {
6513 case SHT_REL:
6514 case SHT_RELA:
6515 if (section->sh_link == 0
6516 && (filedata->file_header.e_type == ET_EXEC
6517 || filedata->file_header.e_type == ET_DYN))
6518 /* A dynamic relocation section where all entries use a
6519 zero symbol index need not specify a symtab section. */
6520 break;
6521 /* Fall through. */
6522 case SHT_SYMTAB_SHNDX:
6523 case SHT_GROUP:
6524 case SHT_HASH:
6525 case SHT_GNU_HASH:
6526 case SHT_GNU_versym:
6527 if (section->sh_link == 0
6528 || section->sh_link >= filedata->file_header.e_shnum
6529 || (filedata->section_headers[section->sh_link].sh_type != SHT_SYMTAB
6530 && filedata->section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6531 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6532 i, section->sh_link);
6533 break;
6534
6535 case SHT_DYNAMIC:
6536 case SHT_SYMTAB:
6537 case SHT_DYNSYM:
6538 case SHT_GNU_verneed:
6539 case SHT_GNU_verdef:
6540 case SHT_GNU_LIBLIST:
6541 if (section->sh_link == 0
6542 || section->sh_link >= filedata->file_header.e_shnum
6543 || filedata->section_headers[section->sh_link].sh_type != SHT_STRTAB)
6544 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6545 i, section->sh_link);
6546 break;
6547
6548 case SHT_INIT_ARRAY:
6549 case SHT_FINI_ARRAY:
6550 case SHT_PREINIT_ARRAY:
6551 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6552 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6553 i, section->sh_link);
6554 break;
6555
6556 default:
6557 /* FIXME: Add support for target specific section types. */
6558#if 0 /* Currently we do not check other section types as there are too
6559 many special cases. Stab sections for example have a type
6560 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6561 section. */
6562 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6563 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6564 i, section->sh_link);
6565#endif
6566 break;
6567 }
6568
6569 /* Check the sh_info field. */
6570 switch (section->sh_type)
6571 {
6572 case SHT_REL:
6573 case SHT_RELA:
6574 if (section->sh_info == 0
6575 && (filedata->file_header.e_type == ET_EXEC
6576 || filedata->file_header.e_type == ET_DYN))
6577 /* Dynamic relocations apply to segments, so they do not
6578 need to specify the section they relocate. */
6579 break;
6580 if (section->sh_info == 0
6581 || section->sh_info >= filedata->file_header.e_shnum
6582 || (filedata->section_headers[section->sh_info].sh_type != SHT_PROGBITS
6583 && filedata->section_headers[section->sh_info].sh_type != SHT_NOBITS
6584 && filedata->section_headers[section->sh_info].sh_type != SHT_NOTE
6585 && filedata->section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6586 && filedata->section_headers[section->sh_info].sh_type != SHT_FINI_ARRAY
6587 && filedata->section_headers[section->sh_info].sh_type != SHT_PREINIT_ARRAY
6588 /* FIXME: Are other section types valid ? */
6589 && filedata->section_headers[section->sh_info].sh_type < SHT_LOOS))
6590 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6591 i, section->sh_info);
6592 break;
6593
6594 case SHT_DYNAMIC:
6595 case SHT_HASH:
6596 case SHT_SYMTAB_SHNDX:
6597 case SHT_INIT_ARRAY:
6598 case SHT_FINI_ARRAY:
6599 case SHT_PREINIT_ARRAY:
6600 if (section->sh_info != 0)
6601 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6602 i, section->sh_info);
6603 break;
6604
6605 case SHT_GROUP:
6606 case SHT_SYMTAB:
6607 case SHT_DYNSYM:
6608 /* A symbol index - we assume that it is valid. */
6609 break;
6610
6611 default:
6612 /* FIXME: Add support for target specific section types. */
6613 if (section->sh_type == SHT_NOBITS)
6614 /* NOBITS section headers with non-zero sh_info fields can be
6615 created when a binary is stripped of everything but its debug
6616 information. The stripped sections have their headers
6617 preserved but their types set to SHT_NOBITS. So do not check
6618 this type of section. */
6619 ;
6620 else if (section->sh_flags & SHF_INFO_LINK)
6621 {
6622 if (section->sh_info < 1 || section->sh_info >= filedata->file_header.e_shnum)
6623 warn (_("[%2u]: Expected link to another section in info field"), i);
6624 }
6625 else if (section->sh_type < SHT_LOOS
6626 && (section->sh_flags & SHF_GNU_MBIND) == 0
6627 && section->sh_info != 0)
6628 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6629 i, section->sh_info);
6630 break;
6631 }
6632
6633 /* Check the sh_size field. */
6634 if (section->sh_size > filedata->file_size
6635 && section->sh_type != SHT_NOBITS
6636 && section->sh_type != SHT_NULL
6637 && section->sh_type < SHT_LOOS)
6638 warn (_("Size of section %u is larger than the entire file!\n"), i);
6639
6640 printf (" [%2u] ", i);
6641 if (do_section_details)
6642 printf ("%s\n ", printable_section_name (filedata, section));
6643 else
6644 print_symbol (-17, SECTION_NAME (section));
6645
6646 printf (do_wide ? " %-15s " : " %-15.15s ",
6647 get_section_type_name (filedata, section->sh_type));
6648
6649 if (is_32bit_elf)
6650 {
6651 const char * link_too_big = NULL;
6652
6653 print_vma (section->sh_addr, LONG_HEX);
6654
6655 printf ( " %6.6lx %6.6lx %2.2lx",
6656 (unsigned long) section->sh_offset,
6657 (unsigned long) section->sh_size,
6658 (unsigned long) section->sh_entsize);
6659
6660 if (do_section_details)
6661 fputs (" ", stdout);
6662 else
6663 printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6664
6665 if (section->sh_link >= filedata->file_header.e_shnum)
6666 {
6667 link_too_big = "";
6668 /* The sh_link value is out of range. Normally this indicates
6669 an error but it can have special values in Solaris binaries. */
6670 switch (filedata->file_header.e_machine)
6671 {
6672 case EM_386:
6673 case EM_IAMCU:
6674 case EM_X86_64:
6675 case EM_L1OM:
6676 case EM_K1OM:
6677 case EM_OLD_SPARCV9:
6678 case EM_SPARC32PLUS:
6679 case EM_SPARCV9:
6680 case EM_SPARC:
6681 if (section->sh_link == (SHN_BEFORE & 0xffff))
6682 link_too_big = "BEFORE";
6683 else if (section->sh_link == (SHN_AFTER & 0xffff))
6684 link_too_big = "AFTER";
6685 break;
6686 default:
6687 break;
6688 }
6689 }
6690
6691 if (do_section_details)
6692 {
6693 if (link_too_big != NULL && * link_too_big)
6694 printf ("<%s> ", link_too_big);
6695 else
6696 printf ("%2u ", section->sh_link);
6697 printf ("%3u %2lu\n", section->sh_info,
6698 (unsigned long) section->sh_addralign);
6699 }
6700 else
6701 printf ("%2u %3u %2lu\n",
6702 section->sh_link,
6703 section->sh_info,
6704 (unsigned long) section->sh_addralign);
6705
6706 if (link_too_big && ! * link_too_big)
6707 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6708 i, section->sh_link);
6709 }
6710 else if (do_wide)
6711 {
6712 print_vma (section->sh_addr, LONG_HEX);
6713
6714 if ((long) section->sh_offset == section->sh_offset)
6715 printf (" %6.6lx", (unsigned long) section->sh_offset);
6716 else
6717 {
6718 putchar (' ');
6719 print_vma (section->sh_offset, LONG_HEX);
6720 }
6721
6722 if ((unsigned long) section->sh_size == section->sh_size)
6723 printf (" %6.6lx", (unsigned long) section->sh_size);
6724 else
6725 {
6726 putchar (' ');
6727 print_vma (section->sh_size, LONG_HEX);
6728 }
6729
6730 if ((unsigned long) section->sh_entsize == section->sh_entsize)
6731 printf (" %2.2lx", (unsigned long) section->sh_entsize);
6732 else
6733 {
6734 putchar (' ');
6735 print_vma (section->sh_entsize, LONG_HEX);
6736 }
6737
6738 if (do_section_details)
6739 fputs (" ", stdout);
6740 else
6741 printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6742
6743 printf ("%2u %3u ", section->sh_link, section->sh_info);
6744
6745 if ((unsigned long) section->sh_addralign == section->sh_addralign)
6746 printf ("%2lu\n", (unsigned long) section->sh_addralign);
6747 else
6748 {
6749 print_vma (section->sh_addralign, DEC);
6750 putchar ('\n');
6751 }
6752 }
6753 else if (do_section_details)
6754 {
6755 putchar (' ');
6756 print_vma (section->sh_addr, LONG_HEX);
6757 if ((long) section->sh_offset == section->sh_offset)
6758 printf (" %16.16lx", (unsigned long) section->sh_offset);
6759 else
6760 {
6761 printf (" ");
6762 print_vma (section->sh_offset, LONG_HEX);
6763 }
6764 printf (" %u\n ", section->sh_link);
6765 print_vma (section->sh_size, LONG_HEX);
6766 putchar (' ');
6767 print_vma (section->sh_entsize, LONG_HEX);
6768
6769 printf (" %-16u %lu\n",
6770 section->sh_info,
6771 (unsigned long) section->sh_addralign);
6772 }
6773 else
6774 {
6775 putchar (' ');
6776 print_vma (section->sh_addr, LONG_HEX);
6777 if ((long) section->sh_offset == section->sh_offset)
6778 printf (" %8.8lx", (unsigned long) section->sh_offset);
6779 else
6780 {
6781 printf (" ");
6782 print_vma (section->sh_offset, LONG_HEX);
6783 }
6784 printf ("\n ");
6785 print_vma (section->sh_size, LONG_HEX);
6786 printf (" ");
6787 print_vma (section->sh_entsize, LONG_HEX);
6788
6789 printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6790
6791 printf (" %2u %3u %lu\n",
6792 section->sh_link,
6793 section->sh_info,
6794 (unsigned long) section->sh_addralign);
6795 }
6796
6797 if (do_section_details)
6798 {
6799 printf (" %s\n", get_elf_section_flags (filedata, section->sh_flags));
6800 if ((section->sh_flags & SHF_COMPRESSED) != 0)
6801 {
6802 /* Minimum section size is 12 bytes for 32-bit compression
6803 header + 12 bytes for compressed data header. */
6804 unsigned char buf[24];
6805
6806 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6807 if (get_data (&buf, filedata, section->sh_offset, 1,
6808 sizeof (buf), _("compression header")))
6809 {
6810 Elf_Internal_Chdr chdr;
6811
6812 if (get_compression_header (&chdr, buf, sizeof (buf)) == 0)
6813 printf (_(" [<corrupt>]\n"));
6814 else
6815 {
6816 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6817 printf (" ZLIB, ");
6818 else
6819 printf (_(" [<unknown>: 0x%x], "),
6820 chdr.ch_type);
6821 print_vma (chdr.ch_size, LONG_HEX);
6822 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6823 }
6824 }
6825 }
6826 }
6827 }
6828
6829 if (!do_section_details)
6830 {
6831 /* The ordering of the letters shown here matches the ordering of the
6832 corresponding SHF_xxx values, and hence the order in which these
6833 letters will be displayed to the user. */
6834 printf (_("Key to Flags:\n\
6835 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6836 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6837 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6838 if (filedata->file_header.e_machine == EM_X86_64
6839 || filedata->file_header.e_machine == EM_L1OM
6840 || filedata->file_header.e_machine == EM_K1OM)
6841 printf (_("l (large), "));
6842 else if (filedata->file_header.e_machine == EM_ARM)
6843 printf (_("y (purecode), "));
6844 else if (filedata->file_header.e_machine == EM_PPC)
6845 printf (_("v (VLE), "));
6846 printf ("p (processor specific)\n");
6847 }
6848
6849 return TRUE;
6850}
6851
6852static bfd_boolean
6853get_symtab (Filedata *filedata, Elf_Internal_Shdr *symsec,
6854 Elf_Internal_Sym **symtab, unsigned long *nsyms,
6855 char **strtab, unsigned long *strtablen)
6856{
6857 *strtab = NULL;
6858 *strtablen = 0;
6859 *symtab = GET_ELF_SYMBOLS (filedata, symsec, nsyms);
6860
6861 if (*symtab == NULL)
6862 return FALSE;
6863
6864 if (symsec->sh_link != 0)
6865 {
6866 Elf_Internal_Shdr *strsec;
6867
6868 if (symsec->sh_link >= filedata->file_header.e_shnum)
6869 {
6870 error (_("Bad sh_link in symbol table section\n"));
6871 free (*symtab);
6872 *symtab = NULL;
6873 *nsyms = 0;
6874 return FALSE;
6875 }
6876
6877 strsec = filedata->section_headers + symsec->sh_link;
6878
6879 *strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
6880 1, strsec->sh_size, _("string table"));
6881 if (*strtab == NULL)
6882 {
6883 free (*symtab);
6884 *symtab = NULL;
6885 *nsyms = 0;
6886 return FALSE;
6887 }
6888 *strtablen = strsec->sh_size;
6889 }
6890 return TRUE;
6891}
6892
6893static const char *
6894get_group_flags (unsigned int flags)
6895{
6896 static char buff[128];
6897
6898 if (flags == 0)
6899 return "";
6900 else if (flags == GRP_COMDAT)
6901 return "COMDAT ";
6902
6903 snprintf (buff, sizeof buff, "[0x%x: %s%s%s]",
6904 flags,
6905 flags & GRP_MASKOS ? _("<OS specific>") : "",
6906 flags & GRP_MASKPROC ? _("<PROC specific>") : "",
6907 (flags & ~(GRP_COMDAT | GRP_MASKOS | GRP_MASKPROC)
6908 ? _("<unknown>") : ""));
6909
6910 return buff;
6911}
6912
6913static bfd_boolean
6914process_section_groups (Filedata * filedata)
6915{
6916 Elf_Internal_Shdr * section;
6917 unsigned int i;
6918 struct group * group;
6919 Elf_Internal_Shdr * symtab_sec;
6920 Elf_Internal_Shdr * strtab_sec;
6921 Elf_Internal_Sym * symtab;
6922 unsigned long num_syms;
6923 char * strtab;
6924 size_t strtab_size;
6925
6926 /* Don't process section groups unless needed. */
6927 if (!do_unwind && !do_section_groups)
6928 return TRUE;
6929
6930 if (filedata->file_header.e_shnum == 0)
6931 {
6932 if (do_section_groups)
6933 printf (_("\nThere are no sections to group in this file.\n"));
6934
6935 return TRUE;
6936 }
6937
6938 if (filedata->section_headers == NULL)
6939 {
6940 error (_("Section headers are not available!\n"));
6941 /* PR 13622: This can happen with a corrupt ELF header. */
6942 return FALSE;
6943 }
6944
6945 filedata->section_headers_groups
6946 = (struct group **) calloc (filedata->file_header.e_shnum,
6947 sizeof (struct group *));
6948
6949 if (filedata->section_headers_groups == NULL)
6950 {
6951 error (_("Out of memory reading %u section group headers\n"),
6952 filedata->file_header.e_shnum);
6953 return FALSE;
6954 }
6955
6956 /* Scan the sections for the group section. */
6957 filedata->group_count = 0;
6958 for (i = 0, section = filedata->section_headers;
6959 i < filedata->file_header.e_shnum;
6960 i++, section++)
6961 if (section->sh_type == SHT_GROUP)
6962 filedata->group_count++;
6963
6964 if (filedata->group_count == 0)
6965 {
6966 if (do_section_groups)
6967 printf (_("\nThere are no section groups in this file.\n"));
6968
6969 return TRUE;
6970 }
6971
6972 filedata->section_groups = (struct group *) calloc (filedata->group_count,
6973 sizeof (struct group));
6974
6975 if (filedata->section_groups == NULL)
6976 {
6977 error (_("Out of memory reading %lu groups\n"),
6978 (unsigned long) filedata->group_count);
6979 return FALSE;
6980 }
6981
6982 symtab_sec = NULL;
6983 strtab_sec = NULL;
6984 symtab = NULL;
6985 num_syms = 0;
6986 strtab = NULL;
6987 strtab_size = 0;
6988 for (i = 0, section = filedata->section_headers, group = filedata->section_groups;
6989 i < filedata->file_header.e_shnum;
6990 i++, section++)
6991 {
6992 if (section->sh_type == SHT_GROUP)
6993 {
6994 const char * name = printable_section_name (filedata, section);
6995 const char * group_name;
6996 unsigned char * start;
6997 unsigned char * indices;
6998 unsigned int entry, j, size;
6999 Elf_Internal_Shdr * sec;
7000 Elf_Internal_Sym * sym;
7001
7002 /* Get the symbol table. */
7003 if (section->sh_link >= filedata->file_header.e_shnum
7004 || ((sec = filedata->section_headers + section->sh_link)->sh_type
7005 != SHT_SYMTAB))
7006 {
7007 error (_("Bad sh_link in group section `%s'\n"), name);
7008 continue;
7009 }
7010
7011 if (symtab_sec != sec)
7012 {
7013 symtab_sec = sec;
7014 free (symtab);
7015 symtab = GET_ELF_SYMBOLS (filedata, symtab_sec, & num_syms);
7016 }
7017
7018 if (symtab == NULL)
7019 {
7020 error (_("Corrupt header in group section `%s'\n"), name);
7021 continue;
7022 }
7023
7024 if (section->sh_info >= num_syms)
7025 {
7026 error (_("Bad sh_info in group section `%s'\n"), name);
7027 continue;
7028 }
7029
7030 sym = symtab + section->sh_info;
7031
7032 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
7033 {
7034 if (sym->st_shndx == 0
7035 || sym->st_shndx >= filedata->file_header.e_shnum)
7036 {
7037 error (_("Bad sh_info in group section `%s'\n"), name);
7038 continue;
7039 }
7040
7041 group_name = SECTION_NAME (filedata->section_headers + sym->st_shndx);
7042 strtab_sec = NULL;
7043 free (strtab);
7044 strtab = NULL;
7045 strtab_size = 0;
7046 }
7047 else
7048 {
7049 /* Get the string table. */
7050 if (symtab_sec->sh_link >= filedata->file_header.e_shnum)
7051 {
7052 strtab_sec = NULL;
7053 free (strtab);
7054 strtab = NULL;
7055 strtab_size = 0;
7056 }
7057 else if (strtab_sec
7058 != (sec = filedata->section_headers + symtab_sec->sh_link))
7059 {
7060 strtab_sec = sec;
7061 free (strtab);
7062
7063 strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
7064 1, strtab_sec->sh_size,
7065 _("string table"));
7066 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
7067 }
7068 group_name = sym->st_name < strtab_size
7069 ? strtab + sym->st_name : _("<corrupt>");
7070 }
7071
7072 /* PR 17531: file: loop. */
7073 if (section->sh_entsize > section->sh_size)
7074 {
7075 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
7076 printable_section_name (filedata, section),
7077 (unsigned long) section->sh_entsize,
7078 (unsigned long) section->sh_size);
7079 continue;
7080 }
7081
7082 start = (unsigned char *) get_data (NULL, filedata, section->sh_offset,
7083 1, section->sh_size,
7084 _("section data"));
7085 if (start == NULL)
7086 continue;
7087
7088 indices = start;
7089 size = (section->sh_size / section->sh_entsize) - 1;
7090 entry = byte_get (indices, 4);
7091 indices += 4;
7092
7093 if (do_section_groups)
7094 {
7095 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
7096 get_group_flags (entry), i, name, group_name, size);
7097
7098 printf (_(" [Index] Name\n"));
7099 }
7100
7101 group->group_index = i;
7102
7103 for (j = 0; j < size; j++)
7104 {
7105 struct group_list * g;
7106
7107 entry = byte_get (indices, 4);
7108 indices += 4;
7109
7110 if (entry >= filedata->file_header.e_shnum)
7111 {
7112 static unsigned num_group_errors = 0;
7113
7114 if (num_group_errors ++ < 10)
7115 {
7116 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
7117 entry, i, filedata->file_header.e_shnum - 1);
7118 if (num_group_errors == 10)
7119 warn (_("Further error messages about overlarge group section indices suppressed\n"));
7120 }
7121 continue;
7122 }
7123
7124 if (filedata->section_headers_groups [entry] != NULL)
7125 {
7126 if (entry)
7127 {
7128 static unsigned num_errs = 0;
7129
7130 if (num_errs ++ < 10)
7131 {
7132 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7133 entry, i,
7134 filedata->section_headers_groups [entry]->group_index);
7135 if (num_errs == 10)
7136 warn (_("Further error messages about already contained group sections suppressed\n"));
7137 }
7138 continue;
7139 }
7140 else
7141 {
7142 /* Intel C/C++ compiler may put section 0 in a
7143 section group. We just warn it the first time
7144 and ignore it afterwards. */
7145 static bfd_boolean warned = FALSE;
7146 if (!warned)
7147 {
7148 error (_("section 0 in group section [%5u]\n"),
7149 filedata->section_headers_groups [entry]->group_index);
7150 warned = TRUE;
7151 }
7152 }
7153 }
7154
7155 filedata->section_headers_groups [entry] = group;
7156
7157 if (do_section_groups)
7158 {
7159 sec = filedata->section_headers + entry;
7160 printf (" [%5u] %s\n", entry, printable_section_name (filedata, sec));
7161 }
7162
7163 g = (struct group_list *) xmalloc (sizeof (struct group_list));
7164 g->section_index = entry;
7165 g->next = group->root;
7166 group->root = g;
7167 }
7168
7169 free (start);
7170
7171 group++;
7172 }
7173 }
7174
7175 free (symtab);
7176 free (strtab);
7177 return TRUE;
7178}
7179
7180/* Data used to display dynamic fixups. */
7181
7182struct ia64_vms_dynfixup
7183{
7184 bfd_vma needed_ident; /* Library ident number. */
7185 bfd_vma needed; /* Index in the dstrtab of the library name. */
7186 bfd_vma fixup_needed; /* Index of the library. */
7187 bfd_vma fixup_rela_cnt; /* Number of fixups. */
7188 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
7189};
7190
7191/* Data used to display dynamic relocations. */
7192
7193struct ia64_vms_dynimgrela
7194{
7195 bfd_vma img_rela_cnt; /* Number of relocations. */
7196 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
7197};
7198
7199/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7200 library). */
7201
7202static bfd_boolean
7203dump_ia64_vms_dynamic_fixups (Filedata * filedata,
7204 struct ia64_vms_dynfixup * fixup,
7205 const char * strtab,
7206 unsigned int strtab_sz)
7207{
7208 Elf64_External_VMS_IMAGE_FIXUP * imfs;
7209 long i;
7210 const char * lib_name;
7211
7212 imfs = get_data (NULL, filedata,
7213 filedata->dynamic_addr + fixup->fixup_rela_off,
7214 sizeof (*imfs), fixup->fixup_rela_cnt,
7215 _("dynamic section image fixups"));
7216 if (!imfs)
7217 return FALSE;
7218
7219 if (fixup->needed < strtab_sz)
7220 lib_name = strtab + fixup->needed;
7221 else
7222 {
7223 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7224 (unsigned long) fixup->needed);
7225 lib_name = "???";
7226 }
7227
7228 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7229 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
7230 printf
7231 (_("Seg Offset Type SymVec DataType\n"));
7232
7233 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
7234 {
7235 unsigned int type;
7236 const char *rtype;
7237
7238 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
7239 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
7240 type = BYTE_GET (imfs [i].type);
7241 rtype = elf_ia64_reloc_type (type);
7242 if (rtype == NULL)
7243 printf (" 0x%08x ", type);
7244 else
7245 printf (" %-32s ", rtype);
7246 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
7247 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
7248 }
7249
7250 free (imfs);
7251 return TRUE;
7252}
7253
7254/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7255
7256static bfd_boolean
7257dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *imgrela)
7258{
7259 Elf64_External_VMS_IMAGE_RELA *imrs;
7260 long i;
7261
7262 imrs = get_data (NULL, filedata,
7263 filedata->dynamic_addr + imgrela->img_rela_off,
7264 sizeof (*imrs), imgrela->img_rela_cnt,
7265 _("dynamic section image relocations"));
7266 if (!imrs)
7267 return FALSE;
7268
7269 printf (_("\nImage relocs\n"));
7270 printf
7271 (_("Seg Offset Type Addend Seg Sym Off\n"));
7272
7273 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
7274 {
7275 unsigned int type;
7276 const char *rtype;
7277
7278 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
7279 printf ("%08" BFD_VMA_FMT "x ",
7280 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
7281 type = BYTE_GET (imrs [i].type);
7282 rtype = elf_ia64_reloc_type (type);
7283 if (rtype == NULL)
7284 printf ("0x%08x ", type);
7285 else
7286 printf ("%-31s ", rtype);
7287 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
7288 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
7289 printf ("%08" BFD_VMA_FMT "x\n",
7290 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
7291 }
7292
7293 free (imrs);
7294 return TRUE;
7295}
7296
7297/* Display IA-64 OpenVMS dynamic relocations and fixups. */
7298
7299static bfd_boolean
7300process_ia64_vms_dynamic_relocs (Filedata * filedata)
7301{
7302 struct ia64_vms_dynfixup fixup;
7303 struct ia64_vms_dynimgrela imgrela;
7304 Elf_Internal_Dyn *entry;
7305 bfd_vma strtab_off = 0;
7306 bfd_vma strtab_sz = 0;
7307 char *strtab = NULL;
7308 bfd_boolean res = TRUE;
7309
7310 memset (&fixup, 0, sizeof (fixup));
7311 memset (&imgrela, 0, sizeof (imgrela));
7312
7313 /* Note: the order of the entries is specified by the OpenVMS specs. */
7314 for (entry = filedata->dynamic_section;
7315 entry < filedata->dynamic_section + filedata->dynamic_nent;
7316 entry++)
7317 {
7318 switch (entry->d_tag)
7319 {
7320 case DT_IA_64_VMS_STRTAB_OFFSET:
7321 strtab_off = entry->d_un.d_val;
7322 break;
7323 case DT_STRSZ:
7324 strtab_sz = entry->d_un.d_val;
7325 if (strtab == NULL)
7326 strtab = get_data (NULL, filedata,
7327 filedata->dynamic_addr + strtab_off,
7328 1, strtab_sz, _("dynamic string section"));
7329 if (strtab == NULL)
7330 strtab_sz = 0;
7331 break;
7332
7333 case DT_IA_64_VMS_NEEDED_IDENT:
7334 fixup.needed_ident = entry->d_un.d_val;
7335 break;
7336 case DT_NEEDED:
7337 fixup.needed = entry->d_un.d_val;
7338 break;
7339 case DT_IA_64_VMS_FIXUP_NEEDED:
7340 fixup.fixup_needed = entry->d_un.d_val;
7341 break;
7342 case DT_IA_64_VMS_FIXUP_RELA_CNT:
7343 fixup.fixup_rela_cnt = entry->d_un.d_val;
7344 break;
7345 case DT_IA_64_VMS_FIXUP_RELA_OFF:
7346 fixup.fixup_rela_off = entry->d_un.d_val;
7347 if (! dump_ia64_vms_dynamic_fixups (filedata, &fixup, strtab, strtab_sz))
7348 res = FALSE;
7349 break;
7350 case DT_IA_64_VMS_IMG_RELA_CNT:
7351 imgrela.img_rela_cnt = entry->d_un.d_val;
7352 break;
7353 case DT_IA_64_VMS_IMG_RELA_OFF:
7354 imgrela.img_rela_off = entry->d_un.d_val;
7355 if (! dump_ia64_vms_dynamic_relocs (filedata, &imgrela))
7356 res = FALSE;
7357 break;
7358
7359 default:
7360 break;
7361 }
7362 }
7363
7364 free (strtab);
7365
7366 return res;
7367}
7368
7369static struct
7370{
7371 const char * name;
7372 int reloc;
7373 int size;
7374 int rela;
7375}
7376 dynamic_relocations [] =
7377{
7378 { "REL", DT_REL, DT_RELSZ, FALSE },
7379 { "RELA", DT_RELA, DT_RELASZ, TRUE },
7380 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
7381};
7382
7383/* Process the reloc section. */
7384
7385static bfd_boolean
7386process_relocs (Filedata * filedata)
7387{
7388 unsigned long rel_size;
7389 unsigned long rel_offset;
7390
7391 if (!do_reloc)
7392 return TRUE;
7393
7394 if (do_using_dynamic)
7395 {
7396 int is_rela;
7397 const char * name;
7398 bfd_boolean has_dynamic_reloc;
7399 unsigned int i;
7400
7401 has_dynamic_reloc = FALSE;
7402
7403 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7404 {
7405 is_rela = dynamic_relocations [i].rela;
7406 name = dynamic_relocations [i].name;
7407 rel_size = filedata->dynamic_info[dynamic_relocations [i].size];
7408 rel_offset = filedata->dynamic_info[dynamic_relocations [i].reloc];
7409
7410 if (rel_size)
7411 has_dynamic_reloc = TRUE;
7412
7413 if (is_rela == UNKNOWN)
7414 {
7415 if (dynamic_relocations [i].reloc == DT_JMPREL)
7416 switch (filedata->dynamic_info[DT_PLTREL])
7417 {
7418 case DT_REL:
7419 is_rela = FALSE;
7420 break;
7421 case DT_RELA:
7422 is_rela = TRUE;
7423 break;
7424 }
7425 }
7426
7427 if (rel_size)
7428 {
7429 printf
7430 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7431 name, rel_offset, rel_size);
7432
7433 dump_relocations (filedata,
7434 offset_from_vma (filedata, rel_offset, rel_size),
7435 rel_size,
7436 filedata->dynamic_symbols,
7437 filedata->num_dynamic_syms,
7438 filedata->dynamic_strings,
7439 filedata->dynamic_strings_length,
7440 is_rela, TRUE /* is_dynamic */);
7441 }
7442 }
7443
7444 if (is_ia64_vms (filedata))
7445 if (process_ia64_vms_dynamic_relocs (filedata))
7446 has_dynamic_reloc = TRUE;
7447
7448 if (! has_dynamic_reloc)
7449 printf (_("\nThere are no dynamic relocations in this file.\n"));
7450 }
7451 else
7452 {
7453 Elf_Internal_Shdr * section;
7454 unsigned long i;
7455 bfd_boolean found = FALSE;
7456
7457 for (i = 0, section = filedata->section_headers;
7458 i < filedata->file_header.e_shnum;
7459 i++, section++)
7460 {
7461 if ( section->sh_type != SHT_RELA
7462 && section->sh_type != SHT_REL)
7463 continue;
7464
7465 rel_offset = section->sh_offset;
7466 rel_size = section->sh_size;
7467
7468 if (rel_size)
7469 {
7470 int is_rela;
7471 unsigned long num_rela;
7472
7473 printf (_("\nRelocation section "));
7474
7475 if (filedata->string_table == NULL)
7476 printf ("%d", section->sh_name);
7477 else
7478 printf ("'%s'", printable_section_name (filedata, section));
7479
7480 num_rela = rel_size / section->sh_entsize;
7481 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7482 " at offset 0x%lx contains %lu entries:\n",
7483 num_rela),
7484 rel_offset, num_rela);
7485
7486 is_rela = section->sh_type == SHT_RELA;
7487
7488 if (section->sh_link != 0
7489 && section->sh_link < filedata->file_header.e_shnum)
7490 {
7491 Elf_Internal_Shdr * symsec;
7492 Elf_Internal_Sym * symtab;
7493 unsigned long nsyms;
7494 unsigned long strtablen = 0;
7495 char * strtab = NULL;
7496
7497 symsec = filedata->section_headers + section->sh_link;
7498 if (symsec->sh_type != SHT_SYMTAB
7499 && symsec->sh_type != SHT_DYNSYM)
7500 continue;
7501
7502 if (!get_symtab (filedata, symsec,
7503 &symtab, &nsyms, &strtab, &strtablen))
7504 continue;
7505
7506 dump_relocations (filedata, rel_offset, rel_size,
7507 symtab, nsyms, strtab, strtablen,
7508 is_rela,
7509 symsec->sh_type == SHT_DYNSYM);
7510 free (strtab);
7511 free (symtab);
7512 }
7513 else
7514 dump_relocations (filedata, rel_offset, rel_size,
7515 NULL, 0, NULL, 0, is_rela,
7516 FALSE /* is_dynamic */);
7517
7518 found = TRUE;
7519 }
7520 }
7521
7522 if (! found)
7523 {
7524 /* Users sometimes forget the -D option, so try to be helpful. */
7525 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7526 {
7527 if (filedata->dynamic_info[dynamic_relocations [i].size])
7528 {
7529 printf (_("\nThere are no static relocations in this file."));
7530 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7531
7532 break;
7533 }
7534 }
7535 if (i == ARRAY_SIZE (dynamic_relocations))
7536 printf (_("\nThere are no relocations in this file.\n"));
7537 }
7538 }
7539
7540 return TRUE;
7541}
7542
7543/* An absolute address consists of a section and an offset. If the
7544 section is NULL, the offset itself is the address, otherwise, the
7545 address equals to LOAD_ADDRESS(section) + offset. */
7546
7547struct absaddr
7548{
7549 unsigned short section;
7550 bfd_vma offset;
7551};
7552
7553/* Find the nearest symbol at or below ADDR. Returns the symbol
7554 name, if found, and the offset from the symbol to ADDR. */
7555
7556static void
7557find_symbol_for_address (Filedata * filedata,
7558 Elf_Internal_Sym * symtab,
7559 unsigned long nsyms,
7560 const char * strtab,
7561 unsigned long strtab_size,
7562 struct absaddr addr,
7563 const char ** symname,
7564 bfd_vma * offset)
7565{
7566 bfd_vma dist = 0x100000;
7567 Elf_Internal_Sym * sym;
7568 Elf_Internal_Sym * beg;
7569 Elf_Internal_Sym * end;
7570 Elf_Internal_Sym * best = NULL;
7571
7572 REMOVE_ARCH_BITS (addr.offset);
7573 beg = symtab;
7574 end = symtab + nsyms;
7575
7576 while (beg < end)
7577 {
7578 bfd_vma value;
7579
7580 sym = beg + (end - beg) / 2;
7581
7582 value = sym->st_value;
7583 REMOVE_ARCH_BITS (value);
7584
7585 if (sym->st_name != 0
7586 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7587 && addr.offset >= value
7588 && addr.offset - value < dist)
7589 {
7590 best = sym;
7591 dist = addr.offset - value;
7592 if (!dist)
7593 break;
7594 }
7595
7596 if (addr.offset < value)
7597 end = sym;
7598 else
7599 beg = sym + 1;
7600 }
7601
7602 if (best)
7603 {
7604 *symname = (best->st_name >= strtab_size
7605 ? _("<corrupt>") : strtab + best->st_name);
7606 *offset = dist;
7607 return;
7608 }
7609
7610 *symname = NULL;
7611 *offset = addr.offset;
7612}
7613
7614static /* signed */ int
7615symcmp (const void *p, const void *q)
7616{
7617 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7618 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7619
7620 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7621}
7622
7623/* Process the unwind section. */
7624
7625#include "unwind-ia64.h"
7626
7627struct ia64_unw_table_entry
7628{
7629 struct absaddr start;
7630 struct absaddr end;
7631 struct absaddr info;
7632};
7633
7634struct ia64_unw_aux_info
7635{
7636 struct ia64_unw_table_entry * table; /* Unwind table. */
7637 unsigned long table_len; /* Length of unwind table. */
7638 unsigned char * info; /* Unwind info. */
7639 unsigned long info_size; /* Size of unwind info. */
7640 bfd_vma info_addr; /* Starting address of unwind info. */
7641 bfd_vma seg_base; /* Starting address of segment. */
7642 Elf_Internal_Sym * symtab; /* The symbol table. */
7643 unsigned long nsyms; /* Number of symbols. */
7644 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7645 unsigned long nfuns; /* Number of entries in funtab. */
7646 char * strtab; /* The string table. */
7647 unsigned long strtab_size; /* Size of string table. */
7648};
7649
7650static bfd_boolean
7651dump_ia64_unwind (Filedata * filedata, struct ia64_unw_aux_info * aux)
7652{
7653 struct ia64_unw_table_entry * tp;
7654 unsigned long j, nfuns;
7655 int in_body;
7656 bfd_boolean res = TRUE;
7657
7658 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7659 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7660 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7661 aux->funtab[nfuns++] = aux->symtab[j];
7662 aux->nfuns = nfuns;
7663 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7664
7665 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7666 {
7667 bfd_vma stamp;
7668 bfd_vma offset;
7669 const unsigned char * dp;
7670 const unsigned char * head;
7671 const unsigned char * end;
7672 const char * procname;
7673
7674 find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7675 aux->strtab_size, tp->start, &procname, &offset);
7676
7677 fputs ("\n<", stdout);
7678
7679 if (procname)
7680 {
7681 fputs (procname, stdout);
7682
7683 if (offset)
7684 printf ("+%lx", (unsigned long) offset);
7685 }
7686
7687 fputs (">: [", stdout);
7688 print_vma (tp->start.offset, PREFIX_HEX);
7689 fputc ('-', stdout);
7690 print_vma (tp->end.offset, PREFIX_HEX);
7691 printf ("], info at +0x%lx\n",
7692 (unsigned long) (tp->info.offset - aux->seg_base));
7693
7694 /* PR 17531: file: 86232b32. */
7695 if (aux->info == NULL)
7696 continue;
7697
7698 offset = tp->info.offset;
7699 if (tp->info.section)
7700 {
7701 if (tp->info.section >= filedata->file_header.e_shnum)
7702 {
7703 warn (_("Invalid section %u in table entry %ld\n"),
7704 tp->info.section, (long) (tp - aux->table));
7705 res = FALSE;
7706 continue;
7707 }
7708 offset += filedata->section_headers[tp->info.section].sh_addr;
7709 }
7710 offset -= aux->info_addr;
7711 /* PR 17531: file: 0997b4d1. */
7712 if (offset >= aux->info_size
7713 || aux->info_size - offset < 8)
7714 {
7715 warn (_("Invalid offset %lx in table entry %ld\n"),
7716 (long) tp->info.offset, (long) (tp - aux->table));
7717 res = FALSE;
7718 continue;
7719 }
7720
7721 head = aux->info + offset;
7722 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7723
7724 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7725 (unsigned) UNW_VER (stamp),
7726 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7727 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7728 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7729 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7730
7731 if (UNW_VER (stamp) != 1)
7732 {
7733 printf (_("\tUnknown version.\n"));
7734 continue;
7735 }
7736
7737 in_body = 0;
7738 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7739 /* PR 17531: file: 16ceda89. */
7740 if (end > aux->info + aux->info_size)
7741 end = aux->info + aux->info_size;
7742 for (dp = head + 8; dp < end;)
7743 dp = unw_decode (dp, in_body, & in_body, end);
7744 }
7745
7746 free (aux->funtab);
7747
7748 return res;
7749}
7750
7751static bfd_boolean
7752slurp_ia64_unwind_table (Filedata * filedata,
7753 struct ia64_unw_aux_info * aux,
7754 Elf_Internal_Shdr * sec)
7755{
7756 unsigned long size, nrelas, i;
7757 Elf_Internal_Phdr * seg;
7758 struct ia64_unw_table_entry * tep;
7759 Elf_Internal_Shdr * relsec;
7760 Elf_Internal_Rela * rela;
7761 Elf_Internal_Rela * rp;
7762 unsigned char * table;
7763 unsigned char * tp;
7764 Elf_Internal_Sym * sym;
7765 const char * relname;
7766
7767 aux->table_len = 0;
7768
7769 /* First, find the starting address of the segment that includes
7770 this section: */
7771
7772 if (filedata->file_header.e_phnum)
7773 {
7774 if (! get_program_headers (filedata))
7775 return FALSE;
7776
7777 for (seg = filedata->program_headers;
7778 seg < filedata->program_headers + filedata->file_header.e_phnum;
7779 ++seg)
7780 {
7781 if (seg->p_type != PT_LOAD)
7782 continue;
7783
7784 if (sec->sh_addr >= seg->p_vaddr
7785 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7786 {
7787 aux->seg_base = seg->p_vaddr;
7788 break;
7789 }
7790 }
7791 }
7792
7793 /* Second, build the unwind table from the contents of the unwind section: */
7794 size = sec->sh_size;
7795 table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7796 _("unwind table"));
7797 if (!table)
7798 return FALSE;
7799
7800 aux->table_len = size / (3 * eh_addr_size);
7801 aux->table = (struct ia64_unw_table_entry *)
7802 xcmalloc (aux->table_len, sizeof (aux->table[0]));
7803 tep = aux->table;
7804
7805 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7806 {
7807 tep->start.section = SHN_UNDEF;
7808 tep->end.section = SHN_UNDEF;
7809 tep->info.section = SHN_UNDEF;
7810 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7811 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7812 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7813 tep->start.offset += aux->seg_base;
7814 tep->end.offset += aux->seg_base;
7815 tep->info.offset += aux->seg_base;
7816 }
7817 free (table);
7818
7819 /* Third, apply any relocations to the unwind table: */
7820 for (relsec = filedata->section_headers;
7821 relsec < filedata->section_headers + filedata->file_header.e_shnum;
7822 ++relsec)
7823 {
7824 if (relsec->sh_type != SHT_RELA
7825 || relsec->sh_info >= filedata->file_header.e_shnum
7826 || filedata->section_headers + relsec->sh_info != sec)
7827 continue;
7828
7829 if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7830 & rela, & nrelas))
7831 {
7832 free (aux->table);
7833 aux->table = NULL;
7834 aux->table_len = 0;
7835 return FALSE;
7836 }
7837
7838 for (rp = rela; rp < rela + nrelas; ++rp)
7839 {
7840 unsigned int sym_ndx;
7841 unsigned int r_type = get_reloc_type (filedata, rp->r_info);
7842 relname = elf_ia64_reloc_type (r_type);
7843
7844 /* PR 17531: file: 9fa67536. */
7845 if (relname == NULL)
7846 {
7847 warn (_("Skipping unknown relocation type: %u\n"), r_type);
7848 continue;
7849 }
7850
7851 if (! const_strneq (relname, "R_IA64_SEGREL"))
7852 {
7853 warn (_("Skipping unexpected relocation type: %s\n"), relname);
7854 continue;
7855 }
7856
7857 i = rp->r_offset / (3 * eh_addr_size);
7858
7859 /* PR 17531: file: 5bc8d9bf. */
7860 if (i >= aux->table_len)
7861 {
7862 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7863 continue;
7864 }
7865
7866 sym_ndx = get_reloc_symindex (rp->r_info);
7867 if (sym_ndx >= aux->nsyms)
7868 {
7869 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7870 sym_ndx);
7871 continue;
7872 }
7873 sym = aux->symtab + sym_ndx;
7874
7875 switch (rp->r_offset / eh_addr_size % 3)
7876 {
7877 case 0:
7878 aux->table[i].start.section = sym->st_shndx;
7879 aux->table[i].start.offset = rp->r_addend + sym->st_value;
7880 break;
7881 case 1:
7882 aux->table[i].end.section = sym->st_shndx;
7883 aux->table[i].end.offset = rp->r_addend + sym->st_value;
7884 break;
7885 case 2:
7886 aux->table[i].info.section = sym->st_shndx;
7887 aux->table[i].info.offset = rp->r_addend + sym->st_value;
7888 break;
7889 default:
7890 break;
7891 }
7892 }
7893
7894 free (rela);
7895 }
7896
7897 return TRUE;
7898}
7899
7900static bfd_boolean
7901ia64_process_unwind (Filedata * filedata)
7902{
7903 Elf_Internal_Shdr * sec;
7904 Elf_Internal_Shdr * unwsec = NULL;
7905 unsigned long i, unwcount = 0, unwstart = 0;
7906 struct ia64_unw_aux_info aux;
7907 bfd_boolean res = TRUE;
7908
7909 memset (& aux, 0, sizeof (aux));
7910
7911 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
7912 {
7913 if (sec->sh_type == SHT_SYMTAB)
7914 {
7915 if (aux.symtab)
7916 {
7917 error (_("Multiple symbol tables encountered\n"));
7918 free (aux.symtab);
7919 aux.symtab = NULL;
7920 free (aux.strtab);
7921 aux.strtab = NULL;
7922 }
7923 if (!get_symtab (filedata, sec, &aux.symtab, &aux.nsyms,
7924 &aux.strtab, &aux.strtab_size))
7925 return FALSE;
7926 }
7927 else if (sec->sh_type == SHT_IA_64_UNWIND)
7928 unwcount++;
7929 }
7930
7931 if (!unwcount)
7932 printf (_("\nThere are no unwind sections in this file.\n"));
7933
7934 while (unwcount-- > 0)
7935 {
7936 char * suffix;
7937 size_t len, len2;
7938
7939 for (i = unwstart, sec = filedata->section_headers + unwstart, unwsec = NULL;
7940 i < filedata->file_header.e_shnum; ++i, ++sec)
7941 if (sec->sh_type == SHT_IA_64_UNWIND)
7942 {
7943 unwsec = sec;
7944 break;
7945 }
7946 /* We have already counted the number of SHT_IA64_UNWIND
7947 sections so the loop above should never fail. */
7948 assert (unwsec != NULL);
7949
7950 unwstart = i + 1;
7951 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7952
7953 if ((unwsec->sh_flags & SHF_GROUP) != 0)
7954 {
7955 /* We need to find which section group it is in. */
7956 struct group_list * g;
7957
7958 if (filedata->section_headers_groups == NULL
7959 || filedata->section_headers_groups[i] == NULL)
7960 i = filedata->file_header.e_shnum;
7961 else
7962 {
7963 g = filedata->section_headers_groups[i]->root;
7964
7965 for (; g != NULL; g = g->next)
7966 {
7967 sec = filedata->section_headers + g->section_index;
7968
7969 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7970 break;
7971 }
7972
7973 if (g == NULL)
7974 i = filedata->file_header.e_shnum;
7975 }
7976 }
7977 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7978 {
7979 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7980 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7981 suffix = SECTION_NAME (unwsec) + len;
7982 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7983 ++i, ++sec)
7984 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7985 && streq (SECTION_NAME (sec) + len2, suffix))
7986 break;
7987 }
7988 else
7989 {
7990 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7991 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7992 len = sizeof (ELF_STRING_ia64_unwind) - 1;
7993 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7994 suffix = "";
7995 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7996 suffix = SECTION_NAME (unwsec) + len;
7997 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7998 ++i, ++sec)
7999 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
8000 && streq (SECTION_NAME (sec) + len2, suffix))
8001 break;
8002 }
8003
8004 if (i == filedata->file_header.e_shnum)
8005 {
8006 printf (_("\nCould not find unwind info section for "));
8007
8008 if (filedata->string_table == NULL)
8009 printf ("%d", unwsec->sh_name);
8010 else
8011 printf ("'%s'", printable_section_name (filedata, unwsec));
8012 }
8013 else
8014 {
8015 aux.info_addr = sec->sh_addr;
8016 aux.info = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1,
8017 sec->sh_size,
8018 _("unwind info"));
8019 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
8020
8021 printf (_("\nUnwind section "));
8022
8023 if (filedata->string_table == NULL)
8024 printf ("%d", unwsec->sh_name);
8025 else
8026 printf ("'%s'", printable_section_name (filedata, unwsec));
8027
8028 printf (_(" at offset 0x%lx contains %lu entries:\n"),
8029 (unsigned long) unwsec->sh_offset,
8030 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
8031
8032 if (slurp_ia64_unwind_table (filedata, & aux, unwsec)
8033 && aux.table_len > 0)
8034 dump_ia64_unwind (filedata, & aux);
8035
8036 free ((char *) aux.table);
8037 free ((char *) aux.info);
8038 aux.table = NULL;
8039 aux.info = NULL;
8040 }
8041 }
8042
8043 free (aux.symtab);
8044 free ((char *) aux.strtab);
8045
8046 return res;
8047}
8048
8049struct hppa_unw_table_entry
8050{
8051 struct absaddr start;
8052 struct absaddr end;
8053 unsigned int Cannot_unwind:1; /* 0 */
8054 unsigned int Millicode:1; /* 1 */
8055 unsigned int Millicode_save_sr0:1; /* 2 */
8056 unsigned int Region_description:2; /* 3..4 */
8057 unsigned int reserved1:1; /* 5 */
8058 unsigned int Entry_SR:1; /* 6 */
8059 unsigned int Entry_FR:4; /* Number saved 7..10 */
8060 unsigned int Entry_GR:5; /* Number saved 11..15 */
8061 unsigned int Args_stored:1; /* 16 */
8062 unsigned int Variable_Frame:1; /* 17 */
8063 unsigned int Separate_Package_Body:1; /* 18 */
8064 unsigned int Frame_Extension_Millicode:1; /* 19 */
8065 unsigned int Stack_Overflow_Check:1; /* 20 */
8066 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
8067 unsigned int Ada_Region:1; /* 22 */
8068 unsigned int cxx_info:1; /* 23 */
8069 unsigned int cxx_try_catch:1; /* 24 */
8070 unsigned int sched_entry_seq:1; /* 25 */
8071 unsigned int reserved2:1; /* 26 */
8072 unsigned int Save_SP:1; /* 27 */
8073 unsigned int Save_RP:1; /* 28 */
8074 unsigned int Save_MRP_in_frame:1; /* 29 */
8075 unsigned int extn_ptr_defined:1; /* 30 */
8076 unsigned int Cleanup_defined:1; /* 31 */
8077
8078 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
8079 unsigned int HP_UX_interrupt_marker:1; /* 1 */
8080 unsigned int Large_frame:1; /* 2 */
8081 unsigned int Pseudo_SP_Set:1; /* 3 */
8082 unsigned int reserved4:1; /* 4 */
8083 unsigned int Total_frame_size:27; /* 5..31 */
8084};
8085
8086struct hppa_unw_aux_info
8087{
8088 struct hppa_unw_table_entry * table; /* Unwind table. */
8089 unsigned long table_len; /* Length of unwind table. */
8090 bfd_vma seg_base; /* Starting address of segment. */
8091 Elf_Internal_Sym * symtab; /* The symbol table. */
8092 unsigned long nsyms; /* Number of symbols. */
8093 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
8094 unsigned long nfuns; /* Number of entries in funtab. */
8095 char * strtab; /* The string table. */
8096 unsigned long strtab_size; /* Size of string table. */
8097};
8098
8099static bfd_boolean
8100dump_hppa_unwind (Filedata * filedata, struct hppa_unw_aux_info * aux)
8101{
8102 struct hppa_unw_table_entry * tp;
8103 unsigned long j, nfuns;
8104 bfd_boolean res = TRUE;
8105
8106 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8107 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8108 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8109 aux->funtab[nfuns++] = aux->symtab[j];
8110 aux->nfuns = nfuns;
8111 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8112
8113 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
8114 {
8115 bfd_vma offset;
8116 const char * procname;
8117
8118 find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8119 aux->strtab_size, tp->start, &procname,
8120 &offset);
8121
8122 fputs ("\n<", stdout);
8123
8124 if (procname)
8125 {
8126 fputs (procname, stdout);
8127
8128 if (offset)
8129 printf ("+%lx", (unsigned long) offset);
8130 }
8131
8132 fputs (">: [", stdout);
8133 print_vma (tp->start.offset, PREFIX_HEX);
8134 fputc ('-', stdout);
8135 print_vma (tp->end.offset, PREFIX_HEX);
8136 printf ("]\n\t");
8137
8138#define PF(_m) if (tp->_m) printf (#_m " ");
8139#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8140 PF(Cannot_unwind);
8141 PF(Millicode);
8142 PF(Millicode_save_sr0);
8143 /* PV(Region_description); */
8144 PF(Entry_SR);
8145 PV(Entry_FR);
8146 PV(Entry_GR);
8147 PF(Args_stored);
8148 PF(Variable_Frame);
8149 PF(Separate_Package_Body);
8150 PF(Frame_Extension_Millicode);
8151 PF(Stack_Overflow_Check);
8152 PF(Two_Instruction_SP_Increment);
8153 PF(Ada_Region);
8154 PF(cxx_info);
8155 PF(cxx_try_catch);
8156 PF(sched_entry_seq);
8157 PF(Save_SP);
8158 PF(Save_RP);
8159 PF(Save_MRP_in_frame);
8160 PF(extn_ptr_defined);
8161 PF(Cleanup_defined);
8162 PF(MPE_XL_interrupt_marker);
8163 PF(HP_UX_interrupt_marker);
8164 PF(Large_frame);
8165 PF(Pseudo_SP_Set);
8166 PV(Total_frame_size);
8167#undef PF
8168#undef PV
8169 }
8170
8171 printf ("\n");
8172
8173 free (aux->funtab);
8174
8175 return res;
8176}
8177
8178static bfd_boolean
8179slurp_hppa_unwind_table (Filedata * filedata,
8180 struct hppa_unw_aux_info * aux,
8181 Elf_Internal_Shdr * sec)
8182{
8183 unsigned long size, unw_ent_size, nentries, nrelas, i;
8184 Elf_Internal_Phdr * seg;
8185 struct hppa_unw_table_entry * tep;
8186 Elf_Internal_Shdr * relsec;
8187 Elf_Internal_Rela * rela;
8188 Elf_Internal_Rela * rp;
8189 unsigned char * table;
8190 unsigned char * tp;
8191 Elf_Internal_Sym * sym;
8192 const char * relname;
8193
8194 /* First, find the starting address of the segment that includes
8195 this section. */
8196 if (filedata->file_header.e_phnum)
8197 {
8198 if (! get_program_headers (filedata))
8199 return FALSE;
8200
8201 for (seg = filedata->program_headers;
8202 seg < filedata->program_headers + filedata->file_header.e_phnum;
8203 ++seg)
8204 {
8205 if (seg->p_type != PT_LOAD)
8206 continue;
8207
8208 if (sec->sh_addr >= seg->p_vaddr
8209 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
8210 {
8211 aux->seg_base = seg->p_vaddr;
8212 break;
8213 }
8214 }
8215 }
8216
8217 /* Second, build the unwind table from the contents of the unwind
8218 section. */
8219 size = sec->sh_size;
8220 table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
8221 _("unwind table"));
8222 if (!table)
8223 return FALSE;
8224
8225 unw_ent_size = 16;
8226 nentries = size / unw_ent_size;
8227 size = unw_ent_size * nentries;
8228
8229 tep = aux->table = (struct hppa_unw_table_entry *)
8230 xcmalloc (nentries, sizeof (aux->table[0]));
8231
8232 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
8233 {
8234 unsigned int tmp1, tmp2;
8235
8236 tep->start.section = SHN_UNDEF;
8237 tep->end.section = SHN_UNDEF;
8238
8239 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
8240 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
8241 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
8242 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
8243
8244 tep->start.offset += aux->seg_base;
8245 tep->end.offset += aux->seg_base;
8246
8247 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
8248 tep->Millicode = (tmp1 >> 30) & 0x1;
8249 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
8250 tep->Region_description = (tmp1 >> 27) & 0x3;
8251 tep->reserved1 = (tmp1 >> 26) & 0x1;
8252 tep->Entry_SR = (tmp1 >> 25) & 0x1;
8253 tep->Entry_FR = (tmp1 >> 21) & 0xf;
8254 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
8255 tep->Args_stored = (tmp1 >> 15) & 0x1;
8256 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
8257 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
8258 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
8259 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
8260 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
8261 tep->Ada_Region = (tmp1 >> 9) & 0x1;
8262 tep->cxx_info = (tmp1 >> 8) & 0x1;
8263 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
8264 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
8265 tep->reserved2 = (tmp1 >> 5) & 0x1;
8266 tep->Save_SP = (tmp1 >> 4) & 0x1;
8267 tep->Save_RP = (tmp1 >> 3) & 0x1;
8268 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
8269 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
8270 tep->Cleanup_defined = tmp1 & 0x1;
8271
8272 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
8273 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
8274 tep->Large_frame = (tmp2 >> 29) & 0x1;
8275 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
8276 tep->reserved4 = (tmp2 >> 27) & 0x1;
8277 tep->Total_frame_size = tmp2 & 0x7ffffff;
8278 }
8279 free (table);
8280
8281 /* Third, apply any relocations to the unwind table. */
8282 for (relsec = filedata->section_headers;
8283 relsec < filedata->section_headers + filedata->file_header.e_shnum;
8284 ++relsec)
8285 {
8286 if (relsec->sh_type != SHT_RELA
8287 || relsec->sh_info >= filedata->file_header.e_shnum
8288 || filedata->section_headers + relsec->sh_info != sec)
8289 continue;
8290
8291 if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
8292 & rela, & nrelas))
8293 return FALSE;
8294
8295 for (rp = rela; rp < rela + nrelas; ++rp)
8296 {
8297 unsigned int sym_ndx;
8298 unsigned int r_type = get_reloc_type (filedata, rp->r_info);
8299 relname = elf_hppa_reloc_type (r_type);
8300
8301 if (relname == NULL)
8302 {
8303 warn (_("Skipping unknown relocation type: %u\n"), r_type);
8304 continue;
8305 }
8306
8307 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8308 if (! const_strneq (relname, "R_PARISC_SEGREL"))
8309 {
8310 warn (_("Skipping unexpected relocation type: %s\n"), relname);
8311 continue;
8312 }
8313
8314 i = rp->r_offset / unw_ent_size;
8315 if (i >= aux->table_len)
8316 {
8317 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
8318 continue;
8319 }
8320
8321 sym_ndx = get_reloc_symindex (rp->r_info);
8322 if (sym_ndx >= aux->nsyms)
8323 {
8324 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8325 sym_ndx);
8326 continue;
8327 }
8328 sym = aux->symtab + sym_ndx;
8329
8330 switch ((rp->r_offset % unw_ent_size) / 4)
8331 {
8332 case 0:
8333 aux->table[i].start.section = sym->st_shndx;
8334 aux->table[i].start.offset = sym->st_value + rp->r_addend;
8335 break;
8336 case 1:
8337 aux->table[i].end.section = sym->st_shndx;
8338 aux->table[i].end.offset = sym->st_value + rp->r_addend;
8339 break;
8340 default:
8341 break;
8342 }
8343 }
8344
8345 free (rela);
8346 }
8347
8348 aux->table_len = nentries;
8349
8350 return TRUE;
8351}
8352
8353static bfd_boolean
8354hppa_process_unwind (Filedata * filedata)
8355{
8356 struct hppa_unw_aux_info aux;
8357 Elf_Internal_Shdr * unwsec = NULL;
8358 Elf_Internal_Shdr * sec;
8359 unsigned long i;
8360 bfd_boolean res = TRUE;
8361
8362 if (filedata->string_table == NULL)
8363 return FALSE;
8364
8365 memset (& aux, 0, sizeof (aux));
8366
8367 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8368 {
8369 if (sec->sh_type == SHT_SYMTAB)
8370 {
8371 if (aux.symtab)
8372 {
8373 error (_("Multiple symbol tables encountered\n"));
8374 free (aux.symtab);
8375 aux.symtab = NULL;
8376 free (aux.strtab);
8377 aux.strtab = NULL;
8378 }
8379 if (!get_symtab (filedata, sec, &aux.symtab, &aux.nsyms,
8380 &aux.strtab, &aux.strtab_size))
8381 return FALSE;
8382 }
8383 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8384 unwsec = sec;
8385 }
8386
8387 if (!unwsec)
8388 printf (_("\nThere are no unwind sections in this file.\n"));
8389
8390 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8391 {
8392 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8393 {
8394 unsigned long num_unwind = sec->sh_size / 16;
8395
8396 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8397 "contains %lu entry:\n",
8398 "\nUnwind section '%s' at offset 0x%lx "
8399 "contains %lu entries:\n",
8400 num_unwind),
8401 printable_section_name (filedata, sec),
8402 (unsigned long) sec->sh_offset,
8403 num_unwind);
8404
8405 if (! slurp_hppa_unwind_table (filedata, &aux, sec))
8406 res = FALSE;
8407
8408 if (res && aux.table_len > 0)
8409 {
8410 if (! dump_hppa_unwind (filedata, &aux))
8411 res = FALSE;
8412 }
8413
8414 free ((char *) aux.table);
8415 aux.table = NULL;
8416 }
8417 }
8418
8419 free (aux.symtab);
8420 free ((char *) aux.strtab);
8421
8422 return res;
8423}
8424
8425struct arm_section
8426{
8427 unsigned char * data; /* The unwind data. */
8428 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
8429 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
8430 unsigned long nrelas; /* The number of relocations. */
8431 unsigned int rel_type; /* REL or RELA ? */
8432 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
8433};
8434
8435struct arm_unw_aux_info
8436{
8437 Filedata * filedata; /* The file containing the unwind sections. */
8438 Elf_Internal_Sym * symtab; /* The file's symbol table. */
8439 unsigned long nsyms; /* Number of symbols. */
8440 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
8441 unsigned long nfuns; /* Number of these symbols. */
8442 char * strtab; /* The file's string table. */
8443 unsigned long strtab_size; /* Size of string table. */
8444};
8445
8446static const char *
8447arm_print_vma_and_name (Filedata * filedata,
8448 struct arm_unw_aux_info * aux,
8449 bfd_vma fn,
8450 struct absaddr addr)
8451{
8452 const char *procname;
8453 bfd_vma sym_offset;
8454
8455 if (addr.section == SHN_UNDEF)
8456 addr.offset = fn;
8457
8458 find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8459 aux->strtab_size, addr, &procname,
8460 &sym_offset);
8461
8462 print_vma (fn, PREFIX_HEX);
8463
8464 if (procname)
8465 {
8466 fputs (" <", stdout);
8467 fputs (procname, stdout);
8468
8469 if (sym_offset)
8470 printf ("+0x%lx", (unsigned long) sym_offset);
8471 fputc ('>', stdout);
8472 }
8473
8474 return procname;
8475}
8476
8477static void
8478arm_free_section (struct arm_section *arm_sec)
8479{
8480 free (arm_sec->data);
8481 free (arm_sec->rela);
8482}
8483
8484/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8485 cached section and install SEC instead.
8486 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8487 and return its valued in * WORDP, relocating if necessary.
8488 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8489 relocation's offset in ADDR.
8490 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8491 into the string table of the symbol associated with the reloc. If no
8492 reloc was applied store -1 there.
8493 5) Return TRUE upon success, FALSE otherwise. */
8494
8495static bfd_boolean
8496get_unwind_section_word (Filedata * filedata,
8497 struct arm_unw_aux_info * aux,
8498 struct arm_section * arm_sec,
8499 Elf_Internal_Shdr * sec,
8500 bfd_vma word_offset,
8501 unsigned int * wordp,
8502 struct absaddr * addr,
8503 bfd_vma * sym_name)
8504{
8505 Elf_Internal_Rela *rp;
8506 Elf_Internal_Sym *sym;
8507 const char * relname;
8508 unsigned int word;
8509 bfd_boolean wrapped;
8510
8511 if (sec == NULL || arm_sec == NULL)
8512 return FALSE;
8513
8514 addr->section = SHN_UNDEF;
8515 addr->offset = 0;
8516
8517 if (sym_name != NULL)
8518 *sym_name = (bfd_vma) -1;
8519
8520 /* If necessary, update the section cache. */
8521 if (sec != arm_sec->sec)
8522 {
8523 Elf_Internal_Shdr *relsec;
8524
8525 arm_free_section (arm_sec);
8526
8527 arm_sec->sec = sec;
8528 arm_sec->data = get_data (NULL, aux->filedata, sec->sh_offset, 1,
8529 sec->sh_size, _("unwind data"));
8530 arm_sec->rela = NULL;
8531 arm_sec->nrelas = 0;
8532
8533 for (relsec = filedata->section_headers;
8534 relsec < filedata->section_headers + filedata->file_header.e_shnum;
8535 ++relsec)
8536 {
8537 if (relsec->sh_info >= filedata->file_header.e_shnum
8538 || filedata->section_headers + relsec->sh_info != sec
8539 /* PR 15745: Check the section type as well. */
8540 || (relsec->sh_type != SHT_REL
8541 && relsec->sh_type != SHT_RELA))
8542 continue;
8543
8544 arm_sec->rel_type = relsec->sh_type;
8545 if (relsec->sh_type == SHT_REL)
8546 {
8547 if (!slurp_rel_relocs (aux->filedata, relsec->sh_offset,
8548 relsec->sh_size,
8549 & arm_sec->rela, & arm_sec->nrelas))
8550 return FALSE;
8551 }
8552 else /* relsec->sh_type == SHT_RELA */
8553 {
8554 if (!slurp_rela_relocs (aux->filedata, relsec->sh_offset,
8555 relsec->sh_size,
8556 & arm_sec->rela, & arm_sec->nrelas))
8557 return FALSE;
8558 }
8559 break;
8560 }
8561
8562 arm_sec->next_rela = arm_sec->rela;
8563 }
8564
8565 /* If there is no unwind data we can do nothing. */
8566 if (arm_sec->data == NULL)
8567 return FALSE;
8568
8569 /* If the offset is invalid then fail. */
8570 if (/* PR 21343 *//* PR 18879 */
8571 sec->sh_size < 4
8572 || word_offset > (sec->sh_size - 4)
8573 || ((bfd_signed_vma) word_offset) < 0)
8574 return FALSE;
8575
8576 /* Get the word at the required offset. */
8577 word = byte_get (arm_sec->data + word_offset, 4);
8578
8579 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8580 if (arm_sec->rela == NULL)
8581 {
8582 * wordp = word;
8583 return TRUE;
8584 }
8585
8586 /* Look through the relocs to find the one that applies to the provided offset. */
8587 wrapped = FALSE;
8588 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8589 {
8590 bfd_vma prelval, offset;
8591
8592 if (rp->r_offset > word_offset && !wrapped)
8593 {
8594 rp = arm_sec->rela;
8595 wrapped = TRUE;
8596 }
8597 if (rp->r_offset > word_offset)
8598 break;
8599
8600 if (rp->r_offset & 3)
8601 {
8602 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8603 (unsigned long) rp->r_offset);
8604 continue;
8605 }
8606
8607 if (rp->r_offset < word_offset)
8608 continue;
8609
8610 /* PR 17531: file: 027-161405-0.004 */
8611 if (aux->symtab == NULL)
8612 continue;
8613
8614 if (arm_sec->rel_type == SHT_REL)
8615 {
8616 offset = word & 0x7fffffff;
8617 if (offset & 0x40000000)
8618 offset |= ~ (bfd_vma) 0x7fffffff;
8619 }
8620 else if (arm_sec->rel_type == SHT_RELA)
8621 offset = rp->r_addend;
8622 else
8623 {
8624 error (_("Unknown section relocation type %d encountered\n"),
8625 arm_sec->rel_type);
8626 break;
8627 }
8628
8629 /* PR 17531 file: 027-1241568-0.004. */
8630 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8631 {
8632 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8633 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8634 break;
8635 }
8636
8637 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8638 offset += sym->st_value;
8639 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8640
8641 /* Check that we are processing the expected reloc type. */
8642 if (filedata->file_header.e_machine == EM_ARM)
8643 {
8644 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8645 if (relname == NULL)
8646 {
8647 warn (_("Skipping unknown ARM relocation type: %d\n"),
8648 (int) ELF32_R_TYPE (rp->r_info));
8649 continue;
8650 }
8651
8652 if (streq (relname, "R_ARM_NONE"))
8653 continue;
8654
8655 if (! streq (relname, "R_ARM_PREL31"))
8656 {
8657 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8658 continue;
8659 }
8660 }
8661 else if (filedata->file_header.e_machine == EM_TI_C6000)
8662 {
8663 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8664 if (relname == NULL)
8665 {
8666 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8667 (int) ELF32_R_TYPE (rp->r_info));
8668 continue;
8669 }
8670
8671 if (streq (relname, "R_C6000_NONE"))
8672 continue;
8673
8674 if (! streq (relname, "R_C6000_PREL31"))
8675 {
8676 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8677 continue;
8678 }
8679
8680 prelval >>= 1;
8681 }
8682 else
8683 {
8684 /* This function currently only supports ARM and TI unwinders. */
8685 warn (_("Only TI and ARM unwinders are currently supported\n"));
8686 break;
8687 }
8688
8689 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8690 addr->section = sym->st_shndx;
8691 addr->offset = offset;
8692
8693 if (sym_name)
8694 * sym_name = sym->st_name;
8695 break;
8696 }
8697
8698 *wordp = word;
8699 arm_sec->next_rela = rp;
8700
8701 return TRUE;
8702}
8703
8704static const char *tic6x_unwind_regnames[16] =
8705{
8706 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8707 "A14", "A13", "A12", "A11", "A10",
8708 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8709};
8710
8711static void
8712decode_tic6x_unwind_regmask (unsigned int mask)
8713{
8714 int i;
8715
8716 for (i = 12; mask; mask >>= 1, i--)
8717 {
8718 if (mask & 1)
8719 {
8720 fputs (tic6x_unwind_regnames[i], stdout);
8721 if (mask > 1)
8722 fputs (", ", stdout);
8723 }
8724 }
8725}
8726
8727#define ADVANCE \
8728 if (remaining == 0 && more_words) \
8729 { \
8730 data_offset += 4; \
8731 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8732 data_offset, & word, & addr, NULL)) \
8733 return FALSE; \
8734 remaining = 4; \
8735 more_words--; \
8736 } \
8737
8738#define GET_OP(OP) \
8739 ADVANCE; \
8740 if (remaining) \
8741 { \
8742 remaining--; \
8743 (OP) = word >> 24; \
8744 word <<= 8; \
8745 } \
8746 else \
8747 { \
8748 printf (_("[Truncated opcode]\n")); \
8749 return FALSE; \
8750 } \
8751 printf ("0x%02x ", OP)
8752
8753static bfd_boolean
8754decode_arm_unwind_bytecode (Filedata * filedata,
8755 struct arm_unw_aux_info * aux,
8756 unsigned int word,
8757 unsigned int remaining,
8758 unsigned int more_words,
8759 bfd_vma data_offset,
8760 Elf_Internal_Shdr * data_sec,
8761 struct arm_section * data_arm_sec)
8762{
8763 struct absaddr addr;
8764 bfd_boolean res = TRUE;
8765
8766 /* Decode the unwinding instructions. */
8767 while (1)
8768 {
8769 unsigned int op, op2;
8770
8771 ADVANCE;
8772 if (remaining == 0)
8773 break;
8774 remaining--;
8775 op = word >> 24;
8776 word <<= 8;
8777
8778 printf (" 0x%02x ", op);
8779
8780 if ((op & 0xc0) == 0x00)
8781 {
8782 int offset = ((op & 0x3f) << 2) + 4;
8783
8784 printf (" vsp = vsp + %d", offset);
8785 }
8786 else if ((op & 0xc0) == 0x40)
8787 {
8788 int offset = ((op & 0x3f) << 2) + 4;
8789
8790 printf (" vsp = vsp - %d", offset);
8791 }
8792 else if ((op & 0xf0) == 0x80)
8793 {
8794 GET_OP (op2);
8795 if (op == 0x80 && op2 == 0)
8796 printf (_("Refuse to unwind"));
8797 else
8798 {
8799 unsigned int mask = ((op & 0x0f) << 8) | op2;
8800 bfd_boolean first = TRUE;
8801 int i;
8802
8803 printf ("pop {");
8804 for (i = 0; i < 12; i++)
8805 if (mask & (1 << i))
8806 {
8807 if (first)
8808 first = FALSE;
8809 else
8810 printf (", ");
8811 printf ("r%d", 4 + i);
8812 }
8813 printf ("}");
8814 }
8815 }
8816 else if ((op & 0xf0) == 0x90)
8817 {
8818 if (op == 0x9d || op == 0x9f)
8819 printf (_(" [Reserved]"));
8820 else
8821 printf (" vsp = r%d", op & 0x0f);
8822 }
8823 else if ((op & 0xf0) == 0xa0)
8824 {
8825 int end = 4 + (op & 0x07);
8826 bfd_boolean first = TRUE;
8827 int i;
8828
8829 printf (" pop {");
8830 for (i = 4; i <= end; i++)
8831 {
8832 if (first)
8833 first = FALSE;
8834 else
8835 printf (", ");
8836 printf ("r%d", i);
8837 }
8838 if (op & 0x08)
8839 {
8840 if (!first)
8841 printf (", ");
8842 printf ("r14");
8843 }
8844 printf ("}");
8845 }
8846 else if (op == 0xb0)
8847 printf (_(" finish"));
8848 else if (op == 0xb1)
8849 {
8850 GET_OP (op2);
8851 if (op2 == 0 || (op2 & 0xf0) != 0)
8852 printf (_("[Spare]"));
8853 else
8854 {
8855 unsigned int mask = op2 & 0x0f;
8856 bfd_boolean first = TRUE;
8857 int i;
8858
8859 printf ("pop {");
8860 for (i = 0; i < 12; i++)
8861 if (mask & (1 << i))
8862 {
8863 if (first)
8864 first = FALSE;
8865 else
8866 printf (", ");
8867 printf ("r%d", i);
8868 }
8869 printf ("}");
8870 }
8871 }
8872 else if (op == 0xb2)
8873 {
8874 unsigned char buf[9];
8875 unsigned int i, len;
8876 unsigned long offset;
8877
8878 for (i = 0; i < sizeof (buf); i++)
8879 {
8880 GET_OP (buf[i]);
8881 if ((buf[i] & 0x80) == 0)
8882 break;
8883 }
8884 if (i == sizeof (buf))
8885 {
8886 error (_("corrupt change to vsp\n"));
8887 res = FALSE;
8888 }
8889 else
8890 {
8891 offset = read_leb128 (buf, buf + i + 1, FALSE, &len, NULL);
8892 assert (len == i + 1);
8893 offset = offset * 4 + 0x204;
8894 printf ("vsp = vsp + %ld", offset);
8895 }
8896 }
8897 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8898 {
8899 unsigned int first, last;
8900
8901 GET_OP (op2);
8902 first = op2 >> 4;
8903 last = op2 & 0x0f;
8904 if (op == 0xc8)
8905 first = first + 16;
8906 printf ("pop {D%d", first);
8907 if (last)
8908 printf ("-D%d", first + last);
8909 printf ("}");
8910 }
8911 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8912 {
8913 unsigned int count = op & 0x07;
8914
8915 printf ("pop {D8");
8916 if (count)
8917 printf ("-D%d", 8 + count);
8918 printf ("}");
8919 }
8920 else if (op >= 0xc0 && op <= 0xc5)
8921 {
8922 unsigned int count = op & 0x07;
8923
8924 printf (" pop {wR10");
8925 if (count)
8926 printf ("-wR%d", 10 + count);
8927 printf ("}");
8928 }
8929 else if (op == 0xc6)
8930 {
8931 unsigned int first, last;
8932
8933 GET_OP (op2);
8934 first = op2 >> 4;
8935 last = op2 & 0x0f;
8936 printf ("pop {wR%d", first);
8937 if (last)
8938 printf ("-wR%d", first + last);
8939 printf ("}");
8940 }
8941 else if (op == 0xc7)
8942 {
8943 GET_OP (op2);
8944 if (op2 == 0 || (op2 & 0xf0) != 0)
8945 printf (_("[Spare]"));
8946 else
8947 {
8948 unsigned int mask = op2 & 0x0f;
8949 bfd_boolean first = TRUE;
8950 int i;
8951
8952 printf ("pop {");
8953 for (i = 0; i < 4; i++)
8954 if (mask & (1 << i))
8955 {
8956 if (first)
8957 first = FALSE;
8958 else
8959 printf (", ");
8960 printf ("wCGR%d", i);
8961 }
8962 printf ("}");
8963 }
8964 }
8965 else
8966 {
8967 printf (_(" [unsupported opcode]"));
8968 res = FALSE;
8969 }
8970
8971 printf ("\n");
8972 }
8973
8974 return res;
8975}
8976
8977static bfd_boolean
8978decode_tic6x_unwind_bytecode (Filedata * filedata,
8979 struct arm_unw_aux_info * aux,
8980 unsigned int word,
8981 unsigned int remaining,
8982 unsigned int more_words,
8983 bfd_vma data_offset,
8984 Elf_Internal_Shdr * data_sec,
8985 struct arm_section * data_arm_sec)
8986{
8987 struct absaddr addr;
8988
8989 /* Decode the unwinding instructions. */
8990 while (1)
8991 {
8992 unsigned int op, op2;
8993
8994 ADVANCE;
8995 if (remaining == 0)
8996 break;
8997 remaining--;
8998 op = word >> 24;
8999 word <<= 8;
9000
9001 printf (" 0x%02x ", op);
9002
9003 if ((op & 0xc0) == 0x00)
9004 {
9005 int offset = ((op & 0x3f) << 3) + 8;
9006 printf (" sp = sp + %d", offset);
9007 }
9008 else if ((op & 0xc0) == 0x80)
9009 {
9010 GET_OP (op2);
9011 if (op == 0x80 && op2 == 0)
9012 printf (_("Refuse to unwind"));
9013 else
9014 {
9015 unsigned int mask = ((op & 0x1f) << 8) | op2;
9016 if (op & 0x20)
9017 printf ("pop compact {");
9018 else
9019 printf ("pop {");
9020
9021 decode_tic6x_unwind_regmask (mask);
9022 printf("}");
9023 }
9024 }
9025 else if ((op & 0xf0) == 0xc0)
9026 {
9027 unsigned int reg;
9028 unsigned int nregs;
9029 unsigned int i;
9030 const char *name;
9031 struct
9032 {
9033 unsigned int offset;
9034 unsigned int reg;
9035 } regpos[16];
9036
9037 /* Scan entire instruction first so that GET_OP output is not
9038 interleaved with disassembly. */
9039 nregs = 0;
9040 for (i = 0; nregs < (op & 0xf); i++)
9041 {
9042 GET_OP (op2);
9043 reg = op2 >> 4;
9044 if (reg != 0xf)
9045 {
9046 regpos[nregs].offset = i * 2;
9047 regpos[nregs].reg = reg;
9048 nregs++;
9049 }
9050
9051 reg = op2 & 0xf;
9052 if (reg != 0xf)
9053 {
9054 regpos[nregs].offset = i * 2 + 1;
9055 regpos[nregs].reg = reg;
9056 nregs++;
9057 }
9058 }
9059
9060 printf (_("pop frame {"));
9061 if (nregs == 0)
9062 {
9063 printf (_("*corrupt* - no registers specified"));
9064 }
9065 else
9066 {
9067 reg = nregs - 1;
9068 for (i = i * 2; i > 0; i--)
9069 {
9070 if (regpos[reg].offset == i - 1)
9071 {
9072 name = tic6x_unwind_regnames[regpos[reg].reg];
9073 if (reg > 0)
9074 reg--;
9075 }
9076 else
9077 name = _("[pad]");
9078
9079 fputs (name, stdout);
9080 if (i > 1)
9081 printf (", ");
9082 }
9083 }
9084
9085 printf ("}");
9086 }
9087 else if (op == 0xd0)
9088 printf (" MOV FP, SP");
9089 else if (op == 0xd1)
9090 printf (" __c6xabi_pop_rts");
9091 else if (op == 0xd2)
9092 {
9093 unsigned char buf[9];
9094 unsigned int i, len;
9095 unsigned long offset;
9096
9097 for (i = 0; i < sizeof (buf); i++)
9098 {
9099 GET_OP (buf[i]);
9100 if ((buf[i] & 0x80) == 0)
9101 break;
9102 }
9103 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9104 if (i == sizeof (buf))
9105 {
9106 warn (_("Corrupt stack pointer adjustment detected\n"));
9107 return FALSE;
9108 }
9109
9110 offset = read_leb128 (buf, buf + i + 1, FALSE, &len, NULL);
9111 assert (len == i + 1);
9112 offset = offset * 8 + 0x408;
9113 printf (_("sp = sp + %ld"), offset);
9114 }
9115 else if ((op & 0xf0) == 0xe0)
9116 {
9117 if ((op & 0x0f) == 7)
9118 printf (" RETURN");
9119 else
9120 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
9121 }
9122 else
9123 {
9124 printf (_(" [unsupported opcode]"));
9125 }
9126 putchar ('\n');
9127 }
9128
9129 return TRUE;
9130}
9131
9132static bfd_vma
9133arm_expand_prel31 (Filedata * filedata, bfd_vma word, bfd_vma where)
9134{
9135 bfd_vma offset;
9136
9137 offset = word & 0x7fffffff;
9138 if (offset & 0x40000000)
9139 offset |= ~ (bfd_vma) 0x7fffffff;
9140
9141 if (filedata->file_header.e_machine == EM_TI_C6000)
9142 offset <<= 1;
9143
9144 return offset + where;
9145}
9146
9147static bfd_boolean
9148decode_arm_unwind (Filedata * filedata,
9149 struct arm_unw_aux_info * aux,
9150 unsigned int word,
9151 unsigned int remaining,
9152 bfd_vma data_offset,
9153 Elf_Internal_Shdr * data_sec,
9154 struct arm_section * data_arm_sec)
9155{
9156 int per_index;
9157 unsigned int more_words = 0;
9158 struct absaddr addr;
9159 bfd_vma sym_name = (bfd_vma) -1;
9160 bfd_boolean res = TRUE;
9161
9162 if (remaining == 0)
9163 {
9164 /* Fetch the first word.
9165 Note - when decoding an object file the address extracted
9166 here will always be 0. So we also pass in the sym_name
9167 parameter so that we can find the symbol associated with
9168 the personality routine. */
9169 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, data_offset,
9170 & word, & addr, & sym_name))
9171 return FALSE;
9172
9173 remaining = 4;
9174 }
9175 else
9176 {
9177 addr.section = SHN_UNDEF;
9178 addr.offset = 0;
9179 }
9180
9181 if ((word & 0x80000000) == 0)
9182 {
9183 /* Expand prel31 for personality routine. */
9184 bfd_vma fn;
9185 const char *procname;
9186
9187 fn = arm_expand_prel31 (filedata, word, data_sec->sh_addr + data_offset);
9188 printf (_(" Personality routine: "));
9189 if (fn == 0
9190 && addr.section == SHN_UNDEF && addr.offset == 0
9191 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
9192 {
9193 procname = aux->strtab + sym_name;
9194 print_vma (fn, PREFIX_HEX);
9195 if (procname)
9196 {
9197 fputs (" <", stdout);
9198 fputs (procname, stdout);
9199 fputc ('>', stdout);
9200 }
9201 }
9202 else
9203 procname = arm_print_vma_and_name (filedata, aux, fn, addr);
9204 fputc ('\n', stdout);
9205
9206 /* The GCC personality routines use the standard compact
9207 encoding, starting with one byte giving the number of
9208 words. */
9209 if (procname != NULL
9210 && (const_strneq (procname, "__gcc_personality_v0")
9211 || const_strneq (procname, "__gxx_personality_v0")
9212 || const_strneq (procname, "__gcj_personality_v0")
9213 || const_strneq (procname, "__gnu_objc_personality_v0")))
9214 {
9215 remaining = 0;
9216 more_words = 1;
9217 ADVANCE;
9218 if (!remaining)
9219 {
9220 printf (_(" [Truncated data]\n"));
9221 return FALSE;
9222 }
9223 more_words = word >> 24;
9224 word <<= 8;
9225 remaining--;
9226 per_index = -1;
9227 }
9228 else
9229 return TRUE;
9230 }
9231 else
9232 {
9233 /* ARM EHABI Section 6.3:
9234
9235 An exception-handling table entry for the compact model looks like:
9236
9237 31 30-28 27-24 23-0
9238 -- ----- ----- ----
9239 1 0 index Data for personalityRoutine[index] */
9240
9241 if (filedata->file_header.e_machine == EM_ARM
9242 && (word & 0x70000000))
9243 {
9244 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
9245 res = FALSE;
9246 }
9247
9248 per_index = (word >> 24) & 0x7f;
9249 printf (_(" Compact model index: %d\n"), per_index);
9250 if (per_index == 0)
9251 {
9252 more_words = 0;
9253 word <<= 8;
9254 remaining--;
9255 }
9256 else if (per_index < 3)
9257 {
9258 more_words = (word >> 16) & 0xff;
9259 word <<= 16;
9260 remaining -= 2;
9261 }
9262 }
9263
9264 switch (filedata->file_header.e_machine)
9265 {
9266 case EM_ARM:
9267 if (per_index < 3)
9268 {
9269 if (! decode_arm_unwind_bytecode (filedata, aux, word, remaining, more_words,
9270 data_offset, data_sec, data_arm_sec))
9271 res = FALSE;
9272 }
9273 else
9274 {
9275 warn (_("Unknown ARM compact model index encountered\n"));
9276 printf (_(" [reserved]\n"));
9277 res = FALSE;
9278 }
9279 break;
9280
9281 case EM_TI_C6000:
9282 if (per_index < 3)
9283 {
9284 if (! decode_tic6x_unwind_bytecode (filedata, aux, word, remaining, more_words,
9285 data_offset, data_sec, data_arm_sec))
9286 res = FALSE;
9287 }
9288 else if (per_index < 5)
9289 {
9290 if (((word >> 17) & 0x7f) == 0x7f)
9291 printf (_(" Restore stack from frame pointer\n"));
9292 else
9293 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
9294 printf (_(" Registers restored: "));
9295 if (per_index == 4)
9296 printf (" (compact) ");
9297 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
9298 putchar ('\n');
9299 printf (_(" Return register: %s\n"),
9300 tic6x_unwind_regnames[word & 0xf]);
9301 }
9302 else
9303 printf (_(" [reserved (%d)]\n"), per_index);
9304 break;
9305
9306 default:
9307 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9308 filedata->file_header.e_machine);
9309 res = FALSE;
9310 }
9311
9312 /* Decode the descriptors. Not implemented. */
9313
9314 return res;
9315}
9316
9317static bfd_boolean
9318dump_arm_unwind (Filedata * filedata,
9319 struct arm_unw_aux_info * aux,
9320 Elf_Internal_Shdr * exidx_sec)
9321{
9322 struct arm_section exidx_arm_sec, extab_arm_sec;
9323 unsigned int i, exidx_len;
9324 unsigned long j, nfuns;
9325 bfd_boolean res = TRUE;
9326
9327 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
9328 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
9329 exidx_len = exidx_sec->sh_size / 8;
9330
9331 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
9332 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
9333 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
9334 aux->funtab[nfuns++] = aux->symtab[j];
9335 aux->nfuns = nfuns;
9336 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
9337
9338 for (i = 0; i < exidx_len; i++)
9339 {
9340 unsigned int exidx_fn, exidx_entry;
9341 struct absaddr fn_addr, entry_addr;
9342 bfd_vma fn;
9343
9344 fputc ('\n', stdout);
9345
9346 if (! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9347 8 * i, & exidx_fn, & fn_addr, NULL)
9348 || ! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9349 8 * i + 4, & exidx_entry, & entry_addr, NULL))
9350 {
9351 free (aux->funtab);
9352 arm_free_section (& exidx_arm_sec);
9353 arm_free_section (& extab_arm_sec);
9354 return FALSE;
9355 }
9356
9357 /* ARM EHABI, Section 5:
9358 An index table entry consists of 2 words.
9359 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9360 if (exidx_fn & 0x80000000)
9361 {
9362 warn (_("corrupt index table entry: %x\n"), exidx_fn);
9363 res = FALSE;
9364 }
9365
9366 fn = arm_expand_prel31 (filedata, exidx_fn, exidx_sec->sh_addr + 8 * i);
9367
9368 arm_print_vma_and_name (filedata, aux, fn, fn_addr);
9369 fputs (": ", stdout);
9370
9371 if (exidx_entry == 1)
9372 {
9373 print_vma (exidx_entry, PREFIX_HEX);
9374 fputs (" [cantunwind]\n", stdout);
9375 }
9376 else if (exidx_entry & 0x80000000)
9377 {
9378 print_vma (exidx_entry, PREFIX_HEX);
9379 fputc ('\n', stdout);
9380 decode_arm_unwind (filedata, aux, exidx_entry, 4, 0, NULL, NULL);
9381 }
9382 else
9383 {
9384 bfd_vma table, table_offset = 0;
9385 Elf_Internal_Shdr *table_sec;
9386
9387 fputs ("@", stdout);
9388 table = arm_expand_prel31 (filedata, exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
9389 print_vma (table, PREFIX_HEX);
9390 printf ("\n");
9391
9392 /* Locate the matching .ARM.extab. */
9393 if (entry_addr.section != SHN_UNDEF
9394 && entry_addr.section < filedata->file_header.e_shnum)
9395 {
9396 table_sec = filedata->section_headers + entry_addr.section;
9397 table_offset = entry_addr.offset;
9398 /* PR 18879 */
9399 if (table_offset > table_sec->sh_size
9400 || ((bfd_signed_vma) table_offset) < 0)
9401 {
9402 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9403 (unsigned long) table_offset,
9404 printable_section_name (filedata, table_sec));
9405 res = FALSE;
9406 continue;
9407 }
9408 }
9409 else
9410 {
9411 table_sec = find_section_by_address (filedata, table);
9412 if (table_sec != NULL)
9413 table_offset = table - table_sec->sh_addr;
9414 }
9415
9416 if (table_sec == NULL)
9417 {
9418 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9419 (unsigned long) table);
9420 res = FALSE;
9421 continue;
9422 }
9423
9424 if (! decode_arm_unwind (filedata, aux, 0, 0, table_offset, table_sec,
9425 &extab_arm_sec))
9426 res = FALSE;
9427 }
9428 }
9429
9430 printf ("\n");
9431
9432 free (aux->funtab);
9433 arm_free_section (&exidx_arm_sec);
9434 arm_free_section (&extab_arm_sec);
9435
9436 return res;
9437}
9438
9439/* Used for both ARM and C6X unwinding tables. */
9440
9441static bfd_boolean
9442arm_process_unwind (Filedata * filedata)
9443{
9444 struct arm_unw_aux_info aux;
9445 Elf_Internal_Shdr *unwsec = NULL;
9446 Elf_Internal_Shdr *sec;
9447 unsigned long i;
9448 unsigned int sec_type;
9449 bfd_boolean res = TRUE;
9450
9451 switch (filedata->file_header.e_machine)
9452 {
9453 case EM_ARM:
9454 sec_type = SHT_ARM_EXIDX;
9455 break;
9456
9457 case EM_TI_C6000:
9458 sec_type = SHT_C6000_UNWIND;
9459 break;
9460
9461 default:
9462 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9463 filedata->file_header.e_machine);
9464 return FALSE;
9465 }
9466
9467 if (filedata->string_table == NULL)
9468 return FALSE;
9469
9470 memset (& aux, 0, sizeof (aux));
9471 aux.filedata = filedata;
9472
9473 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9474 {
9475 if (sec->sh_type == SHT_SYMTAB)
9476 {
9477 if (aux.symtab)
9478 {
9479 error (_("Multiple symbol tables encountered\n"));
9480 free (aux.symtab);
9481 aux.symtab = NULL;
9482 free (aux.strtab);
9483 aux.strtab = NULL;
9484 }
9485 if (!get_symtab (filedata, sec, &aux.symtab, &aux.nsyms,
9486 &aux.strtab, &aux.strtab_size))
9487 return FALSE;
9488 }
9489 else if (sec->sh_type == sec_type)
9490 unwsec = sec;
9491 }
9492
9493 if (unwsec == NULL)
9494 printf (_("\nThere are no unwind sections in this file.\n"));
9495 else
9496 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9497 {
9498 if (sec->sh_type == sec_type)
9499 {
9500 unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size);
9501 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9502 "contains %lu entry:\n",
9503 "\nUnwind section '%s' at offset 0x%lx "
9504 "contains %lu entries:\n",
9505 num_unwind),
9506 printable_section_name (filedata, sec),
9507 (unsigned long) sec->sh_offset,
9508 num_unwind);
9509
9510 if (! dump_arm_unwind (filedata, &aux, sec))
9511 res = FALSE;
9512 }
9513 }
9514
9515 free (aux.symtab);
9516 free ((char *) aux.strtab);
9517
9518 return res;
9519}
9520
9521static bfd_boolean
9522process_unwind (Filedata * filedata)
9523{
9524 struct unwind_handler
9525 {
9526 unsigned int machtype;
9527 bfd_boolean (* handler)(Filedata *);
9528 } handlers[] =
9529 {
9530 { EM_ARM, arm_process_unwind },
9531 { EM_IA_64, ia64_process_unwind },
9532 { EM_PARISC, hppa_process_unwind },
9533 { EM_TI_C6000, arm_process_unwind },
9534 { 0, NULL }
9535 };
9536 int i;
9537
9538 if (!do_unwind)
9539 return TRUE;
9540
9541 for (i = 0; handlers[i].handler != NULL; i++)
9542 if (filedata->file_header.e_machine == handlers[i].machtype)
9543 return handlers[i].handler (filedata);
9544
9545 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9546 get_machine_name (filedata->file_header.e_machine));
9547 return TRUE;
9548}
9549
9550static void
9551dynamic_section_aarch64_val (Elf_Internal_Dyn * entry)
9552{
9553 switch (entry->d_tag)
9554 {
9555 case DT_AARCH64_BTI_PLT:
9556 case DT_AARCH64_PAC_PLT:
9557 break;
9558 default:
9559 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9560 break;
9561 }
9562 putchar ('\n');
9563}
9564
9565static void
9566dynamic_section_mips_val (Filedata * filedata, Elf_Internal_Dyn * entry)
9567{
9568 switch (entry->d_tag)
9569 {
9570 case DT_MIPS_FLAGS:
9571 if (entry->d_un.d_val == 0)
9572 printf (_("NONE"));
9573 else
9574 {
9575 static const char * opts[] =
9576 {
9577 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9578 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9579 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9580 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9581 "RLD_ORDER_SAFE"
9582 };
9583 unsigned int cnt;
9584 bfd_boolean first = TRUE;
9585
9586 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9587 if (entry->d_un.d_val & (1 << cnt))
9588 {
9589 printf ("%s%s", first ? "" : " ", opts[cnt]);
9590 first = FALSE;
9591 }
9592 }
9593 break;
9594
9595 case DT_MIPS_IVERSION:
9596 if (VALID_DYNAMIC_NAME (filedata, entry->d_un.d_val))
9597 printf (_("Interface Version: %s"),
9598 GET_DYNAMIC_NAME (filedata, entry->d_un.d_val));
9599 else
9600 {
9601 char buf[40];
9602 sprintf_vma (buf, entry->d_un.d_ptr);
9603 /* Note: coded this way so that there is a single string for translation. */
9604 printf (_("<corrupt: %s>"), buf);
9605 }
9606 break;
9607
9608 case DT_MIPS_TIME_STAMP:
9609 {
9610 char timebuf[128];
9611 struct tm * tmp;
9612 time_t atime = entry->d_un.d_val;
9613
9614 tmp = gmtime (&atime);
9615 /* PR 17531: file: 6accc532. */
9616 if (tmp == NULL)
9617 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9618 else
9619 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9620 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9621 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9622 printf (_("Time Stamp: %s"), timebuf);
9623 }
9624 break;
9625
9626 case DT_MIPS_RLD_VERSION:
9627 case DT_MIPS_LOCAL_GOTNO:
9628 case DT_MIPS_CONFLICTNO:
9629 case DT_MIPS_LIBLISTNO:
9630 case DT_MIPS_SYMTABNO:
9631 case DT_MIPS_UNREFEXTNO:
9632 case DT_MIPS_HIPAGENO:
9633 case DT_MIPS_DELTA_CLASS_NO:
9634 case DT_MIPS_DELTA_INSTANCE_NO:
9635 case DT_MIPS_DELTA_RELOC_NO:
9636 case DT_MIPS_DELTA_SYM_NO:
9637 case DT_MIPS_DELTA_CLASSSYM_NO:
9638 case DT_MIPS_COMPACT_SIZE:
9639 print_vma (entry->d_un.d_val, DEC);
9640 break;
9641
9642 case DT_MIPS_XHASH:
9643 filedata->dynamic_info_DT_MIPS_XHASH = entry->d_un.d_val;
9644 filedata->dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9645 /* Falls through. */
9646
9647 default:
9648 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9649 }
9650 putchar ('\n');
9651}
9652
9653static void
9654dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9655{
9656 switch (entry->d_tag)
9657 {
9658 case DT_HP_DLD_FLAGS:
9659 {
9660 static struct
9661 {
9662 long int bit;
9663 const char * str;
9664 }
9665 flags[] =
9666 {
9667 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9668 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9669 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9670 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9671 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9672 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9673 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9674 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9675 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9676 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9677 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9678 { DT_HP_GST, "HP_GST" },
9679 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9680 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9681 { DT_HP_NODELETE, "HP_NODELETE" },
9682 { DT_HP_GROUP, "HP_GROUP" },
9683 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9684 };
9685 bfd_boolean first = TRUE;
9686 size_t cnt;
9687 bfd_vma val = entry->d_un.d_val;
9688
9689 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9690 if (val & flags[cnt].bit)
9691 {
9692 if (! first)
9693 putchar (' ');
9694 fputs (flags[cnt].str, stdout);
9695 first = FALSE;
9696 val ^= flags[cnt].bit;
9697 }
9698
9699 if (val != 0 || first)
9700 {
9701 if (! first)
9702 putchar (' ');
9703 print_vma (val, HEX);
9704 }
9705 }
9706 break;
9707
9708 default:
9709 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9710 break;
9711 }
9712 putchar ('\n');
9713}
9714
9715#ifdef BFD64
9716
9717/* VMS vs Unix time offset and factor. */
9718
9719#define VMS_EPOCH_OFFSET 35067168000000000LL
9720#define VMS_GRANULARITY_FACTOR 10000000
9721
9722/* Display a VMS time in a human readable format. */
9723
9724static void
9725print_vms_time (bfd_int64_t vmstime)
9726{
9727 struct tm *tm;
9728 time_t unxtime;
9729
9730 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9731 tm = gmtime (&unxtime);
9732 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9733 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9734 tm->tm_hour, tm->tm_min, tm->tm_sec);
9735}
9736#endif /* BFD64 */
9737
9738static void
9739dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9740{
9741 switch (entry->d_tag)
9742 {
9743 case DT_IA_64_PLT_RESERVE:
9744 /* First 3 slots reserved. */
9745 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9746 printf (" -- ");
9747 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9748 break;
9749
9750 case DT_IA_64_VMS_LINKTIME:
9751#ifdef BFD64
9752 print_vms_time (entry->d_un.d_val);
9753#endif
9754 break;
9755
9756 case DT_IA_64_VMS_LNKFLAGS:
9757 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9758 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9759 printf (" CALL_DEBUG");
9760 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9761 printf (" NOP0BUFS");
9762 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9763 printf (" P0IMAGE");
9764 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9765 printf (" MKTHREADS");
9766 if (entry->d_un.d_val & VMS_LF_UPCALLS)
9767 printf (" UPCALLS");
9768 if (entry->d_un.d_val & VMS_LF_IMGSTA)
9769 printf (" IMGSTA");
9770 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9771 printf (" INITIALIZE");
9772 if (entry->d_un.d_val & VMS_LF_MAIN)
9773 printf (" MAIN");
9774 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9775 printf (" EXE_INIT");
9776 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9777 printf (" TBK_IN_IMG");
9778 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9779 printf (" DBG_IN_IMG");
9780 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9781 printf (" TBK_IN_DSF");
9782 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9783 printf (" DBG_IN_DSF");
9784 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9785 printf (" SIGNATURES");
9786 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9787 printf (" REL_SEG_OFF");
9788 break;
9789
9790 default:
9791 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9792 break;
9793 }
9794 putchar ('\n');
9795}
9796
9797static bfd_boolean
9798get_32bit_dynamic_section (Filedata * filedata)
9799{
9800 Elf32_External_Dyn * edyn;
9801 Elf32_External_Dyn * ext;
9802 Elf_Internal_Dyn * entry;
9803
9804 edyn = (Elf32_External_Dyn *) get_data (NULL, filedata,
9805 filedata->dynamic_addr, 1,
9806 filedata->dynamic_size,
9807 _("dynamic section"));
9808 if (!edyn)
9809 return FALSE;
9810
9811 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9812 might not have the luxury of section headers. Look for the DT_NULL
9813 terminator to determine the number of entries. */
9814 for (ext = edyn, filedata->dynamic_nent = 0;
9815 (char *) (ext + 1) <= (char *) edyn + filedata->dynamic_size;
9816 ext++)
9817 {
9818 filedata->dynamic_nent++;
9819 if (BYTE_GET (ext->d_tag) == DT_NULL)
9820 break;
9821 }
9822
9823 filedata->dynamic_section
9824 = (Elf_Internal_Dyn *) cmalloc (filedata->dynamic_nent, sizeof (* entry));
9825 if (filedata->dynamic_section == NULL)
9826 {
9827 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9828 (unsigned long) filedata->dynamic_nent);
9829 free (edyn);
9830 return FALSE;
9831 }
9832
9833 for (ext = edyn, entry = filedata->dynamic_section;
9834 entry < filedata->dynamic_section + filedata->dynamic_nent;
9835 ext++, entry++)
9836 {
9837 entry->d_tag = BYTE_GET (ext->d_tag);
9838 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9839 }
9840
9841 free (edyn);
9842
9843 return TRUE;
9844}
9845
9846static bfd_boolean
9847get_64bit_dynamic_section (Filedata * filedata)
9848{
9849 Elf64_External_Dyn * edyn;
9850 Elf64_External_Dyn * ext;
9851 Elf_Internal_Dyn * entry;
9852
9853 /* Read in the data. */
9854 edyn = (Elf64_External_Dyn *) get_data (NULL, filedata,
9855 filedata->dynamic_addr, 1,
9856 filedata->dynamic_size,
9857 _("dynamic section"));
9858 if (!edyn)
9859 return FALSE;
9860
9861 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9862 might not have the luxury of section headers. Look for the DT_NULL
9863 terminator to determine the number of entries. */
9864 for (ext = edyn, filedata->dynamic_nent = 0;
9865 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9866 (char *) (ext + 1) <= (char *) edyn + filedata->dynamic_size;
9867 ext++)
9868 {
9869 filedata->dynamic_nent++;
9870 if (BYTE_GET (ext->d_tag) == DT_NULL)
9871 break;
9872 }
9873
9874 filedata->dynamic_section
9875 = (Elf_Internal_Dyn *) cmalloc (filedata->dynamic_nent, sizeof (* entry));
9876 if (filedata->dynamic_section == NULL)
9877 {
9878 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9879 (unsigned long) filedata->dynamic_nent);
9880 free (edyn);
9881 return FALSE;
9882 }
9883
9884 /* Convert from external to internal formats. */
9885 for (ext = edyn, entry = filedata->dynamic_section;
9886 entry < filedata->dynamic_section + filedata->dynamic_nent;
9887 ext++, entry++)
9888 {
9889 entry->d_tag = BYTE_GET (ext->d_tag);
9890 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9891 }
9892
9893 free (edyn);
9894
9895 return TRUE;
9896}
9897
9898static void
9899print_dynamic_flags (bfd_vma flags)
9900{
9901 bfd_boolean first = TRUE;
9902
9903 while (flags)
9904 {
9905 bfd_vma flag;
9906
9907 flag = flags & - flags;
9908 flags &= ~ flag;
9909
9910 if (first)
9911 first = FALSE;
9912 else
9913 putc (' ', stdout);
9914
9915 switch (flag)
9916 {
9917 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
9918 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
9919 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
9920 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
9921 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
9922 default: fputs (_("unknown"), stdout); break;
9923 }
9924 }
9925 puts ("");
9926}
9927
9928static bfd_vma *
9929get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_size)
9930{
9931 unsigned char * e_data;
9932 bfd_vma * i_data;
9933
9934 /* If the size_t type is smaller than the bfd_size_type, eg because
9935 you are building a 32-bit tool on a 64-bit host, then make sure
9936 that when (number) is cast to (size_t) no information is lost. */
9937 if (sizeof (size_t) < sizeof (bfd_size_type)
9938 && (bfd_size_type) ((size_t) number) != number)
9939 {
9940 error (_("Size truncation prevents reading %s elements of size %u\n"),
9941 bfd_vmatoa ("u", number), ent_size);
9942 return NULL;
9943 }
9944
9945 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
9946 attempting to allocate memory when the read is bound to fail. */
9947 if (ent_size * number > filedata->file_size)
9948 {
9949 error (_("Invalid number of dynamic entries: %s\n"),
9950 bfd_vmatoa ("u", number));
9951 return NULL;
9952 }
9953
9954 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
9955 if (e_data == NULL)
9956 {
9957 error (_("Out of memory reading %s dynamic entries\n"),
9958 bfd_vmatoa ("u", number));
9959 return NULL;
9960 }
9961
9962 if (fread (e_data, ent_size, (size_t) number, filedata->handle) != number)
9963 {
9964 error (_("Unable to read in %s bytes of dynamic data\n"),
9965 bfd_vmatoa ("u", number * ent_size));
9966 free (e_data);
9967 return NULL;
9968 }
9969
9970 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
9971 if (i_data == NULL)
9972 {
9973 error (_("Out of memory allocating space for %s dynamic entries\n"),
9974 bfd_vmatoa ("u", number));
9975 free (e_data);
9976 return NULL;
9977 }
9978
9979 while (number--)
9980 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
9981
9982 free (e_data);
9983
9984 return i_data;
9985}
9986
9987static unsigned long
9988get_num_dynamic_syms (Filedata * filedata)
9989{
9990 unsigned long num_of_syms = 0;
9991
9992 if (!do_histogram && (!do_using_dynamic || do_dyn_syms))
9993 return num_of_syms;
9994
9995 if (filedata->dynamic_info[DT_HASH])
9996 {
9997 unsigned char nb[8];
9998 unsigned char nc[8];
9999 unsigned int hash_ent_size = 4;
10000
10001 if ((filedata->file_header.e_machine == EM_ALPHA
10002 || filedata->file_header.e_machine == EM_S390
10003 || filedata->file_header.e_machine == EM_S390_OLD)
10004 && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
10005 hash_ent_size = 8;
10006
10007 if (fseek (filedata->handle,
10008 (filedata->archive_file_offset
10009 + offset_from_vma (filedata, filedata->dynamic_info[DT_HASH],
10010 sizeof nb + sizeof nc)),
10011 SEEK_SET))
10012 {
10013 error (_("Unable to seek to start of dynamic information\n"));
10014 goto no_hash;
10015 }
10016
10017 if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
10018 {
10019 error (_("Failed to read in number of buckets\n"));
10020 goto no_hash;
10021 }
10022
10023 if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
10024 {
10025 error (_("Failed to read in number of chains\n"));
10026 goto no_hash;
10027 }
10028
10029 filedata->nbuckets = byte_get (nb, hash_ent_size);
10030 filedata->nchains = byte_get (nc, hash_ent_size);
10031
10032 if (filedata->nbuckets != 0 && filedata->nchains != 0)
10033 {
10034 filedata->buckets = get_dynamic_data (filedata, filedata->nbuckets,
10035 hash_ent_size);
10036 filedata->chains = get_dynamic_data (filedata, filedata->nchains,
10037 hash_ent_size);
10038
10039 if (filedata->buckets != NULL && filedata->chains != NULL)
10040 num_of_syms = filedata->nchains;
10041 }
10042 no_hash:
10043 if (num_of_syms == 0)
10044 {
10045 free (filedata->buckets);
10046 filedata->buckets = NULL;
10047 free (filedata->chains);
10048 filedata->chains = NULL;
10049 filedata->nbuckets = 0;
10050 }
10051 }
10052
10053 if (filedata->dynamic_info_DT_GNU_HASH)
10054 {
10055 unsigned char nb[16];
10056 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10057 bfd_vma buckets_vma;
10058 unsigned long hn;
10059
10060 if (fseek (filedata->handle,
10061 (filedata->archive_file_offset
10062 + offset_from_vma (filedata,
10063 filedata->dynamic_info_DT_GNU_HASH,
10064 sizeof nb)),
10065 SEEK_SET))
10066 {
10067 error (_("Unable to seek to start of dynamic information\n"));
10068 goto no_gnu_hash;
10069 }
10070
10071 if (fread (nb, 16, 1, filedata->handle) != 1)
10072 {
10073 error (_("Failed to read in number of buckets\n"));
10074 goto no_gnu_hash;
10075 }
10076
10077 filedata->ngnubuckets = byte_get (nb, 4);
10078 filedata->gnusymidx = byte_get (nb + 4, 4);
10079 bitmaskwords = byte_get (nb + 8, 4);
10080 buckets_vma = filedata->dynamic_info_DT_GNU_HASH + 16;
10081 if (is_32bit_elf)
10082 buckets_vma += bitmaskwords * 4;
10083 else
10084 buckets_vma += bitmaskwords * 8;
10085
10086 if (fseek (filedata->handle,
10087 (filedata->archive_file_offset
10088 + offset_from_vma (filedata, buckets_vma, 4)),
10089 SEEK_SET))
10090 {
10091 error (_("Unable to seek to start of dynamic information\n"));
10092 goto no_gnu_hash;
10093 }
10094
10095 filedata->gnubuckets
10096 = get_dynamic_data (filedata, filedata->ngnubuckets, 4);
10097
10098 if (filedata->gnubuckets == NULL)
10099 goto no_gnu_hash;
10100
10101 for (i = 0; i < filedata->ngnubuckets; i++)
10102 if (filedata->gnubuckets[i] != 0)
10103 {
10104 if (filedata->gnubuckets[i] < filedata->gnusymidx)
10105 goto no_gnu_hash;
10106
10107 if (maxchain == 0xffffffff || filedata->gnubuckets[i] > maxchain)
10108 maxchain = filedata->gnubuckets[i];
10109 }
10110
10111 if (maxchain == 0xffffffff)
10112 goto no_gnu_hash;
10113
10114 maxchain -= filedata->gnusymidx;
10115
10116 if (fseek (filedata->handle,
10117 (filedata->archive_file_offset
10118 + offset_from_vma (filedata,
10119 buckets_vma + 4 * (filedata->ngnubuckets
10120 + maxchain),
10121 4)),
10122 SEEK_SET))
10123 {
10124 error (_("Unable to seek to start of dynamic information\n"));
10125 goto no_gnu_hash;
10126 }
10127
10128 do
10129 {
10130 if (fread (nb, 4, 1, filedata->handle) != 1)
10131 {
10132 error (_("Failed to determine last chain length\n"));
10133 goto no_gnu_hash;
10134 }
10135
10136 if (maxchain + 1 == 0)
10137 goto no_gnu_hash;
10138
10139 ++maxchain;
10140 }
10141 while ((byte_get (nb, 4) & 1) == 0);
10142
10143 if (fseek (filedata->handle,
10144 (filedata->archive_file_offset
10145 + offset_from_vma (filedata, (buckets_vma
10146 + 4 * filedata->ngnubuckets),
10147 4)),
10148 SEEK_SET))
10149 {
10150 error (_("Unable to seek to start of dynamic information\n"));
10151 goto no_gnu_hash;
10152 }
10153
10154 filedata->gnuchains = get_dynamic_data (filedata, maxchain, 4);
10155 filedata->ngnuchains = maxchain;
10156
10157 if (filedata->gnuchains == NULL)
10158 goto no_gnu_hash;
10159
10160 if (filedata->dynamic_info_DT_MIPS_XHASH)
10161 {
10162 if (fseek (filedata->handle,
10163 (filedata->archive_file_offset
10164 + offset_from_vma (filedata, (buckets_vma
10165 + 4 * (filedata->ngnubuckets
10166 + maxchain)), 4)),
10167 SEEK_SET))
10168 {
10169 error (_("Unable to seek to start of dynamic information\n"));
10170 goto no_gnu_hash;
10171 }
10172
10173 filedata->mipsxlat = get_dynamic_data (filedata, maxchain, 4);
10174 if (filedata->mipsxlat == NULL)
10175 goto no_gnu_hash;
10176 }
10177
10178 for (hn = 0; hn < filedata->ngnubuckets; ++hn)
10179 if (filedata->gnubuckets[hn] != 0)
10180 {
10181 bfd_vma si = filedata->gnubuckets[hn];
10182 bfd_vma off = si - filedata->gnusymidx;
10183
10184 do
10185 {
10186 if (filedata->dynamic_info_DT_MIPS_XHASH)
10187 {
10188 if (off < filedata->ngnuchains
10189 && filedata->mipsxlat[off] >= num_of_syms)
10190 num_of_syms = filedata->mipsxlat[off] + 1;
10191 }
10192 else
10193 {
10194 if (si >= num_of_syms)
10195 num_of_syms = si + 1;
10196 }
10197 si++;
10198 }
10199 while (off < filedata->ngnuchains
10200 && (filedata->gnuchains[off++] & 1) == 0);
10201 }
10202
10203 if (num_of_syms == 0)
10204 {
10205 no_gnu_hash:
10206 free (filedata->mipsxlat);
10207 filedata->mipsxlat = NULL;
10208 free (filedata->gnuchains);
10209 filedata->gnuchains = NULL;
10210 free (filedata->gnubuckets);
10211 filedata->gnubuckets = NULL;
10212 filedata->ngnubuckets = 0;
10213 filedata->ngnuchains = 0;
10214 }
10215 }
10216
10217 return num_of_syms;
10218}
10219
10220/* Parse and display the contents of the dynamic section. */
10221
10222static bfd_boolean
10223process_dynamic_section (Filedata * filedata)
10224{
10225 Elf_Internal_Dyn * entry;
10226
10227 if (filedata->dynamic_size == 0)
10228 {
10229 if (do_dynamic)
10230 printf (_("\nThere is no dynamic section in this file.\n"));
10231
10232 return TRUE;
10233 }
10234
10235 if (is_32bit_elf)
10236 {
10237 if (! get_32bit_dynamic_section (filedata))
10238 return FALSE;
10239 }
10240 else
10241 {
10242 if (! get_64bit_dynamic_section (filedata))
10243 return FALSE;
10244 }
10245
10246 /* Find the appropriate symbol table. */
10247 if (filedata->dynamic_symbols == NULL || do_histogram)
10248 {
10249 unsigned long num_of_syms;
10250
10251 for (entry = filedata->dynamic_section;
10252 entry < filedata->dynamic_section + filedata->dynamic_nent;
10253 ++entry)
10254 if (entry->d_tag == DT_SYMTAB)
10255 filedata->dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
10256 else if (entry->d_tag == DT_SYMENT)
10257 filedata->dynamic_info[DT_SYMENT] = entry->d_un.d_val;
10258 else if (entry->d_tag == DT_HASH)
10259 filedata->dynamic_info[DT_HASH] = entry->d_un.d_val;
10260 else if (entry->d_tag == DT_GNU_HASH)
10261 filedata->dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10262 else if ((filedata->file_header.e_machine == EM_MIPS
10263 || filedata->file_header.e_machine == EM_MIPS_RS3_LE)
10264 && entry->d_tag == DT_MIPS_XHASH)
10265 {
10266 filedata->dynamic_info_DT_MIPS_XHASH = entry->d_un.d_val;
10267 filedata->dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10268 }
10269
10270 num_of_syms = get_num_dynamic_syms (filedata);
10271
10272 if (num_of_syms != 0
10273 && filedata->dynamic_symbols == NULL
10274 && filedata->dynamic_info[DT_SYMTAB]
10275 && filedata->dynamic_info[DT_SYMENT])
10276 {
10277 Elf_Internal_Phdr *seg;
10278 bfd_vma vma = filedata->dynamic_info[DT_SYMTAB];
10279
10280 if (! get_program_headers (filedata))
10281 {
10282 error (_("Cannot interpret virtual addresses "
10283 "without program headers.\n"));
10284 return FALSE;
10285 }
10286
10287 for (seg = filedata->program_headers;
10288 seg < filedata->program_headers + filedata->file_header.e_phnum;
10289 ++seg)
10290 {
10291 if (seg->p_type != PT_LOAD)
10292 continue;
10293
10294 if (seg->p_offset + seg->p_filesz > filedata->file_size)
10295 {
10296 /* See PR 21379 for a reproducer. */
10297 error (_("Invalid PT_LOAD entry\n"));
10298 return FALSE;
10299 }
10300
10301 if (vma >= (seg->p_vaddr & -seg->p_align)
10302 && vma < seg->p_vaddr + seg->p_filesz)
10303 {
10304 /* Since we do not know how big the symbol table is,
10305 we default to reading in up to the end of PT_LOAD
10306 segment and processing that. This is overkill, I
10307 know, but it should work. */
10308 Elf_Internal_Shdr section;
10309 section.sh_offset = (vma - seg->p_vaddr
10310 + seg->p_offset);
10311 section.sh_size = (num_of_syms
10312 * filedata->dynamic_info[DT_SYMENT]);
10313 section.sh_entsize = filedata->dynamic_info[DT_SYMENT];
10314
10315 if (do_checks
10316 && filedata->dynamic_symtab_section != NULL
10317 && ((filedata->dynamic_symtab_section->sh_offset
10318 != section.sh_offset)
10319 || (filedata->dynamic_symtab_section->sh_size
10320 != section.sh_size)
10321 || (filedata->dynamic_symtab_section->sh_entsize
10322 != section.sh_entsize)))
10323 warn (_("\
10324the .dynsym section doesn't match the DT_SYMTAB and DT_SYMENT tags\n"));
10325
10326 section.sh_name = filedata->string_table_length;
10327 filedata->dynamic_symbols
10328 = GET_ELF_SYMBOLS (filedata, &section,
10329 &filedata->num_dynamic_syms);
10330 if (filedata->dynamic_symbols == NULL
10331 || filedata->num_dynamic_syms != num_of_syms)
10332 {
10333 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
10334 return FALSE;
10335 }
10336 break;
10337 }
10338 }
10339 }
10340 }
10341
10342 /* Similarly find a string table. */
10343 if (filedata->dynamic_strings == NULL)
10344 for (entry = filedata->dynamic_section;
10345 entry < filedata->dynamic_section + filedata->dynamic_nent;
10346 ++entry)
10347 {
10348 if (entry->d_tag == DT_STRTAB)
10349 filedata->dynamic_info[DT_STRTAB] = entry->d_un.d_val;
10350
10351 if (entry->d_tag == DT_STRSZ)
10352 filedata->dynamic_info[DT_STRSZ] = entry->d_un.d_val;
10353
10354 if (filedata->dynamic_info[DT_STRTAB]
10355 && filedata->dynamic_info[DT_STRSZ])
10356 {
10357 unsigned long offset;
10358 bfd_size_type str_tab_len = filedata->dynamic_info[DT_STRSZ];
10359
10360 offset = offset_from_vma (filedata,
10361 filedata->dynamic_info[DT_STRTAB],
10362 str_tab_len);
10363 if (do_checks
10364 && filedata->dynamic_strtab_section
10365 && ((filedata->dynamic_strtab_section->sh_offset
10366 != (file_ptr) offset)
10367 || (filedata->dynamic_strtab_section->sh_size
10368 != str_tab_len)))
10369 warn (_("\
10370the .dynstr section doesn't match the DT_STRTAB and DT_STRSZ tags\n"));
10371
10372 filedata->dynamic_strings
10373 = (char *) get_data (NULL, filedata, offset, 1, str_tab_len,
10374 _("dynamic string table"));
10375 if (filedata->dynamic_strings == NULL)
10376 {
10377 error (_("Corrupt DT_STRTAB dynamic entry\n"));
10378 break;
10379 }
10380
10381 filedata->dynamic_strings_length = str_tab_len;
10382 break;
10383 }
10384 }
10385
10386 /* And find the syminfo section if available. */
10387 if (filedata->dynamic_syminfo == NULL)
10388 {
10389 unsigned long syminsz = 0;
10390
10391 for (entry = filedata->dynamic_section;
10392 entry < filedata->dynamic_section + filedata->dynamic_nent;
10393 ++entry)
10394 {
10395 if (entry->d_tag == DT_SYMINENT)
10396 {
10397 /* Note: these braces are necessary to avoid a syntax
10398 error from the SunOS4 C compiler. */
10399 /* PR binutils/17531: A corrupt file can trigger this test.
10400 So do not use an assert, instead generate an error message. */
10401 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
10402 error (_("Bad value (%d) for SYMINENT entry\n"),
10403 (int) entry->d_un.d_val);
10404 }
10405 else if (entry->d_tag == DT_SYMINSZ)
10406 syminsz = entry->d_un.d_val;
10407 else if (entry->d_tag == DT_SYMINFO)
10408 filedata->dynamic_syminfo_offset
10409 = offset_from_vma (filedata, entry->d_un.d_val, syminsz);
10410 }
10411
10412 if (filedata->dynamic_syminfo_offset != 0 && syminsz != 0)
10413 {
10414 Elf_External_Syminfo * extsyminfo;
10415 Elf_External_Syminfo * extsym;
10416 Elf_Internal_Syminfo * syminfo;
10417
10418 /* There is a syminfo section. Read the data. */
10419 extsyminfo = (Elf_External_Syminfo *)
10420 get_data (NULL, filedata, filedata->dynamic_syminfo_offset,
10421 1, syminsz, _("symbol information"));
10422 if (!extsyminfo)
10423 return FALSE;
10424
10425 if (filedata->dynamic_syminfo != NULL)
10426 {
10427 error (_("Multiple dynamic symbol information sections found\n"));
10428 free (filedata->dynamic_syminfo);
10429 }
10430 filedata->dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
10431 if (filedata->dynamic_syminfo == NULL)
10432 {
10433 error (_("Out of memory allocating %lu bytes "
10434 "for dynamic symbol info\n"),
10435 (unsigned long) syminsz);
10436 return FALSE;
10437 }
10438
10439 filedata->dynamic_syminfo_nent
10440 = syminsz / sizeof (Elf_External_Syminfo);
10441 for (syminfo = filedata->dynamic_syminfo, extsym = extsyminfo;
10442 syminfo < (filedata->dynamic_syminfo
10443 + filedata->dynamic_syminfo_nent);
10444 ++syminfo, ++extsym)
10445 {
10446 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
10447 syminfo->si_flags = BYTE_GET (extsym->si_flags);
10448 }
10449
10450 free (extsyminfo);
10451 }
10452 }
10453
10454 if (do_dynamic && filedata->dynamic_addr)
10455 printf (ngettext ("\nDynamic section at offset 0x%lx "
10456 "contains %lu entry:\n",
10457 "\nDynamic section at offset 0x%lx "
10458 "contains %lu entries:\n",
10459 filedata->dynamic_nent),
10460 filedata->dynamic_addr, (unsigned long) filedata->dynamic_nent);
10461 if (do_dynamic)
10462 printf (_(" Tag Type Name/Value\n"));
10463
10464 for (entry = filedata->dynamic_section;
10465 entry < filedata->dynamic_section + filedata->dynamic_nent;
10466 entry++)
10467 {
10468 if (do_dynamic)
10469 {
10470 const char * dtype;
10471
10472 putchar (' ');
10473 print_vma (entry->d_tag, FULL_HEX);
10474 dtype = get_dynamic_type (filedata, entry->d_tag);
10475 printf (" (%s)%*s", dtype,
10476 ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
10477 }
10478
10479 switch (entry->d_tag)
10480 {
10481 case DT_FLAGS:
10482 if (do_dynamic)
10483 print_dynamic_flags (entry->d_un.d_val);
10484 break;
10485
10486 case DT_AUXILIARY:
10487 case DT_FILTER:
10488 case DT_CONFIG:
10489 case DT_DEPAUDIT:
10490 case DT_AUDIT:
10491 if (do_dynamic)
10492 {
10493 switch (entry->d_tag)
10494 {
10495 case DT_AUXILIARY:
10496 printf (_("Auxiliary library"));
10497 break;
10498
10499 case DT_FILTER:
10500 printf (_("Filter library"));
10501 break;
10502
10503 case DT_CONFIG:
10504 printf (_("Configuration file"));
10505 break;
10506
10507 case DT_DEPAUDIT:
10508 printf (_("Dependency audit library"));
10509 break;
10510
10511 case DT_AUDIT:
10512 printf (_("Audit library"));
10513 break;
10514 }
10515
10516 if (VALID_DYNAMIC_NAME (filedata, entry->d_un.d_val))
10517 printf (": [%s]\n",
10518 GET_DYNAMIC_NAME (filedata, entry->d_un.d_val));
10519 else
10520 {
10521 printf (": ");
10522 print_vma (entry->d_un.d_val, PREFIX_HEX);
10523 putchar ('\n');
10524 }
10525 }
10526 break;
10527
10528 case DT_FEATURE:
10529 if (do_dynamic)
10530 {
10531 printf (_("Flags:"));
10532
10533 if (entry->d_un.d_val == 0)
10534 printf (_(" None\n"));
10535 else
10536 {
10537 unsigned long int val = entry->d_un.d_val;
10538
10539 if (val & DTF_1_PARINIT)
10540 {
10541 printf (" PARINIT");
10542 val ^= DTF_1_PARINIT;
10543 }
10544 if (val & DTF_1_CONFEXP)
10545 {
10546 printf (" CONFEXP");
10547 val ^= DTF_1_CONFEXP;
10548 }
10549 if (val != 0)
10550 printf (" %lx", val);
10551 puts ("");
10552 }
10553 }
10554 break;
10555
10556 case DT_POSFLAG_1:
10557 if (do_dynamic)
10558 {
10559 printf (_("Flags:"));
10560
10561 if (entry->d_un.d_val == 0)
10562 printf (_(" None\n"));
10563 else
10564 {
10565 unsigned long int val = entry->d_un.d_val;
10566
10567 if (val & DF_P1_LAZYLOAD)
10568 {
10569 printf (" LAZYLOAD");
10570 val ^= DF_P1_LAZYLOAD;
10571 }
10572 if (val & DF_P1_GROUPPERM)
10573 {
10574 printf (" GROUPPERM");
10575 val ^= DF_P1_GROUPPERM;
10576 }
10577 if (val != 0)
10578 printf (" %lx", val);
10579 puts ("");
10580 }
10581 }
10582 break;
10583
10584 case DT_FLAGS_1:
10585 if (do_dynamic)
10586 {
10587 printf (_("Flags:"));
10588 if (entry->d_un.d_val == 0)
10589 printf (_(" None\n"));
10590 else
10591 {
10592 unsigned long int val = entry->d_un.d_val;
10593
10594 if (val & DF_1_NOW)
10595 {
10596 printf (" NOW");
10597 val ^= DF_1_NOW;
10598 }
10599 if (val & DF_1_GLOBAL)
10600 {
10601 printf (" GLOBAL");
10602 val ^= DF_1_GLOBAL;
10603 }
10604 if (val & DF_1_GROUP)
10605 {
10606 printf (" GROUP");
10607 val ^= DF_1_GROUP;
10608 }
10609 if (val & DF_1_NODELETE)
10610 {
10611 printf (" NODELETE");
10612 val ^= DF_1_NODELETE;
10613 }
10614 if (val & DF_1_LOADFLTR)
10615 {
10616 printf (" LOADFLTR");
10617 val ^= DF_1_LOADFLTR;
10618 }
10619 if (val & DF_1_INITFIRST)
10620 {
10621 printf (" INITFIRST");
10622 val ^= DF_1_INITFIRST;
10623 }
10624 if (val & DF_1_NOOPEN)
10625 {
10626 printf (" NOOPEN");
10627 val ^= DF_1_NOOPEN;
10628 }
10629 if (val & DF_1_ORIGIN)
10630 {
10631 printf (" ORIGIN");
10632 val ^= DF_1_ORIGIN;
10633 }
10634 if (val & DF_1_DIRECT)
10635 {
10636 printf (" DIRECT");
10637 val ^= DF_1_DIRECT;
10638 }
10639 if (val & DF_1_TRANS)
10640 {
10641 printf (" TRANS");
10642 val ^= DF_1_TRANS;
10643 }
10644 if (val & DF_1_INTERPOSE)
10645 {
10646 printf (" INTERPOSE");
10647 val ^= DF_1_INTERPOSE;
10648 }
10649 if (val & DF_1_NODEFLIB)
10650 {
10651 printf (" NODEFLIB");
10652 val ^= DF_1_NODEFLIB;
10653 }
10654 if (val & DF_1_NODUMP)
10655 {
10656 printf (" NODUMP");
10657 val ^= DF_1_NODUMP;
10658 }
10659 if (val & DF_1_CONFALT)
10660 {
10661 printf (" CONFALT");
10662 val ^= DF_1_CONFALT;
10663 }
10664 if (val & DF_1_ENDFILTEE)
10665 {
10666 printf (" ENDFILTEE");
10667 val ^= DF_1_ENDFILTEE;
10668 }
10669 if (val & DF_1_DISPRELDNE)
10670 {
10671 printf (" DISPRELDNE");
10672 val ^= DF_1_DISPRELDNE;
10673 }
10674 if (val & DF_1_DISPRELPND)
10675 {
10676 printf (" DISPRELPND");
10677 val ^= DF_1_DISPRELPND;
10678 }
10679 if (val & DF_1_NODIRECT)
10680 {
10681 printf (" NODIRECT");
10682 val ^= DF_1_NODIRECT;
10683 }
10684 if (val & DF_1_IGNMULDEF)
10685 {
10686 printf (" IGNMULDEF");
10687 val ^= DF_1_IGNMULDEF;
10688 }
10689 if (val & DF_1_NOKSYMS)
10690 {
10691 printf (" NOKSYMS");
10692 val ^= DF_1_NOKSYMS;
10693 }
10694 if (val & DF_1_NOHDR)
10695 {
10696 printf (" NOHDR");
10697 val ^= DF_1_NOHDR;
10698 }
10699 if (val & DF_1_EDITED)
10700 {
10701 printf (" EDITED");
10702 val ^= DF_1_EDITED;
10703 }
10704 if (val & DF_1_NORELOC)
10705 {
10706 printf (" NORELOC");
10707 val ^= DF_1_NORELOC;
10708 }
10709 if (val & DF_1_SYMINTPOSE)
10710 {
10711 printf (" SYMINTPOSE");
10712 val ^= DF_1_SYMINTPOSE;
10713 }
10714 if (val & DF_1_GLOBAUDIT)
10715 {
10716 printf (" GLOBAUDIT");
10717 val ^= DF_1_GLOBAUDIT;
10718 }
10719 if (val & DF_1_SINGLETON)
10720 {
10721 printf (" SINGLETON");
10722 val ^= DF_1_SINGLETON;
10723 }
10724 if (val & DF_1_STUB)
10725 {
10726 printf (" STUB");
10727 val ^= DF_1_STUB;
10728 }
10729 if (val & DF_1_PIE)
10730 {
10731 printf (" PIE");
10732 val ^= DF_1_PIE;
10733 }
10734 if (val & DF_1_KMOD)
10735 {
10736 printf (" KMOD");
10737 val ^= DF_1_KMOD;
10738 }
10739 if (val & DF_1_WEAKFILTER)
10740 {
10741 printf (" WEAKFILTER");
10742 val ^= DF_1_WEAKFILTER;
10743 }
10744 if (val & DF_1_NOCOMMON)
10745 {
10746 printf (" NOCOMMON");
10747 val ^= DF_1_NOCOMMON;
10748 }
10749 if (val != 0)
10750 printf (" %lx", val);
10751 puts ("");
10752 }
10753 }
10754 break;
10755
10756 case DT_PLTREL:
10757 filedata->dynamic_info[entry->d_tag] = entry->d_un.d_val;
10758 if (do_dynamic)
10759 puts (get_dynamic_type (filedata, entry->d_un.d_val));
10760 break;
10761
10762 case DT_NULL :
10763 case DT_NEEDED :
10764 case DT_PLTGOT :
10765 case DT_HASH :
10766 case DT_STRTAB :
10767 case DT_SYMTAB :
10768 case DT_RELA :
10769 case DT_INIT :
10770 case DT_FINI :
10771 case DT_SONAME :
10772 case DT_RPATH :
10773 case DT_SYMBOLIC:
10774 case DT_REL :
10775 case DT_DEBUG :
10776 case DT_TEXTREL :
10777 case DT_JMPREL :
10778 case DT_RUNPATH :
10779 filedata->dynamic_info[entry->d_tag] = entry->d_un.d_val;
10780
10781 if (do_dynamic)
10782 {
10783 char * name;
10784
10785 if (VALID_DYNAMIC_NAME (filedata, entry->d_un.d_val))
10786 name = GET_DYNAMIC_NAME (filedata, entry->d_un.d_val);
10787 else
10788 name = NULL;
10789
10790 if (name)
10791 {
10792 switch (entry->d_tag)
10793 {
10794 case DT_NEEDED:
10795 printf (_("Shared library: [%s]"), name);
10796
10797 if (streq (name, filedata->program_interpreter))
10798 printf (_(" program interpreter"));
10799 break;
10800
10801 case DT_SONAME:
10802 printf (_("Library soname: [%s]"), name);
10803 break;
10804
10805 case DT_RPATH:
10806 printf (_("Library rpath: [%s]"), name);
10807 break;
10808
10809 case DT_RUNPATH:
10810 printf (_("Library runpath: [%s]"), name);
10811 break;
10812
10813 default:
10814 print_vma (entry->d_un.d_val, PREFIX_HEX);
10815 break;
10816 }
10817 }
10818 else
10819 print_vma (entry->d_un.d_val, PREFIX_HEX);
10820
10821 putchar ('\n');
10822 }
10823 break;
10824
10825 case DT_PLTRELSZ:
10826 case DT_RELASZ :
10827 case DT_STRSZ :
10828 case DT_RELSZ :
10829 case DT_RELAENT :
10830 case DT_SYMENT :
10831 case DT_RELENT :
10832 filedata->dynamic_info[entry->d_tag] = entry->d_un.d_val;
10833 /* Fall through. */
10834 case DT_PLTPADSZ:
10835 case DT_MOVEENT :
10836 case DT_MOVESZ :
10837 case DT_INIT_ARRAYSZ:
10838 case DT_FINI_ARRAYSZ:
10839 case DT_GNU_CONFLICTSZ:
10840 case DT_GNU_LIBLISTSZ:
10841 if (do_dynamic)
10842 {
10843 print_vma (entry->d_un.d_val, UNSIGNED);
10844 printf (_(" (bytes)\n"));
10845 }
10846 break;
10847
10848 case DT_VERDEFNUM:
10849 case DT_VERNEEDNUM:
10850 case DT_RELACOUNT:
10851 case DT_RELCOUNT:
10852 if (do_dynamic)
10853 {
10854 print_vma (entry->d_un.d_val, UNSIGNED);
10855 putchar ('\n');
10856 }
10857 break;
10858
10859 case DT_SYMINSZ:
10860 case DT_SYMINENT:
10861 case DT_SYMINFO:
10862 case DT_USED:
10863 case DT_INIT_ARRAY:
10864 case DT_FINI_ARRAY:
10865 if (do_dynamic)
10866 {
10867 if (entry->d_tag == DT_USED
10868 && VALID_DYNAMIC_NAME (filedata, entry->d_un.d_val))
10869 {
10870 char * name = GET_DYNAMIC_NAME (filedata, entry->d_un.d_val);
10871
10872 if (*name)
10873 {
10874 printf (_("Not needed object: [%s]\n"), name);
10875 break;
10876 }
10877 }
10878
10879 print_vma (entry->d_un.d_val, PREFIX_HEX);
10880 putchar ('\n');
10881 }
10882 break;
10883
10884 case DT_BIND_NOW:
10885 /* The value of this entry is ignored. */
10886 if (do_dynamic)
10887 putchar ('\n');
10888 break;
10889
10890 case DT_GNU_PRELINKED:
10891 if (do_dynamic)
10892 {
10893 struct tm * tmp;
10894 time_t atime = entry->d_un.d_val;
10895
10896 tmp = gmtime (&atime);
10897 /* PR 17533 file: 041-1244816-0.004. */
10898 if (tmp == NULL)
10899 printf (_("<corrupt time val: %lx"),
10900 (unsigned long) atime);
10901 else
10902 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10903 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10904 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10905
10906 }
10907 break;
10908
10909 case DT_GNU_HASH:
10910 filedata->dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10911 if (do_dynamic)
10912 {
10913 print_vma (entry->d_un.d_val, PREFIX_HEX);
10914 putchar ('\n');
10915 }
10916 break;
10917
10918 default:
10919 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10920 filedata->version_info[DT_VERSIONTAGIDX (entry->d_tag)]
10921 = entry->d_un.d_val;
10922
10923 if (do_dynamic)
10924 {
10925 switch (filedata->file_header.e_machine)
10926 {
10927 case EM_AARCH64:
10928 dynamic_section_aarch64_val (entry);
10929 break;
10930 case EM_MIPS:
10931 case EM_MIPS_RS3_LE:
10932 dynamic_section_mips_val (filedata, entry);
10933 break;
10934 case EM_PARISC:
10935 dynamic_section_parisc_val (entry);
10936 break;
10937 case EM_IA_64:
10938 dynamic_section_ia64_val (entry);
10939 break;
10940 default:
10941 print_vma (entry->d_un.d_val, PREFIX_HEX);
10942 putchar ('\n');
10943 }
10944 }
10945 break;
10946 }
10947 }
10948
10949 return TRUE;
10950}
10951
10952static char *
10953get_ver_flags (unsigned int flags)
10954{
10955 static char buff[128];
10956
10957 buff[0] = 0;
10958
10959 if (flags == 0)
10960 return _("none");
10961
10962 if (flags & VER_FLG_BASE)
10963 strcat (buff, "BASE");
10964
10965 if (flags & VER_FLG_WEAK)
10966 {
10967 if (flags & VER_FLG_BASE)
10968 strcat (buff, " | ");
10969
10970 strcat (buff, "WEAK");
10971 }
10972
10973 if (flags & VER_FLG_INFO)
10974 {
10975 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10976 strcat (buff, " | ");
10977
10978 strcat (buff, "INFO");
10979 }
10980
10981 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10982 {
10983 if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10984 strcat (buff, " | ");
10985
10986 strcat (buff, _("<unknown>"));
10987 }
10988
10989 return buff;
10990}
10991
10992/* Display the contents of the version sections. */
10993
10994static bfd_boolean
10995process_version_sections (Filedata * filedata)
10996{
10997 Elf_Internal_Shdr * section;
10998 unsigned i;
10999 bfd_boolean found = FALSE;
11000
11001 if (! do_version)
11002 return TRUE;
11003
11004 for (i = 0, section = filedata->section_headers;
11005 i < filedata->file_header.e_shnum;
11006 i++, section++)
11007 {
11008 switch (section->sh_type)
11009 {
11010 case SHT_GNU_verdef:
11011 {
11012 Elf_External_Verdef * edefs;
11013 unsigned long idx;
11014 unsigned long cnt;
11015 char * endbuf;
11016
11017 found = TRUE;
11018
11019 printf (ngettext ("\nVersion definition section '%s' "
11020 "contains %u entry:\n",
11021 "\nVersion definition section '%s' "
11022 "contains %u entries:\n",
11023 section->sh_info),
11024 printable_section_name (filedata, section),
11025 section->sh_info);
11026
11027 printf (_(" Addr: 0x"));
11028 printf_vma (section->sh_addr);
11029 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11030 (unsigned long) section->sh_offset, section->sh_link,
11031 printable_section_name_from_index (filedata, section->sh_link));
11032
11033 edefs = (Elf_External_Verdef *)
11034 get_data (NULL, filedata, section->sh_offset, 1,section->sh_size,
11035 _("version definition section"));
11036 if (!edefs)
11037 break;
11038 endbuf = (char *) edefs + section->sh_size;
11039
11040 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
11041 {
11042 char * vstart;
11043 Elf_External_Verdef * edef;
11044 Elf_Internal_Verdef ent;
11045 Elf_External_Verdaux * eaux;
11046 Elf_Internal_Verdaux aux;
11047 unsigned long isum;
11048 int j;
11049
11050 vstart = ((char *) edefs) + idx;
11051 if (vstart + sizeof (*edef) > endbuf)
11052 break;
11053
11054 edef = (Elf_External_Verdef *) vstart;
11055
11056 ent.vd_version = BYTE_GET (edef->vd_version);
11057 ent.vd_flags = BYTE_GET (edef->vd_flags);
11058 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
11059 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
11060 ent.vd_hash = BYTE_GET (edef->vd_hash);
11061 ent.vd_aux = BYTE_GET (edef->vd_aux);
11062 ent.vd_next = BYTE_GET (edef->vd_next);
11063
11064 printf (_(" %#06lx: Rev: %d Flags: %s"),
11065 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
11066
11067 printf (_(" Index: %d Cnt: %d "),
11068 ent.vd_ndx, ent.vd_cnt);
11069
11070 /* Check for overflow. */
11071 if (ent.vd_aux > (size_t) (endbuf - vstart))
11072 break;
11073
11074 vstart += ent.vd_aux;
11075
11076 if (vstart + sizeof (*eaux) > endbuf)
11077 break;
11078 eaux = (Elf_External_Verdaux *) vstart;
11079
11080 aux.vda_name = BYTE_GET (eaux->vda_name);
11081 aux.vda_next = BYTE_GET (eaux->vda_next);
11082
11083 if (VALID_DYNAMIC_NAME (filedata, aux.vda_name))
11084 printf (_("Name: %s\n"),
11085 GET_DYNAMIC_NAME (filedata, aux.vda_name));
11086 else
11087 printf (_("Name index: %ld\n"), aux.vda_name);
11088
11089 isum = idx + ent.vd_aux;
11090
11091 for (j = 1; j < ent.vd_cnt; j++)
11092 {
11093 if (aux.vda_next < sizeof (*eaux)
11094 && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
11095 {
11096 warn (_("Invalid vda_next field of %lx\n"),
11097 aux.vda_next);
11098 j = ent.vd_cnt;
11099 break;
11100 }
11101 /* Check for overflow. */
11102 if (aux.vda_next > (size_t) (endbuf - vstart))
11103 break;
11104
11105 isum += aux.vda_next;
11106 vstart += aux.vda_next;
11107
11108 if (vstart + sizeof (*eaux) > endbuf)
11109 break;
11110 eaux = (Elf_External_Verdaux *) vstart;
11111
11112 aux.vda_name = BYTE_GET (eaux->vda_name);
11113 aux.vda_next = BYTE_GET (eaux->vda_next);
11114
11115 if (VALID_DYNAMIC_NAME (filedata, aux.vda_name))
11116 printf (_(" %#06lx: Parent %d: %s\n"),
11117 isum, j,
11118 GET_DYNAMIC_NAME (filedata, aux.vda_name));
11119 else
11120 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
11121 isum, j, aux.vda_name);
11122 }
11123
11124 if (j < ent.vd_cnt)
11125 printf (_(" Version def aux past end of section\n"));
11126
11127 /* PR 17531:
11128 file: id:000001,src:000172+005151,op:splice,rep:2. */
11129 if (ent.vd_next < sizeof (*edef)
11130 && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
11131 {
11132 warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
11133 cnt = section->sh_info;
11134 break;
11135 }
11136 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
11137 break;
11138
11139 idx += ent.vd_next;
11140 }
11141
11142 if (cnt < section->sh_info)
11143 printf (_(" Version definition past end of section\n"));
11144
11145 free (edefs);
11146 }
11147 break;
11148
11149 case SHT_GNU_verneed:
11150 {
11151 Elf_External_Verneed * eneed;
11152 unsigned long idx;
11153 unsigned long cnt;
11154 char * endbuf;
11155
11156 found = TRUE;
11157
11158 printf (ngettext ("\nVersion needs section '%s' "
11159 "contains %u entry:\n",
11160 "\nVersion needs section '%s' "
11161 "contains %u entries:\n",
11162 section->sh_info),
11163 printable_section_name (filedata, section), section->sh_info);
11164
11165 printf (_(" Addr: 0x"));
11166 printf_vma (section->sh_addr);
11167 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11168 (unsigned long) section->sh_offset, section->sh_link,
11169 printable_section_name_from_index (filedata, section->sh_link));
11170
11171 eneed = (Elf_External_Verneed *) get_data (NULL, filedata,
11172 section->sh_offset, 1,
11173 section->sh_size,
11174 _("Version Needs section"));
11175 if (!eneed)
11176 break;
11177 endbuf = (char *) eneed + section->sh_size;
11178
11179 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
11180 {
11181 Elf_External_Verneed * entry;
11182 Elf_Internal_Verneed ent;
11183 unsigned long isum;
11184 int j;
11185 char * vstart;
11186
11187 vstart = ((char *) eneed) + idx;
11188 if (vstart + sizeof (*entry) > endbuf)
11189 break;
11190
11191 entry = (Elf_External_Verneed *) vstart;
11192
11193 ent.vn_version = BYTE_GET (entry->vn_version);
11194 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
11195 ent.vn_file = BYTE_GET (entry->vn_file);
11196 ent.vn_aux = BYTE_GET (entry->vn_aux);
11197 ent.vn_next = BYTE_GET (entry->vn_next);
11198
11199 printf (_(" %#06lx: Version: %d"), idx, ent.vn_version);
11200
11201 if (VALID_DYNAMIC_NAME (filedata, ent.vn_file))
11202 printf (_(" File: %s"),
11203 GET_DYNAMIC_NAME (filedata, ent.vn_file));
11204 else
11205 printf (_(" File: %lx"), ent.vn_file);
11206
11207 printf (_(" Cnt: %d\n"), ent.vn_cnt);
11208
11209 /* Check for overflow. */
11210 if (ent.vn_aux > (size_t) (endbuf - vstart))
11211 break;
11212 vstart += ent.vn_aux;
11213
11214 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
11215 {
11216 Elf_External_Vernaux * eaux;
11217 Elf_Internal_Vernaux aux;
11218
11219 if (vstart + sizeof (*eaux) > endbuf)
11220 break;
11221 eaux = (Elf_External_Vernaux *) vstart;
11222
11223 aux.vna_hash = BYTE_GET (eaux->vna_hash);
11224 aux.vna_flags = BYTE_GET (eaux->vna_flags);
11225 aux.vna_other = BYTE_GET (eaux->vna_other);
11226 aux.vna_name = BYTE_GET (eaux->vna_name);
11227 aux.vna_next = BYTE_GET (eaux->vna_next);
11228
11229 if (VALID_DYNAMIC_NAME (filedata, aux.vna_name))
11230 printf (_(" %#06lx: Name: %s"),
11231 isum, GET_DYNAMIC_NAME (filedata, aux.vna_name));
11232 else
11233 printf (_(" %#06lx: Name index: %lx"),
11234 isum, aux.vna_name);
11235
11236 printf (_(" Flags: %s Version: %d\n"),
11237 get_ver_flags (aux.vna_flags), aux.vna_other);
11238
11239 if (aux.vna_next < sizeof (*eaux)
11240 && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
11241 {
11242 warn (_("Invalid vna_next field of %lx\n"),
11243 aux.vna_next);
11244 j = ent.vn_cnt;
11245 break;
11246 }
11247 /* Check for overflow. */
11248 if (aux.vna_next > (size_t) (endbuf - vstart))
11249 break;
11250 isum += aux.vna_next;
11251 vstart += aux.vna_next;
11252 }
11253
11254 if (j < ent.vn_cnt)
11255 warn (_("Missing Version Needs auxillary information\n"));
11256
11257 if (ent.vn_next < sizeof (*entry)
11258 && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
11259 {
11260 warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
11261 cnt = section->sh_info;
11262 break;
11263 }
11264 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
11265 break;
11266 idx += ent.vn_next;
11267 }
11268
11269 if (cnt < section->sh_info)
11270 warn (_("Missing Version Needs information\n"));
11271
11272 free (eneed);
11273 }
11274 break;
11275
11276 case SHT_GNU_versym:
11277 {
11278 Elf_Internal_Shdr * link_section;
11279 size_t total;
11280 unsigned int cnt;
11281 unsigned char * edata;
11282 unsigned short * data;
11283 char * strtab;
11284 Elf_Internal_Sym * symbols;
11285 Elf_Internal_Shdr * string_sec;
11286 unsigned long num_syms;
11287 long off;
11288
11289 if (section->sh_link >= filedata->file_header.e_shnum)
11290 break;
11291
11292 link_section = filedata->section_headers + section->sh_link;
11293 total = section->sh_size / sizeof (Elf_External_Versym);
11294
11295 if (link_section->sh_link >= filedata->file_header.e_shnum)
11296 break;
11297
11298 found = TRUE;
11299
11300 symbols = GET_ELF_SYMBOLS (filedata, link_section, & num_syms);
11301 if (symbols == NULL)
11302 break;
11303
11304 string_sec = filedata->section_headers + link_section->sh_link;
11305
11306 strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
11307 string_sec->sh_size,
11308 _("version string table"));
11309 if (!strtab)
11310 {
11311 free (symbols);
11312 break;
11313 }
11314
11315 printf (ngettext ("\nVersion symbols section '%s' "
11316 "contains %lu entry:\n",
11317 "\nVersion symbols section '%s' "
11318 "contains %lu entries:\n",
11319 total),
11320 printable_section_name (filedata, section), (unsigned long) total);
11321
11322 printf (_(" Addr: 0x"));
11323 printf_vma (section->sh_addr);
11324 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11325 (unsigned long) section->sh_offset, section->sh_link,
11326 printable_section_name (filedata, link_section));
11327
11328 off = offset_from_vma (filedata,
11329 filedata->version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11330 total * sizeof (short));
11331 edata = (unsigned char *) get_data (NULL, filedata, off,
11332 sizeof (short), total,
11333 _("version symbol data"));
11334 if (!edata)
11335 {
11336 free (strtab);
11337 free (symbols);
11338 break;
11339 }
11340
11341 data = (short unsigned int *) cmalloc (total, sizeof (short));
11342
11343 for (cnt = total; cnt --;)
11344 data[cnt] = byte_get (edata + cnt * sizeof (short),
11345 sizeof (short));
11346
11347 free (edata);
11348
11349 for (cnt = 0; cnt < total; cnt += 4)
11350 {
11351 int j, nn;
11352 char *name;
11353 char *invalid = _("*invalid*");
11354
11355 printf (" %03x:", cnt);
11356
11357 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
11358 switch (data[cnt + j])
11359 {
11360 case 0:
11361 fputs (_(" 0 (*local*) "), stdout);
11362 break;
11363
11364 case 1:
11365 fputs (_(" 1 (*global*) "), stdout);
11366 break;
11367
11368 default:
11369 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
11370 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
11371
11372 /* If this index value is greater than the size of the symbols
11373 array, break to avoid an out-of-bounds read. */
11374 if ((unsigned long)(cnt + j) >= num_syms)
11375 {
11376 warn (_("invalid index into symbol array\n"));
11377 break;
11378 }
11379
11380 name = NULL;
11381 if (filedata->version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11382 {
11383 Elf_Internal_Verneed ivn;
11384 unsigned long offset;
11385
11386 offset = offset_from_vma
11387 (filedata,
11388 filedata->version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11389 sizeof (Elf_External_Verneed));
11390
11391 do
11392 {
11393 Elf_Internal_Vernaux ivna;
11394 Elf_External_Verneed evn;
11395 Elf_External_Vernaux evna;
11396 unsigned long a_off;
11397
11398 if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11399 _("version need")) == NULL)
11400 break;
11401
11402 ivn.vn_aux = BYTE_GET (evn.vn_aux);
11403 ivn.vn_next = BYTE_GET (evn.vn_next);
11404
11405 a_off = offset + ivn.vn_aux;
11406
11407 do
11408 {
11409 if (get_data (&evna, filedata, a_off, sizeof (evna),
11410 1, _("version need aux (2)")) == NULL)
11411 {
11412 ivna.vna_next = 0;
11413 ivna.vna_other = 0;
11414 }
11415 else
11416 {
11417 ivna.vna_next = BYTE_GET (evna.vna_next);
11418 ivna.vna_other = BYTE_GET (evna.vna_other);
11419 }
11420
11421 a_off += ivna.vna_next;
11422 }
11423 while (ivna.vna_other != data[cnt + j]
11424 && ivna.vna_next != 0);
11425
11426 if (ivna.vna_other == data[cnt + j])
11427 {
11428 ivna.vna_name = BYTE_GET (evna.vna_name);
11429
11430 if (ivna.vna_name >= string_sec->sh_size)
11431 name = invalid;
11432 else
11433 name = strtab + ivna.vna_name;
11434 break;
11435 }
11436
11437 offset += ivn.vn_next;
11438 }
11439 while (ivn.vn_next);
11440 }
11441
11442 if (data[cnt + j] != 0x8001
11443 && filedata->version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11444 {
11445 Elf_Internal_Verdef ivd;
11446 Elf_External_Verdef evd;
11447 unsigned long offset;
11448
11449 offset = offset_from_vma
11450 (filedata,
11451 filedata->version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11452 sizeof evd);
11453
11454 do
11455 {
11456 if (get_data (&evd, filedata, offset, sizeof (evd), 1,
11457 _("version def")) == NULL)
11458 {
11459 ivd.vd_next = 0;
11460 /* PR 17531: file: 046-1082287-0.004. */
11461 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
11462 break;
11463 }
11464 else
11465 {
11466 ivd.vd_next = BYTE_GET (evd.vd_next);
11467 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11468 }
11469
11470 offset += ivd.vd_next;
11471 }
11472 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
11473 && ivd.vd_next != 0);
11474
11475 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
11476 {
11477 Elf_External_Verdaux evda;
11478 Elf_Internal_Verdaux ivda;
11479
11480 ivd.vd_aux = BYTE_GET (evd.vd_aux);
11481
11482 if (get_data (&evda, filedata,
11483 offset - ivd.vd_next + ivd.vd_aux,
11484 sizeof (evda), 1,
11485 _("version def aux")) == NULL)
11486 break;
11487
11488 ivda.vda_name = BYTE_GET (evda.vda_name);
11489
11490 if (ivda.vda_name >= string_sec->sh_size)
11491 name = invalid;
11492 else if (name != NULL && name != invalid)
11493 name = _("*both*");
11494 else
11495 name = strtab + ivda.vda_name;
11496 }
11497 }
11498 if (name != NULL)
11499 nn += printf ("(%s%-*s",
11500 name,
11501 12 - (int) strlen (name),
11502 ")");
11503
11504 if (nn < 18)
11505 printf ("%*c", 18 - nn, ' ');
11506 }
11507
11508 putchar ('\n');
11509 }
11510
11511 free (data);
11512 free (strtab);
11513 free (symbols);
11514 }
11515 break;
11516
11517 default:
11518 break;
11519 }
11520 }
11521
11522 if (! found)
11523 printf (_("\nNo version information found in this file.\n"));
11524
11525 return TRUE;
11526}
11527
11528static const char *
11529get_symbol_binding (Filedata * filedata, unsigned int binding)
11530{
11531 static char buff[64];
11532
11533 switch (binding)
11534 {
11535 case STB_LOCAL: return "LOCAL";
11536 case STB_GLOBAL: return "GLOBAL";
11537 case STB_WEAK: return "WEAK";
11538 default:
11539 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
11540 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
11541 binding);
11542 else if (binding >= STB_LOOS && binding <= STB_HIOS)
11543 {
11544 if (binding == STB_GNU_UNIQUE
11545 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU)
11546 return "UNIQUE";
11547 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
11548 }
11549 else
11550 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
11551 return buff;
11552 }
11553}
11554
11555static const char *
11556get_symbol_type (Filedata * filedata, unsigned int type)
11557{
11558 static char buff[64];
11559
11560 switch (type)
11561 {
11562 case STT_NOTYPE: return "NOTYPE";
11563 case STT_OBJECT: return "OBJECT";
11564 case STT_FUNC: return "FUNC";
11565 case STT_SECTION: return "SECTION";
11566 case STT_FILE: return "FILE";
11567 case STT_COMMON: return "COMMON";
11568 case STT_TLS: return "TLS";
11569 case STT_RELC: return "RELC";
11570 case STT_SRELC: return "SRELC";
11571 default:
11572 if (type >= STT_LOPROC && type <= STT_HIPROC)
11573 {
11574 if (filedata->file_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
11575 return "THUMB_FUNC";
11576
11577 if (filedata->file_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
11578 return "REGISTER";
11579
11580 if (filedata->file_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
11581 return "PARISC_MILLI";
11582
11583 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
11584 }
11585 else if (type >= STT_LOOS && type <= STT_HIOS)
11586 {
11587 if (filedata->file_header.e_machine == EM_PARISC)
11588 {
11589 if (type == STT_HP_OPAQUE)
11590 return "HP_OPAQUE";
11591 if (type == STT_HP_STUB)
11592 return "HP_STUB";
11593 }
11594
11595 if (type == STT_GNU_IFUNC
11596 && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
11597 || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD))
11598 return "IFUNC";
11599
11600 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
11601 }
11602 else
11603 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
11604 return buff;
11605 }
11606}
11607
11608static const char *
11609get_symbol_visibility (unsigned int visibility)
11610{
11611 switch (visibility)
11612 {
11613 case STV_DEFAULT: return "DEFAULT";
11614 case STV_INTERNAL: return "INTERNAL";
11615 case STV_HIDDEN: return "HIDDEN";
11616 case STV_PROTECTED: return "PROTECTED";
11617 default:
11618 error (_("Unrecognized visibility value: %u\n"), visibility);
11619 return _("<unknown>");
11620 }
11621}
11622
11623static const char *
11624get_alpha_symbol_other (unsigned int other)
11625{
11626 switch (other)
11627 {
11628 case STO_ALPHA_NOPV: return "NOPV";
11629 case STO_ALPHA_STD_GPLOAD: return "STD GPLOAD";
11630 default:
11631 error (_("Unrecognized alpha specific other value: %u\n"), other);
11632 return _("<unknown>");
11633 }
11634}
11635
11636static const char *
11637get_solaris_symbol_visibility (unsigned int visibility)
11638{
11639 switch (visibility)
11640 {
11641 case 4: return "EXPORTED";
11642 case 5: return "SINGLETON";
11643 case 6: return "ELIMINATE";
11644 default: return get_symbol_visibility (visibility);
11645 }
11646}
11647
11648static const char *
11649get_aarch64_symbol_other (unsigned int other)
11650{
11651 static char buf[32];
11652
11653 if (other & STO_AARCH64_VARIANT_PCS)
11654 {
11655 other &= ~STO_AARCH64_VARIANT_PCS;
11656 if (other == 0)
11657 return "VARIANT_PCS";
11658 snprintf (buf, sizeof buf, "VARIANT_PCS | %x", other);
11659 return buf;
11660 }
11661 return NULL;
11662}
11663
11664static const char *
11665get_mips_symbol_other (unsigned int other)
11666{
11667 switch (other)
11668 {
11669 case STO_OPTIONAL: return "OPTIONAL";
11670 case STO_MIPS_PLT: return "MIPS PLT";
11671 case STO_MIPS_PIC: return "MIPS PIC";
11672 case STO_MICROMIPS: return "MICROMIPS";
11673 case STO_MICROMIPS | STO_MIPS_PIC: return "MICROMIPS, MIPS PIC";
11674 case STO_MIPS16: return "MIPS16";
11675 default: return NULL;
11676 }
11677}
11678
11679static const char *
11680get_ia64_symbol_other (Filedata * filedata, unsigned int other)
11681{
11682 if (is_ia64_vms (filedata))
11683 {
11684 static char res[32];
11685
11686 res[0] = 0;
11687
11688 /* Function types is for images and .STB files only. */
11689 switch (filedata->file_header.e_type)
11690 {
11691 case ET_DYN:
11692 case ET_EXEC:
11693 switch (VMS_ST_FUNC_TYPE (other))
11694 {
11695 case VMS_SFT_CODE_ADDR:
11696 strcat (res, " CA");
11697 break;
11698 case VMS_SFT_SYMV_IDX:
11699 strcat (res, " VEC");
11700 break;
11701 case VMS_SFT_FD:
11702 strcat (res, " FD");
11703 break;
11704 case VMS_SFT_RESERVE:
11705 strcat (res, " RSV");
11706 break;
11707 default:
11708 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11709 VMS_ST_FUNC_TYPE (other));
11710 strcat (res, " <unknown>");
11711 break;
11712 }
11713 break;
11714 default:
11715 break;
11716 }
11717 switch (VMS_ST_LINKAGE (other))
11718 {
11719 case VMS_STL_IGNORE:
11720 strcat (res, " IGN");
11721 break;
11722 case VMS_STL_RESERVE:
11723 strcat (res, " RSV");
11724 break;
11725 case VMS_STL_STD:
11726 strcat (res, " STD");
11727 break;
11728 case VMS_STL_LNK:
11729 strcat (res, " LNK");
11730 break;
11731 default:
11732 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11733 VMS_ST_LINKAGE (other));
11734 strcat (res, " <unknown>");
11735 break;
11736 }
11737
11738 if (res[0] != 0)
11739 return res + 1;
11740 else
11741 return res;
11742 }
11743 return NULL;
11744}
11745
11746static const char *
11747get_ppc64_symbol_other (unsigned int other)
11748{
11749 if ((other & ~STO_PPC64_LOCAL_MASK) != 0)
11750 return NULL;
11751
11752 other >>= STO_PPC64_LOCAL_BIT;
11753 if (other <= 6)
11754 {
11755 static char buf[64];
11756 if (other >= 2)
11757 other = ppc64_decode_local_entry (other);
11758 snprintf (buf, sizeof buf, _("<localentry>: %d"), other);
11759 return buf;
11760 }
11761 return NULL;
11762}
11763
11764static const char *
11765get_symbol_other (Filedata * filedata, unsigned int other)
11766{
11767 const char * result = NULL;
11768 static char buff [64];
11769
11770 if (other == 0)
11771 return "";
11772
11773 switch (filedata->file_header.e_machine)
11774 {
11775 case EM_ALPHA:
11776 result = get_alpha_symbol_other (other);
11777 break;
11778 case EM_AARCH64:
11779 result = get_aarch64_symbol_other (other);
11780 break;
11781 case EM_MIPS:
11782 result = get_mips_symbol_other (other);
11783 break;
11784 case EM_IA_64:
11785 result = get_ia64_symbol_other (filedata, other);
11786 break;
11787 case EM_PPC64:
11788 result = get_ppc64_symbol_other (other);
11789 break;
11790 default:
11791 result = NULL;
11792 break;
11793 }
11794
11795 if (result)
11796 return result;
11797
11798 snprintf (buff, sizeof buff, _("<other>: %x"), other);
11799 return buff;
11800}
11801
11802static const char *
11803get_symbol_index_type (Filedata * filedata, unsigned int type)
11804{
11805 static char buff[32];
11806
11807 switch (type)
11808 {
11809 case SHN_UNDEF: return "UND";
11810 case SHN_ABS: return "ABS";
11811 case SHN_COMMON: return "COM";
11812 default:
11813 if (type == SHN_IA_64_ANSI_COMMON
11814 && filedata->file_header.e_machine == EM_IA_64
11815 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
11816 return "ANSI_COM";
11817 else if ((filedata->file_header.e_machine == EM_X86_64
11818 || filedata->file_header.e_machine == EM_L1OM
11819 || filedata->file_header.e_machine == EM_K1OM)
11820 && type == SHN_X86_64_LCOMMON)
11821 return "LARGE_COM";
11822 else if ((type == SHN_MIPS_SCOMMON
11823 && filedata->file_header.e_machine == EM_MIPS)
11824 || (type == SHN_TIC6X_SCOMMON
11825 && filedata->file_header.e_machine == EM_TI_C6000))
11826 return "SCOM";
11827 else if (type == SHN_MIPS_SUNDEFINED
11828 && filedata->file_header.e_machine == EM_MIPS)
11829 return "SUND";
11830 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
11831 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
11832 else if (type >= SHN_LOOS && type <= SHN_HIOS)
11833 sprintf (buff, "OS [0x%04x]", type & 0xffff);
11834 else if (type >= SHN_LORESERVE)
11835 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
11836 else if (filedata->file_header.e_shnum != 0
11837 && type >= filedata->file_header.e_shnum)
11838 sprintf (buff, _("bad section index[%3d]"), type);
11839 else
11840 sprintf (buff, "%3d", type);
11841 break;
11842 }
11843
11844 return buff;
11845}
11846
11847static const char *
11848get_symbol_version_string (Filedata * filedata,
11849 bfd_boolean is_dynsym,
11850 const char * strtab,
11851 unsigned long int strtab_size,
11852 unsigned int si,
11853 Elf_Internal_Sym * psym,
11854 enum versioned_symbol_info * sym_info,
11855 unsigned short * vna_other)
11856{
11857 unsigned char data[2];
11858 unsigned short vers_data;
11859 unsigned long offset;
11860 unsigned short max_vd_ndx;
11861
11862 if (!is_dynsym
11863 || filedata->version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11864 return NULL;
11865
11866 offset = offset_from_vma (filedata,
11867 filedata->version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11868 sizeof data + si * sizeof (vers_data));
11869
11870 if (get_data (&data, filedata, offset + si * sizeof (vers_data),
11871 sizeof (data), 1, _("version data")) == NULL)
11872 return NULL;
11873
11874 vers_data = byte_get (data, 2);
11875
11876 if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data == 0)
11877 return NULL;
11878
11879 *sym_info = (vers_data & VERSYM_HIDDEN) != 0 ? symbol_hidden : symbol_public;
11880 max_vd_ndx = 0;
11881
11882 /* Usually we'd only see verdef for defined symbols, and verneed for
11883 undefined symbols. However, symbols defined by the linker in
11884 .dynbss for variables copied from a shared library in order to
11885 avoid text relocations are defined yet have verneed. We could
11886 use a heuristic to detect the special case, for example, check
11887 for verneed first on symbols defined in SHT_NOBITS sections, but
11888 it is simpler and more reliable to just look for both verdef and
11889 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11890
11891 if (psym->st_shndx != SHN_UNDEF
11892 && vers_data != 0x8001
11893 && filedata->version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11894 {
11895 Elf_Internal_Verdef ivd;
11896 Elf_Internal_Verdaux ivda;
11897 Elf_External_Verdaux evda;
11898 unsigned long off;
11899
11900 off = offset_from_vma (filedata,
11901 filedata->version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11902 sizeof (Elf_External_Verdef));
11903
11904 do
11905 {
11906 Elf_External_Verdef evd;
11907
11908 if (get_data (&evd, filedata, off, sizeof (evd), 1,
11909 _("version def")) == NULL)
11910 {
11911 ivd.vd_ndx = 0;
11912 ivd.vd_aux = 0;
11913 ivd.vd_next = 0;
11914 ivd.vd_flags = 0;
11915 }
11916 else
11917 {
11918 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11919 ivd.vd_aux = BYTE_GET (evd.vd_aux);
11920 ivd.vd_next = BYTE_GET (evd.vd_next);
11921 ivd.vd_flags = BYTE_GET (evd.vd_flags);
11922 }
11923
11924 if ((ivd.vd_ndx & VERSYM_VERSION) > max_vd_ndx)
11925 max_vd_ndx = ivd.vd_ndx & VERSYM_VERSION;
11926
11927 off += ivd.vd_next;
11928 }
11929 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11930
11931 if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11932 {
11933 if (ivd.vd_ndx == 1 && ivd.vd_flags == VER_FLG_BASE)
11934 return NULL;
11935
11936 off -= ivd.vd_next;
11937 off += ivd.vd_aux;
11938
11939 if (get_data (&evda, filedata, off, sizeof (evda), 1,
11940 _("version def aux")) != NULL)
11941 {
11942 ivda.vda_name = BYTE_GET (evda.vda_name);
11943
11944 if (psym->st_name != ivda.vda_name)
11945 return (ivda.vda_name < strtab_size
11946 ? strtab + ivda.vda_name : _("<corrupt>"));
11947 }
11948 }
11949 }
11950
11951 if (filedata->version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11952 {
11953 Elf_External_Verneed evn;
11954 Elf_Internal_Verneed ivn;
11955 Elf_Internal_Vernaux ivna;
11956
11957 offset = offset_from_vma (filedata,
11958 filedata->version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11959 sizeof evn);
11960 do
11961 {
11962 unsigned long vna_off;
11963
11964 if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11965 _("version need")) == NULL)
11966 {
11967 ivna.vna_next = 0;
11968 ivna.vna_other = 0;
11969 ivna.vna_name = 0;
11970 break;
11971 }
11972
11973 ivn.vn_aux = BYTE_GET (evn.vn_aux);
11974 ivn.vn_next = BYTE_GET (evn.vn_next);
11975
11976 vna_off = offset + ivn.vn_aux;
11977
11978 do
11979 {
11980 Elf_External_Vernaux evna;
11981
11982 if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
11983 _("version need aux (3)")) == NULL)
11984 {
11985 ivna.vna_next = 0;
11986 ivna.vna_other = 0;
11987 ivna.vna_name = 0;
11988 }
11989 else
11990 {
11991 ivna.vna_other = BYTE_GET (evna.vna_other);
11992 ivna.vna_next = BYTE_GET (evna.vna_next);
11993 ivna.vna_name = BYTE_GET (evna.vna_name);
11994 }
11995
11996 vna_off += ivna.vna_next;
11997 }
11998 while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11999
12000 if (ivna.vna_other == vers_data)
12001 break;
12002
12003 offset += ivn.vn_next;
12004 }
12005 while (ivn.vn_next != 0);
12006
12007 if (ivna.vna_other == vers_data)
12008 {
12009 *sym_info = symbol_undefined;
12010 *vna_other = ivna.vna_other;
12011 return (ivna.vna_name < strtab_size
12012 ? strtab + ivna.vna_name : _("<corrupt>"));
12013 }
12014 else if ((max_vd_ndx || (vers_data & VERSYM_VERSION) != 1)
12015 && (vers_data & VERSYM_VERSION) > max_vd_ndx)
12016 return _("<corrupt>");
12017 }
12018 return NULL;
12019}
12020
12021static void
12022print_dynamic_symbol (Filedata *filedata, unsigned long si,
12023 Elf_Internal_Sym *symtab,
12024 Elf_Internal_Shdr *section,
12025 char *strtab, size_t strtab_size)
12026{
12027 const char *version_string;
12028 enum versioned_symbol_info sym_info;
12029 unsigned short vna_other;
12030 Elf_Internal_Sym *psym = symtab + si;
12031
12032 printf ("%6ld: ", si);
12033 print_vma (psym->st_value, LONG_HEX);
12034 putchar (' ');
12035 print_vma (psym->st_size, DEC_5);
12036 printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
12037 printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
12038 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
12039 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
12040 else
12041 {
12042 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
12043
12044 printf (" %-7s", get_symbol_visibility (vis));
12045 /* Check to see if any other bits in the st_other field are set.
12046 Note - displaying this information disrupts the layout of the
12047 table being generated, but for the moment this case is very rare. */
12048 if (psym->st_other ^ vis)
12049 printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
12050 }
12051 printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
12052 print_symbol (25, VALID_SYMBOL_NAME (strtab, strtab_size,
12053 psym->st_name)
12054 ? strtab + psym->st_name : _("<corrupt>"));
12055
12056 version_string
12057 = get_symbol_version_string (filedata,
12058 (section == NULL
12059 || section->sh_type == SHT_DYNSYM),
12060 strtab, strtab_size, si,
12061 psym, &sym_info, &vna_other);
12062 if (version_string)
12063 {
12064 if (sym_info == symbol_undefined)
12065 printf ("@%s (%d)", version_string, vna_other);
12066 else
12067 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
12068 version_string);
12069 }
12070
12071 putchar ('\n');
12072
12073 if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
12074 && section != NULL
12075 && si >= section->sh_info
12076 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12077 && filedata->file_header.e_machine != EM_MIPS
12078 /* Solaris binaries have been found to violate this requirement as
12079 well. Not sure if this is a bug or an ABI requirement. */
12080 && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
12081 warn (_("local symbol %lu found at index >= %s's sh_info value of %u\n"),
12082 si, printable_section_name (filedata, section), section->sh_info);
12083}
12084
12085/* Dump the symbol table. */
12086static bfd_boolean
12087process_symbol_table (Filedata * filedata)
12088{
12089 Elf_Internal_Shdr * section;
12090
12091 if (!do_syms && !do_dyn_syms && !do_histogram)
12092 return TRUE;
12093
12094 if ((filedata->dynamic_info[DT_HASH] || filedata->dynamic_info_DT_GNU_HASH)
12095 && do_syms
12096 && do_using_dynamic
12097 && filedata->dynamic_strings != NULL
12098 && filedata->dynamic_symbols != NULL)
12099 {
12100 unsigned long si;
12101
12102 printf (ngettext ("\nSymbol table for image contains %lu entry:\n",
12103 "\nSymbol table for image contains %lu entries:\n",
12104 filedata->num_dynamic_syms),
12105 filedata->num_dynamic_syms);
12106 if (is_32bit_elf)
12107 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12108 else
12109 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12110
12111 for (si = 0; si < filedata->num_dynamic_syms; si++)
12112 print_dynamic_symbol (filedata, si, filedata->dynamic_symbols, NULL,
12113 filedata->dynamic_strings,
12114 filedata->dynamic_strings_length);
12115 }
12116 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
12117 && filedata->section_headers != NULL)
12118 {
12119 unsigned int i;
12120
12121 for (i = 0, section = filedata->section_headers;
12122 i < filedata->file_header.e_shnum;
12123 i++, section++)
12124 {
12125 char * strtab = NULL;
12126 unsigned long int strtab_size = 0;
12127 Elf_Internal_Sym * symtab;
12128 unsigned long si, num_syms;
12129
12130 if ((section->sh_type != SHT_SYMTAB
12131 && section->sh_type != SHT_DYNSYM)
12132 || (!do_syms
12133 && section->sh_type == SHT_SYMTAB))
12134 continue;
12135
12136 if (section->sh_entsize == 0)
12137 {
12138 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
12139 printable_section_name (filedata, section));
12140 continue;
12141 }
12142
12143 num_syms = section->sh_size / section->sh_entsize;
12144 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
12145 "\nSymbol table '%s' contains %lu entries:\n",
12146 num_syms),
12147 printable_section_name (filedata, section),
12148 num_syms);
12149
12150 if (is_32bit_elf)
12151 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12152 else
12153 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12154
12155 symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
12156 if (symtab == NULL)
12157 continue;
12158
12159 if (section->sh_link == filedata->file_header.e_shstrndx)
12160 {
12161 strtab = filedata->string_table;
12162 strtab_size = filedata->string_table_length;
12163 }
12164 else if (section->sh_link < filedata->file_header.e_shnum)
12165 {
12166 Elf_Internal_Shdr * string_sec;
12167
12168 string_sec = filedata->section_headers + section->sh_link;
12169
12170 strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
12171 1, string_sec->sh_size,
12172 _("string table"));
12173 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
12174 }
12175
12176 for (si = 0; si < num_syms; si++)
12177 print_dynamic_symbol (filedata, si, symtab, section,
12178 strtab, strtab_size);
12179
12180 free (symtab);
12181 if (strtab != filedata->string_table)
12182 free (strtab);
12183 }
12184 }
12185 else if (do_syms)
12186 printf
12187 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12188
12189 if (do_histogram && filedata->buckets != NULL)
12190 {
12191 unsigned long * lengths;
12192 unsigned long * counts;
12193 unsigned long hn;
12194 bfd_vma si;
12195 unsigned long maxlength = 0;
12196 unsigned long nzero_counts = 0;
12197 unsigned long nsyms = 0;
12198 char *visited;
12199
12200 printf (ngettext ("\nHistogram for bucket list length "
12201 "(total of %lu bucket):\n",
12202 "\nHistogram for bucket list length "
12203 "(total of %lu buckets):\n",
12204 (unsigned long) filedata->nbuckets),
12205 (unsigned long) filedata->nbuckets);
12206
12207 lengths = (unsigned long *) calloc (filedata->nbuckets,
12208 sizeof (*lengths));
12209 if (lengths == NULL)
12210 {
12211 error (_("Out of memory allocating space for histogram buckets\n"));
12212 goto err_out;
12213 }
12214 visited = xcmalloc (filedata->nchains, 1);
12215 memset (visited, 0, filedata->nchains);
12216
12217 printf (_(" Length Number %% of total Coverage\n"));
12218 for (hn = 0; hn < filedata->nbuckets; ++hn)
12219 {
12220 for (si = filedata->buckets[hn]; si > 0; si = filedata->chains[si])
12221 {
12222 ++nsyms;
12223 if (maxlength < ++lengths[hn])
12224 ++maxlength;
12225 if (si >= filedata->nchains || visited[si])
12226 {
12227 error (_("histogram chain is corrupt\n"));
12228 break;
12229 }
12230 visited[si] = 1;
12231 }
12232 }
12233 free (visited);
12234
12235 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
12236 if (counts == NULL)
12237 {
12238 free (lengths);
12239 error (_("Out of memory allocating space for histogram counts\n"));
12240 goto err_out;
12241 }
12242
12243 for (hn = 0; hn < filedata->nbuckets; ++hn)
12244 ++counts[lengths[hn]];
12245
12246 if (filedata->nbuckets > 0)
12247 {
12248 unsigned long i;
12249 printf (" 0 %-10lu (%5.1f%%)\n",
12250 counts[0], (counts[0] * 100.0) / filedata->nbuckets);
12251 for (i = 1; i <= maxlength; ++i)
12252 {
12253 nzero_counts += counts[i] * i;
12254 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12255 i, counts[i], (counts[i] * 100.0) / filedata->nbuckets,
12256 (nzero_counts * 100.0) / nsyms);
12257 }
12258 }
12259
12260 free (counts);
12261 free (lengths);
12262 }
12263
12264 free (filedata->buckets);
12265 filedata->buckets = NULL;
12266 filedata->nbuckets = 0;
12267 free (filedata->chains);
12268 filedata->chains = NULL;
12269
12270 if (do_histogram && filedata->gnubuckets != NULL)
12271 {
12272 unsigned long * lengths;
12273 unsigned long * counts;
12274 unsigned long hn;
12275 unsigned long maxlength = 0;
12276 unsigned long nzero_counts = 0;
12277 unsigned long nsyms = 0;
12278
12279 printf (ngettext ("\nHistogram for `%s' bucket list length "
12280 "(total of %lu bucket):\n",
12281 "\nHistogram for `%s' bucket list length "
12282 "(total of %lu buckets):\n",
12283 (unsigned long) filedata->ngnubuckets),
12284 GNU_HASH_SECTION_NAME (filedata),
12285 (unsigned long) filedata->ngnubuckets);
12286
12287 lengths = (unsigned long *) calloc (filedata->ngnubuckets,
12288 sizeof (*lengths));
12289 if (lengths == NULL)
12290 {
12291 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12292 goto err_out;
12293 }
12294
12295 printf (_(" Length Number %% of total Coverage\n"));
12296
12297 for (hn = 0; hn < filedata->ngnubuckets; ++hn)
12298 if (filedata->gnubuckets[hn] != 0)
12299 {
12300 bfd_vma off, length = 1;
12301
12302 for (off = filedata->gnubuckets[hn] - filedata->gnusymidx;
12303 /* PR 17531 file: 010-77222-0.004. */
12304 off < filedata->ngnuchains
12305 && (filedata->gnuchains[off] & 1) == 0;
12306 ++off)
12307 ++length;
12308 lengths[hn] = length;
12309 if (length > maxlength)
12310 maxlength = length;
12311 nsyms += length;
12312 }
12313
12314 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
12315 if (counts == NULL)
12316 {
12317 free (lengths);
12318 error (_("Out of memory allocating space for gnu histogram counts\n"));
12319 goto err_out;
12320 }
12321
12322 for (hn = 0; hn < filedata->ngnubuckets; ++hn)
12323 ++counts[lengths[hn]];
12324
12325 if (filedata->ngnubuckets > 0)
12326 {
12327 unsigned long j;
12328 printf (" 0 %-10lu (%5.1f%%)\n",
12329 counts[0], (counts[0] * 100.0) / filedata->ngnubuckets);
12330 for (j = 1; j <= maxlength; ++j)
12331 {
12332 nzero_counts += counts[j] * j;
12333 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12334 j, counts[j], (counts[j] * 100.0) / filedata->ngnubuckets,
12335 (nzero_counts * 100.0) / nsyms);
12336 }
12337 }
12338
12339 free (counts);
12340 free (lengths);
12341 }
12342 free (filedata->gnubuckets);
12343 filedata->gnubuckets = NULL;
12344 filedata->ngnubuckets = 0;
12345 free (filedata->gnuchains);
12346 filedata->gnuchains = NULL;
12347 filedata->ngnuchains = 0;
12348 free (filedata->mipsxlat);
12349 filedata->mipsxlat = NULL;
12350 return TRUE;
12351
12352 err_out:
12353 free (filedata->gnubuckets);
12354 filedata->gnubuckets = NULL;
12355 filedata->ngnubuckets = 0;
12356 free (filedata->gnuchains);
12357 filedata->gnuchains = NULL;
12358 filedata->ngnuchains = 0;
12359 free (filedata->mipsxlat);
12360 filedata->mipsxlat = NULL;
12361 free (filedata->buckets);
12362 filedata->buckets = NULL;
12363 filedata->nbuckets = 0;
12364 free (filedata->chains);
12365 filedata->chains = NULL;
12366 return FALSE;
12367}
12368
12369static bfd_boolean
12370process_syminfo (Filedata * filedata ATTRIBUTE_UNUSED)
12371{
12372 unsigned int i;
12373
12374 if (filedata->dynamic_syminfo == NULL
12375 || !do_dynamic)
12376 /* No syminfo, this is ok. */
12377 return TRUE;
12378
12379 /* There better should be a dynamic symbol section. */
12380 if (filedata->dynamic_symbols == NULL || filedata->dynamic_strings == NULL)
12381 return FALSE;
12382
12383 if (filedata->dynamic_addr)
12384 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12385 "contains %d entry:\n",
12386 "\nDynamic info segment at offset 0x%lx "
12387 "contains %d entries:\n",
12388 filedata->dynamic_syminfo_nent),
12389 filedata->dynamic_syminfo_offset, filedata->dynamic_syminfo_nent);
12390
12391 printf (_(" Num: Name BoundTo Flags\n"));
12392 for (i = 0; i < filedata->dynamic_syminfo_nent; ++i)
12393 {
12394 unsigned short int flags = filedata->dynamic_syminfo[i].si_flags;
12395
12396 printf ("%4d: ", i);
12397 if (i >= filedata->num_dynamic_syms)
12398 printf (_("<corrupt index>"));
12399 else if (VALID_DYNAMIC_NAME (filedata, filedata->dynamic_symbols[i].st_name))
12400 print_symbol (30, GET_DYNAMIC_NAME (filedata,
12401 filedata->dynamic_symbols[i].st_name));
12402 else
12403 printf (_("<corrupt: %19ld>"), filedata->dynamic_symbols[i].st_name);
12404 putchar (' ');
12405
12406 switch (filedata->dynamic_syminfo[i].si_boundto)
12407 {
12408 case SYMINFO_BT_SELF:
12409 fputs ("SELF ", stdout);
12410 break;
12411 case SYMINFO_BT_PARENT:
12412 fputs ("PARENT ", stdout);
12413 break;
12414 default:
12415 if (filedata->dynamic_syminfo[i].si_boundto > 0
12416 && filedata->dynamic_syminfo[i].si_boundto < filedata->dynamic_nent
12417 && VALID_DYNAMIC_NAME (filedata,
12418 filedata->dynamic_section[filedata->dynamic_syminfo[i].si_boundto].d_un.d_val))
12419 {
12420 print_symbol (10, GET_DYNAMIC_NAME (filedata,
12421 filedata->dynamic_section[filedata->dynamic_syminfo[i].si_boundto].d_un.d_val));
12422 putchar (' ' );
12423 }
12424 else
12425 printf ("%-10d ", filedata->dynamic_syminfo[i].si_boundto);
12426 break;
12427 }
12428
12429 if (flags & SYMINFO_FLG_DIRECT)
12430 printf (" DIRECT");
12431 if (flags & SYMINFO_FLG_PASSTHRU)
12432 printf (" PASSTHRU");
12433 if (flags & SYMINFO_FLG_COPY)
12434 printf (" COPY");
12435 if (flags & SYMINFO_FLG_LAZYLOAD)
12436 printf (" LAZYLOAD");
12437
12438 puts ("");
12439 }
12440
12441 return TRUE;
12442}
12443
12444/* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
12445 is contained by the region START .. END. The types of ADDR, START
12446 and END should all be the same. Note both ADDR + NELEM and END
12447 point to just beyond the end of the regions that are being tested. */
12448#define IN_RANGE(START,END,ADDR,NELEM) \
12449 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
12450
12451/* Check to see if the given reloc needs to be handled in a target specific
12452 manner. If so then process the reloc and return TRUE otherwise return
12453 FALSE.
12454
12455 If called with reloc == NULL, then this is a signal that reloc processing
12456 for the current section has finished, and any saved state should be
12457 discarded. */
12458
12459static bfd_boolean
12460target_specific_reloc_handling (Filedata * filedata,
12461 Elf_Internal_Rela * reloc,
12462 unsigned char * start,
12463 unsigned char * end,
12464 Elf_Internal_Sym * symtab,
12465 unsigned long num_syms)
12466{
12467 unsigned int reloc_type = 0;
12468 unsigned long sym_index = 0;
12469
12470 if (reloc)
12471 {
12472 reloc_type = get_reloc_type (filedata, reloc->r_info);
12473 sym_index = get_reloc_symindex (reloc->r_info);
12474 }
12475
12476 switch (filedata->file_header.e_machine)
12477 {
12478 case EM_MSP430:
12479 case EM_MSP430_OLD:
12480 {
12481 static Elf_Internal_Sym * saved_sym = NULL;
12482
12483 if (reloc == NULL)
12484 {
12485 saved_sym = NULL;
12486 return TRUE;
12487 }
12488
12489 switch (reloc_type)
12490 {
12491 case 10: /* R_MSP430_SYM_DIFF */
12492 if (uses_msp430x_relocs (filedata))
12493 break;
12494 /* Fall through. */
12495 case 21: /* R_MSP430X_SYM_DIFF */
12496 /* PR 21139. */
12497 if (sym_index >= num_syms)
12498 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12499 sym_index);
12500 else
12501 saved_sym = symtab + sym_index;
12502 return TRUE;
12503
12504 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12505 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12506 goto handle_sym_diff;
12507
12508 case 5: /* R_MSP430_16_BYTE */
12509 case 9: /* R_MSP430_8 */
12510 if (uses_msp430x_relocs (filedata))
12511 break;
12512 goto handle_sym_diff;
12513
12514 case 2: /* R_MSP430_ABS16 */
12515 case 15: /* R_MSP430X_ABS16 */
12516 if (! uses_msp430x_relocs (filedata))
12517 break;
12518 goto handle_sym_diff;
12519
12520 handle_sym_diff:
12521 if (saved_sym != NULL)
12522 {
12523 int reloc_size = reloc_type == 1 ? 4 : 2;
12524 bfd_vma value;
12525
12526 if (sym_index >= num_syms)
12527 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12528 sym_index);
12529 else
12530 {
12531 value = reloc->r_addend + (symtab[sym_index].st_value
12532 - saved_sym->st_value);
12533
12534 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12535 byte_put (start + reloc->r_offset, value, reloc_size);
12536 else
12537 /* PR 21137 */
12538 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12539 (long) reloc->r_offset);
12540 }
12541
12542 saved_sym = NULL;
12543 return TRUE;
12544 }
12545 break;
12546
12547 default:
12548 if (saved_sym != NULL)
12549 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12550 break;
12551 }
12552 break;
12553 }
12554
12555 case EM_MN10300:
12556 case EM_CYGNUS_MN10300:
12557 {
12558 static Elf_Internal_Sym * saved_sym = NULL;
12559
12560 if (reloc == NULL)
12561 {
12562 saved_sym = NULL;
12563 return TRUE;
12564 }
12565
12566 switch (reloc_type)
12567 {
12568 case 34: /* R_MN10300_ALIGN */
12569 return TRUE;
12570 case 33: /* R_MN10300_SYM_DIFF */
12571 if (sym_index >= num_syms)
12572 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12573 sym_index);
12574 else
12575 saved_sym = symtab + sym_index;
12576 return TRUE;
12577
12578 case 1: /* R_MN10300_32 */
12579 case 2: /* R_MN10300_16 */
12580 if (saved_sym != NULL)
12581 {
12582 int reloc_size = reloc_type == 1 ? 4 : 2;
12583 bfd_vma value;
12584
12585 if (sym_index >= num_syms)
12586 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12587 sym_index);
12588 else
12589 {
12590 value = reloc->r_addend + (symtab[sym_index].st_value
12591 - saved_sym->st_value);
12592
12593 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12594 byte_put (start + reloc->r_offset, value, reloc_size);
12595 else
12596 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12597 (long) reloc->r_offset);
12598 }
12599
12600 saved_sym = NULL;
12601 return TRUE;
12602 }
12603 break;
12604 default:
12605 if (saved_sym != NULL)
12606 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12607 break;
12608 }
12609 break;
12610 }
12611
12612 case EM_RL78:
12613 {
12614 static bfd_vma saved_sym1 = 0;
12615 static bfd_vma saved_sym2 = 0;
12616 static bfd_vma value;
12617
12618 if (reloc == NULL)
12619 {
12620 saved_sym1 = saved_sym2 = 0;
12621 return TRUE;
12622 }
12623
12624 switch (reloc_type)
12625 {
12626 case 0x80: /* R_RL78_SYM. */
12627 saved_sym1 = saved_sym2;
12628 if (sym_index >= num_syms)
12629 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12630 sym_index);
12631 else
12632 {
12633 saved_sym2 = symtab[sym_index].st_value;
12634 saved_sym2 += reloc->r_addend;
12635 }
12636 return TRUE;
12637
12638 case 0x83: /* R_RL78_OPsub. */
12639 value = saved_sym1 - saved_sym2;
12640 saved_sym2 = saved_sym1 = 0;
12641 return TRUE;
12642 break;
12643
12644 case 0x41: /* R_RL78_ABS32. */
12645 if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12646 byte_put (start + reloc->r_offset, value, 4);
12647 else
12648 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12649 (long) reloc->r_offset);
12650 value = 0;
12651 return TRUE;
12652
12653 case 0x43: /* R_RL78_ABS16. */
12654 if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12655 byte_put (start + reloc->r_offset, value, 2);
12656 else
12657 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12658 (long) reloc->r_offset);
12659 value = 0;
12660 return TRUE;
12661
12662 default:
12663 break;
12664 }
12665 break;
12666 }
12667 }
12668
12669 return FALSE;
12670}
12671
12672/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12673 DWARF debug sections. This is a target specific test. Note - we do not
12674 go through the whole including-target-headers-multiple-times route, (as
12675 we have already done with <elf/h8.h>) because this would become very
12676 messy and even then this function would have to contain target specific
12677 information (the names of the relocs instead of their numeric values).
12678 FIXME: This is not the correct way to solve this problem. The proper way
12679 is to have target specific reloc sizing and typing functions created by
12680 the reloc-macros.h header, in the same way that it already creates the
12681 reloc naming functions. */
12682
12683static bfd_boolean
12684is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12685{
12686 /* Please keep this table alpha-sorted for ease of visual lookup. */
12687 switch (filedata->file_header.e_machine)
12688 {
12689 case EM_386:
12690 case EM_IAMCU:
12691 return reloc_type == 1; /* R_386_32. */
12692 case EM_68K:
12693 return reloc_type == 1; /* R_68K_32. */
12694 case EM_860:
12695 return reloc_type == 1; /* R_860_32. */
12696 case EM_960:
12697 return reloc_type == 2; /* R_960_32. */
12698 case EM_AARCH64:
12699 return (reloc_type == 258
12700 || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12701 case EM_BPF:
12702 return reloc_type == 11; /* R_BPF_DATA_32 */
12703 case EM_ADAPTEVA_EPIPHANY:
12704 return reloc_type == 3;
12705 case EM_ALPHA:
12706 return reloc_type == 1; /* R_ALPHA_REFLONG. */
12707 case EM_ARC:
12708 return reloc_type == 1; /* R_ARC_32. */
12709 case EM_ARC_COMPACT:
12710 case EM_ARC_COMPACT2:
12711 return reloc_type == 4; /* R_ARC_32. */
12712 case EM_ARM:
12713 return reloc_type == 2; /* R_ARM_ABS32 */
12714 case EM_AVR_OLD:
12715 case EM_AVR:
12716 return reloc_type == 1;
12717 case EM_BLACKFIN:
12718 return reloc_type == 0x12; /* R_byte4_data. */
12719 case EM_CRIS:
12720 return reloc_type == 3; /* R_CRIS_32. */
12721 case EM_CR16:
12722 return reloc_type == 3; /* R_CR16_NUM32. */
12723 case EM_CRX:
12724 return reloc_type == 15; /* R_CRX_NUM32. */
12725 case EM_CSKY:
12726 return reloc_type == 1; /* R_CKCORE_ADDR32. */
12727 case EM_CYGNUS_FRV:
12728 return reloc_type == 1;
12729 case EM_CYGNUS_D10V:
12730 case EM_D10V:
12731 return reloc_type == 6; /* R_D10V_32. */
12732 case EM_CYGNUS_D30V:
12733 case EM_D30V:
12734 return reloc_type == 12; /* R_D30V_32_NORMAL. */
12735 case EM_DLX:
12736 return reloc_type == 3; /* R_DLX_RELOC_32. */
12737 case EM_CYGNUS_FR30:
12738 case EM_FR30:
12739 return reloc_type == 3; /* R_FR30_32. */
12740 case EM_FT32:
12741 return reloc_type == 1; /* R_FT32_32. */
12742 case EM_H8S:
12743 case EM_H8_300:
12744 case EM_H8_300H:
12745 return reloc_type == 1; /* R_H8_DIR32. */
12746 case EM_IA_64:
12747 return (reloc_type == 0x64 /* R_IA64_SECREL32MSB. */
12748 || reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
12749 || reloc_type == 0x24 /* R_IA64_DIR32MSB. */
12750 || reloc_type == 0x25 /* R_IA64_DIR32LSB. */);
12751 case EM_IP2K_OLD:
12752 case EM_IP2K:
12753 return reloc_type == 2; /* R_IP2K_32. */
12754 case EM_IQ2000:
12755 return reloc_type == 2; /* R_IQ2000_32. */
12756 case EM_LATTICEMICO32:
12757 return reloc_type == 3; /* R_LM32_32. */
12758 case EM_M32C_OLD:
12759 case EM_M32C:
12760 return reloc_type == 3; /* R_M32C_32. */
12761 case EM_M32R:
12762 return reloc_type == 34; /* R_M32R_32_RELA. */
12763 case EM_68HC11:
12764 case EM_68HC12:
12765 return reloc_type == 6; /* R_M68HC11_32. */
12766 case EM_S12Z:
12767 return reloc_type == 7 || /* R_S12Z_EXT32 */
12768 reloc_type == 6; /* R_S12Z_CW32. */
12769 case EM_MCORE:
12770 return reloc_type == 1; /* R_MCORE_ADDR32. */
12771 case EM_CYGNUS_MEP:
12772 return reloc_type == 4; /* R_MEP_32. */
12773 case EM_METAG:
12774 return reloc_type == 2; /* R_METAG_ADDR32. */
12775 case EM_MICROBLAZE:
12776 return reloc_type == 1; /* R_MICROBLAZE_32. */
12777 case EM_MIPS:
12778 return reloc_type == 2; /* R_MIPS_32. */
12779 case EM_MMIX:
12780 return reloc_type == 4; /* R_MMIX_32. */
12781 case EM_CYGNUS_MN10200:
12782 case EM_MN10200:
12783 return reloc_type == 1; /* R_MN10200_32. */
12784 case EM_CYGNUS_MN10300:
12785 case EM_MN10300:
12786 return reloc_type == 1; /* R_MN10300_32. */
12787 case EM_MOXIE:
12788 return reloc_type == 1; /* R_MOXIE_32. */
12789 case EM_MSP430_OLD:
12790 case EM_MSP430:
12791 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12792 case EM_MT:
12793 return reloc_type == 2; /* R_MT_32. */
12794 case EM_NDS32:
12795 return reloc_type == 20; /* R_NDS32_RELA. */
12796 case EM_ALTERA_NIOS2:
12797 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
12798 case EM_NIOS32:
12799 return reloc_type == 1; /* R_NIOS_32. */
12800 case EM_OR1K:
12801 return reloc_type == 1; /* R_OR1K_32. */
12802 case EM_PARISC:
12803 return (reloc_type == 1 /* R_PARISC_DIR32. */
12804 || reloc_type == 2 /* R_PARISC_DIR21L. */
12805 || reloc_type == 41); /* R_PARISC_SECREL32. */
12806 case EM_PJ:
12807 case EM_PJ_OLD:
12808 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
12809 case EM_PPC64:
12810 return reloc_type == 1; /* R_PPC64_ADDR32. */
12811 case EM_PPC:
12812 return reloc_type == 1; /* R_PPC_ADDR32. */
12813 case EM_TI_PRU:
12814 return reloc_type == 11; /* R_PRU_BFD_RELOC_32. */
12815 case EM_RISCV:
12816 return reloc_type == 1; /* R_RISCV_32. */
12817 case EM_RL78:
12818 return reloc_type == 1; /* R_RL78_DIR32. */
12819 case EM_RX:
12820 return reloc_type == 1; /* R_RX_DIR32. */
12821 case EM_S370:
12822 return reloc_type == 1; /* R_I370_ADDR31. */
12823 case EM_S390_OLD:
12824 case EM_S390:
12825 return reloc_type == 4; /* R_S390_32. */
12826 case EM_SCORE:
12827 return reloc_type == 8; /* R_SCORE_ABS32. */
12828 case EM_SH:
12829 return reloc_type == 1; /* R_SH_DIR32. */
12830 case EM_SPARC32PLUS:
12831 case EM_SPARCV9:
12832 case EM_SPARC:
12833 return reloc_type == 3 /* R_SPARC_32. */
12834 || reloc_type == 23; /* R_SPARC_UA32. */
12835 case EM_SPU:
12836 return reloc_type == 6; /* R_SPU_ADDR32 */
12837 case EM_TI_C6000:
12838 return reloc_type == 1; /* R_C6000_ABS32. */
12839 case EM_TILEGX:
12840 return reloc_type == 2; /* R_TILEGX_32. */
12841 case EM_TILEPRO:
12842 return reloc_type == 1; /* R_TILEPRO_32. */
12843 case EM_CYGNUS_V850:
12844 case EM_V850:
12845 return reloc_type == 6; /* R_V850_ABS32. */
12846 case EM_V800:
12847 return reloc_type == 0x33; /* R_V810_WORD. */
12848 case EM_VAX:
12849 return reloc_type == 1; /* R_VAX_32. */
12850 case EM_VISIUM:
12851 return reloc_type == 3; /* R_VISIUM_32. */
12852 case EM_WEBASSEMBLY:
12853 return reloc_type == 1; /* R_WASM32_32. */
12854 case EM_X86_64:
12855 case EM_L1OM:
12856 case EM_K1OM:
12857 return reloc_type == 10; /* R_X86_64_32. */
12858 case EM_XC16X:
12859 case EM_C166:
12860 return reloc_type == 3; /* R_XC16C_ABS_32. */
12861 case EM_XGATE:
12862 return reloc_type == 4; /* R_XGATE_32. */
12863 case EM_XSTORMY16:
12864 return reloc_type == 1; /* R_XSTROMY16_32. */
12865 case EM_XTENSA_OLD:
12866 case EM_XTENSA:
12867 return reloc_type == 1; /* R_XTENSA_32. */
12868 case EM_Z80:
12869 return reloc_type == 6; /* R_Z80_32. */
12870 default:
12871 {
12872 static unsigned int prev_warn = 0;
12873
12874 /* Avoid repeating the same warning multiple times. */
12875 if (prev_warn != filedata->file_header.e_machine)
12876 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12877 filedata->file_header.e_machine);
12878 prev_warn = filedata->file_header.e_machine;
12879 return FALSE;
12880 }
12881 }
12882}
12883
12884/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12885 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12886
12887static bfd_boolean
12888is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12889{
12890 switch (filedata->file_header.e_machine)
12891 /* Please keep this table alpha-sorted for ease of visual lookup. */
12892 {
12893 case EM_386:
12894 case EM_IAMCU:
12895 return reloc_type == 2; /* R_386_PC32. */
12896 case EM_68K:
12897 return reloc_type == 4; /* R_68K_PC32. */
12898 case EM_AARCH64:
12899 return reloc_type == 261; /* R_AARCH64_PREL32 */
12900 case EM_ADAPTEVA_EPIPHANY:
12901 return reloc_type == 6;
12902 case EM_ALPHA:
12903 return reloc_type == 10; /* R_ALPHA_SREL32. */
12904 case EM_ARC_COMPACT:
12905 case EM_ARC_COMPACT2:
12906 return reloc_type == 49; /* R_ARC_32_PCREL. */
12907 case EM_ARM:
12908 return reloc_type == 3; /* R_ARM_REL32 */
12909 case EM_AVR_OLD:
12910 case EM_AVR:
12911 return reloc_type == 36; /* R_AVR_32_PCREL. */
12912 case EM_MICROBLAZE:
12913 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
12914 case EM_OR1K:
12915 return reloc_type == 9; /* R_OR1K_32_PCREL. */
12916 case EM_PARISC:
12917 return reloc_type == 9; /* R_PARISC_PCREL32. */
12918 case EM_PPC:
12919 return reloc_type == 26; /* R_PPC_REL32. */
12920 case EM_PPC64:
12921 return reloc_type == 26; /* R_PPC64_REL32. */
12922 case EM_RISCV:
12923 return reloc_type == 57; /* R_RISCV_32_PCREL. */
12924 case EM_S390_OLD:
12925 case EM_S390:
12926 return reloc_type == 5; /* R_390_PC32. */
12927 case EM_SH:
12928 return reloc_type == 2; /* R_SH_REL32. */
12929 case EM_SPARC32PLUS:
12930 case EM_SPARCV9:
12931 case EM_SPARC:
12932 return reloc_type == 6; /* R_SPARC_DISP32. */
12933 case EM_SPU:
12934 return reloc_type == 13; /* R_SPU_REL32. */
12935 case EM_TILEGX:
12936 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
12937 case EM_TILEPRO:
12938 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
12939 case EM_VISIUM:
12940 return reloc_type == 6; /* R_VISIUM_32_PCREL */
12941 case EM_X86_64:
12942 case EM_L1OM:
12943 case EM_K1OM:
12944 return reloc_type == 2; /* R_X86_64_PC32. */
12945 case EM_VAX:
12946 return reloc_type == 4; /* R_VAX_PCREL32. */
12947 case EM_XTENSA_OLD:
12948 case EM_XTENSA:
12949 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
12950 default:
12951 /* Do not abort or issue an error message here. Not all targets use
12952 pc-relative 32-bit relocs in their DWARF debug information and we
12953 have already tested for target coverage in is_32bit_abs_reloc. A
12954 more helpful warning message will be generated by apply_relocations
12955 anyway, so just return. */
12956 return FALSE;
12957 }
12958}
12959
12960/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12961 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12962
12963static bfd_boolean
12964is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12965{
12966 switch (filedata->file_header.e_machine)
12967 {
12968 case EM_AARCH64:
12969 return reloc_type == 257; /* R_AARCH64_ABS64. */
12970 case EM_ALPHA:
12971 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
12972 case EM_IA_64:
12973 return (reloc_type == 0x26 /* R_IA64_DIR64MSB. */
12974 || reloc_type == 0x27 /* R_IA64_DIR64LSB. */);
12975 case EM_PARISC:
12976 return reloc_type == 80; /* R_PARISC_DIR64. */
12977 case EM_PPC64:
12978 return reloc_type == 38; /* R_PPC64_ADDR64. */
12979 case EM_RISCV:
12980 return reloc_type == 2; /* R_RISCV_64. */
12981 case EM_SPARC32PLUS:
12982 case EM_SPARCV9:
12983 case EM_SPARC:
12984 return reloc_type == 32 /* R_SPARC_64. */
12985 || reloc_type == 54; /* R_SPARC_UA64. */
12986 case EM_X86_64:
12987 case EM_L1OM:
12988 case EM_K1OM:
12989 return reloc_type == 1; /* R_X86_64_64. */
12990 case EM_S390_OLD:
12991 case EM_S390:
12992 return reloc_type == 22; /* R_S390_64. */
12993 case EM_TILEGX:
12994 return reloc_type == 1; /* R_TILEGX_64. */
12995 case EM_MIPS:
12996 return reloc_type == 18; /* R_MIPS_64. */
12997 default:
12998 return FALSE;
12999 }
13000}
13001
13002/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
13003 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
13004
13005static bfd_boolean
13006is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
13007{
13008 switch (filedata->file_header.e_machine)
13009 {
13010 case EM_AARCH64:
13011 return reloc_type == 260; /* R_AARCH64_PREL64. */
13012 case EM_ALPHA:
13013 return reloc_type == 11; /* R_ALPHA_SREL64. */
13014 case EM_IA_64:
13015 return (reloc_type == 0x4e /* R_IA64_PCREL64MSB. */
13016 || reloc_type == 0x4f /* R_IA64_PCREL64LSB. */);
13017 case EM_PARISC:
13018 return reloc_type == 72; /* R_PARISC_PCREL64. */
13019 case EM_PPC64:
13020 return reloc_type == 44; /* R_PPC64_REL64. */
13021 case EM_SPARC32PLUS:
13022 case EM_SPARCV9:
13023 case EM_SPARC:
13024 return reloc_type == 46; /* R_SPARC_DISP64. */
13025 case EM_X86_64:
13026 case EM_L1OM:
13027 case EM_K1OM:
13028 return reloc_type == 24; /* R_X86_64_PC64. */
13029 case EM_S390_OLD:
13030 case EM_S390:
13031 return reloc_type == 23; /* R_S390_PC64. */
13032 case EM_TILEGX:
13033 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
13034 default:
13035 return FALSE;
13036 }
13037}
13038
13039/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13040 a 24-bit absolute RELA relocation used in DWARF debug sections. */
13041
13042static bfd_boolean
13043is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
13044{
13045 switch (filedata->file_header.e_machine)
13046 {
13047 case EM_CYGNUS_MN10200:
13048 case EM_MN10200:
13049 return reloc_type == 4; /* R_MN10200_24. */
13050 case EM_FT32:
13051 return reloc_type == 5; /* R_FT32_20. */
13052 case EM_Z80:
13053 return reloc_type == 5; /* R_Z80_24. */
13054 default:
13055 return FALSE;
13056 }
13057}
13058
13059/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13060 a 16-bit absolute RELA relocation used in DWARF debug sections. */
13061
13062static bfd_boolean
13063is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
13064{
13065 /* Please keep this table alpha-sorted for ease of visual lookup. */
13066 switch (filedata->file_header.e_machine)
13067 {
13068 case EM_ARC:
13069 case EM_ARC_COMPACT:
13070 case EM_ARC_COMPACT2:
13071 return reloc_type == 2; /* R_ARC_16. */
13072 case EM_ADAPTEVA_EPIPHANY:
13073 return reloc_type == 5;
13074 case EM_AVR_OLD:
13075 case EM_AVR:
13076 return reloc_type == 4; /* R_AVR_16. */
13077 case EM_CYGNUS_D10V:
13078 case EM_D10V:
13079 return reloc_type == 3; /* R_D10V_16. */
13080 case EM_FT32:
13081 return reloc_type == 2; /* R_FT32_16. */
13082 case EM_H8S:
13083 case EM_H8_300:
13084 case EM_H8_300H:
13085 return reloc_type == R_H8_DIR16;
13086 case EM_IP2K_OLD:
13087 case EM_IP2K:
13088 return reloc_type == 1; /* R_IP2K_16. */
13089 case EM_M32C_OLD:
13090 case EM_M32C:
13091 return reloc_type == 1; /* R_M32C_16 */
13092 case EM_CYGNUS_MN10200:
13093 case EM_MN10200:
13094 return reloc_type == 2; /* R_MN10200_16. */
13095 case EM_CYGNUS_MN10300:
13096 case EM_MN10300:
13097 return reloc_type == 2; /* R_MN10300_16. */
13098 case EM_MSP430:
13099 if (uses_msp430x_relocs (filedata))
13100 return reloc_type == 2; /* R_MSP430_ABS16. */
13101 /* Fall through. */
13102 case EM_MSP430_OLD:
13103 return reloc_type == 5; /* R_MSP430_16_BYTE. */
13104 case EM_NDS32:
13105 return reloc_type == 19; /* R_NDS32_RELA. */
13106 case EM_ALTERA_NIOS2:
13107 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
13108 case EM_NIOS32:
13109 return reloc_type == 9; /* R_NIOS_16. */
13110 case EM_OR1K:
13111 return reloc_type == 2; /* R_OR1K_16. */
13112 case EM_RISCV:
13113 return reloc_type == 55; /* R_RISCV_SET16. */
13114 case EM_TI_PRU:
13115 return reloc_type == 8; /* R_PRU_BFD_RELOC_16. */
13116 case EM_TI_C6000:
13117 return reloc_type == 2; /* R_C6000_ABS16. */
13118 case EM_VISIUM:
13119 return reloc_type == 2; /* R_VISIUM_16. */
13120 case EM_XC16X:
13121 case EM_C166:
13122 return reloc_type == 2; /* R_XC16C_ABS_16. */
13123 case EM_XGATE:
13124 return reloc_type == 3; /* R_XGATE_16. */
13125 case EM_Z80:
13126 return reloc_type == 4; /* R_Z80_16. */
13127 default:
13128 return FALSE;
13129 }
13130}
13131
13132/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13133 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13134
13135static bfd_boolean
13136is_8bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
13137{
13138 switch (filedata->file_header.e_machine)
13139 {
13140 case EM_RISCV:
13141 return reloc_type == 54; /* R_RISCV_SET8. */
13142 case EM_Z80:
13143 return reloc_type == 1; /* R_Z80_8. */
13144 default:
13145 return FALSE;
13146 }
13147}
13148
13149/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13150 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13151
13152static bfd_boolean
13153is_6bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
13154{
13155 switch (filedata->file_header.e_machine)
13156 {
13157 case EM_RISCV:
13158 return reloc_type == 53; /* R_RISCV_SET6. */
13159 default:
13160 return FALSE;
13161 }
13162}
13163
13164/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13165 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13166
13167static bfd_boolean
13168is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13169{
13170 /* Please keep this table alpha-sorted for ease of visual lookup. */
13171 switch (filedata->file_header.e_machine)
13172 {
13173 case EM_RISCV:
13174 return reloc_type == 35; /* R_RISCV_ADD32. */
13175 default:
13176 return FALSE;
13177 }
13178}
13179
13180/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13181 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13182
13183static bfd_boolean
13184is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13185{
13186 /* Please keep this table alpha-sorted for ease of visual lookup. */
13187 switch (filedata->file_header.e_machine)
13188 {
13189 case EM_RISCV:
13190 return reloc_type == 39; /* R_RISCV_SUB32. */
13191 default:
13192 return FALSE;
13193 }
13194}
13195
13196/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13197 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13198
13199static bfd_boolean
13200is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13201{
13202 /* Please keep this table alpha-sorted for ease of visual lookup. */
13203 switch (filedata->file_header.e_machine)
13204 {
13205 case EM_RISCV:
13206 return reloc_type == 36; /* R_RISCV_ADD64. */
13207 default:
13208 return FALSE;
13209 }
13210}
13211
13212/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13213 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13214
13215static bfd_boolean
13216is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13217{
13218 /* Please keep this table alpha-sorted for ease of visual lookup. */
13219 switch (filedata->file_header.e_machine)
13220 {
13221 case EM_RISCV:
13222 return reloc_type == 40; /* R_RISCV_SUB64. */
13223 default:
13224 return FALSE;
13225 }
13226}
13227
13228/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13229 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13230
13231static bfd_boolean
13232is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13233{
13234 /* Please keep this table alpha-sorted for ease of visual lookup. */
13235 switch (filedata->file_header.e_machine)
13236 {
13237 case EM_RISCV:
13238 return reloc_type == 34; /* R_RISCV_ADD16. */
13239 default:
13240 return FALSE;
13241 }
13242}
13243
13244/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13245 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13246
13247static bfd_boolean
13248is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13249{
13250 /* Please keep this table alpha-sorted for ease of visual lookup. */
13251 switch (filedata->file_header.e_machine)
13252 {
13253 case EM_RISCV:
13254 return reloc_type == 38; /* R_RISCV_SUB16. */
13255 default:
13256 return FALSE;
13257 }
13258}
13259
13260/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13261 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13262
13263static bfd_boolean
13264is_8bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13265{
13266 /* Please keep this table alpha-sorted for ease of visual lookup. */
13267 switch (filedata->file_header.e_machine)
13268 {
13269 case EM_RISCV:
13270 return reloc_type == 33; /* R_RISCV_ADD8. */
13271 default:
13272 return FALSE;
13273 }
13274}
13275
13276/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13277 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13278
13279static bfd_boolean
13280is_8bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13281{
13282 /* Please keep this table alpha-sorted for ease of visual lookup. */
13283 switch (filedata->file_header.e_machine)
13284 {
13285 case EM_RISCV:
13286 return reloc_type == 37; /* R_RISCV_SUB8. */
13287 default:
13288 return FALSE;
13289 }
13290}
13291
13292/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13293 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13294
13295static bfd_boolean
13296is_6bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13297{
13298 switch (filedata->file_header.e_machine)
13299 {
13300 case EM_RISCV:
13301 return reloc_type == 52; /* R_RISCV_SUB6. */
13302 default:
13303 return FALSE;
13304 }
13305}
13306
13307/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13308 relocation entries (possibly formerly used for SHT_GROUP sections). */
13309
13310static bfd_boolean
13311is_none_reloc (Filedata * filedata, unsigned int reloc_type)
13312{
13313 switch (filedata->file_header.e_machine)
13314 {
13315 case EM_386: /* R_386_NONE. */
13316 case EM_68K: /* R_68K_NONE. */
13317 case EM_ADAPTEVA_EPIPHANY:
13318 case EM_ALPHA: /* R_ALPHA_NONE. */
13319 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
13320 case EM_ARC: /* R_ARC_NONE. */
13321 case EM_ARC_COMPACT2: /* R_ARC_NONE. */
13322 case EM_ARC_COMPACT: /* R_ARC_NONE. */
13323 case EM_ARM: /* R_ARM_NONE. */
13324 case EM_C166: /* R_XC16X_NONE. */
13325 case EM_CRIS: /* R_CRIS_NONE. */
13326 case EM_FT32: /* R_FT32_NONE. */
13327 case EM_IA_64: /* R_IA64_NONE. */
13328 case EM_K1OM: /* R_X86_64_NONE. */
13329 case EM_L1OM: /* R_X86_64_NONE. */
13330 case EM_M32R: /* R_M32R_NONE. */
13331 case EM_MIPS: /* R_MIPS_NONE. */
13332 case EM_MN10300: /* R_MN10300_NONE. */
13333 case EM_MOXIE: /* R_MOXIE_NONE. */
13334 case EM_NIOS32: /* R_NIOS_NONE. */
13335 case EM_OR1K: /* R_OR1K_NONE. */
13336 case EM_PARISC: /* R_PARISC_NONE. */
13337 case EM_PPC64: /* R_PPC64_NONE. */
13338 case EM_PPC: /* R_PPC_NONE. */
13339 case EM_RISCV: /* R_RISCV_NONE. */
13340 case EM_S390: /* R_390_NONE. */
13341 case EM_S390_OLD:
13342 case EM_SH: /* R_SH_NONE. */
13343 case EM_SPARC32PLUS:
13344 case EM_SPARC: /* R_SPARC_NONE. */
13345 case EM_SPARCV9:
13346 case EM_TILEGX: /* R_TILEGX_NONE. */
13347 case EM_TILEPRO: /* R_TILEPRO_NONE. */
13348 case EM_TI_C6000:/* R_C6000_NONE. */
13349 case EM_X86_64: /* R_X86_64_NONE. */
13350 case EM_XC16X:
13351 case EM_Z80: /* R_Z80_NONE. */
13352 case EM_WEBASSEMBLY: /* R_WASM32_NONE. */
13353 return reloc_type == 0;
13354
13355 case EM_AARCH64:
13356 return reloc_type == 0 || reloc_type == 256;
13357 case EM_AVR_OLD:
13358 case EM_AVR:
13359 return (reloc_type == 0 /* R_AVR_NONE. */
13360 || reloc_type == 30 /* R_AVR_DIFF8. */
13361 || reloc_type == 31 /* R_AVR_DIFF16. */
13362 || reloc_type == 32 /* R_AVR_DIFF32. */);
13363 case EM_METAG:
13364 return reloc_type == 3; /* R_METAG_NONE. */
13365 case EM_NDS32:
13366 return (reloc_type == 0 /* R_XTENSA_NONE. */
13367 || reloc_type == 204 /* R_NDS32_DIFF8. */
13368 || reloc_type == 205 /* R_NDS32_DIFF16. */
13369 || reloc_type == 206 /* R_NDS32_DIFF32. */
13370 || reloc_type == 207 /* R_NDS32_ULEB128. */);
13371 case EM_TI_PRU:
13372 return (reloc_type == 0 /* R_PRU_NONE. */
13373 || reloc_type == 65 /* R_PRU_DIFF8. */
13374 || reloc_type == 66 /* R_PRU_DIFF16. */
13375 || reloc_type == 67 /* R_PRU_DIFF32. */);
13376 case EM_XTENSA_OLD:
13377 case EM_XTENSA:
13378 return (reloc_type == 0 /* R_XTENSA_NONE. */
13379 || reloc_type == 17 /* R_XTENSA_DIFF8. */
13380 || reloc_type == 18 /* R_XTENSA_DIFF16. */
13381 || reloc_type == 19 /* R_XTENSA_DIFF32. */
13382 || reloc_type == 57 /* R_XTENSA_PDIFF8. */
13383 || reloc_type == 58 /* R_XTENSA_PDIFF16. */
13384 || reloc_type == 59 /* R_XTENSA_PDIFF32. */
13385 || reloc_type == 60 /* R_XTENSA_NDIFF8. */
13386 || reloc_type == 61 /* R_XTENSA_NDIFF16. */
13387 || reloc_type == 62 /* R_XTENSA_NDIFF32. */);
13388 }
13389 return FALSE;
13390}
13391
13392/* Returns TRUE if there is a relocation against
13393 section NAME at OFFSET bytes. */
13394
13395bfd_boolean
13396reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
13397{
13398 Elf_Internal_Rela * relocs;
13399 Elf_Internal_Rela * rp;
13400
13401 if (dsec == NULL || dsec->reloc_info == NULL)
13402 return FALSE;
13403
13404 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
13405
13406 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
13407 if (rp->r_offset == offset)
13408 return TRUE;
13409
13410 return FALSE;
13411}
13412
13413/* Apply relocations to a section.
13414 Returns TRUE upon success, FALSE otherwise.
13415 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13416 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13417 will be set to the number of relocs loaded.
13418
13419 Note: So far support has been added only for those relocations
13420 which can be found in debug sections. FIXME: Add support for
13421 more relocations ? */
13422
13423static bfd_boolean
13424apply_relocations (Filedata * filedata,
13425 const Elf_Internal_Shdr * section,
13426 unsigned char * start,
13427 bfd_size_type size,
13428 void ** relocs_return,
13429 unsigned long * num_relocs_return)
13430{
13431 Elf_Internal_Shdr * relsec;
13432 unsigned char * end = start + size;
13433
13434 if (relocs_return != NULL)
13435 {
13436 * (Elf_Internal_Rela **) relocs_return = NULL;
13437 * num_relocs_return = 0;
13438 }
13439
13440 if (filedata->file_header.e_type != ET_REL)
13441 /* No relocs to apply. */
13442 return TRUE;
13443
13444 /* Find the reloc section associated with the section. */
13445 for (relsec = filedata->section_headers;
13446 relsec < filedata->section_headers + filedata->file_header.e_shnum;
13447 ++relsec)
13448 {
13449 bfd_boolean is_rela;
13450 unsigned long num_relocs;
13451 Elf_Internal_Rela * relocs;
13452 Elf_Internal_Rela * rp;
13453 Elf_Internal_Shdr * symsec;
13454 Elf_Internal_Sym * symtab;
13455 unsigned long num_syms;
13456 Elf_Internal_Sym * sym;
13457
13458 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13459 || relsec->sh_info >= filedata->file_header.e_shnum
13460 || filedata->section_headers + relsec->sh_info != section
13461 || relsec->sh_size == 0
13462 || relsec->sh_link >= filedata->file_header.e_shnum)
13463 continue;
13464
13465 symsec = filedata->section_headers + relsec->sh_link;
13466 if (symsec->sh_type != SHT_SYMTAB
13467 && symsec->sh_type != SHT_DYNSYM)
13468 return FALSE;
13469
13470 is_rela = relsec->sh_type == SHT_RELA;
13471
13472 if (is_rela)
13473 {
13474 if (!slurp_rela_relocs (filedata, relsec->sh_offset,
13475 relsec->sh_size, & relocs, & num_relocs))
13476 return FALSE;
13477 }
13478 else
13479 {
13480 if (!slurp_rel_relocs (filedata, relsec->sh_offset,
13481 relsec->sh_size, & relocs, & num_relocs))
13482 return FALSE;
13483 }
13484
13485 /* SH uses RELA but uses in place value instead of the addend field. */
13486 if (filedata->file_header.e_machine == EM_SH)
13487 is_rela = FALSE;
13488
13489 symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
13490
13491 for (rp = relocs; rp < relocs + num_relocs; ++rp)
13492 {
13493 bfd_vma addend;
13494 unsigned int reloc_type;
13495 unsigned int reloc_size;
13496 bfd_boolean reloc_inplace = FALSE;
13497 bfd_boolean reloc_subtract = FALSE;
13498 unsigned char * rloc;
13499 unsigned long sym_index;
13500
13501 reloc_type = get_reloc_type (filedata, rp->r_info);
13502
13503 if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
13504 continue;
13505 else if (is_none_reloc (filedata, reloc_type))
13506 continue;
13507 else if (is_32bit_abs_reloc (filedata, reloc_type)
13508 || is_32bit_pcrel_reloc (filedata, reloc_type))
13509 reloc_size = 4;
13510 else if (is_64bit_abs_reloc (filedata, reloc_type)
13511 || is_64bit_pcrel_reloc (filedata, reloc_type))
13512 reloc_size = 8;
13513 else if (is_24bit_abs_reloc (filedata, reloc_type))
13514 reloc_size = 3;
13515 else if (is_16bit_abs_reloc (filedata, reloc_type))
13516 reloc_size = 2;
13517 else if (is_8bit_abs_reloc (filedata, reloc_type)
13518 || is_6bit_abs_reloc (filedata, reloc_type))
13519 reloc_size = 1;
13520 else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
13521 reloc_type))
13522 || is_32bit_inplace_add_reloc (filedata, reloc_type))
13523 {
13524 reloc_size = 4;
13525 reloc_inplace = TRUE;
13526 }
13527 else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
13528 reloc_type))
13529 || is_64bit_inplace_add_reloc (filedata, reloc_type))
13530 {
13531 reloc_size = 8;
13532 reloc_inplace = TRUE;
13533 }
13534 else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
13535 reloc_type))
13536 || is_16bit_inplace_add_reloc (filedata, reloc_type))
13537 {
13538 reloc_size = 2;
13539 reloc_inplace = TRUE;
13540 }
13541 else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
13542 reloc_type))
13543 || is_8bit_inplace_add_reloc (filedata, reloc_type))
13544 {
13545 reloc_size = 1;
13546 reloc_inplace = TRUE;
13547 }
13548 else if ((reloc_subtract = is_6bit_inplace_sub_reloc (filedata,
13549 reloc_type)))
13550 {
13551 reloc_size = 1;
13552 reloc_inplace = TRUE;
13553 }
13554 else
13555 {
13556 static unsigned int prev_reloc = 0;
13557
13558 if (reloc_type != prev_reloc)
13559 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13560 reloc_type, printable_section_name (filedata, section));
13561 prev_reloc = reloc_type;
13562 continue;
13563 }
13564
13565 rloc = start + rp->r_offset;
13566 if (!IN_RANGE (start, end, rloc, reloc_size))
13567 {
13568 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13569 (unsigned long) rp->r_offset,
13570 printable_section_name (filedata, section));
13571 continue;
13572 }
13573
13574 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
13575 if (sym_index >= num_syms)
13576 {
13577 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13578 sym_index, printable_section_name (filedata, section));
13579 continue;
13580 }
13581 sym = symtab + sym_index;
13582
13583 /* If the reloc has a symbol associated with it,
13584 make sure that it is of an appropriate type.
13585
13586 Relocations against symbols without type can happen.
13587 Gcc -feliminate-dwarf2-dups may generate symbols
13588 without type for debug info.
13589
13590 Icc generates relocations against function symbols
13591 instead of local labels.
13592
13593 Relocations against object symbols can happen, eg when
13594 referencing a global array. For an example of this see
13595 the _clz.o binary in libgcc.a. */
13596 if (sym != symtab
13597 && ELF_ST_TYPE (sym->st_info) != STT_COMMON
13598 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
13599 {
13600 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13601 get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
13602 printable_section_name (filedata, relsec),
13603 (long int)(rp - relocs));
13604 continue;
13605 }
13606
13607 addend = 0;
13608 if (is_rela)
13609 addend += rp->r_addend;
13610 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13611 partial_inplace. */
13612 if (!is_rela
13613 || (filedata->file_header.e_machine == EM_XTENSA
13614 && reloc_type == 1)
13615 || ((filedata->file_header.e_machine == EM_PJ
13616 || filedata->file_header.e_machine == EM_PJ_OLD)
13617 && reloc_type == 1)
13618 || ((filedata->file_header.e_machine == EM_D30V
13619 || filedata->file_header.e_machine == EM_CYGNUS_D30V)
13620 && reloc_type == 12)
13621 || reloc_inplace)
13622 {
13623 if (is_6bit_inplace_sub_reloc (filedata, reloc_type))
13624 addend += byte_get (rloc, reloc_size) & 0x3f;
13625 else
13626 addend += byte_get (rloc, reloc_size);
13627 }
13628
13629 if (is_32bit_pcrel_reloc (filedata, reloc_type)
13630 || is_64bit_pcrel_reloc (filedata, reloc_type))
13631 {
13632 /* On HPPA, all pc-relative relocations are biased by 8. */
13633 if (filedata->file_header.e_machine == EM_PARISC)
13634 addend -= 8;
13635 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
13636 reloc_size);
13637 }
13638 else if (is_6bit_abs_reloc (filedata, reloc_type)
13639 || is_6bit_inplace_sub_reloc (filedata, reloc_type))
13640 {
13641 if (reloc_subtract)
13642 addend -= sym->st_value;
13643 else
13644 addend += sym->st_value;
13645 addend = (addend & 0x3f) | (byte_get (rloc, reloc_size) & 0xc0);
13646 byte_put (rloc, addend, reloc_size);
13647 }
13648 else if (reloc_subtract)
13649 byte_put (rloc, addend - sym->st_value, reloc_size);
13650 else
13651 byte_put (rloc, addend + sym->st_value, reloc_size);
13652 }
13653
13654 free (symtab);
13655 /* Let the target specific reloc processing code know that
13656 we have finished with these relocs. */
13657 target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
13658
13659 if (relocs_return)
13660 {
13661 * (Elf_Internal_Rela **) relocs_return = relocs;
13662 * num_relocs_return = num_relocs;
13663 }
13664 else
13665 free (relocs);
13666
13667 break;
13668 }
13669
13670 return TRUE;
13671}
13672
13673#ifdef SUPPORT_DISASSEMBLY
13674static bfd_boolean
13675disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
13676{
13677 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
13678
13679 /* FIXME: XXX -- to be done --- XXX */
13680
13681 return TRUE;
13682}
13683#endif
13684
13685/* Reads in the contents of SECTION from FILE, returning a pointer
13686 to a malloc'ed buffer or NULL if something went wrong. */
13687
13688static char *
13689get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
13690{
13691 bfd_size_type num_bytes = section->sh_size;
13692
13693 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
13694 {
13695 printf (_("Section '%s' has no data to dump.\n"),
13696 printable_section_name (filedata, section));
13697 return NULL;
13698 }
13699
13700 return (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
13701 _("section contents"));
13702}
13703
13704/* Uncompresses a section that was compressed using zlib, in place. */
13705
13706static bfd_boolean
13707uncompress_section_contents (unsigned char ** buffer,
13708 dwarf_size_type uncompressed_size,
13709 dwarf_size_type * size)
13710{
13711 dwarf_size_type compressed_size = *size;
13712 unsigned char * compressed_buffer = *buffer;
13713 unsigned char * uncompressed_buffer;
13714 z_stream strm;
13715 int rc;
13716
13717 /* It is possible the section consists of several compressed
13718 buffers concatenated together, so we uncompress in a loop. */
13719 /* PR 18313: The state field in the z_stream structure is supposed
13720 to be invisible to the user (ie us), but some compilers will
13721 still complain about it being used without initialisation. So
13722 we first zero the entire z_stream structure and then set the fields
13723 that we need. */
13724 memset (& strm, 0, sizeof strm);
13725 strm.avail_in = compressed_size;
13726 strm.next_in = (Bytef *) compressed_buffer;
13727 strm.avail_out = uncompressed_size;
13728 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
13729
13730 rc = inflateInit (& strm);
13731 while (strm.avail_in > 0)
13732 {
13733 if (rc != Z_OK)
13734 goto fail;
13735 strm.next_out = ((Bytef *) uncompressed_buffer
13736 + (uncompressed_size - strm.avail_out));
13737 rc = inflate (&strm, Z_FINISH);
13738 if (rc != Z_STREAM_END)
13739 goto fail;
13740 rc = inflateReset (& strm);
13741 }
13742 rc = inflateEnd (& strm);
13743 if (rc != Z_OK
13744 || strm.avail_out != 0)
13745 goto fail;
13746
13747 *buffer = uncompressed_buffer;
13748 *size = uncompressed_size;
13749 return TRUE;
13750
13751 fail:
13752 free (uncompressed_buffer);
13753 /* Indicate decompression failure. */
13754 *buffer = NULL;
13755 return FALSE;
13756}
13757
13758static bfd_boolean
13759dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
13760{
13761 Elf_Internal_Shdr * relsec;
13762 bfd_size_type num_bytes;
13763 unsigned char * data;
13764 unsigned char * end;
13765 unsigned char * real_start;
13766 unsigned char * start;
13767 bfd_boolean some_strings_shown;
13768
13769 real_start = start = (unsigned char *) get_section_contents (section, filedata);
13770 if (start == NULL)
13771 /* PR 21820: Do not fail if the section was empty. */
13772 return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13773
13774 num_bytes = section->sh_size;
13775
13776 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
13777
13778 if (decompress_dumps)
13779 {
13780 dwarf_size_type new_size = num_bytes;
13781 dwarf_size_type uncompressed_size = 0;
13782
13783 if ((section->sh_flags & SHF_COMPRESSED) != 0)
13784 {
13785 Elf_Internal_Chdr chdr;
13786 unsigned int compression_header_size
13787 = get_compression_header (& chdr, (unsigned char *) start,
13788 num_bytes);
13789 if (compression_header_size == 0)
13790 /* An error message will have already been generated
13791 by get_compression_header. */
13792 goto error_out;
13793
13794 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13795 {
13796 warn (_("section '%s' has unsupported compress type: %d\n"),
13797 printable_section_name (filedata, section), chdr.ch_type);
13798 goto error_out;
13799 }
13800 uncompressed_size = chdr.ch_size;
13801 start += compression_header_size;
13802 new_size -= compression_header_size;
13803 }
13804 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13805 {
13806 /* Read the zlib header. In this case, it should be "ZLIB"
13807 followed by the uncompressed section size, 8 bytes in
13808 big-endian order. */
13809 uncompressed_size = start[4]; uncompressed_size <<= 8;
13810 uncompressed_size += start[5]; uncompressed_size <<= 8;
13811 uncompressed_size += start[6]; uncompressed_size <<= 8;
13812 uncompressed_size += start[7]; uncompressed_size <<= 8;
13813 uncompressed_size += start[8]; uncompressed_size <<= 8;
13814 uncompressed_size += start[9]; uncompressed_size <<= 8;
13815 uncompressed_size += start[10]; uncompressed_size <<= 8;
13816 uncompressed_size += start[11];
13817 start += 12;
13818 new_size -= 12;
13819 }
13820
13821 if (uncompressed_size)
13822 {
13823 if (uncompress_section_contents (& start,
13824 uncompressed_size, & new_size))
13825 num_bytes = new_size;
13826 else
13827 {
13828 error (_("Unable to decompress section %s\n"),
13829 printable_section_name (filedata, section));
13830 goto error_out;
13831 }
13832 }
13833 else
13834 start = real_start;
13835 }
13836
13837 /* If the section being dumped has relocations against it the user might
13838 be expecting these relocations to have been applied. Check for this
13839 case and issue a warning message in order to avoid confusion.
13840 FIXME: Maybe we ought to have an option that dumps a section with
13841 relocs applied ? */
13842 for (relsec = filedata->section_headers;
13843 relsec < filedata->section_headers + filedata->file_header.e_shnum;
13844 ++relsec)
13845 {
13846 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13847 || relsec->sh_info >= filedata->file_header.e_shnum
13848 || filedata->section_headers + relsec->sh_info != section
13849 || relsec->sh_size == 0
13850 || relsec->sh_link >= filedata->file_header.e_shnum)
13851 continue;
13852
13853 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13854 break;
13855 }
13856
13857 data = start;
13858 end = start + num_bytes;
13859 some_strings_shown = FALSE;
13860
13861#ifdef HAVE_MBSTATE_T
13862 mbstate_t state;
13863 /* Initialise the multibyte conversion state. */
13864 memset (& state, 0, sizeof (state));
13865#endif
13866
13867 bfd_boolean continuing = FALSE;
13868
13869 while (data < end)
13870 {
13871 while (!ISPRINT (* data))
13872 if (++ data >= end)
13873 break;
13874
13875 if (data < end)
13876 {
13877 size_t maxlen = end - data;
13878
13879 if (continuing)
13880 {
13881 printf (" ");
13882 continuing = FALSE;
13883 }
13884 else
13885 {
13886#ifndef __MSVCRT__
13887 /* PR 11128: Use two separate invocations in order to work
13888 around bugs in the Solaris 8 implementation of printf. */
13889 printf (" [%6tx] ", data - start);
13890#else
13891 printf (" [%6Ix] ", (size_t) (data - start));
13892#endif
13893 }
13894
13895 if (maxlen > 0)
13896 {
13897 char c;
13898
13899 while (maxlen)
13900 {
13901 c = *data++;
13902
13903 if (c == 0)
13904 break;
13905
13906 /* PR 25543: Treat new-lines as string-ending characters. */
13907 if (c == '\n')
13908 {
13909 printf ("\\n\n");
13910 if (*data != 0)
13911 continuing = TRUE;
13912 break;
13913 }
13914
13915 /* Do not print control characters directly as they can affect terminal
13916 settings. Such characters usually appear in the names generated
13917 by the assembler for local labels. */
13918 if (ISCNTRL (c))
13919 {
13920 printf ("^%c", c + 0x40);
13921 }
13922 else if (ISPRINT (c))
13923 {
13924 putchar (c);
13925 }
13926 else
13927 {
13928 size_t n;
13929#ifdef HAVE_MBSTATE_T
13930 wchar_t w;
13931#endif
13932 /* Let printf do the hard work of displaying multibyte characters. */
13933 printf ("%.1s", data - 1);
13934#ifdef HAVE_MBSTATE_T
13935 /* Try to find out how many bytes made up the character that was
13936 just printed. Advance the symbol pointer past the bytes that
13937 were displayed. */
13938 n = mbrtowc (& w, (char *)(data - 1), MB_CUR_MAX, & state);
13939#else
13940 n = 1;
13941#endif
13942 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
13943 data += (n - 1);
13944 }
13945 }
13946
13947 if (c != '\n')
13948 putchar ('\n');
13949 }
13950 else
13951 {
13952 printf (_("<corrupt>\n"));
13953 data = end;
13954 }
13955 some_strings_shown = TRUE;
13956 }
13957 }
13958
13959 if (! some_strings_shown)
13960 printf (_(" No strings found in this section."));
13961
13962 free (real_start);
13963
13964 putchar ('\n');
13965 return TRUE;
13966
13967error_out:
13968 free (real_start);
13969 return FALSE;
13970}
13971
13972static bfd_boolean
13973dump_section_as_bytes (Elf_Internal_Shdr * section,
13974 Filedata * filedata,
13975 bfd_boolean relocate)
13976{
13977 Elf_Internal_Shdr * relsec;
13978 bfd_size_type bytes;
13979 bfd_size_type section_size;
13980 bfd_vma addr;
13981 unsigned char * data;
13982 unsigned char * real_start;
13983 unsigned char * start;
13984
13985 real_start = start = (unsigned char *) get_section_contents (section, filedata);
13986 if (start == NULL)
13987 /* PR 21820: Do not fail if the section was empty. */
13988 return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13989
13990 section_size = section->sh_size;
13991
13992 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
13993
13994 if (decompress_dumps)
13995 {
13996 dwarf_size_type new_size = section_size;
13997 dwarf_size_type uncompressed_size = 0;
13998
13999 if ((section->sh_flags & SHF_COMPRESSED) != 0)
14000 {
14001 Elf_Internal_Chdr chdr;
14002 unsigned int compression_header_size
14003 = get_compression_header (& chdr, start, section_size);
14004
14005 if (compression_header_size == 0)
14006 /* An error message will have already been generated
14007 by get_compression_header. */
14008 goto error_out;
14009
14010 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
14011 {
14012 warn (_("section '%s' has unsupported compress type: %d\n"),
14013 printable_section_name (filedata, section), chdr.ch_type);
14014 goto error_out;
14015 }
14016 uncompressed_size = chdr.ch_size;
14017 start += compression_header_size;
14018 new_size -= compression_header_size;
14019 }
14020 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
14021 {
14022 /* Read the zlib header. In this case, it should be "ZLIB"
14023 followed by the uncompressed section size, 8 bytes in
14024 big-endian order. */
14025 uncompressed_size = start[4]; uncompressed_size <<= 8;
14026 uncompressed_size += start[5]; uncompressed_size <<= 8;
14027 uncompressed_size += start[6]; uncompressed_size <<= 8;
14028 uncompressed_size += start[7]; uncompressed_size <<= 8;
14029 uncompressed_size += start[8]; uncompressed_size <<= 8;
14030 uncompressed_size += start[9]; uncompressed_size <<= 8;
14031 uncompressed_size += start[10]; uncompressed_size <<= 8;
14032 uncompressed_size += start[11];
14033 start += 12;
14034 new_size -= 12;
14035 }
14036
14037 if (uncompressed_size)
14038 {
14039 if (uncompress_section_contents (& start, uncompressed_size,
14040 & new_size))
14041 {
14042 section_size = new_size;
14043 }
14044 else
14045 {
14046 error (_("Unable to decompress section %s\n"),
14047 printable_section_name (filedata, section));
14048 /* FIXME: Print the section anyway ? */
14049 goto error_out;
14050 }
14051 }
14052 else
14053 start = real_start;
14054 }
14055
14056 if (relocate)
14057 {
14058 if (! apply_relocations (filedata, section, start, section_size, NULL, NULL))
14059 goto error_out;
14060 }
14061 else
14062 {
14063 /* If the section being dumped has relocations against it the user might
14064 be expecting these relocations to have been applied. Check for this
14065 case and issue a warning message in order to avoid confusion.
14066 FIXME: Maybe we ought to have an option that dumps a section with
14067 relocs applied ? */
14068 for (relsec = filedata->section_headers;
14069 relsec < filedata->section_headers + filedata->file_header.e_shnum;
14070 ++relsec)
14071 {
14072 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
14073 || relsec->sh_info >= filedata->file_header.e_shnum
14074 || filedata->section_headers + relsec->sh_info != section
14075 || relsec->sh_size == 0
14076 || relsec->sh_link >= filedata->file_header.e_shnum)
14077 continue;
14078
14079 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14080 break;
14081 }
14082 }
14083
14084 addr = section->sh_addr;
14085 bytes = section_size;
14086 data = start;
14087
14088 while (bytes)
14089 {
14090 int j;
14091 int k;
14092 int lbytes;
14093
14094 lbytes = (bytes > 16 ? 16 : bytes);
14095
14096 printf (" 0x%8.8lx ", (unsigned long) addr);
14097
14098 for (j = 0; j < 16; j++)
14099 {
14100 if (j < lbytes)
14101 printf ("%2.2x", data[j]);
14102 else
14103 printf (" ");
14104
14105 if ((j & 3) == 3)
14106 printf (" ");
14107 }
14108
14109 for (j = 0; j < lbytes; j++)
14110 {
14111 k = data[j];
14112 if (k >= ' ' && k < 0x7f)
14113 printf ("%c", k);
14114 else
14115 printf (".");
14116 }
14117
14118 putchar ('\n');
14119
14120 data += lbytes;
14121 addr += lbytes;
14122 bytes -= lbytes;
14123 }
14124
14125 free (real_start);
14126
14127 putchar ('\n');
14128 return TRUE;
14129
14130 error_out:
14131 free (real_start);
14132 return FALSE;
14133}
14134
14135static ctf_sect_t *
14136shdr_to_ctf_sect (ctf_sect_t *buf, Elf_Internal_Shdr *shdr, Filedata *filedata)
14137{
14138 buf->cts_name = SECTION_NAME (shdr);
14139 buf->cts_size = shdr->sh_size;
14140 buf->cts_entsize = shdr->sh_entsize;
14141
14142 return buf;
14143}
14144
14145/* Formatting callback function passed to ctf_dump. Returns either the pointer
14146 it is passed, or a pointer to newly-allocated storage, in which case
14147 dump_ctf() will free it when it no longer needs it. */
14148
14149static char *dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED,
14150 char *s, void *arg)
14151{
14152 const char *blanks = arg;
14153 char *new_s;
14154
14155 if (asprintf (&new_s, "%s%s", blanks, s) < 0)
14156 return s;
14157 return new_s;
14158}
14159
14160static bfd_boolean
14161dump_section_as_ctf (Elf_Internal_Shdr * section, Filedata * filedata)
14162{
14163 Elf_Internal_Shdr * parent_sec = NULL;
14164 Elf_Internal_Shdr * symtab_sec = NULL;
14165 Elf_Internal_Shdr * strtab_sec = NULL;
14166 void * data = NULL;
14167 void * symdata = NULL;
14168 void * strdata = NULL;
14169 void * parentdata = NULL;
14170 ctf_sect_t ctfsect, symsect, strsect, parentsect;
14171 ctf_sect_t * symsectp = NULL;
14172 ctf_sect_t * strsectp = NULL;
14173 ctf_file_t * ctf = NULL;
14174 ctf_file_t * parent = NULL;
14175
14176 const char *things[] = {"Header", "Labels", "Data objects",
14177 "Function objects", "Variables", "Types", "Strings",
14178 ""};
14179 const char **thing;
14180 int err;
14181 bfd_boolean ret = FALSE;
14182 size_t i;
14183
14184 shdr_to_ctf_sect (&ctfsect, section, filedata);
14185 data = get_section_contents (section, filedata);
14186 ctfsect.cts_data = data;
14187
14188 if (!dump_ctf_symtab_name)
14189 dump_ctf_symtab_name = strdup (".symtab");
14190
14191 if (!dump_ctf_strtab_name)
14192 dump_ctf_strtab_name = strdup (".strtab");
14193
14194 if (dump_ctf_symtab_name && dump_ctf_symtab_name[0] != 0)
14195 {
14196 if ((symtab_sec = find_section (filedata, dump_ctf_symtab_name)) == NULL)
14197 {
14198 error (_("No symbol section named %s\n"), dump_ctf_symtab_name);
14199 goto fail;
14200 }
14201 if ((symdata = (void *) get_data (NULL, filedata,
14202 symtab_sec->sh_offset, 1,
14203 symtab_sec->sh_size,
14204 _("symbols"))) == NULL)
14205 goto fail;
14206 symsectp = shdr_to_ctf_sect (&symsect, symtab_sec, filedata);
14207 symsect.cts_data = symdata;
14208 }
14209 if (dump_ctf_strtab_name && dump_ctf_symtab_name[0] != 0)
14210 {
14211 if ((strtab_sec = find_section (filedata, dump_ctf_strtab_name)) == NULL)
14212 {
14213 error (_("No string table section named %s\n"),
14214 dump_ctf_strtab_name);
14215 goto fail;
14216 }
14217 if ((strdata = (void *) get_data (NULL, filedata,
14218 strtab_sec->sh_offset, 1,
14219 strtab_sec->sh_size,
14220 _("strings"))) == NULL)
14221 goto fail;
14222 strsectp = shdr_to_ctf_sect (&strsect, strtab_sec, filedata);
14223 strsect.cts_data = strdata;
14224 }
14225 if (dump_ctf_parent_name)
14226 {
14227 if ((parent_sec = find_section (filedata, dump_ctf_parent_name)) == NULL)
14228 {
14229 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name);
14230 goto fail;
14231 }
14232 if ((parentdata = (void *) get_data (NULL, filedata,
14233 parent_sec->sh_offset, 1,
14234 parent_sec->sh_size,
14235 _("CTF parent"))) == NULL)
14236 goto fail;
14237 shdr_to_ctf_sect (&parentsect, parent_sec, filedata);
14238 parentsect.cts_data = parentdata;
14239 }
14240
14241 /* Load the CTF file and dump it. */
14242
14243 if ((ctf = ctf_bufopen (&ctfsect, symsectp, strsectp, &err)) == NULL)
14244 {
14245 error (_("CTF open failure: %s\n"), ctf_errmsg (err));
14246 goto fail;
14247 }
14248
14249 if (parentdata)
14250 {
14251 if ((parent = ctf_bufopen (&parentsect, symsectp, strsectp, &err)) == NULL)
14252 {
14253 error (_("CTF open failure: %s\n"), ctf_errmsg (err));
14254 goto fail;
14255 }
14256
14257 ctf_import (ctf, parent);
14258 }
14259
14260 ret = TRUE;
14261
14262 printf (_("\nDump of CTF section '%s':\n"),
14263 printable_section_name (filedata, section));
14264
14265 for (i = 0, thing = things; *thing[0]; thing++, i++)
14266 {
14267 ctf_dump_state_t *s = NULL;
14268 char *item;
14269
14270 printf ("\n %s:\n", *thing);
14271 while ((item = ctf_dump (ctf, &s, i, dump_ctf_indent_lines,
14272 (void *) " ")) != NULL)
14273 {
14274 printf ("%s\n", item);
14275 free (item);
14276 }
14277
14278 if (ctf_errno (ctf))
14279 {
14280 error (_("Iteration failed: %s, %s\n"), *thing,
14281 ctf_errmsg (ctf_errno (ctf)));
14282 ret = FALSE;
14283 }
14284 }
14285
14286 fail:
14287 ctf_file_close (ctf);
14288 ctf_file_close (parent);
14289 free (parentdata);
14290 free (data);
14291 free (symdata);
14292 free (strdata);
14293 return ret;
14294}
14295
14296static bfd_boolean
14297load_specific_debug_section (enum dwarf_section_display_enum debug,
14298 const Elf_Internal_Shdr * sec,
14299 void * data)
14300{
14301 struct dwarf_section * section = &debug_displays [debug].section;
14302 char buf [64];
14303 Filedata * filedata = (Filedata *) data;
14304
14305 if (section->start != NULL)
14306 {
14307 /* If it is already loaded, do nothing. */
14308 if (streq (section->filename, filedata->file_name))
14309 return TRUE;
14310 free (section->start);
14311 }
14312
14313 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
14314 section->address = sec->sh_addr;
14315 section->user_data = NULL;
14316 section->filename = filedata->file_name;
14317 section->start = (unsigned char *) get_data (NULL, filedata,
14318 sec->sh_offset, 1,
14319 sec->sh_size, buf);
14320 if (section->start == NULL)
14321 section->size = 0;
14322 else
14323 {
14324 unsigned char *start = section->start;
14325 dwarf_size_type size = sec->sh_size;
14326 dwarf_size_type uncompressed_size = 0;
14327
14328 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
14329 {
14330 Elf_Internal_Chdr chdr;
14331 unsigned int compression_header_size;
14332
14333 if (size < (is_32bit_elf
14334 ? sizeof (Elf32_External_Chdr)
14335 : sizeof (Elf64_External_Chdr)))
14336 {
14337 warn (_("compressed section %s is too small to contain a compression header\n"),
14338 section->name);
14339 return FALSE;
14340 }
14341
14342 compression_header_size = get_compression_header (&chdr, start, size);
14343 if (compression_header_size == 0)
14344 /* An error message will have already been generated
14345 by get_compression_header. */
14346 return FALSE;
14347
14348 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
14349 {
14350 warn (_("section '%s' has unsupported compress type: %d\n"),
14351 section->name, chdr.ch_type);
14352 return FALSE;
14353 }
14354 uncompressed_size = chdr.ch_size;
14355 start += compression_header_size;
14356 size -= compression_header_size;
14357 }
14358 else if (size > 12 && streq ((char *) start, "ZLIB"))
14359 {
14360 /* Read the zlib header. In this case, it should be "ZLIB"
14361 followed by the uncompressed section size, 8 bytes in
14362 big-endian order. */
14363 uncompressed_size = start[4]; uncompressed_size <<= 8;
14364 uncompressed_size += start[5]; uncompressed_size <<= 8;
14365 uncompressed_size += start[6]; uncompressed_size <<= 8;
14366 uncompressed_size += start[7]; uncompressed_size <<= 8;
14367 uncompressed_size += start[8]; uncompressed_size <<= 8;
14368 uncompressed_size += start[9]; uncompressed_size <<= 8;
14369 uncompressed_size += start[10]; uncompressed_size <<= 8;
14370 uncompressed_size += start[11];
14371 start += 12;
14372 size -= 12;
14373 }
14374
14375 if (uncompressed_size)
14376 {
14377 if (uncompress_section_contents (&start, uncompressed_size,
14378 &size))
14379 {
14380 /* Free the compressed buffer, update the section buffer
14381 and the section size if uncompress is successful. */
14382 free (section->start);
14383 section->start = start;
14384 }
14385 else
14386 {
14387 error (_("Unable to decompress section %s\n"),
14388 printable_section_name (filedata, sec));
14389 return FALSE;
14390 }
14391 }
14392
14393 section->size = size;
14394 }
14395
14396 if (section->start == NULL)
14397 return FALSE;
14398
14399 if (debug_displays [debug].relocate)
14400 {
14401 if (! apply_relocations (filedata, sec, section->start, section->size,
14402 & section->reloc_info, & section->num_relocs))
14403 return FALSE;
14404 }
14405 else
14406 {
14407 section->reloc_info = NULL;
14408 section->num_relocs = 0;
14409 }
14410
14411 return TRUE;
14412}
14413
14414#if HAVE_LIBDEBUGINFOD
14415/* Return a hex string representation of the build-id. */
14416unsigned char *
14417get_build_id (void * data)
14418{
14419 Filedata * filedata = (Filedata *)data;
14420 Elf_Internal_Shdr * shdr;
14421 unsigned long i;
14422
14423 /* Iterate through notes to find note.gnu.build-id.
14424 FIXME: Only the first note in any note section is examined. */
14425 for (i = 0, shdr = filedata->section_headers;
14426 i < filedata->file_header.e_shnum && shdr != NULL;
14427 i++, shdr++)
14428 {
14429 if (shdr->sh_type != SHT_NOTE)
14430 continue;
14431
14432 char * next;
14433 char * end;
14434 size_t data_remaining;
14435 size_t min_notesz;
14436 Elf_External_Note * enote;
14437 Elf_Internal_Note inote;
14438
14439 bfd_vma offset = shdr->sh_offset;
14440 bfd_vma align = shdr->sh_addralign;
14441 bfd_vma length = shdr->sh_size;
14442
14443 enote = (Elf_External_Note *) get_section_contents (shdr, filedata);
14444 if (enote == NULL)
14445 continue;
14446
14447 if (align < 4)
14448 align = 4;
14449 else if (align != 4 && align != 8)
14450 {
14451 free (enote);
14452 continue;
14453 }
14454
14455 end = (char *) enote + length;
14456 data_remaining = end - (char *) enote;
14457
14458 if (!is_ia64_vms (filedata))
14459 {
14460 min_notesz = offsetof (Elf_External_Note, name);
14461 if (data_remaining < min_notesz)
14462 {
14463 warn (_("\
14464malformed note encountered in section %s whilst scanning for build-id note\n"),
14465 printable_section_name (filedata, shdr));
14466 free (enote);
14467 continue;
14468 }
14469 data_remaining -= min_notesz;
14470
14471 inote.type = BYTE_GET (enote->type);
14472 inote.namesz = BYTE_GET (enote->namesz);
14473 inote.namedata = enote->name;
14474 inote.descsz = BYTE_GET (enote->descsz);
14475 inote.descdata = ((char *) enote
14476 + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
14477 inote.descpos = offset + (inote.descdata - (char *) enote);
14478 next = ((char *) enote
14479 + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
14480 }
14481 else
14482 {
14483 Elf64_External_VMS_Note *vms_enote;
14484
14485 /* PR binutils/15191
14486 Make sure that there is enough data to read. */
14487 min_notesz = offsetof (Elf64_External_VMS_Note, name);
14488 if (data_remaining < min_notesz)
14489 {
14490 warn (_("\
14491malformed note encountered in section %s whilst scanning for build-id note\n"),
14492 printable_section_name (filedata, shdr));
14493 free (enote);
14494 continue;
14495 }
14496 data_remaining -= min_notesz;
14497
14498 vms_enote = (Elf64_External_VMS_Note *) enote;
14499 inote.type = BYTE_GET (vms_enote->type);
14500 inote.namesz = BYTE_GET (vms_enote->namesz);
14501 inote.namedata = vms_enote->name;
14502 inote.descsz = BYTE_GET (vms_enote->descsz);
14503 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
14504 inote.descpos = offset + (inote.descdata - (char *) enote);
14505 next = inote.descdata + align_power (inote.descsz, 3);
14506 }
14507
14508 /* Skip malformed notes. */
14509 if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
14510 || (size_t) (inote.descdata - inote.namedata) > data_remaining
14511 || (size_t) (next - inote.descdata) < inote.descsz
14512 || ((size_t) (next - inote.descdata)
14513 > data_remaining - (size_t) (inote.descdata - inote.namedata)))
14514 {
14515 warn (_("\
14516malformed note encountered in section %s whilst scanning for build-id note\n"),
14517 printable_section_name (filedata, shdr));
14518 free (enote);
14519 continue;
14520 }
14521
14522 /* Check if this is the build-id note. If so then convert the build-id
14523 bytes to a hex string. */
14524 if (inote.namesz > 0
14525 && const_strneq (inote.namedata, "GNU")
14526 && inote.type == NT_GNU_BUILD_ID)
14527 {
14528 unsigned long j;
14529 char * build_id;
14530
14531 build_id = malloc (inote.descsz * 2 + 1);
14532 if (build_id == NULL)
14533 {
14534 free (enote);
14535 return NULL;
14536 }
14537
14538 for (j = 0; j < inote.descsz; ++j)
14539 sprintf (build_id + (j * 2), "%02x", inote.descdata[j] & 0xff);
14540 build_id[inote.descsz * 2] = '\0';
14541 free (enote);
14542
14543 return (unsigned char *) build_id;
14544 }
14545 free (enote);
14546 }
14547
14548 return NULL;
14549}
14550#endif /* HAVE_LIBDEBUGINFOD */
14551
14552/* If this is not NULL, load_debug_section will only look for sections
14553 within the list of sections given here. */
14554static unsigned int * section_subset = NULL;
14555
14556bfd_boolean
14557load_debug_section (enum dwarf_section_display_enum debug, void * data)
14558{
14559 struct dwarf_section * section = &debug_displays [debug].section;
14560 Elf_Internal_Shdr * sec;
14561 Filedata * filedata = (Filedata *) data;
14562
14563 /* Without section headers we cannot find any sections. */
14564 if (filedata->section_headers == NULL)
14565 return FALSE;
14566
14567 if (filedata->string_table == NULL
14568 && filedata->file_header.e_shstrndx != SHN_UNDEF
14569 && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
14570 {
14571 Elf_Internal_Shdr * strs;
14572
14573 /* Read in the string table, so that we have section names to scan. */
14574 strs = filedata->section_headers + filedata->file_header.e_shstrndx;
14575
14576 if (strs != NULL && strs->sh_size != 0)
14577 {
14578 filedata->string_table
14579 = (char *) get_data (NULL, filedata, strs->sh_offset,
14580 1, strs->sh_size, _("string table"));
14581
14582 filedata->string_table_length
14583 = filedata->string_table != NULL ? strs->sh_size : 0;
14584 }
14585 }
14586
14587 /* Locate the debug section. */
14588 sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
14589 if (sec != NULL)
14590 section->name = section->uncompressed_name;
14591 else
14592 {
14593 sec = find_section_in_set (filedata, section->compressed_name, section_subset);
14594 if (sec != NULL)
14595 section->name = section->compressed_name;
14596 }
14597 if (sec == NULL)
14598 return FALSE;
14599
14600 /* If we're loading from a subset of sections, and we've loaded
14601 a section matching this name before, it's likely that it's a
14602 different one. */
14603 if (section_subset != NULL)
14604 free_debug_section (debug);
14605
14606 return load_specific_debug_section (debug, sec, data);
14607}
14608
14609void
14610free_debug_section (enum dwarf_section_display_enum debug)
14611{
14612 struct dwarf_section * section = &debug_displays [debug].section;
14613
14614 if (section->start == NULL)
14615 return;
14616
14617 free ((char *) section->start);
14618 section->start = NULL;
14619 section->address = 0;
14620 section->size = 0;
14621
14622 free (section->reloc_info);
14623 section->reloc_info = NULL;
14624 section->num_relocs = 0;
14625}
14626
14627static bfd_boolean
14628display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
14629{
14630 char * name = SECTION_NAME (section);
14631 const char * print_name = printable_section_name (filedata, section);
14632 bfd_size_type length;
14633 bfd_boolean result = TRUE;
14634 int i;
14635
14636 length = section->sh_size;
14637 if (length == 0)
14638 {
14639 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
14640 return TRUE;
14641 }
14642 if (section->sh_type == SHT_NOBITS)
14643 {
14644 /* There is no point in dumping the contents of a debugging section
14645 which has the NOBITS type - the bits in the file will be random.
14646 This can happen when a file containing a .eh_frame section is
14647 stripped with the --only-keep-debug command line option. */
14648 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14649 print_name);
14650 return FALSE;
14651 }
14652
14653 if (const_strneq (name, ".gnu.linkonce.wi."))
14654 name = ".debug_info";
14655
14656 /* See if we know how to display the contents of this section. */
14657 for (i = 0; i < max; i++)
14658 {
14659 enum dwarf_section_display_enum id = (enum dwarf_section_display_enum) i;
14660 struct dwarf_section_display * display = debug_displays + i;
14661 struct dwarf_section * sec = & display->section;
14662
14663 if (streq (sec->uncompressed_name, name)
14664 || (id == line && const_strneq (name, ".debug_line."))
14665 || streq (sec->compressed_name, name))
14666 {
14667 bfd_boolean secondary = (section != find_section (filedata, name));
14668
14669 if (secondary)
14670 free_debug_section (id);
14671
14672 if (i == line && const_strneq (name, ".debug_line."))
14673 sec->name = name;
14674 else if (streq (sec->uncompressed_name, name))
14675 sec->name = sec->uncompressed_name;
14676 else
14677 sec->name = sec->compressed_name;
14678
14679 if (load_specific_debug_section (id, section, filedata))
14680 {
14681 /* If this debug section is part of a CU/TU set in a .dwp file,
14682 restrict load_debug_section to the sections in that set. */
14683 section_subset = find_cu_tu_set (filedata, shndx);
14684
14685 result &= display->display (sec, filedata);
14686
14687 section_subset = NULL;
14688
14689 if (secondary || (id != info && id != abbrev))
14690 free_debug_section (id);
14691 }
14692 break;
14693 }
14694 }
14695
14696 if (i == max)
14697 {
14698 printf (_("Unrecognized debug section: %s\n"), print_name);
14699 result = FALSE;
14700 }
14701
14702 return result;
14703}
14704
14705/* Set DUMP_SECTS for all sections where dumps were requested
14706 based on section name. */
14707
14708static void
14709initialise_dumps_byname (Filedata * filedata)
14710{
14711 struct dump_list_entry * cur;
14712
14713 for (cur = dump_sects_byname; cur; cur = cur->next)
14714 {
14715 unsigned int i;
14716 bfd_boolean any = FALSE;
14717
14718 for (i = 0; i < filedata->file_header.e_shnum; i++)
14719 if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
14720 {
14721 request_dump_bynumber (&filedata->dump, i, cur->type);
14722 any = TRUE;
14723 }
14724
14725 if (!any)
14726 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14727 cur->name);
14728 }
14729}
14730
14731static bfd_boolean
14732process_section_contents (Filedata * filedata)
14733{
14734 Elf_Internal_Shdr * section;
14735 unsigned int i;
14736 bfd_boolean res = TRUE;
14737
14738 if (! do_dump)
14739 return TRUE;
14740
14741 initialise_dumps_byname (filedata);
14742
14743 for (i = 0, section = filedata->section_headers;
14744 i < filedata->file_header.e_shnum && i < filedata->dump.num_dump_sects;
14745 i++, section++)
14746 {
14747 dump_type dump = filedata->dump.dump_sects[i];
14748
14749#ifdef SUPPORT_DISASSEMBLY
14750 if (dump & DISASS_DUMP)
14751 {
14752 if (! disassemble_section (section, filedata))
14753 res = FALSE;
14754 }
14755#endif
14756 if (dump & HEX_DUMP)
14757 {
14758 if (! dump_section_as_bytes (section, filedata, FALSE))
14759 res = FALSE;
14760 }
14761
14762 if (dump & RELOC_DUMP)
14763 {
14764 if (! dump_section_as_bytes (section, filedata, TRUE))
14765 res = FALSE;
14766 }
14767
14768 if (dump & STRING_DUMP)
14769 {
14770 if (! dump_section_as_strings (section, filedata))
14771 res = FALSE;
14772 }
14773
14774 if (dump & DEBUG_DUMP)
14775 {
14776 if (! display_debug_section (i, section, filedata))
14777 res = FALSE;
14778 }
14779
14780 if (dump & CTF_DUMP)
14781 {
14782 if (! dump_section_as_ctf (section, filedata))
14783 res = FALSE;
14784 }
14785 }
14786
14787 /* Check to see if the user requested a
14788 dump of a section that does not exist. */
14789 while (i < filedata->dump.num_dump_sects)
14790 {
14791 if (filedata->dump.dump_sects[i])
14792 {
14793 warn (_("Section %d was not dumped because it does not exist!\n"), i);
14794 res = FALSE;
14795 }
14796 i++;
14797 }
14798
14799 return res;
14800}
14801
14802static void
14803process_mips_fpe_exception (int mask)
14804{
14805 if (mask)
14806 {
14807 bfd_boolean first = TRUE;
14808
14809 if (mask & OEX_FPU_INEX)
14810 fputs ("INEX", stdout), first = FALSE;
14811 if (mask & OEX_FPU_UFLO)
14812 printf ("%sUFLO", first ? "" : "|"), first = FALSE;
14813 if (mask & OEX_FPU_OFLO)
14814 printf ("%sOFLO", first ? "" : "|"), first = FALSE;
14815 if (mask & OEX_FPU_DIV0)
14816 printf ("%sDIV0", first ? "" : "|"), first = FALSE;
14817 if (mask & OEX_FPU_INVAL)
14818 printf ("%sINVAL", first ? "" : "|");
14819 }
14820 else
14821 fputs ("0", stdout);
14822}
14823
14824/* Display's the value of TAG at location P. If TAG is
14825 greater than 0 it is assumed to be an unknown tag, and
14826 a message is printed to this effect. Otherwise it is
14827 assumed that a message has already been printed.
14828
14829 If the bottom bit of TAG is set it assumed to have a
14830 string value, otherwise it is assumed to have an integer
14831 value.
14832
14833 Returns an updated P pointing to the first unread byte
14834 beyond the end of TAG's value.
14835
14836 Reads at or beyond END will not be made. */
14837
14838static unsigned char *
14839display_tag_value (signed int tag,
14840 unsigned char * p,
14841 const unsigned char * const end)
14842{
14843 unsigned long val;
14844
14845 if (tag > 0)
14846 printf (" Tag_unknown_%d: ", tag);
14847
14848 if (p >= end)
14849 {
14850 warn (_("<corrupt tag>\n"));
14851 }
14852 else if (tag & 1)
14853 {
14854 /* PR 17531 file: 027-19978-0.004. */
14855 size_t maxlen = (end - p) - 1;
14856
14857 putchar ('"');
14858 if (maxlen > 0)
14859 {
14860 print_symbol ((int) maxlen, (const char *) p);
14861 p += strnlen ((char *) p, maxlen) + 1;
14862 }
14863 else
14864 {
14865 printf (_("<corrupt string tag>"));
14866 p = (unsigned char *) end;
14867 }
14868 printf ("\"\n");
14869 }
14870 else
14871 {
14872 READ_ULEB (val, p, end);
14873 printf ("%ld (0x%lx)\n", val, val);
14874 }
14875
14876 assert (p <= end);
14877 return p;
14878}
14879
14880/* ARC ABI attributes section. */
14881
14882static unsigned char *
14883display_arc_attribute (unsigned char * p,
14884 const unsigned char * const end)
14885{
14886 unsigned int tag;
14887 unsigned int val;
14888
14889 READ_ULEB (tag, p, end);
14890
14891 switch (tag)
14892 {
14893 case Tag_ARC_PCS_config:
14894 READ_ULEB (val, p, end);
14895 printf (" Tag_ARC_PCS_config: ");
14896 switch (val)
14897 {
14898 case 0:
14899 printf (_("Absent/Non standard\n"));
14900 break;
14901 case 1:
14902 printf (_("Bare metal/mwdt\n"));
14903 break;
14904 case 2:
14905 printf (_("Bare metal/newlib\n"));
14906 break;
14907 case 3:
14908 printf (_("Linux/uclibc\n"));
14909 break;
14910 case 4:
14911 printf (_("Linux/glibc\n"));
14912 break;
14913 default:
14914 printf (_("Unknown\n"));
14915 break;
14916 }
14917 break;
14918
14919 case Tag_ARC_CPU_base:
14920 READ_ULEB (val, p, end);
14921 printf (" Tag_ARC_CPU_base: ");
14922 switch (val)
14923 {
14924 default:
14925 case TAG_CPU_NONE:
14926 printf (_("Absent\n"));
14927 break;
14928 case TAG_CPU_ARC6xx:
14929 printf ("ARC6xx\n");
14930 break;
14931 case TAG_CPU_ARC7xx:
14932 printf ("ARC7xx\n");
14933 break;
14934 case TAG_CPU_ARCEM:
14935 printf ("ARCEM\n");
14936 break;
14937 case TAG_CPU_ARCHS:
14938 printf ("ARCHS\n");
14939 break;
14940 }
14941 break;
14942
14943 case Tag_ARC_CPU_variation:
14944 READ_ULEB (val, p, end);
14945 printf (" Tag_ARC_CPU_variation: ");
14946 switch (val)
14947 {
14948 default:
14949 if (val > 0 && val < 16)
14950 printf ("Core%d\n", val);
14951 else
14952 printf ("Unknown\n");
14953 break;
14954
14955 case 0:
14956 printf (_("Absent\n"));
14957 break;
14958 }
14959 break;
14960
14961 case Tag_ARC_CPU_name:
14962 printf (" Tag_ARC_CPU_name: ");
14963 p = display_tag_value (-1, p, end);
14964 break;
14965
14966 case Tag_ARC_ABI_rf16:
14967 READ_ULEB (val, p, end);
14968 printf (" Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
14969 break;
14970
14971 case Tag_ARC_ABI_osver:
14972 READ_ULEB (val, p, end);
14973 printf (" Tag_ARC_ABI_osver: v%d\n", val);
14974 break;
14975
14976 case Tag_ARC_ABI_pic:
14977 case Tag_ARC_ABI_sda:
14978 READ_ULEB (val, p, end);
14979 printf (tag == Tag_ARC_ABI_sda ? " Tag_ARC_ABI_sda: "
14980 : " Tag_ARC_ABI_pic: ");
14981 switch (val)
14982 {
14983 case 0:
14984 printf (_("Absent\n"));
14985 break;
14986 case 1:
14987 printf ("MWDT\n");
14988 break;
14989 case 2:
14990 printf ("GNU\n");
14991 break;
14992 default:
14993 printf (_("Unknown\n"));
14994 break;
14995 }
14996 break;
14997
14998 case Tag_ARC_ABI_tls:
14999 READ_ULEB (val, p, end);
15000 printf (" Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
15001 break;
15002
15003 case Tag_ARC_ABI_enumsize:
15004 READ_ULEB (val, p, end);
15005 printf (" Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
15006 _("smallest"));
15007 break;
15008
15009 case Tag_ARC_ABI_exceptions:
15010 READ_ULEB (val, p, end);
15011 printf (" Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
15012 : _("default"));
15013 break;
15014
15015 case Tag_ARC_ABI_double_size:
15016 READ_ULEB (val, p, end);
15017 printf (" Tag_ARC_ABI_double_size: %d\n", val);
15018 break;
15019
15020 case Tag_ARC_ISA_config:
15021 printf (" Tag_ARC_ISA_config: ");
15022 p = display_tag_value (-1, p, end);
15023 break;
15024
15025 case Tag_ARC_ISA_apex:
15026 printf (" Tag_ARC_ISA_apex: ");
15027 p = display_tag_value (-1, p, end);
15028 break;
15029
15030 case Tag_ARC_ISA_mpy_option:
15031 READ_ULEB (val, p, end);
15032 printf (" Tag_ARC_ISA_mpy_option: %d\n", val);
15033 break;
15034
15035 case Tag_ARC_ATR_version:
15036 READ_ULEB (val, p, end);
15037 printf (" Tag_ARC_ATR_version: %d\n", val);
15038 break;
15039
15040 default:
15041 return display_tag_value (tag & 1, p, end);
15042 }
15043
15044 return p;
15045}
15046
15047/* ARM EABI attributes section. */
15048typedef struct
15049{
15050 unsigned int tag;
15051 const char * name;
15052 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
15053 unsigned int type;
15054 const char ** table;
15055} arm_attr_public_tag;
15056
15057static const char * arm_attr_tag_CPU_arch[] =
15058 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
15059 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
15060 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
15061static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
15062static const char * arm_attr_tag_THUMB_ISA_use[] =
15063 {"No", "Thumb-1", "Thumb-2", "Yes"};
15064static const char * arm_attr_tag_FP_arch[] =
15065 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
15066 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
15067static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
15068static const char * arm_attr_tag_Advanced_SIMD_arch[] =
15069 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
15070 "NEON for ARMv8.1"};
15071static const char * arm_attr_tag_PCS_config[] =
15072 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
15073 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
15074static const char * arm_attr_tag_ABI_PCS_R9_use[] =
15075 {"V6", "SB", "TLS", "Unused"};
15076static const char * arm_attr_tag_ABI_PCS_RW_data[] =
15077 {"Absolute", "PC-relative", "SB-relative", "None"};
15078static const char * arm_attr_tag_ABI_PCS_RO_data[] =
15079 {"Absolute", "PC-relative", "None"};
15080static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
15081 {"None", "direct", "GOT-indirect"};
15082static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
15083 {"None", "??? 1", "2", "??? 3", "4"};
15084static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
15085static const char * arm_attr_tag_ABI_FP_denormal[] =
15086 {"Unused", "Needed", "Sign only"};
15087static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
15088static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
15089static const char * arm_attr_tag_ABI_FP_number_model[] =
15090 {"Unused", "Finite", "RTABI", "IEEE 754"};
15091static const char * arm_attr_tag_ABI_enum_size[] =
15092 {"Unused", "small", "int", "forced to int"};
15093static const char * arm_attr_tag_ABI_HardFP_use[] =
15094 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
15095static const char * arm_attr_tag_ABI_VFP_args[] =
15096 {"AAPCS", "VFP registers", "custom", "compatible"};
15097static const char * arm_attr_tag_ABI_WMMX_args[] =
15098 {"AAPCS", "WMMX registers", "custom"};
15099static const char * arm_attr_tag_ABI_optimization_goals[] =
15100 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15101 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
15102static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
15103 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15104 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
15105static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
15106static const char * arm_attr_tag_FP_HP_extension[] =
15107 {"Not Allowed", "Allowed"};
15108static const char * arm_attr_tag_ABI_FP_16bit_format[] =
15109 {"None", "IEEE 754", "Alternative Format"};
15110static const char * arm_attr_tag_DSP_extension[] =
15111 {"Follow architecture", "Allowed"};
15112static const char * arm_attr_tag_MPextension_use[] =
15113 {"Not Allowed", "Allowed"};
15114static const char * arm_attr_tag_DIV_use[] =
15115 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
15116 "Allowed in v7-A with integer division extension"};
15117static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
15118static const char * arm_attr_tag_Virtualization_use[] =
15119 {"Not Allowed", "TrustZone", "Virtualization Extensions",
15120 "TrustZone and Virtualization Extensions"};
15121static const char * arm_attr_tag_MPextension_use_legacy[] =
15122 {"Not Allowed", "Allowed"};
15123
15124static const char * arm_attr_tag_MVE_arch[] =
15125 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
15126
15127#define LOOKUP(id, name) \
15128 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
15129static arm_attr_public_tag arm_attr_public_tags[] =
15130{
15131 {4, "CPU_raw_name", 1, NULL},
15132 {5, "CPU_name", 1, NULL},
15133 LOOKUP(6, CPU_arch),
15134 {7, "CPU_arch_profile", 0, NULL},
15135 LOOKUP(8, ARM_ISA_use),
15136 LOOKUP(9, THUMB_ISA_use),
15137 LOOKUP(10, FP_arch),
15138 LOOKUP(11, WMMX_arch),
15139 LOOKUP(12, Advanced_SIMD_arch),
15140 LOOKUP(13, PCS_config),
15141 LOOKUP(14, ABI_PCS_R9_use),
15142 LOOKUP(15, ABI_PCS_RW_data),
15143 LOOKUP(16, ABI_PCS_RO_data),
15144 LOOKUP(17, ABI_PCS_GOT_use),
15145 LOOKUP(18, ABI_PCS_wchar_t),
15146 LOOKUP(19, ABI_FP_rounding),
15147 LOOKUP(20, ABI_FP_denormal),
15148 LOOKUP(21, ABI_FP_exceptions),
15149 LOOKUP(22, ABI_FP_user_exceptions),
15150 LOOKUP(23, ABI_FP_number_model),
15151 {24, "ABI_align_needed", 0, NULL},
15152 {25, "ABI_align_preserved", 0, NULL},
15153 LOOKUP(26, ABI_enum_size),
15154 LOOKUP(27, ABI_HardFP_use),
15155 LOOKUP(28, ABI_VFP_args),
15156 LOOKUP(29, ABI_WMMX_args),
15157 LOOKUP(30, ABI_optimization_goals),
15158 LOOKUP(31, ABI_FP_optimization_goals),
15159 {32, "compatibility", 0, NULL},
15160 LOOKUP(34, CPU_unaligned_access),
15161 LOOKUP(36, FP_HP_extension),
15162 LOOKUP(38, ABI_FP_16bit_format),
15163 LOOKUP(42, MPextension_use),
15164 LOOKUP(44, DIV_use),
15165 LOOKUP(46, DSP_extension),
15166 LOOKUP(48, MVE_arch),
15167 {64, "nodefaults", 0, NULL},
15168 {65, "also_compatible_with", 0, NULL},
15169 LOOKUP(66, T2EE_use),
15170 {67, "conformance", 1, NULL},
15171 LOOKUP(68, Virtualization_use),
15172 LOOKUP(70, MPextension_use_legacy)
15173};
15174#undef LOOKUP
15175
15176static unsigned char *
15177display_arm_attribute (unsigned char * p,
15178 const unsigned char * const end)
15179{
15180 unsigned int tag;
15181 unsigned int val;
15182 arm_attr_public_tag * attr;
15183 unsigned i;
15184 unsigned int type;
15185
15186 READ_ULEB (tag, p, end);
15187 attr = NULL;
15188 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
15189 {
15190 if (arm_attr_public_tags[i].tag == tag)
15191 {
15192 attr = &arm_attr_public_tags[i];
15193 break;
15194 }
15195 }
15196
15197 if (attr)
15198 {
15199 printf (" Tag_%s: ", attr->name);
15200 switch (attr->type)
15201 {
15202 case 0:
15203 switch (tag)
15204 {
15205 case 7: /* Tag_CPU_arch_profile. */
15206 READ_ULEB (val, p, end);
15207 switch (val)
15208 {
15209 case 0: printf (_("None\n")); break;
15210 case 'A': printf (_("Application\n")); break;
15211 case 'R': printf (_("Realtime\n")); break;
15212 case 'M': printf (_("Microcontroller\n")); break;
15213 case 'S': printf (_("Application or Realtime\n")); break;
15214 default: printf ("??? (%d)\n", val); break;
15215 }
15216 break;
15217
15218 case 24: /* Tag_align_needed. */
15219 READ_ULEB (val, p, end);
15220 switch (val)
15221 {
15222 case 0: printf (_("None\n")); break;
15223 case 1: printf (_("8-byte\n")); break;
15224 case 2: printf (_("4-byte\n")); break;
15225 case 3: printf ("??? 3\n"); break;
15226 default:
15227 if (val <= 12)
15228 printf (_("8-byte and up to %d-byte extended\n"),
15229 1 << val);
15230 else
15231 printf ("??? (%d)\n", val);
15232 break;
15233 }
15234 break;
15235
15236 case 25: /* Tag_align_preserved. */
15237 READ_ULEB (val, p, end);
15238 switch (val)
15239 {
15240 case 0: printf (_("None\n")); break;
15241 case 1: printf (_("8-byte, except leaf SP\n")); break;
15242 case 2: printf (_("8-byte\n")); break;
15243 case 3: printf ("??? 3\n"); break;
15244 default:
15245 if (val <= 12)
15246 printf (_("8-byte and up to %d-byte extended\n"),
15247 1 << val);
15248 else
15249 printf ("??? (%d)\n", val);
15250 break;
15251 }
15252 break;
15253
15254 case 32: /* Tag_compatibility. */
15255 {
15256 READ_ULEB (val, p, end);
15257 printf (_("flag = %d, vendor = "), val);
15258 if (p < end - 1)
15259 {
15260 size_t maxlen = (end - p) - 1;
15261
15262 print_symbol ((int) maxlen, (const char *) p);
15263 p += strnlen ((char *) p, maxlen) + 1;
15264 }
15265 else
15266 {
15267 printf (_("<corrupt>"));
15268 p = (unsigned char *) end;
15269 }
15270 putchar ('\n');
15271 }
15272 break;
15273
15274 case 64: /* Tag_nodefaults. */
15275 /* PR 17531: file: 001-505008-0.01. */
15276 if (p < end)
15277 p++;
15278 printf (_("True\n"));
15279 break;
15280
15281 case 65: /* Tag_also_compatible_with. */
15282 READ_ULEB (val, p, end);
15283 if (val == 6 /* Tag_CPU_arch. */)
15284 {
15285 READ_ULEB (val, p, end);
15286 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
15287 printf ("??? (%d)\n", val);
15288 else
15289 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
15290 }
15291 else
15292 printf ("???\n");
15293 while (p < end && *(p++) != '\0' /* NUL terminator. */)
15294 ;
15295 break;
15296
15297 default:
15298 printf (_("<unknown: %d>\n"), tag);
15299 break;
15300 }
15301 return p;
15302
15303 case 1:
15304 return display_tag_value (-1, p, end);
15305 case 2:
15306 return display_tag_value (0, p, end);
15307
15308 default:
15309 assert (attr->type & 0x80);
15310 READ_ULEB (val, p, end);
15311 type = attr->type & 0x7f;
15312 if (val >= type)
15313 printf ("??? (%d)\n", val);
15314 else
15315 printf ("%s\n", attr->table[val]);
15316 return p;
15317 }
15318 }
15319
15320 return display_tag_value (tag, p, end);
15321}
15322
15323static unsigned char *
15324display_gnu_attribute (unsigned char * p,
15325 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
15326 const unsigned char * const end)
15327{
15328 unsigned int tag;
15329 unsigned int val;
15330
15331 READ_ULEB (tag, p, end);
15332
15333 /* Tag_compatibility is the only generic GNU attribute defined at
15334 present. */
15335 if (tag == 32)
15336 {
15337 READ_ULEB (val, p, end);
15338
15339 printf (_("flag = %d, vendor = "), val);
15340 if (p == end)
15341 {
15342 printf (_("<corrupt>\n"));
15343 warn (_("corrupt vendor attribute\n"));
15344 }
15345 else
15346 {
15347 if (p < end - 1)
15348 {
15349 size_t maxlen = (end - p) - 1;
15350
15351 print_symbol ((int) maxlen, (const char *) p);
15352 p += strnlen ((char *) p, maxlen) + 1;
15353 }
15354 else
15355 {
15356 printf (_("<corrupt>"));
15357 p = (unsigned char *) end;
15358 }
15359 putchar ('\n');
15360 }
15361 return p;
15362 }
15363
15364 if ((tag & 2) == 0 && display_proc_gnu_attribute)
15365 return display_proc_gnu_attribute (p, tag, end);
15366
15367 return display_tag_value (tag, p, end);
15368}
15369
15370static unsigned char *
15371display_power_gnu_attribute (unsigned char * p,
15372 unsigned int tag,
15373 const unsigned char * const end)
15374{
15375 unsigned int val;
15376
15377 if (tag == Tag_GNU_Power_ABI_FP)
15378 {
15379 printf (" Tag_GNU_Power_ABI_FP: ");
15380 if (p == end)
15381 {
15382 printf (_("<corrupt>\n"));
15383 return p;
15384 }
15385 READ_ULEB (val, p, end);
15386
15387 if (val > 15)
15388 printf ("(%#x), ", val);
15389
15390 switch (val & 3)
15391 {
15392 case 0:
15393 printf (_("unspecified hard/soft float, "));
15394 break;
15395 case 1:
15396 printf (_("hard float, "));
15397 break;
15398 case 2:
15399 printf (_("soft float, "));
15400 break;
15401 case 3:
15402 printf (_("single-precision hard float, "));
15403 break;
15404 }
15405
15406 switch (val & 0xC)
15407 {
15408 case 0:
15409 printf (_("unspecified long double\n"));
15410 break;
15411 case 4:
15412 printf (_("128-bit IBM long double\n"));
15413 break;
15414 case 8:
15415 printf (_("64-bit long double\n"));
15416 break;
15417 case 12:
15418 printf (_("128-bit IEEE long double\n"));
15419 break;
15420 }
15421 return p;
15422 }
15423
15424 if (tag == Tag_GNU_Power_ABI_Vector)
15425 {
15426 printf (" Tag_GNU_Power_ABI_Vector: ");
15427 if (p == end)
15428 {
15429 printf (_("<corrupt>\n"));
15430 return p;
15431 }
15432 READ_ULEB (val, p, end);
15433
15434 if (val > 3)
15435 printf ("(%#x), ", val);
15436
15437 switch (val & 3)
15438 {
15439 case 0:
15440 printf (_("unspecified\n"));
15441 break;
15442 case 1:
15443 printf (_("generic\n"));
15444 break;
15445 case 2:
15446 printf ("AltiVec\n");
15447 break;
15448 case 3:
15449 printf ("SPE\n");
15450 break;
15451 }
15452 return p;
15453 }
15454
15455 if (tag == Tag_GNU_Power_ABI_Struct_Return)
15456 {
15457 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15458 if (p == end)
15459 {
15460 printf (_("<corrupt>\n"));
15461 return p;
15462 }
15463 READ_ULEB (val, p, end);
15464
15465 if (val > 2)
15466 printf ("(%#x), ", val);
15467
15468 switch (val & 3)
15469 {
15470 case 0:
15471 printf (_("unspecified\n"));
15472 break;
15473 case 1:
15474 printf ("r3/r4\n");
15475 break;
15476 case 2:
15477 printf (_("memory\n"));
15478 break;
15479 case 3:
15480 printf ("???\n");
15481 break;
15482 }
15483 return p;
15484 }
15485
15486 return display_tag_value (tag & 1, p, end);
15487}
15488
15489static unsigned char *
15490display_s390_gnu_attribute (unsigned char * p,
15491 unsigned int tag,
15492 const unsigned char * const end)
15493{
15494 unsigned int val;
15495
15496 if (tag == Tag_GNU_S390_ABI_Vector)
15497 {
15498 printf (" Tag_GNU_S390_ABI_Vector: ");
15499 READ_ULEB (val, p, end);
15500
15501 switch (val)
15502 {
15503 case 0:
15504 printf (_("any\n"));
15505 break;
15506 case 1:
15507 printf (_("software\n"));
15508 break;
15509 case 2:
15510 printf (_("hardware\n"));
15511 break;
15512 default:
15513 printf ("??? (%d)\n", val);
15514 break;
15515 }
15516 return p;
15517 }
15518
15519 return display_tag_value (tag & 1, p, end);
15520}
15521
15522static void
15523display_sparc_hwcaps (unsigned int mask)
15524{
15525 if (mask)
15526 {
15527 bfd_boolean first = TRUE;
15528
15529 if (mask & ELF_SPARC_HWCAP_MUL32)
15530 fputs ("mul32", stdout), first = FALSE;
15531 if (mask & ELF_SPARC_HWCAP_DIV32)
15532 printf ("%sdiv32", first ? "" : "|"), first = FALSE;
15533 if (mask & ELF_SPARC_HWCAP_FSMULD)
15534 printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
15535 if (mask & ELF_SPARC_HWCAP_V8PLUS)
15536 printf ("%sv8plus", first ? "" : "|"), first = FALSE;
15537 if (mask & ELF_SPARC_HWCAP_POPC)
15538 printf ("%spopc", first ? "" : "|"), first = FALSE;
15539 if (mask & ELF_SPARC_HWCAP_VIS)
15540 printf ("%svis", first ? "" : "|"), first = FALSE;
15541 if (mask & ELF_SPARC_HWCAP_VIS2)
15542 printf ("%svis2", first ? "" : "|"), first = FALSE;
15543 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
15544 printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
15545 if (mask & ELF_SPARC_HWCAP_FMAF)
15546 printf ("%sfmaf", first ? "" : "|"), first = FALSE;
15547 if (mask & ELF_SPARC_HWCAP_VIS3)
15548 printf ("%svis3", first ? "" : "|"), first = FALSE;
15549 if (mask & ELF_SPARC_HWCAP_HPC)
15550 printf ("%shpc", first ? "" : "|"), first = FALSE;
15551 if (mask & ELF_SPARC_HWCAP_RANDOM)
15552 printf ("%srandom", first ? "" : "|"), first = FALSE;
15553 if (mask & ELF_SPARC_HWCAP_TRANS)
15554 printf ("%strans", first ? "" : "|"), first = FALSE;
15555 if (mask & ELF_SPARC_HWCAP_FJFMAU)
15556 printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
15557 if (mask & ELF_SPARC_HWCAP_IMA)
15558 printf ("%sima", first ? "" : "|"), first = FALSE;
15559 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
15560 printf ("%scspare", first ? "" : "|"), first = FALSE;
15561 }
15562 else
15563 fputc ('0', stdout);
15564 fputc ('\n', stdout);
15565}
15566
15567static void
15568display_sparc_hwcaps2 (unsigned int mask)
15569{
15570 if (mask)
15571 {
15572 bfd_boolean first = TRUE;
15573
15574 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
15575 fputs ("fjathplus", stdout), first = FALSE;
15576 if (mask & ELF_SPARC_HWCAP2_VIS3B)
15577 printf ("%svis3b", first ? "" : "|"), first = FALSE;
15578 if (mask & ELF_SPARC_HWCAP2_ADP)
15579 printf ("%sadp", first ? "" : "|"), first = FALSE;
15580 if (mask & ELF_SPARC_HWCAP2_SPARC5)
15581 printf ("%ssparc5", first ? "" : "|"), first = FALSE;
15582 if (mask & ELF_SPARC_HWCAP2_MWAIT)
15583 printf ("%smwait", first ? "" : "|"), first = FALSE;
15584 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
15585 printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
15586 if (mask & ELF_SPARC_HWCAP2_XMONT)
15587 printf ("%sxmont2", first ? "" : "|"), first = FALSE;
15588 if (mask & ELF_SPARC_HWCAP2_NSEC)
15589 printf ("%snsec", first ? "" : "|"), first = FALSE;
15590 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
15591 printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
15592 if (mask & ELF_SPARC_HWCAP2_FJDES)
15593 printf ("%sfjdes", first ? "" : "|"), first = FALSE;
15594 if (mask & ELF_SPARC_HWCAP2_FJAES)
15595 printf ("%sfjaes", first ? "" : "|"), first = FALSE;
15596 }
15597 else
15598 fputc ('0', stdout);
15599 fputc ('\n', stdout);
15600}
15601
15602static unsigned char *
15603display_sparc_gnu_attribute (unsigned char * p,
15604 unsigned int tag,
15605 const unsigned char * const end)
15606{
15607 unsigned int val;
15608
15609 if (tag == Tag_GNU_Sparc_HWCAPS)
15610 {
15611 READ_ULEB (val, p, end);
15612 printf (" Tag_GNU_Sparc_HWCAPS: ");
15613 display_sparc_hwcaps (val);
15614 return p;
15615 }
15616 if (tag == Tag_GNU_Sparc_HWCAPS2)
15617 {
15618 READ_ULEB (val, p, end);
15619 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15620 display_sparc_hwcaps2 (val);
15621 return p;
15622 }
15623
15624 return display_tag_value (tag, p, end);
15625}
15626
15627static void
15628print_mips_fp_abi_value (unsigned int val)
15629{
15630 switch (val)
15631 {
15632 case Val_GNU_MIPS_ABI_FP_ANY:
15633 printf (_("Hard or soft float\n"));
15634 break;
15635 case Val_GNU_MIPS_ABI_FP_DOUBLE:
15636 printf (_("Hard float (double precision)\n"));
15637 break;
15638 case Val_GNU_MIPS_ABI_FP_SINGLE:
15639 printf (_("Hard float (single precision)\n"));
15640 break;
15641 case Val_GNU_MIPS_ABI_FP_SOFT:
15642 printf (_("Soft float\n"));
15643 break;
15644 case Val_GNU_MIPS_ABI_FP_OLD_64:
15645 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15646 break;
15647 case Val_GNU_MIPS_ABI_FP_XX:
15648 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15649 break;
15650 case Val_GNU_MIPS_ABI_FP_64:
15651 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15652 break;
15653 case Val_GNU_MIPS_ABI_FP_64A:
15654 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15655 break;
15656 case Val_GNU_MIPS_ABI_FP_NAN2008:
15657 printf (_("NaN 2008 compatibility\n"));
15658 break;
15659 default:
15660 printf ("??? (%d)\n", val);
15661 break;
15662 }
15663}
15664
15665static unsigned char *
15666display_mips_gnu_attribute (unsigned char * p,
15667 unsigned int tag,
15668 const unsigned char * const end)
15669{
15670 if (tag == Tag_GNU_MIPS_ABI_FP)
15671 {
15672 unsigned int val;
15673
15674 printf (" Tag_GNU_MIPS_ABI_FP: ");
15675 READ_ULEB (val, p, end);
15676 print_mips_fp_abi_value (val);
15677 return p;
15678 }
15679
15680 if (tag == Tag_GNU_MIPS_ABI_MSA)
15681 {
15682 unsigned int val;
15683
15684 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15685 READ_ULEB (val, p, end);
15686
15687 switch (val)
15688 {
15689 case Val_GNU_MIPS_ABI_MSA_ANY:
15690 printf (_("Any MSA or not\n"));
15691 break;
15692 case Val_GNU_MIPS_ABI_MSA_128:
15693 printf (_("128-bit MSA\n"));
15694 break;
15695 default:
15696 printf ("??? (%d)\n", val);
15697 break;
15698 }
15699 return p;
15700 }
15701
15702 return display_tag_value (tag & 1, p, end);
15703}
15704
15705static unsigned char *
15706display_tic6x_attribute (unsigned char * p,
15707 const unsigned char * const end)
15708{
15709 unsigned int tag;
15710 unsigned int val;
15711
15712 READ_ULEB (tag, p, end);
15713
15714 switch (tag)
15715 {
15716 case Tag_ISA:
15717 printf (" Tag_ISA: ");
15718 READ_ULEB (val, p, end);
15719
15720 switch (val)
15721 {
15722 case C6XABI_Tag_ISA_none:
15723 printf (_("None\n"));
15724 break;
15725 case C6XABI_Tag_ISA_C62X:
15726 printf ("C62x\n");
15727 break;
15728 case C6XABI_Tag_ISA_C67X:
15729 printf ("C67x\n");
15730 break;
15731 case C6XABI_Tag_ISA_C67XP:
15732 printf ("C67x+\n");
15733 break;
15734 case C6XABI_Tag_ISA_C64X:
15735 printf ("C64x\n");
15736 break;
15737 case C6XABI_Tag_ISA_C64XP:
15738 printf ("C64x+\n");
15739 break;
15740 case C6XABI_Tag_ISA_C674X:
15741 printf ("C674x\n");
15742 break;
15743 default:
15744 printf ("??? (%d)\n", val);
15745 break;
15746 }
15747 return p;
15748
15749 case Tag_ABI_wchar_t:
15750 printf (" Tag_ABI_wchar_t: ");
15751 READ_ULEB (val, p, end);
15752 switch (val)
15753 {
15754 case 0:
15755 printf (_("Not used\n"));
15756 break;
15757 case 1:
15758 printf (_("2 bytes\n"));
15759 break;
15760 case 2:
15761 printf (_("4 bytes\n"));
15762 break;
15763 default:
15764 printf ("??? (%d)\n", val);
15765 break;
15766 }
15767 return p;
15768
15769 case Tag_ABI_stack_align_needed:
15770 printf (" Tag_ABI_stack_align_needed: ");
15771 READ_ULEB (val, p, end);
15772 switch (val)
15773 {
15774 case 0:
15775 printf (_("8-byte\n"));
15776 break;
15777 case 1:
15778 printf (_("16-byte\n"));
15779 break;
15780 default:
15781 printf ("??? (%d)\n", val);
15782 break;
15783 }
15784 return p;
15785
15786 case Tag_ABI_stack_align_preserved:
15787 READ_ULEB (val, p, end);
15788 printf (" Tag_ABI_stack_align_preserved: ");
15789 switch (val)
15790 {
15791 case 0:
15792 printf (_("8-byte\n"));
15793 break;
15794 case 1:
15795 printf (_("16-byte\n"));
15796 break;
15797 default:
15798 printf ("??? (%d)\n", val);
15799 break;
15800 }
15801 return p;
15802
15803 case Tag_ABI_DSBT:
15804 READ_ULEB (val, p, end);
15805 printf (" Tag_ABI_DSBT: ");
15806 switch (val)
15807 {
15808 case 0:
15809 printf (_("DSBT addressing not used\n"));
15810 break;
15811 case 1:
15812 printf (_("DSBT addressing used\n"));
15813 break;
15814 default:
15815 printf ("??? (%d)\n", val);
15816 break;
15817 }
15818 return p;
15819
15820 case Tag_ABI_PID:
15821 READ_ULEB (val, p, end);
15822 printf (" Tag_ABI_PID: ");
15823 switch (val)
15824 {
15825 case 0:
15826 printf (_("Data addressing position-dependent\n"));
15827 break;
15828 case 1:
15829 printf (_("Data addressing position-independent, GOT near DP\n"));
15830 break;
15831 case 2:
15832 printf (_("Data addressing position-independent, GOT far from DP\n"));
15833 break;
15834 default:
15835 printf ("??? (%d)\n", val);
15836 break;
15837 }
15838 return p;
15839
15840 case Tag_ABI_PIC:
15841 READ_ULEB (val, p, end);
15842 printf (" Tag_ABI_PIC: ");
15843 switch (val)
15844 {
15845 case 0:
15846 printf (_("Code addressing position-dependent\n"));
15847 break;
15848 case 1:
15849 printf (_("Code addressing position-independent\n"));
15850 break;
15851 default:
15852 printf ("??? (%d)\n", val);
15853 break;
15854 }
15855 return p;
15856
15857 case Tag_ABI_array_object_alignment:
15858 READ_ULEB (val, p, end);
15859 printf (" Tag_ABI_array_object_alignment: ");
15860 switch (val)
15861 {
15862 case 0:
15863 printf (_("8-byte\n"));
15864 break;
15865 case 1:
15866 printf (_("4-byte\n"));
15867 break;
15868 case 2:
15869 printf (_("16-byte\n"));
15870 break;
15871 default:
15872 printf ("??? (%d)\n", val);
15873 break;
15874 }
15875 return p;
15876
15877 case Tag_ABI_array_object_align_expected:
15878 READ_ULEB (val, p, end);
15879 printf (" Tag_ABI_array_object_align_expected: ");
15880 switch (val)
15881 {
15882 case 0:
15883 printf (_("8-byte\n"));
15884 break;
15885 case 1:
15886 printf (_("4-byte\n"));
15887 break;
15888 case 2:
15889 printf (_("16-byte\n"));
15890 break;
15891 default:
15892 printf ("??? (%d)\n", val);
15893 break;
15894 }
15895 return p;
15896
15897 case Tag_ABI_compatibility:
15898 {
15899 READ_ULEB (val, p, end);
15900 printf (" Tag_ABI_compatibility: ");
15901 printf (_("flag = %d, vendor = "), val);
15902 if (p < end - 1)
15903 {
15904 size_t maxlen = (end - p) - 1;
15905
15906 print_symbol ((int) maxlen, (const char *) p);
15907 p += strnlen ((char *) p, maxlen) + 1;
15908 }
15909 else
15910 {
15911 printf (_("<corrupt>"));
15912 p = (unsigned char *) end;
15913 }
15914 putchar ('\n');
15915 return p;
15916 }
15917
15918 case Tag_ABI_conformance:
15919 {
15920 printf (" Tag_ABI_conformance: \"");
15921 if (p < end - 1)
15922 {
15923 size_t maxlen = (end - p) - 1;
15924
15925 print_symbol ((int) maxlen, (const char *) p);
15926 p += strnlen ((char *) p, maxlen) + 1;
15927 }
15928 else
15929 {
15930 printf (_("<corrupt>"));
15931 p = (unsigned char *) end;
15932 }
15933 printf ("\"\n");
15934 return p;
15935 }
15936 }
15937
15938 return display_tag_value (tag, p, end);
15939}
15940
15941static void
15942display_raw_attribute (unsigned char * p, unsigned char const * const end)
15943{
15944 unsigned long addr = 0;
15945 size_t bytes = end - p;
15946
15947 assert (end >= p);
15948 while (bytes)
15949 {
15950 int j;
15951 int k;
15952 int lbytes = (bytes > 16 ? 16 : bytes);
15953
15954 printf (" 0x%8.8lx ", addr);
15955
15956 for (j = 0; j < 16; j++)
15957 {
15958 if (j < lbytes)
15959 printf ("%2.2x", p[j]);
15960 else
15961 printf (" ");
15962
15963 if ((j & 3) == 3)
15964 printf (" ");
15965 }
15966
15967 for (j = 0; j < lbytes; j++)
15968 {
15969 k = p[j];
15970 if (k >= ' ' && k < 0x7f)
15971 printf ("%c", k);
15972 else
15973 printf (".");
15974 }
15975
15976 putchar ('\n');
15977
15978 p += lbytes;
15979 bytes -= lbytes;
15980 addr += lbytes;
15981 }
15982
15983 putchar ('\n');
15984}
15985
15986static unsigned char *
15987display_msp430x_attribute (unsigned char * p,
15988 const unsigned char * const end)
15989{
15990 unsigned int val;
15991 unsigned int tag;
15992
15993 READ_ULEB (tag, p, end);
15994
15995 switch (tag)
15996 {
15997 case OFBA_MSPABI_Tag_ISA:
15998 printf (" Tag_ISA: ");
15999 READ_ULEB (val, p, end);
16000 switch (val)
16001 {
16002 case 0: printf (_("None\n")); break;
16003 case 1: printf (_("MSP430\n")); break;
16004 case 2: printf (_("MSP430X\n")); break;
16005 default: printf ("??? (%d)\n", val); break;
16006 }
16007 break;
16008
16009 case OFBA_MSPABI_Tag_Code_Model:
16010 printf (" Tag_Code_Model: ");
16011 READ_ULEB (val, p, end);
16012 switch (val)
16013 {
16014 case 0: printf (_("None\n")); break;
16015 case 1: printf (_("Small\n")); break;
16016 case 2: printf (_("Large\n")); break;
16017 default: printf ("??? (%d)\n", val); break;
16018 }
16019 break;
16020
16021 case OFBA_MSPABI_Tag_Data_Model:
16022 printf (" Tag_Data_Model: ");
16023 READ_ULEB (val, p, end);
16024 switch (val)
16025 {
16026 case 0: printf (_("None\n")); break;
16027 case 1: printf (_("Small\n")); break;
16028 case 2: printf (_("Large\n")); break;
16029 case 3: printf (_("Restricted Large\n")); break;
16030 default: printf ("??? (%d)\n", val); break;
16031 }
16032 break;
16033
16034 default:
16035 printf (_(" <unknown tag %d>: "), tag);
16036
16037 if (tag & 1)
16038 {
16039 putchar ('"');
16040 if (p < end - 1)
16041 {
16042 size_t maxlen = (end - p) - 1;
16043
16044 print_symbol ((int) maxlen, (const char *) p);
16045 p += strnlen ((char *) p, maxlen) + 1;
16046 }
16047 else
16048 {
16049 printf (_("<corrupt>"));
16050 p = (unsigned char *) end;
16051 }
16052 printf ("\"\n");
16053 }
16054 else
16055 {
16056 READ_ULEB (val, p, end);
16057 printf ("%d (0x%x)\n", val, val);
16058 }
16059 break;
16060 }
16061
16062 assert (p <= end);
16063 return p;
16064}
16065
16066static unsigned char *
16067display_msp430_gnu_attribute (unsigned char * p,
16068 unsigned int tag,
16069 const unsigned char * const end)
16070{
16071 if (tag == Tag_GNU_MSP430_Data_Region)
16072 {
16073 unsigned int val;
16074
16075 printf (" Tag_GNU_MSP430_Data_Region: ");
16076 READ_ULEB (val, p, end);
16077
16078 switch (val)
16079 {
16080 case Val_GNU_MSP430_Data_Region_Any:
16081 printf (_("Any Region\n"));
16082 break;
16083 case Val_GNU_MSP430_Data_Region_Lower:
16084 printf (_("Lower Region Only\n"));
16085 break;
16086 default:
16087 printf ("??? (%u)\n", val);
16088 }
16089 return p;
16090 }
16091 return display_tag_value (tag & 1, p, end);
16092}
16093
16094struct riscv_attr_tag_t {
16095 const char *name;
16096 unsigned int tag;
16097};
16098
16099static struct riscv_attr_tag_t riscv_attr_tag[] =
16100{
16101#define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
16102 T(arch),
16103 T(priv_spec),
16104 T(priv_spec_minor),
16105 T(priv_spec_revision),
16106 T(unaligned_access),
16107 T(stack_align),
16108#undef T
16109};
16110
16111static unsigned char *
16112display_riscv_attribute (unsigned char *p,
16113 const unsigned char * const end)
16114{
16115 unsigned int val;
16116 unsigned int tag;
16117 struct riscv_attr_tag_t *attr = NULL;
16118 unsigned i;
16119
16120 READ_ULEB (tag, p, end);
16121
16122 /* Find the name of attribute. */
16123 for (i = 0; i < ARRAY_SIZE (riscv_attr_tag); i++)
16124 {
16125 if (riscv_attr_tag[i].tag == tag)
16126 {
16127 attr = &riscv_attr_tag[i];
16128 break;
16129 }
16130 }
16131
16132 if (attr)
16133 printf (" %s: ", attr->name);
16134 else
16135 return display_tag_value (tag, p, end);
16136
16137 switch (tag)
16138 {
16139 case Tag_RISCV_priv_spec:
16140 case Tag_RISCV_priv_spec_minor:
16141 case Tag_RISCV_priv_spec_revision:
16142 READ_ULEB (val, p, end);
16143 printf (_("%u\n"), val);
16144 break;
16145 case Tag_RISCV_unaligned_access:
16146 READ_ULEB (val, p, end);
16147 switch (val)
16148 {
16149 case 0:
16150 printf (_("No unaligned access\n"));
16151 break;
16152 case 1:
16153 printf (_("Unaligned access\n"));
16154 break;
16155 }
16156 break;
16157 case Tag_RISCV_stack_align:
16158 READ_ULEB (val, p, end);
16159 printf (_("%u-bytes\n"), val);
16160 break;
16161 case Tag_RISCV_arch:
16162 p = display_tag_value (-1, p, end);
16163 break;
16164 default:
16165 return display_tag_value (tag, p, end);
16166 }
16167
16168 return p;
16169}
16170
16171static bfd_boolean
16172process_attributes (Filedata * filedata,
16173 const char * public_name,
16174 unsigned int proc_type,
16175 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
16176 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
16177{
16178 Elf_Internal_Shdr * sect;
16179 unsigned i;
16180 bfd_boolean res = TRUE;
16181
16182 /* Find the section header so that we get the size. */
16183 for (i = 0, sect = filedata->section_headers;
16184 i < filedata->file_header.e_shnum;
16185 i++, sect++)
16186 {
16187 unsigned char * contents;
16188 unsigned char * p;
16189
16190 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
16191 continue;
16192
16193 contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
16194 sect->sh_size, _("attributes"));
16195 if (contents == NULL)
16196 {
16197 res = FALSE;
16198 continue;
16199 }
16200
16201 p = contents;
16202 /* The first character is the version of the attributes.
16203 Currently only version 1, (aka 'A') is recognised here. */
16204 if (*p != 'A')
16205 {
16206 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
16207 res = FALSE;
16208 }
16209 else
16210 {
16211 bfd_vma section_len;
16212
16213 section_len = sect->sh_size - 1;
16214 p++;
16215
16216 while (section_len > 0)
16217 {
16218 bfd_vma attr_len;
16219 unsigned int namelen;
16220 bfd_boolean public_section;
16221 bfd_boolean gnu_section;
16222
16223 if (section_len <= 4)
16224 {
16225 error (_("Tag section ends prematurely\n"));
16226 res = FALSE;
16227 break;
16228 }
16229 attr_len = byte_get (p, 4);
16230 p += 4;
16231
16232 if (attr_len > section_len)
16233 {
16234 error (_("Bad attribute length (%u > %u)\n"),
16235 (unsigned) attr_len, (unsigned) section_len);
16236 attr_len = section_len;
16237 res = FALSE;
16238 }
16239 /* PR 17531: file: 001-101425-0.004 */
16240 else if (attr_len < 5)
16241 {
16242 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
16243 res = FALSE;
16244 break;
16245 }
16246
16247 section_len -= attr_len;
16248 attr_len -= 4;
16249
16250 namelen = strnlen ((char *) p, attr_len) + 1;
16251 if (namelen == 0 || namelen >= attr_len)
16252 {
16253 error (_("Corrupt attribute section name\n"));
16254 res = FALSE;
16255 break;
16256 }
16257
16258 printf (_("Attribute Section: "));
16259 print_symbol (INT_MAX, (const char *) p);
16260 putchar ('\n');
16261
16262 if (public_name && streq ((char *) p, public_name))
16263 public_section = TRUE;
16264 else
16265 public_section = FALSE;
16266
16267 if (streq ((char *) p, "gnu"))
16268 gnu_section = TRUE;
16269 else
16270 gnu_section = FALSE;
16271
16272 p += namelen;
16273 attr_len -= namelen;
16274
16275 while (attr_len > 0 && p < contents + sect->sh_size)
16276 {
16277 int tag;
16278 unsigned int val;
16279 bfd_vma size;
16280 unsigned char * end;
16281
16282 /* PR binutils/17531: Safe handling of corrupt files. */
16283 if (attr_len < 6)
16284 {
16285 error (_("Unused bytes at end of section\n"));
16286 res = FALSE;
16287 section_len = 0;
16288 break;
16289 }
16290
16291 tag = *(p++);
16292 size = byte_get (p, 4);
16293 if (size > attr_len)
16294 {
16295 error (_("Bad subsection length (%u > %u)\n"),
16296 (unsigned) size, (unsigned) attr_len);
16297 res = FALSE;
16298 size = attr_len;
16299 }
16300 /* PR binutils/17531: Safe handling of corrupt files. */
16301 if (size < 6)
16302 {
16303 error (_("Bad subsection length (%u < 6)\n"),
16304 (unsigned) size);
16305 res = FALSE;
16306 section_len = 0;
16307 break;
16308 }
16309
16310 attr_len -= size;
16311 end = p + size - 1;
16312 assert (end <= contents + sect->sh_size);
16313 p += 4;
16314
16315 switch (tag)
16316 {
16317 case 1:
16318 printf (_("File Attributes\n"));
16319 break;
16320 case 2:
16321 printf (_("Section Attributes:"));
16322 goto do_numlist;
16323 case 3:
16324 printf (_("Symbol Attributes:"));
16325 /* Fall through. */
16326 do_numlist:
16327 for (;;)
16328 {
16329 READ_ULEB (val, p, end);
16330 if (val == 0)
16331 break;
16332 printf (" %d", val);
16333 }
16334 printf ("\n");
16335 break;
16336 default:
16337 printf (_("Unknown tag: %d\n"), tag);
16338 public_section = FALSE;
16339 break;
16340 }
16341
16342 if (public_section && display_pub_attribute != NULL)
16343 {
16344 while (p < end)
16345 p = display_pub_attribute (p, end);
16346 assert (p == end);
16347 }
16348 else if (gnu_section && display_proc_gnu_attribute != NULL)
16349 {
16350 while (p < end)
16351 p = display_gnu_attribute (p,
16352 display_proc_gnu_attribute,
16353 end);
16354 assert (p == end);
16355 }
16356 else if (p < end)
16357 {
16358 printf (_(" Unknown attribute:\n"));
16359 display_raw_attribute (p, end);
16360 p = end;
16361 }
16362 else
16363 attr_len = 0;
16364 }
16365 }
16366 }
16367
16368 free (contents);
16369 }
16370
16371 return res;
16372}
16373
16374/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16375 Print the Address, Access and Initial fields of an entry at VMA ADDR
16376 and return the VMA of the next entry, or -1 if there was a problem.
16377 Does not read from DATA_END or beyond. */
16378
16379static bfd_vma
16380print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
16381 unsigned char * data_end)
16382{
16383 printf (" ");
16384 print_vma (addr, LONG_HEX);
16385 printf (" ");
16386 if (addr < pltgot + 0xfff0)
16387 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
16388 else
16389 printf ("%10s", "");
16390 printf (" ");
16391 if (data == NULL)
16392 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
16393 else
16394 {
16395 bfd_vma entry;
16396 unsigned char * from = data + addr - pltgot;
16397
16398 if (from + (is_32bit_elf ? 4 : 8) > data_end)
16399 {
16400 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16401 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
16402 return (bfd_vma) -1;
16403 }
16404 else
16405 {
16406 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
16407 print_vma (entry, LONG_HEX);
16408 }
16409 }
16410 return addr + (is_32bit_elf ? 4 : 8);
16411}
16412
16413/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16414 PLTGOT. Print the Address and Initial fields of an entry at VMA
16415 ADDR and return the VMA of the next entry. */
16416
16417static bfd_vma
16418print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
16419{
16420 printf (" ");
16421 print_vma (addr, LONG_HEX);
16422 printf (" ");
16423 if (data == NULL)
16424 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
16425 else
16426 {
16427 bfd_vma entry;
16428
16429 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
16430 print_vma (entry, LONG_HEX);
16431 }
16432 return addr + (is_32bit_elf ? 4 : 8);
16433}
16434
16435static void
16436print_mips_ases (unsigned int mask)
16437{
16438 if (mask & AFL_ASE_DSP)
16439 fputs ("\n\tDSP ASE", stdout);
16440 if (mask & AFL_ASE_DSPR2)
16441 fputs ("\n\tDSP R2 ASE", stdout);
16442 if (mask & AFL_ASE_DSPR3)
16443 fputs ("\n\tDSP R3 ASE", stdout);
16444 if (mask & AFL_ASE_EVA)
16445 fputs ("\n\tEnhanced VA Scheme", stdout);
16446 if (mask & AFL_ASE_MCU)
16447 fputs ("\n\tMCU (MicroController) ASE", stdout);
16448 if (mask & AFL_ASE_MDMX)
16449 fputs ("\n\tMDMX ASE", stdout);
16450 if (mask & AFL_ASE_MIPS3D)
16451 fputs ("\n\tMIPS-3D ASE", stdout);
16452 if (mask & AFL_ASE_MT)
16453 fputs ("\n\tMT ASE", stdout);
16454 if (mask & AFL_ASE_SMARTMIPS)
16455 fputs ("\n\tSmartMIPS ASE", stdout);
16456 if (mask & AFL_ASE_VIRT)
16457 fputs ("\n\tVZ ASE", stdout);
16458 if (mask & AFL_ASE_MSA)
16459 fputs ("\n\tMSA ASE", stdout);
16460 if (mask & AFL_ASE_MIPS16)
16461 fputs ("\n\tMIPS16 ASE", stdout);
16462 if (mask & AFL_ASE_MICROMIPS)
16463 fputs ("\n\tMICROMIPS ASE", stdout);
16464 if (mask & AFL_ASE_XPA)
16465 fputs ("\n\tXPA ASE", stdout);
16466 if (mask & AFL_ASE_MIPS16E2)
16467 fputs ("\n\tMIPS16e2 ASE", stdout);
16468 if (mask & AFL_ASE_CRC)
16469 fputs ("\n\tCRC ASE", stdout);
16470 if (mask & AFL_ASE_GINV)
16471 fputs ("\n\tGINV ASE", stdout);
16472 if (mask & AFL_ASE_LOONGSON_MMI)
16473 fputs ("\n\tLoongson MMI ASE", stdout);
16474 if (mask & AFL_ASE_LOONGSON_CAM)
16475 fputs ("\n\tLoongson CAM ASE", stdout);
16476 if (mask & AFL_ASE_LOONGSON_EXT)
16477 fputs ("\n\tLoongson EXT ASE", stdout);
16478 if (mask & AFL_ASE_LOONGSON_EXT2)
16479 fputs ("\n\tLoongson EXT2 ASE", stdout);
16480 if (mask == 0)
16481 fprintf (stdout, "\n\t%s", _("None"));
16482 else if ((mask & ~AFL_ASE_MASK) != 0)
16483 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
16484}
16485
16486static void
16487print_mips_isa_ext (unsigned int isa_ext)
16488{
16489 switch (isa_ext)
16490 {
16491 case 0:
16492 fputs (_("None"), stdout);
16493 break;
16494 case AFL_EXT_XLR:
16495 fputs ("RMI XLR", stdout);
16496 break;
16497 case AFL_EXT_OCTEON3:
16498 fputs ("Cavium Networks Octeon3", stdout);
16499 break;
16500 case AFL_EXT_OCTEON2:
16501 fputs ("Cavium Networks Octeon2", stdout);
16502 break;
16503 case AFL_EXT_OCTEONP:
16504 fputs ("Cavium Networks OcteonP", stdout);
16505 break;
16506 case AFL_EXT_OCTEON:
16507 fputs ("Cavium Networks Octeon", stdout);
16508 break;
16509 case AFL_EXT_5900:
16510 fputs ("Toshiba R5900", stdout);
16511 break;
16512 case AFL_EXT_4650:
16513 fputs ("MIPS R4650", stdout);
16514 break;
16515 case AFL_EXT_4010:
16516 fputs ("LSI R4010", stdout);
16517 break;
16518 case AFL_EXT_4100:
16519 fputs ("NEC VR4100", stdout);
16520 break;
16521 case AFL_EXT_3900:
16522 fputs ("Toshiba R3900", stdout);
16523 break;
16524 case AFL_EXT_10000:
16525 fputs ("MIPS R10000", stdout);
16526 break;
16527 case AFL_EXT_SB1:
16528 fputs ("Broadcom SB-1", stdout);
16529 break;
16530 case AFL_EXT_4111:
16531 fputs ("NEC VR4111/VR4181", stdout);
16532 break;
16533 case AFL_EXT_4120:
16534 fputs ("NEC VR4120", stdout);
16535 break;
16536 case AFL_EXT_5400:
16537 fputs ("NEC VR5400", stdout);
16538 break;
16539 case AFL_EXT_5500:
16540 fputs ("NEC VR5500", stdout);
16541 break;
16542 case AFL_EXT_LOONGSON_2E:
16543 fputs ("ST Microelectronics Loongson 2E", stdout);
16544 break;
16545 case AFL_EXT_LOONGSON_2F:
16546 fputs ("ST Microelectronics Loongson 2F", stdout);
16547 break;
16548 case AFL_EXT_INTERAPTIV_MR2:
16549 fputs ("Imagination interAptiv MR2", stdout);
16550 break;
16551 default:
16552 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
16553 }
16554}
16555
16556static signed int
16557get_mips_reg_size (int reg_size)
16558{
16559 return (reg_size == AFL_REG_NONE) ? 0
16560 : (reg_size == AFL_REG_32) ? 32
16561 : (reg_size == AFL_REG_64) ? 64
16562 : (reg_size == AFL_REG_128) ? 128
16563 : -1;
16564}
16565
16566static bfd_boolean
16567process_mips_specific (Filedata * filedata)
16568{
16569 Elf_Internal_Dyn * entry;
16570 Elf_Internal_Shdr *sect = NULL;
16571 size_t liblist_offset = 0;
16572 size_t liblistno = 0;
16573 size_t conflictsno = 0;
16574 size_t options_offset = 0;
16575 size_t conflicts_offset = 0;
16576 size_t pltrelsz = 0;
16577 size_t pltrel = 0;
16578 bfd_vma pltgot = 0;
16579 bfd_vma mips_pltgot = 0;
16580 bfd_vma jmprel = 0;
16581 bfd_vma local_gotno = 0;
16582 bfd_vma gotsym = 0;
16583 bfd_vma symtabno = 0;
16584 bfd_boolean res = TRUE;
16585
16586 if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
16587 display_mips_gnu_attribute))
16588 res = FALSE;
16589
16590 sect = find_section (filedata, ".MIPS.abiflags");
16591
16592 if (sect != NULL)
16593 {
16594 Elf_External_ABIFlags_v0 *abiflags_ext;
16595 Elf_Internal_ABIFlags_v0 abiflags_in;
16596
16597 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
16598 {
16599 error (_("Corrupt MIPS ABI Flags section.\n"));
16600 res = FALSE;
16601 }
16602 else
16603 {
16604 abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
16605 sect->sh_size, _("MIPS ABI Flags section"));
16606 if (abiflags_ext)
16607 {
16608 abiflags_in.version = BYTE_GET (abiflags_ext->version);
16609 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
16610 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
16611 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
16612 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
16613 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
16614 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
16615 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
16616 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
16617 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
16618 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
16619
16620 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
16621 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
16622 if (abiflags_in.isa_rev > 1)
16623 printf ("r%d", abiflags_in.isa_rev);
16624 printf ("\nGPR size: %d",
16625 get_mips_reg_size (abiflags_in.gpr_size));
16626 printf ("\nCPR1 size: %d",
16627 get_mips_reg_size (abiflags_in.cpr1_size));
16628 printf ("\nCPR2 size: %d",
16629 get_mips_reg_size (abiflags_in.cpr2_size));
16630 fputs ("\nFP ABI: ", stdout);
16631 print_mips_fp_abi_value (abiflags_in.fp_abi);
16632 fputs ("ISA Extension: ", stdout);
16633 print_mips_isa_ext (abiflags_in.isa_ext);
16634 fputs ("\nASEs:", stdout);
16635 print_mips_ases (abiflags_in.ases);
16636 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
16637 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
16638 fputc ('\n', stdout);
16639 free (abiflags_ext);
16640 }
16641 }
16642 }
16643
16644 /* We have a lot of special sections. Thanks SGI! */
16645 if (filedata->dynamic_section == NULL)
16646 {
16647 /* No dynamic information available. See if there is static GOT. */
16648 sect = find_section (filedata, ".got");
16649 if (sect != NULL)
16650 {
16651 unsigned char *data_end;
16652 unsigned char *data;
16653 bfd_vma ent, end;
16654 int addr_size;
16655
16656 pltgot = sect->sh_addr;
16657
16658 ent = pltgot;
16659 addr_size = (is_32bit_elf ? 4 : 8);
16660 end = pltgot + sect->sh_size;
16661
16662 data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
16663 end - pltgot, 1,
16664 _("Global Offset Table data"));
16665 /* PR 12855: Null data is handled gracefully throughout. */
16666 data_end = data + (end - pltgot);
16667
16668 printf (_("\nStatic GOT:\n"));
16669 printf (_(" Canonical gp value: "));
16670 print_vma (ent + 0x7ff0, LONG_HEX);
16671 printf ("\n\n");
16672
16673 /* In a dynamic binary GOT[0] is reserved for the dynamic
16674 loader to store the lazy resolver pointer, however in
16675 a static binary it may well have been omitted and GOT
16676 reduced to a table of addresses.
16677 PR 21344: Check for the entry being fully available
16678 before fetching it. */
16679 if (data
16680 && data + ent - pltgot + addr_size <= data_end
16681 && byte_get (data + ent - pltgot, addr_size) == 0)
16682 {
16683 printf (_(" Reserved entries:\n"));
16684 printf (_(" %*s %10s %*s\n"),
16685 addr_size * 2, _("Address"), _("Access"),
16686 addr_size * 2, _("Value"));
16687 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16688 printf ("\n");
16689 if (ent == (bfd_vma) -1)
16690 goto sgot_print_fail;
16691
16692 /* Check for the MSB of GOT[1] being set, identifying a
16693 GNU object. This entry will be used by some runtime
16694 loaders, to store the module pointer. Otherwise this
16695 is an ordinary local entry.
16696 PR 21344: Check for the entry being fully available
16697 before fetching it. */
16698 if (data
16699 && data + ent - pltgot + addr_size <= data_end
16700 && (byte_get (data + ent - pltgot, addr_size)
16701 >> (addr_size * 8 - 1)) != 0)
16702 {
16703 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16704 printf ("\n");
16705 if (ent == (bfd_vma) -1)
16706 goto sgot_print_fail;
16707 }
16708 printf ("\n");
16709 }
16710
16711 if (data != NULL && ent < end)
16712 {
16713 printf (_(" Local entries:\n"));
16714 printf (" %*s %10s %*s\n",
16715 addr_size * 2, _("Address"), _("Access"),
16716 addr_size * 2, _("Value"));
16717 while (ent < end)
16718 {
16719 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16720 printf ("\n");
16721 if (ent == (bfd_vma) -1)
16722 goto sgot_print_fail;
16723 }
16724 printf ("\n");
16725 }
16726
16727 sgot_print_fail:
16728 free (data);
16729 }
16730 return res;
16731 }
16732
16733 for (entry = filedata->dynamic_section;
16734 /* PR 17531 file: 012-50589-0.004. */
16735 (entry < filedata->dynamic_section + filedata->dynamic_nent
16736 && entry->d_tag != DT_NULL);
16737 ++entry)
16738 switch (entry->d_tag)
16739 {
16740 case DT_MIPS_LIBLIST:
16741 liblist_offset
16742 = offset_from_vma (filedata, entry->d_un.d_val,
16743 liblistno * sizeof (Elf32_External_Lib));
16744 break;
16745 case DT_MIPS_LIBLISTNO:
16746 liblistno = entry->d_un.d_val;
16747 break;
16748 case DT_MIPS_OPTIONS:
16749 options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
16750 break;
16751 case DT_MIPS_CONFLICT:
16752 conflicts_offset
16753 = offset_from_vma (filedata, entry->d_un.d_val,
16754 conflictsno * sizeof (Elf32_External_Conflict));
16755 break;
16756 case DT_MIPS_CONFLICTNO:
16757 conflictsno = entry->d_un.d_val;
16758 break;
16759 case DT_PLTGOT:
16760 pltgot = entry->d_un.d_ptr;
16761 break;
16762 case DT_MIPS_LOCAL_GOTNO:
16763 local_gotno = entry->d_un.d_val;
16764 break;
16765 case DT_MIPS_GOTSYM:
16766 gotsym = entry->d_un.d_val;
16767 break;
16768 case DT_MIPS_SYMTABNO:
16769 symtabno = entry->d_un.d_val;
16770 break;
16771 case DT_MIPS_PLTGOT:
16772 mips_pltgot = entry->d_un.d_ptr;
16773 break;
16774 case DT_PLTREL:
16775 pltrel = entry->d_un.d_val;
16776 break;
16777 case DT_PLTRELSZ:
16778 pltrelsz = entry->d_un.d_val;
16779 break;
16780 case DT_JMPREL:
16781 jmprel = entry->d_un.d_ptr;
16782 break;
16783 default:
16784 break;
16785 }
16786
16787 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
16788 {
16789 Elf32_External_Lib * elib;
16790 size_t cnt;
16791
16792 elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
16793 sizeof (Elf32_External_Lib),
16794 liblistno,
16795 _("liblist section data"));
16796 if (elib)
16797 {
16798 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16799 "\nSection '.liblist' contains %lu entries:\n",
16800 (unsigned long) liblistno),
16801 (unsigned long) liblistno);
16802 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16803 stdout);
16804
16805 for (cnt = 0; cnt < liblistno; ++cnt)
16806 {
16807 Elf32_Lib liblist;
16808 time_t atime;
16809 char timebuf[128];
16810 struct tm * tmp;
16811
16812 liblist.l_name = BYTE_GET (elib[cnt].l_name);
16813 atime = BYTE_GET (elib[cnt].l_time_stamp);
16814 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16815 liblist.l_version = BYTE_GET (elib[cnt].l_version);
16816 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16817
16818 tmp = gmtime (&atime);
16819 snprintf (timebuf, sizeof (timebuf),
16820 "%04u-%02u-%02uT%02u:%02u:%02u",
16821 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16822 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16823
16824 printf ("%3lu: ", (unsigned long) cnt);
16825 if (VALID_DYNAMIC_NAME (filedata, liblist.l_name))
16826 print_symbol (20, GET_DYNAMIC_NAME (filedata, liblist.l_name));
16827 else
16828 printf (_("<corrupt: %9ld>"), liblist.l_name);
16829 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
16830 liblist.l_version);
16831
16832 if (liblist.l_flags == 0)
16833 puts (_(" NONE"));
16834 else
16835 {
16836 static const struct
16837 {
16838 const char * name;
16839 int bit;
16840 }
16841 l_flags_vals[] =
16842 {
16843 { " EXACT_MATCH", LL_EXACT_MATCH },
16844 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
16845 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
16846 { " EXPORTS", LL_EXPORTS },
16847 { " DELAY_LOAD", LL_DELAY_LOAD },
16848 { " DELTA", LL_DELTA }
16849 };
16850 int flags = liblist.l_flags;
16851 size_t fcnt;
16852
16853 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
16854 if ((flags & l_flags_vals[fcnt].bit) != 0)
16855 {
16856 fputs (l_flags_vals[fcnt].name, stdout);
16857 flags ^= l_flags_vals[fcnt].bit;
16858 }
16859 if (flags != 0)
16860 printf (" %#x", (unsigned int) flags);
16861
16862 puts ("");
16863 }
16864 }
16865
16866 free (elib);
16867 }
16868 else
16869 res = FALSE;
16870 }
16871
16872 if (options_offset != 0)
16873 {
16874 Elf_External_Options * eopt;
16875 size_t offset;
16876 int cnt;
16877 sect = filedata->section_headers;
16878
16879 /* Find the section header so that we get the size. */
16880 sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
16881 /* PR 17533 file: 012-277276-0.004. */
16882 if (sect == NULL)
16883 {
16884 error (_("No MIPS_OPTIONS header found\n"));
16885 return FALSE;
16886 }
16887 /* PR 24243 */
16888 if (sect->sh_size < sizeof (* eopt))
16889 {
16890 error (_("The MIPS options section is too small.\n"));
16891 return FALSE;
16892 }
16893
16894 eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
16895 sect->sh_size, _("options"));
16896 if (eopt)
16897 {
16898 Elf_Internal_Options option;
16899
16900 offset = cnt = 0;
16901 while (offset <= sect->sh_size - sizeof (* eopt))
16902 {
16903 Elf_External_Options * eoption;
16904 unsigned int optsize;
16905
16906 eoption = (Elf_External_Options *) ((char *) eopt + offset);
16907
16908 optsize = BYTE_GET (eoption->size);
16909
16910 /* PR 17531: file: ffa0fa3b. */
16911 if (optsize < sizeof (* eopt)
16912 || optsize > sect->sh_size - offset)
16913 {
16914 error (_("Invalid size (%u) for MIPS option\n"),
16915 optsize);
16916 free (eopt);
16917 return FALSE;
16918 }
16919 offset += optsize;
16920 ++cnt;
16921 }
16922
16923 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16924 "\nSection '%s' contains %d entries:\n",
16925 cnt),
16926 printable_section_name (filedata, sect), cnt);
16927
16928 offset = 0;
16929 while (cnt-- > 0)
16930 {
16931 size_t len;
16932 Elf_External_Options * eoption;
16933
16934 eoption = (Elf_External_Options *) ((char *) eopt + offset);
16935
16936 option.kind = BYTE_GET (eoption->kind);
16937 option.size = BYTE_GET (eoption->size);
16938 option.section = BYTE_GET (eoption->section);
16939 option.info = BYTE_GET (eoption->info);
16940
16941 switch (option.kind)
16942 {
16943 case ODK_NULL:
16944 /* This shouldn't happen. */
16945 printf (" NULL %" PRId16 " %" PRIx32,
16946 option.section, option.info);
16947 break;
16948
16949 case ODK_REGINFO:
16950 printf (" REGINFO ");
16951 if (filedata->file_header.e_machine == EM_MIPS)
16952 {
16953 Elf32_External_RegInfo * ereg;
16954 Elf32_RegInfo reginfo;
16955
16956 /* 32bit form. */
16957 if (option.size < (sizeof (Elf_External_Options)
16958 + sizeof (Elf32_External_RegInfo)))
16959 {
16960 printf (_("<corrupt>\n"));
16961 error (_("Truncated MIPS REGINFO option\n"));
16962 cnt = 0;
16963 break;
16964 }
16965
16966 ereg = (Elf32_External_RegInfo *) (eoption + 1);
16967
16968 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
16969 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16970 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16971 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16972 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16973 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
16974
16975 printf ("GPR %08" PRIx32 " GP 0x%" PRIx32 "\n",
16976 reginfo.ri_gprmask, reginfo.ri_gp_value);
16977 printf (" "
16978 " CPR0 %08" PRIx32 " CPR1 %08" PRIx32
16979 " CPR2 %08" PRIx32 " CPR3 %08" PRIx32 "\n",
16980 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16981 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16982 }
16983 else
16984 {
16985 /* 64 bit form. */
16986 Elf64_External_RegInfo * ereg;
16987 Elf64_Internal_RegInfo reginfo;
16988
16989 if (option.size < (sizeof (Elf_External_Options)
16990 + sizeof (Elf64_External_RegInfo)))
16991 {
16992 printf (_("<corrupt>\n"));
16993 error (_("Truncated MIPS REGINFO option\n"));
16994 cnt = 0;
16995 break;
16996 }
16997
16998 ereg = (Elf64_External_RegInfo *) (eoption + 1);
16999 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
17000 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
17001 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
17002 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
17003 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
17004 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
17005
17006 printf ("GPR %08" PRIx32 " GP 0x%" PRIx64 "\n",
17007 reginfo.ri_gprmask, reginfo.ri_gp_value);
17008 printf (" "
17009 " CPR0 %08" PRIx32 " CPR1 %08" PRIx32
17010 " CPR2 %08" PRIx32 " CPR3 %08" PRIx32 "\n",
17011 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
17012 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
17013 }
17014 offset += option.size;
17015 continue;
17016
17017 case ODK_EXCEPTIONS:
17018 fputs (" EXCEPTIONS fpe_min(", stdout);
17019 process_mips_fpe_exception (option.info & OEX_FPU_MIN);
17020 fputs (") fpe_max(", stdout);
17021 process_mips_fpe_exception ((option.info & OEX_FPU_MAX) >> 8);
17022 fputs (")", stdout);
17023
17024 if (option.info & OEX_PAGE0)
17025 fputs (" PAGE0", stdout);
17026 if (option.info & OEX_SMM)
17027 fputs (" SMM", stdout);
17028 if (option.info & OEX_FPDBUG)
17029 fputs (" FPDBUG", stdout);
17030 if (option.info & OEX_DISMISS)
17031 fputs (" DISMISS", stdout);
17032 break;
17033
17034 case ODK_PAD:
17035 fputs (" PAD ", stdout);
17036 if (option.info & OPAD_PREFIX)
17037 fputs (" PREFIX", stdout);
17038 if (option.info & OPAD_POSTFIX)
17039 fputs (" POSTFIX", stdout);
17040 if (option.info & OPAD_SYMBOL)
17041 fputs (" SYMBOL", stdout);
17042 break;
17043
17044 case ODK_HWPATCH:
17045 fputs (" HWPATCH ", stdout);
17046 if (option.info & OHW_R4KEOP)
17047 fputs (" R4KEOP", stdout);
17048 if (option.info & OHW_R8KPFETCH)
17049 fputs (" R8KPFETCH", stdout);
17050 if (option.info & OHW_R5KEOP)
17051 fputs (" R5KEOP", stdout);
17052 if (option.info & OHW_R5KCVTL)
17053 fputs (" R5KCVTL", stdout);
17054 break;
17055
17056 case ODK_FILL:
17057 fputs (" FILL ", stdout);
17058 /* XXX Print content of info word? */
17059 break;
17060
17061 case ODK_TAGS:
17062 fputs (" TAGS ", stdout);
17063 /* XXX Print content of info word? */
17064 break;
17065
17066 case ODK_HWAND:
17067 fputs (" HWAND ", stdout);
17068 if (option.info & OHWA0_R4KEOP_CHECKED)
17069 fputs (" R4KEOP_CHECKED", stdout);
17070 if (option.info & OHWA0_R4KEOP_CLEAN)
17071 fputs (" R4KEOP_CLEAN", stdout);
17072 break;
17073
17074 case ODK_HWOR:
17075 fputs (" HWOR ", stdout);
17076 if (option.info & OHWA0_R4KEOP_CHECKED)
17077 fputs (" R4KEOP_CHECKED", stdout);
17078 if (option.info & OHWA0_R4KEOP_CLEAN)
17079 fputs (" R4KEOP_CLEAN", stdout);
17080 break;
17081
17082 case ODK_GP_GROUP:
17083 printf (" GP_GROUP %#06x self-contained %#06x",
17084 option.info & OGP_GROUP,
17085 (option.info & OGP_SELF) >> 16);
17086 break;
17087
17088 case ODK_IDENT:
17089 printf (" IDENT %#06x self-contained %#06x",
17090 option.info & OGP_GROUP,
17091 (option.info & OGP_SELF) >> 16);
17092 break;
17093
17094 default:
17095 /* This shouldn't happen. */
17096 printf (" %3d ??? %" PRId16 " %" PRIx32,
17097 option.kind, option.section, option.info);
17098 break;
17099 }
17100
17101 len = sizeof (* eopt);
17102 while (len < option.size)
17103 {
17104 unsigned char datum = *((unsigned char *) eoption + len);
17105
17106 if (ISPRINT (datum))
17107 printf ("%c", datum);
17108 else
17109 printf ("\\%03o", datum);
17110 len ++;
17111 }
17112 fputs ("\n", stdout);
17113
17114 offset += option.size;
17115 }
17116 free (eopt);
17117 }
17118 else
17119 res = FALSE;
17120 }
17121
17122 if (conflicts_offset != 0 && conflictsno != 0)
17123 {
17124 Elf32_Conflict * iconf;
17125 size_t cnt;
17126
17127 if (filedata->dynamic_symbols == NULL)
17128 {
17129 error (_("conflict list found without a dynamic symbol table\n"));
17130 return FALSE;
17131 }
17132
17133 /* PR 21345 - print a slightly more helpful error message
17134 if we are sure that the cmalloc will fail. */
17135 if (conflictsno > filedata->file_size / sizeof (* iconf))
17136 {
17137 error (_("Overlarge number of conflicts detected: %lx\n"),
17138 (long) conflictsno);
17139 return FALSE;
17140 }
17141
17142 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
17143 if (iconf == NULL)
17144 {
17145 error (_("Out of memory allocating space for dynamic conflicts\n"));
17146 return FALSE;
17147 }
17148
17149 if (is_32bit_elf)
17150 {
17151 Elf32_External_Conflict * econf32;
17152
17153 econf32 = (Elf32_External_Conflict *)
17154 get_data (NULL, filedata, conflicts_offset,
17155 sizeof (*econf32), conflictsno, _("conflict"));
17156 if (!econf32)
17157 {
17158 free (iconf);
17159 return FALSE;
17160 }
17161
17162 for (cnt = 0; cnt < conflictsno; ++cnt)
17163 iconf[cnt] = BYTE_GET (econf32[cnt]);
17164
17165 free (econf32);
17166 }
17167 else
17168 {
17169 Elf64_External_Conflict * econf64;
17170
17171 econf64 = (Elf64_External_Conflict *)
17172 get_data (NULL, filedata, conflicts_offset,
17173 sizeof (*econf64), conflictsno, _("conflict"));
17174 if (!econf64)
17175 {
17176 free (iconf);
17177 return FALSE;
17178 }
17179
17180 for (cnt = 0; cnt < conflictsno; ++cnt)
17181 iconf[cnt] = BYTE_GET (econf64[cnt]);
17182
17183 free (econf64);
17184 }
17185
17186 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
17187 "\nSection '.conflict' contains %lu entries:\n",
17188 (unsigned long) conflictsno),
17189 (unsigned long) conflictsno);
17190 puts (_(" Num: Index Value Name"));
17191
17192 for (cnt = 0; cnt < conflictsno; ++cnt)
17193 {
17194 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
17195
17196 if (iconf[cnt] >= filedata->num_dynamic_syms)
17197 printf (_("<corrupt symbol index>"));
17198 else
17199 {
17200 Elf_Internal_Sym * psym;
17201
17202 psym = & filedata->dynamic_symbols[iconf[cnt]];
17203 print_vma (psym->st_value, FULL_HEX);
17204 putchar (' ');
17205 if (VALID_DYNAMIC_NAME (filedata, psym->st_name))
17206 print_symbol (25, GET_DYNAMIC_NAME (filedata, psym->st_name));
17207 else
17208 printf (_("<corrupt: %14ld>"), psym->st_name);
17209 }
17210 putchar ('\n');
17211 }
17212
17213 free (iconf);
17214 }
17215
17216 if (pltgot != 0 && local_gotno != 0)
17217 {
17218 bfd_vma ent, local_end, global_end;
17219 size_t i, offset;
17220 unsigned char * data;
17221 unsigned char * data_end;
17222 int addr_size;
17223
17224 ent = pltgot;
17225 addr_size = (is_32bit_elf ? 4 : 8);
17226 local_end = pltgot + local_gotno * addr_size;
17227
17228 /* PR binutils/17533 file: 012-111227-0.004 */
17229 if (symtabno < gotsym)
17230 {
17231 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
17232 (unsigned long) gotsym, (unsigned long) symtabno);
17233 return FALSE;
17234 }
17235
17236 global_end = local_end + (symtabno - gotsym) * addr_size;
17237 /* PR 17531: file: 54c91a34. */
17238 if (global_end < local_end)
17239 {
17240 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
17241 return FALSE;
17242 }
17243
17244 offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
17245 data = (unsigned char *) get_data (NULL, filedata, offset,
17246 global_end - pltgot, 1,
17247 _("Global Offset Table data"));
17248 /* PR 12855: Null data is handled gracefully throughout. */
17249 data_end = data + (global_end - pltgot);
17250
17251 printf (_("\nPrimary GOT:\n"));
17252 printf (_(" Canonical gp value: "));
17253 print_vma (pltgot + 0x7ff0, LONG_HEX);
17254 printf ("\n\n");
17255
17256 printf (_(" Reserved entries:\n"));
17257 printf (_(" %*s %10s %*s Purpose\n"),
17258 addr_size * 2, _("Address"), _("Access"),
17259 addr_size * 2, _("Initial"));
17260 ent = print_mips_got_entry (data, pltgot, ent, data_end);
17261 printf (_(" Lazy resolver\n"));
17262 if (ent == (bfd_vma) -1)
17263 goto got_print_fail;
17264
17265 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
17266 This entry will be used by some runtime loaders, to store the
17267 module pointer. Otherwise this is an ordinary local entry.
17268 PR 21344: Check for the entry being fully available before
17269 fetching it. */
17270 if (data
17271 && data + ent - pltgot + addr_size <= data_end
17272 && (byte_get (data + ent - pltgot, addr_size)
17273 >> (addr_size * 8 - 1)) != 0)
17274 {
17275 ent = print_mips_got_entry (data, pltgot, ent, data_end);
17276 printf (_(" Module pointer (GNU extension)\n"));
17277 if (ent == (bfd_vma) -1)
17278 goto got_print_fail;
17279 }
17280 printf ("\n");
17281
17282 if (data != NULL && ent < local_end)
17283 {
17284 printf (_(" Local entries:\n"));
17285 printf (" %*s %10s %*s\n",
17286 addr_size * 2, _("Address"), _("Access"),
17287 addr_size * 2, _("Initial"));
17288 while (ent < local_end)
17289 {
17290 ent = print_mips_got_entry (data, pltgot, ent, data_end);
17291 printf ("\n");
17292 if (ent == (bfd_vma) -1)
17293 goto got_print_fail;
17294 }
17295 printf ("\n");
17296 }
17297
17298 if (data != NULL && gotsym < symtabno)
17299 {
17300 int sym_width;
17301
17302 printf (_(" Global entries:\n"));
17303 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
17304 addr_size * 2, _("Address"),
17305 _("Access"),
17306 addr_size * 2, _("Initial"),
17307 addr_size * 2, _("Sym.Val."),
17308 _("Type"),
17309 /* Note for translators: "Ndx" = abbreviated form of "Index". */
17310 _("Ndx"), _("Name"));
17311
17312 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
17313
17314 for (i = gotsym; i < symtabno; i++)
17315 {
17316 ent = print_mips_got_entry (data, pltgot, ent, data_end);
17317 printf (" ");
17318
17319 if (filedata->dynamic_symbols == NULL)
17320 printf (_("<no dynamic symbols>"));
17321 else if (i < filedata->num_dynamic_syms)
17322 {
17323 Elf_Internal_Sym * psym = filedata->dynamic_symbols + i;
17324
17325 print_vma (psym->st_value, LONG_HEX);
17326 printf (" %-7s %3s ",
17327 get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
17328 get_symbol_index_type (filedata, psym->st_shndx));
17329
17330 if (VALID_DYNAMIC_NAME (filedata, psym->st_name))
17331 print_symbol (sym_width,
17332 GET_DYNAMIC_NAME (filedata, psym->st_name));
17333 else
17334 printf (_("<corrupt: %14ld>"), psym->st_name);
17335 }
17336 else
17337 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
17338 (unsigned long) i);
17339
17340 printf ("\n");
17341 if (ent == (bfd_vma) -1)
17342 break;
17343 }
17344 printf ("\n");
17345 }
17346
17347 got_print_fail:
17348 free (data);
17349 }
17350
17351 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
17352 {
17353 bfd_vma ent, end;
17354 size_t offset, rel_offset;
17355 unsigned long count, i;
17356 unsigned char * data;
17357 int addr_size, sym_width;
17358 Elf_Internal_Rela * rels;
17359
17360 rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
17361 if (pltrel == DT_RELA)
17362 {
17363 if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
17364 return FALSE;
17365 }
17366 else
17367 {
17368 if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
17369 return FALSE;
17370 }
17371
17372 ent = mips_pltgot;
17373 addr_size = (is_32bit_elf ? 4 : 8);
17374 end = mips_pltgot + (2 + count) * addr_size;
17375
17376 offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
17377 data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
17378 1, _("Procedure Linkage Table data"));
17379 if (data == NULL)
17380 return FALSE;
17381
17382 printf ("\nPLT GOT:\n\n");
17383 printf (_(" Reserved entries:\n"));
17384 printf (_(" %*s %*s Purpose\n"),
17385 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
17386 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
17387 printf (_(" PLT lazy resolver\n"));
17388 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
17389 printf (_(" Module pointer\n"));
17390 printf ("\n");
17391
17392 printf (_(" Entries:\n"));
17393 printf (" %*s %*s %*s %-7s %3s %s\n",
17394 addr_size * 2, _("Address"),
17395 addr_size * 2, _("Initial"),
17396 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17397 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
17398 for (i = 0; i < count; i++)
17399 {
17400 unsigned long idx = get_reloc_symindex (rels[i].r_info);
17401
17402 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
17403 printf (" ");
17404
17405 if (idx >= filedata->num_dynamic_syms)
17406 printf (_("<corrupt symbol index: %lu>"), idx);
17407 else
17408 {
17409 Elf_Internal_Sym * psym = filedata->dynamic_symbols + idx;
17410
17411 print_vma (psym->st_value, LONG_HEX);
17412 printf (" %-7s %3s ",
17413 get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
17414 get_symbol_index_type (filedata, psym->st_shndx));
17415 if (VALID_DYNAMIC_NAME (filedata, psym->st_name))
17416 print_symbol (sym_width,
17417 GET_DYNAMIC_NAME (filedata, psym->st_name));
17418 else
17419 printf (_("<corrupt: %14ld>"), psym->st_name);
17420 }
17421 printf ("\n");
17422 }
17423 printf ("\n");
17424
17425 free (data);
17426 free (rels);
17427 }
17428
17429 return res;
17430}
17431
17432static bfd_boolean
17433process_nds32_specific (Filedata * filedata)
17434{
17435 Elf_Internal_Shdr *sect = NULL;
17436
17437 sect = find_section (filedata, ".nds32_e_flags");
17438 if (sect != NULL && sect->sh_size >= 4)
17439 {
17440 unsigned char *buf;
17441 unsigned int flag;
17442
17443 printf ("\nNDS32 elf flags section:\n");
17444 buf = get_data (NULL, filedata, sect->sh_offset, 1, 4,
17445 _("NDS32 elf flags section"));
17446
17447 if (buf == NULL)
17448 return FALSE;
17449
17450 flag = byte_get (buf, 4);
17451 free (buf);
17452 switch (flag & 0x3)
17453 {
17454 case 0:
17455 printf ("(VEC_SIZE):\tNo entry.\n");
17456 break;
17457 case 1:
17458 printf ("(VEC_SIZE):\t4 bytes\n");
17459 break;
17460 case 2:
17461 printf ("(VEC_SIZE):\t16 bytes\n");
17462 break;
17463 case 3:
17464 printf ("(VEC_SIZE):\treserved\n");
17465 break;
17466 }
17467 }
17468
17469 return TRUE;
17470}
17471
17472static bfd_boolean
17473process_gnu_liblist (Filedata * filedata)
17474{
17475 Elf_Internal_Shdr * section;
17476 Elf_Internal_Shdr * string_sec;
17477 Elf32_External_Lib * elib;
17478 char * strtab;
17479 size_t strtab_size;
17480 size_t cnt;
17481 unsigned long num_liblist;
17482 unsigned i;
17483 bfd_boolean res = TRUE;
17484
17485 if (! do_arch)
17486 return TRUE;
17487
17488 for (i = 0, section = filedata->section_headers;
17489 i < filedata->file_header.e_shnum;
17490 i++, section++)
17491 {
17492 switch (section->sh_type)
17493 {
17494 case SHT_GNU_LIBLIST:
17495 if (section->sh_link >= filedata->file_header.e_shnum)
17496 break;
17497
17498 elib = (Elf32_External_Lib *)
17499 get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
17500 _("liblist section data"));
17501
17502 if (elib == NULL)
17503 {
17504 res = FALSE;
17505 break;
17506 }
17507
17508 string_sec = filedata->section_headers + section->sh_link;
17509 strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
17510 string_sec->sh_size,
17511 _("liblist string table"));
17512 if (strtab == NULL
17513 || section->sh_entsize != sizeof (Elf32_External_Lib))
17514 {
17515 free (elib);
17516 free (strtab);
17517 res = FALSE;
17518 break;
17519 }
17520 strtab_size = string_sec->sh_size;
17521
17522 num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
17523 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17524 "\nLibrary list section '%s' contains %lu entries:\n",
17525 num_liblist),
17526 printable_section_name (filedata, section),
17527 num_liblist);
17528
17529 puts (_(" Library Time Stamp Checksum Version Flags"));
17530
17531 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
17532 ++cnt)
17533 {
17534 Elf32_Lib liblist;
17535 time_t atime;
17536 char timebuf[128];
17537 struct tm * tmp;
17538
17539 liblist.l_name = BYTE_GET (elib[cnt].l_name);
17540 atime = BYTE_GET (elib[cnt].l_time_stamp);
17541 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
17542 liblist.l_version = BYTE_GET (elib[cnt].l_version);
17543 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
17544
17545 tmp = gmtime (&atime);
17546 snprintf (timebuf, sizeof (timebuf),
17547 "%04u-%02u-%02uT%02u:%02u:%02u",
17548 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
17549 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
17550
17551 printf ("%3lu: ", (unsigned long) cnt);
17552 if (do_wide)
17553 printf ("%-20s", liblist.l_name < strtab_size
17554 ? strtab + liblist.l_name : _("<corrupt>"));
17555 else
17556 printf ("%-20.20s", liblist.l_name < strtab_size
17557 ? strtab + liblist.l_name : _("<corrupt>"));
17558 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
17559 liblist.l_version, liblist.l_flags);
17560 }
17561
17562 free (elib);
17563 free (strtab);
17564 }
17565 }
17566
17567 return res;
17568}
17569
17570static const char *
17571get_note_type (Filedata * filedata, unsigned e_type)
17572{
17573 static char buff[64];
17574
17575 if (filedata->file_header.e_type == ET_CORE)
17576 switch (e_type)
17577 {
17578 case NT_AUXV:
17579 return _("NT_AUXV (auxiliary vector)");
17580 case NT_PRSTATUS:
17581 return _("NT_PRSTATUS (prstatus structure)");
17582 case NT_FPREGSET:
17583 return _("NT_FPREGSET (floating point registers)");
17584 case NT_PRPSINFO:
17585 return _("NT_PRPSINFO (prpsinfo structure)");
17586 case NT_TASKSTRUCT:
17587 return _("NT_TASKSTRUCT (task structure)");
17588 case NT_PRXFPREG:
17589 return _("NT_PRXFPREG (user_xfpregs structure)");
17590 case NT_PPC_VMX:
17591 return _("NT_PPC_VMX (ppc Altivec registers)");
17592 case NT_PPC_VSX:
17593 return _("NT_PPC_VSX (ppc VSX registers)");
17594 case NT_PPC_TAR:
17595 return _("NT_PPC_TAR (ppc TAR register)");
17596 case NT_PPC_PPR:
17597 return _("NT_PPC_PPR (ppc PPR register)");
17598 case NT_PPC_DSCR:
17599 return _("NT_PPC_DSCR (ppc DSCR register)");
17600 case NT_PPC_EBB:
17601 return _("NT_PPC_EBB (ppc EBB registers)");
17602 case NT_PPC_PMU:
17603 return _("NT_PPC_PMU (ppc PMU registers)");
17604 case NT_PPC_TM_CGPR:
17605 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17606 case NT_PPC_TM_CFPR:
17607 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17608 case NT_PPC_TM_CVMX:
17609 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17610 case NT_PPC_TM_CVSX:
17611 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17612 case NT_PPC_TM_SPR:
17613 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17614 case NT_PPC_TM_CTAR:
17615 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17616 case NT_PPC_TM_CPPR:
17617 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17618 case NT_PPC_TM_CDSCR:
17619 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17620 case NT_386_TLS:
17621 return _("NT_386_TLS (x86 TLS information)");
17622 case NT_386_IOPERM:
17623 return _("NT_386_IOPERM (x86 I/O permissions)");
17624 case NT_X86_XSTATE:
17625 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17626 case NT_S390_HIGH_GPRS:
17627 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17628 case NT_S390_TIMER:
17629 return _("NT_S390_TIMER (s390 timer register)");
17630 case NT_S390_TODCMP:
17631 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17632 case NT_S390_TODPREG:
17633 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17634 case NT_S390_CTRS:
17635 return _("NT_S390_CTRS (s390 control registers)");
17636 case NT_S390_PREFIX:
17637 return _("NT_S390_PREFIX (s390 prefix register)");
17638 case NT_S390_LAST_BREAK:
17639 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17640 case NT_S390_SYSTEM_CALL:
17641 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17642 case NT_S390_TDB:
17643 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17644 case NT_S390_VXRS_LOW:
17645 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17646 case NT_S390_VXRS_HIGH:
17647 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17648 case NT_S390_GS_CB:
17649 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17650 case NT_S390_GS_BC:
17651 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17652 case NT_ARM_VFP:
17653 return _("NT_ARM_VFP (arm VFP registers)");
17654 case NT_ARM_TLS:
17655 return _("NT_ARM_TLS (AArch TLS registers)");
17656 case NT_ARM_HW_BREAK:
17657 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17658 case NT_ARM_HW_WATCH:
17659 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17660 case NT_ARC_V2:
17661 return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
17662 case NT_PSTATUS:
17663 return _("NT_PSTATUS (pstatus structure)");
17664 case NT_FPREGS:
17665 return _("NT_FPREGS (floating point registers)");
17666 case NT_PSINFO:
17667 return _("NT_PSINFO (psinfo structure)");
17668 case NT_LWPSTATUS:
17669 return _("NT_LWPSTATUS (lwpstatus_t structure)");
17670 case NT_LWPSINFO:
17671 return _("NT_LWPSINFO (lwpsinfo_t structure)");
17672 case NT_WIN32PSTATUS:
17673 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17674 case NT_SIGINFO:
17675 return _("NT_SIGINFO (siginfo_t data)");
17676 case NT_FILE:
17677 return _("NT_FILE (mapped files)");
17678 default:
17679 break;
17680 }
17681 else
17682 switch (e_type)
17683 {
17684 case NT_VERSION:
17685 return _("NT_VERSION (version)");
17686 case NT_ARCH:
17687 return _("NT_ARCH (architecture)");
17688 case NT_GNU_BUILD_ATTRIBUTE_OPEN:
17689 return _("OPEN");
17690 case NT_GNU_BUILD_ATTRIBUTE_FUNC:
17691 return _("func");
17692 default:
17693 break;
17694 }
17695
17696 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17697 return buff;
17698}
17699
17700static bfd_boolean
17701print_core_note (Elf_Internal_Note *pnote)
17702{
17703 unsigned int addr_size = is_32bit_elf ? 4 : 8;
17704 bfd_vma count, page_size;
17705 unsigned char *descdata, *filenames, *descend;
17706
17707 if (pnote->type != NT_FILE)
17708 {
17709 if (do_wide)
17710 printf ("\n");
17711 return TRUE;
17712 }
17713
17714#ifndef BFD64
17715 if (!is_32bit_elf)
17716 {
17717 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
17718 /* Still "successful". */
17719 return TRUE;
17720 }
17721#endif
17722
17723 if (pnote->descsz < 2 * addr_size)
17724 {
17725 error (_(" Malformed note - too short for header\n"));
17726 return FALSE;
17727 }
17728
17729 descdata = (unsigned char *) pnote->descdata;
17730 descend = descdata + pnote->descsz;
17731
17732 if (descdata[pnote->descsz - 1] != '\0')
17733 {
17734 error (_(" Malformed note - does not end with \\0\n"));
17735 return FALSE;
17736 }
17737
17738 count = byte_get (descdata, addr_size);
17739 descdata += addr_size;
17740
17741 page_size = byte_get (descdata, addr_size);
17742 descdata += addr_size;
17743
17744 if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
17745 || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
17746 {
17747 error (_(" Malformed note - too short for supplied file count\n"));
17748 return FALSE;
17749 }
17750
17751 printf (_(" Page size: "));
17752 print_vma (page_size, DEC);
17753 printf ("\n");
17754
17755 printf (_(" %*s%*s%*s\n"),
17756 (int) (2 + 2 * addr_size), _("Start"),
17757 (int) (4 + 2 * addr_size), _("End"),
17758 (int) (4 + 2 * addr_size), _("Page Offset"));
17759 filenames = descdata + count * 3 * addr_size;
17760 while (count-- > 0)
17761 {
17762 bfd_vma start, end, file_ofs;
17763
17764 if (filenames == descend)
17765 {
17766 error (_(" Malformed note - filenames end too early\n"));
17767 return FALSE;
17768 }
17769
17770 start = byte_get (descdata, addr_size);
17771 descdata += addr_size;
17772 end = byte_get (descdata, addr_size);
17773 descdata += addr_size;
17774 file_ofs = byte_get (descdata, addr_size);
17775 descdata += addr_size;
17776
17777 printf (" ");
17778 print_vma (start, FULL_HEX);
17779 printf (" ");
17780 print_vma (end, FULL_HEX);
17781 printf (" ");
17782 print_vma (file_ofs, FULL_HEX);
17783 printf ("\n %s\n", filenames);
17784
17785 filenames += 1 + strlen ((char *) filenames);
17786 }
17787
17788 return TRUE;
17789}
17790
17791static const char *
17792get_gnu_elf_note_type (unsigned e_type)
17793{
17794 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17795 switch (e_type)
17796 {
17797 case NT_GNU_ABI_TAG:
17798 return _("NT_GNU_ABI_TAG (ABI version tag)");
17799 case NT_GNU_HWCAP:
17800 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17801 case NT_GNU_BUILD_ID:
17802 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17803 case NT_GNU_GOLD_VERSION:
17804 return _("NT_GNU_GOLD_VERSION (gold version)");
17805 case NT_GNU_PROPERTY_TYPE_0:
17806 return _("NT_GNU_PROPERTY_TYPE_0");
17807 case NT_GNU_BUILD_ATTRIBUTE_OPEN:
17808 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17809 case NT_GNU_BUILD_ATTRIBUTE_FUNC:
17810 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17811 default:
17812 {
17813 static char buff[64];
17814
17815 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17816 return buff;
17817 }
17818 }
17819}
17820
17821static void
17822decode_x86_compat_isa (unsigned int bitmask)
17823{
17824 while (bitmask)
17825 {
17826 unsigned int bit = bitmask & (- bitmask);
17827
17828 bitmask &= ~ bit;
17829 switch (bit)
17830 {
17831 case GNU_PROPERTY_X86_COMPAT_ISA_1_486:
17832 printf ("i486");
17833 break;
17834 case GNU_PROPERTY_X86_COMPAT_ISA_1_586:
17835 printf ("586");
17836 break;
17837 case GNU_PROPERTY_X86_COMPAT_ISA_1_686:
17838 printf ("686");
17839 break;
17840 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE:
17841 printf ("SSE");
17842 break;
17843 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2:
17844 printf ("SSE2");
17845 break;
17846 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3:
17847 printf ("SSE3");
17848 break;
17849 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3:
17850 printf ("SSSE3");
17851 break;
17852 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1:
17853 printf ("SSE4_1");
17854 break;
17855 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2:
17856 printf ("SSE4_2");
17857 break;
17858 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX:
17859 printf ("AVX");
17860 break;
17861 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2:
17862 printf ("AVX2");
17863 break;
17864 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F:
17865 printf ("AVX512F");
17866 break;
17867 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD:
17868 printf ("AVX512CD");
17869 break;
17870 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER:
17871 printf ("AVX512ER");
17872 break;
17873 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF:
17874 printf ("AVX512PF");
17875 break;
17876 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL:
17877 printf ("AVX512VL");
17878 break;
17879 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ:
17880 printf ("AVX512DQ");
17881 break;
17882 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW:
17883 printf ("AVX512BW");
17884 break;
17885 default:
17886 printf (_("<unknown: %x>"), bit);
17887 break;
17888 }
17889 if (bitmask)
17890 printf (", ");
17891 }
17892}
17893
17894static void
17895decode_x86_isa (unsigned int bitmask)
17896{
17897 if (!bitmask)
17898 {
17899 printf (_("<None>"));
17900 return;
17901 }
17902
17903 while (bitmask)
17904 {
17905 unsigned int bit = bitmask & (- bitmask);
17906
17907 bitmask &= ~ bit;
17908 switch (bit)
17909 {
17910 case GNU_PROPERTY_X86_ISA_1_CMOV:
17911 printf ("CMOV");
17912 break;
17913 case GNU_PROPERTY_X86_ISA_1_SSE:
17914 printf ("SSE");
17915 break;
17916 case GNU_PROPERTY_X86_ISA_1_SSE2:
17917 printf ("SSE2");
17918 break;
17919 case GNU_PROPERTY_X86_ISA_1_SSE3:
17920 printf ("SSE3");
17921 break;
17922 case GNU_PROPERTY_X86_ISA_1_SSSE3:
17923 printf ("SSSE3");
17924 break;
17925 case GNU_PROPERTY_X86_ISA_1_SSE4_1:
17926 printf ("SSE4_1");
17927 break;
17928 case GNU_PROPERTY_X86_ISA_1_SSE4_2:
17929 printf ("SSE4_2");
17930 break;
17931 case GNU_PROPERTY_X86_ISA_1_AVX:
17932 printf ("AVX");
17933 break;
17934 case GNU_PROPERTY_X86_ISA_1_AVX2:
17935 printf ("AVX2");
17936 break;
17937 case GNU_PROPERTY_X86_ISA_1_FMA:
17938 printf ("FMA");
17939 break;
17940 case GNU_PROPERTY_X86_ISA_1_AVX512F:
17941 printf ("AVX512F");
17942 break;
17943 case GNU_PROPERTY_X86_ISA_1_AVX512CD:
17944 printf ("AVX512CD");
17945 break;
17946 case GNU_PROPERTY_X86_ISA_1_AVX512ER:
17947 printf ("AVX512ER");
17948 break;
17949 case GNU_PROPERTY_X86_ISA_1_AVX512PF:
17950 printf ("AVX512PF");
17951 break;
17952 case GNU_PROPERTY_X86_ISA_1_AVX512VL:
17953 printf ("AVX512VL");
17954 break;
17955 case GNU_PROPERTY_X86_ISA_1_AVX512DQ:
17956 printf ("AVX512DQ");
17957 break;
17958 case GNU_PROPERTY_X86_ISA_1_AVX512BW:
17959 printf ("AVX512BW");
17960 break;
17961 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS:
17962 printf ("AVX512_4FMAPS");
17963 break;
17964 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW:
17965 printf ("AVX512_4VNNIW");
17966 break;
17967 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG:
17968 printf ("AVX512_BITALG");
17969 break;
17970 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA:
17971 printf ("AVX512_IFMA");
17972 break;
17973 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI:
17974 printf ("AVX512_VBMI");
17975 break;
17976 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2:
17977 printf ("AVX512_VBMI2");
17978 break;
17979 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI:
17980 printf ("AVX512_VNNI");
17981 break;
17982 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16:
17983 printf ("AVX512_BF16");
17984 break;
17985 default:
17986 printf (_("<unknown: %x>"), bit);
17987 break;
17988 }
17989 if (bitmask)
17990 printf (", ");
17991 }
17992}
17993
17994static void
17995decode_x86_feature_1 (unsigned int bitmask)
17996{
17997 if (!bitmask)
17998 {
17999 printf (_("<None>"));
18000 return;
18001 }
18002
18003 while (bitmask)
18004 {
18005 unsigned int bit = bitmask & (- bitmask);
18006
18007 bitmask &= ~ bit;
18008 switch (bit)
18009 {
18010 case GNU_PROPERTY_X86_FEATURE_1_IBT:
18011 printf ("IBT");
18012 break;
18013 case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
18014 printf ("SHSTK");
18015 break;
18016 default:
18017 printf (_("<unknown: %x>"), bit);
18018 break;
18019 }
18020 if (bitmask)
18021 printf (", ");
18022 }
18023}
18024
18025static void
18026decode_x86_feature_2 (unsigned int bitmask)
18027{
18028 if (!bitmask)
18029 {
18030 printf (_("<None>"));
18031 return;
18032 }
18033
18034 while (bitmask)
18035 {
18036 unsigned int bit = bitmask & (- bitmask);
18037
18038 bitmask &= ~ bit;
18039 switch (bit)
18040 {
18041 case GNU_PROPERTY_X86_FEATURE_2_X86:
18042 printf ("x86");
18043 break;
18044 case GNU_PROPERTY_X86_FEATURE_2_X87:
18045 printf ("x87");
18046 break;
18047 case GNU_PROPERTY_X86_FEATURE_2_MMX:
18048 printf ("MMX");
18049 break;
18050 case GNU_PROPERTY_X86_FEATURE_2_XMM:
18051 printf ("XMM");
18052 break;
18053 case GNU_PROPERTY_X86_FEATURE_2_YMM:
18054 printf ("YMM");
18055 break;
18056 case GNU_PROPERTY_X86_FEATURE_2_ZMM:
18057 printf ("ZMM");
18058 break;
18059 case GNU_PROPERTY_X86_FEATURE_2_FXSR:
18060 printf ("FXSR");
18061 break;
18062 case GNU_PROPERTY_X86_FEATURE_2_XSAVE:
18063 printf ("XSAVE");
18064 break;
18065 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT:
18066 printf ("XSAVEOPT");
18067 break;
18068 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC:
18069 printf ("XSAVEC");
18070 break;
18071 default:
18072 printf (_("<unknown: %x>"), bit);
18073 break;
18074 }
18075 if (bitmask)
18076 printf (", ");
18077 }
18078}
18079
18080static void
18081decode_aarch64_feature_1_and (unsigned int bitmask)
18082{
18083 while (bitmask)
18084 {
18085 unsigned int bit = bitmask & (- bitmask);
18086
18087 bitmask &= ~ bit;
18088 switch (bit)
18089 {
18090 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI:
18091 printf ("BTI");
18092 break;
18093
18094 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC:
18095 printf ("PAC");
18096 break;
18097
18098 default:
18099 printf (_("<unknown: %x>"), bit);
18100 break;
18101 }
18102 if (bitmask)
18103 printf (", ");
18104 }
18105}
18106
18107static void
18108print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
18109{
18110 unsigned char * ptr = (unsigned char *) pnote->descdata;
18111 unsigned char * ptr_end = ptr + pnote->descsz;
18112 unsigned int size = is_32bit_elf ? 4 : 8;
18113
18114 printf (_(" Properties: "));
18115
18116 if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
18117 {
18118 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
18119 return;
18120 }
18121
18122 while (ptr < ptr_end)
18123 {
18124 unsigned int j;
18125 unsigned int type;
18126 unsigned int datasz;
18127
18128 if ((size_t) (ptr_end - ptr) < 8)
18129 {
18130 printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
18131 break;
18132 }
18133
18134 type = byte_get (ptr, 4);
18135 datasz = byte_get (ptr + 4, 4);
18136
18137 ptr += 8;
18138
18139 if (datasz > (size_t) (ptr_end - ptr))
18140 {
18141 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
18142 type, datasz);
18143 break;
18144 }
18145
18146 if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
18147 {
18148 if (filedata->file_header.e_machine == EM_X86_64
18149 || filedata->file_header.e_machine == EM_IAMCU
18150 || filedata->file_header.e_machine == EM_386)
18151 {
18152 unsigned int bitmask;
18153
18154 if (datasz == 4)
18155 bitmask = byte_get (ptr, 4);
18156 else
18157 bitmask = 0;
18158
18159 switch (type)
18160 {
18161 case GNU_PROPERTY_X86_ISA_1_USED:
18162 if (datasz != 4)
18163 printf (_("x86 ISA used: <corrupt length: %#x> "),
18164 datasz);
18165 else
18166 {
18167 printf ("x86 ISA used: ");
18168 decode_x86_isa (bitmask);
18169 }
18170 goto next;
18171
18172 case GNU_PROPERTY_X86_ISA_1_NEEDED:
18173 if (datasz != 4)
18174 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18175 datasz);
18176 else
18177 {
18178 printf ("x86 ISA needed: ");
18179 decode_x86_isa (bitmask);
18180 }
18181 goto next;
18182
18183 case GNU_PROPERTY_X86_FEATURE_1_AND:
18184 if (datasz != 4)
18185 printf (_("x86 feature: <corrupt length: %#x> "),
18186 datasz);
18187 else
18188 {
18189 printf ("x86 feature: ");
18190 decode_x86_feature_1 (bitmask);
18191 }
18192 goto next;
18193
18194 case GNU_PROPERTY_X86_FEATURE_2_USED:
18195 if (datasz != 4)
18196 printf (_("x86 feature used: <corrupt length: %#x> "),
18197 datasz);
18198 else
18199 {
18200 printf ("x86 feature used: ");
18201 decode_x86_feature_2 (bitmask);
18202 }
18203 goto next;
18204
18205 case GNU_PROPERTY_X86_FEATURE_2_NEEDED:
18206 if (datasz != 4)
18207 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz);
18208 else
18209 {
18210 printf ("x86 feature needed: ");
18211 decode_x86_feature_2 (bitmask);
18212 }
18213 goto next;
18214
18215 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED:
18216 if (datasz != 4)
18217 printf (_("x86 ISA used: <corrupt length: %#x> "),
18218 datasz);
18219 else
18220 {
18221 printf ("x86 ISA used: ");
18222 decode_x86_compat_isa (bitmask);
18223 }
18224 goto next;
18225
18226 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED:
18227 if (datasz != 4)
18228 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18229 datasz);
18230 else
18231 {
18232 printf ("x86 ISA needed: ");
18233 decode_x86_compat_isa (bitmask);
18234 }
18235 goto next;
18236
18237 default:
18238 break;
18239 }
18240 }
18241 else if (filedata->file_header.e_machine == EM_AARCH64)
18242 {
18243 if (type == GNU_PROPERTY_AARCH64_FEATURE_1_AND)
18244 {
18245 printf ("AArch64 feature: ");
18246 if (datasz != 4)
18247 printf (_("<corrupt length: %#x> "), datasz);
18248 else
18249 decode_aarch64_feature_1_and (byte_get (ptr, 4));
18250 goto next;
18251 }
18252 }
18253 }
18254 else
18255 {
18256 switch (type)
18257 {
18258 case GNU_PROPERTY_STACK_SIZE:
18259 printf (_("stack size: "));
18260 if (datasz != size)
18261 printf (_("<corrupt length: %#x> "), datasz);
18262 else
18263 printf ("%#lx", (unsigned long) byte_get (ptr, size));
18264 goto next;
18265
18266 case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
18267 printf ("no copy on protected ");
18268 if (datasz)
18269 printf (_("<corrupt length: %#x> "), datasz);
18270 goto next;
18271
18272 default:
18273 break;
18274 }
18275 }
18276
18277 if (type < GNU_PROPERTY_LOPROC)
18278 printf (_("<unknown type %#x data: "), type);
18279 else if (type < GNU_PROPERTY_LOUSER)
18280 printf (_("<procesor-specific type %#x data: "), type);
18281 else
18282 printf (_("<application-specific type %#x data: "), type);
18283 for (j = 0; j < datasz; ++j)
18284 printf ("%02x ", ptr[j] & 0xff);
18285 printf (">");
18286
18287 next:
18288 ptr += ((datasz + (size - 1)) & ~ (size - 1));
18289 if (ptr == ptr_end)
18290 break;
18291
18292 if (do_wide)
18293 printf (", ");
18294 else
18295 printf ("\n\t");
18296 }
18297
18298 printf ("\n");
18299}
18300
18301static bfd_boolean
18302print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
18303{
18304 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
18305 switch (pnote->type)
18306 {
18307 case NT_GNU_BUILD_ID:
18308 {
18309 unsigned long i;
18310
18311 printf (_(" Build ID: "));
18312 for (i = 0; i < pnote->descsz; ++i)
18313 printf ("%02x", pnote->descdata[i] & 0xff);
18314 printf ("\n");
18315 }
18316 break;
18317
18318 case NT_GNU_ABI_TAG:
18319 {
18320 unsigned long os, major, minor, subminor;
18321 const char *osname;
18322
18323 /* PR 17531: file: 030-599401-0.004. */
18324 if (pnote->descsz < 16)
18325 {
18326 printf (_(" <corrupt GNU_ABI_TAG>\n"));
18327 break;
18328 }
18329
18330 os = byte_get ((unsigned char *) pnote->descdata, 4);
18331 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
18332 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
18333 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
18334
18335 switch (os)
18336 {
18337 case GNU_ABI_TAG_LINUX:
18338 osname = "Linux";
18339 break;
18340 case GNU_ABI_TAG_HURD:
18341 osname = "Hurd";
18342 break;
18343 case GNU_ABI_TAG_SOLARIS:
18344 osname = "Solaris";
18345 break;
18346 case GNU_ABI_TAG_FREEBSD:
18347 osname = "FreeBSD";
18348 break;
18349 case GNU_ABI_TAG_NETBSD:
18350 osname = "NetBSD";
18351 break;
18352 case GNU_ABI_TAG_SYLLABLE:
18353 osname = "Syllable";
18354 break;
18355 case GNU_ABI_TAG_NACL:
18356 osname = "NaCl";
18357 break;
18358 default:
18359 osname = "Unknown";
18360 break;
18361 }
18362
18363 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
18364 major, minor, subminor);
18365 }
18366 break;
18367
18368 case NT_GNU_GOLD_VERSION:
18369 {
18370 unsigned long i;
18371
18372 printf (_(" Version: "));
18373 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
18374 printf ("%c", pnote->descdata[i]);
18375 printf ("\n");
18376 }
18377 break;
18378
18379 case NT_GNU_HWCAP:
18380 {
18381 unsigned long num_entries, mask;
18382
18383 /* Hardware capabilities information. Word 0 is the number of entries.
18384 Word 1 is a bitmask of enabled entries. The rest of the descriptor
18385 is a series of entries, where each entry is a single byte followed
18386 by a nul terminated string. The byte gives the bit number to test
18387 if enabled in the bitmask. */
18388 printf (_(" Hardware Capabilities: "));
18389 if (pnote->descsz < 8)
18390 {
18391 error (_("<corrupt GNU_HWCAP>\n"));
18392 return FALSE;
18393 }
18394 num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
18395 mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
18396 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
18397 /* FIXME: Add code to display the entries... */
18398 }
18399 break;
18400
18401 case NT_GNU_PROPERTY_TYPE_0:
18402 print_gnu_property_note (filedata, pnote);
18403 break;
18404
18405 default:
18406 /* Handle unrecognised types. An error message should have already been
18407 created by get_gnu_elf_note_type(), so all that we need to do is to
18408 display the data. */
18409 {
18410 unsigned long i;
18411
18412 printf (_(" Description data: "));
18413 for (i = 0; i < pnote->descsz; ++i)
18414 printf ("%02x ", pnote->descdata[i] & 0xff);
18415 printf ("\n");
18416 }
18417 break;
18418 }
18419
18420 return TRUE;
18421}
18422
18423static const char *
18424get_v850_elf_note_type (enum v850_notes n_type)
18425{
18426 static char buff[64];
18427
18428 switch (n_type)
18429 {
18430 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
18431 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
18432 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
18433 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
18434 case V850_NOTE_CACHE_INFO: return _("Use of cache");
18435 case V850_NOTE_MMU_INFO: return _("Use of MMU");
18436 default:
18437 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
18438 return buff;
18439 }
18440}
18441
18442static bfd_boolean
18443print_v850_note (Elf_Internal_Note * pnote)
18444{
18445 unsigned int val;
18446
18447 if (pnote->descsz != 4)
18448 return FALSE;
18449
18450 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
18451
18452 if (val == 0)
18453 {
18454 printf (_("not set\n"));
18455 return TRUE;
18456 }
18457
18458 switch (pnote->type)
18459 {
18460 case V850_NOTE_ALIGNMENT:
18461 switch (val)
18462 {
18463 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
18464 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
18465 }
18466 break;
18467
18468 case V850_NOTE_DATA_SIZE:
18469 switch (val)
18470 {
18471 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
18472 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
18473 }
18474 break;
18475
18476 case V850_NOTE_FPU_INFO:
18477 switch (val)
18478 {
18479 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
18480 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
18481 }
18482 break;
18483
18484 case V850_NOTE_MMU_INFO:
18485 case V850_NOTE_CACHE_INFO:
18486 case V850_NOTE_SIMD_INFO:
18487 if (val == EF_RH850_SIMD)
18488 {
18489 printf (_("yes\n"));
18490 return TRUE;
18491 }
18492 break;
18493
18494 default:
18495 /* An 'unknown note type' message will already have been displayed. */
18496 break;
18497 }
18498
18499 printf (_("unknown value: %x\n"), val);
18500 return FALSE;
18501}
18502
18503static bfd_boolean
18504process_netbsd_elf_note (Elf_Internal_Note * pnote)
18505{
18506 unsigned int version;
18507
18508 switch (pnote->type)
18509 {
18510 case NT_NETBSD_IDENT:
18511 if (pnote->descsz < 1)
18512 break;
18513 version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
18514 if ((version / 10000) % 100)
18515 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
18516 version, version / 100000000, (version / 1000000) % 100,
18517 (version / 10000) % 100 > 26 ? "Z" : "",
18518 'A' + (version / 10000) % 26);
18519 else
18520 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
18521 version, version / 100000000, (version / 1000000) % 100,
18522 (version / 100) % 100);
18523 return TRUE;
18524
18525 case NT_NETBSD_MARCH:
18526 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
18527 pnote->descdata);
18528 return TRUE;
18529
18530#ifdef NT_NETBSD_PAX
18531 case NT_NETBSD_PAX:
18532 if (pnote->descsz < 1)
18533 break;
18534 version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
18535 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote->descsz,
18536 ((version & NT_NETBSD_PAX_MPROTECT) ? "+mprotect" : ""),
18537 ((version & NT_NETBSD_PAX_NOMPROTECT) ? "-mprotect" : ""),
18538 ((version & NT_NETBSD_PAX_GUARD) ? "+guard" : ""),
18539 ((version & NT_NETBSD_PAX_NOGUARD) ? "-guard" : ""),
18540 ((version & NT_NETBSD_PAX_ASLR) ? "+ASLR" : ""),
18541 ((version & NT_NETBSD_PAX_NOASLR) ? "-ASLR" : ""));
18542 return TRUE;
18543#endif
18544 }
18545
18546 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
18547 pnote->descsz, pnote->type);
18548 return FALSE;
18549}
18550
18551static const char *
18552get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
18553{
18554 switch (e_type)
18555 {
18556 case NT_FREEBSD_THRMISC:
18557 return _("NT_THRMISC (thrmisc structure)");
18558 case NT_FREEBSD_PROCSTAT_PROC:
18559 return _("NT_PROCSTAT_PROC (proc data)");
18560 case NT_FREEBSD_PROCSTAT_FILES:
18561 return _("NT_PROCSTAT_FILES (files data)");
18562 case NT_FREEBSD_PROCSTAT_VMMAP:
18563 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18564 case NT_FREEBSD_PROCSTAT_GROUPS:
18565 return _("NT_PROCSTAT_GROUPS (groups data)");
18566 case NT_FREEBSD_PROCSTAT_UMASK:
18567 return _("NT_PROCSTAT_UMASK (umask data)");
18568 case NT_FREEBSD_PROCSTAT_RLIMIT:
18569 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18570 case NT_FREEBSD_PROCSTAT_OSREL:
18571 return _("NT_PROCSTAT_OSREL (osreldate data)");
18572 case NT_FREEBSD_PROCSTAT_PSSTRINGS:
18573 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18574 case NT_FREEBSD_PROCSTAT_AUXV:
18575 return _("NT_PROCSTAT_AUXV (auxv data)");
18576 case NT_FREEBSD_PTLWPINFO:
18577 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18578 }
18579 return get_note_type (filedata, e_type);
18580}
18581
18582static const char *
18583get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
18584{
18585 static char buff[64];
18586
18587 switch (e_type)
18588 {
18589 case NT_NETBSDCORE_PROCINFO:
18590 /* NetBSD core "procinfo" structure. */
18591 return _("NetBSD procinfo structure");
18592
18593#ifdef NT_NETBSDCORE_AUXV
18594 case NT_NETBSDCORE_AUXV:
18595 return _("NetBSD ELF auxiliary vector data");
18596#endif
18597
18598#ifdef NT_NETBSDCORE_LWPSTATUS
18599 case NT_NETBSDCORE_LWPSTATUS:
18600 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
18601#endif
18602
18603 default:
18604 /* As of Jan 2020 there are no other machine-independent notes
18605 defined for NetBSD core files. If the note type is less
18606 than the start of the machine-dependent note types, we don't
18607 understand it. */
18608
18609 if (e_type < NT_NETBSDCORE_FIRSTMACH)
18610 {
18611 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18612 return buff;
18613 }
18614 break;
18615 }
18616
18617 switch (filedata->file_header.e_machine)
18618 {
18619 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18620 and PT_GETFPREGS == mach+2. */
18621
18622 case EM_OLD_ALPHA:
18623 case EM_ALPHA:
18624 case EM_SPARC:
18625 case EM_SPARC32PLUS:
18626 case EM_SPARCV9:
18627 switch (e_type)
18628 {
18629 case NT_NETBSDCORE_FIRSTMACH + 0:
18630 return _("PT_GETREGS (reg structure)");
18631 case NT_NETBSDCORE_FIRSTMACH + 2:
18632 return _("PT_GETFPREGS (fpreg structure)");
18633 default:
18634 break;
18635 }
18636 break;
18637
18638 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18639 There's also old PT___GETREGS40 == mach + 1 for old reg
18640 structure which lacks GBR. */
18641 case EM_SH:
18642 switch (e_type)
18643 {
18644 case NT_NETBSDCORE_FIRSTMACH + 1:
18645 return _("PT___GETREGS40 (old reg structure)");
18646 case NT_NETBSDCORE_FIRSTMACH + 3:
18647 return _("PT_GETREGS (reg structure)");
18648 case NT_NETBSDCORE_FIRSTMACH + 5:
18649 return _("PT_GETFPREGS (fpreg structure)");
18650 default:
18651 break;
18652 }
18653 break;
18654
18655 /* On all other arch's, PT_GETREGS == mach+1 and
18656 PT_GETFPREGS == mach+3. */
18657 default:
18658 switch (e_type)
18659 {
18660 case NT_NETBSDCORE_FIRSTMACH + 1:
18661 return _("PT_GETREGS (reg structure)");
18662 case NT_NETBSDCORE_FIRSTMACH + 3:
18663 return _("PT_GETFPREGS (fpreg structure)");
18664 default:
18665 break;
18666 }
18667 }
18668
18669 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
18670 e_type - NT_NETBSDCORE_FIRSTMACH);
18671 return buff;
18672}
18673
18674static const char *
18675get_stapsdt_note_type (unsigned e_type)
18676{
18677 static char buff[64];
18678
18679 switch (e_type)
18680 {
18681 case NT_STAPSDT:
18682 return _("NT_STAPSDT (SystemTap probe descriptors)");
18683
18684 default:
18685 break;
18686 }
18687
18688 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18689 return buff;
18690}
18691
18692static bfd_boolean
18693print_stapsdt_note (Elf_Internal_Note *pnote)
18694{
18695 size_t len, maxlen;
18696 unsigned long addr_size = is_32bit_elf ? 4 : 8;
18697 char *data = pnote->descdata;
18698 char *data_end = pnote->descdata + pnote->descsz;
18699 bfd_vma pc, base_addr, semaphore;
18700 char *provider, *probe, *arg_fmt;
18701
18702 if (pnote->descsz < (addr_size * 3))
18703 goto stapdt_note_too_small;
18704
18705 pc = byte_get ((unsigned char *) data, addr_size);
18706 data += addr_size;
18707
18708 base_addr = byte_get ((unsigned char *) data, addr_size);
18709 data += addr_size;
18710
18711 semaphore = byte_get ((unsigned char *) data, addr_size);
18712 data += addr_size;
18713
18714 if (data >= data_end)
18715 goto stapdt_note_too_small;
18716 maxlen = data_end - data;
18717 len = strnlen (data, maxlen);
18718 if (len < maxlen)
18719 {
18720 provider = data;
18721 data += len + 1;
18722 }
18723 else
18724 goto stapdt_note_too_small;
18725
18726 if (data >= data_end)
18727 goto stapdt_note_too_small;
18728 maxlen = data_end - data;
18729 len = strnlen (data, maxlen);
18730 if (len < maxlen)
18731 {
18732 probe = data;
18733 data += len + 1;
18734 }
18735 else
18736 goto stapdt_note_too_small;
18737
18738 if (data >= data_end)
18739 goto stapdt_note_too_small;
18740 maxlen = data_end - data;
18741 len = strnlen (data, maxlen);
18742 if (len < maxlen)
18743 {
18744 arg_fmt = data;
18745 data += len + 1;
18746 }
18747 else
18748 goto stapdt_note_too_small;
18749
18750 printf (_(" Provider: %s\n"), provider);
18751 printf (_(" Name: %s\n"), probe);
18752 printf (_(" Location: "));
18753 print_vma (pc, FULL_HEX);
18754 printf (_(", Base: "));
18755 print_vma (base_addr, FULL_HEX);
18756 printf (_(", Semaphore: "));
18757 print_vma (semaphore, FULL_HEX);
18758 printf ("\n");
18759 printf (_(" Arguments: %s\n"), arg_fmt);
18760
18761 return data == data_end;
18762
18763 stapdt_note_too_small:
18764 printf (_(" <corrupt - note is too small>\n"));
18765 error (_("corrupt stapdt note - the data size is too small\n"));
18766 return FALSE;
18767}
18768
18769static const char *
18770get_ia64_vms_note_type (unsigned e_type)
18771{
18772 static char buff[64];
18773
18774 switch (e_type)
18775 {
18776 case NT_VMS_MHD:
18777 return _("NT_VMS_MHD (module header)");
18778 case NT_VMS_LNM:
18779 return _("NT_VMS_LNM (language name)");
18780 case NT_VMS_SRC:
18781 return _("NT_VMS_SRC (source files)");
18782 case NT_VMS_TITLE:
18783 return "NT_VMS_TITLE";
18784 case NT_VMS_EIDC:
18785 return _("NT_VMS_EIDC (consistency check)");
18786 case NT_VMS_FPMODE:
18787 return _("NT_VMS_FPMODE (FP mode)");
18788 case NT_VMS_LINKTIME:
18789 return "NT_VMS_LINKTIME";
18790 case NT_VMS_IMGNAM:
18791 return _("NT_VMS_IMGNAM (image name)");
18792 case NT_VMS_IMGID:
18793 return _("NT_VMS_IMGID (image id)");
18794 case NT_VMS_LINKID:
18795 return _("NT_VMS_LINKID (link id)");
18796 case NT_VMS_IMGBID:
18797 return _("NT_VMS_IMGBID (build id)");
18798 case NT_VMS_GSTNAM:
18799 return _("NT_VMS_GSTNAM (sym table name)");
18800 case NT_VMS_ORIG_DYN:
18801 return "NT_VMS_ORIG_DYN";
18802 case NT_VMS_PATCHTIME:
18803 return "NT_VMS_PATCHTIME";
18804 default:
18805 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18806 return buff;
18807 }
18808}
18809
18810static bfd_boolean
18811print_ia64_vms_note (Elf_Internal_Note * pnote)
18812{
18813 int maxlen = pnote->descsz;
18814
18815 if (maxlen < 2 || (unsigned long) maxlen != pnote->descsz)
18816 goto desc_size_fail;
18817
18818 switch (pnote->type)
18819 {
18820 case NT_VMS_MHD:
18821 if (maxlen <= 36)
18822 goto desc_size_fail;
18823
18824 int l = (int) strnlen (pnote->descdata + 34, maxlen - 34);
18825
18826 printf (_(" Creation date : %.17s\n"), pnote->descdata);
18827 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
18828 if (l + 34 < maxlen)
18829 {
18830 printf (_(" Module name : %s\n"), pnote->descdata + 34);
18831 if (l + 35 < maxlen)
18832 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
18833 else
18834 printf (_(" Module version : <missing>\n"));
18835 }
18836 else
18837 {
18838 printf (_(" Module name : <missing>\n"));
18839 printf (_(" Module version : <missing>\n"));
18840 }
18841 break;
18842
18843 case NT_VMS_LNM:
18844 printf (_(" Language: %.*s\n"), maxlen, pnote->descdata);
18845 break;
18846
18847#ifdef BFD64
18848 case NT_VMS_FPMODE:
18849 printf (_(" Floating Point mode: "));
18850 if (maxlen < 8)
18851 goto desc_size_fail;
18852 /* FIXME: Generate an error if descsz > 8 ? */
18853
18854 printf ("0x%016" BFD_VMA_FMT "x\n",
18855 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
18856 break;
18857
18858 case NT_VMS_LINKTIME:
18859 printf (_(" Link time: "));
18860 if (maxlen < 8)
18861 goto desc_size_fail;
18862 /* FIXME: Generate an error if descsz > 8 ? */
18863
18864 print_vms_time
18865 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
18866 printf ("\n");
18867 break;
18868
18869 case NT_VMS_PATCHTIME:
18870 printf (_(" Patch time: "));
18871 if (maxlen < 8)
18872 goto desc_size_fail;
18873 /* FIXME: Generate an error if descsz > 8 ? */
18874
18875 print_vms_time
18876 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
18877 printf ("\n");
18878 break;
18879
18880 case NT_VMS_ORIG_DYN:
18881 if (maxlen < 34)
18882 goto desc_size_fail;
18883
18884 printf (_(" Major id: %u, minor id: %u\n"),
18885 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
18886 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
18887 printf (_(" Last modified : "));
18888 print_vms_time
18889 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
18890 printf (_("\n Link flags : "));
18891 printf ("0x%016" BFD_VMA_FMT "x\n",
18892 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
18893 printf (_(" Header flags: 0x%08x\n"),
18894 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
18895 printf (_(" Image id : %.*s\n"), maxlen - 32, pnote->descdata + 32);
18896 break;
18897#endif
18898
18899 case NT_VMS_IMGNAM:
18900 printf (_(" Image name: %.*s\n"), maxlen, pnote->descdata);
18901 break;
18902
18903 case NT_VMS_GSTNAM:
18904 printf (_(" Global symbol table name: %.*s\n"), maxlen, pnote->descdata);
18905 break;
18906
18907 case NT_VMS_IMGID:
18908 printf (_(" Image id: %.*s\n"), maxlen, pnote->descdata);
18909 break;
18910
18911 case NT_VMS_LINKID:
18912 printf (_(" Linker id: %.*s\n"), maxlen, pnote->descdata);
18913 break;
18914
18915 default:
18916 return FALSE;
18917 }
18918
18919 return TRUE;
18920
18921 desc_size_fail:
18922 printf (_(" <corrupt - data size is too small>\n"));
18923 error (_("corrupt IA64 note: data size is too small\n"));
18924 return FALSE;
18925}
18926
18927struct build_attr_cache {
18928 Filedata *filedata;
18929 char *strtab;
18930 unsigned long strtablen;
18931 Elf_Internal_Sym *symtab;
18932 unsigned long nsyms;
18933} ba_cache;
18934
18935/* Find the symbol associated with a build attribute that is attached
18936 to address OFFSET. If PNAME is non-NULL then store the name of
18937 the symbol (if found) in the provided pointer, Returns NULL if a
18938 symbol could not be found. */
18939
18940static Elf_Internal_Sym *
18941get_symbol_for_build_attribute (Filedata * filedata,
18942 unsigned long offset,
18943 bfd_boolean is_open_attr,
18944 const char ** pname)
18945{
18946 Elf_Internal_Sym *saved_sym = NULL;
18947 Elf_Internal_Sym *sym;
18948
18949 if (filedata->section_headers != NULL
18950 && (ba_cache.filedata == NULL || filedata != ba_cache.filedata))
18951 {
18952 Elf_Internal_Shdr * symsec;
18953
18954 free (ba_cache.strtab);
18955 ba_cache.strtab = NULL;
18956 free (ba_cache.symtab);
18957 ba_cache.symtab = NULL;
18958
18959 /* Load the symbol and string sections. */
18960 for (symsec = filedata->section_headers;
18961 symsec < filedata->section_headers + filedata->file_header.e_shnum;
18962 symsec ++)
18963 {
18964 if (symsec->sh_type == SHT_SYMTAB
18965 && get_symtab (filedata, symsec,
18966 &ba_cache.symtab, &ba_cache.nsyms,
18967 &ba_cache.strtab, &ba_cache.strtablen))
18968 break;
18969 }
18970 ba_cache.filedata = filedata;
18971 }
18972
18973 if (ba_cache.symtab == NULL)
18974 return NULL;
18975
18976 /* Find a symbol whose value matches offset. */
18977 for (sym = ba_cache.symtab; sym < ba_cache.symtab + ba_cache.nsyms; sym ++)
18978 if (sym->st_value == offset)
18979 {
18980 if (sym->st_name >= ba_cache.strtablen)
18981 /* Huh ? This should not happen. */
18982 continue;
18983
18984 if (ba_cache.strtab[sym->st_name] == 0)
18985 continue;
18986
18987 /* The AArch64 and ARM architectures define mapping symbols
18988 (eg $d, $x, $t) which we want to ignore. */
18989 if (ba_cache.strtab[sym->st_name] == '$'
18990 && ba_cache.strtab[sym->st_name + 1] != 0
18991 && ba_cache.strtab[sym->st_name + 2] == 0)
18992 continue;
18993
18994 if (is_open_attr)
18995 {
18996 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
18997 and FILE or OBJECT symbols over NOTYPE symbols. We skip
18998 FUNC symbols entirely. */
18999 switch (ELF_ST_TYPE (sym->st_info))
19000 {
19001 case STT_OBJECT:
19002 case STT_FILE:
19003 saved_sym = sym;
19004 if (sym->st_size)
19005 {
19006 /* If the symbol has a size associated
19007 with it then we can stop searching. */
19008 sym = ba_cache.symtab + ba_cache.nsyms;
19009 }
19010 continue;
19011
19012 case STT_FUNC:
19013 /* Ignore function symbols. */
19014 continue;
19015
19016 default:
19017 break;
19018 }
19019
19020 switch (ELF_ST_BIND (sym->st_info))
19021 {
19022 case STB_GLOBAL:
19023 if (saved_sym == NULL
19024 || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
19025 saved_sym = sym;
19026 break;
19027
19028 case STB_LOCAL:
19029 if (saved_sym == NULL)
19030 saved_sym = sym;
19031 break;
19032
19033 default:
19034 break;
19035 }
19036 }
19037 else
19038 {
19039 if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
19040 continue;
19041
19042 saved_sym = sym;
19043 break;
19044 }
19045 }
19046
19047 if (saved_sym && pname)
19048 * pname = ba_cache.strtab + saved_sym->st_name;
19049
19050 return saved_sym;
19051}
19052
19053/* Returns true iff addr1 and addr2 are in the same section. */
19054
19055static bfd_boolean
19056same_section (Filedata * filedata, unsigned long addr1, unsigned long addr2)
19057{
19058 Elf_Internal_Shdr * a1;
19059 Elf_Internal_Shdr * a2;
19060
19061 a1 = find_section_by_address (filedata, addr1);
19062 a2 = find_section_by_address (filedata, addr2);
19063
19064 return a1 == a2 && a1 != NULL;
19065}
19066
19067static bfd_boolean
19068print_gnu_build_attribute_description (Elf_Internal_Note * pnote,
19069 Filedata * filedata)
19070{
19071 static unsigned long global_offset = 0;
19072 static unsigned long global_end = 0;
19073 static unsigned long func_offset = 0;
19074 static unsigned long func_end = 0;
19075
19076 Elf_Internal_Sym * sym;
19077 const char * name;
19078 unsigned long start;
19079 unsigned long end;
19080 bfd_boolean is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
19081
19082 switch (pnote->descsz)
19083 {
19084 case 0:
19085 /* A zero-length description means that the range of
19086 the previous note of the same type should be used. */
19087 if (is_open_attr)
19088 {
19089 if (global_end > global_offset)
19090 printf (_(" Applies to region from %#lx to %#lx\n"),
19091 global_offset, global_end);
19092 else
19093 printf (_(" Applies to region from %#lx\n"), global_offset);
19094 }
19095 else
19096 {
19097 if (func_end > func_offset)
19098 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset, func_end);
19099 else
19100 printf (_(" Applies to region from %#lx\n"), func_offset);
19101 }
19102 return TRUE;
19103
19104 case 4:
19105 start = byte_get ((unsigned char *) pnote->descdata, 4);
19106 end = 0;
19107 break;
19108
19109 case 8:
19110 if (is_32bit_elf)
19111 {
19112 /* FIXME: We should check that version 3+ notes are being used here... */
19113 start = byte_get ((unsigned char *) pnote->descdata, 4);
19114 end = byte_get ((unsigned char *) pnote->descdata + 4, 4);
19115 }
19116 else
19117 {
19118 start = byte_get ((unsigned char *) pnote->descdata, 8);
19119 end = 0;
19120 }
19121 break;
19122
19123 case 16:
19124 start = byte_get ((unsigned char *) pnote->descdata, 8);
19125 end = byte_get ((unsigned char *) pnote->descdata + 8, 8);
19126 break;
19127
19128 default:
19129 error (_(" <invalid description size: %lx>\n"), pnote->descsz);
19130 printf (_(" <invalid descsz>"));
19131 return FALSE;
19132 }
19133
19134 name = NULL;
19135 sym = get_symbol_for_build_attribute (filedata, start, is_open_attr, & name);
19136 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
19137 in order to avoid them being confused with the start address of the
19138 first function in the file... */
19139 if (sym == NULL && is_open_attr)
19140 sym = get_symbol_for_build_attribute (filedata, start + 2, is_open_attr,
19141 & name);
19142
19143 if (end == 0 && sym != NULL && sym->st_size > 0)
19144 end = start + sym->st_size;
19145
19146 if (is_open_attr)
19147 {
19148 /* FIXME: Need to properly allow for section alignment.
19149 16 is just the alignment used on x86_64. */
19150 if (global_end > 0
19151 && start > BFD_ALIGN (global_end, 16)
19152 /* Build notes are not guaranteed to be organised in order of
19153 increasing address, but we should find the all of the notes
19154 for one section in the same place. */
19155 && same_section (filedata, start, global_end))
19156 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
19157 global_end + 1, start - 1);
19158
19159 printf (_(" Applies to region from %#lx"), start);
19160 global_offset = start;
19161
19162 if (end)
19163 {
19164 printf (_(" to %#lx"), end);
19165 global_end = end;
19166 }
19167 }
19168 else
19169 {
19170 printf (_(" Applies to region from %#lx"), start);
19171 func_offset = start;
19172
19173 if (end)
19174 {
19175 printf (_(" to %#lx"), end);
19176 func_end = end;
19177 }
19178 }
19179
19180 if (sym && name)
19181 printf (_(" (%s)"), name);
19182
19183 printf ("\n");
19184 return TRUE;
19185}
19186
19187static bfd_boolean
19188print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
19189{
19190 static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
19191 static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
19192 static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
19193 char name_type;
19194 char name_attribute;
19195 const char * expected_types;
19196 const char * name = pnote->namedata;
19197 const char * text;
19198 signed int left;
19199
19200 if (name == NULL || pnote->namesz < 2)
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 if (do_wide)
19208 left = 28;
19209 else
19210 left = 20;
19211
19212 /* Version 2 of the spec adds a "GA" prefix to the name field. */
19213 if (name[0] == 'G' && name[1] == 'A')
19214 {
19215 if (pnote->namesz < 4)
19216 {
19217 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
19218 print_symbol (-20, _(" <corrupt name>"));
19219 return FALSE;
19220 }
19221
19222 printf ("GA");
19223 name += 2;
19224 left -= 2;
19225 }
19226
19227 switch ((name_type = * name))
19228 {
19229 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
19230 case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
19231 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
19232 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
19233 printf ("%c", * name);
19234 left --;
19235 break;
19236 default:
19237 error (_("unrecognised attribute type in name field: %d\n"), name_type);
19238 print_symbol (-20, _("<unknown name type>"));
19239 return FALSE;
19240 }
19241
19242 ++ name;
19243 text = NULL;
19244
19245 switch ((name_attribute = * name))
19246 {
19247 case GNU_BUILD_ATTRIBUTE_VERSION:
19248 text = _("<version>");
19249 expected_types = string_expected;
19250 ++ name;
19251 break;
19252 case GNU_BUILD_ATTRIBUTE_STACK_PROT:
19253 text = _("<stack prot>");
19254 expected_types = "!+*";
19255 ++ name;
19256 break;
19257 case GNU_BUILD_ATTRIBUTE_RELRO:
19258 text = _("<relro>");
19259 expected_types = bool_expected;
19260 ++ name;
19261 break;
19262 case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
19263 text = _("<stack size>");
19264 expected_types = number_expected;
19265 ++ name;
19266 break;
19267 case GNU_BUILD_ATTRIBUTE_TOOL:
19268 text = _("<tool>");
19269 expected_types = string_expected;
19270 ++ name;
19271 break;
19272 case GNU_BUILD_ATTRIBUTE_ABI:
19273 text = _("<ABI>");
19274 expected_types = "$*";
19275 ++ name;
19276 break;
19277 case GNU_BUILD_ATTRIBUTE_PIC:
19278 text = _("<PIC>");
19279 expected_types = number_expected;
19280 ++ name;
19281 break;
19282 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
19283 text = _("<short enum>");
19284 expected_types = bool_expected;
19285 ++ name;
19286 break;
19287 default:
19288 if (ISPRINT (* name))
19289 {
19290 int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
19291
19292 if (len > left && ! do_wide)
19293 len = left;
19294 printf ("%.*s:", len, name);
19295 left -= len;
19296 name += len;
19297 }
19298 else
19299 {
19300 static char tmpbuf [128];
19301
19302 error (_("unrecognised byte in name field: %d\n"), * name);
19303 sprintf (tmpbuf, _("<unknown:_%d>"), * name);
19304 text = tmpbuf;
19305 name ++;
19306 }
19307 expected_types = "*$!+";
19308 break;
19309 }
19310
19311 if (text)
19312 left -= printf ("%s", text);
19313
19314 if (strchr (expected_types, name_type) == NULL)
19315 warn (_("attribute does not have an expected type (%c)\n"), name_type);
19316
19317 if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
19318 {
19319 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
19320 (unsigned long) pnote->namesz,
19321 (long) (name - pnote->namedata));
19322 return FALSE;
19323 }
19324
19325 if (left < 1 && ! do_wide)
19326 return TRUE;
19327
19328 switch (name_type)
19329 {
19330 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
19331 {
19332 unsigned int bytes;
19333 unsigned long long val = 0;
19334 unsigned int shift = 0;
19335 char * decoded = NULL;
19336
19337 bytes = pnote->namesz - (name - pnote->namedata);
19338 if (bytes > 0)
19339 /* The -1 is because the name field is always 0 terminated, and we
19340 want to be able to ensure that the shift in the while loop below
19341 will not overflow. */
19342 -- bytes;
19343
19344 if (bytes > sizeof (val))
19345 {
19346 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
19347 bytes);
19348 bytes = sizeof (val);
19349 }
19350 /* We do not bother to warn if bytes == 0 as this can
19351 happen with some early versions of the gcc plugin. */
19352
19353 while (bytes --)
19354 {
19355 unsigned long byte = (* name ++) & 0xff;
19356
19357 val |= byte << shift;
19358 shift += 8;
19359 }
19360
19361 switch (name_attribute)
19362 {
19363 case GNU_BUILD_ATTRIBUTE_PIC:
19364 switch (val)
19365 {
19366 case 0: decoded = "static"; break;
19367 case 1: decoded = "pic"; break;
19368 case 2: decoded = "PIC"; break;
19369 case 3: decoded = "pie"; break;
19370 case 4: decoded = "PIE"; break;
19371 default: break;
19372 }
19373 break;
19374 case GNU_BUILD_ATTRIBUTE_STACK_PROT:
19375 switch (val)
19376 {
19377 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
19378 case 0: decoded = "off"; break;
19379 case 1: decoded = "on"; break;
19380 case 2: decoded = "all"; break;
19381 case 3: decoded = "strong"; break;
19382 case 4: decoded = "explicit"; break;
19383 default: break;
19384 }
19385 break;
19386 default:
19387 break;
19388 }
19389
19390 if (decoded != NULL)
19391 {
19392 print_symbol (-left, decoded);
19393 left = 0;
19394 }
19395 else if (val == 0)
19396 {
19397 printf ("0x0");
19398 left -= 3;
19399 }
19400 else
19401 {
19402 if (do_wide)
19403 left -= printf ("0x%llx", val);
19404 else
19405 left -= printf ("0x%-.*llx", left, val);
19406 }
19407 }
19408 break;
19409 case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
19410 left -= print_symbol (- left, name);
19411 break;
19412 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
19413 left -= print_symbol (- left, "true");
19414 break;
19415 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
19416 left -= print_symbol (- left, "false");
19417 break;
19418 }
19419
19420 if (do_wide && left > 0)
19421 printf ("%-*s", left, " ");
19422
19423 return TRUE;
19424}
19425
19426/* Note that by the ELF standard, the name field is already null byte
19427 terminated, and namesz includes the terminating null byte.
19428 I.E. the value of namesz for the name "FSF" is 4.
19429
19430 If the value of namesz is zero, there is no name present. */
19431
19432static bfd_boolean
19433process_note (Elf_Internal_Note * pnote,
19434 Filedata * filedata)
19435{
19436 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
19437 const char * nt;
19438
19439 if (pnote->namesz == 0)
19440 /* If there is no note name, then use the default set of
19441 note type strings. */
19442 nt = get_note_type (filedata, pnote->type);
19443
19444 else if (const_strneq (pnote->namedata, "GNU"))
19445 /* GNU-specific object file notes. */
19446 nt = get_gnu_elf_note_type (pnote->type);
19447
19448 else if (const_strneq (pnote->namedata, "FreeBSD"))
19449 /* FreeBSD-specific core file notes. */
19450 nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
19451
19452 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
19453 /* NetBSD-specific core file notes. */
19454 nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
19455
19456 else if (const_strneq (pnote->namedata, "NetBSD"))
19457 /* NetBSD-specific core file notes. */
19458 return process_netbsd_elf_note (pnote);
19459
19460 else if (const_strneq (pnote->namedata, "PaX"))
19461 /* NetBSD-specific core file notes. */
19462 return process_netbsd_elf_note (pnote);
19463
19464 else if (strneq (pnote->namedata, "SPU/", 4))
19465 {
19466 /* SPU-specific core file notes. */
19467 nt = pnote->namedata + 4;
19468 name = "SPU";
19469 }
19470
19471 else if (const_strneq (pnote->namedata, "IPF/VMS"))
19472 /* VMS/ia64-specific file notes. */
19473 nt = get_ia64_vms_note_type (pnote->type);
19474
19475 else if (const_strneq (pnote->namedata, "stapsdt"))
19476 nt = get_stapsdt_note_type (pnote->type);
19477
19478 else
19479 /* Don't recognize this note name; just use the default set of
19480 note type strings. */
19481 nt = get_note_type (filedata, pnote->type);
19482
19483 printf (" ");
19484
19485 if (((const_strneq (pnote->namedata, "GA")
19486 && strchr ("*$!+", pnote->namedata[2]) != NULL)
19487 || strchr ("*$!+", pnote->namedata[0]) != NULL)
19488 && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
19489 || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
19490 print_gnu_build_attribute_name (pnote);
19491 else
19492 print_symbol (-20, name);
19493
19494 if (do_wide)
19495 printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
19496 else
19497 printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
19498
19499 if (const_strneq (pnote->namedata, "IPF/VMS"))
19500 return print_ia64_vms_note (pnote);
19501 else if (const_strneq (pnote->namedata, "GNU"))
19502 return print_gnu_note (filedata, pnote);
19503 else if (const_strneq (pnote->namedata, "stapsdt"))
19504 return print_stapsdt_note (pnote);
19505 else if (const_strneq (pnote->namedata, "CORE"))
19506 return print_core_note (pnote);
19507 else if (((const_strneq (pnote->namedata, "GA")
19508 && strchr ("*$!+", pnote->namedata[2]) != NULL)
19509 || strchr ("*$!+", pnote->namedata[0]) != NULL)
19510 && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
19511 || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
19512 return print_gnu_build_attribute_description (pnote, filedata);
19513
19514 if (pnote->descsz)
19515 {
19516 unsigned long i;
19517
19518 printf (_(" description data: "));
19519 for (i = 0; i < pnote->descsz; i++)
19520 printf ("%02x ", pnote->descdata[i] & 0xff);
19521 if (!do_wide)
19522 printf ("\n");
19523 }
19524
19525 if (do_wide)
19526 printf ("\n");
19527
19528 return TRUE;
19529}
19530
19531static bfd_boolean
19532process_notes_at (Filedata * filedata,
19533 Elf_Internal_Shdr * section,
19534 bfd_vma offset,
19535 bfd_vma length,
19536 bfd_vma align)
19537{
19538 Elf_External_Note * pnotes;
19539 Elf_External_Note * external;
19540 char * end;
19541 bfd_boolean res = TRUE;
19542
19543 if (length <= 0)
19544 return FALSE;
19545
19546 if (section)
19547 {
19548 pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
19549 if (pnotes)
19550 {
19551 if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
19552 {
19553 free (pnotes);
19554 return FALSE;
19555 }
19556 }
19557 }
19558 else
19559 pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
19560 _("notes"));
19561
19562 if (pnotes == NULL)
19563 return FALSE;
19564
19565 external = pnotes;
19566
19567 if (section)
19568 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
19569 else
19570 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19571 (unsigned long) offset, (unsigned long) length);
19572
19573 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19574 specifies that notes should be aligned to 4 bytes in 32-bit
19575 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19576 we also support 4 byte alignment in 64-bit objects. If section
19577 alignment is less than 4, we treate alignment as 4 bytes. */
19578 if (align < 4)
19579 align = 4;
19580 else if (align != 4 && align != 8)
19581 {
19582 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19583 (long) align);
19584 free (pnotes);
19585 return FALSE;
19586 }
19587
19588 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19589
19590 end = (char *) pnotes + length;
19591 while ((char *) external < end)
19592 {
19593 Elf_Internal_Note inote;
19594 size_t min_notesz;
19595 char * next;
19596 char * temp = NULL;
19597 size_t data_remaining = end - (char *) external;
19598
19599 if (!is_ia64_vms (filedata))
19600 {
19601 /* PR binutils/15191
19602 Make sure that there is enough data to read. */
19603 min_notesz = offsetof (Elf_External_Note, name);
19604 if (data_remaining < min_notesz)
19605 {
19606 warn (ngettext ("Corrupt note: only %ld byte remains, "
19607 "not enough for a full note\n",
19608 "Corrupt note: only %ld bytes remain, "
19609 "not enough for a full note\n",
19610 data_remaining),
19611 (long) data_remaining);
19612 break;
19613 }
19614 data_remaining -= min_notesz;
19615
19616 inote.type = BYTE_GET (external->type);
19617 inote.namesz = BYTE_GET (external->namesz);
19618 inote.namedata = external->name;
19619 inote.descsz = BYTE_GET (external->descsz);
19620 inote.descdata = ((char *) external
19621 + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
19622 inote.descpos = offset + (inote.descdata - (char *) pnotes);
19623 next = ((char *) external
19624 + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
19625 }
19626 else
19627 {
19628 Elf64_External_VMS_Note *vms_external;
19629
19630 /* PR binutils/15191
19631 Make sure that there is enough data to read. */
19632 min_notesz = offsetof (Elf64_External_VMS_Note, name);
19633 if (data_remaining < min_notesz)
19634 {
19635 warn (ngettext ("Corrupt note: only %ld byte remains, "
19636 "not enough for a full note\n",
19637 "Corrupt note: only %ld bytes remain, "
19638 "not enough for a full note\n",
19639 data_remaining),
19640 (long) data_remaining);
19641 break;
19642 }
19643 data_remaining -= min_notesz;
19644
19645 vms_external = (Elf64_External_VMS_Note *) external;
19646 inote.type = BYTE_GET (vms_external->type);
19647 inote.namesz = BYTE_GET (vms_external->namesz);
19648 inote.namedata = vms_external->name;
19649 inote.descsz = BYTE_GET (vms_external->descsz);
19650 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
19651 inote.descpos = offset + (inote.descdata - (char *) pnotes);
19652 next = inote.descdata + align_power (inote.descsz, 3);
19653 }
19654
19655 /* PR 17531: file: 3443835e. */
19656 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19657 if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
19658 || (size_t) (inote.descdata - inote.namedata) > data_remaining
19659 || (size_t) (next - inote.descdata) < inote.descsz
19660 || ((size_t) (next - inote.descdata)
19661 > data_remaining - (size_t) (inote.descdata - inote.namedata)))
19662 {
19663 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19664 (unsigned long) ((char *) external - (char *) pnotes));
19665 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19666 inote.type, inote.namesz, inote.descsz, (int) align);
19667 break;
19668 }
19669
19670 external = (Elf_External_Note *) next;
19671
19672 /* Verify that name is null terminated. It appears that at least
19673 one version of Linux (RedHat 6.0) generates corefiles that don't
19674 comply with the ELF spec by failing to include the null byte in
19675 namesz. */
19676 if (inote.namesz > 0 && inote.namedata[inote.namesz - 1] != '\0')
19677 {
19678 if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
19679 {
19680 temp = (char *) malloc (inote.namesz + 1);
19681 if (temp == NULL)
19682 {
19683 error (_("Out of memory allocating space for inote name\n"));
19684 res = FALSE;
19685 break;
19686 }
19687
19688 memcpy (temp, inote.namedata, inote.namesz);
19689 inote.namedata = temp;
19690 }
19691 inote.namedata[inote.namesz] = 0;
19692 }
19693
19694 if (! process_note (& inote, filedata))
19695 res = FALSE;
19696
19697 free (temp);
19698 temp = NULL;
19699 }
19700
19701 free (pnotes);
19702
19703 return res;
19704}
19705
19706static bfd_boolean
19707process_corefile_note_segments (Filedata * filedata)
19708{
19709 Elf_Internal_Phdr * segment;
19710 unsigned int i;
19711 bfd_boolean res = TRUE;
19712
19713 if (! get_program_headers (filedata))
19714 return TRUE;
19715
19716 for (i = 0, segment = filedata->program_headers;
19717 i < filedata->file_header.e_phnum;
19718 i++, segment++)
19719 {
19720 if (segment->p_type == PT_NOTE)
19721 if (! process_notes_at (filedata, NULL,
19722 (bfd_vma) segment->p_offset,
19723 (bfd_vma) segment->p_filesz,
19724 (bfd_vma) segment->p_align))
19725 res = FALSE;
19726 }
19727
19728 return res;
19729}
19730
19731static bfd_boolean
19732process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
19733{
19734 Elf_External_Note * pnotes;
19735 Elf_External_Note * external;
19736 char * end;
19737 bfd_boolean res = TRUE;
19738
19739 if (length <= 0)
19740 return FALSE;
19741
19742 pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
19743 _("v850 notes"));
19744 if (pnotes == NULL)
19745 return FALSE;
19746
19747 external = pnotes;
19748 end = (char*) pnotes + length;
19749
19750 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19751 (unsigned long) offset, (unsigned long) length);
19752
19753 while ((char *) external + sizeof (Elf_External_Note) < end)
19754 {
19755 Elf_External_Note * next;
19756 Elf_Internal_Note inote;
19757
19758 inote.type = BYTE_GET (external->type);
19759 inote.namesz = BYTE_GET (external->namesz);
19760 inote.namedata = external->name;
19761 inote.descsz = BYTE_GET (external->descsz);
19762 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
19763 inote.descpos = offset + (inote.descdata - (char *) pnotes);
19764
19765 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
19766 {
19767 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
19768 inote.descdata = inote.namedata;
19769 inote.namesz = 0;
19770 }
19771
19772 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
19773
19774 if ( ((char *) next > end)
19775 || ((char *) next < (char *) pnotes))
19776 {
19777 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19778 (unsigned long) ((char *) external - (char *) pnotes));
19779 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19780 inote.type, inote.namesz, inote.descsz);
19781 break;
19782 }
19783
19784 external = next;
19785
19786 /* Prevent out-of-bounds indexing. */
19787 if ( inote.namedata + inote.namesz > end
19788 || inote.namedata + inote.namesz < inote.namedata)
19789 {
19790 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19791 (unsigned long) ((char *) external - (char *) pnotes));
19792 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19793 inote.type, inote.namesz, inote.descsz);
19794 break;
19795 }
19796
19797 printf (" %s: ", get_v850_elf_note_type (inote.type));
19798
19799 if (! print_v850_note (& inote))
19800 {
19801 res = FALSE;
19802 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19803 inote.namesz, inote.descsz);
19804 }
19805 }
19806
19807 free (pnotes);
19808
19809 return res;
19810}
19811
19812static bfd_boolean
19813process_note_sections (Filedata * filedata)
19814{
19815 Elf_Internal_Shdr * section;
19816 unsigned long i;
19817 unsigned int n = 0;
19818 bfd_boolean res = TRUE;
19819
19820 for (i = 0, section = filedata->section_headers;
19821 i < filedata->file_header.e_shnum && section != NULL;
19822 i++, section++)
19823 {
19824 if (section->sh_type == SHT_NOTE)
19825 {
19826 if (! process_notes_at (filedata, section,
19827 (bfd_vma) section->sh_offset,
19828 (bfd_vma) section->sh_size,
19829 (bfd_vma) section->sh_addralign))
19830 res = FALSE;
19831 n++;
19832 }
19833
19834 if (( filedata->file_header.e_machine == EM_V800
19835 || filedata->file_header.e_machine == EM_V850
19836 || filedata->file_header.e_machine == EM_CYGNUS_V850)
19837 && section->sh_type == SHT_RENESAS_INFO)
19838 {
19839 if (! process_v850_notes (filedata,
19840 (bfd_vma) section->sh_offset,
19841 (bfd_vma) section->sh_size))
19842 res = FALSE;
19843 n++;
19844 }
19845 }
19846
19847 if (n == 0)
19848 /* Try processing NOTE segments instead. */
19849 return process_corefile_note_segments (filedata);
19850
19851 return res;
19852}
19853
19854static bfd_boolean
19855process_notes (Filedata * filedata)
19856{
19857 /* If we have not been asked to display the notes then do nothing. */
19858 if (! do_notes)
19859 return TRUE;
19860
19861 if (filedata->file_header.e_type != ET_CORE)
19862 return process_note_sections (filedata);
19863
19864 /* No program headers means no NOTE segment. */
19865 if (filedata->file_header.e_phnum > 0)
19866 return process_corefile_note_segments (filedata);
19867
19868 printf (_("No note segments present in the core file.\n"));
19869 return TRUE;
19870}
19871
19872static unsigned char *
19873display_public_gnu_attributes (unsigned char * start,
19874 const unsigned char * const end)
19875{
19876 printf (_(" Unknown GNU attribute: %s\n"), start);
19877
19878 start += strnlen ((char *) start, end - start);
19879 display_raw_attribute (start, end);
19880
19881 return (unsigned char *) end;
19882}
19883
19884static unsigned char *
19885display_generic_attribute (unsigned char * start,
19886 unsigned int tag,
19887 const unsigned char * const end)
19888{
19889 if (tag == 0)
19890 return (unsigned char *) end;
19891
19892 return display_tag_value (tag, start, end);
19893}
19894
19895static bfd_boolean
19896process_arch_specific (Filedata * filedata)
19897{
19898 if (! do_arch)
19899 return TRUE;
19900
19901 switch (filedata->file_header.e_machine)
19902 {
19903 case EM_ARC:
19904 case EM_ARC_COMPACT:
19905 case EM_ARC_COMPACT2:
19906 return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
19907 display_arc_attribute,
19908 display_generic_attribute);
19909 case EM_ARM:
19910 return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
19911 display_arm_attribute,
19912 display_generic_attribute);
19913
19914 case EM_MIPS:
19915 case EM_MIPS_RS3_LE:
19916 return process_mips_specific (filedata);
19917
19918 case EM_MSP430:
19919 return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
19920 display_msp430x_attribute,
19921 display_msp430_gnu_attribute);
19922
19923 case EM_RISCV:
19924 return process_attributes (filedata, "riscv", SHT_RISCV_ATTRIBUTES,
19925 display_riscv_attribute,
19926 display_generic_attribute);
19927
19928 case EM_NDS32:
19929 return process_nds32_specific (filedata);
19930
19931 case EM_PPC:
19932 case EM_PPC64:
19933 return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19934 display_power_gnu_attribute);
19935
19936 case EM_S390:
19937 case EM_S390_OLD:
19938 return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19939 display_s390_gnu_attribute);
19940
19941 case EM_SPARC:
19942 case EM_SPARC32PLUS:
19943 case EM_SPARCV9:
19944 return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19945 display_sparc_gnu_attribute);
19946
19947 case EM_TI_C6000:
19948 return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
19949 display_tic6x_attribute,
19950 display_generic_attribute);
19951
19952 default:
19953 return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
19954 display_public_gnu_attributes,
19955 display_generic_attribute);
19956 }
19957}
19958
19959static bfd_boolean
19960get_file_header (Filedata * filedata)
19961{
19962 /* Read in the identity array. */
19963 if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
19964 return FALSE;
19965
19966 /* Determine how to read the rest of the header. */
19967 switch (filedata->file_header.e_ident[EI_DATA])
19968 {
19969 default:
19970 case ELFDATANONE:
19971 case ELFDATA2LSB:
19972 byte_get = byte_get_little_endian;
19973 byte_put = byte_put_little_endian;
19974 break;
19975 case ELFDATA2MSB:
19976 byte_get = byte_get_big_endian;
19977 byte_put = byte_put_big_endian;
19978 break;
19979 }
19980
19981 /* For now we only support 32 bit and 64 bit ELF files. */
19982 is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
19983
19984 /* Read in the rest of the header. */
19985 if (is_32bit_elf)
19986 {
19987 Elf32_External_Ehdr ehdr32;
19988
19989 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
19990 return FALSE;
19991
19992 filedata->file_header.e_type = BYTE_GET (ehdr32.e_type);
19993 filedata->file_header.e_machine = BYTE_GET (ehdr32.e_machine);
19994 filedata->file_header.e_version = BYTE_GET (ehdr32.e_version);
19995 filedata->file_header.e_entry = BYTE_GET (ehdr32.e_entry);
19996 filedata->file_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
19997 filedata->file_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
19998 filedata->file_header.e_flags = BYTE_GET (ehdr32.e_flags);
19999 filedata->file_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
20000 filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
20001 filedata->file_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
20002 filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
20003 filedata->file_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
20004 filedata->file_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
20005 }
20006 else
20007 {
20008 Elf64_External_Ehdr ehdr64;
20009
20010 /* If we have been compiled with sizeof (bfd_vma) == 4, then
20011 we will not be able to cope with the 64bit data found in
20012 64 ELF files. Detect this now and abort before we start
20013 overwriting things. */
20014 if (sizeof (bfd_vma) < 8)
20015 {
20016 error (_("This instance of readelf has been built without support for a\n\
2001764 bit data type and so it cannot read 64 bit ELF files.\n"));
20018 return FALSE;
20019 }
20020
20021 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
20022 return FALSE;
20023
20024 filedata->file_header.e_type = BYTE_GET (ehdr64.e_type);
20025 filedata->file_header.e_machine = BYTE_GET (ehdr64.e_machine);
20026 filedata->file_header.e_version = BYTE_GET (ehdr64.e_version);
20027 filedata->file_header.e_entry = BYTE_GET (ehdr64.e_entry);
20028 filedata->file_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
20029 filedata->file_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
20030 filedata->file_header.e_flags = BYTE_GET (ehdr64.e_flags);
20031 filedata->file_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
20032 filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
20033 filedata->file_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
20034 filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
20035 filedata->file_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
20036 filedata->file_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
20037 }
20038
20039 if (filedata->file_header.e_shoff)
20040 {
20041 /* There may be some extensions in the first section header. Don't
20042 bomb if we can't read it. */
20043 if (is_32bit_elf)
20044 get_32bit_section_headers (filedata, TRUE);
20045 else
20046 get_64bit_section_headers (filedata, TRUE);
20047 }
20048
20049 return TRUE;
20050}
20051
20052static void
20053close_file (Filedata * filedata)
20054{
20055 if (filedata)
20056 {
20057 if (filedata->handle)
20058 fclose (filedata->handle);
20059 free (filedata);
20060 }
20061}
20062
20063void
20064close_debug_file (void * data)
20065{
20066 close_file ((Filedata *) data);
20067}
20068
20069static Filedata *
20070open_file (const char * pathname)
20071{
20072 struct stat statbuf;
20073 Filedata * filedata = NULL;
20074
20075 if (stat (pathname, & statbuf) < 0
20076 || ! S_ISREG (statbuf.st_mode))
20077 goto fail;
20078
20079 filedata = calloc (1, sizeof * filedata);
20080 if (filedata == NULL)
20081 goto fail;
20082
20083 filedata->handle = fopen (pathname, "rb");
20084 if (filedata->handle == NULL)
20085 goto fail;
20086
20087 filedata->file_size = (bfd_size_type) statbuf.st_size;
20088 filedata->file_name = pathname;
20089
20090 if (! get_file_header (filedata))
20091 goto fail;
20092
20093 if (filedata->file_header.e_shoff)
20094 {
20095 bfd_boolean res;
20096
20097 /* Read the section headers again, this time for real. */
20098 if (is_32bit_elf)
20099 res = get_32bit_section_headers (filedata, FALSE);
20100 else
20101 res = get_64bit_section_headers (filedata, FALSE);
20102
20103 if (!res)
20104 goto fail;
20105 }
20106
20107 return filedata;
20108
20109 fail:
20110 if (filedata)
20111 {
20112 if (filedata->handle)
20113 fclose (filedata->handle);
20114 free (filedata);
20115 }
20116 return NULL;
20117}
20118
20119void *
20120open_debug_file (const char * pathname)
20121{
20122 return open_file (pathname);
20123}
20124
20125/* Process one ELF object file according to the command line options.
20126 This file may actually be stored in an archive. The file is
20127 positioned at the start of the ELF object. Returns TRUE if no
20128 problems were encountered, FALSE otherwise. */
20129
20130static bfd_boolean
20131process_object (Filedata * filedata)
20132{
20133 bfd_boolean have_separate_files;
20134 unsigned int i;
20135 bfd_boolean res;
20136
20137 if (! get_file_header (filedata))
20138 {
20139 error (_("%s: Failed to read file header\n"), filedata->file_name);
20140 return FALSE;
20141 }
20142
20143 /* Initialise per file variables. */
20144 for (i = ARRAY_SIZE (filedata->version_info); i--;)
20145 filedata->version_info[i] = 0;
20146
20147 for (i = ARRAY_SIZE (filedata->dynamic_info); i--;)
20148 filedata->dynamic_info[i] = 0;
20149 filedata->dynamic_info_DT_GNU_HASH = 0;
20150 filedata->dynamic_info_DT_MIPS_XHASH = 0;
20151
20152 /* Process the file. */
20153 if (show_name)
20154 printf (_("\nFile: %s\n"), filedata->file_name);
20155
20156 /* Initialise the dump_sects array from the cmdline_dump_sects array.
20157 Note we do this even if cmdline_dump_sects is empty because we
20158 must make sure that the dump_sets array is zeroed out before each
20159 object file is processed. */
20160 if (filedata->dump.num_dump_sects > cmdline.num_dump_sects)
20161 memset (filedata->dump.dump_sects, 0,
20162 filedata->dump.num_dump_sects * sizeof (*filedata->dump.dump_sects));
20163
20164 if (cmdline.num_dump_sects > 0)
20165 {
20166 if (filedata->dump.num_dump_sects == 0)
20167 /* A sneaky way of allocating the dump_sects array. */
20168 request_dump_bynumber (&filedata->dump, cmdline.num_dump_sects, 0);
20169
20170 assert (filedata->dump.num_dump_sects >= cmdline.num_dump_sects);
20171 memcpy (filedata->dump.dump_sects, cmdline.dump_sects,
20172 cmdline.num_dump_sects * sizeof (*filedata->dump.dump_sects));
20173 }
20174
20175 if (! process_file_header (filedata))
20176 return FALSE;
20177
20178 if (! process_section_headers (filedata))
20179 {
20180 /* Without loaded section headers we cannot process lots of things. */
20181 do_unwind = do_version = do_dump = do_arch = FALSE;
20182
20183 if (! do_using_dynamic)
20184 do_syms = do_dyn_syms = do_reloc = FALSE;
20185 }
20186
20187 if (! process_section_groups (filedata))
20188 /* Without loaded section groups we cannot process unwind. */
20189 do_unwind = FALSE;
20190
20191 res = process_program_headers (filedata);
20192 if (res)
20193 res = process_dynamic_section (filedata);
20194
20195 if (! process_relocs (filedata))
20196 res = FALSE;
20197
20198 if (! process_unwind (filedata))
20199 res = FALSE;
20200
20201 if (! process_symbol_table (filedata))
20202 res = FALSE;
20203
20204 if (! process_syminfo (filedata))
20205 res = FALSE;
20206
20207 if (! process_version_sections (filedata))
20208 res = FALSE;
20209
20210 if (filedata->file_header.e_shstrndx != SHN_UNDEF)
20211 have_separate_files = load_separate_debug_files (filedata, filedata->file_name);
20212 else
20213 have_separate_files = FALSE;
20214
20215 if (! process_section_contents (filedata))
20216 res = FALSE;
20217
20218 if (have_separate_files)
20219 {
20220 separate_info * d;
20221
20222 for (d = first_separate_info; d != NULL; d = d->next)
20223 {
20224 if (! process_section_headers (d->handle))
20225 res = FALSE;
20226 else if (! process_section_contents (d->handle))
20227 res = FALSE;
20228 }
20229
20230 /* The file handles are closed by the call to free_debug_memory() below. */
20231 }
20232
20233 if (! process_notes (filedata))
20234 res = FALSE;
20235
20236 if (! process_gnu_liblist (filedata))
20237 res = FALSE;
20238
20239 if (! process_arch_specific (filedata))
20240 res = FALSE;
20241
20242 free (filedata->program_headers);
20243 filedata->program_headers = NULL;
20244
20245 free (filedata->section_headers);
20246 filedata->section_headers = NULL;
20247
20248 free (filedata->string_table);
20249 filedata->string_table = NULL;
20250 filedata->string_table_length = 0;
20251
20252 free (filedata->dump.dump_sects);
20253 filedata->dump.dump_sects = NULL;
20254 filedata->dump.num_dump_sects = 0;
20255
20256 free (filedata->dynamic_strings);
20257 filedata->dynamic_strings = NULL;
20258 filedata->dynamic_strings_length = 0;
20259
20260 free (filedata->dynamic_symbols);
20261 filedata->dynamic_symbols = NULL;
20262 filedata->num_dynamic_syms = 0;
20263
20264 free (filedata->dynamic_syminfo);
20265 filedata->dynamic_syminfo = NULL;
20266
20267 free (filedata->dynamic_section);
20268 filedata->dynamic_section = NULL;
20269
20270 while (filedata->symtab_shndx_list != NULL)
20271 {
20272 elf_section_list *next = filedata->symtab_shndx_list->next;
20273 free (filedata->symtab_shndx_list);
20274 filedata->symtab_shndx_list = next;
20275 }
20276
20277 free (filedata->section_headers_groups);
20278 filedata->section_headers_groups = NULL;
20279
20280 if (filedata->section_groups)
20281 {
20282 struct group_list * g;
20283 struct group_list * next;
20284
20285 for (i = 0; i < filedata->group_count; i++)
20286 {
20287 for (g = filedata->section_groups [i].root; g != NULL; g = next)
20288 {
20289 next = g->next;
20290 free (g);
20291 }
20292 }
20293
20294 free (filedata->section_groups);
20295 filedata->section_groups = NULL;
20296 }
20297
20298 free_debug_memory ();
20299
20300 return res;
20301}
20302
20303/* Process an ELF archive.
20304 On entry the file is positioned just after the ARMAG string.
20305 Returns TRUE upon success, FALSE otherwise. */
20306
20307static bfd_boolean
20308process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
20309{
20310 struct archive_info arch;
20311 struct archive_info nested_arch;
20312 size_t got;
20313 bfd_boolean ret = TRUE;
20314
20315 show_name = TRUE;
20316
20317 /* The ARCH structure is used to hold information about this archive. */
20318 arch.file_name = NULL;
20319 arch.file = NULL;
20320 arch.index_array = NULL;
20321 arch.sym_table = NULL;
20322 arch.longnames = NULL;
20323
20324 /* The NESTED_ARCH structure is used as a single-item cache of information
20325 about a nested archive (when members of a thin archive reside within
20326 another regular archive file). */
20327 nested_arch.file_name = NULL;
20328 nested_arch.file = NULL;
20329 nested_arch.index_array = NULL;
20330 nested_arch.sym_table = NULL;
20331 nested_arch.longnames = NULL;
20332
20333 if (setup_archive (&arch, filedata->file_name, filedata->handle,
20334 filedata->file_size, is_thin_archive,
20335 do_archive_index) != 0)
20336 {
20337 ret = FALSE;
20338 goto out;
20339 }
20340
20341 if (do_archive_index)
20342 {
20343 if (arch.sym_table == NULL)
20344 error (_("%s: unable to dump the index as none was found\n"),
20345 filedata->file_name);
20346 else
20347 {
20348 unsigned long i, l;
20349 unsigned long current_pos;
20350
20351 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes "
20352 "in the symbol table)\n"),
20353 filedata->file_name, (unsigned long) arch.index_num,
20354 arch.sym_size);
20355
20356 current_pos = ftell (filedata->handle);
20357
20358 for (i = l = 0; i < arch.index_num; i++)
20359 {
20360 if (i == 0
20361 || (i > 0 && arch.index_array[i] != arch.index_array[i - 1]))
20362 {
20363 char * member_name
20364 = get_archive_member_name_at (&arch, arch.index_array[i],
20365 &nested_arch);
20366
20367 if (member_name != NULL)
20368 {
20369 char * qualified_name
20370 = make_qualified_name (&arch, &nested_arch,
20371 member_name);
20372
20373 if (qualified_name != NULL)
20374 {
20375 printf (_("Contents of binary %s at offset "),
20376 qualified_name);
20377 (void) print_vma (arch.index_array[i], PREFIX_HEX);
20378 putchar ('\n');
20379 free (qualified_name);
20380 }
20381 free (member_name);
20382 }
20383 }
20384
20385 if (l >= arch.sym_size)
20386 {
20387 error (_("%s: end of the symbol table reached "
20388 "before the end of the index\n"),
20389 filedata->file_name);
20390 ret = FALSE;
20391 break;
20392 }
20393 /* PR 17531: file: 0b6630b2. */
20394 printf ("\t%.*s\n",
20395 (int) (arch.sym_size - l), arch.sym_table + l);
20396 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
20397 }
20398
20399 if (arch.uses_64bit_indices)
20400 l = (l + 7) & ~ 7;
20401 else
20402 l += l & 1;
20403
20404 if (l < arch.sym_size)
20405 {
20406 error (ngettext ("%s: %ld byte remains in the symbol table, "
20407 "but without corresponding entries in "
20408 "the index table\n",
20409 "%s: %ld bytes remain in the symbol table, "
20410 "but without corresponding entries in "
20411 "the index table\n",
20412 arch.sym_size - l),
20413 filedata->file_name, arch.sym_size - l);
20414 ret = FALSE;
20415 }
20416
20417 if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
20418 {
20419 error (_("%s: failed to seek back to start of object files "
20420 "in the archive\n"),
20421 filedata->file_name);
20422 ret = FALSE;
20423 goto out;
20424 }
20425 }
20426
20427 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
20428 && !do_segments && !do_header && !do_dump && !do_version
20429 && !do_histogram && !do_debugging && !do_arch && !do_notes
20430 && !do_section_groups && !do_dyn_syms)
20431 {
20432 ret = TRUE; /* Archive index only. */
20433 goto out;
20434 }
20435 }
20436
20437 while (1)
20438 {
20439 char * name;
20440 size_t namelen;
20441 char * qualified_name;
20442
20443 /* Read the next archive header. */
20444 if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
20445 {
20446 error (_("%s: failed to seek to next archive header\n"),
20447 arch.file_name);
20448 ret = FALSE;
20449 break;
20450 }
20451 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
20452 if (got != sizeof arch.arhdr)
20453 {
20454 if (got == 0)
20455 break;
20456 /* PR 24049 - we cannot use filedata->file_name as this will
20457 have already been freed. */
20458 error (_("%s: failed to read archive header\n"), arch.file_name);
20459
20460 ret = FALSE;
20461 break;
20462 }
20463 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
20464 {
20465 error (_("%s: did not find a valid archive header\n"),
20466 arch.file_name);
20467 ret = FALSE;
20468 break;
20469 }
20470
20471 arch.next_arhdr_offset += sizeof arch.arhdr;
20472
20473 filedata->archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
20474 if (filedata->archive_file_size & 01)
20475 ++filedata->archive_file_size;
20476
20477 name = get_archive_member_name (&arch, &nested_arch);
20478 if (name == NULL)
20479 {
20480 error (_("%s: bad archive file name\n"), arch.file_name);
20481 ret = FALSE;
20482 break;
20483 }
20484 namelen = strlen (name);
20485
20486 qualified_name = make_qualified_name (&arch, &nested_arch, name);
20487 if (qualified_name == NULL)
20488 {
20489 error (_("%s: bad archive file name\n"), arch.file_name);
20490 free (name);
20491 ret = FALSE;
20492 break;
20493 }
20494
20495 if (is_thin_archive && arch.nested_member_origin == 0)
20496 {
20497 /* This is a proxy for an external member of a thin archive. */
20498 Filedata * member_filedata;
20499 char * member_file_name = adjust_relative_path
20500 (filedata->file_name, name, namelen);
20501
20502 free (name);
20503 if (member_file_name == NULL)
20504 {
20505 free (qualified_name);
20506 ret = FALSE;
20507 break;
20508 }
20509
20510 member_filedata = open_file (member_file_name);
20511 if (member_filedata == NULL)
20512 {
20513 error (_("Input file '%s' is not readable.\n"), member_file_name);
20514 free (member_file_name);
20515 free (qualified_name);
20516 ret = FALSE;
20517 break;
20518 }
20519
20520 filedata->archive_file_offset = arch.nested_member_origin;
20521 member_filedata->file_name = qualified_name;
20522
20523 if (! process_object (member_filedata))
20524 ret = FALSE;
20525
20526 close_file (member_filedata);
20527 free (member_file_name);
20528 }
20529 else if (is_thin_archive)
20530 {
20531 Filedata thin_filedata;
20532
20533 memset (&thin_filedata, 0, sizeof (thin_filedata));
20534
20535 /* PR 15140: Allow for corrupt thin archives. */
20536 if (nested_arch.file == NULL)
20537 {
20538 error (_("%s: contains corrupt thin archive: %s\n"),
20539 qualified_name, name);
20540 free (qualified_name);
20541 free (name);
20542 ret = FALSE;
20543 break;
20544 }
20545 free (name);
20546
20547 /* This is a proxy for a member of a nested archive. */
20548 filedata->archive_file_offset
20549 = arch.nested_member_origin + sizeof arch.arhdr;
20550
20551 /* The nested archive file will have been opened and setup by
20552 get_archive_member_name. */
20553 if (fseek (nested_arch.file, filedata->archive_file_offset,
20554 SEEK_SET) != 0)
20555 {
20556 error (_("%s: failed to seek to archive member.\n"),
20557 nested_arch.file_name);
20558 free (qualified_name);
20559 ret = FALSE;
20560 break;
20561 }
20562
20563 thin_filedata.handle = nested_arch.file;
20564 thin_filedata.file_name = qualified_name;
20565
20566 if (! process_object (& thin_filedata))
20567 ret = FALSE;
20568 }
20569 else
20570 {
20571 free (name);
20572 filedata->archive_file_offset = arch.next_arhdr_offset;
20573 filedata->file_name = qualified_name;
20574 if (! process_object (filedata))
20575 ret = FALSE;
20576 arch.next_arhdr_offset += filedata->archive_file_size;
20577 /* Stop looping with "negative" archive_file_size. */
20578 if (arch.next_arhdr_offset < filedata->archive_file_size)
20579 arch.next_arhdr_offset = -1ul;
20580 }
20581
20582 free (qualified_name);
20583 }
20584
20585 out:
20586 if (nested_arch.file != NULL)
20587 fclose (nested_arch.file);
20588 release_archive (&nested_arch);
20589 release_archive (&arch);
20590
20591 return ret;
20592}
20593
20594static bfd_boolean
20595process_file (char * file_name)
20596{
20597 Filedata * filedata = NULL;
20598 struct stat statbuf;
20599 char armag[SARMAG];
20600 bfd_boolean ret = TRUE;
20601
20602 if (stat (file_name, &statbuf) < 0)
20603 {
20604 if (errno == ENOENT)
20605 error (_("'%s': No such file\n"), file_name);
20606 else
20607 error (_("Could not locate '%s'. System error message: %s\n"),
20608 file_name, strerror (errno));
20609 return FALSE;
20610 }
20611
20612 if (! S_ISREG (statbuf.st_mode))
20613 {
20614 error (_("'%s' is not an ordinary file\n"), file_name);
20615 return FALSE;
20616 }
20617
20618 filedata = calloc (1, sizeof * filedata);
20619 if (filedata == NULL)
20620 {
20621 error (_("Out of memory allocating file data structure\n"));
20622 return FALSE;
20623 }
20624
20625 filedata->file_name = file_name;
20626 filedata->handle = fopen (file_name, "rb");
20627 if (filedata->handle == NULL)
20628 {
20629 error (_("Input file '%s' is not readable.\n"), file_name);
20630 free (filedata);
20631 return FALSE;
20632 }
20633
20634 if (fread (armag, SARMAG, 1, filedata->handle) != 1)
20635 {
20636 error (_("%s: Failed to read file's magic number\n"), file_name);
20637 fclose (filedata->handle);
20638 free (filedata);
20639 return FALSE;
20640 }
20641
20642 filedata->file_size = (bfd_size_type) statbuf.st_size;
20643
20644 if (memcmp (armag, ARMAG, SARMAG) == 0)
20645 {
20646 if (! process_archive (filedata, FALSE))
20647 ret = FALSE;
20648 }
20649 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
20650 {
20651 if ( ! process_archive (filedata, TRUE))
20652 ret = FALSE;
20653 }
20654 else
20655 {
20656 if (do_archive_index && !check_all)
20657 error (_("File %s is not an archive so its index cannot be displayed.\n"),
20658 file_name);
20659
20660 rewind (filedata->handle);
20661 filedata->archive_file_size = filedata->archive_file_offset = 0;
20662
20663 if (! process_object (filedata))
20664 ret = FALSE;
20665 }
20666
20667 fclose (filedata->handle);
20668 free (filedata->section_headers);
20669 free (filedata->program_headers);
20670 free (filedata->string_table);
20671 free (filedata->dump.dump_sects);
20672 free (filedata);
20673
20674 free (ba_cache.strtab);
20675 ba_cache.strtab = NULL;
20676 free (ba_cache.symtab);
20677 ba_cache.symtab = NULL;
20678 ba_cache.filedata = NULL;
20679
20680 return ret;
20681}
20682
20683#ifdef SUPPORT_DISASSEMBLY
20684/* Needed by the i386 disassembler. For extra credit, someone could
20685 fix this so that we insert symbolic addresses here, esp for GOT/PLT
20686 symbols. */
20687
20688void
20689print_address (unsigned int addr, FILE * outfile)
20690{
20691 fprintf (outfile,"0x%8.8x", addr);
20692}
20693
20694/* Needed by the i386 disassembler. */
20695
20696void
20697db_task_printsym (unsigned int addr)
20698{
20699 print_address (addr, stderr);
20700}
20701#endif
20702
20703int
20704main (int argc, char ** argv)
20705{
20706 int err;
20707
20708#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20709 setlocale (LC_MESSAGES, "");
20710#endif
20711#if defined (HAVE_SETLOCALE)
20712 setlocale (LC_CTYPE, "");
20713#endif
20714 bindtextdomain (PACKAGE, LOCALEDIR);
20715 textdomain (PACKAGE);
20716
20717 expandargv (&argc, &argv);
20718
20719 parse_args (& cmdline, argc, argv);
20720
20721 if (optind < (argc - 1))
20722 /* When displaying information for more than one file,
20723 prefix the information with the file name. */
20724 show_name = TRUE;
20725 else if (optind >= argc)
20726 {
20727 /* Ensure that the warning is always displayed. */
20728 do_checks = TRUE;
20729
20730 warn (_("Nothing to do.\n"));
20731 usage (stderr);
20732 }
20733
20734 err = FALSE;
20735 while (optind < argc)
20736 if (! process_file (argv[optind++]))
20737 err = TRUE;
20738
20739 free (cmdline.dump_sects);
20740
20741 free (dump_ctf_symtab_name);
20742 free (dump_ctf_strtab_name);
20743 free (dump_ctf_parent_name);
20744
20745 return err ? EXIT_FAILURE : EXIT_SUCCESS;
20746}
A mirror of the official binutils-gdb repository