]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - binutils/readelf.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
opcodes/arc: Fix extract for some add_s instructions
[thirdparty/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;
8699fc3e
AB		 2384 case E_ARC_MACH_NPS400:
2385 strcat (buf, ", NPS400");
2386 break;
a9522a21
AB		 2387
2388 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2389 new ELF with new architecture being read by an old version of
2390 readelf, or (c) An ELF built with non-GNU compiler that does not
2391 set the architecture in the e_flags. */
2392 default:
2393 if (e_machine == EM_ARC_COMPACT)
2394 strcat (buf, ", Unknown ARCompact");
2395 else
2396 strcat (buf, ", Unknown ARC");
2397 break;
2398 }
2399
2400 switch (e_flags & EF_ARC_OSABI_MSK)
2401 {
2402 case E_ARC_OSABI_ORIG:
2403 strcat (buf, ", (ABI:legacy)");
2404 break;
2405 case E_ARC_OSABI_V2:
2406 strcat (buf, ", (ABI:v2)");
2407 break;
2408 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2409 case E_ARC_OSABI_V3:
2410 strcat (buf, ", v3 no-legacy-syscalls ABI");
2411 break;
2412 default:
2413 strcat (buf, ", unrecognised ARC OSABI flag");
2414 break;
2415 }
2416}
2417
f3485b74 2418static void
d3ba0551 2419decode_ARM_machine_flags (unsigned e_flags, char buf[])
f3485b74
NC		 2420{
2421 unsigned eabi;
2422 int unknown = 0;
2423
2424 eabi = EF_ARM_EABI_VERSION (e_flags);
2425 e_flags &= ~ EF_ARM_EABIMASK;
2426
2427 /* Handle "generic" ARM flags. */
2428 if (e_flags & EF_ARM_RELEXEC)
2429 {
2430 strcat (buf, ", relocatable executable");
2431 e_flags &= ~ EF_ARM_RELEXEC;
2432 }
76da6bbe 2433
f3485b74
NC		 2434 /* Now handle EABI specific flags. */
2435 switch (eabi)
2436 {
2437 default:
2c71103e 2438 strcat (buf, ", <unrecognized EABI>");
f3485b74
NC		 2439 if (e_flags)
2440 unknown = 1;
2441 break;
2442
2443 case EF_ARM_EABI_VER1:
a5bcd848 2444 strcat (buf, ", Version1 EABI");
f3485b74
NC		 2445 while (e_flags)
2446 {
2447 unsigned flag;
76da6bbe 2448
f3485b74
NC		 2449 /* Process flags one bit at a time. */
2450 flag = e_flags & - e_flags;
2451 e_flags &= ~ flag;
76da6bbe 2452
f3485b74
NC		 2453 switch (flag)
2454 {
a5bcd848 2455 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
f3485b74
NC		 2456 strcat (buf, ", sorted symbol tables");
2457 break;
76da6bbe 2458
f3485b74
NC		 2459 default:
2460 unknown = 1;
2461 break;
2462 }
2463 }
2464 break;
76da6bbe 2465
a5bcd848
PB		 2466 case EF_ARM_EABI_VER2:
2467 strcat (buf, ", Version2 EABI");
2468 while (e_flags)
2469 {
2470 unsigned flag;
2471
2472 /* Process flags one bit at a time. */
2473 flag = e_flags & - e_flags;
2474 e_flags &= ~ flag;
2475
2476 switch (flag)
2477 {
2478 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2479 strcat (buf, ", sorted symbol tables");
2480 break;
2481
2482 case EF_ARM_DYNSYMSUSESEGIDX:
2483 strcat (buf, ", dynamic symbols use segment index");
2484 break;
2485
2486 case EF_ARM_MAPSYMSFIRST:
2487 strcat (buf, ", mapping symbols precede others");
2488 break;
2489
2490 default:
2491 unknown = 1;
2492 break;
2493 }
2494 }
2495 break;
2496
d507cf36
PB		 2497 case EF_ARM_EABI_VER3:
2498 strcat (buf, ", Version3 EABI");
8cb51566
PB		 2499 break;
2500
2501 case EF_ARM_EABI_VER4:
2502 strcat (buf, ", Version4 EABI");
3bfcb652
NC		 2503 while (e_flags)
2504 {
2505 unsigned flag;
2506
2507 /* Process flags one bit at a time. */
2508 flag = e_flags & - e_flags;
2509 e_flags &= ~ flag;
2510
2511 switch (flag)
2512 {
2513 case EF_ARM_BE8:
2514 strcat (buf, ", BE8");
2515 break;
2516
2517 case EF_ARM_LE8:
2518 strcat (buf, ", LE8");
2519 break;
2520
2521 default:
2522 unknown = 1;
2523 break;
2524 }
2525 break;
2526 }
2527 break;
3a4a14e9
PB		 2528
2529 case EF_ARM_EABI_VER5:
2530 strcat (buf, ", Version5 EABI");
d507cf36
PB		 2531 while (e_flags)
2532 {
2533 unsigned flag;
2534
2535 /* Process flags one bit at a time. */
2536 flag = e_flags & - e_flags;
2537 e_flags &= ~ flag;
2538
2539 switch (flag)
2540 {
2541 case EF_ARM_BE8:
2542 strcat (buf, ", BE8");
2543 break;
2544
2545 case EF_ARM_LE8:
2546 strcat (buf, ", LE8");
2547 break;
2548
3bfcb652
NC		 2549 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2550 strcat (buf, ", soft-float ABI");
2551 break;
2552
2553 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2554 strcat (buf, ", hard-float ABI");
2555 break;
2556
d507cf36
PB		 2557 default:
2558 unknown = 1;
2559 break;
2560 }
2561 }
2562 break;
2563
f3485b74 2564 case EF_ARM_EABI_UNKNOWN:
a5bcd848 2565 strcat (buf, ", GNU EABI");
f3485b74
NC		 2566 while (e_flags)
2567 {
2568 unsigned flag;
76da6bbe 2569
f3485b74
NC		 2570 /* Process flags one bit at a time. */
2571 flag = e_flags & - e_flags;
2572 e_flags &= ~ flag;
76da6bbe 2573
f3485b74
NC		 2574 switch (flag)
2575 {
a5bcd848 2576 case EF_ARM_INTERWORK:
f3485b74
NC		 2577 strcat (buf, ", interworking enabled");
2578 break;
76da6bbe 2579
a5bcd848 2580 case EF_ARM_APCS_26:
f3485b74
NC		 2581 strcat (buf, ", uses APCS/26");
2582 break;
76da6bbe 2583
a5bcd848 2584 case EF_ARM_APCS_FLOAT:
f3485b74
NC		 2585 strcat (buf, ", uses APCS/float");
2586 break;
76da6bbe 2587
a5bcd848 2588 case EF_ARM_PIC:
f3485b74
NC		 2589 strcat (buf, ", position independent");
2590 break;
76da6bbe 2591
a5bcd848 2592 case EF_ARM_ALIGN8:
f3485b74
NC		 2593 strcat (buf, ", 8 bit structure alignment");
2594 break;
76da6bbe 2595
a5bcd848 2596 case EF_ARM_NEW_ABI:
f3485b74
NC		 2597 strcat (buf, ", uses new ABI");
2598 break;
76da6bbe 2599
a5bcd848 2600 case EF_ARM_OLD_ABI:
f3485b74
NC		 2601 strcat (buf, ", uses old ABI");
2602 break;
76da6bbe 2603
a5bcd848 2604 case EF_ARM_SOFT_FLOAT:
f3485b74
NC		 2605 strcat (buf, ", software FP");
2606 break;
76da6bbe 2607
90e01f86
ILT		 2608 case EF_ARM_VFP_FLOAT:
2609 strcat (buf, ", VFP");
2610 break;
2611
fde78edd
NC		 2612 case EF_ARM_MAVERICK_FLOAT:
2613 strcat (buf, ", Maverick FP");
2614 break;
2615
f3485b74
NC		 2616 default:
2617 unknown = 1;
2618 break;
2619 }
2620 }
2621 }
f3485b74
NC		 2622
2623 if (unknown)
2b692964 2624 strcat (buf,_(", <unknown>"));
f3485b74
NC		 2625}
2626
343433df
AB		 2627static void
2628decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2629{
2630 --size; /* Leave space for null terminator. */
2631
2632 switch (e_flags & EF_AVR_MACH)
2633 {
2634 case E_AVR_MACH_AVR1:
2635 strncat (buf, ", avr:1", size);
2636 break;
2637 case E_AVR_MACH_AVR2:
2638 strncat (buf, ", avr:2", size);
2639 break;
2640 case E_AVR_MACH_AVR25:
2641 strncat (buf, ", avr:25", size);
2642 break;
2643 case E_AVR_MACH_AVR3:
2644 strncat (buf, ", avr:3", size);
2645 break;
2646 case E_AVR_MACH_AVR31:
2647 strncat (buf, ", avr:31", size);
2648 break;
2649 case E_AVR_MACH_AVR35:
2650 strncat (buf, ", avr:35", size);
2651 break;
2652 case E_AVR_MACH_AVR4:
2653 strncat (buf, ", avr:4", size);
2654 break;
2655 case E_AVR_MACH_AVR5:
2656 strncat (buf, ", avr:5", size);
2657 break;
2658 case E_AVR_MACH_AVR51:
2659 strncat (buf, ", avr:51", size);
2660 break;
2661 case E_AVR_MACH_AVR6:
2662 strncat (buf, ", avr:6", size);
2663 break;
2664 case E_AVR_MACH_AVRTINY:
2665 strncat (buf, ", avr:100", size);
2666 break;
2667 case E_AVR_MACH_XMEGA1:
2668 strncat (buf, ", avr:101", size);
2669 break;
2670 case E_AVR_MACH_XMEGA2:
2671 strncat (buf, ", avr:102", size);
2672 break;
2673 case E_AVR_MACH_XMEGA3:
2674 strncat (buf, ", avr:103", size);
2675 break;
2676 case E_AVR_MACH_XMEGA4:
2677 strncat (buf, ", avr:104", size);
2678 break;
2679 case E_AVR_MACH_XMEGA5:
2680 strncat (buf, ", avr:105", size);
2681 break;
2682 case E_AVR_MACH_XMEGA6:
2683 strncat (buf, ", avr:106", size);
2684 break;
2685 case E_AVR_MACH_XMEGA7:
2686 strncat (buf, ", avr:107", size);
2687 break;
2688 default:
2689 strncat (buf, ", avr:<unknown>", size);
2690 break;
2691 }
2692
2693 size -= strlen (buf);
2694 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2695 strncat (buf, ", link-relax", size);
2696}
2697
35c08157
KLC		 2698static void
2699decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2700{
2701 unsigned abi;
2702 unsigned arch;
2703 unsigned config;
2704 unsigned version;
2705 int has_fpu = 0;
2706 int r = 0;
2707
2708 static const char *ABI_STRINGS[] =
2709 {
2710 "ABI v0", /* use r5 as return register; only used in N1213HC */
2711 "ABI v1", /* use r0 as return register */
2712 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2713 "ABI v2fp", /* for FPU */
40c7a7cb
KLC		 2714 "AABI",
2715 "ABI2 FP+"
35c08157
KLC		 2716 };
2717 static const char *VER_STRINGS[] =
2718 {
2719 "Andes ELF V1.3 or older",
2720 "Andes ELF V1.3.1",
2721 "Andes ELF V1.4"
2722 };
2723 static const char *ARCH_STRINGS[] =
2724 {
2725 "",
2726 "Andes Star v1.0",
2727 "Andes Star v2.0",
2728 "Andes Star v3.0",
2729 "Andes Star v3.0m"
2730 };
2731
2732 abi = EF_NDS_ABI & e_flags;
2733 arch = EF_NDS_ARCH & e_flags;
2734 config = EF_NDS_INST & e_flags;
2735 version = EF_NDS32_ELF_VERSION & e_flags;
2736
2737 memset (buf, 0, size);
2738
2739 switch (abi)
2740 {
2741 case E_NDS_ABI_V0:
2742 case E_NDS_ABI_V1:
2743 case E_NDS_ABI_V2:
2744 case E_NDS_ABI_V2FP:
2745 case E_NDS_ABI_AABI:
40c7a7cb 2746 case E_NDS_ABI_V2FP_PLUS:
35c08157
KLC		 2747 /* In case there are holes in the array. */
2748 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2749 break;
2750
2751 default:
2752 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2753 break;
2754 }
2755
2756 switch (version)
2757 {
2758 case E_NDS32_ELF_VER_1_2:
2759 case E_NDS32_ELF_VER_1_3:
2760 case E_NDS32_ELF_VER_1_4:
2761 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2762 break;
2763
2764 default:
2765 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2766 break;
2767 }
2768
2769 if (E_NDS_ABI_V0 == abi)
2770 {
2771 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2772 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2773 if (arch == E_NDS_ARCH_STAR_V1_0)
2774 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2775 return;
2776 }
2777
2778 switch (arch)
2779 {
2780 case E_NDS_ARCH_STAR_V1_0:
2781 case E_NDS_ARCH_STAR_V2_0:
2782 case E_NDS_ARCH_STAR_V3_0:
2783 case E_NDS_ARCH_STAR_V3_M:
2784 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2785 break;
2786
2787 default:
2788 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2789 /* ARCH version determines how the e_flags are interpreted.
2790 If it is unknown, we cannot proceed. */
2791 return;
2792 }
2793
2794 /* Newer ABI; Now handle architecture specific flags. */
2795 if (arch == E_NDS_ARCH_STAR_V1_0)
2796 {
2797 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2798 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2799
2800 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2801 r += snprintf (buf + r, size -r, ", MAC");
2802
2803 if (config & E_NDS32_HAS_DIV_INST)
2804 r += snprintf (buf + r, size -r, ", DIV");
2805
2806 if (config & E_NDS32_HAS_16BIT_INST)
2807 r += snprintf (buf + r, size -r, ", 16b");
2808 }
2809 else
2810 {
2811 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2812 {
2813 if (version <= E_NDS32_ELF_VER_1_3)
2814 r += snprintf (buf + r, size -r, ", [B8]");
2815 else
2816 r += snprintf (buf + r, size -r, ", EX9");
2817 }
2818
2819 if (config & E_NDS32_HAS_MAC_DX_INST)
2820 r += snprintf (buf + r, size -r, ", MAC_DX");
2821
2822 if (config & E_NDS32_HAS_DIV_DX_INST)
2823 r += snprintf (buf + r, size -r, ", DIV_DX");
2824
2825 if (config & E_NDS32_HAS_16BIT_INST)
2826 {
2827 if (version <= E_NDS32_ELF_VER_1_3)
2828 r += snprintf (buf + r, size -r, ", 16b");
2829 else
2830 r += snprintf (buf + r, size -r, ", IFC");
2831 }
2832 }
2833
2834 if (config & E_NDS32_HAS_EXT_INST)
2835 r += snprintf (buf + r, size -r, ", PERF1");
2836
2837 if (config & E_NDS32_HAS_EXT2_INST)
2838 r += snprintf (buf + r, size -r, ", PERF2");
2839
2840 if (config & E_NDS32_HAS_FPU_INST)
2841 {
2842 has_fpu = 1;
2843 r += snprintf (buf + r, size -r, ", FPU_SP");
2844 }
2845
2846 if (config & E_NDS32_HAS_FPU_DP_INST)
2847 {
2848 has_fpu = 1;
2849 r += snprintf (buf + r, size -r, ", FPU_DP");
2850 }
2851
2852 if (config & E_NDS32_HAS_FPU_MAC_INST)
2853 {
2854 has_fpu = 1;
2855 r += snprintf (buf + r, size -r, ", FPU_MAC");
2856 }
2857
2858 if (has_fpu)
2859 {
2860 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2861 {
2862 case E_NDS32_FPU_REG_8SP_4DP:
2863 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2864 break;
2865 case E_NDS32_FPU_REG_16SP_8DP:
2866 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2867 break;
2868 case E_NDS32_FPU_REG_32SP_16DP:
2869 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2870 break;
2871 case E_NDS32_FPU_REG_32SP_32DP:
2872 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2873 break;
2874 }
2875 }
2876
2877 if (config & E_NDS32_HAS_AUDIO_INST)
2878 r += snprintf (buf + r, size -r, ", AUDIO");
2879
2880 if (config & E_NDS32_HAS_STRING_INST)
2881 r += snprintf (buf + r, size -r, ", STR");
2882
2883 if (config & E_NDS32_HAS_REDUCED_REGS)
2884 r += snprintf (buf + r, size -r, ", 16REG");
2885
2886 if (config & E_NDS32_HAS_VIDEO_INST)
2887 {
2888 if (version <= E_NDS32_ELF_VER_1_3)
2889 r += snprintf (buf + r, size -r, ", VIDEO");
2890 else
2891 r += snprintf (buf + r, size -r, ", SATURATION");
2892 }
2893
2894 if (config & E_NDS32_HAS_ENCRIPT_INST)
2895 r += snprintf (buf + r, size -r, ", ENCRP");
2896
2897 if (config & E_NDS32_HAS_L2C_INST)
2898 r += snprintf (buf + r, size -r, ", L2C");
2899}
2900
252b5132 2901static char *
d3ba0551 2902get_machine_flags (unsigned e_flags, unsigned e_machine)
252b5132 2903{
b34976b6 2904 static char buf[1024];
252b5132
RH		 2905
2906 buf[0] = '\0';
76da6bbe 2907
252b5132
RH		 2908 if (e_flags)
2909 {
2910 switch (e_machine)
2911 {
2912 default:
2913 break;
2914
886a2506 2915 case EM_ARC_COMPACT2:
886a2506 2916 case EM_ARC_COMPACT:
a9522a21
AB		 2917 decode_ARC_machine_flags (e_flags, e_machine, buf);
2918 break;
886a2506 2919
f3485b74
NC		 2920 case EM_ARM:
2921 decode_ARM_machine_flags (e_flags, buf);
2922 break;
76da6bbe 2923
343433df
AB		 2924 case EM_AVR:
2925 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
2926 break;
2927
781303ce
MF		 2928 case EM_BLACKFIN:
2929 if (e_flags & EF_BFIN_PIC)
2930 strcat (buf, ", PIC");
2931
2932 if (e_flags & EF_BFIN_FDPIC)
2933 strcat (buf, ", FDPIC");
2934
2935 if (e_flags & EF_BFIN_CODE_IN_L1)
2936 strcat (buf, ", code in L1");
2937
2938 if (e_flags & EF_BFIN_DATA_IN_L1)
2939 strcat (buf, ", data in L1");
2940
2941 break;
2942
ec2dfb42
AO		 2943 case EM_CYGNUS_FRV:
2944 switch (e_flags & EF_FRV_CPU_MASK)
2945 {
2946 case EF_FRV_CPU_GENERIC:
2947 break;
2948
2949 default:
2950 strcat (buf, ", fr???");
2951 break;
57346661 2952
ec2dfb42
AO		 2953 case EF_FRV_CPU_FR300:
2954 strcat (buf, ", fr300");
2955 break;
2956
2957 case EF_FRV_CPU_FR400:
2958 strcat (buf, ", fr400");
2959 break;
2960 case EF_FRV_CPU_FR405:
2961 strcat (buf, ", fr405");
2962 break;
2963
2964 case EF_FRV_CPU_FR450:
2965 strcat (buf, ", fr450");
2966 break;
2967
2968 case EF_FRV_CPU_FR500:
2969 strcat (buf, ", fr500");
2970 break;
2971 case EF_FRV_CPU_FR550:
2972 strcat (buf, ", fr550");
2973 break;
2974
2975 case EF_FRV_CPU_SIMPLE:
2976 strcat (buf, ", simple");
2977 break;
2978 case EF_FRV_CPU_TOMCAT:
2979 strcat (buf, ", tomcat");
2980 break;
2981 }
1c877e87 2982 break;
ec2dfb42 2983
53c7db4b 2984 case EM_68K:
425c6cb0 2985 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
76f57f3a 2986 strcat (buf, ", m68000");
425c6cb0 2987 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3bdcfdf4
KH		 2988 strcat (buf, ", cpu32");
2989 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2990 strcat (buf, ", fido_a");
425c6cb0 2991 else
266abb8f 2992 {
2cf0635d
NC		 2993 char const * isa = _("unknown");
2994 char const * mac = _("unknown mac");
2995 char const * additional = NULL;
0112cd26 2996
c694fd50 2997 switch (e_flags & EF_M68K_CF_ISA_MASK)
266abb8f 2998 {
c694fd50 2999 case EF_M68K_CF_ISA_A_NODIV:
0b2e31dc
NS		 3000 isa = "A";
3001 additional = ", nodiv";
3002 break;
c694fd50 3003 case EF_M68K_CF_ISA_A:
266abb8f
NS		 3004 isa = "A";
3005 break;
c694fd50 3006 case EF_M68K_CF_ISA_A_PLUS:
266abb8f
NS		 3007 isa = "A+";
3008 break;
c694fd50 3009 case EF_M68K_CF_ISA_B_NOUSP:
0b2e31dc
NS		 3010 isa = "B";
3011 additional = ", nousp";
3012 break;
c694fd50 3013 case EF_M68K_CF_ISA_B:
266abb8f
NS		 3014 isa = "B";
3015 break;
f608cd77
NS		 3016 case EF_M68K_CF_ISA_C:
3017 isa = "C";
3018 break;
3019 case EF_M68K_CF_ISA_C_NODIV:
3020 isa = "C";
3021 additional = ", nodiv";
3022 break;
266abb8f
NS		 3023 }
3024 strcat (buf, ", cf, isa ");
3025 strcat (buf, isa);
0b2e31dc
NS		 3026 if (additional)
3027 strcat (buf, additional);
c694fd50 3028 if (e_flags & EF_M68K_CF_FLOAT)
0b2e31dc 3029 strcat (buf, ", float");
c694fd50 3030 switch (e_flags & EF_M68K_CF_MAC_MASK)
266abb8f
NS		 3031 {
3032 case 0:
3033 mac = NULL;
3034 break;
c694fd50 3035 case EF_M68K_CF_MAC:
266abb8f
NS		 3036 mac = "mac";
3037 break;
c694fd50 3038 case EF_M68K_CF_EMAC:
266abb8f
NS		 3039 mac = "emac";
3040 break;
f608cd77
NS		 3041 case EF_M68K_CF_EMAC_B:
3042 mac = "emac_b";
3043 break;
266abb8f
NS		 3044 }
3045 if (mac)
3046 {
3047 strcat (buf, ", ");
3048 strcat (buf, mac);
3049 }
266abb8f 3050 }
53c7db4b 3051 break;
33c63f9d 3052
153a2776
NC		 3053 case EM_CYGNUS_MEP:
3054 switch (e_flags & EF_MEP_CPU_MASK)
3055 {
3056 case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3057 case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3058 case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3059 case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3060 case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3061 case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3062 default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3063 }
3064
3065 switch (e_flags & EF_MEP_COP_MASK)
3066 {
3067 case EF_MEP_COP_NONE: break;
3068 case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3069 case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3070 case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3071 case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3072 default: strcat (buf, _("<unknown MeP copro type>")); break;
3073 }
3074
3075 if (e_flags & EF_MEP_LIBRARY)
3076 strcat (buf, ", Built for Library");
3077
3078 if (e_flags & EF_MEP_INDEX_MASK)
3079 sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3080 e_flags & EF_MEP_INDEX_MASK);
3081
3082 if (e_flags & ~ EF_MEP_ALL_FLAGS)
3083 sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3084 e_flags & ~ EF_MEP_ALL_FLAGS);
3085 break;
3086
252b5132
RH		 3087 case EM_PPC:
3088 if (e_flags & EF_PPC_EMB)
3089 strcat (buf, ", emb");
3090
3091 if (e_flags & EF_PPC_RELOCATABLE)
2b692964 3092 strcat (buf, _(", relocatable"));
252b5132
RH		 3093
3094 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2b692964 3095 strcat (buf, _(", relocatable-lib"));
252b5132
RH		 3096 break;
3097
ee67d69a
AM		 3098 case EM_PPC64:
3099 if (e_flags & EF_PPC64_ABI)
3100 {
3101 char abi[] = ", abiv0";
3102
3103 abi[6] += e_flags & EF_PPC64_ABI;
3104 strcat (buf, abi);
3105 }
3106 break;
3107
708e2187
NC		 3108 case EM_V800:
3109 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3110 strcat (buf, ", RH850 ABI");
0b4362b0 3111
708e2187
NC		 3112 if (e_flags & EF_V800_850E3)
3113 strcat (buf, ", V3 architecture");
3114
3115 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3116 strcat (buf, ", FPU not used");
3117
3118 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3119 strcat (buf, ", regmode: COMMON");
3120
3121 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3122 strcat (buf, ", r4 not used");
3123
3124 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3125 strcat (buf, ", r30 not used");
3126
3127 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3128 strcat (buf, ", r5 not used");
3129
3130 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3131 strcat (buf, ", r2 not used");
3132
3133 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3134 {
3135 switch (e_flags & - e_flags)
3136 {
3137 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3138 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
708e2187
NC		 3139 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3140 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
708e2187
NC		 3141 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3142 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3143 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3144 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3145 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3146 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3147 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3148 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3149 default: break;
3150 }
3151 }
3152 break;
3153
2b0337b0 3154 case EM_V850:
252b5132
RH		 3155 case EM_CYGNUS_V850:
3156 switch (e_flags & EF_V850_ARCH)
3157 {
78c8d46c
NC		 3158 case E_V850E3V5_ARCH:
3159 strcat (buf, ", v850e3v5");
3160 break;
1cd986c5
NC		 3161 case E_V850E2V3_ARCH:
3162 strcat (buf, ", v850e2v3");
3163 break;
3164 case E_V850E2_ARCH:
3165 strcat (buf, ", v850e2");
3166 break;
3167 case E_V850E1_ARCH:
3168 strcat (buf, ", v850e1");
8ad30312 3169 break;
252b5132
RH		 3170 case E_V850E_ARCH:
3171 strcat (buf, ", v850e");
3172 break;
252b5132
RH		 3173 case E_V850_ARCH:
3174 strcat (buf, ", v850");
3175 break;
3176 default:
2b692964 3177 strcat (buf, _(", unknown v850 architecture variant"));
252b5132
RH		 3178 break;
3179 }
3180 break;
3181
2b0337b0 3182 case EM_M32R:
252b5132
RH		 3183 case EM_CYGNUS_M32R:
3184 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3185 strcat (buf, ", m32r");
252b5132
RH		 3186 break;
3187
3188 case EM_MIPS:
4fe85591 3189 case EM_MIPS_RS3_LE:
252b5132
RH		 3190 if (e_flags & EF_MIPS_NOREORDER)
3191 strcat (buf, ", noreorder");
3192
3193 if (e_flags & EF_MIPS_PIC)
3194 strcat (buf, ", pic");
3195
3196 if (e_flags & EF_MIPS_CPIC)
3197 strcat (buf, ", cpic");
3198
d1bdd336
TS		 3199 if (e_flags & EF_MIPS_UCODE)
3200 strcat (buf, ", ugen_reserved");
3201
252b5132
RH		 3202 if (e_flags & EF_MIPS_ABI2)
3203 strcat (buf, ", abi2");
3204
43521d43
TS		 3205 if (e_flags & EF_MIPS_OPTIONS_FIRST)
3206 strcat (buf, ", odk first");
3207
a5d22d2a
TS		 3208 if (e_flags & EF_MIPS_32BITMODE)
3209 strcat (buf, ", 32bitmode");
3210
ba92f887
MR		 3211 if (e_flags & EF_MIPS_NAN2008)
3212 strcat (buf, ", nan2008");
3213
fef1b0b3
SE		 3214 if (e_flags & EF_MIPS_FP64)
3215 strcat (buf, ", fp64");
3216
156c2f8b
NC		 3217 switch ((e_flags & EF_MIPS_MACH))
3218 {
3219 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3220 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3221 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
156c2f8b 3222 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
810dfa6e
L		 3223 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3224 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3225 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3226 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
c6c98b38 3227 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
ebcb91b7 3228 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
350cc38d
MS		 3229 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3230 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
fd503541 3231 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
05c6f050 3232 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
67c2a3e8 3233 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
d32e5c54 3234 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
52b6b6b9 3235 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
43521d43
TS		 3236 case 0:
3237 /* We simply ignore the field in this case to avoid confusion:
3238 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3239 extension. */
3240 break;
2b692964 3241 default: strcat (buf, _(", unknown CPU")); break;
156c2f8b 3242 }
43521d43
TS		 3243
3244 switch ((e_flags & EF_MIPS_ABI))
3245 {
3246 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3247 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3248 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3249 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3250 case 0:
3251 /* We simply ignore the field in this case to avoid confusion:
3252 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3253 This means it is likely to be an o32 file, but not for
3254 sure. */
3255 break;
2b692964 3256 default: strcat (buf, _(", unknown ABI")); break;
43521d43
TS		 3257 }
3258
3259 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3260 strcat (buf, ", mdmx");
3261
3262 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3263 strcat (buf, ", mips16");
3264
df58fc94
RS		 3265 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3266 strcat (buf, ", micromips");
3267
43521d43
TS		 3268 switch ((e_flags & EF_MIPS_ARCH))
3269 {
3270 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3271 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3272 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3273 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3274 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3275 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
cb44e358 3276 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
7361da2c 3277 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
43521d43 3278 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
5f74bc13 3279 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
7361da2c 3280 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
2b692964 3281 default: strcat (buf, _(", unknown ISA")); break;
43521d43 3282 }
252b5132 3283 break;
351b4b40 3284
35c08157
KLC		 3285 case EM_NDS32:
3286 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3287 break;
3288
ccde1100
AO		 3289 case EM_SH:
3290 switch ((e_flags & EF_SH_MACH_MASK))
3291 {
3292 case EF_SH1: strcat (buf, ", sh1"); break;
3293 case EF_SH2: strcat (buf, ", sh2"); break;
3294 case EF_SH3: strcat (buf, ", sh3"); break;
3295 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3296 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3297 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3298 case EF_SH3E: strcat (buf, ", sh3e"); break;
3299 case EF_SH4: strcat (buf, ", sh4"); break;
3300 case EF_SH5: strcat (buf, ", sh5"); break;
3301 case EF_SH2E: strcat (buf, ", sh2e"); break;
3302 case EF_SH4A: strcat (buf, ", sh4a"); break;
1d70c7fb 3303 case EF_SH2A: strcat (buf, ", sh2a"); break;
ccde1100
AO		 3304 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3305 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
1d70c7fb 3306 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
0b92ab21
NH		 3307 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3308 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3309 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3310 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3311 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3312 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2b692964 3313 default: strcat (buf, _(", unknown ISA")); break;
ccde1100
AO		 3314 }
3315
cec6a5b8
MR		 3316 if (e_flags & EF_SH_PIC)
3317 strcat (buf, ", pic");
3318
3319 if (e_flags & EF_SH_FDPIC)
3320 strcat (buf, ", fdpic");
ccde1100 3321 break;
948f632f 3322
73589c9d
CS		 3323 case EM_OR1K:
3324 if (e_flags & EF_OR1K_NODELAY)
3325 strcat (buf, ", no delay");
3326 break;
57346661 3327
351b4b40
RH		 3328 case EM_SPARCV9:
3329 if (e_flags & EF_SPARC_32PLUS)
3330 strcat (buf, ", v8+");
3331
3332 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 3333 strcat (buf, ", ultrasparcI");
3334
3335 if (e_flags & EF_SPARC_SUN_US3)
3336 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 3337
3338 if (e_flags & EF_SPARC_HAL_R1)
3339 strcat (buf, ", halr1");
3340
3341 if (e_flags & EF_SPARC_LEDATA)
3342 strcat (buf, ", ledata");
3343
3344 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3345 strcat (buf, ", tso");
3346
3347 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3348 strcat (buf, ", pso");
3349
3350 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3351 strcat (buf, ", rmo");
3352 break;
7d466069 3353
103f02d3
UD		 3354 case EM_PARISC:
3355 switch (e_flags & EF_PARISC_ARCH)
3356 {
3357 case EFA_PARISC_1_0:
3358 strcpy (buf, ", PA-RISC 1.0");
3359 break;
3360 case EFA_PARISC_1_1:
3361 strcpy (buf, ", PA-RISC 1.1");
3362 break;
3363 case EFA_PARISC_2_0:
3364 strcpy (buf, ", PA-RISC 2.0");
3365 break;
3366 default:
3367 break;
3368 }
3369 if (e_flags & EF_PARISC_TRAPNIL)
3370 strcat (buf, ", trapnil");
3371 if (e_flags & EF_PARISC_EXT)
3372 strcat (buf, ", ext");
3373 if (e_flags & EF_PARISC_LSB)
3374 strcat (buf, ", lsb");
3375 if (e_flags & EF_PARISC_WIDE)
3376 strcat (buf, ", wide");
3377 if (e_flags & EF_PARISC_NO_KABP)
3378 strcat (buf, ", no kabp");
3379 if (e_flags & EF_PARISC_LAZYSWAP)
3380 strcat (buf, ", lazyswap");
30800947 3381 break;
76da6bbe 3382
7d466069 3383 case EM_PJ:
2b0337b0 3384 case EM_PJ_OLD:
7d466069
ILT		 3385 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3386 strcat (buf, ", new calling convention");
3387
3388 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3389 strcat (buf, ", gnu calling convention");
3390 break;
4d6ed7c8
NC		 3391
3392 case EM_IA_64:
3393 if ((e_flags & EF_IA_64_ABI64))
3394 strcat (buf, ", 64-bit");
3395 else
3396 strcat (buf, ", 32-bit");
3397 if ((e_flags & EF_IA_64_REDUCEDFP))
3398 strcat (buf, ", reduced fp model");
3399 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3400 strcat (buf, ", no function descriptors, constant gp");
3401 else if ((e_flags & EF_IA_64_CONS_GP))
3402 strcat (buf, ", constant gp");
3403 if ((e_flags & EF_IA_64_ABSOLUTE))
3404 strcat (buf, ", absolute");
28f997cf
TG		 3405 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3406 {
3407 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3408 strcat (buf, ", vms_linkages");
3409 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3410 {
3411 case EF_IA_64_VMS_COMCOD_SUCCESS:
3412 break;
3413 case EF_IA_64_VMS_COMCOD_WARNING:
3414 strcat (buf, ", warning");
3415 break;
3416 case EF_IA_64_VMS_COMCOD_ERROR:
3417 strcat (buf, ", error");
3418 break;
3419 case EF_IA_64_VMS_COMCOD_ABORT:
3420 strcat (buf, ", abort");
3421 break;
3422 default:
bee0ee85
NC		 3423 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3424 e_flags & EF_IA_64_VMS_COMCOD);
3425 strcat (buf, ", <unknown>");
28f997cf
TG		 3426 }
3427 }
4d6ed7c8 3428 break;
179d3252
JT		 3429
3430 case EM_VAX:
3431 if ((e_flags & EF_VAX_NONPIC))
3432 strcat (buf, ", non-PIC");
3433 if ((e_flags & EF_VAX_DFLOAT))
3434 strcat (buf, ", D-Float");
3435 if ((e_flags & EF_VAX_GFLOAT))
3436 strcat (buf, ", G-Float");
3437 break;
c7927a3c 3438
619ed720
EB		 3439 case EM_VISIUM:
3440 if (e_flags & EF_VISIUM_ARCH_MCM)
3441 strcat (buf, ", mcm");
3442 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3443 strcat (buf, ", mcm24");
3444 if (e_flags & EF_VISIUM_ARCH_GR6)
3445 strcat (buf, ", gr6");
3446 break;
3447
4046d87a 3448 case EM_RL78:
1740ba0c
NC		 3449 switch (e_flags & E_FLAG_RL78_CPU_MASK)
3450 {
3451 case E_FLAG_RL78_ANY_CPU: break;
3452 case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3453 case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3454 case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3455 }
856ea05c
KP		 3456 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3457 strcat (buf, ", 64-bit doubles");
4046d87a 3458 break;
0b4362b0 3459
c7927a3c
NC		 3460 case EM_RX:
3461 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3462 strcat (buf, ", 64-bit doubles");
3463 if (e_flags & E_FLAG_RX_DSP)
dd24e3da 3464 strcat (buf, ", dsp");
d4cb0ea0 3465 if (e_flags & E_FLAG_RX_PID)
0b4362b0 3466 strcat (buf, ", pid");
708e2187
NC		 3467 if (e_flags & E_FLAG_RX_ABI)
3468 strcat (buf, ", RX ABI");
3525236c
NC		 3469 if (e_flags & E_FLAG_RX_SINSNS_SET)
3470 strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3471 ? ", uses String instructions" : ", bans String instructions");
a117b0a5
YS		 3472 if (e_flags & E_FLAG_RX_V2)
3473 strcat (buf, ", V2");
d4cb0ea0 3474 break;
55786da2
AK		 3475
3476 case EM_S390:
3477 if (e_flags & EF_S390_HIGH_GPRS)
3478 strcat (buf, ", highgprs");
d4cb0ea0 3479 break;
40b36596
JM		 3480
3481 case EM_TI_C6000:
3482 if ((e_flags & EF_C6000_REL))
3483 strcat (buf, ", relocatable module");
d4cb0ea0 3484 break;
13761a11
NC		 3485
3486 case EM_MSP430:
3487 strcat (buf, _(": architecture variant: "));
3488 switch (e_flags & EF_MSP430_MACH)
3489 {
3490 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3491 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3492 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3493 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3494 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3495 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3496 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3497 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3498 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3499 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3500 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3501 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3502 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3503 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3504 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3505 default:
3506 strcat (buf, _(": unknown")); break;
3507 }
3508
3509 if (e_flags & ~ EF_MSP430_MACH)
3510 strcat (buf, _(": unknown extra flag bits also present"));
252b5132
RH		 3511 }
3512 }
3513
3514 return buf;
3515}
3516
252b5132 3517static const char *
d3ba0551
AM		 3518get_osabi_name (unsigned int osabi)
3519{
3520 static char buff[32];
3521
3522 switch (osabi)
3523 {
3524 case ELFOSABI_NONE: return "UNIX - System V";
3525 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3526 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
9c55345c 3527 case ELFOSABI_GNU: return "UNIX - GNU";
d3ba0551
AM		 3528 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3529 case ELFOSABI_AIX: return "UNIX - AIX";
3530 case ELFOSABI_IRIX: return "UNIX - IRIX";
3531 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3532 case ELFOSABI_TRU64: return "UNIX - TRU64";
3533 case ELFOSABI_MODESTO: return "Novell - Modesto";
3534 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3535 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3536 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3b26c801 3537 case ELFOSABI_AROS: return "AROS";
11636f9e 3538 case ELFOSABI_FENIXOS: return "FenixOS";
d3ba0551 3539 default:
40b36596
JM		 3540 if (osabi >= 64)
3541 switch (elf_header.e_machine)
3542 {
3543 case EM_ARM:
3544 switch (osabi)
3545 {
3546 case ELFOSABI_ARM: return "ARM";
3547 default:
3548 break;
3549 }
3550 break;
3551
3552 case EM_MSP430:
3553 case EM_MSP430_OLD:
619ed720 3554 case EM_VISIUM:
40b36596
JM		 3555 switch (osabi)
3556 {
3557 case ELFOSABI_STANDALONE: return _("Standalone App");
3558 default:
3559 break;
3560 }
3561 break;
3562
3563 case EM_TI_C6000:
3564 switch (osabi)
3565 {
3566 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3567 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3568 default:
3569 break;
3570 }
3571 break;
3572
3573 default:
3574 break;
3575 }
e9e44622 3576 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
d3ba0551
AM		 3577 return buff;
3578 }
3579}
3580
a06ea964
NC		 3581static const char *
3582get_aarch64_segment_type (unsigned long type)
3583{
3584 switch (type)
3585 {
3586 case PT_AARCH64_ARCHEXT:
3587 return "AARCH64_ARCHEXT";
3588 default:
3589 break;
3590 }
3591
3592 return NULL;
3593}
3594
b294bdf8
MM		 3595static const char *
3596get_arm_segment_type (unsigned long type)
3597{
3598 switch (type)
3599 {
3600 case PT_ARM_EXIDX:
3601 return "EXIDX";
3602 default:
3603 break;
3604 }
3605
3606 return NULL;
3607}
3608
d3ba0551
AM		 3609static const char *
3610get_mips_segment_type (unsigned long type)
252b5132
RH		 3611{
3612 switch (type)
3613 {
3614 case PT_MIPS_REGINFO:
3615 return "REGINFO";
3616 case PT_MIPS_RTPROC:
3617 return "RTPROC";
3618 case PT_MIPS_OPTIONS:
3619 return "OPTIONS";
351cdf24
MF		 3620 case PT_MIPS_ABIFLAGS:
3621 return "ABIFLAGS";
252b5132
RH		 3622 default:
3623 break;
3624 }
3625
3626 return NULL;
3627}
3628
103f02d3 3629static const char *
d3ba0551 3630get_parisc_segment_type (unsigned long type)
103f02d3
UD		 3631{
3632 switch (type)
3633 {
3634 case PT_HP_TLS: return "HP_TLS";
3635 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3636 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3637 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3638 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3639 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3640 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3641 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3642 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3643 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3644 case PT_HP_PARALLEL: return "HP_PARALLEL";
3645 case PT_HP_FASTBIND: return "HP_FASTBIND";
eec8f817
DA		 3646 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3647 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3648 case PT_HP_STACK: return "HP_STACK";
3649 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
103f02d3
UD		 3650 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3651 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
61472819 3652 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
103f02d3
UD		 3653 default:
3654 break;
3655 }
3656
3657 return NULL;
3658}
3659
4d6ed7c8 3660static const char *
d3ba0551 3661get_ia64_segment_type (unsigned long type)
4d6ed7c8
NC		 3662{
3663 switch (type)
3664 {
3665 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3666 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
00428cca
AM		 3667 case PT_HP_TLS: return "HP_TLS";
3668 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3669 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3670 case PT_IA_64_HP_STACK: return "HP_STACK";
4d6ed7c8
NC		 3671 default:
3672 break;
3673 }
3674
3675 return NULL;
3676}
3677
40b36596
JM		 3678static const char *
3679get_tic6x_segment_type (unsigned long type)
3680{
3681 switch (type)
3682 {
3683 case PT_C6000_PHATTR: return "C6000_PHATTR";
3684 default:
3685 break;
3686 }
3687
3688 return NULL;
3689}
3690
5522f910
NC		 3691static const char *
3692get_solaris_segment_type (unsigned long type)
3693{
3694 switch (type)
3695 {
3696 case 0x6464e550: return "PT_SUNW_UNWIND";
3697 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3698 case 0x6ffffff7: return "PT_LOSUNW";
3699 case 0x6ffffffa: return "PT_SUNWBSS";
3700 case 0x6ffffffb: return "PT_SUNWSTACK";
3701 case 0x6ffffffc: return "PT_SUNWDTRACE";
3702 case 0x6ffffffd: return "PT_SUNWCAP";
3703 case 0x6fffffff: return "PT_HISUNW";
3704 default: return NULL;
3705 }
3706}
3707
252b5132 3708static const char *
d3ba0551 3709get_segment_type (unsigned long p_type)
252b5132 3710{
b34976b6 3711 static char buff[32];
252b5132
RH		 3712
3713 switch (p_type)
3714 {
b34976b6
AM		 3715 case PT_NULL: return "NULL";
3716 case PT_LOAD: return "LOAD";
252b5132 3717 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 3718 case PT_INTERP: return "INTERP";
3719 case PT_NOTE: return "NOTE";
3720 case PT_SHLIB: return "SHLIB";
3721 case PT_PHDR: return "PHDR";
13ae64f3 3722 case PT_TLS: return "TLS";
252b5132 3723
65765700
JJ		 3724 case PT_GNU_EH_FRAME:
3725 return "GNU_EH_FRAME";
2b05f1b7 3726 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 3727 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 3728
252b5132
RH		 3729 default:
3730 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3731 {
2cf0635d 3732 const char * result;
103f02d3 3733
252b5132
RH		 3734 switch (elf_header.e_machine)
3735 {
a06ea964
NC		 3736 case EM_AARCH64:
3737 result = get_aarch64_segment_type (p_type);
3738 break;
b294bdf8
MM		 3739 case EM_ARM:
3740 result = get_arm_segment_type (p_type);
3741 break;
252b5132 3742 case EM_MIPS:
4fe85591 3743 case EM_MIPS_RS3_LE:
252b5132
RH		 3744 result = get_mips_segment_type (p_type);
3745 break;
103f02d3
UD		 3746 case EM_PARISC:
3747 result = get_parisc_segment_type (p_type);
3748 break;
4d6ed7c8
NC		 3749 case EM_IA_64:
3750 result = get_ia64_segment_type (p_type);
3751 break;
40b36596
JM		 3752 case EM_TI_C6000:
3753 result = get_tic6x_segment_type (p_type);
3754 break;
252b5132
RH		 3755 default:
3756 result = NULL;
3757 break;
3758 }
103f02d3 3759
252b5132
RH		 3760 if (result != NULL)
3761 return result;
103f02d3 3762
252b5132
RH		 3763 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3764 }
3765 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 3766 {
2cf0635d 3767 const char * result;
103f02d3
UD		 3768
3769 switch (elf_header.e_machine)
3770 {
3771 case EM_PARISC:
3772 result = get_parisc_segment_type (p_type);
3773 break;
00428cca
AM		 3774 case EM_IA_64:
3775 result = get_ia64_segment_type (p_type);
3776 break;
103f02d3 3777 default:
5522f910
NC		 3778 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
3779 result = get_solaris_segment_type (p_type);
3780 else
3781 result = NULL;
103f02d3
UD		 3782 break;
3783 }
3784
3785 if (result != NULL)
3786 return result;
3787
3788 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3789 }
252b5132 3790 else
e9e44622 3791 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 3792
3793 return buff;
3794 }
3795}
3796
3797static const char *
d3ba0551 3798get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 3799{
3800 switch (sh_type)
3801 {
b34976b6
AM		 3802 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3803 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3804 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3805 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3806 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3807 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3808 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3809 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3810 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3811 case SHT_MIPS_RELD: return "MIPS_RELD";
3812 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3813 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3814 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3815 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3816 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3817 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3818 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3819 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3820 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3821 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3822 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3823 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3824 case SHT_MIPS_LINE: return "MIPS_LINE";
3825 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3826 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3827 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3828 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3829 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3830 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3831 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3832 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3833 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3834 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3835 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3836 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3837 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3838 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3839 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132 3840 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
351cdf24 3841 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
252b5132
RH		 3842 default:
3843 break;
3844 }
3845 return NULL;
3846}
3847
103f02d3 3848static const char *
d3ba0551 3849get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 3850{
3851 switch (sh_type)
3852 {
3853 case SHT_PARISC_EXT: return "PARISC_EXT";
3854 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3855 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 3856 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3857 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3858 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 3859 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 3860 default:
3861 break;
3862 }
3863 return NULL;
3864}
3865
4d6ed7c8 3866static const char *
d3ba0551 3867get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 3868{
18bd398b 3869 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 3870 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3871 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 3872
4d6ed7c8
NC		 3873 switch (sh_type)
3874 {
148b93f2
NC		 3875 case SHT_IA_64_EXT: return "IA_64_EXT";
3876 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3877 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3878 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3879 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3880 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3881 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3882 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3883 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3884 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 3885 default:
3886 break;
3887 }
3888 return NULL;
3889}
3890
d2b2c203
DJ		 3891static const char *
3892get_x86_64_section_type_name (unsigned int sh_type)
3893{
3894 switch (sh_type)
3895 {
3896 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3897 default:
3898 break;
3899 }
3900 return NULL;
3901}
3902
a06ea964
NC		 3903static const char *
3904get_aarch64_section_type_name (unsigned int sh_type)
3905{
3906 switch (sh_type)
3907 {
3908 case SHT_AARCH64_ATTRIBUTES:
3909 return "AARCH64_ATTRIBUTES";
3910 default:
3911 break;
3912 }
3913 return NULL;
3914}
3915
40a18ebd
NC		 3916static const char *
3917get_arm_section_type_name (unsigned int sh_type)
3918{
3919 switch (sh_type)
3920 {
7f6fed87
NC		 3921 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3922 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3923 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3924 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3925 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 3926 default:
3927 break;
3928 }
3929 return NULL;
3930}
3931
40b36596
JM		 3932static const char *
3933get_tic6x_section_type_name (unsigned int sh_type)
3934{
3935 switch (sh_type)
3936 {
3937 case SHT_C6000_UNWIND:
3938 return "C6000_UNWIND";
3939 case SHT_C6000_PREEMPTMAP:
3940 return "C6000_PREEMPTMAP";
3941 case SHT_C6000_ATTRIBUTES:
3942 return "C6000_ATTRIBUTES";
3943 case SHT_TI_ICODE:
3944 return "TI_ICODE";
3945 case SHT_TI_XREF:
3946 return "TI_XREF";
3947 case SHT_TI_HANDLER:
3948 return "TI_HANDLER";
3949 case SHT_TI_INITINFO:
3950 return "TI_INITINFO";
3951 case SHT_TI_PHATTRS:
3952 return "TI_PHATTRS";
3953 default:
3954 break;
3955 }
3956 return NULL;
3957}
3958
13761a11
NC		 3959static const char *
3960get_msp430x_section_type_name (unsigned int sh_type)
3961{
3962 switch (sh_type)
3963 {
3964 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
3965 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3966 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
3967 default: return NULL;
3968 }
3969}
3970
685080f2
NC		 3971static const char *
3972get_v850_section_type_name (unsigned int sh_type)
3973{
3974 switch (sh_type)
3975 {
3976 case SHT_V850_SCOMMON: return "V850 Small Common";
3977 case SHT_V850_TCOMMON: return "V850 Tiny Common";
3978 case SHT_V850_ZCOMMON: return "V850 Zero Common";
3979 case SHT_RENESAS_IOP: return "RENESAS IOP";
3980 case SHT_RENESAS_INFO: return "RENESAS INFO";
3981 default: return NULL;
3982 }
3983}
3984
252b5132 3985static const char *
d3ba0551 3986get_section_type_name (unsigned int sh_type)
252b5132 3987{
b34976b6 3988 static char buff[32];
9fb71ee4 3989 const char * result;
252b5132
RH		 3990
3991 switch (sh_type)
3992 {
3993 case SHT_NULL: return "NULL";
3994 case SHT_PROGBITS: return "PROGBITS";
3995 case SHT_SYMTAB: return "SYMTAB";
3996 case SHT_STRTAB: return "STRTAB";
3997 case SHT_RELA: return "RELA";
3998 case SHT_HASH: return "HASH";
3999 case SHT_DYNAMIC: return "DYNAMIC";
4000 case SHT_NOTE: return "NOTE";
4001 case SHT_NOBITS: return "NOBITS";
4002 case SHT_REL: return "REL";
4003 case SHT_SHLIB: return "SHLIB";
4004 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 4005 case SHT_INIT_ARRAY: return "INIT_ARRAY";
4006 case SHT_FINI_ARRAY: return "FINI_ARRAY";
4007 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 4008 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 4009 case SHT_GROUP: return "GROUP";
4010 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 4011 case SHT_GNU_verdef: return "VERDEF";
4012 case SHT_GNU_verneed: return "VERNEED";
4013 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 4014 case 0x6ffffff0: return "VERSYM";
4015 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 4016 case 0x7ffffffd: return "AUXILIARY";
4017 case 0x7fffffff: return "FILTER";
047b2264 4018 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 4019
4020 default:
4021 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4022 {
252b5132
RH		 4023 switch (elf_header.e_machine)
4024 {
4025 case EM_MIPS:
4fe85591 4026 case EM_MIPS_RS3_LE:
252b5132
RH		 4027 result = get_mips_section_type_name (sh_type);
4028 break;
103f02d3
UD		 4029 case EM_PARISC:
4030 result = get_parisc_section_type_name (sh_type);
4031 break;
4d6ed7c8
NC		 4032 case EM_IA_64:
4033 result = get_ia64_section_type_name (sh_type);
4034 break;
d2b2c203 4035 case EM_X86_64:
8a9036a4 4036 case EM_L1OM:
7a9068fe 4037 case EM_K1OM:
d2b2c203
DJ		 4038 result = get_x86_64_section_type_name (sh_type);
4039 break;
a06ea964
NC		 4040 case EM_AARCH64:
4041 result = get_aarch64_section_type_name (sh_type);
4042 break;
40a18ebd
NC		 4043 case EM_ARM:
4044 result = get_arm_section_type_name (sh_type);
4045 break;
40b36596
JM		 4046 case EM_TI_C6000:
4047 result = get_tic6x_section_type_name (sh_type);
4048 break;
13761a11
NC		 4049 case EM_MSP430:
4050 result = get_msp430x_section_type_name (sh_type);
4051 break;
685080f2
NC		 4052 case EM_V800:
4053 case EM_V850:
4054 case EM_CYGNUS_V850:
4055 result = get_v850_section_type_name (sh_type);
4056 break;
252b5132
RH		 4057 default:
4058 result = NULL;
4059 break;
4060 }
4061
4062 if (result != NULL)
4063 return result;
4064
9fb71ee4 4065 sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
252b5132
RH		 4066 }
4067 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 4068 {
148b93f2
NC		 4069 switch (elf_header.e_machine)
4070 {
4071 case EM_IA_64:
4072 result = get_ia64_section_type_name (sh_type);
4073 break;
4074 default:
fd85a6a1
NC		 4075 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4076 result = get_solaris_section_type (sh_type);
4077 else
4078 result = NULL;
148b93f2
NC		 4079 break;
4080 }
4081
4082 if (result != NULL)
4083 return result;
4084
9fb71ee4 4085 sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
148b93f2 4086 }
252b5132 4087 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
685080f2
NC		 4088 {
4089 switch (elf_header.e_machine)
4090 {
4091 case EM_V800:
4092 case EM_V850:
4093 case EM_CYGNUS_V850:
9fb71ee4 4094 result = get_v850_section_type_name (sh_type);
a9fb83be 4095 break;
685080f2 4096 default:
9fb71ee4 4097 result = NULL;
685080f2
NC		 4098 break;
4099 }
4100
9fb71ee4
NC		 4101 if (result != NULL)
4102 return result;
4103
4104 sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
685080f2 4105 }
252b5132 4106 else
a7dbfd1c
NC		 4107 /* This message is probably going to be displayed in a 15
4108 character wide field, so put the hex value first. */
4109 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 4110
252b5132
RH		 4111 return buff;
4112 }
4113}
4114
2979dc34 4115#define OPTION_DEBUG_DUMP 512
2c610e4b 4116#define OPTION_DYN_SYMS 513
fd2f0033
TT		 4117#define OPTION_DWARF_DEPTH 514
4118#define OPTION_DWARF_START 515
4723351a 4119#define OPTION_DWARF_CHECK 516
2979dc34 4120
85b1c36d 4121static struct option options[] =
252b5132 4122{
b34976b6 4123 {"all", no_argument, 0, 'a'},
252b5132
RH		 4124 {"file-header", no_argument, 0, 'h'},
4125 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 4126 {"headers", no_argument, 0, 'e'},
4127 {"histogram", no_argument, 0, 'I'},
4128 {"segments", no_argument, 0, 'l'},
4129 {"sections", no_argument, 0, 'S'},
252b5132 4130 {"section-headers", no_argument, 0, 'S'},
f5842774 4131 {"section-groups", no_argument, 0, 'g'},
5477e8a0 4132 {"section-details", no_argument, 0, 't'},
595cf52e 4133 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 4134 {"symbols", no_argument, 0, 's'},
4135 {"syms", no_argument, 0, 's'},
2c610e4b 4136 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 4137 {"relocs", no_argument, 0, 'r'},
4138 {"notes", no_argument, 0, 'n'},
4139 {"dynamic", no_argument, 0, 'd'},
a952a375 4140 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 4141 {"version-info", no_argument, 0, 'V'},
4142 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 4143 {"unwind", no_argument, 0, 'u'},
4145f1d5 4144 {"archive-index", no_argument, 0, 'c'},
b34976b6 4145 {"hex-dump", required_argument, 0, 'x'},
cf13d699 4146 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 4147 {"string-dump", required_argument, 0, 'p'},
0e602686 4148 {"decompress", no_argument, 0, 'z'},
252b5132
RH		 4149#ifdef SUPPORT_DISASSEMBLY
4150 {"instruction-dump", required_argument, 0, 'i'},
4151#endif
cf13d699 4152 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 4153
fd2f0033
TT		 4154 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
4155 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 4156 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 4157
b34976b6
AM		 4158 {"version", no_argument, 0, 'v'},
4159 {"wide", no_argument, 0, 'W'},
4160 {"help", no_argument, 0, 'H'},
4161 {0, no_argument, 0, 0}
252b5132
RH		 4162};
4163
4164static void
2cf0635d 4165usage (FILE * stream)
252b5132 4166{
92f01d61
JM		 4167 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4168 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4169 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 4170 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4171 -h --file-header Display the ELF file header\n\
4172 -l --program-headers Display the program headers\n\
4173 --segments An alias for --program-headers\n\
4174 -S --section-headers Display the sections' header\n\
4175 --sections An alias for --section-headers\n\
f5842774 4176 -g --section-groups Display the section groups\n\
5477e8a0 4177 -t --section-details Display the section details\n\
8b53311e
NC		 4178 -e --headers Equivalent to: -h -l -S\n\
4179 -s --syms Display the symbol table\n\
3f08eb35 4180 --symbols An alias for --syms\n\
2c610e4b 4181 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 4182 -n --notes Display the core notes (if present)\n\
4183 -r --relocs Display the relocations (if present)\n\
4184 -u --unwind Display the unwind info (if present)\n\
b2d38a17 4185 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 4186 -V --version-info Display the version sections (if present)\n\
1b31d05e 4187 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 4188 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 4189 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 4190 -x --hex-dump=<number|name>\n\
4191 Dump the contents of section <number|name> as bytes\n\
4192 -p --string-dump=<number|name>\n\
4193 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 4194 -R --relocated-dump=<number|name>\n\
4195 Dump the contents of section <number|name> as relocated bytes\n\
0e602686 4196 -z --decompress Decompress section before dumping it\n\
f9f0e732 4197 -w[lLiaprmfFsoRt] or\n\
1ed06042 4198 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 4199 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC		 4200 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4201 =addr,=cu_index]\n\
8b53311e 4202 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 4203 fprintf (stream, _("\
4204 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4205 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4206 or deeper\n"));
252b5132 4207#ifdef SUPPORT_DISASSEMBLY
92f01d61 4208 fprintf (stream, _("\
09c11c86
NC		 4209 -i --instruction-dump=<number|name>\n\
4210 Disassemble the contents of section <number|name>\n"));
252b5132 4211#endif
92f01d61 4212 fprintf (stream, _("\
8b53311e
NC		 4213 -I --histogram Display histogram of bucket list lengths\n\
4214 -W --wide Allow output width to exceed 80 characters\n\
07012eee 4215 @<file> Read options from <file>\n\
8b53311e
NC		 4216 -H --help Display this information\n\
4217 -v --version Display the version number of readelf\n"));
1118d252 4218
92f01d61
JM		 4219 if (REPORT_BUGS_TO[0] && stream == stdout)
4220 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 4221
92f01d61 4222 exit (stream == stdout ? 0 : 1);
252b5132
RH		 4223}
4224
18bd398b
NC		 4225/* Record the fact that the user wants the contents of section number
4226 SECTION to be displayed using the method(s) encoded as flags bits
4227 in TYPE. Note, TYPE can be zero if we are creating the array for
4228 the first time. */
4229
252b5132 4230static void
09c11c86 4231request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 4232{
4233 if (section >= num_dump_sects)
4234 {
2cf0635d 4235 dump_type * new_dump_sects;
252b5132 4236
3f5e193b
NC		 4237 new_dump_sects = (dump_type *) calloc (section + 1,
4238 sizeof (* dump_sects));
252b5132
RH		 4239
4240 if (new_dump_sects == NULL)
591a748a 4241 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 4242 else
4243 {
4244 /* Copy current flag settings. */
09c11c86 4245 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 4246
4247 free (dump_sects);
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") },
5405 /* 22 */ { STRING_COMMA_LEN ("ARM_NOREAD") },
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;
5481 case SHF_ARM_NOREAD: sindex = 22; break;
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
MG		 5539 else if (elf_header.e_machine == EM_ARM
5540 && flag == SHF_ARM_NOREAD)
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;
5628 chdr->ch_type = BYTE_GET (echdr->ch_type);
5629 chdr->ch_size = BYTE_GET (echdr->ch_size);
5630 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5631 return sizeof (*echdr);
5632 }
5633 else
5634 {
5635 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5636 chdr->ch_type = BYTE_GET (echdr->ch_type);
5637 chdr->ch_size = BYTE_GET (echdr->ch_size);
5638 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5639 return sizeof (*echdr);
5640 }
5641}
5642
252b5132 5643static int
2cf0635d 5644process_section_headers (FILE * file)
252b5132 5645{
2cf0635d 5646 Elf_Internal_Shdr * section;
b34976b6 5647 unsigned int i;
252b5132
RH		 5648
5649 section_headers = NULL;
5650
5651 if (elf_header.e_shnum == 0)
5652 {
82f2dbf7
NC		 5653 /* PR binutils/12467. */
5654 if (elf_header.e_shoff != 0)
5655 warn (_("possibly corrupt ELF file header - it has a non-zero"
5656 " section header offset, but no section headers\n"));
5657 else if (do_sections)
252b5132
RH		 5658 printf (_("\nThere are no sections in this file.\n"));
5659
5660 return 1;
5661 }
5662
5663 if (do_sections && !do_header)
9ea033b2 5664 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 5665 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5666
9ea033b2
NC		 5667 if (is_32bit_elf)
5668 {
049b0c3a 5669 if (! get_32bit_section_headers (file, FALSE))
9ea033b2
NC		 5670 return 0;
5671 }
049b0c3a 5672 else if (! get_64bit_section_headers (file, FALSE))
252b5132
RH		 5673 return 0;
5674
5675 /* Read in the string table, so that we have names to display. */
0b49d371 5676 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 5677 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 5678 {
4fbb74a6 5679 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 5680
c256ffe7
JJ		 5681 if (section->sh_size != 0)
5682 {
3f5e193b
NC		 5683 string_table = (char *) get_data (NULL, file, section->sh_offset,
5684 1, section->sh_size,
5685 _("string table"));
0de14b54 5686
c256ffe7
JJ		 5687 string_table_length = string_table != NULL ? section->sh_size : 0;
5688 }
252b5132
RH		 5689 }
5690
5691 /* Scan the sections for the dynamic symbol table
e3c8793a 5692 and dynamic string table and debug sections. */
252b5132
RH		 5693 dynamic_symbols = NULL;
5694 dynamic_strings = NULL;
5695 dynamic_syminfo = NULL;
6a40cf0c 5696 symtab_shndx_list = NULL;
103f02d3 5697
89fac5e3
RS		 5698 eh_addr_size = is_32bit_elf ? 4 : 8;
5699 switch (elf_header.e_machine)
5700 {
5701 case EM_MIPS:
5702 case EM_MIPS_RS3_LE:
5703 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5704 FDE addresses. However, the ABI also has a semi-official ILP32
5705 variant for which the normal FDE address size rules apply.
5706
5707 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5708 section, where XX is the size of longs in bits. Unfortunately,
5709 earlier compilers provided no way of distinguishing ILP32 objects
5710 from LP64 objects, so if there's any doubt, we should assume that
5711 the official LP64 form is being used. */
5712 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5713 && find_section (".gcc_compiled_long32") == NULL)
5714 eh_addr_size = 8;
5715 break;
0f56a26a
DD		 5716
5717 case EM_H8_300:
5718 case EM_H8_300H:
5719 switch (elf_header.e_flags & EF_H8_MACH)
5720 {
5721 case E_H8_MACH_H8300:
5722 case E_H8_MACH_H8300HN:
5723 case E_H8_MACH_H8300SN:
5724 case E_H8_MACH_H8300SXN:
5725 eh_addr_size = 2;
5726 break;
5727 case E_H8_MACH_H8300H:
5728 case E_H8_MACH_H8300S:
5729 case E_H8_MACH_H8300SX:
5730 eh_addr_size = 4;
5731 break;
5732 }
f4236fe4
DD		 5733 break;
5734
ff7eeb89 5735 case EM_M32C_OLD:
f4236fe4
DD		 5736 case EM_M32C:
5737 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5738 {
5739 case EF_M32C_CPU_M16C:
5740 eh_addr_size = 2;
5741 break;
5742 }
5743 break;
89fac5e3
RS		 5744 }
5745
76ca31c0
NC		 5746#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5747 do \
5748 { \
5749 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5750 if (section->sh_entsize != expected_entsize) \
9dd3a467 5751 { \
76ca31c0
NC		 5752 char buf[40]; \
5753 sprintf_vma (buf, section->sh_entsize); \
5754 /* Note: coded this way so that there is a single string for \
5755 translation. */ \
5756 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5757 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5758 (unsigned) expected_entsize); \
9dd3a467 5759 section->sh_entsize = expected_entsize; \
76ca31c0
NC		 5760 } \
5761 } \
08d8fa11 5762 while (0)
9dd3a467
NC		 5763
5764#define CHECK_ENTSIZE(section, i, type) \
08d8fa11
JJ		 5765 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5766 sizeof (Elf64_External_##type))
5767
252b5132
RH		 5768 for (i = 0, section = section_headers;
5769 i < elf_header.e_shnum;
b34976b6 5770 i++, section++)
252b5132 5771 {
2cf0635d 5772 char * name = SECTION_NAME (section);
252b5132
RH		 5773
5774 if (section->sh_type == SHT_DYNSYM)
5775 {
5776 if (dynamic_symbols != NULL)
5777 {
5778 error (_("File contains multiple dynamic symbol tables\n"));
5779 continue;
5780 }
5781
08d8fa11 5782 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 5783 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 5784 }
5785 else if (section->sh_type == SHT_STRTAB
18bd398b 5786 && streq (name, ".dynstr"))
252b5132
RH		 5787 {
5788 if (dynamic_strings != NULL)
5789 {
5790 error (_("File contains multiple dynamic string tables\n"));
5791 continue;
5792 }
5793
3f5e193b
NC		 5794 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5795 1, section->sh_size,
5796 _("dynamic strings"));
59245841 5797 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 5798 }
9ad5cbcf
AM		 5799 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5800 {
6a40cf0c
NC		 5801 elf_section_list * entry = xmalloc (sizeof * entry);
5802 entry->hdr = section;
5803 entry->next = symtab_shndx_list;
5804 symtab_shndx_list = entry;
9ad5cbcf 5805 }
08d8fa11
JJ		 5806 else if (section->sh_type == SHT_SYMTAB)
5807 CHECK_ENTSIZE (section, i, Sym);
5808 else if (section->sh_type == SHT_GROUP)
5809 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5810 else if (section->sh_type == SHT_REL)
5811 CHECK_ENTSIZE (section, i, Rel);
5812 else if (section->sh_type == SHT_RELA)
5813 CHECK_ENTSIZE (section, i, Rela);
252b5132 5814 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 5815 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 5816 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC		 5817 || do_debug_str || do_debug_loc || do_debug_ranges
5818 || do_debug_addr || do_debug_cu_index)
1b315056
CS		 5819 && (const_strneq (name, ".debug_")
5820 || const_strneq (name, ".zdebug_")))
252b5132 5821 {
1b315056
CS		 5822 if (name[1] == 'z')
5823 name += sizeof (".zdebug_") - 1;
5824 else
5825 name += sizeof (".debug_") - 1;
252b5132
RH		 5826
5827 if (do_debugging
4723351a
CC		 5828 || (do_debug_info && const_strneq (name, "info"))
5829 || (do_debug_info && const_strneq (name, "types"))
5830 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
b40bf0a2
NC		 5831 || (do_debug_lines && strcmp (name, "line") == 0)
5832 || (do_debug_lines && const_strneq (name, "line."))
4723351a
CC		 5833 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5834 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
459d52c8
DE		 5835 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5836 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
4723351a
CC		 5837 || (do_debug_aranges && const_strneq (name, "aranges"))
5838 || (do_debug_ranges && const_strneq (name, "ranges"))
5839 || (do_debug_frames && const_strneq (name, "frame"))
5840 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5841 || (do_debug_macinfo && const_strneq (name, "macro"))
5842 || (do_debug_str && const_strneq (name, "str"))
5843 || (do_debug_loc && const_strneq (name, "loc"))
657d0d47
CC		 5844 || (do_debug_addr && const_strneq (name, "addr"))
5845 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5846 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 5847 )
09c11c86 5848 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 5849 }
a262ae96 5850 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 5851 else if ((do_debugging || do_debug_info)
0112cd26 5852 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 5853 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 5854 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 5855 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 5856 else if (do_gdb_index && streq (name, ".gdb_index"))
5857 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 5858 /* Trace sections for Itanium VMS. */
5859 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5860 || do_trace_aranges)
5861 && const_strneq (name, ".trace_"))
5862 {
5863 name += sizeof (".trace_") - 1;
5864
5865 if (do_debugging
5866 || (do_trace_info && streq (name, "info"))
5867 || (do_trace_abbrevs && streq (name, "abbrev"))
5868 || (do_trace_aranges && streq (name, "aranges"))
5869 )
5870 request_dump_bynumber (i, DEBUG_DUMP);
5871 }
252b5132
RH		 5872 }
5873
5874 if (! do_sections)
5875 return 1;
5876
3a1a2036
NC		 5877 if (elf_header.e_shnum > 1)
5878 printf (_("\nSection Headers:\n"));
5879 else
5880 printf (_("\nSection Header:\n"));
76da6bbe 5881
f7a99963 5882 if (is_32bit_elf)
595cf52e 5883 {
5477e8a0 5884 if (do_section_details)
595cf52e
L		 5885 {
5886 printf (_(" [Nr] Name\n"));
5477e8a0 5887 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 5888 }
5889 else
5890 printf
5891 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5892 }
d974e256 5893 else if (do_wide)
595cf52e 5894 {
5477e8a0 5895 if (do_section_details)
595cf52e
L		 5896 {
5897 printf (_(" [Nr] Name\n"));
5477e8a0 5898 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 5899 }
5900 else
5901 printf
5902 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5903 }
f7a99963
NC		 5904 else
5905 {
5477e8a0 5906 if (do_section_details)
595cf52e
L		 5907 {
5908 printf (_(" [Nr] Name\n"));
5477e8a0
L		 5909 printf (_(" Type Address Offset Link\n"));
5910 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 5911 }
5912 else
5913 {
5914 printf (_(" [Nr] Name Type Address Offset\n"));
5915 printf (_(" Size EntSize Flags Link Info Align\n"));
5916 }
f7a99963 5917 }
252b5132 5918
5477e8a0
L		 5919 if (do_section_details)
5920 printf (_(" Flags\n"));
5921
252b5132
RH		 5922 for (i = 0, section = section_headers;
5923 i < elf_header.e_shnum;
b34976b6 5924 i++, section++)
252b5132 5925 {
7bfd842d 5926 printf (" [%2u] ", i);
5477e8a0 5927 if (do_section_details)
74e1a04b 5928 printf ("%s\n ", printable_section_name (section));
595cf52e 5929 else
74e1a04b 5930 print_symbol (-17, SECTION_NAME (section));
0b4362b0 5931
ea52a088
NC		 5932 printf (do_wide ? " %-15s " : " %-15.15s ",
5933 get_section_type_name (section->sh_type));
0b4362b0 5934
f7a99963
NC		 5935 if (is_32bit_elf)
5936 {
cfcac11d
NC		 5937 const char * link_too_big = NULL;
5938
f7a99963 5939 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 5940
f7a99963
NC		 5941 printf ( " %6.6lx %6.6lx %2.2lx",
5942 (unsigned long) section->sh_offset,
5943 (unsigned long) section->sh_size,
5944 (unsigned long) section->sh_entsize);
d1133906 5945
5477e8a0
L		 5946 if (do_section_details)
5947 fputs (" ", stdout);
5948 else
5949 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5950
cfcac11d
NC		 5951 if (section->sh_link >= elf_header.e_shnum)
5952 {
5953 link_too_big = "";
5954 /* The sh_link value is out of range. Normally this indicates
caa83f8b 5955 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 5956 switch (elf_header.e_machine)
5957 {
caa83f8b 5958 case EM_386:
22abe556 5959 case EM_IAMCU:
caa83f8b 5960 case EM_X86_64:
7f502d6c 5961 case EM_L1OM:
7a9068fe 5962 case EM_K1OM:
cfcac11d
NC		 5963 case EM_OLD_SPARCV9:
5964 case EM_SPARC32PLUS:
5965 case EM_SPARCV9:
5966 case EM_SPARC:
5967 if (section->sh_link == (SHN_BEFORE & 0xffff))
5968 link_too_big = "BEFORE";
5969 else if (section->sh_link == (SHN_AFTER & 0xffff))
5970 link_too_big = "AFTER";
5971 break;
5972 default:
5973 break;
5974 }
5975 }
5976
5977 if (do_section_details)
5978 {
5979 if (link_too_big != NULL && * link_too_big)
5980 printf ("<%s> ", link_too_big);
5981 else
5982 printf ("%2u ", section->sh_link);
5983 printf ("%3u %2lu\n", section->sh_info,
5984 (unsigned long) section->sh_addralign);
5985 }
5986 else
5987 printf ("%2u %3u %2lu\n",
5988 section->sh_link,
5989 section->sh_info,
5990 (unsigned long) section->sh_addralign);
5991
5992 if (link_too_big && ! * link_too_big)
5993 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5994 i, section->sh_link);
f7a99963 5995 }
d974e256
JJ		 5996 else if (do_wide)
5997 {
5998 print_vma (section->sh_addr, LONG_HEX);
5999
6000 if ((long) section->sh_offset == section->sh_offset)
6001 printf (" %6.6lx", (unsigned long) section->sh_offset);
6002 else
6003 {
6004 putchar (' ');
6005 print_vma (section->sh_offset, LONG_HEX);
6006 }
6007
6008 if ((unsigned long) section->sh_size == section->sh_size)
6009 printf (" %6.6lx", (unsigned long) section->sh_size);
6010 else
6011 {
6012 putchar (' ');
6013 print_vma (section->sh_size, LONG_HEX);
6014 }
6015
6016 if ((unsigned long) section->sh_entsize == section->sh_entsize)
6017 printf (" %2.2lx", (unsigned long) section->sh_entsize);
6018 else
6019 {
6020 putchar (' ');
6021 print_vma (section->sh_entsize, LONG_HEX);
6022 }
6023
5477e8a0
L		 6024 if (do_section_details)
6025 fputs (" ", stdout);
6026 else
6027 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 6028
72de5009 6029 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 6030
6031 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 6032 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 6033 else
6034 {
6035 print_vma (section->sh_addralign, DEC);
6036 putchar ('\n');
6037 }
6038 }
5477e8a0 6039 else if (do_section_details)
595cf52e 6040 {
5477e8a0 6041 printf (" %-15.15s ",
595cf52e 6042 get_section_type_name (section->sh_type));
595cf52e
L		 6043 print_vma (section->sh_addr, LONG_HEX);
6044 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 6045 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 6046 else
6047 {
6048 printf (" ");
6049 print_vma (section->sh_offset, LONG_HEX);
6050 }
72de5009 6051 printf (" %u\n ", section->sh_link);
595cf52e 6052 print_vma (section->sh_size, LONG_HEX);
5477e8a0 6053 putchar (' ');
595cf52e
L		 6054 print_vma (section->sh_entsize, LONG_HEX);
6055
72de5009
AM		 6056 printf (" %-16u %lu\n",
6057 section->sh_info,
595cf52e
L		 6058 (unsigned long) section->sh_addralign);
6059 }
f7a99963
NC		 6060 else
6061 {
6062 putchar (' ');
6063 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 6064 if ((long) section->sh_offset == section->sh_offset)
6065 printf (" %8.8lx", (unsigned long) section->sh_offset);
6066 else
6067 {
6068 printf (" ");
6069 print_vma (section->sh_offset, LONG_HEX);
6070 }
f7a99963
NC		 6071 printf ("\n ");
6072 print_vma (section->sh_size, LONG_HEX);
6073 printf (" ");
6074 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 6075
d1133906 6076 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 6077
72de5009
AM		 6078 printf (" %2u %3u %lu\n",
6079 section->sh_link,
6080 section->sh_info,
f7a99963
NC		 6081 (unsigned long) section->sh_addralign);
6082 }
5477e8a0
L		 6083
6084 if (do_section_details)
77115a4a
L		 6085 {
6086 printf (" %s\n", get_elf_section_flags (section->sh_flags));
6087 if ((section->sh_flags & SHF_COMPRESSED) != 0)
6088 {
6089 /* Minimum section size is 12 bytes for 32-bit compression
6090 header + 12 bytes for compressed data header. */
6091 unsigned char buf[24];
6092 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6093 if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
6094 sizeof (buf), _("compression header")))
6095 {
6096 Elf_Internal_Chdr chdr;
6097 get_compression_header (&chdr, buf);
6098 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6099 printf (" ZLIB, ");
6100 else
6101 printf (_(" [<unknown>: 0x%x], "),
6102 chdr.ch_type);
6103 print_vma (chdr.ch_size, LONG_HEX);
6104 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6105 }
6106 }
6107 }
252b5132
RH		 6108 }
6109
5477e8a0 6110 if (!do_section_details)
3dbcc61d 6111 {
9fb71ee4
NC		 6112 /* The ordering of the letters shown here matches the ordering of the
6113 corresponding SHF_xxx values, and hence the order in which these
6114 letters will be displayed to the user. */
6115 printf (_("Key to Flags:\n\
6116 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6117 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
fd85a6a1 6118 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
3dbcc61d 6119 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 6120 || elf_header.e_machine == EM_L1OM
6121 || elf_header.e_machine == EM_K1OM)
9fb71ee4 6122 printf (_("l (large), "));
91f68a68 6123 else if (elf_header.e_machine == EM_ARM)
9fb71ee4
NC		 6124 printf (_("y (noread), "));
6125 printf ("p (processor specific)\n");
0b4362b0 6126 }
d1133906 6127
252b5132
RH		 6128 return 1;
6129}
6130
f5842774
L		 6131static const char *
6132get_group_flags (unsigned int flags)
6133{
6134 static char buff[32];
6135 switch (flags)
6136 {
220453ec
AM		 6137 case 0:
6138 return "";
6139
f5842774 6140 case GRP_COMDAT:
220453ec 6141 return "COMDAT ";
f5842774
L		 6142
6143 default:
220453ec 6144 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 6145 break;
6146 }
6147 return buff;
6148}
6149
6150static int
2cf0635d 6151process_section_groups (FILE * file)
f5842774 6152{
2cf0635d 6153 Elf_Internal_Shdr * section;
f5842774 6154 unsigned int i;
2cf0635d
NC		 6155 struct group * group;
6156 Elf_Internal_Shdr * symtab_sec;
6157 Elf_Internal_Shdr * strtab_sec;
6158 Elf_Internal_Sym * symtab;
ba5cdace 6159 unsigned long num_syms;
2cf0635d 6160 char * strtab;
c256ffe7 6161 size_t strtab_size;
d1f5c6e3
L		 6162
6163 /* Don't process section groups unless needed. */
6164 if (!do_unwind && !do_section_groups)
6165 return 1;
f5842774
L		 6166
6167 if (elf_header.e_shnum == 0)
6168 {
6169 if (do_section_groups)
82f2dbf7 6170 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 6171
6172 return 1;
6173 }
6174
6175 if (section_headers == NULL)
6176 {
6177 error (_("Section headers are not available!\n"));
fa1908fd
NC		 6178 /* PR 13622: This can happen with a corrupt ELF header. */
6179 return 0;
f5842774
L		 6180 }
6181
3f5e193b
NC		 6182 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
6183 sizeof (struct group *));
e4b17d5c
L		 6184
6185 if (section_headers_groups == NULL)
6186 {
8b73c356
NC		 6187 error (_("Out of memory reading %u section group headers\n"),
6188 elf_header.e_shnum);
e4b17d5c
L		 6189 return 0;
6190 }
6191
f5842774 6192 /* Scan the sections for the group section. */
d1f5c6e3 6193 group_count = 0;
f5842774
L		 6194 for (i = 0, section = section_headers;
6195 i < elf_header.e_shnum;
6196 i++, section++)
e4b17d5c
L		 6197 if (section->sh_type == SHT_GROUP)
6198 group_count++;
6199
d1f5c6e3
L		 6200 if (group_count == 0)
6201 {
6202 if (do_section_groups)
6203 printf (_("\nThere are no section groups in this file.\n"));
6204
6205 return 1;
6206 }
6207
3f5e193b 6208 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 6209
6210 if (section_groups == NULL)
6211 {
8b73c356
NC		 6212 error (_("Out of memory reading %lu groups\n"),
6213 (unsigned long) group_count);
e4b17d5c
L		 6214 return 0;
6215 }
6216
d1f5c6e3
L		 6217 symtab_sec = NULL;
6218 strtab_sec = NULL;
6219 symtab = NULL;
ba5cdace 6220 num_syms = 0;
d1f5c6e3 6221 strtab = NULL;
c256ffe7 6222 strtab_size = 0;
e4b17d5c
L		 6223 for (i = 0, section = section_headers, group = section_groups;
6224 i < elf_header.e_shnum;
6225 i++, section++)
f5842774
L		 6226 {
6227 if (section->sh_type == SHT_GROUP)
6228 {
74e1a04b
NC		 6229 const char * name = printable_section_name (section);
6230 const char * group_name;
2cf0635d
NC		 6231 unsigned char * start;
6232 unsigned char * indices;
f5842774 6233 unsigned int entry, j, size;
2cf0635d
NC		 6234 Elf_Internal_Shdr * sec;
6235 Elf_Internal_Sym * sym;
f5842774
L		 6236
6237 /* Get the symbol table. */
4fbb74a6
AM		 6238 if (section->sh_link >= elf_header.e_shnum
6239 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 6240 != SHT_SYMTAB))
f5842774
L		 6241 {
6242 error (_("Bad sh_link in group section `%s'\n"), name);
6243 continue;
6244 }
d1f5c6e3
L		 6245
6246 if (symtab_sec != sec)
6247 {
6248 symtab_sec = sec;
6249 if (symtab)
6250 free (symtab);
ba5cdace 6251 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 6252 }
f5842774 6253
dd24e3da
NC		 6254 if (symtab == NULL)
6255 {
6256 error (_("Corrupt header in group section `%s'\n"), name);
6257 continue;
6258 }
6259
ba5cdace
NC		 6260 if (section->sh_info >= num_syms)
6261 {
6262 error (_("Bad sh_info in group section `%s'\n"), name);
6263 continue;
6264 }
6265
f5842774
L		 6266 sym = symtab + section->sh_info;
6267
6268 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6269 {
4fbb74a6
AM		 6270 if (sym->st_shndx == 0
6271 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 6272 {
6273 error (_("Bad sh_info in group section `%s'\n"), name);
6274 continue;
6275 }
ba2685cc 6276
4fbb74a6 6277 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 6278 strtab_sec = NULL;
6279 if (strtab)
6280 free (strtab);
f5842774 6281 strtab = NULL;
c256ffe7 6282 strtab_size = 0;
f5842774
L		 6283 }
6284 else
6285 {
6286 /* Get the string table. */
4fbb74a6 6287 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 6288 {
6289 strtab_sec = NULL;
6290 if (strtab)
6291 free (strtab);
6292 strtab = NULL;
6293 strtab_size = 0;
6294 }
6295 else if (strtab_sec
4fbb74a6 6296 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 6297 {
6298 strtab_sec = sec;
6299 if (strtab)
6300 free (strtab);
071436c6 6301
3f5e193b 6302 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
071436c6
NC		 6303 1, strtab_sec->sh_size,
6304 _("string table"));
c256ffe7 6305 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 6306 }
c256ffe7 6307 group_name = sym->st_name < strtab_size
2b692964 6308 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 6309 }
6310
c9c1d674
EG		 6311 /* PR 17531: file: loop. */
6312 if (section->sh_entsize > section->sh_size)
6313 {
6314 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6315 printable_section_name (section),
8066deb1
AM		 6316 (unsigned long) section->sh_entsize,
6317 (unsigned long) section->sh_size);
c9c1d674
EG		 6318 break;
6319 }
6320
3f5e193b
NC		 6321 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6322 1, section->sh_size,
6323 _("section data"));
59245841
NC		 6324 if (start == NULL)
6325 continue;
f5842774
L		 6326
6327 indices = start;
6328 size = (section->sh_size / section->sh_entsize) - 1;
6329 entry = byte_get (indices, 4);
6330 indices += 4;
e4b17d5c
L		 6331
6332 if (do_section_groups)
6333 {
2b692964 6334 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 6335 get_group_flags (entry), i, name, group_name, size);
ba2685cc 6336
e4b17d5c
L		 6337 printf (_(" [Index] Name\n"));
6338 }
6339
6340 group->group_index = i;
6341
f5842774
L		 6342 for (j = 0; j < size; j++)
6343 {
2cf0635d 6344 struct group_list * g;
e4b17d5c 6345
f5842774
L		 6346 entry = byte_get (indices, 4);
6347 indices += 4;
6348
4fbb74a6 6349 if (entry >= elf_header.e_shnum)
391cb864 6350 {
57028622
NC		 6351 static unsigned num_group_errors = 0;
6352
6353 if (num_group_errors ++ < 10)
6354 {
6355 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6356 entry, i, elf_header.e_shnum - 1);
6357 if (num_group_errors == 10)
6358 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6359 }
391cb864
L		 6360 continue;
6361 }
391cb864 6362
4fbb74a6 6363 if (section_headers_groups [entry] != NULL)
e4b17d5c 6364 {
d1f5c6e3
L		 6365 if (entry)
6366 {
57028622
NC		 6367 static unsigned num_errs = 0;
6368
6369 if (num_errs ++ < 10)
6370 {
6371 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6372 entry, i,
6373 section_headers_groups [entry]->group_index);
6374 if (num_errs == 10)
6375 warn (_("Further error messages about already contained group sections suppressed\n"));
6376 }
d1f5c6e3
L		 6377 continue;
6378 }
6379 else
6380 {
6381 /* Intel C/C++ compiler may put section 0 in a
6382 section group. We just warn it the first time
6383 and ignore it afterwards. */
6384 static int warned = 0;
6385 if (!warned)
6386 {
6387 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 6388 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 6389 warned++;
6390 }
6391 }
e4b17d5c
L		 6392 }
6393
4fbb74a6 6394 section_headers_groups [entry] = group;
e4b17d5c
L		 6395
6396 if (do_section_groups)
6397 {
4fbb74a6 6398 sec = section_headers + entry;
74e1a04b 6399 printf (" [%5u] %s\n", entry, printable_section_name (sec));
ba2685cc
AM		 6400 }
6401
3f5e193b 6402 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 6403 g->section_index = entry;
6404 g->next = group->root;
6405 group->root = g;
f5842774
L		 6406 }
6407
f5842774
L		 6408 if (start)
6409 free (start);
e4b17d5c
L		 6410
6411 group++;
f5842774
L		 6412 }
6413 }
6414
d1f5c6e3
L		 6415 if (symtab)
6416 free (symtab);
6417 if (strtab)
6418 free (strtab);
f5842774
L		 6419 return 1;
6420}
6421
28f997cf
TG		 6422/* Data used to display dynamic fixups. */
6423
6424struct ia64_vms_dynfixup
6425{
6426 bfd_vma needed_ident; /* Library ident number. */
6427 bfd_vma needed; /* Index in the dstrtab of the library name. */
6428 bfd_vma fixup_needed; /* Index of the library. */
6429 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6430 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6431};
6432
6433/* Data used to display dynamic relocations. */
6434
6435struct ia64_vms_dynimgrela
6436{
6437 bfd_vma img_rela_cnt; /* Number of relocations. */
6438 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6439};
6440
6441/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6442 library). */
6443
6444static void
6445dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6446 const char *strtab, unsigned int strtab_sz)
6447{
6448 Elf64_External_VMS_IMAGE_FIXUP *imfs;
6449 long i;
6450 const char *lib_name;
6451
6452 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6453 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6454 _("dynamic section image fixups"));
6455 if (!imfs)
6456 return;
6457
6458 if (fixup->needed < strtab_sz)
6459 lib_name = strtab + fixup->needed;
6460 else
6461 {
6462 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 6463 (unsigned long) fixup->needed);
28f997cf
TG		 6464 lib_name = "???";
6465 }
6466 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6467 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6468 printf
6469 (_("Seg Offset Type SymVec DataType\n"));
6470
6471 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6472 {
6473 unsigned int type;
6474 const char *rtype;
6475
6476 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6477 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6478 type = BYTE_GET (imfs [i].type);
6479 rtype = elf_ia64_reloc_type (type);
6480 if (rtype == NULL)
6481 printf (" 0x%08x ", type);
6482 else
6483 printf (" %-32s ", rtype);
6484 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6485 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6486 }
6487
6488 free (imfs);
6489}
6490
6491/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6492
6493static void
6494dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6495{
6496 Elf64_External_VMS_IMAGE_RELA *imrs;
6497 long i;
6498
6499 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6500 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 6501 _("dynamic section image relocations"));
28f997cf
TG		 6502 if (!imrs)
6503 return;
6504
6505 printf (_("\nImage relocs\n"));
6506 printf
6507 (_("Seg Offset Type Addend Seg Sym Off\n"));
6508
6509 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6510 {
6511 unsigned int type;
6512 const char *rtype;
6513
6514 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6515 printf ("%08" BFD_VMA_FMT "x ",
6516 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6517 type = BYTE_GET (imrs [i].type);
6518 rtype = elf_ia64_reloc_type (type);
6519 if (rtype == NULL)
6520 printf ("0x%08x ", type);
6521 else
6522 printf ("%-31s ", rtype);
6523 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6524 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6525 printf ("%08" BFD_VMA_FMT "x\n",
6526 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6527 }
6528
6529 free (imrs);
6530}
6531
6532/* Display IA-64 OpenVMS dynamic relocations and fixups. */
6533
6534static int
6535process_ia64_vms_dynamic_relocs (FILE *file)
6536{
6537 struct ia64_vms_dynfixup fixup;
6538 struct ia64_vms_dynimgrela imgrela;
6539 Elf_Internal_Dyn *entry;
6540 int res = 0;
6541 bfd_vma strtab_off = 0;
6542 bfd_vma strtab_sz = 0;
6543 char *strtab = NULL;
6544
6545 memset (&fixup, 0, sizeof (fixup));
6546 memset (&imgrela, 0, sizeof (imgrela));
6547
6548 /* Note: the order of the entries is specified by the OpenVMS specs. */
6549 for (entry = dynamic_section;
6550 entry < dynamic_section + dynamic_nent;
6551 entry++)
6552 {
6553 switch (entry->d_tag)
6554 {
6555 case DT_IA_64_VMS_STRTAB_OFFSET:
6556 strtab_off = entry->d_un.d_val;
6557 break;
6558 case DT_STRSZ:
6559 strtab_sz = entry->d_un.d_val;
6560 if (strtab == NULL)
6561 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6562 1, strtab_sz, _("dynamic string section"));
6563 break;
6564
6565 case DT_IA_64_VMS_NEEDED_IDENT:
6566 fixup.needed_ident = entry->d_un.d_val;
6567 break;
6568 case DT_NEEDED:
6569 fixup.needed = entry->d_un.d_val;
6570 break;
6571 case DT_IA_64_VMS_FIXUP_NEEDED:
6572 fixup.fixup_needed = entry->d_un.d_val;
6573 break;
6574 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6575 fixup.fixup_rela_cnt = entry->d_un.d_val;
6576 break;
6577 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6578 fixup.fixup_rela_off = entry->d_un.d_val;
6579 res++;
6580 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6581 break;
6582
6583 case DT_IA_64_VMS_IMG_RELA_CNT:
6584 imgrela.img_rela_cnt = entry->d_un.d_val;
6585 break;
6586 case DT_IA_64_VMS_IMG_RELA_OFF:
6587 imgrela.img_rela_off = entry->d_un.d_val;
6588 res++;
6589 dump_ia64_vms_dynamic_relocs (file, &imgrela);
6590 break;
6591
6592 default:
6593 break;
6594 }
6595 }
6596
6597 if (strtab != NULL)
6598 free (strtab);
6599
6600 return res;
6601}
6602
85b1c36d 6603static struct
566b0d53 6604{
2cf0635d 6605 const char * name;
566b0d53
L		 6606 int reloc;
6607 int size;
6608 int rela;
6609} dynamic_relocations [] =
6610{
6611 { "REL", DT_REL, DT_RELSZ, FALSE },
6612 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6613 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6614};
6615
252b5132 6616/* Process the reloc section. */
18bd398b 6617
252b5132 6618static int
2cf0635d 6619process_relocs (FILE * file)
252b5132 6620{
b34976b6
AM		 6621 unsigned long rel_size;
6622 unsigned long rel_offset;
252b5132
RH		 6623
6624
6625 if (!do_reloc)
6626 return 1;
6627
6628 if (do_using_dynamic)
6629 {
566b0d53 6630 int is_rela;
2cf0635d 6631 const char * name;
566b0d53
L		 6632 int has_dynamic_reloc;
6633 unsigned int i;
0de14b54 6634
566b0d53 6635 has_dynamic_reloc = 0;
252b5132 6636
566b0d53 6637 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 6638 {
566b0d53
L		 6639 is_rela = dynamic_relocations [i].rela;
6640 name = dynamic_relocations [i].name;
6641 rel_size = dynamic_info [dynamic_relocations [i].size];
6642 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 6643
566b0d53
L		 6644 has_dynamic_reloc |= rel_size;
6645
6646 if (is_rela == UNKNOWN)
aa903cfb 6647 {
566b0d53
L		 6648 if (dynamic_relocations [i].reloc == DT_JMPREL)
6649 switch (dynamic_info[DT_PLTREL])
6650 {
6651 case DT_REL:
6652 is_rela = FALSE;
6653 break;
6654 case DT_RELA:
6655 is_rela = TRUE;
6656 break;
6657 }
aa903cfb 6658 }
252b5132 6659
566b0d53
L		 6660 if (rel_size)
6661 {
6662 printf
6663 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6664 name, rel_offset, rel_size);
252b5132 6665
d93f0186
NC		 6666 dump_relocations (file,
6667 offset_from_vma (file, rel_offset, rel_size),
6668 rel_size,
566b0d53 6669 dynamic_symbols, num_dynamic_syms,
bb4d2ac2
L		 6670 dynamic_strings, dynamic_strings_length,
6671 is_rela, 1);
566b0d53 6672 }
252b5132 6673 }
566b0d53 6674
28f997cf
TG		 6675 if (is_ia64_vms ())
6676 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6677
566b0d53 6678 if (! has_dynamic_reloc)
252b5132
RH		 6679 printf (_("\nThere are no dynamic relocations in this file.\n"));
6680 }
6681 else
6682 {
2cf0635d 6683 Elf_Internal_Shdr * section;
b34976b6
AM		 6684 unsigned long i;
6685 int found = 0;
252b5132
RH		 6686
6687 for (i = 0, section = section_headers;
6688 i < elf_header.e_shnum;
b34976b6 6689 i++, section++)
252b5132
RH		 6690 {
6691 if ( section->sh_type != SHT_RELA
6692 && section->sh_type != SHT_REL)
6693 continue;
6694
6695 rel_offset = section->sh_offset;
6696 rel_size = section->sh_size;
6697
6698 if (rel_size)
6699 {
2cf0635d 6700 Elf_Internal_Shdr * strsec;
b34976b6 6701 int is_rela;
103f02d3 6702
252b5132
RH		 6703 printf (_("\nRelocation section "));
6704
6705 if (string_table == NULL)
19936277 6706 printf ("%d", section->sh_name);
252b5132 6707 else
74e1a04b 6708 printf ("'%s'", printable_section_name (section));
252b5132
RH		 6709
6710 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6711 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6712
d79b3d50
NC		 6713 is_rela = section->sh_type == SHT_RELA;
6714
4fbb74a6
AM		 6715 if (section->sh_link != 0
6716 && section->sh_link < elf_header.e_shnum)
af3fc3bc 6717 {
2cf0635d
NC		 6718 Elf_Internal_Shdr * symsec;
6719 Elf_Internal_Sym * symtab;
d79b3d50 6720 unsigned long nsyms;
c256ffe7 6721 unsigned long strtablen = 0;
2cf0635d 6722 char * strtab = NULL;
57346661 6723
4fbb74a6 6724 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 6725 if (symsec->sh_type != SHT_SYMTAB
6726 && symsec->sh_type != SHT_DYNSYM)
6727 continue;
6728
ba5cdace 6729 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 6730
af3fc3bc
AM		 6731 if (symtab == NULL)
6732 continue;
252b5132 6733
4fbb74a6
AM		 6734 if (symsec->sh_link != 0
6735 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 6736 {
4fbb74a6 6737 strsec = section_headers + symsec->sh_link;
103f02d3 6738
3f5e193b 6739 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
071436c6
NC		 6740 1, strsec->sh_size,
6741 _("string table"));
c256ffe7
JJ		 6742 strtablen = strtab == NULL ? 0 : strsec->sh_size;
6743 }
252b5132 6744
d79b3d50 6745 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2
L		 6746 symtab, nsyms, strtab, strtablen,
6747 is_rela,
6748 symsec->sh_type == SHT_DYNSYM);
d79b3d50
NC		 6749 if (strtab)
6750 free (strtab);
6751 free (symtab);
6752 }
6753 else
6754 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2 6755 NULL, 0, NULL, 0, is_rela, 0);
252b5132
RH		 6756
6757 found = 1;
6758 }
6759 }
6760
6761 if (! found)
6762 printf (_("\nThere are no relocations in this file.\n"));
6763 }
6764
6765 return 1;
6766}
6767
4d6ed7c8
NC		 6768/* An absolute address consists of a section and an offset. If the
6769 section is NULL, the offset itself is the address, otherwise, the
6770 address equals to LOAD_ADDRESS(section) + offset. */
6771
6772struct absaddr
948f632f
DA		 6773{
6774 unsigned short section;
6775 bfd_vma offset;
6776};
4d6ed7c8 6777
1949de15
L		 6778#define ABSADDR(a) \
6779 ((a).section \
6780 ? section_headers [(a).section].sh_addr + (a).offset \
6781 : (a).offset)
6782
948f632f
DA		 6783/* Find the nearest symbol at or below ADDR. Returns the symbol
6784 name, if found, and the offset from the symbol to ADDR. */
4d6ed7c8 6785
4d6ed7c8 6786static void
2cf0635d 6787find_symbol_for_address (Elf_Internal_Sym * symtab,
948f632f
DA		 6788 unsigned long nsyms,
6789 const char * strtab,
6790 unsigned long strtab_size,
6791 struct absaddr addr,
6792 const char ** symname,
6793 bfd_vma * offset)
4d6ed7c8 6794{
d3ba0551 6795 bfd_vma dist = 0x100000;
2cf0635d 6796 Elf_Internal_Sym * sym;
948f632f
DA		 6797 Elf_Internal_Sym * beg;
6798 Elf_Internal_Sym * end;
2cf0635d 6799 Elf_Internal_Sym * best = NULL;
4d6ed7c8 6800
0b6ae522 6801 REMOVE_ARCH_BITS (addr.offset);
948f632f
DA		 6802 beg = symtab;
6803 end = symtab + nsyms;
0b6ae522 6804
948f632f 6805 while (beg < end)
4d6ed7c8 6806 {
948f632f
DA		 6807 bfd_vma value;
6808
6809 sym = beg + (end - beg) / 2;
0b6ae522 6810
948f632f 6811 value = sym->st_value;
0b6ae522
DJ		 6812 REMOVE_ARCH_BITS (value);
6813
948f632f 6814 if (sym->st_name != 0
4d6ed7c8 6815 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 6816 && addr.offset >= value
6817 && addr.offset - value < dist)
4d6ed7c8
NC		 6818 {
6819 best = sym;
0b6ae522 6820 dist = addr.offset - value;
4d6ed7c8
NC		 6821 if (!dist)
6822 break;
6823 }
948f632f
DA		 6824
6825 if (addr.offset < value)
6826 end = sym;
6827 else
6828 beg = sym + 1;
4d6ed7c8 6829 }
1b31d05e 6830
4d6ed7c8
NC		 6831 if (best)
6832 {
57346661 6833 *symname = (best->st_name >= strtab_size
2b692964 6834 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 6835 *offset = dist;
6836 return;
6837 }
1b31d05e 6838
4d6ed7c8
NC		 6839 *symname = NULL;
6840 *offset = addr.offset;
6841}
6842
948f632f
DA		 6843static int
6844symcmp (const void *p, const void *q)
6845{
6846 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
6847 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
6848
6849 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
6850}
6851
6852/* Process the unwind section. */
6853
6854#include "unwind-ia64.h"
6855
6856struct ia64_unw_table_entry
6857{
6858 struct absaddr start;
6859 struct absaddr end;
6860 struct absaddr info;
6861};
6862
6863struct ia64_unw_aux_info
6864{
6865 struct ia64_unw_table_entry *table; /* Unwind table. */
6866 unsigned long table_len; /* Length of unwind table. */
6867 unsigned char * info; /* Unwind info. */
6868 unsigned long info_size; /* Size of unwind info. */
6869 bfd_vma info_addr; /* Starting address of unwind info. */
6870 bfd_vma seg_base; /* Starting address of segment. */
6871 Elf_Internal_Sym * symtab; /* The symbol table. */
6872 unsigned long nsyms; /* Number of symbols. */
6873 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
6874 unsigned long nfuns; /* Number of entries in funtab. */
6875 char * strtab; /* The string table. */
6876 unsigned long strtab_size; /* Size of string table. */
6877};
6878
4d6ed7c8 6879static void
2cf0635d 6880dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 6881{
2cf0635d 6882 struct ia64_unw_table_entry * tp;
948f632f 6883 unsigned long j, nfuns;
4d6ed7c8 6884 int in_body;
7036c0e1 6885
948f632f
DA		 6886 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
6887 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
6888 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
6889 aux->funtab[nfuns++] = aux->symtab[j];
6890 aux->nfuns = nfuns;
6891 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
6892
4d6ed7c8
NC		 6893 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6894 {
6895 bfd_vma stamp;
6896 bfd_vma offset;
2cf0635d
NC		 6897 const unsigned char * dp;
6898 const unsigned char * head;
53774b7e 6899 const unsigned char * end;
2cf0635d 6900 const char * procname;
4d6ed7c8 6901
948f632f 6902 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661 6903 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 6904
6905 fputs ("\n<", stdout);
6906
6907 if (procname)
6908 {
6909 fputs (procname, stdout);
6910
6911 if (offset)
6912 printf ("+%lx", (unsigned long) offset);
6913 }
6914
6915 fputs (">: [", stdout);
6916 print_vma (tp->start.offset, PREFIX_HEX);
6917 fputc ('-', stdout);
6918 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 6919 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 6920 (unsigned long) (tp->info.offset - aux->seg_base));
6921
53774b7e
NC		 6922 /* PR 17531: file: 86232b32. */
6923 if (aux->info == NULL)
6924 continue;
6925
6926 /* PR 17531: file: 0997b4d1. */
6927 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
6928 {
6929 warn (_("Invalid offset %lx in table entry %ld\n"),
6930 (long) tp->info.offset, (long) (tp - aux->table));
6931 continue;
6932 }
6933
1949de15 6934 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 6935 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 6936
86f55779 6937 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 6938 (unsigned) UNW_VER (stamp),
6939 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6940 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6941 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 6942 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 6943
6944 if (UNW_VER (stamp) != 1)
6945 {
2b692964 6946 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 6947 continue;
6948 }
6949
6950 in_body = 0;
53774b7e
NC		 6951 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
6952 /* PR 17531: file: 16ceda89. */
6953 if (end > aux->info + aux->info_size)
6954 end = aux->info + aux->info_size;
6955 for (dp = head + 8; dp < end;)
b4477bc8 6956 dp = unw_decode (dp, in_body, & in_body, end);
4d6ed7c8 6957 }
948f632f
DA		 6958
6959 free (aux->funtab);
4d6ed7c8
NC		 6960}
6961
53774b7e 6962static bfd_boolean
2cf0635d
NC		 6963slurp_ia64_unwind_table (FILE * file,
6964 struct ia64_unw_aux_info * aux,
6965 Elf_Internal_Shdr * sec)
4d6ed7c8 6966{
89fac5e3 6967 unsigned long size, nrelas, i;
2cf0635d
NC		 6968 Elf_Internal_Phdr * seg;
6969 struct ia64_unw_table_entry * tep;
6970 Elf_Internal_Shdr * relsec;
6971 Elf_Internal_Rela * rela;
6972 Elf_Internal_Rela * rp;
6973 unsigned char * table;
6974 unsigned char * tp;
6975 Elf_Internal_Sym * sym;
6976 const char * relname;
4d6ed7c8 6977
53774b7e
NC		 6978 aux->table_len = 0;
6979
4d6ed7c8
NC		 6980 /* First, find the starting address of the segment that includes
6981 this section: */
6982
6983 if (elf_header.e_phnum)
6984 {
d93f0186 6985 if (! get_program_headers (file))
53774b7e 6986 return FALSE;
4d6ed7c8 6987
d93f0186
NC		 6988 for (seg = program_headers;
6989 seg < program_headers + elf_header.e_phnum;
6990 ++seg)
4d6ed7c8
NC		 6991 {
6992 if (seg->p_type != PT_LOAD)
6993 continue;
6994
6995 if (sec->sh_addr >= seg->p_vaddr
6996 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6997 {
6998 aux->seg_base = seg->p_vaddr;
6999 break;
7000 }
7001 }
4d6ed7c8
NC		 7002 }
7003
7004 /* Second, build the unwind table from the contents of the unwind section: */
7005 size = sec->sh_size;
3f5e193b
NC		 7006 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7007 _("unwind table"));
a6e9f9df 7008 if (!table)
53774b7e 7009 return FALSE;
4d6ed7c8 7010
53774b7e 7011 aux->table_len = size / (3 * eh_addr_size);
3f5e193b 7012 aux->table = (struct ia64_unw_table_entry *)
53774b7e 7013 xcmalloc (aux->table_len, sizeof (aux->table[0]));
89fac5e3 7014 tep = aux->table;
53774b7e
NC		 7015
7016 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
4d6ed7c8
NC		 7017 {
7018 tep->start.section = SHN_UNDEF;
7019 tep->end.section = SHN_UNDEF;
7020 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 7021 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7022 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7023 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 7024 tep->start.offset += aux->seg_base;
7025 tep->end.offset += aux->seg_base;
7026 tep->info.offset += aux->seg_base;
7027 }
7028 free (table);
7029
41e92641 7030 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 7031 for (relsec = section_headers;
7032 relsec < section_headers + elf_header.e_shnum;
7033 ++relsec)
7034 {
7035 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 7036 || relsec->sh_info >= elf_header.e_shnum
7037 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 7038 continue;
7039
7040 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7041 & rela, & nrelas))
53774b7e
NC		 7042 {
7043 free (aux->table);
7044 aux->table = NULL;
7045 aux->table_len = 0;
7046 return FALSE;
7047 }
4d6ed7c8
NC		 7048
7049 for (rp = rela; rp < rela + nrelas; ++rp)
7050 {
aca88567
NC		 7051 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
7052 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 7053
82b1b41b
NC		 7054 /* PR 17531: file: 9fa67536. */
7055 if (relname == NULL)
7056 {
7057 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
7058 continue;
7059 }
948f632f 7060
0112cd26 7061 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 7062 {
82b1b41b 7063 warn (_("Skipping unexpected relocation type: %s\n"), relname);
4d6ed7c8
NC		 7064 continue;
7065 }
7066
89fac5e3 7067 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 7068
53774b7e
NC		 7069 /* PR 17531: file: 5bc8d9bf. */
7070 if (i >= aux->table_len)
7071 {
7072 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7073 continue;
7074 }
7075
7076 switch (rp->r_offset / eh_addr_size % 3)
4d6ed7c8
NC		 7077 {
7078 case 0:
7079 aux->table[i].start.section = sym->st_shndx;
e466bc6e 7080 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 7081 break;
7082 case 1:
7083 aux->table[i].end.section = sym->st_shndx;
e466bc6e 7084 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 7085 break;
7086 case 2:
7087 aux->table[i].info.section = sym->st_shndx;
e466bc6e 7088 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 7089 break;
7090 default:
7091 break;
7092 }
7093 }
7094
7095 free (rela);
7096 }
7097
53774b7e 7098 return TRUE;
4d6ed7c8
NC		 7099}
7100
1b31d05e 7101static void
2cf0635d 7102ia64_process_unwind (FILE * file)
4d6ed7c8 7103{
2cf0635d
NC		 7104 Elf_Internal_Shdr * sec;
7105 Elf_Internal_Shdr * unwsec = NULL;
7106 Elf_Internal_Shdr * strsec;
89fac5e3 7107 unsigned long i, unwcount = 0, unwstart = 0;
57346661 7108 struct ia64_unw_aux_info aux;
f1467e33 7109
4d6ed7c8
NC		 7110 memset (& aux, 0, sizeof (aux));
7111
4d6ed7c8
NC		 7112 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7113 {
c256ffe7 7114 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 7115 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 7116 {
ba5cdace 7117 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 7118
4fbb74a6 7119 strsec = section_headers + sec->sh_link;
4082ef84
NC		 7120 if (aux.strtab != NULL)
7121 {
7122 error (_("Multiple auxillary string tables encountered\n"));
7123 free (aux.strtab);
7124 }
3f5e193b
NC		 7125 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7126 1, strsec->sh_size,
7127 _("string table"));
c256ffe7 7128 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 7129 }
7130 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 7131 unwcount++;
7132 }
7133
7134 if (!unwcount)
7135 printf (_("\nThere are no unwind sections in this file.\n"));
7136
7137 while (unwcount-- > 0)
7138 {
2cf0635d 7139 char * suffix;
579f31ac
JJ		 7140 size_t len, len2;
7141
4082ef84 7142 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
579f31ac
JJ		 7143 i < elf_header.e_shnum; ++i, ++sec)
7144 if (sec->sh_type == SHT_IA_64_UNWIND)
7145 {
7146 unwsec = sec;
7147 break;
7148 }
4082ef84
NC		 7149 /* We have already counted the number of SHT_IA64_UNWIND
7150 sections so the loop above should never fail. */
7151 assert (unwsec != NULL);
579f31ac
JJ		 7152
7153 unwstart = i + 1;
7154 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7155
e4b17d5c
L		 7156 if ((unwsec->sh_flags & SHF_GROUP) != 0)
7157 {
7158 /* We need to find which section group it is in. */
4082ef84 7159 struct group_list * g;
e4b17d5c 7160
4082ef84
NC		 7161 if (section_headers_groups == NULL
7162 || section_headers_groups [i] == NULL)
7163 i = elf_header.e_shnum;
7164 else
e4b17d5c 7165 {
4082ef84 7166 g = section_headers_groups [i]->root;
18bd398b 7167
4082ef84
NC		 7168 for (; g != NULL; g = g->next)
7169 {
7170 sec = section_headers + g->section_index;
e4b17d5c 7171
4082ef84
NC		 7172 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7173 break;
7174 }
7175
7176 if (g == NULL)
7177 i = elf_header.e_shnum;
7178 }
e4b17d5c 7179 }
18bd398b 7180 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 7181 {
18bd398b 7182 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 7183 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7184 suffix = SECTION_NAME (unwsec) + len;
7185 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7186 ++i, ++sec)
18bd398b
NC		 7187 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7188 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 7189 break;
7190 }
7191 else
7192 {
7193 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 7194 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 7195 len = sizeof (ELF_STRING_ia64_unwind) - 1;
7196 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7197 suffix = "";
18bd398b 7198 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 7199 suffix = SECTION_NAME (unwsec) + len;
7200 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7201 ++i, ++sec)
18bd398b
NC		 7202 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7203 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 7204 break;
7205 }
7206
7207 if (i == elf_header.e_shnum)
7208 {
7209 printf (_("\nCould not find unwind info section for "));
7210
7211 if (string_table == NULL)
7212 printf ("%d", unwsec->sh_name);
7213 else
74e1a04b 7214 printf ("'%s'", printable_section_name (unwsec));
579f31ac
JJ		 7215 }
7216 else
4d6ed7c8 7217 {
4d6ed7c8 7218 aux.info_addr = sec->sh_addr;
3f5e193b 7219 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
4082ef84
NC		 7220 sec->sh_size,
7221 _("unwind info"));
59245841 7222 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 7223
579f31ac 7224 printf (_("\nUnwind section "));
4d6ed7c8 7225
579f31ac
JJ		 7226 if (string_table == NULL)
7227 printf ("%d", unwsec->sh_name);
7228 else
74e1a04b 7229 printf ("'%s'", printable_section_name (unwsec));
4d6ed7c8 7230
579f31ac 7231 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 7232 (unsigned long) unwsec->sh_offset,
89fac5e3 7233 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 7234
53774b7e
NC		 7235 if (slurp_ia64_unwind_table (file, & aux, unwsec)
7236 && aux.table_len > 0)
579f31ac
JJ		 7237 dump_ia64_unwind (& aux);
7238
7239 if (aux.table)
7240 free ((char *) aux.table);
7241 if (aux.info)
7242 free ((char *) aux.info);
7243 aux.table = NULL;
7244 aux.info = NULL;
7245 }
4d6ed7c8 7246 }
4d6ed7c8 7247
4d6ed7c8
NC		 7248 if (aux.symtab)
7249 free (aux.symtab);
7250 if (aux.strtab)
7251 free ((char *) aux.strtab);
4d6ed7c8
NC		 7252}
7253
3f5e193b
NC		 7254struct hppa_unw_table_entry
7255 {
7256 struct absaddr start;
7257 struct absaddr end;
948f632f 7258 unsigned int Cannot_unwind:1; /* 0 */
3f5e193b
NC		 7259 unsigned int Millicode:1; /* 1 */
7260 unsigned int Millicode_save_sr0:1; /* 2 */
7261 unsigned int Region_description:2; /* 3..4 */
7262 unsigned int reserved1:1; /* 5 */
7263 unsigned int Entry_SR:1; /* 6 */
7264 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
7265 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
7266 unsigned int Args_stored:1; /* 16 */
948f632f
DA		 7267 unsigned int Variable_Frame:1; /* 17 */
7268 unsigned int Separate_Package_Body:1; /* 18 */
3f5e193b 7269 unsigned int Frame_Extension_Millicode:1; /* 19 */
948f632f
DA		 7270 unsigned int Stack_Overflow_Check:1; /* 20 */
7271 unsigned int Two_Instruction_SP_Increment:1;/* 21 */
3f5e193b
NC		 7272 unsigned int Ada_Region:1; /* 22 */
7273 unsigned int cxx_info:1; /* 23 */
948f632f
DA		 7274 unsigned int cxx_try_catch:1; /* 24 */
7275 unsigned int sched_entry_seq:1; /* 25 */
3f5e193b 7276 unsigned int reserved2:1; /* 26 */
948f632f
DA		 7277 unsigned int Save_SP:1; /* 27 */
7278 unsigned int Save_RP:1; /* 28 */
3f5e193b
NC		 7279 unsigned int Save_MRP_in_frame:1; /* 29 */
7280 unsigned int extn_ptr_defined:1; /* 30 */
948f632f 7281 unsigned int Cleanup_defined:1; /* 31 */
3f5e193b 7282
948f632f
DA		 7283 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
7284 unsigned int HP_UX_interrupt_marker:1; /* 1 */
3f5e193b 7285 unsigned int Large_frame:1; /* 2 */
948f632f 7286 unsigned int Pseudo_SP_Set:1; /* 3 */
3f5e193b
NC		 7287 unsigned int reserved4:1; /* 4 */
7288 unsigned int Total_frame_size:27; /* 5..31 */
7289 };
7290
57346661 7291struct hppa_unw_aux_info
948f632f
DA		 7292{
7293 struct hppa_unw_table_entry * table; /* Unwind table. */
7294 unsigned long table_len; /* Length of unwind table. */
7295 bfd_vma seg_base; /* Starting address of segment. */
7296 Elf_Internal_Sym * symtab; /* The symbol table. */
7297 unsigned long nsyms; /* Number of symbols. */
7298 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7299 unsigned long nfuns; /* Number of entries in funtab. */
7300 char * strtab; /* The string table. */
7301 unsigned long strtab_size; /* Size of string table. */
7302};
57346661
AM		 7303
7304static void
2cf0635d 7305dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 7306{
2cf0635d 7307 struct hppa_unw_table_entry * tp;
948f632f
DA		 7308 unsigned long j, nfuns;
7309
7310 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7311 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7312 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7313 aux->funtab[nfuns++] = aux->symtab[j];
7314 aux->nfuns = nfuns;
7315 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
57346661 7316
57346661
AM		 7317 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7318 {
7319 bfd_vma offset;
2cf0635d 7320 const char * procname;
57346661 7321
948f632f 7322 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661
AM		 7323 aux->strtab_size, tp->start, &procname,
7324 &offset);
7325
7326 fputs ("\n<", stdout);
7327
7328 if (procname)
7329 {
7330 fputs (procname, stdout);
7331
7332 if (offset)
7333 printf ("+%lx", (unsigned long) offset);
7334 }
7335
7336 fputs (">: [", stdout);
7337 print_vma (tp->start.offset, PREFIX_HEX);
7338 fputc ('-', stdout);
7339 print_vma (tp->end.offset, PREFIX_HEX);
7340 printf ("]\n\t");
7341
18bd398b
NC		 7342#define PF(_m) if (tp->_m) printf (#_m " ");
7343#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 7344 PF(Cannot_unwind);
7345 PF(Millicode);
7346 PF(Millicode_save_sr0);
18bd398b 7347 /* PV(Region_description); */
57346661
AM		 7348 PF(Entry_SR);
7349 PV(Entry_FR);
7350 PV(Entry_GR);
7351 PF(Args_stored);
7352 PF(Variable_Frame);
7353 PF(Separate_Package_Body);
7354 PF(Frame_Extension_Millicode);
7355 PF(Stack_Overflow_Check);
7356 PF(Two_Instruction_SP_Increment);
7357 PF(Ada_Region);
7358 PF(cxx_info);
7359 PF(cxx_try_catch);
7360 PF(sched_entry_seq);
7361 PF(Save_SP);
7362 PF(Save_RP);
7363 PF(Save_MRP_in_frame);
7364 PF(extn_ptr_defined);
7365 PF(Cleanup_defined);
7366 PF(MPE_XL_interrupt_marker);
7367 PF(HP_UX_interrupt_marker);
7368 PF(Large_frame);
7369 PF(Pseudo_SP_Set);
7370 PV(Total_frame_size);
7371#undef PF
7372#undef PV
7373 }
7374
18bd398b 7375 printf ("\n");
948f632f
DA		 7376
7377 free (aux->funtab);
57346661
AM		 7378}
7379
7380static int
2cf0635d
NC		 7381slurp_hppa_unwind_table (FILE * file,
7382 struct hppa_unw_aux_info * aux,
7383 Elf_Internal_Shdr * sec)
57346661 7384{
1c0751b2 7385 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 7386 Elf_Internal_Phdr * seg;
7387 struct hppa_unw_table_entry * tep;
7388 Elf_Internal_Shdr * relsec;
7389 Elf_Internal_Rela * rela;
7390 Elf_Internal_Rela * rp;
7391 unsigned char * table;
7392 unsigned char * tp;
7393 Elf_Internal_Sym * sym;
7394 const char * relname;
57346661 7395
57346661
AM		 7396 /* First, find the starting address of the segment that includes
7397 this section. */
7398
7399 if (elf_header.e_phnum)
7400 {
7401 if (! get_program_headers (file))
7402 return 0;
7403
7404 for (seg = program_headers;
7405 seg < program_headers + elf_header.e_phnum;
7406 ++seg)
7407 {
7408 if (seg->p_type != PT_LOAD)
7409 continue;
7410
7411 if (sec->sh_addr >= seg->p_vaddr
7412 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7413 {
7414 aux->seg_base = seg->p_vaddr;
7415 break;
7416 }
7417 }
7418 }
7419
7420 /* Second, build the unwind table from the contents of the unwind
7421 section. */
7422 size = sec->sh_size;
3f5e193b
NC		 7423 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7424 _("unwind table"));
57346661
AM		 7425 if (!table)
7426 return 0;
7427
1c0751b2
DA		 7428 unw_ent_size = 16;
7429 nentries = size / unw_ent_size;
7430 size = unw_ent_size * nentries;
57346661 7431
3f5e193b
NC		 7432 tep = aux->table = (struct hppa_unw_table_entry *)
7433 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 7434
1c0751b2 7435 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 7436 {
7437 unsigned int tmp1, tmp2;
7438
7439 tep->start.section = SHN_UNDEF;
7440 tep->end.section = SHN_UNDEF;
7441
1c0751b2
DA		 7442 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7443 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7444 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7445 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7446
7447 tep->start.offset += aux->seg_base;
7448 tep->end.offset += aux->seg_base;
57346661
AM		 7449
7450 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7451 tep->Millicode = (tmp1 >> 30) & 0x1;
7452 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7453 tep->Region_description = (tmp1 >> 27) & 0x3;
7454 tep->reserved1 = (tmp1 >> 26) & 0x1;
7455 tep->Entry_SR = (tmp1 >> 25) & 0x1;
7456 tep->Entry_FR = (tmp1 >> 21) & 0xf;
7457 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7458 tep->Args_stored = (tmp1 >> 15) & 0x1;
7459 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7460 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7461 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7462 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7463 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7464 tep->Ada_Region = (tmp1 >> 9) & 0x1;
7465 tep->cxx_info = (tmp1 >> 8) & 0x1;
7466 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7467 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7468 tep->reserved2 = (tmp1 >> 5) & 0x1;
7469 tep->Save_SP = (tmp1 >> 4) & 0x1;
7470 tep->Save_RP = (tmp1 >> 3) & 0x1;
7471 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7472 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7473 tep->Cleanup_defined = tmp1 & 0x1;
7474
7475 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7476 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7477 tep->Large_frame = (tmp2 >> 29) & 0x1;
7478 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7479 tep->reserved4 = (tmp2 >> 27) & 0x1;
7480 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 7481 }
7482 free (table);
7483
7484 /* Third, apply any relocations to the unwind table. */
57346661
AM		 7485 for (relsec = section_headers;
7486 relsec < section_headers + elf_header.e_shnum;
7487 ++relsec)
7488 {
7489 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 7490 || relsec->sh_info >= elf_header.e_shnum
7491 || section_headers + relsec->sh_info != sec)
57346661
AM		 7492 continue;
7493
7494 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7495 & rela, & nrelas))
7496 return 0;
7497
7498 for (rp = rela; rp < rela + nrelas; ++rp)
7499 {
aca88567
NC		 7500 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7501 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 7502
7503 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 7504 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 7505 {
7506 warn (_("Skipping unexpected relocation type %s\n"), relname);
7507 continue;
7508 }
7509
7510 i = rp->r_offset / unw_ent_size;
7511
89fac5e3 7512 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 7513 {
7514 case 0:
7515 aux->table[i].start.section = sym->st_shndx;
1e456d54 7516 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 7517 break;
7518 case 1:
7519 aux->table[i].end.section = sym->st_shndx;
1e456d54 7520 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 7521 break;
7522 default:
7523 break;
7524 }
7525 }
7526
7527 free (rela);
7528 }
7529
1c0751b2 7530 aux->table_len = nentries;
57346661
AM		 7531
7532 return 1;
7533}
7534
1b31d05e 7535static void
2cf0635d 7536hppa_process_unwind (FILE * file)
57346661 7537{
57346661 7538 struct hppa_unw_aux_info aux;
2cf0635d
NC		 7539 Elf_Internal_Shdr * unwsec = NULL;
7540 Elf_Internal_Shdr * strsec;
7541 Elf_Internal_Shdr * sec;
18bd398b 7542 unsigned long i;
57346661 7543
c256ffe7 7544 if (string_table == NULL)
1b31d05e
NC		 7545 return;
7546
7547 memset (& aux, 0, sizeof (aux));
57346661
AM		 7548
7549 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7550 {
c256ffe7 7551 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 7552 && sec->sh_link < elf_header.e_shnum)
57346661 7553 {
ba5cdace 7554 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 7555
4fbb74a6 7556 strsec = section_headers + sec->sh_link;
4082ef84
NC		 7557 if (aux.strtab != NULL)
7558 {
7559 error (_("Multiple auxillary string tables encountered\n"));
7560 free (aux.strtab);
7561 }
3f5e193b
NC		 7562 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7563 1, strsec->sh_size,
7564 _("string table"));
c256ffe7 7565 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 7566 }
18bd398b 7567 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 7568 unwsec = sec;
7569 }
7570
7571 if (!unwsec)
7572 printf (_("\nThere are no unwind sections in this file.\n"));
7573
7574 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7575 {
18bd398b 7576 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 7577 {
74e1a04b
NC		 7578 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7579 printable_section_name (sec),
57346661 7580 (unsigned long) sec->sh_offset,
89fac5e3 7581 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 7582
7583 slurp_hppa_unwind_table (file, &aux, sec);
7584 if (aux.table_len > 0)
7585 dump_hppa_unwind (&aux);
7586
7587 if (aux.table)
7588 free ((char *) aux.table);
7589 aux.table = NULL;
7590 }
7591 }
7592
7593 if (aux.symtab)
7594 free (aux.symtab);
7595 if (aux.strtab)
7596 free ((char *) aux.strtab);
57346661
AM		 7597}
7598
0b6ae522
DJ		 7599struct arm_section
7600{
a734115a
NC		 7601 unsigned char * data; /* The unwind data. */
7602 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
7603 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
7604 unsigned long nrelas; /* The number of relocations. */
7605 unsigned int rel_type; /* REL or RELA ? */
7606 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 7607};
7608
7609struct arm_unw_aux_info
7610{
a734115a
NC		 7611 FILE * file; /* The file containing the unwind sections. */
7612 Elf_Internal_Sym * symtab; /* The file's symbol table. */
7613 unsigned long nsyms; /* Number of symbols. */
948f632f
DA		 7614 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7615 unsigned long nfuns; /* Number of these symbols. */
a734115a
NC		 7616 char * strtab; /* The file's string table. */
7617 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 7618};
7619
7620static const char *
7621arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7622 bfd_vma fn, struct absaddr addr)
7623{
7624 const char *procname;
7625 bfd_vma sym_offset;
7626
7627 if (addr.section == SHN_UNDEF)
7628 addr.offset = fn;
7629
948f632f 7630 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
0b6ae522
DJ		 7631 aux->strtab_size, addr, &procname,
7632 &sym_offset);
7633
7634 print_vma (fn, PREFIX_HEX);
7635
7636 if (procname)
7637 {
7638 fputs (" <", stdout);
7639 fputs (procname, stdout);
7640
7641 if (sym_offset)
7642 printf ("+0x%lx", (unsigned long) sym_offset);
7643 fputc ('>', stdout);
7644 }
7645
7646 return procname;
7647}
7648
7649static void
7650arm_free_section (struct arm_section *arm_sec)
7651{
7652 if (arm_sec->data != NULL)
7653 free (arm_sec->data);
7654
7655 if (arm_sec->rela != NULL)
7656 free (arm_sec->rela);
7657}
7658
a734115a
NC		 7659/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7660 cached section and install SEC instead.
7661 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7662 and return its valued in * WORDP, relocating if necessary.
1b31d05e 7663 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 7664 relocation's offset in ADDR.
1b31d05e
NC		 7665 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7666 into the string table of the symbol associated with the reloc. If no
7667 reloc was applied store -1 there.
7668 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 7669
7670static bfd_boolean
1b31d05e
NC		 7671get_unwind_section_word (struct arm_unw_aux_info * aux,
7672 struct arm_section * arm_sec,
7673 Elf_Internal_Shdr * sec,
7674 bfd_vma word_offset,
7675 unsigned int * wordp,
7676 struct absaddr * addr,
7677 bfd_vma * sym_name)
0b6ae522
DJ		 7678{
7679 Elf_Internal_Rela *rp;
7680 Elf_Internal_Sym *sym;
7681 const char * relname;
7682 unsigned int word;
7683 bfd_boolean wrapped;
7684
e0a31db1
NC		 7685 if (sec == NULL || arm_sec == NULL)
7686 return FALSE;
7687
0b6ae522
DJ		 7688 addr->section = SHN_UNDEF;
7689 addr->offset = 0;
7690
1b31d05e
NC		 7691 if (sym_name != NULL)
7692 *sym_name = (bfd_vma) -1;
7693
a734115a 7694 /* If necessary, update the section cache. */
0b6ae522
DJ		 7695 if (sec != arm_sec->sec)
7696 {
7697 Elf_Internal_Shdr *relsec;
7698
7699 arm_free_section (arm_sec);
7700
7701 arm_sec->sec = sec;
7702 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7703 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 7704 arm_sec->rela = NULL;
7705 arm_sec->nrelas = 0;
7706
7707 for (relsec = section_headers;
7708 relsec < section_headers + elf_header.e_shnum;
7709 ++relsec)
7710 {
7711 if (relsec->sh_info >= elf_header.e_shnum
1ae40aa4
NC		 7712 || section_headers + relsec->sh_info != sec
7713 /* PR 15745: Check the section type as well. */
7714 || (relsec->sh_type != SHT_REL
7715 && relsec->sh_type != SHT_RELA))
0b6ae522
DJ		 7716 continue;
7717
a734115a 7718 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 7719 if (relsec->sh_type == SHT_REL)
7720 {
7721 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7722 relsec->sh_size,
7723 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7724 return FALSE;
0b6ae522 7725 }
1ae40aa4 7726 else /* relsec->sh_type == SHT_RELA */
0b6ae522
DJ		 7727 {
7728 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7729 relsec->sh_size,
7730 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7731 return FALSE;
0b6ae522 7732 }
1ae40aa4 7733 break;
0b6ae522
DJ		 7734 }
7735
7736 arm_sec->next_rela = arm_sec->rela;
7737 }
7738
a734115a 7739 /* If there is no unwind data we can do nothing. */
0b6ae522 7740 if (arm_sec->data == NULL)
a734115a 7741 return FALSE;
0b6ae522 7742
e0a31db1 7743 /* If the offset is invalid then fail. */
1a915552
NC		 7744 if (word_offset > (sec->sh_size - 4)
7745 /* PR 18879 */
7746 || (sec->sh_size < 5 && word_offset >= sec->sh_size)
7747 || ((bfd_signed_vma) word_offset) < 0)
e0a31db1
NC		 7748 return FALSE;
7749
a734115a 7750 /* Get the word at the required offset. */
0b6ae522
DJ		 7751 word = byte_get (arm_sec->data + word_offset, 4);
7752
0eff7165
NC		 7753 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7754 if (arm_sec->rela == NULL)
7755 {
7756 * wordp = word;
7757 return TRUE;
7758 }
7759
a734115a 7760 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 7761 wrapped = FALSE;
7762 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7763 {
7764 bfd_vma prelval, offset;
7765
7766 if (rp->r_offset > word_offset && !wrapped)
7767 {
7768 rp = arm_sec->rela;
7769 wrapped = TRUE;
7770 }
7771 if (rp->r_offset > word_offset)
7772 break;
7773
7774 if (rp->r_offset & 3)
7775 {
7776 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7777 (unsigned long) rp->r_offset);
7778 continue;
7779 }
7780
7781 if (rp->r_offset < word_offset)
7782 continue;
7783
74e1a04b
NC		 7784 /* PR 17531: file: 027-161405-0.004 */
7785 if (aux->symtab == NULL)
7786 continue;
7787
0b6ae522
DJ		 7788 if (arm_sec->rel_type == SHT_REL)
7789 {
7790 offset = word & 0x7fffffff;
7791 if (offset & 0x40000000)
7792 offset |= ~ (bfd_vma) 0x7fffffff;
7793 }
a734115a 7794 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 7795 offset = rp->r_addend;
a734115a 7796 else
74e1a04b
NC		 7797 {
7798 error (_("Unknown section relocation type %d encountered\n"),
7799 arm_sec->rel_type);
7800 break;
7801 }
0b6ae522 7802
071436c6
NC		 7803 /* PR 17531 file: 027-1241568-0.004. */
7804 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7805 {
7806 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7807 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7808 break;
7809 }
7810
7811 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
0b6ae522
DJ		 7812 offset += sym->st_value;
7813 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7814
a734115a
NC		 7815 /* Check that we are processing the expected reloc type. */
7816 if (elf_header.e_machine == EM_ARM)
7817 {
7818 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7819 if (relname == NULL)
7820 {
7821 warn (_("Skipping unknown ARM relocation type: %d\n"),
7822 (int) ELF32_R_TYPE (rp->r_info));
7823 continue;
7824 }
a734115a
NC		 7825
7826 if (streq (relname, "R_ARM_NONE"))
7827 continue;
0b4362b0 7828
a734115a
NC		 7829 if (! streq (relname, "R_ARM_PREL31"))
7830 {
071436c6 7831 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
a734115a
NC		 7832 continue;
7833 }
7834 }
7835 else if (elf_header.e_machine == EM_TI_C6000)
7836 {
7837 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7838 if (relname == NULL)
7839 {
7840 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7841 (int) ELF32_R_TYPE (rp->r_info));
7842 continue;
7843 }
0b4362b0 7844
a734115a
NC		 7845 if (streq (relname, "R_C6000_NONE"))
7846 continue;
7847
7848 if (! streq (relname, "R_C6000_PREL31"))
7849 {
071436c6 7850 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
a734115a
NC		 7851 continue;
7852 }
7853
7854 prelval >>= 1;
7855 }
7856 else
74e1a04b
NC		 7857 {
7858 /* This function currently only supports ARM and TI unwinders. */
7859 warn (_("Only TI and ARM unwinders are currently supported\n"));
7860 break;
7861 }
fa197c1c 7862
0b6ae522
DJ		 7863 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7864 addr->section = sym->st_shndx;
7865 addr->offset = offset;
74e1a04b 7866
1b31d05e
NC		 7867 if (sym_name)
7868 * sym_name = sym->st_name;
0b6ae522
DJ		 7869 break;
7870 }
7871
7872 *wordp = word;
7873 arm_sec->next_rela = rp;
7874
a734115a 7875 return TRUE;
0b6ae522
DJ		 7876}
7877
a734115a
NC		 7878static const char *tic6x_unwind_regnames[16] =
7879{
0b4362b0
RM		 7880 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7881 "A14", "A13", "A12", "A11", "A10",
a734115a
NC		 7882 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7883};
fa197c1c 7884
0b6ae522 7885static void
fa197c1c 7886decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 7887{
fa197c1c
PB		 7888 int i;
7889
7890 for (i = 12; mask; mask >>= 1, i--)
7891 {
7892 if (mask & 1)
7893 {
7894 fputs (tic6x_unwind_regnames[i], stdout);
7895 if (mask > 1)
7896 fputs (", ", stdout);
7897 }
7898 }
7899}
0b6ae522
DJ		 7900
7901#define ADVANCE \
7902 if (remaining == 0 && more_words) \
7903 { \
7904 data_offset += 4; \
1b31d05e
NC		 7905 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7906 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 7907 return; \
7908 remaining = 4; \
7909 more_words--; \
7910 } \
7911
7912#define GET_OP(OP) \
7913 ADVANCE; \
7914 if (remaining) \
7915 { \
7916 remaining--; \
7917 (OP) = word >> 24; \
7918 word <<= 8; \
7919 } \
7920 else \
7921 { \
2b692964 7922 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 7923 return; \
7924 } \
cc5914eb 7925 printf ("0x%02x ", OP)
0b6ae522 7926
fa197c1c 7927static void
948f632f
DA		 7928decode_arm_unwind_bytecode (struct arm_unw_aux_info * aux,
7929 unsigned int word,
7930 unsigned int remaining,
7931 unsigned int more_words,
7932 bfd_vma data_offset,
7933 Elf_Internal_Shdr * data_sec,
7934 struct arm_section * data_arm_sec)
fa197c1c
PB		 7935{
7936 struct absaddr addr;
0b6ae522
DJ		 7937
7938 /* Decode the unwinding instructions. */
7939 while (1)
7940 {
7941 unsigned int op, op2;
7942
7943 ADVANCE;
7944 if (remaining == 0)
7945 break;
7946 remaining--;
7947 op = word >> 24;
7948 word <<= 8;
7949
cc5914eb 7950 printf (" 0x%02x ", op);
0b6ae522
DJ		 7951
7952 if ((op & 0xc0) == 0x00)
7953 {
7954 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7955
cc5914eb 7956 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 7957 }
7958 else if ((op & 0xc0) == 0x40)
7959 {
7960 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7961
cc5914eb 7962 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 7963 }
7964 else if ((op & 0xf0) == 0x80)
7965 {
7966 GET_OP (op2);
7967 if (op == 0x80 && op2 == 0)
7968 printf (_("Refuse to unwind"));
7969 else
7970 {
7971 unsigned int mask = ((op & 0x0f) << 8) | op2;
7972 int first = 1;
7973 int i;
2b692964 7974
0b6ae522
DJ		 7975 printf ("pop {");
7976 for (i = 0; i < 12; i++)
7977 if (mask & (1 << i))
7978 {
7979 if (first)
7980 first = 0;
7981 else
7982 printf (", ");
7983 printf ("r%d", 4 + i);
7984 }
7985 printf ("}");
7986 }
7987 }
7988 else if ((op & 0xf0) == 0x90)
7989 {
7990 if (op == 0x9d || op == 0x9f)
7991 printf (_(" [Reserved]"));
7992 else
cc5914eb 7993 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 7994 }
7995 else if ((op & 0xf0) == 0xa0)
7996 {
7997 int end = 4 + (op & 0x07);
7998 int first = 1;
7999 int i;
61865e30 8000
0b6ae522
DJ		 8001 printf (" pop {");
8002 for (i = 4; i <= end; i++)
8003 {
8004 if (first)
8005 first = 0;
8006 else
8007 printf (", ");
8008 printf ("r%d", i);
8009 }
8010 if (op & 0x08)
8011 {
1b31d05e 8012 if (!first)
0b6ae522
DJ		 8013 printf (", ");
8014 printf ("r14");
8015 }
8016 printf ("}");
8017 }
8018 else if (op == 0xb0)
8019 printf (_(" finish"));
8020 else if (op == 0xb1)
8021 {
8022 GET_OP (op2);
8023 if (op2 == 0 || (op2 & 0xf0) != 0)
8024 printf (_("[Spare]"));
8025 else
8026 {
8027 unsigned int mask = op2 & 0x0f;
8028 int first = 1;
8029 int i;
61865e30 8030
0b6ae522
DJ		 8031 printf ("pop {");
8032 for (i = 0; i < 12; i++)
8033 if (mask & (1 << i))
8034 {
8035 if (first)
8036 first = 0;
8037 else
8038 printf (", ");
8039 printf ("r%d", i);
8040 }
8041 printf ("}");
8042 }
8043 }
8044 else if (op == 0xb2)
8045 {
b115cf96 8046 unsigned char buf[9];
0b6ae522
DJ		 8047 unsigned int i, len;
8048 unsigned long offset;
61865e30 8049
b115cf96 8050 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 8051 {
8052 GET_OP (buf[i]);
8053 if ((buf[i] & 0x80) == 0)
8054 break;
8055 }
4082ef84
NC		 8056 if (i == sizeof (buf))
8057 printf (_("corrupt change to vsp"));
8058 else
8059 {
8060 offset = read_uleb128 (buf, &len, buf + i + 1);
8061 assert (len == i + 1);
8062 offset = offset * 4 + 0x204;
8063 printf ("vsp = vsp + %ld", offset);
8064 }
0b6ae522 8065 }
61865e30 8066 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 8067 {
61865e30
NC		 8068 unsigned int first, last;
8069
8070 GET_OP (op2);
8071 first = op2 >> 4;
8072 last = op2 & 0x0f;
8073 if (op == 0xc8)
8074 first = first + 16;
8075 printf ("pop {D%d", first);
8076 if (last)
8077 printf ("-D%d", first + last);
8078 printf ("}");
8079 }
8080 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8081 {
8082 unsigned int count = op & 0x07;
8083
8084 printf ("pop {D8");
8085 if (count)
8086 printf ("-D%d", 8 + count);
8087 printf ("}");
8088 }
8089 else if (op >= 0xc0 && op <= 0xc5)
8090 {
8091 unsigned int count = op & 0x07;
8092
8093 printf (" pop {wR10");
8094 if (count)
8095 printf ("-wR%d", 10 + count);
8096 printf ("}");
8097 }
8098 else if (op == 0xc6)
8099 {
8100 unsigned int first, last;
8101
8102 GET_OP (op2);
8103 first = op2 >> 4;
8104 last = op2 & 0x0f;
8105 printf ("pop {wR%d", first);
8106 if (last)
8107 printf ("-wR%d", first + last);
8108 printf ("}");
8109 }
8110 else if (op == 0xc7)
8111 {
8112 GET_OP (op2);
8113 if (op2 == 0 || (op2 & 0xf0) != 0)
8114 printf (_("[Spare]"));
0b6ae522
DJ		 8115 else
8116 {
61865e30
NC		 8117 unsigned int mask = op2 & 0x0f;
8118 int first = 1;
8119 int i;
8120
8121 printf ("pop {");
8122 for (i = 0; i < 4; i++)
8123 if (mask & (1 << i))
8124 {
8125 if (first)
8126 first = 0;
8127 else
8128 printf (", ");
8129 printf ("wCGR%d", i);
8130 }
8131 printf ("}");
0b6ae522
DJ		 8132 }
8133 }
61865e30
NC		 8134 else
8135 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 8136 printf ("\n");
8137 }
fa197c1c
PB		 8138}
8139
8140static void
948f632f
DA		 8141decode_tic6x_unwind_bytecode (struct arm_unw_aux_info * aux,
8142 unsigned int word,
8143 unsigned int remaining,
8144 unsigned int more_words,
8145 bfd_vma data_offset,
8146 Elf_Internal_Shdr * data_sec,
8147 struct arm_section * data_arm_sec)
fa197c1c
PB		 8148{
8149 struct absaddr addr;
8150
8151 /* Decode the unwinding instructions. */
8152 while (1)
8153 {
8154 unsigned int op, op2;
8155
8156 ADVANCE;
8157 if (remaining == 0)
8158 break;
8159 remaining--;
8160 op = word >> 24;
8161 word <<= 8;
8162
9cf03b7e 8163 printf (" 0x%02x ", op);
fa197c1c
PB		 8164
8165 if ((op & 0xc0) == 0x00)
8166 {
8167 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 8168 printf (" sp = sp + %d", offset);
fa197c1c
PB		 8169 }
8170 else if ((op & 0xc0) == 0x80)
8171 {
8172 GET_OP (op2);
8173 if (op == 0x80 && op2 == 0)
8174 printf (_("Refuse to unwind"));
8175 else
8176 {
8177 unsigned int mask = ((op & 0x1f) << 8) | op2;
8178 if (op & 0x20)
8179 printf ("pop compact {");
8180 else
8181 printf ("pop {");
8182
8183 decode_tic6x_unwind_regmask (mask);
8184 printf("}");
8185 }
8186 }
8187 else if ((op & 0xf0) == 0xc0)
8188 {
8189 unsigned int reg;
8190 unsigned int nregs;
8191 unsigned int i;
8192 const char *name;
a734115a
NC		 8193 struct
8194 {
fa197c1c
PB		 8195 unsigned int offset;
8196 unsigned int reg;
8197 } regpos[16];
8198
8199 /* Scan entire instruction first so that GET_OP output is not
8200 interleaved with disassembly. */
8201 nregs = 0;
8202 for (i = 0; nregs < (op & 0xf); i++)
8203 {
8204 GET_OP (op2);
8205 reg = op2 >> 4;
8206 if (reg != 0xf)
8207 {
8208 regpos[nregs].offset = i * 2;
8209 regpos[nregs].reg = reg;
8210 nregs++;
8211 }
8212
8213 reg = op2 & 0xf;
8214 if (reg != 0xf)
8215 {
8216 regpos[nregs].offset = i * 2 + 1;
8217 regpos[nregs].reg = reg;
8218 nregs++;
8219 }
8220 }
8221
8222 printf (_("pop frame {"));
8223 reg = nregs - 1;
8224 for (i = i * 2; i > 0; i--)
8225 {
8226 if (regpos[reg].offset == i - 1)
8227 {
8228 name = tic6x_unwind_regnames[regpos[reg].reg];
8229 if (reg > 0)
8230 reg--;
8231 }
8232 else
8233 name = _("[pad]");
8234
8235 fputs (name, stdout);
8236 if (i > 1)
8237 printf (", ");
8238 }
8239
8240 printf ("}");
8241 }
8242 else if (op == 0xd0)
8243 printf (" MOV FP, SP");
8244 else if (op == 0xd1)
8245 printf (" __c6xabi_pop_rts");
8246 else if (op == 0xd2)
8247 {
8248 unsigned char buf[9];
8249 unsigned int i, len;
8250 unsigned long offset;
a734115a 8251
fa197c1c
PB		 8252 for (i = 0; i < sizeof (buf); i++)
8253 {
8254 GET_OP (buf[i]);
8255 if ((buf[i] & 0x80) == 0)
8256 break;
8257 }
0eff7165
NC		 8258 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8259 if (i == sizeof (buf))
8260 {
8261 printf ("<corrupt sp adjust>\n");
8262 warn (_("Corrupt stack pointer adjustment detected\n"));
8263 return;
8264 }
948f632f 8265
f6f0e17b 8266 offset = read_uleb128 (buf, &len, buf + i + 1);
fa197c1c
PB		 8267 assert (len == i + 1);
8268 offset = offset * 8 + 0x408;
8269 printf (_("sp = sp + %ld"), offset);
8270 }
8271 else if ((op & 0xf0) == 0xe0)
8272 {
8273 if ((op & 0x0f) == 7)
8274 printf (" RETURN");
8275 else
8276 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8277 }
8278 else
8279 {
8280 printf (_(" [unsupported opcode]"));
8281 }
8282 putchar ('\n');
8283 }
8284}
8285
8286static bfd_vma
a734115a 8287arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 8288{
8289 bfd_vma offset;
8290
8291 offset = word & 0x7fffffff;
8292 if (offset & 0x40000000)
8293 offset |= ~ (bfd_vma) 0x7fffffff;
8294
8295 if (elf_header.e_machine == EM_TI_C6000)
8296 offset <<= 1;
8297
8298 return offset + where;
8299}
8300
8301static void
1b31d05e
NC		 8302decode_arm_unwind (struct arm_unw_aux_info * aux,
8303 unsigned int word,
8304 unsigned int remaining,
8305 bfd_vma data_offset,
8306 Elf_Internal_Shdr * data_sec,
8307 struct arm_section * data_arm_sec)
fa197c1c
PB		 8308{
8309 int per_index;
8310 unsigned int more_words = 0;
37e14bc3 8311 struct absaddr addr;
1b31d05e 8312 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 8313
8314 if (remaining == 0)
8315 {
1b31d05e
NC		 8316 /* Fetch the first word.
8317 Note - when decoding an object file the address extracted
8318 here will always be 0. So we also pass in the sym_name
8319 parameter so that we can find the symbol associated with
8320 the personality routine. */
8321 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8322 & word, & addr, & sym_name))
fa197c1c 8323 return;
1b31d05e 8324
fa197c1c
PB		 8325 remaining = 4;
8326 }
8327
8328 if ((word & 0x80000000) == 0)
8329 {
8330 /* Expand prel31 for personality routine. */
8331 bfd_vma fn;
8332 const char *procname;
8333
a734115a 8334 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 8335 printf (_(" Personality routine: "));
1b31d05e
NC		 8336 if (fn == 0
8337 && addr.section == SHN_UNDEF && addr.offset == 0
8338 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8339 {
8340 procname = aux->strtab + sym_name;
8341 print_vma (fn, PREFIX_HEX);
8342 if (procname)
8343 {
8344 fputs (" <", stdout);
8345 fputs (procname, stdout);
8346 fputc ('>', stdout);
8347 }
8348 }
8349 else
8350 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 8351 fputc ('\n', stdout);
8352
8353 /* The GCC personality routines use the standard compact
8354 encoding, starting with one byte giving the number of
8355 words. */
8356 if (procname != NULL
8357 && (const_strneq (procname, "__gcc_personality_v0")
8358 || const_strneq (procname, "__gxx_personality_v0")
8359 || const_strneq (procname, "__gcj_personality_v0")
8360 || const_strneq (procname, "__gnu_objc_personality_v0")))
8361 {
8362 remaining = 0;
8363 more_words = 1;
8364 ADVANCE;
8365 if (!remaining)
8366 {
8367 printf (_(" [Truncated data]\n"));
8368 return;
8369 }
8370 more_words = word >> 24;
8371 word <<= 8;
8372 remaining--;
8373 per_index = -1;
8374 }
8375 else
8376 return;
8377 }
8378 else
8379 {
1b31d05e 8380 /* ARM EHABI Section 6.3:
0b4362b0 8381
1b31d05e 8382 An exception-handling table entry for the compact model looks like:
0b4362b0 8383
1b31d05e
NC		 8384 31 30-28 27-24 23-0
8385 -- ----- ----- ----
8386 1 0 index Data for personalityRoutine[index] */
8387
8388 if (elf_header.e_machine == EM_ARM
8389 && (word & 0x70000000))
83c257ca 8390 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 8391
fa197c1c 8392 per_index = (word >> 24) & 0x7f;
1b31d05e 8393 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 8394 if (per_index == 0)
8395 {
8396 more_words = 0;
8397 word <<= 8;
8398 remaining--;
8399 }
8400 else if (per_index < 3)
8401 {
8402 more_words = (word >> 16) & 0xff;
8403 word <<= 16;
8404 remaining -= 2;
8405 }
8406 }
8407
8408 switch (elf_header.e_machine)
8409 {
8410 case EM_ARM:
8411 if (per_index < 3)
8412 {
8413 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8414 data_offset, data_sec, data_arm_sec);
8415 }
8416 else
1b31d05e
NC		 8417 {
8418 warn (_("Unknown ARM compact model index encountered\n"));
8419 printf (_(" [reserved]\n"));
8420 }
fa197c1c
PB		 8421 break;
8422
8423 case EM_TI_C6000:
8424 if (per_index < 3)
8425 {
8426 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 8427 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 8428 }
8429 else if (per_index < 5)
8430 {
8431 if (((word >> 17) & 0x7f) == 0x7f)
8432 printf (_(" Restore stack from frame pointer\n"));
8433 else
8434 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
8435 printf (_(" Registers restored: "));
8436 if (per_index == 4)
8437 printf (" (compact) ");
8438 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8439 putchar ('\n');
8440 printf (_(" Return register: %s\n"),
8441 tic6x_unwind_regnames[word & 0xf]);
8442 }
8443 else
1b31d05e 8444 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 8445 break;
8446
8447 default:
74e1a04b 8448 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
1b31d05e 8449 elf_header.e_machine);
fa197c1c 8450 }
0b6ae522
DJ		 8451
8452 /* Decode the descriptors. Not implemented. */
8453}
8454
8455static void
8456dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8457{
8458 struct arm_section exidx_arm_sec, extab_arm_sec;
8459 unsigned int i, exidx_len;
948f632f 8460 unsigned long j, nfuns;
0b6ae522
DJ		 8461
8462 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8463 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8464 exidx_len = exidx_sec->sh_size / 8;
8465
948f632f
DA		 8466 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8467 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8468 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8469 aux->funtab[nfuns++] = aux->symtab[j];
8470 aux->nfuns = nfuns;
8471 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8472
0b6ae522
DJ		 8473 for (i = 0; i < exidx_len; i++)
8474 {
8475 unsigned int exidx_fn, exidx_entry;
8476 struct absaddr fn_addr, entry_addr;
8477 bfd_vma fn;
8478
8479 fputc ('\n', stdout);
8480
1b31d05e
NC		 8481 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8482 8 * i, & exidx_fn, & fn_addr, NULL)
8483 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8484 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 8485 {
948f632f 8486 free (aux->funtab);
1b31d05e
NC		 8487 arm_free_section (& exidx_arm_sec);
8488 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 8489 return;
8490 }
8491
83c257ca
NC		 8492 /* ARM EHABI, Section 5:
8493 An index table entry consists of 2 words.
8494 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8495 if (exidx_fn & 0x80000000)
8496 warn (_("corrupt index table entry: %x\n"), exidx_fn);
8497
a734115a 8498 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 8499
a734115a 8500 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 8501 fputs (": ", stdout);
8502
8503 if (exidx_entry == 1)
8504 {
8505 print_vma (exidx_entry, PREFIX_HEX);
8506 fputs (" [cantunwind]\n", stdout);
8507 }
8508 else if (exidx_entry & 0x80000000)
8509 {
8510 print_vma (exidx_entry, PREFIX_HEX);
8511 fputc ('\n', stdout);
8512 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8513 }
8514 else
8515 {
8f73510c 8516 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 8517 Elf_Internal_Shdr *table_sec;
8518
8519 fputs ("@", stdout);
a734115a 8520 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 8521 print_vma (table, PREFIX_HEX);
8522 printf ("\n");
8523
8524 /* Locate the matching .ARM.extab. */
8525 if (entry_addr.section != SHN_UNDEF
8526 && entry_addr.section < elf_header.e_shnum)
8527 {
8528 table_sec = section_headers + entry_addr.section;
8529 table_offset = entry_addr.offset;
1a915552
NC		 8530 /* PR 18879 */
8531 if (table_offset > table_sec->sh_size
8532 || ((bfd_signed_vma) table_offset) < 0)
8533 {
8534 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8535 (unsigned long) table_offset,
8536 printable_section_name (table_sec));
8537 continue;
8538 }
0b6ae522
DJ		 8539 }
8540 else
8541 {
8542 table_sec = find_section_by_address (table);
8543 if (table_sec != NULL)
8544 table_offset = table - table_sec->sh_addr;
8545 }
8546 if (table_sec == NULL)
8547 {
8548 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8549 (unsigned long) table);
8550 continue;
8551 }
8552 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8553 &extab_arm_sec);
8554 }
8555 }
8556
8557 printf ("\n");
8558
948f632f 8559 free (aux->funtab);
0b6ae522
DJ		 8560 arm_free_section (&exidx_arm_sec);
8561 arm_free_section (&extab_arm_sec);
8562}
8563
fa197c1c 8564/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 8565
8566static void
0b6ae522
DJ		 8567arm_process_unwind (FILE *file)
8568{
8569 struct arm_unw_aux_info aux;
8570 Elf_Internal_Shdr *unwsec = NULL;
8571 Elf_Internal_Shdr *strsec;
8572 Elf_Internal_Shdr *sec;
8573 unsigned long i;
fa197c1c 8574 unsigned int sec_type;
0b6ae522 8575
fa197c1c
PB		 8576 switch (elf_header.e_machine)
8577 {
8578 case EM_ARM:
8579 sec_type = SHT_ARM_EXIDX;
8580 break;
8581
8582 case EM_TI_C6000:
8583 sec_type = SHT_C6000_UNWIND;
8584 break;
8585
0b4362b0 8586 default:
74e1a04b 8587 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
1b31d05e
NC		 8588 elf_header.e_machine);
8589 return;
fa197c1c
PB		 8590 }
8591
0b6ae522 8592 if (string_table == NULL)
1b31d05e
NC		 8593 return;
8594
8595 memset (& aux, 0, sizeof (aux));
8596 aux.file = file;
0b6ae522
DJ		 8597
8598 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8599 {
8600 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8601 {
ba5cdace 8602 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 8603
8604 strsec = section_headers + sec->sh_link;
74e1a04b
NC		 8605
8606 /* PR binutils/17531 file: 011-12666-0.004. */
8607 if (aux.strtab != NULL)
8608 {
4082ef84 8609 error (_("Multiple string tables found in file.\n"));
74e1a04b
NC		 8610 free (aux.strtab);
8611 }
0b6ae522
DJ		 8612 aux.strtab = get_data (NULL, file, strsec->sh_offset,
8613 1, strsec->sh_size, _("string table"));
8614 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8615 }
fa197c1c 8616 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 8617 unwsec = sec;
8618 }
8619
1b31d05e 8620 if (unwsec == NULL)
0b6ae522 8621 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 8622 else
8623 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8624 {
8625 if (sec->sh_type == sec_type)
8626 {
8627 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
74e1a04b 8628 printable_section_name (sec),
1b31d05e
NC		 8629 (unsigned long) sec->sh_offset,
8630 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 8631
1b31d05e
NC		 8632 dump_arm_unwind (&aux, sec);
8633 }
8634 }
0b6ae522
DJ		 8635
8636 if (aux.symtab)
8637 free (aux.symtab);
8638 if (aux.strtab)
8639 free ((char *) aux.strtab);
0b6ae522
DJ		 8640}
8641
1b31d05e 8642static void
2cf0635d 8643process_unwind (FILE * file)
57346661 8644{
2cf0635d
NC		 8645 struct unwind_handler
8646 {
57346661 8647 int machtype;
1b31d05e 8648 void (* handler)(FILE *);
2cf0635d
NC		 8649 } handlers[] =
8650 {
0b6ae522 8651 { EM_ARM, arm_process_unwind },
57346661
AM		 8652 { EM_IA_64, ia64_process_unwind },
8653 { EM_PARISC, hppa_process_unwind },
fa197c1c 8654 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 8655 { 0, 0 }
8656 };
8657 int i;
8658
8659 if (!do_unwind)
1b31d05e 8660 return;
57346661
AM		 8661
8662 for (i = 0; handlers[i].handler != NULL; i++)
8663 if (elf_header.e_machine == handlers[i].machtype)
9f758fdc
NC		 8664 {
8665 handlers[i].handler (file);
8666 return;
8667 }
57346661 8668
1b31d05e
NC		 8669 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8670 get_machine_name (elf_header.e_machine));
57346661
AM		 8671}
8672
252b5132 8673static void
2cf0635d 8674dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 8675{
8676 switch (entry->d_tag)
8677 {
8678 case DT_MIPS_FLAGS:
8679 if (entry->d_un.d_val == 0)
4b68bca3 8680 printf (_("NONE"));
252b5132
RH		 8681 else
8682 {
8683 static const char * opts[] =
8684 {
8685 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8686 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8687 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8688 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8689 "RLD_ORDER_SAFE"
8690 };
8691 unsigned int cnt;
8692 int first = 1;
2b692964 8693
60bca95a 8694 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 8695 if (entry->d_un.d_val & (1 << cnt))
8696 {
8697 printf ("%s%s", first ? "" : " ", opts[cnt]);
8698 first = 0;
8699 }
252b5132
RH		 8700 }
8701 break;
103f02d3 8702
252b5132 8703 case DT_MIPS_IVERSION:
d79b3d50 8704 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 8705 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8706 else
76ca31c0
NC		 8707 {
8708 char buf[40];
8709 sprintf_vma (buf, entry->d_un.d_ptr);
8710 /* Note: coded this way so that there is a single string for translation. */
8711 printf (_("<corrupt: %s>"), buf);
8712 }
252b5132 8713 break;
103f02d3 8714
252b5132
RH		 8715 case DT_MIPS_TIME_STAMP:
8716 {
8717 char timebuf[20];
2cf0635d 8718 struct tm * tmp;
91d6fa6a 8719 time_t atime = entry->d_un.d_val;
82b1b41b 8720
91d6fa6a 8721 tmp = gmtime (&atime);
82b1b41b
NC		 8722 /* PR 17531: file: 6accc532. */
8723 if (tmp == NULL)
8724 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8725 else
8726 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8727 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8728 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 8729 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 8730 }
8731 break;
103f02d3 8732
252b5132
RH		 8733 case DT_MIPS_RLD_VERSION:
8734 case DT_MIPS_LOCAL_GOTNO:
8735 case DT_MIPS_CONFLICTNO:
8736 case DT_MIPS_LIBLISTNO:
8737 case DT_MIPS_SYMTABNO:
8738 case DT_MIPS_UNREFEXTNO:
8739 case DT_MIPS_HIPAGENO:
8740 case DT_MIPS_DELTA_CLASS_NO:
8741 case DT_MIPS_DELTA_INSTANCE_NO:
8742 case DT_MIPS_DELTA_RELOC_NO:
8743 case DT_MIPS_DELTA_SYM_NO:
8744 case DT_MIPS_DELTA_CLASSSYM_NO:
8745 case DT_MIPS_COMPACT_SIZE:
c69075ac 8746 print_vma (entry->d_un.d_val, DEC);
252b5132 8747 break;
103f02d3
UD		 8748
8749 default:
4b68bca3 8750 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 8751 }
4b68bca3 8752 putchar ('\n');
103f02d3
UD		 8753}
8754
103f02d3 8755static void
2cf0635d 8756dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 8757{
8758 switch (entry->d_tag)
8759 {
8760 case DT_HP_DLD_FLAGS:
8761 {
8762 static struct
8763 {
8764 long int bit;
2cf0635d 8765 const char * str;
5e220199
NC		 8766 }
8767 flags[] =
8768 {
8769 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8770 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8771 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8772 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8773 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8774 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8775 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8776 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8777 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8778 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 8779 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8780 { DT_HP_GST, "HP_GST" },
8781 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8782 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8783 { DT_HP_NODELETE, "HP_NODELETE" },
8784 { DT_HP_GROUP, "HP_GROUP" },
8785 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 8786 };
103f02d3 8787 int first = 1;
5e220199 8788 size_t cnt;
f7a99963 8789 bfd_vma val = entry->d_un.d_val;
103f02d3 8790
60bca95a 8791 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 8792 if (val & flags[cnt].bit)
30800947
NC		 8793 {
8794 if (! first)
8795 putchar (' ');
8796 fputs (flags[cnt].str, stdout);
8797 first = 0;
8798 val ^= flags[cnt].bit;
8799 }
76da6bbe 8800
103f02d3 8801 if (val != 0 || first)
f7a99963
NC		 8802 {
8803 if (! first)
8804 putchar (' ');
8805 print_vma (val, HEX);
8806 }
103f02d3
UD		 8807 }
8808 break;
76da6bbe 8809
252b5132 8810 default:
f7a99963
NC		 8811 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8812 break;
252b5132 8813 }
35b1837e 8814 putchar ('\n');
252b5132
RH		 8815}
8816
28f997cf
TG		 8817#ifdef BFD64
8818
8819/* VMS vs Unix time offset and factor. */
8820
8821#define VMS_EPOCH_OFFSET 35067168000000000LL
8822#define VMS_GRANULARITY_FACTOR 10000000
8823
8824/* Display a VMS time in a human readable format. */
8825
8826static void
8827print_vms_time (bfd_int64_t vmstime)
8828{
8829 struct tm *tm;
8830 time_t unxtime;
8831
8832 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8833 tm = gmtime (&unxtime);
8834 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8835 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8836 tm->tm_hour, tm->tm_min, tm->tm_sec);
8837}
8838#endif /* BFD64 */
8839
ecc51f48 8840static void
2cf0635d 8841dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 8842{
8843 switch (entry->d_tag)
8844 {
0de14b54 8845 case DT_IA_64_PLT_RESERVE:
bdf4d63a 8846 /* First 3 slots reserved. */
ecc51f48
NC		 8847 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8848 printf (" -- ");
8849 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 8850 break;
8851
28f997cf
TG		 8852 case DT_IA_64_VMS_LINKTIME:
8853#ifdef BFD64
8854 print_vms_time (entry->d_un.d_val);
8855#endif
8856 break;
8857
8858 case DT_IA_64_VMS_LNKFLAGS:
8859 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8860 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8861 printf (" CALL_DEBUG");
8862 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8863 printf (" NOP0BUFS");
8864 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8865 printf (" P0IMAGE");
8866 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8867 printf (" MKTHREADS");
8868 if (entry->d_un.d_val & VMS_LF_UPCALLS)
8869 printf (" UPCALLS");
8870 if (entry->d_un.d_val & VMS_LF_IMGSTA)
8871 printf (" IMGSTA");
8872 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8873 printf (" INITIALIZE");
8874 if (entry->d_un.d_val & VMS_LF_MAIN)
8875 printf (" MAIN");
8876 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8877 printf (" EXE_INIT");
8878 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8879 printf (" TBK_IN_IMG");
8880 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8881 printf (" DBG_IN_IMG");
8882 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8883 printf (" TBK_IN_DSF");
8884 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8885 printf (" DBG_IN_DSF");
8886 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8887 printf (" SIGNATURES");
8888 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8889 printf (" REL_SEG_OFF");
8890 break;
8891
bdf4d63a
JJ		 8892 default:
8893 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8894 break;
ecc51f48 8895 }
bdf4d63a 8896 putchar ('\n');
ecc51f48
NC		 8897}
8898
252b5132 8899static int
2cf0635d 8900get_32bit_dynamic_section (FILE * file)
252b5132 8901{
2cf0635d
NC		 8902 Elf32_External_Dyn * edyn;
8903 Elf32_External_Dyn * ext;
8904 Elf_Internal_Dyn * entry;
103f02d3 8905
3f5e193b
NC		 8906 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8907 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8908 if (!edyn)
8909 return 0;
103f02d3 8910
071436c6
NC		 8911 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8912 might not have the luxury of section headers. Look for the DT_NULL
8913 terminator to determine the number of entries. */
ba2685cc 8914 for (ext = edyn, dynamic_nent = 0;
53c3012c 8915 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
ba2685cc
AM		 8916 ext++)
8917 {
8918 dynamic_nent++;
8919 if (BYTE_GET (ext->d_tag) == DT_NULL)
8920 break;
8921 }
252b5132 8922
3f5e193b
NC		 8923 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8924 sizeof (* entry));
b2d38a17 8925 if (dynamic_section == NULL)
252b5132 8926 {
8b73c356
NC		 8927 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8928 (unsigned long) dynamic_nent);
9ea033b2
NC		 8929 free (edyn);
8930 return 0;
8931 }
252b5132 8932
fb514b26 8933 for (ext = edyn, entry = dynamic_section;
ba2685cc 8934 entry < dynamic_section + dynamic_nent;
fb514b26 8935 ext++, entry++)
9ea033b2 8936 {
fb514b26
AM		 8937 entry->d_tag = BYTE_GET (ext->d_tag);
8938 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8939 }
8940
9ea033b2
NC		 8941 free (edyn);
8942
8943 return 1;
8944}
8945
8946static int
2cf0635d 8947get_64bit_dynamic_section (FILE * file)
9ea033b2 8948{
2cf0635d
NC		 8949 Elf64_External_Dyn * edyn;
8950 Elf64_External_Dyn * ext;
8951 Elf_Internal_Dyn * entry;
103f02d3 8952
071436c6 8953 /* Read in the data. */
3f5e193b
NC		 8954 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8955 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8956 if (!edyn)
8957 return 0;
103f02d3 8958
071436c6
NC		 8959 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8960 might not have the luxury of section headers. Look for the DT_NULL
8961 terminator to determine the number of entries. */
ba2685cc 8962 for (ext = edyn, dynamic_nent = 0;
53c3012c
AM		 8963 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
8964 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
ba2685cc
AM		 8965 ext++)
8966 {
8967 dynamic_nent++;
66543521 8968 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 8969 break;
8970 }
252b5132 8971
3f5e193b
NC		 8972 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8973 sizeof (* entry));
b2d38a17 8974 if (dynamic_section == NULL)
252b5132 8975 {
8b73c356
NC		 8976 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8977 (unsigned long) dynamic_nent);
252b5132
RH		 8978 free (edyn);
8979 return 0;
8980 }
8981
071436c6 8982 /* Convert from external to internal formats. */
fb514b26 8983 for (ext = edyn, entry = dynamic_section;
ba2685cc 8984 entry < dynamic_section + dynamic_nent;
fb514b26 8985 ext++, entry++)
252b5132 8986 {
66543521
AM		 8987 entry->d_tag = BYTE_GET (ext->d_tag);
8988 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8989 }
8990
8991 free (edyn);
8992
9ea033b2
NC		 8993 return 1;
8994}
8995
e9e44622
JJ		 8996static void
8997print_dynamic_flags (bfd_vma flags)
d1133906 8998{
e9e44622 8999 int first = 1;
13ae64f3 9000
d1133906
NC		 9001 while (flags)
9002 {
9003 bfd_vma flag;
9004
9005 flag = flags & - flags;
9006 flags &= ~ flag;
9007
e9e44622
JJ		 9008 if (first)
9009 first = 0;
9010 else
9011 putc (' ', stdout);
13ae64f3 9012
d1133906
NC		 9013 switch (flag)
9014 {
e9e44622
JJ		 9015 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
9016 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
9017 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
9018 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
9019 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 9020 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 9021 }
9022 }
e9e44622 9023 puts ("");
d1133906
NC		 9024}
9025
b2d38a17
NC		 9026/* Parse and display the contents of the dynamic section. */
9027
9ea033b2 9028static int
2cf0635d 9029process_dynamic_section (FILE * file)
9ea033b2 9030{
2cf0635d 9031 Elf_Internal_Dyn * entry;
9ea033b2
NC		 9032
9033 if (dynamic_size == 0)
9034 {
9035 if (do_dynamic)
b2d38a17 9036 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 9037
9038 return 1;
9039 }
9040
9041 if (is_32bit_elf)
9042 {
b2d38a17 9043 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 9044 return 0;
9045 }
b2d38a17 9046 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 9047 return 0;
9048
252b5132
RH		 9049 /* Find the appropriate symbol table. */
9050 if (dynamic_symbols == NULL)
9051 {
86dba8ee
AM		 9052 for (entry = dynamic_section;
9053 entry < dynamic_section + dynamic_nent;
9054 ++entry)
252b5132 9055 {
c8286bd1 9056 Elf_Internal_Shdr section;
252b5132
RH		 9057
9058 if (entry->d_tag != DT_SYMTAB)
9059 continue;
9060
9061 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9062
9063 /* Since we do not know how big the symbol table is,
9064 we default to reading in the entire file (!) and
9065 processing that. This is overkill, I know, but it
e3c8793a 9066 should work. */
d93f0186 9067 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 9068
fb52b2f4
NC		 9069 if (archive_file_offset != 0)
9070 section.sh_size = archive_file_size - section.sh_offset;
9071 else
9072 {
9073 if (fseek (file, 0, SEEK_END))
591a748a 9074 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 9075
9076 section.sh_size = ftell (file) - section.sh_offset;
9077 }
252b5132 9078
9ea033b2 9079 if (is_32bit_elf)
9ad5cbcf 9080 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 9081 else
9ad5cbcf 9082 section.sh_entsize = sizeof (Elf64_External_Sym);
071436c6 9083 section.sh_name = string_table_length;
252b5132 9084
ba5cdace 9085 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 9086 if (num_dynamic_syms < 1)
252b5132
RH		 9087 {
9088 error (_("Unable to determine the number of symbols to load\n"));
9089 continue;
9090 }
252b5132
RH		 9091 }
9092 }
9093
9094 /* Similarly find a string table. */
9095 if (dynamic_strings == NULL)
9096 {
86dba8ee
AM		 9097 for (entry = dynamic_section;
9098 entry < dynamic_section + dynamic_nent;
9099 ++entry)
252b5132
RH		 9100 {
9101 unsigned long offset;
b34976b6 9102 long str_tab_len;
252b5132
RH		 9103
9104 if (entry->d_tag != DT_STRTAB)
9105 continue;
9106
9107 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9108
9109 /* Since we do not know how big the string table is,
9110 we default to reading in the entire file (!) and
9111 processing that. This is overkill, I know, but it
e3c8793a 9112 should work. */
252b5132 9113
d93f0186 9114 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 9115
9116 if (archive_file_offset != 0)
9117 str_tab_len = archive_file_size - offset;
9118 else
9119 {
9120 if (fseek (file, 0, SEEK_END))
9121 error (_("Unable to seek to end of file\n"));
9122 str_tab_len = ftell (file) - offset;
9123 }
252b5132
RH		 9124
9125 if (str_tab_len < 1)
9126 {
9127 error
9128 (_("Unable to determine the length of the dynamic string table\n"));
9129 continue;
9130 }
9131
3f5e193b
NC		 9132 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
9133 str_tab_len,
9134 _("dynamic string table"));
59245841 9135 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 9136 break;
9137 }
9138 }
9139
9140 /* And find the syminfo section if available. */
9141 if (dynamic_syminfo == NULL)
9142 {
3e8bba36 9143 unsigned long syminsz = 0;
252b5132 9144
86dba8ee
AM		 9145 for (entry = dynamic_section;
9146 entry < dynamic_section + dynamic_nent;
9147 ++entry)
252b5132
RH		 9148 {
9149 if (entry->d_tag == DT_SYMINENT)
9150 {
9151 /* Note: these braces are necessary to avoid a syntax
9152 error from the SunOS4 C compiler. */
049b0c3a
NC		 9153 /* PR binutils/17531: A corrupt file can trigger this test.
9154 So do not use an assert, instead generate an error message. */
9155 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
071436c6 9156 error (_("Bad value (%d) for SYMINENT entry\n"),
049b0c3a 9157 (int) entry->d_un.d_val);
252b5132
RH		 9158 }
9159 else if (entry->d_tag == DT_SYMINSZ)
9160 syminsz = entry->d_un.d_val;
9161 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 9162 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
9163 syminsz);
252b5132
RH		 9164 }
9165
9166 if (dynamic_syminfo_offset != 0 && syminsz != 0)
9167 {
2cf0635d
NC		 9168 Elf_External_Syminfo * extsyminfo;
9169 Elf_External_Syminfo * extsym;
9170 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 9171
9172 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 9173 extsyminfo = (Elf_External_Syminfo *)
9174 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
9175 _("symbol information"));
a6e9f9df
AM		 9176 if (!extsyminfo)
9177 return 0;
252b5132 9178
3f5e193b 9179 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 9180 if (dynamic_syminfo == NULL)
9181 {
8b73c356
NC		 9182 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9183 (unsigned long) syminsz);
252b5132
RH		 9184 return 0;
9185 }
9186
9187 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 9188 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9189 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9190 ++syminfo, ++extsym)
252b5132 9191 {
86dba8ee
AM		 9192 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9193 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 9194 }
9195
9196 free (extsyminfo);
9197 }
9198 }
9199
9200 if (do_dynamic && dynamic_addr)
8b73c356
NC		 9201 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9202 dynamic_addr, (unsigned long) dynamic_nent);
252b5132
RH		 9203 if (do_dynamic)
9204 printf (_(" Tag Type Name/Value\n"));
9205
86dba8ee
AM		 9206 for (entry = dynamic_section;
9207 entry < dynamic_section + dynamic_nent;
9208 entry++)
252b5132
RH		 9209 {
9210 if (do_dynamic)
f7a99963 9211 {
2cf0635d 9212 const char * dtype;
e699b9ff 9213
f7a99963
NC		 9214 putchar (' ');
9215 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 9216 dtype = get_dynamic_type (entry->d_tag);
9217 printf (" (%s)%*s", dtype,
9218 ((is_32bit_elf ? 27 : 19)
9219 - (int) strlen (dtype)),
f7a99963
NC		 9220 " ");
9221 }
252b5132
RH		 9222
9223 switch (entry->d_tag)
9224 {
d1133906
NC		 9225 case DT_FLAGS:
9226 if (do_dynamic)
e9e44622 9227 print_dynamic_flags (entry->d_un.d_val);
d1133906 9228 break;
76da6bbe 9229
252b5132
RH		 9230 case DT_AUXILIARY:
9231 case DT_FILTER:
019148e4
L		 9232 case DT_CONFIG:
9233 case DT_DEPAUDIT:
9234 case DT_AUDIT:
252b5132
RH		 9235 if (do_dynamic)
9236 {
019148e4 9237 switch (entry->d_tag)
b34976b6 9238 {
019148e4
L		 9239 case DT_AUXILIARY:
9240 printf (_("Auxiliary library"));
9241 break;
9242
9243 case DT_FILTER:
9244 printf (_("Filter library"));
9245 break;
9246
b34976b6 9247 case DT_CONFIG:
019148e4
L		 9248 printf (_("Configuration file"));
9249 break;
9250
9251 case DT_DEPAUDIT:
9252 printf (_("Dependency audit library"));
9253 break;
9254
9255 case DT_AUDIT:
9256 printf (_("Audit library"));
9257 break;
9258 }
252b5132 9259
d79b3d50
NC		 9260 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9261 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 9262 else
f7a99963
NC		 9263 {
9264 printf (": ");
9265 print_vma (entry->d_un.d_val, PREFIX_HEX);
9266 putchar ('\n');
9267 }
252b5132
RH		 9268 }
9269 break;
9270
dcefbbbd 9271 case DT_FEATURE:
252b5132
RH		 9272 if (do_dynamic)
9273 {
9274 printf (_("Flags:"));
86f55779 9275
252b5132
RH		 9276 if (entry->d_un.d_val == 0)
9277 printf (_(" None\n"));
9278 else
9279 {
9280 unsigned long int val = entry->d_un.d_val;
86f55779 9281
252b5132
RH		 9282 if (val & DTF_1_PARINIT)
9283 {
9284 printf (" PARINIT");
9285 val ^= DTF_1_PARINIT;
9286 }
dcefbbbd
L		 9287 if (val & DTF_1_CONFEXP)
9288 {
9289 printf (" CONFEXP");
9290 val ^= DTF_1_CONFEXP;
9291 }
252b5132
RH		 9292 if (val != 0)
9293 printf (" %lx", val);
9294 puts ("");
9295 }
9296 }
9297 break;
9298
9299 case DT_POSFLAG_1:
9300 if (do_dynamic)
9301 {
9302 printf (_("Flags:"));
86f55779 9303
252b5132
RH		 9304 if (entry->d_un.d_val == 0)
9305 printf (_(" None\n"));
9306 else
9307 {
9308 unsigned long int val = entry->d_un.d_val;
86f55779 9309
252b5132
RH		 9310 if (val & DF_P1_LAZYLOAD)
9311 {
9312 printf (" LAZYLOAD");
9313 val ^= DF_P1_LAZYLOAD;
9314 }
9315 if (val & DF_P1_GROUPPERM)
9316 {
9317 printf (" GROUPPERM");
9318 val ^= DF_P1_GROUPPERM;
9319 }
9320 if (val != 0)
9321 printf (" %lx", val);
9322 puts ("");
9323 }
9324 }
9325 break;
9326
9327 case DT_FLAGS_1:
9328 if (do_dynamic)
9329 {
9330 printf (_("Flags:"));
9331 if (entry->d_un.d_val == 0)
9332 printf (_(" None\n"));
9333 else
9334 {
9335 unsigned long int val = entry->d_un.d_val;
86f55779 9336
252b5132
RH		 9337 if (val & DF_1_NOW)
9338 {
9339 printf (" NOW");
9340 val ^= DF_1_NOW;
9341 }
9342 if (val & DF_1_GLOBAL)
9343 {
9344 printf (" GLOBAL");
9345 val ^= DF_1_GLOBAL;
9346 }
9347 if (val & DF_1_GROUP)
9348 {
9349 printf (" GROUP");
9350 val ^= DF_1_GROUP;
9351 }
9352 if (val & DF_1_NODELETE)
9353 {
9354 printf (" NODELETE");
9355 val ^= DF_1_NODELETE;
9356 }
9357 if (val & DF_1_LOADFLTR)
9358 {
9359 printf (" LOADFLTR");
9360 val ^= DF_1_LOADFLTR;
9361 }
9362 if (val & DF_1_INITFIRST)
9363 {
9364 printf (" INITFIRST");
9365 val ^= DF_1_INITFIRST;
9366 }
9367 if (val & DF_1_NOOPEN)
9368 {
9369 printf (" NOOPEN");
9370 val ^= DF_1_NOOPEN;
9371 }
9372 if (val & DF_1_ORIGIN)
9373 {
9374 printf (" ORIGIN");
9375 val ^= DF_1_ORIGIN;
9376 }
9377 if (val & DF_1_DIRECT)
9378 {
9379 printf (" DIRECT");
9380 val ^= DF_1_DIRECT;
9381 }
9382 if (val & DF_1_TRANS)
9383 {
9384 printf (" TRANS");
9385 val ^= DF_1_TRANS;
9386 }
9387 if (val & DF_1_INTERPOSE)
9388 {
9389 printf (" INTERPOSE");
9390 val ^= DF_1_INTERPOSE;
9391 }
f7db6139 9392 if (val & DF_1_NODEFLIB)
dcefbbbd 9393 {
f7db6139
L		 9394 printf (" NODEFLIB");
9395 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 9396 }
9397 if (val & DF_1_NODUMP)
9398 {
9399 printf (" NODUMP");
9400 val ^= DF_1_NODUMP;
9401 }
34b60028 9402 if (val & DF_1_CONFALT)
dcefbbbd 9403 {
34b60028
L		 9404 printf (" CONFALT");
9405 val ^= DF_1_CONFALT;
9406 }
9407 if (val & DF_1_ENDFILTEE)
9408 {
9409 printf (" ENDFILTEE");
9410 val ^= DF_1_ENDFILTEE;
9411 }
9412 if (val & DF_1_DISPRELDNE)
9413 {
9414 printf (" DISPRELDNE");
9415 val ^= DF_1_DISPRELDNE;
9416 }
9417 if (val & DF_1_DISPRELPND)
9418 {
9419 printf (" DISPRELPND");
9420 val ^= DF_1_DISPRELPND;
9421 }
9422 if (val & DF_1_NODIRECT)
9423 {
9424 printf (" NODIRECT");
9425 val ^= DF_1_NODIRECT;
9426 }
9427 if (val & DF_1_IGNMULDEF)
9428 {
9429 printf (" IGNMULDEF");
9430 val ^= DF_1_IGNMULDEF;
9431 }
9432 if (val & DF_1_NOKSYMS)
9433 {
9434 printf (" NOKSYMS");
9435 val ^= DF_1_NOKSYMS;
9436 }
9437 if (val & DF_1_NOHDR)
9438 {
9439 printf (" NOHDR");
9440 val ^= DF_1_NOHDR;
9441 }
9442 if (val & DF_1_EDITED)
9443 {
9444 printf (" EDITED");
9445 val ^= DF_1_EDITED;
9446 }
9447 if (val & DF_1_NORELOC)
9448 {
9449 printf (" NORELOC");
9450 val ^= DF_1_NORELOC;
9451 }
9452 if (val & DF_1_SYMINTPOSE)
9453 {
9454 printf (" SYMINTPOSE");
9455 val ^= DF_1_SYMINTPOSE;
9456 }
9457 if (val & DF_1_GLOBAUDIT)
9458 {
9459 printf (" GLOBAUDIT");
9460 val ^= DF_1_GLOBAUDIT;
9461 }
9462 if (val & DF_1_SINGLETON)
9463 {
9464 printf (" SINGLETON");
9465 val ^= DF_1_SINGLETON;
dcefbbbd 9466 }
5c383f02
RO		 9467 if (val & DF_1_STUB)
9468 {
9469 printf (" STUB");
9470 val ^= DF_1_STUB;
9471 }
9472 if (val & DF_1_PIE)
9473 {
9474 printf (" PIE");
9475 val ^= DF_1_PIE;
9476 }
252b5132
RH		 9477 if (val != 0)
9478 printf (" %lx", val);
9479 puts ("");
9480 }
9481 }
9482 break;
9483
9484 case DT_PLTREL:
566b0d53 9485 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9486 if (do_dynamic)
9487 puts (get_dynamic_type (entry->d_un.d_val));
9488 break;
9489
9490 case DT_NULL :
9491 case DT_NEEDED :
9492 case DT_PLTGOT :
9493 case DT_HASH :
9494 case DT_STRTAB :
9495 case DT_SYMTAB :
9496 case DT_RELA :
9497 case DT_INIT :
9498 case DT_FINI :
9499 case DT_SONAME :
9500 case DT_RPATH :
9501 case DT_SYMBOLIC:
9502 case DT_REL :
9503 case DT_DEBUG :
9504 case DT_TEXTREL :
9505 case DT_JMPREL :
019148e4 9506 case DT_RUNPATH :
252b5132
RH		 9507 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9508
9509 if (do_dynamic)
9510 {
2cf0635d 9511 char * name;
252b5132 9512
d79b3d50
NC		 9513 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9514 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9515 else
d79b3d50 9516 name = NULL;
252b5132
RH		 9517
9518 if (name)
9519 {
9520 switch (entry->d_tag)
9521 {
9522 case DT_NEEDED:
9523 printf (_("Shared library: [%s]"), name);
9524
18bd398b 9525 if (streq (name, program_interpreter))
f7a99963 9526 printf (_(" program interpreter"));
252b5132
RH		 9527 break;
9528
9529 case DT_SONAME:
f7a99963 9530 printf (_("Library soname: [%s]"), name);
252b5132
RH		 9531 break;
9532
9533 case DT_RPATH:
f7a99963 9534 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 9535 break;
9536
019148e4
L		 9537 case DT_RUNPATH:
9538 printf (_("Library runpath: [%s]"), name);
9539 break;
9540
252b5132 9541 default:
f7a99963
NC		 9542 print_vma (entry->d_un.d_val, PREFIX_HEX);
9543 break;
252b5132
RH		 9544 }
9545 }
9546 else
f7a99963
NC		 9547 print_vma (entry->d_un.d_val, PREFIX_HEX);
9548
9549 putchar ('\n');
252b5132
RH		 9550 }
9551 break;
9552
9553 case DT_PLTRELSZ:
9554 case DT_RELASZ :
9555 case DT_STRSZ :
9556 case DT_RELSZ :
9557 case DT_RELAENT :
9558 case DT_SYMENT :
9559 case DT_RELENT :
566b0d53 9560 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9561 case DT_PLTPADSZ:
9562 case DT_MOVEENT :
9563 case DT_MOVESZ :
9564 case DT_INIT_ARRAYSZ:
9565 case DT_FINI_ARRAYSZ:
047b2264
JJ		 9566 case DT_GNU_CONFLICTSZ:
9567 case DT_GNU_LIBLISTSZ:
252b5132 9568 if (do_dynamic)
f7a99963
NC		 9569 {
9570 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 9571 printf (_(" (bytes)\n"));
f7a99963 9572 }
252b5132
RH		 9573 break;
9574
9575 case DT_VERDEFNUM:
9576 case DT_VERNEEDNUM:
9577 case DT_RELACOUNT:
9578 case DT_RELCOUNT:
9579 if (do_dynamic)
f7a99963
NC		 9580 {
9581 print_vma (entry->d_un.d_val, UNSIGNED);
9582 putchar ('\n');
9583 }
252b5132
RH		 9584 break;
9585
9586 case DT_SYMINSZ:
9587 case DT_SYMINENT:
9588 case DT_SYMINFO:
9589 case DT_USED:
9590 case DT_INIT_ARRAY:
9591 case DT_FINI_ARRAY:
9592 if (do_dynamic)
9593 {
d79b3d50
NC		 9594 if (entry->d_tag == DT_USED
9595 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 9596 {
2cf0635d 9597 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9598
b34976b6 9599 if (*name)
252b5132
RH		 9600 {
9601 printf (_("Not needed object: [%s]\n"), name);
9602 break;
9603 }
9604 }
103f02d3 9605
f7a99963
NC		 9606 print_vma (entry->d_un.d_val, PREFIX_HEX);
9607 putchar ('\n');
252b5132
RH		 9608 }
9609 break;
9610
9611 case DT_BIND_NOW:
9612 /* The value of this entry is ignored. */
35b1837e
AM		 9613 if (do_dynamic)
9614 putchar ('\n');
252b5132 9615 break;
103f02d3 9616
047b2264
JJ		 9617 case DT_GNU_PRELINKED:
9618 if (do_dynamic)
9619 {
2cf0635d 9620 struct tm * tmp;
91d6fa6a 9621 time_t atime = entry->d_un.d_val;
047b2264 9622
91d6fa6a 9623 tmp = gmtime (&atime);
071436c6
NC		 9624 /* PR 17533 file: 041-1244816-0.004. */
9625 if (tmp == NULL)
5a2cbcf4
L		 9626 printf (_("<corrupt time val: %lx"),
9627 (unsigned long) atime);
071436c6
NC		 9628 else
9629 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9630 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9631 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 9632
9633 }
9634 break;
9635
fdc90cb4
JJ		 9636 case DT_GNU_HASH:
9637 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9638 if (do_dynamic)
9639 {
9640 print_vma (entry->d_un.d_val, PREFIX_HEX);
9641 putchar ('\n');
9642 }
9643 break;
9644
252b5132
RH		 9645 default:
9646 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 9647 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 9648 entry->d_un.d_val;
9649
9650 if (do_dynamic)
9651 {
9652 switch (elf_header.e_machine)
9653 {
9654 case EM_MIPS:
4fe85591 9655 case EM_MIPS_RS3_LE:
b2d38a17 9656 dynamic_section_mips_val (entry);
252b5132 9657 break;
103f02d3 9658 case EM_PARISC:
b2d38a17 9659 dynamic_section_parisc_val (entry);
103f02d3 9660 break;
ecc51f48 9661 case EM_IA_64:
b2d38a17 9662 dynamic_section_ia64_val (entry);
ecc51f48 9663 break;
252b5132 9664 default:
f7a99963
NC		 9665 print_vma (entry->d_un.d_val, PREFIX_HEX);
9666 putchar ('\n');
252b5132
RH		 9667 }
9668 }
9669 break;
9670 }
9671 }
9672
9673 return 1;
9674}
9675
9676static char *
d3ba0551 9677get_ver_flags (unsigned int flags)
252b5132 9678{
b34976b6 9679 static char buff[32];
252b5132
RH		 9680
9681 buff[0] = 0;
9682
9683 if (flags == 0)
9684 return _("none");
9685
9686 if (flags & VER_FLG_BASE)
9687 strcat (buff, "BASE ");
9688
9689 if (flags & VER_FLG_WEAK)
9690 {
9691 if (flags & VER_FLG_BASE)
9692 strcat (buff, "| ");
9693
9694 strcat (buff, "WEAK ");
9695 }
9696
44ec90b9
RO		 9697 if (flags & VER_FLG_INFO)
9698 {
9699 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9700 strcat (buff, "| ");
9701
9702 strcat (buff, "INFO ");
9703 }
9704
9705 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 9706 strcat (buff, _("| <unknown>"));
252b5132
RH		 9707
9708 return buff;
9709}
9710
9711/* Display the contents of the version sections. */
98fb390a 9712
252b5132 9713static int
2cf0635d 9714process_version_sections (FILE * file)
252b5132 9715{
2cf0635d 9716 Elf_Internal_Shdr * section;
b34976b6
AM		 9717 unsigned i;
9718 int found = 0;
252b5132
RH		 9719
9720 if (! do_version)
9721 return 1;
9722
9723 for (i = 0, section = section_headers;
9724 i < elf_header.e_shnum;
b34976b6 9725 i++, section++)
252b5132
RH		 9726 {
9727 switch (section->sh_type)
9728 {
9729 case SHT_GNU_verdef:
9730 {
2cf0635d 9731 Elf_External_Verdef * edefs;
b34976b6
AM		 9732 unsigned int idx;
9733 unsigned int cnt;
2cf0635d 9734 char * endbuf;
252b5132
RH		 9735
9736 found = 1;
9737
74e1a04b
NC		 9738 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9739 printable_section_name (section),
9740 section->sh_info);
252b5132
RH		 9741
9742 printf (_(" Addr: 0x"));
9743 printf_vma (section->sh_addr);
74e1a04b 9744 printf (_(" Offset: %#08lx Link: %u (%s)"),
1b228002 9745 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9746 printable_section_name_from_index (section->sh_link));
252b5132 9747
3f5e193b
NC		 9748 edefs = (Elf_External_Verdef *)
9749 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9750 _("version definition section"));
a6e9f9df
AM		 9751 if (!edefs)
9752 break;
59245841 9753 endbuf = (char *) edefs + section->sh_size;
252b5132 9754
b34976b6 9755 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 9756 {
2cf0635d
NC		 9757 char * vstart;
9758 Elf_External_Verdef * edef;
b34976b6 9759 Elf_Internal_Verdef ent;
2cf0635d 9760 Elf_External_Verdaux * eaux;
b34976b6
AM		 9761 Elf_Internal_Verdaux aux;
9762 int j;
9763 int isum;
103f02d3 9764
7e26601c
NC		 9765 /* Check for very large indicies. */
9766 if (idx > (size_t) (endbuf - (char *) edefs))
dd24e3da
NC		 9767 break;
9768
252b5132 9769 vstart = ((char *) edefs) + idx;
54806181
AM		 9770 if (vstart + sizeof (*edef) > endbuf)
9771 break;
252b5132
RH		 9772
9773 edef = (Elf_External_Verdef *) vstart;
9774
9775 ent.vd_version = BYTE_GET (edef->vd_version);
9776 ent.vd_flags = BYTE_GET (edef->vd_flags);
9777 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
9778 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
9779 ent.vd_hash = BYTE_GET (edef->vd_hash);
9780 ent.vd_aux = BYTE_GET (edef->vd_aux);
9781 ent.vd_next = BYTE_GET (edef->vd_next);
9782
9783 printf (_(" %#06x: Rev: %d Flags: %s"),
9784 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9785
9786 printf (_(" Index: %d Cnt: %d "),
9787 ent.vd_ndx, ent.vd_cnt);
9788
dd24e3da 9789 /* Check for overflow. */
7e26601c 9790 if (ent.vd_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 9791 break;
9792
252b5132
RH		 9793 vstart += ent.vd_aux;
9794
9795 eaux = (Elf_External_Verdaux *) vstart;
9796
9797 aux.vda_name = BYTE_GET (eaux->vda_name);
9798 aux.vda_next = BYTE_GET (eaux->vda_next);
9799
d79b3d50
NC		 9800 if (VALID_DYNAMIC_NAME (aux.vda_name))
9801 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9802 else
9803 printf (_("Name index: %ld\n"), aux.vda_name);
9804
9805 isum = idx + ent.vd_aux;
9806
b34976b6 9807 for (j = 1; j < ent.vd_cnt; j++)
252b5132 9808 {
dd24e3da 9809 /* Check for overflow. */
7e26601c 9810 if (aux.vda_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 9811 break;
9812
252b5132
RH		 9813 isum += aux.vda_next;
9814 vstart += aux.vda_next;
9815
9816 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 9817 if (vstart + sizeof (*eaux) > endbuf)
9818 break;
252b5132
RH		 9819
9820 aux.vda_name = BYTE_GET (eaux->vda_name);
9821 aux.vda_next = BYTE_GET (eaux->vda_next);
9822
d79b3d50 9823 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 9824 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 9825 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9826 else
9827 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9828 isum, j, aux.vda_name);
9829 }
dd24e3da 9830
54806181
AM		 9831 if (j < ent.vd_cnt)
9832 printf (_(" Version def aux past end of section\n"));
252b5132 9833
5d921cbd
NC		 9834 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9835 if (idx + ent.vd_next <= idx)
9836 break;
9837
252b5132
RH		 9838 idx += ent.vd_next;
9839 }
dd24e3da 9840
54806181
AM		 9841 if (cnt < section->sh_info)
9842 printf (_(" Version definition past end of section\n"));
252b5132
RH		 9843
9844 free (edefs);
9845 }
9846 break;
103f02d3 9847
252b5132
RH		 9848 case SHT_GNU_verneed:
9849 {
2cf0635d 9850 Elf_External_Verneed * eneed;
b34976b6
AM		 9851 unsigned int idx;
9852 unsigned int cnt;
2cf0635d 9853 char * endbuf;
252b5132
RH		 9854
9855 found = 1;
9856
72de5009 9857 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
74e1a04b 9858 printable_section_name (section), section->sh_info);
252b5132
RH		 9859
9860 printf (_(" Addr: 0x"));
9861 printf_vma (section->sh_addr);
72de5009 9862 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9863 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9864 printable_section_name_from_index (section->sh_link));
252b5132 9865
3f5e193b
NC		 9866 eneed = (Elf_External_Verneed *) get_data (NULL, file,
9867 section->sh_offset, 1,
9868 section->sh_size,
9cf03b7e 9869 _("Version Needs section"));
a6e9f9df
AM		 9870 if (!eneed)
9871 break;
59245841 9872 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 9873
9874 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9875 {
2cf0635d 9876 Elf_External_Verneed * entry;
b34976b6
AM		 9877 Elf_Internal_Verneed ent;
9878 int j;
9879 int isum;
2cf0635d 9880 char * vstart;
252b5132 9881
7e26601c 9882 if (idx > (size_t) (endbuf - (char *) eneed))
dd24e3da
NC		 9883 break;
9884
252b5132 9885 vstart = ((char *) eneed) + idx;
54806181
AM		 9886 if (vstart + sizeof (*entry) > endbuf)
9887 break;
252b5132
RH		 9888
9889 entry = (Elf_External_Verneed *) vstart;
9890
9891 ent.vn_version = BYTE_GET (entry->vn_version);
9892 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
9893 ent.vn_file = BYTE_GET (entry->vn_file);
9894 ent.vn_aux = BYTE_GET (entry->vn_aux);
9895 ent.vn_next = BYTE_GET (entry->vn_next);
9896
9897 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
9898
d79b3d50
NC		 9899 if (VALID_DYNAMIC_NAME (ent.vn_file))
9900 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 9901 else
9902 printf (_(" File: %lx"), ent.vn_file);
9903
9904 printf (_(" Cnt: %d\n"), ent.vn_cnt);
9905
dd24e3da 9906 /* Check for overflow. */
7e26601c 9907 if (ent.vn_aux > (size_t) (endbuf - vstart))
dd24e3da 9908 break;
252b5132
RH		 9909 vstart += ent.vn_aux;
9910
9911 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9912 {
2cf0635d 9913 Elf_External_Vernaux * eaux;
b34976b6 9914 Elf_Internal_Vernaux aux;
252b5132 9915
54806181
AM		 9916 if (vstart + sizeof (*eaux) > endbuf)
9917 break;
252b5132
RH		 9918 eaux = (Elf_External_Vernaux *) vstart;
9919
9920 aux.vna_hash = BYTE_GET (eaux->vna_hash);
9921 aux.vna_flags = BYTE_GET (eaux->vna_flags);
9922 aux.vna_other = BYTE_GET (eaux->vna_other);
9923 aux.vna_name = BYTE_GET (eaux->vna_name);
9924 aux.vna_next = BYTE_GET (eaux->vna_next);
9925
d79b3d50 9926 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 9927 printf (_(" %#06x: Name: %s"),
d79b3d50 9928 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 9929 else
ecc2063b 9930 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 9931 isum, aux.vna_name);
9932
9933 printf (_(" Flags: %s Version: %d\n"),
9934 get_ver_flags (aux.vna_flags), aux.vna_other);
9935
dd24e3da 9936 /* Check for overflow. */
53774b7e
NC		 9937 if (aux.vna_next > (size_t) (endbuf - vstart)
9938 || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
9939 {
9940 warn (_("Invalid vna_next field of %lx\n"),
9941 aux.vna_next);
9942 j = ent.vn_cnt;
9943 break;
9944 }
252b5132
RH		 9945 isum += aux.vna_next;
9946 vstart += aux.vna_next;
9947 }
9cf03b7e 9948
54806181 9949 if (j < ent.vn_cnt)
9cf03b7e 9950 warn (_("Missing Version Needs auxillary information\n"));
252b5132 9951
bcf83b2a 9952 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
c24cf8b6
NC		 9953 {
9954 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9955 cnt = section->sh_info;
9956 break;
9957 }
252b5132
RH		 9958 idx += ent.vn_next;
9959 }
9cf03b7e 9960
54806181 9961 if (cnt < section->sh_info)
9cf03b7e 9962 warn (_("Missing Version Needs information\n"));
103f02d3 9963
252b5132
RH		 9964 free (eneed);
9965 }
9966 break;
9967
9968 case SHT_GNU_versym:
9969 {
2cf0635d 9970 Elf_Internal_Shdr * link_section;
8b73c356
NC		 9971 size_t total;
9972 unsigned int cnt;
2cf0635d
NC		 9973 unsigned char * edata;
9974 unsigned short * data;
9975 char * strtab;
9976 Elf_Internal_Sym * symbols;
9977 Elf_Internal_Shdr * string_sec;
ba5cdace 9978 unsigned long num_syms;
d3ba0551 9979 long off;
252b5132 9980
4fbb74a6 9981 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9982 break;
9983
4fbb74a6 9984 link_section = section_headers + section->sh_link;
08d8fa11 9985 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 9986
4fbb74a6 9987 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9988 break;
9989
252b5132
RH		 9990 found = 1;
9991
ba5cdace 9992 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 9993 if (symbols == NULL)
9994 break;
252b5132 9995
4fbb74a6 9996 string_sec = section_headers + link_section->sh_link;
252b5132 9997
3f5e193b
NC		 9998 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9999 string_sec->sh_size,
10000 _("version string table"));
a6e9f9df 10001 if (!strtab)
0429c154
MS		 10002 {
10003 free (symbols);
10004 break;
10005 }
252b5132 10006
8b73c356
NC		 10007 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10008 printable_section_name (section), (unsigned long) total);
252b5132
RH		 10009
10010 printf (_(" Addr: "));
10011 printf_vma (section->sh_addr);
72de5009 10012 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 10013 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 10014 printable_section_name (link_section));
252b5132 10015
d3ba0551
AM		 10016 off = offset_from_vma (file,
10017 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10018 total * sizeof (short));
3f5e193b
NC		 10019 edata = (unsigned char *) get_data (NULL, file, off, total,
10020 sizeof (short),
10021 _("version symbol data"));
a6e9f9df
AM		 10022 if (!edata)
10023 {
10024 free (strtab);
0429c154 10025 free (symbols);
a6e9f9df
AM		 10026 break;
10027 }
252b5132 10028
3f5e193b 10029 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 10030
10031 for (cnt = total; cnt --;)
b34976b6
AM		 10032 data[cnt] = byte_get (edata + cnt * sizeof (short),
10033 sizeof (short));
252b5132
RH		 10034
10035 free (edata);
10036
10037 for (cnt = 0; cnt < total; cnt += 4)
10038 {
10039 int j, nn;
ab273396
AM		 10040 char *name;
10041 char *invalid = _("*invalid*");
252b5132
RH		 10042
10043 printf (" %03x:", cnt);
10044
10045 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 10046 switch (data[cnt + j])
252b5132
RH		 10047 {
10048 case 0:
10049 fputs (_(" 0 (*local*) "), stdout);
10050 break;
10051
10052 case 1:
10053 fputs (_(" 1 (*global*) "), stdout);
10054 break;
10055
10056 default:
c244d050
NC		 10057 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10058 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 10059
dd24e3da 10060 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 10061 array, break to avoid an out-of-bounds read. */
10062 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 10063 {
10064 warn (_("invalid index into symbol array\n"));
10065 break;
10066 }
10067
ab273396
AM		 10068 name = NULL;
10069 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 10070 {
b34976b6
AM		 10071 Elf_Internal_Verneed ivn;
10072 unsigned long offset;
252b5132 10073
d93f0186
NC		 10074 offset = offset_from_vma
10075 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10076 sizeof (Elf_External_Verneed));
252b5132 10077
b34976b6 10078 do
252b5132 10079 {
b34976b6
AM		 10080 Elf_Internal_Vernaux ivna;
10081 Elf_External_Verneed evn;
10082 Elf_External_Vernaux evna;
10083 unsigned long a_off;
252b5132 10084
59245841
NC		 10085 if (get_data (&evn, file, offset, sizeof (evn), 1,
10086 _("version need")) == NULL)
10087 break;
0b4362b0 10088
252b5132
RH		 10089 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10090 ivn.vn_next = BYTE_GET (evn.vn_next);
10091
10092 a_off = offset + ivn.vn_aux;
10093
10094 do
10095 {
59245841
NC		 10096 if (get_data (&evna, file, a_off, sizeof (evna),
10097 1, _("version need aux (2)")) == NULL)
10098 {
10099 ivna.vna_next = 0;
10100 ivna.vna_other = 0;
10101 }
10102 else
10103 {
10104 ivna.vna_next = BYTE_GET (evna.vna_next);
10105 ivna.vna_other = BYTE_GET (evna.vna_other);
10106 }
252b5132
RH		 10107
10108 a_off += ivna.vna_next;
10109 }
b34976b6 10110 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 10111 && ivna.vna_next != 0);
10112
b34976b6 10113 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 10114 {
10115 ivna.vna_name = BYTE_GET (evna.vna_name);
10116
54806181 10117 if (ivna.vna_name >= string_sec->sh_size)
ab273396 10118 name = invalid;
54806181
AM		 10119 else
10120 name = strtab + ivna.vna_name;
252b5132
RH		 10121 break;
10122 }
10123
10124 offset += ivn.vn_next;
10125 }
10126 while (ivn.vn_next);
10127 }
00d93f34 10128
ab273396 10129 if (data[cnt + j] != 0x8001
b34976b6 10130 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 10131 {
b34976b6
AM		 10132 Elf_Internal_Verdef ivd;
10133 Elf_External_Verdef evd;
10134 unsigned long offset;
252b5132 10135
d93f0186
NC		 10136 offset = offset_from_vma
10137 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10138 sizeof evd);
252b5132
RH		 10139
10140 do
10141 {
59245841
NC		 10142 if (get_data (&evd, file, offset, sizeof (evd), 1,
10143 _("version def")) == NULL)
10144 {
10145 ivd.vd_next = 0;
948f632f 10146 /* PR 17531: file: 046-1082287-0.004. */
3102e897
NC		 10147 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
10148 break;
59245841
NC		 10149 }
10150 else
10151 {
10152 ivd.vd_next = BYTE_GET (evd.vd_next);
10153 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10154 }
252b5132
RH		 10155
10156 offset += ivd.vd_next;
10157 }
c244d050 10158 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 10159 && ivd.vd_next != 0);
10160
c244d050 10161 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 10162 {
b34976b6
AM		 10163 Elf_External_Verdaux evda;
10164 Elf_Internal_Verdaux ivda;
252b5132
RH		 10165
10166 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10167
59245841
NC		 10168 if (get_data (&evda, file,
10169 offset - ivd.vd_next + ivd.vd_aux,
10170 sizeof (evda), 1,
10171 _("version def aux")) == NULL)
10172 break;
252b5132
RH		 10173
10174 ivda.vda_name = BYTE_GET (evda.vda_name);
10175
54806181 10176 if (ivda.vda_name >= string_sec->sh_size)
ab273396
AM		 10177 name = invalid;
10178 else if (name != NULL && name != invalid)
10179 name = _("*both*");
54806181
AM		 10180 else
10181 name = strtab + ivda.vda_name;
252b5132
RH		 10182 }
10183 }
ab273396
AM		 10184 if (name != NULL)
10185 nn += printf ("(%s%-*s",
10186 name,
10187 12 - (int) strlen (name),
10188 ")");
252b5132
RH		 10189
10190 if (nn < 18)
10191 printf ("%*c", 18 - nn, ' ');
10192 }
10193
10194 putchar ('\n');
10195 }
10196
10197 free (data);
10198 free (strtab);
10199 free (symbols);
10200 }
10201 break;
103f02d3 10202
252b5132
RH		 10203 default:
10204 break;
10205 }
10206 }
10207
10208 if (! found)
10209 printf (_("\nNo version information found in this file.\n"));
10210
10211 return 1;
10212}
10213
d1133906 10214static const char *
d3ba0551 10215get_symbol_binding (unsigned int binding)
252b5132 10216{
b34976b6 10217 static char buff[32];
252b5132
RH		 10218
10219 switch (binding)
10220 {
b34976b6
AM		 10221 case STB_LOCAL: return "LOCAL";
10222 case STB_GLOBAL: return "GLOBAL";
10223 case STB_WEAK: return "WEAK";
252b5132
RH		 10224 default:
10225 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 10226 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10227 binding);
252b5132 10228 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 10229 {
10230 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 10231 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10232 /* GNU is still using the default value 0. */
3e7a7d11
NC		 10233 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10234 return "UNIQUE";
10235 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10236 }
252b5132 10237 else
e9e44622 10238 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 10239 return buff;
10240 }
10241}
10242
d1133906 10243static const char *
d3ba0551 10244get_symbol_type (unsigned int type)
252b5132 10245{
b34976b6 10246 static char buff[32];
252b5132
RH		 10247
10248 switch (type)
10249 {
b34976b6
AM		 10250 case STT_NOTYPE: return "NOTYPE";
10251 case STT_OBJECT: return "OBJECT";
10252 case STT_FUNC: return "FUNC";
10253 case STT_SECTION: return "SECTION";
10254 case STT_FILE: return "FILE";
10255 case STT_COMMON: return "COMMON";
10256 case STT_TLS: return "TLS";
15ab5209
DB		 10257 case STT_RELC: return "RELC";
10258 case STT_SRELC: return "SRELC";
252b5132
RH		 10259 default:
10260 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af 10261 {
3510a7b8
NC		 10262 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10263 return "THUMB_FUNC";
103f02d3 10264
351b4b40 10265 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 10266 return "REGISTER";
10267
10268 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10269 return "PARISC_MILLI";
10270
e9e44622 10271 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 10272 }
252b5132 10273 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 10274 {
10275 if (elf_header.e_machine == EM_PARISC)
10276 {
10277 if (type == STT_HP_OPAQUE)
10278 return "HP_OPAQUE";
10279 if (type == STT_HP_STUB)
10280 return "HP_STUB";
10281 }
10282
d8045f23 10283 if (type == STT_GNU_IFUNC
9c55345c 10284 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 10285 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 10286 /* GNU is still using the default value 0. */
d8045f23
NC		 10287 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10288 return "IFUNC";
10289
e9e44622 10290 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 10291 }
252b5132 10292 else
e9e44622 10293 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 10294 return buff;
10295 }
10296}
10297
d1133906 10298static const char *
d3ba0551 10299get_symbol_visibility (unsigned int visibility)
d1133906
NC		 10300{
10301 switch (visibility)
10302 {
b34976b6
AM		 10303 case STV_DEFAULT: return "DEFAULT";
10304 case STV_INTERNAL: return "INTERNAL";
10305 case STV_HIDDEN: return "HIDDEN";
d1133906 10306 case STV_PROTECTED: return "PROTECTED";
bee0ee85
NC		 10307 default:
10308 error (_("Unrecognized visibility value: %u"), visibility);
10309 return _("<unknown>");
d1133906
NC		 10310 }
10311}
10312
fd85a6a1
NC		 10313static const char *
10314get_solaris_symbol_visibility (unsigned int visibility)
10315{
10316 switch (visibility)
10317 {
10318 case 4: return "EXPORTED";
10319 case 5: return "SINGLETON";
10320 case 6: return "ELIMINATE";
10321 default: return get_symbol_visibility (visibility);
10322 }
10323}
10324
5e2b0d47
NC		 10325static const char *
10326get_mips_symbol_other (unsigned int other)
10327{
10328 switch (other)
10329 {
df58fc94
RS		 10330 case STO_OPTIONAL:
10331 return "OPTIONAL";
10332 case STO_MIPS_PLT:
10333 return "MIPS PLT";
10334 case STO_MIPS_PIC:
10335 return "MIPS PIC";
10336 case STO_MICROMIPS:
10337 return "MICROMIPS";
10338 case STO_MICROMIPS | STO_MIPS_PIC:
10339 return "MICROMIPS, MIPS PIC";
10340 case STO_MIPS16:
10341 return "MIPS16";
10342 default:
10343 return NULL;
5e2b0d47
NC		 10344 }
10345}
10346
28f997cf
TG		 10347static const char *
10348get_ia64_symbol_other (unsigned int other)
10349{
10350 if (is_ia64_vms ())
10351 {
10352 static char res[32];
10353
10354 res[0] = 0;
10355
10356 /* Function types is for images and .STB files only. */
10357 switch (elf_header.e_type)
10358 {
10359 case ET_DYN:
10360 case ET_EXEC:
10361 switch (VMS_ST_FUNC_TYPE (other))
10362 {
10363 case VMS_SFT_CODE_ADDR:
10364 strcat (res, " CA");
10365 break;
10366 case VMS_SFT_SYMV_IDX:
10367 strcat (res, " VEC");
10368 break;
10369 case VMS_SFT_FD:
10370 strcat (res, " FD");
10371 break;
10372 case VMS_SFT_RESERVE:
10373 strcat (res, " RSV");
10374 break;
10375 default:
bee0ee85
NC		 10376 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10377 VMS_ST_FUNC_TYPE (other));
10378 strcat (res, " <unknown>");
10379 break;
28f997cf
TG		 10380 }
10381 break;
10382 default:
10383 break;
10384 }
10385 switch (VMS_ST_LINKAGE (other))
10386 {
10387 case VMS_STL_IGNORE:
10388 strcat (res, " IGN");
10389 break;
10390 case VMS_STL_RESERVE:
10391 strcat (res, " RSV");
10392 break;
10393 case VMS_STL_STD:
10394 strcat (res, " STD");
10395 break;
10396 case VMS_STL_LNK:
10397 strcat (res, " LNK");
10398 break;
10399 default:
bee0ee85
NC		 10400 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10401 VMS_ST_LINKAGE (other));
10402 strcat (res, " <unknown>");
10403 break;
28f997cf
TG		 10404 }
10405
10406 if (res[0] != 0)
10407 return res + 1;
10408 else
10409 return res;
10410 }
10411 return NULL;
10412}
10413
6911b7dc
AM		 10414static const char *
10415get_ppc64_symbol_other (unsigned int other)
10416{
10417 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10418 {
10419 static char buf[32];
10420 snprintf (buf, sizeof buf, _("<localentry>: %d"),
10421 PPC64_LOCAL_ENTRY_OFFSET (other));
10422 return buf;
10423 }
10424 return NULL;
10425}
10426
5e2b0d47
NC		 10427static const char *
10428get_symbol_other (unsigned int other)
10429{
10430 const char * result = NULL;
10431 static char buff [32];
10432
10433 if (other == 0)
10434 return "";
10435
10436 switch (elf_header.e_machine)
10437 {
10438 case EM_MIPS:
10439 result = get_mips_symbol_other (other);
28f997cf
TG		 10440 break;
10441 case EM_IA_64:
10442 result = get_ia64_symbol_other (other);
10443 break;
6911b7dc
AM		 10444 case EM_PPC64:
10445 result = get_ppc64_symbol_other (other);
10446 break;
5e2b0d47 10447 default:
fd85a6a1 10448 result = NULL;
5e2b0d47
NC		 10449 break;
10450 }
10451
10452 if (result)
10453 return result;
10454
10455 snprintf (buff, sizeof buff, _("<other>: %x"), other);
10456 return buff;
10457}
10458
d1133906 10459static const char *
d3ba0551 10460get_symbol_index_type (unsigned int type)
252b5132 10461{
b34976b6 10462 static char buff[32];
5cf1065c 10463
252b5132
RH		 10464 switch (type)
10465 {
b34976b6
AM		 10466 case SHN_UNDEF: return "UND";
10467 case SHN_ABS: return "ABS";
10468 case SHN_COMMON: return "COM";
252b5132 10469 default:
9ce701e2
L		 10470 if (type == SHN_IA_64_ANSI_COMMON
10471 && elf_header.e_machine == EM_IA_64
10472 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10473 return "ANSI_COM";
8a9036a4 10474 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 10475 || elf_header.e_machine == EM_L1OM
10476 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 10477 && type == SHN_X86_64_LCOMMON)
10478 return "LARGE_COM";
ac145307
BS		 10479 else if ((type == SHN_MIPS_SCOMMON
10480 && elf_header.e_machine == EM_MIPS)
10481 || (type == SHN_TIC6X_SCOMMON
10482 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 10483 return "SCOM";
10484 else if (type == SHN_MIPS_SUNDEFINED
10485 && elf_header.e_machine == EM_MIPS)
10486 return "SUND";
9ce701e2 10487 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 10488 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 10489 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 10490 sprintf (buff, "OS [0x%04x]", type & 0xffff);
10491 else if (type >= SHN_LORESERVE)
10492 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4 10493 else if (type >= elf_header.e_shnum)
e0a31db1 10494 sprintf (buff, _("bad section index[%3d]"), type);
252b5132 10495 else
232e7cb8 10496 sprintf (buff, "%3d", type);
5cf1065c 10497 break;
252b5132 10498 }
5cf1065c
NC		 10499
10500 return buff;
252b5132
RH		 10501}
10502
66543521 10503static bfd_vma *
57028622 10504get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
252b5132 10505{
2cf0635d
NC		 10506 unsigned char * e_data;
10507 bfd_vma * i_data;
252b5132 10508
57028622
NC		 10509 /* If the size_t type is smaller than the bfd_size_type, eg because
10510 you are building a 32-bit tool on a 64-bit host, then make sure
10511 that when (number) is cast to (size_t) no information is lost. */
10512 if (sizeof (size_t) < sizeof (bfd_size_type)
10513 && (bfd_size_type) ((size_t) number) != number)
10514 {
ed754a13
AM		 10515 error (_("Size truncation prevents reading %" BFD_VMA_FMT "u"
10516 " elements of size %u\n"),
10517 number, ent_size);
57028622
NC		 10518 return NULL;
10519 }
948f632f 10520
3102e897
NC		 10521 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10522 attempting to allocate memory when the read is bound to fail. */
10523 if (ent_size * number > current_file_size)
10524 {
ed754a13
AM		 10525 error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT "u\n"),
10526 number);
3102e897
NC		 10527 return NULL;
10528 }
10529
57028622 10530 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
252b5132
RH		 10531 if (e_data == NULL)
10532 {
ed754a13
AM		 10533 error (_("Out of memory reading %" BFD_VMA_FMT "u dynamic entries\n"),
10534 number);
252b5132
RH		 10535 return NULL;
10536 }
10537
57028622 10538 if (fread (e_data, ent_size, (size_t) number, file) != number)
252b5132 10539 {
ed754a13
AM		 10540 error (_("Unable to read in %" BFD_VMA_FMT "u bytes of dynamic data\n"),
10541 number * ent_size);
3102e897 10542 free (e_data);
252b5132
RH		 10543 return NULL;
10544 }
10545
57028622 10546 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
252b5132
RH		 10547 if (i_data == NULL)
10548 {
ed754a13
AM		 10549 error (_("Out of memory allocating space for %" BFD_VMA_FMT "u"
10550 " dynamic entries\n"),
10551 number);
252b5132
RH		 10552 free (e_data);
10553 return NULL;
10554 }
10555
10556 while (number--)
66543521 10557 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 10558
10559 free (e_data);
10560
10561 return i_data;
10562}
10563
6bd1a22c
L		 10564static void
10565print_dynamic_symbol (bfd_vma si, unsigned long hn)
10566{
2cf0635d 10567 Elf_Internal_Sym * psym;
6bd1a22c
L		 10568 int n;
10569
6bd1a22c
L		 10570 n = print_vma (si, DEC_5);
10571 if (n < 5)
0b4362b0 10572 fputs (&" "[n], stdout);
6bd1a22c 10573 printf (" %3lu: ", hn);
e0a31db1
NC		 10574
10575 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10576 {
3102e897
NC		 10577 printf (_("<No info available for dynamic symbol number %lu>\n"),
10578 (unsigned long) si);
e0a31db1
NC		 10579 return;
10580 }
10581
10582 psym = dynamic_symbols + si;
6bd1a22c
L		 10583 print_vma (psym->st_value, LONG_HEX);
10584 putchar (' ');
10585 print_vma (psym->st_size, DEC_5);
10586
f4be36b3
AM		 10587 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10588 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
fd85a6a1
NC		 10589
10590 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
10591 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
10592 else
10593 {
10594 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
10595
10596 printf (" %-7s", get_symbol_visibility (vis));
10597 /* Check to see if any other bits in the st_other field are set.
10598 Note - displaying this information disrupts the layout of the
10599 table being generated, but for the moment this case is very
10600 rare. */
10601 if (psym->st_other ^ vis)
10602 printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
10603 }
10604
6bd1a22c
L		 10605 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10606 if (VALID_DYNAMIC_NAME (psym->st_name))
10607 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10608 else
2b692964 10609 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 10610 putchar ('\n');
10611}
10612
bb4d2ac2
L		 10613static const char *
10614get_symbol_version_string (FILE *file, int is_dynsym,
10615 const char *strtab,
10616 unsigned long int strtab_size,
10617 unsigned int si, Elf_Internal_Sym *psym,
10618 enum versioned_symbol_info *sym_info,
10619 unsigned short *vna_other)
10620{
ab273396
AM		 10621 unsigned char data[2];
10622 unsigned short vers_data;
10623 unsigned long offset;
bb4d2ac2 10624
ab273396
AM		 10625 if (!is_dynsym
10626 || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
10627 return NULL;
bb4d2ac2 10628
ab273396
AM		 10629 offset = offset_from_vma (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10630 sizeof data + si * sizeof (vers_data));
bb4d2ac2 10631
ab273396
AM		 10632 if (get_data (&data, file, offset + si * sizeof (vers_data),
10633 sizeof (data), 1, _("version data")) == NULL)
10634 return NULL;
10635
10636 vers_data = byte_get (data, 2);
bb4d2ac2 10637
ab273396
AM		 10638 if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
10639 return NULL;
bb4d2ac2 10640
ab273396
AM		 10641 /* Usually we'd only see verdef for defined symbols, and verneed for
10642 undefined symbols. However, symbols defined by the linker in
10643 .dynbss for variables copied from a shared library in order to
10644 avoid text relocations are defined yet have verneed. We could
10645 use a heuristic to detect the special case, for example, check
10646 for verneed first on symbols defined in SHT_NOBITS sections, but
10647 it is simpler and more reliable to just look for both verdef and
10648 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
bb4d2ac2 10649
ab273396
AM		 10650 if (psym->st_shndx != SHN_UNDEF
10651 && vers_data != 0x8001
10652 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10653 {
10654 Elf_Internal_Verdef ivd;
10655 Elf_Internal_Verdaux ivda;
10656 Elf_External_Verdaux evda;
10657 unsigned long off;
bb4d2ac2 10658
ab273396
AM		 10659 off = offset_from_vma (file,
10660 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10661 sizeof (Elf_External_Verdef));
10662
10663 do
bb4d2ac2 10664 {
ab273396
AM		 10665 Elf_External_Verdef evd;
10666
10667 if (get_data (&evd, file, off, sizeof (evd), 1,
10668 _("version def")) == NULL)
10669 {
10670 ivd.vd_ndx = 0;
10671 ivd.vd_aux = 0;
10672 ivd.vd_next = 0;
10673 }
10674 else
bb4d2ac2 10675 {
ab273396
AM		 10676 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10677 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10678 ivd.vd_next = BYTE_GET (evd.vd_next);
10679 }
bb4d2ac2 10680
ab273396
AM		 10681 off += ivd.vd_next;
10682 }
10683 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
bb4d2ac2 10684
ab273396
AM		 10685 if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
10686 {
10687 off -= ivd.vd_next;
10688 off += ivd.vd_aux;
bb4d2ac2 10689
ab273396
AM		 10690 if (get_data (&evda, file, off, sizeof (evda), 1,
10691 _("version def aux")) != NULL)
10692 {
10693 ivda.vda_name = BYTE_GET (evda.vda_name);
bb4d2ac2 10694
ab273396
AM		 10695 if (psym->st_name != ivda.vda_name)
10696 {
10697 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10698 ? symbol_hidden : symbol_public);
10699 return (ivda.vda_name < strtab_size
10700 ? strtab + ivda.vda_name : _("<corrupt>"));
10701 }
10702 }
10703 }
10704 }
bb4d2ac2 10705
ab273396
AM		 10706 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10707 {
10708 Elf_External_Verneed evn;
10709 Elf_Internal_Verneed ivn;
10710 Elf_Internal_Vernaux ivna;
bb4d2ac2 10711
ab273396
AM		 10712 offset = offset_from_vma (file,
10713 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10714 sizeof evn);
10715 do
10716 {
10717 unsigned long vna_off;
bb4d2ac2 10718
ab273396
AM		 10719 if (get_data (&evn, file, offset, sizeof (evn), 1,
10720 _("version need")) == NULL)
10721 {
10722 ivna.vna_next = 0;
10723 ivna.vna_other = 0;
10724 ivna.vna_name = 0;
10725 break;
10726 }
bb4d2ac2 10727
ab273396
AM		 10728 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10729 ivn.vn_next = BYTE_GET (evn.vn_next);
bb4d2ac2 10730
ab273396 10731 vna_off = offset + ivn.vn_aux;
bb4d2ac2 10732
ab273396
AM		 10733 do
10734 {
10735 Elf_External_Vernaux evna;
bb4d2ac2 10736
ab273396
AM		 10737 if (get_data (&evna, file, vna_off, sizeof (evna), 1,
10738 _("version need aux (3)")) == NULL)
bb4d2ac2 10739 {
ab273396
AM		 10740 ivna.vna_next = 0;
10741 ivna.vna_other = 0;
10742 ivna.vna_name = 0;
bb4d2ac2 10743 }
bb4d2ac2 10744 else
bb4d2ac2 10745 {
ab273396
AM		 10746 ivna.vna_other = BYTE_GET (evna.vna_other);
10747 ivna.vna_next = BYTE_GET (evna.vna_next);
10748 ivna.vna_name = BYTE_GET (evna.vna_name);
10749 }
bb4d2ac2 10750
ab273396
AM		 10751 vna_off += ivna.vna_next;
10752 }
10753 while (ivna.vna_other != vers_data && ivna.vna_next != 0);
bb4d2ac2 10754
ab273396
AM		 10755 if (ivna.vna_other == vers_data)
10756 break;
bb4d2ac2 10757
ab273396
AM		 10758 offset += ivn.vn_next;
10759 }
10760 while (ivn.vn_next != 0);
bb4d2ac2 10761
ab273396
AM		 10762 if (ivna.vna_other == vers_data)
10763 {
10764 *sym_info = symbol_undefined;
10765 *vna_other = ivna.vna_other;
10766 return (ivna.vna_name < strtab_size
10767 ? strtab + ivna.vna_name : _("<corrupt>"));
bb4d2ac2
L		 10768 }
10769 }
ab273396 10770 return NULL;
bb4d2ac2
L		 10771}
10772
e3c8793a 10773/* Dump the symbol table. */
252b5132 10774static int
2cf0635d 10775process_symbol_table (FILE * file)
252b5132 10776{
2cf0635d 10777 Elf_Internal_Shdr * section;
8b73c356
NC		 10778 bfd_size_type nbuckets = 0;
10779 bfd_size_type nchains = 0;
2cf0635d
NC		 10780 bfd_vma * buckets = NULL;
10781 bfd_vma * chains = NULL;
fdc90cb4 10782 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 10783 bfd_vma * gnubuckets = NULL;
10784 bfd_vma * gnuchains = NULL;
6bd1a22c 10785 bfd_vma gnusymidx = 0;
071436c6 10786 bfd_size_type ngnuchains = 0;
252b5132 10787
2c610e4b 10788 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 10789 return 1;
10790
6bd1a22c
L		 10791 if (dynamic_info[DT_HASH]
10792 && (do_histogram
2c610e4b
L		 10793 || (do_using_dynamic
10794 && !do_dyn_syms
10795 && dynamic_strings != NULL)))
252b5132 10796 {
66543521
AM		 10797 unsigned char nb[8];
10798 unsigned char nc[8];
8b73c356 10799 unsigned int hash_ent_size = 4;
66543521
AM		 10800
10801 if ((elf_header.e_machine == EM_ALPHA
10802 || elf_header.e_machine == EM_S390
10803 || elf_header.e_machine == EM_S390_OLD)
10804 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10805 hash_ent_size = 8;
10806
fb52b2f4
NC		 10807 if (fseek (file,
10808 (archive_file_offset
10809 + offset_from_vma (file, dynamic_info[DT_HASH],
10810 sizeof nb + sizeof nc)),
d93f0186 10811 SEEK_SET))
252b5132 10812 {
591a748a 10813 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10814 goto no_hash;
252b5132
RH		 10815 }
10816
66543521 10817 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 10818 {
10819 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10820 goto no_hash;
252b5132
RH		 10821 }
10822
66543521 10823 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 10824 {
10825 error (_("Failed to read in number of chains\n"));
d3a44ec6 10826 goto no_hash;
252b5132
RH		 10827 }
10828
66543521
AM		 10829 nbuckets = byte_get (nb, hash_ent_size);
10830 nchains = byte_get (nc, hash_ent_size);
252b5132 10831
66543521
AM		 10832 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10833 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 10834
d3a44ec6 10835 no_hash:
252b5132 10836 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 10837 {
10838 if (do_using_dynamic)
10839 return 0;
10840 free (buckets);
10841 free (chains);
10842 buckets = NULL;
10843 chains = NULL;
10844 nbuckets = 0;
10845 nchains = 0;
10846 }
252b5132
RH		 10847 }
10848
6bd1a22c
L		 10849 if (dynamic_info_DT_GNU_HASH
10850 && (do_histogram
2c610e4b
L		 10851 || (do_using_dynamic
10852 && !do_dyn_syms
10853 && dynamic_strings != NULL)))
252b5132 10854 {
6bd1a22c
L		 10855 unsigned char nb[16];
10856 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10857 bfd_vma buckets_vma;
10858
10859 if (fseek (file,
10860 (archive_file_offset
10861 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10862 sizeof nb)),
10863 SEEK_SET))
10864 {
10865 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10866 goto no_gnu_hash;
6bd1a22c 10867 }
252b5132 10868
6bd1a22c
L		 10869 if (fread (nb, 16, 1, file) != 1)
10870 {
10871 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10872 goto no_gnu_hash;
6bd1a22c
L		 10873 }
10874
10875 ngnubuckets = byte_get (nb, 4);
10876 gnusymidx = byte_get (nb + 4, 4);
10877 bitmaskwords = byte_get (nb + 8, 4);
10878 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 10879 if (is_32bit_elf)
6bd1a22c 10880 buckets_vma += bitmaskwords * 4;
f7a99963 10881 else
6bd1a22c 10882 buckets_vma += bitmaskwords * 8;
252b5132 10883
6bd1a22c
L		 10884 if (fseek (file,
10885 (archive_file_offset
10886 + offset_from_vma (file, buckets_vma, 4)),
10887 SEEK_SET))
252b5132 10888 {
6bd1a22c 10889 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10890 goto no_gnu_hash;
6bd1a22c
L		 10891 }
10892
10893 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 10894
6bd1a22c 10895 if (gnubuckets == NULL)
d3a44ec6 10896 goto no_gnu_hash;
6bd1a22c
L		 10897
10898 for (i = 0; i < ngnubuckets; i++)
10899 if (gnubuckets[i] != 0)
10900 {
10901 if (gnubuckets[i] < gnusymidx)
10902 return 0;
10903
10904 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10905 maxchain = gnubuckets[i];
10906 }
10907
10908 if (maxchain == 0xffffffff)
d3a44ec6 10909 goto no_gnu_hash;
6bd1a22c
L		 10910
10911 maxchain -= gnusymidx;
10912
10913 if (fseek (file,
10914 (archive_file_offset
10915 + offset_from_vma (file, buckets_vma
10916 + 4 * (ngnubuckets + maxchain), 4)),
10917 SEEK_SET))
10918 {
10919 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10920 goto no_gnu_hash;
6bd1a22c
L		 10921 }
10922
10923 do
10924 {
10925 if (fread (nb, 4, 1, file) != 1)
252b5132 10926 {
6bd1a22c 10927 error (_("Failed to determine last chain length\n"));
d3a44ec6 10928 goto no_gnu_hash;
6bd1a22c 10929 }
252b5132 10930
6bd1a22c 10931 if (maxchain + 1 == 0)
d3a44ec6 10932 goto no_gnu_hash;
252b5132 10933
6bd1a22c
L		 10934 ++maxchain;
10935 }
10936 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 10937
6bd1a22c
L		 10938 if (fseek (file,
10939 (archive_file_offset
10940 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10941 SEEK_SET))
10942 {
10943 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10944 goto no_gnu_hash;
6bd1a22c
L		 10945 }
10946
10947 gnuchains = get_dynamic_data (file, maxchain, 4);
071436c6 10948 ngnuchains = maxchain;
6bd1a22c 10949
d3a44ec6 10950 no_gnu_hash:
6bd1a22c 10951 if (gnuchains == NULL)
d3a44ec6
JJ		 10952 {
10953 free (gnubuckets);
d3a44ec6
JJ		 10954 gnubuckets = NULL;
10955 ngnubuckets = 0;
f64fddf1
NC		 10956 if (do_using_dynamic)
10957 return 0;
d3a44ec6 10958 }
6bd1a22c
L		 10959 }
10960
10961 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10962 && do_syms
10963 && do_using_dynamic
3102e897
NC		 10964 && dynamic_strings != NULL
10965 && dynamic_symbols != NULL)
6bd1a22c
L		 10966 {
10967 unsigned long hn;
10968
10969 if (dynamic_info[DT_HASH])
10970 {
10971 bfd_vma si;
10972
10973 printf (_("\nSymbol table for image:\n"));
10974 if (is_32bit_elf)
10975 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10976 else
10977 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10978
10979 for (hn = 0; hn < nbuckets; hn++)
10980 {
10981 if (! buckets[hn])
10982 continue;
10983
10984 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10985 print_dynamic_symbol (si, hn);
252b5132
RH		 10986 }
10987 }
6bd1a22c
L		 10988
10989 if (dynamic_info_DT_GNU_HASH)
10990 {
10991 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10992 if (is_32bit_elf)
10993 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10994 else
10995 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10996
10997 for (hn = 0; hn < ngnubuckets; ++hn)
10998 if (gnubuckets[hn] != 0)
10999 {
11000 bfd_vma si = gnubuckets[hn];
11001 bfd_vma off = si - gnusymidx;
11002
11003 do
11004 {
11005 print_dynamic_symbol (si, hn);
11006 si++;
11007 }
071436c6 11008 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
6bd1a22c
L		 11009 }
11010 }
252b5132 11011 }
8b73c356
NC		 11012 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11013 && section_headers != NULL)
252b5132 11014 {
b34976b6 11015 unsigned int i;
252b5132
RH		 11016
11017 for (i = 0, section = section_headers;
11018 i < elf_header.e_shnum;
11019 i++, section++)
11020 {
b34976b6 11021 unsigned int si;
2cf0635d 11022 char * strtab = NULL;
c256ffe7 11023 unsigned long int strtab_size = 0;
2cf0635d
NC		 11024 Elf_Internal_Sym * symtab;
11025 Elf_Internal_Sym * psym;
ba5cdace 11026 unsigned long num_syms;
252b5132 11027
2c610e4b
L		 11028 if ((section->sh_type != SHT_SYMTAB
11029 && section->sh_type != SHT_DYNSYM)
11030 || (!do_syms
11031 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 11032 continue;
11033
dd24e3da
NC		 11034 if (section->sh_entsize == 0)
11035 {
11036 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
74e1a04b 11037 printable_section_name (section));
dd24e3da
NC		 11038 continue;
11039 }
11040
252b5132 11041 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
74e1a04b 11042 printable_section_name (section),
252b5132 11043 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 11044
f7a99963 11045 if (is_32bit_elf)
ca47b30c 11046 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 11047 else
ca47b30c 11048 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 11049
ba5cdace 11050 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 11051 if (symtab == NULL)
11052 continue;
11053
11054 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 11055 {
11056 strtab = string_table;
11057 strtab_size = string_table_length;
11058 }
4fbb74a6 11059 else if (section->sh_link < elf_header.e_shnum)
252b5132 11060 {
2cf0635d 11061 Elf_Internal_Shdr * string_sec;
252b5132 11062
4fbb74a6 11063 string_sec = section_headers + section->sh_link;
252b5132 11064
3f5e193b
NC		 11065 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
11066 1, string_sec->sh_size,
11067 _("string table"));
c256ffe7 11068 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 11069 }
11070
ba5cdace 11071 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 11072 {
bb4d2ac2
L		 11073 const char *version_string;
11074 enum versioned_symbol_info sym_info;
11075 unsigned short vna_other;
11076
5e220199 11077 printf ("%6d: ", si);
f7a99963
NC		 11078 print_vma (psym->st_value, LONG_HEX);
11079 putchar (' ');
11080 print_vma (psym->st_size, DEC_5);
d1133906
NC		 11081 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
11082 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
fd85a6a1
NC		 11083 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11084 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
11085 else
11086 {
11087 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11088
11089 printf (" %-7s", get_symbol_visibility (vis));
11090 /* Check to see if any other bits in the st_other field are set.
11091 Note - displaying this information disrupts the layout of the
11092 table being generated, but for the moment this case is very rare. */
11093 if (psym->st_other ^ vis)
11094 printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
11095 }
31104126 11096 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 11097 print_symbol (25, psym->st_name < strtab_size
2b692964 11098 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 11099
bb4d2ac2
L		 11100 version_string
11101 = get_symbol_version_string (file,
11102 section->sh_type == SHT_DYNSYM,
11103 strtab, strtab_size, si,
11104 psym, &sym_info, &vna_other);
11105 if (version_string)
252b5132 11106 {
bb4d2ac2
L		 11107 if (sym_info == symbol_undefined)
11108 printf ("@%s (%d)", version_string, vna_other);
11109 else
11110 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11111 version_string);
252b5132
RH		 11112 }
11113
11114 putchar ('\n');
11115 }
11116
11117 free (symtab);
11118 if (strtab != string_table)
11119 free (strtab);
11120 }
11121 }
11122 else if (do_syms)
11123 printf
11124 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11125
11126 if (do_histogram && buckets != NULL)
11127 {
2cf0635d
NC		 11128 unsigned long * lengths;
11129 unsigned long * counts;
66543521
AM		 11130 unsigned long hn;
11131 bfd_vma si;
11132 unsigned long maxlength = 0;
11133 unsigned long nzero_counts = 0;
11134 unsigned long nsyms = 0;
94d15024 11135 unsigned long chained;
252b5132 11136
66543521
AM		 11137 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11138 (unsigned long) nbuckets);
252b5132 11139
3f5e193b 11140 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 11141 if (lengths == NULL)
11142 {
8b73c356 11143 error (_("Out of memory allocating space for histogram buckets\n"));
252b5132
RH		 11144 return 0;
11145 }
8b73c356
NC		 11146
11147 printf (_(" Length Number %% of total Coverage\n"));
252b5132
RH		 11148 for (hn = 0; hn < nbuckets; ++hn)
11149 {
94d15024
MF		 11150 for (si = buckets[hn], chained = 0;
11151 si > 0 && si < nchains && si < nbuckets && chained <= nchains;
11152 si = chains[si], ++chained)
252b5132 11153 {
b34976b6 11154 ++nsyms;
252b5132 11155 if (maxlength < ++lengths[hn])
b34976b6 11156 ++maxlength;
252b5132 11157 }
94d15024
MF		 11158
11159 /* PR binutils/17531: A corrupt binary could contain broken
11160 histogram data. Do not go into an infinite loop trying
11161 to process it. */
11162 if (chained > nchains)
11163 {
11164 error (_("histogram chain is corrupt\n"));
11165 break;
11166 }
252b5132
RH		 11167 }
11168
3f5e193b 11169 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 11170 if (counts == NULL)
11171 {
b2e951ec 11172 free (lengths);
8b73c356 11173 error (_("Out of memory allocating space for histogram counts\n"));
252b5132
RH		 11174 return 0;
11175 }
11176
11177 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 11178 ++counts[lengths[hn]];
252b5132 11179
103f02d3 11180 if (nbuckets > 0)
252b5132 11181 {
66543521
AM		 11182 unsigned long i;
11183 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 11184 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 11185 for (i = 1; i <= maxlength; ++i)
103f02d3 11186 {
66543521
AM		 11187 nzero_counts += counts[i] * i;
11188 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11189 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 11190 (nzero_counts * 100.0) / nsyms);
11191 }
252b5132
RH		 11192 }
11193
11194 free (counts);
11195 free (lengths);
11196 }
11197
11198 if (buckets != NULL)
11199 {
11200 free (buckets);
11201 free (chains);
11202 }
11203
d3a44ec6 11204 if (do_histogram && gnubuckets != NULL)
fdc90cb4 11205 {
2cf0635d
NC		 11206 unsigned long * lengths;
11207 unsigned long * counts;
fdc90cb4
JJ		 11208 unsigned long hn;
11209 unsigned long maxlength = 0;
11210 unsigned long nzero_counts = 0;
11211 unsigned long nsyms = 0;
fdc90cb4 11212
8b73c356
NC		 11213 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11214 (unsigned long) ngnubuckets);
11215
3f5e193b 11216 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 11217 if (lengths == NULL)
11218 {
8b73c356 11219 error (_("Out of memory allocating space for gnu histogram buckets\n"));
fdc90cb4
JJ		 11220 return 0;
11221 }
11222
fdc90cb4
JJ		 11223 printf (_(" Length Number %% of total Coverage\n"));
11224
11225 for (hn = 0; hn < ngnubuckets; ++hn)
11226 if (gnubuckets[hn] != 0)
11227 {
11228 bfd_vma off, length = 1;
11229
6bd1a22c 11230 for (off = gnubuckets[hn] - gnusymidx;
071436c6
NC		 11231 /* PR 17531 file: 010-77222-0.004. */
11232 off < ngnuchains && (gnuchains[off] & 1) == 0;
11233 ++off)
fdc90cb4
JJ		 11234 ++length;
11235 lengths[hn] = length;
11236 if (length > maxlength)
11237 maxlength = length;
11238 nsyms += length;
11239 }
11240
3f5e193b 11241 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 11242 if (counts == NULL)
11243 {
b2e951ec 11244 free (lengths);
8b73c356 11245 error (_("Out of memory allocating space for gnu histogram counts\n"));
fdc90cb4
JJ		 11246 return 0;
11247 }
11248
11249 for (hn = 0; hn < ngnubuckets; ++hn)
11250 ++counts[lengths[hn]];
11251
11252 if (ngnubuckets > 0)
11253 {
11254 unsigned long j;
11255 printf (" 0 %-10lu (%5.1f%%)\n",
11256 counts[0], (counts[0] * 100.0) / ngnubuckets);
11257 for (j = 1; j <= maxlength; ++j)
11258 {
11259 nzero_counts += counts[j] * j;
11260 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11261 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11262 (nzero_counts * 100.0) / nsyms);
11263 }
11264 }
11265
11266 free (counts);
11267 free (lengths);
11268 free (gnubuckets);
11269 free (gnuchains);
11270 }
11271
252b5132
RH		 11272 return 1;
11273}
11274
11275static int
2cf0635d 11276process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 11277{
b4c96d0d 11278 unsigned int i;
252b5132
RH		 11279
11280 if (dynamic_syminfo == NULL
11281 || !do_dynamic)
11282 /* No syminfo, this is ok. */
11283 return 1;
11284
11285 /* There better should be a dynamic symbol section. */
11286 if (dynamic_symbols == NULL || dynamic_strings == NULL)
11287 return 0;
11288
11289 if (dynamic_addr)
11290 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11291 dynamic_syminfo_offset, dynamic_syminfo_nent);
11292
11293 printf (_(" Num: Name BoundTo Flags\n"));
11294 for (i = 0; i < dynamic_syminfo_nent; ++i)
11295 {
11296 unsigned short int flags = dynamic_syminfo[i].si_flags;
11297
31104126 11298 printf ("%4d: ", i);
4082ef84
NC		 11299 if (i >= num_dynamic_syms)
11300 printf (_("<corrupt index>"));
11301 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
d79b3d50
NC		 11302 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11303 else
2b692964 11304 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 11305 putchar (' ');
252b5132
RH		 11306
11307 switch (dynamic_syminfo[i].si_boundto)
11308 {
11309 case SYMINFO_BT_SELF:
11310 fputs ("SELF ", stdout);
11311 break;
11312 case SYMINFO_BT_PARENT:
11313 fputs ("PARENT ", stdout);
11314 break;
11315 default:
11316 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 11317 && dynamic_syminfo[i].si_boundto < dynamic_nent
11318 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 11319 {
d79b3d50 11320 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 11321 putchar (' ' );
11322 }
252b5132
RH		 11323 else
11324 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11325 break;
11326 }
11327
11328 if (flags & SYMINFO_FLG_DIRECT)
11329 printf (" DIRECT");
11330 if (flags & SYMINFO_FLG_PASSTHRU)
11331 printf (" PASSTHRU");
11332 if (flags & SYMINFO_FLG_COPY)
11333 printf (" COPY");
11334 if (flags & SYMINFO_FLG_LAZYLOAD)
11335 printf (" LAZYLOAD");
11336
11337 puts ("");
11338 }
11339
11340 return 1;
11341}
11342
cf13d699
NC		 11343/* Check to see if the given reloc needs to be handled in a target specific
11344 manner. If so then process the reloc and return TRUE otherwise return
11345 FALSE. */
09c11c86 11346
cf13d699
NC		 11347static bfd_boolean
11348target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11349 unsigned char * start,
11350 Elf_Internal_Sym * symtab)
252b5132 11351{
cf13d699 11352 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 11353
cf13d699 11354 switch (elf_header.e_machine)
252b5132 11355 {
13761a11
NC		 11356 case EM_MSP430:
11357 case EM_MSP430_OLD:
11358 {
11359 static Elf_Internal_Sym * saved_sym = NULL;
11360
11361 switch (reloc_type)
11362 {
11363 case 10: /* R_MSP430_SYM_DIFF */
11364 if (uses_msp430x_relocs ())
11365 break;
11366 case 21: /* R_MSP430X_SYM_DIFF */
11367 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11368 return TRUE;
11369
11370 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11371 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11372 goto handle_sym_diff;
0b4362b0 11373
13761a11
NC		 11374 case 5: /* R_MSP430_16_BYTE */
11375 case 9: /* R_MSP430_8 */
11376 if (uses_msp430x_relocs ())
11377 break;
11378 goto handle_sym_diff;
11379
11380 case 2: /* R_MSP430_ABS16 */
11381 case 15: /* R_MSP430X_ABS16 */
11382 if (! uses_msp430x_relocs ())
11383 break;
11384 goto handle_sym_diff;
0b4362b0 11385
13761a11
NC		 11386 handle_sym_diff:
11387 if (saved_sym != NULL)
11388 {
11389 bfd_vma value;
11390
11391 value = reloc->r_addend
11392 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11393 - saved_sym->st_value);
11394
11395 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11396
11397 saved_sym = NULL;
11398 return TRUE;
11399 }
11400 break;
11401
11402 default:
11403 if (saved_sym != NULL)
071436c6 11404 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13761a11
NC		 11405 break;
11406 }
11407 break;
11408 }
11409
cf13d699
NC		 11410 case EM_MN10300:
11411 case EM_CYGNUS_MN10300:
11412 {
11413 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 11414
cf13d699
NC		 11415 switch (reloc_type)
11416 {
11417 case 34: /* R_MN10300_ALIGN */
11418 return TRUE;
11419 case 33: /* R_MN10300_SYM_DIFF */
11420 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11421 return TRUE;
11422 case 1: /* R_MN10300_32 */
11423 case 2: /* R_MN10300_16 */
11424 if (saved_sym != NULL)
11425 {
11426 bfd_vma value;
252b5132 11427
cf13d699
NC		 11428 value = reloc->r_addend
11429 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11430 - saved_sym->st_value);
252b5132 11431
cf13d699 11432 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 11433
cf13d699
NC		 11434 saved_sym = NULL;
11435 return TRUE;
11436 }
11437 break;
11438 default:
11439 if (saved_sym != NULL)
071436c6 11440 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
cf13d699
NC		 11441 break;
11442 }
11443 break;
11444 }
6ff71e76
NC		 11445
11446 case EM_RL78:
11447 {
11448 static bfd_vma saved_sym1 = 0;
11449 static bfd_vma saved_sym2 = 0;
11450 static bfd_vma value;
11451
11452 switch (reloc_type)
11453 {
11454 case 0x80: /* R_RL78_SYM. */
11455 saved_sym1 = saved_sym2;
11456 saved_sym2 = symtab[get_reloc_symindex (reloc->r_info)].st_value;
11457 saved_sym2 += reloc->r_addend;
11458 return TRUE;
11459
11460 case 0x83: /* R_RL78_OPsub. */
11461 value = saved_sym1 - saved_sym2;
11462 saved_sym2 = saved_sym1 = 0;
11463 return TRUE;
11464 break;
11465
11466 case 0x41: /* R_RL78_ABS32. */
11467 byte_put (start + reloc->r_offset, value, 4);
11468 value = 0;
11469 return TRUE;
11470
11471 case 0x43: /* R_RL78_ABS16. */
11472 byte_put (start + reloc->r_offset, value, 2);
11473 value = 0;
11474 return TRUE;
11475
11476 default:
11477 break;
11478 }
11479 break;
11480 }
252b5132
RH		 11481 }
11482
cf13d699 11483 return FALSE;
252b5132
RH		 11484}
11485
aca88567
NC		 11486/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11487 DWARF debug sections. This is a target specific test. Note - we do not
11488 go through the whole including-target-headers-multiple-times route, (as
11489 we have already done with <elf/h8.h>) because this would become very
11490 messy and even then this function would have to contain target specific
11491 information (the names of the relocs instead of their numeric values).
11492 FIXME: This is not the correct way to solve this problem. The proper way
11493 is to have target specific reloc sizing and typing functions created by
11494 the reloc-macros.h header, in the same way that it already creates the
11495 reloc naming functions. */
11496
11497static bfd_boolean
11498is_32bit_abs_reloc (unsigned int reloc_type)
11499{
d347c9df 11500 /* Please keep this table alpha-sorted for ease of visual lookup. */
aca88567
NC		 11501 switch (elf_header.e_machine)
11502 {
41e92641 11503 case EM_386:
22abe556 11504 case EM_IAMCU:
41e92641 11505 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 11506 case EM_68K:
11507 return reloc_type == 1; /* R_68K_32. */
11508 case EM_860:
11509 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 11510 case EM_960:
11511 return reloc_type == 2; /* R_960_32. */
a06ea964
NC		 11512 case EM_AARCH64:
11513 return reloc_type == 258; /* R_AARCH64_ABS32 */
d347c9df
PS		 11514 case EM_ADAPTEVA_EPIPHANY:
11515 return reloc_type == 3;
aca88567 11516 case EM_ALPHA:
137b6b5f 11517 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 11518 case EM_ARC:
11519 return reloc_type == 1; /* R_ARC_32. */
886a2506
NC		 11520 case EM_ARC_COMPACT:
11521 case EM_ARC_COMPACT2:
11522 return reloc_type == 4; /* R_ARC_32. */
41e92641
NC		 11523 case EM_ARM:
11524 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 11525 case EM_AVR_OLD:
aca88567
NC		 11526 case EM_AVR:
11527 return reloc_type == 1;
11528 case EM_BLACKFIN:
11529 return reloc_type == 0x12; /* R_byte4_data. */
11530 case EM_CRIS:
11531 return reloc_type == 3; /* R_CRIS_32. */
11532 case EM_CR16:
11533 return reloc_type == 3; /* R_CR16_NUM32. */
11534 case EM_CRX:
11535 return reloc_type == 15; /* R_CRX_NUM32. */
11536 case EM_CYGNUS_FRV:
11537 return reloc_type == 1;
41e92641
NC		 11538 case EM_CYGNUS_D10V:
11539 case EM_D10V:
11540 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 11541 case EM_CYGNUS_D30V:
11542 case EM_D30V:
11543 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 11544 case EM_DLX:
11545 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 11546 case EM_CYGNUS_FR30:
11547 case EM_FR30:
11548 return reloc_type == 3; /* R_FR30_32. */
3f8107ab
AM		 11549 case EM_FT32:
11550 return reloc_type == 1; /* R_FT32_32. */
aca88567
NC		 11551 case EM_H8S:
11552 case EM_H8_300:
11553 case EM_H8_300H:
11554 return reloc_type == 1; /* R_H8_DIR32. */
3730236a 11555 case EM_IA_64:
d1c4b12b
NC		 11556 return reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
11557 || reloc_type == 0x25; /* R_IA64_DIR32LSB. */
aca88567
NC		 11558 case EM_IP2K_OLD:
11559 case EM_IP2K:
11560 return reloc_type == 2; /* R_IP2K_32. */
11561 case EM_IQ2000:
11562 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 11563 case EM_LATTICEMICO32:
11564 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 11565 case EM_M32C_OLD:
aca88567
NC		 11566 case EM_M32C:
11567 return reloc_type == 3; /* R_M32C_32. */
11568 case EM_M32R:
11569 return reloc_type == 34; /* R_M32R_32_RELA. */
adec12c1
AM		 11570 case EM_68HC11:
11571 case EM_68HC12:
11572 return reloc_type == 6; /* R_M68HC11_32. */
aca88567
NC		 11573 case EM_MCORE:
11574 return reloc_type == 1; /* R_MCORE_ADDR32. */
11575 case EM_CYGNUS_MEP:
11576 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 11577 case EM_METAG:
11578 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 11579 case EM_MICROBLAZE:
11580 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 11581 case EM_MIPS:
11582 return reloc_type == 2; /* R_MIPS_32. */
11583 case EM_MMIX:
11584 return reloc_type == 4; /* R_MMIX_32. */
11585 case EM_CYGNUS_MN10200:
11586 case EM_MN10200:
11587 return reloc_type == 1; /* R_MN10200_32. */
11588 case EM_CYGNUS_MN10300:
11589 case EM_MN10300:
11590 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 11591 case EM_MOXIE:
11592 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 11593 case EM_MSP430_OLD:
11594 case EM_MSP430:
13761a11 11595 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
aca88567
NC		 11596 case EM_MT:
11597 return reloc_type == 2; /* R_MT_32. */
35c08157
KLC		 11598 case EM_NDS32:
11599 return reloc_type == 20; /* R_NDS32_RELA. */
3e0873ac 11600 case EM_ALTERA_NIOS2:
36591ba1 11601 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
3e0873ac
NC		 11602 case EM_NIOS32:
11603 return reloc_type == 1; /* R_NIOS_32. */
73589c9d
CS		 11604 case EM_OR1K:
11605 return reloc_type == 1; /* R_OR1K_32. */
aca88567 11606 case EM_PARISC:
5fda8eca
NC		 11607 return (reloc_type == 1 /* R_PARISC_DIR32. */
11608 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 11609 case EM_PJ:
11610 case EM_PJ_OLD:
11611 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
11612 case EM_PPC64:
11613 return reloc_type == 1; /* R_PPC64_ADDR32. */
11614 case EM_PPC:
11615 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 11616 case EM_RL78:
11617 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 11618 case EM_RX:
11619 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 11620 case EM_S370:
11621 return reloc_type == 1; /* R_I370_ADDR31. */
11622 case EM_S390_OLD:
11623 case EM_S390:
11624 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 11625 case EM_SCORE:
11626 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 11627 case EM_SH:
11628 return reloc_type == 1; /* R_SH_DIR32. */
11629 case EM_SPARC32PLUS:
11630 case EM_SPARCV9:
11631 case EM_SPARC:
11632 return reloc_type == 3 /* R_SPARC_32. */
11633 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 11634 case EM_SPU:
11635 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 11636 case EM_TI_C6000:
11637 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 11638 case EM_TILEGX:
11639 return reloc_type == 2; /* R_TILEGX_32. */
11640 case EM_TILEPRO:
11641 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 11642 case EM_CYGNUS_V850:
11643 case EM_V850:
11644 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 11645 case EM_V800:
11646 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 11647 case EM_VAX:
11648 return reloc_type == 1; /* R_VAX_32. */
619ed720
EB		 11649 case EM_VISIUM:
11650 return reloc_type == 3; /* R_VISIUM_32. */
aca88567 11651 case EM_X86_64:
8a9036a4 11652 case EM_L1OM:
7a9068fe 11653 case EM_K1OM:
aca88567 11654 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 11655 case EM_XC16X:
11656 case EM_C166:
11657 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 11658 case EM_XGATE:
11659 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 11660 case EM_XSTORMY16:
11661 return reloc_type == 1; /* R_XSTROMY16_32. */
11662 case EM_XTENSA_OLD:
11663 case EM_XTENSA:
11664 return reloc_type == 1; /* R_XTENSA_32. */
aca88567 11665 default:
bee0ee85
NC		 11666 {
11667 static unsigned int prev_warn = 0;
11668
11669 /* Avoid repeating the same warning multiple times. */
11670 if (prev_warn != elf_header.e_machine)
11671 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11672 elf_header.e_machine);
11673 prev_warn = elf_header.e_machine;
11674 return FALSE;
11675 }
aca88567
NC		 11676 }
11677}
11678
11679/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11680 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11681
11682static bfd_boolean
11683is_32bit_pcrel_reloc (unsigned int reloc_type)
11684{
11685 switch (elf_header.e_machine)
d347c9df 11686 /* Please keep this table alpha-sorted for ease of visual lookup. */
aca88567 11687 {
41e92641 11688 case EM_386:
22abe556 11689 case EM_IAMCU:
3e0873ac 11690 return reloc_type == 2; /* R_386_PC32. */
aca88567 11691 case EM_68K:
3e0873ac 11692 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 11693 case EM_AARCH64:
11694 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 11695 case EM_ADAPTEVA_EPIPHANY:
11696 return reloc_type == 6;
aca88567
NC		 11697 case EM_ALPHA:
11698 return reloc_type == 10; /* R_ALPHA_SREL32. */
726c18e1
CZ		 11699 case EM_ARC_COMPACT:
11700 case EM_ARC_COMPACT2:
11701 return reloc_type == 49; /* R_ARC_32_PCREL. */
41e92641 11702 case EM_ARM:
3e0873ac 11703 return reloc_type == 3; /* R_ARM_REL32 */
d347c9df
PS		 11704 case EM_AVR_OLD:
11705 case EM_AVR:
11706 return reloc_type == 36; /* R_AVR_32_PCREL. */
137b6b5f
AM		 11707 case EM_MICROBLAZE:
11708 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
73589c9d
CS		 11709 case EM_OR1K:
11710 return reloc_type == 9; /* R_OR1K_32_PCREL. */
aca88567 11711 case EM_PARISC:
85acf597 11712 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 11713 case EM_PPC:
11714 return reloc_type == 26; /* R_PPC_REL32. */
11715 case EM_PPC64:
3e0873ac 11716 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 11717 case EM_S390_OLD:
11718 case EM_S390:
3e0873ac 11719 return reloc_type == 5; /* R_390_PC32. */
aca88567 11720 case EM_SH:
3e0873ac 11721 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 11722 case EM_SPARC32PLUS:
11723 case EM_SPARCV9:
11724 case EM_SPARC:
3e0873ac 11725 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 11726 case EM_SPU:
11727 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 11728 case EM_TILEGX:
11729 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
11730 case EM_TILEPRO:
11731 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
619ed720
EB		 11732 case EM_VISIUM:
11733 return reloc_type == 6; /* R_VISIUM_32_PCREL */
aca88567 11734 case EM_X86_64:
8a9036a4 11735 case EM_L1OM:
7a9068fe 11736 case EM_K1OM:
3e0873ac 11737 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 11738 case EM_XTENSA_OLD:
11739 case EM_XTENSA:
11740 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 11741 default:
11742 /* Do not abort or issue an error message here. Not all targets use
11743 pc-relative 32-bit relocs in their DWARF debug information and we
11744 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 11745 more helpful warning message will be generated by apply_relocations
11746 anyway, so just return. */
aca88567
NC		 11747 return FALSE;
11748 }
11749}
11750
11751/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11752 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11753
11754static bfd_boolean
11755is_64bit_abs_reloc (unsigned int reloc_type)
11756{
11757 switch (elf_header.e_machine)
11758 {
a06ea964
NC		 11759 case EM_AARCH64:
11760 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 11761 case EM_ALPHA:
11762 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 11763 case EM_IA_64:
11764 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 11765 case EM_PARISC:
11766 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 11767 case EM_PPC64:
11768 return reloc_type == 38; /* R_PPC64_ADDR64. */
11769 case EM_SPARC32PLUS:
11770 case EM_SPARCV9:
11771 case EM_SPARC:
11772 return reloc_type == 54; /* R_SPARC_UA64. */
11773 case EM_X86_64:
8a9036a4 11774 case EM_L1OM:
7a9068fe 11775 case EM_K1OM:
aca88567 11776 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 11777 case EM_S390_OLD:
11778 case EM_S390:
aa137e4d
NC		 11779 return reloc_type == 22; /* R_S390_64. */
11780 case EM_TILEGX:
11781 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 11782 case EM_MIPS:
aa137e4d 11783 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 11784 default:
11785 return FALSE;
11786 }
11787}
11788
85acf597
RH		 11789/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11790 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11791
11792static bfd_boolean
11793is_64bit_pcrel_reloc (unsigned int reloc_type)
11794{
11795 switch (elf_header.e_machine)
11796 {
a06ea964
NC		 11797 case EM_AARCH64:
11798 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 11799 case EM_ALPHA:
aa137e4d 11800 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 11801 case EM_IA_64:
aa137e4d 11802 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 11803 case EM_PARISC:
aa137e4d 11804 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 11805 case EM_PPC64:
aa137e4d 11806 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 11807 case EM_SPARC32PLUS:
11808 case EM_SPARCV9:
11809 case EM_SPARC:
aa137e4d 11810 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 11811 case EM_X86_64:
8a9036a4 11812 case EM_L1OM:
7a9068fe 11813 case EM_K1OM:
aa137e4d 11814 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 11815 case EM_S390_OLD:
11816 case EM_S390:
aa137e4d
NC		 11817 return reloc_type == 23; /* R_S390_PC64. */
11818 case EM_TILEGX:
11819 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 11820 default:
11821 return FALSE;
11822 }
11823}
11824
4dc3c23d
AM		 11825/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11826 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11827
11828static bfd_boolean
11829is_24bit_abs_reloc (unsigned int reloc_type)
11830{
11831 switch (elf_header.e_machine)
11832 {
11833 case EM_CYGNUS_MN10200:
11834 case EM_MN10200:
11835 return reloc_type == 4; /* R_MN10200_24. */
11836 default:
11837 return FALSE;
11838 }
11839}
11840
aca88567
NC		 11841/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11842 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11843
11844static bfd_boolean
11845is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a 11846{
d347c9df 11847 /* Please keep this table alpha-sorted for ease of visual lookup. */
4b78141a
NC		 11848 switch (elf_header.e_machine)
11849 {
886a2506
NC		 11850 case EM_ARC:
11851 case EM_ARC_COMPACT:
11852 case EM_ARC_COMPACT2:
11853 return reloc_type == 2; /* R_ARC_16. */
d347c9df
PS		 11854 case EM_ADAPTEVA_EPIPHANY:
11855 return reloc_type == 5;
aca88567
NC		 11856 case EM_AVR_OLD:
11857 case EM_AVR:
11858 return reloc_type == 4; /* R_AVR_16. */
41e92641
NC		 11859 case EM_CYGNUS_D10V:
11860 case EM_D10V:
11861 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 11862 case EM_H8S:
11863 case EM_H8_300:
11864 case EM_H8_300H:
aca88567
NC		 11865 return reloc_type == R_H8_DIR16;
11866 case EM_IP2K_OLD:
11867 case EM_IP2K:
11868 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 11869 case EM_M32C_OLD:
f4236fe4
DD		 11870 case EM_M32C:
11871 return reloc_type == 1; /* R_M32C_16 */
d347c9df
PS		 11872 case EM_CYGNUS_MN10200:
11873 case EM_MN10200:
11874 return reloc_type == 2; /* R_MN10200_16. */
11875 case EM_CYGNUS_MN10300:
11876 case EM_MN10300:
11877 return reloc_type == 2; /* R_MN10300_16. */
aca88567 11878 case EM_MSP430:
13761a11
NC		 11879 if (uses_msp430x_relocs ())
11880 return reloc_type == 2; /* R_MSP430_ABS16. */
78c8d46c 11881 case EM_MSP430_OLD:
aca88567 11882 return reloc_type == 5; /* R_MSP430_16_BYTE. */
35c08157
KLC		 11883 case EM_NDS32:
11884 return reloc_type == 19; /* R_NDS32_RELA. */
3e0873ac 11885 case EM_ALTERA_NIOS2:
36591ba1 11886 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
3e0873ac
NC		 11887 case EM_NIOS32:
11888 return reloc_type == 9; /* R_NIOS_16. */
73589c9d
CS		 11889 case EM_OR1K:
11890 return reloc_type == 2; /* R_OR1K_16. */
40b36596
JM		 11891 case EM_TI_C6000:
11892 return reloc_type == 2; /* R_C6000_ABS16. */
d347c9df
PS		 11893 case EM_VISIUM:
11894 return reloc_type == 2; /* R_VISIUM_16. */
c29aca4a
NC		 11895 case EM_XC16X:
11896 case EM_C166:
11897 return reloc_type == 2; /* R_XC16C_ABS_16. */
f6c1a2d5
NC		 11898 case EM_XGATE:
11899 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 11900 default:
aca88567 11901 return FALSE;
4b78141a
NC		 11902 }
11903}
11904
2a7b2e88
JK		 11905/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11906 relocation entries (possibly formerly used for SHT_GROUP sections). */
11907
11908static bfd_boolean
11909is_none_reloc (unsigned int reloc_type)
11910{
11911 switch (elf_header.e_machine)
11912 {
cb8f3167 11913 case EM_386: /* R_386_NONE. */
d347c9df 11914 case EM_68K: /* R_68K_NONE. */
cfb8c092 11915 case EM_ADAPTEVA_EPIPHANY:
d347c9df
PS		 11916 case EM_ALPHA: /* R_ALPHA_NONE. */
11917 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
886a2506 11918 case EM_ARC: /* R_ARC_NONE. */
886a2506 11919 case EM_ARC_COMPACT2: /* R_ARC_NONE. */
d347c9df 11920 case EM_ARC_COMPACT: /* R_ARC_NONE. */
cb8f3167 11921 case EM_ARM: /* R_ARM_NONE. */
d347c9df 11922 case EM_C166: /* R_XC16X_NONE. */
cb8f3167 11923 case EM_CRIS: /* R_CRIS_NONE. */
d347c9df
PS		 11924 case EM_FT32: /* R_FT32_NONE. */
11925 case EM_IA_64: /* R_IA64_NONE. */
7a9068fe 11926 case EM_K1OM: /* R_X86_64_NONE. */
d347c9df
PS		 11927 case EM_L1OM: /* R_X86_64_NONE. */
11928 case EM_M32R: /* R_M32R_NONE. */
11929 case EM_MIPS: /* R_MIPS_NONE. */
cb8f3167 11930 case EM_MN10300: /* R_MN10300_NONE. */
5506d11a 11931 case EM_MOXIE: /* R_MOXIE_NONE. */
d347c9df
PS		 11932 case EM_NIOS32: /* R_NIOS_NONE. */
11933 case EM_OR1K: /* R_OR1K_NONE. */
11934 case EM_PARISC: /* R_PARISC_NONE. */
11935 case EM_PPC64: /* R_PPC64_NONE. */
11936 case EM_PPC: /* R_PPC_NONE. */
11937 case EM_S390: /* R_390_NONE. */
11938 case EM_S390_OLD:
11939 case EM_SH: /* R_SH_NONE. */
11940 case EM_SPARC32PLUS:
11941 case EM_SPARC: /* R_SPARC_NONE. */
11942 case EM_SPARCV9:
aa137e4d
NC		 11943 case EM_TILEGX: /* R_TILEGX_NONE. */
11944 case EM_TILEPRO: /* R_TILEPRO_NONE. */
d347c9df
PS		 11945 case EM_TI_C6000:/* R_C6000_NONE. */
11946 case EM_X86_64: /* R_X86_64_NONE. */
c29aca4a 11947 case EM_XC16X:
cb8f3167 11948 return reloc_type == 0;
d347c9df 11949
a06ea964
NC		 11950 case EM_AARCH64:
11951 return reloc_type == 0 || reloc_type == 256;
d347c9df
PS		 11952 case EM_AVR_OLD:
11953 case EM_AVR:
11954 return (reloc_type == 0 /* R_AVR_NONE. */
11955 || reloc_type == 30 /* R_AVR_DIFF8. */
11956 || reloc_type == 31 /* R_AVR_DIFF16. */
11957 || reloc_type == 32 /* R_AVR_DIFF32. */);
11958 case EM_METAG:
11959 return reloc_type == 3; /* R_METAG_NONE. */
35c08157
KLC		 11960 case EM_NDS32:
11961 return (reloc_type == 0 /* R_XTENSA_NONE. */
11962 || reloc_type == 204 /* R_NDS32_DIFF8. */
11963 || reloc_type == 205 /* R_NDS32_DIFF16. */
11964 || reloc_type == 206 /* R_NDS32_DIFF32. */
11965 || reloc_type == 207 /* R_NDS32_ULEB128. */);
58332dda
JK		 11966 case EM_XTENSA_OLD:
11967 case EM_XTENSA:
4dc3c23d
AM		 11968 return (reloc_type == 0 /* R_XTENSA_NONE. */
11969 || reloc_type == 17 /* R_XTENSA_DIFF8. */
11970 || reloc_type == 18 /* R_XTENSA_DIFF16. */
11971 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
2a7b2e88
JK		 11972 }
11973 return FALSE;
11974}
11975
d1c4b12b
NC		 11976/* Returns TRUE if there is a relocation against
11977 section NAME at OFFSET bytes. */
11978
11979bfd_boolean
11980reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
11981{
11982 Elf_Internal_Rela * relocs;
11983 Elf_Internal_Rela * rp;
11984
11985 if (dsec == NULL || dsec->reloc_info == NULL)
11986 return FALSE;
11987
11988 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
11989
11990 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
11991 if (rp->r_offset == offset)
11992 return TRUE;
11993
11994 return FALSE;
11995}
11996
cf13d699
NC		 11997/* Apply relocations to a section.
11998 Note: So far support has been added only for those relocations
11999 which can be found in debug sections.
d1c4b12b
NC		 12000 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
12001 loaded relocs. It is then the caller's responsibility to free them.
cf13d699 12002 FIXME: Add support for more relocations ? */
1b315056 12003
cf13d699 12004static void
d1c4b12b
NC		 12005apply_relocations (void * file,
12006 const Elf_Internal_Shdr * section,
12007 unsigned char * start,
12008 bfd_size_type size,
12009 void ** relocs_return,
12010 unsigned long * num_relocs_return)
1b315056 12011{
cf13d699 12012 Elf_Internal_Shdr * relsec;
0d2a7a93 12013 unsigned char * end = start + size;
cb8f3167 12014
d1c4b12b
NC		 12015 if (relocs_return != NULL)
12016 {
12017 * (Elf_Internal_Rela **) relocs_return = NULL;
12018 * num_relocs_return = 0;
12019 }
12020
cf13d699
NC		 12021 if (elf_header.e_type != ET_REL)
12022 return;
1b315056 12023
cf13d699 12024 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 12025 for (relsec = section_headers;
12026 relsec < section_headers + elf_header.e_shnum;
12027 ++relsec)
252b5132 12028 {
41e92641
NC		 12029 bfd_boolean is_rela;
12030 unsigned long num_relocs;
2cf0635d
NC		 12031 Elf_Internal_Rela * relocs;
12032 Elf_Internal_Rela * rp;
12033 Elf_Internal_Shdr * symsec;
12034 Elf_Internal_Sym * symtab;
ba5cdace 12035 unsigned long num_syms;
2cf0635d 12036 Elf_Internal_Sym * sym;
252b5132 12037
41e92641 12038 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 12039 || relsec->sh_info >= elf_header.e_shnum
12040 || section_headers + relsec->sh_info != section
c256ffe7 12041 || relsec->sh_size == 0
4fbb74a6 12042 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 12043 continue;
428409d5 12044
41e92641
NC		 12045 is_rela = relsec->sh_type == SHT_RELA;
12046
12047 if (is_rela)
12048 {
3f5e193b
NC		 12049 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
12050 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 12051 return;
12052 }
12053 else
12054 {
3f5e193b
NC		 12055 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
12056 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 12057 return;
12058 }
12059
12060 /* SH uses RELA but uses in place value instead of the addend field. */
12061 if (elf_header.e_machine == EM_SH)
12062 is_rela = FALSE;
428409d5 12063
4fbb74a6 12064 symsec = section_headers + relsec->sh_link;
ba5cdace 12065 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 12066
41e92641 12067 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 12068 {
41e92641
NC		 12069 bfd_vma addend;
12070 unsigned int reloc_type;
12071 unsigned int reloc_size;
91d6fa6a 12072 unsigned char * rloc;
ba5cdace 12073 unsigned long sym_index;
4b78141a 12074
aca88567 12075 reloc_type = get_reloc_type (rp->r_info);
41e92641 12076
98fb390a 12077 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 12078 continue;
98fb390a
NC		 12079 else if (is_none_reloc (reloc_type))
12080 continue;
12081 else if (is_32bit_abs_reloc (reloc_type)
12082 || is_32bit_pcrel_reloc (reloc_type))
aca88567 12083 reloc_size = 4;
85acf597
RH		 12084 else if (is_64bit_abs_reloc (reloc_type)
12085 || is_64bit_pcrel_reloc (reloc_type))
aca88567 12086 reloc_size = 8;
4dc3c23d
AM		 12087 else if (is_24bit_abs_reloc (reloc_type))
12088 reloc_size = 3;
aca88567
NC		 12089 else if (is_16bit_abs_reloc (reloc_type))
12090 reloc_size = 2;
12091 else
4b78141a 12092 {
bee0ee85
NC		 12093 static unsigned int prev_reloc = 0;
12094 if (reloc_type != prev_reloc)
12095 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12096 reloc_type, printable_section_name (section));
12097 prev_reloc = reloc_type;
4b78141a
NC		 12098 continue;
12099 }
103f02d3 12100
91d6fa6a 12101 rloc = start + rp->r_offset;
c8da6823 12102 if ((rloc + reloc_size) > end || (rloc < start))
700dd8b7
L		 12103 {
12104 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12105 (unsigned long) rp->r_offset,
74e1a04b 12106 printable_section_name (section));
700dd8b7
L		 12107 continue;
12108 }
103f02d3 12109
ba5cdace
NC		 12110 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
12111 if (sym_index >= num_syms)
12112 {
12113 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
74e1a04b 12114 sym_index, printable_section_name (section));
ba5cdace
NC		 12115 continue;
12116 }
12117 sym = symtab + sym_index;
41e92641
NC		 12118
12119 /* If the reloc has a symbol associated with it,
55f25fc3
L		 12120 make sure that it is of an appropriate type.
12121
12122 Relocations against symbols without type can happen.
12123 Gcc -feliminate-dwarf2-dups may generate symbols
12124 without type for debug info.
12125
12126 Icc generates relocations against function symbols
12127 instead of local labels.
12128
12129 Relocations against object symbols can happen, eg when
12130 referencing a global array. For an example of this see
12131 the _clz.o binary in libgcc.a. */
aca88567 12132 if (sym != symtab
b8871f35 12133 && ELF_ST_TYPE (sym->st_info) != STT_COMMON
55f25fc3 12134 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 12135 {
41e92641 12136 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 12137 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 12138 (long int)(rp - relocs),
74e1a04b 12139 printable_section_name (relsec));
aca88567 12140 continue;
5b18a4bc 12141 }
252b5132 12142
4dc3c23d
AM		 12143 addend = 0;
12144 if (is_rela)
12145 addend += rp->r_addend;
c47320c3
AM		 12146 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12147 partial_inplace. */
4dc3c23d
AM		 12148 if (!is_rela
12149 || (elf_header.e_machine == EM_XTENSA
12150 && reloc_type == 1)
12151 || ((elf_header.e_machine == EM_PJ
12152 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 12153 && reloc_type == 1)
12154 || ((elf_header.e_machine == EM_D30V
12155 || elf_header.e_machine == EM_CYGNUS_D30V)
12156 && reloc_type == 12))
91d6fa6a 12157 addend += byte_get (rloc, reloc_size);
cb8f3167 12158
85acf597
RH		 12159 if (is_32bit_pcrel_reloc (reloc_type)
12160 || is_64bit_pcrel_reloc (reloc_type))
12161 {
12162 /* On HPPA, all pc-relative relocations are biased by 8. */
12163 if (elf_header.e_machine == EM_PARISC)
12164 addend -= 8;
91d6fa6a 12165 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 12166 reloc_size);
12167 }
41e92641 12168 else
91d6fa6a 12169 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 12170 }
252b5132 12171
5b18a4bc 12172 free (symtab);
d1c4b12b
NC		 12173
12174 if (relocs_return)
12175 {
12176 * (Elf_Internal_Rela **) relocs_return = relocs;
12177 * num_relocs_return = num_relocs;
12178 }
12179 else
12180 free (relocs);
12181
5b18a4bc
NC		 12182 break;
12183 }
5b18a4bc 12184}
103f02d3 12185
cf13d699
NC		 12186#ifdef SUPPORT_DISASSEMBLY
12187static int
12188disassemble_section (Elf_Internal_Shdr * section, FILE * file)
12189{
74e1a04b 12190 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
cf13d699 12191
74e1a04b 12192 /* FIXME: XXX -- to be done --- XXX */
cf13d699
NC		 12193
12194 return 1;
12195}
12196#endif
12197
12198/* Reads in the contents of SECTION from FILE, returning a pointer
12199 to a malloc'ed buffer or NULL if something went wrong. */
12200
12201static char *
12202get_section_contents (Elf_Internal_Shdr * section, FILE * file)
12203{
12204 bfd_size_type num_bytes;
12205
12206 num_bytes = section->sh_size;
12207
12208 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
12209 {
12210 printf (_("\nSection '%s' has no data to dump.\n"),
74e1a04b 12211 printable_section_name (section));
cf13d699
NC		 12212 return NULL;
12213 }
12214
3f5e193b
NC		 12215 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
12216 _("section contents"));
cf13d699
NC		 12217}
12218
0e602686
NC		 12219/* Uncompresses a section that was compressed using zlib, in place. */
12220
12221static bfd_boolean
12222uncompress_section_contents (unsigned char **buffer,
12223 dwarf_size_type uncompressed_size,
12224 dwarf_size_type *size)
12225{
12226 dwarf_size_type compressed_size = *size;
12227 unsigned char * compressed_buffer = *buffer;
12228 unsigned char * uncompressed_buffer;
12229 z_stream strm;
12230 int rc;
12231
12232 /* It is possible the section consists of several compressed
12233 buffers concatenated together, so we uncompress in a loop. */
12234 /* PR 18313: The state field in the z_stream structure is supposed
12235 to be invisible to the user (ie us), but some compilers will
12236 still complain about it being used without initialisation. So
12237 we first zero the entire z_stream structure and then set the fields
12238 that we need. */
12239 memset (& strm, 0, sizeof strm);
12240 strm.avail_in = compressed_size;
12241 strm.next_in = (Bytef *) compressed_buffer;
12242 strm.avail_out = uncompressed_size;
12243 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
12244
12245 rc = inflateInit (& strm);
12246 while (strm.avail_in > 0)
12247 {
12248 if (rc != Z_OK)
12249 goto fail;
12250 strm.next_out = ((Bytef *) uncompressed_buffer
12251 + (uncompressed_size - strm.avail_out));
12252 rc = inflate (&strm, Z_FINISH);
12253 if (rc != Z_STREAM_END)
12254 goto fail;
12255 rc = inflateReset (& strm);
12256 }
12257 rc = inflateEnd (& strm);
12258 if (rc != Z_OK
12259 || strm.avail_out != 0)
12260 goto fail;
12261
12262 *buffer = uncompressed_buffer;
12263 *size = uncompressed_size;
12264 return TRUE;
12265
12266 fail:
12267 free (uncompressed_buffer);
12268 /* Indicate decompression failure. */
12269 *buffer = NULL;
12270 return FALSE;
12271}
dd24e3da 12272
cf13d699
NC		 12273static void
12274dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12275{
0e602686
NC		 12276 Elf_Internal_Shdr * relsec;
12277 bfd_size_type num_bytes;
fd8008d8
L		 12278 unsigned char * data;
12279 unsigned char * end;
12280 unsigned char * real_start;
12281 unsigned char * start;
0e602686 12282 bfd_boolean some_strings_shown;
cf13d699 12283
fd8008d8
L		 12284 real_start = start = (unsigned char *) get_section_contents (section,
12285 file);
cf13d699
NC		 12286 if (start == NULL)
12287 return;
0e602686 12288 num_bytes = section->sh_size;
cf13d699 12289
74e1a04b 12290 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
cf13d699 12291
0e602686
NC		 12292 if (decompress_dumps)
12293 {
12294 dwarf_size_type new_size = num_bytes;
12295 dwarf_size_type uncompressed_size = 0;
12296
12297 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12298 {
12299 Elf_Internal_Chdr chdr;
12300 unsigned int compression_header_size
12301 = get_compression_header (& chdr, (unsigned char *) start);
12302
813dabb9 12303 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
0e602686 12304 {
813dabb9
L		 12305 warn (_("section '%s' has unsupported compress type: %d\n"),
12306 printable_section_name (section), chdr.ch_type);
12307 return;
12308 }
12309 else if (chdr.ch_addralign != section->sh_addralign)
12310 {
12311 warn (_("compressed section '%s' is corrupted\n"),
12312 printable_section_name (section));
12313 return;
0e602686 12314 }
813dabb9
L		 12315 uncompressed_size = chdr.ch_size;
12316 start += compression_header_size;
12317 new_size -= compression_header_size;
0e602686
NC		 12318 }
12319 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12320 {
12321 /* Read the zlib header. In this case, it should be "ZLIB"
12322 followed by the uncompressed section size, 8 bytes in
12323 big-endian order. */
12324 uncompressed_size = start[4]; uncompressed_size <<= 8;
12325 uncompressed_size += start[5]; uncompressed_size <<= 8;
12326 uncompressed_size += start[6]; uncompressed_size <<= 8;
12327 uncompressed_size += start[7]; uncompressed_size <<= 8;
12328 uncompressed_size += start[8]; uncompressed_size <<= 8;
12329 uncompressed_size += start[9]; uncompressed_size <<= 8;
12330 uncompressed_size += start[10]; uncompressed_size <<= 8;
12331 uncompressed_size += start[11];
12332 start += 12;
12333 new_size -= 12;
12334 }
12335
12336 if (uncompressed_size
fd8008d8 12337 && uncompress_section_contents (& start,
0e602686
NC		 12338 uncompressed_size, & new_size))
12339 num_bytes = new_size;
12340 }
fd8008d8 12341
cf13d699
NC		 12342 /* If the section being dumped has relocations against it the user might
12343 be expecting these relocations to have been applied. Check for this
12344 case and issue a warning message in order to avoid confusion.
12345 FIXME: Maybe we ought to have an option that dumps a section with
12346 relocs applied ? */
12347 for (relsec = section_headers;
12348 relsec < section_headers + elf_header.e_shnum;
12349 ++relsec)
12350 {
12351 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12352 || relsec->sh_info >= elf_header.e_shnum
12353 || section_headers + relsec->sh_info != section
12354 || relsec->sh_size == 0
12355 || relsec->sh_link >= elf_header.e_shnum)
12356 continue;
12357
12358 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12359 break;
12360 }
12361
cf13d699
NC		 12362 data = start;
12363 end = start + num_bytes;
12364 some_strings_shown = FALSE;
12365
12366 while (data < end)
12367 {
12368 while (!ISPRINT (* data))
12369 if (++ data >= end)
12370 break;
12371
12372 if (data < end)
12373 {
071436c6
NC		 12374 size_t maxlen = end - data;
12375
cf13d699 12376#ifndef __MSVCRT__
c975cc98
NC		 12377 /* PR 11128: Use two separate invocations in order to work
12378 around bugs in the Solaris 8 implementation of printf. */
12379 printf (" [%6tx] ", data - start);
cf13d699 12380#else
071436c6 12381 printf (" [%6Ix] ", (size_t) (data - start));
cf13d699 12382#endif
4082ef84
NC		 12383 if (maxlen > 0)
12384 {
fd8008d8 12385 print_symbol ((int) maxlen, (const char *) data);
4082ef84 12386 putchar ('\n');
fd8008d8 12387 data += strnlen ((const char *) data, maxlen);
4082ef84
NC		 12388 }
12389 else
12390 {
12391 printf (_("<corrupt>\n"));
12392 data = end;
12393 }
cf13d699
NC		 12394 some_strings_shown = TRUE;
12395 }
12396 }
12397
12398 if (! some_strings_shown)
12399 printf (_(" No strings found in this section."));
12400
0e602686 12401 free (real_start);
cf13d699
NC		 12402
12403 putchar ('\n');
12404}
12405
12406static void
12407dump_section_as_bytes (Elf_Internal_Shdr * section,
12408 FILE * file,
12409 bfd_boolean relocate)
12410{
12411 Elf_Internal_Shdr * relsec;
0e602686
NC		 12412 bfd_size_type bytes;
12413 bfd_size_type section_size;
12414 bfd_vma addr;
12415 unsigned char * data;
12416 unsigned char * real_start;
12417 unsigned char * start;
12418
12419 real_start = start = (unsigned char *) get_section_contents (section, file);
cf13d699
NC		 12420 if (start == NULL)
12421 return;
0e602686 12422 section_size = section->sh_size;
cf13d699 12423
74e1a04b 12424 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
cf13d699 12425
0e602686
NC		 12426 if (decompress_dumps)
12427 {
12428 dwarf_size_type new_size = section_size;
12429 dwarf_size_type uncompressed_size = 0;
12430
12431 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12432 {
12433 Elf_Internal_Chdr chdr;
12434 unsigned int compression_header_size
12435 = get_compression_header (& chdr, start);
12436
813dabb9 12437 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
0e602686 12438 {
813dabb9
L		 12439 warn (_("section '%s' has unsupported compress type: %d\n"),
12440 printable_section_name (section), chdr.ch_type);
12441 return;
0e602686 12442 }
813dabb9
L		 12443 else if (chdr.ch_addralign != section->sh_addralign)
12444 {
12445 warn (_("compressed section '%s' is corrupted\n"),
12446 printable_section_name (section));
12447 return;
12448 }
12449 uncompressed_size = chdr.ch_size;
12450 start += compression_header_size;
12451 new_size -= compression_header_size;
0e602686
NC		 12452 }
12453 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12454 {
12455 /* Read the zlib header. In this case, it should be "ZLIB"
12456 followed by the uncompressed section size, 8 bytes in
12457 big-endian order. */
12458 uncompressed_size = start[4]; uncompressed_size <<= 8;
12459 uncompressed_size += start[5]; uncompressed_size <<= 8;
12460 uncompressed_size += start[6]; uncompressed_size <<= 8;
12461 uncompressed_size += start[7]; uncompressed_size <<= 8;
12462 uncompressed_size += start[8]; uncompressed_size <<= 8;
12463 uncompressed_size += start[9]; uncompressed_size <<= 8;
12464 uncompressed_size += start[10]; uncompressed_size <<= 8;
12465 uncompressed_size += start[11];
12466 start += 12;
12467 new_size -= 12;
12468 }
12469
12470 if (uncompressed_size
12471 && uncompress_section_contents (& start, uncompressed_size,
12472 & new_size))
12473 section_size = new_size;
12474 }
14ae95f2 12475
cf13d699
NC		 12476 if (relocate)
12477 {
0e602686 12478 apply_relocations (file, section, start, section_size, NULL, NULL);
cf13d699
NC		 12479 }
12480 else
12481 {
12482 /* If the section being dumped has relocations against it the user might
12483 be expecting these relocations to have been applied. Check for this
12484 case and issue a warning message in order to avoid confusion.
12485 FIXME: Maybe we ought to have an option that dumps a section with
12486 relocs applied ? */
12487 for (relsec = section_headers;
12488 relsec < section_headers + elf_header.e_shnum;
12489 ++relsec)
12490 {
12491 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12492 || relsec->sh_info >= elf_header.e_shnum
12493 || section_headers + relsec->sh_info != section
12494 || relsec->sh_size == 0
12495 || relsec->sh_link >= elf_header.e_shnum)
12496 continue;
12497
12498 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12499 break;
12500 }
12501 }
12502
12503 addr = section->sh_addr;
0e602686 12504 bytes = section_size;
cf13d699
NC		 12505 data = start;
12506
12507 while (bytes)
12508 {
12509 int j;
12510 int k;
12511 int lbytes;
12512
12513 lbytes = (bytes > 16 ? 16 : bytes);
12514
12515 printf (" 0x%8.8lx ", (unsigned long) addr);
12516
12517 for (j = 0; j < 16; j++)
12518 {
12519 if (j < lbytes)
12520 printf ("%2.2x", data[j]);
12521 else
12522 printf (" ");
12523
12524 if ((j & 3) == 3)
12525 printf (" ");
12526 }
12527
12528 for (j = 0; j < lbytes; j++)
12529 {
12530 k = data[j];
12531 if (k >= ' ' && k < 0x7f)
12532 printf ("%c", k);
12533 else
12534 printf (".");
12535 }
12536
12537 putchar ('\n');
12538
12539 data += lbytes;
12540 addr += lbytes;
12541 bytes -= lbytes;
12542 }
12543
0e602686 12544 free (real_start);
cf13d699
NC		 12545
12546 putchar ('\n');
12547}
12548
d966045b
DJ		 12549static int
12550load_specific_debug_section (enum dwarf_section_display_enum debug,
0d2a7a93 12551 const Elf_Internal_Shdr * sec, void * file)
1007acb3 12552{
2cf0635d 12553 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 12554 char buf [64];
1007acb3 12555
19e6b90e
L		 12556 /* If it is already loaded, do nothing. */
12557 if (section->start != NULL)
12558 return 1;
1007acb3 12559
19e6b90e
L		 12560 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12561 section->address = sec->sh_addr;
06614111 12562 section->user_data = NULL;
3f5e193b
NC		 12563 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12564 sec->sh_offset, 1,
12565 sec->sh_size, buf);
59245841
NC		 12566 if (section->start == NULL)
12567 section->size = 0;
12568 else
12569 {
77115a4a
L		 12570 unsigned char *start = section->start;
12571 dwarf_size_type size = sec->sh_size;
dab394de 12572 dwarf_size_type uncompressed_size = 0;
77115a4a
L		 12573
12574 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
12575 {
12576 Elf_Internal_Chdr chdr;
12577 unsigned int compression_header_size
12578 = get_compression_header (&chdr, start);
813dabb9
L		 12579 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12580 {
12581 warn (_("section '%s' has unsupported compress type: %d\n"),
12582 section->name, chdr.ch_type);
12583 return 0;
12584 }
12585 else if (chdr.ch_addralign != sec->sh_addralign)
12586 {
12587 warn (_("compressed section '%s' is corrupted\n"),
12588 section->name);
12589 return 0;
12590 }
dab394de 12591 uncompressed_size = chdr.ch_size;
77115a4a
L		 12592 start += compression_header_size;
12593 size -= compression_header_size;
12594 }
dab394de
L		 12595 else if (size > 12 && streq ((char *) start, "ZLIB"))
12596 {
12597 /* Read the zlib header. In this case, it should be "ZLIB"
12598 followed by the uncompressed section size, 8 bytes in
12599 big-endian order. */
12600 uncompressed_size = start[4]; uncompressed_size <<= 8;
12601 uncompressed_size += start[5]; uncompressed_size <<= 8;
12602 uncompressed_size += start[6]; uncompressed_size <<= 8;
12603 uncompressed_size += start[7]; uncompressed_size <<= 8;
12604 uncompressed_size += start[8]; uncompressed_size <<= 8;
12605 uncompressed_size += start[9]; uncompressed_size <<= 8;
12606 uncompressed_size += start[10]; uncompressed_size <<= 8;
12607 uncompressed_size += start[11];
12608 start += 12;
12609 size -= 12;
12610 }
12611
12612 if (uncompressed_size
12613 && uncompress_section_contents (&start, uncompressed_size,
12614 &size))
77115a4a
L		 12615 {
12616 /* Free the compressed buffer, update the section buffer
12617 and the section size if uncompress is successful. */
12618 free (section->start);
12619 section->start = start;
77115a4a
L		 12620 }
12621 section->size = size;
59245841 12622 }
4a114e3e 12623
1b315056
CS		 12624 if (section->start == NULL)
12625 return 0;
12626
19e6b90e 12627 if (debug_displays [debug].relocate)
d1c4b12b
NC		 12628 apply_relocations ((FILE *) file, sec, section->start, section->size,
12629 & section->reloc_info, & section->num_relocs);
12630 else
12631 {
12632 section->reloc_info = NULL;
12633 section->num_relocs = 0;
12634 }
1007acb3 12635
1b315056 12636 return 1;
1007acb3
L		 12637}
12638
657d0d47
CC		 12639/* If this is not NULL, load_debug_section will only look for sections
12640 within the list of sections given here. */
12641unsigned int *section_subset = NULL;
12642
d966045b 12643int
2cf0635d 12644load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 12645{
2cf0635d
NC		 12646 struct dwarf_section * section = &debug_displays [debug].section;
12647 Elf_Internal_Shdr * sec;
d966045b
DJ		 12648
12649 /* Locate the debug section. */
657d0d47 12650 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 12651 if (sec != NULL)
12652 section->name = section->uncompressed_name;
12653 else
12654 {
657d0d47 12655 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 12656 if (sec != NULL)
12657 section->name = section->compressed_name;
12658 }
12659 if (sec == NULL)
12660 return 0;
12661
657d0d47
CC		 12662 /* If we're loading from a subset of sections, and we've loaded
12663 a section matching this name before, it's likely that it's a
12664 different one. */
12665 if (section_subset != NULL)
12666 free_debug_section (debug);
12667
3f5e193b 12668 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 12669}
12670
19e6b90e
L		 12671void
12672free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 12673{
2cf0635d 12674 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 12675
19e6b90e
L		 12676 if (section->start == NULL)
12677 return;
1007acb3 12678
19e6b90e
L		 12679 free ((char *) section->start);
12680 section->start = NULL;
12681 section->address = 0;
12682 section->size = 0;
1007acb3
L		 12683}
12684
1007acb3 12685static int
657d0d47 12686display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 12687{
2cf0635d 12688 char * name = SECTION_NAME (section);
74e1a04b 12689 const char * print_name = printable_section_name (section);
19e6b90e
L		 12690 bfd_size_type length;
12691 int result = 1;
3f5e193b 12692 int i;
1007acb3 12693
19e6b90e
L		 12694 length = section->sh_size;
12695 if (length == 0)
1007acb3 12696 {
74e1a04b 12697 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
19e6b90e 12698 return 0;
1007acb3 12699 }
5dff79d8
NC		 12700 if (section->sh_type == SHT_NOBITS)
12701 {
12702 /* There is no point in dumping the contents of a debugging section
12703 which has the NOBITS type - the bits in the file will be random.
12704 This can happen when a file containing a .eh_frame section is
12705 stripped with the --only-keep-debug command line option. */
74e1a04b
NC		 12706 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12707 print_name);
5dff79d8
NC		 12708 return 0;
12709 }
1007acb3 12710
0112cd26 12711 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 12712 name = ".debug_info";
1007acb3 12713
19e6b90e
L		 12714 /* See if we know how to display the contents of this section. */
12715 for (i = 0; i < max; i++)
1b315056 12716 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 12717 || (i == line && const_strneq (name, ".debug_line."))
1b315056 12718 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 12719 {
2cf0635d 12720 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 12721 int secondary = (section != find_section (name));
12722
12723 if (secondary)
3f5e193b 12724 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 12725
b40bf0a2
NC		 12726 if (i == line && const_strneq (name, ".debug_line."))
12727 sec->name = name;
12728 else if (streq (sec->uncompressed_name, name))
d966045b
DJ		 12729 sec->name = sec->uncompressed_name;
12730 else
12731 sec->name = sec->compressed_name;
3f5e193b
NC		 12732 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12733 section, file))
19e6b90e 12734 {
657d0d47
CC		 12735 /* If this debug section is part of a CU/TU set in a .dwp file,
12736 restrict load_debug_section to the sections in that set. */
12737 section_subset = find_cu_tu_set (file, shndx);
12738
19e6b90e 12739 result &= debug_displays[i].display (sec, file);
1007acb3 12740
657d0d47
CC		 12741 section_subset = NULL;
12742
d966045b 12743 if (secondary || (i != info && i != abbrev))
3f5e193b 12744 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 12745 }
1007acb3 12746
19e6b90e
L		 12747 break;
12748 }
1007acb3 12749
19e6b90e 12750 if (i == max)
1007acb3 12751 {
74e1a04b 12752 printf (_("Unrecognized debug section: %s\n"), print_name);
19e6b90e 12753 result = 0;
1007acb3
L		 12754 }
12755
19e6b90e 12756 return result;
5b18a4bc 12757}
103f02d3 12758
aef1f6d0
DJ		 12759/* Set DUMP_SECTS for all sections where dumps were requested
12760 based on section name. */
12761
12762static void
12763initialise_dumps_byname (void)
12764{
2cf0635d 12765 struct dump_list_entry * cur;
aef1f6d0
DJ		 12766
12767 for (cur = dump_sects_byname; cur; cur = cur->next)
12768 {
12769 unsigned int i;
12770 int any;
12771
12772 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12773 if (streq (SECTION_NAME (section_headers + i), cur->name))
12774 {
09c11c86 12775 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 12776 any = 1;
12777 }
12778
12779 if (!any)
12780 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12781 cur->name);
12782 }
12783}
12784
5b18a4bc 12785static void
2cf0635d 12786process_section_contents (FILE * file)
5b18a4bc 12787{
2cf0635d 12788 Elf_Internal_Shdr * section;
19e6b90e 12789 unsigned int i;
103f02d3 12790
19e6b90e
L		 12791 if (! do_dump)
12792 return;
103f02d3 12793
aef1f6d0
DJ		 12794 initialise_dumps_byname ();
12795
19e6b90e
L		 12796 for (i = 0, section = section_headers;
12797 i < elf_header.e_shnum && i < num_dump_sects;
12798 i++, section++)
12799 {
12800#ifdef SUPPORT_DISASSEMBLY
12801 if (dump_sects[i] & DISASS_DUMP)
12802 disassemble_section (section, file);
12803#endif
12804 if (dump_sects[i] & HEX_DUMP)
cf13d699 12805 dump_section_as_bytes (section, file, FALSE);
103f02d3 12806
cf13d699
NC		 12807 if (dump_sects[i] & RELOC_DUMP)
12808 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 12809
12810 if (dump_sects[i] & STRING_DUMP)
12811 dump_section_as_strings (section, file);
cf13d699
NC		 12812
12813 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 12814 display_debug_section (i, section, file);
5b18a4bc 12815 }
103f02d3 12816
19e6b90e
L		 12817 /* Check to see if the user requested a
12818 dump of a section that does not exist. */
12819 while (i++ < num_dump_sects)
12820 if (dump_sects[i])
12821 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 12822}
103f02d3 12823
5b18a4bc 12824static void
19e6b90e 12825process_mips_fpe_exception (int mask)
5b18a4bc 12826{
19e6b90e
L		 12827 if (mask)
12828 {
12829 int first = 1;
12830 if (mask & OEX_FPU_INEX)
12831 fputs ("INEX", stdout), first = 0;
12832 if (mask & OEX_FPU_UFLO)
12833 printf ("%sUFLO", first ? "" : "|"), first = 0;
12834 if (mask & OEX_FPU_OFLO)
12835 printf ("%sOFLO", first ? "" : "|"), first = 0;
12836 if (mask & OEX_FPU_DIV0)
12837 printf ("%sDIV0", first ? "" : "|"), first = 0;
12838 if (mask & OEX_FPU_INVAL)
12839 printf ("%sINVAL", first ? "" : "|");
12840 }
5b18a4bc 12841 else
19e6b90e 12842 fputs ("0", stdout);
5b18a4bc 12843}
103f02d3 12844
f6f0e17b
NC		 12845/* Display's the value of TAG at location P. If TAG is
12846 greater than 0 it is assumed to be an unknown tag, and
12847 a message is printed to this effect. Otherwise it is
12848 assumed that a message has already been printed.
12849
12850 If the bottom bit of TAG is set it assumed to have a
12851 string value, otherwise it is assumed to have an integer
12852 value.
12853
12854 Returns an updated P pointing to the first unread byte
12855 beyond the end of TAG's value.
12856
12857 Reads at or beyond END will not be made. */
12858
12859static unsigned char *
12860display_tag_value (int tag,
12861 unsigned char * p,
12862 const unsigned char * const end)
12863{
12864 unsigned long val;
12865
12866 if (tag > 0)
12867 printf (" Tag_unknown_%d: ", tag);
12868
12869 if (p >= end)
12870 {
4082ef84 12871 warn (_("<corrupt tag>\n"));
f6f0e17b
NC		 12872 }
12873 else if (tag & 1)
12874 {
071436c6
NC		 12875 /* PR 17531 file: 027-19978-0.004. */
12876 size_t maxlen = (end - p) - 1;
12877
12878 putchar ('"');
4082ef84
NC		 12879 if (maxlen > 0)
12880 {
12881 print_symbol ((int) maxlen, (const char *) p);
12882 p += strnlen ((char *) p, maxlen) + 1;
12883 }
12884 else
12885 {
12886 printf (_("<corrupt string tag>"));
12887 p = (unsigned char *) end;
12888 }
071436c6 12889 printf ("\"\n");
f6f0e17b
NC		 12890 }
12891 else
12892 {
12893 unsigned int len;
12894
12895 val = read_uleb128 (p, &len, end);
12896 p += len;
12897 printf ("%ld (0x%lx)\n", val, val);
12898 }
12899
4082ef84 12900 assert (p <= end);
f6f0e17b
NC		 12901 return p;
12902}
12903
11c1ff18
PB		 12904/* ARM EABI attributes section. */
12905typedef struct
12906{
70e99720 12907 unsigned int tag;
2cf0635d 12908 const char * name;
11c1ff18 12909 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
70e99720 12910 unsigned int type;
2cf0635d 12911 const char ** table;
11c1ff18
PB		 12912} arm_attr_public_tag;
12913
2cf0635d 12914static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 12915 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
ff8646ee
TP		 12916 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
12917 "v8-M.mainline"};
2cf0635d
NC		 12918static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12919static const char * arm_attr_tag_THUMB_ISA_use[] =
4ed7ed8d 12920 {"No", "Thumb-1", "Thumb-2", "Yes"};
75375b3e 12921static const char * arm_attr_tag_FP_arch[] =
bca38921 12922 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
a715796b 12923 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
2cf0635d 12924static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 12925static const char * arm_attr_tag_Advanced_SIMD_arch[] =
9411fd44
MW		 12926 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
12927 "NEON for ARMv8.1"};
2cf0635d 12928static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 12929 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12930 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 12931static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 12932 {"V6", "SB", "TLS", "Unused"};
2cf0635d 12933static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 12934 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 12935static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 12936 {"Absolute", "PC-relative", "None"};
2cf0635d 12937static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 12938 {"None", "direct", "GOT-indirect"};
2cf0635d 12939static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 12940 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 12941static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12942static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 12943 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 12944static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12945static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12946static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 12947 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 12948static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 12949 {"Unused", "small", "int", "forced to int"};
2cf0635d 12950static const char * arm_attr_tag_ABI_HardFP_use[] =
99654aaf 12951 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
2cf0635d 12952static const char * arm_attr_tag_ABI_VFP_args[] =
5c294fee 12953 {"AAPCS", "VFP registers", "custom", "compatible"};
2cf0635d 12954static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 12955 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 12956static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 12957 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12958 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 12959static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 12960 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12961 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 12962static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 12963static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 12964 {"Not Allowed", "Allowed"};
2cf0635d 12965static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 12966 {"None", "IEEE 754", "Alternative Format"};
15afaa63
TP		 12967static const char * arm_attr_tag_DSP_extension[] =
12968 {"Follow architecture", "Allowed"};
dd24e3da 12969static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 12970 {"Not Allowed", "Allowed"};
12971static const char * arm_attr_tag_DIV_use[] =
dd24e3da 12972 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 12973 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 12974static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12975static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 12976 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 12977 "TrustZone and Virtualization Extensions"};
dd24e3da 12978static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 12979 {"Not Allowed", "Allowed"};
11c1ff18
PB		 12980
12981#define LOOKUP(id, name) \
12982 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 12983static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 12984{
12985 {4, "CPU_raw_name", 1, NULL},
12986 {5, "CPU_name", 1, NULL},
12987 LOOKUP(6, CPU_arch),
12988 {7, "CPU_arch_profile", 0, NULL},
12989 LOOKUP(8, ARM_ISA_use),
12990 LOOKUP(9, THUMB_ISA_use),
75375b3e 12991 LOOKUP(10, FP_arch),
11c1ff18 12992 LOOKUP(11, WMMX_arch),
f5f53991
AS		 12993 LOOKUP(12, Advanced_SIMD_arch),
12994 LOOKUP(13, PCS_config),
11c1ff18
PB		 12995 LOOKUP(14, ABI_PCS_R9_use),
12996 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 12997 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 12998 LOOKUP(17, ABI_PCS_GOT_use),
12999 LOOKUP(18, ABI_PCS_wchar_t),
13000 LOOKUP(19, ABI_FP_rounding),
13001 LOOKUP(20, ABI_FP_denormal),
13002 LOOKUP(21, ABI_FP_exceptions),
13003 LOOKUP(22, ABI_FP_user_exceptions),
13004 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 13005 {24, "ABI_align_needed", 0, NULL},
13006 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 13007 LOOKUP(26, ABI_enum_size),
13008 LOOKUP(27, ABI_HardFP_use),
13009 LOOKUP(28, ABI_VFP_args),
13010 LOOKUP(29, ABI_WMMX_args),
13011 LOOKUP(30, ABI_optimization_goals),
13012 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 13013 {32, "compatibility", 0, NULL},
f5f53991 13014 LOOKUP(34, CPU_unaligned_access),
75375b3e 13015 LOOKUP(36, FP_HP_extension),
8e79c3df 13016 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 13017 LOOKUP(42, MPextension_use),
13018 LOOKUP(44, DIV_use),
15afaa63 13019 LOOKUP(46, DSP_extension),
f5f53991
AS		 13020 {64, "nodefaults", 0, NULL},
13021 {65, "also_compatible_with", 0, NULL},
13022 LOOKUP(66, T2EE_use),
13023 {67, "conformance", 1, NULL},
13024 LOOKUP(68, Virtualization_use),
cd21e546 13025 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 13026};
13027#undef LOOKUP
13028
11c1ff18 13029static unsigned char *
f6f0e17b
NC		 13030display_arm_attribute (unsigned char * p,
13031 const unsigned char * const end)
11c1ff18 13032{
70e99720 13033 unsigned int tag;
11c1ff18 13034 unsigned int len;
70e99720 13035 unsigned int val;
2cf0635d 13036 arm_attr_public_tag * attr;
11c1ff18 13037 unsigned i;
70e99720 13038 unsigned int type;
11c1ff18 13039
f6f0e17b 13040 tag = read_uleb128 (p, &len, end);
11c1ff18
PB		 13041 p += len;
13042 attr = NULL;
2cf0635d 13043 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 13044 {
13045 if (arm_attr_public_tags[i].tag == tag)
13046 {
13047 attr = &arm_attr_public_tags[i];
13048 break;
13049 }
13050 }
13051
13052 if (attr)
13053 {
13054 printf (" Tag_%s: ", attr->name);
13055 switch (attr->type)
13056 {
13057 case 0:
13058 switch (tag)
13059 {
13060 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 13061 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 13062 p += len;
13063 switch (val)
13064 {
2b692964
NC		 13065 case 0: printf (_("None\n")); break;
13066 case 'A': printf (_("Application\n")); break;
13067 case 'R': printf (_("Realtime\n")); break;
13068 case 'M': printf (_("Microcontroller\n")); break;
13069 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 13070 default: printf ("??? (%d)\n", val); break;
13071 }
13072 break;
13073
75375b3e 13074 case 24: /* Tag_align_needed. */
f6f0e17b 13075 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 13076 p += len;
13077 switch (val)
13078 {
2b692964
NC		 13079 case 0: printf (_("None\n")); break;
13080 case 1: printf (_("8-byte\n")); break;
13081 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 13082 case 3: printf ("??? 3\n"); break;
13083 default:
13084 if (val <= 12)
dd24e3da 13085 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 13086 1 << val);
13087 else
13088 printf ("??? (%d)\n", val);
13089 break;
13090 }
13091 break;
13092
13093 case 25: /* Tag_align_preserved. */
f6f0e17b 13094 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 13095 p += len;
13096 switch (val)
13097 {
2b692964
NC		 13098 case 0: printf (_("None\n")); break;
13099 case 1: printf (_("8-byte, except leaf SP\n")); break;
13100 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 13101 case 3: printf ("??? 3\n"); break;
13102 default:
13103 if (val <= 12)
dd24e3da 13104 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 13105 1 << val);
13106 else
13107 printf ("??? (%d)\n", val);
13108 break;
13109 }
13110 break;
13111
11c1ff18 13112 case 32: /* Tag_compatibility. */
071436c6 13113 {
071436c6
NC		 13114 val = read_uleb128 (p, &len, end);
13115 p += len;
071436c6 13116 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 13117 if (p < end - 1)
13118 {
13119 size_t maxlen = (end - p) - 1;
13120
13121 print_symbol ((int) maxlen, (const char *) p);
13122 p += strnlen ((char *) p, maxlen) + 1;
13123 }
13124 else
13125 {
13126 printf (_("<corrupt>"));
13127 p = (unsigned char *) end;
13128 }
071436c6 13129 putchar ('\n');
071436c6 13130 }
11c1ff18
PB		 13131 break;
13132
f5f53991 13133 case 64: /* Tag_nodefaults. */
541a3cbd
NC		 13134 /* PR 17531: file: 001-505008-0.01. */
13135 if (p < end)
13136 p++;
2b692964 13137 printf (_("True\n"));
f5f53991
AS		 13138 break;
13139
13140 case 65: /* Tag_also_compatible_with. */
f6f0e17b 13141 val = read_uleb128 (p, &len, end);
f5f53991
AS		 13142 p += len;
13143 if (val == 6 /* Tag_CPU_arch. */)
13144 {
f6f0e17b 13145 val = read_uleb128 (p, &len, end);
f5f53991 13146 p += len;
071436c6 13147 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 13148 printf ("??? (%d)\n", val);
13149 else
13150 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
13151 }
13152 else
13153 printf ("???\n");
071436c6
NC		 13154 while (p < end && *(p++) != '\0' /* NUL terminator. */)
13155 ;
f5f53991
AS		 13156 break;
13157
11c1ff18 13158 default:
bee0ee85
NC		 13159 printf (_("<unknown: %d>\n"), tag);
13160 break;
11c1ff18
PB		 13161 }
13162 return p;
13163
13164 case 1:
f6f0e17b 13165 return display_tag_value (-1, p, end);
11c1ff18 13166 case 2:
f6f0e17b 13167 return display_tag_value (0, p, end);
11c1ff18
PB		 13168
13169 default:
13170 assert (attr->type & 0x80);
f6f0e17b 13171 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 13172 p += len;
13173 type = attr->type & 0x7f;
13174 if (val >= type)
13175 printf ("??? (%d)\n", val);
13176 else
13177 printf ("%s\n", attr->table[val]);
13178 return p;
13179 }
13180 }
11c1ff18 13181
f6f0e17b 13182 return display_tag_value (tag, p, end);
11c1ff18
PB		 13183}
13184
104d59d1 13185static unsigned char *
60bca95a 13186display_gnu_attribute (unsigned char * p,
f6f0e17b
NC		 13187 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
13188 const unsigned char * const end)
104d59d1
JM		 13189{
13190 int tag;
13191 unsigned int len;
13192 int val;
104d59d1 13193
f6f0e17b 13194 tag = read_uleb128 (p, &len, end);
104d59d1
JM		 13195 p += len;
13196
13197 /* Tag_compatibility is the only generic GNU attribute defined at
13198 present. */
13199 if (tag == 32)
13200 {
f6f0e17b 13201 val = read_uleb128 (p, &len, end);
104d59d1 13202 p += len;
071436c6
NC		 13203
13204 printf (_("flag = %d, vendor = "), val);
f6f0e17b
NC		 13205 if (p == end)
13206 {
071436c6 13207 printf (_("<corrupt>\n"));
f6f0e17b
NC		 13208 warn (_("corrupt vendor attribute\n"));
13209 }
13210 else
13211 {
4082ef84
NC		 13212 if (p < end - 1)
13213 {
13214 size_t maxlen = (end - p) - 1;
071436c6 13215
4082ef84
NC		 13216 print_symbol ((int) maxlen, (const char *) p);
13217 p += strnlen ((char *) p, maxlen) + 1;
13218 }
13219 else
13220 {
13221 printf (_("<corrupt>"));
13222 p = (unsigned char *) end;
13223 }
071436c6 13224 putchar ('\n');
f6f0e17b 13225 }
104d59d1
JM		 13226 return p;
13227 }
13228
13229 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 13230 return display_proc_gnu_attribute (p, tag, end);
104d59d1 13231
f6f0e17b 13232 return display_tag_value (tag, p, end);
104d59d1
JM		 13233}
13234
34c8bcba 13235static unsigned char *
f6f0e17b
NC		 13236display_power_gnu_attribute (unsigned char * p,
13237 int tag,
13238 const unsigned char * const end)
34c8bcba 13239{
34c8bcba
JM		 13240 unsigned int len;
13241 int val;
13242
13243 if (tag == Tag_GNU_Power_ABI_FP)
13244 {
f6f0e17b 13245 val = read_uleb128 (p, &len, end);
34c8bcba
JM		 13246 p += len;
13247 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 13248
34c8bcba
JM		 13249 switch (val)
13250 {
13251 case 0:
2b692964 13252 printf (_("Hard or soft float\n"));
34c8bcba
JM		 13253 break;
13254 case 1:
2b692964 13255 printf (_("Hard float\n"));
34c8bcba
JM		 13256 break;
13257 case 2:
2b692964 13258 printf (_("Soft float\n"));
34c8bcba 13259 break;
3c7b9897 13260 case 3:
2b692964 13261 printf (_("Single-precision hard float\n"));
3c7b9897 13262 break;
34c8bcba
JM		 13263 default:
13264 printf ("??? (%d)\n", val);
13265 break;
13266 }
13267 return p;
13268 }
13269
c6e65352
DJ		 13270 if (tag == Tag_GNU_Power_ABI_Vector)
13271 {
f6f0e17b 13272 val = read_uleb128 (p, &len, end);
c6e65352
DJ		 13273 p += len;
13274 printf (" Tag_GNU_Power_ABI_Vector: ");
13275 switch (val)
13276 {
13277 case 0:
2b692964 13278 printf (_("Any\n"));
c6e65352
DJ		 13279 break;
13280 case 1:
2b692964 13281 printf (_("Generic\n"));
c6e65352
DJ		 13282 break;
13283 case 2:
13284 printf ("AltiVec\n");
13285 break;
13286 case 3:
13287 printf ("SPE\n");
13288 break;
13289 default:
13290 printf ("??? (%d)\n", val);
13291 break;
13292 }
13293 return p;
13294 }
13295
f82e0623
NF		 13296 if (tag == Tag_GNU_Power_ABI_Struct_Return)
13297 {
f6f0e17b
NC		 13298 if (p == end)
13299 {
071436c6 13300 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
f6f0e17b
NC		 13301 return p;
13302 }
0b4362b0 13303
f6f0e17b 13304 val = read_uleb128 (p, &len, end);
f82e0623
NF		 13305 p += len;
13306 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13307 switch (val)
13308 {
13309 case 0:
2b692964 13310 printf (_("Any\n"));
f82e0623
NF		 13311 break;
13312 case 1:
13313 printf ("r3/r4\n");
13314 break;
13315 case 2:
2b692964 13316 printf (_("Memory\n"));
f82e0623
NF		 13317 break;
13318 default:
13319 printf ("??? (%d)\n", val);
13320 break;
13321 }
13322 return p;
13323 }
13324
f6f0e17b 13325 return display_tag_value (tag & 1, p, end);
34c8bcba
JM		 13326}
13327
643f7afb
AK		 13328static unsigned char *
13329display_s390_gnu_attribute (unsigned char * p,
13330 int tag,
13331 const unsigned char * const end)
13332{
13333 unsigned int len;
13334 int val;
13335
13336 if (tag == Tag_GNU_S390_ABI_Vector)
13337 {
13338 val = read_uleb128 (p, &len, end);
13339 p += len;
13340 printf (" Tag_GNU_S390_ABI_Vector: ");
13341
13342 switch (val)
13343 {
13344 case 0:
13345 printf (_("any\n"));
13346 break;
13347 case 1:
13348 printf (_("software\n"));
13349 break;
13350 case 2:
13351 printf (_("hardware\n"));
13352 break;
13353 default:
13354 printf ("??? (%d)\n", val);
13355 break;
13356 }
13357 return p;
13358 }
13359
13360 return display_tag_value (tag & 1, p, end);
13361}
13362
9e8c70f9
DM		 13363static void
13364display_sparc_hwcaps (int mask)
13365{
13366 if (mask)
13367 {
13368 int first = 1;
071436c6 13369
9e8c70f9
DM		 13370 if (mask & ELF_SPARC_HWCAP_MUL32)
13371 fputs ("mul32", stdout), first = 0;
13372 if (mask & ELF_SPARC_HWCAP_DIV32)
13373 printf ("%sdiv32", first ? "" : "|"), first = 0;
13374 if (mask & ELF_SPARC_HWCAP_FSMULD)
13375 printf ("%sfsmuld", first ? "" : "|"), first = 0;
13376 if (mask & ELF_SPARC_HWCAP_V8PLUS)
13377 printf ("%sv8plus", first ? "" : "|"), first = 0;
13378 if (mask & ELF_SPARC_HWCAP_POPC)
13379 printf ("%spopc", first ? "" : "|"), first = 0;
13380 if (mask & ELF_SPARC_HWCAP_VIS)
13381 printf ("%svis", first ? "" : "|"), first = 0;
13382 if (mask & ELF_SPARC_HWCAP_VIS2)
13383 printf ("%svis2", first ? "" : "|"), first = 0;
13384 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
13385 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
13386 if (mask & ELF_SPARC_HWCAP_FMAF)
13387 printf ("%sfmaf", first ? "" : "|"), first = 0;
13388 if (mask & ELF_SPARC_HWCAP_VIS3)
13389 printf ("%svis3", first ? "" : "|"), first = 0;
13390 if (mask & ELF_SPARC_HWCAP_HPC)
13391 printf ("%shpc", first ? "" : "|"), first = 0;
13392 if (mask & ELF_SPARC_HWCAP_RANDOM)
13393 printf ("%srandom", first ? "" : "|"), first = 0;
13394 if (mask & ELF_SPARC_HWCAP_TRANS)
13395 printf ("%strans", first ? "" : "|"), first = 0;
13396 if (mask & ELF_SPARC_HWCAP_FJFMAU)
13397 printf ("%sfjfmau", first ? "" : "|"), first = 0;
13398 if (mask & ELF_SPARC_HWCAP_IMA)
13399 printf ("%sima", first ? "" : "|"), first = 0;
13400 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
13401 printf ("%scspare", first ? "" : "|"), first = 0;
13402 }
13403 else
071436c6
NC		 13404 fputc ('0', stdout);
13405 fputc ('\n', stdout);
9e8c70f9
DM		 13406}
13407
3d68f91c
JM		 13408static void
13409display_sparc_hwcaps2 (int mask)
13410{
13411 if (mask)
13412 {
13413 int first = 1;
071436c6 13414
3d68f91c
JM		 13415 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
13416 fputs ("fjathplus", stdout), first = 0;
13417 if (mask & ELF_SPARC_HWCAP2_VIS3B)
13418 printf ("%svis3b", first ? "" : "|"), first = 0;
13419 if (mask & ELF_SPARC_HWCAP2_ADP)
13420 printf ("%sadp", first ? "" : "|"), first = 0;
13421 if (mask & ELF_SPARC_HWCAP2_SPARC5)
13422 printf ("%ssparc5", first ? "" : "|"), first = 0;
13423 if (mask & ELF_SPARC_HWCAP2_MWAIT)
13424 printf ("%smwait", first ? "" : "|"), first = 0;
13425 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
13426 printf ("%sxmpmul", first ? "" : "|"), first = 0;
13427 if (mask & ELF_SPARC_HWCAP2_XMONT)
13428 printf ("%sxmont2", first ? "" : "|"), first = 0;
13429 if (mask & ELF_SPARC_HWCAP2_NSEC)
13430 printf ("%snsec", first ? "" : "|"), first = 0;
13431 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
13432 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
13433 if (mask & ELF_SPARC_HWCAP2_FJDES)
13434 printf ("%sfjdes", first ? "" : "|"), first = 0;
13435 if (mask & ELF_SPARC_HWCAP2_FJAES)
13436 printf ("%sfjaes", first ? "" : "|"), first = 0;
13437 }
13438 else
071436c6
NC		 13439 fputc ('0', stdout);
13440 fputc ('\n', stdout);
3d68f91c
JM		 13441}
13442
9e8c70f9 13443static unsigned char *
f6f0e17b
NC		 13444display_sparc_gnu_attribute (unsigned char * p,
13445 int tag,
13446 const unsigned char * const end)
9e8c70f9 13447{
3d68f91c
JM		 13448 unsigned int len;
13449 int val;
13450
9e8c70f9
DM		 13451 if (tag == Tag_GNU_Sparc_HWCAPS)
13452 {
f6f0e17b 13453 val = read_uleb128 (p, &len, end);
9e8c70f9
DM		 13454 p += len;
13455 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM		 13456 display_sparc_hwcaps (val);
13457 return p;
3d68f91c
JM		 13458 }
13459 if (tag == Tag_GNU_Sparc_HWCAPS2)
13460 {
13461 val = read_uleb128 (p, &len, end);
13462 p += len;
13463 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13464 display_sparc_hwcaps2 (val);
13465 return p;
13466 }
9e8c70f9 13467
f6f0e17b 13468 return display_tag_value (tag, p, end);
9e8c70f9
DM		 13469}
13470
351cdf24
MF		 13471static void
13472print_mips_fp_abi_value (int val)
13473{
13474 switch (val)
13475 {
13476 case Val_GNU_MIPS_ABI_FP_ANY:
13477 printf (_("Hard or soft float\n"));
13478 break;
13479 case Val_GNU_MIPS_ABI_FP_DOUBLE:
13480 printf (_("Hard float (double precision)\n"));
13481 break;
13482 case Val_GNU_MIPS_ABI_FP_SINGLE:
13483 printf (_("Hard float (single precision)\n"));
13484 break;
13485 case Val_GNU_MIPS_ABI_FP_SOFT:
13486 printf (_("Soft float\n"));
13487 break;
13488 case Val_GNU_MIPS_ABI_FP_OLD_64:
13489 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13490 break;
13491 case Val_GNU_MIPS_ABI_FP_XX:
13492 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13493 break;
13494 case Val_GNU_MIPS_ABI_FP_64:
13495 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13496 break;
13497 case Val_GNU_MIPS_ABI_FP_64A:
13498 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13499 break;
3350cc01
CM		 13500 case Val_GNU_MIPS_ABI_FP_NAN2008:
13501 printf (_("NaN 2008 compatibility\n"));
13502 break;
351cdf24
MF		 13503 default:
13504 printf ("??? (%d)\n", val);
13505 break;
13506 }
13507}
13508
2cf19d5c 13509static unsigned char *
f6f0e17b
NC		 13510display_mips_gnu_attribute (unsigned char * p,
13511 int tag,
13512 const unsigned char * const end)
2cf19d5c 13513{
2cf19d5c
JM		 13514 if (tag == Tag_GNU_MIPS_ABI_FP)
13515 {
f6f0e17b
NC		 13516 unsigned int len;
13517 int val;
13518
13519 val = read_uleb128 (p, &len, end);
2cf19d5c
JM		 13520 p += len;
13521 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 13522
351cdf24
MF		 13523 print_mips_fp_abi_value (val);
13524
2cf19d5c
JM		 13525 return p;
13526 }
13527
a9f58168
CF		 13528 if (tag == Tag_GNU_MIPS_ABI_MSA)
13529 {
13530 unsigned int len;
13531 int val;
13532
13533 val = read_uleb128 (p, &len, end);
13534 p += len;
13535 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13536
13537 switch (val)
13538 {
13539 case Val_GNU_MIPS_ABI_MSA_ANY:
13540 printf (_("Any MSA or not\n"));
13541 break;
13542 case Val_GNU_MIPS_ABI_MSA_128:
13543 printf (_("128-bit MSA\n"));
13544 break;
13545 default:
13546 printf ("??? (%d)\n", val);
13547 break;
13548 }
13549 return p;
13550 }
13551
f6f0e17b 13552 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM		 13553}
13554
59e6276b 13555static unsigned char *
f6f0e17b
NC		 13556display_tic6x_attribute (unsigned char * p,
13557 const unsigned char * const end)
59e6276b
JM		 13558{
13559 int tag;
13560 unsigned int len;
13561 int val;
13562
f6f0e17b 13563 tag = read_uleb128 (p, &len, end);
59e6276b
JM		 13564 p += len;
13565
13566 switch (tag)
13567 {
75fa6dc1 13568 case Tag_ISA:
f6f0e17b 13569 val = read_uleb128 (p, &len, end);
59e6276b 13570 p += len;
75fa6dc1 13571 printf (" Tag_ISA: ");
59e6276b
JM		 13572
13573 switch (val)
13574 {
75fa6dc1 13575 case C6XABI_Tag_ISA_none:
59e6276b
JM		 13576 printf (_("None\n"));
13577 break;
75fa6dc1 13578 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 13579 printf ("C62x\n");
13580 break;
75fa6dc1 13581 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 13582 printf ("C67x\n");
13583 break;
75fa6dc1 13584 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 13585 printf ("C67x+\n");
13586 break;
75fa6dc1 13587 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 13588 printf ("C64x\n");
13589 break;
75fa6dc1 13590 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 13591 printf ("C64x+\n");
13592 break;
75fa6dc1 13593 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 13594 printf ("C674x\n");
13595 break;
13596 default:
13597 printf ("??? (%d)\n", val);
13598 break;
13599 }
13600 return p;
13601
87779176 13602 case Tag_ABI_wchar_t:
f6f0e17b 13603 val = read_uleb128 (p, &len, end);
87779176
JM		 13604 p += len;
13605 printf (" Tag_ABI_wchar_t: ");
13606 switch (val)
13607 {
13608 case 0:
13609 printf (_("Not used\n"));
13610 break;
13611 case 1:
13612 printf (_("2 bytes\n"));
13613 break;
13614 case 2:
13615 printf (_("4 bytes\n"));
13616 break;
13617 default:
13618 printf ("??? (%d)\n", val);
13619 break;
13620 }
13621 return p;
13622
13623 case Tag_ABI_stack_align_needed:
f6f0e17b 13624 val = read_uleb128 (p, &len, end);
87779176
JM		 13625 p += len;
13626 printf (" Tag_ABI_stack_align_needed: ");
13627 switch (val)
13628 {
13629 case 0:
13630 printf (_("8-byte\n"));
13631 break;
13632 case 1:
13633 printf (_("16-byte\n"));
13634 break;
13635 default:
13636 printf ("??? (%d)\n", val);
13637 break;
13638 }
13639 return p;
13640
13641 case Tag_ABI_stack_align_preserved:
f6f0e17b 13642 val = read_uleb128 (p, &len, end);
87779176
JM		 13643 p += len;
13644 printf (" Tag_ABI_stack_align_preserved: ");
13645 switch (val)
13646 {
13647 case 0:
13648 printf (_("8-byte\n"));
13649 break;
13650 case 1:
13651 printf (_("16-byte\n"));
13652 break;
13653 default:
13654 printf ("??? (%d)\n", val);
13655 break;
13656 }
13657 return p;
13658
b5593623 13659 case Tag_ABI_DSBT:
f6f0e17b 13660 val = read_uleb128 (p, &len, end);
b5593623
JM		 13661 p += len;
13662 printf (" Tag_ABI_DSBT: ");
13663 switch (val)
13664 {
13665 case 0:
13666 printf (_("DSBT addressing not used\n"));
13667 break;
13668 case 1:
13669 printf (_("DSBT addressing used\n"));
13670 break;
13671 default:
13672 printf ("??? (%d)\n", val);
13673 break;
13674 }
13675 return p;
13676
87779176 13677 case Tag_ABI_PID:
f6f0e17b 13678 val = read_uleb128 (p, &len, end);
87779176
JM		 13679 p += len;
13680 printf (" Tag_ABI_PID: ");
13681 switch (val)
13682 {
13683 case 0:
13684 printf (_("Data addressing position-dependent\n"));
13685 break;
13686 case 1:
13687 printf (_("Data addressing position-independent, GOT near DP\n"));
13688 break;
13689 case 2:
13690 printf (_("Data addressing position-independent, GOT far from DP\n"));
13691 break;
13692 default:
13693 printf ("??? (%d)\n", val);
13694 break;
13695 }
13696 return p;
13697
13698 case Tag_ABI_PIC:
f6f0e17b 13699 val = read_uleb128 (p, &len, end);
87779176
JM		 13700 p += len;
13701 printf (" Tag_ABI_PIC: ");
13702 switch (val)
13703 {
13704 case 0:
13705 printf (_("Code addressing position-dependent\n"));
13706 break;
13707 case 1:
13708 printf (_("Code addressing position-independent\n"));
13709 break;
13710 default:
13711 printf ("??? (%d)\n", val);
13712 break;
13713 }
13714 return p;
13715
13716 case Tag_ABI_array_object_alignment:
f6f0e17b 13717 val = read_uleb128 (p, &len, end);
87779176
JM		 13718 p += len;
13719 printf (" Tag_ABI_array_object_alignment: ");
13720 switch (val)
13721 {
13722 case 0:
13723 printf (_("8-byte\n"));
13724 break;
13725 case 1:
13726 printf (_("4-byte\n"));
13727 break;
13728 case 2:
13729 printf (_("16-byte\n"));
13730 break;
13731 default:
13732 printf ("??? (%d)\n", val);
13733 break;
13734 }
13735 return p;
13736
13737 case Tag_ABI_array_object_align_expected:
f6f0e17b 13738 val = read_uleb128 (p, &len, end);
87779176
JM		 13739 p += len;
13740 printf (" Tag_ABI_array_object_align_expected: ");
13741 switch (val)
13742 {
13743 case 0:
13744 printf (_("8-byte\n"));
13745 break;
13746 case 1:
13747 printf (_("4-byte\n"));
13748 break;
13749 case 2:
13750 printf (_("16-byte\n"));
13751 break;
13752 default:
13753 printf ("??? (%d)\n", val);
13754 break;
13755 }
13756 return p;
13757
3cbd1c06 13758 case Tag_ABI_compatibility:
071436c6 13759 {
071436c6
NC		 13760 val = read_uleb128 (p, &len, end);
13761 p += len;
13762 printf (" Tag_ABI_compatibility: ");
071436c6 13763 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 13764 if (p < end - 1)
13765 {
13766 size_t maxlen = (end - p) - 1;
13767
13768 print_symbol ((int) maxlen, (const char *) p);
13769 p += strnlen ((char *) p, maxlen) + 1;
13770 }
13771 else
13772 {
13773 printf (_("<corrupt>"));
13774 p = (unsigned char *) end;
13775 }
071436c6 13776 putchar ('\n');
071436c6
NC		 13777 return p;
13778 }
87779176
JM		 13779
13780 case Tag_ABI_conformance:
071436c6 13781 {
4082ef84
NC		 13782 printf (" Tag_ABI_conformance: \"");
13783 if (p < end - 1)
13784 {
13785 size_t maxlen = (end - p) - 1;
071436c6 13786
4082ef84
NC		 13787 print_symbol ((int) maxlen, (const char *) p);
13788 p += strnlen ((char *) p, maxlen) + 1;
13789 }
13790 else
13791 {
13792 printf (_("<corrupt>"));
13793 p = (unsigned char *) end;
13794 }
071436c6 13795 printf ("\"\n");
071436c6
NC		 13796 return p;
13797 }
59e6276b
JM		 13798 }
13799
f6f0e17b
NC		 13800 return display_tag_value (tag, p, end);
13801}
59e6276b 13802
f6f0e17b
NC		 13803static void
13804display_raw_attribute (unsigned char * p, unsigned char * end)
13805{
13806 unsigned long addr = 0;
13807 size_t bytes = end - p;
13808
e0a31db1 13809 assert (end > p);
f6f0e17b 13810 while (bytes)
87779176 13811 {
f6f0e17b
NC		 13812 int j;
13813 int k;
13814 int lbytes = (bytes > 16 ? 16 : bytes);
13815
13816 printf (" 0x%8.8lx ", addr);
13817
13818 for (j = 0; j < 16; j++)
13819 {
13820 if (j < lbytes)
13821 printf ("%2.2x", p[j]);
13822 else
13823 printf (" ");
13824
13825 if ((j & 3) == 3)
13826 printf (" ");
13827 }
13828
13829 for (j = 0; j < lbytes; j++)
13830 {
13831 k = p[j];
13832 if (k >= ' ' && k < 0x7f)
13833 printf ("%c", k);
13834 else
13835 printf (".");
13836 }
13837
13838 putchar ('\n');
13839
13840 p += lbytes;
13841 bytes -= lbytes;
13842 addr += lbytes;
87779176 13843 }
59e6276b 13844
f6f0e17b 13845 putchar ('\n');
59e6276b
JM		 13846}
13847
13761a11
NC		 13848static unsigned char *
13849display_msp430x_attribute (unsigned char * p,
13850 const unsigned char * const end)
13851{
13852 unsigned int len;
13853 int val;
13854 int tag;
13855
13856 tag = read_uleb128 (p, & len, end);
13857 p += len;
0b4362b0 13858
13761a11
NC		 13859 switch (tag)
13860 {
13861 case OFBA_MSPABI_Tag_ISA:
13862 val = read_uleb128 (p, &len, end);
13863 p += len;
13864 printf (" Tag_ISA: ");
13865 switch (val)
13866 {
13867 case 0: printf (_("None\n")); break;
13868 case 1: printf (_("MSP430\n")); break;
13869 case 2: printf (_("MSP430X\n")); break;
13870 default: printf ("??? (%d)\n", val); break;
13871 }
13872 break;
13873
13874 case OFBA_MSPABI_Tag_Code_Model:
13875 val = read_uleb128 (p, &len, end);
13876 p += len;
13877 printf (" Tag_Code_Model: ");
13878 switch (val)
13879 {
13880 case 0: printf (_("None\n")); break;
13881 case 1: printf (_("Small\n")); break;
13882 case 2: printf (_("Large\n")); break;
13883 default: printf ("??? (%d)\n", val); break;
13884 }
13885 break;
13886
13887 case OFBA_MSPABI_Tag_Data_Model:
13888 val = read_uleb128 (p, &len, end);
13889 p += len;
13890 printf (" Tag_Data_Model: ");
13891 switch (val)
13892 {
13893 case 0: printf (_("None\n")); break;
13894 case 1: printf (_("Small\n")); break;
13895 case 2: printf (_("Large\n")); break;
13896 case 3: printf (_("Restricted Large\n")); break;
13897 default: printf ("??? (%d)\n", val); break;
13898 }
13899 break;
13900
13901 default:
13902 printf (_(" <unknown tag %d>: "), tag);
13903
13904 if (tag & 1)
13905 {
071436c6 13906 putchar ('"');
4082ef84
NC		 13907 if (p < end - 1)
13908 {
13909 size_t maxlen = (end - p) - 1;
13910
13911 print_symbol ((int) maxlen, (const char *) p);
13912 p += strnlen ((char *) p, maxlen) + 1;
13913 }
13914 else
13915 {
13916 printf (_("<corrupt>"));
13917 p = (unsigned char *) end;
13918 }
071436c6 13919 printf ("\"\n");
13761a11
NC		 13920 }
13921 else
13922 {
13923 val = read_uleb128 (p, &len, end);
13924 p += len;
13925 printf ("%d (0x%x)\n", val, val);
13926 }
13927 break;
13928 }
13929
4082ef84 13930 assert (p <= end);
13761a11
NC		 13931 return p;
13932}
13933
11c1ff18 13934static int
60bca95a
NC		 13935process_attributes (FILE * file,
13936 const char * public_name,
104d59d1 13937 unsigned int proc_type,
f6f0e17b
NC		 13938 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13939 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
11c1ff18 13940{
2cf0635d 13941 Elf_Internal_Shdr * sect;
11c1ff18
PB		 13942 unsigned i;
13943
13944 /* Find the section header so that we get the size. */
13945 for (i = 0, sect = section_headers;
13946 i < elf_header.e_shnum;
13947 i++, sect++)
13948 {
071436c6
NC		 13949 unsigned char * contents;
13950 unsigned char * p;
13951
104d59d1 13952 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 13953 continue;
13954
3f5e193b
NC		 13955 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13956 sect->sh_size, _("attributes"));
60bca95a 13957 if (contents == NULL)
11c1ff18 13958 continue;
60bca95a 13959
11c1ff18
PB		 13960 p = contents;
13961 if (*p == 'A')
13962 {
071436c6
NC		 13963 bfd_vma section_len;
13964
13965 section_len = sect->sh_size - 1;
11c1ff18 13966 p++;
60bca95a 13967
071436c6 13968 while (section_len > 0)
11c1ff18 13969 {
071436c6 13970 bfd_vma attr_len;
e9847026 13971 unsigned int namelen;
11c1ff18 13972 bfd_boolean public_section;
104d59d1 13973 bfd_boolean gnu_section;
11c1ff18 13974
071436c6 13975 if (section_len <= 4)
e0a31db1
NC		 13976 {
13977 error (_("Tag section ends prematurely\n"));
13978 break;
13979 }
071436c6 13980 attr_len = byte_get (p, 4);
11c1ff18 13981 p += 4;
60bca95a 13982
071436c6 13983 if (attr_len > section_len)
11c1ff18 13984 {
071436c6
NC		 13985 error (_("Bad attribute length (%u > %u)\n"),
13986 (unsigned) attr_len, (unsigned) section_len);
13987 attr_len = section_len;
11c1ff18 13988 }
74e1a04b 13989 /* PR 17531: file: 001-101425-0.004 */
071436c6 13990 else if (attr_len < 5)
74e1a04b 13991 {
071436c6 13992 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
74e1a04b
NC		 13993 break;
13994 }
e9847026 13995
071436c6
NC		 13996 section_len -= attr_len;
13997 attr_len -= 4;
13998
13999 namelen = strnlen ((char *) p, attr_len) + 1;
14000 if (namelen == 0 || namelen >= attr_len)
e9847026
NC		 14001 {
14002 error (_("Corrupt attribute section name\n"));
14003 break;
14004 }
14005
071436c6
NC		 14006 printf (_("Attribute Section: "));
14007 print_symbol (INT_MAX, (const char *) p);
14008 putchar ('\n');
60bca95a
NC		 14009
14010 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 14011 public_section = TRUE;
14012 else
14013 public_section = FALSE;
60bca95a
NC		 14014
14015 if (streq ((char *) p, "gnu"))
104d59d1
JM		 14016 gnu_section = TRUE;
14017 else
14018 gnu_section = FALSE;
60bca95a 14019
11c1ff18 14020 p += namelen;
071436c6 14021 attr_len -= namelen;
e0a31db1 14022
071436c6 14023 while (attr_len > 0 && p < contents + sect->sh_size)
11c1ff18 14024 {
e0a31db1 14025 int tag;
11c1ff18
PB		 14026 int val;
14027 bfd_vma size;
071436c6 14028 unsigned char * end;
60bca95a 14029
e0a31db1 14030 /* PR binutils/17531: Safe handling of corrupt files. */
071436c6 14031 if (attr_len < 6)
e0a31db1
NC		 14032 {
14033 error (_("Unused bytes at end of section\n"));
14034 section_len = 0;
14035 break;
14036 }
14037
14038 tag = *(p++);
11c1ff18 14039 size = byte_get (p, 4);
071436c6 14040 if (size > attr_len)
11c1ff18 14041 {
e9847026 14042 error (_("Bad subsection length (%u > %u)\n"),
071436c6
NC		 14043 (unsigned) size, (unsigned) attr_len);
14044 size = attr_len;
11c1ff18 14045 }
e0a31db1
NC		 14046 /* PR binutils/17531: Safe handling of corrupt files. */
14047 if (size < 6)
14048 {
14049 error (_("Bad subsection length (%u < 6)\n"),
14050 (unsigned) size);
14051 section_len = 0;
14052 break;
14053 }
60bca95a 14054
071436c6 14055 attr_len -= size;
11c1ff18 14056 end = p + size - 1;
071436c6 14057 assert (end <= contents + sect->sh_size);
11c1ff18 14058 p += 4;
60bca95a 14059
11c1ff18
PB		 14060 switch (tag)
14061 {
14062 case 1:
2b692964 14063 printf (_("File Attributes\n"));
11c1ff18
PB		 14064 break;
14065 case 2:
2b692964 14066 printf (_("Section Attributes:"));
11c1ff18
PB		 14067 goto do_numlist;
14068 case 3:
2b692964 14069 printf (_("Symbol Attributes:"));
11c1ff18
PB		 14070 do_numlist:
14071 for (;;)
14072 {
91d6fa6a 14073 unsigned int j;
60bca95a 14074
f6f0e17b 14075 val = read_uleb128 (p, &j, end);
91d6fa6a 14076 p += j;
11c1ff18
PB		 14077 if (val == 0)
14078 break;
14079 printf (" %d", val);
14080 }
14081 printf ("\n");
14082 break;
14083 default:
2b692964 14084 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 14085 public_section = FALSE;
14086 break;
14087 }
60bca95a 14088
071436c6 14089 if (public_section && display_pub_attribute != NULL)
11c1ff18
PB		 14090 {
14091 while (p < end)
f6f0e17b 14092 p = display_pub_attribute (p, end);
071436c6 14093 assert (p <= end);
104d59d1 14094 }
071436c6 14095 else if (gnu_section && display_proc_gnu_attribute != NULL)
104d59d1
JM		 14096 {
14097 while (p < end)
14098 p = display_gnu_attribute (p,
f6f0e17b
NC		 14099 display_proc_gnu_attribute,
14100 end);
071436c6 14101 assert (p <= end);
11c1ff18 14102 }
071436c6 14103 else if (p < end)
11c1ff18 14104 {
071436c6 14105 printf (_(" Unknown attribute:\n"));
f6f0e17b 14106 display_raw_attribute (p, end);
11c1ff18
PB		 14107 p = end;
14108 }
071436c6
NC		 14109 else
14110 attr_len = 0;
11c1ff18
PB		 14111 }
14112 }
14113 }
14114 else
e9847026 14115 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
d70c5fc7 14116
60bca95a 14117 free (contents);
11c1ff18
PB		 14118 }
14119 return 1;
14120}
14121
104d59d1 14122static int
2cf0635d 14123process_arm_specific (FILE * file)
104d59d1
JM		 14124{
14125 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
14126 display_arm_attribute, NULL);
14127}
14128
34c8bcba 14129static int
2cf0635d 14130process_power_specific (FILE * file)
34c8bcba
JM		 14131{
14132 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14133 display_power_gnu_attribute);
14134}
14135
643f7afb
AK		 14136static int
14137process_s390_specific (FILE * file)
14138{
14139 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14140 display_s390_gnu_attribute);
14141}
14142
9e8c70f9
DM		 14143static int
14144process_sparc_specific (FILE * file)
14145{
14146 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14147 display_sparc_gnu_attribute);
14148}
14149
59e6276b
JM		 14150static int
14151process_tic6x_specific (FILE * file)
14152{
14153 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
14154 display_tic6x_attribute, NULL);
14155}
14156
13761a11
NC		 14157static int
14158process_msp430x_specific (FILE * file)
14159{
14160 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
14161 display_msp430x_attribute, NULL);
14162}
14163
ccb4c951
RS		 14164/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14165 Print the Address, Access and Initial fields of an entry at VMA ADDR
82b1b41b
NC		 14166 and return the VMA of the next entry, or -1 if there was a problem.
14167 Does not read from DATA_END or beyond. */
ccb4c951
RS		 14168
14169static bfd_vma
82b1b41b
NC		 14170print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
14171 unsigned char * data_end)
ccb4c951
RS		 14172{
14173 printf (" ");
14174 print_vma (addr, LONG_HEX);
14175 printf (" ");
14176 if (addr < pltgot + 0xfff0)
14177 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
14178 else
14179 printf ("%10s", "");
14180 printf (" ");
14181 if (data == NULL)
2b692964 14182 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 14183 else
14184 {
14185 bfd_vma entry;
82b1b41b 14186 unsigned char * from = data + addr - pltgot;
ccb4c951 14187
82b1b41b
NC		 14188 if (from + (is_32bit_elf ? 4 : 8) > data_end)
14189 {
14190 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14191 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
14192 return (bfd_vma) -1;
14193 }
14194 else
14195 {
14196 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14197 print_vma (entry, LONG_HEX);
14198 }
ccb4c951
RS		 14199 }
14200 return addr + (is_32bit_elf ? 4 : 8);
14201}
14202
861fb55a
DJ		 14203/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14204 PLTGOT. Print the Address and Initial fields of an entry at VMA
14205 ADDR and return the VMA of the next entry. */
14206
14207static bfd_vma
2cf0635d 14208print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 14209{
14210 printf (" ");
14211 print_vma (addr, LONG_HEX);
14212 printf (" ");
14213 if (data == NULL)
2b692964 14214 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 14215 else
14216 {
14217 bfd_vma entry;
14218
14219 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14220 print_vma (entry, LONG_HEX);
14221 }
14222 return addr + (is_32bit_elf ? 4 : 8);
14223}
14224
351cdf24
MF		 14225static void
14226print_mips_ases (unsigned int mask)
14227{
14228 if (mask & AFL_ASE_DSP)
14229 fputs ("\n\tDSP ASE", stdout);
14230 if (mask & AFL_ASE_DSPR2)
14231 fputs ("\n\tDSP R2 ASE", stdout);
8f4f9071
MF		 14232 if (mask & AFL_ASE_DSPR3)
14233 fputs ("\n\tDSP R3 ASE", stdout);
351cdf24
MF		 14234 if (mask & AFL_ASE_EVA)
14235 fputs ("\n\tEnhanced VA Scheme", stdout);
14236 if (mask & AFL_ASE_MCU)
14237 fputs ("\n\tMCU (MicroController) ASE", stdout);
14238 if (mask & AFL_ASE_MDMX)
14239 fputs ("\n\tMDMX ASE", stdout);
14240 if (mask & AFL_ASE_MIPS3D)
14241 fputs ("\n\tMIPS-3D ASE", stdout);
14242 if (mask & AFL_ASE_MT)
14243 fputs ("\n\tMT ASE", stdout);
14244 if (mask & AFL_ASE_SMARTMIPS)
14245 fputs ("\n\tSmartMIPS ASE", stdout);
14246 if (mask & AFL_ASE_VIRT)
14247 fputs ("\n\tVZ ASE", stdout);
14248 if (mask & AFL_ASE_MSA)
14249 fputs ("\n\tMSA ASE", stdout);
14250 if (mask & AFL_ASE_MIPS16)
14251 fputs ("\n\tMIPS16 ASE", stdout);
14252 if (mask & AFL_ASE_MICROMIPS)
14253 fputs ("\n\tMICROMIPS ASE", stdout);
14254 if (mask & AFL_ASE_XPA)
14255 fputs ("\n\tXPA ASE", stdout);
14256 if (mask == 0)
14257 fprintf (stdout, "\n\t%s", _("None"));
00ac7aa0
MF		 14258 else if ((mask & ~AFL_ASE_MASK) != 0)
14259 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
351cdf24
MF		 14260}
14261
14262static void
14263print_mips_isa_ext (unsigned int isa_ext)
14264{
14265 switch (isa_ext)
14266 {
14267 case 0:
14268 fputs (_("None"), stdout);
14269 break;
14270 case AFL_EXT_XLR:
14271 fputs ("RMI XLR", stdout);
14272 break;
2c629856
N		 14273 case AFL_EXT_OCTEON3:
14274 fputs ("Cavium Networks Octeon3", stdout);
14275 break;
351cdf24
MF		 14276 case AFL_EXT_OCTEON2:
14277 fputs ("Cavium Networks Octeon2", stdout);
14278 break;
14279 case AFL_EXT_OCTEONP:
14280 fputs ("Cavium Networks OcteonP", stdout);
14281 break;
14282 case AFL_EXT_LOONGSON_3A:
14283 fputs ("Loongson 3A", stdout);
14284 break;
14285 case AFL_EXT_OCTEON:
14286 fputs ("Cavium Networks Octeon", stdout);
14287 break;
14288 case AFL_EXT_5900:
14289 fputs ("Toshiba R5900", stdout);
14290 break;
14291 case AFL_EXT_4650:
14292 fputs ("MIPS R4650", stdout);
14293 break;
14294 case AFL_EXT_4010:
14295 fputs ("LSI R4010", stdout);
14296 break;
14297 case AFL_EXT_4100:
14298 fputs ("NEC VR4100", stdout);
14299 break;
14300 case AFL_EXT_3900:
14301 fputs ("Toshiba R3900", stdout);
14302 break;
14303 case AFL_EXT_10000:
14304 fputs ("MIPS R10000", stdout);
14305 break;
14306 case AFL_EXT_SB1:
14307 fputs ("Broadcom SB-1", stdout);
14308 break;
14309 case AFL_EXT_4111:
14310 fputs ("NEC VR4111/VR4181", stdout);
14311 break;
14312 case AFL_EXT_4120:
14313 fputs ("NEC VR4120", stdout);
14314 break;
14315 case AFL_EXT_5400:
14316 fputs ("NEC VR5400", stdout);
14317 break;
14318 case AFL_EXT_5500:
14319 fputs ("NEC VR5500", stdout);
14320 break;
14321 case AFL_EXT_LOONGSON_2E:
14322 fputs ("ST Microelectronics Loongson 2E", stdout);
14323 break;
14324 case AFL_EXT_LOONGSON_2F:
14325 fputs ("ST Microelectronics Loongson 2F", stdout);
14326 break;
14327 default:
00ac7aa0 14328 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
351cdf24
MF		 14329 }
14330}
14331
14332static int
14333get_mips_reg_size (int reg_size)
14334{
14335 return (reg_size == AFL_REG_NONE) ? 0
14336 : (reg_size == AFL_REG_32) ? 32
14337 : (reg_size == AFL_REG_64) ? 64
14338 : (reg_size == AFL_REG_128) ? 128
14339 : -1;
14340}
14341
19e6b90e 14342static int
2cf0635d 14343process_mips_specific (FILE * file)
5b18a4bc 14344{
2cf0635d 14345 Elf_Internal_Dyn * entry;
351cdf24 14346 Elf_Internal_Shdr *sect = NULL;
19e6b90e
L		 14347 size_t liblist_offset = 0;
14348 size_t liblistno = 0;
14349 size_t conflictsno = 0;
14350 size_t options_offset = 0;
14351 size_t conflicts_offset = 0;
861fb55a
DJ		 14352 size_t pltrelsz = 0;
14353 size_t pltrel = 0;
ccb4c951 14354 bfd_vma pltgot = 0;
861fb55a
DJ		 14355 bfd_vma mips_pltgot = 0;
14356 bfd_vma jmprel = 0;
ccb4c951
RS		 14357 bfd_vma local_gotno = 0;
14358 bfd_vma gotsym = 0;
14359 bfd_vma symtabno = 0;
103f02d3 14360
2cf19d5c
JM		 14361 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14362 display_mips_gnu_attribute);
14363
351cdf24
MF		 14364 sect = find_section (".MIPS.abiflags");
14365
14366 if (sect != NULL)
14367 {
14368 Elf_External_ABIFlags_v0 *abiflags_ext;
14369 Elf_Internal_ABIFlags_v0 abiflags_in;
14370
14371 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
14372 fputs ("\nCorrupt ABI Flags section.\n", stdout);
14373 else
14374 {
14375 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
14376 sect->sh_size, _("MIPS ABI Flags section"));
14377 if (abiflags_ext)
14378 {
14379 abiflags_in.version = BYTE_GET (abiflags_ext->version);
14380 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
14381 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
14382 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
14383 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
14384 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
14385 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
14386 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
14387 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
14388 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
14389 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
14390
14391 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
14392 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
14393 if (abiflags_in.isa_rev > 1)
14394 printf ("r%d", abiflags_in.isa_rev);
14395 printf ("\nGPR size: %d",
14396 get_mips_reg_size (abiflags_in.gpr_size));
14397 printf ("\nCPR1 size: %d",
14398 get_mips_reg_size (abiflags_in.cpr1_size));
14399 printf ("\nCPR2 size: %d",
14400 get_mips_reg_size (abiflags_in.cpr2_size));
14401 fputs ("\nFP ABI: ", stdout);
14402 print_mips_fp_abi_value (abiflags_in.fp_abi);
14403 fputs ("ISA Extension: ", stdout);
14404 print_mips_isa_ext (abiflags_in.isa_ext);
14405 fputs ("\nASEs:", stdout);
14406 print_mips_ases (abiflags_in.ases);
14407 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
14408 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
14409 fputc ('\n', stdout);
14410 free (abiflags_ext);
14411 }
14412 }
14413 }
14414
19e6b90e
L		 14415 /* We have a lot of special sections. Thanks SGI! */
14416 if (dynamic_section == NULL)
14417 /* No information available. */
14418 return 0;
252b5132 14419
071436c6
NC		 14420 for (entry = dynamic_section;
14421 /* PR 17531 file: 012-50589-0.004. */
14422 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
14423 ++entry)
252b5132
RH		 14424 switch (entry->d_tag)
14425 {
14426 case DT_MIPS_LIBLIST:
d93f0186
NC		 14427 liblist_offset
14428 = offset_from_vma (file, entry->d_un.d_val,
14429 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 14430 break;
14431 case DT_MIPS_LIBLISTNO:
14432 liblistno = entry->d_un.d_val;
14433 break;
14434 case DT_MIPS_OPTIONS:
d93f0186 14435 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 14436 break;
14437 case DT_MIPS_CONFLICT:
d93f0186
NC		 14438 conflicts_offset
14439 = offset_from_vma (file, entry->d_un.d_val,
14440 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 14441 break;
14442 case DT_MIPS_CONFLICTNO:
14443 conflictsno = entry->d_un.d_val;
14444 break;
ccb4c951 14445 case DT_PLTGOT:
861fb55a
DJ		 14446 pltgot = entry->d_un.d_ptr;
14447 break;
ccb4c951
RS		 14448 case DT_MIPS_LOCAL_GOTNO:
14449 local_gotno = entry->d_un.d_val;
14450 break;
14451 case DT_MIPS_GOTSYM:
14452 gotsym = entry->d_un.d_val;
14453 break;
14454 case DT_MIPS_SYMTABNO:
14455 symtabno = entry->d_un.d_val;
14456 break;
861fb55a
DJ		 14457 case DT_MIPS_PLTGOT:
14458 mips_pltgot = entry->d_un.d_ptr;
14459 break;
14460 case DT_PLTREL:
14461 pltrel = entry->d_un.d_val;
14462 break;
14463 case DT_PLTRELSZ:
14464 pltrelsz = entry->d_un.d_val;
14465 break;
14466 case DT_JMPREL:
14467 jmprel = entry->d_un.d_ptr;
14468 break;
252b5132
RH		 14469 default:
14470 break;
14471 }
14472
14473 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
14474 {
2cf0635d 14475 Elf32_External_Lib * elib;
252b5132
RH		 14476 size_t cnt;
14477
3f5e193b
NC		 14478 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
14479 liblistno,
14480 sizeof (Elf32_External_Lib),
9cf03b7e 14481 _("liblist section data"));
a6e9f9df 14482 if (elib)
252b5132 14483 {
2b692964 14484 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 14485 (unsigned long) liblistno);
2b692964 14486 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 14487 stdout);
14488
14489 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 14490 {
a6e9f9df 14491 Elf32_Lib liblist;
91d6fa6a 14492 time_t atime;
a6e9f9df 14493 char timebuf[20];
2cf0635d 14494 struct tm * tmp;
a6e9f9df
AM		 14495
14496 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14497 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 14498 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14499 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14500 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14501
91d6fa6a 14502 tmp = gmtime (&atime);
e9e44622
JJ		 14503 snprintf (timebuf, sizeof (timebuf),
14504 "%04u-%02u-%02uT%02u:%02u:%02u",
14505 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14506 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 14507
31104126 14508 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 14509 if (VALID_DYNAMIC_NAME (liblist.l_name))
14510 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
14511 else
2b692964 14512 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 14513 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
14514 liblist.l_version);
a6e9f9df
AM		 14515
14516 if (liblist.l_flags == 0)
2b692964 14517 puts (_(" NONE"));
a6e9f9df
AM		 14518 else
14519 {
14520 static const struct
252b5132 14521 {
2cf0635d 14522 const char * name;
a6e9f9df 14523 int bit;
252b5132 14524 }
a6e9f9df
AM		 14525 l_flags_vals[] =
14526 {
14527 { " EXACT_MATCH", LL_EXACT_MATCH },
14528 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
14529 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
14530 { " EXPORTS", LL_EXPORTS },
14531 { " DELAY_LOAD", LL_DELAY_LOAD },
14532 { " DELTA", LL_DELTA }
14533 };
14534 int flags = liblist.l_flags;
14535 size_t fcnt;
14536
60bca95a 14537 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 14538 if ((flags & l_flags_vals[fcnt].bit) != 0)
14539 {
14540 fputs (l_flags_vals[fcnt].name, stdout);
14541 flags ^= l_flags_vals[fcnt].bit;
14542 }
14543 if (flags != 0)
14544 printf (" %#x", (unsigned int) flags);
252b5132 14545
a6e9f9df
AM		 14546 puts ("");
14547 }
252b5132 14548 }
252b5132 14549
a6e9f9df
AM		 14550 free (elib);
14551 }
252b5132
RH		 14552 }
14553
14554 if (options_offset != 0)
14555 {
2cf0635d 14556 Elf_External_Options * eopt;
2cf0635d
NC		 14557 Elf_Internal_Options * iopt;
14558 Elf_Internal_Options * option;
252b5132
RH		 14559 size_t offset;
14560 int cnt;
351cdf24 14561 sect = section_headers;
252b5132
RH		 14562
14563 /* Find the section header so that we get the size. */
071436c6 14564 sect = find_section_by_type (SHT_MIPS_OPTIONS);
948f632f 14565 /* PR 17533 file: 012-277276-0.004. */
071436c6
NC		 14566 if (sect == NULL)
14567 {
14568 error (_("No MIPS_OPTIONS header found\n"));
14569 return 0;
14570 }
252b5132 14571
3f5e193b
NC		 14572 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
14573 sect->sh_size, _("options"));
a6e9f9df 14574 if (eopt)
252b5132 14575 {
3f5e193b
NC		 14576 iopt = (Elf_Internal_Options *)
14577 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 14578 if (iopt == NULL)
14579 {
8b73c356 14580 error (_("Out of memory allocatinf space for MIPS options\n"));
a6e9f9df
AM		 14581 return 0;
14582 }
76da6bbe 14583
a6e9f9df
AM		 14584 offset = cnt = 0;
14585 option = iopt;
252b5132 14586
82b1b41b 14587 while (offset <= sect->sh_size - sizeof (* eopt))
a6e9f9df 14588 {
2cf0635d 14589 Elf_External_Options * eoption;
252b5132 14590
a6e9f9df 14591 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 14592
a6e9f9df
AM		 14593 option->kind = BYTE_GET (eoption->kind);
14594 option->size = BYTE_GET (eoption->size);
14595 option->section = BYTE_GET (eoption->section);
14596 option->info = BYTE_GET (eoption->info);
76da6bbe 14597
82b1b41b
NC		 14598 /* PR 17531: file: ffa0fa3b. */
14599 if (option->size < sizeof (* eopt)
14600 || offset + option->size > sect->sh_size)
14601 {
55325047
NC		 14602 error (_("Invalid size (%u) for MIPS option\n"), option->size);
14603 return 0;
82b1b41b 14604 }
a6e9f9df 14605 offset += option->size;
14ae95f2 14606
a6e9f9df
AM		 14607 ++option;
14608 ++cnt;
14609 }
252b5132 14610
a6e9f9df 14611 printf (_("\nSection '%s' contains %d entries:\n"),
74e1a04b 14612 printable_section_name (sect), cnt);
76da6bbe 14613
a6e9f9df 14614 option = iopt;
82b1b41b 14615 offset = 0;
252b5132 14616
a6e9f9df 14617 while (cnt-- > 0)
252b5132 14618 {
a6e9f9df
AM		 14619 size_t len;
14620
14621 switch (option->kind)
252b5132 14622 {
a6e9f9df
AM		 14623 case ODK_NULL:
14624 /* This shouldn't happen. */
14625 printf (" NULL %d %lx", option->section, option->info);
14626 break;
14627 case ODK_REGINFO:
14628 printf (" REGINFO ");
14629 if (elf_header.e_machine == EM_MIPS)
14630 {
14631 /* 32bit form. */
2cf0635d 14632 Elf32_External_RegInfo * ereg;
b34976b6 14633 Elf32_RegInfo reginfo;
a6e9f9df
AM		 14634
14635 ereg = (Elf32_External_RegInfo *) (option + 1);
14636 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14637 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14638 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14639 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14640 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14641 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14642
14643 printf ("GPR %08lx GP 0x%lx\n",
14644 reginfo.ri_gprmask,
14645 (unsigned long) reginfo.ri_gp_value);
14646 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14647 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14648 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14649 }
14650 else
14651 {
14652 /* 64 bit form. */
2cf0635d 14653 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 14654 Elf64_Internal_RegInfo reginfo;
14655
14656 ereg = (Elf64_External_RegInfo *) (option + 1);
14657 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14658 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14659 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14660 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14661 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 14662 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 14663
14664 printf ("GPR %08lx GP 0x",
14665 reginfo.ri_gprmask);
14666 printf_vma (reginfo.ri_gp_value);
14667 printf ("\n");
14668
14669 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14670 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14671 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14672 }
14673 ++option;
14674 continue;
14675 case ODK_EXCEPTIONS:
14676 fputs (" EXCEPTIONS fpe_min(", stdout);
14677 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
14678 fputs (") fpe_max(", stdout);
14679 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
14680 fputs (")", stdout);
14681
14682 if (option->info & OEX_PAGE0)
14683 fputs (" PAGE0", stdout);
14684 if (option->info & OEX_SMM)
14685 fputs (" SMM", stdout);
14686 if (option->info & OEX_FPDBUG)
14687 fputs (" FPDBUG", stdout);
14688 if (option->info & OEX_DISMISS)
14689 fputs (" DISMISS", stdout);
14690 break;
14691 case ODK_PAD:
14692 fputs (" PAD ", stdout);
14693 if (option->info & OPAD_PREFIX)
14694 fputs (" PREFIX", stdout);
14695 if (option->info & OPAD_POSTFIX)
14696 fputs (" POSTFIX", stdout);
14697 if (option->info & OPAD_SYMBOL)
14698 fputs (" SYMBOL", stdout);
14699 break;
14700 case ODK_HWPATCH:
14701 fputs (" HWPATCH ", stdout);
14702 if (option->info & OHW_R4KEOP)
14703 fputs (" R4KEOP", stdout);
14704 if (option->info & OHW_R8KPFETCH)
14705 fputs (" R8KPFETCH", stdout);
14706 if (option->info & OHW_R5KEOP)
14707 fputs (" R5KEOP", stdout);
14708 if (option->info & OHW_R5KCVTL)
14709 fputs (" R5KCVTL", stdout);
14710 break;
14711 case ODK_FILL:
14712 fputs (" FILL ", stdout);
14713 /* XXX Print content of info word? */
14714 break;
14715 case ODK_TAGS:
14716 fputs (" TAGS ", stdout);
14717 /* XXX Print content of info word? */
14718 break;
14719 case ODK_HWAND:
14720 fputs (" HWAND ", stdout);
14721 if (option->info & OHWA0_R4KEOP_CHECKED)
14722 fputs (" R4KEOP_CHECKED", stdout);
14723 if (option->info & OHWA0_R4KEOP_CLEAN)
14724 fputs (" R4KEOP_CLEAN", stdout);
14725 break;
14726 case ODK_HWOR:
14727 fputs (" HWOR ", stdout);
14728 if (option->info & OHWA0_R4KEOP_CHECKED)
14729 fputs (" R4KEOP_CHECKED", stdout);
14730 if (option->info & OHWA0_R4KEOP_CLEAN)
14731 fputs (" R4KEOP_CLEAN", stdout);
14732 break;
14733 case ODK_GP_GROUP:
14734 printf (" GP_GROUP %#06lx self-contained %#06lx",
14735 option->info & OGP_GROUP,
14736 (option->info & OGP_SELF) >> 16);
14737 break;
14738 case ODK_IDENT:
14739 printf (" IDENT %#06lx self-contained %#06lx",
14740 option->info & OGP_GROUP,
14741 (option->info & OGP_SELF) >> 16);
14742 break;
14743 default:
14744 /* This shouldn't happen. */
14745 printf (" %3d ??? %d %lx",
14746 option->kind, option->section, option->info);
14747 break;
252b5132 14748 }
a6e9f9df 14749
2cf0635d 14750 len = sizeof (* eopt);
a6e9f9df 14751 while (len < option->size)
82b1b41b 14752 {
7e27a9d5 14753 unsigned char datum = * ((unsigned char *) eopt + offset + len);
a6e9f9df 14754
82b1b41b
NC		 14755 if (ISPRINT (datum))
14756 printf ("%c", datum);
14757 else
14758 printf ("\\%03o", datum);
14759 len ++;
14760 }
a6e9f9df 14761 fputs ("\n", stdout);
82b1b41b
NC		 14762
14763 offset += option->size;
252b5132 14764 ++option;
252b5132
RH		 14765 }
14766
a6e9f9df 14767 free (eopt);
252b5132 14768 }
252b5132
RH		 14769 }
14770
14771 if (conflicts_offset != 0 && conflictsno != 0)
14772 {
2cf0635d 14773 Elf32_Conflict * iconf;
252b5132
RH		 14774 size_t cnt;
14775
14776 if (dynamic_symbols == NULL)
14777 {
591a748a 14778 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 14779 return 0;
14780 }
14781
3f5e193b 14782 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 14783 if (iconf == NULL)
14784 {
8b73c356 14785 error (_("Out of memory allocating space for dynamic conflicts\n"));
252b5132
RH		 14786 return 0;
14787 }
14788
9ea033b2 14789 if (is_32bit_elf)
252b5132 14790 {
2cf0635d 14791 Elf32_External_Conflict * econf32;
a6e9f9df 14792
3f5e193b
NC		 14793 econf32 = (Elf32_External_Conflict *)
14794 get_data (NULL, file, conflicts_offset, conflictsno,
14795 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 14796 if (!econf32)
14797 return 0;
252b5132
RH		 14798
14799 for (cnt = 0; cnt < conflictsno; ++cnt)
14800 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 14801
14802 free (econf32);
252b5132
RH		 14803 }
14804 else
14805 {
2cf0635d 14806 Elf64_External_Conflict * econf64;
a6e9f9df 14807
3f5e193b
NC		 14808 econf64 = (Elf64_External_Conflict *)
14809 get_data (NULL, file, conflicts_offset, conflictsno,
14810 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 14811 if (!econf64)
14812 return 0;
252b5132
RH		 14813
14814 for (cnt = 0; cnt < conflictsno; ++cnt)
14815 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 14816
14817 free (econf64);
252b5132
RH		 14818 }
14819
c7e7ca54
NC		 14820 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14821 (unsigned long) conflictsno);
252b5132
RH		 14822 puts (_(" Num: Index Value Name"));
14823
14824 for (cnt = 0; cnt < conflictsno; ++cnt)
14825 {
b34976b6 14826 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
e0a31db1
NC		 14827
14828 if (iconf[cnt] >= num_dynamic_syms)
14829 printf (_("<corrupt symbol index>"));
d79b3d50 14830 else
e0a31db1
NC		 14831 {
14832 Elf_Internal_Sym * psym;
14833
14834 psym = & dynamic_symbols[iconf[cnt]];
14835 print_vma (psym->st_value, FULL_HEX);
14836 putchar (' ');
14837 if (VALID_DYNAMIC_NAME (psym->st_name))
14838 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14839 else
14840 printf (_("<corrupt: %14ld>"), psym->st_name);
14841 }
31104126 14842 putchar ('\n');
252b5132
RH		 14843 }
14844
252b5132
RH		 14845 free (iconf);
14846 }
14847
ccb4c951
RS		 14848 if (pltgot != 0 && local_gotno != 0)
14849 {
91d6fa6a 14850 bfd_vma ent, local_end, global_end;
bbeee7ea 14851 size_t i, offset;
2cf0635d 14852 unsigned char * data;
82b1b41b 14853 unsigned char * data_end;
bbeee7ea 14854 int addr_size;
ccb4c951 14855
91d6fa6a 14856 ent = pltgot;
ccb4c951
RS		 14857 addr_size = (is_32bit_elf ? 4 : 8);
14858 local_end = pltgot + local_gotno * addr_size;
ccb4c951 14859
74e1a04b
NC		 14860 /* PR binutils/17533 file: 012-111227-0.004 */
14861 if (symtabno < gotsym)
14862 {
14863 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
82b1b41b 14864 (unsigned long) gotsym, (unsigned long) symtabno);
74e1a04b
NC		 14865 return 0;
14866 }
82b1b41b 14867
74e1a04b 14868 global_end = local_end + (symtabno - gotsym) * addr_size;
82b1b41b
NC		 14869 /* PR 17531: file: 54c91a34. */
14870 if (global_end < local_end)
14871 {
14872 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14873 return 0;
14874 }
948f632f 14875
ccb4c951 14876 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 14877 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 14878 global_end - pltgot, 1,
14879 _("Global Offset Table data"));
59245841
NC		 14880 if (data == NULL)
14881 return 0;
82b1b41b 14882 data_end = data + (global_end - pltgot);
59245841 14883
ccb4c951
RS		 14884 printf (_("\nPrimary GOT:\n"));
14885 printf (_(" Canonical gp value: "));
14886 print_vma (pltgot + 0x7ff0, LONG_HEX);
14887 printf ("\n\n");
14888
14889 printf (_(" Reserved entries:\n"));
14890 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 14891 addr_size * 2, _("Address"), _("Access"),
14892 addr_size * 2, _("Initial"));
82b1b41b 14893 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14894 printf (_(" Lazy resolver\n"));
82b1b41b
NC		 14895 if (ent == (bfd_vma) -1)
14896 goto got_print_fail;
ccb4c951 14897 if (data
91d6fa6a 14898 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 14899 >> (addr_size * 8 - 1)) != 0)
14900 {
82b1b41b 14901 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14902 printf (_(" Module pointer (GNU extension)\n"));
82b1b41b
NC		 14903 if (ent == (bfd_vma) -1)
14904 goto got_print_fail;
ccb4c951
RS		 14905 }
14906 printf ("\n");
14907
91d6fa6a 14908 if (ent < local_end)
ccb4c951
RS		 14909 {
14910 printf (_(" Local entries:\n"));
cc5914eb 14911 printf (" %*s %10s %*s\n",
2b692964
NC		 14912 addr_size * 2, _("Address"), _("Access"),
14913 addr_size * 2, _("Initial"));
91d6fa6a 14914 while (ent < local_end)
ccb4c951 14915 {
82b1b41b 14916 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14917 printf ("\n");
82b1b41b
NC		 14918 if (ent == (bfd_vma) -1)
14919 goto got_print_fail;
ccb4c951
RS		 14920 }
14921 printf ("\n");
14922 }
14923
14924 if (gotsym < symtabno)
14925 {
14926 int sym_width;
14927
14928 printf (_(" Global entries:\n"));
cc5914eb 14929 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 14930 addr_size * 2, _("Address"),
14931 _("Access"),
2b692964 14932 addr_size * 2, _("Initial"),
9cf03b7e
NC		 14933 addr_size * 2, _("Sym.Val."),
14934 _("Type"),
14935 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14936 _("Ndx"), _("Name"));
0b4362b0 14937
ccb4c951 14938 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
e0a31db1 14939
ccb4c951
RS		 14940 for (i = gotsym; i < symtabno; i++)
14941 {
82b1b41b 14942 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14943 printf (" ");
e0a31db1
NC		 14944
14945 if (dynamic_symbols == NULL)
14946 printf (_("<no dynamic symbols>"));
14947 else if (i < num_dynamic_syms)
14948 {
14949 Elf_Internal_Sym * psym = dynamic_symbols + i;
14950
14951 print_vma (psym->st_value, LONG_HEX);
14952 printf (" %-7s %3s ",
14953 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14954 get_symbol_index_type (psym->st_shndx));
14955
14956 if (VALID_DYNAMIC_NAME (psym->st_name))
14957 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14958 else
14959 printf (_("<corrupt: %14ld>"), psym->st_name);
14960 }
ccb4c951 14961 else
7fc5ac57
JBG		 14962 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14963 (unsigned long) i);
e0a31db1 14964
ccb4c951 14965 printf ("\n");
82b1b41b
NC		 14966 if (ent == (bfd_vma) -1)
14967 break;
ccb4c951
RS		 14968 }
14969 printf ("\n");
14970 }
14971
82b1b41b 14972 got_print_fail:
ccb4c951
RS		 14973 if (data)
14974 free (data);
14975 }
14976
861fb55a
DJ		 14977 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14978 {
91d6fa6a 14979 bfd_vma ent, end;
861fb55a
DJ		 14980 size_t offset, rel_offset;
14981 unsigned long count, i;
2cf0635d 14982 unsigned char * data;
861fb55a 14983 int addr_size, sym_width;
2cf0635d 14984 Elf_Internal_Rela * rels;
861fb55a
DJ		 14985
14986 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14987 if (pltrel == DT_RELA)
14988 {
14989 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14990 return 0;
14991 }
14992 else
14993 {
14994 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14995 return 0;
14996 }
14997
91d6fa6a 14998 ent = mips_pltgot;
861fb55a
DJ		 14999 addr_size = (is_32bit_elf ? 4 : 8);
15000 end = mips_pltgot + (2 + count) * addr_size;
15001
15002 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 15003 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 15004 1, _("Procedure Linkage Table data"));
59245841
NC		 15005 if (data == NULL)
15006 return 0;
15007
9cf03b7e 15008 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 15009 printf (_(" Reserved entries:\n"));
15010 printf (_(" %*s %*s Purpose\n"),
2b692964 15011 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 15012 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 15013 printf (_(" PLT lazy resolver\n"));
91d6fa6a 15014 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 15015 printf (_(" Module pointer\n"));
861fb55a
DJ		 15016 printf ("\n");
15017
15018 printf (_(" Entries:\n"));
cc5914eb 15019 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 15020 addr_size * 2, _("Address"),
15021 addr_size * 2, _("Initial"),
15022 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 15023 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
15024 for (i = 0; i < count; i++)
15025 {
df97ab2a 15026 unsigned long idx = get_reloc_symindex (rels[i].r_info);
861fb55a 15027
91d6fa6a 15028 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a 15029 printf (" ");
e0a31db1 15030
df97ab2a
MF		 15031 if (idx >= num_dynamic_syms)
15032 printf (_("<corrupt symbol index: %lu>"), idx);
861fb55a 15033 else
e0a31db1 15034 {
df97ab2a 15035 Elf_Internal_Sym * psym = dynamic_symbols + idx;
e0a31db1
NC		 15036
15037 print_vma (psym->st_value, LONG_HEX);
15038 printf (" %-7s %3s ",
15039 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
15040 get_symbol_index_type (psym->st_shndx));
15041 if (VALID_DYNAMIC_NAME (psym->st_name))
15042 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
15043 else
15044 printf (_("<corrupt: %14ld>"), psym->st_name);
15045 }
861fb55a
DJ		 15046 printf ("\n");
15047 }
15048 printf ("\n");
15049
15050 if (data)
15051 free (data);
15052 free (rels);
15053 }
15054
252b5132
RH		 15055 return 1;
15056}
15057
35c08157
KLC		 15058static int
15059process_nds32_specific (FILE * file)
15060{
15061 Elf_Internal_Shdr *sect = NULL;
15062
15063 sect = find_section (".nds32_e_flags");
15064 if (sect != NULL)
15065 {
15066 unsigned int *flag;
15067
15068 printf ("\nNDS32 elf flags section:\n");
15069 flag = get_data (NULL, file, sect->sh_offset, 1,
15070 sect->sh_size, _("NDS32 elf flags section"));
15071
15072 switch ((*flag) & 0x3)
15073 {
15074 case 0:
15075 printf ("(VEC_SIZE):\tNo entry.\n");
15076 break;
15077 case 1:
15078 printf ("(VEC_SIZE):\t4 bytes\n");
15079 break;
15080 case 2:
15081 printf ("(VEC_SIZE):\t16 bytes\n");
15082 break;
15083 case 3:
15084 printf ("(VEC_SIZE):\treserved\n");
15085 break;
15086 }
15087 }
15088
15089 return TRUE;
15090}
15091
047b2264 15092static int
2cf0635d 15093process_gnu_liblist (FILE * file)
047b2264 15094{
2cf0635d
NC		 15095 Elf_Internal_Shdr * section;
15096 Elf_Internal_Shdr * string_sec;
15097 Elf32_External_Lib * elib;
15098 char * strtab;
c256ffe7 15099 size_t strtab_size;
047b2264
JJ		 15100 size_t cnt;
15101 unsigned i;
15102
15103 if (! do_arch)
15104 return 0;
15105
15106 for (i = 0, section = section_headers;
15107 i < elf_header.e_shnum;
b34976b6 15108 i++, section++)
047b2264
JJ		 15109 {
15110 switch (section->sh_type)
15111 {
15112 case SHT_GNU_LIBLIST:
4fbb74a6 15113 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 15114 break;
15115
3f5e193b
NC		 15116 elib = (Elf32_External_Lib *)
15117 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 15118 _("liblist section data"));
047b2264
JJ		 15119
15120 if (elib == NULL)
15121 break;
4fbb74a6 15122 string_sec = section_headers + section->sh_link;
047b2264 15123
3f5e193b
NC		 15124 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
15125 string_sec->sh_size,
15126 _("liblist string table"));
047b2264
JJ		 15127 if (strtab == NULL
15128 || section->sh_entsize != sizeof (Elf32_External_Lib))
15129 {
15130 free (elib);
2842702f 15131 free (strtab);
047b2264
JJ		 15132 break;
15133 }
59245841 15134 strtab_size = string_sec->sh_size;
047b2264
JJ		 15135
15136 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
74e1a04b 15137 printable_section_name (section),
0af1713e 15138 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 15139
2b692964 15140 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 15141
15142 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
15143 ++cnt)
15144 {
15145 Elf32_Lib liblist;
91d6fa6a 15146 time_t atime;
047b2264 15147 char timebuf[20];
2cf0635d 15148 struct tm * tmp;
047b2264
JJ		 15149
15150 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 15151 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 15152 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15153 liblist.l_version = BYTE_GET (elib[cnt].l_version);
15154 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15155
91d6fa6a 15156 tmp = gmtime (&atime);
e9e44622
JJ		 15157 snprintf (timebuf, sizeof (timebuf),
15158 "%04u-%02u-%02uT%02u:%02u:%02u",
15159 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15160 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 15161
15162 printf ("%3lu: ", (unsigned long) cnt);
15163 if (do_wide)
c256ffe7 15164 printf ("%-20s", liblist.l_name < strtab_size
2b692964 15165 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 15166 else
c256ffe7 15167 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 15168 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 15169 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
15170 liblist.l_version, liblist.l_flags);
15171 }
15172
15173 free (elib);
2842702f 15174 free (strtab);
047b2264
JJ		 15175 }
15176 }
15177
15178 return 1;
15179}
15180
9437c45b 15181static const char *
d3ba0551 15182get_note_type (unsigned e_type)
779fe533
NC		 15183{
15184 static char buff[64];
103f02d3 15185
1ec5cd37
NC		 15186 if (elf_header.e_type == ET_CORE)
15187 switch (e_type)
15188 {
57346661 15189 case NT_AUXV:
1ec5cd37 15190 return _("NT_AUXV (auxiliary vector)");
57346661 15191 case NT_PRSTATUS:
1ec5cd37 15192 return _("NT_PRSTATUS (prstatus structure)");
57346661 15193 case NT_FPREGSET:
1ec5cd37 15194 return _("NT_FPREGSET (floating point registers)");
57346661 15195 case NT_PRPSINFO:
1ec5cd37 15196 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 15197 case NT_TASKSTRUCT:
1ec5cd37 15198 return _("NT_TASKSTRUCT (task structure)");
57346661 15199 case NT_PRXFPREG:
1ec5cd37 15200 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 15201 case NT_PPC_VMX:
15202 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 15203 case NT_PPC_VSX:
15204 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 15205 case NT_386_TLS:
15206 return _("NT_386_TLS (x86 TLS information)");
15207 case NT_386_IOPERM:
15208 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 15209 case NT_X86_XSTATE:
15210 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 15211 case NT_S390_HIGH_GPRS:
15212 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 15213 case NT_S390_TIMER:
15214 return _("NT_S390_TIMER (s390 timer register)");
15215 case NT_S390_TODCMP:
15216 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15217 case NT_S390_TODPREG:
15218 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15219 case NT_S390_CTRS:
15220 return _("NT_S390_CTRS (s390 control registers)");
15221 case NT_S390_PREFIX:
15222 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 15223 case NT_S390_LAST_BREAK:
15224 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15225 case NT_S390_SYSTEM_CALL:
15226 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC		 15227 case NT_S390_TDB:
15228 return _("NT_S390_TDB (s390 transaction diagnostic block)");
4ef9f41a
AA		 15229 case NT_S390_VXRS_LOW:
15230 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15231 case NT_S390_VXRS_HIGH:
15232 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
faa9a424
UW		 15233 case NT_ARM_VFP:
15234 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 15235 case NT_ARM_TLS:
15236 return _("NT_ARM_TLS (AArch TLS registers)");
15237 case NT_ARM_HW_BREAK:
15238 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15239 case NT_ARM_HW_WATCH:
15240 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 15241 case NT_PSTATUS:
1ec5cd37 15242 return _("NT_PSTATUS (pstatus structure)");
57346661 15243 case NT_FPREGS:
1ec5cd37 15244 return _("NT_FPREGS (floating point registers)");
57346661 15245 case NT_PSINFO:
1ec5cd37 15246 return _("NT_PSINFO (psinfo structure)");
57346661 15247 case NT_LWPSTATUS:
1ec5cd37 15248 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 15249 case NT_LWPSINFO:
1ec5cd37 15250 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 15251 case NT_WIN32PSTATUS:
1ec5cd37 15252 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 15253 case NT_SIGINFO:
15254 return _("NT_SIGINFO (siginfo_t data)");
15255 case NT_FILE:
15256 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 15257 default:
15258 break;
15259 }
15260 else
15261 switch (e_type)
15262 {
15263 case NT_VERSION:
15264 return _("NT_VERSION (version)");
15265 case NT_ARCH:
15266 return _("NT_ARCH (architecture)");
15267 default:
15268 break;
15269 }
15270
e9e44622 15271 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 15272 return buff;
779fe533
NC		 15273}
15274
9ece1fa9
TT		 15275static int
15276print_core_note (Elf_Internal_Note *pnote)
15277{
15278 unsigned int addr_size = is_32bit_elf ? 4 : 8;
15279 bfd_vma count, page_size;
15280 unsigned char *descdata, *filenames, *descend;
15281
15282 if (pnote->type != NT_FILE)
15283 return 1;
15284
15285#ifndef BFD64
15286 if (!is_32bit_elf)
15287 {
15288 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15289 /* Still "successful". */
15290 return 1;
15291 }
15292#endif
15293
15294 if (pnote->descsz < 2 * addr_size)
15295 {
15296 printf (_(" Malformed note - too short for header\n"));
15297 return 0;
15298 }
15299
15300 descdata = (unsigned char *) pnote->descdata;
15301 descend = descdata + pnote->descsz;
15302
15303 if (descdata[pnote->descsz - 1] != '\0')
15304 {
15305 printf (_(" Malformed note - does not end with \\0\n"));
15306 return 0;
15307 }
15308
15309 count = byte_get (descdata, addr_size);
15310 descdata += addr_size;
15311
15312 page_size = byte_get (descdata, addr_size);
15313 descdata += addr_size;
15314
15315 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
15316 {
15317 printf (_(" Malformed note - too short for supplied file count\n"));
15318 return 0;
15319 }
15320
15321 printf (_(" Page size: "));
15322 print_vma (page_size, DEC);
15323 printf ("\n");
15324
15325 printf (_(" %*s%*s%*s\n"),
15326 (int) (2 + 2 * addr_size), _("Start"),
15327 (int) (4 + 2 * addr_size), _("End"),
15328 (int) (4 + 2 * addr_size), _("Page Offset"));
15329 filenames = descdata + count * 3 * addr_size;
595712bb 15330 while (count-- > 0)
9ece1fa9
TT		 15331 {
15332 bfd_vma start, end, file_ofs;
15333
15334 if (filenames == descend)
15335 {
15336 printf (_(" Malformed note - filenames end too early\n"));
15337 return 0;
15338 }
15339
15340 start = byte_get (descdata, addr_size);
15341 descdata += addr_size;
15342 end = byte_get (descdata, addr_size);
15343 descdata += addr_size;
15344 file_ofs = byte_get (descdata, addr_size);
15345 descdata += addr_size;
15346
15347 printf (" ");
15348 print_vma (start, FULL_HEX);
15349 printf (" ");
15350 print_vma (end, FULL_HEX);
15351 printf (" ");
15352 print_vma (file_ofs, FULL_HEX);
15353 printf ("\n %s\n", filenames);
15354
15355 filenames += 1 + strlen ((char *) filenames);
15356 }
15357
15358 return 1;
15359}
15360
1118d252
RM		 15361static const char *
15362get_gnu_elf_note_type (unsigned e_type)
15363{
15364 static char buff[64];
15365
15366 switch (e_type)
15367 {
15368 case NT_GNU_ABI_TAG:
15369 return _("NT_GNU_ABI_TAG (ABI version tag)");
15370 case NT_GNU_HWCAP:
15371 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15372 case NT_GNU_BUILD_ID:
15373 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 15374 case NT_GNU_GOLD_VERSION:
15375 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 15376 default:
15377 break;
15378 }
15379
15380 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15381 return buff;
15382}
15383
664f90a3
TT		 15384static int
15385print_gnu_note (Elf_Internal_Note *pnote)
15386{
15387 switch (pnote->type)
15388 {
15389 case NT_GNU_BUILD_ID:
15390 {
15391 unsigned long i;
15392
15393 printf (_(" Build ID: "));
15394 for (i = 0; i < pnote->descsz; ++i)
15395 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 15396 printf ("\n");
664f90a3
TT		 15397 }
15398 break;
15399
15400 case NT_GNU_ABI_TAG:
15401 {
15402 unsigned long os, major, minor, subminor;
15403 const char *osname;
15404
3102e897
NC		 15405 /* PR 17531: file: 030-599401-0.004. */
15406 if (pnote->descsz < 16)
15407 {
15408 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15409 break;
15410 }
15411
664f90a3
TT		 15412 os = byte_get ((unsigned char *) pnote->descdata, 4);
15413 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
15414 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
15415 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
15416
15417 switch (os)
15418 {
15419 case GNU_ABI_TAG_LINUX:
15420 osname = "Linux";
15421 break;
15422 case GNU_ABI_TAG_HURD:
15423 osname = "Hurd";
15424 break;
15425 case GNU_ABI_TAG_SOLARIS:
15426 osname = "Solaris";
15427 break;
15428 case GNU_ABI_TAG_FREEBSD:
15429 osname = "FreeBSD";
15430 break;
15431 case GNU_ABI_TAG_NETBSD:
15432 osname = "NetBSD";
15433 break;
14ae95f2
RM		 15434 case GNU_ABI_TAG_SYLLABLE:
15435 osname = "Syllable";
15436 break;
15437 case GNU_ABI_TAG_NACL:
15438 osname = "NaCl";
15439 break;
664f90a3
TT		 15440 default:
15441 osname = "Unknown";
15442 break;
15443 }
15444
15445 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
15446 major, minor, subminor);
15447 }
15448 break;
926c5385
CC		 15449
15450 case NT_GNU_GOLD_VERSION:
15451 {
15452 unsigned long i;
15453
15454 printf (_(" Version: "));
15455 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
15456 printf ("%c", pnote->descdata[i]);
15457 printf ("\n");
15458 }
15459 break;
664f90a3
TT		 15460 }
15461
15462 return 1;
15463}
15464
685080f2
NC		 15465static const char *
15466get_v850_elf_note_type (enum v850_notes n_type)
15467{
15468 static char buff[64];
15469
15470 switch (n_type)
15471 {
15472 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
15473 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
15474 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
15475 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
15476 case V850_NOTE_CACHE_INFO: return _("Use of cache");
15477 case V850_NOTE_MMU_INFO: return _("Use of MMU");
15478 default:
15479 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
15480 return buff;
15481 }
15482}
15483
15484static int
15485print_v850_note (Elf_Internal_Note * pnote)
15486{
15487 unsigned int val;
15488
15489 if (pnote->descsz != 4)
15490 return 0;
15491 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
15492
15493 if (val == 0)
15494 {
15495 printf (_("not set\n"));
15496 return 1;
15497 }
15498
15499 switch (pnote->type)
15500 {
15501 case V850_NOTE_ALIGNMENT:
15502 switch (val)
15503 {
15504 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
15505 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
15506 }
15507 break;
14ae95f2 15508
685080f2
NC		 15509 case V850_NOTE_DATA_SIZE:
15510 switch (val)
15511 {
15512 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
15513 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
15514 }
15515 break;
14ae95f2 15516
685080f2
NC		 15517 case V850_NOTE_FPU_INFO:
15518 switch (val)
15519 {
15520 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
15521 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
15522 }
15523 break;
14ae95f2 15524
685080f2
NC		 15525 case V850_NOTE_MMU_INFO:
15526 case V850_NOTE_CACHE_INFO:
15527 case V850_NOTE_SIMD_INFO:
15528 if (val == EF_RH850_SIMD)
15529 {
15530 printf (_("yes\n"));
15531 return 1;
15532 }
15533 break;
15534
15535 default:
15536 /* An 'unknown note type' message will already have been displayed. */
15537 break;
15538 }
15539
15540 printf (_("unknown value: %x\n"), val);
15541 return 0;
15542}
15543
c6056a74
SF		 15544static int
15545process_netbsd_elf_note (Elf_Internal_Note * pnote)
15546{
15547 unsigned int version;
15548
15549 switch (pnote->type)
15550 {
15551 case NT_NETBSD_IDENT:
15552 version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
15553 if ((version / 10000) % 100)
15554 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
15555 version, version / 100000000, (version / 1000000) % 100,
15556 (version / 10000) % 100 > 26 ? "Z" : "",
15557 'A' + (version / 10000) % 26);
15558 else
15559 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
15560 version, version / 100000000, (version / 1000000) % 100,
15561 (version / 100) % 100);
15562 return 1;
15563
15564 case NT_NETBSD_MARCH:
15565 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
15566 pnote->descdata);
15567 return 1;
15568
15569 default:
15570 break;
15571 }
15572
15573 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
15574 pnote->type);
15575 return 1;
15576}
15577
f4ddf30f
JB		 15578static const char *
15579get_freebsd_elfcore_note_type (unsigned e_type)
15580{
f4ddf30f
JB		 15581 switch (e_type)
15582 {
15583 case NT_FREEBSD_THRMISC:
15584 return _("NT_THRMISC (thrmisc structure)");
15585 case NT_FREEBSD_PROCSTAT_PROC:
15586 return _("NT_PROCSTAT_PROC (proc data)");
15587 case NT_FREEBSD_PROCSTAT_FILES:
15588 return _("NT_PROCSTAT_FILES (files data)");
15589 case NT_FREEBSD_PROCSTAT_VMMAP:
15590 return _("NT_PROCSTAT_VMMAP (vmmap data)");
15591 case NT_FREEBSD_PROCSTAT_GROUPS:
15592 return _("NT_PROCSTAT_GROUPS (groups data)");
15593 case NT_FREEBSD_PROCSTAT_UMASK:
15594 return _("NT_PROCSTAT_UMASK (umask data)");
15595 case NT_FREEBSD_PROCSTAT_RLIMIT:
15596 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
15597 case NT_FREEBSD_PROCSTAT_OSREL:
15598 return _("NT_PROCSTAT_OSREL (osreldate data)");
15599 case NT_FREEBSD_PROCSTAT_PSSTRINGS:
15600 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
15601 case NT_FREEBSD_PROCSTAT_AUXV:
15602 return _("NT_PROCSTAT_AUXV (auxv data)");
15603 }
15604 return get_note_type (e_type);
15605}
15606
9437c45b 15607static const char *
d3ba0551 15608get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 15609{
15610 static char buff[64];
15611
b4db1224 15612 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 15613 {
15614 /* NetBSD core "procinfo" structure. */
15615 return _("NetBSD procinfo structure");
15616 }
15617
15618 /* As of Jan 2002 there are no other machine-independent notes
15619 defined for NetBSD core files. If the note type is less
15620 than the start of the machine-dependent note types, we don't
15621 understand it. */
15622
b4db1224 15623 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 15624 {
e9e44622 15625 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 15626 return buff;
15627 }
15628
15629 switch (elf_header.e_machine)
15630 {
15631 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15632 and PT_GETFPREGS == mach+2. */
15633
15634 case EM_OLD_ALPHA:
15635 case EM_ALPHA:
15636 case EM_SPARC:
15637 case EM_SPARC32PLUS:
15638 case EM_SPARCV9:
15639 switch (e_type)
15640 {
2b692964 15641 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 15642 return _("PT_GETREGS (reg structure)");
2b692964 15643 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 15644 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15645 default:
15646 break;
15647 }
15648 break;
15649
15650 /* On all other arch's, PT_GETREGS == mach+1 and
15651 PT_GETFPREGS == mach+3. */
15652 default:
15653 switch (e_type)
15654 {
2b692964 15655 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 15656 return _("PT_GETREGS (reg structure)");
2b692964 15657 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 15658 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15659 default:
15660 break;
15661 }
15662 }
15663
9cf03b7e 15664 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 15665 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 15666 return buff;
15667}
15668
70616151
TT		 15669static const char *
15670get_stapsdt_note_type (unsigned e_type)
15671{
15672 static char buff[64];
15673
15674 switch (e_type)
15675 {
15676 case NT_STAPSDT:
15677 return _("NT_STAPSDT (SystemTap probe descriptors)");
15678
15679 default:
15680 break;
15681 }
15682
15683 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15684 return buff;
15685}
15686
c6a9fc58
TT		 15687static int
15688print_stapsdt_note (Elf_Internal_Note *pnote)
15689{
15690 int addr_size = is_32bit_elf ? 4 : 8;
15691 char *data = pnote->descdata;
15692 char *data_end = pnote->descdata + pnote->descsz;
15693 bfd_vma pc, base_addr, semaphore;
15694 char *provider, *probe, *arg_fmt;
15695
15696 pc = byte_get ((unsigned char *) data, addr_size);
15697 data += addr_size;
15698 base_addr = byte_get ((unsigned char *) data, addr_size);
15699 data += addr_size;
15700 semaphore = byte_get ((unsigned char *) data, addr_size);
15701 data += addr_size;
15702
15703 provider = data;
15704 data += strlen (data) + 1;
15705 probe = data;
15706 data += strlen (data) + 1;
15707 arg_fmt = data;
15708 data += strlen (data) + 1;
15709
15710 printf (_(" Provider: %s\n"), provider);
15711 printf (_(" Name: %s\n"), probe);
15712 printf (_(" Location: "));
15713 print_vma (pc, FULL_HEX);
15714 printf (_(", Base: "));
15715 print_vma (base_addr, FULL_HEX);
15716 printf (_(", Semaphore: "));
15717 print_vma (semaphore, FULL_HEX);
9cf03b7e 15718 printf ("\n");
c6a9fc58
TT		 15719 printf (_(" Arguments: %s\n"), arg_fmt);
15720
15721 return data == data_end;
15722}
15723
00e98fc7
TG		 15724static const char *
15725get_ia64_vms_note_type (unsigned e_type)
15726{
15727 static char buff[64];
15728
15729 switch (e_type)
15730 {
15731 case NT_VMS_MHD:
15732 return _("NT_VMS_MHD (module header)");
15733 case NT_VMS_LNM:
15734 return _("NT_VMS_LNM (language name)");
15735 case NT_VMS_SRC:
15736 return _("NT_VMS_SRC (source files)");
15737 case NT_VMS_TITLE:
9cf03b7e 15738 return "NT_VMS_TITLE";
00e98fc7
TG		 15739 case NT_VMS_EIDC:
15740 return _("NT_VMS_EIDC (consistency check)");
15741 case NT_VMS_FPMODE:
15742 return _("NT_VMS_FPMODE (FP mode)");
15743 case NT_VMS_LINKTIME:
9cf03b7e 15744 return "NT_VMS_LINKTIME";
00e98fc7
TG		 15745 case NT_VMS_IMGNAM:
15746 return _("NT_VMS_IMGNAM (image name)");
15747 case NT_VMS_IMGID:
15748 return _("NT_VMS_IMGID (image id)");
15749 case NT_VMS_LINKID:
15750 return _("NT_VMS_LINKID (link id)");
15751 case NT_VMS_IMGBID:
15752 return _("NT_VMS_IMGBID (build id)");
15753 case NT_VMS_GSTNAM:
15754 return _("NT_VMS_GSTNAM (sym table name)");
15755 case NT_VMS_ORIG_DYN:
9cf03b7e 15756 return "NT_VMS_ORIG_DYN";
00e98fc7 15757 case NT_VMS_PATCHTIME:
9cf03b7e 15758 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 15759 default:
15760 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15761 return buff;
15762 }
15763}
15764
15765static int
15766print_ia64_vms_note (Elf_Internal_Note * pnote)
15767{
15768 switch (pnote->type)
15769 {
15770 case NT_VMS_MHD:
15771 if (pnote->descsz > 36)
15772 {
15773 size_t l = strlen (pnote->descdata + 34);
15774 printf (_(" Creation date : %.17s\n"), pnote->descdata);
15775 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
15776 printf (_(" Module name : %s\n"), pnote->descdata + 34);
15777 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
15778 }
15779 else
15780 printf (_(" Invalid size\n"));
15781 break;
15782 case NT_VMS_LNM:
15783 printf (_(" Language: %s\n"), pnote->descdata);
15784 break;
15785#ifdef BFD64
15786 case NT_VMS_FPMODE:
9cf03b7e 15787 printf (_(" Floating Point mode: "));
4a5cb34f 15788 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15789 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
00e98fc7
TG		 15790 break;
15791 case NT_VMS_LINKTIME:
15792 printf (_(" Link time: "));
15793 print_vms_time
15794 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15795 printf ("\n");
15796 break;
15797 case NT_VMS_PATCHTIME:
15798 printf (_(" Patch time: "));
15799 print_vms_time
15800 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15801 printf ("\n");
15802 break;
15803 case NT_VMS_ORIG_DYN:
15804 printf (_(" Major id: %u, minor id: %u\n"),
15805 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
15806 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 15807 printf (_(" Last modified : "));
00e98fc7
TG		 15808 print_vms_time
15809 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 15810 printf (_("\n Link flags : "));
4a5cb34f 15811 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15812 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
00e98fc7 15813 printf (_(" Header flags: 0x%08x\n"),
948f632f 15814 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
00e98fc7
TG		 15815 printf (_(" Image id : %s\n"), pnote->descdata + 32);
15816 break;
15817#endif
15818 case NT_VMS_IMGNAM:
15819 printf (_(" Image name: %s\n"), pnote->descdata);
15820 break;
15821 case NT_VMS_GSTNAM:
15822 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
15823 break;
15824 case NT_VMS_IMGID:
15825 printf (_(" Image id: %s\n"), pnote->descdata);
15826 break;
15827 case NT_VMS_LINKID:
15828 printf (_(" Linker id: %s\n"), pnote->descdata);
15829 break;
15830 default:
15831 break;
15832 }
15833 return 1;
15834}
15835
6d118b09
NC		 15836/* Note that by the ELF standard, the name field is already null byte
15837 terminated, and namesz includes the terminating null byte.
15838 I.E. the value of namesz for the name "FSF" is 4.
15839
e3c8793a 15840 If the value of namesz is zero, there is no name present. */
779fe533 15841static int
2cf0635d 15842process_note (Elf_Internal_Note * pnote)
779fe533 15843{
2cf0635d
NC		 15844 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
15845 const char * nt;
9437c45b
JT		 15846
15847 if (pnote->namesz == 0)
1ec5cd37
NC		 15848 /* If there is no note name, then use the default set of
15849 note type strings. */
15850 nt = get_note_type (pnote->type);
15851
1118d252
RM		 15852 else if (const_strneq (pnote->namedata, "GNU"))
15853 /* GNU-specific object file notes. */
15854 nt = get_gnu_elf_note_type (pnote->type);
f4ddf30f
JB		 15855
15856 else if (const_strneq (pnote->namedata, "FreeBSD"))
15857 /* FreeBSD-specific core file notes. */
15858 nt = get_freebsd_elfcore_note_type (pnote->type);
1118d252 15859
0112cd26 15860 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 15861 /* NetBSD-specific core file notes. */
15862 nt = get_netbsd_elfcore_note_type (pnote->type);
15863
c6056a74
SF		 15864 else if (const_strneq (pnote->namedata, "NetBSD"))
15865 /* NetBSD-specific core file notes. */
15866 return process_netbsd_elf_note (pnote);
15867
b15fa79e
AM		 15868 else if (strneq (pnote->namedata, "SPU/", 4))
15869 {
15870 /* SPU-specific core file notes. */
15871 nt = pnote->namedata + 4;
15872 name = "SPU";
15873 }
15874
00e98fc7
TG		 15875 else if (const_strneq (pnote->namedata, "IPF/VMS"))
15876 /* VMS/ia64-specific file notes. */
15877 nt = get_ia64_vms_note_type (pnote->type);
15878
70616151
TT		 15879 else if (const_strneq (pnote->namedata, "stapsdt"))
15880 nt = get_stapsdt_note_type (pnote->type);
15881
9437c45b 15882 else
1ec5cd37
NC		 15883 /* Don't recognize this note name; just use the default set of
15884 note type strings. */
00e98fc7 15885 nt = get_note_type (pnote->type);
9437c45b 15886
2aee03ae 15887 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 15888
15889 if (const_strneq (pnote->namedata, "IPF/VMS"))
15890 return print_ia64_vms_note (pnote);
664f90a3
TT		 15891 else if (const_strneq (pnote->namedata, "GNU"))
15892 return print_gnu_note (pnote);
c6a9fc58
TT		 15893 else if (const_strneq (pnote->namedata, "stapsdt"))
15894 return print_stapsdt_note (pnote);
9ece1fa9
TT		 15895 else if (const_strneq (pnote->namedata, "CORE"))
15896 return print_core_note (pnote);
00e98fc7
TG		 15897 else
15898 return 1;
779fe533
NC		 15899}
15900
6d118b09 15901
779fe533 15902static int
2cf0635d 15903process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 15904{
2cf0635d
NC		 15905 Elf_External_Note * pnotes;
15906 Elf_External_Note * external;
c8071705 15907 char * end;
b34976b6 15908 int res = 1;
103f02d3 15909
779fe533
NC		 15910 if (length <= 0)
15911 return 0;
103f02d3 15912
3f5e193b 15913 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15b42fb0 15914 _("notes"));
dd24e3da 15915 if (pnotes == NULL)
a6e9f9df 15916 return 0;
779fe533 15917
103f02d3 15918 external = pnotes;
103f02d3 15919
9dd3a467 15920 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 15921 (unsigned long) offset, (unsigned long) length);
2aee03ae 15922 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 15923
c8071705
NC		 15924 end = (char *) pnotes + length;
15925 while ((char *) external < end)
779fe533 15926 {
b34976b6 15927 Elf_Internal_Note inote;
15b42fb0
AM		 15928 size_t min_notesz;
15929 char *next;
2cf0635d 15930 char * temp = NULL;
c8071705 15931 size_t data_remaining = end - (char *) external;
6d118b09 15932
00e98fc7 15933 if (!is_ia64_vms ())
15b42fb0 15934 {
9dd3a467
NC		 15935 /* PR binutils/15191
15936 Make sure that there is enough data to read. */
15b42fb0
AM		 15937 min_notesz = offsetof (Elf_External_Note, name);
15938 if (data_remaining < min_notesz)
9dd3a467
NC		 15939 {
15940 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15941 (int) data_remaining);
15942 break;
15943 }
15b42fb0
AM		 15944 inote.type = BYTE_GET (external->type);
15945 inote.namesz = BYTE_GET (external->namesz);
15946 inote.namedata = external->name;
15947 inote.descsz = BYTE_GET (external->descsz);
15948 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
834f871c 15949 /* PR 17531: file: 3443835e. */
c8071705 15950 if (inote.descdata < (char *) pnotes || inote.descdata > end)
834f871c
NC		 15951 {
15952 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15953 inote.descdata = inote.namedata;
15954 inote.namesz = 0;
15955 }
14ae95f2 15956
15b42fb0
AM		 15957 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15958 next = inote.descdata + align_power (inote.descsz, 2);
15959 }
00e98fc7 15960 else
15b42fb0
AM		 15961 {
15962 Elf64_External_VMS_Note *vms_external;
00e98fc7 15963
9dd3a467
NC		 15964 /* PR binutils/15191
15965 Make sure that there is enough data to read. */
15b42fb0
AM		 15966 min_notesz = offsetof (Elf64_External_VMS_Note, name);
15967 if (data_remaining < min_notesz)
9dd3a467
NC		 15968 {
15969 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15970 (int) data_remaining);
15971 break;
15972 }
3e55a963 15973
15b42fb0
AM		 15974 vms_external = (Elf64_External_VMS_Note *) external;
15975 inote.type = BYTE_GET (vms_external->type);
15976 inote.namesz = BYTE_GET (vms_external->namesz);
15977 inote.namedata = vms_external->name;
15978 inote.descsz = BYTE_GET (vms_external->descsz);
15979 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
15980 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15981 next = inote.descdata + align_power (inote.descsz, 3);
15982 }
15983
15984 if (inote.descdata < (char *) external + min_notesz
15985 || next < (char *) external + min_notesz
5d921cbd
NC		 15986 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15987 || inote.namedata + inote.namesz < inote.namedata
15988 || inote.descdata + inote.descsz < inote.descdata
15b42fb0 15989 || data_remaining < (size_t)(next - (char *) external))
3e55a963 15990 {
15b42fb0 15991 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 15992 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 15993 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC		 15994 inote.type, inote.namesz, inote.descsz);
15995 break;
15996 }
15997
15b42fb0 15998 external = (Elf_External_Note *) next;
dd24e3da 15999
6d118b09
NC		 16000 /* Verify that name is null terminated. It appears that at least
16001 one version of Linux (RedHat 6.0) generates corefiles that don't
16002 comply with the ELF spec by failing to include the null byte in
16003 namesz. */
8b971f9f 16004 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 16005 {
3f5e193b 16006 temp = (char *) malloc (inote.namesz + 1);
6d118b09
NC		 16007 if (temp == NULL)
16008 {
8b73c356 16009 error (_("Out of memory allocating space for inote name\n"));
6d118b09
NC		 16010 res = 0;
16011 break;
16012 }
76da6bbe 16013
6d118b09
NC		 16014 strncpy (temp, inote.namedata, inote.namesz);
16015 temp[inote.namesz] = 0;
76da6bbe 16016
6d118b09
NC		 16017 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
16018 inote.namedata = temp;
16019 }
16020
16021 res &= process_note (& inote);
103f02d3 16022
6d118b09
NC		 16023 if (temp != NULL)
16024 {
16025 free (temp);
16026 temp = NULL;
16027 }
779fe533
NC		 16028 }
16029
16030 free (pnotes);
103f02d3 16031
779fe533
NC		 16032 return res;
16033}
16034
16035static int
2cf0635d 16036process_corefile_note_segments (FILE * file)
779fe533 16037{
2cf0635d 16038 Elf_Internal_Phdr * segment;
b34976b6
AM		 16039 unsigned int i;
16040 int res = 1;
103f02d3 16041
d93f0186 16042 if (! get_program_headers (file))
779fe533 16043 return 0;
103f02d3 16044
779fe533
NC		 16045 for (i = 0, segment = program_headers;
16046 i < elf_header.e_phnum;
b34976b6 16047 i++, segment++)
779fe533
NC		 16048 {
16049 if (segment->p_type == PT_NOTE)
103f02d3 16050 res &= process_corefile_note_segment (file,
30800947
NC		 16051 (bfd_vma) segment->p_offset,
16052 (bfd_vma) segment->p_filesz);
779fe533 16053 }
103f02d3 16054
779fe533
NC		 16055 return res;
16056}
16057
685080f2
NC		 16058static int
16059process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
16060{
16061 Elf_External_Note * pnotes;
16062 Elf_External_Note * external;
c8071705 16063 char * end;
685080f2
NC		 16064 int res = 1;
16065
16066 if (length <= 0)
16067 return 0;
16068
16069 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
16070 _("v850 notes"));
16071 if (pnotes == NULL)
16072 return 0;
16073
16074 external = pnotes;
c8071705 16075 end = (char*) pnotes + length;
685080f2
NC		 16076
16077 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
16078 (unsigned long) offset, (unsigned long) length);
16079
c8071705 16080 while ((char *) external + sizeof (Elf_External_Note) < end)
685080f2
NC		 16081 {
16082 Elf_External_Note * next;
16083 Elf_Internal_Note inote;
16084
16085 inote.type = BYTE_GET (external->type);
16086 inote.namesz = BYTE_GET (external->namesz);
16087 inote.namedata = external->name;
16088 inote.descsz = BYTE_GET (external->descsz);
16089 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
16090 inote.descpos = offset + (inote.descdata - (char *) pnotes);
16091
c8071705
NC		 16092 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
16093 {
16094 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
16095 inote.descdata = inote.namedata;
16096 inote.namesz = 0;
16097 }
16098
685080f2
NC		 16099 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
16100
c8071705 16101 if ( ((char *) next > end)
685080f2
NC		 16102 || ((char *) next < (char *) pnotes))
16103 {
16104 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
16105 (unsigned long) ((char *) external - (char *) pnotes));
16106 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16107 inote.type, inote.namesz, inote.descsz);
16108 break;
16109 }
16110
16111 external = next;
16112
16113 /* Prevent out-of-bounds indexing. */
c8071705 16114 if ( inote.namedata + inote.namesz > end
685080f2
NC		 16115 || inote.namedata + inote.namesz < inote.namedata)
16116 {
16117 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
16118 (unsigned long) ((char *) external - (char *) pnotes));
16119 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16120 inote.type, inote.namesz, inote.descsz);
16121 break;
16122 }
16123
16124 printf (" %s: ", get_v850_elf_note_type (inote.type));
16125
16126 if (! print_v850_note (& inote))
16127 {
16128 res = 0;
16129 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
16130 inote.namesz, inote.descsz);
16131 }
16132 }
16133
16134 free (pnotes);
16135
16136 return res;
16137}
16138
779fe533 16139static int
2cf0635d 16140process_note_sections (FILE * file)
1ec5cd37 16141{
2cf0635d 16142 Elf_Internal_Shdr * section;
1ec5cd37 16143 unsigned long i;
df565f32 16144 int n = 0;
1ec5cd37
NC		 16145 int res = 1;
16146
16147 for (i = 0, section = section_headers;
fa1908fd 16148 i < elf_header.e_shnum && section != NULL;
1ec5cd37 16149 i++, section++)
685080f2
NC		 16150 {
16151 if (section->sh_type == SHT_NOTE)
16152 {
16153 res &= process_corefile_note_segment (file,
16154 (bfd_vma) section->sh_offset,
16155 (bfd_vma) section->sh_size);
16156 n++;
16157 }
16158
16159 if (( elf_header.e_machine == EM_V800
16160 || elf_header.e_machine == EM_V850
16161 || elf_header.e_machine == EM_CYGNUS_V850)
16162 && section->sh_type == SHT_RENESAS_INFO)
16163 {
16164 res &= process_v850_notes (file,
16165 (bfd_vma) section->sh_offset,
16166 (bfd_vma) section->sh_size);
16167 n++;
16168 }
16169 }
df565f32
NC		 16170
16171 if (n == 0)
16172 /* Try processing NOTE segments instead. */
16173 return process_corefile_note_segments (file);
1ec5cd37
NC		 16174
16175 return res;
16176}
16177
16178static int
2cf0635d 16179process_notes (FILE * file)
779fe533
NC		 16180{
16181 /* If we have not been asked to display the notes then do nothing. */
16182 if (! do_notes)
16183 return 1;
103f02d3 16184
779fe533 16185 if (elf_header.e_type != ET_CORE)
1ec5cd37 16186 return process_note_sections (file);
103f02d3 16187
779fe533 16188 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 16189 if (elf_header.e_phnum > 0)
16190 return process_corefile_note_segments (file);
779fe533 16191
1ec5cd37
NC		 16192 printf (_("No note segments present in the core file.\n"));
16193 return 1;
779fe533
NC		 16194}
16195
252b5132 16196static int
2cf0635d 16197process_arch_specific (FILE * file)
252b5132 16198{
a952a375
NC		 16199 if (! do_arch)
16200 return 1;
16201
252b5132
RH		 16202 switch (elf_header.e_machine)
16203 {
11c1ff18
PB		 16204 case EM_ARM:
16205 return process_arm_specific (file);
252b5132 16206 case EM_MIPS:
4fe85591 16207 case EM_MIPS_RS3_LE:
252b5132
RH		 16208 return process_mips_specific (file);
16209 break;
35c08157
KLC		 16210 case EM_NDS32:
16211 return process_nds32_specific (file);
16212 break;
34c8bcba
JM		 16213 case EM_PPC:
16214 return process_power_specific (file);
16215 break;
643f7afb
AK		 16216 case EM_S390:
16217 case EM_S390_OLD:
16218 return process_s390_specific (file);
16219 break;
9e8c70f9
DM		 16220 case EM_SPARC:
16221 case EM_SPARC32PLUS:
16222 case EM_SPARCV9:
16223 return process_sparc_specific (file);
16224 break;
59e6276b
JM		 16225 case EM_TI_C6000:
16226 return process_tic6x_specific (file);
16227 break;
13761a11
NC		 16228 case EM_MSP430:
16229 return process_msp430x_specific (file);
252b5132
RH		 16230 default:
16231 break;
16232 }
16233 return 1;
16234}
16235
16236static int
2cf0635d 16237get_file_header (FILE * file)
252b5132 16238{
9ea033b2
NC		 16239 /* Read in the identity array. */
16240 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 16241 return 0;
16242
9ea033b2 16243 /* Determine how to read the rest of the header. */
b34976b6 16244 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 16245 {
16246 default: /* fall through */
16247 case ELFDATANONE: /* fall through */
adab8cdc
AO		 16248 case ELFDATA2LSB:
16249 byte_get = byte_get_little_endian;
16250 byte_put = byte_put_little_endian;
16251 break;
16252 case ELFDATA2MSB:
16253 byte_get = byte_get_big_endian;
16254 byte_put = byte_put_big_endian;
16255 break;
9ea033b2
NC		 16256 }
16257
16258 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 16259 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 16260
16261 /* Read in the rest of the header. */
16262 if (is_32bit_elf)
16263 {
16264 Elf32_External_Ehdr ehdr32;
252b5132 16265
9ea033b2
NC		 16266 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
16267 return 0;
103f02d3 16268
9ea033b2
NC		 16269 elf_header.e_type = BYTE_GET (ehdr32.e_type);
16270 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
16271 elf_header.e_version = BYTE_GET (ehdr32.e_version);
16272 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
16273 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
16274 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
16275 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
16276 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
16277 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
16278 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
16279 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
16280 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
16281 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
16282 }
252b5132 16283 else
9ea033b2
NC		 16284 {
16285 Elf64_External_Ehdr ehdr64;
a952a375
NC		 16286
16287 /* If we have been compiled with sizeof (bfd_vma) == 4, then
16288 we will not be able to cope with the 64bit data found in
16289 64 ELF files. Detect this now and abort before we start
50c2245b 16290 overwriting things. */
a952a375
NC		 16291 if (sizeof (bfd_vma) < 8)
16292 {
e3c8793a
NC		 16293 error (_("This instance of readelf has been built without support for a\n\
1629464 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 16295 return 0;
16296 }
103f02d3 16297
9ea033b2
NC		 16298 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
16299 return 0;
103f02d3 16300
9ea033b2
NC		 16301 elf_header.e_type = BYTE_GET (ehdr64.e_type);
16302 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
16303 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 16304 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
16305 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
16306 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 16307 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
16308 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
16309 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
16310 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
16311 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
16312 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
16313 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
16314 }
252b5132 16315
7ece0d85
JJ		 16316 if (elf_header.e_shoff)
16317 {
16318 /* There may be some extensions in the first section header. Don't
16319 bomb if we can't read it. */
16320 if (is_32bit_elf)
049b0c3a 16321 get_32bit_section_headers (file, TRUE);
7ece0d85 16322 else
049b0c3a 16323 get_64bit_section_headers (file, TRUE);
7ece0d85 16324 }
560f3c1c 16325
252b5132
RH		 16326 return 1;
16327}
16328
fb52b2f4
NC		 16329/* Process one ELF object file according to the command line options.
16330 This file may actually be stored in an archive. The file is
16331 positioned at the start of the ELF object. */
16332
ff78d6d6 16333static int
2cf0635d 16334process_object (char * file_name, FILE * file)
252b5132 16335{
252b5132
RH		 16336 unsigned int i;
16337
252b5132
RH		 16338 if (! get_file_header (file))
16339 {
16340 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 16341 return 1;
252b5132
RH		 16342 }
16343
16344 /* Initialise per file variables. */
60bca95a 16345 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 16346 version_info[i] = 0;
16347
60bca95a 16348 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 16349 dynamic_info[i] = 0;
5115b233 16350 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 16351
16352 /* Process the file. */
16353 if (show_name)
16354 printf (_("\nFile: %s\n"), file_name);
16355
18bd398b
NC		 16356 /* Initialise the dump_sects array from the cmdline_dump_sects array.
16357 Note we do this even if cmdline_dump_sects is empty because we
16358 must make sure that the dump_sets array is zeroed out before each
16359 object file is processed. */
16360 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 16361 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 16362
16363 if (num_cmdline_dump_sects > 0)
16364 {
16365 if (num_dump_sects == 0)
16366 /* A sneaky way of allocating the dump_sects array. */
09c11c86 16367 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 16368
16369 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 16370 memcpy (dump_sects, cmdline_dump_sects,
16371 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 16372 }
d70c5fc7 16373
252b5132 16374 if (! process_file_header ())
fb52b2f4 16375 return 1;
252b5132 16376
d1f5c6e3 16377 if (! process_section_headers (file))
2f62977e 16378 {
d1f5c6e3
L		 16379 /* Without loaded section headers we cannot process lots of
16380 things. */
2f62977e 16381 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 16382
2f62977e 16383 if (! do_using_dynamic)
2c610e4b 16384 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 16385 }
252b5132 16386
d1f5c6e3
L		 16387 if (! process_section_groups (file))
16388 {
16389 /* Without loaded section groups we cannot process unwind. */
16390 do_unwind = 0;
16391 }
16392
2f62977e 16393 if (process_program_headers (file))
b2d38a17 16394 process_dynamic_section (file);
252b5132
RH		 16395
16396 process_relocs (file);
16397
4d6ed7c8
NC		 16398 process_unwind (file);
16399
252b5132
RH		 16400 process_symbol_table (file);
16401
16402 process_syminfo (file);
16403
16404 process_version_sections (file);
16405
16406 process_section_contents (file);
f5842774 16407
1ec5cd37 16408 process_notes (file);
103f02d3 16409
047b2264
JJ		 16410 process_gnu_liblist (file);
16411
252b5132
RH		 16412 process_arch_specific (file);
16413
d93f0186
NC		 16414 if (program_headers)
16415 {
16416 free (program_headers);
16417 program_headers = NULL;
16418 }
16419
252b5132
RH		 16420 if (section_headers)
16421 {
16422 free (section_headers);
16423 section_headers = NULL;
16424 }
16425
16426 if (string_table)
16427 {
16428 free (string_table);
16429 string_table = NULL;
d40ac9bd 16430 string_table_length = 0;
252b5132
RH		 16431 }
16432
16433 if (dynamic_strings)
16434 {
16435 free (dynamic_strings);
16436 dynamic_strings = NULL;
d79b3d50 16437 dynamic_strings_length = 0;
252b5132
RH		 16438 }
16439
16440 if (dynamic_symbols)
16441 {
16442 free (dynamic_symbols);
16443 dynamic_symbols = NULL;
19936277 16444 num_dynamic_syms = 0;
252b5132
RH		 16445 }
16446
16447 if (dynamic_syminfo)
16448 {
16449 free (dynamic_syminfo);
16450 dynamic_syminfo = NULL;
16451 }
ff78d6d6 16452
293c573e
MR		 16453 if (dynamic_section)
16454 {
16455 free (dynamic_section);
16456 dynamic_section = NULL;
16457 }
16458
e4b17d5c
L		 16459 if (section_headers_groups)
16460 {
16461 free (section_headers_groups);
16462 section_headers_groups = NULL;
16463 }
16464
16465 if (section_groups)
16466 {
2cf0635d
NC		 16467 struct group_list * g;
16468 struct group_list * next;
e4b17d5c
L		 16469
16470 for (i = 0; i < group_count; i++)
16471 {
16472 for (g = section_groups [i].root; g != NULL; g = next)
16473 {
16474 next = g->next;
16475 free (g);
16476 }
16477 }
16478
16479 free (section_groups);
16480 section_groups = NULL;
16481 }
16482
19e6b90e 16483 free_debug_memory ();
18bd398b 16484
ff78d6d6 16485 return 0;
252b5132
RH		 16486}
16487
2cf0635d
NC		 16488/* Process an ELF archive.
16489 On entry the file is positioned just after the ARMAG string. */
16490
16491static int
16492process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
16493{
16494 struct archive_info arch;
16495 struct archive_info nested_arch;
16496 size_t got;
2cf0635d
NC		 16497 int ret;
16498
16499 show_name = 1;
16500
16501 /* The ARCH structure is used to hold information about this archive. */
16502 arch.file_name = NULL;
16503 arch.file = NULL;
16504 arch.index_array = NULL;
16505 arch.sym_table = NULL;
16506 arch.longnames = NULL;
16507
16508 /* The NESTED_ARCH structure is used as a single-item cache of information
16509 about a nested archive (when members of a thin archive reside within
16510 another regular archive file). */
16511 nested_arch.file_name = NULL;
16512 nested_arch.file = NULL;
16513 nested_arch.index_array = NULL;
16514 nested_arch.sym_table = NULL;
16515 nested_arch.longnames = NULL;
16516
16517 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
16518 {
16519 ret = 1;
16520 goto out;
4145f1d5 16521 }
fb52b2f4 16522
4145f1d5
NC		 16523 if (do_archive_index)
16524 {
2cf0635d 16525 if (arch.sym_table == NULL)
4145f1d5
NC		 16526 error (_("%s: unable to dump the index as none was found\n"), file_name);
16527 else
16528 {
591f7597 16529 unsigned long i, l;
4145f1d5
NC		 16530 unsigned long current_pos;
16531
591f7597
NC		 16532 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16533 file_name, (unsigned long) arch.index_num, arch.sym_size);
4145f1d5
NC		 16534 current_pos = ftell (file);
16535
2cf0635d 16536 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 16537 {
2cf0635d
NC		 16538 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
16539 {
16540 char * member_name;
4145f1d5 16541
2cf0635d
NC		 16542 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
16543
16544 if (member_name != NULL)
16545 {
16546 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
16547
16548 if (qualified_name != NULL)
16549 {
c2a7d3f5
NC		 16550 printf (_("Contents of binary %s at offset "), qualified_name);
16551 (void) print_vma (arch.index_array[i], PREFIX_HEX);
16552 putchar ('\n');
2cf0635d
NC		 16553 free (qualified_name);
16554 }
4145f1d5
NC		 16555 }
16556 }
2cf0635d
NC		 16557
16558 if (l >= arch.sym_size)
4145f1d5
NC		 16559 {
16560 error (_("%s: end of the symbol table reached before the end of the index\n"),
16561 file_name);
cb8f3167 16562 break;
4145f1d5 16563 }
591f7597
NC		 16564 /* PR 17531: file: 0b6630b2. */
16565 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
16566 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
4145f1d5
NC		 16567 }
16568
c2a7d3f5
NC		 16569 if (arch.uses_64bit_indicies)
16570 l = (l + 7) & ~ 7;
16571 else
16572 l += l & 1;
16573
2cf0635d 16574 if (l < arch.sym_size)
c2a7d3f5
NC		 16575 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16576 file_name, arch.sym_size - l);
4145f1d5 16577
4145f1d5
NC		 16578 if (fseek (file, current_pos, SEEK_SET) != 0)
16579 {
16580 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 16581 ret = 1;
16582 goto out;
4145f1d5 16583 }
fb52b2f4 16584 }
4145f1d5
NC		 16585
16586 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
16587 && !do_segments && !do_header && !do_dump && !do_version
16588 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 16589 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 16590 {
16591 ret = 0; /* Archive index only. */
16592 goto out;
16593 }
fb52b2f4
NC		 16594 }
16595
d989285c 16596 ret = 0;
fb52b2f4
NC		 16597
16598 while (1)
16599 {
2cf0635d
NC		 16600 char * name;
16601 size_t namelen;
16602 char * qualified_name;
16603
16604 /* Read the next archive header. */
16605 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
16606 {
16607 error (_("%s: failed to seek to next archive header\n"), file_name);
16608 return 1;
16609 }
16610 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
16611 if (got != sizeof arch.arhdr)
16612 {
16613 if (got == 0)
16614 break;
16615 error (_("%s: failed to read archive header\n"), file_name);
16616 ret = 1;
16617 break;
16618 }
16619 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
16620 {
16621 error (_("%s: did not find a valid archive header\n"), arch.file_name);
16622 ret = 1;
16623 break;
16624 }
16625
16626 arch.next_arhdr_offset += sizeof arch.arhdr;
16627
16628 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
16629 if (archive_file_size & 01)
16630 ++archive_file_size;
16631
16632 name = get_archive_member_name (&arch, &nested_arch);
16633 if (name == NULL)
fb52b2f4 16634 {
0fd3a477 16635 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 16636 ret = 1;
16637 break;
fb52b2f4 16638 }
2cf0635d 16639 namelen = strlen (name);
fb52b2f4 16640
2cf0635d
NC		 16641 qualified_name = make_qualified_name (&arch, &nested_arch, name);
16642 if (qualified_name == NULL)
fb52b2f4 16643 {
2cf0635d 16644 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 16645 ret = 1;
16646 break;
fb52b2f4
NC		 16647 }
16648
2cf0635d
NC		 16649 if (is_thin_archive && arch.nested_member_origin == 0)
16650 {
16651 /* This is a proxy for an external member of a thin archive. */
16652 FILE * member_file;
16653 char * member_file_name = adjust_relative_path (file_name, name, namelen);
16654 if (member_file_name == NULL)
16655 {
16656 ret = 1;
16657 break;
16658 }
16659
16660 member_file = fopen (member_file_name, "rb");
16661 if (member_file == NULL)
16662 {
16663 error (_("Input file '%s' is not readable.\n"), member_file_name);
16664 free (member_file_name);
16665 ret = 1;
16666 break;
16667 }
16668
16669 archive_file_offset = arch.nested_member_origin;
16670
16671 ret |= process_object (qualified_name, member_file);
16672
16673 fclose (member_file);
16674 free (member_file_name);
16675 }
16676 else if (is_thin_archive)
16677 {
a043396b
NC		 16678 /* PR 15140: Allow for corrupt thin archives. */
16679 if (nested_arch.file == NULL)
16680 {
16681 error (_("%s: contains corrupt thin archive: %s\n"),
16682 file_name, name);
16683 ret = 1;
16684 break;
16685 }
16686
2cf0635d
NC		 16687 /* This is a proxy for a member of a nested archive. */
16688 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
16689
16690 /* The nested archive file will have been opened and setup by
16691 get_archive_member_name. */
16692 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
16693 {
16694 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
16695 ret = 1;
16696 break;
16697 }
16698
16699 ret |= process_object (qualified_name, nested_arch.file);
16700 }
16701 else
16702 {
16703 archive_file_offset = arch.next_arhdr_offset;
16704 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 16705
2cf0635d
NC		 16706 ret |= process_object (qualified_name, file);
16707 }
fb52b2f4 16708
2b52916e
L		 16709 if (dump_sects != NULL)
16710 {
16711 free (dump_sects);
16712 dump_sects = NULL;
16713 num_dump_sects = 0;
16714 }
16715
2cf0635d 16716 free (qualified_name);
fb52b2f4
NC		 16717 }
16718
4145f1d5 16719 out:
2cf0635d
NC		 16720 if (nested_arch.file != NULL)
16721 fclose (nested_arch.file);
16722 release_archive (&nested_arch);
16723 release_archive (&arch);
fb52b2f4 16724
d989285c 16725 return ret;
fb52b2f4
NC		 16726}
16727
16728static int
2cf0635d 16729process_file (char * file_name)
fb52b2f4 16730{
2cf0635d 16731 FILE * file;
fb52b2f4
NC		 16732 struct stat statbuf;
16733 char armag[SARMAG];
16734 int ret;
16735
16736 if (stat (file_name, &statbuf) < 0)
16737 {
f24ddbdd
NC		 16738 if (errno == ENOENT)
16739 error (_("'%s': No such file\n"), file_name);
16740 else
16741 error (_("Could not locate '%s'. System error message: %s\n"),
16742 file_name, strerror (errno));
16743 return 1;
16744 }
16745
16746 if (! S_ISREG (statbuf.st_mode))
16747 {
16748 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 16749 return 1;
16750 }
16751
16752 file = fopen (file_name, "rb");
16753 if (file == NULL)
16754 {
f24ddbdd 16755 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 16756 return 1;
16757 }
16758
16759 if (fread (armag, SARMAG, 1, file) != 1)
16760 {
4145f1d5 16761 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 16762 fclose (file);
16763 return 1;
16764 }
16765
f54498b4
NC		 16766 current_file_size = (bfd_size_type) statbuf.st_size;
16767
fb52b2f4 16768 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 16769 ret = process_archive (file_name, file, FALSE);
16770 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
16771 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 16772 else
16773 {
4145f1d5
NC		 16774 if (do_archive_index)
16775 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16776 file_name);
16777
fb52b2f4
NC		 16778 rewind (file);
16779 archive_file_size = archive_file_offset = 0;
16780 ret = process_object (file_name, file);
16781 }
16782
16783 fclose (file);
16784
f54498b4 16785 current_file_size = 0;
fb52b2f4
NC		 16786 return ret;
16787}
16788
252b5132
RH		 16789#ifdef SUPPORT_DISASSEMBLY
16790/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 16791 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 16792 symbols. */
252b5132
RH		 16793
16794void
2cf0635d 16795print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 16796{
16797 fprintf (outfile,"0x%8.8x", addr);
16798}
16799
e3c8793a 16800/* Needed by the i386 disassembler. */
252b5132
RH		 16801void
16802db_task_printsym (unsigned int addr)
16803{
16804 print_address (addr, stderr);
16805}
16806#endif
16807
16808int
2cf0635d 16809main (int argc, char ** argv)
252b5132 16810{
ff78d6d6
L		 16811 int err;
16812
252b5132
RH		 16813#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16814 setlocale (LC_MESSAGES, "");
3882b010
L		 16815#endif
16816#if defined (HAVE_SETLOCALE)
16817 setlocale (LC_CTYPE, "");
252b5132
RH		 16818#endif
16819 bindtextdomain (PACKAGE, LOCALEDIR);
16820 textdomain (PACKAGE);
16821
869b9d07
MM		 16822 expandargv (&argc, &argv);
16823
252b5132
RH		 16824 parse_args (argc, argv);
16825
18bd398b 16826 if (num_dump_sects > 0)
59f14fc0 16827 {
18bd398b 16828 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 16829 cmdline_dump_sects = (dump_type *)
16830 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 16831 if (cmdline_dump_sects == NULL)
591a748a 16832 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 16833 else
16834 {
09c11c86
NC		 16835 memcpy (cmdline_dump_sects, dump_sects,
16836 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 16837 num_cmdline_dump_sects = num_dump_sects;
16838 }
16839 }
16840
18bd398b
NC		 16841 if (optind < (argc - 1))
16842 show_name = 1;
5656ba2c
L		 16843 else if (optind >= argc)
16844 {
16845 warn (_("Nothing to do.\n"));
16846 usage (stderr);
16847 }
18bd398b 16848
ff78d6d6 16849 err = 0;
252b5132 16850 while (optind < argc)
18bd398b 16851 err |= process_file (argv[optind++]);
252b5132
RH		 16852
16853 if (dump_sects != NULL)
16854 free (dump_sects);
59f14fc0
AS		 16855 if (cmdline_dump_sects != NULL)
16856 free (cmdline_dump_sects);
252b5132 16857
ff78d6d6 16858 return err;
252b5132 16859}
A mirror of the official binutils-gdb repository