]> 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
Update descriptions of the .2byte, .4byte and .8byte directives.
[thirdparty/binutils-gdb.git] / binutils / readelf.c
CommitLineData
252b5132 1/* readelf.c -- display contents of an ELF format file
2571583a 2 Copyright (C) 1998-2017 Free Software Foundation, Inc.
252b5132
RH		 3
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
12ab83a9 5 Modifications by Nick Clifton <nickc@redhat.com>
252b5132
RH		 6
7 This file is part of GNU Binutils.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
32866df7 11 the Free Software Foundation; either version 3 of the License, or
252b5132
RH		 12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
b43b5d5f
NC		 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 02110-1301, USA. */
252b5132 23\f
9eb20dd8 24/* The difference between readelf and objdump:
252b5132 25
74013231 26 Both programs are capable of displaying the contents of ELF format files,
9eb20dd8 27 so why does the binutils project have two file dumpers ?
0de14b54 28
9eb20dd8
NC		 29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
35
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
38
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
42\f
3db64b00 43#include "sysdep.h"
252b5132 44#include <assert.h>
252b5132 45#include <time.h>
1b315056 46#include <zlib.h>
3bfcb652 47#ifdef HAVE_WCHAR_H
7bfd842d 48#include <wchar.h>
3bfcb652 49#endif
252b5132 50
a952a375 51#if __GNUC__ >= 2
19936277 52/* Define BFD64 here, even if our default architecture is 32 bit ELF
a952a375 53 as this will allow us to read in and parse 64bit and 32bit ELF files.
b34976b6 54 Only do this if we believe that the compiler can support a 64 bit
a952a375 55 data type. For now we only rely on GCC being able to do this. */
19936277 56#define BFD64
a952a375
NC		 57#endif
58
3db64b00
AM		 59#include "bfd.h"
60#include "bucomm.h"
3284fe0c 61#include "elfcomm.h"
19e6b90e 62#include "dwarf.h"
252b5132
RH		 63
64#include "elf/common.h"
65#include "elf/external.h"
66#include "elf/internal.h"
252b5132 67
4b78141a
NC		 68
69/* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
70 we can obtain the H8 reloc numbers. We need these for the
71 get_reloc_size() function. We include h8.h again after defining
72 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
73
74#include "elf/h8.h"
75#undef _ELF_H8_H
76
77/* Undo the effects of #including reloc-macros.h. */
78
79#undef START_RELOC_NUMBERS
80#undef RELOC_NUMBER
81#undef FAKE_RELOC
82#undef EMPTY_RELOC
83#undef END_RELOC_NUMBERS
84#undef _RELOC_MACROS_H
85
252b5132
RH		 86/* The following headers use the elf/reloc-macros.h file to
87 automatically generate relocation recognition functions
88 such as elf_mips_reloc_type() */
89
90#define RELOC_MACROS_GEN_FUNC
91
a06ea964 92#include "elf/aarch64.h"
252b5132 93#include "elf/alpha.h"
3b16e843 94#include "elf/arc.h"
252b5132 95#include "elf/arm.h"
3b16e843 96#include "elf/avr.h"
1d65ded4 97#include "elf/bfin.h"
60bca95a 98#include "elf/cr16.h"
3b16e843 99#include "elf/cris.h"
1c0d3aa6 100#include "elf/crx.h"
252b5132
RH		 101#include "elf/d10v.h"
102#include "elf/d30v.h"
d172d4ba 103#include "elf/dlx.h"
cfb8c092 104#include "elf/epiphany.h"
252b5132 105#include "elf/fr30.h"
5c70f934 106#include "elf/frv.h"
3f8107ab 107#include "elf/ft32.h"
3b16e843
NC		 108#include "elf/h8.h"
109#include "elf/hppa.h"
110#include "elf/i386.h"
35b1837e 111#include "elf/i370.h"
3b16e843
NC		 112#include "elf/i860.h"
113#include "elf/i960.h"
114#include "elf/ia64.h"
1e4cf259 115#include "elf/ip2k.h"
84e94c90 116#include "elf/lm32.h"
1c0d3aa6 117#include "elf/iq2000.h"
49f58d10 118#include "elf/m32c.h"
3b16e843
NC		 119#include "elf/m32r.h"
120#include "elf/m68k.h"
75751cd9 121#include "elf/m68hc11.h"
252b5132 122#include "elf/mcore.h"
15ab5209 123#include "elf/mep.h"
a3c62988 124#include "elf/metag.h"
7ba29e2a 125#include "elf/microblaze.h"
3b16e843 126#include "elf/mips.h"
e23eba97 127#include "elf/riscv.h"
3c3bdf30 128#include "elf/mmix.h"
3b16e843
NC		 129#include "elf/mn10200.h"
130#include "elf/mn10300.h"
5506d11a 131#include "elf/moxie.h"
4970f871 132#include "elf/mt.h"
2469cfa2 133#include "elf/msp430.h"
35c08157 134#include "elf/nds32.h"
13761a11 135#include "elf/nios2.h"
73589c9d 136#include "elf/or1k.h"
7d466069 137#include "elf/pj.h"
3b16e843 138#include "elf/ppc.h"
c833c019 139#include "elf/ppc64.h"
2b100bb5 140#include "elf/pru.h"
99c513f6 141#include "elf/rl78.h"
c7927a3c 142#include "elf/rx.h"
a85d7ed0 143#include "elf/s390.h"
1c0d3aa6 144#include "elf/score.h"
3b16e843
NC		 145#include "elf/sh.h"
146#include "elf/sparc.h"
e9f53129 147#include "elf/spu.h"
40b36596 148#include "elf/tic6x.h"
aa137e4d
NC		 149#include "elf/tilegx.h"
150#include "elf/tilepro.h"
3b16e843 151#include "elf/v850.h"
179d3252 152#include "elf/vax.h"
619ed720 153#include "elf/visium.h"
3b16e843 154#include "elf/x86-64.h"
c29aca4a 155#include "elf/xc16x.h"
f6c1a2d5 156#include "elf/xgate.h"
93fbbb04 157#include "elf/xstormy16.h"
88da6820 158#include "elf/xtensa.h"
252b5132 159
252b5132 160#include "getopt.h"
566b0d53 161#include "libiberty.h"
09c11c86 162#include "safe-ctype.h"
2cf0635d 163#include "filenames.h"
252b5132 164
15b42fb0
AM		 165#ifndef offsetof
166#define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
167#endif
168
6a40cf0c
NC		 169typedef struct elf_section_list
170{
171 Elf_Internal_Shdr * hdr;
172 struct elf_section_list * next;
173} elf_section_list;
174
2cf0635d 175char * program_name = "readelf";
c9c1d674 176static unsigned long archive_file_offset;
85b1c36d 177static unsigned long archive_file_size;
f54498b4 178static bfd_size_type current_file_size;
85b1c36d
BE		 179static unsigned long dynamic_addr;
180static bfd_size_type dynamic_size;
8b73c356 181static size_t dynamic_nent;
2cf0635d 182static char * dynamic_strings;
85b1c36d 183static unsigned long dynamic_strings_length;
2cf0635d 184static char * string_table;
85b1c36d
BE		 185static unsigned long string_table_length;
186static unsigned long num_dynamic_syms;
2cf0635d
NC		 187static Elf_Internal_Sym * dynamic_symbols;
188static Elf_Internal_Syminfo * dynamic_syminfo;
85b1c36d
BE		 189static unsigned long dynamic_syminfo_offset;
190static unsigned int dynamic_syminfo_nent;
f8eae8b2 191static char program_interpreter[PATH_MAX];
bb8a0291 192static bfd_vma dynamic_info[DT_ENCODING];
fdc90cb4 193static bfd_vma dynamic_info_DT_GNU_HASH;
85b1c36d
BE		 194static bfd_vma version_info[16];
195static Elf_Internal_Ehdr elf_header;
2cf0635d
NC		 196static Elf_Internal_Shdr * section_headers;
197static Elf_Internal_Phdr * program_headers;
198static Elf_Internal_Dyn * dynamic_section;
6a40cf0c 199static elf_section_list * symtab_shndx_list;
32ec8896
NC		 200static bfd_boolean show_name = FALSE;
201static bfd_boolean do_dynamic = FALSE;
202static bfd_boolean do_syms = FALSE;
203static bfd_boolean do_dyn_syms = FALSE;
204static bfd_boolean do_reloc = FALSE;
205static bfd_boolean do_sections = FALSE;
206static bfd_boolean do_section_groups = FALSE;
207static bfd_boolean do_section_details = FALSE;
208static bfd_boolean do_segments = FALSE;
209static bfd_boolean do_unwind = FALSE;
210static bfd_boolean do_using_dynamic = FALSE;
211static bfd_boolean do_header = FALSE;
212static bfd_boolean do_dump = FALSE;
213static bfd_boolean do_version = FALSE;
214static bfd_boolean do_histogram = FALSE;
215static bfd_boolean do_debugging = FALSE;
216static bfd_boolean do_arch = FALSE;
217static bfd_boolean do_notes = FALSE;
218static bfd_boolean do_archive_index = FALSE;
219static bfd_boolean is_32bit_elf = FALSE;
220static bfd_boolean decompress_dumps = FALSE;
252b5132 221
e4b17d5c
L		 222struct group_list
223{
2cf0635d 224 struct group_list * next;
e4b17d5c
L		 225 unsigned int section_index;
226};
227
228struct group
229{
2cf0635d 230 struct group_list * root;
e4b17d5c
L		 231 unsigned int group_index;
232};
233
85b1c36d 234static size_t group_count;
2cf0635d
NC		 235static struct group * section_groups;
236static struct group ** section_headers_groups;
e4b17d5c 237
09c11c86
NC		 238
239/* Flag bits indicating particular types of dump. */
240#define HEX_DUMP (1 << 0) /* The -x command line switch. */
241#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
242#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
243#define STRING_DUMP (1 << 3) /* The -p command line switch. */
cf13d699 244#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
09c11c86
NC		 245
246typedef unsigned char dump_type;
247
248/* A linked list of the section names for which dumps were requested. */
aef1f6d0
DJ		 249struct dump_list_entry
250{
2cf0635d 251 char * name;
09c11c86 252 dump_type type;
2cf0635d 253 struct dump_list_entry * next;
aef1f6d0 254};
2cf0635d 255static struct dump_list_entry * dump_sects_byname;
aef1f6d0 256
09c11c86
NC		 257/* A dynamic array of flags indicating for which sections a dump
258 has been requested via command line switches. */
259static dump_type * cmdline_dump_sects = NULL;
260static unsigned int num_cmdline_dump_sects = 0;
18bd398b
NC		 261
262/* A dynamic array of flags indicating for which sections a dump of
263 some kind has been requested. It is reset on a per-object file
aef1f6d0
DJ		 264 basis and then initialised from the cmdline_dump_sects array,
265 the results of interpreting the -w switch, and the
266 dump_sects_byname list. */
09c11c86
NC		 267static dump_type * dump_sects = NULL;
268static unsigned int num_dump_sects = 0;
252b5132 269
252b5132 270
c256ffe7 271/* How to print a vma value. */
843dd992
NC		 272typedef enum print_mode
273{
274 HEX,
275 DEC,
276 DEC_5,
277 UNSIGNED,
278 PREFIX_HEX,
279 FULL_HEX,
280 LONG_HEX
281}
282print_mode;
283
bb4d2ac2
L		 284/* Versioned symbol info. */
285enum versioned_symbol_info
286{
287 symbol_undefined,
288 symbol_hidden,
289 symbol_public
290};
291
32ec8896
NC		 292static const char * get_symbol_version_string
293 (FILE *, bfd_boolean, const char *, unsigned long, unsigned,
294 Elf_Internal_Sym *, enum versioned_symbol_info *, unsigned short *);
bb4d2ac2 295
9c19a809
NC		 296#define UNKNOWN -1
297
2b692964
NC		 298#define SECTION_NAME(X) \
299 ((X) == NULL ? _("<none>") \
300 : string_table == NULL ? _("<no-name>") \
301 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
0b49d371 302 : string_table + (X)->sh_name))
252b5132 303
ee42cf8c 304#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
252b5132 305
ba5cdace
NC		 306#define GET_ELF_SYMBOLS(file, section, sym_count) \
307 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
308 : get_64bit_elf_symbols (file, section, sym_count))
9ea033b2 309
d79b3d50
NC		 310#define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
311/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
312 already been called and verified that the string exists. */
313#define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
18bd398b 314
61865e30
NC		 315#define REMOVE_ARCH_BITS(ADDR) \
316 do \
317 { \
318 if (elf_header.e_machine == EM_ARM) \
319 (ADDR) &= ~1; \
320 } \
321 while (0)
d79b3d50 322\f
c9c1d674
EG		 323/* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
324 the offset of the current archive member, if we are examining an archive.
59245841
NC		 325 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
326 using malloc and fill that. In either case return the pointer to the start of
327 the retrieved data or NULL if something went wrong. If something does go wrong
c9c1d674
EG		 328 and REASON is not NULL then emit an error message using REASON as part of the
329 context. */
59245841 330
c256ffe7 331static void *
57028622
NC		 332get_data (void * var, FILE * file, unsigned long offset, bfd_size_type size,
333 bfd_size_type nmemb, const char * reason)
a6e9f9df 334{
2cf0635d 335 void * mvar;
57028622 336 bfd_size_type amt = size * nmemb;
a6e9f9df 337
c256ffe7 338 if (size == 0 || nmemb == 0)
a6e9f9df
AM		 339 return NULL;
340
57028622
NC		 341 /* If the size_t type is smaller than the bfd_size_type, eg because
342 you are building a 32-bit tool on a 64-bit host, then make sure
343 that when the sizes are cast to (size_t) no information is lost. */
344 if (sizeof (size_t) < sizeof (bfd_size_type)
345 && ( (bfd_size_type) ((size_t) size) != size
346 || (bfd_size_type) ((size_t) nmemb) != nmemb))
347 {
348 if (reason)
ed754a13
AM		 349 error (_("Size truncation prevents reading 0x%" BFD_VMA_FMT "x"
350 " elements of size 0x%" BFD_VMA_FMT "x for %s\n"),
351 nmemb, size, reason);
57028622
NC		 352 return NULL;
353 }
354
355 /* Check for size overflow. */
356 if (amt < nmemb)
357 {
358 if (reason)
ed754a13
AM		 359 error (_("Size overflow prevents reading 0x%" BFD_VMA_FMT "x"
360 " elements of size 0x%" BFD_VMA_FMT "x for %s\n"),
361 nmemb, size, reason);
57028622
NC		 362 return NULL;
363 }
364
c9c1d674
EG		 365 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
366 attempting to allocate memory when the read is bound to fail. */
367 if (amt > current_file_size
368 || offset + archive_file_offset + amt > current_file_size)
a6e9f9df 369 {
049b0c3a 370 if (reason)
ed754a13
AM		 371 error (_("Reading 0x%" BFD_VMA_FMT "x"
372 " bytes extends past end of file for %s\n"),
373 amt, reason);
a6e9f9df
AM		 374 return NULL;
375 }
376
c9c1d674 377 if (fseek (file, archive_file_offset + offset, SEEK_SET))
071436c6
NC		 378 {
379 if (reason)
c9c1d674 380 error (_("Unable to seek to 0x%lx for %s\n"),
ed754a13 381 archive_file_offset + offset, reason);
071436c6
NC		 382 return NULL;
383 }
384
a6e9f9df
AM		 385 mvar = var;
386 if (mvar == NULL)
387 {
c256ffe7 388 /* Check for overflow. */
57028622 389 if (nmemb < (~(bfd_size_type) 0 - 1) / size)
c256ffe7 390 /* + 1 so that we can '\0' terminate invalid string table sections. */
57028622 391 mvar = malloc ((size_t) amt + 1);
a6e9f9df
AM		 392
393 if (mvar == NULL)
394 {
049b0c3a 395 if (reason)
ed754a13
AM		 396 error (_("Out of memory allocating 0x%" BFD_VMA_FMT "x"
397 " bytes for %s\n"),
398 amt, reason);
a6e9f9df
AM		 399 return NULL;
400 }
c256ffe7 401
c9c1d674 402 ((char *) mvar)[amt] = '\0';
a6e9f9df
AM		 403 }
404
57028622 405 if (fread (mvar, (size_t) size, (size_t) nmemb, file) != nmemb)
a6e9f9df 406 {
049b0c3a 407 if (reason)
ed754a13
AM		 408 error (_("Unable to read in 0x%" BFD_VMA_FMT "x bytes of %s\n"),
409 amt, reason);
a6e9f9df
AM		 410 if (mvar != var)
411 free (mvar);
412 return NULL;
413 }
414
415 return mvar;
416}
417
32ec8896
NC		 418/* Print a VMA value in the MODE specified.
419 Returns the number of characters displayed. */
cb8f3167 420
32ec8896 421static unsigned int
14a91970 422print_vma (bfd_vma vma, print_mode mode)
66543521 423{
32ec8896 424 unsigned int nc = 0;
66543521 425
14a91970 426 switch (mode)
66543521 427 {
14a91970
AM		 428 case FULL_HEX:
429 nc = printf ("0x");
1a0670f3 430 /* Fall through. */
14a91970 431 case LONG_HEX:
f7a99963 432#ifdef BFD64
14a91970 433 if (is_32bit_elf)
437c2fb7 434 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
f7a99963 435#endif
14a91970
AM		 436 printf_vma (vma);
437 return nc + 16;
b19aac67 438
14a91970
AM		 439 case DEC_5:
440 if (vma <= 99999)
441 return printf ("%5" BFD_VMA_FMT "d", vma);
1a0670f3 442 /* Fall through. */
14a91970
AM		 443 case PREFIX_HEX:
444 nc = printf ("0x");
1a0670f3 445 /* Fall through. */
14a91970
AM		 446 case HEX:
447 return nc + printf ("%" BFD_VMA_FMT "x", vma);
b19aac67 448
14a91970
AM		 449 case DEC:
450 return printf ("%" BFD_VMA_FMT "d", vma);
b19aac67 451
14a91970
AM		 452 case UNSIGNED:
453 return printf ("%" BFD_VMA_FMT "u", vma);
32ec8896
NC		 454
455 default:
456 /* FIXME: Report unrecognised mode ? */
457 return 0;
f7a99963 458 }
f7a99963
NC		 459}
460
7bfd842d 461/* Display a symbol on stdout. Handles the display of control characters and
3bfcb652 462 multibye characters (assuming the host environment supports them).
31104126 463
7bfd842d
NC		 464 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
465
466 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
467 padding as necessary.
171191ba
NC		 468
469 Returns the number of emitted characters. */
470
471static unsigned int
32ec8896 472print_symbol (signed int width, const char *symbol)
31104126 473{
171191ba 474 bfd_boolean extra_padding = FALSE;
32ec8896 475 signed int num_printed = 0;
3bfcb652 476#ifdef HAVE_MBSTATE_T
7bfd842d 477 mbstate_t state;
3bfcb652 478#endif
32ec8896 479 unsigned int width_remaining;
961c521f 480
7bfd842d 481 if (width < 0)
961c521f 482 {
961c521f
NC		 483 /* Keep the width positive. This also helps. */
484 width = - width;
171191ba 485 extra_padding = TRUE;
0b4362b0 486 }
74e1a04b 487 assert (width != 0);
961c521f 488
7bfd842d
NC		 489 if (do_wide)
490 /* Set the remaining width to a very large value.
491 This simplifies the code below. */
492 width_remaining = INT_MAX;
493 else
494 width_remaining = width;
cb8f3167 495
3bfcb652 496#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 497 /* Initialise the multibyte conversion state. */
498 memset (& state, 0, sizeof (state));
3bfcb652 499#endif
961c521f 500
7bfd842d
NC		 501 while (width_remaining)
502 {
503 size_t n;
7bfd842d 504 const char c = *symbol++;
961c521f 505
7bfd842d 506 if (c == 0)
961c521f
NC		 507 break;
508
7bfd842d
NC		 509 /* Do not print control characters directly as they can affect terminal
510 settings. Such characters usually appear in the names generated
511 by the assembler for local labels. */
512 if (ISCNTRL (c))
961c521f 513 {
7bfd842d 514 if (width_remaining < 2)
961c521f
NC		 515 break;
516
7bfd842d
NC		 517 printf ("^%c", c + 0x40);
518 width_remaining -= 2;
171191ba 519 num_printed += 2;
961c521f 520 }
7bfd842d
NC		 521 else if (ISPRINT (c))
522 {
523 putchar (c);
524 width_remaining --;
525 num_printed ++;
526 }
961c521f
NC		 527 else
528 {
3bfcb652
NC		 529#ifdef HAVE_MBSTATE_T
530 wchar_t w;
531#endif
7bfd842d
NC		 532 /* Let printf do the hard work of displaying multibyte characters. */
533 printf ("%.1s", symbol - 1);
534 width_remaining --;
535 num_printed ++;
536
3bfcb652 537#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 538 /* Try to find out how many bytes made up the character that was
539 just printed. Advance the symbol pointer past the bytes that
540 were displayed. */
541 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
3bfcb652
NC		 542#else
543 n = 1;
544#endif
7bfd842d
NC		 545 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
546 symbol += (n - 1);
961c521f 547 }
961c521f 548 }
171191ba 549
7bfd842d 550 if (extra_padding && num_printed < width)
171191ba
NC		 551 {
552 /* Fill in the remaining spaces. */
7bfd842d
NC		 553 printf ("%-*s", width - num_printed, " ");
554 num_printed = width;
171191ba
NC		 555 }
556
557 return num_printed;
31104126
NC		 558}
559
1449284b 560/* Returns a pointer to a static buffer containing a printable version of
74e1a04b
NC		 561 the given section's name. Like print_symbol, except that it does not try
562 to print multibyte characters, it just interprets them as hex values. */
563
564static const char *
0d2a7a93 565printable_section_name (const Elf_Internal_Shdr * sec)
74e1a04b
NC		 566{
567#define MAX_PRINT_SEC_NAME_LEN 128
568 static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
569 const char * name = SECTION_NAME (sec);
570 char * buf = sec_name_buf;
571 char c;
572 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
573
574 while ((c = * name ++) != 0)
575 {
576 if (ISCNTRL (c))
577 {
578 if (remaining < 2)
579 break;
948f632f 580
74e1a04b
NC		 581 * buf ++ = '^';
582 * buf ++ = c + 0x40;
583 remaining -= 2;
584 }
585 else if (ISPRINT (c))
586 {
587 * buf ++ = c;
588 remaining -= 1;
589 }
590 else
591 {
592 static char hex[17] = "0123456789ABCDEF";
593
594 if (remaining < 4)
595 break;
596 * buf ++ = '<';
597 * buf ++ = hex[(c & 0xf0) >> 4];
598 * buf ++ = hex[c & 0x0f];
599 * buf ++ = '>';
600 remaining -= 4;
601 }
602
603 if (remaining == 0)
604 break;
605 }
606
607 * buf = 0;
608 return sec_name_buf;
609}
610
611static const char *
612printable_section_name_from_index (unsigned long ndx)
613{
614 if (ndx >= elf_header.e_shnum)
615 return _("<corrupt>");
616
617 return printable_section_name (section_headers + ndx);
618}
619
89fac5e3
RS		 620/* Return a pointer to section NAME, or NULL if no such section exists. */
621
622static Elf_Internal_Shdr *
2cf0635d 623find_section (const char * name)
89fac5e3
RS		 624{
625 unsigned int i;
626
627 for (i = 0; i < elf_header.e_shnum; i++)
628 if (streq (SECTION_NAME (section_headers + i), name))
629 return section_headers + i;
630
631 return NULL;
632}
633
0b6ae522
DJ		 634/* Return a pointer to a section containing ADDR, or NULL if no such
635 section exists. */
636
637static Elf_Internal_Shdr *
638find_section_by_address (bfd_vma addr)
639{
640 unsigned int i;
641
642 for (i = 0; i < elf_header.e_shnum; i++)
643 {
644 Elf_Internal_Shdr *sec = section_headers + i;
645 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
646 return sec;
647 }
648
649 return NULL;
650}
651
071436c6
NC		 652static Elf_Internal_Shdr *
653find_section_by_type (unsigned int type)
654{
655 unsigned int i;
656
657 for (i = 0; i < elf_header.e_shnum; i++)
658 {
659 Elf_Internal_Shdr *sec = section_headers + i;
660 if (sec->sh_type == type)
661 return sec;
662 }
663
664 return NULL;
665}
666
657d0d47
CC		 667/* Return a pointer to section NAME, or NULL if no such section exists,
668 restricted to the list of sections given in SET. */
669
670static Elf_Internal_Shdr *
671find_section_in_set (const char * name, unsigned int * set)
672{
673 unsigned int i;
674
675 if (set != NULL)
676 {
677 while ((i = *set++) > 0)
b814a36d
NC		 678 {
679 /* See PR 21156 for a reproducer. */
680 if (i >= elf_header.e_shnum)
681 continue; /* FIXME: Should we issue an error message ? */
682
683 if (streq (SECTION_NAME (section_headers + i), name))
684 return section_headers + i;
685 }
657d0d47
CC		 686 }
687
688 return find_section (name);
689}
690
32ec8896
NC		 691/* Read an unsigned LEB128 encoded value from DATA.
692 Set *LENGTH_RETURN to the number of bytes read. */
0b6ae522 693
f6f0e17b 694static inline unsigned long
32ec8896
NC		 695read_uleb128 (unsigned char * data,
696 unsigned int * length_return,
f6f0e17b 697 const unsigned char * const end)
0b6ae522 698{
f6f0e17b 699 return read_leb128 (data, length_return, FALSE, end);
0b6ae522
DJ		 700}
701
32ec8896 702/* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
28f997cf
TG		 703 This OS has so many departures from the ELF standard that we test it at
704 many places. */
705
32ec8896 706static inline bfd_boolean
28f997cf
TG		 707is_ia64_vms (void)
708{
709 return elf_header.e_machine == EM_IA_64
710 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
711}
712
bcedfee6 713/* Guess the relocation size commonly used by the specific machines. */
252b5132 714
32ec8896 715static bfd_boolean
2dc4cec1 716guess_is_rela (unsigned int e_machine)
252b5132 717{
9c19a809 718 switch (e_machine)
252b5132
RH		 719 {
720 /* Targets that use REL relocations. */
252b5132 721 case EM_386:
22abe556 722 case EM_IAMCU:
63fcb9e9 723 case EM_960:
e9f53129 724 case EM_ARM:
2b0337b0 725 case EM_D10V:
252b5132 726 case EM_CYGNUS_D10V:
e9f53129 727 case EM_DLX:
252b5132 728 case EM_MIPS:
4fe85591 729 case EM_MIPS_RS3_LE:
e9f53129 730 case EM_CYGNUS_M32R:
1c0d3aa6 731 case EM_SCORE:
f6c1a2d5 732 case EM_XGATE:
9c19a809 733 return FALSE;
103f02d3 734
252b5132
RH		 735 /* Targets that use RELA relocations. */
736 case EM_68K:
e9f53129 737 case EM_860:
a06ea964 738 case EM_AARCH64:
cfb8c092 739 case EM_ADAPTEVA_EPIPHANY:
e9f53129
AM		 740 case EM_ALPHA:
741 case EM_ALTERA_NIOS2:
886a2506
NC		 742 case EM_ARC:
743 case EM_ARC_COMPACT:
744 case EM_ARC_COMPACT2:
e9f53129
AM		 745 case EM_AVR:
746 case EM_AVR_OLD:
747 case EM_BLACKFIN:
60bca95a 748 case EM_CR16:
e9f53129
AM		 749 case EM_CRIS:
750 case EM_CRX:
2b0337b0 751 case EM_D30V:
252b5132 752 case EM_CYGNUS_D30V:
2b0337b0 753 case EM_FR30:
3f8107ab 754 case EM_FT32:
252b5132 755 case EM_CYGNUS_FR30:
5c70f934 756 case EM_CYGNUS_FRV:
e9f53129
AM		 757 case EM_H8S:
758 case EM_H8_300:
759 case EM_H8_300H:
800eeca4 760 case EM_IA_64:
1e4cf259
NC		 761 case EM_IP2K:
762 case EM_IP2K_OLD:
3b36097d 763 case EM_IQ2000:
84e94c90 764 case EM_LATTICEMICO32:
ff7eeb89 765 case EM_M32C_OLD:
49f58d10 766 case EM_M32C:
e9f53129
AM		 767 case EM_M32R:
768 case EM_MCORE:
15ab5209 769 case EM_CYGNUS_MEP:
a3c62988 770 case EM_METAG:
e9f53129
AM		 771 case EM_MMIX:
772 case EM_MN10200:
773 case EM_CYGNUS_MN10200:
774 case EM_MN10300:
775 case EM_CYGNUS_MN10300:
5506d11a 776 case EM_MOXIE:
e9f53129
AM		 777 case EM_MSP430:
778 case EM_MSP430_OLD:
d031aafb 779 case EM_MT:
35c08157 780 case EM_NDS32:
64fd6348 781 case EM_NIOS32:
73589c9d 782 case EM_OR1K:
e9f53129
AM		 783 case EM_PPC64:
784 case EM_PPC:
2b100bb5 785 case EM_TI_PRU:
e23eba97 786 case EM_RISCV:
99c513f6 787 case EM_RL78:
c7927a3c 788 case EM_RX:
e9f53129
AM		 789 case EM_S390:
790 case EM_S390_OLD:
791 case EM_SH:
792 case EM_SPARC:
793 case EM_SPARC32PLUS:
794 case EM_SPARCV9:
795 case EM_SPU:
40b36596 796 case EM_TI_C6000:
aa137e4d
NC		 797 case EM_TILEGX:
798 case EM_TILEPRO:
708e2187 799 case EM_V800:
e9f53129
AM		 800 case EM_V850:
801 case EM_CYGNUS_V850:
802 case EM_VAX:
619ed720 803 case EM_VISIUM:
e9f53129 804 case EM_X86_64:
8a9036a4 805 case EM_L1OM:
7a9068fe 806 case EM_K1OM:
e9f53129
AM		 807 case EM_XSTORMY16:
808 case EM_XTENSA:
809 case EM_XTENSA_OLD:
7ba29e2a
NC		 810 case EM_MICROBLAZE:
811 case EM_MICROBLAZE_OLD:
9c19a809 812 return TRUE;
103f02d3 813
e9f53129
AM		 814 case EM_68HC05:
815 case EM_68HC08:
816 case EM_68HC11:
817 case EM_68HC16:
818 case EM_FX66:
819 case EM_ME16:
d1133906 820 case EM_MMA:
d1133906
NC		 821 case EM_NCPU:
822 case EM_NDR1:
e9f53129 823 case EM_PCP:
d1133906 824 case EM_ST100:
e9f53129 825 case EM_ST19:
d1133906 826 case EM_ST7:
e9f53129
AM		 827 case EM_ST9PLUS:
828 case EM_STARCORE:
d1133906 829 case EM_SVX:
e9f53129 830 case EM_TINYJ:
9c19a809
NC		 831 default:
832 warn (_("Don't know about relocations on this machine architecture\n"));
833 return FALSE;
834 }
835}
252b5132 836
32ec8896
NC		 837/* Load RELA type relocations from FILE at REL_OFFSET extending for REL_SIZE bytes.
838 Returns TRUE upon success, FALSE otherwise. If successful then a
839 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
840 and the number of relocs loaded is placed in *NRELASP. It is the caller's
841 responsibility to free the allocated buffer. */
842
843static bfd_boolean
2cf0635d 844slurp_rela_relocs (FILE * file,
d3ba0551
AM		 845 unsigned long rel_offset,
846 unsigned long rel_size,
2cf0635d
NC		 847 Elf_Internal_Rela ** relasp,
848 unsigned long * nrelasp)
9c19a809 849{
2cf0635d 850 Elf_Internal_Rela * relas;
8b73c356 851 size_t nrelas;
4d6ed7c8 852 unsigned int i;
252b5132 853
4d6ed7c8
NC		 854 if (is_32bit_elf)
855 {
2cf0635d 856 Elf32_External_Rela * erelas;
103f02d3 857
3f5e193b 858 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 859 rel_size, _("32-bit relocation data"));
a6e9f9df 860 if (!erelas)
32ec8896 861 return FALSE;
252b5132 862
4d6ed7c8 863 nrelas = rel_size / sizeof (Elf32_External_Rela);
103f02d3 864
3f5e193b
NC		 865 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
866 sizeof (Elf_Internal_Rela));
103f02d3 867
4d6ed7c8
NC		 868 if (relas == NULL)
869 {
c256ffe7 870 free (erelas);
591a748a 871 error (_("out of memory parsing relocs\n"));
32ec8896 872 return FALSE;
4d6ed7c8 873 }
103f02d3 874
4d6ed7c8
NC		 875 for (i = 0; i < nrelas; i++)
876 {
877 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
878 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 879 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
4d6ed7c8 880 }
103f02d3 881
4d6ed7c8
NC		 882 free (erelas);
883 }
884 else
885 {
2cf0635d 886 Elf64_External_Rela * erelas;
103f02d3 887
3f5e193b 888 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 889 rel_size, _("64-bit relocation data"));
a6e9f9df 890 if (!erelas)
32ec8896 891 return FALSE;
4d6ed7c8
NC		 892
893 nrelas = rel_size / sizeof (Elf64_External_Rela);
103f02d3 894
3f5e193b
NC		 895 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
896 sizeof (Elf_Internal_Rela));
103f02d3 897
4d6ed7c8
NC		 898 if (relas == NULL)
899 {
c256ffe7 900 free (erelas);
591a748a 901 error (_("out of memory parsing relocs\n"));
32ec8896 902 return FALSE;
9c19a809 903 }
4d6ed7c8
NC		 904
905 for (i = 0; i < nrelas; i++)
9c19a809 906 {
66543521
AM		 907 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
908 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 909 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
861fb55a
DJ		 910
911 /* The #ifdef BFD64 below is to prevent a compile time
912 warning. We know that if we do not have a 64 bit data
913 type that we will never execute this code anyway. */
914#ifdef BFD64
915 if (elf_header.e_machine == EM_MIPS
916 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
917 {
918 /* In little-endian objects, r_info isn't really a
919 64-bit little-endian value: it has a 32-bit
920 little-endian symbol index followed by four
921 individual byte fields. Reorder INFO
922 accordingly. */
91d6fa6a
NC		 923 bfd_vma inf = relas[i].r_info;
924 inf = (((inf & 0xffffffff) << 32)
925 | ((inf >> 56) & 0xff)
926 | ((inf >> 40) & 0xff00)
927 | ((inf >> 24) & 0xff0000)
928 | ((inf >> 8) & 0xff000000));
929 relas[i].r_info = inf;
861fb55a
DJ		 930 }
931#endif /* BFD64 */
4d6ed7c8 932 }
103f02d3 933
4d6ed7c8
NC		 934 free (erelas);
935 }
32ec8896 936
4d6ed7c8
NC		 937 *relasp = relas;
938 *nrelasp = nrelas;
32ec8896 939 return TRUE;
4d6ed7c8 940}
103f02d3 941
32ec8896
NC		 942/* Load REL type relocations from FILE at REL_OFFSET extending for REL_SIZE bytes.
943 Returns TRUE upon success, FALSE otherwise. If successful then a
944 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
945 and the number of relocs loaded is placed in *NRELSP. It is the caller's
946 responsibility to free the allocated buffer. */
947
948static bfd_boolean
2cf0635d 949slurp_rel_relocs (FILE * file,
d3ba0551
AM		 950 unsigned long rel_offset,
951 unsigned long rel_size,
2cf0635d
NC		 952 Elf_Internal_Rela ** relsp,
953 unsigned long * nrelsp)
4d6ed7c8 954{
2cf0635d 955 Elf_Internal_Rela * rels;
8b73c356 956 size_t nrels;
4d6ed7c8 957 unsigned int i;
103f02d3 958
4d6ed7c8
NC		 959 if (is_32bit_elf)
960 {
2cf0635d 961 Elf32_External_Rel * erels;
103f02d3 962
3f5e193b 963 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 964 rel_size, _("32-bit relocation data"));
a6e9f9df 965 if (!erels)
32ec8896 966 return FALSE;
103f02d3 967
4d6ed7c8 968 nrels = rel_size / sizeof (Elf32_External_Rel);
103f02d3 969
3f5e193b 970 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 971
4d6ed7c8
NC		 972 if (rels == NULL)
973 {
c256ffe7 974 free (erels);
591a748a 975 error (_("out of memory parsing relocs\n"));
32ec8896 976 return FALSE;
4d6ed7c8
NC		 977 }
978
979 for (i = 0; i < nrels; i++)
980 {
981 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
982 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 983 rels[i].r_addend = 0;
9ea033b2 984 }
4d6ed7c8
NC		 985
986 free (erels);
9c19a809
NC		 987 }
988 else
989 {
2cf0635d 990 Elf64_External_Rel * erels;
9ea033b2 991
3f5e193b 992 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 993 rel_size, _("64-bit relocation data"));
a6e9f9df 994 if (!erels)
32ec8896 995 return FALSE;
103f02d3 996
4d6ed7c8 997 nrels = rel_size / sizeof (Elf64_External_Rel);
103f02d3 998
3f5e193b 999 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 1000
4d6ed7c8 1001 if (rels == NULL)
9c19a809 1002 {
c256ffe7 1003 free (erels);
591a748a 1004 error (_("out of memory parsing relocs\n"));
32ec8896 1005 return FALSE;
4d6ed7c8 1006 }
103f02d3 1007
4d6ed7c8
NC		 1008 for (i = 0; i < nrels; i++)
1009 {
66543521
AM		 1010 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1011 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 1012 rels[i].r_addend = 0;
861fb55a
DJ		 1013
1014 /* The #ifdef BFD64 below is to prevent a compile time
1015 warning. We know that if we do not have a 64 bit data
1016 type that we will never execute this code anyway. */
1017#ifdef BFD64
1018 if (elf_header.e_machine == EM_MIPS
1019 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
1020 {
1021 /* In little-endian objects, r_info isn't really a
1022 64-bit little-endian value: it has a 32-bit
1023 little-endian symbol index followed by four
1024 individual byte fields. Reorder INFO
1025 accordingly. */
91d6fa6a
NC		 1026 bfd_vma inf = rels[i].r_info;
1027 inf = (((inf & 0xffffffff) << 32)
1028 | ((inf >> 56) & 0xff)
1029 | ((inf >> 40) & 0xff00)
1030 | ((inf >> 24) & 0xff0000)
1031 | ((inf >> 8) & 0xff000000));
1032 rels[i].r_info = inf;
861fb55a
DJ		 1033 }
1034#endif /* BFD64 */
4d6ed7c8 1035 }
103f02d3 1036
4d6ed7c8
NC		 1037 free (erels);
1038 }
32ec8896 1039
4d6ed7c8
NC		 1040 *relsp = rels;
1041 *nrelsp = nrels;
32ec8896 1042 return TRUE;
4d6ed7c8 1043}
103f02d3 1044
aca88567
NC		 1045/* Returns the reloc type extracted from the reloc info field. */
1046
1047static unsigned int
1048get_reloc_type (bfd_vma reloc_info)
1049{
1050 if (is_32bit_elf)
1051 return ELF32_R_TYPE (reloc_info);
1052
1053 switch (elf_header.e_machine)
1054 {
1055 case EM_MIPS:
1056 /* Note: We assume that reloc_info has already been adjusted for us. */
1057 return ELF64_MIPS_R_TYPE (reloc_info);
1058
1059 case EM_SPARCV9:
1060 return ELF64_R_TYPE_ID (reloc_info);
1061
1062 default:
1063 return ELF64_R_TYPE (reloc_info);
1064 }
1065}
1066
1067/* Return the symbol index extracted from the reloc info field. */
1068
1069static bfd_vma
1070get_reloc_symindex (bfd_vma reloc_info)
1071{
1072 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1073}
1074
13761a11
NC		 1075static inline bfd_boolean
1076uses_msp430x_relocs (void)
1077{
1078 return
1079 elf_header.e_machine == EM_MSP430 /* Paranoia. */
1080 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1081 && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1082 /* TI compiler uses ELFOSABI_NONE. */
1083 || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1084}
1085
d3ba0551
AM		 1086/* Display the contents of the relocation data found at the specified
1087 offset. */
ee42cf8c 1088
32ec8896 1089static bfd_boolean
2cf0635d 1090dump_relocations (FILE * file,
d3ba0551
AM		 1091 unsigned long rel_offset,
1092 unsigned long rel_size,
2cf0635d 1093 Elf_Internal_Sym * symtab,
d3ba0551 1094 unsigned long nsyms,
2cf0635d 1095 char * strtab,
d79b3d50 1096 unsigned long strtablen,
bb4d2ac2 1097 int is_rela,
32ec8896 1098 bfd_boolean is_dynsym)
4d6ed7c8 1099{
32ec8896 1100 unsigned long i;
2cf0635d 1101 Elf_Internal_Rela * rels;
32ec8896 1102 bfd_boolean res = TRUE;
103f02d3 1103
4d6ed7c8
NC		 1104 if (is_rela == UNKNOWN)
1105 is_rela = guess_is_rela (elf_header.e_machine);
103f02d3 1106
4d6ed7c8
NC		 1107 if (is_rela)
1108 {
c8286bd1 1109 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
32ec8896 1110 return FALSE;
4d6ed7c8
NC		 1111 }
1112 else
1113 {
1114 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
32ec8896 1115 return FALSE;
252b5132
RH		 1116 }
1117
410f7a12
L		 1118 if (is_32bit_elf)
1119 {
1120 if (is_rela)
2c71103e
NC		 1121 {
1122 if (do_wide)
1123 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1124 else
1125 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1126 }
410f7a12 1127 else
2c71103e
NC		 1128 {
1129 if (do_wide)
1130 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1131 else
1132 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1133 }
410f7a12 1134 }
252b5132 1135 else
410f7a12
L		 1136 {
1137 if (is_rela)
2c71103e
NC		 1138 {
1139 if (do_wide)
8beeaeb7 1140 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
2c71103e
NC		 1141 else
1142 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1143 }
410f7a12 1144 else
2c71103e
NC		 1145 {
1146 if (do_wide)
8beeaeb7 1147 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
2c71103e
NC		 1148 else
1149 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1150 }
410f7a12 1151 }
252b5132
RH		 1152
1153 for (i = 0; i < rel_size; i++)
1154 {
2cf0635d 1155 const char * rtype;
b34976b6 1156 bfd_vma offset;
91d6fa6a 1157 bfd_vma inf;
b34976b6
AM		 1158 bfd_vma symtab_index;
1159 bfd_vma type;
103f02d3 1160
b34976b6 1161 offset = rels[i].r_offset;
91d6fa6a 1162 inf = rels[i].r_info;
103f02d3 1163
91d6fa6a
NC		 1164 type = get_reloc_type (inf);
1165 symtab_index = get_reloc_symindex (inf);
252b5132 1166
410f7a12
L		 1167 if (is_32bit_elf)
1168 {
39dbeff8
AM		 1169 printf ("%8.8lx %8.8lx ",
1170 (unsigned long) offset & 0xffffffff,
91d6fa6a 1171 (unsigned long) inf & 0xffffffff);
410f7a12
L		 1172 }
1173 else
1174 {
39dbeff8
AM		 1175#if BFD_HOST_64BIT_LONG
1176 printf (do_wide
1177 ? "%16.16lx %16.16lx "
1178 : "%12.12lx %12.12lx ",
91d6fa6a 1179 offset, inf);
39dbeff8 1180#elif BFD_HOST_64BIT_LONG_LONG
6e3d6dc1 1181#ifndef __MSVCRT__
39dbeff8
AM		 1182 printf (do_wide
1183 ? "%16.16llx %16.16llx "
1184 : "%12.12llx %12.12llx ",
91d6fa6a 1185 offset, inf);
6e3d6dc1
NC		 1186#else
1187 printf (do_wide
1188 ? "%16.16I64x %16.16I64x "
1189 : "%12.12I64x %12.12I64x ",
91d6fa6a 1190 offset, inf);
6e3d6dc1 1191#endif
39dbeff8 1192#else
2c71103e
NC		 1193 printf (do_wide
1194 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1195 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
410f7a12
L		 1196 _bfd_int64_high (offset),
1197 _bfd_int64_low (offset),
91d6fa6a
NC		 1198 _bfd_int64_high (inf),
1199 _bfd_int64_low (inf));
9ea033b2 1200#endif
410f7a12 1201 }
103f02d3 1202
252b5132
RH		 1203 switch (elf_header.e_machine)
1204 {
1205 default:
1206 rtype = NULL;
1207 break;
1208
a06ea964
NC		 1209 case EM_AARCH64:
1210 rtype = elf_aarch64_reloc_type (type);
1211 break;
1212
2b0337b0 1213 case EM_M32R:
252b5132 1214 case EM_CYGNUS_M32R:
9ea033b2 1215 rtype = elf_m32r_reloc_type (type);
252b5132
RH		 1216 break;
1217
1218 case EM_386:
22abe556 1219 case EM_IAMCU:
9ea033b2 1220 rtype = elf_i386_reloc_type (type);
252b5132
RH		 1221 break;
1222
ba2685cc
AM		 1223 case EM_68HC11:
1224 case EM_68HC12:
1225 rtype = elf_m68hc11_reloc_type (type);
1226 break;
75751cd9 1227
252b5132 1228 case EM_68K:
9ea033b2 1229 rtype = elf_m68k_reloc_type (type);
252b5132
RH		 1230 break;
1231
63fcb9e9 1232 case EM_960:
9ea033b2 1233 rtype = elf_i960_reloc_type (type);
63fcb9e9
ILT		 1234 break;
1235
adde6300 1236 case EM_AVR:
2b0337b0 1237 case EM_AVR_OLD:
adde6300
AM		 1238 rtype = elf_avr_reloc_type (type);
1239 break;
1240
9ea033b2
NC		 1241 case EM_OLD_SPARCV9:
1242 case EM_SPARC32PLUS:
1243 case EM_SPARCV9:
252b5132 1244 case EM_SPARC:
9ea033b2 1245 rtype = elf_sparc_reloc_type (type);
252b5132
RH		 1246 break;
1247
e9f53129
AM		 1248 case EM_SPU:
1249 rtype = elf_spu_reloc_type (type);
1250 break;
1251
708e2187
NC		 1252 case EM_V800:
1253 rtype = v800_reloc_type (type);
1254 break;
2b0337b0 1255 case EM_V850:
252b5132 1256 case EM_CYGNUS_V850:
9ea033b2 1257 rtype = v850_reloc_type (type);
252b5132
RH		 1258 break;
1259
2b0337b0 1260 case EM_D10V:
252b5132 1261 case EM_CYGNUS_D10V:
9ea033b2 1262 rtype = elf_d10v_reloc_type (type);
252b5132
RH		 1263 break;
1264
2b0337b0 1265 case EM_D30V:
252b5132 1266 case EM_CYGNUS_D30V:
9ea033b2 1267 rtype = elf_d30v_reloc_type (type);
252b5132
RH		 1268 break;
1269
d172d4ba
NC		 1270 case EM_DLX:
1271 rtype = elf_dlx_reloc_type (type);
1272 break;
1273
252b5132 1274 case EM_SH:
9ea033b2 1275 rtype = elf_sh_reloc_type (type);
252b5132
RH		 1276 break;
1277
2b0337b0 1278 case EM_MN10300:
252b5132 1279 case EM_CYGNUS_MN10300:
9ea033b2 1280 rtype = elf_mn10300_reloc_type (type);
252b5132
RH		 1281 break;
1282
2b0337b0 1283 case EM_MN10200:
252b5132 1284 case EM_CYGNUS_MN10200:
9ea033b2 1285 rtype = elf_mn10200_reloc_type (type);
252b5132
RH		 1286 break;
1287
2b0337b0 1288 case EM_FR30:
252b5132 1289 case EM_CYGNUS_FR30:
9ea033b2 1290 rtype = elf_fr30_reloc_type (type);
252b5132
RH		 1291 break;
1292
ba2685cc
AM		 1293 case EM_CYGNUS_FRV:
1294 rtype = elf_frv_reloc_type (type);
1295 break;
5c70f934 1296
3f8107ab
AM		 1297 case EM_FT32:
1298 rtype = elf_ft32_reloc_type (type);
1299 break;
1300
252b5132 1301 case EM_MCORE:
9ea033b2 1302 rtype = elf_mcore_reloc_type (type);
252b5132
RH		 1303 break;
1304
3c3bdf30
NC		 1305 case EM_MMIX:
1306 rtype = elf_mmix_reloc_type (type);
1307 break;
1308
5506d11a
AM		 1309 case EM_MOXIE:
1310 rtype = elf_moxie_reloc_type (type);
1311 break;
1312
2469cfa2 1313 case EM_MSP430:
13761a11
NC		 1314 if (uses_msp430x_relocs ())
1315 {
1316 rtype = elf_msp430x_reloc_type (type);
1317 break;
1318 }
1a0670f3 1319 /* Fall through. */
2469cfa2
NC		 1320 case EM_MSP430_OLD:
1321 rtype = elf_msp430_reloc_type (type);
1322 break;
1323
35c08157
KLC		 1324 case EM_NDS32:
1325 rtype = elf_nds32_reloc_type (type);
1326 break;
1327
252b5132 1328 case EM_PPC:
9ea033b2 1329 rtype = elf_ppc_reloc_type (type);
252b5132
RH		 1330 break;
1331
c833c019
AM		 1332 case EM_PPC64:
1333 rtype = elf_ppc64_reloc_type (type);
1334 break;
1335
252b5132 1336 case EM_MIPS:
4fe85591 1337 case EM_MIPS_RS3_LE:
9ea033b2 1338 rtype = elf_mips_reloc_type (type);
252b5132
RH		 1339 break;
1340
e23eba97
NC		 1341 case EM_RISCV:
1342 rtype = elf_riscv_reloc_type (type);
1343 break;
1344
252b5132 1345 case EM_ALPHA:
9ea033b2 1346 rtype = elf_alpha_reloc_type (type);
252b5132
RH		 1347 break;
1348
1349 case EM_ARM:
9ea033b2 1350 rtype = elf_arm_reloc_type (type);
252b5132
RH		 1351 break;
1352
584da044 1353 case EM_ARC:
886a2506
NC		 1354 case EM_ARC_COMPACT:
1355 case EM_ARC_COMPACT2:
9ea033b2 1356 rtype = elf_arc_reloc_type (type);
252b5132
RH		 1357 break;
1358
1359 case EM_PARISC:
69e617ca 1360 rtype = elf_hppa_reloc_type (type);
252b5132 1361 break;
7d466069 1362
b8720f9d
JL		 1363 case EM_H8_300:
1364 case EM_H8_300H:
1365 case EM_H8S:
1366 rtype = elf_h8_reloc_type (type);
1367 break;
1368
73589c9d
CS		 1369 case EM_OR1K:
1370 rtype = elf_or1k_reloc_type (type);
3b16e843
NC		 1371 break;
1372
7d466069 1373 case EM_PJ:
2b0337b0 1374 case EM_PJ_OLD:
7d466069
ILT		 1375 rtype = elf_pj_reloc_type (type);
1376 break;
800eeca4
JW		 1377 case EM_IA_64:
1378 rtype = elf_ia64_reloc_type (type);
1379 break;
1b61cf92
HPN		 1380
1381 case EM_CRIS:
1382 rtype = elf_cris_reloc_type (type);
1383 break;
535c37ff
JE		 1384
1385 case EM_860:
1386 rtype = elf_i860_reloc_type (type);
1387 break;
bcedfee6
NC		 1388
1389 case EM_X86_64:
8a9036a4 1390 case EM_L1OM:
7a9068fe 1391 case EM_K1OM:
bcedfee6
NC		 1392 rtype = elf_x86_64_reloc_type (type);
1393 break;
a85d7ed0 1394
35b1837e
AM		 1395 case EM_S370:
1396 rtype = i370_reloc_type (type);
1397 break;
1398
53c7db4b
KH		 1399 case EM_S390_OLD:
1400 case EM_S390:
1401 rtype = elf_s390_reloc_type (type);
1402 break;
93fbbb04 1403
1c0d3aa6
NC		 1404 case EM_SCORE:
1405 rtype = elf_score_reloc_type (type);
1406 break;
1407
93fbbb04
GK		 1408 case EM_XSTORMY16:
1409 rtype = elf_xstormy16_reloc_type (type);
1410 break;
179d3252 1411
1fe1f39c
NC		 1412 case EM_CRX:
1413 rtype = elf_crx_reloc_type (type);
1414 break;
1415
179d3252
JT		 1416 case EM_VAX:
1417 rtype = elf_vax_reloc_type (type);
1418 break;
1e4cf259 1419
619ed720
EB		 1420 case EM_VISIUM:
1421 rtype = elf_visium_reloc_type (type);
1422 break;
1423
cfb8c092
NC		 1424 case EM_ADAPTEVA_EPIPHANY:
1425 rtype = elf_epiphany_reloc_type (type);
1426 break;
1427
1e4cf259
NC		 1428 case EM_IP2K:
1429 case EM_IP2K_OLD:
1430 rtype = elf_ip2k_reloc_type (type);
1431 break;
3b36097d
SC		 1432
1433 case EM_IQ2000:
1434 rtype = elf_iq2000_reloc_type (type);
1435 break;
88da6820
NC		 1436
1437 case EM_XTENSA_OLD:
1438 case EM_XTENSA:
1439 rtype = elf_xtensa_reloc_type (type);
1440 break;
a34e3ecb 1441
84e94c90
NC		 1442 case EM_LATTICEMICO32:
1443 rtype = elf_lm32_reloc_type (type);
1444 break;
1445
ff7eeb89 1446 case EM_M32C_OLD:
49f58d10
JB		 1447 case EM_M32C:
1448 rtype = elf_m32c_reloc_type (type);
1449 break;
1450
d031aafb
NS		 1451 case EM_MT:
1452 rtype = elf_mt_reloc_type (type);
a34e3ecb 1453 break;
1d65ded4
CM		 1454
1455 case EM_BLACKFIN:
1456 rtype = elf_bfin_reloc_type (type);
1457 break;
15ab5209
DB		 1458
1459 case EM_CYGNUS_MEP:
1460 rtype = elf_mep_reloc_type (type);
1461 break;
60bca95a
NC		 1462
1463 case EM_CR16:
1464 rtype = elf_cr16_reloc_type (type);
1465 break;
dd24e3da 1466
7ba29e2a
NC		 1467 case EM_MICROBLAZE:
1468 case EM_MICROBLAZE_OLD:
1469 rtype = elf_microblaze_reloc_type (type);
1470 break;
c7927a3c 1471
99c513f6
DD		 1472 case EM_RL78:
1473 rtype = elf_rl78_reloc_type (type);
1474 break;
1475
c7927a3c
NC		 1476 case EM_RX:
1477 rtype = elf_rx_reloc_type (type);
1478 break;
c29aca4a 1479
a3c62988
NC		 1480 case EM_METAG:
1481 rtype = elf_metag_reloc_type (type);
1482 break;
1483
c29aca4a
NC		 1484 case EM_XC16X:
1485 case EM_C166:
1486 rtype = elf_xc16x_reloc_type (type);
1487 break;
40b36596
JM		 1488
1489 case EM_TI_C6000:
1490 rtype = elf_tic6x_reloc_type (type);
1491 break;
aa137e4d
NC		 1492
1493 case EM_TILEGX:
1494 rtype = elf_tilegx_reloc_type (type);
1495 break;
1496
1497 case EM_TILEPRO:
1498 rtype = elf_tilepro_reloc_type (type);
1499 break;
f6c1a2d5
NC		 1500
1501 case EM_XGATE:
1502 rtype = elf_xgate_reloc_type (type);
1503 break;
36591ba1
SL		 1504
1505 case EM_ALTERA_NIOS2:
1506 rtype = elf_nios2_reloc_type (type);
1507 break;
2b100bb5
DD		 1508
1509 case EM_TI_PRU:
1510 rtype = elf_pru_reloc_type (type);
1511 break;
252b5132
RH		 1512 }
1513
1514 if (rtype == NULL)
39dbeff8 1515 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1516 else
8beeaeb7 1517 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1518
7ace3541 1519 if (elf_header.e_machine == EM_ALPHA
157c2599 1520 && rtype != NULL
7ace3541
RH		 1521 && streq (rtype, "R_ALPHA_LITUSE")
1522 && is_rela)
1523 {
1524 switch (rels[i].r_addend)
1525 {
1526 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1527 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1528 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1529 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1530 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1531 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1532 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1533 default: rtype = NULL;
1534 }
32ec8896 1535
7ace3541
RH		 1536 if (rtype)
1537 printf (" (%s)", rtype);
1538 else
1539 {
1540 putchar (' ');
1541 printf (_("<unknown addend: %lx>"),
1542 (unsigned long) rels[i].r_addend);
32ec8896 1543 res = FALSE;
7ace3541
RH		 1544 }
1545 }
1546 else if (symtab_index)
252b5132 1547 {
af3fc3bc 1548 if (symtab == NULL || symtab_index >= nsyms)
32ec8896
NC		 1549 {
1550 error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index);
1551 res = FALSE;
1552 }
af3fc3bc 1553 else
19936277 1554 {
2cf0635d 1555 Elf_Internal_Sym * psym;
bb4d2ac2
L		 1556 const char * version_string;
1557 enum versioned_symbol_info sym_info;
1558 unsigned short vna_other;
19936277 1559
af3fc3bc 1560 psym = symtab + symtab_index;
103f02d3 1561
bb4d2ac2
L		 1562 version_string
1563 = get_symbol_version_string (file, is_dynsym,
1564 strtab, strtablen,
1565 symtab_index,
1566 psym,
1567 &sym_info,
1568 &vna_other);
1569
af3fc3bc 1570 printf (" ");
171191ba 1571
d8045f23
NC		 1572 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1573 {
1574 const char * name;
1575 unsigned int len;
1576 unsigned int width = is_32bit_elf ? 8 : 14;
1577
1578 /* Relocations against GNU_IFUNC symbols do not use the value
1579 of the symbol as the address to relocate against. Instead
1580 they invoke the function named by the symbol and use its
1581 result as the address for relocation.
1582
1583 To indicate this to the user, do not display the value of
1584 the symbol in the "Symbols's Value" field. Instead show
1585 its name followed by () as a hint that the symbol is
1586 invoked. */
1587
1588 if (strtab == NULL
1589 || psym->st_name == 0
1590 || psym->st_name >= strtablen)
1591 name = "??";
1592 else
1593 name = strtab + psym->st_name;
1594
1595 len = print_symbol (width, name);
bb4d2ac2
L		 1596 if (version_string)
1597 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1598 version_string);
d8045f23
NC		 1599 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1600 }
1601 else
1602 {
1603 print_vma (psym->st_value, LONG_HEX);
171191ba 1604
d8045f23
NC		 1605 printf (is_32bit_elf ? " " : " ");
1606 }
103f02d3 1607
af3fc3bc 1608 if (psym->st_name == 0)
f1ef08cb 1609 {
2cf0635d 1610 const char * sec_name = "<null>";
f1ef08cb
AM		 1611 char name_buf[40];
1612
1613 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1614 {
4fbb74a6 1615 if (psym->st_shndx < elf_header.e_shnum)
74e1a04b 1616 sec_name = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM		 1617 else if (psym->st_shndx == SHN_ABS)
1618 sec_name = "ABS";
1619 else if (psym->st_shndx == SHN_COMMON)
1620 sec_name = "COMMON";
ac145307
BS		 1621 else if ((elf_header.e_machine == EM_MIPS
1622 && psym->st_shndx == SHN_MIPS_SCOMMON)
1623 || (elf_header.e_machine == EM_TI_C6000
1624 && psym->st_shndx == SHN_TIC6X_SCOMMON))
172553c7
TS		 1625 sec_name = "SCOMMON";
1626 else if (elf_header.e_machine == EM_MIPS
1627 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1628 sec_name = "SUNDEF";
8a9036a4 1629 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 1630 || elf_header.e_machine == EM_L1OM
1631 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 1632 && psym->st_shndx == SHN_X86_64_LCOMMON)
1633 sec_name = "LARGE_COMMON";
9ce701e2
L		 1634 else if (elf_header.e_machine == EM_IA_64
1635 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1636 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1637 sec_name = "ANSI_COM";
28f997cf 1638 else if (is_ia64_vms ()
148b93f2
NC		 1639 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1640 sec_name = "VMS_SYMVEC";
f1ef08cb
AM		 1641 else
1642 {
1643 sprintf (name_buf, "<section 0x%x>",
1644 (unsigned int) psym->st_shndx);
1645 sec_name = name_buf;
1646 }
1647 }
1648 print_symbol (22, sec_name);
1649 }
af3fc3bc 1650 else if (strtab == NULL)
d79b3d50 1651 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1652 else if (psym->st_name >= strtablen)
32ec8896
NC		 1653 {
1654 error (_("<corrupt string table index: %3ld>"), psym->st_name);
1655 res = FALSE;
1656 }
af3fc3bc 1657 else
bb4d2ac2
L		 1658 {
1659 print_symbol (22, strtab + psym->st_name);
1660 if (version_string)
1661 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1662 version_string);
1663 }
103f02d3 1664
af3fc3bc 1665 if (is_rela)
171191ba 1666 {
7360e63f 1667 bfd_vma off = rels[i].r_addend;
171191ba 1668
7360e63f 1669 if ((bfd_signed_vma) off < 0)
598aaa76 1670 printf (" - %" BFD_VMA_FMT "x", - off);
171191ba 1671 else
598aaa76 1672 printf (" + %" BFD_VMA_FMT "x", off);
171191ba 1673 }
19936277 1674 }
252b5132 1675 }
1b228002 1676 else if (is_rela)
f7a99963 1677 {
7360e63f 1678 bfd_vma off = rels[i].r_addend;
e04d7088
L		 1679
1680 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
7360e63f 1681 if ((bfd_signed_vma) off < 0)
e04d7088
L		 1682 printf ("-%" BFD_VMA_FMT "x", - off);
1683 else
1684 printf ("%" BFD_VMA_FMT "x", off);
f7a99963 1685 }
252b5132 1686
157c2599
NC		 1687 if (elf_header.e_machine == EM_SPARCV9
1688 && rtype != NULL
1689 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1690 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1691
252b5132 1692 putchar ('\n');
2c71103e 1693
aca88567 1694#ifdef BFD64
53c7db4b 1695 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1696 {
91d6fa6a
NC		 1697 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1698 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC		 1699 const char * rtype2 = elf_mips_reloc_type (type2);
1700 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1701
2c71103e
NC		 1702 printf (" Type2: ");
1703
1704 if (rtype2 == NULL)
39dbeff8
AM		 1705 printf (_("unrecognized: %-7lx"),
1706 (unsigned long) type2 & 0xffffffff);
2c71103e
NC		 1707 else
1708 printf ("%-17.17s", rtype2);
1709
18bd398b 1710 printf ("\n Type3: ");
2c71103e
NC		 1711
1712 if (rtype3 == NULL)
39dbeff8
AM		 1713 printf (_("unrecognized: %-7lx"),
1714 (unsigned long) type3 & 0xffffffff);
2c71103e
NC		 1715 else
1716 printf ("%-17.17s", rtype3);
1717
53c7db4b 1718 putchar ('\n');
2c71103e 1719 }
aca88567 1720#endif /* BFD64 */
252b5132
RH		 1721 }
1722
c8286bd1 1723 free (rels);
32ec8896
NC		 1724
1725 return res;
252b5132
RH		 1726}
1727
1728static const char *
d3ba0551 1729get_mips_dynamic_type (unsigned long type)
252b5132
RH		 1730{
1731 switch (type)
1732 {
1733 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1734 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1735 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1736 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1737 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1738 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1739 case DT_MIPS_MSYM: return "MIPS_MSYM";
1740 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1741 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1742 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1743 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1744 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1745 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1746 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1747 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1748 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1749 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
a5499fa4 1750 case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
252b5132
RH		 1751 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1752 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1753 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1754 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1755 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1756 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1757 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1758 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1759 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1760 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1761 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1762 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1763 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1764 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1765 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1766 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1767 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1768 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1769 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1770 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1771 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1772 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1773 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1774 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1775 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1776 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1777 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1778 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1779 default:
1780 return NULL;
1781 }
1782}
1783
9a097730 1784static const char *
d3ba0551 1785get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1786{
1787 switch (type)
1788 {
1789 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1790 default:
1791 return NULL;
1792 }
103f02d3
UD		 1793}
1794
7490d522
AM		 1795static const char *
1796get_ppc_dynamic_type (unsigned long type)
1797{
1798 switch (type)
1799 {
a7f2871e 1800 case DT_PPC_GOT: return "PPC_GOT";
e8910a83 1801 case DT_PPC_OPT: return "PPC_OPT";
7490d522
AM		 1802 default:
1803 return NULL;
1804 }
1805}
1806
f1cb7e17 1807static const char *
d3ba0551 1808get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1809{
1810 switch (type)
1811 {
a7f2871e
AM		 1812 case DT_PPC64_GLINK: return "PPC64_GLINK";
1813 case DT_PPC64_OPD: return "PPC64_OPD";
1814 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
e8910a83 1815 case DT_PPC64_OPT: return "PPC64_OPT";
f1cb7e17
AM		 1816 default:
1817 return NULL;
1818 }
1819}
1820
103f02d3 1821static const char *
d3ba0551 1822get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1823{
1824 switch (type)
1825 {
1826 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1827 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1828 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1829 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1830 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1831 case DT_HP_PREINIT: return "HP_PREINIT";
1832 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1833 case DT_HP_NEEDED: return "HP_NEEDED";
1834 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1835 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1836 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1837 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1838 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1839 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1840 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1841 case DT_HP_FILTERED: return "HP_FILTERED";
1842 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1843 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1844 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1845 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1846 case DT_PLT: return "PLT";
1847 case DT_PLT_SIZE: return "PLT_SIZE";
1848 case DT_DLT: return "DLT";
1849 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1850 default:
1851 return NULL;
1852 }
1853}
9a097730 1854
ecc51f48 1855static const char *
d3ba0551 1856get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1857{
1858 switch (type)
1859 {
148b93f2
NC		 1860 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1861 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1862 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1863 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1864 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1865 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1866 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1867 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1868 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1869 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1870 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1871 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1872 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1873 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1874 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1875 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1876 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1877 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1878 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1879 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1880 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1881 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1882 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1883 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1884 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1885 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1886 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1887 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1888 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1889 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1890 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1891 default:
1892 return NULL;
1893 }
1894}
1895
fd85a6a1
NC		 1896static const char *
1897get_solaris_section_type (unsigned long type)
1898{
1899 switch (type)
1900 {
1901 case 0x6fffffee: return "SUNW_ancillary";
1902 case 0x6fffffef: return "SUNW_capchain";
1903 case 0x6ffffff0: return "SUNW_capinfo";
1904 case 0x6ffffff1: return "SUNW_symsort";
1905 case 0x6ffffff2: return "SUNW_tlssort";
1906 case 0x6ffffff3: return "SUNW_LDYNSYM";
1907 case 0x6ffffff4: return "SUNW_dof";
1908 case 0x6ffffff5: return "SUNW_cap";
1909 case 0x6ffffff6: return "SUNW_SIGNATURE";
1910 case 0x6ffffff7: return "SUNW_ANNOTATE";
1911 case 0x6ffffff8: return "SUNW_DEBUGSTR";
1912 case 0x6ffffff9: return "SUNW_DEBUG";
1913 case 0x6ffffffa: return "SUNW_move";
1914 case 0x6ffffffb: return "SUNW_COMDAT";
1915 case 0x6ffffffc: return "SUNW_syminfo";
1916 case 0x6ffffffd: return "SUNW_verdef";
1917 case 0x6ffffffe: return "SUNW_verneed";
1918 case 0x6fffffff: return "SUNW_versym";
1919 case 0x70000000: return "SPARC_GOTDATA";
1920 default: return NULL;
1921 }
1922}
1923
fabcb361
RH		 1924static const char *
1925get_alpha_dynamic_type (unsigned long type)
1926{
1927 switch (type)
1928 {
1929 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
32ec8896 1930 default: return NULL;
fabcb361
RH		 1931 }
1932}
1933
1c0d3aa6
NC		 1934static const char *
1935get_score_dynamic_type (unsigned long type)
1936{
1937 switch (type)
1938 {
1939 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1940 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1941 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1942 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1943 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1944 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
32ec8896 1945 default: return NULL;
1c0d3aa6
NC		 1946 }
1947}
1948
40b36596
JM		 1949static const char *
1950get_tic6x_dynamic_type (unsigned long type)
1951{
1952 switch (type)
1953 {
1954 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1955 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1956 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1957 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1958 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1959 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
32ec8896 1960 default: return NULL;
40b36596
JM		 1961 }
1962}
1c0d3aa6 1963
36591ba1
SL		 1964static const char *
1965get_nios2_dynamic_type (unsigned long type)
1966{
1967 switch (type)
1968 {
1969 case DT_NIOS2_GP: return "NIOS2_GP";
32ec8896 1970 default: return NULL;
36591ba1
SL		 1971 }
1972}
1973
fd85a6a1
NC		 1974static const char *
1975get_solaris_dynamic_type (unsigned long type)
1976{
1977 switch (type)
1978 {
1979 case 0x6000000d: return "SUNW_AUXILIARY";
1980 case 0x6000000e: return "SUNW_RTLDINF";
1981 case 0x6000000f: return "SUNW_FILTER";
1982 case 0x60000010: return "SUNW_CAP";
1983 case 0x60000011: return "SUNW_SYMTAB";
1984 case 0x60000012: return "SUNW_SYMSZ";
1985 case 0x60000013: return "SUNW_SORTENT";
1986 case 0x60000014: return "SUNW_SYMSORT";
1987 case 0x60000015: return "SUNW_SYMSORTSZ";
1988 case 0x60000016: return "SUNW_TLSSORT";
1989 case 0x60000017: return "SUNW_TLSSORTSZ";
1990 case 0x60000018: return "SUNW_CAPINFO";
1991 case 0x60000019: return "SUNW_STRPAD";
1992 case 0x6000001a: return "SUNW_CAPCHAIN";
1993 case 0x6000001b: return "SUNW_LDMACH";
1994 case 0x6000001d: return "SUNW_CAPCHAINENT";
1995 case 0x6000001f: return "SUNW_CAPCHAINSZ";
1996 case 0x60000021: return "SUNW_PARENT";
1997 case 0x60000023: return "SUNW_ASLR";
1998 case 0x60000025: return "SUNW_RELAX";
1999 case 0x60000029: return "SUNW_NXHEAP";
2000 case 0x6000002b: return "SUNW_NXSTACK";
2001
2002 case 0x70000001: return "SPARC_REGISTER";
2003 case 0x7ffffffd: return "AUXILIARY";
2004 case 0x7ffffffe: return "USED";
2005 case 0x7fffffff: return "FILTER";
2006
15f205b1 2007 default: return NULL;
fd85a6a1
NC		 2008 }
2009}
2010
252b5132 2011static const char *
d3ba0551 2012get_dynamic_type (unsigned long type)
252b5132 2013{
e9e44622 2014 static char buff[64];
252b5132
RH		 2015
2016 switch (type)
2017 {
2018 case DT_NULL: return "NULL";
2019 case DT_NEEDED: return "NEEDED";
2020 case DT_PLTRELSZ: return "PLTRELSZ";
2021 case DT_PLTGOT: return "PLTGOT";
2022 case DT_HASH: return "HASH";
2023 case DT_STRTAB: return "STRTAB";
2024 case DT_SYMTAB: return "SYMTAB";
2025 case DT_RELA: return "RELA";
2026 case DT_RELASZ: return "RELASZ";
2027 case DT_RELAENT: return "RELAENT";
2028 case DT_STRSZ: return "STRSZ";
2029 case DT_SYMENT: return "SYMENT";
2030 case DT_INIT: return "INIT";
2031 case DT_FINI: return "FINI";
2032 case DT_SONAME: return "SONAME";
2033 case DT_RPATH: return "RPATH";
2034 case DT_SYMBOLIC: return "SYMBOLIC";
2035 case DT_REL: return "REL";
2036 case DT_RELSZ: return "RELSZ";
2037 case DT_RELENT: return "RELENT";
2038 case DT_PLTREL: return "PLTREL";
2039 case DT_DEBUG: return "DEBUG";
2040 case DT_TEXTREL: return "TEXTREL";
2041 case DT_JMPREL: return "JMPREL";
2042 case DT_BIND_NOW: return "BIND_NOW";
2043 case DT_INIT_ARRAY: return "INIT_ARRAY";
2044 case DT_FINI_ARRAY: return "FINI_ARRAY";
2045 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2046 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 2047 case DT_RUNPATH: return "RUNPATH";
2048 case DT_FLAGS: return "FLAGS";
2d0e6f43 2049
d1133906
NC		 2050 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2051 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
6d913794 2052 case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
103f02d3 2053
05107a46 2054 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 2055 case DT_PLTPADSZ: return "PLTPADSZ";
2056 case DT_MOVEENT: return "MOVEENT";
2057 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 2058 case DT_FEATURE: return "FEATURE";
252b5132
RH		 2059 case DT_POSFLAG_1: return "POSFLAG_1";
2060 case DT_SYMINSZ: return "SYMINSZ";
2061 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 2062
252b5132 2063 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 2064 case DT_CONFIG: return "CONFIG";
2065 case DT_DEPAUDIT: return "DEPAUDIT";
2066 case DT_AUDIT: return "AUDIT";
2067 case DT_PLTPAD: return "PLTPAD";
2068 case DT_MOVETAB: return "MOVETAB";
252b5132 2069 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 2070
252b5132 2071 case DT_VERSYM: return "VERSYM";
103f02d3 2072
67a4f2b7
AO		 2073 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2074 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 2075 case DT_RELACOUNT: return "RELACOUNT";
2076 case DT_RELCOUNT: return "RELCOUNT";
2077 case DT_FLAGS_1: return "FLAGS_1";
2078 case DT_VERDEF: return "VERDEF";
2079 case DT_VERDEFNUM: return "VERDEFNUM";
2080 case DT_VERNEED: return "VERNEED";
2081 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 2082
019148e4 2083 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 2084 case DT_USED: return "USED";
2085 case DT_FILTER: return "FILTER";
103f02d3 2086
047b2264
JJ		 2087 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2088 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2089 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2090 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2091 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 2092 case DT_GNU_HASH: return "GNU_HASH";
047b2264 2093
252b5132
RH		 2094 default:
2095 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2096 {
2cf0635d 2097 const char * result;
103f02d3 2098
252b5132
RH		 2099 switch (elf_header.e_machine)
2100 {
2101 case EM_MIPS:
4fe85591 2102 case EM_MIPS_RS3_LE:
252b5132
RH		 2103 result = get_mips_dynamic_type (type);
2104 break;
9a097730
RH		 2105 case EM_SPARCV9:
2106 result = get_sparc64_dynamic_type (type);
2107 break;
7490d522
AM		 2108 case EM_PPC:
2109 result = get_ppc_dynamic_type (type);
2110 break;
f1cb7e17
AM		 2111 case EM_PPC64:
2112 result = get_ppc64_dynamic_type (type);
2113 break;
ecc51f48
NC		 2114 case EM_IA_64:
2115 result = get_ia64_dynamic_type (type);
2116 break;
fabcb361
RH		 2117 case EM_ALPHA:
2118 result = get_alpha_dynamic_type (type);
2119 break;
1c0d3aa6
NC		 2120 case EM_SCORE:
2121 result = get_score_dynamic_type (type);
2122 break;
40b36596
JM		 2123 case EM_TI_C6000:
2124 result = get_tic6x_dynamic_type (type);
2125 break;
36591ba1
SL		 2126 case EM_ALTERA_NIOS2:
2127 result = get_nios2_dynamic_type (type);
2128 break;
252b5132 2129 default:
fd85a6a1
NC		 2130 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2131 result = get_solaris_dynamic_type (type);
2132 else
2133 result = NULL;
252b5132
RH		 2134 break;
2135 }
2136
2137 if (result != NULL)
2138 return result;
2139
e9e44622 2140 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 2141 }
eec8f817
DA		 2142 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2143 || (elf_header.e_machine == EM_PARISC
2144 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 2145 {
2cf0635d 2146 const char * result;
103f02d3
UD		 2147
2148 switch (elf_header.e_machine)
2149 {
2150 case EM_PARISC:
2151 result = get_parisc_dynamic_type (type);
2152 break;
148b93f2
NC		 2153 case EM_IA_64:
2154 result = get_ia64_dynamic_type (type);
2155 break;
103f02d3 2156 default:
fd85a6a1
NC		 2157 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2158 result = get_solaris_dynamic_type (type);
2159 else
2160 result = NULL;
103f02d3
UD		 2161 break;
2162 }
2163
2164 if (result != NULL)
2165 return result;
2166
e9e44622
JJ		 2167 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2168 type);
103f02d3 2169 }
252b5132 2170 else
e9e44622 2171 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 2172
252b5132
RH		 2173 return buff;
2174 }
2175}
2176
2177static char *
d3ba0551 2178get_file_type (unsigned e_type)
252b5132 2179{
b34976b6 2180 static char buff[32];
252b5132
RH		 2181
2182 switch (e_type)
2183 {
32ec8896
NC		 2184 case ET_NONE: return _("NONE (None)");
2185 case ET_REL: return _("REL (Relocatable file)");
2186 case ET_EXEC: return _("EXEC (Executable file)");
2187 case ET_DYN: return _("DYN (Shared object file)");
2188 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 2189
2190 default:
2191 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 2192 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 2193 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 2194 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 2195 else
e9e44622 2196 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 2197 return buff;
2198 }
2199}
2200
2201static char *
d3ba0551 2202get_machine_name (unsigned e_machine)
252b5132 2203{
b34976b6 2204 static char buff[64]; /* XXX */
252b5132
RH		 2205
2206 switch (e_machine)
2207 {
55e22ca8
NC		 2208 /* Please keep this switch table sorted by increasing EM_ value. */
2209 /* 0 */
c45021f2
NC		 2210 case EM_NONE: return _("None");
2211 case EM_M32: return "WE32100";
2212 case EM_SPARC: return "Sparc";
2213 case EM_386: return "Intel 80386";
2214 case EM_68K: return "MC68000";
2215 case EM_88K: return "MC88000";
22abe556 2216 case EM_IAMCU: return "Intel MCU";
c45021f2
NC		 2217 case EM_860: return "Intel 80860";
2218 case EM_MIPS: return "MIPS R3000";
2219 case EM_S370: return "IBM System/370";
55e22ca8 2220 /* 10 */
7036c0e1 2221 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 2222 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 2223 case EM_PARISC: return "HPPA";
55e22ca8 2224 case EM_VPP550: return "Fujitsu VPP500";
7036c0e1 2225 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 2226 case EM_960: return "Intel 90860";
2227 case EM_PPC: return "PowerPC";
55e22ca8 2228 /* 20 */
285d1771 2229 case EM_PPC64: return "PowerPC64";
55e22ca8
NC		 2230 case EM_S390_OLD:
2231 case EM_S390: return "IBM S/390";
2232 case EM_SPU: return "SPU";
2233 /* 30 */
2234 case EM_V800: return "Renesas V850 (using RH850 ABI)";
c45021f2
NC		 2235 case EM_FR20: return "Fujitsu FR20";
2236 case EM_RH32: return "TRW RH32";
b34976b6 2237 case EM_MCORE: return "MCORE";
55e22ca8 2238 /* 40 */
7036c0e1
AJ		 2239 case EM_ARM: return "ARM";
2240 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 2241 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 2242 case EM_SPARCV9: return "Sparc v9";
2243 case EM_TRICORE: return "Siemens Tricore";
584da044 2244 case EM_ARC: return "ARC";
c2dcd04e
NC		 2245 case EM_H8_300: return "Renesas H8/300";
2246 case EM_H8_300H: return "Renesas H8/300H";
2247 case EM_H8S: return "Renesas H8S";
2248 case EM_H8_500: return "Renesas H8/500";
55e22ca8 2249 /* 50 */
30800947 2250 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 2251 case EM_MIPS_X: return "Stanford MIPS-X";
2252 case EM_COLDFIRE: return "Motorola Coldfire";
55e22ca8 2253 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
7036c0e1
AJ		 2254 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2255 case EM_PCP: return "Siemens PCP";
2256 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2257 case EM_NDR1: return "Denso NDR1 microprocesspr";
2258 case EM_STARCORE: return "Motorola Star*Core processor";
2259 case EM_ME16: return "Toyota ME16 processor";
55e22ca8 2260 /* 60 */
7036c0e1
AJ		 2261 case EM_ST100: return "STMicroelectronics ST100 processor";
2262 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
55e22ca8 2263 case EM_X86_64: return "Advanced Micro Devices X86-64";
11636f9e
JM		 2264 case EM_PDSP: return "Sony DSP processor";
2265 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2266 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 2267 case EM_FX66: return "Siemens FX66 microcontroller";
2268 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2269 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2270 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
55e22ca8 2271 /* 70 */
7036c0e1
AJ		 2272 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2273 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2274 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2275 case EM_SVX: return "Silicon Graphics SVx";
2276 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2277 case EM_VAX: return "Digital VAX";
1b61cf92 2278 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 2279 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2280 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2281 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
55e22ca8 2282 /* 80 */
b34976b6 2283 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 2284 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 2285 case EM_PRISM: return "Vitesse Prism";
55e22ca8
NC		 2286 case EM_AVR_OLD:
2287 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
2288 case EM_CYGNUS_FR30:
2289 case EM_FR30: return "Fujitsu FR30";
2290 case EM_CYGNUS_D10V:
2291 case EM_D10V: return "d10v";
2292 case EM_CYGNUS_D30V:
2293 case EM_D30V: return "d30v";
2294 case EM_CYGNUS_V850:
2295 case EM_V850: return "Renesas V850";
2296 case EM_CYGNUS_M32R:
2297 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2298 case EM_CYGNUS_MN10300:
2299 case EM_MN10300: return "mn10300";
2300 /* 90 */
2301 case EM_CYGNUS_MN10200:
2302 case EM_MN10200: return "mn10200";
2303 case EM_PJ: return "picoJava";
73589c9d 2304 case EM_OR1K: return "OpenRISC 1000";
55e22ca8 2305 case EM_ARC_COMPACT: return "ARCompact";
88da6820
NC		 2306 case EM_XTENSA_OLD:
2307 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 2308 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2309 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2310 case EM_NS32K: return "National Semiconductor 32000 series";
2311 case EM_TPC: return "Tenor Network TPC processor";
55e22ca8
NC		 2312 case EM_SNP1K: return "Trebia SNP 1000 processor";
2313 /* 100 */
2314 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2315 case EM_IP2K_OLD:
2316 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
11636f9e
JM		 2317 case EM_MAX: return "MAX Processor";
2318 case EM_CR: return "National Semiconductor CompactRISC";
2319 case EM_F2MC16: return "Fujitsu F2MC16";
2320 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
7bbe5bc5 2321 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 2322 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2323 case EM_SEP: return "Sharp embedded microprocessor";
2324 case EM_ARCA: return "Arca RISC microprocessor";
55e22ca8 2325 /* 110 */
11636f9e
JM		 2326 case EM_UNICORE: return "Unicore";
2327 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2328 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348 2329 case EM_ALTERA_NIOS2: return "Altera Nios II";
55e22ca8
NC		 2330 case EM_CRX: return "National Semiconductor CRX microprocessor";
2331 case EM_XGATE: return "Motorola XGATE embedded processor";
c29aca4a 2332 case EM_C166:
d70c5fc7 2333 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 2334 case EM_M16C: return "Renesas M16C series microprocessors";
2335 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2336 case EM_CE: return "Freescale Communication Engine RISC core";
55e22ca8
NC		 2337 /* 120 */
2338 case EM_M32C: return "Renesas M32c";
2339 /* 130 */
11636f9e
JM		 2340 case EM_TSK3000: return "Altium TSK3000 core";
2341 case EM_RS08: return "Freescale RS08 embedded processor";
2342 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
55e22ca8 2343 case EM_SCORE: return "SUNPLUS S+Core";
11636f9e
JM		 2344 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2345 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
55e22ca8 2346 case EM_LATTICEMICO32: return "Lattice Mico32";
11636f9e 2347 case EM_SE_C17: return "Seiko Epson C17 family";
55e22ca8 2348 /* 140 */
11636f9e
JM		 2349 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2350 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2351 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
55e22ca8
NC		 2352 case EM_TI_PRU: return "TI PRU I/O processor";
2353 /* 160 */
11636f9e
JM		 2354 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2355 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2356 case EM_R32C: return "Renesas R32C series microprocessors";
2357 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2358 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2359 case EM_8051: return "Intel 8051 and variants";
2360 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2361 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2362 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2363 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
55e22ca8 2364 /* 170 */
11636f9e
JM		 2365 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2366 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2367 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
c7927a3c 2368 case EM_RX: return "Renesas RX";
a3c62988 2369 case EM_METAG: return "Imagination Technologies Meta processor architecture";
11636f9e
JM		 2370 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2371 case EM_ECOG16: return "Cyan Technology eCOG16 family";
55e22ca8
NC		 2372 case EM_CR16:
2373 case EM_MICROBLAZE:
2374 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
11636f9e
JM		 2375 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2376 case EM_SLE9X: return "Infineon Technologies SLE9X core";
55e22ca8
NC		 2377 /* 180 */
2378 case EM_L1OM: return "Intel L1OM";
2379 case EM_K1OM: return "Intel K1OM";
2380 case EM_INTEL182: return "Intel (reserved)";
2381 case EM_AARCH64: return "AArch64";
2382 case EM_ARM184: return "ARM (reserved)";
2383 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor";
11636f9e
JM		 2384 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2385 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2386 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
55e22ca8 2387 /* 190 */
11636f9e 2388 case EM_CUDA: return "NVIDIA CUDA architecture";
55e22ca8 2389 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
6d913794
NC		 2390 case EM_CLOUDSHIELD: return "CloudShield architecture family";
2391 case EM_COREA_1ST: return "KIPO-KAIST Core-A 1st generation processor family";
2392 case EM_COREA_2ND: return "KIPO-KAIST Core-A 2nd generation processor family";
55e22ca8 2393 case EM_ARC_COMPACT2: return "ARCv2";
6d913794 2394 case EM_OPEN8: return "Open8 8-bit RISC soft processor core";
55e22ca8 2395 case EM_RL78: return "Renesas RL78";
6d913794 2396 case EM_VIDEOCORE5: return "Broadcom VideoCore V processor";
55e22ca8
NC		 2397 case EM_78K0R: return "Renesas 78K0R";
2398 /* 200 */
6d913794 2399 case EM_56800EX: return "Freescale 56800EX Digital Signal Controller (DSC)";
15f205b1
NC		 2400 case EM_BA1: return "Beyond BA1 CPU architecture";
2401 case EM_BA2: return "Beyond BA2 CPU architecture";
6d913794
NC		 2402 case EM_XCORE: return "XMOS xCORE processor family";
2403 case EM_MCHP_PIC: return "Microchip 8-bit PIC(r) family";
55e22ca8 2404 /* 210 */
6d913794
NC		 2405 case EM_KM32: return "KM211 KM32 32-bit processor";
2406 case EM_KMX32: return "KM211 KMX32 32-bit processor";
2407 case EM_KMX16: return "KM211 KMX16 16-bit processor";
2408 case EM_KMX8: return "KM211 KMX8 8-bit processor";
2409 case EM_KVARC: return "KM211 KVARC processor";
15f205b1 2410 case EM_CDP: return "Paneve CDP architecture family";
6d913794
NC		 2411 case EM_COGE: return "Cognitive Smart Memory Processor";
2412 case EM_COOL: return "Bluechip Systems CoolEngine";
2413 case EM_NORC: return "Nanoradio Optimized RISC";
2414 case EM_CSR_KALIMBA: return "CSR Kalimba architecture family";
55e22ca8 2415 /* 220 */
15f205b1 2416 case EM_Z80: return "Zilog Z80";
55e22ca8
NC		 2417 case EM_VISIUM: return "CDS VISIUMcore processor";
2418 case EM_FT32: return "FTDI Chip FT32";
2419 case EM_MOXIE: return "Moxie";
2420 case EM_AMDGPU: return "AMD GPU";
2421 case EM_RISCV: return "RISC-V";
2422 case EM_LANAI: return "Lanai 32-bit processor";
2423 case EM_BPF: return "Linux BPF";
2424
2425 /* Large numbers... */
2426 case EM_MT: return "Morpho Techologies MT processor";
2427 case EM_ALPHA: return "Alpha";
2428 case EM_WEBASSEMBLY: return "Web Assembly";
2429 case EM_DLX: return "OpenDLX";
2430 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
2431 case EM_IQ2000: return "Vitesse IQ2000";
2432 case EM_M32C_OLD:
2433 case EM_NIOS32: return "Altera Nios";
2434 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
2435 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
2436 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2437
252b5132 2438 default:
35d9dd2f 2439 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 2440 return buff;
2441 }
2442}
2443
a9522a21
AB		 2444static void
2445decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2446{
2447 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2448 other compilers don't a specific architecture type in the e_flags, and
2449 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2450 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2451 architectures.
2452
2453 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2454 but also sets a specific architecture type in the e_flags field.
2455
2456 However, when decoding the flags we don't worry if we see an
2457 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2458 ARCEM architecture type. */
2459
2460 switch (e_flags & EF_ARC_MACH_MSK)
2461 {
2462 /* We only expect these to occur for EM_ARC_COMPACT2. */
2463 case EF_ARC_CPU_ARCV2EM:
2464 strcat (buf, ", ARC EM");
2465 break;
2466 case EF_ARC_CPU_ARCV2HS:
2467 strcat (buf, ", ARC HS");
2468 break;
2469
2470 /* We only expect these to occur for EM_ARC_COMPACT. */
2471 case E_ARC_MACH_ARC600:
2472 strcat (buf, ", ARC600");
2473 break;
2474 case E_ARC_MACH_ARC601:
2475 strcat (buf, ", ARC601");
2476 break;
2477 case E_ARC_MACH_ARC700:
2478 strcat (buf, ", ARC700");
2479 break;
2480
2481 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2482 new ELF with new architecture being read by an old version of
2483 readelf, or (c) An ELF built with non-GNU compiler that does not
2484 set the architecture in the e_flags. */
2485 default:
2486 if (e_machine == EM_ARC_COMPACT)
2487 strcat (buf, ", Unknown ARCompact");
2488 else
2489 strcat (buf, ", Unknown ARC");
2490 break;
2491 }
2492
2493 switch (e_flags & EF_ARC_OSABI_MSK)
2494 {
2495 case E_ARC_OSABI_ORIG:
2496 strcat (buf, ", (ABI:legacy)");
2497 break;
2498 case E_ARC_OSABI_V2:
2499 strcat (buf, ", (ABI:v2)");
2500 break;
2501 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2502 case E_ARC_OSABI_V3:
2503 strcat (buf, ", v3 no-legacy-syscalls ABI");
2504 break;
2505 default:
2506 strcat (buf, ", unrecognised ARC OSABI flag");
2507 break;
2508 }
2509}
2510
f3485b74 2511static void
d3ba0551 2512decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 2513{
2514 unsigned eabi;
32ec8896 2515 bfd_boolean unknown = FALSE;
f3485b74
NC		 2516
2517 eabi = EF_ARM_EABI_VERSION (e_flags);
2518 e_flags &= ~ EF_ARM_EABIMASK;
2519
2520 /* Handle "generic" ARM flags. */
2521 if (e_flags & EF_ARM_RELEXEC)
2522 {
2523 strcat (buf, ", relocatable executable");
2524 e_flags &= ~ EF_ARM_RELEXEC;
2525 }
76da6bbe 2526
f3485b74
NC		 2527 /* Now handle EABI specific flags. */
2528 switch (eabi)
2529 {
2530 default:
2c71103e 2531 strcat (buf, ", <unrecognized EABI>");
f3485b74 2532 if (e_flags)
32ec8896 2533 unknown = TRUE;
f3485b74
NC		 2534 break;
2535
2536 case EF_ARM_EABI_VER1:
a5bcd848 2537 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2538 while (e_flags)
2539 {
2540 unsigned flag;
76da6bbe 2541
f3485b74
NC		 2542 /* Process flags one bit at a time. */
2543 flag = e_flags & - e_flags;
2544 e_flags &= ~ flag;
76da6bbe 2545
f3485b74
NC		 2546 switch (flag)
2547 {
a5bcd848 2548 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2549 strcat (buf, ", sorted symbol tables");
2550 break;
76da6bbe 2551
f3485b74 2552 default:
32ec8896 2553 unknown = TRUE;
f3485b74
NC		 2554 break;
2555 }
2556 }
2557 break;
76da6bbe 2558
a5bcd848
PB		 2559 case EF_ARM_EABI_VER2:
2560 strcat (buf, ", Version2 EABI");
2561 while (e_flags)
2562 {
2563 unsigned flag;
2564
2565 /* Process flags one bit at a time. */
2566 flag = e_flags & - e_flags;
2567 e_flags &= ~ flag;
2568
2569 switch (flag)
2570 {
2571 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2572 strcat (buf, ", sorted symbol tables");
2573 break;
2574
2575 case EF_ARM_DYNSYMSUSESEGIDX:
2576 strcat (buf, ", dynamic symbols use segment index");
2577 break;
2578
2579 case EF_ARM_MAPSYMSFIRST:
2580 strcat (buf, ", mapping symbols precede others");
2581 break;
2582
2583 default:
32ec8896 2584 unknown = TRUE;
a5bcd848
PB		 2585 break;
2586 }
2587 }
2588 break;
2589
d507cf36
PB		 2590 case EF_ARM_EABI_VER3:
2591 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2592 break;
2593
2594 case EF_ARM_EABI_VER4:
2595 strcat (buf, ", Version4 EABI");
3bfcb652
NC		 2596 while (e_flags)
2597 {
2598 unsigned flag;
2599
2600 /* Process flags one bit at a time. */
2601 flag = e_flags & - e_flags;
2602 e_flags &= ~ flag;
2603
2604 switch (flag)
2605 {
2606 case EF_ARM_BE8:
2607 strcat (buf, ", BE8");
2608 break;
2609
2610 case EF_ARM_LE8:
2611 strcat (buf, ", LE8");
2612 break;
2613
2614 default:
32ec8896 2615 unknown = TRUE;
3bfcb652
NC		 2616 break;
2617 }
3bfcb652
NC		 2618 }
2619 break;
3a4a14e9
PB		 2620
2621 case EF_ARM_EABI_VER5:
2622 strcat (buf, ", Version5 EABI");
d507cf36
PB		 2623 while (e_flags)
2624 {
2625 unsigned flag;
2626
2627 /* Process flags one bit at a time. */
2628 flag = e_flags & - e_flags;
2629 e_flags &= ~ flag;
2630
2631 switch (flag)
2632 {
2633 case EF_ARM_BE8:
2634 strcat (buf, ", BE8");
2635 break;
2636
2637 case EF_ARM_LE8:
2638 strcat (buf, ", LE8");
2639 break;
2640
3bfcb652
NC		 2641 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2642 strcat (buf, ", soft-float ABI");
2643 break;
2644
2645 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2646 strcat (buf, ", hard-float ABI");
2647 break;
2648
d507cf36 2649 default:
32ec8896 2650 unknown = TRUE;
d507cf36
PB		 2651 break;
2652 }
2653 }
2654 break;
2655
f3485b74 2656 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2657 strcat (buf, ", GNU EABI");
f3485b74
NC		 2658 while (e_flags)
2659 {
2660 unsigned flag;
76da6bbe 2661
f3485b74
NC		 2662 /* Process flags one bit at a time. */
2663 flag = e_flags & - e_flags;
2664 e_flags &= ~ flag;
76da6bbe 2665
f3485b74
NC		 2666 switch (flag)
2667 {
a5bcd848 2668 case EF_ARM_INTERWORK:
f3485b74
NC		 2669 strcat (buf, ", interworking enabled");
2670 break;
76da6bbe 2671
a5bcd848 2672 case EF_ARM_APCS_26:
f3485b74
NC		 2673 strcat (buf, ", uses APCS/26");
2674 break;
76da6bbe 2675
a5bcd848 2676 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2677 strcat (buf, ", uses APCS/float");
2678 break;
76da6bbe 2679
a5bcd848 2680 case EF_ARM_PIC:
f3485b74
NC		 2681 strcat (buf, ", position independent");
2682 break;
76da6bbe 2683
a5bcd848 2684 case EF_ARM_ALIGN8:
f3485b74
NC		 2685 strcat (buf, ", 8 bit structure alignment");
2686 break;
76da6bbe 2687
a5bcd848 2688 case EF_ARM_NEW_ABI:
f3485b74
NC		 2689 strcat (buf, ", uses new ABI");
2690 break;
76da6bbe 2691
a5bcd848 2692 case EF_ARM_OLD_ABI:
f3485b74
NC		 2693 strcat (buf, ", uses old ABI");
2694 break;
76da6bbe 2695
a5bcd848 2696 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2697 strcat (buf, ", software FP");
2698 break;
76da6bbe 2699
90e01f86
ILT		 2700 case EF_ARM_VFP_FLOAT:
2701 strcat (buf, ", VFP");
2702 break;
2703
fde78edd
NC		 2704 case EF_ARM_MAVERICK_FLOAT:
2705 strcat (buf, ", Maverick FP");
2706 break;
2707
f3485b74 2708 default:
32ec8896 2709 unknown = TRUE;
f3485b74
NC		 2710 break;
2711 }
2712 }
2713 }
f3485b74
NC		 2714
2715 if (unknown)
2b692964 2716 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2717}
2718
343433df
AB		 2719static void
2720decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2721{
2722 --size; /* Leave space for null terminator. */
2723
2724 switch (e_flags & EF_AVR_MACH)
2725 {
2726 case E_AVR_MACH_AVR1:
2727 strncat (buf, ", avr:1", size);
2728 break;
2729 case E_AVR_MACH_AVR2:
2730 strncat (buf, ", avr:2", size);
2731 break;
2732 case E_AVR_MACH_AVR25:
2733 strncat (buf, ", avr:25", size);
2734 break;
2735 case E_AVR_MACH_AVR3:
2736 strncat (buf, ", avr:3", size);
2737 break;
2738 case E_AVR_MACH_AVR31:
2739 strncat (buf, ", avr:31", size);
2740 break;
2741 case E_AVR_MACH_AVR35:
2742 strncat (buf, ", avr:35", size);
2743 break;
2744 case E_AVR_MACH_AVR4:
2745 strncat (buf, ", avr:4", size);
2746 break;
2747 case E_AVR_MACH_AVR5:
2748 strncat (buf, ", avr:5", size);
2749 break;
2750 case E_AVR_MACH_AVR51:
2751 strncat (buf, ", avr:51", size);
2752 break;
2753 case E_AVR_MACH_AVR6:
2754 strncat (buf, ", avr:6", size);
2755 break;
2756 case E_AVR_MACH_AVRTINY:
2757 strncat (buf, ", avr:100", size);
2758 break;
2759 case E_AVR_MACH_XMEGA1:
2760 strncat (buf, ", avr:101", size);
2761 break;
2762 case E_AVR_MACH_XMEGA2:
2763 strncat (buf, ", avr:102", size);
2764 break;
2765 case E_AVR_MACH_XMEGA3:
2766 strncat (buf, ", avr:103", size);
2767 break;
2768 case E_AVR_MACH_XMEGA4:
2769 strncat (buf, ", avr:104", size);
2770 break;
2771 case E_AVR_MACH_XMEGA5:
2772 strncat (buf, ", avr:105", size);
2773 break;
2774 case E_AVR_MACH_XMEGA6:
2775 strncat (buf, ", avr:106", size);
2776 break;
2777 case E_AVR_MACH_XMEGA7:
2778 strncat (buf, ", avr:107", size);
2779 break;
2780 default:
2781 strncat (buf, ", avr:<unknown>", size);
2782 break;
2783 }
2784
2785 size -= strlen (buf);
2786 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2787 strncat (buf, ", link-relax", size);
2788}
2789
35c08157
KLC		 2790static void
2791decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2792{
2793 unsigned abi;
2794 unsigned arch;
2795 unsigned config;
2796 unsigned version;
32ec8896
NC		 2797 bfd_boolean has_fpu = FALSE;
2798 unsigned int r = 0;
35c08157
KLC		 2799
2800 static const char *ABI_STRINGS[] =
2801 {
2802 "ABI v0", /* use r5 as return register; only used in N1213HC */
2803 "ABI v1", /* use r0 as return register */
2804 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2805 "ABI v2fp", /* for FPU */
40c7a7cb
KLC		 2806 "AABI",
2807 "ABI2 FP+"
35c08157
KLC		 2808 };
2809 static const char *VER_STRINGS[] =
2810 {
2811 "Andes ELF V1.3 or older",
2812 "Andes ELF V1.3.1",
2813 "Andes ELF V1.4"
2814 };
2815 static const char *ARCH_STRINGS[] =
2816 {
2817 "",
2818 "Andes Star v1.0",
2819 "Andes Star v2.0",
2820 "Andes Star v3.0",
2821 "Andes Star v3.0m"
2822 };
2823
2824 abi = EF_NDS_ABI & e_flags;
2825 arch = EF_NDS_ARCH & e_flags;
2826 config = EF_NDS_INST & e_flags;
2827 version = EF_NDS32_ELF_VERSION & e_flags;
2828
2829 memset (buf, 0, size);
2830
2831 switch (abi)
2832 {
2833 case E_NDS_ABI_V0:
2834 case E_NDS_ABI_V1:
2835 case E_NDS_ABI_V2:
2836 case E_NDS_ABI_V2FP:
2837 case E_NDS_ABI_AABI:
40c7a7cb 2838 case E_NDS_ABI_V2FP_PLUS:
35c08157
KLC		 2839 /* In case there are holes in the array. */
2840 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2841 break;
2842
2843 default:
2844 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2845 break;
2846 }
2847
2848 switch (version)
2849 {
2850 case E_NDS32_ELF_VER_1_2:
2851 case E_NDS32_ELF_VER_1_3:
2852 case E_NDS32_ELF_VER_1_4:
2853 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2854 break;
2855
2856 default:
2857 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2858 break;
2859 }
2860
2861 if (E_NDS_ABI_V0 == abi)
2862 {
2863 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2864 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2865 if (arch == E_NDS_ARCH_STAR_V1_0)
2866 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2867 return;
2868 }
2869
2870 switch (arch)
2871 {
2872 case E_NDS_ARCH_STAR_V1_0:
2873 case E_NDS_ARCH_STAR_V2_0:
2874 case E_NDS_ARCH_STAR_V3_0:
2875 case E_NDS_ARCH_STAR_V3_M:
2876 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2877 break;
2878
2879 default:
2880 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2881 /* ARCH version determines how the e_flags are interpreted.
2882 If it is unknown, we cannot proceed. */
2883 return;
2884 }
2885
2886 /* Newer ABI; Now handle architecture specific flags. */
2887 if (arch == E_NDS_ARCH_STAR_V1_0)
2888 {
2889 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2890 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2891
2892 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2893 r += snprintf (buf + r, size -r, ", MAC");
2894
2895 if (config & E_NDS32_HAS_DIV_INST)
2896 r += snprintf (buf + r, size -r, ", DIV");
2897
2898 if (config & E_NDS32_HAS_16BIT_INST)
2899 r += snprintf (buf + r, size -r, ", 16b");
2900 }
2901 else
2902 {
2903 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2904 {
2905 if (version <= E_NDS32_ELF_VER_1_3)
2906 r += snprintf (buf + r, size -r, ", [B8]");
2907 else
2908 r += snprintf (buf + r, size -r, ", EX9");
2909 }
2910
2911 if (config & E_NDS32_HAS_MAC_DX_INST)
2912 r += snprintf (buf + r, size -r, ", MAC_DX");
2913
2914 if (config & E_NDS32_HAS_DIV_DX_INST)
2915 r += snprintf (buf + r, size -r, ", DIV_DX");
2916
2917 if (config & E_NDS32_HAS_16BIT_INST)
2918 {
2919 if (version <= E_NDS32_ELF_VER_1_3)
2920 r += snprintf (buf + r, size -r, ", 16b");
2921 else
2922 r += snprintf (buf + r, size -r, ", IFC");
2923 }
2924 }
2925
2926 if (config & E_NDS32_HAS_EXT_INST)
2927 r += snprintf (buf + r, size -r, ", PERF1");
2928
2929 if (config & E_NDS32_HAS_EXT2_INST)
2930 r += snprintf (buf + r, size -r, ", PERF2");
2931
2932 if (config & E_NDS32_HAS_FPU_INST)
2933 {
32ec8896 2934 has_fpu = TRUE;
35c08157
KLC		 2935 r += snprintf (buf + r, size -r, ", FPU_SP");
2936 }
2937
2938 if (config & E_NDS32_HAS_FPU_DP_INST)
2939 {
32ec8896 2940 has_fpu = TRUE;
35c08157
KLC		 2941 r += snprintf (buf + r, size -r, ", FPU_DP");
2942 }
2943
2944 if (config & E_NDS32_HAS_FPU_MAC_INST)
2945 {
32ec8896 2946 has_fpu = TRUE;
35c08157
KLC		 2947 r += snprintf (buf + r, size -r, ", FPU_MAC");
2948 }
2949
2950 if (has_fpu)
2951 {
2952 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2953 {
2954 case E_NDS32_FPU_REG_8SP_4DP:
2955 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2956 break;
2957 case E_NDS32_FPU_REG_16SP_8DP:
2958 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2959 break;
2960 case E_NDS32_FPU_REG_32SP_16DP:
2961 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2962 break;
2963 case E_NDS32_FPU_REG_32SP_32DP:
2964 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2965 break;
2966 }
2967 }
2968
2969 if (config & E_NDS32_HAS_AUDIO_INST)
2970 r += snprintf (buf + r, size -r, ", AUDIO");
2971
2972 if (config & E_NDS32_HAS_STRING_INST)
2973 r += snprintf (buf + r, size -r, ", STR");
2974
2975 if (config & E_NDS32_HAS_REDUCED_REGS)
2976 r += snprintf (buf + r, size -r, ", 16REG");
2977
2978 if (config & E_NDS32_HAS_VIDEO_INST)
2979 {
2980 if (version <= E_NDS32_ELF_VER_1_3)
2981 r += snprintf (buf + r, size -r, ", VIDEO");
2982 else
2983 r += snprintf (buf + r, size -r, ", SATURATION");
2984 }
2985
2986 if (config & E_NDS32_HAS_ENCRIPT_INST)
2987 r += snprintf (buf + r, size -r, ", ENCRP");
2988
2989 if (config & E_NDS32_HAS_L2C_INST)
2990 r += snprintf (buf + r, size -r, ", L2C");
2991}
2992
252b5132 2993static char *
d3ba0551 2994get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2995{
b34976b6 2996 static char buf[1024];
252b5132
RH		 2997
2998 buf[0] = '\0';
76da6bbe 2999
252b5132
RH		 3000 if (e_flags)
3001 {
3002 switch (e_machine)
3003 {
3004 default:
3005 break;
3006
886a2506 3007 case EM_ARC_COMPACT2:
886a2506 3008 case EM_ARC_COMPACT:
a9522a21
AB		 3009 decode_ARC_machine_flags (e_flags, e_machine, buf);
3010 break;
886a2506 3011
f3485b74
NC		 3012 case EM_ARM:
3013 decode_ARM_machine_flags (e_flags, buf);
3014 break;
76da6bbe 3015
343433df
AB		 3016 case EM_AVR:
3017 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
3018 break;
3019
781303ce
MF		 3020 case EM_BLACKFIN:
3021 if (e_flags & EF_BFIN_PIC)
3022 strcat (buf, ", PIC");
3023
3024 if (e_flags & EF_BFIN_FDPIC)
3025 strcat (buf, ", FDPIC");
3026
3027 if (e_flags & EF_BFIN_CODE_IN_L1)
3028 strcat (buf, ", code in L1");
3029
3030 if (e_flags & EF_BFIN_DATA_IN_L1)
3031 strcat (buf, ", data in L1");
3032
3033 break;
3034
ec2dfb42
AO		 3035 case EM_CYGNUS_FRV:
3036 switch (e_flags & EF_FRV_CPU_MASK)
3037 {
3038 case EF_FRV_CPU_GENERIC:
3039 break;
3040
3041 default:
3042 strcat (buf, ", fr???");
3043 break;
57346661 3044
ec2dfb42
AO		 3045 case EF_FRV_CPU_FR300:
3046 strcat (buf, ", fr300");
3047 break;
3048
3049 case EF_FRV_CPU_FR400:
3050 strcat (buf, ", fr400");
3051 break;
3052 case EF_FRV_CPU_FR405:
3053 strcat (buf, ", fr405");
3054 break;
3055
3056 case EF_FRV_CPU_FR450:
3057 strcat (buf, ", fr450");
3058 break;
3059
3060 case EF_FRV_CPU_FR500:
3061 strcat (buf, ", fr500");
3062 break;
3063 case EF_FRV_CPU_FR550:
3064 strcat (buf, ", fr550");
3065 break;
3066
3067 case EF_FRV_CPU_SIMPLE:
3068 strcat (buf, ", simple");
3069 break;
3070 case EF_FRV_CPU_TOMCAT:
3071 strcat (buf, ", tomcat");
3072 break;
3073 }
1c877e87 3074 break;
ec2dfb42 3075
53c7db4b 3076 case EM_68K:
425c6cb0 3077 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 3078 strcat (buf, ", m68000");
425c6cb0 3079 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 3080 strcat (buf, ", cpu32");
3081 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3082 strcat (buf, ", fido_a");
425c6cb0 3083 else
266abb8f 3084 {
2cf0635d
NC		 3085 char const * isa = _("unknown");
3086 char const * mac = _("unknown mac");
3087 char const * additional = NULL;
0112cd26 3088
c694fd50 3089 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 3090 {
c694fd50 3091 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 3092 isa = "A";
3093 additional = ", nodiv";
3094 break;
c694fd50 3095 case EF_M68K_CF_ISA_A:
266abb8f
NS		 3096 isa = "A";
3097 break;
c694fd50 3098 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 3099 isa = "A+";
3100 break;
c694fd50 3101 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 3102 isa = "B";
3103 additional = ", nousp";
3104 break;
c694fd50 3105 case EF_M68K_CF_ISA_B:
266abb8f
NS		 3106 isa = "B";
3107 break;
f608cd77
NS		 3108 case EF_M68K_CF_ISA_C:
3109 isa = "C";
3110 break;
3111 case EF_M68K_CF_ISA_C_NODIV:
3112 isa = "C";
3113 additional = ", nodiv";
3114 break;
266abb8f
NS		 3115 }
3116 strcat (buf, ", cf, isa ");
3117 strcat (buf, isa);
0b2e31dc
NS		 3118 if (additional)
3119 strcat (buf, additional);
c694fd50 3120 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 3121 strcat (buf, ", float");
c694fd50 3122 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 3123 {
3124 case 0:
3125 mac = NULL;
3126 break;
c694fd50 3127 case EF_M68K_CF_MAC:
266abb8f
NS		 3128 mac = "mac";
3129 break;
c694fd50 3130 case EF_M68K_CF_EMAC:
266abb8f
NS		 3131 mac = "emac";
3132 break;
f608cd77
NS		 3133 case EF_M68K_CF_EMAC_B:
3134 mac = "emac_b";
3135 break;
266abb8f
NS		 3136 }
3137 if (mac)
3138 {
3139 strcat (buf, ", ");
3140 strcat (buf, mac);
3141 }
266abb8f 3142 }
53c7db4b 3143 break;
33c63f9d 3144
153a2776
NC		 3145 case EM_CYGNUS_MEP:
3146 switch (e_flags & EF_MEP_CPU_MASK)
3147 {
3148 case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3149 case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3150 case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3151 case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3152 case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3153 case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3154 default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3155 }
3156
3157 switch (e_flags & EF_MEP_COP_MASK)
3158 {
3159 case EF_MEP_COP_NONE: break;
3160 case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3161 case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3162 case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3163 case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3164 default: strcat (buf, _("<unknown MeP copro type>")); break;
3165 }
3166
3167 if (e_flags & EF_MEP_LIBRARY)
3168 strcat (buf, ", Built for Library");
3169
3170 if (e_flags & EF_MEP_INDEX_MASK)
3171 sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3172 e_flags & EF_MEP_INDEX_MASK);
3173
3174 if (e_flags & ~ EF_MEP_ALL_FLAGS)
3175 sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3176 e_flags & ~ EF_MEP_ALL_FLAGS);
3177 break;
3178
252b5132
RH		 3179 case EM_PPC:
3180 if (e_flags & EF_PPC_EMB)
3181 strcat (buf, ", emb");
3182
3183 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 3184 strcat (buf, _(", relocatable"));
252b5132
RH		 3185
3186 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 3187 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 3188 break;
3189
ee67d69a
AM		 3190 case EM_PPC64:
3191 if (e_flags & EF_PPC64_ABI)
3192 {
3193 char abi[] = ", abiv0";
3194
3195 abi[6] += e_flags & EF_PPC64_ABI;
3196 strcat (buf, abi);
3197 }
3198 break;
3199
708e2187
NC		 3200 case EM_V800:
3201 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3202 strcat (buf, ", RH850 ABI");
0b4362b0 3203
708e2187
NC		 3204 if (e_flags & EF_V800_850E3)
3205 strcat (buf, ", V3 architecture");
3206
3207 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3208 strcat (buf, ", FPU not used");
3209
3210 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3211 strcat (buf, ", regmode: COMMON");
3212
3213 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3214 strcat (buf, ", r4 not used");
3215
3216 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3217 strcat (buf, ", r30 not used");
3218
3219 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3220 strcat (buf, ", r5 not used");
3221
3222 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3223 strcat (buf, ", r2 not used");
3224
3225 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3226 {
3227 switch (e_flags & - e_flags)
3228 {
3229 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3230 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
708e2187
NC		 3231 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3232 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
708e2187
NC		 3233 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3234 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3235 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3236 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3237 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3238 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3239 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3240 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3241 default: break;
3242 }
3243 }
3244 break;
3245
2b0337b0 3246 case EM_V850:
252b5132
RH		 3247 case EM_CYGNUS_V850:
3248 switch (e_flags & EF_V850_ARCH)
3249 {
78c8d46c
NC		 3250 case E_V850E3V5_ARCH:
3251 strcat (buf, ", v850e3v5");
3252 break;
1cd986c5
NC		 3253 case E_V850E2V3_ARCH:
3254 strcat (buf, ", v850e2v3");
3255 break;
3256 case E_V850E2_ARCH:
3257 strcat (buf, ", v850e2");
3258 break;
3259 case E_V850E1_ARCH:
3260 strcat (buf, ", v850e1");
8ad30312 3261 break;
252b5132
RH		 3262 case E_V850E_ARCH:
3263 strcat (buf, ", v850e");
3264 break;
252b5132
RH		 3265 case E_V850_ARCH:
3266 strcat (buf, ", v850");
3267 break;
3268 default:
2b692964 3269 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 3270 break;
3271 }
3272 break;
3273
2b0337b0 3274 case EM_M32R:
252b5132
RH		 3275 case EM_CYGNUS_M32R:
3276 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3277 strcat (buf, ", m32r");
252b5132
RH		 3278 break;
3279
3280 case EM_MIPS:
4fe85591 3281 case EM_MIPS_RS3_LE:
252b5132
RH		 3282 if (e_flags & EF_MIPS_NOREORDER)
3283 strcat (buf, ", noreorder");
3284
3285 if (e_flags & EF_MIPS_PIC)
3286 strcat (buf, ", pic");
3287
3288 if (e_flags & EF_MIPS_CPIC)
3289 strcat (buf, ", cpic");
3290
d1bdd336
TS		 3291 if (e_flags & EF_MIPS_UCODE)
3292 strcat (buf, ", ugen_reserved");
3293
252b5132
RH		 3294 if (e_flags & EF_MIPS_ABI2)
3295 strcat (buf, ", abi2");
3296
43521d43
TS		 3297 if (e_flags & EF_MIPS_OPTIONS_FIRST)
3298 strcat (buf, ", odk first");
3299
a5d22d2a
TS		 3300 if (e_flags & EF_MIPS_32BITMODE)
3301 strcat (buf, ", 32bitmode");
3302
ba92f887
MR		 3303 if (e_flags & EF_MIPS_NAN2008)
3304 strcat (buf, ", nan2008");
3305
fef1b0b3
SE		 3306 if (e_flags & EF_MIPS_FP64)
3307 strcat (buf, ", fp64");
3308
156c2f8b
NC		 3309 switch ((e_flags & EF_MIPS_MACH))
3310 {
3311 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3312 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3313 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 3314 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 3315 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3316 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3317 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3318 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 3319 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 3320 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 3321 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3322 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 3323 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 3324 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 3325 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
d32e5c54 3326 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
52b6b6b9 3327 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 3328 case 0:
3329 /* We simply ignore the field in this case to avoid confusion:
3330 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3331 extension. */
3332 break;
2b692964 3333 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 3334 }
43521d43
TS		 3335
3336 switch ((e_flags & EF_MIPS_ABI))
3337 {
3338 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3339 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3340 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3341 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3342 case 0:
3343 /* We simply ignore the field in this case to avoid confusion:
3344 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3345 This means it is likely to be an o32 file, but not for
3346 sure. */
3347 break;
2b692964 3348 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 3349 }
3350
3351 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3352 strcat (buf, ", mdmx");
3353
3354 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3355 strcat (buf, ", mips16");
3356
df58fc94
RS		 3357 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3358 strcat (buf, ", micromips");
3359
43521d43
TS		 3360 switch ((e_flags & EF_MIPS_ARCH))
3361 {
3362 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3363 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3364 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3365 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3366 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3367 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 3368 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
7361da2c 3369 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
43521d43 3370 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 3371 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
7361da2c 3372 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
2b692964 3373 default: strcat (buf, _(", unknown ISA")); break;
43521d43 3374 }
252b5132 3375 break;
351b4b40 3376
35c08157
KLC		 3377 case EM_NDS32:
3378 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3379 break;
3380
e23eba97
NC		 3381 case EM_RISCV:
3382 if (e_flags & EF_RISCV_RVC)
3383 strcat (buf, ", RVC");
2922d21d
AW		 3384
3385 switch (e_flags & EF_RISCV_FLOAT_ABI)
3386 {
3387 case EF_RISCV_FLOAT_ABI_SOFT:
3388 strcat (buf, ", soft-float ABI");
3389 break;
3390
3391 case EF_RISCV_FLOAT_ABI_SINGLE:
3392 strcat (buf, ", single-float ABI");
3393 break;
3394
3395 case EF_RISCV_FLOAT_ABI_DOUBLE:
3396 strcat (buf, ", double-float ABI");
3397 break;
3398
3399 case EF_RISCV_FLOAT_ABI_QUAD:
3400 strcat (buf, ", quad-float ABI");
3401 break;
3402 }
e23eba97
NC		 3403 break;
3404
ccde1100
AO		 3405 case EM_SH:
3406 switch ((e_flags & EF_SH_MACH_MASK))
3407 {
3408 case EF_SH1: strcat (buf, ", sh1"); break;
3409 case EF_SH2: strcat (buf, ", sh2"); break;
3410 case EF_SH3: strcat (buf, ", sh3"); break;
3411 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3412 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3413 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3414 case EF_SH3E: strcat (buf, ", sh3e"); break;
3415 case EF_SH4: strcat (buf, ", sh4"); break;
3416 case EF_SH5: strcat (buf, ", sh5"); break;
3417 case EF_SH2E: strcat (buf, ", sh2e"); break;
3418 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 3419 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 3420 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3421 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 3422 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 3423 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3424 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3425 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3426 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3427 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3428 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 3429 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 3430 }
3431
cec6a5b8
MR		 3432 if (e_flags & EF_SH_PIC)
3433 strcat (buf, ", pic");
3434
3435 if (e_flags & EF_SH_FDPIC)
3436 strcat (buf, ", fdpic");
ccde1100 3437 break;
948f632f 3438
73589c9d
CS		 3439 case EM_OR1K:
3440 if (e_flags & EF_OR1K_NODELAY)
3441 strcat (buf, ", no delay");
3442 break;
57346661 3443
351b4b40
RH		 3444 case EM_SPARCV9:
3445 if (e_flags & EF_SPARC_32PLUS)
3446 strcat (buf, ", v8+");
3447
3448 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 3449 strcat (buf, ", ultrasparcI");
3450
3451 if (e_flags & EF_SPARC_SUN_US3)
3452 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 3453
3454 if (e_flags & EF_SPARC_HAL_R1)
3455 strcat (buf, ", halr1");
3456
3457 if (e_flags & EF_SPARC_LEDATA)
3458 strcat (buf, ", ledata");
3459
3460 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3461 strcat (buf, ", tso");
3462
3463 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3464 strcat (buf, ", pso");
3465
3466 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3467 strcat (buf, ", rmo");
3468 break;
7d466069 3469
103f02d3
UD		 3470 case EM_PARISC:
3471 switch (e_flags & EF_PARISC_ARCH)
3472 {
3473 case EFA_PARISC_1_0:
3474 strcpy (buf, ", PA-RISC 1.0");
3475 break;
3476 case EFA_PARISC_1_1:
3477 strcpy (buf, ", PA-RISC 1.1");
3478 break;
3479 case EFA_PARISC_2_0:
3480 strcpy (buf, ", PA-RISC 2.0");
3481 break;
3482 default:
3483 break;
3484 }
3485 if (e_flags & EF_PARISC_TRAPNIL)
3486 strcat (buf, ", trapnil");
3487 if (e_flags & EF_PARISC_EXT)
3488 strcat (buf, ", ext");
3489 if (e_flags & EF_PARISC_LSB)
3490 strcat (buf, ", lsb");
3491 if (e_flags & EF_PARISC_WIDE)
3492 strcat (buf, ", wide");
3493 if (e_flags & EF_PARISC_NO_KABP)
3494 strcat (buf, ", no kabp");
3495 if (e_flags & EF_PARISC_LAZYSWAP)
3496 strcat (buf, ", lazyswap");
30800947 3497 break;
76da6bbe 3498
7d466069 3499 case EM_PJ:
2b0337b0 3500 case EM_PJ_OLD:
7d466069
ILT		 3501 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3502 strcat (buf, ", new calling convention");
3503
3504 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3505 strcat (buf, ", gnu calling convention");
3506 break;
4d6ed7c8
NC		 3507
3508 case EM_IA_64:
3509 if ((e_flags & EF_IA_64_ABI64))
3510 strcat (buf, ", 64-bit");
3511 else
3512 strcat (buf, ", 32-bit");
3513 if ((e_flags & EF_IA_64_REDUCEDFP))
3514 strcat (buf, ", reduced fp model");
3515 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3516 strcat (buf, ", no function descriptors, constant gp");
3517 else if ((e_flags & EF_IA_64_CONS_GP))
3518 strcat (buf, ", constant gp");
3519 if ((e_flags & EF_IA_64_ABSOLUTE))
3520 strcat (buf, ", absolute");
28f997cf
TG		 3521 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3522 {
3523 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3524 strcat (buf, ", vms_linkages");
3525 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3526 {
3527 case EF_IA_64_VMS_COMCOD_SUCCESS:
3528 break;
3529 case EF_IA_64_VMS_COMCOD_WARNING:
3530 strcat (buf, ", warning");
3531 break;
3532 case EF_IA_64_VMS_COMCOD_ERROR:
3533 strcat (buf, ", error");
3534 break;
3535 case EF_IA_64_VMS_COMCOD_ABORT:
3536 strcat (buf, ", abort");
3537 break;
3538 default:
bee0ee85
NC		 3539 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3540 e_flags & EF_IA_64_VMS_COMCOD);
3541 strcat (buf, ", <unknown>");
28f997cf
TG		 3542 }
3543 }
4d6ed7c8 3544 break;
179d3252
JT		 3545
3546 case EM_VAX:
3547 if ((e_flags & EF_VAX_NONPIC))
3548 strcat (buf, ", non-PIC");
3549 if ((e_flags & EF_VAX_DFLOAT))
3550 strcat (buf, ", D-Float");
3551 if ((e_flags & EF_VAX_GFLOAT))
3552 strcat (buf, ", G-Float");
3553 break;
c7927a3c 3554
619ed720
EB		 3555 case EM_VISIUM:
3556 if (e_flags & EF_VISIUM_ARCH_MCM)
3557 strcat (buf, ", mcm");
3558 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3559 strcat (buf, ", mcm24");
3560 if (e_flags & EF_VISIUM_ARCH_GR6)
3561 strcat (buf, ", gr6");
3562 break;
3563
4046d87a 3564 case EM_RL78:
1740ba0c
NC		 3565 switch (e_flags & E_FLAG_RL78_CPU_MASK)
3566 {
3567 case E_FLAG_RL78_ANY_CPU: break;
3568 case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3569 case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3570 case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3571 }
856ea05c
KP		 3572 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3573 strcat (buf, ", 64-bit doubles");
4046d87a 3574 break;
0b4362b0 3575
c7927a3c
NC		 3576 case EM_RX:
3577 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3578 strcat (buf, ", 64-bit doubles");
3579 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 3580 strcat (buf, ", dsp");
d4cb0ea0 3581 if (e_flags & E_FLAG_RX_PID)
0b4362b0 3582 strcat (buf, ", pid");
708e2187
NC		 3583 if (e_flags & E_FLAG_RX_ABI)
3584 strcat (buf, ", RX ABI");
3525236c
NC		 3585 if (e_flags & E_FLAG_RX_SINSNS_SET)
3586 strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3587 ? ", uses String instructions" : ", bans String instructions");
a117b0a5
YS		 3588 if (e_flags & E_FLAG_RX_V2)
3589 strcat (buf, ", V2");
d4cb0ea0 3590 break;
55786da2
AK		 3591
3592 case EM_S390:
3593 if (e_flags & EF_S390_HIGH_GPRS)
3594 strcat (buf, ", highgprs");
d4cb0ea0 3595 break;
40b36596
JM		 3596
3597 case EM_TI_C6000:
3598 if ((e_flags & EF_C6000_REL))
3599 strcat (buf, ", relocatable module");
d4cb0ea0 3600 break;
13761a11
NC		 3601
3602 case EM_MSP430:
3603 strcat (buf, _(": architecture variant: "));
3604 switch (e_flags & EF_MSP430_MACH)
3605 {
3606 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3607 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3608 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3609 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3610 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3611 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3612 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3613 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3614 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3615 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3616 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3617 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3618 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3619 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3620 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3621 default:
3622 strcat (buf, _(": unknown")); break;
3623 }
3624
3625 if (e_flags & ~ EF_MSP430_MACH)
3626 strcat (buf, _(": unknown extra flag bits also present"));
252b5132
RH		 3627 }
3628 }
3629
3630 return buf;
3631}
3632
252b5132 3633static const char *
d3ba0551
AM		 3634get_osabi_name (unsigned int osabi)
3635{
3636 static char buff[32];
3637
3638 switch (osabi)
3639 {
3640 case ELFOSABI_NONE: return "UNIX - System V";
3641 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3642 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 3643 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 3644 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3645 case ELFOSABI_AIX: return "UNIX - AIX";
3646 case ELFOSABI_IRIX: return "UNIX - IRIX";
3647 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3648 case ELFOSABI_TRU64: return "UNIX - TRU64";
3649 case ELFOSABI_MODESTO: return "Novell - Modesto";
3650 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3651 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3652 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 3653 case ELFOSABI_AROS: return "AROS";
11636f9e 3654 case ELFOSABI_FENIXOS: return "FenixOS";
6d913794
NC		 3655 case ELFOSABI_CLOUDABI: return "Nuxi CloudABI";
3656 case ELFOSABI_OPENVOS: return "Stratus Technologies OpenVOS";
d3ba0551 3657 default:
40b36596
JM		 3658 if (osabi >= 64)
3659 switch (elf_header.e_machine)
3660 {
3661 case EM_ARM:
3662 switch (osabi)
3663 {
3664 case ELFOSABI_ARM: return "ARM";
3665 default:
3666 break;
3667 }
3668 break;
3669
3670 case EM_MSP430:
3671 case EM_MSP430_OLD:
619ed720 3672 case EM_VISIUM:
40b36596
JM		 3673 switch (osabi)
3674 {
3675 case ELFOSABI_STANDALONE: return _("Standalone App");
3676 default:
3677 break;
3678 }
3679 break;
3680
3681 case EM_TI_C6000:
3682 switch (osabi)
3683 {
3684 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3685 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3686 default:
3687 break;
3688 }
3689 break;
3690
3691 default:
3692 break;
3693 }
e9e44622 3694 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 3695 return buff;
3696 }
3697}
3698
a06ea964
NC		 3699static const char *
3700get_aarch64_segment_type (unsigned long type)
3701{
3702 switch (type)
3703 {
32ec8896
NC		 3704 case PT_AARCH64_ARCHEXT: return "AARCH64_ARCHEXT";
3705 default: return NULL;
a06ea964 3706 }
a06ea964
NC		 3707}
3708
b294bdf8
MM		 3709static const char *
3710get_arm_segment_type (unsigned long type)
3711{
3712 switch (type)
3713 {
32ec8896
NC		 3714 case PT_ARM_EXIDX: return "EXIDX";
3715 default: return NULL;
b294bdf8 3716 }
b294bdf8
MM		 3717}
3718
d3ba0551
AM		 3719static const char *
3720get_mips_segment_type (unsigned long type)
252b5132
RH		 3721{
3722 switch (type)
3723 {
32ec8896
NC		 3724 case PT_MIPS_REGINFO: return "REGINFO";
3725 case PT_MIPS_RTPROC: return "RTPROC";
3726 case PT_MIPS_OPTIONS: return "OPTIONS";
3727 case PT_MIPS_ABIFLAGS: return "ABIFLAGS";
3728 default: return NULL;
252b5132 3729 }
252b5132
RH		 3730}
3731
103f02d3 3732static const char *
d3ba0551 3733get_parisc_segment_type (unsigned long type)
103f02d3
UD		 3734{
3735 switch (type)
3736 {
3737 case PT_HP_TLS: return "HP_TLS";
3738 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3739 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3740 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3741 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3742 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3743 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3744 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3745 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3746 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3747 case PT_HP_PARALLEL: return "HP_PARALLEL";
3748 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 3749 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3750 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3751 case PT_HP_STACK: return "HP_STACK";
3752 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 3753 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3754 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 3755 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
32ec8896 3756 default: return NULL;
103f02d3 3757 }
103f02d3
UD		 3758}
3759
4d6ed7c8 3760static const char *
d3ba0551 3761get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 3762{
3763 switch (type)
3764 {
3765 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3766 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 3767 case PT_HP_TLS: return "HP_TLS";
3768 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3769 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3770 case PT_IA_64_HP_STACK: return "HP_STACK";
32ec8896 3771 default: return NULL;
4d6ed7c8 3772 }
4d6ed7c8
NC		 3773}
3774
40b36596
JM		 3775static const char *
3776get_tic6x_segment_type (unsigned long type)
3777{
3778 switch (type)
3779 {
32ec8896
NC		 3780 case PT_C6000_PHATTR: return "C6000_PHATTR";
3781 default: return NULL;
40b36596 3782 }
40b36596
JM		 3783}
3784
5522f910
NC		 3785static const char *
3786get_solaris_segment_type (unsigned long type)
3787{
3788 switch (type)
3789 {
3790 case 0x6464e550: return "PT_SUNW_UNWIND";
3791 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3792 case 0x6ffffff7: return "PT_LOSUNW";
3793 case 0x6ffffffa: return "PT_SUNWBSS";
3794 case 0x6ffffffb: return "PT_SUNWSTACK";
3795 case 0x6ffffffc: return "PT_SUNWDTRACE";
3796 case 0x6ffffffd: return "PT_SUNWCAP";
3797 case 0x6fffffff: return "PT_HISUNW";
32ec8896 3798 default: return NULL;
5522f910
NC		 3799 }
3800}
3801
252b5132 3802static const char *
d3ba0551 3803get_segment_type (unsigned long p_type)
252b5132 3804{
b34976b6 3805 static char buff[32];
252b5132
RH		 3806
3807 switch (p_type)
3808 {
b34976b6
AM		 3809 case PT_NULL: return "NULL";
3810 case PT_LOAD: return "LOAD";
252b5132 3811 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 3812 case PT_INTERP: return "INTERP";
3813 case PT_NOTE: return "NOTE";
3814 case PT_SHLIB: return "SHLIB";
3815 case PT_PHDR: return "PHDR";
13ae64f3 3816 case PT_TLS: return "TLS";
32ec8896 3817 case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
2b05f1b7 3818 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 3819 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 3820
252b5132
RH		 3821 default:
3822 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3823 {
2cf0635d 3824 const char * result;
103f02d3 3825
252b5132
RH		 3826 switch (elf_header.e_machine)
3827 {
a06ea964
NC		 3828 case EM_AARCH64:
3829 result = get_aarch64_segment_type (p_type);
3830 break;
b294bdf8
MM		 3831 case EM_ARM:
3832 result = get_arm_segment_type (p_type);
3833 break;
252b5132 3834 case EM_MIPS:
4fe85591 3835 case EM_MIPS_RS3_LE:
252b5132
RH		 3836 result = get_mips_segment_type (p_type);
3837 break;
103f02d3
UD		 3838 case EM_PARISC:
3839 result = get_parisc_segment_type (p_type);
3840 break;
4d6ed7c8
NC		 3841 case EM_IA_64:
3842 result = get_ia64_segment_type (p_type);
3843 break;
40b36596
JM		 3844 case EM_TI_C6000:
3845 result = get_tic6x_segment_type (p_type);
3846 break;
252b5132
RH		 3847 default:
3848 result = NULL;
3849 break;
3850 }
103f02d3 3851
252b5132
RH		 3852 if (result != NULL)
3853 return result;
103f02d3 3854
1a9ccd70 3855 sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
252b5132
RH		 3856 }
3857 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 3858 {
2cf0635d 3859 const char * result;
103f02d3
UD		 3860
3861 switch (elf_header.e_machine)
3862 {
3863 case EM_PARISC:
3864 result = get_parisc_segment_type (p_type);
3865 break;
00428cca
AM		 3866 case EM_IA_64:
3867 result = get_ia64_segment_type (p_type);
3868 break;
103f02d3 3869 default:
5522f910
NC		 3870 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
3871 result = get_solaris_segment_type (p_type);
3872 else
3873 result = NULL;
103f02d3
UD		 3874 break;
3875 }
3876
3877 if (result != NULL)
3878 return result;
3879
1a9ccd70 3880 sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
103f02d3 3881 }
252b5132 3882 else
e9e44622 3883 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 3884
3885 return buff;
3886 }
3887}
3888
3889static const char *
d3ba0551 3890get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 3891{
3892 switch (sh_type)
3893 {
b34976b6
AM		 3894 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3895 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3896 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3897 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3898 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3899 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3900 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3901 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3902 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3903 case SHT_MIPS_RELD: return "MIPS_RELD";
3904 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3905 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3906 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3907 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3908 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3909 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3910 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3911 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3912 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3913 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3914 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3915 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3916 case SHT_MIPS_LINE: return "MIPS_LINE";
3917 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3918 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3919 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3920 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3921 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3922 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3923 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3924 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3925 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3926 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3927 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3928 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3929 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3930 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3931 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132 3932 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
351cdf24 3933 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
252b5132
RH		 3934 default:
3935 break;
3936 }
3937 return NULL;
3938}
3939
103f02d3 3940static const char *
d3ba0551 3941get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 3942{
3943 switch (sh_type)
3944 {
3945 case SHT_PARISC_EXT: return "PARISC_EXT";
3946 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3947 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 3948 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3949 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3950 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 3951 case SHT_PARISC_DLKM: return "PARISC_DLKM";
32ec8896 3952 default: return NULL;
103f02d3 3953 }
103f02d3
UD		 3954}
3955
4d6ed7c8 3956static const char *
d3ba0551 3957get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 3958{
18bd398b 3959 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 3960 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3961 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 3962
4d6ed7c8
NC		 3963 switch (sh_type)
3964 {
148b93f2
NC		 3965 case SHT_IA_64_EXT: return "IA_64_EXT";
3966 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3967 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3968 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3969 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3970 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3971 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3972 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3973 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3974 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 3975 default:
3976 break;
3977 }
3978 return NULL;
3979}
3980
d2b2c203
DJ		 3981static const char *
3982get_x86_64_section_type_name (unsigned int sh_type)
3983{
3984 switch (sh_type)
3985 {
3986 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
32ec8896 3987 default: return NULL;
d2b2c203 3988 }
d2b2c203
DJ		 3989}
3990
a06ea964
NC		 3991static const char *
3992get_aarch64_section_type_name (unsigned int sh_type)
3993{
3994 switch (sh_type)
3995 {
32ec8896
NC		 3996 case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
3997 default: return NULL;
a06ea964 3998 }
a06ea964
NC		 3999}
4000
40a18ebd
NC		 4001static const char *
4002get_arm_section_type_name (unsigned int sh_type)
4003{
4004 switch (sh_type)
4005 {
7f6fed87
NC		 4006 case SHT_ARM_EXIDX: return "ARM_EXIDX";
4007 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
4008 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
4009 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
4010 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
32ec8896 4011 default: return NULL;
40a18ebd 4012 }
40a18ebd
NC		 4013}
4014
40b36596
JM		 4015static const char *
4016get_tic6x_section_type_name (unsigned int sh_type)
4017{
4018 switch (sh_type)
4019 {
32ec8896
NC		 4020 case SHT_C6000_UNWIND: return "C6000_UNWIND";
4021 case SHT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
4022 case SHT_C6000_ATTRIBUTES: return "C6000_ATTRIBUTES";
4023 case SHT_TI_ICODE: return "TI_ICODE";
4024 case SHT_TI_XREF: return "TI_XREF";
4025 case SHT_TI_HANDLER: return "TI_HANDLER";
4026 case SHT_TI_INITINFO: return "TI_INITINFO";
4027 case SHT_TI_PHATTRS: return "TI_PHATTRS";
4028 default: return NULL;
40b36596 4029 }
40b36596
JM		 4030}
4031
13761a11
NC		 4032static const char *
4033get_msp430x_section_type_name (unsigned int sh_type)
4034{
4035 switch (sh_type)
4036 {
32ec8896
NC		 4037 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
4038 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
4039 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
4040 default: return NULL;
13761a11
NC		 4041 }
4042}
4043
685080f2
NC		 4044static const char *
4045get_v850_section_type_name (unsigned int sh_type)
4046{
4047 switch (sh_type)
4048 {
32ec8896
NC		 4049 case SHT_V850_SCOMMON: return "V850 Small Common";
4050 case SHT_V850_TCOMMON: return "V850 Tiny Common";
4051 case SHT_V850_ZCOMMON: return "V850 Zero Common";
4052 case SHT_RENESAS_IOP: return "RENESAS IOP";
4053 case SHT_RENESAS_INFO: return "RENESAS INFO";
4054 default: return NULL;
685080f2
NC		 4055 }
4056}
4057
252b5132 4058static const char *
d3ba0551 4059get_section_type_name (unsigned int sh_type)
252b5132 4060{
b34976b6 4061 static char buff[32];
9fb71ee4 4062 const char * result;
252b5132
RH		 4063
4064 switch (sh_type)
4065 {
4066 case SHT_NULL: return "NULL";
4067 case SHT_PROGBITS: return "PROGBITS";
4068 case SHT_SYMTAB: return "SYMTAB";
4069 case SHT_STRTAB: return "STRTAB";
4070 case SHT_RELA: return "RELA";
4071 case SHT_HASH: return "HASH";
4072 case SHT_DYNAMIC: return "DYNAMIC";
4073 case SHT_NOTE: return "NOTE";
4074 case SHT_NOBITS: return "NOBITS";
4075 case SHT_REL: return "REL";
4076 case SHT_SHLIB: return "SHLIB";
4077 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 4078 case SHT_INIT_ARRAY: return "INIT_ARRAY";
4079 case SHT_FINI_ARRAY: return "FINI_ARRAY";
4080 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 4081 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 4082 case SHT_GROUP: return "GROUP";
4083 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 4084 case SHT_GNU_verdef: return "VERDEF";
4085 case SHT_GNU_verneed: return "VERNEED";
4086 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 4087 case 0x6ffffff0: return "VERSYM";
4088 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 4089 case 0x7ffffffd: return "AUXILIARY";
4090 case 0x7fffffff: return "FILTER";
047b2264 4091 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 4092
4093 default:
4094 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4095 {
252b5132
RH		 4096 switch (elf_header.e_machine)
4097 {
4098 case EM_MIPS:
4fe85591 4099 case EM_MIPS_RS3_LE:
252b5132
RH		 4100 result = get_mips_section_type_name (sh_type);
4101 break;
103f02d3
UD		 4102 case EM_PARISC:
4103 result = get_parisc_section_type_name (sh_type);
4104 break;
4d6ed7c8
NC		 4105 case EM_IA_64:
4106 result = get_ia64_section_type_name (sh_type);
4107 break;
d2b2c203 4108 case EM_X86_64:
8a9036a4 4109 case EM_L1OM:
7a9068fe 4110 case EM_K1OM:
d2b2c203
DJ		 4111 result = get_x86_64_section_type_name (sh_type);
4112 break;
a06ea964
NC		 4113 case EM_AARCH64:
4114 result = get_aarch64_section_type_name (sh_type);
4115 break;
40a18ebd
NC		 4116 case EM_ARM:
4117 result = get_arm_section_type_name (sh_type);
4118 break;
40b36596
JM		 4119 case EM_TI_C6000:
4120 result = get_tic6x_section_type_name (sh_type);
4121 break;
13761a11
NC		 4122 case EM_MSP430:
4123 result = get_msp430x_section_type_name (sh_type);
4124 break;
685080f2
NC		 4125 case EM_V800:
4126 case EM_V850:
4127 case EM_CYGNUS_V850:
4128 result = get_v850_section_type_name (sh_type);
4129 break;
252b5132
RH		 4130 default:
4131 result = NULL;
4132 break;
4133 }
4134
4135 if (result != NULL)
4136 return result;
4137
9fb71ee4 4138 sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
252b5132
RH		 4139 }
4140 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 4141 {
148b93f2
NC		 4142 switch (elf_header.e_machine)
4143 {
4144 case EM_IA_64:
4145 result = get_ia64_section_type_name (sh_type);
4146 break;
4147 default:
fd85a6a1
NC		 4148 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4149 result = get_solaris_section_type (sh_type);
4150 else
1b4b80bf
NC		 4151 {
4152 switch (sh_type)
4153 {
4154 case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4155 case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4156 case SHT_GNU_HASH: result = "GNU_HASH"; break;
4157 case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4158 default:
4159 result = NULL;
4160 break;
4161 }
4162 }
148b93f2
NC		 4163 break;
4164 }
4165
4166 if (result != NULL)
4167 return result;
4168
9fb71ee4 4169 sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
148b93f2 4170 }
252b5132 4171 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
685080f2
NC		 4172 {
4173 switch (elf_header.e_machine)
4174 {
4175 case EM_V800:
4176 case EM_V850:
4177 case EM_CYGNUS_V850:
9fb71ee4 4178 result = get_v850_section_type_name (sh_type);
a9fb83be 4179 break;
685080f2 4180 default:
9fb71ee4 4181 result = NULL;
685080f2
NC		 4182 break;
4183 }
4184
9fb71ee4
NC		 4185 if (result != NULL)
4186 return result;
4187
4188 sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
685080f2 4189 }
252b5132 4190 else
a7dbfd1c
NC		 4191 /* This message is probably going to be displayed in a 15
4192 character wide field, so put the hex value first. */
4193 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 4194
252b5132
RH		 4195 return buff;
4196 }
4197}
4198
2979dc34 4199#define OPTION_DEBUG_DUMP 512
2c610e4b 4200#define OPTION_DYN_SYMS 513
fd2f0033
TT		 4201#define OPTION_DWARF_DEPTH 514
4202#define OPTION_DWARF_START 515
4723351a 4203#define OPTION_DWARF_CHECK 516
2979dc34 4204
85b1c36d 4205static struct option options[] =
252b5132 4206{
b34976b6 4207 {"all", no_argument, 0, 'a'},
252b5132
RH		 4208 {"file-header", no_argument, 0, 'h'},
4209 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 4210 {"headers", no_argument, 0, 'e'},
4211 {"histogram", no_argument, 0, 'I'},
4212 {"segments", no_argument, 0, 'l'},
4213 {"sections", no_argument, 0, 'S'},
252b5132 4214 {"section-headers", no_argument, 0, 'S'},
f5842774 4215 {"section-groups", no_argument, 0, 'g'},
5477e8a0 4216 {"section-details", no_argument, 0, 't'},
595cf52e 4217 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 4218 {"symbols", no_argument, 0, 's'},
4219 {"syms", no_argument, 0, 's'},
2c610e4b 4220 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 4221 {"relocs", no_argument, 0, 'r'},
4222 {"notes", no_argument, 0, 'n'},
4223 {"dynamic", no_argument, 0, 'd'},
a952a375 4224 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 4225 {"version-info", no_argument, 0, 'V'},
4226 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 4227 {"unwind", no_argument, 0, 'u'},
4145f1d5 4228 {"archive-index", no_argument, 0, 'c'},
b34976b6 4229 {"hex-dump", required_argument, 0, 'x'},
cf13d699 4230 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 4231 {"string-dump", required_argument, 0, 'p'},
0e602686 4232 {"decompress", no_argument, 0, 'z'},
252b5132
RH		 4233#ifdef SUPPORT_DISASSEMBLY
4234 {"instruction-dump", required_argument, 0, 'i'},
4235#endif
cf13d699 4236 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 4237
fd2f0033
TT		 4238 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
4239 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 4240 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 4241
b34976b6
AM		 4242 {"version", no_argument, 0, 'v'},
4243 {"wide", no_argument, 0, 'W'},
4244 {"help", no_argument, 0, 'H'},
4245 {0, no_argument, 0, 0}
252b5132
RH		 4246};
4247
4248static void
2cf0635d 4249usage (FILE * stream)
252b5132 4250{
92f01d61
JM		 4251 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4252 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4253 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 4254 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4255 -h --file-header Display the ELF file header\n\
4256 -l --program-headers Display the program headers\n\
4257 --segments An alias for --program-headers\n\
4258 -S --section-headers Display the sections' header\n\
4259 --sections An alias for --section-headers\n\
f5842774 4260 -g --section-groups Display the section groups\n\
5477e8a0 4261 -t --section-details Display the section details\n\
8b53311e
NC		 4262 -e --headers Equivalent to: -h -l -S\n\
4263 -s --syms Display the symbol table\n\
3f08eb35 4264 --symbols An alias for --syms\n\
2c610e4b 4265 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 4266 -n --notes Display the core notes (if present)\n\
4267 -r --relocs Display the relocations (if present)\n\
4268 -u --unwind Display the unwind info (if present)\n\
b2d38a17 4269 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 4270 -V --version-info Display the version sections (if present)\n\
1b31d05e 4271 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 4272 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 4273 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 4274 -x --hex-dump=<number|name>\n\
4275 Dump the contents of section <number|name> as bytes\n\
4276 -p --string-dump=<number|name>\n\
4277 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 4278 -R --relocated-dump=<number|name>\n\
4279 Dump the contents of section <number|name> as relocated bytes\n\
0e602686 4280 -z --decompress Decompress section before dumping it\n\
f9f0e732 4281 -w[lLiaprmfFsoRt] or\n\
1ed06042 4282 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 4283 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC		 4284 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4285 =addr,=cu_index]\n\
8b53311e 4286 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 4287 fprintf (stream, _("\
4288 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4289 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4290 or deeper\n"));
252b5132 4291#ifdef SUPPORT_DISASSEMBLY
92f01d61 4292 fprintf (stream, _("\
09c11c86
NC		 4293 -i --instruction-dump=<number|name>\n\
4294 Disassemble the contents of section <number|name>\n"));
252b5132 4295#endif
92f01d61 4296 fprintf (stream, _("\
8b53311e
NC		 4297 -I --histogram Display histogram of bucket list lengths\n\
4298 -W --wide Allow output width to exceed 80 characters\n\
07012eee 4299 @<file> Read options from <file>\n\
8b53311e
NC		 4300 -H --help Display this information\n\
4301 -v --version Display the version number of readelf\n"));
1118d252 4302
92f01d61
JM		 4303 if (REPORT_BUGS_TO[0] && stream == stdout)
4304 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 4305
92f01d61 4306 exit (stream == stdout ? 0 : 1);
252b5132
RH		 4307}
4308
18bd398b
NC		 4309/* Record the fact that the user wants the contents of section number
4310 SECTION to be displayed using the method(s) encoded as flags bits
4311 in TYPE. Note, TYPE can be zero if we are creating the array for
4312 the first time. */
4313
252b5132 4314static void
09c11c86 4315request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 4316{
4317 if (section >= num_dump_sects)
4318 {
2cf0635d 4319 dump_type * new_dump_sects;
252b5132 4320
3f5e193b
NC		 4321 new_dump_sects = (dump_type *) calloc (section + 1,
4322 sizeof (* dump_sects));
252b5132
RH		 4323
4324 if (new_dump_sects == NULL)
591a748a 4325 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 4326 else
4327 {
21b65bac
NC		 4328 if (dump_sects)
4329 {
4330 /* Copy current flag settings. */
4331 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132 4332
21b65bac
NC		 4333 free (dump_sects);
4334 }
252b5132
RH		 4335
4336 dump_sects = new_dump_sects;
4337 num_dump_sects = section + 1;
4338 }
4339 }
4340
4341 if (dump_sects)
b34976b6 4342 dump_sects[section] |= type;
252b5132
RH		 4343
4344 return;
4345}
4346
aef1f6d0
DJ		 4347/* Request a dump by section name. */
4348
4349static void
2cf0635d 4350request_dump_byname (const char * section, dump_type type)
aef1f6d0 4351{
2cf0635d 4352 struct dump_list_entry * new_request;
aef1f6d0 4353
3f5e193b
NC		 4354 new_request = (struct dump_list_entry *)
4355 malloc (sizeof (struct dump_list_entry));
aef1f6d0 4356 if (!new_request)
591a748a 4357 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4358
4359 new_request->name = strdup (section);
4360 if (!new_request->name)
591a748a 4361 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4362
4363 new_request->type = type;
4364
4365 new_request->next = dump_sects_byname;
4366 dump_sects_byname = new_request;
4367}
4368
cf13d699
NC		 4369static inline void
4370request_dump (dump_type type)
4371{
4372 int section;
4373 char * cp;
4374
4375 do_dump++;
4376 section = strtoul (optarg, & cp, 0);
4377
4378 if (! *cp && section >= 0)
4379 request_dump_bynumber (section, type);
4380 else
4381 request_dump_byname (optarg, type);
4382}
4383
4384
252b5132 4385static void
2cf0635d 4386parse_args (int argc, char ** argv)
252b5132
RH		 4387{
4388 int c;
4389
4390 if (argc < 2)
92f01d61 4391 usage (stderr);
252b5132
RH		 4392
4393 while ((c = getopt_long
0e602686 4394 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
252b5132 4395 {
252b5132
RH		 4396 switch (c)
4397 {
4398 case 0:
4399 /* Long options. */
4400 break;
4401 case 'H':
92f01d61 4402 usage (stdout);
252b5132
RH		 4403 break;
4404
4405 case 'a':
32ec8896
NC		 4406 do_syms = TRUE;
4407 do_reloc = TRUE;
4408 do_unwind = TRUE;
4409 do_dynamic = TRUE;
4410 do_header = TRUE;
4411 do_sections = TRUE;
4412 do_section_groups = TRUE;
4413 do_segments = TRUE;
4414 do_version = TRUE;
4415 do_histogram = TRUE;
4416 do_arch = TRUE;
4417 do_notes = TRUE;
252b5132 4418 break;
f5842774 4419 case 'g':
32ec8896 4420 do_section_groups = TRUE;
f5842774 4421 break;
5477e8a0 4422 case 't':
595cf52e 4423 case 'N':
32ec8896
NC		 4424 do_sections = TRUE;
4425 do_section_details = TRUE;
595cf52e 4426 break;
252b5132 4427 case 'e':
32ec8896
NC		 4428 do_header = TRUE;
4429 do_sections = TRUE;
4430 do_segments = TRUE;
252b5132 4431 break;
a952a375 4432 case 'A':
32ec8896 4433 do_arch = TRUE;
a952a375 4434 break;
252b5132 4435 case 'D':
32ec8896 4436 do_using_dynamic = TRUE;
252b5132
RH		 4437 break;
4438 case 'r':
32ec8896 4439 do_reloc = TRUE;
252b5132 4440 break;
4d6ed7c8 4441 case 'u':
32ec8896 4442 do_unwind = TRUE;
4d6ed7c8 4443 break;
252b5132 4444 case 'h':
32ec8896 4445 do_header = TRUE;
252b5132
RH		 4446 break;
4447 case 'l':
32ec8896 4448 do_segments = TRUE;
252b5132
RH		 4449 break;
4450 case 's':
32ec8896 4451 do_syms = TRUE;
252b5132
RH		 4452 break;
4453 case 'S':
32ec8896 4454 do_sections = TRUE;
252b5132
RH		 4455 break;
4456 case 'd':
32ec8896 4457 do_dynamic = TRUE;
252b5132 4458 break;
a952a375 4459 case 'I':
32ec8896 4460 do_histogram = TRUE;
a952a375 4461 break;
779fe533 4462 case 'n':
32ec8896 4463 do_notes = TRUE;
779fe533 4464 break;
4145f1d5 4465 case 'c':
32ec8896 4466 do_archive_index = TRUE;
4145f1d5 4467 break;
252b5132 4468 case 'x':
cf13d699 4469 request_dump (HEX_DUMP);
aef1f6d0 4470 break;
09c11c86 4471 case 'p':
cf13d699
NC		 4472 request_dump (STRING_DUMP);
4473 break;
4474 case 'R':
4475 request_dump (RELOC_DUMP);
09c11c86 4476 break;
0e602686 4477 case 'z':
32ec8896 4478 decompress_dumps = TRUE;
0e602686 4479 break;
252b5132 4480 case 'w':
32ec8896 4481 do_dump = TRUE;
252b5132 4482 if (optarg == 0)
613ff48b 4483 {
32ec8896 4484 do_debugging = TRUE;
613ff48b
CC		 4485 dwarf_select_sections_all ();
4486 }
252b5132
RH		 4487 else
4488 {
32ec8896 4489 do_debugging = FALSE;
4cb93e3b 4490 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 4491 }
4492 break;
2979dc34 4493 case OPTION_DEBUG_DUMP:
32ec8896 4494 do_dump = TRUE;
2979dc34 4495 if (optarg == 0)
32ec8896 4496 do_debugging = TRUE;
2979dc34
JJ		 4497 else
4498 {
32ec8896 4499 do_debugging = FALSE;
4cb93e3b 4500 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 4501 }
4502 break;
fd2f0033
TT		 4503 case OPTION_DWARF_DEPTH:
4504 {
4505 char *cp;
4506
4507 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4508 }
4509 break;
4510 case OPTION_DWARF_START:
4511 {
4512 char *cp;
4513
4514 dwarf_start_die = strtoul (optarg, & cp, 0);
4515 }
4516 break;
4723351a 4517 case OPTION_DWARF_CHECK:
32ec8896 4518 dwarf_check = TRUE;
4723351a 4519 break;
2c610e4b 4520 case OPTION_DYN_SYMS:
32ec8896 4521 do_dyn_syms = TRUE;
2c610e4b 4522 break;
252b5132
RH		 4523#ifdef SUPPORT_DISASSEMBLY
4524 case 'i':
cf13d699
NC		 4525 request_dump (DISASS_DUMP);
4526 break;
252b5132
RH		 4527#endif
4528 case 'v':
4529 print_version (program_name);
4530 break;
4531 case 'V':
32ec8896 4532 do_version = TRUE;
252b5132 4533 break;
d974e256 4534 case 'W':
32ec8896 4535 do_wide = TRUE;
d974e256 4536 break;
252b5132 4537 default:
252b5132
RH		 4538 /* xgettext:c-format */
4539 error (_("Invalid option '-%c'\n"), c);
1a0670f3 4540 /* Fall through. */
252b5132 4541 case '?':
92f01d61 4542 usage (stderr);
252b5132
RH		 4543 }
4544 }
4545
4d6ed7c8 4546 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 4547 && !do_segments && !do_header && !do_dump && !do_version
f5842774 4548 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 4549 && !do_section_groups && !do_archive_index
4550 && !do_dyn_syms)
92f01d61 4551 usage (stderr);
252b5132
RH		 4552}
4553
4554static const char *
d3ba0551 4555get_elf_class (unsigned int elf_class)
252b5132 4556{
b34976b6 4557 static char buff[32];
103f02d3 4558
252b5132
RH		 4559 switch (elf_class)
4560 {
4561 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 4562 case ELFCLASS32: return "ELF32";
4563 case ELFCLASS64: return "ELF64";
ab5e7794 4564 default:
e9e44622 4565 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 4566 return buff;
252b5132
RH		 4567 }
4568}
4569
4570static const char *
d3ba0551 4571get_data_encoding (unsigned int encoding)
252b5132 4572{
b34976b6 4573 static char buff[32];
103f02d3 4574
252b5132
RH		 4575 switch (encoding)
4576 {
4577 case ELFDATANONE: return _("none");
33c63f9d
CM		 4578 case ELFDATA2LSB: return _("2's complement, little endian");
4579 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 4580 default:
e9e44622 4581 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 4582 return buff;
252b5132
RH		 4583 }
4584}
4585
252b5132 4586/* Decode the data held in 'elf_header'. */
ee42cf8c 4587
32ec8896 4588static bfd_boolean
d3ba0551 4589process_file_header (void)
252b5132 4590{
b34976b6
AM		 4591 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
4592 || elf_header.e_ident[EI_MAG1] != ELFMAG1
4593 || elf_header.e_ident[EI_MAG2] != ELFMAG2
4594 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 4595 {
4596 error
4597 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
32ec8896 4598 return FALSE;
252b5132
RH		 4599 }
4600
2dc4cec1
L		 4601 init_dwarf_regnames (elf_header.e_machine);
4602
252b5132
RH		 4603 if (do_header)
4604 {
32ec8896 4605 unsigned i;
252b5132
RH		 4606
4607 printf (_("ELF Header:\n"));
4608 printf (_(" Magic: "));
b34976b6
AM		 4609 for (i = 0; i < EI_NIDENT; i++)
4610 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 4611 printf ("\n");
4612 printf (_(" Class: %s\n"),
b34976b6 4613 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 4614 printf (_(" Data: %s\n"),
b34976b6 4615 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 4616 printf (_(" Version: %d %s\n"),
b34976b6
AM		 4617 elf_header.e_ident[EI_VERSION],
4618 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 4619 ? "(current)"
b34976b6 4620 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 4621 ? _("<unknown: %lx>")
789be9f7 4622 : "")));
252b5132 4623 printf (_(" OS/ABI: %s\n"),
b34976b6 4624 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 4625 printf (_(" ABI Version: %d\n"),
b34976b6 4626 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 4627 printf (_(" Type: %s\n"),
4628 get_file_type (elf_header.e_type));
4629 printf (_(" Machine: %s\n"),
4630 get_machine_name (elf_header.e_machine));
4631 printf (_(" Version: 0x%lx\n"),
4632 (unsigned long) elf_header.e_version);
76da6bbe 4633
f7a99963
NC		 4634 printf (_(" Entry point address: "));
4635 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4636 printf (_("\n Start of program headers: "));
4637 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4638 printf (_(" (bytes into file)\n Start of section headers: "));
4639 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4640 printf (_(" (bytes into file)\n"));
76da6bbe 4641
252b5132
RH		 4642 printf (_(" Flags: 0x%lx%s\n"),
4643 (unsigned long) elf_header.e_flags,
4644 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4645 printf (_(" Size of this header: %ld (bytes)\n"),
4646 (long) elf_header.e_ehsize);
4647 printf (_(" Size of program headers: %ld (bytes)\n"),
4648 (long) elf_header.e_phentsize);
2046a35d 4649 printf (_(" Number of program headers: %ld"),
252b5132 4650 (long) elf_header.e_phnum);
2046a35d
AM		 4651 if (section_headers != NULL
4652 && elf_header.e_phnum == PN_XNUM
4653 && section_headers[0].sh_info != 0)
cc5914eb 4654 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 4655 putc ('\n', stdout);
252b5132
RH		 4656 printf (_(" Size of section headers: %ld (bytes)\n"),
4657 (long) elf_header.e_shentsize);
560f3c1c 4658 printf (_(" Number of section headers: %ld"),
252b5132 4659 (long) elf_header.e_shnum);
4fbb74a6 4660 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 4661 printf (" (%ld)", (long) section_headers[0].sh_size);
4662 putc ('\n', stdout);
4663 printf (_(" Section header string table index: %ld"),
252b5132 4664 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 4665 if (section_headers != NULL
4666 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 4667 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 4668 else if (elf_header.e_shstrndx != SHN_UNDEF
4669 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 4670 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 4671 putc ('\n', stdout);
4672 }
4673
4674 if (section_headers != NULL)
4675 {
2046a35d
AM		 4676 if (elf_header.e_phnum == PN_XNUM
4677 && section_headers[0].sh_info != 0)
4678 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 4679 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 4680 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 4681 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 4682 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 4683 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 4684 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 4685 free (section_headers);
4686 section_headers = NULL;
252b5132 4687 }
103f02d3 4688
32ec8896 4689 return TRUE;
9ea033b2
NC		 4690}
4691
e0a31db1 4692static bfd_boolean
91d6fa6a 4693get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4694{
2cf0635d
NC		 4695 Elf32_External_Phdr * phdrs;
4696 Elf32_External_Phdr * external;
4697 Elf_Internal_Phdr * internal;
b34976b6 4698 unsigned int i;
e0a31db1
NC		 4699 unsigned int size = elf_header.e_phentsize;
4700 unsigned int num = elf_header.e_phnum;
4701
4702 /* PR binutils/17531: Cope with unexpected section header sizes. */
4703 if (size == 0 || num == 0)
4704 return FALSE;
4705 if (size < sizeof * phdrs)
4706 {
4707 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4708 return FALSE;
4709 }
4710 if (size > sizeof * phdrs)
4711 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4712
3f5e193b 4713 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1
NC		 4714 size, num, _("program headers"));
4715 if (phdrs == NULL)
4716 return FALSE;
9ea033b2 4717
91d6fa6a 4718 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4719 i < elf_header.e_phnum;
b34976b6 4720 i++, internal++, external++)
252b5132 4721 {
9ea033b2
NC		 4722 internal->p_type = BYTE_GET (external->p_type);
4723 internal->p_offset = BYTE_GET (external->p_offset);
4724 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4725 internal->p_paddr = BYTE_GET (external->p_paddr);
4726 internal->p_filesz = BYTE_GET (external->p_filesz);
4727 internal->p_memsz = BYTE_GET (external->p_memsz);
4728 internal->p_flags = BYTE_GET (external->p_flags);
4729 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 4730 }
4731
9ea033b2 4732 free (phdrs);
e0a31db1 4733 return TRUE;
252b5132
RH		 4734}
4735
e0a31db1 4736static bfd_boolean
91d6fa6a 4737get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4738{
2cf0635d
NC		 4739 Elf64_External_Phdr * phdrs;
4740 Elf64_External_Phdr * external;
4741 Elf_Internal_Phdr * internal;
b34976b6 4742 unsigned int i;
e0a31db1
NC		 4743 unsigned int size = elf_header.e_phentsize;
4744 unsigned int num = elf_header.e_phnum;
4745
4746 /* PR binutils/17531: Cope with unexpected section header sizes. */
4747 if (size == 0 || num == 0)
4748 return FALSE;
4749 if (size < sizeof * phdrs)
4750 {
4751 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4752 return FALSE;
4753 }
4754 if (size > sizeof * phdrs)
4755 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4756
3f5e193b 4757 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1 4758 size, num, _("program headers"));
a6e9f9df 4759 if (!phdrs)
e0a31db1 4760 return FALSE;
9ea033b2 4761
91d6fa6a 4762 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4763 i < elf_header.e_phnum;
b34976b6 4764 i++, internal++, external++)
9ea033b2
NC		 4765 {
4766 internal->p_type = BYTE_GET (external->p_type);
4767 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 4768 internal->p_offset = BYTE_GET (external->p_offset);
4769 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4770 internal->p_paddr = BYTE_GET (external->p_paddr);
4771 internal->p_filesz = BYTE_GET (external->p_filesz);
4772 internal->p_memsz = BYTE_GET (external->p_memsz);
4773 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 4774 }
4775
4776 free (phdrs);
e0a31db1 4777 return TRUE;
9ea033b2 4778}
252b5132 4779
32ec8896 4780/* Returns TRUE if the program headers were read into `program_headers'. */
d93f0186 4781
32ec8896 4782static bfd_boolean
2cf0635d 4783get_program_headers (FILE * file)
d93f0186 4784{
2cf0635d 4785 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 4786
4787 /* Check cache of prior read. */
4788 if (program_headers != NULL)
32ec8896 4789 return TRUE;
d93f0186 4790
3f5e193b
NC		 4791 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4792 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 4793
4794 if (phdrs == NULL)
4795 {
8b73c356
NC		 4796 error (_("Out of memory reading %u program headers\n"),
4797 elf_header.e_phnum);
32ec8896 4798 return FALSE;
d93f0186
NC		 4799 }
4800
4801 if (is_32bit_elf
4802 ? get_32bit_program_headers (file, phdrs)
4803 : get_64bit_program_headers (file, phdrs))
4804 {
4805 program_headers = phdrs;
32ec8896 4806 return TRUE;
d93f0186
NC		 4807 }
4808
4809 free (phdrs);
32ec8896 4810 return FALSE;
d93f0186
NC		 4811}
4812
32ec8896 4813/* Returns TRUE if the program headers were loaded. */
2f62977e 4814
32ec8896 4815static bfd_boolean
2cf0635d 4816process_program_headers (FILE * file)
252b5132 4817{
2cf0635d 4818 Elf_Internal_Phdr * segment;
b34976b6 4819 unsigned int i;
1a9ccd70 4820 Elf_Internal_Phdr * previous_load = NULL;
252b5132
RH		 4821
4822 if (elf_header.e_phnum == 0)
4823 {
82f2dbf7
NC		 4824 /* PR binutils/12467. */
4825 if (elf_header.e_phoff != 0)
32ec8896
NC		 4826 {
4827 warn (_("possibly corrupt ELF header - it has a non-zero program"
4828 " header offset, but no program headers\n"));
4829 return FALSE;
4830 }
82f2dbf7 4831 else if (do_segments)
252b5132 4832 printf (_("\nThere are no program headers in this file.\n"));
32ec8896 4833 return TRUE;
252b5132
RH		 4834 }
4835
4836 if (do_segments && !do_header)
4837 {
f7a99963
NC		 4838 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4839 printf (_("Entry point "));
4840 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4841 printf (_("\nThere are %d program headers, starting at offset "),
4842 elf_header.e_phnum);
4843 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4844 printf ("\n");
252b5132
RH		 4845 }
4846
d93f0186 4847 if (! get_program_headers (file))
6b4bf3bc 4848 return TRUE;
103f02d3 4849
252b5132
RH		 4850 if (do_segments)
4851 {
3a1a2036
NC		 4852 if (elf_header.e_phnum > 1)
4853 printf (_("\nProgram Headers:\n"));
4854 else
4855 printf (_("\nProgram Headers:\n"));
76da6bbe 4856
f7a99963
NC		 4857 if (is_32bit_elf)
4858 printf
4859 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 4860 else if (do_wide)
4861 printf
4862 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 4863 else
4864 {
4865 printf
4866 (_(" Type Offset VirtAddr PhysAddr\n"));
4867 printf
4868 (_(" FileSiz MemSiz Flags Align\n"));
4869 }
252b5132
RH		 4870 }
4871
252b5132 4872 dynamic_addr = 0;
1b228002 4873 dynamic_size = 0;
252b5132
RH		 4874
4875 for (i = 0, segment = program_headers;
4876 i < elf_header.e_phnum;
b34976b6 4877 i++, segment++)
252b5132
RH		 4878 {
4879 if (do_segments)
4880 {
103f02d3 4881 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 4882
4883 if (is_32bit_elf)
4884 {
4885 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4886 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4887 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4888 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4889 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4890 printf ("%c%c%c ",
4891 (segment->p_flags & PF_R ? 'R' : ' '),
4892 (segment->p_flags & PF_W ? 'W' : ' '),
4893 (segment->p_flags & PF_X ? 'E' : ' '));
4894 printf ("%#lx", (unsigned long) segment->p_align);
4895 }
d974e256
JJ		 4896 else if (do_wide)
4897 {
4898 if ((unsigned long) segment->p_offset == segment->p_offset)
4899 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4900 else
4901 {
4902 print_vma (segment->p_offset, FULL_HEX);
4903 putchar (' ');
4904 }
4905
4906 print_vma (segment->p_vaddr, FULL_HEX);
4907 putchar (' ');
4908 print_vma (segment->p_paddr, FULL_HEX);
4909 putchar (' ');
4910
4911 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4912 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4913 else
4914 {
4915 print_vma (segment->p_filesz, FULL_HEX);
4916 putchar (' ');
4917 }
4918
4919 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4920 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4921 else
4922 {
f48e6c45 4923 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 4924 }
4925
4926 printf (" %c%c%c ",
4927 (segment->p_flags & PF_R ? 'R' : ' '),
4928 (segment->p_flags & PF_W ? 'W' : ' '),
4929 (segment->p_flags & PF_X ? 'E' : ' '));
4930
4931 if ((unsigned long) segment->p_align == segment->p_align)
4932 printf ("%#lx", (unsigned long) segment->p_align);
4933 else
4934 {
4935 print_vma (segment->p_align, PREFIX_HEX);
4936 }
4937 }
f7a99963
NC		 4938 else
4939 {
4940 print_vma (segment->p_offset, FULL_HEX);
4941 putchar (' ');
4942 print_vma (segment->p_vaddr, FULL_HEX);
4943 putchar (' ');
4944 print_vma (segment->p_paddr, FULL_HEX);
4945 printf ("\n ");
4946 print_vma (segment->p_filesz, FULL_HEX);
4947 putchar (' ');
4948 print_vma (segment->p_memsz, FULL_HEX);
4949 printf (" %c%c%c ",
4950 (segment->p_flags & PF_R ? 'R' : ' '),
4951 (segment->p_flags & PF_W ? 'W' : ' '),
4952 (segment->p_flags & PF_X ? 'E' : ' '));
1d262527 4953 print_vma (segment->p_align, PREFIX_HEX);
f7a99963 4954 }
252b5132 4955
1a9ccd70
NC		 4956 putc ('\n', stdout);
4957 }
f54498b4 4958
252b5132
RH		 4959 switch (segment->p_type)
4960 {
1a9ccd70 4961 case PT_LOAD:
502d895c
NC		 4962#if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
4963 required by the ELF standard, several programs, including the Linux
4964 kernel, make use of non-ordered segments. */
1a9ccd70
NC		 4965 if (previous_load
4966 && previous_load->p_vaddr > segment->p_vaddr)
4967 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
502d895c 4968#endif
1a9ccd70
NC		 4969 if (segment->p_memsz < segment->p_filesz)
4970 error (_("the segment's file size is larger than its memory size\n"));
4971 previous_load = segment;
4972 break;
4973
4974 case PT_PHDR:
4975 /* PR 20815 - Verify that the program header is loaded into memory. */
4976 if (i > 0 && previous_load != NULL)
4977 error (_("the PHDR segment must occur before any LOAD segment\n"));
4978 if (elf_header.e_machine != EM_PARISC)
4979 {
4980 unsigned int j;
4981
4982 for (j = 1; j < elf_header.e_phnum; j++)
4983 if (program_headers[j].p_vaddr <= segment->p_vaddr
4984 && (program_headers[j].p_vaddr + program_headers[j].p_memsz)
4985 >= (segment->p_vaddr + segment->p_filesz))
4986 break;
4987 if (j == elf_header.e_phnum)
4988 error (_("the PHDR segment is not covered by a LOAD segment\n"));
4989 }
4990 break;
4991
252b5132
RH		 4992 case PT_DYNAMIC:
4993 if (dynamic_addr)
4994 error (_("more than one dynamic segment\n"));
4995
20737c13
AM		 4996 /* By default, assume that the .dynamic section is the first
4997 section in the DYNAMIC segment. */
4998 dynamic_addr = segment->p_offset;
4999 dynamic_size = segment->p_filesz;
f54498b4
NC		 5000 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
5001 if (dynamic_addr + dynamic_size >= current_file_size)
5002 {
5003 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5004 dynamic_addr = dynamic_size = 0;
5005 }
20737c13 5006
b2d38a17
NC		 5007 /* Try to locate the .dynamic section. If there is
5008 a section header table, we can easily locate it. */
5009 if (section_headers != NULL)
5010 {
2cf0635d 5011 Elf_Internal_Shdr * sec;
b2d38a17 5012
89fac5e3
RS		 5013 sec = find_section (".dynamic");
5014 if (sec == NULL || sec->sh_size == 0)
b2d38a17 5015 {
28f997cf
TG		 5016 /* A corresponding .dynamic section is expected, but on
5017 IA-64/OpenVMS it is OK for it to be missing. */
5018 if (!is_ia64_vms ())
5019 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 5020 break;
5021 }
5022
42bb2e33 5023 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 5024 {
5025 dynamic_size = 0;
5026 break;
5027 }
42bb2e33 5028
b2d38a17
NC		 5029 dynamic_addr = sec->sh_offset;
5030 dynamic_size = sec->sh_size;
5031
5032 if (dynamic_addr < segment->p_offset
5033 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 5034 warn (_("the .dynamic section is not contained"
5035 " within the dynamic segment\n"));
b2d38a17 5036 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 5037 warn (_("the .dynamic section is not the first section"
5038 " in the dynamic segment.\n"));
b2d38a17 5039 }
252b5132
RH		 5040 break;
5041
5042 case PT_INTERP:
fb52b2f4
NC		 5043 if (fseek (file, archive_file_offset + (long) segment->p_offset,
5044 SEEK_SET))
252b5132
RH		 5045 error (_("Unable to find program interpreter name\n"));
5046 else
5047 {
f8eae8b2 5048 char fmt [32];
9495b2e6 5049 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
f8eae8b2
L		 5050
5051 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 5052 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 5053
252b5132 5054 program_interpreter[0] = 0;
7bd7b3ef
AM		 5055 if (fscanf (file, fmt, program_interpreter) <= 0)
5056 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 5057
5058 if (do_segments)
f54498b4 5059 printf (_(" [Requesting program interpreter: %s]\n"),
252b5132
RH		 5060 program_interpreter);
5061 }
5062 break;
5063 }
252b5132
RH		 5064 }
5065
c256ffe7 5066 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 5067 {
5068 printf (_("\n Section to Segment mapping:\n"));
5069 printf (_(" Segment Sections...\n"));
5070
252b5132
RH		 5071 for (i = 0; i < elf_header.e_phnum; i++)
5072 {
9ad5cbcf 5073 unsigned int j;
2cf0635d 5074 Elf_Internal_Shdr * section;
252b5132
RH		 5075
5076 segment = program_headers + i;
b391a3e3 5077 section = section_headers + 1;
252b5132
RH		 5078
5079 printf (" %2.2d ", i);
5080
b34976b6 5081 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 5082 {
f4638467
AM		 5083 if (!ELF_TBSS_SPECIAL (section, segment)
5084 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
74e1a04b 5085 printf ("%s ", printable_section_name (section));
252b5132
RH		 5086 }
5087
5088 putc ('\n',stdout);
5089 }
5090 }
5091
32ec8896 5092 return TRUE;
252b5132
RH		 5093}
5094
5095
d93f0186
NC		 5096/* Find the file offset corresponding to VMA by using the program headers. */
5097
5098static long
2cf0635d 5099offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 5100{
2cf0635d 5101 Elf_Internal_Phdr * seg;
d93f0186
NC		 5102
5103 if (! get_program_headers (file))
5104 {
5105 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5106 return (long) vma;
5107 }
5108
5109 for (seg = program_headers;
5110 seg < program_headers + elf_header.e_phnum;
5111 ++seg)
5112 {
5113 if (seg->p_type != PT_LOAD)
5114 continue;
5115
5116 if (vma >= (seg->p_vaddr & -seg->p_align)
5117 && vma + size <= seg->p_vaddr + seg->p_filesz)
5118 return vma - seg->p_vaddr + seg->p_offset;
5119 }
5120
5121 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 5122 (unsigned long) vma);
d93f0186
NC		 5123 return (long) vma;
5124}
5125
5126
049b0c3a
NC		 5127/* Allocate memory and load the sections headers into the global pointer
5128 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
5129 generate any error messages if the load fails. */
5130
5131static bfd_boolean
5132get_32bit_section_headers (FILE * file, bfd_boolean probe)
252b5132 5133{
2cf0635d
NC		 5134 Elf32_External_Shdr * shdrs;
5135 Elf_Internal_Shdr * internal;
b34976b6 5136 unsigned int i;
049b0c3a
NC		 5137 unsigned int size = elf_header.e_shentsize;
5138 unsigned int num = probe ? 1 : elf_header.e_shnum;
5139
5140 /* PR binutils/17531: Cope with unexpected section header sizes. */
5141 if (size == 0 || num == 0)
5142 return FALSE;
5143 if (size < sizeof * shdrs)
5144 {
5145 if (! probe)
5146 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5147 return FALSE;
5148 }
5149 if (!probe && size > sizeof * shdrs)
5150 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
252b5132 5151
3f5e193b 5152 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 5153 size, num,
5154 probe ? NULL : _("section headers"));
5155 if (shdrs == NULL)
5156 return FALSE;
252b5132 5157
049b0c3a
NC		 5158 if (section_headers != NULL)
5159 free (section_headers);
3f5e193b
NC		 5160 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
5161 sizeof (Elf_Internal_Shdr));
252b5132
RH		 5162 if (section_headers == NULL)
5163 {
049b0c3a 5164 if (!probe)
8b73c356 5165 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 5166 return FALSE;
252b5132
RH		 5167 }
5168
5169 for (i = 0, internal = section_headers;
560f3c1c 5170 i < num;
b34976b6 5171 i++, internal++)
252b5132
RH		 5172 {
5173 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5174 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5175 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5176 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5177 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5178 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5179 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5180 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5181 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5182 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
315350be
NC		 5183 if (!probe && internal->sh_link > num)
5184 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5185 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5186 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
252b5132
RH		 5187 }
5188
5189 free (shdrs);
049b0c3a 5190 return TRUE;
252b5132
RH		 5191}
5192
049b0c3a
NC		 5193static bfd_boolean
5194get_64bit_section_headers (FILE * file, bfd_boolean probe)
9ea033b2 5195{
2cf0635d
NC		 5196 Elf64_External_Shdr * shdrs;
5197 Elf_Internal_Shdr * internal;
b34976b6 5198 unsigned int i;
049b0c3a
NC		 5199 unsigned int size = elf_header.e_shentsize;
5200 unsigned int num = probe ? 1 : elf_header.e_shnum;
5201
5202 /* PR binutils/17531: Cope with unexpected section header sizes. */
5203 if (size == 0 || num == 0)
5204 return FALSE;
5205 if (size < sizeof * shdrs)
5206 {
5207 if (! probe)
5208 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5209 return FALSE;
5210 }
5211 if (! probe && size > sizeof * shdrs)
5212 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
9ea033b2 5213
3f5e193b 5214 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 5215 size, num,
5216 probe ? NULL : _("section headers"));
5217 if (shdrs == NULL)
5218 return FALSE;
9ea033b2 5219
049b0c3a
NC		 5220 if (section_headers != NULL)
5221 free (section_headers);
3f5e193b
NC		 5222 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
5223 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 5224 if (section_headers == NULL)
5225 {
049b0c3a 5226 if (! probe)
8b73c356 5227 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 5228 return FALSE;
9ea033b2
NC		 5229 }
5230
5231 for (i = 0, internal = section_headers;
560f3c1c 5232 i < num;
b34976b6 5233 i++, internal++)
9ea033b2
NC		 5234 {
5235 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5236 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 5237 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5238 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5239 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5240 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 5241 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5242 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5243 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5244 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
315350be
NC		 5245 if (!probe && internal->sh_link > num)
5246 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5247 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5248 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
9ea033b2
NC		 5249 }
5250
5251 free (shdrs);
049b0c3a 5252 return TRUE;
9ea033b2
NC		 5253}
5254
252b5132 5255static Elf_Internal_Sym *
ba5cdace
NC		 5256get_32bit_elf_symbols (FILE * file,
5257 Elf_Internal_Shdr * section,
5258 unsigned long * num_syms_return)
252b5132 5259{
ba5cdace 5260 unsigned long number = 0;
dd24e3da 5261 Elf32_External_Sym * esyms = NULL;
ba5cdace 5262 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 5263 Elf_Internal_Sym * isyms = NULL;
2cf0635d 5264 Elf_Internal_Sym * psym;
b34976b6 5265 unsigned int j;
252b5132 5266
c9c1d674
EG		 5267 if (section->sh_size == 0)
5268 {
5269 if (num_syms_return != NULL)
5270 * num_syms_return = 0;
5271 return NULL;
5272 }
5273
dd24e3da 5274 /* Run some sanity checks first. */
c9c1d674 5275 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 5276 {
c9c1d674
EG		 5277 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5278 printable_section_name (section), (unsigned long) section->sh_entsize);
ba5cdace 5279 goto exit_point;
dd24e3da
NC		 5280 }
5281
f54498b4
NC		 5282 if (section->sh_size > current_file_size)
5283 {
5284 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
74e1a04b 5285 printable_section_name (section), (unsigned long) section->sh_size);
f54498b4
NC		 5286 goto exit_point;
5287 }
5288
dd24e3da
NC		 5289 number = section->sh_size / section->sh_entsize;
5290
5291 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5292 {
c9c1d674 5293 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 5294 (unsigned long) section->sh_size,
5295 printable_section_name (section),
5296 (unsigned long) section->sh_entsize);
ba5cdace 5297 goto exit_point;
dd24e3da
NC		 5298 }
5299
3f5e193b
NC		 5300 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5301 section->sh_size, _("symbols"));
dd24e3da 5302 if (esyms == NULL)
ba5cdace 5303 goto exit_point;
252b5132 5304
6a40cf0c
NC		 5305 {
5306 elf_section_list * entry;
5307
5308 shndx = NULL;
5309 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5310 if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
c9c1d674 5311 {
6a40cf0c
NC		 5312 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5313 entry->hdr->sh_offset,
5314 1, entry->hdr->sh_size,
5315 _("symbol table section indicies"));
5316 if (shndx == NULL)
5317 goto exit_point;
5318 /* PR17531: file: heap-buffer-overflow */
5319 else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5320 {
5321 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5322 printable_section_name (entry->hdr),
5323 (unsigned long) entry->hdr->sh_size,
5324 (unsigned long) section->sh_size);
5325 goto exit_point;
5326 }
c9c1d674 5327 }
6a40cf0c 5328 }
9ad5cbcf 5329
3f5e193b 5330 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 5331
5332 if (isyms == NULL)
5333 {
8b73c356
NC		 5334 error (_("Out of memory reading %lu symbols\n"),
5335 (unsigned long) number);
dd24e3da 5336 goto exit_point;
252b5132
RH		 5337 }
5338
dd24e3da 5339 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 5340 {
5341 psym->st_name = BYTE_GET (esyms[j].st_name);
5342 psym->st_value = BYTE_GET (esyms[j].st_value);
5343 psym->st_size = BYTE_GET (esyms[j].st_size);
5344 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 5345 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5346 psym->st_shndx
5347 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5348 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5349 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 5350 psym->st_info = BYTE_GET (esyms[j].st_info);
5351 psym->st_other = BYTE_GET (esyms[j].st_other);
5352 }
5353
dd24e3da 5354 exit_point:
ba5cdace 5355 if (shndx != NULL)
9ad5cbcf 5356 free (shndx);
ba5cdace 5357 if (esyms != NULL)
dd24e3da 5358 free (esyms);
252b5132 5359
ba5cdace
NC		 5360 if (num_syms_return != NULL)
5361 * num_syms_return = isyms == NULL ? 0 : number;
5362
252b5132
RH		 5363 return isyms;
5364}
5365
9ea033b2 5366static Elf_Internal_Sym *
ba5cdace
NC		 5367get_64bit_elf_symbols (FILE * file,
5368 Elf_Internal_Shdr * section,
5369 unsigned long * num_syms_return)
9ea033b2 5370{
ba5cdace
NC		 5371 unsigned long number = 0;
5372 Elf64_External_Sym * esyms = NULL;
5373 Elf_External_Sym_Shndx * shndx = NULL;
5374 Elf_Internal_Sym * isyms = NULL;
2cf0635d 5375 Elf_Internal_Sym * psym;
b34976b6 5376 unsigned int j;
9ea033b2 5377
c9c1d674
EG		 5378 if (section->sh_size == 0)
5379 {
5380 if (num_syms_return != NULL)
5381 * num_syms_return = 0;
5382 return NULL;
5383 }
5384
dd24e3da 5385 /* Run some sanity checks first. */
c9c1d674 5386 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 5387 {
c9c1d674 5388 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
8066deb1
AM		 5389 printable_section_name (section),
5390 (unsigned long) section->sh_entsize);
ba5cdace 5391 goto exit_point;
dd24e3da
NC		 5392 }
5393
f54498b4
NC		 5394 if (section->sh_size > current_file_size)
5395 {
5396 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
8066deb1
AM		 5397 printable_section_name (section),
5398 (unsigned long) section->sh_size);
f54498b4
NC		 5399 goto exit_point;
5400 }
5401
dd24e3da
NC		 5402 number = section->sh_size / section->sh_entsize;
5403
5404 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5405 {
c9c1d674 5406 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 5407 (unsigned long) section->sh_size,
5408 printable_section_name (section),
5409 (unsigned long) section->sh_entsize);
ba5cdace 5410 goto exit_point;
dd24e3da
NC		 5411 }
5412
3f5e193b
NC		 5413 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5414 section->sh_size, _("symbols"));
a6e9f9df 5415 if (!esyms)
ba5cdace 5416 goto exit_point;
9ea033b2 5417
6a40cf0c
NC		 5418 {
5419 elf_section_list * entry;
5420
5421 shndx = NULL;
5422 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5423 if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
c9c1d674 5424 {
6a40cf0c
NC		 5425 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5426 entry->hdr->sh_offset,
5427 1, entry->hdr->sh_size,
5428 _("symbol table section indicies"));
5429 if (shndx == NULL)
5430 goto exit_point;
5431 /* PR17531: file: heap-buffer-overflow */
5432 else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5433 {
5434 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5435 printable_section_name (entry->hdr),
5436 (unsigned long) entry->hdr->sh_size,
5437 (unsigned long) section->sh_size);
5438 goto exit_point;
5439 }
c9c1d674 5440 }
6a40cf0c 5441 }
9ad5cbcf 5442
3f5e193b 5443 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 5444
5445 if (isyms == NULL)
5446 {
8b73c356
NC		 5447 error (_("Out of memory reading %lu symbols\n"),
5448 (unsigned long) number);
ba5cdace 5449 goto exit_point;
9ea033b2
NC		 5450 }
5451
ba5cdace 5452 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 5453 {
5454 psym->st_name = BYTE_GET (esyms[j].st_name);
5455 psym->st_info = BYTE_GET (esyms[j].st_info);
5456 psym->st_other = BYTE_GET (esyms[j].st_other);
5457 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 5458
4fbb74a6 5459 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5460 psym->st_shndx
5461 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5462 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5463 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 5464
66543521
AM		 5465 psym->st_value = BYTE_GET (esyms[j].st_value);
5466 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 5467 }
5468
ba5cdace
NC		 5469 exit_point:
5470 if (shndx != NULL)
9ad5cbcf 5471 free (shndx);
ba5cdace
NC		 5472 if (esyms != NULL)
5473 free (esyms);
5474
5475 if (num_syms_return != NULL)
5476 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 5477
5478 return isyms;
5479}
5480
d1133906 5481static const char *
d3ba0551 5482get_elf_section_flags (bfd_vma sh_flags)
d1133906 5483{
5477e8a0 5484 static char buff[1024];
2cf0635d 5485 char * p = buff;
32ec8896
NC		 5486 unsigned int field_size = is_32bit_elf ? 8 : 16;
5487 signed int sindex;
5488 unsigned int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 5489 bfd_vma os_flags = 0;
5490 bfd_vma proc_flags = 0;
5491 bfd_vma unknown_flags = 0;
148b93f2 5492 static const struct
5477e8a0 5493 {
2cf0635d 5494 const char * str;
32ec8896 5495 unsigned int len;
5477e8a0
L		 5496 }
5497 flags [] =
5498 {
cfcac11d
NC		 5499 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5500 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5501 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5502 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5503 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5504 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5505 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5506 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5507 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5508 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5509 /* IA-64 specific. */
5510 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5511 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5512 /* IA-64 OpenVMS specific. */
5513 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5514 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5515 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5516 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5517 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5518 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 5519 /* Generic. */
cfcac11d 5520 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 5521 /* SPARC specific. */
77115a4a 5522 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
ac4c9b04
MG		 5523 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5524 /* ARM specific. */
5525 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
f0728ee3 5526 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
ac4c9b04 5527 /* 23 */ { STRING_COMMA_LEN ("COMDEF") }
5477e8a0
L		 5528 };
5529
5530 if (do_section_details)
5531 {
8d5ff12c
L		 5532 sprintf (buff, "[%*.*lx]: ",
5533 field_size, field_size, (unsigned long) sh_flags);
5534 p += field_size + 4;
5477e8a0 5535 }
76da6bbe 5536
d1133906
NC		 5537 while (sh_flags)
5538 {
5539 bfd_vma flag;
5540
5541 flag = sh_flags & - sh_flags;
5542 sh_flags &= ~ flag;
76da6bbe 5543
5477e8a0 5544 if (do_section_details)
d1133906 5545 {
5477e8a0
L		 5546 switch (flag)
5547 {
91d6fa6a
NC		 5548 case SHF_WRITE: sindex = 0; break;
5549 case SHF_ALLOC: sindex = 1; break;
5550 case SHF_EXECINSTR: sindex = 2; break;
5551 case SHF_MERGE: sindex = 3; break;
5552 case SHF_STRINGS: sindex = 4; break;
5553 case SHF_INFO_LINK: sindex = 5; break;
5554 case SHF_LINK_ORDER: sindex = 6; break;
5555 case SHF_OS_NONCONFORMING: sindex = 7; break;
5556 case SHF_GROUP: sindex = 8; break;
5557 case SHF_TLS: sindex = 9; break;
18ae9cc1 5558 case SHF_EXCLUDE: sindex = 18; break;
77115a4a 5559 case SHF_COMPRESSED: sindex = 20; break;
76da6bbe 5560
5477e8a0 5561 default:
91d6fa6a 5562 sindex = -1;
cfcac11d 5563 switch (elf_header.e_machine)
148b93f2 5564 {
cfcac11d 5565 case EM_IA_64:
148b93f2 5566 if (flag == SHF_IA_64_SHORT)
91d6fa6a 5567 sindex = 10;
148b93f2 5568 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 5569 sindex = 11;
148b93f2
NC		 5570#ifdef BFD64
5571 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5572 switch (flag)
5573 {
91d6fa6a
NC		 5574 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5575 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5576 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5577 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5578 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5579 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 5580 default: break;
5581 }
5582#endif
cfcac11d
NC		 5583 break;
5584
caa83f8b 5585 case EM_386:
22abe556 5586 case EM_IAMCU:
caa83f8b 5587 case EM_X86_64:
7f502d6c 5588 case EM_L1OM:
7a9068fe 5589 case EM_K1OM:
cfcac11d
NC		 5590 case EM_OLD_SPARCV9:
5591 case EM_SPARC32PLUS:
5592 case EM_SPARCV9:
5593 case EM_SPARC:
18ae9cc1 5594 if (flag == SHF_ORDERED)
91d6fa6a 5595 sindex = 19;
cfcac11d 5596 break;
ac4c9b04
MG		 5597
5598 case EM_ARM:
5599 switch (flag)
5600 {
5601 case SHF_ENTRYSECT: sindex = 21; break;
f0728ee3 5602 case SHF_ARM_PURECODE: sindex = 22; break;
ac4c9b04
MG		 5603 case SHF_COMDEF: sindex = 23; break;
5604 default: break;
5605 }
5606 break;
5607
cfcac11d
NC		 5608 default:
5609 break;
148b93f2 5610 }
5477e8a0
L		 5611 }
5612
91d6fa6a 5613 if (sindex != -1)
5477e8a0 5614 {
8d5ff12c
L		 5615 if (p != buff + field_size + 4)
5616 {
5617 if (size < (10 + 2))
bee0ee85
NC		 5618 {
5619 warn (_("Internal error: not enough buffer room for section flag info"));
5620 return _("<unknown>");
5621 }
8d5ff12c
L		 5622 size -= 2;
5623 *p++ = ',';
5624 *p++ = ' ';
5625 }
5626
91d6fa6a
NC		 5627 size -= flags [sindex].len;
5628 p = stpcpy (p, flags [sindex].str);
5477e8a0 5629 }
3b22753a 5630 else if (flag & SHF_MASKOS)
8d5ff12c 5631 os_flags |= flag;
d1133906 5632 else if (flag & SHF_MASKPROC)
8d5ff12c 5633 proc_flags |= flag;
d1133906 5634 else
8d5ff12c 5635 unknown_flags |= flag;
5477e8a0
L		 5636 }
5637 else
5638 {
5639 switch (flag)
5640 {
5641 case SHF_WRITE: *p = 'W'; break;
5642 case SHF_ALLOC: *p = 'A'; break;
5643 case SHF_EXECINSTR: *p = 'X'; break;
5644 case SHF_MERGE: *p = 'M'; break;
5645 case SHF_STRINGS: *p = 'S'; break;
5646 case SHF_INFO_LINK: *p = 'I'; break;
5647 case SHF_LINK_ORDER: *p = 'L'; break;
5648 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5649 case SHF_GROUP: *p = 'G'; break;
5650 case SHF_TLS: *p = 'T'; break;
18ae9cc1 5651 case SHF_EXCLUDE: *p = 'E'; break;
77115a4a 5652 case SHF_COMPRESSED: *p = 'C'; break;
5477e8a0
L		 5653
5654 default:
8a9036a4 5655 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 5656 || elf_header.e_machine == EM_L1OM
5657 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 5658 && flag == SHF_X86_64_LARGE)
5659 *p = 'l';
91f68a68 5660 else if (elf_header.e_machine == EM_ARM
f0728ee3 5661 && flag == SHF_ARM_PURECODE)
91f68a68 5662 *p = 'y';
5477e8a0
L		 5663 else if (flag & SHF_MASKOS)
5664 {
5665 *p = 'o';
5666 sh_flags &= ~ SHF_MASKOS;
5667 }
5668 else if (flag & SHF_MASKPROC)
5669 {
5670 *p = 'p';
5671 sh_flags &= ~ SHF_MASKPROC;
5672 }
5673 else
5674 *p = 'x';
5675 break;
5676 }
5677 p++;
d1133906
NC		 5678 }
5679 }
76da6bbe 5680
8d5ff12c
L		 5681 if (do_section_details)
5682 {
5683 if (os_flags)
5684 {
5685 size -= 5 + field_size;
5686 if (p != buff + field_size + 4)
5687 {
5688 if (size < (2 + 1))
bee0ee85
NC		 5689 {
5690 warn (_("Internal error: not enough buffer room for section flag info"));
5691 return _("<unknown>");
5692 }
8d5ff12c
L		 5693 size -= 2;
5694 *p++ = ',';
5695 *p++ = ' ';
5696 }
5697 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5698 (unsigned long) os_flags);
5699 p += 5 + field_size;
5700 }
5701 if (proc_flags)
5702 {
5703 size -= 7 + field_size;
5704 if (p != buff + field_size + 4)
5705 {
5706 if (size < (2 + 1))
bee0ee85
NC		 5707 {
5708 warn (_("Internal error: not enough buffer room for section flag info"));
5709 return _("<unknown>");
5710 }
8d5ff12c
L		 5711 size -= 2;
5712 *p++ = ',';
5713 *p++ = ' ';
5714 }
5715 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5716 (unsigned long) proc_flags);
5717 p += 7 + field_size;
5718 }
5719 if (unknown_flags)
5720 {
5721 size -= 10 + field_size;
5722 if (p != buff + field_size + 4)
5723 {
5724 if (size < (2 + 1))
bee0ee85
NC		 5725 {
5726 warn (_("Internal error: not enough buffer room for section flag info"));
5727 return _("<unknown>");
5728 }
8d5ff12c
L		 5729 size -= 2;
5730 *p++ = ',';
5731 *p++ = ' ';
5732 }
2b692964 5733 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 5734 (unsigned long) unknown_flags);
5735 p += 10 + field_size;
5736 }
5737 }
5738
e9e44622 5739 *p = '\0';
d1133906
NC		 5740 return buff;
5741}
5742
77115a4a 5743static unsigned int
ebdf1ebf 5744get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
77115a4a
L		 5745{
5746 if (is_32bit_elf)
5747 {
5748 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
d8024a91 5749
ebdf1ebf
NC		 5750 if (size < sizeof (* echdr))
5751 {
5752 error (_("Compressed section is too small even for a compression header\n"));
5753 return 0;
5754 }
5755
77115a4a
L		 5756 chdr->ch_type = BYTE_GET (echdr->ch_type);
5757 chdr->ch_size = BYTE_GET (echdr->ch_size);
5758 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5759 return sizeof (*echdr);
5760 }
5761 else
5762 {
5763 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
d8024a91 5764
ebdf1ebf
NC		 5765 if (size < sizeof (* echdr))
5766 {
5767 error (_("Compressed section is too small even for a compression header\n"));
5768 return 0;
5769 }
5770
77115a4a
L		 5771 chdr->ch_type = BYTE_GET (echdr->ch_type);
5772 chdr->ch_size = BYTE_GET (echdr->ch_size);
5773 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5774 return sizeof (*echdr);
5775 }
5776}
5777
32ec8896 5778static bfd_boolean
2cf0635d 5779process_section_headers (FILE * file)
252b5132 5780{
2cf0635d 5781 Elf_Internal_Shdr * section;
b34976b6 5782 unsigned int i;
252b5132
RH		 5783
5784 section_headers = NULL;
5785
5786 if (elf_header.e_shnum == 0)
5787 {
82f2dbf7
NC		 5788 /* PR binutils/12467. */
5789 if (elf_header.e_shoff != 0)
32ec8896
NC		 5790 {
5791 warn (_("possibly corrupt ELF file header - it has a non-zero"
5792 " section header offset, but no section headers\n"));
5793 return FALSE;
5794 }
82f2dbf7 5795 else if (do_sections)
252b5132
RH		 5796 printf (_("\nThere are no sections in this file.\n"));
5797
32ec8896 5798 return TRUE;
252b5132
RH		 5799 }
5800
5801 if (do_sections && !do_header)
9ea033b2 5802 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 5803 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5804
9ea033b2
NC		 5805 if (is_32bit_elf)
5806 {
049b0c3a 5807 if (! get_32bit_section_headers (file, FALSE))
32ec8896
NC		 5808 return FALSE;
5809 }
5810 else
5811 {
5812 if (! get_64bit_section_headers (file, FALSE))
5813 return FALSE;
9ea033b2 5814 }
252b5132
RH		 5815
5816 /* Read in the string table, so that we have names to display. */
0b49d371 5817 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 5818 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 5819 {
4fbb74a6 5820 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 5821
c256ffe7
JJ		 5822 if (section->sh_size != 0)
5823 {
3f5e193b
NC		 5824 string_table = (char *) get_data (NULL, file, section->sh_offset,
5825 1, section->sh_size,
5826 _("string table"));
0de14b54 5827
c256ffe7
JJ		 5828 string_table_length = string_table != NULL ? section->sh_size : 0;
5829 }
252b5132
RH		 5830 }
5831
5832 /* Scan the sections for the dynamic symbol table
e3c8793a 5833 and dynamic string table and debug sections. */
252b5132
RH		 5834 dynamic_symbols = NULL;
5835 dynamic_strings = NULL;
5836 dynamic_syminfo = NULL;
6a40cf0c 5837 symtab_shndx_list = NULL;
103f02d3 5838
89fac5e3
RS		 5839 eh_addr_size = is_32bit_elf ? 4 : 8;
5840 switch (elf_header.e_machine)
5841 {
5842 case EM_MIPS:
5843 case EM_MIPS_RS3_LE:
5844 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5845 FDE addresses. However, the ABI also has a semi-official ILP32
5846 variant for which the normal FDE address size rules apply.
5847
5848 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5849 section, where XX is the size of longs in bits. Unfortunately,
5850 earlier compilers provided no way of distinguishing ILP32 objects
5851 from LP64 objects, so if there's any doubt, we should assume that
5852 the official LP64 form is being used. */
5853 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5854 && find_section (".gcc_compiled_long32") == NULL)
5855 eh_addr_size = 8;
5856 break;
0f56a26a
DD		 5857
5858 case EM_H8_300:
5859 case EM_H8_300H:
5860 switch (elf_header.e_flags & EF_H8_MACH)
5861 {
5862 case E_H8_MACH_H8300:
5863 case E_H8_MACH_H8300HN:
5864 case E_H8_MACH_H8300SN:
5865 case E_H8_MACH_H8300SXN:
5866 eh_addr_size = 2;
5867 break;
5868 case E_H8_MACH_H8300H:
5869 case E_H8_MACH_H8300S:
5870 case E_H8_MACH_H8300SX:
5871 eh_addr_size = 4;
5872 break;
5873 }
f4236fe4
DD		 5874 break;
5875
ff7eeb89 5876 case EM_M32C_OLD:
f4236fe4
DD		 5877 case EM_M32C:
5878 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5879 {
5880 case EF_M32C_CPU_M16C:
5881 eh_addr_size = 2;
5882 break;
5883 }
5884 break;
89fac5e3
RS		 5885 }
5886
76ca31c0
NC		 5887#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5888 do \
5889 { \
5890 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5891 if (section->sh_entsize != expected_entsize) \
9dd3a467 5892 { \
76ca31c0
NC		 5893 char buf[40]; \
5894 sprintf_vma (buf, section->sh_entsize); \
5895 /* Note: coded this way so that there is a single string for \
5896 translation. */ \
5897 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5898 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5899 (unsigned) expected_entsize); \
9dd3a467 5900 section->sh_entsize = expected_entsize; \
76ca31c0
NC		 5901 } \
5902 } \
08d8fa11 5903 while (0)
9dd3a467
NC		 5904
5905#define CHECK_ENTSIZE(section, i, type) \
08d8fa11
JJ		 5906 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5907 sizeof (Elf64_External_##type))
5908
252b5132
RH		 5909 for (i = 0, section = section_headers;
5910 i < elf_header.e_shnum;
b34976b6 5911 i++, section++)
252b5132 5912 {
2cf0635d 5913 char * name = SECTION_NAME (section);
252b5132
RH		 5914
5915 if (section->sh_type == SHT_DYNSYM)
5916 {
5917 if (dynamic_symbols != NULL)
5918 {
5919 error (_("File contains multiple dynamic symbol tables\n"));
5920 continue;
5921 }
5922
08d8fa11 5923 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 5924 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 5925 }
5926 else if (section->sh_type == SHT_STRTAB
18bd398b 5927 && streq (name, ".dynstr"))
252b5132
RH		 5928 {
5929 if (dynamic_strings != NULL)
5930 {
5931 error (_("File contains multiple dynamic string tables\n"));
5932 continue;
5933 }
5934
3f5e193b
NC		 5935 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5936 1, section->sh_size,
5937 _("dynamic strings"));
59245841 5938 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 5939 }
9ad5cbcf
AM		 5940 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5941 {
6a40cf0c
NC		 5942 elf_section_list * entry = xmalloc (sizeof * entry);
5943 entry->hdr = section;
5944 entry->next = symtab_shndx_list;
5945 symtab_shndx_list = entry;
9ad5cbcf 5946 }
08d8fa11
JJ		 5947 else if (section->sh_type == SHT_SYMTAB)
5948 CHECK_ENTSIZE (section, i, Sym);
5949 else if (section->sh_type == SHT_GROUP)
5950 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5951 else if (section->sh_type == SHT_REL)
5952 CHECK_ENTSIZE (section, i, Rel);
5953 else if (section->sh_type == SHT_RELA)
5954 CHECK_ENTSIZE (section, i, Rela);
252b5132 5955 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 5956 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 5957 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC		 5958 || do_debug_str || do_debug_loc || do_debug_ranges
5959 || do_debug_addr || do_debug_cu_index)
1b315056
CS		 5960 && (const_strneq (name, ".debug_")
5961 || const_strneq (name, ".zdebug_")))
252b5132 5962 {
1b315056
CS		 5963 if (name[1] == 'z')
5964 name += sizeof (".zdebug_") - 1;
5965 else
5966 name += sizeof (".debug_") - 1;
252b5132
RH		 5967
5968 if (do_debugging
4723351a
CC		 5969 || (do_debug_info && const_strneq (name, "info"))
5970 || (do_debug_info && const_strneq (name, "types"))
5971 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
b40bf0a2
NC		 5972 || (do_debug_lines && strcmp (name, "line") == 0)
5973 || (do_debug_lines && const_strneq (name, "line."))
4723351a
CC		 5974 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5975 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
459d52c8
DE		 5976 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5977 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
4723351a
CC		 5978 || (do_debug_aranges && const_strneq (name, "aranges"))
5979 || (do_debug_ranges && const_strneq (name, "ranges"))
77145576 5980 || (do_debug_ranges && const_strneq (name, "rnglists"))
4723351a
CC		 5981 || (do_debug_frames && const_strneq (name, "frame"))
5982 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5983 || (do_debug_macinfo && const_strneq (name, "macro"))
5984 || (do_debug_str && const_strneq (name, "str"))
5985 || (do_debug_loc && const_strneq (name, "loc"))
77145576 5986 || (do_debug_loc && const_strneq (name, "loclists"))
657d0d47
CC		 5987 || (do_debug_addr && const_strneq (name, "addr"))
5988 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5989 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 5990 )
09c11c86 5991 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 5992 }
a262ae96 5993 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 5994 else if ((do_debugging || do_debug_info)
0112cd26 5995 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 5996 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 5997 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 5998 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 5999 else if (do_gdb_index && streq (name, ".gdb_index"))
6000 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 6001 /* Trace sections for Itanium VMS. */
6002 else if ((do_debugging || do_trace_info || do_trace_abbrevs
6003 || do_trace_aranges)
6004 && const_strneq (name, ".trace_"))
6005 {
6006 name += sizeof (".trace_") - 1;
6007
6008 if (do_debugging
6009 || (do_trace_info && streq (name, "info"))
6010 || (do_trace_abbrevs && streq (name, "abbrev"))
6011 || (do_trace_aranges && streq (name, "aranges"))
6012 )
6013 request_dump_bynumber (i, DEBUG_DUMP);
6014 }
252b5132
RH		 6015 }
6016
6017 if (! do_sections)
32ec8896 6018 return TRUE;
252b5132 6019
3a1a2036
NC		 6020 if (elf_header.e_shnum > 1)
6021 printf (_("\nSection Headers:\n"));
6022 else
6023 printf (_("\nSection Header:\n"));
76da6bbe 6024
f7a99963 6025 if (is_32bit_elf)
595cf52e 6026 {
5477e8a0 6027 if (do_section_details)
595cf52e
L		 6028 {
6029 printf (_(" [Nr] Name\n"));
5477e8a0 6030 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 6031 }
6032 else
6033 printf
6034 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6035 }
d974e256 6036 else if (do_wide)
595cf52e 6037 {
5477e8a0 6038 if (do_section_details)
595cf52e
L		 6039 {
6040 printf (_(" [Nr] Name\n"));
5477e8a0 6041 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 6042 }
6043 else
6044 printf
6045 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6046 }
f7a99963
NC		 6047 else
6048 {
5477e8a0 6049 if (do_section_details)
595cf52e
L		 6050 {
6051 printf (_(" [Nr] Name\n"));
5477e8a0
L		 6052 printf (_(" Type Address Offset Link\n"));
6053 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 6054 }
6055 else
6056 {
6057 printf (_(" [Nr] Name Type Address Offset\n"));
6058 printf (_(" Size EntSize Flags Link Info Align\n"));
6059 }
f7a99963 6060 }
252b5132 6061
5477e8a0
L		 6062 if (do_section_details)
6063 printf (_(" Flags\n"));
6064
252b5132
RH		 6065 for (i = 0, section = section_headers;
6066 i < elf_header.e_shnum;
b34976b6 6067 i++, section++)
252b5132 6068 {
dd905818
NC		 6069 /* Run some sanity checks on the section header. */
6070
6071 /* Check the sh_link field. */
6072 switch (section->sh_type)
6073 {
6074 case SHT_SYMTAB_SHNDX:
6075 case SHT_GROUP:
6076 case SHT_HASH:
6077 case SHT_GNU_HASH:
6078 case SHT_GNU_versym:
6079 case SHT_REL:
6080 case SHT_RELA:
6081 if (section->sh_link < 1
cb64e50d 6082 || section->sh_link >= elf_header.e_shnum
dd905818
NC		 6083 || (section_headers[section->sh_link].sh_type != SHT_SYMTAB
6084 && section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6085 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6086 i, section->sh_link);
6087 break;
6088
6089 case SHT_DYNAMIC:
6090 case SHT_SYMTAB:
6091 case SHT_DYNSYM:
6092 case SHT_GNU_verneed:
6093 case SHT_GNU_verdef:
6094 case SHT_GNU_LIBLIST:
6095 if (section->sh_link < 1
cb64e50d 6096 || section->sh_link >= elf_header.e_shnum
dd905818
NC		 6097 || section_headers[section->sh_link].sh_type != SHT_STRTAB)
6098 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6099 i, section->sh_link);
6100 break;
6101
6102 case SHT_INIT_ARRAY:
6103 case SHT_FINI_ARRAY:
6104 case SHT_PREINIT_ARRAY:
6105 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6106 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6107 i, section->sh_link);
6108 break;
6109
6110 default:
6111 /* FIXME: Add support for target specific section types. */
6112#if 0 /* Currently we do not check other section types as there are too
6113 many special cases. Stab sections for example have a type
6114 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6115 section. */
6116 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6117 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6118 i, section->sh_link);
6119#endif
6120 break;
6121 }
6122
6123 /* Check the sh_info field. */
6124 switch (section->sh_type)
6125 {
6126 case SHT_REL:
6127 case SHT_RELA:
6128 if (section->sh_info < 1
cb64e50d 6129 || section->sh_info >= elf_header.e_shnum
dd905818
NC		 6130 || (section_headers[section->sh_info].sh_type != SHT_PROGBITS
6131 && section_headers[section->sh_info].sh_type != SHT_NOBITS
6132 && section_headers[section->sh_info].sh_type != SHT_NOTE
6133 && section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6134 /* FIXME: Are other section types valid ? */
6135 && section_headers[section->sh_info].sh_type < SHT_LOOS))
6136 {
6137 if (section->sh_info == 0
6138 && (streq (SECTION_NAME (section), ".rel.dyn")
6139 || streq (SECTION_NAME (section), ".rela.dyn")))
6140 /* The .rel.dyn and .rela.dyn sections have an sh_info field
4d74727a
AM		 6141 of zero. The relocations in these sections may apply
6142 to many different sections. */
dd905818
NC		 6143 ;
6144 else
6145 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6146 i, section->sh_info);
6147 }
6148 break;
6149
6150 case SHT_DYNAMIC:
6151 case SHT_HASH:
6152 case SHT_SYMTAB_SHNDX:
6153 case SHT_INIT_ARRAY:
6154 case SHT_FINI_ARRAY:
6155 case SHT_PREINIT_ARRAY:
6156 if (section->sh_info != 0)
6157 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6158 i, section->sh_info);
6159 break;
6160
6161 case SHT_GROUP:
6162 case SHT_SYMTAB:
6163 case SHT_DYNSYM:
6164 /* A symbol index - we assume that it is valid. */
6165 break;
6166
6167 default:
6168 /* FIXME: Add support for target specific section types. */
6169 if (section->sh_type == SHT_NOBITS)
6170 /* NOBITS section headers with non-zero sh_info fields can be
6171 created when a binary is stripped of everything but its debug
1a9ccd70
NC		 6172 information. The stripped sections have their headers
6173 preserved but their types set to SHT_NOBITS. So do not check
6174 this type of section. */
dd905818
NC		 6175 ;
6176 else if (section->sh_flags & SHF_INFO_LINK)
6177 {
cb64e50d 6178 if (section->sh_info < 1 || section->sh_info >= elf_header.e_shnum)
dd905818
NC		 6179 warn (_("[%2u]: Expected link to another section in info field"), i);
6180 }
6181 else if (section->sh_type < SHT_LOOS && section->sh_info != 0)
6182 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6183 i, section->sh_info);
6184 break;
6185 }
6186
7bfd842d 6187 printf (" [%2u] ", i);
5477e8a0 6188 if (do_section_details)
74e1a04b 6189 printf ("%s\n ", printable_section_name (section));
595cf52e 6190 else
74e1a04b 6191 print_symbol (-17, SECTION_NAME (section));
0b4362b0 6192
ea52a088
NC		 6193 printf (do_wide ? " %-15s " : " %-15.15s ",
6194 get_section_type_name (section->sh_type));
0b4362b0 6195
f7a99963
NC		 6196 if (is_32bit_elf)
6197 {
cfcac11d
NC		 6198 const char * link_too_big = NULL;
6199
f7a99963 6200 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 6201
f7a99963
NC		 6202 printf ( " %6.6lx %6.6lx %2.2lx",
6203 (unsigned long) section->sh_offset,
6204 (unsigned long) section->sh_size,
6205 (unsigned long) section->sh_entsize);
d1133906 6206
5477e8a0
L		 6207 if (do_section_details)
6208 fputs (" ", stdout);
6209 else
6210 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 6211
cfcac11d
NC		 6212 if (section->sh_link >= elf_header.e_shnum)
6213 {
6214 link_too_big = "";
6215 /* The sh_link value is out of range. Normally this indicates
caa83f8b 6216 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 6217 switch (elf_header.e_machine)
6218 {
caa83f8b 6219 case EM_386:
22abe556 6220 case EM_IAMCU:
caa83f8b 6221 case EM_X86_64:
7f502d6c 6222 case EM_L1OM:
7a9068fe 6223 case EM_K1OM:
cfcac11d
NC		 6224 case EM_OLD_SPARCV9:
6225 case EM_SPARC32PLUS:
6226 case EM_SPARCV9:
6227 case EM_SPARC:
6228 if (section->sh_link == (SHN_BEFORE & 0xffff))
6229 link_too_big = "BEFORE";
6230 else if (section->sh_link == (SHN_AFTER & 0xffff))
6231 link_too_big = "AFTER";
6232 break;
6233 default:
6234 break;
6235 }
6236 }
6237
6238 if (do_section_details)
6239 {
6240 if (link_too_big != NULL && * link_too_big)
6241 printf ("<%s> ", link_too_big);
6242 else
6243 printf ("%2u ", section->sh_link);
6244 printf ("%3u %2lu\n", section->sh_info,
6245 (unsigned long) section->sh_addralign);
6246 }
6247 else
6248 printf ("%2u %3u %2lu\n",
6249 section->sh_link,
6250 section->sh_info,
6251 (unsigned long) section->sh_addralign);
6252
6253 if (link_too_big && ! * link_too_big)
6254 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6255 i, section->sh_link);
f7a99963 6256 }
d974e256
JJ		 6257 else if (do_wide)
6258 {
6259 print_vma (section->sh_addr, LONG_HEX);
6260
6261 if ((long) section->sh_offset == section->sh_offset)
6262 printf (" %6.6lx", (unsigned long) section->sh_offset);
6263 else
6264 {
6265 putchar (' ');
6266 print_vma (section->sh_offset, LONG_HEX);
6267 }
6268
6269 if ((unsigned long) section->sh_size == section->sh_size)
6270 printf (" %6.6lx", (unsigned long) section->sh_size);
6271 else
6272 {
6273 putchar (' ');
6274 print_vma (section->sh_size, LONG_HEX);
6275 }
6276
6277 if ((unsigned long) section->sh_entsize == section->sh_entsize)
6278 printf (" %2.2lx", (unsigned long) section->sh_entsize);
6279 else
6280 {
6281 putchar (' ');
6282 print_vma (section->sh_entsize, LONG_HEX);
6283 }
6284
5477e8a0
L		 6285 if (do_section_details)
6286 fputs (" ", stdout);
6287 else
6288 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 6289
72de5009 6290 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 6291
6292 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 6293 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 6294 else
6295 {
6296 print_vma (section->sh_addralign, DEC);
6297 putchar ('\n');
6298 }
6299 }
5477e8a0 6300 else if (do_section_details)
595cf52e 6301 {
5477e8a0 6302 printf (" %-15.15s ",
595cf52e 6303 get_section_type_name (section->sh_type));
595cf52e
L		 6304 print_vma (section->sh_addr, LONG_HEX);
6305 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 6306 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 6307 else
6308 {
6309 printf (" ");
6310 print_vma (section->sh_offset, LONG_HEX);
6311 }
72de5009 6312 printf (" %u\n ", section->sh_link);
595cf52e 6313 print_vma (section->sh_size, LONG_HEX);
5477e8a0 6314 putchar (' ');
595cf52e
L		 6315 print_vma (section->sh_entsize, LONG_HEX);
6316
72de5009
AM		 6317 printf (" %-16u %lu\n",
6318 section->sh_info,
595cf52e
L		 6319 (unsigned long) section->sh_addralign);
6320 }
f7a99963
NC		 6321 else
6322 {
6323 putchar (' ');
6324 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 6325 if ((long) section->sh_offset == section->sh_offset)
6326 printf (" %8.8lx", (unsigned long) section->sh_offset);
6327 else
6328 {
6329 printf (" ");
6330 print_vma (section->sh_offset, LONG_HEX);
6331 }
f7a99963
NC		 6332 printf ("\n ");
6333 print_vma (section->sh_size, LONG_HEX);
6334 printf (" ");
6335 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 6336
d1133906 6337 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 6338
72de5009
AM		 6339 printf (" %2u %3u %lu\n",
6340 section->sh_link,
6341 section->sh_info,
f7a99963
NC		 6342 (unsigned long) section->sh_addralign);
6343 }
5477e8a0
L		 6344
6345 if (do_section_details)
77115a4a
L		 6346 {
6347 printf (" %s\n", get_elf_section_flags (section->sh_flags));
6348 if ((section->sh_flags & SHF_COMPRESSED) != 0)
6349 {
6350 /* Minimum section size is 12 bytes for 32-bit compression
6351 header + 12 bytes for compressed data header. */
6352 unsigned char buf[24];
d8024a91 6353
77115a4a
L		 6354 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6355 if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
6356 sizeof (buf), _("compression header")))
6357 {
6358 Elf_Internal_Chdr chdr;
d8024a91 6359
ebdf1ebf 6360 (void) get_compression_header (&chdr, buf, sizeof (buf));
d8024a91 6361
77115a4a
L		 6362 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6363 printf (" ZLIB, ");
6364 else
6365 printf (_(" [<unknown>: 0x%x], "),
6366 chdr.ch_type);
6367 print_vma (chdr.ch_size, LONG_HEX);
6368 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6369 }
6370 }
6371 }
252b5132
RH		 6372 }
6373
5477e8a0 6374 if (!do_section_details)
3dbcc61d 6375 {
9fb71ee4
NC		 6376 /* The ordering of the letters shown here matches the ordering of the
6377 corresponding SHF_xxx values, and hence the order in which these
6378 letters will be displayed to the user. */
6379 printf (_("Key to Flags:\n\
6380 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6381 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
fd85a6a1 6382 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
3dbcc61d 6383 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 6384 || elf_header.e_machine == EM_L1OM
6385 || elf_header.e_machine == EM_K1OM)
9fb71ee4 6386 printf (_("l (large), "));
91f68a68 6387 else if (elf_header.e_machine == EM_ARM)
f0728ee3 6388 printf (_("y (purecode), "));
9fb71ee4 6389 printf ("p (processor specific)\n");
0b4362b0 6390 }
d1133906 6391
32ec8896 6392 return TRUE;
252b5132
RH		 6393}
6394
f5842774
L		 6395static const char *
6396get_group_flags (unsigned int flags)
6397{
1449284b 6398 static char buff[128];
220453ec 6399
6d913794
NC		 6400 if (flags == 0)
6401 return "";
6402 else if (flags == GRP_COMDAT)
6403 return "COMDAT ";
f5842774 6404
6d913794
NC		 6405 snprintf (buff, 14, _("[0x%x: "), flags);
6406
6407 flags &= ~ GRP_COMDAT;
6408 if (flags & GRP_MASKOS)
6409 {
6410 strcat (buff, "<OS specific>");
6411 flags &= ~ GRP_MASKOS;
f5842774 6412 }
6d913794
NC		 6413
6414 if (flags & GRP_MASKPROC)
6415 {
6416 strcat (buff, "<PROC specific>");
6417 flags &= ~ GRP_MASKPROC;
6418 }
6419
6420 if (flags)
6421 strcat (buff, "<unknown>");
6422
6423 strcat (buff, "]");
f5842774
L		 6424 return buff;
6425}
6426
32ec8896 6427static bfd_boolean
2cf0635d 6428process_section_groups (FILE * file)
f5842774 6429{
2cf0635d 6430 Elf_Internal_Shdr * section;
f5842774 6431 unsigned int i;
2cf0635d
NC		 6432 struct group * group;
6433 Elf_Internal_Shdr * symtab_sec;
6434 Elf_Internal_Shdr * strtab_sec;
6435 Elf_Internal_Sym * symtab;
ba5cdace 6436 unsigned long num_syms;
2cf0635d 6437 char * strtab;
c256ffe7 6438 size_t strtab_size;
d1f5c6e3
L		 6439
6440 /* Don't process section groups unless needed. */
6441 if (!do_unwind && !do_section_groups)
32ec8896 6442 return TRUE;
f5842774
L		 6443
6444 if (elf_header.e_shnum == 0)
6445 {
6446 if (do_section_groups)
82f2dbf7 6447 printf (_("\nThere are no sections to group in this file.\n"));
f5842774 6448
32ec8896 6449 return TRUE;
f5842774
L		 6450 }
6451
6452 if (section_headers == NULL)
6453 {
6454 error (_("Section headers are not available!\n"));
fa1908fd 6455 /* PR 13622: This can happen with a corrupt ELF header. */
32ec8896 6456 return FALSE;
f5842774
L		 6457 }
6458
3f5e193b
NC		 6459 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
6460 sizeof (struct group *));
e4b17d5c
L		 6461
6462 if (section_headers_groups == NULL)
6463 {
8b73c356
NC		 6464 error (_("Out of memory reading %u section group headers\n"),
6465 elf_header.e_shnum);
32ec8896 6466 return FALSE;
e4b17d5c
L		 6467 }
6468
f5842774 6469 /* Scan the sections for the group section. */
d1f5c6e3 6470 group_count = 0;
f5842774
L		 6471 for (i = 0, section = section_headers;
6472 i < elf_header.e_shnum;
6473 i++, section++)
e4b17d5c
L		 6474 if (section->sh_type == SHT_GROUP)
6475 group_count++;
6476
d1f5c6e3
L		 6477 if (group_count == 0)
6478 {
6479 if (do_section_groups)
6480 printf (_("\nThere are no section groups in this file.\n"));
6481
32ec8896 6482 return TRUE;
d1f5c6e3
L		 6483 }
6484
3f5e193b 6485 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 6486
6487 if (section_groups == NULL)
6488 {
8b73c356
NC		 6489 error (_("Out of memory reading %lu groups\n"),
6490 (unsigned long) group_count);
32ec8896 6491 return FALSE;
e4b17d5c
L		 6492 }
6493
d1f5c6e3
L		 6494 symtab_sec = NULL;
6495 strtab_sec = NULL;
6496 symtab = NULL;
ba5cdace 6497 num_syms = 0;
d1f5c6e3 6498 strtab = NULL;
c256ffe7 6499 strtab_size = 0;
e4b17d5c
L		 6500 for (i = 0, section = section_headers, group = section_groups;
6501 i < elf_header.e_shnum;
6502 i++, section++)
f5842774
L		 6503 {
6504 if (section->sh_type == SHT_GROUP)
6505 {
74e1a04b
NC		 6506 const char * name = printable_section_name (section);
6507 const char * group_name;
2cf0635d
NC		 6508 unsigned char * start;
6509 unsigned char * indices;
f5842774 6510 unsigned int entry, j, size;
2cf0635d
NC		 6511 Elf_Internal_Shdr * sec;
6512 Elf_Internal_Sym * sym;
f5842774
L		 6513
6514 /* Get the symbol table. */
4fbb74a6
AM		 6515 if (section->sh_link >= elf_header.e_shnum
6516 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 6517 != SHT_SYMTAB))
f5842774
L		 6518 {
6519 error (_("Bad sh_link in group section `%s'\n"), name);
6520 continue;
6521 }
d1f5c6e3
L		 6522
6523 if (symtab_sec != sec)
6524 {
6525 symtab_sec = sec;
6526 if (symtab)
6527 free (symtab);
ba5cdace 6528 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 6529 }
f5842774 6530
dd24e3da
NC		 6531 if (symtab == NULL)
6532 {
6533 error (_("Corrupt header in group section `%s'\n"), name);
6534 continue;
6535 }
6536
ba5cdace
NC		 6537 if (section->sh_info >= num_syms)
6538 {
6539 error (_("Bad sh_info in group section `%s'\n"), name);
6540 continue;
6541 }
6542
f5842774
L		 6543 sym = symtab + section->sh_info;
6544
6545 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6546 {
4fbb74a6
AM		 6547 if (sym->st_shndx == 0
6548 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 6549 {
6550 error (_("Bad sh_info in group section `%s'\n"), name);
6551 continue;
6552 }
ba2685cc 6553
4fbb74a6 6554 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 6555 strtab_sec = NULL;
6556 if (strtab)
6557 free (strtab);
f5842774 6558 strtab = NULL;
c256ffe7 6559 strtab_size = 0;
f5842774
L		 6560 }
6561 else
6562 {
6563 /* Get the string table. */
4fbb74a6 6564 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 6565 {
6566 strtab_sec = NULL;
6567 if (strtab)
6568 free (strtab);
6569 strtab = NULL;
6570 strtab_size = 0;
6571 }
6572 else if (strtab_sec
4fbb74a6 6573 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 6574 {
6575 strtab_sec = sec;
6576 if (strtab)
6577 free (strtab);
071436c6 6578
3f5e193b 6579 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
071436c6
NC		 6580 1, strtab_sec->sh_size,
6581 _("string table"));
c256ffe7 6582 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 6583 }
c256ffe7 6584 group_name = sym->st_name < strtab_size
2b692964 6585 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 6586 }
6587
c9c1d674
EG		 6588 /* PR 17531: file: loop. */
6589 if (section->sh_entsize > section->sh_size)
6590 {
6591 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6592 printable_section_name (section),
8066deb1
AM		 6593 (unsigned long) section->sh_entsize,
6594 (unsigned long) section->sh_size);
c9c1d674
EG		 6595 break;
6596 }
6597
3f5e193b
NC		 6598 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6599 1, section->sh_size,
6600 _("section data"));
59245841
NC		 6601 if (start == NULL)
6602 continue;
f5842774
L		 6603
6604 indices = start;
6605 size = (section->sh_size / section->sh_entsize) - 1;
6606 entry = byte_get (indices, 4);
6607 indices += 4;
e4b17d5c
L		 6608
6609 if (do_section_groups)
6610 {
2b692964 6611 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 6612 get_group_flags (entry), i, name, group_name, size);
ba2685cc 6613
e4b17d5c
L		 6614 printf (_(" [Index] Name\n"));
6615 }
6616
6617 group->group_index = i;
6618
f5842774
L		 6619 for (j = 0; j < size; j++)
6620 {
2cf0635d 6621 struct group_list * g;
e4b17d5c 6622
f5842774
L		 6623 entry = byte_get (indices, 4);
6624 indices += 4;
6625
4fbb74a6 6626 if (entry >= elf_header.e_shnum)
391cb864 6627 {
57028622
NC		 6628 static unsigned num_group_errors = 0;
6629
6630 if (num_group_errors ++ < 10)
6631 {
6632 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6633 entry, i, elf_header.e_shnum - 1);
6634 if (num_group_errors == 10)
6635 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6636 }
391cb864
L		 6637 continue;
6638 }
391cb864 6639
4fbb74a6 6640 if (section_headers_groups [entry] != NULL)
e4b17d5c 6641 {
d1f5c6e3
L		 6642 if (entry)
6643 {
57028622
NC		 6644 static unsigned num_errs = 0;
6645
6646 if (num_errs ++ < 10)
6647 {
6648 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6649 entry, i,
6650 section_headers_groups [entry]->group_index);
6651 if (num_errs == 10)
6652 warn (_("Further error messages about already contained group sections suppressed\n"));
6653 }
d1f5c6e3
L		 6654 continue;
6655 }
6656 else
6657 {
6658 /* Intel C/C++ compiler may put section 0 in a
32ec8896 6659 section group. We just warn it the first time
d1f5c6e3 6660 and ignore it afterwards. */
32ec8896 6661 static bfd_boolean warned = FALSE;
d1f5c6e3
L		 6662 if (!warned)
6663 {
6664 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 6665 section_headers_groups [entry]->group_index);
32ec8896 6666 warned = TRUE;
d1f5c6e3
L		 6667 }
6668 }
e4b17d5c
L		 6669 }
6670
4fbb74a6 6671 section_headers_groups [entry] = group;
e4b17d5c
L		 6672
6673 if (do_section_groups)
6674 {
4fbb74a6 6675 sec = section_headers + entry;
74e1a04b 6676 printf (" [%5u] %s\n", entry, printable_section_name (sec));
ba2685cc
AM		 6677 }
6678
3f5e193b 6679 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 6680 g->section_index = entry;
6681 g->next = group->root;
6682 group->root = g;
f5842774
L		 6683 }
6684
f5842774
L		 6685 if (start)
6686 free (start);
e4b17d5c
L		 6687
6688 group++;
f5842774
L		 6689 }
6690 }
6691
d1f5c6e3
L		 6692 if (symtab)
6693 free (symtab);
6694 if (strtab)
6695 free (strtab);
32ec8896 6696 return TRUE;
f5842774
L		 6697}
6698
28f997cf
TG		 6699/* Data used to display dynamic fixups. */
6700
6701struct ia64_vms_dynfixup
6702{
6703 bfd_vma needed_ident; /* Library ident number. */
6704 bfd_vma needed; /* Index in the dstrtab of the library name. */
6705 bfd_vma fixup_needed; /* Index of the library. */
6706 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6707 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6708};
6709
6710/* Data used to display dynamic relocations. */
6711
6712struct ia64_vms_dynimgrela
6713{
6714 bfd_vma img_rela_cnt; /* Number of relocations. */
6715 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6716};
6717
6718/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6719 library). */
6720
32ec8896
NC		 6721static bfd_boolean
6722dump_ia64_vms_dynamic_fixups (FILE * file,
6723 struct ia64_vms_dynfixup * fixup,
6724 const char * strtab,
6725 unsigned int strtab_sz)
28f997cf 6726{
32ec8896 6727 Elf64_External_VMS_IMAGE_FIXUP * imfs;
28f997cf 6728 long i;
32ec8896 6729 const char * lib_name;
28f997cf
TG		 6730
6731 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6732 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6733 _("dynamic section image fixups"));
6734 if (!imfs)
32ec8896 6735 return FALSE;
28f997cf
TG		 6736
6737 if (fixup->needed < strtab_sz)
6738 lib_name = strtab + fixup->needed;
6739 else
6740 {
32ec8896 6741 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7f01b0c6 6742 (unsigned long) fixup->needed);
28f997cf
TG		 6743 lib_name = "???";
6744 }
6745 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6746 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6747 printf
6748 (_("Seg Offset Type SymVec DataType\n"));
6749
6750 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6751 {
6752 unsigned int type;
6753 const char *rtype;
6754
6755 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6756 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6757 type = BYTE_GET (imfs [i].type);
6758 rtype = elf_ia64_reloc_type (type);
6759 if (rtype == NULL)
6760 printf (" 0x%08x ", type);
6761 else
6762 printf (" %-32s ", rtype);
6763 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6764 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6765 }
6766
6767 free (imfs);
32ec8896 6768 return TRUE;
28f997cf
TG		 6769}
6770
6771/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6772
32ec8896 6773static bfd_boolean
28f997cf
TG		 6774dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6775{
6776 Elf64_External_VMS_IMAGE_RELA *imrs;
6777 long i;
6778
6779 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6780 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 6781 _("dynamic section image relocations"));
28f997cf 6782 if (!imrs)
32ec8896 6783 return FALSE;
28f997cf
TG		 6784
6785 printf (_("\nImage relocs\n"));
6786 printf
6787 (_("Seg Offset Type Addend Seg Sym Off\n"));
6788
6789 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6790 {
6791 unsigned int type;
6792 const char *rtype;
6793
6794 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6795 printf ("%08" BFD_VMA_FMT "x ",
6796 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6797 type = BYTE_GET (imrs [i].type);
6798 rtype = elf_ia64_reloc_type (type);
6799 if (rtype == NULL)
6800 printf ("0x%08x ", type);
6801 else
6802 printf ("%-31s ", rtype);
6803 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6804 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6805 printf ("%08" BFD_VMA_FMT "x\n",
6806 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6807 }
6808
6809 free (imrs);
32ec8896 6810 return TRUE;
28f997cf
TG		 6811}
6812
6813/* Display IA-64 OpenVMS dynamic relocations and fixups. */
6814
32ec8896 6815static bfd_boolean
28f997cf
TG		 6816process_ia64_vms_dynamic_relocs (FILE *file)
6817{
6818 struct ia64_vms_dynfixup fixup;
6819 struct ia64_vms_dynimgrela imgrela;
6820 Elf_Internal_Dyn *entry;
28f997cf
TG		 6821 bfd_vma strtab_off = 0;
6822 bfd_vma strtab_sz = 0;
6823 char *strtab = NULL;
32ec8896 6824 bfd_boolean res = TRUE;
28f997cf
TG		 6825
6826 memset (&fixup, 0, sizeof (fixup));
6827 memset (&imgrela, 0, sizeof (imgrela));
6828
6829 /* Note: the order of the entries is specified by the OpenVMS specs. */
6830 for (entry = dynamic_section;
6831 entry < dynamic_section + dynamic_nent;
6832 entry++)
6833 {
6834 switch (entry->d_tag)
6835 {
6836 case DT_IA_64_VMS_STRTAB_OFFSET:
6837 strtab_off = entry->d_un.d_val;
6838 break;
6839 case DT_STRSZ:
6840 strtab_sz = entry->d_un.d_val;
6841 if (strtab == NULL)
6842 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6843 1, strtab_sz, _("dynamic string section"));
6844 break;
6845
6846 case DT_IA_64_VMS_NEEDED_IDENT:
6847 fixup.needed_ident = entry->d_un.d_val;
6848 break;
6849 case DT_NEEDED:
6850 fixup.needed = entry->d_un.d_val;
6851 break;
6852 case DT_IA_64_VMS_FIXUP_NEEDED:
6853 fixup.fixup_needed = entry->d_un.d_val;
6854 break;
6855 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6856 fixup.fixup_rela_cnt = entry->d_un.d_val;
6857 break;
6858 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6859 fixup.fixup_rela_off = entry->d_un.d_val;
32ec8896
NC		 6860 if (! dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz))
6861 res = FALSE;
28f997cf 6862 break;
28f997cf
TG		 6863 case DT_IA_64_VMS_IMG_RELA_CNT:
6864 imgrela.img_rela_cnt = entry->d_un.d_val;
6865 break;
6866 case DT_IA_64_VMS_IMG_RELA_OFF:
6867 imgrela.img_rela_off = entry->d_un.d_val;
32ec8896
NC		 6868 if (! dump_ia64_vms_dynamic_relocs (file, &imgrela))
6869 res = FALSE;
28f997cf
TG		 6870 break;
6871
6872 default:
6873 break;
6874 }
6875 }
6876
6877 if (strtab != NULL)
6878 free (strtab);
6879
6880 return res;
6881}
6882
85b1c36d 6883static struct
566b0d53 6884{
2cf0635d 6885 const char * name;
566b0d53
L		 6886 int reloc;
6887 int size;
6888 int rela;
32ec8896
NC		 6889}
6890 dynamic_relocations [] =
566b0d53 6891{
32ec8896
NC		 6892 { "REL", DT_REL, DT_RELSZ, FALSE },
6893 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6894 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
566b0d53
L		 6895};
6896
252b5132 6897/* Process the reloc section. */
18bd398b 6898
32ec8896 6899static bfd_boolean
2cf0635d 6900process_relocs (FILE * file)
252b5132 6901{
b34976b6
AM		 6902 unsigned long rel_size;
6903 unsigned long rel_offset;
252b5132 6904
252b5132 6905 if (!do_reloc)
32ec8896 6906 return TRUE;
252b5132
RH		 6907
6908 if (do_using_dynamic)
6909 {
32ec8896 6910 int is_rela;
2cf0635d 6911 const char * name;
32ec8896 6912 bfd_boolean has_dynamic_reloc;
566b0d53 6913 unsigned int i;
0de14b54 6914
32ec8896 6915 has_dynamic_reloc = FALSE;
252b5132 6916
566b0d53 6917 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 6918 {
566b0d53
L		 6919 is_rela = dynamic_relocations [i].rela;
6920 name = dynamic_relocations [i].name;
6921 rel_size = dynamic_info [dynamic_relocations [i].size];
6922 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 6923
32ec8896
NC		 6924 if (rel_size)
6925 has_dynamic_reloc = TRUE;
566b0d53
L		 6926
6927 if (is_rela == UNKNOWN)
aa903cfb 6928 {
566b0d53
L		 6929 if (dynamic_relocations [i].reloc == DT_JMPREL)
6930 switch (dynamic_info[DT_PLTREL])
6931 {
6932 case DT_REL:
6933 is_rela = FALSE;
6934 break;
6935 case DT_RELA:
6936 is_rela = TRUE;
6937 break;
6938 }
aa903cfb 6939 }
252b5132 6940
566b0d53
L		 6941 if (rel_size)
6942 {
6943 printf
6944 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6945 name, rel_offset, rel_size);
252b5132 6946
d93f0186
NC		 6947 dump_relocations (file,
6948 offset_from_vma (file, rel_offset, rel_size),
6949 rel_size,
566b0d53 6950 dynamic_symbols, num_dynamic_syms,
bb4d2ac2 6951 dynamic_strings, dynamic_strings_length,
32ec8896 6952 is_rela, TRUE /* is_dynamic */);
566b0d53 6953 }
252b5132 6954 }
566b0d53 6955
28f997cf 6956 if (is_ia64_vms ())
32ec8896
NC		 6957 if (process_ia64_vms_dynamic_relocs (file))
6958 has_dynamic_reloc = TRUE;
28f997cf 6959
566b0d53 6960 if (! has_dynamic_reloc)
252b5132
RH		 6961 printf (_("\nThere are no dynamic relocations in this file.\n"));
6962 }
6963 else
6964 {
2cf0635d 6965 Elf_Internal_Shdr * section;
b34976b6 6966 unsigned long i;
32ec8896 6967 bfd_boolean found = FALSE;
252b5132
RH		 6968
6969 for (i = 0, section = section_headers;
6970 i < elf_header.e_shnum;
b34976b6 6971 i++, section++)
252b5132
RH		 6972 {
6973 if ( section->sh_type != SHT_RELA
6974 && section->sh_type != SHT_REL)
6975 continue;
6976
6977 rel_offset = section->sh_offset;
6978 rel_size = section->sh_size;
6979
6980 if (rel_size)
6981 {
2cf0635d 6982 Elf_Internal_Shdr * strsec;
b34976b6 6983 int is_rela;
103f02d3 6984
252b5132
RH		 6985 printf (_("\nRelocation section "));
6986
6987 if (string_table == NULL)
19936277 6988 printf ("%d", section->sh_name);
252b5132 6989 else
74e1a04b 6990 printf ("'%s'", printable_section_name (section));
252b5132
RH		 6991
6992 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6993 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6994
d79b3d50
NC		 6995 is_rela = section->sh_type == SHT_RELA;
6996
4fbb74a6
AM		 6997 if (section->sh_link != 0
6998 && section->sh_link < elf_header.e_shnum)
af3fc3bc 6999 {
2cf0635d
NC		 7000 Elf_Internal_Shdr * symsec;
7001 Elf_Internal_Sym * symtab;
d79b3d50 7002 unsigned long nsyms;
c256ffe7 7003 unsigned long strtablen = 0;
2cf0635d 7004 char * strtab = NULL;
57346661 7005
4fbb74a6 7006 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 7007 if (symsec->sh_type != SHT_SYMTAB
7008 && symsec->sh_type != SHT_DYNSYM)
7009 continue;
7010
ba5cdace 7011 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 7012
af3fc3bc
AM		 7013 if (symtab == NULL)
7014 continue;
252b5132 7015
4fbb74a6
AM		 7016 if (symsec->sh_link != 0
7017 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 7018 {
4fbb74a6 7019 strsec = section_headers + symsec->sh_link;
103f02d3 7020
3f5e193b 7021 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
071436c6
NC		 7022 1, strsec->sh_size,
7023 _("string table"));
c256ffe7
JJ		 7024 strtablen = strtab == NULL ? 0 : strsec->sh_size;
7025 }
252b5132 7026
d79b3d50 7027 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2
L		 7028 symtab, nsyms, strtab, strtablen,
7029 is_rela,
7030 symsec->sh_type == SHT_DYNSYM);
d79b3d50
NC		 7031 if (strtab)
7032 free (strtab);
7033 free (symtab);
7034 }
7035 else
7036 dump_relocations (file, rel_offset, rel_size,
32ec8896
NC		 7037 NULL, 0, NULL, 0, is_rela,
7038 FALSE /* is_dynamic */);
252b5132 7039
32ec8896 7040 found = TRUE;
252b5132
RH		 7041 }
7042 }
7043
7044 if (! found)
7045 printf (_("\nThere are no relocations in this file.\n"));
7046 }
7047
32ec8896 7048 return TRUE;
252b5132
RH		 7049}
7050
4d6ed7c8
NC		 7051/* An absolute address consists of a section and an offset. If the
7052 section is NULL, the offset itself is the address, otherwise, the
7053 address equals to LOAD_ADDRESS(section) + offset. */
7054
7055struct absaddr
948f632f
DA		 7056{
7057 unsigned short section;
7058 bfd_vma offset;
7059};
4d6ed7c8 7060
1949de15
L		 7061#define ABSADDR(a) \
7062 ((a).section \
7063 ? section_headers [(a).section].sh_addr + (a).offset \
7064 : (a).offset)
7065
948f632f
DA		 7066/* Find the nearest symbol at or below ADDR. Returns the symbol
7067 name, if found, and the offset from the symbol to ADDR. */
4d6ed7c8 7068
4d6ed7c8 7069static void
2cf0635d 7070find_symbol_for_address (Elf_Internal_Sym * symtab,
948f632f
DA		 7071 unsigned long nsyms,
7072 const char * strtab,
7073 unsigned long strtab_size,
7074 struct absaddr addr,
7075 const char ** symname,
7076 bfd_vma * offset)
4d6ed7c8 7077{
d3ba0551 7078 bfd_vma dist = 0x100000;
2cf0635d 7079 Elf_Internal_Sym * sym;
948f632f
DA		 7080 Elf_Internal_Sym * beg;
7081 Elf_Internal_Sym * end;
2cf0635d 7082 Elf_Internal_Sym * best = NULL;
4d6ed7c8 7083
0b6ae522 7084 REMOVE_ARCH_BITS (addr.offset);
948f632f
DA		 7085 beg = symtab;
7086 end = symtab + nsyms;
0b6ae522 7087
948f632f 7088 while (beg < end)
4d6ed7c8 7089 {
948f632f
DA		 7090 bfd_vma value;
7091
7092 sym = beg + (end - beg) / 2;
0b6ae522 7093
948f632f 7094 value = sym->st_value;
0b6ae522
DJ		 7095 REMOVE_ARCH_BITS (value);
7096
948f632f 7097 if (sym->st_name != 0
4d6ed7c8 7098 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 7099 && addr.offset >= value
7100 && addr.offset - value < dist)
4d6ed7c8
NC		 7101 {
7102 best = sym;
0b6ae522 7103 dist = addr.offset - value;
4d6ed7c8
NC		 7104 if (!dist)
7105 break;
7106 }
948f632f
DA		 7107
7108 if (addr.offset < value)
7109 end = sym;
7110 else
7111 beg = sym + 1;
4d6ed7c8 7112 }
1b31d05e 7113
4d6ed7c8
NC		 7114 if (best)
7115 {
57346661 7116 *symname = (best->st_name >= strtab_size
2b692964 7117 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 7118 *offset = dist;
7119 return;
7120 }
1b31d05e 7121
4d6ed7c8
NC		 7122 *symname = NULL;
7123 *offset = addr.offset;
7124}
7125
32ec8896 7126static /* signed */ int
948f632f
DA		 7127symcmp (const void *p, const void *q)
7128{
7129 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7130 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7131
7132 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7133}
7134
7135/* Process the unwind section. */
7136
7137#include "unwind-ia64.h"
7138
7139struct ia64_unw_table_entry
7140{
7141 struct absaddr start;
7142 struct absaddr end;
7143 struct absaddr info;
7144};
7145
7146struct ia64_unw_aux_info
7147{
32ec8896
NC		 7148 struct ia64_unw_table_entry * table; /* Unwind table. */
7149 unsigned long table_len; /* Length of unwind table. */
7150 unsigned char * info; /* Unwind info. */
7151 unsigned long info_size; /* Size of unwind info. */
7152 bfd_vma info_addr; /* Starting address of unwind info. */
7153 bfd_vma seg_base; /* Starting address of segment. */
7154 Elf_Internal_Sym * symtab; /* The symbol table. */
7155 unsigned long nsyms; /* Number of symbols. */
7156 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7157 unsigned long nfuns; /* Number of entries in funtab. */
7158 char * strtab; /* The string table. */
7159 unsigned long strtab_size; /* Size of string table. */
948f632f
DA		 7160};
7161
32ec8896 7162static bfd_boolean
2cf0635d 7163dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 7164{
2cf0635d 7165 struct ia64_unw_table_entry * tp;
948f632f 7166 unsigned long j, nfuns;
4d6ed7c8 7167 int in_body;
32ec8896 7168 bfd_boolean res = TRUE;
7036c0e1 7169
948f632f
DA		 7170 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7171 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7172 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7173 aux->funtab[nfuns++] = aux->symtab[j];
7174 aux->nfuns = nfuns;
7175 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7176
4d6ed7c8
NC		 7177 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7178 {
7179 bfd_vma stamp;
7180 bfd_vma offset;
2cf0635d
NC		 7181 const unsigned char * dp;
7182 const unsigned char * head;
53774b7e 7183 const unsigned char * end;
2cf0635d 7184 const char * procname;
4d6ed7c8 7185
948f632f 7186 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661 7187 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 7188
7189 fputs ("\n<", stdout);
7190
7191 if (procname)
7192 {
7193 fputs (procname, stdout);
7194
7195 if (offset)
7196 printf ("+%lx", (unsigned long) offset);
7197 }
7198
7199 fputs (">: [", stdout);
7200 print_vma (tp->start.offset, PREFIX_HEX);
7201 fputc ('-', stdout);
7202 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 7203 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 7204 (unsigned long) (tp->info.offset - aux->seg_base));
7205
53774b7e
NC		 7206 /* PR 17531: file: 86232b32. */
7207 if (aux->info == NULL)
7208 continue;
7209
7210 /* PR 17531: file: 0997b4d1. */
7211 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7212 {
7213 warn (_("Invalid offset %lx in table entry %ld\n"),
7214 (long) tp->info.offset, (long) (tp - aux->table));
32ec8896 7215 res = FALSE;
53774b7e
NC		 7216 continue;
7217 }
7218
1949de15 7219 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 7220 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 7221
86f55779 7222 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 7223 (unsigned) UNW_VER (stamp),
7224 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7225 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7226 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 7227 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 7228
7229 if (UNW_VER (stamp) != 1)
7230 {
2b692964 7231 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 7232 continue;
7233 }
7234
7235 in_body = 0;
53774b7e
NC		 7236 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7237 /* PR 17531: file: 16ceda89. */
7238 if (end > aux->info + aux->info_size)
7239 end = aux->info + aux->info_size;
7240 for (dp = head + 8; dp < end;)
b4477bc8 7241 dp = unw_decode (dp, in_body, & in_body, end);
4d6ed7c8 7242 }
948f632f
DA		 7243
7244 free (aux->funtab);
32ec8896
NC		 7245
7246 return res;
4d6ed7c8
NC		 7247}
7248
53774b7e 7249static bfd_boolean
2cf0635d
NC		 7250slurp_ia64_unwind_table (FILE * file,
7251 struct ia64_unw_aux_info * aux,
7252 Elf_Internal_Shdr * sec)
4d6ed7c8 7253{
89fac5e3 7254 unsigned long size, nrelas, i;
2cf0635d
NC		 7255 Elf_Internal_Phdr * seg;
7256 struct ia64_unw_table_entry * tep;
7257 Elf_Internal_Shdr * relsec;
7258 Elf_Internal_Rela * rela;
7259 Elf_Internal_Rela * rp;
7260 unsigned char * table;
7261 unsigned char * tp;
7262 Elf_Internal_Sym * sym;
7263 const char * relname;
4d6ed7c8 7264
53774b7e
NC		 7265 aux->table_len = 0;
7266
4d6ed7c8
NC		 7267 /* First, find the starting address of the segment that includes
7268 this section: */
7269
7270 if (elf_header.e_phnum)
7271 {
d93f0186 7272 if (! get_program_headers (file))
53774b7e 7273 return FALSE;
4d6ed7c8 7274
d93f0186
NC		 7275 for (seg = program_headers;
7276 seg < program_headers + elf_header.e_phnum;
7277 ++seg)
4d6ed7c8
NC		 7278 {
7279 if (seg->p_type != PT_LOAD)
7280 continue;
7281
7282 if (sec->sh_addr >= seg->p_vaddr
7283 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7284 {
7285 aux->seg_base = seg->p_vaddr;
7286 break;
7287 }
7288 }
4d6ed7c8
NC		 7289 }
7290
7291 /* Second, build the unwind table from the contents of the unwind section: */
7292 size = sec->sh_size;
3f5e193b
NC		 7293 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7294 _("unwind table"));
a6e9f9df 7295 if (!table)
53774b7e 7296 return FALSE;
4d6ed7c8 7297
53774b7e 7298 aux->table_len = size / (3 * eh_addr_size);
3f5e193b 7299 aux->table = (struct ia64_unw_table_entry *)
53774b7e 7300 xcmalloc (aux->table_len, sizeof (aux->table[0]));
89fac5e3 7301 tep = aux->table;
53774b7e
NC		 7302
7303 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
4d6ed7c8
NC		 7304 {
7305 tep->start.section = SHN_UNDEF;
7306 tep->end.section = SHN_UNDEF;
7307 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 7308 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7309 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7310 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 7311 tep->start.offset += aux->seg_base;
7312 tep->end.offset += aux->seg_base;
7313 tep->info.offset += aux->seg_base;
7314 }
7315 free (table);
7316
41e92641 7317 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 7318 for (relsec = section_headers;
7319 relsec < section_headers + elf_header.e_shnum;
7320 ++relsec)
7321 {
7322 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 7323 || relsec->sh_info >= elf_header.e_shnum
7324 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 7325 continue;
7326
7327 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7328 & rela, & nrelas))
53774b7e
NC		 7329 {
7330 free (aux->table);
7331 aux->table = NULL;
7332 aux->table_len = 0;
7333 return FALSE;
7334 }
4d6ed7c8
NC		 7335
7336 for (rp = rela; rp < rela + nrelas; ++rp)
7337 {
aca88567
NC		 7338 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
7339 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 7340
82b1b41b
NC		 7341 /* PR 17531: file: 9fa67536. */
7342 if (relname == NULL)
7343 {
7344 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
7345 continue;
7346 }
948f632f 7347
0112cd26 7348 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 7349 {
82b1b41b 7350 warn (_("Skipping unexpected relocation type: %s\n"), relname);
4d6ed7c8
NC		 7351 continue;
7352 }
7353
89fac5e3 7354 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 7355
53774b7e
NC		 7356 /* PR 17531: file: 5bc8d9bf. */
7357 if (i >= aux->table_len)
7358 {
7359 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7360 continue;
7361 }
7362
7363 switch (rp->r_offset / eh_addr_size % 3)
4d6ed7c8
NC		 7364 {
7365 case 0:
7366 aux->table[i].start.section = sym->st_shndx;
e466bc6e 7367 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 7368 break;
7369 case 1:
7370 aux->table[i].end.section = sym->st_shndx;
e466bc6e 7371 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 7372 break;
7373 case 2:
7374 aux->table[i].info.section = sym->st_shndx;
e466bc6e 7375 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 7376 break;
7377 default:
7378 break;
7379 }
7380 }
7381
7382 free (rela);
7383 }
7384
53774b7e 7385 return TRUE;
4d6ed7c8
NC		 7386}
7387
32ec8896 7388static bfd_boolean
2cf0635d 7389ia64_process_unwind (FILE * file)
4d6ed7c8 7390{
2cf0635d
NC		 7391 Elf_Internal_Shdr * sec;
7392 Elf_Internal_Shdr * unwsec = NULL;
7393 Elf_Internal_Shdr * strsec;
89fac5e3 7394 unsigned long i, unwcount = 0, unwstart = 0;
57346661 7395 struct ia64_unw_aux_info aux;
32ec8896 7396 bfd_boolean res = TRUE;
f1467e33 7397
4d6ed7c8
NC		 7398 memset (& aux, 0, sizeof (aux));
7399
4d6ed7c8
NC		 7400 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7401 {
c256ffe7 7402 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 7403 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 7404 {
ba5cdace 7405 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 7406
4fbb74a6 7407 strsec = section_headers + sec->sh_link;
4082ef84
NC		 7408 if (aux.strtab != NULL)
7409 {
7410 error (_("Multiple auxillary string tables encountered\n"));
7411 free (aux.strtab);
32ec8896 7412 res = FALSE;
4082ef84 7413 }
3f5e193b
NC		 7414 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7415 1, strsec->sh_size,
7416 _("string table"));
c256ffe7 7417 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 7418 }
7419 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 7420 unwcount++;
7421 }
7422
7423 if (!unwcount)
7424 printf (_("\nThere are no unwind sections in this file.\n"));
7425
7426 while (unwcount-- > 0)
7427 {
2cf0635d 7428 char * suffix;
579f31ac
JJ		 7429 size_t len, len2;
7430
4082ef84 7431 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
579f31ac
JJ		 7432 i < elf_header.e_shnum; ++i, ++sec)
7433 if (sec->sh_type == SHT_IA_64_UNWIND)
7434 {
7435 unwsec = sec;
7436 break;
7437 }
4082ef84
NC		 7438 /* We have already counted the number of SHT_IA64_UNWIND
7439 sections so the loop above should never fail. */
7440 assert (unwsec != NULL);
579f31ac
JJ		 7441
7442 unwstart = i + 1;
7443 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7444
e4b17d5c
L		 7445 if ((unwsec->sh_flags & SHF_GROUP) != 0)
7446 {
7447 /* We need to find which section group it is in. */
4082ef84 7448 struct group_list * g;
e4b17d5c 7449
4082ef84
NC		 7450 if (section_headers_groups == NULL
7451 || section_headers_groups [i] == NULL)
7452 i = elf_header.e_shnum;
7453 else
e4b17d5c 7454 {
4082ef84 7455 g = section_headers_groups [i]->root;
18bd398b 7456
4082ef84
NC		 7457 for (; g != NULL; g = g->next)
7458 {
7459 sec = section_headers + g->section_index;
e4b17d5c 7460
4082ef84
NC		 7461 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7462 break;
7463 }
7464
7465 if (g == NULL)
7466 i = elf_header.e_shnum;
7467 }
e4b17d5c 7468 }
18bd398b 7469 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 7470 {
18bd398b 7471 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 7472 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7473 suffix = SECTION_NAME (unwsec) + len;
7474 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7475 ++i, ++sec)
18bd398b
NC		 7476 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7477 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 7478 break;
7479 }
7480 else
7481 {
7482 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 7483 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 7484 len = sizeof (ELF_STRING_ia64_unwind) - 1;
7485 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7486 suffix = "";
18bd398b 7487 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 7488 suffix = SECTION_NAME (unwsec) + len;
7489 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7490 ++i, ++sec)
18bd398b
NC		 7491 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7492 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 7493 break;
7494 }
7495
7496 if (i == elf_header.e_shnum)
7497 {
7498 printf (_("\nCould not find unwind info section for "));
7499
7500 if (string_table == NULL)
7501 printf ("%d", unwsec->sh_name);
7502 else
74e1a04b 7503 printf ("'%s'", printable_section_name (unwsec));
579f31ac
JJ		 7504 }
7505 else
4d6ed7c8 7506 {
4d6ed7c8 7507 aux.info_addr = sec->sh_addr;
3f5e193b 7508 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
4082ef84
NC		 7509 sec->sh_size,
7510 _("unwind info"));
59245841 7511 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 7512
579f31ac 7513 printf (_("\nUnwind section "));
4d6ed7c8 7514
579f31ac
JJ		 7515 if (string_table == NULL)
7516 printf ("%d", unwsec->sh_name);
7517 else
74e1a04b 7518 printf ("'%s'", printable_section_name (unwsec));
4d6ed7c8 7519
579f31ac 7520 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 7521 (unsigned long) unwsec->sh_offset,
89fac5e3 7522 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 7523
53774b7e
NC		 7524 if (slurp_ia64_unwind_table (file, & aux, unwsec)
7525 && aux.table_len > 0)
579f31ac
JJ		 7526 dump_ia64_unwind (& aux);
7527
7528 if (aux.table)
7529 free ((char *) aux.table);
7530 if (aux.info)
7531 free ((char *) aux.info);
7532 aux.table = NULL;
7533 aux.info = NULL;
7534 }
4d6ed7c8 7535 }
4d6ed7c8 7536
4d6ed7c8
NC		 7537 if (aux.symtab)
7538 free (aux.symtab);
7539 if (aux.strtab)
7540 free ((char *) aux.strtab);
32ec8896
NC		 7541
7542 return res;
4d6ed7c8
NC		 7543}
7544
3f5e193b 7545struct hppa_unw_table_entry
32ec8896
NC		 7546{
7547 struct absaddr start;
7548 struct absaddr end;
7549 unsigned int Cannot_unwind:1; /* 0 */
7550 unsigned int Millicode:1; /* 1 */
7551 unsigned int Millicode_save_sr0:1; /* 2 */
7552 unsigned int Region_description:2; /* 3..4 */
7553 unsigned int reserved1:1; /* 5 */
7554 unsigned int Entry_SR:1; /* 6 */
7555 unsigned int Entry_FR:4; /* Number saved 7..10 */
7556 unsigned int Entry_GR:5; /* Number saved 11..15 */
7557 unsigned int Args_stored:1; /* 16 */
7558 unsigned int Variable_Frame:1; /* 17 */
7559 unsigned int Separate_Package_Body:1; /* 18 */
7560 unsigned int Frame_Extension_Millicode:1; /* 19 */
7561 unsigned int Stack_Overflow_Check:1; /* 20 */
7562 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
7563 unsigned int Ada_Region:1; /* 22 */
7564 unsigned int cxx_info:1; /* 23 */
7565 unsigned int cxx_try_catch:1; /* 24 */
7566 unsigned int sched_entry_seq:1; /* 25 */
7567 unsigned int reserved2:1; /* 26 */
7568 unsigned int Save_SP:1; /* 27 */
7569 unsigned int Save_RP:1; /* 28 */
7570 unsigned int Save_MRP_in_frame:1; /* 29 */
7571 unsigned int extn_ptr_defined:1; /* 30 */
7572 unsigned int Cleanup_defined:1; /* 31 */
7573
7574 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
7575 unsigned int HP_UX_interrupt_marker:1; /* 1 */
7576 unsigned int Large_frame:1; /* 2 */
7577 unsigned int Pseudo_SP_Set:1; /* 3 */
7578 unsigned int reserved4:1; /* 4 */
7579 unsigned int Total_frame_size:27; /* 5..31 */
7580};
3f5e193b 7581
57346661 7582struct hppa_unw_aux_info
948f632f 7583{
32ec8896
NC		 7584 struct hppa_unw_table_entry * table; /* Unwind table. */
7585 unsigned long table_len; /* Length of unwind table. */
7586 bfd_vma seg_base; /* Starting address of segment. */
7587 Elf_Internal_Sym * symtab; /* The symbol table. */
7588 unsigned long nsyms; /* Number of symbols. */
7589 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7590 unsigned long nfuns; /* Number of entries in funtab. */
7591 char * strtab; /* The string table. */
7592 unsigned long strtab_size; /* Size of string table. */
948f632f 7593};
57346661 7594
32ec8896 7595static bfd_boolean
2cf0635d 7596dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 7597{
2cf0635d 7598 struct hppa_unw_table_entry * tp;
948f632f 7599 unsigned long j, nfuns;
32ec8896 7600 bfd_boolean res = TRUE;
948f632f
DA		 7601
7602 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7603 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7604 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7605 aux->funtab[nfuns++] = aux->symtab[j];
7606 aux->nfuns = nfuns;
7607 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
57346661 7608
57346661
AM		 7609 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7610 {
7611 bfd_vma offset;
2cf0635d 7612 const char * procname;
57346661 7613
948f632f 7614 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661
AM		 7615 aux->strtab_size, tp->start, &procname,
7616 &offset);
7617
7618 fputs ("\n<", stdout);
7619
7620 if (procname)
7621 {
7622 fputs (procname, stdout);
7623
7624 if (offset)
7625 printf ("+%lx", (unsigned long) offset);
7626 }
7627
7628 fputs (">: [", stdout);
7629 print_vma (tp->start.offset, PREFIX_HEX);
7630 fputc ('-', stdout);
7631 print_vma (tp->end.offset, PREFIX_HEX);
7632 printf ("]\n\t");
7633
18bd398b
NC		 7634#define PF(_m) if (tp->_m) printf (#_m " ");
7635#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 7636 PF(Cannot_unwind);
7637 PF(Millicode);
7638 PF(Millicode_save_sr0);
18bd398b 7639 /* PV(Region_description); */
57346661
AM		 7640 PF(Entry_SR);
7641 PV(Entry_FR);
7642 PV(Entry_GR);
7643 PF(Args_stored);
7644 PF(Variable_Frame);
7645 PF(Separate_Package_Body);
7646 PF(Frame_Extension_Millicode);
7647 PF(Stack_Overflow_Check);
7648 PF(Two_Instruction_SP_Increment);
7649 PF(Ada_Region);
7650 PF(cxx_info);
7651 PF(cxx_try_catch);
7652 PF(sched_entry_seq);
7653 PF(Save_SP);
7654 PF(Save_RP);
7655 PF(Save_MRP_in_frame);
7656 PF(extn_ptr_defined);
7657 PF(Cleanup_defined);
7658 PF(MPE_XL_interrupt_marker);
7659 PF(HP_UX_interrupt_marker);
7660 PF(Large_frame);
7661 PF(Pseudo_SP_Set);
7662 PV(Total_frame_size);
7663#undef PF
7664#undef PV
7665 }
7666
18bd398b 7667 printf ("\n");
948f632f
DA		 7668
7669 free (aux->funtab);
32ec8896
NC		 7670
7671 return res;
57346661
AM		 7672}
7673
32ec8896 7674static bfd_boolean
2cf0635d
NC		 7675slurp_hppa_unwind_table (FILE * file,
7676 struct hppa_unw_aux_info * aux,
7677 Elf_Internal_Shdr * sec)
57346661 7678{
1c0751b2 7679 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 7680 Elf_Internal_Phdr * seg;
7681 struct hppa_unw_table_entry * tep;
7682 Elf_Internal_Shdr * relsec;
7683 Elf_Internal_Rela * rela;
7684 Elf_Internal_Rela * rp;
7685 unsigned char * table;
7686 unsigned char * tp;
7687 Elf_Internal_Sym * sym;
7688 const char * relname;
57346661 7689
57346661
AM		 7690 /* First, find the starting address of the segment that includes
7691 this section. */
57346661
AM		 7692 if (elf_header.e_phnum)
7693 {
7694 if (! get_program_headers (file))
32ec8896 7695 return FALSE;
57346661
AM		 7696
7697 for (seg = program_headers;
7698 seg < program_headers + elf_header.e_phnum;
7699 ++seg)
7700 {
7701 if (seg->p_type != PT_LOAD)
7702 continue;
7703
7704 if (sec->sh_addr >= seg->p_vaddr
7705 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7706 {
7707 aux->seg_base = seg->p_vaddr;
7708 break;
7709 }
7710 }
7711 }
7712
7713 /* Second, build the unwind table from the contents of the unwind
7714 section. */
7715 size = sec->sh_size;
3f5e193b
NC		 7716 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7717 _("unwind table"));
57346661 7718 if (!table)
32ec8896 7719 return FALSE;
57346661 7720
1c0751b2
DA		 7721 unw_ent_size = 16;
7722 nentries = size / unw_ent_size;
7723 size = unw_ent_size * nentries;
57346661 7724
3f5e193b
NC		 7725 tep = aux->table = (struct hppa_unw_table_entry *)
7726 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 7727
1c0751b2 7728 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 7729 {
7730 unsigned int tmp1, tmp2;
7731
7732 tep->start.section = SHN_UNDEF;
7733 tep->end.section = SHN_UNDEF;
7734
1c0751b2
DA		 7735 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7736 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7737 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7738 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7739
7740 tep->start.offset += aux->seg_base;
7741 tep->end.offset += aux->seg_base;
57346661
AM		 7742
7743 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7744 tep->Millicode = (tmp1 >> 30) & 0x1;
7745 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7746 tep->Region_description = (tmp1 >> 27) & 0x3;
7747 tep->reserved1 = (tmp1 >> 26) & 0x1;
7748 tep->Entry_SR = (tmp1 >> 25) & 0x1;
7749 tep->Entry_FR = (tmp1 >> 21) & 0xf;
7750 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7751 tep->Args_stored = (tmp1 >> 15) & 0x1;
7752 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7753 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7754 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7755 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7756 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7757 tep->Ada_Region = (tmp1 >> 9) & 0x1;
7758 tep->cxx_info = (tmp1 >> 8) & 0x1;
7759 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7760 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7761 tep->reserved2 = (tmp1 >> 5) & 0x1;
7762 tep->Save_SP = (tmp1 >> 4) & 0x1;
7763 tep->Save_RP = (tmp1 >> 3) & 0x1;
7764 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7765 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7766 tep->Cleanup_defined = tmp1 & 0x1;
7767
7768 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7769 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7770 tep->Large_frame = (tmp2 >> 29) & 0x1;
7771 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7772 tep->reserved4 = (tmp2 >> 27) & 0x1;
7773 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 7774 }
7775 free (table);
7776
7777 /* Third, apply any relocations to the unwind table. */
57346661
AM		 7778 for (relsec = section_headers;
7779 relsec < section_headers + elf_header.e_shnum;
7780 ++relsec)
7781 {
7782 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 7783 || relsec->sh_info >= elf_header.e_shnum
7784 || section_headers + relsec->sh_info != sec)
57346661
AM		 7785 continue;
7786
7787 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7788 & rela, & nrelas))
32ec8896 7789 return FALSE;
57346661
AM		 7790
7791 for (rp = rela; rp < rela + nrelas; ++rp)
7792 {
aca88567
NC		 7793 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7794 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 7795
7796 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 7797 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 7798 {
7799 warn (_("Skipping unexpected relocation type %s\n"), relname);
7800 continue;
7801 }
7802
7803 i = rp->r_offset / unw_ent_size;
7804
89fac5e3 7805 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 7806 {
7807 case 0:
7808 aux->table[i].start.section = sym->st_shndx;
1e456d54 7809 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 7810 break;
7811 case 1:
7812 aux->table[i].end.section = sym->st_shndx;
1e456d54 7813 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 7814 break;
7815 default:
7816 break;
7817 }
7818 }
7819
7820 free (rela);
7821 }
7822
1c0751b2 7823 aux->table_len = nentries;
57346661 7824
32ec8896 7825 return TRUE;
57346661
AM		 7826}
7827
32ec8896 7828static bfd_boolean
2cf0635d 7829hppa_process_unwind (FILE * file)
57346661 7830{
57346661 7831 struct hppa_unw_aux_info aux;
2cf0635d
NC		 7832 Elf_Internal_Shdr * unwsec = NULL;
7833 Elf_Internal_Shdr * strsec;
7834 Elf_Internal_Shdr * sec;
18bd398b 7835 unsigned long i;
32ec8896 7836 bfd_boolean res = TRUE;
57346661 7837
c256ffe7 7838 if (string_table == NULL)
32ec8896 7839 return FALSE;
1b31d05e
NC		 7840
7841 memset (& aux, 0, sizeof (aux));
57346661
AM		 7842
7843 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7844 {
c256ffe7 7845 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 7846 && sec->sh_link < elf_header.e_shnum)
57346661 7847 {
ba5cdace 7848 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 7849
4fbb74a6 7850 strsec = section_headers + sec->sh_link;
4082ef84
NC		 7851 if (aux.strtab != NULL)
7852 {
7853 error (_("Multiple auxillary string tables encountered\n"));
7854 free (aux.strtab);
32ec8896 7855 res = FALSE;
4082ef84 7856 }
3f5e193b
NC		 7857 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7858 1, strsec->sh_size,
7859 _("string table"));
c256ffe7 7860 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 7861 }
18bd398b 7862 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 7863 unwsec = sec;
7864 }
7865
7866 if (!unwsec)
7867 printf (_("\nThere are no unwind sections in this file.\n"));
7868
7869 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7870 {
18bd398b 7871 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 7872 {
74e1a04b
NC		 7873 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7874 printable_section_name (sec),
57346661 7875 (unsigned long) sec->sh_offset,
89fac5e3 7876 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661 7877
32ec8896
NC		 7878 if (! slurp_hppa_unwind_table (file, &aux, sec))
7879 res = FALSE;
7880
57346661 7881 if (aux.table_len > 0)
32ec8896
NC		 7882 {
7883 if (! dump_hppa_unwind (&aux))
7884 res = FALSE;
7885 }
57346661
AM		 7886
7887 if (aux.table)
7888 free ((char *) aux.table);
7889 aux.table = NULL;
7890 }
7891 }
7892
7893 if (aux.symtab)
7894 free (aux.symtab);
7895 if (aux.strtab)
7896 free ((char *) aux.strtab);
32ec8896
NC		 7897
7898 return res;
57346661
AM		 7899}
7900
0b6ae522
DJ		 7901struct arm_section
7902{
a734115a
NC		 7903 unsigned char * data; /* The unwind data. */
7904 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
7905 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
7906 unsigned long nrelas; /* The number of relocations. */
7907 unsigned int rel_type; /* REL or RELA ? */
7908 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 7909};
7910
7911struct arm_unw_aux_info
7912{
a734115a
NC		 7913 FILE * file; /* The file containing the unwind sections. */
7914 Elf_Internal_Sym * symtab; /* The file's symbol table. */
7915 unsigned long nsyms; /* Number of symbols. */
948f632f
DA		 7916 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7917 unsigned long nfuns; /* Number of these symbols. */
a734115a
NC		 7918 char * strtab; /* The file's string table. */
7919 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 7920};
7921
7922static const char *
7923arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7924 bfd_vma fn, struct absaddr addr)
7925{
7926 const char *procname;
7927 bfd_vma sym_offset;
7928
7929 if (addr.section == SHN_UNDEF)
7930 addr.offset = fn;
7931
948f632f 7932 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
0b6ae522
DJ		 7933 aux->strtab_size, addr, &procname,
7934 &sym_offset);
7935
7936 print_vma (fn, PREFIX_HEX);
7937
7938 if (procname)
7939 {
7940 fputs (" <", stdout);
7941 fputs (procname, stdout);
7942
7943 if (sym_offset)
7944 printf ("+0x%lx", (unsigned long) sym_offset);
7945 fputc ('>', stdout);
7946 }
7947
7948 return procname;
7949}
7950
7951static void
7952arm_free_section (struct arm_section *arm_sec)
7953{
7954 if (arm_sec->data != NULL)
7955 free (arm_sec->data);
7956
7957 if (arm_sec->rela != NULL)
7958 free (arm_sec->rela);
7959}
7960
a734115a
NC		 7961/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7962 cached section and install SEC instead.
7963 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7964 and return its valued in * WORDP, relocating if necessary.
1b31d05e 7965 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 7966 relocation's offset in ADDR.
1b31d05e
NC		 7967 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7968 into the string table of the symbol associated with the reloc. If no
7969 reloc was applied store -1 there.
7970 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 7971
7972static bfd_boolean
1b31d05e
NC		 7973get_unwind_section_word (struct arm_unw_aux_info * aux,
7974 struct arm_section * arm_sec,
7975 Elf_Internal_Shdr * sec,
7976 bfd_vma word_offset,
7977 unsigned int * wordp,
7978 struct absaddr * addr,
7979 bfd_vma * sym_name)
0b6ae522
DJ		 7980{
7981 Elf_Internal_Rela *rp;
7982 Elf_Internal_Sym *sym;
7983 const char * relname;
7984 unsigned int word;
7985 bfd_boolean wrapped;
7986
e0a31db1
NC		 7987 if (sec == NULL || arm_sec == NULL)
7988 return FALSE;
7989
0b6ae522
DJ		 7990 addr->section = SHN_UNDEF;
7991 addr->offset = 0;
7992
1b31d05e
NC		 7993 if (sym_name != NULL)
7994 *sym_name = (bfd_vma) -1;
7995
a734115a 7996 /* If necessary, update the section cache. */
0b6ae522
DJ		 7997 if (sec != arm_sec->sec)
7998 {
7999 Elf_Internal_Shdr *relsec;
8000
8001 arm_free_section (arm_sec);
8002
8003 arm_sec->sec = sec;
8004 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
8005 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 8006 arm_sec->rela = NULL;
8007 arm_sec->nrelas = 0;
8008
8009 for (relsec = section_headers;
8010 relsec < section_headers + elf_header.e_shnum;
8011 ++relsec)
8012 {
8013 if (relsec->sh_info >= elf_header.e_shnum
1ae40aa4
NC		 8014 || section_headers + relsec->sh_info != sec
8015 /* PR 15745: Check the section type as well. */
8016 || (relsec->sh_type != SHT_REL
8017 && relsec->sh_type != SHT_RELA))
0b6ae522
DJ		 8018 continue;
8019
a734115a 8020 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 8021 if (relsec->sh_type == SHT_REL)
8022 {
8023 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
8024 relsec->sh_size,
8025 & arm_sec->rela, & arm_sec->nrelas))
a734115a 8026 return FALSE;
0b6ae522 8027 }
1ae40aa4 8028 else /* relsec->sh_type == SHT_RELA */
0b6ae522
DJ		 8029 {
8030 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
8031 relsec->sh_size,
8032 & arm_sec->rela, & arm_sec->nrelas))
a734115a 8033 return FALSE;
0b6ae522 8034 }
1ae40aa4 8035 break;
0b6ae522
DJ		 8036 }
8037
8038 arm_sec->next_rela = arm_sec->rela;
8039 }
8040
a734115a 8041 /* If there is no unwind data we can do nothing. */
0b6ae522 8042 if (arm_sec->data == NULL)
a734115a 8043 return FALSE;
0b6ae522 8044
e0a31db1 8045 /* If the offset is invalid then fail. */
1a915552
NC		 8046 if (word_offset > (sec->sh_size - 4)
8047 /* PR 18879 */
8048 || (sec->sh_size < 5 && word_offset >= sec->sh_size)
8049 || ((bfd_signed_vma) word_offset) < 0)
e0a31db1
NC		 8050 return FALSE;
8051
a734115a 8052 /* Get the word at the required offset. */
0b6ae522
DJ		 8053 word = byte_get (arm_sec->data + word_offset, 4);
8054
0eff7165
NC		 8055 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8056 if (arm_sec->rela == NULL)
8057 {
8058 * wordp = word;
8059 return TRUE;
8060 }
8061
a734115a 8062 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 8063 wrapped = FALSE;
8064 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8065 {
8066 bfd_vma prelval, offset;
8067
8068 if (rp->r_offset > word_offset && !wrapped)
8069 {
8070 rp = arm_sec->rela;
8071 wrapped = TRUE;
8072 }
8073 if (rp->r_offset > word_offset)
8074 break;
8075
8076 if (rp->r_offset & 3)
8077 {
8078 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8079 (unsigned long) rp->r_offset);
8080 continue;
8081 }
8082
8083 if (rp->r_offset < word_offset)
8084 continue;
8085
74e1a04b
NC		 8086 /* PR 17531: file: 027-161405-0.004 */
8087 if (aux->symtab == NULL)
8088 continue;
8089
0b6ae522
DJ		 8090 if (arm_sec->rel_type == SHT_REL)
8091 {
8092 offset = word & 0x7fffffff;
8093 if (offset & 0x40000000)
8094 offset |= ~ (bfd_vma) 0x7fffffff;
8095 }
a734115a 8096 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 8097 offset = rp->r_addend;
a734115a 8098 else
74e1a04b
NC		 8099 {
8100 error (_("Unknown section relocation type %d encountered\n"),
8101 arm_sec->rel_type);
8102 break;
8103 }
0b6ae522 8104
071436c6
NC		 8105 /* PR 17531 file: 027-1241568-0.004. */
8106 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8107 {
8108 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8109 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8110 break;
8111 }
8112
8113 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
0b6ae522
DJ		 8114 offset += sym->st_value;
8115 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8116
a734115a
NC		 8117 /* Check that we are processing the expected reloc type. */
8118 if (elf_header.e_machine == EM_ARM)
8119 {
8120 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 8121 if (relname == NULL)
8122 {
8123 warn (_("Skipping unknown ARM relocation type: %d\n"),
8124 (int) ELF32_R_TYPE (rp->r_info));
8125 continue;
8126 }
a734115a
NC		 8127
8128 if (streq (relname, "R_ARM_NONE"))
8129 continue;
0b4362b0 8130
a734115a
NC		 8131 if (! streq (relname, "R_ARM_PREL31"))
8132 {
071436c6 8133 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
a734115a
NC		 8134 continue;
8135 }
8136 }
8137 else if (elf_header.e_machine == EM_TI_C6000)
8138 {
8139 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 8140 if (relname == NULL)
8141 {
8142 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8143 (int) ELF32_R_TYPE (rp->r_info));
8144 continue;
8145 }
0b4362b0 8146
a734115a
NC		 8147 if (streq (relname, "R_C6000_NONE"))
8148 continue;
8149
8150 if (! streq (relname, "R_C6000_PREL31"))
8151 {
071436c6 8152 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
a734115a
NC		 8153 continue;
8154 }
8155
8156 prelval >>= 1;
8157 }
8158 else
74e1a04b
NC		 8159 {
8160 /* This function currently only supports ARM and TI unwinders. */
8161 warn (_("Only TI and ARM unwinders are currently supported\n"));
8162 break;
8163 }
fa197c1c 8164
0b6ae522
DJ		 8165 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8166 addr->section = sym->st_shndx;
8167 addr->offset = offset;
74e1a04b 8168
1b31d05e
NC		 8169 if (sym_name)
8170 * sym_name = sym->st_name;
0b6ae522
DJ		 8171 break;
8172 }
8173
8174 *wordp = word;
8175 arm_sec->next_rela = rp;
8176
a734115a 8177 return TRUE;
0b6ae522
DJ		 8178}
8179
a734115a
NC		 8180static const char *tic6x_unwind_regnames[16] =
8181{
0b4362b0
RM		 8182 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8183 "A14", "A13", "A12", "A11", "A10",
a734115a
NC		 8184 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8185};
fa197c1c 8186
0b6ae522 8187static void
fa197c1c 8188decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 8189{
fa197c1c
PB		 8190 int i;
8191
8192 for (i = 12; mask; mask >>= 1, i--)
8193 {
8194 if (mask & 1)
8195 {
8196 fputs (tic6x_unwind_regnames[i], stdout);
8197 if (mask > 1)
8198 fputs (", ", stdout);
8199 }
8200 }
8201}
0b6ae522
DJ		 8202
8203#define ADVANCE \
8204 if (remaining == 0 && more_words) \
8205 { \
8206 data_offset += 4; \
1b31d05e
NC		 8207 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
8208 data_offset, & word, & addr, NULL)) \
32ec8896 8209 return FALSE; \
0b6ae522
DJ		 8210 remaining = 4; \
8211 more_words--; \
8212 } \
8213
8214#define GET_OP(OP) \
8215 ADVANCE; \
8216 if (remaining) \
8217 { \
8218 remaining--; \
8219 (OP) = word >> 24; \
8220 word <<= 8; \
8221 } \
8222 else \
8223 { \
2b692964 8224 printf (_("[Truncated opcode]\n")); \
32ec8896 8225 return FALSE; \
0b6ae522 8226 } \
cc5914eb 8227 printf ("0x%02x ", OP)
0b6ae522 8228
32ec8896 8229static bfd_boolean
948f632f
DA		 8230decode_arm_unwind_bytecode (struct arm_unw_aux_info * aux,
8231 unsigned int word,
8232 unsigned int remaining,
8233 unsigned int more_words,
8234 bfd_vma data_offset,
8235 Elf_Internal_Shdr * data_sec,
8236 struct arm_section * data_arm_sec)
fa197c1c
PB		 8237{
8238 struct absaddr addr;
32ec8896 8239 bfd_boolean res = TRUE;
0b6ae522
DJ		 8240
8241 /* Decode the unwinding instructions. */
8242 while (1)
8243 {
8244 unsigned int op, op2;
8245
8246 ADVANCE;
8247 if (remaining == 0)
8248 break;
8249 remaining--;
8250 op = word >> 24;
8251 word <<= 8;
8252
cc5914eb 8253 printf (" 0x%02x ", op);
0b6ae522
DJ		 8254
8255 if ((op & 0xc0) == 0x00)
8256 {
8257 int offset = ((op & 0x3f) << 2) + 4;
61865e30 8258
cc5914eb 8259 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 8260 }
8261 else if ((op & 0xc0) == 0x40)
8262 {
8263 int offset = ((op & 0x3f) << 2) + 4;
61865e30 8264
cc5914eb 8265 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 8266 }
8267 else if ((op & 0xf0) == 0x80)
8268 {
8269 GET_OP (op2);
8270 if (op == 0x80 && op2 == 0)
8271 printf (_("Refuse to unwind"));
8272 else
8273 {
8274 unsigned int mask = ((op & 0x0f) << 8) | op2;
32ec8896 8275 bfd_boolean first = TRUE;
0b6ae522 8276 int i;
2b692964 8277
0b6ae522
DJ		 8278 printf ("pop {");
8279 for (i = 0; i < 12; i++)
8280 if (mask & (1 << i))
8281 {
8282 if (first)
32ec8896 8283 first = FALSE;
0b6ae522
DJ		 8284 else
8285 printf (", ");
8286 printf ("r%d", 4 + i);
8287 }
8288 printf ("}");
8289 }
8290 }
8291 else if ((op & 0xf0) == 0x90)
8292 {
8293 if (op == 0x9d || op == 0x9f)
8294 printf (_(" [Reserved]"));
8295 else
cc5914eb 8296 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 8297 }
8298 else if ((op & 0xf0) == 0xa0)
8299 {
8300 int end = 4 + (op & 0x07);
32ec8896 8301 bfd_boolean first = TRUE;
0b6ae522 8302 int i;
61865e30 8303
0b6ae522
DJ		 8304 printf (" pop {");
8305 for (i = 4; i <= end; i++)
8306 {
8307 if (first)
32ec8896 8308 first = FALSE;
0b6ae522
DJ		 8309 else
8310 printf (", ");
8311 printf ("r%d", i);
8312 }
8313 if (op & 0x08)
8314 {
1b31d05e 8315 if (!first)
0b6ae522
DJ		 8316 printf (", ");
8317 printf ("r14");
8318 }
8319 printf ("}");
8320 }
8321 else if (op == 0xb0)
8322 printf (_(" finish"));
8323 else if (op == 0xb1)
8324 {
8325 GET_OP (op2);
8326 if (op2 == 0 || (op2 & 0xf0) != 0)
8327 printf (_("[Spare]"));
8328 else
8329 {
8330 unsigned int mask = op2 & 0x0f;
32ec8896 8331 bfd_boolean first = TRUE;
0b6ae522 8332 int i;
61865e30 8333
0b6ae522
DJ		 8334 printf ("pop {");
8335 for (i = 0; i < 12; i++)
8336 if (mask & (1 << i))
8337 {
8338 if (first)
32ec8896 8339 first = FALSE;
0b6ae522
DJ		 8340 else
8341 printf (", ");
8342 printf ("r%d", i);
8343 }
8344 printf ("}");
8345 }
8346 }
8347 else if (op == 0xb2)
8348 {
b115cf96 8349 unsigned char buf[9];
0b6ae522
DJ		 8350 unsigned int i, len;
8351 unsigned long offset;
61865e30 8352
b115cf96 8353 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 8354 {
8355 GET_OP (buf[i]);
8356 if ((buf[i] & 0x80) == 0)
8357 break;
8358 }
4082ef84 8359 if (i == sizeof (buf))
32ec8896
NC		 8360 {
8361 error (_("corrupt change to vsp"));
8362 res = FALSE;
8363 }
4082ef84
NC		 8364 else
8365 {
8366 offset = read_uleb128 (buf, &len, buf + i + 1);
8367 assert (len == i + 1);
8368 offset = offset * 4 + 0x204;
8369 printf ("vsp = vsp + %ld", offset);
8370 }
0b6ae522 8371 }
61865e30 8372 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 8373 {
61865e30
NC		 8374 unsigned int first, last;
8375
8376 GET_OP (op2);
8377 first = op2 >> 4;
8378 last = op2 & 0x0f;
8379 if (op == 0xc8)
8380 first = first + 16;
8381 printf ("pop {D%d", first);
8382 if (last)
8383 printf ("-D%d", first + last);
8384 printf ("}");
8385 }
8386 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8387 {
8388 unsigned int count = op & 0x07;
8389
8390 printf ("pop {D8");
8391 if (count)
8392 printf ("-D%d", 8 + count);
8393 printf ("}");
8394 }
8395 else if (op >= 0xc0 && op <= 0xc5)
8396 {
8397 unsigned int count = op & 0x07;
8398
8399 printf (" pop {wR10");
8400 if (count)
8401 printf ("-wR%d", 10 + count);
8402 printf ("}");
8403 }
8404 else if (op == 0xc6)
8405 {
8406 unsigned int first, last;
8407
8408 GET_OP (op2);
8409 first = op2 >> 4;
8410 last = op2 & 0x0f;
8411 printf ("pop {wR%d", first);
8412 if (last)
8413 printf ("-wR%d", first + last);
8414 printf ("}");
8415 }
8416 else if (op == 0xc7)
8417 {
8418 GET_OP (op2);
8419 if (op2 == 0 || (op2 & 0xf0) != 0)
8420 printf (_("[Spare]"));
0b6ae522
DJ		 8421 else
8422 {
61865e30 8423 unsigned int mask = op2 & 0x0f;
32ec8896 8424 bfd_boolean first = TRUE;
61865e30
NC		 8425 int i;
8426
8427 printf ("pop {");
8428 for (i = 0; i < 4; i++)
8429 if (mask & (1 << i))
8430 {
8431 if (first)
32ec8896 8432 first = FALSE;
61865e30
NC		 8433 else
8434 printf (", ");
8435 printf ("wCGR%d", i);
8436 }
8437 printf ("}");
0b6ae522
DJ		 8438 }
8439 }
61865e30 8440 else
32ec8896
NC		 8441 {
8442 printf (_(" [unsupported opcode]"));
8443 res = FALSE;
8444 }
8445
0b6ae522
DJ		 8446 printf ("\n");
8447 }
32ec8896
NC		 8448
8449 return res;
fa197c1c
PB		 8450}
8451
32ec8896 8452static bfd_boolean
948f632f
DA		 8453decode_tic6x_unwind_bytecode (struct arm_unw_aux_info * aux,
8454 unsigned int word,
8455 unsigned int remaining,
8456 unsigned int more_words,
8457 bfd_vma data_offset,
8458 Elf_Internal_Shdr * data_sec,
8459 struct arm_section * data_arm_sec)
fa197c1c
PB		 8460{
8461 struct absaddr addr;
8462
8463 /* Decode the unwinding instructions. */
8464 while (1)
8465 {
8466 unsigned int op, op2;
8467
8468 ADVANCE;
8469 if (remaining == 0)
8470 break;
8471 remaining--;
8472 op = word >> 24;
8473 word <<= 8;
8474
9cf03b7e 8475 printf (" 0x%02x ", op);
fa197c1c
PB		 8476
8477 if ((op & 0xc0) == 0x00)
8478 {
8479 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 8480 printf (" sp = sp + %d", offset);
fa197c1c
PB		 8481 }
8482 else if ((op & 0xc0) == 0x80)
8483 {
8484 GET_OP (op2);
8485 if (op == 0x80 && op2 == 0)
8486 printf (_("Refuse to unwind"));
8487 else
8488 {
8489 unsigned int mask = ((op & 0x1f) << 8) | op2;
8490 if (op & 0x20)
8491 printf ("pop compact {");
8492 else
8493 printf ("pop {");
8494
8495 decode_tic6x_unwind_regmask (mask);
8496 printf("}");
8497 }
8498 }
8499 else if ((op & 0xf0) == 0xc0)
8500 {
8501 unsigned int reg;
8502 unsigned int nregs;
8503 unsigned int i;
8504 const char *name;
a734115a
NC		 8505 struct
8506 {
32ec8896
NC		 8507 unsigned int offset;
8508 unsigned int reg;
fa197c1c
PB		 8509 } regpos[16];
8510
8511 /* Scan entire instruction first so that GET_OP output is not
8512 interleaved with disassembly. */
8513 nregs = 0;
8514 for (i = 0; nregs < (op & 0xf); i++)
8515 {
8516 GET_OP (op2);
8517 reg = op2 >> 4;
8518 if (reg != 0xf)
8519 {
8520 regpos[nregs].offset = i * 2;
8521 regpos[nregs].reg = reg;
8522 nregs++;
8523 }
8524
8525 reg = op2 & 0xf;
8526 if (reg != 0xf)
8527 {
8528 regpos[nregs].offset = i * 2 + 1;
8529 regpos[nregs].reg = reg;
8530 nregs++;
8531 }
8532 }
8533
8534 printf (_("pop frame {"));
8535 reg = nregs - 1;
8536 for (i = i * 2; i > 0; i--)
8537 {
8538 if (regpos[reg].offset == i - 1)
8539 {
8540 name = tic6x_unwind_regnames[regpos[reg].reg];
8541 if (reg > 0)
8542 reg--;
8543 }
8544 else
8545 name = _("[pad]");
8546
8547 fputs (name, stdout);
8548 if (i > 1)
8549 printf (", ");
8550 }
8551
8552 printf ("}");
8553 }
8554 else if (op == 0xd0)
8555 printf (" MOV FP, SP");
8556 else if (op == 0xd1)
8557 printf (" __c6xabi_pop_rts");
8558 else if (op == 0xd2)
8559 {
8560 unsigned char buf[9];
8561 unsigned int i, len;
8562 unsigned long offset;
a734115a 8563
fa197c1c
PB		 8564 for (i = 0; i < sizeof (buf); i++)
8565 {
8566 GET_OP (buf[i]);
8567 if ((buf[i] & 0x80) == 0)
8568 break;
8569 }
0eff7165
NC		 8570 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8571 if (i == sizeof (buf))
8572 {
0eff7165 8573 warn (_("Corrupt stack pointer adjustment detected\n"));
32ec8896 8574 return FALSE;
0eff7165 8575 }
948f632f 8576
f6f0e17b 8577 offset = read_uleb128 (buf, &len, buf + i + 1);
fa197c1c
PB		 8578 assert (len == i + 1);
8579 offset = offset * 8 + 0x408;
8580 printf (_("sp = sp + %ld"), offset);
8581 }
8582 else if ((op & 0xf0) == 0xe0)
8583 {
8584 if ((op & 0x0f) == 7)
8585 printf (" RETURN");
8586 else
8587 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8588 }
8589 else
8590 {
8591 printf (_(" [unsupported opcode]"));
8592 }
8593 putchar ('\n');
8594 }
32ec8896
NC		 8595
8596 return TRUE;
fa197c1c
PB		 8597}
8598
8599static bfd_vma
a734115a 8600arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 8601{
8602 bfd_vma offset;
8603
8604 offset = word & 0x7fffffff;
8605 if (offset & 0x40000000)
8606 offset |= ~ (bfd_vma) 0x7fffffff;
8607
8608 if (elf_header.e_machine == EM_TI_C6000)
8609 offset <<= 1;
8610
8611 return offset + where;
8612}
8613
32ec8896 8614static bfd_boolean
1b31d05e
NC		 8615decode_arm_unwind (struct arm_unw_aux_info * aux,
8616 unsigned int word,
8617 unsigned int remaining,
8618 bfd_vma data_offset,
8619 Elf_Internal_Shdr * data_sec,
8620 struct arm_section * data_arm_sec)
fa197c1c
PB		 8621{
8622 int per_index;
8623 unsigned int more_words = 0;
37e14bc3 8624 struct absaddr addr;
1b31d05e 8625 bfd_vma sym_name = (bfd_vma) -1;
32ec8896 8626 bfd_boolean res = FALSE;
fa197c1c
PB		 8627
8628 if (remaining == 0)
8629 {
1b31d05e
NC		 8630 /* Fetch the first word.
8631 Note - when decoding an object file the address extracted
8632 here will always be 0. So we also pass in the sym_name
8633 parameter so that we can find the symbol associated with
8634 the personality routine. */
8635 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8636 & word, & addr, & sym_name))
32ec8896 8637 return FALSE;
1b31d05e 8638
fa197c1c
PB		 8639 remaining = 4;
8640 }
8641
8642 if ((word & 0x80000000) == 0)
8643 {
8644 /* Expand prel31 for personality routine. */
8645 bfd_vma fn;
8646 const char *procname;
8647
a734115a 8648 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 8649 printf (_(" Personality routine: "));
1b31d05e
NC		 8650 if (fn == 0
8651 && addr.section == SHN_UNDEF && addr.offset == 0
8652 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8653 {
8654 procname = aux->strtab + sym_name;
8655 print_vma (fn, PREFIX_HEX);
8656 if (procname)
8657 {
8658 fputs (" <", stdout);
8659 fputs (procname, stdout);
8660 fputc ('>', stdout);
8661 }
8662 }
8663 else
8664 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 8665 fputc ('\n', stdout);
8666
8667 /* The GCC personality routines use the standard compact
8668 encoding, starting with one byte giving the number of
8669 words. */
8670 if (procname != NULL
8671 && (const_strneq (procname, "__gcc_personality_v0")
8672 || const_strneq (procname, "__gxx_personality_v0")
8673 || const_strneq (procname, "__gcj_personality_v0")
8674 || const_strneq (procname, "__gnu_objc_personality_v0")))
8675 {
8676 remaining = 0;
8677 more_words = 1;
8678 ADVANCE;
8679 if (!remaining)
8680 {
8681 printf (_(" [Truncated data]\n"));
32ec8896 8682 return FALSE;
fa197c1c
PB		 8683 }
8684 more_words = word >> 24;
8685 word <<= 8;
8686 remaining--;
8687 per_index = -1;
8688 }
8689 else
32ec8896 8690 return TRUE;
fa197c1c
PB		 8691 }
8692 else
8693 {
1b31d05e 8694 /* ARM EHABI Section 6.3:
0b4362b0 8695
1b31d05e 8696 An exception-handling table entry for the compact model looks like:
0b4362b0 8697
1b31d05e
NC		 8698 31 30-28 27-24 23-0
8699 -- ----- ----- ----
8700 1 0 index Data for personalityRoutine[index] */
8701
8702 if (elf_header.e_machine == EM_ARM
8703 && (word & 0x70000000))
32ec8896
NC		 8704 {
8705 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8706 res = FALSE;
8707 }
1b31d05e 8708
fa197c1c 8709 per_index = (word >> 24) & 0x7f;
1b31d05e 8710 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 8711 if (per_index == 0)
8712 {
8713 more_words = 0;
8714 word <<= 8;
8715 remaining--;
8716 }
8717 else if (per_index < 3)
8718 {
8719 more_words = (word >> 16) & 0xff;
8720 word <<= 16;
8721 remaining -= 2;
8722 }
8723 }
8724
8725 switch (elf_header.e_machine)
8726 {
8727 case EM_ARM:
8728 if (per_index < 3)
8729 {
32ec8896
NC		 8730 if (! decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8731 data_offset, data_sec, data_arm_sec))
8732 res = FALSE;
fa197c1c
PB		 8733 }
8734 else
1b31d05e
NC		 8735 {
8736 warn (_("Unknown ARM compact model index encountered\n"));
8737 printf (_(" [reserved]\n"));
32ec8896 8738 res = FALSE;
1b31d05e 8739 }
fa197c1c
PB		 8740 break;
8741
8742 case EM_TI_C6000:
8743 if (per_index < 3)
8744 {
32ec8896
NC		 8745 if (! decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
8746 data_offset, data_sec, data_arm_sec))
8747 res = FALSE;
fa197c1c
PB		 8748 }
8749 else if (per_index < 5)
8750 {
8751 if (((word >> 17) & 0x7f) == 0x7f)
8752 printf (_(" Restore stack from frame pointer\n"));
8753 else
8754 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
8755 printf (_(" Registers restored: "));
8756 if (per_index == 4)
8757 printf (" (compact) ");
8758 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8759 putchar ('\n');
8760 printf (_(" Return register: %s\n"),
8761 tic6x_unwind_regnames[word & 0xf]);
8762 }
8763 else
1b31d05e 8764 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 8765 break;
8766
8767 default:
74e1a04b 8768 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
1b31d05e 8769 elf_header.e_machine);
32ec8896 8770 res = FALSE;
fa197c1c 8771 }
0b6ae522
DJ		 8772
8773 /* Decode the descriptors. Not implemented. */
32ec8896
NC		 8774
8775 return res;
0b6ae522
DJ		 8776}
8777
32ec8896 8778static bfd_boolean
0b6ae522
DJ		 8779dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8780{
8781 struct arm_section exidx_arm_sec, extab_arm_sec;
8782 unsigned int i, exidx_len;
948f632f 8783 unsigned long j, nfuns;
32ec8896 8784 bfd_boolean res = TRUE;
0b6ae522
DJ		 8785
8786 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8787 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8788 exidx_len = exidx_sec->sh_size / 8;
8789
948f632f
DA		 8790 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8791 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8792 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8793 aux->funtab[nfuns++] = aux->symtab[j];
8794 aux->nfuns = nfuns;
8795 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8796
0b6ae522
DJ		 8797 for (i = 0; i < exidx_len; i++)
8798 {
8799 unsigned int exidx_fn, exidx_entry;
8800 struct absaddr fn_addr, entry_addr;
8801 bfd_vma fn;
8802
8803 fputc ('\n', stdout);
8804
1b31d05e
NC		 8805 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8806 8 * i, & exidx_fn, & fn_addr, NULL)
8807 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8808 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 8809 {
948f632f 8810 free (aux->funtab);
1b31d05e
NC		 8811 arm_free_section (& exidx_arm_sec);
8812 arm_free_section (& extab_arm_sec);
32ec8896 8813 return FALSE;
0b6ae522
DJ		 8814 }
8815
83c257ca
NC		 8816 /* ARM EHABI, Section 5:
8817 An index table entry consists of 2 words.
8818 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8819 if (exidx_fn & 0x80000000)
32ec8896
NC		 8820 {
8821 warn (_("corrupt index table entry: %x\n"), exidx_fn);
8822 res = FALSE;
8823 }
83c257ca 8824
a734115a 8825 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 8826
a734115a 8827 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 8828 fputs (": ", stdout);
8829
8830 if (exidx_entry == 1)
8831 {
8832 print_vma (exidx_entry, PREFIX_HEX);
8833 fputs (" [cantunwind]\n", stdout);
8834 }
8835 else if (exidx_entry & 0x80000000)
8836 {
8837 print_vma (exidx_entry, PREFIX_HEX);
8838 fputc ('\n', stdout);
8839 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8840 }
8841 else
8842 {
8f73510c 8843 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 8844 Elf_Internal_Shdr *table_sec;
8845
8846 fputs ("@", stdout);
a734115a 8847 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 8848 print_vma (table, PREFIX_HEX);
8849 printf ("\n");
8850
8851 /* Locate the matching .ARM.extab. */
8852 if (entry_addr.section != SHN_UNDEF
8853 && entry_addr.section < elf_header.e_shnum)
8854 {
8855 table_sec = section_headers + entry_addr.section;
8856 table_offset = entry_addr.offset;
1a915552
NC		 8857 /* PR 18879 */
8858 if (table_offset > table_sec->sh_size
8859 || ((bfd_signed_vma) table_offset) < 0)
8860 {
8861 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8862 (unsigned long) table_offset,
8863 printable_section_name (table_sec));
32ec8896 8864 res = FALSE;
1a915552
NC		 8865 continue;
8866 }
0b6ae522
DJ		 8867 }
8868 else
8869 {
8870 table_sec = find_section_by_address (table);
8871 if (table_sec != NULL)
8872 table_offset = table - table_sec->sh_addr;
8873 }
32ec8896 8874
0b6ae522
DJ		 8875 if (table_sec == NULL)
8876 {
8877 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8878 (unsigned long) table);
32ec8896 8879 res = FALSE;
0b6ae522
DJ		 8880 continue;
8881 }
32ec8896
NC		 8882
8883 if (! decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8884 &extab_arm_sec))
8885 res = FALSE;
0b6ae522
DJ		 8886 }
8887 }
8888
8889 printf ("\n");
8890
948f632f 8891 free (aux->funtab);
0b6ae522
DJ		 8892 arm_free_section (&exidx_arm_sec);
8893 arm_free_section (&extab_arm_sec);
32ec8896
NC		 8894
8895 return res;
0b6ae522
DJ		 8896}
8897
fa197c1c 8898/* Used for both ARM and C6X unwinding tables. */
1b31d05e 8899
32ec8896 8900static bfd_boolean
0b6ae522
DJ		 8901arm_process_unwind (FILE *file)
8902{
8903 struct arm_unw_aux_info aux;
8904 Elf_Internal_Shdr *unwsec = NULL;
8905 Elf_Internal_Shdr *strsec;
8906 Elf_Internal_Shdr *sec;
8907 unsigned long i;
fa197c1c 8908 unsigned int sec_type;
32ec8896 8909 bfd_boolean res = TRUE;
0b6ae522 8910
fa197c1c
PB		 8911 switch (elf_header.e_machine)
8912 {
8913 case EM_ARM:
8914 sec_type = SHT_ARM_EXIDX;
8915 break;
8916
8917 case EM_TI_C6000:
8918 sec_type = SHT_C6000_UNWIND;
8919 break;
8920
0b4362b0 8921 default:
74e1a04b 8922 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
1b31d05e 8923 elf_header.e_machine);
32ec8896 8924 return FALSE;
fa197c1c
PB		 8925 }
8926
0b6ae522 8927 if (string_table == NULL)
32ec8896 8928 return FALSE;
1b31d05e
NC		 8929
8930 memset (& aux, 0, sizeof (aux));
8931 aux.file = file;
0b6ae522
DJ		 8932
8933 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8934 {
8935 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8936 {
ba5cdace 8937 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 8938
8939 strsec = section_headers + sec->sh_link;
74e1a04b
NC		 8940
8941 /* PR binutils/17531 file: 011-12666-0.004. */
8942 if (aux.strtab != NULL)
8943 {
4082ef84 8944 error (_("Multiple string tables found in file.\n"));
74e1a04b 8945 free (aux.strtab);
32ec8896 8946 res = FALSE;
74e1a04b 8947 }
0b6ae522
DJ		 8948 aux.strtab = get_data (NULL, file, strsec->sh_offset,
8949 1, strsec->sh_size, _("string table"));
8950 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8951 }
fa197c1c 8952 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 8953 unwsec = sec;
8954 }
8955
1b31d05e 8956 if (unwsec == NULL)
0b6ae522 8957 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 8958 else
8959 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8960 {
8961 if (sec->sh_type == sec_type)
8962 {
8963 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
74e1a04b 8964 printable_section_name (sec),
1b31d05e
NC		 8965 (unsigned long) sec->sh_offset,
8966 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 8967
32ec8896
NC		 8968 if (! dump_arm_unwind (&aux, sec))
8969 res = FALSE;
1b31d05e
NC		 8970 }
8971 }
0b6ae522
DJ		 8972
8973 if (aux.symtab)
8974 free (aux.symtab);
8975 if (aux.strtab)
8976 free ((char *) aux.strtab);
32ec8896
NC		 8977
8978 return res;
0b6ae522
DJ		 8979}
8980
32ec8896 8981static bfd_boolean
2cf0635d 8982process_unwind (FILE * file)
57346661 8983{
2cf0635d
NC		 8984 struct unwind_handler
8985 {
32ec8896
NC		 8986 unsigned int machtype;
8987 bfd_boolean (* handler)(FILE *);
2cf0635d
NC		 8988 } handlers[] =
8989 {
0b6ae522 8990 { EM_ARM, arm_process_unwind },
57346661
AM		 8991 { EM_IA_64, ia64_process_unwind },
8992 { EM_PARISC, hppa_process_unwind },
fa197c1c 8993 { EM_TI_C6000, arm_process_unwind },
32ec8896 8994 { 0, NULL }
57346661
AM		 8995 };
8996 int i;
8997
8998 if (!do_unwind)
32ec8896 8999 return TRUE;
57346661
AM		 9000
9001 for (i = 0; handlers[i].handler != NULL; i++)
9002 if (elf_header.e_machine == handlers[i].machtype)
32ec8896 9003 return handlers[i].handler (file);
57346661 9004
1b31d05e
NC		 9005 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9006 get_machine_name (elf_header.e_machine));
32ec8896 9007 return TRUE;
57346661
AM		 9008}
9009
252b5132 9010static void
2cf0635d 9011dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 9012{
9013 switch (entry->d_tag)
9014 {
9015 case DT_MIPS_FLAGS:
9016 if (entry->d_un.d_val == 0)
4b68bca3 9017 printf (_("NONE"));
252b5132
RH		 9018 else
9019 {
9020 static const char * opts[] =
9021 {
9022 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9023 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9024 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9025 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9026 "RLD_ORDER_SAFE"
9027 };
9028 unsigned int cnt;
32ec8896 9029 bfd_boolean first = TRUE;
2b692964 9030
60bca95a 9031 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 9032 if (entry->d_un.d_val & (1 << cnt))
9033 {
9034 printf ("%s%s", first ? "" : " ", opts[cnt]);
32ec8896 9035 first = FALSE;
252b5132 9036 }
252b5132
RH		 9037 }
9038 break;
103f02d3 9039
252b5132 9040 case DT_MIPS_IVERSION:
d79b3d50 9041 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 9042 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 9043 else
76ca31c0
NC		 9044 {
9045 char buf[40];
9046 sprintf_vma (buf, entry->d_un.d_ptr);
9047 /* Note: coded this way so that there is a single string for translation. */
9048 printf (_("<corrupt: %s>"), buf);
9049 }
252b5132 9050 break;
103f02d3 9051
252b5132
RH		 9052 case DT_MIPS_TIME_STAMP:
9053 {
d5b07ef4 9054 char timebuf[128];
2cf0635d 9055 struct tm * tmp;
91d6fa6a 9056 time_t atime = entry->d_un.d_val;
82b1b41b 9057
91d6fa6a 9058 tmp = gmtime (&atime);
82b1b41b
NC		 9059 /* PR 17531: file: 6accc532. */
9060 if (tmp == NULL)
9061 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9062 else
9063 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9064 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9065 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 9066 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 9067 }
9068 break;
103f02d3 9069
252b5132
RH		 9070 case DT_MIPS_RLD_VERSION:
9071 case DT_MIPS_LOCAL_GOTNO:
9072 case DT_MIPS_CONFLICTNO:
9073 case DT_MIPS_LIBLISTNO:
9074 case DT_MIPS_SYMTABNO:
9075 case DT_MIPS_UNREFEXTNO:
9076 case DT_MIPS_HIPAGENO:
9077 case DT_MIPS_DELTA_CLASS_NO:
9078 case DT_MIPS_DELTA_INSTANCE_NO:
9079 case DT_MIPS_DELTA_RELOC_NO:
9080 case DT_MIPS_DELTA_SYM_NO:
9081 case DT_MIPS_DELTA_CLASSSYM_NO:
9082 case DT_MIPS_COMPACT_SIZE:
c69075ac 9083 print_vma (entry->d_un.d_val, DEC);
252b5132 9084 break;
103f02d3
UD		 9085
9086 default:
4b68bca3 9087 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 9088 }
4b68bca3 9089 putchar ('\n');
103f02d3
UD		 9090}
9091
103f02d3 9092static void
2cf0635d 9093dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 9094{
9095 switch (entry->d_tag)
9096 {
9097 case DT_HP_DLD_FLAGS:
9098 {
9099 static struct
9100 {
9101 long int bit;
2cf0635d 9102 const char * str;
5e220199
NC		 9103 }
9104 flags[] =
9105 {
9106 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9107 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9108 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9109 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9110 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9111 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9112 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9113 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9114 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9115 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 9116 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9117 { DT_HP_GST, "HP_GST" },
9118 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9119 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9120 { DT_HP_NODELETE, "HP_NODELETE" },
9121 { DT_HP_GROUP, "HP_GROUP" },
9122 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 9123 };
32ec8896 9124 bfd_boolean first = TRUE;
5e220199 9125 size_t cnt;
f7a99963 9126 bfd_vma val = entry->d_un.d_val;
103f02d3 9127
60bca95a 9128 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 9129 if (val & flags[cnt].bit)
30800947
NC		 9130 {
9131 if (! first)
9132 putchar (' ');
9133 fputs (flags[cnt].str, stdout);
32ec8896 9134 first = FALSE;
30800947
NC		 9135 val ^= flags[cnt].bit;
9136 }
76da6bbe 9137
103f02d3 9138 if (val != 0 || first)
f7a99963
NC		 9139 {
9140 if (! first)
9141 putchar (' ');
9142 print_vma (val, HEX);
9143 }
103f02d3
UD		 9144 }
9145 break;
76da6bbe 9146
252b5132 9147 default:
f7a99963
NC		 9148 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9149 break;
252b5132 9150 }
35b1837e 9151 putchar ('\n');
252b5132
RH		 9152}
9153
28f997cf
TG		 9154#ifdef BFD64
9155
9156/* VMS vs Unix time offset and factor. */
9157
9158#define VMS_EPOCH_OFFSET 35067168000000000LL
9159#define VMS_GRANULARITY_FACTOR 10000000
9160
9161/* Display a VMS time in a human readable format. */
9162
9163static void
9164print_vms_time (bfd_int64_t vmstime)
9165{
9166 struct tm *tm;
9167 time_t unxtime;
9168
9169 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9170 tm = gmtime (&unxtime);
9171 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9172 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9173 tm->tm_hour, tm->tm_min, tm->tm_sec);
9174}
9175#endif /* BFD64 */
9176
ecc51f48 9177static void
2cf0635d 9178dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 9179{
9180 switch (entry->d_tag)
9181 {
0de14b54 9182 case DT_IA_64_PLT_RESERVE:
bdf4d63a 9183 /* First 3 slots reserved. */
ecc51f48
NC		 9184 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9185 printf (" -- ");
9186 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 9187 break;
9188
28f997cf
TG		 9189 case DT_IA_64_VMS_LINKTIME:
9190#ifdef BFD64
9191 print_vms_time (entry->d_un.d_val);
9192#endif
9193 break;
9194
9195 case DT_IA_64_VMS_LNKFLAGS:
9196 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9197 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9198 printf (" CALL_DEBUG");
9199 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9200 printf (" NOP0BUFS");
9201 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9202 printf (" P0IMAGE");
9203 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9204 printf (" MKTHREADS");
9205 if (entry->d_un.d_val & VMS_LF_UPCALLS)
9206 printf (" UPCALLS");
9207 if (entry->d_un.d_val & VMS_LF_IMGSTA)
9208 printf (" IMGSTA");
9209 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9210 printf (" INITIALIZE");
9211 if (entry->d_un.d_val & VMS_LF_MAIN)
9212 printf (" MAIN");
9213 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9214 printf (" EXE_INIT");
9215 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9216 printf (" TBK_IN_IMG");
9217 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9218 printf (" DBG_IN_IMG");
9219 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9220 printf (" TBK_IN_DSF");
9221 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9222 printf (" DBG_IN_DSF");
9223 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9224 printf (" SIGNATURES");
9225 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9226 printf (" REL_SEG_OFF");
9227 break;
9228
bdf4d63a
JJ		 9229 default:
9230 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9231 break;
ecc51f48 9232 }
bdf4d63a 9233 putchar ('\n');
ecc51f48
NC		 9234}
9235
32ec8896 9236static bfd_boolean
2cf0635d 9237get_32bit_dynamic_section (FILE * file)
252b5132 9238{
2cf0635d
NC		 9239 Elf32_External_Dyn * edyn;
9240 Elf32_External_Dyn * ext;
9241 Elf_Internal_Dyn * entry;
103f02d3 9242
3f5e193b
NC		 9243 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
9244 dynamic_size, _("dynamic section"));
a6e9f9df 9245 if (!edyn)
32ec8896 9246 return FALSE;
103f02d3 9247
071436c6
NC		 9248 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9249 might not have the luxury of section headers. Look for the DT_NULL
9250 terminator to determine the number of entries. */
ba2685cc 9251 for (ext = edyn, dynamic_nent = 0;
53c3012c 9252 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
ba2685cc
AM		 9253 ext++)
9254 {
9255 dynamic_nent++;
9256 if (BYTE_GET (ext->d_tag) == DT_NULL)
9257 break;
9258 }
252b5132 9259
3f5e193b
NC		 9260 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9261 sizeof (* entry));
b2d38a17 9262 if (dynamic_section == NULL)
252b5132 9263 {
8b73c356
NC		 9264 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9265 (unsigned long) dynamic_nent);
9ea033b2 9266 free (edyn);
32ec8896 9267 return FALSE;
9ea033b2 9268 }
252b5132 9269
fb514b26 9270 for (ext = edyn, entry = dynamic_section;
ba2685cc 9271 entry < dynamic_section + dynamic_nent;
fb514b26 9272 ext++, entry++)
9ea033b2 9273 {
fb514b26
AM		 9274 entry->d_tag = BYTE_GET (ext->d_tag);
9275 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 9276 }
9277
9ea033b2
NC		 9278 free (edyn);
9279
32ec8896 9280 return TRUE;
9ea033b2
NC		 9281}
9282
32ec8896 9283static bfd_boolean
2cf0635d 9284get_64bit_dynamic_section (FILE * file)
9ea033b2 9285{
2cf0635d
NC		 9286 Elf64_External_Dyn * edyn;
9287 Elf64_External_Dyn * ext;
9288 Elf_Internal_Dyn * entry;
103f02d3 9289
071436c6 9290 /* Read in the data. */
3f5e193b
NC		 9291 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
9292 dynamic_size, _("dynamic section"));
a6e9f9df 9293 if (!edyn)
32ec8896 9294 return FALSE;
103f02d3 9295
071436c6
NC		 9296 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9297 might not have the luxury of section headers. Look for the DT_NULL
9298 terminator to determine the number of entries. */
ba2685cc 9299 for (ext = edyn, dynamic_nent = 0;
53c3012c
AM		 9300 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9301 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
ba2685cc
AM		 9302 ext++)
9303 {
9304 dynamic_nent++;
66543521 9305 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 9306 break;
9307 }
252b5132 9308
3f5e193b
NC		 9309 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9310 sizeof (* entry));
b2d38a17 9311 if (dynamic_section == NULL)
252b5132 9312 {
8b73c356
NC		 9313 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9314 (unsigned long) dynamic_nent);
252b5132 9315 free (edyn);
32ec8896 9316 return FALSE;
252b5132
RH		 9317 }
9318
071436c6 9319 /* Convert from external to internal formats. */
fb514b26 9320 for (ext = edyn, entry = dynamic_section;
ba2685cc 9321 entry < dynamic_section + dynamic_nent;
fb514b26 9322 ext++, entry++)
252b5132 9323 {
66543521
AM		 9324 entry->d_tag = BYTE_GET (ext->d_tag);
9325 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 9326 }
9327
9328 free (edyn);
9329
32ec8896 9330 return TRUE;
9ea033b2
NC		 9331}
9332
e9e44622
JJ		 9333static void
9334print_dynamic_flags (bfd_vma flags)
d1133906 9335{
32ec8896 9336 bfd_boolean first = TRUE;
13ae64f3 9337
d1133906
NC		 9338 while (flags)
9339 {
9340 bfd_vma flag;
9341
9342 flag = flags & - flags;
9343 flags &= ~ flag;
9344
e9e44622 9345 if (first)
32ec8896 9346 first = FALSE;
e9e44622
JJ		 9347 else
9348 putc (' ', stdout);
13ae64f3 9349
d1133906
NC		 9350 switch (flag)
9351 {
e9e44622
JJ		 9352 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
9353 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
9354 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
9355 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
9356 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 9357 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 9358 }
9359 }
e9e44622 9360 puts ("");
d1133906
NC		 9361}
9362
b2d38a17
NC		 9363/* Parse and display the contents of the dynamic section. */
9364
32ec8896 9365static bfd_boolean
2cf0635d 9366process_dynamic_section (FILE * file)
9ea033b2 9367{
2cf0635d 9368 Elf_Internal_Dyn * entry;
9ea033b2
NC		 9369
9370 if (dynamic_size == 0)
9371 {
9372 if (do_dynamic)
b2d38a17 9373 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2 9374
32ec8896 9375 return TRUE;
9ea033b2
NC		 9376 }
9377
9378 if (is_32bit_elf)
9379 {
b2d38a17 9380 if (! get_32bit_dynamic_section (file))
32ec8896
NC		 9381 return FALSE;
9382 }
9383 else
9384 {
9385 if (! get_64bit_dynamic_section (file))
9386 return FALSE;
9ea033b2 9387 }
9ea033b2 9388
252b5132
RH		 9389 /* Find the appropriate symbol table. */
9390 if (dynamic_symbols == NULL)
9391 {
86dba8ee
AM		 9392 for (entry = dynamic_section;
9393 entry < dynamic_section + dynamic_nent;
9394 ++entry)
252b5132 9395 {
c8286bd1 9396 Elf_Internal_Shdr section;
252b5132
RH		 9397
9398 if (entry->d_tag != DT_SYMTAB)
9399 continue;
9400
9401 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9402
9403 /* Since we do not know how big the symbol table is,
9404 we default to reading in the entire file (!) and
9405 processing that. This is overkill, I know, but it
e3c8793a 9406 should work. */
d93f0186 9407 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 9408
fb52b2f4
NC		 9409 if (archive_file_offset != 0)
9410 section.sh_size = archive_file_size - section.sh_offset;
9411 else
9412 {
9413 if (fseek (file, 0, SEEK_END))
591a748a 9414 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 9415
9416 section.sh_size = ftell (file) - section.sh_offset;
9417 }
252b5132 9418
9ea033b2 9419 if (is_32bit_elf)
9ad5cbcf 9420 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 9421 else
9ad5cbcf 9422 section.sh_entsize = sizeof (Elf64_External_Sym);
071436c6 9423 section.sh_name = string_table_length;
252b5132 9424
ba5cdace 9425 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 9426 if (num_dynamic_syms < 1)
252b5132
RH		 9427 {
9428 error (_("Unable to determine the number of symbols to load\n"));
9429 continue;
9430 }
252b5132
RH		 9431 }
9432 }
9433
9434 /* Similarly find a string table. */
9435 if (dynamic_strings == NULL)
9436 {
86dba8ee
AM		 9437 for (entry = dynamic_section;
9438 entry < dynamic_section + dynamic_nent;
9439 ++entry)
252b5132
RH		 9440 {
9441 unsigned long offset;
b34976b6 9442 long str_tab_len;
252b5132
RH		 9443
9444 if (entry->d_tag != DT_STRTAB)
9445 continue;
9446
9447 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9448
9449 /* Since we do not know how big the string table is,
9450 we default to reading in the entire file (!) and
9451 processing that. This is overkill, I know, but it
e3c8793a 9452 should work. */
252b5132 9453
d93f0186 9454 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 9455
9456 if (archive_file_offset != 0)
9457 str_tab_len = archive_file_size - offset;
9458 else
9459 {
9460 if (fseek (file, 0, SEEK_END))
9461 error (_("Unable to seek to end of file\n"));
9462 str_tab_len = ftell (file) - offset;
9463 }
252b5132
RH		 9464
9465 if (str_tab_len < 1)
9466 {
9467 error
9468 (_("Unable to determine the length of the dynamic string table\n"));
9469 continue;
9470 }
9471
3f5e193b
NC		 9472 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
9473 str_tab_len,
9474 _("dynamic string table"));
59245841 9475 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 9476 break;
9477 }
9478 }
9479
9480 /* And find the syminfo section if available. */
9481 if (dynamic_syminfo == NULL)
9482 {
3e8bba36 9483 unsigned long syminsz = 0;
252b5132 9484
86dba8ee
AM		 9485 for (entry = dynamic_section;
9486 entry < dynamic_section + dynamic_nent;
9487 ++entry)
252b5132
RH		 9488 {
9489 if (entry->d_tag == DT_SYMINENT)
9490 {
9491 /* Note: these braces are necessary to avoid a syntax
9492 error from the SunOS4 C compiler. */
049b0c3a
NC		 9493 /* PR binutils/17531: A corrupt file can trigger this test.
9494 So do not use an assert, instead generate an error message. */
9495 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
071436c6 9496 error (_("Bad value (%d) for SYMINENT entry\n"),
049b0c3a 9497 (int) entry->d_un.d_val);
252b5132
RH		 9498 }
9499 else if (entry->d_tag == DT_SYMINSZ)
9500 syminsz = entry->d_un.d_val;
9501 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 9502 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
9503 syminsz);
252b5132
RH		 9504 }
9505
9506 if (dynamic_syminfo_offset != 0 && syminsz != 0)
9507 {
2cf0635d
NC		 9508 Elf_External_Syminfo * extsyminfo;
9509 Elf_External_Syminfo * extsym;
9510 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 9511
9512 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 9513 extsyminfo = (Elf_External_Syminfo *)
9514 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
9515 _("symbol information"));
a6e9f9df 9516 if (!extsyminfo)
32ec8896 9517 return FALSE;
252b5132 9518
3f5e193b 9519 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 9520 if (dynamic_syminfo == NULL)
9521 {
8b73c356
NC		 9522 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9523 (unsigned long) syminsz);
32ec8896 9524 return FALSE;
252b5132
RH		 9525 }
9526
9527 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 9528 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9529 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9530 ++syminfo, ++extsym)
252b5132 9531 {
86dba8ee
AM		 9532 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9533 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 9534 }
9535
9536 free (extsyminfo);
9537 }
9538 }
9539
9540 if (do_dynamic && dynamic_addr)
8b73c356
NC		 9541 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9542 dynamic_addr, (unsigned long) dynamic_nent);
252b5132
RH		 9543 if (do_dynamic)
9544 printf (_(" Tag Type Name/Value\n"));
9545
86dba8ee
AM		 9546 for (entry = dynamic_section;
9547 entry < dynamic_section + dynamic_nent;
9548 entry++)
252b5132
RH		 9549 {
9550 if (do_dynamic)
f7a99963 9551 {
2cf0635d 9552 const char * dtype;
e699b9ff 9553
f7a99963
NC		 9554 putchar (' ');
9555 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 9556 dtype = get_dynamic_type (entry->d_tag);
9557 printf (" (%s)%*s", dtype,
32ec8896 9558 ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
f7a99963 9559 }
252b5132
RH		 9560
9561 switch (entry->d_tag)
9562 {
d1133906
NC		 9563 case DT_FLAGS:
9564 if (do_dynamic)
e9e44622 9565 print_dynamic_flags (entry->d_un.d_val);
d1133906 9566 break;
76da6bbe 9567
252b5132
RH		 9568 case DT_AUXILIARY:
9569 case DT_FILTER:
019148e4
L		 9570 case DT_CONFIG:
9571 case DT_DEPAUDIT:
9572 case DT_AUDIT:
252b5132
RH		 9573 if (do_dynamic)
9574 {
019148e4 9575 switch (entry->d_tag)
b34976b6 9576 {
019148e4
L		 9577 case DT_AUXILIARY:
9578 printf (_("Auxiliary library"));
9579 break;
9580
9581 case DT_FILTER:
9582 printf (_("Filter library"));
9583 break;
9584
b34976b6 9585 case DT_CONFIG:
019148e4
L		 9586 printf (_("Configuration file"));
9587 break;
9588
9589 case DT_DEPAUDIT:
9590 printf (_("Dependency audit library"));
9591 break;
9592
9593 case DT_AUDIT:
9594 printf (_("Audit library"));
9595 break;
9596 }
252b5132 9597
d79b3d50
NC		 9598 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9599 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 9600 else
f7a99963
NC		 9601 {
9602 printf (": ");
9603 print_vma (entry->d_un.d_val, PREFIX_HEX);
9604 putchar ('\n');
9605 }
252b5132
RH		 9606 }
9607 break;
9608
dcefbbbd 9609 case DT_FEATURE:
252b5132
RH		 9610 if (do_dynamic)
9611 {
9612 printf (_("Flags:"));
86f55779 9613
252b5132
RH		 9614 if (entry->d_un.d_val == 0)
9615 printf (_(" None\n"));
9616 else
9617 {
9618 unsigned long int val = entry->d_un.d_val;
86f55779 9619
252b5132
RH		 9620 if (val & DTF_1_PARINIT)
9621 {
9622 printf (" PARINIT");
9623 val ^= DTF_1_PARINIT;
9624 }
dcefbbbd
L		 9625 if (val & DTF_1_CONFEXP)
9626 {
9627 printf (" CONFEXP");
9628 val ^= DTF_1_CONFEXP;
9629 }
252b5132
RH		 9630 if (val != 0)
9631 printf (" %lx", val);
9632 puts ("");
9633 }
9634 }
9635 break;
9636
9637 case DT_POSFLAG_1:
9638 if (do_dynamic)
9639 {
9640 printf (_("Flags:"));
86f55779 9641
252b5132
RH		 9642 if (entry->d_un.d_val == 0)
9643 printf (_(" None\n"));
9644 else
9645 {
9646 unsigned long int val = entry->d_un.d_val;
86f55779 9647
252b5132
RH		 9648 if (val & DF_P1_LAZYLOAD)
9649 {
9650 printf (" LAZYLOAD");
9651 val ^= DF_P1_LAZYLOAD;
9652 }
9653 if (val & DF_P1_GROUPPERM)
9654 {
9655 printf (" GROUPPERM");
9656 val ^= DF_P1_GROUPPERM;
9657 }
9658 if (val != 0)
9659 printf (" %lx", val);
9660 puts ("");
9661 }
9662 }
9663 break;
9664
9665 case DT_FLAGS_1:
9666 if (do_dynamic)
9667 {
9668 printf (_("Flags:"));
9669 if (entry->d_un.d_val == 0)
9670 printf (_(" None\n"));
9671 else
9672 {
9673 unsigned long int val = entry->d_un.d_val;
86f55779 9674
252b5132
RH		 9675 if (val & DF_1_NOW)
9676 {
9677 printf (" NOW");
9678 val ^= DF_1_NOW;
9679 }
9680 if (val & DF_1_GLOBAL)
9681 {
9682 printf (" GLOBAL");
9683 val ^= DF_1_GLOBAL;
9684 }
9685 if (val & DF_1_GROUP)
9686 {
9687 printf (" GROUP");
9688 val ^= DF_1_GROUP;
9689 }
9690 if (val & DF_1_NODELETE)
9691 {
9692 printf (" NODELETE");
9693 val ^= DF_1_NODELETE;
9694 }
9695 if (val & DF_1_LOADFLTR)
9696 {
9697 printf (" LOADFLTR");
9698 val ^= DF_1_LOADFLTR;
9699 }
9700 if (val & DF_1_INITFIRST)
9701 {
9702 printf (" INITFIRST");
9703 val ^= DF_1_INITFIRST;
9704 }
9705 if (val & DF_1_NOOPEN)
9706 {
9707 printf (" NOOPEN");
9708 val ^= DF_1_NOOPEN;
9709 }
9710 if (val & DF_1_ORIGIN)
9711 {
9712 printf (" ORIGIN");
9713 val ^= DF_1_ORIGIN;
9714 }
9715 if (val & DF_1_DIRECT)
9716 {
9717 printf (" DIRECT");
9718 val ^= DF_1_DIRECT;
9719 }
9720 if (val & DF_1_TRANS)
9721 {
9722 printf (" TRANS");
9723 val ^= DF_1_TRANS;
9724 }
9725 if (val & DF_1_INTERPOSE)
9726 {
9727 printf (" INTERPOSE");
9728 val ^= DF_1_INTERPOSE;
9729 }
f7db6139 9730 if (val & DF_1_NODEFLIB)
dcefbbbd 9731 {
f7db6139
L		 9732 printf (" NODEFLIB");
9733 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 9734 }
9735 if (val & DF_1_NODUMP)
9736 {
9737 printf (" NODUMP");
9738 val ^= DF_1_NODUMP;
9739 }
34b60028 9740 if (val & DF_1_CONFALT)
dcefbbbd 9741 {
34b60028
L		 9742 printf (" CONFALT");
9743 val ^= DF_1_CONFALT;
9744 }
9745 if (val & DF_1_ENDFILTEE)
9746 {
9747 printf (" ENDFILTEE");
9748 val ^= DF_1_ENDFILTEE;
9749 }
9750 if (val & DF_1_DISPRELDNE)
9751 {
9752 printf (" DISPRELDNE");
9753 val ^= DF_1_DISPRELDNE;
9754 }
9755 if (val & DF_1_DISPRELPND)
9756 {
9757 printf (" DISPRELPND");
9758 val ^= DF_1_DISPRELPND;
9759 }
9760 if (val & DF_1_NODIRECT)
9761 {
9762 printf (" NODIRECT");
9763 val ^= DF_1_NODIRECT;
9764 }
9765 if (val & DF_1_IGNMULDEF)
9766 {
9767 printf (" IGNMULDEF");
9768 val ^= DF_1_IGNMULDEF;
9769 }
9770 if (val & DF_1_NOKSYMS)
9771 {
9772 printf (" NOKSYMS");
9773 val ^= DF_1_NOKSYMS;
9774 }
9775 if (val & DF_1_NOHDR)
9776 {
9777 printf (" NOHDR");
9778 val ^= DF_1_NOHDR;
9779 }
9780 if (val & DF_1_EDITED)
9781 {
9782 printf (" EDITED");
9783 val ^= DF_1_EDITED;
9784 }
9785 if (val & DF_1_NORELOC)
9786 {
9787 printf (" NORELOC");
9788 val ^= DF_1_NORELOC;
9789 }
9790 if (val & DF_1_SYMINTPOSE)
9791 {
9792 printf (" SYMINTPOSE");
9793 val ^= DF_1_SYMINTPOSE;
9794 }
9795 if (val & DF_1_GLOBAUDIT)
9796 {
9797 printf (" GLOBAUDIT");
9798 val ^= DF_1_GLOBAUDIT;
9799 }
9800 if (val & DF_1_SINGLETON)
9801 {
9802 printf (" SINGLETON");
9803 val ^= DF_1_SINGLETON;
dcefbbbd 9804 }
5c383f02
RO		 9805 if (val & DF_1_STUB)
9806 {
9807 printf (" STUB");
9808 val ^= DF_1_STUB;
9809 }
9810 if (val & DF_1_PIE)
9811 {
9812 printf (" PIE");
9813 val ^= DF_1_PIE;
9814 }
252b5132
RH		 9815 if (val != 0)
9816 printf (" %lx", val);
9817 puts ("");
9818 }
9819 }
9820 break;
9821
9822 case DT_PLTREL:
566b0d53 9823 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9824 if (do_dynamic)
9825 puts (get_dynamic_type (entry->d_un.d_val));
9826 break;
9827
9828 case DT_NULL :
9829 case DT_NEEDED :
9830 case DT_PLTGOT :
9831 case DT_HASH :
9832 case DT_STRTAB :
9833 case DT_SYMTAB :
9834 case DT_RELA :
9835 case DT_INIT :
9836 case DT_FINI :
9837 case DT_SONAME :
9838 case DT_RPATH :
9839 case DT_SYMBOLIC:
9840 case DT_REL :
9841 case DT_DEBUG :
9842 case DT_TEXTREL :
9843 case DT_JMPREL :
019148e4 9844 case DT_RUNPATH :
252b5132
RH		 9845 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9846
9847 if (do_dynamic)
9848 {
2cf0635d 9849 char * name;
252b5132 9850
d79b3d50
NC		 9851 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9852 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9853 else
d79b3d50 9854 name = NULL;
252b5132
RH		 9855
9856 if (name)
9857 {
9858 switch (entry->d_tag)
9859 {
9860 case DT_NEEDED:
9861 printf (_("Shared library: [%s]"), name);
9862
18bd398b 9863 if (streq (name, program_interpreter))
f7a99963 9864 printf (_(" program interpreter"));
252b5132
RH		 9865 break;
9866
9867 case DT_SONAME:
f7a99963 9868 printf (_("Library soname: [%s]"), name);
252b5132
RH		 9869 break;
9870
9871 case DT_RPATH:
f7a99963 9872 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 9873 break;
9874
019148e4
L		 9875 case DT_RUNPATH:
9876 printf (_("Library runpath: [%s]"), name);
9877 break;
9878
252b5132 9879 default:
f7a99963
NC		 9880 print_vma (entry->d_un.d_val, PREFIX_HEX);
9881 break;
252b5132
RH		 9882 }
9883 }
9884 else
f7a99963
NC		 9885 print_vma (entry->d_un.d_val, PREFIX_HEX);
9886
9887 putchar ('\n');
252b5132
RH		 9888 }
9889 break;
9890
9891 case DT_PLTRELSZ:
9892 case DT_RELASZ :
9893 case DT_STRSZ :
9894 case DT_RELSZ :
9895 case DT_RELAENT :
9896 case DT_SYMENT :
9897 case DT_RELENT :
566b0d53 9898 dynamic_info[entry->d_tag] = entry->d_un.d_val;
1a0670f3 9899 /* Fall through. */
252b5132
RH		 9900 case DT_PLTPADSZ:
9901 case DT_MOVEENT :
9902 case DT_MOVESZ :
9903 case DT_INIT_ARRAYSZ:
9904 case DT_FINI_ARRAYSZ:
047b2264
JJ		 9905 case DT_GNU_CONFLICTSZ:
9906 case DT_GNU_LIBLISTSZ:
252b5132 9907 if (do_dynamic)
f7a99963
NC		 9908 {
9909 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 9910 printf (_(" (bytes)\n"));
f7a99963 9911 }
252b5132
RH		 9912 break;
9913
9914 case DT_VERDEFNUM:
9915 case DT_VERNEEDNUM:
9916 case DT_RELACOUNT:
9917 case DT_RELCOUNT:
9918 if (do_dynamic)
f7a99963
NC		 9919 {
9920 print_vma (entry->d_un.d_val, UNSIGNED);
9921 putchar ('\n');
9922 }
252b5132
RH		 9923 break;
9924
9925 case DT_SYMINSZ:
9926 case DT_SYMINENT:
9927 case DT_SYMINFO:
9928 case DT_USED:
9929 case DT_INIT_ARRAY:
9930 case DT_FINI_ARRAY:
9931 if (do_dynamic)
9932 {
d79b3d50
NC		 9933 if (entry->d_tag == DT_USED
9934 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 9935 {
2cf0635d 9936 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9937
b34976b6 9938 if (*name)
252b5132
RH		 9939 {
9940 printf (_("Not needed object: [%s]\n"), name);
9941 break;
9942 }
9943 }
103f02d3 9944
f7a99963
NC		 9945 print_vma (entry->d_un.d_val, PREFIX_HEX);
9946 putchar ('\n');
252b5132
RH		 9947 }
9948 break;
9949
9950 case DT_BIND_NOW:
9951 /* The value of this entry is ignored. */
35b1837e
AM		 9952 if (do_dynamic)
9953 putchar ('\n');
252b5132 9954 break;
103f02d3 9955
047b2264
JJ		 9956 case DT_GNU_PRELINKED:
9957 if (do_dynamic)
9958 {
2cf0635d 9959 struct tm * tmp;
91d6fa6a 9960 time_t atime = entry->d_un.d_val;
047b2264 9961
91d6fa6a 9962 tmp = gmtime (&atime);
071436c6
NC		 9963 /* PR 17533 file: 041-1244816-0.004. */
9964 if (tmp == NULL)
5a2cbcf4
L		 9965 printf (_("<corrupt time val: %lx"),
9966 (unsigned long) atime);
071436c6
NC		 9967 else
9968 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9969 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9970 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 9971
9972 }
9973 break;
9974
fdc90cb4
JJ		 9975 case DT_GNU_HASH:
9976 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9977 if (do_dynamic)
9978 {
9979 print_vma (entry->d_un.d_val, PREFIX_HEX);
9980 putchar ('\n');
9981 }
9982 break;
9983
252b5132
RH		 9984 default:
9985 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 9986 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 9987 entry->d_un.d_val;
9988
9989 if (do_dynamic)
9990 {
9991 switch (elf_header.e_machine)
9992 {
9993 case EM_MIPS:
4fe85591 9994 case EM_MIPS_RS3_LE:
b2d38a17 9995 dynamic_section_mips_val (entry);
252b5132 9996 break;
103f02d3 9997 case EM_PARISC:
b2d38a17 9998 dynamic_section_parisc_val (entry);
103f02d3 9999 break;
ecc51f48 10000 case EM_IA_64:
b2d38a17 10001 dynamic_section_ia64_val (entry);
ecc51f48 10002 break;
252b5132 10003 default:
f7a99963
NC		 10004 print_vma (entry->d_un.d_val, PREFIX_HEX);
10005 putchar ('\n');
252b5132
RH		 10006 }
10007 }
10008 break;
10009 }
10010 }
10011
32ec8896 10012 return TRUE;
252b5132
RH		 10013}
10014
10015static char *
d3ba0551 10016get_ver_flags (unsigned int flags)
252b5132 10017{
b34976b6 10018 static char buff[32];
252b5132
RH		 10019
10020 buff[0] = 0;
10021
10022 if (flags == 0)
10023 return _("none");
10024
10025 if (flags & VER_FLG_BASE)
7bb1ad17 10026 strcat (buff, "BASE");
252b5132
RH		 10027
10028 if (flags & VER_FLG_WEAK)
10029 {
10030 if (flags & VER_FLG_BASE)
7bb1ad17 10031 strcat (buff, " | ");
252b5132 10032
7bb1ad17 10033 strcat (buff, "WEAK");
252b5132
RH		 10034 }
10035
44ec90b9
RO		 10036 if (flags & VER_FLG_INFO)
10037 {
10038 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
7bb1ad17 10039 strcat (buff, " | ");
44ec90b9 10040
7bb1ad17 10041 strcat (buff, "INFO");
44ec90b9
RO		 10042 }
10043
10044 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
7bb1ad17
MR		 10045 {
10046 if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10047 strcat (buff, " | ");
10048
10049 strcat (buff, _("<unknown>"));
10050 }
252b5132
RH		 10051
10052 return buff;
10053}
10054
10055/* Display the contents of the version sections. */
98fb390a 10056
32ec8896 10057static bfd_boolean
2cf0635d 10058process_version_sections (FILE * file)
252b5132 10059{
2cf0635d 10060 Elf_Internal_Shdr * section;
b34976b6 10061 unsigned i;
32ec8896 10062 bfd_boolean found = FALSE;
252b5132
RH		 10063
10064 if (! do_version)
32ec8896 10065 return TRUE;
252b5132
RH		 10066
10067 for (i = 0, section = section_headers;
10068 i < elf_header.e_shnum;
b34976b6 10069 i++, section++)
252b5132
RH		 10070 {
10071 switch (section->sh_type)
10072 {
10073 case SHT_GNU_verdef:
10074 {
2cf0635d 10075 Elf_External_Verdef * edefs;
b34976b6
AM		 10076 unsigned int idx;
10077 unsigned int cnt;
c9f02c3e 10078 unsigned int end;
2cf0635d 10079 char * endbuf;
252b5132 10080
32ec8896 10081 found = TRUE;
252b5132 10082
74e1a04b
NC		 10083 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
10084 printable_section_name (section),
10085 section->sh_info);
252b5132
RH		 10086
10087 printf (_(" Addr: 0x"));
10088 printf_vma (section->sh_addr);
233f82cf 10089 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 10090 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 10091 printable_section_name_from_index (section->sh_link));
252b5132 10092
3f5e193b
NC		 10093 edefs = (Elf_External_Verdef *)
10094 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
10095 _("version definition section"));
a6e9f9df
AM		 10096 if (!edefs)
10097 break;
59245841 10098 endbuf = (char *) edefs + section->sh_size;
252b5132 10099
c9f02c3e
MR		 10100 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
10101 end = (section->sh_info < section->sh_size
10102 ? section->sh_info : section->sh_size);
10103 for (idx = cnt = 0; cnt < end; ++cnt)
252b5132 10104 {
2cf0635d
NC		 10105 char * vstart;
10106 Elf_External_Verdef * edef;
b34976b6 10107 Elf_Internal_Verdef ent;
2cf0635d 10108 Elf_External_Verdaux * eaux;
b34976b6 10109 Elf_Internal_Verdaux aux;
5235cd68 10110 unsigned int isum;
b34976b6 10111 int j;
103f02d3 10112
222c2bf0 10113 /* Check for very large indices. */
7e26601c 10114 if (idx > (size_t) (endbuf - (char *) edefs))
dd24e3da
NC		 10115 break;
10116
252b5132 10117 vstart = ((char *) edefs) + idx;
54806181
AM		 10118 if (vstart + sizeof (*edef) > endbuf)
10119 break;
252b5132
RH		 10120
10121 edef = (Elf_External_Verdef *) vstart;
10122
10123 ent.vd_version = BYTE_GET (edef->vd_version);
10124 ent.vd_flags = BYTE_GET (edef->vd_flags);
10125 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
10126 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
10127 ent.vd_hash = BYTE_GET (edef->vd_hash);
10128 ent.vd_aux = BYTE_GET (edef->vd_aux);
10129 ent.vd_next = BYTE_GET (edef->vd_next);
10130
10131 printf (_(" %#06x: Rev: %d Flags: %s"),
10132 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10133
10134 printf (_(" Index: %d Cnt: %d "),
10135 ent.vd_ndx, ent.vd_cnt);
10136
dd24e3da 10137 /* Check for overflow. */
4aeb00ad 10138 if (ent.vd_aux + sizeof (* eaux) > (size_t) (endbuf - vstart))
dd24e3da
NC		 10139 break;
10140
252b5132
RH		 10141 vstart += ent.vd_aux;
10142
10143 eaux = (Elf_External_Verdaux *) vstart;
10144
10145 aux.vda_name = BYTE_GET (eaux->vda_name);
10146 aux.vda_next = BYTE_GET (eaux->vda_next);
10147
d79b3d50
NC		 10148 if (VALID_DYNAMIC_NAME (aux.vda_name))
10149 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 10150 else
10151 printf (_("Name index: %ld\n"), aux.vda_name);
10152
10153 isum = idx + ent.vd_aux;
10154
b34976b6 10155 for (j = 1; j < ent.vd_cnt; j++)
252b5132 10156 {
dd24e3da 10157 /* Check for overflow. */
7e26601c 10158 if (aux.vda_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 10159 break;
10160
252b5132
RH		 10161 isum += aux.vda_next;
10162 vstart += aux.vda_next;
10163
10164 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 10165 if (vstart + sizeof (*eaux) > endbuf)
10166 break;
252b5132
RH		 10167
10168 aux.vda_name = BYTE_GET (eaux->vda_name);
10169 aux.vda_next = BYTE_GET (eaux->vda_next);
10170
d79b3d50 10171 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 10172 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 10173 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 10174 else
10175 printf (_(" %#06x: Parent %d, name index: %ld\n"),
10176 isum, j, aux.vda_name);
10177 }
dd24e3da 10178
54806181
AM		 10179 if (j < ent.vd_cnt)
10180 printf (_(" Version def aux past end of section\n"));
252b5132 10181
c9f02c3e
MR		 10182 /* PR 17531:
10183 file: id:000001,src:000172+005151,op:splice,rep:2. */
10184 if (idx + ent.vd_next < idx)
5d921cbd
NC		 10185 break;
10186
252b5132
RH		 10187 idx += ent.vd_next;
10188 }
dd24e3da 10189
54806181
AM		 10190 if (cnt < section->sh_info)
10191 printf (_(" Version definition past end of section\n"));
252b5132
RH		 10192
10193 free (edefs);
10194 }
10195 break;
103f02d3 10196
252b5132
RH		 10197 case SHT_GNU_verneed:
10198 {
2cf0635d 10199 Elf_External_Verneed * eneed;
b34976b6
AM		 10200 unsigned int idx;
10201 unsigned int cnt;
2cf0635d 10202 char * endbuf;
252b5132 10203
32ec8896 10204 found = TRUE;
252b5132 10205
72de5009 10206 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
74e1a04b 10207 printable_section_name (section), section->sh_info);
252b5132
RH		 10208
10209 printf (_(" Addr: 0x"));
10210 printf_vma (section->sh_addr);
72de5009 10211 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 10212 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 10213 printable_section_name_from_index (section->sh_link));
252b5132 10214
3f5e193b
NC		 10215 eneed = (Elf_External_Verneed *) get_data (NULL, file,
10216 section->sh_offset, 1,
10217 section->sh_size,
9cf03b7e 10218 _("Version Needs section"));
a6e9f9df
AM		 10219 if (!eneed)
10220 break;
59245841 10221 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 10222
10223 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10224 {
2cf0635d 10225 Elf_External_Verneed * entry;
b34976b6 10226 Elf_Internal_Verneed ent;
5235cd68 10227 unsigned int isum;
b34976b6 10228 int j;
2cf0635d 10229 char * vstart;
252b5132 10230
7e26601c 10231 if (idx > (size_t) (endbuf - (char *) eneed))
dd24e3da
NC		 10232 break;
10233
252b5132 10234 vstart = ((char *) eneed) + idx;
54806181
AM		 10235 if (vstart + sizeof (*entry) > endbuf)
10236 break;
252b5132
RH		 10237
10238 entry = (Elf_External_Verneed *) vstart;
10239
10240 ent.vn_version = BYTE_GET (entry->vn_version);
10241 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
10242 ent.vn_file = BYTE_GET (entry->vn_file);
10243 ent.vn_aux = BYTE_GET (entry->vn_aux);
10244 ent.vn_next = BYTE_GET (entry->vn_next);
10245
10246 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
10247
d79b3d50
NC		 10248 if (VALID_DYNAMIC_NAME (ent.vn_file))
10249 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 10250 else
10251 printf (_(" File: %lx"), ent.vn_file);
10252
10253 printf (_(" Cnt: %d\n"), ent.vn_cnt);
10254
dd24e3da 10255 /* Check for overflow. */
7e26601c 10256 if (ent.vn_aux > (size_t) (endbuf - vstart))
dd24e3da 10257 break;
252b5132
RH		 10258 vstart += ent.vn_aux;
10259
10260 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10261 {
2cf0635d 10262 Elf_External_Vernaux * eaux;
b34976b6 10263 Elf_Internal_Vernaux aux;
252b5132 10264
54806181
AM		 10265 if (vstart + sizeof (*eaux) > endbuf)
10266 break;
252b5132
RH		 10267 eaux = (Elf_External_Vernaux *) vstart;
10268
10269 aux.vna_hash = BYTE_GET (eaux->vna_hash);
10270 aux.vna_flags = BYTE_GET (eaux->vna_flags);
10271 aux.vna_other = BYTE_GET (eaux->vna_other);
10272 aux.vna_name = BYTE_GET (eaux->vna_name);
10273 aux.vna_next = BYTE_GET (eaux->vna_next);
10274
d79b3d50 10275 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 10276 printf (_(" %#06x: Name: %s"),
d79b3d50 10277 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 10278 else
ecc2063b 10279 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 10280 isum, aux.vna_name);
10281
10282 printf (_(" Flags: %s Version: %d\n"),
10283 get_ver_flags (aux.vna_flags), aux.vna_other);
10284
dd24e3da 10285 /* Check for overflow. */
53774b7e
NC		 10286 if (aux.vna_next > (size_t) (endbuf - vstart)
10287 || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
10288 {
10289 warn (_("Invalid vna_next field of %lx\n"),
10290 aux.vna_next);
10291 j = ent.vn_cnt;
10292 break;
10293 }
252b5132
RH		 10294 isum += aux.vna_next;
10295 vstart += aux.vna_next;
10296 }
9cf03b7e 10297
54806181 10298 if (j < ent.vn_cnt)
9cf03b7e 10299 warn (_("Missing Version Needs auxillary information\n"));
252b5132 10300
bcf83b2a 10301 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
c24cf8b6
NC		 10302 {
10303 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
10304 cnt = section->sh_info;
10305 break;
10306 }
252b5132
RH		 10307 idx += ent.vn_next;
10308 }
9cf03b7e 10309
54806181 10310 if (cnt < section->sh_info)
9cf03b7e 10311 warn (_("Missing Version Needs information\n"));
103f02d3 10312
252b5132
RH		 10313 free (eneed);
10314 }
10315 break;
10316
10317 case SHT_GNU_versym:
10318 {
2cf0635d 10319 Elf_Internal_Shdr * link_section;
8b73c356
NC		 10320 size_t total;
10321 unsigned int cnt;
2cf0635d
NC		 10322 unsigned char * edata;
10323 unsigned short * data;
10324 char * strtab;
10325 Elf_Internal_Sym * symbols;
10326 Elf_Internal_Shdr * string_sec;
ba5cdace 10327 unsigned long num_syms;
d3ba0551 10328 long off;
252b5132 10329
4fbb74a6 10330 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 10331 break;
10332
4fbb74a6 10333 link_section = section_headers + section->sh_link;
08d8fa11 10334 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 10335
4fbb74a6 10336 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 10337 break;
10338
32ec8896 10339 found = TRUE;
252b5132 10340
ba5cdace 10341 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 10342 if (symbols == NULL)
10343 break;
252b5132 10344
4fbb74a6 10345 string_sec = section_headers + link_section->sh_link;
252b5132 10346
3f5e193b
NC		 10347 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
10348 string_sec->sh_size,
10349 _("version string table"));
a6e9f9df 10350 if (!strtab)
0429c154
MS		 10351 {
10352 free (symbols);
10353 break;
10354 }
252b5132 10355
8b73c356
NC		 10356 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10357 printable_section_name (section), (unsigned long) total);
252b5132
RH		 10358
10359 printf (_(" Addr: "));
10360 printf_vma (section->sh_addr);
72de5009 10361 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 10362 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 10363 printable_section_name (link_section));
252b5132 10364
d3ba0551
AM		 10365 off = offset_from_vma (file,
10366 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10367 total * sizeof (short));
3f5e193b
NC		 10368 edata = (unsigned char *) get_data (NULL, file, off, total,
10369 sizeof (short),
10370 _("version symbol data"));
a6e9f9df
AM		 10371 if (!edata)
10372 {
10373 free (strtab);
0429c154 10374 free (symbols);
a6e9f9df
AM		 10375 break;
10376 }
252b5132 10377
3f5e193b 10378 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 10379
10380 for (cnt = total; cnt --;)
b34976b6
AM		 10381 data[cnt] = byte_get (edata + cnt * sizeof (short),
10382 sizeof (short));
252b5132
RH		 10383
10384 free (edata);
10385
10386 for (cnt = 0; cnt < total; cnt += 4)
10387 {
10388 int j, nn;
ab273396
AM		 10389 char *name;
10390 char *invalid = _("*invalid*");
252b5132
RH		 10391
10392 printf (" %03x:", cnt);
10393
10394 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 10395 switch (data[cnt + j])
252b5132
RH		 10396 {
10397 case 0:
10398 fputs (_(" 0 (*local*) "), stdout);
10399 break;
10400
10401 case 1:
10402 fputs (_(" 1 (*global*) "), stdout);
10403 break;
10404
10405 default:
c244d050
NC		 10406 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10407 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 10408
dd24e3da 10409 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 10410 array, break to avoid an out-of-bounds read. */
10411 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 10412 {
10413 warn (_("invalid index into symbol array\n"));
10414 break;
10415 }
10416
ab273396
AM		 10417 name = NULL;
10418 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 10419 {
b34976b6
AM		 10420 Elf_Internal_Verneed ivn;
10421 unsigned long offset;
252b5132 10422
d93f0186
NC		 10423 offset = offset_from_vma
10424 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10425 sizeof (Elf_External_Verneed));
252b5132 10426
b34976b6 10427 do
252b5132 10428 {
b34976b6
AM		 10429 Elf_Internal_Vernaux ivna;
10430 Elf_External_Verneed evn;
10431 Elf_External_Vernaux evna;
10432 unsigned long a_off;
252b5132 10433
59245841
NC		 10434 if (get_data (&evn, file, offset, sizeof (evn), 1,
10435 _("version need")) == NULL)
10436 break;
0b4362b0 10437
252b5132
RH		 10438 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10439 ivn.vn_next = BYTE_GET (evn.vn_next);
10440
10441 a_off = offset + ivn.vn_aux;
10442
10443 do
10444 {
59245841
NC		 10445 if (get_data (&evna, file, a_off, sizeof (evna),
10446 1, _("version need aux (2)")) == NULL)
10447 {
10448 ivna.vna_next = 0;
10449 ivna.vna_other = 0;
10450 }
10451 else
10452 {
10453 ivna.vna_next = BYTE_GET (evna.vna_next);
10454 ivna.vna_other = BYTE_GET (evna.vna_other);
10455 }
252b5132
RH		 10456
10457 a_off += ivna.vna_next;
10458 }
b34976b6 10459 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 10460 && ivna.vna_next != 0);
10461
b34976b6 10462 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 10463 {
10464 ivna.vna_name = BYTE_GET (evna.vna_name);
10465
54806181 10466 if (ivna.vna_name >= string_sec->sh_size)
ab273396 10467 name = invalid;
54806181
AM		 10468 else
10469 name = strtab + ivna.vna_name;
252b5132
RH		 10470 break;
10471 }
10472
10473 offset += ivn.vn_next;
10474 }
10475 while (ivn.vn_next);
10476 }
00d93f34 10477
ab273396 10478 if (data[cnt + j] != 0x8001
b34976b6 10479 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 10480 {
b34976b6
AM		 10481 Elf_Internal_Verdef ivd;
10482 Elf_External_Verdef evd;
10483 unsigned long offset;
252b5132 10484
d93f0186
NC		 10485 offset = offset_from_vma
10486 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10487 sizeof evd);
252b5132
RH		 10488
10489 do
10490 {
59245841
NC		 10491 if (get_data (&evd, file, offset, sizeof (evd), 1,
10492 _("version def")) == NULL)
10493 {
10494 ivd.vd_next = 0;
948f632f 10495 /* PR 17531: file: 046-1082287-0.004. */
3102e897
NC		 10496 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
10497 break;
59245841
NC		 10498 }
10499 else
10500 {
10501 ivd.vd_next = BYTE_GET (evd.vd_next);
10502 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10503 }
252b5132
RH		 10504
10505 offset += ivd.vd_next;
10506 }
c244d050 10507 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 10508 && ivd.vd_next != 0);
10509
c244d050 10510 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 10511 {
b34976b6
AM		 10512 Elf_External_Verdaux evda;
10513 Elf_Internal_Verdaux ivda;
252b5132
RH		 10514
10515 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10516
59245841
NC		 10517 if (get_data (&evda, file,
10518 offset - ivd.vd_next + ivd.vd_aux,
10519 sizeof (evda), 1,
10520 _("version def aux")) == NULL)
10521 break;
252b5132
RH		 10522
10523 ivda.vda_name = BYTE_GET (evda.vda_name);
10524
54806181 10525 if (ivda.vda_name >= string_sec->sh_size)
ab273396
AM		 10526 name = invalid;
10527 else if (name != NULL && name != invalid)
10528 name = _("*both*");
54806181
AM		 10529 else
10530 name = strtab + ivda.vda_name;
252b5132
RH		 10531 }
10532 }
ab273396
AM		 10533 if (name != NULL)
10534 nn += printf ("(%s%-*s",
10535 name,
10536 12 - (int) strlen (name),
10537 ")");
252b5132
RH		 10538
10539 if (nn < 18)
10540 printf ("%*c", 18 - nn, ' ');
10541 }
10542
10543 putchar ('\n');
10544 }
10545
10546 free (data);
10547 free (strtab);
10548 free (symbols);
10549 }
10550 break;
103f02d3 10551
252b5132
RH		 10552 default:
10553 break;
10554 }
10555 }
10556
10557 if (! found)
10558 printf (_("\nNo version information found in this file.\n"));
10559
32ec8896 10560 return TRUE;
252b5132
RH		 10561}
10562
d1133906 10563static const char *
d3ba0551 10564get_symbol_binding (unsigned int binding)
252b5132 10565{
b34976b6 10566 static char buff[32];
252b5132
RH		 10567
10568 switch (binding)
10569 {
b34976b6
AM		 10570 case STB_LOCAL: return "LOCAL";
10571 case STB_GLOBAL: return "GLOBAL";
10572 case STB_WEAK: return "WEAK";
252b5132
RH		 10573 default:
10574 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 10575 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10576 binding);
252b5132 10577 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 10578 {
10579 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 10580 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10581 /* GNU is still using the default value 0. */
3e7a7d11
NC		 10582 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10583 return "UNIQUE";
10584 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10585 }
252b5132 10586 else
e9e44622 10587 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 10588 return buff;
10589 }
10590}
10591
d1133906 10592static const char *
d3ba0551 10593get_symbol_type (unsigned int type)
252b5132 10594{
b34976b6 10595 static char buff[32];
252b5132
RH		 10596
10597 switch (type)
10598 {
b34976b6
AM		 10599 case STT_NOTYPE: return "NOTYPE";
10600 case STT_OBJECT: return "OBJECT";
10601 case STT_FUNC: return "FUNC";
10602 case STT_SECTION: return "SECTION";
10603 case STT_FILE: return "FILE";
10604 case STT_COMMON: return "COMMON";
10605 case STT_TLS: return "TLS";
15ab5209
DB		 10606 case STT_RELC: return "RELC";
10607 case STT_SRELC: return "SRELC";
252b5132
RH		 10608 default:
10609 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af 10610 {
3510a7b8
NC		 10611 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10612 return "THUMB_FUNC";
103f02d3 10613
351b4b40 10614 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 10615 return "REGISTER";
10616
10617 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10618 return "PARISC_MILLI";
10619
e9e44622 10620 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 10621 }
252b5132 10622 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 10623 {
10624 if (elf_header.e_machine == EM_PARISC)
10625 {
10626 if (type == STT_HP_OPAQUE)
10627 return "HP_OPAQUE";
10628 if (type == STT_HP_STUB)
10629 return "HP_STUB";
10630 }
10631
d8045f23 10632 if (type == STT_GNU_IFUNC
9c55345c 10633 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 10634 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 10635 /* GNU is still using the default value 0. */
d8045f23
NC		 10636 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10637 return "IFUNC";
10638
e9e44622 10639 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 10640 }
252b5132 10641 else
e9e44622 10642 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 10643 return buff;
10644 }
10645}
10646
d1133906 10647static const char *
d3ba0551 10648get_symbol_visibility (unsigned int visibility)
d1133906
NC		 10649{
10650 switch (visibility)
10651 {
b34976b6
AM		 10652 case STV_DEFAULT: return "DEFAULT";
10653 case STV_INTERNAL: return "INTERNAL";
10654 case STV_HIDDEN: return "HIDDEN";
d1133906 10655 case STV_PROTECTED: return "PROTECTED";
bee0ee85
NC		 10656 default:
10657 error (_("Unrecognized visibility value: %u"), visibility);
10658 return _("<unknown>");
d1133906
NC		 10659 }
10660}
10661
fd85a6a1
NC		 10662static const char *
10663get_solaris_symbol_visibility (unsigned int visibility)
10664{
10665 switch (visibility)
10666 {
10667 case 4: return "EXPORTED";
10668 case 5: return "SINGLETON";
10669 case 6: return "ELIMINATE";
10670 default: return get_symbol_visibility (visibility);
10671 }
10672}
10673
5e2b0d47
NC		 10674static const char *
10675get_mips_symbol_other (unsigned int other)
10676{
10677 switch (other)
10678 {
32ec8896
NC		 10679 case STO_OPTIONAL: return "OPTIONAL";
10680 case STO_MIPS_PLT: return "MIPS PLT";
10681 case STO_MIPS_PIC: return "MIPS PIC";
10682 case STO_MICROMIPS: return "MICROMIPS";
10683 case STO_MICROMIPS | STO_MIPS_PIC: return "MICROMIPS, MIPS PIC";
10684 case STO_MIPS16: return "MIPS16";
10685 default: return NULL;
5e2b0d47
NC		 10686 }
10687}
10688
28f997cf
TG		 10689static const char *
10690get_ia64_symbol_other (unsigned int other)
10691{
10692 if (is_ia64_vms ())
10693 {
10694 static char res[32];
10695
10696 res[0] = 0;
10697
10698 /* Function types is for images and .STB files only. */
10699 switch (elf_header.e_type)
10700 {
10701 case ET_DYN:
10702 case ET_EXEC:
10703 switch (VMS_ST_FUNC_TYPE (other))
10704 {
10705 case VMS_SFT_CODE_ADDR:
10706 strcat (res, " CA");
10707 break;
10708 case VMS_SFT_SYMV_IDX:
10709 strcat (res, " VEC");
10710 break;
10711 case VMS_SFT_FD:
10712 strcat (res, " FD");
10713 break;
10714 case VMS_SFT_RESERVE:
10715 strcat (res, " RSV");
10716 break;
10717 default:
bee0ee85
NC		 10718 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10719 VMS_ST_FUNC_TYPE (other));
10720 strcat (res, " <unknown>");
10721 break;
28f997cf
TG		 10722 }
10723 break;
10724 default:
10725 break;
10726 }
10727 switch (VMS_ST_LINKAGE (other))
10728 {
10729 case VMS_STL_IGNORE:
10730 strcat (res, " IGN");
10731 break;
10732 case VMS_STL_RESERVE:
10733 strcat (res, " RSV");
10734 break;
10735 case VMS_STL_STD:
10736 strcat (res, " STD");
10737 break;
10738 case VMS_STL_LNK:
10739 strcat (res, " LNK");
10740 break;
10741 default:
bee0ee85
NC		 10742 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10743 VMS_ST_LINKAGE (other));
10744 strcat (res, " <unknown>");
10745 break;
28f997cf
TG		 10746 }
10747
10748 if (res[0] != 0)
10749 return res + 1;
10750 else
10751 return res;
10752 }
10753 return NULL;
10754}
10755
6911b7dc
AM		 10756static const char *
10757get_ppc64_symbol_other (unsigned int other)
10758{
10759 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10760 {
10761 static char buf[32];
10762 snprintf (buf, sizeof buf, _("<localentry>: %d"),
10763 PPC64_LOCAL_ENTRY_OFFSET (other));
10764 return buf;
10765 }
10766 return NULL;
10767}
10768
5e2b0d47
NC		 10769static const char *
10770get_symbol_other (unsigned int other)
10771{
10772 const char * result = NULL;
10773 static char buff [32];
10774
10775 if (other == 0)
10776 return "";
10777
10778 switch (elf_header.e_machine)
10779 {
10780 case EM_MIPS:
10781 result = get_mips_symbol_other (other);
28f997cf
TG		 10782 break;
10783 case EM_IA_64:
10784 result = get_ia64_symbol_other (other);
10785 break;
6911b7dc
AM		 10786 case EM_PPC64:
10787 result = get_ppc64_symbol_other (other);
10788 break;
5e2b0d47 10789 default:
fd85a6a1 10790 result = NULL;
5e2b0d47
NC		 10791 break;
10792 }
10793
10794 if (result)
10795 return result;
10796
10797 snprintf (buff, sizeof buff, _("<other>: %x"), other);
10798 return buff;
10799}
10800
d1133906 10801static const char *
d3ba0551 10802get_symbol_index_type (unsigned int type)
252b5132 10803{
b34976b6 10804 static char buff[32];
5cf1065c 10805
252b5132
RH		 10806 switch (type)
10807 {
b34976b6
AM		 10808 case SHN_UNDEF: return "UND";
10809 case SHN_ABS: return "ABS";
10810 case SHN_COMMON: return "COM";
252b5132 10811 default:
9ce701e2
L		 10812 if (type == SHN_IA_64_ANSI_COMMON
10813 && elf_header.e_machine == EM_IA_64
10814 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10815 return "ANSI_COM";
8a9036a4 10816 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 10817 || elf_header.e_machine == EM_L1OM
10818 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 10819 && type == SHN_X86_64_LCOMMON)
10820 return "LARGE_COM";
ac145307
BS		 10821 else if ((type == SHN_MIPS_SCOMMON
10822 && elf_header.e_machine == EM_MIPS)
10823 || (type == SHN_TIC6X_SCOMMON
10824 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 10825 return "SCOM";
10826 else if (type == SHN_MIPS_SUNDEFINED
10827 && elf_header.e_machine == EM_MIPS)
10828 return "SUND";
9ce701e2 10829 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 10830 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 10831 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 10832 sprintf (buff, "OS [0x%04x]", type & 0xffff);
10833 else if (type >= SHN_LORESERVE)
10834 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4 10835 else if (type >= elf_header.e_shnum)
e0a31db1 10836 sprintf (buff, _("bad section index[%3d]"), type);
252b5132 10837 else
232e7cb8 10838 sprintf (buff, "%3d", type);
5cf1065c 10839 break;
252b5132 10840 }
5cf1065c
NC		 10841
10842 return buff;
252b5132
RH		 10843}
10844
66543521 10845static bfd_vma *
57028622 10846get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
252b5132 10847{
2cf0635d
NC		 10848 unsigned char * e_data;
10849 bfd_vma * i_data;
252b5132 10850
57028622
NC		 10851 /* If the size_t type is smaller than the bfd_size_type, eg because
10852 you are building a 32-bit tool on a 64-bit host, then make sure
10853 that when (number) is cast to (size_t) no information is lost. */
10854 if (sizeof (size_t) < sizeof (bfd_size_type)
10855 && (bfd_size_type) ((size_t) number) != number)
10856 {
ed754a13
AM		 10857 error (_("Size truncation prevents reading %" BFD_VMA_FMT "u"
10858 " elements of size %u\n"),
10859 number, ent_size);
57028622
NC		 10860 return NULL;
10861 }
948f632f 10862
3102e897
NC		 10863 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10864 attempting to allocate memory when the read is bound to fail. */
10865 if (ent_size * number > current_file_size)
10866 {
ed754a13
AM		 10867 error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT "u\n"),
10868 number);
3102e897
NC		 10869 return NULL;
10870 }
10871
57028622 10872 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
252b5132
RH		 10873 if (e_data == NULL)
10874 {
ed754a13
AM		 10875 error (_("Out of memory reading %" BFD_VMA_FMT "u dynamic entries\n"),
10876 number);
252b5132
RH		 10877 return NULL;
10878 }
10879
57028622 10880 if (fread (e_data, ent_size, (size_t) number, file) != number)
252b5132 10881 {
ed754a13
AM		 10882 error (_("Unable to read in %" BFD_VMA_FMT "u bytes of dynamic data\n"),
10883 number * ent_size);
3102e897 10884 free (e_data);
252b5132
RH		 10885 return NULL;
10886 }
10887
57028622 10888 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
252b5132
RH		 10889 if (i_data == NULL)
10890 {
ed754a13
AM		 10891 error (_("Out of memory allocating space for %" BFD_VMA_FMT "u"
10892 " dynamic entries\n"),
10893 number);
252b5132
RH		 10894 free (e_data);
10895 return NULL;
10896 }
10897
10898 while (number--)
66543521 10899 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 10900
10901 free (e_data);
10902
10903 return i_data;
10904}
10905
6bd1a22c
L		 10906static void
10907print_dynamic_symbol (bfd_vma si, unsigned long hn)
10908{
2cf0635d 10909 Elf_Internal_Sym * psym;
6bd1a22c
L		 10910 int n;
10911
6bd1a22c
L		 10912 n = print_vma (si, DEC_5);
10913 if (n < 5)
0b4362b0 10914 fputs (&" "[n], stdout);
6bd1a22c 10915 printf (" %3lu: ", hn);
e0a31db1
NC		 10916
10917 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10918 {
3102e897
NC		 10919 printf (_("<No info available for dynamic symbol number %lu>\n"),
10920 (unsigned long) si);
e0a31db1
NC		 10921 return;
10922 }
10923
10924 psym = dynamic_symbols + si;
6bd1a22c
L		 10925 print_vma (psym->st_value, LONG_HEX);
10926 putchar (' ');
10927 print_vma (psym->st_size, DEC_5);
10928
f4be36b3
AM		 10929 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10930 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
fd85a6a1
NC		 10931
10932 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
10933 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
10934 else
10935 {
10936 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
10937
10938 printf (" %-7s", get_symbol_visibility (vis));
10939 /* Check to see if any other bits in the st_other field are set.
10940 Note - displaying this information disrupts the layout of the
10941 table being generated, but for the moment this case is very
10942 rare. */
10943 if (psym->st_other ^ vis)
10944 printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
10945 }
10946
6bd1a22c
L		 10947 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10948 if (VALID_DYNAMIC_NAME (psym->st_name))
10949 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10950 else
2b692964 10951 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 10952 putchar ('\n');
10953}
10954
bb4d2ac2 10955static const char *
1449284b
NC		 10956get_symbol_version_string (FILE * file,
10957 bfd_boolean is_dynsym,
10958 const char * strtab,
10959 unsigned long int strtab_size,
10960 unsigned int si,
10961 Elf_Internal_Sym * psym,
10962 enum versioned_symbol_info * sym_info,
10963 unsigned short * vna_other)
bb4d2ac2 10964{
ab273396
AM		 10965 unsigned char data[2];
10966 unsigned short vers_data;
10967 unsigned long offset;
bb4d2ac2 10968
ab273396
AM		 10969 if (!is_dynsym
10970 || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
10971 return NULL;
bb4d2ac2 10972
ab273396
AM		 10973 offset = offset_from_vma (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10974 sizeof data + si * sizeof (vers_data));
bb4d2ac2 10975
ab273396
AM		 10976 if (get_data (&data, file, offset + si * sizeof (vers_data),
10977 sizeof (data), 1, _("version data")) == NULL)
10978 return NULL;
10979
10980 vers_data = byte_get (data, 2);
bb4d2ac2 10981
ab273396
AM		 10982 if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
10983 return NULL;
bb4d2ac2 10984
ab273396
AM		 10985 /* Usually we'd only see verdef for defined symbols, and verneed for
10986 undefined symbols. However, symbols defined by the linker in
10987 .dynbss for variables copied from a shared library in order to
10988 avoid text relocations are defined yet have verneed. We could
10989 use a heuristic to detect the special case, for example, check
10990 for verneed first on symbols defined in SHT_NOBITS sections, but
10991 it is simpler and more reliable to just look for both verdef and
10992 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
bb4d2ac2 10993
ab273396
AM		 10994 if (psym->st_shndx != SHN_UNDEF
10995 && vers_data != 0x8001
10996 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10997 {
10998 Elf_Internal_Verdef ivd;
10999 Elf_Internal_Verdaux ivda;
11000 Elf_External_Verdaux evda;
11001 unsigned long off;
bb4d2ac2 11002
ab273396
AM		 11003 off = offset_from_vma (file,
11004 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11005 sizeof (Elf_External_Verdef));
11006
11007 do
bb4d2ac2 11008 {
ab273396
AM		 11009 Elf_External_Verdef evd;
11010
11011 if (get_data (&evd, file, off, sizeof (evd), 1,
11012 _("version def")) == NULL)
11013 {
11014 ivd.vd_ndx = 0;
11015 ivd.vd_aux = 0;
11016 ivd.vd_next = 0;
11017 }
11018 else
bb4d2ac2 11019 {
ab273396
AM		 11020 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11021 ivd.vd_aux = BYTE_GET (evd.vd_aux);
11022 ivd.vd_next = BYTE_GET (evd.vd_next);
11023 }
bb4d2ac2 11024
ab273396
AM		 11025 off += ivd.vd_next;
11026 }
11027 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
bb4d2ac2 11028
ab273396
AM		 11029 if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11030 {
11031 off -= ivd.vd_next;
11032 off += ivd.vd_aux;
bb4d2ac2 11033
ab273396
AM		 11034 if (get_data (&evda, file, off, sizeof (evda), 1,
11035 _("version def aux")) != NULL)
11036 {
11037 ivda.vda_name = BYTE_GET (evda.vda_name);
bb4d2ac2 11038
ab273396
AM		 11039 if (psym->st_name != ivda.vda_name)
11040 {
11041 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11042 ? symbol_hidden : symbol_public);
11043 return (ivda.vda_name < strtab_size
11044 ? strtab + ivda.vda_name : _("<corrupt>"));
11045 }
11046 }
11047 }
11048 }
bb4d2ac2 11049
ab273396
AM		 11050 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11051 {
11052 Elf_External_Verneed evn;
11053 Elf_Internal_Verneed ivn;
11054 Elf_Internal_Vernaux ivna;
bb4d2ac2 11055
ab273396
AM		 11056 offset = offset_from_vma (file,
11057 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11058 sizeof evn);
11059 do
11060 {
11061 unsigned long vna_off;
bb4d2ac2 11062
ab273396
AM		 11063 if (get_data (&evn, file, offset, sizeof (evn), 1,
11064 _("version need")) == NULL)
11065 {
11066 ivna.vna_next = 0;
11067 ivna.vna_other = 0;
11068 ivna.vna_name = 0;
11069 break;
11070 }
bb4d2ac2 11071
ab273396
AM		 11072 ivn.vn_aux = BYTE_GET (evn.vn_aux);
11073 ivn.vn_next = BYTE_GET (evn.vn_next);
bb4d2ac2 11074
ab273396 11075 vna_off = offset + ivn.vn_aux;
bb4d2ac2 11076
ab273396
AM		 11077 do
11078 {
11079 Elf_External_Vernaux evna;
bb4d2ac2 11080
ab273396
AM		 11081 if (get_data (&evna, file, vna_off, sizeof (evna), 1,
11082 _("version need aux (3)")) == NULL)
bb4d2ac2 11083 {
ab273396
AM		 11084 ivna.vna_next = 0;
11085 ivna.vna_other = 0;
11086 ivna.vna_name = 0;
bb4d2ac2 11087 }
bb4d2ac2 11088 else
bb4d2ac2 11089 {
ab273396
AM		 11090 ivna.vna_other = BYTE_GET (evna.vna_other);
11091 ivna.vna_next = BYTE_GET (evna.vna_next);
11092 ivna.vna_name = BYTE_GET (evna.vna_name);
11093 }
bb4d2ac2 11094
ab273396
AM		 11095 vna_off += ivna.vna_next;
11096 }
11097 while (ivna.vna_other != vers_data && ivna.vna_next != 0);
bb4d2ac2 11098
ab273396
AM		 11099 if (ivna.vna_other == vers_data)
11100 break;
bb4d2ac2 11101
ab273396
AM		 11102 offset += ivn.vn_next;
11103 }
11104 while (ivn.vn_next != 0);
bb4d2ac2 11105
ab273396
AM		 11106 if (ivna.vna_other == vers_data)
11107 {
11108 *sym_info = symbol_undefined;
11109 *vna_other = ivna.vna_other;
11110 return (ivna.vna_name < strtab_size
11111 ? strtab + ivna.vna_name : _("<corrupt>"));
bb4d2ac2
L		 11112 }
11113 }
ab273396 11114 return NULL;
bb4d2ac2
L		 11115}
11116
e3c8793a 11117/* Dump the symbol table. */
32ec8896 11118static bfd_boolean
2cf0635d 11119process_symbol_table (FILE * file)
252b5132 11120{
2cf0635d 11121 Elf_Internal_Shdr * section;
8b73c356
NC		 11122 bfd_size_type nbuckets = 0;
11123 bfd_size_type nchains = 0;
2cf0635d
NC		 11124 bfd_vma * buckets = NULL;
11125 bfd_vma * chains = NULL;
fdc90cb4 11126 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 11127 bfd_vma * gnubuckets = NULL;
11128 bfd_vma * gnuchains = NULL;
6bd1a22c 11129 bfd_vma gnusymidx = 0;
071436c6 11130 bfd_size_type ngnuchains = 0;
252b5132 11131
2c610e4b 11132 if (!do_syms && !do_dyn_syms && !do_histogram)
32ec8896 11133 return TRUE;
252b5132 11134
6bd1a22c
L		 11135 if (dynamic_info[DT_HASH]
11136 && (do_histogram
2c610e4b
L		 11137 || (do_using_dynamic
11138 && !do_dyn_syms
11139 && dynamic_strings != NULL)))
252b5132 11140 {
66543521
AM		 11141 unsigned char nb[8];
11142 unsigned char nc[8];
8b73c356 11143 unsigned int hash_ent_size = 4;
66543521
AM		 11144
11145 if ((elf_header.e_machine == EM_ALPHA
11146 || elf_header.e_machine == EM_S390
11147 || elf_header.e_machine == EM_S390_OLD)
11148 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
11149 hash_ent_size = 8;
11150
fb52b2f4
NC		 11151 if (fseek (file,
11152 (archive_file_offset
11153 + offset_from_vma (file, dynamic_info[DT_HASH],
11154 sizeof nb + sizeof nc)),
d93f0186 11155 SEEK_SET))
252b5132 11156 {
591a748a 11157 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 11158 goto no_hash;
252b5132
RH		 11159 }
11160
66543521 11161 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 11162 {
11163 error (_("Failed to read in number of buckets\n"));
d3a44ec6 11164 goto no_hash;
252b5132
RH		 11165 }
11166
66543521 11167 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 11168 {
11169 error (_("Failed to read in number of chains\n"));
d3a44ec6 11170 goto no_hash;
252b5132
RH		 11171 }
11172
66543521
AM		 11173 nbuckets = byte_get (nb, hash_ent_size);
11174 nchains = byte_get (nc, hash_ent_size);
252b5132 11175
66543521
AM		 11176 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
11177 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 11178
d3a44ec6 11179 no_hash:
252b5132 11180 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 11181 {
11182 if (do_using_dynamic)
32ec8896 11183 return FALSE;
d3a44ec6
JJ		 11184 free (buckets);
11185 free (chains);
11186 buckets = NULL;
11187 chains = NULL;
11188 nbuckets = 0;
11189 nchains = 0;
11190 }
252b5132
RH		 11191 }
11192
6bd1a22c
L		 11193 if (dynamic_info_DT_GNU_HASH
11194 && (do_histogram
2c610e4b
L		 11195 || (do_using_dynamic
11196 && !do_dyn_syms
11197 && dynamic_strings != NULL)))
252b5132 11198 {
6bd1a22c
L		 11199 unsigned char nb[16];
11200 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11201 bfd_vma buckets_vma;
11202
11203 if (fseek (file,
11204 (archive_file_offset
11205 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
11206 sizeof nb)),
11207 SEEK_SET))
11208 {
11209 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 11210 goto no_gnu_hash;
6bd1a22c 11211 }
252b5132 11212
6bd1a22c
L		 11213 if (fread (nb, 16, 1, file) != 1)
11214 {
11215 error (_("Failed to read in number of buckets\n"));
d3a44ec6 11216 goto no_gnu_hash;
6bd1a22c
L		 11217 }
11218
11219 ngnubuckets = byte_get (nb, 4);
11220 gnusymidx = byte_get (nb + 4, 4);
11221 bitmaskwords = byte_get (nb + 8, 4);
11222 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 11223 if (is_32bit_elf)
6bd1a22c 11224 buckets_vma += bitmaskwords * 4;
f7a99963 11225 else
6bd1a22c 11226 buckets_vma += bitmaskwords * 8;
252b5132 11227
6bd1a22c
L		 11228 if (fseek (file,
11229 (archive_file_offset
11230 + offset_from_vma (file, buckets_vma, 4)),
11231 SEEK_SET))
252b5132 11232 {
6bd1a22c 11233 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 11234 goto no_gnu_hash;
6bd1a22c
L		 11235 }
11236
11237 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 11238
6bd1a22c 11239 if (gnubuckets == NULL)
d3a44ec6 11240 goto no_gnu_hash;
6bd1a22c
L		 11241
11242 for (i = 0; i < ngnubuckets; i++)
11243 if (gnubuckets[i] != 0)
11244 {
11245 if (gnubuckets[i] < gnusymidx)
32ec8896 11246 return FALSE;
6bd1a22c
L		 11247
11248 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11249 maxchain = gnubuckets[i];
11250 }
11251
11252 if (maxchain == 0xffffffff)
d3a44ec6 11253 goto no_gnu_hash;
6bd1a22c
L		 11254
11255 maxchain -= gnusymidx;
11256
11257 if (fseek (file,
11258 (archive_file_offset
11259 + offset_from_vma (file, buckets_vma
11260 + 4 * (ngnubuckets + maxchain), 4)),
11261 SEEK_SET))
11262 {
11263 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 11264 goto no_gnu_hash;
6bd1a22c
L		 11265 }
11266
11267 do
11268 {
11269 if (fread (nb, 4, 1, file) != 1)
252b5132 11270 {
6bd1a22c 11271 error (_("Failed to determine last chain length\n"));
d3a44ec6 11272 goto no_gnu_hash;
6bd1a22c 11273 }
252b5132 11274
6bd1a22c 11275 if (maxchain + 1 == 0)
d3a44ec6 11276 goto no_gnu_hash;
252b5132 11277
6bd1a22c
L		 11278 ++maxchain;
11279 }
11280 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 11281
6bd1a22c
L		 11282 if (fseek (file,
11283 (archive_file_offset
11284 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
11285 SEEK_SET))
11286 {
11287 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 11288 goto no_gnu_hash;
6bd1a22c
L		 11289 }
11290
11291 gnuchains = get_dynamic_data (file, maxchain, 4);
071436c6 11292 ngnuchains = maxchain;
6bd1a22c 11293
d3a44ec6 11294 no_gnu_hash:
6bd1a22c 11295 if (gnuchains == NULL)
d3a44ec6
JJ		 11296 {
11297 free (gnubuckets);
d3a44ec6
JJ		 11298 gnubuckets = NULL;
11299 ngnubuckets = 0;
f64fddf1 11300 if (do_using_dynamic)
32ec8896 11301 return FALSE;
d3a44ec6 11302 }
6bd1a22c
L		 11303 }
11304
11305 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11306 && do_syms
11307 && do_using_dynamic
3102e897
NC		 11308 && dynamic_strings != NULL
11309 && dynamic_symbols != NULL)
6bd1a22c
L		 11310 {
11311 unsigned long hn;
11312
11313 if (dynamic_info[DT_HASH])
11314 {
11315 bfd_vma si;
11316
11317 printf (_("\nSymbol table for image:\n"));
11318 if (is_32bit_elf)
11319 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11320 else
11321 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11322
11323 for (hn = 0; hn < nbuckets; hn++)
11324 {
11325 if (! buckets[hn])
11326 continue;
11327
11328 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
11329 print_dynamic_symbol (si, hn);
252b5132
RH		 11330 }
11331 }
6bd1a22c
L		 11332
11333 if (dynamic_info_DT_GNU_HASH)
11334 {
11335 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11336 if (is_32bit_elf)
11337 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11338 else
11339 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11340
11341 for (hn = 0; hn < ngnubuckets; ++hn)
11342 if (gnubuckets[hn] != 0)
11343 {
11344 bfd_vma si = gnubuckets[hn];
11345 bfd_vma off = si - gnusymidx;
11346
11347 do
11348 {
11349 print_dynamic_symbol (si, hn);
11350 si++;
11351 }
071436c6 11352 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
6bd1a22c
L		 11353 }
11354 }
252b5132 11355 }
8b73c356
NC		 11356 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11357 && section_headers != NULL)
252b5132 11358 {
b34976b6 11359 unsigned int i;
252b5132
RH		 11360
11361 for (i = 0, section = section_headers;
11362 i < elf_header.e_shnum;
11363 i++, section++)
11364 {
b34976b6 11365 unsigned int si;
2cf0635d 11366 char * strtab = NULL;
c256ffe7 11367 unsigned long int strtab_size = 0;
2cf0635d
NC		 11368 Elf_Internal_Sym * symtab;
11369 Elf_Internal_Sym * psym;
ba5cdace 11370 unsigned long num_syms;
252b5132 11371
2c610e4b
L		 11372 if ((section->sh_type != SHT_SYMTAB
11373 && section->sh_type != SHT_DYNSYM)
11374 || (!do_syms
11375 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 11376 continue;
11377
dd24e3da
NC		 11378 if (section->sh_entsize == 0)
11379 {
11380 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
74e1a04b 11381 printable_section_name (section));
dd24e3da
NC		 11382 continue;
11383 }
11384
252b5132 11385 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
74e1a04b 11386 printable_section_name (section),
252b5132 11387 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 11388
f7a99963 11389 if (is_32bit_elf)
ca47b30c 11390 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 11391 else
ca47b30c 11392 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 11393
ba5cdace 11394 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 11395 if (symtab == NULL)
11396 continue;
11397
11398 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 11399 {
11400 strtab = string_table;
11401 strtab_size = string_table_length;
11402 }
4fbb74a6 11403 else if (section->sh_link < elf_header.e_shnum)
252b5132 11404 {
2cf0635d 11405 Elf_Internal_Shdr * string_sec;
252b5132 11406
4fbb74a6 11407 string_sec = section_headers + section->sh_link;
252b5132 11408
3f5e193b
NC		 11409 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
11410 1, string_sec->sh_size,
11411 _("string table"));
c256ffe7 11412 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 11413 }
11414
ba5cdace 11415 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 11416 {
bb4d2ac2
L		 11417 const char *version_string;
11418 enum versioned_symbol_info sym_info;
11419 unsigned short vna_other;
11420
5e220199 11421 printf ("%6d: ", si);
f7a99963
NC		 11422 print_vma (psym->st_value, LONG_HEX);
11423 putchar (' ');
11424 print_vma (psym->st_size, DEC_5);
d1133906
NC		 11425 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
11426 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
fd85a6a1
NC		 11427 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11428 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
11429 else
11430 {
11431 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11432
11433 printf (" %-7s", get_symbol_visibility (vis));
11434 /* Check to see if any other bits in the st_other field are set.
11435 Note - displaying this information disrupts the layout of the
11436 table being generated, but for the moment this case is very rare. */
11437 if (psym->st_other ^ vis)
11438 printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
11439 }
31104126 11440 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 11441 print_symbol (25, psym->st_name < strtab_size
2b692964 11442 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 11443
bb4d2ac2
L		 11444 version_string
11445 = get_symbol_version_string (file,
11446 section->sh_type == SHT_DYNSYM,
11447 strtab, strtab_size, si,
11448 psym, &sym_info, &vna_other);
11449 if (version_string)
252b5132 11450 {
bb4d2ac2
L		 11451 if (sym_info == symbol_undefined)
11452 printf ("@%s (%d)", version_string, vna_other);
11453 else
11454 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11455 version_string);
252b5132
RH		 11456 }
11457
11458 putchar ('\n');
52c3c391
NC		 11459
11460 if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
dd905818
NC		 11461 && si >= section->sh_info
11462 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11463 && elf_header.e_machine != EM_MIPS
11464 /* Solaris binaries have been found to violate this requirement as
11465 well. Not sure if this is a bug or an ABI requirement. */
11466 && elf_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
52c3c391
NC		 11467 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11468 si, printable_section_name (section), section->sh_info);
252b5132
RH		 11469 }
11470
11471 free (symtab);
11472 if (strtab != string_table)
11473 free (strtab);
11474 }
11475 }
11476 else if (do_syms)
11477 printf
11478 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11479
11480 if (do_histogram && buckets != NULL)
11481 {
2cf0635d
NC		 11482 unsigned long * lengths;
11483 unsigned long * counts;
66543521
AM		 11484 unsigned long hn;
11485 bfd_vma si;
11486 unsigned long maxlength = 0;
11487 unsigned long nzero_counts = 0;
11488 unsigned long nsyms = 0;
94d15024 11489 unsigned long chained;
252b5132 11490
66543521
AM		 11491 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11492 (unsigned long) nbuckets);
252b5132 11493
3f5e193b 11494 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 11495 if (lengths == NULL)
11496 {
8b73c356 11497 error (_("Out of memory allocating space for histogram buckets\n"));
32ec8896 11498 return FALSE;
252b5132 11499 }
8b73c356
NC		 11500
11501 printf (_(" Length Number %% of total Coverage\n"));
252b5132
RH		 11502 for (hn = 0; hn < nbuckets; ++hn)
11503 {
94d15024
MF		 11504 for (si = buckets[hn], chained = 0;
11505 si > 0 && si < nchains && si < nbuckets && chained <= nchains;
11506 si = chains[si], ++chained)
252b5132 11507 {
b34976b6 11508 ++nsyms;
252b5132 11509 if (maxlength < ++lengths[hn])
b34976b6 11510 ++maxlength;
252b5132 11511 }
94d15024
MF		 11512
11513 /* PR binutils/17531: A corrupt binary could contain broken
11514 histogram data. Do not go into an infinite loop trying
11515 to process it. */
11516 if (chained > nchains)
11517 {
11518 error (_("histogram chain is corrupt\n"));
11519 break;
11520 }
252b5132
RH		 11521 }
11522
3f5e193b 11523 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 11524 if (counts == NULL)
11525 {
b2e951ec 11526 free (lengths);
8b73c356 11527 error (_("Out of memory allocating space for histogram counts\n"));
32ec8896 11528 return FALSE;
252b5132
RH		 11529 }
11530
11531 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 11532 ++counts[lengths[hn]];
252b5132 11533
103f02d3 11534 if (nbuckets > 0)
252b5132 11535 {
66543521
AM		 11536 unsigned long i;
11537 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 11538 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 11539 for (i = 1; i <= maxlength; ++i)
103f02d3 11540 {
66543521
AM		 11541 nzero_counts += counts[i] * i;
11542 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11543 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 11544 (nzero_counts * 100.0) / nsyms);
11545 }
252b5132
RH		 11546 }
11547
11548 free (counts);
11549 free (lengths);
11550 }
11551
11552 if (buckets != NULL)
11553 {
11554 free (buckets);
11555 free (chains);
11556 }
11557
d3a44ec6 11558 if (do_histogram && gnubuckets != NULL)
fdc90cb4 11559 {
2cf0635d
NC		 11560 unsigned long * lengths;
11561 unsigned long * counts;
fdc90cb4
JJ		 11562 unsigned long hn;
11563 unsigned long maxlength = 0;
11564 unsigned long nzero_counts = 0;
11565 unsigned long nsyms = 0;
fdc90cb4 11566
8b73c356
NC		 11567 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11568 (unsigned long) ngnubuckets);
11569
3f5e193b 11570 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 11571 if (lengths == NULL)
11572 {
8b73c356 11573 error (_("Out of memory allocating space for gnu histogram buckets\n"));
32ec8896 11574 return FALSE;
fdc90cb4
JJ		 11575 }
11576
fdc90cb4
JJ		 11577 printf (_(" Length Number %% of total Coverage\n"));
11578
11579 for (hn = 0; hn < ngnubuckets; ++hn)
11580 if (gnubuckets[hn] != 0)
11581 {
11582 bfd_vma off, length = 1;
11583
6bd1a22c 11584 for (off = gnubuckets[hn] - gnusymidx;
071436c6
NC		 11585 /* PR 17531 file: 010-77222-0.004. */
11586 off < ngnuchains && (gnuchains[off] & 1) == 0;
11587 ++off)
fdc90cb4
JJ		 11588 ++length;
11589 lengths[hn] = length;
11590 if (length > maxlength)
11591 maxlength = length;
11592 nsyms += length;
11593 }
11594
3f5e193b 11595 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 11596 if (counts == NULL)
11597 {
b2e951ec 11598 free (lengths);
8b73c356 11599 error (_("Out of memory allocating space for gnu histogram counts\n"));
32ec8896 11600 return FALSE;
fdc90cb4
JJ		 11601 }
11602
11603 for (hn = 0; hn < ngnubuckets; ++hn)
11604 ++counts[lengths[hn]];
11605
11606 if (ngnubuckets > 0)
11607 {
11608 unsigned long j;
11609 printf (" 0 %-10lu (%5.1f%%)\n",
11610 counts[0], (counts[0] * 100.0) / ngnubuckets);
11611 for (j = 1; j <= maxlength; ++j)
11612 {
11613 nzero_counts += counts[j] * j;
11614 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11615 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11616 (nzero_counts * 100.0) / nsyms);
11617 }
11618 }
11619
11620 free (counts);
11621 free (lengths);
11622 free (gnubuckets);
11623 free (gnuchains);
11624 }
11625
32ec8896 11626 return TRUE;
252b5132
RH		 11627}
11628
32ec8896 11629static bfd_boolean
2cf0635d 11630process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 11631{
b4c96d0d 11632 unsigned int i;
252b5132
RH		 11633
11634 if (dynamic_syminfo == NULL
11635 || !do_dynamic)
11636 /* No syminfo, this is ok. */
32ec8896 11637 return TRUE;
252b5132
RH		 11638
11639 /* There better should be a dynamic symbol section. */
11640 if (dynamic_symbols == NULL || dynamic_strings == NULL)
32ec8896 11641 return FALSE;
252b5132
RH		 11642
11643 if (dynamic_addr)
11644 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11645 dynamic_syminfo_offset, dynamic_syminfo_nent);
11646
11647 printf (_(" Num: Name BoundTo Flags\n"));
11648 for (i = 0; i < dynamic_syminfo_nent; ++i)
11649 {
11650 unsigned short int flags = dynamic_syminfo[i].si_flags;
11651
31104126 11652 printf ("%4d: ", i);
4082ef84
NC		 11653 if (i >= num_dynamic_syms)
11654 printf (_("<corrupt index>"));
11655 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
d79b3d50
NC		 11656 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11657 else
2b692964 11658 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 11659 putchar (' ');
252b5132
RH		 11660
11661 switch (dynamic_syminfo[i].si_boundto)
11662 {
11663 case SYMINFO_BT_SELF:
11664 fputs ("SELF ", stdout);
11665 break;
11666 case SYMINFO_BT_PARENT:
11667 fputs ("PARENT ", stdout);
11668 break;
11669 default:
11670 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 11671 && dynamic_syminfo[i].si_boundto < dynamic_nent
11672 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 11673 {
d79b3d50 11674 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 11675 putchar (' ' );
11676 }
252b5132
RH		 11677 else
11678 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11679 break;
11680 }
11681
11682 if (flags & SYMINFO_FLG_DIRECT)
11683 printf (" DIRECT");
11684 if (flags & SYMINFO_FLG_PASSTHRU)
11685 printf (" PASSTHRU");
11686 if (flags & SYMINFO_FLG_COPY)
11687 printf (" COPY");
11688 if (flags & SYMINFO_FLG_LAZYLOAD)
11689 printf (" LAZYLOAD");
11690
11691 puts ("");
11692 }
11693
32ec8896 11694 return TRUE;
252b5132
RH		 11695}
11696
b32e566b
NC		 11697#define IN_RANGE(START,END,ADDR,OFF) \
11698 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11699
cf13d699
NC		 11700/* Check to see if the given reloc needs to be handled in a target specific
11701 manner. If so then process the reloc and return TRUE otherwise return
f84ce13b
NC		 11702 FALSE.
11703
11704 If called with reloc == NULL, then this is a signal that reloc processing
11705 for the current section has finished, and any saved state should be
11706 discarded. */
09c11c86 11707
cf13d699
NC		 11708static bfd_boolean
11709target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11710 unsigned char * start,
03f7786e 11711 unsigned char * end,
f84ce13b
NC		 11712 Elf_Internal_Sym * symtab,
11713 unsigned long num_syms)
252b5132 11714{
f84ce13b
NC		 11715 unsigned int reloc_type = 0;
11716 unsigned long sym_index = 0;
11717
11718 if (reloc)
11719 {
11720 reloc_type = get_reloc_type (reloc->r_info);
11721 sym_index = get_reloc_symindex (reloc->r_info);
11722 }
252b5132 11723
cf13d699 11724 switch (elf_header.e_machine)
252b5132 11725 {
13761a11
NC		 11726 case EM_MSP430:
11727 case EM_MSP430_OLD:
11728 {
11729 static Elf_Internal_Sym * saved_sym = NULL;
11730
f84ce13b
NC		 11731 if (reloc == NULL)
11732 {
11733 saved_sym = NULL;
11734 return TRUE;
11735 }
11736
13761a11
NC		 11737 switch (reloc_type)
11738 {
11739 case 10: /* R_MSP430_SYM_DIFF */
11740 if (uses_msp430x_relocs ())
11741 break;
1a0670f3 11742 /* Fall through. */
13761a11 11743 case 21: /* R_MSP430X_SYM_DIFF */
f84ce13b
NC		 11744 /* PR 21139. */
11745 if (sym_index >= num_syms)
11746 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11747 sym_index);
11748 else
11749 saved_sym = symtab + sym_index;
13761a11
NC		 11750 return TRUE;
11751
11752 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11753 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11754 goto handle_sym_diff;
0b4362b0 11755
13761a11
NC		 11756 case 5: /* R_MSP430_16_BYTE */
11757 case 9: /* R_MSP430_8 */
11758 if (uses_msp430x_relocs ())
11759 break;
11760 goto handle_sym_diff;
11761
11762 case 2: /* R_MSP430_ABS16 */
11763 case 15: /* R_MSP430X_ABS16 */
11764 if (! uses_msp430x_relocs ())
11765 break;
11766 goto handle_sym_diff;
0b4362b0 11767
13761a11
NC		 11768 handle_sym_diff:
11769 if (saved_sym != NULL)
11770 {
03f7786e 11771 int reloc_size = reloc_type == 1 ? 4 : 2;
13761a11
NC		 11772 bfd_vma value;
11773
f84ce13b
NC		 11774 if (sym_index >= num_syms)
11775 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
11776 sym_index);
03f7786e 11777 else
f84ce13b
NC		 11778 {
11779 value = reloc->r_addend + (symtab[sym_index].st_value
11780 - saved_sym->st_value);
11781
b32e566b 11782 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
f84ce13b 11783 byte_put (start + reloc->r_offset, value, reloc_size);
b32e566b
NC		 11784 else
11785 /* PR 21137 */
11786 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
11787 (long) reloc->r_offset);
f84ce13b 11788 }
13761a11
NC		 11789
11790 saved_sym = NULL;
11791 return TRUE;
11792 }
11793 break;
11794
11795 default:
11796 if (saved_sym != NULL)
071436c6 11797 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13761a11
NC		 11798 break;
11799 }
11800 break;
11801 }
11802
cf13d699
NC		 11803 case EM_MN10300:
11804 case EM_CYGNUS_MN10300:
11805 {
11806 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 11807
f84ce13b
NC		 11808 if (reloc == NULL)
11809 {
11810 saved_sym = NULL;
11811 return TRUE;
11812 }
11813
cf13d699
NC		 11814 switch (reloc_type)
11815 {
11816 case 34: /* R_MN10300_ALIGN */
11817 return TRUE;
11818 case 33: /* R_MN10300_SYM_DIFF */
f84ce13b
NC		 11819 if (sym_index >= num_syms)
11820 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
11821 sym_index);
11822 else
11823 saved_sym = symtab + sym_index;
cf13d699 11824 return TRUE;
f84ce13b 11825
cf13d699
NC		 11826 case 1: /* R_MN10300_32 */
11827 case 2: /* R_MN10300_16 */
11828 if (saved_sym != NULL)
11829 {
03f7786e 11830 int reloc_size = reloc_type == 1 ? 4 : 2;
cf13d699 11831 bfd_vma value;
252b5132 11832
f84ce13b
NC		 11833 if (sym_index >= num_syms)
11834 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
11835 sym_index);
03f7786e 11836 else
f84ce13b
NC		 11837 {
11838 value = reloc->r_addend + (symtab[sym_index].st_value
11839 - saved_sym->st_value);
11840
b32e566b 11841 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
f84ce13b 11842 byte_put (start + reloc->r_offset, value, reloc_size);
b32e566b
NC		 11843 else
11844 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
11845 (long) reloc->r_offset);
f84ce13b 11846 }
252b5132 11847
cf13d699
NC		 11848 saved_sym = NULL;
11849 return TRUE;
11850 }
11851 break;
11852 default:
11853 if (saved_sym != NULL)
071436c6 11854 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
cf13d699
NC		 11855 break;
11856 }
11857 break;
11858 }
6ff71e76
NC		 11859
11860 case EM_RL78:
11861 {
11862 static bfd_vma saved_sym1 = 0;
11863 static bfd_vma saved_sym2 = 0;
11864 static bfd_vma value;
11865
f84ce13b
NC		 11866 if (reloc == NULL)
11867 {
11868 saved_sym1 = saved_sym2 = 0;
11869 return TRUE;
11870 }
11871
6ff71e76
NC		 11872 switch (reloc_type)
11873 {
11874 case 0x80: /* R_RL78_SYM. */
11875 saved_sym1 = saved_sym2;
f84ce13b
NC		 11876 if (sym_index >= num_syms)
11877 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
11878 sym_index);
11879 else
11880 {
11881 saved_sym2 = symtab[sym_index].st_value;
11882 saved_sym2 += reloc->r_addend;
11883 }
6ff71e76
NC		 11884 return TRUE;
11885
11886 case 0x83: /* R_RL78_OPsub. */
11887 value = saved_sym1 - saved_sym2;
11888 saved_sym2 = saved_sym1 = 0;
11889 return TRUE;
11890 break;
11891
11892 case 0x41: /* R_RL78_ABS32. */
b32e566b 11893 if (IN_RANGE (start, end, start + reloc->r_offset, 4))
03f7786e 11894 byte_put (start + reloc->r_offset, value, 4);
b32e566b
NC		 11895 else
11896 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11897 (long) reloc->r_offset);
6ff71e76
NC		 11898 value = 0;
11899 return TRUE;
11900
11901 case 0x43: /* R_RL78_ABS16. */
b32e566b 11902 if (IN_RANGE (start, end, start + reloc->r_offset, 2))
03f7786e 11903 byte_put (start + reloc->r_offset, value, 2);
b32e566b
NC		 11904 else
11905 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11906 (long) reloc->r_offset);
6ff71e76
NC		 11907 value = 0;
11908 return TRUE;
11909
11910 default:
11911 break;
11912 }
11913 break;
11914 }
252b5132
RH		 11915 }
11916
cf13d699 11917 return FALSE;
252b5132
RH		 11918}
11919
aca88567
NC		 11920/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11921 DWARF debug sections. This is a target specific test. Note - we do not
11922 go through the whole including-target-headers-multiple-times route, (as
11923 we have already done with <elf/h8.h>) because this would become very
11924 messy and even then this function would have to contain target specific
11925 information (the names of the relocs instead of their numeric values).
11926 FIXME: This is not the correct way to solve this problem. The proper way
11927 is to have target specific reloc sizing and typing functions created by
11928 the reloc-macros.h header, in the same way that it already creates the
11929 reloc naming functions. */
11930
11931static bfd_boolean
11932is_32bit_abs_reloc (unsigned int reloc_type)
11933{
d347c9df 11934 /* Please keep this table alpha-sorted for ease of visual lookup. */
aca88567
NC		 11935 switch (elf_header.e_machine)
11936 {
41e92641 11937 case EM_386:
22abe556 11938 case EM_IAMCU:
41e92641 11939 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 11940 case EM_68K:
11941 return reloc_type == 1; /* R_68K_32. */
11942 case EM_860:
11943 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 11944 case EM_960:
11945 return reloc_type == 2; /* R_960_32. */
a06ea964 11946 case EM_AARCH64:
9282b95a
JW		 11947 return (reloc_type == 258
11948 || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
d347c9df
PS		 11949 case EM_ADAPTEVA_EPIPHANY:
11950 return reloc_type == 3;
aca88567 11951 case EM_ALPHA:
137b6b5f 11952 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 11953 case EM_ARC:
11954 return reloc_type == 1; /* R_ARC_32. */
886a2506
NC		 11955 case EM_ARC_COMPACT:
11956 case EM_ARC_COMPACT2:
11957 return reloc_type == 4; /* R_ARC_32. */
41e92641
NC		 11958 case EM_ARM:
11959 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 11960 case EM_AVR_OLD:
aca88567
NC		 11961 case EM_AVR:
11962 return reloc_type == 1;
11963 case EM_BLACKFIN:
11964 return reloc_type == 0x12; /* R_byte4_data. */
11965 case EM_CRIS:
11966 return reloc_type == 3; /* R_CRIS_32. */
11967 case EM_CR16:
11968 return reloc_type == 3; /* R_CR16_NUM32. */
11969 case EM_CRX:
11970 return reloc_type == 15; /* R_CRX_NUM32. */
11971 case EM_CYGNUS_FRV:
11972 return reloc_type == 1;
41e92641
NC		 11973 case EM_CYGNUS_D10V:
11974 case EM_D10V:
11975 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 11976 case EM_CYGNUS_D30V:
11977 case EM_D30V:
11978 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 11979 case EM_DLX:
11980 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 11981 case EM_CYGNUS_FR30:
11982 case EM_FR30:
11983 return reloc_type == 3; /* R_FR30_32. */
3f8107ab
AM		 11984 case EM_FT32:
11985 return reloc_type == 1; /* R_FT32_32. */
aca88567
NC		 11986 case EM_H8S:
11987 case EM_H8_300:
11988 case EM_H8_300H:
11989 return reloc_type == 1; /* R_H8_DIR32. */
3730236a 11990 case EM_IA_64:
d1c4b12b
NC		 11991 return reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
11992 || reloc_type == 0x25; /* R_IA64_DIR32LSB. */
aca88567
NC		 11993 case EM_IP2K_OLD:
11994 case EM_IP2K:
11995 return reloc_type == 2; /* R_IP2K_32. */
11996 case EM_IQ2000:
11997 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 11998 case EM_LATTICEMICO32:
11999 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 12000 case EM_M32C_OLD:
aca88567
NC		 12001 case EM_M32C:
12002 return reloc_type == 3; /* R_M32C_32. */
12003 case EM_M32R:
12004 return reloc_type == 34; /* R_M32R_32_RELA. */
adec12c1
AM		 12005 case EM_68HC11:
12006 case EM_68HC12:
12007 return reloc_type == 6; /* R_M68HC11_32. */
aca88567
NC		 12008 case EM_MCORE:
12009 return reloc_type == 1; /* R_MCORE_ADDR32. */
12010 case EM_CYGNUS_MEP:
12011 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 12012 case EM_METAG:
12013 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 12014 case EM_MICROBLAZE:
12015 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 12016 case EM_MIPS:
12017 return reloc_type == 2; /* R_MIPS_32. */
12018 case EM_MMIX:
12019 return reloc_type == 4; /* R_MMIX_32. */
12020 case EM_CYGNUS_MN10200:
12021 case EM_MN10200:
12022 return reloc_type == 1; /* R_MN10200_32. */
12023 case EM_CYGNUS_MN10300:
12024 case EM_MN10300:
12025 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 12026 case EM_MOXIE:
12027 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 12028 case EM_MSP430_OLD:
12029 case EM_MSP430:
13761a11 12030 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
aca88567
NC		 12031 case EM_MT:
12032 return reloc_type == 2; /* R_MT_32. */
35c08157
KLC		 12033 case EM_NDS32:
12034 return reloc_type == 20; /* R_NDS32_RELA. */
3e0873ac 12035 case EM_ALTERA_NIOS2:
36591ba1 12036 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
3e0873ac
NC		 12037 case EM_NIOS32:
12038 return reloc_type == 1; /* R_NIOS_32. */
73589c9d
CS		 12039 case EM_OR1K:
12040 return reloc_type == 1; /* R_OR1K_32. */
aca88567 12041 case EM_PARISC:
5fda8eca
NC		 12042 return (reloc_type == 1 /* R_PARISC_DIR32. */
12043 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 12044 case EM_PJ:
12045 case EM_PJ_OLD:
12046 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
12047 case EM_PPC64:
12048 return reloc_type == 1; /* R_PPC64_ADDR32. */
12049 case EM_PPC:
12050 return reloc_type == 1; /* R_PPC_ADDR32. */
2b100bb5
DD		 12051 case EM_TI_PRU:
12052 return reloc_type == 11; /* R_PRU_BFD_RELOC_32. */
e23eba97
NC		 12053 case EM_RISCV:
12054 return reloc_type == 1; /* R_RISCV_32. */
99c513f6
DD		 12055 case EM_RL78:
12056 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 12057 case EM_RX:
12058 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 12059 case EM_S370:
12060 return reloc_type == 1; /* R_I370_ADDR31. */
12061 case EM_S390_OLD:
12062 case EM_S390:
12063 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 12064 case EM_SCORE:
12065 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 12066 case EM_SH:
12067 return reloc_type == 1; /* R_SH_DIR32. */
12068 case EM_SPARC32PLUS:
12069 case EM_SPARCV9:
12070 case EM_SPARC:
12071 return reloc_type == 3 /* R_SPARC_32. */
12072 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 12073 case EM_SPU:
12074 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 12075 case EM_TI_C6000:
12076 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 12077 case EM_TILEGX:
12078 return reloc_type == 2; /* R_TILEGX_32. */
12079 case EM_TILEPRO:
12080 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 12081 case EM_CYGNUS_V850:
12082 case EM_V850:
12083 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 12084 case EM_V800:
12085 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 12086 case EM_VAX:
12087 return reloc_type == 1; /* R_VAX_32. */
619ed720
EB		 12088 case EM_VISIUM:
12089 return reloc_type == 3; /* R_VISIUM_32. */
aca88567 12090 case EM_X86_64:
8a9036a4 12091 case EM_L1OM:
7a9068fe 12092 case EM_K1OM:
aca88567 12093 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 12094 case EM_XC16X:
12095 case EM_C166:
12096 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 12097 case EM_XGATE:
12098 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 12099 case EM_XSTORMY16:
12100 return reloc_type == 1; /* R_XSTROMY16_32. */
12101 case EM_XTENSA_OLD:
12102 case EM_XTENSA:
12103 return reloc_type == 1; /* R_XTENSA_32. */
aca88567 12104 default:
bee0ee85
NC		 12105 {
12106 static unsigned int prev_warn = 0;
12107
12108 /* Avoid repeating the same warning multiple times. */
12109 if (prev_warn != elf_header.e_machine)
12110 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12111 elf_header.e_machine);
12112 prev_warn = elf_header.e_machine;
12113 return FALSE;
12114 }
aca88567
NC		 12115 }
12116}
12117
12118/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12119 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12120
12121static bfd_boolean
12122is_32bit_pcrel_reloc (unsigned int reloc_type)
12123{
12124 switch (elf_header.e_machine)
d347c9df 12125 /* Please keep this table alpha-sorted for ease of visual lookup. */
aca88567 12126 {
41e92641 12127 case EM_386:
22abe556 12128 case EM_IAMCU:
3e0873ac 12129 return reloc_type == 2; /* R_386_PC32. */
aca88567 12130 case EM_68K:
3e0873ac 12131 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 12132 case EM_AARCH64:
12133 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 12134 case EM_ADAPTEVA_EPIPHANY:
12135 return reloc_type == 6;
aca88567
NC		 12136 case EM_ALPHA:
12137 return reloc_type == 10; /* R_ALPHA_SREL32. */
726c18e1
CZ		 12138 case EM_ARC_COMPACT:
12139 case EM_ARC_COMPACT2:
12140 return reloc_type == 49; /* R_ARC_32_PCREL. */
41e92641 12141 case EM_ARM:
3e0873ac 12142 return reloc_type == 3; /* R_ARM_REL32 */
d347c9df
PS		 12143 case EM_AVR_OLD:
12144 case EM_AVR:
12145 return reloc_type == 36; /* R_AVR_32_PCREL. */
137b6b5f
AM		 12146 case EM_MICROBLAZE:
12147 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
73589c9d
CS		 12148 case EM_OR1K:
12149 return reloc_type == 9; /* R_OR1K_32_PCREL. */
aca88567 12150 case EM_PARISC:
85acf597 12151 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 12152 case EM_PPC:
12153 return reloc_type == 26; /* R_PPC_REL32. */
12154 case EM_PPC64:
3e0873ac 12155 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 12156 case EM_S390_OLD:
12157 case EM_S390:
3e0873ac 12158 return reloc_type == 5; /* R_390_PC32. */
aca88567 12159 case EM_SH:
3e0873ac 12160 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 12161 case EM_SPARC32PLUS:
12162 case EM_SPARCV9:
12163 case EM_SPARC:
3e0873ac 12164 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 12165 case EM_SPU:
12166 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 12167 case EM_TILEGX:
12168 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
12169 case EM_TILEPRO:
12170 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
619ed720
EB		 12171 case EM_VISIUM:
12172 return reloc_type == 6; /* R_VISIUM_32_PCREL */
aca88567 12173 case EM_X86_64:
8a9036a4 12174 case EM_L1OM:
7a9068fe 12175 case EM_K1OM:
3e0873ac 12176 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 12177 case EM_XTENSA_OLD:
12178 case EM_XTENSA:
12179 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 12180 default:
12181 /* Do not abort or issue an error message here. Not all targets use
12182 pc-relative 32-bit relocs in their DWARF debug information and we
12183 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 12184 more helpful warning message will be generated by apply_relocations
12185 anyway, so just return. */
aca88567
NC		 12186 return FALSE;
12187 }
12188}
12189
12190/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12191 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12192
12193static bfd_boolean
12194is_64bit_abs_reloc (unsigned int reloc_type)
12195{
12196 switch (elf_header.e_machine)
12197 {
a06ea964
NC		 12198 case EM_AARCH64:
12199 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 12200 case EM_ALPHA:
12201 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 12202 case EM_IA_64:
12203 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 12204 case EM_PARISC:
12205 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 12206 case EM_PPC64:
12207 return reloc_type == 38; /* R_PPC64_ADDR64. */
e23eba97
NC		 12208 case EM_RISCV:
12209 return reloc_type == 2; /* R_RISCV_64. */
aca88567
NC		 12210 case EM_SPARC32PLUS:
12211 case EM_SPARCV9:
12212 case EM_SPARC:
12213 return reloc_type == 54; /* R_SPARC_UA64. */
12214 case EM_X86_64:
8a9036a4 12215 case EM_L1OM:
7a9068fe 12216 case EM_K1OM:
aca88567 12217 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 12218 case EM_S390_OLD:
12219 case EM_S390:
aa137e4d
NC		 12220 return reloc_type == 22; /* R_S390_64. */
12221 case EM_TILEGX:
12222 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 12223 case EM_MIPS:
aa137e4d 12224 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 12225 default:
12226 return FALSE;
12227 }
12228}
12229
85acf597
RH		 12230/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12231 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12232
12233static bfd_boolean
12234is_64bit_pcrel_reloc (unsigned int reloc_type)
12235{
12236 switch (elf_header.e_machine)
12237 {
a06ea964
NC		 12238 case EM_AARCH64:
12239 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 12240 case EM_ALPHA:
aa137e4d 12241 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 12242 case EM_IA_64:
aa137e4d 12243 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 12244 case EM_PARISC:
aa137e4d 12245 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 12246 case EM_PPC64:
aa137e4d 12247 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 12248 case EM_SPARC32PLUS:
12249 case EM_SPARCV9:
12250 case EM_SPARC:
aa137e4d 12251 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 12252 case EM_X86_64:
8a9036a4 12253 case EM_L1OM:
7a9068fe 12254 case EM_K1OM:
aa137e4d 12255 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 12256 case EM_S390_OLD:
12257 case EM_S390:
aa137e4d
NC		 12258 return reloc_type == 23; /* R_S390_PC64. */
12259 case EM_TILEGX:
12260 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 12261 default:
12262 return FALSE;
12263 }
12264}
12265
4dc3c23d
AM		 12266/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12267 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12268
12269static bfd_boolean
12270is_24bit_abs_reloc (unsigned int reloc_type)
12271{
12272 switch (elf_header.e_machine)
12273 {
12274 case EM_CYGNUS_MN10200:
12275 case EM_MN10200:
12276 return reloc_type == 4; /* R_MN10200_24. */
3ee6e4fb
NC		 12277 case EM_FT32:
12278 return reloc_type == 5; /* R_FT32_20. */
4dc3c23d
AM		 12279 default:
12280 return FALSE;
12281 }
12282}
12283
aca88567
NC		 12284/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12285 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12286
12287static bfd_boolean
12288is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a 12289{
d347c9df 12290 /* Please keep this table alpha-sorted for ease of visual lookup. */
4b78141a
NC		 12291 switch (elf_header.e_machine)
12292 {
886a2506
NC		 12293 case EM_ARC:
12294 case EM_ARC_COMPACT:
12295 case EM_ARC_COMPACT2:
12296 return reloc_type == 2; /* R_ARC_16. */
d347c9df
PS		 12297 case EM_ADAPTEVA_EPIPHANY:
12298 return reloc_type == 5;
aca88567
NC		 12299 case EM_AVR_OLD:
12300 case EM_AVR:
12301 return reloc_type == 4; /* R_AVR_16. */
41e92641
NC		 12302 case EM_CYGNUS_D10V:
12303 case EM_D10V:
12304 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 12305 case EM_H8S:
12306 case EM_H8_300:
12307 case EM_H8_300H:
aca88567
NC		 12308 return reloc_type == R_H8_DIR16;
12309 case EM_IP2K_OLD:
12310 case EM_IP2K:
12311 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 12312 case EM_M32C_OLD:
f4236fe4
DD		 12313 case EM_M32C:
12314 return reloc_type == 1; /* R_M32C_16 */
d347c9df
PS		 12315 case EM_CYGNUS_MN10200:
12316 case EM_MN10200:
12317 return reloc_type == 2; /* R_MN10200_16. */
12318 case EM_CYGNUS_MN10300:
12319 case EM_MN10300:
12320 return reloc_type == 2; /* R_MN10300_16. */
aca88567 12321 case EM_MSP430:
13761a11
NC		 12322 if (uses_msp430x_relocs ())
12323 return reloc_type == 2; /* R_MSP430_ABS16. */
1a0670f3 12324 /* Fall through. */
78c8d46c 12325 case EM_MSP430_OLD:
aca88567 12326 return reloc_type == 5; /* R_MSP430_16_BYTE. */
35c08157
KLC		 12327 case EM_NDS32:
12328 return reloc_type == 19; /* R_NDS32_RELA. */
3e0873ac 12329 case EM_ALTERA_NIOS2:
36591ba1 12330 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
3e0873ac
NC		 12331 case EM_NIOS32:
12332 return reloc_type == 9; /* R_NIOS_16. */
73589c9d
CS		 12333 case EM_OR1K:
12334 return reloc_type == 2; /* R_OR1K_16. */
2b100bb5
DD		 12335 case EM_TI_PRU:
12336 return reloc_type == 8; /* R_PRU_BFD_RELOC_16. */
40b36596
JM		 12337 case EM_TI_C6000:
12338 return reloc_type == 2; /* R_C6000_ABS16. */
d347c9df
PS		 12339 case EM_VISIUM:
12340 return reloc_type == 2; /* R_VISIUM_16. */
c29aca4a
NC		 12341 case EM_XC16X:
12342 case EM_C166:
12343 return reloc_type == 2; /* R_XC16C_ABS_16. */
f6c1a2d5
NC		 12344 case EM_XGATE:
12345 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 12346 default:
aca88567 12347 return FALSE;
4b78141a
NC		 12348 }
12349}
12350
2a7b2e88
JK		 12351/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12352 relocation entries (possibly formerly used for SHT_GROUP sections). */
12353
12354static bfd_boolean
12355is_none_reloc (unsigned int reloc_type)
12356{
12357 switch (elf_header.e_machine)
12358 {
cb8f3167 12359 case EM_386: /* R_386_NONE. */
d347c9df 12360 case EM_68K: /* R_68K_NONE. */
cfb8c092 12361 case EM_ADAPTEVA_EPIPHANY:
d347c9df
PS		 12362 case EM_ALPHA: /* R_ALPHA_NONE. */
12363 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
886a2506 12364 case EM_ARC: /* R_ARC_NONE. */
886a2506 12365 case EM_ARC_COMPACT2: /* R_ARC_NONE. */
d347c9df 12366 case EM_ARC_COMPACT: /* R_ARC_NONE. */
cb8f3167 12367 case EM_ARM: /* R_ARM_NONE. */
d347c9df 12368 case EM_C166: /* R_XC16X_NONE. */
cb8f3167 12369 case EM_CRIS: /* R_CRIS_NONE. */
d347c9df
PS		 12370 case EM_FT32: /* R_FT32_NONE. */
12371 case EM_IA_64: /* R_IA64_NONE. */
7a9068fe 12372 case EM_K1OM: /* R_X86_64_NONE. */
d347c9df
PS		 12373 case EM_L1OM: /* R_X86_64_NONE. */
12374 case EM_M32R: /* R_M32R_NONE. */
12375 case EM_MIPS: /* R_MIPS_NONE. */
cb8f3167 12376 case EM_MN10300: /* R_MN10300_NONE. */
5506d11a 12377 case EM_MOXIE: /* R_MOXIE_NONE. */
d347c9df
PS		 12378 case EM_NIOS32: /* R_NIOS_NONE. */
12379 case EM_OR1K: /* R_OR1K_NONE. */
12380 case EM_PARISC: /* R_PARISC_NONE. */
12381 case EM_PPC64: /* R_PPC64_NONE. */
12382 case EM_PPC: /* R_PPC_NONE. */
e23eba97 12383 case EM_RISCV: /* R_RISCV_NONE. */
d347c9df
PS		 12384 case EM_S390: /* R_390_NONE. */
12385 case EM_S390_OLD:
12386 case EM_SH: /* R_SH_NONE. */
12387 case EM_SPARC32PLUS:
12388 case EM_SPARC: /* R_SPARC_NONE. */
12389 case EM_SPARCV9:
aa137e4d
NC		 12390 case EM_TILEGX: /* R_TILEGX_NONE. */
12391 case EM_TILEPRO: /* R_TILEPRO_NONE. */
d347c9df
PS		 12392 case EM_TI_C6000:/* R_C6000_NONE. */
12393 case EM_X86_64: /* R_X86_64_NONE. */
c29aca4a 12394 case EM_XC16X:
cb8f3167 12395 return reloc_type == 0;
d347c9df 12396
a06ea964
NC		 12397 case EM_AARCH64:
12398 return reloc_type == 0 || reloc_type == 256;
d347c9df
PS		 12399 case EM_AVR_OLD:
12400 case EM_AVR:
12401 return (reloc_type == 0 /* R_AVR_NONE. */
12402 || reloc_type == 30 /* R_AVR_DIFF8. */
12403 || reloc_type == 31 /* R_AVR_DIFF16. */
12404 || reloc_type == 32 /* R_AVR_DIFF32. */);
12405 case EM_METAG:
12406 return reloc_type == 3; /* R_METAG_NONE. */
35c08157
KLC		 12407 case EM_NDS32:
12408 return (reloc_type == 0 /* R_XTENSA_NONE. */
12409 || reloc_type == 204 /* R_NDS32_DIFF8. */
12410 || reloc_type == 205 /* R_NDS32_DIFF16. */
12411 || reloc_type == 206 /* R_NDS32_DIFF32. */
12412 || reloc_type == 207 /* R_NDS32_ULEB128. */);
2b100bb5
DD		 12413 case EM_TI_PRU:
12414 return (reloc_type == 0 /* R_PRU_NONE. */
12415 || reloc_type == 65 /* R_PRU_DIFF8. */
12416 || reloc_type == 66 /* R_PRU_DIFF16. */
12417 || reloc_type == 67 /* R_PRU_DIFF32. */);
58332dda
JK		 12418 case EM_XTENSA_OLD:
12419 case EM_XTENSA:
4dc3c23d
AM		 12420 return (reloc_type == 0 /* R_XTENSA_NONE. */
12421 || reloc_type == 17 /* R_XTENSA_DIFF8. */
12422 || reloc_type == 18 /* R_XTENSA_DIFF16. */
12423 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
2a7b2e88
JK		 12424 }
12425 return FALSE;
12426}
12427
d1c4b12b
NC		 12428/* Returns TRUE if there is a relocation against
12429 section NAME at OFFSET bytes. */
12430
12431bfd_boolean
12432reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
12433{
12434 Elf_Internal_Rela * relocs;
12435 Elf_Internal_Rela * rp;
12436
12437 if (dsec == NULL || dsec->reloc_info == NULL)
12438 return FALSE;
12439
12440 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
12441
12442 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
12443 if (rp->r_offset == offset)
12444 return TRUE;
12445
12446 return FALSE;
12447}
12448
cf13d699 12449/* Apply relocations to a section.
32ec8896
NC		 12450 Returns TRUE upon success, FALSE otherwise.
12451 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12452 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
12453 will be set to the number of relocs loaded.
12454
cf13d699 12455 Note: So far support has been added only for those relocations
32ec8896
NC		 12456 which can be found in debug sections. FIXME: Add support for
12457 more relocations ? */
1b315056 12458
32ec8896 12459static bfd_boolean
d1c4b12b
NC		 12460apply_relocations (void * file,
12461 const Elf_Internal_Shdr * section,
12462 unsigned char * start,
12463 bfd_size_type size,
1449284b 12464 void ** relocs_return,
d1c4b12b 12465 unsigned long * num_relocs_return)
1b315056 12466{
cf13d699 12467 Elf_Internal_Shdr * relsec;
0d2a7a93 12468 unsigned char * end = start + size;
32ec8896 12469 bfd_boolean res = TRUE;
cb8f3167 12470
d1c4b12b
NC		 12471 if (relocs_return != NULL)
12472 {
12473 * (Elf_Internal_Rela **) relocs_return = NULL;
12474 * num_relocs_return = 0;
12475 }
12476
cf13d699 12477 if (elf_header.e_type != ET_REL)
32ec8896
NC		 12478 /* No relocs to apply. */
12479 return TRUE;
1b315056 12480
cf13d699 12481 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 12482 for (relsec = section_headers;
12483 relsec < section_headers + elf_header.e_shnum;
12484 ++relsec)
252b5132 12485 {
41e92641
NC		 12486 bfd_boolean is_rela;
12487 unsigned long num_relocs;
2cf0635d
NC		 12488 Elf_Internal_Rela * relocs;
12489 Elf_Internal_Rela * rp;
12490 Elf_Internal_Shdr * symsec;
12491 Elf_Internal_Sym * symtab;
ba5cdace 12492 unsigned long num_syms;
2cf0635d 12493 Elf_Internal_Sym * sym;
252b5132 12494
41e92641 12495 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 12496 || relsec->sh_info >= elf_header.e_shnum
12497 || section_headers + relsec->sh_info != section
c256ffe7 12498 || relsec->sh_size == 0
4fbb74a6 12499 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 12500 continue;
428409d5 12501
41e92641
NC		 12502 is_rela = relsec->sh_type == SHT_RELA;
12503
12504 if (is_rela)
12505 {
3f5e193b
NC		 12506 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
12507 relsec->sh_size, & relocs, & num_relocs))
32ec8896 12508 return FALSE;
41e92641
NC		 12509 }
12510 else
12511 {
3f5e193b
NC		 12512 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
12513 relsec->sh_size, & relocs, & num_relocs))
32ec8896 12514 return FALSE;
41e92641
NC		 12515 }
12516
12517 /* SH uses RELA but uses in place value instead of the addend field. */
12518 if (elf_header.e_machine == EM_SH)
12519 is_rela = FALSE;
428409d5 12520
4fbb74a6 12521 symsec = section_headers + relsec->sh_link;
1449284b
NC		 12522 if (symsec->sh_type != SHT_SYMTAB
12523 && symsec->sh_type != SHT_DYNSYM)
32ec8896 12524 return FALSE;
ba5cdace 12525 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 12526
41e92641 12527 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 12528 {
41e92641
NC		 12529 bfd_vma addend;
12530 unsigned int reloc_type;
12531 unsigned int reloc_size;
91d6fa6a 12532 unsigned char * rloc;
ba5cdace 12533 unsigned long sym_index;
4b78141a 12534
aca88567 12535 reloc_type = get_reloc_type (rp->r_info);
41e92641 12536
f84ce13b 12537 if (target_specific_reloc_handling (rp, start, end, symtab, num_syms))
2a7b2e88 12538 continue;
98fb390a
NC		 12539 else if (is_none_reloc (reloc_type))
12540 continue;
12541 else if (is_32bit_abs_reloc (reloc_type)
12542 || is_32bit_pcrel_reloc (reloc_type))
aca88567 12543 reloc_size = 4;
85acf597
RH		 12544 else if (is_64bit_abs_reloc (reloc_type)
12545 || is_64bit_pcrel_reloc (reloc_type))
aca88567 12546 reloc_size = 8;
4dc3c23d
AM		 12547 else if (is_24bit_abs_reloc (reloc_type))
12548 reloc_size = 3;
aca88567
NC		 12549 else if (is_16bit_abs_reloc (reloc_type))
12550 reloc_size = 2;
12551 else
4b78141a 12552 {
bee0ee85
NC		 12553 static unsigned int prev_reloc = 0;
12554 if (reloc_type != prev_reloc)
12555 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12556 reloc_type, printable_section_name (section));
12557 prev_reloc = reloc_type;
32ec8896 12558 res = FALSE;
4b78141a
NC		 12559 continue;
12560 }
103f02d3 12561
91d6fa6a 12562 rloc = start + rp->r_offset;
c8da6823 12563 if ((rloc + reloc_size) > end || (rloc < start))
700dd8b7
L		 12564 {
12565 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12566 (unsigned long) rp->r_offset,
74e1a04b 12567 printable_section_name (section));
32ec8896 12568 res = FALSE;
700dd8b7
L		 12569 continue;
12570 }
103f02d3 12571
ba5cdace
NC		 12572 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
12573 if (sym_index >= num_syms)
12574 {
12575 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
74e1a04b 12576 sym_index, printable_section_name (section));
32ec8896 12577 res = FALSE;
ba5cdace
NC		 12578 continue;
12579 }
12580 sym = symtab + sym_index;
41e92641
NC		 12581
12582 /* If the reloc has a symbol associated with it,
55f25fc3
L		 12583 make sure that it is of an appropriate type.
12584
12585 Relocations against symbols without type can happen.
12586 Gcc -feliminate-dwarf2-dups may generate symbols
12587 without type for debug info.
12588
12589 Icc generates relocations against function symbols
12590 instead of local labels.
12591
12592 Relocations against object symbols can happen, eg when
12593 referencing a global array. For an example of this see
12594 the _clz.o binary in libgcc.a. */
aca88567 12595 if (sym != symtab
b8871f35 12596 && ELF_ST_TYPE (sym->st_info) != STT_COMMON
55f25fc3 12597 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 12598 {
41e92641 12599 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 12600 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 12601 (long int)(rp - relocs),
74e1a04b 12602 printable_section_name (relsec));
32ec8896 12603 res = FALSE;
aca88567 12604 continue;
5b18a4bc 12605 }
252b5132 12606
4dc3c23d
AM		 12607 addend = 0;
12608 if (is_rela)
12609 addend += rp->r_addend;
c47320c3
AM		 12610 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12611 partial_inplace. */
4dc3c23d
AM		 12612 if (!is_rela
12613 || (elf_header.e_machine == EM_XTENSA
12614 && reloc_type == 1)
12615 || ((elf_header.e_machine == EM_PJ
12616 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 12617 && reloc_type == 1)
12618 || ((elf_header.e_machine == EM_D30V
12619 || elf_header.e_machine == EM_CYGNUS_D30V)
12620 && reloc_type == 12))
91d6fa6a 12621 addend += byte_get (rloc, reloc_size);
cb8f3167 12622
85acf597
RH		 12623 if (is_32bit_pcrel_reloc (reloc_type)
12624 || is_64bit_pcrel_reloc (reloc_type))
12625 {
12626 /* On HPPA, all pc-relative relocations are biased by 8. */
12627 if (elf_header.e_machine == EM_PARISC)
12628 addend -= 8;
91d6fa6a 12629 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 12630 reloc_size);
12631 }
41e92641 12632 else
91d6fa6a 12633 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 12634 }
252b5132 12635
5b18a4bc 12636 free (symtab);
f84ce13b
NC		 12637 /* Let the target specific reloc processing code know that
12638 we have finished with these relocs. */
12639 target_specific_reloc_handling (NULL, NULL, NULL, NULL, 0);
d1c4b12b
NC		 12640
12641 if (relocs_return)
12642 {
12643 * (Elf_Internal_Rela **) relocs_return = relocs;
12644 * num_relocs_return = num_relocs;
12645 }
12646 else
12647 free (relocs);
12648
5b18a4bc
NC		 12649 break;
12650 }
32ec8896
NC		 12651
12652 return res;
5b18a4bc 12653}
103f02d3 12654
cf13d699 12655#ifdef SUPPORT_DISASSEMBLY
32ec8896 12656static bfd_boolean
cf13d699
NC		 12657disassemble_section (Elf_Internal_Shdr * section, FILE * file)
12658{
74e1a04b 12659 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
cf13d699 12660
74e1a04b 12661 /* FIXME: XXX -- to be done --- XXX */
cf13d699 12662
32ec8896 12663 return TRUE;
cf13d699
NC		 12664}
12665#endif
12666
12667/* Reads in the contents of SECTION from FILE, returning a pointer
12668 to a malloc'ed buffer or NULL if something went wrong. */
12669
12670static char *
12671get_section_contents (Elf_Internal_Shdr * section, FILE * file)
12672{
12673 bfd_size_type num_bytes;
12674
12675 num_bytes = section->sh_size;
12676
12677 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
12678 {
12679 printf (_("\nSection '%s' has no data to dump.\n"),
74e1a04b 12680 printable_section_name (section));
cf13d699
NC		 12681 return NULL;
12682 }
12683
3f5e193b
NC		 12684 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
12685 _("section contents"));
cf13d699
NC		 12686}
12687
0e602686
NC		 12688/* Uncompresses a section that was compressed using zlib, in place. */
12689
12690static bfd_boolean
12691uncompress_section_contents (unsigned char **buffer,
12692 dwarf_size_type uncompressed_size,
12693 dwarf_size_type *size)
12694{
12695 dwarf_size_type compressed_size = *size;
12696 unsigned char * compressed_buffer = *buffer;
12697 unsigned char * uncompressed_buffer;
12698 z_stream strm;
12699 int rc;
12700
12701 /* It is possible the section consists of several compressed
12702 buffers concatenated together, so we uncompress in a loop. */
12703 /* PR 18313: The state field in the z_stream structure is supposed
12704 to be invisible to the user (ie us), but some compilers will
12705 still complain about it being used without initialisation. So
12706 we first zero the entire z_stream structure and then set the fields
12707 that we need. */
12708 memset (& strm, 0, sizeof strm);
12709 strm.avail_in = compressed_size;
12710 strm.next_in = (Bytef *) compressed_buffer;
12711 strm.avail_out = uncompressed_size;
12712 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
12713
12714 rc = inflateInit (& strm);
12715 while (strm.avail_in > 0)
12716 {
12717 if (rc != Z_OK)
12718 goto fail;
12719 strm.next_out = ((Bytef *) uncompressed_buffer
12720 + (uncompressed_size - strm.avail_out));
12721 rc = inflate (&strm, Z_FINISH);
12722 if (rc != Z_STREAM_END)
12723 goto fail;
12724 rc = inflateReset (& strm);
12725 }
12726 rc = inflateEnd (& strm);
12727 if (rc != Z_OK
12728 || strm.avail_out != 0)
12729 goto fail;
12730
12731 *buffer = uncompressed_buffer;
12732 *size = uncompressed_size;
12733 return TRUE;
12734
12735 fail:
12736 free (uncompressed_buffer);
12737 /* Indicate decompression failure. */
12738 *buffer = NULL;
12739 return FALSE;
12740}
dd24e3da 12741
32ec8896 12742static bfd_boolean
cf13d699
NC		 12743dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12744{
0e602686
NC		 12745 Elf_Internal_Shdr * relsec;
12746 bfd_size_type num_bytes;
fd8008d8
L		 12747 unsigned char * data;
12748 unsigned char * end;
12749 unsigned char * real_start;
12750 unsigned char * start;
0e602686 12751 bfd_boolean some_strings_shown;
cf13d699 12752
fd8008d8
L		 12753 real_start = start = (unsigned char *) get_section_contents (section,
12754 file);
cf13d699 12755 if (start == NULL)
32ec8896 12756 return FALSE;
0e602686 12757 num_bytes = section->sh_size;
cf13d699 12758
74e1a04b 12759 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
cf13d699 12760
0e602686
NC		 12761 if (decompress_dumps)
12762 {
12763 dwarf_size_type new_size = num_bytes;
12764 dwarf_size_type uncompressed_size = 0;
12765
12766 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12767 {
12768 Elf_Internal_Chdr chdr;
12769 unsigned int compression_header_size
ebdf1ebf
NC		 12770 = get_compression_header (& chdr, (unsigned char *) start,
12771 num_bytes);
0e602686 12772
813dabb9 12773 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
0e602686 12774 {
813dabb9
L		 12775 warn (_("section '%s' has unsupported compress type: %d\n"),
12776 printable_section_name (section), chdr.ch_type);
32ec8896 12777 return FALSE;
813dabb9
L		 12778 }
12779 else if (chdr.ch_addralign != section->sh_addralign)
12780 {
12781 warn (_("compressed section '%s' is corrupted\n"),
12782 printable_section_name (section));
32ec8896 12783 return FALSE;
0e602686 12784 }
813dabb9
L		 12785 uncompressed_size = chdr.ch_size;
12786 start += compression_header_size;
12787 new_size -= compression_header_size;
0e602686
NC		 12788 }
12789 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12790 {
12791 /* Read the zlib header. In this case, it should be "ZLIB"
12792 followed by the uncompressed section size, 8 bytes in
12793 big-endian order. */
12794 uncompressed_size = start[4]; uncompressed_size <<= 8;
12795 uncompressed_size += start[5]; uncompressed_size <<= 8;
12796 uncompressed_size += start[6]; uncompressed_size <<= 8;
12797 uncompressed_size += start[7]; uncompressed_size <<= 8;
12798 uncompressed_size += start[8]; uncompressed_size <<= 8;
12799 uncompressed_size += start[9]; uncompressed_size <<= 8;
12800 uncompressed_size += start[10]; uncompressed_size <<= 8;
12801 uncompressed_size += start[11];
12802 start += 12;
12803 new_size -= 12;
12804 }
12805
1835f746
NC		 12806 if (uncompressed_size)
12807 {
12808 if (uncompress_section_contents (& start,
12809 uncompressed_size, & new_size))
12810 num_bytes = new_size;
12811 else
12812 {
12813 error (_("Unable to decompress section %s\n"),
12814 printable_section_name (section));
32ec8896 12815 return FALSE;
1835f746
NC		 12816 }
12817 }
bc303e5d
NC		 12818 else
12819 start = real_start;
0e602686 12820 }
fd8008d8 12821
cf13d699
NC		 12822 /* If the section being dumped has relocations against it the user might
12823 be expecting these relocations to have been applied. Check for this
12824 case and issue a warning message in order to avoid confusion.
12825 FIXME: Maybe we ought to have an option that dumps a section with
12826 relocs applied ? */
12827 for (relsec = section_headers;
12828 relsec < section_headers + elf_header.e_shnum;
12829 ++relsec)
12830 {
12831 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12832 || relsec->sh_info >= elf_header.e_shnum
12833 || section_headers + relsec->sh_info != section
12834 || relsec->sh_size == 0
12835 || relsec->sh_link >= elf_header.e_shnum)
12836 continue;
12837
12838 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12839 break;
12840 }
12841
cf13d699
NC		 12842 data = start;
12843 end = start + num_bytes;
12844 some_strings_shown = FALSE;
12845
12846 while (data < end)
12847 {
12848 while (!ISPRINT (* data))
12849 if (++ data >= end)
12850 break;
12851
12852 if (data < end)
12853 {
071436c6
NC		 12854 size_t maxlen = end - data;
12855
cf13d699 12856#ifndef __MSVCRT__
c975cc98
NC		 12857 /* PR 11128: Use two separate invocations in order to work
12858 around bugs in the Solaris 8 implementation of printf. */
12859 printf (" [%6tx] ", data - start);
cf13d699 12860#else
071436c6 12861 printf (" [%6Ix] ", (size_t) (data - start));
cf13d699 12862#endif
4082ef84
NC		 12863 if (maxlen > 0)
12864 {
fd8008d8 12865 print_symbol ((int) maxlen, (const char *) data);
4082ef84 12866 putchar ('\n');
fd8008d8 12867 data += strnlen ((const char *) data, maxlen);
4082ef84
NC		 12868 }
12869 else
12870 {
12871 printf (_("<corrupt>\n"));
12872 data = end;
12873 }
cf13d699
NC		 12874 some_strings_shown = TRUE;
12875 }
12876 }
12877
12878 if (! some_strings_shown)
12879 printf (_(" No strings found in this section."));
12880
0e602686 12881 free (real_start);
cf13d699
NC		 12882
12883 putchar ('\n');
32ec8896 12884 return TRUE;
cf13d699
NC		 12885}
12886
32ec8896 12887static bfd_boolean
cf13d699
NC		 12888dump_section_as_bytes (Elf_Internal_Shdr * section,
12889 FILE * file,
12890 bfd_boolean relocate)
12891{
12892 Elf_Internal_Shdr * relsec;
0e602686
NC		 12893 bfd_size_type bytes;
12894 bfd_size_type section_size;
12895 bfd_vma addr;
12896 unsigned char * data;
12897 unsigned char * real_start;
12898 unsigned char * start;
12899
12900 real_start = start = (unsigned char *) get_section_contents (section, file);
cf13d699 12901 if (start == NULL)
32ec8896
NC		 12902 return FALSE;
12903
0e602686 12904 section_size = section->sh_size;
cf13d699 12905
74e1a04b 12906 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
cf13d699 12907
0e602686
NC		 12908 if (decompress_dumps)
12909 {
12910 dwarf_size_type new_size = section_size;
12911 dwarf_size_type uncompressed_size = 0;
12912
12913 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12914 {
12915 Elf_Internal_Chdr chdr;
12916 unsigned int compression_header_size
ebdf1ebf 12917 = get_compression_header (& chdr, start, section_size);
0e602686 12918
813dabb9 12919 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
0e602686 12920 {
813dabb9
L		 12921 warn (_("section '%s' has unsupported compress type: %d\n"),
12922 printable_section_name (section), chdr.ch_type);
32ec8896 12923 return FALSE;
0e602686 12924 }
813dabb9
L		 12925 else if (chdr.ch_addralign != section->sh_addralign)
12926 {
12927 warn (_("compressed section '%s' is corrupted\n"),
12928 printable_section_name (section));
32ec8896 12929 return FALSE;
813dabb9
L		 12930 }
12931 uncompressed_size = chdr.ch_size;
12932 start += compression_header_size;
12933 new_size -= compression_header_size;
0e602686
NC		 12934 }
12935 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12936 {
12937 /* Read the zlib header. In this case, it should be "ZLIB"
12938 followed by the uncompressed section size, 8 bytes in
12939 big-endian order. */
12940 uncompressed_size = start[4]; uncompressed_size <<= 8;
12941 uncompressed_size += start[5]; uncompressed_size <<= 8;
12942 uncompressed_size += start[6]; uncompressed_size <<= 8;
12943 uncompressed_size += start[7]; uncompressed_size <<= 8;
12944 uncompressed_size += start[8]; uncompressed_size <<= 8;
12945 uncompressed_size += start[9]; uncompressed_size <<= 8;
12946 uncompressed_size += start[10]; uncompressed_size <<= 8;
12947 uncompressed_size += start[11];
12948 start += 12;
12949 new_size -= 12;
12950 }
12951
f055032e
NC		 12952 if (uncompressed_size)
12953 {
12954 if (uncompress_section_contents (& start, uncompressed_size,
12955 & new_size))
bc303e5d
NC		 12956 {
12957 section_size = new_size;
12958 }
f055032e
NC		 12959 else
12960 {
12961 error (_("Unable to decompress section %s\n"),
12962 printable_section_name (section));
bc303e5d 12963 /* FIXME: Print the section anyway ? */
32ec8896 12964 return FALSE;
f055032e
NC		 12965 }
12966 }
bc303e5d
NC		 12967 else
12968 start = real_start;
0e602686 12969 }
14ae95f2 12970
cf13d699
NC		 12971 if (relocate)
12972 {
32ec8896
NC		 12973 if (! apply_relocations (file, section, start, section_size, NULL, NULL))
12974 return FALSE;
cf13d699
NC		 12975 }
12976 else
12977 {
12978 /* If the section being dumped has relocations against it the user might
12979 be expecting these relocations to have been applied. Check for this
12980 case and issue a warning message in order to avoid confusion.
12981 FIXME: Maybe we ought to have an option that dumps a section with
12982 relocs applied ? */
12983 for (relsec = section_headers;
12984 relsec < section_headers + elf_header.e_shnum;
12985 ++relsec)
12986 {
12987 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12988 || relsec->sh_info >= elf_header.e_shnum
12989 || section_headers + relsec->sh_info != section
12990 || relsec->sh_size == 0
12991 || relsec->sh_link >= elf_header.e_shnum)
12992 continue;
12993
12994 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12995 break;
12996 }
12997 }
12998
12999 addr = section->sh_addr;
0e602686 13000 bytes = section_size;
cf13d699
NC		 13001 data = start;
13002
13003 while (bytes)
13004 {
13005 int j;
13006 int k;
13007 int lbytes;
13008
13009 lbytes = (bytes > 16 ? 16 : bytes);
13010
13011 printf (" 0x%8.8lx ", (unsigned long) addr);
13012
13013 for (j = 0; j < 16; j++)
13014 {
13015 if (j < lbytes)
13016 printf ("%2.2x", data[j]);
13017 else
13018 printf (" ");
13019
13020 if ((j & 3) == 3)
13021 printf (" ");
13022 }
13023
13024 for (j = 0; j < lbytes; j++)
13025 {
13026 k = data[j];
13027 if (k >= ' ' && k < 0x7f)
13028 printf ("%c", k);
13029 else
13030 printf (".");
13031 }
13032
13033 putchar ('\n');
13034
13035 data += lbytes;
13036 addr += lbytes;
13037 bytes -= lbytes;
13038 }
13039
0e602686 13040 free (real_start);
cf13d699
NC		 13041
13042 putchar ('\n');
32ec8896 13043 return TRUE;
cf13d699
NC		 13044}
13045
32ec8896 13046static bfd_boolean
d966045b 13047load_specific_debug_section (enum dwarf_section_display_enum debug,
0d2a7a93 13048 const Elf_Internal_Shdr * sec, void * file)
1007acb3 13049{
2cf0635d 13050 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 13051 char buf [64];
1007acb3 13052
19e6b90e
L		 13053 /* If it is already loaded, do nothing. */
13054 if (section->start != NULL)
32ec8896 13055 return TRUE;
1007acb3 13056
19e6b90e
L		 13057 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
13058 section->address = sec->sh_addr;
06614111 13059 section->user_data = NULL;
3f5e193b
NC		 13060 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
13061 sec->sh_offset, 1,
13062 sec->sh_size, buf);
59245841
NC		 13063 if (section->start == NULL)
13064 section->size = 0;
13065 else
13066 {
77115a4a
L		 13067 unsigned char *start = section->start;
13068 dwarf_size_type size = sec->sh_size;
dab394de 13069 dwarf_size_type uncompressed_size = 0;
77115a4a
L		 13070
13071 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
13072 {
13073 Elf_Internal_Chdr chdr;
d8024a91
NC		 13074 unsigned int compression_header_size;
13075
f53be977
L		 13076 if (size < (is_32bit_elf
13077 ? sizeof (Elf32_External_Chdr)
13078 : sizeof (Elf64_External_Chdr)))
d8024a91
NC		 13079 {
13080 warn (_("compressed section %s is too small to contain a compression header"),
13081 section->name);
32ec8896 13082 return FALSE;
d8024a91
NC		 13083 }
13084
ebdf1ebf 13085 compression_header_size = get_compression_header (&chdr, start, size);
d8024a91 13086
813dabb9
L		 13087 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13088 {
13089 warn (_("section '%s' has unsupported compress type: %d\n"),
13090 section->name, chdr.ch_type);
32ec8896 13091 return FALSE;
813dabb9
L		 13092 }
13093 else if (chdr.ch_addralign != sec->sh_addralign)
13094 {
13095 warn (_("compressed section '%s' is corrupted\n"),
13096 section->name);
32ec8896 13097 return FALSE;
813dabb9 13098 }
dab394de 13099 uncompressed_size = chdr.ch_size;
77115a4a
L		 13100 start += compression_header_size;
13101 size -= compression_header_size;
13102 }
dab394de
L		 13103 else if (size > 12 && streq ((char *) start, "ZLIB"))
13104 {
13105 /* Read the zlib header. In this case, it should be "ZLIB"
13106 followed by the uncompressed section size, 8 bytes in
13107 big-endian order. */
13108 uncompressed_size = start[4]; uncompressed_size <<= 8;
13109 uncompressed_size += start[5]; uncompressed_size <<= 8;
13110 uncompressed_size += start[6]; uncompressed_size <<= 8;
13111 uncompressed_size += start[7]; uncompressed_size <<= 8;
13112 uncompressed_size += start[8]; uncompressed_size <<= 8;
13113 uncompressed_size += start[9]; uncompressed_size <<= 8;
13114 uncompressed_size += start[10]; uncompressed_size <<= 8;
13115 uncompressed_size += start[11];
13116 start += 12;
13117 size -= 12;
13118 }
13119
1835f746 13120 if (uncompressed_size)
77115a4a 13121 {
1835f746
NC		 13122 if (uncompress_section_contents (&start, uncompressed_size,
13123 &size))
13124 {
13125 /* Free the compressed buffer, update the section buffer
13126 and the section size if uncompress is successful. */
13127 free (section->start);
13128 section->start = start;
13129 }
13130 else
13131 {
13132 error (_("Unable to decompress section %s\n"),
13133 printable_section_name (sec));
32ec8896 13134 return FALSE;
1835f746 13135 }
77115a4a 13136 }
bc303e5d 13137
77115a4a 13138 section->size = size;
59245841 13139 }
4a114e3e 13140
1b315056 13141 if (section->start == NULL)
32ec8896 13142 return FALSE;
1b315056 13143
19e6b90e 13144 if (debug_displays [debug].relocate)
32ec8896
NC		 13145 {
13146 if (! apply_relocations ((FILE *) file, sec, section->start, section->size,
13147 & section->reloc_info, & section->num_relocs))
13148 return FALSE;
13149 }
d1c4b12b
NC		 13150 else
13151 {
13152 section->reloc_info = NULL;
13153 section->num_relocs = 0;
13154 }
1007acb3 13155
32ec8896 13156 return TRUE;
1007acb3
L		 13157}
13158
657d0d47
CC		 13159/* If this is not NULL, load_debug_section will only look for sections
13160 within the list of sections given here. */
32ec8896 13161static unsigned int * section_subset = NULL;
657d0d47 13162
32ec8896 13163bfd_boolean
2cf0635d 13164load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 13165{
2cf0635d
NC		 13166 struct dwarf_section * section = &debug_displays [debug].section;
13167 Elf_Internal_Shdr * sec;
d966045b
DJ		 13168
13169 /* Locate the debug section. */
657d0d47 13170 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 13171 if (sec != NULL)
13172 section->name = section->uncompressed_name;
13173 else
13174 {
657d0d47 13175 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 13176 if (sec != NULL)
13177 section->name = section->compressed_name;
13178 }
13179 if (sec == NULL)
32ec8896 13180 return FALSE;
d966045b 13181
657d0d47
CC		 13182 /* If we're loading from a subset of sections, and we've loaded
13183 a section matching this name before, it's likely that it's a
13184 different one. */
13185 if (section_subset != NULL)
13186 free_debug_section (debug);
13187
3f5e193b 13188 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 13189}
13190
19e6b90e
L		 13191void
13192free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 13193{
2cf0635d 13194 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 13195
19e6b90e
L		 13196 if (section->start == NULL)
13197 return;
1007acb3 13198
19e6b90e
L		 13199 free ((char *) section->start);
13200 section->start = NULL;
13201 section->address = 0;
13202 section->size = 0;
1007acb3
L		 13203}
13204
32ec8896 13205static bfd_boolean
657d0d47 13206display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 13207{
2cf0635d 13208 char * name = SECTION_NAME (section);
74e1a04b 13209 const char * print_name = printable_section_name (section);
19e6b90e 13210 bfd_size_type length;
32ec8896 13211 bfd_boolean result = TRUE;
3f5e193b 13212 int i;
1007acb3 13213
19e6b90e
L		 13214 length = section->sh_size;
13215 if (length == 0)
1007acb3 13216 {
74e1a04b 13217 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
32ec8896 13218 return TRUE;
1007acb3 13219 }
5dff79d8
NC		 13220 if (section->sh_type == SHT_NOBITS)
13221 {
13222 /* There is no point in dumping the contents of a debugging section
13223 which has the NOBITS type - the bits in the file will be random.
13224 This can happen when a file containing a .eh_frame section is
13225 stripped with the --only-keep-debug command line option. */
74e1a04b
NC		 13226 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13227 print_name);
32ec8896 13228 return FALSE;
5dff79d8 13229 }
1007acb3 13230
0112cd26 13231 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 13232 name = ".debug_info";
1007acb3 13233
19e6b90e
L		 13234 /* See if we know how to display the contents of this section. */
13235 for (i = 0; i < max; i++)
1b315056 13236 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 13237 || (i == line && const_strneq (name, ".debug_line."))
1b315056 13238 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 13239 {
2cf0635d 13240 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 13241 int secondary = (section != find_section (name));
13242
13243 if (secondary)
3f5e193b 13244 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 13245
b40bf0a2
NC		 13246 if (i == line && const_strneq (name, ".debug_line."))
13247 sec->name = name;
13248 else if (streq (sec->uncompressed_name, name))
d966045b
DJ		 13249 sec->name = sec->uncompressed_name;
13250 else
13251 sec->name = sec->compressed_name;
3f5e193b
NC		 13252 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
13253 section, file))
19e6b90e 13254 {
657d0d47
CC		 13255 /* If this debug section is part of a CU/TU set in a .dwp file,
13256 restrict load_debug_section to the sections in that set. */
13257 section_subset = find_cu_tu_set (file, shndx);
13258
19e6b90e 13259 result &= debug_displays[i].display (sec, file);
1007acb3 13260
657d0d47
CC		 13261 section_subset = NULL;
13262
d966045b 13263 if (secondary || (i != info && i != abbrev))
3f5e193b 13264 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 13265 }
1007acb3 13266
19e6b90e
L		 13267 break;
13268 }
1007acb3 13269
19e6b90e 13270 if (i == max)
1007acb3 13271 {
74e1a04b 13272 printf (_("Unrecognized debug section: %s\n"), print_name);
32ec8896 13273 result = FALSE;
1007acb3
L		 13274 }
13275
19e6b90e 13276 return result;
5b18a4bc 13277}
103f02d3 13278
aef1f6d0
DJ		 13279/* Set DUMP_SECTS for all sections where dumps were requested
13280 based on section name. */
13281
13282static void
13283initialise_dumps_byname (void)
13284{
2cf0635d 13285 struct dump_list_entry * cur;
aef1f6d0
DJ		 13286
13287 for (cur = dump_sects_byname; cur; cur = cur->next)
13288 {
13289 unsigned int i;
32ec8896 13290 bfd_boolean any = FALSE;
aef1f6d0 13291
32ec8896 13292 for (i = 0; i < elf_header.e_shnum; i++)
aef1f6d0
DJ		 13293 if (streq (SECTION_NAME (section_headers + i), cur->name))
13294 {
09c11c86 13295 request_dump_bynumber (i, cur->type);
32ec8896 13296 any = TRUE;
aef1f6d0
DJ		 13297 }
13298
13299 if (!any)
13300 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13301 cur->name);
13302 }
13303}
13304
32ec8896 13305static bfd_boolean
2cf0635d 13306process_section_contents (FILE * file)
5b18a4bc 13307{
2cf0635d 13308 Elf_Internal_Shdr * section;
19e6b90e 13309 unsigned int i;
32ec8896 13310 bfd_boolean res = TRUE;
103f02d3 13311
19e6b90e 13312 if (! do_dump)
32ec8896 13313 return TRUE;
103f02d3 13314
aef1f6d0
DJ		 13315 initialise_dumps_byname ();
13316
19e6b90e
L		 13317 for (i = 0, section = section_headers;
13318 i < elf_header.e_shnum && i < num_dump_sects;
13319 i++, section++)
13320 {
13321#ifdef SUPPORT_DISASSEMBLY
13322 if (dump_sects[i] & DISASS_DUMP)
13323 disassemble_section (section, file);
13324#endif
13325 if (dump_sects[i] & HEX_DUMP)
32ec8896
NC		 13326 {
13327 if (! dump_section_as_bytes (section, file, FALSE))
13328 res = FALSE;
13329 }
103f02d3 13330
cf13d699 13331 if (dump_sects[i] & RELOC_DUMP)
32ec8896
NC		 13332 {
13333 if (! dump_section_as_bytes (section, file, TRUE))
13334 res = FALSE;
13335 }
09c11c86
NC		 13336
13337 if (dump_sects[i] & STRING_DUMP)
32ec8896
NC		 13338 {
13339 if (! dump_section_as_strings (section, file))
13340 res = FALSE;
13341 }
cf13d699
NC		 13342
13343 if (dump_sects[i] & DEBUG_DUMP)
32ec8896
NC		 13344 {
13345 if (! display_debug_section (i, section, file))
13346 res = FALSE;
13347 }
5b18a4bc 13348 }
103f02d3 13349
19e6b90e
L		 13350 /* Check to see if the user requested a
13351 dump of a section that does not exist. */
0ee3043f
NC		 13352 while (i < num_dump_sects)
13353 {
13354 if (dump_sects[i])
32ec8896
NC		 13355 {
13356 warn (_("Section %d was not dumped because it does not exist!\n"), i);
13357 res = FALSE;
13358 }
0ee3043f
NC		 13359 i++;
13360 }
32ec8896
NC		 13361
13362 return res;
5b18a4bc 13363}
103f02d3 13364
5b18a4bc 13365static void
19e6b90e 13366process_mips_fpe_exception (int mask)
5b18a4bc 13367{
19e6b90e
L		 13368 if (mask)
13369 {
32ec8896
NC		 13370 bfd_boolean first = TRUE;
13371
19e6b90e 13372 if (mask & OEX_FPU_INEX)
32ec8896 13373 fputs ("INEX", stdout), first = FALSE;
19e6b90e 13374 if (mask & OEX_FPU_UFLO)
32ec8896 13375 printf ("%sUFLO", first ? "" : "|"), first = FALSE;
19e6b90e 13376 if (mask & OEX_FPU_OFLO)
32ec8896 13377 printf ("%sOFLO", first ? "" : "|"), first = FALSE;
19e6b90e 13378 if (mask & OEX_FPU_DIV0)
32ec8896 13379 printf ("%sDIV0", first ? "" : "|"), first = FALSE;
19e6b90e
L		 13380 if (mask & OEX_FPU_INVAL)
13381 printf ("%sINVAL", first ? "" : "|");
13382 }
5b18a4bc 13383 else
19e6b90e 13384 fputs ("0", stdout);
5b18a4bc 13385}
103f02d3 13386
f6f0e17b
NC		 13387/* Display's the value of TAG at location P. If TAG is
13388 greater than 0 it is assumed to be an unknown tag, and
13389 a message is printed to this effect. Otherwise it is
13390 assumed that a message has already been printed.
13391
13392 If the bottom bit of TAG is set it assumed to have a
13393 string value, otherwise it is assumed to have an integer
13394 value.
13395
13396 Returns an updated P pointing to the first unread byte
13397 beyond the end of TAG's value.
13398
13399 Reads at or beyond END will not be made. */
13400
13401static unsigned char *
60abdbed 13402display_tag_value (signed int tag,
f6f0e17b
NC		 13403 unsigned char * p,
13404 const unsigned char * const end)
13405{
13406 unsigned long val;
13407
13408 if (tag > 0)
13409 printf (" Tag_unknown_%d: ", tag);
13410
13411 if (p >= end)
13412 {
4082ef84 13413 warn (_("<corrupt tag>\n"));
f6f0e17b
NC		 13414 }
13415 else if (tag & 1)
13416 {
071436c6
NC		 13417 /* PR 17531 file: 027-19978-0.004. */
13418 size_t maxlen = (end - p) - 1;
13419
13420 putchar ('"');
4082ef84
NC		 13421 if (maxlen > 0)
13422 {
13423 print_symbol ((int) maxlen, (const char *) p);
13424 p += strnlen ((char *) p, maxlen) + 1;
13425 }
13426 else
13427 {
13428 printf (_("<corrupt string tag>"));
13429 p = (unsigned char *) end;
13430 }
071436c6 13431 printf ("\"\n");
f6f0e17b
NC		 13432 }
13433 else
13434 {
13435 unsigned int len;
13436
13437 val = read_uleb128 (p, &len, end);
13438 p += len;
13439 printf ("%ld (0x%lx)\n", val, val);
13440 }
13441
4082ef84 13442 assert (p <= end);
f6f0e17b
NC		 13443 return p;
13444}
13445
11c1ff18
PB		 13446/* ARM EABI attributes section. */
13447typedef struct
13448{
70e99720 13449 unsigned int tag;
2cf0635d 13450 const char * name;
11c1ff18 13451 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
70e99720 13452 unsigned int type;
2cf0635d 13453 const char ** table;
11c1ff18
PB		 13454} arm_attr_public_tag;
13455
2cf0635d 13456static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 13457 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
ff8646ee
TP		 13458 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
13459 "v8-M.mainline"};
2cf0635d
NC		 13460static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
13461static const char * arm_attr_tag_THUMB_ISA_use[] =
4ed7ed8d 13462 {"No", "Thumb-1", "Thumb-2", "Yes"};
75375b3e 13463static const char * arm_attr_tag_FP_arch[] =
bca38921 13464 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
a715796b 13465 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
2cf0635d 13466static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 13467static const char * arm_attr_tag_Advanced_SIMD_arch[] =
9411fd44
MW		 13468 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13469 "NEON for ARMv8.1"};
2cf0635d 13470static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 13471 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13472 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 13473static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 13474 {"V6", "SB", "TLS", "Unused"};
2cf0635d 13475static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 13476 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 13477static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 13478 {"Absolute", "PC-relative", "None"};
2cf0635d 13479static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 13480 {"None", "direct", "GOT-indirect"};
2cf0635d 13481static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 13482 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 13483static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
13484static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 13485 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 13486static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
13487static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
13488static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 13489 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 13490static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 13491 {"Unused", "small", "int", "forced to int"};
2cf0635d 13492static const char * arm_attr_tag_ABI_HardFP_use[] =
99654aaf 13493 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
2cf0635d 13494static const char * arm_attr_tag_ABI_VFP_args[] =
5c294fee 13495 {"AAPCS", "VFP registers", "custom", "compatible"};
2cf0635d 13496static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 13497 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 13498static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 13499 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13500 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 13501static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 13502 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13503 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 13504static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 13505static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 13506 {"Not Allowed", "Allowed"};
2cf0635d 13507static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 13508 {"None", "IEEE 754", "Alternative Format"};
15afaa63
TP		 13509static const char * arm_attr_tag_DSP_extension[] =
13510 {"Follow architecture", "Allowed"};
dd24e3da 13511static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 13512 {"Not Allowed", "Allowed"};
13513static const char * arm_attr_tag_DIV_use[] =
dd24e3da 13514 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 13515 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 13516static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
13517static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 13518 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 13519 "TrustZone and Virtualization Extensions"};
dd24e3da 13520static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 13521 {"Not Allowed", "Allowed"};
11c1ff18
PB		 13522
13523#define LOOKUP(id, name) \
13524 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 13525static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 13526{
13527 {4, "CPU_raw_name", 1, NULL},
13528 {5, "CPU_name", 1, NULL},
13529 LOOKUP(6, CPU_arch),
13530 {7, "CPU_arch_profile", 0, NULL},
13531 LOOKUP(8, ARM_ISA_use),
13532 LOOKUP(9, THUMB_ISA_use),
75375b3e 13533 LOOKUP(10, FP_arch),
11c1ff18 13534 LOOKUP(11, WMMX_arch),
f5f53991
AS		 13535 LOOKUP(12, Advanced_SIMD_arch),
13536 LOOKUP(13, PCS_config),
11c1ff18
PB		 13537 LOOKUP(14, ABI_PCS_R9_use),
13538 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 13539 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 13540 LOOKUP(17, ABI_PCS_GOT_use),
13541 LOOKUP(18, ABI_PCS_wchar_t),
13542 LOOKUP(19, ABI_FP_rounding),
13543 LOOKUP(20, ABI_FP_denormal),
13544 LOOKUP(21, ABI_FP_exceptions),
13545 LOOKUP(22, ABI_FP_user_exceptions),
13546 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 13547 {24, "ABI_align_needed", 0, NULL},
13548 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 13549 LOOKUP(26, ABI_enum_size),
13550 LOOKUP(27, ABI_HardFP_use),
13551 LOOKUP(28, ABI_VFP_args),
13552 LOOKUP(29, ABI_WMMX_args),
13553 LOOKUP(30, ABI_optimization_goals),
13554 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 13555 {32, "compatibility", 0, NULL},
f5f53991 13556 LOOKUP(34, CPU_unaligned_access),
75375b3e 13557 LOOKUP(36, FP_HP_extension),
8e79c3df 13558 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 13559 LOOKUP(42, MPextension_use),
13560 LOOKUP(44, DIV_use),
15afaa63 13561 LOOKUP(46, DSP_extension),
f5f53991
AS		 13562 {64, "nodefaults", 0, NULL},
13563 {65, "also_compatible_with", 0, NULL},
13564 LOOKUP(66, T2EE_use),
13565 {67, "conformance", 1, NULL},
13566 LOOKUP(68, Virtualization_use),
cd21e546 13567 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 13568};
13569#undef LOOKUP
13570
11c1ff18 13571static unsigned char *
f6f0e17b
NC		 13572display_arm_attribute (unsigned char * p,
13573 const unsigned char * const end)
11c1ff18 13574{
70e99720 13575 unsigned int tag;
11c1ff18 13576 unsigned int len;
70e99720 13577 unsigned int val;
2cf0635d 13578 arm_attr_public_tag * attr;
11c1ff18 13579 unsigned i;
70e99720 13580 unsigned int type;
11c1ff18 13581
f6f0e17b 13582 tag = read_uleb128 (p, &len, end);
11c1ff18
PB		 13583 p += len;
13584 attr = NULL;
2cf0635d 13585 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 13586 {
13587 if (arm_attr_public_tags[i].tag == tag)
13588 {
13589 attr = &arm_attr_public_tags[i];
13590 break;
13591 }
13592 }
13593
13594 if (attr)
13595 {
13596 printf (" Tag_%s: ", attr->name);
13597 switch (attr->type)
13598 {
13599 case 0:
13600 switch (tag)
13601 {
13602 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 13603 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 13604 p += len;
13605 switch (val)
13606 {
2b692964
NC		 13607 case 0: printf (_("None\n")); break;
13608 case 'A': printf (_("Application\n")); break;
13609 case 'R': printf (_("Realtime\n")); break;
13610 case 'M': printf (_("Microcontroller\n")); break;
13611 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 13612 default: printf ("??? (%d)\n", val); break;
13613 }
13614 break;
13615
75375b3e 13616 case 24: /* Tag_align_needed. */
f6f0e17b 13617 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 13618 p += len;
13619 switch (val)
13620 {
2b692964
NC		 13621 case 0: printf (_("None\n")); break;
13622 case 1: printf (_("8-byte\n")); break;
13623 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 13624 case 3: printf ("??? 3\n"); break;
13625 default:
13626 if (val <= 12)
dd24e3da 13627 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 13628 1 << val);
13629 else
13630 printf ("??? (%d)\n", val);
13631 break;
13632 }
13633 break;
13634
13635 case 25: /* Tag_align_preserved. */
f6f0e17b 13636 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 13637 p += len;
13638 switch (val)
13639 {
2b692964
NC		 13640 case 0: printf (_("None\n")); break;
13641 case 1: printf (_("8-byte, except leaf SP\n")); break;
13642 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 13643 case 3: printf ("??? 3\n"); break;
13644 default:
13645 if (val <= 12)
dd24e3da 13646 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 13647 1 << val);
13648 else
13649 printf ("??? (%d)\n", val);
13650 break;
13651 }
13652 break;
13653
11c1ff18 13654 case 32: /* Tag_compatibility. */
071436c6 13655 {
071436c6
NC		 13656 val = read_uleb128 (p, &len, end);
13657 p += len;
071436c6 13658 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 13659 if (p < end - 1)
13660 {
13661 size_t maxlen = (end - p) - 1;
13662
13663 print_symbol ((int) maxlen, (const char *) p);
13664 p += strnlen ((char *) p, maxlen) + 1;
13665 }
13666 else
13667 {
13668 printf (_("<corrupt>"));
13669 p = (unsigned char *) end;
13670 }
071436c6 13671 putchar ('\n');
071436c6 13672 }
11c1ff18
PB		 13673 break;
13674
f5f53991 13675 case 64: /* Tag_nodefaults. */
541a3cbd
NC		 13676 /* PR 17531: file: 001-505008-0.01. */
13677 if (p < end)
13678 p++;
2b692964 13679 printf (_("True\n"));
f5f53991
AS		 13680 break;
13681
13682 case 65: /* Tag_also_compatible_with. */
f6f0e17b 13683 val = read_uleb128 (p, &len, end);
f5f53991
AS		 13684 p += len;
13685 if (val == 6 /* Tag_CPU_arch. */)
13686 {
f6f0e17b 13687 val = read_uleb128 (p, &len, end);
f5f53991 13688 p += len;
071436c6 13689 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 13690 printf ("??? (%d)\n", val);
13691 else
13692 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
13693 }
13694 else
13695 printf ("???\n");
071436c6
NC		 13696 while (p < end && *(p++) != '\0' /* NUL terminator. */)
13697 ;
f5f53991
AS		 13698 break;
13699
11c1ff18 13700 default:
bee0ee85
NC		 13701 printf (_("<unknown: %d>\n"), tag);
13702 break;
11c1ff18
PB		 13703 }
13704 return p;
13705
13706 case 1:
f6f0e17b 13707 return display_tag_value (-1, p, end);
11c1ff18 13708 case 2:
f6f0e17b 13709 return display_tag_value (0, p, end);
11c1ff18
PB		 13710
13711 default:
13712 assert (attr->type & 0x80);
f6f0e17b 13713 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 13714 p += len;
13715 type = attr->type & 0x7f;
13716 if (val >= type)
13717 printf ("??? (%d)\n", val);
13718 else
13719 printf ("%s\n", attr->table[val]);
13720 return p;
13721 }
13722 }
11c1ff18 13723
f6f0e17b 13724 return display_tag_value (tag, p, end);
11c1ff18
PB		 13725}
13726
104d59d1 13727static unsigned char *
60bca95a 13728display_gnu_attribute (unsigned char * p,
60abdbed 13729 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
f6f0e17b 13730 const unsigned char * const end)
104d59d1
JM		 13731{
13732 int tag;
13733 unsigned int len;
60abdbed 13734 unsigned int val;
104d59d1 13735
f6f0e17b 13736 tag = read_uleb128 (p, &len, end);
104d59d1
JM		 13737 p += len;
13738
13739 /* Tag_compatibility is the only generic GNU attribute defined at
13740 present. */
13741 if (tag == 32)
13742 {
f6f0e17b 13743 val = read_uleb128 (p, &len, end);
104d59d1 13744 p += len;
071436c6
NC		 13745
13746 printf (_("flag = %d, vendor = "), val);
f6f0e17b
NC		 13747 if (p == end)
13748 {
071436c6 13749 printf (_("<corrupt>\n"));
f6f0e17b
NC		 13750 warn (_("corrupt vendor attribute\n"));
13751 }
13752 else
13753 {
4082ef84
NC		 13754 if (p < end - 1)
13755 {
13756 size_t maxlen = (end - p) - 1;
071436c6 13757
4082ef84
NC		 13758 print_symbol ((int) maxlen, (const char *) p);
13759 p += strnlen ((char *) p, maxlen) + 1;
13760 }
13761 else
13762 {
13763 printf (_("<corrupt>"));
13764 p = (unsigned char *) end;
13765 }
071436c6 13766 putchar ('\n');
f6f0e17b 13767 }
104d59d1
JM		 13768 return p;
13769 }
13770
13771 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 13772 return display_proc_gnu_attribute (p, tag, end);
104d59d1 13773
f6f0e17b 13774 return display_tag_value (tag, p, end);
104d59d1
JM		 13775}
13776
34c8bcba 13777static unsigned char *
f6f0e17b 13778display_power_gnu_attribute (unsigned char * p,
60abdbed 13779 unsigned int tag,
f6f0e17b 13780 const unsigned char * const end)
34c8bcba 13781{
34c8bcba 13782 unsigned int len;
005d79fd 13783 unsigned int val;
34c8bcba
JM		 13784
13785 if (tag == Tag_GNU_Power_ABI_FP)
13786 {
f6f0e17b 13787 val = read_uleb128 (p, &len, end);
34c8bcba
JM		 13788 p += len;
13789 printf (" Tag_GNU_Power_ABI_FP: ");
005d79fd
AM		 13790 if (len == 0)
13791 {
13792 printf (_("<corrupt>\n"));
13793 return p;
13794 }
60bca95a 13795
005d79fd
AM		 13796 if (val > 15)
13797 printf ("(%#x), ", val);
13798
13799 switch (val & 3)
34c8bcba
JM		 13800 {
13801 case 0:
005d79fd 13802 printf (_("unspecified hard/soft float, "));
34c8bcba
JM		 13803 break;
13804 case 1:
005d79fd 13805 printf (_("hard float, "));
34c8bcba
JM		 13806 break;
13807 case 2:
005d79fd 13808 printf (_("soft float, "));
34c8bcba 13809 break;
3c7b9897 13810 case 3:
005d79fd 13811 printf (_("single-precision hard float, "));
3c7b9897 13812 break;
005d79fd
AM		 13813 }
13814
13815 switch (val & 0xC)
13816 {
13817 case 0:
13818 printf (_("unspecified long double\n"));
13819 break;
13820 case 4:
13821 printf (_("128-bit IBM long double\n"));
13822 break;
13823 case 8:
13824 printf (_("64-bit long double\n"));
13825 break;
13826 case 12:
13827 printf (_("128-bit IEEE long double\n"));
34c8bcba
JM		 13828 break;
13829 }
13830 return p;
005d79fd 13831 }
34c8bcba 13832
c6e65352
DJ		 13833 if (tag == Tag_GNU_Power_ABI_Vector)
13834 {
f6f0e17b 13835 val = read_uleb128 (p, &len, end);
c6e65352
DJ		 13836 p += len;
13837 printf (" Tag_GNU_Power_ABI_Vector: ");
005d79fd
AM		 13838 if (len == 0)
13839 {
13840 printf (_("<corrupt>\n"));
13841 return p;
13842 }
13843
13844 if (val > 3)
13845 printf ("(%#x), ", val);
13846
13847 switch (val & 3)
c6e65352
DJ		 13848 {
13849 case 0:
005d79fd 13850 printf (_("unspecified\n"));
c6e65352
DJ		 13851 break;
13852 case 1:
005d79fd 13853 printf (_("generic\n"));
c6e65352
DJ		 13854 break;
13855 case 2:
13856 printf ("AltiVec\n");
13857 break;
13858 case 3:
13859 printf ("SPE\n");
13860 break;
c6e65352
DJ		 13861 }
13862 return p;
005d79fd 13863 }
c6e65352 13864
f82e0623
NF		 13865 if (tag == Tag_GNU_Power_ABI_Struct_Return)
13866 {
005d79fd
AM		 13867 val = read_uleb128 (p, &len, end);
13868 p += len;
13869 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13870 if (len == 0)
f6f0e17b 13871 {
005d79fd 13872 printf (_("<corrupt>\n"));
f6f0e17b
NC		 13873 return p;
13874 }
0b4362b0 13875
005d79fd
AM		 13876 if (val > 2)
13877 printf ("(%#x), ", val);
13878
13879 switch (val & 3)
13880 {
13881 case 0:
13882 printf (_("unspecified\n"));
13883 break;
13884 case 1:
13885 printf ("r3/r4\n");
13886 break;
13887 case 2:
13888 printf (_("memory\n"));
13889 break;
13890 case 3:
13891 printf ("???\n");
13892 break;
13893 }
f82e0623
NF		 13894 return p;
13895 }
13896
f6f0e17b 13897 return display_tag_value (tag & 1, p, end);
34c8bcba
JM		 13898}
13899
643f7afb
AK		 13900static unsigned char *
13901display_s390_gnu_attribute (unsigned char * p,
60abdbed 13902 unsigned int tag,
643f7afb
AK		 13903 const unsigned char * const end)
13904{
13905 unsigned int len;
13906 int val;
13907
13908 if (tag == Tag_GNU_S390_ABI_Vector)
13909 {
13910 val = read_uleb128 (p, &len, end);
13911 p += len;
13912 printf (" Tag_GNU_S390_ABI_Vector: ");
13913
13914 switch (val)
13915 {
13916 case 0:
13917 printf (_("any\n"));
13918 break;
13919 case 1:
13920 printf (_("software\n"));
13921 break;
13922 case 2:
13923 printf (_("hardware\n"));
13924 break;
13925 default:
13926 printf ("??? (%d)\n", val);
13927 break;
13928 }
13929 return p;
13930 }
13931
13932 return display_tag_value (tag & 1, p, end);
13933}
13934
9e8c70f9 13935static void
60abdbed 13936display_sparc_hwcaps (unsigned int mask)
9e8c70f9
DM		 13937{
13938 if (mask)
13939 {
32ec8896 13940 bfd_boolean first = TRUE;
071436c6 13941
9e8c70f9 13942 if (mask & ELF_SPARC_HWCAP_MUL32)
32ec8896 13943 fputs ("mul32", stdout), first = FALSE;
9e8c70f9 13944 if (mask & ELF_SPARC_HWCAP_DIV32)
32ec8896 13945 printf ("%sdiv32", first ? "" : "|"), first = FALSE;
9e8c70f9 13946 if (mask & ELF_SPARC_HWCAP_FSMULD)
32ec8896 13947 printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
9e8c70f9 13948 if (mask & ELF_SPARC_HWCAP_V8PLUS)
32ec8896 13949 printf ("%sv8plus", first ? "" : "|"), first = FALSE;
9e8c70f9 13950 if (mask & ELF_SPARC_HWCAP_POPC)
32ec8896 13951 printf ("%spopc", first ? "" : "|"), first = FALSE;
9e8c70f9 13952 if (mask & ELF_SPARC_HWCAP_VIS)
32ec8896 13953 printf ("%svis", first ? "" : "|"), first = FALSE;
9e8c70f9 13954 if (mask & ELF_SPARC_HWCAP_VIS2)
32ec8896 13955 printf ("%svis2", first ? "" : "|"), first = FALSE;
9e8c70f9 13956 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
32ec8896 13957 printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
9e8c70f9 13958 if (mask & ELF_SPARC_HWCAP_FMAF)
32ec8896 13959 printf ("%sfmaf", first ? "" : "|"), first = FALSE;
9e8c70f9 13960 if (mask & ELF_SPARC_HWCAP_VIS3)
32ec8896 13961 printf ("%svis3", first ? "" : "|"), first = FALSE;
9e8c70f9 13962 if (mask & ELF_SPARC_HWCAP_HPC)
32ec8896 13963 printf ("%shpc", first ? "" : "|"), first = FALSE;
9e8c70f9 13964 if (mask & ELF_SPARC_HWCAP_RANDOM)
32ec8896 13965 printf ("%srandom", first ? "" : "|"), first = FALSE;
9e8c70f9 13966 if (mask & ELF_SPARC_HWCAP_TRANS)
32ec8896 13967 printf ("%strans", first ? "" : "|"), first = FALSE;
9e8c70f9 13968 if (mask & ELF_SPARC_HWCAP_FJFMAU)
32ec8896 13969 printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
9e8c70f9 13970 if (mask & ELF_SPARC_HWCAP_IMA)
32ec8896 13971 printf ("%sima", first ? "" : "|"), first = FALSE;
9e8c70f9 13972 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
32ec8896 13973 printf ("%scspare", first ? "" : "|"), first = FALSE;
9e8c70f9
DM		 13974 }
13975 else
071436c6
NC		 13976 fputc ('0', stdout);
13977 fputc ('\n', stdout);
9e8c70f9
DM		 13978}
13979
3d68f91c 13980static void
60abdbed 13981display_sparc_hwcaps2 (unsigned int mask)
3d68f91c
JM		 13982{
13983 if (mask)
13984 {
32ec8896 13985 bfd_boolean first = TRUE;
071436c6 13986
3d68f91c 13987 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
32ec8896 13988 fputs ("fjathplus", stdout), first = FALSE;
3d68f91c 13989 if (mask & ELF_SPARC_HWCAP2_VIS3B)
32ec8896 13990 printf ("%svis3b", first ? "" : "|"), first = FALSE;
3d68f91c 13991 if (mask & ELF_SPARC_HWCAP2_ADP)
32ec8896 13992 printf ("%sadp", first ? "" : "|"), first = FALSE;
3d68f91c 13993 if (mask & ELF_SPARC_HWCAP2_SPARC5)
32ec8896 13994 printf ("%ssparc5", first ? "" : "|"), first = FALSE;
3d68f91c 13995 if (mask & ELF_SPARC_HWCAP2_MWAIT)
32ec8896 13996 printf ("%smwait", first ? "" : "|"), first = FALSE;
3d68f91c 13997 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
32ec8896 13998 printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
3d68f91c 13999 if (mask & ELF_SPARC_HWCAP2_XMONT)
32ec8896 14000 printf ("%sxmont2", first ? "" : "|"), first = FALSE;
3d68f91c 14001 if (mask & ELF_SPARC_HWCAP2_NSEC)
32ec8896 14002 printf ("%snsec", first ? "" : "|"), first = FALSE;
3d68f91c 14003 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
32ec8896 14004 printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
3d68f91c 14005 if (mask & ELF_SPARC_HWCAP2_FJDES)
32ec8896 14006 printf ("%sfjdes", first ? "" : "|"), first = FALSE;
3d68f91c 14007 if (mask & ELF_SPARC_HWCAP2_FJAES)
32ec8896 14008 printf ("%sfjaes", first ? "" : "|"), first = FALSE;
3d68f91c
JM		 14009 }
14010 else
071436c6
NC		 14011 fputc ('0', stdout);
14012 fputc ('\n', stdout);
3d68f91c
JM		 14013}
14014
9e8c70f9 14015static unsigned char *
f6f0e17b 14016display_sparc_gnu_attribute (unsigned char * p,
60abdbed 14017 unsigned int tag,
f6f0e17b 14018 const unsigned char * const end)
9e8c70f9 14019{
3d68f91c
JM		 14020 unsigned int len;
14021 int val;
14022
9e8c70f9
DM		 14023 if (tag == Tag_GNU_Sparc_HWCAPS)
14024 {
f6f0e17b 14025 val = read_uleb128 (p, &len, end);
9e8c70f9
DM		 14026 p += len;
14027 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM		 14028 display_sparc_hwcaps (val);
14029 return p;
3d68f91c
JM		 14030 }
14031 if (tag == Tag_GNU_Sparc_HWCAPS2)
14032 {
14033 val = read_uleb128 (p, &len, end);
14034 p += len;
14035 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14036 display_sparc_hwcaps2 (val);
14037 return p;
14038 }
9e8c70f9 14039
f6f0e17b 14040 return display_tag_value (tag, p, end);
9e8c70f9
DM		 14041}
14042
351cdf24 14043static void
32ec8896 14044print_mips_fp_abi_value (unsigned int val)
351cdf24
MF		 14045{
14046 switch (val)
14047 {
14048 case Val_GNU_MIPS_ABI_FP_ANY:
14049 printf (_("Hard or soft float\n"));
14050 break;
14051 case Val_GNU_MIPS_ABI_FP_DOUBLE:
14052 printf (_("Hard float (double precision)\n"));
14053 break;
14054 case Val_GNU_MIPS_ABI_FP_SINGLE:
14055 printf (_("Hard float (single precision)\n"));
14056 break;
14057 case Val_GNU_MIPS_ABI_FP_SOFT:
14058 printf (_("Soft float\n"));
14059 break;
14060 case Val_GNU_MIPS_ABI_FP_OLD_64:
14061 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14062 break;
14063 case Val_GNU_MIPS_ABI_FP_XX:
14064 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14065 break;
14066 case Val_GNU_MIPS_ABI_FP_64:
14067 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14068 break;
14069 case Val_GNU_MIPS_ABI_FP_64A:
14070 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14071 break;
3350cc01
CM		 14072 case Val_GNU_MIPS_ABI_FP_NAN2008:
14073 printf (_("NaN 2008 compatibility\n"));
14074 break;
351cdf24
MF		 14075 default:
14076 printf ("??? (%d)\n", val);
14077 break;
14078 }
14079}
14080
2cf19d5c 14081static unsigned char *
f6f0e17b 14082display_mips_gnu_attribute (unsigned char * p,
60abdbed 14083 unsigned int tag,
f6f0e17b 14084 const unsigned char * const end)
2cf19d5c 14085{
2cf19d5c
JM		 14086 if (tag == Tag_GNU_MIPS_ABI_FP)
14087 {
f6f0e17b 14088 unsigned int len;
32ec8896 14089 unsigned int val;
f6f0e17b
NC		 14090
14091 val = read_uleb128 (p, &len, end);
2cf19d5c
JM		 14092 p += len;
14093 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 14094
351cdf24
MF		 14095 print_mips_fp_abi_value (val);
14096
2cf19d5c
JM		 14097 return p;
14098 }
14099
a9f58168
CF		 14100 if (tag == Tag_GNU_MIPS_ABI_MSA)
14101 {
14102 unsigned int len;
32ec8896 14103 unsigned int val;
a9f58168
CF		 14104
14105 val = read_uleb128 (p, &len, end);
14106 p += len;
14107 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14108
14109 switch (val)
14110 {
14111 case Val_GNU_MIPS_ABI_MSA_ANY:
14112 printf (_("Any MSA or not\n"));
14113 break;
14114 case Val_GNU_MIPS_ABI_MSA_128:
14115 printf (_("128-bit MSA\n"));
14116 break;
14117 default:
14118 printf ("??? (%d)\n", val);
14119 break;
14120 }
14121 return p;
14122 }
14123
f6f0e17b 14124 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM		 14125}
14126
59e6276b 14127static unsigned char *
f6f0e17b
NC		 14128display_tic6x_attribute (unsigned char * p,
14129 const unsigned char * const end)
59e6276b 14130{
60abdbed 14131 unsigned int tag;
59e6276b
JM		 14132 unsigned int len;
14133 int val;
14134
f6f0e17b 14135 tag = read_uleb128 (p, &len, end);
59e6276b
JM		 14136 p += len;
14137
14138 switch (tag)
14139 {
75fa6dc1 14140 case Tag_ISA:
f6f0e17b 14141 val = read_uleb128 (p, &len, end);
59e6276b 14142 p += len;
75fa6dc1 14143 printf (" Tag_ISA: ");
59e6276b
JM		 14144
14145 switch (val)
14146 {
75fa6dc1 14147 case C6XABI_Tag_ISA_none:
59e6276b
JM		 14148 printf (_("None\n"));
14149 break;
75fa6dc1 14150 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 14151 printf ("C62x\n");
14152 break;
75fa6dc1 14153 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 14154 printf ("C67x\n");
14155 break;
75fa6dc1 14156 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 14157 printf ("C67x+\n");
14158 break;
75fa6dc1 14159 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 14160 printf ("C64x\n");
14161 break;
75fa6dc1 14162 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 14163 printf ("C64x+\n");
14164 break;
75fa6dc1 14165 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 14166 printf ("C674x\n");
14167 break;
14168 default:
14169 printf ("??? (%d)\n", val);
14170 break;
14171 }
14172 return p;
14173
87779176 14174 case Tag_ABI_wchar_t:
f6f0e17b 14175 val = read_uleb128 (p, &len, end);
87779176
JM		 14176 p += len;
14177 printf (" Tag_ABI_wchar_t: ");
14178 switch (val)
14179 {
14180 case 0:
14181 printf (_("Not used\n"));
14182 break;
14183 case 1:
14184 printf (_("2 bytes\n"));
14185 break;
14186 case 2:
14187 printf (_("4 bytes\n"));
14188 break;
14189 default:
14190 printf ("??? (%d)\n", val);
14191 break;
14192 }
14193 return p;
14194
14195 case Tag_ABI_stack_align_needed:
f6f0e17b 14196 val = read_uleb128 (p, &len, end);
87779176
JM		 14197 p += len;
14198 printf (" Tag_ABI_stack_align_needed: ");
14199 switch (val)
14200 {
14201 case 0:
14202 printf (_("8-byte\n"));
14203 break;
14204 case 1:
14205 printf (_("16-byte\n"));
14206 break;
14207 default:
14208 printf ("??? (%d)\n", val);
14209 break;
14210 }
14211 return p;
14212
14213 case Tag_ABI_stack_align_preserved:
f6f0e17b 14214 val = read_uleb128 (p, &len, end);
87779176
JM		 14215 p += len;
14216 printf (" Tag_ABI_stack_align_preserved: ");
14217 switch (val)
14218 {
14219 case 0:
14220 printf (_("8-byte\n"));
14221 break;
14222 case 1:
14223 printf (_("16-byte\n"));
14224 break;
14225 default:
14226 printf ("??? (%d)\n", val);
14227 break;
14228 }
14229 return p;
14230
b5593623 14231 case Tag_ABI_DSBT:
f6f0e17b 14232 val = read_uleb128 (p, &len, end);
b5593623
JM		 14233 p += len;
14234 printf (" Tag_ABI_DSBT: ");
14235 switch (val)
14236 {
14237 case 0:
14238 printf (_("DSBT addressing not used\n"));
14239 break;
14240 case 1:
14241 printf (_("DSBT addressing used\n"));
14242 break;
14243 default:
14244 printf ("??? (%d)\n", val);
14245 break;
14246 }
14247 return p;
14248
87779176 14249 case Tag_ABI_PID:
f6f0e17b 14250 val = read_uleb128 (p, &len, end);
87779176
JM		 14251 p += len;
14252 printf (" Tag_ABI_PID: ");
14253 switch (val)
14254 {
14255 case 0:
14256 printf (_("Data addressing position-dependent\n"));
14257 break;
14258 case 1:
14259 printf (_("Data addressing position-independent, GOT near DP\n"));
14260 break;
14261 case 2:
14262 printf (_("Data addressing position-independent, GOT far from DP\n"));
14263 break;
14264 default:
14265 printf ("??? (%d)\n", val);
14266 break;
14267 }
14268 return p;
14269
14270 case Tag_ABI_PIC:
f6f0e17b 14271 val = read_uleb128 (p, &len, end);
87779176
JM		 14272 p += len;
14273 printf (" Tag_ABI_PIC: ");
14274 switch (val)
14275 {
14276 case 0:
14277 printf (_("Code addressing position-dependent\n"));
14278 break;
14279 case 1:
14280 printf (_("Code addressing position-independent\n"));
14281 break;
14282 default:
14283 printf ("??? (%d)\n", val);
14284 break;
14285 }
14286 return p;
14287
14288 case Tag_ABI_array_object_alignment:
f6f0e17b 14289 val = read_uleb128 (p, &len, end);
87779176
JM		 14290 p += len;
14291 printf (" Tag_ABI_array_object_alignment: ");
14292 switch (val)
14293 {
14294 case 0:
14295 printf (_("8-byte\n"));
14296 break;
14297 case 1:
14298 printf (_("4-byte\n"));
14299 break;
14300 case 2:
14301 printf (_("16-byte\n"));
14302 break;
14303 default:
14304 printf ("??? (%d)\n", val);
14305 break;
14306 }
14307 return p;
14308
14309 case Tag_ABI_array_object_align_expected:
f6f0e17b 14310 val = read_uleb128 (p, &len, end);
87779176
JM		 14311 p += len;
14312 printf (" Tag_ABI_array_object_align_expected: ");
14313 switch (val)
14314 {
14315 case 0:
14316 printf (_("8-byte\n"));
14317 break;
14318 case 1:
14319 printf (_("4-byte\n"));
14320 break;
14321 case 2:
14322 printf (_("16-byte\n"));
14323 break;
14324 default:
14325 printf ("??? (%d)\n", val);
14326 break;
14327 }
14328 return p;
14329
3cbd1c06 14330 case Tag_ABI_compatibility:
071436c6 14331 {
071436c6
NC		 14332 val = read_uleb128 (p, &len, end);
14333 p += len;
14334 printf (" Tag_ABI_compatibility: ");
071436c6 14335 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 14336 if (p < end - 1)
14337 {
14338 size_t maxlen = (end - p) - 1;
14339
14340 print_symbol ((int) maxlen, (const char *) p);
14341 p += strnlen ((char *) p, maxlen) + 1;
14342 }
14343 else
14344 {
14345 printf (_("<corrupt>"));
14346 p = (unsigned char *) end;
14347 }
071436c6 14348 putchar ('\n');
071436c6
NC		 14349 return p;
14350 }
87779176
JM		 14351
14352 case Tag_ABI_conformance:
071436c6 14353 {
4082ef84
NC		 14354 printf (" Tag_ABI_conformance: \"");
14355 if (p < end - 1)
14356 {
14357 size_t maxlen = (end - p) - 1;
071436c6 14358
4082ef84
NC		 14359 print_symbol ((int) maxlen, (const char *) p);
14360 p += strnlen ((char *) p, maxlen) + 1;
14361 }
14362 else
14363 {
14364 printf (_("<corrupt>"));
14365 p = (unsigned char *) end;
14366 }
071436c6 14367 printf ("\"\n");
071436c6
NC		 14368 return p;
14369 }
59e6276b
JM		 14370 }
14371
f6f0e17b
NC		 14372 return display_tag_value (tag, p, end);
14373}
59e6276b 14374
f6f0e17b 14375static void
60abdbed 14376display_raw_attribute (unsigned char * p, unsigned char const * const end)
f6f0e17b
NC		 14377{
14378 unsigned long addr = 0;
14379 size_t bytes = end - p;
14380
e0a31db1 14381 assert (end > p);
f6f0e17b 14382 while (bytes)
87779176 14383 {
f6f0e17b
NC		 14384 int j;
14385 int k;
14386 int lbytes = (bytes > 16 ? 16 : bytes);
14387
14388 printf (" 0x%8.8lx ", addr);
14389
14390 for (j = 0; j < 16; j++)
14391 {
14392 if (j < lbytes)
14393 printf ("%2.2x", p[j]);
14394 else
14395 printf (" ");
14396
14397 if ((j & 3) == 3)
14398 printf (" ");
14399 }
14400
14401 for (j = 0; j < lbytes; j++)
14402 {
14403 k = p[j];
14404 if (k >= ' ' && k < 0x7f)
14405 printf ("%c", k);
14406 else
14407 printf (".");
14408 }
14409
14410 putchar ('\n');
14411
14412 p += lbytes;
14413 bytes -= lbytes;
14414 addr += lbytes;
87779176 14415 }
59e6276b 14416
f6f0e17b 14417 putchar ('\n');
59e6276b
JM		 14418}
14419
13761a11
NC		 14420static unsigned char *
14421display_msp430x_attribute (unsigned char * p,
14422 const unsigned char * const end)
14423{
14424 unsigned int len;
60abdbed
NC		 14425 unsigned int val;
14426 unsigned int tag;
13761a11
NC		 14427
14428 tag = read_uleb128 (p, & len, end);
14429 p += len;
0b4362b0 14430
13761a11
NC		 14431 switch (tag)
14432 {
14433 case OFBA_MSPABI_Tag_ISA:
14434 val = read_uleb128 (p, &len, end);
14435 p += len;
14436 printf (" Tag_ISA: ");
14437 switch (val)
14438 {
14439 case 0: printf (_("None\n")); break;
14440 case 1: printf (_("MSP430\n")); break;
14441 case 2: printf (_("MSP430X\n")); break;
14442 default: printf ("??? (%d)\n", val); break;
14443 }
14444 break;
14445
14446 case OFBA_MSPABI_Tag_Code_Model:
14447 val = read_uleb128 (p, &len, end);
14448 p += len;
14449 printf (" Tag_Code_Model: ");
14450 switch (val)
14451 {
14452 case 0: printf (_("None\n")); break;
14453 case 1: printf (_("Small\n")); break;
14454 case 2: printf (_("Large\n")); break;
14455 default: printf ("??? (%d)\n", val); break;
14456 }
14457 break;
14458
14459 case OFBA_MSPABI_Tag_Data_Model:
14460 val = read_uleb128 (p, &len, end);
14461 p += len;
14462 printf (" Tag_Data_Model: ");
14463 switch (val)
14464 {
14465 case 0: printf (_("None\n")); break;
14466 case 1: printf (_("Small\n")); break;
14467 case 2: printf (_("Large\n")); break;
14468 case 3: printf (_("Restricted Large\n")); break;
14469 default: printf ("??? (%d)\n", val); break;
14470 }
14471 break;
14472
14473 default:
14474 printf (_(" <unknown tag %d>: "), tag);
14475
14476 if (tag & 1)
14477 {
071436c6 14478 putchar ('"');
4082ef84
NC		 14479 if (p < end - 1)
14480 {
14481 size_t maxlen = (end - p) - 1;
14482
14483 print_symbol ((int) maxlen, (const char *) p);
14484 p += strnlen ((char *) p, maxlen) + 1;
14485 }
14486 else
14487 {
14488 printf (_("<corrupt>"));
14489 p = (unsigned char *) end;
14490 }
071436c6 14491 printf ("\"\n");
13761a11
NC		 14492 }
14493 else
14494 {
14495 val = read_uleb128 (p, &len, end);
14496 p += len;
14497 printf ("%d (0x%x)\n", val, val);
14498 }
14499 break;
14500 }
14501
4082ef84 14502 assert (p <= end);
13761a11
NC		 14503 return p;
14504}
14505
32ec8896 14506static bfd_boolean
60bca95a
NC		 14507process_attributes (FILE * file,
14508 const char * public_name,
104d59d1 14509 unsigned int proc_type,
f6f0e17b 14510 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
60abdbed 14511 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
11c1ff18 14512{
2cf0635d 14513 Elf_Internal_Shdr * sect;
11c1ff18 14514 unsigned i;
32ec8896 14515 bfd_boolean res = TRUE;
11c1ff18
PB		 14516
14517 /* Find the section header so that we get the size. */
14518 for (i = 0, sect = section_headers;
14519 i < elf_header.e_shnum;
14520 i++, sect++)
14521 {
071436c6
NC		 14522 unsigned char * contents;
14523 unsigned char * p;
14524
104d59d1 14525 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 14526 continue;
14527
3f5e193b
NC		 14528 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
14529 sect->sh_size, _("attributes"));
60bca95a 14530 if (contents == NULL)
32ec8896
NC		 14531 {
14532 res = FALSE;
14533 continue;
14534 }
60bca95a 14535
11c1ff18 14536 p = contents;
60abdbed
NC		 14537 /* The first character is the version of the attributes.
14538 Currently only version 1, (aka 'A') is recognised here. */
14539 if (*p != 'A')
32ec8896
NC		 14540 {
14541 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
14542 res = FALSE;
14543 }
60abdbed 14544 else
11c1ff18 14545 {
071436c6
NC		 14546 bfd_vma section_len;
14547
14548 section_len = sect->sh_size - 1;
11c1ff18 14549 p++;
60bca95a 14550
071436c6 14551 while (section_len > 0)
11c1ff18 14552 {
071436c6 14553 bfd_vma attr_len;
e9847026 14554 unsigned int namelen;
11c1ff18 14555 bfd_boolean public_section;
104d59d1 14556 bfd_boolean gnu_section;
11c1ff18 14557
071436c6 14558 if (section_len <= 4)
e0a31db1
NC		 14559 {
14560 error (_("Tag section ends prematurely\n"));
32ec8896 14561 res = FALSE;
e0a31db1
NC		 14562 break;
14563 }
071436c6 14564 attr_len = byte_get (p, 4);
11c1ff18 14565 p += 4;
60bca95a 14566
071436c6 14567 if (attr_len > section_len)
11c1ff18 14568 {
071436c6
NC		 14569 error (_("Bad attribute length (%u > %u)\n"),
14570 (unsigned) attr_len, (unsigned) section_len);
14571 attr_len = section_len;
32ec8896 14572 res = FALSE;
11c1ff18 14573 }
74e1a04b 14574 /* PR 17531: file: 001-101425-0.004 */
071436c6 14575 else if (attr_len < 5)
74e1a04b 14576 {
071436c6 14577 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
32ec8896 14578 res = FALSE;
74e1a04b
NC		 14579 break;
14580 }
e9847026 14581
071436c6
NC		 14582 section_len -= attr_len;
14583 attr_len -= 4;
14584
14585 namelen = strnlen ((char *) p, attr_len) + 1;
14586 if (namelen == 0 || namelen >= attr_len)
e9847026
NC		 14587 {
14588 error (_("Corrupt attribute section name\n"));
32ec8896 14589 res = FALSE;
e9847026
NC		 14590 break;
14591 }
14592
071436c6
NC		 14593 printf (_("Attribute Section: "));
14594 print_symbol (INT_MAX, (const char *) p);
14595 putchar ('\n');
60bca95a
NC		 14596
14597 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 14598 public_section = TRUE;
14599 else
14600 public_section = FALSE;
60bca95a
NC		 14601
14602 if (streq ((char *) p, "gnu"))
104d59d1
JM		 14603 gnu_section = TRUE;
14604 else
14605 gnu_section = FALSE;
60bca95a 14606
11c1ff18 14607 p += namelen;
071436c6 14608 attr_len -= namelen;
e0a31db1 14609
071436c6 14610 while (attr_len > 0 && p < contents + sect->sh_size)
11c1ff18 14611 {
e0a31db1 14612 int tag;
11c1ff18
PB		 14613 int val;
14614 bfd_vma size;
071436c6 14615 unsigned char * end;
60bca95a 14616
e0a31db1 14617 /* PR binutils/17531: Safe handling of corrupt files. */
071436c6 14618 if (attr_len < 6)
e0a31db1
NC		 14619 {
14620 error (_("Unused bytes at end of section\n"));
32ec8896 14621 res = FALSE;
e0a31db1
NC		 14622 section_len = 0;
14623 break;
14624 }
14625
14626 tag = *(p++);
11c1ff18 14627 size = byte_get (p, 4);
071436c6 14628 if (size > attr_len)
11c1ff18 14629 {
e9847026 14630 error (_("Bad subsection length (%u > %u)\n"),
071436c6 14631 (unsigned) size, (unsigned) attr_len);
32ec8896 14632 res = FALSE;
071436c6 14633 size = attr_len;
11c1ff18 14634 }
e0a31db1
NC		 14635 /* PR binutils/17531: Safe handling of corrupt files. */
14636 if (size < 6)
14637 {
14638 error (_("Bad subsection length (%u < 6)\n"),
14639 (unsigned) size);
32ec8896 14640 res = FALSE;
e0a31db1
NC		 14641 section_len = 0;
14642 break;
14643 }
60bca95a 14644
071436c6 14645 attr_len -= size;
11c1ff18 14646 end = p + size - 1;
071436c6 14647 assert (end <= contents + sect->sh_size);
11c1ff18 14648 p += 4;
60bca95a 14649
11c1ff18
PB		 14650 switch (tag)
14651 {
14652 case 1:
2b692964 14653 printf (_("File Attributes\n"));
11c1ff18
PB		 14654 break;
14655 case 2:
2b692964 14656 printf (_("Section Attributes:"));
11c1ff18
PB		 14657 goto do_numlist;
14658 case 3:
2b692964 14659 printf (_("Symbol Attributes:"));
1a0670f3 14660 /* Fall through. */
11c1ff18
PB		 14661 do_numlist:
14662 for (;;)
14663 {
91d6fa6a 14664 unsigned int j;
60bca95a 14665
f6f0e17b 14666 val = read_uleb128 (p, &j, end);
91d6fa6a 14667 p += j;
11c1ff18
PB		 14668 if (val == 0)
14669 break;
14670 printf (" %d", val);
14671 }
14672 printf ("\n");
14673 break;
14674 default:
2b692964 14675 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 14676 public_section = FALSE;
14677 break;
14678 }
60bca95a 14679
071436c6 14680 if (public_section && display_pub_attribute != NULL)
11c1ff18
PB		 14681 {
14682 while (p < end)
f6f0e17b 14683 p = display_pub_attribute (p, end);
60abdbed 14684 assert (p == end);
104d59d1 14685 }
071436c6 14686 else if (gnu_section && display_proc_gnu_attribute != NULL)
104d59d1
JM		 14687 {
14688 while (p < end)
14689 p = display_gnu_attribute (p,
f6f0e17b
NC		 14690 display_proc_gnu_attribute,
14691 end);
60abdbed 14692 assert (p == end);
11c1ff18 14693 }
071436c6 14694 else if (p < end)
11c1ff18 14695 {
071436c6 14696 printf (_(" Unknown attribute:\n"));
f6f0e17b 14697 display_raw_attribute (p, end);
11c1ff18
PB		 14698 p = end;
14699 }
071436c6
NC		 14700 else
14701 attr_len = 0;
11c1ff18
PB		 14702 }
14703 }
14704 }
d70c5fc7 14705
60bca95a 14706 free (contents);
11c1ff18 14707 }
32ec8896
NC		 14708
14709 return res;
11c1ff18
PB		 14710}
14711
ccb4c951
RS		 14712/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14713 Print the Address, Access and Initial fields of an entry at VMA ADDR
82b1b41b
NC		 14714 and return the VMA of the next entry, or -1 if there was a problem.
14715 Does not read from DATA_END or beyond. */
ccb4c951
RS		 14716
14717static bfd_vma
82b1b41b
NC		 14718print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
14719 unsigned char * data_end)
ccb4c951
RS		 14720{
14721 printf (" ");
14722 print_vma (addr, LONG_HEX);
14723 printf (" ");
14724 if (addr < pltgot + 0xfff0)
14725 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
14726 else
14727 printf ("%10s", "");
14728 printf (" ");
14729 if (data == NULL)
2b692964 14730 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 14731 else
14732 {
14733 bfd_vma entry;
82b1b41b 14734 unsigned char * from = data + addr - pltgot;
ccb4c951 14735
82b1b41b
NC		 14736 if (from + (is_32bit_elf ? 4 : 8) > data_end)
14737 {
14738 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14739 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
14740 return (bfd_vma) -1;
14741 }
14742 else
14743 {
14744 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14745 print_vma (entry, LONG_HEX);
14746 }
ccb4c951
RS		 14747 }
14748 return addr + (is_32bit_elf ? 4 : 8);
14749}
14750
861fb55a
DJ		 14751/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14752 PLTGOT. Print the Address and Initial fields of an entry at VMA
14753 ADDR and return the VMA of the next entry. */
14754
14755static bfd_vma
2cf0635d 14756print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 14757{
14758 printf (" ");
14759 print_vma (addr, LONG_HEX);
14760 printf (" ");
14761 if (data == NULL)
2b692964 14762 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 14763 else
14764 {
14765 bfd_vma entry;
14766
14767 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14768 print_vma (entry, LONG_HEX);
14769 }
14770 return addr + (is_32bit_elf ? 4 : 8);
14771}
14772
351cdf24
MF		 14773static void
14774print_mips_ases (unsigned int mask)
14775{
14776 if (mask & AFL_ASE_DSP)
14777 fputs ("\n\tDSP ASE", stdout);
14778 if (mask & AFL_ASE_DSPR2)
14779 fputs ("\n\tDSP R2 ASE", stdout);
8f4f9071
MF		 14780 if (mask & AFL_ASE_DSPR3)
14781 fputs ("\n\tDSP R3 ASE", stdout);
351cdf24
MF		 14782 if (mask & AFL_ASE_EVA)
14783 fputs ("\n\tEnhanced VA Scheme", stdout);
14784 if (mask & AFL_ASE_MCU)
14785 fputs ("\n\tMCU (MicroController) ASE", stdout);
14786 if (mask & AFL_ASE_MDMX)
14787 fputs ("\n\tMDMX ASE", stdout);
14788 if (mask & AFL_ASE_MIPS3D)
14789 fputs ("\n\tMIPS-3D ASE", stdout);
14790 if (mask & AFL_ASE_MT)
14791 fputs ("\n\tMT ASE", stdout);
14792 if (mask & AFL_ASE_SMARTMIPS)
14793 fputs ("\n\tSmartMIPS ASE", stdout);
14794 if (mask & AFL_ASE_VIRT)
14795 fputs ("\n\tVZ ASE", stdout);
14796 if (mask & AFL_ASE_MSA)
14797 fputs ("\n\tMSA ASE", stdout);
14798 if (mask & AFL_ASE_MIPS16)
14799 fputs ("\n\tMIPS16 ASE", stdout);
14800 if (mask & AFL_ASE_MICROMIPS)
14801 fputs ("\n\tMICROMIPS ASE", stdout);
14802 if (mask & AFL_ASE_XPA)
14803 fputs ("\n\tXPA ASE", stdout);
14804 if (mask == 0)
14805 fprintf (stdout, "\n\t%s", _("None"));
00ac7aa0
MF		 14806 else if ((mask & ~AFL_ASE_MASK) != 0)
14807 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
351cdf24
MF		 14808}
14809
14810static void
14811print_mips_isa_ext (unsigned int isa_ext)
14812{
14813 switch (isa_ext)
14814 {
14815 case 0:
14816 fputs (_("None"), stdout);
14817 break;
14818 case AFL_EXT_XLR:
14819 fputs ("RMI XLR", stdout);
14820 break;
2c629856
N		 14821 case AFL_EXT_OCTEON3:
14822 fputs ("Cavium Networks Octeon3", stdout);
14823 break;
351cdf24
MF		 14824 case AFL_EXT_OCTEON2:
14825 fputs ("Cavium Networks Octeon2", stdout);
14826 break;
14827 case AFL_EXT_OCTEONP:
14828 fputs ("Cavium Networks OcteonP", stdout);
14829 break;
14830 case AFL_EXT_LOONGSON_3A:
14831 fputs ("Loongson 3A", stdout);
14832 break;
14833 case AFL_EXT_OCTEON:
14834 fputs ("Cavium Networks Octeon", stdout);
14835 break;
14836 case AFL_EXT_5900:
14837 fputs ("Toshiba R5900", stdout);
14838 break;
14839 case AFL_EXT_4650:
14840 fputs ("MIPS R4650", stdout);
14841 break;
14842 case AFL_EXT_4010:
14843 fputs ("LSI R4010", stdout);
14844 break;
14845 case AFL_EXT_4100:
14846 fputs ("NEC VR4100", stdout);
14847 break;
14848 case AFL_EXT_3900:
14849 fputs ("Toshiba R3900", stdout);
14850 break;
14851 case AFL_EXT_10000:
14852 fputs ("MIPS R10000", stdout);
14853 break;
14854 case AFL_EXT_SB1:
14855 fputs ("Broadcom SB-1", stdout);
14856 break;
14857 case AFL_EXT_4111:
14858 fputs ("NEC VR4111/VR4181", stdout);
14859 break;
14860 case AFL_EXT_4120:
14861 fputs ("NEC VR4120", stdout);
14862 break;
14863 case AFL_EXT_5400:
14864 fputs ("NEC VR5400", stdout);
14865 break;
14866 case AFL_EXT_5500:
14867 fputs ("NEC VR5500", stdout);
14868 break;
14869 case AFL_EXT_LOONGSON_2E:
14870 fputs ("ST Microelectronics Loongson 2E", stdout);
14871 break;
14872 case AFL_EXT_LOONGSON_2F:
14873 fputs ("ST Microelectronics Loongson 2F", stdout);
14874 break;
14875 default:
00ac7aa0 14876 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
351cdf24
MF		 14877 }
14878}
14879
32ec8896 14880static signed int
351cdf24
MF		 14881get_mips_reg_size (int reg_size)
14882{
14883 return (reg_size == AFL_REG_NONE) ? 0
14884 : (reg_size == AFL_REG_32) ? 32
14885 : (reg_size == AFL_REG_64) ? 64
14886 : (reg_size == AFL_REG_128) ? 128
14887 : -1;
14888}
14889
32ec8896 14890static bfd_boolean
2cf0635d 14891process_mips_specific (FILE * file)
5b18a4bc 14892{
2cf0635d 14893 Elf_Internal_Dyn * entry;
351cdf24 14894 Elf_Internal_Shdr *sect = NULL;
19e6b90e
L		 14895 size_t liblist_offset = 0;
14896 size_t liblistno = 0;
14897 size_t conflictsno = 0;
14898 size_t options_offset = 0;
14899 size_t conflicts_offset = 0;
861fb55a
DJ		 14900 size_t pltrelsz = 0;
14901 size_t pltrel = 0;
ccb4c951 14902 bfd_vma pltgot = 0;
861fb55a
DJ		 14903 bfd_vma mips_pltgot = 0;
14904 bfd_vma jmprel = 0;
ccb4c951
RS		 14905 bfd_vma local_gotno = 0;
14906 bfd_vma gotsym = 0;
14907 bfd_vma symtabno = 0;
32ec8896 14908 bfd_boolean res = TRUE;
103f02d3 14909
32ec8896
NC		 14910 if (! process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14911 display_mips_gnu_attribute))
14912 res = FALSE;
2cf19d5c 14913
351cdf24
MF		 14914 sect = find_section (".MIPS.abiflags");
14915
14916 if (sect != NULL)
14917 {
14918 Elf_External_ABIFlags_v0 *abiflags_ext;
14919 Elf_Internal_ABIFlags_v0 abiflags_in;
14920
14921 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
32ec8896
NC		 14922 {
14923 error (_("Corrupt MIPS ABI Flags section.\n"));
14924 res = FALSE;
14925 }
351cdf24
MF		 14926 else
14927 {
14928 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
14929 sect->sh_size, _("MIPS ABI Flags section"));
14930 if (abiflags_ext)
14931 {
14932 abiflags_in.version = BYTE_GET (abiflags_ext->version);
14933 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
14934 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
14935 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
14936 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
14937 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
14938 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
14939 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
14940 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
14941 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
14942 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
14943
14944 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
14945 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
14946 if (abiflags_in.isa_rev > 1)
14947 printf ("r%d", abiflags_in.isa_rev);
14948 printf ("\nGPR size: %d",
14949 get_mips_reg_size (abiflags_in.gpr_size));
14950 printf ("\nCPR1 size: %d",
14951 get_mips_reg_size (abiflags_in.cpr1_size));
14952 printf ("\nCPR2 size: %d",
14953 get_mips_reg_size (abiflags_in.cpr2_size));
14954 fputs ("\nFP ABI: ", stdout);
14955 print_mips_fp_abi_value (abiflags_in.fp_abi);
14956 fputs ("ISA Extension: ", stdout);
14957 print_mips_isa_ext (abiflags_in.isa_ext);
14958 fputs ("\nASEs:", stdout);
14959 print_mips_ases (abiflags_in.ases);
14960 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
14961 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
14962 fputc ('\n', stdout);
14963 free (abiflags_ext);
14964 }
14965 }
14966 }
14967
19e6b90e
L		 14968 /* We have a lot of special sections. Thanks SGI! */
14969 if (dynamic_section == NULL)
14970 /* No information available. */
32ec8896 14971 return res;
252b5132 14972
071436c6
NC		 14973 for (entry = dynamic_section;
14974 /* PR 17531 file: 012-50589-0.004. */
14975 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
14976 ++entry)
252b5132
RH		 14977 switch (entry->d_tag)
14978 {
14979 case DT_MIPS_LIBLIST:
d93f0186
NC		 14980 liblist_offset
14981 = offset_from_vma (file, entry->d_un.d_val,
14982 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 14983 break;
14984 case DT_MIPS_LIBLISTNO:
14985 liblistno = entry->d_un.d_val;
14986 break;
14987 case DT_MIPS_OPTIONS:
d93f0186 14988 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 14989 break;
14990 case DT_MIPS_CONFLICT:
d93f0186
NC		 14991 conflicts_offset
14992 = offset_from_vma (file, entry->d_un.d_val,
14993 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 14994 break;
14995 case DT_MIPS_CONFLICTNO:
14996 conflictsno = entry->d_un.d_val;
14997 break;
ccb4c951 14998 case DT_PLTGOT:
861fb55a
DJ		 14999 pltgot = entry->d_un.d_ptr;
15000 break;
ccb4c951
RS		 15001 case DT_MIPS_LOCAL_GOTNO:
15002 local_gotno = entry->d_un.d_val;
15003 break;
15004 case DT_MIPS_GOTSYM:
15005 gotsym = entry->d_un.d_val;
15006 break;
15007 case DT_MIPS_SYMTABNO:
15008 symtabno = entry->d_un.d_val;
15009 break;
861fb55a
DJ		 15010 case DT_MIPS_PLTGOT:
15011 mips_pltgot = entry->d_un.d_ptr;
15012 break;
15013 case DT_PLTREL:
15014 pltrel = entry->d_un.d_val;
15015 break;
15016 case DT_PLTRELSZ:
15017 pltrelsz = entry->d_un.d_val;
15018 break;
15019 case DT_JMPREL:
15020 jmprel = entry->d_un.d_ptr;
15021 break;
252b5132
RH		 15022 default:
15023 break;
15024 }
15025
15026 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
15027 {
2cf0635d 15028 Elf32_External_Lib * elib;
252b5132
RH		 15029 size_t cnt;
15030
3f5e193b
NC		 15031 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
15032 liblistno,
15033 sizeof (Elf32_External_Lib),
9cf03b7e 15034 _("liblist section data"));
a6e9f9df 15035 if (elib)
252b5132 15036 {
2b692964 15037 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 15038 (unsigned long) liblistno);
2b692964 15039 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 15040 stdout);
15041
15042 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 15043 {
a6e9f9df 15044 Elf32_Lib liblist;
91d6fa6a 15045 time_t atime;
d5b07ef4 15046 char timebuf[128];
2cf0635d 15047 struct tm * tmp;
a6e9f9df
AM		 15048
15049 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 15050 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 15051 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15052 liblist.l_version = BYTE_GET (elib[cnt].l_version);
15053 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15054
91d6fa6a 15055 tmp = gmtime (&atime);
e9e44622
JJ		 15056 snprintf (timebuf, sizeof (timebuf),
15057 "%04u-%02u-%02uT%02u:%02u:%02u",
15058 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15059 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 15060
31104126 15061 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 15062 if (VALID_DYNAMIC_NAME (liblist.l_name))
15063 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
15064 else
2b692964 15065 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 15066 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
15067 liblist.l_version);
a6e9f9df
AM		 15068
15069 if (liblist.l_flags == 0)
2b692964 15070 puts (_(" NONE"));
a6e9f9df
AM		 15071 else
15072 {
15073 static const struct
252b5132 15074 {
2cf0635d 15075 const char * name;
a6e9f9df 15076 int bit;
252b5132 15077 }
a6e9f9df
AM		 15078 l_flags_vals[] =
15079 {
15080 { " EXACT_MATCH", LL_EXACT_MATCH },
15081 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
15082 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
15083 { " EXPORTS", LL_EXPORTS },
15084 { " DELAY_LOAD", LL_DELAY_LOAD },
15085 { " DELTA", LL_DELTA }
15086 };
15087 int flags = liblist.l_flags;
15088 size_t fcnt;
15089
60bca95a 15090 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 15091 if ((flags & l_flags_vals[fcnt].bit) != 0)
15092 {
15093 fputs (l_flags_vals[fcnt].name, stdout);
15094 flags ^= l_flags_vals[fcnt].bit;
15095 }
15096 if (flags != 0)
15097 printf (" %#x", (unsigned int) flags);
252b5132 15098
a6e9f9df
AM		 15099 puts ("");
15100 }
252b5132 15101 }
252b5132 15102
a6e9f9df
AM		 15103 free (elib);
15104 }
32ec8896
NC		 15105 else
15106 res = FALSE;
252b5132
RH		 15107 }
15108
15109 if (options_offset != 0)
15110 {
2cf0635d 15111 Elf_External_Options * eopt;
2cf0635d
NC		 15112 Elf_Internal_Options * iopt;
15113 Elf_Internal_Options * option;
252b5132
RH		 15114 size_t offset;
15115 int cnt;
351cdf24 15116 sect = section_headers;
252b5132
RH		 15117
15118 /* Find the section header so that we get the size. */
071436c6 15119 sect = find_section_by_type (SHT_MIPS_OPTIONS);
948f632f 15120 /* PR 17533 file: 012-277276-0.004. */
071436c6
NC		 15121 if (sect == NULL)
15122 {
15123 error (_("No MIPS_OPTIONS header found\n"));
32ec8896 15124 return FALSE;
071436c6 15125 }
252b5132 15126
3f5e193b
NC		 15127 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
15128 sect->sh_size, _("options"));
a6e9f9df 15129 if (eopt)
252b5132 15130 {
3f5e193b
NC		 15131 iopt = (Elf_Internal_Options *)
15132 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 15133 if (iopt == NULL)
15134 {
fb324ee9 15135 error (_("Out of memory allocating space for MIPS options\n"));
32ec8896 15136 return FALSE;
a6e9f9df 15137 }
76da6bbe 15138
a6e9f9df
AM		 15139 offset = cnt = 0;
15140 option = iopt;
252b5132 15141
82b1b41b 15142 while (offset <= sect->sh_size - sizeof (* eopt))
a6e9f9df 15143 {
2cf0635d 15144 Elf_External_Options * eoption;
252b5132 15145
a6e9f9df 15146 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 15147
a6e9f9df
AM		 15148 option->kind = BYTE_GET (eoption->kind);
15149 option->size = BYTE_GET (eoption->size);
15150 option->section = BYTE_GET (eoption->section);
15151 option->info = BYTE_GET (eoption->info);
76da6bbe 15152
82b1b41b
NC		 15153 /* PR 17531: file: ffa0fa3b. */
15154 if (option->size < sizeof (* eopt)
15155 || offset + option->size > sect->sh_size)
15156 {
55325047 15157 error (_("Invalid size (%u) for MIPS option\n"), option->size);
32ec8896 15158 return FALSE;
82b1b41b 15159 }
a6e9f9df 15160 offset += option->size;
14ae95f2 15161
a6e9f9df
AM		 15162 ++option;
15163 ++cnt;
15164 }
252b5132 15165
a6e9f9df 15166 printf (_("\nSection '%s' contains %d entries:\n"),
74e1a04b 15167 printable_section_name (sect), cnt);
76da6bbe 15168
a6e9f9df 15169 option = iopt;
82b1b41b 15170 offset = 0;
252b5132 15171
a6e9f9df 15172 while (cnt-- > 0)
252b5132 15173 {
a6e9f9df
AM		 15174 size_t len;
15175
15176 switch (option->kind)
252b5132 15177 {
a6e9f9df
AM		 15178 case ODK_NULL:
15179 /* This shouldn't happen. */
15180 printf (" NULL %d %lx", option->section, option->info);
15181 break;
15182 case ODK_REGINFO:
15183 printf (" REGINFO ");
15184 if (elf_header.e_machine == EM_MIPS)
15185 {
15186 /* 32bit form. */
2cf0635d 15187 Elf32_External_RegInfo * ereg;
b34976b6 15188 Elf32_RegInfo reginfo;
a6e9f9df
AM		 15189
15190 ereg = (Elf32_External_RegInfo *) (option + 1);
15191 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
15192 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15193 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15194 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15195 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15196 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
15197
15198 printf ("GPR %08lx GP 0x%lx\n",
15199 reginfo.ri_gprmask,
15200 (unsigned long) reginfo.ri_gp_value);
15201 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15202 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15203 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15204 }
15205 else
15206 {
15207 /* 64 bit form. */
2cf0635d 15208 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 15209 Elf64_Internal_RegInfo reginfo;
15210
15211 ereg = (Elf64_External_RegInfo *) (option + 1);
15212 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
15213 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15214 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15215 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15216 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 15217 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 15218
15219 printf ("GPR %08lx GP 0x",
15220 reginfo.ri_gprmask);
15221 printf_vma (reginfo.ri_gp_value);
15222 printf ("\n");
15223
15224 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15225 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15226 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15227 }
15228 ++option;
15229 continue;
15230 case ODK_EXCEPTIONS:
15231 fputs (" EXCEPTIONS fpe_min(", stdout);
15232 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
15233 fputs (") fpe_max(", stdout);
15234 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
15235 fputs (")", stdout);
15236
15237 if (option->info & OEX_PAGE0)
15238 fputs (" PAGE0", stdout);
15239 if (option->info & OEX_SMM)
15240 fputs (" SMM", stdout);
15241 if (option->info & OEX_FPDBUG)
15242 fputs (" FPDBUG", stdout);
15243 if (option->info & OEX_DISMISS)
15244 fputs (" DISMISS", stdout);
15245 break;
15246 case ODK_PAD:
15247 fputs (" PAD ", stdout);
15248 if (option->info & OPAD_PREFIX)
15249 fputs (" PREFIX", stdout);
15250 if (option->info & OPAD_POSTFIX)
15251 fputs (" POSTFIX", stdout);
15252 if (option->info & OPAD_SYMBOL)
15253 fputs (" SYMBOL", stdout);
15254 break;
15255 case ODK_HWPATCH:
15256 fputs (" HWPATCH ", stdout);
15257 if (option->info & OHW_R4KEOP)
15258 fputs (" R4KEOP", stdout);
15259 if (option->info & OHW_R8KPFETCH)
15260 fputs (" R8KPFETCH", stdout);
15261 if (option->info & OHW_R5KEOP)
15262 fputs (" R5KEOP", stdout);
15263 if (option->info & OHW_R5KCVTL)
15264 fputs (" R5KCVTL", stdout);
15265 break;
15266 case ODK_FILL:
15267 fputs (" FILL ", stdout);
15268 /* XXX Print content of info word? */
15269 break;
15270 case ODK_TAGS:
15271 fputs (" TAGS ", stdout);
15272 /* XXX Print content of info word? */
15273 break;
15274 case ODK_HWAND:
15275 fputs (" HWAND ", stdout);
15276 if (option->info & OHWA0_R4KEOP_CHECKED)
15277 fputs (" R4KEOP_CHECKED", stdout);
15278 if (option->info & OHWA0_R4KEOP_CLEAN)
15279 fputs (" R4KEOP_CLEAN", stdout);
15280 break;
15281 case ODK_HWOR:
15282 fputs (" HWOR ", stdout);
15283 if (option->info & OHWA0_R4KEOP_CHECKED)
15284 fputs (" R4KEOP_CHECKED", stdout);
15285 if (option->info & OHWA0_R4KEOP_CLEAN)
15286 fputs (" R4KEOP_CLEAN", stdout);
15287 break;
15288 case ODK_GP_GROUP:
15289 printf (" GP_GROUP %#06lx self-contained %#06lx",
15290 option->info & OGP_GROUP,
15291 (option->info & OGP_SELF) >> 16);
15292 break;
15293 case ODK_IDENT:
15294 printf (" IDENT %#06lx self-contained %#06lx",
15295 option->info & OGP_GROUP,
15296 (option->info & OGP_SELF) >> 16);
15297 break;
15298 default:
15299 /* This shouldn't happen. */
15300 printf (" %3d ??? %d %lx",
15301 option->kind, option->section, option->info);
15302 break;
252b5132 15303 }
a6e9f9df 15304
2cf0635d 15305 len = sizeof (* eopt);
a6e9f9df 15306 while (len < option->size)
82b1b41b 15307 {
7e27a9d5 15308 unsigned char datum = * ((unsigned char *) eopt + offset + len);
a6e9f9df 15309
82b1b41b
NC		 15310 if (ISPRINT (datum))
15311 printf ("%c", datum);
15312 else
15313 printf ("\\%03o", datum);
15314 len ++;
15315 }
a6e9f9df 15316 fputs ("\n", stdout);
82b1b41b
NC		 15317
15318 offset += option->size;
252b5132 15319 ++option;
252b5132
RH		 15320 }
15321
a6e9f9df 15322 free (eopt);
252b5132 15323 }
32ec8896
NC		 15324 else
15325 res = FALSE;
252b5132
RH		 15326 }
15327
15328 if (conflicts_offset != 0 && conflictsno != 0)
15329 {
2cf0635d 15330 Elf32_Conflict * iconf;
252b5132
RH		 15331 size_t cnt;
15332
15333 if (dynamic_symbols == NULL)
15334 {
591a748a 15335 error (_("conflict list found without a dynamic symbol table\n"));
32ec8896 15336 return FALSE;
252b5132
RH		 15337 }
15338
3f5e193b 15339 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 15340 if (iconf == NULL)
15341 {
8b73c356 15342 error (_("Out of memory allocating space for dynamic conflicts\n"));
32ec8896 15343 return FALSE;
252b5132
RH		 15344 }
15345
9ea033b2 15346 if (is_32bit_elf)
252b5132 15347 {
2cf0635d 15348 Elf32_External_Conflict * econf32;
a6e9f9df 15349
3f5e193b
NC		 15350 econf32 = (Elf32_External_Conflict *)
15351 get_data (NULL, file, conflicts_offset, conflictsno,
15352 sizeof (* econf32), _("conflict"));
a6e9f9df 15353 if (!econf32)
32ec8896 15354 return FALSE;
252b5132
RH		 15355
15356 for (cnt = 0; cnt < conflictsno; ++cnt)
15357 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 15358
15359 free (econf32);
252b5132
RH		 15360 }
15361 else
15362 {
2cf0635d 15363 Elf64_External_Conflict * econf64;
a6e9f9df 15364
3f5e193b
NC		 15365 econf64 = (Elf64_External_Conflict *)
15366 get_data (NULL, file, conflicts_offset, conflictsno,
15367 sizeof (* econf64), _("conflict"));
a6e9f9df 15368 if (!econf64)
32ec8896 15369 return FALSE;
252b5132
RH		 15370
15371 for (cnt = 0; cnt < conflictsno; ++cnt)
15372 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 15373
15374 free (econf64);
252b5132
RH		 15375 }
15376
c7e7ca54
NC		 15377 printf (_("\nSection '.conflict' contains %lu entries:\n"),
15378 (unsigned long) conflictsno);
252b5132
RH		 15379 puts (_(" Num: Index Value Name"));
15380
15381 for (cnt = 0; cnt < conflictsno; ++cnt)
15382 {
b34976b6 15383 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
e0a31db1
NC		 15384
15385 if (iconf[cnt] >= num_dynamic_syms)
15386 printf (_("<corrupt symbol index>"));
d79b3d50 15387 else
e0a31db1
NC		 15388 {
15389 Elf_Internal_Sym * psym;
15390
15391 psym = & dynamic_symbols[iconf[cnt]];
15392 print_vma (psym->st_value, FULL_HEX);
15393 putchar (' ');
15394 if (VALID_DYNAMIC_NAME (psym->st_name))
15395 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
15396 else
15397 printf (_("<corrupt: %14ld>"), psym->st_name);
15398 }
31104126 15399 putchar ('\n');
252b5132
RH		 15400 }
15401
252b5132
RH		 15402 free (iconf);
15403 }
15404
ccb4c951
RS		 15405 if (pltgot != 0 && local_gotno != 0)
15406 {
91d6fa6a 15407 bfd_vma ent, local_end, global_end;
bbeee7ea 15408 size_t i, offset;
2cf0635d 15409 unsigned char * data;
82b1b41b 15410 unsigned char * data_end;
bbeee7ea 15411 int addr_size;
ccb4c951 15412
91d6fa6a 15413 ent = pltgot;
ccb4c951
RS		 15414 addr_size = (is_32bit_elf ? 4 : 8);
15415 local_end = pltgot + local_gotno * addr_size;
ccb4c951 15416
74e1a04b
NC		 15417 /* PR binutils/17533 file: 012-111227-0.004 */
15418 if (symtabno < gotsym)
15419 {
15420 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
82b1b41b 15421 (unsigned long) gotsym, (unsigned long) symtabno);
32ec8896 15422 return FALSE;
74e1a04b 15423 }
82b1b41b 15424
74e1a04b 15425 global_end = local_end + (symtabno - gotsym) * addr_size;
82b1b41b
NC		 15426 /* PR 17531: file: 54c91a34. */
15427 if (global_end < local_end)
15428 {
15429 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
32ec8896 15430 return FALSE;
82b1b41b 15431 }
948f632f 15432
ccb4c951 15433 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 15434 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 15435 global_end - pltgot, 1,
15436 _("Global Offset Table data"));
59245841 15437 if (data == NULL)
32ec8896 15438 return FALSE;
82b1b41b 15439 data_end = data + (global_end - pltgot);
59245841 15440
ccb4c951
RS		 15441 printf (_("\nPrimary GOT:\n"));
15442 printf (_(" Canonical gp value: "));
15443 print_vma (pltgot + 0x7ff0, LONG_HEX);
15444 printf ("\n\n");
15445
15446 printf (_(" Reserved entries:\n"));
15447 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 15448 addr_size * 2, _("Address"), _("Access"),
15449 addr_size * 2, _("Initial"));
82b1b41b 15450 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 15451 printf (_(" Lazy resolver\n"));
82b1b41b
NC		 15452 if (ent == (bfd_vma) -1)
15453 goto got_print_fail;
ccb4c951 15454 if (data
91d6fa6a 15455 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 15456 >> (addr_size * 8 - 1)) != 0)
15457 {
82b1b41b 15458 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 15459 printf (_(" Module pointer (GNU extension)\n"));
82b1b41b
NC		 15460 if (ent == (bfd_vma) -1)
15461 goto got_print_fail;
ccb4c951
RS		 15462 }
15463 printf ("\n");
15464
91d6fa6a 15465 if (ent < local_end)
ccb4c951
RS		 15466 {
15467 printf (_(" Local entries:\n"));
cc5914eb 15468 printf (" %*s %10s %*s\n",
2b692964
NC		 15469 addr_size * 2, _("Address"), _("Access"),
15470 addr_size * 2, _("Initial"));
91d6fa6a 15471 while (ent < local_end)
ccb4c951 15472 {
82b1b41b 15473 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 15474 printf ("\n");
82b1b41b
NC		 15475 if (ent == (bfd_vma) -1)
15476 goto got_print_fail;
ccb4c951
RS		 15477 }
15478 printf ("\n");
15479 }
15480
15481 if (gotsym < symtabno)
15482 {
15483 int sym_width;
15484
15485 printf (_(" Global entries:\n"));
cc5914eb 15486 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 15487 addr_size * 2, _("Address"),
15488 _("Access"),
2b692964 15489 addr_size * 2, _("Initial"),
9cf03b7e
NC		 15490 addr_size * 2, _("Sym.Val."),
15491 _("Type"),
15492 /* Note for translators: "Ndx" = abbreviated form of "Index". */
15493 _("Ndx"), _("Name"));
0b4362b0 15494
ccb4c951 15495 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
e0a31db1 15496
ccb4c951
RS		 15497 for (i = gotsym; i < symtabno; i++)
15498 {
82b1b41b 15499 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 15500 printf (" ");
e0a31db1
NC		 15501
15502 if (dynamic_symbols == NULL)
15503 printf (_("<no dynamic symbols>"));
15504 else if (i < num_dynamic_syms)
15505 {
15506 Elf_Internal_Sym * psym = dynamic_symbols + i;
15507
15508 print_vma (psym->st_value, LONG_HEX);
15509 printf (" %-7s %3s ",
15510 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
15511 get_symbol_index_type (psym->st_shndx));
15512
15513 if (VALID_DYNAMIC_NAME (psym->st_name))
15514 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
15515 else
15516 printf (_("<corrupt: %14ld>"), psym->st_name);
15517 }
ccb4c951 15518 else
7fc5ac57
JBG		 15519 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15520 (unsigned long) i);
e0a31db1 15521
ccb4c951 15522 printf ("\n");
82b1b41b
NC		 15523 if (ent == (bfd_vma) -1)
15524 break;
ccb4c951
RS		 15525 }
15526 printf ("\n");
15527 }
15528
82b1b41b 15529 got_print_fail:
ccb4c951
RS		 15530 if (data)
15531 free (data);
15532 }
15533
861fb55a
DJ		 15534 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
15535 {
91d6fa6a 15536 bfd_vma ent, end;
861fb55a
DJ		 15537 size_t offset, rel_offset;
15538 unsigned long count, i;
2cf0635d 15539 unsigned char * data;
861fb55a 15540 int addr_size, sym_width;
2cf0635d 15541 Elf_Internal_Rela * rels;
861fb55a
DJ		 15542
15543 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
15544 if (pltrel == DT_RELA)
15545 {
15546 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
32ec8896 15547 return FALSE;
861fb55a
DJ		 15548 }
15549 else
15550 {
15551 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
32ec8896 15552 return FALSE;
861fb55a
DJ		 15553 }
15554
91d6fa6a 15555 ent = mips_pltgot;
861fb55a
DJ		 15556 addr_size = (is_32bit_elf ? 4 : 8);
15557 end = mips_pltgot + (2 + count) * addr_size;
15558
15559 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 15560 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 15561 1, _("Procedure Linkage Table data"));
59245841 15562 if (data == NULL)
32ec8896 15563 return FALSE;
59245841 15564
9cf03b7e 15565 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 15566 printf (_(" Reserved entries:\n"));
15567 printf (_(" %*s %*s Purpose\n"),
2b692964 15568 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 15569 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 15570 printf (_(" PLT lazy resolver\n"));
91d6fa6a 15571 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 15572 printf (_(" Module pointer\n"));
861fb55a
DJ		 15573 printf ("\n");
15574
15575 printf (_(" Entries:\n"));
cc5914eb 15576 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 15577 addr_size * 2, _("Address"),
15578 addr_size * 2, _("Initial"),
15579 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 15580 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
15581 for (i = 0; i < count; i++)
15582 {
df97ab2a 15583 unsigned long idx = get_reloc_symindex (rels[i].r_info);
861fb55a 15584
91d6fa6a 15585 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a 15586 printf (" ");
e0a31db1 15587
df97ab2a
MF		 15588 if (idx >= num_dynamic_syms)
15589 printf (_("<corrupt symbol index: %lu>"), idx);
861fb55a 15590 else
e0a31db1 15591 {
df97ab2a 15592 Elf_Internal_Sym * psym = dynamic_symbols + idx;
e0a31db1
NC		 15593
15594 print_vma (psym->st_value, LONG_HEX);
15595 printf (" %-7s %3s ",
15596 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
15597 get_symbol_index_type (psym->st_shndx));
15598 if (VALID_DYNAMIC_NAME (psym->st_name))
15599 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
15600 else
15601 printf (_("<corrupt: %14ld>"), psym->st_name);
15602 }
861fb55a
DJ		 15603 printf ("\n");
15604 }
15605 printf ("\n");
15606
15607 if (data)
15608 free (data);
15609 free (rels);
15610 }
15611
32ec8896 15612 return res;
252b5132
RH		 15613}
15614
32ec8896 15615static bfd_boolean
35c08157
KLC		 15616process_nds32_specific (FILE * file)
15617{
15618 Elf_Internal_Shdr *sect = NULL;
15619
15620 sect = find_section (".nds32_e_flags");
15621 if (sect != NULL)
15622 {
15623 unsigned int *flag;
15624
15625 printf ("\nNDS32 elf flags section:\n");
15626 flag = get_data (NULL, file, sect->sh_offset, 1,
15627 sect->sh_size, _("NDS32 elf flags section"));
15628
32ec8896
NC		 15629 if (! flag)
15630 return FALSE;
15631
35c08157
KLC		 15632 switch ((*flag) & 0x3)
15633 {
15634 case 0:
15635 printf ("(VEC_SIZE):\tNo entry.\n");
15636 break;
15637 case 1:
15638 printf ("(VEC_SIZE):\t4 bytes\n");
15639 break;
15640 case 2:
15641 printf ("(VEC_SIZE):\t16 bytes\n");
15642 break;
15643 case 3:
15644 printf ("(VEC_SIZE):\treserved\n");
15645 break;
15646 }
15647 }
15648
15649 return TRUE;
15650}
15651
32ec8896 15652static bfd_boolean
2cf0635d 15653process_gnu_liblist (FILE * file)
047b2264 15654{
2cf0635d
NC		 15655 Elf_Internal_Shdr * section;
15656 Elf_Internal_Shdr * string_sec;
15657 Elf32_External_Lib * elib;
15658 char * strtab;
c256ffe7 15659 size_t strtab_size;
047b2264
JJ		 15660 size_t cnt;
15661 unsigned i;
32ec8896 15662 bfd_boolean res = TRUE;
047b2264
JJ		 15663
15664 if (! do_arch)
32ec8896 15665 return TRUE;
047b2264
JJ		 15666
15667 for (i = 0, section = section_headers;
15668 i < elf_header.e_shnum;
b34976b6 15669 i++, section++)
047b2264
JJ		 15670 {
15671 switch (section->sh_type)
15672 {
15673 case SHT_GNU_LIBLIST:
4fbb74a6 15674 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 15675 break;
15676
3f5e193b
NC		 15677 elib = (Elf32_External_Lib *)
15678 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 15679 _("liblist section data"));
047b2264
JJ		 15680
15681 if (elib == NULL)
32ec8896
NC		 15682 {
15683 res = FALSE;
15684 break;
15685 }
047b2264 15686
32ec8896 15687 string_sec = section_headers + section->sh_link;
3f5e193b
NC		 15688 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
15689 string_sec->sh_size,
15690 _("liblist string table"));
047b2264
JJ		 15691 if (strtab == NULL
15692 || section->sh_entsize != sizeof (Elf32_External_Lib))
15693 {
15694 free (elib);
2842702f 15695 free (strtab);
32ec8896 15696 res = FALSE;
047b2264
JJ		 15697 break;
15698 }
59245841 15699 strtab_size = string_sec->sh_size;
047b2264
JJ		 15700
15701 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
74e1a04b 15702 printable_section_name (section),
0af1713e 15703 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 15704
2b692964 15705 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 15706
15707 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
15708 ++cnt)
15709 {
15710 Elf32_Lib liblist;
91d6fa6a 15711 time_t atime;
d5b07ef4 15712 char timebuf[128];
2cf0635d 15713 struct tm * tmp;
047b2264
JJ		 15714
15715 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 15716 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 15717 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15718 liblist.l_version = BYTE_GET (elib[cnt].l_version);
15719 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15720
91d6fa6a 15721 tmp = gmtime (&atime);
e9e44622
JJ		 15722 snprintf (timebuf, sizeof (timebuf),
15723 "%04u-%02u-%02uT%02u:%02u:%02u",
15724 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15725 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 15726
15727 printf ("%3lu: ", (unsigned long) cnt);
15728 if (do_wide)
c256ffe7 15729 printf ("%-20s", liblist.l_name < strtab_size
2b692964 15730 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 15731 else
c256ffe7 15732 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 15733 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 15734 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
15735 liblist.l_version, liblist.l_flags);
15736 }
15737
15738 free (elib);
2842702f 15739 free (strtab);
047b2264
JJ		 15740 }
15741 }
15742
32ec8896 15743 return res;
047b2264
JJ		 15744}
15745
9437c45b 15746static const char *
d3ba0551 15747get_note_type (unsigned e_type)
779fe533
NC		 15748{
15749 static char buff[64];
103f02d3 15750
1ec5cd37
NC		 15751 if (elf_header.e_type == ET_CORE)
15752 switch (e_type)
15753 {
57346661 15754 case NT_AUXV:
1ec5cd37 15755 return _("NT_AUXV (auxiliary vector)");
57346661 15756 case NT_PRSTATUS:
1ec5cd37 15757 return _("NT_PRSTATUS (prstatus structure)");
57346661 15758 case NT_FPREGSET:
1ec5cd37 15759 return _("NT_FPREGSET (floating point registers)");
57346661 15760 case NT_PRPSINFO:
1ec5cd37 15761 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 15762 case NT_TASKSTRUCT:
1ec5cd37 15763 return _("NT_TASKSTRUCT (task structure)");
57346661 15764 case NT_PRXFPREG:
1ec5cd37 15765 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 15766 case NT_PPC_VMX:
15767 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 15768 case NT_PPC_VSX:
15769 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 15770 case NT_386_TLS:
15771 return _("NT_386_TLS (x86 TLS information)");
15772 case NT_386_IOPERM:
15773 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 15774 case NT_X86_XSTATE:
15775 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 15776 case NT_S390_HIGH_GPRS:
15777 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 15778 case NT_S390_TIMER:
15779 return _("NT_S390_TIMER (s390 timer register)");
15780 case NT_S390_TODCMP:
15781 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15782 case NT_S390_TODPREG:
15783 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15784 case NT_S390_CTRS:
15785 return _("NT_S390_CTRS (s390 control registers)");
15786 case NT_S390_PREFIX:
15787 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 15788 case NT_S390_LAST_BREAK:
15789 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15790 case NT_S390_SYSTEM_CALL:
15791 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC		 15792 case NT_S390_TDB:
15793 return _("NT_S390_TDB (s390 transaction diagnostic block)");
4ef9f41a
AA		 15794 case NT_S390_VXRS_LOW:
15795 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15796 case NT_S390_VXRS_HIGH:
15797 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
faa9a424
UW		 15798 case NT_ARM_VFP:
15799 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 15800 case NT_ARM_TLS:
15801 return _("NT_ARM_TLS (AArch TLS registers)");
15802 case NT_ARM_HW_BREAK:
15803 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15804 case NT_ARM_HW_WATCH:
15805 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 15806 case NT_PSTATUS:
1ec5cd37 15807 return _("NT_PSTATUS (pstatus structure)");
57346661 15808 case NT_FPREGS:
1ec5cd37 15809 return _("NT_FPREGS (floating point registers)");
57346661 15810 case NT_PSINFO:
1ec5cd37 15811 return _("NT_PSINFO (psinfo structure)");
57346661 15812 case NT_LWPSTATUS:
1ec5cd37 15813 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 15814 case NT_LWPSINFO:
1ec5cd37 15815 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 15816 case NT_WIN32PSTATUS:
1ec5cd37 15817 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 15818 case NT_SIGINFO:
15819 return _("NT_SIGINFO (siginfo_t data)");
15820 case NT_FILE:
15821 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 15822 default:
15823 break;
15824 }
15825 else
15826 switch (e_type)
15827 {
15828 case NT_VERSION:
15829 return _("NT_VERSION (version)");
15830 case NT_ARCH:
15831 return _("NT_ARCH (architecture)");
9ef920e9
NC		 15832 case NT_GNU_BUILD_ATTRIBUTE_OPEN:
15833 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
15834 case NT_GNU_BUILD_ATTRIBUTE_FUNC:
15835 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
1ec5cd37
NC		 15836 default:
15837 break;
15838 }
15839
e9e44622 15840 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 15841 return buff;
779fe533
NC		 15842}
15843
32ec8896 15844static bfd_boolean
9ece1fa9
TT		 15845print_core_note (Elf_Internal_Note *pnote)
15846{
15847 unsigned int addr_size = is_32bit_elf ? 4 : 8;
15848 bfd_vma count, page_size;
15849 unsigned char *descdata, *filenames, *descend;
15850
15851 if (pnote->type != NT_FILE)
32ec8896 15852 return TRUE;
9ece1fa9
TT		 15853
15854#ifndef BFD64
15855 if (!is_32bit_elf)
15856 {
15857 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15858 /* Still "successful". */
32ec8896 15859 return TRUE;
9ece1fa9
TT		 15860 }
15861#endif
15862
15863 if (pnote->descsz < 2 * addr_size)
15864 {
32ec8896
NC		 15865 error (_(" Malformed note - too short for header\n"));
15866 return FALSE;
9ece1fa9
TT		 15867 }
15868
15869 descdata = (unsigned char *) pnote->descdata;
15870 descend = descdata + pnote->descsz;
15871
15872 if (descdata[pnote->descsz - 1] != '\0')
15873 {
32ec8896
NC		 15874 error (_(" Malformed note - does not end with \\0\n"));
15875 return FALSE;
9ece1fa9
TT		 15876 }
15877
15878 count = byte_get (descdata, addr_size);
15879 descdata += addr_size;
15880
15881 page_size = byte_get (descdata, addr_size);
15882 descdata += addr_size;
15883
15884 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
15885 {
32ec8896
NC		 15886 error (_(" Malformed note - too short for supplied file count\n"));
15887 return FALSE;
9ece1fa9
TT		 15888 }
15889
15890 printf (_(" Page size: "));
15891 print_vma (page_size, DEC);
15892 printf ("\n");
15893
15894 printf (_(" %*s%*s%*s\n"),
15895 (int) (2 + 2 * addr_size), _("Start"),
15896 (int) (4 + 2 * addr_size), _("End"),
15897 (int) (4 + 2 * addr_size), _("Page Offset"));
15898 filenames = descdata + count * 3 * addr_size;
595712bb 15899 while (count-- > 0)
9ece1fa9
TT		 15900 {
15901 bfd_vma start, end, file_ofs;
15902
15903 if (filenames == descend)
15904 {
32ec8896
NC		 15905 error (_(" Malformed note - filenames end too early\n"));
15906 return FALSE;
9ece1fa9
TT		 15907 }
15908
15909 start = byte_get (descdata, addr_size);
15910 descdata += addr_size;
15911 end = byte_get (descdata, addr_size);
15912 descdata += addr_size;
15913 file_ofs = byte_get (descdata, addr_size);
15914 descdata += addr_size;
15915
15916 printf (" ");
15917 print_vma (start, FULL_HEX);
15918 printf (" ");
15919 print_vma (end, FULL_HEX);
15920 printf (" ");
15921 print_vma (file_ofs, FULL_HEX);
15922 printf ("\n %s\n", filenames);
15923
15924 filenames += 1 + strlen ((char *) filenames);
15925 }
15926
32ec8896 15927 return TRUE;
9ece1fa9
TT		 15928}
15929
1118d252
RM		 15930static const char *
15931get_gnu_elf_note_type (unsigned e_type)
15932{
1449284b 15933 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
1118d252
RM		 15934 switch (e_type)
15935 {
15936 case NT_GNU_ABI_TAG:
15937 return _("NT_GNU_ABI_TAG (ABI version tag)");
15938 case NT_GNU_HWCAP:
15939 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15940 case NT_GNU_BUILD_ID:
15941 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 15942 case NT_GNU_GOLD_VERSION:
15943 return _("NT_GNU_GOLD_VERSION (gold version)");
9ef920e9
NC		 15944 case NT_GNU_PROPERTY_TYPE_0:
15945 return _("NT_GNU_PROPERTY_TYPE_0");
15946 case NT_GNU_BUILD_ATTRIBUTE_OPEN:
15947 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
15948 case NT_GNU_BUILD_ATTRIBUTE_FUNC:
15949 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
1118d252 15950 default:
1449284b
NC		 15951 {
15952 static char buff[64];
1118d252 15953
1449284b
NC		 15954 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15955 return buff;
15956 }
15957 }
1118d252
RM		 15958}
15959
9ef920e9 15960static void
1fc87489 15961decode_x86_isa (unsigned int bitmask)
9ef920e9
NC		 15962{
15963 while (bitmask)
15964 {
1fc87489 15965 unsigned int bit = bitmask & (- bitmask);
9ef920e9
NC		 15966
15967 bitmask &= ~ bit;
15968 switch (bit)
15969 {
15970 case GNU_PROPERTY_X86_ISA_1_486: printf ("i486"); break;
15971 case GNU_PROPERTY_X86_ISA_1_586: printf ("586"); break;
15972 case GNU_PROPERTY_X86_ISA_1_686: printf ("686"); break;
15973 case GNU_PROPERTY_X86_ISA_1_SSE: printf ("SSE"); break;
15974 case GNU_PROPERTY_X86_ISA_1_SSE2: printf ("SSE2"); break;
15975 case GNU_PROPERTY_X86_ISA_1_SSE3: printf ("SSE3"); break;
15976 case GNU_PROPERTY_X86_ISA_1_SSSE3: printf ("SSSE3"); break;
15977 case GNU_PROPERTY_X86_ISA_1_SSE4_1: printf ("SSE4_1"); break;
15978 case GNU_PROPERTY_X86_ISA_1_SSE4_2: printf ("SSE4_2"); break;
15979 case GNU_PROPERTY_X86_ISA_1_AVX: printf ("AVX"); break;
15980 case GNU_PROPERTY_X86_ISA_1_AVX2: printf ("AVX2"); break;
15981 case GNU_PROPERTY_X86_ISA_1_AVX512F: printf ("AVX512F"); break;
15982 case GNU_PROPERTY_X86_ISA_1_AVX512CD: printf ("AVX512CD"); break;
15983 case GNU_PROPERTY_X86_ISA_1_AVX512ER: printf ("AVX512ER"); break;
15984 case GNU_PROPERTY_X86_ISA_1_AVX512PF: printf ("AVX512PF"); break;
15985 case GNU_PROPERTY_X86_ISA_1_AVX512VL: printf ("AVX512VL"); break;
15986 case GNU_PROPERTY_X86_ISA_1_AVX512DQ: printf ("AVX512DQ"); break;
15987 case GNU_PROPERTY_X86_ISA_1_AVX512BW: printf ("AVX512BW"); break;
1fc87489 15988 default: printf (_("<unknown: %x>"), bit); break;
9ef920e9
NC		 15989 }
15990 if (bitmask)
15991 printf (", ");
15992 }
15993}
15994
15995static void
15996print_gnu_property_note (Elf_Internal_Note * pnote)
15997{
15998 unsigned char * ptr = (unsigned char *) pnote->descdata;
15999 unsigned char * ptr_end = ptr + pnote->descsz;
16000 unsigned int size = is_32bit_elf ? 4 : 8;
16001
16002 printf (_(" Properties: "));
16003
1fc87489 16004 if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
9ef920e9
NC		 16005 {
16006 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
16007 return;
16008 }
16009
1fc87489 16010 while (1)
9ef920e9 16011 {
1fc87489
L		 16012 unsigned int j;
16013 unsigned int type = byte_get (ptr, 4);
16014 unsigned int datasz = byte_get (ptr + 4, 4);
9ef920e9 16015
1fc87489 16016 ptr += 8;
9ef920e9 16017
1fc87489 16018 if ((ptr + datasz) > ptr_end)
9ef920e9 16019 {
1fc87489
L		 16020 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16021 type, datasz);
9ef920e9 16022 break;
1fc87489 16023 }
9ef920e9 16024
1fc87489
L		 16025 if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
16026 {
16027 if (elf_header.e_machine == EM_X86_64
16028 || elf_header.e_machine == EM_IAMCU
16029 || elf_header.e_machine == EM_386)
16030 {
16031 switch (type)
16032 {
16033 case GNU_PROPERTY_X86_ISA_1_USED:
16034 printf ("x86 ISA used: ");
16035 if (datasz != 4)
16036 printf (_("<corrupt length: %#x> "), datasz);
16037 else
16038 decode_x86_isa (byte_get (ptr, 4));
16039 goto next;
9ef920e9 16040
1fc87489
L		 16041 case GNU_PROPERTY_X86_ISA_1_NEEDED:
16042 printf ("x86 ISA needed: ");
16043 if (datasz != 4)
16044 printf (_("<corrupt length: %#x> "), datasz);
16045 else
16046 decode_x86_isa (byte_get (ptr, 4));
16047 goto next;
9ef920e9 16048
1fc87489
L		 16049 default:
16050 break;
16051 }
16052 }
16053 }
16054 else
16055 {
16056 switch (type)
9ef920e9 16057 {
1fc87489
L		 16058 case GNU_PROPERTY_STACK_SIZE:
16059 printf (_("stack size: "));
16060 if (datasz != size)
16061 printf (_("<corrupt length: %#x> "), datasz);
16062 else
16063 printf ("%#lx", (unsigned long) byte_get (ptr, size));
16064 goto next;
16065
16066 case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
16067 printf ("no copy on protected ");
16068 if (datasz)
16069 printf (_("<corrupt length: %#x> "), datasz);
16070 goto next;
16071
16072 default:
9ef920e9
NC		 16073 break;
16074 }
9ef920e9
NC		 16075 }
16076
1fc87489
L		 16077 if (type < GNU_PROPERTY_LOPROC)
16078 printf (_("<unknown type %#x data: "), type);
16079 else if (type < GNU_PROPERTY_LOUSER)
16080 printf (_("<procesor-specific type %#x data: "), type);
16081 else
16082 printf (_("<application-specific type %#x data: "), type);
16083 for (j = 0; j < datasz; ++j)
16084 printf ("%02x ", ptr[j] & 0xff);
16085 printf (">");
16086
16087next:
9ef920e9 16088 ptr += ((datasz + (size - 1)) & ~ (size - 1));
1fc87489
L		 16089 if (ptr == ptr_end)
16090 break;
16091 else
9ef920e9
NC		 16092 {
16093 if (do_wide)
16094 printf (", ");
16095 else
16096 printf ("\n\t");
16097 }
1fc87489
L		 16098
16099 if (ptr > (ptr_end - 8))
16100 {
16101 printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
16102 break;
16103 }
9ef920e9
NC		 16104 }
16105
16106 printf ("\n");
16107}
16108
32ec8896 16109static bfd_boolean
664f90a3
TT		 16110print_gnu_note (Elf_Internal_Note *pnote)
16111{
1449284b 16112 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
664f90a3
TT		 16113 switch (pnote->type)
16114 {
16115 case NT_GNU_BUILD_ID:
16116 {
16117 unsigned long i;
16118
16119 printf (_(" Build ID: "));
16120 for (i = 0; i < pnote->descsz; ++i)
16121 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 16122 printf ("\n");
664f90a3
TT		 16123 }
16124 break;
16125
16126 case NT_GNU_ABI_TAG:
16127 {
16128 unsigned long os, major, minor, subminor;
16129 const char *osname;
16130
3102e897
NC		 16131 /* PR 17531: file: 030-599401-0.004. */
16132 if (pnote->descsz < 16)
16133 {
16134 printf (_(" <corrupt GNU_ABI_TAG>\n"));
16135 break;
16136 }
16137
664f90a3
TT		 16138 os = byte_get ((unsigned char *) pnote->descdata, 4);
16139 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
16140 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
16141 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
16142
16143 switch (os)
16144 {
16145 case GNU_ABI_TAG_LINUX:
16146 osname = "Linux";
16147 break;
16148 case GNU_ABI_TAG_HURD:
16149 osname = "Hurd";
16150 break;
16151 case GNU_ABI_TAG_SOLARIS:
16152 osname = "Solaris";
16153 break;
16154 case GNU_ABI_TAG_FREEBSD:
16155 osname = "FreeBSD";
16156 break;
16157 case GNU_ABI_TAG_NETBSD:
16158 osname = "NetBSD";
16159 break;
14ae95f2
RM		 16160 case GNU_ABI_TAG_SYLLABLE:
16161 osname = "Syllable";
16162 break;
16163 case GNU_ABI_TAG_NACL:
16164 osname = "NaCl";
16165 break;
664f90a3
TT		 16166 default:
16167 osname = "Unknown";
16168 break;
16169 }
16170
16171 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
16172 major, minor, subminor);
16173 }
16174 break;
926c5385
CC		 16175
16176 case NT_GNU_GOLD_VERSION:
16177 {
16178 unsigned long i;
16179
16180 printf (_(" Version: "));
16181 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
16182 printf ("%c", pnote->descdata[i]);
16183 printf ("\n");
16184 }
16185 break;
1449284b
NC		 16186
16187 case NT_GNU_HWCAP:
16188 {
16189 unsigned long num_entries, mask;
16190
16191 /* Hardware capabilities information. Word 0 is the number of entries.
16192 Word 1 is a bitmask of enabled entries. The rest of the descriptor
16193 is a series of entries, where each entry is a single byte followed
16194 by a nul terminated string. The byte gives the bit number to test
16195 if enabled in the bitmask. */
16196 printf (_(" Hardware Capabilities: "));
16197 if (pnote->descsz < 8)
16198 {
32ec8896
NC		 16199 error (_("<corrupt GNU_HWCAP>\n"));
16200 return FALSE;
1449284b
NC		 16201 }
16202 num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
16203 mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
16204 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
16205 /* FIXME: Add code to display the entries... */
16206 }
16207 break;
16208
9ef920e9
NC		 16209 case NT_GNU_PROPERTY_TYPE_0:
16210 print_gnu_property_note (pnote);
16211 break;
16212
1449284b
NC		 16213 default:
16214 /* Handle unrecognised types. An error message should have already been
16215 created by get_gnu_elf_note_type(), so all that we need to do is to
16216 display the data. */
16217 {
16218 unsigned long i;
16219
16220 printf (_(" Description data: "));
16221 for (i = 0; i < pnote->descsz; ++i)
16222 printf ("%02x ", pnote->descdata[i] & 0xff);
16223 printf ("\n");
16224 }
16225 break;
664f90a3
TT		 16226 }
16227
32ec8896 16228 return TRUE;
664f90a3
TT		 16229}
16230
685080f2
NC		 16231static const char *
16232get_v850_elf_note_type (enum v850_notes n_type)
16233{
16234 static char buff[64];
16235
16236 switch (n_type)
16237 {
16238 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
16239 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
16240 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
16241 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
16242 case V850_NOTE_CACHE_INFO: return _("Use of cache");
16243 case V850_NOTE_MMU_INFO: return _("Use of MMU");
16244 default:
16245 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
16246 return buff;
16247 }
16248}
16249
32ec8896 16250static bfd_boolean
685080f2
NC		 16251print_v850_note (Elf_Internal_Note * pnote)
16252{
16253 unsigned int val;
16254
16255 if (pnote->descsz != 4)
32ec8896
NC		 16256 return FALSE;
16257
685080f2
NC		 16258 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
16259
16260 if (val == 0)
16261 {
16262 printf (_("not set\n"));
32ec8896 16263 return TRUE;
685080f2
NC		 16264 }
16265
16266 switch (pnote->type)
16267 {
16268 case V850_NOTE_ALIGNMENT:
16269 switch (val)
16270 {
32ec8896
NC		 16271 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
16272 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
685080f2
NC		 16273 }
16274 break;
14ae95f2 16275
685080f2
NC		 16276 case V850_NOTE_DATA_SIZE:
16277 switch (val)
16278 {
32ec8896
NC		 16279 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
16280 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
685080f2
NC		 16281 }
16282 break;
14ae95f2 16283
685080f2
NC		 16284 case V850_NOTE_FPU_INFO:
16285 switch (val)
16286 {
32ec8896
NC		 16287 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
16288 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
685080f2
NC		 16289 }
16290 break;
14ae95f2 16291
685080f2
NC		 16292 case V850_NOTE_MMU_INFO:
16293 case V850_NOTE_CACHE_INFO:
16294 case V850_NOTE_SIMD_INFO:
16295 if (val == EF_RH850_SIMD)
16296 {
16297 printf (_("yes\n"));
32ec8896 16298 return TRUE;
685080f2
NC		 16299 }
16300 break;
16301
16302 default:
16303 /* An 'unknown note type' message will already have been displayed. */
16304 break;
16305 }
16306
16307 printf (_("unknown value: %x\n"), val);
32ec8896 16308 return FALSE;
685080f2
NC		 16309}
16310
32ec8896 16311static bfd_boolean
c6056a74
SF		 16312process_netbsd_elf_note (Elf_Internal_Note * pnote)
16313{
16314 unsigned int version;
16315
16316 switch (pnote->type)
16317 {
16318 case NT_NETBSD_IDENT:
16319 version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
16320 if ((version / 10000) % 100)
16321 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
16322 version, version / 100000000, (version / 1000000) % 100,
16323 (version / 10000) % 100 > 26 ? "Z" : "",
15f205b1 16324 'A' + (version / 10000) % 26);
c6056a74
SF		 16325 else
16326 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
16327 version, version / 100000000, (version / 1000000) % 100,
15f205b1 16328 (version / 100) % 100);
32ec8896 16329 return TRUE;
c6056a74
SF		 16330
16331 case NT_NETBSD_MARCH:
16332 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
16333 pnote->descdata);
32ec8896 16334 return TRUE;
c6056a74
SF		 16335
16336 default:
32ec8896
NC		 16337 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
16338 pnote->type);
16339 return FALSE;
c6056a74 16340 }
c6056a74
SF		 16341}
16342
f4ddf30f
JB		 16343static const char *
16344get_freebsd_elfcore_note_type (unsigned e_type)
16345{
f4ddf30f
JB		 16346 switch (e_type)
16347 {
16348 case NT_FREEBSD_THRMISC:
16349 return _("NT_THRMISC (thrmisc structure)");
16350 case NT_FREEBSD_PROCSTAT_PROC:
16351 return _("NT_PROCSTAT_PROC (proc data)");
16352 case NT_FREEBSD_PROCSTAT_FILES:
16353 return _("NT_PROCSTAT_FILES (files data)");
16354 case NT_FREEBSD_PROCSTAT_VMMAP:
16355 return _("NT_PROCSTAT_VMMAP (vmmap data)");
16356 case NT_FREEBSD_PROCSTAT_GROUPS:
16357 return _("NT_PROCSTAT_GROUPS (groups data)");
16358 case NT_FREEBSD_PROCSTAT_UMASK:
16359 return _("NT_PROCSTAT_UMASK (umask data)");
16360 case NT_FREEBSD_PROCSTAT_RLIMIT:
16361 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
16362 case NT_FREEBSD_PROCSTAT_OSREL:
16363 return _("NT_PROCSTAT_OSREL (osreldate data)");
16364 case NT_FREEBSD_PROCSTAT_PSSTRINGS:
16365 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
16366 case NT_FREEBSD_PROCSTAT_AUXV:
16367 return _("NT_PROCSTAT_AUXV (auxv data)");
16368 }
16369 return get_note_type (e_type);
16370}
16371
9437c45b 16372static const char *
d3ba0551 16373get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 16374{
16375 static char buff[64];
16376
b4db1224 16377 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 16378 {
16379 /* NetBSD core "procinfo" structure. */
16380 return _("NetBSD procinfo structure");
16381 }
16382
16383 /* As of Jan 2002 there are no other machine-independent notes
16384 defined for NetBSD core files. If the note type is less
16385 than the start of the machine-dependent note types, we don't
16386 understand it. */
16387
b4db1224 16388 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 16389 {
e9e44622 16390 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 16391 return buff;
16392 }
16393
16394 switch (elf_header.e_machine)
16395 {
16396 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
16397 and PT_GETFPREGS == mach+2. */
16398
16399 case EM_OLD_ALPHA:
16400 case EM_ALPHA:
16401 case EM_SPARC:
16402 case EM_SPARC32PLUS:
16403 case EM_SPARCV9:
16404 switch (e_type)
16405 {
2b692964 16406 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 16407 return _("PT_GETREGS (reg structure)");
2b692964 16408 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 16409 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 16410 default:
16411 break;
16412 }
16413 break;
16414
16415 /* On all other arch's, PT_GETREGS == mach+1 and
16416 PT_GETFPREGS == mach+3. */
16417 default:
16418 switch (e_type)
16419 {
2b692964 16420 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 16421 return _("PT_GETREGS (reg structure)");
2b692964 16422 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 16423 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 16424 default:
16425 break;
16426 }
16427 }
16428
9cf03b7e 16429 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 16430 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 16431 return buff;
16432}
16433
70616151
TT		 16434static const char *
16435get_stapsdt_note_type (unsigned e_type)
16436{
16437 static char buff[64];
16438
16439 switch (e_type)
16440 {
16441 case NT_STAPSDT:
16442 return _("NT_STAPSDT (SystemTap probe descriptors)");
16443
16444 default:
16445 break;
16446 }
16447
16448 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16449 return buff;
16450}
16451
32ec8896 16452static bfd_boolean
c6a9fc58
TT		 16453print_stapsdt_note (Elf_Internal_Note *pnote)
16454{
16455 int addr_size = is_32bit_elf ? 4 : 8;
16456 char *data = pnote->descdata;
16457 char *data_end = pnote->descdata + pnote->descsz;
16458 bfd_vma pc, base_addr, semaphore;
16459 char *provider, *probe, *arg_fmt;
16460
16461 pc = byte_get ((unsigned char *) data, addr_size);
16462 data += addr_size;
16463 base_addr = byte_get ((unsigned char *) data, addr_size);
16464 data += addr_size;
16465 semaphore = byte_get ((unsigned char *) data, addr_size);
16466 data += addr_size;
16467
16468 provider = data;
16469 data += strlen (data) + 1;
16470 probe = data;
16471 data += strlen (data) + 1;
16472 arg_fmt = data;
16473 data += strlen (data) + 1;
16474
16475 printf (_(" Provider: %s\n"), provider);
16476 printf (_(" Name: %s\n"), probe);
16477 printf (_(" Location: "));
16478 print_vma (pc, FULL_HEX);
16479 printf (_(", Base: "));
16480 print_vma (base_addr, FULL_HEX);
16481 printf (_(", Semaphore: "));
16482 print_vma (semaphore, FULL_HEX);
9cf03b7e 16483 printf ("\n");
c6a9fc58
TT		 16484 printf (_(" Arguments: %s\n"), arg_fmt);
16485
16486 return data == data_end;
16487}
16488
00e98fc7
TG		 16489static const char *
16490get_ia64_vms_note_type (unsigned e_type)
16491{
16492 static char buff[64];
16493
16494 switch (e_type)
16495 {
16496 case NT_VMS_MHD:
16497 return _("NT_VMS_MHD (module header)");
16498 case NT_VMS_LNM:
16499 return _("NT_VMS_LNM (language name)");
16500 case NT_VMS_SRC:
16501 return _("NT_VMS_SRC (source files)");
16502 case NT_VMS_TITLE:
9cf03b7e 16503 return "NT_VMS_TITLE";
00e98fc7
TG		 16504 case NT_VMS_EIDC:
16505 return _("NT_VMS_EIDC (consistency check)");
16506 case NT_VMS_FPMODE:
16507 return _("NT_VMS_FPMODE (FP mode)");
16508 case NT_VMS_LINKTIME:
9cf03b7e 16509 return "NT_VMS_LINKTIME";
00e98fc7
TG		 16510 case NT_VMS_IMGNAM:
16511 return _("NT_VMS_IMGNAM (image name)");
16512 case NT_VMS_IMGID:
16513 return _("NT_VMS_IMGID (image id)");
16514 case NT_VMS_LINKID:
16515 return _("NT_VMS_LINKID (link id)");
16516 case NT_VMS_IMGBID:
16517 return _("NT_VMS_IMGBID (build id)");
16518 case NT_VMS_GSTNAM:
16519 return _("NT_VMS_GSTNAM (sym table name)");
16520 case NT_VMS_ORIG_DYN:
9cf03b7e 16521 return "NT_VMS_ORIG_DYN";
00e98fc7 16522 case NT_VMS_PATCHTIME:
9cf03b7e 16523 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 16524 default:
16525 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16526 return buff;
16527 }
16528}
16529
32ec8896 16530static bfd_boolean
00e98fc7
TG		 16531print_ia64_vms_note (Elf_Internal_Note * pnote)
16532{
16533 switch (pnote->type)
16534 {
16535 case NT_VMS_MHD:
16536 if (pnote->descsz > 36)
16537 {
16538 size_t l = strlen (pnote->descdata + 34);
16539 printf (_(" Creation date : %.17s\n"), pnote->descdata);
16540 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
16541 printf (_(" Module name : %s\n"), pnote->descdata + 34);
16542 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
16543 }
16544 else
16545 printf (_(" Invalid size\n"));
16546 break;
16547 case NT_VMS_LNM:
16548 printf (_(" Language: %s\n"), pnote->descdata);
16549 break;
16550#ifdef BFD64
16551 case NT_VMS_FPMODE:
9cf03b7e 16552 printf (_(" Floating Point mode: "));
4a5cb34f 16553 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 16554 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
00e98fc7
TG		 16555 break;
16556 case NT_VMS_LINKTIME:
16557 printf (_(" Link time: "));
16558 print_vms_time
16559 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
16560 printf ("\n");
16561 break;
16562 case NT_VMS_PATCHTIME:
16563 printf (_(" Patch time: "));
16564 print_vms_time
16565 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
16566 printf ("\n");
16567 break;
16568 case NT_VMS_ORIG_DYN:
16569 printf (_(" Major id: %u, minor id: %u\n"),
16570 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
16571 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 16572 printf (_(" Last modified : "));
00e98fc7
TG		 16573 print_vms_time
16574 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 16575 printf (_("\n Link flags : "));
4a5cb34f 16576 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 16577 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
00e98fc7 16578 printf (_(" Header flags: 0x%08x\n"),
948f632f 16579 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
00e98fc7
TG		 16580 printf (_(" Image id : %s\n"), pnote->descdata + 32);
16581 break;
16582#endif
16583 case NT_VMS_IMGNAM:
16584 printf (_(" Image name: %s\n"), pnote->descdata);
16585 break;
16586 case NT_VMS_GSTNAM:
16587 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
16588 break;
16589 case NT_VMS_IMGID:
16590 printf (_(" Image id: %s\n"), pnote->descdata);
16591 break;
16592 case NT_VMS_LINKID:
16593 printf (_(" Linker id: %s\n"), pnote->descdata);
16594 break;
16595 default:
32ec8896 16596 return FALSE;
00e98fc7 16597 }
32ec8896 16598 return TRUE;
00e98fc7
TG		 16599}
16600
c799a79d
NC		 16601/* Print the name of the symbol associated with a build attribute
16602 that is attached to address OFFSET. */
16603
9ef920e9 16604static bfd_boolean
c799a79d
NC		 16605print_symbol_for_build_attribute (FILE * file,
16606 unsigned long offset,
16607 bfd_boolean is_open_attr)
9ef920e9 16608{
c799a79d
NC		 16609 static FILE * saved_file = NULL;
16610 static char * strtab;
16611 static unsigned long strtablen;
16612 static Elf_Internal_Sym * symtab;
16613 static unsigned long nsyms;
16614 Elf_Internal_Sym * saved_sym = NULL;
16615 Elf_Internal_Sym * sym;
9ef920e9 16616
c799a79d 16617 if (saved_file == NULL || file != saved_file)
9ef920e9 16618 {
c799a79d 16619 Elf_Internal_Shdr * symsec;
9ef920e9 16620
c799a79d
NC		 16621 /* Load the symbol and string sections. */
16622 for (symsec = section_headers;
16623 symsec < section_headers + elf_header.e_shnum;
16624 symsec ++)
9ef920e9 16625 {
c799a79d 16626 if (symsec->sh_type == SHT_SYMTAB)
9ef920e9 16627 {
c799a79d 16628 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
9ef920e9 16629
c799a79d
NC		 16630 if (symsec->sh_link < elf_header.e_shnum)
16631 {
16632 Elf_Internal_Shdr * strtab_sec = section_headers + symsec->sh_link;
16633
16634 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
16635 1, strtab_sec->sh_size,
16636 _("string table"));
16637 strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
16638 }
9ef920e9
NC		 16639 }
16640 }
c799a79d 16641 saved_file = file;
9ef920e9
NC		 16642 }
16643
c799a79d 16644 if (symtab == NULL || strtab == NULL)
9ef920e9 16645 {
c799a79d
NC		 16646 printf ("\n");
16647 return FALSE;
16648 }
9ef920e9 16649
c799a79d
NC		 16650 /* Find a symbol whose value matches offset. */
16651 for (sym = symtab; sym < symtab + nsyms; sym ++)
16652 if (sym->st_value == offset)
16653 {
16654 if (sym->st_name >= strtablen)
16655 /* Huh ? This should not happen. */
16656 continue;
9ef920e9 16657
c799a79d
NC		 16658 if (strtab[sym->st_name] == 0)
16659 continue;
9ef920e9 16660
c799a79d
NC		 16661 if (is_open_attr)
16662 {
16663 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
16664 and FILE or OBJECT symbols over NOTYPE symbols. We skip
16665 FUNC symbols entirely. */
16666 switch (ELF_ST_TYPE (sym->st_info))
16667 {
16668 case STT_FILE:
16669 saved_sym = sym;
16670 /* We can stop searching now. */
16671 sym = symtab + nsyms;
16672 continue;
9ef920e9 16673
c799a79d
NC		 16674 case STT_OBJECT:
16675 saved_sym = sym;
16676 continue;
9ef920e9 16677
c799a79d
NC		 16678 case STT_FUNC:
16679 /* Ignore function symbols. */
16680 continue;
16681
16682 default:
16683 break;
16684 }
16685
16686 switch (ELF_ST_BIND (sym->st_info))
9ef920e9 16687 {
c799a79d
NC		 16688 case STB_GLOBAL:
16689 if (saved_sym == NULL
16690 || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
16691 saved_sym = sym;
16692 break;
c871dade 16693
c799a79d
NC		 16694 case STB_LOCAL:
16695 if (saved_sym == NULL)
16696 saved_sym = sym;
16697 break;
16698
16699 default:
9ef920e9
NC		 16700 break;
16701 }
16702 }
c799a79d
NC		 16703 else
16704 {
16705 if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
16706 continue;
16707
16708 saved_sym = sym;
16709 break;
16710 }
16711 }
16712
16713 printf (" (%s: %s)\n",
16714 is_open_attr ? _("file") : _("func"),
16715 saved_sym ? strtab + saved_sym->st_name : _("<no symbol found>)"));
16716 return TRUE;
16717}
16718
16719static bfd_boolean
16720print_gnu_build_attribute_description (Elf_Internal_Note * pnote,
16721 FILE * file)
16722{
16723 static unsigned long global_offset = 0;
16724 unsigned long offset;
16725 unsigned int desc_size = is_32bit_elf ? 4 : 8;
16726 bfd_boolean is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
c871dade 16727
c799a79d
NC		 16728 if (pnote->descsz == 0)
16729 {
16730 if (is_open_attr)
c871dade 16731 {
c799a79d
NC		 16732 printf (_(" Applies from offset %#lx\n"), global_offset);
16733 return TRUE;
16734 }
16735 else
16736 {
16737 printf (_(" Applies to func at %#lx"), global_offset);
16738 return print_symbol_for_build_attribute (file, global_offset, is_open_attr);
c871dade 16739 }
9ef920e9
NC		 16740 }
16741
c799a79d
NC		 16742 if (pnote->descsz != desc_size)
16743 {
16744 error (_(" <invalid description size: %lx>\n"), pnote->descsz);
16745 printf (_(" <invalid descsz>"));
16746 return FALSE;
16747 }
16748
16749 offset = byte_get ((unsigned char *) pnote->descdata, desc_size);
16750
16751 if (is_open_attr)
16752 {
16753 printf (_(" Applies from offset %#lx"), offset);
16754 global_offset = offset;
16755 }
16756 else
16757 {
16758 printf (_(" Applies to func at %#lx"), offset);
16759 }
16760
16761 return print_symbol_for_build_attribute (file, offset, is_open_attr);
9ef920e9
NC		 16762}
16763
16764static bfd_boolean
16765print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
16766{
16767 char name_type;
16768 char name_attribute;
16769 char * expected_types;
16770 const char * name = pnote->namedata;
16771 const char * text;
16772 int left;
16773
16774 if (name == NULL || pnote->namesz < 2)
16775 {
16776 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
16777 print_symbol (-20, _(" <corrupt name field>"));
16778 return FALSE;
16779 }
16780
16781 switch ((name_type = * name))
16782 {
16783 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
16784 case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
16785 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
16786 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
16787 printf ("%c", * name);
16788 break;
16789 default:
16790 error (_("unrecognised attribute type in name field: %d\n"), name_type);
16791 print_symbol (-20, _("<unknown name type>"));
16792 return FALSE;
16793 }
16794
16795 left = 19;
16796 ++ name;
16797 text = NULL;
16798
16799 switch ((name_attribute = * name))
16800 {
16801 case GNU_BUILD_ATTRIBUTE_VERSION:
16802 text = _("<version>");
16803 expected_types = "$";
16804 ++ name;
16805 break;
16806 case GNU_BUILD_ATTRIBUTE_STACK_PROT:
16807 text = _("<stack prot>");
16808 expected_types = "!+";
16809 ++ name;
16810 break;
16811 case GNU_BUILD_ATTRIBUTE_RELRO:
16812 text = _("<relro>");
16813 expected_types = "!+";
16814 ++ name;
16815 break;
16816 case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
16817 text = _("<stack size>");
16818 expected_types = "*";
16819 ++ name;
16820 break;
16821 case GNU_BUILD_ATTRIBUTE_TOOL:
16822 text = _("<tool>");
16823 expected_types = "$";
16824 ++ name;
16825 break;
16826 case GNU_BUILD_ATTRIBUTE_ABI:
16827 text = _("<ABI>");
16828 expected_types = "$*";
16829 ++ name;
16830 break;
16831 case GNU_BUILD_ATTRIBUTE_PIC:
16832 text = _("<PIC>");
16833 expected_types = "*";
16834 ++ name;
16835 break;
a8be5506
NC		 16836 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
16837 text = _("<short enum>");
16838 expected_types = "!+";
16839 ++ name;
16840 break;
9ef920e9
NC		 16841
16842 default:
16843 if (ISPRINT (* name))
16844 {
16845 int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
16846
16847 if (len > left && ! do_wide)
16848 len = left;
16849 printf ("%.*s ", len, name);
16850 left -= len;
0dd6ae21 16851 name += len;
9ef920e9
NC		 16852 }
16853 else
16854 {
16855 error (_("unexpected character in name field\n"));
16856 print_symbol (- left, _("<unknown attribute>"));
16857 return 0;
16858 }
16859 expected_types = "*$!+";
16860 break;
16861 }
16862
16863 if (text)
16864 {
16865 printf ("%s", text);
16866 left -= strlen (text);
16867 }
16868
16869 if (strchr (expected_types, name_type) == NULL)
16870 warn (_("attribute does not have the expected type\n"));
16871
16872 if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
16873 {
16874 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
16875 (unsigned long) pnote->namesz,
16876 (long) (name - pnote->namedata));
16877 return FALSE;
16878 }
16879
16880 if (left < 1 && ! do_wide)
16881 return TRUE;
16882
16883 switch (name_type)
16884 {
16885 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
16886 {
16887 unsigned int bytes = pnote->namesz - (name - pnote->namedata);
16888 unsigned long val = 0;
16889 unsigned int shift = 0;
16890
16891 while (bytes --)
16892 {
79a964dc
NC		 16893 unsigned long byte = (* name ++) & 0xff;
16894
16895 val |= byte << shift;
9ef920e9
NC		 16896 shift += 8;
16897 }
16898
16899 if (name_attribute == GNU_BUILD_ATTRIBUTE_PIC)
16900 {
16901 char * pic_type = NULL;
16902
16903 switch (val)
16904 {
16905 case 0: pic_type = "static"; break;
16906 case 1: pic_type = "pic"; break;
16907 case 2: pic_type = "PIC"; break;
16908 case 3: pic_type = "pie"; break;
16909 case 4: pic_type = "PIE"; break;
16910 }
16911
16912 if (pic_type != NULL)
16913 {
16914 if (do_wide)
16915 left -= printf ("%s", pic_type);
16916 else
16917 left -= printf ("%-.*s", left, pic_type);
16918 break;
16919 }
16920 }
16921
16922 if (do_wide)
16923 left -= printf ("0x%lx", val);
16924 else
16925 left -= printf ("0x%-.*lx", left, val);
16926 }
16927 break;
16928 case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
16929 left -= print_symbol (- left, name);
16930 break;
16931 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
16932 left -= print_symbol (- left, "true");
16933 break;
16934 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
16935 left -= print_symbol (- left, "false");
16936 break;
16937 }
16938
16939 if (do_wide && left > 0)
16940 printf ("%-*s", left, " ");
16941
16942 return TRUE;
16943}
16944
6d118b09
NC		 16945/* Note that by the ELF standard, the name field is already null byte
16946 terminated, and namesz includes the terminating null byte.
16947 I.E. the value of namesz for the name "FSF" is 4.
16948
e3c8793a 16949 If the value of namesz is zero, there is no name present. */
9ef920e9 16950
32ec8896 16951static bfd_boolean
9ef920e9 16952process_note (Elf_Internal_Note * pnote,
c799a79d 16953 FILE * file)
779fe533 16954{
2cf0635d
NC		 16955 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
16956 const char * nt;
9437c45b
JT		 16957
16958 if (pnote->namesz == 0)
1ec5cd37
NC		 16959 /* If there is no note name, then use the default set of
16960 note type strings. */
16961 nt = get_note_type (pnote->type);
16962
1118d252
RM		 16963 else if (const_strneq (pnote->namedata, "GNU"))
16964 /* GNU-specific object file notes. */
16965 nt = get_gnu_elf_note_type (pnote->type);
f4ddf30f
JB		 16966
16967 else if (const_strneq (pnote->namedata, "FreeBSD"))
16968 /* FreeBSD-specific core file notes. */
16969 nt = get_freebsd_elfcore_note_type (pnote->type);
1118d252 16970
0112cd26 16971 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 16972 /* NetBSD-specific core file notes. */
16973 nt = get_netbsd_elfcore_note_type (pnote->type);
16974
c6056a74
SF		 16975 else if (const_strneq (pnote->namedata, "NetBSD"))
16976 /* NetBSD-specific core file notes. */
16977 return process_netbsd_elf_note (pnote);
16978
b15fa79e
AM		 16979 else if (strneq (pnote->namedata, "SPU/", 4))
16980 {
16981 /* SPU-specific core file notes. */
16982 nt = pnote->namedata + 4;
16983 name = "SPU";
16984 }
16985
00e98fc7
TG		 16986 else if (const_strneq (pnote->namedata, "IPF/VMS"))
16987 /* VMS/ia64-specific file notes. */
16988 nt = get_ia64_vms_note_type (pnote->type);
16989
70616151
TT		 16990 else if (const_strneq (pnote->namedata, "stapsdt"))
16991 nt = get_stapsdt_note_type (pnote->type);
16992
9437c45b 16993 else
1ec5cd37
NC		 16994 /* Don't recognize this note name; just use the default set of
16995 note type strings. */
00e98fc7 16996 nt = get_note_type (pnote->type);
9437c45b 16997
1449284b 16998 printf (" ");
9ef920e9
NC		 16999
17000 if (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17001 || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC)
17002 print_gnu_build_attribute_name (pnote);
17003 else
17004 print_symbol (-20, name);
17005
17006 if (do_wide)
17007 printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
17008 else
17009 printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
00e98fc7
TG		 17010
17011 if (const_strneq (pnote->namedata, "IPF/VMS"))
17012 return print_ia64_vms_note (pnote);
664f90a3
TT		 17013 else if (const_strneq (pnote->namedata, "GNU"))
17014 return print_gnu_note (pnote);
c6a9fc58
TT		 17015 else if (const_strneq (pnote->namedata, "stapsdt"))
17016 return print_stapsdt_note (pnote);
9ece1fa9
TT		 17017 else if (const_strneq (pnote->namedata, "CORE"))
17018 return print_core_note (pnote);
9ef920e9
NC		 17019 else if (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17020 || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC)
c799a79d 17021 return print_gnu_build_attribute_description (pnote, file);
779fe533 17022
9ef920e9 17023 if (pnote->descsz)
1449284b
NC		 17024 {
17025 unsigned long i;
17026
17027 printf (_(" description data: "));
17028 for (i = 0; i < pnote->descsz; i++)
17029 printf ("%02x ", pnote->descdata[i]);
1449284b
NC		 17030 }
17031
9ef920e9
NC		 17032 if (do_wide)
17033 printf ("\n");
17034
32ec8896 17035 return TRUE;
1449284b 17036}
6d118b09 17037
32ec8896 17038static bfd_boolean
1449284b
NC		 17039process_notes_at (FILE * file,
17040 Elf_Internal_Shdr * section,
17041 bfd_vma offset,
17042 bfd_vma length)
779fe533 17043{
2cf0635d
NC		 17044 Elf_External_Note * pnotes;
17045 Elf_External_Note * external;
c8071705 17046 char * end;
32ec8896 17047 bfd_boolean res = TRUE;
103f02d3 17048
779fe533 17049 if (length <= 0)
32ec8896 17050 return FALSE;
103f02d3 17051
1449284b
NC		 17052 if (section)
17053 {
17054 pnotes = (Elf_External_Note *) get_section_contents (section, file);
17055 if (pnotes)
32ec8896
NC		 17056 {
17057 if (! apply_relocations (file, section, (unsigned char *) pnotes, length, NULL, NULL))
17058 return FALSE;
17059 }
1449284b
NC		 17060 }
17061 else
17062 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
17063 _("notes"));
dd24e3da 17064 if (pnotes == NULL)
32ec8896 17065 return FALSE;
779fe533 17066
103f02d3 17067 external = pnotes;
103f02d3 17068
1449284b
NC		 17069 if (section)
17070 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section));
17071 else
17072 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
17073 (unsigned long) offset, (unsigned long) length);
17074
2aee03ae 17075 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 17076
c8071705
NC		 17077 end = (char *) pnotes + length;
17078 while ((char *) external < end)
779fe533 17079 {
b34976b6 17080 Elf_Internal_Note inote;
15b42fb0
AM		 17081 size_t min_notesz;
17082 char *next;
2cf0635d 17083 char * temp = NULL;
c8071705 17084 size_t data_remaining = end - (char *) external;
6d118b09 17085
00e98fc7 17086 if (!is_ia64_vms ())
15b42fb0 17087 {
9dd3a467
NC		 17088 /* PR binutils/15191
17089 Make sure that there is enough data to read. */
15b42fb0
AM		 17090 min_notesz = offsetof (Elf_External_Note, name);
17091 if (data_remaining < min_notesz)
9dd3a467
NC		 17092 {
17093 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17094 (int) data_remaining);
17095 break;
17096 }
15b42fb0
AM		 17097 inote.type = BYTE_GET (external->type);
17098 inote.namesz = BYTE_GET (external->namesz);
17099 inote.namedata = external->name;
17100 inote.descsz = BYTE_GET (external->descsz);
17101 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
834f871c 17102 /* PR 17531: file: 3443835e. */
c8071705 17103 if (inote.descdata < (char *) pnotes || inote.descdata > end)
834f871c 17104 {
9ef920e9
NC		 17105 warn (_("Corrupt note: name size is too big: (got: %lx, expected no more than: %lx)\n"),
17106 inote.namesz, (long)(end - inote.namedata));
834f871c
NC		 17107 inote.descdata = inote.namedata;
17108 inote.namesz = 0;
17109 }
14ae95f2 17110
15b42fb0
AM		 17111 inote.descpos = offset + (inote.descdata - (char *) pnotes);
17112 next = inote.descdata + align_power (inote.descsz, 2);
17113 }
00e98fc7 17114 else
15b42fb0
AM		 17115 {
17116 Elf64_External_VMS_Note *vms_external;
00e98fc7 17117
9dd3a467
NC		 17118 /* PR binutils/15191
17119 Make sure that there is enough data to read. */
15b42fb0
AM		 17120 min_notesz = offsetof (Elf64_External_VMS_Note, name);
17121 if (data_remaining < min_notesz)
9dd3a467
NC		 17122 {
17123 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17124 (int) data_remaining);
17125 break;
17126 }
3e55a963 17127
15b42fb0
AM		 17128 vms_external = (Elf64_External_VMS_Note *) external;
17129 inote.type = BYTE_GET (vms_external->type);
17130 inote.namesz = BYTE_GET (vms_external->namesz);
17131 inote.namedata = vms_external->name;
17132 inote.descsz = BYTE_GET (vms_external->descsz);
17133 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
17134 inote.descpos = offset + (inote.descdata - (char *) pnotes);
17135 next = inote.descdata + align_power (inote.descsz, 3);
17136 }
17137
17138 if (inote.descdata < (char *) external + min_notesz
17139 || next < (char *) external + min_notesz
5d921cbd
NC		 17140 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
17141 || inote.namedata + inote.namesz < inote.namedata
17142 || inote.descdata + inote.descsz < inote.descdata
15b42fb0 17143 || data_remaining < (size_t)(next - (char *) external))
3e55a963 17144 {
15b42fb0 17145 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 17146 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 17147 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC		 17148 inote.type, inote.namesz, inote.descsz);
17149 break;
17150 }
17151
15b42fb0 17152 external = (Elf_External_Note *) next;
dd24e3da 17153
6d118b09
NC		 17154 /* Verify that name is null terminated. It appears that at least
17155 one version of Linux (RedHat 6.0) generates corefiles that don't
17156 comply with the ELF spec by failing to include the null byte in
17157 namesz. */
8b971f9f 17158 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 17159 {
3f5e193b 17160 temp = (char *) malloc (inote.namesz + 1);
6d118b09
NC		 17161 if (temp == NULL)
17162 {
8b73c356 17163 error (_("Out of memory allocating space for inote name\n"));
32ec8896 17164 res = FALSE;
6d118b09
NC		 17165 break;
17166 }
76da6bbe 17167
79a964dc 17168 memcpy (temp, inote.namedata, inote.namesz);
6d118b09 17169 temp[inote.namesz] = 0;
76da6bbe 17170
6d118b09
NC		 17171 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
17172 inote.namedata = temp;
17173 }
17174
c799a79d 17175 if (! process_note (& inote, file))
6b4bf3bc 17176 res = FALSE;
103f02d3 17177
6d118b09
NC		 17178 if (temp != NULL)
17179 {
17180 free (temp);
17181 temp = NULL;
17182 }
779fe533
NC		 17183 }
17184
17185 free (pnotes);
103f02d3 17186
779fe533
NC		 17187 return res;
17188}
17189
32ec8896 17190static bfd_boolean
2cf0635d 17191process_corefile_note_segments (FILE * file)
779fe533 17192{
2cf0635d 17193 Elf_Internal_Phdr * segment;
b34976b6 17194 unsigned int i;
32ec8896 17195 bfd_boolean res = TRUE;
103f02d3 17196
d93f0186 17197 if (! get_program_headers (file))
6b4bf3bc 17198 return TRUE;
103f02d3 17199
779fe533
NC		 17200 for (i = 0, segment = program_headers;
17201 i < elf_header.e_phnum;
b34976b6 17202 i++, segment++)
779fe533
NC		 17203 {
17204 if (segment->p_type == PT_NOTE)
32ec8896
NC		 17205 if (! process_notes_at (file, NULL,
17206 (bfd_vma) segment->p_offset,
17207 (bfd_vma) segment->p_filesz))
17208 res = FALSE;
779fe533 17209 }
103f02d3 17210
779fe533
NC		 17211 return res;
17212}
17213
32ec8896 17214static bfd_boolean
685080f2
NC		 17215process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
17216{
17217 Elf_External_Note * pnotes;
17218 Elf_External_Note * external;
c8071705 17219 char * end;
32ec8896 17220 bfd_boolean res = TRUE;
685080f2
NC		 17221
17222 if (length <= 0)
32ec8896 17223 return FALSE;
685080f2
NC		 17224
17225 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
17226 _("v850 notes"));
17227 if (pnotes == NULL)
32ec8896 17228 return FALSE;
685080f2
NC		 17229
17230 external = pnotes;
c8071705 17231 end = (char*) pnotes + length;
685080f2
NC		 17232
17233 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
17234 (unsigned long) offset, (unsigned long) length);
17235
c8071705 17236 while ((char *) external + sizeof (Elf_External_Note) < end)
685080f2
NC		 17237 {
17238 Elf_External_Note * next;
17239 Elf_Internal_Note inote;
17240
17241 inote.type = BYTE_GET (external->type);
17242 inote.namesz = BYTE_GET (external->namesz);
17243 inote.namedata = external->name;
17244 inote.descsz = BYTE_GET (external->descsz);
17245 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
17246 inote.descpos = offset + (inote.descdata - (char *) pnotes);
17247
c8071705
NC		 17248 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
17249 {
17250 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
17251 inote.descdata = inote.namedata;
17252 inote.namesz = 0;
17253 }
17254
685080f2
NC		 17255 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
17256
c8071705 17257 if ( ((char *) next > end)
685080f2
NC		 17258 || ((char *) next < (char *) pnotes))
17259 {
17260 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
17261 (unsigned long) ((char *) external - (char *) pnotes));
17262 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17263 inote.type, inote.namesz, inote.descsz);
17264 break;
17265 }
17266
17267 external = next;
17268
17269 /* Prevent out-of-bounds indexing. */
c8071705 17270 if ( inote.namedata + inote.namesz > end
685080f2
NC		 17271 || inote.namedata + inote.namesz < inote.namedata)
17272 {
17273 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
17274 (unsigned long) ((char *) external - (char *) pnotes));
17275 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17276 inote.type, inote.namesz, inote.descsz);
17277 break;
17278 }
17279
17280 printf (" %s: ", get_v850_elf_note_type (inote.type));
17281
17282 if (! print_v850_note (& inote))
17283 {
32ec8896 17284 res = FALSE;
685080f2
NC		 17285 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
17286 inote.namesz, inote.descsz);
17287 }
17288 }
17289
17290 free (pnotes);
17291
17292 return res;
17293}
17294
32ec8896 17295static bfd_boolean
2cf0635d 17296process_note_sections (FILE * file)
1ec5cd37 17297{
2cf0635d 17298 Elf_Internal_Shdr * section;
1ec5cd37 17299 unsigned long i;
32ec8896
NC		 17300 unsigned int n = 0;
17301 bfd_boolean res = TRUE;
1ec5cd37
NC		 17302
17303 for (i = 0, section = section_headers;
fa1908fd 17304 i < elf_header.e_shnum && section != NULL;
1ec5cd37 17305 i++, section++)
685080f2
NC		 17306 {
17307 if (section->sh_type == SHT_NOTE)
17308 {
32ec8896
NC		 17309 if (! process_notes_at (file, section,
17310 (bfd_vma) section->sh_offset,
17311 (bfd_vma) section->sh_size))
17312 res = FALSE;
685080f2
NC		 17313 n++;
17314 }
17315
17316 if (( elf_header.e_machine == EM_V800
17317 || elf_header.e_machine == EM_V850
17318 || elf_header.e_machine == EM_CYGNUS_V850)
17319 && section->sh_type == SHT_RENESAS_INFO)
17320 {
32ec8896
NC		 17321 if (! process_v850_notes (file,
17322 (bfd_vma) section->sh_offset,
17323 (bfd_vma) section->sh_size))
17324 res = FALSE;
685080f2
NC		 17325 n++;
17326 }
17327 }
df565f32
NC		 17328
17329 if (n == 0)
17330 /* Try processing NOTE segments instead. */
17331 return process_corefile_note_segments (file);
1ec5cd37
NC		 17332
17333 return res;
17334}
17335
32ec8896 17336static bfd_boolean
2cf0635d 17337process_notes (FILE * file)
779fe533
NC		 17338{
17339 /* If we have not been asked to display the notes then do nothing. */
17340 if (! do_notes)
32ec8896 17341 return TRUE;
103f02d3 17342
779fe533 17343 if (elf_header.e_type != ET_CORE)
1ec5cd37 17344 return process_note_sections (file);
103f02d3 17345
779fe533 17346 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 17347 if (elf_header.e_phnum > 0)
17348 return process_corefile_note_segments (file);
779fe533 17349
1ec5cd37 17350 printf (_("No note segments present in the core file.\n"));
32ec8896 17351 return TRUE;
779fe533
NC		 17352}
17353
60abdbed
NC		 17354static unsigned char *
17355display_public_gnu_attributes (unsigned char * start,
17356 const unsigned char * const end)
17357{
17358 printf (_(" Unknown GNU attribute: %s\n"), start);
17359
17360 start += strnlen ((char *) start, end - start);
17361 display_raw_attribute (start, end);
17362
17363 return (unsigned char *) end;
17364}
17365
17366static unsigned char *
17367display_generic_attribute (unsigned char * start,
17368 unsigned int tag,
17369 const unsigned char * const end)
17370{
17371 if (tag == 0)
17372 return (unsigned char *) end;
17373
17374 return display_tag_value (tag, start, end);
17375}
17376
32ec8896 17377static bfd_boolean
2cf0635d 17378process_arch_specific (FILE * file)
252b5132 17379{
a952a375 17380 if (! do_arch)
32ec8896 17381 return TRUE;
a952a375 17382
252b5132
RH		 17383 switch (elf_header.e_machine)
17384 {
11c1ff18 17385 case EM_ARM:
60abdbed
NC		 17386 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
17387 display_arm_attribute,
17388 display_generic_attribute);
17389
252b5132 17390 case EM_MIPS:
4fe85591 17391 case EM_MIPS_RS3_LE:
252b5132 17392 return process_mips_specific (file);
60abdbed
NC		 17393
17394 case EM_MSP430:
17395 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
17396 display_msp430x_attribute,
17397 display_generic_attribute);
17398
35c08157
KLC		 17399 case EM_NDS32:
17400 return process_nds32_specific (file);
60abdbed 17401
34c8bcba 17402 case EM_PPC:
b82317dd 17403 case EM_PPC64:
60abdbed
NC		 17404 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17405 display_power_gnu_attribute);
17406
643f7afb
AK		 17407 case EM_S390:
17408 case EM_S390_OLD:
60abdbed
NC		 17409 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17410 display_s390_gnu_attribute);
17411
9e8c70f9
DM		 17412 case EM_SPARC:
17413 case EM_SPARC32PLUS:
17414 case EM_SPARCV9:
60abdbed
NC		 17415 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17416 display_sparc_gnu_attribute);
17417
59e6276b 17418 case EM_TI_C6000:
60abdbed
NC		 17419 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
17420 display_tic6x_attribute,
17421 display_generic_attribute);
17422
252b5132 17423 default:
60abdbed
NC		 17424 return process_attributes (file, "gnu", SHT_GNU_ATTRIBUTES,
17425 display_public_gnu_attributes,
17426 display_generic_attribute);
252b5132 17427 }
252b5132
RH		 17428}
17429
32ec8896 17430static bfd_boolean
2cf0635d 17431get_file_header (FILE * file)
252b5132 17432{
9ea033b2
NC		 17433 /* Read in the identity array. */
17434 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
32ec8896 17435 return FALSE;
252b5132 17436
9ea033b2 17437 /* Determine how to read the rest of the header. */
b34976b6 17438 switch (elf_header.e_ident[EI_DATA])
9ea033b2 17439 {
1a0670f3
AM		 17440 default:
17441 case ELFDATANONE:
adab8cdc
AO		 17442 case ELFDATA2LSB:
17443 byte_get = byte_get_little_endian;
17444 byte_put = byte_put_little_endian;
17445 break;
17446 case ELFDATA2MSB:
17447 byte_get = byte_get_big_endian;
17448 byte_put = byte_put_big_endian;
17449 break;
9ea033b2
NC		 17450 }
17451
17452 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 17453 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 17454
17455 /* Read in the rest of the header. */
17456 if (is_32bit_elf)
17457 {
17458 Elf32_External_Ehdr ehdr32;
252b5132 17459
9ea033b2 17460 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
32ec8896 17461 return FALSE;
103f02d3 17462
9ea033b2
NC		 17463 elf_header.e_type = BYTE_GET (ehdr32.e_type);
17464 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
17465 elf_header.e_version = BYTE_GET (ehdr32.e_version);
17466 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
17467 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
17468 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
17469 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
17470 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
17471 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
17472 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
17473 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
17474 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
17475 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
17476 }
252b5132 17477 else
9ea033b2
NC		 17478 {
17479 Elf64_External_Ehdr ehdr64;
a952a375
NC		 17480
17481 /* If we have been compiled with sizeof (bfd_vma) == 4, then
17482 we will not be able to cope with the 64bit data found in
17483 64 ELF files. Detect this now and abort before we start
50c2245b 17484 overwriting things. */
a952a375
NC		 17485 if (sizeof (bfd_vma) < 8)
17486 {
e3c8793a
NC		 17487 error (_("This instance of readelf has been built without support for a\n\
1748864 bit data type and so it cannot read 64 bit ELF files.\n"));
32ec8896 17489 return FALSE;
a952a375 17490 }
103f02d3 17491
9ea033b2 17492 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
32ec8896 17493 return FALSE;
103f02d3 17494
9ea033b2
NC		 17495 elf_header.e_type = BYTE_GET (ehdr64.e_type);
17496 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
17497 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 17498 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
17499 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
17500 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 17501 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
17502 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
17503 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
17504 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
17505 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
17506 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
17507 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
17508 }
252b5132 17509
7ece0d85
JJ		 17510 if (elf_header.e_shoff)
17511 {
17512 /* There may be some extensions in the first section header. Don't
17513 bomb if we can't read it. */
17514 if (is_32bit_elf)
049b0c3a 17515 get_32bit_section_headers (file, TRUE);
7ece0d85 17516 else
049b0c3a 17517 get_64bit_section_headers (file, TRUE);
7ece0d85 17518 }
560f3c1c 17519
32ec8896 17520 return TRUE;
252b5132
RH		 17521}
17522
fb52b2f4
NC		 17523/* Process one ELF object file according to the command line options.
17524 This file may actually be stored in an archive. The file is
32ec8896
NC		 17525 positioned at the start of the ELF object. Returns TRUE if no
17526 problems were encountered, FALSE otherwise. */
fb52b2f4 17527
32ec8896 17528static bfd_boolean
2cf0635d 17529process_object (char * file_name, FILE * file)
252b5132 17530{
252b5132 17531 unsigned int i;
32ec8896 17532 bfd_boolean res = TRUE;
252b5132 17533
252b5132
RH		 17534 if (! get_file_header (file))
17535 {
17536 error (_("%s: Failed to read file header\n"), file_name);
32ec8896 17537 return FALSE;
252b5132
RH		 17538 }
17539
17540 /* Initialise per file variables. */
60bca95a 17541 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 17542 version_info[i] = 0;
17543
60bca95a 17544 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 17545 dynamic_info[i] = 0;
5115b233 17546 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 17547
17548 /* Process the file. */
17549 if (show_name)
17550 printf (_("\nFile: %s\n"), file_name);
17551
18bd398b
NC		 17552 /* Initialise the dump_sects array from the cmdline_dump_sects array.
17553 Note we do this even if cmdline_dump_sects is empty because we
17554 must make sure that the dump_sets array is zeroed out before each
17555 object file is processed. */
17556 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 17557 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 17558
17559 if (num_cmdline_dump_sects > 0)
17560 {
17561 if (num_dump_sects == 0)
17562 /* A sneaky way of allocating the dump_sects array. */
09c11c86 17563 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 17564
17565 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 17566 memcpy (dump_sects, cmdline_dump_sects,
17567 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 17568 }
d70c5fc7 17569
252b5132 17570 if (! process_file_header ())
32ec8896 17571 return FALSE;
252b5132 17572
d1f5c6e3 17573 if (! process_section_headers (file))
2f62977e 17574 {
32ec8896
NC		 17575 /* Without loaded section headers we cannot process lots of things. */
17576 do_unwind = do_version = do_dump = do_arch = FALSE;
252b5132 17577
2f62977e 17578 if (! do_using_dynamic)
32ec8896 17579 do_syms = do_dyn_syms = do_reloc = FALSE;
2f62977e 17580 }
252b5132 17581
d1f5c6e3 17582 if (! process_section_groups (file))
32ec8896
NC		 17583 /* Without loaded section groups we cannot process unwind. */
17584 do_unwind = FALSE;
d1f5c6e3 17585
2f62977e 17586 if (process_program_headers (file))
b2d38a17 17587 process_dynamic_section (file);
32ec8896
NC		 17588 else
17589 res = FALSE;
252b5132 17590
32ec8896
NC		 17591 if (! process_relocs (file))
17592 res = FALSE;
252b5132 17593
32ec8896
NC		 17594 if (! process_unwind (file))
17595 res = FALSE;
4d6ed7c8 17596
32ec8896
NC		 17597 if (! process_symbol_table (file))
17598 res = FALSE;
252b5132 17599
32ec8896
NC		 17600 if (! process_syminfo (file))
17601 res = FALSE;
252b5132 17602
32ec8896
NC		 17603 if (! process_version_sections (file))
17604 res = FALSE;
252b5132 17605
32ec8896
NC		 17606 if (! process_section_contents (file))
17607 res = FALSE;
f5842774 17608
32ec8896
NC		 17609 if (! process_notes (file))
17610 res = FALSE;
103f02d3 17611
32ec8896
NC		 17612 if (! process_gnu_liblist (file))
17613 res = FALSE;
047b2264 17614
32ec8896
NC		 17615 if (! process_arch_specific (file))
17616 res = FALSE;
252b5132 17617
d93f0186
NC		 17618 if (program_headers)
17619 {
17620 free (program_headers);
17621 program_headers = NULL;
17622 }
17623
252b5132
RH		 17624 if (section_headers)
17625 {
17626 free (section_headers);
17627 section_headers = NULL;
17628 }
17629
17630 if (string_table)
17631 {
17632 free (string_table);
17633 string_table = NULL;
d40ac9bd 17634 string_table_length = 0;
252b5132
RH		 17635 }
17636
17637 if (dynamic_strings)
17638 {
17639 free (dynamic_strings);
17640 dynamic_strings = NULL;
d79b3d50 17641 dynamic_strings_length = 0;
252b5132
RH		 17642 }
17643
17644 if (dynamic_symbols)
17645 {
17646 free (dynamic_symbols);
17647 dynamic_symbols = NULL;
19936277 17648 num_dynamic_syms = 0;
252b5132
RH		 17649 }
17650
17651 if (dynamic_syminfo)
17652 {
17653 free (dynamic_syminfo);
17654 dynamic_syminfo = NULL;
17655 }
ff78d6d6 17656
293c573e
MR		 17657 if (dynamic_section)
17658 {
17659 free (dynamic_section);
17660 dynamic_section = NULL;
17661 }
17662
e4b17d5c
L		 17663 if (section_headers_groups)
17664 {
17665 free (section_headers_groups);
17666 section_headers_groups = NULL;
17667 }
17668
17669 if (section_groups)
17670 {
2cf0635d
NC		 17671 struct group_list * g;
17672 struct group_list * next;
e4b17d5c
L		 17673
17674 for (i = 0; i < group_count; i++)
17675 {
17676 for (g = section_groups [i].root; g != NULL; g = next)
17677 {
17678 next = g->next;
17679 free (g);
17680 }
17681 }
17682
17683 free (section_groups);
17684 section_groups = NULL;
17685 }
17686
19e6b90e 17687 free_debug_memory ();
18bd398b 17688
32ec8896 17689 return res;
252b5132
RH		 17690}
17691
2cf0635d 17692/* Process an ELF archive.
32ec8896
NC		 17693 On entry the file is positioned just after the ARMAG string.
17694 Returns TRUE upon success, FALSE otherwise. */
2cf0635d 17695
32ec8896 17696static bfd_boolean
2cf0635d
NC		 17697process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
17698{
17699 struct archive_info arch;
17700 struct archive_info nested_arch;
17701 size_t got;
32ec8896 17702 bfd_boolean ret = TRUE;
2cf0635d 17703
32ec8896 17704 show_name = TRUE;
2cf0635d
NC		 17705
17706 /* The ARCH structure is used to hold information about this archive. */
17707 arch.file_name = NULL;
17708 arch.file = NULL;
17709 arch.index_array = NULL;
17710 arch.sym_table = NULL;
17711 arch.longnames = NULL;
17712
17713 /* The NESTED_ARCH structure is used as a single-item cache of information
17714 about a nested archive (when members of a thin archive reside within
17715 another regular archive file). */
17716 nested_arch.file_name = NULL;
17717 nested_arch.file = NULL;
17718 nested_arch.index_array = NULL;
17719 nested_arch.sym_table = NULL;
17720 nested_arch.longnames = NULL;
17721
17722 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
17723 {
32ec8896 17724 ret = FALSE;
2cf0635d 17725 goto out;
4145f1d5 17726 }
fb52b2f4 17727
4145f1d5
NC		 17728 if (do_archive_index)
17729 {
2cf0635d 17730 if (arch.sym_table == NULL)
4145f1d5
NC		 17731 error (_("%s: unable to dump the index as none was found\n"), file_name);
17732 else
17733 {
591f7597 17734 unsigned long i, l;
4145f1d5
NC		 17735 unsigned long current_pos;
17736
591f7597
NC		 17737 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
17738 file_name, (unsigned long) arch.index_num, arch.sym_size);
4145f1d5
NC		 17739 current_pos = ftell (file);
17740
2cf0635d 17741 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 17742 {
2cf0635d
NC		 17743 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
17744 {
17745 char * member_name;
4145f1d5 17746
2cf0635d
NC		 17747 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
17748
17749 if (member_name != NULL)
17750 {
17751 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
17752
17753 if (qualified_name != NULL)
17754 {
c2a7d3f5
NC		 17755 printf (_("Contents of binary %s at offset "), qualified_name);
17756 (void) print_vma (arch.index_array[i], PREFIX_HEX);
17757 putchar ('\n');
2cf0635d
NC		 17758 free (qualified_name);
17759 }
4145f1d5
NC		 17760 }
17761 }
2cf0635d
NC		 17762
17763 if (l >= arch.sym_size)
4145f1d5
NC		 17764 {
17765 error (_("%s: end of the symbol table reached before the end of the index\n"),
17766 file_name);
32ec8896 17767 ret = FALSE;
cb8f3167 17768 break;
4145f1d5 17769 }
591f7597
NC		 17770 /* PR 17531: file: 0b6630b2. */
17771 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
17772 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
4145f1d5
NC		 17773 }
17774
c2a7d3f5
NC		 17775 if (arch.uses_64bit_indicies)
17776 l = (l + 7) & ~ 7;
17777 else
17778 l += l & 1;
17779
2cf0635d 17780 if (l < arch.sym_size)
32ec8896
NC		 17781 {
17782 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
17783 file_name, arch.sym_size - l);
17784 ret = FALSE;
17785 }
4145f1d5 17786
4145f1d5
NC		 17787 if (fseek (file, current_pos, SEEK_SET) != 0)
17788 {
17789 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
32ec8896 17790 ret = FALSE;
2cf0635d 17791 goto out;
4145f1d5 17792 }
fb52b2f4 17793 }
4145f1d5
NC		 17794
17795 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
17796 && !do_segments && !do_header && !do_dump && !do_version
17797 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 17798 && !do_section_groups && !do_dyn_syms)
2cf0635d 17799 {
32ec8896 17800 ret = TRUE; /* Archive index only. */
2cf0635d
NC		 17801 goto out;
17802 }
fb52b2f4
NC		 17803 }
17804
fb52b2f4
NC		 17805 while (1)
17806 {
2cf0635d
NC		 17807 char * name;
17808 size_t namelen;
17809 char * qualified_name;
17810
17811 /* Read the next archive header. */
17812 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
17813 {
17814 error (_("%s: failed to seek to next archive header\n"), file_name);
32ec8896 17815 return FALSE;
2cf0635d
NC		 17816 }
17817 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
17818 if (got != sizeof arch.arhdr)
17819 {
17820 if (got == 0)
17821 break;
17822 error (_("%s: failed to read archive header\n"), file_name);
32ec8896 17823 ret = FALSE;
2cf0635d
NC		 17824 break;
17825 }
17826 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
17827 {
17828 error (_("%s: did not find a valid archive header\n"), arch.file_name);
32ec8896 17829 ret = FALSE;
2cf0635d
NC		 17830 break;
17831 }
17832
17833 arch.next_arhdr_offset += sizeof arch.arhdr;
17834
17835 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
17836 if (archive_file_size & 01)
17837 ++archive_file_size;
17838
17839 name = get_archive_member_name (&arch, &nested_arch);
17840 if (name == NULL)
fb52b2f4 17841 {
0fd3a477 17842 error (_("%s: bad archive file name\n"), file_name);
32ec8896 17843 ret = FALSE;
d989285c 17844 break;
fb52b2f4 17845 }
2cf0635d 17846 namelen = strlen (name);
fb52b2f4 17847
2cf0635d
NC		 17848 qualified_name = make_qualified_name (&arch, &nested_arch, name);
17849 if (qualified_name == NULL)
fb52b2f4 17850 {
2cf0635d 17851 error (_("%s: bad archive file name\n"), file_name);
32ec8896 17852 ret = FALSE;
d989285c 17853 break;
fb52b2f4
NC		 17854 }
17855
2cf0635d
NC		 17856 if (is_thin_archive && arch.nested_member_origin == 0)
17857 {
17858 /* This is a proxy for an external member of a thin archive. */
17859 FILE * member_file;
17860 char * member_file_name = adjust_relative_path (file_name, name, namelen);
32ec8896 17861
2cf0635d
NC		 17862 if (member_file_name == NULL)
17863 {
32ec8896 17864 ret = FALSE;
2cf0635d
NC		 17865 break;
17866 }
17867
17868 member_file = fopen (member_file_name, "rb");
17869 if (member_file == NULL)
17870 {
17871 error (_("Input file '%s' is not readable.\n"), member_file_name);
17872 free (member_file_name);
32ec8896 17873 ret = FALSE;
2cf0635d
NC		 17874 break;
17875 }
17876
17877 archive_file_offset = arch.nested_member_origin;
17878
32ec8896
NC		 17879 if (! process_object (qualified_name, member_file))
17880 ret = FALSE;
2cf0635d
NC		 17881
17882 fclose (member_file);
17883 free (member_file_name);
17884 }
17885 else if (is_thin_archive)
17886 {
a043396b
NC		 17887 /* PR 15140: Allow for corrupt thin archives. */
17888 if (nested_arch.file == NULL)
17889 {
17890 error (_("%s: contains corrupt thin archive: %s\n"),
17891 file_name, name);
32ec8896 17892 ret = FALSE;
a043396b
NC		 17893 break;
17894 }
17895
2cf0635d
NC		 17896 /* This is a proxy for a member of a nested archive. */
17897 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
17898
17899 /* The nested archive file will have been opened and setup by
17900 get_archive_member_name. */
17901 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
17902 {
17903 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
32ec8896 17904 ret = FALSE;
2cf0635d
NC		 17905 break;
17906 }
17907
32ec8896
NC		 17908 if (! process_object (qualified_name, nested_arch.file))
17909 ret = FALSE;
2cf0635d
NC		 17910 }
17911 else
17912 {
17913 archive_file_offset = arch.next_arhdr_offset;
17914 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 17915
32ec8896
NC		 17916 if (! process_object (qualified_name, file))
17917 ret = FALSE;
2cf0635d 17918 }
fb52b2f4 17919
2b52916e
L		 17920 if (dump_sects != NULL)
17921 {
17922 free (dump_sects);
17923 dump_sects = NULL;
17924 num_dump_sects = 0;
17925 }
17926
2cf0635d 17927 free (qualified_name);
fb52b2f4
NC		 17928 }
17929
4145f1d5 17930 out:
2cf0635d
NC		 17931 if (nested_arch.file != NULL)
17932 fclose (nested_arch.file);
17933 release_archive (&nested_arch);
17934 release_archive (&arch);
fb52b2f4 17935
d989285c 17936 return ret;
fb52b2f4
NC		 17937}
17938
32ec8896 17939static bfd_boolean
2cf0635d 17940process_file (char * file_name)
fb52b2f4 17941{
2cf0635d 17942 FILE * file;
fb52b2f4
NC		 17943 struct stat statbuf;
17944 char armag[SARMAG];
32ec8896 17945 bfd_boolean ret = TRUE;
fb52b2f4
NC		 17946
17947 if (stat (file_name, &statbuf) < 0)
17948 {
f24ddbdd
NC		 17949 if (errno == ENOENT)
17950 error (_("'%s': No such file\n"), file_name);
17951 else
17952 error (_("Could not locate '%s'. System error message: %s\n"),
17953 file_name, strerror (errno));
32ec8896 17954 return FALSE;
f24ddbdd
NC		 17955 }
17956
17957 if (! S_ISREG (statbuf.st_mode))
17958 {
17959 error (_("'%s' is not an ordinary file\n"), file_name);
32ec8896 17960 return FALSE;
fb52b2f4
NC		 17961 }
17962
17963 file = fopen (file_name, "rb");
17964 if (file == NULL)
17965 {
f24ddbdd 17966 error (_("Input file '%s' is not readable.\n"), file_name);
32ec8896 17967 return FALSE;
fb52b2f4
NC		 17968 }
17969
17970 if (fread (armag, SARMAG, 1, file) != 1)
17971 {
4145f1d5 17972 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4 17973 fclose (file);
32ec8896 17974 return FALSE;
fb52b2f4
NC		 17975 }
17976
f54498b4
NC		 17977 current_file_size = (bfd_size_type) statbuf.st_size;
17978
fb52b2f4 17979 if (memcmp (armag, ARMAG, SARMAG) == 0)
32ec8896
NC		 17980 {
17981 if (! process_archive (file_name, file, FALSE))
17982 ret = FALSE;
17983 }
2cf0635d 17984 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
32ec8896
NC		 17985 {
17986 if ( ! process_archive (file_name, file, TRUE))
17987 ret = FALSE;
17988 }
fb52b2f4
NC		 17989 else
17990 {
4145f1d5
NC		 17991 if (do_archive_index)
17992 error (_("File %s is not an archive so its index cannot be displayed.\n"),
17993 file_name);
17994
fb52b2f4
NC		 17995 rewind (file);
17996 archive_file_size = archive_file_offset = 0;
32ec8896
NC		 17997
17998 if (! process_object (file_name, file))
17999 ret = FALSE;
fb52b2f4
NC		 18000 }
18001
18002 fclose (file);
f54498b4 18003 current_file_size = 0;
32ec8896 18004
fb52b2f4
NC		 18005 return ret;
18006}
18007
252b5132
RH		 18008#ifdef SUPPORT_DISASSEMBLY
18009/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 18010 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 18011 symbols. */
252b5132
RH		 18012
18013void
2cf0635d 18014print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 18015{
18016 fprintf (outfile,"0x%8.8x", addr);
18017}
18018
e3c8793a 18019/* Needed by the i386 disassembler. */
252b5132
RH		 18020void
18021db_task_printsym (unsigned int addr)
18022{
18023 print_address (addr, stderr);
18024}
18025#endif
18026
18027int
2cf0635d 18028main (int argc, char ** argv)
252b5132 18029{
ff78d6d6
L		 18030 int err;
18031
252b5132
RH		 18032#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
18033 setlocale (LC_MESSAGES, "");
3882b010
L		 18034#endif
18035#if defined (HAVE_SETLOCALE)
18036 setlocale (LC_CTYPE, "");
252b5132
RH		 18037#endif
18038 bindtextdomain (PACKAGE, LOCALEDIR);
18039 textdomain (PACKAGE);
18040
869b9d07
MM		 18041 expandargv (&argc, &argv);
18042
252b5132
RH		 18043 parse_args (argc, argv);
18044
18bd398b 18045 if (num_dump_sects > 0)
59f14fc0 18046 {
18bd398b 18047 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 18048 cmdline_dump_sects = (dump_type *)
18049 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 18050 if (cmdline_dump_sects == NULL)
591a748a 18051 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 18052 else
18053 {
09c11c86
NC		 18054 memcpy (cmdline_dump_sects, dump_sects,
18055 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 18056 num_cmdline_dump_sects = num_dump_sects;
18057 }
18058 }
18059
18bd398b 18060 if (optind < (argc - 1))
32ec8896 18061 show_name = TRUE;
5656ba2c
L		 18062 else if (optind >= argc)
18063 {
18064 warn (_("Nothing to do.\n"));
18065 usage (stderr);
18066 }
18bd398b 18067
32ec8896 18068 err = FALSE;
252b5132 18069 while (optind < argc)
32ec8896
NC		 18070 if (! process_file (argv[optind++]))
18071 err = TRUE;
252b5132
RH		 18072
18073 if (dump_sects != NULL)
18074 free (dump_sects);
59f14fc0
AS		 18075 if (cmdline_dump_sects != NULL)
18076 free (cmdline_dump_sects);
252b5132 18077
32ec8896 18078 return err ? EXIT_FAILURE : EXIT_SUCCESS;
252b5132 18079}
A mirror of the official binutils-gdb repository