projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
-Wimplicit-fallthrough noreturn fixes
[deliverable/binutils-gdb.git] / binutils / readelf.c
CommitLineData
252b5132 1/* readelf.c -- display contents of an ELF format file
6f2750fe 2 Copyright (C) 1998-2016 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"
3c3bdf30 127#include "elf/mmix.h"
3b16e843
NC		 128#include "elf/mn10200.h"
129#include "elf/mn10300.h"
5506d11a 130#include "elf/moxie.h"
4970f871 131#include "elf/mt.h"
2469cfa2 132#include "elf/msp430.h"
35c08157 133#include "elf/nds32.h"
13761a11 134#include "elf/nios2.h"
73589c9d 135#include "elf/or1k.h"
7d466069 136#include "elf/pj.h"
3b16e843 137#include "elf/ppc.h"
c833c019 138#include "elf/ppc64.h"
99c513f6 139#include "elf/rl78.h"
c7927a3c 140#include "elf/rx.h"
a85d7ed0 141#include "elf/s390.h"
1c0d3aa6 142#include "elf/score.h"
3b16e843
NC		 143#include "elf/sh.h"
144#include "elf/sparc.h"
e9f53129 145#include "elf/spu.h"
40b36596 146#include "elf/tic6x.h"
aa137e4d
NC		 147#include "elf/tilegx.h"
148#include "elf/tilepro.h"
3b16e843 149#include "elf/v850.h"
179d3252 150#include "elf/vax.h"
619ed720 151#include "elf/visium.h"
3b16e843 152#include "elf/x86-64.h"
c29aca4a 153#include "elf/xc16x.h"
f6c1a2d5 154#include "elf/xgate.h"
93fbbb04 155#include "elf/xstormy16.h"
88da6820 156#include "elf/xtensa.h"
252b5132 157
252b5132 158#include "getopt.h"
566b0d53 159#include "libiberty.h"
09c11c86 160#include "safe-ctype.h"
2cf0635d 161#include "filenames.h"
252b5132 162
15b42fb0
AM		 163#ifndef offsetof
164#define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
165#endif
166
6a40cf0c
NC		 167typedef struct elf_section_list
168{
169 Elf_Internal_Shdr * hdr;
170 struct elf_section_list * next;
171} elf_section_list;
172
2cf0635d 173char * program_name = "readelf";
c9c1d674 174static unsigned long archive_file_offset;
85b1c36d 175static unsigned long archive_file_size;
f54498b4 176static bfd_size_type current_file_size;
85b1c36d
BE		 177static unsigned long dynamic_addr;
178static bfd_size_type dynamic_size;
8b73c356 179static size_t dynamic_nent;
2cf0635d 180static char * dynamic_strings;
85b1c36d 181static unsigned long dynamic_strings_length;
2cf0635d 182static char * string_table;
85b1c36d
BE		 183static unsigned long string_table_length;
184static unsigned long num_dynamic_syms;
2cf0635d
NC		 185static Elf_Internal_Sym * dynamic_symbols;
186static Elf_Internal_Syminfo * dynamic_syminfo;
85b1c36d
BE		 187static unsigned long dynamic_syminfo_offset;
188static unsigned int dynamic_syminfo_nent;
f8eae8b2 189static char program_interpreter[PATH_MAX];
bb8a0291 190static bfd_vma dynamic_info[DT_ENCODING];
fdc90cb4 191static bfd_vma dynamic_info_DT_GNU_HASH;
85b1c36d
BE		 192static bfd_vma version_info[16];
193static Elf_Internal_Ehdr elf_header;
2cf0635d
NC		 194static Elf_Internal_Shdr * section_headers;
195static Elf_Internal_Phdr * program_headers;
196static Elf_Internal_Dyn * dynamic_section;
6a40cf0c 197static elf_section_list * symtab_shndx_list;
85b1c36d
BE		 198static int show_name;
199static int do_dynamic;
200static int do_syms;
2c610e4b 201static int do_dyn_syms;
85b1c36d
BE		 202static int do_reloc;
203static int do_sections;
204static int do_section_groups;
5477e8a0 205static int do_section_details;
85b1c36d
BE		 206static int do_segments;
207static int do_unwind;
208static int do_using_dynamic;
209static int do_header;
210static int do_dump;
211static int do_version;
85b1c36d
BE		 212static int do_histogram;
213static int do_debugging;
85b1c36d
BE		 214static int do_arch;
215static int do_notes;
4145f1d5 216static int do_archive_index;
85b1c36d 217static int is_32bit_elf;
0e602686 218static int decompress_dumps;
252b5132 219
e4b17d5c
L		 220struct group_list
221{
2cf0635d 222 struct group_list * next;
e4b17d5c
L		 223 unsigned int section_index;
224};
225
226struct group
227{
2cf0635d 228 struct group_list * root;
e4b17d5c
L		 229 unsigned int group_index;
230};
231
85b1c36d 232static size_t group_count;
2cf0635d
NC		 233static struct group * section_groups;
234static struct group ** section_headers_groups;
e4b17d5c 235
09c11c86
NC		 236
237/* Flag bits indicating particular types of dump. */
238#define HEX_DUMP (1 << 0) /* The -x command line switch. */
239#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
240#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
241#define STRING_DUMP (1 << 3) /* The -p command line switch. */
cf13d699 242#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
09c11c86
NC		 243
244typedef unsigned char dump_type;
245
246/* A linked list of the section names for which dumps were requested. */
aef1f6d0
DJ		 247struct dump_list_entry
248{
2cf0635d 249 char * name;
09c11c86 250 dump_type type;
2cf0635d 251 struct dump_list_entry * next;
aef1f6d0 252};
2cf0635d 253static struct dump_list_entry * dump_sects_byname;
aef1f6d0 254
09c11c86
NC		 255/* A dynamic array of flags indicating for which sections a dump
256 has been requested via command line switches. */
257static dump_type * cmdline_dump_sects = NULL;
258static unsigned int num_cmdline_dump_sects = 0;
18bd398b
NC		 259
260/* A dynamic array of flags indicating for which sections a dump of
261 some kind has been requested. It is reset on a per-object file
aef1f6d0
DJ		 262 basis and then initialised from the cmdline_dump_sects array,
263 the results of interpreting the -w switch, and the
264 dump_sects_byname list. */
09c11c86
NC		 265static dump_type * dump_sects = NULL;
266static unsigned int num_dump_sects = 0;
252b5132 267
252b5132 268
c256ffe7 269/* How to print a vma value. */
843dd992
NC		 270typedef enum print_mode
271{
272 HEX,
273 DEC,
274 DEC_5,
275 UNSIGNED,
276 PREFIX_HEX,
277 FULL_HEX,
278 LONG_HEX
279}
280print_mode;
281
bb4d2ac2
L		 282/* Versioned symbol info. */
283enum versioned_symbol_info
284{
285 symbol_undefined,
286 symbol_hidden,
287 symbol_public
288};
289
290static const char *get_symbol_version_string
291 (FILE *file, int is_dynsym, const char *strtab,
292 unsigned long int strtab_size, unsigned int si,
293 Elf_Internal_Sym *psym, enum versioned_symbol_info *sym_info,
294 unsigned short *vna_other);
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
14a91970 418/* Print a VMA value. */
cb8f3167 419
66543521 420static int
14a91970 421print_vma (bfd_vma vma, print_mode mode)
66543521 422{
66543521
AM		 423 int nc = 0;
424
14a91970 425 switch (mode)
66543521 426 {
14a91970
AM		 427 case FULL_HEX:
428 nc = printf ("0x");
429 /* Drop through. */
66543521 430
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);
442 /* Drop through. */
66543521 443
14a91970
AM		 444 case PREFIX_HEX:
445 nc = printf ("0x");
446 /* Drop through. */
66543521 447
14a91970
AM		 448 case HEX:
449 return nc + printf ("%" BFD_VMA_FMT "x", vma);
b19aac67 450
14a91970
AM		 451 case DEC:
452 return printf ("%" BFD_VMA_FMT "d", vma);
b19aac67 453
14a91970
AM		 454 case UNSIGNED:
455 return printf ("%" BFD_VMA_FMT "u", vma);
f7a99963 456 }
66543521 457 return 0;
f7a99963
NC		 458}
459
7bfd842d 460/* Display a symbol on stdout. Handles the display of control characters and
3bfcb652 461 multibye characters (assuming the host environment supports them).
31104126 462
7bfd842d
NC		 463 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
464
465 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
466 padding as necessary.
171191ba
NC		 467
468 Returns the number of emitted characters. */
469
470static unsigned int
7a88bc9c 471print_symbol (int width, const char *symbol)
31104126 472{
171191ba 473 bfd_boolean extra_padding = FALSE;
7bfd842d 474 int num_printed = 0;
3bfcb652 475#ifdef HAVE_MBSTATE_T
7bfd842d 476 mbstate_t state;
3bfcb652 477#endif
7bfd842d 478 int width_remaining;
961c521f 479
7bfd842d 480 if (width < 0)
961c521f 481 {
961c521f
NC		 482 /* Keep the width positive. This also helps. */
483 width = - width;
171191ba 484 extra_padding = TRUE;
0b4362b0 485 }
74e1a04b 486 assert (width != 0);
961c521f 487
7bfd842d
NC		 488 if (do_wide)
489 /* Set the remaining width to a very large value.
490 This simplifies the code below. */
491 width_remaining = INT_MAX;
492 else
493 width_remaining = width;
cb8f3167 494
3bfcb652 495#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 496 /* Initialise the multibyte conversion state. */
497 memset (& state, 0, sizeof (state));
3bfcb652 498#endif
961c521f 499
7bfd842d
NC		 500 while (width_remaining)
501 {
502 size_t n;
7bfd842d 503 const char c = *symbol++;
961c521f 504
7bfd842d 505 if (c == 0)
961c521f
NC		 506 break;
507
7bfd842d
NC		 508 /* Do not print control characters directly as they can affect terminal
509 settings. Such characters usually appear in the names generated
510 by the assembler for local labels. */
511 if (ISCNTRL (c))
961c521f 512 {
7bfd842d 513 if (width_remaining < 2)
961c521f
NC		 514 break;
515
7bfd842d
NC		 516 printf ("^%c", c + 0x40);
517 width_remaining -= 2;
171191ba 518 num_printed += 2;
961c521f 519 }
7bfd842d
NC		 520 else if (ISPRINT (c))
521 {
522 putchar (c);
523 width_remaining --;
524 num_printed ++;
525 }
961c521f
NC		 526 else
527 {
3bfcb652
NC		 528#ifdef HAVE_MBSTATE_T
529 wchar_t w;
530#endif
7bfd842d
NC		 531 /* Let printf do the hard work of displaying multibyte characters. */
532 printf ("%.1s", symbol - 1);
533 width_remaining --;
534 num_printed ++;
535
3bfcb652 536#ifdef HAVE_MBSTATE_T
7bfd842d
NC		 537 /* Try to find out how many bytes made up the character that was
538 just printed. Advance the symbol pointer past the bytes that
539 were displayed. */
540 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
3bfcb652
NC		 541#else
542 n = 1;
543#endif
7bfd842d
NC		 544 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
545 symbol += (n - 1);
961c521f 546 }
961c521f 547 }
171191ba 548
7bfd842d 549 if (extra_padding && num_printed < width)
171191ba
NC		 550 {
551 /* Fill in the remaining spaces. */
7bfd842d
NC		 552 printf ("%-*s", width - num_printed, " ");
553 num_printed = width;
171191ba
NC		 554 }
555
556 return num_printed;
31104126
NC		 557}
558
74e1a04b
NC		 559/* Returns a pointer to a static buffer containing a printable version of
560 the given section's name. Like print_symbol, except that it does not try
561 to print multibyte characters, it just interprets them as hex values. */
562
563static const char *
0d2a7a93 564printable_section_name (const Elf_Internal_Shdr * sec)
74e1a04b
NC		 565{
566#define MAX_PRINT_SEC_NAME_LEN 128
567 static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
568 const char * name = SECTION_NAME (sec);
569 char * buf = sec_name_buf;
570 char c;
571 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
572
573 while ((c = * name ++) != 0)
574 {
575 if (ISCNTRL (c))
576 {
577 if (remaining < 2)
578 break;
948f632f 579
74e1a04b
NC		 580 * buf ++ = '^';
581 * buf ++ = c + 0x40;
582 remaining -= 2;
583 }
584 else if (ISPRINT (c))
585 {
586 * buf ++ = c;
587 remaining -= 1;
588 }
589 else
590 {
591 static char hex[17] = "0123456789ABCDEF";
592
593 if (remaining < 4)
594 break;
595 * buf ++ = '<';
596 * buf ++ = hex[(c & 0xf0) >> 4];
597 * buf ++ = hex[c & 0x0f];
598 * buf ++ = '>';
599 remaining -= 4;
600 }
601
602 if (remaining == 0)
603 break;
604 }
605
606 * buf = 0;
607 return sec_name_buf;
608}
609
610static const char *
611printable_section_name_from_index (unsigned long ndx)
612{
613 if (ndx >= elf_header.e_shnum)
614 return _("<corrupt>");
615
616 return printable_section_name (section_headers + ndx);
617}
618
89fac5e3
RS		 619/* Return a pointer to section NAME, or NULL if no such section exists. */
620
621static Elf_Internal_Shdr *
2cf0635d 622find_section (const char * name)
89fac5e3
RS		 623{
624 unsigned int i;
625
626 for (i = 0; i < elf_header.e_shnum; i++)
627 if (streq (SECTION_NAME (section_headers + i), name))
628 return section_headers + i;
629
630 return NULL;
631}
632
0b6ae522
DJ		 633/* Return a pointer to a section containing ADDR, or NULL if no such
634 section exists. */
635
636static Elf_Internal_Shdr *
637find_section_by_address (bfd_vma addr)
638{
639 unsigned int i;
640
641 for (i = 0; i < elf_header.e_shnum; i++)
642 {
643 Elf_Internal_Shdr *sec = section_headers + i;
644 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
645 return sec;
646 }
647
648 return NULL;
649}
650
071436c6
NC		 651static Elf_Internal_Shdr *
652find_section_by_type (unsigned int type)
653{
654 unsigned int i;
655
656 for (i = 0; i < elf_header.e_shnum; i++)
657 {
658 Elf_Internal_Shdr *sec = section_headers + i;
659 if (sec->sh_type == type)
660 return sec;
661 }
662
663 return NULL;
664}
665
657d0d47
CC		 666/* Return a pointer to section NAME, or NULL if no such section exists,
667 restricted to the list of sections given in SET. */
668
669static Elf_Internal_Shdr *
670find_section_in_set (const char * name, unsigned int * set)
671{
672 unsigned int i;
673
674 if (set != NULL)
675 {
676 while ((i = *set++) > 0)
677 if (streq (SECTION_NAME (section_headers + i), name))
678 return section_headers + i;
679 }
680
681 return find_section (name);
682}
683
0b6ae522
DJ		 684/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
685 bytes read. */
686
f6f0e17b
NC		 687static inline unsigned long
688read_uleb128 (unsigned char *data,
689 unsigned int *length_return,
690 const unsigned char * const end)
0b6ae522 691{
f6f0e17b 692 return read_leb128 (data, length_return, FALSE, end);
0b6ae522
DJ		 693}
694
28f997cf
TG		 695/* Return true if the current file is for IA-64 machine and OpenVMS ABI.
696 This OS has so many departures from the ELF standard that we test it at
697 many places. */
698
699static inline int
700is_ia64_vms (void)
701{
702 return elf_header.e_machine == EM_IA_64
703 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
704}
705
bcedfee6 706/* Guess the relocation size commonly used by the specific machines. */
252b5132 707
252b5132 708static int
2dc4cec1 709guess_is_rela (unsigned int e_machine)
252b5132 710{
9c19a809 711 switch (e_machine)
252b5132
RH		 712 {
713 /* Targets that use REL relocations. */
252b5132 714 case EM_386:
22abe556 715 case EM_IAMCU:
63fcb9e9 716 case EM_960:
e9f53129 717 case EM_ARM:
2b0337b0 718 case EM_D10V:
252b5132 719 case EM_CYGNUS_D10V:
e9f53129 720 case EM_DLX:
252b5132 721 case EM_MIPS:
4fe85591 722 case EM_MIPS_RS3_LE:
e9f53129 723 case EM_CYGNUS_M32R:
1c0d3aa6 724 case EM_SCORE:
f6c1a2d5 725 case EM_XGATE:
9c19a809 726 return FALSE;
103f02d3 727
252b5132
RH		 728 /* Targets that use RELA relocations. */
729 case EM_68K:
e9f53129 730 case EM_860:
a06ea964 731 case EM_AARCH64:
cfb8c092 732 case EM_ADAPTEVA_EPIPHANY:
e9f53129
AM		 733 case EM_ALPHA:
734 case EM_ALTERA_NIOS2:
886a2506
NC		 735 case EM_ARC:
736 case EM_ARC_COMPACT:
737 case EM_ARC_COMPACT2:
e9f53129
AM		 738 case EM_AVR:
739 case EM_AVR_OLD:
740 case EM_BLACKFIN:
60bca95a 741 case EM_CR16:
e9f53129
AM		 742 case EM_CRIS:
743 case EM_CRX:
2b0337b0 744 case EM_D30V:
252b5132 745 case EM_CYGNUS_D30V:
2b0337b0 746 case EM_FR30:
3f8107ab 747 case EM_FT32:
252b5132 748 case EM_CYGNUS_FR30:
5c70f934 749 case EM_CYGNUS_FRV:
e9f53129
AM		 750 case EM_H8S:
751 case EM_H8_300:
752 case EM_H8_300H:
800eeca4 753 case EM_IA_64:
1e4cf259
NC		 754 case EM_IP2K:
755 case EM_IP2K_OLD:
3b36097d 756 case EM_IQ2000:
84e94c90 757 case EM_LATTICEMICO32:
ff7eeb89 758 case EM_M32C_OLD:
49f58d10 759 case EM_M32C:
e9f53129
AM		 760 case EM_M32R:
761 case EM_MCORE:
15ab5209 762 case EM_CYGNUS_MEP:
a3c62988 763 case EM_METAG:
e9f53129
AM		 764 case EM_MMIX:
765 case EM_MN10200:
766 case EM_CYGNUS_MN10200:
767 case EM_MN10300:
768 case EM_CYGNUS_MN10300:
5506d11a 769 case EM_MOXIE:
e9f53129
AM		 770 case EM_MSP430:
771 case EM_MSP430_OLD:
d031aafb 772 case EM_MT:
35c08157 773 case EM_NDS32:
64fd6348 774 case EM_NIOS32:
73589c9d 775 case EM_OR1K:
e9f53129
AM		 776 case EM_PPC64:
777 case EM_PPC:
99c513f6 778 case EM_RL78:
c7927a3c 779 case EM_RX:
e9f53129
AM		 780 case EM_S390:
781 case EM_S390_OLD:
782 case EM_SH:
783 case EM_SPARC:
784 case EM_SPARC32PLUS:
785 case EM_SPARCV9:
786 case EM_SPU:
40b36596 787 case EM_TI_C6000:
aa137e4d
NC		 788 case EM_TILEGX:
789 case EM_TILEPRO:
708e2187 790 case EM_V800:
e9f53129
AM		 791 case EM_V850:
792 case EM_CYGNUS_V850:
793 case EM_VAX:
619ed720 794 case EM_VISIUM:
e9f53129 795 case EM_X86_64:
8a9036a4 796 case EM_L1OM:
7a9068fe 797 case EM_K1OM:
e9f53129
AM		 798 case EM_XSTORMY16:
799 case EM_XTENSA:
800 case EM_XTENSA_OLD:
7ba29e2a
NC		 801 case EM_MICROBLAZE:
802 case EM_MICROBLAZE_OLD:
9c19a809 803 return TRUE;
103f02d3 804
e9f53129
AM		 805 case EM_68HC05:
806 case EM_68HC08:
807 case EM_68HC11:
808 case EM_68HC16:
809 case EM_FX66:
810 case EM_ME16:
d1133906 811 case EM_MMA:
d1133906
NC		 812 case EM_NCPU:
813 case EM_NDR1:
e9f53129 814 case EM_PCP:
d1133906 815 case EM_ST100:
e9f53129 816 case EM_ST19:
d1133906 817 case EM_ST7:
e9f53129
AM		 818 case EM_ST9PLUS:
819 case EM_STARCORE:
d1133906 820 case EM_SVX:
e9f53129 821 case EM_TINYJ:
9c19a809
NC		 822 default:
823 warn (_("Don't know about relocations on this machine architecture\n"));
824 return FALSE;
825 }
826}
252b5132 827
9c19a809 828static int
2cf0635d 829slurp_rela_relocs (FILE * file,
d3ba0551
AM		 830 unsigned long rel_offset,
831 unsigned long rel_size,
2cf0635d
NC		 832 Elf_Internal_Rela ** relasp,
833 unsigned long * nrelasp)
9c19a809 834{
2cf0635d 835 Elf_Internal_Rela * relas;
8b73c356 836 size_t nrelas;
4d6ed7c8 837 unsigned int i;
252b5132 838
4d6ed7c8
NC		 839 if (is_32bit_elf)
840 {
2cf0635d 841 Elf32_External_Rela * erelas;
103f02d3 842
3f5e193b 843 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 844 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 845 if (!erelas)
846 return 0;
252b5132 847
4d6ed7c8 848 nrelas = rel_size / sizeof (Elf32_External_Rela);
103f02d3 849
3f5e193b
NC		 850 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
851 sizeof (Elf_Internal_Rela));
103f02d3 852
4d6ed7c8
NC		 853 if (relas == NULL)
854 {
c256ffe7 855 free (erelas);
591a748a 856 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 857 return 0;
858 }
103f02d3 859
4d6ed7c8
NC		 860 for (i = 0; i < nrelas; i++)
861 {
862 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
863 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 864 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
4d6ed7c8 865 }
103f02d3 866
4d6ed7c8
NC		 867 free (erelas);
868 }
869 else
870 {
2cf0635d 871 Elf64_External_Rela * erelas;
103f02d3 872
3f5e193b 873 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 874 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 875 if (!erelas)
876 return 0;
4d6ed7c8
NC		 877
878 nrelas = rel_size / sizeof (Elf64_External_Rela);
103f02d3 879
3f5e193b
NC		 880 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
881 sizeof (Elf_Internal_Rela));
103f02d3 882
4d6ed7c8
NC		 883 if (relas == NULL)
884 {
c256ffe7 885 free (erelas);
591a748a 886 error (_("out of memory parsing relocs\n"));
4d6ed7c8 887 return 0;
9c19a809 888 }
4d6ed7c8
NC		 889
890 for (i = 0; i < nrelas; i++)
9c19a809 891 {
66543521
AM		 892 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
893 relas[i].r_info = BYTE_GET (erelas[i].r_info);
598aaa76 894 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
861fb55a
DJ		 895
896 /* The #ifdef BFD64 below is to prevent a compile time
897 warning. We know that if we do not have a 64 bit data
898 type that we will never execute this code anyway. */
899#ifdef BFD64
900 if (elf_header.e_machine == EM_MIPS
901 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
902 {
903 /* In little-endian objects, r_info isn't really a
904 64-bit little-endian value: it has a 32-bit
905 little-endian symbol index followed by four
906 individual byte fields. Reorder INFO
907 accordingly. */
91d6fa6a
NC		 908 bfd_vma inf = relas[i].r_info;
909 inf = (((inf & 0xffffffff) << 32)
910 | ((inf >> 56) & 0xff)
911 | ((inf >> 40) & 0xff00)
912 | ((inf >> 24) & 0xff0000)
913 | ((inf >> 8) & 0xff000000));
914 relas[i].r_info = inf;
861fb55a
DJ		 915 }
916#endif /* BFD64 */
4d6ed7c8 917 }
103f02d3 918
4d6ed7c8
NC		 919 free (erelas);
920 }
921 *relasp = relas;
922 *nrelasp = nrelas;
923 return 1;
924}
103f02d3 925
4d6ed7c8 926static int
2cf0635d 927slurp_rel_relocs (FILE * file,
d3ba0551
AM		 928 unsigned long rel_offset,
929 unsigned long rel_size,
2cf0635d
NC		 930 Elf_Internal_Rela ** relsp,
931 unsigned long * nrelsp)
4d6ed7c8 932{
2cf0635d 933 Elf_Internal_Rela * rels;
8b73c356 934 size_t nrels;
4d6ed7c8 935 unsigned int i;
103f02d3 936
4d6ed7c8
NC		 937 if (is_32bit_elf)
938 {
2cf0635d 939 Elf32_External_Rel * erels;
103f02d3 940
3f5e193b 941 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 942 rel_size, _("32-bit relocation data"));
a6e9f9df
AM		 943 if (!erels)
944 return 0;
103f02d3 945
4d6ed7c8 946 nrels = rel_size / sizeof (Elf32_External_Rel);
103f02d3 947
3f5e193b 948 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 949
4d6ed7c8
NC		 950 if (rels == NULL)
951 {
c256ffe7 952 free (erels);
591a748a 953 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 954 return 0;
955 }
956
957 for (i = 0; i < nrels; i++)
958 {
959 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
960 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 961 rels[i].r_addend = 0;
9ea033b2 962 }
4d6ed7c8
NC		 963
964 free (erels);
9c19a809
NC		 965 }
966 else
967 {
2cf0635d 968 Elf64_External_Rel * erels;
9ea033b2 969
3f5e193b 970 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
9cf03b7e 971 rel_size, _("64-bit relocation data"));
a6e9f9df
AM		 972 if (!erels)
973 return 0;
103f02d3 974
4d6ed7c8 975 nrels = rel_size / sizeof (Elf64_External_Rel);
103f02d3 976
3f5e193b 977 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
103f02d3 978
4d6ed7c8 979 if (rels == NULL)
9c19a809 980 {
c256ffe7 981 free (erels);
591a748a 982 error (_("out of memory parsing relocs\n"));
4d6ed7c8
NC		 983 return 0;
984 }
103f02d3 985
4d6ed7c8
NC		 986 for (i = 0; i < nrels; i++)
987 {
66543521
AM		 988 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
989 rels[i].r_info = BYTE_GET (erels[i].r_info);
c8286bd1 990 rels[i].r_addend = 0;
861fb55a
DJ		 991
992 /* The #ifdef BFD64 below is to prevent a compile time
993 warning. We know that if we do not have a 64 bit data
994 type that we will never execute this code anyway. */
995#ifdef BFD64
996 if (elf_header.e_machine == EM_MIPS
997 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
998 {
999 /* In little-endian objects, r_info isn't really a
1000 64-bit little-endian value: it has a 32-bit
1001 little-endian symbol index followed by four
1002 individual byte fields. Reorder INFO
1003 accordingly. */
91d6fa6a
NC		 1004 bfd_vma inf = rels[i].r_info;
1005 inf = (((inf & 0xffffffff) << 32)
1006 | ((inf >> 56) & 0xff)
1007 | ((inf >> 40) & 0xff00)
1008 | ((inf >> 24) & 0xff0000)
1009 | ((inf >> 8) & 0xff000000));
1010 rels[i].r_info = inf;
861fb55a
DJ		 1011 }
1012#endif /* BFD64 */
4d6ed7c8 1013 }
103f02d3 1014
4d6ed7c8
NC		 1015 free (erels);
1016 }
1017 *relsp = rels;
1018 *nrelsp = nrels;
1019 return 1;
1020}
103f02d3 1021
aca88567
NC		 1022/* Returns the reloc type extracted from the reloc info field. */
1023
1024static unsigned int
1025get_reloc_type (bfd_vma reloc_info)
1026{
1027 if (is_32bit_elf)
1028 return ELF32_R_TYPE (reloc_info);
1029
1030 switch (elf_header.e_machine)
1031 {
1032 case EM_MIPS:
1033 /* Note: We assume that reloc_info has already been adjusted for us. */
1034 return ELF64_MIPS_R_TYPE (reloc_info);
1035
1036 case EM_SPARCV9:
1037 return ELF64_R_TYPE_ID (reloc_info);
1038
1039 default:
1040 return ELF64_R_TYPE (reloc_info);
1041 }
1042}
1043
1044/* Return the symbol index extracted from the reloc info field. */
1045
1046static bfd_vma
1047get_reloc_symindex (bfd_vma reloc_info)
1048{
1049 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1050}
1051
13761a11
NC		 1052static inline bfd_boolean
1053uses_msp430x_relocs (void)
1054{
1055 return
1056 elf_header.e_machine == EM_MSP430 /* Paranoia. */
1057 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1058 && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1059 /* TI compiler uses ELFOSABI_NONE. */
1060 || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1061}
1062
d3ba0551
AM		 1063/* Display the contents of the relocation data found at the specified
1064 offset. */
ee42cf8c 1065
41e92641 1066static void
2cf0635d 1067dump_relocations (FILE * file,
d3ba0551
AM		 1068 unsigned long rel_offset,
1069 unsigned long rel_size,
2cf0635d 1070 Elf_Internal_Sym * symtab,
d3ba0551 1071 unsigned long nsyms,
2cf0635d 1072 char * strtab,
d79b3d50 1073 unsigned long strtablen,
bb4d2ac2
L		 1074 int is_rela,
1075 int is_dynsym)
4d6ed7c8 1076{
b34976b6 1077 unsigned int i;
2cf0635d 1078 Elf_Internal_Rela * rels;
103f02d3 1079
4d6ed7c8
NC		 1080 if (is_rela == UNKNOWN)
1081 is_rela = guess_is_rela (elf_header.e_machine);
103f02d3 1082
4d6ed7c8
NC		 1083 if (is_rela)
1084 {
c8286bd1 1085 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 1086 return;
4d6ed7c8
NC		 1087 }
1088 else
1089 {
1090 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
41e92641 1091 return;
252b5132
RH		 1092 }
1093
410f7a12
L		 1094 if (is_32bit_elf)
1095 {
1096 if (is_rela)
2c71103e
NC		 1097 {
1098 if (do_wide)
1099 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1100 else
1101 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1102 }
410f7a12 1103 else
2c71103e
NC		 1104 {
1105 if (do_wide)
1106 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1107 else
1108 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1109 }
410f7a12 1110 }
252b5132 1111 else
410f7a12
L		 1112 {
1113 if (is_rela)
2c71103e
NC		 1114 {
1115 if (do_wide)
8beeaeb7 1116 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
2c71103e
NC		 1117 else
1118 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1119 }
410f7a12 1120 else
2c71103e
NC		 1121 {
1122 if (do_wide)
8beeaeb7 1123 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
2c71103e
NC		 1124 else
1125 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1126 }
410f7a12 1127 }
252b5132
RH		 1128
1129 for (i = 0; i < rel_size; i++)
1130 {
2cf0635d 1131 const char * rtype;
b34976b6 1132 bfd_vma offset;
91d6fa6a 1133 bfd_vma inf;
b34976b6
AM		 1134 bfd_vma symtab_index;
1135 bfd_vma type;
103f02d3 1136
b34976b6 1137 offset = rels[i].r_offset;
91d6fa6a 1138 inf = rels[i].r_info;
103f02d3 1139
91d6fa6a
NC		 1140 type = get_reloc_type (inf);
1141 symtab_index = get_reloc_symindex (inf);
252b5132 1142
410f7a12
L		 1143 if (is_32bit_elf)
1144 {
39dbeff8
AM		 1145 printf ("%8.8lx %8.8lx ",
1146 (unsigned long) offset & 0xffffffff,
91d6fa6a 1147 (unsigned long) inf & 0xffffffff);
410f7a12
L		 1148 }
1149 else
1150 {
39dbeff8
AM		 1151#if BFD_HOST_64BIT_LONG
1152 printf (do_wide
1153 ? "%16.16lx %16.16lx "
1154 : "%12.12lx %12.12lx ",
91d6fa6a 1155 offset, inf);
39dbeff8 1156#elif BFD_HOST_64BIT_LONG_LONG
6e3d6dc1 1157#ifndef __MSVCRT__
39dbeff8
AM		 1158 printf (do_wide
1159 ? "%16.16llx %16.16llx "
1160 : "%12.12llx %12.12llx ",
91d6fa6a 1161 offset, inf);
6e3d6dc1
NC		 1162#else
1163 printf (do_wide
1164 ? "%16.16I64x %16.16I64x "
1165 : "%12.12I64x %12.12I64x ",
91d6fa6a 1166 offset, inf);
6e3d6dc1 1167#endif
39dbeff8 1168#else
2c71103e
NC		 1169 printf (do_wide
1170 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1171 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
410f7a12
L		 1172 _bfd_int64_high (offset),
1173 _bfd_int64_low (offset),
91d6fa6a
NC		 1174 _bfd_int64_high (inf),
1175 _bfd_int64_low (inf));
9ea033b2 1176#endif
410f7a12 1177 }
103f02d3 1178
252b5132
RH		 1179 switch (elf_header.e_machine)
1180 {
1181 default:
1182 rtype = NULL;
1183 break;
1184
a06ea964
NC		 1185 case EM_AARCH64:
1186 rtype = elf_aarch64_reloc_type (type);
1187 break;
1188
2b0337b0 1189 case EM_M32R:
252b5132 1190 case EM_CYGNUS_M32R:
9ea033b2 1191 rtype = elf_m32r_reloc_type (type);
252b5132
RH		 1192 break;
1193
1194 case EM_386:
22abe556 1195 case EM_IAMCU:
9ea033b2 1196 rtype = elf_i386_reloc_type (type);
252b5132
RH		 1197 break;
1198
ba2685cc
AM		 1199 case EM_68HC11:
1200 case EM_68HC12:
1201 rtype = elf_m68hc11_reloc_type (type);
1202 break;
75751cd9 1203
252b5132 1204 case EM_68K:
9ea033b2 1205 rtype = elf_m68k_reloc_type (type);
252b5132
RH		 1206 break;
1207
63fcb9e9 1208 case EM_960:
9ea033b2 1209 rtype = elf_i960_reloc_type (type);
63fcb9e9
ILT		 1210 break;
1211
adde6300 1212 case EM_AVR:
2b0337b0 1213 case EM_AVR_OLD:
adde6300
AM		 1214 rtype = elf_avr_reloc_type (type);
1215 break;
1216
9ea033b2
NC		 1217 case EM_OLD_SPARCV9:
1218 case EM_SPARC32PLUS:
1219 case EM_SPARCV9:
252b5132 1220 case EM_SPARC:
9ea033b2 1221 rtype = elf_sparc_reloc_type (type);
252b5132
RH		 1222 break;
1223
e9f53129
AM		 1224 case EM_SPU:
1225 rtype = elf_spu_reloc_type (type);
1226 break;
1227
708e2187
NC		 1228 case EM_V800:
1229 rtype = v800_reloc_type (type);
1230 break;
2b0337b0 1231 case EM_V850:
252b5132 1232 case EM_CYGNUS_V850:
9ea033b2 1233 rtype = v850_reloc_type (type);
252b5132
RH		 1234 break;
1235
2b0337b0 1236 case EM_D10V:
252b5132 1237 case EM_CYGNUS_D10V:
9ea033b2 1238 rtype = elf_d10v_reloc_type (type);
252b5132
RH		 1239 break;
1240
2b0337b0 1241 case EM_D30V:
252b5132 1242 case EM_CYGNUS_D30V:
9ea033b2 1243 rtype = elf_d30v_reloc_type (type);
252b5132
RH		 1244 break;
1245
d172d4ba
NC		 1246 case EM_DLX:
1247 rtype = elf_dlx_reloc_type (type);
1248 break;
1249
252b5132 1250 case EM_SH:
9ea033b2 1251 rtype = elf_sh_reloc_type (type);
252b5132
RH		 1252 break;
1253
2b0337b0 1254 case EM_MN10300:
252b5132 1255 case EM_CYGNUS_MN10300:
9ea033b2 1256 rtype = elf_mn10300_reloc_type (type);
252b5132
RH		 1257 break;
1258
2b0337b0 1259 case EM_MN10200:
252b5132 1260 case EM_CYGNUS_MN10200:
9ea033b2 1261 rtype = elf_mn10200_reloc_type (type);
252b5132
RH		 1262 break;
1263
2b0337b0 1264 case EM_FR30:
252b5132 1265 case EM_CYGNUS_FR30:
9ea033b2 1266 rtype = elf_fr30_reloc_type (type);
252b5132
RH		 1267 break;
1268
ba2685cc
AM		 1269 case EM_CYGNUS_FRV:
1270 rtype = elf_frv_reloc_type (type);
1271 break;
5c70f934 1272
3f8107ab
AM		 1273 case EM_FT32:
1274 rtype = elf_ft32_reloc_type (type);
1275 break;
1276
252b5132 1277 case EM_MCORE:
9ea033b2 1278 rtype = elf_mcore_reloc_type (type);
252b5132
RH		 1279 break;
1280
3c3bdf30
NC		 1281 case EM_MMIX:
1282 rtype = elf_mmix_reloc_type (type);
1283 break;
1284
5506d11a
AM		 1285 case EM_MOXIE:
1286 rtype = elf_moxie_reloc_type (type);
1287 break;
1288
2469cfa2 1289 case EM_MSP430:
13761a11
NC		 1290 if (uses_msp430x_relocs ())
1291 {
1292 rtype = elf_msp430x_reloc_type (type);
1293 break;
1294 }
2469cfa2
NC		 1295 case EM_MSP430_OLD:
1296 rtype = elf_msp430_reloc_type (type);
1297 break;
1298
35c08157
KLC		 1299 case EM_NDS32:
1300 rtype = elf_nds32_reloc_type (type);
1301 break;
1302
252b5132 1303 case EM_PPC:
9ea033b2 1304 rtype = elf_ppc_reloc_type (type);
252b5132
RH		 1305 break;
1306
c833c019
AM		 1307 case EM_PPC64:
1308 rtype = elf_ppc64_reloc_type (type);
1309 break;
1310
252b5132 1311 case EM_MIPS:
4fe85591 1312 case EM_MIPS_RS3_LE:
9ea033b2 1313 rtype = elf_mips_reloc_type (type);
252b5132
RH		 1314 break;
1315
1316 case EM_ALPHA:
9ea033b2 1317 rtype = elf_alpha_reloc_type (type);
252b5132
RH		 1318 break;
1319
1320 case EM_ARM:
9ea033b2 1321 rtype = elf_arm_reloc_type (type);
252b5132
RH		 1322 break;
1323
584da044 1324 case EM_ARC:
886a2506
NC		 1325 case EM_ARC_COMPACT:
1326 case EM_ARC_COMPACT2:
9ea033b2 1327 rtype = elf_arc_reloc_type (type);
252b5132
RH		 1328 break;
1329
1330 case EM_PARISC:
69e617ca 1331 rtype = elf_hppa_reloc_type (type);
252b5132 1332 break;
7d466069 1333
b8720f9d
JL		 1334 case EM_H8_300:
1335 case EM_H8_300H:
1336 case EM_H8S:
1337 rtype = elf_h8_reloc_type (type);
1338 break;
1339
73589c9d
CS		 1340 case EM_OR1K:
1341 rtype = elf_or1k_reloc_type (type);
3b16e843
NC		 1342 break;
1343
7d466069 1344 case EM_PJ:
2b0337b0 1345 case EM_PJ_OLD:
7d466069
ILT		 1346 rtype = elf_pj_reloc_type (type);
1347 break;
800eeca4
JW		 1348 case EM_IA_64:
1349 rtype = elf_ia64_reloc_type (type);
1350 break;
1b61cf92
HPN		 1351
1352 case EM_CRIS:
1353 rtype = elf_cris_reloc_type (type);
1354 break;
535c37ff
JE		 1355
1356 case EM_860:
1357 rtype = elf_i860_reloc_type (type);
1358 break;
bcedfee6
NC		 1359
1360 case EM_X86_64:
8a9036a4 1361 case EM_L1OM:
7a9068fe 1362 case EM_K1OM:
bcedfee6
NC		 1363 rtype = elf_x86_64_reloc_type (type);
1364 break;
a85d7ed0 1365
35b1837e
AM		 1366 case EM_S370:
1367 rtype = i370_reloc_type (type);
1368 break;
1369
53c7db4b
KH		 1370 case EM_S390_OLD:
1371 case EM_S390:
1372 rtype = elf_s390_reloc_type (type);
1373 break;
93fbbb04 1374
1c0d3aa6
NC		 1375 case EM_SCORE:
1376 rtype = elf_score_reloc_type (type);
1377 break;
1378
93fbbb04
GK		 1379 case EM_XSTORMY16:
1380 rtype = elf_xstormy16_reloc_type (type);
1381 break;
179d3252 1382
1fe1f39c
NC		 1383 case EM_CRX:
1384 rtype = elf_crx_reloc_type (type);
1385 break;
1386
179d3252
JT		 1387 case EM_VAX:
1388 rtype = elf_vax_reloc_type (type);
1389 break;
1e4cf259 1390
619ed720
EB		 1391 case EM_VISIUM:
1392 rtype = elf_visium_reloc_type (type);
1393 break;
1394
cfb8c092
NC		 1395 case EM_ADAPTEVA_EPIPHANY:
1396 rtype = elf_epiphany_reloc_type (type);
1397 break;
1398
1e4cf259
NC		 1399 case EM_IP2K:
1400 case EM_IP2K_OLD:
1401 rtype = elf_ip2k_reloc_type (type);
1402 break;
3b36097d
SC		 1403
1404 case EM_IQ2000:
1405 rtype = elf_iq2000_reloc_type (type);
1406 break;
88da6820
NC		 1407
1408 case EM_XTENSA_OLD:
1409 case EM_XTENSA:
1410 rtype = elf_xtensa_reloc_type (type);
1411 break;
a34e3ecb 1412
84e94c90
NC		 1413 case EM_LATTICEMICO32:
1414 rtype = elf_lm32_reloc_type (type);
1415 break;
1416
ff7eeb89 1417 case EM_M32C_OLD:
49f58d10
JB		 1418 case EM_M32C:
1419 rtype = elf_m32c_reloc_type (type);
1420 break;
1421
d031aafb
NS		 1422 case EM_MT:
1423 rtype = elf_mt_reloc_type (type);
a34e3ecb 1424 break;
1d65ded4
CM		 1425
1426 case EM_BLACKFIN:
1427 rtype = elf_bfin_reloc_type (type);
1428 break;
15ab5209
DB		 1429
1430 case EM_CYGNUS_MEP:
1431 rtype = elf_mep_reloc_type (type);
1432 break;
60bca95a
NC		 1433
1434 case EM_CR16:
1435 rtype = elf_cr16_reloc_type (type);
1436 break;
dd24e3da 1437
7ba29e2a
NC		 1438 case EM_MICROBLAZE:
1439 case EM_MICROBLAZE_OLD:
1440 rtype = elf_microblaze_reloc_type (type);
1441 break;
c7927a3c 1442
99c513f6
DD		 1443 case EM_RL78:
1444 rtype = elf_rl78_reloc_type (type);
1445 break;
1446
c7927a3c
NC		 1447 case EM_RX:
1448 rtype = elf_rx_reloc_type (type);
1449 break;
c29aca4a 1450
a3c62988
NC		 1451 case EM_METAG:
1452 rtype = elf_metag_reloc_type (type);
1453 break;
1454
c29aca4a
NC		 1455 case EM_XC16X:
1456 case EM_C166:
1457 rtype = elf_xc16x_reloc_type (type);
1458 break;
40b36596
JM		 1459
1460 case EM_TI_C6000:
1461 rtype = elf_tic6x_reloc_type (type);
1462 break;
aa137e4d
NC		 1463
1464 case EM_TILEGX:
1465 rtype = elf_tilegx_reloc_type (type);
1466 break;
1467
1468 case EM_TILEPRO:
1469 rtype = elf_tilepro_reloc_type (type);
1470 break;
f6c1a2d5
NC		 1471
1472 case EM_XGATE:
1473 rtype = elf_xgate_reloc_type (type);
1474 break;
36591ba1
SL		 1475
1476 case EM_ALTERA_NIOS2:
1477 rtype = elf_nios2_reloc_type (type);
1478 break;
252b5132
RH		 1479 }
1480
1481 if (rtype == NULL)
39dbeff8 1482 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
252b5132 1483 else
8beeaeb7 1484 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
252b5132 1485
7ace3541 1486 if (elf_header.e_machine == EM_ALPHA
157c2599 1487 && rtype != NULL
7ace3541
RH		 1488 && streq (rtype, "R_ALPHA_LITUSE")
1489 && is_rela)
1490 {
1491 switch (rels[i].r_addend)
1492 {
1493 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1494 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1495 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1496 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1497 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1498 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1499 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1500 default: rtype = NULL;
1501 }
1502 if (rtype)
1503 printf (" (%s)", rtype);
1504 else
1505 {
1506 putchar (' ');
1507 printf (_("<unknown addend: %lx>"),
1508 (unsigned long) rels[i].r_addend);
1509 }
1510 }
1511 else if (symtab_index)
252b5132 1512 {
af3fc3bc 1513 if (symtab == NULL || symtab_index >= nsyms)
2b692964 1514 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
af3fc3bc 1515 else
19936277 1516 {
2cf0635d 1517 Elf_Internal_Sym * psym;
bb4d2ac2
L		 1518 const char * version_string;
1519 enum versioned_symbol_info sym_info;
1520 unsigned short vna_other;
19936277 1521
af3fc3bc 1522 psym = symtab + symtab_index;
103f02d3 1523
bb4d2ac2
L		 1524 version_string
1525 = get_symbol_version_string (file, is_dynsym,
1526 strtab, strtablen,
1527 symtab_index,
1528 psym,
1529 &sym_info,
1530 &vna_other);
1531
af3fc3bc 1532 printf (" ");
171191ba 1533
d8045f23
NC		 1534 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1535 {
1536 const char * name;
1537 unsigned int len;
1538 unsigned int width = is_32bit_elf ? 8 : 14;
1539
1540 /* Relocations against GNU_IFUNC symbols do not use the value
1541 of the symbol as the address to relocate against. Instead
1542 they invoke the function named by the symbol and use its
1543 result as the address for relocation.
1544
1545 To indicate this to the user, do not display the value of
1546 the symbol in the "Symbols's Value" field. Instead show
1547 its name followed by () as a hint that the symbol is
1548 invoked. */
1549
1550 if (strtab == NULL
1551 || psym->st_name == 0
1552 || psym->st_name >= strtablen)
1553 name = "??";
1554 else
1555 name = strtab + psym->st_name;
1556
1557 len = print_symbol (width, name);
bb4d2ac2
L		 1558 if (version_string)
1559 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1560 version_string);
d8045f23
NC		 1561 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1562 }
1563 else
1564 {
1565 print_vma (psym->st_value, LONG_HEX);
171191ba 1566
d8045f23
NC		 1567 printf (is_32bit_elf ? " " : " ");
1568 }
103f02d3 1569
af3fc3bc 1570 if (psym->st_name == 0)
f1ef08cb 1571 {
2cf0635d 1572 const char * sec_name = "<null>";
f1ef08cb
AM		 1573 char name_buf[40];
1574
1575 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1576 {
4fbb74a6 1577 if (psym->st_shndx < elf_header.e_shnum)
74e1a04b 1578 sec_name = SECTION_NAME (section_headers + psym->st_shndx);
f1ef08cb
AM		 1579 else if (psym->st_shndx == SHN_ABS)
1580 sec_name = "ABS";
1581 else if (psym->st_shndx == SHN_COMMON)
1582 sec_name = "COMMON";
ac145307
BS		 1583 else if ((elf_header.e_machine == EM_MIPS
1584 && psym->st_shndx == SHN_MIPS_SCOMMON)
1585 || (elf_header.e_machine == EM_TI_C6000
1586 && psym->st_shndx == SHN_TIC6X_SCOMMON))
172553c7
TS		 1587 sec_name = "SCOMMON";
1588 else if (elf_header.e_machine == EM_MIPS
1589 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1590 sec_name = "SUNDEF";
8a9036a4 1591 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 1592 || elf_header.e_machine == EM_L1OM
1593 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 1594 && psym->st_shndx == SHN_X86_64_LCOMMON)
1595 sec_name = "LARGE_COMMON";
9ce701e2
L		 1596 else if (elf_header.e_machine == EM_IA_64
1597 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1598 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1599 sec_name = "ANSI_COM";
28f997cf 1600 else if (is_ia64_vms ()
148b93f2
NC		 1601 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1602 sec_name = "VMS_SYMVEC";
f1ef08cb
AM		 1603 else
1604 {
1605 sprintf (name_buf, "<section 0x%x>",
1606 (unsigned int) psym->st_shndx);
1607 sec_name = name_buf;
1608 }
1609 }
1610 print_symbol (22, sec_name);
1611 }
af3fc3bc 1612 else if (strtab == NULL)
d79b3d50 1613 printf (_("<string table index: %3ld>"), psym->st_name);
c256ffe7 1614 else if (psym->st_name >= strtablen)
d79b3d50 1615 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
af3fc3bc 1616 else
bb4d2ac2
L		 1617 {
1618 print_symbol (22, strtab + psym->st_name);
1619 if (version_string)
1620 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1621 version_string);
1622 }
103f02d3 1623
af3fc3bc 1624 if (is_rela)
171191ba 1625 {
7360e63f 1626 bfd_vma off = rels[i].r_addend;
171191ba 1627
7360e63f 1628 if ((bfd_signed_vma) off < 0)
598aaa76 1629 printf (" - %" BFD_VMA_FMT "x", - off);
171191ba 1630 else
598aaa76 1631 printf (" + %" BFD_VMA_FMT "x", off);
171191ba 1632 }
19936277 1633 }
252b5132 1634 }
1b228002 1635 else if (is_rela)
f7a99963 1636 {
7360e63f 1637 bfd_vma off = rels[i].r_addend;
e04d7088
L		 1638
1639 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
7360e63f 1640 if ((bfd_signed_vma) off < 0)
e04d7088
L		 1641 printf ("-%" BFD_VMA_FMT "x", - off);
1642 else
1643 printf ("%" BFD_VMA_FMT "x", off);
f7a99963 1644 }
252b5132 1645
157c2599
NC		 1646 if (elf_header.e_machine == EM_SPARCV9
1647 && rtype != NULL
1648 && streq (rtype, "R_SPARC_OLO10"))
91d6fa6a 1649 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
351b4b40 1650
252b5132 1651 putchar ('\n');
2c71103e 1652
aca88567 1653#ifdef BFD64
53c7db4b 1654 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
2c71103e 1655 {
91d6fa6a
NC		 1656 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1657 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
2cf0635d
NC		 1658 const char * rtype2 = elf_mips_reloc_type (type2);
1659 const char * rtype3 = elf_mips_reloc_type (type3);
aca88567 1660
2c71103e
NC		 1661 printf (" Type2: ");
1662
1663 if (rtype2 == NULL)
39dbeff8
AM		 1664 printf (_("unrecognized: %-7lx"),
1665 (unsigned long) type2 & 0xffffffff);
2c71103e
NC		 1666 else
1667 printf ("%-17.17s", rtype2);
1668
18bd398b 1669 printf ("\n Type3: ");
2c71103e
NC		 1670
1671 if (rtype3 == NULL)
39dbeff8
AM		 1672 printf (_("unrecognized: %-7lx"),
1673 (unsigned long) type3 & 0xffffffff);
2c71103e
NC		 1674 else
1675 printf ("%-17.17s", rtype3);
1676
53c7db4b 1677 putchar ('\n');
2c71103e 1678 }
aca88567 1679#endif /* BFD64 */
252b5132
RH		 1680 }
1681
c8286bd1 1682 free (rels);
252b5132
RH		 1683}
1684
1685static const char *
d3ba0551 1686get_mips_dynamic_type (unsigned long type)
252b5132
RH		 1687{
1688 switch (type)
1689 {
1690 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1691 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1692 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1693 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1694 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1695 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1696 case DT_MIPS_MSYM: return "MIPS_MSYM";
1697 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1698 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1699 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1700 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1701 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1702 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1703 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1704 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1705 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1706 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
a5499fa4 1707 case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
252b5132
RH		 1708 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1709 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1710 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1711 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1712 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1713 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1714 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1715 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1716 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1717 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1718 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1719 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1720 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1721 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1722 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1723 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1724 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1725 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1726 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1727 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1728 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1729 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1730 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1731 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1732 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1733 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
861fb55a
DJ		 1734 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1735 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
252b5132
RH		 1736 default:
1737 return NULL;
1738 }
1739}
1740
9a097730 1741static const char *
d3ba0551 1742get_sparc64_dynamic_type (unsigned long type)
9a097730
RH		 1743{
1744 switch (type)
1745 {
1746 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1747 default:
1748 return NULL;
1749 }
103f02d3
UD		 1750}
1751
7490d522
AM		 1752static const char *
1753get_ppc_dynamic_type (unsigned long type)
1754{
1755 switch (type)
1756 {
a7f2871e 1757 case DT_PPC_GOT: return "PPC_GOT";
e8910a83 1758 case DT_PPC_OPT: return "PPC_OPT";
7490d522
AM		 1759 default:
1760 return NULL;
1761 }
1762}
1763
f1cb7e17 1764static const char *
d3ba0551 1765get_ppc64_dynamic_type (unsigned long type)
f1cb7e17
AM		 1766{
1767 switch (type)
1768 {
a7f2871e
AM		 1769 case DT_PPC64_GLINK: return "PPC64_GLINK";
1770 case DT_PPC64_OPD: return "PPC64_OPD";
1771 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
e8910a83 1772 case DT_PPC64_OPT: return "PPC64_OPT";
f1cb7e17
AM		 1773 default:
1774 return NULL;
1775 }
1776}
1777
103f02d3 1778static const char *
d3ba0551 1779get_parisc_dynamic_type (unsigned long type)
103f02d3
UD		 1780{
1781 switch (type)
1782 {
1783 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1784 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1785 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1786 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1787 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1788 case DT_HP_PREINIT: return "HP_PREINIT";
1789 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1790 case DT_HP_NEEDED: return "HP_NEEDED";
1791 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1792 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1793 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1794 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1795 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
eec8f817
DA		 1796 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1797 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1798 case DT_HP_FILTERED: return "HP_FILTERED";
1799 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1800 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1801 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1802 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1803 case DT_PLT: return "PLT";
1804 case DT_PLT_SIZE: return "PLT_SIZE";
1805 case DT_DLT: return "DLT";
1806 case DT_DLT_SIZE: return "DLT_SIZE";
103f02d3
UD		 1807 default:
1808 return NULL;
1809 }
1810}
9a097730 1811
ecc51f48 1812static const char *
d3ba0551 1813get_ia64_dynamic_type (unsigned long type)
ecc51f48
NC		 1814{
1815 switch (type)
1816 {
148b93f2
NC		 1817 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1818 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1819 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1820 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1821 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1822 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1823 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1824 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1825 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1826 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1827 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1828 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1829 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1830 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1831 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1832 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1833 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1834 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1835 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1836 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1837 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1838 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1839 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1840 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1841 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1842 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1843 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1844 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1845 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1846 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1847 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
ecc51f48
NC		 1848 default:
1849 return NULL;
1850 }
1851}
1852
fd85a6a1
NC		 1853static const char *
1854get_solaris_section_type (unsigned long type)
1855{
1856 switch (type)
1857 {
1858 case 0x6fffffee: return "SUNW_ancillary";
1859 case 0x6fffffef: return "SUNW_capchain";
1860 case 0x6ffffff0: return "SUNW_capinfo";
1861 case 0x6ffffff1: return "SUNW_symsort";
1862 case 0x6ffffff2: return "SUNW_tlssort";
1863 case 0x6ffffff3: return "SUNW_LDYNSYM";
1864 case 0x6ffffff4: return "SUNW_dof";
1865 case 0x6ffffff5: return "SUNW_cap";
1866 case 0x6ffffff6: return "SUNW_SIGNATURE";
1867 case 0x6ffffff7: return "SUNW_ANNOTATE";
1868 case 0x6ffffff8: return "SUNW_DEBUGSTR";
1869 case 0x6ffffff9: return "SUNW_DEBUG";
1870 case 0x6ffffffa: return "SUNW_move";
1871 case 0x6ffffffb: return "SUNW_COMDAT";
1872 case 0x6ffffffc: return "SUNW_syminfo";
1873 case 0x6ffffffd: return "SUNW_verdef";
1874 case 0x6ffffffe: return "SUNW_verneed";
1875 case 0x6fffffff: return "SUNW_versym";
1876 case 0x70000000: return "SPARC_GOTDATA";
1877 default: return NULL;
1878 }
1879}
1880
fabcb361
RH		 1881static const char *
1882get_alpha_dynamic_type (unsigned long type)
1883{
1884 switch (type)
1885 {
1886 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1887 default:
1888 return NULL;
1889 }
1890}
1891
1c0d3aa6
NC		 1892static const char *
1893get_score_dynamic_type (unsigned long type)
1894{
1895 switch (type)
1896 {
1897 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1898 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1899 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1900 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1901 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1902 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1903 default:
1904 return NULL;
1905 }
1906}
1907
40b36596
JM		 1908static const char *
1909get_tic6x_dynamic_type (unsigned long type)
1910{
1911 switch (type)
1912 {
1913 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1914 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1915 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1916 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1917 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1918 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1919 default:
1920 return NULL;
1921 }
1922}
1c0d3aa6 1923
36591ba1
SL		 1924static const char *
1925get_nios2_dynamic_type (unsigned long type)
1926{
1927 switch (type)
1928 {
1929 case DT_NIOS2_GP: return "NIOS2_GP";
1930 default:
1931 return NULL;
1932 }
1933}
1934
fd85a6a1
NC		 1935static const char *
1936get_solaris_dynamic_type (unsigned long type)
1937{
1938 switch (type)
1939 {
1940 case 0x6000000d: return "SUNW_AUXILIARY";
1941 case 0x6000000e: return "SUNW_RTLDINF";
1942 case 0x6000000f: return "SUNW_FILTER";
1943 case 0x60000010: return "SUNW_CAP";
1944 case 0x60000011: return "SUNW_SYMTAB";
1945 case 0x60000012: return "SUNW_SYMSZ";
1946 case 0x60000013: return "SUNW_SORTENT";
1947 case 0x60000014: return "SUNW_SYMSORT";
1948 case 0x60000015: return "SUNW_SYMSORTSZ";
1949 case 0x60000016: return "SUNW_TLSSORT";
1950 case 0x60000017: return "SUNW_TLSSORTSZ";
1951 case 0x60000018: return "SUNW_CAPINFO";
1952 case 0x60000019: return "SUNW_STRPAD";
1953 case 0x6000001a: return "SUNW_CAPCHAIN";
1954 case 0x6000001b: return "SUNW_LDMACH";
1955 case 0x6000001d: return "SUNW_CAPCHAINENT";
1956 case 0x6000001f: return "SUNW_CAPCHAINSZ";
1957 case 0x60000021: return "SUNW_PARENT";
1958 case 0x60000023: return "SUNW_ASLR";
1959 case 0x60000025: return "SUNW_RELAX";
1960 case 0x60000029: return "SUNW_NXHEAP";
1961 case 0x6000002b: return "SUNW_NXSTACK";
1962
1963 case 0x70000001: return "SPARC_REGISTER";
1964 case 0x7ffffffd: return "AUXILIARY";
1965 case 0x7ffffffe: return "USED";
1966 case 0x7fffffff: return "FILTER";
1967
1968 default: return NULL;
1969 }
1970}
1971
252b5132 1972static const char *
d3ba0551 1973get_dynamic_type (unsigned long type)
252b5132 1974{
e9e44622 1975 static char buff[64];
252b5132
RH		 1976
1977 switch (type)
1978 {
1979 case DT_NULL: return "NULL";
1980 case DT_NEEDED: return "NEEDED";
1981 case DT_PLTRELSZ: return "PLTRELSZ";
1982 case DT_PLTGOT: return "PLTGOT";
1983 case DT_HASH: return "HASH";
1984 case DT_STRTAB: return "STRTAB";
1985 case DT_SYMTAB: return "SYMTAB";
1986 case DT_RELA: return "RELA";
1987 case DT_RELASZ: return "RELASZ";
1988 case DT_RELAENT: return "RELAENT";
1989 case DT_STRSZ: return "STRSZ";
1990 case DT_SYMENT: return "SYMENT";
1991 case DT_INIT: return "INIT";
1992 case DT_FINI: return "FINI";
1993 case DT_SONAME: return "SONAME";
1994 case DT_RPATH: return "RPATH";
1995 case DT_SYMBOLIC: return "SYMBOLIC";
1996 case DT_REL: return "REL";
1997 case DT_RELSZ: return "RELSZ";
1998 case DT_RELENT: return "RELENT";
1999 case DT_PLTREL: return "PLTREL";
2000 case DT_DEBUG: return "DEBUG";
2001 case DT_TEXTREL: return "TEXTREL";
2002 case DT_JMPREL: return "JMPREL";
2003 case DT_BIND_NOW: return "BIND_NOW";
2004 case DT_INIT_ARRAY: return "INIT_ARRAY";
2005 case DT_FINI_ARRAY: return "FINI_ARRAY";
2006 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2007 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 2008 case DT_RUNPATH: return "RUNPATH";
2009 case DT_FLAGS: return "FLAGS";
2d0e6f43 2010
d1133906
NC		 2011 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2012 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
103f02d3 2013
05107a46 2014 case DT_CHECKSUM: return "CHECKSUM";
252b5132
RH		 2015 case DT_PLTPADSZ: return "PLTPADSZ";
2016 case DT_MOVEENT: return "MOVEENT";
2017 case DT_MOVESZ: return "MOVESZ";
dcefbbbd 2018 case DT_FEATURE: return "FEATURE";
252b5132
RH		 2019 case DT_POSFLAG_1: return "POSFLAG_1";
2020 case DT_SYMINSZ: return "SYMINSZ";
2021 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 2022
252b5132 2023 case DT_ADDRRNGLO: return "ADDRRNGLO";
dcefbbbd
L		 2024 case DT_CONFIG: return "CONFIG";
2025 case DT_DEPAUDIT: return "DEPAUDIT";
2026 case DT_AUDIT: return "AUDIT";
2027 case DT_PLTPAD: return "PLTPAD";
2028 case DT_MOVETAB: return "MOVETAB";
252b5132 2029 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 2030
252b5132 2031 case DT_VERSYM: return "VERSYM";
103f02d3 2032
67a4f2b7
AO		 2033 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2034 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
252b5132
RH		 2035 case DT_RELACOUNT: return "RELACOUNT";
2036 case DT_RELCOUNT: return "RELCOUNT";
2037 case DT_FLAGS_1: return "FLAGS_1";
2038 case DT_VERDEF: return "VERDEF";
2039 case DT_VERDEFNUM: return "VERDEFNUM";
2040 case DT_VERNEED: return "VERNEED";
2041 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 2042
019148e4 2043 case DT_AUXILIARY: return "AUXILIARY";
252b5132
RH		 2044 case DT_USED: return "USED";
2045 case DT_FILTER: return "FILTER";
103f02d3 2046
047b2264
JJ		 2047 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2048 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2049 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2050 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2051 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
fdc90cb4 2052 case DT_GNU_HASH: return "GNU_HASH";
047b2264 2053
252b5132
RH		 2054 default:
2055 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2056 {
2cf0635d 2057 const char * result;
103f02d3 2058
252b5132
RH		 2059 switch (elf_header.e_machine)
2060 {
2061 case EM_MIPS:
4fe85591 2062 case EM_MIPS_RS3_LE:
252b5132
RH		 2063 result = get_mips_dynamic_type (type);
2064 break;
9a097730
RH		 2065 case EM_SPARCV9:
2066 result = get_sparc64_dynamic_type (type);
2067 break;
7490d522
AM		 2068 case EM_PPC:
2069 result = get_ppc_dynamic_type (type);
2070 break;
f1cb7e17
AM		 2071 case EM_PPC64:
2072 result = get_ppc64_dynamic_type (type);
2073 break;
ecc51f48
NC		 2074 case EM_IA_64:
2075 result = get_ia64_dynamic_type (type);
2076 break;
fabcb361
RH		 2077 case EM_ALPHA:
2078 result = get_alpha_dynamic_type (type);
2079 break;
1c0d3aa6
NC		 2080 case EM_SCORE:
2081 result = get_score_dynamic_type (type);
2082 break;
40b36596
JM		 2083 case EM_TI_C6000:
2084 result = get_tic6x_dynamic_type (type);
2085 break;
36591ba1
SL		 2086 case EM_ALTERA_NIOS2:
2087 result = get_nios2_dynamic_type (type);
2088 break;
252b5132 2089 default:
fd85a6a1
NC		 2090 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2091 result = get_solaris_dynamic_type (type);
2092 else
2093 result = NULL;
252b5132
RH		 2094 break;
2095 }
2096
2097 if (result != NULL)
2098 return result;
2099
e9e44622 2100 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
252b5132 2101 }
eec8f817
DA		 2102 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2103 || (elf_header.e_machine == EM_PARISC
2104 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
103f02d3 2105 {
2cf0635d 2106 const char * result;
103f02d3
UD		 2107
2108 switch (elf_header.e_machine)
2109 {
2110 case EM_PARISC:
2111 result = get_parisc_dynamic_type (type);
2112 break;
148b93f2
NC		 2113 case EM_IA_64:
2114 result = get_ia64_dynamic_type (type);
2115 break;
103f02d3 2116 default:
fd85a6a1
NC		 2117 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2118 result = get_solaris_dynamic_type (type);
2119 else
2120 result = NULL;
103f02d3
UD		 2121 break;
2122 }
2123
2124 if (result != NULL)
2125 return result;
2126
e9e44622
JJ		 2127 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2128 type);
103f02d3 2129 }
252b5132 2130 else
e9e44622 2131 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
103f02d3 2132
252b5132
RH		 2133 return buff;
2134 }
2135}
2136
2137static char *
d3ba0551 2138get_file_type (unsigned e_type)
252b5132 2139{
b34976b6 2140 static char buff[32];
252b5132
RH		 2141
2142 switch (e_type)
2143 {
2144 case ET_NONE: return _("NONE (None)");
2145 case ET_REL: return _("REL (Relocatable file)");
ba2685cc
AM		 2146 case ET_EXEC: return _("EXEC (Executable file)");
2147 case ET_DYN: return _("DYN (Shared object file)");
2148 case ET_CORE: return _("CORE (Core file)");
252b5132
RH		 2149
2150 default:
2151 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
e9e44622 2152 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
252b5132 2153 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
e9e44622 2154 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
252b5132 2155 else
e9e44622 2156 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
252b5132
RH		 2157 return buff;
2158 }
2159}
2160
2161static char *
d3ba0551 2162get_machine_name (unsigned e_machine)
252b5132 2163{
b34976b6 2164 static char buff[64]; /* XXX */
252b5132
RH		 2165
2166 switch (e_machine)
2167 {
c45021f2 2168 case EM_NONE: return _("None");
a06ea964 2169 case EM_AARCH64: return "AArch64";
c45021f2
NC		 2170 case EM_M32: return "WE32100";
2171 case EM_SPARC: return "Sparc";
e9f53129 2172 case EM_SPU: return "SPU";
c45021f2
NC		 2173 case EM_386: return "Intel 80386";
2174 case EM_68K: return "MC68000";
2175 case EM_88K: return "MC88000";
22abe556 2176 case EM_IAMCU: return "Intel MCU";
c45021f2
NC		 2177 case EM_860: return "Intel 80860";
2178 case EM_MIPS: return "MIPS R3000";
2179 case EM_S370: return "IBM System/370";
7036c0e1 2180 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
252b5132 2181 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
c45021f2 2182 case EM_PARISC: return "HPPA";
252b5132 2183 case EM_PPC_OLD: return "Power PC (old)";
7036c0e1 2184 case EM_SPARC32PLUS: return "Sparc v8+" ;
c45021f2
NC		 2185 case EM_960: return "Intel 90860";
2186 case EM_PPC: return "PowerPC";
285d1771 2187 case EM_PPC64: return "PowerPC64";
c45021f2 2188 case EM_FR20: return "Fujitsu FR20";
3f8107ab 2189 case EM_FT32: return "FTDI FT32";
c45021f2 2190 case EM_RH32: return "TRW RH32";
b34976b6 2191 case EM_MCORE: return "MCORE";
7036c0e1
AJ		 2192 case EM_ARM: return "ARM";
2193 case EM_OLD_ALPHA: return "Digital Alpha (old)";
ef230218 2194 case EM_SH: return "Renesas / SuperH SH";
c45021f2
NC		 2195 case EM_SPARCV9: return "Sparc v9";
2196 case EM_TRICORE: return "Siemens Tricore";
584da044 2197 case EM_ARC: return "ARC";
886a2506
NC		 2198 case EM_ARC_COMPACT: return "ARCompact";
2199 case EM_ARC_COMPACT2: return "ARCv2";
c2dcd04e
NC		 2200 case EM_H8_300: return "Renesas H8/300";
2201 case EM_H8_300H: return "Renesas H8/300H";
2202 case EM_H8S: return "Renesas H8S";
2203 case EM_H8_500: return "Renesas H8/500";
30800947 2204 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 2205 case EM_MIPS_X: return "Stanford MIPS-X";
2206 case EM_COLDFIRE: return "Motorola Coldfire";
c45021f2 2207 case EM_ALPHA: return "Alpha";
2b0337b0
AO		 2208 case EM_CYGNUS_D10V:
2209 case EM_D10V: return "d10v";
2210 case EM_CYGNUS_D30V:
b34976b6 2211 case EM_D30V: return "d30v";
2b0337b0 2212 case EM_CYGNUS_M32R:
26597c86 2213 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2b0337b0 2214 case EM_CYGNUS_V850:
708e2187 2215 case EM_V800: return "Renesas V850 (using RH850 ABI)";
f6c1a2d5 2216 case EM_V850: return "Renesas V850";
2b0337b0
AO		 2217 case EM_CYGNUS_MN10300:
2218 case EM_MN10300: return "mn10300";
2219 case EM_CYGNUS_MN10200:
2220 case EM_MN10200: return "mn10200";
5506d11a 2221 case EM_MOXIE: return "Moxie";
2b0337b0
AO		 2222 case EM_CYGNUS_FR30:
2223 case EM_FR30: return "Fujitsu FR30";
b34976b6 2224 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2b0337b0 2225 case EM_PJ_OLD:
b34976b6 2226 case EM_PJ: return "picoJava";
7036c0e1
AJ		 2227 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2228 case EM_PCP: return "Siemens PCP";
2229 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2230 case EM_NDR1: return "Denso NDR1 microprocesspr";
2231 case EM_STARCORE: return "Motorola Star*Core processor";
2232 case EM_ME16: return "Toyota ME16 processor";
2233 case EM_ST100: return "STMicroelectronics ST100 processor";
2234 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
11636f9e
JM		 2235 case EM_PDSP: return "Sony DSP processor";
2236 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2237 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
7036c0e1
AJ		 2238 case EM_FX66: return "Siemens FX66 microcontroller";
2239 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2240 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2241 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
6927f982 2242 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
7036c0e1
AJ		 2243 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2244 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2245 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2246 case EM_SVX: return "Silicon Graphics SVx";
2247 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2248 case EM_VAX: return "Digital VAX";
619ed720 2249 case EM_VISIUM: return "CDS VISIUMcore processor";
2b0337b0 2250 case EM_AVR_OLD:
b34976b6 2251 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1b61cf92 2252 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
c45021f2
NC		 2253 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2254 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2255 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
b34976b6 2256 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
c45021f2 2257 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
3b36097d 2258 case EM_PRISM: return "Vitesse Prism";
bcedfee6 2259 case EM_X86_64: return "Advanced Micro Devices X86-64";
8a9036a4 2260 case EM_L1OM: return "Intel L1OM";
7a9068fe 2261 case EM_K1OM: return "Intel K1OM";
b7498e0e 2262 case EM_S390_OLD:
b34976b6 2263 case EM_S390: return "IBM S/390";
1c0d3aa6 2264 case EM_SCORE: return "SUNPLUS S+Core";
61865e30 2265 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
73589c9d 2266 case EM_OR1K: return "OpenRISC 1000";
1fe1f39c 2267 case EM_CRX: return "National Semiconductor CRX microprocessor";
cfb8c092 2268 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
d172d4ba 2269 case EM_DLX: return "OpenDLX";
1e4cf259 2270 case EM_IP2K_OLD:
b34976b6 2271 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
3b36097d 2272 case EM_IQ2000: return "Vitesse IQ2000";
88da6820
NC		 2273 case EM_XTENSA_OLD:
2274 case EM_XTENSA: return "Tensilica Xtensa Processor";
11636f9e
JM		 2275 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2276 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2277 case EM_NS32K: return "National Semiconductor 32000 series";
2278 case EM_TPC: return "Tenor Network TPC processor";
2279 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2280 case EM_MAX: return "MAX Processor";
2281 case EM_CR: return "National Semiconductor CompactRISC";
2282 case EM_F2MC16: return "Fujitsu F2MC16";
2283 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
84e94c90 2284 case EM_LATTICEMICO32: return "Lattice Mico32";
ff7eeb89 2285 case EM_M32C_OLD:
49f58d10 2286 case EM_M32C: return "Renesas M32c";
d031aafb 2287 case EM_MT: return "Morpho Techologies MT processor";
7bbe5bc5 2288 case EM_BLACKFIN: return "Analog Devices Blackfin";
11636f9e
JM		 2289 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2290 case EM_SEP: return "Sharp embedded microprocessor";
2291 case EM_ARCA: return "Arca RISC microprocessor";
2292 case EM_UNICORE: return "Unicore";
2293 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2294 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
64fd6348
NC		 2295 case EM_NIOS32: return "Altera Nios";
2296 case EM_ALTERA_NIOS2: return "Altera Nios II";
c29aca4a 2297 case EM_C166:
d70c5fc7 2298 case EM_XC16X: return "Infineon Technologies xc16x";
11636f9e
JM		 2299 case EM_M16C: return "Renesas M16C series microprocessors";
2300 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2301 case EM_CE: return "Freescale Communication Engine RISC core";
2302 case EM_TSK3000: return "Altium TSK3000 core";
2303 case EM_RS08: return "Freescale RS08 embedded processor";
2304 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2305 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2306 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2307 case EM_SE_C17: return "Seiko Epson C17 family";
2308 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2309 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2310 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2311 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2312 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2313 case EM_R32C: return "Renesas R32C series microprocessors";
2314 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2315 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2316 case EM_8051: return "Intel 8051 and variants";
2317 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2318 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2319 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2320 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2321 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2322 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2323 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
15ab5209 2324 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
cb8f3167 2325 case EM_CR16:
f6c1a2d5 2326 case EM_MICROBLAZE:
7ba29e2a 2327 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
99c513f6 2328 case EM_RL78: return "Renesas RL78";
c7927a3c 2329 case EM_RX: return "Renesas RX";
a3c62988 2330 case EM_METAG: return "Imagination Technologies Meta processor architecture";
11636f9e
JM		 2331 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2332 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2333 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2334 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2335 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2336 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2337 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2338 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
aa137e4d 2339 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
11636f9e 2340 case EM_CUDA: return "NVIDIA CUDA architecture";
f6c1a2d5 2341 case EM_XGATE: return "Motorola XGATE embedded processor";
252b5132 2342 default:
35d9dd2f 2343 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
252b5132
RH		 2344 return buff;
2345 }
2346}
2347
a9522a21
AB		 2348static void
2349decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2350{
2351 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2352 other compilers don't a specific architecture type in the e_flags, and
2353 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2354 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2355 architectures.
2356
2357 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2358 but also sets a specific architecture type in the e_flags field.
2359
2360 However, when decoding the flags we don't worry if we see an
2361 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2362 ARCEM architecture type. */
2363
2364 switch (e_flags & EF_ARC_MACH_MSK)
2365 {
2366 /* We only expect these to occur for EM_ARC_COMPACT2. */
2367 case EF_ARC_CPU_ARCV2EM:
2368 strcat (buf, ", ARC EM");
2369 break;
2370 case EF_ARC_CPU_ARCV2HS:
2371 strcat (buf, ", ARC HS");
2372 break;
2373
2374 /* We only expect these to occur for EM_ARC_COMPACT. */
2375 case E_ARC_MACH_ARC600:
2376 strcat (buf, ", ARC600");
2377 break;
2378 case E_ARC_MACH_ARC601:
2379 strcat (buf, ", ARC601");
2380 break;
2381 case E_ARC_MACH_ARC700:
2382 strcat (buf, ", ARC700");
2383 break;
2384
2385 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2386 new ELF with new architecture being read by an old version of
2387 readelf, or (c) An ELF built with non-GNU compiler that does not
2388 set the architecture in the e_flags. */
2389 default:
2390 if (e_machine == EM_ARC_COMPACT)
2391 strcat (buf, ", Unknown ARCompact");
2392 else
2393 strcat (buf, ", Unknown ARC");
2394 break;
2395 }
2396
2397 switch (e_flags & EF_ARC_OSABI_MSK)
2398 {
2399 case E_ARC_OSABI_ORIG:
2400 strcat (buf, ", (ABI:legacy)");
2401 break;
2402 case E_ARC_OSABI_V2:
2403 strcat (buf, ", (ABI:v2)");
2404 break;
2405 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2406 case E_ARC_OSABI_V3:
2407 strcat (buf, ", v3 no-legacy-syscalls ABI");
2408 break;
2409 default:
2410 strcat (buf, ", unrecognised ARC OSABI flag");
2411 break;
2412 }
2413}
2414
f3485b74 2415static void
d3ba0551 2416decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 2417{
2418 unsigned eabi;
2419 int unknown = 0;
2420
2421 eabi = EF_ARM_EABI_VERSION (e_flags);
2422 e_flags &= ~ EF_ARM_EABIMASK;
2423
2424 /* Handle "generic" ARM flags. */
2425 if (e_flags & EF_ARM_RELEXEC)
2426 {
2427 strcat (buf, ", relocatable executable");
2428 e_flags &= ~ EF_ARM_RELEXEC;
2429 }
76da6bbe 2430
f3485b74
NC		 2431 /* Now handle EABI specific flags. */
2432 switch (eabi)
2433 {
2434 default:
2c71103e 2435 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC		 2436 if (e_flags)
2437 unknown = 1;
2438 break;
2439
2440 case EF_ARM_EABI_VER1:
a5bcd848 2441 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2442 while (e_flags)
2443 {
2444 unsigned flag;
76da6bbe 2445
f3485b74
NC		 2446 /* Process flags one bit at a time. */
2447 flag = e_flags & - e_flags;
2448 e_flags &= ~ flag;
76da6bbe 2449
f3485b74
NC		 2450 switch (flag)
2451 {
a5bcd848 2452 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2453 strcat (buf, ", sorted symbol tables");
2454 break;
76da6bbe 2455
f3485b74
NC		 2456 default:
2457 unknown = 1;
2458 break;
2459 }
2460 }
2461 break;
76da6bbe 2462
a5bcd848
PB		 2463 case EF_ARM_EABI_VER2:
2464 strcat (buf, ", Version2 EABI");
2465 while (e_flags)
2466 {
2467 unsigned flag;
2468
2469 /* Process flags one bit at a time. */
2470 flag = e_flags & - e_flags;
2471 e_flags &= ~ flag;
2472
2473 switch (flag)
2474 {
2475 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2476 strcat (buf, ", sorted symbol tables");
2477 break;
2478
2479 case EF_ARM_DYNSYMSUSESEGIDX:
2480 strcat (buf, ", dynamic symbols use segment index");
2481 break;
2482
2483 case EF_ARM_MAPSYMSFIRST:
2484 strcat (buf, ", mapping symbols precede others");
2485 break;
2486
2487 default:
2488 unknown = 1;
2489 break;
2490 }
2491 }
2492 break;
2493
d507cf36
PB		 2494 case EF_ARM_EABI_VER3:
2495 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2496 break;
2497
2498 case EF_ARM_EABI_VER4:
2499 strcat (buf, ", Version4 EABI");
3bfcb652
NC		 2500 while (e_flags)
2501 {
2502 unsigned flag;
2503
2504 /* Process flags one bit at a time. */
2505 flag = e_flags & - e_flags;
2506 e_flags &= ~ flag;
2507
2508 switch (flag)
2509 {
2510 case EF_ARM_BE8:
2511 strcat (buf, ", BE8");
2512 break;
2513
2514 case EF_ARM_LE8:
2515 strcat (buf, ", LE8");
2516 break;
2517
2518 default:
2519 unknown = 1;
2520 break;
2521 }
2522 break;
2523 }
2524 break;
3a4a14e9
PB		 2525
2526 case EF_ARM_EABI_VER5:
2527 strcat (buf, ", Version5 EABI");
d507cf36
PB		 2528 while (e_flags)
2529 {
2530 unsigned flag;
2531
2532 /* Process flags one bit at a time. */
2533 flag = e_flags & - e_flags;
2534 e_flags &= ~ flag;
2535
2536 switch (flag)
2537 {
2538 case EF_ARM_BE8:
2539 strcat (buf, ", BE8");
2540 break;
2541
2542 case EF_ARM_LE8:
2543 strcat (buf, ", LE8");
2544 break;
2545
3bfcb652
NC		 2546 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2547 strcat (buf, ", soft-float ABI");
2548 break;
2549
2550 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2551 strcat (buf, ", hard-float ABI");
2552 break;
2553
d507cf36
PB		 2554 default:
2555 unknown = 1;
2556 break;
2557 }
2558 }
2559 break;
2560
f3485b74 2561 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2562 strcat (buf, ", GNU EABI");
f3485b74
NC		 2563 while (e_flags)
2564 {
2565 unsigned flag;
76da6bbe 2566
f3485b74
NC		 2567 /* Process flags one bit at a time. */
2568 flag = e_flags & - e_flags;
2569 e_flags &= ~ flag;
76da6bbe 2570
f3485b74
NC		 2571 switch (flag)
2572 {
a5bcd848 2573 case EF_ARM_INTERWORK:
f3485b74
NC		 2574 strcat (buf, ", interworking enabled");
2575 break;
76da6bbe 2576
a5bcd848 2577 case EF_ARM_APCS_26:
f3485b74
NC		 2578 strcat (buf, ", uses APCS/26");
2579 break;
76da6bbe 2580
a5bcd848 2581 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2582 strcat (buf, ", uses APCS/float");
2583 break;
76da6bbe 2584
a5bcd848 2585 case EF_ARM_PIC:
f3485b74
NC		 2586 strcat (buf, ", position independent");
2587 break;
76da6bbe 2588
a5bcd848 2589 case EF_ARM_ALIGN8:
f3485b74
NC		 2590 strcat (buf, ", 8 bit structure alignment");
2591 break;
76da6bbe 2592
a5bcd848 2593 case EF_ARM_NEW_ABI:
f3485b74
NC		 2594 strcat (buf, ", uses new ABI");
2595 break;
76da6bbe 2596
a5bcd848 2597 case EF_ARM_OLD_ABI:
f3485b74
NC		 2598 strcat (buf, ", uses old ABI");
2599 break;
76da6bbe 2600
a5bcd848 2601 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2602 strcat (buf, ", software FP");
2603 break;
76da6bbe 2604
90e01f86
ILT		 2605 case EF_ARM_VFP_FLOAT:
2606 strcat (buf, ", VFP");
2607 break;
2608
fde78edd
NC		 2609 case EF_ARM_MAVERICK_FLOAT:
2610 strcat (buf, ", Maverick FP");
2611 break;
2612
f3485b74
NC		 2613 default:
2614 unknown = 1;
2615 break;
2616 }
2617 }
2618 }
f3485b74
NC		 2619
2620 if (unknown)
2b692964 2621 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2622}
2623
343433df
AB		 2624static void
2625decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2626{
2627 --size; /* Leave space for null terminator. */
2628
2629 switch (e_flags & EF_AVR_MACH)
2630 {
2631 case E_AVR_MACH_AVR1:
2632 strncat (buf, ", avr:1", size);
2633 break;
2634 case E_AVR_MACH_AVR2:
2635 strncat (buf, ", avr:2", size);
2636 break;
2637 case E_AVR_MACH_AVR25:
2638 strncat (buf, ", avr:25", size);
2639 break;
2640 case E_AVR_MACH_AVR3:
2641 strncat (buf, ", avr:3", size);
2642 break;
2643 case E_AVR_MACH_AVR31:
2644 strncat (buf, ", avr:31", size);
2645 break;
2646 case E_AVR_MACH_AVR35:
2647 strncat (buf, ", avr:35", size);
2648 break;
2649 case E_AVR_MACH_AVR4:
2650 strncat (buf, ", avr:4", size);
2651 break;
2652 case E_AVR_MACH_AVR5:
2653 strncat (buf, ", avr:5", size);
2654 break;
2655 case E_AVR_MACH_AVR51:
2656 strncat (buf, ", avr:51", size);
2657 break;
2658 case E_AVR_MACH_AVR6:
2659 strncat (buf, ", avr:6", size);
2660 break;
2661 case E_AVR_MACH_AVRTINY:
2662 strncat (buf, ", avr:100", size);
2663 break;
2664 case E_AVR_MACH_XMEGA1:
2665 strncat (buf, ", avr:101", size);
2666 break;
2667 case E_AVR_MACH_XMEGA2:
2668 strncat (buf, ", avr:102", size);
2669 break;
2670 case E_AVR_MACH_XMEGA3:
2671 strncat (buf, ", avr:103", size);
2672 break;
2673 case E_AVR_MACH_XMEGA4:
2674 strncat (buf, ", avr:104", size);
2675 break;
2676 case E_AVR_MACH_XMEGA5:
2677 strncat (buf, ", avr:105", size);
2678 break;
2679 case E_AVR_MACH_XMEGA6:
2680 strncat (buf, ", avr:106", size);
2681 break;
2682 case E_AVR_MACH_XMEGA7:
2683 strncat (buf, ", avr:107", size);
2684 break;
2685 default:
2686 strncat (buf, ", avr:<unknown>", size);
2687 break;
2688 }
2689
2690 size -= strlen (buf);
2691 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2692 strncat (buf, ", link-relax", size);
2693}
2694
35c08157
KLC		 2695static void
2696decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2697{
2698 unsigned abi;
2699 unsigned arch;
2700 unsigned config;
2701 unsigned version;
2702 int has_fpu = 0;
2703 int r = 0;
2704
2705 static const char *ABI_STRINGS[] =
2706 {
2707 "ABI v0", /* use r5 as return register; only used in N1213HC */
2708 "ABI v1", /* use r0 as return register */
2709 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2710 "ABI v2fp", /* for FPU */
40c7a7cb
KLC		 2711 "AABI",
2712 "ABI2 FP+"
35c08157
KLC		 2713 };
2714 static const char *VER_STRINGS[] =
2715 {
2716 "Andes ELF V1.3 or older",
2717 "Andes ELF V1.3.1",
2718 "Andes ELF V1.4"
2719 };
2720 static const char *ARCH_STRINGS[] =
2721 {
2722 "",
2723 "Andes Star v1.0",
2724 "Andes Star v2.0",
2725 "Andes Star v3.0",
2726 "Andes Star v3.0m"
2727 };
2728
2729 abi = EF_NDS_ABI & e_flags;
2730 arch = EF_NDS_ARCH & e_flags;
2731 config = EF_NDS_INST & e_flags;
2732 version = EF_NDS32_ELF_VERSION & e_flags;
2733
2734 memset (buf, 0, size);
2735
2736 switch (abi)
2737 {
2738 case E_NDS_ABI_V0:
2739 case E_NDS_ABI_V1:
2740 case E_NDS_ABI_V2:
2741 case E_NDS_ABI_V2FP:
2742 case E_NDS_ABI_AABI:
40c7a7cb 2743 case E_NDS_ABI_V2FP_PLUS:
35c08157
KLC		 2744 /* In case there are holes in the array. */
2745 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2746 break;
2747
2748 default:
2749 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2750 break;
2751 }
2752
2753 switch (version)
2754 {
2755 case E_NDS32_ELF_VER_1_2:
2756 case E_NDS32_ELF_VER_1_3:
2757 case E_NDS32_ELF_VER_1_4:
2758 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2759 break;
2760
2761 default:
2762 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2763 break;
2764 }
2765
2766 if (E_NDS_ABI_V0 == abi)
2767 {
2768 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2769 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2770 if (arch == E_NDS_ARCH_STAR_V1_0)
2771 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2772 return;
2773 }
2774
2775 switch (arch)
2776 {
2777 case E_NDS_ARCH_STAR_V1_0:
2778 case E_NDS_ARCH_STAR_V2_0:
2779 case E_NDS_ARCH_STAR_V3_0:
2780 case E_NDS_ARCH_STAR_V3_M:
2781 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2782 break;
2783
2784 default:
2785 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2786 /* ARCH version determines how the e_flags are interpreted.
2787 If it is unknown, we cannot proceed. */
2788 return;
2789 }
2790
2791 /* Newer ABI; Now handle architecture specific flags. */
2792 if (arch == E_NDS_ARCH_STAR_V1_0)
2793 {
2794 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2795 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2796
2797 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2798 r += snprintf (buf + r, size -r, ", MAC");
2799
2800 if (config & E_NDS32_HAS_DIV_INST)
2801 r += snprintf (buf + r, size -r, ", DIV");
2802
2803 if (config & E_NDS32_HAS_16BIT_INST)
2804 r += snprintf (buf + r, size -r, ", 16b");
2805 }
2806 else
2807 {
2808 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2809 {
2810 if (version <= E_NDS32_ELF_VER_1_3)
2811 r += snprintf (buf + r, size -r, ", [B8]");
2812 else
2813 r += snprintf (buf + r, size -r, ", EX9");
2814 }
2815
2816 if (config & E_NDS32_HAS_MAC_DX_INST)
2817 r += snprintf (buf + r, size -r, ", MAC_DX");
2818
2819 if (config & E_NDS32_HAS_DIV_DX_INST)
2820 r += snprintf (buf + r, size -r, ", DIV_DX");
2821
2822 if (config & E_NDS32_HAS_16BIT_INST)
2823 {
2824 if (version <= E_NDS32_ELF_VER_1_3)
2825 r += snprintf (buf + r, size -r, ", 16b");
2826 else
2827 r += snprintf (buf + r, size -r, ", IFC");
2828 }
2829 }
2830
2831 if (config & E_NDS32_HAS_EXT_INST)
2832 r += snprintf (buf + r, size -r, ", PERF1");
2833
2834 if (config & E_NDS32_HAS_EXT2_INST)
2835 r += snprintf (buf + r, size -r, ", PERF2");
2836
2837 if (config & E_NDS32_HAS_FPU_INST)
2838 {
2839 has_fpu = 1;
2840 r += snprintf (buf + r, size -r, ", FPU_SP");
2841 }
2842
2843 if (config & E_NDS32_HAS_FPU_DP_INST)
2844 {
2845 has_fpu = 1;
2846 r += snprintf (buf + r, size -r, ", FPU_DP");
2847 }
2848
2849 if (config & E_NDS32_HAS_FPU_MAC_INST)
2850 {
2851 has_fpu = 1;
2852 r += snprintf (buf + r, size -r, ", FPU_MAC");
2853 }
2854
2855 if (has_fpu)
2856 {
2857 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2858 {
2859 case E_NDS32_FPU_REG_8SP_4DP:
2860 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2861 break;
2862 case E_NDS32_FPU_REG_16SP_8DP:
2863 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2864 break;
2865 case E_NDS32_FPU_REG_32SP_16DP:
2866 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2867 break;
2868 case E_NDS32_FPU_REG_32SP_32DP:
2869 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2870 break;
2871 }
2872 }
2873
2874 if (config & E_NDS32_HAS_AUDIO_INST)
2875 r += snprintf (buf + r, size -r, ", AUDIO");
2876
2877 if (config & E_NDS32_HAS_STRING_INST)
2878 r += snprintf (buf + r, size -r, ", STR");
2879
2880 if (config & E_NDS32_HAS_REDUCED_REGS)
2881 r += snprintf (buf + r, size -r, ", 16REG");
2882
2883 if (config & E_NDS32_HAS_VIDEO_INST)
2884 {
2885 if (version <= E_NDS32_ELF_VER_1_3)
2886 r += snprintf (buf + r, size -r, ", VIDEO");
2887 else
2888 r += snprintf (buf + r, size -r, ", SATURATION");
2889 }
2890
2891 if (config & E_NDS32_HAS_ENCRIPT_INST)
2892 r += snprintf (buf + r, size -r, ", ENCRP");
2893
2894 if (config & E_NDS32_HAS_L2C_INST)
2895 r += snprintf (buf + r, size -r, ", L2C");
2896}
2897
252b5132 2898static char *
d3ba0551 2899get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2900{
b34976b6 2901 static char buf[1024];
252b5132
RH		 2902
2903 buf[0] = '\0';
76da6bbe 2904
252b5132
RH		 2905 if (e_flags)
2906 {
2907 switch (e_machine)
2908 {
2909 default:
2910 break;
2911
886a2506 2912 case EM_ARC_COMPACT2:
886a2506 2913 case EM_ARC_COMPACT:
a9522a21
AB		 2914 decode_ARC_machine_flags (e_flags, e_machine, buf);
2915 break;
886a2506 2916
f3485b74
NC		 2917 case EM_ARM:
2918 decode_ARM_machine_flags (e_flags, buf);
2919 break;
76da6bbe 2920
343433df
AB		 2921 case EM_AVR:
2922 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
2923 break;
2924
781303ce
MF		 2925 case EM_BLACKFIN:
2926 if (e_flags & EF_BFIN_PIC)
2927 strcat (buf, ", PIC");
2928
2929 if (e_flags & EF_BFIN_FDPIC)
2930 strcat (buf, ", FDPIC");
2931
2932 if (e_flags & EF_BFIN_CODE_IN_L1)
2933 strcat (buf, ", code in L1");
2934
2935 if (e_flags & EF_BFIN_DATA_IN_L1)
2936 strcat (buf, ", data in L1");
2937
2938 break;
2939
ec2dfb42
AO		 2940 case EM_CYGNUS_FRV:
2941 switch (e_flags & EF_FRV_CPU_MASK)
2942 {
2943 case EF_FRV_CPU_GENERIC:
2944 break;
2945
2946 default:
2947 strcat (buf, ", fr???");
2948 break;
57346661 2949
ec2dfb42
AO		 2950 case EF_FRV_CPU_FR300:
2951 strcat (buf, ", fr300");
2952 break;
2953
2954 case EF_FRV_CPU_FR400:
2955 strcat (buf, ", fr400");
2956 break;
2957 case EF_FRV_CPU_FR405:
2958 strcat (buf, ", fr405");
2959 break;
2960
2961 case EF_FRV_CPU_FR450:
2962 strcat (buf, ", fr450");
2963 break;
2964
2965 case EF_FRV_CPU_FR500:
2966 strcat (buf, ", fr500");
2967 break;
2968 case EF_FRV_CPU_FR550:
2969 strcat (buf, ", fr550");
2970 break;
2971
2972 case EF_FRV_CPU_SIMPLE:
2973 strcat (buf, ", simple");
2974 break;
2975 case EF_FRV_CPU_TOMCAT:
2976 strcat (buf, ", tomcat");
2977 break;
2978 }
1c877e87 2979 break;
ec2dfb42 2980
53c7db4b 2981 case EM_68K:
425c6cb0 2982 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 2983 strcat (buf, ", m68000");
425c6cb0 2984 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 2985 strcat (buf, ", cpu32");
2986 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2987 strcat (buf, ", fido_a");
425c6cb0 2988 else
266abb8f 2989 {
2cf0635d
NC		 2990 char const * isa = _("unknown");
2991 char const * mac = _("unknown mac");
2992 char const * additional = NULL;
0112cd26 2993
c694fd50 2994 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 2995 {
c694fd50 2996 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 2997 isa = "A";
2998 additional = ", nodiv";
2999 break;
c694fd50 3000 case EF_M68K_CF_ISA_A:
266abb8f
NS		 3001 isa = "A";
3002 break;
c694fd50 3003 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 3004 isa = "A+";
3005 break;
c694fd50 3006 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 3007 isa = "B";
3008 additional = ", nousp";
3009 break;
c694fd50 3010 case EF_M68K_CF_ISA_B:
266abb8f
NS		 3011 isa = "B";
3012 break;
f608cd77
NS		 3013 case EF_M68K_CF_ISA_C:
3014 isa = "C";
3015 break;
3016 case EF_M68K_CF_ISA_C_NODIV:
3017 isa = "C";
3018 additional = ", nodiv";
3019 break;
266abb8f
NS		 3020 }
3021 strcat (buf, ", cf, isa ");
3022 strcat (buf, isa);
0b2e31dc
NS		 3023 if (additional)
3024 strcat (buf, additional);
c694fd50 3025 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 3026 strcat (buf, ", float");
c694fd50 3027 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 3028 {
3029 case 0:
3030 mac = NULL;
3031 break;
c694fd50 3032 case EF_M68K_CF_MAC:
266abb8f
NS		 3033 mac = "mac";
3034 break;
c694fd50 3035 case EF_M68K_CF_EMAC:
266abb8f
NS		 3036 mac = "emac";
3037 break;
f608cd77
NS		 3038 case EF_M68K_CF_EMAC_B:
3039 mac = "emac_b";
3040 break;
266abb8f
NS		 3041 }
3042 if (mac)
3043 {
3044 strcat (buf, ", ");
3045 strcat (buf, mac);
3046 }
266abb8f 3047 }
53c7db4b 3048 break;
33c63f9d 3049
153a2776
NC		 3050 case EM_CYGNUS_MEP:
3051 switch (e_flags & EF_MEP_CPU_MASK)
3052 {
3053 case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3054 case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3055 case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3056 case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3057 case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3058 case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3059 default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3060 }
3061
3062 switch (e_flags & EF_MEP_COP_MASK)
3063 {
3064 case EF_MEP_COP_NONE: break;
3065 case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3066 case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3067 case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3068 case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3069 default: strcat (buf, _("<unknown MeP copro type>")); break;
3070 }
3071
3072 if (e_flags & EF_MEP_LIBRARY)
3073 strcat (buf, ", Built for Library");
3074
3075 if (e_flags & EF_MEP_INDEX_MASK)
3076 sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3077 e_flags & EF_MEP_INDEX_MASK);
3078
3079 if (e_flags & ~ EF_MEP_ALL_FLAGS)
3080 sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3081 e_flags & ~ EF_MEP_ALL_FLAGS);
3082 break;
3083
252b5132
RH		 3084 case EM_PPC:
3085 if (e_flags & EF_PPC_EMB)
3086 strcat (buf, ", emb");
3087
3088 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 3089 strcat (buf, _(", relocatable"));
252b5132
RH		 3090
3091 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 3092 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 3093 break;
3094
ee67d69a
AM		 3095 case EM_PPC64:
3096 if (e_flags & EF_PPC64_ABI)
3097 {
3098 char abi[] = ", abiv0";
3099
3100 abi[6] += e_flags & EF_PPC64_ABI;
3101 strcat (buf, abi);
3102 }
3103 break;
3104
708e2187
NC		 3105 case EM_V800:
3106 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3107 strcat (buf, ", RH850 ABI");
0b4362b0 3108
708e2187
NC		 3109 if (e_flags & EF_V800_850E3)
3110 strcat (buf, ", V3 architecture");
3111
3112 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3113 strcat (buf, ", FPU not used");
3114
3115 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3116 strcat (buf, ", regmode: COMMON");
3117
3118 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3119 strcat (buf, ", r4 not used");
3120
3121 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3122 strcat (buf, ", r30 not used");
3123
3124 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3125 strcat (buf, ", r5 not used");
3126
3127 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3128 strcat (buf, ", r2 not used");
3129
3130 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3131 {
3132 switch (e_flags & - e_flags)
3133 {
3134 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3135 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
708e2187
NC		 3136 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3137 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
708e2187
NC		 3138 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3139 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3140 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3141 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3142 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3143 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3144 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3145 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3146 default: break;
3147 }
3148 }
3149 break;
3150
2b0337b0 3151 case EM_V850:
252b5132
RH		 3152 case EM_CYGNUS_V850:
3153 switch (e_flags & EF_V850_ARCH)
3154 {
78c8d46c
NC		 3155 case E_V850E3V5_ARCH:
3156 strcat (buf, ", v850e3v5");
3157 break;
1cd986c5
NC		 3158 case E_V850E2V3_ARCH:
3159 strcat (buf, ", v850e2v3");
3160 break;
3161 case E_V850E2_ARCH:
3162 strcat (buf, ", v850e2");
3163 break;
3164 case E_V850E1_ARCH:
3165 strcat (buf, ", v850e1");
8ad30312 3166 break;
252b5132
RH		 3167 case E_V850E_ARCH:
3168 strcat (buf, ", v850e");
3169 break;
252b5132
RH		 3170 case E_V850_ARCH:
3171 strcat (buf, ", v850");
3172 break;
3173 default:
2b692964 3174 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 3175 break;
3176 }
3177 break;
3178
2b0337b0 3179 case EM_M32R:
252b5132
RH		 3180 case EM_CYGNUS_M32R:
3181 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3182 strcat (buf, ", m32r");
252b5132
RH		 3183 break;
3184
3185 case EM_MIPS:
4fe85591 3186 case EM_MIPS_RS3_LE:
252b5132
RH		 3187 if (e_flags & EF_MIPS_NOREORDER)
3188 strcat (buf, ", noreorder");
3189
3190 if (e_flags & EF_MIPS_PIC)
3191 strcat (buf, ", pic");
3192
3193 if (e_flags & EF_MIPS_CPIC)
3194 strcat (buf, ", cpic");
3195
d1bdd336
TS		 3196 if (e_flags & EF_MIPS_UCODE)
3197 strcat (buf, ", ugen_reserved");
3198
252b5132
RH		 3199 if (e_flags & EF_MIPS_ABI2)
3200 strcat (buf, ", abi2");
3201
43521d43
TS		 3202 if (e_flags & EF_MIPS_OPTIONS_FIRST)
3203 strcat (buf, ", odk first");
3204
a5d22d2a
TS		 3205 if (e_flags & EF_MIPS_32BITMODE)
3206 strcat (buf, ", 32bitmode");
3207
ba92f887
MR		 3208 if (e_flags & EF_MIPS_NAN2008)
3209 strcat (buf, ", nan2008");
3210
fef1b0b3
SE		 3211 if (e_flags & EF_MIPS_FP64)
3212 strcat (buf, ", fp64");
3213
156c2f8b
NC		 3214 switch ((e_flags & EF_MIPS_MACH))
3215 {
3216 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3217 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3218 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 3219 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 3220 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3221 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3222 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3223 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 3224 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 3225 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 3226 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3227 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 3228 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 3229 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 3230 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
d32e5c54 3231 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
52b6b6b9 3232 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 3233 case 0:
3234 /* We simply ignore the field in this case to avoid confusion:
3235 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3236 extension. */
3237 break;
2b692964 3238 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 3239 }
43521d43
TS		 3240
3241 switch ((e_flags & EF_MIPS_ABI))
3242 {
3243 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3244 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3245 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3246 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3247 case 0:
3248 /* We simply ignore the field in this case to avoid confusion:
3249 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3250 This means it is likely to be an o32 file, but not for
3251 sure. */
3252 break;
2b692964 3253 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 3254 }
3255
3256 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3257 strcat (buf, ", mdmx");
3258
3259 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3260 strcat (buf, ", mips16");
3261
df58fc94
RS		 3262 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3263 strcat (buf, ", micromips");
3264
43521d43
TS		 3265 switch ((e_flags & EF_MIPS_ARCH))
3266 {
3267 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3268 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3269 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3270 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3271 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3272 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 3273 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
7361da2c 3274 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
43521d43 3275 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 3276 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
7361da2c 3277 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
2b692964 3278 default: strcat (buf, _(", unknown ISA")); break;
43521d43 3279 }
252b5132 3280 break;
351b4b40 3281
35c08157
KLC		 3282 case EM_NDS32:
3283 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3284 break;
3285
ccde1100
AO		 3286 case EM_SH:
3287 switch ((e_flags & EF_SH_MACH_MASK))
3288 {
3289 case EF_SH1: strcat (buf, ", sh1"); break;
3290 case EF_SH2: strcat (buf, ", sh2"); break;
3291 case EF_SH3: strcat (buf, ", sh3"); break;
3292 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3293 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3294 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3295 case EF_SH3E: strcat (buf, ", sh3e"); break;
3296 case EF_SH4: strcat (buf, ", sh4"); break;
3297 case EF_SH5: strcat (buf, ", sh5"); break;
3298 case EF_SH2E: strcat (buf, ", sh2e"); break;
3299 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 3300 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 3301 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3302 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 3303 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 3304 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3305 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3306 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3307 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3308 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3309 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 3310 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 3311 }
3312
cec6a5b8
MR		 3313 if (e_flags & EF_SH_PIC)
3314 strcat (buf, ", pic");
3315
3316 if (e_flags & EF_SH_FDPIC)
3317 strcat (buf, ", fdpic");
ccde1100 3318 break;
948f632f 3319
73589c9d
CS		 3320 case EM_OR1K:
3321 if (e_flags & EF_OR1K_NODELAY)
3322 strcat (buf, ", no delay");
3323 break;
57346661 3324
351b4b40
RH		 3325 case EM_SPARCV9:
3326 if (e_flags & EF_SPARC_32PLUS)
3327 strcat (buf, ", v8+");
3328
3329 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 3330 strcat (buf, ", ultrasparcI");
3331
3332 if (e_flags & EF_SPARC_SUN_US3)
3333 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 3334
3335 if (e_flags & EF_SPARC_HAL_R1)
3336 strcat (buf, ", halr1");
3337
3338 if (e_flags & EF_SPARC_LEDATA)
3339 strcat (buf, ", ledata");
3340
3341 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3342 strcat (buf, ", tso");
3343
3344 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3345 strcat (buf, ", pso");
3346
3347 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3348 strcat (buf, ", rmo");
3349 break;
7d466069 3350
103f02d3
UD		 3351 case EM_PARISC:
3352 switch (e_flags & EF_PARISC_ARCH)
3353 {
3354 case EFA_PARISC_1_0:
3355 strcpy (buf, ", PA-RISC 1.0");
3356 break;
3357 case EFA_PARISC_1_1:
3358 strcpy (buf, ", PA-RISC 1.1");
3359 break;
3360 case EFA_PARISC_2_0:
3361 strcpy (buf, ", PA-RISC 2.0");
3362 break;
3363 default:
3364 break;
3365 }
3366 if (e_flags & EF_PARISC_TRAPNIL)
3367 strcat (buf, ", trapnil");
3368 if (e_flags & EF_PARISC_EXT)
3369 strcat (buf, ", ext");
3370 if (e_flags & EF_PARISC_LSB)
3371 strcat (buf, ", lsb");
3372 if (e_flags & EF_PARISC_WIDE)
3373 strcat (buf, ", wide");
3374 if (e_flags & EF_PARISC_NO_KABP)
3375 strcat (buf, ", no kabp");
3376 if (e_flags & EF_PARISC_LAZYSWAP)
3377 strcat (buf, ", lazyswap");
30800947 3378 break;
76da6bbe 3379
7d466069 3380 case EM_PJ:
2b0337b0 3381 case EM_PJ_OLD:
7d466069
ILT		 3382 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3383 strcat (buf, ", new calling convention");
3384
3385 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3386 strcat (buf, ", gnu calling convention");
3387 break;
4d6ed7c8
NC		 3388
3389 case EM_IA_64:
3390 if ((e_flags & EF_IA_64_ABI64))
3391 strcat (buf, ", 64-bit");
3392 else
3393 strcat (buf, ", 32-bit");
3394 if ((e_flags & EF_IA_64_REDUCEDFP))
3395 strcat (buf, ", reduced fp model");
3396 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3397 strcat (buf, ", no function descriptors, constant gp");
3398 else if ((e_flags & EF_IA_64_CONS_GP))
3399 strcat (buf, ", constant gp");
3400 if ((e_flags & EF_IA_64_ABSOLUTE))
3401 strcat (buf, ", absolute");
28f997cf
TG		 3402 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3403 {
3404 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3405 strcat (buf, ", vms_linkages");
3406 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3407 {
3408 case EF_IA_64_VMS_COMCOD_SUCCESS:
3409 break;
3410 case EF_IA_64_VMS_COMCOD_WARNING:
3411 strcat (buf, ", warning");
3412 break;
3413 case EF_IA_64_VMS_COMCOD_ERROR:
3414 strcat (buf, ", error");
3415 break;
3416 case EF_IA_64_VMS_COMCOD_ABORT:
3417 strcat (buf, ", abort");
3418 break;
3419 default:
bee0ee85
NC		 3420 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3421 e_flags & EF_IA_64_VMS_COMCOD);
3422 strcat (buf, ", <unknown>");
28f997cf
TG		 3423 }
3424 }
4d6ed7c8 3425 break;
179d3252
JT		 3426
3427 case EM_VAX:
3428 if ((e_flags & EF_VAX_NONPIC))
3429 strcat (buf, ", non-PIC");
3430 if ((e_flags & EF_VAX_DFLOAT))
3431 strcat (buf, ", D-Float");
3432 if ((e_flags & EF_VAX_GFLOAT))
3433 strcat (buf, ", G-Float");
3434 break;
c7927a3c 3435
619ed720
EB		 3436 case EM_VISIUM:
3437 if (e_flags & EF_VISIUM_ARCH_MCM)
3438 strcat (buf, ", mcm");
3439 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3440 strcat (buf, ", mcm24");
3441 if (e_flags & EF_VISIUM_ARCH_GR6)
3442 strcat (buf, ", gr6");
3443 break;
3444
4046d87a 3445 case EM_RL78:
1740ba0c
NC		 3446 switch (e_flags & E_FLAG_RL78_CPU_MASK)
3447 {
3448 case E_FLAG_RL78_ANY_CPU: break;
3449 case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3450 case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3451 case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3452 }
856ea05c
KP		 3453 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3454 strcat (buf, ", 64-bit doubles");
4046d87a 3455 break;
0b4362b0 3456
c7927a3c
NC		 3457 case EM_RX:
3458 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3459 strcat (buf, ", 64-bit doubles");
3460 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 3461 strcat (buf, ", dsp");
d4cb0ea0 3462 if (e_flags & E_FLAG_RX_PID)
0b4362b0 3463 strcat (buf, ", pid");
708e2187
NC		 3464 if (e_flags & E_FLAG_RX_ABI)
3465 strcat (buf, ", RX ABI");
3525236c
NC		 3466 if (e_flags & E_FLAG_RX_SINSNS_SET)
3467 strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3468 ? ", uses String instructions" : ", bans String instructions");
a117b0a5
YS		 3469 if (e_flags & E_FLAG_RX_V2)
3470 strcat (buf, ", V2");
d4cb0ea0 3471 break;
55786da2
AK		 3472
3473 case EM_S390:
3474 if (e_flags & EF_S390_HIGH_GPRS)
3475 strcat (buf, ", highgprs");
d4cb0ea0 3476 break;
40b36596
JM		 3477
3478 case EM_TI_C6000:
3479 if ((e_flags & EF_C6000_REL))
3480 strcat (buf, ", relocatable module");
d4cb0ea0 3481 break;
13761a11
NC		 3482
3483 case EM_MSP430:
3484 strcat (buf, _(": architecture variant: "));
3485 switch (e_flags & EF_MSP430_MACH)
3486 {
3487 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3488 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3489 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3490 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3491 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3492 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3493 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3494 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3495 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3496 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3497 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3498 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3499 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3500 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3501 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3502 default:
3503 strcat (buf, _(": unknown")); break;
3504 }
3505
3506 if (e_flags & ~ EF_MSP430_MACH)
3507 strcat (buf, _(": unknown extra flag bits also present"));
252b5132
RH		 3508 }
3509 }
3510
3511 return buf;
3512}
3513
252b5132 3514static const char *
d3ba0551
AM		 3515get_osabi_name (unsigned int osabi)
3516{
3517 static char buff[32];
3518
3519 switch (osabi)
3520 {
3521 case ELFOSABI_NONE: return "UNIX - System V";
3522 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3523 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 3524 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 3525 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3526 case ELFOSABI_AIX: return "UNIX - AIX";
3527 case ELFOSABI_IRIX: return "UNIX - IRIX";
3528 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3529 case ELFOSABI_TRU64: return "UNIX - TRU64";
3530 case ELFOSABI_MODESTO: return "Novell - Modesto";
3531 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3532 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3533 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 3534 case ELFOSABI_AROS: return "AROS";
11636f9e 3535 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 3536 default:
40b36596
JM		 3537 if (osabi >= 64)
3538 switch (elf_header.e_machine)
3539 {
3540 case EM_ARM:
3541 switch (osabi)
3542 {
3543 case ELFOSABI_ARM: return "ARM";
3544 default:
3545 break;
3546 }
3547 break;
3548
3549 case EM_MSP430:
3550 case EM_MSP430_OLD:
619ed720 3551 case EM_VISIUM:
40b36596
JM		 3552 switch (osabi)
3553 {
3554 case ELFOSABI_STANDALONE: return _("Standalone App");
3555 default:
3556 break;
3557 }
3558 break;
3559
3560 case EM_TI_C6000:
3561 switch (osabi)
3562 {
3563 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3564 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3565 default:
3566 break;
3567 }
3568 break;
3569
3570 default:
3571 break;
3572 }
e9e44622 3573 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 3574 return buff;
3575 }
3576}
3577
a06ea964
NC		 3578static const char *
3579get_aarch64_segment_type (unsigned long type)
3580{
3581 switch (type)
3582 {
3583 case PT_AARCH64_ARCHEXT:
3584 return "AARCH64_ARCHEXT";
3585 default:
3586 break;
3587 }
3588
3589 return NULL;
3590}
3591
b294bdf8
MM		 3592static const char *
3593get_arm_segment_type (unsigned long type)
3594{
3595 switch (type)
3596 {
3597 case PT_ARM_EXIDX:
3598 return "EXIDX";
3599 default:
3600 break;
3601 }
3602
3603 return NULL;
3604}
3605
d3ba0551
AM		 3606static const char *
3607get_mips_segment_type (unsigned long type)
252b5132
RH		 3608{
3609 switch (type)
3610 {
3611 case PT_MIPS_REGINFO:
3612 return "REGINFO";
3613 case PT_MIPS_RTPROC:
3614 return "RTPROC";
3615 case PT_MIPS_OPTIONS:
3616 return "OPTIONS";
351cdf24
MF		 3617 case PT_MIPS_ABIFLAGS:
3618 return "ABIFLAGS";
252b5132
RH		 3619 default:
3620 break;
3621 }
3622
3623 return NULL;
3624}
3625
103f02d3 3626static const char *
d3ba0551 3627get_parisc_segment_type (unsigned long type)
103f02d3
UD		 3628{
3629 switch (type)
3630 {
3631 case PT_HP_TLS: return "HP_TLS";
3632 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3633 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3634 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3635 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3636 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3637 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3638 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3639 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3640 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3641 case PT_HP_PARALLEL: return "HP_PARALLEL";
3642 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 3643 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3644 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3645 case PT_HP_STACK: return "HP_STACK";
3646 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 3647 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3648 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 3649 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 3650 default:
3651 break;
3652 }
3653
3654 return NULL;
3655}
3656
4d6ed7c8 3657static const char *
d3ba0551 3658get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 3659{
3660 switch (type)
3661 {
3662 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3663 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 3664 case PT_HP_TLS: return "HP_TLS";
3665 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3666 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3667 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 3668 default:
3669 break;
3670 }
3671
3672 return NULL;
3673}
3674
40b36596
JM		 3675static const char *
3676get_tic6x_segment_type (unsigned long type)
3677{
3678 switch (type)
3679 {
3680 case PT_C6000_PHATTR: return "C6000_PHATTR";
3681 default:
3682 break;
3683 }
3684
3685 return NULL;
3686}
3687
5522f910
NC		 3688static const char *
3689get_solaris_segment_type (unsigned long type)
3690{
3691 switch (type)
3692 {
3693 case 0x6464e550: return "PT_SUNW_UNWIND";
3694 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3695 case 0x6ffffff7: return "PT_LOSUNW";
3696 case 0x6ffffffa: return "PT_SUNWBSS";
3697 case 0x6ffffffb: return "PT_SUNWSTACK";
3698 case 0x6ffffffc: return "PT_SUNWDTRACE";
3699 case 0x6ffffffd: return "PT_SUNWCAP";
3700 case 0x6fffffff: return "PT_HISUNW";
3701 default: return NULL;
3702 }
3703}
3704
252b5132 3705static const char *
d3ba0551 3706get_segment_type (unsigned long p_type)
252b5132 3707{
b34976b6 3708 static char buff[32];
252b5132
RH		 3709
3710 switch (p_type)
3711 {
b34976b6
AM		 3712 case PT_NULL: return "NULL";
3713 case PT_LOAD: return "LOAD";
252b5132 3714 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 3715 case PT_INTERP: return "INTERP";
3716 case PT_NOTE: return "NOTE";
3717 case PT_SHLIB: return "SHLIB";
3718 case PT_PHDR: return "PHDR";
13ae64f3 3719 case PT_TLS: return "TLS";
252b5132 3720
65765700
JJ		 3721 case PT_GNU_EH_FRAME:
3722 return "GNU_EH_FRAME";
2b05f1b7 3723 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 3724 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 3725
252b5132
RH		 3726 default:
3727 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3728 {
2cf0635d 3729 const char * result;
103f02d3 3730
252b5132
RH		 3731 switch (elf_header.e_machine)
3732 {
a06ea964
NC		 3733 case EM_AARCH64:
3734 result = get_aarch64_segment_type (p_type);
3735 break;
b294bdf8
MM		 3736 case EM_ARM:
3737 result = get_arm_segment_type (p_type);
3738 break;
252b5132 3739 case EM_MIPS:
4fe85591 3740 case EM_MIPS_RS3_LE:
252b5132
RH		 3741 result = get_mips_segment_type (p_type);
3742 break;
103f02d3
UD		 3743 case EM_PARISC:
3744 result = get_parisc_segment_type (p_type);
3745 break;
4d6ed7c8
NC		 3746 case EM_IA_64:
3747 result = get_ia64_segment_type (p_type);
3748 break;
40b36596
JM		 3749 case EM_TI_C6000:
3750 result = get_tic6x_segment_type (p_type);
3751 break;
252b5132
RH		 3752 default:
3753 result = NULL;
3754 break;
3755 }
103f02d3 3756
252b5132
RH		 3757 if (result != NULL)
3758 return result;
103f02d3 3759
252b5132
RH		 3760 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3761 }
3762 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 3763 {
2cf0635d 3764 const char * result;
103f02d3
UD		 3765
3766 switch (elf_header.e_machine)
3767 {
3768 case EM_PARISC:
3769 result = get_parisc_segment_type (p_type);
3770 break;
00428cca
AM		 3771 case EM_IA_64:
3772 result = get_ia64_segment_type (p_type);
3773 break;
103f02d3 3774 default:
5522f910
NC		 3775 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
3776 result = get_solaris_segment_type (p_type);
3777 else
3778 result = NULL;
103f02d3
UD		 3779 break;
3780 }
3781
3782 if (result != NULL)
3783 return result;
3784
3785 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3786 }
252b5132 3787 else
e9e44622 3788 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 3789
3790 return buff;
3791 }
3792}
3793
3794static const char *
d3ba0551 3795get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 3796{
3797 switch (sh_type)
3798 {
b34976b6
AM		 3799 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3800 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3801 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3802 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3803 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3804 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3805 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3806 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3807 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3808 case SHT_MIPS_RELD: return "MIPS_RELD";
3809 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3810 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3811 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3812 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3813 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3814 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3815 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3816 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3817 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3818 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3819 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3820 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3821 case SHT_MIPS_LINE: return "MIPS_LINE";
3822 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3823 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3824 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3825 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3826 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3827 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3828 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3829 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3830 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3831 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3832 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3833 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3834 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3835 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3836 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132 3837 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
351cdf24 3838 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
252b5132
RH		 3839 default:
3840 break;
3841 }
3842 return NULL;
3843}
3844
103f02d3 3845static const char *
d3ba0551 3846get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 3847{
3848 switch (sh_type)
3849 {
3850 case SHT_PARISC_EXT: return "PARISC_EXT";
3851 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3852 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 3853 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3854 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3855 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 3856 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 3857 default:
3858 break;
3859 }
3860 return NULL;
3861}
3862
4d6ed7c8 3863static const char *
d3ba0551 3864get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 3865{
18bd398b 3866 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 3867 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3868 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 3869
4d6ed7c8
NC		 3870 switch (sh_type)
3871 {
148b93f2
NC		 3872 case SHT_IA_64_EXT: return "IA_64_EXT";
3873 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3874 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3875 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3876 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3877 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3878 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3879 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3880 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3881 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 3882 default:
3883 break;
3884 }
3885 return NULL;
3886}
3887
d2b2c203
DJ		 3888static const char *
3889get_x86_64_section_type_name (unsigned int sh_type)
3890{
3891 switch (sh_type)
3892 {
3893 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3894 default:
3895 break;
3896 }
3897 return NULL;
3898}
3899
a06ea964
NC		 3900static const char *
3901get_aarch64_section_type_name (unsigned int sh_type)
3902{
3903 switch (sh_type)
3904 {
3905 case SHT_AARCH64_ATTRIBUTES:
3906 return "AARCH64_ATTRIBUTES";
3907 default:
3908 break;
3909 }
3910 return NULL;
3911}
3912
40a18ebd
NC		 3913static const char *
3914get_arm_section_type_name (unsigned int sh_type)
3915{
3916 switch (sh_type)
3917 {
7f6fed87
NC		 3918 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3919 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3920 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3921 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3922 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 3923 default:
3924 break;
3925 }
3926 return NULL;
3927}
3928
40b36596
JM		 3929static const char *
3930get_tic6x_section_type_name (unsigned int sh_type)
3931{
3932 switch (sh_type)
3933 {
3934 case SHT_C6000_UNWIND:
3935 return "C6000_UNWIND";
3936 case SHT_C6000_PREEMPTMAP:
3937 return "C6000_PREEMPTMAP";
3938 case SHT_C6000_ATTRIBUTES:
3939 return "C6000_ATTRIBUTES";
3940 case SHT_TI_ICODE:
3941 return "TI_ICODE";
3942 case SHT_TI_XREF:
3943 return "TI_XREF";
3944 case SHT_TI_HANDLER:
3945 return "TI_HANDLER";
3946 case SHT_TI_INITINFO:
3947 return "TI_INITINFO";
3948 case SHT_TI_PHATTRS:
3949 return "TI_PHATTRS";
3950 default:
3951 break;
3952 }
3953 return NULL;
3954}
3955
13761a11
NC		 3956static const char *
3957get_msp430x_section_type_name (unsigned int sh_type)
3958{
3959 switch (sh_type)
3960 {
3961 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
3962 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3963 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
3964 default: return NULL;
3965 }
3966}
3967
685080f2
NC		 3968static const char *
3969get_v850_section_type_name (unsigned int sh_type)
3970{
3971 switch (sh_type)
3972 {
3973 case SHT_V850_SCOMMON: return "V850 Small Common";
3974 case SHT_V850_TCOMMON: return "V850 Tiny Common";
3975 case SHT_V850_ZCOMMON: return "V850 Zero Common";
3976 case SHT_RENESAS_IOP: return "RENESAS IOP";
3977 case SHT_RENESAS_INFO: return "RENESAS INFO";
3978 default: return NULL;
3979 }
3980}
3981
252b5132 3982static const char *
d3ba0551 3983get_section_type_name (unsigned int sh_type)
252b5132 3984{
b34976b6 3985 static char buff[32];
9fb71ee4 3986 const char * result;
252b5132
RH		 3987
3988 switch (sh_type)
3989 {
3990 case SHT_NULL: return "NULL";
3991 case SHT_PROGBITS: return "PROGBITS";
3992 case SHT_SYMTAB: return "SYMTAB";
3993 case SHT_STRTAB: return "STRTAB";
3994 case SHT_RELA: return "RELA";
3995 case SHT_HASH: return "HASH";
3996 case SHT_DYNAMIC: return "DYNAMIC";
3997 case SHT_NOTE: return "NOTE";
3998 case SHT_NOBITS: return "NOBITS";
3999 case SHT_REL: return "REL";
4000 case SHT_SHLIB: return "SHLIB";
4001 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 4002 case SHT_INIT_ARRAY: return "INIT_ARRAY";
4003 case SHT_FINI_ARRAY: return "FINI_ARRAY";
4004 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 4005 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 4006 case SHT_GROUP: return "GROUP";
4007 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 4008 case SHT_GNU_verdef: return "VERDEF";
4009 case SHT_GNU_verneed: return "VERNEED";
4010 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 4011 case 0x6ffffff0: return "VERSYM";
4012 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 4013 case 0x7ffffffd: return "AUXILIARY";
4014 case 0x7fffffff: return "FILTER";
047b2264 4015 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 4016
4017 default:
4018 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4019 {
252b5132
RH		 4020 switch (elf_header.e_machine)
4021 {
4022 case EM_MIPS:
4fe85591 4023 case EM_MIPS_RS3_LE:
252b5132
RH		 4024 result = get_mips_section_type_name (sh_type);
4025 break;
103f02d3
UD		 4026 case EM_PARISC:
4027 result = get_parisc_section_type_name (sh_type);
4028 break;
4d6ed7c8
NC		 4029 case EM_IA_64:
4030 result = get_ia64_section_type_name (sh_type);
4031 break;
d2b2c203 4032 case EM_X86_64:
8a9036a4 4033 case EM_L1OM:
7a9068fe 4034 case EM_K1OM:
d2b2c203
DJ		 4035 result = get_x86_64_section_type_name (sh_type);
4036 break;
a06ea964
NC		 4037 case EM_AARCH64:
4038 result = get_aarch64_section_type_name (sh_type);
4039 break;
40a18ebd
NC		 4040 case EM_ARM:
4041 result = get_arm_section_type_name (sh_type);
4042 break;
40b36596
JM		 4043 case EM_TI_C6000:
4044 result = get_tic6x_section_type_name (sh_type);
4045 break;
13761a11
NC		 4046 case EM_MSP430:
4047 result = get_msp430x_section_type_name (sh_type);
4048 break;
685080f2
NC		 4049 case EM_V800:
4050 case EM_V850:
4051 case EM_CYGNUS_V850:
4052 result = get_v850_section_type_name (sh_type);
4053 break;
252b5132
RH		 4054 default:
4055 result = NULL;
4056 break;
4057 }
4058
4059 if (result != NULL)
4060 return result;
4061
9fb71ee4 4062 sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
252b5132
RH		 4063 }
4064 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 4065 {
148b93f2
NC		 4066 switch (elf_header.e_machine)
4067 {
4068 case EM_IA_64:
4069 result = get_ia64_section_type_name (sh_type);
4070 break;
4071 default:
fd85a6a1
NC		 4072 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4073 result = get_solaris_section_type (sh_type);
4074 else
4075 result = NULL;
148b93f2
NC		 4076 break;
4077 }
4078
4079 if (result != NULL)
4080 return result;
4081
9fb71ee4 4082 sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
148b93f2 4083 }
252b5132 4084 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
685080f2
NC		 4085 {
4086 switch (elf_header.e_machine)
4087 {
4088 case EM_V800:
4089 case EM_V850:
4090 case EM_CYGNUS_V850:
9fb71ee4 4091 result = get_v850_section_type_name (sh_type);
a9fb83be 4092 break;
685080f2 4093 default:
9fb71ee4 4094 result = NULL;
685080f2
NC		 4095 break;
4096 }
4097
9fb71ee4
NC		 4098 if (result != NULL)
4099 return result;
4100
4101 sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
685080f2 4102 }
252b5132 4103 else
a7dbfd1c
NC		 4104 /* This message is probably going to be displayed in a 15
4105 character wide field, so put the hex value first. */
4106 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 4107
252b5132
RH		 4108 return buff;
4109 }
4110}
4111
2979dc34 4112#define OPTION_DEBUG_DUMP 512
2c610e4b 4113#define OPTION_DYN_SYMS 513
fd2f0033
TT		 4114#define OPTION_DWARF_DEPTH 514
4115#define OPTION_DWARF_START 515
4723351a 4116#define OPTION_DWARF_CHECK 516
2979dc34 4117
85b1c36d 4118static struct option options[] =
252b5132 4119{
b34976b6 4120 {"all", no_argument, 0, 'a'},
252b5132
RH		 4121 {"file-header", no_argument, 0, 'h'},
4122 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 4123 {"headers", no_argument, 0, 'e'},
4124 {"histogram", no_argument, 0, 'I'},
4125 {"segments", no_argument, 0, 'l'},
4126 {"sections", no_argument, 0, 'S'},
252b5132 4127 {"section-headers", no_argument, 0, 'S'},
f5842774 4128 {"section-groups", no_argument, 0, 'g'},
5477e8a0 4129 {"section-details", no_argument, 0, 't'},
595cf52e 4130 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 4131 {"symbols", no_argument, 0, 's'},
4132 {"syms", no_argument, 0, 's'},
2c610e4b 4133 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 4134 {"relocs", no_argument, 0, 'r'},
4135 {"notes", no_argument, 0, 'n'},
4136 {"dynamic", no_argument, 0, 'd'},
a952a375 4137 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 4138 {"version-info", no_argument, 0, 'V'},
4139 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 4140 {"unwind", no_argument, 0, 'u'},
4145f1d5 4141 {"archive-index", no_argument, 0, 'c'},
b34976b6 4142 {"hex-dump", required_argument, 0, 'x'},
cf13d699 4143 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 4144 {"string-dump", required_argument, 0, 'p'},
0e602686 4145 {"decompress", no_argument, 0, 'z'},
252b5132
RH		 4146#ifdef SUPPORT_DISASSEMBLY
4147 {"instruction-dump", required_argument, 0, 'i'},
4148#endif
cf13d699 4149 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 4150
fd2f0033
TT		 4151 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
4152 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 4153 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 4154
b34976b6
AM		 4155 {"version", no_argument, 0, 'v'},
4156 {"wide", no_argument, 0, 'W'},
4157 {"help", no_argument, 0, 'H'},
4158 {0, no_argument, 0, 0}
252b5132
RH		 4159};
4160
4161static void
2cf0635d 4162usage (FILE * stream)
252b5132 4163{
92f01d61
JM		 4164 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4165 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4166 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 4167 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4168 -h --file-header Display the ELF file header\n\
4169 -l --program-headers Display the program headers\n\
4170 --segments An alias for --program-headers\n\
4171 -S --section-headers Display the sections' header\n\
4172 --sections An alias for --section-headers\n\
f5842774 4173 -g --section-groups Display the section groups\n\
5477e8a0 4174 -t --section-details Display the section details\n\
8b53311e
NC		 4175 -e --headers Equivalent to: -h -l -S\n\
4176 -s --syms Display the symbol table\n\
3f08eb35 4177 --symbols An alias for --syms\n\
2c610e4b 4178 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 4179 -n --notes Display the core notes (if present)\n\
4180 -r --relocs Display the relocations (if present)\n\
4181 -u --unwind Display the unwind info (if present)\n\
b2d38a17 4182 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 4183 -V --version-info Display the version sections (if present)\n\
1b31d05e 4184 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 4185 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 4186 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 4187 -x --hex-dump=<number|name>\n\
4188 Dump the contents of section <number|name> as bytes\n\
4189 -p --string-dump=<number|name>\n\
4190 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 4191 -R --relocated-dump=<number|name>\n\
4192 Dump the contents of section <number|name> as relocated bytes\n\
0e602686 4193 -z --decompress Decompress section before dumping it\n\
f9f0e732 4194 -w[lLiaprmfFsoRt] or\n\
1ed06042 4195 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 4196 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC		 4197 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4198 =addr,=cu_index]\n\
8b53311e 4199 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 4200 fprintf (stream, _("\
4201 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4202 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4203 or deeper\n"));
252b5132 4204#ifdef SUPPORT_DISASSEMBLY
92f01d61 4205 fprintf (stream, _("\
09c11c86
NC		 4206 -i --instruction-dump=<number|name>\n\
4207 Disassemble the contents of section <number|name>\n"));
252b5132 4208#endif
92f01d61 4209 fprintf (stream, _("\
8b53311e
NC		 4210 -I --histogram Display histogram of bucket list lengths\n\
4211 -W --wide Allow output width to exceed 80 characters\n\
07012eee 4212 @<file> Read options from <file>\n\
8b53311e
NC		 4213 -H --help Display this information\n\
4214 -v --version Display the version number of readelf\n"));
1118d252 4215
92f01d61
JM		 4216 if (REPORT_BUGS_TO[0] && stream == stdout)
4217 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 4218
92f01d61 4219 exit (stream == stdout ? 0 : 1);
252b5132
RH		 4220}
4221
18bd398b
NC		 4222/* Record the fact that the user wants the contents of section number
4223 SECTION to be displayed using the method(s) encoded as flags bits
4224 in TYPE. Note, TYPE can be zero if we are creating the array for
4225 the first time. */
4226
252b5132 4227static void
09c11c86 4228request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 4229{
4230 if (section >= num_dump_sects)
4231 {
2cf0635d 4232 dump_type * new_dump_sects;
252b5132 4233
3f5e193b
NC		 4234 new_dump_sects = (dump_type *) calloc (section + 1,
4235 sizeof (* dump_sects));
252b5132
RH		 4236
4237 if (new_dump_sects == NULL)
591a748a 4238 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 4239 else
4240 {
21b65bac
NC		 4241 if (dump_sects)
4242 {
4243 /* Copy current flag settings. */
4244 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132 4245
21b65bac
NC		 4246 free (dump_sects);
4247 }
252b5132
RH		 4248
4249 dump_sects = new_dump_sects;
4250 num_dump_sects = section + 1;
4251 }
4252 }
4253
4254 if (dump_sects)
b34976b6 4255 dump_sects[section] |= type;
252b5132
RH		 4256
4257 return;
4258}
4259
aef1f6d0
DJ		 4260/* Request a dump by section name. */
4261
4262static void
2cf0635d 4263request_dump_byname (const char * section, dump_type type)
aef1f6d0 4264{
2cf0635d 4265 struct dump_list_entry * new_request;
aef1f6d0 4266
3f5e193b
NC		 4267 new_request = (struct dump_list_entry *)
4268 malloc (sizeof (struct dump_list_entry));
aef1f6d0 4269 if (!new_request)
591a748a 4270 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4271
4272 new_request->name = strdup (section);
4273 if (!new_request->name)
591a748a 4274 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4275
4276 new_request->type = type;
4277
4278 new_request->next = dump_sects_byname;
4279 dump_sects_byname = new_request;
4280}
4281
cf13d699
NC		 4282static inline void
4283request_dump (dump_type type)
4284{
4285 int section;
4286 char * cp;
4287
4288 do_dump++;
4289 section = strtoul (optarg, & cp, 0);
4290
4291 if (! *cp && section >= 0)
4292 request_dump_bynumber (section, type);
4293 else
4294 request_dump_byname (optarg, type);
4295}
4296
4297
252b5132 4298static void
2cf0635d 4299parse_args (int argc, char ** argv)
252b5132
RH		 4300{
4301 int c;
4302
4303 if (argc < 2)
92f01d61 4304 usage (stderr);
252b5132
RH		 4305
4306 while ((c = getopt_long
0e602686 4307 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
252b5132 4308 {
252b5132
RH		 4309 switch (c)
4310 {
4311 case 0:
4312 /* Long options. */
4313 break;
4314 case 'H':
92f01d61 4315 usage (stdout);
252b5132
RH		 4316 break;
4317
4318 case 'a':
b34976b6
AM		 4319 do_syms++;
4320 do_reloc++;
4321 do_unwind++;
4322 do_dynamic++;
4323 do_header++;
4324 do_sections++;
f5842774 4325 do_section_groups++;
b34976b6
AM		 4326 do_segments++;
4327 do_version++;
4328 do_histogram++;
4329 do_arch++;
4330 do_notes++;
252b5132 4331 break;
f5842774
L		 4332 case 'g':
4333 do_section_groups++;
4334 break;
5477e8a0 4335 case 't':
595cf52e 4336 case 'N':
5477e8a0
L		 4337 do_sections++;
4338 do_section_details++;
595cf52e 4339 break;
252b5132 4340 case 'e':
b34976b6
AM		 4341 do_header++;
4342 do_sections++;
4343 do_segments++;
252b5132 4344 break;
a952a375 4345 case 'A':
b34976b6 4346 do_arch++;
a952a375 4347 break;
252b5132 4348 case 'D':
b34976b6 4349 do_using_dynamic++;
252b5132
RH		 4350 break;
4351 case 'r':
b34976b6 4352 do_reloc++;
252b5132 4353 break;
4d6ed7c8 4354 case 'u':
b34976b6 4355 do_unwind++;
4d6ed7c8 4356 break;
252b5132 4357 case 'h':
b34976b6 4358 do_header++;
252b5132
RH		 4359 break;
4360 case 'l':
b34976b6 4361 do_segments++;
252b5132
RH		 4362 break;
4363 case 's':
b34976b6 4364 do_syms++;
252b5132
RH		 4365 break;
4366 case 'S':
b34976b6 4367 do_sections++;
252b5132
RH		 4368 break;
4369 case 'd':
b34976b6 4370 do_dynamic++;
252b5132 4371 break;
a952a375 4372 case 'I':
b34976b6 4373 do_histogram++;
a952a375 4374 break;
779fe533 4375 case 'n':
b34976b6 4376 do_notes++;
779fe533 4377 break;
4145f1d5
NC		 4378 case 'c':
4379 do_archive_index++;
4380 break;
252b5132 4381 case 'x':
cf13d699 4382 request_dump (HEX_DUMP);
aef1f6d0 4383 break;
09c11c86 4384 case 'p':
cf13d699
NC		 4385 request_dump (STRING_DUMP);
4386 break;
4387 case 'R':
4388 request_dump (RELOC_DUMP);
09c11c86 4389 break;
0e602686
NC		 4390 case 'z':
4391 decompress_dumps++;
4392 break;
252b5132 4393 case 'w':
b34976b6 4394 do_dump++;
252b5132 4395 if (optarg == 0)
613ff48b
CC		 4396 {
4397 do_debugging = 1;
4398 dwarf_select_sections_all ();
4399 }
252b5132
RH		 4400 else
4401 {
4402 do_debugging = 0;
4cb93e3b 4403 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 4404 }
4405 break;
2979dc34 4406 case OPTION_DEBUG_DUMP:
b34976b6 4407 do_dump++;
2979dc34
JJ		 4408 if (optarg == 0)
4409 do_debugging = 1;
4410 else
4411 {
2979dc34 4412 do_debugging = 0;
4cb93e3b 4413 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 4414 }
4415 break;
fd2f0033
TT		 4416 case OPTION_DWARF_DEPTH:
4417 {
4418 char *cp;
4419
4420 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4421 }
4422 break;
4423 case OPTION_DWARF_START:
4424 {
4425 char *cp;
4426
4427 dwarf_start_die = strtoul (optarg, & cp, 0);
4428 }
4429 break;
4723351a
CC		 4430 case OPTION_DWARF_CHECK:
4431 dwarf_check = 1;
4432 break;
2c610e4b
L		 4433 case OPTION_DYN_SYMS:
4434 do_dyn_syms++;
4435 break;
252b5132
RH		 4436#ifdef SUPPORT_DISASSEMBLY
4437 case 'i':
cf13d699
NC		 4438 request_dump (DISASS_DUMP);
4439 break;
252b5132
RH		 4440#endif
4441 case 'v':
4442 print_version (program_name);
4443 break;
4444 case 'V':
b34976b6 4445 do_version++;
252b5132 4446 break;
d974e256 4447 case 'W':
b34976b6 4448 do_wide++;
d974e256 4449 break;
252b5132 4450 default:
252b5132
RH		 4451 /* xgettext:c-format */
4452 error (_("Invalid option '-%c'\n"), c);
4453 /* Drop through. */
4454 case '?':
92f01d61 4455 usage (stderr);
252b5132
RH		 4456 }
4457 }
4458
4d6ed7c8 4459 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 4460 && !do_segments && !do_header && !do_dump && !do_version
f5842774 4461 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 4462 && !do_section_groups && !do_archive_index
4463 && !do_dyn_syms)
92f01d61 4464 usage (stderr);
252b5132
RH		 4465}
4466
4467static const char *
d3ba0551 4468get_elf_class (unsigned int elf_class)
252b5132 4469{
b34976b6 4470 static char buff[32];
103f02d3 4471
252b5132
RH		 4472 switch (elf_class)
4473 {
4474 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 4475 case ELFCLASS32: return "ELF32";
4476 case ELFCLASS64: return "ELF64";
ab5e7794 4477 default:
e9e44622 4478 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 4479 return buff;
252b5132
RH		 4480 }
4481}
4482
4483static const char *
d3ba0551 4484get_data_encoding (unsigned int encoding)
252b5132 4485{
b34976b6 4486 static char buff[32];
103f02d3 4487
252b5132
RH		 4488 switch (encoding)
4489 {
4490 case ELFDATANONE: return _("none");
33c63f9d
CM		 4491 case ELFDATA2LSB: return _("2's complement, little endian");
4492 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 4493 default:
e9e44622 4494 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 4495 return buff;
252b5132
RH		 4496 }
4497}
4498
252b5132 4499/* Decode the data held in 'elf_header'. */
ee42cf8c 4500
252b5132 4501static int
d3ba0551 4502process_file_header (void)
252b5132 4503{
b34976b6
AM		 4504 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
4505 || elf_header.e_ident[EI_MAG1] != ELFMAG1
4506 || elf_header.e_ident[EI_MAG2] != ELFMAG2
4507 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 4508 {
4509 error
4510 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4511 return 0;
4512 }
4513
2dc4cec1
L		 4514 init_dwarf_regnames (elf_header.e_machine);
4515
252b5132
RH		 4516 if (do_header)
4517 {
4518 int i;
4519
4520 printf (_("ELF Header:\n"));
4521 printf (_(" Magic: "));
b34976b6
AM		 4522 for (i = 0; i < EI_NIDENT; i++)
4523 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 4524 printf ("\n");
4525 printf (_(" Class: %s\n"),
b34976b6 4526 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 4527 printf (_(" Data: %s\n"),
b34976b6 4528 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 4529 printf (_(" Version: %d %s\n"),
b34976b6
AM		 4530 elf_header.e_ident[EI_VERSION],
4531 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 4532 ? "(current)"
b34976b6 4533 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 4534 ? _("<unknown: %lx>")
789be9f7 4535 : "")));
252b5132 4536 printf (_(" OS/ABI: %s\n"),
b34976b6 4537 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 4538 printf (_(" ABI Version: %d\n"),
b34976b6 4539 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 4540 printf (_(" Type: %s\n"),
4541 get_file_type (elf_header.e_type));
4542 printf (_(" Machine: %s\n"),
4543 get_machine_name (elf_header.e_machine));
4544 printf (_(" Version: 0x%lx\n"),
4545 (unsigned long) elf_header.e_version);
76da6bbe 4546
f7a99963
NC		 4547 printf (_(" Entry point address: "));
4548 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4549 printf (_("\n Start of program headers: "));
4550 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4551 printf (_(" (bytes into file)\n Start of section headers: "));
4552 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4553 printf (_(" (bytes into file)\n"));
76da6bbe 4554
252b5132
RH		 4555 printf (_(" Flags: 0x%lx%s\n"),
4556 (unsigned long) elf_header.e_flags,
4557 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4558 printf (_(" Size of this header: %ld (bytes)\n"),
4559 (long) elf_header.e_ehsize);
4560 printf (_(" Size of program headers: %ld (bytes)\n"),
4561 (long) elf_header.e_phentsize);
2046a35d 4562 printf (_(" Number of program headers: %ld"),
252b5132 4563 (long) elf_header.e_phnum);
2046a35d
AM		 4564 if (section_headers != NULL
4565 && elf_header.e_phnum == PN_XNUM
4566 && section_headers[0].sh_info != 0)
cc5914eb 4567 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 4568 putc ('\n', stdout);
252b5132
RH		 4569 printf (_(" Size of section headers: %ld (bytes)\n"),
4570 (long) elf_header.e_shentsize);
560f3c1c 4571 printf (_(" Number of section headers: %ld"),
252b5132 4572 (long) elf_header.e_shnum);
4fbb74a6 4573 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 4574 printf (" (%ld)", (long) section_headers[0].sh_size);
4575 putc ('\n', stdout);
4576 printf (_(" Section header string table index: %ld"),
252b5132 4577 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 4578 if (section_headers != NULL
4579 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 4580 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 4581 else if (elf_header.e_shstrndx != SHN_UNDEF
4582 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 4583 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 4584 putc ('\n', stdout);
4585 }
4586
4587 if (section_headers != NULL)
4588 {
2046a35d
AM		 4589 if (elf_header.e_phnum == PN_XNUM
4590 && section_headers[0].sh_info != 0)
4591 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 4592 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 4593 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 4594 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 4595 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 4596 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 4597 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 4598 free (section_headers);
4599 section_headers = NULL;
252b5132 4600 }
103f02d3 4601
9ea033b2
NC		 4602 return 1;
4603}
4604
e0a31db1 4605static bfd_boolean
91d6fa6a 4606get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4607{
2cf0635d
NC		 4608 Elf32_External_Phdr * phdrs;
4609 Elf32_External_Phdr * external;
4610 Elf_Internal_Phdr * internal;
b34976b6 4611 unsigned int i;
e0a31db1
NC		 4612 unsigned int size = elf_header.e_phentsize;
4613 unsigned int num = elf_header.e_phnum;
4614
4615 /* PR binutils/17531: Cope with unexpected section header sizes. */
4616 if (size == 0 || num == 0)
4617 return FALSE;
4618 if (size < sizeof * phdrs)
4619 {
4620 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4621 return FALSE;
4622 }
4623 if (size > sizeof * phdrs)
4624 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4625
3f5e193b 4626 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1
NC		 4627 size, num, _("program headers"));
4628 if (phdrs == NULL)
4629 return FALSE;
9ea033b2 4630
91d6fa6a 4631 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4632 i < elf_header.e_phnum;
b34976b6 4633 i++, internal++, external++)
252b5132 4634 {
9ea033b2
NC		 4635 internal->p_type = BYTE_GET (external->p_type);
4636 internal->p_offset = BYTE_GET (external->p_offset);
4637 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4638 internal->p_paddr = BYTE_GET (external->p_paddr);
4639 internal->p_filesz = BYTE_GET (external->p_filesz);
4640 internal->p_memsz = BYTE_GET (external->p_memsz);
4641 internal->p_flags = BYTE_GET (external->p_flags);
4642 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 4643 }
4644
9ea033b2 4645 free (phdrs);
e0a31db1 4646 return TRUE;
252b5132
RH		 4647}
4648
e0a31db1 4649static bfd_boolean
91d6fa6a 4650get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4651{
2cf0635d
NC		 4652 Elf64_External_Phdr * phdrs;
4653 Elf64_External_Phdr * external;
4654 Elf_Internal_Phdr * internal;
b34976b6 4655 unsigned int i;
e0a31db1
NC		 4656 unsigned int size = elf_header.e_phentsize;
4657 unsigned int num = elf_header.e_phnum;
4658
4659 /* PR binutils/17531: Cope with unexpected section header sizes. */
4660 if (size == 0 || num == 0)
4661 return FALSE;
4662 if (size < sizeof * phdrs)
4663 {
4664 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4665 return FALSE;
4666 }
4667 if (size > sizeof * phdrs)
4668 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4669
3f5e193b 4670 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1 4671 size, num, _("program headers"));
a6e9f9df 4672 if (!phdrs)
e0a31db1 4673 return FALSE;
9ea033b2 4674
91d6fa6a 4675 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4676 i < elf_header.e_phnum;
b34976b6 4677 i++, internal++, external++)
9ea033b2
NC		 4678 {
4679 internal->p_type = BYTE_GET (external->p_type);
4680 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 4681 internal->p_offset = BYTE_GET (external->p_offset);
4682 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4683 internal->p_paddr = BYTE_GET (external->p_paddr);
4684 internal->p_filesz = BYTE_GET (external->p_filesz);
4685 internal->p_memsz = BYTE_GET (external->p_memsz);
4686 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 4687 }
4688
4689 free (phdrs);
e0a31db1 4690 return TRUE;
9ea033b2 4691}
252b5132 4692
d93f0186
NC		 4693/* Returns 1 if the program headers were read into `program_headers'. */
4694
4695static int
2cf0635d 4696get_program_headers (FILE * file)
d93f0186 4697{
2cf0635d 4698 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 4699
4700 /* Check cache of prior read. */
4701 if (program_headers != NULL)
4702 return 1;
4703
3f5e193b
NC		 4704 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4705 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 4706
4707 if (phdrs == NULL)
4708 {
8b73c356
NC		 4709 error (_("Out of memory reading %u program headers\n"),
4710 elf_header.e_phnum);
d93f0186
NC		 4711 return 0;
4712 }
4713
4714 if (is_32bit_elf
4715 ? get_32bit_program_headers (file, phdrs)
4716 : get_64bit_program_headers (file, phdrs))
4717 {
4718 program_headers = phdrs;
4719 return 1;
4720 }
4721
4722 free (phdrs);
4723 return 0;
4724}
4725
2f62977e
NC		 4726/* Returns 1 if the program headers were loaded. */
4727
252b5132 4728static int
2cf0635d 4729process_program_headers (FILE * file)
252b5132 4730{
2cf0635d 4731 Elf_Internal_Phdr * segment;
b34976b6 4732 unsigned int i;
252b5132
RH		 4733
4734 if (elf_header.e_phnum == 0)
4735 {
82f2dbf7
NC		 4736 /* PR binutils/12467. */
4737 if (elf_header.e_phoff != 0)
4738 warn (_("possibly corrupt ELF header - it has a non-zero program"
9035ed51 4739 " header offset, but no program headers\n"));
82f2dbf7 4740 else if (do_segments)
252b5132 4741 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 4742 return 0;
252b5132
RH		 4743 }
4744
4745 if (do_segments && !do_header)
4746 {
f7a99963
NC		 4747 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4748 printf (_("Entry point "));
4749 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4750 printf (_("\nThere are %d program headers, starting at offset "),
4751 elf_header.e_phnum);
4752 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4753 printf ("\n");
252b5132
RH		 4754 }
4755
d93f0186 4756 if (! get_program_headers (file))
252b5132 4757 return 0;
103f02d3 4758
252b5132
RH		 4759 if (do_segments)
4760 {
3a1a2036
NC		 4761 if (elf_header.e_phnum > 1)
4762 printf (_("\nProgram Headers:\n"));
4763 else
4764 printf (_("\nProgram Headers:\n"));
76da6bbe 4765
f7a99963
NC		 4766 if (is_32bit_elf)
4767 printf
4768 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 4769 else if (do_wide)
4770 printf
4771 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 4772 else
4773 {
4774 printf
4775 (_(" Type Offset VirtAddr PhysAddr\n"));
4776 printf
4777 (_(" FileSiz MemSiz Flags Align\n"));
4778 }
252b5132
RH		 4779 }
4780
252b5132 4781 dynamic_addr = 0;
1b228002 4782 dynamic_size = 0;
252b5132
RH		 4783
4784 for (i = 0, segment = program_headers;
4785 i < elf_header.e_phnum;
b34976b6 4786 i++, segment++)
252b5132
RH		 4787 {
4788 if (do_segments)
4789 {
103f02d3 4790 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 4791
4792 if (is_32bit_elf)
4793 {
4794 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4795 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4796 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4797 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4798 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4799 printf ("%c%c%c ",
4800 (segment->p_flags & PF_R ? 'R' : ' '),
4801 (segment->p_flags & PF_W ? 'W' : ' '),
4802 (segment->p_flags & PF_X ? 'E' : ' '));
4803 printf ("%#lx", (unsigned long) segment->p_align);
4804 }
d974e256
JJ		 4805 else if (do_wide)
4806 {
4807 if ((unsigned long) segment->p_offset == segment->p_offset)
4808 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4809 else
4810 {
4811 print_vma (segment->p_offset, FULL_HEX);
4812 putchar (' ');
4813 }
4814
4815 print_vma (segment->p_vaddr, FULL_HEX);
4816 putchar (' ');
4817 print_vma (segment->p_paddr, FULL_HEX);
4818 putchar (' ');
4819
4820 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4821 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4822 else
4823 {
4824 print_vma (segment->p_filesz, FULL_HEX);
4825 putchar (' ');
4826 }
4827
4828 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4829 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4830 else
4831 {
f48e6c45 4832 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 4833 }
4834
4835 printf (" %c%c%c ",
4836 (segment->p_flags & PF_R ? 'R' : ' '),
4837 (segment->p_flags & PF_W ? 'W' : ' '),
4838 (segment->p_flags & PF_X ? 'E' : ' '));
4839
4840 if ((unsigned long) segment->p_align == segment->p_align)
4841 printf ("%#lx", (unsigned long) segment->p_align);
4842 else
4843 {
4844 print_vma (segment->p_align, PREFIX_HEX);
4845 }
4846 }
f7a99963
NC		 4847 else
4848 {
4849 print_vma (segment->p_offset, FULL_HEX);
4850 putchar (' ');
4851 print_vma (segment->p_vaddr, FULL_HEX);
4852 putchar (' ');
4853 print_vma (segment->p_paddr, FULL_HEX);
4854 printf ("\n ");
4855 print_vma (segment->p_filesz, FULL_HEX);
4856 putchar (' ');
4857 print_vma (segment->p_memsz, FULL_HEX);
4858 printf (" %c%c%c ",
4859 (segment->p_flags & PF_R ? 'R' : ' '),
4860 (segment->p_flags & PF_W ? 'W' : ' '),
4861 (segment->p_flags & PF_X ? 'E' : ' '));
4862 print_vma (segment->p_align, HEX);
4863 }
252b5132
RH		 4864 }
4865
f54498b4
NC		 4866 if (do_segments)
4867 putc ('\n', stdout);
4868
252b5132
RH		 4869 switch (segment->p_type)
4870 {
252b5132
RH		 4871 case PT_DYNAMIC:
4872 if (dynamic_addr)
4873 error (_("more than one dynamic segment\n"));
4874
20737c13
AM		 4875 /* By default, assume that the .dynamic section is the first
4876 section in the DYNAMIC segment. */
4877 dynamic_addr = segment->p_offset;
4878 dynamic_size = segment->p_filesz;
f54498b4
NC		 4879 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4880 if (dynamic_addr + dynamic_size >= current_file_size)
4881 {
4882 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4883 dynamic_addr = dynamic_size = 0;
4884 }
20737c13 4885
b2d38a17
NC		 4886 /* Try to locate the .dynamic section. If there is
4887 a section header table, we can easily locate it. */
4888 if (section_headers != NULL)
4889 {
2cf0635d 4890 Elf_Internal_Shdr * sec;
b2d38a17 4891
89fac5e3
RS		 4892 sec = find_section (".dynamic");
4893 if (sec == NULL || sec->sh_size == 0)
b2d38a17 4894 {
28f997cf
TG		 4895 /* A corresponding .dynamic section is expected, but on
4896 IA-64/OpenVMS it is OK for it to be missing. */
4897 if (!is_ia64_vms ())
4898 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 4899 break;
4900 }
4901
42bb2e33 4902 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 4903 {
4904 dynamic_size = 0;
4905 break;
4906 }
42bb2e33 4907
b2d38a17
NC		 4908 dynamic_addr = sec->sh_offset;
4909 dynamic_size = sec->sh_size;
4910
4911 if (dynamic_addr < segment->p_offset
4912 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 4913 warn (_("the .dynamic section is not contained"
4914 " within the dynamic segment\n"));
b2d38a17 4915 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 4916 warn (_("the .dynamic section is not the first section"
4917 " in the dynamic segment.\n"));
b2d38a17 4918 }
252b5132
RH		 4919 break;
4920
4921 case PT_INTERP:
fb52b2f4
NC		 4922 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4923 SEEK_SET))
252b5132
RH		 4924 error (_("Unable to find program interpreter name\n"));
4925 else
4926 {
f8eae8b2 4927 char fmt [32];
9495b2e6 4928 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
f8eae8b2
L		 4929
4930 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 4931 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 4932
252b5132 4933 program_interpreter[0] = 0;
7bd7b3ef
AM		 4934 if (fscanf (file, fmt, program_interpreter) <= 0)
4935 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 4936
4937 if (do_segments)
f54498b4 4938 printf (_(" [Requesting program interpreter: %s]\n"),
252b5132
RH		 4939 program_interpreter);
4940 }
4941 break;
4942 }
252b5132
RH		 4943 }
4944
c256ffe7 4945 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 4946 {
4947 printf (_("\n Section to Segment mapping:\n"));
4948 printf (_(" Segment Sections...\n"));
4949
252b5132
RH		 4950 for (i = 0; i < elf_header.e_phnum; i++)
4951 {
9ad5cbcf 4952 unsigned int j;
2cf0635d 4953 Elf_Internal_Shdr * section;
252b5132
RH		 4954
4955 segment = program_headers + i;
b391a3e3 4956 section = section_headers + 1;
252b5132
RH		 4957
4958 printf (" %2.2d ", i);
4959
b34976b6 4960 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 4961 {
f4638467
AM		 4962 if (!ELF_TBSS_SPECIAL (section, segment)
4963 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
74e1a04b 4964 printf ("%s ", printable_section_name (section));
252b5132
RH		 4965 }
4966
4967 putc ('\n',stdout);
4968 }
4969 }
4970
252b5132
RH		 4971 return 1;
4972}
4973
4974
d93f0186
NC		 4975/* Find the file offset corresponding to VMA by using the program headers. */
4976
4977static long
2cf0635d 4978offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 4979{
2cf0635d 4980 Elf_Internal_Phdr * seg;
d93f0186
NC		 4981
4982 if (! get_program_headers (file))
4983 {
4984 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4985 return (long) vma;
4986 }
4987
4988 for (seg = program_headers;
4989 seg < program_headers + elf_header.e_phnum;
4990 ++seg)
4991 {
4992 if (seg->p_type != PT_LOAD)
4993 continue;
4994
4995 if (vma >= (seg->p_vaddr & -seg->p_align)
4996 && vma + size <= seg->p_vaddr + seg->p_filesz)
4997 return vma - seg->p_vaddr + seg->p_offset;
4998 }
4999
5000 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 5001 (unsigned long) vma);
d93f0186
NC		 5002 return (long) vma;
5003}
5004
5005
049b0c3a
NC		 5006/* Allocate memory and load the sections headers into the global pointer
5007 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
5008 generate any error messages if the load fails. */
5009
5010static bfd_boolean
5011get_32bit_section_headers (FILE * file, bfd_boolean probe)
252b5132 5012{
2cf0635d
NC		 5013 Elf32_External_Shdr * shdrs;
5014 Elf_Internal_Shdr * internal;
b34976b6 5015 unsigned int i;
049b0c3a
NC		 5016 unsigned int size = elf_header.e_shentsize;
5017 unsigned int num = probe ? 1 : elf_header.e_shnum;
5018
5019 /* PR binutils/17531: Cope with unexpected section header sizes. */
5020 if (size == 0 || num == 0)
5021 return FALSE;
5022 if (size < sizeof * shdrs)
5023 {
5024 if (! probe)
5025 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5026 return FALSE;
5027 }
5028 if (!probe && size > sizeof * shdrs)
5029 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
252b5132 5030
3f5e193b 5031 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 5032 size, num,
5033 probe ? NULL : _("section headers"));
5034 if (shdrs == NULL)
5035 return FALSE;
252b5132 5036
049b0c3a
NC		 5037 if (section_headers != NULL)
5038 free (section_headers);
3f5e193b
NC		 5039 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
5040 sizeof (Elf_Internal_Shdr));
252b5132
RH		 5041 if (section_headers == NULL)
5042 {
049b0c3a 5043 if (!probe)
8b73c356 5044 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 5045 return FALSE;
252b5132
RH		 5046 }
5047
5048 for (i = 0, internal = section_headers;
560f3c1c 5049 i < num;
b34976b6 5050 i++, internal++)
252b5132
RH		 5051 {
5052 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5053 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5054 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5055 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5056 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5057 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5058 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5059 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5060 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5061 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
315350be
NC		 5062 if (!probe && internal->sh_link > num)
5063 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5064 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5065 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
252b5132
RH		 5066 }
5067
5068 free (shdrs);
049b0c3a 5069 return TRUE;
252b5132
RH		 5070}
5071
049b0c3a
NC		 5072static bfd_boolean
5073get_64bit_section_headers (FILE * file, bfd_boolean probe)
9ea033b2 5074{
2cf0635d
NC		 5075 Elf64_External_Shdr * shdrs;
5076 Elf_Internal_Shdr * internal;
b34976b6 5077 unsigned int i;
049b0c3a
NC		 5078 unsigned int size = elf_header.e_shentsize;
5079 unsigned int num = probe ? 1 : elf_header.e_shnum;
5080
5081 /* PR binutils/17531: Cope with unexpected section header sizes. */
5082 if (size == 0 || num == 0)
5083 return FALSE;
5084 if (size < sizeof * shdrs)
5085 {
5086 if (! probe)
5087 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5088 return FALSE;
5089 }
5090 if (! probe && size > sizeof * shdrs)
5091 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
9ea033b2 5092
3f5e193b 5093 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 5094 size, num,
5095 probe ? NULL : _("section headers"));
5096 if (shdrs == NULL)
5097 return FALSE;
9ea033b2 5098
049b0c3a
NC		 5099 if (section_headers != NULL)
5100 free (section_headers);
3f5e193b
NC		 5101 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
5102 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 5103 if (section_headers == NULL)
5104 {
049b0c3a 5105 if (! probe)
8b73c356 5106 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 5107 return FALSE;
9ea033b2
NC		 5108 }
5109
5110 for (i = 0, internal = section_headers;
560f3c1c 5111 i < num;
b34976b6 5112 i++, internal++)
9ea033b2
NC		 5113 {
5114 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5115 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 5116 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5117 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5118 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5119 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 5120 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5121 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5122 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5123 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
315350be
NC		 5124 if (!probe && internal->sh_link > num)
5125 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5126 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5127 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
9ea033b2
NC		 5128 }
5129
5130 free (shdrs);
049b0c3a 5131 return TRUE;
9ea033b2
NC		 5132}
5133
252b5132 5134static Elf_Internal_Sym *
ba5cdace
NC		 5135get_32bit_elf_symbols (FILE * file,
5136 Elf_Internal_Shdr * section,
5137 unsigned long * num_syms_return)
252b5132 5138{
ba5cdace 5139 unsigned long number = 0;
dd24e3da 5140 Elf32_External_Sym * esyms = NULL;
ba5cdace 5141 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 5142 Elf_Internal_Sym * isyms = NULL;
2cf0635d 5143 Elf_Internal_Sym * psym;
b34976b6 5144 unsigned int j;
252b5132 5145
c9c1d674
EG		 5146 if (section->sh_size == 0)
5147 {
5148 if (num_syms_return != NULL)
5149 * num_syms_return = 0;
5150 return NULL;
5151 }
5152
dd24e3da 5153 /* Run some sanity checks first. */
c9c1d674 5154 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 5155 {
c9c1d674
EG		 5156 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5157 printable_section_name (section), (unsigned long) section->sh_entsize);
ba5cdace 5158 goto exit_point;
dd24e3da
NC		 5159 }
5160
f54498b4
NC		 5161 if (section->sh_size > current_file_size)
5162 {
5163 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
74e1a04b 5164 printable_section_name (section), (unsigned long) section->sh_size);
f54498b4
NC		 5165 goto exit_point;
5166 }
5167
dd24e3da
NC		 5168 number = section->sh_size / section->sh_entsize;
5169
5170 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5171 {
c9c1d674 5172 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 5173 (unsigned long) section->sh_size,
5174 printable_section_name (section),
5175 (unsigned long) section->sh_entsize);
ba5cdace 5176 goto exit_point;
dd24e3da
NC		 5177 }
5178
3f5e193b
NC		 5179 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5180 section->sh_size, _("symbols"));
dd24e3da 5181 if (esyms == NULL)
ba5cdace 5182 goto exit_point;
252b5132 5183
6a40cf0c
NC		 5184 {
5185 elf_section_list * entry;
5186
5187 shndx = NULL;
5188 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5189 if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
c9c1d674 5190 {
6a40cf0c
NC		 5191 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5192 entry->hdr->sh_offset,
5193 1, entry->hdr->sh_size,
5194 _("symbol table section indicies"));
5195 if (shndx == NULL)
5196 goto exit_point;
5197 /* PR17531: file: heap-buffer-overflow */
5198 else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5199 {
5200 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5201 printable_section_name (entry->hdr),
5202 (unsigned long) entry->hdr->sh_size,
5203 (unsigned long) section->sh_size);
5204 goto exit_point;
5205 }
c9c1d674 5206 }
6a40cf0c 5207 }
9ad5cbcf 5208
3f5e193b 5209 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 5210
5211 if (isyms == NULL)
5212 {
8b73c356
NC		 5213 error (_("Out of memory reading %lu symbols\n"),
5214 (unsigned long) number);
dd24e3da 5215 goto exit_point;
252b5132
RH		 5216 }
5217
dd24e3da 5218 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 5219 {
5220 psym->st_name = BYTE_GET (esyms[j].st_name);
5221 psym->st_value = BYTE_GET (esyms[j].st_value);
5222 psym->st_size = BYTE_GET (esyms[j].st_size);
5223 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 5224 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5225 psym->st_shndx
5226 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5227 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5228 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 5229 psym->st_info = BYTE_GET (esyms[j].st_info);
5230 psym->st_other = BYTE_GET (esyms[j].st_other);
5231 }
5232
dd24e3da 5233 exit_point:
ba5cdace 5234 if (shndx != NULL)
9ad5cbcf 5235 free (shndx);
ba5cdace 5236 if (esyms != NULL)
dd24e3da 5237 free (esyms);
252b5132 5238
ba5cdace
NC		 5239 if (num_syms_return != NULL)
5240 * num_syms_return = isyms == NULL ? 0 : number;
5241
252b5132
RH		 5242 return isyms;
5243}
5244
9ea033b2 5245static Elf_Internal_Sym *
ba5cdace
NC		 5246get_64bit_elf_symbols (FILE * file,
5247 Elf_Internal_Shdr * section,
5248 unsigned long * num_syms_return)
9ea033b2 5249{
ba5cdace
NC		 5250 unsigned long number = 0;
5251 Elf64_External_Sym * esyms = NULL;
5252 Elf_External_Sym_Shndx * shndx = NULL;
5253 Elf_Internal_Sym * isyms = NULL;
2cf0635d 5254 Elf_Internal_Sym * psym;
b34976b6 5255 unsigned int j;
9ea033b2 5256
c9c1d674
EG		 5257 if (section->sh_size == 0)
5258 {
5259 if (num_syms_return != NULL)
5260 * num_syms_return = 0;
5261 return NULL;
5262 }
5263
dd24e3da 5264 /* Run some sanity checks first. */
c9c1d674 5265 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 5266 {
c9c1d674 5267 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
8066deb1
AM		 5268 printable_section_name (section),
5269 (unsigned long) section->sh_entsize);
ba5cdace 5270 goto exit_point;
dd24e3da
NC		 5271 }
5272
f54498b4
NC		 5273 if (section->sh_size > current_file_size)
5274 {
5275 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
8066deb1
AM		 5276 printable_section_name (section),
5277 (unsigned long) section->sh_size);
f54498b4
NC		 5278 goto exit_point;
5279 }
5280
dd24e3da
NC		 5281 number = section->sh_size / section->sh_entsize;
5282
5283 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5284 {
c9c1d674 5285 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 5286 (unsigned long) section->sh_size,
5287 printable_section_name (section),
5288 (unsigned long) section->sh_entsize);
ba5cdace 5289 goto exit_point;
dd24e3da
NC		 5290 }
5291
3f5e193b
NC		 5292 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5293 section->sh_size, _("symbols"));
a6e9f9df 5294 if (!esyms)
ba5cdace 5295 goto exit_point;
9ea033b2 5296
6a40cf0c
NC		 5297 {
5298 elf_section_list * entry;
5299
5300 shndx = NULL;
5301 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5302 if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
c9c1d674 5303 {
6a40cf0c
NC		 5304 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5305 entry->hdr->sh_offset,
5306 1, entry->hdr->sh_size,
5307 _("symbol table section indicies"));
5308 if (shndx == NULL)
5309 goto exit_point;
5310 /* PR17531: file: heap-buffer-overflow */
5311 else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5312 {
5313 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5314 printable_section_name (entry->hdr),
5315 (unsigned long) entry->hdr->sh_size,
5316 (unsigned long) section->sh_size);
5317 goto exit_point;
5318 }
c9c1d674 5319 }
6a40cf0c 5320 }
9ad5cbcf 5321
3f5e193b 5322 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 5323
5324 if (isyms == NULL)
5325 {
8b73c356
NC		 5326 error (_("Out of memory reading %lu symbols\n"),
5327 (unsigned long) number);
ba5cdace 5328 goto exit_point;
9ea033b2
NC		 5329 }
5330
ba5cdace 5331 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 5332 {
5333 psym->st_name = BYTE_GET (esyms[j].st_name);
5334 psym->st_info = BYTE_GET (esyms[j].st_info);
5335 psym->st_other = BYTE_GET (esyms[j].st_other);
5336 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 5337
4fbb74a6 5338 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5339 psym->st_shndx
5340 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5341 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5342 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 5343
66543521
AM		 5344 psym->st_value = BYTE_GET (esyms[j].st_value);
5345 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 5346 }
5347
ba5cdace
NC		 5348 exit_point:
5349 if (shndx != NULL)
9ad5cbcf 5350 free (shndx);
ba5cdace
NC		 5351 if (esyms != NULL)
5352 free (esyms);
5353
5354 if (num_syms_return != NULL)
5355 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 5356
5357 return isyms;
5358}
5359
d1133906 5360static const char *
d3ba0551 5361get_elf_section_flags (bfd_vma sh_flags)
d1133906 5362{
5477e8a0 5363 static char buff[1024];
2cf0635d 5364 char * p = buff;
8d5ff12c 5365 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 5366 int sindex;
5367 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 5368 bfd_vma os_flags = 0;
5369 bfd_vma proc_flags = 0;
5370 bfd_vma unknown_flags = 0;
148b93f2 5371 static const struct
5477e8a0 5372 {
2cf0635d 5373 const char * str;
5477e8a0
L		 5374 int len;
5375 }
5376 flags [] =
5377 {
cfcac11d
NC		 5378 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5379 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5380 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5381 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5382 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5383 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5384 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5385 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5386 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5387 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5388 /* IA-64 specific. */
5389 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5390 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5391 /* IA-64 OpenVMS specific. */
5392 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5393 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5394 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5395 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5396 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5397 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 5398 /* Generic. */
cfcac11d 5399 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 5400 /* SPARC specific. */
77115a4a 5401 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
ac4c9b04
MG		 5402 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5403 /* ARM specific. */
5404 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
f0728ee3 5405 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
ac4c9b04 5406 /* 23 */ { STRING_COMMA_LEN ("COMDEF") }
5477e8a0
L		 5407 };
5408
5409 if (do_section_details)
5410 {
8d5ff12c
L		 5411 sprintf (buff, "[%*.*lx]: ",
5412 field_size, field_size, (unsigned long) sh_flags);
5413 p += field_size + 4;
5477e8a0 5414 }
76da6bbe 5415
d1133906
NC		 5416 while (sh_flags)
5417 {
5418 bfd_vma flag;
5419
5420 flag = sh_flags & - sh_flags;
5421 sh_flags &= ~ flag;
76da6bbe 5422
5477e8a0 5423 if (do_section_details)
d1133906 5424 {
5477e8a0
L		 5425 switch (flag)
5426 {
91d6fa6a
NC		 5427 case SHF_WRITE: sindex = 0; break;
5428 case SHF_ALLOC: sindex = 1; break;
5429 case SHF_EXECINSTR: sindex = 2; break;
5430 case SHF_MERGE: sindex = 3; break;
5431 case SHF_STRINGS: sindex = 4; break;
5432 case SHF_INFO_LINK: sindex = 5; break;
5433 case SHF_LINK_ORDER: sindex = 6; break;
5434 case SHF_OS_NONCONFORMING: sindex = 7; break;
5435 case SHF_GROUP: sindex = 8; break;
5436 case SHF_TLS: sindex = 9; break;
18ae9cc1 5437 case SHF_EXCLUDE: sindex = 18; break;
77115a4a 5438 case SHF_COMPRESSED: sindex = 20; break;
76da6bbe 5439
5477e8a0 5440 default:
91d6fa6a 5441 sindex = -1;
cfcac11d 5442 switch (elf_header.e_machine)
148b93f2 5443 {
cfcac11d 5444 case EM_IA_64:
148b93f2 5445 if (flag == SHF_IA_64_SHORT)
91d6fa6a 5446 sindex = 10;
148b93f2 5447 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 5448 sindex = 11;
148b93f2
NC		 5449#ifdef BFD64
5450 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5451 switch (flag)
5452 {
91d6fa6a
NC		 5453 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5454 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5455 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5456 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5457 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5458 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 5459 default: break;
5460 }
5461#endif
cfcac11d
NC		 5462 break;
5463
caa83f8b 5464 case EM_386:
22abe556 5465 case EM_IAMCU:
caa83f8b 5466 case EM_X86_64:
7f502d6c 5467 case EM_L1OM:
7a9068fe 5468 case EM_K1OM:
cfcac11d
NC		 5469 case EM_OLD_SPARCV9:
5470 case EM_SPARC32PLUS:
5471 case EM_SPARCV9:
5472 case EM_SPARC:
18ae9cc1 5473 if (flag == SHF_ORDERED)
91d6fa6a 5474 sindex = 19;
cfcac11d 5475 break;
ac4c9b04
MG		 5476
5477 case EM_ARM:
5478 switch (flag)
5479 {
5480 case SHF_ENTRYSECT: sindex = 21; break;
f0728ee3 5481 case SHF_ARM_PURECODE: sindex = 22; break;
ac4c9b04
MG		 5482 case SHF_COMDEF: sindex = 23; break;
5483 default: break;
5484 }
5485 break;
5486
cfcac11d
NC		 5487 default:
5488 break;
148b93f2 5489 }
5477e8a0
L		 5490 }
5491
91d6fa6a 5492 if (sindex != -1)
5477e8a0 5493 {
8d5ff12c
L		 5494 if (p != buff + field_size + 4)
5495 {
5496 if (size < (10 + 2))
bee0ee85
NC		 5497 {
5498 warn (_("Internal error: not enough buffer room for section flag info"));
5499 return _("<unknown>");
5500 }
8d5ff12c
L		 5501 size -= 2;
5502 *p++ = ',';
5503 *p++ = ' ';
5504 }
5505
91d6fa6a
NC		 5506 size -= flags [sindex].len;
5507 p = stpcpy (p, flags [sindex].str);
5477e8a0 5508 }
3b22753a 5509 else if (flag & SHF_MASKOS)
8d5ff12c 5510 os_flags |= flag;
d1133906 5511 else if (flag & SHF_MASKPROC)
8d5ff12c 5512 proc_flags |= flag;
d1133906 5513 else
8d5ff12c 5514 unknown_flags |= flag;
5477e8a0
L		 5515 }
5516 else
5517 {
5518 switch (flag)
5519 {
5520 case SHF_WRITE: *p = 'W'; break;
5521 case SHF_ALLOC: *p = 'A'; break;
5522 case SHF_EXECINSTR: *p = 'X'; break;
5523 case SHF_MERGE: *p = 'M'; break;
5524 case SHF_STRINGS: *p = 'S'; break;
5525 case SHF_INFO_LINK: *p = 'I'; break;
5526 case SHF_LINK_ORDER: *p = 'L'; break;
5527 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5528 case SHF_GROUP: *p = 'G'; break;
5529 case SHF_TLS: *p = 'T'; break;
18ae9cc1 5530 case SHF_EXCLUDE: *p = 'E'; break;
77115a4a 5531 case SHF_COMPRESSED: *p = 'C'; break;
5477e8a0
L		 5532
5533 default:
8a9036a4 5534 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 5535 || elf_header.e_machine == EM_L1OM
5536 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 5537 && flag == SHF_X86_64_LARGE)
5538 *p = 'l';
91f68a68 5539 else if (elf_header.e_machine == EM_ARM
f0728ee3 5540 && flag == SHF_ARM_PURECODE)
91f68a68 5541 *p = 'y';
5477e8a0
L		 5542 else if (flag & SHF_MASKOS)
5543 {
5544 *p = 'o';
5545 sh_flags &= ~ SHF_MASKOS;
5546 }
5547 else if (flag & SHF_MASKPROC)
5548 {
5549 *p = 'p';
5550 sh_flags &= ~ SHF_MASKPROC;
5551 }
5552 else
5553 *p = 'x';
5554 break;
5555 }
5556 p++;
d1133906
NC		 5557 }
5558 }
76da6bbe 5559
8d5ff12c
L		 5560 if (do_section_details)
5561 {
5562 if (os_flags)
5563 {
5564 size -= 5 + field_size;
5565 if (p != buff + field_size + 4)
5566 {
5567 if (size < (2 + 1))
bee0ee85
NC		 5568 {
5569 warn (_("Internal error: not enough buffer room for section flag info"));
5570 return _("<unknown>");
5571 }
8d5ff12c
L		 5572 size -= 2;
5573 *p++ = ',';
5574 *p++ = ' ';
5575 }
5576 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5577 (unsigned long) os_flags);
5578 p += 5 + field_size;
5579 }
5580 if (proc_flags)
5581 {
5582 size -= 7 + field_size;
5583 if (p != buff + field_size + 4)
5584 {
5585 if (size < (2 + 1))
bee0ee85
NC		 5586 {
5587 warn (_("Internal error: not enough buffer room for section flag info"));
5588 return _("<unknown>");
5589 }
8d5ff12c
L		 5590 size -= 2;
5591 *p++ = ',';
5592 *p++ = ' ';
5593 }
5594 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5595 (unsigned long) proc_flags);
5596 p += 7 + field_size;
5597 }
5598 if (unknown_flags)
5599 {
5600 size -= 10 + field_size;
5601 if (p != buff + field_size + 4)
5602 {
5603 if (size < (2 + 1))
bee0ee85
NC		 5604 {
5605 warn (_("Internal error: not enough buffer room for section flag info"));
5606 return _("<unknown>");
5607 }
8d5ff12c
L		 5608 size -= 2;
5609 *p++ = ',';
5610 *p++ = ' ';
5611 }
2b692964 5612 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 5613 (unsigned long) unknown_flags);
5614 p += 10 + field_size;
5615 }
5616 }
5617
e9e44622 5618 *p = '\0';
d1133906
NC		 5619 return buff;
5620}
5621
77115a4a
L		 5622static unsigned int
5623get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf)
5624{
5625 if (is_32bit_elf)
5626 {
5627 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
d8024a91 5628
77115a4a
L		 5629 chdr->ch_type = BYTE_GET (echdr->ch_type);
5630 chdr->ch_size = BYTE_GET (echdr->ch_size);
5631 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5632 return sizeof (*echdr);
5633 }
5634 else
5635 {
5636 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
d8024a91 5637
77115a4a
L		 5638 chdr->ch_type = BYTE_GET (echdr->ch_type);
5639 chdr->ch_size = BYTE_GET (echdr->ch_size);
5640 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5641 return sizeof (*echdr);
5642 }
5643}
5644
252b5132 5645static int
2cf0635d 5646process_section_headers (FILE * file)
252b5132 5647{
2cf0635d 5648 Elf_Internal_Shdr * section;
b34976b6 5649 unsigned int i;
252b5132
RH		 5650
5651 section_headers = NULL;
5652
5653 if (elf_header.e_shnum == 0)
5654 {
82f2dbf7
NC		 5655 /* PR binutils/12467. */
5656 if (elf_header.e_shoff != 0)
5657 warn (_("possibly corrupt ELF file header - it has a non-zero"
5658 " section header offset, but no section headers\n"));
5659 else if (do_sections)
252b5132
RH		 5660 printf (_("\nThere are no sections in this file.\n"));
5661
5662 return 1;
5663 }
5664
5665 if (do_sections && !do_header)
9ea033b2 5666 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 5667 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5668
9ea033b2
NC		 5669 if (is_32bit_elf)
5670 {
049b0c3a 5671 if (! get_32bit_section_headers (file, FALSE))
9ea033b2
NC		 5672 return 0;
5673 }
049b0c3a 5674 else if (! get_64bit_section_headers (file, FALSE))
252b5132
RH		 5675 return 0;
5676
5677 /* Read in the string table, so that we have names to display. */
0b49d371 5678 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 5679 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 5680 {
4fbb74a6 5681 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 5682
c256ffe7
JJ		 5683 if (section->sh_size != 0)
5684 {
3f5e193b
NC		 5685 string_table = (char *) get_data (NULL, file, section->sh_offset,
5686 1, section->sh_size,
5687 _("string table"));
0de14b54 5688
c256ffe7
JJ		 5689 string_table_length = string_table != NULL ? section->sh_size : 0;
5690 }
252b5132
RH		 5691 }
5692
5693 /* Scan the sections for the dynamic symbol table
e3c8793a 5694 and dynamic string table and debug sections. */
252b5132
RH		 5695 dynamic_symbols = NULL;
5696 dynamic_strings = NULL;
5697 dynamic_syminfo = NULL;
6a40cf0c 5698 symtab_shndx_list = NULL;
103f02d3 5699
89fac5e3
RS		 5700 eh_addr_size = is_32bit_elf ? 4 : 8;
5701 switch (elf_header.e_machine)
5702 {
5703 case EM_MIPS:
5704 case EM_MIPS_RS3_LE:
5705 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5706 FDE addresses. However, the ABI also has a semi-official ILP32
5707 variant for which the normal FDE address size rules apply.
5708
5709 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5710 section, where XX is the size of longs in bits. Unfortunately,
5711 earlier compilers provided no way of distinguishing ILP32 objects
5712 from LP64 objects, so if there's any doubt, we should assume that
5713 the official LP64 form is being used. */
5714 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5715 && find_section (".gcc_compiled_long32") == NULL)
5716 eh_addr_size = 8;
5717 break;
0f56a26a
DD		 5718
5719 case EM_H8_300:
5720 case EM_H8_300H:
5721 switch (elf_header.e_flags & EF_H8_MACH)
5722 {
5723 case E_H8_MACH_H8300:
5724 case E_H8_MACH_H8300HN:
5725 case E_H8_MACH_H8300SN:
5726 case E_H8_MACH_H8300SXN:
5727 eh_addr_size = 2;
5728 break;
5729 case E_H8_MACH_H8300H:
5730 case E_H8_MACH_H8300S:
5731 case E_H8_MACH_H8300SX:
5732 eh_addr_size = 4;
5733 break;
5734 }
f4236fe4
DD		 5735 break;
5736
ff7eeb89 5737 case EM_M32C_OLD:
f4236fe4
DD		 5738 case EM_M32C:
5739 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5740 {
5741 case EF_M32C_CPU_M16C:
5742 eh_addr_size = 2;
5743 break;
5744 }
5745 break;
89fac5e3
RS		 5746 }
5747
76ca31c0
NC		 5748#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5749 do \
5750 { \
5751 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5752 if (section->sh_entsize != expected_entsize) \
9dd3a467 5753 { \
76ca31c0
NC		 5754 char buf[40]; \
5755 sprintf_vma (buf, section->sh_entsize); \
5756 /* Note: coded this way so that there is a single string for \
5757 translation. */ \
5758 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5759 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5760 (unsigned) expected_entsize); \
9dd3a467 5761 section->sh_entsize = expected_entsize; \
76ca31c0
NC		 5762 } \
5763 } \
08d8fa11 5764 while (0)
9dd3a467
NC		 5765
5766#define CHECK_ENTSIZE(section, i, type) \
08d8fa11
JJ		 5767 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5768 sizeof (Elf64_External_##type))
5769
252b5132
RH		 5770 for (i = 0, section = section_headers;
5771 i < elf_header.e_shnum;
b34976b6 5772 i++, section++)
252b5132 5773 {
2cf0635d 5774 char * name = SECTION_NAME (section);
252b5132
RH		 5775
5776 if (section->sh_type == SHT_DYNSYM)
5777 {
5778 if (dynamic_symbols != NULL)
5779 {
5780 error (_("File contains multiple dynamic symbol tables\n"));
5781 continue;
5782 }
5783
08d8fa11 5784 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 5785 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 5786 }
5787 else if (section->sh_type == SHT_STRTAB
18bd398b 5788 && streq (name, ".dynstr"))
252b5132
RH		 5789 {
5790 if (dynamic_strings != NULL)
5791 {
5792 error (_("File contains multiple dynamic string tables\n"));
5793 continue;
5794 }
5795
3f5e193b
NC		 5796 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5797 1, section->sh_size,
5798 _("dynamic strings"));
59245841 5799 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 5800 }
9ad5cbcf
AM		 5801 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5802 {
6a40cf0c
NC		 5803 elf_section_list * entry = xmalloc (sizeof * entry);
5804 entry->hdr = section;
5805 entry->next = symtab_shndx_list;
5806 symtab_shndx_list = entry;
9ad5cbcf 5807 }
08d8fa11
JJ		 5808 else if (section->sh_type == SHT_SYMTAB)
5809 CHECK_ENTSIZE (section, i, Sym);
5810 else if (section->sh_type == SHT_GROUP)
5811 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5812 else if (section->sh_type == SHT_REL)
5813 CHECK_ENTSIZE (section, i, Rel);
5814 else if (section->sh_type == SHT_RELA)
5815 CHECK_ENTSIZE (section, i, Rela);
252b5132 5816 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 5817 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 5818 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC		 5819 || do_debug_str || do_debug_loc || do_debug_ranges
5820 || do_debug_addr || do_debug_cu_index)
1b315056
CS		 5821 && (const_strneq (name, ".debug_")
5822 || const_strneq (name, ".zdebug_")))
252b5132 5823 {
1b315056
CS		 5824 if (name[1] == 'z')
5825 name += sizeof (".zdebug_") - 1;
5826 else
5827 name += sizeof (".debug_") - 1;
252b5132
RH		 5828
5829 if (do_debugging
4723351a
CC		 5830 || (do_debug_info && const_strneq (name, "info"))
5831 || (do_debug_info && const_strneq (name, "types"))
5832 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
b40bf0a2
NC		 5833 || (do_debug_lines && strcmp (name, "line") == 0)
5834 || (do_debug_lines && const_strneq (name, "line."))
4723351a
CC		 5835 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5836 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
459d52c8
DE		 5837 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5838 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
4723351a
CC		 5839 || (do_debug_aranges && const_strneq (name, "aranges"))
5840 || (do_debug_ranges && const_strneq (name, "ranges"))
5841 || (do_debug_frames && const_strneq (name, "frame"))
5842 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5843 || (do_debug_macinfo && const_strneq (name, "macro"))
5844 || (do_debug_str && const_strneq (name, "str"))
5845 || (do_debug_loc && const_strneq (name, "loc"))
657d0d47
CC		 5846 || (do_debug_addr && const_strneq (name, "addr"))
5847 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5848 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 5849 )
09c11c86 5850 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 5851 }
a262ae96 5852 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 5853 else if ((do_debugging || do_debug_info)
0112cd26 5854 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 5855 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 5856 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 5857 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 5858 else if (do_gdb_index && streq (name, ".gdb_index"))
5859 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 5860 /* Trace sections for Itanium VMS. */
5861 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5862 || do_trace_aranges)
5863 && const_strneq (name, ".trace_"))
5864 {
5865 name += sizeof (".trace_") - 1;
5866
5867 if (do_debugging
5868 || (do_trace_info && streq (name, "info"))
5869 || (do_trace_abbrevs && streq (name, "abbrev"))
5870 || (do_trace_aranges && streq (name, "aranges"))
5871 )
5872 request_dump_bynumber (i, DEBUG_DUMP);
5873 }
252b5132
RH		 5874 }
5875
5876 if (! do_sections)
5877 return 1;
5878
3a1a2036
NC		 5879 if (elf_header.e_shnum > 1)
5880 printf (_("\nSection Headers:\n"));
5881 else
5882 printf (_("\nSection Header:\n"));
76da6bbe 5883
f7a99963 5884 if (is_32bit_elf)
595cf52e 5885 {
5477e8a0 5886 if (do_section_details)
595cf52e
L		 5887 {
5888 printf (_(" [Nr] Name\n"));
5477e8a0 5889 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 5890 }
5891 else
5892 printf
5893 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5894 }
d974e256 5895 else if (do_wide)
595cf52e 5896 {
5477e8a0 5897 if (do_section_details)
595cf52e
L		 5898 {
5899 printf (_(" [Nr] Name\n"));
5477e8a0 5900 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 5901 }
5902 else
5903 printf
5904 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5905 }
f7a99963
NC		 5906 else
5907 {
5477e8a0 5908 if (do_section_details)
595cf52e
L		 5909 {
5910 printf (_(" [Nr] Name\n"));
5477e8a0
L		 5911 printf (_(" Type Address Offset Link\n"));
5912 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 5913 }
5914 else
5915 {
5916 printf (_(" [Nr] Name Type Address Offset\n"));
5917 printf (_(" Size EntSize Flags Link Info Align\n"));
5918 }
f7a99963 5919 }
252b5132 5920
5477e8a0
L		 5921 if (do_section_details)
5922 printf (_(" Flags\n"));
5923
252b5132
RH		 5924 for (i = 0, section = section_headers;
5925 i < elf_header.e_shnum;
b34976b6 5926 i++, section++)
252b5132 5927 {
dd905818
NC		 5928 /* Run some sanity checks on the section header. */
5929
5930 /* Check the sh_link field. */
5931 switch (section->sh_type)
5932 {
5933 case SHT_SYMTAB_SHNDX:
5934 case SHT_GROUP:
5935 case SHT_HASH:
5936 case SHT_GNU_HASH:
5937 case SHT_GNU_versym:
5938 case SHT_REL:
5939 case SHT_RELA:
5940 if (section->sh_link < 1
5941 || section->sh_link > elf_header.e_shnum
5942 || (section_headers[section->sh_link].sh_type != SHT_SYMTAB
5943 && section_headers[section->sh_link].sh_type != SHT_DYNSYM))
5944 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
5945 i, section->sh_link);
5946 break;
5947
5948 case SHT_DYNAMIC:
5949 case SHT_SYMTAB:
5950 case SHT_DYNSYM:
5951 case SHT_GNU_verneed:
5952 case SHT_GNU_verdef:
5953 case SHT_GNU_LIBLIST:
5954 if (section->sh_link < 1
5955 || section->sh_link > elf_header.e_shnum
5956 || section_headers[section->sh_link].sh_type != SHT_STRTAB)
5957 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
5958 i, section->sh_link);
5959 break;
5960
5961 case SHT_INIT_ARRAY:
5962 case SHT_FINI_ARRAY:
5963 case SHT_PREINIT_ARRAY:
5964 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
5965 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
5966 i, section->sh_link);
5967 break;
5968
5969 default:
5970 /* FIXME: Add support for target specific section types. */
5971#if 0 /* Currently we do not check other section types as there are too
5972 many special cases. Stab sections for example have a type
5973 of SHT_PROGBITS but an sh_link field that links to the .stabstr
5974 section. */
5975 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
5976 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
5977 i, section->sh_link);
5978#endif
5979 break;
5980 }
5981
5982 /* Check the sh_info field. */
5983 switch (section->sh_type)
5984 {
5985 case SHT_REL:
5986 case SHT_RELA:
5987 if (section->sh_info < 1
5988 || section->sh_info > elf_header.e_shnum
5989 || (section_headers[section->sh_info].sh_type != SHT_PROGBITS
5990 && section_headers[section->sh_info].sh_type != SHT_NOBITS
5991 && section_headers[section->sh_info].sh_type != SHT_NOTE
5992 && section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
5993 /* FIXME: Are other section types valid ? */
5994 && section_headers[section->sh_info].sh_type < SHT_LOOS))
5995 {
5996 if (section->sh_info == 0
5997 && (streq (SECTION_NAME (section), ".rel.dyn")
5998 || streq (SECTION_NAME (section), ".rela.dyn")))
5999 /* The .rel.dyn and .rela.dyn sections have an sh_info field
6000 of zero. No idea why. I would have expected the index
6001 of the .plt section. */
6002 ;
6003 else
6004 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6005 i, section->sh_info);
6006 }
6007 break;
6008
6009 case SHT_DYNAMIC:
6010 case SHT_HASH:
6011 case SHT_SYMTAB_SHNDX:
6012 case SHT_INIT_ARRAY:
6013 case SHT_FINI_ARRAY:
6014 case SHT_PREINIT_ARRAY:
6015 if (section->sh_info != 0)
6016 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6017 i, section->sh_info);
6018 break;
6019
6020 case SHT_GROUP:
6021 case SHT_SYMTAB:
6022 case SHT_DYNSYM:
6023 /* A symbol index - we assume that it is valid. */
6024 break;
6025
6026 default:
6027 /* FIXME: Add support for target specific section types. */
6028 if (section->sh_type == SHT_NOBITS)
6029 /* NOBITS section headers with non-zero sh_info fields can be
6030 created when a binary is stripped of everything but its debug
6031 information. The stripped sections have their headers preserved but their types set to SHT_NOBITS. so do not check this type of section. */
6032 ;
6033 else if (section->sh_flags & SHF_INFO_LINK)
6034 {
6035 if (section->sh_info < 1 || section->sh_info > elf_header.e_shnum)
6036 warn (_("[%2u]: Expected link to another section in info field"), i);
6037 }
6038 else if (section->sh_type < SHT_LOOS && section->sh_info != 0)
6039 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6040 i, section->sh_info);
6041 break;
6042 }
6043
7bfd842d 6044 printf (" [%2u] ", i);
5477e8a0 6045 if (do_section_details)
74e1a04b 6046 printf ("%s\n ", printable_section_name (section));
595cf52e 6047 else
74e1a04b 6048 print_symbol (-17, SECTION_NAME (section));
0b4362b0 6049
ea52a088
NC		 6050 printf (do_wide ? " %-15s " : " %-15.15s ",
6051 get_section_type_name (section->sh_type));
0b4362b0 6052
f7a99963
NC		 6053 if (is_32bit_elf)
6054 {
cfcac11d
NC		 6055 const char * link_too_big = NULL;
6056
f7a99963 6057 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 6058
f7a99963
NC		 6059 printf ( " %6.6lx %6.6lx %2.2lx",
6060 (unsigned long) section->sh_offset,
6061 (unsigned long) section->sh_size,
6062 (unsigned long) section->sh_entsize);
d1133906 6063
5477e8a0
L		 6064 if (do_section_details)
6065 fputs (" ", stdout);
6066 else
6067 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 6068
cfcac11d
NC		 6069 if (section->sh_link >= elf_header.e_shnum)
6070 {
6071 link_too_big = "";
6072 /* The sh_link value is out of range. Normally this indicates
caa83f8b 6073 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 6074 switch (elf_header.e_machine)
6075 {
caa83f8b 6076 case EM_386:
22abe556 6077 case EM_IAMCU:
caa83f8b 6078 case EM_X86_64:
7f502d6c 6079 case EM_L1OM:
7a9068fe 6080 case EM_K1OM:
cfcac11d
NC		 6081 case EM_OLD_SPARCV9:
6082 case EM_SPARC32PLUS:
6083 case EM_SPARCV9:
6084 case EM_SPARC:
6085 if (section->sh_link == (SHN_BEFORE & 0xffff))
6086 link_too_big = "BEFORE";
6087 else if (section->sh_link == (SHN_AFTER & 0xffff))
6088 link_too_big = "AFTER";
6089 break;
6090 default:
6091 break;
6092 }
6093 }
6094
6095 if (do_section_details)
6096 {
6097 if (link_too_big != NULL && * link_too_big)
6098 printf ("<%s> ", link_too_big);
6099 else
6100 printf ("%2u ", section->sh_link);
6101 printf ("%3u %2lu\n", section->sh_info,
6102 (unsigned long) section->sh_addralign);
6103 }
6104 else
6105 printf ("%2u %3u %2lu\n",
6106 section->sh_link,
6107 section->sh_info,
6108 (unsigned long) section->sh_addralign);
6109
6110 if (link_too_big && ! * link_too_big)
6111 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6112 i, section->sh_link);
f7a99963 6113 }
d974e256
JJ		 6114 else if (do_wide)
6115 {
6116 print_vma (section->sh_addr, LONG_HEX);
6117
6118 if ((long) section->sh_offset == section->sh_offset)
6119 printf (" %6.6lx", (unsigned long) section->sh_offset);
6120 else
6121 {
6122 putchar (' ');
6123 print_vma (section->sh_offset, LONG_HEX);
6124 }
6125
6126 if ((unsigned long) section->sh_size == section->sh_size)
6127 printf (" %6.6lx", (unsigned long) section->sh_size);
6128 else
6129 {
6130 putchar (' ');
6131 print_vma (section->sh_size, LONG_HEX);
6132 }
6133
6134 if ((unsigned long) section->sh_entsize == section->sh_entsize)
6135 printf (" %2.2lx", (unsigned long) section->sh_entsize);
6136 else
6137 {
6138 putchar (' ');
6139 print_vma (section->sh_entsize, LONG_HEX);
6140 }
6141
5477e8a0
L		 6142 if (do_section_details)
6143 fputs (" ", stdout);
6144 else
6145 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 6146
72de5009 6147 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 6148
6149 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 6150 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 6151 else
6152 {
6153 print_vma (section->sh_addralign, DEC);
6154 putchar ('\n');
6155 }
6156 }
5477e8a0 6157 else if (do_section_details)
595cf52e 6158 {
5477e8a0 6159 printf (" %-15.15s ",
595cf52e 6160 get_section_type_name (section->sh_type));
595cf52e
L		 6161 print_vma (section->sh_addr, LONG_HEX);
6162 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 6163 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 6164 else
6165 {
6166 printf (" ");
6167 print_vma (section->sh_offset, LONG_HEX);
6168 }
72de5009 6169 printf (" %u\n ", section->sh_link);
595cf52e 6170 print_vma (section->sh_size, LONG_HEX);
5477e8a0 6171 putchar (' ');
595cf52e
L		 6172 print_vma (section->sh_entsize, LONG_HEX);
6173
72de5009
AM		 6174 printf (" %-16u %lu\n",
6175 section->sh_info,
595cf52e
L		 6176 (unsigned long) section->sh_addralign);
6177 }
f7a99963
NC		 6178 else
6179 {
6180 putchar (' ');
6181 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 6182 if ((long) section->sh_offset == section->sh_offset)
6183 printf (" %8.8lx", (unsigned long) section->sh_offset);
6184 else
6185 {
6186 printf (" ");
6187 print_vma (section->sh_offset, LONG_HEX);
6188 }
f7a99963
NC		 6189 printf ("\n ");
6190 print_vma (section->sh_size, LONG_HEX);
6191 printf (" ");
6192 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 6193
d1133906 6194 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 6195
72de5009
AM		 6196 printf (" %2u %3u %lu\n",
6197 section->sh_link,
6198 section->sh_info,
f7a99963
NC		 6199 (unsigned long) section->sh_addralign);
6200 }
5477e8a0
L		 6201
6202 if (do_section_details)
77115a4a
L		 6203 {
6204 printf (" %s\n", get_elf_section_flags (section->sh_flags));
6205 if ((section->sh_flags & SHF_COMPRESSED) != 0)
6206 {
6207 /* Minimum section size is 12 bytes for 32-bit compression
6208 header + 12 bytes for compressed data header. */
6209 unsigned char buf[24];
d8024a91 6210
77115a4a
L		 6211 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6212 if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
6213 sizeof (buf), _("compression header")))
6214 {
6215 Elf_Internal_Chdr chdr;
d8024a91
NC		 6216
6217 (void) get_compression_header (&chdr, buf);
6218
77115a4a
L		 6219 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6220 printf (" ZLIB, ");
6221 else
6222 printf (_(" [<unknown>: 0x%x], "),
6223 chdr.ch_type);
6224 print_vma (chdr.ch_size, LONG_HEX);
6225 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6226 }
6227 }
6228 }
252b5132
RH		 6229 }
6230
5477e8a0 6231 if (!do_section_details)
3dbcc61d 6232 {
9fb71ee4
NC		 6233 /* The ordering of the letters shown here matches the ordering of the
6234 corresponding SHF_xxx values, and hence the order in which these
6235 letters will be displayed to the user. */
6236 printf (_("Key to Flags:\n\
6237 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6238 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
fd85a6a1 6239 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
3dbcc61d 6240 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 6241 || elf_header.e_machine == EM_L1OM
6242 || elf_header.e_machine == EM_K1OM)
9fb71ee4 6243 printf (_("l (large), "));
91f68a68 6244 else if (elf_header.e_machine == EM_ARM)
f0728ee3 6245 printf (_("y (purecode), "));
9fb71ee4 6246 printf ("p (processor specific)\n");
0b4362b0 6247 }
d1133906 6248
252b5132
RH		 6249 return 1;
6250}
6251
f5842774
L		 6252static const char *
6253get_group_flags (unsigned int flags)
6254{
6255 static char buff[32];
6256 switch (flags)
6257 {
220453ec
AM		 6258 case 0:
6259 return "";
6260
f5842774 6261 case GRP_COMDAT:
220453ec 6262 return "COMDAT ";
f5842774
L		 6263
6264 default:
220453ec 6265 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 6266 break;
6267 }
6268 return buff;
6269}
6270
6271static int
2cf0635d 6272process_section_groups (FILE * file)
f5842774 6273{
2cf0635d 6274 Elf_Internal_Shdr * section;
f5842774 6275 unsigned int i;
2cf0635d
NC		 6276 struct group * group;
6277 Elf_Internal_Shdr * symtab_sec;
6278 Elf_Internal_Shdr * strtab_sec;
6279 Elf_Internal_Sym * symtab;
ba5cdace 6280 unsigned long num_syms;
2cf0635d 6281 char * strtab;
c256ffe7 6282 size_t strtab_size;
d1f5c6e3
L		 6283
6284 /* Don't process section groups unless needed. */
6285 if (!do_unwind && !do_section_groups)
6286 return 1;
f5842774
L		 6287
6288 if (elf_header.e_shnum == 0)
6289 {
6290 if (do_section_groups)
82f2dbf7 6291 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 6292
6293 return 1;
6294 }
6295
6296 if (section_headers == NULL)
6297 {
6298 error (_("Section headers are not available!\n"));
fa1908fd
NC		 6299 /* PR 13622: This can happen with a corrupt ELF header. */
6300 return 0;
f5842774
L		 6301 }
6302
3f5e193b
NC		 6303 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
6304 sizeof (struct group *));
e4b17d5c
L		 6305
6306 if (section_headers_groups == NULL)
6307 {
8b73c356
NC		 6308 error (_("Out of memory reading %u section group headers\n"),
6309 elf_header.e_shnum);
e4b17d5c
L		 6310 return 0;
6311 }
6312
f5842774 6313 /* Scan the sections for the group section. */
d1f5c6e3 6314 group_count = 0;
f5842774
L		 6315 for (i = 0, section = section_headers;
6316 i < elf_header.e_shnum;
6317 i++, section++)
e4b17d5c
L		 6318 if (section->sh_type == SHT_GROUP)
6319 group_count++;
6320
d1f5c6e3
L		 6321 if (group_count == 0)
6322 {
6323 if (do_section_groups)
6324 printf (_("\nThere are no section groups in this file.\n"));
6325
6326 return 1;
6327 }
6328
3f5e193b 6329 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 6330
6331 if (section_groups == NULL)
6332 {
8b73c356
NC		 6333 error (_("Out of memory reading %lu groups\n"),
6334 (unsigned long) group_count);
e4b17d5c
L		 6335 return 0;
6336 }
6337
d1f5c6e3
L		 6338 symtab_sec = NULL;
6339 strtab_sec = NULL;
6340 symtab = NULL;
ba5cdace 6341 num_syms = 0;
d1f5c6e3 6342 strtab = NULL;
c256ffe7 6343 strtab_size = 0;
e4b17d5c
L		 6344 for (i = 0, section = section_headers, group = section_groups;
6345 i < elf_header.e_shnum;
6346 i++, section++)
f5842774
L		 6347 {
6348 if (section->sh_type == SHT_GROUP)
6349 {
74e1a04b
NC		 6350 const char * name = printable_section_name (section);
6351 const char * group_name;
2cf0635d
NC		 6352 unsigned char * start;
6353 unsigned char * indices;
f5842774 6354 unsigned int entry, j, size;
2cf0635d
NC		 6355 Elf_Internal_Shdr * sec;
6356 Elf_Internal_Sym * sym;
f5842774
L		 6357
6358 /* Get the symbol table. */
4fbb74a6
AM		 6359 if (section->sh_link >= elf_header.e_shnum
6360 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 6361 != SHT_SYMTAB))
f5842774
L		 6362 {
6363 error (_("Bad sh_link in group section `%s'\n"), name);
6364 continue;
6365 }
d1f5c6e3
L		 6366
6367 if (symtab_sec != sec)
6368 {
6369 symtab_sec = sec;
6370 if (symtab)
6371 free (symtab);
ba5cdace 6372 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 6373 }
f5842774 6374
dd24e3da
NC		 6375 if (symtab == NULL)
6376 {
6377 error (_("Corrupt header in group section `%s'\n"), name);
6378 continue;
6379 }
6380
ba5cdace
NC		 6381 if (section->sh_info >= num_syms)
6382 {
6383 error (_("Bad sh_info in group section `%s'\n"), name);
6384 continue;
6385 }
6386
f5842774
L		 6387 sym = symtab + section->sh_info;
6388
6389 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6390 {
4fbb74a6
AM		 6391 if (sym->st_shndx == 0
6392 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 6393 {
6394 error (_("Bad sh_info in group section `%s'\n"), name);
6395 continue;
6396 }
ba2685cc 6397
4fbb74a6 6398 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 6399 strtab_sec = NULL;
6400 if (strtab)
6401 free (strtab);
f5842774 6402 strtab = NULL;
c256ffe7 6403 strtab_size = 0;
f5842774
L		 6404 }
6405 else
6406 {
6407 /* Get the string table. */
4fbb74a6 6408 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 6409 {
6410 strtab_sec = NULL;
6411 if (strtab)
6412 free (strtab);
6413 strtab = NULL;
6414 strtab_size = 0;
6415 }
6416 else if (strtab_sec
4fbb74a6 6417 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 6418 {
6419 strtab_sec = sec;
6420 if (strtab)
6421 free (strtab);
071436c6 6422
3f5e193b 6423 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
071436c6
NC		 6424 1, strtab_sec->sh_size,
6425 _("string table"));
c256ffe7 6426 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 6427 }
c256ffe7 6428 group_name = sym->st_name < strtab_size
2b692964 6429 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 6430 }
6431
c9c1d674
EG		 6432 /* PR 17531: file: loop. */
6433 if (section->sh_entsize > section->sh_size)
6434 {
6435 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6436 printable_section_name (section),
8066deb1
AM		 6437 (unsigned long) section->sh_entsize,
6438 (unsigned long) section->sh_size);
c9c1d674
EG		 6439 break;
6440 }
6441
3f5e193b
NC		 6442 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6443 1, section->sh_size,
6444 _("section data"));
59245841
NC		 6445 if (start == NULL)
6446 continue;
f5842774
L		 6447
6448 indices = start;
6449 size = (section->sh_size / section->sh_entsize) - 1;
6450 entry = byte_get (indices, 4);
6451 indices += 4;
e4b17d5c
L		 6452
6453 if (do_section_groups)
6454 {
2b692964 6455 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 6456 get_group_flags (entry), i, name, group_name, size);
ba2685cc 6457
e4b17d5c
L		 6458 printf (_(" [Index] Name\n"));
6459 }
6460
6461 group->group_index = i;
6462
f5842774
L		 6463 for (j = 0; j < size; j++)
6464 {
2cf0635d 6465 struct group_list * g;
e4b17d5c 6466
f5842774
L		 6467 entry = byte_get (indices, 4);
6468 indices += 4;
6469
4fbb74a6 6470 if (entry >= elf_header.e_shnum)
391cb864 6471 {
57028622
NC		 6472 static unsigned num_group_errors = 0;
6473
6474 if (num_group_errors ++ < 10)
6475 {
6476 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6477 entry, i, elf_header.e_shnum - 1);
6478 if (num_group_errors == 10)
6479 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6480 }
391cb864
L		 6481 continue;
6482 }
391cb864 6483
4fbb74a6 6484 if (section_headers_groups [entry] != NULL)
e4b17d5c 6485 {
d1f5c6e3
L		 6486 if (entry)
6487 {
57028622
NC		 6488 static unsigned num_errs = 0;
6489
6490 if (num_errs ++ < 10)
6491 {
6492 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6493 entry, i,
6494 section_headers_groups [entry]->group_index);
6495 if (num_errs == 10)
6496 warn (_("Further error messages about already contained group sections suppressed\n"));
6497 }
d1f5c6e3
L		 6498 continue;
6499 }
6500 else
6501 {
6502 /* Intel C/C++ compiler may put section 0 in a
6503 section group. We just warn it the first time
6504 and ignore it afterwards. */
6505 static int warned = 0;
6506 if (!warned)
6507 {
6508 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 6509 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 6510 warned++;
6511 }
6512 }
e4b17d5c
L		 6513 }
6514
4fbb74a6 6515 section_headers_groups [entry] = group;
e4b17d5c
L		 6516
6517 if (do_section_groups)
6518 {
4fbb74a6 6519 sec = section_headers + entry;
74e1a04b 6520 printf (" [%5u] %s\n", entry, printable_section_name (sec));
ba2685cc
AM		 6521 }
6522
3f5e193b 6523 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 6524 g->section_index = entry;
6525 g->next = group->root;
6526 group->root = g;
f5842774
L		 6527 }
6528
f5842774
L		 6529 if (start)
6530 free (start);
e4b17d5c
L		 6531
6532 group++;
f5842774
L		 6533 }
6534 }
6535
d1f5c6e3
L		 6536 if (symtab)
6537 free (symtab);
6538 if (strtab)
6539 free (strtab);
f5842774
L		 6540 return 1;
6541}
6542
28f997cf
TG		 6543/* Data used to display dynamic fixups. */
6544
6545struct ia64_vms_dynfixup
6546{
6547 bfd_vma needed_ident; /* Library ident number. */
6548 bfd_vma needed; /* Index in the dstrtab of the library name. */
6549 bfd_vma fixup_needed; /* Index of the library. */
6550 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6551 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6552};
6553
6554/* Data used to display dynamic relocations. */
6555
6556struct ia64_vms_dynimgrela
6557{
6558 bfd_vma img_rela_cnt; /* Number of relocations. */
6559 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6560};
6561
6562/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6563 library). */
6564
6565static void
6566dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6567 const char *strtab, unsigned int strtab_sz)
6568{
6569 Elf64_External_VMS_IMAGE_FIXUP *imfs;
6570 long i;
6571 const char *lib_name;
6572
6573 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6574 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6575 _("dynamic section image fixups"));
6576 if (!imfs)
6577 return;
6578
6579 if (fixup->needed < strtab_sz)
6580 lib_name = strtab + fixup->needed;
6581 else
6582 {
6583 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 6584 (unsigned long) fixup->needed);
28f997cf
TG		 6585 lib_name = "???";
6586 }
6587 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6588 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6589 printf
6590 (_("Seg Offset Type SymVec DataType\n"));
6591
6592 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6593 {
6594 unsigned int type;
6595 const char *rtype;
6596
6597 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6598 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6599 type = BYTE_GET (imfs [i].type);
6600 rtype = elf_ia64_reloc_type (type);
6601 if (rtype == NULL)
6602 printf (" 0x%08x ", type);
6603 else
6604 printf (" %-32s ", rtype);
6605 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6606 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6607 }
6608
6609 free (imfs);
6610}
6611
6612/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6613
6614static void
6615dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6616{
6617 Elf64_External_VMS_IMAGE_RELA *imrs;
6618 long i;
6619
6620 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6621 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 6622 _("dynamic section image relocations"));
28f997cf
TG		 6623 if (!imrs)
6624 return;
6625
6626 printf (_("\nImage relocs\n"));
6627 printf
6628 (_("Seg Offset Type Addend Seg Sym Off\n"));
6629
6630 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6631 {
6632 unsigned int type;
6633 const char *rtype;
6634
6635 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6636 printf ("%08" BFD_VMA_FMT "x ",
6637 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6638 type = BYTE_GET (imrs [i].type);
6639 rtype = elf_ia64_reloc_type (type);
6640 if (rtype == NULL)
6641 printf ("0x%08x ", type);
6642 else
6643 printf ("%-31s ", rtype);
6644 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6645 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6646 printf ("%08" BFD_VMA_FMT "x\n",
6647 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6648 }
6649
6650 free (imrs);
6651}
6652
6653/* Display IA-64 OpenVMS dynamic relocations and fixups. */
6654
6655static int
6656process_ia64_vms_dynamic_relocs (FILE *file)
6657{
6658 struct ia64_vms_dynfixup fixup;
6659 struct ia64_vms_dynimgrela imgrela;
6660 Elf_Internal_Dyn *entry;
6661 int res = 0;
6662 bfd_vma strtab_off = 0;
6663 bfd_vma strtab_sz = 0;
6664 char *strtab = NULL;
6665
6666 memset (&fixup, 0, sizeof (fixup));
6667 memset (&imgrela, 0, sizeof (imgrela));
6668
6669 /* Note: the order of the entries is specified by the OpenVMS specs. */
6670 for (entry = dynamic_section;
6671 entry < dynamic_section + dynamic_nent;
6672 entry++)
6673 {
6674 switch (entry->d_tag)
6675 {
6676 case DT_IA_64_VMS_STRTAB_OFFSET:
6677 strtab_off = entry->d_un.d_val;
6678 break;
6679 case DT_STRSZ:
6680 strtab_sz = entry->d_un.d_val;
6681 if (strtab == NULL)
6682 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6683 1, strtab_sz, _("dynamic string section"));
6684 break;
6685
6686 case DT_IA_64_VMS_NEEDED_IDENT:
6687 fixup.needed_ident = entry->d_un.d_val;
6688 break;
6689 case DT_NEEDED:
6690 fixup.needed = entry->d_un.d_val;
6691 break;
6692 case DT_IA_64_VMS_FIXUP_NEEDED:
6693 fixup.fixup_needed = entry->d_un.d_val;
6694 break;
6695 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6696 fixup.fixup_rela_cnt = entry->d_un.d_val;
6697 break;
6698 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6699 fixup.fixup_rela_off = entry->d_un.d_val;
6700 res++;
6701 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6702 break;
6703
6704 case DT_IA_64_VMS_IMG_RELA_CNT:
6705 imgrela.img_rela_cnt = entry->d_un.d_val;
6706 break;
6707 case DT_IA_64_VMS_IMG_RELA_OFF:
6708 imgrela.img_rela_off = entry->d_un.d_val;
6709 res++;
6710 dump_ia64_vms_dynamic_relocs (file, &imgrela);
6711 break;
6712
6713 default:
6714 break;
6715 }
6716 }
6717
6718 if (strtab != NULL)
6719 free (strtab);
6720
6721 return res;
6722}
6723
85b1c36d 6724static struct
566b0d53 6725{
2cf0635d 6726 const char * name;
566b0d53
L		 6727 int reloc;
6728 int size;
6729 int rela;
6730} dynamic_relocations [] =
6731{
6732 { "REL", DT_REL, DT_RELSZ, FALSE },
6733 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6734 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6735};
6736
252b5132 6737/* Process the reloc section. */
18bd398b 6738
252b5132 6739static int
2cf0635d 6740process_relocs (FILE * file)
252b5132 6741{
b34976b6
AM		 6742 unsigned long rel_size;
6743 unsigned long rel_offset;
252b5132
RH		 6744
6745
6746 if (!do_reloc)
6747 return 1;
6748
6749 if (do_using_dynamic)
6750 {
566b0d53 6751 int is_rela;
2cf0635d 6752 const char * name;
566b0d53
L		 6753 int has_dynamic_reloc;
6754 unsigned int i;
0de14b54 6755
566b0d53 6756 has_dynamic_reloc = 0;
252b5132 6757
566b0d53 6758 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 6759 {
566b0d53
L		 6760 is_rela = dynamic_relocations [i].rela;
6761 name = dynamic_relocations [i].name;
6762 rel_size = dynamic_info [dynamic_relocations [i].size];
6763 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 6764
566b0d53
L		 6765 has_dynamic_reloc |= rel_size;
6766
6767 if (is_rela == UNKNOWN)
aa903cfb 6768 {
566b0d53
L		 6769 if (dynamic_relocations [i].reloc == DT_JMPREL)
6770 switch (dynamic_info[DT_PLTREL])
6771 {
6772 case DT_REL:
6773 is_rela = FALSE;
6774 break;
6775 case DT_RELA:
6776 is_rela = TRUE;
6777 break;
6778 }
aa903cfb 6779 }
252b5132 6780
566b0d53
L		 6781 if (rel_size)
6782 {
6783 printf
6784 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6785 name, rel_offset, rel_size);
252b5132 6786
d93f0186
NC		 6787 dump_relocations (file,
6788 offset_from_vma (file, rel_offset, rel_size),
6789 rel_size,
566b0d53 6790 dynamic_symbols, num_dynamic_syms,
bb4d2ac2
L		 6791 dynamic_strings, dynamic_strings_length,
6792 is_rela, 1);
566b0d53 6793 }
252b5132 6794 }
566b0d53 6795
28f997cf
TG		 6796 if (is_ia64_vms ())
6797 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6798
566b0d53 6799 if (! has_dynamic_reloc)
252b5132
RH		 6800 printf (_("\nThere are no dynamic relocations in this file.\n"));
6801 }
6802 else
6803 {
2cf0635d 6804 Elf_Internal_Shdr * section;
b34976b6
AM		 6805 unsigned long i;
6806 int found = 0;
252b5132
RH		 6807
6808 for (i = 0, section = section_headers;
6809 i < elf_header.e_shnum;
b34976b6 6810 i++, section++)
252b5132
RH		 6811 {
6812 if ( section->sh_type != SHT_RELA
6813 && section->sh_type != SHT_REL)
6814 continue;
6815
6816 rel_offset = section->sh_offset;
6817 rel_size = section->sh_size;
6818
6819 if (rel_size)
6820 {
2cf0635d 6821 Elf_Internal_Shdr * strsec;
b34976b6 6822 int is_rela;
103f02d3 6823
252b5132
RH		 6824 printf (_("\nRelocation section "));
6825
6826 if (string_table == NULL)
19936277 6827 printf ("%d", section->sh_name);
252b5132 6828 else
74e1a04b 6829 printf ("'%s'", printable_section_name (section));
252b5132
RH		 6830
6831 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6832 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6833
d79b3d50
NC		 6834 is_rela = section->sh_type == SHT_RELA;
6835
4fbb74a6
AM		 6836 if (section->sh_link != 0
6837 && section->sh_link < elf_header.e_shnum)
af3fc3bc 6838 {
2cf0635d
NC		 6839 Elf_Internal_Shdr * symsec;
6840 Elf_Internal_Sym * symtab;
d79b3d50 6841 unsigned long nsyms;
c256ffe7 6842 unsigned long strtablen = 0;
2cf0635d 6843 char * strtab = NULL;
57346661 6844
4fbb74a6 6845 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 6846 if (symsec->sh_type != SHT_SYMTAB
6847 && symsec->sh_type != SHT_DYNSYM)
6848 continue;
6849
ba5cdace 6850 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 6851
af3fc3bc
AM		 6852 if (symtab == NULL)
6853 continue;
252b5132 6854
4fbb74a6
AM		 6855 if (symsec->sh_link != 0
6856 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 6857 {
4fbb74a6 6858 strsec = section_headers + symsec->sh_link;
103f02d3 6859
3f5e193b 6860 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
071436c6
NC		 6861 1, strsec->sh_size,
6862 _("string table"));
c256ffe7
JJ		 6863 strtablen = strtab == NULL ? 0 : strsec->sh_size;
6864 }
252b5132 6865
d79b3d50 6866 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2
L		 6867 symtab, nsyms, strtab, strtablen,
6868 is_rela,
6869 symsec->sh_type == SHT_DYNSYM);
d79b3d50
NC		 6870 if (strtab)
6871 free (strtab);
6872 free (symtab);
6873 }
6874 else
6875 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2 6876 NULL, 0, NULL, 0, is_rela, 0);
252b5132
RH		 6877
6878 found = 1;
6879 }
6880 }
6881
6882 if (! found)
6883 printf (_("\nThere are no relocations in this file.\n"));
6884 }
6885
6886 return 1;
6887}
6888
4d6ed7c8
NC		 6889/* An absolute address consists of a section and an offset. If the
6890 section is NULL, the offset itself is the address, otherwise, the
6891 address equals to LOAD_ADDRESS(section) + offset. */
6892
6893struct absaddr
948f632f
DA		 6894{
6895 unsigned short section;
6896 bfd_vma offset;
6897};
4d6ed7c8 6898
1949de15
L		 6899#define ABSADDR(a) \
6900 ((a).section \
6901 ? section_headers [(a).section].sh_addr + (a).offset \
6902 : (a).offset)
6903
948f632f
DA		 6904/* Find the nearest symbol at or below ADDR. Returns the symbol
6905 name, if found, and the offset from the symbol to ADDR. */
4d6ed7c8 6906
4d6ed7c8 6907static void
2cf0635d 6908find_symbol_for_address (Elf_Internal_Sym * symtab,
948f632f
DA		 6909 unsigned long nsyms,
6910 const char * strtab,
6911 unsigned long strtab_size,
6912 struct absaddr addr,
6913 const char ** symname,
6914 bfd_vma * offset)
4d6ed7c8 6915{
d3ba0551 6916 bfd_vma dist = 0x100000;
2cf0635d 6917 Elf_Internal_Sym * sym;
948f632f
DA		 6918 Elf_Internal_Sym * beg;
6919 Elf_Internal_Sym * end;
2cf0635d 6920 Elf_Internal_Sym * best = NULL;
4d6ed7c8 6921
0b6ae522 6922 REMOVE_ARCH_BITS (addr.offset);
948f632f
DA		 6923 beg = symtab;
6924 end = symtab + nsyms;
0b6ae522 6925
948f632f 6926 while (beg < end)
4d6ed7c8 6927 {
948f632f
DA		 6928 bfd_vma value;
6929
6930 sym = beg + (end - beg) / 2;
0b6ae522 6931
948f632f 6932 value = sym->st_value;
0b6ae522
DJ		 6933 REMOVE_ARCH_BITS (value);
6934
948f632f 6935 if (sym->st_name != 0
4d6ed7c8 6936 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 6937 && addr.offset >= value
6938 && addr.offset - value < dist)
4d6ed7c8
NC		 6939 {
6940 best = sym;
0b6ae522 6941 dist = addr.offset - value;
4d6ed7c8
NC		 6942 if (!dist)
6943 break;
6944 }
948f632f
DA		 6945
6946 if (addr.offset < value)
6947 end = sym;
6948 else
6949 beg = sym + 1;
4d6ed7c8 6950 }
1b31d05e 6951
4d6ed7c8
NC		 6952 if (best)
6953 {
57346661 6954 *symname = (best->st_name >= strtab_size
2b692964 6955 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 6956 *offset = dist;
6957 return;
6958 }
1b31d05e 6959
4d6ed7c8
NC		 6960 *symname = NULL;
6961 *offset = addr.offset;
6962}
6963
948f632f
DA		 6964static int
6965symcmp (const void *p, const void *q)
6966{
6967 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
6968 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
6969
6970 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
6971}
6972
6973/* Process the unwind section. */
6974
6975#include "unwind-ia64.h"
6976
6977struct ia64_unw_table_entry
6978{
6979 struct absaddr start;
6980 struct absaddr end;
6981 struct absaddr info;
6982};
6983
6984struct ia64_unw_aux_info
6985{
6986 struct ia64_unw_table_entry *table; /* Unwind table. */
6987 unsigned long table_len; /* Length of unwind table. */
6988 unsigned char * info; /* Unwind info. */
6989 unsigned long info_size; /* Size of unwind info. */
6990 bfd_vma info_addr; /* Starting address of unwind info. */
6991 bfd_vma seg_base; /* Starting address of segment. */
6992 Elf_Internal_Sym * symtab; /* The symbol table. */
6993 unsigned long nsyms; /* Number of symbols. */
6994 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
6995 unsigned long nfuns; /* Number of entries in funtab. */
6996 char * strtab; /* The string table. */
6997 unsigned long strtab_size; /* Size of string table. */
6998};
6999
4d6ed7c8 7000static void
2cf0635d 7001dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 7002{
2cf0635d 7003 struct ia64_unw_table_entry * tp;
948f632f 7004 unsigned long j, nfuns;
4d6ed7c8 7005 int in_body;
7036c0e1 7006
948f632f
DA		 7007 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7008 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7009 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7010 aux->funtab[nfuns++] = aux->symtab[j];
7011 aux->nfuns = nfuns;
7012 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7013
4d6ed7c8
NC		 7014 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7015 {
7016 bfd_vma stamp;
7017 bfd_vma offset;
2cf0635d
NC		 7018 const unsigned char * dp;
7019 const unsigned char * head;
53774b7e 7020 const unsigned char * end;
2cf0635d 7021 const char * procname;
4d6ed7c8 7022
948f632f 7023 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661 7024 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 7025
7026 fputs ("\n<", stdout);
7027
7028 if (procname)
7029 {
7030 fputs (procname, stdout);
7031
7032 if (offset)
7033 printf ("+%lx", (unsigned long) offset);
7034 }
7035
7036 fputs (">: [", stdout);
7037 print_vma (tp->start.offset, PREFIX_HEX);
7038 fputc ('-', stdout);
7039 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 7040 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 7041 (unsigned long) (tp->info.offset - aux->seg_base));
7042
53774b7e
NC		 7043 /* PR 17531: file: 86232b32. */
7044 if (aux->info == NULL)
7045 continue;
7046
7047 /* PR 17531: file: 0997b4d1. */
7048 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7049 {
7050 warn (_("Invalid offset %lx in table entry %ld\n"),
7051 (long) tp->info.offset, (long) (tp - aux->table));
7052 continue;
7053 }
7054
1949de15 7055 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 7056 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 7057
86f55779 7058 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 7059 (unsigned) UNW_VER (stamp),
7060 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7061 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7062 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 7063 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 7064
7065 if (UNW_VER (stamp) != 1)
7066 {
2b692964 7067 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 7068 continue;
7069 }
7070
7071 in_body = 0;
53774b7e
NC		 7072 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7073 /* PR 17531: file: 16ceda89. */
7074 if (end > aux->info + aux->info_size)
7075 end = aux->info + aux->info_size;
7076 for (dp = head + 8; dp < end;)
b4477bc8 7077 dp = unw_decode (dp, in_body, & in_body, end);
4d6ed7c8 7078 }
948f632f
DA		 7079
7080 free (aux->funtab);
4d6ed7c8
NC		 7081}
7082
53774b7e 7083static bfd_boolean
2cf0635d
NC		 7084slurp_ia64_unwind_table (FILE * file,
7085 struct ia64_unw_aux_info * aux,
7086 Elf_Internal_Shdr * sec)
4d6ed7c8 7087{
89fac5e3 7088 unsigned long size, nrelas, i;
2cf0635d
NC		 7089 Elf_Internal_Phdr * seg;
7090 struct ia64_unw_table_entry * tep;
7091 Elf_Internal_Shdr * relsec;
7092 Elf_Internal_Rela * rela;
7093 Elf_Internal_Rela * rp;
7094 unsigned char * table;
7095 unsigned char * tp;
7096 Elf_Internal_Sym * sym;
7097 const char * relname;
4d6ed7c8 7098
53774b7e
NC		 7099 aux->table_len = 0;
7100
4d6ed7c8
NC		 7101 /* First, find the starting address of the segment that includes
7102 this section: */
7103
7104 if (elf_header.e_phnum)
7105 {
d93f0186 7106 if (! get_program_headers (file))
53774b7e 7107 return FALSE;
4d6ed7c8 7108
d93f0186
NC		 7109 for (seg = program_headers;
7110 seg < program_headers + elf_header.e_phnum;
7111 ++seg)
4d6ed7c8
NC		 7112 {
7113 if (seg->p_type != PT_LOAD)
7114 continue;
7115
7116 if (sec->sh_addr >= seg->p_vaddr
7117 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7118 {
7119 aux->seg_base = seg->p_vaddr;
7120 break;
7121 }
7122 }
4d6ed7c8
NC		 7123 }
7124
7125 /* Second, build the unwind table from the contents of the unwind section: */
7126 size = sec->sh_size;
3f5e193b
NC		 7127 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7128 _("unwind table"));
a6e9f9df 7129 if (!table)
53774b7e 7130 return FALSE;
4d6ed7c8 7131
53774b7e 7132 aux->table_len = size / (3 * eh_addr_size);
3f5e193b 7133 aux->table = (struct ia64_unw_table_entry *)
53774b7e 7134 xcmalloc (aux->table_len, sizeof (aux->table[0]));
89fac5e3 7135 tep = aux->table;
53774b7e
NC		 7136
7137 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
4d6ed7c8
NC		 7138 {
7139 tep->start.section = SHN_UNDEF;
7140 tep->end.section = SHN_UNDEF;
7141 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 7142 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7143 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7144 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 7145 tep->start.offset += aux->seg_base;
7146 tep->end.offset += aux->seg_base;
7147 tep->info.offset += aux->seg_base;
7148 }
7149 free (table);
7150
41e92641 7151 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 7152 for (relsec = section_headers;
7153 relsec < section_headers + elf_header.e_shnum;
7154 ++relsec)
7155 {
7156 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 7157 || relsec->sh_info >= elf_header.e_shnum
7158 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 7159 continue;
7160
7161 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7162 & rela, & nrelas))
53774b7e
NC		 7163 {
7164 free (aux->table);
7165 aux->table = NULL;
7166 aux->table_len = 0;
7167 return FALSE;
7168 }
4d6ed7c8
NC		 7169
7170 for (rp = rela; rp < rela + nrelas; ++rp)
7171 {
aca88567
NC		 7172 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
7173 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 7174
82b1b41b
NC		 7175 /* PR 17531: file: 9fa67536. */
7176 if (relname == NULL)
7177 {
7178 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
7179 continue;
7180 }
948f632f 7181
0112cd26 7182 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 7183 {
82b1b41b 7184 warn (_("Skipping unexpected relocation type: %s\n"), relname);
4d6ed7c8
NC		 7185 continue;
7186 }
7187
89fac5e3 7188 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 7189
53774b7e
NC		 7190 /* PR 17531: file: 5bc8d9bf. */
7191 if (i >= aux->table_len)
7192 {
7193 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7194 continue;
7195 }
7196
7197 switch (rp->r_offset / eh_addr_size % 3)
4d6ed7c8
NC		 7198 {
7199 case 0:
7200 aux->table[i].start.section = sym->st_shndx;
e466bc6e 7201 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 7202 break;
7203 case 1:
7204 aux->table[i].end.section = sym->st_shndx;
e466bc6e 7205 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 7206 break;
7207 case 2:
7208 aux->table[i].info.section = sym->st_shndx;
e466bc6e 7209 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 7210 break;
7211 default:
7212 break;
7213 }
7214 }
7215
7216 free (rela);
7217 }
7218
53774b7e 7219 return TRUE;
4d6ed7c8
NC		 7220}
7221
1b31d05e 7222static void
2cf0635d 7223ia64_process_unwind (FILE * file)
4d6ed7c8 7224{
2cf0635d
NC		 7225 Elf_Internal_Shdr * sec;
7226 Elf_Internal_Shdr * unwsec = NULL;
7227 Elf_Internal_Shdr * strsec;
89fac5e3 7228 unsigned long i, unwcount = 0, unwstart = 0;
57346661 7229 struct ia64_unw_aux_info aux;
f1467e33 7230
4d6ed7c8
NC		 7231 memset (& aux, 0, sizeof (aux));
7232
4d6ed7c8
NC		 7233 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7234 {
c256ffe7 7235 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 7236 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 7237 {
ba5cdace 7238 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 7239
4fbb74a6 7240 strsec = section_headers + sec->sh_link;
4082ef84
NC		 7241 if (aux.strtab != NULL)
7242 {
7243 error (_("Multiple auxillary string tables encountered\n"));
7244 free (aux.strtab);
7245 }
3f5e193b
NC		 7246 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7247 1, strsec->sh_size,
7248 _("string table"));
c256ffe7 7249 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 7250 }
7251 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 7252 unwcount++;
7253 }
7254
7255 if (!unwcount)
7256 printf (_("\nThere are no unwind sections in this file.\n"));
7257
7258 while (unwcount-- > 0)
7259 {
2cf0635d 7260 char * suffix;
579f31ac
JJ		 7261 size_t len, len2;
7262
4082ef84 7263 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
579f31ac
JJ		 7264 i < elf_header.e_shnum; ++i, ++sec)
7265 if (sec->sh_type == SHT_IA_64_UNWIND)
7266 {
7267 unwsec = sec;
7268 break;
7269 }
4082ef84
NC		 7270 /* We have already counted the number of SHT_IA64_UNWIND
7271 sections so the loop above should never fail. */
7272 assert (unwsec != NULL);
579f31ac
JJ		 7273
7274 unwstart = i + 1;
7275 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7276
e4b17d5c
L		 7277 if ((unwsec->sh_flags & SHF_GROUP) != 0)
7278 {
7279 /* We need to find which section group it is in. */
4082ef84 7280 struct group_list * g;
e4b17d5c 7281
4082ef84
NC		 7282 if (section_headers_groups == NULL
7283 || section_headers_groups [i] == NULL)
7284 i = elf_header.e_shnum;
7285 else
e4b17d5c 7286 {
4082ef84 7287 g = section_headers_groups [i]->root;
18bd398b 7288
4082ef84
NC		 7289 for (; g != NULL; g = g->next)
7290 {
7291 sec = section_headers + g->section_index;
e4b17d5c 7292
4082ef84
NC		 7293 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7294 break;
7295 }
7296
7297 if (g == NULL)
7298 i = elf_header.e_shnum;
7299 }
e4b17d5c 7300 }
18bd398b 7301 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 7302 {
18bd398b 7303 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 7304 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7305 suffix = SECTION_NAME (unwsec) + len;
7306 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7307 ++i, ++sec)
18bd398b
NC		 7308 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7309 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 7310 break;
7311 }
7312 else
7313 {
7314 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 7315 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 7316 len = sizeof (ELF_STRING_ia64_unwind) - 1;
7317 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7318 suffix = "";
18bd398b 7319 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 7320 suffix = SECTION_NAME (unwsec) + len;
7321 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7322 ++i, ++sec)
18bd398b
NC		 7323 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7324 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 7325 break;
7326 }
7327
7328 if (i == elf_header.e_shnum)
7329 {
7330 printf (_("\nCould not find unwind info section for "));
7331
7332 if (string_table == NULL)
7333 printf ("%d", unwsec->sh_name);
7334 else
74e1a04b 7335 printf ("'%s'", printable_section_name (unwsec));
579f31ac
JJ		 7336 }
7337 else
4d6ed7c8 7338 {
4d6ed7c8 7339 aux.info_addr = sec->sh_addr;
3f5e193b 7340 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
4082ef84
NC		 7341 sec->sh_size,
7342 _("unwind info"));
59245841 7343 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 7344
579f31ac 7345 printf (_("\nUnwind section "));
4d6ed7c8 7346
579f31ac
JJ		 7347 if (string_table == NULL)
7348 printf ("%d", unwsec->sh_name);
7349 else
74e1a04b 7350 printf ("'%s'", printable_section_name (unwsec));
4d6ed7c8 7351
579f31ac 7352 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 7353 (unsigned long) unwsec->sh_offset,
89fac5e3 7354 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 7355
53774b7e
NC		 7356 if (slurp_ia64_unwind_table (file, & aux, unwsec)
7357 && aux.table_len > 0)
579f31ac
JJ		 7358 dump_ia64_unwind (& aux);
7359
7360 if (aux.table)
7361 free ((char *) aux.table);
7362 if (aux.info)
7363 free ((char *) aux.info);
7364 aux.table = NULL;
7365 aux.info = NULL;
7366 }
4d6ed7c8 7367 }
4d6ed7c8 7368
4d6ed7c8
NC		 7369 if (aux.symtab)
7370 free (aux.symtab);
7371 if (aux.strtab)
7372 free ((char *) aux.strtab);
4d6ed7c8
NC		 7373}
7374
3f5e193b
NC		 7375struct hppa_unw_table_entry
7376 {
7377 struct absaddr start;
7378 struct absaddr end;
948f632f 7379 unsigned int Cannot_unwind:1; /* 0 */
3f5e193b
NC		 7380 unsigned int Millicode:1; /* 1 */
7381 unsigned int Millicode_save_sr0:1; /* 2 */
7382 unsigned int Region_description:2; /* 3..4 */
7383 unsigned int reserved1:1; /* 5 */
7384 unsigned int Entry_SR:1; /* 6 */
7385 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
7386 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
7387 unsigned int Args_stored:1; /* 16 */
948f632f
DA		 7388 unsigned int Variable_Frame:1; /* 17 */
7389 unsigned int Separate_Package_Body:1; /* 18 */
3f5e193b 7390 unsigned int Frame_Extension_Millicode:1; /* 19 */
948f632f
DA		 7391 unsigned int Stack_Overflow_Check:1; /* 20 */
7392 unsigned int Two_Instruction_SP_Increment:1;/* 21 */
3f5e193b
NC		 7393 unsigned int Ada_Region:1; /* 22 */
7394 unsigned int cxx_info:1; /* 23 */
948f632f
DA		 7395 unsigned int cxx_try_catch:1; /* 24 */
7396 unsigned int sched_entry_seq:1; /* 25 */
3f5e193b 7397 unsigned int reserved2:1; /* 26 */
948f632f
DA		 7398 unsigned int Save_SP:1; /* 27 */
7399 unsigned int Save_RP:1; /* 28 */
3f5e193b
NC		 7400 unsigned int Save_MRP_in_frame:1; /* 29 */
7401 unsigned int extn_ptr_defined:1; /* 30 */
948f632f 7402 unsigned int Cleanup_defined:1; /* 31 */
3f5e193b 7403
948f632f
DA		 7404 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
7405 unsigned int HP_UX_interrupt_marker:1; /* 1 */
3f5e193b 7406 unsigned int Large_frame:1; /* 2 */
948f632f 7407 unsigned int Pseudo_SP_Set:1; /* 3 */
3f5e193b
NC		 7408 unsigned int reserved4:1; /* 4 */
7409 unsigned int Total_frame_size:27; /* 5..31 */
7410 };
7411
57346661 7412struct hppa_unw_aux_info
948f632f
DA		 7413{
7414 struct hppa_unw_table_entry * table; /* Unwind table. */
7415 unsigned long table_len; /* Length of unwind table. */
7416 bfd_vma seg_base; /* Starting address of segment. */
7417 Elf_Internal_Sym * symtab; /* The symbol table. */
7418 unsigned long nsyms; /* Number of symbols. */
7419 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7420 unsigned long nfuns; /* Number of entries in funtab. */
7421 char * strtab; /* The string table. */
7422 unsigned long strtab_size; /* Size of string table. */
7423};
57346661
AM		 7424
7425static void
2cf0635d 7426dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 7427{
2cf0635d 7428 struct hppa_unw_table_entry * tp;
948f632f
DA		 7429 unsigned long j, nfuns;
7430
7431 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7432 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7433 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7434 aux->funtab[nfuns++] = aux->symtab[j];
7435 aux->nfuns = nfuns;
7436 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
57346661 7437
57346661
AM		 7438 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7439 {
7440 bfd_vma offset;
2cf0635d 7441 const char * procname;
57346661 7442
948f632f 7443 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661
AM		 7444 aux->strtab_size, tp->start, &procname,
7445 &offset);
7446
7447 fputs ("\n<", stdout);
7448
7449 if (procname)
7450 {
7451 fputs (procname, stdout);
7452
7453 if (offset)
7454 printf ("+%lx", (unsigned long) offset);
7455 }
7456
7457 fputs (">: [", stdout);
7458 print_vma (tp->start.offset, PREFIX_HEX);
7459 fputc ('-', stdout);
7460 print_vma (tp->end.offset, PREFIX_HEX);
7461 printf ("]\n\t");
7462
18bd398b
NC		 7463#define PF(_m) if (tp->_m) printf (#_m " ");
7464#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 7465 PF(Cannot_unwind);
7466 PF(Millicode);
7467 PF(Millicode_save_sr0);
18bd398b 7468 /* PV(Region_description); */
57346661
AM		 7469 PF(Entry_SR);
7470 PV(Entry_FR);
7471 PV(Entry_GR);
7472 PF(Args_stored);
7473 PF(Variable_Frame);
7474 PF(Separate_Package_Body);
7475 PF(Frame_Extension_Millicode);
7476 PF(Stack_Overflow_Check);
7477 PF(Two_Instruction_SP_Increment);
7478 PF(Ada_Region);
7479 PF(cxx_info);
7480 PF(cxx_try_catch);
7481 PF(sched_entry_seq);
7482 PF(Save_SP);
7483 PF(Save_RP);
7484 PF(Save_MRP_in_frame);
7485 PF(extn_ptr_defined);
7486 PF(Cleanup_defined);
7487 PF(MPE_XL_interrupt_marker);
7488 PF(HP_UX_interrupt_marker);
7489 PF(Large_frame);
7490 PF(Pseudo_SP_Set);
7491 PV(Total_frame_size);
7492#undef PF
7493#undef PV
7494 }
7495
18bd398b 7496 printf ("\n");
948f632f
DA		 7497
7498 free (aux->funtab);
57346661
AM		 7499}
7500
7501static int
2cf0635d
NC		 7502slurp_hppa_unwind_table (FILE * file,
7503 struct hppa_unw_aux_info * aux,
7504 Elf_Internal_Shdr * sec)
57346661 7505{
1c0751b2 7506 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 7507 Elf_Internal_Phdr * seg;
7508 struct hppa_unw_table_entry * tep;
7509 Elf_Internal_Shdr * relsec;
7510 Elf_Internal_Rela * rela;
7511 Elf_Internal_Rela * rp;
7512 unsigned char * table;
7513 unsigned char * tp;
7514 Elf_Internal_Sym * sym;
7515 const char * relname;
57346661 7516
57346661
AM		 7517 /* First, find the starting address of the segment that includes
7518 this section. */
7519
7520 if (elf_header.e_phnum)
7521 {
7522 if (! get_program_headers (file))
7523 return 0;
7524
7525 for (seg = program_headers;
7526 seg < program_headers + elf_header.e_phnum;
7527 ++seg)
7528 {
7529 if (seg->p_type != PT_LOAD)
7530 continue;
7531
7532 if (sec->sh_addr >= seg->p_vaddr
7533 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7534 {
7535 aux->seg_base = seg->p_vaddr;
7536 break;
7537 }
7538 }
7539 }
7540
7541 /* Second, build the unwind table from the contents of the unwind
7542 section. */
7543 size = sec->sh_size;
3f5e193b
NC		 7544 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7545 _("unwind table"));
57346661
AM		 7546 if (!table)
7547 return 0;
7548
1c0751b2
DA		 7549 unw_ent_size = 16;
7550 nentries = size / unw_ent_size;
7551 size = unw_ent_size * nentries;
57346661 7552
3f5e193b
NC		 7553 tep = aux->table = (struct hppa_unw_table_entry *)
7554 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 7555
1c0751b2 7556 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 7557 {
7558 unsigned int tmp1, tmp2;
7559
7560 tep->start.section = SHN_UNDEF;
7561 tep->end.section = SHN_UNDEF;
7562
1c0751b2
DA		 7563 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7564 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7565 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7566 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7567
7568 tep->start.offset += aux->seg_base;
7569 tep->end.offset += aux->seg_base;
57346661
AM		 7570
7571 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7572 tep->Millicode = (tmp1 >> 30) & 0x1;
7573 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7574 tep->Region_description = (tmp1 >> 27) & 0x3;
7575 tep->reserved1 = (tmp1 >> 26) & 0x1;
7576 tep->Entry_SR = (tmp1 >> 25) & 0x1;
7577 tep->Entry_FR = (tmp1 >> 21) & 0xf;
7578 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7579 tep->Args_stored = (tmp1 >> 15) & 0x1;
7580 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7581 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7582 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7583 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7584 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7585 tep->Ada_Region = (tmp1 >> 9) & 0x1;
7586 tep->cxx_info = (tmp1 >> 8) & 0x1;
7587 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7588 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7589 tep->reserved2 = (tmp1 >> 5) & 0x1;
7590 tep->Save_SP = (tmp1 >> 4) & 0x1;
7591 tep->Save_RP = (tmp1 >> 3) & 0x1;
7592 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7593 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7594 tep->Cleanup_defined = tmp1 & 0x1;
7595
7596 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7597 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7598 tep->Large_frame = (tmp2 >> 29) & 0x1;
7599 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7600 tep->reserved4 = (tmp2 >> 27) & 0x1;
7601 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 7602 }
7603 free (table);
7604
7605 /* Third, apply any relocations to the unwind table. */
57346661
AM		 7606 for (relsec = section_headers;
7607 relsec < section_headers + elf_header.e_shnum;
7608 ++relsec)
7609 {
7610 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 7611 || relsec->sh_info >= elf_header.e_shnum
7612 || section_headers + relsec->sh_info != sec)
57346661
AM		 7613 continue;
7614
7615 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7616 & rela, & nrelas))
7617 return 0;
7618
7619 for (rp = rela; rp < rela + nrelas; ++rp)
7620 {
aca88567
NC		 7621 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7622 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 7623
7624 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 7625 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 7626 {
7627 warn (_("Skipping unexpected relocation type %s\n"), relname);
7628 continue;
7629 }
7630
7631 i = rp->r_offset / unw_ent_size;
7632
89fac5e3 7633 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 7634 {
7635 case 0:
7636 aux->table[i].start.section = sym->st_shndx;
1e456d54 7637 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 7638 break;
7639 case 1:
7640 aux->table[i].end.section = sym->st_shndx;
1e456d54 7641 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 7642 break;
7643 default:
7644 break;
7645 }
7646 }
7647
7648 free (rela);
7649 }
7650
1c0751b2 7651 aux->table_len = nentries;
57346661
AM		 7652
7653 return 1;
7654}
7655
1b31d05e 7656static void
2cf0635d 7657hppa_process_unwind (FILE * file)
57346661 7658{
57346661 7659 struct hppa_unw_aux_info aux;
2cf0635d
NC		 7660 Elf_Internal_Shdr * unwsec = NULL;
7661 Elf_Internal_Shdr * strsec;
7662 Elf_Internal_Shdr * sec;
18bd398b 7663 unsigned long i;
57346661 7664
c256ffe7 7665 if (string_table == NULL)
1b31d05e
NC		 7666 return;
7667
7668 memset (& aux, 0, sizeof (aux));
57346661
AM		 7669
7670 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7671 {
c256ffe7 7672 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 7673 && sec->sh_link < elf_header.e_shnum)
57346661 7674 {
ba5cdace 7675 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 7676
4fbb74a6 7677 strsec = section_headers + sec->sh_link;
4082ef84
NC		 7678 if (aux.strtab != NULL)
7679 {
7680 error (_("Multiple auxillary string tables encountered\n"));
7681 free (aux.strtab);
7682 }
3f5e193b
NC		 7683 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7684 1, strsec->sh_size,
7685 _("string table"));
c256ffe7 7686 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 7687 }
18bd398b 7688 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 7689 unwsec = sec;
7690 }
7691
7692 if (!unwsec)
7693 printf (_("\nThere are no unwind sections in this file.\n"));
7694
7695 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7696 {
18bd398b 7697 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 7698 {
74e1a04b
NC		 7699 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7700 printable_section_name (sec),
57346661 7701 (unsigned long) sec->sh_offset,
89fac5e3 7702 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 7703
7704 slurp_hppa_unwind_table (file, &aux, sec);
7705 if (aux.table_len > 0)
7706 dump_hppa_unwind (&aux);
7707
7708 if (aux.table)
7709 free ((char *) aux.table);
7710 aux.table = NULL;
7711 }
7712 }
7713
7714 if (aux.symtab)
7715 free (aux.symtab);
7716 if (aux.strtab)
7717 free ((char *) aux.strtab);
57346661
AM		 7718}
7719
0b6ae522
DJ		 7720struct arm_section
7721{
a734115a
NC		 7722 unsigned char * data; /* The unwind data. */
7723 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
7724 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
7725 unsigned long nrelas; /* The number of relocations. */
7726 unsigned int rel_type; /* REL or RELA ? */
7727 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 7728};
7729
7730struct arm_unw_aux_info
7731{
a734115a
NC		 7732 FILE * file; /* The file containing the unwind sections. */
7733 Elf_Internal_Sym * symtab; /* The file's symbol table. */
7734 unsigned long nsyms; /* Number of symbols. */
948f632f
DA		 7735 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7736 unsigned long nfuns; /* Number of these symbols. */
a734115a
NC		 7737 char * strtab; /* The file's string table. */
7738 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 7739};
7740
7741static const char *
7742arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7743 bfd_vma fn, struct absaddr addr)
7744{
7745 const char *procname;
7746 bfd_vma sym_offset;
7747
7748 if (addr.section == SHN_UNDEF)
7749 addr.offset = fn;
7750
948f632f 7751 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
0b6ae522
DJ		 7752 aux->strtab_size, addr, &procname,
7753 &sym_offset);
7754
7755 print_vma (fn, PREFIX_HEX);
7756
7757 if (procname)
7758 {
7759 fputs (" <", stdout);
7760 fputs (procname, stdout);
7761
7762 if (sym_offset)
7763 printf ("+0x%lx", (unsigned long) sym_offset);
7764 fputc ('>', stdout);
7765 }
7766
7767 return procname;
7768}
7769
7770static void
7771arm_free_section (struct arm_section *arm_sec)
7772{
7773 if (arm_sec->data != NULL)
7774 free (arm_sec->data);
7775
7776 if (arm_sec->rela != NULL)
7777 free (arm_sec->rela);
7778}
7779
a734115a
NC		 7780/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7781 cached section and install SEC instead.
7782 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7783 and return its valued in * WORDP, relocating if necessary.
1b31d05e 7784 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 7785 relocation's offset in ADDR.
1b31d05e
NC		 7786 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7787 into the string table of the symbol associated with the reloc. If no
7788 reloc was applied store -1 there.
7789 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 7790
7791static bfd_boolean
1b31d05e
NC		 7792get_unwind_section_word (struct arm_unw_aux_info * aux,
7793 struct arm_section * arm_sec,
7794 Elf_Internal_Shdr * sec,
7795 bfd_vma word_offset,
7796 unsigned int * wordp,
7797 struct absaddr * addr,
7798 bfd_vma * sym_name)
0b6ae522
DJ		 7799{
7800 Elf_Internal_Rela *rp;
7801 Elf_Internal_Sym *sym;
7802 const char * relname;
7803 unsigned int word;
7804 bfd_boolean wrapped;
7805
e0a31db1
NC		 7806 if (sec == NULL || arm_sec == NULL)
7807 return FALSE;
7808
0b6ae522
DJ		 7809 addr->section = SHN_UNDEF;
7810 addr->offset = 0;
7811
1b31d05e
NC		 7812 if (sym_name != NULL)
7813 *sym_name = (bfd_vma) -1;
7814
a734115a 7815 /* If necessary, update the section cache. */
0b6ae522
DJ		 7816 if (sec != arm_sec->sec)
7817 {
7818 Elf_Internal_Shdr *relsec;
7819
7820 arm_free_section (arm_sec);
7821
7822 arm_sec->sec = sec;
7823 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7824 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 7825 arm_sec->rela = NULL;
7826 arm_sec->nrelas = 0;
7827
7828 for (relsec = section_headers;
7829 relsec < section_headers + elf_header.e_shnum;
7830 ++relsec)
7831 {
7832 if (relsec->sh_info >= elf_header.e_shnum
1ae40aa4
NC		 7833 || section_headers + relsec->sh_info != sec
7834 /* PR 15745: Check the section type as well. */
7835 || (relsec->sh_type != SHT_REL
7836 && relsec->sh_type != SHT_RELA))
0b6ae522
DJ		 7837 continue;
7838
a734115a 7839 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 7840 if (relsec->sh_type == SHT_REL)
7841 {
7842 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7843 relsec->sh_size,
7844 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7845 return FALSE;
0b6ae522 7846 }
1ae40aa4 7847 else /* relsec->sh_type == SHT_RELA */
0b6ae522
DJ		 7848 {
7849 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7850 relsec->sh_size,
7851 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7852 return FALSE;
0b6ae522 7853 }
1ae40aa4 7854 break;
0b6ae522
DJ		 7855 }
7856
7857 arm_sec->next_rela = arm_sec->rela;
7858 }
7859
a734115a 7860 /* If there is no unwind data we can do nothing. */
0b6ae522 7861 if (arm_sec->data == NULL)
a734115a 7862 return FALSE;
0b6ae522 7863
e0a31db1 7864 /* If the offset is invalid then fail. */
1a915552
NC		 7865 if (word_offset > (sec->sh_size - 4)
7866 /* PR 18879 */
7867 || (sec->sh_size < 5 && word_offset >= sec->sh_size)
7868 || ((bfd_signed_vma) word_offset) < 0)
e0a31db1
NC		 7869 return FALSE;
7870
a734115a 7871 /* Get the word at the required offset. */
0b6ae522
DJ		 7872 word = byte_get (arm_sec->data + word_offset, 4);
7873
0eff7165
NC		 7874 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7875 if (arm_sec->rela == NULL)
7876 {
7877 * wordp = word;
7878 return TRUE;
7879 }
7880
a734115a 7881 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 7882 wrapped = FALSE;
7883 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7884 {
7885 bfd_vma prelval, offset;
7886
7887 if (rp->r_offset > word_offset && !wrapped)
7888 {
7889 rp = arm_sec->rela;
7890 wrapped = TRUE;
7891 }
7892 if (rp->r_offset > word_offset)
7893 break;
7894
7895 if (rp->r_offset & 3)
7896 {
7897 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7898 (unsigned long) rp->r_offset);
7899 continue;
7900 }
7901
7902 if (rp->r_offset < word_offset)
7903 continue;
7904
74e1a04b
NC		 7905 /* PR 17531: file: 027-161405-0.004 */
7906 if (aux->symtab == NULL)
7907 continue;
7908
0b6ae522
DJ		 7909 if (arm_sec->rel_type == SHT_REL)
7910 {
7911 offset = word & 0x7fffffff;
7912 if (offset & 0x40000000)
7913 offset |= ~ (bfd_vma) 0x7fffffff;
7914 }
a734115a 7915 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 7916 offset = rp->r_addend;
a734115a 7917 else
74e1a04b
NC		 7918 {
7919 error (_("Unknown section relocation type %d encountered\n"),
7920 arm_sec->rel_type);
7921 break;
7922 }
0b6ae522 7923
071436c6
NC		 7924 /* PR 17531 file: 027-1241568-0.004. */
7925 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7926 {
7927 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7928 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7929 break;
7930 }
7931
7932 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
0b6ae522
DJ		 7933 offset += sym->st_value;
7934 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7935
a734115a
NC		 7936 /* Check that we are processing the expected reloc type. */
7937 if (elf_header.e_machine == EM_ARM)
7938 {
7939 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7940 if (relname == NULL)
7941 {
7942 warn (_("Skipping unknown ARM relocation type: %d\n"),
7943 (int) ELF32_R_TYPE (rp->r_info));
7944 continue;
7945 }
a734115a
NC		 7946
7947 if (streq (relname, "R_ARM_NONE"))
7948 continue;
0b4362b0 7949
a734115a
NC		 7950 if (! streq (relname, "R_ARM_PREL31"))
7951 {
071436c6 7952 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
a734115a
NC		 7953 continue;
7954 }
7955 }
7956 else if (elf_header.e_machine == EM_TI_C6000)
7957 {
7958 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7959 if (relname == NULL)
7960 {
7961 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7962 (int) ELF32_R_TYPE (rp->r_info));
7963 continue;
7964 }
0b4362b0 7965
a734115a
NC		 7966 if (streq (relname, "R_C6000_NONE"))
7967 continue;
7968
7969 if (! streq (relname, "R_C6000_PREL31"))
7970 {
071436c6 7971 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
a734115a
NC		 7972 continue;
7973 }
7974
7975 prelval >>= 1;
7976 }
7977 else
74e1a04b
NC		 7978 {
7979 /* This function currently only supports ARM and TI unwinders. */
7980 warn (_("Only TI and ARM unwinders are currently supported\n"));
7981 break;
7982 }
fa197c1c 7983
0b6ae522
DJ		 7984 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7985 addr->section = sym->st_shndx;
7986 addr->offset = offset;
74e1a04b 7987
1b31d05e
NC		 7988 if (sym_name)
7989 * sym_name = sym->st_name;
0b6ae522
DJ		 7990 break;
7991 }
7992
7993 *wordp = word;
7994 arm_sec->next_rela = rp;
7995
a734115a 7996 return TRUE;
0b6ae522
DJ		 7997}
7998
a734115a
NC		 7999static const char *tic6x_unwind_regnames[16] =
8000{
0b4362b0
RM		 8001 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8002 "A14", "A13", "A12", "A11", "A10",
a734115a
NC		 8003 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8004};
fa197c1c 8005
0b6ae522 8006static void
fa197c1c 8007decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 8008{
fa197c1c
PB		 8009 int i;
8010
8011 for (i = 12; mask; mask >>= 1, i--)
8012 {
8013 if (mask & 1)
8014 {
8015 fputs (tic6x_unwind_regnames[i], stdout);
8016 if (mask > 1)
8017 fputs (", ", stdout);
8018 }
8019 }
8020}
0b6ae522
DJ		 8021
8022#define ADVANCE \
8023 if (remaining == 0 && more_words) \
8024 { \
8025 data_offset += 4; \
1b31d05e
NC		 8026 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
8027 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 8028 return; \
8029 remaining = 4; \
8030 more_words--; \
8031 } \
8032
8033#define GET_OP(OP) \
8034 ADVANCE; \
8035 if (remaining) \
8036 { \
8037 remaining--; \
8038 (OP) = word >> 24; \
8039 word <<= 8; \
8040 } \
8041 else \
8042 { \
2b692964 8043 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 8044 return; \
8045 } \
cc5914eb 8046 printf ("0x%02x ", OP)
0b6ae522 8047
fa197c1c 8048static void
948f632f
DA		 8049decode_arm_unwind_bytecode (struct arm_unw_aux_info * aux,
8050 unsigned int word,
8051 unsigned int remaining,
8052 unsigned int more_words,
8053 bfd_vma data_offset,
8054 Elf_Internal_Shdr * data_sec,
8055 struct arm_section * data_arm_sec)
fa197c1c
PB		 8056{
8057 struct absaddr addr;
0b6ae522
DJ		 8058
8059 /* Decode the unwinding instructions. */
8060 while (1)
8061 {
8062 unsigned int op, op2;
8063
8064 ADVANCE;
8065 if (remaining == 0)
8066 break;
8067 remaining--;
8068 op = word >> 24;
8069 word <<= 8;
8070
cc5914eb 8071 printf (" 0x%02x ", op);
0b6ae522
DJ		 8072
8073 if ((op & 0xc0) == 0x00)
8074 {
8075 int offset = ((op & 0x3f) << 2) + 4;
61865e30 8076
cc5914eb 8077 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 8078 }
8079 else if ((op & 0xc0) == 0x40)
8080 {
8081 int offset = ((op & 0x3f) << 2) + 4;
61865e30 8082
cc5914eb 8083 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 8084 }
8085 else if ((op & 0xf0) == 0x80)
8086 {
8087 GET_OP (op2);
8088 if (op == 0x80 && op2 == 0)
8089 printf (_("Refuse to unwind"));
8090 else
8091 {
8092 unsigned int mask = ((op & 0x0f) << 8) | op2;
8093 int first = 1;
8094 int i;
2b692964 8095
0b6ae522
DJ		 8096 printf ("pop {");
8097 for (i = 0; i < 12; i++)
8098 if (mask & (1 << i))
8099 {
8100 if (first)
8101 first = 0;
8102 else
8103 printf (", ");
8104 printf ("r%d", 4 + i);
8105 }
8106 printf ("}");
8107 }
8108 }
8109 else if ((op & 0xf0) == 0x90)
8110 {
8111 if (op == 0x9d || op == 0x9f)
8112 printf (_(" [Reserved]"));
8113 else
cc5914eb 8114 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 8115 }
8116 else if ((op & 0xf0) == 0xa0)
8117 {
8118 int end = 4 + (op & 0x07);
8119 int first = 1;
8120 int i;
61865e30 8121
0b6ae522
DJ		 8122 printf (" pop {");
8123 for (i = 4; i <= end; i++)
8124 {
8125 if (first)
8126 first = 0;
8127 else
8128 printf (", ");
8129 printf ("r%d", i);
8130 }
8131 if (op & 0x08)
8132 {
1b31d05e 8133 if (!first)
0b6ae522
DJ		 8134 printf (", ");
8135 printf ("r14");
8136 }
8137 printf ("}");
8138 }
8139 else if (op == 0xb0)
8140 printf (_(" finish"));
8141 else if (op == 0xb1)
8142 {
8143 GET_OP (op2);
8144 if (op2 == 0 || (op2 & 0xf0) != 0)
8145 printf (_("[Spare]"));
8146 else
8147 {
8148 unsigned int mask = op2 & 0x0f;
8149 int first = 1;
8150 int i;
61865e30 8151
0b6ae522
DJ		 8152 printf ("pop {");
8153 for (i = 0; i < 12; i++)
8154 if (mask & (1 << i))
8155 {
8156 if (first)
8157 first = 0;
8158 else
8159 printf (", ");
8160 printf ("r%d", i);
8161 }
8162 printf ("}");
8163 }
8164 }
8165 else if (op == 0xb2)
8166 {
b115cf96 8167 unsigned char buf[9];
0b6ae522
DJ		 8168 unsigned int i, len;
8169 unsigned long offset;
61865e30 8170
b115cf96 8171 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 8172 {
8173 GET_OP (buf[i]);
8174 if ((buf[i] & 0x80) == 0)
8175 break;
8176 }
4082ef84
NC		 8177 if (i == sizeof (buf))
8178 printf (_("corrupt change to vsp"));
8179 else
8180 {
8181 offset = read_uleb128 (buf, &len, buf + i + 1);
8182 assert (len == i + 1);
8183 offset = offset * 4 + 0x204;
8184 printf ("vsp = vsp + %ld", offset);
8185 }
0b6ae522 8186 }
61865e30 8187 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 8188 {
61865e30
NC		 8189 unsigned int first, last;
8190
8191 GET_OP (op2);
8192 first = op2 >> 4;
8193 last = op2 & 0x0f;
8194 if (op == 0xc8)
8195 first = first + 16;
8196 printf ("pop {D%d", first);
8197 if (last)
8198 printf ("-D%d", first + last);
8199 printf ("}");
8200 }
8201 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8202 {
8203 unsigned int count = op & 0x07;
8204
8205 printf ("pop {D8");
8206 if (count)
8207 printf ("-D%d", 8 + count);
8208 printf ("}");
8209 }
8210 else if (op >= 0xc0 && op <= 0xc5)
8211 {
8212 unsigned int count = op & 0x07;
8213
8214 printf (" pop {wR10");
8215 if (count)
8216 printf ("-wR%d", 10 + count);
8217 printf ("}");
8218 }
8219 else if (op == 0xc6)
8220 {
8221 unsigned int first, last;
8222
8223 GET_OP (op2);
8224 first = op2 >> 4;
8225 last = op2 & 0x0f;
8226 printf ("pop {wR%d", first);
8227 if (last)
8228 printf ("-wR%d", first + last);
8229 printf ("}");
8230 }
8231 else if (op == 0xc7)
8232 {
8233 GET_OP (op2);
8234 if (op2 == 0 || (op2 & 0xf0) != 0)
8235 printf (_("[Spare]"));
0b6ae522
DJ		 8236 else
8237 {
61865e30
NC		 8238 unsigned int mask = op2 & 0x0f;
8239 int first = 1;
8240 int i;
8241
8242 printf ("pop {");
8243 for (i = 0; i < 4; i++)
8244 if (mask & (1 << i))
8245 {
8246 if (first)
8247 first = 0;
8248 else
8249 printf (", ");
8250 printf ("wCGR%d", i);
8251 }
8252 printf ("}");
0b6ae522
DJ		 8253 }
8254 }
61865e30
NC		 8255 else
8256 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 8257 printf ("\n");
8258 }
fa197c1c
PB		 8259}
8260
8261static void
948f632f
DA		 8262decode_tic6x_unwind_bytecode (struct arm_unw_aux_info * aux,
8263 unsigned int word,
8264 unsigned int remaining,
8265 unsigned int more_words,
8266 bfd_vma data_offset,
8267 Elf_Internal_Shdr * data_sec,
8268 struct arm_section * data_arm_sec)
fa197c1c
PB		 8269{
8270 struct absaddr addr;
8271
8272 /* Decode the unwinding instructions. */
8273 while (1)
8274 {
8275 unsigned int op, op2;
8276
8277 ADVANCE;
8278 if (remaining == 0)
8279 break;
8280 remaining--;
8281 op = word >> 24;
8282 word <<= 8;
8283
9cf03b7e 8284 printf (" 0x%02x ", op);
fa197c1c
PB		 8285
8286 if ((op & 0xc0) == 0x00)
8287 {
8288 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 8289 printf (" sp = sp + %d", offset);
fa197c1c
PB		 8290 }
8291 else if ((op & 0xc0) == 0x80)
8292 {
8293 GET_OP (op2);
8294 if (op == 0x80 && op2 == 0)
8295 printf (_("Refuse to unwind"));
8296 else
8297 {
8298 unsigned int mask = ((op & 0x1f) << 8) | op2;
8299 if (op & 0x20)
8300 printf ("pop compact {");
8301 else
8302 printf ("pop {");
8303
8304 decode_tic6x_unwind_regmask (mask);
8305 printf("}");
8306 }
8307 }
8308 else if ((op & 0xf0) == 0xc0)
8309 {
8310 unsigned int reg;
8311 unsigned int nregs;
8312 unsigned int i;
8313 const char *name;
a734115a
NC		 8314 struct
8315 {
fa197c1c
PB		 8316 unsigned int offset;
8317 unsigned int reg;
8318 } regpos[16];
8319
8320 /* Scan entire instruction first so that GET_OP output is not
8321 interleaved with disassembly. */
8322 nregs = 0;
8323 for (i = 0; nregs < (op & 0xf); i++)
8324 {
8325 GET_OP (op2);
8326 reg = op2 >> 4;
8327 if (reg != 0xf)
8328 {
8329 regpos[nregs].offset = i * 2;
8330 regpos[nregs].reg = reg;
8331 nregs++;
8332 }
8333
8334 reg = op2 & 0xf;
8335 if (reg != 0xf)
8336 {
8337 regpos[nregs].offset = i * 2 + 1;
8338 regpos[nregs].reg = reg;
8339 nregs++;
8340 }
8341 }
8342
8343 printf (_("pop frame {"));
8344 reg = nregs - 1;
8345 for (i = i * 2; i > 0; i--)
8346 {
8347 if (regpos[reg].offset == i - 1)
8348 {
8349 name = tic6x_unwind_regnames[regpos[reg].reg];
8350 if (reg > 0)
8351 reg--;
8352 }
8353 else
8354 name = _("[pad]");
8355
8356 fputs (name, stdout);
8357 if (i > 1)
8358 printf (", ");
8359 }
8360
8361 printf ("}");
8362 }
8363 else if (op == 0xd0)
8364 printf (" MOV FP, SP");
8365 else if (op == 0xd1)
8366 printf (" __c6xabi_pop_rts");
8367 else if (op == 0xd2)
8368 {
8369 unsigned char buf[9];
8370 unsigned int i, len;
8371 unsigned long offset;
a734115a 8372
fa197c1c
PB		 8373 for (i = 0; i < sizeof (buf); i++)
8374 {
8375 GET_OP (buf[i]);
8376 if ((buf[i] & 0x80) == 0)
8377 break;
8378 }
0eff7165
NC		 8379 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8380 if (i == sizeof (buf))
8381 {
8382 printf ("<corrupt sp adjust>\n");
8383 warn (_("Corrupt stack pointer adjustment detected\n"));
8384 return;
8385 }
948f632f 8386
f6f0e17b 8387 offset = read_uleb128 (buf, &len, buf + i + 1);
fa197c1c
PB		 8388 assert (len == i + 1);
8389 offset = offset * 8 + 0x408;
8390 printf (_("sp = sp + %ld"), offset);
8391 }
8392 else if ((op & 0xf0) == 0xe0)
8393 {
8394 if ((op & 0x0f) == 7)
8395 printf (" RETURN");
8396 else
8397 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8398 }
8399 else
8400 {
8401 printf (_(" [unsupported opcode]"));
8402 }
8403 putchar ('\n');
8404 }
8405}
8406
8407static bfd_vma
a734115a 8408arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 8409{
8410 bfd_vma offset;
8411
8412 offset = word & 0x7fffffff;
8413 if (offset & 0x40000000)
8414 offset |= ~ (bfd_vma) 0x7fffffff;
8415
8416 if (elf_header.e_machine == EM_TI_C6000)
8417 offset <<= 1;
8418
8419 return offset + where;
8420}
8421
8422static void
1b31d05e
NC		 8423decode_arm_unwind (struct arm_unw_aux_info * aux,
8424 unsigned int word,
8425 unsigned int remaining,
8426 bfd_vma data_offset,
8427 Elf_Internal_Shdr * data_sec,
8428 struct arm_section * data_arm_sec)
fa197c1c
PB		 8429{
8430 int per_index;
8431 unsigned int more_words = 0;
37e14bc3 8432 struct absaddr addr;
1b31d05e 8433 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 8434
8435 if (remaining == 0)
8436 {
1b31d05e
NC		 8437 /* Fetch the first word.
8438 Note - when decoding an object file the address extracted
8439 here will always be 0. So we also pass in the sym_name
8440 parameter so that we can find the symbol associated with
8441 the personality routine. */
8442 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8443 & word, & addr, & sym_name))
fa197c1c 8444 return;
1b31d05e 8445
fa197c1c
PB		 8446 remaining = 4;
8447 }
8448
8449 if ((word & 0x80000000) == 0)
8450 {
8451 /* Expand prel31 for personality routine. */
8452 bfd_vma fn;
8453 const char *procname;
8454
a734115a 8455 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 8456 printf (_(" Personality routine: "));
1b31d05e
NC		 8457 if (fn == 0
8458 && addr.section == SHN_UNDEF && addr.offset == 0
8459 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8460 {
8461 procname = aux->strtab + sym_name;
8462 print_vma (fn, PREFIX_HEX);
8463 if (procname)
8464 {
8465 fputs (" <", stdout);
8466 fputs (procname, stdout);
8467 fputc ('>', stdout);
8468 }
8469 }
8470 else
8471 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 8472 fputc ('\n', stdout);
8473
8474 /* The GCC personality routines use the standard compact
8475 encoding, starting with one byte giving the number of
8476 words. */
8477 if (procname != NULL
8478 && (const_strneq (procname, "__gcc_personality_v0")
8479 || const_strneq (procname, "__gxx_personality_v0")
8480 || const_strneq (procname, "__gcj_personality_v0")
8481 || const_strneq (procname, "__gnu_objc_personality_v0")))
8482 {
8483 remaining = 0;
8484 more_words = 1;
8485 ADVANCE;
8486 if (!remaining)
8487 {
8488 printf (_(" [Truncated data]\n"));
8489 return;
8490 }
8491 more_words = word >> 24;
8492 word <<= 8;
8493 remaining--;
8494 per_index = -1;
8495 }
8496 else
8497 return;
8498 }
8499 else
8500 {
1b31d05e 8501 /* ARM EHABI Section 6.3:
0b4362b0 8502
1b31d05e 8503 An exception-handling table entry for the compact model looks like:
0b4362b0 8504
1b31d05e
NC		 8505 31 30-28 27-24 23-0
8506 -- ----- ----- ----
8507 1 0 index Data for personalityRoutine[index] */
8508
8509 if (elf_header.e_machine == EM_ARM
8510 && (word & 0x70000000))
83c257ca 8511 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 8512
fa197c1c 8513 per_index = (word >> 24) & 0x7f;
1b31d05e 8514 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 8515 if (per_index == 0)
8516 {
8517 more_words = 0;
8518 word <<= 8;
8519 remaining--;
8520 }
8521 else if (per_index < 3)
8522 {
8523 more_words = (word >> 16) & 0xff;
8524 word <<= 16;
8525 remaining -= 2;
8526 }
8527 }
8528
8529 switch (elf_header.e_machine)
8530 {
8531 case EM_ARM:
8532 if (per_index < 3)
8533 {
8534 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8535 data_offset, data_sec, data_arm_sec);
8536 }
8537 else
1b31d05e
NC		 8538 {
8539 warn (_("Unknown ARM compact model index encountered\n"));
8540 printf (_(" [reserved]\n"));
8541 }
fa197c1c
PB		 8542 break;
8543
8544 case EM_TI_C6000:
8545 if (per_index < 3)
8546 {
8547 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 8548 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 8549 }
8550 else if (per_index < 5)
8551 {
8552 if (((word >> 17) & 0x7f) == 0x7f)
8553 printf (_(" Restore stack from frame pointer\n"));
8554 else
8555 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
8556 printf (_(" Registers restored: "));
8557 if (per_index == 4)
8558 printf (" (compact) ");
8559 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8560 putchar ('\n');
8561 printf (_(" Return register: %s\n"),
8562 tic6x_unwind_regnames[word & 0xf]);
8563 }
8564 else
1b31d05e 8565 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 8566 break;
8567
8568 default:
74e1a04b 8569 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
1b31d05e 8570 elf_header.e_machine);
fa197c1c 8571 }
0b6ae522
DJ		 8572
8573 /* Decode the descriptors. Not implemented. */
8574}
8575
8576static void
8577dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8578{
8579 struct arm_section exidx_arm_sec, extab_arm_sec;
8580 unsigned int i, exidx_len;
948f632f 8581 unsigned long j, nfuns;
0b6ae522
DJ		 8582
8583 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8584 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8585 exidx_len = exidx_sec->sh_size / 8;
8586
948f632f
DA		 8587 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8588 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8589 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8590 aux->funtab[nfuns++] = aux->symtab[j];
8591 aux->nfuns = nfuns;
8592 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8593
0b6ae522
DJ		 8594 for (i = 0; i < exidx_len; i++)
8595 {
8596 unsigned int exidx_fn, exidx_entry;
8597 struct absaddr fn_addr, entry_addr;
8598 bfd_vma fn;
8599
8600 fputc ('\n', stdout);
8601
1b31d05e
NC		 8602 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8603 8 * i, & exidx_fn, & fn_addr, NULL)
8604 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8605 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 8606 {
948f632f 8607 free (aux->funtab);
1b31d05e
NC		 8608 arm_free_section (& exidx_arm_sec);
8609 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 8610 return;
8611 }
8612
83c257ca
NC		 8613 /* ARM EHABI, Section 5:
8614 An index table entry consists of 2 words.
8615 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8616 if (exidx_fn & 0x80000000)
8617 warn (_("corrupt index table entry: %x\n"), exidx_fn);
8618
a734115a 8619 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 8620
a734115a 8621 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 8622 fputs (": ", stdout);
8623
8624 if (exidx_entry == 1)
8625 {
8626 print_vma (exidx_entry, PREFIX_HEX);
8627 fputs (" [cantunwind]\n", stdout);
8628 }
8629 else if (exidx_entry & 0x80000000)
8630 {
8631 print_vma (exidx_entry, PREFIX_HEX);
8632 fputc ('\n', stdout);
8633 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8634 }
8635 else
8636 {
8f73510c 8637 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 8638 Elf_Internal_Shdr *table_sec;
8639
8640 fputs ("@", stdout);
a734115a 8641 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 8642 print_vma (table, PREFIX_HEX);
8643 printf ("\n");
8644
8645 /* Locate the matching .ARM.extab. */
8646 if (entry_addr.section != SHN_UNDEF
8647 && entry_addr.section < elf_header.e_shnum)
8648 {
8649 table_sec = section_headers + entry_addr.section;
8650 table_offset = entry_addr.offset;
1a915552
NC		 8651 /* PR 18879 */
8652 if (table_offset > table_sec->sh_size
8653 || ((bfd_signed_vma) table_offset) < 0)
8654 {
8655 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8656 (unsigned long) table_offset,
8657 printable_section_name (table_sec));
8658 continue;
8659 }
0b6ae522
DJ		 8660 }
8661 else
8662 {
8663 table_sec = find_section_by_address (table);
8664 if (table_sec != NULL)
8665 table_offset = table - table_sec->sh_addr;
8666 }
8667 if (table_sec == NULL)
8668 {
8669 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8670 (unsigned long) table);
8671 continue;
8672 }
8673 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8674 &extab_arm_sec);
8675 }
8676 }
8677
8678 printf ("\n");
8679
948f632f 8680 free (aux->funtab);
0b6ae522
DJ		 8681 arm_free_section (&exidx_arm_sec);
8682 arm_free_section (&extab_arm_sec);
8683}
8684
fa197c1c 8685/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 8686
8687static void
0b6ae522
DJ		 8688arm_process_unwind (FILE *file)
8689{
8690 struct arm_unw_aux_info aux;
8691 Elf_Internal_Shdr *unwsec = NULL;
8692 Elf_Internal_Shdr *strsec;
8693 Elf_Internal_Shdr *sec;
8694 unsigned long i;
fa197c1c 8695 unsigned int sec_type;
0b6ae522 8696
fa197c1c
PB		 8697 switch (elf_header.e_machine)
8698 {
8699 case EM_ARM:
8700 sec_type = SHT_ARM_EXIDX;
8701 break;
8702
8703 case EM_TI_C6000:
8704 sec_type = SHT_C6000_UNWIND;
8705 break;
8706
0b4362b0 8707 default:
74e1a04b 8708 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
1b31d05e
NC		 8709 elf_header.e_machine);
8710 return;
fa197c1c
PB		 8711 }
8712
0b6ae522 8713 if (string_table == NULL)
1b31d05e
NC		 8714 return;
8715
8716 memset (& aux, 0, sizeof (aux));
8717 aux.file = file;
0b6ae522
DJ		 8718
8719 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8720 {
8721 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8722 {
ba5cdace 8723 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 8724
8725 strsec = section_headers + sec->sh_link;
74e1a04b
NC		 8726
8727 /* PR binutils/17531 file: 011-12666-0.004. */
8728 if (aux.strtab != NULL)
8729 {
4082ef84 8730 error (_("Multiple string tables found in file.\n"));
74e1a04b
NC		 8731 free (aux.strtab);
8732 }
0b6ae522
DJ		 8733 aux.strtab = get_data (NULL, file, strsec->sh_offset,
8734 1, strsec->sh_size, _("string table"));
8735 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8736 }
fa197c1c 8737 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 8738 unwsec = sec;
8739 }
8740
1b31d05e 8741 if (unwsec == NULL)
0b6ae522 8742 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 8743 else
8744 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8745 {
8746 if (sec->sh_type == sec_type)
8747 {
8748 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
74e1a04b 8749 printable_section_name (sec),
1b31d05e
NC		 8750 (unsigned long) sec->sh_offset,
8751 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 8752
1b31d05e
NC		 8753 dump_arm_unwind (&aux, sec);
8754 }
8755 }
0b6ae522
DJ		 8756
8757 if (aux.symtab)
8758 free (aux.symtab);
8759 if (aux.strtab)
8760 free ((char *) aux.strtab);
0b6ae522
DJ		 8761}
8762
1b31d05e 8763static void
2cf0635d 8764process_unwind (FILE * file)
57346661 8765{
2cf0635d
NC		 8766 struct unwind_handler
8767 {
57346661 8768 int machtype;
1b31d05e 8769 void (* handler)(FILE *);
2cf0635d
NC		 8770 } handlers[] =
8771 {
0b6ae522 8772 { EM_ARM, arm_process_unwind },
57346661
AM		 8773 { EM_IA_64, ia64_process_unwind },
8774 { EM_PARISC, hppa_process_unwind },
fa197c1c 8775 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 8776 { 0, 0 }
8777 };
8778 int i;
8779
8780 if (!do_unwind)
1b31d05e 8781 return;
57346661
AM		 8782
8783 for (i = 0; handlers[i].handler != NULL; i++)
8784 if (elf_header.e_machine == handlers[i].machtype)
9f758fdc
NC		 8785 {
8786 handlers[i].handler (file);
8787 return;
8788 }
57346661 8789
1b31d05e
NC		 8790 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8791 get_machine_name (elf_header.e_machine));
57346661
AM		 8792}
8793
252b5132 8794static void
2cf0635d 8795dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 8796{
8797 switch (entry->d_tag)
8798 {
8799 case DT_MIPS_FLAGS:
8800 if (entry->d_un.d_val == 0)
4b68bca3 8801 printf (_("NONE"));
252b5132
RH		 8802 else
8803 {
8804 static const char * opts[] =
8805 {
8806 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8807 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8808 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8809 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8810 "RLD_ORDER_SAFE"
8811 };
8812 unsigned int cnt;
8813 int first = 1;
2b692964 8814
60bca95a 8815 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 8816 if (entry->d_un.d_val & (1 << cnt))
8817 {
8818 printf ("%s%s", first ? "" : " ", opts[cnt]);
8819 first = 0;
8820 }
252b5132
RH		 8821 }
8822 break;
103f02d3 8823
252b5132 8824 case DT_MIPS_IVERSION:
d79b3d50 8825 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 8826 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8827 else
76ca31c0
NC		 8828 {
8829 char buf[40];
8830 sprintf_vma (buf, entry->d_un.d_ptr);
8831 /* Note: coded this way so that there is a single string for translation. */
8832 printf (_("<corrupt: %s>"), buf);
8833 }
252b5132 8834 break;
103f02d3 8835
252b5132
RH		 8836 case DT_MIPS_TIME_STAMP:
8837 {
d5b07ef4 8838 char timebuf[128];
2cf0635d 8839 struct tm * tmp;
91d6fa6a 8840 time_t atime = entry->d_un.d_val;
82b1b41b 8841
91d6fa6a 8842 tmp = gmtime (&atime);
82b1b41b
NC		 8843 /* PR 17531: file: 6accc532. */
8844 if (tmp == NULL)
8845 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8846 else
8847 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8848 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8849 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 8850 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 8851 }
8852 break;
103f02d3 8853
252b5132
RH		 8854 case DT_MIPS_RLD_VERSION:
8855 case DT_MIPS_LOCAL_GOTNO:
8856 case DT_MIPS_CONFLICTNO:
8857 case DT_MIPS_LIBLISTNO:
8858 case DT_MIPS_SYMTABNO:
8859 case DT_MIPS_UNREFEXTNO:
8860 case DT_MIPS_HIPAGENO:
8861 case DT_MIPS_DELTA_CLASS_NO:
8862 case DT_MIPS_DELTA_INSTANCE_NO:
8863 case DT_MIPS_DELTA_RELOC_NO:
8864 case DT_MIPS_DELTA_SYM_NO:
8865 case DT_MIPS_DELTA_CLASSSYM_NO:
8866 case DT_MIPS_COMPACT_SIZE:
c69075ac 8867 print_vma (entry->d_un.d_val, DEC);
252b5132 8868 break;
103f02d3
UD		 8869
8870 default:
4b68bca3 8871 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 8872 }
4b68bca3 8873 putchar ('\n');
103f02d3
UD		 8874}
8875
103f02d3 8876static void
2cf0635d 8877dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 8878{
8879 switch (entry->d_tag)
8880 {
8881 case DT_HP_DLD_FLAGS:
8882 {
8883 static struct
8884 {
8885 long int bit;
2cf0635d 8886 const char * str;
5e220199
NC		 8887 }
8888 flags[] =
8889 {
8890 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8891 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8892 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8893 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8894 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8895 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8896 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8897 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8898 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8899 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 8900 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8901 { DT_HP_GST, "HP_GST" },
8902 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8903 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8904 { DT_HP_NODELETE, "HP_NODELETE" },
8905 { DT_HP_GROUP, "HP_GROUP" },
8906 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 8907 };
103f02d3 8908 int first = 1;
5e220199 8909 size_t cnt;
f7a99963 8910 bfd_vma val = entry->d_un.d_val;
103f02d3 8911
60bca95a 8912 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 8913 if (val & flags[cnt].bit)
30800947
NC		 8914 {
8915 if (! first)
8916 putchar (' ');
8917 fputs (flags[cnt].str, stdout);
8918 first = 0;
8919 val ^= flags[cnt].bit;
8920 }
76da6bbe 8921
103f02d3 8922 if (val != 0 || first)
f7a99963
NC		 8923 {
8924 if (! first)
8925 putchar (' ');
8926 print_vma (val, HEX);
8927 }
103f02d3
UD		 8928 }
8929 break;
76da6bbe 8930
252b5132 8931 default:
f7a99963
NC		 8932 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8933 break;
252b5132 8934 }
35b1837e 8935 putchar ('\n');
252b5132
RH		 8936}
8937
28f997cf
TG		 8938#ifdef BFD64
8939
8940/* VMS vs Unix time offset and factor. */
8941
8942#define VMS_EPOCH_OFFSET 35067168000000000LL
8943#define VMS_GRANULARITY_FACTOR 10000000
8944
8945/* Display a VMS time in a human readable format. */
8946
8947static void
8948print_vms_time (bfd_int64_t vmstime)
8949{
8950 struct tm *tm;
8951 time_t unxtime;
8952
8953 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8954 tm = gmtime (&unxtime);
8955 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8956 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8957 tm->tm_hour, tm->tm_min, tm->tm_sec);
8958}
8959#endif /* BFD64 */
8960
ecc51f48 8961static void
2cf0635d 8962dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 8963{
8964 switch (entry->d_tag)
8965 {
0de14b54 8966 case DT_IA_64_PLT_RESERVE:
bdf4d63a 8967 /* First 3 slots reserved. */
ecc51f48
NC		 8968 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8969 printf (" -- ");
8970 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 8971 break;
8972
28f997cf
TG		 8973 case DT_IA_64_VMS_LINKTIME:
8974#ifdef BFD64
8975 print_vms_time (entry->d_un.d_val);
8976#endif
8977 break;
8978
8979 case DT_IA_64_VMS_LNKFLAGS:
8980 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8981 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8982 printf (" CALL_DEBUG");
8983 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8984 printf (" NOP0BUFS");
8985 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8986 printf (" P0IMAGE");
8987 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8988 printf (" MKTHREADS");
8989 if (entry->d_un.d_val & VMS_LF_UPCALLS)
8990 printf (" UPCALLS");
8991 if (entry->d_un.d_val & VMS_LF_IMGSTA)
8992 printf (" IMGSTA");
8993 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8994 printf (" INITIALIZE");
8995 if (entry->d_un.d_val & VMS_LF_MAIN)
8996 printf (" MAIN");
8997 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8998 printf (" EXE_INIT");
8999 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9000 printf (" TBK_IN_IMG");
9001 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9002 printf (" DBG_IN_IMG");
9003 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9004 printf (" TBK_IN_DSF");
9005 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9006 printf (" DBG_IN_DSF");
9007 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9008 printf (" SIGNATURES");
9009 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9010 printf (" REL_SEG_OFF");
9011 break;
9012
bdf4d63a
JJ		 9013 default:
9014 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9015 break;
ecc51f48 9016 }
bdf4d63a 9017 putchar ('\n');
ecc51f48
NC		 9018}
9019
252b5132 9020static int
2cf0635d 9021get_32bit_dynamic_section (FILE * file)
252b5132 9022{
2cf0635d
NC		 9023 Elf32_External_Dyn * edyn;
9024 Elf32_External_Dyn * ext;
9025 Elf_Internal_Dyn * entry;
103f02d3 9026
3f5e193b
NC		 9027 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
9028 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 9029 if (!edyn)
9030 return 0;
103f02d3 9031
071436c6
NC		 9032 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9033 might not have the luxury of section headers. Look for the DT_NULL
9034 terminator to determine the number of entries. */
ba2685cc 9035 for (ext = edyn, dynamic_nent = 0;
53c3012c 9036 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
ba2685cc
AM		 9037 ext++)
9038 {
9039 dynamic_nent++;
9040 if (BYTE_GET (ext->d_tag) == DT_NULL)
9041 break;
9042 }
252b5132 9043
3f5e193b
NC		 9044 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9045 sizeof (* entry));
b2d38a17 9046 if (dynamic_section == NULL)
252b5132 9047 {
8b73c356
NC		 9048 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9049 (unsigned long) dynamic_nent);
9ea033b2
NC		 9050 free (edyn);
9051 return 0;
9052 }
252b5132 9053
fb514b26 9054 for (ext = edyn, entry = dynamic_section;
ba2685cc 9055 entry < dynamic_section + dynamic_nent;
fb514b26 9056 ext++, entry++)
9ea033b2 9057 {
fb514b26
AM		 9058 entry->d_tag = BYTE_GET (ext->d_tag);
9059 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 9060 }
9061
9ea033b2
NC		 9062 free (edyn);
9063
9064 return 1;
9065}
9066
9067static int
2cf0635d 9068get_64bit_dynamic_section (FILE * file)
9ea033b2 9069{
2cf0635d
NC		 9070 Elf64_External_Dyn * edyn;
9071 Elf64_External_Dyn * ext;
9072 Elf_Internal_Dyn * entry;
103f02d3 9073
071436c6 9074 /* Read in the data. */
3f5e193b
NC		 9075 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
9076 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 9077 if (!edyn)
9078 return 0;
103f02d3 9079
071436c6
NC		 9080 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9081 might not have the luxury of section headers. Look for the DT_NULL
9082 terminator to determine the number of entries. */
ba2685cc 9083 for (ext = edyn, dynamic_nent = 0;
53c3012c
AM		 9084 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9085 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
ba2685cc
AM		 9086 ext++)
9087 {
9088 dynamic_nent++;
66543521 9089 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 9090 break;
9091 }
252b5132 9092
3f5e193b
NC		 9093 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9094 sizeof (* entry));
b2d38a17 9095 if (dynamic_section == NULL)
252b5132 9096 {
8b73c356
NC		 9097 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9098 (unsigned long) dynamic_nent);
252b5132
RH		 9099 free (edyn);
9100 return 0;
9101 }
9102
071436c6 9103 /* Convert from external to internal formats. */
fb514b26 9104 for (ext = edyn, entry = dynamic_section;
ba2685cc 9105 entry < dynamic_section + dynamic_nent;
fb514b26 9106 ext++, entry++)
252b5132 9107 {
66543521
AM		 9108 entry->d_tag = BYTE_GET (ext->d_tag);
9109 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 9110 }
9111
9112 free (edyn);
9113
9ea033b2
NC		 9114 return 1;
9115}
9116
e9e44622
JJ		 9117static void
9118print_dynamic_flags (bfd_vma flags)
d1133906 9119{
e9e44622 9120 int first = 1;
13ae64f3 9121
d1133906
NC		 9122 while (flags)
9123 {
9124 bfd_vma flag;
9125
9126 flag = flags & - flags;
9127 flags &= ~ flag;
9128
e9e44622
JJ		 9129 if (first)
9130 first = 0;
9131 else
9132 putc (' ', stdout);
13ae64f3 9133
d1133906
NC		 9134 switch (flag)
9135 {
e9e44622
JJ		 9136 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
9137 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
9138 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
9139 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
9140 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 9141 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 9142 }
9143 }
e9e44622 9144 puts ("");
d1133906
NC		 9145}
9146
b2d38a17
NC		 9147/* Parse and display the contents of the dynamic section. */
9148
9ea033b2 9149static int
2cf0635d 9150process_dynamic_section (FILE * file)
9ea033b2 9151{
2cf0635d 9152 Elf_Internal_Dyn * entry;
9ea033b2
NC		 9153
9154 if (dynamic_size == 0)
9155 {
9156 if (do_dynamic)
b2d38a17 9157 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 9158
9159 return 1;
9160 }
9161
9162 if (is_32bit_elf)
9163 {
b2d38a17 9164 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 9165 return 0;
9166 }
b2d38a17 9167 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 9168 return 0;
9169
252b5132
RH		 9170 /* Find the appropriate symbol table. */
9171 if (dynamic_symbols == NULL)
9172 {
86dba8ee
AM		 9173 for (entry = dynamic_section;
9174 entry < dynamic_section + dynamic_nent;
9175 ++entry)
252b5132 9176 {
c8286bd1 9177 Elf_Internal_Shdr section;
252b5132
RH		 9178
9179 if (entry->d_tag != DT_SYMTAB)
9180 continue;
9181
9182 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9183
9184 /* Since we do not know how big the symbol table is,
9185 we default to reading in the entire file (!) and
9186 processing that. This is overkill, I know, but it
e3c8793a 9187 should work. */
d93f0186 9188 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 9189
fb52b2f4
NC		 9190 if (archive_file_offset != 0)
9191 section.sh_size = archive_file_size - section.sh_offset;
9192 else
9193 {
9194 if (fseek (file, 0, SEEK_END))
591a748a 9195 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 9196
9197 section.sh_size = ftell (file) - section.sh_offset;
9198 }
252b5132 9199
9ea033b2 9200 if (is_32bit_elf)
9ad5cbcf 9201 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 9202 else
9ad5cbcf 9203 section.sh_entsize = sizeof (Elf64_External_Sym);
071436c6 9204 section.sh_name = string_table_length;
252b5132 9205
ba5cdace 9206 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 9207 if (num_dynamic_syms < 1)
252b5132
RH		 9208 {
9209 error (_("Unable to determine the number of symbols to load\n"));
9210 continue;
9211 }
252b5132
RH		 9212 }
9213 }
9214
9215 /* Similarly find a string table. */
9216 if (dynamic_strings == NULL)
9217 {
86dba8ee
AM		 9218 for (entry = dynamic_section;
9219 entry < dynamic_section + dynamic_nent;
9220 ++entry)
252b5132
RH		 9221 {
9222 unsigned long offset;
b34976b6 9223 long str_tab_len;
252b5132
RH		 9224
9225 if (entry->d_tag != DT_STRTAB)
9226 continue;
9227
9228 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9229
9230 /* Since we do not know how big the string table is,
9231 we default to reading in the entire file (!) and
9232 processing that. This is overkill, I know, but it
e3c8793a 9233 should work. */
252b5132 9234
d93f0186 9235 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 9236
9237 if (archive_file_offset != 0)
9238 str_tab_len = archive_file_size - offset;
9239 else
9240 {
9241 if (fseek (file, 0, SEEK_END))
9242 error (_("Unable to seek to end of file\n"));
9243 str_tab_len = ftell (file) - offset;
9244 }
252b5132
RH		 9245
9246 if (str_tab_len < 1)
9247 {
9248 error
9249 (_("Unable to determine the length of the dynamic string table\n"));
9250 continue;
9251 }
9252
3f5e193b
NC		 9253 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
9254 str_tab_len,
9255 _("dynamic string table"));
59245841 9256 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 9257 break;
9258 }
9259 }
9260
9261 /* And find the syminfo section if available. */
9262 if (dynamic_syminfo == NULL)
9263 {
3e8bba36 9264 unsigned long syminsz = 0;
252b5132 9265
86dba8ee
AM		 9266 for (entry = dynamic_section;
9267 entry < dynamic_section + dynamic_nent;
9268 ++entry)
252b5132
RH		 9269 {
9270 if (entry->d_tag == DT_SYMINENT)
9271 {
9272 /* Note: these braces are necessary to avoid a syntax
9273 error from the SunOS4 C compiler. */
049b0c3a
NC		 9274 /* PR binutils/17531: A corrupt file can trigger this test.
9275 So do not use an assert, instead generate an error message. */
9276 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
071436c6 9277 error (_("Bad value (%d) for SYMINENT entry\n"),
049b0c3a 9278 (int) entry->d_un.d_val);
252b5132
RH		 9279 }
9280 else if (entry->d_tag == DT_SYMINSZ)
9281 syminsz = entry->d_un.d_val;
9282 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 9283 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
9284 syminsz);
252b5132
RH		 9285 }
9286
9287 if (dynamic_syminfo_offset != 0 && syminsz != 0)
9288 {
2cf0635d
NC		 9289 Elf_External_Syminfo * extsyminfo;
9290 Elf_External_Syminfo * extsym;
9291 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 9292
9293 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 9294 extsyminfo = (Elf_External_Syminfo *)
9295 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
9296 _("symbol information"));
a6e9f9df
AM		 9297 if (!extsyminfo)
9298 return 0;
252b5132 9299
3f5e193b 9300 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 9301 if (dynamic_syminfo == NULL)
9302 {
8b73c356
NC		 9303 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9304 (unsigned long) syminsz);
252b5132
RH		 9305 return 0;
9306 }
9307
9308 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 9309 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9310 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9311 ++syminfo, ++extsym)
252b5132 9312 {
86dba8ee
AM		 9313 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9314 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 9315 }
9316
9317 free (extsyminfo);
9318 }
9319 }
9320
9321 if (do_dynamic && dynamic_addr)
8b73c356
NC		 9322 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9323 dynamic_addr, (unsigned long) dynamic_nent);
252b5132
RH		 9324 if (do_dynamic)
9325 printf (_(" Tag Type Name/Value\n"));
9326
86dba8ee
AM		 9327 for (entry = dynamic_section;
9328 entry < dynamic_section + dynamic_nent;
9329 entry++)
252b5132
RH		 9330 {
9331 if (do_dynamic)
f7a99963 9332 {
2cf0635d 9333 const char * dtype;
e699b9ff 9334
f7a99963
NC		 9335 putchar (' ');
9336 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 9337 dtype = get_dynamic_type (entry->d_tag);
9338 printf (" (%s)%*s", dtype,
9339 ((is_32bit_elf ? 27 : 19)
9340 - (int) strlen (dtype)),
f7a99963
NC		 9341 " ");
9342 }
252b5132
RH		 9343
9344 switch (entry->d_tag)
9345 {
d1133906
NC		 9346 case DT_FLAGS:
9347 if (do_dynamic)
e9e44622 9348 print_dynamic_flags (entry->d_un.d_val);
d1133906 9349 break;
76da6bbe 9350
252b5132
RH		 9351 case DT_AUXILIARY:
9352 case DT_FILTER:
019148e4
L		 9353 case DT_CONFIG:
9354 case DT_DEPAUDIT:
9355 case DT_AUDIT:
252b5132
RH		 9356 if (do_dynamic)
9357 {
019148e4 9358 switch (entry->d_tag)
b34976b6 9359 {
019148e4
L		 9360 case DT_AUXILIARY:
9361 printf (_("Auxiliary library"));
9362 break;
9363
9364 case DT_FILTER:
9365 printf (_("Filter library"));
9366 break;
9367
b34976b6 9368 case DT_CONFIG:
019148e4
L		 9369 printf (_("Configuration file"));
9370 break;
9371
9372 case DT_DEPAUDIT:
9373 printf (_("Dependency audit library"));
9374 break;
9375
9376 case DT_AUDIT:
9377 printf (_("Audit library"));
9378 break;
9379 }
252b5132 9380
d79b3d50
NC		 9381 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9382 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 9383 else
f7a99963
NC		 9384 {
9385 printf (": ");
9386 print_vma (entry->d_un.d_val, PREFIX_HEX);
9387 putchar ('\n');
9388 }
252b5132
RH		 9389 }
9390 break;
9391
dcefbbbd 9392 case DT_FEATURE:
252b5132
RH		 9393 if (do_dynamic)
9394 {
9395 printf (_("Flags:"));
86f55779 9396
252b5132
RH		 9397 if (entry->d_un.d_val == 0)
9398 printf (_(" None\n"));
9399 else
9400 {
9401 unsigned long int val = entry->d_un.d_val;
86f55779 9402
252b5132
RH		 9403 if (val & DTF_1_PARINIT)
9404 {
9405 printf (" PARINIT");
9406 val ^= DTF_1_PARINIT;
9407 }
dcefbbbd
L		 9408 if (val & DTF_1_CONFEXP)
9409 {
9410 printf (" CONFEXP");
9411 val ^= DTF_1_CONFEXP;
9412 }
252b5132
RH		 9413 if (val != 0)
9414 printf (" %lx", val);
9415 puts ("");
9416 }
9417 }
9418 break;
9419
9420 case DT_POSFLAG_1:
9421 if (do_dynamic)
9422 {
9423 printf (_("Flags:"));
86f55779 9424
252b5132
RH		 9425 if (entry->d_un.d_val == 0)
9426 printf (_(" None\n"));
9427 else
9428 {
9429 unsigned long int val = entry->d_un.d_val;
86f55779 9430
252b5132
RH		 9431 if (val & DF_P1_LAZYLOAD)
9432 {
9433 printf (" LAZYLOAD");
9434 val ^= DF_P1_LAZYLOAD;
9435 }
9436 if (val & DF_P1_GROUPPERM)
9437 {
9438 printf (" GROUPPERM");
9439 val ^= DF_P1_GROUPPERM;
9440 }
9441 if (val != 0)
9442 printf (" %lx", val);
9443 puts ("");
9444 }
9445 }
9446 break;
9447
9448 case DT_FLAGS_1:
9449 if (do_dynamic)
9450 {
9451 printf (_("Flags:"));
9452 if (entry->d_un.d_val == 0)
9453 printf (_(" None\n"));
9454 else
9455 {
9456 unsigned long int val = entry->d_un.d_val;
86f55779 9457
252b5132
RH		 9458 if (val & DF_1_NOW)
9459 {
9460 printf (" NOW");
9461 val ^= DF_1_NOW;
9462 }
9463 if (val & DF_1_GLOBAL)
9464 {
9465 printf (" GLOBAL");
9466 val ^= DF_1_GLOBAL;
9467 }
9468 if (val & DF_1_GROUP)
9469 {
9470 printf (" GROUP");
9471 val ^= DF_1_GROUP;
9472 }
9473 if (val & DF_1_NODELETE)
9474 {
9475 printf (" NODELETE");
9476 val ^= DF_1_NODELETE;
9477 }
9478 if (val & DF_1_LOADFLTR)
9479 {
9480 printf (" LOADFLTR");
9481 val ^= DF_1_LOADFLTR;
9482 }
9483 if (val & DF_1_INITFIRST)
9484 {
9485 printf (" INITFIRST");
9486 val ^= DF_1_INITFIRST;
9487 }
9488 if (val & DF_1_NOOPEN)
9489 {
9490 printf (" NOOPEN");
9491 val ^= DF_1_NOOPEN;
9492 }
9493 if (val & DF_1_ORIGIN)
9494 {
9495 printf (" ORIGIN");
9496 val ^= DF_1_ORIGIN;
9497 }
9498 if (val & DF_1_DIRECT)
9499 {
9500 printf (" DIRECT");
9501 val ^= DF_1_DIRECT;
9502 }
9503 if (val & DF_1_TRANS)
9504 {
9505 printf (" TRANS");
9506 val ^= DF_1_TRANS;
9507 }
9508 if (val & DF_1_INTERPOSE)
9509 {
9510 printf (" INTERPOSE");
9511 val ^= DF_1_INTERPOSE;
9512 }
f7db6139 9513 if (val & DF_1_NODEFLIB)
dcefbbbd 9514 {
f7db6139
L		 9515 printf (" NODEFLIB");
9516 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 9517 }
9518 if (val & DF_1_NODUMP)
9519 {
9520 printf (" NODUMP");
9521 val ^= DF_1_NODUMP;
9522 }
34b60028 9523 if (val & DF_1_CONFALT)
dcefbbbd 9524 {
34b60028
L		 9525 printf (" CONFALT");
9526 val ^= DF_1_CONFALT;
9527 }
9528 if (val & DF_1_ENDFILTEE)
9529 {
9530 printf (" ENDFILTEE");
9531 val ^= DF_1_ENDFILTEE;
9532 }
9533 if (val & DF_1_DISPRELDNE)
9534 {
9535 printf (" DISPRELDNE");
9536 val ^= DF_1_DISPRELDNE;
9537 }
9538 if (val & DF_1_DISPRELPND)
9539 {
9540 printf (" DISPRELPND");
9541 val ^= DF_1_DISPRELPND;
9542 }
9543 if (val & DF_1_NODIRECT)
9544 {
9545 printf (" NODIRECT");
9546 val ^= DF_1_NODIRECT;
9547 }
9548 if (val & DF_1_IGNMULDEF)
9549 {
9550 printf (" IGNMULDEF");
9551 val ^= DF_1_IGNMULDEF;
9552 }
9553 if (val & DF_1_NOKSYMS)
9554 {
9555 printf (" NOKSYMS");
9556 val ^= DF_1_NOKSYMS;
9557 }
9558 if (val & DF_1_NOHDR)
9559 {
9560 printf (" NOHDR");
9561 val ^= DF_1_NOHDR;
9562 }
9563 if (val & DF_1_EDITED)
9564 {
9565 printf (" EDITED");
9566 val ^= DF_1_EDITED;
9567 }
9568 if (val & DF_1_NORELOC)
9569 {
9570 printf (" NORELOC");
9571 val ^= DF_1_NORELOC;
9572 }
9573 if (val & DF_1_SYMINTPOSE)
9574 {
9575 printf (" SYMINTPOSE");
9576 val ^= DF_1_SYMINTPOSE;
9577 }
9578 if (val & DF_1_GLOBAUDIT)
9579 {
9580 printf (" GLOBAUDIT");
9581 val ^= DF_1_GLOBAUDIT;
9582 }
9583 if (val & DF_1_SINGLETON)
9584 {
9585 printf (" SINGLETON");
9586 val ^= DF_1_SINGLETON;
dcefbbbd 9587 }
5c383f02
RO		 9588 if (val & DF_1_STUB)
9589 {
9590 printf (" STUB");
9591 val ^= DF_1_STUB;
9592 }
9593 if (val & DF_1_PIE)
9594 {
9595 printf (" PIE");
9596 val ^= DF_1_PIE;
9597 }
252b5132
RH		 9598 if (val != 0)
9599 printf (" %lx", val);
9600 puts ("");
9601 }
9602 }
9603 break;
9604
9605 case DT_PLTREL:
566b0d53 9606 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9607 if (do_dynamic)
9608 puts (get_dynamic_type (entry->d_un.d_val));
9609 break;
9610
9611 case DT_NULL :
9612 case DT_NEEDED :
9613 case DT_PLTGOT :
9614 case DT_HASH :
9615 case DT_STRTAB :
9616 case DT_SYMTAB :
9617 case DT_RELA :
9618 case DT_INIT :
9619 case DT_FINI :
9620 case DT_SONAME :
9621 case DT_RPATH :
9622 case DT_SYMBOLIC:
9623 case DT_REL :
9624 case DT_DEBUG :
9625 case DT_TEXTREL :
9626 case DT_JMPREL :
019148e4 9627 case DT_RUNPATH :
252b5132
RH		 9628 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9629
9630 if (do_dynamic)
9631 {
2cf0635d 9632 char * name;
252b5132 9633
d79b3d50
NC		 9634 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9635 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9636 else
d79b3d50 9637 name = NULL;
252b5132
RH		 9638
9639 if (name)
9640 {
9641 switch (entry->d_tag)
9642 {
9643 case DT_NEEDED:
9644 printf (_("Shared library: [%s]"), name);
9645
18bd398b 9646 if (streq (name, program_interpreter))
f7a99963 9647 printf (_(" program interpreter"));
252b5132
RH		 9648 break;
9649
9650 case DT_SONAME:
f7a99963 9651 printf (_("Library soname: [%s]"), name);
252b5132
RH		 9652 break;
9653
9654 case DT_RPATH:
f7a99963 9655 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 9656 break;
9657
019148e4
L		 9658 case DT_RUNPATH:
9659 printf (_("Library runpath: [%s]"), name);
9660 break;
9661
252b5132 9662 default:
f7a99963
NC		 9663 print_vma (entry->d_un.d_val, PREFIX_HEX);
9664 break;
252b5132
RH		 9665 }
9666 }
9667 else
f7a99963
NC		 9668 print_vma (entry->d_un.d_val, PREFIX_HEX);
9669
9670 putchar ('\n');
252b5132
RH		 9671 }
9672 break;
9673
9674 case DT_PLTRELSZ:
9675 case DT_RELASZ :
9676 case DT_STRSZ :
9677 case DT_RELSZ :
9678 case DT_RELAENT :
9679 case DT_SYMENT :
9680 case DT_RELENT :
566b0d53 9681 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9682 case DT_PLTPADSZ:
9683 case DT_MOVEENT :
9684 case DT_MOVESZ :
9685 case DT_INIT_ARRAYSZ:
9686 case DT_FINI_ARRAYSZ:
047b2264
JJ		 9687 case DT_GNU_CONFLICTSZ:
9688 case DT_GNU_LIBLISTSZ:
252b5132 9689 if (do_dynamic)
f7a99963
NC		 9690 {
9691 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 9692 printf (_(" (bytes)\n"));
f7a99963 9693 }
252b5132
RH		 9694 break;
9695
9696 case DT_VERDEFNUM:
9697 case DT_VERNEEDNUM:
9698 case DT_RELACOUNT:
9699 case DT_RELCOUNT:
9700 if (do_dynamic)
f7a99963
NC		 9701 {
9702 print_vma (entry->d_un.d_val, UNSIGNED);
9703 putchar ('\n');
9704 }
252b5132
RH		 9705 break;
9706
9707 case DT_SYMINSZ:
9708 case DT_SYMINENT:
9709 case DT_SYMINFO:
9710 case DT_USED:
9711 case DT_INIT_ARRAY:
9712 case DT_FINI_ARRAY:
9713 if (do_dynamic)
9714 {
d79b3d50
NC		 9715 if (entry->d_tag == DT_USED
9716 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 9717 {
2cf0635d 9718 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9719
b34976b6 9720 if (*name)
252b5132
RH		 9721 {
9722 printf (_("Not needed object: [%s]\n"), name);
9723 break;
9724 }
9725 }
103f02d3 9726
f7a99963
NC		 9727 print_vma (entry->d_un.d_val, PREFIX_HEX);
9728 putchar ('\n');
252b5132
RH		 9729 }
9730 break;
9731
9732 case DT_BIND_NOW:
9733 /* The value of this entry is ignored. */
35b1837e
AM		 9734 if (do_dynamic)
9735 putchar ('\n');
252b5132 9736 break;
103f02d3 9737
047b2264
JJ		 9738 case DT_GNU_PRELINKED:
9739 if (do_dynamic)
9740 {
2cf0635d 9741 struct tm * tmp;
91d6fa6a 9742 time_t atime = entry->d_un.d_val;
047b2264 9743
91d6fa6a 9744 tmp = gmtime (&atime);
071436c6
NC		 9745 /* PR 17533 file: 041-1244816-0.004. */
9746 if (tmp == NULL)
5a2cbcf4
L		 9747 printf (_("<corrupt time val: %lx"),
9748 (unsigned long) atime);
071436c6
NC		 9749 else
9750 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9751 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9752 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 9753
9754 }
9755 break;
9756
fdc90cb4
JJ		 9757 case DT_GNU_HASH:
9758 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9759 if (do_dynamic)
9760 {
9761 print_vma (entry->d_un.d_val, PREFIX_HEX);
9762 putchar ('\n');
9763 }
9764 break;
9765
252b5132
RH		 9766 default:
9767 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 9768 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 9769 entry->d_un.d_val;
9770
9771 if (do_dynamic)
9772 {
9773 switch (elf_header.e_machine)
9774 {
9775 case EM_MIPS:
4fe85591 9776 case EM_MIPS_RS3_LE:
b2d38a17 9777 dynamic_section_mips_val (entry);
252b5132 9778 break;
103f02d3 9779 case EM_PARISC:
b2d38a17 9780 dynamic_section_parisc_val (entry);
103f02d3 9781 break;
ecc51f48 9782 case EM_IA_64:
b2d38a17 9783 dynamic_section_ia64_val (entry);
ecc51f48 9784 break;
252b5132 9785 default:
f7a99963
NC		 9786 print_vma (entry->d_un.d_val, PREFIX_HEX);
9787 putchar ('\n');
252b5132
RH		 9788 }
9789 }
9790 break;
9791 }
9792 }
9793
9794 return 1;
9795}
9796
9797static char *
d3ba0551 9798get_ver_flags (unsigned int flags)
252b5132 9799{
b34976b6 9800 static char buff[32];
252b5132
RH		 9801
9802 buff[0] = 0;
9803
9804 if (flags == 0)
9805 return _("none");
9806
9807 if (flags & VER_FLG_BASE)
9808 strcat (buff, "BASE ");
9809
9810 if (flags & VER_FLG_WEAK)
9811 {
9812 if (flags & VER_FLG_BASE)
9813 strcat (buff, "| ");
9814
9815 strcat (buff, "WEAK ");
9816 }
9817
44ec90b9
RO		 9818 if (flags & VER_FLG_INFO)
9819 {
9820 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9821 strcat (buff, "| ");
9822
9823 strcat (buff, "INFO ");
9824 }
9825
9826 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 9827 strcat (buff, _("| <unknown>"));
252b5132
RH		 9828
9829 return buff;
9830}
9831
9832/* Display the contents of the version sections. */
98fb390a 9833
252b5132 9834static int
2cf0635d 9835process_version_sections (FILE * file)
252b5132 9836{
2cf0635d 9837 Elf_Internal_Shdr * section;
b34976b6
AM		 9838 unsigned i;
9839 int found = 0;
252b5132
RH		 9840
9841 if (! do_version)
9842 return 1;
9843
9844 for (i = 0, section = section_headers;
9845 i < elf_header.e_shnum;
b34976b6 9846 i++, section++)
252b5132
RH		 9847 {
9848 switch (section->sh_type)
9849 {
9850 case SHT_GNU_verdef:
9851 {
2cf0635d 9852 Elf_External_Verdef * edefs;
b34976b6
AM		 9853 unsigned int idx;
9854 unsigned int cnt;
2cf0635d 9855 char * endbuf;
252b5132
RH		 9856
9857 found = 1;
9858
74e1a04b
NC		 9859 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9860 printable_section_name (section),
9861 section->sh_info);
252b5132
RH		 9862
9863 printf (_(" Addr: 0x"));
9864 printf_vma (section->sh_addr);
74e1a04b 9865 printf (_(" Offset: %#08lx Link: %u (%s)"),
1b228002 9866 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9867 printable_section_name_from_index (section->sh_link));
252b5132 9868
3f5e193b
NC		 9869 edefs = (Elf_External_Verdef *)
9870 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9871 _("version definition section"));
a6e9f9df
AM		 9872 if (!edefs)
9873 break;
59245841 9874 endbuf = (char *) edefs + section->sh_size;
252b5132 9875
b34976b6 9876 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 9877 {
2cf0635d
NC		 9878 char * vstart;
9879 Elf_External_Verdef * edef;
b34976b6 9880 Elf_Internal_Verdef ent;
2cf0635d 9881 Elf_External_Verdaux * eaux;
b34976b6
AM		 9882 Elf_Internal_Verdaux aux;
9883 int j;
9884 int isum;
103f02d3 9885
7e26601c
NC		 9886 /* Check for very large indicies. */
9887 if (idx > (size_t) (endbuf - (char *) edefs))
dd24e3da
NC		 9888 break;
9889
252b5132 9890 vstart = ((char *) edefs) + idx;
54806181
AM		 9891 if (vstart + sizeof (*edef) > endbuf)
9892 break;
252b5132
RH		 9893
9894 edef = (Elf_External_Verdef *) vstart;
9895
9896 ent.vd_version = BYTE_GET (edef->vd_version);
9897 ent.vd_flags = BYTE_GET (edef->vd_flags);
9898 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
9899 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
9900 ent.vd_hash = BYTE_GET (edef->vd_hash);
9901 ent.vd_aux = BYTE_GET (edef->vd_aux);
9902 ent.vd_next = BYTE_GET (edef->vd_next);
9903
9904 printf (_(" %#06x: Rev: %d Flags: %s"),
9905 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9906
9907 printf (_(" Index: %d Cnt: %d "),
9908 ent.vd_ndx, ent.vd_cnt);
9909
dd24e3da 9910 /* Check for overflow. */
7e26601c 9911 if (ent.vd_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 9912 break;
9913
252b5132
RH		 9914 vstart += ent.vd_aux;
9915
9916 eaux = (Elf_External_Verdaux *) vstart;
9917
9918 aux.vda_name = BYTE_GET (eaux->vda_name);
9919 aux.vda_next = BYTE_GET (eaux->vda_next);
9920
d79b3d50
NC		 9921 if (VALID_DYNAMIC_NAME (aux.vda_name))
9922 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9923 else
9924 printf (_("Name index: %ld\n"), aux.vda_name);
9925
9926 isum = idx + ent.vd_aux;
9927
b34976b6 9928 for (j = 1; j < ent.vd_cnt; j++)
252b5132 9929 {
dd24e3da 9930 /* Check for overflow. */
7e26601c 9931 if (aux.vda_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 9932 break;
9933
252b5132
RH		 9934 isum += aux.vda_next;
9935 vstart += aux.vda_next;
9936
9937 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 9938 if (vstart + sizeof (*eaux) > endbuf)
9939 break;
252b5132
RH		 9940
9941 aux.vda_name = BYTE_GET (eaux->vda_name);
9942 aux.vda_next = BYTE_GET (eaux->vda_next);
9943
d79b3d50 9944 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 9945 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 9946 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9947 else
9948 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9949 isum, j, aux.vda_name);
9950 }
dd24e3da 9951
54806181
AM		 9952 if (j < ent.vd_cnt)
9953 printf (_(" Version def aux past end of section\n"));
252b5132 9954
5d921cbd
NC		 9955 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9956 if (idx + ent.vd_next <= idx)
9957 break;
9958
252b5132
RH		 9959 idx += ent.vd_next;
9960 }
dd24e3da 9961
54806181
AM		 9962 if (cnt < section->sh_info)
9963 printf (_(" Version definition past end of section\n"));
252b5132
RH		 9964
9965 free (edefs);
9966 }
9967 break;
103f02d3 9968
252b5132
RH		 9969 case SHT_GNU_verneed:
9970 {
2cf0635d 9971 Elf_External_Verneed * eneed;
b34976b6
AM		 9972 unsigned int idx;
9973 unsigned int cnt;
2cf0635d 9974 char * endbuf;
252b5132
RH		 9975
9976 found = 1;
9977
72de5009 9978 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
74e1a04b 9979 printable_section_name (section), section->sh_info);
252b5132
RH		 9980
9981 printf (_(" Addr: 0x"));
9982 printf_vma (section->sh_addr);
72de5009 9983 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9984 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9985 printable_section_name_from_index (section->sh_link));
252b5132 9986
3f5e193b
NC		 9987 eneed = (Elf_External_Verneed *) get_data (NULL, file,
9988 section->sh_offset, 1,
9989 section->sh_size,
9cf03b7e 9990 _("Version Needs section"));
a6e9f9df
AM		 9991 if (!eneed)
9992 break;
59245841 9993 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 9994
9995 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9996 {
2cf0635d 9997 Elf_External_Verneed * entry;
b34976b6
AM		 9998 Elf_Internal_Verneed ent;
9999 int j;
10000 int isum;
2cf0635d 10001 char * vstart;
252b5132 10002
7e26601c 10003 if (idx > (size_t) (endbuf - (char *) eneed))
dd24e3da
NC		 10004 break;
10005
252b5132 10006 vstart = ((char *) eneed) + idx;
54806181
AM		 10007 if (vstart + sizeof (*entry) > endbuf)
10008 break;
252b5132
RH		 10009
10010 entry = (Elf_External_Verneed *) vstart;
10011
10012 ent.vn_version = BYTE_GET (entry->vn_version);
10013 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
10014 ent.vn_file = BYTE_GET (entry->vn_file);
10015 ent.vn_aux = BYTE_GET (entry->vn_aux);
10016 ent.vn_next = BYTE_GET (entry->vn_next);
10017
10018 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
10019
d79b3d50
NC		 10020 if (VALID_DYNAMIC_NAME (ent.vn_file))
10021 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 10022 else
10023 printf (_(" File: %lx"), ent.vn_file);
10024
10025 printf (_(" Cnt: %d\n"), ent.vn_cnt);
10026
dd24e3da 10027 /* Check for overflow. */
7e26601c 10028 if (ent.vn_aux > (size_t) (endbuf - vstart))
dd24e3da 10029 break;
252b5132
RH		 10030 vstart += ent.vn_aux;
10031
10032 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10033 {
2cf0635d 10034 Elf_External_Vernaux * eaux;
b34976b6 10035 Elf_Internal_Vernaux aux;
252b5132 10036
54806181
AM		 10037 if (vstart + sizeof (*eaux) > endbuf)
10038 break;
252b5132
RH		 10039 eaux = (Elf_External_Vernaux *) vstart;
10040
10041 aux.vna_hash = BYTE_GET (eaux->vna_hash);
10042 aux.vna_flags = BYTE_GET (eaux->vna_flags);
10043 aux.vna_other = BYTE_GET (eaux->vna_other);
10044 aux.vna_name = BYTE_GET (eaux->vna_name);
10045 aux.vna_next = BYTE_GET (eaux->vna_next);
10046
d79b3d50 10047 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 10048 printf (_(" %#06x: Name: %s"),
d79b3d50 10049 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 10050 else
ecc2063b 10051 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 10052 isum, aux.vna_name);
10053
10054 printf (_(" Flags: %s Version: %d\n"),
10055 get_ver_flags (aux.vna_flags), aux.vna_other);
10056
dd24e3da 10057 /* Check for overflow. */
53774b7e
NC		 10058 if (aux.vna_next > (size_t) (endbuf - vstart)
10059 || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
10060 {
10061 warn (_("Invalid vna_next field of %lx\n"),
10062 aux.vna_next);
10063 j = ent.vn_cnt;
10064 break;
10065 }
252b5132
RH		 10066 isum += aux.vna_next;
10067 vstart += aux.vna_next;
10068 }
9cf03b7e 10069
54806181 10070 if (j < ent.vn_cnt)
9cf03b7e 10071 warn (_("Missing Version Needs auxillary information\n"));
252b5132 10072
bcf83b2a 10073 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
c24cf8b6
NC		 10074 {
10075 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
10076 cnt = section->sh_info;
10077 break;
10078 }
252b5132
RH		 10079 idx += ent.vn_next;
10080 }
9cf03b7e 10081
54806181 10082 if (cnt < section->sh_info)
9cf03b7e 10083 warn (_("Missing Version Needs information\n"));
103f02d3 10084
252b5132
RH		 10085 free (eneed);
10086 }
10087 break;
10088
10089 case SHT_GNU_versym:
10090 {
2cf0635d 10091 Elf_Internal_Shdr * link_section;
8b73c356
NC		 10092 size_t total;
10093 unsigned int cnt;
2cf0635d
NC		 10094 unsigned char * edata;
10095 unsigned short * data;
10096 char * strtab;
10097 Elf_Internal_Sym * symbols;
10098 Elf_Internal_Shdr * string_sec;
ba5cdace 10099 unsigned long num_syms;
d3ba0551 10100 long off;
252b5132 10101
4fbb74a6 10102 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 10103 break;
10104
4fbb74a6 10105 link_section = section_headers + section->sh_link;
08d8fa11 10106 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 10107
4fbb74a6 10108 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 10109 break;
10110
252b5132
RH		 10111 found = 1;
10112
ba5cdace 10113 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 10114 if (symbols == NULL)
10115 break;
252b5132 10116
4fbb74a6 10117 string_sec = section_headers + link_section->sh_link;
252b5132 10118
3f5e193b
NC		 10119 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
10120 string_sec->sh_size,
10121 _("version string table"));
a6e9f9df 10122 if (!strtab)
0429c154
MS		 10123 {
10124 free (symbols);
10125 break;
10126 }
252b5132 10127
8b73c356
NC		 10128 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10129 printable_section_name (section), (unsigned long) total);
252b5132
RH		 10130
10131 printf (_(" Addr: "));
10132 printf_vma (section->sh_addr);
72de5009 10133 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 10134 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 10135 printable_section_name (link_section));
252b5132 10136
d3ba0551
AM		 10137 off = offset_from_vma (file,
10138 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10139 total * sizeof (short));
3f5e193b
NC		 10140 edata = (unsigned char *) get_data (NULL, file, off, total,
10141 sizeof (short),
10142 _("version symbol data"));
a6e9f9df
AM		 10143 if (!edata)
10144 {
10145 free (strtab);
0429c154 10146 free (symbols);
a6e9f9df
AM		 10147 break;
10148 }
252b5132 10149
3f5e193b 10150 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 10151
10152 for (cnt = total; cnt --;)
b34976b6
AM		 10153 data[cnt] = byte_get (edata + cnt * sizeof (short),
10154 sizeof (short));
252b5132
RH		 10155
10156 free (edata);
10157
10158 for (cnt = 0; cnt < total; cnt += 4)
10159 {
10160 int j, nn;
ab273396
AM		 10161 char *name;
10162 char *invalid = _("*invalid*");
252b5132
RH		 10163
10164 printf (" %03x:", cnt);
10165
10166 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 10167 switch (data[cnt + j])
252b5132
RH		 10168 {
10169 case 0:
10170 fputs (_(" 0 (*local*) "), stdout);
10171 break;
10172
10173 case 1:
10174 fputs (_(" 1 (*global*) "), stdout);
10175 break;
10176
10177 default:
c244d050
NC		 10178 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10179 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 10180
dd24e3da 10181 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 10182 array, break to avoid an out-of-bounds read. */
10183 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 10184 {
10185 warn (_("invalid index into symbol array\n"));
10186 break;
10187 }
10188
ab273396
AM		 10189 name = NULL;
10190 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 10191 {
b34976b6
AM		 10192 Elf_Internal_Verneed ivn;
10193 unsigned long offset;
252b5132 10194
d93f0186
NC		 10195 offset = offset_from_vma
10196 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10197 sizeof (Elf_External_Verneed));
252b5132 10198
b34976b6 10199 do
252b5132 10200 {
b34976b6
AM		 10201 Elf_Internal_Vernaux ivna;
10202 Elf_External_Verneed evn;
10203 Elf_External_Vernaux evna;
10204 unsigned long a_off;
252b5132 10205
59245841
NC		 10206 if (get_data (&evn, file, offset, sizeof (evn), 1,
10207 _("version need")) == NULL)
10208 break;
0b4362b0 10209
252b5132
RH		 10210 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10211 ivn.vn_next = BYTE_GET (evn.vn_next);
10212
10213 a_off = offset + ivn.vn_aux;
10214
10215 do
10216 {
59245841
NC		 10217 if (get_data (&evna, file, a_off, sizeof (evna),
10218 1, _("version need aux (2)")) == NULL)
10219 {
10220 ivna.vna_next = 0;
10221 ivna.vna_other = 0;
10222 }
10223 else
10224 {
10225 ivna.vna_next = BYTE_GET (evna.vna_next);
10226 ivna.vna_other = BYTE_GET (evna.vna_other);
10227 }
252b5132
RH		 10228
10229 a_off += ivna.vna_next;
10230 }
b34976b6 10231 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 10232 && ivna.vna_next != 0);
10233
b34976b6 10234 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 10235 {
10236 ivna.vna_name = BYTE_GET (evna.vna_name);
10237
54806181 10238 if (ivna.vna_name >= string_sec->sh_size)
ab273396 10239 name = invalid;
54806181
AM		 10240 else
10241 name = strtab + ivna.vna_name;
252b5132
RH		 10242 break;
10243 }
10244
10245 offset += ivn.vn_next;
10246 }
10247 while (ivn.vn_next);
10248 }
00d93f34 10249
ab273396 10250 if (data[cnt + j] != 0x8001
b34976b6 10251 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 10252 {
b34976b6
AM		 10253 Elf_Internal_Verdef ivd;
10254 Elf_External_Verdef evd;
10255 unsigned long offset;
252b5132 10256
d93f0186
NC		 10257 offset = offset_from_vma
10258 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10259 sizeof evd);
252b5132
RH		 10260
10261 do
10262 {
59245841
NC		 10263 if (get_data (&evd, file, offset, sizeof (evd), 1,
10264 _("version def")) == NULL)
10265 {
10266 ivd.vd_next = 0;
948f632f 10267 /* PR 17531: file: 046-1082287-0.004. */
3102e897
NC		 10268 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
10269 break;
59245841
NC		 10270 }
10271 else
10272 {
10273 ivd.vd_next = BYTE_GET (evd.vd_next);
10274 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10275 }
252b5132
RH		 10276
10277 offset += ivd.vd_next;
10278 }
c244d050 10279 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 10280 && ivd.vd_next != 0);
10281
c244d050 10282 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 10283 {
b34976b6
AM		 10284 Elf_External_Verdaux evda;
10285 Elf_Internal_Verdaux ivda;
252b5132
RH		 10286
10287 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10288
59245841
NC		 10289 if (get_data (&evda, file,
10290 offset - ivd.vd_next + ivd.vd_aux,
10291 sizeof (evda), 1,
10292 _("version def aux")) == NULL)
10293 break;
252b5132
RH		 10294
10295 ivda.vda_name = BYTE_GET (evda.vda_name);
10296
54806181 10297 if (ivda.vda_name >= string_sec->sh_size)
ab273396
AM		 10298 name = invalid;
10299 else if (name != NULL && name != invalid)
10300 name = _("*both*");
54806181
AM		 10301 else
10302 name = strtab + ivda.vda_name;
252b5132
RH		 10303 }
10304 }
ab273396
AM		 10305 if (name != NULL)
10306 nn += printf ("(%s%-*s",
10307 name,
10308 12 - (int) strlen (name),
10309 ")");
252b5132
RH		 10310
10311 if (nn < 18)
10312 printf ("%*c", 18 - nn, ' ');
10313 }
10314
10315 putchar ('\n');
10316 }
10317
10318 free (data);
10319 free (strtab);
10320 free (symbols);
10321 }
10322 break;
103f02d3 10323
252b5132
RH		 10324 default:
10325 break;
10326 }
10327 }
10328
10329 if (! found)
10330 printf (_("\nNo version information found in this file.\n"));
10331
10332 return 1;
10333}
10334
d1133906 10335static const char *
d3ba0551 10336get_symbol_binding (unsigned int binding)
252b5132 10337{
b34976b6 10338 static char buff[32];
252b5132
RH		 10339
10340 switch (binding)
10341 {
b34976b6
AM		 10342 case STB_LOCAL: return "LOCAL";
10343 case STB_GLOBAL: return "GLOBAL";
10344 case STB_WEAK: return "WEAK";
252b5132
RH		 10345 default:
10346 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 10347 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10348 binding);
252b5132 10349 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 10350 {
10351 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 10352 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10353 /* GNU is still using the default value 0. */
3e7a7d11
NC		 10354 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10355 return "UNIQUE";
10356 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10357 }
252b5132 10358 else
e9e44622 10359 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 10360 return buff;
10361 }
10362}
10363
d1133906 10364static const char *
d3ba0551 10365get_symbol_type (unsigned int type)
252b5132 10366{
b34976b6 10367 static char buff[32];
252b5132
RH		 10368
10369 switch (type)
10370 {
b34976b6
AM		 10371 case STT_NOTYPE: return "NOTYPE";
10372 case STT_OBJECT: return "OBJECT";
10373 case STT_FUNC: return "FUNC";
10374 case STT_SECTION: return "SECTION";
10375 case STT_FILE: return "FILE";
10376 case STT_COMMON: return "COMMON";
10377 case STT_TLS: return "TLS";
15ab5209
DB		 10378 case STT_RELC: return "RELC";
10379 case STT_SRELC: return "SRELC";
252b5132
RH		 10380 default:
10381 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af 10382 {
3510a7b8
NC		 10383 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10384 return "THUMB_FUNC";
103f02d3 10385
351b4b40 10386 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 10387 return "REGISTER";
10388
10389 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10390 return "PARISC_MILLI";
10391
e9e44622 10392 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 10393 }
252b5132 10394 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 10395 {
10396 if (elf_header.e_machine == EM_PARISC)
10397 {
10398 if (type == STT_HP_OPAQUE)
10399 return "HP_OPAQUE";
10400 if (type == STT_HP_STUB)
10401 return "HP_STUB";
10402 }
10403
d8045f23 10404 if (type == STT_GNU_IFUNC
9c55345c 10405 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 10406 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 10407 /* GNU is still using the default value 0. */
d8045f23
NC		 10408 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10409 return "IFUNC";
10410
e9e44622 10411 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 10412 }
252b5132 10413 else
e9e44622 10414 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 10415 return buff;
10416 }
10417}
10418
d1133906 10419static const char *
d3ba0551 10420get_symbol_visibility (unsigned int visibility)
d1133906
NC		 10421{
10422 switch (visibility)
10423 {
b34976b6
AM		 10424 case STV_DEFAULT: return "DEFAULT";
10425 case STV_INTERNAL: return "INTERNAL";
10426 case STV_HIDDEN: return "HIDDEN";
d1133906 10427 case STV_PROTECTED: return "PROTECTED";
bee0ee85
NC		 10428 default:
10429 error (_("Unrecognized visibility value: %u"), visibility);
10430 return _("<unknown>");
d1133906
NC		 10431 }
10432}
10433
fd85a6a1
NC		 10434static const char *
10435get_solaris_symbol_visibility (unsigned int visibility)
10436{
10437 switch (visibility)
10438 {
10439 case 4: return "EXPORTED";
10440 case 5: return "SINGLETON";
10441 case 6: return "ELIMINATE";
10442 default: return get_symbol_visibility (visibility);
10443 }
10444}
10445
5e2b0d47
NC		 10446static const char *
10447get_mips_symbol_other (unsigned int other)
10448{
10449 switch (other)
10450 {
df58fc94
RS		 10451 case STO_OPTIONAL:
10452 return "OPTIONAL";
10453 case STO_MIPS_PLT:
10454 return "MIPS PLT";
10455 case STO_MIPS_PIC:
10456 return "MIPS PIC";
10457 case STO_MICROMIPS:
10458 return "MICROMIPS";
10459 case STO_MICROMIPS | STO_MIPS_PIC:
10460 return "MICROMIPS, MIPS PIC";
10461 case STO_MIPS16:
10462 return "MIPS16";
10463 default:
10464 return NULL;
5e2b0d47
NC		 10465 }
10466}
10467
28f997cf
TG		 10468static const char *
10469get_ia64_symbol_other (unsigned int other)
10470{
10471 if (is_ia64_vms ())
10472 {
10473 static char res[32];
10474
10475 res[0] = 0;
10476
10477 /* Function types is for images and .STB files only. */
10478 switch (elf_header.e_type)
10479 {
10480 case ET_DYN:
10481 case ET_EXEC:
10482 switch (VMS_ST_FUNC_TYPE (other))
10483 {
10484 case VMS_SFT_CODE_ADDR:
10485 strcat (res, " CA");
10486 break;
10487 case VMS_SFT_SYMV_IDX:
10488 strcat (res, " VEC");
10489 break;
10490 case VMS_SFT_FD:
10491 strcat (res, " FD");
10492 break;
10493 case VMS_SFT_RESERVE:
10494 strcat (res, " RSV");
10495 break;
10496 default:
bee0ee85
NC		 10497 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10498 VMS_ST_FUNC_TYPE (other));
10499 strcat (res, " <unknown>");
10500 break;
28f997cf
TG		 10501 }
10502 break;
10503 default:
10504 break;
10505 }
10506 switch (VMS_ST_LINKAGE (other))
10507 {
10508 case VMS_STL_IGNORE:
10509 strcat (res, " IGN");
10510 break;
10511 case VMS_STL_RESERVE:
10512 strcat (res, " RSV");
10513 break;
10514 case VMS_STL_STD:
10515 strcat (res, " STD");
10516 break;
10517 case VMS_STL_LNK:
10518 strcat (res, " LNK");
10519 break;
10520 default:
bee0ee85
NC		 10521 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10522 VMS_ST_LINKAGE (other));
10523 strcat (res, " <unknown>");
10524 break;
28f997cf
TG		 10525 }
10526
10527 if (res[0] != 0)
10528 return res + 1;
10529 else
10530 return res;
10531 }
10532 return NULL;
10533}
10534
6911b7dc
AM		 10535static const char *
10536get_ppc64_symbol_other (unsigned int other)
10537{
10538 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10539 {
10540 static char buf[32];
10541 snprintf (buf, sizeof buf, _("<localentry>: %d"),
10542 PPC64_LOCAL_ENTRY_OFFSET (other));
10543 return buf;
10544 }
10545 return NULL;
10546}
10547
5e2b0d47
NC		 10548static const char *
10549get_symbol_other (unsigned int other)
10550{
10551 const char * result = NULL;
10552 static char buff [32];
10553
10554 if (other == 0)
10555 return "";
10556
10557 switch (elf_header.e_machine)
10558 {
10559 case EM_MIPS:
10560 result = get_mips_symbol_other (other);
28f997cf
TG		 10561 break;
10562 case EM_IA_64:
10563 result = get_ia64_symbol_other (other);
10564 break;
6911b7dc
AM		 10565 case EM_PPC64:
10566 result = get_ppc64_symbol_other (other);
10567 break;
5e2b0d47 10568 default:
fd85a6a1 10569 result = NULL;
5e2b0d47
NC		 10570 break;
10571 }
10572
10573 if (result)
10574 return result;
10575
10576 snprintf (buff, sizeof buff, _("<other>: %x"), other);
10577 return buff;
10578}
10579
d1133906 10580static const char *
d3ba0551 10581get_symbol_index_type (unsigned int type)
252b5132 10582{
b34976b6 10583 static char buff[32];
5cf1065c 10584
252b5132
RH		 10585 switch (type)
10586 {
b34976b6
AM		 10587 case SHN_UNDEF: return "UND";
10588 case SHN_ABS: return "ABS";
10589 case SHN_COMMON: return "COM";
252b5132 10590 default:
9ce701e2
L		 10591 if (type == SHN_IA_64_ANSI_COMMON
10592 && elf_header.e_machine == EM_IA_64
10593 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10594 return "ANSI_COM";
8a9036a4 10595 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 10596 || elf_header.e_machine == EM_L1OM
10597 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 10598 && type == SHN_X86_64_LCOMMON)
10599 return "LARGE_COM";
ac145307
BS		 10600 else if ((type == SHN_MIPS_SCOMMON
10601 && elf_header.e_machine == EM_MIPS)
10602 || (type == SHN_TIC6X_SCOMMON
10603 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 10604 return "SCOM";
10605 else if (type == SHN_MIPS_SUNDEFINED
10606 && elf_header.e_machine == EM_MIPS)
10607 return "SUND";
9ce701e2 10608 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 10609 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 10610 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 10611 sprintf (buff, "OS [0x%04x]", type & 0xffff);
10612 else if (type >= SHN_LORESERVE)
10613 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4 10614 else if (type >= elf_header.e_shnum)
e0a31db1 10615 sprintf (buff, _("bad section index[%3d]"), type);
252b5132 10616 else
232e7cb8 10617 sprintf (buff, "%3d", type);
5cf1065c 10618 break;
252b5132 10619 }
5cf1065c
NC		 10620
10621 return buff;
252b5132
RH		 10622}
10623
66543521 10624static bfd_vma *
57028622 10625get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
252b5132 10626{
2cf0635d
NC		 10627 unsigned char * e_data;
10628 bfd_vma * i_data;
252b5132 10629
57028622
NC		 10630 /* If the size_t type is smaller than the bfd_size_type, eg because
10631 you are building a 32-bit tool on a 64-bit host, then make sure
10632 that when (number) is cast to (size_t) no information is lost. */
10633 if (sizeof (size_t) < sizeof (bfd_size_type)
10634 && (bfd_size_type) ((size_t) number) != number)
10635 {
ed754a13
AM		 10636 error (_("Size truncation prevents reading %" BFD_VMA_FMT "u"
10637 " elements of size %u\n"),
10638 number, ent_size);
57028622
NC		 10639 return NULL;
10640 }
948f632f 10641
3102e897
NC		 10642 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10643 attempting to allocate memory when the read is bound to fail. */
10644 if (ent_size * number > current_file_size)
10645 {
ed754a13
AM		 10646 error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT "u\n"),
10647 number);
3102e897
NC		 10648 return NULL;
10649 }
10650
57028622 10651 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
252b5132
RH		 10652 if (e_data == NULL)
10653 {
ed754a13
AM		 10654 error (_("Out of memory reading %" BFD_VMA_FMT "u dynamic entries\n"),
10655 number);
252b5132
RH		 10656 return NULL;
10657 }
10658
57028622 10659 if (fread (e_data, ent_size, (size_t) number, file) != number)
252b5132 10660 {
ed754a13
AM		 10661 error (_("Unable to read in %" BFD_VMA_FMT "u bytes of dynamic data\n"),
10662 number * ent_size);
3102e897 10663 free (e_data);
252b5132
RH		 10664 return NULL;
10665 }
10666
57028622 10667 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
252b5132
RH		 10668 if (i_data == NULL)
10669 {
ed754a13
AM		 10670 error (_("Out of memory allocating space for %" BFD_VMA_FMT "u"
10671 " dynamic entries\n"),
10672 number);
252b5132
RH		 10673 free (e_data);
10674 return NULL;
10675 }
10676
10677 while (number--)
66543521 10678 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 10679
10680 free (e_data);
10681
10682 return i_data;
10683}
10684
6bd1a22c
L		 10685static void
10686print_dynamic_symbol (bfd_vma si, unsigned long hn)
10687{
2cf0635d 10688 Elf_Internal_Sym * psym;
6bd1a22c
L		 10689 int n;
10690
6bd1a22c
L		 10691 n = print_vma (si, DEC_5);
10692 if (n < 5)
0b4362b0 10693 fputs (&" "[n], stdout);
6bd1a22c 10694 printf (" %3lu: ", hn);
e0a31db1
NC		 10695
10696 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10697 {
3102e897
NC		 10698 printf (_("<No info available for dynamic symbol number %lu>\n"),
10699 (unsigned long) si);
e0a31db1
NC		 10700 return;
10701 }
10702
10703 psym = dynamic_symbols + si;
6bd1a22c
L		 10704 print_vma (psym->st_value, LONG_HEX);
10705 putchar (' ');
10706 print_vma (psym->st_size, DEC_5);
10707
f4be36b3
AM		 10708 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10709 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
fd85a6a1
NC		 10710
10711 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
10712 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
10713 else
10714 {
10715 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
10716
10717 printf (" %-7s", get_symbol_visibility (vis));
10718 /* Check to see if any other bits in the st_other field are set.
10719 Note - displaying this information disrupts the layout of the
10720 table being generated, but for the moment this case is very
10721 rare. */
10722 if (psym->st_other ^ vis)
10723 printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
10724 }
10725
6bd1a22c
L		 10726 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10727 if (VALID_DYNAMIC_NAME (psym->st_name))
10728 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10729 else
2b692964 10730 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 10731 putchar ('\n');
10732}
10733
bb4d2ac2
L		 10734static const char *
10735get_symbol_version_string (FILE *file, int is_dynsym,
10736 const char *strtab,
10737 unsigned long int strtab_size,
10738 unsigned int si, Elf_Internal_Sym *psym,
10739 enum versioned_symbol_info *sym_info,
10740 unsigned short *vna_other)
10741{
ab273396
AM		 10742 unsigned char data[2];
10743 unsigned short vers_data;
10744 unsigned long offset;
bb4d2ac2 10745
ab273396
AM		 10746 if (!is_dynsym
10747 || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
10748 return NULL;
bb4d2ac2 10749
ab273396
AM		 10750 offset = offset_from_vma (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10751 sizeof data + si * sizeof (vers_data));
bb4d2ac2 10752
ab273396
AM		 10753 if (get_data (&data, file, offset + si * sizeof (vers_data),
10754 sizeof (data), 1, _("version data")) == NULL)
10755 return NULL;
10756
10757 vers_data = byte_get (data, 2);
bb4d2ac2 10758
ab273396
AM		 10759 if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
10760 return NULL;
bb4d2ac2 10761
ab273396
AM		 10762 /* Usually we'd only see verdef for defined symbols, and verneed for
10763 undefined symbols. However, symbols defined by the linker in
10764 .dynbss for variables copied from a shared library in order to
10765 avoid text relocations are defined yet have verneed. We could
10766 use a heuristic to detect the special case, for example, check
10767 for verneed first on symbols defined in SHT_NOBITS sections, but
10768 it is simpler and more reliable to just look for both verdef and
10769 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
bb4d2ac2 10770
ab273396
AM		 10771 if (psym->st_shndx != SHN_UNDEF
10772 && vers_data != 0x8001
10773 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10774 {
10775 Elf_Internal_Verdef ivd;
10776 Elf_Internal_Verdaux ivda;
10777 Elf_External_Verdaux evda;
10778 unsigned long off;
bb4d2ac2 10779
ab273396
AM		 10780 off = offset_from_vma (file,
10781 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10782 sizeof (Elf_External_Verdef));
10783
10784 do
bb4d2ac2 10785 {
ab273396
AM		 10786 Elf_External_Verdef evd;
10787
10788 if (get_data (&evd, file, off, sizeof (evd), 1,
10789 _("version def")) == NULL)
10790 {
10791 ivd.vd_ndx = 0;
10792 ivd.vd_aux = 0;
10793 ivd.vd_next = 0;
10794 }
10795 else
bb4d2ac2 10796 {
ab273396
AM		 10797 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10798 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10799 ivd.vd_next = BYTE_GET (evd.vd_next);
10800 }
bb4d2ac2 10801
ab273396
AM		 10802 off += ivd.vd_next;
10803 }
10804 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
bb4d2ac2 10805
ab273396
AM		 10806 if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
10807 {
10808 off -= ivd.vd_next;
10809 off += ivd.vd_aux;
bb4d2ac2 10810
ab273396
AM		 10811 if (get_data (&evda, file, off, sizeof (evda), 1,
10812 _("version def aux")) != NULL)
10813 {
10814 ivda.vda_name = BYTE_GET (evda.vda_name);
bb4d2ac2 10815
ab273396
AM		 10816 if (psym->st_name != ivda.vda_name)
10817 {
10818 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10819 ? symbol_hidden : symbol_public);
10820 return (ivda.vda_name < strtab_size
10821 ? strtab + ivda.vda_name : _("<corrupt>"));
10822 }
10823 }
10824 }
10825 }
bb4d2ac2 10826
ab273396
AM		 10827 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10828 {
10829 Elf_External_Verneed evn;
10830 Elf_Internal_Verneed ivn;
10831 Elf_Internal_Vernaux ivna;
bb4d2ac2 10832
ab273396
AM		 10833 offset = offset_from_vma (file,
10834 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10835 sizeof evn);
10836 do
10837 {
10838 unsigned long vna_off;
bb4d2ac2 10839
ab273396
AM		 10840 if (get_data (&evn, file, offset, sizeof (evn), 1,
10841 _("version need")) == NULL)
10842 {
10843 ivna.vna_next = 0;
10844 ivna.vna_other = 0;
10845 ivna.vna_name = 0;
10846 break;
10847 }
bb4d2ac2 10848
ab273396
AM		 10849 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10850 ivn.vn_next = BYTE_GET (evn.vn_next);
bb4d2ac2 10851
ab273396 10852 vna_off = offset + ivn.vn_aux;
bb4d2ac2 10853
ab273396
AM		 10854 do
10855 {
10856 Elf_External_Vernaux evna;
bb4d2ac2 10857
ab273396
AM		 10858 if (get_data (&evna, file, vna_off, sizeof (evna), 1,
10859 _("version need aux (3)")) == NULL)
bb4d2ac2 10860 {
ab273396
AM		 10861 ivna.vna_next = 0;
10862 ivna.vna_other = 0;
10863 ivna.vna_name = 0;
bb4d2ac2 10864 }
bb4d2ac2 10865 else
bb4d2ac2 10866 {
ab273396
AM		 10867 ivna.vna_other = BYTE_GET (evna.vna_other);
10868 ivna.vna_next = BYTE_GET (evna.vna_next);
10869 ivna.vna_name = BYTE_GET (evna.vna_name);
10870 }
bb4d2ac2 10871
ab273396
AM		 10872 vna_off += ivna.vna_next;
10873 }
10874 while (ivna.vna_other != vers_data && ivna.vna_next != 0);
bb4d2ac2 10875
ab273396
AM		 10876 if (ivna.vna_other == vers_data)
10877 break;
bb4d2ac2 10878
ab273396
AM		 10879 offset += ivn.vn_next;
10880 }
10881 while (ivn.vn_next != 0);
bb4d2ac2 10882
ab273396
AM		 10883 if (ivna.vna_other == vers_data)
10884 {
10885 *sym_info = symbol_undefined;
10886 *vna_other = ivna.vna_other;
10887 return (ivna.vna_name < strtab_size
10888 ? strtab + ivna.vna_name : _("<corrupt>"));
bb4d2ac2
L		 10889 }
10890 }
ab273396 10891 return NULL;
bb4d2ac2
L		 10892}
10893
e3c8793a 10894/* Dump the symbol table. */
252b5132 10895static int
2cf0635d 10896process_symbol_table (FILE * file)
252b5132 10897{
2cf0635d 10898 Elf_Internal_Shdr * section;
8b73c356
NC		 10899 bfd_size_type nbuckets = 0;
10900 bfd_size_type nchains = 0;
2cf0635d
NC		 10901 bfd_vma * buckets = NULL;
10902 bfd_vma * chains = NULL;
fdc90cb4 10903 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 10904 bfd_vma * gnubuckets = NULL;
10905 bfd_vma * gnuchains = NULL;
6bd1a22c 10906 bfd_vma gnusymidx = 0;
071436c6 10907 bfd_size_type ngnuchains = 0;
252b5132 10908
2c610e4b 10909 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 10910 return 1;
10911
6bd1a22c
L		 10912 if (dynamic_info[DT_HASH]
10913 && (do_histogram
2c610e4b
L		 10914 || (do_using_dynamic
10915 && !do_dyn_syms
10916 && dynamic_strings != NULL)))
252b5132 10917 {
66543521
AM		 10918 unsigned char nb[8];
10919 unsigned char nc[8];
8b73c356 10920 unsigned int hash_ent_size = 4;
66543521
AM		 10921
10922 if ((elf_header.e_machine == EM_ALPHA
10923 || elf_header.e_machine == EM_S390
10924 || elf_header.e_machine == EM_S390_OLD)
10925 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10926 hash_ent_size = 8;
10927
fb52b2f4
NC		 10928 if (fseek (file,
10929 (archive_file_offset
10930 + offset_from_vma (file, dynamic_info[DT_HASH],
10931 sizeof nb + sizeof nc)),
d93f0186 10932 SEEK_SET))
252b5132 10933 {
591a748a 10934 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10935 goto no_hash;
252b5132
RH		 10936 }
10937
66543521 10938 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 10939 {
10940 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10941 goto no_hash;
252b5132
RH		 10942 }
10943
66543521 10944 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 10945 {
10946 error (_("Failed to read in number of chains\n"));
d3a44ec6 10947 goto no_hash;
252b5132
RH		 10948 }
10949
66543521
AM		 10950 nbuckets = byte_get (nb, hash_ent_size);
10951 nchains = byte_get (nc, hash_ent_size);
252b5132 10952
66543521
AM		 10953 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10954 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 10955
d3a44ec6 10956 no_hash:
252b5132 10957 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 10958 {
10959 if (do_using_dynamic)
10960 return 0;
10961 free (buckets);
10962 free (chains);
10963 buckets = NULL;
10964 chains = NULL;
10965 nbuckets = 0;
10966 nchains = 0;
10967 }
252b5132
RH		 10968 }
10969
6bd1a22c
L		 10970 if (dynamic_info_DT_GNU_HASH
10971 && (do_histogram
2c610e4b
L		 10972 || (do_using_dynamic
10973 && !do_dyn_syms
10974 && dynamic_strings != NULL)))
252b5132 10975 {
6bd1a22c
L		 10976 unsigned char nb[16];
10977 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10978 bfd_vma buckets_vma;
10979
10980 if (fseek (file,
10981 (archive_file_offset
10982 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10983 sizeof nb)),
10984 SEEK_SET))
10985 {
10986 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10987 goto no_gnu_hash;
6bd1a22c 10988 }
252b5132 10989
6bd1a22c
L		 10990 if (fread (nb, 16, 1, file) != 1)
10991 {
10992 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10993 goto no_gnu_hash;
6bd1a22c
L		 10994 }
10995
10996 ngnubuckets = byte_get (nb, 4);
10997 gnusymidx = byte_get (nb + 4, 4);
10998 bitmaskwords = byte_get (nb + 8, 4);
10999 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 11000 if (is_32bit_elf)
6bd1a22c 11001 buckets_vma += bitmaskwords * 4;
f7a99963 11002 else
6bd1a22c 11003 buckets_vma += bitmaskwords * 8;
252b5132 11004
6bd1a22c
L		 11005 if (fseek (file,
11006 (archive_file_offset
11007 + offset_from_vma (file, buckets_vma, 4)),
11008 SEEK_SET))
252b5132 11009 {
6bd1a22c 11010 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 11011 goto no_gnu_hash;
6bd1a22c
L		 11012 }
11013
11014 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 11015
6bd1a22c 11016 if (gnubuckets == NULL)
d3a44ec6 11017 goto no_gnu_hash;
6bd1a22c
L		 11018
11019 for (i = 0; i < ngnubuckets; i++)
11020 if (gnubuckets[i] != 0)
11021 {
11022 if (gnubuckets[i] < gnusymidx)
11023 return 0;
11024
11025 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11026 maxchain = gnubuckets[i];
11027 }
11028
11029 if (maxchain == 0xffffffff)
d3a44ec6 11030 goto no_gnu_hash;
6bd1a22c
L		 11031
11032 maxchain -= gnusymidx;
11033
11034 if (fseek (file,
11035 (archive_file_offset
11036 + offset_from_vma (file, buckets_vma
11037 + 4 * (ngnubuckets + maxchain), 4)),
11038 SEEK_SET))
11039 {
11040 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 11041 goto no_gnu_hash;
6bd1a22c
L		 11042 }
11043
11044 do
11045 {
11046 if (fread (nb, 4, 1, file) != 1)
252b5132 11047 {
6bd1a22c 11048 error (_("Failed to determine last chain length\n"));
d3a44ec6 11049 goto no_gnu_hash;
6bd1a22c 11050 }
252b5132 11051
6bd1a22c 11052 if (maxchain + 1 == 0)
d3a44ec6 11053 goto no_gnu_hash;
252b5132 11054
6bd1a22c
L		 11055 ++maxchain;
11056 }
11057 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 11058
6bd1a22c
L		 11059 if (fseek (file,
11060 (archive_file_offset
11061 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
11062 SEEK_SET))
11063 {
11064 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 11065 goto no_gnu_hash;
6bd1a22c
L		 11066 }
11067
11068 gnuchains = get_dynamic_data (file, maxchain, 4);
071436c6 11069 ngnuchains = maxchain;
6bd1a22c 11070
d3a44ec6 11071 no_gnu_hash:
6bd1a22c 11072 if (gnuchains == NULL)
d3a44ec6
JJ		 11073 {
11074 free (gnubuckets);
d3a44ec6
JJ		 11075 gnubuckets = NULL;
11076 ngnubuckets = 0;
f64fddf1
NC		 11077 if (do_using_dynamic)
11078 return 0;
d3a44ec6 11079 }
6bd1a22c
L		 11080 }
11081
11082 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11083 && do_syms
11084 && do_using_dynamic
3102e897
NC		 11085 && dynamic_strings != NULL
11086 && dynamic_symbols != NULL)
6bd1a22c
L		 11087 {
11088 unsigned long hn;
11089
11090 if (dynamic_info[DT_HASH])
11091 {
11092 bfd_vma si;
11093
11094 printf (_("\nSymbol table for image:\n"));
11095 if (is_32bit_elf)
11096 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11097 else
11098 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11099
11100 for (hn = 0; hn < nbuckets; hn++)
11101 {
11102 if (! buckets[hn])
11103 continue;
11104
11105 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
11106 print_dynamic_symbol (si, hn);
252b5132
RH		 11107 }
11108 }
6bd1a22c
L		 11109
11110 if (dynamic_info_DT_GNU_HASH)
11111 {
11112 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11113 if (is_32bit_elf)
11114 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11115 else
11116 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11117
11118 for (hn = 0; hn < ngnubuckets; ++hn)
11119 if (gnubuckets[hn] != 0)
11120 {
11121 bfd_vma si = gnubuckets[hn];
11122 bfd_vma off = si - gnusymidx;
11123
11124 do
11125 {
11126 print_dynamic_symbol (si, hn);
11127 si++;
11128 }
071436c6 11129 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
6bd1a22c
L		 11130 }
11131 }
252b5132 11132 }
8b73c356
NC		 11133 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11134 && section_headers != NULL)
252b5132 11135 {
b34976b6 11136 unsigned int i;
252b5132
RH		 11137
11138 for (i = 0, section = section_headers;
11139 i < elf_header.e_shnum;
11140 i++, section++)
11141 {
b34976b6 11142 unsigned int si;
2cf0635d 11143 char * strtab = NULL;
c256ffe7 11144 unsigned long int strtab_size = 0;
2cf0635d
NC		 11145 Elf_Internal_Sym * symtab;
11146 Elf_Internal_Sym * psym;
ba5cdace 11147 unsigned long num_syms;
252b5132 11148
2c610e4b
L		 11149 if ((section->sh_type != SHT_SYMTAB
11150 && section->sh_type != SHT_DYNSYM)
11151 || (!do_syms
11152 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 11153 continue;
11154
dd24e3da
NC		 11155 if (section->sh_entsize == 0)
11156 {
11157 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
74e1a04b 11158 printable_section_name (section));
dd24e3da
NC		 11159 continue;
11160 }
11161
252b5132 11162 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
74e1a04b 11163 printable_section_name (section),
252b5132 11164 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 11165
f7a99963 11166 if (is_32bit_elf)
ca47b30c 11167 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 11168 else
ca47b30c 11169 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 11170
ba5cdace 11171 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 11172 if (symtab == NULL)
11173 continue;
11174
11175 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 11176 {
11177 strtab = string_table;
11178 strtab_size = string_table_length;
11179 }
4fbb74a6 11180 else if (section->sh_link < elf_header.e_shnum)
252b5132 11181 {
2cf0635d 11182 Elf_Internal_Shdr * string_sec;
252b5132 11183
4fbb74a6 11184 string_sec = section_headers + section->sh_link;
252b5132 11185
3f5e193b
NC		 11186 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
11187 1, string_sec->sh_size,
11188 _("string table"));
c256ffe7 11189 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 11190 }
11191
ba5cdace 11192 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 11193 {
bb4d2ac2
L		 11194 const char *version_string;
11195 enum versioned_symbol_info sym_info;
11196 unsigned short vna_other;
11197
5e220199 11198 printf ("%6d: ", si);
f7a99963
NC		 11199 print_vma (psym->st_value, LONG_HEX);
11200 putchar (' ');
11201 print_vma (psym->st_size, DEC_5);
d1133906
NC		 11202 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
11203 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
fd85a6a1
NC		 11204 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11205 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
11206 else
11207 {
11208 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11209
11210 printf (" %-7s", get_symbol_visibility (vis));
11211 /* Check to see if any other bits in the st_other field are set.
11212 Note - displaying this information disrupts the layout of the
11213 table being generated, but for the moment this case is very rare. */
11214 if (psym->st_other ^ vis)
11215 printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
11216 }
31104126 11217 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 11218 print_symbol (25, psym->st_name < strtab_size
2b692964 11219 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 11220
bb4d2ac2
L		 11221 version_string
11222 = get_symbol_version_string (file,
11223 section->sh_type == SHT_DYNSYM,
11224 strtab, strtab_size, si,
11225 psym, &sym_info, &vna_other);
11226 if (version_string)
252b5132 11227 {
bb4d2ac2
L		 11228 if (sym_info == symbol_undefined)
11229 printf ("@%s (%d)", version_string, vna_other);
11230 else
11231 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11232 version_string);
252b5132
RH		 11233 }
11234
11235 putchar ('\n');
52c3c391
NC		 11236
11237 if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
dd905818
NC		 11238 && si >= section->sh_info
11239 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11240 && elf_header.e_machine != EM_MIPS
11241 /* Solaris binaries have been found to violate this requirement as
11242 well. Not sure if this is a bug or an ABI requirement. */
11243 && elf_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
52c3c391
NC		 11244 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11245 si, printable_section_name (section), section->sh_info);
252b5132
RH		 11246 }
11247
11248 free (symtab);
11249 if (strtab != string_table)
11250 free (strtab);
11251 }
11252 }
11253 else if (do_syms)
11254 printf
11255 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11256
11257 if (do_histogram && buckets != NULL)
11258 {
2cf0635d
NC		 11259 unsigned long * lengths;
11260 unsigned long * counts;
66543521
AM		 11261 unsigned long hn;
11262 bfd_vma si;
11263 unsigned long maxlength = 0;
11264 unsigned long nzero_counts = 0;
11265 unsigned long nsyms = 0;
94d15024 11266 unsigned long chained;
252b5132 11267
66543521
AM		 11268 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11269 (unsigned long) nbuckets);
252b5132 11270
3f5e193b 11271 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 11272 if (lengths == NULL)
11273 {
8b73c356 11274 error (_("Out of memory allocating space for histogram buckets\n"));
252b5132
RH		 11275 return 0;
11276 }
8b73c356
NC		 11277
11278 printf (_(" Length Number %% of total Coverage\n"));
252b5132
RH		 11279 for (hn = 0; hn < nbuckets; ++hn)
11280 {
94d15024
MF		 11281 for (si = buckets[hn], chained = 0;
11282 si > 0 && si < nchains && si < nbuckets && chained <= nchains;
11283 si = chains[si], ++chained)
252b5132 11284 {
b34976b6 11285 ++nsyms;
252b5132 11286 if (maxlength < ++lengths[hn])
b34976b6 11287 ++maxlength;
252b5132 11288 }
94d15024
MF		 11289
11290 /* PR binutils/17531: A corrupt binary could contain broken
11291 histogram data. Do not go into an infinite loop trying
11292 to process it. */
11293 if (chained > nchains)
11294 {
11295 error (_("histogram chain is corrupt\n"));
11296 break;
11297 }
252b5132
RH		 11298 }
11299
3f5e193b 11300 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 11301 if (counts == NULL)
11302 {
b2e951ec 11303 free (lengths);
8b73c356 11304 error (_("Out of memory allocating space for histogram counts\n"));
252b5132
RH		 11305 return 0;
11306 }
11307
11308 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 11309 ++counts[lengths[hn]];
252b5132 11310
103f02d3 11311 if (nbuckets > 0)
252b5132 11312 {
66543521
AM		 11313 unsigned long i;
11314 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 11315 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 11316 for (i = 1; i <= maxlength; ++i)
103f02d3 11317 {
66543521
AM		 11318 nzero_counts += counts[i] * i;
11319 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11320 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 11321 (nzero_counts * 100.0) / nsyms);
11322 }
252b5132
RH		 11323 }
11324
11325 free (counts);
11326 free (lengths);
11327 }
11328
11329 if (buckets != NULL)
11330 {
11331 free (buckets);
11332 free (chains);
11333 }
11334
d3a44ec6 11335 if (do_histogram && gnubuckets != NULL)
fdc90cb4 11336 {
2cf0635d
NC		 11337 unsigned long * lengths;
11338 unsigned long * counts;
fdc90cb4
JJ		 11339 unsigned long hn;
11340 unsigned long maxlength = 0;
11341 unsigned long nzero_counts = 0;
11342 unsigned long nsyms = 0;
fdc90cb4 11343
8b73c356
NC		 11344 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11345 (unsigned long) ngnubuckets);
11346
3f5e193b 11347 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 11348 if (lengths == NULL)
11349 {
8b73c356 11350 error (_("Out of memory allocating space for gnu histogram buckets\n"));
fdc90cb4
JJ		 11351 return 0;
11352 }
11353
fdc90cb4
JJ		 11354 printf (_(" Length Number %% of total Coverage\n"));
11355
11356 for (hn = 0; hn < ngnubuckets; ++hn)
11357 if (gnubuckets[hn] != 0)
11358 {
11359 bfd_vma off, length = 1;
11360
6bd1a22c 11361 for (off = gnubuckets[hn] - gnusymidx;
071436c6
NC		 11362 /* PR 17531 file: 010-77222-0.004. */
11363 off < ngnuchains && (gnuchains[off] & 1) == 0;
11364 ++off)
fdc90cb4
JJ		 11365 ++length;
11366 lengths[hn] = length;
11367 if (length > maxlength)
11368 maxlength = length;
11369 nsyms += length;
11370 }
11371
3f5e193b 11372 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 11373 if (counts == NULL)
11374 {
b2e951ec 11375 free (lengths);
8b73c356 11376 error (_("Out of memory allocating space for gnu histogram counts\n"));
fdc90cb4
JJ		 11377 return 0;
11378 }
11379
11380 for (hn = 0; hn < ngnubuckets; ++hn)
11381 ++counts[lengths[hn]];
11382
11383 if (ngnubuckets > 0)
11384 {
11385 unsigned long j;
11386 printf (" 0 %-10lu (%5.1f%%)\n",
11387 counts[0], (counts[0] * 100.0) / ngnubuckets);
11388 for (j = 1; j <= maxlength; ++j)
11389 {
11390 nzero_counts += counts[j] * j;
11391 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11392 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11393 (nzero_counts * 100.0) / nsyms);
11394 }
11395 }
11396
11397 free (counts);
11398 free (lengths);
11399 free (gnubuckets);
11400 free (gnuchains);
11401 }
11402
252b5132
RH		 11403 return 1;
11404}
11405
11406static int
2cf0635d 11407process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 11408{
b4c96d0d 11409 unsigned int i;
252b5132
RH		 11410
11411 if (dynamic_syminfo == NULL
11412 || !do_dynamic)
11413 /* No syminfo, this is ok. */
11414 return 1;
11415
11416 /* There better should be a dynamic symbol section. */
11417 if (dynamic_symbols == NULL || dynamic_strings == NULL)
11418 return 0;
11419
11420 if (dynamic_addr)
11421 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11422 dynamic_syminfo_offset, dynamic_syminfo_nent);
11423
11424 printf (_(" Num: Name BoundTo Flags\n"));
11425 for (i = 0; i < dynamic_syminfo_nent; ++i)
11426 {
11427 unsigned short int flags = dynamic_syminfo[i].si_flags;
11428
31104126 11429 printf ("%4d: ", i);
4082ef84
NC		 11430 if (i >= num_dynamic_syms)
11431 printf (_("<corrupt index>"));
11432 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
d79b3d50
NC		 11433 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11434 else
2b692964 11435 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 11436 putchar (' ');
252b5132
RH		 11437
11438 switch (dynamic_syminfo[i].si_boundto)
11439 {
11440 case SYMINFO_BT_SELF:
11441 fputs ("SELF ", stdout);
11442 break;
11443 case SYMINFO_BT_PARENT:
11444 fputs ("PARENT ", stdout);
11445 break;
11446 default:
11447 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 11448 && dynamic_syminfo[i].si_boundto < dynamic_nent
11449 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 11450 {
d79b3d50 11451 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 11452 putchar (' ' );
11453 }
252b5132
RH		 11454 else
11455 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11456 break;
11457 }
11458
11459 if (flags & SYMINFO_FLG_DIRECT)
11460 printf (" DIRECT");
11461 if (flags & SYMINFO_FLG_PASSTHRU)
11462 printf (" PASSTHRU");
11463 if (flags & SYMINFO_FLG_COPY)
11464 printf (" COPY");
11465 if (flags & SYMINFO_FLG_LAZYLOAD)
11466 printf (" LAZYLOAD");
11467
11468 puts ("");
11469 }
11470
11471 return 1;
11472}
11473
cf13d699
NC		 11474/* Check to see if the given reloc needs to be handled in a target specific
11475 manner. If so then process the reloc and return TRUE otherwise return
11476 FALSE. */
09c11c86 11477
cf13d699
NC		 11478static bfd_boolean
11479target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11480 unsigned char * start,
11481 Elf_Internal_Sym * symtab)
252b5132 11482{
cf13d699 11483 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 11484
cf13d699 11485 switch (elf_header.e_machine)
252b5132 11486 {
13761a11
NC		 11487 case EM_MSP430:
11488 case EM_MSP430_OLD:
11489 {
11490 static Elf_Internal_Sym * saved_sym = NULL;
11491
11492 switch (reloc_type)
11493 {
11494 case 10: /* R_MSP430_SYM_DIFF */
11495 if (uses_msp430x_relocs ())
11496 break;
11497 case 21: /* R_MSP430X_SYM_DIFF */
11498 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11499 return TRUE;
11500
11501 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11502 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11503 goto handle_sym_diff;
0b4362b0 11504
13761a11
NC		 11505 case 5: /* R_MSP430_16_BYTE */
11506 case 9: /* R_MSP430_8 */
11507 if (uses_msp430x_relocs ())
11508 break;
11509 goto handle_sym_diff;
11510
11511 case 2: /* R_MSP430_ABS16 */
11512 case 15: /* R_MSP430X_ABS16 */
11513 if (! uses_msp430x_relocs ())
11514 break;
11515 goto handle_sym_diff;
0b4362b0 11516
13761a11
NC		 11517 handle_sym_diff:
11518 if (saved_sym != NULL)
11519 {
11520 bfd_vma value;
11521
11522 value = reloc->r_addend
11523 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11524 - saved_sym->st_value);
11525
11526 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11527
11528 saved_sym = NULL;
11529 return TRUE;
11530 }
11531 break;
11532
11533 default:
11534 if (saved_sym != NULL)
071436c6 11535 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13761a11
NC		 11536 break;
11537 }
11538 break;
11539 }
11540
cf13d699
NC		 11541 case EM_MN10300:
11542 case EM_CYGNUS_MN10300:
11543 {
11544 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 11545
cf13d699
NC		 11546 switch (reloc_type)
11547 {
11548 case 34: /* R_MN10300_ALIGN */
11549 return TRUE;
11550 case 33: /* R_MN10300_SYM_DIFF */
11551 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11552 return TRUE;
11553 case 1: /* R_MN10300_32 */
11554 case 2: /* R_MN10300_16 */
11555 if (saved_sym != NULL)
11556 {
11557 bfd_vma value;
252b5132 11558
cf13d699
NC		 11559 value = reloc->r_addend
11560 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11561 - saved_sym->st_value);
252b5132 11562
cf13d699 11563 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 11564
cf13d699
NC		 11565 saved_sym = NULL;
11566 return TRUE;
11567 }
11568 break;
11569 default:
11570 if (saved_sym != NULL)
071436c6 11571 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
cf13d699
NC		 11572 break;
11573 }
11574 break;
11575 }
6ff71e76
NC		 11576
11577 case EM_RL78:
11578 {
11579 static bfd_vma saved_sym1 = 0;
11580 static bfd_vma saved_sym2 = 0;
11581 static bfd_vma value;
11582
11583 switch (reloc_type)
11584 {
11585 case 0x80: /* R_RL78_SYM. */
11586 saved_sym1 = saved_sym2;
11587 saved_sym2 = symtab[get_reloc_symindex (reloc->r_info)].st_value;
11588 saved_sym2 += reloc->r_addend;
11589 return TRUE;
11590
11591 case 0x83: /* R_RL78_OPsub. */
11592 value = saved_sym1 - saved_sym2;
11593 saved_sym2 = saved_sym1 = 0;
11594 return TRUE;
11595 break;
11596
11597 case 0x41: /* R_RL78_ABS32. */
11598 byte_put (start + reloc->r_offset, value, 4);
11599 value = 0;
11600 return TRUE;
11601
11602 case 0x43: /* R_RL78_ABS16. */
11603 byte_put (start + reloc->r_offset, value, 2);
11604 value = 0;
11605 return TRUE;
11606
11607 default:
11608 break;
11609 }
11610 break;
11611 }
252b5132
RH		 11612 }
11613
cf13d699 11614 return FALSE;
252b5132
RH		 11615}
11616
aca88567
NC		 11617/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11618 DWARF debug sections. This is a target specific test. Note - we do not
11619 go through the whole including-target-headers-multiple-times route, (as
11620 we have already done with <elf/h8.h>) because this would become very
11621 messy and even then this function would have to contain target specific
11622 information (the names of the relocs instead of their numeric values).
11623 FIXME: This is not the correct way to solve this problem. The proper way
11624 is to have target specific reloc sizing and typing functions created by
11625 the reloc-macros.h header, in the same way that it already creates the
11626 reloc naming functions. */
11627
11628static bfd_boolean
11629is_32bit_abs_reloc (unsigned int reloc_type)
11630{
d347c9df 11631 /* Please keep this table alpha-sorted for ease of visual lookup. */
aca88567
NC		 11632 switch (elf_header.e_machine)
11633 {
41e92641 11634 case EM_386:
22abe556 11635 case EM_IAMCU:
41e92641 11636 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 11637 case EM_68K:
11638 return reloc_type == 1; /* R_68K_32. */
11639 case EM_860:
11640 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 11641 case EM_960:
11642 return reloc_type == 2; /* R_960_32. */
a06ea964
NC		 11643 case EM_AARCH64:
11644 return reloc_type == 258; /* R_AARCH64_ABS32 */
d347c9df
PS		 11645 case EM_ADAPTEVA_EPIPHANY:
11646 return reloc_type == 3;
aca88567 11647 case EM_ALPHA:
137b6b5f 11648 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 11649 case EM_ARC:
11650 return reloc_type == 1; /* R_ARC_32. */
886a2506
NC		 11651 case EM_ARC_COMPACT:
11652 case EM_ARC_COMPACT2:
11653 return reloc_type == 4; /* R_ARC_32. */
41e92641
NC		 11654 case EM_ARM:
11655 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 11656 case EM_AVR_OLD:
aca88567
NC		 11657 case EM_AVR:
11658 return reloc_type == 1;
11659 case EM_BLACKFIN:
11660 return reloc_type == 0x12; /* R_byte4_data. */
11661 case EM_CRIS:
11662 return reloc_type == 3; /* R_CRIS_32. */
11663 case EM_CR16:
11664 return reloc_type == 3; /* R_CR16_NUM32. */
11665 case EM_CRX:
11666 return reloc_type == 15; /* R_CRX_NUM32. */
11667 case EM_CYGNUS_FRV:
11668 return reloc_type == 1;
41e92641
NC		 11669 case EM_CYGNUS_D10V:
11670 case EM_D10V:
11671 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 11672 case EM_CYGNUS_D30V:
11673 case EM_D30V:
11674 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 11675 case EM_DLX:
11676 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 11677 case EM_CYGNUS_FR30:
11678 case EM_FR30:
11679 return reloc_type == 3; /* R_FR30_32. */
3f8107ab
AM		 11680 case EM_FT32:
11681 return reloc_type == 1; /* R_FT32_32. */
aca88567
NC		 11682 case EM_H8S:
11683 case EM_H8_300:
11684 case EM_H8_300H:
11685 return reloc_type == 1; /* R_H8_DIR32. */
3730236a 11686 case EM_IA_64:
d1c4b12b
NC		 11687 return reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
11688 || reloc_type == 0x25; /* R_IA64_DIR32LSB. */
aca88567
NC		 11689 case EM_IP2K_OLD:
11690 case EM_IP2K:
11691 return reloc_type == 2; /* R_IP2K_32. */
11692 case EM_IQ2000:
11693 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 11694 case EM_LATTICEMICO32:
11695 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 11696 case EM_M32C_OLD:
aca88567
NC		 11697 case EM_M32C:
11698 return reloc_type == 3; /* R_M32C_32. */
11699 case EM_M32R:
11700 return reloc_type == 34; /* R_M32R_32_RELA. */
adec12c1
AM		 11701 case EM_68HC11:
11702 case EM_68HC12:
11703 return reloc_type == 6; /* R_M68HC11_32. */
aca88567
NC		 11704 case EM_MCORE:
11705 return reloc_type == 1; /* R_MCORE_ADDR32. */
11706 case EM_CYGNUS_MEP:
11707 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 11708 case EM_METAG:
11709 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 11710 case EM_MICROBLAZE:
11711 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 11712 case EM_MIPS:
11713 return reloc_type == 2; /* R_MIPS_32. */
11714 case EM_MMIX:
11715 return reloc_type == 4; /* R_MMIX_32. */
11716 case EM_CYGNUS_MN10200:
11717 case EM_MN10200:
11718 return reloc_type == 1; /* R_MN10200_32. */
11719 case EM_CYGNUS_MN10300:
11720 case EM_MN10300:
11721 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 11722 case EM_MOXIE:
11723 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 11724 case EM_MSP430_OLD:
11725 case EM_MSP430:
13761a11 11726 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
aca88567
NC		 11727 case EM_MT:
11728 return reloc_type == 2; /* R_MT_32. */
35c08157
KLC		 11729 case EM_NDS32:
11730 return reloc_type == 20; /* R_NDS32_RELA. */
3e0873ac 11731 case EM_ALTERA_NIOS2:
36591ba1 11732 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
3e0873ac
NC		 11733 case EM_NIOS32:
11734 return reloc_type == 1; /* R_NIOS_32. */
73589c9d
CS		 11735 case EM_OR1K:
11736 return reloc_type == 1; /* R_OR1K_32. */
aca88567 11737 case EM_PARISC:
5fda8eca
NC		 11738 return (reloc_type == 1 /* R_PARISC_DIR32. */
11739 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 11740 case EM_PJ:
11741 case EM_PJ_OLD:
11742 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
11743 case EM_PPC64:
11744 return reloc_type == 1; /* R_PPC64_ADDR32. */
11745 case EM_PPC:
11746 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 11747 case EM_RL78:
11748 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 11749 case EM_RX:
11750 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 11751 case EM_S370:
11752 return reloc_type == 1; /* R_I370_ADDR31. */
11753 case EM_S390_OLD:
11754 case EM_S390:
11755 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 11756 case EM_SCORE:
11757 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 11758 case EM_SH:
11759 return reloc_type == 1; /* R_SH_DIR32. */
11760 case EM_SPARC32PLUS:
11761 case EM_SPARCV9:
11762 case EM_SPARC:
11763 return reloc_type == 3 /* R_SPARC_32. */
11764 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 11765 case EM_SPU:
11766 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 11767 case EM_TI_C6000:
11768 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 11769 case EM_TILEGX:
11770 return reloc_type == 2; /* R_TILEGX_32. */
11771 case EM_TILEPRO:
11772 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 11773 case EM_CYGNUS_V850:
11774 case EM_V850:
11775 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 11776 case EM_V800:
11777 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 11778 case EM_VAX:
11779 return reloc_type == 1; /* R_VAX_32. */
619ed720
EB		 11780 case EM_VISIUM:
11781 return reloc_type == 3; /* R_VISIUM_32. */
aca88567 11782 case EM_X86_64:
8a9036a4 11783 case EM_L1OM:
7a9068fe 11784 case EM_K1OM:
aca88567 11785 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 11786 case EM_XC16X:
11787 case EM_C166:
11788 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 11789 case EM_XGATE:
11790 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 11791 case EM_XSTORMY16:
11792 return reloc_type == 1; /* R_XSTROMY16_32. */
11793 case EM_XTENSA_OLD:
11794 case EM_XTENSA:
11795 return reloc_type == 1; /* R_XTENSA_32. */
aca88567 11796 default:
bee0ee85
NC		 11797 {
11798 static unsigned int prev_warn = 0;
11799
11800 /* Avoid repeating the same warning multiple times. */
11801 if (prev_warn != elf_header.e_machine)
11802 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11803 elf_header.e_machine);
11804 prev_warn = elf_header.e_machine;
11805 return FALSE;
11806 }
aca88567
NC		 11807 }
11808}
11809
11810/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11811 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11812
11813static bfd_boolean
11814is_32bit_pcrel_reloc (unsigned int reloc_type)
11815{
11816 switch (elf_header.e_machine)
d347c9df 11817 /* Please keep this table alpha-sorted for ease of visual lookup. */
aca88567 11818 {
41e92641 11819 case EM_386:
22abe556 11820 case EM_IAMCU:
3e0873ac 11821 return reloc_type == 2; /* R_386_PC32. */
aca88567 11822 case EM_68K:
3e0873ac 11823 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 11824 case EM_AARCH64:
11825 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 11826 case EM_ADAPTEVA_EPIPHANY:
11827 return reloc_type == 6;
aca88567
NC		 11828 case EM_ALPHA:
11829 return reloc_type == 10; /* R_ALPHA_SREL32. */
726c18e1
CZ		 11830 case EM_ARC_COMPACT:
11831 case EM_ARC_COMPACT2:
11832 return reloc_type == 49; /* R_ARC_32_PCREL. */
41e92641 11833 case EM_ARM:
3e0873ac 11834 return reloc_type == 3; /* R_ARM_REL32 */
d347c9df
PS		 11835 case EM_AVR_OLD:
11836 case EM_AVR:
11837 return reloc_type == 36; /* R_AVR_32_PCREL. */
137b6b5f
AM		 11838 case EM_MICROBLAZE:
11839 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
73589c9d
CS		 11840 case EM_OR1K:
11841 return reloc_type == 9; /* R_OR1K_32_PCREL. */
aca88567 11842 case EM_PARISC:
85acf597 11843 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 11844 case EM_PPC:
11845 return reloc_type == 26; /* R_PPC_REL32. */
11846 case EM_PPC64:
3e0873ac 11847 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 11848 case EM_S390_OLD:
11849 case EM_S390:
3e0873ac 11850 return reloc_type == 5; /* R_390_PC32. */
aca88567 11851 case EM_SH:
3e0873ac 11852 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 11853 case EM_SPARC32PLUS:
11854 case EM_SPARCV9:
11855 case EM_SPARC:
3e0873ac 11856 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 11857 case EM_SPU:
11858 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 11859 case EM_TILEGX:
11860 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
11861 case EM_TILEPRO:
11862 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
619ed720
EB		 11863 case EM_VISIUM:
11864 return reloc_type == 6; /* R_VISIUM_32_PCREL */
aca88567 11865 case EM_X86_64:
8a9036a4 11866 case EM_L1OM:
7a9068fe 11867 case EM_K1OM:
3e0873ac 11868 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 11869 case EM_XTENSA_OLD:
11870 case EM_XTENSA:
11871 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 11872 default:
11873 /* Do not abort or issue an error message here. Not all targets use
11874 pc-relative 32-bit relocs in their DWARF debug information and we
11875 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 11876 more helpful warning message will be generated by apply_relocations
11877 anyway, so just return. */
aca88567
NC		 11878 return FALSE;
11879 }
11880}
11881
11882/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11883 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11884
11885static bfd_boolean
11886is_64bit_abs_reloc (unsigned int reloc_type)
11887{
11888 switch (elf_header.e_machine)
11889 {
a06ea964
NC		 11890 case EM_AARCH64:
11891 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 11892 case EM_ALPHA:
11893 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 11894 case EM_IA_64:
11895 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 11896 case EM_PARISC:
11897 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 11898 case EM_PPC64:
11899 return reloc_type == 38; /* R_PPC64_ADDR64. */
11900 case EM_SPARC32PLUS:
11901 case EM_SPARCV9:
11902 case EM_SPARC:
11903 return reloc_type == 54; /* R_SPARC_UA64. */
11904 case EM_X86_64:
8a9036a4 11905 case EM_L1OM:
7a9068fe 11906 case EM_K1OM:
aca88567 11907 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 11908 case EM_S390_OLD:
11909 case EM_S390:
aa137e4d
NC		 11910 return reloc_type == 22; /* R_S390_64. */
11911 case EM_TILEGX:
11912 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 11913 case EM_MIPS:
aa137e4d 11914 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 11915 default:
11916 return FALSE;
11917 }
11918}
11919
85acf597
RH		 11920/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11921 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11922
11923static bfd_boolean
11924is_64bit_pcrel_reloc (unsigned int reloc_type)
11925{
11926 switch (elf_header.e_machine)
11927 {
a06ea964
NC		 11928 case EM_AARCH64:
11929 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 11930 case EM_ALPHA:
aa137e4d 11931 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 11932 case EM_IA_64:
aa137e4d 11933 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 11934 case EM_PARISC:
aa137e4d 11935 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 11936 case EM_PPC64:
aa137e4d 11937 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 11938 case EM_SPARC32PLUS:
11939 case EM_SPARCV9:
11940 case EM_SPARC:
aa137e4d 11941 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 11942 case EM_X86_64:
8a9036a4 11943 case EM_L1OM:
7a9068fe 11944 case EM_K1OM:
aa137e4d 11945 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 11946 case EM_S390_OLD:
11947 case EM_S390:
aa137e4d
NC		 11948 return reloc_type == 23; /* R_S390_PC64. */
11949 case EM_TILEGX:
11950 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 11951 default:
11952 return FALSE;
11953 }
11954}
11955
4dc3c23d
AM		 11956/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11957 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11958
11959static bfd_boolean
11960is_24bit_abs_reloc (unsigned int reloc_type)
11961{
11962 switch (elf_header.e_machine)
11963 {
11964 case EM_CYGNUS_MN10200:
11965 case EM_MN10200:
11966 return reloc_type == 4; /* R_MN10200_24. */
3ee6e4fb
NC		 11967 case EM_FT32:
11968 return reloc_type == 5; /* R_FT32_20. */
4dc3c23d
AM		 11969 default:
11970 return FALSE;
11971 }
11972}
11973
aca88567
NC		 11974/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11975 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11976
11977static bfd_boolean
11978is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a 11979{
d347c9df 11980 /* Please keep this table alpha-sorted for ease of visual lookup. */
4b78141a
NC		 11981 switch (elf_header.e_machine)
11982 {
886a2506
NC		 11983 case EM_ARC:
11984 case EM_ARC_COMPACT:
11985 case EM_ARC_COMPACT2:
11986 return reloc_type == 2; /* R_ARC_16. */
d347c9df
PS		 11987 case EM_ADAPTEVA_EPIPHANY:
11988 return reloc_type == 5;
aca88567
NC		 11989 case EM_AVR_OLD:
11990 case EM_AVR:
11991 return reloc_type == 4; /* R_AVR_16. */
41e92641
NC		 11992 case EM_CYGNUS_D10V:
11993 case EM_D10V:
11994 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 11995 case EM_H8S:
11996 case EM_H8_300:
11997 case EM_H8_300H:
aca88567
NC		 11998 return reloc_type == R_H8_DIR16;
11999 case EM_IP2K_OLD:
12000 case EM_IP2K:
12001 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 12002 case EM_M32C_OLD:
f4236fe4
DD		 12003 case EM_M32C:
12004 return reloc_type == 1; /* R_M32C_16 */
d347c9df
PS		 12005 case EM_CYGNUS_MN10200:
12006 case EM_MN10200:
12007 return reloc_type == 2; /* R_MN10200_16. */
12008 case EM_CYGNUS_MN10300:
12009 case EM_MN10300:
12010 return reloc_type == 2; /* R_MN10300_16. */
aca88567 12011 case EM_MSP430:
13761a11
NC		 12012 if (uses_msp430x_relocs ())
12013 return reloc_type == 2; /* R_MSP430_ABS16. */
78c8d46c 12014 case EM_MSP430_OLD:
aca88567 12015 return reloc_type == 5; /* R_MSP430_16_BYTE. */
35c08157
KLC		 12016 case EM_NDS32:
12017 return reloc_type == 19; /* R_NDS32_RELA. */
3e0873ac 12018 case EM_ALTERA_NIOS2:
36591ba1 12019 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
3e0873ac
NC		 12020 case EM_NIOS32:
12021 return reloc_type == 9; /* R_NIOS_16. */
73589c9d
CS		 12022 case EM_OR1K:
12023 return reloc_type == 2; /* R_OR1K_16. */
40b36596
JM		 12024 case EM_TI_C6000:
12025 return reloc_type == 2; /* R_C6000_ABS16. */
d347c9df
PS		 12026 case EM_VISIUM:
12027 return reloc_type == 2; /* R_VISIUM_16. */
c29aca4a
NC		 12028 case EM_XC16X:
12029 case EM_C166:
12030 return reloc_type == 2; /* R_XC16C_ABS_16. */
f6c1a2d5
NC		 12031 case EM_XGATE:
12032 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 12033 default:
aca88567 12034 return FALSE;
4b78141a
NC		 12035 }
12036}
12037
2a7b2e88
JK		 12038/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12039 relocation entries (possibly formerly used for SHT_GROUP sections). */
12040
12041static bfd_boolean
12042is_none_reloc (unsigned int reloc_type)
12043{
12044 switch (elf_header.e_machine)
12045 {
cb8f3167 12046 case EM_386: /* R_386_NONE. */
d347c9df 12047 case EM_68K: /* R_68K_NONE. */
cfb8c092 12048 case EM_ADAPTEVA_EPIPHANY:
d347c9df
PS		 12049 case EM_ALPHA: /* R_ALPHA_NONE. */
12050 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
886a2506 12051 case EM_ARC: /* R_ARC_NONE. */
886a2506 12052 case EM_ARC_COMPACT2: /* R_ARC_NONE. */
d347c9df 12053 case EM_ARC_COMPACT: /* R_ARC_NONE. */
cb8f3167 12054 case EM_ARM: /* R_ARM_NONE. */
d347c9df 12055 case EM_C166: /* R_XC16X_NONE. */
cb8f3167 12056 case EM_CRIS: /* R_CRIS_NONE. */
d347c9df
PS		 12057 case EM_FT32: /* R_FT32_NONE. */
12058 case EM_IA_64: /* R_IA64_NONE. */
7a9068fe 12059 case EM_K1OM: /* R_X86_64_NONE. */
d347c9df
PS		 12060 case EM_L1OM: /* R_X86_64_NONE. */
12061 case EM_M32R: /* R_M32R_NONE. */
12062 case EM_MIPS: /* R_MIPS_NONE. */
cb8f3167 12063 case EM_MN10300: /* R_MN10300_NONE. */
5506d11a 12064 case EM_MOXIE: /* R_MOXIE_NONE. */
d347c9df
PS		 12065 case EM_NIOS32: /* R_NIOS_NONE. */
12066 case EM_OR1K: /* R_OR1K_NONE. */
12067 case EM_PARISC: /* R_PARISC_NONE. */
12068 case EM_PPC64: /* R_PPC64_NONE. */
12069 case EM_PPC: /* R_PPC_NONE. */
12070 case EM_S390: /* R_390_NONE. */
12071 case EM_S390_OLD:
12072 case EM_SH: /* R_SH_NONE. */
12073 case EM_SPARC32PLUS:
12074 case EM_SPARC: /* R_SPARC_NONE. */
12075 case EM_SPARCV9:
aa137e4d
NC		 12076 case EM_TILEGX: /* R_TILEGX_NONE. */
12077 case EM_TILEPRO: /* R_TILEPRO_NONE. */
d347c9df
PS		 12078 case EM_TI_C6000:/* R_C6000_NONE. */
12079 case EM_X86_64: /* R_X86_64_NONE. */
c29aca4a 12080 case EM_XC16X:
cb8f3167 12081 return reloc_type == 0;
d347c9df 12082
a06ea964
NC		 12083 case EM_AARCH64:
12084 return reloc_type == 0 || reloc_type == 256;
d347c9df
PS		 12085 case EM_AVR_OLD:
12086 case EM_AVR:
12087 return (reloc_type == 0 /* R_AVR_NONE. */
12088 || reloc_type == 30 /* R_AVR_DIFF8. */
12089 || reloc_type == 31 /* R_AVR_DIFF16. */
12090 || reloc_type == 32 /* R_AVR_DIFF32. */);
12091 case EM_METAG:
12092 return reloc_type == 3; /* R_METAG_NONE. */
35c08157
KLC		 12093 case EM_NDS32:
12094 return (reloc_type == 0 /* R_XTENSA_NONE. */
12095 || reloc_type == 204 /* R_NDS32_DIFF8. */
12096 || reloc_type == 205 /* R_NDS32_DIFF16. */
12097 || reloc_type == 206 /* R_NDS32_DIFF32. */
12098 || reloc_type == 207 /* R_NDS32_ULEB128. */);
58332dda
JK		 12099 case EM_XTENSA_OLD:
12100 case EM_XTENSA:
4dc3c23d
AM		 12101 return (reloc_type == 0 /* R_XTENSA_NONE. */
12102 || reloc_type == 17 /* R_XTENSA_DIFF8. */
12103 || reloc_type == 18 /* R_XTENSA_DIFF16. */
12104 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
2a7b2e88
JK		 12105 }
12106 return FALSE;
12107}
12108
d1c4b12b
NC		 12109/* Returns TRUE if there is a relocation against
12110 section NAME at OFFSET bytes. */
12111
12112bfd_boolean
12113reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
12114{
12115 Elf_Internal_Rela * relocs;
12116 Elf_Internal_Rela * rp;
12117
12118 if (dsec == NULL || dsec->reloc_info == NULL)
12119 return FALSE;
12120
12121 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
12122
12123 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
12124 if (rp->r_offset == offset)
12125 return TRUE;
12126
12127 return FALSE;
12128}
12129
cf13d699
NC		 12130/* Apply relocations to a section.
12131 Note: So far support has been added only for those relocations
12132 which can be found in debug sections.
d1c4b12b
NC		 12133 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
12134 loaded relocs. It is then the caller's responsibility to free them.
cf13d699 12135 FIXME: Add support for more relocations ? */
1b315056 12136
cf13d699 12137static void
d1c4b12b
NC		 12138apply_relocations (void * file,
12139 const Elf_Internal_Shdr * section,
12140 unsigned char * start,
12141 bfd_size_type size,
12142 void ** relocs_return,
12143 unsigned long * num_relocs_return)
1b315056 12144{
cf13d699 12145 Elf_Internal_Shdr * relsec;
0d2a7a93 12146 unsigned char * end = start + size;
cb8f3167 12147
d1c4b12b
NC		 12148 if (relocs_return != NULL)
12149 {
12150 * (Elf_Internal_Rela **) relocs_return = NULL;
12151 * num_relocs_return = 0;
12152 }
12153
cf13d699
NC		 12154 if (elf_header.e_type != ET_REL)
12155 return;
1b315056 12156
cf13d699 12157 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 12158 for (relsec = section_headers;
12159 relsec < section_headers + elf_header.e_shnum;
12160 ++relsec)
252b5132 12161 {
41e92641
NC		 12162 bfd_boolean is_rela;
12163 unsigned long num_relocs;
2cf0635d
NC		 12164 Elf_Internal_Rela * relocs;
12165 Elf_Internal_Rela * rp;
12166 Elf_Internal_Shdr * symsec;
12167 Elf_Internal_Sym * symtab;
ba5cdace 12168 unsigned long num_syms;
2cf0635d 12169 Elf_Internal_Sym * sym;
252b5132 12170
41e92641 12171 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 12172 || relsec->sh_info >= elf_header.e_shnum
12173 || section_headers + relsec->sh_info != section
c256ffe7 12174 || relsec->sh_size == 0
4fbb74a6 12175 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 12176 continue;
428409d5 12177
41e92641
NC		 12178 is_rela = relsec->sh_type == SHT_RELA;
12179
12180 if (is_rela)
12181 {
3f5e193b
NC		 12182 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
12183 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 12184 return;
12185 }
12186 else
12187 {
3f5e193b
NC		 12188 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
12189 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 12190 return;
12191 }
12192
12193 /* SH uses RELA but uses in place value instead of the addend field. */
12194 if (elf_header.e_machine == EM_SH)
12195 is_rela = FALSE;
428409d5 12196
4fbb74a6 12197 symsec = section_headers + relsec->sh_link;
ba5cdace 12198 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 12199
41e92641 12200 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 12201 {
41e92641
NC		 12202 bfd_vma addend;
12203 unsigned int reloc_type;
12204 unsigned int reloc_size;
91d6fa6a 12205 unsigned char * rloc;
ba5cdace 12206 unsigned long sym_index;
4b78141a 12207
aca88567 12208 reloc_type = get_reloc_type (rp->r_info);
41e92641 12209
98fb390a 12210 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 12211 continue;
98fb390a
NC		 12212 else if (is_none_reloc (reloc_type))
12213 continue;
12214 else if (is_32bit_abs_reloc (reloc_type)
12215 || is_32bit_pcrel_reloc (reloc_type))
aca88567 12216 reloc_size = 4;
85acf597
RH		 12217 else if (is_64bit_abs_reloc (reloc_type)
12218 || is_64bit_pcrel_reloc (reloc_type))
aca88567 12219 reloc_size = 8;
4dc3c23d
AM		 12220 else if (is_24bit_abs_reloc (reloc_type))
12221 reloc_size = 3;
aca88567
NC		 12222 else if (is_16bit_abs_reloc (reloc_type))
12223 reloc_size = 2;
12224 else
4b78141a 12225 {
bee0ee85
NC		 12226 static unsigned int prev_reloc = 0;
12227 if (reloc_type != prev_reloc)
12228 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12229 reloc_type, printable_section_name (section));
12230 prev_reloc = reloc_type;
4b78141a
NC		 12231 continue;
12232 }
103f02d3 12233
91d6fa6a 12234 rloc = start + rp->r_offset;
c8da6823 12235 if ((rloc + reloc_size) > end || (rloc < start))
700dd8b7
L		 12236 {
12237 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12238 (unsigned long) rp->r_offset,
74e1a04b 12239 printable_section_name (section));
700dd8b7
L		 12240 continue;
12241 }
103f02d3 12242
ba5cdace
NC		 12243 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
12244 if (sym_index >= num_syms)
12245 {
12246 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
74e1a04b 12247 sym_index, printable_section_name (section));
ba5cdace
NC		 12248 continue;
12249 }
12250 sym = symtab + sym_index;
41e92641
NC		 12251
12252 /* If the reloc has a symbol associated with it,
55f25fc3
L		 12253 make sure that it is of an appropriate type.
12254
12255 Relocations against symbols without type can happen.
12256 Gcc -feliminate-dwarf2-dups may generate symbols
12257 without type for debug info.
12258
12259 Icc generates relocations against function symbols
12260 instead of local labels.
12261
12262 Relocations against object symbols can happen, eg when
12263 referencing a global array. For an example of this see
12264 the _clz.o binary in libgcc.a. */
aca88567 12265 if (sym != symtab
b8871f35 12266 && ELF_ST_TYPE (sym->st_info) != STT_COMMON
55f25fc3 12267 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 12268 {
41e92641 12269 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 12270 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 12271 (long int)(rp - relocs),
74e1a04b 12272 printable_section_name (relsec));
aca88567 12273 continue;
5b18a4bc 12274 }
252b5132 12275
4dc3c23d
AM		 12276 addend = 0;
12277 if (is_rela)
12278 addend += rp->r_addend;
c47320c3
AM		 12279 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12280 partial_inplace. */
4dc3c23d
AM		 12281 if (!is_rela
12282 || (elf_header.e_machine == EM_XTENSA
12283 && reloc_type == 1)
12284 || ((elf_header.e_machine == EM_PJ
12285 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 12286 && reloc_type == 1)
12287 || ((elf_header.e_machine == EM_D30V
12288 || elf_header.e_machine == EM_CYGNUS_D30V)
12289 && reloc_type == 12))
91d6fa6a 12290 addend += byte_get (rloc, reloc_size);
cb8f3167 12291
85acf597
RH		 12292 if (is_32bit_pcrel_reloc (reloc_type)
12293 || is_64bit_pcrel_reloc (reloc_type))
12294 {
12295 /* On HPPA, all pc-relative relocations are biased by 8. */
12296 if (elf_header.e_machine == EM_PARISC)
12297 addend -= 8;
91d6fa6a 12298 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 12299 reloc_size);
12300 }
41e92641 12301 else
91d6fa6a 12302 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 12303 }
252b5132 12304
5b18a4bc 12305 free (symtab);
d1c4b12b
NC		 12306
12307 if (relocs_return)
12308 {
12309 * (Elf_Internal_Rela **) relocs_return = relocs;
12310 * num_relocs_return = num_relocs;
12311 }
12312 else
12313 free (relocs);
12314
5b18a4bc
NC		 12315 break;
12316 }
5b18a4bc 12317}
103f02d3 12318
cf13d699
NC		 12319#ifdef SUPPORT_DISASSEMBLY
12320static int
12321disassemble_section (Elf_Internal_Shdr * section, FILE * file)
12322{
74e1a04b 12323 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
cf13d699 12324
74e1a04b 12325 /* FIXME: XXX -- to be done --- XXX */
cf13d699
NC		 12326
12327 return 1;
12328}
12329#endif
12330
12331/* Reads in the contents of SECTION from FILE, returning a pointer
12332 to a malloc'ed buffer or NULL if something went wrong. */
12333
12334static char *
12335get_section_contents (Elf_Internal_Shdr * section, FILE * file)
12336{
12337 bfd_size_type num_bytes;
12338
12339 num_bytes = section->sh_size;
12340
12341 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
12342 {
12343 printf (_("\nSection '%s' has no data to dump.\n"),
74e1a04b 12344 printable_section_name (section));
cf13d699
NC		 12345 return NULL;
12346 }
12347
3f5e193b
NC		 12348 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
12349 _("section contents"));
cf13d699
NC		 12350}
12351
0e602686
NC		 12352/* Uncompresses a section that was compressed using zlib, in place. */
12353
12354static bfd_boolean
12355uncompress_section_contents (unsigned char **buffer,
12356 dwarf_size_type uncompressed_size,
12357 dwarf_size_type *size)
12358{
12359 dwarf_size_type compressed_size = *size;
12360 unsigned char * compressed_buffer = *buffer;
12361 unsigned char * uncompressed_buffer;
12362 z_stream strm;
12363 int rc;
12364
12365 /* It is possible the section consists of several compressed
12366 buffers concatenated together, so we uncompress in a loop. */
12367 /* PR 18313: The state field in the z_stream structure is supposed
12368 to be invisible to the user (ie us), but some compilers will
12369 still complain about it being used without initialisation. So
12370 we first zero the entire z_stream structure and then set the fields
12371 that we need. */
12372 memset (& strm, 0, sizeof strm);
12373 strm.avail_in = compressed_size;
12374 strm.next_in = (Bytef *) compressed_buffer;
12375 strm.avail_out = uncompressed_size;
12376 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
12377
12378 rc = inflateInit (& strm);
12379 while (strm.avail_in > 0)
12380 {
12381 if (rc != Z_OK)
12382 goto fail;
12383 strm.next_out = ((Bytef *) uncompressed_buffer
12384 + (uncompressed_size - strm.avail_out));
12385 rc = inflate (&strm, Z_FINISH);
12386 if (rc != Z_STREAM_END)
12387 goto fail;
12388 rc = inflateReset (& strm);
12389 }
12390 rc = inflateEnd (& strm);
12391 if (rc != Z_OK
12392 || strm.avail_out != 0)
12393 goto fail;
12394
12395 *buffer = uncompressed_buffer;
12396 *size = uncompressed_size;
12397 return TRUE;
12398
12399 fail:
12400 free (uncompressed_buffer);
12401 /* Indicate decompression failure. */
12402 *buffer = NULL;
12403 return FALSE;
12404}
dd24e3da 12405
cf13d699
NC		 12406static void
12407dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12408{
0e602686
NC		 12409 Elf_Internal_Shdr * relsec;
12410 bfd_size_type num_bytes;
fd8008d8
L		 12411 unsigned char * data;
12412 unsigned char * end;
12413 unsigned char * real_start;
12414 unsigned char * start;
0e602686 12415 bfd_boolean some_strings_shown;
cf13d699 12416
fd8008d8
L		 12417 real_start = start = (unsigned char *) get_section_contents (section,
12418 file);
cf13d699
NC		 12419 if (start == NULL)
12420 return;
0e602686 12421 num_bytes = section->sh_size;
cf13d699 12422
74e1a04b 12423 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
cf13d699 12424
0e602686
NC		 12425 if (decompress_dumps)
12426 {
12427 dwarf_size_type new_size = num_bytes;
12428 dwarf_size_type uncompressed_size = 0;
12429
12430 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12431 {
12432 Elf_Internal_Chdr chdr;
12433 unsigned int compression_header_size
12434 = get_compression_header (& chdr, (unsigned char *) start);
12435
813dabb9 12436 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
0e602686 12437 {
813dabb9
L		 12438 warn (_("section '%s' has unsupported compress type: %d\n"),
12439 printable_section_name (section), chdr.ch_type);
12440 return;
12441 }
12442 else if (chdr.ch_addralign != section->sh_addralign)
12443 {
12444 warn (_("compressed section '%s' is corrupted\n"),
12445 printable_section_name (section));
12446 return;
0e602686 12447 }
813dabb9
L		 12448 uncompressed_size = chdr.ch_size;
12449 start += compression_header_size;
12450 new_size -= compression_header_size;
0e602686
NC		 12451 }
12452 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12453 {
12454 /* Read the zlib header. In this case, it should be "ZLIB"
12455 followed by the uncompressed section size, 8 bytes in
12456 big-endian order. */
12457 uncompressed_size = start[4]; uncompressed_size <<= 8;
12458 uncompressed_size += start[5]; uncompressed_size <<= 8;
12459 uncompressed_size += start[6]; uncompressed_size <<= 8;
12460 uncompressed_size += start[7]; uncompressed_size <<= 8;
12461 uncompressed_size += start[8]; uncompressed_size <<= 8;
12462 uncompressed_size += start[9]; uncompressed_size <<= 8;
12463 uncompressed_size += start[10]; uncompressed_size <<= 8;
12464 uncompressed_size += start[11];
12465 start += 12;
12466 new_size -= 12;
12467 }
12468
12469 if (uncompressed_size
fd8008d8 12470 && uncompress_section_contents (& start,
0e602686
NC		 12471 uncompressed_size, & new_size))
12472 num_bytes = new_size;
12473 }
fd8008d8 12474
cf13d699
NC		 12475 /* If the section being dumped has relocations against it the user might
12476 be expecting these relocations to have been applied. Check for this
12477 case and issue a warning message in order to avoid confusion.
12478 FIXME: Maybe we ought to have an option that dumps a section with
12479 relocs applied ? */
12480 for (relsec = section_headers;
12481 relsec < section_headers + elf_header.e_shnum;
12482 ++relsec)
12483 {
12484 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12485 || relsec->sh_info >= elf_header.e_shnum
12486 || section_headers + relsec->sh_info != section
12487 || relsec->sh_size == 0
12488 || relsec->sh_link >= elf_header.e_shnum)
12489 continue;
12490
12491 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12492 break;
12493 }
12494
cf13d699
NC		 12495 data = start;
12496 end = start + num_bytes;
12497 some_strings_shown = FALSE;
12498
12499 while (data < end)
12500 {
12501 while (!ISPRINT (* data))
12502 if (++ data >= end)
12503 break;
12504
12505 if (data < end)
12506 {
071436c6
NC		 12507 size_t maxlen = end - data;
12508
cf13d699 12509#ifndef __MSVCRT__
c975cc98
NC		 12510 /* PR 11128: Use two separate invocations in order to work
12511 around bugs in the Solaris 8 implementation of printf. */
12512 printf (" [%6tx] ", data - start);
cf13d699 12513#else
071436c6 12514 printf (" [%6Ix] ", (size_t) (data - start));
cf13d699 12515#endif
4082ef84
NC		 12516 if (maxlen > 0)
12517 {
fd8008d8 12518 print_symbol ((int) maxlen, (const char *) data);
4082ef84 12519 putchar ('\n');
fd8008d8 12520 data += strnlen ((const char *) data, maxlen);
4082ef84
NC		 12521 }
12522 else
12523 {
12524 printf (_("<corrupt>\n"));
12525 data = end;
12526 }
cf13d699
NC		 12527 some_strings_shown = TRUE;
12528 }
12529 }
12530
12531 if (! some_strings_shown)
12532 printf (_(" No strings found in this section."));
12533
0e602686 12534 free (real_start);
cf13d699
NC		 12535
12536 putchar ('\n');
12537}
12538
12539static void
12540dump_section_as_bytes (Elf_Internal_Shdr * section,
12541 FILE * file,
12542 bfd_boolean relocate)
12543{
12544 Elf_Internal_Shdr * relsec;
0e602686
NC		 12545 bfd_size_type bytes;
12546 bfd_size_type section_size;
12547 bfd_vma addr;
12548 unsigned char * data;
12549 unsigned char * real_start;
12550 unsigned char * start;
12551
12552 real_start = start = (unsigned char *) get_section_contents (section, file);
cf13d699
NC		 12553 if (start == NULL)
12554 return;
0e602686 12555 section_size = section->sh_size;
cf13d699 12556
74e1a04b 12557 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
cf13d699 12558
0e602686
NC		 12559 if (decompress_dumps)
12560 {
12561 dwarf_size_type new_size = section_size;
12562 dwarf_size_type uncompressed_size = 0;
12563
12564 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12565 {
12566 Elf_Internal_Chdr chdr;
12567 unsigned int compression_header_size
12568 = get_compression_header (& chdr, start);
12569
813dabb9 12570 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
0e602686 12571 {
813dabb9
L		 12572 warn (_("section '%s' has unsupported compress type: %d\n"),
12573 printable_section_name (section), chdr.ch_type);
12574 return;
0e602686 12575 }
813dabb9
L		 12576 else if (chdr.ch_addralign != section->sh_addralign)
12577 {
12578 warn (_("compressed section '%s' is corrupted\n"),
12579 printable_section_name (section));
12580 return;
12581 }
12582 uncompressed_size = chdr.ch_size;
12583 start += compression_header_size;
12584 new_size -= compression_header_size;
0e602686
NC		 12585 }
12586 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12587 {
12588 /* Read the zlib header. In this case, it should be "ZLIB"
12589 followed by the uncompressed section size, 8 bytes in
12590 big-endian order. */
12591 uncompressed_size = start[4]; uncompressed_size <<= 8;
12592 uncompressed_size += start[5]; uncompressed_size <<= 8;
12593 uncompressed_size += start[6]; uncompressed_size <<= 8;
12594 uncompressed_size += start[7]; uncompressed_size <<= 8;
12595 uncompressed_size += start[8]; uncompressed_size <<= 8;
12596 uncompressed_size += start[9]; uncompressed_size <<= 8;
12597 uncompressed_size += start[10]; uncompressed_size <<= 8;
12598 uncompressed_size += start[11];
12599 start += 12;
12600 new_size -= 12;
12601 }
12602
12603 if (uncompressed_size
12604 && uncompress_section_contents (& start, uncompressed_size,
12605 & new_size))
12606 section_size = new_size;
12607 }
14ae95f2 12608
cf13d699
NC		 12609 if (relocate)
12610 {
0e602686 12611 apply_relocations (file, section, start, section_size, NULL, NULL);
cf13d699
NC		 12612 }
12613 else
12614 {
12615 /* If the section being dumped has relocations against it the user might
12616 be expecting these relocations to have been applied. Check for this
12617 case and issue a warning message in order to avoid confusion.
12618 FIXME: Maybe we ought to have an option that dumps a section with
12619 relocs applied ? */
12620 for (relsec = section_headers;
12621 relsec < section_headers + elf_header.e_shnum;
12622 ++relsec)
12623 {
12624 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12625 || relsec->sh_info >= elf_header.e_shnum
12626 || section_headers + relsec->sh_info != section
12627 || relsec->sh_size == 0
12628 || relsec->sh_link >= elf_header.e_shnum)
12629 continue;
12630
12631 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12632 break;
12633 }
12634 }
12635
12636 addr = section->sh_addr;
0e602686 12637 bytes = section_size;
cf13d699
NC		 12638 data = start;
12639
12640 while (bytes)
12641 {
12642 int j;
12643 int k;
12644 int lbytes;
12645
12646 lbytes = (bytes > 16 ? 16 : bytes);
12647
12648 printf (" 0x%8.8lx ", (unsigned long) addr);
12649
12650 for (j = 0; j < 16; j++)
12651 {
12652 if (j < lbytes)
12653 printf ("%2.2x", data[j]);
12654 else
12655 printf (" ");
12656
12657 if ((j & 3) == 3)
12658 printf (" ");
12659 }
12660
12661 for (j = 0; j < lbytes; j++)
12662 {
12663 k = data[j];
12664 if (k >= ' ' && k < 0x7f)
12665 printf ("%c", k);
12666 else
12667 printf (".");
12668 }
12669
12670 putchar ('\n');
12671
12672 data += lbytes;
12673 addr += lbytes;
12674 bytes -= lbytes;
12675 }
12676
0e602686 12677 free (real_start);
cf13d699
NC		 12678
12679 putchar ('\n');
12680}
12681
d966045b
DJ		 12682static int
12683load_specific_debug_section (enum dwarf_section_display_enum debug,
0d2a7a93 12684 const Elf_Internal_Shdr * sec, void * file)
1007acb3 12685{
2cf0635d 12686 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 12687 char buf [64];
1007acb3 12688
19e6b90e
L		 12689 /* If it is already loaded, do nothing. */
12690 if (section->start != NULL)
12691 return 1;
1007acb3 12692
19e6b90e
L		 12693 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12694 section->address = sec->sh_addr;
06614111 12695 section->user_data = NULL;
3f5e193b
NC		 12696 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12697 sec->sh_offset, 1,
12698 sec->sh_size, buf);
59245841
NC		 12699 if (section->start == NULL)
12700 section->size = 0;
12701 else
12702 {
77115a4a
L		 12703 unsigned char *start = section->start;
12704 dwarf_size_type size = sec->sh_size;
dab394de 12705 dwarf_size_type uncompressed_size = 0;
77115a4a
L		 12706
12707 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
12708 {
12709 Elf_Internal_Chdr chdr;
d8024a91
NC		 12710 unsigned int compression_header_size;
12711
f53be977
L		 12712 if (size < (is_32bit_elf
12713 ? sizeof (Elf32_External_Chdr)
12714 : sizeof (Elf64_External_Chdr)))
d8024a91
NC		 12715 {
12716 warn (_("compressed section %s is too small to contain a compression header"),
12717 section->name);
12718 return 0;
12719 }
12720
12721 compression_header_size = get_compression_header (&chdr, start);
12722
813dabb9
L		 12723 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12724 {
12725 warn (_("section '%s' has unsupported compress type: %d\n"),
12726 section->name, chdr.ch_type);
12727 return 0;
12728 }
12729 else if (chdr.ch_addralign != sec->sh_addralign)
12730 {
12731 warn (_("compressed section '%s' is corrupted\n"),
12732 section->name);
12733 return 0;
12734 }
dab394de 12735 uncompressed_size = chdr.ch_size;
77115a4a
L		 12736 start += compression_header_size;
12737 size -= compression_header_size;
12738 }
dab394de
L		 12739 else if (size > 12 && streq ((char *) start, "ZLIB"))
12740 {
12741 /* Read the zlib header. In this case, it should be "ZLIB"
12742 followed by the uncompressed section size, 8 bytes in
12743 big-endian order. */
12744 uncompressed_size = start[4]; uncompressed_size <<= 8;
12745 uncompressed_size += start[5]; uncompressed_size <<= 8;
12746 uncompressed_size += start[6]; uncompressed_size <<= 8;
12747 uncompressed_size += start[7]; uncompressed_size <<= 8;
12748 uncompressed_size += start[8]; uncompressed_size <<= 8;
12749 uncompressed_size += start[9]; uncompressed_size <<= 8;
12750 uncompressed_size += start[10]; uncompressed_size <<= 8;
12751 uncompressed_size += start[11];
12752 start += 12;
12753 size -= 12;
12754 }
12755
12756 if (uncompressed_size
12757 && uncompress_section_contents (&start, uncompressed_size,
12758 &size))
77115a4a
L		 12759 {
12760 /* Free the compressed buffer, update the section buffer
12761 and the section size if uncompress is successful. */
12762 free (section->start);
12763 section->start = start;
77115a4a
L		 12764 }
12765 section->size = size;
59245841 12766 }
4a114e3e 12767
1b315056
CS		 12768 if (section->start == NULL)
12769 return 0;
12770
19e6b90e 12771 if (debug_displays [debug].relocate)
d1c4b12b
NC		 12772 apply_relocations ((FILE *) file, sec, section->start, section->size,
12773 & section->reloc_info, & section->num_relocs);
12774 else
12775 {
12776 section->reloc_info = NULL;
12777 section->num_relocs = 0;
12778 }
1007acb3 12779
1b315056 12780 return 1;
1007acb3
L		 12781}
12782
657d0d47
CC		 12783/* If this is not NULL, load_debug_section will only look for sections
12784 within the list of sections given here. */
12785unsigned int *section_subset = NULL;
12786
d966045b 12787int
2cf0635d 12788load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 12789{
2cf0635d
NC		 12790 struct dwarf_section * section = &debug_displays [debug].section;
12791 Elf_Internal_Shdr * sec;
d966045b
DJ		 12792
12793 /* Locate the debug section. */
657d0d47 12794 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 12795 if (sec != NULL)
12796 section->name = section->uncompressed_name;
12797 else
12798 {
657d0d47 12799 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 12800 if (sec != NULL)
12801 section->name = section->compressed_name;
12802 }
12803 if (sec == NULL)
12804 return 0;
12805
657d0d47
CC		 12806 /* If we're loading from a subset of sections, and we've loaded
12807 a section matching this name before, it's likely that it's a
12808 different one. */
12809 if (section_subset != NULL)
12810 free_debug_section (debug);
12811
3f5e193b 12812 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 12813}
12814
19e6b90e
L		 12815void
12816free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 12817{
2cf0635d 12818 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 12819
19e6b90e
L		 12820 if (section->start == NULL)
12821 return;
1007acb3 12822
19e6b90e
L		 12823 free ((char *) section->start);
12824 section->start = NULL;
12825 section->address = 0;
12826 section->size = 0;
1007acb3
L		 12827}
12828
1007acb3 12829static int
657d0d47 12830display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 12831{
2cf0635d 12832 char * name = SECTION_NAME (section);
74e1a04b 12833 const char * print_name = printable_section_name (section);
19e6b90e
L		 12834 bfd_size_type length;
12835 int result = 1;
3f5e193b 12836 int i;
1007acb3 12837
19e6b90e
L		 12838 length = section->sh_size;
12839 if (length == 0)
1007acb3 12840 {
74e1a04b 12841 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
19e6b90e 12842 return 0;
1007acb3 12843 }
5dff79d8
NC		 12844 if (section->sh_type == SHT_NOBITS)
12845 {
12846 /* There is no point in dumping the contents of a debugging section
12847 which has the NOBITS type - the bits in the file will be random.
12848 This can happen when a file containing a .eh_frame section is
12849 stripped with the --only-keep-debug command line option. */
74e1a04b
NC		 12850 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12851 print_name);
5dff79d8
NC		 12852 return 0;
12853 }
1007acb3 12854
0112cd26 12855 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 12856 name = ".debug_info";
1007acb3 12857
19e6b90e
L		 12858 /* See if we know how to display the contents of this section. */
12859 for (i = 0; i < max; i++)
1b315056 12860 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 12861 || (i == line && const_strneq (name, ".debug_line."))
1b315056 12862 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 12863 {
2cf0635d 12864 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 12865 int secondary = (section != find_section (name));
12866
12867 if (secondary)
3f5e193b 12868 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 12869
b40bf0a2
NC		 12870 if (i == line && const_strneq (name, ".debug_line."))
12871 sec->name = name;
12872 else if (streq (sec->uncompressed_name, name))
d966045b
DJ		 12873 sec->name = sec->uncompressed_name;
12874 else
12875 sec->name = sec->compressed_name;
3f5e193b
NC		 12876 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12877 section, file))
19e6b90e 12878 {
657d0d47
CC		 12879 /* If this debug section is part of a CU/TU set in a .dwp file,
12880 restrict load_debug_section to the sections in that set. */
12881 section_subset = find_cu_tu_set (file, shndx);
12882
19e6b90e 12883 result &= debug_displays[i].display (sec, file);
1007acb3 12884
657d0d47
CC		 12885 section_subset = NULL;
12886
d966045b 12887 if (secondary || (i != info && i != abbrev))
3f5e193b 12888 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 12889 }
1007acb3 12890
19e6b90e
L		 12891 break;
12892 }
1007acb3 12893
19e6b90e 12894 if (i == max)
1007acb3 12895 {
74e1a04b 12896 printf (_("Unrecognized debug section: %s\n"), print_name);
19e6b90e 12897 result = 0;
1007acb3
L		 12898 }
12899
19e6b90e 12900 return result;
5b18a4bc 12901}
103f02d3 12902
aef1f6d0
DJ		 12903/* Set DUMP_SECTS for all sections where dumps were requested
12904 based on section name. */
12905
12906static void
12907initialise_dumps_byname (void)
12908{
2cf0635d 12909 struct dump_list_entry * cur;
aef1f6d0
DJ		 12910
12911 for (cur = dump_sects_byname; cur; cur = cur->next)
12912 {
12913 unsigned int i;
12914 int any;
12915
12916 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12917 if (streq (SECTION_NAME (section_headers + i), cur->name))
12918 {
09c11c86 12919 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 12920 any = 1;
12921 }
12922
12923 if (!any)
12924 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12925 cur->name);
12926 }
12927}
12928
5b18a4bc 12929static void
2cf0635d 12930process_section_contents (FILE * file)
5b18a4bc 12931{
2cf0635d 12932 Elf_Internal_Shdr * section;
19e6b90e 12933 unsigned int i;
103f02d3 12934
19e6b90e
L		 12935 if (! do_dump)
12936 return;
103f02d3 12937
aef1f6d0
DJ		 12938 initialise_dumps_byname ();
12939
19e6b90e
L		 12940 for (i = 0, section = section_headers;
12941 i < elf_header.e_shnum && i < num_dump_sects;
12942 i++, section++)
12943 {
12944#ifdef SUPPORT_DISASSEMBLY
12945 if (dump_sects[i] & DISASS_DUMP)
12946 disassemble_section (section, file);
12947#endif
12948 if (dump_sects[i] & HEX_DUMP)
cf13d699 12949 dump_section_as_bytes (section, file, FALSE);
103f02d3 12950
cf13d699
NC		 12951 if (dump_sects[i] & RELOC_DUMP)
12952 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 12953
12954 if (dump_sects[i] & STRING_DUMP)
12955 dump_section_as_strings (section, file);
cf13d699
NC		 12956
12957 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 12958 display_debug_section (i, section, file);
5b18a4bc 12959 }
103f02d3 12960
19e6b90e
L		 12961 /* Check to see if the user requested a
12962 dump of a section that does not exist. */
12963 while (i++ < num_dump_sects)
12964 if (dump_sects[i])
12965 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 12966}
103f02d3 12967
5b18a4bc 12968static void
19e6b90e 12969process_mips_fpe_exception (int mask)
5b18a4bc 12970{
19e6b90e
L		 12971 if (mask)
12972 {
12973 int first = 1;
12974 if (mask & OEX_FPU_INEX)
12975 fputs ("INEX", stdout), first = 0;
12976 if (mask & OEX_FPU_UFLO)
12977 printf ("%sUFLO", first ? "" : "|"), first = 0;
12978 if (mask & OEX_FPU_OFLO)
12979 printf ("%sOFLO", first ? "" : "|"), first = 0;
12980 if (mask & OEX_FPU_DIV0)
12981 printf ("%sDIV0", first ? "" : "|"), first = 0;
12982 if (mask & OEX_FPU_INVAL)
12983 printf ("%sINVAL", first ? "" : "|");
12984 }
5b18a4bc 12985 else
19e6b90e 12986 fputs ("0", stdout);
5b18a4bc 12987}
103f02d3 12988
f6f0e17b
NC		 12989/* Display's the value of TAG at location P. If TAG is
12990 greater than 0 it is assumed to be an unknown tag, and
12991 a message is printed to this effect. Otherwise it is
12992 assumed that a message has already been printed.
12993
12994 If the bottom bit of TAG is set it assumed to have a
12995 string value, otherwise it is assumed to have an integer
12996 value.
12997
12998 Returns an updated P pointing to the first unread byte
12999 beyond the end of TAG's value.
13000
13001 Reads at or beyond END will not be made. */
13002
13003static unsigned char *
13004display_tag_value (int tag,
13005 unsigned char * p,
13006 const unsigned char * const end)
13007{
13008 unsigned long val;
13009
13010 if (tag > 0)
13011 printf (" Tag_unknown_%d: ", tag);
13012
13013 if (p >= end)
13014 {
4082ef84 13015 warn (_("<corrupt tag>\n"));
f6f0e17b
NC		 13016 }
13017 else if (tag & 1)
13018 {
071436c6
NC		 13019 /* PR 17531 file: 027-19978-0.004. */
13020 size_t maxlen = (end - p) - 1;
13021
13022 putchar ('"');
4082ef84
NC		 13023 if (maxlen > 0)
13024 {
13025 print_symbol ((int) maxlen, (const char *) p);
13026 p += strnlen ((char *) p, maxlen) + 1;
13027 }
13028 else
13029 {
13030 printf (_("<corrupt string tag>"));
13031 p = (unsigned char *) end;
13032 }
071436c6 13033 printf ("\"\n");
f6f0e17b
NC		 13034 }
13035 else
13036 {
13037 unsigned int len;
13038
13039 val = read_uleb128 (p, &len, end);
13040 p += len;
13041 printf ("%ld (0x%lx)\n", val, val);
13042 }
13043
4082ef84 13044 assert (p <= end);
f6f0e17b
NC		 13045 return p;
13046}
13047
11c1ff18
PB		 13048/* ARM EABI attributes section. */
13049typedef struct
13050{
70e99720 13051 unsigned int tag;
2cf0635d 13052 const char * name;
11c1ff18 13053 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
70e99720 13054 unsigned int type;
2cf0635d 13055 const char ** table;
11c1ff18
PB		 13056} arm_attr_public_tag;
13057
2cf0635d 13058static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 13059 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
ff8646ee
TP		 13060 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
13061 "v8-M.mainline"};
2cf0635d
NC		 13062static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
13063static const char * arm_attr_tag_THUMB_ISA_use[] =
4ed7ed8d 13064 {"No", "Thumb-1", "Thumb-2", "Yes"};
75375b3e 13065static const char * arm_attr_tag_FP_arch[] =
bca38921 13066 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
a715796b 13067 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
2cf0635d 13068static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 13069static const char * arm_attr_tag_Advanced_SIMD_arch[] =
9411fd44
MW		 13070 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13071 "NEON for ARMv8.1"};
2cf0635d 13072static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 13073 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13074 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 13075static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 13076 {"V6", "SB", "TLS", "Unused"};
2cf0635d 13077static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 13078 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 13079static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 13080 {"Absolute", "PC-relative", "None"};
2cf0635d 13081static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 13082 {"None", "direct", "GOT-indirect"};
2cf0635d 13083static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 13084 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 13085static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
13086static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 13087 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 13088static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
13089static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
13090static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 13091 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 13092static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 13093 {"Unused", "small", "int", "forced to int"};
2cf0635d 13094static const char * arm_attr_tag_ABI_HardFP_use[] =
99654aaf 13095 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
2cf0635d 13096static const char * arm_attr_tag_ABI_VFP_args[] =
5c294fee 13097 {"AAPCS", "VFP registers", "custom", "compatible"};
2cf0635d 13098static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 13099 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 13100static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 13101 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13102 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 13103static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 13104 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13105 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 13106static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 13107static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 13108 {"Not Allowed", "Allowed"};
2cf0635d 13109static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 13110 {"None", "IEEE 754", "Alternative Format"};
15afaa63
TP		 13111static const char * arm_attr_tag_DSP_extension[] =
13112 {"Follow architecture", "Allowed"};
dd24e3da 13113static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 13114 {"Not Allowed", "Allowed"};
13115static const char * arm_attr_tag_DIV_use[] =
dd24e3da 13116 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 13117 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 13118static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
13119static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 13120 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 13121 "TrustZone and Virtualization Extensions"};
dd24e3da 13122static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 13123 {"Not Allowed", "Allowed"};
11c1ff18
PB		 13124
13125#define LOOKUP(id, name) \
13126 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 13127static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 13128{
13129 {4, "CPU_raw_name", 1, NULL},
13130 {5, "CPU_name", 1, NULL},
13131 LOOKUP(6, CPU_arch),
13132 {7, "CPU_arch_profile", 0, NULL},
13133 LOOKUP(8, ARM_ISA_use),
13134 LOOKUP(9, THUMB_ISA_use),
75375b3e 13135 LOOKUP(10, FP_arch),
11c1ff18 13136 LOOKUP(11, WMMX_arch),
f5f53991
AS		 13137 LOOKUP(12, Advanced_SIMD_arch),
13138 LOOKUP(13, PCS_config),
11c1ff18
PB		 13139 LOOKUP(14, ABI_PCS_R9_use),
13140 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 13141 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 13142 LOOKUP(17, ABI_PCS_GOT_use),
13143 LOOKUP(18, ABI_PCS_wchar_t),
13144 LOOKUP(19, ABI_FP_rounding),
13145 LOOKUP(20, ABI_FP_denormal),
13146 LOOKUP(21, ABI_FP_exceptions),
13147 LOOKUP(22, ABI_FP_user_exceptions),
13148 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 13149 {24, "ABI_align_needed", 0, NULL},
13150 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 13151 LOOKUP(26, ABI_enum_size),
13152 LOOKUP(27, ABI_HardFP_use),
13153 LOOKUP(28, ABI_VFP_args),
13154 LOOKUP(29, ABI_WMMX_args),
13155 LOOKUP(30, ABI_optimization_goals),
13156 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 13157 {32, "compatibility", 0, NULL},
f5f53991 13158 LOOKUP(34, CPU_unaligned_access),
75375b3e 13159 LOOKUP(36, FP_HP_extension),
8e79c3df 13160 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 13161 LOOKUP(42, MPextension_use),
13162 LOOKUP(44, DIV_use),
15afaa63 13163 LOOKUP(46, DSP_extension),
f5f53991
AS		 13164 {64, "nodefaults", 0, NULL},
13165 {65, "also_compatible_with", 0, NULL},
13166 LOOKUP(66, T2EE_use),
13167 {67, "conformance", 1, NULL},
13168 LOOKUP(68, Virtualization_use),
cd21e546 13169 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 13170};
13171#undef LOOKUP
13172
11c1ff18 13173static unsigned char *
f6f0e17b
NC		 13174display_arm_attribute (unsigned char * p,
13175 const unsigned char * const end)
11c1ff18 13176{
70e99720 13177 unsigned int tag;
11c1ff18 13178 unsigned int len;
70e99720 13179 unsigned int val;
2cf0635d 13180 arm_attr_public_tag * attr;
11c1ff18 13181 unsigned i;
70e99720 13182 unsigned int type;
11c1ff18 13183
f6f0e17b 13184 tag = read_uleb128 (p, &len, end);
11c1ff18
PB		 13185 p += len;
13186 attr = NULL;
2cf0635d 13187 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 13188 {
13189 if (arm_attr_public_tags[i].tag == tag)
13190 {
13191 attr = &arm_attr_public_tags[i];
13192 break;
13193 }
13194 }
13195
13196 if (attr)
13197 {
13198 printf (" Tag_%s: ", attr->name);
13199 switch (attr->type)
13200 {
13201 case 0:
13202 switch (tag)
13203 {
13204 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 13205 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 13206 p += len;
13207 switch (val)
13208 {
2b692964
NC		 13209 case 0: printf (_("None\n")); break;
13210 case 'A': printf (_("Application\n")); break;
13211 case 'R': printf (_("Realtime\n")); break;
13212 case 'M': printf (_("Microcontroller\n")); break;
13213 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 13214 default: printf ("??? (%d)\n", val); break;
13215 }
13216 break;
13217
75375b3e 13218 case 24: /* Tag_align_needed. */
f6f0e17b 13219 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 13220 p += len;
13221 switch (val)
13222 {
2b692964
NC		 13223 case 0: printf (_("None\n")); break;
13224 case 1: printf (_("8-byte\n")); break;
13225 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 13226 case 3: printf ("??? 3\n"); break;
13227 default:
13228 if (val <= 12)
dd24e3da 13229 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 13230 1 << val);
13231 else
13232 printf ("??? (%d)\n", val);
13233 break;
13234 }
13235 break;
13236
13237 case 25: /* Tag_align_preserved. */
f6f0e17b 13238 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 13239 p += len;
13240 switch (val)
13241 {
2b692964
NC		 13242 case 0: printf (_("None\n")); break;
13243 case 1: printf (_("8-byte, except leaf SP\n")); break;
13244 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 13245 case 3: printf ("??? 3\n"); break;
13246 default:
13247 if (val <= 12)
dd24e3da 13248 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 13249 1 << val);
13250 else
13251 printf ("??? (%d)\n", val);
13252 break;
13253 }
13254 break;
13255
11c1ff18 13256 case 32: /* Tag_compatibility. */
071436c6 13257 {
071436c6
NC		 13258 val = read_uleb128 (p, &len, end);
13259 p += len;
071436c6 13260 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 13261 if (p < end - 1)
13262 {
13263 size_t maxlen = (end - p) - 1;
13264
13265 print_symbol ((int) maxlen, (const char *) p);
13266 p += strnlen ((char *) p, maxlen) + 1;
13267 }
13268 else
13269 {
13270 printf (_("<corrupt>"));
13271 p = (unsigned char *) end;
13272 }
071436c6 13273 putchar ('\n');
071436c6 13274 }
11c1ff18
PB		 13275 break;
13276
f5f53991 13277 case 64: /* Tag_nodefaults. */
541a3cbd
NC		 13278 /* PR 17531: file: 001-505008-0.01. */
13279 if (p < end)
13280 p++;
2b692964 13281 printf (_("True\n"));
f5f53991
AS		 13282 break;
13283
13284 case 65: /* Tag_also_compatible_with. */
f6f0e17b 13285 val = read_uleb128 (p, &len, end);
f5f53991
AS		 13286 p += len;
13287 if (val == 6 /* Tag_CPU_arch. */)
13288 {
f6f0e17b 13289 val = read_uleb128 (p, &len, end);
f5f53991 13290 p += len;
071436c6 13291 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 13292 printf ("??? (%d)\n", val);
13293 else
13294 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
13295 }
13296 else
13297 printf ("???\n");
071436c6
NC		 13298 while (p < end && *(p++) != '\0' /* NUL terminator. */)
13299 ;
f5f53991
AS		 13300 break;
13301
11c1ff18 13302 default:
bee0ee85
NC		 13303 printf (_("<unknown: %d>\n"), tag);
13304 break;
11c1ff18
PB		 13305 }
13306 return p;
13307
13308 case 1:
f6f0e17b 13309 return display_tag_value (-1, p, end);
11c1ff18 13310 case 2:
f6f0e17b 13311 return display_tag_value (0, p, end);
11c1ff18
PB		 13312
13313 default:
13314 assert (attr->type & 0x80);
f6f0e17b 13315 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 13316 p += len;
13317 type = attr->type & 0x7f;
13318 if (val >= type)
13319 printf ("??? (%d)\n", val);
13320 else
13321 printf ("%s\n", attr->table[val]);
13322 return p;
13323 }
13324 }
11c1ff18 13325
f6f0e17b 13326 return display_tag_value (tag, p, end);
11c1ff18
PB		 13327}
13328
104d59d1 13329static unsigned char *
60bca95a 13330display_gnu_attribute (unsigned char * p,
f6f0e17b
NC		 13331 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
13332 const unsigned char * const end)
104d59d1
JM		 13333{
13334 int tag;
13335 unsigned int len;
13336 int val;
104d59d1 13337
f6f0e17b 13338 tag = read_uleb128 (p, &len, end);
104d59d1
JM		 13339 p += len;
13340
13341 /* Tag_compatibility is the only generic GNU attribute defined at
13342 present. */
13343 if (tag == 32)
13344 {
f6f0e17b 13345 val = read_uleb128 (p, &len, end);
104d59d1 13346 p += len;
071436c6
NC		 13347
13348 printf (_("flag = %d, vendor = "), val);
f6f0e17b
NC		 13349 if (p == end)
13350 {
071436c6 13351 printf (_("<corrupt>\n"));
f6f0e17b
NC		 13352 warn (_("corrupt vendor attribute\n"));
13353 }
13354 else
13355 {
4082ef84
NC		 13356 if (p < end - 1)
13357 {
13358 size_t maxlen = (end - p) - 1;
071436c6 13359
4082ef84
NC		 13360 print_symbol ((int) maxlen, (const char *) p);
13361 p += strnlen ((char *) p, maxlen) + 1;
13362 }
13363 else
13364 {
13365 printf (_("<corrupt>"));
13366 p = (unsigned char *) end;
13367 }
071436c6 13368 putchar ('\n');
f6f0e17b 13369 }
104d59d1
JM		 13370 return p;
13371 }
13372
13373 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 13374 return display_proc_gnu_attribute (p, tag, end);
104d59d1 13375
f6f0e17b 13376 return display_tag_value (tag, p, end);
104d59d1
JM		 13377}
13378
34c8bcba 13379static unsigned char *
f6f0e17b
NC		 13380display_power_gnu_attribute (unsigned char * p,
13381 int tag,
13382 const unsigned char * const end)
34c8bcba 13383{
34c8bcba 13384 unsigned int len;
005d79fd 13385 unsigned int val;
34c8bcba
JM		 13386
13387 if (tag == Tag_GNU_Power_ABI_FP)
13388 {
f6f0e17b 13389 val = read_uleb128 (p, &len, end);
34c8bcba
JM		 13390 p += len;
13391 printf (" Tag_GNU_Power_ABI_FP: ");
005d79fd
AM		 13392 if (len == 0)
13393 {
13394 printf (_("<corrupt>\n"));
13395 return p;
13396 }
60bca95a 13397
005d79fd
AM		 13398 if (val > 15)
13399 printf ("(%#x), ", val);
13400
13401 switch (val & 3)
34c8bcba
JM		 13402 {
13403 case 0:
005d79fd 13404 printf (_("unspecified hard/soft float, "));
34c8bcba
JM		 13405 break;
13406 case 1:
005d79fd 13407 printf (_("hard float, "));
34c8bcba
JM		 13408 break;
13409 case 2:
005d79fd 13410 printf (_("soft float, "));
34c8bcba 13411 break;
3c7b9897 13412 case 3:
005d79fd 13413 printf (_("single-precision hard float, "));
3c7b9897 13414 break;
005d79fd
AM		 13415 }
13416
13417 switch (val & 0xC)
13418 {
13419 case 0:
13420 printf (_("unspecified long double\n"));
13421 break;
13422 case 4:
13423 printf (_("128-bit IBM long double\n"));
13424 break;
13425 case 8:
13426 printf (_("64-bit long double\n"));
13427 break;
13428 case 12:
13429 printf (_("128-bit IEEE long double\n"));
34c8bcba
JM		 13430 break;
13431 }
13432 return p;
005d79fd 13433 }
34c8bcba 13434
c6e65352
DJ		 13435 if (tag == Tag_GNU_Power_ABI_Vector)
13436 {
f6f0e17b 13437 val = read_uleb128 (p, &len, end);
c6e65352
DJ		 13438 p += len;
13439 printf (" Tag_GNU_Power_ABI_Vector: ");
005d79fd
AM		 13440 if (len == 0)
13441 {
13442 printf (_("<corrupt>\n"));
13443 return p;
13444 }
13445
13446 if (val > 3)
13447 printf ("(%#x), ", val);
13448
13449 switch (val & 3)
c6e65352
DJ		 13450 {
13451 case 0:
005d79fd 13452 printf (_("unspecified\n"));
c6e65352
DJ		 13453 break;
13454 case 1:
005d79fd 13455 printf (_("generic\n"));
c6e65352
DJ		 13456 break;
13457 case 2:
13458 printf ("AltiVec\n");
13459 break;
13460 case 3:
13461 printf ("SPE\n");
13462 break;
c6e65352
DJ		 13463 }
13464 return p;
005d79fd 13465 }
c6e65352 13466
f82e0623
NF		 13467 if (tag == Tag_GNU_Power_ABI_Struct_Return)
13468 {
005d79fd
AM		 13469 val = read_uleb128 (p, &len, end);
13470 p += len;
13471 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13472 if (len == 0)
f6f0e17b 13473 {
005d79fd 13474 printf (_("<corrupt>\n"));
f6f0e17b
NC		 13475 return p;
13476 }
0b4362b0 13477
005d79fd
AM		 13478 if (val > 2)
13479 printf ("(%#x), ", val);
13480
13481 switch (val & 3)
13482 {
13483 case 0:
13484 printf (_("unspecified\n"));
13485 break;
13486 case 1:
13487 printf ("r3/r4\n");
13488 break;
13489 case 2:
13490 printf (_("memory\n"));
13491 break;
13492 case 3:
13493 printf ("???\n");
13494 break;
13495 }
f82e0623
NF		 13496 return p;
13497 }
13498
f6f0e17b 13499 return display_tag_value (tag & 1, p, end);
34c8bcba
JM		 13500}
13501
643f7afb
AK		 13502static unsigned char *
13503display_s390_gnu_attribute (unsigned char * p,
13504 int tag,
13505 const unsigned char * const end)
13506{
13507 unsigned int len;
13508 int val;
13509
13510 if (tag == Tag_GNU_S390_ABI_Vector)
13511 {
13512 val = read_uleb128 (p, &len, end);
13513 p += len;
13514 printf (" Tag_GNU_S390_ABI_Vector: ");
13515
13516 switch (val)
13517 {
13518 case 0:
13519 printf (_("any\n"));
13520 break;
13521 case 1:
13522 printf (_("software\n"));
13523 break;
13524 case 2:
13525 printf (_("hardware\n"));
13526 break;
13527 default:
13528 printf ("??? (%d)\n", val);
13529 break;
13530 }
13531 return p;
13532 }
13533
13534 return display_tag_value (tag & 1, p, end);
13535}
13536
9e8c70f9
DM		 13537static void
13538display_sparc_hwcaps (int mask)
13539{
13540 if (mask)
13541 {
13542 int first = 1;
071436c6 13543
9e8c70f9
DM		 13544 if (mask & ELF_SPARC_HWCAP_MUL32)
13545 fputs ("mul32", stdout), first = 0;
13546 if (mask & ELF_SPARC_HWCAP_DIV32)
13547 printf ("%sdiv32", first ? "" : "|"), first = 0;
13548 if (mask & ELF_SPARC_HWCAP_FSMULD)
13549 printf ("%sfsmuld", first ? "" : "|"), first = 0;
13550 if (mask & ELF_SPARC_HWCAP_V8PLUS)
13551 printf ("%sv8plus", first ? "" : "|"), first = 0;
13552 if (mask & ELF_SPARC_HWCAP_POPC)
13553 printf ("%spopc", first ? "" : "|"), first = 0;
13554 if (mask & ELF_SPARC_HWCAP_VIS)
13555 printf ("%svis", first ? "" : "|"), first = 0;
13556 if (mask & ELF_SPARC_HWCAP_VIS2)
13557 printf ("%svis2", first ? "" : "|"), first = 0;
13558 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
13559 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
13560 if (mask & ELF_SPARC_HWCAP_FMAF)
13561 printf ("%sfmaf", first ? "" : "|"), first = 0;
13562 if (mask & ELF_SPARC_HWCAP_VIS3)
13563 printf ("%svis3", first ? "" : "|"), first = 0;
13564 if (mask & ELF_SPARC_HWCAP_HPC)
13565 printf ("%shpc", first ? "" : "|"), first = 0;
13566 if (mask & ELF_SPARC_HWCAP_RANDOM)
13567 printf ("%srandom", first ? "" : "|"), first = 0;
13568 if (mask & ELF_SPARC_HWCAP_TRANS)
13569 printf ("%strans", first ? "" : "|"), first = 0;
13570 if (mask & ELF_SPARC_HWCAP_FJFMAU)
13571 printf ("%sfjfmau", first ? "" : "|"), first = 0;
13572 if (mask & ELF_SPARC_HWCAP_IMA)
13573 printf ("%sima", first ? "" : "|"), first = 0;
13574 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
13575 printf ("%scspare", first ? "" : "|"), first = 0;
13576 }
13577 else
071436c6
NC		 13578 fputc ('0', stdout);
13579 fputc ('\n', stdout);
9e8c70f9
DM		 13580}
13581
3d68f91c
JM		 13582static void
13583display_sparc_hwcaps2 (int mask)
13584{
13585 if (mask)
13586 {
13587 int first = 1;
071436c6 13588
3d68f91c
JM		 13589 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
13590 fputs ("fjathplus", stdout), first = 0;
13591 if (mask & ELF_SPARC_HWCAP2_VIS3B)
13592 printf ("%svis3b", first ? "" : "|"), first = 0;
13593 if (mask & ELF_SPARC_HWCAP2_ADP)
13594 printf ("%sadp", first ? "" : "|"), first = 0;
13595 if (mask & ELF_SPARC_HWCAP2_SPARC5)
13596 printf ("%ssparc5", first ? "" : "|"), first = 0;
13597 if (mask & ELF_SPARC_HWCAP2_MWAIT)
13598 printf ("%smwait", first ? "" : "|"), first = 0;
13599 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
13600 printf ("%sxmpmul", first ? "" : "|"), first = 0;
13601 if (mask & ELF_SPARC_HWCAP2_XMONT)
13602 printf ("%sxmont2", first ? "" : "|"), first = 0;
13603 if (mask & ELF_SPARC_HWCAP2_NSEC)
13604 printf ("%snsec", first ? "" : "|"), first = 0;
13605 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
13606 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
13607 if (mask & ELF_SPARC_HWCAP2_FJDES)
13608 printf ("%sfjdes", first ? "" : "|"), first = 0;
13609 if (mask & ELF_SPARC_HWCAP2_FJAES)
13610 printf ("%sfjaes", first ? "" : "|"), first = 0;
13611 }
13612 else
071436c6
NC		 13613 fputc ('0', stdout);
13614 fputc ('\n', stdout);
3d68f91c
JM		 13615}
13616
9e8c70f9 13617static unsigned char *
f6f0e17b
NC		 13618display_sparc_gnu_attribute (unsigned char * p,
13619 int tag,
13620 const unsigned char * const end)
9e8c70f9 13621{
3d68f91c
JM		 13622 unsigned int len;
13623 int val;
13624
9e8c70f9
DM		 13625 if (tag == Tag_GNU_Sparc_HWCAPS)
13626 {
f6f0e17b 13627 val = read_uleb128 (p, &len, end);
9e8c70f9
DM		 13628 p += len;
13629 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM		 13630 display_sparc_hwcaps (val);
13631 return p;
3d68f91c
JM		 13632 }
13633 if (tag == Tag_GNU_Sparc_HWCAPS2)
13634 {
13635 val = read_uleb128 (p, &len, end);
13636 p += len;
13637 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13638 display_sparc_hwcaps2 (val);
13639 return p;
13640 }
9e8c70f9 13641
f6f0e17b 13642 return display_tag_value (tag, p, end);
9e8c70f9
DM		 13643}
13644
351cdf24
MF		 13645static void
13646print_mips_fp_abi_value (int val)
13647{
13648 switch (val)
13649 {
13650 case Val_GNU_MIPS_ABI_FP_ANY:
13651 printf (_("Hard or soft float\n"));
13652 break;
13653 case Val_GNU_MIPS_ABI_FP_DOUBLE:
13654 printf (_("Hard float (double precision)\n"));
13655 break;
13656 case Val_GNU_MIPS_ABI_FP_SINGLE:
13657 printf (_("Hard float (single precision)\n"));
13658 break;
13659 case Val_GNU_MIPS_ABI_FP_SOFT:
13660 printf (_("Soft float\n"));
13661 break;
13662 case Val_GNU_MIPS_ABI_FP_OLD_64:
13663 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13664 break;
13665 case Val_GNU_MIPS_ABI_FP_XX:
13666 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13667 break;
13668 case Val_GNU_MIPS_ABI_FP_64:
13669 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13670 break;
13671 case Val_GNU_MIPS_ABI_FP_64A:
13672 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13673 break;
3350cc01
CM		 13674 case Val_GNU_MIPS_ABI_FP_NAN2008:
13675 printf (_("NaN 2008 compatibility\n"));
13676 break;
351cdf24
MF		 13677 default:
13678 printf ("??? (%d)\n", val);
13679 break;
13680 }
13681}
13682
2cf19d5c 13683static unsigned char *
f6f0e17b
NC		 13684display_mips_gnu_attribute (unsigned char * p,
13685 int tag,
13686 const unsigned char * const end)
2cf19d5c 13687{
2cf19d5c
JM		 13688 if (tag == Tag_GNU_MIPS_ABI_FP)
13689 {
f6f0e17b
NC		 13690 unsigned int len;
13691 int val;
13692
13693 val = read_uleb128 (p, &len, end);
2cf19d5c
JM		 13694 p += len;
13695 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 13696
351cdf24
MF		 13697 print_mips_fp_abi_value (val);
13698
2cf19d5c
JM		 13699 return p;
13700 }
13701
a9f58168
CF		 13702 if (tag == Tag_GNU_MIPS_ABI_MSA)
13703 {
13704 unsigned int len;
13705 int val;
13706
13707 val = read_uleb128 (p, &len, end);
13708 p += len;
13709 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13710
13711 switch (val)
13712 {
13713 case Val_GNU_MIPS_ABI_MSA_ANY:
13714 printf (_("Any MSA or not\n"));
13715 break;
13716 case Val_GNU_MIPS_ABI_MSA_128:
13717 printf (_("128-bit MSA\n"));
13718 break;
13719 default:
13720 printf ("??? (%d)\n", val);
13721 break;
13722 }
13723 return p;
13724 }
13725
f6f0e17b 13726 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM		 13727}
13728
59e6276b 13729static unsigned char *
f6f0e17b
NC		 13730display_tic6x_attribute (unsigned char * p,
13731 const unsigned char * const end)
59e6276b
JM		 13732{
13733 int tag;
13734 unsigned int len;
13735 int val;
13736
f6f0e17b 13737 tag = read_uleb128 (p, &len, end);
59e6276b
JM		 13738 p += len;
13739
13740 switch (tag)
13741 {
75fa6dc1 13742 case Tag_ISA:
f6f0e17b 13743 val = read_uleb128 (p, &len, end);
59e6276b 13744 p += len;
75fa6dc1 13745 printf (" Tag_ISA: ");
59e6276b
JM		 13746
13747 switch (val)
13748 {
75fa6dc1 13749 case C6XABI_Tag_ISA_none:
59e6276b
JM		 13750 printf (_("None\n"));
13751 break;
75fa6dc1 13752 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 13753 printf ("C62x\n");
13754 break;
75fa6dc1 13755 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 13756 printf ("C67x\n");
13757 break;
75fa6dc1 13758 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 13759 printf ("C67x+\n");
13760 break;
75fa6dc1 13761 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 13762 printf ("C64x\n");
13763 break;
75fa6dc1 13764 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 13765 printf ("C64x+\n");
13766 break;
75fa6dc1 13767 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 13768 printf ("C674x\n");
13769 break;
13770 default:
13771 printf ("??? (%d)\n", val);
13772 break;
13773 }
13774 return p;
13775
87779176 13776 case Tag_ABI_wchar_t:
f6f0e17b 13777 val = read_uleb128 (p, &len, end);
87779176
JM		 13778 p += len;
13779 printf (" Tag_ABI_wchar_t: ");
13780 switch (val)
13781 {
13782 case 0:
13783 printf (_("Not used\n"));
13784 break;
13785 case 1:
13786 printf (_("2 bytes\n"));
13787 break;
13788 case 2:
13789 printf (_("4 bytes\n"));
13790 break;
13791 default:
13792 printf ("??? (%d)\n", val);
13793 break;
13794 }
13795 return p;
13796
13797 case Tag_ABI_stack_align_needed:
f6f0e17b 13798 val = read_uleb128 (p, &len, end);
87779176
JM		 13799 p += len;
13800 printf (" Tag_ABI_stack_align_needed: ");
13801 switch (val)
13802 {
13803 case 0:
13804 printf (_("8-byte\n"));
13805 break;
13806 case 1:
13807 printf (_("16-byte\n"));
13808 break;
13809 default:
13810 printf ("??? (%d)\n", val);
13811 break;
13812 }
13813 return p;
13814
13815 case Tag_ABI_stack_align_preserved:
f6f0e17b 13816 val = read_uleb128 (p, &len, end);
87779176
JM		 13817 p += len;
13818 printf (" Tag_ABI_stack_align_preserved: ");
13819 switch (val)
13820 {
13821 case 0:
13822 printf (_("8-byte\n"));
13823 break;
13824 case 1:
13825 printf (_("16-byte\n"));
13826 break;
13827 default:
13828 printf ("??? (%d)\n", val);
13829 break;
13830 }
13831 return p;
13832
b5593623 13833 case Tag_ABI_DSBT:
f6f0e17b 13834 val = read_uleb128 (p, &len, end);
b5593623
JM		 13835 p += len;
13836 printf (" Tag_ABI_DSBT: ");
13837 switch (val)
13838 {
13839 case 0:
13840 printf (_("DSBT addressing not used\n"));
13841 break;
13842 case 1:
13843 printf (_("DSBT addressing used\n"));
13844 break;
13845 default:
13846 printf ("??? (%d)\n", val);
13847 break;
13848 }
13849 return p;
13850
87779176 13851 case Tag_ABI_PID:
f6f0e17b 13852 val = read_uleb128 (p, &len, end);
87779176
JM		 13853 p += len;
13854 printf (" Tag_ABI_PID: ");
13855 switch (val)
13856 {
13857 case 0:
13858 printf (_("Data addressing position-dependent\n"));
13859 break;
13860 case 1:
13861 printf (_("Data addressing position-independent, GOT near DP\n"));
13862 break;
13863 case 2:
13864 printf (_("Data addressing position-independent, GOT far from DP\n"));
13865 break;
13866 default:
13867 printf ("??? (%d)\n", val);
13868 break;
13869 }
13870 return p;
13871
13872 case Tag_ABI_PIC:
f6f0e17b 13873 val = read_uleb128 (p, &len, end);
87779176
JM		 13874 p += len;
13875 printf (" Tag_ABI_PIC: ");
13876 switch (val)
13877 {
13878 case 0:
13879 printf (_("Code addressing position-dependent\n"));
13880 break;
13881 case 1:
13882 printf (_("Code addressing position-independent\n"));
13883 break;
13884 default:
13885 printf ("??? (%d)\n", val);
13886 break;
13887 }
13888 return p;
13889
13890 case Tag_ABI_array_object_alignment:
f6f0e17b 13891 val = read_uleb128 (p, &len, end);
87779176
JM		 13892 p += len;
13893 printf (" Tag_ABI_array_object_alignment: ");
13894 switch (val)
13895 {
13896 case 0:
13897 printf (_("8-byte\n"));
13898 break;
13899 case 1:
13900 printf (_("4-byte\n"));
13901 break;
13902 case 2:
13903 printf (_("16-byte\n"));
13904 break;
13905 default:
13906 printf ("??? (%d)\n", val);
13907 break;
13908 }
13909 return p;
13910
13911 case Tag_ABI_array_object_align_expected:
f6f0e17b 13912 val = read_uleb128 (p, &len, end);
87779176
JM		 13913 p += len;
13914 printf (" Tag_ABI_array_object_align_expected: ");
13915 switch (val)
13916 {
13917 case 0:
13918 printf (_("8-byte\n"));
13919 break;
13920 case 1:
13921 printf (_("4-byte\n"));
13922 break;
13923 case 2:
13924 printf (_("16-byte\n"));
13925 break;
13926 default:
13927 printf ("??? (%d)\n", val);
13928 break;
13929 }
13930 return p;
13931
3cbd1c06 13932 case Tag_ABI_compatibility:
071436c6 13933 {
071436c6
NC		 13934 val = read_uleb128 (p, &len, end);
13935 p += len;
13936 printf (" Tag_ABI_compatibility: ");
071436c6 13937 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 13938 if (p < end - 1)
13939 {
13940 size_t maxlen = (end - p) - 1;
13941
13942 print_symbol ((int) maxlen, (const char *) p);
13943 p += strnlen ((char *) p, maxlen) + 1;
13944 }
13945 else
13946 {
13947 printf (_("<corrupt>"));
13948 p = (unsigned char *) end;
13949 }
071436c6 13950 putchar ('\n');
071436c6
NC		 13951 return p;
13952 }
87779176
JM		 13953
13954 case Tag_ABI_conformance:
071436c6 13955 {
4082ef84
NC		 13956 printf (" Tag_ABI_conformance: \"");
13957 if (p < end - 1)
13958 {
13959 size_t maxlen = (end - p) - 1;
071436c6 13960
4082ef84
NC		 13961 print_symbol ((int) maxlen, (const char *) p);
13962 p += strnlen ((char *) p, maxlen) + 1;
13963 }
13964 else
13965 {
13966 printf (_("<corrupt>"));
13967 p = (unsigned char *) end;
13968 }
071436c6 13969 printf ("\"\n");
071436c6
NC		 13970 return p;
13971 }
59e6276b
JM		 13972 }
13973
f6f0e17b
NC		 13974 return display_tag_value (tag, p, end);
13975}
59e6276b 13976
f6f0e17b
NC		 13977static void
13978display_raw_attribute (unsigned char * p, unsigned char * end)
13979{
13980 unsigned long addr = 0;
13981 size_t bytes = end - p;
13982
e0a31db1 13983 assert (end > p);
f6f0e17b 13984 while (bytes)
87779176 13985 {
f6f0e17b
NC		 13986 int j;
13987 int k;
13988 int lbytes = (bytes > 16 ? 16 : bytes);
13989
13990 printf (" 0x%8.8lx ", addr);
13991
13992 for (j = 0; j < 16; j++)
13993 {
13994 if (j < lbytes)
13995 printf ("%2.2x", p[j]);
13996 else
13997 printf (" ");
13998
13999 if ((j & 3) == 3)
14000 printf (" ");
14001 }
14002
14003 for (j = 0; j < lbytes; j++)
14004 {
14005 k = p[j];
14006 if (k >= ' ' && k < 0x7f)
14007 printf ("%c", k);
14008 else
14009 printf (".");
14010 }
14011
14012 putchar ('\n');
14013
14014 p += lbytes;
14015 bytes -= lbytes;
14016 addr += lbytes;
87779176 14017 }
59e6276b 14018
f6f0e17b 14019 putchar ('\n');
59e6276b
JM		 14020}
14021
13761a11
NC		 14022static unsigned char *
14023display_msp430x_attribute (unsigned char * p,
14024 const unsigned char * const end)
14025{
14026 unsigned int len;
14027 int val;
14028 int tag;
14029
14030 tag = read_uleb128 (p, & len, end);
14031 p += len;
0b4362b0 14032
13761a11
NC		 14033 switch (tag)
14034 {
14035 case OFBA_MSPABI_Tag_ISA:
14036 val = read_uleb128 (p, &len, end);
14037 p += len;
14038 printf (" Tag_ISA: ");
14039 switch (val)
14040 {
14041 case 0: printf (_("None\n")); break;
14042 case 1: printf (_("MSP430\n")); break;
14043 case 2: printf (_("MSP430X\n")); break;
14044 default: printf ("??? (%d)\n", val); break;
14045 }
14046 break;
14047
14048 case OFBA_MSPABI_Tag_Code_Model:
14049 val = read_uleb128 (p, &len, end);
14050 p += len;
14051 printf (" Tag_Code_Model: ");
14052 switch (val)
14053 {
14054 case 0: printf (_("None\n")); break;
14055 case 1: printf (_("Small\n")); break;
14056 case 2: printf (_("Large\n")); break;
14057 default: printf ("??? (%d)\n", val); break;
14058 }
14059 break;
14060
14061 case OFBA_MSPABI_Tag_Data_Model:
14062 val = read_uleb128 (p, &len, end);
14063 p += len;
14064 printf (" Tag_Data_Model: ");
14065 switch (val)
14066 {
14067 case 0: printf (_("None\n")); break;
14068 case 1: printf (_("Small\n")); break;
14069 case 2: printf (_("Large\n")); break;
14070 case 3: printf (_("Restricted Large\n")); break;
14071 default: printf ("??? (%d)\n", val); break;
14072 }
14073 break;
14074
14075 default:
14076 printf (_(" <unknown tag %d>: "), tag);
14077
14078 if (tag & 1)
14079 {
071436c6 14080 putchar ('"');
4082ef84
NC		 14081 if (p < end - 1)
14082 {
14083 size_t maxlen = (end - p) - 1;
14084
14085 print_symbol ((int) maxlen, (const char *) p);
14086 p += strnlen ((char *) p, maxlen) + 1;
14087 }
14088 else
14089 {
14090 printf (_("<corrupt>"));
14091 p = (unsigned char *) end;
14092 }
071436c6 14093 printf ("\"\n");
13761a11
NC		 14094 }
14095 else
14096 {
14097 val = read_uleb128 (p, &len, end);
14098 p += len;
14099 printf ("%d (0x%x)\n", val, val);
14100 }
14101 break;
14102 }
14103
4082ef84 14104 assert (p <= end);
13761a11
NC		 14105 return p;
14106}
14107
11c1ff18 14108static int
60bca95a
NC		 14109process_attributes (FILE * file,
14110 const char * public_name,
104d59d1 14111 unsigned int proc_type,
f6f0e17b
NC		 14112 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
14113 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
11c1ff18 14114{
2cf0635d 14115 Elf_Internal_Shdr * sect;
11c1ff18
PB		 14116 unsigned i;
14117
14118 /* Find the section header so that we get the size. */
14119 for (i = 0, sect = section_headers;
14120 i < elf_header.e_shnum;
14121 i++, sect++)
14122 {
071436c6
NC		 14123 unsigned char * contents;
14124 unsigned char * p;
14125
104d59d1 14126 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 14127 continue;
14128
3f5e193b
NC		 14129 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
14130 sect->sh_size, _("attributes"));
60bca95a 14131 if (contents == NULL)
11c1ff18 14132 continue;
60bca95a 14133
11c1ff18
PB		 14134 p = contents;
14135 if (*p == 'A')
14136 {
071436c6
NC		 14137 bfd_vma section_len;
14138
14139 section_len = sect->sh_size - 1;
11c1ff18 14140 p++;
60bca95a 14141
071436c6 14142 while (section_len > 0)
11c1ff18 14143 {
071436c6 14144 bfd_vma attr_len;
e9847026 14145 unsigned int namelen;
11c1ff18 14146 bfd_boolean public_section;
104d59d1 14147 bfd_boolean gnu_section;
11c1ff18 14148
071436c6 14149 if (section_len <= 4)
e0a31db1
NC		 14150 {
14151 error (_("Tag section ends prematurely\n"));
14152 break;
14153 }
071436c6 14154 attr_len = byte_get (p, 4);
11c1ff18 14155 p += 4;
60bca95a 14156
071436c6 14157 if (attr_len > section_len)
11c1ff18 14158 {
071436c6
NC		 14159 error (_("Bad attribute length (%u > %u)\n"),
14160 (unsigned) attr_len, (unsigned) section_len);
14161 attr_len = section_len;
11c1ff18 14162 }
74e1a04b 14163 /* PR 17531: file: 001-101425-0.004 */
071436c6 14164 else if (attr_len < 5)
74e1a04b 14165 {
071436c6 14166 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
74e1a04b
NC		 14167 break;
14168 }
e9847026 14169
071436c6
NC		 14170 section_len -= attr_len;
14171 attr_len -= 4;
14172
14173 namelen = strnlen ((char *) p, attr_len) + 1;
14174 if (namelen == 0 || namelen >= attr_len)
e9847026
NC		 14175 {
14176 error (_("Corrupt attribute section name\n"));
14177 break;
14178 }
14179
071436c6
NC		 14180 printf (_("Attribute Section: "));
14181 print_symbol (INT_MAX, (const char *) p);
14182 putchar ('\n');
60bca95a
NC		 14183
14184 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 14185 public_section = TRUE;
14186 else
14187 public_section = FALSE;
60bca95a
NC		 14188
14189 if (streq ((char *) p, "gnu"))
104d59d1
JM		 14190 gnu_section = TRUE;
14191 else
14192 gnu_section = FALSE;
60bca95a 14193
11c1ff18 14194 p += namelen;
071436c6 14195 attr_len -= namelen;
e0a31db1 14196
071436c6 14197 while (attr_len > 0 && p < contents + sect->sh_size)
11c1ff18 14198 {
e0a31db1 14199 int tag;
11c1ff18
PB		 14200 int val;
14201 bfd_vma size;
071436c6 14202 unsigned char * end;
60bca95a 14203
e0a31db1 14204 /* PR binutils/17531: Safe handling of corrupt files. */
071436c6 14205 if (attr_len < 6)
e0a31db1
NC		 14206 {
14207 error (_("Unused bytes at end of section\n"));
14208 section_len = 0;
14209 break;
14210 }
14211
14212 tag = *(p++);
11c1ff18 14213 size = byte_get (p, 4);
071436c6 14214 if (size > attr_len)
11c1ff18 14215 {
e9847026 14216 error (_("Bad subsection length (%u > %u)\n"),
071436c6
NC		 14217 (unsigned) size, (unsigned) attr_len);
14218 size = attr_len;
11c1ff18 14219 }
e0a31db1
NC		 14220 /* PR binutils/17531: Safe handling of corrupt files. */
14221 if (size < 6)
14222 {
14223 error (_("Bad subsection length (%u < 6)\n"),
14224 (unsigned) size);
14225 section_len = 0;
14226 break;
14227 }
60bca95a 14228
071436c6 14229 attr_len -= size;
11c1ff18 14230 end = p + size - 1;
071436c6 14231 assert (end <= contents + sect->sh_size);
11c1ff18 14232 p += 4;
60bca95a 14233
11c1ff18
PB		 14234 switch (tag)
14235 {
14236 case 1:
2b692964 14237 printf (_("File Attributes\n"));
11c1ff18
PB		 14238 break;
14239 case 2:
2b692964 14240 printf (_("Section Attributes:"));
11c1ff18
PB		 14241 goto do_numlist;
14242 case 3:
2b692964 14243 printf (_("Symbol Attributes:"));
11c1ff18
PB		 14244 do_numlist:
14245 for (;;)
14246 {
91d6fa6a 14247 unsigned int j;
60bca95a 14248
f6f0e17b 14249 val = read_uleb128 (p, &j, end);
91d6fa6a 14250 p += j;
11c1ff18
PB		 14251 if (val == 0)
14252 break;
14253 printf (" %d", val);
14254 }
14255 printf ("\n");
14256 break;
14257 default:
2b692964 14258 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 14259 public_section = FALSE;
14260 break;
14261 }
60bca95a 14262
071436c6 14263 if (public_section && display_pub_attribute != NULL)
11c1ff18
PB		 14264 {
14265 while (p < end)
f6f0e17b 14266 p = display_pub_attribute (p, end);
071436c6 14267 assert (p <= end);
104d59d1 14268 }
071436c6 14269 else if (gnu_section && display_proc_gnu_attribute != NULL)
104d59d1
JM		 14270 {
14271 while (p < end)
14272 p = display_gnu_attribute (p,
f6f0e17b
NC		 14273 display_proc_gnu_attribute,
14274 end);
071436c6 14275 assert (p <= end);
11c1ff18 14276 }
071436c6 14277 else if (p < end)
11c1ff18 14278 {
071436c6 14279 printf (_(" Unknown attribute:\n"));
f6f0e17b 14280 display_raw_attribute (p, end);
11c1ff18
PB		 14281 p = end;
14282 }
071436c6
NC		 14283 else
14284 attr_len = 0;
11c1ff18
PB		 14285 }
14286 }
14287 }
14288 else
e9847026 14289 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
d70c5fc7 14290
60bca95a 14291 free (contents);
11c1ff18
PB		 14292 }
14293 return 1;
14294}
14295
104d59d1 14296static int
2cf0635d 14297process_arm_specific (FILE * file)
104d59d1
JM		 14298{
14299 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
14300 display_arm_attribute, NULL);
14301}
14302
34c8bcba 14303static int
2cf0635d 14304process_power_specific (FILE * file)
34c8bcba
JM		 14305{
14306 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14307 display_power_gnu_attribute);
14308}
14309
643f7afb
AK		 14310static int
14311process_s390_specific (FILE * file)
14312{
14313 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14314 display_s390_gnu_attribute);
14315}
14316
9e8c70f9
DM		 14317static int
14318process_sparc_specific (FILE * file)
14319{
14320 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14321 display_sparc_gnu_attribute);
14322}
14323
59e6276b
JM		 14324static int
14325process_tic6x_specific (FILE * file)
14326{
14327 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
14328 display_tic6x_attribute, NULL);
14329}
14330
13761a11
NC		 14331static int
14332process_msp430x_specific (FILE * file)
14333{
14334 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
14335 display_msp430x_attribute, NULL);
14336}
14337
ccb4c951
RS		 14338/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14339 Print the Address, Access and Initial fields of an entry at VMA ADDR
82b1b41b
NC		 14340 and return the VMA of the next entry, or -1 if there was a problem.
14341 Does not read from DATA_END or beyond. */
ccb4c951
RS		 14342
14343static bfd_vma
82b1b41b
NC		 14344print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
14345 unsigned char * data_end)
ccb4c951
RS		 14346{
14347 printf (" ");
14348 print_vma (addr, LONG_HEX);
14349 printf (" ");
14350 if (addr < pltgot + 0xfff0)
14351 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
14352 else
14353 printf ("%10s", "");
14354 printf (" ");
14355 if (data == NULL)
2b692964 14356 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 14357 else
14358 {
14359 bfd_vma entry;
82b1b41b 14360 unsigned char * from = data + addr - pltgot;
ccb4c951 14361
82b1b41b
NC		 14362 if (from + (is_32bit_elf ? 4 : 8) > data_end)
14363 {
14364 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14365 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
14366 return (bfd_vma) -1;
14367 }
14368 else
14369 {
14370 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14371 print_vma (entry, LONG_HEX);
14372 }
ccb4c951
RS		 14373 }
14374 return addr + (is_32bit_elf ? 4 : 8);
14375}
14376
861fb55a
DJ		 14377/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14378 PLTGOT. Print the Address and Initial fields of an entry at VMA
14379 ADDR and return the VMA of the next entry. */
14380
14381static bfd_vma
2cf0635d 14382print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 14383{
14384 printf (" ");
14385 print_vma (addr, LONG_HEX);
14386 printf (" ");
14387 if (data == NULL)
2b692964 14388 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 14389 else
14390 {
14391 bfd_vma entry;
14392
14393 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14394 print_vma (entry, LONG_HEX);
14395 }
14396 return addr + (is_32bit_elf ? 4 : 8);
14397}
14398
351cdf24
MF		 14399static void
14400print_mips_ases (unsigned int mask)
14401{
14402 if (mask & AFL_ASE_DSP)
14403 fputs ("\n\tDSP ASE", stdout);
14404 if (mask & AFL_ASE_DSPR2)
14405 fputs ("\n\tDSP R2 ASE", stdout);
8f4f9071
MF		 14406 if (mask & AFL_ASE_DSPR3)
14407 fputs ("\n\tDSP R3 ASE", stdout);
351cdf24
MF		 14408 if (mask & AFL_ASE_EVA)
14409 fputs ("\n\tEnhanced VA Scheme", stdout);
14410 if (mask & AFL_ASE_MCU)
14411 fputs ("\n\tMCU (MicroController) ASE", stdout);
14412 if (mask & AFL_ASE_MDMX)
14413 fputs ("\n\tMDMX ASE", stdout);
14414 if (mask & AFL_ASE_MIPS3D)
14415 fputs ("\n\tMIPS-3D ASE", stdout);
14416 if (mask & AFL_ASE_MT)
14417 fputs ("\n\tMT ASE", stdout);
14418 if (mask & AFL_ASE_SMARTMIPS)
14419 fputs ("\n\tSmartMIPS ASE", stdout);
14420 if (mask & AFL_ASE_VIRT)
14421 fputs ("\n\tVZ ASE", stdout);
14422 if (mask & AFL_ASE_MSA)
14423 fputs ("\n\tMSA ASE", stdout);
14424 if (mask & AFL_ASE_MIPS16)
14425 fputs ("\n\tMIPS16 ASE", stdout);
14426 if (mask & AFL_ASE_MICROMIPS)
14427 fputs ("\n\tMICROMIPS ASE", stdout);
14428 if (mask & AFL_ASE_XPA)
14429 fputs ("\n\tXPA ASE", stdout);
14430 if (mask == 0)
14431 fprintf (stdout, "\n\t%s", _("None"));
00ac7aa0
MF		 14432 else if ((mask & ~AFL_ASE_MASK) != 0)
14433 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
351cdf24
MF		 14434}
14435
14436static void
14437print_mips_isa_ext (unsigned int isa_ext)
14438{
14439 switch (isa_ext)
14440 {
14441 case 0:
14442 fputs (_("None"), stdout);
14443 break;
14444 case AFL_EXT_XLR:
14445 fputs ("RMI XLR", stdout);
14446 break;
2c629856
N		 14447 case AFL_EXT_OCTEON3:
14448 fputs ("Cavium Networks Octeon3", stdout);
14449 break;
351cdf24
MF		 14450 case AFL_EXT_OCTEON2:
14451 fputs ("Cavium Networks Octeon2", stdout);
14452 break;
14453 case AFL_EXT_OCTEONP:
14454 fputs ("Cavium Networks OcteonP", stdout);
14455 break;
14456 case AFL_EXT_LOONGSON_3A:
14457 fputs ("Loongson 3A", stdout);
14458 break;
14459 case AFL_EXT_OCTEON:
14460 fputs ("Cavium Networks Octeon", stdout);
14461 break;
14462 case AFL_EXT_5900:
14463 fputs ("Toshiba R5900", stdout);
14464 break;
14465 case AFL_EXT_4650:
14466 fputs ("MIPS R4650", stdout);
14467 break;
14468 case AFL_EXT_4010:
14469 fputs ("LSI R4010", stdout);
14470 break;
14471 case AFL_EXT_4100:
14472 fputs ("NEC VR4100", stdout);
14473 break;
14474 case AFL_EXT_3900:
14475 fputs ("Toshiba R3900", stdout);
14476 break;
14477 case AFL_EXT_10000:
14478 fputs ("MIPS R10000", stdout);
14479 break;
14480 case AFL_EXT_SB1:
14481 fputs ("Broadcom SB-1", stdout);
14482 break;
14483 case AFL_EXT_4111:
14484 fputs ("NEC VR4111/VR4181", stdout);
14485 break;
14486 case AFL_EXT_4120:
14487 fputs ("NEC VR4120", stdout);
14488 break;
14489 case AFL_EXT_5400:
14490 fputs ("NEC VR5400", stdout);
14491 break;
14492 case AFL_EXT_5500:
14493 fputs ("NEC VR5500", stdout);
14494 break;
14495 case AFL_EXT_LOONGSON_2E:
14496 fputs ("ST Microelectronics Loongson 2E", stdout);
14497 break;
14498 case AFL_EXT_LOONGSON_2F:
14499 fputs ("ST Microelectronics Loongson 2F", stdout);
14500 break;
14501 default:
00ac7aa0 14502 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
351cdf24
MF		 14503 }
14504}
14505
14506static int
14507get_mips_reg_size (int reg_size)
14508{
14509 return (reg_size == AFL_REG_NONE) ? 0
14510 : (reg_size == AFL_REG_32) ? 32
14511 : (reg_size == AFL_REG_64) ? 64
14512 : (reg_size == AFL_REG_128) ? 128
14513 : -1;
14514}
14515
19e6b90e 14516static int
2cf0635d 14517process_mips_specific (FILE * file)
5b18a4bc 14518{
2cf0635d 14519 Elf_Internal_Dyn * entry;
351cdf24 14520 Elf_Internal_Shdr *sect = NULL;
19e6b90e
L		 14521 size_t liblist_offset = 0;
14522 size_t liblistno = 0;
14523 size_t conflictsno = 0;
14524 size_t options_offset = 0;
14525 size_t conflicts_offset = 0;
861fb55a
DJ		 14526 size_t pltrelsz = 0;
14527 size_t pltrel = 0;
ccb4c951 14528 bfd_vma pltgot = 0;
861fb55a
DJ		 14529 bfd_vma mips_pltgot = 0;
14530 bfd_vma jmprel = 0;
ccb4c951
RS		 14531 bfd_vma local_gotno = 0;
14532 bfd_vma gotsym = 0;
14533 bfd_vma symtabno = 0;
103f02d3 14534
2cf19d5c
JM		 14535 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14536 display_mips_gnu_attribute);
14537
351cdf24
MF		 14538 sect = find_section (".MIPS.abiflags");
14539
14540 if (sect != NULL)
14541 {
14542 Elf_External_ABIFlags_v0 *abiflags_ext;
14543 Elf_Internal_ABIFlags_v0 abiflags_in;
14544
14545 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
14546 fputs ("\nCorrupt ABI Flags section.\n", stdout);
14547 else
14548 {
14549 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
14550 sect->sh_size, _("MIPS ABI Flags section"));
14551 if (abiflags_ext)
14552 {
14553 abiflags_in.version = BYTE_GET (abiflags_ext->version);
14554 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
14555 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
14556 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
14557 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
14558 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
14559 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
14560 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
14561 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
14562 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
14563 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
14564
14565 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
14566 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
14567 if (abiflags_in.isa_rev > 1)
14568 printf ("r%d", abiflags_in.isa_rev);
14569 printf ("\nGPR size: %d",
14570 get_mips_reg_size (abiflags_in.gpr_size));
14571 printf ("\nCPR1 size: %d",
14572 get_mips_reg_size (abiflags_in.cpr1_size));
14573 printf ("\nCPR2 size: %d",
14574 get_mips_reg_size (abiflags_in.cpr2_size));
14575 fputs ("\nFP ABI: ", stdout);
14576 print_mips_fp_abi_value (abiflags_in.fp_abi);
14577 fputs ("ISA Extension: ", stdout);
14578 print_mips_isa_ext (abiflags_in.isa_ext);
14579 fputs ("\nASEs:", stdout);
14580 print_mips_ases (abiflags_in.ases);
14581 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
14582 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
14583 fputc ('\n', stdout);
14584 free (abiflags_ext);
14585 }
14586 }
14587 }
14588
19e6b90e
L		 14589 /* We have a lot of special sections. Thanks SGI! */
14590 if (dynamic_section == NULL)
14591 /* No information available. */
14592 return 0;
252b5132 14593
071436c6
NC		 14594 for (entry = dynamic_section;
14595 /* PR 17531 file: 012-50589-0.004. */
14596 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
14597 ++entry)
252b5132
RH		 14598 switch (entry->d_tag)
14599 {
14600 case DT_MIPS_LIBLIST:
d93f0186
NC		 14601 liblist_offset
14602 = offset_from_vma (file, entry->d_un.d_val,
14603 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 14604 break;
14605 case DT_MIPS_LIBLISTNO:
14606 liblistno = entry->d_un.d_val;
14607 break;
14608 case DT_MIPS_OPTIONS:
d93f0186 14609 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 14610 break;
14611 case DT_MIPS_CONFLICT:
d93f0186
NC		 14612 conflicts_offset
14613 = offset_from_vma (file, entry->d_un.d_val,
14614 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 14615 break;
14616 case DT_MIPS_CONFLICTNO:
14617 conflictsno = entry->d_un.d_val;
14618 break;
ccb4c951 14619 case DT_PLTGOT:
861fb55a
DJ		 14620 pltgot = entry->d_un.d_ptr;
14621 break;
ccb4c951
RS		 14622 case DT_MIPS_LOCAL_GOTNO:
14623 local_gotno = entry->d_un.d_val;
14624 break;
14625 case DT_MIPS_GOTSYM:
14626 gotsym = entry->d_un.d_val;
14627 break;
14628 case DT_MIPS_SYMTABNO:
14629 symtabno = entry->d_un.d_val;
14630 break;
861fb55a
DJ		 14631 case DT_MIPS_PLTGOT:
14632 mips_pltgot = entry->d_un.d_ptr;
14633 break;
14634 case DT_PLTREL:
14635 pltrel = entry->d_un.d_val;
14636 break;
14637 case DT_PLTRELSZ:
14638 pltrelsz = entry->d_un.d_val;
14639 break;
14640 case DT_JMPREL:
14641 jmprel = entry->d_un.d_ptr;
14642 break;
252b5132
RH		 14643 default:
14644 break;
14645 }
14646
14647 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
14648 {
2cf0635d 14649 Elf32_External_Lib * elib;
252b5132
RH		 14650 size_t cnt;
14651
3f5e193b
NC		 14652 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
14653 liblistno,
14654 sizeof (Elf32_External_Lib),
9cf03b7e 14655 _("liblist section data"));
a6e9f9df 14656 if (elib)
252b5132 14657 {
2b692964 14658 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 14659 (unsigned long) liblistno);
2b692964 14660 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 14661 stdout);
14662
14663 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 14664 {
a6e9f9df 14665 Elf32_Lib liblist;
91d6fa6a 14666 time_t atime;
d5b07ef4 14667 char timebuf[128];
2cf0635d 14668 struct tm * tmp;
a6e9f9df
AM		 14669
14670 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14671 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 14672 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14673 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14674 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14675
91d6fa6a 14676 tmp = gmtime (&atime);
e9e44622
JJ		 14677 snprintf (timebuf, sizeof (timebuf),
14678 "%04u-%02u-%02uT%02u:%02u:%02u",
14679 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14680 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 14681
31104126 14682 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 14683 if (VALID_DYNAMIC_NAME (liblist.l_name))
14684 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
14685 else
2b692964 14686 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 14687 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
14688 liblist.l_version);
a6e9f9df
AM		 14689
14690 if (liblist.l_flags == 0)
2b692964 14691 puts (_(" NONE"));
a6e9f9df
AM		 14692 else
14693 {
14694 static const struct
252b5132 14695 {
2cf0635d 14696 const char * name;
a6e9f9df 14697 int bit;
252b5132 14698 }
a6e9f9df
AM		 14699 l_flags_vals[] =
14700 {
14701 { " EXACT_MATCH", LL_EXACT_MATCH },
14702 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
14703 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
14704 { " EXPORTS", LL_EXPORTS },
14705 { " DELAY_LOAD", LL_DELAY_LOAD },
14706 { " DELTA", LL_DELTA }
14707 };
14708 int flags = liblist.l_flags;
14709 size_t fcnt;
14710
60bca95a 14711 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 14712 if ((flags & l_flags_vals[fcnt].bit) != 0)
14713 {
14714 fputs (l_flags_vals[fcnt].name, stdout);
14715 flags ^= l_flags_vals[fcnt].bit;
14716 }
14717 if (flags != 0)
14718 printf (" %#x", (unsigned int) flags);
252b5132 14719
a6e9f9df
AM		 14720 puts ("");
14721 }
252b5132 14722 }
252b5132 14723
a6e9f9df
AM		 14724 free (elib);
14725 }
252b5132
RH		 14726 }
14727
14728 if (options_offset != 0)
14729 {
2cf0635d 14730 Elf_External_Options * eopt;
2cf0635d
NC		 14731 Elf_Internal_Options * iopt;
14732 Elf_Internal_Options * option;
252b5132
RH		 14733 size_t offset;
14734 int cnt;
351cdf24 14735 sect = section_headers;
252b5132
RH		 14736
14737 /* Find the section header so that we get the size. */
071436c6 14738 sect = find_section_by_type (SHT_MIPS_OPTIONS);
948f632f 14739 /* PR 17533 file: 012-277276-0.004. */
071436c6
NC		 14740 if (sect == NULL)
14741 {
14742 error (_("No MIPS_OPTIONS header found\n"));
14743 return 0;
14744 }
252b5132 14745
3f5e193b
NC		 14746 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
14747 sect->sh_size, _("options"));
a6e9f9df 14748 if (eopt)
252b5132 14749 {
3f5e193b
NC		 14750 iopt = (Elf_Internal_Options *)
14751 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 14752 if (iopt == NULL)
14753 {
fb324ee9 14754 error (_("Out of memory allocating space for MIPS options\n"));
a6e9f9df
AM		 14755 return 0;
14756 }
76da6bbe 14757
a6e9f9df
AM		 14758 offset = cnt = 0;
14759 option = iopt;
252b5132 14760
82b1b41b 14761 while (offset <= sect->sh_size - sizeof (* eopt))
a6e9f9df 14762 {
2cf0635d 14763 Elf_External_Options * eoption;
252b5132 14764
a6e9f9df 14765 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 14766
a6e9f9df
AM		 14767 option->kind = BYTE_GET (eoption->kind);
14768 option->size = BYTE_GET (eoption->size);
14769 option->section = BYTE_GET (eoption->section);
14770 option->info = BYTE_GET (eoption->info);
76da6bbe 14771
82b1b41b
NC		 14772 /* PR 17531: file: ffa0fa3b. */
14773 if (option->size < sizeof (* eopt)
14774 || offset + option->size > sect->sh_size)
14775 {
55325047
NC		 14776 error (_("Invalid size (%u) for MIPS option\n"), option->size);
14777 return 0;
82b1b41b 14778 }
a6e9f9df 14779 offset += option->size;
14ae95f2 14780
a6e9f9df
AM		 14781 ++option;
14782 ++cnt;
14783 }
252b5132 14784
a6e9f9df 14785 printf (_("\nSection '%s' contains %d entries:\n"),
74e1a04b 14786 printable_section_name (sect), cnt);
76da6bbe 14787
a6e9f9df 14788 option = iopt;
82b1b41b 14789 offset = 0;
252b5132 14790
a6e9f9df 14791 while (cnt-- > 0)
252b5132 14792 {
a6e9f9df
AM		 14793 size_t len;
14794
14795 switch (option->kind)
252b5132 14796 {
a6e9f9df
AM		 14797 case ODK_NULL:
14798 /* This shouldn't happen. */
14799 printf (" NULL %d %lx", option->section, option->info);
14800 break;
14801 case ODK_REGINFO:
14802 printf (" REGINFO ");
14803 if (elf_header.e_machine == EM_MIPS)
14804 {
14805 /* 32bit form. */
2cf0635d 14806 Elf32_External_RegInfo * ereg;
b34976b6 14807 Elf32_RegInfo reginfo;
a6e9f9df
AM		 14808
14809 ereg = (Elf32_External_RegInfo *) (option + 1);
14810 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14811 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14812 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14813 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14814 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14815 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14816
14817 printf ("GPR %08lx GP 0x%lx\n",
14818 reginfo.ri_gprmask,
14819 (unsigned long) reginfo.ri_gp_value);
14820 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14821 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14822 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14823 }
14824 else
14825 {
14826 /* 64 bit form. */
2cf0635d 14827 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 14828 Elf64_Internal_RegInfo reginfo;
14829
14830 ereg = (Elf64_External_RegInfo *) (option + 1);
14831 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14832 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14833 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14834 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14835 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 14836 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 14837
14838 printf ("GPR %08lx GP 0x",
14839 reginfo.ri_gprmask);
14840 printf_vma (reginfo.ri_gp_value);
14841 printf ("\n");
14842
14843 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14844 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14845 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14846 }
14847 ++option;
14848 continue;
14849 case ODK_EXCEPTIONS:
14850 fputs (" EXCEPTIONS fpe_min(", stdout);
14851 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
14852 fputs (") fpe_max(", stdout);
14853 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
14854 fputs (")", stdout);
14855
14856 if (option->info & OEX_PAGE0)
14857 fputs (" PAGE0", stdout);
14858 if (option->info & OEX_SMM)
14859 fputs (" SMM", stdout);
14860 if (option->info & OEX_FPDBUG)
14861 fputs (" FPDBUG", stdout);
14862 if (option->info & OEX_DISMISS)
14863 fputs (" DISMISS", stdout);
14864 break;
14865 case ODK_PAD:
14866 fputs (" PAD ", stdout);
14867 if (option->info & OPAD_PREFIX)
14868 fputs (" PREFIX", stdout);
14869 if (option->info & OPAD_POSTFIX)
14870 fputs (" POSTFIX", stdout);
14871 if (option->info & OPAD_SYMBOL)
14872 fputs (" SYMBOL", stdout);
14873 break;
14874 case ODK_HWPATCH:
14875 fputs (" HWPATCH ", stdout);
14876 if (option->info & OHW_R4KEOP)
14877 fputs (" R4KEOP", stdout);
14878 if (option->info & OHW_R8KPFETCH)
14879 fputs (" R8KPFETCH", stdout);
14880 if (option->info & OHW_R5KEOP)
14881 fputs (" R5KEOP", stdout);
14882 if (option->info & OHW_R5KCVTL)
14883 fputs (" R5KCVTL", stdout);
14884 break;
14885 case ODK_FILL:
14886 fputs (" FILL ", stdout);
14887 /* XXX Print content of info word? */
14888 break;
14889 case ODK_TAGS:
14890 fputs (" TAGS ", stdout);
14891 /* XXX Print content of info word? */
14892 break;
14893 case ODK_HWAND:
14894 fputs (" HWAND ", stdout);
14895 if (option->info & OHWA0_R4KEOP_CHECKED)
14896 fputs (" R4KEOP_CHECKED", stdout);
14897 if (option->info & OHWA0_R4KEOP_CLEAN)
14898 fputs (" R4KEOP_CLEAN", stdout);
14899 break;
14900 case ODK_HWOR:
14901 fputs (" HWOR ", stdout);
14902 if (option->info & OHWA0_R4KEOP_CHECKED)
14903 fputs (" R4KEOP_CHECKED", stdout);
14904 if (option->info & OHWA0_R4KEOP_CLEAN)
14905 fputs (" R4KEOP_CLEAN", stdout);
14906 break;
14907 case ODK_GP_GROUP:
14908 printf (" GP_GROUP %#06lx self-contained %#06lx",
14909 option->info & OGP_GROUP,
14910 (option->info & OGP_SELF) >> 16);
14911 break;
14912 case ODK_IDENT:
14913 printf (" IDENT %#06lx self-contained %#06lx",
14914 option->info & OGP_GROUP,
14915 (option->info & OGP_SELF) >> 16);
14916 break;
14917 default:
14918 /* This shouldn't happen. */
14919 printf (" %3d ??? %d %lx",
14920 option->kind, option->section, option->info);
14921 break;
252b5132 14922 }
a6e9f9df 14923
2cf0635d 14924 len = sizeof (* eopt);
a6e9f9df 14925 while (len < option->size)
82b1b41b 14926 {
7e27a9d5 14927 unsigned char datum = * ((unsigned char *) eopt + offset + len);
a6e9f9df 14928
82b1b41b
NC		 14929 if (ISPRINT (datum))
14930 printf ("%c", datum);
14931 else
14932 printf ("\\%03o", datum);
14933 len ++;
14934 }
a6e9f9df 14935 fputs ("\n", stdout);
82b1b41b
NC		 14936
14937 offset += option->size;
252b5132 14938 ++option;
252b5132
RH		 14939 }
14940
a6e9f9df 14941 free (eopt);
252b5132 14942 }
252b5132
RH		 14943 }
14944
14945 if (conflicts_offset != 0 && conflictsno != 0)
14946 {
2cf0635d 14947 Elf32_Conflict * iconf;
252b5132
RH		 14948 size_t cnt;
14949
14950 if (dynamic_symbols == NULL)
14951 {
591a748a 14952 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 14953 return 0;
14954 }
14955
3f5e193b 14956 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 14957 if (iconf == NULL)
14958 {
8b73c356 14959 error (_("Out of memory allocating space for dynamic conflicts\n"));
252b5132
RH		 14960 return 0;
14961 }
14962
9ea033b2 14963 if (is_32bit_elf)
252b5132 14964 {
2cf0635d 14965 Elf32_External_Conflict * econf32;
a6e9f9df 14966
3f5e193b
NC		 14967 econf32 = (Elf32_External_Conflict *)
14968 get_data (NULL, file, conflicts_offset, conflictsno,
14969 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 14970 if (!econf32)
14971 return 0;
252b5132
RH		 14972
14973 for (cnt = 0; cnt < conflictsno; ++cnt)
14974 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 14975
14976 free (econf32);
252b5132
RH		 14977 }
14978 else
14979 {
2cf0635d 14980 Elf64_External_Conflict * econf64;
a6e9f9df 14981
3f5e193b
NC		 14982 econf64 = (Elf64_External_Conflict *)
14983 get_data (NULL, file, conflicts_offset, conflictsno,
14984 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 14985 if (!econf64)
14986 return 0;
252b5132
RH		 14987
14988 for (cnt = 0; cnt < conflictsno; ++cnt)
14989 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 14990
14991 free (econf64);
252b5132
RH		 14992 }
14993
c7e7ca54
NC		 14994 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14995 (unsigned long) conflictsno);
252b5132
RH		 14996 puts (_(" Num: Index Value Name"));
14997
14998 for (cnt = 0; cnt < conflictsno; ++cnt)
14999 {
b34976b6 15000 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
e0a31db1
NC		 15001
15002 if (iconf[cnt] >= num_dynamic_syms)
15003 printf (_("<corrupt symbol index>"));
d79b3d50 15004 else
e0a31db1
NC		 15005 {
15006 Elf_Internal_Sym * psym;
15007
15008 psym = & dynamic_symbols[iconf[cnt]];
15009 print_vma (psym->st_value, FULL_HEX);
15010 putchar (' ');
15011 if (VALID_DYNAMIC_NAME (psym->st_name))
15012 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
15013 else
15014 printf (_("<corrupt: %14ld>"), psym->st_name);
15015 }
31104126 15016 putchar ('\n');
252b5132
RH		 15017 }
15018
252b5132
RH		 15019 free (iconf);
15020 }
15021
ccb4c951
RS		 15022 if (pltgot != 0 && local_gotno != 0)
15023 {
91d6fa6a 15024 bfd_vma ent, local_end, global_end;
bbeee7ea 15025 size_t i, offset;
2cf0635d 15026 unsigned char * data;
82b1b41b 15027 unsigned char * data_end;
bbeee7ea 15028 int addr_size;
ccb4c951 15029
91d6fa6a 15030 ent = pltgot;
ccb4c951
RS		 15031 addr_size = (is_32bit_elf ? 4 : 8);
15032 local_end = pltgot + local_gotno * addr_size;
ccb4c951 15033
74e1a04b
NC		 15034 /* PR binutils/17533 file: 012-111227-0.004 */
15035 if (symtabno < gotsym)
15036 {
15037 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
82b1b41b 15038 (unsigned long) gotsym, (unsigned long) symtabno);
74e1a04b
NC		 15039 return 0;
15040 }
82b1b41b 15041
74e1a04b 15042 global_end = local_end + (symtabno - gotsym) * addr_size;
82b1b41b
NC		 15043 /* PR 17531: file: 54c91a34. */
15044 if (global_end < local_end)
15045 {
15046 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
15047 return 0;
15048 }
948f632f 15049
ccb4c951 15050 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 15051 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 15052 global_end - pltgot, 1,
15053 _("Global Offset Table data"));
59245841
NC		 15054 if (data == NULL)
15055 return 0;
82b1b41b 15056 data_end = data + (global_end - pltgot);
59245841 15057
ccb4c951
RS		 15058 printf (_("\nPrimary GOT:\n"));
15059 printf (_(" Canonical gp value: "));
15060 print_vma (pltgot + 0x7ff0, LONG_HEX);
15061 printf ("\n\n");
15062
15063 printf (_(" Reserved entries:\n"));
15064 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 15065 addr_size * 2, _("Address"), _("Access"),
15066 addr_size * 2, _("Initial"));
82b1b41b 15067 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 15068 printf (_(" Lazy resolver\n"));
82b1b41b
NC		 15069 if (ent == (bfd_vma) -1)
15070 goto got_print_fail;
ccb4c951 15071 if (data
91d6fa6a 15072 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 15073 >> (addr_size * 8 - 1)) != 0)
15074 {
82b1b41b 15075 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 15076 printf (_(" Module pointer (GNU extension)\n"));
82b1b41b
NC		 15077 if (ent == (bfd_vma) -1)
15078 goto got_print_fail;
ccb4c951
RS		 15079 }
15080 printf ("\n");
15081
91d6fa6a 15082 if (ent < local_end)
ccb4c951
RS		 15083 {
15084 printf (_(" Local entries:\n"));
cc5914eb 15085 printf (" %*s %10s %*s\n",
2b692964
NC		 15086 addr_size * 2, _("Address"), _("Access"),
15087 addr_size * 2, _("Initial"));
91d6fa6a 15088 while (ent < local_end)
ccb4c951 15089 {
82b1b41b 15090 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 15091 printf ("\n");
82b1b41b
NC		 15092 if (ent == (bfd_vma) -1)
15093 goto got_print_fail;
ccb4c951
RS		 15094 }
15095 printf ("\n");
15096 }
15097
15098 if (gotsym < symtabno)
15099 {
15100 int sym_width;
15101
15102 printf (_(" Global entries:\n"));
cc5914eb 15103 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 15104 addr_size * 2, _("Address"),
15105 _("Access"),
2b692964 15106 addr_size * 2, _("Initial"),
9cf03b7e
NC		 15107 addr_size * 2, _("Sym.Val."),
15108 _("Type"),
15109 /* Note for translators: "Ndx" = abbreviated form of "Index". */
15110 _("Ndx"), _("Name"));
0b4362b0 15111
ccb4c951 15112 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
e0a31db1 15113
ccb4c951
RS		 15114 for (i = gotsym; i < symtabno; i++)
15115 {
82b1b41b 15116 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 15117 printf (" ");
e0a31db1
NC		 15118
15119 if (dynamic_symbols == NULL)
15120 printf (_("<no dynamic symbols>"));
15121 else if (i < num_dynamic_syms)
15122 {
15123 Elf_Internal_Sym * psym = dynamic_symbols + i;
15124
15125 print_vma (psym->st_value, LONG_HEX);
15126 printf (" %-7s %3s ",
15127 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
15128 get_symbol_index_type (psym->st_shndx));
15129
15130 if (VALID_DYNAMIC_NAME (psym->st_name))
15131 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
15132 else
15133 printf (_("<corrupt: %14ld>"), psym->st_name);
15134 }
ccb4c951 15135 else
7fc5ac57
JBG		 15136 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15137 (unsigned long) i);
e0a31db1 15138
ccb4c951 15139 printf ("\n");
82b1b41b
NC		 15140 if (ent == (bfd_vma) -1)
15141 break;
ccb4c951
RS		 15142 }
15143 printf ("\n");
15144 }
15145
82b1b41b 15146 got_print_fail:
ccb4c951
RS		 15147 if (data)
15148 free (data);
15149 }
15150
861fb55a
DJ		 15151 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
15152 {
91d6fa6a 15153 bfd_vma ent, end;
861fb55a
DJ		 15154 size_t offset, rel_offset;
15155 unsigned long count, i;
2cf0635d 15156 unsigned char * data;
861fb55a 15157 int addr_size, sym_width;
2cf0635d 15158 Elf_Internal_Rela * rels;
861fb55a
DJ		 15159
15160 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
15161 if (pltrel == DT_RELA)
15162 {
15163 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
15164 return 0;
15165 }
15166 else
15167 {
15168 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
15169 return 0;
15170 }
15171
91d6fa6a 15172 ent = mips_pltgot;
861fb55a
DJ		 15173 addr_size = (is_32bit_elf ? 4 : 8);
15174 end = mips_pltgot + (2 + count) * addr_size;
15175
15176 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 15177 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 15178 1, _("Procedure Linkage Table data"));
59245841
NC		 15179 if (data == NULL)
15180 return 0;
15181
9cf03b7e 15182 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 15183 printf (_(" Reserved entries:\n"));
15184 printf (_(" %*s %*s Purpose\n"),
2b692964 15185 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 15186 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 15187 printf (_(" PLT lazy resolver\n"));
91d6fa6a 15188 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 15189 printf (_(" Module pointer\n"));
861fb55a
DJ		 15190 printf ("\n");
15191
15192 printf (_(" Entries:\n"));
cc5914eb 15193 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 15194 addr_size * 2, _("Address"),
15195 addr_size * 2, _("Initial"),
15196 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 15197 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
15198 for (i = 0; i < count; i++)
15199 {
df97ab2a 15200 unsigned long idx = get_reloc_symindex (rels[i].r_info);
861fb55a 15201
91d6fa6a 15202 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a 15203 printf (" ");
e0a31db1 15204
df97ab2a
MF		 15205 if (idx >= num_dynamic_syms)
15206 printf (_("<corrupt symbol index: %lu>"), idx);
861fb55a 15207 else
e0a31db1 15208 {
df97ab2a 15209 Elf_Internal_Sym * psym = dynamic_symbols + idx;
e0a31db1
NC		 15210
15211 print_vma (psym->st_value, LONG_HEX);
15212 printf (" %-7s %3s ",
15213 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
15214 get_symbol_index_type (psym->st_shndx));
15215 if (VALID_DYNAMIC_NAME (psym->st_name))
15216 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
15217 else
15218 printf (_("<corrupt: %14ld>"), psym->st_name);
15219 }
861fb55a
DJ		 15220 printf ("\n");
15221 }
15222 printf ("\n");
15223
15224 if (data)
15225 free (data);
15226 free (rels);
15227 }
15228
252b5132
RH		 15229 return 1;
15230}
15231
35c08157
KLC		 15232static int
15233process_nds32_specific (FILE * file)
15234{
15235 Elf_Internal_Shdr *sect = NULL;
15236
15237 sect = find_section (".nds32_e_flags");
15238 if (sect != NULL)
15239 {
15240 unsigned int *flag;
15241
15242 printf ("\nNDS32 elf flags section:\n");
15243 flag = get_data (NULL, file, sect->sh_offset, 1,
15244 sect->sh_size, _("NDS32 elf flags section"));
15245
15246 switch ((*flag) & 0x3)
15247 {
15248 case 0:
15249 printf ("(VEC_SIZE):\tNo entry.\n");
15250 break;
15251 case 1:
15252 printf ("(VEC_SIZE):\t4 bytes\n");
15253 break;
15254 case 2:
15255 printf ("(VEC_SIZE):\t16 bytes\n");
15256 break;
15257 case 3:
15258 printf ("(VEC_SIZE):\treserved\n");
15259 break;
15260 }
15261 }
15262
15263 return TRUE;
15264}
15265
047b2264 15266static int
2cf0635d 15267process_gnu_liblist (FILE * file)
047b2264 15268{
2cf0635d
NC		 15269 Elf_Internal_Shdr * section;
15270 Elf_Internal_Shdr * string_sec;
15271 Elf32_External_Lib * elib;
15272 char * strtab;
c256ffe7 15273 size_t strtab_size;
047b2264
JJ		 15274 size_t cnt;
15275 unsigned i;
15276
15277 if (! do_arch)
15278 return 0;
15279
15280 for (i = 0, section = section_headers;
15281 i < elf_header.e_shnum;
b34976b6 15282 i++, section++)
047b2264
JJ		 15283 {
15284 switch (section->sh_type)
15285 {
15286 case SHT_GNU_LIBLIST:
4fbb74a6 15287 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 15288 break;
15289
3f5e193b
NC		 15290 elib = (Elf32_External_Lib *)
15291 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 15292 _("liblist section data"));
047b2264
JJ		 15293
15294 if (elib == NULL)
15295 break;
4fbb74a6 15296 string_sec = section_headers + section->sh_link;
047b2264 15297
3f5e193b
NC		 15298 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
15299 string_sec->sh_size,
15300 _("liblist string table"));
047b2264
JJ		 15301 if (strtab == NULL
15302 || section->sh_entsize != sizeof (Elf32_External_Lib))
15303 {
15304 free (elib);
2842702f 15305 free (strtab);
047b2264
JJ		 15306 break;
15307 }
59245841 15308 strtab_size = string_sec->sh_size;
047b2264
JJ		 15309
15310 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
74e1a04b 15311 printable_section_name (section),
0af1713e 15312 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 15313
2b692964 15314 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 15315
15316 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
15317 ++cnt)
15318 {
15319 Elf32_Lib liblist;
91d6fa6a 15320 time_t atime;
d5b07ef4 15321 char timebuf[128];
2cf0635d 15322 struct tm * tmp;
047b2264
JJ		 15323
15324 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 15325 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 15326 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15327 liblist.l_version = BYTE_GET (elib[cnt].l_version);
15328 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15329
91d6fa6a 15330 tmp = gmtime (&atime);
e9e44622
JJ		 15331 snprintf (timebuf, sizeof (timebuf),
15332 "%04u-%02u-%02uT%02u:%02u:%02u",
15333 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15334 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 15335
15336 printf ("%3lu: ", (unsigned long) cnt);
15337 if (do_wide)
c256ffe7 15338 printf ("%-20s", liblist.l_name < strtab_size
2b692964 15339 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 15340 else
c256ffe7 15341 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 15342 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 15343 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
15344 liblist.l_version, liblist.l_flags);
15345 }
15346
15347 free (elib);
2842702f 15348 free (strtab);
047b2264
JJ		 15349 }
15350 }
15351
15352 return 1;
15353}
15354
9437c45b 15355static const char *
d3ba0551 15356get_note_type (unsigned e_type)
779fe533
NC		 15357{
15358 static char buff[64];
103f02d3 15359
1ec5cd37
NC		 15360 if (elf_header.e_type == ET_CORE)
15361 switch (e_type)
15362 {
57346661 15363 case NT_AUXV:
1ec5cd37 15364 return _("NT_AUXV (auxiliary vector)");
57346661 15365 case NT_PRSTATUS:
1ec5cd37 15366 return _("NT_PRSTATUS (prstatus structure)");
57346661 15367 case NT_FPREGSET:
1ec5cd37 15368 return _("NT_FPREGSET (floating point registers)");
57346661 15369 case NT_PRPSINFO:
1ec5cd37 15370 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 15371 case NT_TASKSTRUCT:
1ec5cd37 15372 return _("NT_TASKSTRUCT (task structure)");
57346661 15373 case NT_PRXFPREG:
1ec5cd37 15374 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 15375 case NT_PPC_VMX:
15376 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 15377 case NT_PPC_VSX:
15378 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 15379 case NT_386_TLS:
15380 return _("NT_386_TLS (x86 TLS information)");
15381 case NT_386_IOPERM:
15382 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 15383 case NT_X86_XSTATE:
15384 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 15385 case NT_S390_HIGH_GPRS:
15386 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 15387 case NT_S390_TIMER:
15388 return _("NT_S390_TIMER (s390 timer register)");
15389 case NT_S390_TODCMP:
15390 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15391 case NT_S390_TODPREG:
15392 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15393 case NT_S390_CTRS:
15394 return _("NT_S390_CTRS (s390 control registers)");
15395 case NT_S390_PREFIX:
15396 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 15397 case NT_S390_LAST_BREAK:
15398 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15399 case NT_S390_SYSTEM_CALL:
15400 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC		 15401 case NT_S390_TDB:
15402 return _("NT_S390_TDB (s390 transaction diagnostic block)");
4ef9f41a
AA		 15403 case NT_S390_VXRS_LOW:
15404 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15405 case NT_S390_VXRS_HIGH:
15406 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
faa9a424
UW		 15407 case NT_ARM_VFP:
15408 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 15409 case NT_ARM_TLS:
15410 return _("NT_ARM_TLS (AArch TLS registers)");
15411 case NT_ARM_HW_BREAK:
15412 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15413 case NT_ARM_HW_WATCH:
15414 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 15415 case NT_PSTATUS:
1ec5cd37 15416 return _("NT_PSTATUS (pstatus structure)");
57346661 15417 case NT_FPREGS:
1ec5cd37 15418 return _("NT_FPREGS (floating point registers)");
57346661 15419 case NT_PSINFO:
1ec5cd37 15420 return _("NT_PSINFO (psinfo structure)");
57346661 15421 case NT_LWPSTATUS:
1ec5cd37 15422 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 15423 case NT_LWPSINFO:
1ec5cd37 15424 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 15425 case NT_WIN32PSTATUS:
1ec5cd37 15426 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 15427 case NT_SIGINFO:
15428 return _("NT_SIGINFO (siginfo_t data)");
15429 case NT_FILE:
15430 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 15431 default:
15432 break;
15433 }
15434 else
15435 switch (e_type)
15436 {
15437 case NT_VERSION:
15438 return _("NT_VERSION (version)");
15439 case NT_ARCH:
15440 return _("NT_ARCH (architecture)");
15441 default:
15442 break;
15443 }
15444
e9e44622 15445 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 15446 return buff;
779fe533
NC		 15447}
15448
9ece1fa9
TT		 15449static int
15450print_core_note (Elf_Internal_Note *pnote)
15451{
15452 unsigned int addr_size = is_32bit_elf ? 4 : 8;
15453 bfd_vma count, page_size;
15454 unsigned char *descdata, *filenames, *descend;
15455
15456 if (pnote->type != NT_FILE)
15457 return 1;
15458
15459#ifndef BFD64
15460 if (!is_32bit_elf)
15461 {
15462 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15463 /* Still "successful". */
15464 return 1;
15465 }
15466#endif
15467
15468 if (pnote->descsz < 2 * addr_size)
15469 {
15470 printf (_(" Malformed note - too short for header\n"));
15471 return 0;
15472 }
15473
15474 descdata = (unsigned char *) pnote->descdata;
15475 descend = descdata + pnote->descsz;
15476
15477 if (descdata[pnote->descsz - 1] != '\0')
15478 {
15479 printf (_(" Malformed note - does not end with \\0\n"));
15480 return 0;
15481 }
15482
15483 count = byte_get (descdata, addr_size);
15484 descdata += addr_size;
15485
15486 page_size = byte_get (descdata, addr_size);
15487 descdata += addr_size;
15488
15489 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
15490 {
15491 printf (_(" Malformed note - too short for supplied file count\n"));
15492 return 0;
15493 }
15494
15495 printf (_(" Page size: "));
15496 print_vma (page_size, DEC);
15497 printf ("\n");
15498
15499 printf (_(" %*s%*s%*s\n"),
15500 (int) (2 + 2 * addr_size), _("Start"),
15501 (int) (4 + 2 * addr_size), _("End"),
15502 (int) (4 + 2 * addr_size), _("Page Offset"));
15503 filenames = descdata + count * 3 * addr_size;
595712bb 15504 while (count-- > 0)
9ece1fa9
TT		 15505 {
15506 bfd_vma start, end, file_ofs;
15507
15508 if (filenames == descend)
15509 {
15510 printf (_(" Malformed note - filenames end too early\n"));
15511 return 0;
15512 }
15513
15514 start = byte_get (descdata, addr_size);
15515 descdata += addr_size;
15516 end = byte_get (descdata, addr_size);
15517 descdata += addr_size;
15518 file_ofs = byte_get (descdata, addr_size);
15519 descdata += addr_size;
15520
15521 printf (" ");
15522 print_vma (start, FULL_HEX);
15523 printf (" ");
15524 print_vma (end, FULL_HEX);
15525 printf (" ");
15526 print_vma (file_ofs, FULL_HEX);
15527 printf ("\n %s\n", filenames);
15528
15529 filenames += 1 + strlen ((char *) filenames);
15530 }
15531
15532 return 1;
15533}
15534
1118d252
RM		 15535static const char *
15536get_gnu_elf_note_type (unsigned e_type)
15537{
15538 static char buff[64];
15539
15540 switch (e_type)
15541 {
15542 case NT_GNU_ABI_TAG:
15543 return _("NT_GNU_ABI_TAG (ABI version tag)");
15544 case NT_GNU_HWCAP:
15545 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15546 case NT_GNU_BUILD_ID:
15547 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 15548 case NT_GNU_GOLD_VERSION:
15549 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 15550 default:
15551 break;
15552 }
15553
15554 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15555 return buff;
15556}
15557
664f90a3
TT		 15558static int
15559print_gnu_note (Elf_Internal_Note *pnote)
15560{
15561 switch (pnote->type)
15562 {
15563 case NT_GNU_BUILD_ID:
15564 {
15565 unsigned long i;
15566
15567 printf (_(" Build ID: "));
15568 for (i = 0; i < pnote->descsz; ++i)
15569 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 15570 printf ("\n");
664f90a3
TT		 15571 }
15572 break;
15573
15574 case NT_GNU_ABI_TAG:
15575 {
15576 unsigned long os, major, minor, subminor;
15577 const char *osname;
15578
3102e897
NC		 15579 /* PR 17531: file: 030-599401-0.004. */
15580 if (pnote->descsz < 16)
15581 {
15582 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15583 break;
15584 }
15585
664f90a3
TT		 15586 os = byte_get ((unsigned char *) pnote->descdata, 4);
15587 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
15588 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
15589 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
15590
15591 switch (os)
15592 {
15593 case GNU_ABI_TAG_LINUX:
15594 osname = "Linux";
15595 break;
15596 case GNU_ABI_TAG_HURD:
15597 osname = "Hurd";
15598 break;
15599 case GNU_ABI_TAG_SOLARIS:
15600 osname = "Solaris";
15601 break;
15602 case GNU_ABI_TAG_FREEBSD:
15603 osname = "FreeBSD";
15604 break;
15605 case GNU_ABI_TAG_NETBSD:
15606 osname = "NetBSD";
15607 break;
14ae95f2
RM		 15608 case GNU_ABI_TAG_SYLLABLE:
15609 osname = "Syllable";
15610 break;
15611 case GNU_ABI_TAG_NACL:
15612 osname = "NaCl";
15613 break;
664f90a3
TT		 15614 default:
15615 osname = "Unknown";
15616 break;
15617 }
15618
15619 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
15620 major, minor, subminor);
15621 }
15622 break;
926c5385
CC		 15623
15624 case NT_GNU_GOLD_VERSION:
15625 {
15626 unsigned long i;
15627
15628 printf (_(" Version: "));
15629 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
15630 printf ("%c", pnote->descdata[i]);
15631 printf ("\n");
15632 }
15633 break;
664f90a3
TT		 15634 }
15635
15636 return 1;
15637}
15638
685080f2
NC		 15639static const char *
15640get_v850_elf_note_type (enum v850_notes n_type)
15641{
15642 static char buff[64];
15643
15644 switch (n_type)
15645 {
15646 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
15647 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
15648 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
15649 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
15650 case V850_NOTE_CACHE_INFO: return _("Use of cache");
15651 case V850_NOTE_MMU_INFO: return _("Use of MMU");
15652 default:
15653 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
15654 return buff;
15655 }
15656}
15657
15658static int
15659print_v850_note (Elf_Internal_Note * pnote)
15660{
15661 unsigned int val;
15662
15663 if (pnote->descsz != 4)
15664 return 0;
15665 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
15666
15667 if (val == 0)
15668 {
15669 printf (_("not set\n"));
15670 return 1;
15671 }
15672
15673 switch (pnote->type)
15674 {
15675 case V850_NOTE_ALIGNMENT:
15676 switch (val)
15677 {
15678 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
15679 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
15680 }
15681 break;
14ae95f2 15682
685080f2
NC		 15683 case V850_NOTE_DATA_SIZE:
15684 switch (val)
15685 {
15686 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
15687 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
15688 }
15689 break;
14ae95f2 15690
685080f2
NC		 15691 case V850_NOTE_FPU_INFO:
15692 switch (val)
15693 {
15694 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
15695 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
15696 }
15697 break;
14ae95f2 15698
685080f2
NC		 15699 case V850_NOTE_MMU_INFO:
15700 case V850_NOTE_CACHE_INFO:
15701 case V850_NOTE_SIMD_INFO:
15702 if (val == EF_RH850_SIMD)
15703 {
15704 printf (_("yes\n"));
15705 return 1;
15706 }
15707 break;
15708
15709 default:
15710 /* An 'unknown note type' message will already have been displayed. */
15711 break;
15712 }
15713
15714 printf (_("unknown value: %x\n"), val);
15715 return 0;
15716}
15717
c6056a74
SF		 15718static int
15719process_netbsd_elf_note (Elf_Internal_Note * pnote)
15720{
15721 unsigned int version;
15722
15723 switch (pnote->type)
15724 {
15725 case NT_NETBSD_IDENT:
15726 version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
15727 if ((version / 10000) % 100)
15728 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
15729 version, version / 100000000, (version / 1000000) % 100,
15730 (version / 10000) % 100 > 26 ? "Z" : "",
15731 'A' + (version / 10000) % 26);
15732 else
15733 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
15734 version, version / 100000000, (version / 1000000) % 100,
15735 (version / 100) % 100);
15736 return 1;
15737
15738 case NT_NETBSD_MARCH:
15739 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
15740 pnote->descdata);
15741 return 1;
15742
15743 default:
15744 break;
15745 }
15746
15747 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
15748 pnote->type);
15749 return 1;
15750}
15751
f4ddf30f
JB		 15752static const char *
15753get_freebsd_elfcore_note_type (unsigned e_type)
15754{
f4ddf30f
JB		 15755 switch (e_type)
15756 {
15757 case NT_FREEBSD_THRMISC:
15758 return _("NT_THRMISC (thrmisc structure)");
15759 case NT_FREEBSD_PROCSTAT_PROC:
15760 return _("NT_PROCSTAT_PROC (proc data)");
15761 case NT_FREEBSD_PROCSTAT_FILES:
15762 return _("NT_PROCSTAT_FILES (files data)");
15763 case NT_FREEBSD_PROCSTAT_VMMAP:
15764 return _("NT_PROCSTAT_VMMAP (vmmap data)");
15765 case NT_FREEBSD_PROCSTAT_GROUPS:
15766 return _("NT_PROCSTAT_GROUPS (groups data)");
15767 case NT_FREEBSD_PROCSTAT_UMASK:
15768 return _("NT_PROCSTAT_UMASK (umask data)");
15769 case NT_FREEBSD_PROCSTAT_RLIMIT:
15770 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
15771 case NT_FREEBSD_PROCSTAT_OSREL:
15772 return _("NT_PROCSTAT_OSREL (osreldate data)");
15773 case NT_FREEBSD_PROCSTAT_PSSTRINGS:
15774 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
15775 case NT_FREEBSD_PROCSTAT_AUXV:
15776 return _("NT_PROCSTAT_AUXV (auxv data)");
15777 }
15778 return get_note_type (e_type);
15779}
15780
9437c45b 15781static const char *
d3ba0551 15782get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 15783{
15784 static char buff[64];
15785
b4db1224 15786 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 15787 {
15788 /* NetBSD core "procinfo" structure. */
15789 return _("NetBSD procinfo structure");
15790 }
15791
15792 /* As of Jan 2002 there are no other machine-independent notes
15793 defined for NetBSD core files. If the note type is less
15794 than the start of the machine-dependent note types, we don't
15795 understand it. */
15796
b4db1224 15797 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 15798 {
e9e44622 15799 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 15800 return buff;
15801 }
15802
15803 switch (elf_header.e_machine)
15804 {
15805 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15806 and PT_GETFPREGS == mach+2. */
15807
15808 case EM_OLD_ALPHA:
15809 case EM_ALPHA:
15810 case EM_SPARC:
15811 case EM_SPARC32PLUS:
15812 case EM_SPARCV9:
15813 switch (e_type)
15814 {
2b692964 15815 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 15816 return _("PT_GETREGS (reg structure)");
2b692964 15817 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 15818 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15819 default:
15820 break;
15821 }
15822 break;
15823
15824 /* On all other arch's, PT_GETREGS == mach+1 and
15825 PT_GETFPREGS == mach+3. */
15826 default:
15827 switch (e_type)
15828 {
2b692964 15829 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 15830 return _("PT_GETREGS (reg structure)");
2b692964 15831 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 15832 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15833 default:
15834 break;
15835 }
15836 }
15837
9cf03b7e 15838 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 15839 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 15840 return buff;
15841}
15842
70616151
TT		 15843static const char *
15844get_stapsdt_note_type (unsigned e_type)
15845{
15846 static char buff[64];
15847
15848 switch (e_type)
15849 {
15850 case NT_STAPSDT:
15851 return _("NT_STAPSDT (SystemTap probe descriptors)");
15852
15853 default:
15854 break;
15855 }
15856
15857 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15858 return buff;
15859}
15860
c6a9fc58
TT		 15861static int
15862print_stapsdt_note (Elf_Internal_Note *pnote)
15863{
15864 int addr_size = is_32bit_elf ? 4 : 8;
15865 char *data = pnote->descdata;
15866 char *data_end = pnote->descdata + pnote->descsz;
15867 bfd_vma pc, base_addr, semaphore;
15868 char *provider, *probe, *arg_fmt;
15869
15870 pc = byte_get ((unsigned char *) data, addr_size);
15871 data += addr_size;
15872 base_addr = byte_get ((unsigned char *) data, addr_size);
15873 data += addr_size;
15874 semaphore = byte_get ((unsigned char *) data, addr_size);
15875 data += addr_size;
15876
15877 provider = data;
15878 data += strlen (data) + 1;
15879 probe = data;
15880 data += strlen (data) + 1;
15881 arg_fmt = data;
15882 data += strlen (data) + 1;
15883
15884 printf (_(" Provider: %s\n"), provider);
15885 printf (_(" Name: %s\n"), probe);
15886 printf (_(" Location: "));
15887 print_vma (pc, FULL_HEX);
15888 printf (_(", Base: "));
15889 print_vma (base_addr, FULL_HEX);
15890 printf (_(", Semaphore: "));
15891 print_vma (semaphore, FULL_HEX);
9cf03b7e 15892 printf ("\n");
c6a9fc58
TT		 15893 printf (_(" Arguments: %s\n"), arg_fmt);
15894
15895 return data == data_end;
15896}
15897
00e98fc7
TG		 15898static const char *
15899get_ia64_vms_note_type (unsigned e_type)
15900{
15901 static char buff[64];
15902
15903 switch (e_type)
15904 {
15905 case NT_VMS_MHD:
15906 return _("NT_VMS_MHD (module header)");
15907 case NT_VMS_LNM:
15908 return _("NT_VMS_LNM (language name)");
15909 case NT_VMS_SRC:
15910 return _("NT_VMS_SRC (source files)");
15911 case NT_VMS_TITLE:
9cf03b7e 15912 return "NT_VMS_TITLE";
00e98fc7
TG		 15913 case NT_VMS_EIDC:
15914 return _("NT_VMS_EIDC (consistency check)");
15915 case NT_VMS_FPMODE:
15916 return _("NT_VMS_FPMODE (FP mode)");
15917 case NT_VMS_LINKTIME:
9cf03b7e 15918 return "NT_VMS_LINKTIME";
00e98fc7
TG		 15919 case NT_VMS_IMGNAM:
15920 return _("NT_VMS_IMGNAM (image name)");
15921 case NT_VMS_IMGID:
15922 return _("NT_VMS_IMGID (image id)");
15923 case NT_VMS_LINKID:
15924 return _("NT_VMS_LINKID (link id)");
15925 case NT_VMS_IMGBID:
15926 return _("NT_VMS_IMGBID (build id)");
15927 case NT_VMS_GSTNAM:
15928 return _("NT_VMS_GSTNAM (sym table name)");
15929 case NT_VMS_ORIG_DYN:
9cf03b7e 15930 return "NT_VMS_ORIG_DYN";
00e98fc7 15931 case NT_VMS_PATCHTIME:
9cf03b7e 15932 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 15933 default:
15934 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15935 return buff;
15936 }
15937}
15938
15939static int
15940print_ia64_vms_note (Elf_Internal_Note * pnote)
15941{
15942 switch (pnote->type)
15943 {
15944 case NT_VMS_MHD:
15945 if (pnote->descsz > 36)
15946 {
15947 size_t l = strlen (pnote->descdata + 34);
15948 printf (_(" Creation date : %.17s\n"), pnote->descdata);
15949 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
15950 printf (_(" Module name : %s\n"), pnote->descdata + 34);
15951 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
15952 }
15953 else
15954 printf (_(" Invalid size\n"));
15955 break;
15956 case NT_VMS_LNM:
15957 printf (_(" Language: %s\n"), pnote->descdata);
15958 break;
15959#ifdef BFD64
15960 case NT_VMS_FPMODE:
9cf03b7e 15961 printf (_(" Floating Point mode: "));
4a5cb34f 15962 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15963 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
00e98fc7
TG		 15964 break;
15965 case NT_VMS_LINKTIME:
15966 printf (_(" Link time: "));
15967 print_vms_time
15968 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15969 printf ("\n");
15970 break;
15971 case NT_VMS_PATCHTIME:
15972 printf (_(" Patch time: "));
15973 print_vms_time
15974 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15975 printf ("\n");
15976 break;
15977 case NT_VMS_ORIG_DYN:
15978 printf (_(" Major id: %u, minor id: %u\n"),
15979 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
15980 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 15981 printf (_(" Last modified : "));
00e98fc7
TG		 15982 print_vms_time
15983 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 15984 printf (_("\n Link flags : "));
4a5cb34f 15985 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15986 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
00e98fc7 15987 printf (_(" Header flags: 0x%08x\n"),
948f632f 15988 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
00e98fc7
TG		 15989 printf (_(" Image id : %s\n"), pnote->descdata + 32);
15990 break;
15991#endif
15992 case NT_VMS_IMGNAM:
15993 printf (_(" Image name: %s\n"), pnote->descdata);
15994 break;
15995 case NT_VMS_GSTNAM:
15996 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
15997 break;
15998 case NT_VMS_IMGID:
15999 printf (_(" Image id: %s\n"), pnote->descdata);
16000 break;
16001 case NT_VMS_LINKID:
16002 printf (_(" Linker id: %s\n"), pnote->descdata);
16003 break;
16004 default:
16005 break;
16006 }
16007 return 1;
16008}
16009
6d118b09
NC		 16010/* Note that by the ELF standard, the name field is already null byte
16011 terminated, and namesz includes the terminating null byte.
16012 I.E. the value of namesz for the name "FSF" is 4.
16013
e3c8793a 16014 If the value of namesz is zero, there is no name present. */
779fe533 16015static int
2cf0635d 16016process_note (Elf_Internal_Note * pnote)
779fe533 16017{
2cf0635d
NC		 16018 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
16019 const char * nt;
9437c45b
JT		 16020
16021 if (pnote->namesz == 0)
1ec5cd37
NC		 16022 /* If there is no note name, then use the default set of
16023 note type strings. */
16024 nt = get_note_type (pnote->type);
16025
1118d252
RM		 16026 else if (const_strneq (pnote->namedata, "GNU"))
16027 /* GNU-specific object file notes. */
16028 nt = get_gnu_elf_note_type (pnote->type);
f4ddf30f
JB		 16029
16030 else if (const_strneq (pnote->namedata, "FreeBSD"))
16031 /* FreeBSD-specific core file notes. */
16032 nt = get_freebsd_elfcore_note_type (pnote->type);
1118d252 16033
0112cd26 16034 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 16035 /* NetBSD-specific core file notes. */
16036 nt = get_netbsd_elfcore_note_type (pnote->type);
16037
c6056a74
SF		 16038 else if (const_strneq (pnote->namedata, "NetBSD"))
16039 /* NetBSD-specific core file notes. */
16040 return process_netbsd_elf_note (pnote);
16041
b15fa79e
AM		 16042 else if (strneq (pnote->namedata, "SPU/", 4))
16043 {
16044 /* SPU-specific core file notes. */
16045 nt = pnote->namedata + 4;
16046 name = "SPU";
16047 }
16048
00e98fc7
TG		 16049 else if (const_strneq (pnote->namedata, "IPF/VMS"))
16050 /* VMS/ia64-specific file notes. */
16051 nt = get_ia64_vms_note_type (pnote->type);
16052
70616151
TT		 16053 else if (const_strneq (pnote->namedata, "stapsdt"))
16054 nt = get_stapsdt_note_type (pnote->type);
16055
9437c45b 16056 else
1ec5cd37
NC		 16057 /* Don't recognize this note name; just use the default set of
16058 note type strings. */
00e98fc7 16059 nt = get_note_type (pnote->type);
9437c45b 16060
2aee03ae 16061 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 16062
16063 if (const_strneq (pnote->namedata, "IPF/VMS"))
16064 return print_ia64_vms_note (pnote);
664f90a3
TT		 16065 else if (const_strneq (pnote->namedata, "GNU"))
16066 return print_gnu_note (pnote);
c6a9fc58
TT		 16067 else if (const_strneq (pnote->namedata, "stapsdt"))
16068 return print_stapsdt_note (pnote);
9ece1fa9
TT		 16069 else if (const_strneq (pnote->namedata, "CORE"))
16070 return print_core_note (pnote);
00e98fc7
TG		 16071 else
16072 return 1;
779fe533
NC		 16073}
16074
6d118b09 16075
779fe533 16076static int
2cf0635d 16077process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 16078{
2cf0635d
NC		 16079 Elf_External_Note * pnotes;
16080 Elf_External_Note * external;
c8071705 16081 char * end;
b34976b6 16082 int res = 1;
103f02d3 16083
779fe533
NC		 16084 if (length <= 0)
16085 return 0;
103f02d3 16086
3f5e193b 16087 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15b42fb0 16088 _("notes"));
dd24e3da 16089 if (pnotes == NULL)
a6e9f9df 16090 return 0;
779fe533 16091
103f02d3 16092 external = pnotes;
103f02d3 16093
9dd3a467 16094 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 16095 (unsigned long) offset, (unsigned long) length);
2aee03ae 16096 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 16097
c8071705
NC		 16098 end = (char *) pnotes + length;
16099 while ((char *) external < end)
779fe533 16100 {
b34976b6 16101 Elf_Internal_Note inote;
15b42fb0
AM		 16102 size_t min_notesz;
16103 char *next;
2cf0635d 16104 char * temp = NULL;
c8071705 16105 size_t data_remaining = end - (char *) external;
6d118b09 16106
00e98fc7 16107 if (!is_ia64_vms ())
15b42fb0 16108 {
9dd3a467
NC		 16109 /* PR binutils/15191
16110 Make sure that there is enough data to read. */
15b42fb0
AM		 16111 min_notesz = offsetof (Elf_External_Note, name);
16112 if (data_remaining < min_notesz)
9dd3a467
NC		 16113 {
16114 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
16115 (int) data_remaining);
16116 break;
16117 }
15b42fb0
AM		 16118 inote.type = BYTE_GET (external->type);
16119 inote.namesz = BYTE_GET (external->namesz);
16120 inote.namedata = external->name;
16121 inote.descsz = BYTE_GET (external->descsz);
16122 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
834f871c 16123 /* PR 17531: file: 3443835e. */
c8071705 16124 if (inote.descdata < (char *) pnotes || inote.descdata > end)
834f871c
NC		 16125 {
16126 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
16127 inote.descdata = inote.namedata;
16128 inote.namesz = 0;
16129 }
14ae95f2 16130
15b42fb0
AM		 16131 inote.descpos = offset + (inote.descdata - (char *) pnotes);
16132 next = inote.descdata + align_power (inote.descsz, 2);
16133 }
00e98fc7 16134 else
15b42fb0
AM		 16135 {
16136 Elf64_External_VMS_Note *vms_external;
00e98fc7 16137
9dd3a467
NC		 16138 /* PR binutils/15191
16139 Make sure that there is enough data to read. */
15b42fb0
AM		 16140 min_notesz = offsetof (Elf64_External_VMS_Note, name);
16141 if (data_remaining < min_notesz)
9dd3a467
NC		 16142 {
16143 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
16144 (int) data_remaining);
16145 break;
16146 }
3e55a963 16147
15b42fb0
AM		 16148 vms_external = (Elf64_External_VMS_Note *) external;
16149 inote.type = BYTE_GET (vms_external->type);
16150 inote.namesz = BYTE_GET (vms_external->namesz);
16151 inote.namedata = vms_external->name;
16152 inote.descsz = BYTE_GET (vms_external->descsz);
16153 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
16154 inote.descpos = offset + (inote.descdata - (char *) pnotes);
16155 next = inote.descdata + align_power (inote.descsz, 3);
16156 }
16157
16158 if (inote.descdata < (char *) external + min_notesz
16159 || next < (char *) external + min_notesz
5d921cbd
NC		 16160 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
16161 || inote.namedata + inote.namesz < inote.namedata
16162 || inote.descdata + inote.descsz < inote.descdata
15b42fb0 16163 || data_remaining < (size_t)(next - (char *) external))
3e55a963 16164 {
15b42fb0 16165 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 16166 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 16167 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC		 16168 inote.type, inote.namesz, inote.descsz);
16169 break;
16170 }
16171
15b42fb0 16172 external = (Elf_External_Note *) next;
dd24e3da 16173
6d118b09
NC		 16174 /* Verify that name is null terminated. It appears that at least
16175 one version of Linux (RedHat 6.0) generates corefiles that don't
16176 comply with the ELF spec by failing to include the null byte in
16177 namesz. */
8b971f9f 16178 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 16179 {
3f5e193b 16180 temp = (char *) malloc (inote.namesz + 1);
6d118b09
NC		 16181 if (temp == NULL)
16182 {
8b73c356 16183 error (_("Out of memory allocating space for inote name\n"));
6d118b09
NC		 16184 res = 0;
16185 break;
16186 }
76da6bbe 16187
6d118b09
NC		 16188 strncpy (temp, inote.namedata, inote.namesz);
16189 temp[inote.namesz] = 0;
76da6bbe 16190
6d118b09
NC		 16191 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
16192 inote.namedata = temp;
16193 }
16194
16195 res &= process_note (& inote);
103f02d3 16196
6d118b09
NC		 16197 if (temp != NULL)
16198 {
16199 free (temp);
16200 temp = NULL;
16201 }
779fe533
NC		 16202 }
16203
16204 free (pnotes);
103f02d3 16205
779fe533
NC		 16206 return res;
16207}
16208
16209static int
2cf0635d 16210process_corefile_note_segments (FILE * file)
779fe533 16211{
2cf0635d 16212 Elf_Internal_Phdr * segment;
b34976b6
AM		 16213 unsigned int i;
16214 int res = 1;
103f02d3 16215
d93f0186 16216 if (! get_program_headers (file))
779fe533 16217 return 0;
103f02d3 16218
779fe533
NC		 16219 for (i = 0, segment = program_headers;
16220 i < elf_header.e_phnum;
b34976b6 16221 i++, segment++)
779fe533
NC		 16222 {
16223 if (segment->p_type == PT_NOTE)
103f02d3 16224 res &= process_corefile_note_segment (file,
30800947
NC		 16225 (bfd_vma) segment->p_offset,
16226 (bfd_vma) segment->p_filesz);
779fe533 16227 }
103f02d3 16228
779fe533
NC		 16229 return res;
16230}
16231
685080f2
NC		 16232static int
16233process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
16234{
16235 Elf_External_Note * pnotes;
16236 Elf_External_Note * external;
c8071705 16237 char * end;
685080f2
NC		 16238 int res = 1;
16239
16240 if (length <= 0)
16241 return 0;
16242
16243 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
16244 _("v850 notes"));
16245 if (pnotes == NULL)
16246 return 0;
16247
16248 external = pnotes;
c8071705 16249 end = (char*) pnotes + length;
685080f2
NC		 16250
16251 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
16252 (unsigned long) offset, (unsigned long) length);
16253
c8071705 16254 while ((char *) external + sizeof (Elf_External_Note) < end)
685080f2
NC		 16255 {
16256 Elf_External_Note * next;
16257 Elf_Internal_Note inote;
16258
16259 inote.type = BYTE_GET (external->type);
16260 inote.namesz = BYTE_GET (external->namesz);
16261 inote.namedata = external->name;
16262 inote.descsz = BYTE_GET (external->descsz);
16263 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
16264 inote.descpos = offset + (inote.descdata - (char *) pnotes);
16265
c8071705
NC		 16266 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
16267 {
16268 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
16269 inote.descdata = inote.namedata;
16270 inote.namesz = 0;
16271 }
16272
685080f2
NC		 16273 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
16274
c8071705 16275 if ( ((char *) next > end)
685080f2
NC		 16276 || ((char *) next < (char *) pnotes))
16277 {
16278 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
16279 (unsigned long) ((char *) external - (char *) pnotes));
16280 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16281 inote.type, inote.namesz, inote.descsz);
16282 break;
16283 }
16284
16285 external = next;
16286
16287 /* Prevent out-of-bounds indexing. */
c8071705 16288 if ( inote.namedata + inote.namesz > end
685080f2
NC		 16289 || inote.namedata + inote.namesz < inote.namedata)
16290 {
16291 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
16292 (unsigned long) ((char *) external - (char *) pnotes));
16293 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16294 inote.type, inote.namesz, inote.descsz);
16295 break;
16296 }
16297
16298 printf (" %s: ", get_v850_elf_note_type (inote.type));
16299
16300 if (! print_v850_note (& inote))
16301 {
16302 res = 0;
16303 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
16304 inote.namesz, inote.descsz);
16305 }
16306 }
16307
16308 free (pnotes);
16309
16310 return res;
16311}
16312
779fe533 16313static int
2cf0635d 16314process_note_sections (FILE * file)
1ec5cd37 16315{
2cf0635d 16316 Elf_Internal_Shdr * section;
1ec5cd37 16317 unsigned long i;
df565f32 16318 int n = 0;
1ec5cd37
NC		 16319 int res = 1;
16320
16321 for (i = 0, section = section_headers;
fa1908fd 16322 i < elf_header.e_shnum && section != NULL;
1ec5cd37 16323 i++, section++)
685080f2
NC		 16324 {
16325 if (section->sh_type == SHT_NOTE)
16326 {
16327 res &= process_corefile_note_segment (file,
16328 (bfd_vma) section->sh_offset,
16329 (bfd_vma) section->sh_size);
16330 n++;
16331 }
16332
16333 if (( elf_header.e_machine == EM_V800
16334 || elf_header.e_machine == EM_V850
16335 || elf_header.e_machine == EM_CYGNUS_V850)
16336 && section->sh_type == SHT_RENESAS_INFO)
16337 {
16338 res &= process_v850_notes (file,
16339 (bfd_vma) section->sh_offset,
16340 (bfd_vma) section->sh_size);
16341 n++;
16342 }
16343 }
df565f32
NC		 16344
16345 if (n == 0)
16346 /* Try processing NOTE segments instead. */
16347 return process_corefile_note_segments (file);
1ec5cd37
NC		 16348
16349 return res;
16350}
16351
16352static int
2cf0635d 16353process_notes (FILE * file)
779fe533
NC		 16354{
16355 /* If we have not been asked to display the notes then do nothing. */
16356 if (! do_notes)
16357 return 1;
103f02d3 16358
779fe533 16359 if (elf_header.e_type != ET_CORE)
1ec5cd37 16360 return process_note_sections (file);
103f02d3 16361
779fe533 16362 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 16363 if (elf_header.e_phnum > 0)
16364 return process_corefile_note_segments (file);
779fe533 16365
1ec5cd37
NC		 16366 printf (_("No note segments present in the core file.\n"));
16367 return 1;
779fe533
NC		 16368}
16369
252b5132 16370static int
2cf0635d 16371process_arch_specific (FILE * file)
252b5132 16372{
a952a375
NC		 16373 if (! do_arch)
16374 return 1;
16375
252b5132
RH		 16376 switch (elf_header.e_machine)
16377 {
11c1ff18
PB		 16378 case EM_ARM:
16379 return process_arm_specific (file);
252b5132 16380 case EM_MIPS:
4fe85591 16381 case EM_MIPS_RS3_LE:
252b5132
RH		 16382 return process_mips_specific (file);
16383 break;
35c08157
KLC		 16384 case EM_NDS32:
16385 return process_nds32_specific (file);
16386 break;
34c8bcba 16387 case EM_PPC:
b82317dd 16388 case EM_PPC64:
34c8bcba
JM		 16389 return process_power_specific (file);
16390 break;
643f7afb
AK		 16391 case EM_S390:
16392 case EM_S390_OLD:
16393 return process_s390_specific (file);
16394 break;
9e8c70f9
DM		 16395 case EM_SPARC:
16396 case EM_SPARC32PLUS:
16397 case EM_SPARCV9:
16398 return process_sparc_specific (file);
16399 break;
59e6276b
JM		 16400 case EM_TI_C6000:
16401 return process_tic6x_specific (file);
16402 break;
13761a11
NC		 16403 case EM_MSP430:
16404 return process_msp430x_specific (file);
252b5132
RH		 16405 default:
16406 break;
16407 }
16408 return 1;
16409}
16410
16411static int
2cf0635d 16412get_file_header (FILE * file)
252b5132 16413{
9ea033b2
NC		 16414 /* Read in the identity array. */
16415 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 16416 return 0;
16417
9ea033b2 16418 /* Determine how to read the rest of the header. */
b34976b6 16419 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 16420 {
16421 default: /* fall through */
16422 case ELFDATANONE: /* fall through */
adab8cdc
AO		 16423 case ELFDATA2LSB:
16424 byte_get = byte_get_little_endian;
16425 byte_put = byte_put_little_endian;
16426 break;
16427 case ELFDATA2MSB:
16428 byte_get = byte_get_big_endian;
16429 byte_put = byte_put_big_endian;
16430 break;
9ea033b2
NC		 16431 }
16432
16433 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 16434 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 16435
16436 /* Read in the rest of the header. */
16437 if (is_32bit_elf)
16438 {
16439 Elf32_External_Ehdr ehdr32;
252b5132 16440
9ea033b2
NC		 16441 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
16442 return 0;
103f02d3 16443
9ea033b2
NC		 16444 elf_header.e_type = BYTE_GET (ehdr32.e_type);
16445 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
16446 elf_header.e_version = BYTE_GET (ehdr32.e_version);
16447 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
16448 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
16449 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
16450 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
16451 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
16452 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
16453 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
16454 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
16455 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
16456 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
16457 }
252b5132 16458 else
9ea033b2
NC		 16459 {
16460 Elf64_External_Ehdr ehdr64;
a952a375
NC		 16461
16462 /* If we have been compiled with sizeof (bfd_vma) == 4, then
16463 we will not be able to cope with the 64bit data found in
16464 64 ELF files. Detect this now and abort before we start
50c2245b 16465 overwriting things. */
a952a375
NC		 16466 if (sizeof (bfd_vma) < 8)
16467 {
e3c8793a
NC		 16468 error (_("This instance of readelf has been built without support for a\n\
1646964 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 16470 return 0;
16471 }
103f02d3 16472
9ea033b2
NC		 16473 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
16474 return 0;
103f02d3 16475
9ea033b2
NC		 16476 elf_header.e_type = BYTE_GET (ehdr64.e_type);
16477 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
16478 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 16479 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
16480 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
16481 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 16482 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
16483 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
16484 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
16485 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
16486 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
16487 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
16488 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
16489 }
252b5132 16490
7ece0d85
JJ		 16491 if (elf_header.e_shoff)
16492 {
16493 /* There may be some extensions in the first section header. Don't
16494 bomb if we can't read it. */
16495 if (is_32bit_elf)
049b0c3a 16496 get_32bit_section_headers (file, TRUE);
7ece0d85 16497 else
049b0c3a 16498 get_64bit_section_headers (file, TRUE);
7ece0d85 16499 }
560f3c1c 16500
252b5132
RH		 16501 return 1;
16502}
16503
fb52b2f4
NC		 16504/* Process one ELF object file according to the command line options.
16505 This file may actually be stored in an archive. The file is
16506 positioned at the start of the ELF object. */
16507
ff78d6d6 16508static int
2cf0635d 16509process_object (char * file_name, FILE * file)
252b5132 16510{
252b5132
RH		 16511 unsigned int i;
16512
252b5132
RH		 16513 if (! get_file_header (file))
16514 {
16515 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 16516 return 1;
252b5132
RH		 16517 }
16518
16519 /* Initialise per file variables. */
60bca95a 16520 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 16521 version_info[i] = 0;
16522
60bca95a 16523 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 16524 dynamic_info[i] = 0;
5115b233 16525 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 16526
16527 /* Process the file. */
16528 if (show_name)
16529 printf (_("\nFile: %s\n"), file_name);
16530
18bd398b
NC		 16531 /* Initialise the dump_sects array from the cmdline_dump_sects array.
16532 Note we do this even if cmdline_dump_sects is empty because we
16533 must make sure that the dump_sets array is zeroed out before each
16534 object file is processed. */
16535 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 16536 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 16537
16538 if (num_cmdline_dump_sects > 0)
16539 {
16540 if (num_dump_sects == 0)
16541 /* A sneaky way of allocating the dump_sects array. */
09c11c86 16542 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 16543
16544 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 16545 memcpy (dump_sects, cmdline_dump_sects,
16546 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 16547 }
d70c5fc7 16548
252b5132 16549 if (! process_file_header ())
fb52b2f4 16550 return 1;
252b5132 16551
d1f5c6e3 16552 if (! process_section_headers (file))
2f62977e 16553 {
d1f5c6e3
L		 16554 /* Without loaded section headers we cannot process lots of
16555 things. */
2f62977e 16556 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 16557
2f62977e 16558 if (! do_using_dynamic)
2c610e4b 16559 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 16560 }
252b5132 16561
d1f5c6e3
L		 16562 if (! process_section_groups (file))
16563 {
16564 /* Without loaded section groups we cannot process unwind. */
16565 do_unwind = 0;
16566 }
16567
2f62977e 16568 if (process_program_headers (file))
b2d38a17 16569 process_dynamic_section (file);
252b5132
RH		 16570
16571 process_relocs (file);
16572
4d6ed7c8
NC		 16573 process_unwind (file);
16574
252b5132
RH		 16575 process_symbol_table (file);
16576
16577 process_syminfo (file);
16578
16579 process_version_sections (file);
16580
16581 process_section_contents (file);
f5842774 16582
1ec5cd37 16583 process_notes (file);
103f02d3 16584
047b2264
JJ		 16585 process_gnu_liblist (file);
16586
252b5132
RH		 16587 process_arch_specific (file);
16588
d93f0186
NC		 16589 if (program_headers)
16590 {
16591 free (program_headers);
16592 program_headers = NULL;
16593 }
16594
252b5132
RH		 16595 if (section_headers)
16596 {
16597 free (section_headers);
16598 section_headers = NULL;
16599 }
16600
16601 if (string_table)
16602 {
16603 free (string_table);
16604 string_table = NULL;
d40ac9bd 16605 string_table_length = 0;
252b5132
RH		 16606 }
16607
16608 if (dynamic_strings)
16609 {
16610 free (dynamic_strings);
16611 dynamic_strings = NULL;
d79b3d50 16612 dynamic_strings_length = 0;
252b5132
RH		 16613 }
16614
16615 if (dynamic_symbols)
16616 {
16617 free (dynamic_symbols);
16618 dynamic_symbols = NULL;
19936277 16619 num_dynamic_syms = 0;
252b5132
RH		 16620 }
16621
16622 if (dynamic_syminfo)
16623 {
16624 free (dynamic_syminfo);
16625 dynamic_syminfo = NULL;
16626 }
ff78d6d6 16627
293c573e
MR		 16628 if (dynamic_section)
16629 {
16630 free (dynamic_section);
16631 dynamic_section = NULL;
16632 }
16633
e4b17d5c
L		 16634 if (section_headers_groups)
16635 {
16636 free (section_headers_groups);
16637 section_headers_groups = NULL;
16638 }
16639
16640 if (section_groups)
16641 {
2cf0635d
NC		 16642 struct group_list * g;
16643 struct group_list * next;
e4b17d5c
L		 16644
16645 for (i = 0; i < group_count; i++)
16646 {
16647 for (g = section_groups [i].root; g != NULL; g = next)
16648 {
16649 next = g->next;
16650 free (g);
16651 }
16652 }
16653
16654 free (section_groups);
16655 section_groups = NULL;
16656 }
16657
19e6b90e 16658 free_debug_memory ();
18bd398b 16659
ff78d6d6 16660 return 0;
252b5132
RH		 16661}
16662
2cf0635d
NC		 16663/* Process an ELF archive.
16664 On entry the file is positioned just after the ARMAG string. */
16665
16666static int
16667process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
16668{
16669 struct archive_info arch;
16670 struct archive_info nested_arch;
16671 size_t got;
2cf0635d
NC		 16672 int ret;
16673
16674 show_name = 1;
16675
16676 /* The ARCH structure is used to hold information about this archive. */
16677 arch.file_name = NULL;
16678 arch.file = NULL;
16679 arch.index_array = NULL;
16680 arch.sym_table = NULL;
16681 arch.longnames = NULL;
16682
16683 /* The NESTED_ARCH structure is used as a single-item cache of information
16684 about a nested archive (when members of a thin archive reside within
16685 another regular archive file). */
16686 nested_arch.file_name = NULL;
16687 nested_arch.file = NULL;
16688 nested_arch.index_array = NULL;
16689 nested_arch.sym_table = NULL;
16690 nested_arch.longnames = NULL;
16691
16692 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
16693 {
16694 ret = 1;
16695 goto out;
4145f1d5 16696 }
fb52b2f4 16697
4145f1d5
NC		 16698 if (do_archive_index)
16699 {
2cf0635d 16700 if (arch.sym_table == NULL)
4145f1d5
NC		 16701 error (_("%s: unable to dump the index as none was found\n"), file_name);
16702 else
16703 {
591f7597 16704 unsigned long i, l;
4145f1d5
NC		 16705 unsigned long current_pos;
16706
591f7597
NC		 16707 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16708 file_name, (unsigned long) arch.index_num, arch.sym_size);
4145f1d5
NC		 16709 current_pos = ftell (file);
16710
2cf0635d 16711 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 16712 {
2cf0635d
NC		 16713 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
16714 {
16715 char * member_name;
4145f1d5 16716
2cf0635d
NC		 16717 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
16718
16719 if (member_name != NULL)
16720 {
16721 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
16722
16723 if (qualified_name != NULL)
16724 {
c2a7d3f5
NC		 16725 printf (_("Contents of binary %s at offset "), qualified_name);
16726 (void) print_vma (arch.index_array[i], PREFIX_HEX);
16727 putchar ('\n');
2cf0635d
NC		 16728 free (qualified_name);
16729 }
4145f1d5
NC		 16730 }
16731 }
2cf0635d
NC		 16732
16733 if (l >= arch.sym_size)
4145f1d5
NC		 16734 {
16735 error (_("%s: end of the symbol table reached before the end of the index\n"),
16736 file_name);
cb8f3167 16737 break;
4145f1d5 16738 }
591f7597
NC		 16739 /* PR 17531: file: 0b6630b2. */
16740 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
16741 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
4145f1d5
NC		 16742 }
16743
c2a7d3f5
NC		 16744 if (arch.uses_64bit_indicies)
16745 l = (l + 7) & ~ 7;
16746 else
16747 l += l & 1;
16748
2cf0635d 16749 if (l < arch.sym_size)
c2a7d3f5
NC		 16750 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16751 file_name, arch.sym_size - l);
4145f1d5 16752
4145f1d5
NC		 16753 if (fseek (file, current_pos, SEEK_SET) != 0)
16754 {
16755 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 16756 ret = 1;
16757 goto out;
4145f1d5 16758 }
fb52b2f4 16759 }
4145f1d5
NC		 16760
16761 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
16762 && !do_segments && !do_header && !do_dump && !do_version
16763 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 16764 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 16765 {
16766 ret = 0; /* Archive index only. */
16767 goto out;
16768 }
fb52b2f4
NC		 16769 }
16770
d989285c 16771 ret = 0;
fb52b2f4
NC		 16772
16773 while (1)
16774 {
2cf0635d
NC		 16775 char * name;
16776 size_t namelen;
16777 char * qualified_name;
16778
16779 /* Read the next archive header. */
16780 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
16781 {
16782 error (_("%s: failed to seek to next archive header\n"), file_name);
16783 return 1;
16784 }
16785 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
16786 if (got != sizeof arch.arhdr)
16787 {
16788 if (got == 0)
16789 break;
16790 error (_("%s: failed to read archive header\n"), file_name);
16791 ret = 1;
16792 break;
16793 }
16794 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
16795 {
16796 error (_("%s: did not find a valid archive header\n"), arch.file_name);
16797 ret = 1;
16798 break;
16799 }
16800
16801 arch.next_arhdr_offset += sizeof arch.arhdr;
16802
16803 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
16804 if (archive_file_size & 01)
16805 ++archive_file_size;
16806
16807 name = get_archive_member_name (&arch, &nested_arch);
16808 if (name == NULL)
fb52b2f4 16809 {
0fd3a477 16810 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 16811 ret = 1;
16812 break;
fb52b2f4 16813 }
2cf0635d 16814 namelen = strlen (name);
fb52b2f4 16815
2cf0635d
NC		 16816 qualified_name = make_qualified_name (&arch, &nested_arch, name);
16817 if (qualified_name == NULL)
fb52b2f4 16818 {
2cf0635d 16819 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 16820 ret = 1;
16821 break;
fb52b2f4
NC		 16822 }
16823
2cf0635d
NC		 16824 if (is_thin_archive && arch.nested_member_origin == 0)
16825 {
16826 /* This is a proxy for an external member of a thin archive. */
16827 FILE * member_file;
16828 char * member_file_name = adjust_relative_path (file_name, name, namelen);
16829 if (member_file_name == NULL)
16830 {
16831 ret = 1;
16832 break;
16833 }
16834
16835 member_file = fopen (member_file_name, "rb");
16836 if (member_file == NULL)
16837 {
16838 error (_("Input file '%s' is not readable.\n"), member_file_name);
16839 free (member_file_name);
16840 ret = 1;
16841 break;
16842 }
16843
16844 archive_file_offset = arch.nested_member_origin;
16845
16846 ret |= process_object (qualified_name, member_file);
16847
16848 fclose (member_file);
16849 free (member_file_name);
16850 }
16851 else if (is_thin_archive)
16852 {
a043396b
NC		 16853 /* PR 15140: Allow for corrupt thin archives. */
16854 if (nested_arch.file == NULL)
16855 {
16856 error (_("%s: contains corrupt thin archive: %s\n"),
16857 file_name, name);
16858 ret = 1;
16859 break;
16860 }
16861
2cf0635d
NC		 16862 /* This is a proxy for a member of a nested archive. */
16863 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
16864
16865 /* The nested archive file will have been opened and setup by
16866 get_archive_member_name. */
16867 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
16868 {
16869 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
16870 ret = 1;
16871 break;
16872 }
16873
16874 ret |= process_object (qualified_name, nested_arch.file);
16875 }
16876 else
16877 {
16878 archive_file_offset = arch.next_arhdr_offset;
16879 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 16880
2cf0635d
NC		 16881 ret |= process_object (qualified_name, file);
16882 }
fb52b2f4 16883
2b52916e
L		 16884 if (dump_sects != NULL)
16885 {
16886 free (dump_sects);
16887 dump_sects = NULL;
16888 num_dump_sects = 0;
16889 }
16890
2cf0635d 16891 free (qualified_name);
fb52b2f4
NC		 16892 }
16893
4145f1d5 16894 out:
2cf0635d
NC		 16895 if (nested_arch.file != NULL)
16896 fclose (nested_arch.file);
16897 release_archive (&nested_arch);
16898 release_archive (&arch);
fb52b2f4 16899
d989285c 16900 return ret;
fb52b2f4
NC		 16901}
16902
16903static int
2cf0635d 16904process_file (char * file_name)
fb52b2f4 16905{
2cf0635d 16906 FILE * file;
fb52b2f4
NC		 16907 struct stat statbuf;
16908 char armag[SARMAG];
16909 int ret;
16910
16911 if (stat (file_name, &statbuf) < 0)
16912 {
f24ddbdd
NC		 16913 if (errno == ENOENT)
16914 error (_("'%s': No such file\n"), file_name);
16915 else
16916 error (_("Could not locate '%s'. System error message: %s\n"),
16917 file_name, strerror (errno));
16918 return 1;
16919 }
16920
16921 if (! S_ISREG (statbuf.st_mode))
16922 {
16923 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 16924 return 1;
16925 }
16926
16927 file = fopen (file_name, "rb");
16928 if (file == NULL)
16929 {
f24ddbdd 16930 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 16931 return 1;
16932 }
16933
16934 if (fread (armag, SARMAG, 1, file) != 1)
16935 {
4145f1d5 16936 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 16937 fclose (file);
16938 return 1;
16939 }
16940
f54498b4
NC		 16941 current_file_size = (bfd_size_type) statbuf.st_size;
16942
fb52b2f4 16943 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 16944 ret = process_archive (file_name, file, FALSE);
16945 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
16946 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 16947 else
16948 {
4145f1d5
NC		 16949 if (do_archive_index)
16950 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16951 file_name);
16952
fb52b2f4
NC		 16953 rewind (file);
16954 archive_file_size = archive_file_offset = 0;
16955 ret = process_object (file_name, file);
16956 }
16957
16958 fclose (file);
16959
f54498b4 16960 current_file_size = 0;
fb52b2f4
NC		 16961 return ret;
16962}
16963
252b5132
RH		 16964#ifdef SUPPORT_DISASSEMBLY
16965/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 16966 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 16967 symbols. */
252b5132
RH		 16968
16969void
2cf0635d 16970print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 16971{
16972 fprintf (outfile,"0x%8.8x", addr);
16973}
16974
e3c8793a 16975/* Needed by the i386 disassembler. */
252b5132
RH		 16976void
16977db_task_printsym (unsigned int addr)
16978{
16979 print_address (addr, stderr);
16980}
16981#endif
16982
16983int
2cf0635d 16984main (int argc, char ** argv)
252b5132 16985{
ff78d6d6
L		 16986 int err;
16987
252b5132
RH		 16988#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16989 setlocale (LC_MESSAGES, "");
3882b010
L		 16990#endif
16991#if defined (HAVE_SETLOCALE)
16992 setlocale (LC_CTYPE, "");
252b5132
RH		 16993#endif
16994 bindtextdomain (PACKAGE, LOCALEDIR);
16995 textdomain (PACKAGE);
16996
869b9d07
MM		 16997 expandargv (&argc, &argv);
16998
252b5132
RH		 16999 parse_args (argc, argv);
17000
18bd398b 17001 if (num_dump_sects > 0)
59f14fc0 17002 {
18bd398b 17003 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 17004 cmdline_dump_sects = (dump_type *)
17005 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 17006 if (cmdline_dump_sects == NULL)
591a748a 17007 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 17008 else
17009 {
09c11c86
NC		 17010 memcpy (cmdline_dump_sects, dump_sects,
17011 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 17012 num_cmdline_dump_sects = num_dump_sects;
17013 }
17014 }
17015
18bd398b
NC		 17016 if (optind < (argc - 1))
17017 show_name = 1;
5656ba2c
L		 17018 else if (optind >= argc)
17019 {
17020 warn (_("Nothing to do.\n"));
17021 usage (stderr);
17022 }
18bd398b 17023
ff78d6d6 17024 err = 0;
252b5132 17025 while (optind < argc)
18bd398b 17026 err |= process_file (argv[optind++]);
252b5132
RH		 17027
17028 if (dump_sects != NULL)
17029 free (dump_sects);
59f14fc0
AS		 17030 if (cmdline_dump_sects != NULL)
17031 free (cmdline_dump_sects);
252b5132 17032
ff78d6d6 17033 return err;
252b5132 17034}
GDB Binutils - Deliverables
This page took 3.120884 seconds and 4 git commands to generate.