]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - binutils/readelf.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Automatic date update in version.in
[thirdparty/binutils-gdb.git] / binutils / readelf.c
CommitLineData
252b5132 1/* readelf.c -- display contents of an ELF format file
2571583a 2 Copyright (C) 1998-2017 Free Software Foundation, Inc.
252b5132
RH		 3
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
12ab83a9 5 Modifications by Nick Clifton <nickc@redhat.com>
252b5132
RH		 6
7 This file is part of GNU Binutils.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
32866df7 11 the Free Software Foundation; either version 3 of the License, or
252b5132
RH		 12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
b43b5d5f
NC		 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 02110-1301, USA. */
252b5132 23\f
9eb20dd8 24/* The difference between readelf and objdump:
252b5132 25
74013231 26 Both programs are capable of displaying the contents of ELF format files,
9eb20dd8 27 so why does the binutils project have two file dumpers ?
0de14b54 28
9eb20dd8
NC		 29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
35
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
38
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
42\f
3db64b00 43#include "sysdep.h"
252b5132 44#include <assert.h>
252b5132 45#include <time.h>
1b315056 46#include <zlib.h>
3bfcb652 47#ifdef HAVE_WCHAR_H
7bfd842d 48#include <wchar.h>
3bfcb652 49#endif
252b5132 50
a952a375 51#if __GNUC__ >= 2
19936277 52/* Define BFD64 here, even if our default architecture is 32 bit ELF
a952a375 53 as this will allow us to read in and parse 64bit and 32bit ELF files.
b34976b6 54 Only do this if we believe that the compiler can support a 64 bit
a952a375 55 data type. For now we only rely on GCC being able to do this. */
19936277 56#define BFD64
a952a375
NC		 57#endif
58
3db64b00
AM		 59#include "bfd.h"
60#include "bucomm.h"
3284fe0c 61#include "elfcomm.h"
19e6b90e 62#include "dwarf.h"
252b5132
RH		 63
64#include "elf/common.h"
65#include "elf/external.h"
66#include "elf/internal.h"
252b5132 67
4b78141a
NC		 68
69/* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
70 we can obtain the H8 reloc numbers. We need these for the
71 get_reloc_size() function. We include h8.h again after defining
72 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
73
74#include "elf/h8.h"
75#undef _ELF_H8_H
76
77/* Undo the effects of #including reloc-macros.h. */
78
79#undef START_RELOC_NUMBERS
80#undef RELOC_NUMBER
81#undef FAKE_RELOC
82#undef EMPTY_RELOC
83#undef END_RELOC_NUMBERS
84#undef _RELOC_MACROS_H
85
252b5132
RH		 86/* The following headers use the elf/reloc-macros.h file to
87 automatically generate relocation recognition functions
88 such as elf_mips_reloc_type() */
89
90#define RELOC_MACROS_GEN_FUNC
91
a06ea964 92#include "elf/aarch64.h"
252b5132 93#include "elf/alpha.h"
3b16e843 94#include "elf/arc.h"
252b5132 95#include "elf/arm.h"
3b16e843 96#include "elf/avr.h"
1d65ded4 97#include "elf/bfin.h"
60bca95a 98#include "elf/cr16.h"
3b16e843 99#include "elf/cris.h"
1c0d3aa6 100#include "elf/crx.h"
252b5132
RH		 101#include "elf/d10v.h"
102#include "elf/d30v.h"
d172d4ba 103#include "elf/dlx.h"
cfb8c092 104#include "elf/epiphany.h"
252b5132 105#include "elf/fr30.h"
5c70f934 106#include "elf/frv.h"
3f8107ab 107#include "elf/ft32.h"
3b16e843
NC		 108#include "elf/h8.h"
109#include "elf/hppa.h"
110#include "elf/i386.h"
35b1837e 111#include "elf/i370.h"
3b16e843
NC		 112#include "elf/i860.h"
113#include "elf/i960.h"
114#include "elf/ia64.h"
1e4cf259 115#include "elf/ip2k.h"
84e94c90 116#include "elf/lm32.h"
1c0d3aa6 117#include "elf/iq2000.h"
49f58d10 118#include "elf/m32c.h"
3b16e843
NC		 119#include "elf/m32r.h"
120#include "elf/m68k.h"
75751cd9 121#include "elf/m68hc11.h"
252b5132 122#include "elf/mcore.h"
15ab5209 123#include "elf/mep.h"
a3c62988 124#include "elf/metag.h"
7ba29e2a 125#include "elf/microblaze.h"
3b16e843 126#include "elf/mips.h"
e23eba97 127#include "elf/riscv.h"
3c3bdf30 128#include "elf/mmix.h"
3b16e843
NC		 129#include "elf/mn10200.h"
130#include "elf/mn10300.h"
5506d11a 131#include "elf/moxie.h"
4970f871 132#include "elf/mt.h"
2469cfa2 133#include "elf/msp430.h"
35c08157 134#include "elf/nds32.h"
13761a11 135#include "elf/nios2.h"
73589c9d 136#include "elf/or1k.h"
7d466069 137#include "elf/pj.h"
3b16e843 138#include "elf/ppc.h"
c833c019 139#include "elf/ppc64.h"
2b100bb5 140#include "elf/pru.h"
99c513f6 141#include "elf/rl78.h"
c7927a3c 142#include "elf/rx.h"
a85d7ed0 143#include "elf/s390.h"
1c0d3aa6 144#include "elf/score.h"
3b16e843
NC		 145#include "elf/sh.h"
146#include "elf/sparc.h"
e9f53129 147#include "elf/spu.h"
40b36596 148#include "elf/tic6x.h"
aa137e4d
NC		 149#include "elf/tilegx.h"
150#include "elf/tilepro.h"
3b16e843 151#include "elf/v850.h"
179d3252 152#include "elf/vax.h"
619ed720 153#include "elf/visium.h"
f96bd6c2 154#include "elf/wasm32.h"
3b16e843 155#include "elf/x86-64.h"
c29aca4a 156#include "elf/xc16x.h"
f6c1a2d5 157#include "elf/xgate.h"
93fbbb04 158#include "elf/xstormy16.h"
88da6820 159#include "elf/xtensa.h"
252b5132 160
252b5132 161#include "getopt.h"
566b0d53 162#include "libiberty.h"
09c11c86 163#include "safe-ctype.h"
2cf0635d 164#include "filenames.h"
252b5132 165
15b42fb0
AM		 166#ifndef offsetof
167#define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
168#endif
169
6a40cf0c
NC		 170typedef struct elf_section_list
171{
172 Elf_Internal_Shdr * hdr;
173 struct elf_section_list * next;
174} elf_section_list;
175
2cf0635d 176char * program_name = "readelf";
c9c1d674 177static unsigned long archive_file_offset;
85b1c36d 178static unsigned long archive_file_size;
f54498b4 179static bfd_size_type current_file_size;
85b1c36d
BE		 180static unsigned long dynamic_addr;
181static bfd_size_type dynamic_size;
8b73c356 182static size_t dynamic_nent;
2cf0635d 183static char * dynamic_strings;
85b1c36d 184static unsigned long dynamic_strings_length;
2cf0635d 185static char * string_table;
85b1c36d
BE		 186static unsigned long string_table_length;
187static unsigned long num_dynamic_syms;
2cf0635d
NC		 188static Elf_Internal_Sym * dynamic_symbols;
189static Elf_Internal_Syminfo * dynamic_syminfo;
85b1c36d
BE		 190static unsigned long dynamic_syminfo_offset;
191static unsigned int dynamic_syminfo_nent;
f8eae8b2 192static char program_interpreter[PATH_MAX];
bb8a0291 193static bfd_vma dynamic_info[DT_ENCODING];
fdc90cb4 194static bfd_vma dynamic_info_DT_GNU_HASH;
85b1c36d
BE		 195static bfd_vma version_info[16];
196static Elf_Internal_Ehdr elf_header;
2cf0635d
NC		 197static Elf_Internal_Shdr * section_headers;
198static Elf_Internal_Phdr * program_headers;
199static Elf_Internal_Dyn * dynamic_section;
6a40cf0c 200static elf_section_list * symtab_shndx_list;
32ec8896
NC		 201static bfd_boolean show_name = FALSE;
202static bfd_boolean do_dynamic = FALSE;
203static bfd_boolean do_syms = FALSE;
204static bfd_boolean do_dyn_syms = FALSE;
205static bfd_boolean do_reloc = FALSE;
206static bfd_boolean do_sections = FALSE;
207static bfd_boolean do_section_groups = FALSE;
208static bfd_boolean do_section_details = FALSE;
209static bfd_boolean do_segments = FALSE;
210static bfd_boolean do_unwind = FALSE;
211static bfd_boolean do_using_dynamic = FALSE;
212static bfd_boolean do_header = FALSE;
213static bfd_boolean do_dump = FALSE;
214static bfd_boolean do_version = FALSE;
215static bfd_boolean do_histogram = FALSE;
216static bfd_boolean do_debugging = FALSE;
217static bfd_boolean do_arch = FALSE;
218static bfd_boolean do_notes = FALSE;
219static bfd_boolean do_archive_index = FALSE;
220static bfd_boolean is_32bit_elf = FALSE;
221static bfd_boolean decompress_dumps = FALSE;
252b5132 222
e4b17d5c
L		 223struct group_list
224{
2cf0635d 225 struct group_list * next;
e4b17d5c
L		 226 unsigned int section_index;
227};
228
229struct group
230{
2cf0635d 231 struct group_list * root;
e4b17d5c
L		 232 unsigned int group_index;
233};
234
85b1c36d 235static size_t group_count;
2cf0635d
NC		 236static struct group * section_groups;
237static struct group ** section_headers_groups;
e4b17d5c 238
09c11c86
NC		 239
240/* Flag bits indicating particular types of dump. */
241#define HEX_DUMP (1 << 0) /* The -x command line switch. */
242#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
243#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
244#define STRING_DUMP (1 << 3) /* The -p command line switch. */
cf13d699 245#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
09c11c86
NC		 246
247typedef unsigned char dump_type;
248
249/* A linked list of the section names for which dumps were requested. */
aef1f6d0
DJ		 250struct dump_list_entry
251{
2cf0635d 252 char * name;
09c11c86 253 dump_type type;
2cf0635d 254 struct dump_list_entry * next;
aef1f6d0 255};
2cf0635d 256static struct dump_list_entry * dump_sects_byname;
aef1f6d0 257
09c11c86
NC		 258/* A dynamic array of flags indicating for which sections a dump
259 has been requested via command line switches. */
260static dump_type * cmdline_dump_sects = NULL;
261static unsigned int num_cmdline_dump_sects = 0;
18bd398b
NC		 262
263/* A dynamic array of flags indicating for which sections a dump of
264 some kind has been requested. It is reset on a per-object file
aef1f6d0
DJ		 265 basis and then initialised from the cmdline_dump_sects array,
266 the results of interpreting the -w switch, and the
267 dump_sects_byname list. */
09c11c86
NC		 268static dump_type * dump_sects = NULL;
269static unsigned int num_dump_sects = 0;
252b5132 270
252b5132 271
c256ffe7 272/* How to print a vma value. */
843dd992
NC		 273typedef enum print_mode
274{
275 HEX,
276 DEC,
277 DEC_5,
278 UNSIGNED,
279 PREFIX_HEX,
280 FULL_HEX,
281 LONG_HEX
282}
283print_mode;
284
bb4d2ac2
L		 285/* Versioned symbol info. */
286enum versioned_symbol_info
287{
288 symbol_undefined,
289 symbol_hidden,
290 symbol_public
291};
292
32ec8896
NC		 293static const char * get_symbol_version_string
294 (FILE *, bfd_boolean, const char *, unsigned long, unsigned,
295 Elf_Internal_Sym *, enum versioned_symbol_info *, unsigned short *);
bb4d2ac2 296
9c19a809
NC		 297#define UNKNOWN -1
298
2b692964
NC		 299#define SECTION_NAME(X) \
300 ((X) == NULL ? _("<none>") \
301 : string_table == NULL ? _("<no-name>") \
302 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
0b49d371 303 : string_table + (X)->sh_name))
252b5132 304
ee42cf8c 305#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
252b5132 306
ba5cdace
NC		 307#define GET_ELF_SYMBOLS(file, section, sym_count) \
308 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
309 : get_64bit_elf_symbols (file, section, sym_count))
9ea033b2 310
d79b3d50
NC		 311#define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
312/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
313 already been called and verified that the string exists. */
314#define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
18bd398b 315
61865e30
NC		 316#define REMOVE_ARCH_BITS(ADDR) \
317 do \
318 { \
319 if (elf_header.e_machine == EM_ARM) \
320 (ADDR) &= ~1; \
321 } \
322 while (0)
d79b3d50 323\f
c9c1d674
EG		 324/* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
325 the offset of the current archive member, if we are examining an archive.
59245841
NC		 326 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
327 using malloc and fill that. In either case return the pointer to the start of
328 the retrieved data or NULL if something went wrong. If something does go wrong
c9c1d674
EG		 329 and REASON is not NULL then emit an error message using REASON as part of the
330 context. */
59245841 331
c256ffe7 332static void *
57028622
NC		 333get_data (void * var, FILE * file, unsigned long offset, bfd_size_type size,
334 bfd_size_type nmemb, const char * reason)
a6e9f9df 335{
2cf0635d 336 void * mvar;
57028622 337 bfd_size_type amt = size * nmemb;
a6e9f9df 338
c256ffe7 339 if (size == 0 || nmemb == 0)
a6e9f9df
AM		 340 return NULL;
341
57028622
NC		 342 /* If the size_t type is smaller than the bfd_size_type, eg because
343 you are building a 32-bit tool on a 64-bit host, then make sure
344 that when the sizes are cast to (size_t) no information is lost. */
345 if (sizeof (size_t) < sizeof (bfd_size_type)
346 && ( (bfd_size_type) ((size_t) size) != size
347 || (bfd_size_type) ((size_t) nmemb) != nmemb))
348 {
349 if (reason)
ed754a13
AM		 350 error (_("Size truncation prevents reading 0x%" BFD_VMA_FMT "x"
351 " elements of size 0x%" BFD_VMA_FMT "x for %s\n"),
352 nmemb, size, reason);
57028622
NC		 353 return NULL;
354 }
355
356 /* Check for size overflow. */
357 if (amt < nmemb)
358 {
359 if (reason)
ed754a13
AM		 360 error (_("Size overflow prevents reading 0x%" BFD_VMA_FMT "x"
361 " elements of size 0x%" BFD_VMA_FMT "x for %s\n"),
362 nmemb, size, reason);
57028622
NC		 363 return NULL;
364 }
365
c9c1d674
EG		 366 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
367 attempting to allocate memory when the read is bound to fail. */
368 if (amt > current_file_size
369 || offset + archive_file_offset + amt > current_file_size)
a6e9f9df 370 {
049b0c3a 371 if (reason)
ed754a13
AM		 372 error (_("Reading 0x%" BFD_VMA_FMT "x"
373 " bytes extends past end of file for %s\n"),
374 amt, reason);
a6e9f9df
AM		 375 return NULL;
376 }
377
c9c1d674 378 if (fseek (file, archive_file_offset + offset, SEEK_SET))
071436c6
NC		 379 {
380 if (reason)
c9c1d674 381 error (_("Unable to seek to 0x%lx for %s\n"),
ed754a13 382 archive_file_offset + offset, reason);
071436c6
NC		 383 return NULL;
384 }
385
a6e9f9df
AM		 386 mvar = var;
387 if (mvar == NULL)
388 {
c256ffe7 389 /* Check for overflow. */
57028622 390 if (nmemb < (~(bfd_size_type) 0 - 1) / size)
c256ffe7 391 /* + 1 so that we can '\0' terminate invalid string table sections. */
57028622 392 mvar = malloc ((size_t) amt + 1);
a6e9f9df
AM		 393
394 if (mvar == NULL)
395 {
049b0c3a 396 if (reason)
ed754a13
AM		 397 error (_("Out of memory allocating 0x%" BFD_VMA_FMT "x"
398 " bytes for %s\n"),
399 amt, reason);
a6e9f9df
AM		 400 return NULL;
401 }
c256ffe7 402
c9c1d674 403 ((char *) mvar)[amt] = '\0';
a6e9f9df
AM		 404 }
405
57028622 406 if (fread (mvar, (size_t) size, (size_t) nmemb, file) != nmemb)
a6e9f9df 407 {
049b0c3a 408 if (reason)
ed754a13
AM		 409 error (_("Unable to read in 0x%" BFD_VMA_FMT "x bytes of %s\n"),
410 amt, reason);
a6e9f9df
AM		 411 if (mvar != var)
412 free (mvar);
413 return NULL;
414 }
415
416 return mvar;
417}
418
32ec8896
NC		 419/* Print a VMA value in the MODE specified.
420 Returns the number of characters displayed. */
cb8f3167 421
32ec8896 422static unsigned int
14a91970 423print_vma (bfd_vma vma, print_mode mode)
66543521 424{
32ec8896 425 unsigned int nc = 0;
66543521 426
14a91970 427 switch (mode)
66543521 428 {
14a91970
AM		 429 case FULL_HEX:
430 nc = printf ("0x");
1a0670f3 431 /* Fall through. */
14a91970 432 case LONG_HEX:
f7a99963 433#ifdef BFD64
14a91970 434 if (is_32bit_elf)
437c2fb7 435 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
f7a99963 436#endif
14a91970
AM		 437 printf_vma (vma);
438 return nc + 16;
b19aac67 439
14a91970
AM		 440 case DEC_5:
441 if (vma <= 99999)
442 return printf ("%5" BFD_VMA_FMT "d", vma);
1a0670f3 443 /* Fall through. */
14a91970
AM		 444 case PREFIX_HEX:
445 nc = printf ("0x");
1a0670f3 446 /* Fall through. */
14a91970
AM		 447 case HEX:
448 return nc + printf ("%" BFD_VMA_FMT "x", vma);
b19aac67 449
14a91970
AM		 450 case DEC:
451 return printf ("%" BFD_VMA_FMT "d", vma);
b19aac67 452
14a91970
AM		 453 case UNSIGNED:
454 return printf ("%" BFD_VMA_FMT "u", vma);
32ec8896
NC		 455
456 default:
457 /* FIXME: Report unrecognised mode ? */
458 return 0;
f7a99963 459 }
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
32ec8896 473print_symbol (signed int width, const char *symbol)
31104126 474{
171191ba 475 bfd_boolean extra_padding = FALSE;
32ec8896 476 signed int num_printed = 0;
3bfcb652 477#ifdef HAVE_MBSTATE_T
7bfd842d 478 mbstate_t state;
3bfcb652 479#endif
32ec8896 480 unsigned int width_remaining;
961c521f 481
7bfd842d 482 if (width < 0)
961c521f 483 {
88305e1b 484 /* Keep the width positive. This helps the code below. */
961c521f 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
32ec8896
NC		 692/* Read an unsigned LEB128 encoded value from DATA.
693 Set *LENGTH_RETURN to the number of bytes read. */
0b6ae522 694
f6f0e17b 695static inline unsigned long
32ec8896
NC		 696read_uleb128 (unsigned char * data,
697 unsigned int * length_return,
f6f0e17b 698 const unsigned char * const end)
0b6ae522 699{
f6f0e17b 700 return read_leb128 (data, length_return, FALSE, end);
0b6ae522
DJ		 701}
702
32ec8896 703/* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
28f997cf
TG		 704 This OS has so many departures from the ELF standard that we test it at
705 many places. */
706
32ec8896 707static inline bfd_boolean
28f997cf
TG		 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
32ec8896 716static bfd_boolean
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:
f96bd6c2 813 case EM_WEBASSEMBLY:
9c19a809 814 return TRUE;
103f02d3 815
e9f53129
AM		 816 case EM_68HC05:
817 case EM_68HC08:
818 case EM_68HC11:
819 case EM_68HC16:
820 case EM_FX66:
821 case EM_ME16:
d1133906 822 case EM_MMA:
d1133906
NC		 823 case EM_NCPU:
824 case EM_NDR1:
e9f53129 825 case EM_PCP:
d1133906 826 case EM_ST100:
e9f53129 827 case EM_ST19:
d1133906 828 case EM_ST7:
e9f53129
AM		 829 case EM_ST9PLUS:
830 case EM_STARCORE:
d1133906 831 case EM_SVX:
e9f53129 832 case EM_TINYJ:
9c19a809
NC		 833 default:
834 warn (_("Don't know about relocations on this machine architecture\n"));
835 return FALSE;
836 }
837}
252b5132 838
32ec8896
NC		 839/* Load RELA type relocations from FILE at REL_OFFSET extending for REL_SIZE bytes.
840 Returns TRUE upon success, FALSE otherwise. If successful then a
841 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
842 and the number of relocs loaded is placed in *NRELASP. It is the caller's
843 responsibility to free the allocated buffer. */
844
845static bfd_boolean
2cf0635d 846slurp_rela_relocs (FILE * file,
d3ba0551
AM		 847 unsigned long rel_offset,
848 unsigned long rel_size,
2cf0635d
NC		 849 Elf_Internal_Rela ** relasp,
850 unsigned long * nrelasp)
9c19a809 851{
2cf0635d 852 Elf_Internal_Rela * relas;
8b73c356 853 size_t nrelas;
4d6ed7c8 854 unsigned int i;
252b5132 855
4d6ed7c8
NC		 856 if (is_32bit_elf)
857 {
2cf0635d 858 Elf32_External_Rela * erelas;
103f02d3 859
3f5e193b 860 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 861 rel_size, _("32-bit relocation data"));
a6e9f9df 862 if (!erelas)
32ec8896 863 return FALSE;
252b5132 864
4d6ed7c8 865 nrelas = rel_size / sizeof (Elf32_External_Rela);
103f02d3 866
3f5e193b
NC		 867 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
868 sizeof (Elf_Internal_Rela));
103f02d3 869
4d6ed7c8
NC		 870 if (relas == NULL)
871 {
c256ffe7 872 free (erelas);
591a748a 873 error (_("out of memory parsing relocs\n"));
32ec8896 874 return FALSE;
4d6ed7c8 875 }
103f02d3 876
4d6ed7c8
NC		 877 for (i = 0; i < nrelas; i++)
878 {
879 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
880 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 881 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
4d6ed7c8 882 }
103f02d3 883
4d6ed7c8
NC		 884 free (erelas);
885 }
886 else
887 {
2cf0635d 888 Elf64_External_Rela * erelas;
103f02d3 889
3f5e193b 890 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 891 rel_size, _("64-bit relocation data"));
a6e9f9df 892 if (!erelas)
32ec8896 893 return FALSE;
4d6ed7c8
NC		 894
895 nrelas = rel_size / sizeof (Elf64_External_Rela);
103f02d3 896
3f5e193b
NC		 897 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
898 sizeof (Elf_Internal_Rela));
103f02d3 899
4d6ed7c8
NC		 900 if (relas == NULL)
901 {
c256ffe7 902 free (erelas);
591a748a 903 error (_("out of memory parsing relocs\n"));
32ec8896 904 return FALSE;
9c19a809 905 }
4d6ed7c8
NC		 906
907 for (i = 0; i < nrelas; i++)
9c19a809 908 {
66543521
AM		 909 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
910 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 911 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
861fb55a
DJ		 912
913 /* The #ifdef BFD64 below is to prevent a compile time
914 warning. We know that if we do not have a 64 bit data
915 type that we will never execute this code anyway. */
916#ifdef BFD64
917 if (elf_header.e_machine == EM_MIPS
918 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
919 {
920 /* In little-endian objects, r_info isn't really a
921 64-bit little-endian value: it has a 32-bit
922 little-endian symbol index followed by four
923 individual byte fields. Reorder INFO
924 accordingly. */
91d6fa6a
NC		 925 bfd_vma inf = relas[i].r_info;
926 inf = (((inf & 0xffffffff) << 32)
927 | ((inf >> 56) & 0xff)
928 | ((inf >> 40) & 0xff00)
929 | ((inf >> 24) & 0xff0000)
930 | ((inf >> 8) & 0xff000000));
931 relas[i].r_info = inf;
861fb55a
DJ		 932 }
933#endif /* BFD64 */
4d6ed7c8 934 }
103f02d3 935
4d6ed7c8
NC		 936 free (erelas);
937 }
32ec8896 938
4d6ed7c8
NC		 939 *relasp = relas;
940 *nrelasp = nrelas;
32ec8896 941 return TRUE;
4d6ed7c8 942}
103f02d3 943
32ec8896
NC		 944/* Load REL type relocations from FILE at REL_OFFSET extending for REL_SIZE bytes.
945 Returns TRUE upon success, FALSE otherwise. If successful then a
946 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
947 and the number of relocs loaded is placed in *NRELSP. It is the caller's
948 responsibility to free the allocated buffer. */
949
950static bfd_boolean
2cf0635d 951slurp_rel_relocs (FILE * file,
d3ba0551
AM		 952 unsigned long rel_offset,
953 unsigned long rel_size,
2cf0635d
NC		 954 Elf_Internal_Rela ** relsp,
955 unsigned long * nrelsp)
4d6ed7c8 956{
2cf0635d 957 Elf_Internal_Rela * rels;
8b73c356 958 size_t nrels;
4d6ed7c8 959 unsigned int i;
103f02d3 960
4d6ed7c8
NC		 961 if (is_32bit_elf)
962 {
2cf0635d 963 Elf32_External_Rel * erels;
103f02d3 964
3f5e193b 965 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 966 rel_size, _("32-bit relocation data"));
a6e9f9df 967 if (!erels)
32ec8896 968 return FALSE;
103f02d3 969
4d6ed7c8 970 nrels = rel_size / sizeof (Elf32_External_Rel);
103f02d3 971
3f5e193b 972 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 973
4d6ed7c8
NC		 974 if (rels == NULL)
975 {
c256ffe7 976 free (erels);
591a748a 977 error (_("out of memory parsing relocs\n"));
32ec8896 978 return FALSE;
4d6ed7c8
NC		 979 }
980
981 for (i = 0; i < nrels; i++)
982 {
983 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
984 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 985 rels[i].r_addend = 0;
9ea033b2 986 }
4d6ed7c8
NC		 987
988 free (erels);
9c19a809
NC		 989 }
990 else
991 {
2cf0635d 992 Elf64_External_Rel * erels;
9ea033b2 993
3f5e193b 994 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 995 rel_size, _("64-bit relocation data"));
a6e9f9df 996 if (!erels)
32ec8896 997 return FALSE;
103f02d3 998
4d6ed7c8 999 nrels = rel_size / sizeof (Elf64_External_Rel);
103f02d3 1000
3f5e193b 1001 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 1002
4d6ed7c8 1003 if (rels == NULL)
9c19a809 1004 {
c256ffe7 1005 free (erels);
591a748a 1006 error (_("out of memory parsing relocs\n"));
32ec8896 1007 return FALSE;
4d6ed7c8 1008 }
103f02d3 1009
4d6ed7c8
NC		 1010 for (i = 0; i < nrels; i++)
1011 {
66543521
AM		 1012 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1013 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 1014 rels[i].r_addend = 0;
861fb55a
DJ		 1015
1016 /* The #ifdef BFD64 below is to prevent a compile time
1017 warning. We know that if we do not have a 64 bit data
1018 type that we will never execute this code anyway. */
1019#ifdef BFD64
1020 if (elf_header.e_machine == EM_MIPS
1021 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
1022 {
1023 /* In little-endian objects, r_info isn't really a
1024 64-bit little-endian value: it has a 32-bit
1025 little-endian symbol index followed by four
1026 individual byte fields. Reorder INFO
1027 accordingly. */
91d6fa6a
NC		 1028 bfd_vma inf = rels[i].r_info;
1029 inf = (((inf & 0xffffffff) << 32)
1030 | ((inf >> 56) & 0xff)
1031 | ((inf >> 40) & 0xff00)
1032 | ((inf >> 24) & 0xff0000)
1033 | ((inf >> 8) & 0xff000000));
1034 rels[i].r_info = inf;
861fb55a
DJ		 1035 }
1036#endif /* BFD64 */
4d6ed7c8 1037 }
103f02d3 1038
4d6ed7c8
NC		 1039 free (erels);
1040 }
32ec8896 1041
4d6ed7c8
NC		 1042 *relsp = rels;
1043 *nrelsp = nrels;
32ec8896 1044 return TRUE;
4d6ed7c8 1045}
103f02d3 1046
aca88567
NC		 1047/* Returns the reloc type extracted from the reloc info field. */
1048
1049static unsigned int
1050get_reloc_type (bfd_vma reloc_info)
1051{
1052 if (is_32bit_elf)
1053 return ELF32_R_TYPE (reloc_info);
1054
1055 switch (elf_header.e_machine)
1056 {
1057 case EM_MIPS:
1058 /* Note: We assume that reloc_info has already been adjusted for us. */
1059 return ELF64_MIPS_R_TYPE (reloc_info);
1060
1061 case EM_SPARCV9:
1062 return ELF64_R_TYPE_ID (reloc_info);
1063
1064 default:
1065 return ELF64_R_TYPE (reloc_info);
1066 }
1067}
1068
1069/* Return the symbol index extracted from the reloc info field. */
1070
1071static bfd_vma
1072get_reloc_symindex (bfd_vma reloc_info)
1073{
1074 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1075}
1076
13761a11
NC		 1077static inline bfd_boolean
1078uses_msp430x_relocs (void)
1079{
1080 return
1081 elf_header.e_machine == EM_MSP430 /* Paranoia. */
1082 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1083 && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1084 /* TI compiler uses ELFOSABI_NONE. */
1085 || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1086}
1087
d3ba0551
AM		 1088/* Display the contents of the relocation data found at the specified
1089 offset. */
ee42cf8c 1090
32ec8896 1091static bfd_boolean
2cf0635d 1092dump_relocations (FILE * file,
d3ba0551
AM		 1093 unsigned long rel_offset,
1094 unsigned long rel_size,
2cf0635d 1095 Elf_Internal_Sym * symtab,
d3ba0551 1096 unsigned long nsyms,
2cf0635d 1097 char * strtab,
d79b3d50 1098 unsigned long strtablen,
bb4d2ac2 1099 int is_rela,
32ec8896 1100 bfd_boolean is_dynsym)
4d6ed7c8 1101{
32ec8896 1102 unsigned long i;
2cf0635d 1103 Elf_Internal_Rela * rels;
32ec8896 1104 bfd_boolean res = TRUE;
103f02d3 1105
4d6ed7c8
NC		 1106 if (is_rela == UNKNOWN)
1107 is_rela = guess_is_rela (elf_header.e_machine);
103f02d3 1108
4d6ed7c8
NC		 1109 if (is_rela)
1110 {
c8286bd1 1111 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
32ec8896 1112 return FALSE;
4d6ed7c8
NC		 1113 }
1114 else
1115 {
1116 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
32ec8896 1117 return FALSE;
252b5132
RH		 1118 }
1119
410f7a12
L		 1120 if (is_32bit_elf)
1121 {
1122 if (is_rela)
2c71103e
NC		 1123 {
1124 if (do_wide)
1125 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1126 else
1127 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1128 }
410f7a12 1129 else
2c71103e
NC		 1130 {
1131 if (do_wide)
1132 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1133 else
1134 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1135 }
410f7a12 1136 }
252b5132 1137 else
410f7a12
L		 1138 {
1139 if (is_rela)
2c71103e
NC		 1140 {
1141 if (do_wide)
8beeaeb7 1142 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
2c71103e
NC		 1143 else
1144 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1145 }
410f7a12 1146 else
2c71103e
NC		 1147 {
1148 if (do_wide)
8beeaeb7 1149 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
2c71103e
NC		 1150 else
1151 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1152 }
410f7a12 1153 }
252b5132
RH		 1154
1155 for (i = 0; i < rel_size; i++)
1156 {
2cf0635d 1157 const char * rtype;
b34976b6 1158 bfd_vma offset;
91d6fa6a 1159 bfd_vma inf;
b34976b6
AM		 1160 bfd_vma symtab_index;
1161 bfd_vma type;
103f02d3 1162
b34976b6 1163 offset = rels[i].r_offset;
91d6fa6a 1164 inf = rels[i].r_info;
103f02d3 1165
91d6fa6a
NC		 1166 type = get_reloc_type (inf);
1167 symtab_index = get_reloc_symindex (inf);
252b5132 1168
410f7a12
L		 1169 if (is_32bit_elf)
1170 {
39dbeff8
AM		 1171 printf ("%8.8lx %8.8lx ",
1172 (unsigned long) offset & 0xffffffff,
91d6fa6a 1173 (unsigned long) inf & 0xffffffff);
410f7a12
L		 1174 }
1175 else
1176 {
39dbeff8
AM		 1177#if BFD_HOST_64BIT_LONG
1178 printf (do_wide
1179 ? "%16.16lx %16.16lx "
1180 : "%12.12lx %12.12lx ",
91d6fa6a 1181 offset, inf);
39dbeff8 1182#elif BFD_HOST_64BIT_LONG_LONG
6e3d6dc1 1183#ifndef __MSVCRT__
39dbeff8
AM		 1184 printf (do_wide
1185 ? "%16.16llx %16.16llx "
1186 : "%12.12llx %12.12llx ",
91d6fa6a 1187 offset, inf);
6e3d6dc1
NC		 1188#else
1189 printf (do_wide
1190 ? "%16.16I64x %16.16I64x "
1191 : "%12.12I64x %12.12I64x ",
91d6fa6a 1192 offset, inf);
6e3d6dc1 1193#endif
39dbeff8 1194#else
2c71103e
NC		 1195 printf (do_wide
1196 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1197 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
410f7a12
L		 1198 _bfd_int64_high (offset),
1199 _bfd_int64_low (offset),
91d6fa6a
NC		 1200 _bfd_int64_high (inf),
1201 _bfd_int64_low (inf));
9ea033b2 1202#endif
410f7a12 1203 }
103f02d3 1204
252b5132
RH		 1205 switch (elf_header.e_machine)
1206 {
1207 default:
1208 rtype = NULL;
1209 break;
1210
a06ea964
NC		 1211 case EM_AARCH64:
1212 rtype = elf_aarch64_reloc_type (type);
1213 break;
1214
2b0337b0 1215 case EM_M32R:
252b5132 1216 case EM_CYGNUS_M32R:
9ea033b2 1217 rtype = elf_m32r_reloc_type (type);
252b5132
RH		 1218 break;
1219
1220 case EM_386:
22abe556 1221 case EM_IAMCU:
9ea033b2 1222 rtype = elf_i386_reloc_type (type);
252b5132
RH		 1223 break;
1224
ba2685cc
AM		 1225 case EM_68HC11:
1226 case EM_68HC12:
1227 rtype = elf_m68hc11_reloc_type (type);
1228 break;
75751cd9 1229
252b5132 1230 case EM_68K:
9ea033b2 1231 rtype = elf_m68k_reloc_type (type);
252b5132
RH		 1232 break;
1233
63fcb9e9 1234 case EM_960:
9ea033b2 1235 rtype = elf_i960_reloc_type (type);
63fcb9e9
ILT		 1236 break;
1237
adde6300 1238 case EM_AVR:
2b0337b0 1239 case EM_AVR_OLD:
adde6300
AM		 1240 rtype = elf_avr_reloc_type (type);
1241 break;
1242
9ea033b2
NC		 1243 case EM_OLD_SPARCV9:
1244 case EM_SPARC32PLUS:
1245 case EM_SPARCV9:
252b5132 1246 case EM_SPARC:
9ea033b2 1247 rtype = elf_sparc_reloc_type (type);
252b5132
RH		 1248 break;
1249
e9f53129
AM		 1250 case EM_SPU:
1251 rtype = elf_spu_reloc_type (type);
1252 break;
1253
708e2187
NC		 1254 case EM_V800:
1255 rtype = v800_reloc_type (type);
1256 break;
2b0337b0 1257 case EM_V850:
252b5132 1258 case EM_CYGNUS_V850:
9ea033b2 1259 rtype = v850_reloc_type (type);
252b5132
RH		 1260 break;
1261
2b0337b0 1262 case EM_D10V:
252b5132 1263 case EM_CYGNUS_D10V:
9ea033b2 1264 rtype = elf_d10v_reloc_type (type);
252b5132
RH		 1265 break;
1266
2b0337b0 1267 case EM_D30V:
252b5132 1268 case EM_CYGNUS_D30V:
9ea033b2 1269 rtype = elf_d30v_reloc_type (type);
252b5132
RH		 1270 break;
1271
d172d4ba
NC		 1272 case EM_DLX:
1273 rtype = elf_dlx_reloc_type (type);
1274 break;
1275
252b5132 1276 case EM_SH:
9ea033b2 1277 rtype = elf_sh_reloc_type (type);
252b5132
RH		 1278 break;
1279
2b0337b0 1280 case EM_MN10300:
252b5132 1281 case EM_CYGNUS_MN10300:
9ea033b2 1282 rtype = elf_mn10300_reloc_type (type);
252b5132
RH		 1283 break;
1284
2b0337b0 1285 case EM_MN10200:
252b5132 1286 case EM_CYGNUS_MN10200:
9ea033b2 1287 rtype = elf_mn10200_reloc_type (type);
252b5132
RH		 1288 break;
1289
2b0337b0 1290 case EM_FR30:
252b5132 1291 case EM_CYGNUS_FR30:
9ea033b2 1292 rtype = elf_fr30_reloc_type (type);
252b5132
RH		 1293 break;
1294
ba2685cc
AM		 1295 case EM_CYGNUS_FRV:
1296 rtype = elf_frv_reloc_type (type);
1297 break;
5c70f934 1298
3f8107ab
AM		 1299 case EM_FT32:
1300 rtype = elf_ft32_reloc_type (type);
1301 break;
1302
252b5132 1303 case EM_MCORE:
9ea033b2 1304 rtype = elf_mcore_reloc_type (type);
252b5132
RH		 1305 break;
1306
3c3bdf30
NC		 1307 case EM_MMIX:
1308 rtype = elf_mmix_reloc_type (type);
1309 break;
1310
5506d11a
AM		 1311 case EM_MOXIE:
1312 rtype = elf_moxie_reloc_type (type);
1313 break;
1314
2469cfa2 1315 case EM_MSP430:
13761a11
NC		 1316 if (uses_msp430x_relocs ())
1317 {
1318 rtype = elf_msp430x_reloc_type (type);
1319 break;
1320 }
1a0670f3 1321 /* Fall through. */
2469cfa2
NC		 1322 case EM_MSP430_OLD:
1323 rtype = elf_msp430_reloc_type (type);
1324 break;
1325
35c08157
KLC		 1326 case EM_NDS32:
1327 rtype = elf_nds32_reloc_type (type);
1328 break;
1329
252b5132 1330 case EM_PPC:
9ea033b2 1331 rtype = elf_ppc_reloc_type (type);
252b5132
RH		 1332 break;
1333
c833c019
AM		 1334 case EM_PPC64:
1335 rtype = elf_ppc64_reloc_type (type);
1336 break;
1337
252b5132 1338 case EM_MIPS:
4fe85591 1339 case EM_MIPS_RS3_LE:
9ea033b2 1340 rtype = elf_mips_reloc_type (type);
252b5132
RH		 1341 break;
1342
e23eba97
NC		 1343 case EM_RISCV:
1344 rtype = elf_riscv_reloc_type (type);
1345 break;
1346
252b5132 1347 case EM_ALPHA:
9ea033b2 1348 rtype = elf_alpha_reloc_type (type);
252b5132
RH		 1349 break;
1350
1351 case EM_ARM:
9ea033b2 1352 rtype = elf_arm_reloc_type (type);
252b5132
RH		 1353 break;
1354
584da044 1355 case EM_ARC:
886a2506
NC		 1356 case EM_ARC_COMPACT:
1357 case EM_ARC_COMPACT2:
9ea033b2 1358 rtype = elf_arc_reloc_type (type);
252b5132
RH		 1359 break;
1360
1361 case EM_PARISC:
69e617ca 1362 rtype = elf_hppa_reloc_type (type);
252b5132 1363 break;
7d466069 1364
b8720f9d
JL		 1365 case EM_H8_300:
1366 case EM_H8_300H:
1367 case EM_H8S:
1368 rtype = elf_h8_reloc_type (type);
1369 break;
1370
73589c9d
CS		 1371 case EM_OR1K:
1372 rtype = elf_or1k_reloc_type (type);
3b16e843
NC		 1373 break;
1374
7d466069 1375 case EM_PJ:
2b0337b0 1376 case EM_PJ_OLD:
7d466069
ILT		 1377 rtype = elf_pj_reloc_type (type);
1378 break;
800eeca4
JW		 1379 case EM_IA_64:
1380 rtype = elf_ia64_reloc_type (type);
1381 break;
1b61cf92
HPN		 1382
1383 case EM_CRIS:
1384 rtype = elf_cris_reloc_type (type);
1385 break;
535c37ff
JE		 1386
1387 case EM_860:
1388 rtype = elf_i860_reloc_type (type);
1389 break;
bcedfee6
NC		 1390
1391 case EM_X86_64:
8a9036a4 1392 case EM_L1OM:
7a9068fe 1393 case EM_K1OM:
bcedfee6
NC		 1394 rtype = elf_x86_64_reloc_type (type);
1395 break;
a85d7ed0 1396
35b1837e
AM		 1397 case EM_S370:
1398 rtype = i370_reloc_type (type);
1399 break;
1400
53c7db4b
KH		 1401 case EM_S390_OLD:
1402 case EM_S390:
1403 rtype = elf_s390_reloc_type (type);
1404 break;
93fbbb04 1405
1c0d3aa6
NC		 1406 case EM_SCORE:
1407 rtype = elf_score_reloc_type (type);
1408 break;
1409
93fbbb04
GK		 1410 case EM_XSTORMY16:
1411 rtype = elf_xstormy16_reloc_type (type);
1412 break;
179d3252 1413
1fe1f39c
NC		 1414 case EM_CRX:
1415 rtype = elf_crx_reloc_type (type);
1416 break;
1417
179d3252
JT		 1418 case EM_VAX:
1419 rtype = elf_vax_reloc_type (type);
1420 break;
1e4cf259 1421
619ed720
EB		 1422 case EM_VISIUM:
1423 rtype = elf_visium_reloc_type (type);
1424 break;
1425
cfb8c092
NC		 1426 case EM_ADAPTEVA_EPIPHANY:
1427 rtype = elf_epiphany_reloc_type (type);
1428 break;
1429
1e4cf259
NC		 1430 case EM_IP2K:
1431 case EM_IP2K_OLD:
1432 rtype = elf_ip2k_reloc_type (type);
1433 break;
3b36097d
SC		 1434
1435 case EM_IQ2000:
1436 rtype = elf_iq2000_reloc_type (type);
1437 break;
88da6820
NC		 1438
1439 case EM_XTENSA_OLD:
1440 case EM_XTENSA:
1441 rtype = elf_xtensa_reloc_type (type);
1442 break;
a34e3ecb 1443
84e94c90
NC		 1444 case EM_LATTICEMICO32:
1445 rtype = elf_lm32_reloc_type (type);
1446 break;
1447
ff7eeb89 1448 case EM_M32C_OLD:
49f58d10
JB		 1449 case EM_M32C:
1450 rtype = elf_m32c_reloc_type (type);
1451 break;
1452
d031aafb
NS		 1453 case EM_MT:
1454 rtype = elf_mt_reloc_type (type);
a34e3ecb 1455 break;
1d65ded4
CM		 1456
1457 case EM_BLACKFIN:
1458 rtype = elf_bfin_reloc_type (type);
1459 break;
15ab5209
DB		 1460
1461 case EM_CYGNUS_MEP:
1462 rtype = elf_mep_reloc_type (type);
1463 break;
60bca95a
NC		 1464
1465 case EM_CR16:
1466 rtype = elf_cr16_reloc_type (type);
1467 break;
dd24e3da 1468
7ba29e2a
NC		 1469 case EM_MICROBLAZE:
1470 case EM_MICROBLAZE_OLD:
1471 rtype = elf_microblaze_reloc_type (type);
1472 break;
c7927a3c 1473
99c513f6
DD		 1474 case EM_RL78:
1475 rtype = elf_rl78_reloc_type (type);
1476 break;
1477
c7927a3c
NC		 1478 case EM_RX:
1479 rtype = elf_rx_reloc_type (type);
1480 break;
c29aca4a 1481
a3c62988
NC		 1482 case EM_METAG:
1483 rtype = elf_metag_reloc_type (type);
1484 break;
1485
c29aca4a
NC		 1486 case EM_XC16X:
1487 case EM_C166:
1488 rtype = elf_xc16x_reloc_type (type);
1489 break;
40b36596
JM		 1490
1491 case EM_TI_C6000:
1492 rtype = elf_tic6x_reloc_type (type);
1493 break;
aa137e4d
NC		 1494
1495 case EM_TILEGX:
1496 rtype = elf_tilegx_reloc_type (type);
1497 break;
1498
1499 case EM_TILEPRO:
1500 rtype = elf_tilepro_reloc_type (type);
1501 break;
f6c1a2d5 1502
f96bd6c2
PC		 1503 case EM_WEBASSEMBLY:
1504 rtype = elf_wasm32_reloc_type (type);
1505 break;
1506
f6c1a2d5
NC		 1507 case EM_XGATE:
1508 rtype = elf_xgate_reloc_type (type);
1509 break;
36591ba1
SL		 1510
1511 case EM_ALTERA_NIOS2:
1512 rtype = elf_nios2_reloc_type (type);
1513 break;
2b100bb5
DD		 1514
1515 case EM_TI_PRU:
1516 rtype = elf_pru_reloc_type (type);
1517 break;
252b5132
RH		 1518 }
1519
1520 if (rtype == NULL)
39dbeff8 1521 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1522 else
8beeaeb7 1523 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1524
7ace3541 1525 if (elf_header.e_machine == EM_ALPHA
157c2599 1526 && rtype != NULL
7ace3541
RH		 1527 && streq (rtype, "R_ALPHA_LITUSE")
1528 && is_rela)
1529 {
1530 switch (rels[i].r_addend)
1531 {
1532 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1533 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1534 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1535 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1536 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1537 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1538 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1539 default: rtype = NULL;
1540 }
32ec8896 1541
7ace3541
RH		 1542 if (rtype)
1543 printf (" (%s)", rtype);
1544 else
1545 {
1546 putchar (' ');
1547 printf (_("<unknown addend: %lx>"),
1548 (unsigned long) rels[i].r_addend);
32ec8896 1549 res = FALSE;
7ace3541
RH		 1550 }
1551 }
1552 else if (symtab_index)
252b5132 1553 {
af3fc3bc 1554 if (symtab == NULL || symtab_index >= nsyms)
32ec8896
NC		 1555 {
1556 error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index);
1557 res = FALSE;
1558 }
af3fc3bc 1559 else
19936277 1560 {
2cf0635d 1561 Elf_Internal_Sym * psym;
bb4d2ac2
L		 1562 const char * version_string;
1563 enum versioned_symbol_info sym_info;
1564 unsigned short vna_other;
19936277 1565
af3fc3bc 1566 psym = symtab + symtab_index;
103f02d3 1567
bb4d2ac2
L		 1568 version_string
1569 = get_symbol_version_string (file, is_dynsym,
1570 strtab, strtablen,
1571 symtab_index,
1572 psym,
1573 &sym_info,
1574 &vna_other);
1575
af3fc3bc 1576 printf (" ");
171191ba 1577
d8045f23
NC		 1578 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1579 {
1580 const char * name;
1581 unsigned int len;
1582 unsigned int width = is_32bit_elf ? 8 : 14;
1583
1584 /* Relocations against GNU_IFUNC symbols do not use the value
1585 of the symbol as the address to relocate against. Instead
1586 they invoke the function named by the symbol and use its
1587 result as the address for relocation.
1588
1589 To indicate this to the user, do not display the value of
1590 the symbol in the "Symbols's Value" field. Instead show
1591 its name followed by () as a hint that the symbol is
1592 invoked. */
1593
1594 if (strtab == NULL
1595 || psym->st_name == 0
1596 || psym->st_name >= strtablen)
1597 name = "??";
1598 else
1599 name = strtab + psym->st_name;
1600
1601 len = print_symbol (width, name);
bb4d2ac2
L		 1602 if (version_string)
1603 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1604 version_string);
d8045f23
NC		 1605 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1606 }
1607 else
1608 {
1609 print_vma (psym->st_value, LONG_HEX);
171191ba 1610
d8045f23
NC		 1611 printf (is_32bit_elf ? " " : " ");
1612 }
103f02d3 1613
af3fc3bc 1614 if (psym->st_name == 0)
f1ef08cb 1615 {
2cf0635d 1616 const char * sec_name = "<null>";
f1ef08cb
AM		 1617 char name_buf[40];
1618
1619 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1620 {
4fbb74a6 1621 if (psym->st_shndx < elf_header.e_shnum)
74e1a04b 1622 sec_name = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM		 1623 else if (psym->st_shndx == SHN_ABS)
1624 sec_name = "ABS";
1625 else if (psym->st_shndx == SHN_COMMON)
1626 sec_name = "COMMON";
ac145307
BS		 1627 else if ((elf_header.e_machine == EM_MIPS
1628 && psym->st_shndx == SHN_MIPS_SCOMMON)
1629 || (elf_header.e_machine == EM_TI_C6000
1630 && psym->st_shndx == SHN_TIC6X_SCOMMON))
172553c7
TS		 1631 sec_name = "SCOMMON";
1632 else if (elf_header.e_machine == EM_MIPS
1633 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1634 sec_name = "SUNDEF";
8a9036a4 1635 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 1636 || elf_header.e_machine == EM_L1OM
1637 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 1638 && psym->st_shndx == SHN_X86_64_LCOMMON)
1639 sec_name = "LARGE_COMMON";
9ce701e2
L		 1640 else if (elf_header.e_machine == EM_IA_64
1641 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1642 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1643 sec_name = "ANSI_COM";
28f997cf 1644 else if (is_ia64_vms ()
148b93f2
NC		 1645 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1646 sec_name = "VMS_SYMVEC";
f1ef08cb
AM		 1647 else
1648 {
1649 sprintf (name_buf, "<section 0x%x>",
1650 (unsigned int) psym->st_shndx);
1651 sec_name = name_buf;
1652 }
1653 }
1654 print_symbol (22, sec_name);
1655 }
af3fc3bc 1656 else if (strtab == NULL)
d79b3d50 1657 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1658 else if (psym->st_name >= strtablen)
32ec8896
NC		 1659 {
1660 error (_("<corrupt string table index: %3ld>"), psym->st_name);
1661 res = FALSE;
1662 }
af3fc3bc 1663 else
bb4d2ac2
L		 1664 {
1665 print_symbol (22, strtab + psym->st_name);
1666 if (version_string)
1667 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1668 version_string);
1669 }
103f02d3 1670
af3fc3bc 1671 if (is_rela)
171191ba 1672 {
7360e63f 1673 bfd_vma off = rels[i].r_addend;
171191ba 1674
7360e63f 1675 if ((bfd_signed_vma) off < 0)
598aaa76 1676 printf (" - %" BFD_VMA_FMT "x", - off);
171191ba 1677 else
598aaa76 1678 printf (" + %" BFD_VMA_FMT "x", off);
171191ba 1679 }
19936277 1680 }
252b5132 1681 }
1b228002 1682 else if (is_rela)
f7a99963 1683 {
7360e63f 1684 bfd_vma off = rels[i].r_addend;
e04d7088
L		 1685
1686 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
7360e63f 1687 if ((bfd_signed_vma) off < 0)
e04d7088
L		 1688 printf ("-%" BFD_VMA_FMT "x", - off);
1689 else
1690 printf ("%" BFD_VMA_FMT "x", off);
f7a99963 1691 }
252b5132 1692
157c2599
NC		 1693 if (elf_header.e_machine == EM_SPARCV9
1694 && rtype != NULL
1695 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1696 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1697
252b5132 1698 putchar ('\n');
2c71103e 1699
aca88567 1700#ifdef BFD64
53c7db4b 1701 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1702 {
91d6fa6a
NC		 1703 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1704 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC		 1705 const char * rtype2 = elf_mips_reloc_type (type2);
1706 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1707
2c71103e
NC		 1708 printf (" Type2: ");
1709
1710 if (rtype2 == NULL)
39dbeff8
AM		 1711 printf (_("unrecognized: %-7lx"),
1712 (unsigned long) type2 & 0xffffffff);
2c71103e
NC		 1713 else
1714 printf ("%-17.17s", rtype2);
1715
18bd398b 1716 printf ("\n Type3: ");
2c71103e
NC		 1717
1718 if (rtype3 == NULL)
39dbeff8
AM		 1719 printf (_("unrecognized: %-7lx"),
1720 (unsigned long) type3 & 0xffffffff);
2c71103e
NC		 1721 else
1722 printf ("%-17.17s", rtype3);
1723
53c7db4b 1724 putchar ('\n');
2c71103e 1725 }
aca88567 1726#endif /* BFD64 */
252b5132
RH		 1727 }
1728
c8286bd1 1729 free (rels);
32ec8896
NC		 1730
1731 return res;
252b5132
RH		 1732}
1733
1734static const char *
d3ba0551 1735get_mips_dynamic_type (unsigned long type)
252b5132
RH		 1736{
1737 switch (type)
1738 {
1739 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1740 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1741 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1742 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1743 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1744 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1745 case DT_MIPS_MSYM: return "MIPS_MSYM";
1746 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1747 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1748 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1749 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1750 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1751 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1752 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1753 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1754 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1755 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
a5499fa4 1756 case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
252b5132
RH		 1757 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1758 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1759 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1760 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1761 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1762 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1763 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1764 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1765 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1766 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1767 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1768 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1769 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1770 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1771 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1772 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1773 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1774 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1775 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1776 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1777 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1778 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1779 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1780 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1781 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1782 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1783 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1784 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1785 default:
1786 return NULL;
1787 }
1788}
1789
9a097730 1790static const char *
d3ba0551 1791get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1792{
1793 switch (type)
1794 {
1795 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1796 default:
1797 return NULL;
1798 }
103f02d3
UD		 1799}
1800
7490d522
AM		 1801static const char *
1802get_ppc_dynamic_type (unsigned long type)
1803{
1804 switch (type)
1805 {
a7f2871e 1806 case DT_PPC_GOT: return "PPC_GOT";
e8910a83 1807 case DT_PPC_OPT: return "PPC_OPT";
7490d522
AM		 1808 default:
1809 return NULL;
1810 }
1811}
1812
f1cb7e17 1813static const char *
d3ba0551 1814get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1815{
1816 switch (type)
1817 {
a7f2871e
AM		 1818 case DT_PPC64_GLINK: return "PPC64_GLINK";
1819 case DT_PPC64_OPD: return "PPC64_OPD";
1820 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
e8910a83 1821 case DT_PPC64_OPT: return "PPC64_OPT";
f1cb7e17
AM		 1822 default:
1823 return NULL;
1824 }
1825}
1826
103f02d3 1827static const char *
d3ba0551 1828get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1829{
1830 switch (type)
1831 {
1832 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1833 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1834 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1835 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1836 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1837 case DT_HP_PREINIT: return "HP_PREINIT";
1838 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1839 case DT_HP_NEEDED: return "HP_NEEDED";
1840 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1841 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1842 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1843 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1844 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1845 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1846 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1847 case DT_HP_FILTERED: return "HP_FILTERED";
1848 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1849 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1850 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1851 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1852 case DT_PLT: return "PLT";
1853 case DT_PLT_SIZE: return "PLT_SIZE";
1854 case DT_DLT: return "DLT";
1855 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1856 default:
1857 return NULL;
1858 }
1859}
9a097730 1860
ecc51f48 1861static const char *
d3ba0551 1862get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1863{
1864 switch (type)
1865 {
148b93f2
NC		 1866 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1867 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1868 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1869 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1870 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1871 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1872 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1873 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1874 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1875 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1876 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1877 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1878 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1879 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1880 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1881 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1882 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1883 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1884 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1885 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1886 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1887 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1888 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1889 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1890 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1891 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1892 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1893 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1894 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1895 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1896 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1897 default:
1898 return NULL;
1899 }
1900}
1901
fd85a6a1
NC		 1902static const char *
1903get_solaris_section_type (unsigned long type)
1904{
1905 switch (type)
1906 {
1907 case 0x6fffffee: return "SUNW_ancillary";
1908 case 0x6fffffef: return "SUNW_capchain";
1909 case 0x6ffffff0: return "SUNW_capinfo";
1910 case 0x6ffffff1: return "SUNW_symsort";
1911 case 0x6ffffff2: return "SUNW_tlssort";
1912 case 0x6ffffff3: return "SUNW_LDYNSYM";
1913 case 0x6ffffff4: return "SUNW_dof";
1914 case 0x6ffffff5: return "SUNW_cap";
1915 case 0x6ffffff6: return "SUNW_SIGNATURE";
1916 case 0x6ffffff7: return "SUNW_ANNOTATE";
1917 case 0x6ffffff8: return "SUNW_DEBUGSTR";
1918 case 0x6ffffff9: return "SUNW_DEBUG";
1919 case 0x6ffffffa: return "SUNW_move";
1920 case 0x6ffffffb: return "SUNW_COMDAT";
1921 case 0x6ffffffc: return "SUNW_syminfo";
1922 case 0x6ffffffd: return "SUNW_verdef";
1923 case 0x6ffffffe: return "SUNW_verneed";
1924 case 0x6fffffff: return "SUNW_versym";
1925 case 0x70000000: return "SPARC_GOTDATA";
1926 default: return NULL;
1927 }
1928}
1929
fabcb361
RH		 1930static const char *
1931get_alpha_dynamic_type (unsigned long type)
1932{
1933 switch (type)
1934 {
1935 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
32ec8896 1936 default: return NULL;
fabcb361
RH		 1937 }
1938}
1939
1c0d3aa6
NC		 1940static const char *
1941get_score_dynamic_type (unsigned long type)
1942{
1943 switch (type)
1944 {
1945 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1946 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1947 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1948 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1949 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1950 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
32ec8896 1951 default: return NULL;
1c0d3aa6
NC		 1952 }
1953}
1954
40b36596
JM		 1955static const char *
1956get_tic6x_dynamic_type (unsigned long type)
1957{
1958 switch (type)
1959 {
1960 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1961 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1962 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1963 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1964 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1965 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
32ec8896 1966 default: return NULL;
40b36596
JM		 1967 }
1968}
1c0d3aa6 1969
36591ba1
SL		 1970static const char *
1971get_nios2_dynamic_type (unsigned long type)
1972{
1973 switch (type)
1974 {
1975 case DT_NIOS2_GP: return "NIOS2_GP";
32ec8896 1976 default: return NULL;
36591ba1
SL		 1977 }
1978}
1979
fd85a6a1
NC		 1980static const char *
1981get_solaris_dynamic_type (unsigned long type)
1982{
1983 switch (type)
1984 {
1985 case 0x6000000d: return "SUNW_AUXILIARY";
1986 case 0x6000000e: return "SUNW_RTLDINF";
1987 case 0x6000000f: return "SUNW_FILTER";
1988 case 0x60000010: return "SUNW_CAP";
1989 case 0x60000011: return "SUNW_SYMTAB";
1990 case 0x60000012: return "SUNW_SYMSZ";
1991 case 0x60000013: return "SUNW_SORTENT";
1992 case 0x60000014: return "SUNW_SYMSORT";
1993 case 0x60000015: return "SUNW_SYMSORTSZ";
1994 case 0x60000016: return "SUNW_TLSSORT";
1995 case 0x60000017: return "SUNW_TLSSORTSZ";
1996 case 0x60000018: return "SUNW_CAPINFO";
1997 case 0x60000019: return "SUNW_STRPAD";
1998 case 0x6000001a: return "SUNW_CAPCHAIN";
1999 case 0x6000001b: return "SUNW_LDMACH";
2000 case 0x6000001d: return "SUNW_CAPCHAINENT";
2001 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2002 case 0x60000021: return "SUNW_PARENT";
2003 case 0x60000023: return "SUNW_ASLR";
2004 case 0x60000025: return "SUNW_RELAX";
2005 case 0x60000029: return "SUNW_NXHEAP";
2006 case 0x6000002b: return "SUNW_NXSTACK";
2007
2008 case 0x70000001: return "SPARC_REGISTER";
2009 case 0x7ffffffd: return "AUXILIARY";
2010 case 0x7ffffffe: return "USED";
2011 case 0x7fffffff: return "FILTER";
2012
15f205b1 2013 default: return NULL;
fd85a6a1
NC		 2014 }
2015}
2016
252b5132 2017static const char *
d3ba0551 2018get_dynamic_type (unsigned long type)
252b5132 2019{
e9e44622 2020 static char buff[64];
252b5132
RH		 2021
2022 switch (type)
2023 {
2024 case DT_NULL: return "NULL";
2025 case DT_NEEDED: return "NEEDED";
2026 case DT_PLTRELSZ: return "PLTRELSZ";
2027 case DT_PLTGOT: return "PLTGOT";
2028 case DT_HASH: return "HASH";
2029 case DT_STRTAB: return "STRTAB";
2030 case DT_SYMTAB: return "SYMTAB";
2031 case DT_RELA: return "RELA";
2032 case DT_RELASZ: return "RELASZ";
2033 case DT_RELAENT: return "RELAENT";
2034 case DT_STRSZ: return "STRSZ";
2035 case DT_SYMENT: return "SYMENT";
2036 case DT_INIT: return "INIT";
2037 case DT_FINI: return "FINI";
2038 case DT_SONAME: return "SONAME";
2039 case DT_RPATH: return "RPATH";
2040 case DT_SYMBOLIC: return "SYMBOLIC";
2041 case DT_REL: return "REL";
2042 case DT_RELSZ: return "RELSZ";
2043 case DT_RELENT: return "RELENT";
2044 case DT_PLTREL: return "PLTREL";
2045 case DT_DEBUG: return "DEBUG";
2046 case DT_TEXTREL: return "TEXTREL";
2047 case DT_JMPREL: return "JMPREL";
2048 case DT_BIND_NOW: return "BIND_NOW";
2049 case DT_INIT_ARRAY: return "INIT_ARRAY";
2050 case DT_FINI_ARRAY: return "FINI_ARRAY";
2051 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2052 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 2053 case DT_RUNPATH: return "RUNPATH";
2054 case DT_FLAGS: return "FLAGS";
2d0e6f43 2055
d1133906
NC		 2056 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2057 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
6d913794 2058 case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
103f02d3 2059
05107a46 2060 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 2061 case DT_PLTPADSZ: return "PLTPADSZ";
2062 case DT_MOVEENT: return "MOVEENT";
2063 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 2064 case DT_FEATURE: return "FEATURE";
252b5132
RH		 2065 case DT_POSFLAG_1: return "POSFLAG_1";
2066 case DT_SYMINSZ: return "SYMINSZ";
2067 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 2068
252b5132 2069 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 2070 case DT_CONFIG: return "CONFIG";
2071 case DT_DEPAUDIT: return "DEPAUDIT";
2072 case DT_AUDIT: return "AUDIT";
2073 case DT_PLTPAD: return "PLTPAD";
2074 case DT_MOVETAB: return "MOVETAB";
252b5132 2075 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 2076
252b5132 2077 case DT_VERSYM: return "VERSYM";
103f02d3 2078
67a4f2b7
AO		 2079 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2080 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 2081 case DT_RELACOUNT: return "RELACOUNT";
2082 case DT_RELCOUNT: return "RELCOUNT";
2083 case DT_FLAGS_1: return "FLAGS_1";
2084 case DT_VERDEF: return "VERDEF";
2085 case DT_VERDEFNUM: return "VERDEFNUM";
2086 case DT_VERNEED: return "VERNEED";
2087 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 2088
019148e4 2089 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 2090 case DT_USED: return "USED";
2091 case DT_FILTER: return "FILTER";
103f02d3 2092
047b2264
JJ		 2093 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2094 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2095 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2096 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2097 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 2098 case DT_GNU_HASH: return "GNU_HASH";
047b2264 2099
252b5132
RH		 2100 default:
2101 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2102 {
2cf0635d 2103 const char * result;
103f02d3 2104
252b5132
RH		 2105 switch (elf_header.e_machine)
2106 {
2107 case EM_MIPS:
4fe85591 2108 case EM_MIPS_RS3_LE:
252b5132
RH		 2109 result = get_mips_dynamic_type (type);
2110 break;
9a097730
RH		 2111 case EM_SPARCV9:
2112 result = get_sparc64_dynamic_type (type);
2113 break;
7490d522
AM		 2114 case EM_PPC:
2115 result = get_ppc_dynamic_type (type);
2116 break;
f1cb7e17
AM		 2117 case EM_PPC64:
2118 result = get_ppc64_dynamic_type (type);
2119 break;
ecc51f48
NC		 2120 case EM_IA_64:
2121 result = get_ia64_dynamic_type (type);
2122 break;
fabcb361
RH		 2123 case EM_ALPHA:
2124 result = get_alpha_dynamic_type (type);
2125 break;
1c0d3aa6
NC		 2126 case EM_SCORE:
2127 result = get_score_dynamic_type (type);
2128 break;
40b36596
JM		 2129 case EM_TI_C6000:
2130 result = get_tic6x_dynamic_type (type);
2131 break;
36591ba1
SL		 2132 case EM_ALTERA_NIOS2:
2133 result = get_nios2_dynamic_type (type);
2134 break;
252b5132 2135 default:
fd85a6a1
NC		 2136 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2137 result = get_solaris_dynamic_type (type);
2138 else
2139 result = NULL;
252b5132
RH		 2140 break;
2141 }
2142
2143 if (result != NULL)
2144 return result;
2145
e9e44622 2146 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 2147 }
eec8f817
DA		 2148 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2149 || (elf_header.e_machine == EM_PARISC
2150 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 2151 {
2cf0635d 2152 const char * result;
103f02d3
UD		 2153
2154 switch (elf_header.e_machine)
2155 {
2156 case EM_PARISC:
2157 result = get_parisc_dynamic_type (type);
2158 break;
148b93f2
NC		 2159 case EM_IA_64:
2160 result = get_ia64_dynamic_type (type);
2161 break;
103f02d3 2162 default:
fd85a6a1
NC		 2163 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2164 result = get_solaris_dynamic_type (type);
2165 else
2166 result = NULL;
103f02d3
UD		 2167 break;
2168 }
2169
2170 if (result != NULL)
2171 return result;
2172
e9e44622
JJ		 2173 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2174 type);
103f02d3 2175 }
252b5132 2176 else
e9e44622 2177 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 2178
252b5132
RH		 2179 return buff;
2180 }
2181}
2182
2183static char *
d3ba0551 2184get_file_type (unsigned e_type)
252b5132 2185{
b34976b6 2186 static char buff[32];
252b5132
RH		 2187
2188 switch (e_type)
2189 {
32ec8896
NC		 2190 case ET_NONE: return _("NONE (None)");
2191 case ET_REL: return _("REL (Relocatable file)");
2192 case ET_EXEC: return _("EXEC (Executable file)");
2193 case ET_DYN: return _("DYN (Shared object file)");
2194 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 2195
2196 default:
2197 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 2198 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 2199 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 2200 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 2201 else
e9e44622 2202 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 2203 return buff;
2204 }
2205}
2206
2207static char *
d3ba0551 2208get_machine_name (unsigned e_machine)
252b5132 2209{
b34976b6 2210 static char buff[64]; /* XXX */
252b5132
RH		 2211
2212 switch (e_machine)
2213 {
55e22ca8
NC		 2214 /* Please keep this switch table sorted by increasing EM_ value. */
2215 /* 0 */
c45021f2
NC		 2216 case EM_NONE: return _("None");
2217 case EM_M32: return "WE32100";
2218 case EM_SPARC: return "Sparc";
2219 case EM_386: return "Intel 80386";
2220 case EM_68K: return "MC68000";
2221 case EM_88K: return "MC88000";
22abe556 2222 case EM_IAMCU: return "Intel MCU";
c45021f2
NC		 2223 case EM_860: return "Intel 80860";
2224 case EM_MIPS: return "MIPS R3000";
2225 case EM_S370: return "IBM System/370";
55e22ca8 2226 /* 10 */
7036c0e1 2227 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 2228 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 2229 case EM_PARISC: return "HPPA";
55e22ca8 2230 case EM_VPP550: return "Fujitsu VPP500";
7036c0e1 2231 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 2232 case EM_960: return "Intel 90860";
2233 case EM_PPC: return "PowerPC";
55e22ca8 2234 /* 20 */
285d1771 2235 case EM_PPC64: return "PowerPC64";
55e22ca8
NC		 2236 case EM_S390_OLD:
2237 case EM_S390: return "IBM S/390";
2238 case EM_SPU: return "SPU";
2239 /* 30 */
2240 case EM_V800: return "Renesas V850 (using RH850 ABI)";
c45021f2
NC		 2241 case EM_FR20: return "Fujitsu FR20";
2242 case EM_RH32: return "TRW RH32";
b34976b6 2243 case EM_MCORE: return "MCORE";
55e22ca8 2244 /* 40 */
7036c0e1
AJ		 2245 case EM_ARM: return "ARM";
2246 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 2247 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 2248 case EM_SPARCV9: return "Sparc v9";
2249 case EM_TRICORE: return "Siemens Tricore";
584da044 2250 case EM_ARC: return "ARC";
c2dcd04e
NC		 2251 case EM_H8_300: return "Renesas H8/300";
2252 case EM_H8_300H: return "Renesas H8/300H";
2253 case EM_H8S: return "Renesas H8S";
2254 case EM_H8_500: return "Renesas H8/500";
55e22ca8 2255 /* 50 */
30800947 2256 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 2257 case EM_MIPS_X: return "Stanford MIPS-X";
2258 case EM_COLDFIRE: return "Motorola Coldfire";
55e22ca8 2259 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
7036c0e1
AJ		 2260 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2261 case EM_PCP: return "Siemens PCP";
2262 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2263 case EM_NDR1: return "Denso NDR1 microprocesspr";
2264 case EM_STARCORE: return "Motorola Star*Core processor";
2265 case EM_ME16: return "Toyota ME16 processor";
55e22ca8 2266 /* 60 */
7036c0e1
AJ		 2267 case EM_ST100: return "STMicroelectronics ST100 processor";
2268 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
55e22ca8 2269 case EM_X86_64: return "Advanced Micro Devices X86-64";
11636f9e
JM		 2270 case EM_PDSP: return "Sony DSP processor";
2271 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2272 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 2273 case EM_FX66: return "Siemens FX66 microcontroller";
2274 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2275 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2276 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
55e22ca8 2277 /* 70 */
7036c0e1
AJ		 2278 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2279 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2280 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2281 case EM_SVX: return "Silicon Graphics SVx";
2282 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2283 case EM_VAX: return "Digital VAX";
1b61cf92 2284 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 2285 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2286 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2287 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
55e22ca8 2288 /* 80 */
b34976b6 2289 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 2290 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 2291 case EM_PRISM: return "Vitesse Prism";
55e22ca8
NC		 2292 case EM_AVR_OLD:
2293 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
2294 case EM_CYGNUS_FR30:
2295 case EM_FR30: return "Fujitsu FR30";
2296 case EM_CYGNUS_D10V:
2297 case EM_D10V: return "d10v";
2298 case EM_CYGNUS_D30V:
2299 case EM_D30V: return "d30v";
2300 case EM_CYGNUS_V850:
2301 case EM_V850: return "Renesas V850";
2302 case EM_CYGNUS_M32R:
2303 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2304 case EM_CYGNUS_MN10300:
2305 case EM_MN10300: return "mn10300";
2306 /* 90 */
2307 case EM_CYGNUS_MN10200:
2308 case EM_MN10200: return "mn10200";
2309 case EM_PJ: return "picoJava";
73589c9d 2310 case EM_OR1K: return "OpenRISC 1000";
55e22ca8 2311 case EM_ARC_COMPACT: return "ARCompact";
88da6820
NC		 2312 case EM_XTENSA_OLD:
2313 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 2314 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2315 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2316 case EM_NS32K: return "National Semiconductor 32000 series";
2317 case EM_TPC: return "Tenor Network TPC processor";
55e22ca8
NC		 2318 case EM_SNP1K: return "Trebia SNP 1000 processor";
2319 /* 100 */
2320 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2321 case EM_IP2K_OLD:
2322 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
11636f9e
JM		 2323 case EM_MAX: return "MAX Processor";
2324 case EM_CR: return "National Semiconductor CompactRISC";
2325 case EM_F2MC16: return "Fujitsu F2MC16";
2326 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
7bbe5bc5 2327 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 2328 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2329 case EM_SEP: return "Sharp embedded microprocessor";
2330 case EM_ARCA: return "Arca RISC microprocessor";
55e22ca8 2331 /* 110 */
11636f9e
JM		 2332 case EM_UNICORE: return "Unicore";
2333 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2334 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348 2335 case EM_ALTERA_NIOS2: return "Altera Nios II";
55e22ca8
NC		 2336 case EM_CRX: return "National Semiconductor CRX microprocessor";
2337 case EM_XGATE: return "Motorola XGATE embedded processor";
c29aca4a 2338 case EM_C166:
d70c5fc7 2339 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 2340 case EM_M16C: return "Renesas M16C series microprocessors";
2341 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2342 case EM_CE: return "Freescale Communication Engine RISC core";
55e22ca8
NC		 2343 /* 120 */
2344 case EM_M32C: return "Renesas M32c";
2345 /* 130 */
11636f9e
JM		 2346 case EM_TSK3000: return "Altium TSK3000 core";
2347 case EM_RS08: return "Freescale RS08 embedded processor";
2348 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
55e22ca8 2349 case EM_SCORE: return "SUNPLUS S+Core";
11636f9e
JM		 2350 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2351 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
55e22ca8 2352 case EM_LATTICEMICO32: return "Lattice Mico32";
11636f9e 2353 case EM_SE_C17: return "Seiko Epson C17 family";
55e22ca8 2354 /* 140 */
11636f9e
JM		 2355 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2356 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2357 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
55e22ca8
NC		 2358 case EM_TI_PRU: return "TI PRU I/O processor";
2359 /* 160 */
11636f9e
JM		 2360 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2361 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2362 case EM_R32C: return "Renesas R32C series microprocessors";
2363 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2364 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2365 case EM_8051: return "Intel 8051 and variants";
2366 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2367 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2368 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2369 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
55e22ca8 2370 /* 170 */
11636f9e
JM		 2371 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2372 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2373 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
c7927a3c 2374 case EM_RX: return "Renesas RX";
a3c62988 2375 case EM_METAG: return "Imagination Technologies Meta processor architecture";
11636f9e
JM		 2376 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2377 case EM_ECOG16: return "Cyan Technology eCOG16 family";
55e22ca8
NC		 2378 case EM_CR16:
2379 case EM_MICROBLAZE:
2380 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
11636f9e
JM		 2381 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2382 case EM_SLE9X: return "Infineon Technologies SLE9X core";
55e22ca8
NC		 2383 /* 180 */
2384 case EM_L1OM: return "Intel L1OM";
2385 case EM_K1OM: return "Intel K1OM";
2386 case EM_INTEL182: return "Intel (reserved)";
2387 case EM_AARCH64: return "AArch64";
2388 case EM_ARM184: return "ARM (reserved)";
2389 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor";
11636f9e
JM		 2390 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2391 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2392 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
55e22ca8 2393 /* 190 */
11636f9e 2394 case EM_CUDA: return "NVIDIA CUDA architecture";
55e22ca8 2395 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
6d913794
NC		 2396 case EM_CLOUDSHIELD: return "CloudShield architecture family";
2397 case EM_COREA_1ST: return "KIPO-KAIST Core-A 1st generation processor family";
2398 case EM_COREA_2ND: return "KIPO-KAIST Core-A 2nd generation processor family";
55e22ca8 2399 case EM_ARC_COMPACT2: return "ARCv2";
6d913794 2400 case EM_OPEN8: return "Open8 8-bit RISC soft processor core";
55e22ca8 2401 case EM_RL78: return "Renesas RL78";
6d913794 2402 case EM_VIDEOCORE5: return "Broadcom VideoCore V processor";
55e22ca8
NC		 2403 case EM_78K0R: return "Renesas 78K0R";
2404 /* 200 */
6d913794 2405 case EM_56800EX: return "Freescale 56800EX Digital Signal Controller (DSC)";
15f205b1
NC		 2406 case EM_BA1: return "Beyond BA1 CPU architecture";
2407 case EM_BA2: return "Beyond BA2 CPU architecture";
6d913794
NC		 2408 case EM_XCORE: return "XMOS xCORE processor family";
2409 case EM_MCHP_PIC: return "Microchip 8-bit PIC(r) family";
55e22ca8 2410 /* 210 */
6d913794
NC		 2411 case EM_KM32: return "KM211 KM32 32-bit processor";
2412 case EM_KMX32: return "KM211 KMX32 32-bit processor";
2413 case EM_KMX16: return "KM211 KMX16 16-bit processor";
2414 case EM_KMX8: return "KM211 KMX8 8-bit processor";
2415 case EM_KVARC: return "KM211 KVARC processor";
15f205b1 2416 case EM_CDP: return "Paneve CDP architecture family";
6d913794
NC		 2417 case EM_COGE: return "Cognitive Smart Memory Processor";
2418 case EM_COOL: return "Bluechip Systems CoolEngine";
2419 case EM_NORC: return "Nanoradio Optimized RISC";
2420 case EM_CSR_KALIMBA: return "CSR Kalimba architecture family";
55e22ca8 2421 /* 220 */
15f205b1 2422 case EM_Z80: return "Zilog Z80";
55e22ca8
NC		 2423 case EM_VISIUM: return "CDS VISIUMcore processor";
2424 case EM_FT32: return "FTDI Chip FT32";
2425 case EM_MOXIE: return "Moxie";
2426 case EM_AMDGPU: return "AMD GPU";
2427 case EM_RISCV: return "RISC-V";
2428 case EM_LANAI: return "Lanai 32-bit processor";
2429 case EM_BPF: return "Linux BPF";
2430
2431 /* Large numbers... */
2432 case EM_MT: return "Morpho Techologies MT processor";
2433 case EM_ALPHA: return "Alpha";
2434 case EM_WEBASSEMBLY: return "Web Assembly";
2435 case EM_DLX: return "OpenDLX";
2436 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
2437 case EM_IQ2000: return "Vitesse IQ2000";
2438 case EM_M32C_OLD:
2439 case EM_NIOS32: return "Altera Nios";
2440 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
2441 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
2442 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2443
252b5132 2444 default:
35d9dd2f 2445 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 2446 return buff;
2447 }
2448}
2449
a9522a21
AB		 2450static void
2451decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2452{
2453 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2454 other compilers don't a specific architecture type in the e_flags, and
2455 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2456 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2457 architectures.
2458
2459 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2460 but also sets a specific architecture type in the e_flags field.
2461
2462 However, when decoding the flags we don't worry if we see an
2463 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2464 ARCEM architecture type. */
2465
2466 switch (e_flags & EF_ARC_MACH_MSK)
2467 {
2468 /* We only expect these to occur for EM_ARC_COMPACT2. */
2469 case EF_ARC_CPU_ARCV2EM:
2470 strcat (buf, ", ARC EM");
2471 break;
2472 case EF_ARC_CPU_ARCV2HS:
2473 strcat (buf, ", ARC HS");
2474 break;
2475
2476 /* We only expect these to occur for EM_ARC_COMPACT. */
2477 case E_ARC_MACH_ARC600:
2478 strcat (buf, ", ARC600");
2479 break;
2480 case E_ARC_MACH_ARC601:
2481 strcat (buf, ", ARC601");
2482 break;
2483 case E_ARC_MACH_ARC700:
2484 strcat (buf, ", ARC700");
2485 break;
2486
2487 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2488 new ELF with new architecture being read by an old version of
2489 readelf, or (c) An ELF built with non-GNU compiler that does not
2490 set the architecture in the e_flags. */
2491 default:
2492 if (e_machine == EM_ARC_COMPACT)
2493 strcat (buf, ", Unknown ARCompact");
2494 else
2495 strcat (buf, ", Unknown ARC");
2496 break;
2497 }
2498
2499 switch (e_flags & EF_ARC_OSABI_MSK)
2500 {
2501 case E_ARC_OSABI_ORIG:
2502 strcat (buf, ", (ABI:legacy)");
2503 break;
2504 case E_ARC_OSABI_V2:
2505 strcat (buf, ", (ABI:v2)");
2506 break;
2507 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2508 case E_ARC_OSABI_V3:
2509 strcat (buf, ", v3 no-legacy-syscalls ABI");
2510 break;
53a346d8
CZ		 2511 case E_ARC_OSABI_V4:
2512 strcat (buf, ", v4 ABI");
2513 break;
a9522a21
AB		 2514 default:
2515 strcat (buf, ", unrecognised ARC OSABI flag");
2516 break;
2517 }
2518}
2519
f3485b74 2520static void
d3ba0551 2521decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 2522{
2523 unsigned eabi;
32ec8896 2524 bfd_boolean unknown = FALSE;
f3485b74
NC		 2525
2526 eabi = EF_ARM_EABI_VERSION (e_flags);
2527 e_flags &= ~ EF_ARM_EABIMASK;
2528
2529 /* Handle "generic" ARM flags. */
2530 if (e_flags & EF_ARM_RELEXEC)
2531 {
2532 strcat (buf, ", relocatable executable");
2533 e_flags &= ~ EF_ARM_RELEXEC;
2534 }
76da6bbe 2535
f3485b74
NC		 2536 /* Now handle EABI specific flags. */
2537 switch (eabi)
2538 {
2539 default:
2c71103e 2540 strcat (buf, ", <unrecognized EABI>");
f3485b74 2541 if (e_flags)
32ec8896 2542 unknown = TRUE;
f3485b74
NC		 2543 break;
2544
2545 case EF_ARM_EABI_VER1:
a5bcd848 2546 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2547 while (e_flags)
2548 {
2549 unsigned flag;
76da6bbe 2550
f3485b74
NC		 2551 /* Process flags one bit at a time. */
2552 flag = e_flags & - e_flags;
2553 e_flags &= ~ flag;
76da6bbe 2554
f3485b74
NC		 2555 switch (flag)
2556 {
a5bcd848 2557 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2558 strcat (buf, ", sorted symbol tables");
2559 break;
76da6bbe 2560
f3485b74 2561 default:
32ec8896 2562 unknown = TRUE;
f3485b74
NC		 2563 break;
2564 }
2565 }
2566 break;
76da6bbe 2567
a5bcd848
PB		 2568 case EF_ARM_EABI_VER2:
2569 strcat (buf, ", Version2 EABI");
2570 while (e_flags)
2571 {
2572 unsigned flag;
2573
2574 /* Process flags one bit at a time. */
2575 flag = e_flags & - e_flags;
2576 e_flags &= ~ flag;
2577
2578 switch (flag)
2579 {
2580 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2581 strcat (buf, ", sorted symbol tables");
2582 break;
2583
2584 case EF_ARM_DYNSYMSUSESEGIDX:
2585 strcat (buf, ", dynamic symbols use segment index");
2586 break;
2587
2588 case EF_ARM_MAPSYMSFIRST:
2589 strcat (buf, ", mapping symbols precede others");
2590 break;
2591
2592 default:
32ec8896 2593 unknown = TRUE;
a5bcd848
PB		 2594 break;
2595 }
2596 }
2597 break;
2598
d507cf36
PB		 2599 case EF_ARM_EABI_VER3:
2600 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2601 break;
2602
2603 case EF_ARM_EABI_VER4:
2604 strcat (buf, ", Version4 EABI");
3bfcb652
NC		 2605 while (e_flags)
2606 {
2607 unsigned flag;
2608
2609 /* Process flags one bit at a time. */
2610 flag = e_flags & - e_flags;
2611 e_flags &= ~ flag;
2612
2613 switch (flag)
2614 {
2615 case EF_ARM_BE8:
2616 strcat (buf, ", BE8");
2617 break;
2618
2619 case EF_ARM_LE8:
2620 strcat (buf, ", LE8");
2621 break;
2622
2623 default:
32ec8896 2624 unknown = TRUE;
3bfcb652
NC		 2625 break;
2626 }
3bfcb652
NC		 2627 }
2628 break;
3a4a14e9
PB		 2629
2630 case EF_ARM_EABI_VER5:
2631 strcat (buf, ", Version5 EABI");
d507cf36
PB		 2632 while (e_flags)
2633 {
2634 unsigned flag;
2635
2636 /* Process flags one bit at a time. */
2637 flag = e_flags & - e_flags;
2638 e_flags &= ~ flag;
2639
2640 switch (flag)
2641 {
2642 case EF_ARM_BE8:
2643 strcat (buf, ", BE8");
2644 break;
2645
2646 case EF_ARM_LE8:
2647 strcat (buf, ", LE8");
2648 break;
2649
3bfcb652
NC		 2650 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2651 strcat (buf, ", soft-float ABI");
2652 break;
2653
2654 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2655 strcat (buf, ", hard-float ABI");
2656 break;
2657
d507cf36 2658 default:
32ec8896 2659 unknown = TRUE;
d507cf36
PB		 2660 break;
2661 }
2662 }
2663 break;
2664
f3485b74 2665 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2666 strcat (buf, ", GNU EABI");
f3485b74
NC		 2667 while (e_flags)
2668 {
2669 unsigned flag;
76da6bbe 2670
f3485b74
NC		 2671 /* Process flags one bit at a time. */
2672 flag = e_flags & - e_flags;
2673 e_flags &= ~ flag;
76da6bbe 2674
f3485b74
NC		 2675 switch (flag)
2676 {
a5bcd848 2677 case EF_ARM_INTERWORK:
f3485b74
NC		 2678 strcat (buf, ", interworking enabled");
2679 break;
76da6bbe 2680
a5bcd848 2681 case EF_ARM_APCS_26:
f3485b74
NC		 2682 strcat (buf, ", uses APCS/26");
2683 break;
76da6bbe 2684
a5bcd848 2685 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2686 strcat (buf, ", uses APCS/float");
2687 break;
76da6bbe 2688
a5bcd848 2689 case EF_ARM_PIC:
f3485b74
NC		 2690 strcat (buf, ", position independent");
2691 break;
76da6bbe 2692
a5bcd848 2693 case EF_ARM_ALIGN8:
f3485b74
NC		 2694 strcat (buf, ", 8 bit structure alignment");
2695 break;
76da6bbe 2696
a5bcd848 2697 case EF_ARM_NEW_ABI:
f3485b74
NC		 2698 strcat (buf, ", uses new ABI");
2699 break;
76da6bbe 2700
a5bcd848 2701 case EF_ARM_OLD_ABI:
f3485b74
NC		 2702 strcat (buf, ", uses old ABI");
2703 break;
76da6bbe 2704
a5bcd848 2705 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2706 strcat (buf, ", software FP");
2707 break;
76da6bbe 2708
90e01f86
ILT		 2709 case EF_ARM_VFP_FLOAT:
2710 strcat (buf, ", VFP");
2711 break;
2712
fde78edd
NC		 2713 case EF_ARM_MAVERICK_FLOAT:
2714 strcat (buf, ", Maverick FP");
2715 break;
2716
f3485b74 2717 default:
32ec8896 2718 unknown = TRUE;
f3485b74
NC		 2719 break;
2720 }
2721 }
2722 }
f3485b74
NC		 2723
2724 if (unknown)
2b692964 2725 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2726}
2727
343433df
AB		 2728static void
2729decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2730{
2731 --size; /* Leave space for null terminator. */
2732
2733 switch (e_flags & EF_AVR_MACH)
2734 {
2735 case E_AVR_MACH_AVR1:
2736 strncat (buf, ", avr:1", size);
2737 break;
2738 case E_AVR_MACH_AVR2:
2739 strncat (buf, ", avr:2", size);
2740 break;
2741 case E_AVR_MACH_AVR25:
2742 strncat (buf, ", avr:25", size);
2743 break;
2744 case E_AVR_MACH_AVR3:
2745 strncat (buf, ", avr:3", size);
2746 break;
2747 case E_AVR_MACH_AVR31:
2748 strncat (buf, ", avr:31", size);
2749 break;
2750 case E_AVR_MACH_AVR35:
2751 strncat (buf, ", avr:35", size);
2752 break;
2753 case E_AVR_MACH_AVR4:
2754 strncat (buf, ", avr:4", size);
2755 break;
2756 case E_AVR_MACH_AVR5:
2757 strncat (buf, ", avr:5", size);
2758 break;
2759 case E_AVR_MACH_AVR51:
2760 strncat (buf, ", avr:51", size);
2761 break;
2762 case E_AVR_MACH_AVR6:
2763 strncat (buf, ", avr:6", size);
2764 break;
2765 case E_AVR_MACH_AVRTINY:
2766 strncat (buf, ", avr:100", size);
2767 break;
2768 case E_AVR_MACH_XMEGA1:
2769 strncat (buf, ", avr:101", size);
2770 break;
2771 case E_AVR_MACH_XMEGA2:
2772 strncat (buf, ", avr:102", size);
2773 break;
2774 case E_AVR_MACH_XMEGA3:
2775 strncat (buf, ", avr:103", size);
2776 break;
2777 case E_AVR_MACH_XMEGA4:
2778 strncat (buf, ", avr:104", size);
2779 break;
2780 case E_AVR_MACH_XMEGA5:
2781 strncat (buf, ", avr:105", size);
2782 break;
2783 case E_AVR_MACH_XMEGA6:
2784 strncat (buf, ", avr:106", size);
2785 break;
2786 case E_AVR_MACH_XMEGA7:
2787 strncat (buf, ", avr:107", size);
2788 break;
2789 default:
2790 strncat (buf, ", avr:<unknown>", size);
2791 break;
2792 }
2793
2794 size -= strlen (buf);
2795 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2796 strncat (buf, ", link-relax", size);
2797}
2798
35c08157
KLC		 2799static void
2800decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2801{
2802 unsigned abi;
2803 unsigned arch;
2804 unsigned config;
2805 unsigned version;
32ec8896
NC		 2806 bfd_boolean has_fpu = FALSE;
2807 unsigned int r = 0;
35c08157
KLC		 2808
2809 static const char *ABI_STRINGS[] =
2810 {
2811 "ABI v0", /* use r5 as return register; only used in N1213HC */
2812 "ABI v1", /* use r0 as return register */
2813 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2814 "ABI v2fp", /* for FPU */
40c7a7cb
KLC		 2815 "AABI",
2816 "ABI2 FP+"
35c08157
KLC		 2817 };
2818 static const char *VER_STRINGS[] =
2819 {
2820 "Andes ELF V1.3 or older",
2821 "Andes ELF V1.3.1",
2822 "Andes ELF V1.4"
2823 };
2824 static const char *ARCH_STRINGS[] =
2825 {
2826 "",
2827 "Andes Star v1.0",
2828 "Andes Star v2.0",
2829 "Andes Star v3.0",
2830 "Andes Star v3.0m"
2831 };
2832
2833 abi = EF_NDS_ABI & e_flags;
2834 arch = EF_NDS_ARCH & e_flags;
2835 config = EF_NDS_INST & e_flags;
2836 version = EF_NDS32_ELF_VERSION & e_flags;
2837
2838 memset (buf, 0, size);
2839
2840 switch (abi)
2841 {
2842 case E_NDS_ABI_V0:
2843 case E_NDS_ABI_V1:
2844 case E_NDS_ABI_V2:
2845 case E_NDS_ABI_V2FP:
2846 case E_NDS_ABI_AABI:
40c7a7cb 2847 case E_NDS_ABI_V2FP_PLUS:
35c08157
KLC		 2848 /* In case there are holes in the array. */
2849 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2850 break;
2851
2852 default:
2853 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2854 break;
2855 }
2856
2857 switch (version)
2858 {
2859 case E_NDS32_ELF_VER_1_2:
2860 case E_NDS32_ELF_VER_1_3:
2861 case E_NDS32_ELF_VER_1_4:
2862 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2863 break;
2864
2865 default:
2866 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2867 break;
2868 }
2869
2870 if (E_NDS_ABI_V0 == abi)
2871 {
2872 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2873 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2874 if (arch == E_NDS_ARCH_STAR_V1_0)
2875 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2876 return;
2877 }
2878
2879 switch (arch)
2880 {
2881 case E_NDS_ARCH_STAR_V1_0:
2882 case E_NDS_ARCH_STAR_V2_0:
2883 case E_NDS_ARCH_STAR_V3_0:
2884 case E_NDS_ARCH_STAR_V3_M:
2885 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2886 break;
2887
2888 default:
2889 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2890 /* ARCH version determines how the e_flags are interpreted.
2891 If it is unknown, we cannot proceed. */
2892 return;
2893 }
2894
2895 /* Newer ABI; Now handle architecture specific flags. */
2896 if (arch == E_NDS_ARCH_STAR_V1_0)
2897 {
2898 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2899 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2900
2901 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2902 r += snprintf (buf + r, size -r, ", MAC");
2903
2904 if (config & E_NDS32_HAS_DIV_INST)
2905 r += snprintf (buf + r, size -r, ", DIV");
2906
2907 if (config & E_NDS32_HAS_16BIT_INST)
2908 r += snprintf (buf + r, size -r, ", 16b");
2909 }
2910 else
2911 {
2912 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2913 {
2914 if (version <= E_NDS32_ELF_VER_1_3)
2915 r += snprintf (buf + r, size -r, ", [B8]");
2916 else
2917 r += snprintf (buf + r, size -r, ", EX9");
2918 }
2919
2920 if (config & E_NDS32_HAS_MAC_DX_INST)
2921 r += snprintf (buf + r, size -r, ", MAC_DX");
2922
2923 if (config & E_NDS32_HAS_DIV_DX_INST)
2924 r += snprintf (buf + r, size -r, ", DIV_DX");
2925
2926 if (config & E_NDS32_HAS_16BIT_INST)
2927 {
2928 if (version <= E_NDS32_ELF_VER_1_3)
2929 r += snprintf (buf + r, size -r, ", 16b");
2930 else
2931 r += snprintf (buf + r, size -r, ", IFC");
2932 }
2933 }
2934
2935 if (config & E_NDS32_HAS_EXT_INST)
2936 r += snprintf (buf + r, size -r, ", PERF1");
2937
2938 if (config & E_NDS32_HAS_EXT2_INST)
2939 r += snprintf (buf + r, size -r, ", PERF2");
2940
2941 if (config & E_NDS32_HAS_FPU_INST)
2942 {
32ec8896 2943 has_fpu = TRUE;
35c08157
KLC		 2944 r += snprintf (buf + r, size -r, ", FPU_SP");
2945 }
2946
2947 if (config & E_NDS32_HAS_FPU_DP_INST)
2948 {
32ec8896 2949 has_fpu = TRUE;
35c08157
KLC		 2950 r += snprintf (buf + r, size -r, ", FPU_DP");
2951 }
2952
2953 if (config & E_NDS32_HAS_FPU_MAC_INST)
2954 {
32ec8896 2955 has_fpu = TRUE;
35c08157
KLC		 2956 r += snprintf (buf + r, size -r, ", FPU_MAC");
2957 }
2958
2959 if (has_fpu)
2960 {
2961 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2962 {
2963 case E_NDS32_FPU_REG_8SP_4DP:
2964 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2965 break;
2966 case E_NDS32_FPU_REG_16SP_8DP:
2967 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2968 break;
2969 case E_NDS32_FPU_REG_32SP_16DP:
2970 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2971 break;
2972 case E_NDS32_FPU_REG_32SP_32DP:
2973 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2974 break;
2975 }
2976 }
2977
2978 if (config & E_NDS32_HAS_AUDIO_INST)
2979 r += snprintf (buf + r, size -r, ", AUDIO");
2980
2981 if (config & E_NDS32_HAS_STRING_INST)
2982 r += snprintf (buf + r, size -r, ", STR");
2983
2984 if (config & E_NDS32_HAS_REDUCED_REGS)
2985 r += snprintf (buf + r, size -r, ", 16REG");
2986
2987 if (config & E_NDS32_HAS_VIDEO_INST)
2988 {
2989 if (version <= E_NDS32_ELF_VER_1_3)
2990 r += snprintf (buf + r, size -r, ", VIDEO");
2991 else
2992 r += snprintf (buf + r, size -r, ", SATURATION");
2993 }
2994
2995 if (config & E_NDS32_HAS_ENCRIPT_INST)
2996 r += snprintf (buf + r, size -r, ", ENCRP");
2997
2998 if (config & E_NDS32_HAS_L2C_INST)
2999 r += snprintf (buf + r, size -r, ", L2C");
3000}
3001
252b5132 3002static char *
d3ba0551 3003get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 3004{
b34976b6 3005 static char buf[1024];
252b5132
RH		 3006
3007 buf[0] = '\0';
76da6bbe 3008
252b5132
RH		 3009 if (e_flags)
3010 {
3011 switch (e_machine)
3012 {
3013 default:
3014 break;
3015
886a2506 3016 case EM_ARC_COMPACT2:
886a2506 3017 case EM_ARC_COMPACT:
a9522a21
AB		 3018 decode_ARC_machine_flags (e_flags, e_machine, buf);
3019 break;
886a2506 3020
f3485b74
NC		 3021 case EM_ARM:
3022 decode_ARM_machine_flags (e_flags, buf);
3023 break;
76da6bbe 3024
343433df
AB		 3025 case EM_AVR:
3026 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
3027 break;
3028
781303ce
MF		 3029 case EM_BLACKFIN:
3030 if (e_flags & EF_BFIN_PIC)
3031 strcat (buf, ", PIC");
3032
3033 if (e_flags & EF_BFIN_FDPIC)
3034 strcat (buf, ", FDPIC");
3035
3036 if (e_flags & EF_BFIN_CODE_IN_L1)
3037 strcat (buf, ", code in L1");
3038
3039 if (e_flags & EF_BFIN_DATA_IN_L1)
3040 strcat (buf, ", data in L1");
3041
3042 break;
3043
ec2dfb42
AO		 3044 case EM_CYGNUS_FRV:
3045 switch (e_flags & EF_FRV_CPU_MASK)
3046 {
3047 case EF_FRV_CPU_GENERIC:
3048 break;
3049
3050 default:
3051 strcat (buf, ", fr???");
3052 break;
57346661 3053
ec2dfb42
AO		 3054 case EF_FRV_CPU_FR300:
3055 strcat (buf, ", fr300");
3056 break;
3057
3058 case EF_FRV_CPU_FR400:
3059 strcat (buf, ", fr400");
3060 break;
3061 case EF_FRV_CPU_FR405:
3062 strcat (buf, ", fr405");
3063 break;
3064
3065 case EF_FRV_CPU_FR450:
3066 strcat (buf, ", fr450");
3067 break;
3068
3069 case EF_FRV_CPU_FR500:
3070 strcat (buf, ", fr500");
3071 break;
3072 case EF_FRV_CPU_FR550:
3073 strcat (buf, ", fr550");
3074 break;
3075
3076 case EF_FRV_CPU_SIMPLE:
3077 strcat (buf, ", simple");
3078 break;
3079 case EF_FRV_CPU_TOMCAT:
3080 strcat (buf, ", tomcat");
3081 break;
3082 }
1c877e87 3083 break;
ec2dfb42 3084
53c7db4b 3085 case EM_68K:
425c6cb0 3086 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 3087 strcat (buf, ", m68000");
425c6cb0 3088 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 3089 strcat (buf, ", cpu32");
3090 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3091 strcat (buf, ", fido_a");
425c6cb0 3092 else
266abb8f 3093 {
2cf0635d
NC		 3094 char const * isa = _("unknown");
3095 char const * mac = _("unknown mac");
3096 char const * additional = NULL;
0112cd26 3097
c694fd50 3098 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 3099 {
c694fd50 3100 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 3101 isa = "A";
3102 additional = ", nodiv";
3103 break;
c694fd50 3104 case EF_M68K_CF_ISA_A:
266abb8f
NS		 3105 isa = "A";
3106 break;
c694fd50 3107 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 3108 isa = "A+";
3109 break;
c694fd50 3110 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 3111 isa = "B";
3112 additional = ", nousp";
3113 break;
c694fd50 3114 case EF_M68K_CF_ISA_B:
266abb8f
NS		 3115 isa = "B";
3116 break;
f608cd77
NS		 3117 case EF_M68K_CF_ISA_C:
3118 isa = "C";
3119 break;
3120 case EF_M68K_CF_ISA_C_NODIV:
3121 isa = "C";
3122 additional = ", nodiv";
3123 break;
266abb8f
NS		 3124 }
3125 strcat (buf, ", cf, isa ");
3126 strcat (buf, isa);
0b2e31dc
NS		 3127 if (additional)
3128 strcat (buf, additional);
c694fd50 3129 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 3130 strcat (buf, ", float");
c694fd50 3131 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 3132 {
3133 case 0:
3134 mac = NULL;
3135 break;
c694fd50 3136 case EF_M68K_CF_MAC:
266abb8f
NS		 3137 mac = "mac";
3138 break;
c694fd50 3139 case EF_M68K_CF_EMAC:
266abb8f
NS		 3140 mac = "emac";
3141 break;
f608cd77
NS		 3142 case EF_M68K_CF_EMAC_B:
3143 mac = "emac_b";
3144 break;
266abb8f
NS		 3145 }
3146 if (mac)
3147 {
3148 strcat (buf, ", ");
3149 strcat (buf, mac);
3150 }
266abb8f 3151 }
53c7db4b 3152 break;
33c63f9d 3153
153a2776
NC		 3154 case EM_CYGNUS_MEP:
3155 switch (e_flags & EF_MEP_CPU_MASK)
3156 {
3157 case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3158 case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3159 case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3160 case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3161 case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3162 case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3163 default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3164 }
3165
3166 switch (e_flags & EF_MEP_COP_MASK)
3167 {
3168 case EF_MEP_COP_NONE: break;
3169 case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3170 case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3171 case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3172 case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3173 default: strcat (buf, _("<unknown MeP copro type>")); break;
3174 }
3175
3176 if (e_flags & EF_MEP_LIBRARY)
3177 strcat (buf, ", Built for Library");
3178
3179 if (e_flags & EF_MEP_INDEX_MASK)
3180 sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3181 e_flags & EF_MEP_INDEX_MASK);
3182
3183 if (e_flags & ~ EF_MEP_ALL_FLAGS)
3184 sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3185 e_flags & ~ EF_MEP_ALL_FLAGS);
3186 break;
3187
252b5132
RH		 3188 case EM_PPC:
3189 if (e_flags & EF_PPC_EMB)
3190 strcat (buf, ", emb");
3191
3192 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 3193 strcat (buf, _(", relocatable"));
252b5132
RH		 3194
3195 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 3196 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 3197 break;
3198
ee67d69a
AM		 3199 case EM_PPC64:
3200 if (e_flags & EF_PPC64_ABI)
3201 {
3202 char abi[] = ", abiv0";
3203
3204 abi[6] += e_flags & EF_PPC64_ABI;
3205 strcat (buf, abi);
3206 }
3207 break;
3208
708e2187
NC		 3209 case EM_V800:
3210 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3211 strcat (buf, ", RH850 ABI");
0b4362b0 3212
708e2187
NC		 3213 if (e_flags & EF_V800_850E3)
3214 strcat (buf, ", V3 architecture");
3215
3216 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3217 strcat (buf, ", FPU not used");
3218
3219 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3220 strcat (buf, ", regmode: COMMON");
3221
3222 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3223 strcat (buf, ", r4 not used");
3224
3225 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3226 strcat (buf, ", r30 not used");
3227
3228 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3229 strcat (buf, ", r5 not used");
3230
3231 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3232 strcat (buf, ", r2 not used");
3233
3234 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3235 {
3236 switch (e_flags & - e_flags)
3237 {
3238 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3239 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
708e2187
NC		 3240 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3241 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
708e2187
NC		 3242 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3243 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3244 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3245 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3246 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3247 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3248 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3249 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3250 default: break;
3251 }
3252 }
3253 break;
3254
2b0337b0 3255 case EM_V850:
252b5132
RH		 3256 case EM_CYGNUS_V850:
3257 switch (e_flags & EF_V850_ARCH)
3258 {
78c8d46c
NC		 3259 case E_V850E3V5_ARCH:
3260 strcat (buf, ", v850e3v5");
3261 break;
1cd986c5
NC		 3262 case E_V850E2V3_ARCH:
3263 strcat (buf, ", v850e2v3");
3264 break;
3265 case E_V850E2_ARCH:
3266 strcat (buf, ", v850e2");
3267 break;
3268 case E_V850E1_ARCH:
3269 strcat (buf, ", v850e1");
8ad30312 3270 break;
252b5132
RH		 3271 case E_V850E_ARCH:
3272 strcat (buf, ", v850e");
3273 break;
252b5132
RH		 3274 case E_V850_ARCH:
3275 strcat (buf, ", v850");
3276 break;
3277 default:
2b692964 3278 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 3279 break;
3280 }
3281 break;
3282
2b0337b0 3283 case EM_M32R:
252b5132
RH		 3284 case EM_CYGNUS_M32R:
3285 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3286 strcat (buf, ", m32r");
252b5132
RH		 3287 break;
3288
3289 case EM_MIPS:
4fe85591 3290 case EM_MIPS_RS3_LE:
252b5132
RH		 3291 if (e_flags & EF_MIPS_NOREORDER)
3292 strcat (buf, ", noreorder");
3293
3294 if (e_flags & EF_MIPS_PIC)
3295 strcat (buf, ", pic");
3296
3297 if (e_flags & EF_MIPS_CPIC)
3298 strcat (buf, ", cpic");
3299
d1bdd336
TS		 3300 if (e_flags & EF_MIPS_UCODE)
3301 strcat (buf, ", ugen_reserved");
3302
252b5132
RH		 3303 if (e_flags & EF_MIPS_ABI2)
3304 strcat (buf, ", abi2");
3305
43521d43
TS		 3306 if (e_flags & EF_MIPS_OPTIONS_FIRST)
3307 strcat (buf, ", odk first");
3308
a5d22d2a
TS		 3309 if (e_flags & EF_MIPS_32BITMODE)
3310 strcat (buf, ", 32bitmode");
3311
ba92f887
MR		 3312 if (e_flags & EF_MIPS_NAN2008)
3313 strcat (buf, ", nan2008");
3314
fef1b0b3
SE		 3315 if (e_flags & EF_MIPS_FP64)
3316 strcat (buf, ", fp64");
3317
156c2f8b
NC		 3318 switch ((e_flags & EF_MIPS_MACH))
3319 {
3320 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3321 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3322 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 3323 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 3324 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3325 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3326 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3327 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 3328 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 3329 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 3330 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3331 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 3332 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 3333 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 3334 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
d32e5c54 3335 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
52b6b6b9 3336 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
38bf472a 3337 case E_MIPS_MACH_IAMR2: strcat (buf, ", interaptiv-mr2"); break;
43521d43
TS		 3338 case 0:
3339 /* We simply ignore the field in this case to avoid confusion:
3340 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3341 extension. */
3342 break;
2b692964 3343 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 3344 }
43521d43
TS		 3345
3346 switch ((e_flags & EF_MIPS_ABI))
3347 {
3348 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3349 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3350 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3351 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3352 case 0:
3353 /* We simply ignore the field in this case to avoid confusion:
3354 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3355 This means it is likely to be an o32 file, but not for
3356 sure. */
3357 break;
2b692964 3358 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 3359 }
3360
3361 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3362 strcat (buf, ", mdmx");
3363
3364 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3365 strcat (buf, ", mips16");
3366
df58fc94
RS		 3367 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3368 strcat (buf, ", micromips");
3369
43521d43
TS		 3370 switch ((e_flags & EF_MIPS_ARCH))
3371 {
3372 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3373 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3374 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3375 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3376 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3377 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 3378 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
7361da2c 3379 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
43521d43 3380 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 3381 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
7361da2c 3382 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
2b692964 3383 default: strcat (buf, _(", unknown ISA")); break;
43521d43 3384 }
252b5132 3385 break;
351b4b40 3386
35c08157
KLC		 3387 case EM_NDS32:
3388 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3389 break;
3390
e23eba97
NC		 3391 case EM_RISCV:
3392 if (e_flags & EF_RISCV_RVC)
3393 strcat (buf, ", RVC");
2922d21d
AW		 3394
3395 switch (e_flags & EF_RISCV_FLOAT_ABI)
3396 {
3397 case EF_RISCV_FLOAT_ABI_SOFT:
3398 strcat (buf, ", soft-float ABI");
3399 break;
3400
3401 case EF_RISCV_FLOAT_ABI_SINGLE:
3402 strcat (buf, ", single-float ABI");
3403 break;
3404
3405 case EF_RISCV_FLOAT_ABI_DOUBLE:
3406 strcat (buf, ", double-float ABI");
3407 break;
3408
3409 case EF_RISCV_FLOAT_ABI_QUAD:
3410 strcat (buf, ", quad-float ABI");
3411 break;
3412 }
e23eba97
NC		 3413 break;
3414
ccde1100
AO		 3415 case EM_SH:
3416 switch ((e_flags & EF_SH_MACH_MASK))
3417 {
3418 case EF_SH1: strcat (buf, ", sh1"); break;
3419 case EF_SH2: strcat (buf, ", sh2"); break;
3420 case EF_SH3: strcat (buf, ", sh3"); break;
3421 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3422 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3423 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3424 case EF_SH3E: strcat (buf, ", sh3e"); break;
3425 case EF_SH4: strcat (buf, ", sh4"); break;
3426 case EF_SH5: strcat (buf, ", sh5"); break;
3427 case EF_SH2E: strcat (buf, ", sh2e"); break;
3428 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 3429 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 3430 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3431 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 3432 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 3433 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3434 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3435 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3436 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3437 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3438 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 3439 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 3440 }
3441
cec6a5b8
MR		 3442 if (e_flags & EF_SH_PIC)
3443 strcat (buf, ", pic");
3444
3445 if (e_flags & EF_SH_FDPIC)
3446 strcat (buf, ", fdpic");
ccde1100 3447 break;
948f632f 3448
73589c9d
CS		 3449 case EM_OR1K:
3450 if (e_flags & EF_OR1K_NODELAY)
3451 strcat (buf, ", no delay");
3452 break;
57346661 3453
351b4b40
RH		 3454 case EM_SPARCV9:
3455 if (e_flags & EF_SPARC_32PLUS)
3456 strcat (buf, ", v8+");
3457
3458 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 3459 strcat (buf, ", ultrasparcI");
3460
3461 if (e_flags & EF_SPARC_SUN_US3)
3462 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 3463
3464 if (e_flags & EF_SPARC_HAL_R1)
3465 strcat (buf, ", halr1");
3466
3467 if (e_flags & EF_SPARC_LEDATA)
3468 strcat (buf, ", ledata");
3469
3470 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3471 strcat (buf, ", tso");
3472
3473 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3474 strcat (buf, ", pso");
3475
3476 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3477 strcat (buf, ", rmo");
3478 break;
7d466069 3479
103f02d3
UD		 3480 case EM_PARISC:
3481 switch (e_flags & EF_PARISC_ARCH)
3482 {
3483 case EFA_PARISC_1_0:
3484 strcpy (buf, ", PA-RISC 1.0");
3485 break;
3486 case EFA_PARISC_1_1:
3487 strcpy (buf, ", PA-RISC 1.1");
3488 break;
3489 case EFA_PARISC_2_0:
3490 strcpy (buf, ", PA-RISC 2.0");
3491 break;
3492 default:
3493 break;
3494 }
3495 if (e_flags & EF_PARISC_TRAPNIL)
3496 strcat (buf, ", trapnil");
3497 if (e_flags & EF_PARISC_EXT)
3498 strcat (buf, ", ext");
3499 if (e_flags & EF_PARISC_LSB)
3500 strcat (buf, ", lsb");
3501 if (e_flags & EF_PARISC_WIDE)
3502 strcat (buf, ", wide");
3503 if (e_flags & EF_PARISC_NO_KABP)
3504 strcat (buf, ", no kabp");
3505 if (e_flags & EF_PARISC_LAZYSWAP)
3506 strcat (buf, ", lazyswap");
30800947 3507 break;
76da6bbe 3508
7d466069 3509 case EM_PJ:
2b0337b0 3510 case EM_PJ_OLD:
7d466069
ILT		 3511 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3512 strcat (buf, ", new calling convention");
3513
3514 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3515 strcat (buf, ", gnu calling convention");
3516 break;
4d6ed7c8
NC		 3517
3518 case EM_IA_64:
3519 if ((e_flags & EF_IA_64_ABI64))
3520 strcat (buf, ", 64-bit");
3521 else
3522 strcat (buf, ", 32-bit");
3523 if ((e_flags & EF_IA_64_REDUCEDFP))
3524 strcat (buf, ", reduced fp model");
3525 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3526 strcat (buf, ", no function descriptors, constant gp");
3527 else if ((e_flags & EF_IA_64_CONS_GP))
3528 strcat (buf, ", constant gp");
3529 if ((e_flags & EF_IA_64_ABSOLUTE))
3530 strcat (buf, ", absolute");
28f997cf
TG		 3531 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3532 {
3533 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3534 strcat (buf, ", vms_linkages");
3535 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3536 {
3537 case EF_IA_64_VMS_COMCOD_SUCCESS:
3538 break;
3539 case EF_IA_64_VMS_COMCOD_WARNING:
3540 strcat (buf, ", warning");
3541 break;
3542 case EF_IA_64_VMS_COMCOD_ERROR:
3543 strcat (buf, ", error");
3544 break;
3545 case EF_IA_64_VMS_COMCOD_ABORT:
3546 strcat (buf, ", abort");
3547 break;
3548 default:
bee0ee85
NC		 3549 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3550 e_flags & EF_IA_64_VMS_COMCOD);
3551 strcat (buf, ", <unknown>");
28f997cf
TG		 3552 }
3553 }
4d6ed7c8 3554 break;
179d3252
JT		 3555
3556 case EM_VAX:
3557 if ((e_flags & EF_VAX_NONPIC))
3558 strcat (buf, ", non-PIC");
3559 if ((e_flags & EF_VAX_DFLOAT))
3560 strcat (buf, ", D-Float");
3561 if ((e_flags & EF_VAX_GFLOAT))
3562 strcat (buf, ", G-Float");
3563 break;
c7927a3c 3564
619ed720
EB		 3565 case EM_VISIUM:
3566 if (e_flags & EF_VISIUM_ARCH_MCM)
3567 strcat (buf, ", mcm");
3568 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3569 strcat (buf, ", mcm24");
3570 if (e_flags & EF_VISIUM_ARCH_GR6)
3571 strcat (buf, ", gr6");
3572 break;
3573
4046d87a 3574 case EM_RL78:
1740ba0c
NC		 3575 switch (e_flags & E_FLAG_RL78_CPU_MASK)
3576 {
3577 case E_FLAG_RL78_ANY_CPU: break;
3578 case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3579 case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3580 case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3581 }
856ea05c
KP		 3582 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3583 strcat (buf, ", 64-bit doubles");
4046d87a 3584 break;
0b4362b0 3585
c7927a3c
NC		 3586 case EM_RX:
3587 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3588 strcat (buf, ", 64-bit doubles");
3589 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 3590 strcat (buf, ", dsp");
d4cb0ea0 3591 if (e_flags & E_FLAG_RX_PID)
0b4362b0 3592 strcat (buf, ", pid");
708e2187
NC		 3593 if (e_flags & E_FLAG_RX_ABI)
3594 strcat (buf, ", RX ABI");
3525236c
NC		 3595 if (e_flags & E_FLAG_RX_SINSNS_SET)
3596 strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3597 ? ", uses String instructions" : ", bans String instructions");
a117b0a5
YS		 3598 if (e_flags & E_FLAG_RX_V2)
3599 strcat (buf, ", V2");
d4cb0ea0 3600 break;
55786da2
AK		 3601
3602 case EM_S390:
3603 if (e_flags & EF_S390_HIGH_GPRS)
3604 strcat (buf, ", highgprs");
d4cb0ea0 3605 break;
40b36596
JM		 3606
3607 case EM_TI_C6000:
3608 if ((e_flags & EF_C6000_REL))
3609 strcat (buf, ", relocatable module");
d4cb0ea0 3610 break;
13761a11
NC		 3611
3612 case EM_MSP430:
3613 strcat (buf, _(": architecture variant: "));
3614 switch (e_flags & EF_MSP430_MACH)
3615 {
3616 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3617 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3618 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3619 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3620 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3621 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3622 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3623 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3624 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3625 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3626 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3627 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3628 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3629 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3630 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3631 default:
3632 strcat (buf, _(": unknown")); break;
3633 }
3634
3635 if (e_flags & ~ EF_MSP430_MACH)
3636 strcat (buf, _(": unknown extra flag bits also present"));
252b5132
RH		 3637 }
3638 }
3639
3640 return buf;
3641}
3642
252b5132 3643static const char *
d3ba0551
AM		 3644get_osabi_name (unsigned int osabi)
3645{
3646 static char buff[32];
3647
3648 switch (osabi)
3649 {
3650 case ELFOSABI_NONE: return "UNIX - System V";
3651 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3652 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 3653 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 3654 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3655 case ELFOSABI_AIX: return "UNIX - AIX";
3656 case ELFOSABI_IRIX: return "UNIX - IRIX";
3657 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3658 case ELFOSABI_TRU64: return "UNIX - TRU64";
3659 case ELFOSABI_MODESTO: return "Novell - Modesto";
3660 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3661 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3662 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 3663 case ELFOSABI_AROS: return "AROS";
11636f9e 3664 case ELFOSABI_FENIXOS: return "FenixOS";
6d913794
NC		 3665 case ELFOSABI_CLOUDABI: return "Nuxi CloudABI";
3666 case ELFOSABI_OPENVOS: return "Stratus Technologies OpenVOS";
d3ba0551 3667 default:
40b36596
JM		 3668 if (osabi >= 64)
3669 switch (elf_header.e_machine)
3670 {
3671 case EM_ARM:
3672 switch (osabi)
3673 {
3674 case ELFOSABI_ARM: return "ARM";
3675 default:
3676 break;
3677 }
3678 break;
3679
3680 case EM_MSP430:
3681 case EM_MSP430_OLD:
619ed720 3682 case EM_VISIUM:
40b36596
JM		 3683 switch (osabi)
3684 {
3685 case ELFOSABI_STANDALONE: return _("Standalone App");
3686 default:
3687 break;
3688 }
3689 break;
3690
3691 case EM_TI_C6000:
3692 switch (osabi)
3693 {
3694 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3695 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3696 default:
3697 break;
3698 }
3699 break;
3700
3701 default:
3702 break;
3703 }
e9e44622 3704 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 3705 return buff;
3706 }
3707}
3708
a06ea964
NC		 3709static const char *
3710get_aarch64_segment_type (unsigned long type)
3711{
3712 switch (type)
3713 {
32ec8896
NC		 3714 case PT_AARCH64_ARCHEXT: return "AARCH64_ARCHEXT";
3715 default: return NULL;
a06ea964 3716 }
a06ea964
NC		 3717}
3718
b294bdf8
MM		 3719static const char *
3720get_arm_segment_type (unsigned long type)
3721{
3722 switch (type)
3723 {
32ec8896
NC		 3724 case PT_ARM_EXIDX: return "EXIDX";
3725 default: return NULL;
b294bdf8 3726 }
b294bdf8
MM		 3727}
3728
b4cbbe8f
AK		 3729static const char *
3730get_s390_segment_type (unsigned long type)
3731{
3732 switch (type)
3733 {
3734 case PT_S390_PGSTE: return "S390_PGSTE";
3735 default: return NULL;
3736 }
3737}
3738
d3ba0551
AM		 3739static const char *
3740get_mips_segment_type (unsigned long type)
252b5132
RH		 3741{
3742 switch (type)
3743 {
32ec8896
NC		 3744 case PT_MIPS_REGINFO: return "REGINFO";
3745 case PT_MIPS_RTPROC: return "RTPROC";
3746 case PT_MIPS_OPTIONS: return "OPTIONS";
3747 case PT_MIPS_ABIFLAGS: return "ABIFLAGS";
3748 default: return NULL;
252b5132 3749 }
252b5132
RH		 3750}
3751
103f02d3 3752static const char *
d3ba0551 3753get_parisc_segment_type (unsigned long type)
103f02d3
UD		 3754{
3755 switch (type)
3756 {
3757 case PT_HP_TLS: return "HP_TLS";
3758 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3759 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3760 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3761 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3762 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3763 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3764 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3765 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3766 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3767 case PT_HP_PARALLEL: return "HP_PARALLEL";
3768 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 3769 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3770 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3771 case PT_HP_STACK: return "HP_STACK";
3772 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 3773 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3774 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 3775 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
32ec8896 3776 default: return NULL;
103f02d3 3777 }
103f02d3
UD		 3778}
3779
4d6ed7c8 3780static const char *
d3ba0551 3781get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 3782{
3783 switch (type)
3784 {
3785 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3786 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 3787 case PT_HP_TLS: return "HP_TLS";
3788 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3789 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3790 case PT_IA_64_HP_STACK: return "HP_STACK";
32ec8896 3791 default: return NULL;
4d6ed7c8 3792 }
4d6ed7c8
NC		 3793}
3794
40b36596
JM		 3795static const char *
3796get_tic6x_segment_type (unsigned long type)
3797{
3798 switch (type)
3799 {
32ec8896
NC		 3800 case PT_C6000_PHATTR: return "C6000_PHATTR";
3801 default: return NULL;
40b36596 3802 }
40b36596
JM		 3803}
3804
5522f910
NC		 3805static const char *
3806get_solaris_segment_type (unsigned long type)
3807{
3808 switch (type)
3809 {
3810 case 0x6464e550: return "PT_SUNW_UNWIND";
3811 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3812 case 0x6ffffff7: return "PT_LOSUNW";
3813 case 0x6ffffffa: return "PT_SUNWBSS";
3814 case 0x6ffffffb: return "PT_SUNWSTACK";
3815 case 0x6ffffffc: return "PT_SUNWDTRACE";
3816 case 0x6ffffffd: return "PT_SUNWCAP";
3817 case 0x6fffffff: return "PT_HISUNW";
32ec8896 3818 default: return NULL;
5522f910
NC		 3819 }
3820}
3821
252b5132 3822static const char *
d3ba0551 3823get_segment_type (unsigned long p_type)
252b5132 3824{
b34976b6 3825 static char buff[32];
252b5132
RH		 3826
3827 switch (p_type)
3828 {
b34976b6
AM		 3829 case PT_NULL: return "NULL";
3830 case PT_LOAD: return "LOAD";
252b5132 3831 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 3832 case PT_INTERP: return "INTERP";
3833 case PT_NOTE: return "NOTE";
3834 case PT_SHLIB: return "SHLIB";
3835 case PT_PHDR: return "PHDR";
13ae64f3 3836 case PT_TLS: return "TLS";
32ec8896 3837 case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
2b05f1b7 3838 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 3839 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 3840
252b5132 3841 default:
a91e1603
L		 3842 if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
3843 {
3844 sprintf (buff, "GNU_MBIND+%#lx",
3845 p_type - PT_GNU_MBIND_LO);
3846 }
3847 else if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
252b5132 3848 {
2cf0635d 3849 const char * result;
103f02d3 3850
252b5132
RH		 3851 switch (elf_header.e_machine)
3852 {
a06ea964
NC		 3853 case EM_AARCH64:
3854 result = get_aarch64_segment_type (p_type);
3855 break;
b294bdf8
MM		 3856 case EM_ARM:
3857 result = get_arm_segment_type (p_type);
3858 break;
252b5132 3859 case EM_MIPS:
4fe85591 3860 case EM_MIPS_RS3_LE:
252b5132
RH		 3861 result = get_mips_segment_type (p_type);
3862 break;
103f02d3
UD		 3863 case EM_PARISC:
3864 result = get_parisc_segment_type (p_type);
3865 break;
4d6ed7c8
NC		 3866 case EM_IA_64:
3867 result = get_ia64_segment_type (p_type);
3868 break;
40b36596
JM		 3869 case EM_TI_C6000:
3870 result = get_tic6x_segment_type (p_type);
3871 break;
b4cbbe8f
AK		 3872 case EM_S390:
3873 case EM_S390_OLD:
3874 result = get_s390_segment_type (p_type);
3875 break;
252b5132
RH		 3876 default:
3877 result = NULL;
3878 break;
3879 }
103f02d3 3880
252b5132
RH		 3881 if (result != NULL)
3882 return result;
103f02d3 3883
1a9ccd70 3884 sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
252b5132
RH		 3885 }
3886 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 3887 {
2cf0635d 3888 const char * result;
103f02d3
UD		 3889
3890 switch (elf_header.e_machine)
3891 {
3892 case EM_PARISC:
3893 result = get_parisc_segment_type (p_type);
3894 break;
00428cca
AM		 3895 case EM_IA_64:
3896 result = get_ia64_segment_type (p_type);
3897 break;
103f02d3 3898 default:
5522f910
NC		 3899 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
3900 result = get_solaris_segment_type (p_type);
3901 else
3902 result = NULL;
103f02d3
UD		 3903 break;
3904 }
3905
3906 if (result != NULL)
3907 return result;
3908
1a9ccd70 3909 sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
103f02d3 3910 }
252b5132 3911 else
e9e44622 3912 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 3913
3914 return buff;
3915 }
3916}
3917
53a346d8
CZ		 3918static const char *
3919get_arc_section_type_name (unsigned int sh_type)
3920{
3921 switch (sh_type)
3922 {
3923 case SHT_ARC_ATTRIBUTES: return "ARC_ATTRIBUTES";
3924 default:
3925 break;
3926 }
3927 return NULL;
3928}
3929
252b5132 3930static const char *
d3ba0551 3931get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 3932{
3933 switch (sh_type)
3934 {
b34976b6
AM		 3935 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3936 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3937 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3938 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3939 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3940 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3941 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3942 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3943 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3944 case SHT_MIPS_RELD: return "MIPS_RELD";
3945 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3946 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3947 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3948 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3949 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3950 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3951 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3952 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3953 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3954 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3955 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3956 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3957 case SHT_MIPS_LINE: return "MIPS_LINE";
3958 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3959 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3960 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3961 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3962 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3963 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3964 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3965 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3966 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3967 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3968 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3969 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3970 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3971 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3972 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132 3973 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
351cdf24 3974 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
252b5132
RH		 3975 default:
3976 break;
3977 }
3978 return NULL;
3979}
3980
103f02d3 3981static const char *
d3ba0551 3982get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 3983{
3984 switch (sh_type)
3985 {
3986 case SHT_PARISC_EXT: return "PARISC_EXT";
3987 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3988 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 3989 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3990 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3991 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 3992 case SHT_PARISC_DLKM: return "PARISC_DLKM";
32ec8896 3993 default: return NULL;
103f02d3 3994 }
103f02d3
UD		 3995}
3996
4d6ed7c8 3997static const char *
d3ba0551 3998get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 3999{
18bd398b 4000 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 4001 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
4002 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 4003
4d6ed7c8
NC		 4004 switch (sh_type)
4005 {
148b93f2
NC		 4006 case SHT_IA_64_EXT: return "IA_64_EXT";
4007 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
4008 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
4009 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
4010 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
4011 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
4012 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
4013 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
4014 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
4015 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 4016 default:
4017 break;
4018 }
4019 return NULL;
4020}
4021
d2b2c203
DJ		 4022static const char *
4023get_x86_64_section_type_name (unsigned int sh_type)
4024{
4025 switch (sh_type)
4026 {
4027 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
32ec8896 4028 default: return NULL;
d2b2c203 4029 }
d2b2c203
DJ		 4030}
4031
a06ea964
NC		 4032static const char *
4033get_aarch64_section_type_name (unsigned int sh_type)
4034{
4035 switch (sh_type)
4036 {
32ec8896
NC		 4037 case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4038 default: return NULL;
a06ea964 4039 }
a06ea964
NC		 4040}
4041
40a18ebd
NC		 4042static const char *
4043get_arm_section_type_name (unsigned int sh_type)
4044{
4045 switch (sh_type)
4046 {
7f6fed87
NC		 4047 case SHT_ARM_EXIDX: return "ARM_EXIDX";
4048 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
4049 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
4050 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
4051 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
32ec8896 4052 default: return NULL;
40a18ebd 4053 }
40a18ebd
NC		 4054}
4055
40b36596
JM		 4056static const char *
4057get_tic6x_section_type_name (unsigned int sh_type)
4058{
4059 switch (sh_type)
4060 {
32ec8896
NC		 4061 case SHT_C6000_UNWIND: return "C6000_UNWIND";
4062 case SHT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
4063 case SHT_C6000_ATTRIBUTES: return "C6000_ATTRIBUTES";
4064 case SHT_TI_ICODE: return "TI_ICODE";
4065 case SHT_TI_XREF: return "TI_XREF";
4066 case SHT_TI_HANDLER: return "TI_HANDLER";
4067 case SHT_TI_INITINFO: return "TI_INITINFO";
4068 case SHT_TI_PHATTRS: return "TI_PHATTRS";
4069 default: return NULL;
40b36596 4070 }
40b36596
JM		 4071}
4072
13761a11
NC		 4073static const char *
4074get_msp430x_section_type_name (unsigned int sh_type)
4075{
4076 switch (sh_type)
4077 {
32ec8896
NC		 4078 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
4079 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
4080 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
4081 default: return NULL;
13761a11
NC		 4082 }
4083}
4084
685080f2
NC		 4085static const char *
4086get_v850_section_type_name (unsigned int sh_type)
4087{
4088 switch (sh_type)
4089 {
32ec8896
NC		 4090 case SHT_V850_SCOMMON: return "V850 Small Common";
4091 case SHT_V850_TCOMMON: return "V850 Tiny Common";
4092 case SHT_V850_ZCOMMON: return "V850 Zero Common";
4093 case SHT_RENESAS_IOP: return "RENESAS IOP";
4094 case SHT_RENESAS_INFO: return "RENESAS INFO";
4095 default: return NULL;
685080f2
NC		 4096 }
4097}
4098
252b5132 4099static const char *
d3ba0551 4100get_section_type_name (unsigned int sh_type)
252b5132 4101{
b34976b6 4102 static char buff[32];
9fb71ee4 4103 const char * result;
252b5132
RH		 4104
4105 switch (sh_type)
4106 {
4107 case SHT_NULL: return "NULL";
4108 case SHT_PROGBITS: return "PROGBITS";
4109 case SHT_SYMTAB: return "SYMTAB";
4110 case SHT_STRTAB: return "STRTAB";
4111 case SHT_RELA: return "RELA";
4112 case SHT_HASH: return "HASH";
4113 case SHT_DYNAMIC: return "DYNAMIC";
4114 case SHT_NOTE: return "NOTE";
4115 case SHT_NOBITS: return "NOBITS";
4116 case SHT_REL: return "REL";
4117 case SHT_SHLIB: return "SHLIB";
4118 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 4119 case SHT_INIT_ARRAY: return "INIT_ARRAY";
4120 case SHT_FINI_ARRAY: return "FINI_ARRAY";
4121 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 4122 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 4123 case SHT_GROUP: return "GROUP";
4124 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 4125 case SHT_GNU_verdef: return "VERDEF";
4126 case SHT_GNU_verneed: return "VERNEED";
4127 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 4128 case 0x6ffffff0: return "VERSYM";
4129 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 4130 case 0x7ffffffd: return "AUXILIARY";
4131 case 0x7fffffff: return "FILTER";
047b2264 4132 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 4133
4134 default:
4135 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4136 {
252b5132
RH		 4137 switch (elf_header.e_machine)
4138 {
53a346d8
CZ		 4139 case EM_ARC:
4140 case EM_ARC_COMPACT:
4141 case EM_ARC_COMPACT2:
4142 result = get_arc_section_type_name (sh_type);
4143 break;
252b5132 4144 case EM_MIPS:
4fe85591 4145 case EM_MIPS_RS3_LE:
252b5132
RH		 4146 result = get_mips_section_type_name (sh_type);
4147 break;
103f02d3
UD		 4148 case EM_PARISC:
4149 result = get_parisc_section_type_name (sh_type);
4150 break;
4d6ed7c8
NC		 4151 case EM_IA_64:
4152 result = get_ia64_section_type_name (sh_type);
4153 break;
d2b2c203 4154 case EM_X86_64:
8a9036a4 4155 case EM_L1OM:
7a9068fe 4156 case EM_K1OM:
d2b2c203
DJ		 4157 result = get_x86_64_section_type_name (sh_type);
4158 break;
a06ea964
NC		 4159 case EM_AARCH64:
4160 result = get_aarch64_section_type_name (sh_type);
4161 break;
40a18ebd
NC		 4162 case EM_ARM:
4163 result = get_arm_section_type_name (sh_type);
4164 break;
40b36596
JM		 4165 case EM_TI_C6000:
4166 result = get_tic6x_section_type_name (sh_type);
4167 break;
13761a11
NC		 4168 case EM_MSP430:
4169 result = get_msp430x_section_type_name (sh_type);
4170 break;
685080f2
NC		 4171 case EM_V800:
4172 case EM_V850:
4173 case EM_CYGNUS_V850:
4174 result = get_v850_section_type_name (sh_type);
4175 break;
252b5132
RH		 4176 default:
4177 result = NULL;
4178 break;
4179 }
4180
4181 if (result != NULL)
4182 return result;
4183
9fb71ee4 4184 sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
252b5132
RH		 4185 }
4186 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 4187 {
148b93f2
NC		 4188 switch (elf_header.e_machine)
4189 {
4190 case EM_IA_64:
4191 result = get_ia64_section_type_name (sh_type);
4192 break;
4193 default:
fd85a6a1
NC		 4194 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4195 result = get_solaris_section_type (sh_type);
4196 else
1b4b80bf
NC		 4197 {
4198 switch (sh_type)
4199 {
4200 case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4201 case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4202 case SHT_GNU_HASH: result = "GNU_HASH"; break;
4203 case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4204 default:
4205 result = NULL;
4206 break;
4207 }
4208 }
148b93f2
NC		 4209 break;
4210 }
4211
4212 if (result != NULL)
4213 return result;
4214
9fb71ee4 4215 sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
148b93f2 4216 }
252b5132 4217 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
685080f2
NC		 4218 {
4219 switch (elf_header.e_machine)
4220 {
4221 case EM_V800:
4222 case EM_V850:
4223 case EM_CYGNUS_V850:
9fb71ee4 4224 result = get_v850_section_type_name (sh_type);
a9fb83be 4225 break;
685080f2 4226 default:
9fb71ee4 4227 result = NULL;
685080f2
NC		 4228 break;
4229 }
4230
9fb71ee4
NC		 4231 if (result != NULL)
4232 return result;
4233
4234 sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
685080f2 4235 }
252b5132 4236 else
a7dbfd1c
NC		 4237 /* This message is probably going to be displayed in a 15
4238 character wide field, so put the hex value first. */
4239 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 4240
252b5132
RH		 4241 return buff;
4242 }
4243}
4244
2979dc34 4245#define OPTION_DEBUG_DUMP 512
2c610e4b 4246#define OPTION_DYN_SYMS 513
fd2f0033
TT		 4247#define OPTION_DWARF_DEPTH 514
4248#define OPTION_DWARF_START 515
4723351a 4249#define OPTION_DWARF_CHECK 516
2979dc34 4250
85b1c36d 4251static struct option options[] =
252b5132 4252{
b34976b6 4253 {"all", no_argument, 0, 'a'},
252b5132
RH		 4254 {"file-header", no_argument, 0, 'h'},
4255 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 4256 {"headers", no_argument, 0, 'e'},
4257 {"histogram", no_argument, 0, 'I'},
4258 {"segments", no_argument, 0, 'l'},
4259 {"sections", no_argument, 0, 'S'},
252b5132 4260 {"section-headers", no_argument, 0, 'S'},
f5842774 4261 {"section-groups", no_argument, 0, 'g'},
5477e8a0 4262 {"section-details", no_argument, 0, 't'},
595cf52e 4263 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 4264 {"symbols", no_argument, 0, 's'},
4265 {"syms", no_argument, 0, 's'},
2c610e4b 4266 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 4267 {"relocs", no_argument, 0, 'r'},
4268 {"notes", no_argument, 0, 'n'},
4269 {"dynamic", no_argument, 0, 'd'},
a952a375 4270 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 4271 {"version-info", no_argument, 0, 'V'},
4272 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 4273 {"unwind", no_argument, 0, 'u'},
4145f1d5 4274 {"archive-index", no_argument, 0, 'c'},
b34976b6 4275 {"hex-dump", required_argument, 0, 'x'},
cf13d699 4276 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 4277 {"string-dump", required_argument, 0, 'p'},
0e602686 4278 {"decompress", no_argument, 0, 'z'},
252b5132
RH		 4279#ifdef SUPPORT_DISASSEMBLY
4280 {"instruction-dump", required_argument, 0, 'i'},
4281#endif
cf13d699 4282 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 4283
fd2f0033
TT		 4284 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
4285 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 4286 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 4287
b34976b6
AM		 4288 {"version", no_argument, 0, 'v'},
4289 {"wide", no_argument, 0, 'W'},
4290 {"help", no_argument, 0, 'H'},
4291 {0, no_argument, 0, 0}
252b5132
RH		 4292};
4293
4294static void
2cf0635d 4295usage (FILE * stream)
252b5132 4296{
92f01d61
JM		 4297 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4298 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4299 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 4300 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4301 -h --file-header Display the ELF file header\n\
4302 -l --program-headers Display the program headers\n\
4303 --segments An alias for --program-headers\n\
4304 -S --section-headers Display the sections' header\n\
4305 --sections An alias for --section-headers\n\
f5842774 4306 -g --section-groups Display the section groups\n\
5477e8a0 4307 -t --section-details Display the section details\n\
8b53311e
NC		 4308 -e --headers Equivalent to: -h -l -S\n\
4309 -s --syms Display the symbol table\n\
3f08eb35 4310 --symbols An alias for --syms\n\
2c610e4b 4311 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 4312 -n --notes Display the core notes (if present)\n\
4313 -r --relocs Display the relocations (if present)\n\
4314 -u --unwind Display the unwind info (if present)\n\
b2d38a17 4315 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 4316 -V --version-info Display the version sections (if present)\n\
1b31d05e 4317 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 4318 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 4319 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 4320 -x --hex-dump=<number|name>\n\
4321 Dump the contents of section <number|name> as bytes\n\
4322 -p --string-dump=<number|name>\n\
4323 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 4324 -R --relocated-dump=<number|name>\n\
4325 Dump the contents of section <number|name> as relocated bytes\n\
0e602686 4326 -z --decompress Decompress section before dumping it\n\
f9f0e732 4327 -w[lLiaprmfFsoRt] or\n\
1ed06042 4328 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 4329 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC		 4330 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4331 =addr,=cu_index]\n\
8b53311e 4332 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 4333 fprintf (stream, _("\
4334 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4335 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4336 or deeper\n"));
252b5132 4337#ifdef SUPPORT_DISASSEMBLY
92f01d61 4338 fprintf (stream, _("\
09c11c86
NC		 4339 -i --instruction-dump=<number|name>\n\
4340 Disassemble the contents of section <number|name>\n"));
252b5132 4341#endif
92f01d61 4342 fprintf (stream, _("\
8b53311e
NC		 4343 -I --histogram Display histogram of bucket list lengths\n\
4344 -W --wide Allow output width to exceed 80 characters\n\
07012eee 4345 @<file> Read options from <file>\n\
8b53311e
NC		 4346 -H --help Display this information\n\
4347 -v --version Display the version number of readelf\n"));
1118d252 4348
92f01d61
JM		 4349 if (REPORT_BUGS_TO[0] && stream == stdout)
4350 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 4351
92f01d61 4352 exit (stream == stdout ? 0 : 1);
252b5132
RH		 4353}
4354
18bd398b
NC		 4355/* Record the fact that the user wants the contents of section number
4356 SECTION to be displayed using the method(s) encoded as flags bits
4357 in TYPE. Note, TYPE can be zero if we are creating the array for
4358 the first time. */
4359
252b5132 4360static void
09c11c86 4361request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 4362{
4363 if (section >= num_dump_sects)
4364 {
2cf0635d 4365 dump_type * new_dump_sects;
252b5132 4366
3f5e193b
NC		 4367 new_dump_sects = (dump_type *) calloc (section + 1,
4368 sizeof (* dump_sects));
252b5132
RH		 4369
4370 if (new_dump_sects == NULL)
591a748a 4371 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 4372 else
4373 {
21b65bac
NC		 4374 if (dump_sects)
4375 {
4376 /* Copy current flag settings. */
4377 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132 4378
21b65bac
NC		 4379 free (dump_sects);
4380 }
252b5132
RH		 4381
4382 dump_sects = new_dump_sects;
4383 num_dump_sects = section + 1;
4384 }
4385 }
4386
4387 if (dump_sects)
b34976b6 4388 dump_sects[section] |= type;
252b5132
RH		 4389
4390 return;
4391}
4392
aef1f6d0
DJ		 4393/* Request a dump by section name. */
4394
4395static void
2cf0635d 4396request_dump_byname (const char * section, dump_type type)
aef1f6d0 4397{
2cf0635d 4398 struct dump_list_entry * new_request;
aef1f6d0 4399
3f5e193b
NC		 4400 new_request = (struct dump_list_entry *)
4401 malloc (sizeof (struct dump_list_entry));
aef1f6d0 4402 if (!new_request)
591a748a 4403 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4404
4405 new_request->name = strdup (section);
4406 if (!new_request->name)
591a748a 4407 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4408
4409 new_request->type = type;
4410
4411 new_request->next = dump_sects_byname;
4412 dump_sects_byname = new_request;
4413}
4414
cf13d699
NC		 4415static inline void
4416request_dump (dump_type type)
4417{
4418 int section;
4419 char * cp;
4420
4421 do_dump++;
4422 section = strtoul (optarg, & cp, 0);
4423
4424 if (! *cp && section >= 0)
4425 request_dump_bynumber (section, type);
4426 else
4427 request_dump_byname (optarg, type);
4428}
4429
4430
252b5132 4431static void
2cf0635d 4432parse_args (int argc, char ** argv)
252b5132
RH		 4433{
4434 int c;
4435
4436 if (argc < 2)
92f01d61 4437 usage (stderr);
252b5132
RH		 4438
4439 while ((c = getopt_long
0e602686 4440 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
252b5132 4441 {
252b5132
RH		 4442 switch (c)
4443 {
4444 case 0:
4445 /* Long options. */
4446 break;
4447 case 'H':
92f01d61 4448 usage (stdout);
252b5132
RH		 4449 break;
4450
4451 case 'a':
32ec8896
NC		 4452 do_syms = TRUE;
4453 do_reloc = TRUE;
4454 do_unwind = TRUE;
4455 do_dynamic = TRUE;
4456 do_header = TRUE;
4457 do_sections = TRUE;
4458 do_section_groups = TRUE;
4459 do_segments = TRUE;
4460 do_version = TRUE;
4461 do_histogram = TRUE;
4462 do_arch = TRUE;
4463 do_notes = TRUE;
252b5132 4464 break;
f5842774 4465 case 'g':
32ec8896 4466 do_section_groups = TRUE;
f5842774 4467 break;
5477e8a0 4468 case 't':
595cf52e 4469 case 'N':
32ec8896
NC		 4470 do_sections = TRUE;
4471 do_section_details = TRUE;
595cf52e 4472 break;
252b5132 4473 case 'e':
32ec8896
NC		 4474 do_header = TRUE;
4475 do_sections = TRUE;
4476 do_segments = TRUE;
252b5132 4477 break;
a952a375 4478 case 'A':
32ec8896 4479 do_arch = TRUE;
a952a375 4480 break;
252b5132 4481 case 'D':
32ec8896 4482 do_using_dynamic = TRUE;
252b5132
RH		 4483 break;
4484 case 'r':
32ec8896 4485 do_reloc = TRUE;
252b5132 4486 break;
4d6ed7c8 4487 case 'u':
32ec8896 4488 do_unwind = TRUE;
4d6ed7c8 4489 break;
252b5132 4490 case 'h':
32ec8896 4491 do_header = TRUE;
252b5132
RH		 4492 break;
4493 case 'l':
32ec8896 4494 do_segments = TRUE;
252b5132
RH		 4495 break;
4496 case 's':
32ec8896 4497 do_syms = TRUE;
252b5132
RH		 4498 break;
4499 case 'S':
32ec8896 4500 do_sections = TRUE;
252b5132
RH		 4501 break;
4502 case 'd':
32ec8896 4503 do_dynamic = TRUE;
252b5132 4504 break;
a952a375 4505 case 'I':
32ec8896 4506 do_histogram = TRUE;
a952a375 4507 break;
779fe533 4508 case 'n':
32ec8896 4509 do_notes = TRUE;
779fe533 4510 break;
4145f1d5 4511 case 'c':
32ec8896 4512 do_archive_index = TRUE;
4145f1d5 4513 break;
252b5132 4514 case 'x':
cf13d699 4515 request_dump (HEX_DUMP);
aef1f6d0 4516 break;
09c11c86 4517 case 'p':
cf13d699
NC		 4518 request_dump (STRING_DUMP);
4519 break;
4520 case 'R':
4521 request_dump (RELOC_DUMP);
09c11c86 4522 break;
0e602686 4523 case 'z':
32ec8896 4524 decompress_dumps = TRUE;
0e602686 4525 break;
252b5132 4526 case 'w':
32ec8896 4527 do_dump = TRUE;
252b5132 4528 if (optarg == 0)
613ff48b 4529 {
32ec8896 4530 do_debugging = TRUE;
613ff48b
CC		 4531 dwarf_select_sections_all ();
4532 }
252b5132
RH		 4533 else
4534 {
32ec8896 4535 do_debugging = FALSE;
4cb93e3b 4536 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 4537 }
4538 break;
2979dc34 4539 case OPTION_DEBUG_DUMP:
32ec8896 4540 do_dump = TRUE;
2979dc34 4541 if (optarg == 0)
32ec8896 4542 do_debugging = TRUE;
2979dc34
JJ		 4543 else
4544 {
32ec8896 4545 do_debugging = FALSE;
4cb93e3b 4546 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 4547 }
4548 break;
fd2f0033
TT		 4549 case OPTION_DWARF_DEPTH:
4550 {
4551 char *cp;
4552
4553 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4554 }
4555 break;
4556 case OPTION_DWARF_START:
4557 {
4558 char *cp;
4559
4560 dwarf_start_die = strtoul (optarg, & cp, 0);
4561 }
4562 break;
4723351a 4563 case OPTION_DWARF_CHECK:
32ec8896 4564 dwarf_check = TRUE;
4723351a 4565 break;
2c610e4b 4566 case OPTION_DYN_SYMS:
32ec8896 4567 do_dyn_syms = TRUE;
2c610e4b 4568 break;
252b5132
RH		 4569#ifdef SUPPORT_DISASSEMBLY
4570 case 'i':
cf13d699
NC		 4571 request_dump (DISASS_DUMP);
4572 break;
252b5132
RH		 4573#endif
4574 case 'v':
4575 print_version (program_name);
4576 break;
4577 case 'V':
32ec8896 4578 do_version = TRUE;
252b5132 4579 break;
d974e256 4580 case 'W':
32ec8896 4581 do_wide = TRUE;
d974e256 4582 break;
252b5132 4583 default:
252b5132
RH		 4584 /* xgettext:c-format */
4585 error (_("Invalid option '-%c'\n"), c);
1a0670f3 4586 /* Fall through. */
252b5132 4587 case '?':
92f01d61 4588 usage (stderr);
252b5132
RH		 4589 }
4590 }
4591
4d6ed7c8 4592 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 4593 && !do_segments && !do_header && !do_dump && !do_version
f5842774 4594 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 4595 && !do_section_groups && !do_archive_index
4596 && !do_dyn_syms)
92f01d61 4597 usage (stderr);
252b5132
RH		 4598}
4599
4600static const char *
d3ba0551 4601get_elf_class (unsigned int elf_class)
252b5132 4602{
b34976b6 4603 static char buff[32];
103f02d3 4604
252b5132
RH		 4605 switch (elf_class)
4606 {
4607 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 4608 case ELFCLASS32: return "ELF32";
4609 case ELFCLASS64: return "ELF64";
ab5e7794 4610 default:
e9e44622 4611 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 4612 return buff;
252b5132
RH		 4613 }
4614}
4615
4616static const char *
d3ba0551 4617get_data_encoding (unsigned int encoding)
252b5132 4618{
b34976b6 4619 static char buff[32];
103f02d3 4620
252b5132
RH		 4621 switch (encoding)
4622 {
4623 case ELFDATANONE: return _("none");
33c63f9d
CM		 4624 case ELFDATA2LSB: return _("2's complement, little endian");
4625 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 4626 default:
e9e44622 4627 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 4628 return buff;
252b5132
RH		 4629 }
4630}
4631
252b5132 4632/* Decode the data held in 'elf_header'. */
ee42cf8c 4633
32ec8896 4634static bfd_boolean
d3ba0551 4635process_file_header (void)
252b5132 4636{
b34976b6
AM		 4637 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
4638 || elf_header.e_ident[EI_MAG1] != ELFMAG1
4639 || elf_header.e_ident[EI_MAG2] != ELFMAG2
4640 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 4641 {
4642 error
4643 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
32ec8896 4644 return FALSE;
252b5132
RH		 4645 }
4646
2dc4cec1
L		 4647 init_dwarf_regnames (elf_header.e_machine);
4648
252b5132
RH		 4649 if (do_header)
4650 {
32ec8896 4651 unsigned i;
252b5132
RH		 4652
4653 printf (_("ELF Header:\n"));
4654 printf (_(" Magic: "));
b34976b6
AM		 4655 for (i = 0; i < EI_NIDENT; i++)
4656 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 4657 printf ("\n");
4658 printf (_(" Class: %s\n"),
b34976b6 4659 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 4660 printf (_(" Data: %s\n"),
b34976b6 4661 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 4662 printf (_(" Version: %d %s\n"),
b34976b6
AM		 4663 elf_header.e_ident[EI_VERSION],
4664 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 4665 ? "(current)"
b34976b6 4666 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 4667 ? _("<unknown: %lx>")
789be9f7 4668 : "")));
252b5132 4669 printf (_(" OS/ABI: %s\n"),
b34976b6 4670 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 4671 printf (_(" ABI Version: %d\n"),
b34976b6 4672 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 4673 printf (_(" Type: %s\n"),
4674 get_file_type (elf_header.e_type));
4675 printf (_(" Machine: %s\n"),
4676 get_machine_name (elf_header.e_machine));
4677 printf (_(" Version: 0x%lx\n"),
4678 (unsigned long) elf_header.e_version);
76da6bbe 4679
f7a99963
NC		 4680 printf (_(" Entry point address: "));
4681 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4682 printf (_("\n Start of program headers: "));
4683 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4684 printf (_(" (bytes into file)\n Start of section headers: "));
4685 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4686 printf (_(" (bytes into file)\n"));
76da6bbe 4687
252b5132
RH		 4688 printf (_(" Flags: 0x%lx%s\n"),
4689 (unsigned long) elf_header.e_flags,
4690 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4691 printf (_(" Size of this header: %ld (bytes)\n"),
4692 (long) elf_header.e_ehsize);
4693 printf (_(" Size of program headers: %ld (bytes)\n"),
4694 (long) elf_header.e_phentsize);
2046a35d 4695 printf (_(" Number of program headers: %ld"),
252b5132 4696 (long) elf_header.e_phnum);
2046a35d
AM		 4697 if (section_headers != NULL
4698 && elf_header.e_phnum == PN_XNUM
4699 && section_headers[0].sh_info != 0)
cc5914eb 4700 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 4701 putc ('\n', stdout);
252b5132
RH		 4702 printf (_(" Size of section headers: %ld (bytes)\n"),
4703 (long) elf_header.e_shentsize);
560f3c1c 4704 printf (_(" Number of section headers: %ld"),
252b5132 4705 (long) elf_header.e_shnum);
4fbb74a6 4706 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 4707 printf (" (%ld)", (long) section_headers[0].sh_size);
4708 putc ('\n', stdout);
4709 printf (_(" Section header string table index: %ld"),
252b5132 4710 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 4711 if (section_headers != NULL
4712 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 4713 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 4714 else if (elf_header.e_shstrndx != SHN_UNDEF
4715 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 4716 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 4717 putc ('\n', stdout);
4718 }
4719
4720 if (section_headers != NULL)
4721 {
2046a35d
AM		 4722 if (elf_header.e_phnum == PN_XNUM
4723 && section_headers[0].sh_info != 0)
4724 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 4725 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 4726 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 4727 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 4728 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 4729 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 4730 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 4731 free (section_headers);
4732 section_headers = NULL;
252b5132 4733 }
103f02d3 4734
32ec8896 4735 return TRUE;
9ea033b2
NC		 4736}
4737
e0a31db1 4738static bfd_boolean
91d6fa6a 4739get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4740{
2cf0635d
NC		 4741 Elf32_External_Phdr * phdrs;
4742 Elf32_External_Phdr * external;
4743 Elf_Internal_Phdr * internal;
b34976b6 4744 unsigned int i;
e0a31db1
NC		 4745 unsigned int size = elf_header.e_phentsize;
4746 unsigned int num = elf_header.e_phnum;
4747
4748 /* PR binutils/17531: Cope with unexpected section header sizes. */
4749 if (size == 0 || num == 0)
4750 return FALSE;
4751 if (size < sizeof * phdrs)
4752 {
4753 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4754 return FALSE;
4755 }
4756 if (size > sizeof * phdrs)
4757 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4758
3f5e193b 4759 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1
NC		 4760 size, num, _("program headers"));
4761 if (phdrs == NULL)
4762 return FALSE;
9ea033b2 4763
91d6fa6a 4764 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4765 i < elf_header.e_phnum;
b34976b6 4766 i++, internal++, external++)
252b5132 4767 {
9ea033b2
NC		 4768 internal->p_type = BYTE_GET (external->p_type);
4769 internal->p_offset = BYTE_GET (external->p_offset);
4770 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4771 internal->p_paddr = BYTE_GET (external->p_paddr);
4772 internal->p_filesz = BYTE_GET (external->p_filesz);
4773 internal->p_memsz = BYTE_GET (external->p_memsz);
4774 internal->p_flags = BYTE_GET (external->p_flags);
4775 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 4776 }
4777
9ea033b2 4778 free (phdrs);
e0a31db1 4779 return TRUE;
252b5132
RH		 4780}
4781
e0a31db1 4782static bfd_boolean
91d6fa6a 4783get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4784{
2cf0635d
NC		 4785 Elf64_External_Phdr * phdrs;
4786 Elf64_External_Phdr * external;
4787 Elf_Internal_Phdr * internal;
b34976b6 4788 unsigned int i;
e0a31db1
NC		 4789 unsigned int size = elf_header.e_phentsize;
4790 unsigned int num = elf_header.e_phnum;
4791
4792 /* PR binutils/17531: Cope with unexpected section header sizes. */
4793 if (size == 0 || num == 0)
4794 return FALSE;
4795 if (size < sizeof * phdrs)
4796 {
4797 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4798 return FALSE;
4799 }
4800 if (size > sizeof * phdrs)
4801 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4802
3f5e193b 4803 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1 4804 size, num, _("program headers"));
a6e9f9df 4805 if (!phdrs)
e0a31db1 4806 return FALSE;
9ea033b2 4807
91d6fa6a 4808 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4809 i < elf_header.e_phnum;
b34976b6 4810 i++, internal++, external++)
9ea033b2
NC		 4811 {
4812 internal->p_type = BYTE_GET (external->p_type);
4813 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 4814 internal->p_offset = BYTE_GET (external->p_offset);
4815 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4816 internal->p_paddr = BYTE_GET (external->p_paddr);
4817 internal->p_filesz = BYTE_GET (external->p_filesz);
4818 internal->p_memsz = BYTE_GET (external->p_memsz);
4819 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 4820 }
4821
4822 free (phdrs);
e0a31db1 4823 return TRUE;
9ea033b2 4824}
252b5132 4825
32ec8896 4826/* Returns TRUE if the program headers were read into `program_headers'. */
d93f0186 4827
32ec8896 4828static bfd_boolean
2cf0635d 4829get_program_headers (FILE * file)
d93f0186 4830{
2cf0635d 4831 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 4832
4833 /* Check cache of prior read. */
4834 if (program_headers != NULL)
32ec8896 4835 return TRUE;
d93f0186 4836
82156ab7
NC		 4837 /* Be kind to memory checkers by looking for
4838 e_phnum values which we know must be invalid. */
4839 if (elf_header.e_phnum
4840 * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
4841 >= current_file_size)
4842 {
4843 error (_("Too many program headers - %#x - the file is not that big\n"),
4844 elf_header.e_phnum);
4845 return FALSE;
4846 }
d93f0186 4847
82156ab7
NC		 4848 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4849 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 4850 if (phdrs == NULL)
4851 {
8b73c356
NC		 4852 error (_("Out of memory reading %u program headers\n"),
4853 elf_header.e_phnum);
32ec8896 4854 return FALSE;
d93f0186
NC		 4855 }
4856
4857 if (is_32bit_elf
4858 ? get_32bit_program_headers (file, phdrs)
4859 : get_64bit_program_headers (file, phdrs))
4860 {
4861 program_headers = phdrs;
32ec8896 4862 return TRUE;
d93f0186
NC		 4863 }
4864
4865 free (phdrs);
32ec8896 4866 return FALSE;
d93f0186
NC		 4867}
4868
32ec8896 4869/* Returns TRUE if the program headers were loaded. */
2f62977e 4870
32ec8896 4871static bfd_boolean
2cf0635d 4872process_program_headers (FILE * file)
252b5132 4873{
2cf0635d 4874 Elf_Internal_Phdr * segment;
b34976b6 4875 unsigned int i;
1a9ccd70 4876 Elf_Internal_Phdr * previous_load = NULL;
252b5132
RH		 4877
4878 if (elf_header.e_phnum == 0)
4879 {
82f2dbf7
NC		 4880 /* PR binutils/12467. */
4881 if (elf_header.e_phoff != 0)
32ec8896
NC		 4882 {
4883 warn (_("possibly corrupt ELF header - it has a non-zero program"
4884 " header offset, but no program headers\n"));
4885 return FALSE;
4886 }
82f2dbf7 4887 else if (do_segments)
252b5132 4888 printf (_("\nThere are no program headers in this file.\n"));
32ec8896 4889 return TRUE;
252b5132
RH		 4890 }
4891
4892 if (do_segments && !do_header)
4893 {
f7a99963
NC		 4894 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4895 printf (_("Entry point "));
4896 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4897 printf (_("\nThere are %d program headers, starting at offset "),
4898 elf_header.e_phnum);
4899 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4900 printf ("\n");
252b5132
RH		 4901 }
4902
d93f0186 4903 if (! get_program_headers (file))
6b4bf3bc 4904 return TRUE;
103f02d3 4905
252b5132
RH		 4906 if (do_segments)
4907 {
3a1a2036
NC		 4908 if (elf_header.e_phnum > 1)
4909 printf (_("\nProgram Headers:\n"));
4910 else
4911 printf (_("\nProgram Headers:\n"));
76da6bbe 4912
f7a99963
NC		 4913 if (is_32bit_elf)
4914 printf
4915 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 4916 else if (do_wide)
4917 printf
4918 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 4919 else
4920 {
4921 printf
4922 (_(" Type Offset VirtAddr PhysAddr\n"));
4923 printf
4924 (_(" FileSiz MemSiz Flags Align\n"));
4925 }
252b5132
RH		 4926 }
4927
252b5132 4928 dynamic_addr = 0;
1b228002 4929 dynamic_size = 0;
252b5132
RH		 4930
4931 for (i = 0, segment = program_headers;
4932 i < elf_header.e_phnum;
b34976b6 4933 i++, segment++)
252b5132
RH		 4934 {
4935 if (do_segments)
4936 {
103f02d3 4937 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 4938
4939 if (is_32bit_elf)
4940 {
4941 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4942 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4943 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4944 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4945 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4946 printf ("%c%c%c ",
4947 (segment->p_flags & PF_R ? 'R' : ' '),
4948 (segment->p_flags & PF_W ? 'W' : ' '),
4949 (segment->p_flags & PF_X ? 'E' : ' '));
4950 printf ("%#lx", (unsigned long) segment->p_align);
4951 }
d974e256
JJ		 4952 else if (do_wide)
4953 {
4954 if ((unsigned long) segment->p_offset == segment->p_offset)
4955 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4956 else
4957 {
4958 print_vma (segment->p_offset, FULL_HEX);
4959 putchar (' ');
4960 }
4961
4962 print_vma (segment->p_vaddr, FULL_HEX);
4963 putchar (' ');
4964 print_vma (segment->p_paddr, FULL_HEX);
4965 putchar (' ');
4966
4967 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4968 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4969 else
4970 {
4971 print_vma (segment->p_filesz, FULL_HEX);
4972 putchar (' ');
4973 }
4974
4975 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4976 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4977 else
4978 {
f48e6c45 4979 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 4980 }
4981
4982 printf (" %c%c%c ",
4983 (segment->p_flags & PF_R ? 'R' : ' '),
4984 (segment->p_flags & PF_W ? 'W' : ' '),
4985 (segment->p_flags & PF_X ? 'E' : ' '));
4986
4987 if ((unsigned long) segment->p_align == segment->p_align)
4988 printf ("%#lx", (unsigned long) segment->p_align);
4989 else
4990 {
4991 print_vma (segment->p_align, PREFIX_HEX);
4992 }
4993 }
f7a99963
NC		 4994 else
4995 {
4996 print_vma (segment->p_offset, FULL_HEX);
4997 putchar (' ');
4998 print_vma (segment->p_vaddr, FULL_HEX);
4999 putchar (' ');
5000 print_vma (segment->p_paddr, FULL_HEX);
5001 printf ("\n ");
5002 print_vma (segment->p_filesz, FULL_HEX);
5003 putchar (' ');
5004 print_vma (segment->p_memsz, FULL_HEX);
5005 printf (" %c%c%c ",
5006 (segment->p_flags & PF_R ? 'R' : ' '),
5007 (segment->p_flags & PF_W ? 'W' : ' '),
5008 (segment->p_flags & PF_X ? 'E' : ' '));
1d262527 5009 print_vma (segment->p_align, PREFIX_HEX);
f7a99963 5010 }
252b5132 5011
1a9ccd70
NC		 5012 putc ('\n', stdout);
5013 }
f54498b4 5014
252b5132
RH		 5015 switch (segment->p_type)
5016 {
1a9ccd70 5017 case PT_LOAD:
502d895c
NC		 5018#if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5019 required by the ELF standard, several programs, including the Linux
5020 kernel, make use of non-ordered segments. */
1a9ccd70
NC		 5021 if (previous_load
5022 && previous_load->p_vaddr > segment->p_vaddr)
5023 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
502d895c 5024#endif
1a9ccd70
NC		 5025 if (segment->p_memsz < segment->p_filesz)
5026 error (_("the segment's file size is larger than its memory size\n"));
5027 previous_load = segment;
5028 break;
5029
5030 case PT_PHDR:
5031 /* PR 20815 - Verify that the program header is loaded into memory. */
5032 if (i > 0 && previous_load != NULL)
5033 error (_("the PHDR segment must occur before any LOAD segment\n"));
5034 if (elf_header.e_machine != EM_PARISC)
5035 {
5036 unsigned int j;
5037
5038 for (j = 1; j < elf_header.e_phnum; j++)
5039 if (program_headers[j].p_vaddr <= segment->p_vaddr
5040 && (program_headers[j].p_vaddr + program_headers[j].p_memsz)
5041 >= (segment->p_vaddr + segment->p_filesz))
5042 break;
5043 if (j == elf_header.e_phnum)
5044 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5045 }
5046 break;
5047
252b5132
RH		 5048 case PT_DYNAMIC:
5049 if (dynamic_addr)
5050 error (_("more than one dynamic segment\n"));
5051
20737c13
AM		 5052 /* By default, assume that the .dynamic section is the first
5053 section in the DYNAMIC segment. */
5054 dynamic_addr = segment->p_offset;
5055 dynamic_size = segment->p_filesz;
5056
b2d38a17
NC		 5057 /* Try to locate the .dynamic section. If there is
5058 a section header table, we can easily locate it. */
5059 if (section_headers != NULL)
5060 {
2cf0635d 5061 Elf_Internal_Shdr * sec;
b2d38a17 5062
89fac5e3
RS		 5063 sec = find_section (".dynamic");
5064 if (sec == NULL || sec->sh_size == 0)
b2d38a17 5065 {
28f997cf
TG		 5066 /* A corresponding .dynamic section is expected, but on
5067 IA-64/OpenVMS it is OK for it to be missing. */
5068 if (!is_ia64_vms ())
5069 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 5070 break;
5071 }
5072
42bb2e33 5073 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 5074 {
5075 dynamic_size = 0;
5076 break;
5077 }
42bb2e33 5078
b2d38a17
NC		 5079 dynamic_addr = sec->sh_offset;
5080 dynamic_size = sec->sh_size;
5081
5082 if (dynamic_addr < segment->p_offset
5083 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 5084 warn (_("the .dynamic section is not contained"
5085 " within the dynamic segment\n"));
b2d38a17 5086 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 5087 warn (_("the .dynamic section is not the first section"
5088 " in the dynamic segment.\n"));
b2d38a17 5089 }
39e224f6
MW		 5090
5091 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5092 segment. Check this after matching against the section headers
5093 so we don't warn on debuginfo file (which have NOBITS .dynamic
5094 sections). */
5095 if (dynamic_addr + dynamic_size >= current_file_size)
5096 {
5097 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5098 dynamic_addr = dynamic_size = 0;
5099 }
252b5132
RH		 5100 break;
5101
5102 case PT_INTERP:
fb52b2f4
NC		 5103 if (fseek (file, archive_file_offset + (long) segment->p_offset,
5104 SEEK_SET))
252b5132
RH		 5105 error (_("Unable to find program interpreter name\n"));
5106 else
5107 {
f8eae8b2 5108 char fmt [32];
9495b2e6 5109 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
f8eae8b2
L		 5110
5111 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 5112 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 5113
252b5132 5114 program_interpreter[0] = 0;
7bd7b3ef
AM		 5115 if (fscanf (file, fmt, program_interpreter) <= 0)
5116 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 5117
5118 if (do_segments)
f54498b4 5119 printf (_(" [Requesting program interpreter: %s]\n"),
252b5132
RH		 5120 program_interpreter);
5121 }
5122 break;
5123 }
252b5132
RH		 5124 }
5125
c256ffe7 5126 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 5127 {
5128 printf (_("\n Section to Segment mapping:\n"));
5129 printf (_(" Segment Sections...\n"));
5130
252b5132
RH		 5131 for (i = 0; i < elf_header.e_phnum; i++)
5132 {
9ad5cbcf 5133 unsigned int j;
2cf0635d 5134 Elf_Internal_Shdr * section;
252b5132
RH		 5135
5136 segment = program_headers + i;
b391a3e3 5137 section = section_headers + 1;
252b5132
RH		 5138
5139 printf (" %2.2d ", i);
5140
b34976b6 5141 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 5142 {
f4638467
AM		 5143 if (!ELF_TBSS_SPECIAL (section, segment)
5144 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
74e1a04b 5145 printf ("%s ", printable_section_name (section));
252b5132
RH		 5146 }
5147
5148 putc ('\n',stdout);
5149 }
5150 }
5151
32ec8896 5152 return TRUE;
252b5132
RH		 5153}
5154
5155
d93f0186
NC		 5156/* Find the file offset corresponding to VMA by using the program headers. */
5157
5158static long
2cf0635d 5159offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 5160{
2cf0635d 5161 Elf_Internal_Phdr * seg;
d93f0186
NC		 5162
5163 if (! get_program_headers (file))
5164 {
5165 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5166 return (long) vma;
5167 }
5168
5169 for (seg = program_headers;
5170 seg < program_headers + elf_header.e_phnum;
5171 ++seg)
5172 {
5173 if (seg->p_type != PT_LOAD)
5174 continue;
5175
5176 if (vma >= (seg->p_vaddr & -seg->p_align)
5177 && vma + size <= seg->p_vaddr + seg->p_filesz)
5178 return vma - seg->p_vaddr + seg->p_offset;
5179 }
5180
5181 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 5182 (unsigned long) vma);
d93f0186
NC		 5183 return (long) vma;
5184}
5185
5186
049b0c3a
NC		 5187/* Allocate memory and load the sections headers into the global pointer
5188 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
5189 generate any error messages if the load fails. */
5190
5191static bfd_boolean
5192get_32bit_section_headers (FILE * file, bfd_boolean probe)
252b5132 5193{
2cf0635d
NC		 5194 Elf32_External_Shdr * shdrs;
5195 Elf_Internal_Shdr * internal;
b34976b6 5196 unsigned int i;
049b0c3a
NC		 5197 unsigned int size = elf_header.e_shentsize;
5198 unsigned int num = probe ? 1 : elf_header.e_shnum;
5199
5200 /* PR binutils/17531: Cope with unexpected section header sizes. */
5201 if (size == 0 || num == 0)
5202 return FALSE;
5203 if (size < sizeof * shdrs)
5204 {
5205 if (! probe)
5206 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5207 return FALSE;
5208 }
5209 if (!probe && size > sizeof * shdrs)
5210 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
252b5132 5211
3f5e193b 5212 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 5213 size, num,
5214 probe ? NULL : _("section headers"));
5215 if (shdrs == NULL)
5216 return FALSE;
252b5132 5217
049b0c3a
NC		 5218 if (section_headers != NULL)
5219 free (section_headers);
3f5e193b
NC		 5220 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
5221 sizeof (Elf_Internal_Shdr));
252b5132
RH		 5222 if (section_headers == NULL)
5223 {
049b0c3a 5224 if (!probe)
8b73c356 5225 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 5226 return FALSE;
252b5132
RH		 5227 }
5228
5229 for (i = 0, internal = section_headers;
560f3c1c 5230 i < num;
b34976b6 5231 i++, internal++)
252b5132
RH		 5232 {
5233 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5234 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5235 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5236 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5237 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5238 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5239 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5240 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5241 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5242 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
315350be
NC		 5243 if (!probe && internal->sh_link > num)
5244 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5245 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5246 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
252b5132
RH		 5247 }
5248
5249 free (shdrs);
049b0c3a 5250 return TRUE;
252b5132
RH		 5251}
5252
049b0c3a
NC		 5253static bfd_boolean
5254get_64bit_section_headers (FILE * file, bfd_boolean probe)
9ea033b2 5255{
2cf0635d
NC		 5256 Elf64_External_Shdr * shdrs;
5257 Elf_Internal_Shdr * internal;
b34976b6 5258 unsigned int i;
049b0c3a
NC		 5259 unsigned int size = elf_header.e_shentsize;
5260 unsigned int num = probe ? 1 : elf_header.e_shnum;
5261
5262 /* PR binutils/17531: Cope with unexpected section header sizes. */
5263 if (size == 0 || num == 0)
5264 return FALSE;
5265 if (size < sizeof * shdrs)
5266 {
5267 if (! probe)
5268 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5269 return FALSE;
5270 }
5271 if (! probe && size > sizeof * shdrs)
5272 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
9ea033b2 5273
3f5e193b 5274 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 5275 size, num,
5276 probe ? NULL : _("section headers"));
5277 if (shdrs == NULL)
5278 return FALSE;
9ea033b2 5279
049b0c3a
NC		 5280 if (section_headers != NULL)
5281 free (section_headers);
3f5e193b
NC		 5282 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
5283 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 5284 if (section_headers == NULL)
5285 {
049b0c3a 5286 if (! probe)
8b73c356 5287 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 5288 return FALSE;
9ea033b2
NC		 5289 }
5290
5291 for (i = 0, internal = section_headers;
560f3c1c 5292 i < num;
b34976b6 5293 i++, internal++)
9ea033b2
NC		 5294 {
5295 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5296 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 5297 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5298 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5299 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5300 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 5301 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5302 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5303 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5304 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
315350be
NC		 5305 if (!probe && internal->sh_link > num)
5306 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5307 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5308 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
9ea033b2
NC		 5309 }
5310
5311 free (shdrs);
049b0c3a 5312 return TRUE;
9ea033b2
NC		 5313}
5314
252b5132 5315static Elf_Internal_Sym *
ba5cdace
NC		 5316get_32bit_elf_symbols (FILE * file,
5317 Elf_Internal_Shdr * section,
5318 unsigned long * num_syms_return)
252b5132 5319{
ba5cdace 5320 unsigned long number = 0;
dd24e3da 5321 Elf32_External_Sym * esyms = NULL;
ba5cdace 5322 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 5323 Elf_Internal_Sym * isyms = NULL;
2cf0635d 5324 Elf_Internal_Sym * psym;
b34976b6 5325 unsigned int j;
252b5132 5326
c9c1d674
EG		 5327 if (section->sh_size == 0)
5328 {
5329 if (num_syms_return != NULL)
5330 * num_syms_return = 0;
5331 return NULL;
5332 }
5333
dd24e3da 5334 /* Run some sanity checks first. */
c9c1d674 5335 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 5336 {
c9c1d674
EG		 5337 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5338 printable_section_name (section), (unsigned long) section->sh_entsize);
ba5cdace 5339 goto exit_point;
dd24e3da
NC		 5340 }
5341
f54498b4
NC		 5342 if (section->sh_size > current_file_size)
5343 {
5344 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
74e1a04b 5345 printable_section_name (section), (unsigned long) section->sh_size);
f54498b4
NC		 5346 goto exit_point;
5347 }
5348
dd24e3da
NC		 5349 number = section->sh_size / section->sh_entsize;
5350
5351 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5352 {
c9c1d674 5353 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 5354 (unsigned long) section->sh_size,
5355 printable_section_name (section),
5356 (unsigned long) section->sh_entsize);
ba5cdace 5357 goto exit_point;
dd24e3da
NC		 5358 }
5359
3f5e193b
NC		 5360 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5361 section->sh_size, _("symbols"));
dd24e3da 5362 if (esyms == NULL)
ba5cdace 5363 goto exit_point;
252b5132 5364
6a40cf0c
NC		 5365 {
5366 elf_section_list * entry;
5367
5368 shndx = NULL;
5369 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5370 if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
c9c1d674 5371 {
6a40cf0c
NC		 5372 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5373 entry->hdr->sh_offset,
5374 1, entry->hdr->sh_size,
5375 _("symbol table section indicies"));
5376 if (shndx == NULL)
5377 goto exit_point;
5378 /* PR17531: file: heap-buffer-overflow */
5379 else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5380 {
5381 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5382 printable_section_name (entry->hdr),
5383 (unsigned long) entry->hdr->sh_size,
5384 (unsigned long) section->sh_size);
5385 goto exit_point;
5386 }
c9c1d674 5387 }
6a40cf0c 5388 }
9ad5cbcf 5389
3f5e193b 5390 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 5391
5392 if (isyms == NULL)
5393 {
8b73c356
NC		 5394 error (_("Out of memory reading %lu symbols\n"),
5395 (unsigned long) number);
dd24e3da 5396 goto exit_point;
252b5132
RH		 5397 }
5398
dd24e3da 5399 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 5400 {
5401 psym->st_name = BYTE_GET (esyms[j].st_name);
5402 psym->st_value = BYTE_GET (esyms[j].st_value);
5403 psym->st_size = BYTE_GET (esyms[j].st_size);
5404 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 5405 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5406 psym->st_shndx
5407 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5408 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5409 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 5410 psym->st_info = BYTE_GET (esyms[j].st_info);
5411 psym->st_other = BYTE_GET (esyms[j].st_other);
5412 }
5413
dd24e3da 5414 exit_point:
ba5cdace 5415 if (shndx != NULL)
9ad5cbcf 5416 free (shndx);
ba5cdace 5417 if (esyms != NULL)
dd24e3da 5418 free (esyms);
252b5132 5419
ba5cdace
NC		 5420 if (num_syms_return != NULL)
5421 * num_syms_return = isyms == NULL ? 0 : number;
5422
252b5132
RH		 5423 return isyms;
5424}
5425
9ea033b2 5426static Elf_Internal_Sym *
ba5cdace
NC		 5427get_64bit_elf_symbols (FILE * file,
5428 Elf_Internal_Shdr * section,
5429 unsigned long * num_syms_return)
9ea033b2 5430{
ba5cdace
NC		 5431 unsigned long number = 0;
5432 Elf64_External_Sym * esyms = NULL;
5433 Elf_External_Sym_Shndx * shndx = NULL;
5434 Elf_Internal_Sym * isyms = NULL;
2cf0635d 5435 Elf_Internal_Sym * psym;
b34976b6 5436 unsigned int j;
9ea033b2 5437
c9c1d674
EG		 5438 if (section->sh_size == 0)
5439 {
5440 if (num_syms_return != NULL)
5441 * num_syms_return = 0;
5442 return NULL;
5443 }
5444
dd24e3da 5445 /* Run some sanity checks first. */
c9c1d674 5446 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 5447 {
c9c1d674 5448 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
8066deb1
AM		 5449 printable_section_name (section),
5450 (unsigned long) section->sh_entsize);
ba5cdace 5451 goto exit_point;
dd24e3da
NC		 5452 }
5453
f54498b4
NC		 5454 if (section->sh_size > current_file_size)
5455 {
5456 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
8066deb1
AM		 5457 printable_section_name (section),
5458 (unsigned long) section->sh_size);
f54498b4
NC		 5459 goto exit_point;
5460 }
5461
dd24e3da
NC		 5462 number = section->sh_size / section->sh_entsize;
5463
5464 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5465 {
c9c1d674 5466 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 5467 (unsigned long) section->sh_size,
5468 printable_section_name (section),
5469 (unsigned long) section->sh_entsize);
ba5cdace 5470 goto exit_point;
dd24e3da
NC		 5471 }
5472
3f5e193b
NC		 5473 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5474 section->sh_size, _("symbols"));
a6e9f9df 5475 if (!esyms)
ba5cdace 5476 goto exit_point;
9ea033b2 5477
6a40cf0c
NC		 5478 {
5479 elf_section_list * entry;
5480
5481 shndx = NULL;
5482 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5483 if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
c9c1d674 5484 {
6a40cf0c
NC		 5485 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5486 entry->hdr->sh_offset,
5487 1, entry->hdr->sh_size,
5488 _("symbol table section indicies"));
5489 if (shndx == NULL)
5490 goto exit_point;
5491 /* PR17531: file: heap-buffer-overflow */
5492 else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5493 {
5494 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5495 printable_section_name (entry->hdr),
5496 (unsigned long) entry->hdr->sh_size,
5497 (unsigned long) section->sh_size);
5498 goto exit_point;
5499 }
c9c1d674 5500 }
6a40cf0c 5501 }
9ad5cbcf 5502
3f5e193b 5503 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 5504
5505 if (isyms == NULL)
5506 {
8b73c356
NC		 5507 error (_("Out of memory reading %lu symbols\n"),
5508 (unsigned long) number);
ba5cdace 5509 goto exit_point;
9ea033b2
NC		 5510 }
5511
ba5cdace 5512 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 5513 {
5514 psym->st_name = BYTE_GET (esyms[j].st_name);
5515 psym->st_info = BYTE_GET (esyms[j].st_info);
5516 psym->st_other = BYTE_GET (esyms[j].st_other);
5517 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 5518
4fbb74a6 5519 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5520 psym->st_shndx
5521 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5522 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5523 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 5524
66543521
AM		 5525 psym->st_value = BYTE_GET (esyms[j].st_value);
5526 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 5527 }
5528
ba5cdace
NC		 5529 exit_point:
5530 if (shndx != NULL)
9ad5cbcf 5531 free (shndx);
ba5cdace
NC		 5532 if (esyms != NULL)
5533 free (esyms);
5534
5535 if (num_syms_return != NULL)
5536 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 5537
5538 return isyms;
5539}
5540
d1133906 5541static const char *
d3ba0551 5542get_elf_section_flags (bfd_vma sh_flags)
d1133906 5543{
5477e8a0 5544 static char buff[1024];
2cf0635d 5545 char * p = buff;
32ec8896
NC		 5546 unsigned int field_size = is_32bit_elf ? 8 : 16;
5547 signed int sindex;
5548 unsigned int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 5549 bfd_vma os_flags = 0;
5550 bfd_vma proc_flags = 0;
5551 bfd_vma unknown_flags = 0;
148b93f2 5552 static const struct
5477e8a0 5553 {
2cf0635d 5554 const char * str;
32ec8896 5555 unsigned int len;
5477e8a0
L		 5556 }
5557 flags [] =
5558 {
cfcac11d
NC		 5559 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5560 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5561 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5562 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5563 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5564 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5565 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5566 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5567 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5568 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5569 /* IA-64 specific. */
5570 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5571 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5572 /* IA-64 OpenVMS specific. */
5573 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5574 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5575 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5576 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5577 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5578 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 5579 /* Generic. */
cfcac11d 5580 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 5581 /* SPARC specific. */
77115a4a 5582 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
ac4c9b04
MG		 5583 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5584 /* ARM specific. */
5585 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
f0728ee3 5586 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
a91e1603
L		 5587 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5588 /* GNU specific. */
5589 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5477e8a0
L		 5590 };
5591
5592 if (do_section_details)
5593 {
8d5ff12c
L		 5594 sprintf (buff, "[%*.*lx]: ",
5595 field_size, field_size, (unsigned long) sh_flags);
5596 p += field_size + 4;
5477e8a0 5597 }
76da6bbe 5598
d1133906
NC		 5599 while (sh_flags)
5600 {
5601 bfd_vma flag;
5602
5603 flag = sh_flags & - sh_flags;
5604 sh_flags &= ~ flag;
76da6bbe 5605
5477e8a0 5606 if (do_section_details)
d1133906 5607 {
5477e8a0
L		 5608 switch (flag)
5609 {
91d6fa6a
NC		 5610 case SHF_WRITE: sindex = 0; break;
5611 case SHF_ALLOC: sindex = 1; break;
5612 case SHF_EXECINSTR: sindex = 2; break;
5613 case SHF_MERGE: sindex = 3; break;
5614 case SHF_STRINGS: sindex = 4; break;
5615 case SHF_INFO_LINK: sindex = 5; break;
5616 case SHF_LINK_ORDER: sindex = 6; break;
5617 case SHF_OS_NONCONFORMING: sindex = 7; break;
5618 case SHF_GROUP: sindex = 8; break;
5619 case SHF_TLS: sindex = 9; break;
18ae9cc1 5620 case SHF_EXCLUDE: sindex = 18; break;
77115a4a 5621 case SHF_COMPRESSED: sindex = 20; break;
a91e1603 5622 case SHF_GNU_MBIND: sindex = 24; break;
76da6bbe 5623
5477e8a0 5624 default:
91d6fa6a 5625 sindex = -1;
cfcac11d 5626 switch (elf_header.e_machine)
148b93f2 5627 {
cfcac11d 5628 case EM_IA_64:
148b93f2 5629 if (flag == SHF_IA_64_SHORT)
91d6fa6a 5630 sindex = 10;
148b93f2 5631 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 5632 sindex = 11;
148b93f2
NC		 5633#ifdef BFD64
5634 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5635 switch (flag)
5636 {
91d6fa6a
NC		 5637 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5638 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5639 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5640 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5641 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5642 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 5643 default: break;
5644 }
5645#endif
cfcac11d
NC		 5646 break;
5647
caa83f8b 5648 case EM_386:
22abe556 5649 case EM_IAMCU:
caa83f8b 5650 case EM_X86_64:
7f502d6c 5651 case EM_L1OM:
7a9068fe 5652 case EM_K1OM:
cfcac11d
NC		 5653 case EM_OLD_SPARCV9:
5654 case EM_SPARC32PLUS:
5655 case EM_SPARCV9:
5656 case EM_SPARC:
18ae9cc1 5657 if (flag == SHF_ORDERED)
91d6fa6a 5658 sindex = 19;
cfcac11d 5659 break;
ac4c9b04
MG		 5660
5661 case EM_ARM:
5662 switch (flag)
5663 {
5664 case SHF_ENTRYSECT: sindex = 21; break;
f0728ee3 5665 case SHF_ARM_PURECODE: sindex = 22; break;
ac4c9b04
MG		 5666 case SHF_COMDEF: sindex = 23; break;
5667 default: break;
5668 }
5669 break;
5670
cfcac11d
NC		 5671 default:
5672 break;
148b93f2 5673 }
5477e8a0
L		 5674 }
5675
91d6fa6a 5676 if (sindex != -1)
5477e8a0 5677 {
8d5ff12c
L		 5678 if (p != buff + field_size + 4)
5679 {
5680 if (size < (10 + 2))
bee0ee85
NC		 5681 {
5682 warn (_("Internal error: not enough buffer room for section flag info"));
5683 return _("<unknown>");
5684 }
8d5ff12c
L		 5685 size -= 2;
5686 *p++ = ',';
5687 *p++ = ' ';
5688 }
5689
91d6fa6a
NC		 5690 size -= flags [sindex].len;
5691 p = stpcpy (p, flags [sindex].str);
5477e8a0 5692 }
3b22753a 5693 else if (flag & SHF_MASKOS)
8d5ff12c 5694 os_flags |= flag;
d1133906 5695 else if (flag & SHF_MASKPROC)
8d5ff12c 5696 proc_flags |= flag;
d1133906 5697 else
8d5ff12c 5698 unknown_flags |= flag;
5477e8a0
L		 5699 }
5700 else
5701 {
5702 switch (flag)
5703 {
5704 case SHF_WRITE: *p = 'W'; break;
5705 case SHF_ALLOC: *p = 'A'; break;
5706 case SHF_EXECINSTR: *p = 'X'; break;
5707 case SHF_MERGE: *p = 'M'; break;
5708 case SHF_STRINGS: *p = 'S'; break;
5709 case SHF_INFO_LINK: *p = 'I'; break;
5710 case SHF_LINK_ORDER: *p = 'L'; break;
5711 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5712 case SHF_GROUP: *p = 'G'; break;
5713 case SHF_TLS: *p = 'T'; break;
18ae9cc1 5714 case SHF_EXCLUDE: *p = 'E'; break;
77115a4a 5715 case SHF_COMPRESSED: *p = 'C'; break;
a91e1603 5716 case SHF_GNU_MBIND: *p = 'D'; break;
5477e8a0
L		 5717
5718 default:
8a9036a4 5719 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 5720 || elf_header.e_machine == EM_L1OM
5721 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 5722 && flag == SHF_X86_64_LARGE)
5723 *p = 'l';
91f68a68 5724 else if (elf_header.e_machine == EM_ARM
f0728ee3 5725 && flag == SHF_ARM_PURECODE)
91f68a68 5726 *p = 'y';
5477e8a0
L		 5727 else if (flag & SHF_MASKOS)
5728 {
5729 *p = 'o';
5730 sh_flags &= ~ SHF_MASKOS;
5731 }
5732 else if (flag & SHF_MASKPROC)
5733 {
5734 *p = 'p';
5735 sh_flags &= ~ SHF_MASKPROC;
5736 }
5737 else
5738 *p = 'x';
5739 break;
5740 }
5741 p++;
d1133906
NC		 5742 }
5743 }
76da6bbe 5744
8d5ff12c
L		 5745 if (do_section_details)
5746 {
5747 if (os_flags)
5748 {
5749 size -= 5 + field_size;
5750 if (p != buff + field_size + 4)
5751 {
5752 if (size < (2 + 1))
bee0ee85
NC		 5753 {
5754 warn (_("Internal error: not enough buffer room for section flag info"));
5755 return _("<unknown>");
5756 }
8d5ff12c
L		 5757 size -= 2;
5758 *p++ = ',';
5759 *p++ = ' ';
5760 }
5761 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5762 (unsigned long) os_flags);
5763 p += 5 + field_size;
5764 }
5765 if (proc_flags)
5766 {
5767 size -= 7 + field_size;
5768 if (p != buff + field_size + 4)
5769 {
5770 if (size < (2 + 1))
bee0ee85
NC		 5771 {
5772 warn (_("Internal error: not enough buffer room for section flag info"));
5773 return _("<unknown>");
5774 }
8d5ff12c
L		 5775 size -= 2;
5776 *p++ = ',';
5777 *p++ = ' ';
5778 }
5779 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5780 (unsigned long) proc_flags);
5781 p += 7 + field_size;
5782 }
5783 if (unknown_flags)
5784 {
5785 size -= 10 + field_size;
5786 if (p != buff + field_size + 4)
5787 {
5788 if (size < (2 + 1))
bee0ee85
NC		 5789 {
5790 warn (_("Internal error: not enough buffer room for section flag info"));
5791 return _("<unknown>");
5792 }
8d5ff12c
L		 5793 size -= 2;
5794 *p++ = ',';
5795 *p++ = ' ';
5796 }
2b692964 5797 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 5798 (unsigned long) unknown_flags);
5799 p += 10 + field_size;
5800 }
5801 }
5802
e9e44622 5803 *p = '\0';
d1133906
NC		 5804 return buff;
5805}
5806
77115a4a 5807static unsigned int
ebdf1ebf 5808get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
77115a4a
L		 5809{
5810 if (is_32bit_elf)
5811 {
5812 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
d8024a91 5813
ebdf1ebf
NC		 5814 if (size < sizeof (* echdr))
5815 {
5816 error (_("Compressed section is too small even for a compression header\n"));
5817 return 0;
5818 }
5819
77115a4a
L		 5820 chdr->ch_type = BYTE_GET (echdr->ch_type);
5821 chdr->ch_size = BYTE_GET (echdr->ch_size);
5822 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5823 return sizeof (*echdr);
5824 }
5825 else
5826 {
5827 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
d8024a91 5828
ebdf1ebf
NC		 5829 if (size < sizeof (* echdr))
5830 {
5831 error (_("Compressed section is too small even for a compression header\n"));
5832 return 0;
5833 }
5834
77115a4a
L		 5835 chdr->ch_type = BYTE_GET (echdr->ch_type);
5836 chdr->ch_size = BYTE_GET (echdr->ch_size);
5837 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5838 return sizeof (*echdr);
5839 }
5840}
5841
32ec8896 5842static bfd_boolean
2cf0635d 5843process_section_headers (FILE * file)
252b5132 5844{
2cf0635d 5845 Elf_Internal_Shdr * section;
b34976b6 5846 unsigned int i;
252b5132
RH		 5847
5848 section_headers = NULL;
5849
5850 if (elf_header.e_shnum == 0)
5851 {
82f2dbf7
NC		 5852 /* PR binutils/12467. */
5853 if (elf_header.e_shoff != 0)
32ec8896
NC		 5854 {
5855 warn (_("possibly corrupt ELF file header - it has a non-zero"
5856 " section header offset, but no section headers\n"));
5857 return FALSE;
5858 }
82f2dbf7 5859 else if (do_sections)
252b5132
RH		 5860 printf (_("\nThere are no sections in this file.\n"));
5861
32ec8896 5862 return TRUE;
252b5132
RH		 5863 }
5864
5865 if (do_sections && !do_header)
9ea033b2 5866 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 5867 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5868
9ea033b2
NC		 5869 if (is_32bit_elf)
5870 {
049b0c3a 5871 if (! get_32bit_section_headers (file, FALSE))
32ec8896
NC		 5872 return FALSE;
5873 }
5874 else
5875 {
5876 if (! get_64bit_section_headers (file, FALSE))
5877 return FALSE;
9ea033b2 5878 }
252b5132
RH		 5879
5880 /* Read in the string table, so that we have names to display. */
0b49d371 5881 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 5882 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 5883 {
4fbb74a6 5884 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 5885
c256ffe7
JJ		 5886 if (section->sh_size != 0)
5887 {
3f5e193b
NC		 5888 string_table = (char *) get_data (NULL, file, section->sh_offset,
5889 1, section->sh_size,
5890 _("string table"));
0de14b54 5891
c256ffe7
JJ		 5892 string_table_length = string_table != NULL ? section->sh_size : 0;
5893 }
252b5132
RH		 5894 }
5895
5896 /* Scan the sections for the dynamic symbol table
e3c8793a 5897 and dynamic string table and debug sections. */
252b5132
RH		 5898 dynamic_symbols = NULL;
5899 dynamic_strings = NULL;
5900 dynamic_syminfo = NULL;
6a40cf0c 5901 symtab_shndx_list = NULL;
103f02d3 5902
89fac5e3
RS		 5903 eh_addr_size = is_32bit_elf ? 4 : 8;
5904 switch (elf_header.e_machine)
5905 {
5906 case EM_MIPS:
5907 case EM_MIPS_RS3_LE:
5908 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5909 FDE addresses. However, the ABI also has a semi-official ILP32
5910 variant for which the normal FDE address size rules apply.
5911
5912 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5913 section, where XX is the size of longs in bits. Unfortunately,
5914 earlier compilers provided no way of distinguishing ILP32 objects
5915 from LP64 objects, so if there's any doubt, we should assume that
5916 the official LP64 form is being used. */
5917 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5918 && find_section (".gcc_compiled_long32") == NULL)
5919 eh_addr_size = 8;
5920 break;
0f56a26a
DD		 5921
5922 case EM_H8_300:
5923 case EM_H8_300H:
5924 switch (elf_header.e_flags & EF_H8_MACH)
5925 {
5926 case E_H8_MACH_H8300:
5927 case E_H8_MACH_H8300HN:
5928 case E_H8_MACH_H8300SN:
5929 case E_H8_MACH_H8300SXN:
5930 eh_addr_size = 2;
5931 break;
5932 case E_H8_MACH_H8300H:
5933 case E_H8_MACH_H8300S:
5934 case E_H8_MACH_H8300SX:
5935 eh_addr_size = 4;
5936 break;
5937 }
f4236fe4
DD		 5938 break;
5939
ff7eeb89 5940 case EM_M32C_OLD:
f4236fe4
DD		 5941 case EM_M32C:
5942 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5943 {
5944 case EF_M32C_CPU_M16C:
5945 eh_addr_size = 2;
5946 break;
5947 }
5948 break;
89fac5e3
RS		 5949 }
5950
76ca31c0
NC		 5951#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5952 do \
5953 { \
5954 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5955 if (section->sh_entsize != expected_entsize) \
9dd3a467 5956 { \
76ca31c0
NC		 5957 char buf[40]; \
5958 sprintf_vma (buf, section->sh_entsize); \
5959 /* Note: coded this way so that there is a single string for \
5960 translation. */ \
5961 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5962 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5963 (unsigned) expected_entsize); \
9dd3a467 5964 section->sh_entsize = expected_entsize; \
76ca31c0
NC		 5965 } \
5966 } \
08d8fa11 5967 while (0)
9dd3a467
NC		 5968
5969#define CHECK_ENTSIZE(section, i, type) \
08d8fa11
JJ		 5970 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5971 sizeof (Elf64_External_##type))
5972
252b5132
RH		 5973 for (i = 0, section = section_headers;
5974 i < elf_header.e_shnum;
b34976b6 5975 i++, section++)
252b5132 5976 {
2cf0635d 5977 char * name = SECTION_NAME (section);
252b5132
RH		 5978
5979 if (section->sh_type == SHT_DYNSYM)
5980 {
5981 if (dynamic_symbols != NULL)
5982 {
5983 error (_("File contains multiple dynamic symbol tables\n"));
5984 continue;
5985 }
5986
08d8fa11 5987 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 5988 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 5989 }
5990 else if (section->sh_type == SHT_STRTAB
18bd398b 5991 && streq (name, ".dynstr"))
252b5132
RH		 5992 {
5993 if (dynamic_strings != NULL)
5994 {
5995 error (_("File contains multiple dynamic string tables\n"));
5996 continue;
5997 }
5998
3f5e193b
NC		 5999 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
6000 1, section->sh_size,
6001 _("dynamic strings"));
59245841 6002 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 6003 }
9ad5cbcf
AM		 6004 else if (section->sh_type == SHT_SYMTAB_SHNDX)
6005 {
6a40cf0c
NC		 6006 elf_section_list * entry = xmalloc (sizeof * entry);
6007 entry->hdr = section;
6008 entry->next = symtab_shndx_list;
6009 symtab_shndx_list = entry;
9ad5cbcf 6010 }
08d8fa11
JJ		 6011 else if (section->sh_type == SHT_SYMTAB)
6012 CHECK_ENTSIZE (section, i, Sym);
6013 else if (section->sh_type == SHT_GROUP)
6014 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6015 else if (section->sh_type == SHT_REL)
6016 CHECK_ENTSIZE (section, i, Rel);
6017 else if (section->sh_type == SHT_RELA)
6018 CHECK_ENTSIZE (section, i, Rela);
252b5132 6019 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 6020 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 6021 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC		 6022 || do_debug_str || do_debug_loc || do_debug_ranges
6023 || do_debug_addr || do_debug_cu_index)
1b315056
CS		 6024 && (const_strneq (name, ".debug_")
6025 || const_strneq (name, ".zdebug_")))
252b5132 6026 {
1b315056
CS		 6027 if (name[1] == 'z')
6028 name += sizeof (".zdebug_") - 1;
6029 else
6030 name += sizeof (".debug_") - 1;
252b5132
RH		 6031
6032 if (do_debugging
4723351a
CC		 6033 || (do_debug_info && const_strneq (name, "info"))
6034 || (do_debug_info && const_strneq (name, "types"))
6035 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
b40bf0a2
NC		 6036 || (do_debug_lines && strcmp (name, "line") == 0)
6037 || (do_debug_lines && const_strneq (name, "line."))
4723351a
CC		 6038 || (do_debug_pubnames && const_strneq (name, "pubnames"))
6039 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
459d52c8
DE		 6040 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6041 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
4723351a
CC		 6042 || (do_debug_aranges && const_strneq (name, "aranges"))
6043 || (do_debug_ranges && const_strneq (name, "ranges"))
77145576 6044 || (do_debug_ranges && const_strneq (name, "rnglists"))
4723351a
CC		 6045 || (do_debug_frames && const_strneq (name, "frame"))
6046 || (do_debug_macinfo && const_strneq (name, "macinfo"))
6047 || (do_debug_macinfo && const_strneq (name, "macro"))
6048 || (do_debug_str && const_strneq (name, "str"))
6049 || (do_debug_loc && const_strneq (name, "loc"))
77145576 6050 || (do_debug_loc && const_strneq (name, "loclists"))
657d0d47
CC		 6051 || (do_debug_addr && const_strneq (name, "addr"))
6052 || (do_debug_cu_index && const_strneq (name, "cu_index"))
6053 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 6054 )
09c11c86 6055 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 6056 }
a262ae96 6057 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 6058 else if ((do_debugging || do_debug_info)
0112cd26 6059 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 6060 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 6061 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 6062 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 6063 else if (do_gdb_index && streq (name, ".gdb_index"))
6064 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 6065 /* Trace sections for Itanium VMS. */
6066 else if ((do_debugging || do_trace_info || do_trace_abbrevs
6067 || do_trace_aranges)
6068 && const_strneq (name, ".trace_"))
6069 {
6070 name += sizeof (".trace_") - 1;
6071
6072 if (do_debugging
6073 || (do_trace_info && streq (name, "info"))
6074 || (do_trace_abbrevs && streq (name, "abbrev"))
6075 || (do_trace_aranges && streq (name, "aranges"))
6076 )
6077 request_dump_bynumber (i, DEBUG_DUMP);
6078 }
252b5132
RH		 6079 }
6080
6081 if (! do_sections)
32ec8896 6082 return TRUE;
252b5132 6083
3a1a2036
NC		 6084 if (elf_header.e_shnum > 1)
6085 printf (_("\nSection Headers:\n"));
6086 else
6087 printf (_("\nSection Header:\n"));
76da6bbe 6088
f7a99963 6089 if (is_32bit_elf)
595cf52e 6090 {
5477e8a0 6091 if (do_section_details)
595cf52e
L		 6092 {
6093 printf (_(" [Nr] Name\n"));
5477e8a0 6094 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 6095 }
6096 else
6097 printf
6098 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6099 }
d974e256 6100 else if (do_wide)
595cf52e 6101 {
5477e8a0 6102 if (do_section_details)
595cf52e
L		 6103 {
6104 printf (_(" [Nr] Name\n"));
5477e8a0 6105 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 6106 }
6107 else
6108 printf
6109 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6110 }
f7a99963
NC		 6111 else
6112 {
5477e8a0 6113 if (do_section_details)
595cf52e
L		 6114 {
6115 printf (_(" [Nr] Name\n"));
5477e8a0
L		 6116 printf (_(" Type Address Offset Link\n"));
6117 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 6118 }
6119 else
6120 {
6121 printf (_(" [Nr] Name Type Address Offset\n"));
6122 printf (_(" Size EntSize Flags Link Info Align\n"));
6123 }
f7a99963 6124 }
252b5132 6125
5477e8a0
L		 6126 if (do_section_details)
6127 printf (_(" Flags\n"));
6128
252b5132
RH		 6129 for (i = 0, section = section_headers;
6130 i < elf_header.e_shnum;
b34976b6 6131 i++, section++)
252b5132 6132 {
dd905818
NC		 6133 /* Run some sanity checks on the section header. */
6134
6135 /* Check the sh_link field. */
6136 switch (section->sh_type)
6137 {
6138 case SHT_SYMTAB_SHNDX:
6139 case SHT_GROUP:
6140 case SHT_HASH:
6141 case SHT_GNU_HASH:
6142 case SHT_GNU_versym:
6143 case SHT_REL:
6144 case SHT_RELA:
6145 if (section->sh_link < 1
cb64e50d 6146 || section->sh_link >= elf_header.e_shnum
dd905818
NC		 6147 || (section_headers[section->sh_link].sh_type != SHT_SYMTAB
6148 && section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6149 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6150 i, section->sh_link);
6151 break;
6152
6153 case SHT_DYNAMIC:
6154 case SHT_SYMTAB:
6155 case SHT_DYNSYM:
6156 case SHT_GNU_verneed:
6157 case SHT_GNU_verdef:
6158 case SHT_GNU_LIBLIST:
6159 if (section->sh_link < 1
cb64e50d 6160 || section->sh_link >= elf_header.e_shnum
dd905818
NC		 6161 || section_headers[section->sh_link].sh_type != SHT_STRTAB)
6162 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6163 i, section->sh_link);
6164 break;
6165
6166 case SHT_INIT_ARRAY:
6167 case SHT_FINI_ARRAY:
6168 case SHT_PREINIT_ARRAY:
6169 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6170 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6171 i, section->sh_link);
6172 break;
6173
6174 default:
6175 /* FIXME: Add support for target specific section types. */
6176#if 0 /* Currently we do not check other section types as there are too
6177 many special cases. Stab sections for example have a type
6178 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6179 section. */
6180 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6181 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6182 i, section->sh_link);
6183#endif
6184 break;
6185 }
6186
6187 /* Check the sh_info field. */
6188 switch (section->sh_type)
6189 {
6190 case SHT_REL:
6191 case SHT_RELA:
6192 if (section->sh_info < 1
cb64e50d 6193 || section->sh_info >= elf_header.e_shnum
dd905818
NC		 6194 || (section_headers[section->sh_info].sh_type != SHT_PROGBITS
6195 && section_headers[section->sh_info].sh_type != SHT_NOBITS
6196 && section_headers[section->sh_info].sh_type != SHT_NOTE
6197 && section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6198 /* FIXME: Are other section types valid ? */
6199 && section_headers[section->sh_info].sh_type < SHT_LOOS))
6200 {
6201 if (section->sh_info == 0
6202 && (streq (SECTION_NAME (section), ".rel.dyn")
6203 || streq (SECTION_NAME (section), ".rela.dyn")))
6204 /* The .rel.dyn and .rela.dyn sections have an sh_info field
4d74727a
AM		 6205 of zero. The relocations in these sections may apply
6206 to many different sections. */
dd905818
NC		 6207 ;
6208 else
6209 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6210 i, section->sh_info);
6211 }
6212 break;
6213
6214 case SHT_DYNAMIC:
6215 case SHT_HASH:
6216 case SHT_SYMTAB_SHNDX:
6217 case SHT_INIT_ARRAY:
6218 case SHT_FINI_ARRAY:
6219 case SHT_PREINIT_ARRAY:
6220 if (section->sh_info != 0)
6221 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6222 i, section->sh_info);
6223 break;
6224
6225 case SHT_GROUP:
6226 case SHT_SYMTAB:
6227 case SHT_DYNSYM:
6228 /* A symbol index - we assume that it is valid. */
6229 break;
6230
6231 default:
6232 /* FIXME: Add support for target specific section types. */
6233 if (section->sh_type == SHT_NOBITS)
6234 /* NOBITS section headers with non-zero sh_info fields can be
6235 created when a binary is stripped of everything but its debug
1a9ccd70
NC		 6236 information. The stripped sections have their headers
6237 preserved but their types set to SHT_NOBITS. So do not check
6238 this type of section. */
dd905818
NC		 6239 ;
6240 else if (section->sh_flags & SHF_INFO_LINK)
6241 {
cb64e50d 6242 if (section->sh_info < 1 || section->sh_info >= elf_header.e_shnum)
dd905818
NC		 6243 warn (_("[%2u]: Expected link to another section in info field"), i);
6244 }
a91e1603
L		 6245 else if (section->sh_type < SHT_LOOS
6246 && (section->sh_flags & SHF_GNU_MBIND) == 0
6247 && section->sh_info != 0)
dd905818
NC		 6248 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6249 i, section->sh_info);
6250 break;
6251 }
6252
3e6b6445
NC		 6253 /* Check the sh_size field. */
6254 if (section->sh_size > current_file_size
6255 && section->sh_type != SHT_NOBITS
6256 && section->sh_type != SHT_NULL
6257 && section->sh_type < SHT_LOOS)
6258 warn (_("Size of section %u is larger than the entire file!\n"), i);
6259
7bfd842d 6260 printf (" [%2u] ", i);
5477e8a0 6261 if (do_section_details)
74e1a04b 6262 printf ("%s\n ", printable_section_name (section));
595cf52e 6263 else
74e1a04b 6264 print_symbol (-17, SECTION_NAME (section));
0b4362b0 6265
ea52a088
NC		 6266 printf (do_wide ? " %-15s " : " %-15.15s ",
6267 get_section_type_name (section->sh_type));
0b4362b0 6268
f7a99963
NC		 6269 if (is_32bit_elf)
6270 {
cfcac11d
NC		 6271 const char * link_too_big = NULL;
6272
f7a99963 6273 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 6274
f7a99963
NC		 6275 printf ( " %6.6lx %6.6lx %2.2lx",
6276 (unsigned long) section->sh_offset,
6277 (unsigned long) section->sh_size,
6278 (unsigned long) section->sh_entsize);
d1133906 6279
5477e8a0
L		 6280 if (do_section_details)
6281 fputs (" ", stdout);
6282 else
6283 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 6284
cfcac11d
NC		 6285 if (section->sh_link >= elf_header.e_shnum)
6286 {
6287 link_too_big = "";
6288 /* The sh_link value is out of range. Normally this indicates
caa83f8b 6289 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 6290 switch (elf_header.e_machine)
6291 {
caa83f8b 6292 case EM_386:
22abe556 6293 case EM_IAMCU:
caa83f8b 6294 case EM_X86_64:
7f502d6c 6295 case EM_L1OM:
7a9068fe 6296 case EM_K1OM:
cfcac11d
NC		 6297 case EM_OLD_SPARCV9:
6298 case EM_SPARC32PLUS:
6299 case EM_SPARCV9:
6300 case EM_SPARC:
6301 if (section->sh_link == (SHN_BEFORE & 0xffff))
6302 link_too_big = "BEFORE";
6303 else if (section->sh_link == (SHN_AFTER & 0xffff))
6304 link_too_big = "AFTER";
6305 break;
6306 default:
6307 break;
6308 }
6309 }
6310
6311 if (do_section_details)
6312 {
6313 if (link_too_big != NULL && * link_too_big)
6314 printf ("<%s> ", link_too_big);
6315 else
6316 printf ("%2u ", section->sh_link);
6317 printf ("%3u %2lu\n", section->sh_info,
6318 (unsigned long) section->sh_addralign);
6319 }
6320 else
6321 printf ("%2u %3u %2lu\n",
6322 section->sh_link,
6323 section->sh_info,
6324 (unsigned long) section->sh_addralign);
6325
6326 if (link_too_big && ! * link_too_big)
6327 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6328 i, section->sh_link);
f7a99963 6329 }
d974e256
JJ		 6330 else if (do_wide)
6331 {
6332 print_vma (section->sh_addr, LONG_HEX);
6333
6334 if ((long) section->sh_offset == section->sh_offset)
6335 printf (" %6.6lx", (unsigned long) section->sh_offset);
6336 else
6337 {
6338 putchar (' ');
6339 print_vma (section->sh_offset, LONG_HEX);
6340 }
6341
6342 if ((unsigned long) section->sh_size == section->sh_size)
6343 printf (" %6.6lx", (unsigned long) section->sh_size);
6344 else
6345 {
6346 putchar (' ');
6347 print_vma (section->sh_size, LONG_HEX);
6348 }
6349
6350 if ((unsigned long) section->sh_entsize == section->sh_entsize)
6351 printf (" %2.2lx", (unsigned long) section->sh_entsize);
6352 else
6353 {
6354 putchar (' ');
6355 print_vma (section->sh_entsize, LONG_HEX);
6356 }
6357
5477e8a0
L		 6358 if (do_section_details)
6359 fputs (" ", stdout);
6360 else
6361 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 6362
72de5009 6363 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 6364
6365 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 6366 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 6367 else
6368 {
6369 print_vma (section->sh_addralign, DEC);
6370 putchar ('\n');
6371 }
6372 }
5477e8a0 6373 else if (do_section_details)
595cf52e 6374 {
5477e8a0 6375 printf (" %-15.15s ",
595cf52e 6376 get_section_type_name (section->sh_type));
595cf52e
L		 6377 print_vma (section->sh_addr, LONG_HEX);
6378 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 6379 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 6380 else
6381 {
6382 printf (" ");
6383 print_vma (section->sh_offset, LONG_HEX);
6384 }
72de5009 6385 printf (" %u\n ", section->sh_link);
595cf52e 6386 print_vma (section->sh_size, LONG_HEX);
5477e8a0 6387 putchar (' ');
595cf52e
L		 6388 print_vma (section->sh_entsize, LONG_HEX);
6389
72de5009
AM		 6390 printf (" %-16u %lu\n",
6391 section->sh_info,
595cf52e
L		 6392 (unsigned long) section->sh_addralign);
6393 }
f7a99963
NC		 6394 else
6395 {
6396 putchar (' ');
6397 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 6398 if ((long) section->sh_offset == section->sh_offset)
6399 printf (" %8.8lx", (unsigned long) section->sh_offset);
6400 else
6401 {
6402 printf (" ");
6403 print_vma (section->sh_offset, LONG_HEX);
6404 }
f7a99963
NC		 6405 printf ("\n ");
6406 print_vma (section->sh_size, LONG_HEX);
6407 printf (" ");
6408 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 6409
d1133906 6410 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 6411
72de5009
AM		 6412 printf (" %2u %3u %lu\n",
6413 section->sh_link,
6414 section->sh_info,
f7a99963
NC		 6415 (unsigned long) section->sh_addralign);
6416 }
5477e8a0
L		 6417
6418 if (do_section_details)
77115a4a
L		 6419 {
6420 printf (" %s\n", get_elf_section_flags (section->sh_flags));
6421 if ((section->sh_flags & SHF_COMPRESSED) != 0)
6422 {
6423 /* Minimum section size is 12 bytes for 32-bit compression
6424 header + 12 bytes for compressed data header. */
6425 unsigned char buf[24];
d8024a91 6426
77115a4a
L		 6427 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6428 if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
6429 sizeof (buf), _("compression header")))
6430 {
6431 Elf_Internal_Chdr chdr;
d8024a91 6432
ebdf1ebf 6433 (void) get_compression_header (&chdr, buf, sizeof (buf));
d8024a91 6434
77115a4a
L		 6435 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6436 printf (" ZLIB, ");
6437 else
6438 printf (_(" [<unknown>: 0x%x], "),
6439 chdr.ch_type);
6440 print_vma (chdr.ch_size, LONG_HEX);
6441 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6442 }
6443 }
6444 }
252b5132
RH		 6445 }
6446
5477e8a0 6447 if (!do_section_details)
3dbcc61d 6448 {
9fb71ee4
NC		 6449 /* The ordering of the letters shown here matches the ordering of the
6450 corresponding SHF_xxx values, and hence the order in which these
6451 letters will be displayed to the user. */
6452 printf (_("Key to Flags:\n\
6453 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6454 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
fd85a6a1 6455 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
3dbcc61d 6456 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 6457 || elf_header.e_machine == EM_L1OM
6458 || elf_header.e_machine == EM_K1OM)
9fb71ee4 6459 printf (_("l (large), "));
91f68a68 6460 else if (elf_header.e_machine == EM_ARM)
f0728ee3 6461 printf (_("y (purecode), "));
9fb71ee4 6462 printf ("p (processor specific)\n");
0b4362b0 6463 }
d1133906 6464
32ec8896 6465 return TRUE;
252b5132
RH		 6466}
6467
f5842774
L		 6468static const char *
6469get_group_flags (unsigned int flags)
6470{
1449284b 6471 static char buff[128];
220453ec 6472
6d913794
NC		 6473 if (flags == 0)
6474 return "";
6475 else if (flags == GRP_COMDAT)
6476 return "COMDAT ";
f5842774 6477
6d913794
NC		 6478 snprintf (buff, 14, _("[0x%x: "), flags);
6479
6480 flags &= ~ GRP_COMDAT;
6481 if (flags & GRP_MASKOS)
6482 {
6483 strcat (buff, "<OS specific>");
6484 flags &= ~ GRP_MASKOS;
f5842774 6485 }
6d913794
NC		 6486
6487 if (flags & GRP_MASKPROC)
6488 {
6489 strcat (buff, "<PROC specific>");
6490 flags &= ~ GRP_MASKPROC;
6491 }
6492
6493 if (flags)
6494 strcat (buff, "<unknown>");
6495
6496 strcat (buff, "]");
f5842774
L		 6497 return buff;
6498}
6499
32ec8896 6500static bfd_boolean
2cf0635d 6501process_section_groups (FILE * file)
f5842774 6502{
2cf0635d 6503 Elf_Internal_Shdr * section;
f5842774 6504 unsigned int i;
2cf0635d
NC		 6505 struct group * group;
6506 Elf_Internal_Shdr * symtab_sec;
6507 Elf_Internal_Shdr * strtab_sec;
6508 Elf_Internal_Sym * symtab;
ba5cdace 6509 unsigned long num_syms;
2cf0635d 6510 char * strtab;
c256ffe7 6511 size_t strtab_size;
d1f5c6e3
L		 6512
6513 /* Don't process section groups unless needed. */
6514 if (!do_unwind && !do_section_groups)
32ec8896 6515 return TRUE;
f5842774
L		 6516
6517 if (elf_header.e_shnum == 0)
6518 {
6519 if (do_section_groups)
82f2dbf7 6520 printf (_("\nThere are no sections to group in this file.\n"));
f5842774 6521
32ec8896 6522 return TRUE;
f5842774
L		 6523 }
6524
6525 if (section_headers == NULL)
6526 {
6527 error (_("Section headers are not available!\n"));
fa1908fd 6528 /* PR 13622: This can happen with a corrupt ELF header. */
32ec8896 6529 return FALSE;
f5842774
L		 6530 }
6531
3f5e193b
NC		 6532 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
6533 sizeof (struct group *));
e4b17d5c
L		 6534
6535 if (section_headers_groups == NULL)
6536 {
8b73c356
NC		 6537 error (_("Out of memory reading %u section group headers\n"),
6538 elf_header.e_shnum);
32ec8896 6539 return FALSE;
e4b17d5c
L		 6540 }
6541
f5842774 6542 /* Scan the sections for the group section. */
d1f5c6e3 6543 group_count = 0;
f5842774
L		 6544 for (i = 0, section = section_headers;
6545 i < elf_header.e_shnum;
6546 i++, section++)
e4b17d5c
L		 6547 if (section->sh_type == SHT_GROUP)
6548 group_count++;
6549
d1f5c6e3
L		 6550 if (group_count == 0)
6551 {
6552 if (do_section_groups)
6553 printf (_("\nThere are no section groups in this file.\n"));
6554
32ec8896 6555 return TRUE;
d1f5c6e3
L		 6556 }
6557
3f5e193b 6558 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 6559
6560 if (section_groups == NULL)
6561 {
8b73c356
NC		 6562 error (_("Out of memory reading %lu groups\n"),
6563 (unsigned long) group_count);
32ec8896 6564 return FALSE;
e4b17d5c
L		 6565 }
6566
d1f5c6e3
L		 6567 symtab_sec = NULL;
6568 strtab_sec = NULL;
6569 symtab = NULL;
ba5cdace 6570 num_syms = 0;
d1f5c6e3 6571 strtab = NULL;
c256ffe7 6572 strtab_size = 0;
e4b17d5c
L		 6573 for (i = 0, section = section_headers, group = section_groups;
6574 i < elf_header.e_shnum;
6575 i++, section++)
f5842774
L		 6576 {
6577 if (section->sh_type == SHT_GROUP)
6578 {
74e1a04b
NC		 6579 const char * name = printable_section_name (section);
6580 const char * group_name;
2cf0635d
NC		 6581 unsigned char * start;
6582 unsigned char * indices;
f5842774 6583 unsigned int entry, j, size;
2cf0635d
NC		 6584 Elf_Internal_Shdr * sec;
6585 Elf_Internal_Sym * sym;
f5842774
L		 6586
6587 /* Get the symbol table. */
4fbb74a6
AM		 6588 if (section->sh_link >= elf_header.e_shnum
6589 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 6590 != SHT_SYMTAB))
f5842774
L		 6591 {
6592 error (_("Bad sh_link in group section `%s'\n"), name);
6593 continue;
6594 }
d1f5c6e3
L		 6595
6596 if (symtab_sec != sec)
6597 {
6598 symtab_sec = sec;
6599 if (symtab)
6600 free (symtab);
ba5cdace 6601 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 6602 }
f5842774 6603
dd24e3da
NC		 6604 if (symtab == NULL)
6605 {
6606 error (_("Corrupt header in group section `%s'\n"), name);
6607 continue;
6608 }
6609
ba5cdace
NC		 6610 if (section->sh_info >= num_syms)
6611 {
6612 error (_("Bad sh_info in group section `%s'\n"), name);
6613 continue;
6614 }
6615
f5842774
L		 6616 sym = symtab + section->sh_info;
6617
6618 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6619 {
4fbb74a6
AM		 6620 if (sym->st_shndx == 0
6621 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 6622 {
6623 error (_("Bad sh_info in group section `%s'\n"), name);
6624 continue;
6625 }
ba2685cc 6626
4fbb74a6 6627 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 6628 strtab_sec = NULL;
6629 if (strtab)
6630 free (strtab);
f5842774 6631 strtab = NULL;
c256ffe7 6632 strtab_size = 0;
f5842774
L		 6633 }
6634 else
6635 {
6636 /* Get the string table. */
4fbb74a6 6637 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 6638 {
6639 strtab_sec = NULL;
6640 if (strtab)
6641 free (strtab);
6642 strtab = NULL;
6643 strtab_size = 0;
6644 }
6645 else if (strtab_sec
4fbb74a6 6646 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 6647 {
6648 strtab_sec = sec;
6649 if (strtab)
6650 free (strtab);
071436c6 6651
3f5e193b 6652 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
071436c6
NC		 6653 1, strtab_sec->sh_size,
6654 _("string table"));
c256ffe7 6655 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 6656 }
c256ffe7 6657 group_name = sym->st_name < strtab_size
2b692964 6658 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 6659 }
6660
c9c1d674
EG		 6661 /* PR 17531: file: loop. */
6662 if (section->sh_entsize > section->sh_size)
6663 {
6664 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6665 printable_section_name (section),
8066deb1
AM		 6666 (unsigned long) section->sh_entsize,
6667 (unsigned long) section->sh_size);
c9c1d674
EG		 6668 break;
6669 }
6670
3f5e193b
NC		 6671 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6672 1, section->sh_size,
6673 _("section data"));
59245841
NC		 6674 if (start == NULL)
6675 continue;
f5842774
L		 6676
6677 indices = start;
6678 size = (section->sh_size / section->sh_entsize) - 1;
6679 entry = byte_get (indices, 4);
6680 indices += 4;
e4b17d5c
L		 6681
6682 if (do_section_groups)
6683 {
2b692964 6684 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 6685 get_group_flags (entry), i, name, group_name, size);
ba2685cc 6686
e4b17d5c
L		 6687 printf (_(" [Index] Name\n"));
6688 }
6689
6690 group->group_index = i;
6691
f5842774
L		 6692 for (j = 0; j < size; j++)
6693 {
2cf0635d 6694 struct group_list * g;
e4b17d5c 6695
f5842774
L		 6696 entry = byte_get (indices, 4);
6697 indices += 4;
6698
4fbb74a6 6699 if (entry >= elf_header.e_shnum)
391cb864 6700 {
57028622
NC		 6701 static unsigned num_group_errors = 0;
6702
6703 if (num_group_errors ++ < 10)
6704 {
6705 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6706 entry, i, elf_header.e_shnum - 1);
6707 if (num_group_errors == 10)
6708 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6709 }
391cb864
L		 6710 continue;
6711 }
391cb864 6712
4fbb74a6 6713 if (section_headers_groups [entry] != NULL)
e4b17d5c 6714 {
d1f5c6e3
L		 6715 if (entry)
6716 {
57028622
NC		 6717 static unsigned num_errs = 0;
6718
6719 if (num_errs ++ < 10)
6720 {
6721 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6722 entry, i,
6723 section_headers_groups [entry]->group_index);
6724 if (num_errs == 10)
6725 warn (_("Further error messages about already contained group sections suppressed\n"));
6726 }
d1f5c6e3
L		 6727 continue;
6728 }
6729 else
6730 {
6731 /* Intel C/C++ compiler may put section 0 in a
32ec8896 6732 section group. We just warn it the first time
d1f5c6e3 6733 and ignore it afterwards. */
32ec8896 6734 static bfd_boolean warned = FALSE;
d1f5c6e3
L		 6735 if (!warned)
6736 {
6737 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 6738 section_headers_groups [entry]->group_index);
32ec8896 6739 warned = TRUE;
d1f5c6e3
L		 6740 }
6741 }
e4b17d5c
L		 6742 }
6743
4fbb74a6 6744 section_headers_groups [entry] = group;
e4b17d5c
L		 6745
6746 if (do_section_groups)
6747 {
4fbb74a6 6748 sec = section_headers + entry;
74e1a04b 6749 printf (" [%5u] %s\n", entry, printable_section_name (sec));
ba2685cc
AM		 6750 }
6751
3f5e193b 6752 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 6753 g->section_index = entry;
6754 g->next = group->root;
6755 group->root = g;
f5842774
L		 6756 }
6757
f5842774
L		 6758 if (start)
6759 free (start);
e4b17d5c
L		 6760
6761 group++;
f5842774
L		 6762 }
6763 }
6764
d1f5c6e3
L		 6765 if (symtab)
6766 free (symtab);
6767 if (strtab)
6768 free (strtab);
32ec8896 6769 return TRUE;
f5842774
L		 6770}
6771
28f997cf
TG		 6772/* Data used to display dynamic fixups. */
6773
6774struct ia64_vms_dynfixup
6775{
6776 bfd_vma needed_ident; /* Library ident number. */
6777 bfd_vma needed; /* Index in the dstrtab of the library name. */
6778 bfd_vma fixup_needed; /* Index of the library. */
6779 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6780 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6781};
6782
6783/* Data used to display dynamic relocations. */
6784
6785struct ia64_vms_dynimgrela
6786{
6787 bfd_vma img_rela_cnt; /* Number of relocations. */
6788 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6789};
6790
6791/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6792 library). */
6793
32ec8896
NC		 6794static bfd_boolean
6795dump_ia64_vms_dynamic_fixups (FILE * file,
6796 struct ia64_vms_dynfixup * fixup,
6797 const char * strtab,
6798 unsigned int strtab_sz)
28f997cf 6799{
32ec8896 6800 Elf64_External_VMS_IMAGE_FIXUP * imfs;
28f997cf 6801 long i;
32ec8896 6802 const char * lib_name;
28f997cf
TG		 6803
6804 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6805 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6806 _("dynamic section image fixups"));
6807 if (!imfs)
32ec8896 6808 return FALSE;
28f997cf
TG		 6809
6810 if (fixup->needed < strtab_sz)
6811 lib_name = strtab + fixup->needed;
6812 else
6813 {
32ec8896 6814 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7f01b0c6 6815 (unsigned long) fixup->needed);
28f997cf
TG		 6816 lib_name = "???";
6817 }
6818 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6819 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6820 printf
6821 (_("Seg Offset Type SymVec DataType\n"));
6822
6823 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6824 {
6825 unsigned int type;
6826 const char *rtype;
6827
6828 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6829 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6830 type = BYTE_GET (imfs [i].type);
6831 rtype = elf_ia64_reloc_type (type);
6832 if (rtype == NULL)
6833 printf (" 0x%08x ", type);
6834 else
6835 printf (" %-32s ", rtype);
6836 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6837 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6838 }
6839
6840 free (imfs);
32ec8896 6841 return TRUE;
28f997cf
TG		 6842}
6843
6844/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6845
32ec8896 6846static bfd_boolean
28f997cf
TG		 6847dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6848{
6849 Elf64_External_VMS_IMAGE_RELA *imrs;
6850 long i;
6851
6852 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6853 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 6854 _("dynamic section image relocations"));
28f997cf 6855 if (!imrs)
32ec8896 6856 return FALSE;
28f997cf
TG		 6857
6858 printf (_("\nImage relocs\n"));
6859 printf
6860 (_("Seg Offset Type Addend Seg Sym Off\n"));
6861
6862 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6863 {
6864 unsigned int type;
6865 const char *rtype;
6866
6867 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6868 printf ("%08" BFD_VMA_FMT "x ",
6869 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6870 type = BYTE_GET (imrs [i].type);
6871 rtype = elf_ia64_reloc_type (type);
6872 if (rtype == NULL)
6873 printf ("0x%08x ", type);
6874 else
6875 printf ("%-31s ", rtype);
6876 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6877 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6878 printf ("%08" BFD_VMA_FMT "x\n",
6879 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6880 }
6881
6882 free (imrs);
32ec8896 6883 return TRUE;
28f997cf
TG		 6884}
6885
6886/* Display IA-64 OpenVMS dynamic relocations and fixups. */
6887
32ec8896 6888static bfd_boolean
28f997cf
TG		 6889process_ia64_vms_dynamic_relocs (FILE *file)
6890{
6891 struct ia64_vms_dynfixup fixup;
6892 struct ia64_vms_dynimgrela imgrela;
6893 Elf_Internal_Dyn *entry;
28f997cf
TG		 6894 bfd_vma strtab_off = 0;
6895 bfd_vma strtab_sz = 0;
6896 char *strtab = NULL;
32ec8896 6897 bfd_boolean res = TRUE;
28f997cf
TG		 6898
6899 memset (&fixup, 0, sizeof (fixup));
6900 memset (&imgrela, 0, sizeof (imgrela));
6901
6902 /* Note: the order of the entries is specified by the OpenVMS specs. */
6903 for (entry = dynamic_section;
6904 entry < dynamic_section + dynamic_nent;
6905 entry++)
6906 {
6907 switch (entry->d_tag)
6908 {
6909 case DT_IA_64_VMS_STRTAB_OFFSET:
6910 strtab_off = entry->d_un.d_val;
6911 break;
6912 case DT_STRSZ:
6913 strtab_sz = entry->d_un.d_val;
6914 if (strtab == NULL)
6915 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6916 1, strtab_sz, _("dynamic string section"));
6917 break;
6918
6919 case DT_IA_64_VMS_NEEDED_IDENT:
6920 fixup.needed_ident = entry->d_un.d_val;
6921 break;
6922 case DT_NEEDED:
6923 fixup.needed = entry->d_un.d_val;
6924 break;
6925 case DT_IA_64_VMS_FIXUP_NEEDED:
6926 fixup.fixup_needed = entry->d_un.d_val;
6927 break;
6928 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6929 fixup.fixup_rela_cnt = entry->d_un.d_val;
6930 break;
6931 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6932 fixup.fixup_rela_off = entry->d_un.d_val;
32ec8896
NC		 6933 if (! dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz))
6934 res = FALSE;
28f997cf 6935 break;
28f997cf
TG		 6936 case DT_IA_64_VMS_IMG_RELA_CNT:
6937 imgrela.img_rela_cnt = entry->d_un.d_val;
6938 break;
6939 case DT_IA_64_VMS_IMG_RELA_OFF:
6940 imgrela.img_rela_off = entry->d_un.d_val;
32ec8896
NC		 6941 if (! dump_ia64_vms_dynamic_relocs (file, &imgrela))
6942 res = FALSE;
28f997cf
TG		 6943 break;
6944
6945 default:
6946 break;
6947 }
6948 }
6949
6950 if (strtab != NULL)
6951 free (strtab);
6952
6953 return res;
6954}
6955
85b1c36d 6956static struct
566b0d53 6957{
2cf0635d 6958 const char * name;
566b0d53
L		 6959 int reloc;
6960 int size;
6961 int rela;
32ec8896
NC		 6962}
6963 dynamic_relocations [] =
566b0d53 6964{
32ec8896
NC		 6965 { "REL", DT_REL, DT_RELSZ, FALSE },
6966 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6967 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
566b0d53
L		 6968};
6969
252b5132 6970/* Process the reloc section. */
18bd398b 6971
32ec8896 6972static bfd_boolean
2cf0635d 6973process_relocs (FILE * file)
252b5132 6974{
b34976b6
AM		 6975 unsigned long rel_size;
6976 unsigned long rel_offset;
252b5132 6977
252b5132 6978 if (!do_reloc)
32ec8896 6979 return TRUE;
252b5132
RH		 6980
6981 if (do_using_dynamic)
6982 {
32ec8896 6983 int is_rela;
2cf0635d 6984 const char * name;
32ec8896 6985 bfd_boolean has_dynamic_reloc;
566b0d53 6986 unsigned int i;
0de14b54 6987
32ec8896 6988 has_dynamic_reloc = FALSE;
252b5132 6989
566b0d53 6990 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 6991 {
566b0d53
L		 6992 is_rela = dynamic_relocations [i].rela;
6993 name = dynamic_relocations [i].name;
6994 rel_size = dynamic_info [dynamic_relocations [i].size];
6995 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 6996
32ec8896
NC		 6997 if (rel_size)
6998 has_dynamic_reloc = TRUE;
566b0d53
L		 6999
7000 if (is_rela == UNKNOWN)
aa903cfb 7001 {
566b0d53
L		 7002 if (dynamic_relocations [i].reloc == DT_JMPREL)
7003 switch (dynamic_info[DT_PLTREL])
7004 {
7005 case DT_REL:
7006 is_rela = FALSE;
7007 break;
7008 case DT_RELA:
7009 is_rela = TRUE;
7010 break;
7011 }
aa903cfb 7012 }
252b5132 7013
566b0d53
L		 7014 if (rel_size)
7015 {
7016 printf
7017 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7018 name, rel_offset, rel_size);
252b5132 7019
d93f0186
NC		 7020 dump_relocations (file,
7021 offset_from_vma (file, rel_offset, rel_size),
7022 rel_size,
566b0d53 7023 dynamic_symbols, num_dynamic_syms,
bb4d2ac2 7024 dynamic_strings, dynamic_strings_length,
32ec8896 7025 is_rela, TRUE /* is_dynamic */);
566b0d53 7026 }
252b5132 7027 }
566b0d53 7028
28f997cf 7029 if (is_ia64_vms ())
32ec8896
NC		 7030 if (process_ia64_vms_dynamic_relocs (file))
7031 has_dynamic_reloc = TRUE;
28f997cf 7032
566b0d53 7033 if (! has_dynamic_reloc)
252b5132
RH		 7034 printf (_("\nThere are no dynamic relocations in this file.\n"));
7035 }
7036 else
7037 {
2cf0635d 7038 Elf_Internal_Shdr * section;
b34976b6 7039 unsigned long i;
32ec8896 7040 bfd_boolean found = FALSE;
252b5132
RH		 7041
7042 for (i = 0, section = section_headers;
7043 i < elf_header.e_shnum;
b34976b6 7044 i++, section++)
252b5132
RH		 7045 {
7046 if ( section->sh_type != SHT_RELA
7047 && section->sh_type != SHT_REL)
7048 continue;
7049
7050 rel_offset = section->sh_offset;
7051 rel_size = section->sh_size;
7052
7053 if (rel_size)
7054 {
2cf0635d 7055 Elf_Internal_Shdr * strsec;
b34976b6 7056 int is_rela;
103f02d3 7057
252b5132
RH		 7058 printf (_("\nRelocation section "));
7059
7060 if (string_table == NULL)
19936277 7061 printf ("%d", section->sh_name);
252b5132 7062 else
74e1a04b 7063 printf ("'%s'", printable_section_name (section));
252b5132
RH		 7064
7065 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7066 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
7067
d79b3d50
NC		 7068 is_rela = section->sh_type == SHT_RELA;
7069
4fbb74a6
AM		 7070 if (section->sh_link != 0
7071 && section->sh_link < elf_header.e_shnum)
af3fc3bc 7072 {
2cf0635d
NC		 7073 Elf_Internal_Shdr * symsec;
7074 Elf_Internal_Sym * symtab;
d79b3d50 7075 unsigned long nsyms;
c256ffe7 7076 unsigned long strtablen = 0;
2cf0635d 7077 char * strtab = NULL;
57346661 7078
4fbb74a6 7079 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 7080 if (symsec->sh_type != SHT_SYMTAB
7081 && symsec->sh_type != SHT_DYNSYM)
7082 continue;
7083
ba5cdace 7084 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 7085
af3fc3bc
AM		 7086 if (symtab == NULL)
7087 continue;
252b5132 7088
4fbb74a6
AM		 7089 if (symsec->sh_link != 0
7090 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 7091 {
4fbb74a6 7092 strsec = section_headers + symsec->sh_link;
103f02d3 7093
3f5e193b 7094 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
071436c6
NC		 7095 1, strsec->sh_size,
7096 _("string table"));
c256ffe7
JJ		 7097 strtablen = strtab == NULL ? 0 : strsec->sh_size;
7098 }
252b5132 7099
d79b3d50 7100 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2
L		 7101 symtab, nsyms, strtab, strtablen,
7102 is_rela,
7103 symsec->sh_type == SHT_DYNSYM);
d79b3d50
NC		 7104 if (strtab)
7105 free (strtab);
7106 free (symtab);
7107 }
7108 else
7109 dump_relocations (file, rel_offset, rel_size,
32ec8896
NC		 7110 NULL, 0, NULL, 0, is_rela,
7111 FALSE /* is_dynamic */);
252b5132 7112
32ec8896 7113 found = TRUE;
252b5132
RH		 7114 }
7115 }
7116
7117 if (! found)
7118 printf (_("\nThere are no relocations in this file.\n"));
7119 }
7120
32ec8896 7121 return TRUE;
252b5132
RH		 7122}
7123
4d6ed7c8
NC		 7124/* An absolute address consists of a section and an offset. If the
7125 section is NULL, the offset itself is the address, otherwise, the
7126 address equals to LOAD_ADDRESS(section) + offset. */
7127
7128struct absaddr
948f632f
DA		 7129{
7130 unsigned short section;
7131 bfd_vma offset;
7132};
4d6ed7c8 7133
1949de15
L		 7134#define ABSADDR(a) \
7135 ((a).section \
7136 ? section_headers [(a).section].sh_addr + (a).offset \
7137 : (a).offset)
7138
948f632f
DA		 7139/* Find the nearest symbol at or below ADDR. Returns the symbol
7140 name, if found, and the offset from the symbol to ADDR. */
4d6ed7c8 7141
4d6ed7c8 7142static void
2cf0635d 7143find_symbol_for_address (Elf_Internal_Sym * symtab,
948f632f
DA		 7144 unsigned long nsyms,
7145 const char * strtab,
7146 unsigned long strtab_size,
7147 struct absaddr addr,
7148 const char ** symname,
7149 bfd_vma * offset)
4d6ed7c8 7150{
d3ba0551 7151 bfd_vma dist = 0x100000;
2cf0635d 7152 Elf_Internal_Sym * sym;
948f632f
DA		 7153 Elf_Internal_Sym * beg;
7154 Elf_Internal_Sym * end;
2cf0635d 7155 Elf_Internal_Sym * best = NULL;
4d6ed7c8 7156
0b6ae522 7157 REMOVE_ARCH_BITS (addr.offset);
948f632f
DA		 7158 beg = symtab;
7159 end = symtab + nsyms;
0b6ae522 7160
948f632f 7161 while (beg < end)
4d6ed7c8 7162 {
948f632f
DA		 7163 bfd_vma value;
7164
7165 sym = beg + (end - beg) / 2;
0b6ae522 7166
948f632f 7167 value = sym->st_value;
0b6ae522
DJ		 7168 REMOVE_ARCH_BITS (value);
7169
948f632f 7170 if (sym->st_name != 0
4d6ed7c8 7171 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 7172 && addr.offset >= value
7173 && addr.offset - value < dist)
4d6ed7c8
NC		 7174 {
7175 best = sym;
0b6ae522 7176 dist = addr.offset - value;
4d6ed7c8
NC		 7177 if (!dist)
7178 break;
7179 }
948f632f
DA		 7180
7181 if (addr.offset < value)
7182 end = sym;
7183 else
7184 beg = sym + 1;
4d6ed7c8 7185 }
1b31d05e 7186
4d6ed7c8
NC		 7187 if (best)
7188 {
57346661 7189 *symname = (best->st_name >= strtab_size
2b692964 7190 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 7191 *offset = dist;
7192 return;
7193 }
1b31d05e 7194
4d6ed7c8
NC		 7195 *symname = NULL;
7196 *offset = addr.offset;
7197}
7198
32ec8896 7199static /* signed */ int
948f632f
DA		 7200symcmp (const void *p, const void *q)
7201{
7202 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7203 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7204
7205 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7206}
7207
7208/* Process the unwind section. */
7209
7210#include "unwind-ia64.h"
7211
7212struct ia64_unw_table_entry
7213{
7214 struct absaddr start;
7215 struct absaddr end;
7216 struct absaddr info;
7217};
7218
7219struct ia64_unw_aux_info
7220{
32ec8896
NC		 7221 struct ia64_unw_table_entry * table; /* Unwind table. */
7222 unsigned long table_len; /* Length of unwind table. */
7223 unsigned char * info; /* Unwind info. */
7224 unsigned long info_size; /* Size of unwind info. */
7225 bfd_vma info_addr; /* Starting address of unwind info. */
7226 bfd_vma seg_base; /* Starting address of segment. */
7227 Elf_Internal_Sym * symtab; /* The symbol table. */
7228 unsigned long nsyms; /* Number of symbols. */
7229 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7230 unsigned long nfuns; /* Number of entries in funtab. */
7231 char * strtab; /* The string table. */
7232 unsigned long strtab_size; /* Size of string table. */
948f632f
DA		 7233};
7234
32ec8896 7235static bfd_boolean
2cf0635d 7236dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 7237{
2cf0635d 7238 struct ia64_unw_table_entry * tp;
948f632f 7239 unsigned long j, nfuns;
4d6ed7c8 7240 int in_body;
32ec8896 7241 bfd_boolean res = TRUE;
7036c0e1 7242
948f632f
DA		 7243 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7244 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7245 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7246 aux->funtab[nfuns++] = aux->symtab[j];
7247 aux->nfuns = nfuns;
7248 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7249
4d6ed7c8
NC		 7250 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7251 {
7252 bfd_vma stamp;
7253 bfd_vma offset;
2cf0635d
NC		 7254 const unsigned char * dp;
7255 const unsigned char * head;
53774b7e 7256 const unsigned char * end;
2cf0635d 7257 const char * procname;
4d6ed7c8 7258
948f632f 7259 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661 7260 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 7261
7262 fputs ("\n<", stdout);
7263
7264 if (procname)
7265 {
7266 fputs (procname, stdout);
7267
7268 if (offset)
7269 printf ("+%lx", (unsigned long) offset);
7270 }
7271
7272 fputs (">: [", stdout);
7273 print_vma (tp->start.offset, PREFIX_HEX);
7274 fputc ('-', stdout);
7275 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 7276 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 7277 (unsigned long) (tp->info.offset - aux->seg_base));
7278
53774b7e
NC		 7279 /* PR 17531: file: 86232b32. */
7280 if (aux->info == NULL)
7281 continue;
7282
7283 /* PR 17531: file: 0997b4d1. */
7284 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7285 {
7286 warn (_("Invalid offset %lx in table entry %ld\n"),
7287 (long) tp->info.offset, (long) (tp - aux->table));
32ec8896 7288 res = FALSE;
53774b7e
NC		 7289 continue;
7290 }
7291
1949de15 7292 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 7293 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 7294
86f55779 7295 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 7296 (unsigned) UNW_VER (stamp),
7297 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7298 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7299 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 7300 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 7301
7302 if (UNW_VER (stamp) != 1)
7303 {
2b692964 7304 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 7305 continue;
7306 }
7307
7308 in_body = 0;
53774b7e
NC		 7309 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7310 /* PR 17531: file: 16ceda89. */
7311 if (end > aux->info + aux->info_size)
7312 end = aux->info + aux->info_size;
7313 for (dp = head + 8; dp < end;)
b4477bc8 7314 dp = unw_decode (dp, in_body, & in_body, end);
4d6ed7c8 7315 }
948f632f
DA		 7316
7317 free (aux->funtab);
32ec8896
NC		 7318
7319 return res;
4d6ed7c8
NC		 7320}
7321
53774b7e 7322static bfd_boolean
2cf0635d
NC		 7323slurp_ia64_unwind_table (FILE * file,
7324 struct ia64_unw_aux_info * aux,
7325 Elf_Internal_Shdr * sec)
4d6ed7c8 7326{
89fac5e3 7327 unsigned long size, nrelas, i;
2cf0635d
NC		 7328 Elf_Internal_Phdr * seg;
7329 struct ia64_unw_table_entry * tep;
7330 Elf_Internal_Shdr * relsec;
7331 Elf_Internal_Rela * rela;
7332 Elf_Internal_Rela * rp;
7333 unsigned char * table;
7334 unsigned char * tp;
7335 Elf_Internal_Sym * sym;
7336 const char * relname;
4d6ed7c8 7337
53774b7e
NC		 7338 aux->table_len = 0;
7339
4d6ed7c8
NC		 7340 /* First, find the starting address of the segment that includes
7341 this section: */
7342
7343 if (elf_header.e_phnum)
7344 {
d93f0186 7345 if (! get_program_headers (file))
53774b7e 7346 return FALSE;
4d6ed7c8 7347
d93f0186
NC		 7348 for (seg = program_headers;
7349 seg < program_headers + elf_header.e_phnum;
7350 ++seg)
4d6ed7c8
NC		 7351 {
7352 if (seg->p_type != PT_LOAD)
7353 continue;
7354
7355 if (sec->sh_addr >= seg->p_vaddr
7356 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7357 {
7358 aux->seg_base = seg->p_vaddr;
7359 break;
7360 }
7361 }
4d6ed7c8
NC		 7362 }
7363
7364 /* Second, build the unwind table from the contents of the unwind section: */
7365 size = sec->sh_size;
3f5e193b
NC		 7366 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7367 _("unwind table"));
a6e9f9df 7368 if (!table)
53774b7e 7369 return FALSE;
4d6ed7c8 7370
53774b7e 7371 aux->table_len = size / (3 * eh_addr_size);
3f5e193b 7372 aux->table = (struct ia64_unw_table_entry *)
53774b7e 7373 xcmalloc (aux->table_len, sizeof (aux->table[0]));
89fac5e3 7374 tep = aux->table;
53774b7e
NC		 7375
7376 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
4d6ed7c8
NC		 7377 {
7378 tep->start.section = SHN_UNDEF;
7379 tep->end.section = SHN_UNDEF;
7380 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 7381 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7382 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7383 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 7384 tep->start.offset += aux->seg_base;
7385 tep->end.offset += aux->seg_base;
7386 tep->info.offset += aux->seg_base;
7387 }
7388 free (table);
7389
41e92641 7390 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 7391 for (relsec = section_headers;
7392 relsec < section_headers + elf_header.e_shnum;
7393 ++relsec)
7394 {
7395 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 7396 || relsec->sh_info >= elf_header.e_shnum
7397 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 7398 continue;
7399
7400 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7401 & rela, & nrelas))
53774b7e
NC		 7402 {
7403 free (aux->table);
7404 aux->table = NULL;
7405 aux->table_len = 0;
7406 return FALSE;
7407 }
4d6ed7c8
NC		 7408
7409 for (rp = rela; rp < rela + nrelas; ++rp)
7410 {
aca88567
NC		 7411 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
7412 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 7413
82b1b41b
NC		 7414 /* PR 17531: file: 9fa67536. */
7415 if (relname == NULL)
7416 {
7417 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
7418 continue;
7419 }
948f632f 7420
0112cd26 7421 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 7422 {
82b1b41b 7423 warn (_("Skipping unexpected relocation type: %s\n"), relname);
4d6ed7c8
NC		 7424 continue;
7425 }
7426
89fac5e3 7427 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 7428
53774b7e
NC		 7429 /* PR 17531: file: 5bc8d9bf. */
7430 if (i >= aux->table_len)
7431 {
7432 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7433 continue;
7434 }
7435
7436 switch (rp->r_offset / eh_addr_size % 3)
4d6ed7c8
NC		 7437 {
7438 case 0:
7439 aux->table[i].start.section = sym->st_shndx;
e466bc6e 7440 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 7441 break;
7442 case 1:
7443 aux->table[i].end.section = sym->st_shndx;
e466bc6e 7444 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 7445 break;
7446 case 2:
7447 aux->table[i].info.section = sym->st_shndx;
e466bc6e 7448 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 7449 break;
7450 default:
7451 break;
7452 }
7453 }
7454
7455 free (rela);
7456 }
7457
53774b7e 7458 return TRUE;
4d6ed7c8
NC		 7459}
7460
32ec8896 7461static bfd_boolean
2cf0635d 7462ia64_process_unwind (FILE * file)
4d6ed7c8 7463{
2cf0635d
NC		 7464 Elf_Internal_Shdr * sec;
7465 Elf_Internal_Shdr * unwsec = NULL;
7466 Elf_Internal_Shdr * strsec;
89fac5e3 7467 unsigned long i, unwcount = 0, unwstart = 0;
57346661 7468 struct ia64_unw_aux_info aux;
32ec8896 7469 bfd_boolean res = TRUE;
f1467e33 7470
4d6ed7c8
NC		 7471 memset (& aux, 0, sizeof (aux));
7472
4d6ed7c8
NC		 7473 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7474 {
c256ffe7 7475 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 7476 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 7477 {
ba5cdace 7478 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 7479
4fbb74a6 7480 strsec = section_headers + sec->sh_link;
4082ef84
NC		 7481 if (aux.strtab != NULL)
7482 {
7483 error (_("Multiple auxillary string tables encountered\n"));
7484 free (aux.strtab);
32ec8896 7485 res = FALSE;
4082ef84 7486 }
3f5e193b
NC		 7487 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7488 1, strsec->sh_size,
7489 _("string table"));
c256ffe7 7490 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 7491 }
7492 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 7493 unwcount++;
7494 }
7495
7496 if (!unwcount)
7497 printf (_("\nThere are no unwind sections in this file.\n"));
7498
7499 while (unwcount-- > 0)
7500 {
2cf0635d 7501 char * suffix;
579f31ac
JJ		 7502 size_t len, len2;
7503
4082ef84 7504 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
579f31ac
JJ		 7505 i < elf_header.e_shnum; ++i, ++sec)
7506 if (sec->sh_type == SHT_IA_64_UNWIND)
7507 {
7508 unwsec = sec;
7509 break;
7510 }
4082ef84
NC		 7511 /* We have already counted the number of SHT_IA64_UNWIND
7512 sections so the loop above should never fail. */
7513 assert (unwsec != NULL);
579f31ac
JJ		 7514
7515 unwstart = i + 1;
7516 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7517
e4b17d5c
L		 7518 if ((unwsec->sh_flags & SHF_GROUP) != 0)
7519 {
7520 /* We need to find which section group it is in. */
4082ef84 7521 struct group_list * g;
e4b17d5c 7522
4082ef84
NC		 7523 if (section_headers_groups == NULL
7524 || section_headers_groups [i] == NULL)
7525 i = elf_header.e_shnum;
7526 else
e4b17d5c 7527 {
4082ef84 7528 g = section_headers_groups [i]->root;
18bd398b 7529
4082ef84
NC		 7530 for (; g != NULL; g = g->next)
7531 {
7532 sec = section_headers + g->section_index;
e4b17d5c 7533
4082ef84
NC		 7534 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7535 break;
7536 }
7537
7538 if (g == NULL)
7539 i = elf_header.e_shnum;
7540 }
e4b17d5c 7541 }
18bd398b 7542 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 7543 {
18bd398b 7544 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 7545 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7546 suffix = SECTION_NAME (unwsec) + len;
7547 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7548 ++i, ++sec)
18bd398b
NC		 7549 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7550 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 7551 break;
7552 }
7553 else
7554 {
7555 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 7556 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 7557 len = sizeof (ELF_STRING_ia64_unwind) - 1;
7558 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7559 suffix = "";
18bd398b 7560 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 7561 suffix = SECTION_NAME (unwsec) + len;
7562 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7563 ++i, ++sec)
18bd398b
NC		 7564 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7565 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 7566 break;
7567 }
7568
7569 if (i == elf_header.e_shnum)
7570 {
7571 printf (_("\nCould not find unwind info section for "));
7572
7573 if (string_table == NULL)
7574 printf ("%d", unwsec->sh_name);
7575 else
74e1a04b 7576 printf ("'%s'", printable_section_name (unwsec));
579f31ac
JJ		 7577 }
7578 else
4d6ed7c8 7579 {
4d6ed7c8 7580 aux.info_addr = sec->sh_addr;
3f5e193b 7581 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
4082ef84
NC		 7582 sec->sh_size,
7583 _("unwind info"));
59245841 7584 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 7585
579f31ac 7586 printf (_("\nUnwind section "));
4d6ed7c8 7587
579f31ac
JJ		 7588 if (string_table == NULL)
7589 printf ("%d", unwsec->sh_name);
7590 else
74e1a04b 7591 printf ("'%s'", printable_section_name (unwsec));
4d6ed7c8 7592
579f31ac 7593 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 7594 (unsigned long) unwsec->sh_offset,
89fac5e3 7595 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 7596
53774b7e
NC		 7597 if (slurp_ia64_unwind_table (file, & aux, unwsec)
7598 && aux.table_len > 0)
579f31ac
JJ		 7599 dump_ia64_unwind (& aux);
7600
7601 if (aux.table)
7602 free ((char *) aux.table);
7603 if (aux.info)
7604 free ((char *) aux.info);
7605 aux.table = NULL;
7606 aux.info = NULL;
7607 }
4d6ed7c8 7608 }
4d6ed7c8 7609
4d6ed7c8
NC		 7610 if (aux.symtab)
7611 free (aux.symtab);
7612 if (aux.strtab)
7613 free ((char *) aux.strtab);
32ec8896
NC		 7614
7615 return res;
4d6ed7c8
NC		 7616}
7617
3f5e193b 7618struct hppa_unw_table_entry
32ec8896
NC		 7619{
7620 struct absaddr start;
7621 struct absaddr end;
7622 unsigned int Cannot_unwind:1; /* 0 */
7623 unsigned int Millicode:1; /* 1 */
7624 unsigned int Millicode_save_sr0:1; /* 2 */
7625 unsigned int Region_description:2; /* 3..4 */
7626 unsigned int reserved1:1; /* 5 */
7627 unsigned int Entry_SR:1; /* 6 */
7628 unsigned int Entry_FR:4; /* Number saved 7..10 */
7629 unsigned int Entry_GR:5; /* Number saved 11..15 */
7630 unsigned int Args_stored:1; /* 16 */
7631 unsigned int Variable_Frame:1; /* 17 */
7632 unsigned int Separate_Package_Body:1; /* 18 */
7633 unsigned int Frame_Extension_Millicode:1; /* 19 */
7634 unsigned int Stack_Overflow_Check:1; /* 20 */
7635 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
7636 unsigned int Ada_Region:1; /* 22 */
7637 unsigned int cxx_info:1; /* 23 */
7638 unsigned int cxx_try_catch:1; /* 24 */
7639 unsigned int sched_entry_seq:1; /* 25 */
7640 unsigned int reserved2:1; /* 26 */
7641 unsigned int Save_SP:1; /* 27 */
7642 unsigned int Save_RP:1; /* 28 */
7643 unsigned int Save_MRP_in_frame:1; /* 29 */
7644 unsigned int extn_ptr_defined:1; /* 30 */
7645 unsigned int Cleanup_defined:1; /* 31 */
7646
7647 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
7648 unsigned int HP_UX_interrupt_marker:1; /* 1 */
7649 unsigned int Large_frame:1; /* 2 */
7650 unsigned int Pseudo_SP_Set:1; /* 3 */
7651 unsigned int reserved4:1; /* 4 */
7652 unsigned int Total_frame_size:27; /* 5..31 */
7653};
3f5e193b 7654
57346661 7655struct hppa_unw_aux_info
948f632f 7656{
32ec8896
NC		 7657 struct hppa_unw_table_entry * table; /* Unwind table. */
7658 unsigned long table_len; /* Length of unwind table. */
7659 bfd_vma seg_base; /* Starting address of segment. */
7660 Elf_Internal_Sym * symtab; /* The symbol table. */
7661 unsigned long nsyms; /* Number of symbols. */
7662 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7663 unsigned long nfuns; /* Number of entries in funtab. */
7664 char * strtab; /* The string table. */
7665 unsigned long strtab_size; /* Size of string table. */
948f632f 7666};
57346661 7667
32ec8896 7668static bfd_boolean
2cf0635d 7669dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 7670{
2cf0635d 7671 struct hppa_unw_table_entry * tp;
948f632f 7672 unsigned long j, nfuns;
32ec8896 7673 bfd_boolean res = TRUE;
948f632f
DA		 7674
7675 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7676 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7677 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7678 aux->funtab[nfuns++] = aux->symtab[j];
7679 aux->nfuns = nfuns;
7680 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
57346661 7681
57346661
AM		 7682 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7683 {
7684 bfd_vma offset;
2cf0635d 7685 const char * procname;
57346661 7686
948f632f 7687 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661
AM		 7688 aux->strtab_size, tp->start, &procname,
7689 &offset);
7690
7691 fputs ("\n<", stdout);
7692
7693 if (procname)
7694 {
7695 fputs (procname, stdout);
7696
7697 if (offset)
7698 printf ("+%lx", (unsigned long) offset);
7699 }
7700
7701 fputs (">: [", stdout);
7702 print_vma (tp->start.offset, PREFIX_HEX);
7703 fputc ('-', stdout);
7704 print_vma (tp->end.offset, PREFIX_HEX);
7705 printf ("]\n\t");
7706
18bd398b
NC		 7707#define PF(_m) if (tp->_m) printf (#_m " ");
7708#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 7709 PF(Cannot_unwind);
7710 PF(Millicode);
7711 PF(Millicode_save_sr0);
18bd398b 7712 /* PV(Region_description); */
57346661
AM		 7713 PF(Entry_SR);
7714 PV(Entry_FR);
7715 PV(Entry_GR);
7716 PF(Args_stored);
7717 PF(Variable_Frame);
7718 PF(Separate_Package_Body);
7719 PF(Frame_Extension_Millicode);
7720 PF(Stack_Overflow_Check);
7721 PF(Two_Instruction_SP_Increment);
7722 PF(Ada_Region);
7723 PF(cxx_info);
7724 PF(cxx_try_catch);
7725 PF(sched_entry_seq);
7726 PF(Save_SP);
7727 PF(Save_RP);
7728 PF(Save_MRP_in_frame);
7729 PF(extn_ptr_defined);
7730 PF(Cleanup_defined);
7731 PF(MPE_XL_interrupt_marker);
7732 PF(HP_UX_interrupt_marker);
7733 PF(Large_frame);
7734 PF(Pseudo_SP_Set);
7735 PV(Total_frame_size);
7736#undef PF
7737#undef PV
7738 }
7739
18bd398b 7740 printf ("\n");
948f632f
DA		 7741
7742 free (aux->funtab);
32ec8896
NC		 7743
7744 return res;
57346661
AM		 7745}
7746
32ec8896 7747static bfd_boolean
2cf0635d
NC		 7748slurp_hppa_unwind_table (FILE * file,
7749 struct hppa_unw_aux_info * aux,
7750 Elf_Internal_Shdr * sec)
57346661 7751{
1c0751b2 7752 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 7753 Elf_Internal_Phdr * seg;
7754 struct hppa_unw_table_entry * tep;
7755 Elf_Internal_Shdr * relsec;
7756 Elf_Internal_Rela * rela;
7757 Elf_Internal_Rela * rp;
7758 unsigned char * table;
7759 unsigned char * tp;
7760 Elf_Internal_Sym * sym;
7761 const char * relname;
57346661 7762
57346661
AM		 7763 /* First, find the starting address of the segment that includes
7764 this section. */
57346661
AM		 7765 if (elf_header.e_phnum)
7766 {
7767 if (! get_program_headers (file))
32ec8896 7768 return FALSE;
57346661
AM		 7769
7770 for (seg = program_headers;
7771 seg < program_headers + elf_header.e_phnum;
7772 ++seg)
7773 {
7774 if (seg->p_type != PT_LOAD)
7775 continue;
7776
7777 if (sec->sh_addr >= seg->p_vaddr
7778 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7779 {
7780 aux->seg_base = seg->p_vaddr;
7781 break;
7782 }
7783 }
7784 }
7785
7786 /* Second, build the unwind table from the contents of the unwind
7787 section. */
7788 size = sec->sh_size;
3f5e193b
NC		 7789 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7790 _("unwind table"));
57346661 7791 if (!table)
32ec8896 7792 return FALSE;
57346661 7793
1c0751b2
DA		 7794 unw_ent_size = 16;
7795 nentries = size / unw_ent_size;
7796 size = unw_ent_size * nentries;
57346661 7797
3f5e193b
NC		 7798 tep = aux->table = (struct hppa_unw_table_entry *)
7799 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 7800
1c0751b2 7801 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 7802 {
7803 unsigned int tmp1, tmp2;
7804
7805 tep->start.section = SHN_UNDEF;
7806 tep->end.section = SHN_UNDEF;
7807
1c0751b2
DA		 7808 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7809 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7810 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7811 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7812
7813 tep->start.offset += aux->seg_base;
7814 tep->end.offset += aux->seg_base;
57346661
AM		 7815
7816 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7817 tep->Millicode = (tmp1 >> 30) & 0x1;
7818 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7819 tep->Region_description = (tmp1 >> 27) & 0x3;
7820 tep->reserved1 = (tmp1 >> 26) & 0x1;
7821 tep->Entry_SR = (tmp1 >> 25) & 0x1;
7822 tep->Entry_FR = (tmp1 >> 21) & 0xf;
7823 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7824 tep->Args_stored = (tmp1 >> 15) & 0x1;
7825 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7826 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7827 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7828 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7829 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7830 tep->Ada_Region = (tmp1 >> 9) & 0x1;
7831 tep->cxx_info = (tmp1 >> 8) & 0x1;
7832 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7833 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7834 tep->reserved2 = (tmp1 >> 5) & 0x1;
7835 tep->Save_SP = (tmp1 >> 4) & 0x1;
7836 tep->Save_RP = (tmp1 >> 3) & 0x1;
7837 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7838 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7839 tep->Cleanup_defined = tmp1 & 0x1;
7840
7841 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7842 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7843 tep->Large_frame = (tmp2 >> 29) & 0x1;
7844 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7845 tep->reserved4 = (tmp2 >> 27) & 0x1;
7846 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 7847 }
7848 free (table);
7849
7850 /* Third, apply any relocations to the unwind table. */
57346661
AM		 7851 for (relsec = section_headers;
7852 relsec < section_headers + elf_header.e_shnum;
7853 ++relsec)
7854 {
7855 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 7856 || relsec->sh_info >= elf_header.e_shnum
7857 || section_headers + relsec->sh_info != sec)
57346661
AM		 7858 continue;
7859
7860 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7861 & rela, & nrelas))
32ec8896 7862 return FALSE;
57346661
AM		 7863
7864 for (rp = rela; rp < rela + nrelas; ++rp)
7865 {
aca88567
NC		 7866 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7867 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 7868
7869 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 7870 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 7871 {
7872 warn (_("Skipping unexpected relocation type %s\n"), relname);
7873 continue;
7874 }
7875
7876 i = rp->r_offset / unw_ent_size;
7877
89fac5e3 7878 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 7879 {
7880 case 0:
7881 aux->table[i].start.section = sym->st_shndx;
1e456d54 7882 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 7883 break;
7884 case 1:
7885 aux->table[i].end.section = sym->st_shndx;
1e456d54 7886 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 7887 break;
7888 default:
7889 break;
7890 }
7891 }
7892
7893 free (rela);
7894 }
7895
1c0751b2 7896 aux->table_len = nentries;
57346661 7897
32ec8896 7898 return TRUE;
57346661
AM		 7899}
7900
32ec8896 7901static bfd_boolean
2cf0635d 7902hppa_process_unwind (FILE * file)
57346661 7903{
57346661 7904 struct hppa_unw_aux_info aux;
2cf0635d
NC		 7905 Elf_Internal_Shdr * unwsec = NULL;
7906 Elf_Internal_Shdr * strsec;
7907 Elf_Internal_Shdr * sec;
18bd398b 7908 unsigned long i;
32ec8896 7909 bfd_boolean res = TRUE;
57346661 7910
c256ffe7 7911 if (string_table == NULL)
32ec8896 7912 return FALSE;
1b31d05e
NC		 7913
7914 memset (& aux, 0, sizeof (aux));
57346661
AM		 7915
7916 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7917 {
c256ffe7 7918 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 7919 && sec->sh_link < elf_header.e_shnum)
57346661 7920 {
ba5cdace 7921 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 7922
4fbb74a6 7923 strsec = section_headers + sec->sh_link;
4082ef84
NC		 7924 if (aux.strtab != NULL)
7925 {
7926 error (_("Multiple auxillary string tables encountered\n"));
7927 free (aux.strtab);
32ec8896 7928 res = FALSE;
4082ef84 7929 }
3f5e193b
NC		 7930 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7931 1, strsec->sh_size,
7932 _("string table"));
c256ffe7 7933 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 7934 }
18bd398b 7935 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 7936 unwsec = sec;
7937 }
7938
7939 if (!unwsec)
7940 printf (_("\nThere are no unwind sections in this file.\n"));
7941
7942 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7943 {
18bd398b 7944 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 7945 {
74e1a04b
NC		 7946 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7947 printable_section_name (sec),
57346661 7948 (unsigned long) sec->sh_offset,
89fac5e3 7949 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661 7950
32ec8896
NC		 7951 if (! slurp_hppa_unwind_table (file, &aux, sec))
7952 res = FALSE;
7953
57346661 7954 if (aux.table_len > 0)
32ec8896
NC		 7955 {
7956 if (! dump_hppa_unwind (&aux))
7957 res = FALSE;
7958 }
57346661
AM		 7959
7960 if (aux.table)
7961 free ((char *) aux.table);
7962 aux.table = NULL;
7963 }
7964 }
7965
7966 if (aux.symtab)
7967 free (aux.symtab);
7968 if (aux.strtab)
7969 free ((char *) aux.strtab);
32ec8896
NC		 7970
7971 return res;
57346661
AM		 7972}
7973
0b6ae522
DJ		 7974struct arm_section
7975{
a734115a
NC		 7976 unsigned char * data; /* The unwind data. */
7977 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
7978 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
7979 unsigned long nrelas; /* The number of relocations. */
7980 unsigned int rel_type; /* REL or RELA ? */
7981 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 7982};
7983
7984struct arm_unw_aux_info
7985{
a734115a
NC		 7986 FILE * file; /* The file containing the unwind sections. */
7987 Elf_Internal_Sym * symtab; /* The file's symbol table. */
7988 unsigned long nsyms; /* Number of symbols. */
948f632f
DA		 7989 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7990 unsigned long nfuns; /* Number of these symbols. */
a734115a
NC		 7991 char * strtab; /* The file's string table. */
7992 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 7993};
7994
7995static const char *
7996arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7997 bfd_vma fn, struct absaddr addr)
7998{
7999 const char *procname;
8000 bfd_vma sym_offset;
8001
8002 if (addr.section == SHN_UNDEF)
8003 addr.offset = fn;
8004
948f632f 8005 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
0b6ae522
DJ		 8006 aux->strtab_size, addr, &procname,
8007 &sym_offset);
8008
8009 print_vma (fn, PREFIX_HEX);
8010
8011 if (procname)
8012 {
8013 fputs (" <", stdout);
8014 fputs (procname, stdout);
8015
8016 if (sym_offset)
8017 printf ("+0x%lx", (unsigned long) sym_offset);
8018 fputc ('>', stdout);
8019 }
8020
8021 return procname;
8022}
8023
8024static void
8025arm_free_section (struct arm_section *arm_sec)
8026{
8027 if (arm_sec->data != NULL)
8028 free (arm_sec->data);
8029
8030 if (arm_sec->rela != NULL)
8031 free (arm_sec->rela);
8032}
8033
a734115a
NC		 8034/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8035 cached section and install SEC instead.
8036 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8037 and return its valued in * WORDP, relocating if necessary.
1b31d05e 8038 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 8039 relocation's offset in ADDR.
1b31d05e
NC		 8040 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8041 into the string table of the symbol associated with the reloc. If no
8042 reloc was applied store -1 there.
8043 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 8044
8045static bfd_boolean
1b31d05e
NC		 8046get_unwind_section_word (struct arm_unw_aux_info * aux,
8047 struct arm_section * arm_sec,
8048 Elf_Internal_Shdr * sec,
8049 bfd_vma word_offset,
8050 unsigned int * wordp,
8051 struct absaddr * addr,
8052 bfd_vma * sym_name)
0b6ae522
DJ		 8053{
8054 Elf_Internal_Rela *rp;
8055 Elf_Internal_Sym *sym;
8056 const char * relname;
8057 unsigned int word;
8058 bfd_boolean wrapped;
8059
e0a31db1
NC		 8060 if (sec == NULL || arm_sec == NULL)
8061 return FALSE;
8062
0b6ae522
DJ		 8063 addr->section = SHN_UNDEF;
8064 addr->offset = 0;
8065
1b31d05e
NC		 8066 if (sym_name != NULL)
8067 *sym_name = (bfd_vma) -1;
8068
a734115a 8069 /* If necessary, update the section cache. */
0b6ae522
DJ		 8070 if (sec != arm_sec->sec)
8071 {
8072 Elf_Internal_Shdr *relsec;
8073
8074 arm_free_section (arm_sec);
8075
8076 arm_sec->sec = sec;
8077 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
8078 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 8079 arm_sec->rela = NULL;
8080 arm_sec->nrelas = 0;
8081
8082 for (relsec = section_headers;
8083 relsec < section_headers + elf_header.e_shnum;
8084 ++relsec)
8085 {
8086 if (relsec->sh_info >= elf_header.e_shnum
1ae40aa4
NC		 8087 || section_headers + relsec->sh_info != sec
8088 /* PR 15745: Check the section type as well. */
8089 || (relsec->sh_type != SHT_REL
8090 && relsec->sh_type != SHT_RELA))
0b6ae522
DJ		 8091 continue;
8092
a734115a 8093 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 8094 if (relsec->sh_type == SHT_REL)
8095 {
8096 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
8097 relsec->sh_size,
8098 & arm_sec->rela, & arm_sec->nrelas))
a734115a 8099 return FALSE;
0b6ae522 8100 }
1ae40aa4 8101 else /* relsec->sh_type == SHT_RELA */
0b6ae522
DJ		 8102 {
8103 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
8104 relsec->sh_size,
8105 & arm_sec->rela, & arm_sec->nrelas))
a734115a 8106 return FALSE;
0b6ae522 8107 }
1ae40aa4 8108 break;
0b6ae522
DJ		 8109 }
8110
8111 arm_sec->next_rela = arm_sec->rela;
8112 }
8113
a734115a 8114 /* If there is no unwind data we can do nothing. */
0b6ae522 8115 if (arm_sec->data == NULL)
a734115a 8116 return FALSE;
0b6ae522 8117
e0a31db1 8118 /* If the offset is invalid then fail. */
f32ba729
NC		 8119 if (/* PR 21343 *//* PR 18879 */
8120 sec->sh_size < 4
8121 || word_offset > (sec->sh_size - 4)
1a915552 8122 || ((bfd_signed_vma) word_offset) < 0)
e0a31db1
NC		 8123 return FALSE;
8124
a734115a 8125 /* Get the word at the required offset. */
0b6ae522
DJ		 8126 word = byte_get (arm_sec->data + word_offset, 4);
8127
0eff7165
NC		 8128 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8129 if (arm_sec->rela == NULL)
8130 {
8131 * wordp = word;
8132 return TRUE;
8133 }
8134
a734115a 8135 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 8136 wrapped = FALSE;
8137 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8138 {
8139 bfd_vma prelval, offset;
8140
8141 if (rp->r_offset > word_offset && !wrapped)
8142 {
8143 rp = arm_sec->rela;
8144 wrapped = TRUE;
8145 }
8146 if (rp->r_offset > word_offset)
8147 break;
8148
8149 if (rp->r_offset & 3)
8150 {
8151 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8152 (unsigned long) rp->r_offset);
8153 continue;
8154 }
8155
8156 if (rp->r_offset < word_offset)
8157 continue;
8158
74e1a04b
NC		 8159 /* PR 17531: file: 027-161405-0.004 */
8160 if (aux->symtab == NULL)
8161 continue;
8162
0b6ae522
DJ		 8163 if (arm_sec->rel_type == SHT_REL)
8164 {
8165 offset = word & 0x7fffffff;
8166 if (offset & 0x40000000)
8167 offset |= ~ (bfd_vma) 0x7fffffff;
8168 }
a734115a 8169 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 8170 offset = rp->r_addend;
a734115a 8171 else
74e1a04b
NC		 8172 {
8173 error (_("Unknown section relocation type %d encountered\n"),
8174 arm_sec->rel_type);
8175 break;
8176 }
0b6ae522 8177
071436c6
NC		 8178 /* PR 17531 file: 027-1241568-0.004. */
8179 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8180 {
8181 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8182 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8183 break;
8184 }
8185
8186 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
0b6ae522
DJ		 8187 offset += sym->st_value;
8188 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8189
a734115a
NC		 8190 /* Check that we are processing the expected reloc type. */
8191 if (elf_header.e_machine == EM_ARM)
8192 {
8193 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 8194 if (relname == NULL)
8195 {
8196 warn (_("Skipping unknown ARM relocation type: %d\n"),
8197 (int) ELF32_R_TYPE (rp->r_info));
8198 continue;
8199 }
a734115a
NC		 8200
8201 if (streq (relname, "R_ARM_NONE"))
8202 continue;
0b4362b0 8203
a734115a
NC		 8204 if (! streq (relname, "R_ARM_PREL31"))
8205 {
071436c6 8206 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
a734115a
NC		 8207 continue;
8208 }
8209 }
8210 else if (elf_header.e_machine == EM_TI_C6000)
8211 {
8212 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 8213 if (relname == NULL)
8214 {
8215 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8216 (int) ELF32_R_TYPE (rp->r_info));
8217 continue;
8218 }
0b4362b0 8219
a734115a
NC		 8220 if (streq (relname, "R_C6000_NONE"))
8221 continue;
8222
8223 if (! streq (relname, "R_C6000_PREL31"))
8224 {
071436c6 8225 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
a734115a
NC		 8226 continue;
8227 }
8228
8229 prelval >>= 1;
8230 }
8231 else
74e1a04b
NC		 8232 {
8233 /* This function currently only supports ARM and TI unwinders. */
8234 warn (_("Only TI and ARM unwinders are currently supported\n"));
8235 break;
8236 }
fa197c1c 8237
0b6ae522
DJ		 8238 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8239 addr->section = sym->st_shndx;
8240 addr->offset = offset;
74e1a04b 8241
1b31d05e
NC		 8242 if (sym_name)
8243 * sym_name = sym->st_name;
0b6ae522
DJ		 8244 break;
8245 }
8246
8247 *wordp = word;
8248 arm_sec->next_rela = rp;
8249
a734115a 8250 return TRUE;
0b6ae522
DJ		 8251}
8252
a734115a
NC		 8253static const char *tic6x_unwind_regnames[16] =
8254{
0b4362b0
RM		 8255 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8256 "A14", "A13", "A12", "A11", "A10",
a734115a
NC		 8257 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8258};
fa197c1c 8259
0b6ae522 8260static void
fa197c1c 8261decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 8262{
fa197c1c
PB		 8263 int i;
8264
8265 for (i = 12; mask; mask >>= 1, i--)
8266 {
8267 if (mask & 1)
8268 {
8269 fputs (tic6x_unwind_regnames[i], stdout);
8270 if (mask > 1)
8271 fputs (", ", stdout);
8272 }
8273 }
8274}
0b6ae522
DJ		 8275
8276#define ADVANCE \
8277 if (remaining == 0 && more_words) \
8278 { \
8279 data_offset += 4; \
1b31d05e
NC		 8280 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
8281 data_offset, & word, & addr, NULL)) \
32ec8896 8282 return FALSE; \
0b6ae522
DJ		 8283 remaining = 4; \
8284 more_words--; \
8285 } \
8286
8287#define GET_OP(OP) \
8288 ADVANCE; \
8289 if (remaining) \
8290 { \
8291 remaining--; \
8292 (OP) = word >> 24; \
8293 word <<= 8; \
8294 } \
8295 else \
8296 { \
2b692964 8297 printf (_("[Truncated opcode]\n")); \
32ec8896 8298 return FALSE; \
0b6ae522 8299 } \
cc5914eb 8300 printf ("0x%02x ", OP)
0b6ae522 8301
32ec8896 8302static bfd_boolean
948f632f
DA		 8303decode_arm_unwind_bytecode (struct arm_unw_aux_info * aux,
8304 unsigned int word,
8305 unsigned int remaining,
8306 unsigned int more_words,
8307 bfd_vma data_offset,
8308 Elf_Internal_Shdr * data_sec,
8309 struct arm_section * data_arm_sec)
fa197c1c
PB		 8310{
8311 struct absaddr addr;
32ec8896 8312 bfd_boolean res = TRUE;
0b6ae522
DJ		 8313
8314 /* Decode the unwinding instructions. */
8315 while (1)
8316 {
8317 unsigned int op, op2;
8318
8319 ADVANCE;
8320 if (remaining == 0)
8321 break;
8322 remaining--;
8323 op = word >> 24;
8324 word <<= 8;
8325
cc5914eb 8326 printf (" 0x%02x ", op);
0b6ae522
DJ		 8327
8328 if ((op & 0xc0) == 0x00)
8329 {
8330 int offset = ((op & 0x3f) << 2) + 4;
61865e30 8331
cc5914eb 8332 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 8333 }
8334 else if ((op & 0xc0) == 0x40)
8335 {
8336 int offset = ((op & 0x3f) << 2) + 4;
61865e30 8337
cc5914eb 8338 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 8339 }
8340 else if ((op & 0xf0) == 0x80)
8341 {
8342 GET_OP (op2);
8343 if (op == 0x80 && op2 == 0)
8344 printf (_("Refuse to unwind"));
8345 else
8346 {
8347 unsigned int mask = ((op & 0x0f) << 8) | op2;
32ec8896 8348 bfd_boolean first = TRUE;
0b6ae522 8349 int i;
2b692964 8350
0b6ae522
DJ		 8351 printf ("pop {");
8352 for (i = 0; i < 12; i++)
8353 if (mask & (1 << i))
8354 {
8355 if (first)
32ec8896 8356 first = FALSE;
0b6ae522
DJ		 8357 else
8358 printf (", ");
8359 printf ("r%d", 4 + i);
8360 }
8361 printf ("}");
8362 }
8363 }
8364 else if ((op & 0xf0) == 0x90)
8365 {
8366 if (op == 0x9d || op == 0x9f)
8367 printf (_(" [Reserved]"));
8368 else
cc5914eb 8369 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 8370 }
8371 else if ((op & 0xf0) == 0xa0)
8372 {
8373 int end = 4 + (op & 0x07);
32ec8896 8374 bfd_boolean first = TRUE;
0b6ae522 8375 int i;
61865e30 8376
0b6ae522
DJ		 8377 printf (" pop {");
8378 for (i = 4; i <= end; i++)
8379 {
8380 if (first)
32ec8896 8381 first = FALSE;
0b6ae522
DJ		 8382 else
8383 printf (", ");
8384 printf ("r%d", i);
8385 }
8386 if (op & 0x08)
8387 {
1b31d05e 8388 if (!first)
0b6ae522
DJ		 8389 printf (", ");
8390 printf ("r14");
8391 }
8392 printf ("}");
8393 }
8394 else if (op == 0xb0)
8395 printf (_(" finish"));
8396 else if (op == 0xb1)
8397 {
8398 GET_OP (op2);
8399 if (op2 == 0 || (op2 & 0xf0) != 0)
8400 printf (_("[Spare]"));
8401 else
8402 {
8403 unsigned int mask = op2 & 0x0f;
32ec8896 8404 bfd_boolean first = TRUE;
0b6ae522 8405 int i;
61865e30 8406
0b6ae522
DJ		 8407 printf ("pop {");
8408 for (i = 0; i < 12; i++)
8409 if (mask & (1 << i))
8410 {
8411 if (first)
32ec8896 8412 first = FALSE;
0b6ae522
DJ		 8413 else
8414 printf (", ");
8415 printf ("r%d", i);
8416 }
8417 printf ("}");
8418 }
8419 }
8420 else if (op == 0xb2)
8421 {
b115cf96 8422 unsigned char buf[9];
0b6ae522
DJ		 8423 unsigned int i, len;
8424 unsigned long offset;
61865e30 8425
b115cf96 8426 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 8427 {
8428 GET_OP (buf[i]);
8429 if ((buf[i] & 0x80) == 0)
8430 break;
8431 }
4082ef84 8432 if (i == sizeof (buf))
32ec8896
NC		 8433 {
8434 error (_("corrupt change to vsp"));
8435 res = FALSE;
8436 }
4082ef84
NC		 8437 else
8438 {
8439 offset = read_uleb128 (buf, &len, buf + i + 1);
8440 assert (len == i + 1);
8441 offset = offset * 4 + 0x204;
8442 printf ("vsp = vsp + %ld", offset);
8443 }
0b6ae522 8444 }
61865e30 8445 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 8446 {
61865e30
NC		 8447 unsigned int first, last;
8448
8449 GET_OP (op2);
8450 first = op2 >> 4;
8451 last = op2 & 0x0f;
8452 if (op == 0xc8)
8453 first = first + 16;
8454 printf ("pop {D%d", first);
8455 if (last)
8456 printf ("-D%d", first + last);
8457 printf ("}");
8458 }
8459 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8460 {
8461 unsigned int count = op & 0x07;
8462
8463 printf ("pop {D8");
8464 if (count)
8465 printf ("-D%d", 8 + count);
8466 printf ("}");
8467 }
8468 else if (op >= 0xc0 && op <= 0xc5)
8469 {
8470 unsigned int count = op & 0x07;
8471
8472 printf (" pop {wR10");
8473 if (count)
8474 printf ("-wR%d", 10 + count);
8475 printf ("}");
8476 }
8477 else if (op == 0xc6)
8478 {
8479 unsigned int first, last;
8480
8481 GET_OP (op2);
8482 first = op2 >> 4;
8483 last = op2 & 0x0f;
8484 printf ("pop {wR%d", first);
8485 if (last)
8486 printf ("-wR%d", first + last);
8487 printf ("}");
8488 }
8489 else if (op == 0xc7)
8490 {
8491 GET_OP (op2);
8492 if (op2 == 0 || (op2 & 0xf0) != 0)
8493 printf (_("[Spare]"));
0b6ae522
DJ		 8494 else
8495 {
61865e30 8496 unsigned int mask = op2 & 0x0f;
32ec8896 8497 bfd_boolean first = TRUE;
61865e30
NC		 8498 int i;
8499
8500 printf ("pop {");
8501 for (i = 0; i < 4; i++)
8502 if (mask & (1 << i))
8503 {
8504 if (first)
32ec8896 8505 first = FALSE;
61865e30
NC		 8506 else
8507 printf (", ");
8508 printf ("wCGR%d", i);
8509 }
8510 printf ("}");
0b6ae522
DJ		 8511 }
8512 }
61865e30 8513 else
32ec8896
NC		 8514 {
8515 printf (_(" [unsupported opcode]"));
8516 res = FALSE;
8517 }
8518
0b6ae522
DJ		 8519 printf ("\n");
8520 }
32ec8896
NC		 8521
8522 return res;
fa197c1c
PB		 8523}
8524
32ec8896 8525static bfd_boolean
948f632f
DA		 8526decode_tic6x_unwind_bytecode (struct arm_unw_aux_info * aux,
8527 unsigned int word,
8528 unsigned int remaining,
8529 unsigned int more_words,
8530 bfd_vma data_offset,
8531 Elf_Internal_Shdr * data_sec,
8532 struct arm_section * data_arm_sec)
fa197c1c
PB		 8533{
8534 struct absaddr addr;
8535
8536 /* Decode the unwinding instructions. */
8537 while (1)
8538 {
8539 unsigned int op, op2;
8540
8541 ADVANCE;
8542 if (remaining == 0)
8543 break;
8544 remaining--;
8545 op = word >> 24;
8546 word <<= 8;
8547
9cf03b7e 8548 printf (" 0x%02x ", op);
fa197c1c
PB		 8549
8550 if ((op & 0xc0) == 0x00)
8551 {
8552 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 8553 printf (" sp = sp + %d", offset);
fa197c1c
PB		 8554 }
8555 else if ((op & 0xc0) == 0x80)
8556 {
8557 GET_OP (op2);
8558 if (op == 0x80 && op2 == 0)
8559 printf (_("Refuse to unwind"));
8560 else
8561 {
8562 unsigned int mask = ((op & 0x1f) << 8) | op2;
8563 if (op & 0x20)
8564 printf ("pop compact {");
8565 else
8566 printf ("pop {");
8567
8568 decode_tic6x_unwind_regmask (mask);
8569 printf("}");
8570 }
8571 }
8572 else if ((op & 0xf0) == 0xc0)
8573 {
8574 unsigned int reg;
8575 unsigned int nregs;
8576 unsigned int i;
8577 const char *name;
a734115a
NC		 8578 struct
8579 {
32ec8896
NC		 8580 unsigned int offset;
8581 unsigned int reg;
fa197c1c
PB		 8582 } regpos[16];
8583
8584 /* Scan entire instruction first so that GET_OP output is not
8585 interleaved with disassembly. */
8586 nregs = 0;
8587 for (i = 0; nregs < (op & 0xf); i++)
8588 {
8589 GET_OP (op2);
8590 reg = op2 >> 4;
8591 if (reg != 0xf)
8592 {
8593 regpos[nregs].offset = i * 2;
8594 regpos[nregs].reg = reg;
8595 nregs++;
8596 }
8597
8598 reg = op2 & 0xf;
8599 if (reg != 0xf)
8600 {
8601 regpos[nregs].offset = i * 2 + 1;
8602 regpos[nregs].reg = reg;
8603 nregs++;
8604 }
8605 }
8606
8607 printf (_("pop frame {"));
8608 reg = nregs - 1;
8609 for (i = i * 2; i > 0; i--)
8610 {
8611 if (regpos[reg].offset == i - 1)
8612 {
8613 name = tic6x_unwind_regnames[regpos[reg].reg];
8614 if (reg > 0)
8615 reg--;
8616 }
8617 else
8618 name = _("[pad]");
8619
8620 fputs (name, stdout);
8621 if (i > 1)
8622 printf (", ");
8623 }
8624
8625 printf ("}");
8626 }
8627 else if (op == 0xd0)
8628 printf (" MOV FP, SP");
8629 else if (op == 0xd1)
8630 printf (" __c6xabi_pop_rts");
8631 else if (op == 0xd2)
8632 {
8633 unsigned char buf[9];
8634 unsigned int i, len;
8635 unsigned long offset;
a734115a 8636
fa197c1c
PB		 8637 for (i = 0; i < sizeof (buf); i++)
8638 {
8639 GET_OP (buf[i]);
8640 if ((buf[i] & 0x80) == 0)
8641 break;
8642 }
0eff7165
NC		 8643 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8644 if (i == sizeof (buf))
8645 {
0eff7165 8646 warn (_("Corrupt stack pointer adjustment detected\n"));
32ec8896 8647 return FALSE;
0eff7165 8648 }
948f632f 8649
f6f0e17b 8650 offset = read_uleb128 (buf, &len, buf + i + 1);
fa197c1c
PB		 8651 assert (len == i + 1);
8652 offset = offset * 8 + 0x408;
8653 printf (_("sp = sp + %ld"), offset);
8654 }
8655 else if ((op & 0xf0) == 0xe0)
8656 {
8657 if ((op & 0x0f) == 7)
8658 printf (" RETURN");
8659 else
8660 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8661 }
8662 else
8663 {
8664 printf (_(" [unsupported opcode]"));
8665 }
8666 putchar ('\n');
8667 }
32ec8896
NC		 8668
8669 return TRUE;
fa197c1c
PB		 8670}
8671
8672static bfd_vma
a734115a 8673arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 8674{
8675 bfd_vma offset;
8676
8677 offset = word & 0x7fffffff;
8678 if (offset & 0x40000000)
8679 offset |= ~ (bfd_vma) 0x7fffffff;
8680
8681 if (elf_header.e_machine == EM_TI_C6000)
8682 offset <<= 1;
8683
8684 return offset + where;
8685}
8686
32ec8896 8687static bfd_boolean
1b31d05e
NC		 8688decode_arm_unwind (struct arm_unw_aux_info * aux,
8689 unsigned int word,
8690 unsigned int remaining,
8691 bfd_vma data_offset,
8692 Elf_Internal_Shdr * data_sec,
8693 struct arm_section * data_arm_sec)
fa197c1c
PB		 8694{
8695 int per_index;
8696 unsigned int more_words = 0;
37e14bc3 8697 struct absaddr addr;
1b31d05e 8698 bfd_vma sym_name = (bfd_vma) -1;
32ec8896 8699 bfd_boolean res = FALSE;
fa197c1c
PB		 8700
8701 if (remaining == 0)
8702 {
1b31d05e
NC		 8703 /* Fetch the first word.
8704 Note - when decoding an object file the address extracted
8705 here will always be 0. So we also pass in the sym_name
8706 parameter so that we can find the symbol associated with
8707 the personality routine. */
8708 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8709 & word, & addr, & sym_name))
32ec8896 8710 return FALSE;
1b31d05e 8711
fa197c1c
PB		 8712 remaining = 4;
8713 }
8714
8715 if ((word & 0x80000000) == 0)
8716 {
8717 /* Expand prel31 for personality routine. */
8718 bfd_vma fn;
8719 const char *procname;
8720
a734115a 8721 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 8722 printf (_(" Personality routine: "));
1b31d05e
NC		 8723 if (fn == 0
8724 && addr.section == SHN_UNDEF && addr.offset == 0
8725 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8726 {
8727 procname = aux->strtab + sym_name;
8728 print_vma (fn, PREFIX_HEX);
8729 if (procname)
8730 {
8731 fputs (" <", stdout);
8732 fputs (procname, stdout);
8733 fputc ('>', stdout);
8734 }
8735 }
8736 else
8737 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 8738 fputc ('\n', stdout);
8739
8740 /* The GCC personality routines use the standard compact
8741 encoding, starting with one byte giving the number of
8742 words. */
8743 if (procname != NULL
8744 && (const_strneq (procname, "__gcc_personality_v0")
8745 || const_strneq (procname, "__gxx_personality_v0")
8746 || const_strneq (procname, "__gcj_personality_v0")
8747 || const_strneq (procname, "__gnu_objc_personality_v0")))
8748 {
8749 remaining = 0;
8750 more_words = 1;
8751 ADVANCE;
8752 if (!remaining)
8753 {
8754 printf (_(" [Truncated data]\n"));
32ec8896 8755 return FALSE;
fa197c1c
PB		 8756 }
8757 more_words = word >> 24;
8758 word <<= 8;
8759 remaining--;
8760 per_index = -1;
8761 }
8762 else
32ec8896 8763 return TRUE;
fa197c1c
PB		 8764 }
8765 else
8766 {
1b31d05e 8767 /* ARM EHABI Section 6.3:
0b4362b0 8768
1b31d05e 8769 An exception-handling table entry for the compact model looks like:
0b4362b0 8770
1b31d05e
NC		 8771 31 30-28 27-24 23-0
8772 -- ----- ----- ----
8773 1 0 index Data for personalityRoutine[index] */
8774
8775 if (elf_header.e_machine == EM_ARM
8776 && (word & 0x70000000))
32ec8896
NC		 8777 {
8778 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8779 res = FALSE;
8780 }
1b31d05e 8781
fa197c1c 8782 per_index = (word >> 24) & 0x7f;
1b31d05e 8783 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 8784 if (per_index == 0)
8785 {
8786 more_words = 0;
8787 word <<= 8;
8788 remaining--;
8789 }
8790 else if (per_index < 3)
8791 {
8792 more_words = (word >> 16) & 0xff;
8793 word <<= 16;
8794 remaining -= 2;
8795 }
8796 }
8797
8798 switch (elf_header.e_machine)
8799 {
8800 case EM_ARM:
8801 if (per_index < 3)
8802 {
32ec8896
NC		 8803 if (! decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8804 data_offset, data_sec, data_arm_sec))
8805 res = FALSE;
fa197c1c
PB		 8806 }
8807 else
1b31d05e
NC		 8808 {
8809 warn (_("Unknown ARM compact model index encountered\n"));
8810 printf (_(" [reserved]\n"));
32ec8896 8811 res = FALSE;
1b31d05e 8812 }
fa197c1c
PB		 8813 break;
8814
8815 case EM_TI_C6000:
8816 if (per_index < 3)
8817 {
32ec8896
NC		 8818 if (! decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
8819 data_offset, data_sec, data_arm_sec))
8820 res = FALSE;
fa197c1c
PB		 8821 }
8822 else if (per_index < 5)
8823 {
8824 if (((word >> 17) & 0x7f) == 0x7f)
8825 printf (_(" Restore stack from frame pointer\n"));
8826 else
8827 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
8828 printf (_(" Registers restored: "));
8829 if (per_index == 4)
8830 printf (" (compact) ");
8831 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8832 putchar ('\n');
8833 printf (_(" Return register: %s\n"),
8834 tic6x_unwind_regnames[word & 0xf]);
8835 }
8836 else
1b31d05e 8837 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 8838 break;
8839
8840 default:
74e1a04b 8841 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
1b31d05e 8842 elf_header.e_machine);
32ec8896 8843 res = FALSE;
fa197c1c 8844 }
0b6ae522
DJ		 8845
8846 /* Decode the descriptors. Not implemented. */
32ec8896
NC		 8847
8848 return res;
0b6ae522
DJ		 8849}
8850
32ec8896 8851static bfd_boolean
0b6ae522
DJ		 8852dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8853{
8854 struct arm_section exidx_arm_sec, extab_arm_sec;
8855 unsigned int i, exidx_len;
948f632f 8856 unsigned long j, nfuns;
32ec8896 8857 bfd_boolean res = TRUE;
0b6ae522
DJ		 8858
8859 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8860 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8861 exidx_len = exidx_sec->sh_size / 8;
8862
948f632f
DA		 8863 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8864 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8865 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8866 aux->funtab[nfuns++] = aux->symtab[j];
8867 aux->nfuns = nfuns;
8868 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8869
0b6ae522
DJ		 8870 for (i = 0; i < exidx_len; i++)
8871 {
8872 unsigned int exidx_fn, exidx_entry;
8873 struct absaddr fn_addr, entry_addr;
8874 bfd_vma fn;
8875
8876 fputc ('\n', stdout);
8877
1b31d05e
NC		 8878 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8879 8 * i, & exidx_fn, & fn_addr, NULL)
8880 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8881 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 8882 {
948f632f 8883 free (aux->funtab);
1b31d05e
NC		 8884 arm_free_section (& exidx_arm_sec);
8885 arm_free_section (& extab_arm_sec);
32ec8896 8886 return FALSE;
0b6ae522
DJ		 8887 }
8888
83c257ca
NC		 8889 /* ARM EHABI, Section 5:
8890 An index table entry consists of 2 words.
8891 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8892 if (exidx_fn & 0x80000000)
32ec8896
NC		 8893 {
8894 warn (_("corrupt index table entry: %x\n"), exidx_fn);
8895 res = FALSE;
8896 }
83c257ca 8897
a734115a 8898 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 8899
a734115a 8900 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 8901 fputs (": ", stdout);
8902
8903 if (exidx_entry == 1)
8904 {
8905 print_vma (exidx_entry, PREFIX_HEX);
8906 fputs (" [cantunwind]\n", stdout);
8907 }
8908 else if (exidx_entry & 0x80000000)
8909 {
8910 print_vma (exidx_entry, PREFIX_HEX);
8911 fputc ('\n', stdout);
8912 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8913 }
8914 else
8915 {
8f73510c 8916 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 8917 Elf_Internal_Shdr *table_sec;
8918
8919 fputs ("@", stdout);
a734115a 8920 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 8921 print_vma (table, PREFIX_HEX);
8922 printf ("\n");
8923
8924 /* Locate the matching .ARM.extab. */
8925 if (entry_addr.section != SHN_UNDEF
8926 && entry_addr.section < elf_header.e_shnum)
8927 {
8928 table_sec = section_headers + entry_addr.section;
8929 table_offset = entry_addr.offset;
1a915552
NC		 8930 /* PR 18879 */
8931 if (table_offset > table_sec->sh_size
8932 || ((bfd_signed_vma) table_offset) < 0)
8933 {
8934 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8935 (unsigned long) table_offset,
8936 printable_section_name (table_sec));
32ec8896 8937 res = FALSE;
1a915552
NC		 8938 continue;
8939 }
0b6ae522
DJ		 8940 }
8941 else
8942 {
8943 table_sec = find_section_by_address (table);
8944 if (table_sec != NULL)
8945 table_offset = table - table_sec->sh_addr;
8946 }
32ec8896 8947
0b6ae522
DJ		 8948 if (table_sec == NULL)
8949 {
8950 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8951 (unsigned long) table);
32ec8896 8952 res = FALSE;
0b6ae522
DJ		 8953 continue;
8954 }
32ec8896
NC		 8955
8956 if (! decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8957 &extab_arm_sec))
8958 res = FALSE;
0b6ae522
DJ		 8959 }
8960 }
8961
8962 printf ("\n");
8963
948f632f 8964 free (aux->funtab);
0b6ae522
DJ		 8965 arm_free_section (&exidx_arm_sec);
8966 arm_free_section (&extab_arm_sec);
32ec8896
NC		 8967
8968 return res;
0b6ae522
DJ		 8969}
8970
fa197c1c 8971/* Used for both ARM and C6X unwinding tables. */
1b31d05e 8972
32ec8896 8973static bfd_boolean
0b6ae522
DJ		 8974arm_process_unwind (FILE *file)
8975{
8976 struct arm_unw_aux_info aux;
8977 Elf_Internal_Shdr *unwsec = NULL;
8978 Elf_Internal_Shdr *strsec;
8979 Elf_Internal_Shdr *sec;
8980 unsigned long i;
fa197c1c 8981 unsigned int sec_type;
32ec8896 8982 bfd_boolean res = TRUE;
0b6ae522 8983
fa197c1c
PB		 8984 switch (elf_header.e_machine)
8985 {
8986 case EM_ARM:
8987 sec_type = SHT_ARM_EXIDX;
8988 break;
8989
8990 case EM_TI_C6000:
8991 sec_type = SHT_C6000_UNWIND;
8992 break;
8993
0b4362b0 8994 default:
74e1a04b 8995 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
1b31d05e 8996 elf_header.e_machine);
32ec8896 8997 return FALSE;
fa197c1c
PB		 8998 }
8999
0b6ae522 9000 if (string_table == NULL)
32ec8896 9001 return FALSE;
1b31d05e
NC		 9002
9003 memset (& aux, 0, sizeof (aux));
9004 aux.file = file;
0b6ae522
DJ		 9005
9006 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
9007 {
9008 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
9009 {
ba5cdace 9010 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 9011
9012 strsec = section_headers + sec->sh_link;
74e1a04b
NC		 9013
9014 /* PR binutils/17531 file: 011-12666-0.004. */
9015 if (aux.strtab != NULL)
9016 {
4082ef84 9017 error (_("Multiple string tables found in file.\n"));
74e1a04b 9018 free (aux.strtab);
32ec8896 9019 res = FALSE;
74e1a04b 9020 }
0b6ae522
DJ		 9021 aux.strtab = get_data (NULL, file, strsec->sh_offset,
9022 1, strsec->sh_size, _("string table"));
9023 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9024 }
fa197c1c 9025 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 9026 unwsec = sec;
9027 }
9028
1b31d05e 9029 if (unwsec == NULL)
0b6ae522 9030 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 9031 else
9032 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
9033 {
9034 if (sec->sh_type == sec_type)
9035 {
9036 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
74e1a04b 9037 printable_section_name (sec),
1b31d05e
NC		 9038 (unsigned long) sec->sh_offset,
9039 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 9040
32ec8896
NC		 9041 if (! dump_arm_unwind (&aux, sec))
9042 res = FALSE;
1b31d05e
NC		 9043 }
9044 }
0b6ae522
DJ		 9045
9046 if (aux.symtab)
9047 free (aux.symtab);
9048 if (aux.strtab)
9049 free ((char *) aux.strtab);
32ec8896
NC		 9050
9051 return res;
0b6ae522
DJ		 9052}
9053
32ec8896 9054static bfd_boolean
2cf0635d 9055process_unwind (FILE * file)
57346661 9056{
2cf0635d
NC		 9057 struct unwind_handler
9058 {
32ec8896
NC		 9059 unsigned int machtype;
9060 bfd_boolean (* handler)(FILE *);
2cf0635d
NC		 9061 } handlers[] =
9062 {
0b6ae522 9063 { EM_ARM, arm_process_unwind },
57346661
AM		 9064 { EM_IA_64, ia64_process_unwind },
9065 { EM_PARISC, hppa_process_unwind },
fa197c1c 9066 { EM_TI_C6000, arm_process_unwind },
32ec8896 9067 { 0, NULL }
57346661
AM		 9068 };
9069 int i;
9070
9071 if (!do_unwind)
32ec8896 9072 return TRUE;
57346661
AM		 9073
9074 for (i = 0; handlers[i].handler != NULL; i++)
9075 if (elf_header.e_machine == handlers[i].machtype)
32ec8896 9076 return handlers[i].handler (file);
57346661 9077
1b31d05e
NC		 9078 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9079 get_machine_name (elf_header.e_machine));
32ec8896 9080 return TRUE;
57346661
AM		 9081}
9082
252b5132 9083static void
2cf0635d 9084dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 9085{
9086 switch (entry->d_tag)
9087 {
9088 case DT_MIPS_FLAGS:
9089 if (entry->d_un.d_val == 0)
4b68bca3 9090 printf (_("NONE"));
252b5132
RH		 9091 else
9092 {
9093 static const char * opts[] =
9094 {
9095 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9096 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9097 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9098 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9099 "RLD_ORDER_SAFE"
9100 };
9101 unsigned int cnt;
32ec8896 9102 bfd_boolean first = TRUE;
2b692964 9103
60bca95a 9104 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 9105 if (entry->d_un.d_val & (1 << cnt))
9106 {
9107 printf ("%s%s", first ? "" : " ", opts[cnt]);
32ec8896 9108 first = FALSE;
252b5132 9109 }
252b5132
RH		 9110 }
9111 break;
103f02d3 9112
252b5132 9113 case DT_MIPS_IVERSION:
d79b3d50 9114 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 9115 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 9116 else
76ca31c0
NC		 9117 {
9118 char buf[40];
9119 sprintf_vma (buf, entry->d_un.d_ptr);
9120 /* Note: coded this way so that there is a single string for translation. */
9121 printf (_("<corrupt: %s>"), buf);
9122 }
252b5132 9123 break;
103f02d3 9124
252b5132
RH		 9125 case DT_MIPS_TIME_STAMP:
9126 {
d5b07ef4 9127 char timebuf[128];
2cf0635d 9128 struct tm * tmp;
91d6fa6a 9129 time_t atime = entry->d_un.d_val;
82b1b41b 9130
91d6fa6a 9131 tmp = gmtime (&atime);
82b1b41b
NC		 9132 /* PR 17531: file: 6accc532. */
9133 if (tmp == NULL)
9134 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9135 else
9136 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9137 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9138 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 9139 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 9140 }
9141 break;
103f02d3 9142
252b5132
RH		 9143 case DT_MIPS_RLD_VERSION:
9144 case DT_MIPS_LOCAL_GOTNO:
9145 case DT_MIPS_CONFLICTNO:
9146 case DT_MIPS_LIBLISTNO:
9147 case DT_MIPS_SYMTABNO:
9148 case DT_MIPS_UNREFEXTNO:
9149 case DT_MIPS_HIPAGENO:
9150 case DT_MIPS_DELTA_CLASS_NO:
9151 case DT_MIPS_DELTA_INSTANCE_NO:
9152 case DT_MIPS_DELTA_RELOC_NO:
9153 case DT_MIPS_DELTA_SYM_NO:
9154 case DT_MIPS_DELTA_CLASSSYM_NO:
9155 case DT_MIPS_COMPACT_SIZE:
c69075ac 9156 print_vma (entry->d_un.d_val, DEC);
252b5132 9157 break;
103f02d3
UD		 9158
9159 default:
4b68bca3 9160 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 9161 }
4b68bca3 9162 putchar ('\n');
103f02d3
UD		 9163}
9164
103f02d3 9165static void
2cf0635d 9166dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 9167{
9168 switch (entry->d_tag)
9169 {
9170 case DT_HP_DLD_FLAGS:
9171 {
9172 static struct
9173 {
9174 long int bit;
2cf0635d 9175 const char * str;
5e220199
NC		 9176 }
9177 flags[] =
9178 {
9179 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9180 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9181 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9182 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9183 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9184 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9185 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9186 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9187 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9188 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 9189 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9190 { DT_HP_GST, "HP_GST" },
9191 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9192 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9193 { DT_HP_NODELETE, "HP_NODELETE" },
9194 { DT_HP_GROUP, "HP_GROUP" },
9195 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 9196 };
32ec8896 9197 bfd_boolean first = TRUE;
5e220199 9198 size_t cnt;
f7a99963 9199 bfd_vma val = entry->d_un.d_val;
103f02d3 9200
60bca95a 9201 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 9202 if (val & flags[cnt].bit)
30800947
NC		 9203 {
9204 if (! first)
9205 putchar (' ');
9206 fputs (flags[cnt].str, stdout);
32ec8896 9207 first = FALSE;
30800947
NC		 9208 val ^= flags[cnt].bit;
9209 }
76da6bbe 9210
103f02d3 9211 if (val != 0 || first)
f7a99963
NC		 9212 {
9213 if (! first)
9214 putchar (' ');
9215 print_vma (val, HEX);
9216 }
103f02d3
UD		 9217 }
9218 break;
76da6bbe 9219
252b5132 9220 default:
f7a99963
NC		 9221 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9222 break;
252b5132 9223 }
35b1837e 9224 putchar ('\n');
252b5132
RH		 9225}
9226
28f997cf
TG		 9227#ifdef BFD64
9228
9229/* VMS vs Unix time offset and factor. */
9230
9231#define VMS_EPOCH_OFFSET 35067168000000000LL
9232#define VMS_GRANULARITY_FACTOR 10000000
9233
9234/* Display a VMS time in a human readable format. */
9235
9236static void
9237print_vms_time (bfd_int64_t vmstime)
9238{
9239 struct tm *tm;
9240 time_t unxtime;
9241
9242 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9243 tm = gmtime (&unxtime);
9244 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9245 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9246 tm->tm_hour, tm->tm_min, tm->tm_sec);
9247}
9248#endif /* BFD64 */
9249
ecc51f48 9250static void
2cf0635d 9251dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 9252{
9253 switch (entry->d_tag)
9254 {
0de14b54 9255 case DT_IA_64_PLT_RESERVE:
bdf4d63a 9256 /* First 3 slots reserved. */
ecc51f48
NC		 9257 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9258 printf (" -- ");
9259 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 9260 break;
9261
28f997cf
TG		 9262 case DT_IA_64_VMS_LINKTIME:
9263#ifdef BFD64
9264 print_vms_time (entry->d_un.d_val);
9265#endif
9266 break;
9267
9268 case DT_IA_64_VMS_LNKFLAGS:
9269 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9270 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9271 printf (" CALL_DEBUG");
9272 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9273 printf (" NOP0BUFS");
9274 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9275 printf (" P0IMAGE");
9276 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9277 printf (" MKTHREADS");
9278 if (entry->d_un.d_val & VMS_LF_UPCALLS)
9279 printf (" UPCALLS");
9280 if (entry->d_un.d_val & VMS_LF_IMGSTA)
9281 printf (" IMGSTA");
9282 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9283 printf (" INITIALIZE");
9284 if (entry->d_un.d_val & VMS_LF_MAIN)
9285 printf (" MAIN");
9286 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9287 printf (" EXE_INIT");
9288 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9289 printf (" TBK_IN_IMG");
9290 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9291 printf (" DBG_IN_IMG");
9292 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9293 printf (" TBK_IN_DSF");
9294 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9295 printf (" DBG_IN_DSF");
9296 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9297 printf (" SIGNATURES");
9298 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9299 printf (" REL_SEG_OFF");
9300 break;
9301
bdf4d63a
JJ		 9302 default:
9303 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9304 break;
ecc51f48 9305 }
bdf4d63a 9306 putchar ('\n');
ecc51f48
NC		 9307}
9308
32ec8896 9309static bfd_boolean
2cf0635d 9310get_32bit_dynamic_section (FILE * file)
252b5132 9311{
2cf0635d
NC		 9312 Elf32_External_Dyn * edyn;
9313 Elf32_External_Dyn * ext;
9314 Elf_Internal_Dyn * entry;
103f02d3 9315
3f5e193b
NC		 9316 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
9317 dynamic_size, _("dynamic section"));
a6e9f9df 9318 if (!edyn)
32ec8896 9319 return FALSE;
103f02d3 9320
071436c6
NC		 9321 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9322 might not have the luxury of section headers. Look for the DT_NULL
9323 terminator to determine the number of entries. */
ba2685cc 9324 for (ext = edyn, dynamic_nent = 0;
53c3012c 9325 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
ba2685cc
AM		 9326 ext++)
9327 {
9328 dynamic_nent++;
9329 if (BYTE_GET (ext->d_tag) == DT_NULL)
9330 break;
9331 }
252b5132 9332
3f5e193b
NC		 9333 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9334 sizeof (* entry));
b2d38a17 9335 if (dynamic_section == NULL)
252b5132 9336 {
8b73c356
NC		 9337 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9338 (unsigned long) dynamic_nent);
9ea033b2 9339 free (edyn);
32ec8896 9340 return FALSE;
9ea033b2 9341 }
252b5132 9342
fb514b26 9343 for (ext = edyn, entry = dynamic_section;
ba2685cc 9344 entry < dynamic_section + dynamic_nent;
fb514b26 9345 ext++, entry++)
9ea033b2 9346 {
fb514b26
AM		 9347 entry->d_tag = BYTE_GET (ext->d_tag);
9348 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 9349 }
9350
9ea033b2
NC		 9351 free (edyn);
9352
32ec8896 9353 return TRUE;
9ea033b2
NC		 9354}
9355
32ec8896 9356static bfd_boolean
2cf0635d 9357get_64bit_dynamic_section (FILE * file)
9ea033b2 9358{
2cf0635d
NC		 9359 Elf64_External_Dyn * edyn;
9360 Elf64_External_Dyn * ext;
9361 Elf_Internal_Dyn * entry;
103f02d3 9362
071436c6 9363 /* Read in the data. */
3f5e193b
NC		 9364 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
9365 dynamic_size, _("dynamic section"));
a6e9f9df 9366 if (!edyn)
32ec8896 9367 return FALSE;
103f02d3 9368
071436c6
NC		 9369 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9370 might not have the luxury of section headers. Look for the DT_NULL
9371 terminator to determine the number of entries. */
ba2685cc 9372 for (ext = edyn, dynamic_nent = 0;
53c3012c
AM		 9373 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9374 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
ba2685cc
AM		 9375 ext++)
9376 {
9377 dynamic_nent++;
66543521 9378 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 9379 break;
9380 }
252b5132 9381
3f5e193b
NC		 9382 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9383 sizeof (* entry));
b2d38a17 9384 if (dynamic_section == NULL)
252b5132 9385 {
8b73c356
NC		 9386 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9387 (unsigned long) dynamic_nent);
252b5132 9388 free (edyn);
32ec8896 9389 return FALSE;
252b5132
RH		 9390 }
9391
071436c6 9392 /* Convert from external to internal formats. */
fb514b26 9393 for (ext = edyn, entry = dynamic_section;
ba2685cc 9394 entry < dynamic_section + dynamic_nent;
fb514b26 9395 ext++, entry++)
252b5132 9396 {
66543521
AM		 9397 entry->d_tag = BYTE_GET (ext->d_tag);
9398 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 9399 }
9400
9401 free (edyn);
9402
32ec8896 9403 return TRUE;
9ea033b2
NC		 9404}
9405
e9e44622
JJ		 9406static void
9407print_dynamic_flags (bfd_vma flags)
d1133906 9408{
32ec8896 9409 bfd_boolean first = TRUE;
13ae64f3 9410
d1133906
NC		 9411 while (flags)
9412 {
9413 bfd_vma flag;
9414
9415 flag = flags & - flags;
9416 flags &= ~ flag;
9417
e9e44622 9418 if (first)
32ec8896 9419 first = FALSE;
e9e44622
JJ		 9420 else
9421 putc (' ', stdout);
13ae64f3 9422
d1133906
NC		 9423 switch (flag)
9424 {
e9e44622
JJ		 9425 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
9426 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
9427 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
9428 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
9429 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 9430 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 9431 }
9432 }
e9e44622 9433 puts ("");
d1133906
NC		 9434}
9435
b2d38a17
NC		 9436/* Parse and display the contents of the dynamic section. */
9437
32ec8896 9438static bfd_boolean
2cf0635d 9439process_dynamic_section (FILE * file)
9ea033b2 9440{
2cf0635d 9441 Elf_Internal_Dyn * entry;
9ea033b2
NC		 9442
9443 if (dynamic_size == 0)
9444 {
9445 if (do_dynamic)
b2d38a17 9446 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2 9447
32ec8896 9448 return TRUE;
9ea033b2
NC		 9449 }
9450
9451 if (is_32bit_elf)
9452 {
b2d38a17 9453 if (! get_32bit_dynamic_section (file))
32ec8896
NC		 9454 return FALSE;
9455 }
9456 else
9457 {
9458 if (! get_64bit_dynamic_section (file))
9459 return FALSE;
9ea033b2 9460 }
9ea033b2 9461
252b5132
RH		 9462 /* Find the appropriate symbol table. */
9463 if (dynamic_symbols == NULL)
9464 {
86dba8ee
AM		 9465 for (entry = dynamic_section;
9466 entry < dynamic_section + dynamic_nent;
9467 ++entry)
252b5132 9468 {
c8286bd1 9469 Elf_Internal_Shdr section;
252b5132
RH		 9470
9471 if (entry->d_tag != DT_SYMTAB)
9472 continue;
9473
9474 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9475
9476 /* Since we do not know how big the symbol table is,
9477 we default to reading in the entire file (!) and
9478 processing that. This is overkill, I know, but it
e3c8793a 9479 should work. */
d93f0186 9480 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
7296a62a
NC		 9481 if ((bfd_size_type) section.sh_offset > current_file_size)
9482 {
9483 /* See PR 21379 for a reproducer. */
9484 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9485 return FALSE;
9486 }
252b5132 9487
fb52b2f4
NC		 9488 if (archive_file_offset != 0)
9489 section.sh_size = archive_file_size - section.sh_offset;
9490 else
9491 {
9492 if (fseek (file, 0, SEEK_END))
591a748a 9493 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 9494
9495 section.sh_size = ftell (file) - section.sh_offset;
9496 }
252b5132 9497
9ea033b2 9498 if (is_32bit_elf)
9ad5cbcf 9499 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 9500 else
9ad5cbcf 9501 section.sh_entsize = sizeof (Elf64_External_Sym);
071436c6 9502 section.sh_name = string_table_length;
252b5132 9503
ba5cdace 9504 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 9505 if (num_dynamic_syms < 1)
252b5132
RH		 9506 {
9507 error (_("Unable to determine the number of symbols to load\n"));
9508 continue;
9509 }
252b5132
RH		 9510 }
9511 }
9512
9513 /* Similarly find a string table. */
9514 if (dynamic_strings == NULL)
9515 {
86dba8ee
AM		 9516 for (entry = dynamic_section;
9517 entry < dynamic_section + dynamic_nent;
9518 ++entry)
252b5132
RH		 9519 {
9520 unsigned long offset;
b34976b6 9521 long str_tab_len;
252b5132
RH		 9522
9523 if (entry->d_tag != DT_STRTAB)
9524 continue;
9525
9526 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9527
9528 /* Since we do not know how big the string table is,
9529 we default to reading in the entire file (!) and
9530 processing that. This is overkill, I know, but it
e3c8793a 9531 should work. */
252b5132 9532
d93f0186 9533 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 9534
9535 if (archive_file_offset != 0)
9536 str_tab_len = archive_file_size - offset;
9537 else
9538 {
9539 if (fseek (file, 0, SEEK_END))
9540 error (_("Unable to seek to end of file\n"));
9541 str_tab_len = ftell (file) - offset;
9542 }
252b5132
RH		 9543
9544 if (str_tab_len < 1)
9545 {
9546 error
9547 (_("Unable to determine the length of the dynamic string table\n"));
9548 continue;
9549 }
9550
3f5e193b
NC		 9551 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
9552 str_tab_len,
9553 _("dynamic string table"));
59245841 9554 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 9555 break;
9556 }
9557 }
9558
9559 /* And find the syminfo section if available. */
9560 if (dynamic_syminfo == NULL)
9561 {
3e8bba36 9562 unsigned long syminsz = 0;
252b5132 9563
86dba8ee
AM		 9564 for (entry = dynamic_section;
9565 entry < dynamic_section + dynamic_nent;
9566 ++entry)
252b5132
RH		 9567 {
9568 if (entry->d_tag == DT_SYMINENT)
9569 {
9570 /* Note: these braces are necessary to avoid a syntax
9571 error from the SunOS4 C compiler. */
049b0c3a
NC		 9572 /* PR binutils/17531: A corrupt file can trigger this test.
9573 So do not use an assert, instead generate an error message. */
9574 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
071436c6 9575 error (_("Bad value (%d) for SYMINENT entry\n"),
049b0c3a 9576 (int) entry->d_un.d_val);
252b5132
RH		 9577 }
9578 else if (entry->d_tag == DT_SYMINSZ)
9579 syminsz = entry->d_un.d_val;
9580 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 9581 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
9582 syminsz);
252b5132
RH		 9583 }
9584
9585 if (dynamic_syminfo_offset != 0 && syminsz != 0)
9586 {
2cf0635d
NC		 9587 Elf_External_Syminfo * extsyminfo;
9588 Elf_External_Syminfo * extsym;
9589 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 9590
9591 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 9592 extsyminfo = (Elf_External_Syminfo *)
9593 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
9594 _("symbol information"));
a6e9f9df 9595 if (!extsyminfo)
32ec8896 9596 return FALSE;
252b5132 9597
3f5e193b 9598 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 9599 if (dynamic_syminfo == NULL)
9600 {
8b73c356
NC		 9601 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9602 (unsigned long) syminsz);
32ec8896 9603 return FALSE;
252b5132
RH		 9604 }
9605
9606 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 9607 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9608 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9609 ++syminfo, ++extsym)
252b5132 9610 {
86dba8ee
AM		 9611 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9612 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 9613 }
9614
9615 free (extsyminfo);
9616 }
9617 }
9618
9619 if (do_dynamic && dynamic_addr)
8b73c356
NC		 9620 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9621 dynamic_addr, (unsigned long) dynamic_nent);
252b5132
RH		 9622 if (do_dynamic)
9623 printf (_(" Tag Type Name/Value\n"));
9624
86dba8ee
AM		 9625 for (entry = dynamic_section;
9626 entry < dynamic_section + dynamic_nent;
9627 entry++)
252b5132
RH		 9628 {
9629 if (do_dynamic)
f7a99963 9630 {
2cf0635d 9631 const char * dtype;
e699b9ff 9632
f7a99963
NC		 9633 putchar (' ');
9634 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 9635 dtype = get_dynamic_type (entry->d_tag);
9636 printf (" (%s)%*s", dtype,
32ec8896 9637 ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
f7a99963 9638 }
252b5132
RH		 9639
9640 switch (entry->d_tag)
9641 {
d1133906
NC		 9642 case DT_FLAGS:
9643 if (do_dynamic)
e9e44622 9644 print_dynamic_flags (entry->d_un.d_val);
d1133906 9645 break;
76da6bbe 9646
252b5132
RH		 9647 case DT_AUXILIARY:
9648 case DT_FILTER:
019148e4
L		 9649 case DT_CONFIG:
9650 case DT_DEPAUDIT:
9651 case DT_AUDIT:
252b5132
RH		 9652 if (do_dynamic)
9653 {
019148e4 9654 switch (entry->d_tag)
b34976b6 9655 {
019148e4
L		 9656 case DT_AUXILIARY:
9657 printf (_("Auxiliary library"));
9658 break;
9659
9660 case DT_FILTER:
9661 printf (_("Filter library"));
9662 break;
9663
b34976b6 9664 case DT_CONFIG:
019148e4
L		 9665 printf (_("Configuration file"));
9666 break;
9667
9668 case DT_DEPAUDIT:
9669 printf (_("Dependency audit library"));
9670 break;
9671
9672 case DT_AUDIT:
9673 printf (_("Audit library"));
9674 break;
9675 }
252b5132 9676
d79b3d50
NC		 9677 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9678 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 9679 else
f7a99963
NC		 9680 {
9681 printf (": ");
9682 print_vma (entry->d_un.d_val, PREFIX_HEX);
9683 putchar ('\n');
9684 }
252b5132
RH		 9685 }
9686 break;
9687
dcefbbbd 9688 case DT_FEATURE:
252b5132
RH		 9689 if (do_dynamic)
9690 {
9691 printf (_("Flags:"));
86f55779 9692
252b5132
RH		 9693 if (entry->d_un.d_val == 0)
9694 printf (_(" None\n"));
9695 else
9696 {
9697 unsigned long int val = entry->d_un.d_val;
86f55779 9698
252b5132
RH		 9699 if (val & DTF_1_PARINIT)
9700 {
9701 printf (" PARINIT");
9702 val ^= DTF_1_PARINIT;
9703 }
dcefbbbd
L		 9704 if (val & DTF_1_CONFEXP)
9705 {
9706 printf (" CONFEXP");
9707 val ^= DTF_1_CONFEXP;
9708 }
252b5132
RH		 9709 if (val != 0)
9710 printf (" %lx", val);
9711 puts ("");
9712 }
9713 }
9714 break;
9715
9716 case DT_POSFLAG_1:
9717 if (do_dynamic)
9718 {
9719 printf (_("Flags:"));
86f55779 9720
252b5132
RH		 9721 if (entry->d_un.d_val == 0)
9722 printf (_(" None\n"));
9723 else
9724 {
9725 unsigned long int val = entry->d_un.d_val;
86f55779 9726
252b5132
RH		 9727 if (val & DF_P1_LAZYLOAD)
9728 {
9729 printf (" LAZYLOAD");
9730 val ^= DF_P1_LAZYLOAD;
9731 }
9732 if (val & DF_P1_GROUPPERM)
9733 {
9734 printf (" GROUPPERM");
9735 val ^= DF_P1_GROUPPERM;
9736 }
9737 if (val != 0)
9738 printf (" %lx", val);
9739 puts ("");
9740 }
9741 }
9742 break;
9743
9744 case DT_FLAGS_1:
9745 if (do_dynamic)
9746 {
9747 printf (_("Flags:"));
9748 if (entry->d_un.d_val == 0)
9749 printf (_(" None\n"));
9750 else
9751 {
9752 unsigned long int val = entry->d_un.d_val;
86f55779 9753
252b5132
RH		 9754 if (val & DF_1_NOW)
9755 {
9756 printf (" NOW");
9757 val ^= DF_1_NOW;
9758 }
9759 if (val & DF_1_GLOBAL)
9760 {
9761 printf (" GLOBAL");
9762 val ^= DF_1_GLOBAL;
9763 }
9764 if (val & DF_1_GROUP)
9765 {
9766 printf (" GROUP");
9767 val ^= DF_1_GROUP;
9768 }
9769 if (val & DF_1_NODELETE)
9770 {
9771 printf (" NODELETE");
9772 val ^= DF_1_NODELETE;
9773 }
9774 if (val & DF_1_LOADFLTR)
9775 {
9776 printf (" LOADFLTR");
9777 val ^= DF_1_LOADFLTR;
9778 }
9779 if (val & DF_1_INITFIRST)
9780 {
9781 printf (" INITFIRST");
9782 val ^= DF_1_INITFIRST;
9783 }
9784 if (val & DF_1_NOOPEN)
9785 {
9786 printf (" NOOPEN");
9787 val ^= DF_1_NOOPEN;
9788 }
9789 if (val & DF_1_ORIGIN)
9790 {
9791 printf (" ORIGIN");
9792 val ^= DF_1_ORIGIN;
9793 }
9794 if (val & DF_1_DIRECT)
9795 {
9796 printf (" DIRECT");
9797 val ^= DF_1_DIRECT;
9798 }
9799 if (val & DF_1_TRANS)
9800 {
9801 printf (" TRANS");
9802 val ^= DF_1_TRANS;
9803 }
9804 if (val & DF_1_INTERPOSE)
9805 {
9806 printf (" INTERPOSE");
9807 val ^= DF_1_INTERPOSE;
9808 }
f7db6139 9809 if (val & DF_1_NODEFLIB)
dcefbbbd 9810 {
f7db6139
L		 9811 printf (" NODEFLIB");
9812 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 9813 }
9814 if (val & DF_1_NODUMP)
9815 {
9816 printf (" NODUMP");
9817 val ^= DF_1_NODUMP;
9818 }
34b60028 9819 if (val & DF_1_CONFALT)
dcefbbbd 9820 {
34b60028
L		 9821 printf (" CONFALT");
9822 val ^= DF_1_CONFALT;
9823 }
9824 if (val & DF_1_ENDFILTEE)
9825 {
9826 printf (" ENDFILTEE");
9827 val ^= DF_1_ENDFILTEE;
9828 }
9829 if (val & DF_1_DISPRELDNE)
9830 {
9831 printf (" DISPRELDNE");
9832 val ^= DF_1_DISPRELDNE;
9833 }
9834 if (val & DF_1_DISPRELPND)
9835 {
9836 printf (" DISPRELPND");
9837 val ^= DF_1_DISPRELPND;
9838 }
9839 if (val & DF_1_NODIRECT)
9840 {
9841 printf (" NODIRECT");
9842 val ^= DF_1_NODIRECT;
9843 }
9844 if (val & DF_1_IGNMULDEF)
9845 {
9846 printf (" IGNMULDEF");
9847 val ^= DF_1_IGNMULDEF;
9848 }
9849 if (val & DF_1_NOKSYMS)
9850 {
9851 printf (" NOKSYMS");
9852 val ^= DF_1_NOKSYMS;
9853 }
9854 if (val & DF_1_NOHDR)
9855 {
9856 printf (" NOHDR");
9857 val ^= DF_1_NOHDR;
9858 }
9859 if (val & DF_1_EDITED)
9860 {
9861 printf (" EDITED");
9862 val ^= DF_1_EDITED;
9863 }
9864 if (val & DF_1_NORELOC)
9865 {
9866 printf (" NORELOC");
9867 val ^= DF_1_NORELOC;
9868 }
9869 if (val & DF_1_SYMINTPOSE)
9870 {
9871 printf (" SYMINTPOSE");
9872 val ^= DF_1_SYMINTPOSE;
9873 }
9874 if (val & DF_1_GLOBAUDIT)
9875 {
9876 printf (" GLOBAUDIT");
9877 val ^= DF_1_GLOBAUDIT;
9878 }
9879 if (val & DF_1_SINGLETON)
9880 {
9881 printf (" SINGLETON");
9882 val ^= DF_1_SINGLETON;
dcefbbbd 9883 }
5c383f02
RO		 9884 if (val & DF_1_STUB)
9885 {
9886 printf (" STUB");
9887 val ^= DF_1_STUB;
9888 }
9889 if (val & DF_1_PIE)
9890 {
9891 printf (" PIE");
9892 val ^= DF_1_PIE;
9893 }
252b5132
RH		 9894 if (val != 0)
9895 printf (" %lx", val);
9896 puts ("");
9897 }
9898 }
9899 break;
9900
9901 case DT_PLTREL:
566b0d53 9902 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9903 if (do_dynamic)
9904 puts (get_dynamic_type (entry->d_un.d_val));
9905 break;
9906
9907 case DT_NULL :
9908 case DT_NEEDED :
9909 case DT_PLTGOT :
9910 case DT_HASH :
9911 case DT_STRTAB :
9912 case DT_SYMTAB :
9913 case DT_RELA :
9914 case DT_INIT :
9915 case DT_FINI :
9916 case DT_SONAME :
9917 case DT_RPATH :
9918 case DT_SYMBOLIC:
9919 case DT_REL :
9920 case DT_DEBUG :
9921 case DT_TEXTREL :
9922 case DT_JMPREL :
019148e4 9923 case DT_RUNPATH :
252b5132
RH		 9924 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9925
9926 if (do_dynamic)
9927 {
2cf0635d 9928 char * name;
252b5132 9929
d79b3d50
NC		 9930 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9931 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9932 else
d79b3d50 9933 name = NULL;
252b5132
RH		 9934
9935 if (name)
9936 {
9937 switch (entry->d_tag)
9938 {
9939 case DT_NEEDED:
9940 printf (_("Shared library: [%s]"), name);
9941
18bd398b 9942 if (streq (name, program_interpreter))
f7a99963 9943 printf (_(" program interpreter"));
252b5132
RH		 9944 break;
9945
9946 case DT_SONAME:
f7a99963 9947 printf (_("Library soname: [%s]"), name);
252b5132
RH		 9948 break;
9949
9950 case DT_RPATH:
f7a99963 9951 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 9952 break;
9953
019148e4
L		 9954 case DT_RUNPATH:
9955 printf (_("Library runpath: [%s]"), name);
9956 break;
9957
252b5132 9958 default:
f7a99963
NC		 9959 print_vma (entry->d_un.d_val, PREFIX_HEX);
9960 break;
252b5132
RH		 9961 }
9962 }
9963 else
f7a99963
NC		 9964 print_vma (entry->d_un.d_val, PREFIX_HEX);
9965
9966 putchar ('\n');
252b5132
RH		 9967 }
9968 break;
9969
9970 case DT_PLTRELSZ:
9971 case DT_RELASZ :
9972 case DT_STRSZ :
9973 case DT_RELSZ :
9974 case DT_RELAENT :
9975 case DT_SYMENT :
9976 case DT_RELENT :
566b0d53 9977 dynamic_info[entry->d_tag] = entry->d_un.d_val;
1a0670f3 9978 /* Fall through. */
252b5132
RH		 9979 case DT_PLTPADSZ:
9980 case DT_MOVEENT :
9981 case DT_MOVESZ :
9982 case DT_INIT_ARRAYSZ:
9983 case DT_FINI_ARRAYSZ:
047b2264
JJ		 9984 case DT_GNU_CONFLICTSZ:
9985 case DT_GNU_LIBLISTSZ:
252b5132 9986 if (do_dynamic)
f7a99963
NC		 9987 {
9988 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 9989 printf (_(" (bytes)\n"));
f7a99963 9990 }
252b5132
RH		 9991 break;
9992
9993 case DT_VERDEFNUM:
9994 case DT_VERNEEDNUM:
9995 case DT_RELACOUNT:
9996 case DT_RELCOUNT:
9997 if (do_dynamic)
f7a99963
NC		 9998 {
9999 print_vma (entry->d_un.d_val, UNSIGNED);
10000 putchar ('\n');
10001 }
252b5132
RH		 10002 break;
10003
10004 case DT_SYMINSZ:
10005 case DT_SYMINENT:
10006 case DT_SYMINFO:
10007 case DT_USED:
10008 case DT_INIT_ARRAY:
10009 case DT_FINI_ARRAY:
10010 if (do_dynamic)
10011 {
d79b3d50
NC		 10012 if (entry->d_tag == DT_USED
10013 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 10014 {
2cf0635d 10015 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 10016
b34976b6 10017 if (*name)
252b5132
RH		 10018 {
10019 printf (_("Not needed object: [%s]\n"), name);
10020 break;
10021 }
10022 }
103f02d3 10023
f7a99963
NC		 10024 print_vma (entry->d_un.d_val, PREFIX_HEX);
10025 putchar ('\n');
252b5132
RH		 10026 }
10027 break;
10028
10029 case DT_BIND_NOW:
10030 /* The value of this entry is ignored. */
35b1837e
AM		 10031 if (do_dynamic)
10032 putchar ('\n');
252b5132 10033 break;
103f02d3 10034
047b2264
JJ		 10035 case DT_GNU_PRELINKED:
10036 if (do_dynamic)
10037 {
2cf0635d 10038 struct tm * tmp;
91d6fa6a 10039 time_t atime = entry->d_un.d_val;
047b2264 10040
91d6fa6a 10041 tmp = gmtime (&atime);
071436c6
NC		 10042 /* PR 17533 file: 041-1244816-0.004. */
10043 if (tmp == NULL)
5a2cbcf4
L		 10044 printf (_("<corrupt time val: %lx"),
10045 (unsigned long) atime);
071436c6
NC		 10046 else
10047 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10048 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10049 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 10050
10051 }
10052 break;
10053
fdc90cb4
JJ		 10054 case DT_GNU_HASH:
10055 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10056 if (do_dynamic)
10057 {
10058 print_vma (entry->d_un.d_val, PREFIX_HEX);
10059 putchar ('\n');
10060 }
10061 break;
10062
252b5132
RH		 10063 default:
10064 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 10065 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 10066 entry->d_un.d_val;
10067
10068 if (do_dynamic)
10069 {
10070 switch (elf_header.e_machine)
10071 {
10072 case EM_MIPS:
4fe85591 10073 case EM_MIPS_RS3_LE:
b2d38a17 10074 dynamic_section_mips_val (entry);
252b5132 10075 break;
103f02d3 10076 case EM_PARISC:
b2d38a17 10077 dynamic_section_parisc_val (entry);
103f02d3 10078 break;
ecc51f48 10079 case EM_IA_64:
b2d38a17 10080 dynamic_section_ia64_val (entry);
ecc51f48 10081 break;
252b5132 10082 default:
f7a99963
NC		 10083 print_vma (entry->d_un.d_val, PREFIX_HEX);
10084 putchar ('\n');
252b5132
RH		 10085 }
10086 }
10087 break;
10088 }
10089 }
10090
32ec8896 10091 return TRUE;
252b5132
RH		 10092}
10093
10094static char *
d3ba0551 10095get_ver_flags (unsigned int flags)
252b5132 10096{
b34976b6 10097 static char buff[32];
252b5132
RH		 10098
10099 buff[0] = 0;
10100
10101 if (flags == 0)
10102 return _("none");
10103
10104 if (flags & VER_FLG_BASE)
7bb1ad17 10105 strcat (buff, "BASE");
252b5132
RH		 10106
10107 if (flags & VER_FLG_WEAK)
10108 {
10109 if (flags & VER_FLG_BASE)
7bb1ad17 10110 strcat (buff, " | ");
252b5132 10111
7bb1ad17 10112 strcat (buff, "WEAK");
252b5132
RH		 10113 }
10114
44ec90b9
RO		 10115 if (flags & VER_FLG_INFO)
10116 {
10117 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
7bb1ad17 10118 strcat (buff, " | ");
44ec90b9 10119
7bb1ad17 10120 strcat (buff, "INFO");
44ec90b9
RO		 10121 }
10122
10123 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
7bb1ad17
MR		 10124 {
10125 if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10126 strcat (buff, " | ");
10127
10128 strcat (buff, _("<unknown>"));
10129 }
252b5132
RH		 10130
10131 return buff;
10132}
10133
10134/* Display the contents of the version sections. */
98fb390a 10135
32ec8896 10136static bfd_boolean
2cf0635d 10137process_version_sections (FILE * file)
252b5132 10138{
2cf0635d 10139 Elf_Internal_Shdr * section;
b34976b6 10140 unsigned i;
32ec8896 10141 bfd_boolean found = FALSE;
252b5132
RH		 10142
10143 if (! do_version)
32ec8896 10144 return TRUE;
252b5132
RH		 10145
10146 for (i = 0, section = section_headers;
10147 i < elf_header.e_shnum;
b34976b6 10148 i++, section++)
252b5132
RH		 10149 {
10150 switch (section->sh_type)
10151 {
10152 case SHT_GNU_verdef:
10153 {
2cf0635d 10154 Elf_External_Verdef * edefs;
b34976b6
AM		 10155 unsigned int idx;
10156 unsigned int cnt;
c9f02c3e 10157 unsigned int end;
2cf0635d 10158 char * endbuf;
252b5132 10159
32ec8896 10160 found = TRUE;
252b5132 10161
74e1a04b
NC		 10162 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
10163 printable_section_name (section),
10164 section->sh_info);
252b5132
RH		 10165
10166 printf (_(" Addr: 0x"));
10167 printf_vma (section->sh_addr);
233f82cf 10168 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 10169 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 10170 printable_section_name_from_index (section->sh_link));
252b5132 10171
3f5e193b
NC		 10172 edefs = (Elf_External_Verdef *)
10173 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
10174 _("version definition section"));
a6e9f9df
AM		 10175 if (!edefs)
10176 break;
59245841 10177 endbuf = (char *) edefs + section->sh_size;
252b5132 10178
c9f02c3e
MR		 10179 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
10180 end = (section->sh_info < section->sh_size
10181 ? section->sh_info : section->sh_size);
10182 for (idx = cnt = 0; cnt < end; ++cnt)
252b5132 10183 {
2cf0635d
NC		 10184 char * vstart;
10185 Elf_External_Verdef * edef;
b34976b6 10186 Elf_Internal_Verdef ent;
2cf0635d 10187 Elf_External_Verdaux * eaux;
b34976b6 10188 Elf_Internal_Verdaux aux;
5235cd68 10189 unsigned int isum;
b34976b6 10190 int j;
103f02d3 10191
222c2bf0 10192 /* Check for very large indices. */
7e26601c 10193 if (idx > (size_t) (endbuf - (char *) edefs))
dd24e3da
NC		 10194 break;
10195
252b5132 10196 vstart = ((char *) edefs) + idx;
54806181
AM		 10197 if (vstart + sizeof (*edef) > endbuf)
10198 break;
252b5132
RH		 10199
10200 edef = (Elf_External_Verdef *) vstart;
10201
10202 ent.vd_version = BYTE_GET (edef->vd_version);
10203 ent.vd_flags = BYTE_GET (edef->vd_flags);
10204 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
10205 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
10206 ent.vd_hash = BYTE_GET (edef->vd_hash);
10207 ent.vd_aux = BYTE_GET (edef->vd_aux);
10208 ent.vd_next = BYTE_GET (edef->vd_next);
10209
10210 printf (_(" %#06x: Rev: %d Flags: %s"),
10211 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10212
10213 printf (_(" Index: %d Cnt: %d "),
10214 ent.vd_ndx, ent.vd_cnt);
10215
4e3afec2
NC		 10216 /* Check for overflow and underflow. */
10217 if (ent.vd_aux + sizeof (* eaux) > (size_t) (endbuf - vstart)
10218 || (vstart + ent.vd_aux < vstart))
dd24e3da
NC		 10219 break;
10220
252b5132
RH		 10221 vstart += ent.vd_aux;
10222
10223 eaux = (Elf_External_Verdaux *) vstart;
10224
10225 aux.vda_name = BYTE_GET (eaux->vda_name);
10226 aux.vda_next = BYTE_GET (eaux->vda_next);
10227
d79b3d50
NC		 10228 if (VALID_DYNAMIC_NAME (aux.vda_name))
10229 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 10230 else
10231 printf (_("Name index: %ld\n"), aux.vda_name);
10232
10233 isum = idx + ent.vd_aux;
10234
b34976b6 10235 for (j = 1; j < ent.vd_cnt; j++)
252b5132 10236 {
dd24e3da 10237 /* Check for overflow. */
7e26601c 10238 if (aux.vda_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 10239 break;
10240
252b5132
RH		 10241 isum += aux.vda_next;
10242 vstart += aux.vda_next;
10243
10244 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 10245 if (vstart + sizeof (*eaux) > endbuf)
10246 break;
252b5132
RH		 10247
10248 aux.vda_name = BYTE_GET (eaux->vda_name);
10249 aux.vda_next = BYTE_GET (eaux->vda_next);
10250
d79b3d50 10251 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 10252 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 10253 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 10254 else
10255 printf (_(" %#06x: Parent %d, name index: %ld\n"),
10256 isum, j, aux.vda_name);
10257 }
dd24e3da 10258
54806181
AM		 10259 if (j < ent.vd_cnt)
10260 printf (_(" Version def aux past end of section\n"));
252b5132 10261
c9f02c3e
MR		 10262 /* PR 17531:
10263 file: id:000001,src:000172+005151,op:splice,rep:2. */
10264 if (idx + ent.vd_next < idx)
5d921cbd
NC		 10265 break;
10266
252b5132
RH		 10267 idx += ent.vd_next;
10268 }
dd24e3da 10269
54806181
AM		 10270 if (cnt < section->sh_info)
10271 printf (_(" Version definition past end of section\n"));
252b5132
RH		 10272
10273 free (edefs);
10274 }
10275 break;
103f02d3 10276
252b5132
RH		 10277 case SHT_GNU_verneed:
10278 {
2cf0635d 10279 Elf_External_Verneed * eneed;
b34976b6
AM		 10280 unsigned int idx;
10281 unsigned int cnt;
2cf0635d 10282 char * endbuf;
252b5132 10283
32ec8896 10284 found = TRUE;
252b5132 10285
72de5009 10286 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
74e1a04b 10287 printable_section_name (section), section->sh_info);
252b5132
RH		 10288
10289 printf (_(" Addr: 0x"));
10290 printf_vma (section->sh_addr);
72de5009 10291 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 10292 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 10293 printable_section_name_from_index (section->sh_link));
252b5132 10294
3f5e193b
NC		 10295 eneed = (Elf_External_Verneed *) get_data (NULL, file,
10296 section->sh_offset, 1,
10297 section->sh_size,
9cf03b7e 10298 _("Version Needs section"));
a6e9f9df
AM		 10299 if (!eneed)
10300 break;
59245841 10301 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 10302
10303 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10304 {
2cf0635d 10305 Elf_External_Verneed * entry;
b34976b6 10306 Elf_Internal_Verneed ent;
5235cd68 10307 unsigned int isum;
b34976b6 10308 int j;
2cf0635d 10309 char * vstart;
252b5132 10310
7e26601c 10311 if (idx > (size_t) (endbuf - (char *) eneed))
dd24e3da
NC		 10312 break;
10313
252b5132 10314 vstart = ((char *) eneed) + idx;
54806181
AM		 10315 if (vstart + sizeof (*entry) > endbuf)
10316 break;
252b5132
RH		 10317
10318 entry = (Elf_External_Verneed *) vstart;
10319
10320 ent.vn_version = BYTE_GET (entry->vn_version);
10321 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
10322 ent.vn_file = BYTE_GET (entry->vn_file);
10323 ent.vn_aux = BYTE_GET (entry->vn_aux);
10324 ent.vn_next = BYTE_GET (entry->vn_next);
10325
10326 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
10327
d79b3d50
NC		 10328 if (VALID_DYNAMIC_NAME (ent.vn_file))
10329 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 10330 else
10331 printf (_(" File: %lx"), ent.vn_file);
10332
10333 printf (_(" Cnt: %d\n"), ent.vn_cnt);
10334
dd24e3da 10335 /* Check for overflow. */
7e26601c 10336 if (ent.vn_aux > (size_t) (endbuf - vstart))
dd24e3da 10337 break;
252b5132
RH		 10338 vstart += ent.vn_aux;
10339
10340 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10341 {
2cf0635d 10342 Elf_External_Vernaux * eaux;
b34976b6 10343 Elf_Internal_Vernaux aux;
252b5132 10344
54806181
AM		 10345 if (vstart + sizeof (*eaux) > endbuf)
10346 break;
252b5132
RH		 10347 eaux = (Elf_External_Vernaux *) vstart;
10348
10349 aux.vna_hash = BYTE_GET (eaux->vna_hash);
10350 aux.vna_flags = BYTE_GET (eaux->vna_flags);
10351 aux.vna_other = BYTE_GET (eaux->vna_other);
10352 aux.vna_name = BYTE_GET (eaux->vna_name);
10353 aux.vna_next = BYTE_GET (eaux->vna_next);
10354
d79b3d50 10355 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 10356 printf (_(" %#06x: Name: %s"),
d79b3d50 10357 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 10358 else
ecc2063b 10359 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 10360 isum, aux.vna_name);
10361
10362 printf (_(" Flags: %s Version: %d\n"),
10363 get_ver_flags (aux.vna_flags), aux.vna_other);
10364
dd24e3da 10365 /* Check for overflow. */
53774b7e
NC		 10366 if (aux.vna_next > (size_t) (endbuf - vstart)
10367 || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
10368 {
10369 warn (_("Invalid vna_next field of %lx\n"),
10370 aux.vna_next);
10371 j = ent.vn_cnt;
10372 break;
10373 }
252b5132
RH		 10374 isum += aux.vna_next;
10375 vstart += aux.vna_next;
10376 }
9cf03b7e 10377
54806181 10378 if (j < ent.vn_cnt)
9cf03b7e 10379 warn (_("Missing Version Needs auxillary information\n"));
252b5132 10380
bcf83b2a 10381 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
c24cf8b6
NC		 10382 {
10383 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
10384 cnt = section->sh_info;
10385 break;
10386 }
252b5132
RH		 10387 idx += ent.vn_next;
10388 }
9cf03b7e 10389
54806181 10390 if (cnt < section->sh_info)
9cf03b7e 10391 warn (_("Missing Version Needs information\n"));
103f02d3 10392
252b5132
RH		 10393 free (eneed);
10394 }
10395 break;
10396
10397 case SHT_GNU_versym:
10398 {
2cf0635d 10399 Elf_Internal_Shdr * link_section;
8b73c356
NC		 10400 size_t total;
10401 unsigned int cnt;
2cf0635d
NC		 10402 unsigned char * edata;
10403 unsigned short * data;
10404 char * strtab;
10405 Elf_Internal_Sym * symbols;
10406 Elf_Internal_Shdr * string_sec;
ba5cdace 10407 unsigned long num_syms;
d3ba0551 10408 long off;
252b5132 10409
4fbb74a6 10410 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 10411 break;
10412
4fbb74a6 10413 link_section = section_headers + section->sh_link;
08d8fa11 10414 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 10415
4fbb74a6 10416 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 10417 break;
10418
32ec8896 10419 found = TRUE;
252b5132 10420
ba5cdace 10421 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 10422 if (symbols == NULL)
10423 break;
252b5132 10424
4fbb74a6 10425 string_sec = section_headers + link_section->sh_link;
252b5132 10426
3f5e193b
NC		 10427 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
10428 string_sec->sh_size,
10429 _("version string table"));
a6e9f9df 10430 if (!strtab)
0429c154
MS		 10431 {
10432 free (symbols);
10433 break;
10434 }
252b5132 10435
8b73c356
NC		 10436 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10437 printable_section_name (section), (unsigned long) total);
252b5132
RH		 10438
10439 printf (_(" Addr: "));
10440 printf_vma (section->sh_addr);
72de5009 10441 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 10442 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 10443 printable_section_name (link_section));
252b5132 10444
d3ba0551
AM		 10445 off = offset_from_vma (file,
10446 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10447 total * sizeof (short));
3f5e193b
NC		 10448 edata = (unsigned char *) get_data (NULL, file, off, total,
10449 sizeof (short),
10450 _("version symbol data"));
a6e9f9df
AM		 10451 if (!edata)
10452 {
10453 free (strtab);
0429c154 10454 free (symbols);
a6e9f9df
AM		 10455 break;
10456 }
252b5132 10457
3f5e193b 10458 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 10459
10460 for (cnt = total; cnt --;)
b34976b6
AM		 10461 data[cnt] = byte_get (edata + cnt * sizeof (short),
10462 sizeof (short));
252b5132
RH		 10463
10464 free (edata);
10465
10466 for (cnt = 0; cnt < total; cnt += 4)
10467 {
10468 int j, nn;
ab273396
AM		 10469 char *name;
10470 char *invalid = _("*invalid*");
252b5132
RH		 10471
10472 printf (" %03x:", cnt);
10473
10474 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 10475 switch (data[cnt + j])
252b5132
RH		 10476 {
10477 case 0:
10478 fputs (_(" 0 (*local*) "), stdout);
10479 break;
10480
10481 case 1:
10482 fputs (_(" 1 (*global*) "), stdout);
10483 break;
10484
10485 default:
c244d050
NC		 10486 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10487 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 10488
dd24e3da 10489 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 10490 array, break to avoid an out-of-bounds read. */
10491 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 10492 {
10493 warn (_("invalid index into symbol array\n"));
10494 break;
10495 }
10496
ab273396
AM		 10497 name = NULL;
10498 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 10499 {
b34976b6
AM		 10500 Elf_Internal_Verneed ivn;
10501 unsigned long offset;
252b5132 10502
d93f0186
NC		 10503 offset = offset_from_vma
10504 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10505 sizeof (Elf_External_Verneed));
252b5132 10506
b34976b6 10507 do
252b5132 10508 {
b34976b6
AM		 10509 Elf_Internal_Vernaux ivna;
10510 Elf_External_Verneed evn;
10511 Elf_External_Vernaux evna;
10512 unsigned long a_off;
252b5132 10513
59245841
NC		 10514 if (get_data (&evn, file, offset, sizeof (evn), 1,
10515 _("version need")) == NULL)
10516 break;
0b4362b0 10517
252b5132
RH		 10518 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10519 ivn.vn_next = BYTE_GET (evn.vn_next);
10520
10521 a_off = offset + ivn.vn_aux;
10522
10523 do
10524 {
59245841
NC		 10525 if (get_data (&evna, file, a_off, sizeof (evna),
10526 1, _("version need aux (2)")) == NULL)
10527 {
10528 ivna.vna_next = 0;
10529 ivna.vna_other = 0;
10530 }
10531 else
10532 {
10533 ivna.vna_next = BYTE_GET (evna.vna_next);
10534 ivna.vna_other = BYTE_GET (evna.vna_other);
10535 }
252b5132
RH		 10536
10537 a_off += ivna.vna_next;
10538 }
b34976b6 10539 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 10540 && ivna.vna_next != 0);
10541
b34976b6 10542 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 10543 {
10544 ivna.vna_name = BYTE_GET (evna.vna_name);
10545
54806181 10546 if (ivna.vna_name >= string_sec->sh_size)
ab273396 10547 name = invalid;
54806181
AM		 10548 else
10549 name = strtab + ivna.vna_name;
252b5132
RH		 10550 break;
10551 }
10552
10553 offset += ivn.vn_next;
10554 }
10555 while (ivn.vn_next);
10556 }
00d93f34 10557
ab273396 10558 if (data[cnt + j] != 0x8001
b34976b6 10559 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 10560 {
b34976b6
AM		 10561 Elf_Internal_Verdef ivd;
10562 Elf_External_Verdef evd;
10563 unsigned long offset;
252b5132 10564
d93f0186
NC		 10565 offset = offset_from_vma
10566 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10567 sizeof evd);
252b5132
RH		 10568
10569 do
10570 {
59245841
NC		 10571 if (get_data (&evd, file, offset, sizeof (evd), 1,
10572 _("version def")) == NULL)
10573 {
10574 ivd.vd_next = 0;
948f632f 10575 /* PR 17531: file: 046-1082287-0.004. */
3102e897
NC		 10576 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
10577 break;
59245841
NC		 10578 }
10579 else
10580 {
10581 ivd.vd_next = BYTE_GET (evd.vd_next);
10582 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10583 }
252b5132
RH		 10584
10585 offset += ivd.vd_next;
10586 }
c244d050 10587 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 10588 && ivd.vd_next != 0);
10589
c244d050 10590 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 10591 {
b34976b6
AM		 10592 Elf_External_Verdaux evda;
10593 Elf_Internal_Verdaux ivda;
252b5132
RH		 10594
10595 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10596
59245841
NC		 10597 if (get_data (&evda, file,
10598 offset - ivd.vd_next + ivd.vd_aux,
10599 sizeof (evda), 1,
10600 _("version def aux")) == NULL)
10601 break;
252b5132
RH		 10602
10603 ivda.vda_name = BYTE_GET (evda.vda_name);
10604
54806181 10605 if (ivda.vda_name >= string_sec->sh_size)
ab273396
AM		 10606 name = invalid;
10607 else if (name != NULL && name != invalid)
10608 name = _("*both*");
54806181
AM		 10609 else
10610 name = strtab + ivda.vda_name;
252b5132
RH		 10611 }
10612 }
ab273396
AM		 10613 if (name != NULL)
10614 nn += printf ("(%s%-*s",
10615 name,
10616 12 - (int) strlen (name),
10617 ")");
252b5132
RH		 10618
10619 if (nn < 18)
10620 printf ("%*c", 18 - nn, ' ');
10621 }
10622
10623 putchar ('\n');
10624 }
10625
10626 free (data);
10627 free (strtab);
10628 free (symbols);
10629 }
10630 break;
103f02d3 10631
252b5132
RH		 10632 default:
10633 break;
10634 }
10635 }
10636
10637 if (! found)
10638 printf (_("\nNo version information found in this file.\n"));
10639
32ec8896 10640 return TRUE;
252b5132
RH		 10641}
10642
d1133906 10643static const char *
d3ba0551 10644get_symbol_binding (unsigned int binding)
252b5132 10645{
b34976b6 10646 static char buff[32];
252b5132
RH		 10647
10648 switch (binding)
10649 {
b34976b6
AM		 10650 case STB_LOCAL: return "LOCAL";
10651 case STB_GLOBAL: return "GLOBAL";
10652 case STB_WEAK: return "WEAK";
252b5132
RH		 10653 default:
10654 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 10655 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10656 binding);
252b5132 10657 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 10658 {
10659 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 10660 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10661 /* GNU is still using the default value 0. */
3e7a7d11
NC		 10662 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10663 return "UNIQUE";
10664 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10665 }
252b5132 10666 else
e9e44622 10667 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 10668 return buff;
10669 }
10670}
10671
d1133906 10672static const char *
d3ba0551 10673get_symbol_type (unsigned int type)
252b5132 10674{
b34976b6 10675 static char buff[32];
252b5132
RH		 10676
10677 switch (type)
10678 {
b34976b6
AM		 10679 case STT_NOTYPE: return "NOTYPE";
10680 case STT_OBJECT: return "OBJECT";
10681 case STT_FUNC: return "FUNC";
10682 case STT_SECTION: return "SECTION";
10683 case STT_FILE: return "FILE";
10684 case STT_COMMON: return "COMMON";
10685 case STT_TLS: return "TLS";
15ab5209
DB		 10686 case STT_RELC: return "RELC";
10687 case STT_SRELC: return "SRELC";
252b5132
RH		 10688 default:
10689 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af 10690 {
3510a7b8
NC		 10691 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10692 return "THUMB_FUNC";
103f02d3 10693
351b4b40 10694 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 10695 return "REGISTER";
10696
10697 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10698 return "PARISC_MILLI";
10699
e9e44622 10700 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 10701 }
252b5132 10702 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 10703 {
10704 if (elf_header.e_machine == EM_PARISC)
10705 {
10706 if (type == STT_HP_OPAQUE)
10707 return "HP_OPAQUE";
10708 if (type == STT_HP_STUB)
10709 return "HP_STUB";
10710 }
10711
d8045f23 10712 if (type == STT_GNU_IFUNC
9c55345c 10713 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 10714 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 10715 /* GNU is still using the default value 0. */
d8045f23
NC		 10716 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10717 return "IFUNC";
10718
e9e44622 10719 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 10720 }
252b5132 10721 else
e9e44622 10722 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 10723 return buff;
10724 }
10725}
10726
d1133906 10727static const char *
d3ba0551 10728get_symbol_visibility (unsigned int visibility)
d1133906
NC		 10729{
10730 switch (visibility)
10731 {
b34976b6
AM		 10732 case STV_DEFAULT: return "DEFAULT";
10733 case STV_INTERNAL: return "INTERNAL";
10734 case STV_HIDDEN: return "HIDDEN";
d1133906 10735 case STV_PROTECTED: return "PROTECTED";
bee0ee85
NC		 10736 default:
10737 error (_("Unrecognized visibility value: %u"), visibility);
10738 return _("<unknown>");
d1133906
NC		 10739 }
10740}
10741
fd85a6a1
NC		 10742static const char *
10743get_solaris_symbol_visibility (unsigned int visibility)
10744{
10745 switch (visibility)
10746 {
10747 case 4: return "EXPORTED";
10748 case 5: return "SINGLETON";
10749 case 6: return "ELIMINATE";
10750 default: return get_symbol_visibility (visibility);
10751 }
10752}
10753
5e2b0d47
NC		 10754static const char *
10755get_mips_symbol_other (unsigned int other)
10756{
10757 switch (other)
10758 {
32ec8896
NC		 10759 case STO_OPTIONAL: return "OPTIONAL";
10760 case STO_MIPS_PLT: return "MIPS PLT";
10761 case STO_MIPS_PIC: return "MIPS PIC";
10762 case STO_MICROMIPS: return "MICROMIPS";
10763 case STO_MICROMIPS | STO_MIPS_PIC: return "MICROMIPS, MIPS PIC";
10764 case STO_MIPS16: return "MIPS16";
10765 default: return NULL;
5e2b0d47
NC		 10766 }
10767}
10768
28f997cf
TG		 10769static const char *
10770get_ia64_symbol_other (unsigned int other)
10771{
10772 if (is_ia64_vms ())
10773 {
10774 static char res[32];
10775
10776 res[0] = 0;
10777
10778 /* Function types is for images and .STB files only. */
10779 switch (elf_header.e_type)
10780 {
10781 case ET_DYN:
10782 case ET_EXEC:
10783 switch (VMS_ST_FUNC_TYPE (other))
10784 {
10785 case VMS_SFT_CODE_ADDR:
10786 strcat (res, " CA");
10787 break;
10788 case VMS_SFT_SYMV_IDX:
10789 strcat (res, " VEC");
10790 break;
10791 case VMS_SFT_FD:
10792 strcat (res, " FD");
10793 break;
10794 case VMS_SFT_RESERVE:
10795 strcat (res, " RSV");
10796 break;
10797 default:
bee0ee85
NC		 10798 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10799 VMS_ST_FUNC_TYPE (other));
10800 strcat (res, " <unknown>");
10801 break;
28f997cf
TG		 10802 }
10803 break;
10804 default:
10805 break;
10806 }
10807 switch (VMS_ST_LINKAGE (other))
10808 {
10809 case VMS_STL_IGNORE:
10810 strcat (res, " IGN");
10811 break;
10812 case VMS_STL_RESERVE:
10813 strcat (res, " RSV");
10814 break;
10815 case VMS_STL_STD:
10816 strcat (res, " STD");
10817 break;
10818 case VMS_STL_LNK:
10819 strcat (res, " LNK");
10820 break;
10821 default:
bee0ee85
NC		 10822 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10823 VMS_ST_LINKAGE (other));
10824 strcat (res, " <unknown>");
10825 break;
28f997cf
TG		 10826 }
10827
10828 if (res[0] != 0)
10829 return res + 1;
10830 else
10831 return res;
10832 }
10833 return NULL;
10834}
10835
6911b7dc
AM		 10836static const char *
10837get_ppc64_symbol_other (unsigned int other)
10838{
10839 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10840 {
10841 static char buf[32];
10842 snprintf (buf, sizeof buf, _("<localentry>: %d"),
10843 PPC64_LOCAL_ENTRY_OFFSET (other));
10844 return buf;
10845 }
10846 return NULL;
10847}
10848
5e2b0d47
NC		 10849static const char *
10850get_symbol_other (unsigned int other)
10851{
10852 const char * result = NULL;
10853 static char buff [32];
10854
10855 if (other == 0)
10856 return "";
10857
10858 switch (elf_header.e_machine)
10859 {
10860 case EM_MIPS:
10861 result = get_mips_symbol_other (other);
28f997cf
TG		 10862 break;
10863 case EM_IA_64:
10864 result = get_ia64_symbol_other (other);
10865 break;
6911b7dc
AM		 10866 case EM_PPC64:
10867 result = get_ppc64_symbol_other (other);
10868 break;
5e2b0d47 10869 default:
fd85a6a1 10870 result = NULL;
5e2b0d47
NC		 10871 break;
10872 }
10873
10874 if (result)
10875 return result;
10876
10877 snprintf (buff, sizeof buff, _("<other>: %x"), other);
10878 return buff;
10879}
10880
d1133906 10881static const char *
d3ba0551 10882get_symbol_index_type (unsigned int type)
252b5132 10883{
b34976b6 10884 static char buff[32];
5cf1065c 10885
252b5132
RH		 10886 switch (type)
10887 {
b34976b6
AM		 10888 case SHN_UNDEF: return "UND";
10889 case SHN_ABS: return "ABS";
10890 case SHN_COMMON: return "COM";
252b5132 10891 default:
9ce701e2
L		 10892 if (type == SHN_IA_64_ANSI_COMMON
10893 && elf_header.e_machine == EM_IA_64
10894 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10895 return "ANSI_COM";
8a9036a4 10896 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 10897 || elf_header.e_machine == EM_L1OM
10898 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 10899 && type == SHN_X86_64_LCOMMON)
10900 return "LARGE_COM";
ac145307
BS		 10901 else if ((type == SHN_MIPS_SCOMMON
10902 && elf_header.e_machine == EM_MIPS)
10903 || (type == SHN_TIC6X_SCOMMON
10904 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 10905 return "SCOM";
10906 else if (type == SHN_MIPS_SUNDEFINED
10907 && elf_header.e_machine == EM_MIPS)
10908 return "SUND";
9ce701e2 10909 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 10910 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 10911 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 10912 sprintf (buff, "OS [0x%04x]", type & 0xffff);
10913 else if (type >= SHN_LORESERVE)
10914 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4 10915 else if (type >= elf_header.e_shnum)
e0a31db1 10916 sprintf (buff, _("bad section index[%3d]"), type);
252b5132 10917 else
232e7cb8 10918 sprintf (buff, "%3d", type);
5cf1065c 10919 break;
252b5132 10920 }
5cf1065c
NC		 10921
10922 return buff;
252b5132
RH		 10923}
10924
66543521 10925static bfd_vma *
57028622 10926get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
252b5132 10927{
2cf0635d
NC		 10928 unsigned char * e_data;
10929 bfd_vma * i_data;
252b5132 10930
57028622
NC		 10931 /* If the size_t type is smaller than the bfd_size_type, eg because
10932 you are building a 32-bit tool on a 64-bit host, then make sure
10933 that when (number) is cast to (size_t) no information is lost. */
10934 if (sizeof (size_t) < sizeof (bfd_size_type)
10935 && (bfd_size_type) ((size_t) number) != number)
10936 {
ed754a13
AM		 10937 error (_("Size truncation prevents reading %" BFD_VMA_FMT "u"
10938 " elements of size %u\n"),
10939 number, ent_size);
57028622
NC		 10940 return NULL;
10941 }
948f632f 10942
3102e897
NC		 10943 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10944 attempting to allocate memory when the read is bound to fail. */
10945 if (ent_size * number > current_file_size)
10946 {
ed754a13
AM		 10947 error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT "u\n"),
10948 number);
3102e897
NC		 10949 return NULL;
10950 }
10951
57028622 10952 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
252b5132
RH		 10953 if (e_data == NULL)
10954 {
ed754a13
AM		 10955 error (_("Out of memory reading %" BFD_VMA_FMT "u dynamic entries\n"),
10956 number);
252b5132
RH		 10957 return NULL;
10958 }
10959
57028622 10960 if (fread (e_data, ent_size, (size_t) number, file) != number)
252b5132 10961 {
ed754a13
AM		 10962 error (_("Unable to read in %" BFD_VMA_FMT "u bytes of dynamic data\n"),
10963 number * ent_size);
3102e897 10964 free (e_data);
252b5132
RH		 10965 return NULL;
10966 }
10967
57028622 10968 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
252b5132
RH		 10969 if (i_data == NULL)
10970 {
ed754a13
AM		 10971 error (_("Out of memory allocating space for %" BFD_VMA_FMT "u"
10972 " dynamic entries\n"),
10973 number);
252b5132
RH		 10974 free (e_data);
10975 return NULL;
10976 }
10977
10978 while (number--)
66543521 10979 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 10980
10981 free (e_data);
10982
10983 return i_data;
10984}
10985
6bd1a22c
L		 10986static void
10987print_dynamic_symbol (bfd_vma si, unsigned long hn)
10988{
2cf0635d 10989 Elf_Internal_Sym * psym;
6bd1a22c
L		 10990 int n;
10991
6bd1a22c
L		 10992 n = print_vma (si, DEC_5);
10993 if (n < 5)
0b4362b0 10994 fputs (&" "[n], stdout);
6bd1a22c 10995 printf (" %3lu: ", hn);
e0a31db1
NC		 10996
10997 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10998 {
3102e897
NC		 10999 printf (_("<No info available for dynamic symbol number %lu>\n"),
11000 (unsigned long) si);
e0a31db1
NC		 11001 return;
11002 }
11003
11004 psym = dynamic_symbols + si;
6bd1a22c
L		 11005 print_vma (psym->st_value, LONG_HEX);
11006 putchar (' ');
11007 print_vma (psym->st_size, DEC_5);
11008
f4be36b3
AM		 11009 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
11010 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
fd85a6a1
NC		 11011
11012 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11013 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
11014 else
11015 {
11016 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11017
11018 printf (" %-7s", get_symbol_visibility (vis));
11019 /* Check to see if any other bits in the st_other field are set.
11020 Note - displaying this information disrupts the layout of the
11021 table being generated, but for the moment this case is very
11022 rare. */
11023 if (psym->st_other ^ vis)
11024 printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
11025 }
11026
6bd1a22c
L		 11027 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
11028 if (VALID_DYNAMIC_NAME (psym->st_name))
11029 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11030 else
2b692964 11031 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 11032 putchar ('\n');
11033}
11034
bb4d2ac2 11035static const char *
1449284b
NC		 11036get_symbol_version_string (FILE * file,
11037 bfd_boolean is_dynsym,
11038 const char * strtab,
11039 unsigned long int strtab_size,
11040 unsigned int si,
11041 Elf_Internal_Sym * psym,
11042 enum versioned_symbol_info * sym_info,
11043 unsigned short * vna_other)
bb4d2ac2 11044{
ab273396
AM		 11045 unsigned char data[2];
11046 unsigned short vers_data;
11047 unsigned long offset;
bb4d2ac2 11048
ab273396
AM		 11049 if (!is_dynsym
11050 || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11051 return NULL;
bb4d2ac2 11052
ab273396
AM		 11053 offset = offset_from_vma (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11054 sizeof data + si * sizeof (vers_data));
bb4d2ac2 11055
ab273396
AM		 11056 if (get_data (&data, file, offset + si * sizeof (vers_data),
11057 sizeof (data), 1, _("version data")) == NULL)
11058 return NULL;
11059
11060 vers_data = byte_get (data, 2);
bb4d2ac2 11061
ab273396
AM		 11062 if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
11063 return NULL;
bb4d2ac2 11064
ab273396
AM		 11065 /* Usually we'd only see verdef for defined symbols, and verneed for
11066 undefined symbols. However, symbols defined by the linker in
11067 .dynbss for variables copied from a shared library in order to
11068 avoid text relocations are defined yet have verneed. We could
11069 use a heuristic to detect the special case, for example, check
11070 for verneed first on symbols defined in SHT_NOBITS sections, but
11071 it is simpler and more reliable to just look for both verdef and
11072 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
bb4d2ac2 11073
ab273396
AM		 11074 if (psym->st_shndx != SHN_UNDEF
11075 && vers_data != 0x8001
11076 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11077 {
11078 Elf_Internal_Verdef ivd;
11079 Elf_Internal_Verdaux ivda;
11080 Elf_External_Verdaux evda;
11081 unsigned long off;
bb4d2ac2 11082
ab273396
AM		 11083 off = offset_from_vma (file,
11084 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11085 sizeof (Elf_External_Verdef));
11086
11087 do
bb4d2ac2 11088 {
ab273396
AM		 11089 Elf_External_Verdef evd;
11090
11091 if (get_data (&evd, file, off, sizeof (evd), 1,
11092 _("version def")) == NULL)
11093 {
11094 ivd.vd_ndx = 0;
11095 ivd.vd_aux = 0;
11096 ivd.vd_next = 0;
11097 }
11098 else
bb4d2ac2 11099 {
ab273396
AM		 11100 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11101 ivd.vd_aux = BYTE_GET (evd.vd_aux);
11102 ivd.vd_next = BYTE_GET (evd.vd_next);
11103 }
bb4d2ac2 11104
ab273396
AM		 11105 off += ivd.vd_next;
11106 }
11107 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
bb4d2ac2 11108
ab273396
AM		 11109 if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11110 {
11111 off -= ivd.vd_next;
11112 off += ivd.vd_aux;
bb4d2ac2 11113
ab273396
AM		 11114 if (get_data (&evda, file, off, sizeof (evda), 1,
11115 _("version def aux")) != NULL)
11116 {
11117 ivda.vda_name = BYTE_GET (evda.vda_name);
bb4d2ac2 11118
ab273396
AM		 11119 if (psym->st_name != ivda.vda_name)
11120 {
11121 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11122 ? symbol_hidden : symbol_public);
11123 return (ivda.vda_name < strtab_size
11124 ? strtab + ivda.vda_name : _("<corrupt>"));
11125 }
11126 }
11127 }
11128 }
bb4d2ac2 11129
ab273396
AM		 11130 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11131 {
11132 Elf_External_Verneed evn;
11133 Elf_Internal_Verneed ivn;
11134 Elf_Internal_Vernaux ivna;
bb4d2ac2 11135
ab273396
AM		 11136 offset = offset_from_vma (file,
11137 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11138 sizeof evn);
11139 do
11140 {
11141 unsigned long vna_off;
bb4d2ac2 11142
ab273396
AM		 11143 if (get_data (&evn, file, offset, sizeof (evn), 1,
11144 _("version need")) == NULL)
11145 {
11146 ivna.vna_next = 0;
11147 ivna.vna_other = 0;
11148 ivna.vna_name = 0;
11149 break;
11150 }
bb4d2ac2 11151
ab273396
AM		 11152 ivn.vn_aux = BYTE_GET (evn.vn_aux);
11153 ivn.vn_next = BYTE_GET (evn.vn_next);
bb4d2ac2 11154
ab273396 11155 vna_off = offset + ivn.vn_aux;
bb4d2ac2 11156
ab273396
AM		 11157 do
11158 {
11159 Elf_External_Vernaux evna;
bb4d2ac2 11160
ab273396
AM		 11161 if (get_data (&evna, file, vna_off, sizeof (evna), 1,
11162 _("version need aux (3)")) == NULL)
bb4d2ac2 11163 {
ab273396
AM		 11164 ivna.vna_next = 0;
11165 ivna.vna_other = 0;
11166 ivna.vna_name = 0;
bb4d2ac2 11167 }
bb4d2ac2 11168 else
bb4d2ac2 11169 {
ab273396
AM		 11170 ivna.vna_other = BYTE_GET (evna.vna_other);
11171 ivna.vna_next = BYTE_GET (evna.vna_next);
11172 ivna.vna_name = BYTE_GET (evna.vna_name);
11173 }
bb4d2ac2 11174
ab273396
AM		 11175 vna_off += ivna.vna_next;
11176 }
11177 while (ivna.vna_other != vers_data && ivna.vna_next != 0);
bb4d2ac2 11178
ab273396
AM		 11179 if (ivna.vna_other == vers_data)
11180 break;
bb4d2ac2 11181
ab273396
AM		 11182 offset += ivn.vn_next;
11183 }
11184 while (ivn.vn_next != 0);
bb4d2ac2 11185
ab273396
AM		 11186 if (ivna.vna_other == vers_data)
11187 {
11188 *sym_info = symbol_undefined;
11189 *vna_other = ivna.vna_other;
11190 return (ivna.vna_name < strtab_size
11191 ? strtab + ivna.vna_name : _("<corrupt>"));
bb4d2ac2
L		 11192 }
11193 }
ab273396 11194 return NULL;
bb4d2ac2
L		 11195}
11196
e3c8793a 11197/* Dump the symbol table. */
32ec8896 11198static bfd_boolean
2cf0635d 11199process_symbol_table (FILE * file)
252b5132 11200{
2cf0635d 11201 Elf_Internal_Shdr * section;
8b73c356
NC		 11202 bfd_size_type nbuckets = 0;
11203 bfd_size_type nchains = 0;
2cf0635d
NC		 11204 bfd_vma * buckets = NULL;
11205 bfd_vma * chains = NULL;
fdc90cb4 11206 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 11207 bfd_vma * gnubuckets = NULL;
11208 bfd_vma * gnuchains = NULL;
6bd1a22c 11209 bfd_vma gnusymidx = 0;
071436c6 11210 bfd_size_type ngnuchains = 0;
252b5132 11211
2c610e4b 11212 if (!do_syms && !do_dyn_syms && !do_histogram)
32ec8896 11213 return TRUE;
252b5132 11214
6bd1a22c
L		 11215 if (dynamic_info[DT_HASH]
11216 && (do_histogram
2c610e4b
L		 11217 || (do_using_dynamic
11218 && !do_dyn_syms
11219 && dynamic_strings != NULL)))
252b5132 11220 {
66543521
AM		 11221 unsigned char nb[8];
11222 unsigned char nc[8];
8b73c356 11223 unsigned int hash_ent_size = 4;
66543521
AM		 11224
11225 if ((elf_header.e_machine == EM_ALPHA
11226 || elf_header.e_machine == EM_S390
11227 || elf_header.e_machine == EM_S390_OLD)
11228 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
11229 hash_ent_size = 8;
11230
fb52b2f4
NC		 11231 if (fseek (file,
11232 (archive_file_offset
11233 + offset_from_vma (file, dynamic_info[DT_HASH],
11234 sizeof nb + sizeof nc)),
d93f0186 11235 SEEK_SET))
252b5132 11236 {
591a748a 11237 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 11238 goto no_hash;
252b5132
RH		 11239 }
11240
66543521 11241 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 11242 {
11243 error (_("Failed to read in number of buckets\n"));
d3a44ec6 11244 goto no_hash;
252b5132
RH		 11245 }
11246
66543521 11247 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 11248 {
11249 error (_("Failed to read in number of chains\n"));
d3a44ec6 11250 goto no_hash;
252b5132
RH		 11251 }
11252
66543521
AM		 11253 nbuckets = byte_get (nb, hash_ent_size);
11254 nchains = byte_get (nc, hash_ent_size);
252b5132 11255
66543521
AM		 11256 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
11257 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 11258
d3a44ec6 11259 no_hash:
252b5132 11260 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 11261 {
11262 if (do_using_dynamic)
32ec8896 11263 return FALSE;
d3a44ec6
JJ		 11264 free (buckets);
11265 free (chains);
11266 buckets = NULL;
11267 chains = NULL;
11268 nbuckets = 0;
11269 nchains = 0;
11270 }
252b5132
RH		 11271 }
11272
6bd1a22c
L		 11273 if (dynamic_info_DT_GNU_HASH
11274 && (do_histogram
2c610e4b
L		 11275 || (do_using_dynamic
11276 && !do_dyn_syms
11277 && dynamic_strings != NULL)))
252b5132 11278 {
6bd1a22c
L		 11279 unsigned char nb[16];
11280 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11281 bfd_vma buckets_vma;
11282
11283 if (fseek (file,
11284 (archive_file_offset
11285 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
11286 sizeof nb)),
11287 SEEK_SET))
11288 {
11289 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 11290 goto no_gnu_hash;
6bd1a22c 11291 }
252b5132 11292
6bd1a22c
L		 11293 if (fread (nb, 16, 1, file) != 1)
11294 {
11295 error (_("Failed to read in number of buckets\n"));
d3a44ec6 11296 goto no_gnu_hash;
6bd1a22c
L		 11297 }
11298
11299 ngnubuckets = byte_get (nb, 4);
11300 gnusymidx = byte_get (nb + 4, 4);
11301 bitmaskwords = byte_get (nb + 8, 4);
11302 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 11303 if (is_32bit_elf)
6bd1a22c 11304 buckets_vma += bitmaskwords * 4;
f7a99963 11305 else
6bd1a22c 11306 buckets_vma += bitmaskwords * 8;
252b5132 11307
6bd1a22c
L		 11308 if (fseek (file,
11309 (archive_file_offset
11310 + offset_from_vma (file, buckets_vma, 4)),
11311 SEEK_SET))
252b5132 11312 {
6bd1a22c 11313 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 11314 goto no_gnu_hash;
6bd1a22c
L		 11315 }
11316
11317 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 11318
6bd1a22c 11319 if (gnubuckets == NULL)
d3a44ec6 11320 goto no_gnu_hash;
6bd1a22c
L		 11321
11322 for (i = 0; i < ngnubuckets; i++)
11323 if (gnubuckets[i] != 0)
11324 {
11325 if (gnubuckets[i] < gnusymidx)
32ec8896 11326 return FALSE;
6bd1a22c
L		 11327
11328 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11329 maxchain = gnubuckets[i];
11330 }
11331
11332 if (maxchain == 0xffffffff)
d3a44ec6 11333 goto no_gnu_hash;
6bd1a22c
L		 11334
11335 maxchain -= gnusymidx;
11336
11337 if (fseek (file,
11338 (archive_file_offset
11339 + offset_from_vma (file, buckets_vma
11340 + 4 * (ngnubuckets + maxchain), 4)),
11341 SEEK_SET))
11342 {
11343 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 11344 goto no_gnu_hash;
6bd1a22c
L		 11345 }
11346
11347 do
11348 {
11349 if (fread (nb, 4, 1, file) != 1)
252b5132 11350 {
6bd1a22c 11351 error (_("Failed to determine last chain length\n"));
d3a44ec6 11352 goto no_gnu_hash;
6bd1a22c 11353 }
252b5132 11354
6bd1a22c 11355 if (maxchain + 1 == 0)
d3a44ec6 11356 goto no_gnu_hash;
252b5132 11357
6bd1a22c
L		 11358 ++maxchain;
11359 }
11360 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 11361
6bd1a22c
L		 11362 if (fseek (file,
11363 (archive_file_offset
11364 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
11365 SEEK_SET))
11366 {
11367 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 11368 goto no_gnu_hash;
6bd1a22c
L		 11369 }
11370
11371 gnuchains = get_dynamic_data (file, maxchain, 4);
071436c6 11372 ngnuchains = maxchain;
6bd1a22c 11373
d3a44ec6 11374 no_gnu_hash:
6bd1a22c 11375 if (gnuchains == NULL)
d3a44ec6
JJ		 11376 {
11377 free (gnubuckets);
d3a44ec6
JJ		 11378 gnubuckets = NULL;
11379 ngnubuckets = 0;
f64fddf1 11380 if (do_using_dynamic)
32ec8896 11381 return FALSE;
d3a44ec6 11382 }
6bd1a22c
L		 11383 }
11384
11385 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11386 && do_syms
11387 && do_using_dynamic
3102e897
NC		 11388 && dynamic_strings != NULL
11389 && dynamic_symbols != NULL)
6bd1a22c
L		 11390 {
11391 unsigned long hn;
11392
11393 if (dynamic_info[DT_HASH])
11394 {
11395 bfd_vma si;
11396
11397 printf (_("\nSymbol table for image:\n"));
11398 if (is_32bit_elf)
11399 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11400 else
11401 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11402
11403 for (hn = 0; hn < nbuckets; hn++)
11404 {
11405 if (! buckets[hn])
11406 continue;
11407
11408 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
11409 print_dynamic_symbol (si, hn);
252b5132
RH		 11410 }
11411 }
6bd1a22c
L		 11412
11413 if (dynamic_info_DT_GNU_HASH)
11414 {
11415 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11416 if (is_32bit_elf)
11417 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11418 else
11419 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11420
11421 for (hn = 0; hn < ngnubuckets; ++hn)
11422 if (gnubuckets[hn] != 0)
11423 {
11424 bfd_vma si = gnubuckets[hn];
11425 bfd_vma off = si - gnusymidx;
11426
11427 do
11428 {
11429 print_dynamic_symbol (si, hn);
11430 si++;
11431 }
071436c6 11432 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
6bd1a22c
L		 11433 }
11434 }
252b5132 11435 }
8b73c356
NC		 11436 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11437 && section_headers != NULL)
252b5132 11438 {
b34976b6 11439 unsigned int i;
252b5132
RH		 11440
11441 for (i = 0, section = section_headers;
11442 i < elf_header.e_shnum;
11443 i++, section++)
11444 {
b34976b6 11445 unsigned int si;
2cf0635d 11446 char * strtab = NULL;
c256ffe7 11447 unsigned long int strtab_size = 0;
2cf0635d
NC		 11448 Elf_Internal_Sym * symtab;
11449 Elf_Internal_Sym * psym;
ba5cdace 11450 unsigned long num_syms;
252b5132 11451
2c610e4b
L		 11452 if ((section->sh_type != SHT_SYMTAB
11453 && section->sh_type != SHT_DYNSYM)
11454 || (!do_syms
11455 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 11456 continue;
11457
dd24e3da
NC		 11458 if (section->sh_entsize == 0)
11459 {
11460 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
74e1a04b 11461 printable_section_name (section));
dd24e3da
NC		 11462 continue;
11463 }
11464
252b5132 11465 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
74e1a04b 11466 printable_section_name (section),
252b5132 11467 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 11468
f7a99963 11469 if (is_32bit_elf)
ca47b30c 11470 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 11471 else
ca47b30c 11472 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 11473
ba5cdace 11474 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 11475 if (symtab == NULL)
11476 continue;
11477
11478 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 11479 {
11480 strtab = string_table;
11481 strtab_size = string_table_length;
11482 }
4fbb74a6 11483 else if (section->sh_link < elf_header.e_shnum)
252b5132 11484 {
2cf0635d 11485 Elf_Internal_Shdr * string_sec;
252b5132 11486
4fbb74a6 11487 string_sec = section_headers + section->sh_link;
252b5132 11488
3f5e193b
NC		 11489 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
11490 1, string_sec->sh_size,
11491 _("string table"));
c256ffe7 11492 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 11493 }
11494
ba5cdace 11495 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 11496 {
bb4d2ac2
L		 11497 const char *version_string;
11498 enum versioned_symbol_info sym_info;
11499 unsigned short vna_other;
11500
5e220199 11501 printf ("%6d: ", si);
f7a99963
NC		 11502 print_vma (psym->st_value, LONG_HEX);
11503 putchar (' ');
11504 print_vma (psym->st_size, DEC_5);
d1133906
NC		 11505 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
11506 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
fd85a6a1
NC		 11507 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11508 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
11509 else
11510 {
11511 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11512
11513 printf (" %-7s", get_symbol_visibility (vis));
11514 /* Check to see if any other bits in the st_other field are set.
11515 Note - displaying this information disrupts the layout of the
11516 table being generated, but for the moment this case is very rare. */
11517 if (psym->st_other ^ vis)
11518 printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
11519 }
31104126 11520 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 11521 print_symbol (25, psym->st_name < strtab_size
2b692964 11522 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 11523
bb4d2ac2
L		 11524 version_string
11525 = get_symbol_version_string (file,
11526 section->sh_type == SHT_DYNSYM,
11527 strtab, strtab_size, si,
11528 psym, &sym_info, &vna_other);
11529 if (version_string)
252b5132 11530 {
bb4d2ac2
L		 11531 if (sym_info == symbol_undefined)
11532 printf ("@%s (%d)", version_string, vna_other);
11533 else
11534 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11535 version_string);
252b5132
RH		 11536 }
11537
11538 putchar ('\n');
52c3c391
NC		 11539
11540 if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
dd905818
NC		 11541 && si >= section->sh_info
11542 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11543 && elf_header.e_machine != EM_MIPS
11544 /* Solaris binaries have been found to violate this requirement as
11545 well. Not sure if this is a bug or an ABI requirement. */
11546 && elf_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
52c3c391
NC		 11547 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11548 si, printable_section_name (section), section->sh_info);
252b5132
RH		 11549 }
11550
11551 free (symtab);
11552 if (strtab != string_table)
11553 free (strtab);
11554 }
11555 }
11556 else if (do_syms)
11557 printf
11558 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11559
11560 if (do_histogram && buckets != NULL)
11561 {
2cf0635d
NC		 11562 unsigned long * lengths;
11563 unsigned long * counts;
66543521
AM		 11564 unsigned long hn;
11565 bfd_vma si;
11566 unsigned long maxlength = 0;
11567 unsigned long nzero_counts = 0;
11568 unsigned long nsyms = 0;
94d15024 11569 unsigned long chained;
252b5132 11570
66543521
AM		 11571 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11572 (unsigned long) nbuckets);
252b5132 11573
3f5e193b 11574 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 11575 if (lengths == NULL)
11576 {
8b73c356 11577 error (_("Out of memory allocating space for histogram buckets\n"));
32ec8896 11578 return FALSE;
252b5132 11579 }
8b73c356
NC		 11580
11581 printf (_(" Length Number %% of total Coverage\n"));
252b5132
RH		 11582 for (hn = 0; hn < nbuckets; ++hn)
11583 {
94d15024
MF		 11584 for (si = buckets[hn], chained = 0;
11585 si > 0 && si < nchains && si < nbuckets && chained <= nchains;
11586 si = chains[si], ++chained)
252b5132 11587 {
b34976b6 11588 ++nsyms;
252b5132 11589 if (maxlength < ++lengths[hn])
b34976b6 11590 ++maxlength;
252b5132 11591 }
94d15024
MF		 11592
11593 /* PR binutils/17531: A corrupt binary could contain broken
11594 histogram data. Do not go into an infinite loop trying
11595 to process it. */
11596 if (chained > nchains)
11597 {
11598 error (_("histogram chain is corrupt\n"));
11599 break;
11600 }
252b5132
RH		 11601 }
11602
3f5e193b 11603 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 11604 if (counts == NULL)
11605 {
b2e951ec 11606 free (lengths);
8b73c356 11607 error (_("Out of memory allocating space for histogram counts\n"));
32ec8896 11608 return FALSE;
252b5132
RH		 11609 }
11610
11611 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 11612 ++counts[lengths[hn]];
252b5132 11613
103f02d3 11614 if (nbuckets > 0)
252b5132 11615 {
66543521
AM		 11616 unsigned long i;
11617 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 11618 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 11619 for (i = 1; i <= maxlength; ++i)
103f02d3 11620 {
66543521
AM		 11621 nzero_counts += counts[i] * i;
11622 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11623 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 11624 (nzero_counts * 100.0) / nsyms);
11625 }
252b5132
RH		 11626 }
11627
11628 free (counts);
11629 free (lengths);
11630 }
11631
11632 if (buckets != NULL)
11633 {
11634 free (buckets);
11635 free (chains);
11636 }
11637
d3a44ec6 11638 if (do_histogram && gnubuckets != NULL)
fdc90cb4 11639 {
2cf0635d
NC		 11640 unsigned long * lengths;
11641 unsigned long * counts;
fdc90cb4
JJ		 11642 unsigned long hn;
11643 unsigned long maxlength = 0;
11644 unsigned long nzero_counts = 0;
11645 unsigned long nsyms = 0;
fdc90cb4 11646
8b73c356
NC		 11647 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11648 (unsigned long) ngnubuckets);
11649
3f5e193b 11650 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 11651 if (lengths == NULL)
11652 {
8b73c356 11653 error (_("Out of memory allocating space for gnu histogram buckets\n"));
32ec8896 11654 return FALSE;
fdc90cb4
JJ		 11655 }
11656
fdc90cb4
JJ		 11657 printf (_(" Length Number %% of total Coverage\n"));
11658
11659 for (hn = 0; hn < ngnubuckets; ++hn)
11660 if (gnubuckets[hn] != 0)
11661 {
11662 bfd_vma off, length = 1;
11663
6bd1a22c 11664 for (off = gnubuckets[hn] - gnusymidx;
071436c6
NC		 11665 /* PR 17531 file: 010-77222-0.004. */
11666 off < ngnuchains && (gnuchains[off] & 1) == 0;
11667 ++off)
fdc90cb4
JJ		 11668 ++length;
11669 lengths[hn] = length;
11670 if (length > maxlength)
11671 maxlength = length;
11672 nsyms += length;
11673 }
11674
3f5e193b 11675 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 11676 if (counts == NULL)
11677 {
b2e951ec 11678 free (lengths);
8b73c356 11679 error (_("Out of memory allocating space for gnu histogram counts\n"));
32ec8896 11680 return FALSE;
fdc90cb4
JJ		 11681 }
11682
11683 for (hn = 0; hn < ngnubuckets; ++hn)
11684 ++counts[lengths[hn]];
11685
11686 if (ngnubuckets > 0)
11687 {
11688 unsigned long j;
11689 printf (" 0 %-10lu (%5.1f%%)\n",
11690 counts[0], (counts[0] * 100.0) / ngnubuckets);
11691 for (j = 1; j <= maxlength; ++j)
11692 {
11693 nzero_counts += counts[j] * j;
11694 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11695 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11696 (nzero_counts * 100.0) / nsyms);
11697 }
11698 }
11699
11700 free (counts);
11701 free (lengths);
11702 free (gnubuckets);
11703 free (gnuchains);
11704 }
11705
32ec8896 11706 return TRUE;
252b5132
RH		 11707}
11708
32ec8896 11709static bfd_boolean
2cf0635d 11710process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 11711{
b4c96d0d 11712 unsigned int i;
252b5132
RH		 11713
11714 if (dynamic_syminfo == NULL
11715 || !do_dynamic)
11716 /* No syminfo, this is ok. */
32ec8896 11717 return TRUE;
252b5132
RH		 11718
11719 /* There better should be a dynamic symbol section. */
11720 if (dynamic_symbols == NULL || dynamic_strings == NULL)
32ec8896 11721 return FALSE;
252b5132
RH		 11722
11723 if (dynamic_addr)
11724 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11725 dynamic_syminfo_offset, dynamic_syminfo_nent);
11726
11727 printf (_(" Num: Name BoundTo Flags\n"));
11728 for (i = 0; i < dynamic_syminfo_nent; ++i)
11729 {
11730 unsigned short int flags = dynamic_syminfo[i].si_flags;
11731
31104126 11732 printf ("%4d: ", i);
4082ef84
NC		 11733 if (i >= num_dynamic_syms)
11734 printf (_("<corrupt index>"));
11735 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
d79b3d50
NC		 11736 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11737 else
2b692964 11738 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 11739 putchar (' ');
252b5132
RH		 11740
11741 switch (dynamic_syminfo[i].si_boundto)
11742 {
11743 case SYMINFO_BT_SELF:
11744 fputs ("SELF ", stdout);
11745 break;
11746 case SYMINFO_BT_PARENT:
11747 fputs ("PARENT ", stdout);
11748 break;
11749 default:
11750 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 11751 && dynamic_syminfo[i].si_boundto < dynamic_nent
11752 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 11753 {
d79b3d50 11754 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 11755 putchar (' ' );
11756 }
252b5132
RH		 11757 else
11758 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11759 break;
11760 }
11761
11762 if (flags & SYMINFO_FLG_DIRECT)
11763 printf (" DIRECT");
11764 if (flags & SYMINFO_FLG_PASSTHRU)
11765 printf (" PASSTHRU");
11766 if (flags & SYMINFO_FLG_COPY)
11767 printf (" COPY");
11768 if (flags & SYMINFO_FLG_LAZYLOAD)
11769 printf (" LAZYLOAD");
11770
11771 puts ("");
11772 }
11773
32ec8896 11774 return TRUE;
252b5132
RH		 11775}
11776
b32e566b
NC		 11777#define IN_RANGE(START,END,ADDR,OFF) \
11778 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11779
cf13d699
NC		 11780/* Check to see if the given reloc needs to be handled in a target specific
11781 manner. If so then process the reloc and return TRUE otherwise return
f84ce13b
NC		 11782 FALSE.
11783
11784 If called with reloc == NULL, then this is a signal that reloc processing
11785 for the current section has finished, and any saved state should be
11786 discarded. */
09c11c86 11787
cf13d699
NC		 11788static bfd_boolean
11789target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11790 unsigned char * start,
03f7786e 11791 unsigned char * end,
f84ce13b
NC		 11792 Elf_Internal_Sym * symtab,
11793 unsigned long num_syms)
252b5132 11794{
f84ce13b
NC		 11795 unsigned int reloc_type = 0;
11796 unsigned long sym_index = 0;
11797
11798 if (reloc)
11799 {
11800 reloc_type = get_reloc_type (reloc->r_info);
11801 sym_index = get_reloc_symindex (reloc->r_info);
11802 }
252b5132 11803
cf13d699 11804 switch (elf_header.e_machine)
252b5132 11805 {
13761a11
NC		 11806 case EM_MSP430:
11807 case EM_MSP430_OLD:
11808 {
11809 static Elf_Internal_Sym * saved_sym = NULL;
11810
f84ce13b
NC		 11811 if (reloc == NULL)
11812 {
11813 saved_sym = NULL;
11814 return TRUE;
11815 }
11816
13761a11
NC		 11817 switch (reloc_type)
11818 {
11819 case 10: /* R_MSP430_SYM_DIFF */
11820 if (uses_msp430x_relocs ())
11821 break;
1a0670f3 11822 /* Fall through. */
13761a11 11823 case 21: /* R_MSP430X_SYM_DIFF */
f84ce13b
NC		 11824 /* PR 21139. */
11825 if (sym_index >= num_syms)
11826 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11827 sym_index);
11828 else
11829 saved_sym = symtab + sym_index;
13761a11
NC		 11830 return TRUE;
11831
11832 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11833 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11834 goto handle_sym_diff;
0b4362b0 11835
13761a11
NC		 11836 case 5: /* R_MSP430_16_BYTE */
11837 case 9: /* R_MSP430_8 */
11838 if (uses_msp430x_relocs ())
11839 break;
11840 goto handle_sym_diff;
11841
11842 case 2: /* R_MSP430_ABS16 */
11843 case 15: /* R_MSP430X_ABS16 */
11844 if (! uses_msp430x_relocs ())
11845 break;
11846 goto handle_sym_diff;
0b4362b0 11847
13761a11
NC		 11848 handle_sym_diff:
11849 if (saved_sym != NULL)
11850 {
03f7786e 11851 int reloc_size = reloc_type == 1 ? 4 : 2;
13761a11
NC		 11852 bfd_vma value;
11853
f84ce13b
NC		 11854 if (sym_index >= num_syms)
11855 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
11856 sym_index);
03f7786e 11857 else
f84ce13b
NC		 11858 {
11859 value = reloc->r_addend + (symtab[sym_index].st_value
11860 - saved_sym->st_value);
11861
b32e566b 11862 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
f84ce13b 11863 byte_put (start + reloc->r_offset, value, reloc_size);
b32e566b
NC		 11864 else
11865 /* PR 21137 */
11866 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
11867 (long) reloc->r_offset);
f84ce13b 11868 }
13761a11
NC		 11869
11870 saved_sym = NULL;
11871 return TRUE;
11872 }
11873 break;
11874
11875 default:
11876 if (saved_sym != NULL)
071436c6 11877 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13761a11
NC		 11878 break;
11879 }
11880 break;
11881 }
11882
cf13d699
NC		 11883 case EM_MN10300:
11884 case EM_CYGNUS_MN10300:
11885 {
11886 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 11887
f84ce13b
NC		 11888 if (reloc == NULL)
11889 {
11890 saved_sym = NULL;
11891 return TRUE;
11892 }
11893
cf13d699
NC		 11894 switch (reloc_type)
11895 {
11896 case 34: /* R_MN10300_ALIGN */
11897 return TRUE;
11898 case 33: /* R_MN10300_SYM_DIFF */
f84ce13b
NC		 11899 if (sym_index >= num_syms)
11900 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
11901 sym_index);
11902 else
11903 saved_sym = symtab + sym_index;
cf13d699 11904 return TRUE;
f84ce13b 11905
cf13d699
NC		 11906 case 1: /* R_MN10300_32 */
11907 case 2: /* R_MN10300_16 */
11908 if (saved_sym != NULL)
11909 {
03f7786e 11910 int reloc_size = reloc_type == 1 ? 4 : 2;
cf13d699 11911 bfd_vma value;
252b5132 11912
f84ce13b
NC		 11913 if (sym_index >= num_syms)
11914 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
11915 sym_index);
03f7786e 11916 else
f84ce13b
NC		 11917 {
11918 value = reloc->r_addend + (symtab[sym_index].st_value
11919 - saved_sym->st_value);
11920
b32e566b 11921 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
f84ce13b 11922 byte_put (start + reloc->r_offset, value, reloc_size);
b32e566b
NC		 11923 else
11924 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
11925 (long) reloc->r_offset);
f84ce13b 11926 }
252b5132 11927
cf13d699
NC		 11928 saved_sym = NULL;
11929 return TRUE;
11930 }
11931 break;
11932 default:
11933 if (saved_sym != NULL)
071436c6 11934 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
cf13d699
NC		 11935 break;
11936 }
11937 break;
11938 }
6ff71e76
NC		 11939
11940 case EM_RL78:
11941 {
11942 static bfd_vma saved_sym1 = 0;
11943 static bfd_vma saved_sym2 = 0;
11944 static bfd_vma value;
11945
f84ce13b
NC		 11946 if (reloc == NULL)
11947 {
11948 saved_sym1 = saved_sym2 = 0;
11949 return TRUE;
11950 }
11951
6ff71e76
NC		 11952 switch (reloc_type)
11953 {
11954 case 0x80: /* R_RL78_SYM. */
11955 saved_sym1 = saved_sym2;
f84ce13b
NC		 11956 if (sym_index >= num_syms)
11957 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
11958 sym_index);
11959 else
11960 {
11961 saved_sym2 = symtab[sym_index].st_value;
11962 saved_sym2 += reloc->r_addend;
11963 }
6ff71e76
NC		 11964 return TRUE;
11965
11966 case 0x83: /* R_RL78_OPsub. */
11967 value = saved_sym1 - saved_sym2;
11968 saved_sym2 = saved_sym1 = 0;
11969 return TRUE;
11970 break;
11971
11972 case 0x41: /* R_RL78_ABS32. */
b32e566b 11973 if (IN_RANGE (start, end, start + reloc->r_offset, 4))
03f7786e 11974 byte_put (start + reloc->r_offset, value, 4);
b32e566b
NC		 11975 else
11976 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11977 (long) reloc->r_offset);
6ff71e76
NC		 11978 value = 0;
11979 return TRUE;
11980
11981 case 0x43: /* R_RL78_ABS16. */
b32e566b 11982 if (IN_RANGE (start, end, start + reloc->r_offset, 2))
03f7786e 11983 byte_put (start + reloc->r_offset, value, 2);
b32e566b
NC		 11984 else
11985 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11986 (long) reloc->r_offset);
6ff71e76
NC		 11987 value = 0;
11988 return TRUE;
11989
11990 default:
11991 break;
11992 }
11993 break;
11994 }
252b5132
RH		 11995 }
11996
cf13d699 11997 return FALSE;
252b5132
RH		 11998}
11999
aca88567
NC		 12000/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12001 DWARF debug sections. This is a target specific test. Note - we do not
12002 go through the whole including-target-headers-multiple-times route, (as
12003 we have already done with <elf/h8.h>) because this would become very
12004 messy and even then this function would have to contain target specific
12005 information (the names of the relocs instead of their numeric values).
12006 FIXME: This is not the correct way to solve this problem. The proper way
12007 is to have target specific reloc sizing and typing functions created by
12008 the reloc-macros.h header, in the same way that it already creates the
12009 reloc naming functions. */
12010
12011static bfd_boolean
12012is_32bit_abs_reloc (unsigned int reloc_type)
12013{
d347c9df 12014 /* Please keep this table alpha-sorted for ease of visual lookup. */
aca88567
NC		 12015 switch (elf_header.e_machine)
12016 {
41e92641 12017 case EM_386:
22abe556 12018 case EM_IAMCU:
41e92641 12019 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 12020 case EM_68K:
12021 return reloc_type == 1; /* R_68K_32. */
12022 case EM_860:
12023 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 12024 case EM_960:
12025 return reloc_type == 2; /* R_960_32. */
a06ea964 12026 case EM_AARCH64:
9282b95a
JW		 12027 return (reloc_type == 258
12028 || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
d347c9df
PS		 12029 case EM_ADAPTEVA_EPIPHANY:
12030 return reloc_type == 3;
aca88567 12031 case EM_ALPHA:
137b6b5f 12032 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 12033 case EM_ARC:
12034 return reloc_type == 1; /* R_ARC_32. */
886a2506
NC		 12035 case EM_ARC_COMPACT:
12036 case EM_ARC_COMPACT2:
12037 return reloc_type == 4; /* R_ARC_32. */
41e92641
NC		 12038 case EM_ARM:
12039 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 12040 case EM_AVR_OLD:
aca88567
NC		 12041 case EM_AVR:
12042 return reloc_type == 1;
12043 case EM_BLACKFIN:
12044 return reloc_type == 0x12; /* R_byte4_data. */
12045 case EM_CRIS:
12046 return reloc_type == 3; /* R_CRIS_32. */
12047 case EM_CR16:
12048 return reloc_type == 3; /* R_CR16_NUM32. */
12049 case EM_CRX:
12050 return reloc_type == 15; /* R_CRX_NUM32. */
12051 case EM_CYGNUS_FRV:
12052 return reloc_type == 1;
41e92641
NC		 12053 case EM_CYGNUS_D10V:
12054 case EM_D10V:
12055 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 12056 case EM_CYGNUS_D30V:
12057 case EM_D30V:
12058 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 12059 case EM_DLX:
12060 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 12061 case EM_CYGNUS_FR30:
12062 case EM_FR30:
12063 return reloc_type == 3; /* R_FR30_32. */
3f8107ab
AM		 12064 case EM_FT32:
12065 return reloc_type == 1; /* R_FT32_32. */
aca88567
NC		 12066 case EM_H8S:
12067 case EM_H8_300:
12068 case EM_H8_300H:
12069 return reloc_type == 1; /* R_H8_DIR32. */
3730236a 12070 case EM_IA_64:
d1c4b12b
NC		 12071 return reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
12072 || reloc_type == 0x25; /* R_IA64_DIR32LSB. */
aca88567
NC		 12073 case EM_IP2K_OLD:
12074 case EM_IP2K:
12075 return reloc_type == 2; /* R_IP2K_32. */
12076 case EM_IQ2000:
12077 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 12078 case EM_LATTICEMICO32:
12079 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 12080 case EM_M32C_OLD:
aca88567
NC		 12081 case EM_M32C:
12082 return reloc_type == 3; /* R_M32C_32. */
12083 case EM_M32R:
12084 return reloc_type == 34; /* R_M32R_32_RELA. */
adec12c1
AM		 12085 case EM_68HC11:
12086 case EM_68HC12:
12087 return reloc_type == 6; /* R_M68HC11_32. */
aca88567
NC		 12088 case EM_MCORE:
12089 return reloc_type == 1; /* R_MCORE_ADDR32. */
12090 case EM_CYGNUS_MEP:
12091 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 12092 case EM_METAG:
12093 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 12094 case EM_MICROBLAZE:
12095 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 12096 case EM_MIPS:
12097 return reloc_type == 2; /* R_MIPS_32. */
12098 case EM_MMIX:
12099 return reloc_type == 4; /* R_MMIX_32. */
12100 case EM_CYGNUS_MN10200:
12101 case EM_MN10200:
12102 return reloc_type == 1; /* R_MN10200_32. */
12103 case EM_CYGNUS_MN10300:
12104 case EM_MN10300:
12105 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 12106 case EM_MOXIE:
12107 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 12108 case EM_MSP430_OLD:
12109 case EM_MSP430:
13761a11 12110 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
aca88567
NC		 12111 case EM_MT:
12112 return reloc_type == 2; /* R_MT_32. */
35c08157
KLC		 12113 case EM_NDS32:
12114 return reloc_type == 20; /* R_NDS32_RELA. */
3e0873ac 12115 case EM_ALTERA_NIOS2:
36591ba1 12116 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
3e0873ac
NC		 12117 case EM_NIOS32:
12118 return reloc_type == 1; /* R_NIOS_32. */
73589c9d
CS		 12119 case EM_OR1K:
12120 return reloc_type == 1; /* R_OR1K_32. */
aca88567 12121 case EM_PARISC:
5fda8eca
NC		 12122 return (reloc_type == 1 /* R_PARISC_DIR32. */
12123 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 12124 case EM_PJ:
12125 case EM_PJ_OLD:
12126 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
12127 case EM_PPC64:
12128 return reloc_type == 1; /* R_PPC64_ADDR32. */
12129 case EM_PPC:
12130 return reloc_type == 1; /* R_PPC_ADDR32. */
2b100bb5
DD		 12131 case EM_TI_PRU:
12132 return reloc_type == 11; /* R_PRU_BFD_RELOC_32. */
e23eba97
NC		 12133 case EM_RISCV:
12134 return reloc_type == 1; /* R_RISCV_32. */
99c513f6
DD		 12135 case EM_RL78:
12136 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 12137 case EM_RX:
12138 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 12139 case EM_S370:
12140 return reloc_type == 1; /* R_I370_ADDR31. */
12141 case EM_S390_OLD:
12142 case EM_S390:
12143 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 12144 case EM_SCORE:
12145 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 12146 case EM_SH:
12147 return reloc_type == 1; /* R_SH_DIR32. */
12148 case EM_SPARC32PLUS:
12149 case EM_SPARCV9:
12150 case EM_SPARC:
12151 return reloc_type == 3 /* R_SPARC_32. */
12152 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 12153 case EM_SPU:
12154 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 12155 case EM_TI_C6000:
12156 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 12157 case EM_TILEGX:
12158 return reloc_type == 2; /* R_TILEGX_32. */
12159 case EM_TILEPRO:
12160 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 12161 case EM_CYGNUS_V850:
12162 case EM_V850:
12163 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 12164 case EM_V800:
12165 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 12166 case EM_VAX:
12167 return reloc_type == 1; /* R_VAX_32. */
619ed720
EB		 12168 case EM_VISIUM:
12169 return reloc_type == 3; /* R_VISIUM_32. */
f96bd6c2
PC		 12170 case EM_WEBASSEMBLY:
12171 return reloc_type == 1; /* R_WASM32_32. */
aca88567 12172 case EM_X86_64:
8a9036a4 12173 case EM_L1OM:
7a9068fe 12174 case EM_K1OM:
aca88567 12175 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 12176 case EM_XC16X:
12177 case EM_C166:
12178 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 12179 case EM_XGATE:
12180 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 12181 case EM_XSTORMY16:
12182 return reloc_type == 1; /* R_XSTROMY16_32. */
12183 case EM_XTENSA_OLD:
12184 case EM_XTENSA:
12185 return reloc_type == 1; /* R_XTENSA_32. */
aca88567 12186 default:
bee0ee85
NC		 12187 {
12188 static unsigned int prev_warn = 0;
12189
12190 /* Avoid repeating the same warning multiple times. */
12191 if (prev_warn != elf_header.e_machine)
12192 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12193 elf_header.e_machine);
12194 prev_warn = elf_header.e_machine;
12195 return FALSE;
12196 }
aca88567
NC		 12197 }
12198}
12199
12200/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12201 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12202
12203static bfd_boolean
12204is_32bit_pcrel_reloc (unsigned int reloc_type)
12205{
12206 switch (elf_header.e_machine)
d347c9df 12207 /* Please keep this table alpha-sorted for ease of visual lookup. */
aca88567 12208 {
41e92641 12209 case EM_386:
22abe556 12210 case EM_IAMCU:
3e0873ac 12211 return reloc_type == 2; /* R_386_PC32. */
aca88567 12212 case EM_68K:
3e0873ac 12213 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 12214 case EM_AARCH64:
12215 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 12216 case EM_ADAPTEVA_EPIPHANY:
12217 return reloc_type == 6;
aca88567
NC		 12218 case EM_ALPHA:
12219 return reloc_type == 10; /* R_ALPHA_SREL32. */
726c18e1
CZ		 12220 case EM_ARC_COMPACT:
12221 case EM_ARC_COMPACT2:
12222 return reloc_type == 49; /* R_ARC_32_PCREL. */
41e92641 12223 case EM_ARM:
3e0873ac 12224 return reloc_type == 3; /* R_ARM_REL32 */
d347c9df
PS		 12225 case EM_AVR_OLD:
12226 case EM_AVR:
12227 return reloc_type == 36; /* R_AVR_32_PCREL. */
137b6b5f
AM		 12228 case EM_MICROBLAZE:
12229 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
73589c9d
CS		 12230 case EM_OR1K:
12231 return reloc_type == 9; /* R_OR1K_32_PCREL. */
aca88567 12232 case EM_PARISC:
85acf597 12233 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 12234 case EM_PPC:
12235 return reloc_type == 26; /* R_PPC_REL32. */
12236 case EM_PPC64:
3e0873ac 12237 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 12238 case EM_S390_OLD:
12239 case EM_S390:
3e0873ac 12240 return reloc_type == 5; /* R_390_PC32. */
aca88567 12241 case EM_SH:
3e0873ac 12242 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 12243 case EM_SPARC32PLUS:
12244 case EM_SPARCV9:
12245 case EM_SPARC:
3e0873ac 12246 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 12247 case EM_SPU:
12248 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 12249 case EM_TILEGX:
12250 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
12251 case EM_TILEPRO:
12252 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
619ed720
EB		 12253 case EM_VISIUM:
12254 return reloc_type == 6; /* R_VISIUM_32_PCREL */
aca88567 12255 case EM_X86_64:
8a9036a4 12256 case EM_L1OM:
7a9068fe 12257 case EM_K1OM:
3e0873ac 12258 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 12259 case EM_XTENSA_OLD:
12260 case EM_XTENSA:
12261 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 12262 default:
12263 /* Do not abort or issue an error message here. Not all targets use
12264 pc-relative 32-bit relocs in their DWARF debug information and we
12265 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 12266 more helpful warning message will be generated by apply_relocations
12267 anyway, so just return. */
aca88567
NC		 12268 return FALSE;
12269 }
12270}
12271
12272/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12273 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12274
12275static bfd_boolean
12276is_64bit_abs_reloc (unsigned int reloc_type)
12277{
12278 switch (elf_header.e_machine)
12279 {
a06ea964
NC		 12280 case EM_AARCH64:
12281 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 12282 case EM_ALPHA:
12283 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 12284 case EM_IA_64:
12285 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 12286 case EM_PARISC:
12287 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 12288 case EM_PPC64:
12289 return reloc_type == 38; /* R_PPC64_ADDR64. */
e23eba97
NC		 12290 case EM_RISCV:
12291 return reloc_type == 2; /* R_RISCV_64. */
aca88567
NC		 12292 case EM_SPARC32PLUS:
12293 case EM_SPARCV9:
12294 case EM_SPARC:
12295 return reloc_type == 54; /* R_SPARC_UA64. */
12296 case EM_X86_64:
8a9036a4 12297 case EM_L1OM:
7a9068fe 12298 case EM_K1OM:
aca88567 12299 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 12300 case EM_S390_OLD:
12301 case EM_S390:
aa137e4d
NC		 12302 return reloc_type == 22; /* R_S390_64. */
12303 case EM_TILEGX:
12304 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 12305 case EM_MIPS:
aa137e4d 12306 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 12307 default:
12308 return FALSE;
12309 }
12310}
12311
85acf597
RH		 12312/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12313 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12314
12315static bfd_boolean
12316is_64bit_pcrel_reloc (unsigned int reloc_type)
12317{
12318 switch (elf_header.e_machine)
12319 {
a06ea964
NC		 12320 case EM_AARCH64:
12321 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 12322 case EM_ALPHA:
aa137e4d 12323 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 12324 case EM_IA_64:
aa137e4d 12325 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 12326 case EM_PARISC:
aa137e4d 12327 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 12328 case EM_PPC64:
aa137e4d 12329 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 12330 case EM_SPARC32PLUS:
12331 case EM_SPARCV9:
12332 case EM_SPARC:
aa137e4d 12333 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 12334 case EM_X86_64:
8a9036a4 12335 case EM_L1OM:
7a9068fe 12336 case EM_K1OM:
aa137e4d 12337 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 12338 case EM_S390_OLD:
12339 case EM_S390:
aa137e4d
NC		 12340 return reloc_type == 23; /* R_S390_PC64. */
12341 case EM_TILEGX:
12342 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 12343 default:
12344 return FALSE;
12345 }
12346}
12347
4dc3c23d
AM		 12348/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12349 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12350
12351static bfd_boolean
12352is_24bit_abs_reloc (unsigned int reloc_type)
12353{
12354 switch (elf_header.e_machine)
12355 {
12356 case EM_CYGNUS_MN10200:
12357 case EM_MN10200:
12358 return reloc_type == 4; /* R_MN10200_24. */
3ee6e4fb
NC		 12359 case EM_FT32:
12360 return reloc_type == 5; /* R_FT32_20. */
4dc3c23d
AM		 12361 default:
12362 return FALSE;
12363 }
12364}
12365
aca88567
NC		 12366/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12367 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12368
12369static bfd_boolean
12370is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a 12371{
d347c9df 12372 /* Please keep this table alpha-sorted for ease of visual lookup. */
4b78141a
NC		 12373 switch (elf_header.e_machine)
12374 {
886a2506
NC		 12375 case EM_ARC:
12376 case EM_ARC_COMPACT:
12377 case EM_ARC_COMPACT2:
12378 return reloc_type == 2; /* R_ARC_16. */
d347c9df
PS		 12379 case EM_ADAPTEVA_EPIPHANY:
12380 return reloc_type == 5;
aca88567
NC		 12381 case EM_AVR_OLD:
12382 case EM_AVR:
12383 return reloc_type == 4; /* R_AVR_16. */
41e92641
NC		 12384 case EM_CYGNUS_D10V:
12385 case EM_D10V:
12386 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 12387 case EM_H8S:
12388 case EM_H8_300:
12389 case EM_H8_300H:
aca88567
NC		 12390 return reloc_type == R_H8_DIR16;
12391 case EM_IP2K_OLD:
12392 case EM_IP2K:
12393 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 12394 case EM_M32C_OLD:
f4236fe4
DD		 12395 case EM_M32C:
12396 return reloc_type == 1; /* R_M32C_16 */
d347c9df
PS		 12397 case EM_CYGNUS_MN10200:
12398 case EM_MN10200:
12399 return reloc_type == 2; /* R_MN10200_16. */
12400 case EM_CYGNUS_MN10300:
12401 case EM_MN10300:
12402 return reloc_type == 2; /* R_MN10300_16. */
aca88567 12403 case EM_MSP430:
13761a11
NC		 12404 if (uses_msp430x_relocs ())
12405 return reloc_type == 2; /* R_MSP430_ABS16. */
1a0670f3 12406 /* Fall through. */
78c8d46c 12407 case EM_MSP430_OLD:
aca88567 12408 return reloc_type == 5; /* R_MSP430_16_BYTE. */
35c08157
KLC		 12409 case EM_NDS32:
12410 return reloc_type == 19; /* R_NDS32_RELA. */
3e0873ac 12411 case EM_ALTERA_NIOS2:
36591ba1 12412 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
3e0873ac
NC		 12413 case EM_NIOS32:
12414 return reloc_type == 9; /* R_NIOS_16. */
73589c9d
CS		 12415 case EM_OR1K:
12416 return reloc_type == 2; /* R_OR1K_16. */
2b100bb5
DD		 12417 case EM_TI_PRU:
12418 return reloc_type == 8; /* R_PRU_BFD_RELOC_16. */
40b36596
JM		 12419 case EM_TI_C6000:
12420 return reloc_type == 2; /* R_C6000_ABS16. */
d347c9df
PS		 12421 case EM_VISIUM:
12422 return reloc_type == 2; /* R_VISIUM_16. */
c29aca4a
NC		 12423 case EM_XC16X:
12424 case EM_C166:
12425 return reloc_type == 2; /* R_XC16C_ABS_16. */
f6c1a2d5
NC		 12426 case EM_XGATE:
12427 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 12428 default:
aca88567 12429 return FALSE;
4b78141a
NC		 12430 }
12431}
12432
2a7b2e88
JK		 12433/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12434 relocation entries (possibly formerly used for SHT_GROUP sections). */
12435
12436static bfd_boolean
12437is_none_reloc (unsigned int reloc_type)
12438{
12439 switch (elf_header.e_machine)
12440 {
cb8f3167 12441 case EM_386: /* R_386_NONE. */
d347c9df 12442 case EM_68K: /* R_68K_NONE. */
cfb8c092 12443 case EM_ADAPTEVA_EPIPHANY:
d347c9df
PS		 12444 case EM_ALPHA: /* R_ALPHA_NONE. */
12445 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
886a2506 12446 case EM_ARC: /* R_ARC_NONE. */
886a2506 12447 case EM_ARC_COMPACT2: /* R_ARC_NONE. */
d347c9df 12448 case EM_ARC_COMPACT: /* R_ARC_NONE. */
cb8f3167 12449 case EM_ARM: /* R_ARM_NONE. */
d347c9df 12450 case EM_C166: /* R_XC16X_NONE. */
cb8f3167 12451 case EM_CRIS: /* R_CRIS_NONE. */
d347c9df
PS		 12452 case EM_FT32: /* R_FT32_NONE. */
12453 case EM_IA_64: /* R_IA64_NONE. */
7a9068fe 12454 case EM_K1OM: /* R_X86_64_NONE. */
d347c9df
PS		 12455 case EM_L1OM: /* R_X86_64_NONE. */
12456 case EM_M32R: /* R_M32R_NONE. */
12457 case EM_MIPS: /* R_MIPS_NONE. */
cb8f3167 12458 case EM_MN10300: /* R_MN10300_NONE. */
5506d11a 12459 case EM_MOXIE: /* R_MOXIE_NONE. */
d347c9df
PS		 12460 case EM_NIOS32: /* R_NIOS_NONE. */
12461 case EM_OR1K: /* R_OR1K_NONE. */
12462 case EM_PARISC: /* R_PARISC_NONE. */
12463 case EM_PPC64: /* R_PPC64_NONE. */
12464 case EM_PPC: /* R_PPC_NONE. */
e23eba97 12465 case EM_RISCV: /* R_RISCV_NONE. */
d347c9df
PS		 12466 case EM_S390: /* R_390_NONE. */
12467 case EM_S390_OLD:
12468 case EM_SH: /* R_SH_NONE. */
12469 case EM_SPARC32PLUS:
12470 case EM_SPARC: /* R_SPARC_NONE. */
12471 case EM_SPARCV9:
aa137e4d
NC		 12472 case EM_TILEGX: /* R_TILEGX_NONE. */
12473 case EM_TILEPRO: /* R_TILEPRO_NONE. */
d347c9df
PS		 12474 case EM_TI_C6000:/* R_C6000_NONE. */
12475 case EM_X86_64: /* R_X86_64_NONE. */
c29aca4a 12476 case EM_XC16X:
f96bd6c2 12477 case EM_WEBASSEMBLY: /* R_WASM32_NONE. */
cb8f3167 12478 return reloc_type == 0;
d347c9df 12479
a06ea964
NC		 12480 case EM_AARCH64:
12481 return reloc_type == 0 || reloc_type == 256;
d347c9df
PS		 12482 case EM_AVR_OLD:
12483 case EM_AVR:
12484 return (reloc_type == 0 /* R_AVR_NONE. */
12485 || reloc_type == 30 /* R_AVR_DIFF8. */
12486 || reloc_type == 31 /* R_AVR_DIFF16. */
12487 || reloc_type == 32 /* R_AVR_DIFF32. */);
12488 case EM_METAG:
12489 return reloc_type == 3; /* R_METAG_NONE. */
35c08157
KLC		 12490 case EM_NDS32:
12491 return (reloc_type == 0 /* R_XTENSA_NONE. */
12492 || reloc_type == 204 /* R_NDS32_DIFF8. */
12493 || reloc_type == 205 /* R_NDS32_DIFF16. */
12494 || reloc_type == 206 /* R_NDS32_DIFF32. */
12495 || reloc_type == 207 /* R_NDS32_ULEB128. */);
2b100bb5
DD		 12496 case EM_TI_PRU:
12497 return (reloc_type == 0 /* R_PRU_NONE. */
12498 || reloc_type == 65 /* R_PRU_DIFF8. */
12499 || reloc_type == 66 /* R_PRU_DIFF16. */
12500 || reloc_type == 67 /* R_PRU_DIFF32. */);
58332dda
JK		 12501 case EM_XTENSA_OLD:
12502 case EM_XTENSA:
4dc3c23d
AM		 12503 return (reloc_type == 0 /* R_XTENSA_NONE. */
12504 || reloc_type == 17 /* R_XTENSA_DIFF8. */
12505 || reloc_type == 18 /* R_XTENSA_DIFF16. */
12506 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
2a7b2e88
JK		 12507 }
12508 return FALSE;
12509}
12510
d1c4b12b
NC		 12511/* Returns TRUE if there is a relocation against
12512 section NAME at OFFSET bytes. */
12513
12514bfd_boolean
12515reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
12516{
12517 Elf_Internal_Rela * relocs;
12518 Elf_Internal_Rela * rp;
12519
12520 if (dsec == NULL || dsec->reloc_info == NULL)
12521 return FALSE;
12522
12523 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
12524
12525 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
12526 if (rp->r_offset == offset)
12527 return TRUE;
12528
12529 return FALSE;
12530}
12531
cf13d699 12532/* Apply relocations to a section.
32ec8896
NC		 12533 Returns TRUE upon success, FALSE otherwise.
12534 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12535 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
12536 will be set to the number of relocs loaded.
12537
cf13d699 12538 Note: So far support has been added only for those relocations
32ec8896
NC		 12539 which can be found in debug sections. FIXME: Add support for
12540 more relocations ? */
1b315056 12541
32ec8896 12542static bfd_boolean
d1c4b12b
NC		 12543apply_relocations (void * file,
12544 const Elf_Internal_Shdr * section,
12545 unsigned char * start,
12546 bfd_size_type size,
1449284b 12547 void ** relocs_return,
d1c4b12b 12548 unsigned long * num_relocs_return)
1b315056 12549{
cf13d699 12550 Elf_Internal_Shdr * relsec;
0d2a7a93 12551 unsigned char * end = start + size;
32ec8896 12552 bfd_boolean res = TRUE;
cb8f3167 12553
d1c4b12b
NC		 12554 if (relocs_return != NULL)
12555 {
12556 * (Elf_Internal_Rela **) relocs_return = NULL;
12557 * num_relocs_return = 0;
12558 }
12559
cf13d699 12560 if (elf_header.e_type != ET_REL)
32ec8896
NC		 12561 /* No relocs to apply. */
12562 return TRUE;
1b315056 12563
cf13d699 12564 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 12565 for (relsec = section_headers;
12566 relsec < section_headers + elf_header.e_shnum;
12567 ++relsec)
252b5132 12568 {
41e92641
NC		 12569 bfd_boolean is_rela;
12570 unsigned long num_relocs;
2cf0635d
NC		 12571 Elf_Internal_Rela * relocs;
12572 Elf_Internal_Rela * rp;
12573 Elf_Internal_Shdr * symsec;
12574 Elf_Internal_Sym * symtab;
ba5cdace 12575 unsigned long num_syms;
2cf0635d 12576 Elf_Internal_Sym * sym;
252b5132 12577
41e92641 12578 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 12579 || relsec->sh_info >= elf_header.e_shnum
12580 || section_headers + relsec->sh_info != section
c256ffe7 12581 || relsec->sh_size == 0
4fbb74a6 12582 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 12583 continue;
428409d5 12584
41e92641
NC		 12585 is_rela = relsec->sh_type == SHT_RELA;
12586
12587 if (is_rela)
12588 {
3f5e193b
NC		 12589 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
12590 relsec->sh_size, & relocs, & num_relocs))
32ec8896 12591 return FALSE;
41e92641
NC		 12592 }
12593 else
12594 {
3f5e193b
NC		 12595 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
12596 relsec->sh_size, & relocs, & num_relocs))
32ec8896 12597 return FALSE;
41e92641
NC		 12598 }
12599
12600 /* SH uses RELA but uses in place value instead of the addend field. */
12601 if (elf_header.e_machine == EM_SH)
12602 is_rela = FALSE;
428409d5 12603
4fbb74a6 12604 symsec = section_headers + relsec->sh_link;
1449284b
NC		 12605 if (symsec->sh_type != SHT_SYMTAB
12606 && symsec->sh_type != SHT_DYNSYM)
32ec8896 12607 return FALSE;
ba5cdace 12608 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 12609
41e92641 12610 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 12611 {
41e92641
NC		 12612 bfd_vma addend;
12613 unsigned int reloc_type;
12614 unsigned int reloc_size;
91d6fa6a 12615 unsigned char * rloc;
ba5cdace 12616 unsigned long sym_index;
4b78141a 12617
aca88567 12618 reloc_type = get_reloc_type (rp->r_info);
41e92641 12619
f84ce13b 12620 if (target_specific_reloc_handling (rp, start, end, symtab, num_syms))
2a7b2e88 12621 continue;
98fb390a
NC		 12622 else if (is_none_reloc (reloc_type))
12623 continue;
12624 else if (is_32bit_abs_reloc (reloc_type)
12625 || is_32bit_pcrel_reloc (reloc_type))
aca88567 12626 reloc_size = 4;
85acf597
RH		 12627 else if (is_64bit_abs_reloc (reloc_type)
12628 || is_64bit_pcrel_reloc (reloc_type))
aca88567 12629 reloc_size = 8;
4dc3c23d
AM		 12630 else if (is_24bit_abs_reloc (reloc_type))
12631 reloc_size = 3;
aca88567
NC		 12632 else if (is_16bit_abs_reloc (reloc_type))
12633 reloc_size = 2;
12634 else
4b78141a 12635 {
bee0ee85
NC		 12636 static unsigned int prev_reloc = 0;
12637 if (reloc_type != prev_reloc)
12638 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12639 reloc_type, printable_section_name (section));
12640 prev_reloc = reloc_type;
32ec8896 12641 res = FALSE;
4b78141a
NC		 12642 continue;
12643 }
103f02d3 12644
91d6fa6a 12645 rloc = start + rp->r_offset;
c8da6823 12646 if ((rloc + reloc_size) > end || (rloc < start))
700dd8b7
L		 12647 {
12648 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12649 (unsigned long) rp->r_offset,
74e1a04b 12650 printable_section_name (section));
32ec8896 12651 res = FALSE;
700dd8b7
L		 12652 continue;
12653 }
103f02d3 12654
ba5cdace
NC		 12655 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
12656 if (sym_index >= num_syms)
12657 {
12658 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
74e1a04b 12659 sym_index, printable_section_name (section));
32ec8896 12660 res = FALSE;
ba5cdace
NC		 12661 continue;
12662 }
12663 sym = symtab + sym_index;
41e92641
NC		 12664
12665 /* If the reloc has a symbol associated with it,
55f25fc3
L		 12666 make sure that it is of an appropriate type.
12667
12668 Relocations against symbols without type can happen.
12669 Gcc -feliminate-dwarf2-dups may generate symbols
12670 without type for debug info.
12671
12672 Icc generates relocations against function symbols
12673 instead of local labels.
12674
12675 Relocations against object symbols can happen, eg when
12676 referencing a global array. For an example of this see
12677 the _clz.o binary in libgcc.a. */
aca88567 12678 if (sym != symtab
b8871f35 12679 && ELF_ST_TYPE (sym->st_info) != STT_COMMON
55f25fc3 12680 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 12681 {
41e92641 12682 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 12683 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 12684 (long int)(rp - relocs),
74e1a04b 12685 printable_section_name (relsec));
32ec8896 12686 res = FALSE;
aca88567 12687 continue;
5b18a4bc 12688 }
252b5132 12689
4dc3c23d
AM		 12690 addend = 0;
12691 if (is_rela)
12692 addend += rp->r_addend;
c47320c3
AM		 12693 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12694 partial_inplace. */
4dc3c23d
AM		 12695 if (!is_rela
12696 || (elf_header.e_machine == EM_XTENSA
12697 && reloc_type == 1)
12698 || ((elf_header.e_machine == EM_PJ
12699 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 12700 && reloc_type == 1)
12701 || ((elf_header.e_machine == EM_D30V
12702 || elf_header.e_machine == EM_CYGNUS_D30V)
12703 && reloc_type == 12))
91d6fa6a 12704 addend += byte_get (rloc, reloc_size);
cb8f3167 12705
85acf597
RH		 12706 if (is_32bit_pcrel_reloc (reloc_type)
12707 || is_64bit_pcrel_reloc (reloc_type))
12708 {
12709 /* On HPPA, all pc-relative relocations are biased by 8. */
12710 if (elf_header.e_machine == EM_PARISC)
12711 addend -= 8;
91d6fa6a 12712 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 12713 reloc_size);
12714 }
41e92641 12715 else
91d6fa6a 12716 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 12717 }
252b5132 12718
5b18a4bc 12719 free (symtab);
f84ce13b
NC		 12720 /* Let the target specific reloc processing code know that
12721 we have finished with these relocs. */
12722 target_specific_reloc_handling (NULL, NULL, NULL, NULL, 0);
d1c4b12b
NC		 12723
12724 if (relocs_return)
12725 {
12726 * (Elf_Internal_Rela **) relocs_return = relocs;
12727 * num_relocs_return = num_relocs;
12728 }
12729 else
12730 free (relocs);
12731
5b18a4bc
NC		 12732 break;
12733 }
32ec8896
NC		 12734
12735 return res;
5b18a4bc 12736}
103f02d3 12737
cf13d699 12738#ifdef SUPPORT_DISASSEMBLY
32ec8896 12739static bfd_boolean
cf13d699
NC		 12740disassemble_section (Elf_Internal_Shdr * section, FILE * file)
12741{
74e1a04b 12742 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
cf13d699 12743
74e1a04b 12744 /* FIXME: XXX -- to be done --- XXX */
cf13d699 12745
32ec8896 12746 return TRUE;
cf13d699
NC		 12747}
12748#endif
12749
12750/* Reads in the contents of SECTION from FILE, returning a pointer
12751 to a malloc'ed buffer or NULL if something went wrong. */
12752
12753static char *
12754get_section_contents (Elf_Internal_Shdr * section, FILE * file)
12755{
12756 bfd_size_type num_bytes;
12757
12758 num_bytes = section->sh_size;
12759
12760 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
12761 {
12762 printf (_("\nSection '%s' has no data to dump.\n"),
74e1a04b 12763 printable_section_name (section));
cf13d699
NC		 12764 return NULL;
12765 }
12766
3f5e193b
NC		 12767 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
12768 _("section contents"));
cf13d699
NC		 12769}
12770
0e602686
NC		 12771/* Uncompresses a section that was compressed using zlib, in place. */
12772
12773static bfd_boolean
12774uncompress_section_contents (unsigned char **buffer,
12775 dwarf_size_type uncompressed_size,
12776 dwarf_size_type *size)
12777{
12778 dwarf_size_type compressed_size = *size;
12779 unsigned char * compressed_buffer = *buffer;
12780 unsigned char * uncompressed_buffer;
12781 z_stream strm;
12782 int rc;
12783
12784 /* It is possible the section consists of several compressed
12785 buffers concatenated together, so we uncompress in a loop. */
12786 /* PR 18313: The state field in the z_stream structure is supposed
12787 to be invisible to the user (ie us), but some compilers will
12788 still complain about it being used without initialisation. So
12789 we first zero the entire z_stream structure and then set the fields
12790 that we need. */
12791 memset (& strm, 0, sizeof strm);
12792 strm.avail_in = compressed_size;
12793 strm.next_in = (Bytef *) compressed_buffer;
12794 strm.avail_out = uncompressed_size;
12795 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
12796
12797 rc = inflateInit (& strm);
12798 while (strm.avail_in > 0)
12799 {
12800 if (rc != Z_OK)
12801 goto fail;
12802 strm.next_out = ((Bytef *) uncompressed_buffer
12803 + (uncompressed_size - strm.avail_out));
12804 rc = inflate (&strm, Z_FINISH);
12805 if (rc != Z_STREAM_END)
12806 goto fail;
12807 rc = inflateReset (& strm);
12808 }
12809 rc = inflateEnd (& strm);
12810 if (rc != Z_OK
12811 || strm.avail_out != 0)
12812 goto fail;
12813
12814 *buffer = uncompressed_buffer;
12815 *size = uncompressed_size;
12816 return TRUE;
12817
12818 fail:
12819 free (uncompressed_buffer);
12820 /* Indicate decompression failure. */
12821 *buffer = NULL;
12822 return FALSE;
12823}
dd24e3da 12824
32ec8896 12825static bfd_boolean
cf13d699
NC		 12826dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12827{
0e602686
NC		 12828 Elf_Internal_Shdr * relsec;
12829 bfd_size_type num_bytes;
fd8008d8
L		 12830 unsigned char * data;
12831 unsigned char * end;
12832 unsigned char * real_start;
12833 unsigned char * start;
0e602686 12834 bfd_boolean some_strings_shown;
cf13d699 12835
fd8008d8
L		 12836 real_start = start = (unsigned char *) get_section_contents (section,
12837 file);
cf13d699 12838 if (start == NULL)
32ec8896 12839 return FALSE;
0e602686 12840 num_bytes = section->sh_size;
cf13d699 12841
74e1a04b 12842 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
cf13d699 12843
0e602686
NC		 12844 if (decompress_dumps)
12845 {
12846 dwarf_size_type new_size = num_bytes;
12847 dwarf_size_type uncompressed_size = 0;
12848
12849 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12850 {
12851 Elf_Internal_Chdr chdr;
12852 unsigned int compression_header_size
ebdf1ebf
NC		 12853 = get_compression_header (& chdr, (unsigned char *) start,
12854 num_bytes);
0e602686 12855
813dabb9 12856 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
0e602686 12857 {
813dabb9
L		 12858 warn (_("section '%s' has unsupported compress type: %d\n"),
12859 printable_section_name (section), chdr.ch_type);
32ec8896 12860 return FALSE;
813dabb9
L		 12861 }
12862 else if (chdr.ch_addralign != section->sh_addralign)
12863 {
12864 warn (_("compressed section '%s' is corrupted\n"),
12865 printable_section_name (section));
32ec8896 12866 return FALSE;
0e602686 12867 }
813dabb9
L		 12868 uncompressed_size = chdr.ch_size;
12869 start += compression_header_size;
12870 new_size -= compression_header_size;
0e602686
NC		 12871 }
12872 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12873 {
12874 /* Read the zlib header. In this case, it should be "ZLIB"
12875 followed by the uncompressed section size, 8 bytes in
12876 big-endian order. */
12877 uncompressed_size = start[4]; uncompressed_size <<= 8;
12878 uncompressed_size += start[5]; uncompressed_size <<= 8;
12879 uncompressed_size += start[6]; uncompressed_size <<= 8;
12880 uncompressed_size += start[7]; uncompressed_size <<= 8;
12881 uncompressed_size += start[8]; uncompressed_size <<= 8;
12882 uncompressed_size += start[9]; uncompressed_size <<= 8;
12883 uncompressed_size += start[10]; uncompressed_size <<= 8;
12884 uncompressed_size += start[11];
12885 start += 12;
12886 new_size -= 12;
12887 }
12888
1835f746
NC		 12889 if (uncompressed_size)
12890 {
12891 if (uncompress_section_contents (& start,
12892 uncompressed_size, & new_size))
12893 num_bytes = new_size;
12894 else
12895 {
12896 error (_("Unable to decompress section %s\n"),
12897 printable_section_name (section));
32ec8896 12898 return FALSE;
1835f746
NC		 12899 }
12900 }
bc303e5d
NC		 12901 else
12902 start = real_start;
0e602686 12903 }
fd8008d8 12904
cf13d699
NC		 12905 /* If the section being dumped has relocations against it the user might
12906 be expecting these relocations to have been applied. Check for this
12907 case and issue a warning message in order to avoid confusion.
12908 FIXME: Maybe we ought to have an option that dumps a section with
12909 relocs applied ? */
12910 for (relsec = section_headers;
12911 relsec < section_headers + elf_header.e_shnum;
12912 ++relsec)
12913 {
12914 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12915 || relsec->sh_info >= elf_header.e_shnum
12916 || section_headers + relsec->sh_info != section
12917 || relsec->sh_size == 0
12918 || relsec->sh_link >= elf_header.e_shnum)
12919 continue;
12920
12921 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12922 break;
12923 }
12924
cf13d699
NC		 12925 data = start;
12926 end = start + num_bytes;
12927 some_strings_shown = FALSE;
12928
12929 while (data < end)
12930 {
12931 while (!ISPRINT (* data))
12932 if (++ data >= end)
12933 break;
12934
12935 if (data < end)
12936 {
071436c6
NC		 12937 size_t maxlen = end - data;
12938
cf13d699 12939#ifndef __MSVCRT__
c975cc98
NC		 12940 /* PR 11128: Use two separate invocations in order to work
12941 around bugs in the Solaris 8 implementation of printf. */
12942 printf (" [%6tx] ", data - start);
cf13d699 12943#else
071436c6 12944 printf (" [%6Ix] ", (size_t) (data - start));
cf13d699 12945#endif
4082ef84
NC		 12946 if (maxlen > 0)
12947 {
fd8008d8 12948 print_symbol ((int) maxlen, (const char *) data);
4082ef84 12949 putchar ('\n');
fd8008d8 12950 data += strnlen ((const char *) data, maxlen);
4082ef84
NC		 12951 }
12952 else
12953 {
12954 printf (_("<corrupt>\n"));
12955 data = end;
12956 }
cf13d699
NC		 12957 some_strings_shown = TRUE;
12958 }
12959 }
12960
12961 if (! some_strings_shown)
12962 printf (_(" No strings found in this section."));
12963
0e602686 12964 free (real_start);
cf13d699
NC		 12965
12966 putchar ('\n');
32ec8896 12967 return TRUE;
cf13d699
NC		 12968}
12969
32ec8896 12970static bfd_boolean
cf13d699
NC		 12971dump_section_as_bytes (Elf_Internal_Shdr * section,
12972 FILE * file,
12973 bfd_boolean relocate)
12974{
12975 Elf_Internal_Shdr * relsec;
0e602686
NC		 12976 bfd_size_type bytes;
12977 bfd_size_type section_size;
12978 bfd_vma addr;
12979 unsigned char * data;
12980 unsigned char * real_start;
12981 unsigned char * start;
12982
12983 real_start = start = (unsigned char *) get_section_contents (section, file);
cf13d699 12984 if (start == NULL)
32ec8896
NC		 12985 return FALSE;
12986
0e602686 12987 section_size = section->sh_size;
cf13d699 12988
74e1a04b 12989 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
cf13d699 12990
0e602686
NC		 12991 if (decompress_dumps)
12992 {
12993 dwarf_size_type new_size = section_size;
12994 dwarf_size_type uncompressed_size = 0;
12995
12996 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12997 {
12998 Elf_Internal_Chdr chdr;
12999 unsigned int compression_header_size
ebdf1ebf 13000 = get_compression_header (& chdr, start, section_size);
0e602686 13001
813dabb9 13002 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
0e602686 13003 {
813dabb9
L		 13004 warn (_("section '%s' has unsupported compress type: %d\n"),
13005 printable_section_name (section), chdr.ch_type);
32ec8896 13006 return FALSE;
0e602686 13007 }
813dabb9
L		 13008 else if (chdr.ch_addralign != section->sh_addralign)
13009 {
13010 warn (_("compressed section '%s' is corrupted\n"),
13011 printable_section_name (section));
32ec8896 13012 return FALSE;
813dabb9
L		 13013 }
13014 uncompressed_size = chdr.ch_size;
13015 start += compression_header_size;
13016 new_size -= compression_header_size;
0e602686
NC		 13017 }
13018 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13019 {
13020 /* Read the zlib header. In this case, it should be "ZLIB"
13021 followed by the uncompressed section size, 8 bytes in
13022 big-endian order. */
13023 uncompressed_size = start[4]; uncompressed_size <<= 8;
13024 uncompressed_size += start[5]; uncompressed_size <<= 8;
13025 uncompressed_size += start[6]; uncompressed_size <<= 8;
13026 uncompressed_size += start[7]; uncompressed_size <<= 8;
13027 uncompressed_size += start[8]; uncompressed_size <<= 8;
13028 uncompressed_size += start[9]; uncompressed_size <<= 8;
13029 uncompressed_size += start[10]; uncompressed_size <<= 8;
13030 uncompressed_size += start[11];
13031 start += 12;
13032 new_size -= 12;
13033 }
13034
f055032e
NC		 13035 if (uncompressed_size)
13036 {
13037 if (uncompress_section_contents (& start, uncompressed_size,
13038 & new_size))
bc303e5d
NC		 13039 {
13040 section_size = new_size;
13041 }
f055032e
NC		 13042 else
13043 {
13044 error (_("Unable to decompress section %s\n"),
13045 printable_section_name (section));
bc303e5d 13046 /* FIXME: Print the section anyway ? */
32ec8896 13047 return FALSE;
f055032e
NC		 13048 }
13049 }
bc303e5d
NC		 13050 else
13051 start = real_start;
0e602686 13052 }
14ae95f2 13053
cf13d699
NC		 13054 if (relocate)
13055 {
32ec8896
NC		 13056 if (! apply_relocations (file, section, start, section_size, NULL, NULL))
13057 return FALSE;
cf13d699
NC		 13058 }
13059 else
13060 {
13061 /* If the section being dumped has relocations against it the user might
13062 be expecting these relocations to have been applied. Check for this
13063 case and issue a warning message in order to avoid confusion.
13064 FIXME: Maybe we ought to have an option that dumps a section with
13065 relocs applied ? */
13066 for (relsec = section_headers;
13067 relsec < section_headers + elf_header.e_shnum;
13068 ++relsec)
13069 {
13070 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13071 || relsec->sh_info >= elf_header.e_shnum
13072 || section_headers + relsec->sh_info != section
13073 || relsec->sh_size == 0
13074 || relsec->sh_link >= elf_header.e_shnum)
13075 continue;
13076
13077 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13078 break;
13079 }
13080 }
13081
13082 addr = section->sh_addr;
0e602686 13083 bytes = section_size;
cf13d699
NC		 13084 data = start;
13085
13086 while (bytes)
13087 {
13088 int j;
13089 int k;
13090 int lbytes;
13091
13092 lbytes = (bytes > 16 ? 16 : bytes);
13093
13094 printf (" 0x%8.8lx ", (unsigned long) addr);
13095
13096 for (j = 0; j < 16; j++)
13097 {
13098 if (j < lbytes)
13099 printf ("%2.2x", data[j]);
13100 else
13101 printf (" ");
13102
13103 if ((j & 3) == 3)
13104 printf (" ");
13105 }
13106
13107 for (j = 0; j < lbytes; j++)
13108 {
13109 k = data[j];
13110 if (k >= ' ' && k < 0x7f)
13111 printf ("%c", k);
13112 else
13113 printf (".");
13114 }
13115
13116 putchar ('\n');
13117
13118 data += lbytes;
13119 addr += lbytes;
13120 bytes -= lbytes;
13121 }
13122
0e602686 13123 free (real_start);
cf13d699
NC		 13124
13125 putchar ('\n');
32ec8896 13126 return TRUE;
cf13d699
NC		 13127}
13128
32ec8896 13129static bfd_boolean
d966045b 13130load_specific_debug_section (enum dwarf_section_display_enum debug,
0d2a7a93 13131 const Elf_Internal_Shdr * sec, void * file)
1007acb3 13132{
2cf0635d 13133 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 13134 char buf [64];
1007acb3 13135
19e6b90e
L		 13136 /* If it is already loaded, do nothing. */
13137 if (section->start != NULL)
32ec8896 13138 return TRUE;
1007acb3 13139
19e6b90e
L		 13140 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
13141 section->address = sec->sh_addr;
06614111 13142 section->user_data = NULL;
3f5e193b
NC		 13143 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
13144 sec->sh_offset, 1,
13145 sec->sh_size, buf);
59245841
NC		 13146 if (section->start == NULL)
13147 section->size = 0;
13148 else
13149 {
77115a4a
L		 13150 unsigned char *start = section->start;
13151 dwarf_size_type size = sec->sh_size;
dab394de 13152 dwarf_size_type uncompressed_size = 0;
77115a4a
L		 13153
13154 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
13155 {
13156 Elf_Internal_Chdr chdr;
d8024a91
NC		 13157 unsigned int compression_header_size;
13158
f53be977
L		 13159 if (size < (is_32bit_elf
13160 ? sizeof (Elf32_External_Chdr)
13161 : sizeof (Elf64_External_Chdr)))
d8024a91
NC		 13162 {
13163 warn (_("compressed section %s is too small to contain a compression header"),
13164 section->name);
32ec8896 13165 return FALSE;
d8024a91
NC		 13166 }
13167
ebdf1ebf 13168 compression_header_size = get_compression_header (&chdr, start, size);
d8024a91 13169
813dabb9
L		 13170 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13171 {
13172 warn (_("section '%s' has unsupported compress type: %d\n"),
13173 section->name, chdr.ch_type);
32ec8896 13174 return FALSE;
813dabb9
L		 13175 }
13176 else if (chdr.ch_addralign != sec->sh_addralign)
13177 {
13178 warn (_("compressed section '%s' is corrupted\n"),
13179 section->name);
32ec8896 13180 return FALSE;
813dabb9 13181 }
dab394de 13182 uncompressed_size = chdr.ch_size;
77115a4a
L		 13183 start += compression_header_size;
13184 size -= compression_header_size;
13185 }
dab394de
L		 13186 else if (size > 12 && streq ((char *) start, "ZLIB"))
13187 {
13188 /* Read the zlib header. In this case, it should be "ZLIB"
13189 followed by the uncompressed section size, 8 bytes in
13190 big-endian order. */
13191 uncompressed_size = start[4]; uncompressed_size <<= 8;
13192 uncompressed_size += start[5]; uncompressed_size <<= 8;
13193 uncompressed_size += start[6]; uncompressed_size <<= 8;
13194 uncompressed_size += start[7]; uncompressed_size <<= 8;
13195 uncompressed_size += start[8]; uncompressed_size <<= 8;
13196 uncompressed_size += start[9]; uncompressed_size <<= 8;
13197 uncompressed_size += start[10]; uncompressed_size <<= 8;
13198 uncompressed_size += start[11];
13199 start += 12;
13200 size -= 12;
13201 }
13202
1835f746 13203 if (uncompressed_size)
77115a4a 13204 {
1835f746
NC		 13205 if (uncompress_section_contents (&start, uncompressed_size,
13206 &size))
13207 {
13208 /* Free the compressed buffer, update the section buffer
13209 and the section size if uncompress is successful. */
13210 free (section->start);
13211 section->start = start;
13212 }
13213 else
13214 {
13215 error (_("Unable to decompress section %s\n"),
13216 printable_section_name (sec));
32ec8896 13217 return FALSE;
1835f746 13218 }
77115a4a 13219 }
bc303e5d 13220
77115a4a 13221 section->size = size;
59245841 13222 }
4a114e3e 13223
1b315056 13224 if (section->start == NULL)
32ec8896 13225 return FALSE;
1b315056 13226
19e6b90e 13227 if (debug_displays [debug].relocate)
32ec8896
NC		 13228 {
13229 if (! apply_relocations ((FILE *) file, sec, section->start, section->size,
13230 & section->reloc_info, & section->num_relocs))
13231 return FALSE;
13232 }
d1c4b12b
NC		 13233 else
13234 {
13235 section->reloc_info = NULL;
13236 section->num_relocs = 0;
13237 }
1007acb3 13238
32ec8896 13239 return TRUE;
1007acb3
L		 13240}
13241
657d0d47
CC		 13242/* If this is not NULL, load_debug_section will only look for sections
13243 within the list of sections given here. */
32ec8896 13244static unsigned int * section_subset = NULL;
657d0d47 13245
32ec8896 13246bfd_boolean
2cf0635d 13247load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 13248{
2cf0635d
NC		 13249 struct dwarf_section * section = &debug_displays [debug].section;
13250 Elf_Internal_Shdr * sec;
d966045b
DJ		 13251
13252 /* Locate the debug section. */
657d0d47 13253 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 13254 if (sec != NULL)
13255 section->name = section->uncompressed_name;
13256 else
13257 {
657d0d47 13258 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 13259 if (sec != NULL)
13260 section->name = section->compressed_name;
13261 }
13262 if (sec == NULL)
32ec8896 13263 return FALSE;
d966045b 13264
657d0d47
CC		 13265 /* If we're loading from a subset of sections, and we've loaded
13266 a section matching this name before, it's likely that it's a
13267 different one. */
13268 if (section_subset != NULL)
13269 free_debug_section (debug);
13270
3f5e193b 13271 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 13272}
13273
19e6b90e
L		 13274void
13275free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 13276{
2cf0635d 13277 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 13278
19e6b90e
L		 13279 if (section->start == NULL)
13280 return;
1007acb3 13281
19e6b90e
L		 13282 free ((char *) section->start);
13283 section->start = NULL;
13284 section->address = 0;
13285 section->size = 0;
1007acb3
L		 13286}
13287
32ec8896 13288static bfd_boolean
657d0d47 13289display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 13290{
2cf0635d 13291 char * name = SECTION_NAME (section);
74e1a04b 13292 const char * print_name = printable_section_name (section);
19e6b90e 13293 bfd_size_type length;
32ec8896 13294 bfd_boolean result = TRUE;
3f5e193b 13295 int i;
1007acb3 13296
19e6b90e
L		 13297 length = section->sh_size;
13298 if (length == 0)
1007acb3 13299 {
74e1a04b 13300 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
32ec8896 13301 return TRUE;
1007acb3 13302 }
5dff79d8
NC		 13303 if (section->sh_type == SHT_NOBITS)
13304 {
13305 /* There is no point in dumping the contents of a debugging section
13306 which has the NOBITS type - the bits in the file will be random.
13307 This can happen when a file containing a .eh_frame section is
13308 stripped with the --only-keep-debug command line option. */
74e1a04b
NC		 13309 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13310 print_name);
32ec8896 13311 return FALSE;
5dff79d8 13312 }
1007acb3 13313
0112cd26 13314 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 13315 name = ".debug_info";
1007acb3 13316
19e6b90e
L		 13317 /* See if we know how to display the contents of this section. */
13318 for (i = 0; i < max; i++)
1b315056 13319 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 13320 || (i == line && const_strneq (name, ".debug_line."))
1b315056 13321 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 13322 {
2cf0635d 13323 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 13324 int secondary = (section != find_section (name));
13325
13326 if (secondary)
3f5e193b 13327 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 13328
b40bf0a2
NC		 13329 if (i == line && const_strneq (name, ".debug_line."))
13330 sec->name = name;
13331 else if (streq (sec->uncompressed_name, name))
d966045b
DJ		 13332 sec->name = sec->uncompressed_name;
13333 else
13334 sec->name = sec->compressed_name;
3f5e193b
NC		 13335 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
13336 section, file))
19e6b90e 13337 {
657d0d47
CC		 13338 /* If this debug section is part of a CU/TU set in a .dwp file,
13339 restrict load_debug_section to the sections in that set. */
13340 section_subset = find_cu_tu_set (file, shndx);
13341
19e6b90e 13342 result &= debug_displays[i].display (sec, file);
1007acb3 13343
657d0d47
CC		 13344 section_subset = NULL;
13345
d966045b 13346 if (secondary || (i != info && i != abbrev))
3f5e193b 13347 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 13348 }
1007acb3 13349
19e6b90e
L		 13350 break;
13351 }
1007acb3 13352
19e6b90e 13353 if (i == max)
1007acb3 13354 {
74e1a04b 13355 printf (_("Unrecognized debug section: %s\n"), print_name);
32ec8896 13356 result = FALSE;
1007acb3
L		 13357 }
13358
19e6b90e 13359 return result;
5b18a4bc 13360}
103f02d3 13361
aef1f6d0
DJ		 13362/* Set DUMP_SECTS for all sections where dumps were requested
13363 based on section name. */
13364
13365static void
13366initialise_dumps_byname (void)
13367{
2cf0635d 13368 struct dump_list_entry * cur;
aef1f6d0
DJ		 13369
13370 for (cur = dump_sects_byname; cur; cur = cur->next)
13371 {
13372 unsigned int i;
32ec8896 13373 bfd_boolean any = FALSE;
aef1f6d0 13374
32ec8896 13375 for (i = 0; i < elf_header.e_shnum; i++)
aef1f6d0
DJ		 13376 if (streq (SECTION_NAME (section_headers + i), cur->name))
13377 {
09c11c86 13378 request_dump_bynumber (i, cur->type);
32ec8896 13379 any = TRUE;
aef1f6d0
DJ		 13380 }
13381
13382 if (!any)
13383 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13384 cur->name);
13385 }
13386}
13387
32ec8896 13388static bfd_boolean
2cf0635d 13389process_section_contents (FILE * file)
5b18a4bc 13390{
2cf0635d 13391 Elf_Internal_Shdr * section;
19e6b90e 13392 unsigned int i;
32ec8896 13393 bfd_boolean res = TRUE;
103f02d3 13394
19e6b90e 13395 if (! do_dump)
32ec8896 13396 return TRUE;
103f02d3 13397
aef1f6d0
DJ		 13398 initialise_dumps_byname ();
13399
19e6b90e
L		 13400 for (i = 0, section = section_headers;
13401 i < elf_header.e_shnum && i < num_dump_sects;
13402 i++, section++)
13403 {
13404#ifdef SUPPORT_DISASSEMBLY
13405 if (dump_sects[i] & DISASS_DUMP)
13406 disassemble_section (section, file);
13407#endif
13408 if (dump_sects[i] & HEX_DUMP)
32ec8896
NC		 13409 {
13410 if (! dump_section_as_bytes (section, file, FALSE))
13411 res = FALSE;
13412 }
103f02d3 13413
cf13d699 13414 if (dump_sects[i] & RELOC_DUMP)
32ec8896
NC		 13415 {
13416 if (! dump_section_as_bytes (section, file, TRUE))
13417 res = FALSE;
13418 }
09c11c86
NC		 13419
13420 if (dump_sects[i] & STRING_DUMP)
32ec8896
NC		 13421 {
13422 if (! dump_section_as_strings (section, file))
13423 res = FALSE;
13424 }
cf13d699
NC		 13425
13426 if (dump_sects[i] & DEBUG_DUMP)
32ec8896
NC		 13427 {
13428 if (! display_debug_section (i, section, file))
13429 res = FALSE;
13430 }
5b18a4bc 13431 }
103f02d3 13432
19e6b90e
L		 13433 /* Check to see if the user requested a
13434 dump of a section that does not exist. */
0ee3043f
NC		 13435 while (i < num_dump_sects)
13436 {
13437 if (dump_sects[i])
32ec8896
NC		 13438 {
13439 warn (_("Section %d was not dumped because it does not exist!\n"), i);
13440 res = FALSE;
13441 }
0ee3043f
NC		 13442 i++;
13443 }
32ec8896
NC		 13444
13445 return res;
5b18a4bc 13446}
103f02d3 13447
5b18a4bc 13448static void
19e6b90e 13449process_mips_fpe_exception (int mask)
5b18a4bc 13450{
19e6b90e
L		 13451 if (mask)
13452 {
32ec8896
NC		 13453 bfd_boolean first = TRUE;
13454
19e6b90e 13455 if (mask & OEX_FPU_INEX)
32ec8896 13456 fputs ("INEX", stdout), first = FALSE;
19e6b90e 13457 if (mask & OEX_FPU_UFLO)
32ec8896 13458 printf ("%sUFLO", first ? "" : "|"), first = FALSE;
19e6b90e 13459 if (mask & OEX_FPU_OFLO)
32ec8896 13460 printf ("%sOFLO", first ? "" : "|"), first = FALSE;
19e6b90e 13461 if (mask & OEX_FPU_DIV0)
32ec8896 13462 printf ("%sDIV0", first ? "" : "|"), first = FALSE;
19e6b90e
L		 13463 if (mask & OEX_FPU_INVAL)
13464 printf ("%sINVAL", first ? "" : "|");
13465 }
5b18a4bc 13466 else
19e6b90e 13467 fputs ("0", stdout);
5b18a4bc 13468}
103f02d3 13469
f6f0e17b
NC		 13470/* Display's the value of TAG at location P. If TAG is
13471 greater than 0 it is assumed to be an unknown tag, and
13472 a message is printed to this effect. Otherwise it is
13473 assumed that a message has already been printed.
13474
13475 If the bottom bit of TAG is set it assumed to have a
13476 string value, otherwise it is assumed to have an integer
13477 value.
13478
13479 Returns an updated P pointing to the first unread byte
13480 beyond the end of TAG's value.
13481
13482 Reads at or beyond END will not be made. */
13483
13484static unsigned char *
60abdbed 13485display_tag_value (signed int tag,
f6f0e17b
NC		 13486 unsigned char * p,
13487 const unsigned char * const end)
13488{
13489 unsigned long val;
13490
13491 if (tag > 0)
13492 printf (" Tag_unknown_%d: ", tag);
13493
13494 if (p >= end)
13495 {
4082ef84 13496 warn (_("<corrupt tag>\n"));
f6f0e17b
NC		 13497 }
13498 else if (tag & 1)
13499 {
071436c6
NC		 13500 /* PR 17531 file: 027-19978-0.004. */
13501 size_t maxlen = (end - p) - 1;
13502
13503 putchar ('"');
4082ef84
NC		 13504 if (maxlen > 0)
13505 {
13506 print_symbol ((int) maxlen, (const char *) p);
13507 p += strnlen ((char *) p, maxlen) + 1;
13508 }
13509 else
13510 {
13511 printf (_("<corrupt string tag>"));
13512 p = (unsigned char *) end;
13513 }
071436c6 13514 printf ("\"\n");
f6f0e17b
NC		 13515 }
13516 else
13517 {
13518 unsigned int len;
13519
13520 val = read_uleb128 (p, &len, end);
13521 p += len;
13522 printf ("%ld (0x%lx)\n", val, val);
13523 }
13524
4082ef84 13525 assert (p <= end);
f6f0e17b
NC		 13526 return p;
13527}
13528
53a346d8
CZ		 13529/* ARC ABI attributes section. */
13530
13531static unsigned char *
13532display_arc_attribute (unsigned char * p,
13533 const unsigned char * const end)
13534{
13535 unsigned int tag;
13536 unsigned int len;
13537 unsigned int val;
13538
13539 tag = read_uleb128 (p, &len, end);
13540 p += len;
13541
13542 switch (tag)
13543 {
13544 case Tag_ARC_PCS_config:
13545 val = read_uleb128 (p, &len, end);
13546 p += len;
13547 printf (" Tag_ARC_PCS_config: ");
13548 switch (val)
13549 {
13550 case 0:
13551 printf (_("Absent/Non standard\n"));
13552 break;
13553 case 1:
13554 printf (_("Bare metal/mwdt\n"));
13555 break;
13556 case 2:
13557 printf (_("Bare metal/newlib\n"));
13558 break;
13559 case 3:
13560 printf (_("Linux/uclibc\n"));
13561 break;
13562 case 4:
13563 printf (_("Linux/glibc\n"));
13564 break;
13565 default:
13566 printf (_("Unknown\n"));
13567 break;
13568 }
13569 break;
13570
13571 case Tag_ARC_CPU_base:
13572 val = read_uleb128 (p, &len, end);
13573 p += len;
13574 printf (" Tag_ARC_CPU_base: ");
13575 switch (val)
13576 {
13577 default:
13578 case TAG_CPU_NONE:
13579 printf (_("Absent\n"));
13580 break;
13581 case TAG_CPU_ARC6xx:
13582 printf ("ARC6xx\n");
13583 break;
13584 case TAG_CPU_ARC7xx:
13585 printf ("ARC7xx\n");
13586 break;
13587 case TAG_CPU_ARCEM:
13588 printf ("ARCEM\n");
13589 break;
13590 case TAG_CPU_ARCHS:
13591 printf ("ARCHS\n");
13592 break;
13593 }
13594 break;
13595
13596 case Tag_ARC_CPU_variation:
13597 val = read_uleb128 (p, &len, end);
13598 p += len;
13599 printf (" Tag_ARC_CPU_variation: ");
13600 switch (val)
13601 {
13602 default:
13603 if (val > 0 && val < 16)
53a346d8 13604 printf ("Core%d\n", val);
d8cbc93b
JL		 13605 else
13606 printf ("Unknown\n");
13607 break;
13608
53a346d8
CZ		 13609 case 0:
13610 printf (_("Absent\n"));
13611 break;
13612 }
13613 break;
13614
13615 case Tag_ARC_CPU_name:
13616 printf (" Tag_ARC_CPU_name: ");
13617 p = display_tag_value (-1, p, end);
13618 break;
13619
13620 case Tag_ARC_ABI_rf16:
13621 val = read_uleb128 (p, &len, end);
13622 p += len;
13623 printf (" Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
13624 break;
13625
13626 case Tag_ARC_ABI_osver:
13627 val = read_uleb128 (p, &len, end);
13628 p += len;
13629 printf (" Tag_ARC_ABI_osver: v%d\n", val);
13630 break;
13631
13632 case Tag_ARC_ABI_pic:
13633 case Tag_ARC_ABI_sda:
13634 val = read_uleb128 (p, &len, end);
13635 p += len;
13636 printf (tag == Tag_ARC_ABI_sda ? " Tag_ARC_ABI_sda: "
13637 : " Tag_ARC_ABI_pic: ");
13638 switch (val)
13639 {
13640 case 0:
13641 printf (_("Absent\n"));
13642 break;
13643 case 1:
13644 printf ("MWDT\n");
13645 break;
13646 case 2:
13647 printf ("GNU\n");
13648 break;
13649 default:
13650 printf (_("Unknown\n"));
13651 break;
13652 }
13653 break;
13654
13655 case Tag_ARC_ABI_tls:
13656 val = read_uleb128 (p, &len, end);
13657 p += len;
13658 printf (" Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
13659 break;
13660
13661 case Tag_ARC_ABI_enumsize:
13662 val = read_uleb128 (p, &len, end);
13663 p += len;
13664 printf (" Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
13665 _("smallest"));
13666 break;
13667
13668 case Tag_ARC_ABI_exceptions:
13669 val = read_uleb128 (p, &len, end);
13670 p += len;
13671 printf (" Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
13672 : _("default"));
13673 break;
13674
13675 case Tag_ARC_ABI_double_size:
13676 val = read_uleb128 (p, &len, end);
13677 p += len;
13678 printf (" Tag_ARC_ABI_double_size: %d\n", val);
13679 break;
13680
13681 case Tag_ARC_ISA_config:
13682 printf (" Tag_ARC_ISA_config: ");
13683 p = display_tag_value (-1, p, end);
13684 break;
13685
13686 case Tag_ARC_ISA_apex:
13687 printf (" Tag_ARC_ISA_apex: ");
13688 p = display_tag_value (-1, p, end);
13689 break;
13690
13691 case Tag_ARC_ISA_mpy_option:
13692 val = read_uleb128 (p, &len, end);
13693 p += len;
13694 printf (" Tag_ARC_ISA_mpy_option: %d\n", val);
13695 break;
13696
13697 default:
13698 return display_tag_value (tag & 1, p, end);
13699 }
13700
13701 return p;
13702}
13703
11c1ff18
PB		 13704/* ARM EABI attributes section. */
13705typedef struct
13706{
70e99720 13707 unsigned int tag;
2cf0635d 13708 const char * name;
11c1ff18 13709 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
70e99720 13710 unsigned int type;
2cf0635d 13711 const char ** table;
11c1ff18
PB		 13712} arm_attr_public_tag;
13713
2cf0635d 13714static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 13715 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
ced40572 13716 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
ff8646ee 13717 "v8-M.mainline"};
2cf0635d
NC		 13718static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
13719static const char * arm_attr_tag_THUMB_ISA_use[] =
4ed7ed8d 13720 {"No", "Thumb-1", "Thumb-2", "Yes"};
75375b3e 13721static const char * arm_attr_tag_FP_arch[] =
bca38921 13722 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
a715796b 13723 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
2cf0635d 13724static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 13725static const char * arm_attr_tag_Advanced_SIMD_arch[] =
9411fd44
MW		 13726 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13727 "NEON for ARMv8.1"};
2cf0635d 13728static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 13729 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13730 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 13731static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 13732 {"V6", "SB", "TLS", "Unused"};
2cf0635d 13733static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 13734 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 13735static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 13736 {"Absolute", "PC-relative", "None"};
2cf0635d 13737static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 13738 {"None", "direct", "GOT-indirect"};
2cf0635d 13739static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 13740 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 13741static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
13742static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 13743 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 13744static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
13745static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
13746static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 13747 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 13748static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 13749 {"Unused", "small", "int", "forced to int"};
2cf0635d 13750static const char * arm_attr_tag_ABI_HardFP_use[] =
99654aaf 13751 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
2cf0635d 13752static const char * arm_attr_tag_ABI_VFP_args[] =
5c294fee 13753 {"AAPCS", "VFP registers", "custom", "compatible"};
2cf0635d 13754static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 13755 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 13756static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 13757 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13758 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 13759static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 13760 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13761 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 13762static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 13763static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 13764 {"Not Allowed", "Allowed"};
2cf0635d 13765static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 13766 {"None", "IEEE 754", "Alternative Format"};
15afaa63
TP		 13767static const char * arm_attr_tag_DSP_extension[] =
13768 {"Follow architecture", "Allowed"};
dd24e3da 13769static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 13770 {"Not Allowed", "Allowed"};
13771static const char * arm_attr_tag_DIV_use[] =
dd24e3da 13772 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 13773 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 13774static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
13775static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 13776 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 13777 "TrustZone and Virtualization Extensions"};
dd24e3da 13778static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 13779 {"Not Allowed", "Allowed"};
11c1ff18
PB		 13780
13781#define LOOKUP(id, name) \
13782 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 13783static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 13784{
13785 {4, "CPU_raw_name", 1, NULL},
13786 {5, "CPU_name", 1, NULL},
13787 LOOKUP(6, CPU_arch),
13788 {7, "CPU_arch_profile", 0, NULL},
13789 LOOKUP(8, ARM_ISA_use),
13790 LOOKUP(9, THUMB_ISA_use),
75375b3e 13791 LOOKUP(10, FP_arch),
11c1ff18 13792 LOOKUP(11, WMMX_arch),
f5f53991
AS		 13793 LOOKUP(12, Advanced_SIMD_arch),
13794 LOOKUP(13, PCS_config),
11c1ff18
PB		 13795 LOOKUP(14, ABI_PCS_R9_use),
13796 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 13797 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 13798 LOOKUP(17, ABI_PCS_GOT_use),
13799 LOOKUP(18, ABI_PCS_wchar_t),
13800 LOOKUP(19, ABI_FP_rounding),
13801 LOOKUP(20, ABI_FP_denormal),
13802 LOOKUP(21, ABI_FP_exceptions),
13803 LOOKUP(22, ABI_FP_user_exceptions),
13804 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 13805 {24, "ABI_align_needed", 0, NULL},
13806 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 13807 LOOKUP(26, ABI_enum_size),
13808 LOOKUP(27, ABI_HardFP_use),
13809 LOOKUP(28, ABI_VFP_args),
13810 LOOKUP(29, ABI_WMMX_args),
13811 LOOKUP(30, ABI_optimization_goals),
13812 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 13813 {32, "compatibility", 0, NULL},
f5f53991 13814 LOOKUP(34, CPU_unaligned_access),
75375b3e 13815 LOOKUP(36, FP_HP_extension),
8e79c3df 13816 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 13817 LOOKUP(42, MPextension_use),
13818 LOOKUP(44, DIV_use),
15afaa63 13819 LOOKUP(46, DSP_extension),
f5f53991
AS		 13820 {64, "nodefaults", 0, NULL},
13821 {65, "also_compatible_with", 0, NULL},
13822 LOOKUP(66, T2EE_use),
13823 {67, "conformance", 1, NULL},
13824 LOOKUP(68, Virtualization_use),
cd21e546 13825 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 13826};
13827#undef LOOKUP
13828
11c1ff18 13829static unsigned char *
f6f0e17b
NC		 13830display_arm_attribute (unsigned char * p,
13831 const unsigned char * const end)
11c1ff18 13832{
70e99720 13833 unsigned int tag;
11c1ff18 13834 unsigned int len;
70e99720 13835 unsigned int val;
2cf0635d 13836 arm_attr_public_tag * attr;
11c1ff18 13837 unsigned i;
70e99720 13838 unsigned int type;
11c1ff18 13839
f6f0e17b 13840 tag = read_uleb128 (p, &len, end);
11c1ff18
PB		 13841 p += len;
13842 attr = NULL;
2cf0635d 13843 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 13844 {
13845 if (arm_attr_public_tags[i].tag == tag)
13846 {
13847 attr = &arm_attr_public_tags[i];
13848 break;
13849 }
13850 }
13851
13852 if (attr)
13853 {
13854 printf (" Tag_%s: ", attr->name);
13855 switch (attr->type)
13856 {
13857 case 0:
13858 switch (tag)
13859 {
13860 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 13861 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 13862 p += len;
13863 switch (val)
13864 {
2b692964
NC		 13865 case 0: printf (_("None\n")); break;
13866 case 'A': printf (_("Application\n")); break;
13867 case 'R': printf (_("Realtime\n")); break;
13868 case 'M': printf (_("Microcontroller\n")); break;
13869 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 13870 default: printf ("??? (%d)\n", val); break;
13871 }
13872 break;
13873
75375b3e 13874 case 24: /* Tag_align_needed. */
f6f0e17b 13875 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 13876 p += len;
13877 switch (val)
13878 {
2b692964
NC		 13879 case 0: printf (_("None\n")); break;
13880 case 1: printf (_("8-byte\n")); break;
13881 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 13882 case 3: printf ("??? 3\n"); break;
13883 default:
13884 if (val <= 12)
dd24e3da 13885 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 13886 1 << val);
13887 else
13888 printf ("??? (%d)\n", val);
13889 break;
13890 }
13891 break;
13892
13893 case 25: /* Tag_align_preserved. */
f6f0e17b 13894 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 13895 p += len;
13896 switch (val)
13897 {
2b692964
NC		 13898 case 0: printf (_("None\n")); break;
13899 case 1: printf (_("8-byte, except leaf SP\n")); break;
13900 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 13901 case 3: printf ("??? 3\n"); break;
13902 default:
13903 if (val <= 12)
dd24e3da 13904 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 13905 1 << val);
13906 else
13907 printf ("??? (%d)\n", val);
13908 break;
13909 }
13910 break;
13911
11c1ff18 13912 case 32: /* Tag_compatibility. */
071436c6 13913 {
071436c6
NC		 13914 val = read_uleb128 (p, &len, end);
13915 p += len;
071436c6 13916 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 13917 if (p < end - 1)
13918 {
13919 size_t maxlen = (end - p) - 1;
13920
13921 print_symbol ((int) maxlen, (const char *) p);
13922 p += strnlen ((char *) p, maxlen) + 1;
13923 }
13924 else
13925 {
13926 printf (_("<corrupt>"));
13927 p = (unsigned char *) end;
13928 }
071436c6 13929 putchar ('\n');
071436c6 13930 }
11c1ff18
PB		 13931 break;
13932
f5f53991 13933 case 64: /* Tag_nodefaults. */
541a3cbd
NC		 13934 /* PR 17531: file: 001-505008-0.01. */
13935 if (p < end)
13936 p++;
2b692964 13937 printf (_("True\n"));
f5f53991
AS		 13938 break;
13939
13940 case 65: /* Tag_also_compatible_with. */
f6f0e17b 13941 val = read_uleb128 (p, &len, end);
f5f53991
AS		 13942 p += len;
13943 if (val == 6 /* Tag_CPU_arch. */)
13944 {
f6f0e17b 13945 val = read_uleb128 (p, &len, end);
f5f53991 13946 p += len;
071436c6 13947 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 13948 printf ("??? (%d)\n", val);
13949 else
13950 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
13951 }
13952 else
13953 printf ("???\n");
071436c6
NC		 13954 while (p < end && *(p++) != '\0' /* NUL terminator. */)
13955 ;
f5f53991
AS		 13956 break;
13957
11c1ff18 13958 default:
bee0ee85
NC		 13959 printf (_("<unknown: %d>\n"), tag);
13960 break;
11c1ff18
PB		 13961 }
13962 return p;
13963
13964 case 1:
f6f0e17b 13965 return display_tag_value (-1, p, end);
11c1ff18 13966 case 2:
f6f0e17b 13967 return display_tag_value (0, p, end);
11c1ff18
PB		 13968
13969 default:
13970 assert (attr->type & 0x80);
f6f0e17b 13971 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 13972 p += len;
13973 type = attr->type & 0x7f;
13974 if (val >= type)
13975 printf ("??? (%d)\n", val);
13976 else
13977 printf ("%s\n", attr->table[val]);
13978 return p;
13979 }
13980 }
11c1ff18 13981
f6f0e17b 13982 return display_tag_value (tag, p, end);
11c1ff18
PB		 13983}
13984
104d59d1 13985static unsigned char *
60bca95a 13986display_gnu_attribute (unsigned char * p,
60abdbed 13987 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
f6f0e17b 13988 const unsigned char * const end)
104d59d1
JM		 13989{
13990 int tag;
13991 unsigned int len;
60abdbed 13992 unsigned int val;
104d59d1 13993
f6f0e17b 13994 tag = read_uleb128 (p, &len, end);
104d59d1
JM		 13995 p += len;
13996
13997 /* Tag_compatibility is the only generic GNU attribute defined at
13998 present. */
13999 if (tag == 32)
14000 {
f6f0e17b 14001 val = read_uleb128 (p, &len, end);
104d59d1 14002 p += len;
071436c6
NC		 14003
14004 printf (_("flag = %d, vendor = "), val);
f6f0e17b
NC		 14005 if (p == end)
14006 {
071436c6 14007 printf (_("<corrupt>\n"));
f6f0e17b
NC		 14008 warn (_("corrupt vendor attribute\n"));
14009 }
14010 else
14011 {
4082ef84
NC		 14012 if (p < end - 1)
14013 {
14014 size_t maxlen = (end - p) - 1;
071436c6 14015
4082ef84
NC		 14016 print_symbol ((int) maxlen, (const char *) p);
14017 p += strnlen ((char *) p, maxlen) + 1;
14018 }
14019 else
14020 {
14021 printf (_("<corrupt>"));
14022 p = (unsigned char *) end;
14023 }
071436c6 14024 putchar ('\n');
f6f0e17b 14025 }
104d59d1
JM		 14026 return p;
14027 }
14028
14029 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 14030 return display_proc_gnu_attribute (p, tag, end);
104d59d1 14031
f6f0e17b 14032 return display_tag_value (tag, p, end);
104d59d1
JM		 14033}
14034
34c8bcba 14035static unsigned char *
f6f0e17b 14036display_power_gnu_attribute (unsigned char * p,
60abdbed 14037 unsigned int tag,
f6f0e17b 14038 const unsigned char * const end)
34c8bcba 14039{
34c8bcba 14040 unsigned int len;
005d79fd 14041 unsigned int val;
34c8bcba
JM		 14042
14043 if (tag == Tag_GNU_Power_ABI_FP)
14044 {
f6f0e17b 14045 val = read_uleb128 (p, &len, end);
34c8bcba
JM		 14046 p += len;
14047 printf (" Tag_GNU_Power_ABI_FP: ");
005d79fd
AM		 14048 if (len == 0)
14049 {
14050 printf (_("<corrupt>\n"));
14051 return p;
14052 }
60bca95a 14053
005d79fd
AM		 14054 if (val > 15)
14055 printf ("(%#x), ", val);
14056
14057 switch (val & 3)
34c8bcba
JM		 14058 {
14059 case 0:
005d79fd 14060 printf (_("unspecified hard/soft float, "));
34c8bcba
JM		 14061 break;
14062 case 1:
005d79fd 14063 printf (_("hard float, "));
34c8bcba
JM		 14064 break;
14065 case 2:
005d79fd 14066 printf (_("soft float, "));
34c8bcba 14067 break;
3c7b9897 14068 case 3:
005d79fd 14069 printf (_("single-precision hard float, "));
3c7b9897 14070 break;
005d79fd
AM		 14071 }
14072
14073 switch (val & 0xC)
14074 {
14075 case 0:
14076 printf (_("unspecified long double\n"));
14077 break;
14078 case 4:
14079 printf (_("128-bit IBM long double\n"));
14080 break;
14081 case 8:
14082 printf (_("64-bit long double\n"));
14083 break;
14084 case 12:
14085 printf (_("128-bit IEEE long double\n"));
34c8bcba
JM		 14086 break;
14087 }
14088 return p;
005d79fd 14089 }
34c8bcba 14090
c6e65352
DJ		 14091 if (tag == Tag_GNU_Power_ABI_Vector)
14092 {
f6f0e17b 14093 val = read_uleb128 (p, &len, end);
c6e65352
DJ		 14094 p += len;
14095 printf (" Tag_GNU_Power_ABI_Vector: ");
005d79fd
AM		 14096 if (len == 0)
14097 {
14098 printf (_("<corrupt>\n"));
14099 return p;
14100 }
14101
14102 if (val > 3)
14103 printf ("(%#x), ", val);
14104
14105 switch (val & 3)
c6e65352
DJ		 14106 {
14107 case 0:
005d79fd 14108 printf (_("unspecified\n"));
c6e65352
DJ		 14109 break;
14110 case 1:
005d79fd 14111 printf (_("generic\n"));
c6e65352
DJ		 14112 break;
14113 case 2:
14114 printf ("AltiVec\n");
14115 break;
14116 case 3:
14117 printf ("SPE\n");
14118 break;
c6e65352
DJ		 14119 }
14120 return p;
005d79fd 14121 }
c6e65352 14122
f82e0623
NF		 14123 if (tag == Tag_GNU_Power_ABI_Struct_Return)
14124 {
005d79fd
AM		 14125 val = read_uleb128 (p, &len, end);
14126 p += len;
14127 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
14128 if (len == 0)
f6f0e17b 14129 {
005d79fd 14130 printf (_("<corrupt>\n"));
f6f0e17b
NC		 14131 return p;
14132 }
0b4362b0 14133
005d79fd
AM		 14134 if (val > 2)
14135 printf ("(%#x), ", val);
14136
14137 switch (val & 3)
14138 {
14139 case 0:
14140 printf (_("unspecified\n"));
14141 break;
14142 case 1:
14143 printf ("r3/r4\n");
14144 break;
14145 case 2:
14146 printf (_("memory\n"));
14147 break;
14148 case 3:
14149 printf ("???\n");
14150 break;
14151 }
f82e0623
NF		 14152 return p;
14153 }
14154
f6f0e17b 14155 return display_tag_value (tag & 1, p, end);
34c8bcba
JM		 14156}
14157
643f7afb
AK		 14158static unsigned char *
14159display_s390_gnu_attribute (unsigned char * p,
60abdbed 14160 unsigned int tag,
643f7afb
AK		 14161 const unsigned char * const end)
14162{
14163 unsigned int len;
14164 int val;
14165
14166 if (tag == Tag_GNU_S390_ABI_Vector)
14167 {
14168 val = read_uleb128 (p, &len, end);
14169 p += len;
14170 printf (" Tag_GNU_S390_ABI_Vector: ");
14171
14172 switch (val)
14173 {
14174 case 0:
14175 printf (_("any\n"));
14176 break;
14177 case 1:
14178 printf (_("software\n"));
14179 break;
14180 case 2:
14181 printf (_("hardware\n"));
14182 break;
14183 default:
14184 printf ("??? (%d)\n", val);
14185 break;
14186 }
14187 return p;
14188 }
14189
14190 return display_tag_value (tag & 1, p, end);
14191}
14192
9e8c70f9 14193static void
60abdbed 14194display_sparc_hwcaps (unsigned int mask)
9e8c70f9
DM		 14195{
14196 if (mask)
14197 {
32ec8896 14198 bfd_boolean first = TRUE;
071436c6 14199
9e8c70f9 14200 if (mask & ELF_SPARC_HWCAP_MUL32)
32ec8896 14201 fputs ("mul32", stdout), first = FALSE;
9e8c70f9 14202 if (mask & ELF_SPARC_HWCAP_DIV32)
32ec8896 14203 printf ("%sdiv32", first ? "" : "|"), first = FALSE;
9e8c70f9 14204 if (mask & ELF_SPARC_HWCAP_FSMULD)
32ec8896 14205 printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
9e8c70f9 14206 if (mask & ELF_SPARC_HWCAP_V8PLUS)
32ec8896 14207 printf ("%sv8plus", first ? "" : "|"), first = FALSE;
9e8c70f9 14208 if (mask & ELF_SPARC_HWCAP_POPC)
32ec8896 14209 printf ("%spopc", first ? "" : "|"), first = FALSE;
9e8c70f9 14210 if (mask & ELF_SPARC_HWCAP_VIS)
32ec8896 14211 printf ("%svis", first ? "" : "|"), first = FALSE;
9e8c70f9 14212 if (mask & ELF_SPARC_HWCAP_VIS2)
32ec8896 14213 printf ("%svis2", first ? "" : "|"), first = FALSE;
9e8c70f9 14214 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
32ec8896 14215 printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
9e8c70f9 14216 if (mask & ELF_SPARC_HWCAP_FMAF)
32ec8896 14217 printf ("%sfmaf", first ? "" : "|"), first = FALSE;
9e8c70f9 14218 if (mask & ELF_SPARC_HWCAP_VIS3)
32ec8896 14219 printf ("%svis3", first ? "" : "|"), first = FALSE;
9e8c70f9 14220 if (mask & ELF_SPARC_HWCAP_HPC)
32ec8896 14221 printf ("%shpc", first ? "" : "|"), first = FALSE;
9e8c70f9 14222 if (mask & ELF_SPARC_HWCAP_RANDOM)
32ec8896 14223 printf ("%srandom", first ? "" : "|"), first = FALSE;
9e8c70f9 14224 if (mask & ELF_SPARC_HWCAP_TRANS)
32ec8896 14225 printf ("%strans", first ? "" : "|"), first = FALSE;
9e8c70f9 14226 if (mask & ELF_SPARC_HWCAP_FJFMAU)
32ec8896 14227 printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
9e8c70f9 14228 if (mask & ELF_SPARC_HWCAP_IMA)
32ec8896 14229 printf ("%sima", first ? "" : "|"), first = FALSE;
9e8c70f9 14230 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
32ec8896 14231 printf ("%scspare", first ? "" : "|"), first = FALSE;
9e8c70f9
DM		 14232 }
14233 else
071436c6
NC		 14234 fputc ('0', stdout);
14235 fputc ('\n', stdout);
9e8c70f9
DM		 14236}
14237
3d68f91c 14238static void
60abdbed 14239display_sparc_hwcaps2 (unsigned int mask)
3d68f91c
JM		 14240{
14241 if (mask)
14242 {
32ec8896 14243 bfd_boolean first = TRUE;
071436c6 14244
3d68f91c 14245 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
32ec8896 14246 fputs ("fjathplus", stdout), first = FALSE;
3d68f91c 14247 if (mask & ELF_SPARC_HWCAP2_VIS3B)
32ec8896 14248 printf ("%svis3b", first ? "" : "|"), first = FALSE;
3d68f91c 14249 if (mask & ELF_SPARC_HWCAP2_ADP)
32ec8896 14250 printf ("%sadp", first ? "" : "|"), first = FALSE;
3d68f91c 14251 if (mask & ELF_SPARC_HWCAP2_SPARC5)
32ec8896 14252 printf ("%ssparc5", first ? "" : "|"), first = FALSE;
3d68f91c 14253 if (mask & ELF_SPARC_HWCAP2_MWAIT)
32ec8896 14254 printf ("%smwait", first ? "" : "|"), first = FALSE;
3d68f91c 14255 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
32ec8896 14256 printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
3d68f91c 14257 if (mask & ELF_SPARC_HWCAP2_XMONT)
32ec8896 14258 printf ("%sxmont2", first ? "" : "|"), first = FALSE;
3d68f91c 14259 if (mask & ELF_SPARC_HWCAP2_NSEC)
32ec8896 14260 printf ("%snsec", first ? "" : "|"), first = FALSE;
3d68f91c 14261 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
32ec8896 14262 printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
3d68f91c 14263 if (mask & ELF_SPARC_HWCAP2_FJDES)
32ec8896 14264 printf ("%sfjdes", first ? "" : "|"), first = FALSE;
3d68f91c 14265 if (mask & ELF_SPARC_HWCAP2_FJAES)
32ec8896 14266 printf ("%sfjaes", first ? "" : "|"), first = FALSE;
3d68f91c
JM		 14267 }
14268 else
071436c6
NC		 14269 fputc ('0', stdout);
14270 fputc ('\n', stdout);
3d68f91c
JM		 14271}
14272
9e8c70f9 14273static unsigned char *
f6f0e17b 14274display_sparc_gnu_attribute (unsigned char * p,
60abdbed 14275 unsigned int tag,
f6f0e17b 14276 const unsigned char * const end)
9e8c70f9 14277{
3d68f91c
JM		 14278 unsigned int len;
14279 int val;
14280
9e8c70f9
DM		 14281 if (tag == Tag_GNU_Sparc_HWCAPS)
14282 {
f6f0e17b 14283 val = read_uleb128 (p, &len, end);
9e8c70f9
DM		 14284 p += len;
14285 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM		 14286 display_sparc_hwcaps (val);
14287 return p;
3d68f91c
JM		 14288 }
14289 if (tag == Tag_GNU_Sparc_HWCAPS2)
14290 {
14291 val = read_uleb128 (p, &len, end);
14292 p += len;
14293 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14294 display_sparc_hwcaps2 (val);
14295 return p;
14296 }
9e8c70f9 14297
f6f0e17b 14298 return display_tag_value (tag, p, end);
9e8c70f9
DM		 14299}
14300
351cdf24 14301static void
32ec8896 14302print_mips_fp_abi_value (unsigned int val)
351cdf24
MF		 14303{
14304 switch (val)
14305 {
14306 case Val_GNU_MIPS_ABI_FP_ANY:
14307 printf (_("Hard or soft float\n"));
14308 break;
14309 case Val_GNU_MIPS_ABI_FP_DOUBLE:
14310 printf (_("Hard float (double precision)\n"));
14311 break;
14312 case Val_GNU_MIPS_ABI_FP_SINGLE:
14313 printf (_("Hard float (single precision)\n"));
14314 break;
14315 case Val_GNU_MIPS_ABI_FP_SOFT:
14316 printf (_("Soft float\n"));
14317 break;
14318 case Val_GNU_MIPS_ABI_FP_OLD_64:
14319 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14320 break;
14321 case Val_GNU_MIPS_ABI_FP_XX:
14322 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14323 break;
14324 case Val_GNU_MIPS_ABI_FP_64:
14325 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14326 break;
14327 case Val_GNU_MIPS_ABI_FP_64A:
14328 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14329 break;
3350cc01
CM		 14330 case Val_GNU_MIPS_ABI_FP_NAN2008:
14331 printf (_("NaN 2008 compatibility\n"));
14332 break;
351cdf24
MF		 14333 default:
14334 printf ("??? (%d)\n", val);
14335 break;
14336 }
14337}
14338
2cf19d5c 14339static unsigned char *
f6f0e17b 14340display_mips_gnu_attribute (unsigned char * p,
60abdbed 14341 unsigned int tag,
f6f0e17b 14342 const unsigned char * const end)
2cf19d5c 14343{
2cf19d5c
JM		 14344 if (tag == Tag_GNU_MIPS_ABI_FP)
14345 {
f6f0e17b 14346 unsigned int len;
32ec8896 14347 unsigned int val;
f6f0e17b
NC		 14348
14349 val = read_uleb128 (p, &len, end);
2cf19d5c
JM		 14350 p += len;
14351 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 14352
351cdf24
MF		 14353 print_mips_fp_abi_value (val);
14354
2cf19d5c
JM		 14355 return p;
14356 }
14357
a9f58168
CF		 14358 if (tag == Tag_GNU_MIPS_ABI_MSA)
14359 {
14360 unsigned int len;
32ec8896 14361 unsigned int val;
a9f58168
CF		 14362
14363 val = read_uleb128 (p, &len, end);
14364 p += len;
14365 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14366
14367 switch (val)
14368 {
14369 case Val_GNU_MIPS_ABI_MSA_ANY:
14370 printf (_("Any MSA or not\n"));
14371 break;
14372 case Val_GNU_MIPS_ABI_MSA_128:
14373 printf (_("128-bit MSA\n"));
14374 break;
14375 default:
14376 printf ("??? (%d)\n", val);
14377 break;
14378 }
14379 return p;
14380 }
14381
f6f0e17b 14382 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM		 14383}
14384
59e6276b 14385static unsigned char *
f6f0e17b
NC		 14386display_tic6x_attribute (unsigned char * p,
14387 const unsigned char * const end)
59e6276b 14388{
60abdbed 14389 unsigned int tag;
59e6276b
JM		 14390 unsigned int len;
14391 int val;
14392
f6f0e17b 14393 tag = read_uleb128 (p, &len, end);
59e6276b
JM		 14394 p += len;
14395
14396 switch (tag)
14397 {
75fa6dc1 14398 case Tag_ISA:
f6f0e17b 14399 val = read_uleb128 (p, &len, end);
59e6276b 14400 p += len;
75fa6dc1 14401 printf (" Tag_ISA: ");
59e6276b
JM		 14402
14403 switch (val)
14404 {
75fa6dc1 14405 case C6XABI_Tag_ISA_none:
59e6276b
JM		 14406 printf (_("None\n"));
14407 break;
75fa6dc1 14408 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 14409 printf ("C62x\n");
14410 break;
75fa6dc1 14411 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 14412 printf ("C67x\n");
14413 break;
75fa6dc1 14414 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 14415 printf ("C67x+\n");
14416 break;
75fa6dc1 14417 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 14418 printf ("C64x\n");
14419 break;
75fa6dc1 14420 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 14421 printf ("C64x+\n");
14422 break;
75fa6dc1 14423 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 14424 printf ("C674x\n");
14425 break;
14426 default:
14427 printf ("??? (%d)\n", val);
14428 break;
14429 }
14430 return p;
14431
87779176 14432 case Tag_ABI_wchar_t:
f6f0e17b 14433 val = read_uleb128 (p, &len, end);
87779176
JM		 14434 p += len;
14435 printf (" Tag_ABI_wchar_t: ");
14436 switch (val)
14437 {
14438 case 0:
14439 printf (_("Not used\n"));
14440 break;
14441 case 1:
14442 printf (_("2 bytes\n"));
14443 break;
14444 case 2:
14445 printf (_("4 bytes\n"));
14446 break;
14447 default:
14448 printf ("??? (%d)\n", val);
14449 break;
14450 }
14451 return p;
14452
14453 case Tag_ABI_stack_align_needed:
f6f0e17b 14454 val = read_uleb128 (p, &len, end);
87779176
JM		 14455 p += len;
14456 printf (" Tag_ABI_stack_align_needed: ");
14457 switch (val)
14458 {
14459 case 0:
14460 printf (_("8-byte\n"));
14461 break;
14462 case 1:
14463 printf (_("16-byte\n"));
14464 break;
14465 default:
14466 printf ("??? (%d)\n", val);
14467 break;
14468 }
14469 return p;
14470
14471 case Tag_ABI_stack_align_preserved:
f6f0e17b 14472 val = read_uleb128 (p, &len, end);
87779176
JM		 14473 p += len;
14474 printf (" Tag_ABI_stack_align_preserved: ");
14475 switch (val)
14476 {
14477 case 0:
14478 printf (_("8-byte\n"));
14479 break;
14480 case 1:
14481 printf (_("16-byte\n"));
14482 break;
14483 default:
14484 printf ("??? (%d)\n", val);
14485 break;
14486 }
14487 return p;
14488
b5593623 14489 case Tag_ABI_DSBT:
f6f0e17b 14490 val = read_uleb128 (p, &len, end);
b5593623
JM		 14491 p += len;
14492 printf (" Tag_ABI_DSBT: ");
14493 switch (val)
14494 {
14495 case 0:
14496 printf (_("DSBT addressing not used\n"));
14497 break;
14498 case 1:
14499 printf (_("DSBT addressing used\n"));
14500 break;
14501 default:
14502 printf ("??? (%d)\n", val);
14503 break;
14504 }
14505 return p;
14506
87779176 14507 case Tag_ABI_PID:
f6f0e17b 14508 val = read_uleb128 (p, &len, end);
87779176
JM		 14509 p += len;
14510 printf (" Tag_ABI_PID: ");
14511 switch (val)
14512 {
14513 case 0:
14514 printf (_("Data addressing position-dependent\n"));
14515 break;
14516 case 1:
14517 printf (_("Data addressing position-independent, GOT near DP\n"));
14518 break;
14519 case 2:
14520 printf (_("Data addressing position-independent, GOT far from DP\n"));
14521 break;
14522 default:
14523 printf ("??? (%d)\n", val);
14524 break;
14525 }
14526 return p;
14527
14528 case Tag_ABI_PIC:
f6f0e17b 14529 val = read_uleb128 (p, &len, end);
87779176
JM		 14530 p += len;
14531 printf (" Tag_ABI_PIC: ");
14532 switch (val)
14533 {
14534 case 0:
14535 printf (_("Code addressing position-dependent\n"));
14536 break;
14537 case 1:
14538 printf (_("Code addressing position-independent\n"));
14539 break;
14540 default:
14541 printf ("??? (%d)\n", val);
14542 break;
14543 }
14544 return p;
14545
14546 case Tag_ABI_array_object_alignment:
f6f0e17b 14547 val = read_uleb128 (p, &len, end);
87779176
JM		 14548 p += len;
14549 printf (" Tag_ABI_array_object_alignment: ");
14550 switch (val)
14551 {
14552 case 0:
14553 printf (_("8-byte\n"));
14554 break;
14555 case 1:
14556 printf (_("4-byte\n"));
14557 break;
14558 case 2:
14559 printf (_("16-byte\n"));
14560 break;
14561 default:
14562 printf ("??? (%d)\n", val);
14563 break;
14564 }
14565 return p;
14566
14567 case Tag_ABI_array_object_align_expected:
f6f0e17b 14568 val = read_uleb128 (p, &len, end);
87779176
JM		 14569 p += len;
14570 printf (" Tag_ABI_array_object_align_expected: ");
14571 switch (val)
14572 {
14573 case 0:
14574 printf (_("8-byte\n"));
14575 break;
14576 case 1:
14577 printf (_("4-byte\n"));
14578 break;
14579 case 2:
14580 printf (_("16-byte\n"));
14581 break;
14582 default:
14583 printf ("??? (%d)\n", val);
14584 break;
14585 }
14586 return p;
14587
3cbd1c06 14588 case Tag_ABI_compatibility:
071436c6 14589 {
071436c6
NC		 14590 val = read_uleb128 (p, &len, end);
14591 p += len;
14592 printf (" Tag_ABI_compatibility: ");
071436c6 14593 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 14594 if (p < end - 1)
14595 {
14596 size_t maxlen = (end - p) - 1;
14597
14598 print_symbol ((int) maxlen, (const char *) p);
14599 p += strnlen ((char *) p, maxlen) + 1;
14600 }
14601 else
14602 {
14603 printf (_("<corrupt>"));
14604 p = (unsigned char *) end;
14605 }
071436c6 14606 putchar ('\n');
071436c6
NC		 14607 return p;
14608 }
87779176
JM		 14609
14610 case Tag_ABI_conformance:
071436c6 14611 {
4082ef84
NC		 14612 printf (" Tag_ABI_conformance: \"");
14613 if (p < end - 1)
14614 {
14615 size_t maxlen = (end - p) - 1;
071436c6 14616
4082ef84
NC		 14617 print_symbol ((int) maxlen, (const char *) p);
14618 p += strnlen ((char *) p, maxlen) + 1;
14619 }
14620 else
14621 {
14622 printf (_("<corrupt>"));
14623 p = (unsigned char *) end;
14624 }
071436c6 14625 printf ("\"\n");
071436c6
NC		 14626 return p;
14627 }
59e6276b
JM		 14628 }
14629
f6f0e17b
NC		 14630 return display_tag_value (tag, p, end);
14631}
59e6276b 14632
f6f0e17b 14633static void
60abdbed 14634display_raw_attribute (unsigned char * p, unsigned char const * const end)
f6f0e17b
NC		 14635{
14636 unsigned long addr = 0;
14637 size_t bytes = end - p;
14638
e0a31db1 14639 assert (end > p);
f6f0e17b 14640 while (bytes)
87779176 14641 {
f6f0e17b
NC		 14642 int j;
14643 int k;
14644 int lbytes = (bytes > 16 ? 16 : bytes);
14645
14646 printf (" 0x%8.8lx ", addr);
14647
14648 for (j = 0; j < 16; j++)
14649 {
14650 if (j < lbytes)
14651 printf ("%2.2x", p[j]);
14652 else
14653 printf (" ");
14654
14655 if ((j & 3) == 3)
14656 printf (" ");
14657 }
14658
14659 for (j = 0; j < lbytes; j++)
14660 {
14661 k = p[j];
14662 if (k >= ' ' && k < 0x7f)
14663 printf ("%c", k);
14664 else
14665 printf (".");
14666 }
14667
14668 putchar ('\n');
14669
14670 p += lbytes;
14671 bytes -= lbytes;
14672 addr += lbytes;
87779176 14673 }
59e6276b 14674
f6f0e17b 14675 putchar ('\n');
59e6276b
JM		 14676}
14677
13761a11
NC		 14678static unsigned char *
14679display_msp430x_attribute (unsigned char * p,
14680 const unsigned char * const end)
14681{
14682 unsigned int len;
60abdbed
NC		 14683 unsigned int val;
14684 unsigned int tag;
13761a11
NC		 14685
14686 tag = read_uleb128 (p, & len, end);
14687 p += len;
0b4362b0 14688
13761a11
NC		 14689 switch (tag)
14690 {
14691 case OFBA_MSPABI_Tag_ISA:
14692 val = read_uleb128 (p, &len, end);
14693 p += len;
14694 printf (" Tag_ISA: ");
14695 switch (val)
14696 {
14697 case 0: printf (_("None\n")); break;
14698 case 1: printf (_("MSP430\n")); break;
14699 case 2: printf (_("MSP430X\n")); break;
14700 default: printf ("??? (%d)\n", val); break;
14701 }
14702 break;
14703
14704 case OFBA_MSPABI_Tag_Code_Model:
14705 val = read_uleb128 (p, &len, end);
14706 p += len;
14707 printf (" Tag_Code_Model: ");
14708 switch (val)
14709 {
14710 case 0: printf (_("None\n")); break;
14711 case 1: printf (_("Small\n")); break;
14712 case 2: printf (_("Large\n")); break;
14713 default: printf ("??? (%d)\n", val); break;
14714 }
14715 break;
14716
14717 case OFBA_MSPABI_Tag_Data_Model:
14718 val = read_uleb128 (p, &len, end);
14719 p += len;
14720 printf (" Tag_Data_Model: ");
14721 switch (val)
14722 {
14723 case 0: printf (_("None\n")); break;
14724 case 1: printf (_("Small\n")); break;
14725 case 2: printf (_("Large\n")); break;
14726 case 3: printf (_("Restricted Large\n")); break;
14727 default: printf ("??? (%d)\n", val); break;
14728 }
14729 break;
14730
14731 default:
14732 printf (_(" <unknown tag %d>: "), tag);
14733
14734 if (tag & 1)
14735 {
071436c6 14736 putchar ('"');
4082ef84
NC		 14737 if (p < end - 1)
14738 {
14739 size_t maxlen = (end - p) - 1;
14740
14741 print_symbol ((int) maxlen, (const char *) p);
14742 p += strnlen ((char *) p, maxlen) + 1;
14743 }
14744 else
14745 {
14746 printf (_("<corrupt>"));
14747 p = (unsigned char *) end;
14748 }
071436c6 14749 printf ("\"\n");
13761a11
NC		 14750 }
14751 else
14752 {
14753 val = read_uleb128 (p, &len, end);
14754 p += len;
14755 printf ("%d (0x%x)\n", val, val);
14756 }
14757 break;
14758 }
14759
4082ef84 14760 assert (p <= end);
13761a11
NC		 14761 return p;
14762}
14763
32ec8896 14764static bfd_boolean
60bca95a
NC		 14765process_attributes (FILE * file,
14766 const char * public_name,
104d59d1 14767 unsigned int proc_type,
f6f0e17b 14768 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
60abdbed 14769 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
11c1ff18 14770{
2cf0635d 14771 Elf_Internal_Shdr * sect;
11c1ff18 14772 unsigned i;
32ec8896 14773 bfd_boolean res = TRUE;
11c1ff18
PB		 14774
14775 /* Find the section header so that we get the size. */
14776 for (i = 0, sect = section_headers;
14777 i < elf_header.e_shnum;
14778 i++, sect++)
14779 {
071436c6
NC		 14780 unsigned char * contents;
14781 unsigned char * p;
14782
104d59d1 14783 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 14784 continue;
14785
3f5e193b
NC		 14786 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
14787 sect->sh_size, _("attributes"));
60bca95a 14788 if (contents == NULL)
32ec8896
NC		 14789 {
14790 res = FALSE;
14791 continue;
14792 }
60bca95a 14793
11c1ff18 14794 p = contents;
60abdbed
NC		 14795 /* The first character is the version of the attributes.
14796 Currently only version 1, (aka 'A') is recognised here. */
14797 if (*p != 'A')
32ec8896
NC		 14798 {
14799 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
14800 res = FALSE;
14801 }
60abdbed 14802 else
11c1ff18 14803 {
071436c6
NC		 14804 bfd_vma section_len;
14805
14806 section_len = sect->sh_size - 1;
11c1ff18 14807 p++;
60bca95a 14808
071436c6 14809 while (section_len > 0)
11c1ff18 14810 {
071436c6 14811 bfd_vma attr_len;
e9847026 14812 unsigned int namelen;
11c1ff18 14813 bfd_boolean public_section;
104d59d1 14814 bfd_boolean gnu_section;
11c1ff18 14815
071436c6 14816 if (section_len <= 4)
e0a31db1
NC		 14817 {
14818 error (_("Tag section ends prematurely\n"));
32ec8896 14819 res = FALSE;
e0a31db1
NC		 14820 break;
14821 }
071436c6 14822 attr_len = byte_get (p, 4);
11c1ff18 14823 p += 4;
60bca95a 14824
071436c6 14825 if (attr_len > section_len)
11c1ff18 14826 {
071436c6
NC		 14827 error (_("Bad attribute length (%u > %u)\n"),
14828 (unsigned) attr_len, (unsigned) section_len);
14829 attr_len = section_len;
32ec8896 14830 res = FALSE;
11c1ff18 14831 }
74e1a04b 14832 /* PR 17531: file: 001-101425-0.004 */
071436c6 14833 else if (attr_len < 5)
74e1a04b 14834 {
071436c6 14835 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
32ec8896 14836 res = FALSE;
74e1a04b
NC		 14837 break;
14838 }
e9847026 14839
071436c6
NC		 14840 section_len -= attr_len;
14841 attr_len -= 4;
14842
14843 namelen = strnlen ((char *) p, attr_len) + 1;
14844 if (namelen == 0 || namelen >= attr_len)
e9847026
NC		 14845 {
14846 error (_("Corrupt attribute section name\n"));
32ec8896 14847 res = FALSE;
e9847026
NC		 14848 break;
14849 }
14850
071436c6
NC		 14851 printf (_("Attribute Section: "));
14852 print_symbol (INT_MAX, (const char *) p);
14853 putchar ('\n');
60bca95a
NC		 14854
14855 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 14856 public_section = TRUE;
14857 else
14858 public_section = FALSE;
60bca95a
NC		 14859
14860 if (streq ((char *) p, "gnu"))
104d59d1
JM		 14861 gnu_section = TRUE;
14862 else
14863 gnu_section = FALSE;
60bca95a 14864
11c1ff18 14865 p += namelen;
071436c6 14866 attr_len -= namelen;
e0a31db1 14867
071436c6 14868 while (attr_len > 0 && p < contents + sect->sh_size)
11c1ff18 14869 {
e0a31db1 14870 int tag;
11c1ff18
PB		 14871 int val;
14872 bfd_vma size;
071436c6 14873 unsigned char * end;
60bca95a 14874
e0a31db1 14875 /* PR binutils/17531: Safe handling of corrupt files. */
071436c6 14876 if (attr_len < 6)
e0a31db1
NC		 14877 {
14878 error (_("Unused bytes at end of section\n"));
32ec8896 14879 res = FALSE;
e0a31db1
NC		 14880 section_len = 0;
14881 break;
14882 }
14883
14884 tag = *(p++);
11c1ff18 14885 size = byte_get (p, 4);
071436c6 14886 if (size > attr_len)
11c1ff18 14887 {
e9847026 14888 error (_("Bad subsection length (%u > %u)\n"),
071436c6 14889 (unsigned) size, (unsigned) attr_len);
32ec8896 14890 res = FALSE;
071436c6 14891 size = attr_len;
11c1ff18 14892 }
e0a31db1
NC		 14893 /* PR binutils/17531: Safe handling of corrupt files. */
14894 if (size < 6)
14895 {
14896 error (_("Bad subsection length (%u < 6)\n"),
14897 (unsigned) size);
32ec8896 14898 res = FALSE;
e0a31db1
NC		 14899 section_len = 0;
14900 break;
14901 }
60bca95a 14902
071436c6 14903 attr_len -= size;
11c1ff18 14904 end = p + size - 1;
071436c6 14905 assert (end <= contents + sect->sh_size);
11c1ff18 14906 p += 4;
60bca95a 14907
11c1ff18
PB		 14908 switch (tag)
14909 {
14910 case 1:
2b692964 14911 printf (_("File Attributes\n"));
11c1ff18
PB		 14912 break;
14913 case 2:
2b692964 14914 printf (_("Section Attributes:"));
11c1ff18
PB		 14915 goto do_numlist;
14916 case 3:
2b692964 14917 printf (_("Symbol Attributes:"));
1a0670f3 14918 /* Fall through. */
11c1ff18
PB		 14919 do_numlist:
14920 for (;;)
14921 {
91d6fa6a 14922 unsigned int j;
60bca95a 14923
f6f0e17b 14924 val = read_uleb128 (p, &j, end);
91d6fa6a 14925 p += j;
11c1ff18
PB		 14926 if (val == 0)
14927 break;
14928 printf (" %d", val);
14929 }
14930 printf ("\n");
14931 break;
14932 default:
2b692964 14933 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 14934 public_section = FALSE;
14935 break;
14936 }
60bca95a 14937
071436c6 14938 if (public_section && display_pub_attribute != NULL)
11c1ff18
PB		 14939 {
14940 while (p < end)
f6f0e17b 14941 p = display_pub_attribute (p, end);
60abdbed 14942 assert (p == end);
104d59d1 14943 }
071436c6 14944 else if (gnu_section && display_proc_gnu_attribute != NULL)
104d59d1
JM		 14945 {
14946 while (p < end)
14947 p = display_gnu_attribute (p,
f6f0e17b
NC		 14948 display_proc_gnu_attribute,
14949 end);
60abdbed 14950 assert (p == end);
11c1ff18 14951 }
071436c6 14952 else if (p < end)
11c1ff18 14953 {
071436c6 14954 printf (_(" Unknown attribute:\n"));
f6f0e17b 14955 display_raw_attribute (p, end);
11c1ff18
PB		 14956 p = end;
14957 }
071436c6
NC		 14958 else
14959 attr_len = 0;
11c1ff18
PB		 14960 }
14961 }
14962 }
d70c5fc7 14963
60bca95a 14964 free (contents);
11c1ff18 14965 }
32ec8896
NC		 14966
14967 return res;
11c1ff18
PB		 14968}
14969
ccb4c951
RS		 14970/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14971 Print the Address, Access and Initial fields of an entry at VMA ADDR
82b1b41b
NC		 14972 and return the VMA of the next entry, or -1 if there was a problem.
14973 Does not read from DATA_END or beyond. */
ccb4c951
RS		 14974
14975static bfd_vma
82b1b41b
NC		 14976print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
14977 unsigned char * data_end)
ccb4c951
RS		 14978{
14979 printf (" ");
14980 print_vma (addr, LONG_HEX);
14981 printf (" ");
14982 if (addr < pltgot + 0xfff0)
14983 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
14984 else
14985 printf ("%10s", "");
14986 printf (" ");
14987 if (data == NULL)
2b692964 14988 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 14989 else
14990 {
14991 bfd_vma entry;
82b1b41b 14992 unsigned char * from = data + addr - pltgot;
ccb4c951 14993
82b1b41b
NC		 14994 if (from + (is_32bit_elf ? 4 : 8) > data_end)
14995 {
14996 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14997 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
14998 return (bfd_vma) -1;
14999 }
15000 else
15001 {
15002 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15003 print_vma (entry, LONG_HEX);
15004 }
ccb4c951
RS		 15005 }
15006 return addr + (is_32bit_elf ? 4 : 8);
15007}
15008
861fb55a
DJ		 15009/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15010 PLTGOT. Print the Address and Initial fields of an entry at VMA
15011 ADDR and return the VMA of the next entry. */
15012
15013static bfd_vma
2cf0635d 15014print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 15015{
15016 printf (" ");
15017 print_vma (addr, LONG_HEX);
15018 printf (" ");
15019 if (data == NULL)
2b692964 15020 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 15021 else
15022 {
15023 bfd_vma entry;
15024
15025 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15026 print_vma (entry, LONG_HEX);
15027 }
15028 return addr + (is_32bit_elf ? 4 : 8);
15029}
15030
351cdf24
MF		 15031static void
15032print_mips_ases (unsigned int mask)
15033{
15034 if (mask & AFL_ASE_DSP)
15035 fputs ("\n\tDSP ASE", stdout);
15036 if (mask & AFL_ASE_DSPR2)
15037 fputs ("\n\tDSP R2 ASE", stdout);
8f4f9071
MF		 15038 if (mask & AFL_ASE_DSPR3)
15039 fputs ("\n\tDSP R3 ASE", stdout);
351cdf24
MF		 15040 if (mask & AFL_ASE_EVA)
15041 fputs ("\n\tEnhanced VA Scheme", stdout);
15042 if (mask & AFL_ASE_MCU)
15043 fputs ("\n\tMCU (MicroController) ASE", stdout);
15044 if (mask & AFL_ASE_MDMX)
15045 fputs ("\n\tMDMX ASE", stdout);
15046 if (mask & AFL_ASE_MIPS3D)
15047 fputs ("\n\tMIPS-3D ASE", stdout);
15048 if (mask & AFL_ASE_MT)
15049 fputs ("\n\tMT ASE", stdout);
15050 if (mask & AFL_ASE_SMARTMIPS)
15051 fputs ("\n\tSmartMIPS ASE", stdout);
15052 if (mask & AFL_ASE_VIRT)
15053 fputs ("\n\tVZ ASE", stdout);
15054 if (mask & AFL_ASE_MSA)
15055 fputs ("\n\tMSA ASE", stdout);
15056 if (mask & AFL_ASE_MIPS16)
15057 fputs ("\n\tMIPS16 ASE", stdout);
15058 if (mask & AFL_ASE_MICROMIPS)
15059 fputs ("\n\tMICROMIPS ASE", stdout);
15060 if (mask & AFL_ASE_XPA)
15061 fputs ("\n\tXPA ASE", stdout);
25499ac7
MR		 15062 if (mask & AFL_ASE_MIPS16E2)
15063 fputs ("\n\tMIPS16e2 ASE", stdout);
351cdf24
MF		 15064 if (mask == 0)
15065 fprintf (stdout, "\n\t%s", _("None"));
00ac7aa0
MF		 15066 else if ((mask & ~AFL_ASE_MASK) != 0)
15067 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
351cdf24
MF		 15068}
15069
15070static void
15071print_mips_isa_ext (unsigned int isa_ext)
15072{
15073 switch (isa_ext)
15074 {
15075 case 0:
15076 fputs (_("None"), stdout);
15077 break;
15078 case AFL_EXT_XLR:
15079 fputs ("RMI XLR", stdout);
15080 break;
2c629856
N		 15081 case AFL_EXT_OCTEON3:
15082 fputs ("Cavium Networks Octeon3", stdout);
15083 break;
351cdf24
MF		 15084 case AFL_EXT_OCTEON2:
15085 fputs ("Cavium Networks Octeon2", stdout);
15086 break;
15087 case AFL_EXT_OCTEONP:
15088 fputs ("Cavium Networks OcteonP", stdout);
15089 break;
15090 case AFL_EXT_LOONGSON_3A:
15091 fputs ("Loongson 3A", stdout);
15092 break;
15093 case AFL_EXT_OCTEON:
15094 fputs ("Cavium Networks Octeon", stdout);
15095 break;
15096 case AFL_EXT_5900:
15097 fputs ("Toshiba R5900", stdout);
15098 break;
15099 case AFL_EXT_4650:
15100 fputs ("MIPS R4650", stdout);
15101 break;
15102 case AFL_EXT_4010:
15103 fputs ("LSI R4010", stdout);
15104 break;
15105 case AFL_EXT_4100:
15106 fputs ("NEC VR4100", stdout);
15107 break;
15108 case AFL_EXT_3900:
15109 fputs ("Toshiba R3900", stdout);
15110 break;
15111 case AFL_EXT_10000:
15112 fputs ("MIPS R10000", stdout);
15113 break;
15114 case AFL_EXT_SB1:
15115 fputs ("Broadcom SB-1", stdout);
15116 break;
15117 case AFL_EXT_4111:
15118 fputs ("NEC VR4111/VR4181", stdout);
15119 break;
15120 case AFL_EXT_4120:
15121 fputs ("NEC VR4120", stdout);
15122 break;
15123 case AFL_EXT_5400:
15124 fputs ("NEC VR5400", stdout);
15125 break;
15126 case AFL_EXT_5500:
15127 fputs ("NEC VR5500", stdout);
15128 break;
15129 case AFL_EXT_LOONGSON_2E:
15130 fputs ("ST Microelectronics Loongson 2E", stdout);
15131 break;
15132 case AFL_EXT_LOONGSON_2F:
15133 fputs ("ST Microelectronics Loongson 2F", stdout);
15134 break;
38bf472a
MR		 15135 case AFL_EXT_INTERAPTIV_MR2:
15136 fputs ("Imagination interAptiv MR2", stdout);
15137 break;
351cdf24 15138 default:
00ac7aa0 15139 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
351cdf24
MF		 15140 }
15141}
15142
32ec8896 15143static signed int
351cdf24
MF		 15144get_mips_reg_size (int reg_size)
15145{
15146 return (reg_size == AFL_REG_NONE) ? 0
15147 : (reg_size == AFL_REG_32) ? 32
15148 : (reg_size == AFL_REG_64) ? 64
15149 : (reg_size == AFL_REG_128) ? 128
15150 : -1;
15151}
15152
32ec8896 15153static bfd_boolean
2cf0635d 15154process_mips_specific (FILE * file)
5b18a4bc 15155{
2cf0635d 15156 Elf_Internal_Dyn * entry;
351cdf24 15157 Elf_Internal_Shdr *sect = NULL;
19e6b90e
L		 15158 size_t liblist_offset = 0;
15159 size_t liblistno = 0;
15160 size_t conflictsno = 0;
15161 size_t options_offset = 0;
15162 size_t conflicts_offset = 0;
861fb55a
DJ		 15163 size_t pltrelsz = 0;
15164 size_t pltrel = 0;
ccb4c951 15165 bfd_vma pltgot = 0;
861fb55a
DJ		 15166 bfd_vma mips_pltgot = 0;
15167 bfd_vma jmprel = 0;
ccb4c951
RS		 15168 bfd_vma local_gotno = 0;
15169 bfd_vma gotsym = 0;
15170 bfd_vma symtabno = 0;
32ec8896 15171 bfd_boolean res = TRUE;
103f02d3 15172
32ec8896
NC		 15173 if (! process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
15174 display_mips_gnu_attribute))
15175 res = FALSE;
2cf19d5c 15176
351cdf24
MF		 15177 sect = find_section (".MIPS.abiflags");
15178
15179 if (sect != NULL)
15180 {
15181 Elf_External_ABIFlags_v0 *abiflags_ext;
15182 Elf_Internal_ABIFlags_v0 abiflags_in;
15183
15184 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
32ec8896
NC		 15185 {
15186 error (_("Corrupt MIPS ABI Flags section.\n"));
15187 res = FALSE;
15188 }
351cdf24
MF		 15189 else
15190 {
15191 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
15192 sect->sh_size, _("MIPS ABI Flags section"));
15193 if (abiflags_ext)
15194 {
15195 abiflags_in.version = BYTE_GET (abiflags_ext->version);
15196 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
15197 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
15198 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
15199 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
15200 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
15201 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
15202 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
15203 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
15204 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
15205 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
15206
15207 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
15208 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
15209 if (abiflags_in.isa_rev > 1)
15210 printf ("r%d", abiflags_in.isa_rev);
15211 printf ("\nGPR size: %d",
15212 get_mips_reg_size (abiflags_in.gpr_size));
15213 printf ("\nCPR1 size: %d",
15214 get_mips_reg_size (abiflags_in.cpr1_size));
15215 printf ("\nCPR2 size: %d",
15216 get_mips_reg_size (abiflags_in.cpr2_size));
15217 fputs ("\nFP ABI: ", stdout);
15218 print_mips_fp_abi_value (abiflags_in.fp_abi);
15219 fputs ("ISA Extension: ", stdout);
15220 print_mips_isa_ext (abiflags_in.isa_ext);
15221 fputs ("\nASEs:", stdout);
15222 print_mips_ases (abiflags_in.ases);
15223 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
15224 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
15225 fputc ('\n', stdout);
15226 free (abiflags_ext);
15227 }
15228 }
15229 }
15230
19e6b90e
L		 15231 /* We have a lot of special sections. Thanks SGI! */
15232 if (dynamic_section == NULL)
bbdd9a68
MR		 15233 {
15234 /* No dynamic information available. See if there is static GOT. */
15235 sect = find_section (".got");
15236 if (sect != NULL)
15237 {
15238 unsigned char *data_end;
15239 unsigned char *data;
15240 bfd_vma ent, end;
15241 int addr_size;
15242
15243 pltgot = sect->sh_addr;
15244
15245 ent = pltgot;
15246 addr_size = (is_32bit_elf ? 4 : 8);
15247 end = pltgot + sect->sh_size;
15248
15249 data = (unsigned char *) get_data (NULL, file, sect->sh_offset,
15250 end - pltgot, 1,
15251 _("Global Offset Table data"));
15252 /* PR 12855: Null data is handled gracefully throughout. */
15253 data_end = data + (end - pltgot);
15254
15255 printf (_("\nStatic GOT:\n"));
15256 printf (_(" Canonical gp value: "));
15257 print_vma (ent + 0x7ff0, LONG_HEX);
15258 printf ("\n\n");
15259
15260 /* In a dynamic binary GOT[0] is reserved for the dynamic
15261 loader to store the lazy resolver pointer, however in
15262 a static binary it may well have been omitted and GOT
15263 reduced to a table of addresses.
15264 PR 21344: Check for the entry being fully available
15265 before fetching it. */
15266 if (data
15267 && data + ent - pltgot + addr_size <= data_end
15268 && byte_get (data + ent - pltgot, addr_size) == 0)
15269 {
15270 printf (_(" Reserved entries:\n"));
15271 printf (_(" %*s %10s %*s\n"),
15272 addr_size * 2, _("Address"), _("Access"),
15273 addr_size * 2, _("Value"));
15274 ent = print_mips_got_entry (data, pltgot, ent, data_end);
15275 printf ("\n");
15276 if (ent == (bfd_vma) -1)
15277 goto sgot_print_fail;
15278
15279 /* Check for the MSB of GOT[1] being set, identifying a
15280 GNU object. This entry will be used by some runtime
15281 loaders, to store the module pointer. Otherwise this
15282 is an ordinary local entry.
15283 PR 21344: Check for the entry being fully available
15284 before fetching it. */
15285 if (data
15286 && data + ent - pltgot + addr_size <= data_end
15287 && (byte_get (data + ent - pltgot, addr_size)
15288 >> (addr_size * 8 - 1)) != 0)
15289 {
15290 ent = print_mips_got_entry (data, pltgot, ent, data_end);
15291 printf ("\n");
15292 if (ent == (bfd_vma) -1)
15293 goto sgot_print_fail;
15294 }
15295 printf ("\n");
15296 }
15297
15298 if (ent < end)
15299 {
15300 printf (_(" Local entries:\n"));
15301 printf (" %*s %10s %*s\n",
15302 addr_size * 2, _("Address"), _("Access"),
15303 addr_size * 2, _("Value"));
15304 while (ent < end)
15305 {
15306 ent = print_mips_got_entry (data, pltgot, ent, data_end);
15307 printf ("\n");
15308 if (ent == (bfd_vma) -1)
15309 goto sgot_print_fail;
15310 }
15311 printf ("\n");
15312 }
15313
15314 sgot_print_fail:
15315 if (data)
15316 free (data);
15317 }
15318 return res;
15319 }
252b5132 15320
071436c6
NC		 15321 for (entry = dynamic_section;
15322 /* PR 17531 file: 012-50589-0.004. */
15323 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
15324 ++entry)
252b5132
RH		 15325 switch (entry->d_tag)
15326 {
15327 case DT_MIPS_LIBLIST:
d93f0186
NC		 15328 liblist_offset
15329 = offset_from_vma (file, entry->d_un.d_val,
15330 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 15331 break;
15332 case DT_MIPS_LIBLISTNO:
15333 liblistno = entry->d_un.d_val;
15334 break;
15335 case DT_MIPS_OPTIONS:
d93f0186 15336 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 15337 break;
15338 case DT_MIPS_CONFLICT:
d93f0186
NC		 15339 conflicts_offset
15340 = offset_from_vma (file, entry->d_un.d_val,
15341 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 15342 break;
15343 case DT_MIPS_CONFLICTNO:
15344 conflictsno = entry->d_un.d_val;
15345 break;
ccb4c951 15346 case DT_PLTGOT:
861fb55a
DJ		 15347 pltgot = entry->d_un.d_ptr;
15348 break;
ccb4c951
RS		 15349 case DT_MIPS_LOCAL_GOTNO:
15350 local_gotno = entry->d_un.d_val;
15351 break;
15352 case DT_MIPS_GOTSYM:
15353 gotsym = entry->d_un.d_val;
15354 break;
15355 case DT_MIPS_SYMTABNO:
15356 symtabno = entry->d_un.d_val;
15357 break;
861fb55a
DJ		 15358 case DT_MIPS_PLTGOT:
15359 mips_pltgot = entry->d_un.d_ptr;
15360 break;
15361 case DT_PLTREL:
15362 pltrel = entry->d_un.d_val;
15363 break;
15364 case DT_PLTRELSZ:
15365 pltrelsz = entry->d_un.d_val;
15366 break;
15367 case DT_JMPREL:
15368 jmprel = entry->d_un.d_ptr;
15369 break;
252b5132
RH		 15370 default:
15371 break;
15372 }
15373
15374 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
15375 {
2cf0635d 15376 Elf32_External_Lib * elib;
252b5132
RH		 15377 size_t cnt;
15378
3f5e193b
NC		 15379 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
15380 liblistno,
15381 sizeof (Elf32_External_Lib),
9cf03b7e 15382 _("liblist section data"));
a6e9f9df 15383 if (elib)
252b5132 15384 {
2b692964 15385 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 15386 (unsigned long) liblistno);
2b692964 15387 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 15388 stdout);
15389
15390 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 15391 {
a6e9f9df 15392 Elf32_Lib liblist;
91d6fa6a 15393 time_t atime;
d5b07ef4 15394 char timebuf[128];
2cf0635d 15395 struct tm * tmp;
a6e9f9df
AM		 15396
15397 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 15398 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 15399 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15400 liblist.l_version = BYTE_GET (elib[cnt].l_version);
15401 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15402
91d6fa6a 15403 tmp = gmtime (&atime);
e9e44622
JJ		 15404 snprintf (timebuf, sizeof (timebuf),
15405 "%04u-%02u-%02uT%02u:%02u:%02u",
15406 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15407 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 15408
31104126 15409 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 15410 if (VALID_DYNAMIC_NAME (liblist.l_name))
15411 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
15412 else
2b692964 15413 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 15414 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
15415 liblist.l_version);
a6e9f9df
AM		 15416
15417 if (liblist.l_flags == 0)
2b692964 15418 puts (_(" NONE"));
a6e9f9df
AM		 15419 else
15420 {
15421 static const struct
252b5132 15422 {
2cf0635d 15423 const char * name;
a6e9f9df 15424 int bit;
252b5132 15425 }
a6e9f9df
AM		 15426 l_flags_vals[] =
15427 {
15428 { " EXACT_MATCH", LL_EXACT_MATCH },
15429 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
15430 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
15431 { " EXPORTS", LL_EXPORTS },
15432 { " DELAY_LOAD", LL_DELAY_LOAD },
15433 { " DELTA", LL_DELTA }
15434 };
15435 int flags = liblist.l_flags;
15436 size_t fcnt;
15437
60bca95a 15438 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 15439 if ((flags & l_flags_vals[fcnt].bit) != 0)
15440 {
15441 fputs (l_flags_vals[fcnt].name, stdout);
15442 flags ^= l_flags_vals[fcnt].bit;
15443 }
15444 if (flags != 0)
15445 printf (" %#x", (unsigned int) flags);
252b5132 15446
a6e9f9df
AM		 15447 puts ("");
15448 }
252b5132 15449 }
252b5132 15450
a6e9f9df
AM		 15451 free (elib);
15452 }
32ec8896
NC		 15453 else
15454 res = FALSE;
252b5132
RH		 15455 }
15456
15457 if (options_offset != 0)
15458 {
2cf0635d 15459 Elf_External_Options * eopt;
2cf0635d
NC		 15460 Elf_Internal_Options * iopt;
15461 Elf_Internal_Options * option;
252b5132
RH		 15462 size_t offset;
15463 int cnt;
351cdf24 15464 sect = section_headers;
252b5132
RH		 15465
15466 /* Find the section header so that we get the size. */
071436c6 15467 sect = find_section_by_type (SHT_MIPS_OPTIONS);
948f632f 15468 /* PR 17533 file: 012-277276-0.004. */
071436c6
NC		 15469 if (sect == NULL)
15470 {
15471 error (_("No MIPS_OPTIONS header found\n"));
32ec8896 15472 return FALSE;
071436c6 15473 }
252b5132 15474
3f5e193b
NC		 15475 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
15476 sect->sh_size, _("options"));
a6e9f9df 15477 if (eopt)
252b5132 15478 {
3f5e193b
NC		 15479 iopt = (Elf_Internal_Options *)
15480 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 15481 if (iopt == NULL)
15482 {
fb324ee9 15483 error (_("Out of memory allocating space for MIPS options\n"));
32ec8896 15484 return FALSE;
a6e9f9df 15485 }
76da6bbe 15486
a6e9f9df
AM		 15487 offset = cnt = 0;
15488 option = iopt;
252b5132 15489
82b1b41b 15490 while (offset <= sect->sh_size - sizeof (* eopt))
a6e9f9df 15491 {
2cf0635d 15492 Elf_External_Options * eoption;
252b5132 15493
a6e9f9df 15494 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 15495
a6e9f9df
AM		 15496 option->kind = BYTE_GET (eoption->kind);
15497 option->size = BYTE_GET (eoption->size);
15498 option->section = BYTE_GET (eoption->section);
15499 option->info = BYTE_GET (eoption->info);
76da6bbe 15500
82b1b41b
NC		 15501 /* PR 17531: file: ffa0fa3b. */
15502 if (option->size < sizeof (* eopt)
15503 || offset + option->size > sect->sh_size)
15504 {
55325047 15505 error (_("Invalid size (%u) for MIPS option\n"), option->size);
32ec8896 15506 return FALSE;
82b1b41b 15507 }
a6e9f9df 15508 offset += option->size;
14ae95f2 15509
a6e9f9df
AM		 15510 ++option;
15511 ++cnt;
15512 }
252b5132 15513
a6e9f9df 15514 printf (_("\nSection '%s' contains %d entries:\n"),
74e1a04b 15515 printable_section_name (sect), cnt);
76da6bbe 15516
a6e9f9df 15517 option = iopt;
82b1b41b 15518 offset = 0;
252b5132 15519
a6e9f9df 15520 while (cnt-- > 0)
252b5132 15521 {
a6e9f9df
AM		 15522 size_t len;
15523
15524 switch (option->kind)
252b5132 15525 {
a6e9f9df
AM		 15526 case ODK_NULL:
15527 /* This shouldn't happen. */
15528 printf (" NULL %d %lx", option->section, option->info);
15529 break;
15530 case ODK_REGINFO:
15531 printf (" REGINFO ");
15532 if (elf_header.e_machine == EM_MIPS)
15533 {
15534 /* 32bit form. */
2cf0635d 15535 Elf32_External_RegInfo * ereg;
b34976b6 15536 Elf32_RegInfo reginfo;
a6e9f9df
AM		 15537
15538 ereg = (Elf32_External_RegInfo *) (option + 1);
15539 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
15540 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15541 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15542 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15543 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15544 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
15545
15546 printf ("GPR %08lx GP 0x%lx\n",
15547 reginfo.ri_gprmask,
15548 (unsigned long) reginfo.ri_gp_value);
15549 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15550 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15551 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15552 }
15553 else
15554 {
15555 /* 64 bit form. */
2cf0635d 15556 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 15557 Elf64_Internal_RegInfo reginfo;
15558
15559 ereg = (Elf64_External_RegInfo *) (option + 1);
15560 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
15561 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15562 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15563 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15564 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 15565 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 15566
15567 printf ("GPR %08lx GP 0x",
15568 reginfo.ri_gprmask);
15569 printf_vma (reginfo.ri_gp_value);
15570 printf ("\n");
15571
15572 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15573 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15574 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15575 }
15576 ++option;
15577 continue;
15578 case ODK_EXCEPTIONS:
15579 fputs (" EXCEPTIONS fpe_min(", stdout);
15580 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
15581 fputs (") fpe_max(", stdout);
15582 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
15583 fputs (")", stdout);
15584
15585 if (option->info & OEX_PAGE0)
15586 fputs (" PAGE0", stdout);
15587 if (option->info & OEX_SMM)
15588 fputs (" SMM", stdout);
15589 if (option->info & OEX_FPDBUG)
15590 fputs (" FPDBUG", stdout);
15591 if (option->info & OEX_DISMISS)
15592 fputs (" DISMISS", stdout);
15593 break;
15594 case ODK_PAD:
15595 fputs (" PAD ", stdout);
15596 if (option->info & OPAD_PREFIX)
15597 fputs (" PREFIX", stdout);
15598 if (option->info & OPAD_POSTFIX)
15599 fputs (" POSTFIX", stdout);
15600 if (option->info & OPAD_SYMBOL)
15601 fputs (" SYMBOL", stdout);
15602 break;
15603 case ODK_HWPATCH:
15604 fputs (" HWPATCH ", stdout);
15605 if (option->info & OHW_R4KEOP)
15606 fputs (" R4KEOP", stdout);
15607 if (option->info & OHW_R8KPFETCH)
15608 fputs (" R8KPFETCH", stdout);
15609 if (option->info & OHW_R5KEOP)
15610 fputs (" R5KEOP", stdout);
15611 if (option->info & OHW_R5KCVTL)
15612 fputs (" R5KCVTL", stdout);
15613 break;
15614 case ODK_FILL:
15615 fputs (" FILL ", stdout);
15616 /* XXX Print content of info word? */
15617 break;
15618 case ODK_TAGS:
15619 fputs (" TAGS ", stdout);
15620 /* XXX Print content of info word? */
15621 break;
15622 case ODK_HWAND:
15623 fputs (" HWAND ", stdout);
15624 if (option->info & OHWA0_R4KEOP_CHECKED)
15625 fputs (" R4KEOP_CHECKED", stdout);
15626 if (option->info & OHWA0_R4KEOP_CLEAN)
15627 fputs (" R4KEOP_CLEAN", stdout);
15628 break;
15629 case ODK_HWOR:
15630 fputs (" HWOR ", stdout);
15631 if (option->info & OHWA0_R4KEOP_CHECKED)
15632 fputs (" R4KEOP_CHECKED", stdout);
15633 if (option->info & OHWA0_R4KEOP_CLEAN)
15634 fputs (" R4KEOP_CLEAN", stdout);
15635 break;
15636 case ODK_GP_GROUP:
15637 printf (" GP_GROUP %#06lx self-contained %#06lx",
15638 option->info & OGP_GROUP,
15639 (option->info & OGP_SELF) >> 16);
15640 break;
15641 case ODK_IDENT:
15642 printf (" IDENT %#06lx self-contained %#06lx",
15643 option->info & OGP_GROUP,
15644 (option->info & OGP_SELF) >> 16);
15645 break;
15646 default:
15647 /* This shouldn't happen. */
15648 printf (" %3d ??? %d %lx",
15649 option->kind, option->section, option->info);
15650 break;
252b5132 15651 }
a6e9f9df 15652
2cf0635d 15653 len = sizeof (* eopt);
a6e9f9df 15654 while (len < option->size)
82b1b41b 15655 {
7e27a9d5 15656 unsigned char datum = * ((unsigned char *) eopt + offset + len);
a6e9f9df 15657
82b1b41b
NC		 15658 if (ISPRINT (datum))
15659 printf ("%c", datum);
15660 else
15661 printf ("\\%03o", datum);
15662 len ++;
15663 }
a6e9f9df 15664 fputs ("\n", stdout);
82b1b41b
NC		 15665
15666 offset += option->size;
252b5132 15667 ++option;
252b5132
RH		 15668 }
15669
a6e9f9df 15670 free (eopt);
252b5132 15671 }
32ec8896
NC		 15672 else
15673 res = FALSE;
252b5132
RH		 15674 }
15675
15676 if (conflicts_offset != 0 && conflictsno != 0)
15677 {
2cf0635d 15678 Elf32_Conflict * iconf;
252b5132
RH		 15679 size_t cnt;
15680
15681 if (dynamic_symbols == NULL)
15682 {
591a748a 15683 error (_("conflict list found without a dynamic symbol table\n"));
32ec8896 15684 return FALSE;
252b5132
RH		 15685 }
15686
7296a62a
NC		 15687 /* PR 21345 - print a slightly more helpful error message
15688 if we are sure that the cmalloc will fail. */
15689 if (conflictsno * sizeof (* iconf) > current_file_size)
15690 {
15691 error (_("Overlarge number of conflicts detected: %lx\n"),
15692 (long) conflictsno);
15693 return FALSE;
15694 }
15695
3f5e193b 15696 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 15697 if (iconf == NULL)
15698 {
8b73c356 15699 error (_("Out of memory allocating space for dynamic conflicts\n"));
32ec8896 15700 return FALSE;
252b5132
RH		 15701 }
15702
9ea033b2 15703 if (is_32bit_elf)
252b5132 15704 {
2cf0635d 15705 Elf32_External_Conflict * econf32;
a6e9f9df 15706
3f5e193b
NC		 15707 econf32 = (Elf32_External_Conflict *)
15708 get_data (NULL, file, conflicts_offset, conflictsno,
15709 sizeof (* econf32), _("conflict"));
a6e9f9df 15710 if (!econf32)
32ec8896 15711 return FALSE;
252b5132
RH		 15712
15713 for (cnt = 0; cnt < conflictsno; ++cnt)
15714 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 15715
15716 free (econf32);
252b5132
RH		 15717 }
15718 else
15719 {
2cf0635d 15720 Elf64_External_Conflict * econf64;
a6e9f9df 15721
3f5e193b
NC		 15722 econf64 = (Elf64_External_Conflict *)
15723 get_data (NULL, file, conflicts_offset, conflictsno,
15724 sizeof (* econf64), _("conflict"));
a6e9f9df 15725 if (!econf64)
32ec8896 15726 return FALSE;
252b5132
RH		 15727
15728 for (cnt = 0; cnt < conflictsno; ++cnt)
15729 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 15730
15731 free (econf64);
252b5132
RH		 15732 }
15733
c7e7ca54
NC		 15734 printf (_("\nSection '.conflict' contains %lu entries:\n"),
15735 (unsigned long) conflictsno);
252b5132
RH		 15736 puts (_(" Num: Index Value Name"));
15737
15738 for (cnt = 0; cnt < conflictsno; ++cnt)
15739 {
b34976b6 15740 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
e0a31db1
NC		 15741
15742 if (iconf[cnt] >= num_dynamic_syms)
15743 printf (_("<corrupt symbol index>"));
d79b3d50 15744 else
e0a31db1
NC		 15745 {
15746 Elf_Internal_Sym * psym;
15747
15748 psym = & dynamic_symbols[iconf[cnt]];
15749 print_vma (psym->st_value, FULL_HEX);
15750 putchar (' ');
15751 if (VALID_DYNAMIC_NAME (psym->st_name))
15752 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
15753 else
15754 printf (_("<corrupt: %14ld>"), psym->st_name);
15755 }
31104126 15756 putchar ('\n');
252b5132
RH		 15757 }
15758
252b5132
RH		 15759 free (iconf);
15760 }
15761
ccb4c951
RS		 15762 if (pltgot != 0 && local_gotno != 0)
15763 {
91d6fa6a 15764 bfd_vma ent, local_end, global_end;
bbeee7ea 15765 size_t i, offset;
2cf0635d 15766 unsigned char * data;
82b1b41b 15767 unsigned char * data_end;
bbeee7ea 15768 int addr_size;
ccb4c951 15769
91d6fa6a 15770 ent = pltgot;
ccb4c951
RS		 15771 addr_size = (is_32bit_elf ? 4 : 8);
15772 local_end = pltgot + local_gotno * addr_size;
ccb4c951 15773
74e1a04b
NC		 15774 /* PR binutils/17533 file: 012-111227-0.004 */
15775 if (symtabno < gotsym)
15776 {
15777 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
82b1b41b 15778 (unsigned long) gotsym, (unsigned long) symtabno);
32ec8896 15779 return FALSE;
74e1a04b 15780 }
82b1b41b 15781
74e1a04b 15782 global_end = local_end + (symtabno - gotsym) * addr_size;
82b1b41b
NC		 15783 /* PR 17531: file: 54c91a34. */
15784 if (global_end < local_end)
15785 {
15786 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
32ec8896 15787 return FALSE;
82b1b41b 15788 }
948f632f 15789
ccb4c951 15790 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 15791 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 15792 global_end - pltgot, 1,
15793 _("Global Offset Table data"));
919383ac 15794 /* PR 12855: Null data is handled gracefully throughout. */
82b1b41b 15795 data_end = data + (global_end - pltgot);
59245841 15796
ccb4c951
RS		 15797 printf (_("\nPrimary GOT:\n"));
15798 printf (_(" Canonical gp value: "));
15799 print_vma (pltgot + 0x7ff0, LONG_HEX);
15800 printf ("\n\n");
15801
15802 printf (_(" Reserved entries:\n"));
15803 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 15804 addr_size * 2, _("Address"), _("Access"),
15805 addr_size * 2, _("Initial"));
82b1b41b 15806 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 15807 printf (_(" Lazy resolver\n"));
82b1b41b
NC		 15808 if (ent == (bfd_vma) -1)
15809 goto got_print_fail;
75ec1fdb 15810
c4ab9505
MR		 15811 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
15812 This entry will be used by some runtime loaders, to store the
15813 module pointer. Otherwise this is an ordinary local entry.
15814 PR 21344: Check for the entry being fully available before
15815 fetching it. */
15816 if (data
15817 && data + ent - pltgot + addr_size <= data_end
15818 && (byte_get (data + ent - pltgot, addr_size)
15819 >> (addr_size * 8 - 1)) != 0)
15820 {
15821 ent = print_mips_got_entry (data, pltgot, ent, data_end);
15822 printf (_(" Module pointer (GNU extension)\n"));
15823 if (ent == (bfd_vma) -1)
15824 goto got_print_fail;
ccb4c951
RS		 15825 }
15826 printf ("\n");
15827
91d6fa6a 15828 if (ent < local_end)
ccb4c951
RS		 15829 {
15830 printf (_(" Local entries:\n"));
cc5914eb 15831 printf (" %*s %10s %*s\n",
2b692964
NC		 15832 addr_size * 2, _("Address"), _("Access"),
15833 addr_size * 2, _("Initial"));
91d6fa6a 15834 while (ent < local_end)
ccb4c951 15835 {
82b1b41b 15836 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 15837 printf ("\n");
82b1b41b
NC		 15838 if (ent == (bfd_vma) -1)
15839 goto got_print_fail;
ccb4c951
RS		 15840 }
15841 printf ("\n");
15842 }
15843
15844 if (gotsym < symtabno)
15845 {
15846 int sym_width;
15847
15848 printf (_(" Global entries:\n"));
cc5914eb 15849 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 15850 addr_size * 2, _("Address"),
15851 _("Access"),
2b692964 15852 addr_size * 2, _("Initial"),
9cf03b7e
NC		 15853 addr_size * 2, _("Sym.Val."),
15854 _("Type"),
15855 /* Note for translators: "Ndx" = abbreviated form of "Index". */
15856 _("Ndx"), _("Name"));
0b4362b0 15857
ccb4c951 15858 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
e0a31db1 15859
ccb4c951
RS		 15860 for (i = gotsym; i < symtabno; i++)
15861 {
82b1b41b 15862 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 15863 printf (" ");
e0a31db1
NC		 15864
15865 if (dynamic_symbols == NULL)
15866 printf (_("<no dynamic symbols>"));
15867 else if (i < num_dynamic_syms)
15868 {
15869 Elf_Internal_Sym * psym = dynamic_symbols + i;
15870
15871 print_vma (psym->st_value, LONG_HEX);
15872 printf (" %-7s %3s ",
15873 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
15874 get_symbol_index_type (psym->st_shndx));
15875
15876 if (VALID_DYNAMIC_NAME (psym->st_name))
15877 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
15878 else
15879 printf (_("<corrupt: %14ld>"), psym->st_name);
15880 }
ccb4c951 15881 else
7fc5ac57
JBG		 15882 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15883 (unsigned long) i);
e0a31db1 15884
ccb4c951 15885 printf ("\n");
82b1b41b
NC		 15886 if (ent == (bfd_vma) -1)
15887 break;
ccb4c951
RS		 15888 }
15889 printf ("\n");
15890 }
15891
82b1b41b 15892 got_print_fail:
ccb4c951
RS		 15893 if (data)
15894 free (data);
15895 }
15896
861fb55a
DJ		 15897 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
15898 {
91d6fa6a 15899 bfd_vma ent, end;
861fb55a
DJ		 15900 size_t offset, rel_offset;
15901 unsigned long count, i;
2cf0635d 15902 unsigned char * data;
861fb55a 15903 int addr_size, sym_width;
2cf0635d 15904 Elf_Internal_Rela * rels;
861fb55a
DJ		 15905
15906 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
15907 if (pltrel == DT_RELA)
15908 {
15909 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
32ec8896 15910 return FALSE;
861fb55a
DJ		 15911 }
15912 else
15913 {
15914 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
32ec8896 15915 return FALSE;
861fb55a
DJ		 15916 }
15917
91d6fa6a 15918 ent = mips_pltgot;
861fb55a
DJ		 15919 addr_size = (is_32bit_elf ? 4 : 8);
15920 end = mips_pltgot + (2 + count) * addr_size;
15921
15922 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 15923 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 15924 1, _("Procedure Linkage Table data"));
59245841 15925 if (data == NULL)
32ec8896 15926 return FALSE;
59245841 15927
9cf03b7e 15928 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 15929 printf (_(" Reserved entries:\n"));
15930 printf (_(" %*s %*s Purpose\n"),
2b692964 15931 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 15932 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 15933 printf (_(" PLT lazy resolver\n"));
91d6fa6a 15934 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 15935 printf (_(" Module pointer\n"));
861fb55a
DJ		 15936 printf ("\n");
15937
15938 printf (_(" Entries:\n"));
cc5914eb 15939 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 15940 addr_size * 2, _("Address"),
15941 addr_size * 2, _("Initial"),
15942 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 15943 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
15944 for (i = 0; i < count; i++)
15945 {
df97ab2a 15946 unsigned long idx = get_reloc_symindex (rels[i].r_info);
861fb55a 15947
91d6fa6a 15948 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a 15949 printf (" ");
e0a31db1 15950
df97ab2a
MF		 15951 if (idx >= num_dynamic_syms)
15952 printf (_("<corrupt symbol index: %lu>"), idx);
861fb55a 15953 else
e0a31db1 15954 {
df97ab2a 15955 Elf_Internal_Sym * psym = dynamic_symbols + idx;
e0a31db1
NC		 15956
15957 print_vma (psym->st_value, LONG_HEX);
15958 printf (" %-7s %3s ",
15959 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
15960 get_symbol_index_type (psym->st_shndx));
15961 if (VALID_DYNAMIC_NAME (psym->st_name))
15962 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
15963 else
15964 printf (_("<corrupt: %14ld>"), psym->st_name);
15965 }
861fb55a
DJ		 15966 printf ("\n");
15967 }
15968 printf ("\n");
15969
15970 if (data)
15971 free (data);
15972 free (rels);
15973 }
15974
32ec8896 15975 return res;
252b5132
RH		 15976}
15977
32ec8896 15978static bfd_boolean
35c08157
KLC		 15979process_nds32_specific (FILE * file)
15980{
15981 Elf_Internal_Shdr *sect = NULL;
15982
15983 sect = find_section (".nds32_e_flags");
15984 if (sect != NULL)
15985 {
15986 unsigned int *flag;
15987
15988 printf ("\nNDS32 elf flags section:\n");
15989 flag = get_data (NULL, file, sect->sh_offset, 1,
15990 sect->sh_size, _("NDS32 elf flags section"));
15991
32ec8896
NC		 15992 if (! flag)
15993 return FALSE;
15994
35c08157
KLC		 15995 switch ((*flag) & 0x3)
15996 {
15997 case 0:
15998 printf ("(VEC_SIZE):\tNo entry.\n");
15999 break;
16000 case 1:
16001 printf ("(VEC_SIZE):\t4 bytes\n");
16002 break;
16003 case 2:
16004 printf ("(VEC_SIZE):\t16 bytes\n");
16005 break;
16006 case 3:
16007 printf ("(VEC_SIZE):\treserved\n");
16008 break;
16009 }
16010 }
16011
16012 return TRUE;
16013}
16014
32ec8896 16015static bfd_boolean
2cf0635d 16016process_gnu_liblist (FILE * file)
047b2264 16017{
2cf0635d
NC		 16018 Elf_Internal_Shdr * section;
16019 Elf_Internal_Shdr * string_sec;
16020 Elf32_External_Lib * elib;
16021 char * strtab;
c256ffe7 16022 size_t strtab_size;
047b2264
JJ		 16023 size_t cnt;
16024 unsigned i;
32ec8896 16025 bfd_boolean res = TRUE;
047b2264
JJ		 16026
16027 if (! do_arch)
32ec8896 16028 return TRUE;
047b2264
JJ		 16029
16030 for (i = 0, section = section_headers;
16031 i < elf_header.e_shnum;
b34976b6 16032 i++, section++)
047b2264
JJ		 16033 {
16034 switch (section->sh_type)
16035 {
16036 case SHT_GNU_LIBLIST:
4fbb74a6 16037 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 16038 break;
16039
3f5e193b
NC		 16040 elib = (Elf32_External_Lib *)
16041 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 16042 _("liblist section data"));
047b2264
JJ		 16043
16044 if (elib == NULL)
32ec8896
NC		 16045 {
16046 res = FALSE;
16047 break;
16048 }
047b2264 16049
32ec8896 16050 string_sec = section_headers + section->sh_link;
3f5e193b
NC		 16051 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
16052 string_sec->sh_size,
16053 _("liblist string table"));
047b2264
JJ		 16054 if (strtab == NULL
16055 || section->sh_entsize != sizeof (Elf32_External_Lib))
16056 {
16057 free (elib);
2842702f 16058 free (strtab);
32ec8896 16059 res = FALSE;
047b2264
JJ		 16060 break;
16061 }
59245841 16062 strtab_size = string_sec->sh_size;
047b2264
JJ		 16063
16064 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
74e1a04b 16065 printable_section_name (section),
0af1713e 16066 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 16067
2b692964 16068 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 16069
16070 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
16071 ++cnt)
16072 {
16073 Elf32_Lib liblist;
91d6fa6a 16074 time_t atime;
d5b07ef4 16075 char timebuf[128];
2cf0635d 16076 struct tm * tmp;
047b2264
JJ		 16077
16078 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 16079 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 16080 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16081 liblist.l_version = BYTE_GET (elib[cnt].l_version);
16082 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16083
91d6fa6a 16084 tmp = gmtime (&atime);
e9e44622
JJ		 16085 snprintf (timebuf, sizeof (timebuf),
16086 "%04u-%02u-%02uT%02u:%02u:%02u",
16087 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16088 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 16089
16090 printf ("%3lu: ", (unsigned long) cnt);
16091 if (do_wide)
c256ffe7 16092 printf ("%-20s", liblist.l_name < strtab_size
2b692964 16093 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 16094 else
c256ffe7 16095 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 16096 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 16097 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
16098 liblist.l_version, liblist.l_flags);
16099 }
16100
16101 free (elib);
2842702f 16102 free (strtab);
047b2264
JJ		 16103 }
16104 }
16105
32ec8896 16106 return res;
047b2264
JJ		 16107}
16108
9437c45b 16109static const char *
d3ba0551 16110get_note_type (unsigned e_type)
779fe533
NC		 16111{
16112 static char buff[64];
103f02d3 16113
1ec5cd37
NC		 16114 if (elf_header.e_type == ET_CORE)
16115 switch (e_type)
16116 {
57346661 16117 case NT_AUXV:
1ec5cd37 16118 return _("NT_AUXV (auxiliary vector)");
57346661 16119 case NT_PRSTATUS:
1ec5cd37 16120 return _("NT_PRSTATUS (prstatus structure)");
57346661 16121 case NT_FPREGSET:
1ec5cd37 16122 return _("NT_FPREGSET (floating point registers)");
57346661 16123 case NT_PRPSINFO:
1ec5cd37 16124 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 16125 case NT_TASKSTRUCT:
1ec5cd37 16126 return _("NT_TASKSTRUCT (task structure)");
57346661 16127 case NT_PRXFPREG:
1ec5cd37 16128 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 16129 case NT_PPC_VMX:
16130 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 16131 case NT_PPC_VSX:
16132 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 16133 case NT_386_TLS:
16134 return _("NT_386_TLS (x86 TLS information)");
16135 case NT_386_IOPERM:
16136 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 16137 case NT_X86_XSTATE:
16138 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 16139 case NT_S390_HIGH_GPRS:
16140 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 16141 case NT_S390_TIMER:
16142 return _("NT_S390_TIMER (s390 timer register)");
16143 case NT_S390_TODCMP:
16144 return _("NT_S390_TODCMP (s390 TOD comparator register)");
16145 case NT_S390_TODPREG:
16146 return _("NT_S390_TODPREG (s390 TOD programmable register)");
16147 case NT_S390_CTRS:
16148 return _("NT_S390_CTRS (s390 control registers)");
16149 case NT_S390_PREFIX:
16150 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 16151 case NT_S390_LAST_BREAK:
16152 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16153 case NT_S390_SYSTEM_CALL:
16154 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC		 16155 case NT_S390_TDB:
16156 return _("NT_S390_TDB (s390 transaction diagnostic block)");
4ef9f41a
AA		 16157 case NT_S390_VXRS_LOW:
16158 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16159 case NT_S390_VXRS_HIGH:
16160 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
faa9a424
UW		 16161 case NT_ARM_VFP:
16162 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 16163 case NT_ARM_TLS:
16164 return _("NT_ARM_TLS (AArch TLS registers)");
16165 case NT_ARM_HW_BREAK:
16166 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16167 case NT_ARM_HW_WATCH:
16168 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 16169 case NT_PSTATUS:
1ec5cd37 16170 return _("NT_PSTATUS (pstatus structure)");
57346661 16171 case NT_FPREGS:
1ec5cd37 16172 return _("NT_FPREGS (floating point registers)");
57346661 16173 case NT_PSINFO:
1ec5cd37 16174 return _("NT_PSINFO (psinfo structure)");
57346661 16175 case NT_LWPSTATUS:
1ec5cd37 16176 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 16177 case NT_LWPSINFO:
1ec5cd37 16178 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 16179 case NT_WIN32PSTATUS:
1ec5cd37 16180 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 16181 case NT_SIGINFO:
16182 return _("NT_SIGINFO (siginfo_t data)");
16183 case NT_FILE:
16184 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 16185 default:
16186 break;
16187 }
16188 else
16189 switch (e_type)
16190 {
16191 case NT_VERSION:
16192 return _("NT_VERSION (version)");
16193 case NT_ARCH:
16194 return _("NT_ARCH (architecture)");
9ef920e9
NC		 16195 case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16196 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16197 case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16198 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
1ec5cd37
NC		 16199 default:
16200 break;
16201 }
16202
e9e44622 16203 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 16204 return buff;
779fe533
NC		 16205}
16206
32ec8896 16207static bfd_boolean
9ece1fa9
TT		 16208print_core_note (Elf_Internal_Note *pnote)
16209{
16210 unsigned int addr_size = is_32bit_elf ? 4 : 8;
16211 bfd_vma count, page_size;
16212 unsigned char *descdata, *filenames, *descend;
16213
16214 if (pnote->type != NT_FILE)
32ec8896 16215 return TRUE;
9ece1fa9
TT		 16216
16217#ifndef BFD64
16218 if (!is_32bit_elf)
16219 {
16220 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
16221 /* Still "successful". */
32ec8896 16222 return TRUE;
9ece1fa9
TT		 16223 }
16224#endif
16225
16226 if (pnote->descsz < 2 * addr_size)
16227 {
32ec8896
NC		 16228 error (_(" Malformed note - too short for header\n"));
16229 return FALSE;
9ece1fa9
TT		 16230 }
16231
16232 descdata = (unsigned char *) pnote->descdata;
16233 descend = descdata + pnote->descsz;
16234
16235 if (descdata[pnote->descsz - 1] != '\0')
16236 {
32ec8896
NC		 16237 error (_(" Malformed note - does not end with \\0\n"));
16238 return FALSE;
9ece1fa9
TT		 16239 }
16240
16241 count = byte_get (descdata, addr_size);
16242 descdata += addr_size;
16243
16244 page_size = byte_get (descdata, addr_size);
16245 descdata += addr_size;
16246
16247 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
16248 {
32ec8896
NC		 16249 error (_(" Malformed note - too short for supplied file count\n"));
16250 return FALSE;
9ece1fa9
TT		 16251 }
16252
16253 printf (_(" Page size: "));
16254 print_vma (page_size, DEC);
16255 printf ("\n");
16256
16257 printf (_(" %*s%*s%*s\n"),
16258 (int) (2 + 2 * addr_size), _("Start"),
16259 (int) (4 + 2 * addr_size), _("End"),
16260 (int) (4 + 2 * addr_size), _("Page Offset"));
16261 filenames = descdata + count * 3 * addr_size;
595712bb 16262 while (count-- > 0)
9ece1fa9
TT		 16263 {
16264 bfd_vma start, end, file_ofs;
16265
16266 if (filenames == descend)
16267 {
32ec8896
NC		 16268 error (_(" Malformed note - filenames end too early\n"));
16269 return FALSE;
9ece1fa9
TT		 16270 }
16271
16272 start = byte_get (descdata, addr_size);
16273 descdata += addr_size;
16274 end = byte_get (descdata, addr_size);
16275 descdata += addr_size;
16276 file_ofs = byte_get (descdata, addr_size);
16277 descdata += addr_size;
16278
16279 printf (" ");
16280 print_vma (start, FULL_HEX);
16281 printf (" ");
16282 print_vma (end, FULL_HEX);
16283 printf (" ");
16284 print_vma (file_ofs, FULL_HEX);
16285 printf ("\n %s\n", filenames);
16286
16287 filenames += 1 + strlen ((char *) filenames);
16288 }
16289
32ec8896 16290 return TRUE;
9ece1fa9
TT		 16291}
16292
1118d252
RM		 16293static const char *
16294get_gnu_elf_note_type (unsigned e_type)
16295{
1449284b 16296 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
1118d252
RM		 16297 switch (e_type)
16298 {
16299 case NT_GNU_ABI_TAG:
16300 return _("NT_GNU_ABI_TAG (ABI version tag)");
16301 case NT_GNU_HWCAP:
16302 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16303 case NT_GNU_BUILD_ID:
16304 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 16305 case NT_GNU_GOLD_VERSION:
16306 return _("NT_GNU_GOLD_VERSION (gold version)");
9ef920e9
NC		 16307 case NT_GNU_PROPERTY_TYPE_0:
16308 return _("NT_GNU_PROPERTY_TYPE_0");
16309 case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16310 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16311 case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16312 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
1118d252 16313 default:
1449284b
NC		 16314 {
16315 static char buff[64];
1118d252 16316
1449284b
NC		 16317 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16318 return buff;
16319 }
16320 }
1118d252
RM		 16321}
16322
9ef920e9 16323static void
1fc87489 16324decode_x86_isa (unsigned int bitmask)
9ef920e9
NC		 16325{
16326 while (bitmask)
16327 {
1fc87489 16328 unsigned int bit = bitmask & (- bitmask);
9ef920e9
NC		 16329
16330 bitmask &= ~ bit;
16331 switch (bit)
16332 {
16333 case GNU_PROPERTY_X86_ISA_1_486: printf ("i486"); break;
16334 case GNU_PROPERTY_X86_ISA_1_586: printf ("586"); break;
16335 case GNU_PROPERTY_X86_ISA_1_686: printf ("686"); break;
16336 case GNU_PROPERTY_X86_ISA_1_SSE: printf ("SSE"); break;
16337 case GNU_PROPERTY_X86_ISA_1_SSE2: printf ("SSE2"); break;
16338 case GNU_PROPERTY_X86_ISA_1_SSE3: printf ("SSE3"); break;
16339 case GNU_PROPERTY_X86_ISA_1_SSSE3: printf ("SSSE3"); break;
16340 case GNU_PROPERTY_X86_ISA_1_SSE4_1: printf ("SSE4_1"); break;
16341 case GNU_PROPERTY_X86_ISA_1_SSE4_2: printf ("SSE4_2"); break;
16342 case GNU_PROPERTY_X86_ISA_1_AVX: printf ("AVX"); break;
16343 case GNU_PROPERTY_X86_ISA_1_AVX2: printf ("AVX2"); break;
16344 case GNU_PROPERTY_X86_ISA_1_AVX512F: printf ("AVX512F"); break;
16345 case GNU_PROPERTY_X86_ISA_1_AVX512CD: printf ("AVX512CD"); break;
16346 case GNU_PROPERTY_X86_ISA_1_AVX512ER: printf ("AVX512ER"); break;
16347 case GNU_PROPERTY_X86_ISA_1_AVX512PF: printf ("AVX512PF"); break;
16348 case GNU_PROPERTY_X86_ISA_1_AVX512VL: printf ("AVX512VL"); break;
16349 case GNU_PROPERTY_X86_ISA_1_AVX512DQ: printf ("AVX512DQ"); break;
16350 case GNU_PROPERTY_X86_ISA_1_AVX512BW: printf ("AVX512BW"); break;
1fc87489 16351 default: printf (_("<unknown: %x>"), bit); break;
9ef920e9
NC		 16352 }
16353 if (bitmask)
16354 printf (", ");
16355 }
16356}
16357
ee2fdd6f
L		 16358static void
16359decode_x86_feature (unsigned int type, unsigned int bitmask)
16360{
16361 while (bitmask)
16362 {
16363 unsigned int bit = bitmask & (- bitmask);
16364
16365 bitmask &= ~ bit;
16366 switch (bit)
16367 {
16368 case GNU_PROPERTY_X86_FEATURE_1_IBT:
16369 switch (type)
16370 {
16371 case GNU_PROPERTY_X86_FEATURE_1_AND:
16372 printf ("IBT");
16373 break;
16374 default:
16375 /* This should never happen. */
16376 abort ();
16377 }
16378 break;
48580982
L		 16379 case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
16380 switch (type)
16381 {
16382 case GNU_PROPERTY_X86_FEATURE_1_AND:
16383 printf ("SHSTK");
16384 break;
16385 default:
16386 /* This should never happen. */
16387 abort ();
16388 }
16389 break;
ee2fdd6f
L		 16390 default:
16391 printf (_("<unknown: %x>"), bit);
16392 break;
16393 }
16394 if (bitmask)
16395 printf (", ");
16396 }
16397}
16398
9ef920e9
NC		 16399static void
16400print_gnu_property_note (Elf_Internal_Note * pnote)
16401{
16402 unsigned char * ptr = (unsigned char *) pnote->descdata;
16403 unsigned char * ptr_end = ptr + pnote->descsz;
16404 unsigned int size = is_32bit_elf ? 4 : 8;
16405
16406 printf (_(" Properties: "));
16407
1fc87489 16408 if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
9ef920e9
NC		 16409 {
16410 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
16411 return;
16412 }
16413
1fc87489 16414 while (1)
9ef920e9 16415 {
1fc87489
L		 16416 unsigned int j;
16417 unsigned int type = byte_get (ptr, 4);
16418 unsigned int datasz = byte_get (ptr + 4, 4);
9ef920e9 16419
1fc87489 16420 ptr += 8;
9ef920e9 16421
1fc87489 16422 if ((ptr + datasz) > ptr_end)
9ef920e9 16423 {
1fc87489
L		 16424 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16425 type, datasz);
9ef920e9 16426 break;
1fc87489 16427 }
9ef920e9 16428
1fc87489
L		 16429 if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
16430 {
16431 if (elf_header.e_machine == EM_X86_64
16432 || elf_header.e_machine == EM_IAMCU
16433 || elf_header.e_machine == EM_386)
16434 {
16435 switch (type)
16436 {
16437 case GNU_PROPERTY_X86_ISA_1_USED:
16438 printf ("x86 ISA used: ");
16439 if (datasz != 4)
16440 printf (_("<corrupt length: %#x> "), datasz);
16441 else
16442 decode_x86_isa (byte_get (ptr, 4));
16443 goto next;
9ef920e9 16444
1fc87489
L		 16445 case GNU_PROPERTY_X86_ISA_1_NEEDED:
16446 printf ("x86 ISA needed: ");
16447 if (datasz != 4)
16448 printf (_("<corrupt length: %#x> "), datasz);
16449 else
16450 decode_x86_isa (byte_get (ptr, 4));
16451 goto next;
9ef920e9 16452
ee2fdd6f
L		 16453 case GNU_PROPERTY_X86_FEATURE_1_AND:
16454 printf ("x86 feature: ");
16455 if (datasz != 4)
16456 printf (_("<corrupt length: %#x> "), datasz);
16457 else
16458 decode_x86_feature (type, byte_get (ptr, 4));
16459 goto next;
16460
1fc87489
L		 16461 default:
16462 break;
16463 }
16464 }
16465 }
16466 else
16467 {
16468 switch (type)
9ef920e9 16469 {
1fc87489
L		 16470 case GNU_PROPERTY_STACK_SIZE:
16471 printf (_("stack size: "));
16472 if (datasz != size)
16473 printf (_("<corrupt length: %#x> "), datasz);
16474 else
16475 printf ("%#lx", (unsigned long) byte_get (ptr, size));
16476 goto next;
16477
16478 case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
16479 printf ("no copy on protected ");
16480 if (datasz)
16481 printf (_("<corrupt length: %#x> "), datasz);
16482 goto next;
16483
16484 default:
9ef920e9
NC		 16485 break;
16486 }
9ef920e9
NC		 16487 }
16488
1fc87489
L		 16489 if (type < GNU_PROPERTY_LOPROC)
16490 printf (_("<unknown type %#x data: "), type);
16491 else if (type < GNU_PROPERTY_LOUSER)
16492 printf (_("<procesor-specific type %#x data: "), type);
16493 else
16494 printf (_("<application-specific type %#x data: "), type);
16495 for (j = 0; j < datasz; ++j)
16496 printf ("%02x ", ptr[j] & 0xff);
16497 printf (">");
16498
16499next:
9ef920e9 16500 ptr += ((datasz + (size - 1)) & ~ (size - 1));
1fc87489
L		 16501 if (ptr == ptr_end)
16502 break;
16503 else
9ef920e9
NC		 16504 {
16505 if (do_wide)
16506 printf (", ");
16507 else
16508 printf ("\n\t");
16509 }
1fc87489
L		 16510
16511 if (ptr > (ptr_end - 8))
16512 {
16513 printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
16514 break;
16515 }
9ef920e9
NC		 16516 }
16517
16518 printf ("\n");
16519}
16520
32ec8896 16521static bfd_boolean
664f90a3
TT		 16522print_gnu_note (Elf_Internal_Note *pnote)
16523{
1449284b 16524 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
664f90a3
TT		 16525 switch (pnote->type)
16526 {
16527 case NT_GNU_BUILD_ID:
16528 {
16529 unsigned long i;
16530
16531 printf (_(" Build ID: "));
16532 for (i = 0; i < pnote->descsz; ++i)
16533 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 16534 printf ("\n");
664f90a3
TT		 16535 }
16536 break;
16537
16538 case NT_GNU_ABI_TAG:
16539 {
16540 unsigned long os, major, minor, subminor;
16541 const char *osname;
16542
3102e897
NC		 16543 /* PR 17531: file: 030-599401-0.004. */
16544 if (pnote->descsz < 16)
16545 {
16546 printf (_(" <corrupt GNU_ABI_TAG>\n"));
16547 break;
16548 }
16549
664f90a3
TT		 16550 os = byte_get ((unsigned char *) pnote->descdata, 4);
16551 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
16552 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
16553 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
16554
16555 switch (os)
16556 {
16557 case GNU_ABI_TAG_LINUX:
16558 osname = "Linux";
16559 break;
16560 case GNU_ABI_TAG_HURD:
16561 osname = "Hurd";
16562 break;
16563 case GNU_ABI_TAG_SOLARIS:
16564 osname = "Solaris";
16565 break;
16566 case GNU_ABI_TAG_FREEBSD:
16567 osname = "FreeBSD";
16568 break;
16569 case GNU_ABI_TAG_NETBSD:
16570 osname = "NetBSD";
16571 break;
14ae95f2
RM		 16572 case GNU_ABI_TAG_SYLLABLE:
16573 osname = "Syllable";
16574 break;
16575 case GNU_ABI_TAG_NACL:
16576 osname = "NaCl";
16577 break;
664f90a3
TT		 16578 default:
16579 osname = "Unknown";
16580 break;
16581 }
16582
16583 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
16584 major, minor, subminor);
16585 }
16586 break;
926c5385
CC		 16587
16588 case NT_GNU_GOLD_VERSION:
16589 {
16590 unsigned long i;
16591
16592 printf (_(" Version: "));
16593 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
16594 printf ("%c", pnote->descdata[i]);
16595 printf ("\n");
16596 }
16597 break;
1449284b
NC		 16598
16599 case NT_GNU_HWCAP:
16600 {
16601 unsigned long num_entries, mask;
16602
16603 /* Hardware capabilities information. Word 0 is the number of entries.
16604 Word 1 is a bitmask of enabled entries. The rest of the descriptor
16605 is a series of entries, where each entry is a single byte followed
16606 by a nul terminated string. The byte gives the bit number to test
16607 if enabled in the bitmask. */
16608 printf (_(" Hardware Capabilities: "));
16609 if (pnote->descsz < 8)
16610 {
32ec8896
NC		 16611 error (_("<corrupt GNU_HWCAP>\n"));
16612 return FALSE;
1449284b
NC		 16613 }
16614 num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
16615 mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
16616 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
16617 /* FIXME: Add code to display the entries... */
16618 }
16619 break;
16620
9ef920e9
NC		 16621 case NT_GNU_PROPERTY_TYPE_0:
16622 print_gnu_property_note (pnote);
16623 break;
16624
1449284b
NC		 16625 default:
16626 /* Handle unrecognised types. An error message should have already been
16627 created by get_gnu_elf_note_type(), so all that we need to do is to
16628 display the data. */
16629 {
16630 unsigned long i;
16631
16632 printf (_(" Description data: "));
16633 for (i = 0; i < pnote->descsz; ++i)
16634 printf ("%02x ", pnote->descdata[i] & 0xff);
16635 printf ("\n");
16636 }
16637 break;
664f90a3
TT		 16638 }
16639
32ec8896 16640 return TRUE;
664f90a3
TT		 16641}
16642
685080f2
NC		 16643static const char *
16644get_v850_elf_note_type (enum v850_notes n_type)
16645{
16646 static char buff[64];
16647
16648 switch (n_type)
16649 {
16650 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
16651 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
16652 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
16653 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
16654 case V850_NOTE_CACHE_INFO: return _("Use of cache");
16655 case V850_NOTE_MMU_INFO: return _("Use of MMU");
16656 default:
16657 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
16658 return buff;
16659 }
16660}
16661
32ec8896 16662static bfd_boolean
685080f2
NC		 16663print_v850_note (Elf_Internal_Note * pnote)
16664{
16665 unsigned int val;
16666
16667 if (pnote->descsz != 4)
32ec8896
NC		 16668 return FALSE;
16669
685080f2
NC		 16670 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
16671
16672 if (val == 0)
16673 {
16674 printf (_("not set\n"));
32ec8896 16675 return TRUE;
685080f2
NC		 16676 }
16677
16678 switch (pnote->type)
16679 {
16680 case V850_NOTE_ALIGNMENT:
16681 switch (val)
16682 {
32ec8896
NC		 16683 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
16684 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
685080f2
NC		 16685 }
16686 break;
14ae95f2 16687
685080f2
NC		 16688 case V850_NOTE_DATA_SIZE:
16689 switch (val)
16690 {
32ec8896
NC		 16691 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
16692 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
685080f2
NC		 16693 }
16694 break;
14ae95f2 16695
685080f2
NC		 16696 case V850_NOTE_FPU_INFO:
16697 switch (val)
16698 {
32ec8896
NC		 16699 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
16700 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
685080f2
NC		 16701 }
16702 break;
14ae95f2 16703
685080f2
NC		 16704 case V850_NOTE_MMU_INFO:
16705 case V850_NOTE_CACHE_INFO:
16706 case V850_NOTE_SIMD_INFO:
16707 if (val == EF_RH850_SIMD)
16708 {
16709 printf (_("yes\n"));
32ec8896 16710 return TRUE;
685080f2
NC		 16711 }
16712 break;
16713
16714 default:
16715 /* An 'unknown note type' message will already have been displayed. */
16716 break;
16717 }
16718
16719 printf (_("unknown value: %x\n"), val);
32ec8896 16720 return FALSE;
685080f2
NC		 16721}
16722
32ec8896 16723static bfd_boolean
c6056a74
SF		 16724process_netbsd_elf_note (Elf_Internal_Note * pnote)
16725{
16726 unsigned int version;
16727
16728 switch (pnote->type)
16729 {
16730 case NT_NETBSD_IDENT:
16731 version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
16732 if ((version / 10000) % 100)
16733 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
16734 version, version / 100000000, (version / 1000000) % 100,
16735 (version / 10000) % 100 > 26 ? "Z" : "",
15f205b1 16736 'A' + (version / 10000) % 26);
c6056a74
SF		 16737 else
16738 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
16739 version, version / 100000000, (version / 1000000) % 100,
15f205b1 16740 (version / 100) % 100);
32ec8896 16741 return TRUE;
c6056a74
SF		 16742
16743 case NT_NETBSD_MARCH:
16744 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
16745 pnote->descdata);
32ec8896 16746 return TRUE;
c6056a74
SF		 16747
16748 default:
32ec8896
NC		 16749 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
16750 pnote->type);
16751 return FALSE;
c6056a74 16752 }
c6056a74
SF		 16753}
16754
f4ddf30f
JB		 16755static const char *
16756get_freebsd_elfcore_note_type (unsigned e_type)
16757{
f4ddf30f
JB		 16758 switch (e_type)
16759 {
16760 case NT_FREEBSD_THRMISC:
16761 return _("NT_THRMISC (thrmisc structure)");
16762 case NT_FREEBSD_PROCSTAT_PROC:
16763 return _("NT_PROCSTAT_PROC (proc data)");
16764 case NT_FREEBSD_PROCSTAT_FILES:
16765 return _("NT_PROCSTAT_FILES (files data)");
16766 case NT_FREEBSD_PROCSTAT_VMMAP:
16767 return _("NT_PROCSTAT_VMMAP (vmmap data)");
16768 case NT_FREEBSD_PROCSTAT_GROUPS:
16769 return _("NT_PROCSTAT_GROUPS (groups data)");
16770 case NT_FREEBSD_PROCSTAT_UMASK:
16771 return _("NT_PROCSTAT_UMASK (umask data)");
16772 case NT_FREEBSD_PROCSTAT_RLIMIT:
16773 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
16774 case NT_FREEBSD_PROCSTAT_OSREL:
16775 return _("NT_PROCSTAT_OSREL (osreldate data)");
16776 case NT_FREEBSD_PROCSTAT_PSSTRINGS:
16777 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
16778 case NT_FREEBSD_PROCSTAT_AUXV:
16779 return _("NT_PROCSTAT_AUXV (auxv data)");
16780 }
16781 return get_note_type (e_type);
16782}
16783
9437c45b 16784static const char *
d3ba0551 16785get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 16786{
16787 static char buff[64];
16788
b4db1224 16789 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 16790 {
16791 /* NetBSD core "procinfo" structure. */
16792 return _("NetBSD procinfo structure");
16793 }
16794
16795 /* As of Jan 2002 there are no other machine-independent notes
16796 defined for NetBSD core files. If the note type is less
16797 than the start of the machine-dependent note types, we don't
16798 understand it. */
16799
b4db1224 16800 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 16801 {
e9e44622 16802 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 16803 return buff;
16804 }
16805
16806 switch (elf_header.e_machine)
16807 {
16808 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
16809 and PT_GETFPREGS == mach+2. */
16810
16811 case EM_OLD_ALPHA:
16812 case EM_ALPHA:
16813 case EM_SPARC:
16814 case EM_SPARC32PLUS:
16815 case EM_SPARCV9:
16816 switch (e_type)
16817 {
2b692964 16818 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 16819 return _("PT_GETREGS (reg structure)");
2b692964 16820 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 16821 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 16822 default:
16823 break;
16824 }
16825 break;
16826
16827 /* On all other arch's, PT_GETREGS == mach+1 and
16828 PT_GETFPREGS == mach+3. */
16829 default:
16830 switch (e_type)
16831 {
2b692964 16832 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 16833 return _("PT_GETREGS (reg structure)");
2b692964 16834 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 16835 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 16836 default:
16837 break;
16838 }
16839 }
16840
9cf03b7e 16841 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 16842 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 16843 return buff;
16844}
16845
70616151
TT		 16846static const char *
16847get_stapsdt_note_type (unsigned e_type)
16848{
16849 static char buff[64];
16850
16851 switch (e_type)
16852 {
16853 case NT_STAPSDT:
16854 return _("NT_STAPSDT (SystemTap probe descriptors)");
16855
16856 default:
16857 break;
16858 }
16859
16860 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16861 return buff;
16862}
16863
32ec8896 16864static bfd_boolean
c6a9fc58
TT		 16865print_stapsdt_note (Elf_Internal_Note *pnote)
16866{
16867 int addr_size = is_32bit_elf ? 4 : 8;
16868 char *data = pnote->descdata;
16869 char *data_end = pnote->descdata + pnote->descsz;
16870 bfd_vma pc, base_addr, semaphore;
16871 char *provider, *probe, *arg_fmt;
16872
16873 pc = byte_get ((unsigned char *) data, addr_size);
16874 data += addr_size;
16875 base_addr = byte_get ((unsigned char *) data, addr_size);
16876 data += addr_size;
16877 semaphore = byte_get ((unsigned char *) data, addr_size);
16878 data += addr_size;
16879
16880 provider = data;
16881 data += strlen (data) + 1;
16882 probe = data;
16883 data += strlen (data) + 1;
16884 arg_fmt = data;
16885 data += strlen (data) + 1;
16886
16887 printf (_(" Provider: %s\n"), provider);
16888 printf (_(" Name: %s\n"), probe);
16889 printf (_(" Location: "));
16890 print_vma (pc, FULL_HEX);
16891 printf (_(", Base: "));
16892 print_vma (base_addr, FULL_HEX);
16893 printf (_(", Semaphore: "));
16894 print_vma (semaphore, FULL_HEX);
9cf03b7e 16895 printf ("\n");
c6a9fc58
TT		 16896 printf (_(" Arguments: %s\n"), arg_fmt);
16897
16898 return data == data_end;
16899}
16900
00e98fc7
TG		 16901static const char *
16902get_ia64_vms_note_type (unsigned e_type)
16903{
16904 static char buff[64];
16905
16906 switch (e_type)
16907 {
16908 case NT_VMS_MHD:
16909 return _("NT_VMS_MHD (module header)");
16910 case NT_VMS_LNM:
16911 return _("NT_VMS_LNM (language name)");
16912 case NT_VMS_SRC:
16913 return _("NT_VMS_SRC (source files)");
16914 case NT_VMS_TITLE:
9cf03b7e 16915 return "NT_VMS_TITLE";
00e98fc7
TG		 16916 case NT_VMS_EIDC:
16917 return _("NT_VMS_EIDC (consistency check)");
16918 case NT_VMS_FPMODE:
16919 return _("NT_VMS_FPMODE (FP mode)");
16920 case NT_VMS_LINKTIME:
9cf03b7e 16921 return "NT_VMS_LINKTIME";
00e98fc7
TG		 16922 case NT_VMS_IMGNAM:
16923 return _("NT_VMS_IMGNAM (image name)");
16924 case NT_VMS_IMGID:
16925 return _("NT_VMS_IMGID (image id)");
16926 case NT_VMS_LINKID:
16927 return _("NT_VMS_LINKID (link id)");
16928 case NT_VMS_IMGBID:
16929 return _("NT_VMS_IMGBID (build id)");
16930 case NT_VMS_GSTNAM:
16931 return _("NT_VMS_GSTNAM (sym table name)");
16932 case NT_VMS_ORIG_DYN:
9cf03b7e 16933 return "NT_VMS_ORIG_DYN";
00e98fc7 16934 case NT_VMS_PATCHTIME:
9cf03b7e 16935 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 16936 default:
16937 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16938 return buff;
16939 }
16940}
16941
32ec8896 16942static bfd_boolean
00e98fc7
TG		 16943print_ia64_vms_note (Elf_Internal_Note * pnote)
16944{
16945 switch (pnote->type)
16946 {
16947 case NT_VMS_MHD:
16948 if (pnote->descsz > 36)
16949 {
16950 size_t l = strlen (pnote->descdata + 34);
16951 printf (_(" Creation date : %.17s\n"), pnote->descdata);
16952 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
16953 printf (_(" Module name : %s\n"), pnote->descdata + 34);
16954 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
16955 }
16956 else
16957 printf (_(" Invalid size\n"));
16958 break;
16959 case NT_VMS_LNM:
16960 printf (_(" Language: %s\n"), pnote->descdata);
16961 break;
16962#ifdef BFD64
16963 case NT_VMS_FPMODE:
9cf03b7e 16964 printf (_(" Floating Point mode: "));
4a5cb34f 16965 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 16966 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
00e98fc7
TG		 16967 break;
16968 case NT_VMS_LINKTIME:
16969 printf (_(" Link time: "));
16970 print_vms_time
16971 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
16972 printf ("\n");
16973 break;
16974 case NT_VMS_PATCHTIME:
16975 printf (_(" Patch time: "));
16976 print_vms_time
16977 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
16978 printf ("\n");
16979 break;
16980 case NT_VMS_ORIG_DYN:
16981 printf (_(" Major id: %u, minor id: %u\n"),
16982 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
16983 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 16984 printf (_(" Last modified : "));
00e98fc7
TG		 16985 print_vms_time
16986 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 16987 printf (_("\n Link flags : "));
4a5cb34f 16988 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 16989 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
00e98fc7 16990 printf (_(" Header flags: 0x%08x\n"),
948f632f 16991 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
00e98fc7
TG		 16992 printf (_(" Image id : %s\n"), pnote->descdata + 32);
16993 break;
16994#endif
16995 case NT_VMS_IMGNAM:
16996 printf (_(" Image name: %s\n"), pnote->descdata);
16997 break;
16998 case NT_VMS_GSTNAM:
16999 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
17000 break;
17001 case NT_VMS_IMGID:
17002 printf (_(" Image id: %s\n"), pnote->descdata);
17003 break;
17004 case NT_VMS_LINKID:
17005 printf (_(" Linker id: %s\n"), pnote->descdata);
17006 break;
17007 default:
32ec8896 17008 return FALSE;
00e98fc7 17009 }
32ec8896 17010 return TRUE;
00e98fc7
TG		 17011}
17012
c799a79d
NC		 17013/* Print the name of the symbol associated with a build attribute
17014 that is attached to address OFFSET. */
17015
9ef920e9 17016static bfd_boolean
c799a79d
NC		 17017print_symbol_for_build_attribute (FILE * file,
17018 unsigned long offset,
17019 bfd_boolean is_open_attr)
9ef920e9 17020{
c799a79d
NC		 17021 static FILE * saved_file = NULL;
17022 static char * strtab;
17023 static unsigned long strtablen;
17024 static Elf_Internal_Sym * symtab;
17025 static unsigned long nsyms;
7296a62a
NC		 17026 Elf_Internal_Sym * saved_sym = NULL;
17027 Elf_Internal_Sym * sym;
9ef920e9 17028
7296a62a
NC		 17029 if (section_headers != NULL
17030 && (saved_file == NULL || file != saved_file))
9ef920e9 17031 {
c799a79d 17032 Elf_Internal_Shdr * symsec;
9ef920e9 17033
c799a79d
NC		 17034 /* Load the symbol and string sections. */
17035 for (symsec = section_headers;
17036 symsec < section_headers + elf_header.e_shnum;
17037 symsec ++)
9ef920e9 17038 {
c799a79d 17039 if (symsec->sh_type == SHT_SYMTAB)
9ef920e9 17040 {
c799a79d 17041 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
9ef920e9 17042
c799a79d
NC		 17043 if (symsec->sh_link < elf_header.e_shnum)
17044 {
17045 Elf_Internal_Shdr * strtab_sec = section_headers + symsec->sh_link;
17046
17047 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
17048 1, strtab_sec->sh_size,
17049 _("string table"));
17050 strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
17051 }
9ef920e9
NC		 17052 }
17053 }
c799a79d 17054 saved_file = file;
9ef920e9
NC		 17055 }
17056
c799a79d 17057 if (symtab == NULL || strtab == NULL)
9ef920e9 17058 {
c799a79d
NC		 17059 printf ("\n");
17060 return FALSE;
17061 }
9ef920e9 17062
c799a79d
NC		 17063 /* Find a symbol whose value matches offset. */
17064 for (sym = symtab; sym < symtab + nsyms; sym ++)
17065 if (sym->st_value == offset)
17066 {
17067 if (sym->st_name >= strtablen)
17068 /* Huh ? This should not happen. */
17069 continue;
9ef920e9 17070
c799a79d
NC		 17071 if (strtab[sym->st_name] == 0)
17072 continue;
9ef920e9 17073
c799a79d
NC		 17074 if (is_open_attr)
17075 {
17076 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17077 and FILE or OBJECT symbols over NOTYPE symbols. We skip
17078 FUNC symbols entirely. */
17079 switch (ELF_ST_TYPE (sym->st_info))
17080 {
17081 case STT_FILE:
17082 saved_sym = sym;
17083 /* We can stop searching now. */
17084 sym = symtab + nsyms;
17085 continue;
9ef920e9 17086
c799a79d
NC		 17087 case STT_OBJECT:
17088 saved_sym = sym;
17089 continue;
9ef920e9 17090
c799a79d
NC		 17091 case STT_FUNC:
17092 /* Ignore function symbols. */
17093 continue;
17094
17095 default:
17096 break;
17097 }
17098
17099 switch (ELF_ST_BIND (sym->st_info))
9ef920e9 17100 {
c799a79d
NC		 17101 case STB_GLOBAL:
17102 if (saved_sym == NULL
17103 || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
17104 saved_sym = sym;
17105 break;
c871dade 17106
c799a79d
NC		 17107 case STB_LOCAL:
17108 if (saved_sym == NULL)
17109 saved_sym = sym;
17110 break;
17111
17112 default:
9ef920e9
NC		 17113 break;
17114 }
17115 }
c799a79d
NC		 17116 else
17117 {
17118 if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
17119 continue;
17120
17121 saved_sym = sym;
17122 break;
17123 }
17124 }
17125
17126 printf (" (%s: %s)\n",
17127 is_open_attr ? _("file") : _("func"),
17128 saved_sym ? strtab + saved_sym->st_name : _("<no symbol found>)"));
17129 return TRUE;
17130}
17131
17132static bfd_boolean
17133print_gnu_build_attribute_description (Elf_Internal_Note * pnote,
17134 FILE * file)
17135{
17136 static unsigned long global_offset = 0;
17137 unsigned long offset;
17138 unsigned int desc_size = is_32bit_elf ? 4 : 8;
17139 bfd_boolean is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
c871dade 17140
c799a79d
NC		 17141 if (pnote->descsz == 0)
17142 {
17143 if (is_open_attr)
c871dade 17144 {
c799a79d
NC		 17145 printf (_(" Applies from offset %#lx\n"), global_offset);
17146 return TRUE;
17147 }
17148 else
17149 {
17150 printf (_(" Applies to func at %#lx"), global_offset);
17151 return print_symbol_for_build_attribute (file, global_offset, is_open_attr);
c871dade 17152 }
9ef920e9
NC		 17153 }
17154
c799a79d
NC		 17155 if (pnote->descsz != desc_size)
17156 {
17157 error (_(" <invalid description size: %lx>\n"), pnote->descsz);
17158 printf (_(" <invalid descsz>"));
17159 return FALSE;
17160 }
17161
17162 offset = byte_get ((unsigned char *) pnote->descdata, desc_size);
17163
17164 if (is_open_attr)
17165 {
17166 printf (_(" Applies from offset %#lx"), offset);
17167 global_offset = offset;
17168 }
17169 else
17170 {
17171 printf (_(" Applies to func at %#lx"), offset);
17172 }
17173
17174 return print_symbol_for_build_attribute (file, offset, is_open_attr);
9ef920e9
NC		 17175}
17176
17177static bfd_boolean
17178print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
17179{
1d15e434
NC		 17180 static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
17181 static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
17182 static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
9ef920e9
NC		 17183 char name_type;
17184 char name_attribute;
1d15e434 17185 const char * expected_types;
9ef920e9
NC		 17186 const char * name = pnote->namedata;
17187 const char * text;
88305e1b 17188 signed int left;
9ef920e9
NC		 17189
17190 if (name == NULL || pnote->namesz < 2)
17191 {
17192 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
7296a62a 17193 print_symbol (-20, _(" <corrupt name>"));
9ef920e9
NC		 17194 return FALSE;
17195 }
17196
88305e1b
NC		 17197 left = 20;
17198
17199 /* Version 2 of the spec adds a "GA" prefix to the name field. */
17200 if (name[0] == 'G' && name[1] == 'A')
17201 {
17202 printf ("GA");
17203 name += 2;
17204 left -= 2;
17205 }
17206
9ef920e9
NC		 17207 switch ((name_type = * name))
17208 {
17209 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17210 case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17211 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17212 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17213 printf ("%c", * name);
88305e1b 17214 left --;
9ef920e9
NC		 17215 break;
17216 default:
17217 error (_("unrecognised attribute type in name field: %d\n"), name_type);
17218 print_symbol (-20, _("<unknown name type>"));
17219 return FALSE;
17220 }
17221
9ef920e9
NC		 17222 ++ name;
17223 text = NULL;
17224
17225 switch ((name_attribute = * name))
17226 {
17227 case GNU_BUILD_ATTRIBUTE_VERSION:
17228 text = _("<version>");
1d15e434 17229 expected_types = string_expected;
9ef920e9
NC		 17230 ++ name;
17231 break;
17232 case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17233 text = _("<stack prot>");
75d7d298 17234 expected_types = "!+*";
9ef920e9
NC		 17235 ++ name;
17236 break;
17237 case GNU_BUILD_ATTRIBUTE_RELRO:
17238 text = _("<relro>");
1d15e434 17239 expected_types = bool_expected;
9ef920e9
NC		 17240 ++ name;
17241 break;
17242 case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
17243 text = _("<stack size>");
1d15e434 17244 expected_types = number_expected;
9ef920e9
NC		 17245 ++ name;
17246 break;
17247 case GNU_BUILD_ATTRIBUTE_TOOL:
17248 text = _("<tool>");
1d15e434 17249 expected_types = string_expected;
9ef920e9
NC		 17250 ++ name;
17251 break;
17252 case GNU_BUILD_ATTRIBUTE_ABI:
17253 text = _("<ABI>");
17254 expected_types = "$*";
17255 ++ name;
17256 break;
17257 case GNU_BUILD_ATTRIBUTE_PIC:
17258 text = _("<PIC>");
1d15e434 17259 expected_types = number_expected;
9ef920e9
NC		 17260 ++ name;
17261 break;
a8be5506
NC		 17262 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
17263 text = _("<short enum>");
1d15e434 17264 expected_types = bool_expected;
a8be5506
NC		 17265 ++ name;
17266 break;
9ef920e9
NC		 17267 default:
17268 if (ISPRINT (* name))
17269 {
17270 int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
17271
17272 if (len > left && ! do_wide)
17273 len = left;
75d7d298 17274 printf ("%.*s:", len, name);
9ef920e9 17275 left -= len;
0dd6ae21 17276 name += len;
9ef920e9
NC		 17277 }
17278 else
17279 {
3e6b6445 17280 static char tmpbuf [128];
88305e1b 17281
3e6b6445
NC		 17282 error (_("unrecognised byte in name field: %d\n"), * name);
17283 sprintf (tmpbuf, _("<unknown:_%d>"), * name);
17284 text = tmpbuf;
17285 name ++;
9ef920e9
NC		 17286 }
17287 expected_types = "*$!+";
17288 break;
17289 }
17290
17291 if (text)
88305e1b 17292 left -= printf ("%s", text);
9ef920e9
NC		 17293
17294 if (strchr (expected_types, name_type) == NULL)
75d7d298 17295 warn (_("attribute does not have an expected type (%c)\n"), name_type);
9ef920e9
NC		 17296
17297 if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
17298 {
17299 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17300 (unsigned long) pnote->namesz,
17301 (long) (name - pnote->namedata));
17302 return FALSE;
17303 }
17304
17305 if (left < 1 && ! do_wide)
17306 return TRUE;
17307
17308 switch (name_type)
17309 {
17310 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17311 {
b06b2c92 17312 unsigned int bytes;
ddef72cd
NC		 17313 unsigned long long val = 0;
17314 unsigned int shift = 0;
17315 char * decoded = NULL;
17316
b06b2c92
NC		 17317 bytes = pnote->namesz - (name - pnote->namedata);
17318 if (bytes > 0)
17319 /* The -1 is because the name field is always 0 terminated, and we
17320 want to be able to ensure that the shift in the while loop below
17321 will not overflow. */
17322 -- bytes;
17323
ddef72cd
NC		 17324 if (bytes > sizeof (val))
17325 {
b06b2c92
NC		 17326 fprintf (stderr, "namesz %lx name %p namedata %p\n",
17327 pnote->namesz, name, pnote->namedata);
3e6b6445
NC		 17328 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
17329 bytes);
17330 bytes = sizeof (val);
ddef72cd 17331 }
3e6b6445
NC		 17332 /* We do not bother to warn if bytes == 0 as this can
17333 happen with some early versions of the gcc plugin. */
9ef920e9
NC		 17334
17335 while (bytes --)
17336 {
79a964dc
NC		 17337 unsigned long byte = (* name ++) & 0xff;
17338
17339 val |= byte << shift;
9ef920e9
NC		 17340 shift += 8;
17341 }
17342
75d7d298 17343 switch (name_attribute)
9ef920e9 17344 {
75d7d298 17345 case GNU_BUILD_ATTRIBUTE_PIC:
9ef920e9
NC		 17346 switch (val)
17347 {
75d7d298
NC		 17348 case 0: decoded = "static"; break;
17349 case 1: decoded = "pic"; break;
17350 case 2: decoded = "PIC"; break;
17351 case 3: decoded = "pie"; break;
17352 case 4: decoded = "PIE"; break;
17353 default: break;
9ef920e9 17354 }
75d7d298
NC		 17355 break;
17356 case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17357 switch (val)
9ef920e9 17358 {
75d7d298
NC		 17359 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
17360 case 0: decoded = "off"; break;
17361 case 1: decoded = "on"; break;
17362 case 2: decoded = "all"; break;
17363 case 3: decoded = "strong"; break;
17364 case 4: decoded = "explicit"; break;
17365 default: break;
9ef920e9 17366 }
75d7d298
NC		 17367 break;
17368 default:
17369 break;
9ef920e9
NC		 17370 }
17371
75d7d298 17372 if (decoded != NULL)
3e6b6445
NC		 17373 {
17374 print_symbol (-left, decoded);
17375 left = 0;
17376 }
17377 else if (val == 0)
17378 {
17379 printf ("0x0");
17380 left -= 3;
17381 }
9ef920e9 17382 else
75d7d298
NC		 17383 {
17384 if (do_wide)
ddef72cd 17385 left -= printf ("0x%llx", val);
75d7d298 17386 else
ddef72cd 17387 left -= printf ("0x%-.*llx", left, val);
75d7d298 17388 }
9ef920e9
NC		 17389 }
17390 break;
17391 case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17392 left -= print_symbol (- left, name);
17393 break;
17394 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17395 left -= print_symbol (- left, "true");
17396 break;
17397 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17398 left -= print_symbol (- left, "false");
17399 break;
17400 }
17401
17402 if (do_wide && left > 0)
17403 printf ("%-*s", left, " ");
17404
17405 return TRUE;
17406}
17407
6d118b09
NC		 17408/* Note that by the ELF standard, the name field is already null byte
17409 terminated, and namesz includes the terminating null byte.
17410 I.E. the value of namesz for the name "FSF" is 4.
17411
e3c8793a 17412 If the value of namesz is zero, there is no name present. */
9ef920e9 17413
32ec8896 17414static bfd_boolean
9ef920e9 17415process_note (Elf_Internal_Note * pnote,
c799a79d 17416 FILE * file)
779fe533 17417{
2cf0635d
NC		 17418 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
17419 const char * nt;
9437c45b
JT		 17420
17421 if (pnote->namesz == 0)
1ec5cd37
NC		 17422 /* If there is no note name, then use the default set of
17423 note type strings. */
17424 nt = get_note_type (pnote->type);
17425
1118d252
RM		 17426 else if (const_strneq (pnote->namedata, "GNU"))
17427 /* GNU-specific object file notes. */
17428 nt = get_gnu_elf_note_type (pnote->type);
f4ddf30f
JB		 17429
17430 else if (const_strneq (pnote->namedata, "FreeBSD"))
17431 /* FreeBSD-specific core file notes. */
17432 nt = get_freebsd_elfcore_note_type (pnote->type);
1118d252 17433
0112cd26 17434 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 17435 /* NetBSD-specific core file notes. */
17436 nt = get_netbsd_elfcore_note_type (pnote->type);
17437
c6056a74
SF		 17438 else if (const_strneq (pnote->namedata, "NetBSD"))
17439 /* NetBSD-specific core file notes. */
17440 return process_netbsd_elf_note (pnote);
17441
b15fa79e
AM		 17442 else if (strneq (pnote->namedata, "SPU/", 4))
17443 {
17444 /* SPU-specific core file notes. */
17445 nt = pnote->namedata + 4;
17446 name = "SPU";
17447 }
17448
00e98fc7
TG		 17449 else if (const_strneq (pnote->namedata, "IPF/VMS"))
17450 /* VMS/ia64-specific file notes. */
17451 nt = get_ia64_vms_note_type (pnote->type);
17452
70616151
TT		 17453 else if (const_strneq (pnote->namedata, "stapsdt"))
17454 nt = get_stapsdt_note_type (pnote->type);
17455
9437c45b 17456 else
1ec5cd37
NC		 17457 /* Don't recognize this note name; just use the default set of
17458 note type strings. */
00e98fc7 17459 nt = get_note_type (pnote->type);
9437c45b 17460
1449284b 17461 printf (" ");
9ef920e9
NC		 17462
17463 if (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17464 || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC)
17465 print_gnu_build_attribute_name (pnote);
17466 else
17467 print_symbol (-20, name);
17468
17469 if (do_wide)
17470 printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
17471 else
17472 printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
00e98fc7
TG		 17473
17474 if (const_strneq (pnote->namedata, "IPF/VMS"))
17475 return print_ia64_vms_note (pnote);
664f90a3
TT		 17476 else if (const_strneq (pnote->namedata, "GNU"))
17477 return print_gnu_note (pnote);
c6a9fc58
TT		 17478 else if (const_strneq (pnote->namedata, "stapsdt"))
17479 return print_stapsdt_note (pnote);
9ece1fa9
TT		 17480 else if (const_strneq (pnote->namedata, "CORE"))
17481 return print_core_note (pnote);
9ef920e9
NC		 17482 else if (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17483 || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC)
c799a79d 17484 return print_gnu_build_attribute_description (pnote, file);
779fe533 17485
9ef920e9 17486 if (pnote->descsz)
1449284b
NC		 17487 {
17488 unsigned long i;
17489
17490 printf (_(" description data: "));
17491 for (i = 0; i < pnote->descsz; i++)
17492 printf ("%02x ", pnote->descdata[i]);
1449284b
NC		 17493 }
17494
9ef920e9
NC		 17495 if (do_wide)
17496 printf ("\n");
17497
32ec8896 17498 return TRUE;
1449284b 17499}
6d118b09 17500
32ec8896 17501static bfd_boolean
1449284b
NC		 17502process_notes_at (FILE * file,
17503 Elf_Internal_Shdr * section,
17504 bfd_vma offset,
17505 bfd_vma length)
779fe533 17506{
2cf0635d
NC		 17507 Elf_External_Note * pnotes;
17508 Elf_External_Note * external;
c8071705 17509 char * end;
32ec8896 17510 bfd_boolean res = TRUE;
103f02d3 17511
779fe533 17512 if (length <= 0)
32ec8896 17513 return FALSE;
103f02d3 17514
1449284b
NC		 17515 if (section)
17516 {
17517 pnotes = (Elf_External_Note *) get_section_contents (section, file);
17518 if (pnotes)
32ec8896
NC		 17519 {
17520 if (! apply_relocations (file, section, (unsigned char *) pnotes, length, NULL, NULL))
17521 return FALSE;
17522 }
1449284b
NC		 17523 }
17524 else
17525 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
17526 _("notes"));
dd24e3da 17527 if (pnotes == NULL)
32ec8896 17528 return FALSE;
779fe533 17529
103f02d3 17530 external = pnotes;
103f02d3 17531
1449284b
NC		 17532 if (section)
17533 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section));
17534 else
17535 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
17536 (unsigned long) offset, (unsigned long) length);
17537
2aee03ae 17538 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 17539
c8071705
NC		 17540 end = (char *) pnotes + length;
17541 while ((char *) external < end)
779fe533 17542 {
b34976b6 17543 Elf_Internal_Note inote;
15b42fb0
AM		 17544 size_t min_notesz;
17545 char *next;
2cf0635d 17546 char * temp = NULL;
c8071705 17547 size_t data_remaining = end - (char *) external;
6d118b09 17548
00e98fc7 17549 if (!is_ia64_vms ())
15b42fb0 17550 {
9dd3a467
NC		 17551 /* PR binutils/15191
17552 Make sure that there is enough data to read. */
15b42fb0
AM		 17553 min_notesz = offsetof (Elf_External_Note, name);
17554 if (data_remaining < min_notesz)
9dd3a467
NC		 17555 {
17556 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17557 (int) data_remaining);
17558 break;
17559 }
15b42fb0
AM		 17560 inote.type = BYTE_GET (external->type);
17561 inote.namesz = BYTE_GET (external->namesz);
17562 inote.namedata = external->name;
17563 inote.descsz = BYTE_GET (external->descsz);
17564 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
834f871c 17565 /* PR 17531: file: 3443835e. */
c8071705 17566 if (inote.descdata < (char *) pnotes || inote.descdata > end)
834f871c 17567 {
9ef920e9
NC		 17568 warn (_("Corrupt note: name size is too big: (got: %lx, expected no more than: %lx)\n"),
17569 inote.namesz, (long)(end - inote.namedata));
834f871c
NC		 17570 inote.descdata = inote.namedata;
17571 inote.namesz = 0;
17572 }
14ae95f2 17573
15b42fb0
AM		 17574 inote.descpos = offset + (inote.descdata - (char *) pnotes);
17575 next = inote.descdata + align_power (inote.descsz, 2);
17576 }
00e98fc7 17577 else
15b42fb0
AM		 17578 {
17579 Elf64_External_VMS_Note *vms_external;
00e98fc7 17580
9dd3a467
NC		 17581 /* PR binutils/15191
17582 Make sure that there is enough data to read. */
15b42fb0
AM		 17583 min_notesz = offsetof (Elf64_External_VMS_Note, name);
17584 if (data_remaining < min_notesz)
9dd3a467
NC		 17585 {
17586 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17587 (int) data_remaining);
17588 break;
17589 }
3e55a963 17590
15b42fb0
AM		 17591 vms_external = (Elf64_External_VMS_Note *) external;
17592 inote.type = BYTE_GET (vms_external->type);
17593 inote.namesz = BYTE_GET (vms_external->namesz);
17594 inote.namedata = vms_external->name;
17595 inote.descsz = BYTE_GET (vms_external->descsz);
17596 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
17597 inote.descpos = offset + (inote.descdata - (char *) pnotes);
17598 next = inote.descdata + align_power (inote.descsz, 3);
17599 }
17600
17601 if (inote.descdata < (char *) external + min_notesz
17602 || next < (char *) external + min_notesz
5d921cbd
NC		 17603 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
17604 || inote.namedata + inote.namesz < inote.namedata
17605 || inote.descdata + inote.descsz < inote.descdata
15b42fb0 17606 || data_remaining < (size_t)(next - (char *) external))
3e55a963 17607 {
15b42fb0 17608 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 17609 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 17610 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC		 17611 inote.type, inote.namesz, inote.descsz);
17612 break;
17613 }
17614
15b42fb0 17615 external = (Elf_External_Note *) next;
dd24e3da 17616
6d118b09
NC		 17617 /* Verify that name is null terminated. It appears that at least
17618 one version of Linux (RedHat 6.0) generates corefiles that don't
17619 comply with the ELF spec by failing to include the null byte in
17620 namesz. */
8b971f9f 17621 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 17622 {
3f5e193b 17623 temp = (char *) malloc (inote.namesz + 1);
6d118b09
NC		 17624 if (temp == NULL)
17625 {
8b73c356 17626 error (_("Out of memory allocating space for inote name\n"));
32ec8896 17627 res = FALSE;
6d118b09
NC		 17628 break;
17629 }
76da6bbe 17630
79a964dc 17631 memcpy (temp, inote.namedata, inote.namesz);
6d118b09 17632 temp[inote.namesz] = 0;
76da6bbe 17633
6d118b09
NC		 17634 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
17635 inote.namedata = temp;
17636 }
17637
c799a79d 17638 if (! process_note (& inote, file))
6b4bf3bc 17639 res = FALSE;
103f02d3 17640
6d118b09
NC		 17641 if (temp != NULL)
17642 {
17643 free (temp);
17644 temp = NULL;
17645 }
779fe533
NC		 17646 }
17647
17648 free (pnotes);
103f02d3 17649
779fe533
NC		 17650 return res;
17651}
17652
32ec8896 17653static bfd_boolean
2cf0635d 17654process_corefile_note_segments (FILE * file)
779fe533 17655{
2cf0635d 17656 Elf_Internal_Phdr * segment;
b34976b6 17657 unsigned int i;
32ec8896 17658 bfd_boolean res = TRUE;
103f02d3 17659
d93f0186 17660 if (! get_program_headers (file))
6b4bf3bc 17661 return TRUE;
103f02d3 17662
779fe533
NC		 17663 for (i = 0, segment = program_headers;
17664 i < elf_header.e_phnum;
b34976b6 17665 i++, segment++)
779fe533
NC		 17666 {
17667 if (segment->p_type == PT_NOTE)
32ec8896
NC		 17668 if (! process_notes_at (file, NULL,
17669 (bfd_vma) segment->p_offset,
17670 (bfd_vma) segment->p_filesz))
17671 res = FALSE;
779fe533 17672 }
103f02d3 17673
779fe533
NC		 17674 return res;
17675}
17676
32ec8896 17677static bfd_boolean
685080f2
NC		 17678process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
17679{
17680 Elf_External_Note * pnotes;
17681 Elf_External_Note * external;
c8071705 17682 char * end;
32ec8896 17683 bfd_boolean res = TRUE;
685080f2
NC		 17684
17685 if (length <= 0)
32ec8896 17686 return FALSE;
685080f2
NC		 17687
17688 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
17689 _("v850 notes"));
17690 if (pnotes == NULL)
32ec8896 17691 return FALSE;
685080f2
NC		 17692
17693 external = pnotes;
c8071705 17694 end = (char*) pnotes + length;
685080f2
NC		 17695
17696 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
17697 (unsigned long) offset, (unsigned long) length);
17698
c8071705 17699 while ((char *) external + sizeof (Elf_External_Note) < end)
685080f2
NC		 17700 {
17701 Elf_External_Note * next;
17702 Elf_Internal_Note inote;
17703
17704 inote.type = BYTE_GET (external->type);
17705 inote.namesz = BYTE_GET (external->namesz);
17706 inote.namedata = external->name;
17707 inote.descsz = BYTE_GET (external->descsz);
17708 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
17709 inote.descpos = offset + (inote.descdata - (char *) pnotes);
17710
c8071705
NC		 17711 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
17712 {
17713 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
17714 inote.descdata = inote.namedata;
17715 inote.namesz = 0;
17716 }
17717
685080f2
NC		 17718 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
17719
c8071705 17720 if ( ((char *) next > end)
685080f2
NC		 17721 || ((char *) next < (char *) pnotes))
17722 {
17723 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
17724 (unsigned long) ((char *) external - (char *) pnotes));
17725 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17726 inote.type, inote.namesz, inote.descsz);
17727 break;
17728 }
17729
17730 external = next;
17731
17732 /* Prevent out-of-bounds indexing. */
c8071705 17733 if ( inote.namedata + inote.namesz > end
685080f2
NC		 17734 || inote.namedata + inote.namesz < inote.namedata)
17735 {
17736 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
17737 (unsigned long) ((char *) external - (char *) pnotes));
17738 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17739 inote.type, inote.namesz, inote.descsz);
17740 break;
17741 }
17742
17743 printf (" %s: ", get_v850_elf_note_type (inote.type));
17744
17745 if (! print_v850_note (& inote))
17746 {
32ec8896 17747 res = FALSE;
685080f2
NC		 17748 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
17749 inote.namesz, inote.descsz);
17750 }
17751 }
17752
17753 free (pnotes);
17754
17755 return res;
17756}
17757
32ec8896 17758static bfd_boolean
2cf0635d 17759process_note_sections (FILE * file)
1ec5cd37 17760{
2cf0635d 17761 Elf_Internal_Shdr * section;
1ec5cd37 17762 unsigned long i;
32ec8896
NC		 17763 unsigned int n = 0;
17764 bfd_boolean res = TRUE;
1ec5cd37
NC		 17765
17766 for (i = 0, section = section_headers;
fa1908fd 17767 i < elf_header.e_shnum && section != NULL;
1ec5cd37 17768 i++, section++)
685080f2
NC		 17769 {
17770 if (section->sh_type == SHT_NOTE)
17771 {
32ec8896
NC		 17772 if (! process_notes_at (file, section,
17773 (bfd_vma) section->sh_offset,
17774 (bfd_vma) section->sh_size))
17775 res = FALSE;
685080f2
NC		 17776 n++;
17777 }
17778
17779 if (( elf_header.e_machine == EM_V800
17780 || elf_header.e_machine == EM_V850
17781 || elf_header.e_machine == EM_CYGNUS_V850)
17782 && section->sh_type == SHT_RENESAS_INFO)
17783 {
32ec8896
NC		 17784 if (! process_v850_notes (file,
17785 (bfd_vma) section->sh_offset,
17786 (bfd_vma) section->sh_size))
17787 res = FALSE;
685080f2
NC		 17788 n++;
17789 }
17790 }
df565f32
NC		 17791
17792 if (n == 0)
17793 /* Try processing NOTE segments instead. */
17794 return process_corefile_note_segments (file);
1ec5cd37
NC		 17795
17796 return res;
17797}
17798
32ec8896 17799static bfd_boolean
2cf0635d 17800process_notes (FILE * file)
779fe533
NC		 17801{
17802 /* If we have not been asked to display the notes then do nothing. */
17803 if (! do_notes)
32ec8896 17804 return TRUE;
103f02d3 17805
779fe533 17806 if (elf_header.e_type != ET_CORE)
1ec5cd37 17807 return process_note_sections (file);
103f02d3 17808
779fe533 17809 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 17810 if (elf_header.e_phnum > 0)
17811 return process_corefile_note_segments (file);
779fe533 17812
1ec5cd37 17813 printf (_("No note segments present in the core file.\n"));
32ec8896 17814 return TRUE;
779fe533
NC		 17815}
17816
60abdbed
NC		 17817static unsigned char *
17818display_public_gnu_attributes (unsigned char * start,
17819 const unsigned char * const end)
17820{
17821 printf (_(" Unknown GNU attribute: %s\n"), start);
17822
17823 start += strnlen ((char *) start, end - start);
17824 display_raw_attribute (start, end);
17825
17826 return (unsigned char *) end;
17827}
17828
17829static unsigned char *
17830display_generic_attribute (unsigned char * start,
17831 unsigned int tag,
17832 const unsigned char * const end)
17833{
17834 if (tag == 0)
17835 return (unsigned char *) end;
17836
17837 return display_tag_value (tag, start, end);
17838}
17839
32ec8896 17840static bfd_boolean
2cf0635d 17841process_arch_specific (FILE * file)
252b5132 17842{
a952a375 17843 if (! do_arch)
32ec8896 17844 return TRUE;
a952a375 17845
252b5132
RH		 17846 switch (elf_header.e_machine)
17847 {
53a346d8
CZ		 17848 case EM_ARC:
17849 case EM_ARC_COMPACT:
17850 case EM_ARC_COMPACT2:
17851 return process_attributes (file, "ARC", SHT_ARC_ATTRIBUTES,
17852 display_arc_attribute,
17853 display_generic_attribute);
11c1ff18 17854 case EM_ARM:
60abdbed
NC		 17855 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
17856 display_arm_attribute,
17857 display_generic_attribute);
17858
252b5132 17859 case EM_MIPS:
4fe85591 17860 case EM_MIPS_RS3_LE:
252b5132 17861 return process_mips_specific (file);
60abdbed
NC		 17862
17863 case EM_MSP430:
7296a62a 17864 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
60abdbed
NC		 17865 display_msp430x_attribute,
17866 display_generic_attribute);
17867
35c08157
KLC		 17868 case EM_NDS32:
17869 return process_nds32_specific (file);
60abdbed 17870
34c8bcba 17871 case EM_PPC:
b82317dd 17872 case EM_PPC64:
60abdbed
NC		 17873 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17874 display_power_gnu_attribute);
17875
643f7afb
AK		 17876 case EM_S390:
17877 case EM_S390_OLD:
60abdbed
NC		 17878 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17879 display_s390_gnu_attribute);
17880
9e8c70f9
DM		 17881 case EM_SPARC:
17882 case EM_SPARC32PLUS:
17883 case EM_SPARCV9:
60abdbed
NC		 17884 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17885 display_sparc_gnu_attribute);
17886
59e6276b 17887 case EM_TI_C6000:
60abdbed
NC		 17888 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
17889 display_tic6x_attribute,
17890 display_generic_attribute);
17891
252b5132 17892 default:
60abdbed
NC		 17893 return process_attributes (file, "gnu", SHT_GNU_ATTRIBUTES,
17894 display_public_gnu_attributes,
17895 display_generic_attribute);
252b5132 17896 }
252b5132
RH		 17897}
17898
32ec8896 17899static bfd_boolean
2cf0635d 17900get_file_header (FILE * file)
252b5132 17901{
9ea033b2
NC		 17902 /* Read in the identity array. */
17903 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
32ec8896 17904 return FALSE;
252b5132 17905
9ea033b2 17906 /* Determine how to read the rest of the header. */
b34976b6 17907 switch (elf_header.e_ident[EI_DATA])
9ea033b2 17908 {
1a0670f3
AM		 17909 default:
17910 case ELFDATANONE:
adab8cdc
AO		 17911 case ELFDATA2LSB:
17912 byte_get = byte_get_little_endian;
17913 byte_put = byte_put_little_endian;
17914 break;
17915 case ELFDATA2MSB:
17916 byte_get = byte_get_big_endian;
17917 byte_put = byte_put_big_endian;
17918 break;
9ea033b2
NC		 17919 }
17920
17921 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 17922 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 17923
17924 /* Read in the rest of the header. */
17925 if (is_32bit_elf)
17926 {
17927 Elf32_External_Ehdr ehdr32;
252b5132 17928
9ea033b2 17929 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
32ec8896 17930 return FALSE;
103f02d3 17931
9ea033b2
NC		 17932 elf_header.e_type = BYTE_GET (ehdr32.e_type);
17933 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
17934 elf_header.e_version = BYTE_GET (ehdr32.e_version);
17935 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
17936 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
17937 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
17938 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
17939 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
17940 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
17941 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
17942 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
17943 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
17944 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
17945 }
252b5132 17946 else
9ea033b2
NC		 17947 {
17948 Elf64_External_Ehdr ehdr64;
a952a375
NC		 17949
17950 /* If we have been compiled with sizeof (bfd_vma) == 4, then
17951 we will not be able to cope with the 64bit data found in
17952 64 ELF files. Detect this now and abort before we start
50c2245b 17953 overwriting things. */
a952a375
NC		 17954 if (sizeof (bfd_vma) < 8)
17955 {
e3c8793a
NC		 17956 error (_("This instance of readelf has been built without support for a\n\
1795764 bit data type and so it cannot read 64 bit ELF files.\n"));
32ec8896 17958 return FALSE;
a952a375 17959 }
103f02d3 17960
9ea033b2 17961 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
32ec8896 17962 return FALSE;
103f02d3 17963
9ea033b2
NC		 17964 elf_header.e_type = BYTE_GET (ehdr64.e_type);
17965 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
17966 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 17967 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
17968 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
17969 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 17970 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
17971 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
17972 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
17973 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
17974 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
17975 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
17976 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
17977 }
252b5132 17978
7ece0d85
JJ		 17979 if (elf_header.e_shoff)
17980 {
17981 /* There may be some extensions in the first section header. Don't
17982 bomb if we can't read it. */
17983 if (is_32bit_elf)
049b0c3a 17984 get_32bit_section_headers (file, TRUE);
7ece0d85 17985 else
049b0c3a 17986 get_64bit_section_headers (file, TRUE);
7ece0d85 17987 }
560f3c1c 17988
32ec8896 17989 return TRUE;
252b5132
RH		 17990}
17991
fb52b2f4
NC		 17992/* Process one ELF object file according to the command line options.
17993 This file may actually be stored in an archive. The file is
32ec8896
NC		 17994 positioned at the start of the ELF object. Returns TRUE if no
17995 problems were encountered, FALSE otherwise. */
fb52b2f4 17996
32ec8896 17997static bfd_boolean
2cf0635d 17998process_object (char * file_name, FILE * file)
252b5132 17999{
252b5132 18000 unsigned int i;
32ec8896 18001 bfd_boolean res = TRUE;
252b5132 18002
252b5132
RH		 18003 if (! get_file_header (file))
18004 {
18005 error (_("%s: Failed to read file header\n"), file_name);
32ec8896 18006 return FALSE;
252b5132
RH		 18007 }
18008
18009 /* Initialise per file variables. */
60bca95a 18010 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 18011 version_info[i] = 0;
18012
60bca95a 18013 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 18014 dynamic_info[i] = 0;
5115b233 18015 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 18016
18017 /* Process the file. */
18018 if (show_name)
18019 printf (_("\nFile: %s\n"), file_name);
18020
18bd398b
NC		 18021 /* Initialise the dump_sects array from the cmdline_dump_sects array.
18022 Note we do this even if cmdline_dump_sects is empty because we
18023 must make sure that the dump_sets array is zeroed out before each
18024 object file is processed. */
18025 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 18026 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 18027
18028 if (num_cmdline_dump_sects > 0)
18029 {
18030 if (num_dump_sects == 0)
18031 /* A sneaky way of allocating the dump_sects array. */
09c11c86 18032 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 18033
18034 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 18035 memcpy (dump_sects, cmdline_dump_sects,
18036 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 18037 }
d70c5fc7 18038
252b5132 18039 if (! process_file_header ())
32ec8896 18040 return FALSE;
252b5132 18041
d1f5c6e3 18042 if (! process_section_headers (file))
2f62977e 18043 {
32ec8896
NC		 18044 /* Without loaded section headers we cannot process lots of things. */
18045 do_unwind = do_version = do_dump = do_arch = FALSE;
252b5132 18046
2f62977e 18047 if (! do_using_dynamic)
32ec8896 18048 do_syms = do_dyn_syms = do_reloc = FALSE;
2f62977e 18049 }
252b5132 18050
d1f5c6e3 18051 if (! process_section_groups (file))
32ec8896
NC		 18052 /* Without loaded section groups we cannot process unwind. */
18053 do_unwind = FALSE;
d1f5c6e3 18054
2f62977e 18055 if (process_program_headers (file))
b2d38a17 18056 process_dynamic_section (file);
32ec8896
NC		 18057 else
18058 res = FALSE;
252b5132 18059
32ec8896
NC		 18060 if (! process_relocs (file))
18061 res = FALSE;
252b5132 18062
32ec8896
NC		 18063 if (! process_unwind (file))
18064 res = FALSE;
4d6ed7c8 18065
32ec8896
NC		 18066 if (! process_symbol_table (file))
18067 res = FALSE;
252b5132 18068
32ec8896
NC		 18069 if (! process_syminfo (file))
18070 res = FALSE;
252b5132 18071
32ec8896
NC		 18072 if (! process_version_sections (file))
18073 res = FALSE;
252b5132 18074
32ec8896
NC		 18075 if (! process_section_contents (file))
18076 res = FALSE;
f5842774 18077
32ec8896
NC		 18078 if (! process_notes (file))
18079 res = FALSE;
103f02d3 18080
32ec8896
NC		 18081 if (! process_gnu_liblist (file))
18082 res = FALSE;
047b2264 18083
32ec8896
NC		 18084 if (! process_arch_specific (file))
18085 res = FALSE;
252b5132 18086
d93f0186
NC		 18087 if (program_headers)
18088 {
18089 free (program_headers);
18090 program_headers = NULL;
18091 }
18092
252b5132
RH		 18093 if (section_headers)
18094 {
18095 free (section_headers);
18096 section_headers = NULL;
18097 }
18098
18099 if (string_table)
18100 {
18101 free (string_table);
18102 string_table = NULL;
d40ac9bd 18103 string_table_length = 0;
252b5132
RH		 18104 }
18105
18106 if (dynamic_strings)
18107 {
18108 free (dynamic_strings);
18109 dynamic_strings = NULL;
d79b3d50 18110 dynamic_strings_length = 0;
252b5132
RH		 18111 }
18112
18113 if (dynamic_symbols)
18114 {
18115 free (dynamic_symbols);
18116 dynamic_symbols = NULL;
19936277 18117 num_dynamic_syms = 0;
252b5132
RH		 18118 }
18119
18120 if (dynamic_syminfo)
18121 {
18122 free (dynamic_syminfo);
18123 dynamic_syminfo = NULL;
18124 }
ff78d6d6 18125
293c573e
MR		 18126 if (dynamic_section)
18127 {
18128 free (dynamic_section);
18129 dynamic_section = NULL;
18130 }
18131
e4b17d5c
L		 18132 if (section_headers_groups)
18133 {
18134 free (section_headers_groups);
18135 section_headers_groups = NULL;
18136 }
18137
18138 if (section_groups)
18139 {
2cf0635d
NC		 18140 struct group_list * g;
18141 struct group_list * next;
e4b17d5c
L		 18142
18143 for (i = 0; i < group_count; i++)
18144 {
18145 for (g = section_groups [i].root; g != NULL; g = next)
18146 {
18147 next = g->next;
18148 free (g);
18149 }
18150 }
18151
18152 free (section_groups);
18153 section_groups = NULL;
18154 }
18155
19e6b90e 18156 free_debug_memory ();
18bd398b 18157
32ec8896 18158 return res;
252b5132
RH		 18159}
18160
2cf0635d 18161/* Process an ELF archive.
32ec8896
NC		 18162 On entry the file is positioned just after the ARMAG string.
18163 Returns TRUE upon success, FALSE otherwise. */
2cf0635d 18164
32ec8896 18165static bfd_boolean
2cf0635d
NC		 18166process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
18167{
18168 struct archive_info arch;
18169 struct archive_info nested_arch;
18170 size_t got;
32ec8896 18171 bfd_boolean ret = TRUE;
2cf0635d 18172
32ec8896 18173 show_name = TRUE;
2cf0635d
NC		 18174
18175 /* The ARCH structure is used to hold information about this archive. */
18176 arch.file_name = NULL;
18177 arch.file = NULL;
18178 arch.index_array = NULL;
18179 arch.sym_table = NULL;
18180 arch.longnames = NULL;
18181
18182 /* The NESTED_ARCH structure is used as a single-item cache of information
18183 about a nested archive (when members of a thin archive reside within
18184 another regular archive file). */
18185 nested_arch.file_name = NULL;
18186 nested_arch.file = NULL;
18187 nested_arch.index_array = NULL;
18188 nested_arch.sym_table = NULL;
18189 nested_arch.longnames = NULL;
18190
18191 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
18192 {
32ec8896 18193 ret = FALSE;
2cf0635d 18194 goto out;
4145f1d5 18195 }
fb52b2f4 18196
4145f1d5
NC		 18197 if (do_archive_index)
18198 {
2cf0635d 18199 if (arch.sym_table == NULL)
4145f1d5
NC		 18200 error (_("%s: unable to dump the index as none was found\n"), file_name);
18201 else
18202 {
591f7597 18203 unsigned long i, l;
4145f1d5
NC		 18204 unsigned long current_pos;
18205
591f7597
NC		 18206 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
18207 file_name, (unsigned long) arch.index_num, arch.sym_size);
4145f1d5
NC		 18208 current_pos = ftell (file);
18209
2cf0635d 18210 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 18211 {
2cf0635d
NC		 18212 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
18213 {
18214 char * member_name;
4145f1d5 18215
2cf0635d
NC		 18216 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
18217
18218 if (member_name != NULL)
18219 {
18220 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
18221
18222 if (qualified_name != NULL)
18223 {
c2a7d3f5
NC		 18224 printf (_("Contents of binary %s at offset "), qualified_name);
18225 (void) print_vma (arch.index_array[i], PREFIX_HEX);
18226 putchar ('\n');
2cf0635d
NC		 18227 free (qualified_name);
18228 }
4145f1d5
NC		 18229 }
18230 }
2cf0635d
NC		 18231
18232 if (l >= arch.sym_size)
4145f1d5
NC		 18233 {
18234 error (_("%s: end of the symbol table reached before the end of the index\n"),
18235 file_name);
32ec8896 18236 ret = FALSE;
cb8f3167 18237 break;
4145f1d5 18238 }
591f7597
NC		 18239 /* PR 17531: file: 0b6630b2. */
18240 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
18241 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
4145f1d5
NC		 18242 }
18243
c2a7d3f5
NC		 18244 if (arch.uses_64bit_indicies)
18245 l = (l + 7) & ~ 7;
18246 else
18247 l += l & 1;
18248
2cf0635d 18249 if (l < arch.sym_size)
32ec8896
NC		 18250 {
18251 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
18252 file_name, arch.sym_size - l);
18253 ret = FALSE;
18254 }
4145f1d5 18255
4145f1d5
NC		 18256 if (fseek (file, current_pos, SEEK_SET) != 0)
18257 {
18258 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
32ec8896 18259 ret = FALSE;
2cf0635d 18260 goto out;
4145f1d5 18261 }
fb52b2f4 18262 }
4145f1d5
NC		 18263
18264 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
18265 && !do_segments && !do_header && !do_dump && !do_version
18266 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 18267 && !do_section_groups && !do_dyn_syms)
2cf0635d 18268 {
32ec8896 18269 ret = TRUE; /* Archive index only. */
2cf0635d
NC		 18270 goto out;
18271 }
fb52b2f4
NC		 18272 }
18273
fb52b2f4
NC		 18274 while (1)
18275 {
2cf0635d
NC		 18276 char * name;
18277 size_t namelen;
18278 char * qualified_name;
18279
18280 /* Read the next archive header. */
18281 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
18282 {
18283 error (_("%s: failed to seek to next archive header\n"), file_name);
32ec8896 18284 return FALSE;
2cf0635d
NC		 18285 }
18286 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
18287 if (got != sizeof arch.arhdr)
18288 {
18289 if (got == 0)
18290 break;
18291 error (_("%s: failed to read archive header\n"), file_name);
32ec8896 18292 ret = FALSE;
2cf0635d
NC		 18293 break;
18294 }
18295 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
18296 {
18297 error (_("%s: did not find a valid archive header\n"), arch.file_name);
32ec8896 18298 ret = FALSE;
2cf0635d
NC		 18299 break;
18300 }
18301
18302 arch.next_arhdr_offset += sizeof arch.arhdr;
18303
18304 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
18305 if (archive_file_size & 01)
18306 ++archive_file_size;
18307
18308 name = get_archive_member_name (&arch, &nested_arch);
18309 if (name == NULL)
fb52b2f4 18310 {
0fd3a477 18311 error (_("%s: bad archive file name\n"), file_name);
32ec8896 18312 ret = FALSE;
d989285c 18313 break;
fb52b2f4 18314 }
2cf0635d 18315 namelen = strlen (name);
fb52b2f4 18316
2cf0635d
NC		 18317 qualified_name = make_qualified_name (&arch, &nested_arch, name);
18318 if (qualified_name == NULL)
fb52b2f4 18319 {
2cf0635d 18320 error (_("%s: bad archive file name\n"), file_name);
32ec8896 18321 ret = FALSE;
d989285c 18322 break;
fb52b2f4
NC		 18323 }
18324
2cf0635d
NC		 18325 if (is_thin_archive && arch.nested_member_origin == 0)
18326 {
18327 /* This is a proxy for an external member of a thin archive. */
18328 FILE * member_file;
18329 char * member_file_name = adjust_relative_path (file_name, name, namelen);
32ec8896 18330
2cf0635d
NC		 18331 if (member_file_name == NULL)
18332 {
32ec8896 18333 ret = FALSE;
2cf0635d
NC		 18334 break;
18335 }
18336
18337 member_file = fopen (member_file_name, "rb");
18338 if (member_file == NULL)
18339 {
18340 error (_("Input file '%s' is not readable.\n"), member_file_name);
18341 free (member_file_name);
32ec8896 18342 ret = FALSE;
2cf0635d
NC		 18343 break;
18344 }
18345
18346 archive_file_offset = arch.nested_member_origin;
18347
32ec8896
NC		 18348 if (! process_object (qualified_name, member_file))
18349 ret = FALSE;
2cf0635d
NC		 18350
18351 fclose (member_file);
18352 free (member_file_name);
18353 }
18354 else if (is_thin_archive)
18355 {
a043396b
NC		 18356 /* PR 15140: Allow for corrupt thin archives. */
18357 if (nested_arch.file == NULL)
18358 {
18359 error (_("%s: contains corrupt thin archive: %s\n"),
18360 file_name, name);
32ec8896 18361 ret = FALSE;
a043396b
NC		 18362 break;
18363 }
18364
2cf0635d
NC		 18365 /* This is a proxy for a member of a nested archive. */
18366 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
18367
18368 /* The nested archive file will have been opened and setup by
18369 get_archive_member_name. */
18370 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
18371 {
18372 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
32ec8896 18373 ret = FALSE;
2cf0635d
NC		 18374 break;
18375 }
18376
32ec8896
NC		 18377 if (! process_object (qualified_name, nested_arch.file))
18378 ret = FALSE;
2cf0635d
NC		 18379 }
18380 else
18381 {
18382 archive_file_offset = arch.next_arhdr_offset;
18383 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 18384
32ec8896
NC		 18385 if (! process_object (qualified_name, file))
18386 ret = FALSE;
2cf0635d 18387 }
fb52b2f4 18388
2b52916e
L		 18389 if (dump_sects != NULL)
18390 {
18391 free (dump_sects);
18392 dump_sects = NULL;
18393 num_dump_sects = 0;
18394 }
18395
2cf0635d 18396 free (qualified_name);
fb52b2f4
NC		 18397 }
18398
4145f1d5 18399 out:
2cf0635d
NC		 18400 if (nested_arch.file != NULL)
18401 fclose (nested_arch.file);
18402 release_archive (&nested_arch);
18403 release_archive (&arch);
fb52b2f4 18404
d989285c 18405 return ret;
fb52b2f4
NC		 18406}
18407
32ec8896 18408static bfd_boolean
2cf0635d 18409process_file (char * file_name)
fb52b2f4 18410{
2cf0635d 18411 FILE * file;
fb52b2f4
NC		 18412 struct stat statbuf;
18413 char armag[SARMAG];
32ec8896 18414 bfd_boolean ret = TRUE;
fb52b2f4
NC		 18415
18416 if (stat (file_name, &statbuf) < 0)
18417 {
f24ddbdd
NC		 18418 if (errno == ENOENT)
18419 error (_("'%s': No such file\n"), file_name);
18420 else
18421 error (_("Could not locate '%s'. System error message: %s\n"),
18422 file_name, strerror (errno));
32ec8896 18423 return FALSE;
f24ddbdd
NC		 18424 }
18425
18426 if (! S_ISREG (statbuf.st_mode))
18427 {
18428 error (_("'%s' is not an ordinary file\n"), file_name);
32ec8896 18429 return FALSE;
fb52b2f4
NC		 18430 }
18431
18432 file = fopen (file_name, "rb");
18433 if (file == NULL)
18434 {
f24ddbdd 18435 error (_("Input file '%s' is not readable.\n"), file_name);
32ec8896 18436 return FALSE;
fb52b2f4
NC		 18437 }
18438
18439 if (fread (armag, SARMAG, 1, file) != 1)
18440 {
4145f1d5 18441 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4 18442 fclose (file);
32ec8896 18443 return FALSE;
fb52b2f4
NC		 18444 }
18445
f54498b4
NC		 18446 current_file_size = (bfd_size_type) statbuf.st_size;
18447
fb52b2f4 18448 if (memcmp (armag, ARMAG, SARMAG) == 0)
32ec8896
NC		 18449 {
18450 if (! process_archive (file_name, file, FALSE))
18451 ret = FALSE;
18452 }
2cf0635d 18453 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
32ec8896
NC		 18454 {
18455 if ( ! process_archive (file_name, file, TRUE))
18456 ret = FALSE;
18457 }
fb52b2f4
NC		 18458 else
18459 {
4145f1d5
NC		 18460 if (do_archive_index)
18461 error (_("File %s is not an archive so its index cannot be displayed.\n"),
18462 file_name);
18463
fb52b2f4
NC		 18464 rewind (file);
18465 archive_file_size = archive_file_offset = 0;
32ec8896
NC		 18466
18467 if (! process_object (file_name, file))
18468 ret = FALSE;
fb52b2f4
NC		 18469 }
18470
18471 fclose (file);
f54498b4 18472 current_file_size = 0;
32ec8896 18473
fb52b2f4
NC		 18474 return ret;
18475}
18476
252b5132
RH		 18477#ifdef SUPPORT_DISASSEMBLY
18478/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 18479 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 18480 symbols. */
252b5132
RH		 18481
18482void
2cf0635d 18483print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 18484{
18485 fprintf (outfile,"0x%8.8x", addr);
18486}
18487
e3c8793a 18488/* Needed by the i386 disassembler. */
252b5132
RH		 18489void
18490db_task_printsym (unsigned int addr)
18491{
18492 print_address (addr, stderr);
18493}
18494#endif
18495
18496int
2cf0635d 18497main (int argc, char ** argv)
252b5132 18498{
ff78d6d6
L		 18499 int err;
18500
252b5132
RH		 18501#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
18502 setlocale (LC_MESSAGES, "");
3882b010
L		 18503#endif
18504#if defined (HAVE_SETLOCALE)
18505 setlocale (LC_CTYPE, "");
252b5132
RH		 18506#endif
18507 bindtextdomain (PACKAGE, LOCALEDIR);
18508 textdomain (PACKAGE);
18509
869b9d07
MM		 18510 expandargv (&argc, &argv);
18511
252b5132
RH		 18512 parse_args (argc, argv);
18513
18bd398b 18514 if (num_dump_sects > 0)
59f14fc0 18515 {
18bd398b 18516 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 18517 cmdline_dump_sects = (dump_type *)
18518 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 18519 if (cmdline_dump_sects == NULL)
591a748a 18520 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 18521 else
18522 {
09c11c86
NC		 18523 memcpy (cmdline_dump_sects, dump_sects,
18524 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 18525 num_cmdline_dump_sects = num_dump_sects;
18526 }
18527 }
18528
18bd398b 18529 if (optind < (argc - 1))
32ec8896 18530 show_name = TRUE;
5656ba2c
L		 18531 else if (optind >= argc)
18532 {
18533 warn (_("Nothing to do.\n"));
18534 usage (stderr);
18535 }
18bd398b 18536
32ec8896 18537 err = FALSE;
252b5132 18538 while (optind < argc)
32ec8896
NC		 18539 if (! process_file (argv[optind++]))
18540 err = TRUE;
252b5132
RH		 18541
18542 if (dump_sects != NULL)
18543 free (dump_sects);
59f14fc0
AS		 18544 if (cmdline_dump_sects != NULL)
18545 free (cmdline_dump_sects);
252b5132 18546
32ec8896 18547 return err ? EXIT_FAILURE : EXIT_SUCCESS;
252b5132 18548}
A mirror of the official binutils-gdb repository