]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - binutils/readelf.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
DWARF attrs: add delimiter
[thirdparty/binutils-gdb.git] / binutils / readelf.c
CommitLineData
252b5132 1/* readelf.c -- display contents of an ELF format file
2571583a 2 Copyright (C) 1998-2017 Free Software Foundation, Inc.
252b5132
RH		 3
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
12ab83a9 5 Modifications by Nick Clifton <nickc@redhat.com>
252b5132
RH		 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
32866df7 11 the Free Software Foundation; either version 3 of the License, or
252b5132
RH		 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
b43b5d5f
NC		 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 02110-1301, USA. */
252b5132 23\f
9eb20dd8 24/* The difference between readelf and objdump:
252b5132 25
74013231 26 Both programs are capable of displaying the contents of ELF format files,
9eb20dd8 27 so why does the binutils project have two file dumpers ?
0de14b54 28
9eb20dd8
NC		 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
3db64b00 43#include "sysdep.h"
252b5132 44#include <assert.h>
252b5132 45#include <time.h>
1b315056 46#include <zlib.h>
3bfcb652 47#ifdef HAVE_WCHAR_H
7bfd842d 48#include <wchar.h>
3bfcb652 49#endif
252b5132 50
a952a375 51#if __GNUC__ >= 2
19936277 52/* Define BFD64 here, even if our default architecture is 32 bit ELF
a952a375 53 as this will allow us to read in and parse 64bit and 32bit ELF files.
b34976b6 54 Only do this if we believe that the compiler can support a 64 bit
a952a375 55 data type. For now we only rely on GCC being able to do this. */
19936277 56#define BFD64
a952a375
NC		 57#endif
58
3db64b00
AM		 59#include "bfd.h"
60#include "bucomm.h"
3284fe0c 61#include "elfcomm.h"
19e6b90e 62#include "dwarf.h"
252b5132
RH		 63
64#include "elf/common.h"
65#include "elf/external.h"
66#include "elf/internal.h"
252b5132 67
4b78141a
NC		 68
69/* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
70 we can obtain the H8 reloc numbers. We need these for the
71 get_reloc_size() function. We include h8.h again after defining
72 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
73
74#include "elf/h8.h"
75#undef _ELF_H8_H
76
77/* Undo the effects of #including reloc-macros.h. */
78
79#undef START_RELOC_NUMBERS
80#undef RELOC_NUMBER
81#undef FAKE_RELOC
82#undef EMPTY_RELOC
83#undef END_RELOC_NUMBERS
84#undef _RELOC_MACROS_H
85
252b5132
RH		 86/* The following headers use the elf/reloc-macros.h file to
87 automatically generate relocation recognition functions
88 such as elf_mips_reloc_type() */
89
90#define RELOC_MACROS_GEN_FUNC
91
a06ea964 92#include "elf/aarch64.h"
252b5132 93#include "elf/alpha.h"
3b16e843 94#include "elf/arc.h"
252b5132 95#include "elf/arm.h"
3b16e843 96#include "elf/avr.h"
1d65ded4 97#include "elf/bfin.h"
60bca95a 98#include "elf/cr16.h"
3b16e843 99#include "elf/cris.h"
1c0d3aa6 100#include "elf/crx.h"
252b5132
RH		 101#include "elf/d10v.h"
102#include "elf/d30v.h"
d172d4ba 103#include "elf/dlx.h"
cfb8c092 104#include "elf/epiphany.h"
252b5132 105#include "elf/fr30.h"
5c70f934 106#include "elf/frv.h"
3f8107ab 107#include "elf/ft32.h"
3b16e843
NC		 108#include "elf/h8.h"
109#include "elf/hppa.h"
110#include "elf/i386.h"
35b1837e 111#include "elf/i370.h"
3b16e843
NC		 112#include "elf/i860.h"
113#include "elf/i960.h"
114#include "elf/ia64.h"
1e4cf259 115#include "elf/ip2k.h"
84e94c90 116#include "elf/lm32.h"
1c0d3aa6 117#include "elf/iq2000.h"
49f58d10 118#include "elf/m32c.h"
3b16e843
NC		 119#include "elf/m32r.h"
120#include "elf/m68k.h"
75751cd9 121#include "elf/m68hc11.h"
252b5132 122#include "elf/mcore.h"
15ab5209 123#include "elf/mep.h"
a3c62988 124#include "elf/metag.h"
7ba29e2a 125#include "elf/microblaze.h"
3b16e843 126#include "elf/mips.h"
e23eba97 127#include "elf/riscv.h"
3c3bdf30 128#include "elf/mmix.h"
3b16e843
NC		 129#include "elf/mn10200.h"
130#include "elf/mn10300.h"
5506d11a 131#include "elf/moxie.h"
4970f871 132#include "elf/mt.h"
2469cfa2 133#include "elf/msp430.h"
35c08157 134#include "elf/nds32.h"
13761a11 135#include "elf/nios2.h"
73589c9d 136#include "elf/or1k.h"
7d466069 137#include "elf/pj.h"
3b16e843 138#include "elf/ppc.h"
c833c019 139#include "elf/ppc64.h"
2b100bb5 140#include "elf/pru.h"
99c513f6 141#include "elf/rl78.h"
c7927a3c 142#include "elf/rx.h"
a85d7ed0 143#include "elf/s390.h"
1c0d3aa6 144#include "elf/score.h"
3b16e843
NC		 145#include "elf/sh.h"
146#include "elf/sparc.h"
e9f53129 147#include "elf/spu.h"
40b36596 148#include "elf/tic6x.h"
aa137e4d
NC		 149#include "elf/tilegx.h"
150#include "elf/tilepro.h"
3b16e843 151#include "elf/v850.h"
179d3252 152#include "elf/vax.h"
619ed720 153#include "elf/visium.h"
3b16e843 154#include "elf/x86-64.h"
c29aca4a 155#include "elf/xc16x.h"
f6c1a2d5 156#include "elf/xgate.h"
93fbbb04 157#include "elf/xstormy16.h"
88da6820 158#include "elf/xtensa.h"
252b5132 159
252b5132 160#include "getopt.h"
566b0d53 161#include "libiberty.h"
09c11c86 162#include "safe-ctype.h"
2cf0635d 163#include "filenames.h"
252b5132 164
15b42fb0
AM		 165#ifndef offsetof
166#define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
167#endif
168
6a40cf0c
NC		 169typedef struct elf_section_list
170{
171 Elf_Internal_Shdr * hdr;
172 struct elf_section_list * next;
173} elf_section_list;
174
2cf0635d 175char * program_name = "readelf";
c9c1d674 176static unsigned long archive_file_offset;
85b1c36d 177static unsigned long archive_file_size;
f54498b4 178static bfd_size_type current_file_size;
85b1c36d
BE		 179static unsigned long dynamic_addr;
180static bfd_size_type dynamic_size;
8b73c356 181static size_t dynamic_nent;
2cf0635d 182static char * dynamic_strings;
85b1c36d 183static unsigned long dynamic_strings_length;
2cf0635d 184static char * string_table;
85b1c36d
BE		 185static unsigned long string_table_length;
186static unsigned long num_dynamic_syms;
2cf0635d
NC		 187static Elf_Internal_Sym * dynamic_symbols;
188static Elf_Internal_Syminfo * dynamic_syminfo;
85b1c36d
BE		 189static unsigned long dynamic_syminfo_offset;
190static unsigned int dynamic_syminfo_nent;
f8eae8b2 191static char program_interpreter[PATH_MAX];
bb8a0291 192static bfd_vma dynamic_info[DT_ENCODING];
fdc90cb4 193static bfd_vma dynamic_info_DT_GNU_HASH;
85b1c36d
BE		 194static bfd_vma version_info[16];
195static Elf_Internal_Ehdr elf_header;
2cf0635d
NC		 196static Elf_Internal_Shdr * section_headers;
197static Elf_Internal_Phdr * program_headers;
198static Elf_Internal_Dyn * dynamic_section;
6a40cf0c 199static elf_section_list * symtab_shndx_list;
85b1c36d
BE		 200static int show_name;
201static int do_dynamic;
202static int do_syms;
2c610e4b 203static int do_dyn_syms;
85b1c36d
BE		 204static int do_reloc;
205static int do_sections;
206static int do_section_groups;
5477e8a0 207static int do_section_details;
85b1c36d
BE		 208static int do_segments;
209static int do_unwind;
210static int do_using_dynamic;
211static int do_header;
212static int do_dump;
213static int do_version;
85b1c36d
BE		 214static int do_histogram;
215static int do_debugging;
85b1c36d
BE		 216static int do_arch;
217static int do_notes;
4145f1d5 218static int do_archive_index;
85b1c36d 219static int is_32bit_elf;
0e602686 220static int decompress_dumps;
252b5132 221
e4b17d5c
L		 222struct group_list
223{
2cf0635d 224 struct group_list * next;
e4b17d5c
L		 225 unsigned int section_index;
226};
227
228struct group
229{
2cf0635d 230 struct group_list * root;
e4b17d5c
L		 231 unsigned int group_index;
232};
233
85b1c36d 234static size_t group_count;
2cf0635d
NC		 235static struct group * section_groups;
236static struct group ** section_headers_groups;
e4b17d5c 237
09c11c86
NC		 238
239/* Flag bits indicating particular types of dump. */
240#define HEX_DUMP (1 << 0) /* The -x command line switch. */
241#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
242#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
243#define STRING_DUMP (1 << 3) /* The -p command line switch. */
cf13d699 244#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
09c11c86
NC		 245
246typedef unsigned char dump_type;
247
248/* A linked list of the section names for which dumps were requested. */
aef1f6d0
DJ		 249struct dump_list_entry
250{
2cf0635d 251 char * name;
09c11c86 252 dump_type type;
2cf0635d 253 struct dump_list_entry * next;
aef1f6d0 254};
2cf0635d 255static struct dump_list_entry * dump_sects_byname;
aef1f6d0 256
09c11c86
NC		 257/* A dynamic array of flags indicating for which sections a dump
258 has been requested via command line switches. */
259static dump_type * cmdline_dump_sects = NULL;
260static unsigned int num_cmdline_dump_sects = 0;
18bd398b
NC		 261
262/* A dynamic array of flags indicating for which sections a dump of
263 some kind has been requested. It is reset on a per-object file
aef1f6d0
DJ		 264 basis and then initialised from the cmdline_dump_sects array,
265 the results of interpreting the -w switch, and the
266 dump_sects_byname list. */
09c11c86
NC		 267static dump_type * dump_sects = NULL;
268static unsigned int num_dump_sects = 0;
252b5132 269
252b5132 270
c256ffe7 271/* How to print a vma value. */
843dd992
NC		 272typedef enum print_mode
273{
274 HEX,
275 DEC,
276 DEC_5,
277 UNSIGNED,
278 PREFIX_HEX,
279 FULL_HEX,
280 LONG_HEX
281}
282print_mode;
283
bb4d2ac2
L		 284/* Versioned symbol info. */
285enum versioned_symbol_info
286{
287 symbol_undefined,
288 symbol_hidden,
289 symbol_public
290};
291
15f205b1 292static const char *get_symbol_version_string
bb4d2ac2
L		 293 (FILE *file, int is_dynsym, const char *strtab,
294 unsigned long int strtab_size, unsigned int si,
295 Elf_Internal_Sym *psym, enum versioned_symbol_info *sym_info,
296 unsigned short *vna_other);
297
9c19a809
NC		 298#define UNKNOWN -1
299
2b692964
NC		 300#define SECTION_NAME(X) \
301 ((X) == NULL ? _("<none>") \
302 : string_table == NULL ? _("<no-name>") \
303 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
0b49d371 304 : string_table + (X)->sh_name))
252b5132 305
ee42cf8c 306#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
252b5132 307
ba5cdace
NC		 308#define GET_ELF_SYMBOLS(file, section, sym_count) \
309 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
310 : get_64bit_elf_symbols (file, section, sym_count))
9ea033b2 311
d79b3d50
NC		 312#define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
313/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
314 already been called and verified that the string exists. */
315#define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
18bd398b 316
61865e30
NC		 317#define REMOVE_ARCH_BITS(ADDR) \
318 do \
319 { \
320 if (elf_header.e_machine == EM_ARM) \
321 (ADDR) &= ~1; \
322 } \
323 while (0)
d79b3d50 324\f
c9c1d674
EG		 325/* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
326 the offset of the current archive member, if we are examining an archive.
59245841
NC		 327 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
328 using malloc and fill that. In either case return the pointer to the start of
329 the retrieved data or NULL if something went wrong. If something does go wrong
c9c1d674
EG		 330 and REASON is not NULL then emit an error message using REASON as part of the
331 context. */
59245841 332
c256ffe7 333static void *
57028622
NC		 334get_data (void * var, FILE * file, unsigned long offset, bfd_size_type size,
335 bfd_size_type nmemb, const char * reason)
a6e9f9df 336{
2cf0635d 337 void * mvar;
57028622 338 bfd_size_type amt = size * nmemb;
a6e9f9df 339
c256ffe7 340 if (size == 0 || nmemb == 0)
a6e9f9df
AM		 341 return NULL;
342
57028622
NC		 343 /* If the size_t type is smaller than the bfd_size_type, eg because
344 you are building a 32-bit tool on a 64-bit host, then make sure
345 that when the sizes are cast to (size_t) no information is lost. */
346 if (sizeof (size_t) < sizeof (bfd_size_type)
347 && ( (bfd_size_type) ((size_t) size) != size
348 || (bfd_size_type) ((size_t) nmemb) != nmemb))
349 {
350 if (reason)
ed754a13
AM		 351 error (_("Size truncation prevents reading 0x%" BFD_VMA_FMT "x"
352 " elements of size 0x%" BFD_VMA_FMT "x for %s\n"),
353 nmemb, size, reason);
57028622
NC		 354 return NULL;
355 }
356
357 /* Check for size overflow. */
358 if (amt < nmemb)
359 {
360 if (reason)
ed754a13
AM		 361 error (_("Size overflow prevents reading 0x%" BFD_VMA_FMT "x"
362 " elements of size 0x%" BFD_VMA_FMT "x for %s\n"),
363 nmemb, size, reason);
57028622
NC		 364 return NULL;
365 }
366
c9c1d674
EG		 367 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
368 attempting to allocate memory when the read is bound to fail. */
369 if (amt > current_file_size
370 || offset + archive_file_offset + amt > current_file_size)
a6e9f9df 371 {
049b0c3a 372 if (reason)
ed754a13
AM		 373 error (_("Reading 0x%" BFD_VMA_FMT "x"
374 " bytes extends past end of file for %s\n"),
375 amt, reason);
a6e9f9df
AM		 376 return NULL;
377 }
378
c9c1d674 379 if (fseek (file, archive_file_offset + offset, SEEK_SET))
071436c6
NC		 380 {
381 if (reason)
c9c1d674 382 error (_("Unable to seek to 0x%lx for %s\n"),
ed754a13 383 archive_file_offset + offset, reason);
071436c6
NC		 384 return NULL;
385 }
386
a6e9f9df
AM		 387 mvar = var;
388 if (mvar == NULL)
389 {
c256ffe7 390 /* Check for overflow. */
57028622 391 if (nmemb < (~(bfd_size_type) 0 - 1) / size)
c256ffe7 392 /* + 1 so that we can '\0' terminate invalid string table sections. */
57028622 393 mvar = malloc ((size_t) amt + 1);
a6e9f9df
AM		 394
395 if (mvar == NULL)
396 {
049b0c3a 397 if (reason)
ed754a13
AM		 398 error (_("Out of memory allocating 0x%" BFD_VMA_FMT "x"
399 " bytes for %s\n"),
400 amt, reason);
a6e9f9df
AM		 401 return NULL;
402 }
c256ffe7 403
c9c1d674 404 ((char *) mvar)[amt] = '\0';
a6e9f9df
AM		 405 }
406
57028622 407 if (fread (mvar, (size_t) size, (size_t) nmemb, file) != nmemb)
a6e9f9df 408 {
049b0c3a 409 if (reason)
ed754a13
AM		 410 error (_("Unable to read in 0x%" BFD_VMA_FMT "x bytes of %s\n"),
411 amt, reason);
a6e9f9df
AM		 412 if (mvar != var)
413 free (mvar);
414 return NULL;
415 }
416
417 return mvar;
418}
419
14a91970 420/* Print a VMA value. */
cb8f3167 421
66543521 422static int
14a91970 423print_vma (bfd_vma vma, print_mode mode)
66543521 424{
66543521
AM		 425 int nc = 0;
426
14a91970 427 switch (mode)
66543521 428 {
14a91970
AM		 429 case FULL_HEX:
430 nc = printf ("0x");
1a0670f3 431 /* Fall through. */
66543521 432
14a91970 433 case LONG_HEX:
f7a99963 434#ifdef BFD64
14a91970 435 if (is_32bit_elf)
437c2fb7 436 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
f7a99963 437#endif
14a91970
AM		 438 printf_vma (vma);
439 return nc + 16;
b19aac67 440
14a91970
AM		 441 case DEC_5:
442 if (vma <= 99999)
443 return printf ("%5" BFD_VMA_FMT "d", vma);
1a0670f3 444 /* Fall through. */
66543521 445
14a91970
AM		 446 case PREFIX_HEX:
447 nc = printf ("0x");
1a0670f3 448 /* Fall through. */
66543521 449
14a91970
AM		 450 case HEX:
451 return nc + printf ("%" BFD_VMA_FMT "x", vma);
b19aac67 452
14a91970
AM		 453 case DEC:
454 return printf ("%" BFD_VMA_FMT "d", vma);
b19aac67 455
14a91970
AM		 456 case UNSIGNED:
457 return printf ("%" BFD_VMA_FMT "u", vma);
f7a99963 458 }
66543521 459 return 0;
f7a99963
NC		 460}
461
7bfd842d 462/* Display a symbol on stdout. Handles the display of control characters and
3bfcb652 463 multibye characters (assuming the host environment supports them).
31104126 464
7bfd842d
NC		 465 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
466
467 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
468 padding as necessary.
171191ba
NC		 469
470 Returns the number of emitted characters. */
471
472static unsigned int
7a88bc9c 473print_symbol (int width, const char *symbol)
31104126 474{
171191ba 475 bfd_boolean extra_padding = FALSE;
7bfd842d 476 int num_printed = 0;
3bfcb652 477#ifdef HAVE_MBSTATE_T
7bfd842d 478 mbstate_t state;
3bfcb652 479#endif
7bfd842d 480 int width_remaining;
961c521f 481
7bfd842d 482 if (width < 0)
961c521f 483 {
961c521f
NC		 484 /* Keep the width positive. This also helps. */
485 width = - width;
171191ba 486 extra_padding = TRUE;
0b4362b0 487 }
74e1a04b 488 assert (width != 0);
961c521f 489
7bfd842d
NC		 490 if (do_wide)
491 /* Set the remaining width to a very large value.
492 This simplifies the code below. */
493 width_remaining = INT_MAX;
494 else
495 width_remaining = width;
cb8f3167 496
3bfcb652 497#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 498 /* Initialise the multibyte conversion state. */
499 memset (& state, 0, sizeof (state));
3bfcb652 500#endif
961c521f 501
7bfd842d
NC		 502 while (width_remaining)
503 {
504 size_t n;
7bfd842d 505 const char c = *symbol++;
961c521f 506
7bfd842d 507 if (c == 0)
961c521f
NC		 508 break;
509
7bfd842d
NC		 510 /* Do not print control characters directly as they can affect terminal
511 settings. Such characters usually appear in the names generated
512 by the assembler for local labels. */
513 if (ISCNTRL (c))
961c521f 514 {
7bfd842d 515 if (width_remaining < 2)
961c521f
NC		 516 break;
517
7bfd842d
NC		 518 printf ("^%c", c + 0x40);
519 width_remaining -= 2;
171191ba 520 num_printed += 2;
961c521f 521 }
7bfd842d
NC		 522 else if (ISPRINT (c))
523 {
524 putchar (c);
525 width_remaining --;
526 num_printed ++;
527 }
961c521f
NC		 528 else
529 {
3bfcb652
NC		 530#ifdef HAVE_MBSTATE_T
531 wchar_t w;
532#endif
7bfd842d
NC		 533 /* Let printf do the hard work of displaying multibyte characters. */
534 printf ("%.1s", symbol - 1);
535 width_remaining --;
536 num_printed ++;
537
3bfcb652 538#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 539 /* Try to find out how many bytes made up the character that was
540 just printed. Advance the symbol pointer past the bytes that
541 were displayed. */
542 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
3bfcb652
NC		 543#else
544 n = 1;
545#endif
7bfd842d
NC		 546 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
547 symbol += (n - 1);
961c521f 548 }
961c521f 549 }
171191ba 550
7bfd842d 551 if (extra_padding && num_printed < width)
171191ba
NC		 552 {
553 /* Fill in the remaining spaces. */
7bfd842d
NC		 554 printf ("%-*s", width - num_printed, " ");
555 num_printed = width;
171191ba
NC		 556 }
557
558 return num_printed;
31104126
NC		 559}
560
1449284b 561/* Returns a pointer to a static buffer containing a printable version of
74e1a04b
NC		 562 the given section's name. Like print_symbol, except that it does not try
563 to print multibyte characters, it just interprets them as hex values. */
564
565static const char *
0d2a7a93 566printable_section_name (const Elf_Internal_Shdr * sec)
74e1a04b
NC		 567{
568#define MAX_PRINT_SEC_NAME_LEN 128
569 static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
570 const char * name = SECTION_NAME (sec);
571 char * buf = sec_name_buf;
572 char c;
573 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
574
575 while ((c = * name ++) != 0)
576 {
577 if (ISCNTRL (c))
578 {
579 if (remaining < 2)
580 break;
948f632f 581
74e1a04b
NC		 582 * buf ++ = '^';
583 * buf ++ = c + 0x40;
584 remaining -= 2;
585 }
586 else if (ISPRINT (c))
587 {
588 * buf ++ = c;
589 remaining -= 1;
590 }
591 else
592 {
593 static char hex[17] = "0123456789ABCDEF";
594
595 if (remaining < 4)
596 break;
597 * buf ++ = '<';
598 * buf ++ = hex[(c & 0xf0) >> 4];
599 * buf ++ = hex[c & 0x0f];
600 * buf ++ = '>';
601 remaining -= 4;
602 }
603
604 if (remaining == 0)
605 break;
606 }
607
608 * buf = 0;
609 return sec_name_buf;
610}
611
612static const char *
613printable_section_name_from_index (unsigned long ndx)
614{
615 if (ndx >= elf_header.e_shnum)
616 return _("<corrupt>");
617
618 return printable_section_name (section_headers + ndx);
619}
620
89fac5e3
RS		 621/* Return a pointer to section NAME, or NULL if no such section exists. */
622
623static Elf_Internal_Shdr *
2cf0635d 624find_section (const char * name)
89fac5e3
RS		 625{
626 unsigned int i;
627
628 for (i = 0; i < elf_header.e_shnum; i++)
629 if (streq (SECTION_NAME (section_headers + i), name))
630 return section_headers + i;
631
632 return NULL;
633}
634
0b6ae522
DJ		 635/* Return a pointer to a section containing ADDR, or NULL if no such
636 section exists. */
637
638static Elf_Internal_Shdr *
639find_section_by_address (bfd_vma addr)
640{
641 unsigned int i;
642
643 for (i = 0; i < elf_header.e_shnum; i++)
644 {
645 Elf_Internal_Shdr *sec = section_headers + i;
646 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
647 return sec;
648 }
649
650 return NULL;
651}
652
071436c6
NC		 653static Elf_Internal_Shdr *
654find_section_by_type (unsigned int type)
655{
656 unsigned int i;
657
658 for (i = 0; i < elf_header.e_shnum; i++)
659 {
660 Elf_Internal_Shdr *sec = section_headers + i;
661 if (sec->sh_type == type)
662 return sec;
663 }
664
665 return NULL;
666}
667
657d0d47
CC		 668/* Return a pointer to section NAME, or NULL if no such section exists,
669 restricted to the list of sections given in SET. */
670
671static Elf_Internal_Shdr *
672find_section_in_set (const char * name, unsigned int * set)
673{
674 unsigned int i;
675
676 if (set != NULL)
677 {
678 while ((i = *set++) > 0)
b814a36d
NC		 679 {
680 /* See PR 21156 for a reproducer. */
681 if (i >= elf_header.e_shnum)
682 continue; /* FIXME: Should we issue an error message ? */
683
684 if (streq (SECTION_NAME (section_headers + i), name))
685 return section_headers + i;
686 }
657d0d47
CC		 687 }
688
689 return find_section (name);
690}
691
0b6ae522
DJ		 692/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
693 bytes read. */
694
f6f0e17b
NC		 695static inline unsigned long
696read_uleb128 (unsigned char *data,
697 unsigned int *length_return,
698 const unsigned char * const end)
0b6ae522 699{
f6f0e17b 700 return read_leb128 (data, length_return, FALSE, end);
0b6ae522
DJ		 701}
702
28f997cf
TG		 703/* Return true if the current file is for IA-64 machine and OpenVMS ABI.
704 This OS has so many departures from the ELF standard that we test it at
705 many places. */
706
707static inline int
708is_ia64_vms (void)
709{
710 return elf_header.e_machine == EM_IA_64
711 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
712}
713
bcedfee6 714/* Guess the relocation size commonly used by the specific machines. */
252b5132 715
252b5132 716static int
2dc4cec1 717guess_is_rela (unsigned int e_machine)
252b5132 718{
9c19a809 719 switch (e_machine)
252b5132
RH		 720 {
721 /* Targets that use REL relocations. */
252b5132 722 case EM_386:
22abe556 723 case EM_IAMCU:
63fcb9e9 724 case EM_960:
e9f53129 725 case EM_ARM:
2b0337b0 726 case EM_D10V:
252b5132 727 case EM_CYGNUS_D10V:
e9f53129 728 case EM_DLX:
252b5132 729 case EM_MIPS:
4fe85591 730 case EM_MIPS_RS3_LE:
e9f53129 731 case EM_CYGNUS_M32R:
1c0d3aa6 732 case EM_SCORE:
f6c1a2d5 733 case EM_XGATE:
9c19a809 734 return FALSE;
103f02d3 735
252b5132
RH		 736 /* Targets that use RELA relocations. */
737 case EM_68K:
e9f53129 738 case EM_860:
a06ea964 739 case EM_AARCH64:
cfb8c092 740 case EM_ADAPTEVA_EPIPHANY:
e9f53129
AM		 741 case EM_ALPHA:
742 case EM_ALTERA_NIOS2:
886a2506
NC		 743 case EM_ARC:
744 case EM_ARC_COMPACT:
745 case EM_ARC_COMPACT2:
e9f53129
AM		 746 case EM_AVR:
747 case EM_AVR_OLD:
748 case EM_BLACKFIN:
60bca95a 749 case EM_CR16:
e9f53129
AM		 750 case EM_CRIS:
751 case EM_CRX:
2b0337b0 752 case EM_D30V:
252b5132 753 case EM_CYGNUS_D30V:
2b0337b0 754 case EM_FR30:
3f8107ab 755 case EM_FT32:
252b5132 756 case EM_CYGNUS_FR30:
5c70f934 757 case EM_CYGNUS_FRV:
e9f53129
AM		 758 case EM_H8S:
759 case EM_H8_300:
760 case EM_H8_300H:
800eeca4 761 case EM_IA_64:
1e4cf259
NC		 762 case EM_IP2K:
763 case EM_IP2K_OLD:
3b36097d 764 case EM_IQ2000:
84e94c90 765 case EM_LATTICEMICO32:
ff7eeb89 766 case EM_M32C_OLD:
49f58d10 767 case EM_M32C:
e9f53129
AM		 768 case EM_M32R:
769 case EM_MCORE:
15ab5209 770 case EM_CYGNUS_MEP:
a3c62988 771 case EM_METAG:
e9f53129
AM		 772 case EM_MMIX:
773 case EM_MN10200:
774 case EM_CYGNUS_MN10200:
775 case EM_MN10300:
776 case EM_CYGNUS_MN10300:
5506d11a 777 case EM_MOXIE:
e9f53129
AM		 778 case EM_MSP430:
779 case EM_MSP430_OLD:
d031aafb 780 case EM_MT:
35c08157 781 case EM_NDS32:
64fd6348 782 case EM_NIOS32:
73589c9d 783 case EM_OR1K:
e9f53129
AM		 784 case EM_PPC64:
785 case EM_PPC:
2b100bb5 786 case EM_TI_PRU:
e23eba97 787 case EM_RISCV:
99c513f6 788 case EM_RL78:
c7927a3c 789 case EM_RX:
e9f53129
AM		 790 case EM_S390:
791 case EM_S390_OLD:
792 case EM_SH:
793 case EM_SPARC:
794 case EM_SPARC32PLUS:
795 case EM_SPARCV9:
796 case EM_SPU:
40b36596 797 case EM_TI_C6000:
aa137e4d
NC		 798 case EM_TILEGX:
799 case EM_TILEPRO:
708e2187 800 case EM_V800:
e9f53129
AM		 801 case EM_V850:
802 case EM_CYGNUS_V850:
803 case EM_VAX:
619ed720 804 case EM_VISIUM:
e9f53129 805 case EM_X86_64:
8a9036a4 806 case EM_L1OM:
7a9068fe 807 case EM_K1OM:
e9f53129
AM		 808 case EM_XSTORMY16:
809 case EM_XTENSA:
810 case EM_XTENSA_OLD:
7ba29e2a
NC		 811 case EM_MICROBLAZE:
812 case EM_MICROBLAZE_OLD:
9c19a809 813 return TRUE;
103f02d3 814
e9f53129
AM		 815 case EM_68HC05:
816 case EM_68HC08:
817 case EM_68HC11:
818 case EM_68HC16:
819 case EM_FX66:
820 case EM_ME16:
d1133906 821 case EM_MMA:
d1133906
NC		 822 case EM_NCPU:
823 case EM_NDR1:
e9f53129 824 case EM_PCP:
d1133906 825 case EM_ST100:
e9f53129 826 case EM_ST19:
d1133906 827 case EM_ST7:
e9f53129
AM		 828 case EM_ST9PLUS:
829 case EM_STARCORE:
d1133906 830 case EM_SVX:
e9f53129 831 case EM_TINYJ:
9c19a809
NC		 832 default:
833 warn (_("Don't know about relocations on this machine architecture\n"));
834 return FALSE;
835 }
836}
252b5132 837
9c19a809 838static int
2cf0635d 839slurp_rela_relocs (FILE * file,
d3ba0551
AM		 840 unsigned long rel_offset,
841 unsigned long rel_size,
2cf0635d
NC		 842 Elf_Internal_Rela ** relasp,
843 unsigned long * nrelasp)
9c19a809 844{
2cf0635d 845 Elf_Internal_Rela * relas;
8b73c356 846 size_t nrelas;
4d6ed7c8 847 unsigned int i;
252b5132 848
4d6ed7c8
NC		 849 if (is_32bit_elf)
850 {
2cf0635d 851 Elf32_External_Rela * erelas;
103f02d3 852
3f5e193b 853 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 854 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 855 if (!erelas)
856 return 0;
252b5132 857
4d6ed7c8 858 nrelas = rel_size / sizeof (Elf32_External_Rela);
103f02d3 859
3f5e193b
NC		 860 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
861 sizeof (Elf_Internal_Rela));
103f02d3 862
4d6ed7c8
NC		 863 if (relas == NULL)
864 {
c256ffe7 865 free (erelas);
591a748a 866 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 867 return 0;
868 }
103f02d3 869
4d6ed7c8
NC		 870 for (i = 0; i < nrelas; i++)
871 {
872 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
873 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 874 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
4d6ed7c8 875 }
103f02d3 876
4d6ed7c8
NC		 877 free (erelas);
878 }
879 else
880 {
2cf0635d 881 Elf64_External_Rela * erelas;
103f02d3 882
3f5e193b 883 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 884 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 885 if (!erelas)
886 return 0;
4d6ed7c8
NC		 887
888 nrelas = rel_size / sizeof (Elf64_External_Rela);
103f02d3 889
3f5e193b
NC		 890 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
891 sizeof (Elf_Internal_Rela));
103f02d3 892
4d6ed7c8
NC		 893 if (relas == NULL)
894 {
c256ffe7 895 free (erelas);
591a748a 896 error (_("out of memory parsing relocs\n"));
4d6ed7c8 897 return 0;
9c19a809 898 }
4d6ed7c8
NC		 899
900 for (i = 0; i < nrelas; i++)
9c19a809 901 {
66543521
AM		 902 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
903 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 904 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
861fb55a
DJ		 905
906 /* The #ifdef BFD64 below is to prevent a compile time
907 warning. We know that if we do not have a 64 bit data
908 type that we will never execute this code anyway. */
909#ifdef BFD64
910 if (elf_header.e_machine == EM_MIPS
911 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
912 {
913 /* In little-endian objects, r_info isn't really a
914 64-bit little-endian value: it has a 32-bit
915 little-endian symbol index followed by four
916 individual byte fields. Reorder INFO
917 accordingly. */
91d6fa6a
NC		 918 bfd_vma inf = relas[i].r_info;
919 inf = (((inf & 0xffffffff) << 32)
920 | ((inf >> 56) & 0xff)
921 | ((inf >> 40) & 0xff00)
922 | ((inf >> 24) & 0xff0000)
923 | ((inf >> 8) & 0xff000000));
924 relas[i].r_info = inf;
861fb55a
DJ		 925 }
926#endif /* BFD64 */
4d6ed7c8 927 }
103f02d3 928
4d6ed7c8
NC		 929 free (erelas);
930 }
931 *relasp = relas;
932 *nrelasp = nrelas;
933 return 1;
934}
103f02d3 935
4d6ed7c8 936static int
2cf0635d 937slurp_rel_relocs (FILE * file,
d3ba0551
AM		 938 unsigned long rel_offset,
939 unsigned long rel_size,
2cf0635d
NC		 940 Elf_Internal_Rela ** relsp,
941 unsigned long * nrelsp)
4d6ed7c8 942{
2cf0635d 943 Elf_Internal_Rela * rels;
8b73c356 944 size_t nrels;
4d6ed7c8 945 unsigned int i;
103f02d3 946
4d6ed7c8
NC		 947 if (is_32bit_elf)
948 {
2cf0635d 949 Elf32_External_Rel * erels;
103f02d3 950
3f5e193b 951 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 952 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 953 if (!erels)
954 return 0;
103f02d3 955
4d6ed7c8 956 nrels = rel_size / sizeof (Elf32_External_Rel);
103f02d3 957
3f5e193b 958 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 959
4d6ed7c8
NC		 960 if (rels == NULL)
961 {
c256ffe7 962 free (erels);
591a748a 963 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 964 return 0;
965 }
966
967 for (i = 0; i < nrels; i++)
968 {
969 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
970 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 971 rels[i].r_addend = 0;
9ea033b2 972 }
4d6ed7c8
NC		 973
974 free (erels);
9c19a809
NC		 975 }
976 else
977 {
2cf0635d 978 Elf64_External_Rel * erels;
9ea033b2 979
3f5e193b 980 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 981 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 982 if (!erels)
983 return 0;
103f02d3 984
4d6ed7c8 985 nrels = rel_size / sizeof (Elf64_External_Rel);
103f02d3 986
3f5e193b 987 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 988
4d6ed7c8 989 if (rels == NULL)
9c19a809 990 {
c256ffe7 991 free (erels);
591a748a 992 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 993 return 0;
994 }
103f02d3 995
4d6ed7c8
NC		 996 for (i = 0; i < nrels; i++)
997 {
66543521
AM		 998 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
999 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 1000 rels[i].r_addend = 0;
861fb55a
DJ		 1001
1002 /* The #ifdef BFD64 below is to prevent a compile time
1003 warning. We know that if we do not have a 64 bit data
1004 type that we will never execute this code anyway. */
1005#ifdef BFD64
1006 if (elf_header.e_machine == EM_MIPS
1007 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
1008 {
1009 /* In little-endian objects, r_info isn't really a
1010 64-bit little-endian value: it has a 32-bit
1011 little-endian symbol index followed by four
1012 individual byte fields. Reorder INFO
1013 accordingly. */
91d6fa6a
NC		 1014 bfd_vma inf = rels[i].r_info;
1015 inf = (((inf & 0xffffffff) << 32)
1016 | ((inf >> 56) & 0xff)
1017 | ((inf >> 40) & 0xff00)
1018 | ((inf >> 24) & 0xff0000)
1019 | ((inf >> 8) & 0xff000000));
1020 rels[i].r_info = inf;
861fb55a
DJ		 1021 }
1022#endif /* BFD64 */
4d6ed7c8 1023 }
103f02d3 1024
4d6ed7c8
NC		 1025 free (erels);
1026 }
1027 *relsp = rels;
1028 *nrelsp = nrels;
1029 return 1;
1030}
103f02d3 1031
aca88567
NC		 1032/* Returns the reloc type extracted from the reloc info field. */
1033
1034static unsigned int
1035get_reloc_type (bfd_vma reloc_info)
1036{
1037 if (is_32bit_elf)
1038 return ELF32_R_TYPE (reloc_info);
1039
1040 switch (elf_header.e_machine)
1041 {
1042 case EM_MIPS:
1043 /* Note: We assume that reloc_info has already been adjusted for us. */
1044 return ELF64_MIPS_R_TYPE (reloc_info);
1045
1046 case EM_SPARCV9:
1047 return ELF64_R_TYPE_ID (reloc_info);
1048
1049 default:
1050 return ELF64_R_TYPE (reloc_info);
1051 }
1052}
1053
1054/* Return the symbol index extracted from the reloc info field. */
1055
1056static bfd_vma
1057get_reloc_symindex (bfd_vma reloc_info)
1058{
1059 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1060}
1061
13761a11
NC		 1062static inline bfd_boolean
1063uses_msp430x_relocs (void)
1064{
1065 return
1066 elf_header.e_machine == EM_MSP430 /* Paranoia. */
1067 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1068 && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1069 /* TI compiler uses ELFOSABI_NONE. */
1070 || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1071}
1072
d3ba0551
AM		 1073/* Display the contents of the relocation data found at the specified
1074 offset. */
ee42cf8c 1075
41e92641 1076static void
2cf0635d 1077dump_relocations (FILE * file,
d3ba0551
AM		 1078 unsigned long rel_offset,
1079 unsigned long rel_size,
2cf0635d 1080 Elf_Internal_Sym * symtab,
d3ba0551 1081 unsigned long nsyms,
2cf0635d 1082 char * strtab,
d79b3d50 1083 unsigned long strtablen,
bb4d2ac2
L		 1084 int is_rela,
1085 int is_dynsym)
4d6ed7c8 1086{
b34976b6 1087 unsigned int i;
2cf0635d 1088 Elf_Internal_Rela * rels;
103f02d3 1089
4d6ed7c8
NC		 1090 if (is_rela == UNKNOWN)
1091 is_rela = guess_is_rela (elf_header.e_machine);
103f02d3 1092
4d6ed7c8
NC		 1093 if (is_rela)
1094 {
c8286bd1 1095 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 1096 return;
4d6ed7c8
NC		 1097 }
1098 else
1099 {
1100 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 1101 return;
252b5132
RH		 1102 }
1103
410f7a12
L		 1104 if (is_32bit_elf)
1105 {
1106 if (is_rela)
2c71103e
NC		 1107 {
1108 if (do_wide)
1109 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1110 else
1111 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1112 }
410f7a12 1113 else
2c71103e
NC		 1114 {
1115 if (do_wide)
1116 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1117 else
1118 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1119 }
410f7a12 1120 }
252b5132 1121 else
410f7a12
L		 1122 {
1123 if (is_rela)
2c71103e
NC		 1124 {
1125 if (do_wide)
8beeaeb7 1126 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
2c71103e
NC		 1127 else
1128 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1129 }
410f7a12 1130 else
2c71103e
NC		 1131 {
1132 if (do_wide)
8beeaeb7 1133 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
2c71103e
NC		 1134 else
1135 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1136 }
410f7a12 1137 }
252b5132
RH		 1138
1139 for (i = 0; i < rel_size; i++)
1140 {
2cf0635d 1141 const char * rtype;
b34976b6 1142 bfd_vma offset;
91d6fa6a 1143 bfd_vma inf;
b34976b6
AM		 1144 bfd_vma symtab_index;
1145 bfd_vma type;
103f02d3 1146
b34976b6 1147 offset = rels[i].r_offset;
91d6fa6a 1148 inf = rels[i].r_info;
103f02d3 1149
91d6fa6a
NC		 1150 type = get_reloc_type (inf);
1151 symtab_index = get_reloc_symindex (inf);
252b5132 1152
410f7a12
L		 1153 if (is_32bit_elf)
1154 {
39dbeff8
AM		 1155 printf ("%8.8lx %8.8lx ",
1156 (unsigned long) offset & 0xffffffff,
91d6fa6a 1157 (unsigned long) inf & 0xffffffff);
410f7a12
L		 1158 }
1159 else
1160 {
39dbeff8
AM		 1161#if BFD_HOST_64BIT_LONG
1162 printf (do_wide
1163 ? "%16.16lx %16.16lx "
1164 : "%12.12lx %12.12lx ",
91d6fa6a 1165 offset, inf);
39dbeff8 1166#elif BFD_HOST_64BIT_LONG_LONG
6e3d6dc1 1167#ifndef __MSVCRT__
39dbeff8
AM		 1168 printf (do_wide
1169 ? "%16.16llx %16.16llx "
1170 : "%12.12llx %12.12llx ",
91d6fa6a 1171 offset, inf);
6e3d6dc1
NC		 1172#else
1173 printf (do_wide
1174 ? "%16.16I64x %16.16I64x "
1175 : "%12.12I64x %12.12I64x ",
91d6fa6a 1176 offset, inf);
6e3d6dc1 1177#endif
39dbeff8 1178#else
2c71103e
NC		 1179 printf (do_wide
1180 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1181 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
410f7a12
L		 1182 _bfd_int64_high (offset),
1183 _bfd_int64_low (offset),
91d6fa6a
NC		 1184 _bfd_int64_high (inf),
1185 _bfd_int64_low (inf));
9ea033b2 1186#endif
410f7a12 1187 }
103f02d3 1188
252b5132
RH		 1189 switch (elf_header.e_machine)
1190 {
1191 default:
1192 rtype = NULL;
1193 break;
1194
a06ea964
NC		 1195 case EM_AARCH64:
1196 rtype = elf_aarch64_reloc_type (type);
1197 break;
1198
2b0337b0 1199 case EM_M32R:
252b5132 1200 case EM_CYGNUS_M32R:
9ea033b2 1201 rtype = elf_m32r_reloc_type (type);
252b5132
RH		 1202 break;
1203
1204 case EM_386:
22abe556 1205 case EM_IAMCU:
9ea033b2 1206 rtype = elf_i386_reloc_type (type);
252b5132
RH		 1207 break;
1208
ba2685cc
AM		 1209 case EM_68HC11:
1210 case EM_68HC12:
1211 rtype = elf_m68hc11_reloc_type (type);
1212 break;
75751cd9 1213
252b5132 1214 case EM_68K:
9ea033b2 1215 rtype = elf_m68k_reloc_type (type);
252b5132
RH		 1216 break;
1217
63fcb9e9 1218 case EM_960:
9ea033b2 1219 rtype = elf_i960_reloc_type (type);
63fcb9e9
ILT		 1220 break;
1221
adde6300 1222 case EM_AVR:
2b0337b0 1223 case EM_AVR_OLD:
adde6300
AM		 1224 rtype = elf_avr_reloc_type (type);
1225 break;
1226
9ea033b2
NC		 1227 case EM_OLD_SPARCV9:
1228 case EM_SPARC32PLUS:
1229 case EM_SPARCV9:
252b5132 1230 case EM_SPARC:
9ea033b2 1231 rtype = elf_sparc_reloc_type (type);
252b5132
RH		 1232 break;
1233
e9f53129
AM		 1234 case EM_SPU:
1235 rtype = elf_spu_reloc_type (type);
1236 break;
1237
708e2187
NC		 1238 case EM_V800:
1239 rtype = v800_reloc_type (type);
1240 break;
2b0337b0 1241 case EM_V850:
252b5132 1242 case EM_CYGNUS_V850:
9ea033b2 1243 rtype = v850_reloc_type (type);
252b5132
RH		 1244 break;
1245
2b0337b0 1246 case EM_D10V:
252b5132 1247 case EM_CYGNUS_D10V:
9ea033b2 1248 rtype = elf_d10v_reloc_type (type);
252b5132
RH		 1249 break;
1250
2b0337b0 1251 case EM_D30V:
252b5132 1252 case EM_CYGNUS_D30V:
9ea033b2 1253 rtype = elf_d30v_reloc_type (type);
252b5132
RH		 1254 break;
1255
d172d4ba
NC		 1256 case EM_DLX:
1257 rtype = elf_dlx_reloc_type (type);
1258 break;
1259
252b5132 1260 case EM_SH:
9ea033b2 1261 rtype = elf_sh_reloc_type (type);
252b5132
RH		 1262 break;
1263
2b0337b0 1264 case EM_MN10300:
252b5132 1265 case EM_CYGNUS_MN10300:
9ea033b2 1266 rtype = elf_mn10300_reloc_type (type);
252b5132
RH		 1267 break;
1268
2b0337b0 1269 case EM_MN10200:
252b5132 1270 case EM_CYGNUS_MN10200:
9ea033b2 1271 rtype = elf_mn10200_reloc_type (type);
252b5132
RH		 1272 break;
1273
2b0337b0 1274 case EM_FR30:
252b5132 1275 case EM_CYGNUS_FR30:
9ea033b2 1276 rtype = elf_fr30_reloc_type (type);
252b5132
RH		 1277 break;
1278
ba2685cc
AM		 1279 case EM_CYGNUS_FRV:
1280 rtype = elf_frv_reloc_type (type);
1281 break;
5c70f934 1282
3f8107ab
AM		 1283 case EM_FT32:
1284 rtype = elf_ft32_reloc_type (type);
1285 break;
1286
252b5132 1287 case EM_MCORE:
9ea033b2 1288 rtype = elf_mcore_reloc_type (type);
252b5132
RH		 1289 break;
1290
3c3bdf30
NC		 1291 case EM_MMIX:
1292 rtype = elf_mmix_reloc_type (type);
1293 break;
1294
5506d11a
AM		 1295 case EM_MOXIE:
1296 rtype = elf_moxie_reloc_type (type);
1297 break;
1298
2469cfa2 1299 case EM_MSP430:
13761a11
NC		 1300 if (uses_msp430x_relocs ())
1301 {
1302 rtype = elf_msp430x_reloc_type (type);
1303 break;
1304 }
1a0670f3 1305 /* Fall through. */
2469cfa2
NC		 1306 case EM_MSP430_OLD:
1307 rtype = elf_msp430_reloc_type (type);
1308 break;
1309
35c08157
KLC		 1310 case EM_NDS32:
1311 rtype = elf_nds32_reloc_type (type);
1312 break;
1313
252b5132 1314 case EM_PPC:
9ea033b2 1315 rtype = elf_ppc_reloc_type (type);
252b5132
RH		 1316 break;
1317
c833c019
AM		 1318 case EM_PPC64:
1319 rtype = elf_ppc64_reloc_type (type);
1320 break;
1321
252b5132 1322 case EM_MIPS:
4fe85591 1323 case EM_MIPS_RS3_LE:
9ea033b2 1324 rtype = elf_mips_reloc_type (type);
252b5132
RH		 1325 break;
1326
e23eba97
NC		 1327 case EM_RISCV:
1328 rtype = elf_riscv_reloc_type (type);
1329 break;
1330
252b5132 1331 case EM_ALPHA:
9ea033b2 1332 rtype = elf_alpha_reloc_type (type);
252b5132
RH		 1333 break;
1334
1335 case EM_ARM:
9ea033b2 1336 rtype = elf_arm_reloc_type (type);
252b5132
RH		 1337 break;
1338
584da044 1339 case EM_ARC:
886a2506
NC		 1340 case EM_ARC_COMPACT:
1341 case EM_ARC_COMPACT2:
9ea033b2 1342 rtype = elf_arc_reloc_type (type);
252b5132
RH		 1343 break;
1344
1345 case EM_PARISC:
69e617ca 1346 rtype = elf_hppa_reloc_type (type);
252b5132 1347 break;
7d466069 1348
b8720f9d
JL		 1349 case EM_H8_300:
1350 case EM_H8_300H:
1351 case EM_H8S:
1352 rtype = elf_h8_reloc_type (type);
1353 break;
1354
73589c9d
CS		 1355 case EM_OR1K:
1356 rtype = elf_or1k_reloc_type (type);
3b16e843
NC		 1357 break;
1358
7d466069 1359 case EM_PJ:
2b0337b0 1360 case EM_PJ_OLD:
7d466069
ILT		 1361 rtype = elf_pj_reloc_type (type);
1362 break;
800eeca4
JW		 1363 case EM_IA_64:
1364 rtype = elf_ia64_reloc_type (type);
1365 break;
1b61cf92
HPN		 1366
1367 case EM_CRIS:
1368 rtype = elf_cris_reloc_type (type);
1369 break;
535c37ff
JE		 1370
1371 case EM_860:
1372 rtype = elf_i860_reloc_type (type);
1373 break;
bcedfee6
NC		 1374
1375 case EM_X86_64:
8a9036a4 1376 case EM_L1OM:
7a9068fe 1377 case EM_K1OM:
bcedfee6
NC		 1378 rtype = elf_x86_64_reloc_type (type);
1379 break;
a85d7ed0 1380
35b1837e
AM		 1381 case EM_S370:
1382 rtype = i370_reloc_type (type);
1383 break;
1384
53c7db4b
KH		 1385 case EM_S390_OLD:
1386 case EM_S390:
1387 rtype = elf_s390_reloc_type (type);
1388 break;
93fbbb04 1389
1c0d3aa6
NC		 1390 case EM_SCORE:
1391 rtype = elf_score_reloc_type (type);
1392 break;
1393
93fbbb04
GK		 1394 case EM_XSTORMY16:
1395 rtype = elf_xstormy16_reloc_type (type);
1396 break;
179d3252 1397
1fe1f39c
NC		 1398 case EM_CRX:
1399 rtype = elf_crx_reloc_type (type);
1400 break;
1401
179d3252
JT		 1402 case EM_VAX:
1403 rtype = elf_vax_reloc_type (type);
1404 break;
1e4cf259 1405
619ed720
EB		 1406 case EM_VISIUM:
1407 rtype = elf_visium_reloc_type (type);
1408 break;
1409
cfb8c092
NC		 1410 case EM_ADAPTEVA_EPIPHANY:
1411 rtype = elf_epiphany_reloc_type (type);
1412 break;
1413
1e4cf259
NC		 1414 case EM_IP2K:
1415 case EM_IP2K_OLD:
1416 rtype = elf_ip2k_reloc_type (type);
1417 break;
3b36097d
SC		 1418
1419 case EM_IQ2000:
1420 rtype = elf_iq2000_reloc_type (type);
1421 break;
88da6820
NC		 1422
1423 case EM_XTENSA_OLD:
1424 case EM_XTENSA:
1425 rtype = elf_xtensa_reloc_type (type);
1426 break;
a34e3ecb 1427
84e94c90
NC		 1428 case EM_LATTICEMICO32:
1429 rtype = elf_lm32_reloc_type (type);
1430 break;
1431
ff7eeb89 1432 case EM_M32C_OLD:
49f58d10
JB		 1433 case EM_M32C:
1434 rtype = elf_m32c_reloc_type (type);
1435 break;
1436
d031aafb
NS		 1437 case EM_MT:
1438 rtype = elf_mt_reloc_type (type);
a34e3ecb 1439 break;
1d65ded4
CM		 1440
1441 case EM_BLACKFIN:
1442 rtype = elf_bfin_reloc_type (type);
1443 break;
15ab5209
DB		 1444
1445 case EM_CYGNUS_MEP:
1446 rtype = elf_mep_reloc_type (type);
1447 break;
60bca95a
NC		 1448
1449 case EM_CR16:
1450 rtype = elf_cr16_reloc_type (type);
1451 break;
dd24e3da 1452
7ba29e2a
NC		 1453 case EM_MICROBLAZE:
1454 case EM_MICROBLAZE_OLD:
1455 rtype = elf_microblaze_reloc_type (type);
1456 break;
c7927a3c 1457
99c513f6
DD		 1458 case EM_RL78:
1459 rtype = elf_rl78_reloc_type (type);
1460 break;
1461
c7927a3c
NC		 1462 case EM_RX:
1463 rtype = elf_rx_reloc_type (type);
1464 break;
c29aca4a 1465
a3c62988
NC		 1466 case EM_METAG:
1467 rtype = elf_metag_reloc_type (type);
1468 break;
1469
c29aca4a
NC		 1470 case EM_XC16X:
1471 case EM_C166:
1472 rtype = elf_xc16x_reloc_type (type);
1473 break;
40b36596
JM		 1474
1475 case EM_TI_C6000:
1476 rtype = elf_tic6x_reloc_type (type);
1477 break;
aa137e4d
NC		 1478
1479 case EM_TILEGX:
1480 rtype = elf_tilegx_reloc_type (type);
1481 break;
1482
1483 case EM_TILEPRO:
1484 rtype = elf_tilepro_reloc_type (type);
1485 break;
f6c1a2d5
NC		 1486
1487 case EM_XGATE:
1488 rtype = elf_xgate_reloc_type (type);
1489 break;
36591ba1
SL		 1490
1491 case EM_ALTERA_NIOS2:
1492 rtype = elf_nios2_reloc_type (type);
1493 break;
2b100bb5
DD		 1494
1495 case EM_TI_PRU:
1496 rtype = elf_pru_reloc_type (type);
1497 break;
252b5132
RH		 1498 }
1499
1500 if (rtype == NULL)
39dbeff8 1501 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1502 else
8beeaeb7 1503 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1504
7ace3541 1505 if (elf_header.e_machine == EM_ALPHA
157c2599 1506 && rtype != NULL
7ace3541
RH		 1507 && streq (rtype, "R_ALPHA_LITUSE")
1508 && is_rela)
1509 {
1510 switch (rels[i].r_addend)
1511 {
1512 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1513 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1514 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1515 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1516 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1517 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1518 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1519 default: rtype = NULL;
1520 }
1521 if (rtype)
1522 printf (" (%s)", rtype);
1523 else
1524 {
1525 putchar (' ');
1526 printf (_("<unknown addend: %lx>"),
1527 (unsigned long) rels[i].r_addend);
1528 }
1529 }
1530 else if (symtab_index)
252b5132 1531 {
af3fc3bc 1532 if (symtab == NULL || symtab_index >= nsyms)
2b692964 1533 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
af3fc3bc 1534 else
19936277 1535 {
2cf0635d 1536 Elf_Internal_Sym * psym;
bb4d2ac2
L		 1537 const char * version_string;
1538 enum versioned_symbol_info sym_info;
1539 unsigned short vna_other;
19936277 1540
af3fc3bc 1541 psym = symtab + symtab_index;
103f02d3 1542
bb4d2ac2
L		 1543 version_string
1544 = get_symbol_version_string (file, is_dynsym,
1545 strtab, strtablen,
1546 symtab_index,
1547 psym,
1548 &sym_info,
1549 &vna_other);
1550
af3fc3bc 1551 printf (" ");
171191ba 1552
d8045f23
NC		 1553 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1554 {
1555 const char * name;
1556 unsigned int len;
1557 unsigned int width = is_32bit_elf ? 8 : 14;
1558
1559 /* Relocations against GNU_IFUNC symbols do not use the value
1560 of the symbol as the address to relocate against. Instead
1561 they invoke the function named by the symbol and use its
1562 result as the address for relocation.
1563
1564 To indicate this to the user, do not display the value of
1565 the symbol in the "Symbols's Value" field. Instead show
1566 its name followed by () as a hint that the symbol is
1567 invoked. */
1568
1569 if (strtab == NULL
1570 || psym->st_name == 0
1571 || psym->st_name >= strtablen)
1572 name = "??";
1573 else
1574 name = strtab + psym->st_name;
1575
1576 len = print_symbol (width, name);
bb4d2ac2
L		 1577 if (version_string)
1578 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1579 version_string);
d8045f23
NC		 1580 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1581 }
1582 else
1583 {
1584 print_vma (psym->st_value, LONG_HEX);
171191ba 1585
d8045f23
NC		 1586 printf (is_32bit_elf ? " " : " ");
1587 }
103f02d3 1588
af3fc3bc 1589 if (psym->st_name == 0)
f1ef08cb 1590 {
2cf0635d 1591 const char * sec_name = "<null>";
f1ef08cb
AM		 1592 char name_buf[40];
1593
1594 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1595 {
4fbb74a6 1596 if (psym->st_shndx < elf_header.e_shnum)
74e1a04b 1597 sec_name = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM		 1598 else if (psym->st_shndx == SHN_ABS)
1599 sec_name = "ABS";
1600 else if (psym->st_shndx == SHN_COMMON)
1601 sec_name = "COMMON";
ac145307
BS		 1602 else if ((elf_header.e_machine == EM_MIPS
1603 && psym->st_shndx == SHN_MIPS_SCOMMON)
1604 || (elf_header.e_machine == EM_TI_C6000
1605 && psym->st_shndx == SHN_TIC6X_SCOMMON))
172553c7
TS		 1606 sec_name = "SCOMMON";
1607 else if (elf_header.e_machine == EM_MIPS
1608 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1609 sec_name = "SUNDEF";
8a9036a4 1610 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 1611 || elf_header.e_machine == EM_L1OM
1612 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 1613 && psym->st_shndx == SHN_X86_64_LCOMMON)
1614 sec_name = "LARGE_COMMON";
9ce701e2
L		 1615 else if (elf_header.e_machine == EM_IA_64
1616 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1617 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1618 sec_name = "ANSI_COM";
28f997cf 1619 else if (is_ia64_vms ()
148b93f2
NC		 1620 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1621 sec_name = "VMS_SYMVEC";
f1ef08cb
AM		 1622 else
1623 {
1624 sprintf (name_buf, "<section 0x%x>",
1625 (unsigned int) psym->st_shndx);
1626 sec_name = name_buf;
1627 }
1628 }
1629 print_symbol (22, sec_name);
1630 }
af3fc3bc 1631 else if (strtab == NULL)
d79b3d50 1632 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1633 else if (psym->st_name >= strtablen)
d79b3d50 1634 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
af3fc3bc 1635 else
bb4d2ac2
L		 1636 {
1637 print_symbol (22, strtab + psym->st_name);
1638 if (version_string)
1639 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1640 version_string);
1641 }
103f02d3 1642
af3fc3bc 1643 if (is_rela)
171191ba 1644 {
7360e63f 1645 bfd_vma off = rels[i].r_addend;
171191ba 1646
7360e63f 1647 if ((bfd_signed_vma) off < 0)
598aaa76 1648 printf (" - %" BFD_VMA_FMT "x", - off);
171191ba 1649 else
598aaa76 1650 printf (" + %" BFD_VMA_FMT "x", off);
171191ba 1651 }
19936277 1652 }
252b5132 1653 }
1b228002 1654 else if (is_rela)
f7a99963 1655 {
7360e63f 1656 bfd_vma off = rels[i].r_addend;
e04d7088
L		 1657
1658 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
7360e63f 1659 if ((bfd_signed_vma) off < 0)
e04d7088
L		 1660 printf ("-%" BFD_VMA_FMT "x", - off);
1661 else
1662 printf ("%" BFD_VMA_FMT "x", off);
f7a99963 1663 }
252b5132 1664
157c2599
NC		 1665 if (elf_header.e_machine == EM_SPARCV9
1666 && rtype != NULL
1667 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1668 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1669
252b5132 1670 putchar ('\n');
2c71103e 1671
aca88567 1672#ifdef BFD64
53c7db4b 1673 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1674 {
91d6fa6a
NC		 1675 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1676 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC		 1677 const char * rtype2 = elf_mips_reloc_type (type2);
1678 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1679
2c71103e
NC		 1680 printf (" Type2: ");
1681
1682 if (rtype2 == NULL)
39dbeff8
AM		 1683 printf (_("unrecognized: %-7lx"),
1684 (unsigned long) type2 & 0xffffffff);
2c71103e
NC		 1685 else
1686 printf ("%-17.17s", rtype2);
1687
18bd398b 1688 printf ("\n Type3: ");
2c71103e
NC		 1689
1690 if (rtype3 == NULL)
39dbeff8
AM		 1691 printf (_("unrecognized: %-7lx"),
1692 (unsigned long) type3 & 0xffffffff);
2c71103e
NC		 1693 else
1694 printf ("%-17.17s", rtype3);
1695
53c7db4b 1696 putchar ('\n');
2c71103e 1697 }
aca88567 1698#endif /* BFD64 */
252b5132
RH		 1699 }
1700
c8286bd1 1701 free (rels);
252b5132
RH		 1702}
1703
1704static const char *
d3ba0551 1705get_mips_dynamic_type (unsigned long type)
252b5132
RH		 1706{
1707 switch (type)
1708 {
1709 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1710 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1711 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1712 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1713 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1714 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1715 case DT_MIPS_MSYM: return "MIPS_MSYM";
1716 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1717 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1718 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1719 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1720 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1721 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1722 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1723 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1724 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1725 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
a5499fa4 1726 case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
252b5132
RH		 1727 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1728 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1729 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1730 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1731 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1732 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1733 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1734 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1735 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1736 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1737 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1738 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1739 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1740 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1741 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1742 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1743 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1744 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1745 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1746 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1747 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1748 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1749 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1750 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1751 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1752 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1753 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1754 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1755 default:
1756 return NULL;
1757 }
1758}
1759
9a097730 1760static const char *
d3ba0551 1761get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1762{
1763 switch (type)
1764 {
1765 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1766 default:
1767 return NULL;
1768 }
103f02d3
UD		 1769}
1770
7490d522
AM		 1771static const char *
1772get_ppc_dynamic_type (unsigned long type)
1773{
1774 switch (type)
1775 {
a7f2871e 1776 case DT_PPC_GOT: return "PPC_GOT";
e8910a83 1777 case DT_PPC_OPT: return "PPC_OPT";
7490d522
AM		 1778 default:
1779 return NULL;
1780 }
1781}
1782
f1cb7e17 1783static const char *
d3ba0551 1784get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1785{
1786 switch (type)
1787 {
a7f2871e
AM		 1788 case DT_PPC64_GLINK: return "PPC64_GLINK";
1789 case DT_PPC64_OPD: return "PPC64_OPD";
1790 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
e8910a83 1791 case DT_PPC64_OPT: return "PPC64_OPT";
f1cb7e17
AM		 1792 default:
1793 return NULL;
1794 }
1795}
1796
103f02d3 1797static const char *
d3ba0551 1798get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1799{
1800 switch (type)
1801 {
1802 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1803 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1804 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1805 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1806 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1807 case DT_HP_PREINIT: return "HP_PREINIT";
1808 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1809 case DT_HP_NEEDED: return "HP_NEEDED";
1810 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1811 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1812 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1813 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1814 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1815 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1816 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1817 case DT_HP_FILTERED: return "HP_FILTERED";
1818 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1819 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1820 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1821 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1822 case DT_PLT: return "PLT";
1823 case DT_PLT_SIZE: return "PLT_SIZE";
1824 case DT_DLT: return "DLT";
1825 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1826 default:
1827 return NULL;
1828 }
1829}
9a097730 1830
ecc51f48 1831static const char *
d3ba0551 1832get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1833{
1834 switch (type)
1835 {
148b93f2
NC		 1836 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1837 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1838 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1839 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1840 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1841 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1842 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1843 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1844 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1845 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1846 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1847 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1848 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1849 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1850 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1851 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1852 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1853 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1854 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1855 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1856 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1857 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1858 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1859 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1860 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1861 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1862 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1863 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1864 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1865 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1866 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1867 default:
1868 return NULL;
1869 }
1870}
1871
fd85a6a1
NC		 1872static const char *
1873get_solaris_section_type (unsigned long type)
1874{
1875 switch (type)
1876 {
1877 case 0x6fffffee: return "SUNW_ancillary";
1878 case 0x6fffffef: return "SUNW_capchain";
1879 case 0x6ffffff0: return "SUNW_capinfo";
1880 case 0x6ffffff1: return "SUNW_symsort";
1881 case 0x6ffffff2: return "SUNW_tlssort";
1882 case 0x6ffffff3: return "SUNW_LDYNSYM";
1883 case 0x6ffffff4: return "SUNW_dof";
1884 case 0x6ffffff5: return "SUNW_cap";
1885 case 0x6ffffff6: return "SUNW_SIGNATURE";
1886 case 0x6ffffff7: return "SUNW_ANNOTATE";
1887 case 0x6ffffff8: return "SUNW_DEBUGSTR";
1888 case 0x6ffffff9: return "SUNW_DEBUG";
1889 case 0x6ffffffa: return "SUNW_move";
1890 case 0x6ffffffb: return "SUNW_COMDAT";
1891 case 0x6ffffffc: return "SUNW_syminfo";
1892 case 0x6ffffffd: return "SUNW_verdef";
1893 case 0x6ffffffe: return "SUNW_verneed";
1894 case 0x6fffffff: return "SUNW_versym";
1895 case 0x70000000: return "SPARC_GOTDATA";
1896 default: return NULL;
1897 }
1898}
1899
fabcb361
RH		 1900static const char *
1901get_alpha_dynamic_type (unsigned long type)
1902{
1903 switch (type)
1904 {
1905 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1906 default:
1907 return NULL;
1908 }
1909}
1910
1c0d3aa6
NC		 1911static const char *
1912get_score_dynamic_type (unsigned long type)
1913{
1914 switch (type)
1915 {
1916 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1917 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1918 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1919 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1920 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1921 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1922 default:
1923 return NULL;
1924 }
1925}
1926
40b36596
JM		 1927static const char *
1928get_tic6x_dynamic_type (unsigned long type)
1929{
1930 switch (type)
1931 {
1932 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1933 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1934 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1935 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1936 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1937 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1938 default:
1939 return NULL;
1940 }
1941}
1c0d3aa6 1942
36591ba1
SL		 1943static const char *
1944get_nios2_dynamic_type (unsigned long type)
1945{
1946 switch (type)
1947 {
1948 case DT_NIOS2_GP: return "NIOS2_GP";
1949 default:
1950 return NULL;
1951 }
1952}
1953
fd85a6a1
NC		 1954static const char *
1955get_solaris_dynamic_type (unsigned long type)
1956{
1957 switch (type)
1958 {
1959 case 0x6000000d: return "SUNW_AUXILIARY";
1960 case 0x6000000e: return "SUNW_RTLDINF";
1961 case 0x6000000f: return "SUNW_FILTER";
1962 case 0x60000010: return "SUNW_CAP";
1963 case 0x60000011: return "SUNW_SYMTAB";
1964 case 0x60000012: return "SUNW_SYMSZ";
1965 case 0x60000013: return "SUNW_SORTENT";
1966 case 0x60000014: return "SUNW_SYMSORT";
1967 case 0x60000015: return "SUNW_SYMSORTSZ";
1968 case 0x60000016: return "SUNW_TLSSORT";
1969 case 0x60000017: return "SUNW_TLSSORTSZ";
1970 case 0x60000018: return "SUNW_CAPINFO";
1971 case 0x60000019: return "SUNW_STRPAD";
1972 case 0x6000001a: return "SUNW_CAPCHAIN";
1973 case 0x6000001b: return "SUNW_LDMACH";
1974 case 0x6000001d: return "SUNW_CAPCHAINENT";
1975 case 0x6000001f: return "SUNW_CAPCHAINSZ";
1976 case 0x60000021: return "SUNW_PARENT";
1977 case 0x60000023: return "SUNW_ASLR";
1978 case 0x60000025: return "SUNW_RELAX";
1979 case 0x60000029: return "SUNW_NXHEAP";
1980 case 0x6000002b: return "SUNW_NXSTACK";
1981
1982 case 0x70000001: return "SPARC_REGISTER";
1983 case 0x7ffffffd: return "AUXILIARY";
1984 case 0x7ffffffe: return "USED";
1985 case 0x7fffffff: return "FILTER";
1986
15f205b1 1987 default: return NULL;
fd85a6a1
NC		 1988 }
1989}
1990
252b5132 1991static const char *
d3ba0551 1992get_dynamic_type (unsigned long type)
252b5132 1993{
e9e44622 1994 static char buff[64];
252b5132
RH		 1995
1996 switch (type)
1997 {
1998 case DT_NULL: return "NULL";
1999 case DT_NEEDED: return "NEEDED";
2000 case DT_PLTRELSZ: return "PLTRELSZ";
2001 case DT_PLTGOT: return "PLTGOT";
2002 case DT_HASH: return "HASH";
2003 case DT_STRTAB: return "STRTAB";
2004 case DT_SYMTAB: return "SYMTAB";
2005 case DT_RELA: return "RELA";
2006 case DT_RELASZ: return "RELASZ";
2007 case DT_RELAENT: return "RELAENT";
2008 case DT_STRSZ: return "STRSZ";
2009 case DT_SYMENT: return "SYMENT";
2010 case DT_INIT: return "INIT";
2011 case DT_FINI: return "FINI";
2012 case DT_SONAME: return "SONAME";
2013 case DT_RPATH: return "RPATH";
2014 case DT_SYMBOLIC: return "SYMBOLIC";
2015 case DT_REL: return "REL";
2016 case DT_RELSZ: return "RELSZ";
2017 case DT_RELENT: return "RELENT";
2018 case DT_PLTREL: return "PLTREL";
2019 case DT_DEBUG: return "DEBUG";
2020 case DT_TEXTREL: return "TEXTREL";
2021 case DT_JMPREL: return "JMPREL";
2022 case DT_BIND_NOW: return "BIND_NOW";
2023 case DT_INIT_ARRAY: return "INIT_ARRAY";
2024 case DT_FINI_ARRAY: return "FINI_ARRAY";
2025 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2026 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 2027 case DT_RUNPATH: return "RUNPATH";
2028 case DT_FLAGS: return "FLAGS";
2d0e6f43 2029
d1133906
NC		 2030 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2031 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
6d913794 2032 case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
103f02d3 2033
05107a46 2034 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 2035 case DT_PLTPADSZ: return "PLTPADSZ";
2036 case DT_MOVEENT: return "MOVEENT";
2037 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 2038 case DT_FEATURE: return "FEATURE";
252b5132
RH		 2039 case DT_POSFLAG_1: return "POSFLAG_1";
2040 case DT_SYMINSZ: return "SYMINSZ";
2041 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 2042
252b5132 2043 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 2044 case DT_CONFIG: return "CONFIG";
2045 case DT_DEPAUDIT: return "DEPAUDIT";
2046 case DT_AUDIT: return "AUDIT";
2047 case DT_PLTPAD: return "PLTPAD";
2048 case DT_MOVETAB: return "MOVETAB";
252b5132 2049 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 2050
252b5132 2051 case DT_VERSYM: return "VERSYM";
103f02d3 2052
67a4f2b7
AO		 2053 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2054 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 2055 case DT_RELACOUNT: return "RELACOUNT";
2056 case DT_RELCOUNT: return "RELCOUNT";
2057 case DT_FLAGS_1: return "FLAGS_1";
2058 case DT_VERDEF: return "VERDEF";
2059 case DT_VERDEFNUM: return "VERDEFNUM";
2060 case DT_VERNEED: return "VERNEED";
2061 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 2062
019148e4 2063 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 2064 case DT_USED: return "USED";
2065 case DT_FILTER: return "FILTER";
103f02d3 2066
047b2264
JJ		 2067 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2068 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2069 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2070 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2071 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 2072 case DT_GNU_HASH: return "GNU_HASH";
047b2264 2073
252b5132
RH		 2074 default:
2075 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2076 {
2cf0635d 2077 const char * result;
103f02d3 2078
252b5132
RH		 2079 switch (elf_header.e_machine)
2080 {
2081 case EM_MIPS:
4fe85591 2082 case EM_MIPS_RS3_LE:
252b5132
RH		 2083 result = get_mips_dynamic_type (type);
2084 break;
9a097730
RH		 2085 case EM_SPARCV9:
2086 result = get_sparc64_dynamic_type (type);
2087 break;
7490d522
AM		 2088 case EM_PPC:
2089 result = get_ppc_dynamic_type (type);
2090 break;
f1cb7e17
AM		 2091 case EM_PPC64:
2092 result = get_ppc64_dynamic_type (type);
2093 break;
ecc51f48
NC		 2094 case EM_IA_64:
2095 result = get_ia64_dynamic_type (type);
2096 break;
fabcb361
RH		 2097 case EM_ALPHA:
2098 result = get_alpha_dynamic_type (type);
2099 break;
1c0d3aa6
NC		 2100 case EM_SCORE:
2101 result = get_score_dynamic_type (type);
2102 break;
40b36596
JM		 2103 case EM_TI_C6000:
2104 result = get_tic6x_dynamic_type (type);
2105 break;
36591ba1
SL		 2106 case EM_ALTERA_NIOS2:
2107 result = get_nios2_dynamic_type (type);
2108 break;
252b5132 2109 default:
fd85a6a1
NC		 2110 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2111 result = get_solaris_dynamic_type (type);
2112 else
2113 result = NULL;
252b5132
RH		 2114 break;
2115 }
2116
2117 if (result != NULL)
2118 return result;
2119
e9e44622 2120 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 2121 }
eec8f817
DA		 2122 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2123 || (elf_header.e_machine == EM_PARISC
2124 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 2125 {
2cf0635d 2126 const char * result;
103f02d3
UD		 2127
2128 switch (elf_header.e_machine)
2129 {
2130 case EM_PARISC:
2131 result = get_parisc_dynamic_type (type);
2132 break;
148b93f2
NC		 2133 case EM_IA_64:
2134 result = get_ia64_dynamic_type (type);
2135 break;
103f02d3 2136 default:
fd85a6a1
NC		 2137 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2138 result = get_solaris_dynamic_type (type);
2139 else
2140 result = NULL;
103f02d3
UD		 2141 break;
2142 }
2143
2144 if (result != NULL)
2145 return result;
2146
e9e44622
JJ		 2147 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2148 type);
103f02d3 2149 }
252b5132 2150 else
e9e44622 2151 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 2152
252b5132
RH		 2153 return buff;
2154 }
2155}
2156
2157static char *
d3ba0551 2158get_file_type (unsigned e_type)
252b5132 2159{
b34976b6 2160 static char buff[32];
252b5132
RH		 2161
2162 switch (e_type)
2163 {
2164 case ET_NONE: return _("NONE (None)");
2165 case ET_REL: return _("REL (Relocatable file)");
ba2685cc
AM		 2166 case ET_EXEC: return _("EXEC (Executable file)");
2167 case ET_DYN: return _("DYN (Shared object file)");
2168 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 2169
2170 default:
2171 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 2172 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 2173 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 2174 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 2175 else
e9e44622 2176 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 2177 return buff;
2178 }
2179}
2180
2181static char *
d3ba0551 2182get_machine_name (unsigned e_machine)
252b5132 2183{
b34976b6 2184 static char buff[64]; /* XXX */
252b5132
RH		 2185
2186 switch (e_machine)
2187 {
c45021f2 2188 case EM_NONE: return _("None");
a06ea964 2189 case EM_AARCH64: return "AArch64";
c45021f2
NC		 2190 case EM_M32: return "WE32100";
2191 case EM_SPARC: return "Sparc";
e9f53129 2192 case EM_SPU: return "SPU";
c45021f2
NC		 2193 case EM_386: return "Intel 80386";
2194 case EM_68K: return "MC68000";
2195 case EM_88K: return "MC88000";
22abe556 2196 case EM_IAMCU: return "Intel MCU";
c45021f2
NC		 2197 case EM_860: return "Intel 80860";
2198 case EM_MIPS: return "MIPS R3000";
2199 case EM_S370: return "IBM System/370";
7036c0e1 2200 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 2201 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 2202 case EM_PARISC: return "HPPA";
252b5132 2203 case EM_PPC_OLD: return "Power PC (old)";
7036c0e1 2204 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 2205 case EM_960: return "Intel 90860";
2206 case EM_PPC: return "PowerPC";
285d1771 2207 case EM_PPC64: return "PowerPC64";
c45021f2 2208 case EM_FR20: return "Fujitsu FR20";
3f8107ab 2209 case EM_FT32: return "FTDI FT32";
c45021f2 2210 case EM_RH32: return "TRW RH32";
b34976b6 2211 case EM_MCORE: return "MCORE";
7036c0e1
AJ		 2212 case EM_ARM: return "ARM";
2213 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 2214 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 2215 case EM_SPARCV9: return "Sparc v9";
2216 case EM_TRICORE: return "Siemens Tricore";
584da044 2217 case EM_ARC: return "ARC";
886a2506
NC		 2218 case EM_ARC_COMPACT: return "ARCompact";
2219 case EM_ARC_COMPACT2: return "ARCv2";
c2dcd04e
NC		 2220 case EM_H8_300: return "Renesas H8/300";
2221 case EM_H8_300H: return "Renesas H8/300H";
2222 case EM_H8S: return "Renesas H8S";
2223 case EM_H8_500: return "Renesas H8/500";
30800947 2224 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 2225 case EM_MIPS_X: return "Stanford MIPS-X";
2226 case EM_COLDFIRE: return "Motorola Coldfire";
c45021f2 2227 case EM_ALPHA: return "Alpha";
2b0337b0
AO		 2228 case EM_CYGNUS_D10V:
2229 case EM_D10V: return "d10v";
2230 case EM_CYGNUS_D30V:
b34976b6 2231 case EM_D30V: return "d30v";
2b0337b0 2232 case EM_CYGNUS_M32R:
26597c86 2233 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2b0337b0 2234 case EM_CYGNUS_V850:
708e2187 2235 case EM_V800: return "Renesas V850 (using RH850 ABI)";
f6c1a2d5 2236 case EM_V850: return "Renesas V850";
2b0337b0
AO		 2237 case EM_CYGNUS_MN10300:
2238 case EM_MN10300: return "mn10300";
2239 case EM_CYGNUS_MN10200:
2240 case EM_MN10200: return "mn10200";
5506d11a 2241 case EM_MOXIE: return "Moxie";
2b0337b0
AO		 2242 case EM_CYGNUS_FR30:
2243 case EM_FR30: return "Fujitsu FR30";
b34976b6 2244 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2b0337b0 2245 case EM_PJ_OLD:
b34976b6 2246 case EM_PJ: return "picoJava";
7036c0e1
AJ		 2247 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2248 case EM_PCP: return "Siemens PCP";
2249 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2250 case EM_NDR1: return "Denso NDR1 microprocesspr";
2251 case EM_STARCORE: return "Motorola Star*Core processor";
2252 case EM_ME16: return "Toyota ME16 processor";
2253 case EM_ST100: return "STMicroelectronics ST100 processor";
2254 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
11636f9e
JM		 2255 case EM_PDSP: return "Sony DSP processor";
2256 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2257 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 2258 case EM_FX66: return "Siemens FX66 microcontroller";
2259 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2260 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2261 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
6927f982 2262 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
7036c0e1
AJ		 2263 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2264 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2265 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2266 case EM_SVX: return "Silicon Graphics SVx";
2267 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2268 case EM_VAX: return "Digital VAX";
619ed720 2269 case EM_VISIUM: return "CDS VISIUMcore processor";
2b0337b0 2270 case EM_AVR_OLD:
b34976b6 2271 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1b61cf92 2272 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 2273 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2274 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2275 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
b34976b6 2276 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 2277 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 2278 case EM_PRISM: return "Vitesse Prism";
bcedfee6 2279 case EM_X86_64: return "Advanced Micro Devices X86-64";
8a9036a4 2280 case EM_L1OM: return "Intel L1OM";
7a9068fe 2281 case EM_K1OM: return "Intel K1OM";
b7498e0e 2282 case EM_S390_OLD:
b34976b6 2283 case EM_S390: return "IBM S/390";
1c0d3aa6 2284 case EM_SCORE: return "SUNPLUS S+Core";
61865e30 2285 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
73589c9d 2286 case EM_OR1K: return "OpenRISC 1000";
1fe1f39c 2287 case EM_CRX: return "National Semiconductor CRX microprocessor";
cfb8c092 2288 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
d172d4ba 2289 case EM_DLX: return "OpenDLX";
1e4cf259 2290 case EM_IP2K_OLD:
b34976b6 2291 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
3b36097d 2292 case EM_IQ2000: return "Vitesse IQ2000";
88da6820
NC		 2293 case EM_XTENSA_OLD:
2294 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 2295 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2296 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2297 case EM_NS32K: return "National Semiconductor 32000 series";
2298 case EM_TPC: return "Tenor Network TPC processor";
2299 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2300 case EM_MAX: return "MAX Processor";
2301 case EM_CR: return "National Semiconductor CompactRISC";
2302 case EM_F2MC16: return "Fujitsu F2MC16";
2303 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
84e94c90 2304 case EM_LATTICEMICO32: return "Lattice Mico32";
ff7eeb89 2305 case EM_M32C_OLD:
49f58d10 2306 case EM_M32C: return "Renesas M32c";
d031aafb 2307 case EM_MT: return "Morpho Techologies MT processor";
7bbe5bc5 2308 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 2309 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2310 case EM_SEP: return "Sharp embedded microprocessor";
2311 case EM_ARCA: return "Arca RISC microprocessor";
2312 case EM_UNICORE: return "Unicore";
2313 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2314 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348
NC		 2315 case EM_NIOS32: return "Altera Nios";
2316 case EM_ALTERA_NIOS2: return "Altera Nios II";
c29aca4a 2317 case EM_C166:
d70c5fc7 2318 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 2319 case EM_M16C: return "Renesas M16C series microprocessors";
2320 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2321 case EM_CE: return "Freescale Communication Engine RISC core";
2322 case EM_TSK3000: return "Altium TSK3000 core";
2323 case EM_RS08: return "Freescale RS08 embedded processor";
2324 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2325 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2326 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2327 case EM_SE_C17: return "Seiko Epson C17 family";
2328 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2329 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2330 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2331 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2332 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2333 case EM_R32C: return "Renesas R32C series microprocessors";
2334 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2335 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2336 case EM_8051: return "Intel 8051 and variants";
2337 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2338 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2339 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2340 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2341 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2342 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2343 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
15ab5209 2344 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
cb8f3167 2345 case EM_CR16:
f6c1a2d5 2346 case EM_MICROBLAZE:
7ba29e2a 2347 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
e23eba97 2348 case EM_RISCV: return "RISC-V";
99c513f6 2349 case EM_RL78: return "Renesas RL78";
c7927a3c 2350 case EM_RX: return "Renesas RX";
a3c62988 2351 case EM_METAG: return "Imagination Technologies Meta processor architecture";
11636f9e
JM		 2352 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2353 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2354 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2355 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2356 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2357 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2358 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2359 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
aa137e4d 2360 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
11636f9e 2361 case EM_CUDA: return "NVIDIA CUDA architecture";
f6c1a2d5 2362 case EM_XGATE: return "Motorola XGATE embedded processor";
6d913794
NC		 2363 case EM_CLOUDSHIELD: return "CloudShield architecture family";
2364 case EM_COREA_1ST: return "KIPO-KAIST Core-A 1st generation processor family";
2365 case EM_COREA_2ND: return "KIPO-KAIST Core-A 2nd generation processor family";
2366 case EM_OPEN8: return "Open8 8-bit RISC soft processor core";
2367 case EM_VIDEOCORE5: return "Broadcom VideoCore V processor";
2368 case EM_56800EX: return "Freescale 56800EX Digital Signal Controller (DSC)";
15f205b1
NC		 2369 case EM_BA1: return "Beyond BA1 CPU architecture";
2370 case EM_BA2: return "Beyond BA2 CPU architecture";
6d913794
NC		 2371 case EM_XCORE: return "XMOS xCORE processor family";
2372 case EM_MCHP_PIC: return "Microchip 8-bit PIC(r) family";
2373 case EM_KM32: return "KM211 KM32 32-bit processor";
2374 case EM_KMX32: return "KM211 KMX32 32-bit processor";
2375 case EM_KMX16: return "KM211 KMX16 16-bit processor";
2376 case EM_KMX8: return "KM211 KMX8 8-bit processor";
2377 case EM_KVARC: return "KM211 KVARC processor";
15f205b1 2378 case EM_CDP: return "Paneve CDP architecture family";
6d913794
NC		 2379 case EM_COGE: return "Cognitive Smart Memory Processor";
2380 case EM_COOL: return "Bluechip Systems CoolEngine";
2381 case EM_NORC: return "Nanoradio Optimized RISC";
2382 case EM_CSR_KALIMBA: return "CSR Kalimba architecture family";
15f205b1 2383 case EM_Z80: return "Zilog Z80";
6d913794 2384 case EM_AMDGPU: return "AMD GPU architecture";
2b100bb5 2385 case EM_TI_PRU: return "TI PRU I/O processor";
252b5132 2386 default:
35d9dd2f 2387 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 2388 return buff;
2389 }
2390}
2391
a9522a21
AB		 2392static void
2393decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2394{
2395 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2396 other compilers don't a specific architecture type in the e_flags, and
2397 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2398 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2399 architectures.
2400
2401 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2402 but also sets a specific architecture type in the e_flags field.
2403
2404 However, when decoding the flags we don't worry if we see an
2405 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2406 ARCEM architecture type. */
2407
2408 switch (e_flags & EF_ARC_MACH_MSK)
2409 {
2410 /* We only expect these to occur for EM_ARC_COMPACT2. */
2411 case EF_ARC_CPU_ARCV2EM:
2412 strcat (buf, ", ARC EM");
2413 break;
2414 case EF_ARC_CPU_ARCV2HS:
2415 strcat (buf, ", ARC HS");
2416 break;
2417
2418 /* We only expect these to occur for EM_ARC_COMPACT. */
2419 case E_ARC_MACH_ARC600:
2420 strcat (buf, ", ARC600");
2421 break;
2422 case E_ARC_MACH_ARC601:
2423 strcat (buf, ", ARC601");
2424 break;
2425 case E_ARC_MACH_ARC700:
2426 strcat (buf, ", ARC700");
2427 break;
2428
2429 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2430 new ELF with new architecture being read by an old version of
2431 readelf, or (c) An ELF built with non-GNU compiler that does not
2432 set the architecture in the e_flags. */
2433 default:
2434 if (e_machine == EM_ARC_COMPACT)
2435 strcat (buf, ", Unknown ARCompact");
2436 else
2437 strcat (buf, ", Unknown ARC");
2438 break;
2439 }
2440
2441 switch (e_flags & EF_ARC_OSABI_MSK)
2442 {
2443 case E_ARC_OSABI_ORIG:
2444 strcat (buf, ", (ABI:legacy)");
2445 break;
2446 case E_ARC_OSABI_V2:
2447 strcat (buf, ", (ABI:v2)");
2448 break;
2449 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2450 case E_ARC_OSABI_V3:
2451 strcat (buf, ", v3 no-legacy-syscalls ABI");
2452 break;
2453 default:
2454 strcat (buf, ", unrecognised ARC OSABI flag");
2455 break;
2456 }
2457}
2458
f3485b74 2459static void
d3ba0551 2460decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 2461{
2462 unsigned eabi;
2463 int unknown = 0;
2464
2465 eabi = EF_ARM_EABI_VERSION (e_flags);
2466 e_flags &= ~ EF_ARM_EABIMASK;
2467
2468 /* Handle "generic" ARM flags. */
2469 if (e_flags & EF_ARM_RELEXEC)
2470 {
2471 strcat (buf, ", relocatable executable");
2472 e_flags &= ~ EF_ARM_RELEXEC;
2473 }
76da6bbe 2474
f3485b74
NC		 2475 /* Now handle EABI specific flags. */
2476 switch (eabi)
2477 {
2478 default:
2c71103e 2479 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC		 2480 if (e_flags)
2481 unknown = 1;
2482 break;
2483
2484 case EF_ARM_EABI_VER1:
a5bcd848 2485 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2486 while (e_flags)
2487 {
2488 unsigned flag;
76da6bbe 2489
f3485b74
NC		 2490 /* Process flags one bit at a time. */
2491 flag = e_flags & - e_flags;
2492 e_flags &= ~ flag;
76da6bbe 2493
f3485b74
NC		 2494 switch (flag)
2495 {
a5bcd848 2496 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2497 strcat (buf, ", sorted symbol tables");
2498 break;
76da6bbe 2499
f3485b74
NC		 2500 default:
2501 unknown = 1;
2502 break;
2503 }
2504 }
2505 break;
76da6bbe 2506
a5bcd848
PB		 2507 case EF_ARM_EABI_VER2:
2508 strcat (buf, ", Version2 EABI");
2509 while (e_flags)
2510 {
2511 unsigned flag;
2512
2513 /* Process flags one bit at a time. */
2514 flag = e_flags & - e_flags;
2515 e_flags &= ~ flag;
2516
2517 switch (flag)
2518 {
2519 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2520 strcat (buf, ", sorted symbol tables");
2521 break;
2522
2523 case EF_ARM_DYNSYMSUSESEGIDX:
2524 strcat (buf, ", dynamic symbols use segment index");
2525 break;
2526
2527 case EF_ARM_MAPSYMSFIRST:
2528 strcat (buf, ", mapping symbols precede others");
2529 break;
2530
2531 default:
2532 unknown = 1;
2533 break;
2534 }
2535 }
2536 break;
2537
d507cf36
PB		 2538 case EF_ARM_EABI_VER3:
2539 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2540 break;
2541
2542 case EF_ARM_EABI_VER4:
2543 strcat (buf, ", Version4 EABI");
3bfcb652
NC		 2544 while (e_flags)
2545 {
2546 unsigned flag;
2547
2548 /* Process flags one bit at a time. */
2549 flag = e_flags & - e_flags;
2550 e_flags &= ~ flag;
2551
2552 switch (flag)
2553 {
2554 case EF_ARM_BE8:
2555 strcat (buf, ", BE8");
2556 break;
2557
2558 case EF_ARM_LE8:
2559 strcat (buf, ", LE8");
2560 break;
2561
2562 default:
2563 unknown = 1;
2564 break;
2565 }
2566 break;
2567 }
2568 break;
3a4a14e9
PB		 2569
2570 case EF_ARM_EABI_VER5:
2571 strcat (buf, ", Version5 EABI");
d507cf36
PB		 2572 while (e_flags)
2573 {
2574 unsigned flag;
2575
2576 /* Process flags one bit at a time. */
2577 flag = e_flags & - e_flags;
2578 e_flags &= ~ flag;
2579
2580 switch (flag)
2581 {
2582 case EF_ARM_BE8:
2583 strcat (buf, ", BE8");
2584 break;
2585
2586 case EF_ARM_LE8:
2587 strcat (buf, ", LE8");
2588 break;
2589
3bfcb652
NC		 2590 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2591 strcat (buf, ", soft-float ABI");
2592 break;
2593
2594 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2595 strcat (buf, ", hard-float ABI");
2596 break;
2597
d507cf36
PB		 2598 default:
2599 unknown = 1;
2600 break;
2601 }
2602 }
2603 break;
2604
f3485b74 2605 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2606 strcat (buf, ", GNU EABI");
f3485b74
NC		 2607 while (e_flags)
2608 {
2609 unsigned flag;
76da6bbe 2610
f3485b74
NC		 2611 /* Process flags one bit at a time. */
2612 flag = e_flags & - e_flags;
2613 e_flags &= ~ flag;
76da6bbe 2614
f3485b74
NC		 2615 switch (flag)
2616 {
a5bcd848 2617 case EF_ARM_INTERWORK:
f3485b74
NC		 2618 strcat (buf, ", interworking enabled");
2619 break;
76da6bbe 2620
a5bcd848 2621 case EF_ARM_APCS_26:
f3485b74
NC		 2622 strcat (buf, ", uses APCS/26");
2623 break;
76da6bbe 2624
a5bcd848 2625 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2626 strcat (buf, ", uses APCS/float");
2627 break;
76da6bbe 2628
a5bcd848 2629 case EF_ARM_PIC:
f3485b74
NC		 2630 strcat (buf, ", position independent");
2631 break;
76da6bbe 2632
a5bcd848 2633 case EF_ARM_ALIGN8:
f3485b74
NC		 2634 strcat (buf, ", 8 bit structure alignment");
2635 break;
76da6bbe 2636
a5bcd848 2637 case EF_ARM_NEW_ABI:
f3485b74
NC		 2638 strcat (buf, ", uses new ABI");
2639 break;
76da6bbe 2640
a5bcd848 2641 case EF_ARM_OLD_ABI:
f3485b74
NC		 2642 strcat (buf, ", uses old ABI");
2643 break;
76da6bbe 2644
a5bcd848 2645 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2646 strcat (buf, ", software FP");
2647 break;
76da6bbe 2648
90e01f86
ILT		 2649 case EF_ARM_VFP_FLOAT:
2650 strcat (buf, ", VFP");
2651 break;
2652
fde78edd
NC		 2653 case EF_ARM_MAVERICK_FLOAT:
2654 strcat (buf, ", Maverick FP");
2655 break;
2656
f3485b74
NC		 2657 default:
2658 unknown = 1;
2659 break;
2660 }
2661 }
2662 }
f3485b74
NC		 2663
2664 if (unknown)
2b692964 2665 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2666}
2667
343433df
AB		 2668static void
2669decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2670{
2671 --size; /* Leave space for null terminator. */
2672
2673 switch (e_flags & EF_AVR_MACH)
2674 {
2675 case E_AVR_MACH_AVR1:
2676 strncat (buf, ", avr:1", size);
2677 break;
2678 case E_AVR_MACH_AVR2:
2679 strncat (buf, ", avr:2", size);
2680 break;
2681 case E_AVR_MACH_AVR25:
2682 strncat (buf, ", avr:25", size);
2683 break;
2684 case E_AVR_MACH_AVR3:
2685 strncat (buf, ", avr:3", size);
2686 break;
2687 case E_AVR_MACH_AVR31:
2688 strncat (buf, ", avr:31", size);
2689 break;
2690 case E_AVR_MACH_AVR35:
2691 strncat (buf, ", avr:35", size);
2692 break;
2693 case E_AVR_MACH_AVR4:
2694 strncat (buf, ", avr:4", size);
2695 break;
2696 case E_AVR_MACH_AVR5:
2697 strncat (buf, ", avr:5", size);
2698 break;
2699 case E_AVR_MACH_AVR51:
2700 strncat (buf, ", avr:51", size);
2701 break;
2702 case E_AVR_MACH_AVR6:
2703 strncat (buf, ", avr:6", size);
2704 break;
2705 case E_AVR_MACH_AVRTINY:
2706 strncat (buf, ", avr:100", size);
2707 break;
2708 case E_AVR_MACH_XMEGA1:
2709 strncat (buf, ", avr:101", size);
2710 break;
2711 case E_AVR_MACH_XMEGA2:
2712 strncat (buf, ", avr:102", size);
2713 break;
2714 case E_AVR_MACH_XMEGA3:
2715 strncat (buf, ", avr:103", size);
2716 break;
2717 case E_AVR_MACH_XMEGA4:
2718 strncat (buf, ", avr:104", size);
2719 break;
2720 case E_AVR_MACH_XMEGA5:
2721 strncat (buf, ", avr:105", size);
2722 break;
2723 case E_AVR_MACH_XMEGA6:
2724 strncat (buf, ", avr:106", size);
2725 break;
2726 case E_AVR_MACH_XMEGA7:
2727 strncat (buf, ", avr:107", size);
2728 break;
2729 default:
2730 strncat (buf, ", avr:<unknown>", size);
2731 break;
2732 }
2733
2734 size -= strlen (buf);
2735 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2736 strncat (buf, ", link-relax", size);
2737}
2738
35c08157
KLC		 2739static void
2740decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2741{
2742 unsigned abi;
2743 unsigned arch;
2744 unsigned config;
2745 unsigned version;
2746 int has_fpu = 0;
2747 int r = 0;
2748
2749 static const char *ABI_STRINGS[] =
2750 {
2751 "ABI v0", /* use r5 as return register; only used in N1213HC */
2752 "ABI v1", /* use r0 as return register */
2753 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2754 "ABI v2fp", /* for FPU */
40c7a7cb
KLC		 2755 "AABI",
2756 "ABI2 FP+"
35c08157
KLC		 2757 };
2758 static const char *VER_STRINGS[] =
2759 {
2760 "Andes ELF V1.3 or older",
2761 "Andes ELF V1.3.1",
2762 "Andes ELF V1.4"
2763 };
2764 static const char *ARCH_STRINGS[] =
2765 {
2766 "",
2767 "Andes Star v1.0",
2768 "Andes Star v2.0",
2769 "Andes Star v3.0",
2770 "Andes Star v3.0m"
2771 };
2772
2773 abi = EF_NDS_ABI & e_flags;
2774 arch = EF_NDS_ARCH & e_flags;
2775 config = EF_NDS_INST & e_flags;
2776 version = EF_NDS32_ELF_VERSION & e_flags;
2777
2778 memset (buf, 0, size);
2779
2780 switch (abi)
2781 {
2782 case E_NDS_ABI_V0:
2783 case E_NDS_ABI_V1:
2784 case E_NDS_ABI_V2:
2785 case E_NDS_ABI_V2FP:
2786 case E_NDS_ABI_AABI:
40c7a7cb 2787 case E_NDS_ABI_V2FP_PLUS:
35c08157
KLC		 2788 /* In case there are holes in the array. */
2789 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2790 break;
2791
2792 default:
2793 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2794 break;
2795 }
2796
2797 switch (version)
2798 {
2799 case E_NDS32_ELF_VER_1_2:
2800 case E_NDS32_ELF_VER_1_3:
2801 case E_NDS32_ELF_VER_1_4:
2802 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2803 break;
2804
2805 default:
2806 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2807 break;
2808 }
2809
2810 if (E_NDS_ABI_V0 == abi)
2811 {
2812 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2813 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2814 if (arch == E_NDS_ARCH_STAR_V1_0)
2815 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2816 return;
2817 }
2818
2819 switch (arch)
2820 {
2821 case E_NDS_ARCH_STAR_V1_0:
2822 case E_NDS_ARCH_STAR_V2_0:
2823 case E_NDS_ARCH_STAR_V3_0:
2824 case E_NDS_ARCH_STAR_V3_M:
2825 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2826 break;
2827
2828 default:
2829 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2830 /* ARCH version determines how the e_flags are interpreted.
2831 If it is unknown, we cannot proceed. */
2832 return;
2833 }
2834
2835 /* Newer ABI; Now handle architecture specific flags. */
2836 if (arch == E_NDS_ARCH_STAR_V1_0)
2837 {
2838 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2839 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2840
2841 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2842 r += snprintf (buf + r, size -r, ", MAC");
2843
2844 if (config & E_NDS32_HAS_DIV_INST)
2845 r += snprintf (buf + r, size -r, ", DIV");
2846
2847 if (config & E_NDS32_HAS_16BIT_INST)
2848 r += snprintf (buf + r, size -r, ", 16b");
2849 }
2850 else
2851 {
2852 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2853 {
2854 if (version <= E_NDS32_ELF_VER_1_3)
2855 r += snprintf (buf + r, size -r, ", [B8]");
2856 else
2857 r += snprintf (buf + r, size -r, ", EX9");
2858 }
2859
2860 if (config & E_NDS32_HAS_MAC_DX_INST)
2861 r += snprintf (buf + r, size -r, ", MAC_DX");
2862
2863 if (config & E_NDS32_HAS_DIV_DX_INST)
2864 r += snprintf (buf + r, size -r, ", DIV_DX");
2865
2866 if (config & E_NDS32_HAS_16BIT_INST)
2867 {
2868 if (version <= E_NDS32_ELF_VER_1_3)
2869 r += snprintf (buf + r, size -r, ", 16b");
2870 else
2871 r += snprintf (buf + r, size -r, ", IFC");
2872 }
2873 }
2874
2875 if (config & E_NDS32_HAS_EXT_INST)
2876 r += snprintf (buf + r, size -r, ", PERF1");
2877
2878 if (config & E_NDS32_HAS_EXT2_INST)
2879 r += snprintf (buf + r, size -r, ", PERF2");
2880
2881 if (config & E_NDS32_HAS_FPU_INST)
2882 {
2883 has_fpu = 1;
2884 r += snprintf (buf + r, size -r, ", FPU_SP");
2885 }
2886
2887 if (config & E_NDS32_HAS_FPU_DP_INST)
2888 {
2889 has_fpu = 1;
2890 r += snprintf (buf + r, size -r, ", FPU_DP");
2891 }
2892
2893 if (config & E_NDS32_HAS_FPU_MAC_INST)
2894 {
2895 has_fpu = 1;
2896 r += snprintf (buf + r, size -r, ", FPU_MAC");
2897 }
2898
2899 if (has_fpu)
2900 {
2901 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2902 {
2903 case E_NDS32_FPU_REG_8SP_4DP:
2904 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2905 break;
2906 case E_NDS32_FPU_REG_16SP_8DP:
2907 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2908 break;
2909 case E_NDS32_FPU_REG_32SP_16DP:
2910 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2911 break;
2912 case E_NDS32_FPU_REG_32SP_32DP:
2913 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2914 break;
2915 }
2916 }
2917
2918 if (config & E_NDS32_HAS_AUDIO_INST)
2919 r += snprintf (buf + r, size -r, ", AUDIO");
2920
2921 if (config & E_NDS32_HAS_STRING_INST)
2922 r += snprintf (buf + r, size -r, ", STR");
2923
2924 if (config & E_NDS32_HAS_REDUCED_REGS)
2925 r += snprintf (buf + r, size -r, ", 16REG");
2926
2927 if (config & E_NDS32_HAS_VIDEO_INST)
2928 {
2929 if (version <= E_NDS32_ELF_VER_1_3)
2930 r += snprintf (buf + r, size -r, ", VIDEO");
2931 else
2932 r += snprintf (buf + r, size -r, ", SATURATION");
2933 }
2934
2935 if (config & E_NDS32_HAS_ENCRIPT_INST)
2936 r += snprintf (buf + r, size -r, ", ENCRP");
2937
2938 if (config & E_NDS32_HAS_L2C_INST)
2939 r += snprintf (buf + r, size -r, ", L2C");
2940}
2941
252b5132 2942static char *
d3ba0551 2943get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2944{
b34976b6 2945 static char buf[1024];
252b5132
RH		 2946
2947 buf[0] = '\0';
76da6bbe 2948
252b5132
RH		 2949 if (e_flags)
2950 {
2951 switch (e_machine)
2952 {
2953 default:
2954 break;
2955
886a2506 2956 case EM_ARC_COMPACT2:
886a2506 2957 case EM_ARC_COMPACT:
a9522a21
AB		 2958 decode_ARC_machine_flags (e_flags, e_machine, buf);
2959 break;
886a2506 2960
f3485b74
NC		 2961 case EM_ARM:
2962 decode_ARM_machine_flags (e_flags, buf);
2963 break;
76da6bbe 2964
343433df
AB		 2965 case EM_AVR:
2966 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
2967 break;
2968
781303ce
MF		 2969 case EM_BLACKFIN:
2970 if (e_flags & EF_BFIN_PIC)
2971 strcat (buf, ", PIC");
2972
2973 if (e_flags & EF_BFIN_FDPIC)
2974 strcat (buf, ", FDPIC");
2975
2976 if (e_flags & EF_BFIN_CODE_IN_L1)
2977 strcat (buf, ", code in L1");
2978
2979 if (e_flags & EF_BFIN_DATA_IN_L1)
2980 strcat (buf, ", data in L1");
2981
2982 break;
2983
ec2dfb42
AO		 2984 case EM_CYGNUS_FRV:
2985 switch (e_flags & EF_FRV_CPU_MASK)
2986 {
2987 case EF_FRV_CPU_GENERIC:
2988 break;
2989
2990 default:
2991 strcat (buf, ", fr???");
2992 break;
57346661 2993
ec2dfb42
AO		 2994 case EF_FRV_CPU_FR300:
2995 strcat (buf, ", fr300");
2996 break;
2997
2998 case EF_FRV_CPU_FR400:
2999 strcat (buf, ", fr400");
3000 break;
3001 case EF_FRV_CPU_FR405:
3002 strcat (buf, ", fr405");
3003 break;
3004
3005 case EF_FRV_CPU_FR450:
3006 strcat (buf, ", fr450");
3007 break;
3008
3009 case EF_FRV_CPU_FR500:
3010 strcat (buf, ", fr500");
3011 break;
3012 case EF_FRV_CPU_FR550:
3013 strcat (buf, ", fr550");
3014 break;
3015
3016 case EF_FRV_CPU_SIMPLE:
3017 strcat (buf, ", simple");
3018 break;
3019 case EF_FRV_CPU_TOMCAT:
3020 strcat (buf, ", tomcat");
3021 break;
3022 }
1c877e87 3023 break;
ec2dfb42 3024
53c7db4b 3025 case EM_68K:
425c6cb0 3026 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 3027 strcat (buf, ", m68000");
425c6cb0 3028 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 3029 strcat (buf, ", cpu32");
3030 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3031 strcat (buf, ", fido_a");
425c6cb0 3032 else
266abb8f 3033 {
2cf0635d
NC		 3034 char const * isa = _("unknown");
3035 char const * mac = _("unknown mac");
3036 char const * additional = NULL;
0112cd26 3037
c694fd50 3038 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 3039 {
c694fd50 3040 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 3041 isa = "A";
3042 additional = ", nodiv";
3043 break;
c694fd50 3044 case EF_M68K_CF_ISA_A:
266abb8f
NS		 3045 isa = "A";
3046 break;
c694fd50 3047 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 3048 isa = "A+";
3049 break;
c694fd50 3050 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 3051 isa = "B";
3052 additional = ", nousp";
3053 break;
c694fd50 3054 case EF_M68K_CF_ISA_B:
266abb8f
NS		 3055 isa = "B";
3056 break;
f608cd77
NS		 3057 case EF_M68K_CF_ISA_C:
3058 isa = "C";
3059 break;
3060 case EF_M68K_CF_ISA_C_NODIV:
3061 isa = "C";
3062 additional = ", nodiv";
3063 break;
266abb8f
NS		 3064 }
3065 strcat (buf, ", cf, isa ");
3066 strcat (buf, isa);
0b2e31dc
NS		 3067 if (additional)
3068 strcat (buf, additional);
c694fd50 3069 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 3070 strcat (buf, ", float");
c694fd50 3071 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 3072 {
3073 case 0:
3074 mac = NULL;
3075 break;
c694fd50 3076 case EF_M68K_CF_MAC:
266abb8f
NS		 3077 mac = "mac";
3078 break;
c694fd50 3079 case EF_M68K_CF_EMAC:
266abb8f
NS		 3080 mac = "emac";
3081 break;
f608cd77
NS		 3082 case EF_M68K_CF_EMAC_B:
3083 mac = "emac_b";
3084 break;
266abb8f
NS		 3085 }
3086 if (mac)
3087 {
3088 strcat (buf, ", ");
3089 strcat (buf, mac);
3090 }
266abb8f 3091 }
53c7db4b 3092 break;
33c63f9d 3093
153a2776
NC		 3094 case EM_CYGNUS_MEP:
3095 switch (e_flags & EF_MEP_CPU_MASK)
3096 {
3097 case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3098 case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3099 case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3100 case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3101 case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3102 case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3103 default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3104 }
3105
3106 switch (e_flags & EF_MEP_COP_MASK)
3107 {
3108 case EF_MEP_COP_NONE: break;
3109 case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3110 case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3111 case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3112 case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3113 default: strcat (buf, _("<unknown MeP copro type>")); break;
3114 }
3115
3116 if (e_flags & EF_MEP_LIBRARY)
3117 strcat (buf, ", Built for Library");
3118
3119 if (e_flags & EF_MEP_INDEX_MASK)
3120 sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3121 e_flags & EF_MEP_INDEX_MASK);
3122
3123 if (e_flags & ~ EF_MEP_ALL_FLAGS)
3124 sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3125 e_flags & ~ EF_MEP_ALL_FLAGS);
3126 break;
3127
252b5132
RH		 3128 case EM_PPC:
3129 if (e_flags & EF_PPC_EMB)
3130 strcat (buf, ", emb");
3131
3132 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 3133 strcat (buf, _(", relocatable"));
252b5132
RH		 3134
3135 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 3136 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 3137 break;
3138
ee67d69a
AM		 3139 case EM_PPC64:
3140 if (e_flags & EF_PPC64_ABI)
3141 {
3142 char abi[] = ", abiv0";
3143
3144 abi[6] += e_flags & EF_PPC64_ABI;
3145 strcat (buf, abi);
3146 }
3147 break;
3148
708e2187
NC		 3149 case EM_V800:
3150 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3151 strcat (buf, ", RH850 ABI");
0b4362b0 3152
708e2187
NC		 3153 if (e_flags & EF_V800_850E3)
3154 strcat (buf, ", V3 architecture");
3155
3156 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3157 strcat (buf, ", FPU not used");
3158
3159 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3160 strcat (buf, ", regmode: COMMON");
3161
3162 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3163 strcat (buf, ", r4 not used");
3164
3165 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3166 strcat (buf, ", r30 not used");
3167
3168 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3169 strcat (buf, ", r5 not used");
3170
3171 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3172 strcat (buf, ", r2 not used");
3173
3174 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3175 {
3176 switch (e_flags & - e_flags)
3177 {
3178 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3179 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
708e2187
NC		 3180 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3181 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
708e2187
NC		 3182 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3183 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3184 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3185 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3186 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3187 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3188 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3189 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3190 default: break;
3191 }
3192 }
3193 break;
3194
2b0337b0 3195 case EM_V850:
252b5132
RH		 3196 case EM_CYGNUS_V850:
3197 switch (e_flags & EF_V850_ARCH)
3198 {
78c8d46c
NC		 3199 case E_V850E3V5_ARCH:
3200 strcat (buf, ", v850e3v5");
3201 break;
1cd986c5
NC		 3202 case E_V850E2V3_ARCH:
3203 strcat (buf, ", v850e2v3");
3204 break;
3205 case E_V850E2_ARCH:
3206 strcat (buf, ", v850e2");
3207 break;
3208 case E_V850E1_ARCH:
3209 strcat (buf, ", v850e1");
8ad30312 3210 break;
252b5132
RH		 3211 case E_V850E_ARCH:
3212 strcat (buf, ", v850e");
3213 break;
252b5132
RH		 3214 case E_V850_ARCH:
3215 strcat (buf, ", v850");
3216 break;
3217 default:
2b692964 3218 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 3219 break;
3220 }
3221 break;
3222
2b0337b0 3223 case EM_M32R:
252b5132
RH		 3224 case EM_CYGNUS_M32R:
3225 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3226 strcat (buf, ", m32r");
252b5132
RH		 3227 break;
3228
3229 case EM_MIPS:
4fe85591 3230 case EM_MIPS_RS3_LE:
252b5132
RH		 3231 if (e_flags & EF_MIPS_NOREORDER)
3232 strcat (buf, ", noreorder");
3233
3234 if (e_flags & EF_MIPS_PIC)
3235 strcat (buf, ", pic");
3236
3237 if (e_flags & EF_MIPS_CPIC)
3238 strcat (buf, ", cpic");
3239
d1bdd336
TS		 3240 if (e_flags & EF_MIPS_UCODE)
3241 strcat (buf, ", ugen_reserved");
3242
252b5132
RH		 3243 if (e_flags & EF_MIPS_ABI2)
3244 strcat (buf, ", abi2");
3245
43521d43
TS		 3246 if (e_flags & EF_MIPS_OPTIONS_FIRST)
3247 strcat (buf, ", odk first");
3248
a5d22d2a
TS		 3249 if (e_flags & EF_MIPS_32BITMODE)
3250 strcat (buf, ", 32bitmode");
3251
ba92f887
MR		 3252 if (e_flags & EF_MIPS_NAN2008)
3253 strcat (buf, ", nan2008");
3254
fef1b0b3
SE		 3255 if (e_flags & EF_MIPS_FP64)
3256 strcat (buf, ", fp64");
3257
156c2f8b
NC		 3258 switch ((e_flags & EF_MIPS_MACH))
3259 {
3260 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3261 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3262 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 3263 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 3264 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3265 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3266 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3267 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 3268 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 3269 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 3270 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3271 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 3272 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 3273 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 3274 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
d32e5c54 3275 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
52b6b6b9 3276 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 3277 case 0:
3278 /* We simply ignore the field in this case to avoid confusion:
3279 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3280 extension. */
3281 break;
2b692964 3282 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 3283 }
43521d43
TS		 3284
3285 switch ((e_flags & EF_MIPS_ABI))
3286 {
3287 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3288 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3289 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3290 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3291 case 0:
3292 /* We simply ignore the field in this case to avoid confusion:
3293 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3294 This means it is likely to be an o32 file, but not for
3295 sure. */
3296 break;
2b692964 3297 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 3298 }
3299
3300 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3301 strcat (buf, ", mdmx");
3302
3303 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3304 strcat (buf, ", mips16");
3305
df58fc94
RS		 3306 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3307 strcat (buf, ", micromips");
3308
43521d43
TS		 3309 switch ((e_flags & EF_MIPS_ARCH))
3310 {
3311 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3312 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3313 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3314 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3315 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3316 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 3317 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
7361da2c 3318 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
43521d43 3319 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 3320 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
7361da2c 3321 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
2b692964 3322 default: strcat (buf, _(", unknown ISA")); break;
43521d43 3323 }
252b5132 3324 break;
351b4b40 3325
35c08157
KLC		 3326 case EM_NDS32:
3327 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3328 break;
3329
e23eba97
NC		 3330 case EM_RISCV:
3331 if (e_flags & EF_RISCV_RVC)
3332 strcat (buf, ", RVC");
2922d21d
AW		 3333
3334 switch (e_flags & EF_RISCV_FLOAT_ABI)
3335 {
3336 case EF_RISCV_FLOAT_ABI_SOFT:
3337 strcat (buf, ", soft-float ABI");
3338 break;
3339
3340 case EF_RISCV_FLOAT_ABI_SINGLE:
3341 strcat (buf, ", single-float ABI");
3342 break;
3343
3344 case EF_RISCV_FLOAT_ABI_DOUBLE:
3345 strcat (buf, ", double-float ABI");
3346 break;
3347
3348 case EF_RISCV_FLOAT_ABI_QUAD:
3349 strcat (buf, ", quad-float ABI");
3350 break;
3351 }
e23eba97
NC		 3352 break;
3353
ccde1100
AO		 3354 case EM_SH:
3355 switch ((e_flags & EF_SH_MACH_MASK))
3356 {
3357 case EF_SH1: strcat (buf, ", sh1"); break;
3358 case EF_SH2: strcat (buf, ", sh2"); break;
3359 case EF_SH3: strcat (buf, ", sh3"); break;
3360 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3361 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3362 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3363 case EF_SH3E: strcat (buf, ", sh3e"); break;
3364 case EF_SH4: strcat (buf, ", sh4"); break;
3365 case EF_SH5: strcat (buf, ", sh5"); break;
3366 case EF_SH2E: strcat (buf, ", sh2e"); break;
3367 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 3368 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 3369 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3370 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 3371 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 3372 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3373 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3374 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3375 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3376 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3377 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 3378 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 3379 }
3380
cec6a5b8
MR		 3381 if (e_flags & EF_SH_PIC)
3382 strcat (buf, ", pic");
3383
3384 if (e_flags & EF_SH_FDPIC)
3385 strcat (buf, ", fdpic");
ccde1100 3386 break;
948f632f 3387
73589c9d
CS		 3388 case EM_OR1K:
3389 if (e_flags & EF_OR1K_NODELAY)
3390 strcat (buf, ", no delay");
3391 break;
57346661 3392
351b4b40
RH		 3393 case EM_SPARCV9:
3394 if (e_flags & EF_SPARC_32PLUS)
3395 strcat (buf, ", v8+");
3396
3397 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 3398 strcat (buf, ", ultrasparcI");
3399
3400 if (e_flags & EF_SPARC_SUN_US3)
3401 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 3402
3403 if (e_flags & EF_SPARC_HAL_R1)
3404 strcat (buf, ", halr1");
3405
3406 if (e_flags & EF_SPARC_LEDATA)
3407 strcat (buf, ", ledata");
3408
3409 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3410 strcat (buf, ", tso");
3411
3412 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3413 strcat (buf, ", pso");
3414
3415 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3416 strcat (buf, ", rmo");
3417 break;
7d466069 3418
103f02d3
UD		 3419 case EM_PARISC:
3420 switch (e_flags & EF_PARISC_ARCH)
3421 {
3422 case EFA_PARISC_1_0:
3423 strcpy (buf, ", PA-RISC 1.0");
3424 break;
3425 case EFA_PARISC_1_1:
3426 strcpy (buf, ", PA-RISC 1.1");
3427 break;
3428 case EFA_PARISC_2_0:
3429 strcpy (buf, ", PA-RISC 2.0");
3430 break;
3431 default:
3432 break;
3433 }
3434 if (e_flags & EF_PARISC_TRAPNIL)
3435 strcat (buf, ", trapnil");
3436 if (e_flags & EF_PARISC_EXT)
3437 strcat (buf, ", ext");
3438 if (e_flags & EF_PARISC_LSB)
3439 strcat (buf, ", lsb");
3440 if (e_flags & EF_PARISC_WIDE)
3441 strcat (buf, ", wide");
3442 if (e_flags & EF_PARISC_NO_KABP)
3443 strcat (buf, ", no kabp");
3444 if (e_flags & EF_PARISC_LAZYSWAP)
3445 strcat (buf, ", lazyswap");
30800947 3446 break;
76da6bbe 3447
7d466069 3448 case EM_PJ:
2b0337b0 3449 case EM_PJ_OLD:
7d466069
ILT		 3450 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3451 strcat (buf, ", new calling convention");
3452
3453 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3454 strcat (buf, ", gnu calling convention");
3455 break;
4d6ed7c8
NC		 3456
3457 case EM_IA_64:
3458 if ((e_flags & EF_IA_64_ABI64))
3459 strcat (buf, ", 64-bit");
3460 else
3461 strcat (buf, ", 32-bit");
3462 if ((e_flags & EF_IA_64_REDUCEDFP))
3463 strcat (buf, ", reduced fp model");
3464 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3465 strcat (buf, ", no function descriptors, constant gp");
3466 else if ((e_flags & EF_IA_64_CONS_GP))
3467 strcat (buf, ", constant gp");
3468 if ((e_flags & EF_IA_64_ABSOLUTE))
3469 strcat (buf, ", absolute");
28f997cf
TG		 3470 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3471 {
3472 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3473 strcat (buf, ", vms_linkages");
3474 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3475 {
3476 case EF_IA_64_VMS_COMCOD_SUCCESS:
3477 break;
3478 case EF_IA_64_VMS_COMCOD_WARNING:
3479 strcat (buf, ", warning");
3480 break;
3481 case EF_IA_64_VMS_COMCOD_ERROR:
3482 strcat (buf, ", error");
3483 break;
3484 case EF_IA_64_VMS_COMCOD_ABORT:
3485 strcat (buf, ", abort");
3486 break;
3487 default:
bee0ee85
NC		 3488 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3489 e_flags & EF_IA_64_VMS_COMCOD);
3490 strcat (buf, ", <unknown>");
28f997cf
TG		 3491 }
3492 }
4d6ed7c8 3493 break;
179d3252
JT		 3494
3495 case EM_VAX:
3496 if ((e_flags & EF_VAX_NONPIC))
3497 strcat (buf, ", non-PIC");
3498 if ((e_flags & EF_VAX_DFLOAT))
3499 strcat (buf, ", D-Float");
3500 if ((e_flags & EF_VAX_GFLOAT))
3501 strcat (buf, ", G-Float");
3502 break;
c7927a3c 3503
619ed720
EB		 3504 case EM_VISIUM:
3505 if (e_flags & EF_VISIUM_ARCH_MCM)
3506 strcat (buf, ", mcm");
3507 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3508 strcat (buf, ", mcm24");
3509 if (e_flags & EF_VISIUM_ARCH_GR6)
3510 strcat (buf, ", gr6");
3511 break;
3512
4046d87a 3513 case EM_RL78:
1740ba0c
NC		 3514 switch (e_flags & E_FLAG_RL78_CPU_MASK)
3515 {
3516 case E_FLAG_RL78_ANY_CPU: break;
3517 case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3518 case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3519 case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3520 }
856ea05c
KP		 3521 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3522 strcat (buf, ", 64-bit doubles");
4046d87a 3523 break;
0b4362b0 3524
c7927a3c
NC		 3525 case EM_RX:
3526 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3527 strcat (buf, ", 64-bit doubles");
3528 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 3529 strcat (buf, ", dsp");
d4cb0ea0 3530 if (e_flags & E_FLAG_RX_PID)
0b4362b0 3531 strcat (buf, ", pid");
708e2187
NC		 3532 if (e_flags & E_FLAG_RX_ABI)
3533 strcat (buf, ", RX ABI");
3525236c
NC		 3534 if (e_flags & E_FLAG_RX_SINSNS_SET)
3535 strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3536 ? ", uses String instructions" : ", bans String instructions");
a117b0a5
YS		 3537 if (e_flags & E_FLAG_RX_V2)
3538 strcat (buf, ", V2");
d4cb0ea0 3539 break;
55786da2
AK		 3540
3541 case EM_S390:
3542 if (e_flags & EF_S390_HIGH_GPRS)
3543 strcat (buf, ", highgprs");
d4cb0ea0 3544 break;
40b36596
JM		 3545
3546 case EM_TI_C6000:
3547 if ((e_flags & EF_C6000_REL))
3548 strcat (buf, ", relocatable module");
d4cb0ea0 3549 break;
13761a11
NC		 3550
3551 case EM_MSP430:
3552 strcat (buf, _(": architecture variant: "));
3553 switch (e_flags & EF_MSP430_MACH)
3554 {
3555 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3556 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3557 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3558 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3559 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3560 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3561 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3562 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3563 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3564 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3565 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3566 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3567 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3568 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3569 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3570 default:
3571 strcat (buf, _(": unknown")); break;
3572 }
3573
3574 if (e_flags & ~ EF_MSP430_MACH)
3575 strcat (buf, _(": unknown extra flag bits also present"));
252b5132
RH		 3576 }
3577 }
3578
3579 return buf;
3580}
3581
252b5132 3582static const char *
d3ba0551
AM		 3583get_osabi_name (unsigned int osabi)
3584{
3585 static char buff[32];
3586
3587 switch (osabi)
3588 {
3589 case ELFOSABI_NONE: return "UNIX - System V";
3590 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3591 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 3592 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 3593 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3594 case ELFOSABI_AIX: return "UNIX - AIX";
3595 case ELFOSABI_IRIX: return "UNIX - IRIX";
3596 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3597 case ELFOSABI_TRU64: return "UNIX - TRU64";
3598 case ELFOSABI_MODESTO: return "Novell - Modesto";
3599 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3600 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3601 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 3602 case ELFOSABI_AROS: return "AROS";
11636f9e 3603 case ELFOSABI_FENIXOS: return "FenixOS";
6d913794
NC		 3604 case ELFOSABI_CLOUDABI: return "Nuxi CloudABI";
3605 case ELFOSABI_OPENVOS: return "Stratus Technologies OpenVOS";
d3ba0551 3606 default:
40b36596
JM		 3607 if (osabi >= 64)
3608 switch (elf_header.e_machine)
3609 {
3610 case EM_ARM:
3611 switch (osabi)
3612 {
3613 case ELFOSABI_ARM: return "ARM";
3614 default:
3615 break;
3616 }
3617 break;
3618
3619 case EM_MSP430:
3620 case EM_MSP430_OLD:
619ed720 3621 case EM_VISIUM:
40b36596
JM		 3622 switch (osabi)
3623 {
3624 case ELFOSABI_STANDALONE: return _("Standalone App");
3625 default:
3626 break;
3627 }
3628 break;
3629
3630 case EM_TI_C6000:
3631 switch (osabi)
3632 {
3633 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3634 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3635 default:
3636 break;
3637 }
3638 break;
3639
3640 default:
3641 break;
3642 }
e9e44622 3643 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 3644 return buff;
3645 }
3646}
3647
a06ea964
NC		 3648static const char *
3649get_aarch64_segment_type (unsigned long type)
3650{
3651 switch (type)
3652 {
3653 case PT_AARCH64_ARCHEXT:
3654 return "AARCH64_ARCHEXT";
3655 default:
3656 break;
3657 }
3658
3659 return NULL;
3660}
3661
b294bdf8
MM		 3662static const char *
3663get_arm_segment_type (unsigned long type)
3664{
3665 switch (type)
3666 {
3667 case PT_ARM_EXIDX:
3668 return "EXIDX";
3669 default:
3670 break;
3671 }
3672
3673 return NULL;
3674}
3675
d3ba0551
AM		 3676static const char *
3677get_mips_segment_type (unsigned long type)
252b5132
RH		 3678{
3679 switch (type)
3680 {
3681 case PT_MIPS_REGINFO:
3682 return "REGINFO";
3683 case PT_MIPS_RTPROC:
3684 return "RTPROC";
3685 case PT_MIPS_OPTIONS:
3686 return "OPTIONS";
351cdf24
MF		 3687 case PT_MIPS_ABIFLAGS:
3688 return "ABIFLAGS";
252b5132
RH		 3689 default:
3690 break;
3691 }
3692
3693 return NULL;
3694}
3695
103f02d3 3696static const char *
d3ba0551 3697get_parisc_segment_type (unsigned long type)
103f02d3
UD		 3698{
3699 switch (type)
3700 {
3701 case PT_HP_TLS: return "HP_TLS";
3702 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3703 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3704 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3705 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3706 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3707 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3708 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3709 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3710 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3711 case PT_HP_PARALLEL: return "HP_PARALLEL";
3712 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 3713 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3714 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3715 case PT_HP_STACK: return "HP_STACK";
3716 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 3717 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3718 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 3719 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 3720 default:
3721 break;
3722 }
3723
3724 return NULL;
3725}
3726
4d6ed7c8 3727static const char *
d3ba0551 3728get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 3729{
3730 switch (type)
3731 {
3732 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3733 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 3734 case PT_HP_TLS: return "HP_TLS";
3735 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3736 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3737 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 3738 default:
3739 break;
3740 }
3741
3742 return NULL;
3743}
3744
40b36596
JM		 3745static const char *
3746get_tic6x_segment_type (unsigned long type)
3747{
3748 switch (type)
3749 {
3750 case PT_C6000_PHATTR: return "C6000_PHATTR";
3751 default:
3752 break;
3753 }
3754
3755 return NULL;
3756}
3757
5522f910
NC		 3758static const char *
3759get_solaris_segment_type (unsigned long type)
3760{
3761 switch (type)
3762 {
3763 case 0x6464e550: return "PT_SUNW_UNWIND";
3764 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3765 case 0x6ffffff7: return "PT_LOSUNW";
3766 case 0x6ffffffa: return "PT_SUNWBSS";
3767 case 0x6ffffffb: return "PT_SUNWSTACK";
3768 case 0x6ffffffc: return "PT_SUNWDTRACE";
3769 case 0x6ffffffd: return "PT_SUNWCAP";
3770 case 0x6fffffff: return "PT_HISUNW";
3771 default: return NULL;
3772 }
3773}
3774
252b5132 3775static const char *
d3ba0551 3776get_segment_type (unsigned long p_type)
252b5132 3777{
b34976b6 3778 static char buff[32];
252b5132
RH		 3779
3780 switch (p_type)
3781 {
b34976b6
AM		 3782 case PT_NULL: return "NULL";
3783 case PT_LOAD: return "LOAD";
252b5132 3784 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 3785 case PT_INTERP: return "INTERP";
3786 case PT_NOTE: return "NOTE";
3787 case PT_SHLIB: return "SHLIB";
3788 case PT_PHDR: return "PHDR";
13ae64f3 3789 case PT_TLS: return "TLS";
252b5132 3790
65765700
JJ		 3791 case PT_GNU_EH_FRAME:
3792 return "GNU_EH_FRAME";
2b05f1b7 3793 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 3794 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 3795
252b5132
RH		 3796 default:
3797 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3798 {
2cf0635d 3799 const char * result;
103f02d3 3800
252b5132
RH		 3801 switch (elf_header.e_machine)
3802 {
a06ea964
NC		 3803 case EM_AARCH64:
3804 result = get_aarch64_segment_type (p_type);
3805 break;
b294bdf8
MM		 3806 case EM_ARM:
3807 result = get_arm_segment_type (p_type);
3808 break;
252b5132 3809 case EM_MIPS:
4fe85591 3810 case EM_MIPS_RS3_LE:
252b5132
RH		 3811 result = get_mips_segment_type (p_type);
3812 break;
103f02d3
UD		 3813 case EM_PARISC:
3814 result = get_parisc_segment_type (p_type);
3815 break;
4d6ed7c8
NC		 3816 case EM_IA_64:
3817 result = get_ia64_segment_type (p_type);
3818 break;
40b36596
JM		 3819 case EM_TI_C6000:
3820 result = get_tic6x_segment_type (p_type);
3821 break;
252b5132
RH		 3822 default:
3823 result = NULL;
3824 break;
3825 }
103f02d3 3826
252b5132
RH		 3827 if (result != NULL)
3828 return result;
103f02d3 3829
1a9ccd70 3830 sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
252b5132
RH		 3831 }
3832 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 3833 {
2cf0635d 3834 const char * result;
103f02d3
UD		 3835
3836 switch (elf_header.e_machine)
3837 {
3838 case EM_PARISC:
3839 result = get_parisc_segment_type (p_type);
3840 break;
00428cca
AM		 3841 case EM_IA_64:
3842 result = get_ia64_segment_type (p_type);
3843 break;
103f02d3 3844 default:
5522f910
NC		 3845 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
3846 result = get_solaris_segment_type (p_type);
3847 else
3848 result = NULL;
103f02d3
UD		 3849 break;
3850 }
3851
3852 if (result != NULL)
3853 return result;
3854
1a9ccd70 3855 sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
103f02d3 3856 }
252b5132 3857 else
e9e44622 3858 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 3859
3860 return buff;
3861 }
3862}
3863
3864static const char *
d3ba0551 3865get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 3866{
3867 switch (sh_type)
3868 {
b34976b6
AM		 3869 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3870 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3871 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3872 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3873 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3874 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3875 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3876 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3877 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3878 case SHT_MIPS_RELD: return "MIPS_RELD";
3879 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3880 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3881 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3882 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3883 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3884 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3885 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3886 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3887 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3888 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3889 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3890 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3891 case SHT_MIPS_LINE: return "MIPS_LINE";
3892 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3893 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3894 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3895 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3896 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3897 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3898 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3899 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3900 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3901 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3902 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3903 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3904 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3905 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3906 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132 3907 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
351cdf24 3908 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
252b5132
RH		 3909 default:
3910 break;
3911 }
3912 return NULL;
3913}
3914
103f02d3 3915static const char *
d3ba0551 3916get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 3917{
3918 switch (sh_type)
3919 {
3920 case SHT_PARISC_EXT: return "PARISC_EXT";
3921 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3922 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 3923 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3924 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3925 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 3926 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 3927 default:
3928 break;
3929 }
3930 return NULL;
3931}
3932
4d6ed7c8 3933static const char *
d3ba0551 3934get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 3935{
18bd398b 3936 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 3937 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3938 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 3939
4d6ed7c8
NC		 3940 switch (sh_type)
3941 {
148b93f2
NC		 3942 case SHT_IA_64_EXT: return "IA_64_EXT";
3943 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3944 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3945 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3946 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3947 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3948 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3949 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3950 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3951 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 3952 default:
3953 break;
3954 }
3955 return NULL;
3956}
3957
d2b2c203
DJ		 3958static const char *
3959get_x86_64_section_type_name (unsigned int sh_type)
3960{
3961 switch (sh_type)
3962 {
3963 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3964 default:
3965 break;
3966 }
3967 return NULL;
3968}
3969
a06ea964
NC		 3970static const char *
3971get_aarch64_section_type_name (unsigned int sh_type)
3972{
3973 switch (sh_type)
3974 {
3975 case SHT_AARCH64_ATTRIBUTES:
3976 return "AARCH64_ATTRIBUTES";
3977 default:
3978 break;
3979 }
3980 return NULL;
3981}
3982
40a18ebd
NC		 3983static const char *
3984get_arm_section_type_name (unsigned int sh_type)
3985{
3986 switch (sh_type)
3987 {
7f6fed87
NC		 3988 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3989 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3990 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3991 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3992 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 3993 default:
3994 break;
3995 }
3996 return NULL;
3997}
3998
40b36596
JM		 3999static const char *
4000get_tic6x_section_type_name (unsigned int sh_type)
4001{
4002 switch (sh_type)
4003 {
4004 case SHT_C6000_UNWIND:
4005 return "C6000_UNWIND";
4006 case SHT_C6000_PREEMPTMAP:
4007 return "C6000_PREEMPTMAP";
4008 case SHT_C6000_ATTRIBUTES:
4009 return "C6000_ATTRIBUTES";
4010 case SHT_TI_ICODE:
4011 return "TI_ICODE";
4012 case SHT_TI_XREF:
4013 return "TI_XREF";
4014 case SHT_TI_HANDLER:
4015 return "TI_HANDLER";
4016 case SHT_TI_INITINFO:
4017 return "TI_INITINFO";
4018 case SHT_TI_PHATTRS:
4019 return "TI_PHATTRS";
4020 default:
4021 break;
4022 }
4023 return NULL;
4024}
4025
13761a11
NC		 4026static const char *
4027get_msp430x_section_type_name (unsigned int sh_type)
4028{
4029 switch (sh_type)
4030 {
4031 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
4032 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
4033 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
4034 default: return NULL;
4035 }
4036}
4037
685080f2
NC		 4038static const char *
4039get_v850_section_type_name (unsigned int sh_type)
4040{
4041 switch (sh_type)
4042 {
4043 case SHT_V850_SCOMMON: return "V850 Small Common";
4044 case SHT_V850_TCOMMON: return "V850 Tiny Common";
4045 case SHT_V850_ZCOMMON: return "V850 Zero Common";
4046 case SHT_RENESAS_IOP: return "RENESAS IOP";
4047 case SHT_RENESAS_INFO: return "RENESAS INFO";
4048 default: return NULL;
4049 }
4050}
4051
252b5132 4052static const char *
d3ba0551 4053get_section_type_name (unsigned int sh_type)
252b5132 4054{
b34976b6 4055 static char buff[32];
9fb71ee4 4056 const char * result;
252b5132
RH		 4057
4058 switch (sh_type)
4059 {
4060 case SHT_NULL: return "NULL";
4061 case SHT_PROGBITS: return "PROGBITS";
4062 case SHT_SYMTAB: return "SYMTAB";
4063 case SHT_STRTAB: return "STRTAB";
4064 case SHT_RELA: return "RELA";
4065 case SHT_HASH: return "HASH";
4066 case SHT_DYNAMIC: return "DYNAMIC";
4067 case SHT_NOTE: return "NOTE";
4068 case SHT_NOBITS: return "NOBITS";
4069 case SHT_REL: return "REL";
4070 case SHT_SHLIB: return "SHLIB";
4071 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 4072 case SHT_INIT_ARRAY: return "INIT_ARRAY";
4073 case SHT_FINI_ARRAY: return "FINI_ARRAY";
4074 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 4075 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 4076 case SHT_GROUP: return "GROUP";
4077 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 4078 case SHT_GNU_verdef: return "VERDEF";
4079 case SHT_GNU_verneed: return "VERNEED";
4080 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 4081 case 0x6ffffff0: return "VERSYM";
4082 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 4083 case 0x7ffffffd: return "AUXILIARY";
4084 case 0x7fffffff: return "FILTER";
047b2264 4085 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 4086
4087 default:
4088 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4089 {
252b5132
RH		 4090 switch (elf_header.e_machine)
4091 {
4092 case EM_MIPS:
4fe85591 4093 case EM_MIPS_RS3_LE:
252b5132
RH		 4094 result = get_mips_section_type_name (sh_type);
4095 break;
103f02d3
UD		 4096 case EM_PARISC:
4097 result = get_parisc_section_type_name (sh_type);
4098 break;
4d6ed7c8
NC		 4099 case EM_IA_64:
4100 result = get_ia64_section_type_name (sh_type);
4101 break;
d2b2c203 4102 case EM_X86_64:
8a9036a4 4103 case EM_L1OM:
7a9068fe 4104 case EM_K1OM:
d2b2c203
DJ		 4105 result = get_x86_64_section_type_name (sh_type);
4106 break;
a06ea964
NC		 4107 case EM_AARCH64:
4108 result = get_aarch64_section_type_name (sh_type);
4109 break;
40a18ebd
NC		 4110 case EM_ARM:
4111 result = get_arm_section_type_name (sh_type);
4112 break;
40b36596
JM		 4113 case EM_TI_C6000:
4114 result = get_tic6x_section_type_name (sh_type);
4115 break;
13761a11
NC		 4116 case EM_MSP430:
4117 result = get_msp430x_section_type_name (sh_type);
4118 break;
685080f2
NC		 4119 case EM_V800:
4120 case EM_V850:
4121 case EM_CYGNUS_V850:
4122 result = get_v850_section_type_name (sh_type);
4123 break;
252b5132
RH		 4124 default:
4125 result = NULL;
4126 break;
4127 }
4128
4129 if (result != NULL)
4130 return result;
4131
9fb71ee4 4132 sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
252b5132
RH		 4133 }
4134 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 4135 {
148b93f2
NC		 4136 switch (elf_header.e_machine)
4137 {
4138 case EM_IA_64:
4139 result = get_ia64_section_type_name (sh_type);
4140 break;
4141 default:
fd85a6a1
NC		 4142 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4143 result = get_solaris_section_type (sh_type);
4144 else
1b4b80bf
NC		 4145 {
4146 switch (sh_type)
4147 {
4148 case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4149 case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4150 case SHT_GNU_HASH: result = "GNU_HASH"; break;
4151 case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4152 default:
4153 result = NULL;
4154 break;
4155 }
4156 }
148b93f2
NC		 4157 break;
4158 }
4159
4160 if (result != NULL)
4161 return result;
4162
9fb71ee4 4163 sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
148b93f2 4164 }
252b5132 4165 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
685080f2
NC		 4166 {
4167 switch (elf_header.e_machine)
4168 {
4169 case EM_V800:
4170 case EM_V850:
4171 case EM_CYGNUS_V850:
9fb71ee4 4172 result = get_v850_section_type_name (sh_type);
a9fb83be 4173 break;
685080f2 4174 default:
9fb71ee4 4175 result = NULL;
685080f2
NC		 4176 break;
4177 }
4178
9fb71ee4
NC		 4179 if (result != NULL)
4180 return result;
4181
4182 sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
685080f2 4183 }
252b5132 4184 else
a7dbfd1c
NC		 4185 /* This message is probably going to be displayed in a 15
4186 character wide field, so put the hex value first. */
4187 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 4188
252b5132
RH		 4189 return buff;
4190 }
4191}
4192
2979dc34 4193#define OPTION_DEBUG_DUMP 512
2c610e4b 4194#define OPTION_DYN_SYMS 513
fd2f0033
TT		 4195#define OPTION_DWARF_DEPTH 514
4196#define OPTION_DWARF_START 515
4723351a 4197#define OPTION_DWARF_CHECK 516
2979dc34 4198
85b1c36d 4199static struct option options[] =
252b5132 4200{
b34976b6 4201 {"all", no_argument, 0, 'a'},
252b5132
RH		 4202 {"file-header", no_argument, 0, 'h'},
4203 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 4204 {"headers", no_argument, 0, 'e'},
4205 {"histogram", no_argument, 0, 'I'},
4206 {"segments", no_argument, 0, 'l'},
4207 {"sections", no_argument, 0, 'S'},
252b5132 4208 {"section-headers", no_argument, 0, 'S'},
f5842774 4209 {"section-groups", no_argument, 0, 'g'},
5477e8a0 4210 {"section-details", no_argument, 0, 't'},
595cf52e 4211 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 4212 {"symbols", no_argument, 0, 's'},
4213 {"syms", no_argument, 0, 's'},
2c610e4b 4214 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 4215 {"relocs", no_argument, 0, 'r'},
4216 {"notes", no_argument, 0, 'n'},
4217 {"dynamic", no_argument, 0, 'd'},
a952a375 4218 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 4219 {"version-info", no_argument, 0, 'V'},
4220 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 4221 {"unwind", no_argument, 0, 'u'},
4145f1d5 4222 {"archive-index", no_argument, 0, 'c'},
b34976b6 4223 {"hex-dump", required_argument, 0, 'x'},
cf13d699 4224 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 4225 {"string-dump", required_argument, 0, 'p'},
0e602686 4226 {"decompress", no_argument, 0, 'z'},
252b5132
RH		 4227#ifdef SUPPORT_DISASSEMBLY
4228 {"instruction-dump", required_argument, 0, 'i'},
4229#endif
cf13d699 4230 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 4231
fd2f0033
TT		 4232 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
4233 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 4234 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 4235
b34976b6
AM		 4236 {"version", no_argument, 0, 'v'},
4237 {"wide", no_argument, 0, 'W'},
4238 {"help", no_argument, 0, 'H'},
4239 {0, no_argument, 0, 0}
252b5132
RH		 4240};
4241
4242static void
2cf0635d 4243usage (FILE * stream)
252b5132 4244{
92f01d61
JM		 4245 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4246 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4247 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 4248 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4249 -h --file-header Display the ELF file header\n\
4250 -l --program-headers Display the program headers\n\
4251 --segments An alias for --program-headers\n\
4252 -S --section-headers Display the sections' header\n\
4253 --sections An alias for --section-headers\n\
f5842774 4254 -g --section-groups Display the section groups\n\
5477e8a0 4255 -t --section-details Display the section details\n\
8b53311e
NC		 4256 -e --headers Equivalent to: -h -l -S\n\
4257 -s --syms Display the symbol table\n\
3f08eb35 4258 --symbols An alias for --syms\n\
2c610e4b 4259 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 4260 -n --notes Display the core notes (if present)\n\
4261 -r --relocs Display the relocations (if present)\n\
4262 -u --unwind Display the unwind info (if present)\n\
b2d38a17 4263 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 4264 -V --version-info Display the version sections (if present)\n\
1b31d05e 4265 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 4266 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 4267 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 4268 -x --hex-dump=<number|name>\n\
4269 Dump the contents of section <number|name> as bytes\n\
4270 -p --string-dump=<number|name>\n\
4271 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 4272 -R --relocated-dump=<number|name>\n\
4273 Dump the contents of section <number|name> as relocated bytes\n\
0e602686 4274 -z --decompress Decompress section before dumping it\n\
f9f0e732 4275 -w[lLiaprmfFsoRt] or\n\
1ed06042 4276 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 4277 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC		 4278 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4279 =addr,=cu_index]\n\
8b53311e 4280 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 4281 fprintf (stream, _("\
4282 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4283 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4284 or deeper\n"));
252b5132 4285#ifdef SUPPORT_DISASSEMBLY
92f01d61 4286 fprintf (stream, _("\
09c11c86
NC		 4287 -i --instruction-dump=<number|name>\n\
4288 Disassemble the contents of section <number|name>\n"));
252b5132 4289#endif
92f01d61 4290 fprintf (stream, _("\
8b53311e
NC		 4291 -I --histogram Display histogram of bucket list lengths\n\
4292 -W --wide Allow output width to exceed 80 characters\n\
07012eee 4293 @<file> Read options from <file>\n\
8b53311e
NC		 4294 -H --help Display this information\n\
4295 -v --version Display the version number of readelf\n"));
1118d252 4296
92f01d61
JM		 4297 if (REPORT_BUGS_TO[0] && stream == stdout)
4298 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 4299
92f01d61 4300 exit (stream == stdout ? 0 : 1);
252b5132
RH		 4301}
4302
18bd398b
NC		 4303/* Record the fact that the user wants the contents of section number
4304 SECTION to be displayed using the method(s) encoded as flags bits
4305 in TYPE. Note, TYPE can be zero if we are creating the array for
4306 the first time. */
4307
252b5132 4308static void
09c11c86 4309request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 4310{
4311 if (section >= num_dump_sects)
4312 {
2cf0635d 4313 dump_type * new_dump_sects;
252b5132 4314
3f5e193b
NC		 4315 new_dump_sects = (dump_type *) calloc (section + 1,
4316 sizeof (* dump_sects));
252b5132
RH		 4317
4318 if (new_dump_sects == NULL)
591a748a 4319 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 4320 else
4321 {
21b65bac
NC		 4322 if (dump_sects)
4323 {
4324 /* Copy current flag settings. */
4325 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132 4326
21b65bac
NC		 4327 free (dump_sects);
4328 }
252b5132
RH		 4329
4330 dump_sects = new_dump_sects;
4331 num_dump_sects = section + 1;
4332 }
4333 }
4334
4335 if (dump_sects)
b34976b6 4336 dump_sects[section] |= type;
252b5132
RH		 4337
4338 return;
4339}
4340
aef1f6d0
DJ		 4341/* Request a dump by section name. */
4342
4343static void
2cf0635d 4344request_dump_byname (const char * section, dump_type type)
aef1f6d0 4345{
2cf0635d 4346 struct dump_list_entry * new_request;
aef1f6d0 4347
3f5e193b
NC		 4348 new_request = (struct dump_list_entry *)
4349 malloc (sizeof (struct dump_list_entry));
aef1f6d0 4350 if (!new_request)
591a748a 4351 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4352
4353 new_request->name = strdup (section);
4354 if (!new_request->name)
591a748a 4355 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4356
4357 new_request->type = type;
4358
4359 new_request->next = dump_sects_byname;
4360 dump_sects_byname = new_request;
4361}
4362
cf13d699
NC		 4363static inline void
4364request_dump (dump_type type)
4365{
4366 int section;
4367 char * cp;
4368
4369 do_dump++;
4370 section = strtoul (optarg, & cp, 0);
4371
4372 if (! *cp && section >= 0)
4373 request_dump_bynumber (section, type);
4374 else
4375 request_dump_byname (optarg, type);
4376}
4377
4378
252b5132 4379static void
2cf0635d 4380parse_args (int argc, char ** argv)
252b5132
RH		 4381{
4382 int c;
4383
4384 if (argc < 2)
92f01d61 4385 usage (stderr);
252b5132
RH		 4386
4387 while ((c = getopt_long
0e602686 4388 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
252b5132 4389 {
252b5132
RH		 4390 switch (c)
4391 {
4392 case 0:
4393 /* Long options. */
4394 break;
4395 case 'H':
92f01d61 4396 usage (stdout);
252b5132
RH		 4397 break;
4398
4399 case 'a':
b34976b6
AM		 4400 do_syms++;
4401 do_reloc++;
4402 do_unwind++;
4403 do_dynamic++;
4404 do_header++;
4405 do_sections++;
f5842774 4406 do_section_groups++;
b34976b6
AM		 4407 do_segments++;
4408 do_version++;
4409 do_histogram++;
4410 do_arch++;
4411 do_notes++;
252b5132 4412 break;
f5842774
L		 4413 case 'g':
4414 do_section_groups++;
4415 break;
5477e8a0 4416 case 't':
595cf52e 4417 case 'N':
5477e8a0
L		 4418 do_sections++;
4419 do_section_details++;
595cf52e 4420 break;
252b5132 4421 case 'e':
b34976b6
AM		 4422 do_header++;
4423 do_sections++;
4424 do_segments++;
252b5132 4425 break;
a952a375 4426 case 'A':
b34976b6 4427 do_arch++;
a952a375 4428 break;
252b5132 4429 case 'D':
b34976b6 4430 do_using_dynamic++;
252b5132
RH		 4431 break;
4432 case 'r':
b34976b6 4433 do_reloc++;
252b5132 4434 break;
4d6ed7c8 4435 case 'u':
b34976b6 4436 do_unwind++;
4d6ed7c8 4437 break;
252b5132 4438 case 'h':
b34976b6 4439 do_header++;
252b5132
RH		 4440 break;
4441 case 'l':
b34976b6 4442 do_segments++;
252b5132
RH		 4443 break;
4444 case 's':
b34976b6 4445 do_syms++;
252b5132
RH		 4446 break;
4447 case 'S':
b34976b6 4448 do_sections++;
252b5132
RH		 4449 break;
4450 case 'd':
b34976b6 4451 do_dynamic++;
252b5132 4452 break;
a952a375 4453 case 'I':
b34976b6 4454 do_histogram++;
a952a375 4455 break;
779fe533 4456 case 'n':
b34976b6 4457 do_notes++;
779fe533 4458 break;
4145f1d5
NC		 4459 case 'c':
4460 do_archive_index++;
4461 break;
252b5132 4462 case 'x':
cf13d699 4463 request_dump (HEX_DUMP);
aef1f6d0 4464 break;
09c11c86 4465 case 'p':
cf13d699
NC		 4466 request_dump (STRING_DUMP);
4467 break;
4468 case 'R':
4469 request_dump (RELOC_DUMP);
09c11c86 4470 break;
0e602686
NC		 4471 case 'z':
4472 decompress_dumps++;
4473 break;
252b5132 4474 case 'w':
b34976b6 4475 do_dump++;
252b5132 4476 if (optarg == 0)
613ff48b
CC		 4477 {
4478 do_debugging = 1;
4479 dwarf_select_sections_all ();
4480 }
252b5132
RH		 4481 else
4482 {
4483 do_debugging = 0;
4cb93e3b 4484 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 4485 }
4486 break;
2979dc34 4487 case OPTION_DEBUG_DUMP:
b34976b6 4488 do_dump++;
2979dc34
JJ		 4489 if (optarg == 0)
4490 do_debugging = 1;
4491 else
4492 {
2979dc34 4493 do_debugging = 0;
4cb93e3b 4494 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 4495 }
4496 break;
fd2f0033
TT		 4497 case OPTION_DWARF_DEPTH:
4498 {
4499 char *cp;
4500
4501 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4502 }
4503 break;
4504 case OPTION_DWARF_START:
4505 {
4506 char *cp;
4507
4508 dwarf_start_die = strtoul (optarg, & cp, 0);
4509 }
4510 break;
4723351a
CC		 4511 case OPTION_DWARF_CHECK:
4512 dwarf_check = 1;
4513 break;
2c610e4b
L		 4514 case OPTION_DYN_SYMS:
4515 do_dyn_syms++;
4516 break;
252b5132
RH		 4517#ifdef SUPPORT_DISASSEMBLY
4518 case 'i':
cf13d699
NC		 4519 request_dump (DISASS_DUMP);
4520 break;
252b5132
RH		 4521#endif
4522 case 'v':
4523 print_version (program_name);
4524 break;
4525 case 'V':
b34976b6 4526 do_version++;
252b5132 4527 break;
d974e256 4528 case 'W':
b34976b6 4529 do_wide++;
d974e256 4530 break;
252b5132 4531 default:
252b5132
RH		 4532 /* xgettext:c-format */
4533 error (_("Invalid option '-%c'\n"), c);
1a0670f3 4534 /* Fall through. */
252b5132 4535 case '?':
92f01d61 4536 usage (stderr);
252b5132
RH		 4537 }
4538 }
4539
4d6ed7c8 4540 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 4541 && !do_segments && !do_header && !do_dump && !do_version
f5842774 4542 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 4543 && !do_section_groups && !do_archive_index
4544 && !do_dyn_syms)
92f01d61 4545 usage (stderr);
252b5132
RH		 4546}
4547
4548static const char *
d3ba0551 4549get_elf_class (unsigned int elf_class)
252b5132 4550{
b34976b6 4551 static char buff[32];
103f02d3 4552
252b5132
RH		 4553 switch (elf_class)
4554 {
4555 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 4556 case ELFCLASS32: return "ELF32";
4557 case ELFCLASS64: return "ELF64";
ab5e7794 4558 default:
e9e44622 4559 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 4560 return buff;
252b5132
RH		 4561 }
4562}
4563
4564static const char *
d3ba0551 4565get_data_encoding (unsigned int encoding)
252b5132 4566{
b34976b6 4567 static char buff[32];
103f02d3 4568
252b5132
RH		 4569 switch (encoding)
4570 {
4571 case ELFDATANONE: return _("none");
33c63f9d
CM		 4572 case ELFDATA2LSB: return _("2's complement, little endian");
4573 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 4574 default:
e9e44622 4575 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 4576 return buff;
252b5132
RH		 4577 }
4578}
4579
252b5132 4580/* Decode the data held in 'elf_header'. */
ee42cf8c 4581
252b5132 4582static int
d3ba0551 4583process_file_header (void)
252b5132 4584{
b34976b6
AM		 4585 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
4586 || elf_header.e_ident[EI_MAG1] != ELFMAG1
4587 || elf_header.e_ident[EI_MAG2] != ELFMAG2
4588 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 4589 {
4590 error
4591 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4592 return 0;
4593 }
4594
2dc4cec1
L		 4595 init_dwarf_regnames (elf_header.e_machine);
4596
252b5132
RH		 4597 if (do_header)
4598 {
4599 int i;
4600
4601 printf (_("ELF Header:\n"));
4602 printf (_(" Magic: "));
b34976b6
AM		 4603 for (i = 0; i < EI_NIDENT; i++)
4604 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 4605 printf ("\n");
4606 printf (_(" Class: %s\n"),
b34976b6 4607 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 4608 printf (_(" Data: %s\n"),
b34976b6 4609 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 4610 printf (_(" Version: %d %s\n"),
b34976b6
AM		 4611 elf_header.e_ident[EI_VERSION],
4612 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 4613 ? "(current)"
b34976b6 4614 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 4615 ? _("<unknown: %lx>")
789be9f7 4616 : "")));
252b5132 4617 printf (_(" OS/ABI: %s\n"),
b34976b6 4618 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 4619 printf (_(" ABI Version: %d\n"),
b34976b6 4620 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 4621 printf (_(" Type: %s\n"),
4622 get_file_type (elf_header.e_type));
4623 printf (_(" Machine: %s\n"),
4624 get_machine_name (elf_header.e_machine));
4625 printf (_(" Version: 0x%lx\n"),
4626 (unsigned long) elf_header.e_version);
76da6bbe 4627
f7a99963
NC		 4628 printf (_(" Entry point address: "));
4629 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4630 printf (_("\n Start of program headers: "));
4631 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4632 printf (_(" (bytes into file)\n Start of section headers: "));
4633 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4634 printf (_(" (bytes into file)\n"));
76da6bbe 4635
252b5132
RH		 4636 printf (_(" Flags: 0x%lx%s\n"),
4637 (unsigned long) elf_header.e_flags,
4638 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4639 printf (_(" Size of this header: %ld (bytes)\n"),
4640 (long) elf_header.e_ehsize);
4641 printf (_(" Size of program headers: %ld (bytes)\n"),
4642 (long) elf_header.e_phentsize);
2046a35d 4643 printf (_(" Number of program headers: %ld"),
252b5132 4644 (long) elf_header.e_phnum);
2046a35d
AM		 4645 if (section_headers != NULL
4646 && elf_header.e_phnum == PN_XNUM
4647 && section_headers[0].sh_info != 0)
cc5914eb 4648 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 4649 putc ('\n', stdout);
252b5132
RH		 4650 printf (_(" Size of section headers: %ld (bytes)\n"),
4651 (long) elf_header.e_shentsize);
560f3c1c 4652 printf (_(" Number of section headers: %ld"),
252b5132 4653 (long) elf_header.e_shnum);
4fbb74a6 4654 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 4655 printf (" (%ld)", (long) section_headers[0].sh_size);
4656 putc ('\n', stdout);
4657 printf (_(" Section header string table index: %ld"),
252b5132 4658 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 4659 if (section_headers != NULL
4660 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 4661 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 4662 else if (elf_header.e_shstrndx != SHN_UNDEF
4663 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 4664 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 4665 putc ('\n', stdout);
4666 }
4667
4668 if (section_headers != NULL)
4669 {
2046a35d
AM		 4670 if (elf_header.e_phnum == PN_XNUM
4671 && section_headers[0].sh_info != 0)
4672 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 4673 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 4674 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 4675 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 4676 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 4677 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 4678 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 4679 free (section_headers);
4680 section_headers = NULL;
252b5132 4681 }
103f02d3 4682
9ea033b2
NC		 4683 return 1;
4684}
4685
e0a31db1 4686static bfd_boolean
91d6fa6a 4687get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4688{
2cf0635d
NC		 4689 Elf32_External_Phdr * phdrs;
4690 Elf32_External_Phdr * external;
4691 Elf_Internal_Phdr * internal;
b34976b6 4692 unsigned int i;
e0a31db1
NC		 4693 unsigned int size = elf_header.e_phentsize;
4694 unsigned int num = elf_header.e_phnum;
4695
4696 /* PR binutils/17531: Cope with unexpected section header sizes. */
4697 if (size == 0 || num == 0)
4698 return FALSE;
4699 if (size < sizeof * phdrs)
4700 {
4701 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4702 return FALSE;
4703 }
4704 if (size > sizeof * phdrs)
4705 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4706
3f5e193b 4707 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1
NC		 4708 size, num, _("program headers"));
4709 if (phdrs == NULL)
4710 return FALSE;
9ea033b2 4711
91d6fa6a 4712 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4713 i < elf_header.e_phnum;
b34976b6 4714 i++, internal++, external++)
252b5132 4715 {
9ea033b2
NC		 4716 internal->p_type = BYTE_GET (external->p_type);
4717 internal->p_offset = BYTE_GET (external->p_offset);
4718 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4719 internal->p_paddr = BYTE_GET (external->p_paddr);
4720 internal->p_filesz = BYTE_GET (external->p_filesz);
4721 internal->p_memsz = BYTE_GET (external->p_memsz);
4722 internal->p_flags = BYTE_GET (external->p_flags);
4723 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 4724 }
4725
9ea033b2 4726 free (phdrs);
e0a31db1 4727 return TRUE;
252b5132
RH		 4728}
4729
e0a31db1 4730static bfd_boolean
91d6fa6a 4731get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4732{
2cf0635d
NC		 4733 Elf64_External_Phdr * phdrs;
4734 Elf64_External_Phdr * external;
4735 Elf_Internal_Phdr * internal;
b34976b6 4736 unsigned int i;
e0a31db1
NC		 4737 unsigned int size = elf_header.e_phentsize;
4738 unsigned int num = elf_header.e_phnum;
4739
4740 /* PR binutils/17531: Cope with unexpected section header sizes. */
4741 if (size == 0 || num == 0)
4742 return FALSE;
4743 if (size < sizeof * phdrs)
4744 {
4745 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4746 return FALSE;
4747 }
4748 if (size > sizeof * phdrs)
4749 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4750
3f5e193b 4751 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1 4752 size, num, _("program headers"));
a6e9f9df 4753 if (!phdrs)
e0a31db1 4754 return FALSE;
9ea033b2 4755
91d6fa6a 4756 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4757 i < elf_header.e_phnum;
b34976b6 4758 i++, internal++, external++)
9ea033b2
NC		 4759 {
4760 internal->p_type = BYTE_GET (external->p_type);
4761 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 4762 internal->p_offset = BYTE_GET (external->p_offset);
4763 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4764 internal->p_paddr = BYTE_GET (external->p_paddr);
4765 internal->p_filesz = BYTE_GET (external->p_filesz);
4766 internal->p_memsz = BYTE_GET (external->p_memsz);
4767 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 4768 }
4769
4770 free (phdrs);
e0a31db1 4771 return TRUE;
9ea033b2 4772}
252b5132 4773
d93f0186
NC		 4774/* Returns 1 if the program headers were read into `program_headers'. */
4775
4776static int
2cf0635d 4777get_program_headers (FILE * file)
d93f0186 4778{
2cf0635d 4779 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 4780
4781 /* Check cache of prior read. */
4782 if (program_headers != NULL)
4783 return 1;
4784
3f5e193b
NC		 4785 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4786 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 4787
4788 if (phdrs == NULL)
4789 {
8b73c356
NC		 4790 error (_("Out of memory reading %u program headers\n"),
4791 elf_header.e_phnum);
d93f0186
NC		 4792 return 0;
4793 }
4794
4795 if (is_32bit_elf
4796 ? get_32bit_program_headers (file, phdrs)
4797 : get_64bit_program_headers (file, phdrs))
4798 {
4799 program_headers = phdrs;
4800 return 1;
4801 }
4802
4803 free (phdrs);
4804 return 0;
4805}
4806
2f62977e
NC		 4807/* Returns 1 if the program headers were loaded. */
4808
252b5132 4809static int
2cf0635d 4810process_program_headers (FILE * file)
252b5132 4811{
2cf0635d 4812 Elf_Internal_Phdr * segment;
b34976b6 4813 unsigned int i;
1a9ccd70 4814 Elf_Internal_Phdr * previous_load = NULL;
252b5132
RH		 4815
4816 if (elf_header.e_phnum == 0)
4817 {
82f2dbf7
NC		 4818 /* PR binutils/12467. */
4819 if (elf_header.e_phoff != 0)
4820 warn (_("possibly corrupt ELF header - it has a non-zero program"
9035ed51 4821 " header offset, but no program headers\n"));
82f2dbf7 4822 else if (do_segments)
252b5132 4823 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 4824 return 0;
252b5132
RH		 4825 }
4826
4827 if (do_segments && !do_header)
4828 {
f7a99963
NC		 4829 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4830 printf (_("Entry point "));
4831 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4832 printf (_("\nThere are %d program headers, starting at offset "),
4833 elf_header.e_phnum);
4834 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4835 printf ("\n");
252b5132
RH		 4836 }
4837
d93f0186 4838 if (! get_program_headers (file))
252b5132 4839 return 0;
103f02d3 4840
252b5132
RH		 4841 if (do_segments)
4842 {
3a1a2036
NC		 4843 if (elf_header.e_phnum > 1)
4844 printf (_("\nProgram Headers:\n"));
4845 else
4846 printf (_("\nProgram Headers:\n"));
76da6bbe 4847
f7a99963
NC		 4848 if (is_32bit_elf)
4849 printf
4850 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 4851 else if (do_wide)
4852 printf
4853 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 4854 else
4855 {
4856 printf
4857 (_(" Type Offset VirtAddr PhysAddr\n"));
4858 printf
4859 (_(" FileSiz MemSiz Flags Align\n"));
4860 }
252b5132
RH		 4861 }
4862
252b5132 4863 dynamic_addr = 0;
1b228002 4864 dynamic_size = 0;
252b5132
RH		 4865
4866 for (i = 0, segment = program_headers;
4867 i < elf_header.e_phnum;
b34976b6 4868 i++, segment++)
252b5132
RH		 4869 {
4870 if (do_segments)
4871 {
103f02d3 4872 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 4873
4874 if (is_32bit_elf)
4875 {
4876 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4877 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4878 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4879 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4880 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4881 printf ("%c%c%c ",
4882 (segment->p_flags & PF_R ? 'R' : ' '),
4883 (segment->p_flags & PF_W ? 'W' : ' '),
4884 (segment->p_flags & PF_X ? 'E' : ' '));
4885 printf ("%#lx", (unsigned long) segment->p_align);
4886 }
d974e256
JJ		 4887 else if (do_wide)
4888 {
4889 if ((unsigned long) segment->p_offset == segment->p_offset)
4890 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4891 else
4892 {
4893 print_vma (segment->p_offset, FULL_HEX);
4894 putchar (' ');
4895 }
4896
4897 print_vma (segment->p_vaddr, FULL_HEX);
4898 putchar (' ');
4899 print_vma (segment->p_paddr, FULL_HEX);
4900 putchar (' ');
4901
4902 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4903 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4904 else
4905 {
4906 print_vma (segment->p_filesz, FULL_HEX);
4907 putchar (' ');
4908 }
4909
4910 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4911 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4912 else
4913 {
f48e6c45 4914 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 4915 }
4916
4917 printf (" %c%c%c ",
4918 (segment->p_flags & PF_R ? 'R' : ' '),
4919 (segment->p_flags & PF_W ? 'W' : ' '),
4920 (segment->p_flags & PF_X ? 'E' : ' '));
4921
4922 if ((unsigned long) segment->p_align == segment->p_align)
4923 printf ("%#lx", (unsigned long) segment->p_align);
4924 else
4925 {
4926 print_vma (segment->p_align, PREFIX_HEX);
4927 }
4928 }
f7a99963
NC		 4929 else
4930 {
4931 print_vma (segment->p_offset, FULL_HEX);
4932 putchar (' ');
4933 print_vma (segment->p_vaddr, FULL_HEX);
4934 putchar (' ');
4935 print_vma (segment->p_paddr, FULL_HEX);
4936 printf ("\n ");
4937 print_vma (segment->p_filesz, FULL_HEX);
4938 putchar (' ');
4939 print_vma (segment->p_memsz, FULL_HEX);
4940 printf (" %c%c%c ",
4941 (segment->p_flags & PF_R ? 'R' : ' '),
4942 (segment->p_flags & PF_W ? 'W' : ' '),
4943 (segment->p_flags & PF_X ? 'E' : ' '));
1d262527 4944 print_vma (segment->p_align, PREFIX_HEX);
f7a99963 4945 }
252b5132 4946
1a9ccd70
NC		 4947 putc ('\n', stdout);
4948 }
f54498b4 4949
252b5132
RH		 4950 switch (segment->p_type)
4951 {
1a9ccd70 4952 case PT_LOAD:
502d895c
NC		 4953#if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
4954 required by the ELF standard, several programs, including the Linux
4955 kernel, make use of non-ordered segments. */
1a9ccd70
NC		 4956 if (previous_load
4957 && previous_load->p_vaddr > segment->p_vaddr)
4958 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
502d895c 4959#endif
1a9ccd70
NC		 4960 if (segment->p_memsz < segment->p_filesz)
4961 error (_("the segment's file size is larger than its memory size\n"));
4962 previous_load = segment;
4963 break;
4964
4965 case PT_PHDR:
4966 /* PR 20815 - Verify that the program header is loaded into memory. */
4967 if (i > 0 && previous_load != NULL)
4968 error (_("the PHDR segment must occur before any LOAD segment\n"));
4969 if (elf_header.e_machine != EM_PARISC)
4970 {
4971 unsigned int j;
4972
4973 for (j = 1; j < elf_header.e_phnum; j++)
4974 if (program_headers[j].p_vaddr <= segment->p_vaddr
4975 && (program_headers[j].p_vaddr + program_headers[j].p_memsz)
4976 >= (segment->p_vaddr + segment->p_filesz))
4977 break;
4978 if (j == elf_header.e_phnum)
4979 error (_("the PHDR segment is not covered by a LOAD segment\n"));
4980 }
4981 break;
4982
252b5132
RH		 4983 case PT_DYNAMIC:
4984 if (dynamic_addr)
4985 error (_("more than one dynamic segment\n"));
4986
20737c13
AM		 4987 /* By default, assume that the .dynamic section is the first
4988 section in the DYNAMIC segment. */
4989 dynamic_addr = segment->p_offset;
4990 dynamic_size = segment->p_filesz;
f54498b4
NC		 4991 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4992 if (dynamic_addr + dynamic_size >= current_file_size)
4993 {
4994 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4995 dynamic_addr = dynamic_size = 0;
4996 }
20737c13 4997
b2d38a17
NC		 4998 /* Try to locate the .dynamic section. If there is
4999 a section header table, we can easily locate it. */
5000 if (section_headers != NULL)
5001 {
2cf0635d 5002 Elf_Internal_Shdr * sec;
b2d38a17 5003
89fac5e3
RS		 5004 sec = find_section (".dynamic");
5005 if (sec == NULL || sec->sh_size == 0)
b2d38a17 5006 {
28f997cf
TG		 5007 /* A corresponding .dynamic section is expected, but on
5008 IA-64/OpenVMS it is OK for it to be missing. */
5009 if (!is_ia64_vms ())
5010 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 5011 break;
5012 }
5013
42bb2e33 5014 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 5015 {
5016 dynamic_size = 0;
5017 break;
5018 }
42bb2e33 5019
b2d38a17
NC		 5020 dynamic_addr = sec->sh_offset;
5021 dynamic_size = sec->sh_size;
5022
5023 if (dynamic_addr < segment->p_offset
5024 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 5025 warn (_("the .dynamic section is not contained"
5026 " within the dynamic segment\n"));
b2d38a17 5027 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 5028 warn (_("the .dynamic section is not the first section"
5029 " in the dynamic segment.\n"));
b2d38a17 5030 }
252b5132
RH		 5031 break;
5032
5033 case PT_INTERP:
fb52b2f4
NC		 5034 if (fseek (file, archive_file_offset + (long) segment->p_offset,
5035 SEEK_SET))
252b5132
RH		 5036 error (_("Unable to find program interpreter name\n"));
5037 else
5038 {
f8eae8b2 5039 char fmt [32];
9495b2e6 5040 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
f8eae8b2
L		 5041
5042 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 5043 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 5044
252b5132 5045 program_interpreter[0] = 0;
7bd7b3ef
AM		 5046 if (fscanf (file, fmt, program_interpreter) <= 0)
5047 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 5048
5049 if (do_segments)
f54498b4 5050 printf (_(" [Requesting program interpreter: %s]\n"),
252b5132
RH		 5051 program_interpreter);
5052 }
5053 break;
5054 }
252b5132
RH		 5055 }
5056
c256ffe7 5057 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 5058 {
5059 printf (_("\n Section to Segment mapping:\n"));
5060 printf (_(" Segment Sections...\n"));
5061
252b5132
RH		 5062 for (i = 0; i < elf_header.e_phnum; i++)
5063 {
9ad5cbcf 5064 unsigned int j;
2cf0635d 5065 Elf_Internal_Shdr * section;
252b5132
RH		 5066
5067 segment = program_headers + i;
b391a3e3 5068 section = section_headers + 1;
252b5132
RH		 5069
5070 printf (" %2.2d ", i);
5071
b34976b6 5072 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 5073 {
f4638467
AM		 5074 if (!ELF_TBSS_SPECIAL (section, segment)
5075 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
74e1a04b 5076 printf ("%s ", printable_section_name (section));
252b5132
RH		 5077 }
5078
5079 putc ('\n',stdout);
5080 }
5081 }
5082
252b5132
RH		 5083 return 1;
5084}
5085
5086
d93f0186
NC		 5087/* Find the file offset corresponding to VMA by using the program headers. */
5088
5089static long
2cf0635d 5090offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 5091{
2cf0635d 5092 Elf_Internal_Phdr * seg;
d93f0186
NC		 5093
5094 if (! get_program_headers (file))
5095 {
5096 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5097 return (long) vma;
5098 }
5099
5100 for (seg = program_headers;
5101 seg < program_headers + elf_header.e_phnum;
5102 ++seg)
5103 {
5104 if (seg->p_type != PT_LOAD)
5105 continue;
5106
5107 if (vma >= (seg->p_vaddr & -seg->p_align)
5108 && vma + size <= seg->p_vaddr + seg->p_filesz)
5109 return vma - seg->p_vaddr + seg->p_offset;
5110 }
5111
5112 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 5113 (unsigned long) vma);
d93f0186
NC		 5114 return (long) vma;
5115}
5116
5117
049b0c3a
NC		 5118/* Allocate memory and load the sections headers into the global pointer
5119 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
5120 generate any error messages if the load fails. */
5121
5122static bfd_boolean
5123get_32bit_section_headers (FILE * file, bfd_boolean probe)
252b5132 5124{
2cf0635d
NC		 5125 Elf32_External_Shdr * shdrs;
5126 Elf_Internal_Shdr * internal;
b34976b6 5127 unsigned int i;
049b0c3a
NC		 5128 unsigned int size = elf_header.e_shentsize;
5129 unsigned int num = probe ? 1 : elf_header.e_shnum;
5130
5131 /* PR binutils/17531: Cope with unexpected section header sizes. */
5132 if (size == 0 || num == 0)
5133 return FALSE;
5134 if (size < sizeof * shdrs)
5135 {
5136 if (! probe)
5137 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5138 return FALSE;
5139 }
5140 if (!probe && size > sizeof * shdrs)
5141 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
252b5132 5142
3f5e193b 5143 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 5144 size, num,
5145 probe ? NULL : _("section headers"));
5146 if (shdrs == NULL)
5147 return FALSE;
252b5132 5148
049b0c3a
NC		 5149 if (section_headers != NULL)
5150 free (section_headers);
3f5e193b
NC		 5151 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
5152 sizeof (Elf_Internal_Shdr));
252b5132
RH		 5153 if (section_headers == NULL)
5154 {
049b0c3a 5155 if (!probe)
8b73c356 5156 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 5157 return FALSE;
252b5132
RH		 5158 }
5159
5160 for (i = 0, internal = section_headers;
560f3c1c 5161 i < num;
b34976b6 5162 i++, internal++)
252b5132
RH		 5163 {
5164 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5165 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5166 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5167 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5168 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5169 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5170 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5171 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5172 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5173 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
315350be
NC		 5174 if (!probe && internal->sh_link > num)
5175 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5176 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5177 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
252b5132
RH		 5178 }
5179
5180 free (shdrs);
049b0c3a 5181 return TRUE;
252b5132
RH		 5182}
5183
049b0c3a
NC		 5184static bfd_boolean
5185get_64bit_section_headers (FILE * file, bfd_boolean probe)
9ea033b2 5186{
2cf0635d
NC		 5187 Elf64_External_Shdr * shdrs;
5188 Elf_Internal_Shdr * internal;
b34976b6 5189 unsigned int i;
049b0c3a
NC		 5190 unsigned int size = elf_header.e_shentsize;
5191 unsigned int num = probe ? 1 : elf_header.e_shnum;
5192
5193 /* PR binutils/17531: Cope with unexpected section header sizes. */
5194 if (size == 0 || num == 0)
5195 return FALSE;
5196 if (size < sizeof * shdrs)
5197 {
5198 if (! probe)
5199 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5200 return FALSE;
5201 }
5202 if (! probe && size > sizeof * shdrs)
5203 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
9ea033b2 5204
3f5e193b 5205 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 5206 size, num,
5207 probe ? NULL : _("section headers"));
5208 if (shdrs == NULL)
5209 return FALSE;
9ea033b2 5210
049b0c3a
NC		 5211 if (section_headers != NULL)
5212 free (section_headers);
3f5e193b
NC		 5213 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
5214 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 5215 if (section_headers == NULL)
5216 {
049b0c3a 5217 if (! probe)
8b73c356 5218 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 5219 return FALSE;
9ea033b2
NC		 5220 }
5221
5222 for (i = 0, internal = section_headers;
560f3c1c 5223 i < num;
b34976b6 5224 i++, internal++)
9ea033b2
NC		 5225 {
5226 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5227 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 5228 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5229 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5230 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5231 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 5232 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5233 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5234 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5235 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
315350be
NC		 5236 if (!probe && internal->sh_link > num)
5237 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5238 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5239 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
9ea033b2
NC		 5240 }
5241
5242 free (shdrs);
049b0c3a 5243 return TRUE;
9ea033b2
NC		 5244}
5245
252b5132 5246static Elf_Internal_Sym *
ba5cdace
NC		 5247get_32bit_elf_symbols (FILE * file,
5248 Elf_Internal_Shdr * section,
5249 unsigned long * num_syms_return)
252b5132 5250{
ba5cdace 5251 unsigned long number = 0;
dd24e3da 5252 Elf32_External_Sym * esyms = NULL;
ba5cdace 5253 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 5254 Elf_Internal_Sym * isyms = NULL;
2cf0635d 5255 Elf_Internal_Sym * psym;
b34976b6 5256 unsigned int j;
252b5132 5257
c9c1d674
EG		 5258 if (section->sh_size == 0)
5259 {
5260 if (num_syms_return != NULL)
5261 * num_syms_return = 0;
5262 return NULL;
5263 }
5264
dd24e3da 5265 /* Run some sanity checks first. */
c9c1d674 5266 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 5267 {
c9c1d674
EG		 5268 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5269 printable_section_name (section), (unsigned long) section->sh_entsize);
ba5cdace 5270 goto exit_point;
dd24e3da
NC		 5271 }
5272
f54498b4
NC		 5273 if (section->sh_size > current_file_size)
5274 {
5275 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
74e1a04b 5276 printable_section_name (section), (unsigned long) section->sh_size);
f54498b4
NC		 5277 goto exit_point;
5278 }
5279
dd24e3da
NC		 5280 number = section->sh_size / section->sh_entsize;
5281
5282 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5283 {
c9c1d674 5284 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 5285 (unsigned long) section->sh_size,
5286 printable_section_name (section),
5287 (unsigned long) section->sh_entsize);
ba5cdace 5288 goto exit_point;
dd24e3da
NC		 5289 }
5290
3f5e193b
NC		 5291 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5292 section->sh_size, _("symbols"));
dd24e3da 5293 if (esyms == NULL)
ba5cdace 5294 goto exit_point;
252b5132 5295
6a40cf0c
NC		 5296 {
5297 elf_section_list * entry;
5298
5299 shndx = NULL;
5300 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5301 if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
c9c1d674 5302 {
6a40cf0c
NC		 5303 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5304 entry->hdr->sh_offset,
5305 1, entry->hdr->sh_size,
5306 _("symbol table section indicies"));
5307 if (shndx == NULL)
5308 goto exit_point;
5309 /* PR17531: file: heap-buffer-overflow */
5310 else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5311 {
5312 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5313 printable_section_name (entry->hdr),
5314 (unsigned long) entry->hdr->sh_size,
5315 (unsigned long) section->sh_size);
5316 goto exit_point;
5317 }
c9c1d674 5318 }
6a40cf0c 5319 }
9ad5cbcf 5320
3f5e193b 5321 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 5322
5323 if (isyms == NULL)
5324 {
8b73c356
NC		 5325 error (_("Out of memory reading %lu symbols\n"),
5326 (unsigned long) number);
dd24e3da 5327 goto exit_point;
252b5132
RH		 5328 }
5329
dd24e3da 5330 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 5331 {
5332 psym->st_name = BYTE_GET (esyms[j].st_name);
5333 psym->st_value = BYTE_GET (esyms[j].st_value);
5334 psym->st_size = BYTE_GET (esyms[j].st_size);
5335 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 5336 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5337 psym->st_shndx
5338 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5339 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5340 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 5341 psym->st_info = BYTE_GET (esyms[j].st_info);
5342 psym->st_other = BYTE_GET (esyms[j].st_other);
5343 }
5344
dd24e3da 5345 exit_point:
ba5cdace 5346 if (shndx != NULL)
9ad5cbcf 5347 free (shndx);
ba5cdace 5348 if (esyms != NULL)
dd24e3da 5349 free (esyms);
252b5132 5350
ba5cdace
NC		 5351 if (num_syms_return != NULL)
5352 * num_syms_return = isyms == NULL ? 0 : number;
5353
252b5132
RH		 5354 return isyms;
5355}
5356
9ea033b2 5357static Elf_Internal_Sym *
ba5cdace
NC		 5358get_64bit_elf_symbols (FILE * file,
5359 Elf_Internal_Shdr * section,
5360 unsigned long * num_syms_return)
9ea033b2 5361{
ba5cdace
NC		 5362 unsigned long number = 0;
5363 Elf64_External_Sym * esyms = NULL;
5364 Elf_External_Sym_Shndx * shndx = NULL;
5365 Elf_Internal_Sym * isyms = NULL;
2cf0635d 5366 Elf_Internal_Sym * psym;
b34976b6 5367 unsigned int j;
9ea033b2 5368
c9c1d674
EG		 5369 if (section->sh_size == 0)
5370 {
5371 if (num_syms_return != NULL)
5372 * num_syms_return = 0;
5373 return NULL;
5374 }
5375
dd24e3da 5376 /* Run some sanity checks first. */
c9c1d674 5377 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 5378 {
c9c1d674 5379 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
8066deb1
AM		 5380 printable_section_name (section),
5381 (unsigned long) section->sh_entsize);
ba5cdace 5382 goto exit_point;
dd24e3da
NC		 5383 }
5384
f54498b4
NC		 5385 if (section->sh_size > current_file_size)
5386 {
5387 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
8066deb1
AM		 5388 printable_section_name (section),
5389 (unsigned long) section->sh_size);
f54498b4
NC		 5390 goto exit_point;
5391 }
5392
dd24e3da
NC		 5393 number = section->sh_size / section->sh_entsize;
5394
5395 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5396 {
c9c1d674 5397 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 5398 (unsigned long) section->sh_size,
5399 printable_section_name (section),
5400 (unsigned long) section->sh_entsize);
ba5cdace 5401 goto exit_point;
dd24e3da
NC		 5402 }
5403
3f5e193b
NC		 5404 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5405 section->sh_size, _("symbols"));
a6e9f9df 5406 if (!esyms)
ba5cdace 5407 goto exit_point;
9ea033b2 5408
6a40cf0c
NC		 5409 {
5410 elf_section_list * entry;
5411
5412 shndx = NULL;
5413 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5414 if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
c9c1d674 5415 {
6a40cf0c
NC		 5416 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5417 entry->hdr->sh_offset,
5418 1, entry->hdr->sh_size,
5419 _("symbol table section indicies"));
5420 if (shndx == NULL)
5421 goto exit_point;
5422 /* PR17531: file: heap-buffer-overflow */
5423 else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5424 {
5425 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5426 printable_section_name (entry->hdr),
5427 (unsigned long) entry->hdr->sh_size,
5428 (unsigned long) section->sh_size);
5429 goto exit_point;
5430 }
c9c1d674 5431 }
6a40cf0c 5432 }
9ad5cbcf 5433
3f5e193b 5434 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 5435
5436 if (isyms == NULL)
5437 {
8b73c356
NC		 5438 error (_("Out of memory reading %lu symbols\n"),
5439 (unsigned long) number);
ba5cdace 5440 goto exit_point;
9ea033b2
NC		 5441 }
5442
ba5cdace 5443 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 5444 {
5445 psym->st_name = BYTE_GET (esyms[j].st_name);
5446 psym->st_info = BYTE_GET (esyms[j].st_info);
5447 psym->st_other = BYTE_GET (esyms[j].st_other);
5448 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 5449
4fbb74a6 5450 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5451 psym->st_shndx
5452 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5453 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5454 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 5455
66543521
AM		 5456 psym->st_value = BYTE_GET (esyms[j].st_value);
5457 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 5458 }
5459
ba5cdace
NC		 5460 exit_point:
5461 if (shndx != NULL)
9ad5cbcf 5462 free (shndx);
ba5cdace
NC		 5463 if (esyms != NULL)
5464 free (esyms);
5465
5466 if (num_syms_return != NULL)
5467 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 5468
5469 return isyms;
5470}
5471
d1133906 5472static const char *
d3ba0551 5473get_elf_section_flags (bfd_vma sh_flags)
d1133906 5474{
5477e8a0 5475 static char buff[1024];
2cf0635d 5476 char * p = buff;
8d5ff12c 5477 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 5478 int sindex;
5479 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 5480 bfd_vma os_flags = 0;
5481 bfd_vma proc_flags = 0;
5482 bfd_vma unknown_flags = 0;
148b93f2 5483 static const struct
5477e8a0 5484 {
2cf0635d 5485 const char * str;
5477e8a0
L		 5486 int len;
5487 }
5488 flags [] =
5489 {
cfcac11d
NC		 5490 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5491 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5492 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5493 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5494 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5495 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5496 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5497 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5498 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5499 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5500 /* IA-64 specific. */
5501 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5502 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5503 /* IA-64 OpenVMS specific. */
5504 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5505 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5506 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5507 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5508 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5509 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 5510 /* Generic. */
cfcac11d 5511 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 5512 /* SPARC specific. */
77115a4a 5513 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
ac4c9b04
MG		 5514 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5515 /* ARM specific. */
5516 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
f0728ee3 5517 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
ac4c9b04 5518 /* 23 */ { STRING_COMMA_LEN ("COMDEF") }
5477e8a0
L		 5519 };
5520
5521 if (do_section_details)
5522 {
8d5ff12c
L		 5523 sprintf (buff, "[%*.*lx]: ",
5524 field_size, field_size, (unsigned long) sh_flags);
5525 p += field_size + 4;
5477e8a0 5526 }
76da6bbe 5527
d1133906
NC		 5528 while (sh_flags)
5529 {
5530 bfd_vma flag;
5531
5532 flag = sh_flags & - sh_flags;
5533 sh_flags &= ~ flag;
76da6bbe 5534
5477e8a0 5535 if (do_section_details)
d1133906 5536 {
5477e8a0
L		 5537 switch (flag)
5538 {
91d6fa6a
NC		 5539 case SHF_WRITE: sindex = 0; break;
5540 case SHF_ALLOC: sindex = 1; break;
5541 case SHF_EXECINSTR: sindex = 2; break;
5542 case SHF_MERGE: sindex = 3; break;
5543 case SHF_STRINGS: sindex = 4; break;
5544 case SHF_INFO_LINK: sindex = 5; break;
5545 case SHF_LINK_ORDER: sindex = 6; break;
5546 case SHF_OS_NONCONFORMING: sindex = 7; break;
5547 case SHF_GROUP: sindex = 8; break;
5548 case SHF_TLS: sindex = 9; break;
18ae9cc1 5549 case SHF_EXCLUDE: sindex = 18; break;
77115a4a 5550 case SHF_COMPRESSED: sindex = 20; break;
76da6bbe 5551
5477e8a0 5552 default:
91d6fa6a 5553 sindex = -1;
cfcac11d 5554 switch (elf_header.e_machine)
148b93f2 5555 {
cfcac11d 5556 case EM_IA_64:
148b93f2 5557 if (flag == SHF_IA_64_SHORT)
91d6fa6a 5558 sindex = 10;
148b93f2 5559 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 5560 sindex = 11;
148b93f2
NC		 5561#ifdef BFD64
5562 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5563 switch (flag)
5564 {
91d6fa6a
NC		 5565 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5566 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5567 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5568 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5569 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5570 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 5571 default: break;
5572 }
5573#endif
cfcac11d
NC		 5574 break;
5575
caa83f8b 5576 case EM_386:
22abe556 5577 case EM_IAMCU:
caa83f8b 5578 case EM_X86_64:
7f502d6c 5579 case EM_L1OM:
7a9068fe 5580 case EM_K1OM:
cfcac11d
NC		 5581 case EM_OLD_SPARCV9:
5582 case EM_SPARC32PLUS:
5583 case EM_SPARCV9:
5584 case EM_SPARC:
18ae9cc1 5585 if (flag == SHF_ORDERED)
91d6fa6a 5586 sindex = 19;
cfcac11d 5587 break;
ac4c9b04
MG		 5588
5589 case EM_ARM:
5590 switch (flag)
5591 {
5592 case SHF_ENTRYSECT: sindex = 21; break;
f0728ee3 5593 case SHF_ARM_PURECODE: sindex = 22; break;
ac4c9b04
MG		 5594 case SHF_COMDEF: sindex = 23; break;
5595 default: break;
5596 }
5597 break;
5598
cfcac11d
NC		 5599 default:
5600 break;
148b93f2 5601 }
5477e8a0
L		 5602 }
5603
91d6fa6a 5604 if (sindex != -1)
5477e8a0 5605 {
8d5ff12c
L		 5606 if (p != buff + field_size + 4)
5607 {
5608 if (size < (10 + 2))
bee0ee85
NC		 5609 {
5610 warn (_("Internal error: not enough buffer room for section flag info"));
5611 return _("<unknown>");
5612 }
8d5ff12c
L		 5613 size -= 2;
5614 *p++ = ',';
5615 *p++ = ' ';
5616 }
5617
91d6fa6a
NC		 5618 size -= flags [sindex].len;
5619 p = stpcpy (p, flags [sindex].str);
5477e8a0 5620 }
3b22753a 5621 else if (flag & SHF_MASKOS)
8d5ff12c 5622 os_flags |= flag;
d1133906 5623 else if (flag & SHF_MASKPROC)
8d5ff12c 5624 proc_flags |= flag;
d1133906 5625 else
8d5ff12c 5626 unknown_flags |= flag;
5477e8a0
L		 5627 }
5628 else
5629 {
5630 switch (flag)
5631 {
5632 case SHF_WRITE: *p = 'W'; break;
5633 case SHF_ALLOC: *p = 'A'; break;
5634 case SHF_EXECINSTR: *p = 'X'; break;
5635 case SHF_MERGE: *p = 'M'; break;
5636 case SHF_STRINGS: *p = 'S'; break;
5637 case SHF_INFO_LINK: *p = 'I'; break;
5638 case SHF_LINK_ORDER: *p = 'L'; break;
5639 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5640 case SHF_GROUP: *p = 'G'; break;
5641 case SHF_TLS: *p = 'T'; break;
18ae9cc1 5642 case SHF_EXCLUDE: *p = 'E'; break;
77115a4a 5643 case SHF_COMPRESSED: *p = 'C'; break;
5477e8a0
L		 5644
5645 default:
8a9036a4 5646 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 5647 || elf_header.e_machine == EM_L1OM
5648 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 5649 && flag == SHF_X86_64_LARGE)
5650 *p = 'l';
91f68a68 5651 else if (elf_header.e_machine == EM_ARM
f0728ee3 5652 && flag == SHF_ARM_PURECODE)
91f68a68 5653 *p = 'y';
5477e8a0
L		 5654 else if (flag & SHF_MASKOS)
5655 {
5656 *p = 'o';
5657 sh_flags &= ~ SHF_MASKOS;
5658 }
5659 else if (flag & SHF_MASKPROC)
5660 {
5661 *p = 'p';
5662 sh_flags &= ~ SHF_MASKPROC;
5663 }
5664 else
5665 *p = 'x';
5666 break;
5667 }
5668 p++;
d1133906
NC		 5669 }
5670 }
76da6bbe 5671
8d5ff12c
L		 5672 if (do_section_details)
5673 {
5674 if (os_flags)
5675 {
5676 size -= 5 + field_size;
5677 if (p != buff + field_size + 4)
5678 {
5679 if (size < (2 + 1))
bee0ee85
NC		 5680 {
5681 warn (_("Internal error: not enough buffer room for section flag info"));
5682 return _("<unknown>");
5683 }
8d5ff12c
L		 5684 size -= 2;
5685 *p++ = ',';
5686 *p++ = ' ';
5687 }
5688 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5689 (unsigned long) os_flags);
5690 p += 5 + field_size;
5691 }
5692 if (proc_flags)
5693 {
5694 size -= 7 + field_size;
5695 if (p != buff + field_size + 4)
5696 {
5697 if (size < (2 + 1))
bee0ee85
NC		 5698 {
5699 warn (_("Internal error: not enough buffer room for section flag info"));
5700 return _("<unknown>");
5701 }
8d5ff12c
L		 5702 size -= 2;
5703 *p++ = ',';
5704 *p++ = ' ';
5705 }
5706 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5707 (unsigned long) proc_flags);
5708 p += 7 + field_size;
5709 }
5710 if (unknown_flags)
5711 {
5712 size -= 10 + field_size;
5713 if (p != buff + field_size + 4)
5714 {
5715 if (size < (2 + 1))
bee0ee85
NC		 5716 {
5717 warn (_("Internal error: not enough buffer room for section flag info"));
5718 return _("<unknown>");
5719 }
8d5ff12c
L		 5720 size -= 2;
5721 *p++ = ',';
5722 *p++ = ' ';
5723 }
2b692964 5724 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 5725 (unsigned long) unknown_flags);
5726 p += 10 + field_size;
5727 }
5728 }
5729
e9e44622 5730 *p = '\0';
d1133906
NC		 5731 return buff;
5732}
5733
77115a4a 5734static unsigned int
ebdf1ebf 5735get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
77115a4a
L		 5736{
5737 if (is_32bit_elf)
5738 {
5739 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
d8024a91 5740
ebdf1ebf
NC		 5741 if (size < sizeof (* echdr))
5742 {
5743 error (_("Compressed section is too small even for a compression header\n"));
5744 return 0;
5745 }
5746
77115a4a
L		 5747 chdr->ch_type = BYTE_GET (echdr->ch_type);
5748 chdr->ch_size = BYTE_GET (echdr->ch_size);
5749 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5750 return sizeof (*echdr);
5751 }
5752 else
5753 {
5754 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
d8024a91 5755
ebdf1ebf
NC		 5756 if (size < sizeof (* echdr))
5757 {
5758 error (_("Compressed section is too small even for a compression header\n"));
5759 return 0;
5760 }
5761
77115a4a
L		 5762 chdr->ch_type = BYTE_GET (echdr->ch_type);
5763 chdr->ch_size = BYTE_GET (echdr->ch_size);
5764 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5765 return sizeof (*echdr);
5766 }
5767}
5768
252b5132 5769static int
2cf0635d 5770process_section_headers (FILE * file)
252b5132 5771{
2cf0635d 5772 Elf_Internal_Shdr * section;
b34976b6 5773 unsigned int i;
252b5132
RH		 5774
5775 section_headers = NULL;
5776
5777 if (elf_header.e_shnum == 0)
5778 {
82f2dbf7
NC		 5779 /* PR binutils/12467. */
5780 if (elf_header.e_shoff != 0)
5781 warn (_("possibly corrupt ELF file header - it has a non-zero"
5782 " section header offset, but no section headers\n"));
5783 else if (do_sections)
252b5132
RH		 5784 printf (_("\nThere are no sections in this file.\n"));
5785
5786 return 1;
5787 }
5788
5789 if (do_sections && !do_header)
9ea033b2 5790 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 5791 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5792
9ea033b2
NC		 5793 if (is_32bit_elf)
5794 {
049b0c3a 5795 if (! get_32bit_section_headers (file, FALSE))
9ea033b2
NC		 5796 return 0;
5797 }
049b0c3a 5798 else if (! get_64bit_section_headers (file, FALSE))
252b5132
RH		 5799 return 0;
5800
5801 /* Read in the string table, so that we have names to display. */
0b49d371 5802 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 5803 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 5804 {
4fbb74a6 5805 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 5806
c256ffe7
JJ		 5807 if (section->sh_size != 0)
5808 {
3f5e193b
NC		 5809 string_table = (char *) get_data (NULL, file, section->sh_offset,
5810 1, section->sh_size,
5811 _("string table"));
0de14b54 5812
c256ffe7
JJ		 5813 string_table_length = string_table != NULL ? section->sh_size : 0;
5814 }
252b5132
RH		 5815 }
5816
5817 /* Scan the sections for the dynamic symbol table
e3c8793a 5818 and dynamic string table and debug sections. */
252b5132
RH		 5819 dynamic_symbols = NULL;
5820 dynamic_strings = NULL;
5821 dynamic_syminfo = NULL;
6a40cf0c 5822 symtab_shndx_list = NULL;
103f02d3 5823
89fac5e3
RS		 5824 eh_addr_size = is_32bit_elf ? 4 : 8;
5825 switch (elf_header.e_machine)
5826 {
5827 case EM_MIPS:
5828 case EM_MIPS_RS3_LE:
5829 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5830 FDE addresses. However, the ABI also has a semi-official ILP32
5831 variant for which the normal FDE address size rules apply.
5832
5833 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5834 section, where XX is the size of longs in bits. Unfortunately,
5835 earlier compilers provided no way of distinguishing ILP32 objects
5836 from LP64 objects, so if there's any doubt, we should assume that
5837 the official LP64 form is being used. */
5838 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5839 && find_section (".gcc_compiled_long32") == NULL)
5840 eh_addr_size = 8;
5841 break;
0f56a26a
DD		 5842
5843 case EM_H8_300:
5844 case EM_H8_300H:
5845 switch (elf_header.e_flags & EF_H8_MACH)
5846 {
5847 case E_H8_MACH_H8300:
5848 case E_H8_MACH_H8300HN:
5849 case E_H8_MACH_H8300SN:
5850 case E_H8_MACH_H8300SXN:
5851 eh_addr_size = 2;
5852 break;
5853 case E_H8_MACH_H8300H:
5854 case E_H8_MACH_H8300S:
5855 case E_H8_MACH_H8300SX:
5856 eh_addr_size = 4;
5857 break;
5858 }
f4236fe4
DD		 5859 break;
5860
ff7eeb89 5861 case EM_M32C_OLD:
f4236fe4
DD		 5862 case EM_M32C:
5863 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5864 {
5865 case EF_M32C_CPU_M16C:
5866 eh_addr_size = 2;
5867 break;
5868 }
5869 break;
89fac5e3
RS		 5870 }
5871
76ca31c0
NC		 5872#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5873 do \
5874 { \
5875 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5876 if (section->sh_entsize != expected_entsize) \
9dd3a467 5877 { \
76ca31c0
NC		 5878 char buf[40]; \
5879 sprintf_vma (buf, section->sh_entsize); \
5880 /* Note: coded this way so that there is a single string for \
5881 translation. */ \
5882 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5883 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5884 (unsigned) expected_entsize); \
9dd3a467 5885 section->sh_entsize = expected_entsize; \
76ca31c0
NC		 5886 } \
5887 } \
08d8fa11 5888 while (0)
9dd3a467
NC		 5889
5890#define CHECK_ENTSIZE(section, i, type) \
08d8fa11
JJ		 5891 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5892 sizeof (Elf64_External_##type))
5893
252b5132
RH		 5894 for (i = 0, section = section_headers;
5895 i < elf_header.e_shnum;
b34976b6 5896 i++, section++)
252b5132 5897 {
2cf0635d 5898 char * name = SECTION_NAME (section);
252b5132
RH		 5899
5900 if (section->sh_type == SHT_DYNSYM)
5901 {
5902 if (dynamic_symbols != NULL)
5903 {
5904 error (_("File contains multiple dynamic symbol tables\n"));
5905 continue;
5906 }
5907
08d8fa11 5908 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 5909 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 5910 }
5911 else if (section->sh_type == SHT_STRTAB
18bd398b 5912 && streq (name, ".dynstr"))
252b5132
RH		 5913 {
5914 if (dynamic_strings != NULL)
5915 {
5916 error (_("File contains multiple dynamic string tables\n"));
5917 continue;
5918 }
5919
3f5e193b
NC		 5920 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5921 1, section->sh_size,
5922 _("dynamic strings"));
59245841 5923 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 5924 }
9ad5cbcf
AM		 5925 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5926 {
6a40cf0c
NC		 5927 elf_section_list * entry = xmalloc (sizeof * entry);
5928 entry->hdr = section;
5929 entry->next = symtab_shndx_list;
5930 symtab_shndx_list = entry;
9ad5cbcf 5931 }
08d8fa11
JJ		 5932 else if (section->sh_type == SHT_SYMTAB)
5933 CHECK_ENTSIZE (section, i, Sym);
5934 else if (section->sh_type == SHT_GROUP)
5935 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5936 else if (section->sh_type == SHT_REL)
5937 CHECK_ENTSIZE (section, i, Rel);
5938 else if (section->sh_type == SHT_RELA)
5939 CHECK_ENTSIZE (section, i, Rela);
252b5132 5940 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 5941 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 5942 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC		 5943 || do_debug_str || do_debug_loc || do_debug_ranges
5944 || do_debug_addr || do_debug_cu_index)
1b315056
CS		 5945 && (const_strneq (name, ".debug_")
5946 || const_strneq (name, ".zdebug_")))
252b5132 5947 {
1b315056
CS		 5948 if (name[1] == 'z')
5949 name += sizeof (".zdebug_") - 1;
5950 else
5951 name += sizeof (".debug_") - 1;
252b5132
RH		 5952
5953 if (do_debugging
4723351a
CC		 5954 || (do_debug_info && const_strneq (name, "info"))
5955 || (do_debug_info && const_strneq (name, "types"))
5956 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
b40bf0a2
NC		 5957 || (do_debug_lines && strcmp (name, "line") == 0)
5958 || (do_debug_lines && const_strneq (name, "line."))
4723351a
CC		 5959 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5960 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
459d52c8
DE		 5961 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5962 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
4723351a
CC		 5963 || (do_debug_aranges && const_strneq (name, "aranges"))
5964 || (do_debug_ranges && const_strneq (name, "ranges"))
5965 || (do_debug_frames && const_strneq (name, "frame"))
5966 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5967 || (do_debug_macinfo && const_strneq (name, "macro"))
5968 || (do_debug_str && const_strneq (name, "str"))
5969 || (do_debug_loc && const_strneq (name, "loc"))
657d0d47
CC		 5970 || (do_debug_addr && const_strneq (name, "addr"))
5971 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5972 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 5973 )
09c11c86 5974 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 5975 }
a262ae96 5976 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 5977 else if ((do_debugging || do_debug_info)
0112cd26 5978 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 5979 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 5980 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 5981 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 5982 else if (do_gdb_index && streq (name, ".gdb_index"))
5983 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 5984 /* Trace sections for Itanium VMS. */
5985 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5986 || do_trace_aranges)
5987 && const_strneq (name, ".trace_"))
5988 {
5989 name += sizeof (".trace_") - 1;
5990
5991 if (do_debugging
5992 || (do_trace_info && streq (name, "info"))
5993 || (do_trace_abbrevs && streq (name, "abbrev"))
5994 || (do_trace_aranges && streq (name, "aranges"))
5995 )
5996 request_dump_bynumber (i, DEBUG_DUMP);
5997 }
252b5132
RH		 5998 }
5999
6000 if (! do_sections)
6001 return 1;
6002
3a1a2036
NC		 6003 if (elf_header.e_shnum > 1)
6004 printf (_("\nSection Headers:\n"));
6005 else
6006 printf (_("\nSection Header:\n"));
76da6bbe 6007
f7a99963 6008 if (is_32bit_elf)
595cf52e 6009 {
5477e8a0 6010 if (do_section_details)
595cf52e
L		 6011 {
6012 printf (_(" [Nr] Name\n"));
5477e8a0 6013 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 6014 }
6015 else
6016 printf
6017 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6018 }
d974e256 6019 else if (do_wide)
595cf52e 6020 {
5477e8a0 6021 if (do_section_details)
595cf52e
L		 6022 {
6023 printf (_(" [Nr] Name\n"));
5477e8a0 6024 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 6025 }
6026 else
6027 printf
6028 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6029 }
f7a99963
NC		 6030 else
6031 {
5477e8a0 6032 if (do_section_details)
595cf52e
L		 6033 {
6034 printf (_(" [Nr] Name\n"));
5477e8a0
L		 6035 printf (_(" Type Address Offset Link\n"));
6036 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 6037 }
6038 else
6039 {
6040 printf (_(" [Nr] Name Type Address Offset\n"));
6041 printf (_(" Size EntSize Flags Link Info Align\n"));
6042 }
f7a99963 6043 }
252b5132 6044
5477e8a0
L		 6045 if (do_section_details)
6046 printf (_(" Flags\n"));
6047
252b5132
RH		 6048 for (i = 0, section = section_headers;
6049 i < elf_header.e_shnum;
b34976b6 6050 i++, section++)
252b5132 6051 {
dd905818
NC		 6052 /* Run some sanity checks on the section header. */
6053
6054 /* Check the sh_link field. */
6055 switch (section->sh_type)
6056 {
6057 case SHT_SYMTAB_SHNDX:
6058 case SHT_GROUP:
6059 case SHT_HASH:
6060 case SHT_GNU_HASH:
6061 case SHT_GNU_versym:
6062 case SHT_REL:
6063 case SHT_RELA:
6064 if (section->sh_link < 1
cb64e50d 6065 || section->sh_link >= elf_header.e_shnum
dd905818
NC		 6066 || (section_headers[section->sh_link].sh_type != SHT_SYMTAB
6067 && section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6068 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6069 i, section->sh_link);
6070 break;
6071
6072 case SHT_DYNAMIC:
6073 case SHT_SYMTAB:
6074 case SHT_DYNSYM:
6075 case SHT_GNU_verneed:
6076 case SHT_GNU_verdef:
6077 case SHT_GNU_LIBLIST:
6078 if (section->sh_link < 1
cb64e50d 6079 || section->sh_link >= elf_header.e_shnum
dd905818
NC		 6080 || section_headers[section->sh_link].sh_type != SHT_STRTAB)
6081 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6082 i, section->sh_link);
6083 break;
6084
6085 case SHT_INIT_ARRAY:
6086 case SHT_FINI_ARRAY:
6087 case SHT_PREINIT_ARRAY:
6088 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6089 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6090 i, section->sh_link);
6091 break;
6092
6093 default:
6094 /* FIXME: Add support for target specific section types. */
6095#if 0 /* Currently we do not check other section types as there are too
6096 many special cases. Stab sections for example have a type
6097 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6098 section. */
6099 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6100 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6101 i, section->sh_link);
6102#endif
6103 break;
6104 }
6105
6106 /* Check the sh_info field. */
6107 switch (section->sh_type)
6108 {
6109 case SHT_REL:
6110 case SHT_RELA:
6111 if (section->sh_info < 1
cb64e50d 6112 || section->sh_info >= elf_header.e_shnum
dd905818
NC		 6113 || (section_headers[section->sh_info].sh_type != SHT_PROGBITS
6114 && section_headers[section->sh_info].sh_type != SHT_NOBITS
6115 && section_headers[section->sh_info].sh_type != SHT_NOTE
6116 && section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6117 /* FIXME: Are other section types valid ? */
6118 && section_headers[section->sh_info].sh_type < SHT_LOOS))
6119 {
6120 if (section->sh_info == 0
6121 && (streq (SECTION_NAME (section), ".rel.dyn")
6122 || streq (SECTION_NAME (section), ".rela.dyn")))
6123 /* The .rel.dyn and .rela.dyn sections have an sh_info field
4d74727a
AM		 6124 of zero. The relocations in these sections may apply
6125 to many different sections. */
dd905818
NC		 6126 ;
6127 else
6128 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6129 i, section->sh_info);
6130 }
6131 break;
6132
6133 case SHT_DYNAMIC:
6134 case SHT_HASH:
6135 case SHT_SYMTAB_SHNDX:
6136 case SHT_INIT_ARRAY:
6137 case SHT_FINI_ARRAY:
6138 case SHT_PREINIT_ARRAY:
6139 if (section->sh_info != 0)
6140 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6141 i, section->sh_info);
6142 break;
6143
6144 case SHT_GROUP:
6145 case SHT_SYMTAB:
6146 case SHT_DYNSYM:
6147 /* A symbol index - we assume that it is valid. */
6148 break;
6149
6150 default:
6151 /* FIXME: Add support for target specific section types. */
6152 if (section->sh_type == SHT_NOBITS)
6153 /* NOBITS section headers with non-zero sh_info fields can be
6154 created when a binary is stripped of everything but its debug
1a9ccd70
NC		 6155 information. The stripped sections have their headers
6156 preserved but their types set to SHT_NOBITS. So do not check
6157 this type of section. */
dd905818
NC		 6158 ;
6159 else if (section->sh_flags & SHF_INFO_LINK)
6160 {
cb64e50d 6161 if (section->sh_info < 1 || section->sh_info >= elf_header.e_shnum)
dd905818
NC		 6162 warn (_("[%2u]: Expected link to another section in info field"), i);
6163 }
6164 else if (section->sh_type < SHT_LOOS && section->sh_info != 0)
6165 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6166 i, section->sh_info);
6167 break;
6168 }
6169
7bfd842d 6170 printf (" [%2u] ", i);
5477e8a0 6171 if (do_section_details)
74e1a04b 6172 printf ("%s\n ", printable_section_name (section));
595cf52e 6173 else
74e1a04b 6174 print_symbol (-17, SECTION_NAME (section));
0b4362b0 6175
ea52a088
NC		 6176 printf (do_wide ? " %-15s " : " %-15.15s ",
6177 get_section_type_name (section->sh_type));
0b4362b0 6178
f7a99963
NC		 6179 if (is_32bit_elf)
6180 {
cfcac11d
NC		 6181 const char * link_too_big = NULL;
6182
f7a99963 6183 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 6184
f7a99963
NC		 6185 printf ( " %6.6lx %6.6lx %2.2lx",
6186 (unsigned long) section->sh_offset,
6187 (unsigned long) section->sh_size,
6188 (unsigned long) section->sh_entsize);
d1133906 6189
5477e8a0
L		 6190 if (do_section_details)
6191 fputs (" ", stdout);
6192 else
6193 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 6194
cfcac11d
NC		 6195 if (section->sh_link >= elf_header.e_shnum)
6196 {
6197 link_too_big = "";
6198 /* The sh_link value is out of range. Normally this indicates
caa83f8b 6199 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 6200 switch (elf_header.e_machine)
6201 {
caa83f8b 6202 case EM_386:
22abe556 6203 case EM_IAMCU:
caa83f8b 6204 case EM_X86_64:
7f502d6c 6205 case EM_L1OM:
7a9068fe 6206 case EM_K1OM:
cfcac11d
NC		 6207 case EM_OLD_SPARCV9:
6208 case EM_SPARC32PLUS:
6209 case EM_SPARCV9:
6210 case EM_SPARC:
6211 if (section->sh_link == (SHN_BEFORE & 0xffff))
6212 link_too_big = "BEFORE";
6213 else if (section->sh_link == (SHN_AFTER & 0xffff))
6214 link_too_big = "AFTER";
6215 break;
6216 default:
6217 break;
6218 }
6219 }
6220
6221 if (do_section_details)
6222 {
6223 if (link_too_big != NULL && * link_too_big)
6224 printf ("<%s> ", link_too_big);
6225 else
6226 printf ("%2u ", section->sh_link);
6227 printf ("%3u %2lu\n", section->sh_info,
6228 (unsigned long) section->sh_addralign);
6229 }
6230 else
6231 printf ("%2u %3u %2lu\n",
6232 section->sh_link,
6233 section->sh_info,
6234 (unsigned long) section->sh_addralign);
6235
6236 if (link_too_big && ! * link_too_big)
6237 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6238 i, section->sh_link);
f7a99963 6239 }
d974e256
JJ		 6240 else if (do_wide)
6241 {
6242 print_vma (section->sh_addr, LONG_HEX);
6243
6244 if ((long) section->sh_offset == section->sh_offset)
6245 printf (" %6.6lx", (unsigned long) section->sh_offset);
6246 else
6247 {
6248 putchar (' ');
6249 print_vma (section->sh_offset, LONG_HEX);
6250 }
6251
6252 if ((unsigned long) section->sh_size == section->sh_size)
6253 printf (" %6.6lx", (unsigned long) section->sh_size);
6254 else
6255 {
6256 putchar (' ');
6257 print_vma (section->sh_size, LONG_HEX);
6258 }
6259
6260 if ((unsigned long) section->sh_entsize == section->sh_entsize)
6261 printf (" %2.2lx", (unsigned long) section->sh_entsize);
6262 else
6263 {
6264 putchar (' ');
6265 print_vma (section->sh_entsize, LONG_HEX);
6266 }
6267
5477e8a0
L		 6268 if (do_section_details)
6269 fputs (" ", stdout);
6270 else
6271 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 6272
72de5009 6273 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 6274
6275 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 6276 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 6277 else
6278 {
6279 print_vma (section->sh_addralign, DEC);
6280 putchar ('\n');
6281 }
6282 }
5477e8a0 6283 else if (do_section_details)
595cf52e 6284 {
5477e8a0 6285 printf (" %-15.15s ",
595cf52e 6286 get_section_type_name (section->sh_type));
595cf52e
L		 6287 print_vma (section->sh_addr, LONG_HEX);
6288 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 6289 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 6290 else
6291 {
6292 printf (" ");
6293 print_vma (section->sh_offset, LONG_HEX);
6294 }
72de5009 6295 printf (" %u\n ", section->sh_link);
595cf52e 6296 print_vma (section->sh_size, LONG_HEX);
5477e8a0 6297 putchar (' ');
595cf52e
L		 6298 print_vma (section->sh_entsize, LONG_HEX);
6299
72de5009
AM		 6300 printf (" %-16u %lu\n",
6301 section->sh_info,
595cf52e
L		 6302 (unsigned long) section->sh_addralign);
6303 }
f7a99963
NC		 6304 else
6305 {
6306 putchar (' ');
6307 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 6308 if ((long) section->sh_offset == section->sh_offset)
6309 printf (" %8.8lx", (unsigned long) section->sh_offset);
6310 else
6311 {
6312 printf (" ");
6313 print_vma (section->sh_offset, LONG_HEX);
6314 }
f7a99963
NC		 6315 printf ("\n ");
6316 print_vma (section->sh_size, LONG_HEX);
6317 printf (" ");
6318 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 6319
d1133906 6320 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 6321
72de5009
AM		 6322 printf (" %2u %3u %lu\n",
6323 section->sh_link,
6324 section->sh_info,
f7a99963
NC		 6325 (unsigned long) section->sh_addralign);
6326 }
5477e8a0
L		 6327
6328 if (do_section_details)
77115a4a
L		 6329 {
6330 printf (" %s\n", get_elf_section_flags (section->sh_flags));
6331 if ((section->sh_flags & SHF_COMPRESSED) != 0)
6332 {
6333 /* Minimum section size is 12 bytes for 32-bit compression
6334 header + 12 bytes for compressed data header. */
6335 unsigned char buf[24];
d8024a91 6336
77115a4a
L		 6337 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6338 if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
6339 sizeof (buf), _("compression header")))
6340 {
6341 Elf_Internal_Chdr chdr;
d8024a91 6342
ebdf1ebf 6343 (void) get_compression_header (&chdr, buf, sizeof (buf));
d8024a91 6344
77115a4a
L		 6345 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6346 printf (" ZLIB, ");
6347 else
6348 printf (_(" [<unknown>: 0x%x], "),
6349 chdr.ch_type);
6350 print_vma (chdr.ch_size, LONG_HEX);
6351 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6352 }
6353 }
6354 }
252b5132
RH		 6355 }
6356
5477e8a0 6357 if (!do_section_details)
3dbcc61d 6358 {
9fb71ee4
NC		 6359 /* The ordering of the letters shown here matches the ordering of the
6360 corresponding SHF_xxx values, and hence the order in which these
6361 letters will be displayed to the user. */
6362 printf (_("Key to Flags:\n\
6363 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6364 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
fd85a6a1 6365 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
3dbcc61d 6366 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 6367 || elf_header.e_machine == EM_L1OM
6368 || elf_header.e_machine == EM_K1OM)
9fb71ee4 6369 printf (_("l (large), "));
91f68a68 6370 else if (elf_header.e_machine == EM_ARM)
f0728ee3 6371 printf (_("y (purecode), "));
9fb71ee4 6372 printf ("p (processor specific)\n");
0b4362b0 6373 }
d1133906 6374
252b5132
RH		 6375 return 1;
6376}
6377
f5842774
L		 6378static const char *
6379get_group_flags (unsigned int flags)
6380{
1449284b 6381 static char buff[128];
220453ec 6382
6d913794
NC		 6383 if (flags == 0)
6384 return "";
6385 else if (flags == GRP_COMDAT)
6386 return "COMDAT ";
f5842774 6387
6d913794
NC		 6388 snprintf (buff, 14, _("[0x%x: "), flags);
6389
6390 flags &= ~ GRP_COMDAT;
6391 if (flags & GRP_MASKOS)
6392 {
6393 strcat (buff, "<OS specific>");
6394 flags &= ~ GRP_MASKOS;
f5842774 6395 }
6d913794
NC		 6396
6397 if (flags & GRP_MASKPROC)
6398 {
6399 strcat (buff, "<PROC specific>");
6400 flags &= ~ GRP_MASKPROC;
6401 }
6402
6403 if (flags)
6404 strcat (buff, "<unknown>");
6405
6406 strcat (buff, "]");
f5842774
L		 6407 return buff;
6408}
6409
6410static int
2cf0635d 6411process_section_groups (FILE * file)
f5842774 6412{
2cf0635d 6413 Elf_Internal_Shdr * section;
f5842774 6414 unsigned int i;
2cf0635d
NC		 6415 struct group * group;
6416 Elf_Internal_Shdr * symtab_sec;
6417 Elf_Internal_Shdr * strtab_sec;
6418 Elf_Internal_Sym * symtab;
ba5cdace 6419 unsigned long num_syms;
2cf0635d 6420 char * strtab;
c256ffe7 6421 size_t strtab_size;
d1f5c6e3
L		 6422
6423 /* Don't process section groups unless needed. */
6424 if (!do_unwind && !do_section_groups)
6425 return 1;
f5842774
L		 6426
6427 if (elf_header.e_shnum == 0)
6428 {
6429 if (do_section_groups)
82f2dbf7 6430 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 6431
6432 return 1;
6433 }
6434
6435 if (section_headers == NULL)
6436 {
6437 error (_("Section headers are not available!\n"));
fa1908fd
NC		 6438 /* PR 13622: This can happen with a corrupt ELF header. */
6439 return 0;
f5842774
L		 6440 }
6441
3f5e193b
NC		 6442 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
6443 sizeof (struct group *));
e4b17d5c
L		 6444
6445 if (section_headers_groups == NULL)
6446 {
8b73c356
NC		 6447 error (_("Out of memory reading %u section group headers\n"),
6448 elf_header.e_shnum);
e4b17d5c
L		 6449 return 0;
6450 }
6451
f5842774 6452 /* Scan the sections for the group section. */
d1f5c6e3 6453 group_count = 0;
f5842774
L		 6454 for (i = 0, section = section_headers;
6455 i < elf_header.e_shnum;
6456 i++, section++)
e4b17d5c
L		 6457 if (section->sh_type == SHT_GROUP)
6458 group_count++;
6459
d1f5c6e3
L		 6460 if (group_count == 0)
6461 {
6462 if (do_section_groups)
6463 printf (_("\nThere are no section groups in this file.\n"));
6464
6465 return 1;
6466 }
6467
3f5e193b 6468 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 6469
6470 if (section_groups == NULL)
6471 {
8b73c356
NC		 6472 error (_("Out of memory reading %lu groups\n"),
6473 (unsigned long) group_count);
e4b17d5c
L		 6474 return 0;
6475 }
6476
d1f5c6e3
L		 6477 symtab_sec = NULL;
6478 strtab_sec = NULL;
6479 symtab = NULL;
ba5cdace 6480 num_syms = 0;
d1f5c6e3 6481 strtab = NULL;
c256ffe7 6482 strtab_size = 0;
e4b17d5c
L		 6483 for (i = 0, section = section_headers, group = section_groups;
6484 i < elf_header.e_shnum;
6485 i++, section++)
f5842774
L		 6486 {
6487 if (section->sh_type == SHT_GROUP)
6488 {
74e1a04b
NC		 6489 const char * name = printable_section_name (section);
6490 const char * group_name;
2cf0635d
NC		 6491 unsigned char * start;
6492 unsigned char * indices;
f5842774 6493 unsigned int entry, j, size;
2cf0635d
NC		 6494 Elf_Internal_Shdr * sec;
6495 Elf_Internal_Sym * sym;
f5842774
L		 6496
6497 /* Get the symbol table. */
4fbb74a6
AM		 6498 if (section->sh_link >= elf_header.e_shnum
6499 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 6500 != SHT_SYMTAB))
f5842774
L		 6501 {
6502 error (_("Bad sh_link in group section `%s'\n"), name);
6503 continue;
6504 }
d1f5c6e3
L		 6505
6506 if (symtab_sec != sec)
6507 {
6508 symtab_sec = sec;
6509 if (symtab)
6510 free (symtab);
ba5cdace 6511 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 6512 }
f5842774 6513
dd24e3da
NC		 6514 if (symtab == NULL)
6515 {
6516 error (_("Corrupt header in group section `%s'\n"), name);
6517 continue;
6518 }
6519
ba5cdace
NC		 6520 if (section->sh_info >= num_syms)
6521 {
6522 error (_("Bad sh_info in group section `%s'\n"), name);
6523 continue;
6524 }
6525
f5842774
L		 6526 sym = symtab + section->sh_info;
6527
6528 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6529 {
4fbb74a6
AM		 6530 if (sym->st_shndx == 0
6531 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 6532 {
6533 error (_("Bad sh_info in group section `%s'\n"), name);
6534 continue;
6535 }
ba2685cc 6536
4fbb74a6 6537 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 6538 strtab_sec = NULL;
6539 if (strtab)
6540 free (strtab);
f5842774 6541 strtab = NULL;
c256ffe7 6542 strtab_size = 0;
f5842774
L		 6543 }
6544 else
6545 {
6546 /* Get the string table. */
4fbb74a6 6547 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 6548 {
6549 strtab_sec = NULL;
6550 if (strtab)
6551 free (strtab);
6552 strtab = NULL;
6553 strtab_size = 0;
6554 }
6555 else if (strtab_sec
4fbb74a6 6556 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 6557 {
6558 strtab_sec = sec;
6559 if (strtab)
6560 free (strtab);
071436c6 6561
3f5e193b 6562 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
071436c6
NC		 6563 1, strtab_sec->sh_size,
6564 _("string table"));
c256ffe7 6565 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 6566 }
c256ffe7 6567 group_name = sym->st_name < strtab_size
2b692964 6568 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 6569 }
6570
c9c1d674
EG		 6571 /* PR 17531: file: loop. */
6572 if (section->sh_entsize > section->sh_size)
6573 {
6574 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6575 printable_section_name (section),
8066deb1
AM		 6576 (unsigned long) section->sh_entsize,
6577 (unsigned long) section->sh_size);
c9c1d674
EG		 6578 break;
6579 }
6580
3f5e193b
NC		 6581 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6582 1, section->sh_size,
6583 _("section data"));
59245841
NC		 6584 if (start == NULL)
6585 continue;
f5842774
L		 6586
6587 indices = start;
6588 size = (section->sh_size / section->sh_entsize) - 1;
6589 entry = byte_get (indices, 4);
6590 indices += 4;
e4b17d5c
L		 6591
6592 if (do_section_groups)
6593 {
2b692964 6594 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 6595 get_group_flags (entry), i, name, group_name, size);
ba2685cc 6596
e4b17d5c
L		 6597 printf (_(" [Index] Name\n"));
6598 }
6599
6600 group->group_index = i;
6601
f5842774
L		 6602 for (j = 0; j < size; j++)
6603 {
2cf0635d 6604 struct group_list * g;
e4b17d5c 6605
f5842774
L		 6606 entry = byte_get (indices, 4);
6607 indices += 4;
6608
4fbb74a6 6609 if (entry >= elf_header.e_shnum)
391cb864 6610 {
57028622
NC		 6611 static unsigned num_group_errors = 0;
6612
6613 if (num_group_errors ++ < 10)
6614 {
6615 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6616 entry, i, elf_header.e_shnum - 1);
6617 if (num_group_errors == 10)
6618 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6619 }
391cb864
L		 6620 continue;
6621 }
391cb864 6622
4fbb74a6 6623 if (section_headers_groups [entry] != NULL)
e4b17d5c 6624 {
d1f5c6e3
L		 6625 if (entry)
6626 {
57028622
NC		 6627 static unsigned num_errs = 0;
6628
6629 if (num_errs ++ < 10)
6630 {
6631 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6632 entry, i,
6633 section_headers_groups [entry]->group_index);
6634 if (num_errs == 10)
6635 warn (_("Further error messages about already contained group sections suppressed\n"));
6636 }
d1f5c6e3
L		 6637 continue;
6638 }
6639 else
6640 {
6641 /* Intel C/C++ compiler may put section 0 in a
6642 section group. We just warn it the first time
6643 and ignore it afterwards. */
6644 static int warned = 0;
6645 if (!warned)
6646 {
6647 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 6648 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 6649 warned++;
6650 }
6651 }
e4b17d5c
L		 6652 }
6653
4fbb74a6 6654 section_headers_groups [entry] = group;
e4b17d5c
L		 6655
6656 if (do_section_groups)
6657 {
4fbb74a6 6658 sec = section_headers + entry;
74e1a04b 6659 printf (" [%5u] %s\n", entry, printable_section_name (sec));
ba2685cc
AM		 6660 }
6661
3f5e193b 6662 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 6663 g->section_index = entry;
6664 g->next = group->root;
6665 group->root = g;
f5842774
L		 6666 }
6667
f5842774
L		 6668 if (start)
6669 free (start);
e4b17d5c
L		 6670
6671 group++;
f5842774
L		 6672 }
6673 }
6674
d1f5c6e3
L		 6675 if (symtab)
6676 free (symtab);
6677 if (strtab)
6678 free (strtab);
f5842774
L		 6679 return 1;
6680}
6681
28f997cf
TG		 6682/* Data used to display dynamic fixups. */
6683
6684struct ia64_vms_dynfixup
6685{
6686 bfd_vma needed_ident; /* Library ident number. */
6687 bfd_vma needed; /* Index in the dstrtab of the library name. */
6688 bfd_vma fixup_needed; /* Index of the library. */
6689 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6690 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6691};
6692
6693/* Data used to display dynamic relocations. */
6694
6695struct ia64_vms_dynimgrela
6696{
6697 bfd_vma img_rela_cnt; /* Number of relocations. */
6698 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6699};
6700
6701/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6702 library). */
6703
6704static void
6705dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6706 const char *strtab, unsigned int strtab_sz)
6707{
6708 Elf64_External_VMS_IMAGE_FIXUP *imfs;
6709 long i;
6710 const char *lib_name;
6711
6712 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6713 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6714 _("dynamic section image fixups"));
6715 if (!imfs)
6716 return;
6717
6718 if (fixup->needed < strtab_sz)
6719 lib_name = strtab + fixup->needed;
6720 else
6721 {
6722 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 6723 (unsigned long) fixup->needed);
28f997cf
TG		 6724 lib_name = "???";
6725 }
6726 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6727 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6728 printf
6729 (_("Seg Offset Type SymVec DataType\n"));
6730
6731 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6732 {
6733 unsigned int type;
6734 const char *rtype;
6735
6736 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6737 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6738 type = BYTE_GET (imfs [i].type);
6739 rtype = elf_ia64_reloc_type (type);
6740 if (rtype == NULL)
6741 printf (" 0x%08x ", type);
6742 else
6743 printf (" %-32s ", rtype);
6744 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6745 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6746 }
6747
6748 free (imfs);
6749}
6750
6751/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6752
6753static void
6754dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6755{
6756 Elf64_External_VMS_IMAGE_RELA *imrs;
6757 long i;
6758
6759 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6760 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 6761 _("dynamic section image relocations"));
28f997cf
TG		 6762 if (!imrs)
6763 return;
6764
6765 printf (_("\nImage relocs\n"));
6766 printf
6767 (_("Seg Offset Type Addend Seg Sym Off\n"));
6768
6769 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6770 {
6771 unsigned int type;
6772 const char *rtype;
6773
6774 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6775 printf ("%08" BFD_VMA_FMT "x ",
6776 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6777 type = BYTE_GET (imrs [i].type);
6778 rtype = elf_ia64_reloc_type (type);
6779 if (rtype == NULL)
6780 printf ("0x%08x ", type);
6781 else
6782 printf ("%-31s ", rtype);
6783 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6784 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6785 printf ("%08" BFD_VMA_FMT "x\n",
6786 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6787 }
6788
6789 free (imrs);
6790}
6791
6792/* Display IA-64 OpenVMS dynamic relocations and fixups. */
6793
6794static int
6795process_ia64_vms_dynamic_relocs (FILE *file)
6796{
6797 struct ia64_vms_dynfixup fixup;
6798 struct ia64_vms_dynimgrela imgrela;
6799 Elf_Internal_Dyn *entry;
6800 int res = 0;
6801 bfd_vma strtab_off = 0;
6802 bfd_vma strtab_sz = 0;
6803 char *strtab = NULL;
6804
6805 memset (&fixup, 0, sizeof (fixup));
6806 memset (&imgrela, 0, sizeof (imgrela));
6807
6808 /* Note: the order of the entries is specified by the OpenVMS specs. */
6809 for (entry = dynamic_section;
6810 entry < dynamic_section + dynamic_nent;
6811 entry++)
6812 {
6813 switch (entry->d_tag)
6814 {
6815 case DT_IA_64_VMS_STRTAB_OFFSET:
6816 strtab_off = entry->d_un.d_val;
6817 break;
6818 case DT_STRSZ:
6819 strtab_sz = entry->d_un.d_val;
6820 if (strtab == NULL)
6821 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6822 1, strtab_sz, _("dynamic string section"));
6823 break;
6824
6825 case DT_IA_64_VMS_NEEDED_IDENT:
6826 fixup.needed_ident = entry->d_un.d_val;
6827 break;
6828 case DT_NEEDED:
6829 fixup.needed = entry->d_un.d_val;
6830 break;
6831 case DT_IA_64_VMS_FIXUP_NEEDED:
6832 fixup.fixup_needed = entry->d_un.d_val;
6833 break;
6834 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6835 fixup.fixup_rela_cnt = entry->d_un.d_val;
6836 break;
6837 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6838 fixup.fixup_rela_off = entry->d_un.d_val;
6839 res++;
6840 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6841 break;
6842
6843 case DT_IA_64_VMS_IMG_RELA_CNT:
6844 imgrela.img_rela_cnt = entry->d_un.d_val;
6845 break;
6846 case DT_IA_64_VMS_IMG_RELA_OFF:
6847 imgrela.img_rela_off = entry->d_un.d_val;
6848 res++;
6849 dump_ia64_vms_dynamic_relocs (file, &imgrela);
6850 break;
6851
6852 default:
6853 break;
6854 }
6855 }
6856
6857 if (strtab != NULL)
6858 free (strtab);
6859
6860 return res;
6861}
6862
85b1c36d 6863static struct
566b0d53 6864{
2cf0635d 6865 const char * name;
566b0d53
L		 6866 int reloc;
6867 int size;
6868 int rela;
6869} dynamic_relocations [] =
6870{
6871 { "REL", DT_REL, DT_RELSZ, FALSE },
6872 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6873 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6874};
6875
252b5132 6876/* Process the reloc section. */
18bd398b 6877
252b5132 6878static int
2cf0635d 6879process_relocs (FILE * file)
252b5132 6880{
b34976b6
AM		 6881 unsigned long rel_size;
6882 unsigned long rel_offset;
252b5132
RH		 6883
6884
6885 if (!do_reloc)
6886 return 1;
6887
6888 if (do_using_dynamic)
6889 {
566b0d53 6890 int is_rela;
2cf0635d 6891 const char * name;
566b0d53
L		 6892 int has_dynamic_reloc;
6893 unsigned int i;
0de14b54 6894
566b0d53 6895 has_dynamic_reloc = 0;
252b5132 6896
566b0d53 6897 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 6898 {
566b0d53
L		 6899 is_rela = dynamic_relocations [i].rela;
6900 name = dynamic_relocations [i].name;
6901 rel_size = dynamic_info [dynamic_relocations [i].size];
6902 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 6903
566b0d53
L		 6904 has_dynamic_reloc |= rel_size;
6905
6906 if (is_rela == UNKNOWN)
aa903cfb 6907 {
566b0d53
L		 6908 if (dynamic_relocations [i].reloc == DT_JMPREL)
6909 switch (dynamic_info[DT_PLTREL])
6910 {
6911 case DT_REL:
6912 is_rela = FALSE;
6913 break;
6914 case DT_RELA:
6915 is_rela = TRUE;
6916 break;
6917 }
aa903cfb 6918 }
252b5132 6919
566b0d53
L		 6920 if (rel_size)
6921 {
6922 printf
6923 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6924 name, rel_offset, rel_size);
252b5132 6925
d93f0186
NC		 6926 dump_relocations (file,
6927 offset_from_vma (file, rel_offset, rel_size),
6928 rel_size,
566b0d53 6929 dynamic_symbols, num_dynamic_syms,
bb4d2ac2
L		 6930 dynamic_strings, dynamic_strings_length,
6931 is_rela, 1);
566b0d53 6932 }
252b5132 6933 }
566b0d53 6934
28f997cf
TG		 6935 if (is_ia64_vms ())
6936 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6937
566b0d53 6938 if (! has_dynamic_reloc)
252b5132
RH		 6939 printf (_("\nThere are no dynamic relocations in this file.\n"));
6940 }
6941 else
6942 {
2cf0635d 6943 Elf_Internal_Shdr * section;
b34976b6
AM		 6944 unsigned long i;
6945 int found = 0;
252b5132
RH		 6946
6947 for (i = 0, section = section_headers;
6948 i < elf_header.e_shnum;
b34976b6 6949 i++, section++)
252b5132
RH		 6950 {
6951 if ( section->sh_type != SHT_RELA
6952 && section->sh_type != SHT_REL)
6953 continue;
6954
6955 rel_offset = section->sh_offset;
6956 rel_size = section->sh_size;
6957
6958 if (rel_size)
6959 {
2cf0635d 6960 Elf_Internal_Shdr * strsec;
b34976b6 6961 int is_rela;
103f02d3 6962
252b5132
RH		 6963 printf (_("\nRelocation section "));
6964
6965 if (string_table == NULL)
19936277 6966 printf ("%d", section->sh_name);
252b5132 6967 else
74e1a04b 6968 printf ("'%s'", printable_section_name (section));
252b5132
RH		 6969
6970 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6971 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6972
d79b3d50
NC		 6973 is_rela = section->sh_type == SHT_RELA;
6974
4fbb74a6
AM		 6975 if (section->sh_link != 0
6976 && section->sh_link < elf_header.e_shnum)
af3fc3bc 6977 {
2cf0635d
NC		 6978 Elf_Internal_Shdr * symsec;
6979 Elf_Internal_Sym * symtab;
d79b3d50 6980 unsigned long nsyms;
c256ffe7 6981 unsigned long strtablen = 0;
2cf0635d 6982 char * strtab = NULL;
57346661 6983
4fbb74a6 6984 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 6985 if (symsec->sh_type != SHT_SYMTAB
6986 && symsec->sh_type != SHT_DYNSYM)
6987 continue;
6988
ba5cdace 6989 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 6990
af3fc3bc
AM		 6991 if (symtab == NULL)
6992 continue;
252b5132 6993
4fbb74a6
AM		 6994 if (symsec->sh_link != 0
6995 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 6996 {
4fbb74a6 6997 strsec = section_headers + symsec->sh_link;
103f02d3 6998
3f5e193b 6999 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
071436c6
NC		 7000 1, strsec->sh_size,
7001 _("string table"));
c256ffe7
JJ		 7002 strtablen = strtab == NULL ? 0 : strsec->sh_size;
7003 }
252b5132 7004
d79b3d50 7005 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2
L		 7006 symtab, nsyms, strtab, strtablen,
7007 is_rela,
7008 symsec->sh_type == SHT_DYNSYM);
d79b3d50
NC		 7009 if (strtab)
7010 free (strtab);
7011 free (symtab);
7012 }
7013 else
7014 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2 7015 NULL, 0, NULL, 0, is_rela, 0);
252b5132
RH		 7016
7017 found = 1;
7018 }
7019 }
7020
7021 if (! found)
7022 printf (_("\nThere are no relocations in this file.\n"));
7023 }
7024
7025 return 1;
7026}
7027
4d6ed7c8
NC		 7028/* An absolute address consists of a section and an offset. If the
7029 section is NULL, the offset itself is the address, otherwise, the
7030 address equals to LOAD_ADDRESS(section) + offset. */
7031
7032struct absaddr
948f632f
DA		 7033{
7034 unsigned short section;
7035 bfd_vma offset;
7036};
4d6ed7c8 7037
1949de15
L		 7038#define ABSADDR(a) \
7039 ((a).section \
7040 ? section_headers [(a).section].sh_addr + (a).offset \
7041 : (a).offset)
7042
948f632f
DA		 7043/* Find the nearest symbol at or below ADDR. Returns the symbol
7044 name, if found, and the offset from the symbol to ADDR. */
4d6ed7c8 7045
4d6ed7c8 7046static void
2cf0635d 7047find_symbol_for_address (Elf_Internal_Sym * symtab,
948f632f
DA		 7048 unsigned long nsyms,
7049 const char * strtab,
7050 unsigned long strtab_size,
7051 struct absaddr addr,
7052 const char ** symname,
7053 bfd_vma * offset)
4d6ed7c8 7054{
d3ba0551 7055 bfd_vma dist = 0x100000;
2cf0635d 7056 Elf_Internal_Sym * sym;
948f632f
DA		 7057 Elf_Internal_Sym * beg;
7058 Elf_Internal_Sym * end;
2cf0635d 7059 Elf_Internal_Sym * best = NULL;
4d6ed7c8 7060
0b6ae522 7061 REMOVE_ARCH_BITS (addr.offset);
948f632f
DA		 7062 beg = symtab;
7063 end = symtab + nsyms;
0b6ae522 7064
948f632f 7065 while (beg < end)
4d6ed7c8 7066 {
948f632f
DA		 7067 bfd_vma value;
7068
7069 sym = beg + (end - beg) / 2;
0b6ae522 7070
948f632f 7071 value = sym->st_value;
0b6ae522
DJ		 7072 REMOVE_ARCH_BITS (value);
7073
948f632f 7074 if (sym->st_name != 0
4d6ed7c8 7075 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 7076 && addr.offset >= value
7077 && addr.offset - value < dist)
4d6ed7c8
NC		 7078 {
7079 best = sym;
0b6ae522 7080 dist = addr.offset - value;
4d6ed7c8
NC		 7081 if (!dist)
7082 break;
7083 }
948f632f
DA		 7084
7085 if (addr.offset < value)
7086 end = sym;
7087 else
7088 beg = sym + 1;
4d6ed7c8 7089 }
1b31d05e 7090
4d6ed7c8
NC		 7091 if (best)
7092 {
57346661 7093 *symname = (best->st_name >= strtab_size
2b692964 7094 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 7095 *offset = dist;
7096 return;
7097 }
1b31d05e 7098
4d6ed7c8
NC		 7099 *symname = NULL;
7100 *offset = addr.offset;
7101}
7102
948f632f
DA		 7103static int
7104symcmp (const void *p, const void *q)
7105{
7106 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7107 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7108
7109 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7110}
7111
7112/* Process the unwind section. */
7113
7114#include "unwind-ia64.h"
7115
7116struct ia64_unw_table_entry
7117{
7118 struct absaddr start;
7119 struct absaddr end;
7120 struct absaddr info;
7121};
7122
7123struct ia64_unw_aux_info
7124{
7125 struct ia64_unw_table_entry *table; /* Unwind table. */
7126 unsigned long table_len; /* Length of unwind table. */
7127 unsigned char * info; /* Unwind info. */
7128 unsigned long info_size; /* Size of unwind info. */
7129 bfd_vma info_addr; /* Starting address of unwind info. */
7130 bfd_vma seg_base; /* Starting address of segment. */
7131 Elf_Internal_Sym * symtab; /* The symbol table. */
7132 unsigned long nsyms; /* Number of symbols. */
7133 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7134 unsigned long nfuns; /* Number of entries in funtab. */
7135 char * strtab; /* The string table. */
7136 unsigned long strtab_size; /* Size of string table. */
7137};
7138
4d6ed7c8 7139static void
2cf0635d 7140dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 7141{
2cf0635d 7142 struct ia64_unw_table_entry * tp;
948f632f 7143 unsigned long j, nfuns;
4d6ed7c8 7144 int in_body;
7036c0e1 7145
948f632f
DA		 7146 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7147 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7148 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7149 aux->funtab[nfuns++] = aux->symtab[j];
7150 aux->nfuns = nfuns;
7151 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7152
4d6ed7c8
NC		 7153 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7154 {
7155 bfd_vma stamp;
7156 bfd_vma offset;
2cf0635d
NC		 7157 const unsigned char * dp;
7158 const unsigned char * head;
53774b7e 7159 const unsigned char * end;
2cf0635d 7160 const char * procname;
4d6ed7c8 7161
948f632f 7162 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661 7163 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 7164
7165 fputs ("\n<", stdout);
7166
7167 if (procname)
7168 {
7169 fputs (procname, stdout);
7170
7171 if (offset)
7172 printf ("+%lx", (unsigned long) offset);
7173 }
7174
7175 fputs (">: [", stdout);
7176 print_vma (tp->start.offset, PREFIX_HEX);
7177 fputc ('-', stdout);
7178 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 7179 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 7180 (unsigned long) (tp->info.offset - aux->seg_base));
7181
53774b7e
NC		 7182 /* PR 17531: file: 86232b32. */
7183 if (aux->info == NULL)
7184 continue;
7185
7186 /* PR 17531: file: 0997b4d1. */
7187 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7188 {
7189 warn (_("Invalid offset %lx in table entry %ld\n"),
7190 (long) tp->info.offset, (long) (tp - aux->table));
7191 continue;
7192 }
7193
1949de15 7194 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 7195 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 7196
86f55779 7197 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 7198 (unsigned) UNW_VER (stamp),
7199 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7200 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7201 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 7202 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 7203
7204 if (UNW_VER (stamp) != 1)
7205 {
2b692964 7206 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 7207 continue;
7208 }
7209
7210 in_body = 0;
53774b7e
NC		 7211 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7212 /* PR 17531: file: 16ceda89. */
7213 if (end > aux->info + aux->info_size)
7214 end = aux->info + aux->info_size;
7215 for (dp = head + 8; dp < end;)
b4477bc8 7216 dp = unw_decode (dp, in_body, & in_body, end);
4d6ed7c8 7217 }
948f632f
DA		 7218
7219 free (aux->funtab);
4d6ed7c8
NC		 7220}
7221
53774b7e 7222static bfd_boolean
2cf0635d
NC		 7223slurp_ia64_unwind_table (FILE * file,
7224 struct ia64_unw_aux_info * aux,
7225 Elf_Internal_Shdr * sec)
4d6ed7c8 7226{
89fac5e3 7227 unsigned long size, nrelas, i;
2cf0635d
NC		 7228 Elf_Internal_Phdr * seg;
7229 struct ia64_unw_table_entry * tep;
7230 Elf_Internal_Shdr * relsec;
7231 Elf_Internal_Rela * rela;
7232 Elf_Internal_Rela * rp;
7233 unsigned char * table;
7234 unsigned char * tp;
7235 Elf_Internal_Sym * sym;
7236 const char * relname;
4d6ed7c8 7237
53774b7e
NC		 7238 aux->table_len = 0;
7239
4d6ed7c8
NC		 7240 /* First, find the starting address of the segment that includes
7241 this section: */
7242
7243 if (elf_header.e_phnum)
7244 {
d93f0186 7245 if (! get_program_headers (file))
53774b7e 7246 return FALSE;
4d6ed7c8 7247
d93f0186
NC		 7248 for (seg = program_headers;
7249 seg < program_headers + elf_header.e_phnum;
7250 ++seg)
4d6ed7c8
NC		 7251 {
7252 if (seg->p_type != PT_LOAD)
7253 continue;
7254
7255 if (sec->sh_addr >= seg->p_vaddr
7256 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7257 {
7258 aux->seg_base = seg->p_vaddr;
7259 break;
7260 }
7261 }
4d6ed7c8
NC		 7262 }
7263
7264 /* Second, build the unwind table from the contents of the unwind section: */
7265 size = sec->sh_size;
3f5e193b
NC		 7266 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7267 _("unwind table"));
a6e9f9df 7268 if (!table)
53774b7e 7269 return FALSE;
4d6ed7c8 7270
53774b7e 7271 aux->table_len = size / (3 * eh_addr_size);
3f5e193b 7272 aux->table = (struct ia64_unw_table_entry *)
53774b7e 7273 xcmalloc (aux->table_len, sizeof (aux->table[0]));
89fac5e3 7274 tep = aux->table;
53774b7e
NC		 7275
7276 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
4d6ed7c8
NC		 7277 {
7278 tep->start.section = SHN_UNDEF;
7279 tep->end.section = SHN_UNDEF;
7280 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 7281 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7282 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7283 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 7284 tep->start.offset += aux->seg_base;
7285 tep->end.offset += aux->seg_base;
7286 tep->info.offset += aux->seg_base;
7287 }
7288 free (table);
7289
41e92641 7290 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 7291 for (relsec = section_headers;
7292 relsec < section_headers + elf_header.e_shnum;
7293 ++relsec)
7294 {
7295 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 7296 || relsec->sh_info >= elf_header.e_shnum
7297 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 7298 continue;
7299
7300 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7301 & rela, & nrelas))
53774b7e
NC		 7302 {
7303 free (aux->table);
7304 aux->table = NULL;
7305 aux->table_len = 0;
7306 return FALSE;
7307 }
4d6ed7c8
NC		 7308
7309 for (rp = rela; rp < rela + nrelas; ++rp)
7310 {
aca88567
NC		 7311 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
7312 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 7313
82b1b41b
NC		 7314 /* PR 17531: file: 9fa67536. */
7315 if (relname == NULL)
7316 {
7317 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
7318 continue;
7319 }
948f632f 7320
0112cd26 7321 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 7322 {
82b1b41b 7323 warn (_("Skipping unexpected relocation type: %s\n"), relname);
4d6ed7c8
NC		 7324 continue;
7325 }
7326
89fac5e3 7327 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 7328
53774b7e
NC		 7329 /* PR 17531: file: 5bc8d9bf. */
7330 if (i >= aux->table_len)
7331 {
7332 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7333 continue;
7334 }
7335
7336 switch (rp->r_offset / eh_addr_size % 3)
4d6ed7c8
NC		 7337 {
7338 case 0:
7339 aux->table[i].start.section = sym->st_shndx;
e466bc6e 7340 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 7341 break;
7342 case 1:
7343 aux->table[i].end.section = sym->st_shndx;
e466bc6e 7344 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 7345 break;
7346 case 2:
7347 aux->table[i].info.section = sym->st_shndx;
e466bc6e 7348 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 7349 break;
7350 default:
7351 break;
7352 }
7353 }
7354
7355 free (rela);
7356 }
7357
53774b7e 7358 return TRUE;
4d6ed7c8
NC		 7359}
7360
1b31d05e 7361static void
2cf0635d 7362ia64_process_unwind (FILE * file)
4d6ed7c8 7363{
2cf0635d
NC		 7364 Elf_Internal_Shdr * sec;
7365 Elf_Internal_Shdr * unwsec = NULL;
7366 Elf_Internal_Shdr * strsec;
89fac5e3 7367 unsigned long i, unwcount = 0, unwstart = 0;
57346661 7368 struct ia64_unw_aux_info aux;
f1467e33 7369
4d6ed7c8
NC		 7370 memset (& aux, 0, sizeof (aux));
7371
4d6ed7c8
NC		 7372 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7373 {
c256ffe7 7374 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 7375 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 7376 {
ba5cdace 7377 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 7378
4fbb74a6 7379 strsec = section_headers + sec->sh_link;
4082ef84
NC		 7380 if (aux.strtab != NULL)
7381 {
7382 error (_("Multiple auxillary string tables encountered\n"));
7383 free (aux.strtab);
7384 }
3f5e193b
NC		 7385 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7386 1, strsec->sh_size,
7387 _("string table"));
c256ffe7 7388 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 7389 }
7390 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 7391 unwcount++;
7392 }
7393
7394 if (!unwcount)
7395 printf (_("\nThere are no unwind sections in this file.\n"));
7396
7397 while (unwcount-- > 0)
7398 {
2cf0635d 7399 char * suffix;
579f31ac
JJ		 7400 size_t len, len2;
7401
4082ef84 7402 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
579f31ac
JJ		 7403 i < elf_header.e_shnum; ++i, ++sec)
7404 if (sec->sh_type == SHT_IA_64_UNWIND)
7405 {
7406 unwsec = sec;
7407 break;
7408 }
4082ef84
NC		 7409 /* We have already counted the number of SHT_IA64_UNWIND
7410 sections so the loop above should never fail. */
7411 assert (unwsec != NULL);
579f31ac
JJ		 7412
7413 unwstart = i + 1;
7414 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7415
e4b17d5c
L		 7416 if ((unwsec->sh_flags & SHF_GROUP) != 0)
7417 {
7418 /* We need to find which section group it is in. */
4082ef84 7419 struct group_list * g;
e4b17d5c 7420
4082ef84
NC		 7421 if (section_headers_groups == NULL
7422 || section_headers_groups [i] == NULL)
7423 i = elf_header.e_shnum;
7424 else
e4b17d5c 7425 {
4082ef84 7426 g = section_headers_groups [i]->root;
18bd398b 7427
4082ef84
NC		 7428 for (; g != NULL; g = g->next)
7429 {
7430 sec = section_headers + g->section_index;
e4b17d5c 7431
4082ef84
NC		 7432 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7433 break;
7434 }
7435
7436 if (g == NULL)
7437 i = elf_header.e_shnum;
7438 }
e4b17d5c 7439 }
18bd398b 7440 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 7441 {
18bd398b 7442 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 7443 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7444 suffix = SECTION_NAME (unwsec) + len;
7445 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7446 ++i, ++sec)
18bd398b
NC		 7447 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7448 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 7449 break;
7450 }
7451 else
7452 {
7453 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 7454 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 7455 len = sizeof (ELF_STRING_ia64_unwind) - 1;
7456 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7457 suffix = "";
18bd398b 7458 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 7459 suffix = SECTION_NAME (unwsec) + len;
7460 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7461 ++i, ++sec)
18bd398b
NC		 7462 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7463 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 7464 break;
7465 }
7466
7467 if (i == elf_header.e_shnum)
7468 {
7469 printf (_("\nCould not find unwind info section for "));
7470
7471 if (string_table == NULL)
7472 printf ("%d", unwsec->sh_name);
7473 else
74e1a04b 7474 printf ("'%s'", printable_section_name (unwsec));
579f31ac
JJ		 7475 }
7476 else
4d6ed7c8 7477 {
4d6ed7c8 7478 aux.info_addr = sec->sh_addr;
3f5e193b 7479 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
4082ef84
NC		 7480 sec->sh_size,
7481 _("unwind info"));
59245841 7482 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 7483
579f31ac 7484 printf (_("\nUnwind section "));
4d6ed7c8 7485
579f31ac
JJ		 7486 if (string_table == NULL)
7487 printf ("%d", unwsec->sh_name);
7488 else
74e1a04b 7489 printf ("'%s'", printable_section_name (unwsec));
4d6ed7c8 7490
579f31ac 7491 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 7492 (unsigned long) unwsec->sh_offset,
89fac5e3 7493 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 7494
53774b7e
NC		 7495 if (slurp_ia64_unwind_table (file, & aux, unwsec)
7496 && aux.table_len > 0)
579f31ac
JJ		 7497 dump_ia64_unwind (& aux);
7498
7499 if (aux.table)
7500 free ((char *) aux.table);
7501 if (aux.info)
7502 free ((char *) aux.info);
7503 aux.table = NULL;
7504 aux.info = NULL;
7505 }
4d6ed7c8 7506 }
4d6ed7c8 7507
4d6ed7c8
NC		 7508 if (aux.symtab)
7509 free (aux.symtab);
7510 if (aux.strtab)
7511 free ((char *) aux.strtab);
4d6ed7c8
NC		 7512}
7513
3f5e193b
NC		 7514struct hppa_unw_table_entry
7515 {
7516 struct absaddr start;
7517 struct absaddr end;
948f632f 7518 unsigned int Cannot_unwind:1; /* 0 */
3f5e193b
NC		 7519 unsigned int Millicode:1; /* 1 */
7520 unsigned int Millicode_save_sr0:1; /* 2 */
7521 unsigned int Region_description:2; /* 3..4 */
7522 unsigned int reserved1:1; /* 5 */
7523 unsigned int Entry_SR:1; /* 6 */
7524 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
7525 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
7526 unsigned int Args_stored:1; /* 16 */
948f632f
DA		 7527 unsigned int Variable_Frame:1; /* 17 */
7528 unsigned int Separate_Package_Body:1; /* 18 */
3f5e193b 7529 unsigned int Frame_Extension_Millicode:1; /* 19 */
948f632f
DA		 7530 unsigned int Stack_Overflow_Check:1; /* 20 */
7531 unsigned int Two_Instruction_SP_Increment:1;/* 21 */
3f5e193b
NC		 7532 unsigned int Ada_Region:1; /* 22 */
7533 unsigned int cxx_info:1; /* 23 */
948f632f
DA		 7534 unsigned int cxx_try_catch:1; /* 24 */
7535 unsigned int sched_entry_seq:1; /* 25 */
3f5e193b 7536 unsigned int reserved2:1; /* 26 */
948f632f
DA		 7537 unsigned int Save_SP:1; /* 27 */
7538 unsigned int Save_RP:1; /* 28 */
3f5e193b
NC		 7539 unsigned int Save_MRP_in_frame:1; /* 29 */
7540 unsigned int extn_ptr_defined:1; /* 30 */
948f632f 7541 unsigned int Cleanup_defined:1; /* 31 */
3f5e193b 7542
948f632f
DA		 7543 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
7544 unsigned int HP_UX_interrupt_marker:1; /* 1 */
3f5e193b 7545 unsigned int Large_frame:1; /* 2 */
948f632f 7546 unsigned int Pseudo_SP_Set:1; /* 3 */
3f5e193b
NC		 7547 unsigned int reserved4:1; /* 4 */
7548 unsigned int Total_frame_size:27; /* 5..31 */
7549 };
7550
57346661 7551struct hppa_unw_aux_info
948f632f
DA		 7552{
7553 struct hppa_unw_table_entry * table; /* Unwind table. */
7554 unsigned long table_len; /* Length of unwind table. */
7555 bfd_vma seg_base; /* Starting address of segment. */
7556 Elf_Internal_Sym * symtab; /* The symbol table. */
7557 unsigned long nsyms; /* Number of symbols. */
7558 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7559 unsigned long nfuns; /* Number of entries in funtab. */
7560 char * strtab; /* The string table. */
7561 unsigned long strtab_size; /* Size of string table. */
7562};
57346661
AM		 7563
7564static void
2cf0635d 7565dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 7566{
2cf0635d 7567 struct hppa_unw_table_entry * tp;
948f632f
DA		 7568 unsigned long j, nfuns;
7569
7570 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7571 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7572 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7573 aux->funtab[nfuns++] = aux->symtab[j];
7574 aux->nfuns = nfuns;
7575 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
57346661 7576
57346661
AM		 7577 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7578 {
7579 bfd_vma offset;
2cf0635d 7580 const char * procname;
57346661 7581
948f632f 7582 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661
AM		 7583 aux->strtab_size, tp->start, &procname,
7584 &offset);
7585
7586 fputs ("\n<", stdout);
7587
7588 if (procname)
7589 {
7590 fputs (procname, stdout);
7591
7592 if (offset)
7593 printf ("+%lx", (unsigned long) offset);
7594 }
7595
7596 fputs (">: [", stdout);
7597 print_vma (tp->start.offset, PREFIX_HEX);
7598 fputc ('-', stdout);
7599 print_vma (tp->end.offset, PREFIX_HEX);
7600 printf ("]\n\t");
7601
18bd398b
NC		 7602#define PF(_m) if (tp->_m) printf (#_m " ");
7603#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 7604 PF(Cannot_unwind);
7605 PF(Millicode);
7606 PF(Millicode_save_sr0);
18bd398b 7607 /* PV(Region_description); */
57346661
AM		 7608 PF(Entry_SR);
7609 PV(Entry_FR);
7610 PV(Entry_GR);
7611 PF(Args_stored);
7612 PF(Variable_Frame);
7613 PF(Separate_Package_Body);
7614 PF(Frame_Extension_Millicode);
7615 PF(Stack_Overflow_Check);
7616 PF(Two_Instruction_SP_Increment);
7617 PF(Ada_Region);
7618 PF(cxx_info);
7619 PF(cxx_try_catch);
7620 PF(sched_entry_seq);
7621 PF(Save_SP);
7622 PF(Save_RP);
7623 PF(Save_MRP_in_frame);
7624 PF(extn_ptr_defined);
7625 PF(Cleanup_defined);
7626 PF(MPE_XL_interrupt_marker);
7627 PF(HP_UX_interrupt_marker);
7628 PF(Large_frame);
7629 PF(Pseudo_SP_Set);
7630 PV(Total_frame_size);
7631#undef PF
7632#undef PV
7633 }
7634
18bd398b 7635 printf ("\n");
948f632f
DA		 7636
7637 free (aux->funtab);
57346661
AM		 7638}
7639
7640static int
2cf0635d
NC		 7641slurp_hppa_unwind_table (FILE * file,
7642 struct hppa_unw_aux_info * aux,
7643 Elf_Internal_Shdr * sec)
57346661 7644{
1c0751b2 7645 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 7646 Elf_Internal_Phdr * seg;
7647 struct hppa_unw_table_entry * tep;
7648 Elf_Internal_Shdr * relsec;
7649 Elf_Internal_Rela * rela;
7650 Elf_Internal_Rela * rp;
7651 unsigned char * table;
7652 unsigned char * tp;
7653 Elf_Internal_Sym * sym;
7654 const char * relname;
57346661 7655
57346661
AM		 7656 /* First, find the starting address of the segment that includes
7657 this section. */
7658
7659 if (elf_header.e_phnum)
7660 {
7661 if (! get_program_headers (file))
7662 return 0;
7663
7664 for (seg = program_headers;
7665 seg < program_headers + elf_header.e_phnum;
7666 ++seg)
7667 {
7668 if (seg->p_type != PT_LOAD)
7669 continue;
7670
7671 if (sec->sh_addr >= seg->p_vaddr
7672 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7673 {
7674 aux->seg_base = seg->p_vaddr;
7675 break;
7676 }
7677 }
7678 }
7679
7680 /* Second, build the unwind table from the contents of the unwind
7681 section. */
7682 size = sec->sh_size;
3f5e193b
NC		 7683 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7684 _("unwind table"));
57346661
AM		 7685 if (!table)
7686 return 0;
7687
1c0751b2
DA		 7688 unw_ent_size = 16;
7689 nentries = size / unw_ent_size;
7690 size = unw_ent_size * nentries;
57346661 7691
3f5e193b
NC		 7692 tep = aux->table = (struct hppa_unw_table_entry *)
7693 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 7694
1c0751b2 7695 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 7696 {
7697 unsigned int tmp1, tmp2;
7698
7699 tep->start.section = SHN_UNDEF;
7700 tep->end.section = SHN_UNDEF;
7701
1c0751b2
DA		 7702 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7703 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7704 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7705 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7706
7707 tep->start.offset += aux->seg_base;
7708 tep->end.offset += aux->seg_base;
57346661
AM		 7709
7710 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7711 tep->Millicode = (tmp1 >> 30) & 0x1;
7712 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7713 tep->Region_description = (tmp1 >> 27) & 0x3;
7714 tep->reserved1 = (tmp1 >> 26) & 0x1;
7715 tep->Entry_SR = (tmp1 >> 25) & 0x1;
7716 tep->Entry_FR = (tmp1 >> 21) & 0xf;
7717 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7718 tep->Args_stored = (tmp1 >> 15) & 0x1;
7719 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7720 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7721 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7722 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7723 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7724 tep->Ada_Region = (tmp1 >> 9) & 0x1;
7725 tep->cxx_info = (tmp1 >> 8) & 0x1;
7726 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7727 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7728 tep->reserved2 = (tmp1 >> 5) & 0x1;
7729 tep->Save_SP = (tmp1 >> 4) & 0x1;
7730 tep->Save_RP = (tmp1 >> 3) & 0x1;
7731 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7732 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7733 tep->Cleanup_defined = tmp1 & 0x1;
7734
7735 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7736 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7737 tep->Large_frame = (tmp2 >> 29) & 0x1;
7738 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7739 tep->reserved4 = (tmp2 >> 27) & 0x1;
7740 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 7741 }
7742 free (table);
7743
7744 /* Third, apply any relocations to the unwind table. */
57346661
AM		 7745 for (relsec = section_headers;
7746 relsec < section_headers + elf_header.e_shnum;
7747 ++relsec)
7748 {
7749 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 7750 || relsec->sh_info >= elf_header.e_shnum
7751 || section_headers + relsec->sh_info != sec)
57346661
AM		 7752 continue;
7753
7754 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7755 & rela, & nrelas))
7756 return 0;
7757
7758 for (rp = rela; rp < rela + nrelas; ++rp)
7759 {
aca88567
NC		 7760 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7761 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 7762
7763 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 7764 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 7765 {
7766 warn (_("Skipping unexpected relocation type %s\n"), relname);
7767 continue;
7768 }
7769
7770 i = rp->r_offset / unw_ent_size;
7771
89fac5e3 7772 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 7773 {
7774 case 0:
7775 aux->table[i].start.section = sym->st_shndx;
1e456d54 7776 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 7777 break;
7778 case 1:
7779 aux->table[i].end.section = sym->st_shndx;
1e456d54 7780 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 7781 break;
7782 default:
7783 break;
7784 }
7785 }
7786
7787 free (rela);
7788 }
7789
1c0751b2 7790 aux->table_len = nentries;
57346661
AM		 7791
7792 return 1;
7793}
7794
1b31d05e 7795static void
2cf0635d 7796hppa_process_unwind (FILE * file)
57346661 7797{
57346661 7798 struct hppa_unw_aux_info aux;
2cf0635d
NC		 7799 Elf_Internal_Shdr * unwsec = NULL;
7800 Elf_Internal_Shdr * strsec;
7801 Elf_Internal_Shdr * sec;
18bd398b 7802 unsigned long i;
57346661 7803
c256ffe7 7804 if (string_table == NULL)
1b31d05e
NC		 7805 return;
7806
7807 memset (& aux, 0, sizeof (aux));
57346661
AM		 7808
7809 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7810 {
c256ffe7 7811 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 7812 && sec->sh_link < elf_header.e_shnum)
57346661 7813 {
ba5cdace 7814 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 7815
4fbb74a6 7816 strsec = section_headers + sec->sh_link;
4082ef84
NC		 7817 if (aux.strtab != NULL)
7818 {
7819 error (_("Multiple auxillary string tables encountered\n"));
7820 free (aux.strtab);
7821 }
3f5e193b
NC		 7822 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7823 1, strsec->sh_size,
7824 _("string table"));
c256ffe7 7825 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 7826 }
18bd398b 7827 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 7828 unwsec = sec;
7829 }
7830
7831 if (!unwsec)
7832 printf (_("\nThere are no unwind sections in this file.\n"));
7833
7834 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7835 {
18bd398b 7836 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 7837 {
74e1a04b
NC		 7838 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7839 printable_section_name (sec),
57346661 7840 (unsigned long) sec->sh_offset,
89fac5e3 7841 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 7842
7843 slurp_hppa_unwind_table (file, &aux, sec);
7844 if (aux.table_len > 0)
7845 dump_hppa_unwind (&aux);
7846
7847 if (aux.table)
7848 free ((char *) aux.table);
7849 aux.table = NULL;
7850 }
7851 }
7852
7853 if (aux.symtab)
7854 free (aux.symtab);
7855 if (aux.strtab)
7856 free ((char *) aux.strtab);
57346661
AM		 7857}
7858
0b6ae522
DJ		 7859struct arm_section
7860{
a734115a
NC		 7861 unsigned char * data; /* The unwind data. */
7862 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
7863 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
7864 unsigned long nrelas; /* The number of relocations. */
7865 unsigned int rel_type; /* REL or RELA ? */
7866 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 7867};
7868
7869struct arm_unw_aux_info
7870{
a734115a
NC		 7871 FILE * file; /* The file containing the unwind sections. */
7872 Elf_Internal_Sym * symtab; /* The file's symbol table. */
7873 unsigned long nsyms; /* Number of symbols. */
948f632f
DA		 7874 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7875 unsigned long nfuns; /* Number of these symbols. */
a734115a
NC		 7876 char * strtab; /* The file's string table. */
7877 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 7878};
7879
7880static const char *
7881arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7882 bfd_vma fn, struct absaddr addr)
7883{
7884 const char *procname;
7885 bfd_vma sym_offset;
7886
7887 if (addr.section == SHN_UNDEF)
7888 addr.offset = fn;
7889
948f632f 7890 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
0b6ae522
DJ		 7891 aux->strtab_size, addr, &procname,
7892 &sym_offset);
7893
7894 print_vma (fn, PREFIX_HEX);
7895
7896 if (procname)
7897 {
7898 fputs (" <", stdout);
7899 fputs (procname, stdout);
7900
7901 if (sym_offset)
7902 printf ("+0x%lx", (unsigned long) sym_offset);
7903 fputc ('>', stdout);
7904 }
7905
7906 return procname;
7907}
7908
7909static void
7910arm_free_section (struct arm_section *arm_sec)
7911{
7912 if (arm_sec->data != NULL)
7913 free (arm_sec->data);
7914
7915 if (arm_sec->rela != NULL)
7916 free (arm_sec->rela);
7917}
7918
a734115a
NC		 7919/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7920 cached section and install SEC instead.
7921 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7922 and return its valued in * WORDP, relocating if necessary.
1b31d05e 7923 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 7924 relocation's offset in ADDR.
1b31d05e
NC		 7925 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7926 into the string table of the symbol associated with the reloc. If no
7927 reloc was applied store -1 there.
7928 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 7929
7930static bfd_boolean
1b31d05e
NC		 7931get_unwind_section_word (struct arm_unw_aux_info * aux,
7932 struct arm_section * arm_sec,
7933 Elf_Internal_Shdr * sec,
7934 bfd_vma word_offset,
7935 unsigned int * wordp,
7936 struct absaddr * addr,
7937 bfd_vma * sym_name)
0b6ae522
DJ		 7938{
7939 Elf_Internal_Rela *rp;
7940 Elf_Internal_Sym *sym;
7941 const char * relname;
7942 unsigned int word;
7943 bfd_boolean wrapped;
7944
e0a31db1
NC		 7945 if (sec == NULL || arm_sec == NULL)
7946 return FALSE;
7947
0b6ae522
DJ		 7948 addr->section = SHN_UNDEF;
7949 addr->offset = 0;
7950
1b31d05e
NC		 7951 if (sym_name != NULL)
7952 *sym_name = (bfd_vma) -1;
7953
a734115a 7954 /* If necessary, update the section cache. */
0b6ae522
DJ		 7955 if (sec != arm_sec->sec)
7956 {
7957 Elf_Internal_Shdr *relsec;
7958
7959 arm_free_section (arm_sec);
7960
7961 arm_sec->sec = sec;
7962 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7963 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 7964 arm_sec->rela = NULL;
7965 arm_sec->nrelas = 0;
7966
7967 for (relsec = section_headers;
7968 relsec < section_headers + elf_header.e_shnum;
7969 ++relsec)
7970 {
7971 if (relsec->sh_info >= elf_header.e_shnum
1ae40aa4
NC		 7972 || section_headers + relsec->sh_info != sec
7973 /* PR 15745: Check the section type as well. */
7974 || (relsec->sh_type != SHT_REL
7975 && relsec->sh_type != SHT_RELA))
0b6ae522
DJ		 7976 continue;
7977
a734115a 7978 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 7979 if (relsec->sh_type == SHT_REL)
7980 {
7981 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7982 relsec->sh_size,
7983 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7984 return FALSE;
0b6ae522 7985 }
1ae40aa4 7986 else /* relsec->sh_type == SHT_RELA */
0b6ae522
DJ		 7987 {
7988 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7989 relsec->sh_size,
7990 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7991 return FALSE;
0b6ae522 7992 }
1ae40aa4 7993 break;
0b6ae522
DJ		 7994 }
7995
7996 arm_sec->next_rela = arm_sec->rela;
7997 }
7998
a734115a 7999 /* If there is no unwind data we can do nothing. */
0b6ae522 8000 if (arm_sec->data == NULL)
a734115a 8001 return FALSE;
0b6ae522 8002
e0a31db1 8003 /* If the offset is invalid then fail. */
1a915552
NC		 8004 if (word_offset > (sec->sh_size - 4)
8005 /* PR 18879 */
8006 || (sec->sh_size < 5 && word_offset >= sec->sh_size)
8007 || ((bfd_signed_vma) word_offset) < 0)
e0a31db1
NC		 8008 return FALSE;
8009
a734115a 8010 /* Get the word at the required offset. */
0b6ae522
DJ		 8011 word = byte_get (arm_sec->data + word_offset, 4);
8012
0eff7165
NC		 8013 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8014 if (arm_sec->rela == NULL)
8015 {
8016 * wordp = word;
8017 return TRUE;
8018 }
8019
a734115a 8020 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 8021 wrapped = FALSE;
8022 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8023 {
8024 bfd_vma prelval, offset;
8025
8026 if (rp->r_offset > word_offset && !wrapped)
8027 {
8028 rp = arm_sec->rela;
8029 wrapped = TRUE;
8030 }
8031 if (rp->r_offset > word_offset)
8032 break;
8033
8034 if (rp->r_offset & 3)
8035 {
8036 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8037 (unsigned long) rp->r_offset);
8038 continue;
8039 }
8040
8041 if (rp->r_offset < word_offset)
8042 continue;
8043
74e1a04b
NC		 8044 /* PR 17531: file: 027-161405-0.004 */
8045 if (aux->symtab == NULL)
8046 continue;
8047
0b6ae522
DJ		 8048 if (arm_sec->rel_type == SHT_REL)
8049 {
8050 offset = word & 0x7fffffff;
8051 if (offset & 0x40000000)
8052 offset |= ~ (bfd_vma) 0x7fffffff;
8053 }
a734115a 8054 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 8055 offset = rp->r_addend;
a734115a 8056 else
74e1a04b
NC		 8057 {
8058 error (_("Unknown section relocation type %d encountered\n"),
8059 arm_sec->rel_type);
8060 break;
8061 }
0b6ae522 8062
071436c6
NC		 8063 /* PR 17531 file: 027-1241568-0.004. */
8064 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8065 {
8066 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8067 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8068 break;
8069 }
8070
8071 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
0b6ae522
DJ		 8072 offset += sym->st_value;
8073 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8074
a734115a
NC		 8075 /* Check that we are processing the expected reloc type. */
8076 if (elf_header.e_machine == EM_ARM)
8077 {
8078 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 8079 if (relname == NULL)
8080 {
8081 warn (_("Skipping unknown ARM relocation type: %d\n"),
8082 (int) ELF32_R_TYPE (rp->r_info));
8083 continue;
8084 }
a734115a
NC		 8085
8086 if (streq (relname, "R_ARM_NONE"))
8087 continue;
0b4362b0 8088
a734115a
NC		 8089 if (! streq (relname, "R_ARM_PREL31"))
8090 {
071436c6 8091 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
a734115a
NC		 8092 continue;
8093 }
8094 }
8095 else if (elf_header.e_machine == EM_TI_C6000)
8096 {
8097 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 8098 if (relname == NULL)
8099 {
8100 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8101 (int) ELF32_R_TYPE (rp->r_info));
8102 continue;
8103 }
0b4362b0 8104
a734115a
NC		 8105 if (streq (relname, "R_C6000_NONE"))
8106 continue;
8107
8108 if (! streq (relname, "R_C6000_PREL31"))
8109 {
071436c6 8110 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
a734115a
NC		 8111 continue;
8112 }
8113
8114 prelval >>= 1;
8115 }
8116 else
74e1a04b
NC		 8117 {
8118 /* This function currently only supports ARM and TI unwinders. */
8119 warn (_("Only TI and ARM unwinders are currently supported\n"));
8120 break;
8121 }
fa197c1c 8122
0b6ae522
DJ		 8123 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8124 addr->section = sym->st_shndx;
8125 addr->offset = offset;
74e1a04b 8126
1b31d05e
NC		 8127 if (sym_name)
8128 * sym_name = sym->st_name;
0b6ae522
DJ		 8129 break;
8130 }
8131
8132 *wordp = word;
8133 arm_sec->next_rela = rp;
8134
a734115a 8135 return TRUE;
0b6ae522
DJ		 8136}
8137
a734115a
NC		 8138static const char *tic6x_unwind_regnames[16] =
8139{
0b4362b0
RM		 8140 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8141 "A14", "A13", "A12", "A11", "A10",
a734115a
NC		 8142 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8143};
fa197c1c 8144
0b6ae522 8145static void
fa197c1c 8146decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 8147{
fa197c1c
PB		 8148 int i;
8149
8150 for (i = 12; mask; mask >>= 1, i--)
8151 {
8152 if (mask & 1)
8153 {
8154 fputs (tic6x_unwind_regnames[i], stdout);
8155 if (mask > 1)
8156 fputs (", ", stdout);
8157 }
8158 }
8159}
0b6ae522
DJ		 8160
8161#define ADVANCE \
8162 if (remaining == 0 && more_words) \
8163 { \
8164 data_offset += 4; \
1b31d05e
NC		 8165 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
8166 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 8167 return; \
8168 remaining = 4; \
8169 more_words--; \
8170 } \
8171
8172#define GET_OP(OP) \
8173 ADVANCE; \
8174 if (remaining) \
8175 { \
8176 remaining--; \
8177 (OP) = word >> 24; \
8178 word <<= 8; \
8179 } \
8180 else \
8181 { \
2b692964 8182 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 8183 return; \
8184 } \
cc5914eb 8185 printf ("0x%02x ", OP)
0b6ae522 8186
fa197c1c 8187static void
948f632f
DA		 8188decode_arm_unwind_bytecode (struct arm_unw_aux_info * aux,
8189 unsigned int word,
8190 unsigned int remaining,
8191 unsigned int more_words,
8192 bfd_vma data_offset,
8193 Elf_Internal_Shdr * data_sec,
8194 struct arm_section * data_arm_sec)
fa197c1c
PB		 8195{
8196 struct absaddr addr;
0b6ae522
DJ		 8197
8198 /* Decode the unwinding instructions. */
8199 while (1)
8200 {
8201 unsigned int op, op2;
8202
8203 ADVANCE;
8204 if (remaining == 0)
8205 break;
8206 remaining--;
8207 op = word >> 24;
8208 word <<= 8;
8209
cc5914eb 8210 printf (" 0x%02x ", op);
0b6ae522
DJ		 8211
8212 if ((op & 0xc0) == 0x00)
8213 {
8214 int offset = ((op & 0x3f) << 2) + 4;
61865e30 8215
cc5914eb 8216 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 8217 }
8218 else if ((op & 0xc0) == 0x40)
8219 {
8220 int offset = ((op & 0x3f) << 2) + 4;
61865e30 8221
cc5914eb 8222 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 8223 }
8224 else if ((op & 0xf0) == 0x80)
8225 {
8226 GET_OP (op2);
8227 if (op == 0x80 && op2 == 0)
8228 printf (_("Refuse to unwind"));
8229 else
8230 {
8231 unsigned int mask = ((op & 0x0f) << 8) | op2;
8232 int first = 1;
8233 int i;
2b692964 8234
0b6ae522
DJ		 8235 printf ("pop {");
8236 for (i = 0; i < 12; i++)
8237 if (mask & (1 << i))
8238 {
8239 if (first)
8240 first = 0;
8241 else
8242 printf (", ");
8243 printf ("r%d", 4 + i);
8244 }
8245 printf ("}");
8246 }
8247 }
8248 else if ((op & 0xf0) == 0x90)
8249 {
8250 if (op == 0x9d || op == 0x9f)
8251 printf (_(" [Reserved]"));
8252 else
cc5914eb 8253 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 8254 }
8255 else if ((op & 0xf0) == 0xa0)
8256 {
8257 int end = 4 + (op & 0x07);
8258 int first = 1;
8259 int i;
61865e30 8260
0b6ae522
DJ		 8261 printf (" pop {");
8262 for (i = 4; i <= end; i++)
8263 {
8264 if (first)
8265 first = 0;
8266 else
8267 printf (", ");
8268 printf ("r%d", i);
8269 }
8270 if (op & 0x08)
8271 {
1b31d05e 8272 if (!first)
0b6ae522
DJ		 8273 printf (", ");
8274 printf ("r14");
8275 }
8276 printf ("}");
8277 }
8278 else if (op == 0xb0)
8279 printf (_(" finish"));
8280 else if (op == 0xb1)
8281 {
8282 GET_OP (op2);
8283 if (op2 == 0 || (op2 & 0xf0) != 0)
8284 printf (_("[Spare]"));
8285 else
8286 {
8287 unsigned int mask = op2 & 0x0f;
8288 int first = 1;
8289 int i;
61865e30 8290
0b6ae522
DJ		 8291 printf ("pop {");
8292 for (i = 0; i < 12; i++)
8293 if (mask & (1 << i))
8294 {
8295 if (first)
8296 first = 0;
8297 else
8298 printf (", ");
8299 printf ("r%d", i);
8300 }
8301 printf ("}");
8302 }
8303 }
8304 else if (op == 0xb2)
8305 {
b115cf96 8306 unsigned char buf[9];
0b6ae522
DJ		 8307 unsigned int i, len;
8308 unsigned long offset;
61865e30 8309
b115cf96 8310 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 8311 {
8312 GET_OP (buf[i]);
8313 if ((buf[i] & 0x80) == 0)
8314 break;
8315 }
4082ef84
NC		 8316 if (i == sizeof (buf))
8317 printf (_("corrupt change to vsp"));
8318 else
8319 {
8320 offset = read_uleb128 (buf, &len, buf + i + 1);
8321 assert (len == i + 1);
8322 offset = offset * 4 + 0x204;
8323 printf ("vsp = vsp + %ld", offset);
8324 }
0b6ae522 8325 }
61865e30 8326 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 8327 {
61865e30
NC		 8328 unsigned int first, last;
8329
8330 GET_OP (op2);
8331 first = op2 >> 4;
8332 last = op2 & 0x0f;
8333 if (op == 0xc8)
8334 first = first + 16;
8335 printf ("pop {D%d", first);
8336 if (last)
8337 printf ("-D%d", first + last);
8338 printf ("}");
8339 }
8340 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8341 {
8342 unsigned int count = op & 0x07;
8343
8344 printf ("pop {D8");
8345 if (count)
8346 printf ("-D%d", 8 + count);
8347 printf ("}");
8348 }
8349 else if (op >= 0xc0 && op <= 0xc5)
8350 {
8351 unsigned int count = op & 0x07;
8352
8353 printf (" pop {wR10");
8354 if (count)
8355 printf ("-wR%d", 10 + count);
8356 printf ("}");
8357 }
8358 else if (op == 0xc6)
8359 {
8360 unsigned int first, last;
8361
8362 GET_OP (op2);
8363 first = op2 >> 4;
8364 last = op2 & 0x0f;
8365 printf ("pop {wR%d", first);
8366 if (last)
8367 printf ("-wR%d", first + last);
8368 printf ("}");
8369 }
8370 else if (op == 0xc7)
8371 {
8372 GET_OP (op2);
8373 if (op2 == 0 || (op2 & 0xf0) != 0)
8374 printf (_("[Spare]"));
0b6ae522
DJ		 8375 else
8376 {
61865e30
NC		 8377 unsigned int mask = op2 & 0x0f;
8378 int first = 1;
8379 int i;
8380
8381 printf ("pop {");
8382 for (i = 0; i < 4; i++)
8383 if (mask & (1 << i))
8384 {
8385 if (first)
8386 first = 0;
8387 else
8388 printf (", ");
8389 printf ("wCGR%d", i);
8390 }
8391 printf ("}");
0b6ae522
DJ		 8392 }
8393 }
61865e30
NC		 8394 else
8395 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 8396 printf ("\n");
8397 }
fa197c1c
PB		 8398}
8399
8400static void
948f632f
DA		 8401decode_tic6x_unwind_bytecode (struct arm_unw_aux_info * aux,
8402 unsigned int word,
8403 unsigned int remaining,
8404 unsigned int more_words,
8405 bfd_vma data_offset,
8406 Elf_Internal_Shdr * data_sec,
8407 struct arm_section * data_arm_sec)
fa197c1c
PB		 8408{
8409 struct absaddr addr;
8410
8411 /* Decode the unwinding instructions. */
8412 while (1)
8413 {
8414 unsigned int op, op2;
8415
8416 ADVANCE;
8417 if (remaining == 0)
8418 break;
8419 remaining--;
8420 op = word >> 24;
8421 word <<= 8;
8422
9cf03b7e 8423 printf (" 0x%02x ", op);
fa197c1c
PB		 8424
8425 if ((op & 0xc0) == 0x00)
8426 {
8427 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 8428 printf (" sp = sp + %d", offset);
fa197c1c
PB		 8429 }
8430 else if ((op & 0xc0) == 0x80)
8431 {
8432 GET_OP (op2);
8433 if (op == 0x80 && op2 == 0)
8434 printf (_("Refuse to unwind"));
8435 else
8436 {
8437 unsigned int mask = ((op & 0x1f) << 8) | op2;
8438 if (op & 0x20)
8439 printf ("pop compact {");
8440 else
8441 printf ("pop {");
8442
8443 decode_tic6x_unwind_regmask (mask);
8444 printf("}");
8445 }
8446 }
8447 else if ((op & 0xf0) == 0xc0)
8448 {
8449 unsigned int reg;
8450 unsigned int nregs;
8451 unsigned int i;
8452 const char *name;
a734115a
NC		 8453 struct
8454 {
fa197c1c
PB		 8455 unsigned int offset;
8456 unsigned int reg;
8457 } regpos[16];
8458
8459 /* Scan entire instruction first so that GET_OP output is not
8460 interleaved with disassembly. */
8461 nregs = 0;
8462 for (i = 0; nregs < (op & 0xf); i++)
8463 {
8464 GET_OP (op2);
8465 reg = op2 >> 4;
8466 if (reg != 0xf)
8467 {
8468 regpos[nregs].offset = i * 2;
8469 regpos[nregs].reg = reg;
8470 nregs++;
8471 }
8472
8473 reg = op2 & 0xf;
8474 if (reg != 0xf)
8475 {
8476 regpos[nregs].offset = i * 2 + 1;
8477 regpos[nregs].reg = reg;
8478 nregs++;
8479 }
8480 }
8481
8482 printf (_("pop frame {"));
8483 reg = nregs - 1;
8484 for (i = i * 2; i > 0; i--)
8485 {
8486 if (regpos[reg].offset == i - 1)
8487 {
8488 name = tic6x_unwind_regnames[regpos[reg].reg];
8489 if (reg > 0)
8490 reg--;
8491 }
8492 else
8493 name = _("[pad]");
8494
8495 fputs (name, stdout);
8496 if (i > 1)
8497 printf (", ");
8498 }
8499
8500 printf ("}");
8501 }
8502 else if (op == 0xd0)
8503 printf (" MOV FP, SP");
8504 else if (op == 0xd1)
8505 printf (" __c6xabi_pop_rts");
8506 else if (op == 0xd2)
8507 {
8508 unsigned char buf[9];
8509 unsigned int i, len;
8510 unsigned long offset;
a734115a 8511
fa197c1c
PB		 8512 for (i = 0; i < sizeof (buf); i++)
8513 {
8514 GET_OP (buf[i]);
8515 if ((buf[i] & 0x80) == 0)
8516 break;
8517 }
0eff7165
NC		 8518 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8519 if (i == sizeof (buf))
8520 {
8521 printf ("<corrupt sp adjust>\n");
8522 warn (_("Corrupt stack pointer adjustment detected\n"));
8523 return;
8524 }
948f632f 8525
f6f0e17b 8526 offset = read_uleb128 (buf, &len, buf + i + 1);
fa197c1c
PB		 8527 assert (len == i + 1);
8528 offset = offset * 8 + 0x408;
8529 printf (_("sp = sp + %ld"), offset);
8530 }
8531 else if ((op & 0xf0) == 0xe0)
8532 {
8533 if ((op & 0x0f) == 7)
8534 printf (" RETURN");
8535 else
8536 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8537 }
8538 else
8539 {
8540 printf (_(" [unsupported opcode]"));
8541 }
8542 putchar ('\n');
8543 }
8544}
8545
8546static bfd_vma
a734115a 8547arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 8548{
8549 bfd_vma offset;
8550
8551 offset = word & 0x7fffffff;
8552 if (offset & 0x40000000)
8553 offset |= ~ (bfd_vma) 0x7fffffff;
8554
8555 if (elf_header.e_machine == EM_TI_C6000)
8556 offset <<= 1;
8557
8558 return offset + where;
8559}
8560
8561static void
1b31d05e
NC		 8562decode_arm_unwind (struct arm_unw_aux_info * aux,
8563 unsigned int word,
8564 unsigned int remaining,
8565 bfd_vma data_offset,
8566 Elf_Internal_Shdr * data_sec,
8567 struct arm_section * data_arm_sec)
fa197c1c
PB		 8568{
8569 int per_index;
8570 unsigned int more_words = 0;
37e14bc3 8571 struct absaddr addr;
1b31d05e 8572 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 8573
8574 if (remaining == 0)
8575 {
1b31d05e
NC		 8576 /* Fetch the first word.
8577 Note - when decoding an object file the address extracted
8578 here will always be 0. So we also pass in the sym_name
8579 parameter so that we can find the symbol associated with
8580 the personality routine. */
8581 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8582 & word, & addr, & sym_name))
fa197c1c 8583 return;
1b31d05e 8584
fa197c1c
PB		 8585 remaining = 4;
8586 }
8587
8588 if ((word & 0x80000000) == 0)
8589 {
8590 /* Expand prel31 for personality routine. */
8591 bfd_vma fn;
8592 const char *procname;
8593
a734115a 8594 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 8595 printf (_(" Personality routine: "));
1b31d05e
NC		 8596 if (fn == 0
8597 && addr.section == SHN_UNDEF && addr.offset == 0
8598 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8599 {
8600 procname = aux->strtab + sym_name;
8601 print_vma (fn, PREFIX_HEX);
8602 if (procname)
8603 {
8604 fputs (" <", stdout);
8605 fputs (procname, stdout);
8606 fputc ('>', stdout);
8607 }
8608 }
8609 else
8610 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 8611 fputc ('\n', stdout);
8612
8613 /* The GCC personality routines use the standard compact
8614 encoding, starting with one byte giving the number of
8615 words. */
8616 if (procname != NULL
8617 && (const_strneq (procname, "__gcc_personality_v0")
8618 || const_strneq (procname, "__gxx_personality_v0")
8619 || const_strneq (procname, "__gcj_personality_v0")
8620 || const_strneq (procname, "__gnu_objc_personality_v0")))
8621 {
8622 remaining = 0;
8623 more_words = 1;
8624 ADVANCE;
8625 if (!remaining)
8626 {
8627 printf (_(" [Truncated data]\n"));
8628 return;
8629 }
8630 more_words = word >> 24;
8631 word <<= 8;
8632 remaining--;
8633 per_index = -1;
8634 }
8635 else
8636 return;
8637 }
8638 else
8639 {
1b31d05e 8640 /* ARM EHABI Section 6.3:
0b4362b0 8641
1b31d05e 8642 An exception-handling table entry for the compact model looks like:
0b4362b0 8643
1b31d05e
NC		 8644 31 30-28 27-24 23-0
8645 -- ----- ----- ----
8646 1 0 index Data for personalityRoutine[index] */
8647
8648 if (elf_header.e_machine == EM_ARM
8649 && (word & 0x70000000))
83c257ca 8650 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 8651
fa197c1c 8652 per_index = (word >> 24) & 0x7f;
1b31d05e 8653 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 8654 if (per_index == 0)
8655 {
8656 more_words = 0;
8657 word <<= 8;
8658 remaining--;
8659 }
8660 else if (per_index < 3)
8661 {
8662 more_words = (word >> 16) & 0xff;
8663 word <<= 16;
8664 remaining -= 2;
8665 }
8666 }
8667
8668 switch (elf_header.e_machine)
8669 {
8670 case EM_ARM:
8671 if (per_index < 3)
8672 {
8673 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8674 data_offset, data_sec, data_arm_sec);
8675 }
8676 else
1b31d05e
NC		 8677 {
8678 warn (_("Unknown ARM compact model index encountered\n"));
8679 printf (_(" [reserved]\n"));
8680 }
fa197c1c
PB		 8681 break;
8682
8683 case EM_TI_C6000:
8684 if (per_index < 3)
8685 {
8686 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 8687 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 8688 }
8689 else if (per_index < 5)
8690 {
8691 if (((word >> 17) & 0x7f) == 0x7f)
8692 printf (_(" Restore stack from frame pointer\n"));
8693 else
8694 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
8695 printf (_(" Registers restored: "));
8696 if (per_index == 4)
8697 printf (" (compact) ");
8698 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8699 putchar ('\n');
8700 printf (_(" Return register: %s\n"),
8701 tic6x_unwind_regnames[word & 0xf]);
8702 }
8703 else
1b31d05e 8704 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 8705 break;
8706
8707 default:
74e1a04b 8708 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
1b31d05e 8709 elf_header.e_machine);
fa197c1c 8710 }
0b6ae522
DJ		 8711
8712 /* Decode the descriptors. Not implemented. */
8713}
8714
8715static void
8716dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8717{
8718 struct arm_section exidx_arm_sec, extab_arm_sec;
8719 unsigned int i, exidx_len;
948f632f 8720 unsigned long j, nfuns;
0b6ae522
DJ		 8721
8722 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8723 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8724 exidx_len = exidx_sec->sh_size / 8;
8725
948f632f
DA		 8726 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8727 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8728 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8729 aux->funtab[nfuns++] = aux->symtab[j];
8730 aux->nfuns = nfuns;
8731 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8732
0b6ae522
DJ		 8733 for (i = 0; i < exidx_len; i++)
8734 {
8735 unsigned int exidx_fn, exidx_entry;
8736 struct absaddr fn_addr, entry_addr;
8737 bfd_vma fn;
8738
8739 fputc ('\n', stdout);
8740
1b31d05e
NC		 8741 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8742 8 * i, & exidx_fn, & fn_addr, NULL)
8743 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8744 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 8745 {
948f632f 8746 free (aux->funtab);
1b31d05e
NC		 8747 arm_free_section (& exidx_arm_sec);
8748 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 8749 return;
8750 }
8751
83c257ca
NC		 8752 /* ARM EHABI, Section 5:
8753 An index table entry consists of 2 words.
8754 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8755 if (exidx_fn & 0x80000000)
8756 warn (_("corrupt index table entry: %x\n"), exidx_fn);
8757
a734115a 8758 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 8759
a734115a 8760 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 8761 fputs (": ", stdout);
8762
8763 if (exidx_entry == 1)
8764 {
8765 print_vma (exidx_entry, PREFIX_HEX);
8766 fputs (" [cantunwind]\n", stdout);
8767 }
8768 else if (exidx_entry & 0x80000000)
8769 {
8770 print_vma (exidx_entry, PREFIX_HEX);
8771 fputc ('\n', stdout);
8772 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8773 }
8774 else
8775 {
8f73510c 8776 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 8777 Elf_Internal_Shdr *table_sec;
8778
8779 fputs ("@", stdout);
a734115a 8780 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 8781 print_vma (table, PREFIX_HEX);
8782 printf ("\n");
8783
8784 /* Locate the matching .ARM.extab. */
8785 if (entry_addr.section != SHN_UNDEF
8786 && entry_addr.section < elf_header.e_shnum)
8787 {
8788 table_sec = section_headers + entry_addr.section;
8789 table_offset = entry_addr.offset;
1a915552
NC		 8790 /* PR 18879 */
8791 if (table_offset > table_sec->sh_size
8792 || ((bfd_signed_vma) table_offset) < 0)
8793 {
8794 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8795 (unsigned long) table_offset,
8796 printable_section_name (table_sec));
8797 continue;
8798 }
0b6ae522
DJ		 8799 }
8800 else
8801 {
8802 table_sec = find_section_by_address (table);
8803 if (table_sec != NULL)
8804 table_offset = table - table_sec->sh_addr;
8805 }
8806 if (table_sec == NULL)
8807 {
8808 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8809 (unsigned long) table);
8810 continue;
8811 }
8812 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8813 &extab_arm_sec);
8814 }
8815 }
8816
8817 printf ("\n");
8818
948f632f 8819 free (aux->funtab);
0b6ae522
DJ		 8820 arm_free_section (&exidx_arm_sec);
8821 arm_free_section (&extab_arm_sec);
8822}
8823
fa197c1c 8824/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 8825
8826static void
0b6ae522
DJ		 8827arm_process_unwind (FILE *file)
8828{
8829 struct arm_unw_aux_info aux;
8830 Elf_Internal_Shdr *unwsec = NULL;
8831 Elf_Internal_Shdr *strsec;
8832 Elf_Internal_Shdr *sec;
8833 unsigned long i;
fa197c1c 8834 unsigned int sec_type;
0b6ae522 8835
fa197c1c
PB		 8836 switch (elf_header.e_machine)
8837 {
8838 case EM_ARM:
8839 sec_type = SHT_ARM_EXIDX;
8840 break;
8841
8842 case EM_TI_C6000:
8843 sec_type = SHT_C6000_UNWIND;
8844 break;
8845
0b4362b0 8846 default:
74e1a04b 8847 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
1b31d05e
NC		 8848 elf_header.e_machine);
8849 return;
fa197c1c
PB		 8850 }
8851
0b6ae522 8852 if (string_table == NULL)
1b31d05e
NC		 8853 return;
8854
8855 memset (& aux, 0, sizeof (aux));
8856 aux.file = file;
0b6ae522
DJ		 8857
8858 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8859 {
8860 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8861 {
ba5cdace 8862 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 8863
8864 strsec = section_headers + sec->sh_link;
74e1a04b
NC		 8865
8866 /* PR binutils/17531 file: 011-12666-0.004. */
8867 if (aux.strtab != NULL)
8868 {
4082ef84 8869 error (_("Multiple string tables found in file.\n"));
74e1a04b
NC		 8870 free (aux.strtab);
8871 }
0b6ae522
DJ		 8872 aux.strtab = get_data (NULL, file, strsec->sh_offset,
8873 1, strsec->sh_size, _("string table"));
8874 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8875 }
fa197c1c 8876 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 8877 unwsec = sec;
8878 }
8879
1b31d05e 8880 if (unwsec == NULL)
0b6ae522 8881 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 8882 else
8883 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8884 {
8885 if (sec->sh_type == sec_type)
8886 {
8887 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
74e1a04b 8888 printable_section_name (sec),
1b31d05e
NC		 8889 (unsigned long) sec->sh_offset,
8890 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 8891
1b31d05e
NC		 8892 dump_arm_unwind (&aux, sec);
8893 }
8894 }
0b6ae522
DJ		 8895
8896 if (aux.symtab)
8897 free (aux.symtab);
8898 if (aux.strtab)
8899 free ((char *) aux.strtab);
0b6ae522
DJ		 8900}
8901
1b31d05e 8902static void
2cf0635d 8903process_unwind (FILE * file)
57346661 8904{
2cf0635d
NC		 8905 struct unwind_handler
8906 {
57346661 8907 int machtype;
1b31d05e 8908 void (* handler)(FILE *);
2cf0635d
NC		 8909 } handlers[] =
8910 {
0b6ae522 8911 { EM_ARM, arm_process_unwind },
57346661
AM		 8912 { EM_IA_64, ia64_process_unwind },
8913 { EM_PARISC, hppa_process_unwind },
fa197c1c 8914 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 8915 { 0, 0 }
8916 };
8917 int i;
8918
8919 if (!do_unwind)
1b31d05e 8920 return;
57346661
AM		 8921
8922 for (i = 0; handlers[i].handler != NULL; i++)
8923 if (elf_header.e_machine == handlers[i].machtype)
9f758fdc
NC		 8924 {
8925 handlers[i].handler (file);
8926 return;
8927 }
57346661 8928
1b31d05e
NC		 8929 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8930 get_machine_name (elf_header.e_machine));
57346661
AM		 8931}
8932
252b5132 8933static void
2cf0635d 8934dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 8935{
8936 switch (entry->d_tag)
8937 {
8938 case DT_MIPS_FLAGS:
8939 if (entry->d_un.d_val == 0)
4b68bca3 8940 printf (_("NONE"));
252b5132
RH		 8941 else
8942 {
8943 static const char * opts[] =
8944 {
8945 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8946 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8947 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8948 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8949 "RLD_ORDER_SAFE"
8950 };
8951 unsigned int cnt;
8952 int first = 1;
2b692964 8953
60bca95a 8954 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 8955 if (entry->d_un.d_val & (1 << cnt))
8956 {
8957 printf ("%s%s", first ? "" : " ", opts[cnt]);
8958 first = 0;
8959 }
252b5132
RH		 8960 }
8961 break;
103f02d3 8962
252b5132 8963 case DT_MIPS_IVERSION:
d79b3d50 8964 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 8965 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8966 else
76ca31c0
NC		 8967 {
8968 char buf[40];
8969 sprintf_vma (buf, entry->d_un.d_ptr);
8970 /* Note: coded this way so that there is a single string for translation. */
8971 printf (_("<corrupt: %s>"), buf);
8972 }
252b5132 8973 break;
103f02d3 8974
252b5132
RH		 8975 case DT_MIPS_TIME_STAMP:
8976 {
d5b07ef4 8977 char timebuf[128];
2cf0635d 8978 struct tm * tmp;
91d6fa6a 8979 time_t atime = entry->d_un.d_val;
82b1b41b 8980
91d6fa6a 8981 tmp = gmtime (&atime);
82b1b41b
NC		 8982 /* PR 17531: file: 6accc532. */
8983 if (tmp == NULL)
8984 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8985 else
8986 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8987 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8988 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 8989 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 8990 }
8991 break;
103f02d3 8992
252b5132
RH		 8993 case DT_MIPS_RLD_VERSION:
8994 case DT_MIPS_LOCAL_GOTNO:
8995 case DT_MIPS_CONFLICTNO:
8996 case DT_MIPS_LIBLISTNO:
8997 case DT_MIPS_SYMTABNO:
8998 case DT_MIPS_UNREFEXTNO:
8999 case DT_MIPS_HIPAGENO:
9000 case DT_MIPS_DELTA_CLASS_NO:
9001 case DT_MIPS_DELTA_INSTANCE_NO:
9002 case DT_MIPS_DELTA_RELOC_NO:
9003 case DT_MIPS_DELTA_SYM_NO:
9004 case DT_MIPS_DELTA_CLASSSYM_NO:
9005 case DT_MIPS_COMPACT_SIZE:
c69075ac 9006 print_vma (entry->d_un.d_val, DEC);
252b5132 9007 break;
103f02d3
UD		 9008
9009 default:
4b68bca3 9010 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 9011 }
4b68bca3 9012 putchar ('\n');
103f02d3
UD		 9013}
9014
103f02d3 9015static void
2cf0635d 9016dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 9017{
9018 switch (entry->d_tag)
9019 {
9020 case DT_HP_DLD_FLAGS:
9021 {
9022 static struct
9023 {
9024 long int bit;
2cf0635d 9025 const char * str;
5e220199
NC		 9026 }
9027 flags[] =
9028 {
9029 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9030 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9031 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9032 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9033 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9034 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9035 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9036 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9037 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9038 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 9039 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9040 { DT_HP_GST, "HP_GST" },
9041 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9042 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9043 { DT_HP_NODELETE, "HP_NODELETE" },
9044 { DT_HP_GROUP, "HP_GROUP" },
9045 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 9046 };
103f02d3 9047 int first = 1;
5e220199 9048 size_t cnt;
f7a99963 9049 bfd_vma val = entry->d_un.d_val;
103f02d3 9050
60bca95a 9051 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 9052 if (val & flags[cnt].bit)
30800947
NC		 9053 {
9054 if (! first)
9055 putchar (' ');
9056 fputs (flags[cnt].str, stdout);
9057 first = 0;
9058 val ^= flags[cnt].bit;
9059 }
76da6bbe 9060
103f02d3 9061 if (val != 0 || first)
f7a99963
NC		 9062 {
9063 if (! first)
9064 putchar (' ');
9065 print_vma (val, HEX);
9066 }
103f02d3
UD		 9067 }
9068 break;
76da6bbe 9069
252b5132 9070 default:
f7a99963
NC		 9071 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9072 break;
252b5132 9073 }
35b1837e 9074 putchar ('\n');
252b5132
RH		 9075}
9076
28f997cf
TG		 9077#ifdef BFD64
9078
9079/* VMS vs Unix time offset and factor. */
9080
9081#define VMS_EPOCH_OFFSET 35067168000000000LL
9082#define VMS_GRANULARITY_FACTOR 10000000
9083
9084/* Display a VMS time in a human readable format. */
9085
9086static void
9087print_vms_time (bfd_int64_t vmstime)
9088{
9089 struct tm *tm;
9090 time_t unxtime;
9091
9092 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9093 tm = gmtime (&unxtime);
9094 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9095 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9096 tm->tm_hour, tm->tm_min, tm->tm_sec);
9097}
9098#endif /* BFD64 */
9099
ecc51f48 9100static void
2cf0635d 9101dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 9102{
9103 switch (entry->d_tag)
9104 {
0de14b54 9105 case DT_IA_64_PLT_RESERVE:
bdf4d63a 9106 /* First 3 slots reserved. */
ecc51f48
NC		 9107 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9108 printf (" -- ");
9109 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 9110 break;
9111
28f997cf
TG		 9112 case DT_IA_64_VMS_LINKTIME:
9113#ifdef BFD64
9114 print_vms_time (entry->d_un.d_val);
9115#endif
9116 break;
9117
9118 case DT_IA_64_VMS_LNKFLAGS:
9119 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9120 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9121 printf (" CALL_DEBUG");
9122 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9123 printf (" NOP0BUFS");
9124 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9125 printf (" P0IMAGE");
9126 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9127 printf (" MKTHREADS");
9128 if (entry->d_un.d_val & VMS_LF_UPCALLS)
9129 printf (" UPCALLS");
9130 if (entry->d_un.d_val & VMS_LF_IMGSTA)
9131 printf (" IMGSTA");
9132 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9133 printf (" INITIALIZE");
9134 if (entry->d_un.d_val & VMS_LF_MAIN)
9135 printf (" MAIN");
9136 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9137 printf (" EXE_INIT");
9138 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9139 printf (" TBK_IN_IMG");
9140 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9141 printf (" DBG_IN_IMG");
9142 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9143 printf (" TBK_IN_DSF");
9144 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9145 printf (" DBG_IN_DSF");
9146 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9147 printf (" SIGNATURES");
9148 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9149 printf (" REL_SEG_OFF");
9150 break;
9151
bdf4d63a
JJ		 9152 default:
9153 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9154 break;
ecc51f48 9155 }
bdf4d63a 9156 putchar ('\n');
ecc51f48
NC		 9157}
9158
252b5132 9159static int
2cf0635d 9160get_32bit_dynamic_section (FILE * file)
252b5132 9161{
2cf0635d
NC		 9162 Elf32_External_Dyn * edyn;
9163 Elf32_External_Dyn * ext;
9164 Elf_Internal_Dyn * entry;
103f02d3 9165
3f5e193b
NC		 9166 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
9167 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 9168 if (!edyn)
9169 return 0;
103f02d3 9170
071436c6
NC		 9171 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9172 might not have the luxury of section headers. Look for the DT_NULL
9173 terminator to determine the number of entries. */
ba2685cc 9174 for (ext = edyn, dynamic_nent = 0;
53c3012c 9175 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
ba2685cc
AM		 9176 ext++)
9177 {
9178 dynamic_nent++;
9179 if (BYTE_GET (ext->d_tag) == DT_NULL)
9180 break;
9181 }
252b5132 9182
3f5e193b
NC		 9183 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9184 sizeof (* entry));
b2d38a17 9185 if (dynamic_section == NULL)
252b5132 9186 {
8b73c356
NC		 9187 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9188 (unsigned long) dynamic_nent);
9ea033b2
NC		 9189 free (edyn);
9190 return 0;
9191 }
252b5132 9192
fb514b26 9193 for (ext = edyn, entry = dynamic_section;
ba2685cc 9194 entry < dynamic_section + dynamic_nent;
fb514b26 9195 ext++, entry++)
9ea033b2 9196 {
fb514b26
AM		 9197 entry->d_tag = BYTE_GET (ext->d_tag);
9198 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 9199 }
9200
9ea033b2
NC		 9201 free (edyn);
9202
9203 return 1;
9204}
9205
9206static int
2cf0635d 9207get_64bit_dynamic_section (FILE * file)
9ea033b2 9208{
2cf0635d
NC		 9209 Elf64_External_Dyn * edyn;
9210 Elf64_External_Dyn * ext;
9211 Elf_Internal_Dyn * entry;
103f02d3 9212
071436c6 9213 /* Read in the data. */
3f5e193b
NC		 9214 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
9215 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 9216 if (!edyn)
9217 return 0;
103f02d3 9218
071436c6
NC		 9219 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9220 might not have the luxury of section headers. Look for the DT_NULL
9221 terminator to determine the number of entries. */
ba2685cc 9222 for (ext = edyn, dynamic_nent = 0;
53c3012c
AM		 9223 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9224 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
ba2685cc
AM		 9225 ext++)
9226 {
9227 dynamic_nent++;
66543521 9228 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 9229 break;
9230 }
252b5132 9231
3f5e193b
NC		 9232 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9233 sizeof (* entry));
b2d38a17 9234 if (dynamic_section == NULL)
252b5132 9235 {
8b73c356
NC		 9236 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9237 (unsigned long) dynamic_nent);
252b5132
RH		 9238 free (edyn);
9239 return 0;
9240 }
9241
071436c6 9242 /* Convert from external to internal formats. */
fb514b26 9243 for (ext = edyn, entry = dynamic_section;
ba2685cc 9244 entry < dynamic_section + dynamic_nent;
fb514b26 9245 ext++, entry++)
252b5132 9246 {
66543521
AM		 9247 entry->d_tag = BYTE_GET (ext->d_tag);
9248 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 9249 }
9250
9251 free (edyn);
9252
9ea033b2
NC		 9253 return 1;
9254}
9255
e9e44622
JJ		 9256static void
9257print_dynamic_flags (bfd_vma flags)
d1133906 9258{
e9e44622 9259 int first = 1;
13ae64f3 9260
d1133906
NC		 9261 while (flags)
9262 {
9263 bfd_vma flag;
9264
9265 flag = flags & - flags;
9266 flags &= ~ flag;
9267
e9e44622
JJ		 9268 if (first)
9269 first = 0;
9270 else
9271 putc (' ', stdout);
13ae64f3 9272
d1133906
NC		 9273 switch (flag)
9274 {
e9e44622
JJ		 9275 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
9276 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
9277 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
9278 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
9279 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 9280 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 9281 }
9282 }
e9e44622 9283 puts ("");
d1133906
NC		 9284}
9285
b2d38a17
NC		 9286/* Parse and display the contents of the dynamic section. */
9287
9ea033b2 9288static int
2cf0635d 9289process_dynamic_section (FILE * file)
9ea033b2 9290{
2cf0635d 9291 Elf_Internal_Dyn * entry;
9ea033b2
NC		 9292
9293 if (dynamic_size == 0)
9294 {
9295 if (do_dynamic)
b2d38a17 9296 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 9297
9298 return 1;
9299 }
9300
9301 if (is_32bit_elf)
9302 {
b2d38a17 9303 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 9304 return 0;
9305 }
b2d38a17 9306 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 9307 return 0;
9308
252b5132
RH		 9309 /* Find the appropriate symbol table. */
9310 if (dynamic_symbols == NULL)
9311 {
86dba8ee
AM		 9312 for (entry = dynamic_section;
9313 entry < dynamic_section + dynamic_nent;
9314 ++entry)
252b5132 9315 {
c8286bd1 9316 Elf_Internal_Shdr section;
252b5132
RH		 9317
9318 if (entry->d_tag != DT_SYMTAB)
9319 continue;
9320
9321 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9322
9323 /* Since we do not know how big the symbol table is,
9324 we default to reading in the entire file (!) and
9325 processing that. This is overkill, I know, but it
e3c8793a 9326 should work. */
d93f0186 9327 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 9328
fb52b2f4
NC		 9329 if (archive_file_offset != 0)
9330 section.sh_size = archive_file_size - section.sh_offset;
9331 else
9332 {
9333 if (fseek (file, 0, SEEK_END))
591a748a 9334 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 9335
9336 section.sh_size = ftell (file) - section.sh_offset;
9337 }
252b5132 9338
9ea033b2 9339 if (is_32bit_elf)
9ad5cbcf 9340 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 9341 else
9ad5cbcf 9342 section.sh_entsize = sizeof (Elf64_External_Sym);
071436c6 9343 section.sh_name = string_table_length;
252b5132 9344
ba5cdace 9345 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 9346 if (num_dynamic_syms < 1)
252b5132
RH		 9347 {
9348 error (_("Unable to determine the number of symbols to load\n"));
9349 continue;
9350 }
252b5132
RH		 9351 }
9352 }
9353
9354 /* Similarly find a string table. */
9355 if (dynamic_strings == NULL)
9356 {
86dba8ee
AM		 9357 for (entry = dynamic_section;
9358 entry < dynamic_section + dynamic_nent;
9359 ++entry)
252b5132
RH		 9360 {
9361 unsigned long offset;
b34976b6 9362 long str_tab_len;
252b5132
RH		 9363
9364 if (entry->d_tag != DT_STRTAB)
9365 continue;
9366
9367 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9368
9369 /* Since we do not know how big the string table is,
9370 we default to reading in the entire file (!) and
9371 processing that. This is overkill, I know, but it
e3c8793a 9372 should work. */
252b5132 9373
d93f0186 9374 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 9375
9376 if (archive_file_offset != 0)
9377 str_tab_len = archive_file_size - offset;
9378 else
9379 {
9380 if (fseek (file, 0, SEEK_END))
9381 error (_("Unable to seek to end of file\n"));
9382 str_tab_len = ftell (file) - offset;
9383 }
252b5132
RH		 9384
9385 if (str_tab_len < 1)
9386 {
9387 error
9388 (_("Unable to determine the length of the dynamic string table\n"));
9389 continue;
9390 }
9391
3f5e193b
NC		 9392 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
9393 str_tab_len,
9394 _("dynamic string table"));
59245841 9395 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 9396 break;
9397 }
9398 }
9399
9400 /* And find the syminfo section if available. */
9401 if (dynamic_syminfo == NULL)
9402 {
3e8bba36 9403 unsigned long syminsz = 0;
252b5132 9404
86dba8ee
AM		 9405 for (entry = dynamic_section;
9406 entry < dynamic_section + dynamic_nent;
9407 ++entry)
252b5132
RH		 9408 {
9409 if (entry->d_tag == DT_SYMINENT)
9410 {
9411 /* Note: these braces are necessary to avoid a syntax
9412 error from the SunOS4 C compiler. */
049b0c3a
NC		 9413 /* PR binutils/17531: A corrupt file can trigger this test.
9414 So do not use an assert, instead generate an error message. */
9415 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
071436c6 9416 error (_("Bad value (%d) for SYMINENT entry\n"),
049b0c3a 9417 (int) entry->d_un.d_val);
252b5132
RH		 9418 }
9419 else if (entry->d_tag == DT_SYMINSZ)
9420 syminsz = entry->d_un.d_val;
9421 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 9422 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
9423 syminsz);
252b5132
RH		 9424 }
9425
9426 if (dynamic_syminfo_offset != 0 && syminsz != 0)
9427 {
2cf0635d
NC		 9428 Elf_External_Syminfo * extsyminfo;
9429 Elf_External_Syminfo * extsym;
9430 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 9431
9432 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 9433 extsyminfo = (Elf_External_Syminfo *)
9434 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
9435 _("symbol information"));
a6e9f9df
AM		 9436 if (!extsyminfo)
9437 return 0;
252b5132 9438
3f5e193b 9439 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 9440 if (dynamic_syminfo == NULL)
9441 {
8b73c356
NC		 9442 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9443 (unsigned long) syminsz);
252b5132
RH		 9444 return 0;
9445 }
9446
9447 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 9448 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9449 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9450 ++syminfo, ++extsym)
252b5132 9451 {
86dba8ee
AM		 9452 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9453 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 9454 }
9455
9456 free (extsyminfo);
9457 }
9458 }
9459
9460 if (do_dynamic && dynamic_addr)
8b73c356
NC		 9461 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9462 dynamic_addr, (unsigned long) dynamic_nent);
252b5132
RH		 9463 if (do_dynamic)
9464 printf (_(" Tag Type Name/Value\n"));
9465
86dba8ee
AM		 9466 for (entry = dynamic_section;
9467 entry < dynamic_section + dynamic_nent;
9468 entry++)
252b5132
RH		 9469 {
9470 if (do_dynamic)
f7a99963 9471 {
2cf0635d 9472 const char * dtype;
e699b9ff 9473
f7a99963
NC		 9474 putchar (' ');
9475 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 9476 dtype = get_dynamic_type (entry->d_tag);
9477 printf (" (%s)%*s", dtype,
9478 ((is_32bit_elf ? 27 : 19)
9479 - (int) strlen (dtype)),
f7a99963
NC		 9480 " ");
9481 }
252b5132
RH		 9482
9483 switch (entry->d_tag)
9484 {
d1133906
NC		 9485 case DT_FLAGS:
9486 if (do_dynamic)
e9e44622 9487 print_dynamic_flags (entry->d_un.d_val);
d1133906 9488 break;
76da6bbe 9489
252b5132
RH		 9490 case DT_AUXILIARY:
9491 case DT_FILTER:
019148e4
L		 9492 case DT_CONFIG:
9493 case DT_DEPAUDIT:
9494 case DT_AUDIT:
252b5132
RH		 9495 if (do_dynamic)
9496 {
019148e4 9497 switch (entry->d_tag)
b34976b6 9498 {
019148e4
L		 9499 case DT_AUXILIARY:
9500 printf (_("Auxiliary library"));
9501 break;
9502
9503 case DT_FILTER:
9504 printf (_("Filter library"));
9505 break;
9506
b34976b6 9507 case DT_CONFIG:
019148e4
L		 9508 printf (_("Configuration file"));
9509 break;
9510
9511 case DT_DEPAUDIT:
9512 printf (_("Dependency audit library"));
9513 break;
9514
9515 case DT_AUDIT:
9516 printf (_("Audit library"));
9517 break;
9518 }
252b5132 9519
d79b3d50
NC		 9520 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9521 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 9522 else
f7a99963
NC		 9523 {
9524 printf (": ");
9525 print_vma (entry->d_un.d_val, PREFIX_HEX);
9526 putchar ('\n');
9527 }
252b5132
RH		 9528 }
9529 break;
9530
dcefbbbd 9531 case DT_FEATURE:
252b5132
RH		 9532 if (do_dynamic)
9533 {
9534 printf (_("Flags:"));
86f55779 9535
252b5132
RH		 9536 if (entry->d_un.d_val == 0)
9537 printf (_(" None\n"));
9538 else
9539 {
9540 unsigned long int val = entry->d_un.d_val;
86f55779 9541
252b5132
RH		 9542 if (val & DTF_1_PARINIT)
9543 {
9544 printf (" PARINIT");
9545 val ^= DTF_1_PARINIT;
9546 }
dcefbbbd
L		 9547 if (val & DTF_1_CONFEXP)
9548 {
9549 printf (" CONFEXP");
9550 val ^= DTF_1_CONFEXP;
9551 }
252b5132
RH		 9552 if (val != 0)
9553 printf (" %lx", val);
9554 puts ("");
9555 }
9556 }
9557 break;
9558
9559 case DT_POSFLAG_1:
9560 if (do_dynamic)
9561 {
9562 printf (_("Flags:"));
86f55779 9563
252b5132
RH		 9564 if (entry->d_un.d_val == 0)
9565 printf (_(" None\n"));
9566 else
9567 {
9568 unsigned long int val = entry->d_un.d_val;
86f55779 9569
252b5132
RH		 9570 if (val & DF_P1_LAZYLOAD)
9571 {
9572 printf (" LAZYLOAD");
9573 val ^= DF_P1_LAZYLOAD;
9574 }
9575 if (val & DF_P1_GROUPPERM)
9576 {
9577 printf (" GROUPPERM");
9578 val ^= DF_P1_GROUPPERM;
9579 }
9580 if (val != 0)
9581 printf (" %lx", val);
9582 puts ("");
9583 }
9584 }
9585 break;
9586
9587 case DT_FLAGS_1:
9588 if (do_dynamic)
9589 {
9590 printf (_("Flags:"));
9591 if (entry->d_un.d_val == 0)
9592 printf (_(" None\n"));
9593 else
9594 {
9595 unsigned long int val = entry->d_un.d_val;
86f55779 9596
252b5132
RH		 9597 if (val & DF_1_NOW)
9598 {
9599 printf (" NOW");
9600 val ^= DF_1_NOW;
9601 }
9602 if (val & DF_1_GLOBAL)
9603 {
9604 printf (" GLOBAL");
9605 val ^= DF_1_GLOBAL;
9606 }
9607 if (val & DF_1_GROUP)
9608 {
9609 printf (" GROUP");
9610 val ^= DF_1_GROUP;
9611 }
9612 if (val & DF_1_NODELETE)
9613 {
9614 printf (" NODELETE");
9615 val ^= DF_1_NODELETE;
9616 }
9617 if (val & DF_1_LOADFLTR)
9618 {
9619 printf (" LOADFLTR");
9620 val ^= DF_1_LOADFLTR;
9621 }
9622 if (val & DF_1_INITFIRST)
9623 {
9624 printf (" INITFIRST");
9625 val ^= DF_1_INITFIRST;
9626 }
9627 if (val & DF_1_NOOPEN)
9628 {
9629 printf (" NOOPEN");
9630 val ^= DF_1_NOOPEN;
9631 }
9632 if (val & DF_1_ORIGIN)
9633 {
9634 printf (" ORIGIN");
9635 val ^= DF_1_ORIGIN;
9636 }
9637 if (val & DF_1_DIRECT)
9638 {
9639 printf (" DIRECT");
9640 val ^= DF_1_DIRECT;
9641 }
9642 if (val & DF_1_TRANS)
9643 {
9644 printf (" TRANS");
9645 val ^= DF_1_TRANS;
9646 }
9647 if (val & DF_1_INTERPOSE)
9648 {
9649 printf (" INTERPOSE");
9650 val ^= DF_1_INTERPOSE;
9651 }
f7db6139 9652 if (val & DF_1_NODEFLIB)
dcefbbbd 9653 {
f7db6139
L		 9654 printf (" NODEFLIB");
9655 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 9656 }
9657 if (val & DF_1_NODUMP)
9658 {
9659 printf (" NODUMP");
9660 val ^= DF_1_NODUMP;
9661 }
34b60028 9662 if (val & DF_1_CONFALT)
dcefbbbd 9663 {
34b60028
L		 9664 printf (" CONFALT");
9665 val ^= DF_1_CONFALT;
9666 }
9667 if (val & DF_1_ENDFILTEE)
9668 {
9669 printf (" ENDFILTEE");
9670 val ^= DF_1_ENDFILTEE;
9671 }
9672 if (val & DF_1_DISPRELDNE)
9673 {
9674 printf (" DISPRELDNE");
9675 val ^= DF_1_DISPRELDNE;
9676 }
9677 if (val & DF_1_DISPRELPND)
9678 {
9679 printf (" DISPRELPND");
9680 val ^= DF_1_DISPRELPND;
9681 }
9682 if (val & DF_1_NODIRECT)
9683 {
9684 printf (" NODIRECT");
9685 val ^= DF_1_NODIRECT;
9686 }
9687 if (val & DF_1_IGNMULDEF)
9688 {
9689 printf (" IGNMULDEF");
9690 val ^= DF_1_IGNMULDEF;
9691 }
9692 if (val & DF_1_NOKSYMS)
9693 {
9694 printf (" NOKSYMS");
9695 val ^= DF_1_NOKSYMS;
9696 }
9697 if (val & DF_1_NOHDR)
9698 {
9699 printf (" NOHDR");
9700 val ^= DF_1_NOHDR;
9701 }
9702 if (val & DF_1_EDITED)
9703 {
9704 printf (" EDITED");
9705 val ^= DF_1_EDITED;
9706 }
9707 if (val & DF_1_NORELOC)
9708 {
9709 printf (" NORELOC");
9710 val ^= DF_1_NORELOC;
9711 }
9712 if (val & DF_1_SYMINTPOSE)
9713 {
9714 printf (" SYMINTPOSE");
9715 val ^= DF_1_SYMINTPOSE;
9716 }
9717 if (val & DF_1_GLOBAUDIT)
9718 {
9719 printf (" GLOBAUDIT");
9720 val ^= DF_1_GLOBAUDIT;
9721 }
9722 if (val & DF_1_SINGLETON)
9723 {
9724 printf (" SINGLETON");
9725 val ^= DF_1_SINGLETON;
dcefbbbd 9726 }
5c383f02
RO		 9727 if (val & DF_1_STUB)
9728 {
9729 printf (" STUB");
9730 val ^= DF_1_STUB;
9731 }
9732 if (val & DF_1_PIE)
9733 {
9734 printf (" PIE");
9735 val ^= DF_1_PIE;
9736 }
252b5132
RH		 9737 if (val != 0)
9738 printf (" %lx", val);
9739 puts ("");
9740 }
9741 }
9742 break;
9743
9744 case DT_PLTREL:
566b0d53 9745 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9746 if (do_dynamic)
9747 puts (get_dynamic_type (entry->d_un.d_val));
9748 break;
9749
9750 case DT_NULL :
9751 case DT_NEEDED :
9752 case DT_PLTGOT :
9753 case DT_HASH :
9754 case DT_STRTAB :
9755 case DT_SYMTAB :
9756 case DT_RELA :
9757 case DT_INIT :
9758 case DT_FINI :
9759 case DT_SONAME :
9760 case DT_RPATH :
9761 case DT_SYMBOLIC:
9762 case DT_REL :
9763 case DT_DEBUG :
9764 case DT_TEXTREL :
9765 case DT_JMPREL :
019148e4 9766 case DT_RUNPATH :
252b5132
RH		 9767 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9768
9769 if (do_dynamic)
9770 {
2cf0635d 9771 char * name;
252b5132 9772
d79b3d50
NC		 9773 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9774 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9775 else
d79b3d50 9776 name = NULL;
252b5132
RH		 9777
9778 if (name)
9779 {
9780 switch (entry->d_tag)
9781 {
9782 case DT_NEEDED:
9783 printf (_("Shared library: [%s]"), name);
9784
18bd398b 9785 if (streq (name, program_interpreter))
f7a99963 9786 printf (_(" program interpreter"));
252b5132
RH		 9787 break;
9788
9789 case DT_SONAME:
f7a99963 9790 printf (_("Library soname: [%s]"), name);
252b5132
RH		 9791 break;
9792
9793 case DT_RPATH:
f7a99963 9794 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 9795 break;
9796
019148e4
L		 9797 case DT_RUNPATH:
9798 printf (_("Library runpath: [%s]"), name);
9799 break;
9800
252b5132 9801 default:
f7a99963
NC		 9802 print_vma (entry->d_un.d_val, PREFIX_HEX);
9803 break;
252b5132
RH		 9804 }
9805 }
9806 else
f7a99963
NC		 9807 print_vma (entry->d_un.d_val, PREFIX_HEX);
9808
9809 putchar ('\n');
252b5132
RH		 9810 }
9811 break;
9812
9813 case DT_PLTRELSZ:
9814 case DT_RELASZ :
9815 case DT_STRSZ :
9816 case DT_RELSZ :
9817 case DT_RELAENT :
9818 case DT_SYMENT :
9819 case DT_RELENT :
566b0d53 9820 dynamic_info[entry->d_tag] = entry->d_un.d_val;
1a0670f3 9821 /* Fall through. */
252b5132
RH		 9822 case DT_PLTPADSZ:
9823 case DT_MOVEENT :
9824 case DT_MOVESZ :
9825 case DT_INIT_ARRAYSZ:
9826 case DT_FINI_ARRAYSZ:
047b2264
JJ		 9827 case DT_GNU_CONFLICTSZ:
9828 case DT_GNU_LIBLISTSZ:
252b5132 9829 if (do_dynamic)
f7a99963
NC		 9830 {
9831 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 9832 printf (_(" (bytes)\n"));
f7a99963 9833 }
252b5132
RH		 9834 break;
9835
9836 case DT_VERDEFNUM:
9837 case DT_VERNEEDNUM:
9838 case DT_RELACOUNT:
9839 case DT_RELCOUNT:
9840 if (do_dynamic)
f7a99963
NC		 9841 {
9842 print_vma (entry->d_un.d_val, UNSIGNED);
9843 putchar ('\n');
9844 }
252b5132
RH		 9845 break;
9846
9847 case DT_SYMINSZ:
9848 case DT_SYMINENT:
9849 case DT_SYMINFO:
9850 case DT_USED:
9851 case DT_INIT_ARRAY:
9852 case DT_FINI_ARRAY:
9853 if (do_dynamic)
9854 {
d79b3d50
NC		 9855 if (entry->d_tag == DT_USED
9856 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 9857 {
2cf0635d 9858 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9859
b34976b6 9860 if (*name)
252b5132
RH		 9861 {
9862 printf (_("Not needed object: [%s]\n"), name);
9863 break;
9864 }
9865 }
103f02d3 9866
f7a99963
NC		 9867 print_vma (entry->d_un.d_val, PREFIX_HEX);
9868 putchar ('\n');
252b5132
RH		 9869 }
9870 break;
9871
9872 case DT_BIND_NOW:
9873 /* The value of this entry is ignored. */
35b1837e
AM		 9874 if (do_dynamic)
9875 putchar ('\n');
252b5132 9876 break;
103f02d3 9877
047b2264
JJ		 9878 case DT_GNU_PRELINKED:
9879 if (do_dynamic)
9880 {
2cf0635d 9881 struct tm * tmp;
91d6fa6a 9882 time_t atime = entry->d_un.d_val;
047b2264 9883
91d6fa6a 9884 tmp = gmtime (&atime);
071436c6
NC		 9885 /* PR 17533 file: 041-1244816-0.004. */
9886 if (tmp == NULL)
5a2cbcf4
L		 9887 printf (_("<corrupt time val: %lx"),
9888 (unsigned long) atime);
071436c6
NC		 9889 else
9890 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9891 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9892 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 9893
9894 }
9895 break;
9896
fdc90cb4
JJ		 9897 case DT_GNU_HASH:
9898 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9899 if (do_dynamic)
9900 {
9901 print_vma (entry->d_un.d_val, PREFIX_HEX);
9902 putchar ('\n');
9903 }
9904 break;
9905
252b5132
RH		 9906 default:
9907 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 9908 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 9909 entry->d_un.d_val;
9910
9911 if (do_dynamic)
9912 {
9913 switch (elf_header.e_machine)
9914 {
9915 case EM_MIPS:
4fe85591 9916 case EM_MIPS_RS3_LE:
b2d38a17 9917 dynamic_section_mips_val (entry);
252b5132 9918 break;
103f02d3 9919 case EM_PARISC:
b2d38a17 9920 dynamic_section_parisc_val (entry);
103f02d3 9921 break;
ecc51f48 9922 case EM_IA_64:
b2d38a17 9923 dynamic_section_ia64_val (entry);
ecc51f48 9924 break;
252b5132 9925 default:
f7a99963
NC		 9926 print_vma (entry->d_un.d_val, PREFIX_HEX);
9927 putchar ('\n');
252b5132
RH		 9928 }
9929 }
9930 break;
9931 }
9932 }
9933
9934 return 1;
9935}
9936
9937static char *
d3ba0551 9938get_ver_flags (unsigned int flags)
252b5132 9939{
b34976b6 9940 static char buff[32];
252b5132
RH		 9941
9942 buff[0] = 0;
9943
9944 if (flags == 0)
9945 return _("none");
9946
9947 if (flags & VER_FLG_BASE)
9948 strcat (buff, "BASE ");
9949
9950 if (flags & VER_FLG_WEAK)
9951 {
9952 if (flags & VER_FLG_BASE)
9953 strcat (buff, "| ");
9954
9955 strcat (buff, "WEAK ");
9956 }
9957
44ec90b9
RO		 9958 if (flags & VER_FLG_INFO)
9959 {
9960 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9961 strcat (buff, "| ");
9962
9963 strcat (buff, "INFO ");
9964 }
9965
9966 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 9967 strcat (buff, _("| <unknown>"));
252b5132
RH		 9968
9969 return buff;
9970}
9971
9972/* Display the contents of the version sections. */
98fb390a 9973
252b5132 9974static int
2cf0635d 9975process_version_sections (FILE * file)
252b5132 9976{
2cf0635d 9977 Elf_Internal_Shdr * section;
b34976b6
AM		 9978 unsigned i;
9979 int found = 0;
252b5132
RH		 9980
9981 if (! do_version)
9982 return 1;
9983
9984 for (i = 0, section = section_headers;
9985 i < elf_header.e_shnum;
b34976b6 9986 i++, section++)
252b5132
RH		 9987 {
9988 switch (section->sh_type)
9989 {
9990 case SHT_GNU_verdef:
9991 {
2cf0635d 9992 Elf_External_Verdef * edefs;
b34976b6
AM		 9993 unsigned int idx;
9994 unsigned int cnt;
2cf0635d 9995 char * endbuf;
252b5132
RH		 9996
9997 found = 1;
9998
74e1a04b
NC		 9999 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
10000 printable_section_name (section),
10001 section->sh_info);
252b5132
RH		 10002
10003 printf (_(" Addr: 0x"));
10004 printf_vma (section->sh_addr);
233f82cf 10005 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 10006 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 10007 printable_section_name_from_index (section->sh_link));
252b5132 10008
3f5e193b
NC		 10009 edefs = (Elf_External_Verdef *)
10010 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
10011 _("version definition section"));
a6e9f9df
AM		 10012 if (!edefs)
10013 break;
59245841 10014 endbuf = (char *) edefs + section->sh_size;
252b5132 10015
b34976b6 10016 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 10017 {
2cf0635d
NC		 10018 char * vstart;
10019 Elf_External_Verdef * edef;
b34976b6 10020 Elf_Internal_Verdef ent;
2cf0635d 10021 Elf_External_Verdaux * eaux;
b34976b6
AM		 10022 Elf_Internal_Verdaux aux;
10023 int j;
10024 int isum;
103f02d3 10025
222c2bf0 10026 /* Check for very large indices. */
7e26601c 10027 if (idx > (size_t) (endbuf - (char *) edefs))
dd24e3da
NC		 10028 break;
10029
252b5132 10030 vstart = ((char *) edefs) + idx;
54806181
AM		 10031 if (vstart + sizeof (*edef) > endbuf)
10032 break;
252b5132
RH		 10033
10034 edef = (Elf_External_Verdef *) vstart;
10035
10036 ent.vd_version = BYTE_GET (edef->vd_version);
10037 ent.vd_flags = BYTE_GET (edef->vd_flags);
10038 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
10039 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
10040 ent.vd_hash = BYTE_GET (edef->vd_hash);
10041 ent.vd_aux = BYTE_GET (edef->vd_aux);
10042 ent.vd_next = BYTE_GET (edef->vd_next);
10043
10044 printf (_(" %#06x: Rev: %d Flags: %s"),
10045 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10046
10047 printf (_(" Index: %d Cnt: %d "),
10048 ent.vd_ndx, ent.vd_cnt);
10049
dd24e3da 10050 /* Check for overflow. */
4aeb00ad 10051 if (ent.vd_aux + sizeof (* eaux) > (size_t) (endbuf - vstart))
dd24e3da
NC		 10052 break;
10053
252b5132
RH		 10054 vstart += ent.vd_aux;
10055
10056 eaux = (Elf_External_Verdaux *) vstart;
10057
10058 aux.vda_name = BYTE_GET (eaux->vda_name);
10059 aux.vda_next = BYTE_GET (eaux->vda_next);
10060
d79b3d50
NC		 10061 if (VALID_DYNAMIC_NAME (aux.vda_name))
10062 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 10063 else
10064 printf (_("Name index: %ld\n"), aux.vda_name);
10065
10066 isum = idx + ent.vd_aux;
10067
b34976b6 10068 for (j = 1; j < ent.vd_cnt; j++)
252b5132 10069 {
dd24e3da 10070 /* Check for overflow. */
7e26601c 10071 if (aux.vda_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 10072 break;
10073
252b5132
RH		 10074 isum += aux.vda_next;
10075 vstart += aux.vda_next;
10076
10077 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 10078 if (vstart + sizeof (*eaux) > endbuf)
10079 break;
252b5132
RH		 10080
10081 aux.vda_name = BYTE_GET (eaux->vda_name);
10082 aux.vda_next = BYTE_GET (eaux->vda_next);
10083
d79b3d50 10084 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 10085 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 10086 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 10087 else
10088 printf (_(" %#06x: Parent %d, name index: %ld\n"),
10089 isum, j, aux.vda_name);
10090 }
dd24e3da 10091
54806181
AM		 10092 if (j < ent.vd_cnt)
10093 printf (_(" Version def aux past end of section\n"));
252b5132 10094
5d921cbd
NC		 10095 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
10096 if (idx + ent.vd_next <= idx)
10097 break;
10098
252b5132
RH		 10099 idx += ent.vd_next;
10100 }
dd24e3da 10101
54806181
AM		 10102 if (cnt < section->sh_info)
10103 printf (_(" Version definition past end of section\n"));
252b5132
RH		 10104
10105 free (edefs);
10106 }
10107 break;
103f02d3 10108
252b5132
RH		 10109 case SHT_GNU_verneed:
10110 {
2cf0635d 10111 Elf_External_Verneed * eneed;
b34976b6
AM		 10112 unsigned int idx;
10113 unsigned int cnt;
2cf0635d 10114 char * endbuf;
252b5132
RH		 10115
10116 found = 1;
10117
72de5009 10118 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
74e1a04b 10119 printable_section_name (section), section->sh_info);
252b5132
RH		 10120
10121 printf (_(" Addr: 0x"));
10122 printf_vma (section->sh_addr);
72de5009 10123 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 10124 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 10125 printable_section_name_from_index (section->sh_link));
252b5132 10126
3f5e193b
NC		 10127 eneed = (Elf_External_Verneed *) get_data (NULL, file,
10128 section->sh_offset, 1,
10129 section->sh_size,
9cf03b7e 10130 _("Version Needs section"));
a6e9f9df
AM		 10131 if (!eneed)
10132 break;
59245841 10133 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 10134
10135 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10136 {
2cf0635d 10137 Elf_External_Verneed * entry;
b34976b6
AM		 10138 Elf_Internal_Verneed ent;
10139 int j;
10140 int isum;
2cf0635d 10141 char * vstart;
252b5132 10142
7e26601c 10143 if (idx > (size_t) (endbuf - (char *) eneed))
dd24e3da
NC		 10144 break;
10145
252b5132 10146 vstart = ((char *) eneed) + idx;
54806181
AM		 10147 if (vstart + sizeof (*entry) > endbuf)
10148 break;
252b5132
RH		 10149
10150 entry = (Elf_External_Verneed *) vstart;
10151
10152 ent.vn_version = BYTE_GET (entry->vn_version);
10153 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
10154 ent.vn_file = BYTE_GET (entry->vn_file);
10155 ent.vn_aux = BYTE_GET (entry->vn_aux);
10156 ent.vn_next = BYTE_GET (entry->vn_next);
10157
10158 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
10159
d79b3d50
NC		 10160 if (VALID_DYNAMIC_NAME (ent.vn_file))
10161 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 10162 else
10163 printf (_(" File: %lx"), ent.vn_file);
10164
10165 printf (_(" Cnt: %d\n"), ent.vn_cnt);
10166
dd24e3da 10167 /* Check for overflow. */
7e26601c 10168 if (ent.vn_aux > (size_t) (endbuf - vstart))
dd24e3da 10169 break;
252b5132
RH		 10170 vstart += ent.vn_aux;
10171
10172 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10173 {
2cf0635d 10174 Elf_External_Vernaux * eaux;
b34976b6 10175 Elf_Internal_Vernaux aux;
252b5132 10176
54806181
AM		 10177 if (vstart + sizeof (*eaux) > endbuf)
10178 break;
252b5132
RH		 10179 eaux = (Elf_External_Vernaux *) vstart;
10180
10181 aux.vna_hash = BYTE_GET (eaux->vna_hash);
10182 aux.vna_flags = BYTE_GET (eaux->vna_flags);
10183 aux.vna_other = BYTE_GET (eaux->vna_other);
10184 aux.vna_name = BYTE_GET (eaux->vna_name);
10185 aux.vna_next = BYTE_GET (eaux->vna_next);
10186
d79b3d50 10187 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 10188 printf (_(" %#06x: Name: %s"),
d79b3d50 10189 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 10190 else
ecc2063b 10191 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 10192 isum, aux.vna_name);
10193
10194 printf (_(" Flags: %s Version: %d\n"),
10195 get_ver_flags (aux.vna_flags), aux.vna_other);
10196
dd24e3da 10197 /* Check for overflow. */
53774b7e
NC		 10198 if (aux.vna_next > (size_t) (endbuf - vstart)
10199 || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
10200 {
10201 warn (_("Invalid vna_next field of %lx\n"),
10202 aux.vna_next);
10203 j = ent.vn_cnt;
10204 break;
10205 }
252b5132
RH		 10206 isum += aux.vna_next;
10207 vstart += aux.vna_next;
10208 }
9cf03b7e 10209
54806181 10210 if (j < ent.vn_cnt)
9cf03b7e 10211 warn (_("Missing Version Needs auxillary information\n"));
252b5132 10212
bcf83b2a 10213 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
c24cf8b6
NC		 10214 {
10215 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
10216 cnt = section->sh_info;
10217 break;
10218 }
252b5132
RH		 10219 idx += ent.vn_next;
10220 }
9cf03b7e 10221
54806181 10222 if (cnt < section->sh_info)
9cf03b7e 10223 warn (_("Missing Version Needs information\n"));
103f02d3 10224
252b5132
RH		 10225 free (eneed);
10226 }
10227 break;
10228
10229 case SHT_GNU_versym:
10230 {
2cf0635d 10231 Elf_Internal_Shdr * link_section;
8b73c356
NC		 10232 size_t total;
10233 unsigned int cnt;
2cf0635d
NC		 10234 unsigned char * edata;
10235 unsigned short * data;
10236 char * strtab;
10237 Elf_Internal_Sym * symbols;
10238 Elf_Internal_Shdr * string_sec;
ba5cdace 10239 unsigned long num_syms;
d3ba0551 10240 long off;
252b5132 10241
4fbb74a6 10242 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 10243 break;
10244
4fbb74a6 10245 link_section = section_headers + section->sh_link;
08d8fa11 10246 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 10247
4fbb74a6 10248 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 10249 break;
10250
252b5132
RH		 10251 found = 1;
10252
ba5cdace 10253 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 10254 if (symbols == NULL)
10255 break;
252b5132 10256
4fbb74a6 10257 string_sec = section_headers + link_section->sh_link;
252b5132 10258
3f5e193b
NC		 10259 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
10260 string_sec->sh_size,
10261 _("version string table"));
a6e9f9df 10262 if (!strtab)
0429c154
MS		 10263 {
10264 free (symbols);
10265 break;
10266 }
252b5132 10267
8b73c356
NC		 10268 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10269 printable_section_name (section), (unsigned long) total);
252b5132
RH		 10270
10271 printf (_(" Addr: "));
10272 printf_vma (section->sh_addr);
72de5009 10273 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 10274 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 10275 printable_section_name (link_section));
252b5132 10276
d3ba0551
AM		 10277 off = offset_from_vma (file,
10278 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10279 total * sizeof (short));
3f5e193b
NC		 10280 edata = (unsigned char *) get_data (NULL, file, off, total,
10281 sizeof (short),
10282 _("version symbol data"));
a6e9f9df
AM		 10283 if (!edata)
10284 {
10285 free (strtab);
0429c154 10286 free (symbols);
a6e9f9df
AM		 10287 break;
10288 }
252b5132 10289
3f5e193b 10290 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 10291
10292 for (cnt = total; cnt --;)
b34976b6
AM		 10293 data[cnt] = byte_get (edata + cnt * sizeof (short),
10294 sizeof (short));
252b5132
RH		 10295
10296 free (edata);
10297
10298 for (cnt = 0; cnt < total; cnt += 4)
10299 {
10300 int j, nn;
ab273396
AM		 10301 char *name;
10302 char *invalid = _("*invalid*");
252b5132
RH		 10303
10304 printf (" %03x:", cnt);
10305
10306 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 10307 switch (data[cnt + j])
252b5132
RH		 10308 {
10309 case 0:
10310 fputs (_(" 0 (*local*) "), stdout);
10311 break;
10312
10313 case 1:
10314 fputs (_(" 1 (*global*) "), stdout);
10315 break;
10316
10317 default:
c244d050
NC		 10318 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10319 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 10320
dd24e3da 10321 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 10322 array, break to avoid an out-of-bounds read. */
10323 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 10324 {
10325 warn (_("invalid index into symbol array\n"));
10326 break;
10327 }
10328
ab273396
AM		 10329 name = NULL;
10330 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 10331 {
b34976b6
AM		 10332 Elf_Internal_Verneed ivn;
10333 unsigned long offset;
252b5132 10334
d93f0186
NC		 10335 offset = offset_from_vma
10336 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10337 sizeof (Elf_External_Verneed));
252b5132 10338
b34976b6 10339 do
252b5132 10340 {
b34976b6
AM		 10341 Elf_Internal_Vernaux ivna;
10342 Elf_External_Verneed evn;
10343 Elf_External_Vernaux evna;
10344 unsigned long a_off;
252b5132 10345
59245841
NC		 10346 if (get_data (&evn, file, offset, sizeof (evn), 1,
10347 _("version need")) == NULL)
10348 break;
0b4362b0 10349
252b5132
RH		 10350 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10351 ivn.vn_next = BYTE_GET (evn.vn_next);
10352
10353 a_off = offset + ivn.vn_aux;
10354
10355 do
10356 {
59245841
NC		 10357 if (get_data (&evna, file, a_off, sizeof (evna),
10358 1, _("version need aux (2)")) == NULL)
10359 {
10360 ivna.vna_next = 0;
10361 ivna.vna_other = 0;
10362 }
10363 else
10364 {
10365 ivna.vna_next = BYTE_GET (evna.vna_next);
10366 ivna.vna_other = BYTE_GET (evna.vna_other);
10367 }
252b5132
RH		 10368
10369 a_off += ivna.vna_next;
10370 }
b34976b6 10371 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 10372 && ivna.vna_next != 0);
10373
b34976b6 10374 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 10375 {
10376 ivna.vna_name = BYTE_GET (evna.vna_name);
10377
54806181 10378 if (ivna.vna_name >= string_sec->sh_size)
ab273396 10379 name = invalid;
54806181
AM		 10380 else
10381 name = strtab + ivna.vna_name;
252b5132
RH		 10382 break;
10383 }
10384
10385 offset += ivn.vn_next;
10386 }
10387 while (ivn.vn_next);
10388 }
00d93f34 10389
ab273396 10390 if (data[cnt + j] != 0x8001
b34976b6 10391 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 10392 {
b34976b6
AM		 10393 Elf_Internal_Verdef ivd;
10394 Elf_External_Verdef evd;
10395 unsigned long offset;
252b5132 10396
d93f0186
NC		 10397 offset = offset_from_vma
10398 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10399 sizeof evd);
252b5132
RH		 10400
10401 do
10402 {
59245841
NC		 10403 if (get_data (&evd, file, offset, sizeof (evd), 1,
10404 _("version def")) == NULL)
10405 {
10406 ivd.vd_next = 0;
948f632f 10407 /* PR 17531: file: 046-1082287-0.004. */
3102e897
NC		 10408 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
10409 break;
59245841
NC		 10410 }
10411 else
10412 {
10413 ivd.vd_next = BYTE_GET (evd.vd_next);
10414 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10415 }
252b5132
RH		 10416
10417 offset += ivd.vd_next;
10418 }
c244d050 10419 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 10420 && ivd.vd_next != 0);
10421
c244d050 10422 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 10423 {
b34976b6
AM		 10424 Elf_External_Verdaux evda;
10425 Elf_Internal_Verdaux ivda;
252b5132
RH		 10426
10427 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10428
59245841
NC		 10429 if (get_data (&evda, file,
10430 offset - ivd.vd_next + ivd.vd_aux,
10431 sizeof (evda), 1,
10432 _("version def aux")) == NULL)
10433 break;
252b5132
RH		 10434
10435 ivda.vda_name = BYTE_GET (evda.vda_name);
10436
54806181 10437 if (ivda.vda_name >= string_sec->sh_size)
ab273396
AM		 10438 name = invalid;
10439 else if (name != NULL && name != invalid)
10440 name = _("*both*");
54806181
AM		 10441 else
10442 name = strtab + ivda.vda_name;
252b5132
RH		 10443 }
10444 }
ab273396
AM		 10445 if (name != NULL)
10446 nn += printf ("(%s%-*s",
10447 name,
10448 12 - (int) strlen (name),
10449 ")");
252b5132
RH		 10450
10451 if (nn < 18)
10452 printf ("%*c", 18 - nn, ' ');
10453 }
10454
10455 putchar ('\n');
10456 }
10457
10458 free (data);
10459 free (strtab);
10460 free (symbols);
10461 }
10462 break;
103f02d3 10463
252b5132
RH		 10464 default:
10465 break;
10466 }
10467 }
10468
10469 if (! found)
10470 printf (_("\nNo version information found in this file.\n"));
10471
10472 return 1;
10473}
10474
d1133906 10475static const char *
d3ba0551 10476get_symbol_binding (unsigned int binding)
252b5132 10477{
b34976b6 10478 static char buff[32];
252b5132
RH		 10479
10480 switch (binding)
10481 {
b34976b6
AM		 10482 case STB_LOCAL: return "LOCAL";
10483 case STB_GLOBAL: return "GLOBAL";
10484 case STB_WEAK: return "WEAK";
252b5132
RH		 10485 default:
10486 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 10487 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10488 binding);
252b5132 10489 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 10490 {
10491 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 10492 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10493 /* GNU is still using the default value 0. */
3e7a7d11
NC		 10494 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10495 return "UNIQUE";
10496 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10497 }
252b5132 10498 else
e9e44622 10499 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 10500 return buff;
10501 }
10502}
10503
d1133906 10504static const char *
d3ba0551 10505get_symbol_type (unsigned int type)
252b5132 10506{
b34976b6 10507 static char buff[32];
252b5132
RH		 10508
10509 switch (type)
10510 {
b34976b6
AM		 10511 case STT_NOTYPE: return "NOTYPE";
10512 case STT_OBJECT: return "OBJECT";
10513 case STT_FUNC: return "FUNC";
10514 case STT_SECTION: return "SECTION";
10515 case STT_FILE: return "FILE";
10516 case STT_COMMON: return "COMMON";
10517 case STT_TLS: return "TLS";
15ab5209
DB		 10518 case STT_RELC: return "RELC";
10519 case STT_SRELC: return "SRELC";
252b5132
RH		 10520 default:
10521 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af 10522 {
3510a7b8
NC		 10523 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10524 return "THUMB_FUNC";
103f02d3 10525
351b4b40 10526 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 10527 return "REGISTER";
10528
10529 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10530 return "PARISC_MILLI";
10531
e9e44622 10532 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 10533 }
252b5132 10534 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 10535 {
10536 if (elf_header.e_machine == EM_PARISC)
10537 {
10538 if (type == STT_HP_OPAQUE)
10539 return "HP_OPAQUE";
10540 if (type == STT_HP_STUB)
10541 return "HP_STUB";
10542 }
10543
d8045f23 10544 if (type == STT_GNU_IFUNC
9c55345c 10545 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 10546 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 10547 /* GNU is still using the default value 0. */
d8045f23
NC		 10548 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10549 return "IFUNC";
10550
e9e44622 10551 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 10552 }
252b5132 10553 else
e9e44622 10554 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 10555 return buff;
10556 }
10557}
10558
d1133906 10559static const char *
d3ba0551 10560get_symbol_visibility (unsigned int visibility)
d1133906
NC		 10561{
10562 switch (visibility)
10563 {
b34976b6
AM		 10564 case STV_DEFAULT: return "DEFAULT";
10565 case STV_INTERNAL: return "INTERNAL";
10566 case STV_HIDDEN: return "HIDDEN";
d1133906 10567 case STV_PROTECTED: return "PROTECTED";
bee0ee85
NC		 10568 default:
10569 error (_("Unrecognized visibility value: %u"), visibility);
10570 return _("<unknown>");
d1133906
NC		 10571 }
10572}
10573
fd85a6a1
NC		 10574static const char *
10575get_solaris_symbol_visibility (unsigned int visibility)
10576{
10577 switch (visibility)
10578 {
10579 case 4: return "EXPORTED";
10580 case 5: return "SINGLETON";
10581 case 6: return "ELIMINATE";
10582 default: return get_symbol_visibility (visibility);
10583 }
10584}
10585
5e2b0d47
NC		 10586static const char *
10587get_mips_symbol_other (unsigned int other)
10588{
10589 switch (other)
10590 {
df58fc94
RS		 10591 case STO_OPTIONAL:
10592 return "OPTIONAL";
10593 case STO_MIPS_PLT:
10594 return "MIPS PLT";
10595 case STO_MIPS_PIC:
10596 return "MIPS PIC";
10597 case STO_MICROMIPS:
10598 return "MICROMIPS";
10599 case STO_MICROMIPS | STO_MIPS_PIC:
10600 return "MICROMIPS, MIPS PIC";
10601 case STO_MIPS16:
10602 return "MIPS16";
10603 default:
10604 return NULL;
5e2b0d47
NC		 10605 }
10606}
10607
28f997cf
TG		 10608static const char *
10609get_ia64_symbol_other (unsigned int other)
10610{
10611 if (is_ia64_vms ())
10612 {
10613 static char res[32];
10614
10615 res[0] = 0;
10616
10617 /* Function types is for images and .STB files only. */
10618 switch (elf_header.e_type)
10619 {
10620 case ET_DYN:
10621 case ET_EXEC:
10622 switch (VMS_ST_FUNC_TYPE (other))
10623 {
10624 case VMS_SFT_CODE_ADDR:
10625 strcat (res, " CA");
10626 break;
10627 case VMS_SFT_SYMV_IDX:
10628 strcat (res, " VEC");
10629 break;
10630 case VMS_SFT_FD:
10631 strcat (res, " FD");
10632 break;
10633 case VMS_SFT_RESERVE:
10634 strcat (res, " RSV");
10635 break;
10636 default:
bee0ee85
NC		 10637 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10638 VMS_ST_FUNC_TYPE (other));
10639 strcat (res, " <unknown>");
10640 break;
28f997cf
TG		 10641 }
10642 break;
10643 default:
10644 break;
10645 }
10646 switch (VMS_ST_LINKAGE (other))
10647 {
10648 case VMS_STL_IGNORE:
10649 strcat (res, " IGN");
10650 break;
10651 case VMS_STL_RESERVE:
10652 strcat (res, " RSV");
10653 break;
10654 case VMS_STL_STD:
10655 strcat (res, " STD");
10656 break;
10657 case VMS_STL_LNK:
10658 strcat (res, " LNK");
10659 break;
10660 default:
bee0ee85
NC		 10661 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10662 VMS_ST_LINKAGE (other));
10663 strcat (res, " <unknown>");
10664 break;
28f997cf
TG		 10665 }
10666
10667 if (res[0] != 0)
10668 return res + 1;
10669 else
10670 return res;
10671 }
10672 return NULL;
10673}
10674
6911b7dc
AM		 10675static const char *
10676get_ppc64_symbol_other (unsigned int other)
10677{
10678 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10679 {
10680 static char buf[32];
10681 snprintf (buf, sizeof buf, _("<localentry>: %d"),
10682 PPC64_LOCAL_ENTRY_OFFSET (other));
10683 return buf;
10684 }
10685 return NULL;
10686}
10687
5e2b0d47
NC		 10688static const char *
10689get_symbol_other (unsigned int other)
10690{
10691 const char * result = NULL;
10692 static char buff [32];
10693
10694 if (other == 0)
10695 return "";
10696
10697 switch (elf_header.e_machine)
10698 {
10699 case EM_MIPS:
10700 result = get_mips_symbol_other (other);
28f997cf
TG		 10701 break;
10702 case EM_IA_64:
10703 result = get_ia64_symbol_other (other);
10704 break;
6911b7dc
AM		 10705 case EM_PPC64:
10706 result = get_ppc64_symbol_other (other);
10707 break;
5e2b0d47 10708 default:
fd85a6a1 10709 result = NULL;
5e2b0d47
NC		 10710 break;
10711 }
10712
10713 if (result)
10714 return result;
10715
10716 snprintf (buff, sizeof buff, _("<other>: %x"), other);
10717 return buff;
10718}
10719
d1133906 10720static const char *
d3ba0551 10721get_symbol_index_type (unsigned int type)
252b5132 10722{
b34976b6 10723 static char buff[32];
5cf1065c 10724
252b5132
RH		 10725 switch (type)
10726 {
b34976b6
AM		 10727 case SHN_UNDEF: return "UND";
10728 case SHN_ABS: return "ABS";
10729 case SHN_COMMON: return "COM";
252b5132 10730 default:
9ce701e2
L		 10731 if (type == SHN_IA_64_ANSI_COMMON
10732 && elf_header.e_machine == EM_IA_64
10733 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10734 return "ANSI_COM";
8a9036a4 10735 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 10736 || elf_header.e_machine == EM_L1OM
10737 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 10738 && type == SHN_X86_64_LCOMMON)
10739 return "LARGE_COM";
ac145307
BS		 10740 else if ((type == SHN_MIPS_SCOMMON
10741 && elf_header.e_machine == EM_MIPS)
10742 || (type == SHN_TIC6X_SCOMMON
10743 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 10744 return "SCOM";
10745 else if (type == SHN_MIPS_SUNDEFINED
10746 && elf_header.e_machine == EM_MIPS)
10747 return "SUND";
9ce701e2 10748 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 10749 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 10750 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 10751 sprintf (buff, "OS [0x%04x]", type & 0xffff);
10752 else if (type >= SHN_LORESERVE)
10753 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4 10754 else if (type >= elf_header.e_shnum)
e0a31db1 10755 sprintf (buff, _("bad section index[%3d]"), type);
252b5132 10756 else
232e7cb8 10757 sprintf (buff, "%3d", type);
5cf1065c 10758 break;
252b5132 10759 }
5cf1065c
NC		 10760
10761 return buff;
252b5132
RH		 10762}
10763
66543521 10764static bfd_vma *
57028622 10765get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
252b5132 10766{
2cf0635d
NC		 10767 unsigned char * e_data;
10768 bfd_vma * i_data;
252b5132 10769
57028622
NC		 10770 /* If the size_t type is smaller than the bfd_size_type, eg because
10771 you are building a 32-bit tool on a 64-bit host, then make sure
10772 that when (number) is cast to (size_t) no information is lost. */
10773 if (sizeof (size_t) < sizeof (bfd_size_type)
10774 && (bfd_size_type) ((size_t) number) != number)
10775 {
ed754a13
AM		 10776 error (_("Size truncation prevents reading %" BFD_VMA_FMT "u"
10777 " elements of size %u\n"),
10778 number, ent_size);
57028622
NC		 10779 return NULL;
10780 }
948f632f 10781
3102e897
NC		 10782 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10783 attempting to allocate memory when the read is bound to fail. */
10784 if (ent_size * number > current_file_size)
10785 {
ed754a13
AM		 10786 error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT "u\n"),
10787 number);
3102e897
NC		 10788 return NULL;
10789 }
10790
57028622 10791 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
252b5132
RH		 10792 if (e_data == NULL)
10793 {
ed754a13
AM		 10794 error (_("Out of memory reading %" BFD_VMA_FMT "u dynamic entries\n"),
10795 number);
252b5132
RH		 10796 return NULL;
10797 }
10798
57028622 10799 if (fread (e_data, ent_size, (size_t) number, file) != number)
252b5132 10800 {
ed754a13
AM		 10801 error (_("Unable to read in %" BFD_VMA_FMT "u bytes of dynamic data\n"),
10802 number * ent_size);
3102e897 10803 free (e_data);
252b5132
RH		 10804 return NULL;
10805 }
10806
57028622 10807 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
252b5132
RH		 10808 if (i_data == NULL)
10809 {
ed754a13
AM		 10810 error (_("Out of memory allocating space for %" BFD_VMA_FMT "u"
10811 " dynamic entries\n"),
10812 number);
252b5132
RH		 10813 free (e_data);
10814 return NULL;
10815 }
10816
10817 while (number--)
66543521 10818 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 10819
10820 free (e_data);
10821
10822 return i_data;
10823}
10824
6bd1a22c
L		 10825static void
10826print_dynamic_symbol (bfd_vma si, unsigned long hn)
10827{
2cf0635d 10828 Elf_Internal_Sym * psym;
6bd1a22c
L		 10829 int n;
10830
6bd1a22c
L		 10831 n = print_vma (si, DEC_5);
10832 if (n < 5)
0b4362b0 10833 fputs (&" "[n], stdout);
6bd1a22c 10834 printf (" %3lu: ", hn);
e0a31db1
NC		 10835
10836 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10837 {
3102e897
NC		 10838 printf (_("<No info available for dynamic symbol number %lu>\n"),
10839 (unsigned long) si);
e0a31db1
NC		 10840 return;
10841 }
10842
10843 psym = dynamic_symbols + si;
6bd1a22c
L		 10844 print_vma (psym->st_value, LONG_HEX);
10845 putchar (' ');
10846 print_vma (psym->st_size, DEC_5);
10847
f4be36b3
AM		 10848 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10849 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
fd85a6a1
NC		 10850
10851 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
10852 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
10853 else
10854 {
10855 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
10856
10857 printf (" %-7s", get_symbol_visibility (vis));
10858 /* Check to see if any other bits in the st_other field are set.
10859 Note - displaying this information disrupts the layout of the
10860 table being generated, but for the moment this case is very
10861 rare. */
10862 if (psym->st_other ^ vis)
10863 printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
10864 }
10865
6bd1a22c
L		 10866 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10867 if (VALID_DYNAMIC_NAME (psym->st_name))
10868 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10869 else
2b692964 10870 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 10871 putchar ('\n');
10872}
10873
bb4d2ac2 10874static const char *
1449284b
NC		 10875get_symbol_version_string (FILE * file,
10876 bfd_boolean is_dynsym,
10877 const char * strtab,
10878 unsigned long int strtab_size,
10879 unsigned int si,
10880 Elf_Internal_Sym * psym,
10881 enum versioned_symbol_info * sym_info,
10882 unsigned short * vna_other)
bb4d2ac2 10883{
ab273396
AM		 10884 unsigned char data[2];
10885 unsigned short vers_data;
10886 unsigned long offset;
bb4d2ac2 10887
ab273396
AM		 10888 if (!is_dynsym
10889 || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
10890 return NULL;
bb4d2ac2 10891
ab273396
AM		 10892 offset = offset_from_vma (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10893 sizeof data + si * sizeof (vers_data));
bb4d2ac2 10894
ab273396
AM		 10895 if (get_data (&data, file, offset + si * sizeof (vers_data),
10896 sizeof (data), 1, _("version data")) == NULL)
10897 return NULL;
10898
10899 vers_data = byte_get (data, 2);
bb4d2ac2 10900
ab273396
AM		 10901 if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
10902 return NULL;
bb4d2ac2 10903
ab273396
AM		 10904 /* Usually we'd only see verdef for defined symbols, and verneed for
10905 undefined symbols. However, symbols defined by the linker in
10906 .dynbss for variables copied from a shared library in order to
10907 avoid text relocations are defined yet have verneed. We could
10908 use a heuristic to detect the special case, for example, check
10909 for verneed first on symbols defined in SHT_NOBITS sections, but
10910 it is simpler and more reliable to just look for both verdef and
10911 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
bb4d2ac2 10912
ab273396
AM		 10913 if (psym->st_shndx != SHN_UNDEF
10914 && vers_data != 0x8001
10915 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10916 {
10917 Elf_Internal_Verdef ivd;
10918 Elf_Internal_Verdaux ivda;
10919 Elf_External_Verdaux evda;
10920 unsigned long off;
bb4d2ac2 10921
ab273396
AM		 10922 off = offset_from_vma (file,
10923 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10924 sizeof (Elf_External_Verdef));
10925
10926 do
bb4d2ac2 10927 {
ab273396
AM		 10928 Elf_External_Verdef evd;
10929
10930 if (get_data (&evd, file, off, sizeof (evd), 1,
10931 _("version def")) == NULL)
10932 {
10933 ivd.vd_ndx = 0;
10934 ivd.vd_aux = 0;
10935 ivd.vd_next = 0;
10936 }
10937 else
bb4d2ac2 10938 {
ab273396
AM		 10939 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10940 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10941 ivd.vd_next = BYTE_GET (evd.vd_next);
10942 }
bb4d2ac2 10943
ab273396
AM		 10944 off += ivd.vd_next;
10945 }
10946 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
bb4d2ac2 10947
ab273396
AM		 10948 if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
10949 {
10950 off -= ivd.vd_next;
10951 off += ivd.vd_aux;
bb4d2ac2 10952
ab273396
AM		 10953 if (get_data (&evda, file, off, sizeof (evda), 1,
10954 _("version def aux")) != NULL)
10955 {
10956 ivda.vda_name = BYTE_GET (evda.vda_name);
bb4d2ac2 10957
ab273396
AM		 10958 if (psym->st_name != ivda.vda_name)
10959 {
10960 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10961 ? symbol_hidden : symbol_public);
10962 return (ivda.vda_name < strtab_size
10963 ? strtab + ivda.vda_name : _("<corrupt>"));
10964 }
10965 }
10966 }
10967 }
bb4d2ac2 10968
ab273396
AM		 10969 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10970 {
10971 Elf_External_Verneed evn;
10972 Elf_Internal_Verneed ivn;
10973 Elf_Internal_Vernaux ivna;
bb4d2ac2 10974
ab273396
AM		 10975 offset = offset_from_vma (file,
10976 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10977 sizeof evn);
10978 do
10979 {
10980 unsigned long vna_off;
bb4d2ac2 10981
ab273396
AM		 10982 if (get_data (&evn, file, offset, sizeof (evn), 1,
10983 _("version need")) == NULL)
10984 {
10985 ivna.vna_next = 0;
10986 ivna.vna_other = 0;
10987 ivna.vna_name = 0;
10988 break;
10989 }
bb4d2ac2 10990
ab273396
AM		 10991 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10992 ivn.vn_next = BYTE_GET (evn.vn_next);
bb4d2ac2 10993
ab273396 10994 vna_off = offset + ivn.vn_aux;
bb4d2ac2 10995
ab273396
AM		 10996 do
10997 {
10998 Elf_External_Vernaux evna;
bb4d2ac2 10999
ab273396
AM		 11000 if (get_data (&evna, file, vna_off, sizeof (evna), 1,
11001 _("version need aux (3)")) == NULL)
bb4d2ac2 11002 {
ab273396
AM		 11003 ivna.vna_next = 0;
11004 ivna.vna_other = 0;
11005 ivna.vna_name = 0;
bb4d2ac2 11006 }
bb4d2ac2 11007 else
bb4d2ac2 11008 {
ab273396
AM		 11009 ivna.vna_other = BYTE_GET (evna.vna_other);
11010 ivna.vna_next = BYTE_GET (evna.vna_next);
11011 ivna.vna_name = BYTE_GET (evna.vna_name);
11012 }
bb4d2ac2 11013
ab273396
AM		 11014 vna_off += ivna.vna_next;
11015 }
11016 while (ivna.vna_other != vers_data && ivna.vna_next != 0);
bb4d2ac2 11017
ab273396
AM		 11018 if (ivna.vna_other == vers_data)
11019 break;
bb4d2ac2 11020
ab273396
AM		 11021 offset += ivn.vn_next;
11022 }
11023 while (ivn.vn_next != 0);
bb4d2ac2 11024
ab273396
AM		 11025 if (ivna.vna_other == vers_data)
11026 {
11027 *sym_info = symbol_undefined;
11028 *vna_other = ivna.vna_other;
11029 return (ivna.vna_name < strtab_size
11030 ? strtab + ivna.vna_name : _("<corrupt>"));
bb4d2ac2
L		 11031 }
11032 }
ab273396 11033 return NULL;
bb4d2ac2
L		 11034}
11035
e3c8793a 11036/* Dump the symbol table. */
252b5132 11037static int
2cf0635d 11038process_symbol_table (FILE * file)
252b5132 11039{
2cf0635d 11040 Elf_Internal_Shdr * section;
8b73c356
NC		 11041 bfd_size_type nbuckets = 0;
11042 bfd_size_type nchains = 0;
2cf0635d
NC		 11043 bfd_vma * buckets = NULL;
11044 bfd_vma * chains = NULL;
fdc90cb4 11045 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 11046 bfd_vma * gnubuckets = NULL;
11047 bfd_vma * gnuchains = NULL;
6bd1a22c 11048 bfd_vma gnusymidx = 0;
071436c6 11049 bfd_size_type ngnuchains = 0;
252b5132 11050
2c610e4b 11051 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 11052 return 1;
11053
6bd1a22c
L		 11054 if (dynamic_info[DT_HASH]
11055 && (do_histogram
2c610e4b
L		 11056 || (do_using_dynamic
11057 && !do_dyn_syms
11058 && dynamic_strings != NULL)))
252b5132 11059 {
66543521
AM		 11060 unsigned char nb[8];
11061 unsigned char nc[8];
8b73c356 11062 unsigned int hash_ent_size = 4;
66543521
AM		 11063
11064 if ((elf_header.e_machine == EM_ALPHA
11065 || elf_header.e_machine == EM_S390
11066 || elf_header.e_machine == EM_S390_OLD)
11067 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
11068 hash_ent_size = 8;
11069
fb52b2f4
NC		 11070 if (fseek (file,
11071 (archive_file_offset
11072 + offset_from_vma (file, dynamic_info[DT_HASH],
11073 sizeof nb + sizeof nc)),
d93f0186 11074 SEEK_SET))
252b5132 11075 {
591a748a 11076 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 11077 goto no_hash;
252b5132
RH		 11078 }
11079
66543521 11080 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 11081 {
11082 error (_("Failed to read in number of buckets\n"));
d3a44ec6 11083 goto no_hash;
252b5132
RH		 11084 }
11085
66543521 11086 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 11087 {
11088 error (_("Failed to read in number of chains\n"));
d3a44ec6 11089 goto no_hash;
252b5132
RH		 11090 }
11091
66543521
AM		 11092 nbuckets = byte_get (nb, hash_ent_size);
11093 nchains = byte_get (nc, hash_ent_size);
252b5132 11094
66543521
AM		 11095 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
11096 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 11097
d3a44ec6 11098 no_hash:
252b5132 11099 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 11100 {
11101 if (do_using_dynamic)
11102 return 0;
11103 free (buckets);
11104 free (chains);
11105 buckets = NULL;
11106 chains = NULL;
11107 nbuckets = 0;
11108 nchains = 0;
11109 }
252b5132
RH		 11110 }
11111
6bd1a22c
L		 11112 if (dynamic_info_DT_GNU_HASH
11113 && (do_histogram
2c610e4b
L		 11114 || (do_using_dynamic
11115 && !do_dyn_syms
11116 && dynamic_strings != NULL)))
252b5132 11117 {
6bd1a22c
L		 11118 unsigned char nb[16];
11119 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11120 bfd_vma buckets_vma;
11121
11122 if (fseek (file,
11123 (archive_file_offset
11124 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
11125 sizeof nb)),
11126 SEEK_SET))
11127 {
11128 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 11129 goto no_gnu_hash;
6bd1a22c 11130 }
252b5132 11131
6bd1a22c
L		 11132 if (fread (nb, 16, 1, file) != 1)
11133 {
11134 error (_("Failed to read in number of buckets\n"));
d3a44ec6 11135 goto no_gnu_hash;
6bd1a22c
L		 11136 }
11137
11138 ngnubuckets = byte_get (nb, 4);
11139 gnusymidx = byte_get (nb + 4, 4);
11140 bitmaskwords = byte_get (nb + 8, 4);
11141 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 11142 if (is_32bit_elf)
6bd1a22c 11143 buckets_vma += bitmaskwords * 4;
f7a99963 11144 else
6bd1a22c 11145 buckets_vma += bitmaskwords * 8;
252b5132 11146
6bd1a22c
L		 11147 if (fseek (file,
11148 (archive_file_offset
11149 + offset_from_vma (file, buckets_vma, 4)),
11150 SEEK_SET))
252b5132 11151 {
6bd1a22c 11152 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 11153 goto no_gnu_hash;
6bd1a22c
L		 11154 }
11155
11156 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 11157
6bd1a22c 11158 if (gnubuckets == NULL)
d3a44ec6 11159 goto no_gnu_hash;
6bd1a22c
L		 11160
11161 for (i = 0; i < ngnubuckets; i++)
11162 if (gnubuckets[i] != 0)
11163 {
11164 if (gnubuckets[i] < gnusymidx)
11165 return 0;
11166
11167 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11168 maxchain = gnubuckets[i];
11169 }
11170
11171 if (maxchain == 0xffffffff)
d3a44ec6 11172 goto no_gnu_hash;
6bd1a22c
L		 11173
11174 maxchain -= gnusymidx;
11175
11176 if (fseek (file,
11177 (archive_file_offset
11178 + offset_from_vma (file, buckets_vma
11179 + 4 * (ngnubuckets + maxchain), 4)),
11180 SEEK_SET))
11181 {
11182 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 11183 goto no_gnu_hash;
6bd1a22c
L		 11184 }
11185
11186 do
11187 {
11188 if (fread (nb, 4, 1, file) != 1)
252b5132 11189 {
6bd1a22c 11190 error (_("Failed to determine last chain length\n"));
d3a44ec6 11191 goto no_gnu_hash;
6bd1a22c 11192 }
252b5132 11193
6bd1a22c 11194 if (maxchain + 1 == 0)
d3a44ec6 11195 goto no_gnu_hash;
252b5132 11196
6bd1a22c
L		 11197 ++maxchain;
11198 }
11199 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 11200
6bd1a22c
L		 11201 if (fseek (file,
11202 (archive_file_offset
11203 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
11204 SEEK_SET))
11205 {
11206 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 11207 goto no_gnu_hash;
6bd1a22c
L		 11208 }
11209
11210 gnuchains = get_dynamic_data (file, maxchain, 4);
071436c6 11211 ngnuchains = maxchain;
6bd1a22c 11212
d3a44ec6 11213 no_gnu_hash:
6bd1a22c 11214 if (gnuchains == NULL)
d3a44ec6
JJ		 11215 {
11216 free (gnubuckets);
d3a44ec6
JJ		 11217 gnubuckets = NULL;
11218 ngnubuckets = 0;
f64fddf1
NC		 11219 if (do_using_dynamic)
11220 return 0;
d3a44ec6 11221 }
6bd1a22c
L		 11222 }
11223
11224 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11225 && do_syms
11226 && do_using_dynamic
3102e897
NC		 11227 && dynamic_strings != NULL
11228 && dynamic_symbols != NULL)
6bd1a22c
L		 11229 {
11230 unsigned long hn;
11231
11232 if (dynamic_info[DT_HASH])
11233 {
11234 bfd_vma si;
11235
11236 printf (_("\nSymbol table for image:\n"));
11237 if (is_32bit_elf)
11238 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11239 else
11240 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11241
11242 for (hn = 0; hn < nbuckets; hn++)
11243 {
11244 if (! buckets[hn])
11245 continue;
11246
11247 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
11248 print_dynamic_symbol (si, hn);
252b5132
RH		 11249 }
11250 }
6bd1a22c
L		 11251
11252 if (dynamic_info_DT_GNU_HASH)
11253 {
11254 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11255 if (is_32bit_elf)
11256 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11257 else
11258 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11259
11260 for (hn = 0; hn < ngnubuckets; ++hn)
11261 if (gnubuckets[hn] != 0)
11262 {
11263 bfd_vma si = gnubuckets[hn];
11264 bfd_vma off = si - gnusymidx;
11265
11266 do
11267 {
11268 print_dynamic_symbol (si, hn);
11269 si++;
11270 }
071436c6 11271 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
6bd1a22c
L		 11272 }
11273 }
252b5132 11274 }
8b73c356
NC		 11275 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11276 && section_headers != NULL)
252b5132 11277 {
b34976b6 11278 unsigned int i;
252b5132
RH		 11279
11280 for (i = 0, section = section_headers;
11281 i < elf_header.e_shnum;
11282 i++, section++)
11283 {
b34976b6 11284 unsigned int si;
2cf0635d 11285 char * strtab = NULL;
c256ffe7 11286 unsigned long int strtab_size = 0;
2cf0635d
NC		 11287 Elf_Internal_Sym * symtab;
11288 Elf_Internal_Sym * psym;
ba5cdace 11289 unsigned long num_syms;
252b5132 11290
2c610e4b
L		 11291 if ((section->sh_type != SHT_SYMTAB
11292 && section->sh_type != SHT_DYNSYM)
11293 || (!do_syms
11294 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 11295 continue;
11296
dd24e3da
NC		 11297 if (section->sh_entsize == 0)
11298 {
11299 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
74e1a04b 11300 printable_section_name (section));
dd24e3da
NC		 11301 continue;
11302 }
11303
252b5132 11304 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
74e1a04b 11305 printable_section_name (section),
252b5132 11306 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 11307
f7a99963 11308 if (is_32bit_elf)
ca47b30c 11309 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 11310 else
ca47b30c 11311 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 11312
ba5cdace 11313 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 11314 if (symtab == NULL)
11315 continue;
11316
11317 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 11318 {
11319 strtab = string_table;
11320 strtab_size = string_table_length;
11321 }
4fbb74a6 11322 else if (section->sh_link < elf_header.e_shnum)
252b5132 11323 {
2cf0635d 11324 Elf_Internal_Shdr * string_sec;
252b5132 11325
4fbb74a6 11326 string_sec = section_headers + section->sh_link;
252b5132 11327
3f5e193b
NC		 11328 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
11329 1, string_sec->sh_size,
11330 _("string table"));
c256ffe7 11331 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 11332 }
11333
ba5cdace 11334 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 11335 {
bb4d2ac2
L		 11336 const char *version_string;
11337 enum versioned_symbol_info sym_info;
11338 unsigned short vna_other;
11339
5e220199 11340 printf ("%6d: ", si);
f7a99963
NC		 11341 print_vma (psym->st_value, LONG_HEX);
11342 putchar (' ');
11343 print_vma (psym->st_size, DEC_5);
d1133906
NC		 11344 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
11345 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
fd85a6a1
NC		 11346 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11347 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
11348 else
11349 {
11350 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11351
11352 printf (" %-7s", get_symbol_visibility (vis));
11353 /* Check to see if any other bits in the st_other field are set.
11354 Note - displaying this information disrupts the layout of the
11355 table being generated, but for the moment this case is very rare. */
11356 if (psym->st_other ^ vis)
11357 printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
11358 }
31104126 11359 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 11360 print_symbol (25, psym->st_name < strtab_size
2b692964 11361 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 11362
bb4d2ac2
L		 11363 version_string
11364 = get_symbol_version_string (file,
11365 section->sh_type == SHT_DYNSYM,
11366 strtab, strtab_size, si,
11367 psym, &sym_info, &vna_other);
11368 if (version_string)
252b5132 11369 {
bb4d2ac2
L		 11370 if (sym_info == symbol_undefined)
11371 printf ("@%s (%d)", version_string, vna_other);
11372 else
11373 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11374 version_string);
252b5132
RH		 11375 }
11376
11377 putchar ('\n');
52c3c391
NC		 11378
11379 if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
dd905818
NC		 11380 && si >= section->sh_info
11381 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11382 && elf_header.e_machine != EM_MIPS
11383 /* Solaris binaries have been found to violate this requirement as
11384 well. Not sure if this is a bug or an ABI requirement. */
11385 && elf_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
52c3c391
NC		 11386 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11387 si, printable_section_name (section), section->sh_info);
252b5132
RH		 11388 }
11389
11390 free (symtab);
11391 if (strtab != string_table)
11392 free (strtab);
11393 }
11394 }
11395 else if (do_syms)
11396 printf
11397 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11398
11399 if (do_histogram && buckets != NULL)
11400 {
2cf0635d
NC		 11401 unsigned long * lengths;
11402 unsigned long * counts;
66543521
AM		 11403 unsigned long hn;
11404 bfd_vma si;
11405 unsigned long maxlength = 0;
11406 unsigned long nzero_counts = 0;
11407 unsigned long nsyms = 0;
94d15024 11408 unsigned long chained;
252b5132 11409
66543521
AM		 11410 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11411 (unsigned long) nbuckets);
252b5132 11412
3f5e193b 11413 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 11414 if (lengths == NULL)
11415 {
8b73c356 11416 error (_("Out of memory allocating space for histogram buckets\n"));
252b5132
RH		 11417 return 0;
11418 }
8b73c356
NC		 11419
11420 printf (_(" Length Number %% of total Coverage\n"));
252b5132
RH		 11421 for (hn = 0; hn < nbuckets; ++hn)
11422 {
94d15024
MF		 11423 for (si = buckets[hn], chained = 0;
11424 si > 0 && si < nchains && si < nbuckets && chained <= nchains;
11425 si = chains[si], ++chained)
252b5132 11426 {
b34976b6 11427 ++nsyms;
252b5132 11428 if (maxlength < ++lengths[hn])
b34976b6 11429 ++maxlength;
252b5132 11430 }
94d15024
MF		 11431
11432 /* PR binutils/17531: A corrupt binary could contain broken
11433 histogram data. Do not go into an infinite loop trying
11434 to process it. */
11435 if (chained > nchains)
11436 {
11437 error (_("histogram chain is corrupt\n"));
11438 break;
11439 }
252b5132
RH		 11440 }
11441
3f5e193b 11442 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 11443 if (counts == NULL)
11444 {
b2e951ec 11445 free (lengths);
8b73c356 11446 error (_("Out of memory allocating space for histogram counts\n"));
252b5132
RH		 11447 return 0;
11448 }
11449
11450 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 11451 ++counts[lengths[hn]];
252b5132 11452
103f02d3 11453 if (nbuckets > 0)
252b5132 11454 {
66543521
AM		 11455 unsigned long i;
11456 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 11457 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 11458 for (i = 1; i <= maxlength; ++i)
103f02d3 11459 {
66543521
AM		 11460 nzero_counts += counts[i] * i;
11461 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11462 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 11463 (nzero_counts * 100.0) / nsyms);
11464 }
252b5132
RH		 11465 }
11466
11467 free (counts);
11468 free (lengths);
11469 }
11470
11471 if (buckets != NULL)
11472 {
11473 free (buckets);
11474 free (chains);
11475 }
11476
d3a44ec6 11477 if (do_histogram && gnubuckets != NULL)
fdc90cb4 11478 {
2cf0635d
NC		 11479 unsigned long * lengths;
11480 unsigned long * counts;
fdc90cb4
JJ		 11481 unsigned long hn;
11482 unsigned long maxlength = 0;
11483 unsigned long nzero_counts = 0;
11484 unsigned long nsyms = 0;
fdc90cb4 11485
8b73c356
NC		 11486 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11487 (unsigned long) ngnubuckets);
11488
3f5e193b 11489 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 11490 if (lengths == NULL)
11491 {
8b73c356 11492 error (_("Out of memory allocating space for gnu histogram buckets\n"));
fdc90cb4
JJ		 11493 return 0;
11494 }
11495
fdc90cb4
JJ		 11496 printf (_(" Length Number %% of total Coverage\n"));
11497
11498 for (hn = 0; hn < ngnubuckets; ++hn)
11499 if (gnubuckets[hn] != 0)
11500 {
11501 bfd_vma off, length = 1;
11502
6bd1a22c 11503 for (off = gnubuckets[hn] - gnusymidx;
071436c6
NC		 11504 /* PR 17531 file: 010-77222-0.004. */
11505 off < ngnuchains && (gnuchains[off] & 1) == 0;
11506 ++off)
fdc90cb4
JJ		 11507 ++length;
11508 lengths[hn] = length;
11509 if (length > maxlength)
11510 maxlength = length;
11511 nsyms += length;
11512 }
11513
3f5e193b 11514 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 11515 if (counts == NULL)
11516 {
b2e951ec 11517 free (lengths);
8b73c356 11518 error (_("Out of memory allocating space for gnu histogram counts\n"));
fdc90cb4
JJ		 11519 return 0;
11520 }
11521
11522 for (hn = 0; hn < ngnubuckets; ++hn)
11523 ++counts[lengths[hn]];
11524
11525 if (ngnubuckets > 0)
11526 {
11527 unsigned long j;
11528 printf (" 0 %-10lu (%5.1f%%)\n",
11529 counts[0], (counts[0] * 100.0) / ngnubuckets);
11530 for (j = 1; j <= maxlength; ++j)
11531 {
11532 nzero_counts += counts[j] * j;
11533 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11534 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11535 (nzero_counts * 100.0) / nsyms);
11536 }
11537 }
11538
11539 free (counts);
11540 free (lengths);
11541 free (gnubuckets);
11542 free (gnuchains);
11543 }
11544
252b5132
RH		 11545 return 1;
11546}
11547
11548static int
2cf0635d 11549process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 11550{
b4c96d0d 11551 unsigned int i;
252b5132
RH		 11552
11553 if (dynamic_syminfo == NULL
11554 || !do_dynamic)
11555 /* No syminfo, this is ok. */
11556 return 1;
11557
11558 /* There better should be a dynamic symbol section. */
11559 if (dynamic_symbols == NULL || dynamic_strings == NULL)
11560 return 0;
11561
11562 if (dynamic_addr)
11563 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11564 dynamic_syminfo_offset, dynamic_syminfo_nent);
11565
11566 printf (_(" Num: Name BoundTo Flags\n"));
11567 for (i = 0; i < dynamic_syminfo_nent; ++i)
11568 {
11569 unsigned short int flags = dynamic_syminfo[i].si_flags;
11570
31104126 11571 printf ("%4d: ", i);
4082ef84
NC		 11572 if (i >= num_dynamic_syms)
11573 printf (_("<corrupt index>"));
11574 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
d79b3d50
NC		 11575 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11576 else
2b692964 11577 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 11578 putchar (' ');
252b5132
RH		 11579
11580 switch (dynamic_syminfo[i].si_boundto)
11581 {
11582 case SYMINFO_BT_SELF:
11583 fputs ("SELF ", stdout);
11584 break;
11585 case SYMINFO_BT_PARENT:
11586 fputs ("PARENT ", stdout);
11587 break;
11588 default:
11589 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 11590 && dynamic_syminfo[i].si_boundto < dynamic_nent
11591 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 11592 {
d79b3d50 11593 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 11594 putchar (' ' );
11595 }
252b5132
RH		 11596 else
11597 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11598 break;
11599 }
11600
11601 if (flags & SYMINFO_FLG_DIRECT)
11602 printf (" DIRECT");
11603 if (flags & SYMINFO_FLG_PASSTHRU)
11604 printf (" PASSTHRU");
11605 if (flags & SYMINFO_FLG_COPY)
11606 printf (" COPY");
11607 if (flags & SYMINFO_FLG_LAZYLOAD)
11608 printf (" LAZYLOAD");
11609
11610 puts ("");
11611 }
11612
11613 return 1;
11614}
11615
b32e566b
NC		 11616#define IN_RANGE(START,END,ADDR,OFF) \
11617 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11618
cf13d699
NC		 11619/* Check to see if the given reloc needs to be handled in a target specific
11620 manner. If so then process the reloc and return TRUE otherwise return
f84ce13b
NC		 11621 FALSE.
11622
11623 If called with reloc == NULL, then this is a signal that reloc processing
11624 for the current section has finished, and any saved state should be
11625 discarded. */
09c11c86 11626
cf13d699
NC		 11627static bfd_boolean
11628target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11629 unsigned char * start,
03f7786e 11630 unsigned char * end,
f84ce13b
NC		 11631 Elf_Internal_Sym * symtab,
11632 unsigned long num_syms)
252b5132 11633{
f84ce13b
NC		 11634 unsigned int reloc_type = 0;
11635 unsigned long sym_index = 0;
11636
11637 if (reloc)
11638 {
11639 reloc_type = get_reloc_type (reloc->r_info);
11640 sym_index = get_reloc_symindex (reloc->r_info);
11641 }
252b5132 11642
cf13d699 11643 switch (elf_header.e_machine)
252b5132 11644 {
13761a11
NC		 11645 case EM_MSP430:
11646 case EM_MSP430_OLD:
11647 {
11648 static Elf_Internal_Sym * saved_sym = NULL;
11649
f84ce13b
NC		 11650 if (reloc == NULL)
11651 {
11652 saved_sym = NULL;
11653 return TRUE;
11654 }
11655
13761a11
NC		 11656 switch (reloc_type)
11657 {
11658 case 10: /* R_MSP430_SYM_DIFF */
11659 if (uses_msp430x_relocs ())
11660 break;
1a0670f3 11661 /* Fall through. */
13761a11 11662 case 21: /* R_MSP430X_SYM_DIFF */
f84ce13b
NC		 11663 /* PR 21139. */
11664 if (sym_index >= num_syms)
11665 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11666 sym_index);
11667 else
11668 saved_sym = symtab + sym_index;
13761a11
NC		 11669 return TRUE;
11670
11671 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11672 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11673 goto handle_sym_diff;
0b4362b0 11674
13761a11
NC		 11675 case 5: /* R_MSP430_16_BYTE */
11676 case 9: /* R_MSP430_8 */
11677 if (uses_msp430x_relocs ())
11678 break;
11679 goto handle_sym_diff;
11680
11681 case 2: /* R_MSP430_ABS16 */
11682 case 15: /* R_MSP430X_ABS16 */
11683 if (! uses_msp430x_relocs ())
11684 break;
11685 goto handle_sym_diff;
0b4362b0 11686
13761a11
NC		 11687 handle_sym_diff:
11688 if (saved_sym != NULL)
11689 {
03f7786e 11690 int reloc_size = reloc_type == 1 ? 4 : 2;
13761a11
NC		 11691 bfd_vma value;
11692
f84ce13b
NC		 11693 if (sym_index >= num_syms)
11694 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
11695 sym_index);
03f7786e 11696 else
f84ce13b
NC		 11697 {
11698 value = reloc->r_addend + (symtab[sym_index].st_value
11699 - saved_sym->st_value);
11700
b32e566b 11701 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
f84ce13b 11702 byte_put (start + reloc->r_offset, value, reloc_size);
b32e566b
NC		 11703 else
11704 /* PR 21137 */
11705 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
11706 (long) reloc->r_offset);
f84ce13b 11707 }
13761a11
NC		 11708
11709 saved_sym = NULL;
11710 return TRUE;
11711 }
11712 break;
11713
11714 default:
11715 if (saved_sym != NULL)
071436c6 11716 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13761a11
NC		 11717 break;
11718 }
11719 break;
11720 }
11721
cf13d699
NC		 11722 case EM_MN10300:
11723 case EM_CYGNUS_MN10300:
11724 {
11725 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 11726
f84ce13b
NC		 11727 if (reloc == NULL)
11728 {
11729 saved_sym = NULL;
11730 return TRUE;
11731 }
11732
cf13d699
NC		 11733 switch (reloc_type)
11734 {
11735 case 34: /* R_MN10300_ALIGN */
11736 return TRUE;
11737 case 33: /* R_MN10300_SYM_DIFF */
f84ce13b
NC		 11738 if (sym_index >= num_syms)
11739 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
11740 sym_index);
11741 else
11742 saved_sym = symtab + sym_index;
cf13d699 11743 return TRUE;
f84ce13b 11744
cf13d699
NC		 11745 case 1: /* R_MN10300_32 */
11746 case 2: /* R_MN10300_16 */
11747 if (saved_sym != NULL)
11748 {
03f7786e 11749 int reloc_size = reloc_type == 1 ? 4 : 2;
cf13d699 11750 bfd_vma value;
252b5132 11751
f84ce13b
NC		 11752 if (sym_index >= num_syms)
11753 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
11754 sym_index);
03f7786e 11755 else
f84ce13b
NC		 11756 {
11757 value = reloc->r_addend + (symtab[sym_index].st_value
11758 - saved_sym->st_value);
11759
b32e566b 11760 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
f84ce13b 11761 byte_put (start + reloc->r_offset, value, reloc_size);
b32e566b
NC		 11762 else
11763 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
11764 (long) reloc->r_offset);
f84ce13b 11765 }
252b5132 11766
cf13d699
NC		 11767 saved_sym = NULL;
11768 return TRUE;
11769 }
11770 break;
11771 default:
11772 if (saved_sym != NULL)
071436c6 11773 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
cf13d699
NC		 11774 break;
11775 }
11776 break;
11777 }
6ff71e76
NC		 11778
11779 case EM_RL78:
11780 {
11781 static bfd_vma saved_sym1 = 0;
11782 static bfd_vma saved_sym2 = 0;
11783 static bfd_vma value;
11784
f84ce13b
NC		 11785 if (reloc == NULL)
11786 {
11787 saved_sym1 = saved_sym2 = 0;
11788 return TRUE;
11789 }
11790
6ff71e76
NC		 11791 switch (reloc_type)
11792 {
11793 case 0x80: /* R_RL78_SYM. */
11794 saved_sym1 = saved_sym2;
f84ce13b
NC		 11795 if (sym_index >= num_syms)
11796 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
11797 sym_index);
11798 else
11799 {
11800 saved_sym2 = symtab[sym_index].st_value;
11801 saved_sym2 += reloc->r_addend;
11802 }
6ff71e76
NC		 11803 return TRUE;
11804
11805 case 0x83: /* R_RL78_OPsub. */
11806 value = saved_sym1 - saved_sym2;
11807 saved_sym2 = saved_sym1 = 0;
11808 return TRUE;
11809 break;
11810
11811 case 0x41: /* R_RL78_ABS32. */
b32e566b 11812 if (IN_RANGE (start, end, start + reloc->r_offset, 4))
03f7786e 11813 byte_put (start + reloc->r_offset, value, 4);
b32e566b
NC		 11814 else
11815 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11816 (long) reloc->r_offset);
6ff71e76
NC		 11817 value = 0;
11818 return TRUE;
11819
11820 case 0x43: /* R_RL78_ABS16. */
b32e566b 11821 if (IN_RANGE (start, end, start + reloc->r_offset, 2))
03f7786e 11822 byte_put (start + reloc->r_offset, value, 2);
b32e566b
NC		 11823 else
11824 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11825 (long) reloc->r_offset);
6ff71e76
NC		 11826 value = 0;
11827 return TRUE;
11828
11829 default:
11830 break;
11831 }
11832 break;
11833 }
252b5132
RH		 11834 }
11835
cf13d699 11836 return FALSE;
252b5132
RH		 11837}
11838
aca88567
NC		 11839/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11840 DWARF debug sections. This is a target specific test. Note - we do not
11841 go through the whole including-target-headers-multiple-times route, (as
11842 we have already done with <elf/h8.h>) because this would become very
11843 messy and even then this function would have to contain target specific
11844 information (the names of the relocs instead of their numeric values).
11845 FIXME: This is not the correct way to solve this problem. The proper way
11846 is to have target specific reloc sizing and typing functions created by
11847 the reloc-macros.h header, in the same way that it already creates the
11848 reloc naming functions. */
11849
11850static bfd_boolean
11851is_32bit_abs_reloc (unsigned int reloc_type)
11852{
d347c9df 11853 /* Please keep this table alpha-sorted for ease of visual lookup. */
aca88567
NC		 11854 switch (elf_header.e_machine)
11855 {
41e92641 11856 case EM_386:
22abe556 11857 case EM_IAMCU:
41e92641 11858 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 11859 case EM_68K:
11860 return reloc_type == 1; /* R_68K_32. */
11861 case EM_860:
11862 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 11863 case EM_960:
11864 return reloc_type == 2; /* R_960_32. */
a06ea964 11865 case EM_AARCH64:
9282b95a
JW		 11866 return (reloc_type == 258
11867 || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
d347c9df
PS		 11868 case EM_ADAPTEVA_EPIPHANY:
11869 return reloc_type == 3;
aca88567 11870 case EM_ALPHA:
137b6b5f 11871 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 11872 case EM_ARC:
11873 return reloc_type == 1; /* R_ARC_32. */
886a2506
NC		 11874 case EM_ARC_COMPACT:
11875 case EM_ARC_COMPACT2:
11876 return reloc_type == 4; /* R_ARC_32. */
41e92641
NC		 11877 case EM_ARM:
11878 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 11879 case EM_AVR_OLD:
aca88567
NC		 11880 case EM_AVR:
11881 return reloc_type == 1;
11882 case EM_BLACKFIN:
11883 return reloc_type == 0x12; /* R_byte4_data. */
11884 case EM_CRIS:
11885 return reloc_type == 3; /* R_CRIS_32. */
11886 case EM_CR16:
11887 return reloc_type == 3; /* R_CR16_NUM32. */
11888 case EM_CRX:
11889 return reloc_type == 15; /* R_CRX_NUM32. */
11890 case EM_CYGNUS_FRV:
11891 return reloc_type == 1;
41e92641
NC		 11892 case EM_CYGNUS_D10V:
11893 case EM_D10V:
11894 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 11895 case EM_CYGNUS_D30V:
11896 case EM_D30V:
11897 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 11898 case EM_DLX:
11899 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 11900 case EM_CYGNUS_FR30:
11901 case EM_FR30:
11902 return reloc_type == 3; /* R_FR30_32. */
3f8107ab
AM		 11903 case EM_FT32:
11904 return reloc_type == 1; /* R_FT32_32. */
aca88567
NC		 11905 case EM_H8S:
11906 case EM_H8_300:
11907 case EM_H8_300H:
11908 return reloc_type == 1; /* R_H8_DIR32. */
3730236a 11909 case EM_IA_64:
d1c4b12b
NC		 11910 return reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
11911 || reloc_type == 0x25; /* R_IA64_DIR32LSB. */
aca88567
NC		 11912 case EM_IP2K_OLD:
11913 case EM_IP2K:
11914 return reloc_type == 2; /* R_IP2K_32. */
11915 case EM_IQ2000:
11916 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 11917 case EM_LATTICEMICO32:
11918 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 11919 case EM_M32C_OLD:
aca88567
NC		 11920 case EM_M32C:
11921 return reloc_type == 3; /* R_M32C_32. */
11922 case EM_M32R:
11923 return reloc_type == 34; /* R_M32R_32_RELA. */
adec12c1
AM		 11924 case EM_68HC11:
11925 case EM_68HC12:
11926 return reloc_type == 6; /* R_M68HC11_32. */
aca88567
NC		 11927 case EM_MCORE:
11928 return reloc_type == 1; /* R_MCORE_ADDR32. */
11929 case EM_CYGNUS_MEP:
11930 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 11931 case EM_METAG:
11932 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 11933 case EM_MICROBLAZE:
11934 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 11935 case EM_MIPS:
11936 return reloc_type == 2; /* R_MIPS_32. */
11937 case EM_MMIX:
11938 return reloc_type == 4; /* R_MMIX_32. */
11939 case EM_CYGNUS_MN10200:
11940 case EM_MN10200:
11941 return reloc_type == 1; /* R_MN10200_32. */
11942 case EM_CYGNUS_MN10300:
11943 case EM_MN10300:
11944 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 11945 case EM_MOXIE:
11946 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 11947 case EM_MSP430_OLD:
11948 case EM_MSP430:
13761a11 11949 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
aca88567
NC		 11950 case EM_MT:
11951 return reloc_type == 2; /* R_MT_32. */
35c08157
KLC		 11952 case EM_NDS32:
11953 return reloc_type == 20; /* R_NDS32_RELA. */
3e0873ac 11954 case EM_ALTERA_NIOS2:
36591ba1 11955 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
3e0873ac
NC		 11956 case EM_NIOS32:
11957 return reloc_type == 1; /* R_NIOS_32. */
73589c9d
CS		 11958 case EM_OR1K:
11959 return reloc_type == 1; /* R_OR1K_32. */
aca88567 11960 case EM_PARISC:
5fda8eca
NC		 11961 return (reloc_type == 1 /* R_PARISC_DIR32. */
11962 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 11963 case EM_PJ:
11964 case EM_PJ_OLD:
11965 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
11966 case EM_PPC64:
11967 return reloc_type == 1; /* R_PPC64_ADDR32. */
11968 case EM_PPC:
11969 return reloc_type == 1; /* R_PPC_ADDR32. */
2b100bb5
DD		 11970 case EM_TI_PRU:
11971 return reloc_type == 11; /* R_PRU_BFD_RELOC_32. */
e23eba97
NC		 11972 case EM_RISCV:
11973 return reloc_type == 1; /* R_RISCV_32. */
99c513f6
DD		 11974 case EM_RL78:
11975 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 11976 case EM_RX:
11977 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 11978 case EM_S370:
11979 return reloc_type == 1; /* R_I370_ADDR31. */
11980 case EM_S390_OLD:
11981 case EM_S390:
11982 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 11983 case EM_SCORE:
11984 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 11985 case EM_SH:
11986 return reloc_type == 1; /* R_SH_DIR32. */
11987 case EM_SPARC32PLUS:
11988 case EM_SPARCV9:
11989 case EM_SPARC:
11990 return reloc_type == 3 /* R_SPARC_32. */
11991 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 11992 case EM_SPU:
11993 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 11994 case EM_TI_C6000:
11995 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 11996 case EM_TILEGX:
11997 return reloc_type == 2; /* R_TILEGX_32. */
11998 case EM_TILEPRO:
11999 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 12000 case EM_CYGNUS_V850:
12001 case EM_V850:
12002 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 12003 case EM_V800:
12004 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 12005 case EM_VAX:
12006 return reloc_type == 1; /* R_VAX_32. */
619ed720
EB		 12007 case EM_VISIUM:
12008 return reloc_type == 3; /* R_VISIUM_32. */
aca88567 12009 case EM_X86_64:
8a9036a4 12010 case EM_L1OM:
7a9068fe 12011 case EM_K1OM:
aca88567 12012 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 12013 case EM_XC16X:
12014 case EM_C166:
12015 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 12016 case EM_XGATE:
12017 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 12018 case EM_XSTORMY16:
12019 return reloc_type == 1; /* R_XSTROMY16_32. */
12020 case EM_XTENSA_OLD:
12021 case EM_XTENSA:
12022 return reloc_type == 1; /* R_XTENSA_32. */
aca88567 12023 default:
bee0ee85
NC		 12024 {
12025 static unsigned int prev_warn = 0;
12026
12027 /* Avoid repeating the same warning multiple times. */
12028 if (prev_warn != elf_header.e_machine)
12029 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12030 elf_header.e_machine);
12031 prev_warn = elf_header.e_machine;
12032 return FALSE;
12033 }
aca88567
NC		 12034 }
12035}
12036
12037/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12038 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12039
12040static bfd_boolean
12041is_32bit_pcrel_reloc (unsigned int reloc_type)
12042{
12043 switch (elf_header.e_machine)
d347c9df 12044 /* Please keep this table alpha-sorted for ease of visual lookup. */
aca88567 12045 {
41e92641 12046 case EM_386:
22abe556 12047 case EM_IAMCU:
3e0873ac 12048 return reloc_type == 2; /* R_386_PC32. */
aca88567 12049 case EM_68K:
3e0873ac 12050 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 12051 case EM_AARCH64:
12052 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 12053 case EM_ADAPTEVA_EPIPHANY:
12054 return reloc_type == 6;
aca88567
NC		 12055 case EM_ALPHA:
12056 return reloc_type == 10; /* R_ALPHA_SREL32. */
726c18e1
CZ		 12057 case EM_ARC_COMPACT:
12058 case EM_ARC_COMPACT2:
12059 return reloc_type == 49; /* R_ARC_32_PCREL. */
41e92641 12060 case EM_ARM:
3e0873ac 12061 return reloc_type == 3; /* R_ARM_REL32 */
d347c9df
PS		 12062 case EM_AVR_OLD:
12063 case EM_AVR:
12064 return reloc_type == 36; /* R_AVR_32_PCREL. */
137b6b5f
AM		 12065 case EM_MICROBLAZE:
12066 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
73589c9d
CS		 12067 case EM_OR1K:
12068 return reloc_type == 9; /* R_OR1K_32_PCREL. */
aca88567 12069 case EM_PARISC:
85acf597 12070 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 12071 case EM_PPC:
12072 return reloc_type == 26; /* R_PPC_REL32. */
12073 case EM_PPC64:
3e0873ac 12074 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 12075 case EM_S390_OLD:
12076 case EM_S390:
3e0873ac 12077 return reloc_type == 5; /* R_390_PC32. */
aca88567 12078 case EM_SH:
3e0873ac 12079 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 12080 case EM_SPARC32PLUS:
12081 case EM_SPARCV9:
12082 case EM_SPARC:
3e0873ac 12083 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 12084 case EM_SPU:
12085 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 12086 case EM_TILEGX:
12087 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
12088 case EM_TILEPRO:
12089 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
619ed720
EB		 12090 case EM_VISIUM:
12091 return reloc_type == 6; /* R_VISIUM_32_PCREL */
aca88567 12092 case EM_X86_64:
8a9036a4 12093 case EM_L1OM:
7a9068fe 12094 case EM_K1OM:
3e0873ac 12095 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 12096 case EM_XTENSA_OLD:
12097 case EM_XTENSA:
12098 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 12099 default:
12100 /* Do not abort or issue an error message here. Not all targets use
12101 pc-relative 32-bit relocs in their DWARF debug information and we
12102 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 12103 more helpful warning message will be generated by apply_relocations
12104 anyway, so just return. */
aca88567
NC		 12105 return FALSE;
12106 }
12107}
12108
12109/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12110 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12111
12112static bfd_boolean
12113is_64bit_abs_reloc (unsigned int reloc_type)
12114{
12115 switch (elf_header.e_machine)
12116 {
a06ea964
NC		 12117 case EM_AARCH64:
12118 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 12119 case EM_ALPHA:
12120 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 12121 case EM_IA_64:
12122 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 12123 case EM_PARISC:
12124 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 12125 case EM_PPC64:
12126 return reloc_type == 38; /* R_PPC64_ADDR64. */
e23eba97
NC		 12127 case EM_RISCV:
12128 return reloc_type == 2; /* R_RISCV_64. */
aca88567
NC		 12129 case EM_SPARC32PLUS:
12130 case EM_SPARCV9:
12131 case EM_SPARC:
12132 return reloc_type == 54; /* R_SPARC_UA64. */
12133 case EM_X86_64:
8a9036a4 12134 case EM_L1OM:
7a9068fe 12135 case EM_K1OM:
aca88567 12136 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 12137 case EM_S390_OLD:
12138 case EM_S390:
aa137e4d
NC		 12139 return reloc_type == 22; /* R_S390_64. */
12140 case EM_TILEGX:
12141 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 12142 case EM_MIPS:
aa137e4d 12143 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 12144 default:
12145 return FALSE;
12146 }
12147}
12148
85acf597
RH		 12149/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12150 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12151
12152static bfd_boolean
12153is_64bit_pcrel_reloc (unsigned int reloc_type)
12154{
12155 switch (elf_header.e_machine)
12156 {
a06ea964
NC		 12157 case EM_AARCH64:
12158 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 12159 case EM_ALPHA:
aa137e4d 12160 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 12161 case EM_IA_64:
aa137e4d 12162 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 12163 case EM_PARISC:
aa137e4d 12164 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 12165 case EM_PPC64:
aa137e4d 12166 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 12167 case EM_SPARC32PLUS:
12168 case EM_SPARCV9:
12169 case EM_SPARC:
aa137e4d 12170 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 12171 case EM_X86_64:
8a9036a4 12172 case EM_L1OM:
7a9068fe 12173 case EM_K1OM:
aa137e4d 12174 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 12175 case EM_S390_OLD:
12176 case EM_S390:
aa137e4d
NC		 12177 return reloc_type == 23; /* R_S390_PC64. */
12178 case EM_TILEGX:
12179 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 12180 default:
12181 return FALSE;
12182 }
12183}
12184
4dc3c23d
AM		 12185/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12186 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12187
12188static bfd_boolean
12189is_24bit_abs_reloc (unsigned int reloc_type)
12190{
12191 switch (elf_header.e_machine)
12192 {
12193 case EM_CYGNUS_MN10200:
12194 case EM_MN10200:
12195 return reloc_type == 4; /* R_MN10200_24. */
3ee6e4fb
NC		 12196 case EM_FT32:
12197 return reloc_type == 5; /* R_FT32_20. */
4dc3c23d
AM		 12198 default:
12199 return FALSE;
12200 }
12201}
12202
aca88567
NC		 12203/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12204 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12205
12206static bfd_boolean
12207is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a 12208{
d347c9df 12209 /* Please keep this table alpha-sorted for ease of visual lookup. */
4b78141a
NC		 12210 switch (elf_header.e_machine)
12211 {
886a2506
NC		 12212 case EM_ARC:
12213 case EM_ARC_COMPACT:
12214 case EM_ARC_COMPACT2:
12215 return reloc_type == 2; /* R_ARC_16. */
d347c9df
PS		 12216 case EM_ADAPTEVA_EPIPHANY:
12217 return reloc_type == 5;
aca88567
NC		 12218 case EM_AVR_OLD:
12219 case EM_AVR:
12220 return reloc_type == 4; /* R_AVR_16. */
41e92641
NC		 12221 case EM_CYGNUS_D10V:
12222 case EM_D10V:
12223 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 12224 case EM_H8S:
12225 case EM_H8_300:
12226 case EM_H8_300H:
aca88567
NC		 12227 return reloc_type == R_H8_DIR16;
12228 case EM_IP2K_OLD:
12229 case EM_IP2K:
12230 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 12231 case EM_M32C_OLD:
f4236fe4
DD		 12232 case EM_M32C:
12233 return reloc_type == 1; /* R_M32C_16 */
d347c9df
PS		 12234 case EM_CYGNUS_MN10200:
12235 case EM_MN10200:
12236 return reloc_type == 2; /* R_MN10200_16. */
12237 case EM_CYGNUS_MN10300:
12238 case EM_MN10300:
12239 return reloc_type == 2; /* R_MN10300_16. */
aca88567 12240 case EM_MSP430:
13761a11
NC		 12241 if (uses_msp430x_relocs ())
12242 return reloc_type == 2; /* R_MSP430_ABS16. */
1a0670f3 12243 /* Fall through. */
78c8d46c 12244 case EM_MSP430_OLD:
aca88567 12245 return reloc_type == 5; /* R_MSP430_16_BYTE. */
35c08157
KLC		 12246 case EM_NDS32:
12247 return reloc_type == 19; /* R_NDS32_RELA. */
3e0873ac 12248 case EM_ALTERA_NIOS2:
36591ba1 12249 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
3e0873ac
NC		 12250 case EM_NIOS32:
12251 return reloc_type == 9; /* R_NIOS_16. */
73589c9d
CS		 12252 case EM_OR1K:
12253 return reloc_type == 2; /* R_OR1K_16. */
2b100bb5
DD		 12254 case EM_TI_PRU:
12255 return reloc_type == 8; /* R_PRU_BFD_RELOC_16. */
40b36596
JM		 12256 case EM_TI_C6000:
12257 return reloc_type == 2; /* R_C6000_ABS16. */
d347c9df
PS		 12258 case EM_VISIUM:
12259 return reloc_type == 2; /* R_VISIUM_16. */
c29aca4a
NC		 12260 case EM_XC16X:
12261 case EM_C166:
12262 return reloc_type == 2; /* R_XC16C_ABS_16. */
f6c1a2d5
NC		 12263 case EM_XGATE:
12264 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 12265 default:
aca88567 12266 return FALSE;
4b78141a
NC		 12267 }
12268}
12269
2a7b2e88
JK		 12270/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12271 relocation entries (possibly formerly used for SHT_GROUP sections). */
12272
12273static bfd_boolean
12274is_none_reloc (unsigned int reloc_type)
12275{
12276 switch (elf_header.e_machine)
12277 {
cb8f3167 12278 case EM_386: /* R_386_NONE. */
d347c9df 12279 case EM_68K: /* R_68K_NONE. */
cfb8c092 12280 case EM_ADAPTEVA_EPIPHANY:
d347c9df
PS		 12281 case EM_ALPHA: /* R_ALPHA_NONE. */
12282 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
886a2506 12283 case EM_ARC: /* R_ARC_NONE. */
886a2506 12284 case EM_ARC_COMPACT2: /* R_ARC_NONE. */
d347c9df 12285 case EM_ARC_COMPACT: /* R_ARC_NONE. */
cb8f3167 12286 case EM_ARM: /* R_ARM_NONE. */
d347c9df 12287 case EM_C166: /* R_XC16X_NONE. */
cb8f3167 12288 case EM_CRIS: /* R_CRIS_NONE. */
d347c9df
PS		 12289 case EM_FT32: /* R_FT32_NONE. */
12290 case EM_IA_64: /* R_IA64_NONE. */
7a9068fe 12291 case EM_K1OM: /* R_X86_64_NONE. */
d347c9df
PS		 12292 case EM_L1OM: /* R_X86_64_NONE. */
12293 case EM_M32R: /* R_M32R_NONE. */
12294 case EM_MIPS: /* R_MIPS_NONE. */
cb8f3167 12295 case EM_MN10300: /* R_MN10300_NONE. */
5506d11a 12296 case EM_MOXIE: /* R_MOXIE_NONE. */
d347c9df
PS		 12297 case EM_NIOS32: /* R_NIOS_NONE. */
12298 case EM_OR1K: /* R_OR1K_NONE. */
12299 case EM_PARISC: /* R_PARISC_NONE. */
12300 case EM_PPC64: /* R_PPC64_NONE. */
12301 case EM_PPC: /* R_PPC_NONE. */
e23eba97 12302 case EM_RISCV: /* R_RISCV_NONE. */
d347c9df
PS		 12303 case EM_S390: /* R_390_NONE. */
12304 case EM_S390_OLD:
12305 case EM_SH: /* R_SH_NONE. */
12306 case EM_SPARC32PLUS:
12307 case EM_SPARC: /* R_SPARC_NONE. */
12308 case EM_SPARCV9:
aa137e4d
NC		 12309 case EM_TILEGX: /* R_TILEGX_NONE. */
12310 case EM_TILEPRO: /* R_TILEPRO_NONE. */
d347c9df
PS		 12311 case EM_TI_C6000:/* R_C6000_NONE. */
12312 case EM_X86_64: /* R_X86_64_NONE. */
c29aca4a 12313 case EM_XC16X:
cb8f3167 12314 return reloc_type == 0;
d347c9df 12315
a06ea964
NC		 12316 case EM_AARCH64:
12317 return reloc_type == 0 || reloc_type == 256;
d347c9df
PS		 12318 case EM_AVR_OLD:
12319 case EM_AVR:
12320 return (reloc_type == 0 /* R_AVR_NONE. */
12321 || reloc_type == 30 /* R_AVR_DIFF8. */
12322 || reloc_type == 31 /* R_AVR_DIFF16. */
12323 || reloc_type == 32 /* R_AVR_DIFF32. */);
12324 case EM_METAG:
12325 return reloc_type == 3; /* R_METAG_NONE. */
35c08157
KLC		 12326 case EM_NDS32:
12327 return (reloc_type == 0 /* R_XTENSA_NONE. */
12328 || reloc_type == 204 /* R_NDS32_DIFF8. */
12329 || reloc_type == 205 /* R_NDS32_DIFF16. */
12330 || reloc_type == 206 /* R_NDS32_DIFF32. */
12331 || reloc_type == 207 /* R_NDS32_ULEB128. */);
2b100bb5
DD		 12332 case EM_TI_PRU:
12333 return (reloc_type == 0 /* R_PRU_NONE. */
12334 || reloc_type == 65 /* R_PRU_DIFF8. */
12335 || reloc_type == 66 /* R_PRU_DIFF16. */
12336 || reloc_type == 67 /* R_PRU_DIFF32. */);
58332dda
JK		 12337 case EM_XTENSA_OLD:
12338 case EM_XTENSA:
4dc3c23d
AM		 12339 return (reloc_type == 0 /* R_XTENSA_NONE. */
12340 || reloc_type == 17 /* R_XTENSA_DIFF8. */
12341 || reloc_type == 18 /* R_XTENSA_DIFF16. */
12342 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
2a7b2e88
JK		 12343 }
12344 return FALSE;
12345}
12346
d1c4b12b
NC		 12347/* Returns TRUE if there is a relocation against
12348 section NAME at OFFSET bytes. */
12349
12350bfd_boolean
12351reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
12352{
12353 Elf_Internal_Rela * relocs;
12354 Elf_Internal_Rela * rp;
12355
12356 if (dsec == NULL || dsec->reloc_info == NULL)
12357 return FALSE;
12358
12359 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
12360
12361 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
12362 if (rp->r_offset == offset)
12363 return TRUE;
12364
12365 return FALSE;
12366}
12367
cf13d699
NC		 12368/* Apply relocations to a section.
12369 Note: So far support has been added only for those relocations
12370 which can be found in debug sections.
d1c4b12b
NC		 12371 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
12372 loaded relocs. It is then the caller's responsibility to free them.
cf13d699 12373 FIXME: Add support for more relocations ? */
1b315056 12374
cf13d699 12375static void
d1c4b12b
NC		 12376apply_relocations (void * file,
12377 const Elf_Internal_Shdr * section,
12378 unsigned char * start,
12379 bfd_size_type size,
1449284b 12380 void ** relocs_return,
d1c4b12b 12381 unsigned long * num_relocs_return)
1b315056 12382{
cf13d699 12383 Elf_Internal_Shdr * relsec;
0d2a7a93 12384 unsigned char * end = start + size;
cb8f3167 12385
d1c4b12b
NC		 12386 if (relocs_return != NULL)
12387 {
12388 * (Elf_Internal_Rela **) relocs_return = NULL;
12389 * num_relocs_return = 0;
12390 }
12391
cf13d699
NC		 12392 if (elf_header.e_type != ET_REL)
12393 return;
1b315056 12394
cf13d699 12395 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 12396 for (relsec = section_headers;
12397 relsec < section_headers + elf_header.e_shnum;
12398 ++relsec)
252b5132 12399 {
41e92641
NC		 12400 bfd_boolean is_rela;
12401 unsigned long num_relocs;
2cf0635d
NC		 12402 Elf_Internal_Rela * relocs;
12403 Elf_Internal_Rela * rp;
12404 Elf_Internal_Shdr * symsec;
12405 Elf_Internal_Sym * symtab;
ba5cdace 12406 unsigned long num_syms;
2cf0635d 12407 Elf_Internal_Sym * sym;
252b5132 12408
41e92641 12409 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 12410 || relsec->sh_info >= elf_header.e_shnum
12411 || section_headers + relsec->sh_info != section
c256ffe7 12412 || relsec->sh_size == 0
4fbb74a6 12413 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 12414 continue;
428409d5 12415
41e92641
NC		 12416 is_rela = relsec->sh_type == SHT_RELA;
12417
12418 if (is_rela)
12419 {
3f5e193b
NC		 12420 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
12421 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 12422 return;
12423 }
12424 else
12425 {
3f5e193b
NC		 12426 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
12427 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 12428 return;
12429 }
12430
12431 /* SH uses RELA but uses in place value instead of the addend field. */
12432 if (elf_header.e_machine == EM_SH)
12433 is_rela = FALSE;
428409d5 12434
4fbb74a6 12435 symsec = section_headers + relsec->sh_link;
1449284b
NC		 12436 if (symsec->sh_type != SHT_SYMTAB
12437 && symsec->sh_type != SHT_DYNSYM)
12438 return;
ba5cdace 12439 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 12440
41e92641 12441 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 12442 {
41e92641
NC		 12443 bfd_vma addend;
12444 unsigned int reloc_type;
12445 unsigned int reloc_size;
91d6fa6a 12446 unsigned char * rloc;
ba5cdace 12447 unsigned long sym_index;
4b78141a 12448
aca88567 12449 reloc_type = get_reloc_type (rp->r_info);
41e92641 12450
f84ce13b 12451 if (target_specific_reloc_handling (rp, start, end, symtab, num_syms))
2a7b2e88 12452 continue;
98fb390a
NC		 12453 else if (is_none_reloc (reloc_type))
12454 continue;
12455 else if (is_32bit_abs_reloc (reloc_type)
12456 || is_32bit_pcrel_reloc (reloc_type))
aca88567 12457 reloc_size = 4;
85acf597
RH		 12458 else if (is_64bit_abs_reloc (reloc_type)
12459 || is_64bit_pcrel_reloc (reloc_type))
aca88567 12460 reloc_size = 8;
4dc3c23d
AM		 12461 else if (is_24bit_abs_reloc (reloc_type))
12462 reloc_size = 3;
aca88567
NC		 12463 else if (is_16bit_abs_reloc (reloc_type))
12464 reloc_size = 2;
12465 else
4b78141a 12466 {
bee0ee85
NC		 12467 static unsigned int prev_reloc = 0;
12468 if (reloc_type != prev_reloc)
12469 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12470 reloc_type, printable_section_name (section));
12471 prev_reloc = reloc_type;
4b78141a
NC		 12472 continue;
12473 }
103f02d3 12474
91d6fa6a 12475 rloc = start + rp->r_offset;
c8da6823 12476 if ((rloc + reloc_size) > end || (rloc < start))
700dd8b7
L		 12477 {
12478 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12479 (unsigned long) rp->r_offset,
74e1a04b 12480 printable_section_name (section));
700dd8b7
L		 12481 continue;
12482 }
103f02d3 12483
ba5cdace
NC		 12484 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
12485 if (sym_index >= num_syms)
12486 {
12487 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
74e1a04b 12488 sym_index, printable_section_name (section));
ba5cdace
NC		 12489 continue;
12490 }
12491 sym = symtab + sym_index;
41e92641
NC		 12492
12493 /* If the reloc has a symbol associated with it,
55f25fc3
L		 12494 make sure that it is of an appropriate type.
12495
12496 Relocations against symbols without type can happen.
12497 Gcc -feliminate-dwarf2-dups may generate symbols
12498 without type for debug info.
12499
12500 Icc generates relocations against function symbols
12501 instead of local labels.
12502
12503 Relocations against object symbols can happen, eg when
12504 referencing a global array. For an example of this see
12505 the _clz.o binary in libgcc.a. */
aca88567 12506 if (sym != symtab
b8871f35 12507 && ELF_ST_TYPE (sym->st_info) != STT_COMMON
55f25fc3 12508 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 12509 {
41e92641 12510 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 12511 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 12512 (long int)(rp - relocs),
74e1a04b 12513 printable_section_name (relsec));
aca88567 12514 continue;
5b18a4bc 12515 }
252b5132 12516
4dc3c23d
AM		 12517 addend = 0;
12518 if (is_rela)
12519 addend += rp->r_addend;
c47320c3
AM		 12520 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12521 partial_inplace. */
4dc3c23d
AM		 12522 if (!is_rela
12523 || (elf_header.e_machine == EM_XTENSA
12524 && reloc_type == 1)
12525 || ((elf_header.e_machine == EM_PJ
12526 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 12527 && reloc_type == 1)
12528 || ((elf_header.e_machine == EM_D30V
12529 || elf_header.e_machine == EM_CYGNUS_D30V)
12530 && reloc_type == 12))
91d6fa6a 12531 addend += byte_get (rloc, reloc_size);
cb8f3167 12532
85acf597
RH		 12533 if (is_32bit_pcrel_reloc (reloc_type)
12534 || is_64bit_pcrel_reloc (reloc_type))
12535 {
12536 /* On HPPA, all pc-relative relocations are biased by 8. */
12537 if (elf_header.e_machine == EM_PARISC)
12538 addend -= 8;
91d6fa6a 12539 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 12540 reloc_size);
12541 }
41e92641 12542 else
91d6fa6a 12543 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 12544 }
252b5132 12545
5b18a4bc 12546 free (symtab);
f84ce13b
NC		 12547 /* Let the target specific reloc processing code know that
12548 we have finished with these relocs. */
12549 target_specific_reloc_handling (NULL, NULL, NULL, NULL, 0);
d1c4b12b
NC		 12550
12551 if (relocs_return)
12552 {
12553 * (Elf_Internal_Rela **) relocs_return = relocs;
12554 * num_relocs_return = num_relocs;
12555 }
12556 else
12557 free (relocs);
12558
5b18a4bc
NC		 12559 break;
12560 }
5b18a4bc 12561}
103f02d3 12562
cf13d699
NC		 12563#ifdef SUPPORT_DISASSEMBLY
12564static int
12565disassemble_section (Elf_Internal_Shdr * section, FILE * file)
12566{
74e1a04b 12567 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
cf13d699 12568
74e1a04b 12569 /* FIXME: XXX -- to be done --- XXX */
cf13d699
NC		 12570
12571 return 1;
12572}
12573#endif
12574
12575/* Reads in the contents of SECTION from FILE, returning a pointer
12576 to a malloc'ed buffer or NULL if something went wrong. */
12577
12578static char *
12579get_section_contents (Elf_Internal_Shdr * section, FILE * file)
12580{
12581 bfd_size_type num_bytes;
12582
12583 num_bytes = section->sh_size;
12584
12585 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
12586 {
12587 printf (_("\nSection '%s' has no data to dump.\n"),
74e1a04b 12588 printable_section_name (section));
cf13d699
NC		 12589 return NULL;
12590 }
12591
3f5e193b
NC		 12592 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
12593 _("section contents"));
cf13d699
NC		 12594}
12595
0e602686
NC		 12596/* Uncompresses a section that was compressed using zlib, in place. */
12597
12598static bfd_boolean
12599uncompress_section_contents (unsigned char **buffer,
12600 dwarf_size_type uncompressed_size,
12601 dwarf_size_type *size)
12602{
12603 dwarf_size_type compressed_size = *size;
12604 unsigned char * compressed_buffer = *buffer;
12605 unsigned char * uncompressed_buffer;
12606 z_stream strm;
12607 int rc;
12608
12609 /* It is possible the section consists of several compressed
12610 buffers concatenated together, so we uncompress in a loop. */
12611 /* PR 18313: The state field in the z_stream structure is supposed
12612 to be invisible to the user (ie us), but some compilers will
12613 still complain about it being used without initialisation. So
12614 we first zero the entire z_stream structure and then set the fields
12615 that we need. */
12616 memset (& strm, 0, sizeof strm);
12617 strm.avail_in = compressed_size;
12618 strm.next_in = (Bytef *) compressed_buffer;
12619 strm.avail_out = uncompressed_size;
12620 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
12621
12622 rc = inflateInit (& strm);
12623 while (strm.avail_in > 0)
12624 {
12625 if (rc != Z_OK)
12626 goto fail;
12627 strm.next_out = ((Bytef *) uncompressed_buffer
12628 + (uncompressed_size - strm.avail_out));
12629 rc = inflate (&strm, Z_FINISH);
12630 if (rc != Z_STREAM_END)
12631 goto fail;
12632 rc = inflateReset (& strm);
12633 }
12634 rc = inflateEnd (& strm);
12635 if (rc != Z_OK
12636 || strm.avail_out != 0)
12637 goto fail;
12638
12639 *buffer = uncompressed_buffer;
12640 *size = uncompressed_size;
12641 return TRUE;
12642
12643 fail:
12644 free (uncompressed_buffer);
12645 /* Indicate decompression failure. */
12646 *buffer = NULL;
12647 return FALSE;
12648}
dd24e3da 12649
cf13d699
NC		 12650static void
12651dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12652{
0e602686
NC		 12653 Elf_Internal_Shdr * relsec;
12654 bfd_size_type num_bytes;
fd8008d8
L		 12655 unsigned char * data;
12656 unsigned char * end;
12657 unsigned char * real_start;
12658 unsigned char * start;
0e602686 12659 bfd_boolean some_strings_shown;
cf13d699 12660
fd8008d8
L		 12661 real_start = start = (unsigned char *) get_section_contents (section,
12662 file);
cf13d699
NC		 12663 if (start == NULL)
12664 return;
0e602686 12665 num_bytes = section->sh_size;
cf13d699 12666
74e1a04b 12667 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
cf13d699 12668
0e602686
NC		 12669 if (decompress_dumps)
12670 {
12671 dwarf_size_type new_size = num_bytes;
12672 dwarf_size_type uncompressed_size = 0;
12673
12674 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12675 {
12676 Elf_Internal_Chdr chdr;
12677 unsigned int compression_header_size
ebdf1ebf
NC		 12678 = get_compression_header (& chdr, (unsigned char *) start,
12679 num_bytes);
0e602686 12680
813dabb9 12681 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
0e602686 12682 {
813dabb9
L		 12683 warn (_("section '%s' has unsupported compress type: %d\n"),
12684 printable_section_name (section), chdr.ch_type);
12685 return;
12686 }
12687 else if (chdr.ch_addralign != section->sh_addralign)
12688 {
12689 warn (_("compressed section '%s' is corrupted\n"),
12690 printable_section_name (section));
12691 return;
0e602686 12692 }
813dabb9
L		 12693 uncompressed_size = chdr.ch_size;
12694 start += compression_header_size;
12695 new_size -= compression_header_size;
0e602686
NC		 12696 }
12697 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12698 {
12699 /* Read the zlib header. In this case, it should be "ZLIB"
12700 followed by the uncompressed section size, 8 bytes in
12701 big-endian order. */
12702 uncompressed_size = start[4]; uncompressed_size <<= 8;
12703 uncompressed_size += start[5]; uncompressed_size <<= 8;
12704 uncompressed_size += start[6]; uncompressed_size <<= 8;
12705 uncompressed_size += start[7]; uncompressed_size <<= 8;
12706 uncompressed_size += start[8]; uncompressed_size <<= 8;
12707 uncompressed_size += start[9]; uncompressed_size <<= 8;
12708 uncompressed_size += start[10]; uncompressed_size <<= 8;
12709 uncompressed_size += start[11];
12710 start += 12;
12711 new_size -= 12;
12712 }
12713
1835f746
NC		 12714 if (uncompressed_size)
12715 {
12716 if (uncompress_section_contents (& start,
12717 uncompressed_size, & new_size))
12718 num_bytes = new_size;
12719 else
12720 {
12721 error (_("Unable to decompress section %s\n"),
12722 printable_section_name (section));
12723 return;
12724 }
12725 }
bc303e5d
NC		 12726 else
12727 start = real_start;
0e602686 12728 }
fd8008d8 12729
cf13d699
NC		 12730 /* If the section being dumped has relocations against it the user might
12731 be expecting these relocations to have been applied. Check for this
12732 case and issue a warning message in order to avoid confusion.
12733 FIXME: Maybe we ought to have an option that dumps a section with
12734 relocs applied ? */
12735 for (relsec = section_headers;
12736 relsec < section_headers + elf_header.e_shnum;
12737 ++relsec)
12738 {
12739 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12740 || relsec->sh_info >= elf_header.e_shnum
12741 || section_headers + relsec->sh_info != section
12742 || relsec->sh_size == 0
12743 || relsec->sh_link >= elf_header.e_shnum)
12744 continue;
12745
12746 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12747 break;
12748 }
12749
cf13d699
NC		 12750 data = start;
12751 end = start + num_bytes;
12752 some_strings_shown = FALSE;
12753
12754 while (data < end)
12755 {
12756 while (!ISPRINT (* data))
12757 if (++ data >= end)
12758 break;
12759
12760 if (data < end)
12761 {
071436c6
NC		 12762 size_t maxlen = end - data;
12763
cf13d699 12764#ifndef __MSVCRT__
c975cc98
NC		 12765 /* PR 11128: Use two separate invocations in order to work
12766 around bugs in the Solaris 8 implementation of printf. */
12767 printf (" [%6tx] ", data - start);
cf13d699 12768#else
071436c6 12769 printf (" [%6Ix] ", (size_t) (data - start));
cf13d699 12770#endif
4082ef84
NC		 12771 if (maxlen > 0)
12772 {
fd8008d8 12773 print_symbol ((int) maxlen, (const char *) data);
4082ef84 12774 putchar ('\n');
fd8008d8 12775 data += strnlen ((const char *) data, maxlen);
4082ef84
NC		 12776 }
12777 else
12778 {
12779 printf (_("<corrupt>\n"));
12780 data = end;
12781 }
cf13d699
NC		 12782 some_strings_shown = TRUE;
12783 }
12784 }
12785
12786 if (! some_strings_shown)
12787 printf (_(" No strings found in this section."));
12788
0e602686 12789 free (real_start);
cf13d699
NC		 12790
12791 putchar ('\n');
12792}
12793
12794static void
12795dump_section_as_bytes (Elf_Internal_Shdr * section,
12796 FILE * file,
12797 bfd_boolean relocate)
12798{
12799 Elf_Internal_Shdr * relsec;
0e602686
NC		 12800 bfd_size_type bytes;
12801 bfd_size_type section_size;
12802 bfd_vma addr;
12803 unsigned char * data;
12804 unsigned char * real_start;
12805 unsigned char * start;
12806
12807 real_start = start = (unsigned char *) get_section_contents (section, file);
cf13d699
NC		 12808 if (start == NULL)
12809 return;
0e602686 12810 section_size = section->sh_size;
cf13d699 12811
74e1a04b 12812 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
cf13d699 12813
0e602686
NC		 12814 if (decompress_dumps)
12815 {
12816 dwarf_size_type new_size = section_size;
12817 dwarf_size_type uncompressed_size = 0;
12818
12819 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12820 {
12821 Elf_Internal_Chdr chdr;
12822 unsigned int compression_header_size
ebdf1ebf 12823 = get_compression_header (& chdr, start, section_size);
0e602686 12824
813dabb9 12825 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
0e602686 12826 {
813dabb9
L		 12827 warn (_("section '%s' has unsupported compress type: %d\n"),
12828 printable_section_name (section), chdr.ch_type);
12829 return;
0e602686 12830 }
813dabb9
L		 12831 else if (chdr.ch_addralign != section->sh_addralign)
12832 {
12833 warn (_("compressed section '%s' is corrupted\n"),
12834 printable_section_name (section));
12835 return;
12836 }
12837 uncompressed_size = chdr.ch_size;
12838 start += compression_header_size;
12839 new_size -= compression_header_size;
0e602686
NC		 12840 }
12841 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12842 {
12843 /* Read the zlib header. In this case, it should be "ZLIB"
12844 followed by the uncompressed section size, 8 bytes in
12845 big-endian order. */
12846 uncompressed_size = start[4]; uncompressed_size <<= 8;
12847 uncompressed_size += start[5]; uncompressed_size <<= 8;
12848 uncompressed_size += start[6]; uncompressed_size <<= 8;
12849 uncompressed_size += start[7]; uncompressed_size <<= 8;
12850 uncompressed_size += start[8]; uncompressed_size <<= 8;
12851 uncompressed_size += start[9]; uncompressed_size <<= 8;
12852 uncompressed_size += start[10]; uncompressed_size <<= 8;
12853 uncompressed_size += start[11];
12854 start += 12;
12855 new_size -= 12;
12856 }
12857
f055032e
NC		 12858 if (uncompressed_size)
12859 {
12860 if (uncompress_section_contents (& start, uncompressed_size,
12861 & new_size))
bc303e5d
NC		 12862 {
12863 section_size = new_size;
12864 }
f055032e
NC		 12865 else
12866 {
12867 error (_("Unable to decompress section %s\n"),
12868 printable_section_name (section));
bc303e5d 12869 /* FIXME: Print the section anyway ? */
f055032e
NC		 12870 return;
12871 }
12872 }
bc303e5d
NC		 12873 else
12874 start = real_start;
0e602686 12875 }
14ae95f2 12876
cf13d699
NC		 12877 if (relocate)
12878 {
0e602686 12879 apply_relocations (file, section, start, section_size, NULL, NULL);
cf13d699
NC		 12880 }
12881 else
12882 {
12883 /* If the section being dumped has relocations against it the user might
12884 be expecting these relocations to have been applied. Check for this
12885 case and issue a warning message in order to avoid confusion.
12886 FIXME: Maybe we ought to have an option that dumps a section with
12887 relocs applied ? */
12888 for (relsec = section_headers;
12889 relsec < section_headers + elf_header.e_shnum;
12890 ++relsec)
12891 {
12892 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12893 || relsec->sh_info >= elf_header.e_shnum
12894 || section_headers + relsec->sh_info != section
12895 || relsec->sh_size == 0
12896 || relsec->sh_link >= elf_header.e_shnum)
12897 continue;
12898
12899 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12900 break;
12901 }
12902 }
12903
12904 addr = section->sh_addr;
0e602686 12905 bytes = section_size;
cf13d699
NC		 12906 data = start;
12907
12908 while (bytes)
12909 {
12910 int j;
12911 int k;
12912 int lbytes;
12913
12914 lbytes = (bytes > 16 ? 16 : bytes);
12915
12916 printf (" 0x%8.8lx ", (unsigned long) addr);
12917
12918 for (j = 0; j < 16; j++)
12919 {
12920 if (j < lbytes)
12921 printf ("%2.2x", data[j]);
12922 else
12923 printf (" ");
12924
12925 if ((j & 3) == 3)
12926 printf (" ");
12927 }
12928
12929 for (j = 0; j < lbytes; j++)
12930 {
12931 k = data[j];
12932 if (k >= ' ' && k < 0x7f)
12933 printf ("%c", k);
12934 else
12935 printf (".");
12936 }
12937
12938 putchar ('\n');
12939
12940 data += lbytes;
12941 addr += lbytes;
12942 bytes -= lbytes;
12943 }
12944
0e602686 12945 free (real_start);
cf13d699
NC		 12946
12947 putchar ('\n');
12948}
12949
d966045b
DJ		 12950static int
12951load_specific_debug_section (enum dwarf_section_display_enum debug,
0d2a7a93 12952 const Elf_Internal_Shdr * sec, void * file)
1007acb3 12953{
2cf0635d 12954 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 12955 char buf [64];
1007acb3 12956
19e6b90e
L		 12957 /* If it is already loaded, do nothing. */
12958 if (section->start != NULL)
12959 return 1;
1007acb3 12960
19e6b90e
L		 12961 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12962 section->address = sec->sh_addr;
06614111 12963 section->user_data = NULL;
3f5e193b
NC		 12964 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12965 sec->sh_offset, 1,
12966 sec->sh_size, buf);
59245841
NC		 12967 if (section->start == NULL)
12968 section->size = 0;
12969 else
12970 {
77115a4a
L		 12971 unsigned char *start = section->start;
12972 dwarf_size_type size = sec->sh_size;
dab394de 12973 dwarf_size_type uncompressed_size = 0;
77115a4a
L		 12974
12975 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
12976 {
12977 Elf_Internal_Chdr chdr;
d8024a91
NC		 12978 unsigned int compression_header_size;
12979
f53be977
L		 12980 if (size < (is_32bit_elf
12981 ? sizeof (Elf32_External_Chdr)
12982 : sizeof (Elf64_External_Chdr)))
d8024a91
NC		 12983 {
12984 warn (_("compressed section %s is too small to contain a compression header"),
12985 section->name);
12986 return 0;
12987 }
12988
ebdf1ebf 12989 compression_header_size = get_compression_header (&chdr, start, size);
d8024a91 12990
813dabb9
L		 12991 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12992 {
12993 warn (_("section '%s' has unsupported compress type: %d\n"),
12994 section->name, chdr.ch_type);
12995 return 0;
12996 }
12997 else if (chdr.ch_addralign != sec->sh_addralign)
12998 {
12999 warn (_("compressed section '%s' is corrupted\n"),
13000 section->name);
13001 return 0;
13002 }
dab394de 13003 uncompressed_size = chdr.ch_size;
77115a4a
L		 13004 start += compression_header_size;
13005 size -= compression_header_size;
13006 }
dab394de
L		 13007 else if (size > 12 && streq ((char *) start, "ZLIB"))
13008 {
13009 /* Read the zlib header. In this case, it should be "ZLIB"
13010 followed by the uncompressed section size, 8 bytes in
13011 big-endian order. */
13012 uncompressed_size = start[4]; uncompressed_size <<= 8;
13013 uncompressed_size += start[5]; uncompressed_size <<= 8;
13014 uncompressed_size += start[6]; uncompressed_size <<= 8;
13015 uncompressed_size += start[7]; uncompressed_size <<= 8;
13016 uncompressed_size += start[8]; uncompressed_size <<= 8;
13017 uncompressed_size += start[9]; uncompressed_size <<= 8;
13018 uncompressed_size += start[10]; uncompressed_size <<= 8;
13019 uncompressed_size += start[11];
13020 start += 12;
13021 size -= 12;
13022 }
13023
1835f746 13024 if (uncompressed_size)
77115a4a 13025 {
1835f746
NC		 13026 if (uncompress_section_contents (&start, uncompressed_size,
13027 &size))
13028 {
13029 /* Free the compressed buffer, update the section buffer
13030 and the section size if uncompress is successful. */
13031 free (section->start);
13032 section->start = start;
13033 }
13034 else
13035 {
13036 error (_("Unable to decompress section %s\n"),
13037 printable_section_name (sec));
13038 return 0;
13039 }
77115a4a 13040 }
bc303e5d 13041
77115a4a 13042 section->size = size;
59245841 13043 }
4a114e3e 13044
1b315056
CS		 13045 if (section->start == NULL)
13046 return 0;
13047
19e6b90e 13048 if (debug_displays [debug].relocate)
d1c4b12b
NC		 13049 apply_relocations ((FILE *) file, sec, section->start, section->size,
13050 & section->reloc_info, & section->num_relocs);
13051 else
13052 {
13053 section->reloc_info = NULL;
13054 section->num_relocs = 0;
13055 }
1007acb3 13056
1b315056 13057 return 1;
1007acb3
L		 13058}
13059
657d0d47
CC		 13060/* If this is not NULL, load_debug_section will only look for sections
13061 within the list of sections given here. */
13062unsigned int *section_subset = NULL;
13063
d966045b 13064int
2cf0635d 13065load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 13066{
2cf0635d
NC		 13067 struct dwarf_section * section = &debug_displays [debug].section;
13068 Elf_Internal_Shdr * sec;
d966045b
DJ		 13069
13070 /* Locate the debug section. */
657d0d47 13071 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 13072 if (sec != NULL)
13073 section->name = section->uncompressed_name;
13074 else
13075 {
657d0d47 13076 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 13077 if (sec != NULL)
13078 section->name = section->compressed_name;
13079 }
13080 if (sec == NULL)
13081 return 0;
13082
657d0d47
CC		 13083 /* If we're loading from a subset of sections, and we've loaded
13084 a section matching this name before, it's likely that it's a
13085 different one. */
13086 if (section_subset != NULL)
13087 free_debug_section (debug);
13088
3f5e193b 13089 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 13090}
13091
19e6b90e
L		 13092void
13093free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 13094{
2cf0635d 13095 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 13096
19e6b90e
L		 13097 if (section->start == NULL)
13098 return;
1007acb3 13099
19e6b90e
L		 13100 free ((char *) section->start);
13101 section->start = NULL;
13102 section->address = 0;
13103 section->size = 0;
1007acb3
L		 13104}
13105
1007acb3 13106static int
657d0d47 13107display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 13108{
2cf0635d 13109 char * name = SECTION_NAME (section);
74e1a04b 13110 const char * print_name = printable_section_name (section);
19e6b90e
L		 13111 bfd_size_type length;
13112 int result = 1;
3f5e193b 13113 int i;
1007acb3 13114
19e6b90e
L		 13115 length = section->sh_size;
13116 if (length == 0)
1007acb3 13117 {
74e1a04b 13118 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
19e6b90e 13119 return 0;
1007acb3 13120 }
5dff79d8
NC		 13121 if (section->sh_type == SHT_NOBITS)
13122 {
13123 /* There is no point in dumping the contents of a debugging section
13124 which has the NOBITS type - the bits in the file will be random.
13125 This can happen when a file containing a .eh_frame section is
13126 stripped with the --only-keep-debug command line option. */
74e1a04b
NC		 13127 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13128 print_name);
5dff79d8
NC		 13129 return 0;
13130 }
1007acb3 13131
0112cd26 13132 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 13133 name = ".debug_info";
1007acb3 13134
19e6b90e
L		 13135 /* See if we know how to display the contents of this section. */
13136 for (i = 0; i < max; i++)
1b315056 13137 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 13138 || (i == line && const_strneq (name, ".debug_line."))
1b315056 13139 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 13140 {
2cf0635d 13141 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 13142 int secondary = (section != find_section (name));
13143
13144 if (secondary)
3f5e193b 13145 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 13146
b40bf0a2
NC		 13147 if (i == line && const_strneq (name, ".debug_line."))
13148 sec->name = name;
13149 else if (streq (sec->uncompressed_name, name))
d966045b
DJ		 13150 sec->name = sec->uncompressed_name;
13151 else
13152 sec->name = sec->compressed_name;
3f5e193b
NC		 13153 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
13154 section, file))
19e6b90e 13155 {
657d0d47
CC		 13156 /* If this debug section is part of a CU/TU set in a .dwp file,
13157 restrict load_debug_section to the sections in that set. */
13158 section_subset = find_cu_tu_set (file, shndx);
13159
19e6b90e 13160 result &= debug_displays[i].display (sec, file);
1007acb3 13161
657d0d47
CC		 13162 section_subset = NULL;
13163
d966045b 13164 if (secondary || (i != info && i != abbrev))
3f5e193b 13165 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 13166 }
1007acb3 13167
19e6b90e
L		 13168 break;
13169 }
1007acb3 13170
19e6b90e 13171 if (i == max)
1007acb3 13172 {
74e1a04b 13173 printf (_("Unrecognized debug section: %s\n"), print_name);
19e6b90e 13174 result = 0;
1007acb3
L		 13175 }
13176
19e6b90e 13177 return result;
5b18a4bc 13178}
103f02d3 13179
aef1f6d0
DJ		 13180/* Set DUMP_SECTS for all sections where dumps were requested
13181 based on section name. */
13182
13183static void
13184initialise_dumps_byname (void)
13185{
2cf0635d 13186 struct dump_list_entry * cur;
aef1f6d0
DJ		 13187
13188 for (cur = dump_sects_byname; cur; cur = cur->next)
13189 {
13190 unsigned int i;
13191 int any;
13192
13193 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
13194 if (streq (SECTION_NAME (section_headers + i), cur->name))
13195 {
09c11c86 13196 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 13197 any = 1;
13198 }
13199
13200 if (!any)
13201 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13202 cur->name);
13203 }
13204}
13205
5b18a4bc 13206static void
2cf0635d 13207process_section_contents (FILE * file)
5b18a4bc 13208{
2cf0635d 13209 Elf_Internal_Shdr * section;
19e6b90e 13210 unsigned int i;
103f02d3 13211
19e6b90e
L		 13212 if (! do_dump)
13213 return;
103f02d3 13214
aef1f6d0
DJ		 13215 initialise_dumps_byname ();
13216
19e6b90e
L		 13217 for (i = 0, section = section_headers;
13218 i < elf_header.e_shnum && i < num_dump_sects;
13219 i++, section++)
13220 {
13221#ifdef SUPPORT_DISASSEMBLY
13222 if (dump_sects[i] & DISASS_DUMP)
13223 disassemble_section (section, file);
13224#endif
13225 if (dump_sects[i] & HEX_DUMP)
cf13d699 13226 dump_section_as_bytes (section, file, FALSE);
103f02d3 13227
cf13d699
NC		 13228 if (dump_sects[i] & RELOC_DUMP)
13229 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 13230
13231 if (dump_sects[i] & STRING_DUMP)
13232 dump_section_as_strings (section, file);
cf13d699
NC		 13233
13234 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 13235 display_debug_section (i, section, file);
5b18a4bc 13236 }
103f02d3 13237
19e6b90e
L		 13238 /* Check to see if the user requested a
13239 dump of a section that does not exist. */
0ee3043f
NC		 13240 while (i < num_dump_sects)
13241 {
13242 if (dump_sects[i])
13243 warn (_("Section %d was not dumped because it does not exist!\n"), i);
13244 i++;
13245 }
5b18a4bc 13246}
103f02d3 13247
5b18a4bc 13248static void
19e6b90e 13249process_mips_fpe_exception (int mask)
5b18a4bc 13250{
19e6b90e
L		 13251 if (mask)
13252 {
13253 int first = 1;
13254 if (mask & OEX_FPU_INEX)
13255 fputs ("INEX", stdout), first = 0;
13256 if (mask & OEX_FPU_UFLO)
13257 printf ("%sUFLO", first ? "" : "|"), first = 0;
13258 if (mask & OEX_FPU_OFLO)
13259 printf ("%sOFLO", first ? "" : "|"), first = 0;
13260 if (mask & OEX_FPU_DIV0)
13261 printf ("%sDIV0", first ? "" : "|"), first = 0;
13262 if (mask & OEX_FPU_INVAL)
13263 printf ("%sINVAL", first ? "" : "|");
13264 }
5b18a4bc 13265 else
19e6b90e 13266 fputs ("0", stdout);
5b18a4bc 13267}
103f02d3 13268
f6f0e17b
NC		 13269/* Display's the value of TAG at location P. If TAG is
13270 greater than 0 it is assumed to be an unknown tag, and
13271 a message is printed to this effect. Otherwise it is
13272 assumed that a message has already been printed.
13273
13274 If the bottom bit of TAG is set it assumed to have a
13275 string value, otherwise it is assumed to have an integer
13276 value.
13277
13278 Returns an updated P pointing to the first unread byte
13279 beyond the end of TAG's value.
13280
13281 Reads at or beyond END will not be made. */
13282
13283static unsigned char *
60abdbed 13284display_tag_value (signed int tag,
f6f0e17b
NC		 13285 unsigned char * p,
13286 const unsigned char * const end)
13287{
13288 unsigned long val;
13289
13290 if (tag > 0)
13291 printf (" Tag_unknown_%d: ", tag);
13292
13293 if (p >= end)
13294 {
4082ef84 13295 warn (_("<corrupt tag>\n"));
f6f0e17b
NC		 13296 }
13297 else if (tag & 1)
13298 {
071436c6
NC		 13299 /* PR 17531 file: 027-19978-0.004. */
13300 size_t maxlen = (end - p) - 1;
13301
13302 putchar ('"');
4082ef84
NC		 13303 if (maxlen > 0)
13304 {
13305 print_symbol ((int) maxlen, (const char *) p);
13306 p += strnlen ((char *) p, maxlen) + 1;
13307 }
13308 else
13309 {
13310 printf (_("<corrupt string tag>"));
13311 p = (unsigned char *) end;
13312 }
071436c6 13313 printf ("\"\n");
f6f0e17b
NC		 13314 }
13315 else
13316 {
13317 unsigned int len;
13318
13319 val = read_uleb128 (p, &len, end);
13320 p += len;
13321 printf ("%ld (0x%lx)\n", val, val);
13322 }
13323
4082ef84 13324 assert (p <= end);
f6f0e17b
NC		 13325 return p;
13326}
13327
11c1ff18
PB		 13328/* ARM EABI attributes section. */
13329typedef struct
13330{
70e99720 13331 unsigned int tag;
2cf0635d 13332 const char * name;
11c1ff18 13333 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
70e99720 13334 unsigned int type;
2cf0635d 13335 const char ** table;
11c1ff18
PB		 13336} arm_attr_public_tag;
13337
2cf0635d 13338static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 13339 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
ff8646ee
TP		 13340 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
13341 "v8-M.mainline"};
2cf0635d
NC		 13342static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
13343static const char * arm_attr_tag_THUMB_ISA_use[] =
4ed7ed8d 13344 {"No", "Thumb-1", "Thumb-2", "Yes"};
75375b3e 13345static const char * arm_attr_tag_FP_arch[] =
bca38921 13346 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
a715796b 13347 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
2cf0635d 13348static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 13349static const char * arm_attr_tag_Advanced_SIMD_arch[] =
9411fd44
MW		 13350 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13351 "NEON for ARMv8.1"};
2cf0635d 13352static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 13353 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13354 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 13355static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 13356 {"V6", "SB", "TLS", "Unused"};
2cf0635d 13357static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 13358 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 13359static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 13360 {"Absolute", "PC-relative", "None"};
2cf0635d 13361static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 13362 {"None", "direct", "GOT-indirect"};
2cf0635d 13363static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 13364 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 13365static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
13366static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 13367 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 13368static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
13369static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
13370static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 13371 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 13372static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 13373 {"Unused", "small", "int", "forced to int"};
2cf0635d 13374static const char * arm_attr_tag_ABI_HardFP_use[] =
99654aaf 13375 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
2cf0635d 13376static const char * arm_attr_tag_ABI_VFP_args[] =
5c294fee 13377 {"AAPCS", "VFP registers", "custom", "compatible"};
2cf0635d 13378static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 13379 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 13380static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 13381 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13382 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 13383static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 13384 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13385 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 13386static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 13387static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 13388 {"Not Allowed", "Allowed"};
2cf0635d 13389static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 13390 {"None", "IEEE 754", "Alternative Format"};
15afaa63
TP		 13391static const char * arm_attr_tag_DSP_extension[] =
13392 {"Follow architecture", "Allowed"};
dd24e3da 13393static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 13394 {"Not Allowed", "Allowed"};
13395static const char * arm_attr_tag_DIV_use[] =
dd24e3da 13396 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 13397 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 13398static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
13399static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 13400 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 13401 "TrustZone and Virtualization Extensions"};
dd24e3da 13402static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 13403 {"Not Allowed", "Allowed"};
11c1ff18
PB		 13404
13405#define LOOKUP(id, name) \
13406 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 13407static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 13408{
13409 {4, "CPU_raw_name", 1, NULL},
13410 {5, "CPU_name", 1, NULL},
13411 LOOKUP(6, CPU_arch),
13412 {7, "CPU_arch_profile", 0, NULL},
13413 LOOKUP(8, ARM_ISA_use),
13414 LOOKUP(9, THUMB_ISA_use),
75375b3e 13415 LOOKUP(10, FP_arch),
11c1ff18 13416 LOOKUP(11, WMMX_arch),
f5f53991
AS		 13417 LOOKUP(12, Advanced_SIMD_arch),
13418 LOOKUP(13, PCS_config),
11c1ff18
PB		 13419 LOOKUP(14, ABI_PCS_R9_use),
13420 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 13421 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 13422 LOOKUP(17, ABI_PCS_GOT_use),
13423 LOOKUP(18, ABI_PCS_wchar_t),
13424 LOOKUP(19, ABI_FP_rounding),
13425 LOOKUP(20, ABI_FP_denormal),
13426 LOOKUP(21, ABI_FP_exceptions),
13427 LOOKUP(22, ABI_FP_user_exceptions),
13428 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 13429 {24, "ABI_align_needed", 0, NULL},
13430 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 13431 LOOKUP(26, ABI_enum_size),
13432 LOOKUP(27, ABI_HardFP_use),
13433 LOOKUP(28, ABI_VFP_args),
13434 LOOKUP(29, ABI_WMMX_args),
13435 LOOKUP(30, ABI_optimization_goals),
13436 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 13437 {32, "compatibility", 0, NULL},
f5f53991 13438 LOOKUP(34, CPU_unaligned_access),
75375b3e 13439 LOOKUP(36, FP_HP_extension),
8e79c3df 13440 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 13441 LOOKUP(42, MPextension_use),
13442 LOOKUP(44, DIV_use),
15afaa63 13443 LOOKUP(46, DSP_extension),
f5f53991
AS		 13444 {64, "nodefaults", 0, NULL},
13445 {65, "also_compatible_with", 0, NULL},
13446 LOOKUP(66, T2EE_use),
13447 {67, "conformance", 1, NULL},
13448 LOOKUP(68, Virtualization_use),
cd21e546 13449 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 13450};
13451#undef LOOKUP
13452
11c1ff18 13453static unsigned char *
f6f0e17b
NC		 13454display_arm_attribute (unsigned char * p,
13455 const unsigned char * const end)
11c1ff18 13456{
70e99720 13457 unsigned int tag;
11c1ff18 13458 unsigned int len;
70e99720 13459 unsigned int val;
2cf0635d 13460 arm_attr_public_tag * attr;
11c1ff18 13461 unsigned i;
70e99720 13462 unsigned int type;
11c1ff18 13463
f6f0e17b 13464 tag = read_uleb128 (p, &len, end);
11c1ff18
PB		 13465 p += len;
13466 attr = NULL;
2cf0635d 13467 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 13468 {
13469 if (arm_attr_public_tags[i].tag == tag)
13470 {
13471 attr = &arm_attr_public_tags[i];
13472 break;
13473 }
13474 }
13475
13476 if (attr)
13477 {
13478 printf (" Tag_%s: ", attr->name);
13479 switch (attr->type)
13480 {
13481 case 0:
13482 switch (tag)
13483 {
13484 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 13485 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 13486 p += len;
13487 switch (val)
13488 {
2b692964
NC		 13489 case 0: printf (_("None\n")); break;
13490 case 'A': printf (_("Application\n")); break;
13491 case 'R': printf (_("Realtime\n")); break;
13492 case 'M': printf (_("Microcontroller\n")); break;
13493 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 13494 default: printf ("??? (%d)\n", val); break;
13495 }
13496 break;
13497
75375b3e 13498 case 24: /* Tag_align_needed. */
f6f0e17b 13499 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 13500 p += len;
13501 switch (val)
13502 {
2b692964
NC		 13503 case 0: printf (_("None\n")); break;
13504 case 1: printf (_("8-byte\n")); break;
13505 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 13506 case 3: printf ("??? 3\n"); break;
13507 default:
13508 if (val <= 12)
dd24e3da 13509 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 13510 1 << val);
13511 else
13512 printf ("??? (%d)\n", val);
13513 break;
13514 }
13515 break;
13516
13517 case 25: /* Tag_align_preserved. */
f6f0e17b 13518 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 13519 p += len;
13520 switch (val)
13521 {
2b692964
NC		 13522 case 0: printf (_("None\n")); break;
13523 case 1: printf (_("8-byte, except leaf SP\n")); break;
13524 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 13525 case 3: printf ("??? 3\n"); break;
13526 default:
13527 if (val <= 12)
dd24e3da 13528 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 13529 1 << val);
13530 else
13531 printf ("??? (%d)\n", val);
13532 break;
13533 }
13534 break;
13535
11c1ff18 13536 case 32: /* Tag_compatibility. */
071436c6 13537 {
071436c6
NC		 13538 val = read_uleb128 (p, &len, end);
13539 p += len;
071436c6 13540 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 13541 if (p < end - 1)
13542 {
13543 size_t maxlen = (end - p) - 1;
13544
13545 print_symbol ((int) maxlen, (const char *) p);
13546 p += strnlen ((char *) p, maxlen) + 1;
13547 }
13548 else
13549 {
13550 printf (_("<corrupt>"));
13551 p = (unsigned char *) end;
13552 }
071436c6 13553 putchar ('\n');
071436c6 13554 }
11c1ff18
PB		 13555 break;
13556
f5f53991 13557 case 64: /* Tag_nodefaults. */
541a3cbd
NC		 13558 /* PR 17531: file: 001-505008-0.01. */
13559 if (p < end)
13560 p++;
2b692964 13561 printf (_("True\n"));
f5f53991
AS		 13562 break;
13563
13564 case 65: /* Tag_also_compatible_with. */
f6f0e17b 13565 val = read_uleb128 (p, &len, end);
f5f53991
AS		 13566 p += len;
13567 if (val == 6 /* Tag_CPU_arch. */)
13568 {
f6f0e17b 13569 val = read_uleb128 (p, &len, end);
f5f53991 13570 p += len;
071436c6 13571 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 13572 printf ("??? (%d)\n", val);
13573 else
13574 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
13575 }
13576 else
13577 printf ("???\n");
071436c6
NC		 13578 while (p < end && *(p++) != '\0' /* NUL terminator. */)
13579 ;
f5f53991
AS		 13580 break;
13581
11c1ff18 13582 default:
bee0ee85
NC		 13583 printf (_("<unknown: %d>\n"), tag);
13584 break;
11c1ff18
PB		 13585 }
13586 return p;
13587
13588 case 1:
f6f0e17b 13589 return display_tag_value (-1, p, end);
11c1ff18 13590 case 2:
f6f0e17b 13591 return display_tag_value (0, p, end);
11c1ff18
PB		 13592
13593 default:
13594 assert (attr->type & 0x80);
f6f0e17b 13595 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 13596 p += len;
13597 type = attr->type & 0x7f;
13598 if (val >= type)
13599 printf ("??? (%d)\n", val);
13600 else
13601 printf ("%s\n", attr->table[val]);
13602 return p;
13603 }
13604 }
11c1ff18 13605
f6f0e17b 13606 return display_tag_value (tag, p, end);
11c1ff18
PB		 13607}
13608
104d59d1 13609static unsigned char *
60bca95a 13610display_gnu_attribute (unsigned char * p,
60abdbed 13611 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
f6f0e17b 13612 const unsigned char * const end)
104d59d1
JM		 13613{
13614 int tag;
13615 unsigned int len;
60abdbed 13616 unsigned int val;
104d59d1 13617
f6f0e17b 13618 tag = read_uleb128 (p, &len, end);
104d59d1
JM		 13619 p += len;
13620
13621 /* Tag_compatibility is the only generic GNU attribute defined at
13622 present. */
13623 if (tag == 32)
13624 {
f6f0e17b 13625 val = read_uleb128 (p, &len, end);
104d59d1 13626 p += len;
071436c6
NC		 13627
13628 printf (_("flag = %d, vendor = "), val);
f6f0e17b
NC		 13629 if (p == end)
13630 {
071436c6 13631 printf (_("<corrupt>\n"));
f6f0e17b
NC		 13632 warn (_("corrupt vendor attribute\n"));
13633 }
13634 else
13635 {
4082ef84
NC		 13636 if (p < end - 1)
13637 {
13638 size_t maxlen = (end - p) - 1;
071436c6 13639
4082ef84
NC		 13640 print_symbol ((int) maxlen, (const char *) p);
13641 p += strnlen ((char *) p, maxlen) + 1;
13642 }
13643 else
13644 {
13645 printf (_("<corrupt>"));
13646 p = (unsigned char *) end;
13647 }
071436c6 13648 putchar ('\n');
f6f0e17b 13649 }
104d59d1
JM		 13650 return p;
13651 }
13652
13653 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 13654 return display_proc_gnu_attribute (p, tag, end);
104d59d1 13655
f6f0e17b 13656 return display_tag_value (tag, p, end);
104d59d1
JM		 13657}
13658
34c8bcba 13659static unsigned char *
f6f0e17b 13660display_power_gnu_attribute (unsigned char * p,
60abdbed 13661 unsigned int tag,
f6f0e17b 13662 const unsigned char * const end)
34c8bcba 13663{
34c8bcba 13664 unsigned int len;
005d79fd 13665 unsigned int val;
34c8bcba
JM		 13666
13667 if (tag == Tag_GNU_Power_ABI_FP)
13668 {
f6f0e17b 13669 val = read_uleb128 (p, &len, end);
34c8bcba
JM		 13670 p += len;
13671 printf (" Tag_GNU_Power_ABI_FP: ");
005d79fd
AM		 13672 if (len == 0)
13673 {
13674 printf (_("<corrupt>\n"));
13675 return p;
13676 }
60bca95a 13677
005d79fd
AM		 13678 if (val > 15)
13679 printf ("(%#x), ", val);
13680
13681 switch (val & 3)
34c8bcba
JM		 13682 {
13683 case 0:
005d79fd 13684 printf (_("unspecified hard/soft float, "));
34c8bcba
JM		 13685 break;
13686 case 1:
005d79fd 13687 printf (_("hard float, "));
34c8bcba
JM		 13688 break;
13689 case 2:
005d79fd 13690 printf (_("soft float, "));
34c8bcba 13691 break;
3c7b9897 13692 case 3:
005d79fd 13693 printf (_("single-precision hard float, "));
3c7b9897 13694 break;
005d79fd
AM		 13695 }
13696
13697 switch (val & 0xC)
13698 {
13699 case 0:
13700 printf (_("unspecified long double\n"));
13701 break;
13702 case 4:
13703 printf (_("128-bit IBM long double\n"));
13704 break;
13705 case 8:
13706 printf (_("64-bit long double\n"));
13707 break;
13708 case 12:
13709 printf (_("128-bit IEEE long double\n"));
34c8bcba
JM		 13710 break;
13711 }
13712 return p;
005d79fd 13713 }
34c8bcba 13714
c6e65352
DJ		 13715 if (tag == Tag_GNU_Power_ABI_Vector)
13716 {
f6f0e17b 13717 val = read_uleb128 (p, &len, end);
c6e65352
DJ		 13718 p += len;
13719 printf (" Tag_GNU_Power_ABI_Vector: ");
005d79fd
AM		 13720 if (len == 0)
13721 {
13722 printf (_("<corrupt>\n"));
13723 return p;
13724 }
13725
13726 if (val > 3)
13727 printf ("(%#x), ", val);
13728
13729 switch (val & 3)
c6e65352
DJ		 13730 {
13731 case 0:
005d79fd 13732 printf (_("unspecified\n"));
c6e65352
DJ		 13733 break;
13734 case 1:
005d79fd 13735 printf (_("generic\n"));
c6e65352
DJ		 13736 break;
13737 case 2:
13738 printf ("AltiVec\n");
13739 break;
13740 case 3:
13741 printf ("SPE\n");
13742 break;
c6e65352
DJ		 13743 }
13744 return p;
005d79fd 13745 }
c6e65352 13746
f82e0623
NF		 13747 if (tag == Tag_GNU_Power_ABI_Struct_Return)
13748 {
005d79fd
AM		 13749 val = read_uleb128 (p, &len, end);
13750 p += len;
13751 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13752 if (len == 0)
f6f0e17b 13753 {
005d79fd 13754 printf (_("<corrupt>\n"));
f6f0e17b
NC		 13755 return p;
13756 }
0b4362b0 13757
005d79fd
AM		 13758 if (val > 2)
13759 printf ("(%#x), ", val);
13760
13761 switch (val & 3)
13762 {
13763 case 0:
13764 printf (_("unspecified\n"));
13765 break;
13766 case 1:
13767 printf ("r3/r4\n");
13768 break;
13769 case 2:
13770 printf (_("memory\n"));
13771 break;
13772 case 3:
13773 printf ("???\n");
13774 break;
13775 }
f82e0623
NF		 13776 return p;
13777 }
13778
f6f0e17b 13779 return display_tag_value (tag & 1, p, end);
34c8bcba
JM		 13780}
13781
643f7afb
AK		 13782static unsigned char *
13783display_s390_gnu_attribute (unsigned char * p,
60abdbed 13784 unsigned int tag,
643f7afb
AK		 13785 const unsigned char * const end)
13786{
13787 unsigned int len;
13788 int val;
13789
13790 if (tag == Tag_GNU_S390_ABI_Vector)
13791 {
13792 val = read_uleb128 (p, &len, end);
13793 p += len;
13794 printf (" Tag_GNU_S390_ABI_Vector: ");
13795
13796 switch (val)
13797 {
13798 case 0:
13799 printf (_("any\n"));
13800 break;
13801 case 1:
13802 printf (_("software\n"));
13803 break;
13804 case 2:
13805 printf (_("hardware\n"));
13806 break;
13807 default:
13808 printf ("??? (%d)\n", val);
13809 break;
13810 }
13811 return p;
13812 }
13813
13814 return display_tag_value (tag & 1, p, end);
13815}
13816
9e8c70f9 13817static void
60abdbed 13818display_sparc_hwcaps (unsigned int mask)
9e8c70f9
DM		 13819{
13820 if (mask)
13821 {
13822 int first = 1;
071436c6 13823
9e8c70f9
DM		 13824 if (mask & ELF_SPARC_HWCAP_MUL32)
13825 fputs ("mul32", stdout), first = 0;
13826 if (mask & ELF_SPARC_HWCAP_DIV32)
13827 printf ("%sdiv32", first ? "" : "|"), first = 0;
13828 if (mask & ELF_SPARC_HWCAP_FSMULD)
13829 printf ("%sfsmuld", first ? "" : "|"), first = 0;
13830 if (mask & ELF_SPARC_HWCAP_V8PLUS)
13831 printf ("%sv8plus", first ? "" : "|"), first = 0;
13832 if (mask & ELF_SPARC_HWCAP_POPC)
13833 printf ("%spopc", first ? "" : "|"), first = 0;
13834 if (mask & ELF_SPARC_HWCAP_VIS)
13835 printf ("%svis", first ? "" : "|"), first = 0;
13836 if (mask & ELF_SPARC_HWCAP_VIS2)
13837 printf ("%svis2", first ? "" : "|"), first = 0;
13838 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
13839 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
13840 if (mask & ELF_SPARC_HWCAP_FMAF)
13841 printf ("%sfmaf", first ? "" : "|"), first = 0;
13842 if (mask & ELF_SPARC_HWCAP_VIS3)
13843 printf ("%svis3", first ? "" : "|"), first = 0;
13844 if (mask & ELF_SPARC_HWCAP_HPC)
13845 printf ("%shpc", first ? "" : "|"), first = 0;
13846 if (mask & ELF_SPARC_HWCAP_RANDOM)
13847 printf ("%srandom", first ? "" : "|"), first = 0;
13848 if (mask & ELF_SPARC_HWCAP_TRANS)
13849 printf ("%strans", first ? "" : "|"), first = 0;
13850 if (mask & ELF_SPARC_HWCAP_FJFMAU)
13851 printf ("%sfjfmau", first ? "" : "|"), first = 0;
13852 if (mask & ELF_SPARC_HWCAP_IMA)
13853 printf ("%sima", first ? "" : "|"), first = 0;
13854 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
13855 printf ("%scspare", first ? "" : "|"), first = 0;
13856 }
13857 else
071436c6
NC		 13858 fputc ('0', stdout);
13859 fputc ('\n', stdout);
9e8c70f9
DM		 13860}
13861
3d68f91c 13862static void
60abdbed 13863display_sparc_hwcaps2 (unsigned int mask)
3d68f91c
JM		 13864{
13865 if (mask)
13866 {
13867 int first = 1;
071436c6 13868
3d68f91c
JM		 13869 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
13870 fputs ("fjathplus", stdout), first = 0;
13871 if (mask & ELF_SPARC_HWCAP2_VIS3B)
13872 printf ("%svis3b", first ? "" : "|"), first = 0;
13873 if (mask & ELF_SPARC_HWCAP2_ADP)
13874 printf ("%sadp", first ? "" : "|"), first = 0;
13875 if (mask & ELF_SPARC_HWCAP2_SPARC5)
13876 printf ("%ssparc5", first ? "" : "|"), first = 0;
13877 if (mask & ELF_SPARC_HWCAP2_MWAIT)
13878 printf ("%smwait", first ? "" : "|"), first = 0;
13879 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
13880 printf ("%sxmpmul", first ? "" : "|"), first = 0;
13881 if (mask & ELF_SPARC_HWCAP2_XMONT)
13882 printf ("%sxmont2", first ? "" : "|"), first = 0;
13883 if (mask & ELF_SPARC_HWCAP2_NSEC)
13884 printf ("%snsec", first ? "" : "|"), first = 0;
13885 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
13886 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
13887 if (mask & ELF_SPARC_HWCAP2_FJDES)
13888 printf ("%sfjdes", first ? "" : "|"), first = 0;
13889 if (mask & ELF_SPARC_HWCAP2_FJAES)
13890 printf ("%sfjaes", first ? "" : "|"), first = 0;
13891 }
13892 else
071436c6
NC		 13893 fputc ('0', stdout);
13894 fputc ('\n', stdout);
3d68f91c
JM		 13895}
13896
9e8c70f9 13897static unsigned char *
f6f0e17b 13898display_sparc_gnu_attribute (unsigned char * p,
60abdbed 13899 unsigned int tag,
f6f0e17b 13900 const unsigned char * const end)
9e8c70f9 13901{
3d68f91c
JM		 13902 unsigned int len;
13903 int val;
13904
9e8c70f9
DM		 13905 if (tag == Tag_GNU_Sparc_HWCAPS)
13906 {
f6f0e17b 13907 val = read_uleb128 (p, &len, end);
9e8c70f9
DM		 13908 p += len;
13909 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM		 13910 display_sparc_hwcaps (val);
13911 return p;
3d68f91c
JM		 13912 }
13913 if (tag == Tag_GNU_Sparc_HWCAPS2)
13914 {
13915 val = read_uleb128 (p, &len, end);
13916 p += len;
13917 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13918 display_sparc_hwcaps2 (val);
13919 return p;
13920 }
9e8c70f9 13921
f6f0e17b 13922 return display_tag_value (tag, p, end);
9e8c70f9
DM		 13923}
13924
351cdf24
MF		 13925static void
13926print_mips_fp_abi_value (int val)
13927{
13928 switch (val)
13929 {
13930 case Val_GNU_MIPS_ABI_FP_ANY:
13931 printf (_("Hard or soft float\n"));
13932 break;
13933 case Val_GNU_MIPS_ABI_FP_DOUBLE:
13934 printf (_("Hard float (double precision)\n"));
13935 break;
13936 case Val_GNU_MIPS_ABI_FP_SINGLE:
13937 printf (_("Hard float (single precision)\n"));
13938 break;
13939 case Val_GNU_MIPS_ABI_FP_SOFT:
13940 printf (_("Soft float\n"));
13941 break;
13942 case Val_GNU_MIPS_ABI_FP_OLD_64:
13943 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13944 break;
13945 case Val_GNU_MIPS_ABI_FP_XX:
13946 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13947 break;
13948 case Val_GNU_MIPS_ABI_FP_64:
13949 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13950 break;
13951 case Val_GNU_MIPS_ABI_FP_64A:
13952 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13953 break;
3350cc01
CM		 13954 case Val_GNU_MIPS_ABI_FP_NAN2008:
13955 printf (_("NaN 2008 compatibility\n"));
13956 break;
351cdf24
MF		 13957 default:
13958 printf ("??? (%d)\n", val);
13959 break;
13960 }
13961}
13962
2cf19d5c 13963static unsigned char *
f6f0e17b 13964display_mips_gnu_attribute (unsigned char * p,
60abdbed 13965 unsigned int tag,
f6f0e17b 13966 const unsigned char * const end)
2cf19d5c 13967{
2cf19d5c
JM		 13968 if (tag == Tag_GNU_MIPS_ABI_FP)
13969 {
f6f0e17b
NC		 13970 unsigned int len;
13971 int val;
13972
13973 val = read_uleb128 (p, &len, end);
2cf19d5c
JM		 13974 p += len;
13975 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 13976
351cdf24
MF		 13977 print_mips_fp_abi_value (val);
13978
2cf19d5c
JM		 13979 return p;
13980 }
13981
a9f58168
CF		 13982 if (tag == Tag_GNU_MIPS_ABI_MSA)
13983 {
13984 unsigned int len;
13985 int val;
13986
13987 val = read_uleb128 (p, &len, end);
13988 p += len;
13989 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13990
13991 switch (val)
13992 {
13993 case Val_GNU_MIPS_ABI_MSA_ANY:
13994 printf (_("Any MSA or not\n"));
13995 break;
13996 case Val_GNU_MIPS_ABI_MSA_128:
13997 printf (_("128-bit MSA\n"));
13998 break;
13999 default:
14000 printf ("??? (%d)\n", val);
14001 break;
14002 }
14003 return p;
14004 }
14005
f6f0e17b 14006 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM		 14007}
14008
59e6276b 14009static unsigned char *
f6f0e17b
NC		 14010display_tic6x_attribute (unsigned char * p,
14011 const unsigned char * const end)
59e6276b 14012{
60abdbed 14013 unsigned int tag;
59e6276b
JM		 14014 unsigned int len;
14015 int val;
14016
f6f0e17b 14017 tag = read_uleb128 (p, &len, end);
59e6276b
JM		 14018 p += len;
14019
14020 switch (tag)
14021 {
75fa6dc1 14022 case Tag_ISA:
f6f0e17b 14023 val = read_uleb128 (p, &len, end);
59e6276b 14024 p += len;
75fa6dc1 14025 printf (" Tag_ISA: ");
59e6276b
JM		 14026
14027 switch (val)
14028 {
75fa6dc1 14029 case C6XABI_Tag_ISA_none:
59e6276b
JM		 14030 printf (_("None\n"));
14031 break;
75fa6dc1 14032 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 14033 printf ("C62x\n");
14034 break;
75fa6dc1 14035 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 14036 printf ("C67x\n");
14037 break;
75fa6dc1 14038 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 14039 printf ("C67x+\n");
14040 break;
75fa6dc1 14041 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 14042 printf ("C64x\n");
14043 break;
75fa6dc1 14044 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 14045 printf ("C64x+\n");
14046 break;
75fa6dc1 14047 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 14048 printf ("C674x\n");
14049 break;
14050 default:
14051 printf ("??? (%d)\n", val);
14052 break;
14053 }
14054 return p;
14055
87779176 14056 case Tag_ABI_wchar_t:
f6f0e17b 14057 val = read_uleb128 (p, &len, end);
87779176
JM		 14058 p += len;
14059 printf (" Tag_ABI_wchar_t: ");
14060 switch (val)
14061 {
14062 case 0:
14063 printf (_("Not used\n"));
14064 break;
14065 case 1:
14066 printf (_("2 bytes\n"));
14067 break;
14068 case 2:
14069 printf (_("4 bytes\n"));
14070 break;
14071 default:
14072 printf ("??? (%d)\n", val);
14073 break;
14074 }
14075 return p;
14076
14077 case Tag_ABI_stack_align_needed:
f6f0e17b 14078 val = read_uleb128 (p, &len, end);
87779176
JM		 14079 p += len;
14080 printf (" Tag_ABI_stack_align_needed: ");
14081 switch (val)
14082 {
14083 case 0:
14084 printf (_("8-byte\n"));
14085 break;
14086 case 1:
14087 printf (_("16-byte\n"));
14088 break;
14089 default:
14090 printf ("??? (%d)\n", val);
14091 break;
14092 }
14093 return p;
14094
14095 case Tag_ABI_stack_align_preserved:
f6f0e17b 14096 val = read_uleb128 (p, &len, end);
87779176
JM		 14097 p += len;
14098 printf (" Tag_ABI_stack_align_preserved: ");
14099 switch (val)
14100 {
14101 case 0:
14102 printf (_("8-byte\n"));
14103 break;
14104 case 1:
14105 printf (_("16-byte\n"));
14106 break;
14107 default:
14108 printf ("??? (%d)\n", val);
14109 break;
14110 }
14111 return p;
14112
b5593623 14113 case Tag_ABI_DSBT:
f6f0e17b 14114 val = read_uleb128 (p, &len, end);
b5593623
JM		 14115 p += len;
14116 printf (" Tag_ABI_DSBT: ");
14117 switch (val)
14118 {
14119 case 0:
14120 printf (_("DSBT addressing not used\n"));
14121 break;
14122 case 1:
14123 printf (_("DSBT addressing used\n"));
14124 break;
14125 default:
14126 printf ("??? (%d)\n", val);
14127 break;
14128 }
14129 return p;
14130
87779176 14131 case Tag_ABI_PID:
f6f0e17b 14132 val = read_uleb128 (p, &len, end);
87779176
JM		 14133 p += len;
14134 printf (" Tag_ABI_PID: ");
14135 switch (val)
14136 {
14137 case 0:
14138 printf (_("Data addressing position-dependent\n"));
14139 break;
14140 case 1:
14141 printf (_("Data addressing position-independent, GOT near DP\n"));
14142 break;
14143 case 2:
14144 printf (_("Data addressing position-independent, GOT far from DP\n"));
14145 break;
14146 default:
14147 printf ("??? (%d)\n", val);
14148 break;
14149 }
14150 return p;
14151
14152 case Tag_ABI_PIC:
f6f0e17b 14153 val = read_uleb128 (p, &len, end);
87779176
JM		 14154 p += len;
14155 printf (" Tag_ABI_PIC: ");
14156 switch (val)
14157 {
14158 case 0:
14159 printf (_("Code addressing position-dependent\n"));
14160 break;
14161 case 1:
14162 printf (_("Code addressing position-independent\n"));
14163 break;
14164 default:
14165 printf ("??? (%d)\n", val);
14166 break;
14167 }
14168 return p;
14169
14170 case Tag_ABI_array_object_alignment:
f6f0e17b 14171 val = read_uleb128 (p, &len, end);
87779176
JM		 14172 p += len;
14173 printf (" Tag_ABI_array_object_alignment: ");
14174 switch (val)
14175 {
14176 case 0:
14177 printf (_("8-byte\n"));
14178 break;
14179 case 1:
14180 printf (_("4-byte\n"));
14181 break;
14182 case 2:
14183 printf (_("16-byte\n"));
14184 break;
14185 default:
14186 printf ("??? (%d)\n", val);
14187 break;
14188 }
14189 return p;
14190
14191 case Tag_ABI_array_object_align_expected:
f6f0e17b 14192 val = read_uleb128 (p, &len, end);
87779176
JM		 14193 p += len;
14194 printf (" Tag_ABI_array_object_align_expected: ");
14195 switch (val)
14196 {
14197 case 0:
14198 printf (_("8-byte\n"));
14199 break;
14200 case 1:
14201 printf (_("4-byte\n"));
14202 break;
14203 case 2:
14204 printf (_("16-byte\n"));
14205 break;
14206 default:
14207 printf ("??? (%d)\n", val);
14208 break;
14209 }
14210 return p;
14211
3cbd1c06 14212 case Tag_ABI_compatibility:
071436c6 14213 {
071436c6
NC		 14214 val = read_uleb128 (p, &len, end);
14215 p += len;
14216 printf (" Tag_ABI_compatibility: ");
071436c6 14217 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 14218 if (p < end - 1)
14219 {
14220 size_t maxlen = (end - p) - 1;
14221
14222 print_symbol ((int) maxlen, (const char *) p);
14223 p += strnlen ((char *) p, maxlen) + 1;
14224 }
14225 else
14226 {
14227 printf (_("<corrupt>"));
14228 p = (unsigned char *) end;
14229 }
071436c6 14230 putchar ('\n');
071436c6
NC		 14231 return p;
14232 }
87779176
JM		 14233
14234 case Tag_ABI_conformance:
071436c6 14235 {
4082ef84
NC		 14236 printf (" Tag_ABI_conformance: \"");
14237 if (p < end - 1)
14238 {
14239 size_t maxlen = (end - p) - 1;
071436c6 14240
4082ef84
NC		 14241 print_symbol ((int) maxlen, (const char *) p);
14242 p += strnlen ((char *) p, maxlen) + 1;
14243 }
14244 else
14245 {
14246 printf (_("<corrupt>"));
14247 p = (unsigned char *) end;
14248 }
071436c6 14249 printf ("\"\n");
071436c6
NC		 14250 return p;
14251 }
59e6276b
JM		 14252 }
14253
f6f0e17b
NC		 14254 return display_tag_value (tag, p, end);
14255}
59e6276b 14256
f6f0e17b 14257static void
60abdbed 14258display_raw_attribute (unsigned char * p, unsigned char const * const end)
f6f0e17b
NC		 14259{
14260 unsigned long addr = 0;
14261 size_t bytes = end - p;
14262
e0a31db1 14263 assert (end > p);
f6f0e17b 14264 while (bytes)
87779176 14265 {
f6f0e17b
NC		 14266 int j;
14267 int k;
14268 int lbytes = (bytes > 16 ? 16 : bytes);
14269
14270 printf (" 0x%8.8lx ", addr);
14271
14272 for (j = 0; j < 16; j++)
14273 {
14274 if (j < lbytes)
14275 printf ("%2.2x", p[j]);
14276 else
14277 printf (" ");
14278
14279 if ((j & 3) == 3)
14280 printf (" ");
14281 }
14282
14283 for (j = 0; j < lbytes; j++)
14284 {
14285 k = p[j];
14286 if (k >= ' ' && k < 0x7f)
14287 printf ("%c", k);
14288 else
14289 printf (".");
14290 }
14291
14292 putchar ('\n');
14293
14294 p += lbytes;
14295 bytes -= lbytes;
14296 addr += lbytes;
87779176 14297 }
59e6276b 14298
f6f0e17b 14299 putchar ('\n');
59e6276b
JM		 14300}
14301
13761a11
NC		 14302static unsigned char *
14303display_msp430x_attribute (unsigned char * p,
14304 const unsigned char * const end)
14305{
14306 unsigned int len;
60abdbed
NC		 14307 unsigned int val;
14308 unsigned int tag;
13761a11
NC		 14309
14310 tag = read_uleb128 (p, & len, end);
14311 p += len;
0b4362b0 14312
13761a11
NC		 14313 switch (tag)
14314 {
14315 case OFBA_MSPABI_Tag_ISA:
14316 val = read_uleb128 (p, &len, end);
14317 p += len;
14318 printf (" Tag_ISA: ");
14319 switch (val)
14320 {
14321 case 0: printf (_("None\n")); break;
14322 case 1: printf (_("MSP430\n")); break;
14323 case 2: printf (_("MSP430X\n")); break;
14324 default: printf ("??? (%d)\n", val); break;
14325 }
14326 break;
14327
14328 case OFBA_MSPABI_Tag_Code_Model:
14329 val = read_uleb128 (p, &len, end);
14330 p += len;
14331 printf (" Tag_Code_Model: ");
14332 switch (val)
14333 {
14334 case 0: printf (_("None\n")); break;
14335 case 1: printf (_("Small\n")); break;
14336 case 2: printf (_("Large\n")); break;
14337 default: printf ("??? (%d)\n", val); break;
14338 }
14339 break;
14340
14341 case OFBA_MSPABI_Tag_Data_Model:
14342 val = read_uleb128 (p, &len, end);
14343 p += len;
14344 printf (" Tag_Data_Model: ");
14345 switch (val)
14346 {
14347 case 0: printf (_("None\n")); break;
14348 case 1: printf (_("Small\n")); break;
14349 case 2: printf (_("Large\n")); break;
14350 case 3: printf (_("Restricted Large\n")); break;
14351 default: printf ("??? (%d)\n", val); break;
14352 }
14353 break;
14354
14355 default:
14356 printf (_(" <unknown tag %d>: "), tag);
14357
14358 if (tag & 1)
14359 {
071436c6 14360 putchar ('"');
4082ef84
NC		 14361 if (p < end - 1)
14362 {
14363 size_t maxlen = (end - p) - 1;
14364
14365 print_symbol ((int) maxlen, (const char *) p);
14366 p += strnlen ((char *) p, maxlen) + 1;
14367 }
14368 else
14369 {
14370 printf (_("<corrupt>"));
14371 p = (unsigned char *) end;
14372 }
071436c6 14373 printf ("\"\n");
13761a11
NC		 14374 }
14375 else
14376 {
14377 val = read_uleb128 (p, &len, end);
14378 p += len;
14379 printf ("%d (0x%x)\n", val, val);
14380 }
14381 break;
14382 }
14383
4082ef84 14384 assert (p <= end);
13761a11
NC		 14385 return p;
14386}
14387
11c1ff18 14388static int
60bca95a
NC		 14389process_attributes (FILE * file,
14390 const char * public_name,
104d59d1 14391 unsigned int proc_type,
f6f0e17b 14392 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
60abdbed 14393 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
11c1ff18 14394{
2cf0635d 14395 Elf_Internal_Shdr * sect;
11c1ff18
PB		 14396 unsigned i;
14397
14398 /* Find the section header so that we get the size. */
14399 for (i = 0, sect = section_headers;
14400 i < elf_header.e_shnum;
14401 i++, sect++)
14402 {
071436c6
NC		 14403 unsigned char * contents;
14404 unsigned char * p;
14405
104d59d1 14406 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 14407 continue;
14408
3f5e193b
NC		 14409 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
14410 sect->sh_size, _("attributes"));
60bca95a 14411 if (contents == NULL)
11c1ff18 14412 continue;
60bca95a 14413
11c1ff18 14414 p = contents;
60abdbed
NC		 14415 /* The first character is the version of the attributes.
14416 Currently only version 1, (aka 'A') is recognised here. */
14417 if (*p != 'A')
14418 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
14419 else
11c1ff18 14420 {
071436c6
NC		 14421 bfd_vma section_len;
14422
14423 section_len = sect->sh_size - 1;
11c1ff18 14424 p++;
60bca95a 14425
071436c6 14426 while (section_len > 0)
11c1ff18 14427 {
071436c6 14428 bfd_vma attr_len;
e9847026 14429 unsigned int namelen;
11c1ff18 14430 bfd_boolean public_section;
104d59d1 14431 bfd_boolean gnu_section;
11c1ff18 14432
071436c6 14433 if (section_len <= 4)
e0a31db1
NC		 14434 {
14435 error (_("Tag section ends prematurely\n"));
14436 break;
14437 }
071436c6 14438 attr_len = byte_get (p, 4);
11c1ff18 14439 p += 4;
60bca95a 14440
071436c6 14441 if (attr_len > section_len)
11c1ff18 14442 {
071436c6
NC		 14443 error (_("Bad attribute length (%u > %u)\n"),
14444 (unsigned) attr_len, (unsigned) section_len);
14445 attr_len = section_len;
11c1ff18 14446 }
74e1a04b 14447 /* PR 17531: file: 001-101425-0.004 */
071436c6 14448 else if (attr_len < 5)
74e1a04b 14449 {
071436c6 14450 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
74e1a04b
NC		 14451 break;
14452 }
e9847026 14453
071436c6
NC		 14454 section_len -= attr_len;
14455 attr_len -= 4;
14456
14457 namelen = strnlen ((char *) p, attr_len) + 1;
14458 if (namelen == 0 || namelen >= attr_len)
e9847026
NC		 14459 {
14460 error (_("Corrupt attribute section name\n"));
14461 break;
14462 }
14463
071436c6
NC		 14464 printf (_("Attribute Section: "));
14465 print_symbol (INT_MAX, (const char *) p);
14466 putchar ('\n');
60bca95a
NC		 14467
14468 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 14469 public_section = TRUE;
14470 else
14471 public_section = FALSE;
60bca95a
NC		 14472
14473 if (streq ((char *) p, "gnu"))
104d59d1
JM		 14474 gnu_section = TRUE;
14475 else
14476 gnu_section = FALSE;
60bca95a 14477
11c1ff18 14478 p += namelen;
071436c6 14479 attr_len -= namelen;
e0a31db1 14480
071436c6 14481 while (attr_len > 0 && p < contents + sect->sh_size)
11c1ff18 14482 {
e0a31db1 14483 int tag;
11c1ff18
PB		 14484 int val;
14485 bfd_vma size;
071436c6 14486 unsigned char * end;
60bca95a 14487
e0a31db1 14488 /* PR binutils/17531: Safe handling of corrupt files. */
071436c6 14489 if (attr_len < 6)
e0a31db1
NC		 14490 {
14491 error (_("Unused bytes at end of section\n"));
14492 section_len = 0;
14493 break;
14494 }
14495
14496 tag = *(p++);
11c1ff18 14497 size = byte_get (p, 4);
071436c6 14498 if (size > attr_len)
11c1ff18 14499 {
e9847026 14500 error (_("Bad subsection length (%u > %u)\n"),
071436c6
NC		 14501 (unsigned) size, (unsigned) attr_len);
14502 size = attr_len;
11c1ff18 14503 }
e0a31db1
NC		 14504 /* PR binutils/17531: Safe handling of corrupt files. */
14505 if (size < 6)
14506 {
14507 error (_("Bad subsection length (%u < 6)\n"),
14508 (unsigned) size);
14509 section_len = 0;
14510 break;
14511 }
60bca95a 14512
071436c6 14513 attr_len -= size;
11c1ff18 14514 end = p + size - 1;
071436c6 14515 assert (end <= contents + sect->sh_size);
11c1ff18 14516 p += 4;
60bca95a 14517
11c1ff18
PB		 14518 switch (tag)
14519 {
14520 case 1:
2b692964 14521 printf (_("File Attributes\n"));
11c1ff18
PB		 14522 break;
14523 case 2:
2b692964 14524 printf (_("Section Attributes:"));
11c1ff18
PB		 14525 goto do_numlist;
14526 case 3:
2b692964 14527 printf (_("Symbol Attributes:"));
1a0670f3 14528 /* Fall through. */
11c1ff18
PB		 14529 do_numlist:
14530 for (;;)
14531 {
91d6fa6a 14532 unsigned int j;
60bca95a 14533
f6f0e17b 14534 val = read_uleb128 (p, &j, end);
91d6fa6a 14535 p += j;
11c1ff18
PB		 14536 if (val == 0)
14537 break;
14538 printf (" %d", val);
14539 }
14540 printf ("\n");
14541 break;
14542 default:
2b692964 14543 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 14544 public_section = FALSE;
14545 break;
14546 }
60bca95a 14547
071436c6 14548 if (public_section && display_pub_attribute != NULL)
11c1ff18
PB		 14549 {
14550 while (p < end)
f6f0e17b 14551 p = display_pub_attribute (p, end);
60abdbed 14552 assert (p == end);
104d59d1 14553 }
071436c6 14554 else if (gnu_section && display_proc_gnu_attribute != NULL)
104d59d1
JM		 14555 {
14556 while (p < end)
14557 p = display_gnu_attribute (p,
f6f0e17b
NC		 14558 display_proc_gnu_attribute,
14559 end);
60abdbed 14560 assert (p == end);
11c1ff18 14561 }
071436c6 14562 else if (p < end)
11c1ff18 14563 {
071436c6 14564 printf (_(" Unknown attribute:\n"));
f6f0e17b 14565 display_raw_attribute (p, end);
11c1ff18
PB		 14566 p = end;
14567 }
071436c6
NC		 14568 else
14569 attr_len = 0;
11c1ff18
PB		 14570 }
14571 }
14572 }
d70c5fc7 14573
60bca95a 14574 free (contents);
11c1ff18
PB		 14575 }
14576 return 1;
14577}
14578
ccb4c951
RS		 14579/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14580 Print the Address, Access and Initial fields of an entry at VMA ADDR
82b1b41b
NC		 14581 and return the VMA of the next entry, or -1 if there was a problem.
14582 Does not read from DATA_END or beyond. */
ccb4c951
RS		 14583
14584static bfd_vma
82b1b41b
NC		 14585print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
14586 unsigned char * data_end)
ccb4c951
RS		 14587{
14588 printf (" ");
14589 print_vma (addr, LONG_HEX);
14590 printf (" ");
14591 if (addr < pltgot + 0xfff0)
14592 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
14593 else
14594 printf ("%10s", "");
14595 printf (" ");
14596 if (data == NULL)
2b692964 14597 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 14598 else
14599 {
14600 bfd_vma entry;
82b1b41b 14601 unsigned char * from = data + addr - pltgot;
ccb4c951 14602
82b1b41b
NC		 14603 if (from + (is_32bit_elf ? 4 : 8) > data_end)
14604 {
14605 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14606 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
14607 return (bfd_vma) -1;
14608 }
14609 else
14610 {
14611 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14612 print_vma (entry, LONG_HEX);
14613 }
ccb4c951
RS		 14614 }
14615 return addr + (is_32bit_elf ? 4 : 8);
14616}
14617
861fb55a
DJ		 14618/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14619 PLTGOT. Print the Address and Initial fields of an entry at VMA
14620 ADDR and return the VMA of the next entry. */
14621
14622static bfd_vma
2cf0635d 14623print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 14624{
14625 printf (" ");
14626 print_vma (addr, LONG_HEX);
14627 printf (" ");
14628 if (data == NULL)
2b692964 14629 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 14630 else
14631 {
14632 bfd_vma entry;
14633
14634 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14635 print_vma (entry, LONG_HEX);
14636 }
14637 return addr + (is_32bit_elf ? 4 : 8);
14638}
14639
351cdf24
MF		 14640static void
14641print_mips_ases (unsigned int mask)
14642{
14643 if (mask & AFL_ASE_DSP)
14644 fputs ("\n\tDSP ASE", stdout);
14645 if (mask & AFL_ASE_DSPR2)
14646 fputs ("\n\tDSP R2 ASE", stdout);
8f4f9071
MF		 14647 if (mask & AFL_ASE_DSPR3)
14648 fputs ("\n\tDSP R3 ASE", stdout);
351cdf24
MF		 14649 if (mask & AFL_ASE_EVA)
14650 fputs ("\n\tEnhanced VA Scheme", stdout);
14651 if (mask & AFL_ASE_MCU)
14652 fputs ("\n\tMCU (MicroController) ASE", stdout);
14653 if (mask & AFL_ASE_MDMX)
14654 fputs ("\n\tMDMX ASE", stdout);
14655 if (mask & AFL_ASE_MIPS3D)
14656 fputs ("\n\tMIPS-3D ASE", stdout);
14657 if (mask & AFL_ASE_MT)
14658 fputs ("\n\tMT ASE", stdout);
14659 if (mask & AFL_ASE_SMARTMIPS)
14660 fputs ("\n\tSmartMIPS ASE", stdout);
14661 if (mask & AFL_ASE_VIRT)
14662 fputs ("\n\tVZ ASE", stdout);
14663 if (mask & AFL_ASE_MSA)
14664 fputs ("\n\tMSA ASE", stdout);
14665 if (mask & AFL_ASE_MIPS16)
14666 fputs ("\n\tMIPS16 ASE", stdout);
14667 if (mask & AFL_ASE_MICROMIPS)
14668 fputs ("\n\tMICROMIPS ASE", stdout);
14669 if (mask & AFL_ASE_XPA)
14670 fputs ("\n\tXPA ASE", stdout);
14671 if (mask == 0)
14672 fprintf (stdout, "\n\t%s", _("None"));
00ac7aa0
MF		 14673 else if ((mask & ~AFL_ASE_MASK) != 0)
14674 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
351cdf24
MF		 14675}
14676
14677static void
14678print_mips_isa_ext (unsigned int isa_ext)
14679{
14680 switch (isa_ext)
14681 {
14682 case 0:
14683 fputs (_("None"), stdout);
14684 break;
14685 case AFL_EXT_XLR:
14686 fputs ("RMI XLR", stdout);
14687 break;
2c629856
N		 14688 case AFL_EXT_OCTEON3:
14689 fputs ("Cavium Networks Octeon3", stdout);
14690 break;
351cdf24
MF		 14691 case AFL_EXT_OCTEON2:
14692 fputs ("Cavium Networks Octeon2", stdout);
14693 break;
14694 case AFL_EXT_OCTEONP:
14695 fputs ("Cavium Networks OcteonP", stdout);
14696 break;
14697 case AFL_EXT_LOONGSON_3A:
14698 fputs ("Loongson 3A", stdout);
14699 break;
14700 case AFL_EXT_OCTEON:
14701 fputs ("Cavium Networks Octeon", stdout);
14702 break;
14703 case AFL_EXT_5900:
14704 fputs ("Toshiba R5900", stdout);
14705 break;
14706 case AFL_EXT_4650:
14707 fputs ("MIPS R4650", stdout);
14708 break;
14709 case AFL_EXT_4010:
14710 fputs ("LSI R4010", stdout);
14711 break;
14712 case AFL_EXT_4100:
14713 fputs ("NEC VR4100", stdout);
14714 break;
14715 case AFL_EXT_3900:
14716 fputs ("Toshiba R3900", stdout);
14717 break;
14718 case AFL_EXT_10000:
14719 fputs ("MIPS R10000", stdout);
14720 break;
14721 case AFL_EXT_SB1:
14722 fputs ("Broadcom SB-1", stdout);
14723 break;
14724 case AFL_EXT_4111:
14725 fputs ("NEC VR4111/VR4181", stdout);
14726 break;
14727 case AFL_EXT_4120:
14728 fputs ("NEC VR4120", stdout);
14729 break;
14730 case AFL_EXT_5400:
14731 fputs ("NEC VR5400", stdout);
14732 break;
14733 case AFL_EXT_5500:
14734 fputs ("NEC VR5500", stdout);
14735 break;
14736 case AFL_EXT_LOONGSON_2E:
14737 fputs ("ST Microelectronics Loongson 2E", stdout);
14738 break;
14739 case AFL_EXT_LOONGSON_2F:
14740 fputs ("ST Microelectronics Loongson 2F", stdout);
14741 break;
14742 default:
00ac7aa0 14743 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
351cdf24
MF		 14744 }
14745}
14746
14747static int
14748get_mips_reg_size (int reg_size)
14749{
14750 return (reg_size == AFL_REG_NONE) ? 0
14751 : (reg_size == AFL_REG_32) ? 32
14752 : (reg_size == AFL_REG_64) ? 64
14753 : (reg_size == AFL_REG_128) ? 128
14754 : -1;
14755}
14756
19e6b90e 14757static int
2cf0635d 14758process_mips_specific (FILE * file)
5b18a4bc 14759{
2cf0635d 14760 Elf_Internal_Dyn * entry;
351cdf24 14761 Elf_Internal_Shdr *sect = NULL;
19e6b90e
L		 14762 size_t liblist_offset = 0;
14763 size_t liblistno = 0;
14764 size_t conflictsno = 0;
14765 size_t options_offset = 0;
14766 size_t conflicts_offset = 0;
861fb55a
DJ		 14767 size_t pltrelsz = 0;
14768 size_t pltrel = 0;
ccb4c951 14769 bfd_vma pltgot = 0;
861fb55a
DJ		 14770 bfd_vma mips_pltgot = 0;
14771 bfd_vma jmprel = 0;
ccb4c951
RS		 14772 bfd_vma local_gotno = 0;
14773 bfd_vma gotsym = 0;
14774 bfd_vma symtabno = 0;
103f02d3 14775
2cf19d5c
JM		 14776 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14777 display_mips_gnu_attribute);
14778
351cdf24
MF		 14779 sect = find_section (".MIPS.abiflags");
14780
14781 if (sect != NULL)
14782 {
14783 Elf_External_ABIFlags_v0 *abiflags_ext;
14784 Elf_Internal_ABIFlags_v0 abiflags_in;
14785
14786 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
14787 fputs ("\nCorrupt ABI Flags section.\n", stdout);
14788 else
14789 {
14790 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
14791 sect->sh_size, _("MIPS ABI Flags section"));
14792 if (abiflags_ext)
14793 {
14794 abiflags_in.version = BYTE_GET (abiflags_ext->version);
14795 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
14796 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
14797 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
14798 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
14799 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
14800 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
14801 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
14802 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
14803 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
14804 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
14805
14806 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
14807 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
14808 if (abiflags_in.isa_rev > 1)
14809 printf ("r%d", abiflags_in.isa_rev);
14810 printf ("\nGPR size: %d",
14811 get_mips_reg_size (abiflags_in.gpr_size));
14812 printf ("\nCPR1 size: %d",
14813 get_mips_reg_size (abiflags_in.cpr1_size));
14814 printf ("\nCPR2 size: %d",
14815 get_mips_reg_size (abiflags_in.cpr2_size));
14816 fputs ("\nFP ABI: ", stdout);
14817 print_mips_fp_abi_value (abiflags_in.fp_abi);
14818 fputs ("ISA Extension: ", stdout);
14819 print_mips_isa_ext (abiflags_in.isa_ext);
14820 fputs ("\nASEs:", stdout);
14821 print_mips_ases (abiflags_in.ases);
14822 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
14823 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
14824 fputc ('\n', stdout);
14825 free (abiflags_ext);
14826 }
14827 }
14828 }
14829
19e6b90e
L		 14830 /* We have a lot of special sections. Thanks SGI! */
14831 if (dynamic_section == NULL)
14832 /* No information available. */
14833 return 0;
252b5132 14834
071436c6
NC		 14835 for (entry = dynamic_section;
14836 /* PR 17531 file: 012-50589-0.004. */
14837 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
14838 ++entry)
252b5132
RH		 14839 switch (entry->d_tag)
14840 {
14841 case DT_MIPS_LIBLIST:
d93f0186
NC		 14842 liblist_offset
14843 = offset_from_vma (file, entry->d_un.d_val,
14844 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 14845 break;
14846 case DT_MIPS_LIBLISTNO:
14847 liblistno = entry->d_un.d_val;
14848 break;
14849 case DT_MIPS_OPTIONS:
d93f0186 14850 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 14851 break;
14852 case DT_MIPS_CONFLICT:
d93f0186
NC		 14853 conflicts_offset
14854 = offset_from_vma (file, entry->d_un.d_val,
14855 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 14856 break;
14857 case DT_MIPS_CONFLICTNO:
14858 conflictsno = entry->d_un.d_val;
14859 break;
ccb4c951 14860 case DT_PLTGOT:
861fb55a
DJ		 14861 pltgot = entry->d_un.d_ptr;
14862 break;
ccb4c951
RS		 14863 case DT_MIPS_LOCAL_GOTNO:
14864 local_gotno = entry->d_un.d_val;
14865 break;
14866 case DT_MIPS_GOTSYM:
14867 gotsym = entry->d_un.d_val;
14868 break;
14869 case DT_MIPS_SYMTABNO:
14870 symtabno = entry->d_un.d_val;
14871 break;
861fb55a
DJ		 14872 case DT_MIPS_PLTGOT:
14873 mips_pltgot = entry->d_un.d_ptr;
14874 break;
14875 case DT_PLTREL:
14876 pltrel = entry->d_un.d_val;
14877 break;
14878 case DT_PLTRELSZ:
14879 pltrelsz = entry->d_un.d_val;
14880 break;
14881 case DT_JMPREL:
14882 jmprel = entry->d_un.d_ptr;
14883 break;
252b5132
RH		 14884 default:
14885 break;
14886 }
14887
14888 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
14889 {
2cf0635d 14890 Elf32_External_Lib * elib;
252b5132
RH		 14891 size_t cnt;
14892
3f5e193b
NC		 14893 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
14894 liblistno,
14895 sizeof (Elf32_External_Lib),
9cf03b7e 14896 _("liblist section data"));
a6e9f9df 14897 if (elib)
252b5132 14898 {
2b692964 14899 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 14900 (unsigned long) liblistno);
2b692964 14901 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 14902 stdout);
14903
14904 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 14905 {
a6e9f9df 14906 Elf32_Lib liblist;
91d6fa6a 14907 time_t atime;
d5b07ef4 14908 char timebuf[128];
2cf0635d 14909 struct tm * tmp;
a6e9f9df
AM		 14910
14911 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14912 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 14913 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14914 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14915 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14916
91d6fa6a 14917 tmp = gmtime (&atime);
e9e44622
JJ		 14918 snprintf (timebuf, sizeof (timebuf),
14919 "%04u-%02u-%02uT%02u:%02u:%02u",
14920 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14921 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 14922
31104126 14923 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 14924 if (VALID_DYNAMIC_NAME (liblist.l_name))
14925 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
14926 else
2b692964 14927 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 14928 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
14929 liblist.l_version);
a6e9f9df
AM		 14930
14931 if (liblist.l_flags == 0)
2b692964 14932 puts (_(" NONE"));
a6e9f9df
AM		 14933 else
14934 {
14935 static const struct
252b5132 14936 {
2cf0635d 14937 const char * name;
a6e9f9df 14938 int bit;
252b5132 14939 }
a6e9f9df
AM		 14940 l_flags_vals[] =
14941 {
14942 { " EXACT_MATCH", LL_EXACT_MATCH },
14943 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
14944 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
14945 { " EXPORTS", LL_EXPORTS },
14946 { " DELAY_LOAD", LL_DELAY_LOAD },
14947 { " DELTA", LL_DELTA }
14948 };
14949 int flags = liblist.l_flags;
14950 size_t fcnt;
14951
60bca95a 14952 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 14953 if ((flags & l_flags_vals[fcnt].bit) != 0)
14954 {
14955 fputs (l_flags_vals[fcnt].name, stdout);
14956 flags ^= l_flags_vals[fcnt].bit;
14957 }
14958 if (flags != 0)
14959 printf (" %#x", (unsigned int) flags);
252b5132 14960
a6e9f9df
AM		 14961 puts ("");
14962 }
252b5132 14963 }
252b5132 14964
a6e9f9df
AM		 14965 free (elib);
14966 }
252b5132
RH		 14967 }
14968
14969 if (options_offset != 0)
14970 {
2cf0635d 14971 Elf_External_Options * eopt;
2cf0635d
NC		 14972 Elf_Internal_Options * iopt;
14973 Elf_Internal_Options * option;
252b5132
RH		 14974 size_t offset;
14975 int cnt;
351cdf24 14976 sect = section_headers;
252b5132
RH		 14977
14978 /* Find the section header so that we get the size. */
071436c6 14979 sect = find_section_by_type (SHT_MIPS_OPTIONS);
948f632f 14980 /* PR 17533 file: 012-277276-0.004. */
071436c6
NC		 14981 if (sect == NULL)
14982 {
14983 error (_("No MIPS_OPTIONS header found\n"));
14984 return 0;
14985 }
252b5132 14986
3f5e193b
NC		 14987 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
14988 sect->sh_size, _("options"));
a6e9f9df 14989 if (eopt)
252b5132 14990 {
3f5e193b
NC		 14991 iopt = (Elf_Internal_Options *)
14992 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 14993 if (iopt == NULL)
14994 {
fb324ee9 14995 error (_("Out of memory allocating space for MIPS options\n"));
a6e9f9df
AM		 14996 return 0;
14997 }
76da6bbe 14998
a6e9f9df
AM		 14999 offset = cnt = 0;
15000 option = iopt;
252b5132 15001
82b1b41b 15002 while (offset <= sect->sh_size - sizeof (* eopt))
a6e9f9df 15003 {
2cf0635d 15004 Elf_External_Options * eoption;
252b5132 15005
a6e9f9df 15006 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 15007
a6e9f9df
AM		 15008 option->kind = BYTE_GET (eoption->kind);
15009 option->size = BYTE_GET (eoption->size);
15010 option->section = BYTE_GET (eoption->section);
15011 option->info = BYTE_GET (eoption->info);
76da6bbe 15012
82b1b41b
NC		 15013 /* PR 17531: file: ffa0fa3b. */
15014 if (option->size < sizeof (* eopt)
15015 || offset + option->size > sect->sh_size)
15016 {
55325047
NC		 15017 error (_("Invalid size (%u) for MIPS option\n"), option->size);
15018 return 0;
82b1b41b 15019 }
a6e9f9df 15020 offset += option->size;
14ae95f2 15021
a6e9f9df
AM		 15022 ++option;
15023 ++cnt;
15024 }
252b5132 15025
a6e9f9df 15026 printf (_("\nSection '%s' contains %d entries:\n"),
74e1a04b 15027 printable_section_name (sect), cnt);
76da6bbe 15028
a6e9f9df 15029 option = iopt;
82b1b41b 15030 offset = 0;
252b5132 15031
a6e9f9df 15032 while (cnt-- > 0)
252b5132 15033 {
a6e9f9df
AM		 15034 size_t len;
15035
15036 switch (option->kind)
252b5132 15037 {
a6e9f9df
AM		 15038 case ODK_NULL:
15039 /* This shouldn't happen. */
15040 printf (" NULL %d %lx", option->section, option->info);
15041 break;
15042 case ODK_REGINFO:
15043 printf (" REGINFO ");
15044 if (elf_header.e_machine == EM_MIPS)
15045 {
15046 /* 32bit form. */
2cf0635d 15047 Elf32_External_RegInfo * ereg;
b34976b6 15048 Elf32_RegInfo reginfo;
a6e9f9df
AM		 15049
15050 ereg = (Elf32_External_RegInfo *) (option + 1);
15051 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
15052 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15053 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15054 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15055 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15056 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
15057
15058 printf ("GPR %08lx GP 0x%lx\n",
15059 reginfo.ri_gprmask,
15060 (unsigned long) reginfo.ri_gp_value);
15061 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15062 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15063 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15064 }
15065 else
15066 {
15067 /* 64 bit form. */
2cf0635d 15068 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 15069 Elf64_Internal_RegInfo reginfo;
15070
15071 ereg = (Elf64_External_RegInfo *) (option + 1);
15072 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
15073 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15074 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15075 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15076 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 15077 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 15078
15079 printf ("GPR %08lx GP 0x",
15080 reginfo.ri_gprmask);
15081 printf_vma (reginfo.ri_gp_value);
15082 printf ("\n");
15083
15084 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15085 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15086 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15087 }
15088 ++option;
15089 continue;
15090 case ODK_EXCEPTIONS:
15091 fputs (" EXCEPTIONS fpe_min(", stdout);
15092 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
15093 fputs (") fpe_max(", stdout);
15094 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
15095 fputs (")", stdout);
15096
15097 if (option->info & OEX_PAGE0)
15098 fputs (" PAGE0", stdout);
15099 if (option->info & OEX_SMM)
15100 fputs (" SMM", stdout);
15101 if (option->info & OEX_FPDBUG)
15102 fputs (" FPDBUG", stdout);
15103 if (option->info & OEX_DISMISS)
15104 fputs (" DISMISS", stdout);
15105 break;
15106 case ODK_PAD:
15107 fputs (" PAD ", stdout);
15108 if (option->info & OPAD_PREFIX)
15109 fputs (" PREFIX", stdout);
15110 if (option->info & OPAD_POSTFIX)
15111 fputs (" POSTFIX", stdout);
15112 if (option->info & OPAD_SYMBOL)
15113 fputs (" SYMBOL", stdout);
15114 break;
15115 case ODK_HWPATCH:
15116 fputs (" HWPATCH ", stdout);
15117 if (option->info & OHW_R4KEOP)
15118 fputs (" R4KEOP", stdout);
15119 if (option->info & OHW_R8KPFETCH)
15120 fputs (" R8KPFETCH", stdout);
15121 if (option->info & OHW_R5KEOP)
15122 fputs (" R5KEOP", stdout);
15123 if (option->info & OHW_R5KCVTL)
15124 fputs (" R5KCVTL", stdout);
15125 break;
15126 case ODK_FILL:
15127 fputs (" FILL ", stdout);
15128 /* XXX Print content of info word? */
15129 break;
15130 case ODK_TAGS:
15131 fputs (" TAGS ", stdout);
15132 /* XXX Print content of info word? */
15133 break;
15134 case ODK_HWAND:
15135 fputs (" HWAND ", stdout);
15136 if (option->info & OHWA0_R4KEOP_CHECKED)
15137 fputs (" R4KEOP_CHECKED", stdout);
15138 if (option->info & OHWA0_R4KEOP_CLEAN)
15139 fputs (" R4KEOP_CLEAN", stdout);
15140 break;
15141 case ODK_HWOR:
15142 fputs (" HWOR ", stdout);
15143 if (option->info & OHWA0_R4KEOP_CHECKED)
15144 fputs (" R4KEOP_CHECKED", stdout);
15145 if (option->info & OHWA0_R4KEOP_CLEAN)
15146 fputs (" R4KEOP_CLEAN", stdout);
15147 break;
15148 case ODK_GP_GROUP:
15149 printf (" GP_GROUP %#06lx self-contained %#06lx",
15150 option->info & OGP_GROUP,
15151 (option->info & OGP_SELF) >> 16);
15152 break;
15153 case ODK_IDENT:
15154 printf (" IDENT %#06lx self-contained %#06lx",
15155 option->info & OGP_GROUP,
15156 (option->info & OGP_SELF) >> 16);
15157 break;
15158 default:
15159 /* This shouldn't happen. */
15160 printf (" %3d ??? %d %lx",
15161 option->kind, option->section, option->info);
15162 break;
252b5132 15163 }
a6e9f9df 15164
2cf0635d 15165 len = sizeof (* eopt);
a6e9f9df 15166 while (len < option->size)
82b1b41b 15167 {
7e27a9d5 15168 unsigned char datum = * ((unsigned char *) eopt + offset + len);
a6e9f9df 15169
82b1b41b
NC		 15170 if (ISPRINT (datum))
15171 printf ("%c", datum);
15172 else
15173 printf ("\\%03o", datum);
15174 len ++;
15175 }
a6e9f9df 15176 fputs ("\n", stdout);
82b1b41b
NC		 15177
15178 offset += option->size;
252b5132 15179 ++option;
252b5132
RH		 15180 }
15181
a6e9f9df 15182 free (eopt);
252b5132 15183 }
252b5132
RH		 15184 }
15185
15186 if (conflicts_offset != 0 && conflictsno != 0)
15187 {
2cf0635d 15188 Elf32_Conflict * iconf;
252b5132
RH		 15189 size_t cnt;
15190
15191 if (dynamic_symbols == NULL)
15192 {
591a748a 15193 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 15194 return 0;
15195 }
15196
3f5e193b 15197 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 15198 if (iconf == NULL)
15199 {
8b73c356 15200 error (_("Out of memory allocating space for dynamic conflicts\n"));
252b5132
RH		 15201 return 0;
15202 }
15203
9ea033b2 15204 if (is_32bit_elf)
252b5132 15205 {
2cf0635d 15206 Elf32_External_Conflict * econf32;
a6e9f9df 15207
3f5e193b
NC		 15208 econf32 = (Elf32_External_Conflict *)
15209 get_data (NULL, file, conflicts_offset, conflictsno,
15210 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 15211 if (!econf32)
15212 return 0;
252b5132
RH		 15213
15214 for (cnt = 0; cnt < conflictsno; ++cnt)
15215 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 15216
15217 free (econf32);
252b5132
RH		 15218 }
15219 else
15220 {
2cf0635d 15221 Elf64_External_Conflict * econf64;
a6e9f9df 15222
3f5e193b
NC		 15223 econf64 = (Elf64_External_Conflict *)
15224 get_data (NULL, file, conflicts_offset, conflictsno,
15225 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 15226 if (!econf64)
15227 return 0;
252b5132
RH		 15228
15229 for (cnt = 0; cnt < conflictsno; ++cnt)
15230 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 15231
15232 free (econf64);
252b5132
RH		 15233 }
15234
c7e7ca54
NC		 15235 printf (_("\nSection '.conflict' contains %lu entries:\n"),
15236 (unsigned long) conflictsno);
252b5132
RH		 15237 puts (_(" Num: Index Value Name"));
15238
15239 for (cnt = 0; cnt < conflictsno; ++cnt)
15240 {
b34976b6 15241 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
e0a31db1
NC		 15242
15243 if (iconf[cnt] >= num_dynamic_syms)
15244 printf (_("<corrupt symbol index>"));
d79b3d50 15245 else
e0a31db1
NC		 15246 {
15247 Elf_Internal_Sym * psym;
15248
15249 psym = & dynamic_symbols[iconf[cnt]];
15250 print_vma (psym->st_value, FULL_HEX);
15251 putchar (' ');
15252 if (VALID_DYNAMIC_NAME (psym->st_name))
15253 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
15254 else
15255 printf (_("<corrupt: %14ld>"), psym->st_name);
15256 }
31104126 15257 putchar ('\n');
252b5132
RH		 15258 }
15259
252b5132
RH		 15260 free (iconf);
15261 }
15262
ccb4c951
RS		 15263 if (pltgot != 0 && local_gotno != 0)
15264 {
91d6fa6a 15265 bfd_vma ent, local_end, global_end;
bbeee7ea 15266 size_t i, offset;
2cf0635d 15267 unsigned char * data;
82b1b41b 15268 unsigned char * data_end;
bbeee7ea 15269 int addr_size;
ccb4c951 15270
91d6fa6a 15271 ent = pltgot;
ccb4c951
RS		 15272 addr_size = (is_32bit_elf ? 4 : 8);
15273 local_end = pltgot + local_gotno * addr_size;
ccb4c951 15274
74e1a04b
NC		 15275 /* PR binutils/17533 file: 012-111227-0.004 */
15276 if (symtabno < gotsym)
15277 {
15278 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
82b1b41b 15279 (unsigned long) gotsym, (unsigned long) symtabno);
74e1a04b
NC		 15280 return 0;
15281 }
82b1b41b 15282
74e1a04b 15283 global_end = local_end + (symtabno - gotsym) * addr_size;
82b1b41b
NC		 15284 /* PR 17531: file: 54c91a34. */
15285 if (global_end < local_end)
15286 {
15287 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
15288 return 0;
15289 }
948f632f 15290
ccb4c951 15291 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 15292 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 15293 global_end - pltgot, 1,
15294 _("Global Offset Table data"));
59245841
NC		 15295 if (data == NULL)
15296 return 0;
82b1b41b 15297 data_end = data + (global_end - pltgot);
59245841 15298
ccb4c951
RS		 15299 printf (_("\nPrimary GOT:\n"));
15300 printf (_(" Canonical gp value: "));
15301 print_vma (pltgot + 0x7ff0, LONG_HEX);
15302 printf ("\n\n");
15303
15304 printf (_(" Reserved entries:\n"));
15305 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 15306 addr_size * 2, _("Address"), _("Access"),
15307 addr_size * 2, _("Initial"));
82b1b41b 15308 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 15309 printf (_(" Lazy resolver\n"));
82b1b41b
NC		 15310 if (ent == (bfd_vma) -1)
15311 goto got_print_fail;
ccb4c951 15312 if (data
91d6fa6a 15313 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 15314 >> (addr_size * 8 - 1)) != 0)
15315 {
82b1b41b 15316 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 15317 printf (_(" Module pointer (GNU extension)\n"));
82b1b41b
NC		 15318 if (ent == (bfd_vma) -1)
15319 goto got_print_fail;
ccb4c951
RS		 15320 }
15321 printf ("\n");
15322
91d6fa6a 15323 if (ent < local_end)
ccb4c951
RS		 15324 {
15325 printf (_(" Local entries:\n"));
cc5914eb 15326 printf (" %*s %10s %*s\n",
2b692964
NC		 15327 addr_size * 2, _("Address"), _("Access"),
15328 addr_size * 2, _("Initial"));
91d6fa6a 15329 while (ent < local_end)
ccb4c951 15330 {
82b1b41b 15331 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 15332 printf ("\n");
82b1b41b
NC		 15333 if (ent == (bfd_vma) -1)
15334 goto got_print_fail;
ccb4c951
RS		 15335 }
15336 printf ("\n");
15337 }
15338
15339 if (gotsym < symtabno)
15340 {
15341 int sym_width;
15342
15343 printf (_(" Global entries:\n"));
cc5914eb 15344 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 15345 addr_size * 2, _("Address"),
15346 _("Access"),
2b692964 15347 addr_size * 2, _("Initial"),
9cf03b7e
NC		 15348 addr_size * 2, _("Sym.Val."),
15349 _("Type"),
15350 /* Note for translators: "Ndx" = abbreviated form of "Index". */
15351 _("Ndx"), _("Name"));
0b4362b0 15352
ccb4c951 15353 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
e0a31db1 15354
ccb4c951
RS		 15355 for (i = gotsym; i < symtabno; i++)
15356 {
82b1b41b 15357 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 15358 printf (" ");
e0a31db1
NC		 15359
15360 if (dynamic_symbols == NULL)
15361 printf (_("<no dynamic symbols>"));
15362 else if (i < num_dynamic_syms)
15363 {
15364 Elf_Internal_Sym * psym = dynamic_symbols + i;
15365
15366 print_vma (psym->st_value, LONG_HEX);
15367 printf (" %-7s %3s ",
15368 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
15369 get_symbol_index_type (psym->st_shndx));
15370
15371 if (VALID_DYNAMIC_NAME (psym->st_name))
15372 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
15373 else
15374 printf (_("<corrupt: %14ld>"), psym->st_name);
15375 }
ccb4c951 15376 else
7fc5ac57
JBG		 15377 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15378 (unsigned long) i);
e0a31db1 15379
ccb4c951 15380 printf ("\n");
82b1b41b
NC		 15381 if (ent == (bfd_vma) -1)
15382 break;
ccb4c951
RS		 15383 }
15384 printf ("\n");
15385 }
15386
82b1b41b 15387 got_print_fail:
ccb4c951
RS		 15388 if (data)
15389 free (data);
15390 }
15391
861fb55a
DJ		 15392 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
15393 {
91d6fa6a 15394 bfd_vma ent, end;
861fb55a
DJ		 15395 size_t offset, rel_offset;
15396 unsigned long count, i;
2cf0635d 15397 unsigned char * data;
861fb55a 15398 int addr_size, sym_width;
2cf0635d 15399 Elf_Internal_Rela * rels;
861fb55a
DJ		 15400
15401 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
15402 if (pltrel == DT_RELA)
15403 {
15404 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
15405 return 0;
15406 }
15407 else
15408 {
15409 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
15410 return 0;
15411 }
15412
91d6fa6a 15413 ent = mips_pltgot;
861fb55a
DJ		 15414 addr_size = (is_32bit_elf ? 4 : 8);
15415 end = mips_pltgot + (2 + count) * addr_size;
15416
15417 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 15418 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 15419 1, _("Procedure Linkage Table data"));
59245841
NC		 15420 if (data == NULL)
15421 return 0;
15422
9cf03b7e 15423 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 15424 printf (_(" Reserved entries:\n"));
15425 printf (_(" %*s %*s Purpose\n"),
2b692964 15426 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 15427 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 15428 printf (_(" PLT lazy resolver\n"));
91d6fa6a 15429 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 15430 printf (_(" Module pointer\n"));
861fb55a
DJ		 15431 printf ("\n");
15432
15433 printf (_(" Entries:\n"));
cc5914eb 15434 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 15435 addr_size * 2, _("Address"),
15436 addr_size * 2, _("Initial"),
15437 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 15438 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
15439 for (i = 0; i < count; i++)
15440 {
df97ab2a 15441 unsigned long idx = get_reloc_symindex (rels[i].r_info);
861fb55a 15442
91d6fa6a 15443 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a 15444 printf (" ");
e0a31db1 15445
df97ab2a
MF		 15446 if (idx >= num_dynamic_syms)
15447 printf (_("<corrupt symbol index: %lu>"), idx);
861fb55a 15448 else
e0a31db1 15449 {
df97ab2a 15450 Elf_Internal_Sym * psym = dynamic_symbols + idx;
e0a31db1
NC		 15451
15452 print_vma (psym->st_value, LONG_HEX);
15453 printf (" %-7s %3s ",
15454 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
15455 get_symbol_index_type (psym->st_shndx));
15456 if (VALID_DYNAMIC_NAME (psym->st_name))
15457 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
15458 else
15459 printf (_("<corrupt: %14ld>"), psym->st_name);
15460 }
861fb55a
DJ		 15461 printf ("\n");
15462 }
15463 printf ("\n");
15464
15465 if (data)
15466 free (data);
15467 free (rels);
15468 }
15469
252b5132
RH		 15470 return 1;
15471}
15472
35c08157
KLC		 15473static int
15474process_nds32_specific (FILE * file)
15475{
15476 Elf_Internal_Shdr *sect = NULL;
15477
15478 sect = find_section (".nds32_e_flags");
15479 if (sect != NULL)
15480 {
15481 unsigned int *flag;
15482
15483 printf ("\nNDS32 elf flags section:\n");
15484 flag = get_data (NULL, file, sect->sh_offset, 1,
15485 sect->sh_size, _("NDS32 elf flags section"));
15486
15487 switch ((*flag) & 0x3)
15488 {
15489 case 0:
15490 printf ("(VEC_SIZE):\tNo entry.\n");
15491 break;
15492 case 1:
15493 printf ("(VEC_SIZE):\t4 bytes\n");
15494 break;
15495 case 2:
15496 printf ("(VEC_SIZE):\t16 bytes\n");
15497 break;
15498 case 3:
15499 printf ("(VEC_SIZE):\treserved\n");
15500 break;
15501 }
15502 }
15503
15504 return TRUE;
15505}
15506
047b2264 15507static int
2cf0635d 15508process_gnu_liblist (FILE * file)
047b2264 15509{
2cf0635d
NC		 15510 Elf_Internal_Shdr * section;
15511 Elf_Internal_Shdr * string_sec;
15512 Elf32_External_Lib * elib;
15513 char * strtab;
c256ffe7 15514 size_t strtab_size;
047b2264
JJ		 15515 size_t cnt;
15516 unsigned i;
15517
15518 if (! do_arch)
15519 return 0;
15520
15521 for (i = 0, section = section_headers;
15522 i < elf_header.e_shnum;
b34976b6 15523 i++, section++)
047b2264
JJ		 15524 {
15525 switch (section->sh_type)
15526 {
15527 case SHT_GNU_LIBLIST:
4fbb74a6 15528 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 15529 break;
15530
3f5e193b
NC		 15531 elib = (Elf32_External_Lib *)
15532 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 15533 _("liblist section data"));
047b2264
JJ		 15534
15535 if (elib == NULL)
15536 break;
4fbb74a6 15537 string_sec = section_headers + section->sh_link;
047b2264 15538
3f5e193b
NC		 15539 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
15540 string_sec->sh_size,
15541 _("liblist string table"));
047b2264
JJ		 15542 if (strtab == NULL
15543 || section->sh_entsize != sizeof (Elf32_External_Lib))
15544 {
15545 free (elib);
2842702f 15546 free (strtab);
047b2264
JJ		 15547 break;
15548 }
59245841 15549 strtab_size = string_sec->sh_size;
047b2264
JJ		 15550
15551 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
74e1a04b 15552 printable_section_name (section),
0af1713e 15553 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 15554
2b692964 15555 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 15556
15557 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
15558 ++cnt)
15559 {
15560 Elf32_Lib liblist;
91d6fa6a 15561 time_t atime;
d5b07ef4 15562 char timebuf[128];
2cf0635d 15563 struct tm * tmp;
047b2264
JJ		 15564
15565 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 15566 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 15567 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15568 liblist.l_version = BYTE_GET (elib[cnt].l_version);
15569 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15570
91d6fa6a 15571 tmp = gmtime (&atime);
e9e44622
JJ		 15572 snprintf (timebuf, sizeof (timebuf),
15573 "%04u-%02u-%02uT%02u:%02u:%02u",
15574 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15575 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 15576
15577 printf ("%3lu: ", (unsigned long) cnt);
15578 if (do_wide)
c256ffe7 15579 printf ("%-20s", liblist.l_name < strtab_size
2b692964 15580 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 15581 else
c256ffe7 15582 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 15583 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 15584 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
15585 liblist.l_version, liblist.l_flags);
15586 }
15587
15588 free (elib);
2842702f 15589 free (strtab);
047b2264
JJ		 15590 }
15591 }
15592
15593 return 1;
15594}
15595
9437c45b 15596static const char *
d3ba0551 15597get_note_type (unsigned e_type)
779fe533
NC		 15598{
15599 static char buff[64];
103f02d3 15600
1ec5cd37
NC		 15601 if (elf_header.e_type == ET_CORE)
15602 switch (e_type)
15603 {
57346661 15604 case NT_AUXV:
1ec5cd37 15605 return _("NT_AUXV (auxiliary vector)");
57346661 15606 case NT_PRSTATUS:
1ec5cd37 15607 return _("NT_PRSTATUS (prstatus structure)");
57346661 15608 case NT_FPREGSET:
1ec5cd37 15609 return _("NT_FPREGSET (floating point registers)");
57346661 15610 case NT_PRPSINFO:
1ec5cd37 15611 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 15612 case NT_TASKSTRUCT:
1ec5cd37 15613 return _("NT_TASKSTRUCT (task structure)");
57346661 15614 case NT_PRXFPREG:
1ec5cd37 15615 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 15616 case NT_PPC_VMX:
15617 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 15618 case NT_PPC_VSX:
15619 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 15620 case NT_386_TLS:
15621 return _("NT_386_TLS (x86 TLS information)");
15622 case NT_386_IOPERM:
15623 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 15624 case NT_X86_XSTATE:
15625 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 15626 case NT_S390_HIGH_GPRS:
15627 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 15628 case NT_S390_TIMER:
15629 return _("NT_S390_TIMER (s390 timer register)");
15630 case NT_S390_TODCMP:
15631 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15632 case NT_S390_TODPREG:
15633 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15634 case NT_S390_CTRS:
15635 return _("NT_S390_CTRS (s390 control registers)");
15636 case NT_S390_PREFIX:
15637 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 15638 case NT_S390_LAST_BREAK:
15639 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15640 case NT_S390_SYSTEM_CALL:
15641 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC		 15642 case NT_S390_TDB:
15643 return _("NT_S390_TDB (s390 transaction diagnostic block)");
4ef9f41a
AA		 15644 case NT_S390_VXRS_LOW:
15645 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15646 case NT_S390_VXRS_HIGH:
15647 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
faa9a424
UW		 15648 case NT_ARM_VFP:
15649 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 15650 case NT_ARM_TLS:
15651 return _("NT_ARM_TLS (AArch TLS registers)");
15652 case NT_ARM_HW_BREAK:
15653 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15654 case NT_ARM_HW_WATCH:
15655 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 15656 case NT_PSTATUS:
1ec5cd37 15657 return _("NT_PSTATUS (pstatus structure)");
57346661 15658 case NT_FPREGS:
1ec5cd37 15659 return _("NT_FPREGS (floating point registers)");
57346661 15660 case NT_PSINFO:
1ec5cd37 15661 return _("NT_PSINFO (psinfo structure)");
57346661 15662 case NT_LWPSTATUS:
1ec5cd37 15663 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 15664 case NT_LWPSINFO:
1ec5cd37 15665 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 15666 case NT_WIN32PSTATUS:
1ec5cd37 15667 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 15668 case NT_SIGINFO:
15669 return _("NT_SIGINFO (siginfo_t data)");
15670 case NT_FILE:
15671 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 15672 default:
15673 break;
15674 }
15675 else
15676 switch (e_type)
15677 {
15678 case NT_VERSION:
15679 return _("NT_VERSION (version)");
15680 case NT_ARCH:
15681 return _("NT_ARCH (architecture)");
15682 default:
15683 break;
15684 }
15685
e9e44622 15686 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 15687 return buff;
779fe533
NC		 15688}
15689
9ece1fa9
TT		 15690static int
15691print_core_note (Elf_Internal_Note *pnote)
15692{
15693 unsigned int addr_size = is_32bit_elf ? 4 : 8;
15694 bfd_vma count, page_size;
15695 unsigned char *descdata, *filenames, *descend;
15696
15697 if (pnote->type != NT_FILE)
15698 return 1;
15699
15700#ifndef BFD64
15701 if (!is_32bit_elf)
15702 {
15703 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15704 /* Still "successful". */
15705 return 1;
15706 }
15707#endif
15708
15709 if (pnote->descsz < 2 * addr_size)
15710 {
15711 printf (_(" Malformed note - too short for header\n"));
15712 return 0;
15713 }
15714
15715 descdata = (unsigned char *) pnote->descdata;
15716 descend = descdata + pnote->descsz;
15717
15718 if (descdata[pnote->descsz - 1] != '\0')
15719 {
15720 printf (_(" Malformed note - does not end with \\0\n"));
15721 return 0;
15722 }
15723
15724 count = byte_get (descdata, addr_size);
15725 descdata += addr_size;
15726
15727 page_size = byte_get (descdata, addr_size);
15728 descdata += addr_size;
15729
15730 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
15731 {
15732 printf (_(" Malformed note - too short for supplied file count\n"));
15733 return 0;
15734 }
15735
15736 printf (_(" Page size: "));
15737 print_vma (page_size, DEC);
15738 printf ("\n");
15739
15740 printf (_(" %*s%*s%*s\n"),
15741 (int) (2 + 2 * addr_size), _("Start"),
15742 (int) (4 + 2 * addr_size), _("End"),
15743 (int) (4 + 2 * addr_size), _("Page Offset"));
15744 filenames = descdata + count * 3 * addr_size;
595712bb 15745 while (count-- > 0)
9ece1fa9
TT		 15746 {
15747 bfd_vma start, end, file_ofs;
15748
15749 if (filenames == descend)
15750 {
15751 printf (_(" Malformed note - filenames end too early\n"));
15752 return 0;
15753 }
15754
15755 start = byte_get (descdata, addr_size);
15756 descdata += addr_size;
15757 end = byte_get (descdata, addr_size);
15758 descdata += addr_size;
15759 file_ofs = byte_get (descdata, addr_size);
15760 descdata += addr_size;
15761
15762 printf (" ");
15763 print_vma (start, FULL_HEX);
15764 printf (" ");
15765 print_vma (end, FULL_HEX);
15766 printf (" ");
15767 print_vma (file_ofs, FULL_HEX);
15768 printf ("\n %s\n", filenames);
15769
15770 filenames += 1 + strlen ((char *) filenames);
15771 }
15772
15773 return 1;
15774}
15775
1118d252
RM		 15776static const char *
15777get_gnu_elf_note_type (unsigned e_type)
15778{
1449284b 15779 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
1118d252
RM		 15780 switch (e_type)
15781 {
15782 case NT_GNU_ABI_TAG:
15783 return _("NT_GNU_ABI_TAG (ABI version tag)");
15784 case NT_GNU_HWCAP:
15785 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15786 case NT_GNU_BUILD_ID:
15787 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 15788 case NT_GNU_GOLD_VERSION:
15789 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252 15790 default:
1449284b
NC		 15791 {
15792 static char buff[64];
1118d252 15793
1449284b
NC		 15794 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15795 return buff;
15796 }
15797 }
1118d252
RM		 15798}
15799
664f90a3
TT		 15800static int
15801print_gnu_note (Elf_Internal_Note *pnote)
15802{
1449284b 15803 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
664f90a3
TT		 15804 switch (pnote->type)
15805 {
15806 case NT_GNU_BUILD_ID:
15807 {
15808 unsigned long i;
15809
15810 printf (_(" Build ID: "));
15811 for (i = 0; i < pnote->descsz; ++i)
15812 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 15813 printf ("\n");
664f90a3
TT		 15814 }
15815 break;
15816
15817 case NT_GNU_ABI_TAG:
15818 {
15819 unsigned long os, major, minor, subminor;
15820 const char *osname;
15821
3102e897
NC		 15822 /* PR 17531: file: 030-599401-0.004. */
15823 if (pnote->descsz < 16)
15824 {
15825 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15826 break;
15827 }
15828
664f90a3
TT		 15829 os = byte_get ((unsigned char *) pnote->descdata, 4);
15830 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
15831 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
15832 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
15833
15834 switch (os)
15835 {
15836 case GNU_ABI_TAG_LINUX:
15837 osname = "Linux";
15838 break;
15839 case GNU_ABI_TAG_HURD:
15840 osname = "Hurd";
15841 break;
15842 case GNU_ABI_TAG_SOLARIS:
15843 osname = "Solaris";
15844 break;
15845 case GNU_ABI_TAG_FREEBSD:
15846 osname = "FreeBSD";
15847 break;
15848 case GNU_ABI_TAG_NETBSD:
15849 osname = "NetBSD";
15850 break;
14ae95f2
RM		 15851 case GNU_ABI_TAG_SYLLABLE:
15852 osname = "Syllable";
15853 break;
15854 case GNU_ABI_TAG_NACL:
15855 osname = "NaCl";
15856 break;
664f90a3
TT		 15857 default:
15858 osname = "Unknown";
15859 break;
15860 }
15861
15862 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
15863 major, minor, subminor);
15864 }
15865 break;
926c5385
CC		 15866
15867 case NT_GNU_GOLD_VERSION:
15868 {
15869 unsigned long i;
15870
15871 printf (_(" Version: "));
15872 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
15873 printf ("%c", pnote->descdata[i]);
15874 printf ("\n");
15875 }
15876 break;
1449284b
NC		 15877
15878 case NT_GNU_HWCAP:
15879 {
15880 unsigned long num_entries, mask;
15881
15882 /* Hardware capabilities information. Word 0 is the number of entries.
15883 Word 1 is a bitmask of enabled entries. The rest of the descriptor
15884 is a series of entries, where each entry is a single byte followed
15885 by a nul terminated string. The byte gives the bit number to test
15886 if enabled in the bitmask. */
15887 printf (_(" Hardware Capabilities: "));
15888 if (pnote->descsz < 8)
15889 {
15890 printf (_("<corrupt GNU_HWCAP>\n"));
15891 break;
15892 }
15893 num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
15894 mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
15895 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
15896 /* FIXME: Add code to display the entries... */
15897 }
15898 break;
15899
15900 default:
15901 /* Handle unrecognised types. An error message should have already been
15902 created by get_gnu_elf_note_type(), so all that we need to do is to
15903 display the data. */
15904 {
15905 unsigned long i;
15906
15907 printf (_(" Description data: "));
15908 for (i = 0; i < pnote->descsz; ++i)
15909 printf ("%02x ", pnote->descdata[i] & 0xff);
15910 printf ("\n");
15911 }
15912 break;
664f90a3
TT		 15913 }
15914
15915 return 1;
15916}
15917
685080f2
NC		 15918static const char *
15919get_v850_elf_note_type (enum v850_notes n_type)
15920{
15921 static char buff[64];
15922
15923 switch (n_type)
15924 {
15925 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
15926 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
15927 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
15928 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
15929 case V850_NOTE_CACHE_INFO: return _("Use of cache");
15930 case V850_NOTE_MMU_INFO: return _("Use of MMU");
15931 default:
15932 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
15933 return buff;
15934 }
15935}
15936
15937static int
15938print_v850_note (Elf_Internal_Note * pnote)
15939{
15940 unsigned int val;
15941
15942 if (pnote->descsz != 4)
15943 return 0;
15944 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
15945
15946 if (val == 0)
15947 {
15948 printf (_("not set\n"));
15949 return 1;
15950 }
15951
15952 switch (pnote->type)
15953 {
15954 case V850_NOTE_ALIGNMENT:
15955 switch (val)
15956 {
15957 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
15958 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
15959 }
15960 break;
14ae95f2 15961
685080f2
NC		 15962 case V850_NOTE_DATA_SIZE:
15963 switch (val)
15964 {
15965 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
15966 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
15967 }
15968 break;
14ae95f2 15969
685080f2
NC		 15970 case V850_NOTE_FPU_INFO:
15971 switch (val)
15972 {
15973 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
15974 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
15975 }
15976 break;
14ae95f2 15977
685080f2
NC		 15978 case V850_NOTE_MMU_INFO:
15979 case V850_NOTE_CACHE_INFO:
15980 case V850_NOTE_SIMD_INFO:
15981 if (val == EF_RH850_SIMD)
15982 {
15983 printf (_("yes\n"));
15984 return 1;
15985 }
15986 break;
15987
15988 default:
15989 /* An 'unknown note type' message will already have been displayed. */
15990 break;
15991 }
15992
15993 printf (_("unknown value: %x\n"), val);
15994 return 0;
15995}
15996
15f205b1 15997static int
c6056a74
SF		 15998process_netbsd_elf_note (Elf_Internal_Note * pnote)
15999{
16000 unsigned int version;
16001
16002 switch (pnote->type)
16003 {
16004 case NT_NETBSD_IDENT:
16005 version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
16006 if ((version / 10000) % 100)
16007 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
16008 version, version / 100000000, (version / 1000000) % 100,
16009 (version / 10000) % 100 > 26 ? "Z" : "",
15f205b1 16010 'A' + (version / 10000) % 26);
c6056a74
SF		 16011 else
16012 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
16013 version, version / 100000000, (version / 1000000) % 100,
15f205b1 16014 (version / 100) % 100);
c6056a74
SF		 16015 return 1;
16016
16017 case NT_NETBSD_MARCH:
16018 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
16019 pnote->descdata);
16020 return 1;
16021
16022 default:
16023 break;
16024 }
16025
16026 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
16027 pnote->type);
16028 return 1;
16029}
16030
f4ddf30f
JB		 16031static const char *
16032get_freebsd_elfcore_note_type (unsigned e_type)
16033{
f4ddf30f
JB		 16034 switch (e_type)
16035 {
16036 case NT_FREEBSD_THRMISC:
16037 return _("NT_THRMISC (thrmisc structure)");
16038 case NT_FREEBSD_PROCSTAT_PROC:
16039 return _("NT_PROCSTAT_PROC (proc data)");
16040 case NT_FREEBSD_PROCSTAT_FILES:
16041 return _("NT_PROCSTAT_FILES (files data)");
16042 case NT_FREEBSD_PROCSTAT_VMMAP:
16043 return _("NT_PROCSTAT_VMMAP (vmmap data)");
16044 case NT_FREEBSD_PROCSTAT_GROUPS:
16045 return _("NT_PROCSTAT_GROUPS (groups data)");
16046 case NT_FREEBSD_PROCSTAT_UMASK:
16047 return _("NT_PROCSTAT_UMASK (umask data)");
16048 case NT_FREEBSD_PROCSTAT_RLIMIT:
16049 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
16050 case NT_FREEBSD_PROCSTAT_OSREL:
16051 return _("NT_PROCSTAT_OSREL (osreldate data)");
16052 case NT_FREEBSD_PROCSTAT_PSSTRINGS:
16053 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
16054 case NT_FREEBSD_PROCSTAT_AUXV:
16055 return _("NT_PROCSTAT_AUXV (auxv data)");
16056 }
16057 return get_note_type (e_type);
16058}
16059
9437c45b 16060static const char *
d3ba0551 16061get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 16062{
16063 static char buff[64];
16064
b4db1224 16065 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 16066 {
16067 /* NetBSD core "procinfo" structure. */
16068 return _("NetBSD procinfo structure");
16069 }
16070
16071 /* As of Jan 2002 there are no other machine-independent notes
16072 defined for NetBSD core files. If the note type is less
16073 than the start of the machine-dependent note types, we don't
16074 understand it. */
16075
b4db1224 16076 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 16077 {
e9e44622 16078 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 16079 return buff;
16080 }
16081
16082 switch (elf_header.e_machine)
16083 {
16084 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
16085 and PT_GETFPREGS == mach+2. */
16086
16087 case EM_OLD_ALPHA:
16088 case EM_ALPHA:
16089 case EM_SPARC:
16090 case EM_SPARC32PLUS:
16091 case EM_SPARCV9:
16092 switch (e_type)
16093 {
2b692964 16094 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 16095 return _("PT_GETREGS (reg structure)");
2b692964 16096 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 16097 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 16098 default:
16099 break;
16100 }
16101 break;
16102
16103 /* On all other arch's, PT_GETREGS == mach+1 and
16104 PT_GETFPREGS == mach+3. */
16105 default:
16106 switch (e_type)
16107 {
2b692964 16108 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 16109 return _("PT_GETREGS (reg structure)");
2b692964 16110 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 16111 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 16112 default:
16113 break;
16114 }
16115 }
16116
9cf03b7e 16117 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 16118 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 16119 return buff;
16120}
16121
70616151
TT		 16122static const char *
16123get_stapsdt_note_type (unsigned e_type)
16124{
16125 static char buff[64];
16126
16127 switch (e_type)
16128 {
16129 case NT_STAPSDT:
16130 return _("NT_STAPSDT (SystemTap probe descriptors)");
16131
16132 default:
16133 break;
16134 }
16135
16136 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16137 return buff;
16138}
16139
c6a9fc58
TT		 16140static int
16141print_stapsdt_note (Elf_Internal_Note *pnote)
16142{
16143 int addr_size = is_32bit_elf ? 4 : 8;
16144 char *data = pnote->descdata;
16145 char *data_end = pnote->descdata + pnote->descsz;
16146 bfd_vma pc, base_addr, semaphore;
16147 char *provider, *probe, *arg_fmt;
16148
16149 pc = byte_get ((unsigned char *) data, addr_size);
16150 data += addr_size;
16151 base_addr = byte_get ((unsigned char *) data, addr_size);
16152 data += addr_size;
16153 semaphore = byte_get ((unsigned char *) data, addr_size);
16154 data += addr_size;
16155
16156 provider = data;
16157 data += strlen (data) + 1;
16158 probe = data;
16159 data += strlen (data) + 1;
16160 arg_fmt = data;
16161 data += strlen (data) + 1;
16162
16163 printf (_(" Provider: %s\n"), provider);
16164 printf (_(" Name: %s\n"), probe);
16165 printf (_(" Location: "));
16166 print_vma (pc, FULL_HEX);
16167 printf (_(", Base: "));
16168 print_vma (base_addr, FULL_HEX);
16169 printf (_(", Semaphore: "));
16170 print_vma (semaphore, FULL_HEX);
9cf03b7e 16171 printf ("\n");
c6a9fc58
TT		 16172 printf (_(" Arguments: %s\n"), arg_fmt);
16173
16174 return data == data_end;
16175}
16176
00e98fc7
TG		 16177static const char *
16178get_ia64_vms_note_type (unsigned e_type)
16179{
16180 static char buff[64];
16181
16182 switch (e_type)
16183 {
16184 case NT_VMS_MHD:
16185 return _("NT_VMS_MHD (module header)");
16186 case NT_VMS_LNM:
16187 return _("NT_VMS_LNM (language name)");
16188 case NT_VMS_SRC:
16189 return _("NT_VMS_SRC (source files)");
16190 case NT_VMS_TITLE:
9cf03b7e 16191 return "NT_VMS_TITLE";
00e98fc7
TG		 16192 case NT_VMS_EIDC:
16193 return _("NT_VMS_EIDC (consistency check)");
16194 case NT_VMS_FPMODE:
16195 return _("NT_VMS_FPMODE (FP mode)");
16196 case NT_VMS_LINKTIME:
9cf03b7e 16197 return "NT_VMS_LINKTIME";
00e98fc7
TG		 16198 case NT_VMS_IMGNAM:
16199 return _("NT_VMS_IMGNAM (image name)");
16200 case NT_VMS_IMGID:
16201 return _("NT_VMS_IMGID (image id)");
16202 case NT_VMS_LINKID:
16203 return _("NT_VMS_LINKID (link id)");
16204 case NT_VMS_IMGBID:
16205 return _("NT_VMS_IMGBID (build id)");
16206 case NT_VMS_GSTNAM:
16207 return _("NT_VMS_GSTNAM (sym table name)");
16208 case NT_VMS_ORIG_DYN:
9cf03b7e 16209 return "NT_VMS_ORIG_DYN";
00e98fc7 16210 case NT_VMS_PATCHTIME:
9cf03b7e 16211 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 16212 default:
16213 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16214 return buff;
16215 }
16216}
16217
16218static int
16219print_ia64_vms_note (Elf_Internal_Note * pnote)
16220{
16221 switch (pnote->type)
16222 {
16223 case NT_VMS_MHD:
16224 if (pnote->descsz > 36)
16225 {
16226 size_t l = strlen (pnote->descdata + 34);
16227 printf (_(" Creation date : %.17s\n"), pnote->descdata);
16228 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
16229 printf (_(" Module name : %s\n"), pnote->descdata + 34);
16230 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
16231 }
16232 else
16233 printf (_(" Invalid size\n"));
16234 break;
16235 case NT_VMS_LNM:
16236 printf (_(" Language: %s\n"), pnote->descdata);
16237 break;
16238#ifdef BFD64
16239 case NT_VMS_FPMODE:
9cf03b7e 16240 printf (_(" Floating Point mode: "));
4a5cb34f 16241 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 16242 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
00e98fc7
TG		 16243 break;
16244 case NT_VMS_LINKTIME:
16245 printf (_(" Link time: "));
16246 print_vms_time
16247 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
16248 printf ("\n");
16249 break;
16250 case NT_VMS_PATCHTIME:
16251 printf (_(" Patch time: "));
16252 print_vms_time
16253 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
16254 printf ("\n");
16255 break;
16256 case NT_VMS_ORIG_DYN:
16257 printf (_(" Major id: %u, minor id: %u\n"),
16258 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
16259 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 16260 printf (_(" Last modified : "));
00e98fc7
TG		 16261 print_vms_time
16262 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 16263 printf (_("\n Link flags : "));
4a5cb34f 16264 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 16265 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
00e98fc7 16266 printf (_(" Header flags: 0x%08x\n"),
948f632f 16267 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
00e98fc7
TG		 16268 printf (_(" Image id : %s\n"), pnote->descdata + 32);
16269 break;
16270#endif
16271 case NT_VMS_IMGNAM:
16272 printf (_(" Image name: %s\n"), pnote->descdata);
16273 break;
16274 case NT_VMS_GSTNAM:
16275 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
16276 break;
16277 case NT_VMS_IMGID:
16278 printf (_(" Image id: %s\n"), pnote->descdata);
16279 break;
16280 case NT_VMS_LINKID:
16281 printf (_(" Linker id: %s\n"), pnote->descdata);
16282 break;
16283 default:
16284 break;
16285 }
16286 return 1;
16287}
16288
6d118b09
NC		 16289/* Note that by the ELF standard, the name field is already null byte
16290 terminated, and namesz includes the terminating null byte.
16291 I.E. the value of namesz for the name "FSF" is 4.
16292
e3c8793a 16293 If the value of namesz is zero, there is no name present. */
779fe533 16294static int
1449284b
NC		 16295process_note (Elf_Internal_Note * pnote,
16296 FILE * file ATTRIBUTE_UNUSED,
16297 Elf_Internal_Shdr * section ATTRIBUTE_UNUSED)
779fe533 16298{
2cf0635d
NC		 16299 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
16300 const char * nt;
9437c45b
JT		 16301
16302 if (pnote->namesz == 0)
1ec5cd37
NC		 16303 /* If there is no note name, then use the default set of
16304 note type strings. */
16305 nt = get_note_type (pnote->type);
16306
1118d252
RM		 16307 else if (const_strneq (pnote->namedata, "GNU"))
16308 /* GNU-specific object file notes. */
16309 nt = get_gnu_elf_note_type (pnote->type);
f4ddf30f
JB		 16310
16311 else if (const_strneq (pnote->namedata, "FreeBSD"))
16312 /* FreeBSD-specific core file notes. */
16313 nt = get_freebsd_elfcore_note_type (pnote->type);
1118d252 16314
0112cd26 16315 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 16316 /* NetBSD-specific core file notes. */
16317 nt = get_netbsd_elfcore_note_type (pnote->type);
16318
c6056a74
SF		 16319 else if (const_strneq (pnote->namedata, "NetBSD"))
16320 /* NetBSD-specific core file notes. */
16321 return process_netbsd_elf_note (pnote);
16322
b15fa79e
AM		 16323 else if (strneq (pnote->namedata, "SPU/", 4))
16324 {
16325 /* SPU-specific core file notes. */
16326 nt = pnote->namedata + 4;
16327 name = "SPU";
16328 }
16329
00e98fc7
TG		 16330 else if (const_strneq (pnote->namedata, "IPF/VMS"))
16331 /* VMS/ia64-specific file notes. */
16332 nt = get_ia64_vms_note_type (pnote->type);
16333
70616151
TT		 16334 else if (const_strneq (pnote->namedata, "stapsdt"))
16335 nt = get_stapsdt_note_type (pnote->type);
16336
9437c45b 16337 else
1ec5cd37
NC		 16338 /* Don't recognize this note name; just use the default set of
16339 note type strings. */
00e98fc7 16340 nt = get_note_type (pnote->type);
9437c45b 16341
1449284b
NC		 16342 printf (" ");
16343 print_symbol (-20, name);
16344 printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
00e98fc7
TG		 16345
16346 if (const_strneq (pnote->namedata, "IPF/VMS"))
16347 return print_ia64_vms_note (pnote);
664f90a3
TT		 16348 else if (const_strneq (pnote->namedata, "GNU"))
16349 return print_gnu_note (pnote);
c6a9fc58
TT		 16350 else if (const_strneq (pnote->namedata, "stapsdt"))
16351 return print_stapsdt_note (pnote);
9ece1fa9
TT		 16352 else if (const_strneq (pnote->namedata, "CORE"))
16353 return print_core_note (pnote);
779fe533 16354
1449284b
NC		 16355 else if (pnote->descsz)
16356 {
16357 unsigned long i;
16358
16359 printf (_(" description data: "));
16360 for (i = 0; i < pnote->descsz; i++)
16361 printf ("%02x ", pnote->descdata[i]);
16362 printf ("\n");
16363 }
16364
16365 return 1;
16366}
6d118b09 16367
779fe533 16368static int
1449284b
NC		 16369process_notes_at (FILE * file,
16370 Elf_Internal_Shdr * section,
16371 bfd_vma offset,
16372 bfd_vma length)
779fe533 16373{
2cf0635d
NC		 16374 Elf_External_Note * pnotes;
16375 Elf_External_Note * external;
c8071705 16376 char * end;
b34976b6 16377 int res = 1;
103f02d3 16378
779fe533
NC		 16379 if (length <= 0)
16380 return 0;
103f02d3 16381
1449284b
NC		 16382 if (section)
16383 {
16384 pnotes = (Elf_External_Note *) get_section_contents (section, file);
16385 if (pnotes)
16386 apply_relocations (file, section, (unsigned char *) pnotes, length, NULL, NULL);
16387 }
16388 else
16389 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
16390 _("notes"));
dd24e3da 16391 if (pnotes == NULL)
a6e9f9df 16392 return 0;
779fe533 16393
103f02d3 16394 external = pnotes;
103f02d3 16395
1449284b
NC		 16396 if (section)
16397 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section));
16398 else
16399 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
16400 (unsigned long) offset, (unsigned long) length);
16401
2aee03ae 16402 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 16403
c8071705
NC		 16404 end = (char *) pnotes + length;
16405 while ((char *) external < end)
779fe533 16406 {
b34976b6 16407 Elf_Internal_Note inote;
15b42fb0
AM		 16408 size_t min_notesz;
16409 char *next;
2cf0635d 16410 char * temp = NULL;
c8071705 16411 size_t data_remaining = end - (char *) external;
6d118b09 16412
00e98fc7 16413 if (!is_ia64_vms ())
15b42fb0 16414 {
9dd3a467
NC		 16415 /* PR binutils/15191
16416 Make sure that there is enough data to read. */
15b42fb0
AM		 16417 min_notesz = offsetof (Elf_External_Note, name);
16418 if (data_remaining < min_notesz)
9dd3a467
NC		 16419 {
16420 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
16421 (int) data_remaining);
16422 break;
16423 }
15b42fb0
AM		 16424 inote.type = BYTE_GET (external->type);
16425 inote.namesz = BYTE_GET (external->namesz);
16426 inote.namedata = external->name;
16427 inote.descsz = BYTE_GET (external->descsz);
16428 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
834f871c 16429 /* PR 17531: file: 3443835e. */
c8071705 16430 if (inote.descdata < (char *) pnotes || inote.descdata > end)
834f871c
NC		 16431 {
16432 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
16433 inote.descdata = inote.namedata;
16434 inote.namesz = 0;
16435 }
14ae95f2 16436
15b42fb0
AM		 16437 inote.descpos = offset + (inote.descdata - (char *) pnotes);
16438 next = inote.descdata + align_power (inote.descsz, 2);
16439 }
00e98fc7 16440 else
15b42fb0
AM		 16441 {
16442 Elf64_External_VMS_Note *vms_external;
00e98fc7 16443
9dd3a467
NC		 16444 /* PR binutils/15191
16445 Make sure that there is enough data to read. */
15b42fb0
AM		 16446 min_notesz = offsetof (Elf64_External_VMS_Note, name);
16447 if (data_remaining < min_notesz)
9dd3a467
NC		 16448 {
16449 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
16450 (int) data_remaining);
16451 break;
16452 }
3e55a963 16453
15b42fb0
AM		 16454 vms_external = (Elf64_External_VMS_Note *) external;
16455 inote.type = BYTE_GET (vms_external->type);
16456 inote.namesz = BYTE_GET (vms_external->namesz);
16457 inote.namedata = vms_external->name;
16458 inote.descsz = BYTE_GET (vms_external->descsz);
16459 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
16460 inote.descpos = offset + (inote.descdata - (char *) pnotes);
16461 next = inote.descdata + align_power (inote.descsz, 3);
16462 }
16463
16464 if (inote.descdata < (char *) external + min_notesz
16465 || next < (char *) external + min_notesz
5d921cbd
NC		 16466 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
16467 || inote.namedata + inote.namesz < inote.namedata
16468 || inote.descdata + inote.descsz < inote.descdata
15b42fb0 16469 || data_remaining < (size_t)(next - (char *) external))
3e55a963 16470 {
15b42fb0 16471 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 16472 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 16473 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC		 16474 inote.type, inote.namesz, inote.descsz);
16475 break;
16476 }
16477
15b42fb0 16478 external = (Elf_External_Note *) next;
dd24e3da 16479
6d118b09
NC		 16480 /* Verify that name is null terminated. It appears that at least
16481 one version of Linux (RedHat 6.0) generates corefiles that don't
16482 comply with the ELF spec by failing to include the null byte in
16483 namesz. */
8b971f9f 16484 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 16485 {
3f5e193b 16486 temp = (char *) malloc (inote.namesz + 1);
6d118b09
NC		 16487 if (temp == NULL)
16488 {
8b73c356 16489 error (_("Out of memory allocating space for inote name\n"));
6d118b09
NC		 16490 res = 0;
16491 break;
16492 }
76da6bbe 16493
6d118b09
NC		 16494 strncpy (temp, inote.namedata, inote.namesz);
16495 temp[inote.namesz] = 0;
76da6bbe 16496
6d118b09
NC		 16497 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
16498 inote.namedata = temp;
16499 }
16500
1449284b 16501 res &= process_note (& inote, file, section);
103f02d3 16502
6d118b09
NC		 16503 if (temp != NULL)
16504 {
16505 free (temp);
16506 temp = NULL;
16507 }
779fe533
NC		 16508 }
16509
16510 free (pnotes);
103f02d3 16511
779fe533
NC		 16512 return res;
16513}
16514
16515static int
2cf0635d 16516process_corefile_note_segments (FILE * file)
779fe533 16517{
2cf0635d 16518 Elf_Internal_Phdr * segment;
b34976b6
AM		 16519 unsigned int i;
16520 int res = 1;
103f02d3 16521
d93f0186 16522 if (! get_program_headers (file))
779fe533 16523 return 0;
103f02d3 16524
779fe533
NC		 16525 for (i = 0, segment = program_headers;
16526 i < elf_header.e_phnum;
b34976b6 16527 i++, segment++)
779fe533
NC		 16528 {
16529 if (segment->p_type == PT_NOTE)
1449284b
NC		 16530 res &= process_notes_at (file, NULL,
16531 (bfd_vma) segment->p_offset,
16532 (bfd_vma) segment->p_filesz);
779fe533 16533 }
103f02d3 16534
779fe533
NC		 16535 return res;
16536}
16537
685080f2
NC		 16538static int
16539process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
16540{
16541 Elf_External_Note * pnotes;
16542 Elf_External_Note * external;
c8071705 16543 char * end;
685080f2
NC		 16544 int res = 1;
16545
16546 if (length <= 0)
16547 return 0;
16548
16549 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
16550 _("v850 notes"));
16551 if (pnotes == NULL)
16552 return 0;
16553
16554 external = pnotes;
c8071705 16555 end = (char*) pnotes + length;
685080f2
NC		 16556
16557 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
16558 (unsigned long) offset, (unsigned long) length);
16559
c8071705 16560 while ((char *) external + sizeof (Elf_External_Note) < end)
685080f2
NC		 16561 {
16562 Elf_External_Note * next;
16563 Elf_Internal_Note inote;
16564
16565 inote.type = BYTE_GET (external->type);
16566 inote.namesz = BYTE_GET (external->namesz);
16567 inote.namedata = external->name;
16568 inote.descsz = BYTE_GET (external->descsz);
16569 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
16570 inote.descpos = offset + (inote.descdata - (char *) pnotes);
16571
c8071705
NC		 16572 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
16573 {
16574 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
16575 inote.descdata = inote.namedata;
16576 inote.namesz = 0;
16577 }
16578
685080f2
NC		 16579 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
16580
c8071705 16581 if ( ((char *) next > end)
685080f2
NC		 16582 || ((char *) next < (char *) pnotes))
16583 {
16584 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
16585 (unsigned long) ((char *) external - (char *) pnotes));
16586 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16587 inote.type, inote.namesz, inote.descsz);
16588 break;
16589 }
16590
16591 external = next;
16592
16593 /* Prevent out-of-bounds indexing. */
c8071705 16594 if ( inote.namedata + inote.namesz > end
685080f2
NC		 16595 || inote.namedata + inote.namesz < inote.namedata)
16596 {
16597 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
16598 (unsigned long) ((char *) external - (char *) pnotes));
16599 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16600 inote.type, inote.namesz, inote.descsz);
16601 break;
16602 }
16603
16604 printf (" %s: ", get_v850_elf_note_type (inote.type));
16605
16606 if (! print_v850_note (& inote))
16607 {
16608 res = 0;
16609 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
16610 inote.namesz, inote.descsz);
16611 }
16612 }
16613
16614 free (pnotes);
16615
16616 return res;
16617}
16618
779fe533 16619static int
2cf0635d 16620process_note_sections (FILE * file)
1ec5cd37 16621{
2cf0635d 16622 Elf_Internal_Shdr * section;
1ec5cd37 16623 unsigned long i;
df565f32 16624 int n = 0;
1ec5cd37
NC		 16625 int res = 1;
16626
16627 for (i = 0, section = section_headers;
fa1908fd 16628 i < elf_header.e_shnum && section != NULL;
1ec5cd37 16629 i++, section++)
685080f2
NC		 16630 {
16631 if (section->sh_type == SHT_NOTE)
16632 {
1449284b
NC		 16633 res &= process_notes_at (file, section,
16634 (bfd_vma) section->sh_offset,
16635 (bfd_vma) section->sh_size);
685080f2
NC		 16636 n++;
16637 }
16638
16639 if (( elf_header.e_machine == EM_V800
16640 || elf_header.e_machine == EM_V850
16641 || elf_header.e_machine == EM_CYGNUS_V850)
16642 && section->sh_type == SHT_RENESAS_INFO)
16643 {
16644 res &= process_v850_notes (file,
16645 (bfd_vma) section->sh_offset,
16646 (bfd_vma) section->sh_size);
16647 n++;
16648 }
16649 }
df565f32
NC		 16650
16651 if (n == 0)
16652 /* Try processing NOTE segments instead. */
16653 return process_corefile_note_segments (file);
1ec5cd37
NC		 16654
16655 return res;
16656}
16657
16658static int
2cf0635d 16659process_notes (FILE * file)
779fe533
NC		 16660{
16661 /* If we have not been asked to display the notes then do nothing. */
16662 if (! do_notes)
16663 return 1;
103f02d3 16664
779fe533 16665 if (elf_header.e_type != ET_CORE)
1ec5cd37 16666 return process_note_sections (file);
103f02d3 16667
779fe533 16668 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 16669 if (elf_header.e_phnum > 0)
16670 return process_corefile_note_segments (file);
779fe533 16671
1ec5cd37
NC		 16672 printf (_("No note segments present in the core file.\n"));
16673 return 1;
779fe533
NC		 16674}
16675
60abdbed
NC		 16676static unsigned char *
16677display_public_gnu_attributes (unsigned char * start,
16678 const unsigned char * const end)
16679{
16680 printf (_(" Unknown GNU attribute: %s\n"), start);
16681
16682 start += strnlen ((char *) start, end - start);
16683 display_raw_attribute (start, end);
16684
16685 return (unsigned char *) end;
16686}
16687
16688static unsigned char *
16689display_generic_attribute (unsigned char * start,
16690 unsigned int tag,
16691 const unsigned char * const end)
16692{
16693 if (tag == 0)
16694 return (unsigned char *) end;
16695
16696 return display_tag_value (tag, start, end);
16697}
16698
252b5132 16699static int
2cf0635d 16700process_arch_specific (FILE * file)
252b5132 16701{
a952a375
NC		 16702 if (! do_arch)
16703 return 1;
16704
252b5132
RH		 16705 switch (elf_header.e_machine)
16706 {
11c1ff18 16707 case EM_ARM:
60abdbed
NC		 16708 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
16709 display_arm_attribute,
16710 display_generic_attribute);
16711
252b5132 16712 case EM_MIPS:
4fe85591 16713 case EM_MIPS_RS3_LE:
252b5132 16714 return process_mips_specific (file);
60abdbed
NC		 16715
16716 case EM_MSP430:
16717 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
16718 display_msp430x_attribute,
16719 display_generic_attribute);
16720
35c08157
KLC		 16721 case EM_NDS32:
16722 return process_nds32_specific (file);
60abdbed 16723
34c8bcba 16724 case EM_PPC:
b82317dd 16725 case EM_PPC64:
60abdbed
NC		 16726 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
16727 display_power_gnu_attribute);
16728
643f7afb
AK		 16729 case EM_S390:
16730 case EM_S390_OLD:
60abdbed
NC		 16731 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
16732 display_s390_gnu_attribute);
16733
9e8c70f9
DM		 16734 case EM_SPARC:
16735 case EM_SPARC32PLUS:
16736 case EM_SPARCV9:
60abdbed
NC		 16737 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
16738 display_sparc_gnu_attribute);
16739
59e6276b 16740 case EM_TI_C6000:
60abdbed
NC		 16741 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
16742 display_tic6x_attribute,
16743 display_generic_attribute);
16744
252b5132 16745 default:
60abdbed
NC		 16746 return process_attributes (file, "gnu", SHT_GNU_ATTRIBUTES,
16747 display_public_gnu_attributes,
16748 display_generic_attribute);
252b5132 16749 }
252b5132
RH		 16750}
16751
16752static int
2cf0635d 16753get_file_header (FILE * file)
252b5132 16754{
9ea033b2
NC		 16755 /* Read in the identity array. */
16756 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 16757 return 0;
16758
9ea033b2 16759 /* Determine how to read the rest of the header. */
b34976b6 16760 switch (elf_header.e_ident[EI_DATA])
9ea033b2 16761 {
1a0670f3
AM		 16762 default:
16763 case ELFDATANONE:
adab8cdc
AO		 16764 case ELFDATA2LSB:
16765 byte_get = byte_get_little_endian;
16766 byte_put = byte_put_little_endian;
16767 break;
16768 case ELFDATA2MSB:
16769 byte_get = byte_get_big_endian;
16770 byte_put = byte_put_big_endian;
16771 break;
9ea033b2
NC		 16772 }
16773
16774 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 16775 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 16776
16777 /* Read in the rest of the header. */
16778 if (is_32bit_elf)
16779 {
16780 Elf32_External_Ehdr ehdr32;
252b5132 16781
9ea033b2
NC		 16782 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
16783 return 0;
103f02d3 16784
9ea033b2
NC		 16785 elf_header.e_type = BYTE_GET (ehdr32.e_type);
16786 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
16787 elf_header.e_version = BYTE_GET (ehdr32.e_version);
16788 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
16789 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
16790 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
16791 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
16792 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
16793 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
16794 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
16795 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
16796 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
16797 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
16798 }
252b5132 16799 else
9ea033b2
NC		 16800 {
16801 Elf64_External_Ehdr ehdr64;
a952a375
NC		 16802
16803 /* If we have been compiled with sizeof (bfd_vma) == 4, then
16804 we will not be able to cope with the 64bit data found in
16805 64 ELF files. Detect this now and abort before we start
50c2245b 16806 overwriting things. */
a952a375
NC		 16807 if (sizeof (bfd_vma) < 8)
16808 {
e3c8793a
NC		 16809 error (_("This instance of readelf has been built without support for a\n\
1681064 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 16811 return 0;
16812 }
103f02d3 16813
9ea033b2
NC		 16814 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
16815 return 0;
103f02d3 16816
9ea033b2
NC		 16817 elf_header.e_type = BYTE_GET (ehdr64.e_type);
16818 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
16819 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 16820 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
16821 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
16822 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 16823 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
16824 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
16825 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
16826 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
16827 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
16828 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
16829 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
16830 }
252b5132 16831
7ece0d85
JJ		 16832 if (elf_header.e_shoff)
16833 {
16834 /* There may be some extensions in the first section header. Don't
16835 bomb if we can't read it. */
16836 if (is_32bit_elf)
049b0c3a 16837 get_32bit_section_headers (file, TRUE);
7ece0d85 16838 else
049b0c3a 16839 get_64bit_section_headers (file, TRUE);
7ece0d85 16840 }
560f3c1c 16841
252b5132
RH		 16842 return 1;
16843}
16844
fb52b2f4
NC		 16845/* Process one ELF object file according to the command line options.
16846 This file may actually be stored in an archive. The file is
16847 positioned at the start of the ELF object. */
16848
ff78d6d6 16849static int
2cf0635d 16850process_object (char * file_name, FILE * file)
252b5132 16851{
252b5132
RH		 16852 unsigned int i;
16853
252b5132
RH		 16854 if (! get_file_header (file))
16855 {
16856 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 16857 return 1;
252b5132
RH		 16858 }
16859
16860 /* Initialise per file variables. */
60bca95a 16861 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 16862 version_info[i] = 0;
16863
60bca95a 16864 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 16865 dynamic_info[i] = 0;
5115b233 16866 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 16867
16868 /* Process the file. */
16869 if (show_name)
16870 printf (_("\nFile: %s\n"), file_name);
16871
18bd398b
NC		 16872 /* Initialise the dump_sects array from the cmdline_dump_sects array.
16873 Note we do this even if cmdline_dump_sects is empty because we
16874 must make sure that the dump_sets array is zeroed out before each
16875 object file is processed. */
16876 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 16877 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 16878
16879 if (num_cmdline_dump_sects > 0)
16880 {
16881 if (num_dump_sects == 0)
16882 /* A sneaky way of allocating the dump_sects array. */
09c11c86 16883 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 16884
16885 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 16886 memcpy (dump_sects, cmdline_dump_sects,
16887 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 16888 }
d70c5fc7 16889
252b5132 16890 if (! process_file_header ())
fb52b2f4 16891 return 1;
252b5132 16892
d1f5c6e3 16893 if (! process_section_headers (file))
2f62977e 16894 {
d1f5c6e3
L		 16895 /* Without loaded section headers we cannot process lots of
16896 things. */
2f62977e 16897 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 16898
2f62977e 16899 if (! do_using_dynamic)
2c610e4b 16900 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 16901 }
252b5132 16902
d1f5c6e3
L		 16903 if (! process_section_groups (file))
16904 {
16905 /* Without loaded section groups we cannot process unwind. */
16906 do_unwind = 0;
16907 }
16908
2f62977e 16909 if (process_program_headers (file))
b2d38a17 16910 process_dynamic_section (file);
252b5132
RH		 16911
16912 process_relocs (file);
16913
4d6ed7c8
NC		 16914 process_unwind (file);
16915
252b5132
RH		 16916 process_symbol_table (file);
16917
16918 process_syminfo (file);
16919
16920 process_version_sections (file);
16921
16922 process_section_contents (file);
f5842774 16923
1ec5cd37 16924 process_notes (file);
103f02d3 16925
047b2264
JJ		 16926 process_gnu_liblist (file);
16927
252b5132
RH		 16928 process_arch_specific (file);
16929
d93f0186
NC		 16930 if (program_headers)
16931 {
16932 free (program_headers);
16933 program_headers = NULL;
16934 }
16935
252b5132
RH		 16936 if (section_headers)
16937 {
16938 free (section_headers);
16939 section_headers = NULL;
16940 }
16941
16942 if (string_table)
16943 {
16944 free (string_table);
16945 string_table = NULL;
d40ac9bd 16946 string_table_length = 0;
252b5132
RH		 16947 }
16948
16949 if (dynamic_strings)
16950 {
16951 free (dynamic_strings);
16952 dynamic_strings = NULL;
d79b3d50 16953 dynamic_strings_length = 0;
252b5132
RH		 16954 }
16955
16956 if (dynamic_symbols)
16957 {
16958 free (dynamic_symbols);
16959 dynamic_symbols = NULL;
19936277 16960 num_dynamic_syms = 0;
252b5132
RH		 16961 }
16962
16963 if (dynamic_syminfo)
16964 {
16965 free (dynamic_syminfo);
16966 dynamic_syminfo = NULL;
16967 }
ff78d6d6 16968
293c573e
MR		 16969 if (dynamic_section)
16970 {
16971 free (dynamic_section);
16972 dynamic_section = NULL;
16973 }
16974
e4b17d5c
L		 16975 if (section_headers_groups)
16976 {
16977 free (section_headers_groups);
16978 section_headers_groups = NULL;
16979 }
16980
16981 if (section_groups)
16982 {
2cf0635d
NC		 16983 struct group_list * g;
16984 struct group_list * next;
e4b17d5c
L		 16985
16986 for (i = 0; i < group_count; i++)
16987 {
16988 for (g = section_groups [i].root; g != NULL; g = next)
16989 {
16990 next = g->next;
16991 free (g);
16992 }
16993 }
16994
16995 free (section_groups);
16996 section_groups = NULL;
16997 }
16998
19e6b90e 16999 free_debug_memory ();
18bd398b 17000
ff78d6d6 17001 return 0;
252b5132
RH		 17002}
17003
2cf0635d
NC		 17004/* Process an ELF archive.
17005 On entry the file is positioned just after the ARMAG string. */
17006
17007static int
17008process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
17009{
17010 struct archive_info arch;
17011 struct archive_info nested_arch;
17012 size_t got;
2cf0635d
NC		 17013 int ret;
17014
17015 show_name = 1;
17016
17017 /* The ARCH structure is used to hold information about this archive. */
17018 arch.file_name = NULL;
17019 arch.file = NULL;
17020 arch.index_array = NULL;
17021 arch.sym_table = NULL;
17022 arch.longnames = NULL;
17023
17024 /* The NESTED_ARCH structure is used as a single-item cache of information
17025 about a nested archive (when members of a thin archive reside within
17026 another regular archive file). */
17027 nested_arch.file_name = NULL;
17028 nested_arch.file = NULL;
17029 nested_arch.index_array = NULL;
17030 nested_arch.sym_table = NULL;
17031 nested_arch.longnames = NULL;
17032
17033 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
17034 {
17035 ret = 1;
17036 goto out;
4145f1d5 17037 }
fb52b2f4 17038
4145f1d5
NC		 17039 if (do_archive_index)
17040 {
2cf0635d 17041 if (arch.sym_table == NULL)
4145f1d5
NC		 17042 error (_("%s: unable to dump the index as none was found\n"), file_name);
17043 else
17044 {
591f7597 17045 unsigned long i, l;
4145f1d5
NC		 17046 unsigned long current_pos;
17047
591f7597
NC		 17048 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
17049 file_name, (unsigned long) arch.index_num, arch.sym_size);
4145f1d5
NC		 17050 current_pos = ftell (file);
17051
2cf0635d 17052 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 17053 {
2cf0635d
NC		 17054 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
17055 {
17056 char * member_name;
4145f1d5 17057
2cf0635d
NC		 17058 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
17059
17060 if (member_name != NULL)
17061 {
17062 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
17063
17064 if (qualified_name != NULL)
17065 {
c2a7d3f5
NC		 17066 printf (_("Contents of binary %s at offset "), qualified_name);
17067 (void) print_vma (arch.index_array[i], PREFIX_HEX);
17068 putchar ('\n');
2cf0635d
NC		 17069 free (qualified_name);
17070 }
4145f1d5
NC		 17071 }
17072 }
2cf0635d
NC		 17073
17074 if (l >= arch.sym_size)
4145f1d5
NC		 17075 {
17076 error (_("%s: end of the symbol table reached before the end of the index\n"),
17077 file_name);
cb8f3167 17078 break;
4145f1d5 17079 }
591f7597
NC		 17080 /* PR 17531: file: 0b6630b2. */
17081 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
17082 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
4145f1d5
NC		 17083 }
17084
c2a7d3f5
NC		 17085 if (arch.uses_64bit_indicies)
17086 l = (l + 7) & ~ 7;
17087 else
17088 l += l & 1;
17089
2cf0635d 17090 if (l < arch.sym_size)
c2a7d3f5
NC		 17091 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
17092 file_name, arch.sym_size - l);
4145f1d5 17093
4145f1d5
NC		 17094 if (fseek (file, current_pos, SEEK_SET) != 0)
17095 {
17096 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 17097 ret = 1;
17098 goto out;
4145f1d5 17099 }
fb52b2f4 17100 }
4145f1d5
NC		 17101
17102 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
17103 && !do_segments && !do_header && !do_dump && !do_version
17104 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 17105 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 17106 {
17107 ret = 0; /* Archive index only. */
17108 goto out;
17109 }
fb52b2f4
NC		 17110 }
17111
d989285c 17112 ret = 0;
fb52b2f4
NC		 17113
17114 while (1)
17115 {
2cf0635d
NC		 17116 char * name;
17117 size_t namelen;
17118 char * qualified_name;
17119
17120 /* Read the next archive header. */
17121 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
17122 {
17123 error (_("%s: failed to seek to next archive header\n"), file_name);
17124 return 1;
17125 }
17126 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
17127 if (got != sizeof arch.arhdr)
17128 {
17129 if (got == 0)
17130 break;
17131 error (_("%s: failed to read archive header\n"), file_name);
17132 ret = 1;
17133 break;
17134 }
17135 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
17136 {
17137 error (_("%s: did not find a valid archive header\n"), arch.file_name);
17138 ret = 1;
17139 break;
17140 }
17141
17142 arch.next_arhdr_offset += sizeof arch.arhdr;
17143
17144 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
17145 if (archive_file_size & 01)
17146 ++archive_file_size;
17147
17148 name = get_archive_member_name (&arch, &nested_arch);
17149 if (name == NULL)
fb52b2f4 17150 {
0fd3a477 17151 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 17152 ret = 1;
17153 break;
fb52b2f4 17154 }
2cf0635d 17155 namelen = strlen (name);
fb52b2f4 17156
2cf0635d
NC		 17157 qualified_name = make_qualified_name (&arch, &nested_arch, name);
17158 if (qualified_name == NULL)
fb52b2f4 17159 {
2cf0635d 17160 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 17161 ret = 1;
17162 break;
fb52b2f4
NC		 17163 }
17164
2cf0635d
NC		 17165 if (is_thin_archive && arch.nested_member_origin == 0)
17166 {
17167 /* This is a proxy for an external member of a thin archive. */
17168 FILE * member_file;
17169 char * member_file_name = adjust_relative_path (file_name, name, namelen);
17170 if (member_file_name == NULL)
17171 {
17172 ret = 1;
17173 break;
17174 }
17175
17176 member_file = fopen (member_file_name, "rb");
17177 if (member_file == NULL)
17178 {
17179 error (_("Input file '%s' is not readable.\n"), member_file_name);
17180 free (member_file_name);
17181 ret = 1;
17182 break;
17183 }
17184
17185 archive_file_offset = arch.nested_member_origin;
17186
17187 ret |= process_object (qualified_name, member_file);
17188
17189 fclose (member_file);
17190 free (member_file_name);
17191 }
17192 else if (is_thin_archive)
17193 {
a043396b
NC		 17194 /* PR 15140: Allow for corrupt thin archives. */
17195 if (nested_arch.file == NULL)
17196 {
17197 error (_("%s: contains corrupt thin archive: %s\n"),
17198 file_name, name);
17199 ret = 1;
17200 break;
17201 }
17202
2cf0635d
NC		 17203 /* This is a proxy for a member of a nested archive. */
17204 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
17205
17206 /* The nested archive file will have been opened and setup by
17207 get_archive_member_name. */
17208 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
17209 {
17210 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
17211 ret = 1;
17212 break;
17213 }
17214
17215 ret |= process_object (qualified_name, nested_arch.file);
17216 }
17217 else
17218 {
17219 archive_file_offset = arch.next_arhdr_offset;
17220 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 17221
2cf0635d
NC		 17222 ret |= process_object (qualified_name, file);
17223 }
fb52b2f4 17224
2b52916e
L		 17225 if (dump_sects != NULL)
17226 {
17227 free (dump_sects);
17228 dump_sects = NULL;
17229 num_dump_sects = 0;
17230 }
17231
2cf0635d 17232 free (qualified_name);
fb52b2f4
NC		 17233 }
17234
4145f1d5 17235 out:
2cf0635d
NC		 17236 if (nested_arch.file != NULL)
17237 fclose (nested_arch.file);
17238 release_archive (&nested_arch);
17239 release_archive (&arch);
fb52b2f4 17240
d989285c 17241 return ret;
fb52b2f4
NC		 17242}
17243
17244static int
2cf0635d 17245process_file (char * file_name)
fb52b2f4 17246{
2cf0635d 17247 FILE * file;
fb52b2f4
NC		 17248 struct stat statbuf;
17249 char armag[SARMAG];
17250 int ret;
17251
17252 if (stat (file_name, &statbuf) < 0)
17253 {
f24ddbdd
NC		 17254 if (errno == ENOENT)
17255 error (_("'%s': No such file\n"), file_name);
17256 else
17257 error (_("Could not locate '%s'. System error message: %s\n"),
17258 file_name, strerror (errno));
17259 return 1;
17260 }
17261
17262 if (! S_ISREG (statbuf.st_mode))
17263 {
17264 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 17265 return 1;
17266 }
17267
17268 file = fopen (file_name, "rb");
17269 if (file == NULL)
17270 {
f24ddbdd 17271 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 17272 return 1;
17273 }
17274
17275 if (fread (armag, SARMAG, 1, file) != 1)
17276 {
4145f1d5 17277 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 17278 fclose (file);
17279 return 1;
17280 }
17281
f54498b4
NC		 17282 current_file_size = (bfd_size_type) statbuf.st_size;
17283
fb52b2f4 17284 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 17285 ret = process_archive (file_name, file, FALSE);
17286 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
17287 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 17288 else
17289 {
4145f1d5
NC		 17290 if (do_archive_index)
17291 error (_("File %s is not an archive so its index cannot be displayed.\n"),
17292 file_name);
17293
fb52b2f4
NC		 17294 rewind (file);
17295 archive_file_size = archive_file_offset = 0;
17296 ret = process_object (file_name, file);
17297 }
17298
17299 fclose (file);
17300
f54498b4 17301 current_file_size = 0;
fb52b2f4
NC		 17302 return ret;
17303}
17304
252b5132
RH		 17305#ifdef SUPPORT_DISASSEMBLY
17306/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 17307 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 17308 symbols. */
252b5132
RH		 17309
17310void
2cf0635d 17311print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 17312{
17313 fprintf (outfile,"0x%8.8x", addr);
17314}
17315
e3c8793a 17316/* Needed by the i386 disassembler. */
252b5132
RH		 17317void
17318db_task_printsym (unsigned int addr)
17319{
17320 print_address (addr, stderr);
17321}
17322#endif
17323
17324int
2cf0635d 17325main (int argc, char ** argv)
252b5132 17326{
ff78d6d6
L		 17327 int err;
17328
252b5132
RH		 17329#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
17330 setlocale (LC_MESSAGES, "");
3882b010
L		 17331#endif
17332#if defined (HAVE_SETLOCALE)
17333 setlocale (LC_CTYPE, "");
252b5132
RH		 17334#endif
17335 bindtextdomain (PACKAGE, LOCALEDIR);
17336 textdomain (PACKAGE);
17337
869b9d07
MM		 17338 expandargv (&argc, &argv);
17339
252b5132
RH		 17340 parse_args (argc, argv);
17341
18bd398b 17342 if (num_dump_sects > 0)
59f14fc0 17343 {
18bd398b 17344 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 17345 cmdline_dump_sects = (dump_type *)
17346 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 17347 if (cmdline_dump_sects == NULL)
591a748a 17348 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 17349 else
17350 {
09c11c86
NC		 17351 memcpy (cmdline_dump_sects, dump_sects,
17352 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 17353 num_cmdline_dump_sects = num_dump_sects;
17354 }
17355 }
17356
18bd398b
NC		 17357 if (optind < (argc - 1))
17358 show_name = 1;
5656ba2c
L		 17359 else if (optind >= argc)
17360 {
17361 warn (_("Nothing to do.\n"));
17362 usage (stderr);
17363 }
18bd398b 17364
ff78d6d6 17365 err = 0;
252b5132 17366 while (optind < argc)
18bd398b 17367 err |= process_file (argv[optind++]);
252b5132
RH		 17368
17369 if (dump_sects != NULL)
17370 free (dump_sects);
59f14fc0
AS		 17371 if (cmdline_dump_sects != NULL)
17372 free (cmdline_dump_sects);
252b5132 17373
ff78d6d6 17374 return err;
252b5132 17375}
A mirror of the official binutils-gdb repository