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