projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
readelf: Make version section index sum unsigned
[deliverable/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"))
77145576 5965 || (do_debug_ranges && const_strneq (name, "rnglists"))
4723351a
CC		 5966 || (do_debug_frames && const_strneq (name, "frame"))
5967 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5968 || (do_debug_macinfo && const_strneq (name, "macro"))
5969 || (do_debug_str && const_strneq (name, "str"))
5970 || (do_debug_loc && const_strneq (name, "loc"))
77145576 5971 || (do_debug_loc && const_strneq (name, "loclists"))
657d0d47
CC		 5972 || (do_debug_addr && const_strneq (name, "addr"))
5973 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5974 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 5975 )
09c11c86 5976 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 5977 }
a262ae96 5978 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 5979 else if ((do_debugging || do_debug_info)
0112cd26 5980 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 5981 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 5982 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 5983 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 5984 else if (do_gdb_index && streq (name, ".gdb_index"))
5985 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 5986 /* Trace sections for Itanium VMS. */
5987 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5988 || do_trace_aranges)
5989 && const_strneq (name, ".trace_"))
5990 {
5991 name += sizeof (".trace_") - 1;
5992
5993 if (do_debugging
5994 || (do_trace_info && streq (name, "info"))
5995 || (do_trace_abbrevs && streq (name, "abbrev"))
5996 || (do_trace_aranges && streq (name, "aranges"))
5997 )
5998 request_dump_bynumber (i, DEBUG_DUMP);
5999 }
252b5132
RH		 6000 }
6001
6002 if (! do_sections)
6003 return 1;
6004
3a1a2036
NC		 6005 if (elf_header.e_shnum > 1)
6006 printf (_("\nSection Headers:\n"));
6007 else
6008 printf (_("\nSection Header:\n"));
76da6bbe 6009
f7a99963 6010 if (is_32bit_elf)
595cf52e 6011 {
5477e8a0 6012 if (do_section_details)
595cf52e
L		 6013 {
6014 printf (_(" [Nr] Name\n"));
5477e8a0 6015 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 6016 }
6017 else
6018 printf
6019 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6020 }
d974e256 6021 else if (do_wide)
595cf52e 6022 {
5477e8a0 6023 if (do_section_details)
595cf52e
L		 6024 {
6025 printf (_(" [Nr] Name\n"));
5477e8a0 6026 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 6027 }
6028 else
6029 printf
6030 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6031 }
f7a99963
NC		 6032 else
6033 {
5477e8a0 6034 if (do_section_details)
595cf52e
L		 6035 {
6036 printf (_(" [Nr] Name\n"));
5477e8a0
L		 6037 printf (_(" Type Address Offset Link\n"));
6038 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 6039 }
6040 else
6041 {
6042 printf (_(" [Nr] Name Type Address Offset\n"));
6043 printf (_(" Size EntSize Flags Link Info Align\n"));
6044 }
f7a99963 6045 }
252b5132 6046
5477e8a0
L		 6047 if (do_section_details)
6048 printf (_(" Flags\n"));
6049
252b5132
RH		 6050 for (i = 0, section = section_headers;
6051 i < elf_header.e_shnum;
b34976b6 6052 i++, section++)
252b5132 6053 {
dd905818
NC		 6054 /* Run some sanity checks on the section header. */
6055
6056 /* Check the sh_link field. */
6057 switch (section->sh_type)
6058 {
6059 case SHT_SYMTAB_SHNDX:
6060 case SHT_GROUP:
6061 case SHT_HASH:
6062 case SHT_GNU_HASH:
6063 case SHT_GNU_versym:
6064 case SHT_REL:
6065 case SHT_RELA:
6066 if (section->sh_link < 1
cb64e50d 6067 || section->sh_link >= elf_header.e_shnum
dd905818
NC		 6068 || (section_headers[section->sh_link].sh_type != SHT_SYMTAB
6069 && section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6070 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6071 i, section->sh_link);
6072 break;
6073
6074 case SHT_DYNAMIC:
6075 case SHT_SYMTAB:
6076 case SHT_DYNSYM:
6077 case SHT_GNU_verneed:
6078 case SHT_GNU_verdef:
6079 case SHT_GNU_LIBLIST:
6080 if (section->sh_link < 1
cb64e50d 6081 || section->sh_link >= elf_header.e_shnum
dd905818
NC		 6082 || section_headers[section->sh_link].sh_type != SHT_STRTAB)
6083 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6084 i, section->sh_link);
6085 break;
6086
6087 case SHT_INIT_ARRAY:
6088 case SHT_FINI_ARRAY:
6089 case SHT_PREINIT_ARRAY:
6090 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6091 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6092 i, section->sh_link);
6093 break;
6094
6095 default:
6096 /* FIXME: Add support for target specific section types. */
6097#if 0 /* Currently we do not check other section types as there are too
6098 many special cases. Stab sections for example have a type
6099 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6100 section. */
6101 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6102 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6103 i, section->sh_link);
6104#endif
6105 break;
6106 }
6107
6108 /* Check the sh_info field. */
6109 switch (section->sh_type)
6110 {
6111 case SHT_REL:
6112 case SHT_RELA:
6113 if (section->sh_info < 1
cb64e50d 6114 || section->sh_info >= elf_header.e_shnum
dd905818
NC		 6115 || (section_headers[section->sh_info].sh_type != SHT_PROGBITS
6116 && section_headers[section->sh_info].sh_type != SHT_NOBITS
6117 && section_headers[section->sh_info].sh_type != SHT_NOTE
6118 && section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6119 /* FIXME: Are other section types valid ? */
6120 && section_headers[section->sh_info].sh_type < SHT_LOOS))
6121 {
6122 if (section->sh_info == 0
6123 && (streq (SECTION_NAME (section), ".rel.dyn")
6124 || streq (SECTION_NAME (section), ".rela.dyn")))
6125 /* The .rel.dyn and .rela.dyn sections have an sh_info field
4d74727a
AM		 6126 of zero. The relocations in these sections may apply
6127 to many different sections. */
dd905818
NC		 6128 ;
6129 else
6130 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6131 i, section->sh_info);
6132 }
6133 break;
6134
6135 case SHT_DYNAMIC:
6136 case SHT_HASH:
6137 case SHT_SYMTAB_SHNDX:
6138 case SHT_INIT_ARRAY:
6139 case SHT_FINI_ARRAY:
6140 case SHT_PREINIT_ARRAY:
6141 if (section->sh_info != 0)
6142 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6143 i, section->sh_info);
6144 break;
6145
6146 case SHT_GROUP:
6147 case SHT_SYMTAB:
6148 case SHT_DYNSYM:
6149 /* A symbol index - we assume that it is valid. */
6150 break;
6151
6152 default:
6153 /* FIXME: Add support for target specific section types. */
6154 if (section->sh_type == SHT_NOBITS)
6155 /* NOBITS section headers with non-zero sh_info fields can be
6156 created when a binary is stripped of everything but its debug
1a9ccd70
NC		 6157 information. The stripped sections have their headers
6158 preserved but their types set to SHT_NOBITS. So do not check
6159 this type of section. */
dd905818
NC		 6160 ;
6161 else if (section->sh_flags & SHF_INFO_LINK)
6162 {
cb64e50d 6163 if (section->sh_info < 1 || section->sh_info >= elf_header.e_shnum)
dd905818
NC		 6164 warn (_("[%2u]: Expected link to another section in info field"), i);
6165 }
6166 else if (section->sh_type < SHT_LOOS && section->sh_info != 0)
6167 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6168 i, section->sh_info);
6169 break;
6170 }
6171
7bfd842d 6172 printf (" [%2u] ", i);
5477e8a0 6173 if (do_section_details)
74e1a04b 6174 printf ("%s\n ", printable_section_name (section));
595cf52e 6175 else
74e1a04b 6176 print_symbol (-17, SECTION_NAME (section));
0b4362b0 6177
ea52a088
NC		 6178 printf (do_wide ? " %-15s " : " %-15.15s ",
6179 get_section_type_name (section->sh_type));
0b4362b0 6180
f7a99963
NC		 6181 if (is_32bit_elf)
6182 {
cfcac11d
NC		 6183 const char * link_too_big = NULL;
6184
f7a99963 6185 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 6186
f7a99963
NC		 6187 printf ( " %6.6lx %6.6lx %2.2lx",
6188 (unsigned long) section->sh_offset,
6189 (unsigned long) section->sh_size,
6190 (unsigned long) section->sh_entsize);
d1133906 6191
5477e8a0
L		 6192 if (do_section_details)
6193 fputs (" ", stdout);
6194 else
6195 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 6196
cfcac11d
NC		 6197 if (section->sh_link >= elf_header.e_shnum)
6198 {
6199 link_too_big = "";
6200 /* The sh_link value is out of range. Normally this indicates
caa83f8b 6201 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 6202 switch (elf_header.e_machine)
6203 {
caa83f8b 6204 case EM_386:
22abe556 6205 case EM_IAMCU:
caa83f8b 6206 case EM_X86_64:
7f502d6c 6207 case EM_L1OM:
7a9068fe 6208 case EM_K1OM:
cfcac11d
NC		 6209 case EM_OLD_SPARCV9:
6210 case EM_SPARC32PLUS:
6211 case EM_SPARCV9:
6212 case EM_SPARC:
6213 if (section->sh_link == (SHN_BEFORE & 0xffff))
6214 link_too_big = "BEFORE";
6215 else if (section->sh_link == (SHN_AFTER & 0xffff))
6216 link_too_big = "AFTER";
6217 break;
6218 default:
6219 break;
6220 }
6221 }
6222
6223 if (do_section_details)
6224 {
6225 if (link_too_big != NULL && * link_too_big)
6226 printf ("<%s> ", link_too_big);
6227 else
6228 printf ("%2u ", section->sh_link);
6229 printf ("%3u %2lu\n", section->sh_info,
6230 (unsigned long) section->sh_addralign);
6231 }
6232 else
6233 printf ("%2u %3u %2lu\n",
6234 section->sh_link,
6235 section->sh_info,
6236 (unsigned long) section->sh_addralign);
6237
6238 if (link_too_big && ! * link_too_big)
6239 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6240 i, section->sh_link);
f7a99963 6241 }
d974e256
JJ		 6242 else if (do_wide)
6243 {
6244 print_vma (section->sh_addr, LONG_HEX);
6245
6246 if ((long) section->sh_offset == section->sh_offset)
6247 printf (" %6.6lx", (unsigned long) section->sh_offset);
6248 else
6249 {
6250 putchar (' ');
6251 print_vma (section->sh_offset, LONG_HEX);
6252 }
6253
6254 if ((unsigned long) section->sh_size == section->sh_size)
6255 printf (" %6.6lx", (unsigned long) section->sh_size);
6256 else
6257 {
6258 putchar (' ');
6259 print_vma (section->sh_size, LONG_HEX);
6260 }
6261
6262 if ((unsigned long) section->sh_entsize == section->sh_entsize)
6263 printf (" %2.2lx", (unsigned long) section->sh_entsize);
6264 else
6265 {
6266 putchar (' ');
6267 print_vma (section->sh_entsize, LONG_HEX);
6268 }
6269
5477e8a0
L		 6270 if (do_section_details)
6271 fputs (" ", stdout);
6272 else
6273 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 6274
72de5009 6275 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 6276
6277 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 6278 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 6279 else
6280 {
6281 print_vma (section->sh_addralign, DEC);
6282 putchar ('\n');
6283 }
6284 }
5477e8a0 6285 else if (do_section_details)
595cf52e 6286 {
5477e8a0 6287 printf (" %-15.15s ",
595cf52e 6288 get_section_type_name (section->sh_type));
595cf52e
L		 6289 print_vma (section->sh_addr, LONG_HEX);
6290 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 6291 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 6292 else
6293 {
6294 printf (" ");
6295 print_vma (section->sh_offset, LONG_HEX);
6296 }
72de5009 6297 printf (" %u\n ", section->sh_link);
595cf52e 6298 print_vma (section->sh_size, LONG_HEX);
5477e8a0 6299 putchar (' ');
595cf52e
L		 6300 print_vma (section->sh_entsize, LONG_HEX);
6301
72de5009
AM		 6302 printf (" %-16u %lu\n",
6303 section->sh_info,
595cf52e
L		 6304 (unsigned long) section->sh_addralign);
6305 }
f7a99963
NC		 6306 else
6307 {
6308 putchar (' ');
6309 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 6310 if ((long) section->sh_offset == section->sh_offset)
6311 printf (" %8.8lx", (unsigned long) section->sh_offset);
6312 else
6313 {
6314 printf (" ");
6315 print_vma (section->sh_offset, LONG_HEX);
6316 }
f7a99963
NC		 6317 printf ("\n ");
6318 print_vma (section->sh_size, LONG_HEX);
6319 printf (" ");
6320 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 6321
d1133906 6322 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 6323
72de5009
AM		 6324 printf (" %2u %3u %lu\n",
6325 section->sh_link,
6326 section->sh_info,
f7a99963
NC		 6327 (unsigned long) section->sh_addralign);
6328 }
5477e8a0
L		 6329
6330 if (do_section_details)
77115a4a
L		 6331 {
6332 printf (" %s\n", get_elf_section_flags (section->sh_flags));
6333 if ((section->sh_flags & SHF_COMPRESSED) != 0)
6334 {
6335 /* Minimum section size is 12 bytes for 32-bit compression
6336 header + 12 bytes for compressed data header. */
6337 unsigned char buf[24];
d8024a91 6338
77115a4a
L		 6339 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6340 if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
6341 sizeof (buf), _("compression header")))
6342 {
6343 Elf_Internal_Chdr chdr;
d8024a91 6344
ebdf1ebf 6345 (void) get_compression_header (&chdr, buf, sizeof (buf));
d8024a91 6346
77115a4a
L		 6347 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6348 printf (" ZLIB, ");
6349 else
6350 printf (_(" [<unknown>: 0x%x], "),
6351 chdr.ch_type);
6352 print_vma (chdr.ch_size, LONG_HEX);
6353 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6354 }
6355 }
6356 }
252b5132
RH		 6357 }
6358
5477e8a0 6359 if (!do_section_details)
3dbcc61d 6360 {
9fb71ee4
NC		 6361 /* The ordering of the letters shown here matches the ordering of the
6362 corresponding SHF_xxx values, and hence the order in which these
6363 letters will be displayed to the user. */
6364 printf (_("Key to Flags:\n\
6365 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6366 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
fd85a6a1 6367 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
3dbcc61d 6368 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 6369 || elf_header.e_machine == EM_L1OM
6370 || elf_header.e_machine == EM_K1OM)
9fb71ee4 6371 printf (_("l (large), "));
91f68a68 6372 else if (elf_header.e_machine == EM_ARM)
f0728ee3 6373 printf (_("y (purecode), "));
9fb71ee4 6374 printf ("p (processor specific)\n");
0b4362b0 6375 }
d1133906 6376
252b5132
RH		 6377 return 1;
6378}
6379
f5842774
L		 6380static const char *
6381get_group_flags (unsigned int flags)
6382{
1449284b 6383 static char buff[128];
220453ec 6384
6d913794
NC		 6385 if (flags == 0)
6386 return "";
6387 else if (flags == GRP_COMDAT)
6388 return "COMDAT ";
f5842774 6389
6d913794
NC		 6390 snprintf (buff, 14, _("[0x%x: "), flags);
6391
6392 flags &= ~ GRP_COMDAT;
6393 if (flags & GRP_MASKOS)
6394 {
6395 strcat (buff, "<OS specific>");
6396 flags &= ~ GRP_MASKOS;
f5842774 6397 }
6d913794
NC		 6398
6399 if (flags & GRP_MASKPROC)
6400 {
6401 strcat (buff, "<PROC specific>");
6402 flags &= ~ GRP_MASKPROC;
6403 }
6404
6405 if (flags)
6406 strcat (buff, "<unknown>");
6407
6408 strcat (buff, "]");
f5842774
L		 6409 return buff;
6410}
6411
6412static int
2cf0635d 6413process_section_groups (FILE * file)
f5842774 6414{
2cf0635d 6415 Elf_Internal_Shdr * section;
f5842774 6416 unsigned int i;
2cf0635d
NC		 6417 struct group * group;
6418 Elf_Internal_Shdr * symtab_sec;
6419 Elf_Internal_Shdr * strtab_sec;
6420 Elf_Internal_Sym * symtab;
ba5cdace 6421 unsigned long num_syms;
2cf0635d 6422 char * strtab;
c256ffe7 6423 size_t strtab_size;
d1f5c6e3
L		 6424
6425 /* Don't process section groups unless needed. */
6426 if (!do_unwind && !do_section_groups)
6427 return 1;
f5842774
L		 6428
6429 if (elf_header.e_shnum == 0)
6430 {
6431 if (do_section_groups)
82f2dbf7 6432 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 6433
6434 return 1;
6435 }
6436
6437 if (section_headers == NULL)
6438 {
6439 error (_("Section headers are not available!\n"));
fa1908fd
NC		 6440 /* PR 13622: This can happen with a corrupt ELF header. */
6441 return 0;
f5842774
L		 6442 }
6443
3f5e193b
NC		 6444 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
6445 sizeof (struct group *));
e4b17d5c
L		 6446
6447 if (section_headers_groups == NULL)
6448 {
8b73c356
NC		 6449 error (_("Out of memory reading %u section group headers\n"),
6450 elf_header.e_shnum);
e4b17d5c
L		 6451 return 0;
6452 }
6453
f5842774 6454 /* Scan the sections for the group section. */
d1f5c6e3 6455 group_count = 0;
f5842774
L		 6456 for (i = 0, section = section_headers;
6457 i < elf_header.e_shnum;
6458 i++, section++)
e4b17d5c
L		 6459 if (section->sh_type == SHT_GROUP)
6460 group_count++;
6461
d1f5c6e3
L		 6462 if (group_count == 0)
6463 {
6464 if (do_section_groups)
6465 printf (_("\nThere are no section groups in this file.\n"));
6466
6467 return 1;
6468 }
6469
3f5e193b 6470 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 6471
6472 if (section_groups == NULL)
6473 {
8b73c356
NC		 6474 error (_("Out of memory reading %lu groups\n"),
6475 (unsigned long) group_count);
e4b17d5c
L		 6476 return 0;
6477 }
6478
d1f5c6e3
L		 6479 symtab_sec = NULL;
6480 strtab_sec = NULL;
6481 symtab = NULL;
ba5cdace 6482 num_syms = 0;
d1f5c6e3 6483 strtab = NULL;
c256ffe7 6484 strtab_size = 0;
e4b17d5c
L		 6485 for (i = 0, section = section_headers, group = section_groups;
6486 i < elf_header.e_shnum;
6487 i++, section++)
f5842774
L		 6488 {
6489 if (section->sh_type == SHT_GROUP)
6490 {
74e1a04b
NC		 6491 const char * name = printable_section_name (section);
6492 const char * group_name;
2cf0635d
NC		 6493 unsigned char * start;
6494 unsigned char * indices;
f5842774 6495 unsigned int entry, j, size;
2cf0635d
NC		 6496 Elf_Internal_Shdr * sec;
6497 Elf_Internal_Sym * sym;
f5842774
L		 6498
6499 /* Get the symbol table. */
4fbb74a6
AM		 6500 if (section->sh_link >= elf_header.e_shnum
6501 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 6502 != SHT_SYMTAB))
f5842774
L		 6503 {
6504 error (_("Bad sh_link in group section `%s'\n"), name);
6505 continue;
6506 }
d1f5c6e3
L		 6507
6508 if (symtab_sec != sec)
6509 {
6510 symtab_sec = sec;
6511 if (symtab)
6512 free (symtab);
ba5cdace 6513 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 6514 }
f5842774 6515
dd24e3da
NC		 6516 if (symtab == NULL)
6517 {
6518 error (_("Corrupt header in group section `%s'\n"), name);
6519 continue;
6520 }
6521
ba5cdace
NC		 6522 if (section->sh_info >= num_syms)
6523 {
6524 error (_("Bad sh_info in group section `%s'\n"), name);
6525 continue;
6526 }
6527
f5842774
L		 6528 sym = symtab + section->sh_info;
6529
6530 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6531 {
4fbb74a6
AM		 6532 if (sym->st_shndx == 0
6533 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 6534 {
6535 error (_("Bad sh_info in group section `%s'\n"), name);
6536 continue;
6537 }
ba2685cc 6538
4fbb74a6 6539 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 6540 strtab_sec = NULL;
6541 if (strtab)
6542 free (strtab);
f5842774 6543 strtab = NULL;
c256ffe7 6544 strtab_size = 0;
f5842774
L		 6545 }
6546 else
6547 {
6548 /* Get the string table. */
4fbb74a6 6549 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 6550 {
6551 strtab_sec = NULL;
6552 if (strtab)
6553 free (strtab);
6554 strtab = NULL;
6555 strtab_size = 0;
6556 }
6557 else if (strtab_sec
4fbb74a6 6558 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 6559 {
6560 strtab_sec = sec;
6561 if (strtab)
6562 free (strtab);
071436c6 6563
3f5e193b 6564 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
071436c6
NC		 6565 1, strtab_sec->sh_size,
6566 _("string table"));
c256ffe7 6567 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 6568 }
c256ffe7 6569 group_name = sym->st_name < strtab_size
2b692964 6570 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 6571 }
6572
c9c1d674
EG		 6573 /* PR 17531: file: loop. */
6574 if (section->sh_entsize > section->sh_size)
6575 {
6576 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6577 printable_section_name (section),
8066deb1
AM		 6578 (unsigned long) section->sh_entsize,
6579 (unsigned long) section->sh_size);
c9c1d674
EG		 6580 break;
6581 }
6582
3f5e193b
NC		 6583 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6584 1, section->sh_size,
6585 _("section data"));
59245841
NC		 6586 if (start == NULL)
6587 continue;
f5842774
L		 6588
6589 indices = start;
6590 size = (section->sh_size / section->sh_entsize) - 1;
6591 entry = byte_get (indices, 4);
6592 indices += 4;
e4b17d5c
L		 6593
6594 if (do_section_groups)
6595 {
2b692964 6596 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 6597 get_group_flags (entry), i, name, group_name, size);
ba2685cc 6598
e4b17d5c
L		 6599 printf (_(" [Index] Name\n"));
6600 }
6601
6602 group->group_index = i;
6603
f5842774
L		 6604 for (j = 0; j < size; j++)
6605 {
2cf0635d 6606 struct group_list * g;
e4b17d5c 6607
f5842774
L		 6608 entry = byte_get (indices, 4);
6609 indices += 4;
6610
4fbb74a6 6611 if (entry >= elf_header.e_shnum)
391cb864 6612 {
57028622
NC		 6613 static unsigned num_group_errors = 0;
6614
6615 if (num_group_errors ++ < 10)
6616 {
6617 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6618 entry, i, elf_header.e_shnum - 1);
6619 if (num_group_errors == 10)
6620 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6621 }
391cb864
L		 6622 continue;
6623 }
391cb864 6624
4fbb74a6 6625 if (section_headers_groups [entry] != NULL)
e4b17d5c 6626 {
d1f5c6e3
L		 6627 if (entry)
6628 {
57028622
NC		 6629 static unsigned num_errs = 0;
6630
6631 if (num_errs ++ < 10)
6632 {
6633 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6634 entry, i,
6635 section_headers_groups [entry]->group_index);
6636 if (num_errs == 10)
6637 warn (_("Further error messages about already contained group sections suppressed\n"));
6638 }
d1f5c6e3
L		 6639 continue;
6640 }
6641 else
6642 {
6643 /* Intel C/C++ compiler may put section 0 in a
6644 section group. We just warn it the first time
6645 and ignore it afterwards. */
6646 static int warned = 0;
6647 if (!warned)
6648 {
6649 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 6650 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 6651 warned++;
6652 }
6653 }
e4b17d5c
L		 6654 }
6655
4fbb74a6 6656 section_headers_groups [entry] = group;
e4b17d5c
L		 6657
6658 if (do_section_groups)
6659 {
4fbb74a6 6660 sec = section_headers + entry;
74e1a04b 6661 printf (" [%5u] %s\n", entry, printable_section_name (sec));
ba2685cc
AM		 6662 }
6663
3f5e193b 6664 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 6665 g->section_index = entry;
6666 g->next = group->root;
6667 group->root = g;
f5842774
L		 6668 }
6669
f5842774
L		 6670 if (start)
6671 free (start);
e4b17d5c
L		 6672
6673 group++;
f5842774
L		 6674 }
6675 }
6676
d1f5c6e3
L		 6677 if (symtab)
6678 free (symtab);
6679 if (strtab)
6680 free (strtab);
f5842774
L		 6681 return 1;
6682}
6683
28f997cf
TG		 6684/* Data used to display dynamic fixups. */
6685
6686struct ia64_vms_dynfixup
6687{
6688 bfd_vma needed_ident; /* Library ident number. */
6689 bfd_vma needed; /* Index in the dstrtab of the library name. */
6690 bfd_vma fixup_needed; /* Index of the library. */
6691 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6692 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6693};
6694
6695/* Data used to display dynamic relocations. */
6696
6697struct ia64_vms_dynimgrela
6698{
6699 bfd_vma img_rela_cnt; /* Number of relocations. */
6700 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6701};
6702
6703/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6704 library). */
6705
6706static void
6707dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6708 const char *strtab, unsigned int strtab_sz)
6709{
6710 Elf64_External_VMS_IMAGE_FIXUP *imfs;
6711 long i;
6712 const char *lib_name;
6713
6714 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6715 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6716 _("dynamic section image fixups"));
6717 if (!imfs)
6718 return;
6719
6720 if (fixup->needed < strtab_sz)
6721 lib_name = strtab + fixup->needed;
6722 else
6723 {
6724 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 6725 (unsigned long) fixup->needed);
28f997cf
TG		 6726 lib_name = "???";
6727 }
6728 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6729 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6730 printf
6731 (_("Seg Offset Type SymVec DataType\n"));
6732
6733 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6734 {
6735 unsigned int type;
6736 const char *rtype;
6737
6738 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6739 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6740 type = BYTE_GET (imfs [i].type);
6741 rtype = elf_ia64_reloc_type (type);
6742 if (rtype == NULL)
6743 printf (" 0x%08x ", type);
6744 else
6745 printf (" %-32s ", rtype);
6746 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6747 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6748 }
6749
6750 free (imfs);
6751}
6752
6753/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6754
6755static void
6756dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6757{
6758 Elf64_External_VMS_IMAGE_RELA *imrs;
6759 long i;
6760
6761 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6762 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 6763 _("dynamic section image relocations"));
28f997cf
TG		 6764 if (!imrs)
6765 return;
6766
6767 printf (_("\nImage relocs\n"));
6768 printf
6769 (_("Seg Offset Type Addend Seg Sym Off\n"));
6770
6771 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6772 {
6773 unsigned int type;
6774 const char *rtype;
6775
6776 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6777 printf ("%08" BFD_VMA_FMT "x ",
6778 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6779 type = BYTE_GET (imrs [i].type);
6780 rtype = elf_ia64_reloc_type (type);
6781 if (rtype == NULL)
6782 printf ("0x%08x ", type);
6783 else
6784 printf ("%-31s ", rtype);
6785 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6786 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6787 printf ("%08" BFD_VMA_FMT "x\n",
6788 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6789 }
6790
6791 free (imrs);
6792}
6793
6794/* Display IA-64 OpenVMS dynamic relocations and fixups. */
6795
6796static int
6797process_ia64_vms_dynamic_relocs (FILE *file)
6798{
6799 struct ia64_vms_dynfixup fixup;
6800 struct ia64_vms_dynimgrela imgrela;
6801 Elf_Internal_Dyn *entry;
6802 int res = 0;
6803 bfd_vma strtab_off = 0;
6804 bfd_vma strtab_sz = 0;
6805 char *strtab = NULL;
6806
6807 memset (&fixup, 0, sizeof (fixup));
6808 memset (&imgrela, 0, sizeof (imgrela));
6809
6810 /* Note: the order of the entries is specified by the OpenVMS specs. */
6811 for (entry = dynamic_section;
6812 entry < dynamic_section + dynamic_nent;
6813 entry++)
6814 {
6815 switch (entry->d_tag)
6816 {
6817 case DT_IA_64_VMS_STRTAB_OFFSET:
6818 strtab_off = entry->d_un.d_val;
6819 break;
6820 case DT_STRSZ:
6821 strtab_sz = entry->d_un.d_val;
6822 if (strtab == NULL)
6823 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6824 1, strtab_sz, _("dynamic string section"));
6825 break;
6826
6827 case DT_IA_64_VMS_NEEDED_IDENT:
6828 fixup.needed_ident = entry->d_un.d_val;
6829 break;
6830 case DT_NEEDED:
6831 fixup.needed = entry->d_un.d_val;
6832 break;
6833 case DT_IA_64_VMS_FIXUP_NEEDED:
6834 fixup.fixup_needed = entry->d_un.d_val;
6835 break;
6836 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6837 fixup.fixup_rela_cnt = entry->d_un.d_val;
6838 break;
6839 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6840 fixup.fixup_rela_off = entry->d_un.d_val;
6841 res++;
6842 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6843 break;
6844
6845 case DT_IA_64_VMS_IMG_RELA_CNT:
6846 imgrela.img_rela_cnt = entry->d_un.d_val;
6847 break;
6848 case DT_IA_64_VMS_IMG_RELA_OFF:
6849 imgrela.img_rela_off = entry->d_un.d_val;
6850 res++;
6851 dump_ia64_vms_dynamic_relocs (file, &imgrela);
6852 break;
6853
6854 default:
6855 break;
6856 }
6857 }
6858
6859 if (strtab != NULL)
6860 free (strtab);
6861
6862 return res;
6863}
6864
85b1c36d 6865static struct
566b0d53 6866{
2cf0635d 6867 const char * name;
566b0d53
L		 6868 int reloc;
6869 int size;
6870 int rela;
6871} dynamic_relocations [] =
6872{
6873 { "REL", DT_REL, DT_RELSZ, FALSE },
6874 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6875 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6876};
6877
252b5132 6878/* Process the reloc section. */
18bd398b 6879
252b5132 6880static int
2cf0635d 6881process_relocs (FILE * file)
252b5132 6882{
b34976b6
AM		 6883 unsigned long rel_size;
6884 unsigned long rel_offset;
252b5132
RH		 6885
6886
6887 if (!do_reloc)
6888 return 1;
6889
6890 if (do_using_dynamic)
6891 {
566b0d53 6892 int is_rela;
2cf0635d 6893 const char * name;
566b0d53
L		 6894 int has_dynamic_reloc;
6895 unsigned int i;
0de14b54 6896
566b0d53 6897 has_dynamic_reloc = 0;
252b5132 6898
566b0d53 6899 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 6900 {
566b0d53
L		 6901 is_rela = dynamic_relocations [i].rela;
6902 name = dynamic_relocations [i].name;
6903 rel_size = dynamic_info [dynamic_relocations [i].size];
6904 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 6905
566b0d53
L		 6906 has_dynamic_reloc |= rel_size;
6907
6908 if (is_rela == UNKNOWN)
aa903cfb 6909 {
566b0d53
L		 6910 if (dynamic_relocations [i].reloc == DT_JMPREL)
6911 switch (dynamic_info[DT_PLTREL])
6912 {
6913 case DT_REL:
6914 is_rela = FALSE;
6915 break;
6916 case DT_RELA:
6917 is_rela = TRUE;
6918 break;
6919 }
aa903cfb 6920 }
252b5132 6921
566b0d53
L		 6922 if (rel_size)
6923 {
6924 printf
6925 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6926 name, rel_offset, rel_size);
252b5132 6927
d93f0186
NC		 6928 dump_relocations (file,
6929 offset_from_vma (file, rel_offset, rel_size),
6930 rel_size,
566b0d53 6931 dynamic_symbols, num_dynamic_syms,
bb4d2ac2
L		 6932 dynamic_strings, dynamic_strings_length,
6933 is_rela, 1);
566b0d53 6934 }
252b5132 6935 }
566b0d53 6936
28f997cf
TG		 6937 if (is_ia64_vms ())
6938 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6939
566b0d53 6940 if (! has_dynamic_reloc)
252b5132
RH		 6941 printf (_("\nThere are no dynamic relocations in this file.\n"));
6942 }
6943 else
6944 {
2cf0635d 6945 Elf_Internal_Shdr * section;
b34976b6
AM		 6946 unsigned long i;
6947 int found = 0;
252b5132
RH		 6948
6949 for (i = 0, section = section_headers;
6950 i < elf_header.e_shnum;
b34976b6 6951 i++, section++)
252b5132
RH		 6952 {
6953 if ( section->sh_type != SHT_RELA
6954 && section->sh_type != SHT_REL)
6955 continue;
6956
6957 rel_offset = section->sh_offset;
6958 rel_size = section->sh_size;
6959
6960 if (rel_size)
6961 {
2cf0635d 6962 Elf_Internal_Shdr * strsec;
b34976b6 6963 int is_rela;
103f02d3 6964
252b5132
RH		 6965 printf (_("\nRelocation section "));
6966
6967 if (string_table == NULL)
19936277 6968 printf ("%d", section->sh_name);
252b5132 6969 else
74e1a04b 6970 printf ("'%s'", printable_section_name (section));
252b5132
RH		 6971
6972 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6973 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6974
d79b3d50
NC		 6975 is_rela = section->sh_type == SHT_RELA;
6976
4fbb74a6
AM		 6977 if (section->sh_link != 0
6978 && section->sh_link < elf_header.e_shnum)
af3fc3bc 6979 {
2cf0635d
NC		 6980 Elf_Internal_Shdr * symsec;
6981 Elf_Internal_Sym * symtab;
d79b3d50 6982 unsigned long nsyms;
c256ffe7 6983 unsigned long strtablen = 0;
2cf0635d 6984 char * strtab = NULL;
57346661 6985
4fbb74a6 6986 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 6987 if (symsec->sh_type != SHT_SYMTAB
6988 && symsec->sh_type != SHT_DYNSYM)
6989 continue;
6990
ba5cdace 6991 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 6992
af3fc3bc
AM		 6993 if (symtab == NULL)
6994 continue;
252b5132 6995
4fbb74a6
AM		 6996 if (symsec->sh_link != 0
6997 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 6998 {
4fbb74a6 6999 strsec = section_headers + symsec->sh_link;
103f02d3 7000
3f5e193b 7001 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
071436c6
NC		 7002 1, strsec->sh_size,
7003 _("string table"));
c256ffe7
JJ		 7004 strtablen = strtab == NULL ? 0 : strsec->sh_size;
7005 }
252b5132 7006
d79b3d50 7007 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2
L		 7008 symtab, nsyms, strtab, strtablen,
7009 is_rela,
7010 symsec->sh_type == SHT_DYNSYM);
d79b3d50
NC		 7011 if (strtab)
7012 free (strtab);
7013 free (symtab);
7014 }
7015 else
7016 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2 7017 NULL, 0, NULL, 0, is_rela, 0);
252b5132
RH		 7018
7019 found = 1;
7020 }
7021 }
7022
7023 if (! found)
7024 printf (_("\nThere are no relocations in this file.\n"));
7025 }
7026
7027 return 1;
7028}
7029
4d6ed7c8
NC		 7030/* An absolute address consists of a section and an offset. If the
7031 section is NULL, the offset itself is the address, otherwise, the
7032 address equals to LOAD_ADDRESS(section) + offset. */
7033
7034struct absaddr
948f632f
DA		 7035{
7036 unsigned short section;
7037 bfd_vma offset;
7038};
4d6ed7c8 7039
1949de15
L		 7040#define ABSADDR(a) \
7041 ((a).section \
7042 ? section_headers [(a).section].sh_addr + (a).offset \
7043 : (a).offset)
7044
948f632f
DA		 7045/* Find the nearest symbol at or below ADDR. Returns the symbol
7046 name, if found, and the offset from the symbol to ADDR. */
4d6ed7c8 7047
4d6ed7c8 7048static void
2cf0635d 7049find_symbol_for_address (Elf_Internal_Sym * symtab,
948f632f
DA		 7050 unsigned long nsyms,
7051 const char * strtab,
7052 unsigned long strtab_size,
7053 struct absaddr addr,
7054 const char ** symname,
7055 bfd_vma * offset)
4d6ed7c8 7056{
d3ba0551 7057 bfd_vma dist = 0x100000;
2cf0635d 7058 Elf_Internal_Sym * sym;
948f632f
DA		 7059 Elf_Internal_Sym * beg;
7060 Elf_Internal_Sym * end;
2cf0635d 7061 Elf_Internal_Sym * best = NULL;
4d6ed7c8 7062
0b6ae522 7063 REMOVE_ARCH_BITS (addr.offset);
948f632f
DA		 7064 beg = symtab;
7065 end = symtab + nsyms;
0b6ae522 7066
948f632f 7067 while (beg < end)
4d6ed7c8 7068 {
948f632f
DA		 7069 bfd_vma value;
7070
7071 sym = beg + (end - beg) / 2;
0b6ae522 7072
948f632f 7073 value = sym->st_value;
0b6ae522
DJ		 7074 REMOVE_ARCH_BITS (value);
7075
948f632f 7076 if (sym->st_name != 0
4d6ed7c8 7077 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 7078 && addr.offset >= value
7079 && addr.offset - value < dist)
4d6ed7c8
NC		 7080 {
7081 best = sym;
0b6ae522 7082 dist = addr.offset - value;
4d6ed7c8
NC		 7083 if (!dist)
7084 break;
7085 }
948f632f
DA		 7086
7087 if (addr.offset < value)
7088 end = sym;
7089 else
7090 beg = sym + 1;
4d6ed7c8 7091 }
1b31d05e 7092
4d6ed7c8
NC		 7093 if (best)
7094 {
57346661 7095 *symname = (best->st_name >= strtab_size
2b692964 7096 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 7097 *offset = dist;
7098 return;
7099 }
1b31d05e 7100
4d6ed7c8
NC		 7101 *symname = NULL;
7102 *offset = addr.offset;
7103}
7104
948f632f
DA		 7105static int
7106symcmp (const void *p, const void *q)
7107{
7108 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7109 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7110
7111 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7112}
7113
7114/* Process the unwind section. */
7115
7116#include "unwind-ia64.h"
7117
7118struct ia64_unw_table_entry
7119{
7120 struct absaddr start;
7121 struct absaddr end;
7122 struct absaddr info;
7123};
7124
7125struct ia64_unw_aux_info
7126{
7127 struct ia64_unw_table_entry *table; /* Unwind table. */
7128 unsigned long table_len; /* Length of unwind table. */
7129 unsigned char * info; /* Unwind info. */
7130 unsigned long info_size; /* Size of unwind info. */
7131 bfd_vma info_addr; /* Starting address of unwind info. */
7132 bfd_vma seg_base; /* Starting address of segment. */
7133 Elf_Internal_Sym * symtab; /* The symbol table. */
7134 unsigned long nsyms; /* Number of symbols. */
7135 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7136 unsigned long nfuns; /* Number of entries in funtab. */
7137 char * strtab; /* The string table. */
7138 unsigned long strtab_size; /* Size of string table. */
7139};
7140
4d6ed7c8 7141static void
2cf0635d 7142dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 7143{
2cf0635d 7144 struct ia64_unw_table_entry * tp;
948f632f 7145 unsigned long j, nfuns;
4d6ed7c8 7146 int in_body;
7036c0e1 7147
948f632f
DA		 7148 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7149 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7150 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7151 aux->funtab[nfuns++] = aux->symtab[j];
7152 aux->nfuns = nfuns;
7153 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7154
4d6ed7c8
NC		 7155 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7156 {
7157 bfd_vma stamp;
7158 bfd_vma offset;
2cf0635d
NC		 7159 const unsigned char * dp;
7160 const unsigned char * head;
53774b7e 7161 const unsigned char * end;
2cf0635d 7162 const char * procname;
4d6ed7c8 7163
948f632f 7164 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661 7165 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 7166
7167 fputs ("\n<", stdout);
7168
7169 if (procname)
7170 {
7171 fputs (procname, stdout);
7172
7173 if (offset)
7174 printf ("+%lx", (unsigned long) offset);
7175 }
7176
7177 fputs (">: [", stdout);
7178 print_vma (tp->start.offset, PREFIX_HEX);
7179 fputc ('-', stdout);
7180 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 7181 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 7182 (unsigned long) (tp->info.offset - aux->seg_base));
7183
53774b7e
NC		 7184 /* PR 17531: file: 86232b32. */
7185 if (aux->info == NULL)
7186 continue;
7187
7188 /* PR 17531: file: 0997b4d1. */
7189 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7190 {
7191 warn (_("Invalid offset %lx in table entry %ld\n"),
7192 (long) tp->info.offset, (long) (tp - aux->table));
7193 continue;
7194 }
7195
1949de15 7196 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 7197 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 7198
86f55779 7199 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 7200 (unsigned) UNW_VER (stamp),
7201 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7202 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7203 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 7204 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 7205
7206 if (UNW_VER (stamp) != 1)
7207 {
2b692964 7208 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 7209 continue;
7210 }
7211
7212 in_body = 0;
53774b7e
NC		 7213 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7214 /* PR 17531: file: 16ceda89. */
7215 if (end > aux->info + aux->info_size)
7216 end = aux->info + aux->info_size;
7217 for (dp = head + 8; dp < end;)
b4477bc8 7218 dp = unw_decode (dp, in_body, & in_body, end);
4d6ed7c8 7219 }
948f632f
DA		 7220
7221 free (aux->funtab);
4d6ed7c8
NC		 7222}
7223
53774b7e 7224static bfd_boolean
2cf0635d
NC		 7225slurp_ia64_unwind_table (FILE * file,
7226 struct ia64_unw_aux_info * aux,
7227 Elf_Internal_Shdr * sec)
4d6ed7c8 7228{
89fac5e3 7229 unsigned long size, nrelas, i;
2cf0635d
NC		 7230 Elf_Internal_Phdr * seg;
7231 struct ia64_unw_table_entry * tep;
7232 Elf_Internal_Shdr * relsec;
7233 Elf_Internal_Rela * rela;
7234 Elf_Internal_Rela * rp;
7235 unsigned char * table;
7236 unsigned char * tp;
7237 Elf_Internal_Sym * sym;
7238 const char * relname;
4d6ed7c8 7239
53774b7e
NC		 7240 aux->table_len = 0;
7241
4d6ed7c8
NC		 7242 /* First, find the starting address of the segment that includes
7243 this section: */
7244
7245 if (elf_header.e_phnum)
7246 {
d93f0186 7247 if (! get_program_headers (file))
53774b7e 7248 return FALSE;
4d6ed7c8 7249
d93f0186
NC		 7250 for (seg = program_headers;
7251 seg < program_headers + elf_header.e_phnum;
7252 ++seg)
4d6ed7c8
NC		 7253 {
7254 if (seg->p_type != PT_LOAD)
7255 continue;
7256
7257 if (sec->sh_addr >= seg->p_vaddr
7258 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7259 {
7260 aux->seg_base = seg->p_vaddr;
7261 break;
7262 }
7263 }
4d6ed7c8
NC		 7264 }
7265
7266 /* Second, build the unwind table from the contents of the unwind section: */
7267 size = sec->sh_size;
3f5e193b
NC		 7268 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7269 _("unwind table"));
a6e9f9df 7270 if (!table)
53774b7e 7271 return FALSE;
4d6ed7c8 7272
53774b7e 7273 aux->table_len = size / (3 * eh_addr_size);
3f5e193b 7274 aux->table = (struct ia64_unw_table_entry *)
53774b7e 7275 xcmalloc (aux->table_len, sizeof (aux->table[0]));
89fac5e3 7276 tep = aux->table;
53774b7e
NC		 7277
7278 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
4d6ed7c8
NC		 7279 {
7280 tep->start.section = SHN_UNDEF;
7281 tep->end.section = SHN_UNDEF;
7282 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 7283 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7284 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7285 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 7286 tep->start.offset += aux->seg_base;
7287 tep->end.offset += aux->seg_base;
7288 tep->info.offset += aux->seg_base;
7289 }
7290 free (table);
7291
41e92641 7292 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 7293 for (relsec = section_headers;
7294 relsec < section_headers + elf_header.e_shnum;
7295 ++relsec)
7296 {
7297 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 7298 || relsec->sh_info >= elf_header.e_shnum
7299 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 7300 continue;
7301
7302 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7303 & rela, & nrelas))
53774b7e
NC		 7304 {
7305 free (aux->table);
7306 aux->table = NULL;
7307 aux->table_len = 0;
7308 return FALSE;
7309 }
4d6ed7c8
NC		 7310
7311 for (rp = rela; rp < rela + nrelas; ++rp)
7312 {
aca88567
NC		 7313 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
7314 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 7315
82b1b41b
NC		 7316 /* PR 17531: file: 9fa67536. */
7317 if (relname == NULL)
7318 {
7319 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
7320 continue;
7321 }
948f632f 7322
0112cd26 7323 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 7324 {
82b1b41b 7325 warn (_("Skipping unexpected relocation type: %s\n"), relname);
4d6ed7c8
NC		 7326 continue;
7327 }
7328
89fac5e3 7329 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 7330
53774b7e
NC		 7331 /* PR 17531: file: 5bc8d9bf. */
7332 if (i >= aux->table_len)
7333 {
7334 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7335 continue;
7336 }
7337
7338 switch (rp->r_offset / eh_addr_size % 3)
4d6ed7c8
NC		 7339 {
7340 case 0:
7341 aux->table[i].start.section = sym->st_shndx;
e466bc6e 7342 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 7343 break;
7344 case 1:
7345 aux->table[i].end.section = sym->st_shndx;
e466bc6e 7346 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 7347 break;
7348 case 2:
7349 aux->table[i].info.section = sym->st_shndx;
e466bc6e 7350 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 7351 break;
7352 default:
7353 break;
7354 }
7355 }
7356
7357 free (rela);
7358 }
7359
53774b7e 7360 return TRUE;
4d6ed7c8
NC		 7361}
7362
1b31d05e 7363static void
2cf0635d 7364ia64_process_unwind (FILE * file)
4d6ed7c8 7365{
2cf0635d
NC		 7366 Elf_Internal_Shdr * sec;
7367 Elf_Internal_Shdr * unwsec = NULL;
7368 Elf_Internal_Shdr * strsec;
89fac5e3 7369 unsigned long i, unwcount = 0, unwstart = 0;
57346661 7370 struct ia64_unw_aux_info aux;
f1467e33 7371
4d6ed7c8
NC		 7372 memset (& aux, 0, sizeof (aux));
7373
4d6ed7c8
NC		 7374 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7375 {
c256ffe7 7376 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 7377 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 7378 {
ba5cdace 7379 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 7380
4fbb74a6 7381 strsec = section_headers + sec->sh_link;
4082ef84
NC		 7382 if (aux.strtab != NULL)
7383 {
7384 error (_("Multiple auxillary string tables encountered\n"));
7385 free (aux.strtab);
7386 }
3f5e193b
NC		 7387 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7388 1, strsec->sh_size,
7389 _("string table"));
c256ffe7 7390 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 7391 }
7392 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 7393 unwcount++;
7394 }
7395
7396 if (!unwcount)
7397 printf (_("\nThere are no unwind sections in this file.\n"));
7398
7399 while (unwcount-- > 0)
7400 {
2cf0635d 7401 char * suffix;
579f31ac
JJ		 7402 size_t len, len2;
7403
4082ef84 7404 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
579f31ac
JJ		 7405 i < elf_header.e_shnum; ++i, ++sec)
7406 if (sec->sh_type == SHT_IA_64_UNWIND)
7407 {
7408 unwsec = sec;
7409 break;
7410 }
4082ef84
NC		 7411 /* We have already counted the number of SHT_IA64_UNWIND
7412 sections so the loop above should never fail. */
7413 assert (unwsec != NULL);
579f31ac
JJ		 7414
7415 unwstart = i + 1;
7416 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7417
e4b17d5c
L		 7418 if ((unwsec->sh_flags & SHF_GROUP) != 0)
7419 {
7420 /* We need to find which section group it is in. */
4082ef84 7421 struct group_list * g;
e4b17d5c 7422
4082ef84
NC		 7423 if (section_headers_groups == NULL
7424 || section_headers_groups [i] == NULL)
7425 i = elf_header.e_shnum;
7426 else
e4b17d5c 7427 {
4082ef84 7428 g = section_headers_groups [i]->root;
18bd398b 7429
4082ef84
NC		 7430 for (; g != NULL; g = g->next)
7431 {
7432 sec = section_headers + g->section_index;
e4b17d5c 7433
4082ef84
NC		 7434 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7435 break;
7436 }
7437
7438 if (g == NULL)
7439 i = elf_header.e_shnum;
7440 }
e4b17d5c 7441 }
18bd398b 7442 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 7443 {
18bd398b 7444 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 7445 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7446 suffix = SECTION_NAME (unwsec) + len;
7447 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7448 ++i, ++sec)
18bd398b
NC		 7449 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7450 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 7451 break;
7452 }
7453 else
7454 {
7455 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 7456 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 7457 len = sizeof (ELF_STRING_ia64_unwind) - 1;
7458 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7459 suffix = "";
18bd398b 7460 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 7461 suffix = SECTION_NAME (unwsec) + len;
7462 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7463 ++i, ++sec)
18bd398b
NC		 7464 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7465 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 7466 break;
7467 }
7468
7469 if (i == elf_header.e_shnum)
7470 {
7471 printf (_("\nCould not find unwind info section for "));
7472
7473 if (string_table == NULL)
7474 printf ("%d", unwsec->sh_name);
7475 else
74e1a04b 7476 printf ("'%s'", printable_section_name (unwsec));
579f31ac
JJ		 7477 }
7478 else
4d6ed7c8 7479 {
4d6ed7c8 7480 aux.info_addr = sec->sh_addr;
3f5e193b 7481 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
4082ef84
NC		 7482 sec->sh_size,
7483 _("unwind info"));
59245841 7484 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 7485
579f31ac 7486 printf (_("\nUnwind section "));
4d6ed7c8 7487
579f31ac
JJ		 7488 if (string_table == NULL)
7489 printf ("%d", unwsec->sh_name);
7490 else
74e1a04b 7491 printf ("'%s'", printable_section_name (unwsec));
4d6ed7c8 7492
579f31ac 7493 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 7494 (unsigned long) unwsec->sh_offset,
89fac5e3 7495 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 7496
53774b7e
NC		 7497 if (slurp_ia64_unwind_table (file, & aux, unwsec)
7498 && aux.table_len > 0)
579f31ac
JJ		 7499 dump_ia64_unwind (& aux);
7500
7501 if (aux.table)
7502 free ((char *) aux.table);
7503 if (aux.info)
7504 free ((char *) aux.info);
7505 aux.table = NULL;
7506 aux.info = NULL;
7507 }
4d6ed7c8 7508 }
4d6ed7c8 7509
4d6ed7c8
NC		 7510 if (aux.symtab)
7511 free (aux.symtab);
7512 if (aux.strtab)
7513 free ((char *) aux.strtab);
4d6ed7c8
NC		 7514}
7515
3f5e193b
NC		 7516struct hppa_unw_table_entry
7517 {
7518 struct absaddr start;
7519 struct absaddr end;
948f632f 7520 unsigned int Cannot_unwind:1; /* 0 */
3f5e193b
NC		 7521 unsigned int Millicode:1; /* 1 */
7522 unsigned int Millicode_save_sr0:1; /* 2 */
7523 unsigned int Region_description:2; /* 3..4 */
7524 unsigned int reserved1:1; /* 5 */
7525 unsigned int Entry_SR:1; /* 6 */
7526 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
7527 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
7528 unsigned int Args_stored:1; /* 16 */
948f632f
DA		 7529 unsigned int Variable_Frame:1; /* 17 */
7530 unsigned int Separate_Package_Body:1; /* 18 */
3f5e193b 7531 unsigned int Frame_Extension_Millicode:1; /* 19 */
948f632f
DA		 7532 unsigned int Stack_Overflow_Check:1; /* 20 */
7533 unsigned int Two_Instruction_SP_Increment:1;/* 21 */
3f5e193b
NC		 7534 unsigned int Ada_Region:1; /* 22 */
7535 unsigned int cxx_info:1; /* 23 */
948f632f
DA		 7536 unsigned int cxx_try_catch:1; /* 24 */
7537 unsigned int sched_entry_seq:1; /* 25 */
3f5e193b 7538 unsigned int reserved2:1; /* 26 */
948f632f
DA		 7539 unsigned int Save_SP:1; /* 27 */
7540 unsigned int Save_RP:1; /* 28 */
3f5e193b
NC		 7541 unsigned int Save_MRP_in_frame:1; /* 29 */
7542 unsigned int extn_ptr_defined:1; /* 30 */
948f632f 7543 unsigned int Cleanup_defined:1; /* 31 */
3f5e193b 7544
948f632f
DA		 7545 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
7546 unsigned int HP_UX_interrupt_marker:1; /* 1 */
3f5e193b 7547 unsigned int Large_frame:1; /* 2 */
948f632f 7548 unsigned int Pseudo_SP_Set:1; /* 3 */
3f5e193b
NC		 7549 unsigned int reserved4:1; /* 4 */
7550 unsigned int Total_frame_size:27; /* 5..31 */
7551 };
7552
57346661 7553struct hppa_unw_aux_info
948f632f
DA		 7554{
7555 struct hppa_unw_table_entry * table; /* Unwind table. */
7556 unsigned long table_len; /* Length of unwind table. */
7557 bfd_vma seg_base; /* Starting address of segment. */
7558 Elf_Internal_Sym * symtab; /* The symbol table. */
7559 unsigned long nsyms; /* Number of symbols. */
7560 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7561 unsigned long nfuns; /* Number of entries in funtab. */
7562 char * strtab; /* The string table. */
7563 unsigned long strtab_size; /* Size of string table. */
7564};
57346661
AM		 7565
7566static void
2cf0635d 7567dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 7568{
2cf0635d 7569 struct hppa_unw_table_entry * tp;
948f632f
DA		 7570 unsigned long j, nfuns;
7571
7572 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7573 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7574 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7575 aux->funtab[nfuns++] = aux->symtab[j];
7576 aux->nfuns = nfuns;
7577 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
57346661 7578
57346661
AM		 7579 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7580 {
7581 bfd_vma offset;
2cf0635d 7582 const char * procname;
57346661 7583
948f632f 7584 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661
AM		 7585 aux->strtab_size, tp->start, &procname,
7586 &offset);
7587
7588 fputs ("\n<", stdout);
7589
7590 if (procname)
7591 {
7592 fputs (procname, stdout);
7593
7594 if (offset)
7595 printf ("+%lx", (unsigned long) offset);
7596 }
7597
7598 fputs (">: [", stdout);
7599 print_vma (tp->start.offset, PREFIX_HEX);
7600 fputc ('-', stdout);
7601 print_vma (tp->end.offset, PREFIX_HEX);
7602 printf ("]\n\t");
7603
18bd398b
NC		 7604#define PF(_m) if (tp->_m) printf (#_m " ");
7605#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 7606 PF(Cannot_unwind);
7607 PF(Millicode);
7608 PF(Millicode_save_sr0);
18bd398b 7609 /* PV(Region_description); */
57346661
AM		 7610 PF(Entry_SR);
7611 PV(Entry_FR);
7612 PV(Entry_GR);
7613 PF(Args_stored);
7614 PF(Variable_Frame);
7615 PF(Separate_Package_Body);
7616 PF(Frame_Extension_Millicode);
7617 PF(Stack_Overflow_Check);
7618 PF(Two_Instruction_SP_Increment);
7619 PF(Ada_Region);
7620 PF(cxx_info);
7621 PF(cxx_try_catch);
7622 PF(sched_entry_seq);
7623 PF(Save_SP);
7624 PF(Save_RP);
7625 PF(Save_MRP_in_frame);
7626 PF(extn_ptr_defined);
7627 PF(Cleanup_defined);
7628 PF(MPE_XL_interrupt_marker);
7629 PF(HP_UX_interrupt_marker);
7630 PF(Large_frame);
7631 PF(Pseudo_SP_Set);
7632 PV(Total_frame_size);
7633#undef PF
7634#undef PV
7635 }
7636
18bd398b 7637 printf ("\n");
948f632f
DA		 7638
7639 free (aux->funtab);
57346661
AM		 7640}
7641
7642static int
2cf0635d
NC		 7643slurp_hppa_unwind_table (FILE * file,
7644 struct hppa_unw_aux_info * aux,
7645 Elf_Internal_Shdr * sec)
57346661 7646{
1c0751b2 7647 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 7648 Elf_Internal_Phdr * seg;
7649 struct hppa_unw_table_entry * tep;
7650 Elf_Internal_Shdr * relsec;
7651 Elf_Internal_Rela * rela;
7652 Elf_Internal_Rela * rp;
7653 unsigned char * table;
7654 unsigned char * tp;
7655 Elf_Internal_Sym * sym;
7656 const char * relname;
57346661 7657
57346661
AM		 7658 /* First, find the starting address of the segment that includes
7659 this section. */
7660
7661 if (elf_header.e_phnum)
7662 {
7663 if (! get_program_headers (file))
7664 return 0;
7665
7666 for (seg = program_headers;
7667 seg < program_headers + elf_header.e_phnum;
7668 ++seg)
7669 {
7670 if (seg->p_type != PT_LOAD)
7671 continue;
7672
7673 if (sec->sh_addr >= seg->p_vaddr
7674 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7675 {
7676 aux->seg_base = seg->p_vaddr;
7677 break;
7678 }
7679 }
7680 }
7681
7682 /* Second, build the unwind table from the contents of the unwind
7683 section. */
7684 size = sec->sh_size;
3f5e193b
NC		 7685 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7686 _("unwind table"));
57346661
AM		 7687 if (!table)
7688 return 0;
7689
1c0751b2
DA		 7690 unw_ent_size = 16;
7691 nentries = size / unw_ent_size;
7692 size = unw_ent_size * nentries;
57346661 7693
3f5e193b
NC		 7694 tep = aux->table = (struct hppa_unw_table_entry *)
7695 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 7696
1c0751b2 7697 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 7698 {
7699 unsigned int tmp1, tmp2;
7700
7701 tep->start.section = SHN_UNDEF;
7702 tep->end.section = SHN_UNDEF;
7703
1c0751b2
DA		 7704 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7705 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7706 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7707 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7708
7709 tep->start.offset += aux->seg_base;
7710 tep->end.offset += aux->seg_base;
57346661
AM		 7711
7712 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7713 tep->Millicode = (tmp1 >> 30) & 0x1;
7714 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7715 tep->Region_description = (tmp1 >> 27) & 0x3;
7716 tep->reserved1 = (tmp1 >> 26) & 0x1;
7717 tep->Entry_SR = (tmp1 >> 25) & 0x1;
7718 tep->Entry_FR = (tmp1 >> 21) & 0xf;
7719 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7720 tep->Args_stored = (tmp1 >> 15) & 0x1;
7721 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7722 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7723 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7724 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7725 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7726 tep->Ada_Region = (tmp1 >> 9) & 0x1;
7727 tep->cxx_info = (tmp1 >> 8) & 0x1;
7728 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7729 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7730 tep->reserved2 = (tmp1 >> 5) & 0x1;
7731 tep->Save_SP = (tmp1 >> 4) & 0x1;
7732 tep->Save_RP = (tmp1 >> 3) & 0x1;
7733 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7734 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7735 tep->Cleanup_defined = tmp1 & 0x1;
7736
7737 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7738 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7739 tep->Large_frame = (tmp2 >> 29) & 0x1;
7740 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7741 tep->reserved4 = (tmp2 >> 27) & 0x1;
7742 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 7743 }
7744 free (table);
7745
7746 /* Third, apply any relocations to the unwind table. */
57346661
AM		 7747 for (relsec = section_headers;
7748 relsec < section_headers + elf_header.e_shnum;
7749 ++relsec)
7750 {
7751 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 7752 || relsec->sh_info >= elf_header.e_shnum
7753 || section_headers + relsec->sh_info != sec)
57346661
AM		 7754 continue;
7755
7756 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7757 & rela, & nrelas))
7758 return 0;
7759
7760 for (rp = rela; rp < rela + nrelas; ++rp)
7761 {
aca88567
NC		 7762 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7763 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 7764
7765 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 7766 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 7767 {
7768 warn (_("Skipping unexpected relocation type %s\n"), relname);
7769 continue;
7770 }
7771
7772 i = rp->r_offset / unw_ent_size;
7773
89fac5e3 7774 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 7775 {
7776 case 0:
7777 aux->table[i].start.section = sym->st_shndx;
1e456d54 7778 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 7779 break;
7780 case 1:
7781 aux->table[i].end.section = sym->st_shndx;
1e456d54 7782 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 7783 break;
7784 default:
7785 break;
7786 }
7787 }
7788
7789 free (rela);
7790 }
7791
1c0751b2 7792 aux->table_len = nentries;
57346661
AM		 7793
7794 return 1;
7795}
7796
1b31d05e 7797static void
2cf0635d 7798hppa_process_unwind (FILE * file)
57346661 7799{
57346661 7800 struct hppa_unw_aux_info aux;
2cf0635d
NC		 7801 Elf_Internal_Shdr * unwsec = NULL;
7802 Elf_Internal_Shdr * strsec;
7803 Elf_Internal_Shdr * sec;
18bd398b 7804 unsigned long i;
57346661 7805
c256ffe7 7806 if (string_table == NULL)
1b31d05e
NC		 7807 return;
7808
7809 memset (& aux, 0, sizeof (aux));
57346661
AM		 7810
7811 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7812 {
c256ffe7 7813 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 7814 && sec->sh_link < elf_header.e_shnum)
57346661 7815 {
ba5cdace 7816 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 7817
4fbb74a6 7818 strsec = section_headers + sec->sh_link;
4082ef84
NC		 7819 if (aux.strtab != NULL)
7820 {
7821 error (_("Multiple auxillary string tables encountered\n"));
7822 free (aux.strtab);
7823 }
3f5e193b
NC		 7824 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7825 1, strsec->sh_size,
7826 _("string table"));
c256ffe7 7827 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 7828 }
18bd398b 7829 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 7830 unwsec = sec;
7831 }
7832
7833 if (!unwsec)
7834 printf (_("\nThere are no unwind sections in this file.\n"));
7835
7836 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7837 {
18bd398b 7838 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 7839 {
74e1a04b
NC		 7840 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7841 printable_section_name (sec),
57346661 7842 (unsigned long) sec->sh_offset,
89fac5e3 7843 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 7844
7845 slurp_hppa_unwind_table (file, &aux, sec);
7846 if (aux.table_len > 0)
7847 dump_hppa_unwind (&aux);
7848
7849 if (aux.table)
7850 free ((char *) aux.table);
7851 aux.table = NULL;
7852 }
7853 }
7854
7855 if (aux.symtab)
7856 free (aux.symtab);
7857 if (aux.strtab)
7858 free ((char *) aux.strtab);
57346661
AM		 7859}
7860
0b6ae522
DJ		 7861struct arm_section
7862{
a734115a
NC		 7863 unsigned char * data; /* The unwind data. */
7864 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
7865 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
7866 unsigned long nrelas; /* The number of relocations. */
7867 unsigned int rel_type; /* REL or RELA ? */
7868 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 7869};
7870
7871struct arm_unw_aux_info
7872{
a734115a
NC		 7873 FILE * file; /* The file containing the unwind sections. */
7874 Elf_Internal_Sym * symtab; /* The file's symbol table. */
7875 unsigned long nsyms; /* Number of symbols. */
948f632f
DA		 7876 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7877 unsigned long nfuns; /* Number of these symbols. */
a734115a
NC		 7878 char * strtab; /* The file's string table. */
7879 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 7880};
7881
7882static const char *
7883arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7884 bfd_vma fn, struct absaddr addr)
7885{
7886 const char *procname;
7887 bfd_vma sym_offset;
7888
7889 if (addr.section == SHN_UNDEF)
7890 addr.offset = fn;
7891
948f632f 7892 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
0b6ae522
DJ		 7893 aux->strtab_size, addr, &procname,
7894 &sym_offset);
7895
7896 print_vma (fn, PREFIX_HEX);
7897
7898 if (procname)
7899 {
7900 fputs (" <", stdout);
7901 fputs (procname, stdout);
7902
7903 if (sym_offset)
7904 printf ("+0x%lx", (unsigned long) sym_offset);
7905 fputc ('>', stdout);
7906 }
7907
7908 return procname;
7909}
7910
7911static void
7912arm_free_section (struct arm_section *arm_sec)
7913{
7914 if (arm_sec->data != NULL)
7915 free (arm_sec->data);
7916
7917 if (arm_sec->rela != NULL)
7918 free (arm_sec->rela);
7919}
7920
a734115a
NC		 7921/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7922 cached section and install SEC instead.
7923 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7924 and return its valued in * WORDP, relocating if necessary.
1b31d05e 7925 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 7926 relocation's offset in ADDR.
1b31d05e
NC		 7927 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7928 into the string table of the symbol associated with the reloc. If no
7929 reloc was applied store -1 there.
7930 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 7931
7932static bfd_boolean
1b31d05e
NC		 7933get_unwind_section_word (struct arm_unw_aux_info * aux,
7934 struct arm_section * arm_sec,
7935 Elf_Internal_Shdr * sec,
7936 bfd_vma word_offset,
7937 unsigned int * wordp,
7938 struct absaddr * addr,
7939 bfd_vma * sym_name)
0b6ae522
DJ		 7940{
7941 Elf_Internal_Rela *rp;
7942 Elf_Internal_Sym *sym;
7943 const char * relname;
7944 unsigned int word;
7945 bfd_boolean wrapped;
7946
e0a31db1
NC		 7947 if (sec == NULL || arm_sec == NULL)
7948 return FALSE;
7949
0b6ae522
DJ		 7950 addr->section = SHN_UNDEF;
7951 addr->offset = 0;
7952
1b31d05e
NC		 7953 if (sym_name != NULL)
7954 *sym_name = (bfd_vma) -1;
7955
a734115a 7956 /* If necessary, update the section cache. */
0b6ae522
DJ		 7957 if (sec != arm_sec->sec)
7958 {
7959 Elf_Internal_Shdr *relsec;
7960
7961 arm_free_section (arm_sec);
7962
7963 arm_sec->sec = sec;
7964 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7965 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 7966 arm_sec->rela = NULL;
7967 arm_sec->nrelas = 0;
7968
7969 for (relsec = section_headers;
7970 relsec < section_headers + elf_header.e_shnum;
7971 ++relsec)
7972 {
7973 if (relsec->sh_info >= elf_header.e_shnum
1ae40aa4
NC		 7974 || section_headers + relsec->sh_info != sec
7975 /* PR 15745: Check the section type as well. */
7976 || (relsec->sh_type != SHT_REL
7977 && relsec->sh_type != SHT_RELA))
0b6ae522
DJ		 7978 continue;
7979
a734115a 7980 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 7981 if (relsec->sh_type == SHT_REL)
7982 {
7983 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7984 relsec->sh_size,
7985 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7986 return FALSE;
0b6ae522 7987 }
1ae40aa4 7988 else /* relsec->sh_type == SHT_RELA */
0b6ae522
DJ		 7989 {
7990 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7991 relsec->sh_size,
7992 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7993 return FALSE;
0b6ae522 7994 }
1ae40aa4 7995 break;
0b6ae522
DJ		 7996 }
7997
7998 arm_sec->next_rela = arm_sec->rela;
7999 }
8000
a734115a 8001 /* If there is no unwind data we can do nothing. */
0b6ae522 8002 if (arm_sec->data == NULL)
a734115a 8003 return FALSE;
0b6ae522 8004
e0a31db1 8005 /* If the offset is invalid then fail. */
1a915552
NC		 8006 if (word_offset > (sec->sh_size - 4)
8007 /* PR 18879 */
8008 || (sec->sh_size < 5 && word_offset >= sec->sh_size)
8009 || ((bfd_signed_vma) word_offset) < 0)
e0a31db1
NC		 8010 return FALSE;
8011
a734115a 8012 /* Get the word at the required offset. */
0b6ae522
DJ		 8013 word = byte_get (arm_sec->data + word_offset, 4);
8014
0eff7165
NC		 8015 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8016 if (arm_sec->rela == NULL)
8017 {
8018 * wordp = word;
8019 return TRUE;
8020 }
8021
a734115a 8022 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 8023 wrapped = FALSE;
8024 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8025 {
8026 bfd_vma prelval, offset;
8027
8028 if (rp->r_offset > word_offset && !wrapped)
8029 {
8030 rp = arm_sec->rela;
8031 wrapped = TRUE;
8032 }
8033 if (rp->r_offset > word_offset)
8034 break;
8035
8036 if (rp->r_offset & 3)
8037 {
8038 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8039 (unsigned long) rp->r_offset);
8040 continue;
8041 }
8042
8043 if (rp->r_offset < word_offset)
8044 continue;
8045
74e1a04b
NC		 8046 /* PR 17531: file: 027-161405-0.004 */
8047 if (aux->symtab == NULL)
8048 continue;
8049
0b6ae522
DJ		 8050 if (arm_sec->rel_type == SHT_REL)
8051 {
8052 offset = word & 0x7fffffff;
8053 if (offset & 0x40000000)
8054 offset |= ~ (bfd_vma) 0x7fffffff;
8055 }
a734115a 8056 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 8057 offset = rp->r_addend;
a734115a 8058 else
74e1a04b
NC		 8059 {
8060 error (_("Unknown section relocation type %d encountered\n"),
8061 arm_sec->rel_type);
8062 break;
8063 }
0b6ae522 8064
071436c6
NC		 8065 /* PR 17531 file: 027-1241568-0.004. */
8066 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8067 {
8068 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8069 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8070 break;
8071 }
8072
8073 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
0b6ae522
DJ		 8074 offset += sym->st_value;
8075 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8076
a734115a
NC		 8077 /* Check that we are processing the expected reloc type. */
8078 if (elf_header.e_machine == EM_ARM)
8079 {
8080 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 8081 if (relname == NULL)
8082 {
8083 warn (_("Skipping unknown ARM relocation type: %d\n"),
8084 (int) ELF32_R_TYPE (rp->r_info));
8085 continue;
8086 }
a734115a
NC		 8087
8088 if (streq (relname, "R_ARM_NONE"))
8089 continue;
0b4362b0 8090
a734115a
NC		 8091 if (! streq (relname, "R_ARM_PREL31"))
8092 {
071436c6 8093 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
a734115a
NC		 8094 continue;
8095 }
8096 }
8097 else if (elf_header.e_machine == EM_TI_C6000)
8098 {
8099 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 8100 if (relname == NULL)
8101 {
8102 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8103 (int) ELF32_R_TYPE (rp->r_info));
8104 continue;
8105 }
0b4362b0 8106
a734115a
NC		 8107 if (streq (relname, "R_C6000_NONE"))
8108 continue;
8109
8110 if (! streq (relname, "R_C6000_PREL31"))
8111 {
071436c6 8112 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
a734115a
NC		 8113 continue;
8114 }
8115
8116 prelval >>= 1;
8117 }
8118 else
74e1a04b
NC		 8119 {
8120 /* This function currently only supports ARM and TI unwinders. */
8121 warn (_("Only TI and ARM unwinders are currently supported\n"));
8122 break;
8123 }
fa197c1c 8124
0b6ae522
DJ		 8125 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8126 addr->section = sym->st_shndx;
8127 addr->offset = offset;
74e1a04b 8128
1b31d05e
NC		 8129 if (sym_name)
8130 * sym_name = sym->st_name;
0b6ae522
DJ		 8131 break;
8132 }
8133
8134 *wordp = word;
8135 arm_sec->next_rela = rp;
8136
a734115a 8137 return TRUE;
0b6ae522
DJ		 8138}
8139
a734115a
NC		 8140static const char *tic6x_unwind_regnames[16] =
8141{
0b4362b0
RM		 8142 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8143 "A14", "A13", "A12", "A11", "A10",
a734115a
NC		 8144 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8145};
fa197c1c 8146
0b6ae522 8147static void
fa197c1c 8148decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 8149{
fa197c1c
PB		 8150 int i;
8151
8152 for (i = 12; mask; mask >>= 1, i--)
8153 {
8154 if (mask & 1)
8155 {
8156 fputs (tic6x_unwind_regnames[i], stdout);
8157 if (mask > 1)
8158 fputs (", ", stdout);
8159 }
8160 }
8161}
0b6ae522
DJ		 8162
8163#define ADVANCE \
8164 if (remaining == 0 && more_words) \
8165 { \
8166 data_offset += 4; \
1b31d05e
NC		 8167 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
8168 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 8169 return; \
8170 remaining = 4; \
8171 more_words--; \
8172 } \
8173
8174#define GET_OP(OP) \
8175 ADVANCE; \
8176 if (remaining) \
8177 { \
8178 remaining--; \
8179 (OP) = word >> 24; \
8180 word <<= 8; \
8181 } \
8182 else \
8183 { \
2b692964 8184 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 8185 return; \
8186 } \
cc5914eb 8187 printf ("0x%02x ", OP)
0b6ae522 8188
fa197c1c 8189static void
948f632f
DA		 8190decode_arm_unwind_bytecode (struct arm_unw_aux_info * aux,
8191 unsigned int word,
8192 unsigned int remaining,
8193 unsigned int more_words,
8194 bfd_vma data_offset,
8195 Elf_Internal_Shdr * data_sec,
8196 struct arm_section * data_arm_sec)
fa197c1c
PB		 8197{
8198 struct absaddr addr;
0b6ae522
DJ		 8199
8200 /* Decode the unwinding instructions. */
8201 while (1)
8202 {
8203 unsigned int op, op2;
8204
8205 ADVANCE;
8206 if (remaining == 0)
8207 break;
8208 remaining--;
8209 op = word >> 24;
8210 word <<= 8;
8211
cc5914eb 8212 printf (" 0x%02x ", op);
0b6ae522
DJ		 8213
8214 if ((op & 0xc0) == 0x00)
8215 {
8216 int offset = ((op & 0x3f) << 2) + 4;
61865e30 8217
cc5914eb 8218 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 8219 }
8220 else if ((op & 0xc0) == 0x40)
8221 {
8222 int offset = ((op & 0x3f) << 2) + 4;
61865e30 8223
cc5914eb 8224 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 8225 }
8226 else if ((op & 0xf0) == 0x80)
8227 {
8228 GET_OP (op2);
8229 if (op == 0x80 && op2 == 0)
8230 printf (_("Refuse to unwind"));
8231 else
8232 {
8233 unsigned int mask = ((op & 0x0f) << 8) | op2;
8234 int first = 1;
8235 int i;
2b692964 8236
0b6ae522
DJ		 8237 printf ("pop {");
8238 for (i = 0; i < 12; i++)
8239 if (mask & (1 << i))
8240 {
8241 if (first)
8242 first = 0;
8243 else
8244 printf (", ");
8245 printf ("r%d", 4 + i);
8246 }
8247 printf ("}");
8248 }
8249 }
8250 else if ((op & 0xf0) == 0x90)
8251 {
8252 if (op == 0x9d || op == 0x9f)
8253 printf (_(" [Reserved]"));
8254 else
cc5914eb 8255 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 8256 }
8257 else if ((op & 0xf0) == 0xa0)
8258 {
8259 int end = 4 + (op & 0x07);
8260 int first = 1;
8261 int i;
61865e30 8262
0b6ae522
DJ		 8263 printf (" pop {");
8264 for (i = 4; i <= end; i++)
8265 {
8266 if (first)
8267 first = 0;
8268 else
8269 printf (", ");
8270 printf ("r%d", i);
8271 }
8272 if (op & 0x08)
8273 {
1b31d05e 8274 if (!first)
0b6ae522
DJ		 8275 printf (", ");
8276 printf ("r14");
8277 }
8278 printf ("}");
8279 }
8280 else if (op == 0xb0)
8281 printf (_(" finish"));
8282 else if (op == 0xb1)
8283 {
8284 GET_OP (op2);
8285 if (op2 == 0 || (op2 & 0xf0) != 0)
8286 printf (_("[Spare]"));
8287 else
8288 {
8289 unsigned int mask = op2 & 0x0f;
8290 int first = 1;
8291 int i;
61865e30 8292
0b6ae522
DJ		 8293 printf ("pop {");
8294 for (i = 0; i < 12; i++)
8295 if (mask & (1 << i))
8296 {
8297 if (first)
8298 first = 0;
8299 else
8300 printf (", ");
8301 printf ("r%d", i);
8302 }
8303 printf ("}");
8304 }
8305 }
8306 else if (op == 0xb2)
8307 {
b115cf96 8308 unsigned char buf[9];
0b6ae522
DJ		 8309 unsigned int i, len;
8310 unsigned long offset;
61865e30 8311
b115cf96 8312 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 8313 {
8314 GET_OP (buf[i]);
8315 if ((buf[i] & 0x80) == 0)
8316 break;
8317 }
4082ef84
NC		 8318 if (i == sizeof (buf))
8319 printf (_("corrupt change to vsp"));
8320 else
8321 {
8322 offset = read_uleb128 (buf, &len, buf + i + 1);
8323 assert (len == i + 1);
8324 offset = offset * 4 + 0x204;
8325 printf ("vsp = vsp + %ld", offset);
8326 }
0b6ae522 8327 }
61865e30 8328 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 8329 {
61865e30
NC		 8330 unsigned int first, last;
8331
8332 GET_OP (op2);
8333 first = op2 >> 4;
8334 last = op2 & 0x0f;
8335 if (op == 0xc8)
8336 first = first + 16;
8337 printf ("pop {D%d", first);
8338 if (last)
8339 printf ("-D%d", first + last);
8340 printf ("}");
8341 }
8342 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8343 {
8344 unsigned int count = op & 0x07;
8345
8346 printf ("pop {D8");
8347 if (count)
8348 printf ("-D%d", 8 + count);
8349 printf ("}");
8350 }
8351 else if (op >= 0xc0 && op <= 0xc5)
8352 {
8353 unsigned int count = op & 0x07;
8354
8355 printf (" pop {wR10");
8356 if (count)
8357 printf ("-wR%d", 10 + count);
8358 printf ("}");
8359 }
8360 else if (op == 0xc6)
8361 {
8362 unsigned int first, last;
8363
8364 GET_OP (op2);
8365 first = op2 >> 4;
8366 last = op2 & 0x0f;
8367 printf ("pop {wR%d", first);
8368 if (last)
8369 printf ("-wR%d", first + last);
8370 printf ("}");
8371 }
8372 else if (op == 0xc7)
8373 {
8374 GET_OP (op2);
8375 if (op2 == 0 || (op2 & 0xf0) != 0)
8376 printf (_("[Spare]"));
0b6ae522
DJ		 8377 else
8378 {
61865e30
NC		 8379 unsigned int mask = op2 & 0x0f;
8380 int first = 1;
8381 int i;
8382
8383 printf ("pop {");
8384 for (i = 0; i < 4; i++)
8385 if (mask & (1 << i))
8386 {
8387 if (first)
8388 first = 0;
8389 else
8390 printf (", ");
8391 printf ("wCGR%d", i);
8392 }
8393 printf ("}");
0b6ae522
DJ		 8394 }
8395 }
61865e30
NC		 8396 else
8397 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 8398 printf ("\n");
8399 }
fa197c1c
PB		 8400}
8401
8402static void
948f632f
DA		 8403decode_tic6x_unwind_bytecode (struct arm_unw_aux_info * aux,
8404 unsigned int word,
8405 unsigned int remaining,
8406 unsigned int more_words,
8407 bfd_vma data_offset,
8408 Elf_Internal_Shdr * data_sec,
8409 struct arm_section * data_arm_sec)
fa197c1c
PB		 8410{
8411 struct absaddr addr;
8412
8413 /* Decode the unwinding instructions. */
8414 while (1)
8415 {
8416 unsigned int op, op2;
8417
8418 ADVANCE;
8419 if (remaining == 0)
8420 break;
8421 remaining--;
8422 op = word >> 24;
8423 word <<= 8;
8424
9cf03b7e 8425 printf (" 0x%02x ", op);
fa197c1c
PB		 8426
8427 if ((op & 0xc0) == 0x00)
8428 {
8429 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 8430 printf (" sp = sp + %d", offset);
fa197c1c
PB		 8431 }
8432 else if ((op & 0xc0) == 0x80)
8433 {
8434 GET_OP (op2);
8435 if (op == 0x80 && op2 == 0)
8436 printf (_("Refuse to unwind"));
8437 else
8438 {
8439 unsigned int mask = ((op & 0x1f) << 8) | op2;
8440 if (op & 0x20)
8441 printf ("pop compact {");
8442 else
8443 printf ("pop {");
8444
8445 decode_tic6x_unwind_regmask (mask);
8446 printf("}");
8447 }
8448 }
8449 else if ((op & 0xf0) == 0xc0)
8450 {
8451 unsigned int reg;
8452 unsigned int nregs;
8453 unsigned int i;
8454 const char *name;
a734115a
NC		 8455 struct
8456 {
fa197c1c
PB		 8457 unsigned int offset;
8458 unsigned int reg;
8459 } regpos[16];
8460
8461 /* Scan entire instruction first so that GET_OP output is not
8462 interleaved with disassembly. */
8463 nregs = 0;
8464 for (i = 0; nregs < (op & 0xf); i++)
8465 {
8466 GET_OP (op2);
8467 reg = op2 >> 4;
8468 if (reg != 0xf)
8469 {
8470 regpos[nregs].offset = i * 2;
8471 regpos[nregs].reg = reg;
8472 nregs++;
8473 }
8474
8475 reg = op2 & 0xf;
8476 if (reg != 0xf)
8477 {
8478 regpos[nregs].offset = i * 2 + 1;
8479 regpos[nregs].reg = reg;
8480 nregs++;
8481 }
8482 }
8483
8484 printf (_("pop frame {"));
8485 reg = nregs - 1;
8486 for (i = i * 2; i > 0; i--)
8487 {
8488 if (regpos[reg].offset == i - 1)
8489 {
8490 name = tic6x_unwind_regnames[regpos[reg].reg];
8491 if (reg > 0)
8492 reg--;
8493 }
8494 else
8495 name = _("[pad]");
8496
8497 fputs (name, stdout);
8498 if (i > 1)
8499 printf (", ");
8500 }
8501
8502 printf ("}");
8503 }
8504 else if (op == 0xd0)
8505 printf (" MOV FP, SP");
8506 else if (op == 0xd1)
8507 printf (" __c6xabi_pop_rts");
8508 else if (op == 0xd2)
8509 {
8510 unsigned char buf[9];
8511 unsigned int i, len;
8512 unsigned long offset;
a734115a 8513
fa197c1c
PB		 8514 for (i = 0; i < sizeof (buf); i++)
8515 {
8516 GET_OP (buf[i]);
8517 if ((buf[i] & 0x80) == 0)
8518 break;
8519 }
0eff7165
NC		 8520 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8521 if (i == sizeof (buf))
8522 {
8523 printf ("<corrupt sp adjust>\n");
8524 warn (_("Corrupt stack pointer adjustment detected\n"));
8525 return;
8526 }
948f632f 8527
f6f0e17b 8528 offset = read_uleb128 (buf, &len, buf + i + 1);
fa197c1c
PB		 8529 assert (len == i + 1);
8530 offset = offset * 8 + 0x408;
8531 printf (_("sp = sp + %ld"), offset);
8532 }
8533 else if ((op & 0xf0) == 0xe0)
8534 {
8535 if ((op & 0x0f) == 7)
8536 printf (" RETURN");
8537 else
8538 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8539 }
8540 else
8541 {
8542 printf (_(" [unsupported opcode]"));
8543 }
8544 putchar ('\n');
8545 }
8546}
8547
8548static bfd_vma
a734115a 8549arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 8550{
8551 bfd_vma offset;
8552
8553 offset = word & 0x7fffffff;
8554 if (offset & 0x40000000)
8555 offset |= ~ (bfd_vma) 0x7fffffff;
8556
8557 if (elf_header.e_machine == EM_TI_C6000)
8558 offset <<= 1;
8559
8560 return offset + where;
8561}
8562
8563static void
1b31d05e
NC		 8564decode_arm_unwind (struct arm_unw_aux_info * aux,
8565 unsigned int word,
8566 unsigned int remaining,
8567 bfd_vma data_offset,
8568 Elf_Internal_Shdr * data_sec,
8569 struct arm_section * data_arm_sec)
fa197c1c
PB		 8570{
8571 int per_index;
8572 unsigned int more_words = 0;
37e14bc3 8573 struct absaddr addr;
1b31d05e 8574 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 8575
8576 if (remaining == 0)
8577 {
1b31d05e
NC		 8578 /* Fetch the first word.
8579 Note - when decoding an object file the address extracted
8580 here will always be 0. So we also pass in the sym_name
8581 parameter so that we can find the symbol associated with
8582 the personality routine. */
8583 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8584 & word, & addr, & sym_name))
fa197c1c 8585 return;
1b31d05e 8586
fa197c1c
PB		 8587 remaining = 4;
8588 }
8589
8590 if ((word & 0x80000000) == 0)
8591 {
8592 /* Expand prel31 for personality routine. */
8593 bfd_vma fn;
8594 const char *procname;
8595
a734115a 8596 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 8597 printf (_(" Personality routine: "));
1b31d05e
NC		 8598 if (fn == 0
8599 && addr.section == SHN_UNDEF && addr.offset == 0
8600 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8601 {
8602 procname = aux->strtab + sym_name;
8603 print_vma (fn, PREFIX_HEX);
8604 if (procname)
8605 {
8606 fputs (" <", stdout);
8607 fputs (procname, stdout);
8608 fputc ('>', stdout);
8609 }
8610 }
8611 else
8612 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 8613 fputc ('\n', stdout);
8614
8615 /* The GCC personality routines use the standard compact
8616 encoding, starting with one byte giving the number of
8617 words. */
8618 if (procname != NULL
8619 && (const_strneq (procname, "__gcc_personality_v0")
8620 || const_strneq (procname, "__gxx_personality_v0")
8621 || const_strneq (procname, "__gcj_personality_v0")
8622 || const_strneq (procname, "__gnu_objc_personality_v0")))
8623 {
8624 remaining = 0;
8625 more_words = 1;
8626 ADVANCE;
8627 if (!remaining)
8628 {
8629 printf (_(" [Truncated data]\n"));
8630 return;
8631 }
8632 more_words = word >> 24;
8633 word <<= 8;
8634 remaining--;
8635 per_index = -1;
8636 }
8637 else
8638 return;
8639 }
8640 else
8641 {
1b31d05e 8642 /* ARM EHABI Section 6.3:
0b4362b0 8643
1b31d05e 8644 An exception-handling table entry for the compact model looks like:
0b4362b0 8645
1b31d05e
NC		 8646 31 30-28 27-24 23-0
8647 -- ----- ----- ----
8648 1 0 index Data for personalityRoutine[index] */
8649
8650 if (elf_header.e_machine == EM_ARM
8651 && (word & 0x70000000))
83c257ca 8652 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 8653
fa197c1c 8654 per_index = (word >> 24) & 0x7f;
1b31d05e 8655 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 8656 if (per_index == 0)
8657 {
8658 more_words = 0;
8659 word <<= 8;
8660 remaining--;
8661 }
8662 else if (per_index < 3)
8663 {
8664 more_words = (word >> 16) & 0xff;
8665 word <<= 16;
8666 remaining -= 2;
8667 }
8668 }
8669
8670 switch (elf_header.e_machine)
8671 {
8672 case EM_ARM:
8673 if (per_index < 3)
8674 {
8675 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8676 data_offset, data_sec, data_arm_sec);
8677 }
8678 else
1b31d05e
NC		 8679 {
8680 warn (_("Unknown ARM compact model index encountered\n"));
8681 printf (_(" [reserved]\n"));
8682 }
fa197c1c
PB		 8683 break;
8684
8685 case EM_TI_C6000:
8686 if (per_index < 3)
8687 {
8688 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 8689 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 8690 }
8691 else if (per_index < 5)
8692 {
8693 if (((word >> 17) & 0x7f) == 0x7f)
8694 printf (_(" Restore stack from frame pointer\n"));
8695 else
8696 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
8697 printf (_(" Registers restored: "));
8698 if (per_index == 4)
8699 printf (" (compact) ");
8700 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8701 putchar ('\n');
8702 printf (_(" Return register: %s\n"),
8703 tic6x_unwind_regnames[word & 0xf]);
8704 }
8705 else
1b31d05e 8706 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 8707 break;
8708
8709 default:
74e1a04b 8710 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
1b31d05e 8711 elf_header.e_machine);
fa197c1c 8712 }
0b6ae522
DJ		 8713
8714 /* Decode the descriptors. Not implemented. */
8715}
8716
8717static void
8718dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8719{
8720 struct arm_section exidx_arm_sec, extab_arm_sec;
8721 unsigned int i, exidx_len;
948f632f 8722 unsigned long j, nfuns;
0b6ae522
DJ		 8723
8724 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8725 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8726 exidx_len = exidx_sec->sh_size / 8;
8727
948f632f
DA		 8728 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8729 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8730 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8731 aux->funtab[nfuns++] = aux->symtab[j];
8732 aux->nfuns = nfuns;
8733 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8734
0b6ae522
DJ		 8735 for (i = 0; i < exidx_len; i++)
8736 {
8737 unsigned int exidx_fn, exidx_entry;
8738 struct absaddr fn_addr, entry_addr;
8739 bfd_vma fn;
8740
8741 fputc ('\n', stdout);
8742
1b31d05e
NC		 8743 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8744 8 * i, & exidx_fn, & fn_addr, NULL)
8745 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8746 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 8747 {
948f632f 8748 free (aux->funtab);
1b31d05e
NC		 8749 arm_free_section (& exidx_arm_sec);
8750 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 8751 return;
8752 }
8753
83c257ca
NC		 8754 /* ARM EHABI, Section 5:
8755 An index table entry consists of 2 words.
8756 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8757 if (exidx_fn & 0x80000000)
8758 warn (_("corrupt index table entry: %x\n"), exidx_fn);
8759
a734115a 8760 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 8761
a734115a 8762 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 8763 fputs (": ", stdout);
8764
8765 if (exidx_entry == 1)
8766 {
8767 print_vma (exidx_entry, PREFIX_HEX);
8768 fputs (" [cantunwind]\n", stdout);
8769 }
8770 else if (exidx_entry & 0x80000000)
8771 {
8772 print_vma (exidx_entry, PREFIX_HEX);
8773 fputc ('\n', stdout);
8774 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8775 }
8776 else
8777 {
8f73510c 8778 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 8779 Elf_Internal_Shdr *table_sec;
8780
8781 fputs ("@", stdout);
a734115a 8782 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 8783 print_vma (table, PREFIX_HEX);
8784 printf ("\n");
8785
8786 /* Locate the matching .ARM.extab. */
8787 if (entry_addr.section != SHN_UNDEF
8788 && entry_addr.section < elf_header.e_shnum)
8789 {
8790 table_sec = section_headers + entry_addr.section;
8791 table_offset = entry_addr.offset;
1a915552
NC		 8792 /* PR 18879 */
8793 if (table_offset > table_sec->sh_size
8794 || ((bfd_signed_vma) table_offset) < 0)
8795 {
8796 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8797 (unsigned long) table_offset,
8798 printable_section_name (table_sec));
8799 continue;
8800 }
0b6ae522
DJ		 8801 }
8802 else
8803 {
8804 table_sec = find_section_by_address (table);
8805 if (table_sec != NULL)
8806 table_offset = table - table_sec->sh_addr;
8807 }
8808 if (table_sec == NULL)
8809 {
8810 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8811 (unsigned long) table);
8812 continue;
8813 }
8814 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8815 &extab_arm_sec);
8816 }
8817 }
8818
8819 printf ("\n");
8820
948f632f 8821 free (aux->funtab);
0b6ae522
DJ		 8822 arm_free_section (&exidx_arm_sec);
8823 arm_free_section (&extab_arm_sec);
8824}
8825
fa197c1c 8826/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 8827
8828static void
0b6ae522
DJ		 8829arm_process_unwind (FILE *file)
8830{
8831 struct arm_unw_aux_info aux;
8832 Elf_Internal_Shdr *unwsec = NULL;
8833 Elf_Internal_Shdr *strsec;
8834 Elf_Internal_Shdr *sec;
8835 unsigned long i;
fa197c1c 8836 unsigned int sec_type;
0b6ae522 8837
fa197c1c
PB		 8838 switch (elf_header.e_machine)
8839 {
8840 case EM_ARM:
8841 sec_type = SHT_ARM_EXIDX;
8842 break;
8843
8844 case EM_TI_C6000:
8845 sec_type = SHT_C6000_UNWIND;
8846 break;
8847
0b4362b0 8848 default:
74e1a04b 8849 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
1b31d05e
NC		 8850 elf_header.e_machine);
8851 return;
fa197c1c
PB		 8852 }
8853
0b6ae522 8854 if (string_table == NULL)
1b31d05e
NC		 8855 return;
8856
8857 memset (& aux, 0, sizeof (aux));
8858 aux.file = file;
0b6ae522
DJ		 8859
8860 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8861 {
8862 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8863 {
ba5cdace 8864 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 8865
8866 strsec = section_headers + sec->sh_link;
74e1a04b
NC		 8867
8868 /* PR binutils/17531 file: 011-12666-0.004. */
8869 if (aux.strtab != NULL)
8870 {
4082ef84 8871 error (_("Multiple string tables found in file.\n"));
74e1a04b
NC		 8872 free (aux.strtab);
8873 }
0b6ae522
DJ		 8874 aux.strtab = get_data (NULL, file, strsec->sh_offset,
8875 1, strsec->sh_size, _("string table"));
8876 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8877 }
fa197c1c 8878 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 8879 unwsec = sec;
8880 }
8881
1b31d05e 8882 if (unwsec == NULL)
0b6ae522 8883 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 8884 else
8885 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8886 {
8887 if (sec->sh_type == sec_type)
8888 {
8889 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
74e1a04b 8890 printable_section_name (sec),
1b31d05e
NC		 8891 (unsigned long) sec->sh_offset,
8892 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 8893
1b31d05e
NC		 8894 dump_arm_unwind (&aux, sec);
8895 }
8896 }
0b6ae522
DJ		 8897
8898 if (aux.symtab)
8899 free (aux.symtab);
8900 if (aux.strtab)
8901 free ((char *) aux.strtab);
0b6ae522
DJ		 8902}
8903
1b31d05e 8904static void
2cf0635d 8905process_unwind (FILE * file)
57346661 8906{
2cf0635d
NC		 8907 struct unwind_handler
8908 {
57346661 8909 int machtype;
1b31d05e 8910 void (* handler)(FILE *);
2cf0635d
NC		 8911 } handlers[] =
8912 {
0b6ae522 8913 { EM_ARM, arm_process_unwind },
57346661
AM		 8914 { EM_IA_64, ia64_process_unwind },
8915 { EM_PARISC, hppa_process_unwind },
fa197c1c 8916 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 8917 { 0, 0 }
8918 };
8919 int i;
8920
8921 if (!do_unwind)
1b31d05e 8922 return;
57346661
AM		 8923
8924 for (i = 0; handlers[i].handler != NULL; i++)
8925 if (elf_header.e_machine == handlers[i].machtype)
9f758fdc
NC		 8926 {
8927 handlers[i].handler (file);
8928 return;
8929 }
57346661 8930
1b31d05e
NC		 8931 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8932 get_machine_name (elf_header.e_machine));
57346661
AM		 8933}
8934
252b5132 8935static void
2cf0635d 8936dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 8937{
8938 switch (entry->d_tag)
8939 {
8940 case DT_MIPS_FLAGS:
8941 if (entry->d_un.d_val == 0)
4b68bca3 8942 printf (_("NONE"));
252b5132
RH		 8943 else
8944 {
8945 static const char * opts[] =
8946 {
8947 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8948 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8949 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8950 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8951 "RLD_ORDER_SAFE"
8952 };
8953 unsigned int cnt;
8954 int first = 1;
2b692964 8955
60bca95a 8956 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 8957 if (entry->d_un.d_val & (1 << cnt))
8958 {
8959 printf ("%s%s", first ? "" : " ", opts[cnt]);
8960 first = 0;
8961 }
252b5132
RH		 8962 }
8963 break;
103f02d3 8964
252b5132 8965 case DT_MIPS_IVERSION:
d79b3d50 8966 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 8967 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8968 else
76ca31c0
NC		 8969 {
8970 char buf[40];
8971 sprintf_vma (buf, entry->d_un.d_ptr);
8972 /* Note: coded this way so that there is a single string for translation. */
8973 printf (_("<corrupt: %s>"), buf);
8974 }
252b5132 8975 break;
103f02d3 8976
252b5132
RH		 8977 case DT_MIPS_TIME_STAMP:
8978 {
d5b07ef4 8979 char timebuf[128];
2cf0635d 8980 struct tm * tmp;
91d6fa6a 8981 time_t atime = entry->d_un.d_val;
82b1b41b 8982
91d6fa6a 8983 tmp = gmtime (&atime);
82b1b41b
NC		 8984 /* PR 17531: file: 6accc532. */
8985 if (tmp == NULL)
8986 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8987 else
8988 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8989 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8990 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 8991 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 8992 }
8993 break;
103f02d3 8994
252b5132
RH		 8995 case DT_MIPS_RLD_VERSION:
8996 case DT_MIPS_LOCAL_GOTNO:
8997 case DT_MIPS_CONFLICTNO:
8998 case DT_MIPS_LIBLISTNO:
8999 case DT_MIPS_SYMTABNO:
9000 case DT_MIPS_UNREFEXTNO:
9001 case DT_MIPS_HIPAGENO:
9002 case DT_MIPS_DELTA_CLASS_NO:
9003 case DT_MIPS_DELTA_INSTANCE_NO:
9004 case DT_MIPS_DELTA_RELOC_NO:
9005 case DT_MIPS_DELTA_SYM_NO:
9006 case DT_MIPS_DELTA_CLASSSYM_NO:
9007 case DT_MIPS_COMPACT_SIZE:
c69075ac 9008 print_vma (entry->d_un.d_val, DEC);
252b5132 9009 break;
103f02d3
UD		 9010
9011 default:
4b68bca3 9012 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 9013 }
4b68bca3 9014 putchar ('\n');
103f02d3
UD		 9015}
9016
103f02d3 9017static void
2cf0635d 9018dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 9019{
9020 switch (entry->d_tag)
9021 {
9022 case DT_HP_DLD_FLAGS:
9023 {
9024 static struct
9025 {
9026 long int bit;
2cf0635d 9027 const char * str;
5e220199
NC		 9028 }
9029 flags[] =
9030 {
9031 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9032 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9033 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9034 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9035 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9036 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9037 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9038 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9039 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9040 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 9041 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9042 { DT_HP_GST, "HP_GST" },
9043 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9044 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9045 { DT_HP_NODELETE, "HP_NODELETE" },
9046 { DT_HP_GROUP, "HP_GROUP" },
9047 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 9048 };
103f02d3 9049 int first = 1;
5e220199 9050 size_t cnt;
f7a99963 9051 bfd_vma val = entry->d_un.d_val;
103f02d3 9052
60bca95a 9053 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 9054 if (val & flags[cnt].bit)
30800947
NC		 9055 {
9056 if (! first)
9057 putchar (' ');
9058 fputs (flags[cnt].str, stdout);
9059 first = 0;
9060 val ^= flags[cnt].bit;
9061 }
76da6bbe 9062
103f02d3 9063 if (val != 0 || first)
f7a99963
NC		 9064 {
9065 if (! first)
9066 putchar (' ');
9067 print_vma (val, HEX);
9068 }
103f02d3
UD		 9069 }
9070 break;
76da6bbe 9071
252b5132 9072 default:
f7a99963
NC		 9073 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9074 break;
252b5132 9075 }
35b1837e 9076 putchar ('\n');
252b5132
RH		 9077}
9078
28f997cf
TG		 9079#ifdef BFD64
9080
9081/* VMS vs Unix time offset and factor. */
9082
9083#define VMS_EPOCH_OFFSET 35067168000000000LL
9084#define VMS_GRANULARITY_FACTOR 10000000
9085
9086/* Display a VMS time in a human readable format. */
9087
9088static void
9089print_vms_time (bfd_int64_t vmstime)
9090{
9091 struct tm *tm;
9092 time_t unxtime;
9093
9094 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9095 tm = gmtime (&unxtime);
9096 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9097 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9098 tm->tm_hour, tm->tm_min, tm->tm_sec);
9099}
9100#endif /* BFD64 */
9101
ecc51f48 9102static void
2cf0635d 9103dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 9104{
9105 switch (entry->d_tag)
9106 {
0de14b54 9107 case DT_IA_64_PLT_RESERVE:
bdf4d63a 9108 /* First 3 slots reserved. */
ecc51f48
NC		 9109 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9110 printf (" -- ");
9111 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 9112 break;
9113
28f997cf
TG		 9114 case DT_IA_64_VMS_LINKTIME:
9115#ifdef BFD64
9116 print_vms_time (entry->d_un.d_val);
9117#endif
9118 break;
9119
9120 case DT_IA_64_VMS_LNKFLAGS:
9121 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9122 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9123 printf (" CALL_DEBUG");
9124 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9125 printf (" NOP0BUFS");
9126 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9127 printf (" P0IMAGE");
9128 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9129 printf (" MKTHREADS");
9130 if (entry->d_un.d_val & VMS_LF_UPCALLS)
9131 printf (" UPCALLS");
9132 if (entry->d_un.d_val & VMS_LF_IMGSTA)
9133 printf (" IMGSTA");
9134 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9135 printf (" INITIALIZE");
9136 if (entry->d_un.d_val & VMS_LF_MAIN)
9137 printf (" MAIN");
9138 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9139 printf (" EXE_INIT");
9140 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9141 printf (" TBK_IN_IMG");
9142 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9143 printf (" DBG_IN_IMG");
9144 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9145 printf (" TBK_IN_DSF");
9146 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9147 printf (" DBG_IN_DSF");
9148 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9149 printf (" SIGNATURES");
9150 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9151 printf (" REL_SEG_OFF");
9152 break;
9153
bdf4d63a
JJ		 9154 default:
9155 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9156 break;
ecc51f48 9157 }
bdf4d63a 9158 putchar ('\n');
ecc51f48
NC		 9159}
9160
252b5132 9161static int
2cf0635d 9162get_32bit_dynamic_section (FILE * file)
252b5132 9163{
2cf0635d
NC		 9164 Elf32_External_Dyn * edyn;
9165 Elf32_External_Dyn * ext;
9166 Elf_Internal_Dyn * entry;
103f02d3 9167
3f5e193b
NC		 9168 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
9169 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 9170 if (!edyn)
9171 return 0;
103f02d3 9172
071436c6
NC		 9173 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9174 might not have the luxury of section headers. Look for the DT_NULL
9175 terminator to determine the number of entries. */
ba2685cc 9176 for (ext = edyn, dynamic_nent = 0;
53c3012c 9177 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
ba2685cc
AM		 9178 ext++)
9179 {
9180 dynamic_nent++;
9181 if (BYTE_GET (ext->d_tag) == DT_NULL)
9182 break;
9183 }
252b5132 9184
3f5e193b
NC		 9185 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9186 sizeof (* entry));
b2d38a17 9187 if (dynamic_section == NULL)
252b5132 9188 {
8b73c356
NC		 9189 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9190 (unsigned long) dynamic_nent);
9ea033b2
NC		 9191 free (edyn);
9192 return 0;
9193 }
252b5132 9194
fb514b26 9195 for (ext = edyn, entry = dynamic_section;
ba2685cc 9196 entry < dynamic_section + dynamic_nent;
fb514b26 9197 ext++, entry++)
9ea033b2 9198 {
fb514b26
AM		 9199 entry->d_tag = BYTE_GET (ext->d_tag);
9200 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 9201 }
9202
9ea033b2
NC		 9203 free (edyn);
9204
9205 return 1;
9206}
9207
9208static int
2cf0635d 9209get_64bit_dynamic_section (FILE * file)
9ea033b2 9210{
2cf0635d
NC		 9211 Elf64_External_Dyn * edyn;
9212 Elf64_External_Dyn * ext;
9213 Elf_Internal_Dyn * entry;
103f02d3 9214
071436c6 9215 /* Read in the data. */
3f5e193b
NC		 9216 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
9217 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 9218 if (!edyn)
9219 return 0;
103f02d3 9220
071436c6
NC		 9221 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9222 might not have the luxury of section headers. Look for the DT_NULL
9223 terminator to determine the number of entries. */
ba2685cc 9224 for (ext = edyn, dynamic_nent = 0;
53c3012c
AM		 9225 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9226 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
ba2685cc
AM		 9227 ext++)
9228 {
9229 dynamic_nent++;
66543521 9230 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 9231 break;
9232 }
252b5132 9233
3f5e193b
NC		 9234 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9235 sizeof (* entry));
b2d38a17 9236 if (dynamic_section == NULL)
252b5132 9237 {
8b73c356
NC		 9238 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9239 (unsigned long) dynamic_nent);
252b5132
RH		 9240 free (edyn);
9241 return 0;
9242 }
9243
071436c6 9244 /* Convert from external to internal formats. */
fb514b26 9245 for (ext = edyn, entry = dynamic_section;
ba2685cc 9246 entry < dynamic_section + dynamic_nent;
fb514b26 9247 ext++, entry++)
252b5132 9248 {
66543521
AM		 9249 entry->d_tag = BYTE_GET (ext->d_tag);
9250 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 9251 }
9252
9253 free (edyn);
9254
9ea033b2
NC		 9255 return 1;
9256}
9257
e9e44622
JJ		 9258static void
9259print_dynamic_flags (bfd_vma flags)
d1133906 9260{
e9e44622 9261 int first = 1;
13ae64f3 9262
d1133906
NC		 9263 while (flags)
9264 {
9265 bfd_vma flag;
9266
9267 flag = flags & - flags;
9268 flags &= ~ flag;
9269
e9e44622
JJ		 9270 if (first)
9271 first = 0;
9272 else
9273 putc (' ', stdout);
13ae64f3 9274
d1133906
NC		 9275 switch (flag)
9276 {
e9e44622
JJ		 9277 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
9278 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
9279 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
9280 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
9281 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 9282 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 9283 }
9284 }
e9e44622 9285 puts ("");
d1133906
NC		 9286}
9287
b2d38a17
NC		 9288/* Parse and display the contents of the dynamic section. */
9289
9ea033b2 9290static int
2cf0635d 9291process_dynamic_section (FILE * file)
9ea033b2 9292{
2cf0635d 9293 Elf_Internal_Dyn * entry;
9ea033b2
NC		 9294
9295 if (dynamic_size == 0)
9296 {
9297 if (do_dynamic)
b2d38a17 9298 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 9299
9300 return 1;
9301 }
9302
9303 if (is_32bit_elf)
9304 {
b2d38a17 9305 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 9306 return 0;
9307 }
b2d38a17 9308 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 9309 return 0;
9310
252b5132
RH		 9311 /* Find the appropriate symbol table. */
9312 if (dynamic_symbols == NULL)
9313 {
86dba8ee
AM		 9314 for (entry = dynamic_section;
9315 entry < dynamic_section + dynamic_nent;
9316 ++entry)
252b5132 9317 {
c8286bd1 9318 Elf_Internal_Shdr section;
252b5132
RH		 9319
9320 if (entry->d_tag != DT_SYMTAB)
9321 continue;
9322
9323 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9324
9325 /* Since we do not know how big the symbol table is,
9326 we default to reading in the entire file (!) and
9327 processing that. This is overkill, I know, but it
e3c8793a 9328 should work. */
d93f0186 9329 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 9330
fb52b2f4
NC		 9331 if (archive_file_offset != 0)
9332 section.sh_size = archive_file_size - section.sh_offset;
9333 else
9334 {
9335 if (fseek (file, 0, SEEK_END))
591a748a 9336 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 9337
9338 section.sh_size = ftell (file) - section.sh_offset;
9339 }
252b5132 9340
9ea033b2 9341 if (is_32bit_elf)
9ad5cbcf 9342 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 9343 else
9ad5cbcf 9344 section.sh_entsize = sizeof (Elf64_External_Sym);
071436c6 9345 section.sh_name = string_table_length;
252b5132 9346
ba5cdace 9347 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 9348 if (num_dynamic_syms < 1)
252b5132
RH		 9349 {
9350 error (_("Unable to determine the number of symbols to load\n"));
9351 continue;
9352 }
252b5132
RH		 9353 }
9354 }
9355
9356 /* Similarly find a string table. */
9357 if (dynamic_strings == NULL)
9358 {
86dba8ee
AM		 9359 for (entry = dynamic_section;
9360 entry < dynamic_section + dynamic_nent;
9361 ++entry)
252b5132
RH		 9362 {
9363 unsigned long offset;
b34976b6 9364 long str_tab_len;
252b5132
RH		 9365
9366 if (entry->d_tag != DT_STRTAB)
9367 continue;
9368
9369 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9370
9371 /* Since we do not know how big the string table is,
9372 we default to reading in the entire file (!) and
9373 processing that. This is overkill, I know, but it
e3c8793a 9374 should work. */
252b5132 9375
d93f0186 9376 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 9377
9378 if (archive_file_offset != 0)
9379 str_tab_len = archive_file_size - offset;
9380 else
9381 {
9382 if (fseek (file, 0, SEEK_END))
9383 error (_("Unable to seek to end of file\n"));
9384 str_tab_len = ftell (file) - offset;
9385 }
252b5132
RH		 9386
9387 if (str_tab_len < 1)
9388 {
9389 error
9390 (_("Unable to determine the length of the dynamic string table\n"));
9391 continue;
9392 }
9393
3f5e193b
NC		 9394 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
9395 str_tab_len,
9396 _("dynamic string table"));
59245841 9397 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 9398 break;
9399 }
9400 }
9401
9402 /* And find the syminfo section if available. */
9403 if (dynamic_syminfo == NULL)
9404 {
3e8bba36 9405 unsigned long syminsz = 0;
252b5132 9406
86dba8ee
AM		 9407 for (entry = dynamic_section;
9408 entry < dynamic_section + dynamic_nent;
9409 ++entry)
252b5132
RH		 9410 {
9411 if (entry->d_tag == DT_SYMINENT)
9412 {
9413 /* Note: these braces are necessary to avoid a syntax
9414 error from the SunOS4 C compiler. */
049b0c3a
NC		 9415 /* PR binutils/17531: A corrupt file can trigger this test.
9416 So do not use an assert, instead generate an error message. */
9417 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
071436c6 9418 error (_("Bad value (%d) for SYMINENT entry\n"),
049b0c3a 9419 (int) entry->d_un.d_val);
252b5132
RH		 9420 }
9421 else if (entry->d_tag == DT_SYMINSZ)
9422 syminsz = entry->d_un.d_val;
9423 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 9424 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
9425 syminsz);
252b5132
RH		 9426 }
9427
9428 if (dynamic_syminfo_offset != 0 && syminsz != 0)
9429 {
2cf0635d
NC		 9430 Elf_External_Syminfo * extsyminfo;
9431 Elf_External_Syminfo * extsym;
9432 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 9433
9434 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 9435 extsyminfo = (Elf_External_Syminfo *)
9436 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
9437 _("symbol information"));
a6e9f9df
AM		 9438 if (!extsyminfo)
9439 return 0;
252b5132 9440
3f5e193b 9441 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 9442 if (dynamic_syminfo == NULL)
9443 {
8b73c356
NC		 9444 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9445 (unsigned long) syminsz);
252b5132
RH		 9446 return 0;
9447 }
9448
9449 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 9450 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9451 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9452 ++syminfo, ++extsym)
252b5132 9453 {
86dba8ee
AM		 9454 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9455 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 9456 }
9457
9458 free (extsyminfo);
9459 }
9460 }
9461
9462 if (do_dynamic && dynamic_addr)
8b73c356
NC		 9463 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9464 dynamic_addr, (unsigned long) dynamic_nent);
252b5132
RH		 9465 if (do_dynamic)
9466 printf (_(" Tag Type Name/Value\n"));
9467
86dba8ee
AM		 9468 for (entry = dynamic_section;
9469 entry < dynamic_section + dynamic_nent;
9470 entry++)
252b5132
RH		 9471 {
9472 if (do_dynamic)
f7a99963 9473 {
2cf0635d 9474 const char * dtype;
e699b9ff 9475
f7a99963
NC		 9476 putchar (' ');
9477 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 9478 dtype = get_dynamic_type (entry->d_tag);
9479 printf (" (%s)%*s", dtype,
9480 ((is_32bit_elf ? 27 : 19)
9481 - (int) strlen (dtype)),
f7a99963
NC		 9482 " ");
9483 }
252b5132
RH		 9484
9485 switch (entry->d_tag)
9486 {
d1133906
NC		 9487 case DT_FLAGS:
9488 if (do_dynamic)
e9e44622 9489 print_dynamic_flags (entry->d_un.d_val);
d1133906 9490 break;
76da6bbe 9491
252b5132
RH		 9492 case DT_AUXILIARY:
9493 case DT_FILTER:
019148e4
L		 9494 case DT_CONFIG:
9495 case DT_DEPAUDIT:
9496 case DT_AUDIT:
252b5132
RH		 9497 if (do_dynamic)
9498 {
019148e4 9499 switch (entry->d_tag)
b34976b6 9500 {
019148e4
L		 9501 case DT_AUXILIARY:
9502 printf (_("Auxiliary library"));
9503 break;
9504
9505 case DT_FILTER:
9506 printf (_("Filter library"));
9507 break;
9508
b34976b6 9509 case DT_CONFIG:
019148e4
L		 9510 printf (_("Configuration file"));
9511 break;
9512
9513 case DT_DEPAUDIT:
9514 printf (_("Dependency audit library"));
9515 break;
9516
9517 case DT_AUDIT:
9518 printf (_("Audit library"));
9519 break;
9520 }
252b5132 9521
d79b3d50
NC		 9522 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9523 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 9524 else
f7a99963
NC		 9525 {
9526 printf (": ");
9527 print_vma (entry->d_un.d_val, PREFIX_HEX);
9528 putchar ('\n');
9529 }
252b5132
RH		 9530 }
9531 break;
9532
dcefbbbd 9533 case DT_FEATURE:
252b5132
RH		 9534 if (do_dynamic)
9535 {
9536 printf (_("Flags:"));
86f55779 9537
252b5132
RH		 9538 if (entry->d_un.d_val == 0)
9539 printf (_(" None\n"));
9540 else
9541 {
9542 unsigned long int val = entry->d_un.d_val;
86f55779 9543
252b5132
RH		 9544 if (val & DTF_1_PARINIT)
9545 {
9546 printf (" PARINIT");
9547 val ^= DTF_1_PARINIT;
9548 }
dcefbbbd
L		 9549 if (val & DTF_1_CONFEXP)
9550 {
9551 printf (" CONFEXP");
9552 val ^= DTF_1_CONFEXP;
9553 }
252b5132
RH		 9554 if (val != 0)
9555 printf (" %lx", val);
9556 puts ("");
9557 }
9558 }
9559 break;
9560
9561 case DT_POSFLAG_1:
9562 if (do_dynamic)
9563 {
9564 printf (_("Flags:"));
86f55779 9565
252b5132
RH		 9566 if (entry->d_un.d_val == 0)
9567 printf (_(" None\n"));
9568 else
9569 {
9570 unsigned long int val = entry->d_un.d_val;
86f55779 9571
252b5132
RH		 9572 if (val & DF_P1_LAZYLOAD)
9573 {
9574 printf (" LAZYLOAD");
9575 val ^= DF_P1_LAZYLOAD;
9576 }
9577 if (val & DF_P1_GROUPPERM)
9578 {
9579 printf (" GROUPPERM");
9580 val ^= DF_P1_GROUPPERM;
9581 }
9582 if (val != 0)
9583 printf (" %lx", val);
9584 puts ("");
9585 }
9586 }
9587 break;
9588
9589 case DT_FLAGS_1:
9590 if (do_dynamic)
9591 {
9592 printf (_("Flags:"));
9593 if (entry->d_un.d_val == 0)
9594 printf (_(" None\n"));
9595 else
9596 {
9597 unsigned long int val = entry->d_un.d_val;
86f55779 9598
252b5132
RH		 9599 if (val & DF_1_NOW)
9600 {
9601 printf (" NOW");
9602 val ^= DF_1_NOW;
9603 }
9604 if (val & DF_1_GLOBAL)
9605 {
9606 printf (" GLOBAL");
9607 val ^= DF_1_GLOBAL;
9608 }
9609 if (val & DF_1_GROUP)
9610 {
9611 printf (" GROUP");
9612 val ^= DF_1_GROUP;
9613 }
9614 if (val & DF_1_NODELETE)
9615 {
9616 printf (" NODELETE");
9617 val ^= DF_1_NODELETE;
9618 }
9619 if (val & DF_1_LOADFLTR)
9620 {
9621 printf (" LOADFLTR");
9622 val ^= DF_1_LOADFLTR;
9623 }
9624 if (val & DF_1_INITFIRST)
9625 {
9626 printf (" INITFIRST");
9627 val ^= DF_1_INITFIRST;
9628 }
9629 if (val & DF_1_NOOPEN)
9630 {
9631 printf (" NOOPEN");
9632 val ^= DF_1_NOOPEN;
9633 }
9634 if (val & DF_1_ORIGIN)
9635 {
9636 printf (" ORIGIN");
9637 val ^= DF_1_ORIGIN;
9638 }
9639 if (val & DF_1_DIRECT)
9640 {
9641 printf (" DIRECT");
9642 val ^= DF_1_DIRECT;
9643 }
9644 if (val & DF_1_TRANS)
9645 {
9646 printf (" TRANS");
9647 val ^= DF_1_TRANS;
9648 }
9649 if (val & DF_1_INTERPOSE)
9650 {
9651 printf (" INTERPOSE");
9652 val ^= DF_1_INTERPOSE;
9653 }
f7db6139 9654 if (val & DF_1_NODEFLIB)
dcefbbbd 9655 {
f7db6139
L		 9656 printf (" NODEFLIB");
9657 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 9658 }
9659 if (val & DF_1_NODUMP)
9660 {
9661 printf (" NODUMP");
9662 val ^= DF_1_NODUMP;
9663 }
34b60028 9664 if (val & DF_1_CONFALT)
dcefbbbd 9665 {
34b60028
L		 9666 printf (" CONFALT");
9667 val ^= DF_1_CONFALT;
9668 }
9669 if (val & DF_1_ENDFILTEE)
9670 {
9671 printf (" ENDFILTEE");
9672 val ^= DF_1_ENDFILTEE;
9673 }
9674 if (val & DF_1_DISPRELDNE)
9675 {
9676 printf (" DISPRELDNE");
9677 val ^= DF_1_DISPRELDNE;
9678 }
9679 if (val & DF_1_DISPRELPND)
9680 {
9681 printf (" DISPRELPND");
9682 val ^= DF_1_DISPRELPND;
9683 }
9684 if (val & DF_1_NODIRECT)
9685 {
9686 printf (" NODIRECT");
9687 val ^= DF_1_NODIRECT;
9688 }
9689 if (val & DF_1_IGNMULDEF)
9690 {
9691 printf (" IGNMULDEF");
9692 val ^= DF_1_IGNMULDEF;
9693 }
9694 if (val & DF_1_NOKSYMS)
9695 {
9696 printf (" NOKSYMS");
9697 val ^= DF_1_NOKSYMS;
9698 }
9699 if (val & DF_1_NOHDR)
9700 {
9701 printf (" NOHDR");
9702 val ^= DF_1_NOHDR;
9703 }
9704 if (val & DF_1_EDITED)
9705 {
9706 printf (" EDITED");
9707 val ^= DF_1_EDITED;
9708 }
9709 if (val & DF_1_NORELOC)
9710 {
9711 printf (" NORELOC");
9712 val ^= DF_1_NORELOC;
9713 }
9714 if (val & DF_1_SYMINTPOSE)
9715 {
9716 printf (" SYMINTPOSE");
9717 val ^= DF_1_SYMINTPOSE;
9718 }
9719 if (val & DF_1_GLOBAUDIT)
9720 {
9721 printf (" GLOBAUDIT");
9722 val ^= DF_1_GLOBAUDIT;
9723 }
9724 if (val & DF_1_SINGLETON)
9725 {
9726 printf (" SINGLETON");
9727 val ^= DF_1_SINGLETON;
dcefbbbd 9728 }
5c383f02
RO		 9729 if (val & DF_1_STUB)
9730 {
9731 printf (" STUB");
9732 val ^= DF_1_STUB;
9733 }
9734 if (val & DF_1_PIE)
9735 {
9736 printf (" PIE");
9737 val ^= DF_1_PIE;
9738 }
252b5132
RH		 9739 if (val != 0)
9740 printf (" %lx", val);
9741 puts ("");
9742 }
9743 }
9744 break;
9745
9746 case DT_PLTREL:
566b0d53 9747 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9748 if (do_dynamic)
9749 puts (get_dynamic_type (entry->d_un.d_val));
9750 break;
9751
9752 case DT_NULL :
9753 case DT_NEEDED :
9754 case DT_PLTGOT :
9755 case DT_HASH :
9756 case DT_STRTAB :
9757 case DT_SYMTAB :
9758 case DT_RELA :
9759 case DT_INIT :
9760 case DT_FINI :
9761 case DT_SONAME :
9762 case DT_RPATH :
9763 case DT_SYMBOLIC:
9764 case DT_REL :
9765 case DT_DEBUG :
9766 case DT_TEXTREL :
9767 case DT_JMPREL :
019148e4 9768 case DT_RUNPATH :
252b5132
RH		 9769 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9770
9771 if (do_dynamic)
9772 {
2cf0635d 9773 char * name;
252b5132 9774
d79b3d50
NC		 9775 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9776 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9777 else
d79b3d50 9778 name = NULL;
252b5132
RH		 9779
9780 if (name)
9781 {
9782 switch (entry->d_tag)
9783 {
9784 case DT_NEEDED:
9785 printf (_("Shared library: [%s]"), name);
9786
18bd398b 9787 if (streq (name, program_interpreter))
f7a99963 9788 printf (_(" program interpreter"));
252b5132
RH		 9789 break;
9790
9791 case DT_SONAME:
f7a99963 9792 printf (_("Library soname: [%s]"), name);
252b5132
RH		 9793 break;
9794
9795 case DT_RPATH:
f7a99963 9796 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 9797 break;
9798
019148e4
L		 9799 case DT_RUNPATH:
9800 printf (_("Library runpath: [%s]"), name);
9801 break;
9802
252b5132 9803 default:
f7a99963
NC		 9804 print_vma (entry->d_un.d_val, PREFIX_HEX);
9805 break;
252b5132
RH		 9806 }
9807 }
9808 else
f7a99963
NC		 9809 print_vma (entry->d_un.d_val, PREFIX_HEX);
9810
9811 putchar ('\n');
252b5132
RH		 9812 }
9813 break;
9814
9815 case DT_PLTRELSZ:
9816 case DT_RELASZ :
9817 case DT_STRSZ :
9818 case DT_RELSZ :
9819 case DT_RELAENT :
9820 case DT_SYMENT :
9821 case DT_RELENT :
566b0d53 9822 dynamic_info[entry->d_tag] = entry->d_un.d_val;
1a0670f3 9823 /* Fall through. */
252b5132
RH		 9824 case DT_PLTPADSZ:
9825 case DT_MOVEENT :
9826 case DT_MOVESZ :
9827 case DT_INIT_ARRAYSZ:
9828 case DT_FINI_ARRAYSZ:
047b2264
JJ		 9829 case DT_GNU_CONFLICTSZ:
9830 case DT_GNU_LIBLISTSZ:
252b5132 9831 if (do_dynamic)
f7a99963
NC		 9832 {
9833 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 9834 printf (_(" (bytes)\n"));
f7a99963 9835 }
252b5132
RH		 9836 break;
9837
9838 case DT_VERDEFNUM:
9839 case DT_VERNEEDNUM:
9840 case DT_RELACOUNT:
9841 case DT_RELCOUNT:
9842 if (do_dynamic)
f7a99963
NC		 9843 {
9844 print_vma (entry->d_un.d_val, UNSIGNED);
9845 putchar ('\n');
9846 }
252b5132
RH		 9847 break;
9848
9849 case DT_SYMINSZ:
9850 case DT_SYMINENT:
9851 case DT_SYMINFO:
9852 case DT_USED:
9853 case DT_INIT_ARRAY:
9854 case DT_FINI_ARRAY:
9855 if (do_dynamic)
9856 {
d79b3d50
NC		 9857 if (entry->d_tag == DT_USED
9858 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 9859 {
2cf0635d 9860 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9861
b34976b6 9862 if (*name)
252b5132
RH		 9863 {
9864 printf (_("Not needed object: [%s]\n"), name);
9865 break;
9866 }
9867 }
103f02d3 9868
f7a99963
NC		 9869 print_vma (entry->d_un.d_val, PREFIX_HEX);
9870 putchar ('\n');
252b5132
RH		 9871 }
9872 break;
9873
9874 case DT_BIND_NOW:
9875 /* The value of this entry is ignored. */
35b1837e
AM		 9876 if (do_dynamic)
9877 putchar ('\n');
252b5132 9878 break;
103f02d3 9879
047b2264
JJ		 9880 case DT_GNU_PRELINKED:
9881 if (do_dynamic)
9882 {
2cf0635d 9883 struct tm * tmp;
91d6fa6a 9884 time_t atime = entry->d_un.d_val;
047b2264 9885
91d6fa6a 9886 tmp = gmtime (&atime);
071436c6
NC		 9887 /* PR 17533 file: 041-1244816-0.004. */
9888 if (tmp == NULL)
5a2cbcf4
L		 9889 printf (_("<corrupt time val: %lx"),
9890 (unsigned long) atime);
071436c6
NC		 9891 else
9892 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9893 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9894 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 9895
9896 }
9897 break;
9898
fdc90cb4
JJ		 9899 case DT_GNU_HASH:
9900 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9901 if (do_dynamic)
9902 {
9903 print_vma (entry->d_un.d_val, PREFIX_HEX);
9904 putchar ('\n');
9905 }
9906 break;
9907
252b5132
RH		 9908 default:
9909 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 9910 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 9911 entry->d_un.d_val;
9912
9913 if (do_dynamic)
9914 {
9915 switch (elf_header.e_machine)
9916 {
9917 case EM_MIPS:
4fe85591 9918 case EM_MIPS_RS3_LE:
b2d38a17 9919 dynamic_section_mips_val (entry);
252b5132 9920 break;
103f02d3 9921 case EM_PARISC:
b2d38a17 9922 dynamic_section_parisc_val (entry);
103f02d3 9923 break;
ecc51f48 9924 case EM_IA_64:
b2d38a17 9925 dynamic_section_ia64_val (entry);
ecc51f48 9926 break;
252b5132 9927 default:
f7a99963
NC		 9928 print_vma (entry->d_un.d_val, PREFIX_HEX);
9929 putchar ('\n');
252b5132
RH		 9930 }
9931 }
9932 break;
9933 }
9934 }
9935
9936 return 1;
9937}
9938
9939static char *
d3ba0551 9940get_ver_flags (unsigned int flags)
252b5132 9941{
b34976b6 9942 static char buff[32];
252b5132
RH		 9943
9944 buff[0] = 0;
9945
9946 if (flags == 0)
9947 return _("none");
9948
9949 if (flags & VER_FLG_BASE)
9950 strcat (buff, "BASE ");
9951
9952 if (flags & VER_FLG_WEAK)
9953 {
9954 if (flags & VER_FLG_BASE)
9955 strcat (buff, "| ");
9956
9957 strcat (buff, "WEAK ");
9958 }
9959
44ec90b9
RO		 9960 if (flags & VER_FLG_INFO)
9961 {
9962 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9963 strcat (buff, "| ");
9964
9965 strcat (buff, "INFO ");
9966 }
9967
9968 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 9969 strcat (buff, _("| <unknown>"));
252b5132
RH		 9970
9971 return buff;
9972}
9973
9974/* Display the contents of the version sections. */
98fb390a 9975
252b5132 9976static int
2cf0635d 9977process_version_sections (FILE * file)
252b5132 9978{
2cf0635d 9979 Elf_Internal_Shdr * section;
b34976b6
AM		 9980 unsigned i;
9981 int found = 0;
252b5132
RH		 9982
9983 if (! do_version)
9984 return 1;
9985
9986 for (i = 0, section = section_headers;
9987 i < elf_header.e_shnum;
b34976b6 9988 i++, section++)
252b5132
RH		 9989 {
9990 switch (section->sh_type)
9991 {
9992 case SHT_GNU_verdef:
9993 {
2cf0635d 9994 Elf_External_Verdef * edefs;
b34976b6
AM		 9995 unsigned int idx;
9996 unsigned int cnt;
c9f02c3e 9997 unsigned int end;
2cf0635d 9998 char * endbuf;
252b5132
RH		 9999
10000 found = 1;
10001
74e1a04b
NC		 10002 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
10003 printable_section_name (section),
10004 section->sh_info);
252b5132
RH		 10005
10006 printf (_(" Addr: 0x"));
10007 printf_vma (section->sh_addr);
233f82cf 10008 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 10009 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 10010 printable_section_name_from_index (section->sh_link));
252b5132 10011
3f5e193b
NC		 10012 edefs = (Elf_External_Verdef *)
10013 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
10014 _("version definition section"));
a6e9f9df
AM		 10015 if (!edefs)
10016 break;
59245841 10017 endbuf = (char *) edefs + section->sh_size;
252b5132 10018
c9f02c3e
MR		 10019 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
10020 end = (section->sh_info < section->sh_size
10021 ? section->sh_info : section->sh_size);
10022 for (idx = cnt = 0; cnt < end; ++cnt)
252b5132 10023 {
2cf0635d
NC		 10024 char * vstart;
10025 Elf_External_Verdef * edef;
b34976b6 10026 Elf_Internal_Verdef ent;
2cf0635d 10027 Elf_External_Verdaux * eaux;
b34976b6 10028 Elf_Internal_Verdaux aux;
5235cd68 10029 unsigned int isum;
b34976b6 10030 int j;
103f02d3 10031
222c2bf0 10032 /* Check for very large indices. */
7e26601c 10033 if (idx > (size_t) (endbuf - (char *) edefs))
dd24e3da
NC		 10034 break;
10035
252b5132 10036 vstart = ((char *) edefs) + idx;
54806181
AM		 10037 if (vstart + sizeof (*edef) > endbuf)
10038 break;
252b5132
RH		 10039
10040 edef = (Elf_External_Verdef *) vstart;
10041
10042 ent.vd_version = BYTE_GET (edef->vd_version);
10043 ent.vd_flags = BYTE_GET (edef->vd_flags);
10044 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
10045 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
10046 ent.vd_hash = BYTE_GET (edef->vd_hash);
10047 ent.vd_aux = BYTE_GET (edef->vd_aux);
10048 ent.vd_next = BYTE_GET (edef->vd_next);
10049
10050 printf (_(" %#06x: Rev: %d Flags: %s"),
10051 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10052
10053 printf (_(" Index: %d Cnt: %d "),
10054 ent.vd_ndx, ent.vd_cnt);
10055
dd24e3da 10056 /* Check for overflow. */
4aeb00ad 10057 if (ent.vd_aux + sizeof (* eaux) > (size_t) (endbuf - vstart))
dd24e3da
NC		 10058 break;
10059
252b5132
RH		 10060 vstart += ent.vd_aux;
10061
10062 eaux = (Elf_External_Verdaux *) vstart;
10063
10064 aux.vda_name = BYTE_GET (eaux->vda_name);
10065 aux.vda_next = BYTE_GET (eaux->vda_next);
10066
d79b3d50
NC		 10067 if (VALID_DYNAMIC_NAME (aux.vda_name))
10068 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 10069 else
10070 printf (_("Name index: %ld\n"), aux.vda_name);
10071
10072 isum = idx + ent.vd_aux;
10073
b34976b6 10074 for (j = 1; j < ent.vd_cnt; j++)
252b5132 10075 {
dd24e3da 10076 /* Check for overflow. */
7e26601c 10077 if (aux.vda_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 10078 break;
10079
252b5132
RH		 10080 isum += aux.vda_next;
10081 vstart += aux.vda_next;
10082
10083 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 10084 if (vstart + sizeof (*eaux) > endbuf)
10085 break;
252b5132
RH		 10086
10087 aux.vda_name = BYTE_GET (eaux->vda_name);
10088 aux.vda_next = BYTE_GET (eaux->vda_next);
10089
d79b3d50 10090 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 10091 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 10092 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 10093 else
10094 printf (_(" %#06x: Parent %d, name index: %ld\n"),
10095 isum, j, aux.vda_name);
10096 }
dd24e3da 10097
54806181
AM		 10098 if (j < ent.vd_cnt)
10099 printf (_(" Version def aux past end of section\n"));
252b5132 10100
c9f02c3e
MR		 10101 /* PR 17531:
10102 file: id:000001,src:000172+005151,op:splice,rep:2. */
10103 if (idx + ent.vd_next < idx)
5d921cbd
NC		 10104 break;
10105
252b5132
RH		 10106 idx += ent.vd_next;
10107 }
dd24e3da 10108
54806181
AM		 10109 if (cnt < section->sh_info)
10110 printf (_(" Version definition past end of section\n"));
252b5132
RH		 10111
10112 free (edefs);
10113 }
10114 break;
103f02d3 10115
252b5132
RH		 10116 case SHT_GNU_verneed:
10117 {
2cf0635d 10118 Elf_External_Verneed * eneed;
b34976b6
AM		 10119 unsigned int idx;
10120 unsigned int cnt;
2cf0635d 10121 char * endbuf;
252b5132
RH		 10122
10123 found = 1;
10124
72de5009 10125 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
74e1a04b 10126 printable_section_name (section), section->sh_info);
252b5132
RH		 10127
10128 printf (_(" Addr: 0x"));
10129 printf_vma (section->sh_addr);
72de5009 10130 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 10131 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 10132 printable_section_name_from_index (section->sh_link));
252b5132 10133
3f5e193b
NC		 10134 eneed = (Elf_External_Verneed *) get_data (NULL, file,
10135 section->sh_offset, 1,
10136 section->sh_size,
9cf03b7e 10137 _("Version Needs section"));
a6e9f9df
AM		 10138 if (!eneed)
10139 break;
59245841 10140 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 10141
10142 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10143 {
2cf0635d 10144 Elf_External_Verneed * entry;
b34976b6 10145 Elf_Internal_Verneed ent;
5235cd68 10146 unsigned int isum;
b34976b6 10147 int j;
2cf0635d 10148 char * vstart;
252b5132 10149
7e26601c 10150 if (idx > (size_t) (endbuf - (char *) eneed))
dd24e3da
NC		 10151 break;
10152
252b5132 10153 vstart = ((char *) eneed) + idx;
54806181
AM		 10154 if (vstart + sizeof (*entry) > endbuf)
10155 break;
252b5132
RH		 10156
10157 entry = (Elf_External_Verneed *) vstart;
10158
10159 ent.vn_version = BYTE_GET (entry->vn_version);
10160 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
10161 ent.vn_file = BYTE_GET (entry->vn_file);
10162 ent.vn_aux = BYTE_GET (entry->vn_aux);
10163 ent.vn_next = BYTE_GET (entry->vn_next);
10164
10165 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
10166
d79b3d50
NC		 10167 if (VALID_DYNAMIC_NAME (ent.vn_file))
10168 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 10169 else
10170 printf (_(" File: %lx"), ent.vn_file);
10171
10172 printf (_(" Cnt: %d\n"), ent.vn_cnt);
10173
dd24e3da 10174 /* Check for overflow. */
7e26601c 10175 if (ent.vn_aux > (size_t) (endbuf - vstart))
dd24e3da 10176 break;
252b5132
RH		 10177 vstart += ent.vn_aux;
10178
10179 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10180 {
2cf0635d 10181 Elf_External_Vernaux * eaux;
b34976b6 10182 Elf_Internal_Vernaux aux;
252b5132 10183
54806181
AM		 10184 if (vstart + sizeof (*eaux) > endbuf)
10185 break;
252b5132
RH		 10186 eaux = (Elf_External_Vernaux *) vstart;
10187
10188 aux.vna_hash = BYTE_GET (eaux->vna_hash);
10189 aux.vna_flags = BYTE_GET (eaux->vna_flags);
10190 aux.vna_other = BYTE_GET (eaux->vna_other);
10191 aux.vna_name = BYTE_GET (eaux->vna_name);
10192 aux.vna_next = BYTE_GET (eaux->vna_next);
10193
d79b3d50 10194 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 10195 printf (_(" %#06x: Name: %s"),
d79b3d50 10196 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 10197 else
ecc2063b 10198 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 10199 isum, aux.vna_name);
10200
10201 printf (_(" Flags: %s Version: %d\n"),
10202 get_ver_flags (aux.vna_flags), aux.vna_other);
10203
dd24e3da 10204 /* Check for overflow. */
53774b7e
NC		 10205 if (aux.vna_next > (size_t) (endbuf - vstart)
10206 || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
10207 {
10208 warn (_("Invalid vna_next field of %lx\n"),
10209 aux.vna_next);
10210 j = ent.vn_cnt;
10211 break;
10212 }
252b5132
RH		 10213 isum += aux.vna_next;
10214 vstart += aux.vna_next;
10215 }
9cf03b7e 10216
54806181 10217 if (j < ent.vn_cnt)
9cf03b7e 10218 warn (_("Missing Version Needs auxillary information\n"));
252b5132 10219
bcf83b2a 10220 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
c24cf8b6
NC		 10221 {
10222 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
10223 cnt = section->sh_info;
10224 break;
10225 }
252b5132
RH		 10226 idx += ent.vn_next;
10227 }
9cf03b7e 10228
54806181 10229 if (cnt < section->sh_info)
9cf03b7e 10230 warn (_("Missing Version Needs information\n"));
103f02d3 10231
252b5132
RH		 10232 free (eneed);
10233 }
10234 break;
10235
10236 case SHT_GNU_versym:
10237 {
2cf0635d 10238 Elf_Internal_Shdr * link_section;
8b73c356
NC		 10239 size_t total;
10240 unsigned int cnt;
2cf0635d
NC		 10241 unsigned char * edata;
10242 unsigned short * data;
10243 char * strtab;
10244 Elf_Internal_Sym * symbols;
10245 Elf_Internal_Shdr * string_sec;
ba5cdace 10246 unsigned long num_syms;
d3ba0551 10247 long off;
252b5132 10248
4fbb74a6 10249 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 10250 break;
10251
4fbb74a6 10252 link_section = section_headers + section->sh_link;
08d8fa11 10253 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 10254
4fbb74a6 10255 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 10256 break;
10257
252b5132
RH		 10258 found = 1;
10259
ba5cdace 10260 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 10261 if (symbols == NULL)
10262 break;
252b5132 10263
4fbb74a6 10264 string_sec = section_headers + link_section->sh_link;
252b5132 10265
3f5e193b
NC		 10266 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
10267 string_sec->sh_size,
10268 _("version string table"));
a6e9f9df 10269 if (!strtab)
0429c154
MS		 10270 {
10271 free (symbols);
10272 break;
10273 }
252b5132 10274
8b73c356
NC		 10275 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10276 printable_section_name (section), (unsigned long) total);
252b5132
RH		 10277
10278 printf (_(" Addr: "));
10279 printf_vma (section->sh_addr);
72de5009 10280 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 10281 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 10282 printable_section_name (link_section));
252b5132 10283
d3ba0551
AM		 10284 off = offset_from_vma (file,
10285 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10286 total * sizeof (short));
3f5e193b
NC		 10287 edata = (unsigned char *) get_data (NULL, file, off, total,
10288 sizeof (short),
10289 _("version symbol data"));
a6e9f9df
AM		 10290 if (!edata)
10291 {
10292 free (strtab);
0429c154 10293 free (symbols);
a6e9f9df
AM		 10294 break;
10295 }
252b5132 10296
3f5e193b 10297 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 10298
10299 for (cnt = total; cnt --;)
b34976b6
AM		 10300 data[cnt] = byte_get (edata + cnt * sizeof (short),
10301 sizeof (short));
252b5132
RH		 10302
10303 free (edata);
10304
10305 for (cnt = 0; cnt < total; cnt += 4)
10306 {
10307 int j, nn;
ab273396
AM		 10308 char *name;
10309 char *invalid = _("*invalid*");
252b5132
RH		 10310
10311 printf (" %03x:", cnt);
10312
10313 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 10314 switch (data[cnt + j])
252b5132
RH		 10315 {
10316 case 0:
10317 fputs (_(" 0 (*local*) "), stdout);
10318 break;
10319
10320 case 1:
10321 fputs (_(" 1 (*global*) "), stdout);
10322 break;
10323
10324 default:
c244d050
NC		 10325 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10326 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 10327
dd24e3da 10328 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 10329 array, break to avoid an out-of-bounds read. */
10330 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 10331 {
10332 warn (_("invalid index into symbol array\n"));
10333 break;
10334 }
10335
ab273396
AM		 10336 name = NULL;
10337 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 10338 {
b34976b6
AM		 10339 Elf_Internal_Verneed ivn;
10340 unsigned long offset;
252b5132 10341
d93f0186
NC		 10342 offset = offset_from_vma
10343 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10344 sizeof (Elf_External_Verneed));
252b5132 10345
b34976b6 10346 do
252b5132 10347 {
b34976b6
AM		 10348 Elf_Internal_Vernaux ivna;
10349 Elf_External_Verneed evn;
10350 Elf_External_Vernaux evna;
10351 unsigned long a_off;
252b5132 10352
59245841
NC		 10353 if (get_data (&evn, file, offset, sizeof (evn), 1,
10354 _("version need")) == NULL)
10355 break;
0b4362b0 10356
252b5132
RH		 10357 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10358 ivn.vn_next = BYTE_GET (evn.vn_next);
10359
10360 a_off = offset + ivn.vn_aux;
10361
10362 do
10363 {
59245841
NC		 10364 if (get_data (&evna, file, a_off, sizeof (evna),
10365 1, _("version need aux (2)")) == NULL)
10366 {
10367 ivna.vna_next = 0;
10368 ivna.vna_other = 0;
10369 }
10370 else
10371 {
10372 ivna.vna_next = BYTE_GET (evna.vna_next);
10373 ivna.vna_other = BYTE_GET (evna.vna_other);
10374 }
252b5132
RH		 10375
10376 a_off += ivna.vna_next;
10377 }
b34976b6 10378 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 10379 && ivna.vna_next != 0);
10380
b34976b6 10381 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 10382 {
10383 ivna.vna_name = BYTE_GET (evna.vna_name);
10384
54806181 10385 if (ivna.vna_name >= string_sec->sh_size)
ab273396 10386 name = invalid;
54806181
AM		 10387 else
10388 name = strtab + ivna.vna_name;
252b5132
RH		 10389 break;
10390 }
10391
10392 offset += ivn.vn_next;
10393 }
10394 while (ivn.vn_next);
10395 }
00d93f34 10396
ab273396 10397 if (data[cnt + j] != 0x8001
b34976b6 10398 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 10399 {
b34976b6
AM		 10400 Elf_Internal_Verdef ivd;
10401 Elf_External_Verdef evd;
10402 unsigned long offset;
252b5132 10403
d93f0186
NC		 10404 offset = offset_from_vma
10405 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10406 sizeof evd);
252b5132
RH		 10407
10408 do
10409 {
59245841
NC		 10410 if (get_data (&evd, file, offset, sizeof (evd), 1,
10411 _("version def")) == NULL)
10412 {
10413 ivd.vd_next = 0;
948f632f 10414 /* PR 17531: file: 046-1082287-0.004. */
3102e897
NC		 10415 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
10416 break;
59245841
NC		 10417 }
10418 else
10419 {
10420 ivd.vd_next = BYTE_GET (evd.vd_next);
10421 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10422 }
252b5132
RH		 10423
10424 offset += ivd.vd_next;
10425 }
c244d050 10426 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 10427 && ivd.vd_next != 0);
10428
c244d050 10429 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 10430 {
b34976b6
AM		 10431 Elf_External_Verdaux evda;
10432 Elf_Internal_Verdaux ivda;
252b5132
RH		 10433
10434 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10435
59245841
NC		 10436 if (get_data (&evda, file,
10437 offset - ivd.vd_next + ivd.vd_aux,
10438 sizeof (evda), 1,
10439 _("version def aux")) == NULL)
10440 break;
252b5132
RH		 10441
10442 ivda.vda_name = BYTE_GET (evda.vda_name);
10443
54806181 10444 if (ivda.vda_name >= string_sec->sh_size)
ab273396
AM		 10445 name = invalid;
10446 else if (name != NULL && name != invalid)
10447 name = _("*both*");
54806181
AM		 10448 else
10449 name = strtab + ivda.vda_name;
252b5132
RH		 10450 }
10451 }
ab273396
AM		 10452 if (name != NULL)
10453 nn += printf ("(%s%-*s",
10454 name,
10455 12 - (int) strlen (name),
10456 ")");
252b5132
RH		 10457
10458 if (nn < 18)
10459 printf ("%*c", 18 - nn, ' ');
10460 }
10461
10462 putchar ('\n');
10463 }
10464
10465 free (data);
10466 free (strtab);
10467 free (symbols);
10468 }
10469 break;
103f02d3 10470
252b5132
RH		 10471 default:
10472 break;
10473 }
10474 }
10475
10476 if (! found)
10477 printf (_("\nNo version information found in this file.\n"));
10478
10479 return 1;
10480}
10481
d1133906 10482static const char *
d3ba0551 10483get_symbol_binding (unsigned int binding)
252b5132 10484{
b34976b6 10485 static char buff[32];
252b5132
RH		 10486
10487 switch (binding)
10488 {
b34976b6
AM		 10489 case STB_LOCAL: return "LOCAL";
10490 case STB_GLOBAL: return "GLOBAL";
10491 case STB_WEAK: return "WEAK";
252b5132
RH		 10492 default:
10493 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 10494 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10495 binding);
252b5132 10496 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 10497 {
10498 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 10499 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10500 /* GNU is still using the default value 0. */
3e7a7d11
NC		 10501 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10502 return "UNIQUE";
10503 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10504 }
252b5132 10505 else
e9e44622 10506 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 10507 return buff;
10508 }
10509}
10510
d1133906 10511static const char *
d3ba0551 10512get_symbol_type (unsigned int type)
252b5132 10513{
b34976b6 10514 static char buff[32];
252b5132
RH		 10515
10516 switch (type)
10517 {
b34976b6
AM		 10518 case STT_NOTYPE: return "NOTYPE";
10519 case STT_OBJECT: return "OBJECT";
10520 case STT_FUNC: return "FUNC";
10521 case STT_SECTION: return "SECTION";
10522 case STT_FILE: return "FILE";
10523 case STT_COMMON: return "COMMON";
10524 case STT_TLS: return "TLS";
15ab5209
DB		 10525 case STT_RELC: return "RELC";
10526 case STT_SRELC: return "SRELC";
252b5132
RH		 10527 default:
10528 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af 10529 {
3510a7b8
NC		 10530 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10531 return "THUMB_FUNC";
103f02d3 10532
351b4b40 10533 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 10534 return "REGISTER";
10535
10536 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10537 return "PARISC_MILLI";
10538
e9e44622 10539 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 10540 }
252b5132 10541 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 10542 {
10543 if (elf_header.e_machine == EM_PARISC)
10544 {
10545 if (type == STT_HP_OPAQUE)
10546 return "HP_OPAQUE";
10547 if (type == STT_HP_STUB)
10548 return "HP_STUB";
10549 }
10550
d8045f23 10551 if (type == STT_GNU_IFUNC
9c55345c 10552 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 10553 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 10554 /* GNU is still using the default value 0. */
d8045f23
NC		 10555 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10556 return "IFUNC";
10557
e9e44622 10558 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 10559 }
252b5132 10560 else
e9e44622 10561 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 10562 return buff;
10563 }
10564}
10565
d1133906 10566static const char *
d3ba0551 10567get_symbol_visibility (unsigned int visibility)
d1133906
NC		 10568{
10569 switch (visibility)
10570 {
b34976b6
AM		 10571 case STV_DEFAULT: return "DEFAULT";
10572 case STV_INTERNAL: return "INTERNAL";
10573 case STV_HIDDEN: return "HIDDEN";
d1133906 10574 case STV_PROTECTED: return "PROTECTED";
bee0ee85
NC		 10575 default:
10576 error (_("Unrecognized visibility value: %u"), visibility);
10577 return _("<unknown>");
d1133906
NC		 10578 }
10579}
10580
fd85a6a1
NC		 10581static const char *
10582get_solaris_symbol_visibility (unsigned int visibility)
10583{
10584 switch (visibility)
10585 {
10586 case 4: return "EXPORTED";
10587 case 5: return "SINGLETON";
10588 case 6: return "ELIMINATE";
10589 default: return get_symbol_visibility (visibility);
10590 }
10591}
10592
5e2b0d47
NC		 10593static const char *
10594get_mips_symbol_other (unsigned int other)
10595{
10596 switch (other)
10597 {
df58fc94
RS		 10598 case STO_OPTIONAL:
10599 return "OPTIONAL";
10600 case STO_MIPS_PLT:
10601 return "MIPS PLT";
10602 case STO_MIPS_PIC:
10603 return "MIPS PIC";
10604 case STO_MICROMIPS:
10605 return "MICROMIPS";
10606 case STO_MICROMIPS | STO_MIPS_PIC:
10607 return "MICROMIPS, MIPS PIC";
10608 case STO_MIPS16:
10609 return "MIPS16";
10610 default:
10611 return NULL;
5e2b0d47
NC		 10612 }
10613}
10614
28f997cf
TG		 10615static const char *
10616get_ia64_symbol_other (unsigned int other)
10617{
10618 if (is_ia64_vms ())
10619 {
10620 static char res[32];
10621
10622 res[0] = 0;
10623
10624 /* Function types is for images and .STB files only. */
10625 switch (elf_header.e_type)
10626 {
10627 case ET_DYN:
10628 case ET_EXEC:
10629 switch (VMS_ST_FUNC_TYPE (other))
10630 {
10631 case VMS_SFT_CODE_ADDR:
10632 strcat (res, " CA");
10633 break;
10634 case VMS_SFT_SYMV_IDX:
10635 strcat (res, " VEC");
10636 break;
10637 case VMS_SFT_FD:
10638 strcat (res, " FD");
10639 break;
10640 case VMS_SFT_RESERVE:
10641 strcat (res, " RSV");
10642 break;
10643 default:
bee0ee85
NC		 10644 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10645 VMS_ST_FUNC_TYPE (other));
10646 strcat (res, " <unknown>");
10647 break;
28f997cf
TG		 10648 }
10649 break;
10650 default:
10651 break;
10652 }
10653 switch (VMS_ST_LINKAGE (other))
10654 {
10655 case VMS_STL_IGNORE:
10656 strcat (res, " IGN");
10657 break;
10658 case VMS_STL_RESERVE:
10659 strcat (res, " RSV");
10660 break;
10661 case VMS_STL_STD:
10662 strcat (res, " STD");
10663 break;
10664 case VMS_STL_LNK:
10665 strcat (res, " LNK");
10666 break;
10667 default:
bee0ee85
NC		 10668 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10669 VMS_ST_LINKAGE (other));
10670 strcat (res, " <unknown>");
10671 break;
28f997cf
TG		 10672 }
10673
10674 if (res[0] != 0)
10675 return res + 1;
10676 else
10677 return res;
10678 }
10679 return NULL;
10680}
10681
6911b7dc
AM		 10682static const char *
10683get_ppc64_symbol_other (unsigned int other)
10684{
10685 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10686 {
10687 static char buf[32];
10688 snprintf (buf, sizeof buf, _("<localentry>: %d"),
10689 PPC64_LOCAL_ENTRY_OFFSET (other));
10690 return buf;
10691 }
10692 return NULL;
10693}
10694
5e2b0d47
NC		 10695static const char *
10696get_symbol_other (unsigned int other)
10697{
10698 const char * result = NULL;
10699 static char buff [32];
10700
10701 if (other == 0)
10702 return "";
10703
10704 switch (elf_header.e_machine)
10705 {
10706 case EM_MIPS:
10707 result = get_mips_symbol_other (other);
28f997cf
TG		 10708 break;
10709 case EM_IA_64:
10710 result = get_ia64_symbol_other (other);
10711 break;
6911b7dc
AM		 10712 case EM_PPC64:
10713 result = get_ppc64_symbol_other (other);
10714 break;
5e2b0d47 10715 default:
fd85a6a1 10716 result = NULL;
5e2b0d47
NC		 10717 break;
10718 }
10719
10720 if (result)
10721 return result;
10722
10723 snprintf (buff, sizeof buff, _("<other>: %x"), other);
10724 return buff;
10725}
10726
d1133906 10727static const char *
d3ba0551 10728get_symbol_index_type (unsigned int type)
252b5132 10729{
b34976b6 10730 static char buff[32];
5cf1065c 10731
252b5132
RH		 10732 switch (type)
10733 {
b34976b6
AM		 10734 case SHN_UNDEF: return "UND";
10735 case SHN_ABS: return "ABS";
10736 case SHN_COMMON: return "COM";
252b5132 10737 default:
9ce701e2
L		 10738 if (type == SHN_IA_64_ANSI_COMMON
10739 && elf_header.e_machine == EM_IA_64
10740 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10741 return "ANSI_COM";
8a9036a4 10742 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 10743 || elf_header.e_machine == EM_L1OM
10744 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 10745 && type == SHN_X86_64_LCOMMON)
10746 return "LARGE_COM";
ac145307
BS		 10747 else if ((type == SHN_MIPS_SCOMMON
10748 && elf_header.e_machine == EM_MIPS)
10749 || (type == SHN_TIC6X_SCOMMON
10750 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 10751 return "SCOM";
10752 else if (type == SHN_MIPS_SUNDEFINED
10753 && elf_header.e_machine == EM_MIPS)
10754 return "SUND";
9ce701e2 10755 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 10756 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 10757 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 10758 sprintf (buff, "OS [0x%04x]", type & 0xffff);
10759 else if (type >= SHN_LORESERVE)
10760 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4 10761 else if (type >= elf_header.e_shnum)
e0a31db1 10762 sprintf (buff, _("bad section index[%3d]"), type);
252b5132 10763 else
232e7cb8 10764 sprintf (buff, "%3d", type);
5cf1065c 10765 break;
252b5132 10766 }
5cf1065c
NC		 10767
10768 return buff;
252b5132
RH		 10769}
10770
66543521 10771static bfd_vma *
57028622 10772get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
252b5132 10773{
2cf0635d
NC		 10774 unsigned char * e_data;
10775 bfd_vma * i_data;
252b5132 10776
57028622
NC		 10777 /* If the size_t type is smaller than the bfd_size_type, eg because
10778 you are building a 32-bit tool on a 64-bit host, then make sure
10779 that when (number) is cast to (size_t) no information is lost. */
10780 if (sizeof (size_t) < sizeof (bfd_size_type)
10781 && (bfd_size_type) ((size_t) number) != number)
10782 {
ed754a13
AM		 10783 error (_("Size truncation prevents reading %" BFD_VMA_FMT "u"
10784 " elements of size %u\n"),
10785 number, ent_size);
57028622
NC		 10786 return NULL;
10787 }
948f632f 10788
3102e897
NC		 10789 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10790 attempting to allocate memory when the read is bound to fail. */
10791 if (ent_size * number > current_file_size)
10792 {
ed754a13
AM		 10793 error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT "u\n"),
10794 number);
3102e897
NC		 10795 return NULL;
10796 }
10797
57028622 10798 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
252b5132
RH		 10799 if (e_data == NULL)
10800 {
ed754a13
AM		 10801 error (_("Out of memory reading %" BFD_VMA_FMT "u dynamic entries\n"),
10802 number);
252b5132
RH		 10803 return NULL;
10804 }
10805
57028622 10806 if (fread (e_data, ent_size, (size_t) number, file) != number)
252b5132 10807 {
ed754a13
AM		 10808 error (_("Unable to read in %" BFD_VMA_FMT "u bytes of dynamic data\n"),
10809 number * ent_size);
3102e897 10810 free (e_data);
252b5132
RH		 10811 return NULL;
10812 }
10813
57028622 10814 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
252b5132
RH		 10815 if (i_data == NULL)
10816 {
ed754a13
AM		 10817 error (_("Out of memory allocating space for %" BFD_VMA_FMT "u"
10818 " dynamic entries\n"),
10819 number);
252b5132
RH		 10820 free (e_data);
10821 return NULL;
10822 }
10823
10824 while (number--)
66543521 10825 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 10826
10827 free (e_data);
10828
10829 return i_data;
10830}
10831
6bd1a22c
L		 10832static void
10833print_dynamic_symbol (bfd_vma si, unsigned long hn)
10834{
2cf0635d 10835 Elf_Internal_Sym * psym;
6bd1a22c
L		 10836 int n;
10837
6bd1a22c
L		 10838 n = print_vma (si, DEC_5);
10839 if (n < 5)
0b4362b0 10840 fputs (&" "[n], stdout);
6bd1a22c 10841 printf (" %3lu: ", hn);
e0a31db1
NC		 10842
10843 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10844 {
3102e897
NC		 10845 printf (_("<No info available for dynamic symbol number %lu>\n"),
10846 (unsigned long) si);
e0a31db1
NC		 10847 return;
10848 }
10849
10850 psym = dynamic_symbols + si;
6bd1a22c
L		 10851 print_vma (psym->st_value, LONG_HEX);
10852 putchar (' ');
10853 print_vma (psym->st_size, DEC_5);
10854
f4be36b3
AM		 10855 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10856 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
fd85a6a1
NC		 10857
10858 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
10859 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
10860 else
10861 {
10862 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
10863
10864 printf (" %-7s", get_symbol_visibility (vis));
10865 /* Check to see if any other bits in the st_other field are set.
10866 Note - displaying this information disrupts the layout of the
10867 table being generated, but for the moment this case is very
10868 rare. */
10869 if (psym->st_other ^ vis)
10870 printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
10871 }
10872
6bd1a22c
L		 10873 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10874 if (VALID_DYNAMIC_NAME (psym->st_name))
10875 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10876 else
2b692964 10877 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 10878 putchar ('\n');
10879}
10880
bb4d2ac2 10881static const char *
1449284b
NC		 10882get_symbol_version_string (FILE * file,
10883 bfd_boolean is_dynsym,
10884 const char * strtab,
10885 unsigned long int strtab_size,
10886 unsigned int si,
10887 Elf_Internal_Sym * psym,
10888 enum versioned_symbol_info * sym_info,
10889 unsigned short * vna_other)
bb4d2ac2 10890{
ab273396
AM		 10891 unsigned char data[2];
10892 unsigned short vers_data;
10893 unsigned long offset;
bb4d2ac2 10894
ab273396
AM		 10895 if (!is_dynsym
10896 || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
10897 return NULL;
bb4d2ac2 10898
ab273396
AM		 10899 offset = offset_from_vma (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10900 sizeof data + si * sizeof (vers_data));
bb4d2ac2 10901
ab273396
AM		 10902 if (get_data (&data, file, offset + si * sizeof (vers_data),
10903 sizeof (data), 1, _("version data")) == NULL)
10904 return NULL;
10905
10906 vers_data = byte_get (data, 2);
bb4d2ac2 10907
ab273396
AM		 10908 if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
10909 return NULL;
bb4d2ac2 10910
ab273396
AM		 10911 /* Usually we'd only see verdef for defined symbols, and verneed for
10912 undefined symbols. However, symbols defined by the linker in
10913 .dynbss for variables copied from a shared library in order to
10914 avoid text relocations are defined yet have verneed. We could
10915 use a heuristic to detect the special case, for example, check
10916 for verneed first on symbols defined in SHT_NOBITS sections, but
10917 it is simpler and more reliable to just look for both verdef and
10918 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
bb4d2ac2 10919
ab273396
AM		 10920 if (psym->st_shndx != SHN_UNDEF
10921 && vers_data != 0x8001
10922 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10923 {
10924 Elf_Internal_Verdef ivd;
10925 Elf_Internal_Verdaux ivda;
10926 Elf_External_Verdaux evda;
10927 unsigned long off;
bb4d2ac2 10928
ab273396
AM		 10929 off = offset_from_vma (file,
10930 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10931 sizeof (Elf_External_Verdef));
10932
10933 do
bb4d2ac2 10934 {
ab273396
AM		 10935 Elf_External_Verdef evd;
10936
10937 if (get_data (&evd, file, off, sizeof (evd), 1,
10938 _("version def")) == NULL)
10939 {
10940 ivd.vd_ndx = 0;
10941 ivd.vd_aux = 0;
10942 ivd.vd_next = 0;
10943 }
10944 else
bb4d2ac2 10945 {
ab273396
AM		 10946 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10947 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10948 ivd.vd_next = BYTE_GET (evd.vd_next);
10949 }
bb4d2ac2 10950
ab273396
AM		 10951 off += ivd.vd_next;
10952 }
10953 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
bb4d2ac2 10954
ab273396
AM		 10955 if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
10956 {
10957 off -= ivd.vd_next;
10958 off += ivd.vd_aux;
bb4d2ac2 10959
ab273396
AM		 10960 if (get_data (&evda, file, off, sizeof (evda), 1,
10961 _("version def aux")) != NULL)
10962 {
10963 ivda.vda_name = BYTE_GET (evda.vda_name);
bb4d2ac2 10964
ab273396
AM		 10965 if (psym->st_name != ivda.vda_name)
10966 {
10967 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10968 ? symbol_hidden : symbol_public);
10969 return (ivda.vda_name < strtab_size
10970 ? strtab + ivda.vda_name : _("<corrupt>"));
10971 }
10972 }
10973 }
10974 }
bb4d2ac2 10975
ab273396
AM		 10976 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10977 {
10978 Elf_External_Verneed evn;
10979 Elf_Internal_Verneed ivn;
10980 Elf_Internal_Vernaux ivna;
bb4d2ac2 10981
ab273396
AM		 10982 offset = offset_from_vma (file,
10983 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10984 sizeof evn);
10985 do
10986 {
10987 unsigned long vna_off;
bb4d2ac2 10988
ab273396
AM		 10989 if (get_data (&evn, file, offset, sizeof (evn), 1,
10990 _("version need")) == NULL)
10991 {
10992 ivna.vna_next = 0;
10993 ivna.vna_other = 0;
10994 ivna.vna_name = 0;
10995 break;
10996 }
bb4d2ac2 10997
ab273396
AM		 10998 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10999 ivn.vn_next = BYTE_GET (evn.vn_next);
bb4d2ac2 11000
ab273396 11001 vna_off = offset + ivn.vn_aux;
bb4d2ac2 11002
ab273396
AM		 11003 do
11004 {
11005 Elf_External_Vernaux evna;
bb4d2ac2 11006
ab273396
AM		 11007 if (get_data (&evna, file, vna_off, sizeof (evna), 1,
11008 _("version need aux (3)")) == NULL)
bb4d2ac2 11009 {
ab273396
AM		 11010 ivna.vna_next = 0;
11011 ivna.vna_other = 0;
11012 ivna.vna_name = 0;
bb4d2ac2 11013 }
bb4d2ac2 11014 else
bb4d2ac2 11015 {
ab273396
AM		 11016 ivna.vna_other = BYTE_GET (evna.vna_other);
11017 ivna.vna_next = BYTE_GET (evna.vna_next);
11018 ivna.vna_name = BYTE_GET (evna.vna_name);
11019 }
bb4d2ac2 11020
ab273396
AM		 11021 vna_off += ivna.vna_next;
11022 }
11023 while (ivna.vna_other != vers_data && ivna.vna_next != 0);
bb4d2ac2 11024
ab273396
AM		 11025 if (ivna.vna_other == vers_data)
11026 break;
bb4d2ac2 11027
ab273396
AM		 11028 offset += ivn.vn_next;
11029 }
11030 while (ivn.vn_next != 0);
bb4d2ac2 11031
ab273396
AM		 11032 if (ivna.vna_other == vers_data)
11033 {
11034 *sym_info = symbol_undefined;
11035 *vna_other = ivna.vna_other;
11036 return (ivna.vna_name < strtab_size
11037 ? strtab + ivna.vna_name : _("<corrupt>"));
bb4d2ac2
L		 11038 }
11039 }
ab273396 11040 return NULL;
bb4d2ac2
L		 11041}
11042
e3c8793a 11043/* Dump the symbol table. */
252b5132 11044static int
2cf0635d 11045process_symbol_table (FILE * file)
252b5132 11046{
2cf0635d 11047 Elf_Internal_Shdr * section;
8b73c356
NC		 11048 bfd_size_type nbuckets = 0;
11049 bfd_size_type nchains = 0;
2cf0635d
NC		 11050 bfd_vma * buckets = NULL;
11051 bfd_vma * chains = NULL;
fdc90cb4 11052 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 11053 bfd_vma * gnubuckets = NULL;
11054 bfd_vma * gnuchains = NULL;
6bd1a22c 11055 bfd_vma gnusymidx = 0;
071436c6 11056 bfd_size_type ngnuchains = 0;
252b5132 11057
2c610e4b 11058 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 11059 return 1;
11060
6bd1a22c
L		 11061 if (dynamic_info[DT_HASH]
11062 && (do_histogram
2c610e4b
L		 11063 || (do_using_dynamic
11064 && !do_dyn_syms
11065 && dynamic_strings != NULL)))
252b5132 11066 {
66543521
AM		 11067 unsigned char nb[8];
11068 unsigned char nc[8];
8b73c356 11069 unsigned int hash_ent_size = 4;
66543521
AM		 11070
11071 if ((elf_header.e_machine == EM_ALPHA
11072 || elf_header.e_machine == EM_S390
11073 || elf_header.e_machine == EM_S390_OLD)
11074 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
11075 hash_ent_size = 8;
11076
fb52b2f4
NC		 11077 if (fseek (file,
11078 (archive_file_offset
11079 + offset_from_vma (file, dynamic_info[DT_HASH],
11080 sizeof nb + sizeof nc)),
d93f0186 11081 SEEK_SET))
252b5132 11082 {
591a748a 11083 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 11084 goto no_hash;
252b5132
RH		 11085 }
11086
66543521 11087 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 11088 {
11089 error (_("Failed to read in number of buckets\n"));
d3a44ec6 11090 goto no_hash;
252b5132
RH		 11091 }
11092
66543521 11093 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 11094 {
11095 error (_("Failed to read in number of chains\n"));
d3a44ec6 11096 goto no_hash;
252b5132
RH		 11097 }
11098
66543521
AM		 11099 nbuckets = byte_get (nb, hash_ent_size);
11100 nchains = byte_get (nc, hash_ent_size);
252b5132 11101
66543521
AM		 11102 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
11103 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 11104
d3a44ec6 11105 no_hash:
252b5132 11106 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 11107 {
11108 if (do_using_dynamic)
11109 return 0;
11110 free (buckets);
11111 free (chains);
11112 buckets = NULL;
11113 chains = NULL;
11114 nbuckets = 0;
11115 nchains = 0;
11116 }
252b5132
RH		 11117 }
11118
6bd1a22c
L		 11119 if (dynamic_info_DT_GNU_HASH
11120 && (do_histogram
2c610e4b
L		 11121 || (do_using_dynamic
11122 && !do_dyn_syms
11123 && dynamic_strings != NULL)))
252b5132 11124 {
6bd1a22c
L		 11125 unsigned char nb[16];
11126 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11127 bfd_vma buckets_vma;
11128
11129 if (fseek (file,
11130 (archive_file_offset
11131 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
11132 sizeof nb)),
11133 SEEK_SET))
11134 {
11135 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 11136 goto no_gnu_hash;
6bd1a22c 11137 }
252b5132 11138
6bd1a22c
L		 11139 if (fread (nb, 16, 1, file) != 1)
11140 {
11141 error (_("Failed to read in number of buckets\n"));
d3a44ec6 11142 goto no_gnu_hash;
6bd1a22c
L		 11143 }
11144
11145 ngnubuckets = byte_get (nb, 4);
11146 gnusymidx = byte_get (nb + 4, 4);
11147 bitmaskwords = byte_get (nb + 8, 4);
11148 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 11149 if (is_32bit_elf)
6bd1a22c 11150 buckets_vma += bitmaskwords * 4;
f7a99963 11151 else
6bd1a22c 11152 buckets_vma += bitmaskwords * 8;
252b5132 11153
6bd1a22c
L		 11154 if (fseek (file,
11155 (archive_file_offset
11156 + offset_from_vma (file, buckets_vma, 4)),
11157 SEEK_SET))
252b5132 11158 {
6bd1a22c 11159 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 11160 goto no_gnu_hash;
6bd1a22c
L		 11161 }
11162
11163 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 11164
6bd1a22c 11165 if (gnubuckets == NULL)
d3a44ec6 11166 goto no_gnu_hash;
6bd1a22c
L		 11167
11168 for (i = 0; i < ngnubuckets; i++)
11169 if (gnubuckets[i] != 0)
11170 {
11171 if (gnubuckets[i] < gnusymidx)
11172 return 0;
11173
11174 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11175 maxchain = gnubuckets[i];
11176 }
11177
11178 if (maxchain == 0xffffffff)
d3a44ec6 11179 goto no_gnu_hash;
6bd1a22c
L		 11180
11181 maxchain -= gnusymidx;
11182
11183 if (fseek (file,
11184 (archive_file_offset
11185 + offset_from_vma (file, buckets_vma
11186 + 4 * (ngnubuckets + maxchain), 4)),
11187 SEEK_SET))
11188 {
11189 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 11190 goto no_gnu_hash;
6bd1a22c
L		 11191 }
11192
11193 do
11194 {
11195 if (fread (nb, 4, 1, file) != 1)
252b5132 11196 {
6bd1a22c 11197 error (_("Failed to determine last chain length\n"));
d3a44ec6 11198 goto no_gnu_hash;
6bd1a22c 11199 }
252b5132 11200
6bd1a22c 11201 if (maxchain + 1 == 0)
d3a44ec6 11202 goto no_gnu_hash;
252b5132 11203
6bd1a22c
L		 11204 ++maxchain;
11205 }
11206 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 11207
6bd1a22c
L		 11208 if (fseek (file,
11209 (archive_file_offset
11210 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
11211 SEEK_SET))
11212 {
11213 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 11214 goto no_gnu_hash;
6bd1a22c
L		 11215 }
11216
11217 gnuchains = get_dynamic_data (file, maxchain, 4);
071436c6 11218 ngnuchains = maxchain;
6bd1a22c 11219
d3a44ec6 11220 no_gnu_hash:
6bd1a22c 11221 if (gnuchains == NULL)
d3a44ec6
JJ		 11222 {
11223 free (gnubuckets);
d3a44ec6
JJ		 11224 gnubuckets = NULL;
11225 ngnubuckets = 0;
f64fddf1
NC		 11226 if (do_using_dynamic)
11227 return 0;
d3a44ec6 11228 }
6bd1a22c
L		 11229 }
11230
11231 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11232 && do_syms
11233 && do_using_dynamic
3102e897
NC		 11234 && dynamic_strings != NULL
11235 && dynamic_symbols != NULL)
6bd1a22c
L		 11236 {
11237 unsigned long hn;
11238
11239 if (dynamic_info[DT_HASH])
11240 {
11241 bfd_vma si;
11242
11243 printf (_("\nSymbol table for image:\n"));
11244 if (is_32bit_elf)
11245 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11246 else
11247 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11248
11249 for (hn = 0; hn < nbuckets; hn++)
11250 {
11251 if (! buckets[hn])
11252 continue;
11253
11254 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
11255 print_dynamic_symbol (si, hn);
252b5132
RH		 11256 }
11257 }
6bd1a22c
L		 11258
11259 if (dynamic_info_DT_GNU_HASH)
11260 {
11261 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11262 if (is_32bit_elf)
11263 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11264 else
11265 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11266
11267 for (hn = 0; hn < ngnubuckets; ++hn)
11268 if (gnubuckets[hn] != 0)
11269 {
11270 bfd_vma si = gnubuckets[hn];
11271 bfd_vma off = si - gnusymidx;
11272
11273 do
11274 {
11275 print_dynamic_symbol (si, hn);
11276 si++;
11277 }
071436c6 11278 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
6bd1a22c
L		 11279 }
11280 }
252b5132 11281 }
8b73c356
NC		 11282 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11283 && section_headers != NULL)
252b5132 11284 {
b34976b6 11285 unsigned int i;
252b5132
RH		 11286
11287 for (i = 0, section = section_headers;
11288 i < elf_header.e_shnum;
11289 i++, section++)
11290 {
b34976b6 11291 unsigned int si;
2cf0635d 11292 char * strtab = NULL;
c256ffe7 11293 unsigned long int strtab_size = 0;
2cf0635d
NC		 11294 Elf_Internal_Sym * symtab;
11295 Elf_Internal_Sym * psym;
ba5cdace 11296 unsigned long num_syms;
252b5132 11297
2c610e4b
L		 11298 if ((section->sh_type != SHT_SYMTAB
11299 && section->sh_type != SHT_DYNSYM)
11300 || (!do_syms
11301 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 11302 continue;
11303
dd24e3da
NC		 11304 if (section->sh_entsize == 0)
11305 {
11306 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
74e1a04b 11307 printable_section_name (section));
dd24e3da
NC		 11308 continue;
11309 }
11310
252b5132 11311 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
74e1a04b 11312 printable_section_name (section),
252b5132 11313 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 11314
f7a99963 11315 if (is_32bit_elf)
ca47b30c 11316 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 11317 else
ca47b30c 11318 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 11319
ba5cdace 11320 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 11321 if (symtab == NULL)
11322 continue;
11323
11324 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 11325 {
11326 strtab = string_table;
11327 strtab_size = string_table_length;
11328 }
4fbb74a6 11329 else if (section->sh_link < elf_header.e_shnum)
252b5132 11330 {
2cf0635d 11331 Elf_Internal_Shdr * string_sec;
252b5132 11332
4fbb74a6 11333 string_sec = section_headers + section->sh_link;
252b5132 11334
3f5e193b
NC		 11335 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
11336 1, string_sec->sh_size,
11337 _("string table"));
c256ffe7 11338 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 11339 }
11340
ba5cdace 11341 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 11342 {
bb4d2ac2
L		 11343 const char *version_string;
11344 enum versioned_symbol_info sym_info;
11345 unsigned short vna_other;
11346
5e220199 11347 printf ("%6d: ", si);
f7a99963
NC		 11348 print_vma (psym->st_value, LONG_HEX);
11349 putchar (' ');
11350 print_vma (psym->st_size, DEC_5);
d1133906
NC		 11351 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
11352 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
fd85a6a1
NC		 11353 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11354 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
11355 else
11356 {
11357 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11358
11359 printf (" %-7s", get_symbol_visibility (vis));
11360 /* Check to see if any other bits in the st_other field are set.
11361 Note - displaying this information disrupts the layout of the
11362 table being generated, but for the moment this case is very rare. */
11363 if (psym->st_other ^ vis)
11364 printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
11365 }
31104126 11366 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 11367 print_symbol (25, psym->st_name < strtab_size
2b692964 11368 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 11369
bb4d2ac2
L		 11370 version_string
11371 = get_symbol_version_string (file,
11372 section->sh_type == SHT_DYNSYM,
11373 strtab, strtab_size, si,
11374 psym, &sym_info, &vna_other);
11375 if (version_string)
252b5132 11376 {
bb4d2ac2
L		 11377 if (sym_info == symbol_undefined)
11378 printf ("@%s (%d)", version_string, vna_other);
11379 else
11380 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11381 version_string);
252b5132
RH		 11382 }
11383
11384 putchar ('\n');
52c3c391
NC		 11385
11386 if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
dd905818
NC		 11387 && si >= section->sh_info
11388 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11389 && elf_header.e_machine != EM_MIPS
11390 /* Solaris binaries have been found to violate this requirement as
11391 well. Not sure if this is a bug or an ABI requirement. */
11392 && elf_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
52c3c391
NC		 11393 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11394 si, printable_section_name (section), section->sh_info);
252b5132
RH		 11395 }
11396
11397 free (symtab);
11398 if (strtab != string_table)
11399 free (strtab);
11400 }
11401 }
11402 else if (do_syms)
11403 printf
11404 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11405
11406 if (do_histogram && buckets != NULL)
11407 {
2cf0635d
NC		 11408 unsigned long * lengths;
11409 unsigned long * counts;
66543521
AM		 11410 unsigned long hn;
11411 bfd_vma si;
11412 unsigned long maxlength = 0;
11413 unsigned long nzero_counts = 0;
11414 unsigned long nsyms = 0;
94d15024 11415 unsigned long chained;
252b5132 11416
66543521
AM		 11417 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11418 (unsigned long) nbuckets);
252b5132 11419
3f5e193b 11420 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 11421 if (lengths == NULL)
11422 {
8b73c356 11423 error (_("Out of memory allocating space for histogram buckets\n"));
252b5132
RH		 11424 return 0;
11425 }
8b73c356
NC		 11426
11427 printf (_(" Length Number %% of total Coverage\n"));
252b5132
RH		 11428 for (hn = 0; hn < nbuckets; ++hn)
11429 {
94d15024
MF		 11430 for (si = buckets[hn], chained = 0;
11431 si > 0 && si < nchains && si < nbuckets && chained <= nchains;
11432 si = chains[si], ++chained)
252b5132 11433 {
b34976b6 11434 ++nsyms;
252b5132 11435 if (maxlength < ++lengths[hn])
b34976b6 11436 ++maxlength;
252b5132 11437 }
94d15024
MF		 11438
11439 /* PR binutils/17531: A corrupt binary could contain broken
11440 histogram data. Do not go into an infinite loop trying
11441 to process it. */
11442 if (chained > nchains)
11443 {
11444 error (_("histogram chain is corrupt\n"));
11445 break;
11446 }
252b5132
RH		 11447 }
11448
3f5e193b 11449 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 11450 if (counts == NULL)
11451 {
b2e951ec 11452 free (lengths);
8b73c356 11453 error (_("Out of memory allocating space for histogram counts\n"));
252b5132
RH		 11454 return 0;
11455 }
11456
11457 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 11458 ++counts[lengths[hn]];
252b5132 11459
103f02d3 11460 if (nbuckets > 0)
252b5132 11461 {
66543521
AM		 11462 unsigned long i;
11463 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 11464 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 11465 for (i = 1; i <= maxlength; ++i)
103f02d3 11466 {
66543521
AM		 11467 nzero_counts += counts[i] * i;
11468 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11469 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 11470 (nzero_counts * 100.0) / nsyms);
11471 }
252b5132
RH		 11472 }
11473
11474 free (counts);
11475 free (lengths);
11476 }
11477
11478 if (buckets != NULL)
11479 {
11480 free (buckets);
11481 free (chains);
11482 }
11483
d3a44ec6 11484 if (do_histogram && gnubuckets != NULL)
fdc90cb4 11485 {
2cf0635d
NC		 11486 unsigned long * lengths;
11487 unsigned long * counts;
fdc90cb4
JJ		 11488 unsigned long hn;
11489 unsigned long maxlength = 0;
11490 unsigned long nzero_counts = 0;
11491 unsigned long nsyms = 0;
fdc90cb4 11492
8b73c356
NC		 11493 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11494 (unsigned long) ngnubuckets);
11495
3f5e193b 11496 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 11497 if (lengths == NULL)
11498 {
8b73c356 11499 error (_("Out of memory allocating space for gnu histogram buckets\n"));
fdc90cb4
JJ		 11500 return 0;
11501 }
11502
fdc90cb4
JJ		 11503 printf (_(" Length Number %% of total Coverage\n"));
11504
11505 for (hn = 0; hn < ngnubuckets; ++hn)
11506 if (gnubuckets[hn] != 0)
11507 {
11508 bfd_vma off, length = 1;
11509
6bd1a22c 11510 for (off = gnubuckets[hn] - gnusymidx;
071436c6
NC		 11511 /* PR 17531 file: 010-77222-0.004. */
11512 off < ngnuchains && (gnuchains[off] & 1) == 0;
11513 ++off)
fdc90cb4
JJ		 11514 ++length;
11515 lengths[hn] = length;
11516 if (length > maxlength)
11517 maxlength = length;
11518 nsyms += length;
11519 }
11520
3f5e193b 11521 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 11522 if (counts == NULL)
11523 {
b2e951ec 11524 free (lengths);
8b73c356 11525 error (_("Out of memory allocating space for gnu histogram counts\n"));
fdc90cb4
JJ		 11526 return 0;
11527 }
11528
11529 for (hn = 0; hn < ngnubuckets; ++hn)
11530 ++counts[lengths[hn]];
11531
11532 if (ngnubuckets > 0)
11533 {
11534 unsigned long j;
11535 printf (" 0 %-10lu (%5.1f%%)\n",
11536 counts[0], (counts[0] * 100.0) / ngnubuckets);
11537 for (j = 1; j <= maxlength; ++j)
11538 {
11539 nzero_counts += counts[j] * j;
11540 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11541 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11542 (nzero_counts * 100.0) / nsyms);
11543 }
11544 }
11545
11546 free (counts);
11547 free (lengths);
11548 free (gnubuckets);
11549 free (gnuchains);
11550 }
11551
252b5132
RH		 11552 return 1;
11553}
11554
11555static int
2cf0635d 11556process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 11557{
b4c96d0d 11558 unsigned int i;
252b5132
RH		 11559
11560 if (dynamic_syminfo == NULL
11561 || !do_dynamic)
11562 /* No syminfo, this is ok. */
11563 return 1;
11564
11565 /* There better should be a dynamic symbol section. */
11566 if (dynamic_symbols == NULL || dynamic_strings == NULL)
11567 return 0;
11568
11569 if (dynamic_addr)
11570 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11571 dynamic_syminfo_offset, dynamic_syminfo_nent);
11572
11573 printf (_(" Num: Name BoundTo Flags\n"));
11574 for (i = 0; i < dynamic_syminfo_nent; ++i)
11575 {
11576 unsigned short int flags = dynamic_syminfo[i].si_flags;
11577
31104126 11578 printf ("%4d: ", i);
4082ef84
NC		 11579 if (i >= num_dynamic_syms)
11580 printf (_("<corrupt index>"));
11581 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
d79b3d50
NC		 11582 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11583 else
2b692964 11584 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 11585 putchar (' ');
252b5132
RH		 11586
11587 switch (dynamic_syminfo[i].si_boundto)
11588 {
11589 case SYMINFO_BT_SELF:
11590 fputs ("SELF ", stdout);
11591 break;
11592 case SYMINFO_BT_PARENT:
11593 fputs ("PARENT ", stdout);
11594 break;
11595 default:
11596 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 11597 && dynamic_syminfo[i].si_boundto < dynamic_nent
11598 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 11599 {
d79b3d50 11600 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 11601 putchar (' ' );
11602 }
252b5132
RH		 11603 else
11604 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11605 break;
11606 }
11607
11608 if (flags & SYMINFO_FLG_DIRECT)
11609 printf (" DIRECT");
11610 if (flags & SYMINFO_FLG_PASSTHRU)
11611 printf (" PASSTHRU");
11612 if (flags & SYMINFO_FLG_COPY)
11613 printf (" COPY");
11614 if (flags & SYMINFO_FLG_LAZYLOAD)
11615 printf (" LAZYLOAD");
11616
11617 puts ("");
11618 }
11619
11620 return 1;
11621}
11622
b32e566b
NC		 11623#define IN_RANGE(START,END,ADDR,OFF) \
11624 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11625
cf13d699
NC		 11626/* Check to see if the given reloc needs to be handled in a target specific
11627 manner. If so then process the reloc and return TRUE otherwise return
f84ce13b
NC		 11628 FALSE.
11629
11630 If called with reloc == NULL, then this is a signal that reloc processing
11631 for the current section has finished, and any saved state should be
11632 discarded. */
09c11c86 11633
cf13d699
NC		 11634static bfd_boolean
11635target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11636 unsigned char * start,
03f7786e 11637 unsigned char * end,
f84ce13b
NC		 11638 Elf_Internal_Sym * symtab,
11639 unsigned long num_syms)
252b5132 11640{
f84ce13b
NC		 11641 unsigned int reloc_type = 0;
11642 unsigned long sym_index = 0;
11643
11644 if (reloc)
11645 {
11646 reloc_type = get_reloc_type (reloc->r_info);
11647 sym_index = get_reloc_symindex (reloc->r_info);
11648 }
252b5132 11649
cf13d699 11650 switch (elf_header.e_machine)
252b5132 11651 {
13761a11
NC		 11652 case EM_MSP430:
11653 case EM_MSP430_OLD:
11654 {
11655 static Elf_Internal_Sym * saved_sym = NULL;
11656
f84ce13b
NC		 11657 if (reloc == NULL)
11658 {
11659 saved_sym = NULL;
11660 return TRUE;
11661 }
11662
13761a11
NC		 11663 switch (reloc_type)
11664 {
11665 case 10: /* R_MSP430_SYM_DIFF */
11666 if (uses_msp430x_relocs ())
11667 break;
1a0670f3 11668 /* Fall through. */
13761a11 11669 case 21: /* R_MSP430X_SYM_DIFF */
f84ce13b
NC		 11670 /* PR 21139. */
11671 if (sym_index >= num_syms)
11672 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11673 sym_index);
11674 else
11675 saved_sym = symtab + sym_index;
13761a11
NC		 11676 return TRUE;
11677
11678 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11679 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11680 goto handle_sym_diff;
0b4362b0 11681
13761a11
NC		 11682 case 5: /* R_MSP430_16_BYTE */
11683 case 9: /* R_MSP430_8 */
11684 if (uses_msp430x_relocs ())
11685 break;
11686 goto handle_sym_diff;
11687
11688 case 2: /* R_MSP430_ABS16 */
11689 case 15: /* R_MSP430X_ABS16 */
11690 if (! uses_msp430x_relocs ())
11691 break;
11692 goto handle_sym_diff;
0b4362b0 11693
13761a11
NC		 11694 handle_sym_diff:
11695 if (saved_sym != NULL)
11696 {
03f7786e 11697 int reloc_size = reloc_type == 1 ? 4 : 2;
13761a11
NC		 11698 bfd_vma value;
11699
f84ce13b
NC		 11700 if (sym_index >= num_syms)
11701 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
11702 sym_index);
03f7786e 11703 else
f84ce13b
NC		 11704 {
11705 value = reloc->r_addend + (symtab[sym_index].st_value
11706 - saved_sym->st_value);
11707
b32e566b 11708 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
f84ce13b 11709 byte_put (start + reloc->r_offset, value, reloc_size);
b32e566b
NC		 11710 else
11711 /* PR 21137 */
11712 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
11713 (long) reloc->r_offset);
f84ce13b 11714 }
13761a11
NC		 11715
11716 saved_sym = NULL;
11717 return TRUE;
11718 }
11719 break;
11720
11721 default:
11722 if (saved_sym != NULL)
071436c6 11723 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13761a11
NC		 11724 break;
11725 }
11726 break;
11727 }
11728
cf13d699
NC		 11729 case EM_MN10300:
11730 case EM_CYGNUS_MN10300:
11731 {
11732 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 11733
f84ce13b
NC		 11734 if (reloc == NULL)
11735 {
11736 saved_sym = NULL;
11737 return TRUE;
11738 }
11739
cf13d699
NC		 11740 switch (reloc_type)
11741 {
11742 case 34: /* R_MN10300_ALIGN */
11743 return TRUE;
11744 case 33: /* R_MN10300_SYM_DIFF */
f84ce13b
NC		 11745 if (sym_index >= num_syms)
11746 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
11747 sym_index);
11748 else
11749 saved_sym = symtab + sym_index;
cf13d699 11750 return TRUE;
f84ce13b 11751
cf13d699
NC		 11752 case 1: /* R_MN10300_32 */
11753 case 2: /* R_MN10300_16 */
11754 if (saved_sym != NULL)
11755 {
03f7786e 11756 int reloc_size = reloc_type == 1 ? 4 : 2;
cf13d699 11757 bfd_vma value;
252b5132 11758
f84ce13b
NC		 11759 if (sym_index >= num_syms)
11760 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
11761 sym_index);
03f7786e 11762 else
f84ce13b
NC		 11763 {
11764 value = reloc->r_addend + (symtab[sym_index].st_value
11765 - saved_sym->st_value);
11766
b32e566b 11767 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
f84ce13b 11768 byte_put (start + reloc->r_offset, value, reloc_size);
b32e566b
NC		 11769 else
11770 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
11771 (long) reloc->r_offset);
f84ce13b 11772 }
252b5132 11773
cf13d699
NC		 11774 saved_sym = NULL;
11775 return TRUE;
11776 }
11777 break;
11778 default:
11779 if (saved_sym != NULL)
071436c6 11780 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
cf13d699
NC		 11781 break;
11782 }
11783 break;
11784 }
6ff71e76
NC		 11785
11786 case EM_RL78:
11787 {
11788 static bfd_vma saved_sym1 = 0;
11789 static bfd_vma saved_sym2 = 0;
11790 static bfd_vma value;
11791
f84ce13b
NC		 11792 if (reloc == NULL)
11793 {
11794 saved_sym1 = saved_sym2 = 0;
11795 return TRUE;
11796 }
11797
6ff71e76
NC		 11798 switch (reloc_type)
11799 {
11800 case 0x80: /* R_RL78_SYM. */
11801 saved_sym1 = saved_sym2;
f84ce13b
NC		 11802 if (sym_index >= num_syms)
11803 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
11804 sym_index);
11805 else
11806 {
11807 saved_sym2 = symtab[sym_index].st_value;
11808 saved_sym2 += reloc->r_addend;
11809 }
6ff71e76
NC		 11810 return TRUE;
11811
11812 case 0x83: /* R_RL78_OPsub. */
11813 value = saved_sym1 - saved_sym2;
11814 saved_sym2 = saved_sym1 = 0;
11815 return TRUE;
11816 break;
11817
11818 case 0x41: /* R_RL78_ABS32. */
b32e566b 11819 if (IN_RANGE (start, end, start + reloc->r_offset, 4))
03f7786e 11820 byte_put (start + reloc->r_offset, value, 4);
b32e566b
NC		 11821 else
11822 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11823 (long) reloc->r_offset);
6ff71e76
NC		 11824 value = 0;
11825 return TRUE;
11826
11827 case 0x43: /* R_RL78_ABS16. */
b32e566b 11828 if (IN_RANGE (start, end, start + reloc->r_offset, 2))
03f7786e 11829 byte_put (start + reloc->r_offset, value, 2);
b32e566b
NC		 11830 else
11831 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11832 (long) reloc->r_offset);
6ff71e76
NC		 11833 value = 0;
11834 return TRUE;
11835
11836 default:
11837 break;
11838 }
11839 break;
11840 }
252b5132
RH		 11841 }
11842
cf13d699 11843 return FALSE;
252b5132
RH		 11844}
11845
aca88567
NC		 11846/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11847 DWARF debug sections. This is a target specific test. Note - we do not
11848 go through the whole including-target-headers-multiple-times route, (as
11849 we have already done with <elf/h8.h>) because this would become very
11850 messy and even then this function would have to contain target specific
11851 information (the names of the relocs instead of their numeric values).
11852 FIXME: This is not the correct way to solve this problem. The proper way
11853 is to have target specific reloc sizing and typing functions created by
11854 the reloc-macros.h header, in the same way that it already creates the
11855 reloc naming functions. */
11856
11857static bfd_boolean
11858is_32bit_abs_reloc (unsigned int reloc_type)
11859{
d347c9df 11860 /* Please keep this table alpha-sorted for ease of visual lookup. */
aca88567
NC		 11861 switch (elf_header.e_machine)
11862 {
41e92641 11863 case EM_386:
22abe556 11864 case EM_IAMCU:
41e92641 11865 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 11866 case EM_68K:
11867 return reloc_type == 1; /* R_68K_32. */
11868 case EM_860:
11869 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 11870 case EM_960:
11871 return reloc_type == 2; /* R_960_32. */
a06ea964 11872 case EM_AARCH64:
9282b95a
JW		 11873 return (reloc_type == 258
11874 || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
d347c9df
PS		 11875 case EM_ADAPTEVA_EPIPHANY:
11876 return reloc_type == 3;
aca88567 11877 case EM_ALPHA:
137b6b5f 11878 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 11879 case EM_ARC:
11880 return reloc_type == 1; /* R_ARC_32. */
886a2506
NC		 11881 case EM_ARC_COMPACT:
11882 case EM_ARC_COMPACT2:
11883 return reloc_type == 4; /* R_ARC_32. */
41e92641
NC		 11884 case EM_ARM:
11885 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 11886 case EM_AVR_OLD:
aca88567
NC		 11887 case EM_AVR:
11888 return reloc_type == 1;
11889 case EM_BLACKFIN:
11890 return reloc_type == 0x12; /* R_byte4_data. */
11891 case EM_CRIS:
11892 return reloc_type == 3; /* R_CRIS_32. */
11893 case EM_CR16:
11894 return reloc_type == 3; /* R_CR16_NUM32. */
11895 case EM_CRX:
11896 return reloc_type == 15; /* R_CRX_NUM32. */
11897 case EM_CYGNUS_FRV:
11898 return reloc_type == 1;
41e92641
NC		 11899 case EM_CYGNUS_D10V:
11900 case EM_D10V:
11901 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 11902 case EM_CYGNUS_D30V:
11903 case EM_D30V:
11904 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 11905 case EM_DLX:
11906 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 11907 case EM_CYGNUS_FR30:
11908 case EM_FR30:
11909 return reloc_type == 3; /* R_FR30_32. */
3f8107ab
AM		 11910 case EM_FT32:
11911 return reloc_type == 1; /* R_FT32_32. */
aca88567
NC		 11912 case EM_H8S:
11913 case EM_H8_300:
11914 case EM_H8_300H:
11915 return reloc_type == 1; /* R_H8_DIR32. */
3730236a 11916 case EM_IA_64:
d1c4b12b
NC		 11917 return reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
11918 || reloc_type == 0x25; /* R_IA64_DIR32LSB. */
aca88567
NC		 11919 case EM_IP2K_OLD:
11920 case EM_IP2K:
11921 return reloc_type == 2; /* R_IP2K_32. */
11922 case EM_IQ2000:
11923 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 11924 case EM_LATTICEMICO32:
11925 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 11926 case EM_M32C_OLD:
aca88567
NC		 11927 case EM_M32C:
11928 return reloc_type == 3; /* R_M32C_32. */
11929 case EM_M32R:
11930 return reloc_type == 34; /* R_M32R_32_RELA. */
adec12c1
AM		 11931 case EM_68HC11:
11932 case EM_68HC12:
11933 return reloc_type == 6; /* R_M68HC11_32. */
aca88567
NC		 11934 case EM_MCORE:
11935 return reloc_type == 1; /* R_MCORE_ADDR32. */
11936 case EM_CYGNUS_MEP:
11937 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 11938 case EM_METAG:
11939 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 11940 case EM_MICROBLAZE:
11941 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 11942 case EM_MIPS:
11943 return reloc_type == 2; /* R_MIPS_32. */
11944 case EM_MMIX:
11945 return reloc_type == 4; /* R_MMIX_32. */
11946 case EM_CYGNUS_MN10200:
11947 case EM_MN10200:
11948 return reloc_type == 1; /* R_MN10200_32. */
11949 case EM_CYGNUS_MN10300:
11950 case EM_MN10300:
11951 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 11952 case EM_MOXIE:
11953 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 11954 case EM_MSP430_OLD:
11955 case EM_MSP430:
13761a11 11956 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
aca88567
NC		 11957 case EM_MT:
11958 return reloc_type == 2; /* R_MT_32. */
35c08157
KLC		 11959 case EM_NDS32:
11960 return reloc_type == 20; /* R_NDS32_RELA. */
3e0873ac 11961 case EM_ALTERA_NIOS2:
36591ba1 11962 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
3e0873ac
NC		 11963 case EM_NIOS32:
11964 return reloc_type == 1; /* R_NIOS_32. */
73589c9d
CS		 11965 case EM_OR1K:
11966 return reloc_type == 1; /* R_OR1K_32. */
aca88567 11967 case EM_PARISC:
5fda8eca
NC		 11968 return (reloc_type == 1 /* R_PARISC_DIR32. */
11969 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 11970 case EM_PJ:
11971 case EM_PJ_OLD:
11972 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
11973 case EM_PPC64:
11974 return reloc_type == 1; /* R_PPC64_ADDR32. */
11975 case EM_PPC:
11976 return reloc_type == 1; /* R_PPC_ADDR32. */
2b100bb5
DD		 11977 case EM_TI_PRU:
11978 return reloc_type == 11; /* R_PRU_BFD_RELOC_32. */
e23eba97
NC		 11979 case EM_RISCV:
11980 return reloc_type == 1; /* R_RISCV_32. */
99c513f6
DD		 11981 case EM_RL78:
11982 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 11983 case EM_RX:
11984 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 11985 case EM_S370:
11986 return reloc_type == 1; /* R_I370_ADDR31. */
11987 case EM_S390_OLD:
11988 case EM_S390:
11989 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 11990 case EM_SCORE:
11991 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 11992 case EM_SH:
11993 return reloc_type == 1; /* R_SH_DIR32. */
11994 case EM_SPARC32PLUS:
11995 case EM_SPARCV9:
11996 case EM_SPARC:
11997 return reloc_type == 3 /* R_SPARC_32. */
11998 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 11999 case EM_SPU:
12000 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 12001 case EM_TI_C6000:
12002 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 12003 case EM_TILEGX:
12004 return reloc_type == 2; /* R_TILEGX_32. */
12005 case EM_TILEPRO:
12006 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 12007 case EM_CYGNUS_V850:
12008 case EM_V850:
12009 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 12010 case EM_V800:
12011 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 12012 case EM_VAX:
12013 return reloc_type == 1; /* R_VAX_32. */
619ed720
EB		 12014 case EM_VISIUM:
12015 return reloc_type == 3; /* R_VISIUM_32. */
aca88567 12016 case EM_X86_64:
8a9036a4 12017 case EM_L1OM:
7a9068fe 12018 case EM_K1OM:
aca88567 12019 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 12020 case EM_XC16X:
12021 case EM_C166:
12022 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 12023 case EM_XGATE:
12024 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 12025 case EM_XSTORMY16:
12026 return reloc_type == 1; /* R_XSTROMY16_32. */
12027 case EM_XTENSA_OLD:
12028 case EM_XTENSA:
12029 return reloc_type == 1; /* R_XTENSA_32. */
aca88567 12030 default:
bee0ee85
NC		 12031 {
12032 static unsigned int prev_warn = 0;
12033
12034 /* Avoid repeating the same warning multiple times. */
12035 if (prev_warn != elf_header.e_machine)
12036 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12037 elf_header.e_machine);
12038 prev_warn = elf_header.e_machine;
12039 return FALSE;
12040 }
aca88567
NC		 12041 }
12042}
12043
12044/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12045 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12046
12047static bfd_boolean
12048is_32bit_pcrel_reloc (unsigned int reloc_type)
12049{
12050 switch (elf_header.e_machine)
d347c9df 12051 /* Please keep this table alpha-sorted for ease of visual lookup. */
aca88567 12052 {
41e92641 12053 case EM_386:
22abe556 12054 case EM_IAMCU:
3e0873ac 12055 return reloc_type == 2; /* R_386_PC32. */
aca88567 12056 case EM_68K:
3e0873ac 12057 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 12058 case EM_AARCH64:
12059 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 12060 case EM_ADAPTEVA_EPIPHANY:
12061 return reloc_type == 6;
aca88567
NC		 12062 case EM_ALPHA:
12063 return reloc_type == 10; /* R_ALPHA_SREL32. */
726c18e1
CZ		 12064 case EM_ARC_COMPACT:
12065 case EM_ARC_COMPACT2:
12066 return reloc_type == 49; /* R_ARC_32_PCREL. */
41e92641 12067 case EM_ARM:
3e0873ac 12068 return reloc_type == 3; /* R_ARM_REL32 */
d347c9df
PS		 12069 case EM_AVR_OLD:
12070 case EM_AVR:
12071 return reloc_type == 36; /* R_AVR_32_PCREL. */
137b6b5f
AM		 12072 case EM_MICROBLAZE:
12073 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
73589c9d
CS		 12074 case EM_OR1K:
12075 return reloc_type == 9; /* R_OR1K_32_PCREL. */
aca88567 12076 case EM_PARISC:
85acf597 12077 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 12078 case EM_PPC:
12079 return reloc_type == 26; /* R_PPC_REL32. */
12080 case EM_PPC64:
3e0873ac 12081 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 12082 case EM_S390_OLD:
12083 case EM_S390:
3e0873ac 12084 return reloc_type == 5; /* R_390_PC32. */
aca88567 12085 case EM_SH:
3e0873ac 12086 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 12087 case EM_SPARC32PLUS:
12088 case EM_SPARCV9:
12089 case EM_SPARC:
3e0873ac 12090 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 12091 case EM_SPU:
12092 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 12093 case EM_TILEGX:
12094 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
12095 case EM_TILEPRO:
12096 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
619ed720
EB		 12097 case EM_VISIUM:
12098 return reloc_type == 6; /* R_VISIUM_32_PCREL */
aca88567 12099 case EM_X86_64:
8a9036a4 12100 case EM_L1OM:
7a9068fe 12101 case EM_K1OM:
3e0873ac 12102 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 12103 case EM_XTENSA_OLD:
12104 case EM_XTENSA:
12105 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 12106 default:
12107 /* Do not abort or issue an error message here. Not all targets use
12108 pc-relative 32-bit relocs in their DWARF debug information and we
12109 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 12110 more helpful warning message will be generated by apply_relocations
12111 anyway, so just return. */
aca88567
NC		 12112 return FALSE;
12113 }
12114}
12115
12116/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12117 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12118
12119static bfd_boolean
12120is_64bit_abs_reloc (unsigned int reloc_type)
12121{
12122 switch (elf_header.e_machine)
12123 {
a06ea964
NC		 12124 case EM_AARCH64:
12125 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 12126 case EM_ALPHA:
12127 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 12128 case EM_IA_64:
12129 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 12130 case EM_PARISC:
12131 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 12132 case EM_PPC64:
12133 return reloc_type == 38; /* R_PPC64_ADDR64. */
e23eba97
NC		 12134 case EM_RISCV:
12135 return reloc_type == 2; /* R_RISCV_64. */
aca88567
NC		 12136 case EM_SPARC32PLUS:
12137 case EM_SPARCV9:
12138 case EM_SPARC:
12139 return reloc_type == 54; /* R_SPARC_UA64. */
12140 case EM_X86_64:
8a9036a4 12141 case EM_L1OM:
7a9068fe 12142 case EM_K1OM:
aca88567 12143 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 12144 case EM_S390_OLD:
12145 case EM_S390:
aa137e4d
NC		 12146 return reloc_type == 22; /* R_S390_64. */
12147 case EM_TILEGX:
12148 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 12149 case EM_MIPS:
aa137e4d 12150 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 12151 default:
12152 return FALSE;
12153 }
12154}
12155
85acf597
RH		 12156/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12157 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12158
12159static bfd_boolean
12160is_64bit_pcrel_reloc (unsigned int reloc_type)
12161{
12162 switch (elf_header.e_machine)
12163 {
a06ea964
NC		 12164 case EM_AARCH64:
12165 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 12166 case EM_ALPHA:
aa137e4d 12167 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 12168 case EM_IA_64:
aa137e4d 12169 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 12170 case EM_PARISC:
aa137e4d 12171 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 12172 case EM_PPC64:
aa137e4d 12173 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 12174 case EM_SPARC32PLUS:
12175 case EM_SPARCV9:
12176 case EM_SPARC:
aa137e4d 12177 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 12178 case EM_X86_64:
8a9036a4 12179 case EM_L1OM:
7a9068fe 12180 case EM_K1OM:
aa137e4d 12181 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 12182 case EM_S390_OLD:
12183 case EM_S390:
aa137e4d
NC		 12184 return reloc_type == 23; /* R_S390_PC64. */
12185 case EM_TILEGX:
12186 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 12187 default:
12188 return FALSE;
12189 }
12190}
12191
4dc3c23d
AM		 12192/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12193 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12194
12195static bfd_boolean
12196is_24bit_abs_reloc (unsigned int reloc_type)
12197{
12198 switch (elf_header.e_machine)
12199 {
12200 case EM_CYGNUS_MN10200:
12201 case EM_MN10200:
12202 return reloc_type == 4; /* R_MN10200_24. */
3ee6e4fb
NC		 12203 case EM_FT32:
12204 return reloc_type == 5; /* R_FT32_20. */
4dc3c23d
AM		 12205 default:
12206 return FALSE;
12207 }
12208}
12209
aca88567
NC		 12210/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12211 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12212
12213static bfd_boolean
12214is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a 12215{
d347c9df 12216 /* Please keep this table alpha-sorted for ease of visual lookup. */
4b78141a
NC		 12217 switch (elf_header.e_machine)
12218 {
886a2506
NC		 12219 case EM_ARC:
12220 case EM_ARC_COMPACT:
12221 case EM_ARC_COMPACT2:
12222 return reloc_type == 2; /* R_ARC_16. */
d347c9df
PS		 12223 case EM_ADAPTEVA_EPIPHANY:
12224 return reloc_type == 5;
aca88567
NC		 12225 case EM_AVR_OLD:
12226 case EM_AVR:
12227 return reloc_type == 4; /* R_AVR_16. */
41e92641
NC		 12228 case EM_CYGNUS_D10V:
12229 case EM_D10V:
12230 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 12231 case EM_H8S:
12232 case EM_H8_300:
12233 case EM_H8_300H:
aca88567
NC		 12234 return reloc_type == R_H8_DIR16;
12235 case EM_IP2K_OLD:
12236 case EM_IP2K:
12237 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 12238 case EM_M32C_OLD:
f4236fe4
DD		 12239 case EM_M32C:
12240 return reloc_type == 1; /* R_M32C_16 */
d347c9df
PS		 12241 case EM_CYGNUS_MN10200:
12242 case EM_MN10200:
12243 return reloc_type == 2; /* R_MN10200_16. */
12244 case EM_CYGNUS_MN10300:
12245 case EM_MN10300:
12246 return reloc_type == 2; /* R_MN10300_16. */
aca88567 12247 case EM_MSP430:
13761a11
NC		 12248 if (uses_msp430x_relocs ())
12249 return reloc_type == 2; /* R_MSP430_ABS16. */
1a0670f3 12250 /* Fall through. */
78c8d46c 12251 case EM_MSP430_OLD:
aca88567 12252 return reloc_type == 5; /* R_MSP430_16_BYTE. */
35c08157
KLC		 12253 case EM_NDS32:
12254 return reloc_type == 19; /* R_NDS32_RELA. */
3e0873ac 12255 case EM_ALTERA_NIOS2:
36591ba1 12256 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
3e0873ac
NC		 12257 case EM_NIOS32:
12258 return reloc_type == 9; /* R_NIOS_16. */
73589c9d
CS		 12259 case EM_OR1K:
12260 return reloc_type == 2; /* R_OR1K_16. */
2b100bb5
DD		 12261 case EM_TI_PRU:
12262 return reloc_type == 8; /* R_PRU_BFD_RELOC_16. */
40b36596
JM		 12263 case EM_TI_C6000:
12264 return reloc_type == 2; /* R_C6000_ABS16. */
d347c9df
PS		 12265 case EM_VISIUM:
12266 return reloc_type == 2; /* R_VISIUM_16. */
c29aca4a
NC		 12267 case EM_XC16X:
12268 case EM_C166:
12269 return reloc_type == 2; /* R_XC16C_ABS_16. */
f6c1a2d5
NC		 12270 case EM_XGATE:
12271 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 12272 default:
aca88567 12273 return FALSE;
4b78141a
NC		 12274 }
12275}
12276
2a7b2e88
JK		 12277/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12278 relocation entries (possibly formerly used for SHT_GROUP sections). */
12279
12280static bfd_boolean
12281is_none_reloc (unsigned int reloc_type)
12282{
12283 switch (elf_header.e_machine)
12284 {
cb8f3167 12285 case EM_386: /* R_386_NONE. */
d347c9df 12286 case EM_68K: /* R_68K_NONE. */
cfb8c092 12287 case EM_ADAPTEVA_EPIPHANY:
d347c9df
PS		 12288 case EM_ALPHA: /* R_ALPHA_NONE. */
12289 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
886a2506 12290 case EM_ARC: /* R_ARC_NONE. */
886a2506 12291 case EM_ARC_COMPACT2: /* R_ARC_NONE. */
d347c9df 12292 case EM_ARC_COMPACT: /* R_ARC_NONE. */
cb8f3167 12293 case EM_ARM: /* R_ARM_NONE. */
d347c9df 12294 case EM_C166: /* R_XC16X_NONE. */
cb8f3167 12295 case EM_CRIS: /* R_CRIS_NONE. */
d347c9df
PS		 12296 case EM_FT32: /* R_FT32_NONE. */
12297 case EM_IA_64: /* R_IA64_NONE. */
7a9068fe 12298 case EM_K1OM: /* R_X86_64_NONE. */
d347c9df
PS		 12299 case EM_L1OM: /* R_X86_64_NONE. */
12300 case EM_M32R: /* R_M32R_NONE. */
12301 case EM_MIPS: /* R_MIPS_NONE. */
cb8f3167 12302 case EM_MN10300: /* R_MN10300_NONE. */
5506d11a 12303 case EM_MOXIE: /* R_MOXIE_NONE. */
d347c9df
PS		 12304 case EM_NIOS32: /* R_NIOS_NONE. */
12305 case EM_OR1K: /* R_OR1K_NONE. */
12306 case EM_PARISC: /* R_PARISC_NONE. */
12307 case EM_PPC64: /* R_PPC64_NONE. */
12308 case EM_PPC: /* R_PPC_NONE. */
e23eba97 12309 case EM_RISCV: /* R_RISCV_NONE. */
d347c9df
PS		 12310 case EM_S390: /* R_390_NONE. */
12311 case EM_S390_OLD:
12312 case EM_SH: /* R_SH_NONE. */
12313 case EM_SPARC32PLUS:
12314 case EM_SPARC: /* R_SPARC_NONE. */
12315 case EM_SPARCV9:
aa137e4d
NC		 12316 case EM_TILEGX: /* R_TILEGX_NONE. */
12317 case EM_TILEPRO: /* R_TILEPRO_NONE. */
d347c9df
PS		 12318 case EM_TI_C6000:/* R_C6000_NONE. */
12319 case EM_X86_64: /* R_X86_64_NONE. */
c29aca4a 12320 case EM_XC16X:
cb8f3167 12321 return reloc_type == 0;
d347c9df 12322
a06ea964
NC		 12323 case EM_AARCH64:
12324 return reloc_type == 0 || reloc_type == 256;
d347c9df
PS		 12325 case EM_AVR_OLD:
12326 case EM_AVR:
12327 return (reloc_type == 0 /* R_AVR_NONE. */
12328 || reloc_type == 30 /* R_AVR_DIFF8. */
12329 || reloc_type == 31 /* R_AVR_DIFF16. */
12330 || reloc_type == 32 /* R_AVR_DIFF32. */);
12331 case EM_METAG:
12332 return reloc_type == 3; /* R_METAG_NONE. */
35c08157
KLC		 12333 case EM_NDS32:
12334 return (reloc_type == 0 /* R_XTENSA_NONE. */
12335 || reloc_type == 204 /* R_NDS32_DIFF8. */
12336 || reloc_type == 205 /* R_NDS32_DIFF16. */
12337 || reloc_type == 206 /* R_NDS32_DIFF32. */
12338 || reloc_type == 207 /* R_NDS32_ULEB128. */);
2b100bb5
DD		 12339 case EM_TI_PRU:
12340 return (reloc_type == 0 /* R_PRU_NONE. */
12341 || reloc_type == 65 /* R_PRU_DIFF8. */
12342 || reloc_type == 66 /* R_PRU_DIFF16. */
12343 || reloc_type == 67 /* R_PRU_DIFF32. */);
58332dda
JK		 12344 case EM_XTENSA_OLD:
12345 case EM_XTENSA:
4dc3c23d
AM		 12346 return (reloc_type == 0 /* R_XTENSA_NONE. */
12347 || reloc_type == 17 /* R_XTENSA_DIFF8. */
12348 || reloc_type == 18 /* R_XTENSA_DIFF16. */
12349 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
2a7b2e88
JK		 12350 }
12351 return FALSE;
12352}
12353
d1c4b12b
NC		 12354/* Returns TRUE if there is a relocation against
12355 section NAME at OFFSET bytes. */
12356
12357bfd_boolean
12358reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
12359{
12360 Elf_Internal_Rela * relocs;
12361 Elf_Internal_Rela * rp;
12362
12363 if (dsec == NULL || dsec->reloc_info == NULL)
12364 return FALSE;
12365
12366 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
12367
12368 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
12369 if (rp->r_offset == offset)
12370 return TRUE;
12371
12372 return FALSE;
12373}
12374
cf13d699
NC		 12375/* Apply relocations to a section.
12376 Note: So far support has been added only for those relocations
12377 which can be found in debug sections.
d1c4b12b
NC		 12378 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
12379 loaded relocs. It is then the caller's responsibility to free them.
cf13d699 12380 FIXME: Add support for more relocations ? */
1b315056 12381
cf13d699 12382static void
d1c4b12b
NC		 12383apply_relocations (void * file,
12384 const Elf_Internal_Shdr * section,
12385 unsigned char * start,
12386 bfd_size_type size,
1449284b 12387 void ** relocs_return,
d1c4b12b 12388 unsigned long * num_relocs_return)
1b315056 12389{
cf13d699 12390 Elf_Internal_Shdr * relsec;
0d2a7a93 12391 unsigned char * end = start + size;
cb8f3167 12392
d1c4b12b
NC		 12393 if (relocs_return != NULL)
12394 {
12395 * (Elf_Internal_Rela **) relocs_return = NULL;
12396 * num_relocs_return = 0;
12397 }
12398
cf13d699
NC		 12399 if (elf_header.e_type != ET_REL)
12400 return;
1b315056 12401
cf13d699 12402 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 12403 for (relsec = section_headers;
12404 relsec < section_headers + elf_header.e_shnum;
12405 ++relsec)
252b5132 12406 {
41e92641
NC		 12407 bfd_boolean is_rela;
12408 unsigned long num_relocs;
2cf0635d
NC		 12409 Elf_Internal_Rela * relocs;
12410 Elf_Internal_Rela * rp;
12411 Elf_Internal_Shdr * symsec;
12412 Elf_Internal_Sym * symtab;
ba5cdace 12413 unsigned long num_syms;
2cf0635d 12414 Elf_Internal_Sym * sym;
252b5132 12415
41e92641 12416 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 12417 || relsec->sh_info >= elf_header.e_shnum
12418 || section_headers + relsec->sh_info != section
c256ffe7 12419 || relsec->sh_size == 0
4fbb74a6 12420 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 12421 continue;
428409d5 12422
41e92641
NC		 12423 is_rela = relsec->sh_type == SHT_RELA;
12424
12425 if (is_rela)
12426 {
3f5e193b
NC		 12427 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
12428 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 12429 return;
12430 }
12431 else
12432 {
3f5e193b
NC		 12433 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
12434 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 12435 return;
12436 }
12437
12438 /* SH uses RELA but uses in place value instead of the addend field. */
12439 if (elf_header.e_machine == EM_SH)
12440 is_rela = FALSE;
428409d5 12441
4fbb74a6 12442 symsec = section_headers + relsec->sh_link;
1449284b
NC		 12443 if (symsec->sh_type != SHT_SYMTAB
12444 && symsec->sh_type != SHT_DYNSYM)
12445 return;
ba5cdace 12446 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 12447
41e92641 12448 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 12449 {
41e92641
NC		 12450 bfd_vma addend;
12451 unsigned int reloc_type;
12452 unsigned int reloc_size;
91d6fa6a 12453 unsigned char * rloc;
ba5cdace 12454 unsigned long sym_index;
4b78141a 12455
aca88567 12456 reloc_type = get_reloc_type (rp->r_info);
41e92641 12457
f84ce13b 12458 if (target_specific_reloc_handling (rp, start, end, symtab, num_syms))
2a7b2e88 12459 continue;
98fb390a
NC		 12460 else if (is_none_reloc (reloc_type))
12461 continue;
12462 else if (is_32bit_abs_reloc (reloc_type)
12463 || is_32bit_pcrel_reloc (reloc_type))
aca88567 12464 reloc_size = 4;
85acf597
RH		 12465 else if (is_64bit_abs_reloc (reloc_type)
12466 || is_64bit_pcrel_reloc (reloc_type))
aca88567 12467 reloc_size = 8;
4dc3c23d
AM		 12468 else if (is_24bit_abs_reloc (reloc_type))
12469 reloc_size = 3;
aca88567
NC		 12470 else if (is_16bit_abs_reloc (reloc_type))
12471 reloc_size = 2;
12472 else
4b78141a 12473 {
bee0ee85
NC		 12474 static unsigned int prev_reloc = 0;
12475 if (reloc_type != prev_reloc)
12476 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12477 reloc_type, printable_section_name (section));
12478 prev_reloc = reloc_type;
4b78141a
NC		 12479 continue;
12480 }
103f02d3 12481
91d6fa6a 12482 rloc = start + rp->r_offset;
c8da6823 12483 if ((rloc + reloc_size) > end || (rloc < start))
700dd8b7
L		 12484 {
12485 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12486 (unsigned long) rp->r_offset,
74e1a04b 12487 printable_section_name (section));
700dd8b7
L		 12488 continue;
12489 }
103f02d3 12490
ba5cdace
NC		 12491 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
12492 if (sym_index >= num_syms)
12493 {
12494 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
74e1a04b 12495 sym_index, printable_section_name (section));
ba5cdace
NC		 12496 continue;
12497 }
12498 sym = symtab + sym_index;
41e92641
NC		 12499
12500 /* If the reloc has a symbol associated with it,
55f25fc3
L		 12501 make sure that it is of an appropriate type.
12502
12503 Relocations against symbols without type can happen.
12504 Gcc -feliminate-dwarf2-dups may generate symbols
12505 without type for debug info.
12506
12507 Icc generates relocations against function symbols
12508 instead of local labels.
12509
12510 Relocations against object symbols can happen, eg when
12511 referencing a global array. For an example of this see
12512 the _clz.o binary in libgcc.a. */
aca88567 12513 if (sym != symtab
b8871f35 12514 && ELF_ST_TYPE (sym->st_info) != STT_COMMON
55f25fc3 12515 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 12516 {
41e92641 12517 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 12518 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 12519 (long int)(rp - relocs),
74e1a04b 12520 printable_section_name (relsec));
aca88567 12521 continue;
5b18a4bc 12522 }
252b5132 12523
4dc3c23d
AM		 12524 addend = 0;
12525 if (is_rela)
12526 addend += rp->r_addend;
c47320c3
AM		 12527 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12528 partial_inplace. */
4dc3c23d
AM		 12529 if (!is_rela
12530 || (elf_header.e_machine == EM_XTENSA
12531 && reloc_type == 1)
12532 || ((elf_header.e_machine == EM_PJ
12533 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 12534 && reloc_type == 1)
12535 || ((elf_header.e_machine == EM_D30V
12536 || elf_header.e_machine == EM_CYGNUS_D30V)
12537 && reloc_type == 12))
91d6fa6a 12538 addend += byte_get (rloc, reloc_size);
cb8f3167 12539
85acf597
RH		 12540 if (is_32bit_pcrel_reloc (reloc_type)
12541 || is_64bit_pcrel_reloc (reloc_type))
12542 {
12543 /* On HPPA, all pc-relative relocations are biased by 8. */
12544 if (elf_header.e_machine == EM_PARISC)
12545 addend -= 8;
91d6fa6a 12546 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 12547 reloc_size);
12548 }
41e92641 12549 else
91d6fa6a 12550 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 12551 }
252b5132 12552
5b18a4bc 12553 free (symtab);
f84ce13b
NC		 12554 /* Let the target specific reloc processing code know that
12555 we have finished with these relocs. */
12556 target_specific_reloc_handling (NULL, NULL, NULL, NULL, 0);
d1c4b12b
NC		 12557
12558 if (relocs_return)
12559 {
12560 * (Elf_Internal_Rela **) relocs_return = relocs;
12561 * num_relocs_return = num_relocs;
12562 }
12563 else
12564 free (relocs);
12565
5b18a4bc
NC		 12566 break;
12567 }
5b18a4bc 12568}
103f02d3 12569
cf13d699
NC		 12570#ifdef SUPPORT_DISASSEMBLY
12571static int
12572disassemble_section (Elf_Internal_Shdr * section, FILE * file)
12573{
74e1a04b 12574 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
cf13d699 12575
74e1a04b 12576 /* FIXME: XXX -- to be done --- XXX */
cf13d699
NC		 12577
12578 return 1;
12579}
12580#endif
12581
12582/* Reads in the contents of SECTION from FILE, returning a pointer
12583 to a malloc'ed buffer or NULL if something went wrong. */
12584
12585static char *
12586get_section_contents (Elf_Internal_Shdr * section, FILE * file)
12587{
12588 bfd_size_type num_bytes;
12589
12590 num_bytes = section->sh_size;
12591
12592 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
12593 {
12594 printf (_("\nSection '%s' has no data to dump.\n"),
74e1a04b 12595 printable_section_name (section));
cf13d699
NC		 12596 return NULL;
12597 }
12598
3f5e193b
NC		 12599 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
12600 _("section contents"));
cf13d699
NC		 12601}
12602
0e602686
NC		 12603/* Uncompresses a section that was compressed using zlib, in place. */
12604
12605static bfd_boolean
12606uncompress_section_contents (unsigned char **buffer,
12607 dwarf_size_type uncompressed_size,
12608 dwarf_size_type *size)
12609{
12610 dwarf_size_type compressed_size = *size;
12611 unsigned char * compressed_buffer = *buffer;
12612 unsigned char * uncompressed_buffer;
12613 z_stream strm;
12614 int rc;
12615
12616 /* It is possible the section consists of several compressed
12617 buffers concatenated together, so we uncompress in a loop. */
12618 /* PR 18313: The state field in the z_stream structure is supposed
12619 to be invisible to the user (ie us), but some compilers will
12620 still complain about it being used without initialisation. So
12621 we first zero the entire z_stream structure and then set the fields
12622 that we need. */
12623 memset (& strm, 0, sizeof strm);
12624 strm.avail_in = compressed_size;
12625 strm.next_in = (Bytef *) compressed_buffer;
12626 strm.avail_out = uncompressed_size;
12627 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
12628
12629 rc = inflateInit (& strm);
12630 while (strm.avail_in > 0)
12631 {
12632 if (rc != Z_OK)
12633 goto fail;
12634 strm.next_out = ((Bytef *) uncompressed_buffer
12635 + (uncompressed_size - strm.avail_out));
12636 rc = inflate (&strm, Z_FINISH);
12637 if (rc != Z_STREAM_END)
12638 goto fail;
12639 rc = inflateReset (& strm);
12640 }
12641 rc = inflateEnd (& strm);
12642 if (rc != Z_OK
12643 || strm.avail_out != 0)
12644 goto fail;
12645
12646 *buffer = uncompressed_buffer;
12647 *size = uncompressed_size;
12648 return TRUE;
12649
12650 fail:
12651 free (uncompressed_buffer);
12652 /* Indicate decompression failure. */
12653 *buffer = NULL;
12654 return FALSE;
12655}
dd24e3da 12656
cf13d699
NC		 12657static void
12658dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12659{
0e602686
NC		 12660 Elf_Internal_Shdr * relsec;
12661 bfd_size_type num_bytes;
fd8008d8
L		 12662 unsigned char * data;
12663 unsigned char * end;
12664 unsigned char * real_start;
12665 unsigned char * start;
0e602686 12666 bfd_boolean some_strings_shown;
cf13d699 12667
fd8008d8
L		 12668 real_start = start = (unsigned char *) get_section_contents (section,
12669 file);
cf13d699
NC		 12670 if (start == NULL)
12671 return;
0e602686 12672 num_bytes = section->sh_size;
cf13d699 12673
74e1a04b 12674 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
cf13d699 12675
0e602686
NC		 12676 if (decompress_dumps)
12677 {
12678 dwarf_size_type new_size = num_bytes;
12679 dwarf_size_type uncompressed_size = 0;
12680
12681 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12682 {
12683 Elf_Internal_Chdr chdr;
12684 unsigned int compression_header_size
ebdf1ebf
NC		 12685 = get_compression_header (& chdr, (unsigned char *) start,
12686 num_bytes);
0e602686 12687
813dabb9 12688 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
0e602686 12689 {
813dabb9
L		 12690 warn (_("section '%s' has unsupported compress type: %d\n"),
12691 printable_section_name (section), chdr.ch_type);
12692 return;
12693 }
12694 else if (chdr.ch_addralign != section->sh_addralign)
12695 {
12696 warn (_("compressed section '%s' is corrupted\n"),
12697 printable_section_name (section));
12698 return;
0e602686 12699 }
813dabb9
L		 12700 uncompressed_size = chdr.ch_size;
12701 start += compression_header_size;
12702 new_size -= compression_header_size;
0e602686
NC		 12703 }
12704 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12705 {
12706 /* Read the zlib header. In this case, it should be "ZLIB"
12707 followed by the uncompressed section size, 8 bytes in
12708 big-endian order. */
12709 uncompressed_size = start[4]; uncompressed_size <<= 8;
12710 uncompressed_size += start[5]; uncompressed_size <<= 8;
12711 uncompressed_size += start[6]; uncompressed_size <<= 8;
12712 uncompressed_size += start[7]; uncompressed_size <<= 8;
12713 uncompressed_size += start[8]; uncompressed_size <<= 8;
12714 uncompressed_size += start[9]; uncompressed_size <<= 8;
12715 uncompressed_size += start[10]; uncompressed_size <<= 8;
12716 uncompressed_size += start[11];
12717 start += 12;
12718 new_size -= 12;
12719 }
12720
1835f746
NC		 12721 if (uncompressed_size)
12722 {
12723 if (uncompress_section_contents (& start,
12724 uncompressed_size, & new_size))
12725 num_bytes = new_size;
12726 else
12727 {
12728 error (_("Unable to decompress section %s\n"),
12729 printable_section_name (section));
12730 return;
12731 }
12732 }
bc303e5d
NC		 12733 else
12734 start = real_start;
0e602686 12735 }
fd8008d8 12736
cf13d699
NC		 12737 /* If the section being dumped has relocations against it the user might
12738 be expecting these relocations to have been applied. Check for this
12739 case and issue a warning message in order to avoid confusion.
12740 FIXME: Maybe we ought to have an option that dumps a section with
12741 relocs applied ? */
12742 for (relsec = section_headers;
12743 relsec < section_headers + elf_header.e_shnum;
12744 ++relsec)
12745 {
12746 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12747 || relsec->sh_info >= elf_header.e_shnum
12748 || section_headers + relsec->sh_info != section
12749 || relsec->sh_size == 0
12750 || relsec->sh_link >= elf_header.e_shnum)
12751 continue;
12752
12753 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12754 break;
12755 }
12756
cf13d699
NC		 12757 data = start;
12758 end = start + num_bytes;
12759 some_strings_shown = FALSE;
12760
12761 while (data < end)
12762 {
12763 while (!ISPRINT (* data))
12764 if (++ data >= end)
12765 break;
12766
12767 if (data < end)
12768 {
071436c6
NC		 12769 size_t maxlen = end - data;
12770
cf13d699 12771#ifndef __MSVCRT__
c975cc98
NC		 12772 /* PR 11128: Use two separate invocations in order to work
12773 around bugs in the Solaris 8 implementation of printf. */
12774 printf (" [%6tx] ", data - start);
cf13d699 12775#else
071436c6 12776 printf (" [%6Ix] ", (size_t) (data - start));
cf13d699 12777#endif
4082ef84
NC		 12778 if (maxlen > 0)
12779 {
fd8008d8 12780 print_symbol ((int) maxlen, (const char *) data);
4082ef84 12781 putchar ('\n');
fd8008d8 12782 data += strnlen ((const char *) data, maxlen);
4082ef84
NC		 12783 }
12784 else
12785 {
12786 printf (_("<corrupt>\n"));
12787 data = end;
12788 }
cf13d699
NC		 12789 some_strings_shown = TRUE;
12790 }
12791 }
12792
12793 if (! some_strings_shown)
12794 printf (_(" No strings found in this section."));
12795
0e602686 12796 free (real_start);
cf13d699
NC		 12797
12798 putchar ('\n');
12799}
12800
12801static void
12802dump_section_as_bytes (Elf_Internal_Shdr * section,
12803 FILE * file,
12804 bfd_boolean relocate)
12805{
12806 Elf_Internal_Shdr * relsec;
0e602686
NC		 12807 bfd_size_type bytes;
12808 bfd_size_type section_size;
12809 bfd_vma addr;
12810 unsigned char * data;
12811 unsigned char * real_start;
12812 unsigned char * start;
12813
12814 real_start = start = (unsigned char *) get_section_contents (section, file);
cf13d699
NC		 12815 if (start == NULL)
12816 return;
0e602686 12817 section_size = section->sh_size;
cf13d699 12818
74e1a04b 12819 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
cf13d699 12820
0e602686
NC		 12821 if (decompress_dumps)
12822 {
12823 dwarf_size_type new_size = section_size;
12824 dwarf_size_type uncompressed_size = 0;
12825
12826 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12827 {
12828 Elf_Internal_Chdr chdr;
12829 unsigned int compression_header_size
ebdf1ebf 12830 = get_compression_header (& chdr, start, section_size);
0e602686 12831
813dabb9 12832 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
0e602686 12833 {
813dabb9
L		 12834 warn (_("section '%s' has unsupported compress type: %d\n"),
12835 printable_section_name (section), chdr.ch_type);
12836 return;
0e602686 12837 }
813dabb9
L		 12838 else if (chdr.ch_addralign != section->sh_addralign)
12839 {
12840 warn (_("compressed section '%s' is corrupted\n"),
12841 printable_section_name (section));
12842 return;
12843 }
12844 uncompressed_size = chdr.ch_size;
12845 start += compression_header_size;
12846 new_size -= compression_header_size;
0e602686
NC		 12847 }
12848 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12849 {
12850 /* Read the zlib header. In this case, it should be "ZLIB"
12851 followed by the uncompressed section size, 8 bytes in
12852 big-endian order. */
12853 uncompressed_size = start[4]; uncompressed_size <<= 8;
12854 uncompressed_size += start[5]; uncompressed_size <<= 8;
12855 uncompressed_size += start[6]; uncompressed_size <<= 8;
12856 uncompressed_size += start[7]; uncompressed_size <<= 8;
12857 uncompressed_size += start[8]; uncompressed_size <<= 8;
12858 uncompressed_size += start[9]; uncompressed_size <<= 8;
12859 uncompressed_size += start[10]; uncompressed_size <<= 8;
12860 uncompressed_size += start[11];
12861 start += 12;
12862 new_size -= 12;
12863 }
12864
f055032e
NC		 12865 if (uncompressed_size)
12866 {
12867 if (uncompress_section_contents (& start, uncompressed_size,
12868 & new_size))
bc303e5d
NC		 12869 {
12870 section_size = new_size;
12871 }
f055032e
NC		 12872 else
12873 {
12874 error (_("Unable to decompress section %s\n"),
12875 printable_section_name (section));
bc303e5d 12876 /* FIXME: Print the section anyway ? */
f055032e
NC		 12877 return;
12878 }
12879 }
bc303e5d
NC		 12880 else
12881 start = real_start;
0e602686 12882 }
14ae95f2 12883
cf13d699
NC		 12884 if (relocate)
12885 {
0e602686 12886 apply_relocations (file, section, start, section_size, NULL, NULL);
cf13d699
NC		 12887 }
12888 else
12889 {
12890 /* If the section being dumped has relocations against it the user might
12891 be expecting these relocations to have been applied. Check for this
12892 case and issue a warning message in order to avoid confusion.
12893 FIXME: Maybe we ought to have an option that dumps a section with
12894 relocs applied ? */
12895 for (relsec = section_headers;
12896 relsec < section_headers + elf_header.e_shnum;
12897 ++relsec)
12898 {
12899 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12900 || relsec->sh_info >= elf_header.e_shnum
12901 || section_headers + relsec->sh_info != section
12902 || relsec->sh_size == 0
12903 || relsec->sh_link >= elf_header.e_shnum)
12904 continue;
12905
12906 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12907 break;
12908 }
12909 }
12910
12911 addr = section->sh_addr;
0e602686 12912 bytes = section_size;
cf13d699
NC		 12913 data = start;
12914
12915 while (bytes)
12916 {
12917 int j;
12918 int k;
12919 int lbytes;
12920
12921 lbytes = (bytes > 16 ? 16 : bytes);
12922
12923 printf (" 0x%8.8lx ", (unsigned long) addr);
12924
12925 for (j = 0; j < 16; j++)
12926 {
12927 if (j < lbytes)
12928 printf ("%2.2x", data[j]);
12929 else
12930 printf (" ");
12931
12932 if ((j & 3) == 3)
12933 printf (" ");
12934 }
12935
12936 for (j = 0; j < lbytes; j++)
12937 {
12938 k = data[j];
12939 if (k >= ' ' && k < 0x7f)
12940 printf ("%c", k);
12941 else
12942 printf (".");
12943 }
12944
12945 putchar ('\n');
12946
12947 data += lbytes;
12948 addr += lbytes;
12949 bytes -= lbytes;
12950 }
12951
0e602686 12952 free (real_start);
cf13d699
NC		 12953
12954 putchar ('\n');
12955}
12956
d966045b
DJ		 12957static int
12958load_specific_debug_section (enum dwarf_section_display_enum debug,
0d2a7a93 12959 const Elf_Internal_Shdr * sec, void * file)
1007acb3 12960{
2cf0635d 12961 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 12962 char buf [64];
1007acb3 12963
19e6b90e
L		 12964 /* If it is already loaded, do nothing. */
12965 if (section->start != NULL)
12966 return 1;
1007acb3 12967
19e6b90e
L		 12968 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12969 section->address = sec->sh_addr;
06614111 12970 section->user_data = NULL;
3f5e193b
NC		 12971 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12972 sec->sh_offset, 1,
12973 sec->sh_size, buf);
59245841
NC		 12974 if (section->start == NULL)
12975 section->size = 0;
12976 else
12977 {
77115a4a
L		 12978 unsigned char *start = section->start;
12979 dwarf_size_type size = sec->sh_size;
dab394de 12980 dwarf_size_type uncompressed_size = 0;
77115a4a
L		 12981
12982 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
12983 {
12984 Elf_Internal_Chdr chdr;
d8024a91
NC		 12985 unsigned int compression_header_size;
12986
f53be977
L		 12987 if (size < (is_32bit_elf
12988 ? sizeof (Elf32_External_Chdr)
12989 : sizeof (Elf64_External_Chdr)))
d8024a91
NC		 12990 {
12991 warn (_("compressed section %s is too small to contain a compression header"),
12992 section->name);
12993 return 0;
12994 }
12995
ebdf1ebf 12996 compression_header_size = get_compression_header (&chdr, start, size);
d8024a91 12997
813dabb9
L		 12998 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12999 {
13000 warn (_("section '%s' has unsupported compress type: %d\n"),
13001 section->name, chdr.ch_type);
13002 return 0;
13003 }
13004 else if (chdr.ch_addralign != sec->sh_addralign)
13005 {
13006 warn (_("compressed section '%s' is corrupted\n"),
13007 section->name);
13008 return 0;
13009 }
dab394de 13010 uncompressed_size = chdr.ch_size;
77115a4a
L		 13011 start += compression_header_size;
13012 size -= compression_header_size;
13013 }
dab394de
L		 13014 else if (size > 12 && streq ((char *) start, "ZLIB"))
13015 {
13016 /* Read the zlib header. In this case, it should be "ZLIB"
13017 followed by the uncompressed section size, 8 bytes in
13018 big-endian order. */
13019 uncompressed_size = start[4]; uncompressed_size <<= 8;
13020 uncompressed_size += start[5]; uncompressed_size <<= 8;
13021 uncompressed_size += start[6]; uncompressed_size <<= 8;
13022 uncompressed_size += start[7]; uncompressed_size <<= 8;
13023 uncompressed_size += start[8]; uncompressed_size <<= 8;
13024 uncompressed_size += start[9]; uncompressed_size <<= 8;
13025 uncompressed_size += start[10]; uncompressed_size <<= 8;
13026 uncompressed_size += start[11];
13027 start += 12;
13028 size -= 12;
13029 }
13030
1835f746 13031 if (uncompressed_size)
77115a4a 13032 {
1835f746
NC		 13033 if (uncompress_section_contents (&start, uncompressed_size,
13034 &size))
13035 {
13036 /* Free the compressed buffer, update the section buffer
13037 and the section size if uncompress is successful. */
13038 free (section->start);
13039 section->start = start;
13040 }
13041 else
13042 {
13043 error (_("Unable to decompress section %s\n"),
13044 printable_section_name (sec));
13045 return 0;
13046 }
77115a4a 13047 }
bc303e5d 13048
77115a4a 13049 section->size = size;
59245841 13050 }
4a114e3e 13051
1b315056
CS		 13052 if (section->start == NULL)
13053 return 0;
13054
19e6b90e 13055 if (debug_displays [debug].relocate)
d1c4b12b
NC		 13056 apply_relocations ((FILE *) file, sec, section->start, section->size,
13057 & section->reloc_info, & section->num_relocs);
13058 else
13059 {
13060 section->reloc_info = NULL;
13061 section->num_relocs = 0;
13062 }
1007acb3 13063
1b315056 13064 return 1;
1007acb3
L		 13065}
13066
657d0d47
CC		 13067/* If this is not NULL, load_debug_section will only look for sections
13068 within the list of sections given here. */
13069unsigned int *section_subset = NULL;
13070
d966045b 13071int
2cf0635d 13072load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 13073{
2cf0635d
NC		 13074 struct dwarf_section * section = &debug_displays [debug].section;
13075 Elf_Internal_Shdr * sec;
d966045b
DJ		 13076
13077 /* Locate the debug section. */
657d0d47 13078 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 13079 if (sec != NULL)
13080 section->name = section->uncompressed_name;
13081 else
13082 {
657d0d47 13083 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 13084 if (sec != NULL)
13085 section->name = section->compressed_name;
13086 }
13087 if (sec == NULL)
13088 return 0;
13089
657d0d47
CC		 13090 /* If we're loading from a subset of sections, and we've loaded
13091 a section matching this name before, it's likely that it's a
13092 different one. */
13093 if (section_subset != NULL)
13094 free_debug_section (debug);
13095
3f5e193b 13096 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 13097}
13098
19e6b90e
L		 13099void
13100free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 13101{
2cf0635d 13102 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 13103
19e6b90e
L		 13104 if (section->start == NULL)
13105 return;
1007acb3 13106
19e6b90e
L		 13107 free ((char *) section->start);
13108 section->start = NULL;
13109 section->address = 0;
13110 section->size = 0;
1007acb3
L		 13111}
13112
1007acb3 13113static int
657d0d47 13114display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 13115{
2cf0635d 13116 char * name = SECTION_NAME (section);
74e1a04b 13117 const char * print_name = printable_section_name (section);
19e6b90e
L		 13118 bfd_size_type length;
13119 int result = 1;
3f5e193b 13120 int i;
1007acb3 13121
19e6b90e
L		 13122 length = section->sh_size;
13123 if (length == 0)
1007acb3 13124 {
74e1a04b 13125 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
19e6b90e 13126 return 0;
1007acb3 13127 }
5dff79d8
NC		 13128 if (section->sh_type == SHT_NOBITS)
13129 {
13130 /* There is no point in dumping the contents of a debugging section
13131 which has the NOBITS type - the bits in the file will be random.
13132 This can happen when a file containing a .eh_frame section is
13133 stripped with the --only-keep-debug command line option. */
74e1a04b
NC		 13134 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13135 print_name);
5dff79d8
NC		 13136 return 0;
13137 }
1007acb3 13138
0112cd26 13139 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 13140 name = ".debug_info";
1007acb3 13141
19e6b90e
L		 13142 /* See if we know how to display the contents of this section. */
13143 for (i = 0; i < max; i++)
1b315056 13144 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 13145 || (i == line && const_strneq (name, ".debug_line."))
1b315056 13146 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 13147 {
2cf0635d 13148 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 13149 int secondary = (section != find_section (name));
13150
13151 if (secondary)
3f5e193b 13152 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 13153
b40bf0a2
NC		 13154 if (i == line && const_strneq (name, ".debug_line."))
13155 sec->name = name;
13156 else if (streq (sec->uncompressed_name, name))
d966045b
DJ		 13157 sec->name = sec->uncompressed_name;
13158 else
13159 sec->name = sec->compressed_name;
3f5e193b
NC		 13160 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
13161 section, file))
19e6b90e 13162 {
657d0d47
CC		 13163 /* If this debug section is part of a CU/TU set in a .dwp file,
13164 restrict load_debug_section to the sections in that set. */
13165 section_subset = find_cu_tu_set (file, shndx);
13166
19e6b90e 13167 result &= debug_displays[i].display (sec, file);
1007acb3 13168
657d0d47
CC		 13169 section_subset = NULL;
13170
d966045b 13171 if (secondary || (i != info && i != abbrev))
3f5e193b 13172 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 13173 }
1007acb3 13174
19e6b90e
L		 13175 break;
13176 }
1007acb3 13177
19e6b90e 13178 if (i == max)
1007acb3 13179 {
74e1a04b 13180 printf (_("Unrecognized debug section: %s\n"), print_name);
19e6b90e 13181 result = 0;
1007acb3
L		 13182 }
13183
19e6b90e 13184 return result;
5b18a4bc 13185}
103f02d3 13186
aef1f6d0
DJ		 13187/* Set DUMP_SECTS for all sections where dumps were requested
13188 based on section name. */
13189
13190static void
13191initialise_dumps_byname (void)
13192{
2cf0635d 13193 struct dump_list_entry * cur;
aef1f6d0
DJ		 13194
13195 for (cur = dump_sects_byname; cur; cur = cur->next)
13196 {
13197 unsigned int i;
13198 int any;
13199
13200 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
13201 if (streq (SECTION_NAME (section_headers + i), cur->name))
13202 {
09c11c86 13203 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 13204 any = 1;
13205 }
13206
13207 if (!any)
13208 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13209 cur->name);
13210 }
13211}
13212
5b18a4bc 13213static void
2cf0635d 13214process_section_contents (FILE * file)
5b18a4bc 13215{
2cf0635d 13216 Elf_Internal_Shdr * section;
19e6b90e 13217 unsigned int i;
103f02d3 13218
19e6b90e
L		 13219 if (! do_dump)
13220 return;
103f02d3 13221
aef1f6d0
DJ		 13222 initialise_dumps_byname ();
13223
19e6b90e
L		 13224 for (i = 0, section = section_headers;
13225 i < elf_header.e_shnum && i < num_dump_sects;
13226 i++, section++)
13227 {
13228#ifdef SUPPORT_DISASSEMBLY
13229 if (dump_sects[i] & DISASS_DUMP)
13230 disassemble_section (section, file);
13231#endif
13232 if (dump_sects[i] & HEX_DUMP)
cf13d699 13233 dump_section_as_bytes (section, file, FALSE);
103f02d3 13234
cf13d699
NC		 13235 if (dump_sects[i] & RELOC_DUMP)
13236 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 13237
13238 if (dump_sects[i] & STRING_DUMP)
13239 dump_section_as_strings (section, file);
cf13d699
NC		 13240
13241 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 13242 display_debug_section (i, section, file);
5b18a4bc 13243 }
103f02d3 13244
19e6b90e
L		 13245 /* Check to see if the user requested a
13246 dump of a section that does not exist. */
0ee3043f
NC		 13247 while (i < num_dump_sects)
13248 {
13249 if (dump_sects[i])
13250 warn (_("Section %d was not dumped because it does not exist!\n"), i);
13251 i++;
13252 }
5b18a4bc 13253}
103f02d3 13254
5b18a4bc 13255static void
19e6b90e 13256process_mips_fpe_exception (int mask)
5b18a4bc 13257{
19e6b90e
L		 13258 if (mask)
13259 {
13260 int first = 1;
13261 if (mask & OEX_FPU_INEX)
13262 fputs ("INEX", stdout), first = 0;
13263 if (mask & OEX_FPU_UFLO)
13264 printf ("%sUFLO", first ? "" : "|"), first = 0;
13265 if (mask & OEX_FPU_OFLO)
13266 printf ("%sOFLO", first ? "" : "|"), first = 0;
13267 if (mask & OEX_FPU_DIV0)
13268 printf ("%sDIV0", first ? "" : "|"), first = 0;
13269 if (mask & OEX_FPU_INVAL)
13270 printf ("%sINVAL", first ? "" : "|");
13271 }
5b18a4bc 13272 else
19e6b90e 13273 fputs ("0", stdout);
5b18a4bc 13274}
103f02d3 13275
f6f0e17b
NC		 13276/* Display's the value of TAG at location P. If TAG is
13277 greater than 0 it is assumed to be an unknown tag, and
13278 a message is printed to this effect. Otherwise it is
13279 assumed that a message has already been printed.
13280
13281 If the bottom bit of TAG is set it assumed to have a
13282 string value, otherwise it is assumed to have an integer
13283 value.
13284
13285 Returns an updated P pointing to the first unread byte
13286 beyond the end of TAG's value.
13287
13288 Reads at or beyond END will not be made. */
13289
13290static unsigned char *
60abdbed 13291display_tag_value (signed int tag,
f6f0e17b
NC		 13292 unsigned char * p,
13293 const unsigned char * const end)
13294{
13295 unsigned long val;
13296
13297 if (tag > 0)
13298 printf (" Tag_unknown_%d: ", tag);
13299
13300 if (p >= end)
13301 {
4082ef84 13302 warn (_("<corrupt tag>\n"));
f6f0e17b
NC		 13303 }
13304 else if (tag & 1)
13305 {
071436c6
NC		 13306 /* PR 17531 file: 027-19978-0.004. */
13307 size_t maxlen = (end - p) - 1;
13308
13309 putchar ('"');
4082ef84
NC		 13310 if (maxlen > 0)
13311 {
13312 print_symbol ((int) maxlen, (const char *) p);
13313 p += strnlen ((char *) p, maxlen) + 1;
13314 }
13315 else
13316 {
13317 printf (_("<corrupt string tag>"));
13318 p = (unsigned char *) end;
13319 }
071436c6 13320 printf ("\"\n");
f6f0e17b
NC		 13321 }
13322 else
13323 {
13324 unsigned int len;
13325
13326 val = read_uleb128 (p, &len, end);
13327 p += len;
13328 printf ("%ld (0x%lx)\n", val, val);
13329 }
13330
4082ef84 13331 assert (p <= end);
f6f0e17b
NC		 13332 return p;
13333}
13334
11c1ff18
PB		 13335/* ARM EABI attributes section. */
13336typedef struct
13337{
70e99720 13338 unsigned int tag;
2cf0635d 13339 const char * name;
11c1ff18 13340 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
70e99720 13341 unsigned int type;
2cf0635d 13342 const char ** table;
11c1ff18
PB		 13343} arm_attr_public_tag;
13344
2cf0635d 13345static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 13346 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
ff8646ee
TP		 13347 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
13348 "v8-M.mainline"};
2cf0635d
NC		 13349static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
13350static const char * arm_attr_tag_THUMB_ISA_use[] =
4ed7ed8d 13351 {"No", "Thumb-1", "Thumb-2", "Yes"};
75375b3e 13352static const char * arm_attr_tag_FP_arch[] =
bca38921 13353 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
a715796b 13354 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
2cf0635d 13355static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 13356static const char * arm_attr_tag_Advanced_SIMD_arch[] =
9411fd44
MW		 13357 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13358 "NEON for ARMv8.1"};
2cf0635d 13359static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 13360 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13361 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 13362static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 13363 {"V6", "SB", "TLS", "Unused"};
2cf0635d 13364static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 13365 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 13366static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 13367 {"Absolute", "PC-relative", "None"};
2cf0635d 13368static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 13369 {"None", "direct", "GOT-indirect"};
2cf0635d 13370static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 13371 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 13372static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
13373static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 13374 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 13375static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
13376static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
13377static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 13378 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 13379static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 13380 {"Unused", "small", "int", "forced to int"};
2cf0635d 13381static const char * arm_attr_tag_ABI_HardFP_use[] =
99654aaf 13382 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
2cf0635d 13383static const char * arm_attr_tag_ABI_VFP_args[] =
5c294fee 13384 {"AAPCS", "VFP registers", "custom", "compatible"};
2cf0635d 13385static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 13386 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 13387static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 13388 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13389 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 13390static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 13391 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13392 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 13393static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 13394static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 13395 {"Not Allowed", "Allowed"};
2cf0635d 13396static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 13397 {"None", "IEEE 754", "Alternative Format"};
15afaa63
TP		 13398static const char * arm_attr_tag_DSP_extension[] =
13399 {"Follow architecture", "Allowed"};
dd24e3da 13400static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 13401 {"Not Allowed", "Allowed"};
13402static const char * arm_attr_tag_DIV_use[] =
dd24e3da 13403 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 13404 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 13405static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
13406static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 13407 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 13408 "TrustZone and Virtualization Extensions"};
dd24e3da 13409static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 13410 {"Not Allowed", "Allowed"};
11c1ff18
PB		 13411
13412#define LOOKUP(id, name) \
13413 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 13414static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 13415{
13416 {4, "CPU_raw_name", 1, NULL},
13417 {5, "CPU_name", 1, NULL},
13418 LOOKUP(6, CPU_arch),
13419 {7, "CPU_arch_profile", 0, NULL},
13420 LOOKUP(8, ARM_ISA_use),
13421 LOOKUP(9, THUMB_ISA_use),
75375b3e 13422 LOOKUP(10, FP_arch),
11c1ff18 13423 LOOKUP(11, WMMX_arch),
f5f53991
AS		 13424 LOOKUP(12, Advanced_SIMD_arch),
13425 LOOKUP(13, PCS_config),
11c1ff18
PB		 13426 LOOKUP(14, ABI_PCS_R9_use),
13427 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 13428 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 13429 LOOKUP(17, ABI_PCS_GOT_use),
13430 LOOKUP(18, ABI_PCS_wchar_t),
13431 LOOKUP(19, ABI_FP_rounding),
13432 LOOKUP(20, ABI_FP_denormal),
13433 LOOKUP(21, ABI_FP_exceptions),
13434 LOOKUP(22, ABI_FP_user_exceptions),
13435 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 13436 {24, "ABI_align_needed", 0, NULL},
13437 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 13438 LOOKUP(26, ABI_enum_size),
13439 LOOKUP(27, ABI_HardFP_use),
13440 LOOKUP(28, ABI_VFP_args),
13441 LOOKUP(29, ABI_WMMX_args),
13442 LOOKUP(30, ABI_optimization_goals),
13443 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 13444 {32, "compatibility", 0, NULL},
f5f53991 13445 LOOKUP(34, CPU_unaligned_access),
75375b3e 13446 LOOKUP(36, FP_HP_extension),
8e79c3df 13447 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 13448 LOOKUP(42, MPextension_use),
13449 LOOKUP(44, DIV_use),
15afaa63 13450 LOOKUP(46, DSP_extension),
f5f53991
AS		 13451 {64, "nodefaults", 0, NULL},
13452 {65, "also_compatible_with", 0, NULL},
13453 LOOKUP(66, T2EE_use),
13454 {67, "conformance", 1, NULL},
13455 LOOKUP(68, Virtualization_use),
cd21e546 13456 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 13457};
13458#undef LOOKUP
13459
11c1ff18 13460static unsigned char *
f6f0e17b
NC		 13461display_arm_attribute (unsigned char * p,
13462 const unsigned char * const end)
11c1ff18 13463{
70e99720 13464 unsigned int tag;
11c1ff18 13465 unsigned int len;
70e99720 13466 unsigned int val;
2cf0635d 13467 arm_attr_public_tag * attr;
11c1ff18 13468 unsigned i;
70e99720 13469 unsigned int type;
11c1ff18 13470
f6f0e17b 13471 tag = read_uleb128 (p, &len, end);
11c1ff18
PB		 13472 p += len;
13473 attr = NULL;
2cf0635d 13474 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 13475 {
13476 if (arm_attr_public_tags[i].tag == tag)
13477 {
13478 attr = &arm_attr_public_tags[i];
13479 break;
13480 }
13481 }
13482
13483 if (attr)
13484 {
13485 printf (" Tag_%s: ", attr->name);
13486 switch (attr->type)
13487 {
13488 case 0:
13489 switch (tag)
13490 {
13491 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 13492 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 13493 p += len;
13494 switch (val)
13495 {
2b692964
NC		 13496 case 0: printf (_("None\n")); break;
13497 case 'A': printf (_("Application\n")); break;
13498 case 'R': printf (_("Realtime\n")); break;
13499 case 'M': printf (_("Microcontroller\n")); break;
13500 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 13501 default: printf ("??? (%d)\n", val); break;
13502 }
13503 break;
13504
75375b3e 13505 case 24: /* Tag_align_needed. */
f6f0e17b 13506 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 13507 p += len;
13508 switch (val)
13509 {
2b692964
NC		 13510 case 0: printf (_("None\n")); break;
13511 case 1: printf (_("8-byte\n")); break;
13512 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 13513 case 3: printf ("??? 3\n"); break;
13514 default:
13515 if (val <= 12)
dd24e3da 13516 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 13517 1 << val);
13518 else
13519 printf ("??? (%d)\n", val);
13520 break;
13521 }
13522 break;
13523
13524 case 25: /* Tag_align_preserved. */
f6f0e17b 13525 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 13526 p += len;
13527 switch (val)
13528 {
2b692964
NC		 13529 case 0: printf (_("None\n")); break;
13530 case 1: printf (_("8-byte, except leaf SP\n")); break;
13531 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 13532 case 3: printf ("??? 3\n"); break;
13533 default:
13534 if (val <= 12)
dd24e3da 13535 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 13536 1 << val);
13537 else
13538 printf ("??? (%d)\n", val);
13539 break;
13540 }
13541 break;
13542
11c1ff18 13543 case 32: /* Tag_compatibility. */
071436c6 13544 {
071436c6
NC		 13545 val = read_uleb128 (p, &len, end);
13546 p += len;
071436c6 13547 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 13548 if (p < end - 1)
13549 {
13550 size_t maxlen = (end - p) - 1;
13551
13552 print_symbol ((int) maxlen, (const char *) p);
13553 p += strnlen ((char *) p, maxlen) + 1;
13554 }
13555 else
13556 {
13557 printf (_("<corrupt>"));
13558 p = (unsigned char *) end;
13559 }
071436c6 13560 putchar ('\n');
071436c6 13561 }
11c1ff18
PB		 13562 break;
13563
f5f53991 13564 case 64: /* Tag_nodefaults. */
541a3cbd
NC		 13565 /* PR 17531: file: 001-505008-0.01. */
13566 if (p < end)
13567 p++;
2b692964 13568 printf (_("True\n"));
f5f53991
AS		 13569 break;
13570
13571 case 65: /* Tag_also_compatible_with. */
f6f0e17b 13572 val = read_uleb128 (p, &len, end);
f5f53991
AS		 13573 p += len;
13574 if (val == 6 /* Tag_CPU_arch. */)
13575 {
f6f0e17b 13576 val = read_uleb128 (p, &len, end);
f5f53991 13577 p += len;
071436c6 13578 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 13579 printf ("??? (%d)\n", val);
13580 else
13581 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
13582 }
13583 else
13584 printf ("???\n");
071436c6
NC		 13585 while (p < end && *(p++) != '\0' /* NUL terminator. */)
13586 ;
f5f53991
AS		 13587 break;
13588
11c1ff18 13589 default:
bee0ee85
NC		 13590 printf (_("<unknown: %d>\n"), tag);
13591 break;
11c1ff18
PB		 13592 }
13593 return p;
13594
13595 case 1:
f6f0e17b 13596 return display_tag_value (-1, p, end);
11c1ff18 13597 case 2:
f6f0e17b 13598 return display_tag_value (0, p, end);
11c1ff18
PB		 13599
13600 default:
13601 assert (attr->type & 0x80);
f6f0e17b 13602 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 13603 p += len;
13604 type = attr->type & 0x7f;
13605 if (val >= type)
13606 printf ("??? (%d)\n", val);
13607 else
13608 printf ("%s\n", attr->table[val]);
13609 return p;
13610 }
13611 }
11c1ff18 13612
f6f0e17b 13613 return display_tag_value (tag, p, end);
11c1ff18
PB		 13614}
13615
104d59d1 13616static unsigned char *
60bca95a 13617display_gnu_attribute (unsigned char * p,
60abdbed 13618 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
f6f0e17b 13619 const unsigned char * const end)
104d59d1
JM		 13620{
13621 int tag;
13622 unsigned int len;
60abdbed 13623 unsigned int val;
104d59d1 13624
f6f0e17b 13625 tag = read_uleb128 (p, &len, end);
104d59d1
JM		 13626 p += len;
13627
13628 /* Tag_compatibility is the only generic GNU attribute defined at
13629 present. */
13630 if (tag == 32)
13631 {
f6f0e17b 13632 val = read_uleb128 (p, &len, end);
104d59d1 13633 p += len;
071436c6
NC		 13634
13635 printf (_("flag = %d, vendor = "), val);
f6f0e17b
NC		 13636 if (p == end)
13637 {
071436c6 13638 printf (_("<corrupt>\n"));
f6f0e17b
NC		 13639 warn (_("corrupt vendor attribute\n"));
13640 }
13641 else
13642 {
4082ef84
NC		 13643 if (p < end - 1)
13644 {
13645 size_t maxlen = (end - p) - 1;
071436c6 13646
4082ef84
NC		 13647 print_symbol ((int) maxlen, (const char *) p);
13648 p += strnlen ((char *) p, maxlen) + 1;
13649 }
13650 else
13651 {
13652 printf (_("<corrupt>"));
13653 p = (unsigned char *) end;
13654 }
071436c6 13655 putchar ('\n');
f6f0e17b 13656 }
104d59d1
JM		 13657 return p;
13658 }
13659
13660 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 13661 return display_proc_gnu_attribute (p, tag, end);
104d59d1 13662
f6f0e17b 13663 return display_tag_value (tag, p, end);
104d59d1
JM		 13664}
13665
34c8bcba 13666static unsigned char *
f6f0e17b 13667display_power_gnu_attribute (unsigned char * p,
60abdbed 13668 unsigned int tag,
f6f0e17b 13669 const unsigned char * const end)
34c8bcba 13670{
34c8bcba 13671 unsigned int len;
005d79fd 13672 unsigned int val;
34c8bcba
JM		 13673
13674 if (tag == Tag_GNU_Power_ABI_FP)
13675 {
f6f0e17b 13676 val = read_uleb128 (p, &len, end);
34c8bcba
JM		 13677 p += len;
13678 printf (" Tag_GNU_Power_ABI_FP: ");
005d79fd
AM		 13679 if (len == 0)
13680 {
13681 printf (_("<corrupt>\n"));
13682 return p;
13683 }
60bca95a 13684
005d79fd
AM		 13685 if (val > 15)
13686 printf ("(%#x), ", val);
13687
13688 switch (val & 3)
34c8bcba
JM		 13689 {
13690 case 0:
005d79fd 13691 printf (_("unspecified hard/soft float, "));
34c8bcba
JM		 13692 break;
13693 case 1:
005d79fd 13694 printf (_("hard float, "));
34c8bcba
JM		 13695 break;
13696 case 2:
005d79fd 13697 printf (_("soft float, "));
34c8bcba 13698 break;
3c7b9897 13699 case 3:
005d79fd 13700 printf (_("single-precision hard float, "));
3c7b9897 13701 break;
005d79fd
AM		 13702 }
13703
13704 switch (val & 0xC)
13705 {
13706 case 0:
13707 printf (_("unspecified long double\n"));
13708 break;
13709 case 4:
13710 printf (_("128-bit IBM long double\n"));
13711 break;
13712 case 8:
13713 printf (_("64-bit long double\n"));
13714 break;
13715 case 12:
13716 printf (_("128-bit IEEE long double\n"));
34c8bcba
JM		 13717 break;
13718 }
13719 return p;
005d79fd 13720 }
34c8bcba 13721
c6e65352
DJ		 13722 if (tag == Tag_GNU_Power_ABI_Vector)
13723 {
f6f0e17b 13724 val = read_uleb128 (p, &len, end);
c6e65352
DJ		 13725 p += len;
13726 printf (" Tag_GNU_Power_ABI_Vector: ");
005d79fd
AM		 13727 if (len == 0)
13728 {
13729 printf (_("<corrupt>\n"));
13730 return p;
13731 }
13732
13733 if (val > 3)
13734 printf ("(%#x), ", val);
13735
13736 switch (val & 3)
c6e65352
DJ		 13737 {
13738 case 0:
005d79fd 13739 printf (_("unspecified\n"));
c6e65352
DJ		 13740 break;
13741 case 1:
005d79fd 13742 printf (_("generic\n"));
c6e65352
DJ		 13743 break;
13744 case 2:
13745 printf ("AltiVec\n");
13746 break;
13747 case 3:
13748 printf ("SPE\n");
13749 break;
c6e65352
DJ		 13750 }
13751 return p;
005d79fd 13752 }
c6e65352 13753
f82e0623
NF		 13754 if (tag == Tag_GNU_Power_ABI_Struct_Return)
13755 {
005d79fd
AM		 13756 val = read_uleb128 (p, &len, end);
13757 p += len;
13758 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13759 if (len == 0)
f6f0e17b 13760 {
005d79fd 13761 printf (_("<corrupt>\n"));
f6f0e17b
NC		 13762 return p;
13763 }
0b4362b0 13764
005d79fd
AM		 13765 if (val > 2)
13766 printf ("(%#x), ", val);
13767
13768 switch (val & 3)
13769 {
13770 case 0:
13771 printf (_("unspecified\n"));
13772 break;
13773 case 1:
13774 printf ("r3/r4\n");
13775 break;
13776 case 2:
13777 printf (_("memory\n"));
13778 break;
13779 case 3:
13780 printf ("???\n");
13781 break;
13782 }
f82e0623
NF		 13783 return p;
13784 }
13785
f6f0e17b 13786 return display_tag_value (tag & 1, p, end);
34c8bcba
JM		 13787}
13788
643f7afb
AK		 13789static unsigned char *
13790display_s390_gnu_attribute (unsigned char * p,
60abdbed 13791 unsigned int tag,
643f7afb
AK		 13792 const unsigned char * const end)
13793{
13794 unsigned int len;
13795 int val;
13796
13797 if (tag == Tag_GNU_S390_ABI_Vector)
13798 {
13799 val = read_uleb128 (p, &len, end);
13800 p += len;
13801 printf (" Tag_GNU_S390_ABI_Vector: ");
13802
13803 switch (val)
13804 {
13805 case 0:
13806 printf (_("any\n"));
13807 break;
13808 case 1:
13809 printf (_("software\n"));
13810 break;
13811 case 2:
13812 printf (_("hardware\n"));
13813 break;
13814 default:
13815 printf ("??? (%d)\n", val);
13816 break;
13817 }
13818 return p;
13819 }
13820
13821 return display_tag_value (tag & 1, p, end);
13822}
13823
9e8c70f9 13824static void
60abdbed 13825display_sparc_hwcaps (unsigned int mask)
9e8c70f9
DM		 13826{
13827 if (mask)
13828 {
13829 int first = 1;
071436c6 13830
9e8c70f9
DM		 13831 if (mask & ELF_SPARC_HWCAP_MUL32)
13832 fputs ("mul32", stdout), first = 0;
13833 if (mask & ELF_SPARC_HWCAP_DIV32)
13834 printf ("%sdiv32", first ? "" : "|"), first = 0;
13835 if (mask & ELF_SPARC_HWCAP_FSMULD)
13836 printf ("%sfsmuld", first ? "" : "|"), first = 0;
13837 if (mask & ELF_SPARC_HWCAP_V8PLUS)
13838 printf ("%sv8plus", first ? "" : "|"), first = 0;
13839 if (mask & ELF_SPARC_HWCAP_POPC)
13840 printf ("%spopc", first ? "" : "|"), first = 0;
13841 if (mask & ELF_SPARC_HWCAP_VIS)
13842 printf ("%svis", first ? "" : "|"), first = 0;
13843 if (mask & ELF_SPARC_HWCAP_VIS2)
13844 printf ("%svis2", first ? "" : "|"), first = 0;
13845 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
13846 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
13847 if (mask & ELF_SPARC_HWCAP_FMAF)
13848 printf ("%sfmaf", first ? "" : "|"), first = 0;
13849 if (mask & ELF_SPARC_HWCAP_VIS3)
13850 printf ("%svis3", first ? "" : "|"), first = 0;
13851 if (mask & ELF_SPARC_HWCAP_HPC)
13852 printf ("%shpc", first ? "" : "|"), first = 0;
13853 if (mask & ELF_SPARC_HWCAP_RANDOM)
13854 printf ("%srandom", first ? "" : "|"), first = 0;
13855 if (mask & ELF_SPARC_HWCAP_TRANS)
13856 printf ("%strans", first ? "" : "|"), first = 0;
13857 if (mask & ELF_SPARC_HWCAP_FJFMAU)
13858 printf ("%sfjfmau", first ? "" : "|"), first = 0;
13859 if (mask & ELF_SPARC_HWCAP_IMA)
13860 printf ("%sima", first ? "" : "|"), first = 0;
13861 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
13862 printf ("%scspare", first ? "" : "|"), first = 0;
13863 }
13864 else
071436c6
NC		 13865 fputc ('0', stdout);
13866 fputc ('\n', stdout);
9e8c70f9
DM		 13867}
13868
3d68f91c 13869static void
60abdbed 13870display_sparc_hwcaps2 (unsigned int mask)
3d68f91c
JM		 13871{
13872 if (mask)
13873 {
13874 int first = 1;
071436c6 13875
3d68f91c
JM		 13876 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
13877 fputs ("fjathplus", stdout), first = 0;
13878 if (mask & ELF_SPARC_HWCAP2_VIS3B)
13879 printf ("%svis3b", first ? "" : "|"), first = 0;
13880 if (mask & ELF_SPARC_HWCAP2_ADP)
13881 printf ("%sadp", first ? "" : "|"), first = 0;
13882 if (mask & ELF_SPARC_HWCAP2_SPARC5)
13883 printf ("%ssparc5", first ? "" : "|"), first = 0;
13884 if (mask & ELF_SPARC_HWCAP2_MWAIT)
13885 printf ("%smwait", first ? "" : "|"), first = 0;
13886 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
13887 printf ("%sxmpmul", first ? "" : "|"), first = 0;
13888 if (mask & ELF_SPARC_HWCAP2_XMONT)
13889 printf ("%sxmont2", first ? "" : "|"), first = 0;
13890 if (mask & ELF_SPARC_HWCAP2_NSEC)
13891 printf ("%snsec", first ? "" : "|"), first = 0;
13892 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
13893 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
13894 if (mask & ELF_SPARC_HWCAP2_FJDES)
13895 printf ("%sfjdes", first ? "" : "|"), first = 0;
13896 if (mask & ELF_SPARC_HWCAP2_FJAES)
13897 printf ("%sfjaes", first ? "" : "|"), first = 0;
13898 }
13899 else
071436c6
NC		 13900 fputc ('0', stdout);
13901 fputc ('\n', stdout);
3d68f91c
JM		 13902}
13903
9e8c70f9 13904static unsigned char *
f6f0e17b 13905display_sparc_gnu_attribute (unsigned char * p,
60abdbed 13906 unsigned int tag,
f6f0e17b 13907 const unsigned char * const end)
9e8c70f9 13908{
3d68f91c
JM		 13909 unsigned int len;
13910 int val;
13911
9e8c70f9
DM		 13912 if (tag == Tag_GNU_Sparc_HWCAPS)
13913 {
f6f0e17b 13914 val = read_uleb128 (p, &len, end);
9e8c70f9
DM		 13915 p += len;
13916 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM		 13917 display_sparc_hwcaps (val);
13918 return p;
3d68f91c
JM		 13919 }
13920 if (tag == Tag_GNU_Sparc_HWCAPS2)
13921 {
13922 val = read_uleb128 (p, &len, end);
13923 p += len;
13924 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13925 display_sparc_hwcaps2 (val);
13926 return p;
13927 }
9e8c70f9 13928
f6f0e17b 13929 return display_tag_value (tag, p, end);
9e8c70f9
DM		 13930}
13931
351cdf24
MF		 13932static void
13933print_mips_fp_abi_value (int val)
13934{
13935 switch (val)
13936 {
13937 case Val_GNU_MIPS_ABI_FP_ANY:
13938 printf (_("Hard or soft float\n"));
13939 break;
13940 case Val_GNU_MIPS_ABI_FP_DOUBLE:
13941 printf (_("Hard float (double precision)\n"));
13942 break;
13943 case Val_GNU_MIPS_ABI_FP_SINGLE:
13944 printf (_("Hard float (single precision)\n"));
13945 break;
13946 case Val_GNU_MIPS_ABI_FP_SOFT:
13947 printf (_("Soft float\n"));
13948 break;
13949 case Val_GNU_MIPS_ABI_FP_OLD_64:
13950 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13951 break;
13952 case Val_GNU_MIPS_ABI_FP_XX:
13953 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13954 break;
13955 case Val_GNU_MIPS_ABI_FP_64:
13956 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13957 break;
13958 case Val_GNU_MIPS_ABI_FP_64A:
13959 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13960 break;
3350cc01
CM		 13961 case Val_GNU_MIPS_ABI_FP_NAN2008:
13962 printf (_("NaN 2008 compatibility\n"));
13963 break;
351cdf24
MF		 13964 default:
13965 printf ("??? (%d)\n", val);
13966 break;
13967 }
13968}
13969
2cf19d5c 13970static unsigned char *
f6f0e17b 13971display_mips_gnu_attribute (unsigned char * p,
60abdbed 13972 unsigned int tag,
f6f0e17b 13973 const unsigned char * const end)
2cf19d5c 13974{
2cf19d5c
JM		 13975 if (tag == Tag_GNU_MIPS_ABI_FP)
13976 {
f6f0e17b
NC		 13977 unsigned int len;
13978 int val;
13979
13980 val = read_uleb128 (p, &len, end);
2cf19d5c
JM		 13981 p += len;
13982 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 13983
351cdf24
MF		 13984 print_mips_fp_abi_value (val);
13985
2cf19d5c
JM		 13986 return p;
13987 }
13988
a9f58168
CF		 13989 if (tag == Tag_GNU_MIPS_ABI_MSA)
13990 {
13991 unsigned int len;
13992 int val;
13993
13994 val = read_uleb128 (p, &len, end);
13995 p += len;
13996 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13997
13998 switch (val)
13999 {
14000 case Val_GNU_MIPS_ABI_MSA_ANY:
14001 printf (_("Any MSA or not\n"));
14002 break;
14003 case Val_GNU_MIPS_ABI_MSA_128:
14004 printf (_("128-bit MSA\n"));
14005 break;
14006 default:
14007 printf ("??? (%d)\n", val);
14008 break;
14009 }
14010 return p;
14011 }
14012
f6f0e17b 14013 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM		 14014}
14015
59e6276b 14016static unsigned char *
f6f0e17b
NC		 14017display_tic6x_attribute (unsigned char * p,
14018 const unsigned char * const end)
59e6276b 14019{
60abdbed 14020 unsigned int tag;
59e6276b
JM		 14021 unsigned int len;
14022 int val;
14023
f6f0e17b 14024 tag = read_uleb128 (p, &len, end);
59e6276b
JM		 14025 p += len;
14026
14027 switch (tag)
14028 {
75fa6dc1 14029 case Tag_ISA:
f6f0e17b 14030 val = read_uleb128 (p, &len, end);
59e6276b 14031 p += len;
75fa6dc1 14032 printf (" Tag_ISA: ");
59e6276b
JM		 14033
14034 switch (val)
14035 {
75fa6dc1 14036 case C6XABI_Tag_ISA_none:
59e6276b
JM		 14037 printf (_("None\n"));
14038 break;
75fa6dc1 14039 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 14040 printf ("C62x\n");
14041 break;
75fa6dc1 14042 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 14043 printf ("C67x\n");
14044 break;
75fa6dc1 14045 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 14046 printf ("C67x+\n");
14047 break;
75fa6dc1 14048 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 14049 printf ("C64x\n");
14050 break;
75fa6dc1 14051 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 14052 printf ("C64x+\n");
14053 break;
75fa6dc1 14054 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 14055 printf ("C674x\n");
14056 break;
14057 default:
14058 printf ("??? (%d)\n", val);
14059 break;
14060 }
14061 return p;
14062
87779176 14063 case Tag_ABI_wchar_t:
f6f0e17b 14064 val = read_uleb128 (p, &len, end);
87779176
JM		 14065 p += len;
14066 printf (" Tag_ABI_wchar_t: ");
14067 switch (val)
14068 {
14069 case 0:
14070 printf (_("Not used\n"));
14071 break;
14072 case 1:
14073 printf (_("2 bytes\n"));
14074 break;
14075 case 2:
14076 printf (_("4 bytes\n"));
14077 break;
14078 default:
14079 printf ("??? (%d)\n", val);
14080 break;
14081 }
14082 return p;
14083
14084 case Tag_ABI_stack_align_needed:
f6f0e17b 14085 val = read_uleb128 (p, &len, end);
87779176
JM		 14086 p += len;
14087 printf (" Tag_ABI_stack_align_needed: ");
14088 switch (val)
14089 {
14090 case 0:
14091 printf (_("8-byte\n"));
14092 break;
14093 case 1:
14094 printf (_("16-byte\n"));
14095 break;
14096 default:
14097 printf ("??? (%d)\n", val);
14098 break;
14099 }
14100 return p;
14101
14102 case Tag_ABI_stack_align_preserved:
f6f0e17b 14103 val = read_uleb128 (p, &len, end);
87779176
JM		 14104 p += len;
14105 printf (" Tag_ABI_stack_align_preserved: ");
14106 switch (val)
14107 {
14108 case 0:
14109 printf (_("8-byte\n"));
14110 break;
14111 case 1:
14112 printf (_("16-byte\n"));
14113 break;
14114 default:
14115 printf ("??? (%d)\n", val);
14116 break;
14117 }
14118 return p;
14119
b5593623 14120 case Tag_ABI_DSBT:
f6f0e17b 14121 val = read_uleb128 (p, &len, end);
b5593623
JM		 14122 p += len;
14123 printf (" Tag_ABI_DSBT: ");
14124 switch (val)
14125 {
14126 case 0:
14127 printf (_("DSBT addressing not used\n"));
14128 break;
14129 case 1:
14130 printf (_("DSBT addressing used\n"));
14131 break;
14132 default:
14133 printf ("??? (%d)\n", val);
14134 break;
14135 }
14136 return p;
14137
87779176 14138 case Tag_ABI_PID:
f6f0e17b 14139 val = read_uleb128 (p, &len, end);
87779176
JM		 14140 p += len;
14141 printf (" Tag_ABI_PID: ");
14142 switch (val)
14143 {
14144 case 0:
14145 printf (_("Data addressing position-dependent\n"));
14146 break;
14147 case 1:
14148 printf (_("Data addressing position-independent, GOT near DP\n"));
14149 break;
14150 case 2:
14151 printf (_("Data addressing position-independent, GOT far from DP\n"));
14152 break;
14153 default:
14154 printf ("??? (%d)\n", val);
14155 break;
14156 }
14157 return p;
14158
14159 case Tag_ABI_PIC:
f6f0e17b 14160 val = read_uleb128 (p, &len, end);
87779176
JM		 14161 p += len;
14162 printf (" Tag_ABI_PIC: ");
14163 switch (val)
14164 {
14165 case 0:
14166 printf (_("Code addressing position-dependent\n"));
14167 break;
14168 case 1:
14169 printf (_("Code addressing position-independent\n"));
14170 break;
14171 default:
14172 printf ("??? (%d)\n", val);
14173 break;
14174 }
14175 return p;
14176
14177 case Tag_ABI_array_object_alignment:
f6f0e17b 14178 val = read_uleb128 (p, &len, end);
87779176
JM		 14179 p += len;
14180 printf (" Tag_ABI_array_object_alignment: ");
14181 switch (val)
14182 {
14183 case 0:
14184 printf (_("8-byte\n"));
14185 break;
14186 case 1:
14187 printf (_("4-byte\n"));
14188 break;
14189 case 2:
14190 printf (_("16-byte\n"));
14191 break;
14192 default:
14193 printf ("??? (%d)\n", val);
14194 break;
14195 }
14196 return p;
14197
14198 case Tag_ABI_array_object_align_expected:
f6f0e17b 14199 val = read_uleb128 (p, &len, end);
87779176
JM		 14200 p += len;
14201 printf (" Tag_ABI_array_object_align_expected: ");
14202 switch (val)
14203 {
14204 case 0:
14205 printf (_("8-byte\n"));
14206 break;
14207 case 1:
14208 printf (_("4-byte\n"));
14209 break;
14210 case 2:
14211 printf (_("16-byte\n"));
14212 break;
14213 default:
14214 printf ("??? (%d)\n", val);
14215 break;
14216 }
14217 return p;
14218
3cbd1c06 14219 case Tag_ABI_compatibility:
071436c6 14220 {
071436c6
NC		 14221 val = read_uleb128 (p, &len, end);
14222 p += len;
14223 printf (" Tag_ABI_compatibility: ");
071436c6 14224 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 14225 if (p < end - 1)
14226 {
14227 size_t maxlen = (end - p) - 1;
14228
14229 print_symbol ((int) maxlen, (const char *) p);
14230 p += strnlen ((char *) p, maxlen) + 1;
14231 }
14232 else
14233 {
14234 printf (_("<corrupt>"));
14235 p = (unsigned char *) end;
14236 }
071436c6 14237 putchar ('\n');
071436c6
NC		 14238 return p;
14239 }
87779176
JM		 14240
14241 case Tag_ABI_conformance:
071436c6 14242 {
4082ef84
NC		 14243 printf (" Tag_ABI_conformance: \"");
14244 if (p < end - 1)
14245 {
14246 size_t maxlen = (end - p) - 1;
071436c6 14247
4082ef84
NC		 14248 print_symbol ((int) maxlen, (const char *) p);
14249 p += strnlen ((char *) p, maxlen) + 1;
14250 }
14251 else
14252 {
14253 printf (_("<corrupt>"));
14254 p = (unsigned char *) end;
14255 }
071436c6 14256 printf ("\"\n");
071436c6
NC		 14257 return p;
14258 }
59e6276b
JM		 14259 }
14260
f6f0e17b
NC		 14261 return display_tag_value (tag, p, end);
14262}
59e6276b 14263
f6f0e17b 14264static void
60abdbed 14265display_raw_attribute (unsigned char * p, unsigned char const * const end)
f6f0e17b
NC		 14266{
14267 unsigned long addr = 0;
14268 size_t bytes = end - p;
14269
e0a31db1 14270 assert (end > p);
f6f0e17b 14271 while (bytes)
87779176 14272 {
f6f0e17b
NC		 14273 int j;
14274 int k;
14275 int lbytes = (bytes > 16 ? 16 : bytes);
14276
14277 printf (" 0x%8.8lx ", addr);
14278
14279 for (j = 0; j < 16; j++)
14280 {
14281 if (j < lbytes)
14282 printf ("%2.2x", p[j]);
14283 else
14284 printf (" ");
14285
14286 if ((j & 3) == 3)
14287 printf (" ");
14288 }
14289
14290 for (j = 0; j < lbytes; j++)
14291 {
14292 k = p[j];
14293 if (k >= ' ' && k < 0x7f)
14294 printf ("%c", k);
14295 else
14296 printf (".");
14297 }
14298
14299 putchar ('\n');
14300
14301 p += lbytes;
14302 bytes -= lbytes;
14303 addr += lbytes;
87779176 14304 }
59e6276b 14305
f6f0e17b 14306 putchar ('\n');
59e6276b
JM		 14307}
14308
13761a11
NC		 14309static unsigned char *
14310display_msp430x_attribute (unsigned char * p,
14311 const unsigned char * const end)
14312{
14313 unsigned int len;
60abdbed
NC		 14314 unsigned int val;
14315 unsigned int tag;
13761a11
NC		 14316
14317 tag = read_uleb128 (p, & len, end);
14318 p += len;
0b4362b0 14319
13761a11
NC		 14320 switch (tag)
14321 {
14322 case OFBA_MSPABI_Tag_ISA:
14323 val = read_uleb128 (p, &len, end);
14324 p += len;
14325 printf (" Tag_ISA: ");
14326 switch (val)
14327 {
14328 case 0: printf (_("None\n")); break;
14329 case 1: printf (_("MSP430\n")); break;
14330 case 2: printf (_("MSP430X\n")); break;
14331 default: printf ("??? (%d)\n", val); break;
14332 }
14333 break;
14334
14335 case OFBA_MSPABI_Tag_Code_Model:
14336 val = read_uleb128 (p, &len, end);
14337 p += len;
14338 printf (" Tag_Code_Model: ");
14339 switch (val)
14340 {
14341 case 0: printf (_("None\n")); break;
14342 case 1: printf (_("Small\n")); break;
14343 case 2: printf (_("Large\n")); break;
14344 default: printf ("??? (%d)\n", val); break;
14345 }
14346 break;
14347
14348 case OFBA_MSPABI_Tag_Data_Model:
14349 val = read_uleb128 (p, &len, end);
14350 p += len;
14351 printf (" Tag_Data_Model: ");
14352 switch (val)
14353 {
14354 case 0: printf (_("None\n")); break;
14355 case 1: printf (_("Small\n")); break;
14356 case 2: printf (_("Large\n")); break;
14357 case 3: printf (_("Restricted Large\n")); break;
14358 default: printf ("??? (%d)\n", val); break;
14359 }
14360 break;
14361
14362 default:
14363 printf (_(" <unknown tag %d>: "), tag);
14364
14365 if (tag & 1)
14366 {
071436c6 14367 putchar ('"');
4082ef84
NC		 14368 if (p < end - 1)
14369 {
14370 size_t maxlen = (end - p) - 1;
14371
14372 print_symbol ((int) maxlen, (const char *) p);
14373 p += strnlen ((char *) p, maxlen) + 1;
14374 }
14375 else
14376 {
14377 printf (_("<corrupt>"));
14378 p = (unsigned char *) end;
14379 }
071436c6 14380 printf ("\"\n");
13761a11
NC		 14381 }
14382 else
14383 {
14384 val = read_uleb128 (p, &len, end);
14385 p += len;
14386 printf ("%d (0x%x)\n", val, val);
14387 }
14388 break;
14389 }
14390
4082ef84 14391 assert (p <= end);
13761a11
NC		 14392 return p;
14393}
14394
11c1ff18 14395static int
60bca95a
NC		 14396process_attributes (FILE * file,
14397 const char * public_name,
104d59d1 14398 unsigned int proc_type,
f6f0e17b 14399 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
60abdbed 14400 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
11c1ff18 14401{
2cf0635d 14402 Elf_Internal_Shdr * sect;
11c1ff18
PB		 14403 unsigned i;
14404
14405 /* Find the section header so that we get the size. */
14406 for (i = 0, sect = section_headers;
14407 i < elf_header.e_shnum;
14408 i++, sect++)
14409 {
071436c6
NC		 14410 unsigned char * contents;
14411 unsigned char * p;
14412
104d59d1 14413 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 14414 continue;
14415
3f5e193b
NC		 14416 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
14417 sect->sh_size, _("attributes"));
60bca95a 14418 if (contents == NULL)
11c1ff18 14419 continue;
60bca95a 14420
11c1ff18 14421 p = contents;
60abdbed
NC		 14422 /* The first character is the version of the attributes.
14423 Currently only version 1, (aka 'A') is recognised here. */
14424 if (*p != 'A')
14425 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
14426 else
11c1ff18 14427 {
071436c6
NC		 14428 bfd_vma section_len;
14429
14430 section_len = sect->sh_size - 1;
11c1ff18 14431 p++;
60bca95a 14432
071436c6 14433 while (section_len > 0)
11c1ff18 14434 {
071436c6 14435 bfd_vma attr_len;
e9847026 14436 unsigned int namelen;
11c1ff18 14437 bfd_boolean public_section;
104d59d1 14438 bfd_boolean gnu_section;
11c1ff18 14439
071436c6 14440 if (section_len <= 4)
e0a31db1
NC		 14441 {
14442 error (_("Tag section ends prematurely\n"));
14443 break;
14444 }
071436c6 14445 attr_len = byte_get (p, 4);
11c1ff18 14446 p += 4;
60bca95a 14447
071436c6 14448 if (attr_len > section_len)
11c1ff18 14449 {
071436c6
NC		 14450 error (_("Bad attribute length (%u > %u)\n"),
14451 (unsigned) attr_len, (unsigned) section_len);
14452 attr_len = section_len;
11c1ff18 14453 }
74e1a04b 14454 /* PR 17531: file: 001-101425-0.004 */
071436c6 14455 else if (attr_len < 5)
74e1a04b 14456 {
071436c6 14457 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
74e1a04b
NC		 14458 break;
14459 }
e9847026 14460
071436c6
NC		 14461 section_len -= attr_len;
14462 attr_len -= 4;
14463
14464 namelen = strnlen ((char *) p, attr_len) + 1;
14465 if (namelen == 0 || namelen >= attr_len)
e9847026
NC		 14466 {
14467 error (_("Corrupt attribute section name\n"));
14468 break;
14469 }
14470
071436c6
NC		 14471 printf (_("Attribute Section: "));
14472 print_symbol (INT_MAX, (const char *) p);
14473 putchar ('\n');
60bca95a
NC		 14474
14475 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 14476 public_section = TRUE;
14477 else
14478 public_section = FALSE;
60bca95a
NC		 14479
14480 if (streq ((char *) p, "gnu"))
104d59d1
JM		 14481 gnu_section = TRUE;
14482 else
14483 gnu_section = FALSE;
60bca95a 14484
11c1ff18 14485 p += namelen;
071436c6 14486 attr_len -= namelen;
e0a31db1 14487
071436c6 14488 while (attr_len > 0 && p < contents + sect->sh_size)
11c1ff18 14489 {
e0a31db1 14490 int tag;
11c1ff18
PB		 14491 int val;
14492 bfd_vma size;
071436c6 14493 unsigned char * end;
60bca95a 14494
e0a31db1 14495 /* PR binutils/17531: Safe handling of corrupt files. */
071436c6 14496 if (attr_len < 6)
e0a31db1
NC		 14497 {
14498 error (_("Unused bytes at end of section\n"));
14499 section_len = 0;
14500 break;
14501 }
14502
14503 tag = *(p++);
11c1ff18 14504 size = byte_get (p, 4);
071436c6 14505 if (size > attr_len)
11c1ff18 14506 {
e9847026 14507 error (_("Bad subsection length (%u > %u)\n"),
071436c6
NC		 14508 (unsigned) size, (unsigned) attr_len);
14509 size = attr_len;
11c1ff18 14510 }
e0a31db1
NC		 14511 /* PR binutils/17531: Safe handling of corrupt files. */
14512 if (size < 6)
14513 {
14514 error (_("Bad subsection length (%u < 6)\n"),
14515 (unsigned) size);
14516 section_len = 0;
14517 break;
14518 }
60bca95a 14519
071436c6 14520 attr_len -= size;
11c1ff18 14521 end = p + size - 1;
071436c6 14522 assert (end <= contents + sect->sh_size);
11c1ff18 14523 p += 4;
60bca95a 14524
11c1ff18
PB		 14525 switch (tag)
14526 {
14527 case 1:
2b692964 14528 printf (_("File Attributes\n"));
11c1ff18
PB		 14529 break;
14530 case 2:
2b692964 14531 printf (_("Section Attributes:"));
11c1ff18
PB		 14532 goto do_numlist;
14533 case 3:
2b692964 14534 printf (_("Symbol Attributes:"));
1a0670f3 14535 /* Fall through. */
11c1ff18
PB		 14536 do_numlist:
14537 for (;;)
14538 {
91d6fa6a 14539 unsigned int j;
60bca95a 14540
f6f0e17b 14541 val = read_uleb128 (p, &j, end);
91d6fa6a 14542 p += j;
11c1ff18
PB		 14543 if (val == 0)
14544 break;
14545 printf (" %d", val);
14546 }
14547 printf ("\n");
14548 break;
14549 default:
2b692964 14550 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 14551 public_section = FALSE;
14552 break;
14553 }
60bca95a 14554
071436c6 14555 if (public_section && display_pub_attribute != NULL)
11c1ff18
PB		 14556 {
14557 while (p < end)
f6f0e17b 14558 p = display_pub_attribute (p, end);
60abdbed 14559 assert (p == end);
104d59d1 14560 }
071436c6 14561 else if (gnu_section && display_proc_gnu_attribute != NULL)
104d59d1
JM		 14562 {
14563 while (p < end)
14564 p = display_gnu_attribute (p,
f6f0e17b
NC		 14565 display_proc_gnu_attribute,
14566 end);
60abdbed 14567 assert (p == end);
11c1ff18 14568 }
071436c6 14569 else if (p < end)
11c1ff18 14570 {
071436c6 14571 printf (_(" Unknown attribute:\n"));
f6f0e17b 14572 display_raw_attribute (p, end);
11c1ff18
PB		 14573 p = end;
14574 }
071436c6
NC		 14575 else
14576 attr_len = 0;
11c1ff18
PB		 14577 }
14578 }
14579 }
d70c5fc7 14580
60bca95a 14581 free (contents);
11c1ff18
PB		 14582 }
14583 return 1;
14584}
14585
ccb4c951
RS		 14586/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14587 Print the Address, Access and Initial fields of an entry at VMA ADDR
82b1b41b
NC		 14588 and return the VMA of the next entry, or -1 if there was a problem.
14589 Does not read from DATA_END or beyond. */
ccb4c951
RS		 14590
14591static bfd_vma
82b1b41b
NC		 14592print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
14593 unsigned char * data_end)
ccb4c951
RS		 14594{
14595 printf (" ");
14596 print_vma (addr, LONG_HEX);
14597 printf (" ");
14598 if (addr < pltgot + 0xfff0)
14599 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
14600 else
14601 printf ("%10s", "");
14602 printf (" ");
14603 if (data == NULL)
2b692964 14604 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 14605 else
14606 {
14607 bfd_vma entry;
82b1b41b 14608 unsigned char * from = data + addr - pltgot;
ccb4c951 14609
82b1b41b
NC		 14610 if (from + (is_32bit_elf ? 4 : 8) > data_end)
14611 {
14612 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14613 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
14614 return (bfd_vma) -1;
14615 }
14616 else
14617 {
14618 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14619 print_vma (entry, LONG_HEX);
14620 }
ccb4c951
RS		 14621 }
14622 return addr + (is_32bit_elf ? 4 : 8);
14623}
14624
861fb55a
DJ		 14625/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14626 PLTGOT. Print the Address and Initial fields of an entry at VMA
14627 ADDR and return the VMA of the next entry. */
14628
14629static bfd_vma
2cf0635d 14630print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 14631{
14632 printf (" ");
14633 print_vma (addr, LONG_HEX);
14634 printf (" ");
14635 if (data == NULL)
2b692964 14636 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 14637 else
14638 {
14639 bfd_vma entry;
14640
14641 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14642 print_vma (entry, LONG_HEX);
14643 }
14644 return addr + (is_32bit_elf ? 4 : 8);
14645}
14646
351cdf24
MF		 14647static void
14648print_mips_ases (unsigned int mask)
14649{
14650 if (mask & AFL_ASE_DSP)
14651 fputs ("\n\tDSP ASE", stdout);
14652 if (mask & AFL_ASE_DSPR2)
14653 fputs ("\n\tDSP R2 ASE", stdout);
8f4f9071
MF		 14654 if (mask & AFL_ASE_DSPR3)
14655 fputs ("\n\tDSP R3 ASE", stdout);
351cdf24
MF		 14656 if (mask & AFL_ASE_EVA)
14657 fputs ("\n\tEnhanced VA Scheme", stdout);
14658 if (mask & AFL_ASE_MCU)
14659 fputs ("\n\tMCU (MicroController) ASE", stdout);
14660 if (mask & AFL_ASE_MDMX)
14661 fputs ("\n\tMDMX ASE", stdout);
14662 if (mask & AFL_ASE_MIPS3D)
14663 fputs ("\n\tMIPS-3D ASE", stdout);
14664 if (mask & AFL_ASE_MT)
14665 fputs ("\n\tMT ASE", stdout);
14666 if (mask & AFL_ASE_SMARTMIPS)
14667 fputs ("\n\tSmartMIPS ASE", stdout);
14668 if (mask & AFL_ASE_VIRT)
14669 fputs ("\n\tVZ ASE", stdout);
14670 if (mask & AFL_ASE_MSA)
14671 fputs ("\n\tMSA ASE", stdout);
14672 if (mask & AFL_ASE_MIPS16)
14673 fputs ("\n\tMIPS16 ASE", stdout);
14674 if (mask & AFL_ASE_MICROMIPS)
14675 fputs ("\n\tMICROMIPS ASE", stdout);
14676 if (mask & AFL_ASE_XPA)
14677 fputs ("\n\tXPA ASE", stdout);
14678 if (mask == 0)
14679 fprintf (stdout, "\n\t%s", _("None"));
00ac7aa0
MF		 14680 else if ((mask & ~AFL_ASE_MASK) != 0)
14681 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
351cdf24
MF		 14682}
14683
14684static void
14685print_mips_isa_ext (unsigned int isa_ext)
14686{
14687 switch (isa_ext)
14688 {
14689 case 0:
14690 fputs (_("None"), stdout);
14691 break;
14692 case AFL_EXT_XLR:
14693 fputs ("RMI XLR", stdout);
14694 break;
2c629856
N		 14695 case AFL_EXT_OCTEON3:
14696 fputs ("Cavium Networks Octeon3", stdout);
14697 break;
351cdf24
MF		 14698 case AFL_EXT_OCTEON2:
14699 fputs ("Cavium Networks Octeon2", stdout);
14700 break;
14701 case AFL_EXT_OCTEONP:
14702 fputs ("Cavium Networks OcteonP", stdout);
14703 break;
14704 case AFL_EXT_LOONGSON_3A:
14705 fputs ("Loongson 3A", stdout);
14706 break;
14707 case AFL_EXT_OCTEON:
14708 fputs ("Cavium Networks Octeon", stdout);
14709 break;
14710 case AFL_EXT_5900:
14711 fputs ("Toshiba R5900", stdout);
14712 break;
14713 case AFL_EXT_4650:
14714 fputs ("MIPS R4650", stdout);
14715 break;
14716 case AFL_EXT_4010:
14717 fputs ("LSI R4010", stdout);
14718 break;
14719 case AFL_EXT_4100:
14720 fputs ("NEC VR4100", stdout);
14721 break;
14722 case AFL_EXT_3900:
14723 fputs ("Toshiba R3900", stdout);
14724 break;
14725 case AFL_EXT_10000:
14726 fputs ("MIPS R10000", stdout);
14727 break;
14728 case AFL_EXT_SB1:
14729 fputs ("Broadcom SB-1", stdout);
14730 break;
14731 case AFL_EXT_4111:
14732 fputs ("NEC VR4111/VR4181", stdout);
14733 break;
14734 case AFL_EXT_4120:
14735 fputs ("NEC VR4120", stdout);
14736 break;
14737 case AFL_EXT_5400:
14738 fputs ("NEC VR5400", stdout);
14739 break;
14740 case AFL_EXT_5500:
14741 fputs ("NEC VR5500", stdout);
14742 break;
14743 case AFL_EXT_LOONGSON_2E:
14744 fputs ("ST Microelectronics Loongson 2E", stdout);
14745 break;
14746 case AFL_EXT_LOONGSON_2F:
14747 fputs ("ST Microelectronics Loongson 2F", stdout);
14748 break;
14749 default:
00ac7aa0 14750 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
351cdf24
MF		 14751 }
14752}
14753
14754static int
14755get_mips_reg_size (int reg_size)
14756{
14757 return (reg_size == AFL_REG_NONE) ? 0
14758 : (reg_size == AFL_REG_32) ? 32
14759 : (reg_size == AFL_REG_64) ? 64
14760 : (reg_size == AFL_REG_128) ? 128
14761 : -1;
14762}
14763
19e6b90e 14764static int
2cf0635d 14765process_mips_specific (FILE * file)
5b18a4bc 14766{
2cf0635d 14767 Elf_Internal_Dyn * entry;
351cdf24 14768 Elf_Internal_Shdr *sect = NULL;
19e6b90e
L		 14769 size_t liblist_offset = 0;
14770 size_t liblistno = 0;
14771 size_t conflictsno = 0;
14772 size_t options_offset = 0;
14773 size_t conflicts_offset = 0;
861fb55a
DJ		 14774 size_t pltrelsz = 0;
14775 size_t pltrel = 0;
ccb4c951 14776 bfd_vma pltgot = 0;
861fb55a
DJ		 14777 bfd_vma mips_pltgot = 0;
14778 bfd_vma jmprel = 0;
ccb4c951
RS		 14779 bfd_vma local_gotno = 0;
14780 bfd_vma gotsym = 0;
14781 bfd_vma symtabno = 0;
103f02d3 14782
2cf19d5c
JM		 14783 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14784 display_mips_gnu_attribute);
14785
351cdf24
MF		 14786 sect = find_section (".MIPS.abiflags");
14787
14788 if (sect != NULL)
14789 {
14790 Elf_External_ABIFlags_v0 *abiflags_ext;
14791 Elf_Internal_ABIFlags_v0 abiflags_in;
14792
14793 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
14794 fputs ("\nCorrupt ABI Flags section.\n", stdout);
14795 else
14796 {
14797 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
14798 sect->sh_size, _("MIPS ABI Flags section"));
14799 if (abiflags_ext)
14800 {
14801 abiflags_in.version = BYTE_GET (abiflags_ext->version);
14802 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
14803 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
14804 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
14805 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
14806 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
14807 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
14808 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
14809 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
14810 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
14811 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
14812
14813 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
14814 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
14815 if (abiflags_in.isa_rev > 1)
14816 printf ("r%d", abiflags_in.isa_rev);
14817 printf ("\nGPR size: %d",
14818 get_mips_reg_size (abiflags_in.gpr_size));
14819 printf ("\nCPR1 size: %d",
14820 get_mips_reg_size (abiflags_in.cpr1_size));
14821 printf ("\nCPR2 size: %d",
14822 get_mips_reg_size (abiflags_in.cpr2_size));
14823 fputs ("\nFP ABI: ", stdout);
14824 print_mips_fp_abi_value (abiflags_in.fp_abi);
14825 fputs ("ISA Extension: ", stdout);
14826 print_mips_isa_ext (abiflags_in.isa_ext);
14827 fputs ("\nASEs:", stdout);
14828 print_mips_ases (abiflags_in.ases);
14829 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
14830 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
14831 fputc ('\n', stdout);
14832 free (abiflags_ext);
14833 }
14834 }
14835 }
14836
19e6b90e
L		 14837 /* We have a lot of special sections. Thanks SGI! */
14838 if (dynamic_section == NULL)
14839 /* No information available. */
14840 return 0;
252b5132 14841
071436c6
NC		 14842 for (entry = dynamic_section;
14843 /* PR 17531 file: 012-50589-0.004. */
14844 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
14845 ++entry)
252b5132
RH		 14846 switch (entry->d_tag)
14847 {
14848 case DT_MIPS_LIBLIST:
d93f0186
NC		 14849 liblist_offset
14850 = offset_from_vma (file, entry->d_un.d_val,
14851 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 14852 break;
14853 case DT_MIPS_LIBLISTNO:
14854 liblistno = entry->d_un.d_val;
14855 break;
14856 case DT_MIPS_OPTIONS:
d93f0186 14857 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 14858 break;
14859 case DT_MIPS_CONFLICT:
d93f0186
NC		 14860 conflicts_offset
14861 = offset_from_vma (file, entry->d_un.d_val,
14862 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 14863 break;
14864 case DT_MIPS_CONFLICTNO:
14865 conflictsno = entry->d_un.d_val;
14866 break;
ccb4c951 14867 case DT_PLTGOT:
861fb55a
DJ		 14868 pltgot = entry->d_un.d_ptr;
14869 break;
ccb4c951
RS		 14870 case DT_MIPS_LOCAL_GOTNO:
14871 local_gotno = entry->d_un.d_val;
14872 break;
14873 case DT_MIPS_GOTSYM:
14874 gotsym = entry->d_un.d_val;
14875 break;
14876 case DT_MIPS_SYMTABNO:
14877 symtabno = entry->d_un.d_val;
14878 break;
861fb55a
DJ		 14879 case DT_MIPS_PLTGOT:
14880 mips_pltgot = entry->d_un.d_ptr;
14881 break;
14882 case DT_PLTREL:
14883 pltrel = entry->d_un.d_val;
14884 break;
14885 case DT_PLTRELSZ:
14886 pltrelsz = entry->d_un.d_val;
14887 break;
14888 case DT_JMPREL:
14889 jmprel = entry->d_un.d_ptr;
14890 break;
252b5132
RH		 14891 default:
14892 break;
14893 }
14894
14895 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
14896 {
2cf0635d 14897 Elf32_External_Lib * elib;
252b5132
RH		 14898 size_t cnt;
14899
3f5e193b
NC		 14900 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
14901 liblistno,
14902 sizeof (Elf32_External_Lib),
9cf03b7e 14903 _("liblist section data"));
a6e9f9df 14904 if (elib)
252b5132 14905 {
2b692964 14906 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 14907 (unsigned long) liblistno);
2b692964 14908 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 14909 stdout);
14910
14911 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 14912 {
a6e9f9df 14913 Elf32_Lib liblist;
91d6fa6a 14914 time_t atime;
d5b07ef4 14915 char timebuf[128];
2cf0635d 14916 struct tm * tmp;
a6e9f9df
AM		 14917
14918 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14919 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 14920 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14921 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14922 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14923
91d6fa6a 14924 tmp = gmtime (&atime);
e9e44622
JJ		 14925 snprintf (timebuf, sizeof (timebuf),
14926 "%04u-%02u-%02uT%02u:%02u:%02u",
14927 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14928 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 14929
31104126 14930 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 14931 if (VALID_DYNAMIC_NAME (liblist.l_name))
14932 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
14933 else
2b692964 14934 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 14935 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
14936 liblist.l_version);
a6e9f9df
AM		 14937
14938 if (liblist.l_flags == 0)
2b692964 14939 puts (_(" NONE"));
a6e9f9df
AM		 14940 else
14941 {
14942 static const struct
252b5132 14943 {
2cf0635d 14944 const char * name;
a6e9f9df 14945 int bit;
252b5132 14946 }
a6e9f9df
AM		 14947 l_flags_vals[] =
14948 {
14949 { " EXACT_MATCH", LL_EXACT_MATCH },
14950 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
14951 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
14952 { " EXPORTS", LL_EXPORTS },
14953 { " DELAY_LOAD", LL_DELAY_LOAD },
14954 { " DELTA", LL_DELTA }
14955 };
14956 int flags = liblist.l_flags;
14957 size_t fcnt;
14958
60bca95a 14959 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 14960 if ((flags & l_flags_vals[fcnt].bit) != 0)
14961 {
14962 fputs (l_flags_vals[fcnt].name, stdout);
14963 flags ^= l_flags_vals[fcnt].bit;
14964 }
14965 if (flags != 0)
14966 printf (" %#x", (unsigned int) flags);
252b5132 14967
a6e9f9df
AM		 14968 puts ("");
14969 }
252b5132 14970 }
252b5132 14971
a6e9f9df
AM		 14972 free (elib);
14973 }
252b5132
RH		 14974 }
14975
14976 if (options_offset != 0)
14977 {
2cf0635d 14978 Elf_External_Options * eopt;
2cf0635d
NC		 14979 Elf_Internal_Options * iopt;
14980 Elf_Internal_Options * option;
252b5132
RH		 14981 size_t offset;
14982 int cnt;
351cdf24 14983 sect = section_headers;
252b5132
RH		 14984
14985 /* Find the section header so that we get the size. */
071436c6 14986 sect = find_section_by_type (SHT_MIPS_OPTIONS);
948f632f 14987 /* PR 17533 file: 012-277276-0.004. */
071436c6
NC		 14988 if (sect == NULL)
14989 {
14990 error (_("No MIPS_OPTIONS header found\n"));
14991 return 0;
14992 }
252b5132 14993
3f5e193b
NC		 14994 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
14995 sect->sh_size, _("options"));
a6e9f9df 14996 if (eopt)
252b5132 14997 {
3f5e193b
NC		 14998 iopt = (Elf_Internal_Options *)
14999 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 15000 if (iopt == NULL)
15001 {
fb324ee9 15002 error (_("Out of memory allocating space for MIPS options\n"));
a6e9f9df
AM		 15003 return 0;
15004 }
76da6bbe 15005
a6e9f9df
AM		 15006 offset = cnt = 0;
15007 option = iopt;
252b5132 15008
82b1b41b 15009 while (offset <= sect->sh_size - sizeof (* eopt))
a6e9f9df 15010 {
2cf0635d 15011 Elf_External_Options * eoption;
252b5132 15012
a6e9f9df 15013 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 15014
a6e9f9df
AM		 15015 option->kind = BYTE_GET (eoption->kind);
15016 option->size = BYTE_GET (eoption->size);
15017 option->section = BYTE_GET (eoption->section);
15018 option->info = BYTE_GET (eoption->info);
76da6bbe 15019
82b1b41b
NC		 15020 /* PR 17531: file: ffa0fa3b. */
15021 if (option->size < sizeof (* eopt)
15022 || offset + option->size > sect->sh_size)
15023 {
55325047
NC		 15024 error (_("Invalid size (%u) for MIPS option\n"), option->size);
15025 return 0;
82b1b41b 15026 }
a6e9f9df 15027 offset += option->size;
14ae95f2 15028
a6e9f9df
AM		 15029 ++option;
15030 ++cnt;
15031 }
252b5132 15032
a6e9f9df 15033 printf (_("\nSection '%s' contains %d entries:\n"),
74e1a04b 15034 printable_section_name (sect), cnt);
76da6bbe 15035
a6e9f9df 15036 option = iopt;
82b1b41b 15037 offset = 0;
252b5132 15038
a6e9f9df 15039 while (cnt-- > 0)
252b5132 15040 {
a6e9f9df
AM		 15041 size_t len;
15042
15043 switch (option->kind)
252b5132 15044 {
a6e9f9df
AM		 15045 case ODK_NULL:
15046 /* This shouldn't happen. */
15047 printf (" NULL %d %lx", option->section, option->info);
15048 break;
15049 case ODK_REGINFO:
15050 printf (" REGINFO ");
15051 if (elf_header.e_machine == EM_MIPS)
15052 {
15053 /* 32bit form. */
2cf0635d 15054 Elf32_External_RegInfo * ereg;
b34976b6 15055 Elf32_RegInfo reginfo;
a6e9f9df
AM		 15056
15057 ereg = (Elf32_External_RegInfo *) (option + 1);
15058 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
15059 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15060 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15061 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15062 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15063 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
15064
15065 printf ("GPR %08lx GP 0x%lx\n",
15066 reginfo.ri_gprmask,
15067 (unsigned long) reginfo.ri_gp_value);
15068 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15069 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15070 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15071 }
15072 else
15073 {
15074 /* 64 bit form. */
2cf0635d 15075 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 15076 Elf64_Internal_RegInfo reginfo;
15077
15078 ereg = (Elf64_External_RegInfo *) (option + 1);
15079 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
15080 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15081 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15082 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15083 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 15084 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 15085
15086 printf ("GPR %08lx GP 0x",
15087 reginfo.ri_gprmask);
15088 printf_vma (reginfo.ri_gp_value);
15089 printf ("\n");
15090
15091 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15092 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15093 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15094 }
15095 ++option;
15096 continue;
15097 case ODK_EXCEPTIONS:
15098 fputs (" EXCEPTIONS fpe_min(", stdout);
15099 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
15100 fputs (") fpe_max(", stdout);
15101 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
15102 fputs (")", stdout);
15103
15104 if (option->info & OEX_PAGE0)
15105 fputs (" PAGE0", stdout);
15106 if (option->info & OEX_SMM)
15107 fputs (" SMM", stdout);
15108 if (option->info & OEX_FPDBUG)
15109 fputs (" FPDBUG", stdout);
15110 if (option->info & OEX_DISMISS)
15111 fputs (" DISMISS", stdout);
15112 break;
15113 case ODK_PAD:
15114 fputs (" PAD ", stdout);
15115 if (option->info & OPAD_PREFIX)
15116 fputs (" PREFIX", stdout);
15117 if (option->info & OPAD_POSTFIX)
15118 fputs (" POSTFIX", stdout);
15119 if (option->info & OPAD_SYMBOL)
15120 fputs (" SYMBOL", stdout);
15121 break;
15122 case ODK_HWPATCH:
15123 fputs (" HWPATCH ", stdout);
15124 if (option->info & OHW_R4KEOP)
15125 fputs (" R4KEOP", stdout);
15126 if (option->info & OHW_R8KPFETCH)
15127 fputs (" R8KPFETCH", stdout);
15128 if (option->info & OHW_R5KEOP)
15129 fputs (" R5KEOP", stdout);
15130 if (option->info & OHW_R5KCVTL)
15131 fputs (" R5KCVTL", stdout);
15132 break;
15133 case ODK_FILL:
15134 fputs (" FILL ", stdout);
15135 /* XXX Print content of info word? */
15136 break;
15137 case ODK_TAGS:
15138 fputs (" TAGS ", stdout);
15139 /* XXX Print content of info word? */
15140 break;
15141 case ODK_HWAND:
15142 fputs (" HWAND ", 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_HWOR:
15149 fputs (" HWOR ", stdout);
15150 if (option->info & OHWA0_R4KEOP_CHECKED)
15151 fputs (" R4KEOP_CHECKED", stdout);
15152 if (option->info & OHWA0_R4KEOP_CLEAN)
15153 fputs (" R4KEOP_CLEAN", stdout);
15154 break;
15155 case ODK_GP_GROUP:
15156 printf (" GP_GROUP %#06lx self-contained %#06lx",
15157 option->info & OGP_GROUP,
15158 (option->info & OGP_SELF) >> 16);
15159 break;
15160 case ODK_IDENT:
15161 printf (" IDENT %#06lx self-contained %#06lx",
15162 option->info & OGP_GROUP,
15163 (option->info & OGP_SELF) >> 16);
15164 break;
15165 default:
15166 /* This shouldn't happen. */
15167 printf (" %3d ??? %d %lx",
15168 option->kind, option->section, option->info);
15169 break;
252b5132 15170 }
a6e9f9df 15171
2cf0635d 15172 len = sizeof (* eopt);
a6e9f9df 15173 while (len < option->size)
82b1b41b 15174 {
7e27a9d5 15175 unsigned char datum = * ((unsigned char *) eopt + offset + len);
a6e9f9df 15176
82b1b41b
NC		 15177 if (ISPRINT (datum))
15178 printf ("%c", datum);
15179 else
15180 printf ("\\%03o", datum);
15181 len ++;
15182 }
a6e9f9df 15183 fputs ("\n", stdout);
82b1b41b
NC		 15184
15185 offset += option->size;
252b5132 15186 ++option;
252b5132
RH		 15187 }
15188
a6e9f9df 15189 free (eopt);
252b5132 15190 }
252b5132
RH		 15191 }
15192
15193 if (conflicts_offset != 0 && conflictsno != 0)
15194 {
2cf0635d 15195 Elf32_Conflict * iconf;
252b5132
RH		 15196 size_t cnt;
15197
15198 if (dynamic_symbols == NULL)
15199 {
591a748a 15200 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 15201 return 0;
15202 }
15203
3f5e193b 15204 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 15205 if (iconf == NULL)
15206 {
8b73c356 15207 error (_("Out of memory allocating space for dynamic conflicts\n"));
252b5132
RH		 15208 return 0;
15209 }
15210
9ea033b2 15211 if (is_32bit_elf)
252b5132 15212 {
2cf0635d 15213 Elf32_External_Conflict * econf32;
a6e9f9df 15214
3f5e193b
NC		 15215 econf32 = (Elf32_External_Conflict *)
15216 get_data (NULL, file, conflicts_offset, conflictsno,
15217 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 15218 if (!econf32)
15219 return 0;
252b5132
RH		 15220
15221 for (cnt = 0; cnt < conflictsno; ++cnt)
15222 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 15223
15224 free (econf32);
252b5132
RH		 15225 }
15226 else
15227 {
2cf0635d 15228 Elf64_External_Conflict * econf64;
a6e9f9df 15229
3f5e193b
NC		 15230 econf64 = (Elf64_External_Conflict *)
15231 get_data (NULL, file, conflicts_offset, conflictsno,
15232 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 15233 if (!econf64)
15234 return 0;
252b5132
RH		 15235
15236 for (cnt = 0; cnt < conflictsno; ++cnt)
15237 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 15238
15239 free (econf64);
252b5132
RH		 15240 }
15241
c7e7ca54
NC		 15242 printf (_("\nSection '.conflict' contains %lu entries:\n"),
15243 (unsigned long) conflictsno);
252b5132
RH		 15244 puts (_(" Num: Index Value Name"));
15245
15246 for (cnt = 0; cnt < conflictsno; ++cnt)
15247 {
b34976b6 15248 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
e0a31db1
NC		 15249
15250 if (iconf[cnt] >= num_dynamic_syms)
15251 printf (_("<corrupt symbol index>"));
d79b3d50 15252 else
e0a31db1
NC		 15253 {
15254 Elf_Internal_Sym * psym;
15255
15256 psym = & dynamic_symbols[iconf[cnt]];
15257 print_vma (psym->st_value, FULL_HEX);
15258 putchar (' ');
15259 if (VALID_DYNAMIC_NAME (psym->st_name))
15260 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
15261 else
15262 printf (_("<corrupt: %14ld>"), psym->st_name);
15263 }
31104126 15264 putchar ('\n');
252b5132
RH		 15265 }
15266
252b5132
RH		 15267 free (iconf);
15268 }
15269
ccb4c951
RS		 15270 if (pltgot != 0 && local_gotno != 0)
15271 {
91d6fa6a 15272 bfd_vma ent, local_end, global_end;
bbeee7ea 15273 size_t i, offset;
2cf0635d 15274 unsigned char * data;
82b1b41b 15275 unsigned char * data_end;
bbeee7ea 15276 int addr_size;
ccb4c951 15277
91d6fa6a 15278 ent = pltgot;
ccb4c951
RS		 15279 addr_size = (is_32bit_elf ? 4 : 8);
15280 local_end = pltgot + local_gotno * addr_size;
ccb4c951 15281
74e1a04b
NC		 15282 /* PR binutils/17533 file: 012-111227-0.004 */
15283 if (symtabno < gotsym)
15284 {
15285 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
82b1b41b 15286 (unsigned long) gotsym, (unsigned long) symtabno);
74e1a04b
NC		 15287 return 0;
15288 }
82b1b41b 15289
74e1a04b 15290 global_end = local_end + (symtabno - gotsym) * addr_size;
82b1b41b
NC		 15291 /* PR 17531: file: 54c91a34. */
15292 if (global_end < local_end)
15293 {
15294 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
15295 return 0;
15296 }
948f632f 15297
ccb4c951 15298 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 15299 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 15300 global_end - pltgot, 1,
15301 _("Global Offset Table data"));
59245841
NC		 15302 if (data == NULL)
15303 return 0;
82b1b41b 15304 data_end = data + (global_end - pltgot);
59245841 15305
ccb4c951
RS		 15306 printf (_("\nPrimary GOT:\n"));
15307 printf (_(" Canonical gp value: "));
15308 print_vma (pltgot + 0x7ff0, LONG_HEX);
15309 printf ("\n\n");
15310
15311 printf (_(" Reserved entries:\n"));
15312 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 15313 addr_size * 2, _("Address"), _("Access"),
15314 addr_size * 2, _("Initial"));
82b1b41b 15315 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 15316 printf (_(" Lazy resolver\n"));
82b1b41b
NC		 15317 if (ent == (bfd_vma) -1)
15318 goto got_print_fail;
ccb4c951 15319 if (data
91d6fa6a 15320 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 15321 >> (addr_size * 8 - 1)) != 0)
15322 {
82b1b41b 15323 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 15324 printf (_(" Module pointer (GNU extension)\n"));
82b1b41b
NC		 15325 if (ent == (bfd_vma) -1)
15326 goto got_print_fail;
ccb4c951
RS		 15327 }
15328 printf ("\n");
15329
91d6fa6a 15330 if (ent < local_end)
ccb4c951
RS		 15331 {
15332 printf (_(" Local entries:\n"));
cc5914eb 15333 printf (" %*s %10s %*s\n",
2b692964
NC		 15334 addr_size * 2, _("Address"), _("Access"),
15335 addr_size * 2, _("Initial"));
91d6fa6a 15336 while (ent < local_end)
ccb4c951 15337 {
82b1b41b 15338 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 15339 printf ("\n");
82b1b41b
NC		 15340 if (ent == (bfd_vma) -1)
15341 goto got_print_fail;
ccb4c951
RS		 15342 }
15343 printf ("\n");
15344 }
15345
15346 if (gotsym < symtabno)
15347 {
15348 int sym_width;
15349
15350 printf (_(" Global entries:\n"));
cc5914eb 15351 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 15352 addr_size * 2, _("Address"),
15353 _("Access"),
2b692964 15354 addr_size * 2, _("Initial"),
9cf03b7e
NC		 15355 addr_size * 2, _("Sym.Val."),
15356 _("Type"),
15357 /* Note for translators: "Ndx" = abbreviated form of "Index". */
15358 _("Ndx"), _("Name"));
0b4362b0 15359
ccb4c951 15360 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
e0a31db1 15361
ccb4c951
RS		 15362 for (i = gotsym; i < symtabno; i++)
15363 {
82b1b41b 15364 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 15365 printf (" ");
e0a31db1
NC		 15366
15367 if (dynamic_symbols == NULL)
15368 printf (_("<no dynamic symbols>"));
15369 else if (i < num_dynamic_syms)
15370 {
15371 Elf_Internal_Sym * psym = dynamic_symbols + i;
15372
15373 print_vma (psym->st_value, LONG_HEX);
15374 printf (" %-7s %3s ",
15375 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
15376 get_symbol_index_type (psym->st_shndx));
15377
15378 if (VALID_DYNAMIC_NAME (psym->st_name))
15379 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
15380 else
15381 printf (_("<corrupt: %14ld>"), psym->st_name);
15382 }
ccb4c951 15383 else
7fc5ac57
JBG		 15384 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15385 (unsigned long) i);
e0a31db1 15386
ccb4c951 15387 printf ("\n");
82b1b41b
NC		 15388 if (ent == (bfd_vma) -1)
15389 break;
ccb4c951
RS		 15390 }
15391 printf ("\n");
15392 }
15393
82b1b41b 15394 got_print_fail:
ccb4c951
RS		 15395 if (data)
15396 free (data);
15397 }
15398
861fb55a
DJ		 15399 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
15400 {
91d6fa6a 15401 bfd_vma ent, end;
861fb55a
DJ		 15402 size_t offset, rel_offset;
15403 unsigned long count, i;
2cf0635d 15404 unsigned char * data;
861fb55a 15405 int addr_size, sym_width;
2cf0635d 15406 Elf_Internal_Rela * rels;
861fb55a
DJ		 15407
15408 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
15409 if (pltrel == DT_RELA)
15410 {
15411 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
15412 return 0;
15413 }
15414 else
15415 {
15416 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
15417 return 0;
15418 }
15419
91d6fa6a 15420 ent = mips_pltgot;
861fb55a
DJ		 15421 addr_size = (is_32bit_elf ? 4 : 8);
15422 end = mips_pltgot + (2 + count) * addr_size;
15423
15424 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 15425 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 15426 1, _("Procedure Linkage Table data"));
59245841
NC		 15427 if (data == NULL)
15428 return 0;
15429
9cf03b7e 15430 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 15431 printf (_(" Reserved entries:\n"));
15432 printf (_(" %*s %*s Purpose\n"),
2b692964 15433 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 15434 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 15435 printf (_(" PLT lazy resolver\n"));
91d6fa6a 15436 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 15437 printf (_(" Module pointer\n"));
861fb55a
DJ		 15438 printf ("\n");
15439
15440 printf (_(" Entries:\n"));
cc5914eb 15441 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 15442 addr_size * 2, _("Address"),
15443 addr_size * 2, _("Initial"),
15444 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 15445 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
15446 for (i = 0; i < count; i++)
15447 {
df97ab2a 15448 unsigned long idx = get_reloc_symindex (rels[i].r_info);
861fb55a 15449
91d6fa6a 15450 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a 15451 printf (" ");
e0a31db1 15452
df97ab2a
MF		 15453 if (idx >= num_dynamic_syms)
15454 printf (_("<corrupt symbol index: %lu>"), idx);
861fb55a 15455 else
e0a31db1 15456 {
df97ab2a 15457 Elf_Internal_Sym * psym = dynamic_symbols + idx;
e0a31db1
NC		 15458
15459 print_vma (psym->st_value, LONG_HEX);
15460 printf (" %-7s %3s ",
15461 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
15462 get_symbol_index_type (psym->st_shndx));
15463 if (VALID_DYNAMIC_NAME (psym->st_name))
15464 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
15465 else
15466 printf (_("<corrupt: %14ld>"), psym->st_name);
15467 }
861fb55a
DJ		 15468 printf ("\n");
15469 }
15470 printf ("\n");
15471
15472 if (data)
15473 free (data);
15474 free (rels);
15475 }
15476
252b5132
RH		 15477 return 1;
15478}
15479
35c08157
KLC		 15480static int
15481process_nds32_specific (FILE * file)
15482{
15483 Elf_Internal_Shdr *sect = NULL;
15484
15485 sect = find_section (".nds32_e_flags");
15486 if (sect != NULL)
15487 {
15488 unsigned int *flag;
15489
15490 printf ("\nNDS32 elf flags section:\n");
15491 flag = get_data (NULL, file, sect->sh_offset, 1,
15492 sect->sh_size, _("NDS32 elf flags section"));
15493
15494 switch ((*flag) & 0x3)
15495 {
15496 case 0:
15497 printf ("(VEC_SIZE):\tNo entry.\n");
15498 break;
15499 case 1:
15500 printf ("(VEC_SIZE):\t4 bytes\n");
15501 break;
15502 case 2:
15503 printf ("(VEC_SIZE):\t16 bytes\n");
15504 break;
15505 case 3:
15506 printf ("(VEC_SIZE):\treserved\n");
15507 break;
15508 }
15509 }
15510
15511 return TRUE;
15512}
15513
047b2264 15514static int
2cf0635d 15515process_gnu_liblist (FILE * file)
047b2264 15516{
2cf0635d
NC		 15517 Elf_Internal_Shdr * section;
15518 Elf_Internal_Shdr * string_sec;
15519 Elf32_External_Lib * elib;
15520 char * strtab;
c256ffe7 15521 size_t strtab_size;
047b2264
JJ		 15522 size_t cnt;
15523 unsigned i;
15524
15525 if (! do_arch)
15526 return 0;
15527
15528 for (i = 0, section = section_headers;
15529 i < elf_header.e_shnum;
b34976b6 15530 i++, section++)
047b2264
JJ		 15531 {
15532 switch (section->sh_type)
15533 {
15534 case SHT_GNU_LIBLIST:
4fbb74a6 15535 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 15536 break;
15537
3f5e193b
NC		 15538 elib = (Elf32_External_Lib *)
15539 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 15540 _("liblist section data"));
047b2264
JJ		 15541
15542 if (elib == NULL)
15543 break;
4fbb74a6 15544 string_sec = section_headers + section->sh_link;
047b2264 15545
3f5e193b
NC		 15546 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
15547 string_sec->sh_size,
15548 _("liblist string table"));
047b2264
JJ		 15549 if (strtab == NULL
15550 || section->sh_entsize != sizeof (Elf32_External_Lib))
15551 {
15552 free (elib);
2842702f 15553 free (strtab);
047b2264
JJ		 15554 break;
15555 }
59245841 15556 strtab_size = string_sec->sh_size;
047b2264
JJ		 15557
15558 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
74e1a04b 15559 printable_section_name (section),
0af1713e 15560 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 15561
2b692964 15562 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 15563
15564 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
15565 ++cnt)
15566 {
15567 Elf32_Lib liblist;
91d6fa6a 15568 time_t atime;
d5b07ef4 15569 char timebuf[128];
2cf0635d 15570 struct tm * tmp;
047b2264
JJ		 15571
15572 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 15573 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 15574 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15575 liblist.l_version = BYTE_GET (elib[cnt].l_version);
15576 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15577
91d6fa6a 15578 tmp = gmtime (&atime);
e9e44622
JJ		 15579 snprintf (timebuf, sizeof (timebuf),
15580 "%04u-%02u-%02uT%02u:%02u:%02u",
15581 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15582 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 15583
15584 printf ("%3lu: ", (unsigned long) cnt);
15585 if (do_wide)
c256ffe7 15586 printf ("%-20s", liblist.l_name < strtab_size
2b692964 15587 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 15588 else
c256ffe7 15589 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 15590 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 15591 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
15592 liblist.l_version, liblist.l_flags);
15593 }
15594
15595 free (elib);
2842702f 15596 free (strtab);
047b2264
JJ		 15597 }
15598 }
15599
15600 return 1;
15601}
15602
9437c45b 15603static const char *
d3ba0551 15604get_note_type (unsigned e_type)
779fe533
NC		 15605{
15606 static char buff[64];
103f02d3 15607
1ec5cd37
NC		 15608 if (elf_header.e_type == ET_CORE)
15609 switch (e_type)
15610 {
57346661 15611 case NT_AUXV:
1ec5cd37 15612 return _("NT_AUXV (auxiliary vector)");
57346661 15613 case NT_PRSTATUS:
1ec5cd37 15614 return _("NT_PRSTATUS (prstatus structure)");
57346661 15615 case NT_FPREGSET:
1ec5cd37 15616 return _("NT_FPREGSET (floating point registers)");
57346661 15617 case NT_PRPSINFO:
1ec5cd37 15618 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 15619 case NT_TASKSTRUCT:
1ec5cd37 15620 return _("NT_TASKSTRUCT (task structure)");
57346661 15621 case NT_PRXFPREG:
1ec5cd37 15622 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 15623 case NT_PPC_VMX:
15624 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 15625 case NT_PPC_VSX:
15626 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 15627 case NT_386_TLS:
15628 return _("NT_386_TLS (x86 TLS information)");
15629 case NT_386_IOPERM:
15630 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 15631 case NT_X86_XSTATE:
15632 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 15633 case NT_S390_HIGH_GPRS:
15634 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 15635 case NT_S390_TIMER:
15636 return _("NT_S390_TIMER (s390 timer register)");
15637 case NT_S390_TODCMP:
15638 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15639 case NT_S390_TODPREG:
15640 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15641 case NT_S390_CTRS:
15642 return _("NT_S390_CTRS (s390 control registers)");
15643 case NT_S390_PREFIX:
15644 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 15645 case NT_S390_LAST_BREAK:
15646 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15647 case NT_S390_SYSTEM_CALL:
15648 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC		 15649 case NT_S390_TDB:
15650 return _("NT_S390_TDB (s390 transaction diagnostic block)");
4ef9f41a
AA		 15651 case NT_S390_VXRS_LOW:
15652 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15653 case NT_S390_VXRS_HIGH:
15654 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
faa9a424
UW		 15655 case NT_ARM_VFP:
15656 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 15657 case NT_ARM_TLS:
15658 return _("NT_ARM_TLS (AArch TLS registers)");
15659 case NT_ARM_HW_BREAK:
15660 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15661 case NT_ARM_HW_WATCH:
15662 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 15663 case NT_PSTATUS:
1ec5cd37 15664 return _("NT_PSTATUS (pstatus structure)");
57346661 15665 case NT_FPREGS:
1ec5cd37 15666 return _("NT_FPREGS (floating point registers)");
57346661 15667 case NT_PSINFO:
1ec5cd37 15668 return _("NT_PSINFO (psinfo structure)");
57346661 15669 case NT_LWPSTATUS:
1ec5cd37 15670 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 15671 case NT_LWPSINFO:
1ec5cd37 15672 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 15673 case NT_WIN32PSTATUS:
1ec5cd37 15674 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 15675 case NT_SIGINFO:
15676 return _("NT_SIGINFO (siginfo_t data)");
15677 case NT_FILE:
15678 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 15679 default:
15680 break;
15681 }
15682 else
15683 switch (e_type)
15684 {
15685 case NT_VERSION:
15686 return _("NT_VERSION (version)");
15687 case NT_ARCH:
15688 return _("NT_ARCH (architecture)");
15689 default:
15690 break;
15691 }
15692
e9e44622 15693 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 15694 return buff;
779fe533
NC		 15695}
15696
9ece1fa9
TT		 15697static int
15698print_core_note (Elf_Internal_Note *pnote)
15699{
15700 unsigned int addr_size = is_32bit_elf ? 4 : 8;
15701 bfd_vma count, page_size;
15702 unsigned char *descdata, *filenames, *descend;
15703
15704 if (pnote->type != NT_FILE)
15705 return 1;
15706
15707#ifndef BFD64
15708 if (!is_32bit_elf)
15709 {
15710 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15711 /* Still "successful". */
15712 return 1;
15713 }
15714#endif
15715
15716 if (pnote->descsz < 2 * addr_size)
15717 {
15718 printf (_(" Malformed note - too short for header\n"));
15719 return 0;
15720 }
15721
15722 descdata = (unsigned char *) pnote->descdata;
15723 descend = descdata + pnote->descsz;
15724
15725 if (descdata[pnote->descsz - 1] != '\0')
15726 {
15727 printf (_(" Malformed note - does not end with \\0\n"));
15728 return 0;
15729 }
15730
15731 count = byte_get (descdata, addr_size);
15732 descdata += addr_size;
15733
15734 page_size = byte_get (descdata, addr_size);
15735 descdata += addr_size;
15736
15737 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
15738 {
15739 printf (_(" Malformed note - too short for supplied file count\n"));
15740 return 0;
15741 }
15742
15743 printf (_(" Page size: "));
15744 print_vma (page_size, DEC);
15745 printf ("\n");
15746
15747 printf (_(" %*s%*s%*s\n"),
15748 (int) (2 + 2 * addr_size), _("Start"),
15749 (int) (4 + 2 * addr_size), _("End"),
15750 (int) (4 + 2 * addr_size), _("Page Offset"));
15751 filenames = descdata + count * 3 * addr_size;
595712bb 15752 while (count-- > 0)
9ece1fa9
TT		 15753 {
15754 bfd_vma start, end, file_ofs;
15755
15756 if (filenames == descend)
15757 {
15758 printf (_(" Malformed note - filenames end too early\n"));
15759 return 0;
15760 }
15761
15762 start = byte_get (descdata, addr_size);
15763 descdata += addr_size;
15764 end = byte_get (descdata, addr_size);
15765 descdata += addr_size;
15766 file_ofs = byte_get (descdata, addr_size);
15767 descdata += addr_size;
15768
15769 printf (" ");
15770 print_vma (start, FULL_HEX);
15771 printf (" ");
15772 print_vma (end, FULL_HEX);
15773 printf (" ");
15774 print_vma (file_ofs, FULL_HEX);
15775 printf ("\n %s\n", filenames);
15776
15777 filenames += 1 + strlen ((char *) filenames);
15778 }
15779
15780 return 1;
15781}
15782
1118d252
RM		 15783static const char *
15784get_gnu_elf_note_type (unsigned e_type)
15785{
1449284b 15786 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
1118d252
RM		 15787 switch (e_type)
15788 {
15789 case NT_GNU_ABI_TAG:
15790 return _("NT_GNU_ABI_TAG (ABI version tag)");
15791 case NT_GNU_HWCAP:
15792 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15793 case NT_GNU_BUILD_ID:
15794 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 15795 case NT_GNU_GOLD_VERSION:
15796 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252 15797 default:
1449284b
NC		 15798 {
15799 static char buff[64];
1118d252 15800
1449284b
NC		 15801 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15802 return buff;
15803 }
15804 }
1118d252
RM		 15805}
15806
664f90a3
TT		 15807static int
15808print_gnu_note (Elf_Internal_Note *pnote)
15809{
1449284b 15810 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
664f90a3
TT		 15811 switch (pnote->type)
15812 {
15813 case NT_GNU_BUILD_ID:
15814 {
15815 unsigned long i;
15816
15817 printf (_(" Build ID: "));
15818 for (i = 0; i < pnote->descsz; ++i)
15819 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 15820 printf ("\n");
664f90a3
TT		 15821 }
15822 break;
15823
15824 case NT_GNU_ABI_TAG:
15825 {
15826 unsigned long os, major, minor, subminor;
15827 const char *osname;
15828
3102e897
NC		 15829 /* PR 17531: file: 030-599401-0.004. */
15830 if (pnote->descsz < 16)
15831 {
15832 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15833 break;
15834 }
15835
664f90a3
TT		 15836 os = byte_get ((unsigned char *) pnote->descdata, 4);
15837 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
15838 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
15839 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
15840
15841 switch (os)
15842 {
15843 case GNU_ABI_TAG_LINUX:
15844 osname = "Linux";
15845 break;
15846 case GNU_ABI_TAG_HURD:
15847 osname = "Hurd";
15848 break;
15849 case GNU_ABI_TAG_SOLARIS:
15850 osname = "Solaris";
15851 break;
15852 case GNU_ABI_TAG_FREEBSD:
15853 osname = "FreeBSD";
15854 break;
15855 case GNU_ABI_TAG_NETBSD:
15856 osname = "NetBSD";
15857 break;
14ae95f2
RM		 15858 case GNU_ABI_TAG_SYLLABLE:
15859 osname = "Syllable";
15860 break;
15861 case GNU_ABI_TAG_NACL:
15862 osname = "NaCl";
15863 break;
664f90a3
TT		 15864 default:
15865 osname = "Unknown";
15866 break;
15867 }
15868
15869 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
15870 major, minor, subminor);
15871 }
15872 break;
926c5385
CC		 15873
15874 case NT_GNU_GOLD_VERSION:
15875 {
15876 unsigned long i;
15877
15878 printf (_(" Version: "));
15879 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
15880 printf ("%c", pnote->descdata[i]);
15881 printf ("\n");
15882 }
15883 break;
1449284b
NC		 15884
15885 case NT_GNU_HWCAP:
15886 {
15887 unsigned long num_entries, mask;
15888
15889 /* Hardware capabilities information. Word 0 is the number of entries.
15890 Word 1 is a bitmask of enabled entries. The rest of the descriptor
15891 is a series of entries, where each entry is a single byte followed
15892 by a nul terminated string. The byte gives the bit number to test
15893 if enabled in the bitmask. */
15894 printf (_(" Hardware Capabilities: "));
15895 if (pnote->descsz < 8)
15896 {
15897 printf (_("<corrupt GNU_HWCAP>\n"));
15898 break;
15899 }
15900 num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
15901 mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
15902 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
15903 /* FIXME: Add code to display the entries... */
15904 }
15905 break;
15906
15907 default:
15908 /* Handle unrecognised types. An error message should have already been
15909 created by get_gnu_elf_note_type(), so all that we need to do is to
15910 display the data. */
15911 {
15912 unsigned long i;
15913
15914 printf (_(" Description data: "));
15915 for (i = 0; i < pnote->descsz; ++i)
15916 printf ("%02x ", pnote->descdata[i] & 0xff);
15917 printf ("\n");
15918 }
15919 break;
664f90a3
TT		 15920 }
15921
15922 return 1;
15923}
15924
685080f2
NC		 15925static const char *
15926get_v850_elf_note_type (enum v850_notes n_type)
15927{
15928 static char buff[64];
15929
15930 switch (n_type)
15931 {
15932 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
15933 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
15934 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
15935 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
15936 case V850_NOTE_CACHE_INFO: return _("Use of cache");
15937 case V850_NOTE_MMU_INFO: return _("Use of MMU");
15938 default:
15939 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
15940 return buff;
15941 }
15942}
15943
15944static int
15945print_v850_note (Elf_Internal_Note * pnote)
15946{
15947 unsigned int val;
15948
15949 if (pnote->descsz != 4)
15950 return 0;
15951 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
15952
15953 if (val == 0)
15954 {
15955 printf (_("not set\n"));
15956 return 1;
15957 }
15958
15959 switch (pnote->type)
15960 {
15961 case V850_NOTE_ALIGNMENT:
15962 switch (val)
15963 {
15964 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
15965 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
15966 }
15967 break;
14ae95f2 15968
685080f2
NC		 15969 case V850_NOTE_DATA_SIZE:
15970 switch (val)
15971 {
15972 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
15973 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
15974 }
15975 break;
14ae95f2 15976
685080f2
NC		 15977 case V850_NOTE_FPU_INFO:
15978 switch (val)
15979 {
15980 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
15981 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
15982 }
15983 break;
14ae95f2 15984
685080f2
NC		 15985 case V850_NOTE_MMU_INFO:
15986 case V850_NOTE_CACHE_INFO:
15987 case V850_NOTE_SIMD_INFO:
15988 if (val == EF_RH850_SIMD)
15989 {
15990 printf (_("yes\n"));
15991 return 1;
15992 }
15993 break;
15994
15995 default:
15996 /* An 'unknown note type' message will already have been displayed. */
15997 break;
15998 }
15999
16000 printf (_("unknown value: %x\n"), val);
16001 return 0;
16002}
16003
15f205b1 16004static int
c6056a74
SF		 16005process_netbsd_elf_note (Elf_Internal_Note * pnote)
16006{
16007 unsigned int version;
16008
16009 switch (pnote->type)
16010 {
16011 case NT_NETBSD_IDENT:
16012 version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
16013 if ((version / 10000) % 100)
16014 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
16015 version, version / 100000000, (version / 1000000) % 100,
16016 (version / 10000) % 100 > 26 ? "Z" : "",
15f205b1 16017 'A' + (version / 10000) % 26);
c6056a74
SF		 16018 else
16019 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
16020 version, version / 100000000, (version / 1000000) % 100,
15f205b1 16021 (version / 100) % 100);
c6056a74
SF		 16022 return 1;
16023
16024 case NT_NETBSD_MARCH:
16025 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
16026 pnote->descdata);
16027 return 1;
16028
16029 default:
16030 break;
16031 }
16032
16033 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
16034 pnote->type);
16035 return 1;
16036}
16037
f4ddf30f
JB		 16038static const char *
16039get_freebsd_elfcore_note_type (unsigned e_type)
16040{
f4ddf30f
JB		 16041 switch (e_type)
16042 {
16043 case NT_FREEBSD_THRMISC:
16044 return _("NT_THRMISC (thrmisc structure)");
16045 case NT_FREEBSD_PROCSTAT_PROC:
16046 return _("NT_PROCSTAT_PROC (proc data)");
16047 case NT_FREEBSD_PROCSTAT_FILES:
16048 return _("NT_PROCSTAT_FILES (files data)");
16049 case NT_FREEBSD_PROCSTAT_VMMAP:
16050 return _("NT_PROCSTAT_VMMAP (vmmap data)");
16051 case NT_FREEBSD_PROCSTAT_GROUPS:
16052 return _("NT_PROCSTAT_GROUPS (groups data)");
16053 case NT_FREEBSD_PROCSTAT_UMASK:
16054 return _("NT_PROCSTAT_UMASK (umask data)");
16055 case NT_FREEBSD_PROCSTAT_RLIMIT:
16056 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
16057 case NT_FREEBSD_PROCSTAT_OSREL:
16058 return _("NT_PROCSTAT_OSREL (osreldate data)");
16059 case NT_FREEBSD_PROCSTAT_PSSTRINGS:
16060 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
16061 case NT_FREEBSD_PROCSTAT_AUXV:
16062 return _("NT_PROCSTAT_AUXV (auxv data)");
16063 }
16064 return get_note_type (e_type);
16065}
16066
9437c45b 16067static const char *
d3ba0551 16068get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 16069{
16070 static char buff[64];
16071
b4db1224 16072 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 16073 {
16074 /* NetBSD core "procinfo" structure. */
16075 return _("NetBSD procinfo structure");
16076 }
16077
16078 /* As of Jan 2002 there are no other machine-independent notes
16079 defined for NetBSD core files. If the note type is less
16080 than the start of the machine-dependent note types, we don't
16081 understand it. */
16082
b4db1224 16083 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 16084 {
e9e44622 16085 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 16086 return buff;
16087 }
16088
16089 switch (elf_header.e_machine)
16090 {
16091 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
16092 and PT_GETFPREGS == mach+2. */
16093
16094 case EM_OLD_ALPHA:
16095 case EM_ALPHA:
16096 case EM_SPARC:
16097 case EM_SPARC32PLUS:
16098 case EM_SPARCV9:
16099 switch (e_type)
16100 {
2b692964 16101 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 16102 return _("PT_GETREGS (reg structure)");
2b692964 16103 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 16104 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 16105 default:
16106 break;
16107 }
16108 break;
16109
16110 /* On all other arch's, PT_GETREGS == mach+1 and
16111 PT_GETFPREGS == mach+3. */
16112 default:
16113 switch (e_type)
16114 {
2b692964 16115 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 16116 return _("PT_GETREGS (reg structure)");
2b692964 16117 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 16118 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 16119 default:
16120 break;
16121 }
16122 }
16123
9cf03b7e 16124 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 16125 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 16126 return buff;
16127}
16128
70616151
TT		 16129static const char *
16130get_stapsdt_note_type (unsigned e_type)
16131{
16132 static char buff[64];
16133
16134 switch (e_type)
16135 {
16136 case NT_STAPSDT:
16137 return _("NT_STAPSDT (SystemTap probe descriptors)");
16138
16139 default:
16140 break;
16141 }
16142
16143 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16144 return buff;
16145}
16146
c6a9fc58
TT		 16147static int
16148print_stapsdt_note (Elf_Internal_Note *pnote)
16149{
16150 int addr_size = is_32bit_elf ? 4 : 8;
16151 char *data = pnote->descdata;
16152 char *data_end = pnote->descdata + pnote->descsz;
16153 bfd_vma pc, base_addr, semaphore;
16154 char *provider, *probe, *arg_fmt;
16155
16156 pc = byte_get ((unsigned char *) data, addr_size);
16157 data += addr_size;
16158 base_addr = byte_get ((unsigned char *) data, addr_size);
16159 data += addr_size;
16160 semaphore = byte_get ((unsigned char *) data, addr_size);
16161 data += addr_size;
16162
16163 provider = data;
16164 data += strlen (data) + 1;
16165 probe = data;
16166 data += strlen (data) + 1;
16167 arg_fmt = data;
16168 data += strlen (data) + 1;
16169
16170 printf (_(" Provider: %s\n"), provider);
16171 printf (_(" Name: %s\n"), probe);
16172 printf (_(" Location: "));
16173 print_vma (pc, FULL_HEX);
16174 printf (_(", Base: "));
16175 print_vma (base_addr, FULL_HEX);
16176 printf (_(", Semaphore: "));
16177 print_vma (semaphore, FULL_HEX);
9cf03b7e 16178 printf ("\n");
c6a9fc58
TT		 16179 printf (_(" Arguments: %s\n"), arg_fmt);
16180
16181 return data == data_end;
16182}
16183
00e98fc7
TG		 16184static const char *
16185get_ia64_vms_note_type (unsigned e_type)
16186{
16187 static char buff[64];
16188
16189 switch (e_type)
16190 {
16191 case NT_VMS_MHD:
16192 return _("NT_VMS_MHD (module header)");
16193 case NT_VMS_LNM:
16194 return _("NT_VMS_LNM (language name)");
16195 case NT_VMS_SRC:
16196 return _("NT_VMS_SRC (source files)");
16197 case NT_VMS_TITLE:
9cf03b7e 16198 return "NT_VMS_TITLE";
00e98fc7
TG		 16199 case NT_VMS_EIDC:
16200 return _("NT_VMS_EIDC (consistency check)");
16201 case NT_VMS_FPMODE:
16202 return _("NT_VMS_FPMODE (FP mode)");
16203 case NT_VMS_LINKTIME:
9cf03b7e 16204 return "NT_VMS_LINKTIME";
00e98fc7
TG		 16205 case NT_VMS_IMGNAM:
16206 return _("NT_VMS_IMGNAM (image name)");
16207 case NT_VMS_IMGID:
16208 return _("NT_VMS_IMGID (image id)");
16209 case NT_VMS_LINKID:
16210 return _("NT_VMS_LINKID (link id)");
16211 case NT_VMS_IMGBID:
16212 return _("NT_VMS_IMGBID (build id)");
16213 case NT_VMS_GSTNAM:
16214 return _("NT_VMS_GSTNAM (sym table name)");
16215 case NT_VMS_ORIG_DYN:
9cf03b7e 16216 return "NT_VMS_ORIG_DYN";
00e98fc7 16217 case NT_VMS_PATCHTIME:
9cf03b7e 16218 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 16219 default:
16220 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16221 return buff;
16222 }
16223}
16224
16225static int
16226print_ia64_vms_note (Elf_Internal_Note * pnote)
16227{
16228 switch (pnote->type)
16229 {
16230 case NT_VMS_MHD:
16231 if (pnote->descsz > 36)
16232 {
16233 size_t l = strlen (pnote->descdata + 34);
16234 printf (_(" Creation date : %.17s\n"), pnote->descdata);
16235 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
16236 printf (_(" Module name : %s\n"), pnote->descdata + 34);
16237 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
16238 }
16239 else
16240 printf (_(" Invalid size\n"));
16241 break;
16242 case NT_VMS_LNM:
16243 printf (_(" Language: %s\n"), pnote->descdata);
16244 break;
16245#ifdef BFD64
16246 case NT_VMS_FPMODE:
9cf03b7e 16247 printf (_(" Floating Point mode: "));
4a5cb34f 16248 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 16249 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
00e98fc7
TG		 16250 break;
16251 case NT_VMS_LINKTIME:
16252 printf (_(" Link time: "));
16253 print_vms_time
16254 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
16255 printf ("\n");
16256 break;
16257 case NT_VMS_PATCHTIME:
16258 printf (_(" Patch time: "));
16259 print_vms_time
16260 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
16261 printf ("\n");
16262 break;
16263 case NT_VMS_ORIG_DYN:
16264 printf (_(" Major id: %u, minor id: %u\n"),
16265 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
16266 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 16267 printf (_(" Last modified : "));
00e98fc7
TG		 16268 print_vms_time
16269 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 16270 printf (_("\n Link flags : "));
4a5cb34f 16271 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 16272 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
00e98fc7 16273 printf (_(" Header flags: 0x%08x\n"),
948f632f 16274 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
00e98fc7
TG		 16275 printf (_(" Image id : %s\n"), pnote->descdata + 32);
16276 break;
16277#endif
16278 case NT_VMS_IMGNAM:
16279 printf (_(" Image name: %s\n"), pnote->descdata);
16280 break;
16281 case NT_VMS_GSTNAM:
16282 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
16283 break;
16284 case NT_VMS_IMGID:
16285 printf (_(" Image id: %s\n"), pnote->descdata);
16286 break;
16287 case NT_VMS_LINKID:
16288 printf (_(" Linker id: %s\n"), pnote->descdata);
16289 break;
16290 default:
16291 break;
16292 }
16293 return 1;
16294}
16295
6d118b09
NC		 16296/* Note that by the ELF standard, the name field is already null byte
16297 terminated, and namesz includes the terminating null byte.
16298 I.E. the value of namesz for the name "FSF" is 4.
16299
e3c8793a 16300 If the value of namesz is zero, there is no name present. */
779fe533 16301static int
1449284b
NC		 16302process_note (Elf_Internal_Note * pnote,
16303 FILE * file ATTRIBUTE_UNUSED,
16304 Elf_Internal_Shdr * section ATTRIBUTE_UNUSED)
779fe533 16305{
2cf0635d
NC		 16306 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
16307 const char * nt;
9437c45b
JT		 16308
16309 if (pnote->namesz == 0)
1ec5cd37
NC		 16310 /* If there is no note name, then use the default set of
16311 note type strings. */
16312 nt = get_note_type (pnote->type);
16313
1118d252
RM		 16314 else if (const_strneq (pnote->namedata, "GNU"))
16315 /* GNU-specific object file notes. */
16316 nt = get_gnu_elf_note_type (pnote->type);
f4ddf30f
JB		 16317
16318 else if (const_strneq (pnote->namedata, "FreeBSD"))
16319 /* FreeBSD-specific core file notes. */
16320 nt = get_freebsd_elfcore_note_type (pnote->type);
1118d252 16321
0112cd26 16322 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 16323 /* NetBSD-specific core file notes. */
16324 nt = get_netbsd_elfcore_note_type (pnote->type);
16325
c6056a74
SF		 16326 else if (const_strneq (pnote->namedata, "NetBSD"))
16327 /* NetBSD-specific core file notes. */
16328 return process_netbsd_elf_note (pnote);
16329
b15fa79e
AM		 16330 else if (strneq (pnote->namedata, "SPU/", 4))
16331 {
16332 /* SPU-specific core file notes. */
16333 nt = pnote->namedata + 4;
16334 name = "SPU";
16335 }
16336
00e98fc7
TG		 16337 else if (const_strneq (pnote->namedata, "IPF/VMS"))
16338 /* VMS/ia64-specific file notes. */
16339 nt = get_ia64_vms_note_type (pnote->type);
16340
70616151
TT		 16341 else if (const_strneq (pnote->namedata, "stapsdt"))
16342 nt = get_stapsdt_note_type (pnote->type);
16343
9437c45b 16344 else
1ec5cd37
NC		 16345 /* Don't recognize this note name; just use the default set of
16346 note type strings. */
00e98fc7 16347 nt = get_note_type (pnote->type);
9437c45b 16348
1449284b
NC		 16349 printf (" ");
16350 print_symbol (-20, name);
16351 printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
00e98fc7
TG		 16352
16353 if (const_strneq (pnote->namedata, "IPF/VMS"))
16354 return print_ia64_vms_note (pnote);
664f90a3
TT		 16355 else if (const_strneq (pnote->namedata, "GNU"))
16356 return print_gnu_note (pnote);
c6a9fc58
TT		 16357 else if (const_strneq (pnote->namedata, "stapsdt"))
16358 return print_stapsdt_note (pnote);
9ece1fa9
TT		 16359 else if (const_strneq (pnote->namedata, "CORE"))
16360 return print_core_note (pnote);
779fe533 16361
1449284b
NC		 16362 else if (pnote->descsz)
16363 {
16364 unsigned long i;
16365
16366 printf (_(" description data: "));
16367 for (i = 0; i < pnote->descsz; i++)
16368 printf ("%02x ", pnote->descdata[i]);
16369 printf ("\n");
16370 }
16371
16372 return 1;
16373}
6d118b09 16374
779fe533 16375static int
1449284b
NC		 16376process_notes_at (FILE * file,
16377 Elf_Internal_Shdr * section,
16378 bfd_vma offset,
16379 bfd_vma length)
779fe533 16380{
2cf0635d
NC		 16381 Elf_External_Note * pnotes;
16382 Elf_External_Note * external;
c8071705 16383 char * end;
b34976b6 16384 int res = 1;
103f02d3 16385
779fe533
NC		 16386 if (length <= 0)
16387 return 0;
103f02d3 16388
1449284b
NC		 16389 if (section)
16390 {
16391 pnotes = (Elf_External_Note *) get_section_contents (section, file);
16392 if (pnotes)
16393 apply_relocations (file, section, (unsigned char *) pnotes, length, NULL, NULL);
16394 }
16395 else
16396 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
16397 _("notes"));
dd24e3da 16398 if (pnotes == NULL)
a6e9f9df 16399 return 0;
779fe533 16400
103f02d3 16401 external = pnotes;
103f02d3 16402
1449284b
NC		 16403 if (section)
16404 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section));
16405 else
16406 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
16407 (unsigned long) offset, (unsigned long) length);
16408
2aee03ae 16409 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 16410
c8071705
NC		 16411 end = (char *) pnotes + length;
16412 while ((char *) external < end)
779fe533 16413 {
b34976b6 16414 Elf_Internal_Note inote;
15b42fb0
AM		 16415 size_t min_notesz;
16416 char *next;
2cf0635d 16417 char * temp = NULL;
c8071705 16418 size_t data_remaining = end - (char *) external;
6d118b09 16419
00e98fc7 16420 if (!is_ia64_vms ())
15b42fb0 16421 {
9dd3a467
NC		 16422 /* PR binutils/15191
16423 Make sure that there is enough data to read. */
15b42fb0
AM		 16424 min_notesz = offsetof (Elf_External_Note, name);
16425 if (data_remaining < min_notesz)
9dd3a467
NC		 16426 {
16427 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
16428 (int) data_remaining);
16429 break;
16430 }
15b42fb0
AM		 16431 inote.type = BYTE_GET (external->type);
16432 inote.namesz = BYTE_GET (external->namesz);
16433 inote.namedata = external->name;
16434 inote.descsz = BYTE_GET (external->descsz);
16435 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
834f871c 16436 /* PR 17531: file: 3443835e. */
c8071705 16437 if (inote.descdata < (char *) pnotes || inote.descdata > end)
834f871c
NC		 16438 {
16439 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
16440 inote.descdata = inote.namedata;
16441 inote.namesz = 0;
16442 }
14ae95f2 16443
15b42fb0
AM		 16444 inote.descpos = offset + (inote.descdata - (char *) pnotes);
16445 next = inote.descdata + align_power (inote.descsz, 2);
16446 }
00e98fc7 16447 else
15b42fb0
AM		 16448 {
16449 Elf64_External_VMS_Note *vms_external;
00e98fc7 16450
9dd3a467
NC		 16451 /* PR binutils/15191
16452 Make sure that there is enough data to read. */
15b42fb0
AM		 16453 min_notesz = offsetof (Elf64_External_VMS_Note, name);
16454 if (data_remaining < min_notesz)
9dd3a467
NC		 16455 {
16456 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
16457 (int) data_remaining);
16458 break;
16459 }
3e55a963 16460
15b42fb0
AM		 16461 vms_external = (Elf64_External_VMS_Note *) external;
16462 inote.type = BYTE_GET (vms_external->type);
16463 inote.namesz = BYTE_GET (vms_external->namesz);
16464 inote.namedata = vms_external->name;
16465 inote.descsz = BYTE_GET (vms_external->descsz);
16466 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
16467 inote.descpos = offset + (inote.descdata - (char *) pnotes);
16468 next = inote.descdata + align_power (inote.descsz, 3);
16469 }
16470
16471 if (inote.descdata < (char *) external + min_notesz
16472 || next < (char *) external + min_notesz
5d921cbd
NC		 16473 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
16474 || inote.namedata + inote.namesz < inote.namedata
16475 || inote.descdata + inote.descsz < inote.descdata
15b42fb0 16476 || data_remaining < (size_t)(next - (char *) external))
3e55a963 16477 {
15b42fb0 16478 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 16479 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 16480 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC		 16481 inote.type, inote.namesz, inote.descsz);
16482 break;
16483 }
16484
15b42fb0 16485 external = (Elf_External_Note *) next;
dd24e3da 16486
6d118b09
NC		 16487 /* Verify that name is null terminated. It appears that at least
16488 one version of Linux (RedHat 6.0) generates corefiles that don't
16489 comply with the ELF spec by failing to include the null byte in
16490 namesz. */
8b971f9f 16491 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 16492 {
3f5e193b 16493 temp = (char *) malloc (inote.namesz + 1);
6d118b09
NC		 16494 if (temp == NULL)
16495 {
8b73c356 16496 error (_("Out of memory allocating space for inote name\n"));
6d118b09
NC		 16497 res = 0;
16498 break;
16499 }
76da6bbe 16500
6d118b09
NC		 16501 strncpy (temp, inote.namedata, inote.namesz);
16502 temp[inote.namesz] = 0;
76da6bbe 16503
6d118b09
NC		 16504 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
16505 inote.namedata = temp;
16506 }
16507
1449284b 16508 res &= process_note (& inote, file, section);
103f02d3 16509
6d118b09
NC		 16510 if (temp != NULL)
16511 {
16512 free (temp);
16513 temp = NULL;
16514 }
779fe533
NC		 16515 }
16516
16517 free (pnotes);
103f02d3 16518
779fe533
NC		 16519 return res;
16520}
16521
16522static int
2cf0635d 16523process_corefile_note_segments (FILE * file)
779fe533 16524{
2cf0635d 16525 Elf_Internal_Phdr * segment;
b34976b6
AM		 16526 unsigned int i;
16527 int res = 1;
103f02d3 16528
d93f0186 16529 if (! get_program_headers (file))
779fe533 16530 return 0;
103f02d3 16531
779fe533
NC		 16532 for (i = 0, segment = program_headers;
16533 i < elf_header.e_phnum;
b34976b6 16534 i++, segment++)
779fe533
NC		 16535 {
16536 if (segment->p_type == PT_NOTE)
1449284b
NC		 16537 res &= process_notes_at (file, NULL,
16538 (bfd_vma) segment->p_offset,
16539 (bfd_vma) segment->p_filesz);
779fe533 16540 }
103f02d3 16541
779fe533
NC		 16542 return res;
16543}
16544
685080f2
NC		 16545static int
16546process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
16547{
16548 Elf_External_Note * pnotes;
16549 Elf_External_Note * external;
c8071705 16550 char * end;
685080f2
NC		 16551 int res = 1;
16552
16553 if (length <= 0)
16554 return 0;
16555
16556 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
16557 _("v850 notes"));
16558 if (pnotes == NULL)
16559 return 0;
16560
16561 external = pnotes;
c8071705 16562 end = (char*) pnotes + length;
685080f2
NC		 16563
16564 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
16565 (unsigned long) offset, (unsigned long) length);
16566
c8071705 16567 while ((char *) external + sizeof (Elf_External_Note) < end)
685080f2
NC		 16568 {
16569 Elf_External_Note * next;
16570 Elf_Internal_Note inote;
16571
16572 inote.type = BYTE_GET (external->type);
16573 inote.namesz = BYTE_GET (external->namesz);
16574 inote.namedata = external->name;
16575 inote.descsz = BYTE_GET (external->descsz);
16576 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
16577 inote.descpos = offset + (inote.descdata - (char *) pnotes);
16578
c8071705
NC		 16579 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
16580 {
16581 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
16582 inote.descdata = inote.namedata;
16583 inote.namesz = 0;
16584 }
16585
685080f2
NC		 16586 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
16587
c8071705 16588 if ( ((char *) next > end)
685080f2
NC		 16589 || ((char *) next < (char *) pnotes))
16590 {
16591 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
16592 (unsigned long) ((char *) external - (char *) pnotes));
16593 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16594 inote.type, inote.namesz, inote.descsz);
16595 break;
16596 }
16597
16598 external = next;
16599
16600 /* Prevent out-of-bounds indexing. */
c8071705 16601 if ( inote.namedata + inote.namesz > end
685080f2
NC		 16602 || inote.namedata + inote.namesz < inote.namedata)
16603 {
16604 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
16605 (unsigned long) ((char *) external - (char *) pnotes));
16606 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16607 inote.type, inote.namesz, inote.descsz);
16608 break;
16609 }
16610
16611 printf (" %s: ", get_v850_elf_note_type (inote.type));
16612
16613 if (! print_v850_note (& inote))
16614 {
16615 res = 0;
16616 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
16617 inote.namesz, inote.descsz);
16618 }
16619 }
16620
16621 free (pnotes);
16622
16623 return res;
16624}
16625
779fe533 16626static int
2cf0635d 16627process_note_sections (FILE * file)
1ec5cd37 16628{
2cf0635d 16629 Elf_Internal_Shdr * section;
1ec5cd37 16630 unsigned long i;
df565f32 16631 int n = 0;
1ec5cd37
NC		 16632 int res = 1;
16633
16634 for (i = 0, section = section_headers;
fa1908fd 16635 i < elf_header.e_shnum && section != NULL;
1ec5cd37 16636 i++, section++)
685080f2
NC		 16637 {
16638 if (section->sh_type == SHT_NOTE)
16639 {
1449284b
NC		 16640 res &= process_notes_at (file, section,
16641 (bfd_vma) section->sh_offset,
16642 (bfd_vma) section->sh_size);
685080f2
NC		 16643 n++;
16644 }
16645
16646 if (( elf_header.e_machine == EM_V800
16647 || elf_header.e_machine == EM_V850
16648 || elf_header.e_machine == EM_CYGNUS_V850)
16649 && section->sh_type == SHT_RENESAS_INFO)
16650 {
16651 res &= process_v850_notes (file,
16652 (bfd_vma) section->sh_offset,
16653 (bfd_vma) section->sh_size);
16654 n++;
16655 }
16656 }
df565f32
NC		 16657
16658 if (n == 0)
16659 /* Try processing NOTE segments instead. */
16660 return process_corefile_note_segments (file);
1ec5cd37
NC		 16661
16662 return res;
16663}
16664
16665static int
2cf0635d 16666process_notes (FILE * file)
779fe533
NC		 16667{
16668 /* If we have not been asked to display the notes then do nothing. */
16669 if (! do_notes)
16670 return 1;
103f02d3 16671
779fe533 16672 if (elf_header.e_type != ET_CORE)
1ec5cd37 16673 return process_note_sections (file);
103f02d3 16674
779fe533 16675 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 16676 if (elf_header.e_phnum > 0)
16677 return process_corefile_note_segments (file);
779fe533 16678
1ec5cd37
NC		 16679 printf (_("No note segments present in the core file.\n"));
16680 return 1;
779fe533
NC		 16681}
16682
60abdbed
NC		 16683static unsigned char *
16684display_public_gnu_attributes (unsigned char * start,
16685 const unsigned char * const end)
16686{
16687 printf (_(" Unknown GNU attribute: %s\n"), start);
16688
16689 start += strnlen ((char *) start, end - start);
16690 display_raw_attribute (start, end);
16691
16692 return (unsigned char *) end;
16693}
16694
16695static unsigned char *
16696display_generic_attribute (unsigned char * start,
16697 unsigned int tag,
16698 const unsigned char * const end)
16699{
16700 if (tag == 0)
16701 return (unsigned char *) end;
16702
16703 return display_tag_value (tag, start, end);
16704}
16705
252b5132 16706static int
2cf0635d 16707process_arch_specific (FILE * file)
252b5132 16708{
a952a375
NC		 16709 if (! do_arch)
16710 return 1;
16711
252b5132
RH		 16712 switch (elf_header.e_machine)
16713 {
11c1ff18 16714 case EM_ARM:
60abdbed
NC		 16715 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
16716 display_arm_attribute,
16717 display_generic_attribute);
16718
252b5132 16719 case EM_MIPS:
4fe85591 16720 case EM_MIPS_RS3_LE:
252b5132 16721 return process_mips_specific (file);
60abdbed
NC		 16722
16723 case EM_MSP430:
16724 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
16725 display_msp430x_attribute,
16726 display_generic_attribute);
16727
35c08157
KLC		 16728 case EM_NDS32:
16729 return process_nds32_specific (file);
60abdbed 16730
34c8bcba 16731 case EM_PPC:
b82317dd 16732 case EM_PPC64:
60abdbed
NC		 16733 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
16734 display_power_gnu_attribute);
16735
643f7afb
AK		 16736 case EM_S390:
16737 case EM_S390_OLD:
60abdbed
NC		 16738 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
16739 display_s390_gnu_attribute);
16740
9e8c70f9
DM		 16741 case EM_SPARC:
16742 case EM_SPARC32PLUS:
16743 case EM_SPARCV9:
60abdbed
NC		 16744 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
16745 display_sparc_gnu_attribute);
16746
59e6276b 16747 case EM_TI_C6000:
60abdbed
NC		 16748 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
16749 display_tic6x_attribute,
16750 display_generic_attribute);
16751
252b5132 16752 default:
60abdbed
NC		 16753 return process_attributes (file, "gnu", SHT_GNU_ATTRIBUTES,
16754 display_public_gnu_attributes,
16755 display_generic_attribute);
252b5132 16756 }
252b5132
RH		 16757}
16758
16759static int
2cf0635d 16760get_file_header (FILE * file)
252b5132 16761{
9ea033b2
NC		 16762 /* Read in the identity array. */
16763 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 16764 return 0;
16765
9ea033b2 16766 /* Determine how to read the rest of the header. */
b34976b6 16767 switch (elf_header.e_ident[EI_DATA])
9ea033b2 16768 {
1a0670f3
AM		 16769 default:
16770 case ELFDATANONE:
adab8cdc
AO		 16771 case ELFDATA2LSB:
16772 byte_get = byte_get_little_endian;
16773 byte_put = byte_put_little_endian;
16774 break;
16775 case ELFDATA2MSB:
16776 byte_get = byte_get_big_endian;
16777 byte_put = byte_put_big_endian;
16778 break;
9ea033b2
NC		 16779 }
16780
16781 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 16782 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 16783
16784 /* Read in the rest of the header. */
16785 if (is_32bit_elf)
16786 {
16787 Elf32_External_Ehdr ehdr32;
252b5132 16788
9ea033b2
NC		 16789 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
16790 return 0;
103f02d3 16791
9ea033b2
NC		 16792 elf_header.e_type = BYTE_GET (ehdr32.e_type);
16793 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
16794 elf_header.e_version = BYTE_GET (ehdr32.e_version);
16795 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
16796 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
16797 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
16798 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
16799 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
16800 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
16801 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
16802 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
16803 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
16804 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
16805 }
252b5132 16806 else
9ea033b2
NC		 16807 {
16808 Elf64_External_Ehdr ehdr64;
a952a375
NC		 16809
16810 /* If we have been compiled with sizeof (bfd_vma) == 4, then
16811 we will not be able to cope with the 64bit data found in
16812 64 ELF files. Detect this now and abort before we start
50c2245b 16813 overwriting things. */
a952a375
NC		 16814 if (sizeof (bfd_vma) < 8)
16815 {
e3c8793a
NC		 16816 error (_("This instance of readelf has been built without support for a\n\
1681764 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 16818 return 0;
16819 }
103f02d3 16820
9ea033b2
NC		 16821 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
16822 return 0;
103f02d3 16823
9ea033b2
NC		 16824 elf_header.e_type = BYTE_GET (ehdr64.e_type);
16825 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
16826 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 16827 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
16828 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
16829 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 16830 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
16831 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
16832 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
16833 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
16834 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
16835 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
16836 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
16837 }
252b5132 16838
7ece0d85
JJ		 16839 if (elf_header.e_shoff)
16840 {
16841 /* There may be some extensions in the first section header. Don't
16842 bomb if we can't read it. */
16843 if (is_32bit_elf)
049b0c3a 16844 get_32bit_section_headers (file, TRUE);
7ece0d85 16845 else
049b0c3a 16846 get_64bit_section_headers (file, TRUE);
7ece0d85 16847 }
560f3c1c 16848
252b5132
RH		 16849 return 1;
16850}
16851
fb52b2f4
NC		 16852/* Process one ELF object file according to the command line options.
16853 This file may actually be stored in an archive. The file is
16854 positioned at the start of the ELF object. */
16855
ff78d6d6 16856static int
2cf0635d 16857process_object (char * file_name, FILE * file)
252b5132 16858{
252b5132
RH		 16859 unsigned int i;
16860
252b5132
RH		 16861 if (! get_file_header (file))
16862 {
16863 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 16864 return 1;
252b5132
RH		 16865 }
16866
16867 /* Initialise per file variables. */
60bca95a 16868 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 16869 version_info[i] = 0;
16870
60bca95a 16871 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 16872 dynamic_info[i] = 0;
5115b233 16873 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 16874
16875 /* Process the file. */
16876 if (show_name)
16877 printf (_("\nFile: %s\n"), file_name);
16878
18bd398b
NC		 16879 /* Initialise the dump_sects array from the cmdline_dump_sects array.
16880 Note we do this even if cmdline_dump_sects is empty because we
16881 must make sure that the dump_sets array is zeroed out before each
16882 object file is processed. */
16883 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 16884 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 16885
16886 if (num_cmdline_dump_sects > 0)
16887 {
16888 if (num_dump_sects == 0)
16889 /* A sneaky way of allocating the dump_sects array. */
09c11c86 16890 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 16891
16892 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 16893 memcpy (dump_sects, cmdline_dump_sects,
16894 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 16895 }
d70c5fc7 16896
252b5132 16897 if (! process_file_header ())
fb52b2f4 16898 return 1;
252b5132 16899
d1f5c6e3 16900 if (! process_section_headers (file))
2f62977e 16901 {
d1f5c6e3
L		 16902 /* Without loaded section headers we cannot process lots of
16903 things. */
2f62977e 16904 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 16905
2f62977e 16906 if (! do_using_dynamic)
2c610e4b 16907 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 16908 }
252b5132 16909
d1f5c6e3
L		 16910 if (! process_section_groups (file))
16911 {
16912 /* Without loaded section groups we cannot process unwind. */
16913 do_unwind = 0;
16914 }
16915
2f62977e 16916 if (process_program_headers (file))
b2d38a17 16917 process_dynamic_section (file);
252b5132
RH		 16918
16919 process_relocs (file);
16920
4d6ed7c8
NC		 16921 process_unwind (file);
16922
252b5132
RH		 16923 process_symbol_table (file);
16924
16925 process_syminfo (file);
16926
16927 process_version_sections (file);
16928
16929 process_section_contents (file);
f5842774 16930
1ec5cd37 16931 process_notes (file);
103f02d3 16932
047b2264
JJ		 16933 process_gnu_liblist (file);
16934
252b5132
RH		 16935 process_arch_specific (file);
16936
d93f0186
NC		 16937 if (program_headers)
16938 {
16939 free (program_headers);
16940 program_headers = NULL;
16941 }
16942
252b5132
RH		 16943 if (section_headers)
16944 {
16945 free (section_headers);
16946 section_headers = NULL;
16947 }
16948
16949 if (string_table)
16950 {
16951 free (string_table);
16952 string_table = NULL;
d40ac9bd 16953 string_table_length = 0;
252b5132
RH		 16954 }
16955
16956 if (dynamic_strings)
16957 {
16958 free (dynamic_strings);
16959 dynamic_strings = NULL;
d79b3d50 16960 dynamic_strings_length = 0;
252b5132
RH		 16961 }
16962
16963 if (dynamic_symbols)
16964 {
16965 free (dynamic_symbols);
16966 dynamic_symbols = NULL;
19936277 16967 num_dynamic_syms = 0;
252b5132
RH		 16968 }
16969
16970 if (dynamic_syminfo)
16971 {
16972 free (dynamic_syminfo);
16973 dynamic_syminfo = NULL;
16974 }
ff78d6d6 16975
293c573e
MR		 16976 if (dynamic_section)
16977 {
16978 free (dynamic_section);
16979 dynamic_section = NULL;
16980 }
16981
e4b17d5c
L		 16982 if (section_headers_groups)
16983 {
16984 free (section_headers_groups);
16985 section_headers_groups = NULL;
16986 }
16987
16988 if (section_groups)
16989 {
2cf0635d
NC		 16990 struct group_list * g;
16991 struct group_list * next;
e4b17d5c
L		 16992
16993 for (i = 0; i < group_count; i++)
16994 {
16995 for (g = section_groups [i].root; g != NULL; g = next)
16996 {
16997 next = g->next;
16998 free (g);
16999 }
17000 }
17001
17002 free (section_groups);
17003 section_groups = NULL;
17004 }
17005
19e6b90e 17006 free_debug_memory ();
18bd398b 17007
ff78d6d6 17008 return 0;
252b5132
RH		 17009}
17010
2cf0635d
NC		 17011/* Process an ELF archive.
17012 On entry the file is positioned just after the ARMAG string. */
17013
17014static int
17015process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
17016{
17017 struct archive_info arch;
17018 struct archive_info nested_arch;
17019 size_t got;
2cf0635d
NC		 17020 int ret;
17021
17022 show_name = 1;
17023
17024 /* The ARCH structure is used to hold information about this archive. */
17025 arch.file_name = NULL;
17026 arch.file = NULL;
17027 arch.index_array = NULL;
17028 arch.sym_table = NULL;
17029 arch.longnames = NULL;
17030
17031 /* The NESTED_ARCH structure is used as a single-item cache of information
17032 about a nested archive (when members of a thin archive reside within
17033 another regular archive file). */
17034 nested_arch.file_name = NULL;
17035 nested_arch.file = NULL;
17036 nested_arch.index_array = NULL;
17037 nested_arch.sym_table = NULL;
17038 nested_arch.longnames = NULL;
17039
17040 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
17041 {
17042 ret = 1;
17043 goto out;
4145f1d5 17044 }
fb52b2f4 17045
4145f1d5
NC		 17046 if (do_archive_index)
17047 {
2cf0635d 17048 if (arch.sym_table == NULL)
4145f1d5
NC		 17049 error (_("%s: unable to dump the index as none was found\n"), file_name);
17050 else
17051 {
591f7597 17052 unsigned long i, l;
4145f1d5
NC		 17053 unsigned long current_pos;
17054
591f7597
NC		 17055 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
17056 file_name, (unsigned long) arch.index_num, arch.sym_size);
4145f1d5
NC		 17057 current_pos = ftell (file);
17058
2cf0635d 17059 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 17060 {
2cf0635d
NC		 17061 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
17062 {
17063 char * member_name;
4145f1d5 17064
2cf0635d
NC		 17065 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
17066
17067 if (member_name != NULL)
17068 {
17069 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
17070
17071 if (qualified_name != NULL)
17072 {
c2a7d3f5
NC		 17073 printf (_("Contents of binary %s at offset "), qualified_name);
17074 (void) print_vma (arch.index_array[i], PREFIX_HEX);
17075 putchar ('\n');
2cf0635d
NC		 17076 free (qualified_name);
17077 }
4145f1d5
NC		 17078 }
17079 }
2cf0635d
NC		 17080
17081 if (l >= arch.sym_size)
4145f1d5
NC		 17082 {
17083 error (_("%s: end of the symbol table reached before the end of the index\n"),
17084 file_name);
cb8f3167 17085 break;
4145f1d5 17086 }
591f7597
NC		 17087 /* PR 17531: file: 0b6630b2. */
17088 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
17089 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
4145f1d5
NC		 17090 }
17091
c2a7d3f5
NC		 17092 if (arch.uses_64bit_indicies)
17093 l = (l + 7) & ~ 7;
17094 else
17095 l += l & 1;
17096
2cf0635d 17097 if (l < arch.sym_size)
c2a7d3f5
NC		 17098 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
17099 file_name, arch.sym_size - l);
4145f1d5 17100
4145f1d5
NC		 17101 if (fseek (file, current_pos, SEEK_SET) != 0)
17102 {
17103 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 17104 ret = 1;
17105 goto out;
4145f1d5 17106 }
fb52b2f4 17107 }
4145f1d5
NC		 17108
17109 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
17110 && !do_segments && !do_header && !do_dump && !do_version
17111 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 17112 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 17113 {
17114 ret = 0; /* Archive index only. */
17115 goto out;
17116 }
fb52b2f4
NC		 17117 }
17118
d989285c 17119 ret = 0;
fb52b2f4
NC		 17120
17121 while (1)
17122 {
2cf0635d
NC		 17123 char * name;
17124 size_t namelen;
17125 char * qualified_name;
17126
17127 /* Read the next archive header. */
17128 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
17129 {
17130 error (_("%s: failed to seek to next archive header\n"), file_name);
17131 return 1;
17132 }
17133 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
17134 if (got != sizeof arch.arhdr)
17135 {
17136 if (got == 0)
17137 break;
17138 error (_("%s: failed to read archive header\n"), file_name);
17139 ret = 1;
17140 break;
17141 }
17142 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
17143 {
17144 error (_("%s: did not find a valid archive header\n"), arch.file_name);
17145 ret = 1;
17146 break;
17147 }
17148
17149 arch.next_arhdr_offset += sizeof arch.arhdr;
17150
17151 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
17152 if (archive_file_size & 01)
17153 ++archive_file_size;
17154
17155 name = get_archive_member_name (&arch, &nested_arch);
17156 if (name == NULL)
fb52b2f4 17157 {
0fd3a477 17158 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 17159 ret = 1;
17160 break;
fb52b2f4 17161 }
2cf0635d 17162 namelen = strlen (name);
fb52b2f4 17163
2cf0635d
NC		 17164 qualified_name = make_qualified_name (&arch, &nested_arch, name);
17165 if (qualified_name == NULL)
fb52b2f4 17166 {
2cf0635d 17167 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 17168 ret = 1;
17169 break;
fb52b2f4
NC		 17170 }
17171
2cf0635d
NC		 17172 if (is_thin_archive && arch.nested_member_origin == 0)
17173 {
17174 /* This is a proxy for an external member of a thin archive. */
17175 FILE * member_file;
17176 char * member_file_name = adjust_relative_path (file_name, name, namelen);
17177 if (member_file_name == NULL)
17178 {
17179 ret = 1;
17180 break;
17181 }
17182
17183 member_file = fopen (member_file_name, "rb");
17184 if (member_file == NULL)
17185 {
17186 error (_("Input file '%s' is not readable.\n"), member_file_name);
17187 free (member_file_name);
17188 ret = 1;
17189 break;
17190 }
17191
17192 archive_file_offset = arch.nested_member_origin;
17193
17194 ret |= process_object (qualified_name, member_file);
17195
17196 fclose (member_file);
17197 free (member_file_name);
17198 }
17199 else if (is_thin_archive)
17200 {
a043396b
NC		 17201 /* PR 15140: Allow for corrupt thin archives. */
17202 if (nested_arch.file == NULL)
17203 {
17204 error (_("%s: contains corrupt thin archive: %s\n"),
17205 file_name, name);
17206 ret = 1;
17207 break;
17208 }
17209
2cf0635d
NC		 17210 /* This is a proxy for a member of a nested archive. */
17211 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
17212
17213 /* The nested archive file will have been opened and setup by
17214 get_archive_member_name. */
17215 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
17216 {
17217 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
17218 ret = 1;
17219 break;
17220 }
17221
17222 ret |= process_object (qualified_name, nested_arch.file);
17223 }
17224 else
17225 {
17226 archive_file_offset = arch.next_arhdr_offset;
17227 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 17228
2cf0635d
NC		 17229 ret |= process_object (qualified_name, file);
17230 }
fb52b2f4 17231
2b52916e
L		 17232 if (dump_sects != NULL)
17233 {
17234 free (dump_sects);
17235 dump_sects = NULL;
17236 num_dump_sects = 0;
17237 }
17238
2cf0635d 17239 free (qualified_name);
fb52b2f4
NC		 17240 }
17241
4145f1d5 17242 out:
2cf0635d
NC		 17243 if (nested_arch.file != NULL)
17244 fclose (nested_arch.file);
17245 release_archive (&nested_arch);
17246 release_archive (&arch);
fb52b2f4 17247
d989285c 17248 return ret;
fb52b2f4
NC		 17249}
17250
17251static int
2cf0635d 17252process_file (char * file_name)
fb52b2f4 17253{
2cf0635d 17254 FILE * file;
fb52b2f4
NC		 17255 struct stat statbuf;
17256 char armag[SARMAG];
17257 int ret;
17258
17259 if (stat (file_name, &statbuf) < 0)
17260 {
f24ddbdd
NC		 17261 if (errno == ENOENT)
17262 error (_("'%s': No such file\n"), file_name);
17263 else
17264 error (_("Could not locate '%s'. System error message: %s\n"),
17265 file_name, strerror (errno));
17266 return 1;
17267 }
17268
17269 if (! S_ISREG (statbuf.st_mode))
17270 {
17271 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 17272 return 1;
17273 }
17274
17275 file = fopen (file_name, "rb");
17276 if (file == NULL)
17277 {
f24ddbdd 17278 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 17279 return 1;
17280 }
17281
17282 if (fread (armag, SARMAG, 1, file) != 1)
17283 {
4145f1d5 17284 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 17285 fclose (file);
17286 return 1;
17287 }
17288
f54498b4
NC		 17289 current_file_size = (bfd_size_type) statbuf.st_size;
17290
fb52b2f4 17291 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 17292 ret = process_archive (file_name, file, FALSE);
17293 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
17294 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 17295 else
17296 {
4145f1d5
NC		 17297 if (do_archive_index)
17298 error (_("File %s is not an archive so its index cannot be displayed.\n"),
17299 file_name);
17300
fb52b2f4
NC		 17301 rewind (file);
17302 archive_file_size = archive_file_offset = 0;
17303 ret = process_object (file_name, file);
17304 }
17305
17306 fclose (file);
17307
f54498b4 17308 current_file_size = 0;
fb52b2f4
NC		 17309 return ret;
17310}
17311
252b5132
RH		 17312#ifdef SUPPORT_DISASSEMBLY
17313/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 17314 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 17315 symbols. */
252b5132
RH		 17316
17317void
2cf0635d 17318print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 17319{
17320 fprintf (outfile,"0x%8.8x", addr);
17321}
17322
e3c8793a 17323/* Needed by the i386 disassembler. */
252b5132
RH		 17324void
17325db_task_printsym (unsigned int addr)
17326{
17327 print_address (addr, stderr);
17328}
17329#endif
17330
17331int
2cf0635d 17332main (int argc, char ** argv)
252b5132 17333{
ff78d6d6
L		 17334 int err;
17335
252b5132
RH		 17336#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
17337 setlocale (LC_MESSAGES, "");
3882b010
L		 17338#endif
17339#if defined (HAVE_SETLOCALE)
17340 setlocale (LC_CTYPE, "");
252b5132
RH		 17341#endif
17342 bindtextdomain (PACKAGE, LOCALEDIR);
17343 textdomain (PACKAGE);
17344
869b9d07
MM		 17345 expandargv (&argc, &argv);
17346
252b5132
RH		 17347 parse_args (argc, argv);
17348
18bd398b 17349 if (num_dump_sects > 0)
59f14fc0 17350 {
18bd398b 17351 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 17352 cmdline_dump_sects = (dump_type *)
17353 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 17354 if (cmdline_dump_sects == NULL)
591a748a 17355 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 17356 else
17357 {
09c11c86
NC		 17358 memcpy (cmdline_dump_sects, dump_sects,
17359 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 17360 num_cmdline_dump_sects = num_dump_sects;
17361 }
17362 }
17363
18bd398b
NC		 17364 if (optind < (argc - 1))
17365 show_name = 1;
5656ba2c
L		 17366 else if (optind >= argc)
17367 {
17368 warn (_("Nothing to do.\n"));
17369 usage (stderr);
17370 }
18bd398b 17371
ff78d6d6 17372 err = 0;
252b5132 17373 while (optind < argc)
18bd398b 17374 err |= process_file (argv[optind++]);
252b5132
RH		 17375
17376 if (dump_sects != NULL)
17377 free (dump_sects);
59f14fc0
AS		 17378 if (cmdline_dump_sects != NULL)
17379 free (cmdline_dump_sects);
252b5132 17380
ff78d6d6 17381 return err;
252b5132 17382}
GDB Binutils - Deliverables
This page took 2.603917 seconds and 4 git commands to generate.