]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - binutils/readelf.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Automatic date update in version.in
[thirdparty/binutils-gdb.git] / binutils / readelf.c
CommitLineData
252b5132 1/* readelf.c -- display contents of an ELF format file
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
252b5132 3691static const char *
d3ba0551 3692get_segment_type (unsigned long p_type)
252b5132 3693{
b34976b6 3694 static char buff[32];
252b5132
RH		 3695
3696 switch (p_type)
3697 {
b34976b6
AM		 3698 case PT_NULL: return "NULL";
3699 case PT_LOAD: return "LOAD";
252b5132 3700 case PT_DYNAMIC: return "DYNAMIC";
b34976b6
AM		 3701 case PT_INTERP: return "INTERP";
3702 case PT_NOTE: return "NOTE";
3703 case PT_SHLIB: return "SHLIB";
3704 case PT_PHDR: return "PHDR";
13ae64f3 3705 case PT_TLS: return "TLS";
252b5132 3706
65765700
JJ		 3707 case PT_GNU_EH_FRAME:
3708 return "GNU_EH_FRAME";
2b05f1b7 3709 case PT_GNU_STACK: return "GNU_STACK";
8c37241b 3710 case PT_GNU_RELRO: return "GNU_RELRO";
65765700 3711
252b5132
RH		 3712 default:
3713 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3714 {
2cf0635d 3715 const char * result;
103f02d3 3716
252b5132
RH		 3717 switch (elf_header.e_machine)
3718 {
a06ea964
NC		 3719 case EM_AARCH64:
3720 result = get_aarch64_segment_type (p_type);
3721 break;
b294bdf8
MM		 3722 case EM_ARM:
3723 result = get_arm_segment_type (p_type);
3724 break;
252b5132 3725 case EM_MIPS:
4fe85591 3726 case EM_MIPS_RS3_LE:
252b5132
RH		 3727 result = get_mips_segment_type (p_type);
3728 break;
103f02d3
UD		 3729 case EM_PARISC:
3730 result = get_parisc_segment_type (p_type);
3731 break;
4d6ed7c8
NC		 3732 case EM_IA_64:
3733 result = get_ia64_segment_type (p_type);
3734 break;
40b36596
JM		 3735 case EM_TI_C6000:
3736 result = get_tic6x_segment_type (p_type);
3737 break;
252b5132
RH		 3738 default:
3739 result = NULL;
3740 break;
3741 }
103f02d3 3742
252b5132
RH		 3743 if (result != NULL)
3744 return result;
103f02d3 3745
252b5132
RH		 3746 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3747 }
3748 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3 3749 {
2cf0635d 3750 const char * result;
103f02d3
UD		 3751
3752 switch (elf_header.e_machine)
3753 {
3754 case EM_PARISC:
3755 result = get_parisc_segment_type (p_type);
3756 break;
00428cca
AM		 3757 case EM_IA_64:
3758 result = get_ia64_segment_type (p_type);
3759 break;
103f02d3
UD		 3760 default:
3761 result = NULL;
3762 break;
3763 }
3764
3765 if (result != NULL)
3766 return result;
3767
3768 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3769 }
252b5132 3770 else
e9e44622 3771 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
252b5132
RH		 3772
3773 return buff;
3774 }
3775}
3776
3777static const char *
d3ba0551 3778get_mips_section_type_name (unsigned int sh_type)
252b5132
RH		 3779{
3780 switch (sh_type)
3781 {
b34976b6
AM		 3782 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3783 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3784 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3785 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3786 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3787 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3788 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3789 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3790 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3791 case SHT_MIPS_RELD: return "MIPS_RELD";
3792 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3793 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3794 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3795 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3796 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3797 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3798 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3799 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3800 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3801 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3802 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3803 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3804 case SHT_MIPS_LINE: return "MIPS_LINE";
3805 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3806 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3807 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3808 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3809 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3810 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3811 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3812 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3813 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3814 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3815 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3816 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3817 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3818 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3819 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
252b5132 3820 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
351cdf24 3821 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
252b5132
RH		 3822 default:
3823 break;
3824 }
3825 return NULL;
3826}
3827
103f02d3 3828static const char *
d3ba0551 3829get_parisc_section_type_name (unsigned int sh_type)
103f02d3
UD		 3830{
3831 switch (sh_type)
3832 {
3833 case SHT_PARISC_EXT: return "PARISC_EXT";
3834 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3835 case SHT_PARISC_DOC: return "PARISC_DOC";
eec8f817
DA		 3836 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3837 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3838 case SHT_PARISC_STUBS: return "PARISC_STUBS";
61472819 3839 case SHT_PARISC_DLKM: return "PARISC_DLKM";
103f02d3
UD		 3840 default:
3841 break;
3842 }
3843 return NULL;
3844}
3845
4d6ed7c8 3846static const char *
d3ba0551 3847get_ia64_section_type_name (unsigned int sh_type)
4d6ed7c8 3848{
18bd398b 3849 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
ecc51f48
NC		 3850 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3851 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
0de14b54 3852
4d6ed7c8
NC		 3853 switch (sh_type)
3854 {
148b93f2
NC		 3855 case SHT_IA_64_EXT: return "IA_64_EXT";
3856 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3857 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3858 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3859 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3860 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3861 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3862 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3863 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3864 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4d6ed7c8
NC		 3865 default:
3866 break;
3867 }
3868 return NULL;
3869}
3870
d2b2c203
DJ		 3871static const char *
3872get_x86_64_section_type_name (unsigned int sh_type)
3873{
3874 switch (sh_type)
3875 {
3876 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3877 default:
3878 break;
3879 }
3880 return NULL;
3881}
3882
a06ea964
NC		 3883static const char *
3884get_aarch64_section_type_name (unsigned int sh_type)
3885{
3886 switch (sh_type)
3887 {
3888 case SHT_AARCH64_ATTRIBUTES:
3889 return "AARCH64_ATTRIBUTES";
3890 default:
3891 break;
3892 }
3893 return NULL;
3894}
3895
40a18ebd
NC		 3896static const char *
3897get_arm_section_type_name (unsigned int sh_type)
3898{
3899 switch (sh_type)
3900 {
7f6fed87
NC		 3901 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3902 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3903 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3904 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3905 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
40a18ebd
NC		 3906 default:
3907 break;
3908 }
3909 return NULL;
3910}
3911
40b36596
JM		 3912static const char *
3913get_tic6x_section_type_name (unsigned int sh_type)
3914{
3915 switch (sh_type)
3916 {
3917 case SHT_C6000_UNWIND:
3918 return "C6000_UNWIND";
3919 case SHT_C6000_PREEMPTMAP:
3920 return "C6000_PREEMPTMAP";
3921 case SHT_C6000_ATTRIBUTES:
3922 return "C6000_ATTRIBUTES";
3923 case SHT_TI_ICODE:
3924 return "TI_ICODE";
3925 case SHT_TI_XREF:
3926 return "TI_XREF";
3927 case SHT_TI_HANDLER:
3928 return "TI_HANDLER";
3929 case SHT_TI_INITINFO:
3930 return "TI_INITINFO";
3931 case SHT_TI_PHATTRS:
3932 return "TI_PHATTRS";
3933 default:
3934 break;
3935 }
3936 return NULL;
3937}
3938
13761a11
NC		 3939static const char *
3940get_msp430x_section_type_name (unsigned int sh_type)
3941{
3942 switch (sh_type)
3943 {
3944 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
3945 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3946 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
3947 default: return NULL;
3948 }
3949}
3950
685080f2
NC		 3951static const char *
3952get_v850_section_type_name (unsigned int sh_type)
3953{
3954 switch (sh_type)
3955 {
3956 case SHT_V850_SCOMMON: return "V850 Small Common";
3957 case SHT_V850_TCOMMON: return "V850 Tiny Common";
3958 case SHT_V850_ZCOMMON: return "V850 Zero Common";
3959 case SHT_RENESAS_IOP: return "RENESAS IOP";
3960 case SHT_RENESAS_INFO: return "RENESAS INFO";
3961 default: return NULL;
3962 }
3963}
3964
252b5132 3965static const char *
d3ba0551 3966get_section_type_name (unsigned int sh_type)
252b5132 3967{
b34976b6 3968 static char buff[32];
9fb71ee4 3969 const char * result;
252b5132
RH		 3970
3971 switch (sh_type)
3972 {
3973 case SHT_NULL: return "NULL";
3974 case SHT_PROGBITS: return "PROGBITS";
3975 case SHT_SYMTAB: return "SYMTAB";
3976 case SHT_STRTAB: return "STRTAB";
3977 case SHT_RELA: return "RELA";
3978 case SHT_HASH: return "HASH";
3979 case SHT_DYNAMIC: return "DYNAMIC";
3980 case SHT_NOTE: return "NOTE";
3981 case SHT_NOBITS: return "NOBITS";
3982 case SHT_REL: return "REL";
3983 case SHT_SHLIB: return "SHLIB";
3984 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 3985 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3986 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3987 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
fdc90cb4 3988 case SHT_GNU_HASH: return "GNU_HASH";
93ebe586
NC		 3989 case SHT_GROUP: return "GROUP";
3990 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
252b5132
RH		 3991 case SHT_GNU_verdef: return "VERDEF";
3992 case SHT_GNU_verneed: return "VERNEED";
3993 case SHT_GNU_versym: return "VERSYM";
b34976b6
AM		 3994 case 0x6ffffff0: return "VERSYM";
3995 case 0x6ffffffc: return "VERDEF";
252b5132
RH		 3996 case 0x7ffffffd: return "AUXILIARY";
3997 case 0x7fffffff: return "FILTER";
047b2264 3998 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
252b5132
RH		 3999
4000 default:
4001 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4002 {
252b5132
RH		 4003 switch (elf_header.e_machine)
4004 {
4005 case EM_MIPS:
4fe85591 4006 case EM_MIPS_RS3_LE:
252b5132
RH		 4007 result = get_mips_section_type_name (sh_type);
4008 break;
103f02d3
UD		 4009 case EM_PARISC:
4010 result = get_parisc_section_type_name (sh_type);
4011 break;
4d6ed7c8
NC		 4012 case EM_IA_64:
4013 result = get_ia64_section_type_name (sh_type);
4014 break;
d2b2c203 4015 case EM_X86_64:
8a9036a4 4016 case EM_L1OM:
7a9068fe 4017 case EM_K1OM:
d2b2c203
DJ		 4018 result = get_x86_64_section_type_name (sh_type);
4019 break;
a06ea964
NC		 4020 case EM_AARCH64:
4021 result = get_aarch64_section_type_name (sh_type);
4022 break;
40a18ebd
NC		 4023 case EM_ARM:
4024 result = get_arm_section_type_name (sh_type);
4025 break;
40b36596
JM		 4026 case EM_TI_C6000:
4027 result = get_tic6x_section_type_name (sh_type);
4028 break;
13761a11
NC		 4029 case EM_MSP430:
4030 result = get_msp430x_section_type_name (sh_type);
4031 break;
685080f2
NC		 4032 case EM_V800:
4033 case EM_V850:
4034 case EM_CYGNUS_V850:
4035 result = get_v850_section_type_name (sh_type);
4036 break;
252b5132
RH		 4037 default:
4038 result = NULL;
4039 break;
4040 }
4041
4042 if (result != NULL)
4043 return result;
4044
9fb71ee4 4045 sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
252b5132
RH		 4046 }
4047 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
148b93f2 4048 {
148b93f2
NC		 4049 switch (elf_header.e_machine)
4050 {
4051 case EM_IA_64:
4052 result = get_ia64_section_type_name (sh_type);
4053 break;
4054 default:
fd85a6a1
NC		 4055 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4056 result = get_solaris_section_type (sh_type);
4057 else
4058 result = NULL;
148b93f2
NC		 4059 break;
4060 }
4061
4062 if (result != NULL)
4063 return result;
4064
9fb71ee4 4065 sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
148b93f2 4066 }
252b5132 4067 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
685080f2
NC		 4068 {
4069 switch (elf_header.e_machine)
4070 {
4071 case EM_V800:
4072 case EM_V850:
4073 case EM_CYGNUS_V850:
9fb71ee4 4074 result = get_v850_section_type_name (sh_type);
a9fb83be 4075 break;
685080f2 4076 default:
9fb71ee4 4077 result = NULL;
685080f2
NC		 4078 break;
4079 }
4080
9fb71ee4
NC		 4081 if (result != NULL)
4082 return result;
4083
4084 sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
685080f2 4085 }
252b5132 4086 else
a7dbfd1c
NC		 4087 /* This message is probably going to be displayed in a 15
4088 character wide field, so put the hex value first. */
4089 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
103f02d3 4090
252b5132
RH		 4091 return buff;
4092 }
4093}
4094
2979dc34 4095#define OPTION_DEBUG_DUMP 512
2c610e4b 4096#define OPTION_DYN_SYMS 513
fd2f0033
TT		 4097#define OPTION_DWARF_DEPTH 514
4098#define OPTION_DWARF_START 515
4723351a 4099#define OPTION_DWARF_CHECK 516
2979dc34 4100
85b1c36d 4101static struct option options[] =
252b5132 4102{
b34976b6 4103 {"all", no_argument, 0, 'a'},
252b5132
RH		 4104 {"file-header", no_argument, 0, 'h'},
4105 {"program-headers", no_argument, 0, 'l'},
b34976b6
AM		 4106 {"headers", no_argument, 0, 'e'},
4107 {"histogram", no_argument, 0, 'I'},
4108 {"segments", no_argument, 0, 'l'},
4109 {"sections", no_argument, 0, 'S'},
252b5132 4110 {"section-headers", no_argument, 0, 'S'},
f5842774 4111 {"section-groups", no_argument, 0, 'g'},
5477e8a0 4112 {"section-details", no_argument, 0, 't'},
595cf52e 4113 {"full-section-name",no_argument, 0, 'N'},
b34976b6
AM		 4114 {"symbols", no_argument, 0, 's'},
4115 {"syms", no_argument, 0, 's'},
2c610e4b 4116 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
b34976b6
AM		 4117 {"relocs", no_argument, 0, 'r'},
4118 {"notes", no_argument, 0, 'n'},
4119 {"dynamic", no_argument, 0, 'd'},
a952a375 4120 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 4121 {"version-info", no_argument, 0, 'V'},
4122 {"use-dynamic", no_argument, 0, 'D'},
09c11c86 4123 {"unwind", no_argument, 0, 'u'},
4145f1d5 4124 {"archive-index", no_argument, 0, 'c'},
b34976b6 4125 {"hex-dump", required_argument, 0, 'x'},
cf13d699 4126 {"relocated-dump", required_argument, 0, 'R'},
09c11c86 4127 {"string-dump", required_argument, 0, 'p'},
0e602686 4128 {"decompress", no_argument, 0, 'z'},
252b5132
RH		 4129#ifdef SUPPORT_DISASSEMBLY
4130 {"instruction-dump", required_argument, 0, 'i'},
4131#endif
cf13d699 4132 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
252b5132 4133
fd2f0033
TT		 4134 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
4135 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4723351a 4136 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
fd2f0033 4137
b34976b6
AM		 4138 {"version", no_argument, 0, 'v'},
4139 {"wide", no_argument, 0, 'W'},
4140 {"help", no_argument, 0, 'H'},
4141 {0, no_argument, 0, 0}
252b5132
RH		 4142};
4143
4144static void
2cf0635d 4145usage (FILE * stream)
252b5132 4146{
92f01d61
JM		 4147 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4148 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4149 fprintf (stream, _(" Options are:\n\
8b53311e
NC		 4150 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4151 -h --file-header Display the ELF file header\n\
4152 -l --program-headers Display the program headers\n\
4153 --segments An alias for --program-headers\n\
4154 -S --section-headers Display the sections' header\n\
4155 --sections An alias for --section-headers\n\
f5842774 4156 -g --section-groups Display the section groups\n\
5477e8a0 4157 -t --section-details Display the section details\n\
8b53311e
NC		 4158 -e --headers Equivalent to: -h -l -S\n\
4159 -s --syms Display the symbol table\n\
3f08eb35 4160 --symbols An alias for --syms\n\
2c610e4b 4161 --dyn-syms Display the dynamic symbol table\n\
8b53311e
NC		 4162 -n --notes Display the core notes (if present)\n\
4163 -r --relocs Display the relocations (if present)\n\
4164 -u --unwind Display the unwind info (if present)\n\
b2d38a17 4165 -d --dynamic Display the dynamic section (if present)\n\
8b53311e 4166 -V --version-info Display the version sections (if present)\n\
1b31d05e 4167 -A --arch-specific Display architecture specific information (if any)\n\
4145f1d5 4168 -c --archive-index Display the symbol/file index in an archive\n\
8b53311e 4169 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
09c11c86
NC		 4170 -x --hex-dump=<number|name>\n\
4171 Dump the contents of section <number|name> as bytes\n\
4172 -p --string-dump=<number|name>\n\
4173 Dump the contents of section <number|name> as strings\n\
cf13d699
NC		 4174 -R --relocated-dump=<number|name>\n\
4175 Dump the contents of section <number|name> as relocated bytes\n\
0e602686 4176 -z --decompress Decompress section before dumping it\n\
f9f0e732 4177 -w[lLiaprmfFsoRt] or\n\
1ed06042 4178 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
6f875884 4179 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
657d0d47
CC		 4180 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4181 =addr,=cu_index]\n\
8b53311e 4182 Display the contents of DWARF2 debug sections\n"));
fd2f0033
TT		 4183 fprintf (stream, _("\
4184 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4185 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4186 or deeper\n"));
252b5132 4187#ifdef SUPPORT_DISASSEMBLY
92f01d61 4188 fprintf (stream, _("\
09c11c86
NC		 4189 -i --instruction-dump=<number|name>\n\
4190 Disassemble the contents of section <number|name>\n"));
252b5132 4191#endif
92f01d61 4192 fprintf (stream, _("\
8b53311e
NC		 4193 -I --histogram Display histogram of bucket list lengths\n\
4194 -W --wide Allow output width to exceed 80 characters\n\
07012eee 4195 @<file> Read options from <file>\n\
8b53311e
NC		 4196 -H --help Display this information\n\
4197 -v --version Display the version number of readelf\n"));
1118d252 4198
92f01d61
JM		 4199 if (REPORT_BUGS_TO[0] && stream == stdout)
4200 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 4201
92f01d61 4202 exit (stream == stdout ? 0 : 1);
252b5132
RH		 4203}
4204
18bd398b
NC		 4205/* Record the fact that the user wants the contents of section number
4206 SECTION to be displayed using the method(s) encoded as flags bits
4207 in TYPE. Note, TYPE can be zero if we are creating the array for
4208 the first time. */
4209
252b5132 4210static void
09c11c86 4211request_dump_bynumber (unsigned int section, dump_type type)
252b5132
RH		 4212{
4213 if (section >= num_dump_sects)
4214 {
2cf0635d 4215 dump_type * new_dump_sects;
252b5132 4216
3f5e193b
NC		 4217 new_dump_sects = (dump_type *) calloc (section + 1,
4218 sizeof (* dump_sects));
252b5132
RH		 4219
4220 if (new_dump_sects == NULL)
591a748a 4221 error (_("Out of memory allocating dump request table.\n"));
252b5132
RH		 4222 else
4223 {
4224 /* Copy current flag settings. */
09c11c86 4225 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
252b5132
RH		 4226
4227 free (dump_sects);
4228
4229 dump_sects = new_dump_sects;
4230 num_dump_sects = section + 1;
4231 }
4232 }
4233
4234 if (dump_sects)
b34976b6 4235 dump_sects[section] |= type;
252b5132
RH		 4236
4237 return;
4238}
4239
aef1f6d0
DJ		 4240/* Request a dump by section name. */
4241
4242static void
2cf0635d 4243request_dump_byname (const char * section, dump_type type)
aef1f6d0 4244{
2cf0635d 4245 struct dump_list_entry * new_request;
aef1f6d0 4246
3f5e193b
NC		 4247 new_request = (struct dump_list_entry *)
4248 malloc (sizeof (struct dump_list_entry));
aef1f6d0 4249 if (!new_request)
591a748a 4250 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4251
4252 new_request->name = strdup (section);
4253 if (!new_request->name)
591a748a 4254 error (_("Out of memory allocating dump request table.\n"));
aef1f6d0
DJ		 4255
4256 new_request->type = type;
4257
4258 new_request->next = dump_sects_byname;
4259 dump_sects_byname = new_request;
4260}
4261
cf13d699
NC		 4262static inline void
4263request_dump (dump_type type)
4264{
4265 int section;
4266 char * cp;
4267
4268 do_dump++;
4269 section = strtoul (optarg, & cp, 0);
4270
4271 if (! *cp && section >= 0)
4272 request_dump_bynumber (section, type);
4273 else
4274 request_dump_byname (optarg, type);
4275}
4276
4277
252b5132 4278static void
2cf0635d 4279parse_args (int argc, char ** argv)
252b5132
RH		 4280{
4281 int c;
4282
4283 if (argc < 2)
92f01d61 4284 usage (stderr);
252b5132
RH		 4285
4286 while ((c = getopt_long
0e602686 4287 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
252b5132 4288 {
252b5132
RH		 4289 switch (c)
4290 {
4291 case 0:
4292 /* Long options. */
4293 break;
4294 case 'H':
92f01d61 4295 usage (stdout);
252b5132
RH		 4296 break;
4297
4298 case 'a':
b34976b6
AM		 4299 do_syms++;
4300 do_reloc++;
4301 do_unwind++;
4302 do_dynamic++;
4303 do_header++;
4304 do_sections++;
f5842774 4305 do_section_groups++;
b34976b6
AM		 4306 do_segments++;
4307 do_version++;
4308 do_histogram++;
4309 do_arch++;
4310 do_notes++;
252b5132 4311 break;
f5842774
L		 4312 case 'g':
4313 do_section_groups++;
4314 break;
5477e8a0 4315 case 't':
595cf52e 4316 case 'N':
5477e8a0
L		 4317 do_sections++;
4318 do_section_details++;
595cf52e 4319 break;
252b5132 4320 case 'e':
b34976b6
AM		 4321 do_header++;
4322 do_sections++;
4323 do_segments++;
252b5132 4324 break;
a952a375 4325 case 'A':
b34976b6 4326 do_arch++;
a952a375 4327 break;
252b5132 4328 case 'D':
b34976b6 4329 do_using_dynamic++;
252b5132
RH		 4330 break;
4331 case 'r':
b34976b6 4332 do_reloc++;
252b5132 4333 break;
4d6ed7c8 4334 case 'u':
b34976b6 4335 do_unwind++;
4d6ed7c8 4336 break;
252b5132 4337 case 'h':
b34976b6 4338 do_header++;
252b5132
RH		 4339 break;
4340 case 'l':
b34976b6 4341 do_segments++;
252b5132
RH		 4342 break;
4343 case 's':
b34976b6 4344 do_syms++;
252b5132
RH		 4345 break;
4346 case 'S':
b34976b6 4347 do_sections++;
252b5132
RH		 4348 break;
4349 case 'd':
b34976b6 4350 do_dynamic++;
252b5132 4351 break;
a952a375 4352 case 'I':
b34976b6 4353 do_histogram++;
a952a375 4354 break;
779fe533 4355 case 'n':
b34976b6 4356 do_notes++;
779fe533 4357 break;
4145f1d5
NC		 4358 case 'c':
4359 do_archive_index++;
4360 break;
252b5132 4361 case 'x':
cf13d699 4362 request_dump (HEX_DUMP);
aef1f6d0 4363 break;
09c11c86 4364 case 'p':
cf13d699
NC		 4365 request_dump (STRING_DUMP);
4366 break;
4367 case 'R':
4368 request_dump (RELOC_DUMP);
09c11c86 4369 break;
0e602686
NC		 4370 case 'z':
4371 decompress_dumps++;
4372 break;
252b5132 4373 case 'w':
b34976b6 4374 do_dump++;
252b5132 4375 if (optarg == 0)
613ff48b
CC		 4376 {
4377 do_debugging = 1;
4378 dwarf_select_sections_all ();
4379 }
252b5132
RH		 4380 else
4381 {
4382 do_debugging = 0;
4cb93e3b 4383 dwarf_select_sections_by_letters (optarg);
252b5132
RH		 4384 }
4385 break;
2979dc34 4386 case OPTION_DEBUG_DUMP:
b34976b6 4387 do_dump++;
2979dc34
JJ		 4388 if (optarg == 0)
4389 do_debugging = 1;
4390 else
4391 {
2979dc34 4392 do_debugging = 0;
4cb93e3b 4393 dwarf_select_sections_by_names (optarg);
2979dc34
JJ		 4394 }
4395 break;
fd2f0033
TT		 4396 case OPTION_DWARF_DEPTH:
4397 {
4398 char *cp;
4399
4400 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4401 }
4402 break;
4403 case OPTION_DWARF_START:
4404 {
4405 char *cp;
4406
4407 dwarf_start_die = strtoul (optarg, & cp, 0);
4408 }
4409 break;
4723351a
CC		 4410 case OPTION_DWARF_CHECK:
4411 dwarf_check = 1;
4412 break;
2c610e4b
L		 4413 case OPTION_DYN_SYMS:
4414 do_dyn_syms++;
4415 break;
252b5132
RH		 4416#ifdef SUPPORT_DISASSEMBLY
4417 case 'i':
cf13d699
NC		 4418 request_dump (DISASS_DUMP);
4419 break;
252b5132
RH		 4420#endif
4421 case 'v':
4422 print_version (program_name);
4423 break;
4424 case 'V':
b34976b6 4425 do_version++;
252b5132 4426 break;
d974e256 4427 case 'W':
b34976b6 4428 do_wide++;
d974e256 4429 break;
252b5132 4430 default:
252b5132
RH		 4431 /* xgettext:c-format */
4432 error (_("Invalid option '-%c'\n"), c);
4433 /* Drop through. */
4434 case '?':
92f01d61 4435 usage (stderr);
252b5132
RH		 4436 }
4437 }
4438
4d6ed7c8 4439 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
252b5132 4440 && !do_segments && !do_header && !do_dump && !do_version
f5842774 4441 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b
L		 4442 && !do_section_groups && !do_archive_index
4443 && !do_dyn_syms)
92f01d61 4444 usage (stderr);
252b5132
RH		 4445}
4446
4447static const char *
d3ba0551 4448get_elf_class (unsigned int elf_class)
252b5132 4449{
b34976b6 4450 static char buff[32];
103f02d3 4451
252b5132
RH		 4452 switch (elf_class)
4453 {
4454 case ELFCLASSNONE: return _("none");
e3c8793a
NC		 4455 case ELFCLASS32: return "ELF32";
4456 case ELFCLASS64: return "ELF64";
ab5e7794 4457 default:
e9e44622 4458 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
ab5e7794 4459 return buff;
252b5132
RH		 4460 }
4461}
4462
4463static const char *
d3ba0551 4464get_data_encoding (unsigned int encoding)
252b5132 4465{
b34976b6 4466 static char buff[32];
103f02d3 4467
252b5132
RH		 4468 switch (encoding)
4469 {
4470 case ELFDATANONE: return _("none");
33c63f9d
CM		 4471 case ELFDATA2LSB: return _("2's complement, little endian");
4472 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 4473 default:
e9e44622 4474 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
ab5e7794 4475 return buff;
252b5132
RH		 4476 }
4477}
4478
252b5132 4479/* Decode the data held in 'elf_header'. */
ee42cf8c 4480
252b5132 4481static int
d3ba0551 4482process_file_header (void)
252b5132 4483{
b34976b6
AM		 4484 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
4485 || elf_header.e_ident[EI_MAG1] != ELFMAG1
4486 || elf_header.e_ident[EI_MAG2] != ELFMAG2
4487 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
252b5132
RH		 4488 {
4489 error
4490 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4491 return 0;
4492 }
4493
2dc4cec1
L		 4494 init_dwarf_regnames (elf_header.e_machine);
4495
252b5132
RH		 4496 if (do_header)
4497 {
4498 int i;
4499
4500 printf (_("ELF Header:\n"));
4501 printf (_(" Magic: "));
b34976b6
AM		 4502 for (i = 0; i < EI_NIDENT; i++)
4503 printf ("%2.2x ", elf_header.e_ident[i]);
252b5132
RH		 4504 printf ("\n");
4505 printf (_(" Class: %s\n"),
b34976b6 4506 get_elf_class (elf_header.e_ident[EI_CLASS]));
252b5132 4507 printf (_(" Data: %s\n"),
b34976b6 4508 get_data_encoding (elf_header.e_ident[EI_DATA]));
252b5132 4509 printf (_(" Version: %d %s\n"),
b34976b6
AM		 4510 elf_header.e_ident[EI_VERSION],
4511 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
789be9f7 4512 ? "(current)"
b34976b6 4513 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2b692964 4514 ? _("<unknown: %lx>")
789be9f7 4515 : "")));
252b5132 4516 printf (_(" OS/ABI: %s\n"),
b34976b6 4517 get_osabi_name (elf_header.e_ident[EI_OSABI]));
252b5132 4518 printf (_(" ABI Version: %d\n"),
b34976b6 4519 elf_header.e_ident[EI_ABIVERSION]);
252b5132
RH		 4520 printf (_(" Type: %s\n"),
4521 get_file_type (elf_header.e_type));
4522 printf (_(" Machine: %s\n"),
4523 get_machine_name (elf_header.e_machine));
4524 printf (_(" Version: 0x%lx\n"),
4525 (unsigned long) elf_header.e_version);
76da6bbe 4526
f7a99963
NC		 4527 printf (_(" Entry point address: "));
4528 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4529 printf (_("\n Start of program headers: "));
4530 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4531 printf (_(" (bytes into file)\n Start of section headers: "));
4532 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4533 printf (_(" (bytes into file)\n"));
76da6bbe 4534
252b5132
RH		 4535 printf (_(" Flags: 0x%lx%s\n"),
4536 (unsigned long) elf_header.e_flags,
4537 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4538 printf (_(" Size of this header: %ld (bytes)\n"),
4539 (long) elf_header.e_ehsize);
4540 printf (_(" Size of program headers: %ld (bytes)\n"),
4541 (long) elf_header.e_phentsize);
2046a35d 4542 printf (_(" Number of program headers: %ld"),
252b5132 4543 (long) elf_header.e_phnum);
2046a35d
AM		 4544 if (section_headers != NULL
4545 && elf_header.e_phnum == PN_XNUM
4546 && section_headers[0].sh_info != 0)
cc5914eb 4547 printf (" (%ld)", (long) section_headers[0].sh_info);
2046a35d 4548 putc ('\n', stdout);
252b5132
RH		 4549 printf (_(" Size of section headers: %ld (bytes)\n"),
4550 (long) elf_header.e_shentsize);
560f3c1c 4551 printf (_(" Number of section headers: %ld"),
252b5132 4552 (long) elf_header.e_shnum);
4fbb74a6 4553 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
560f3c1c
AM		 4554 printf (" (%ld)", (long) section_headers[0].sh_size);
4555 putc ('\n', stdout);
4556 printf (_(" Section header string table index: %ld"),
252b5132 4557 (long) elf_header.e_shstrndx);
4fbb74a6
AM		 4558 if (section_headers != NULL
4559 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
72de5009 4560 printf (" (%u)", section_headers[0].sh_link);
15ba6505
AM		 4561 else if (elf_header.e_shstrndx != SHN_UNDEF
4562 && elf_header.e_shstrndx >= elf_header.e_shnum)
2b692964 4563 printf (_(" <corrupt: out of range>"));
560f3c1c
AM		 4564 putc ('\n', stdout);
4565 }
4566
4567 if (section_headers != NULL)
4568 {
2046a35d
AM		 4569 if (elf_header.e_phnum == PN_XNUM
4570 && section_headers[0].sh_info != 0)
4571 elf_header.e_phnum = section_headers[0].sh_info;
4fbb74a6 4572 if (elf_header.e_shnum == SHN_UNDEF)
560f3c1c 4573 elf_header.e_shnum = section_headers[0].sh_size;
4fbb74a6 4574 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
560f3c1c 4575 elf_header.e_shstrndx = section_headers[0].sh_link;
4fbb74a6 4576 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
0b49d371 4577 elf_header.e_shstrndx = SHN_UNDEF;
560f3c1c
AM		 4578 free (section_headers);
4579 section_headers = NULL;
252b5132 4580 }
103f02d3 4581
9ea033b2
NC		 4582 return 1;
4583}
4584
e0a31db1 4585static bfd_boolean
91d6fa6a 4586get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4587{
2cf0635d
NC		 4588 Elf32_External_Phdr * phdrs;
4589 Elf32_External_Phdr * external;
4590 Elf_Internal_Phdr * internal;
b34976b6 4591 unsigned int i;
e0a31db1
NC		 4592 unsigned int size = elf_header.e_phentsize;
4593 unsigned int num = elf_header.e_phnum;
4594
4595 /* PR binutils/17531: Cope with unexpected section header sizes. */
4596 if (size == 0 || num == 0)
4597 return FALSE;
4598 if (size < sizeof * phdrs)
4599 {
4600 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4601 return FALSE;
4602 }
4603 if (size > sizeof * phdrs)
4604 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4605
3f5e193b 4606 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1
NC		 4607 size, num, _("program headers"));
4608 if (phdrs == NULL)
4609 return FALSE;
9ea033b2 4610
91d6fa6a 4611 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4612 i < elf_header.e_phnum;
b34976b6 4613 i++, internal++, external++)
252b5132 4614 {
9ea033b2
NC		 4615 internal->p_type = BYTE_GET (external->p_type);
4616 internal->p_offset = BYTE_GET (external->p_offset);
4617 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4618 internal->p_paddr = BYTE_GET (external->p_paddr);
4619 internal->p_filesz = BYTE_GET (external->p_filesz);
4620 internal->p_memsz = BYTE_GET (external->p_memsz);
4621 internal->p_flags = BYTE_GET (external->p_flags);
4622 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 4623 }
4624
9ea033b2 4625 free (phdrs);
e0a31db1 4626 return TRUE;
252b5132
RH		 4627}
4628
e0a31db1 4629static bfd_boolean
91d6fa6a 4630get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
9ea033b2 4631{
2cf0635d
NC		 4632 Elf64_External_Phdr * phdrs;
4633 Elf64_External_Phdr * external;
4634 Elf_Internal_Phdr * internal;
b34976b6 4635 unsigned int i;
e0a31db1
NC		 4636 unsigned int size = elf_header.e_phentsize;
4637 unsigned int num = elf_header.e_phnum;
4638
4639 /* PR binutils/17531: Cope with unexpected section header sizes. */
4640 if (size == 0 || num == 0)
4641 return FALSE;
4642 if (size < sizeof * phdrs)
4643 {
4644 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4645 return FALSE;
4646 }
4647 if (size > sizeof * phdrs)
4648 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
103f02d3 4649
3f5e193b 4650 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
e0a31db1 4651 size, num, _("program headers"));
a6e9f9df 4652 if (!phdrs)
e0a31db1 4653 return FALSE;
9ea033b2 4654
91d6fa6a 4655 for (i = 0, internal = pheaders, external = phdrs;
9ea033b2 4656 i < elf_header.e_phnum;
b34976b6 4657 i++, internal++, external++)
9ea033b2
NC		 4658 {
4659 internal->p_type = BYTE_GET (external->p_type);
4660 internal->p_flags = BYTE_GET (external->p_flags);
66543521
AM		 4661 internal->p_offset = BYTE_GET (external->p_offset);
4662 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4663 internal->p_paddr = BYTE_GET (external->p_paddr);
4664 internal->p_filesz = BYTE_GET (external->p_filesz);
4665 internal->p_memsz = BYTE_GET (external->p_memsz);
4666 internal->p_align = BYTE_GET (external->p_align);
9ea033b2
NC		 4667 }
4668
4669 free (phdrs);
e0a31db1 4670 return TRUE;
9ea033b2 4671}
252b5132 4672
d93f0186
NC		 4673/* Returns 1 if the program headers were read into `program_headers'. */
4674
4675static int
2cf0635d 4676get_program_headers (FILE * file)
d93f0186 4677{
2cf0635d 4678 Elf_Internal_Phdr * phdrs;
d93f0186
NC		 4679
4680 /* Check cache of prior read. */
4681 if (program_headers != NULL)
4682 return 1;
4683
3f5e193b
NC		 4684 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4685 sizeof (Elf_Internal_Phdr));
d93f0186
NC		 4686
4687 if (phdrs == NULL)
4688 {
8b73c356
NC		 4689 error (_("Out of memory reading %u program headers\n"),
4690 elf_header.e_phnum);
d93f0186
NC		 4691 return 0;
4692 }
4693
4694 if (is_32bit_elf
4695 ? get_32bit_program_headers (file, phdrs)
4696 : get_64bit_program_headers (file, phdrs))
4697 {
4698 program_headers = phdrs;
4699 return 1;
4700 }
4701
4702 free (phdrs);
4703 return 0;
4704}
4705
2f62977e
NC		 4706/* Returns 1 if the program headers were loaded. */
4707
252b5132 4708static int
2cf0635d 4709process_program_headers (FILE * file)
252b5132 4710{
2cf0635d 4711 Elf_Internal_Phdr * segment;
b34976b6 4712 unsigned int i;
252b5132
RH		 4713
4714 if (elf_header.e_phnum == 0)
4715 {
82f2dbf7
NC		 4716 /* PR binutils/12467. */
4717 if (elf_header.e_phoff != 0)
4718 warn (_("possibly corrupt ELF header - it has a non-zero program"
9035ed51 4719 " header offset, but no program headers\n"));
82f2dbf7 4720 else if (do_segments)
252b5132 4721 printf (_("\nThere are no program headers in this file.\n"));
2f62977e 4722 return 0;
252b5132
RH		 4723 }
4724
4725 if (do_segments && !do_header)
4726 {
f7a99963
NC		 4727 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4728 printf (_("Entry point "));
4729 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4730 printf (_("\nThere are %d program headers, starting at offset "),
4731 elf_header.e_phnum);
4732 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4733 printf ("\n");
252b5132
RH		 4734 }
4735
d93f0186 4736 if (! get_program_headers (file))
252b5132 4737 return 0;
103f02d3 4738
252b5132
RH		 4739 if (do_segments)
4740 {
3a1a2036
NC		 4741 if (elf_header.e_phnum > 1)
4742 printf (_("\nProgram Headers:\n"));
4743 else
4744 printf (_("\nProgram Headers:\n"));
76da6bbe 4745
f7a99963
NC		 4746 if (is_32bit_elf)
4747 printf
4748 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
d974e256
JJ		 4749 else if (do_wide)
4750 printf
4751 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
f7a99963
NC		 4752 else
4753 {
4754 printf
4755 (_(" Type Offset VirtAddr PhysAddr\n"));
4756 printf
4757 (_(" FileSiz MemSiz Flags Align\n"));
4758 }
252b5132
RH		 4759 }
4760
252b5132 4761 dynamic_addr = 0;
1b228002 4762 dynamic_size = 0;
252b5132
RH		 4763
4764 for (i = 0, segment = program_headers;
4765 i < elf_header.e_phnum;
b34976b6 4766 i++, segment++)
252b5132
RH		 4767 {
4768 if (do_segments)
4769 {
103f02d3 4770 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 4771
4772 if (is_32bit_elf)
4773 {
4774 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4775 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4776 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4777 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4778 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4779 printf ("%c%c%c ",
4780 (segment->p_flags & PF_R ? 'R' : ' '),
4781 (segment->p_flags & PF_W ? 'W' : ' '),
4782 (segment->p_flags & PF_X ? 'E' : ' '));
4783 printf ("%#lx", (unsigned long) segment->p_align);
4784 }
d974e256
JJ		 4785 else if (do_wide)
4786 {
4787 if ((unsigned long) segment->p_offset == segment->p_offset)
4788 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4789 else
4790 {
4791 print_vma (segment->p_offset, FULL_HEX);
4792 putchar (' ');
4793 }
4794
4795 print_vma (segment->p_vaddr, FULL_HEX);
4796 putchar (' ');
4797 print_vma (segment->p_paddr, FULL_HEX);
4798 putchar (' ');
4799
4800 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4801 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4802 else
4803 {
4804 print_vma (segment->p_filesz, FULL_HEX);
4805 putchar (' ');
4806 }
4807
4808 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4809 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4810 else
4811 {
f48e6c45 4812 print_vma (segment->p_memsz, FULL_HEX);
d974e256
JJ		 4813 }
4814
4815 printf (" %c%c%c ",
4816 (segment->p_flags & PF_R ? 'R' : ' '),
4817 (segment->p_flags & PF_W ? 'W' : ' '),
4818 (segment->p_flags & PF_X ? 'E' : ' '));
4819
4820 if ((unsigned long) segment->p_align == segment->p_align)
4821 printf ("%#lx", (unsigned long) segment->p_align);
4822 else
4823 {
4824 print_vma (segment->p_align, PREFIX_HEX);
4825 }
4826 }
f7a99963
NC		 4827 else
4828 {
4829 print_vma (segment->p_offset, FULL_HEX);
4830 putchar (' ');
4831 print_vma (segment->p_vaddr, FULL_HEX);
4832 putchar (' ');
4833 print_vma (segment->p_paddr, FULL_HEX);
4834 printf ("\n ");
4835 print_vma (segment->p_filesz, FULL_HEX);
4836 putchar (' ');
4837 print_vma (segment->p_memsz, FULL_HEX);
4838 printf (" %c%c%c ",
4839 (segment->p_flags & PF_R ? 'R' : ' '),
4840 (segment->p_flags & PF_W ? 'W' : ' '),
4841 (segment->p_flags & PF_X ? 'E' : ' '));
4842 print_vma (segment->p_align, HEX);
4843 }
252b5132
RH		 4844 }
4845
f54498b4
NC		 4846 if (do_segments)
4847 putc ('\n', stdout);
4848
252b5132
RH		 4849 switch (segment->p_type)
4850 {
252b5132
RH		 4851 case PT_DYNAMIC:
4852 if (dynamic_addr)
4853 error (_("more than one dynamic segment\n"));
4854
20737c13
AM		 4855 /* By default, assume that the .dynamic section is the first
4856 section in the DYNAMIC segment. */
4857 dynamic_addr = segment->p_offset;
4858 dynamic_size = segment->p_filesz;
f54498b4
NC		 4859 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4860 if (dynamic_addr + dynamic_size >= current_file_size)
4861 {
4862 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4863 dynamic_addr = dynamic_size = 0;
4864 }
20737c13 4865
b2d38a17
NC		 4866 /* Try to locate the .dynamic section. If there is
4867 a section header table, we can easily locate it. */
4868 if (section_headers != NULL)
4869 {
2cf0635d 4870 Elf_Internal_Shdr * sec;
b2d38a17 4871
89fac5e3
RS		 4872 sec = find_section (".dynamic");
4873 if (sec == NULL || sec->sh_size == 0)
b2d38a17 4874 {
28f997cf
TG		 4875 /* A corresponding .dynamic section is expected, but on
4876 IA-64/OpenVMS it is OK for it to be missing. */
4877 if (!is_ia64_vms ())
4878 error (_("no .dynamic section in the dynamic segment\n"));
b2d38a17
NC		 4879 break;
4880 }
4881
42bb2e33 4882 if (sec->sh_type == SHT_NOBITS)
20737c13
AM		 4883 {
4884 dynamic_size = 0;
4885 break;
4886 }
42bb2e33 4887
b2d38a17
NC		 4888 dynamic_addr = sec->sh_offset;
4889 dynamic_size = sec->sh_size;
4890
4891 if (dynamic_addr < segment->p_offset
4892 || dynamic_addr > segment->p_offset + segment->p_filesz)
20737c13
AM		 4893 warn (_("the .dynamic section is not contained"
4894 " within the dynamic segment\n"));
b2d38a17 4895 else if (dynamic_addr > segment->p_offset)
20737c13
AM		 4896 warn (_("the .dynamic section is not the first section"
4897 " in the dynamic segment.\n"));
b2d38a17 4898 }
252b5132
RH		 4899 break;
4900
4901 case PT_INTERP:
fb52b2f4
NC		 4902 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4903 SEEK_SET))
252b5132
RH		 4904 error (_("Unable to find program interpreter name\n"));
4905 else
4906 {
f8eae8b2 4907 char fmt [32];
9495b2e6 4908 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
f8eae8b2
L		 4909
4910 if (ret >= (int) sizeof (fmt) || ret < 0)
591a748a 4911 error (_("Internal error: failed to create format string to display program interpreter\n"));
f8eae8b2 4912
252b5132 4913 program_interpreter[0] = 0;
7bd7b3ef
AM		 4914 if (fscanf (file, fmt, program_interpreter) <= 0)
4915 error (_("Unable to read program interpreter name\n"));
252b5132
RH		 4916
4917 if (do_segments)
f54498b4 4918 printf (_(" [Requesting program interpreter: %s]\n"),
252b5132
RH		 4919 program_interpreter);
4920 }
4921 break;
4922 }
252b5132
RH		 4923 }
4924
c256ffe7 4925 if (do_segments && section_headers != NULL && string_table != NULL)
252b5132
RH		 4926 {
4927 printf (_("\n Section to Segment mapping:\n"));
4928 printf (_(" Segment Sections...\n"));
4929
252b5132
RH		 4930 for (i = 0; i < elf_header.e_phnum; i++)
4931 {
9ad5cbcf 4932 unsigned int j;
2cf0635d 4933 Elf_Internal_Shdr * section;
252b5132
RH		 4934
4935 segment = program_headers + i;
b391a3e3 4936 section = section_headers + 1;
252b5132
RH		 4937
4938 printf (" %2.2d ", i);
4939
b34976b6 4940 for (j = 1; j < elf_header.e_shnum; j++, section++)
252b5132 4941 {
f4638467
AM		 4942 if (!ELF_TBSS_SPECIAL (section, segment)
4943 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
74e1a04b 4944 printf ("%s ", printable_section_name (section));
252b5132
RH		 4945 }
4946
4947 putc ('\n',stdout);
4948 }
4949 }
4950
252b5132
RH		 4951 return 1;
4952}
4953
4954
d93f0186
NC		 4955/* Find the file offset corresponding to VMA by using the program headers. */
4956
4957static long
2cf0635d 4958offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
d93f0186 4959{
2cf0635d 4960 Elf_Internal_Phdr * seg;
d93f0186
NC		 4961
4962 if (! get_program_headers (file))
4963 {
4964 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4965 return (long) vma;
4966 }
4967
4968 for (seg = program_headers;
4969 seg < program_headers + elf_header.e_phnum;
4970 ++seg)
4971 {
4972 if (seg->p_type != PT_LOAD)
4973 continue;
4974
4975 if (vma >= (seg->p_vaddr & -seg->p_align)
4976 && vma + size <= seg->p_vaddr + seg->p_filesz)
4977 return vma - seg->p_vaddr + seg->p_offset;
4978 }
4979
4980 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
0af1713e 4981 (unsigned long) vma);
d93f0186
NC		 4982 return (long) vma;
4983}
4984
4985
049b0c3a
NC		 4986/* Allocate memory and load the sections headers into the global pointer
4987 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4988 generate any error messages if the load fails. */
4989
4990static bfd_boolean
4991get_32bit_section_headers (FILE * file, bfd_boolean probe)
252b5132 4992{
2cf0635d
NC		 4993 Elf32_External_Shdr * shdrs;
4994 Elf_Internal_Shdr * internal;
b34976b6 4995 unsigned int i;
049b0c3a
NC		 4996 unsigned int size = elf_header.e_shentsize;
4997 unsigned int num = probe ? 1 : elf_header.e_shnum;
4998
4999 /* PR binutils/17531: Cope with unexpected section header sizes. */
5000 if (size == 0 || num == 0)
5001 return FALSE;
5002 if (size < sizeof * shdrs)
5003 {
5004 if (! probe)
5005 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5006 return FALSE;
5007 }
5008 if (!probe && size > sizeof * shdrs)
5009 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
252b5132 5010
3f5e193b 5011 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 5012 size, num,
5013 probe ? NULL : _("section headers"));
5014 if (shdrs == NULL)
5015 return FALSE;
252b5132 5016
049b0c3a
NC		 5017 if (section_headers != NULL)
5018 free (section_headers);
3f5e193b
NC		 5019 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
5020 sizeof (Elf_Internal_Shdr));
252b5132
RH		 5021 if (section_headers == NULL)
5022 {
049b0c3a 5023 if (!probe)
8b73c356 5024 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 5025 return FALSE;
252b5132
RH		 5026 }
5027
5028 for (i = 0, internal = section_headers;
560f3c1c 5029 i < num;
b34976b6 5030 i++, internal++)
252b5132
RH		 5031 {
5032 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5033 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5034 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5035 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5036 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5037 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5038 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5039 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5040 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5041 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
5042 }
5043
5044 free (shdrs);
049b0c3a 5045 return TRUE;
252b5132
RH		 5046}
5047
049b0c3a
NC		 5048static bfd_boolean
5049get_64bit_section_headers (FILE * file, bfd_boolean probe)
9ea033b2 5050{
2cf0635d
NC		 5051 Elf64_External_Shdr * shdrs;
5052 Elf_Internal_Shdr * internal;
b34976b6 5053 unsigned int i;
049b0c3a
NC		 5054 unsigned int size = elf_header.e_shentsize;
5055 unsigned int num = probe ? 1 : elf_header.e_shnum;
5056
5057 /* PR binutils/17531: Cope with unexpected section header sizes. */
5058 if (size == 0 || num == 0)
5059 return FALSE;
5060 if (size < sizeof * shdrs)
5061 {
5062 if (! probe)
5063 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5064 return FALSE;
5065 }
5066 if (! probe && size > sizeof * shdrs)
5067 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
9ea033b2 5068
3f5e193b 5069 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
049b0c3a
NC		 5070 size, num,
5071 probe ? NULL : _("section headers"));
5072 if (shdrs == NULL)
5073 return FALSE;
9ea033b2 5074
049b0c3a
NC		 5075 if (section_headers != NULL)
5076 free (section_headers);
3f5e193b
NC		 5077 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
5078 sizeof (Elf_Internal_Shdr));
9ea033b2
NC		 5079 if (section_headers == NULL)
5080 {
049b0c3a 5081 if (! probe)
8b73c356 5082 error (_("Out of memory reading %u section headers\n"), num);
049b0c3a 5083 return FALSE;
9ea033b2
NC		 5084 }
5085
5086 for (i = 0, internal = section_headers;
560f3c1c 5087 i < num;
b34976b6 5088 i++, internal++)
9ea033b2
NC		 5089 {
5090 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5091 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
66543521
AM		 5092 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5093 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5094 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5095 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
9ea033b2
NC		 5096 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5097 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5098 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5099 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5100 }
5101
5102 free (shdrs);
049b0c3a 5103 return TRUE;
9ea033b2
NC		 5104}
5105
252b5132 5106static Elf_Internal_Sym *
ba5cdace
NC		 5107get_32bit_elf_symbols (FILE * file,
5108 Elf_Internal_Shdr * section,
5109 unsigned long * num_syms_return)
252b5132 5110{
ba5cdace 5111 unsigned long number = 0;
dd24e3da 5112 Elf32_External_Sym * esyms = NULL;
ba5cdace 5113 Elf_External_Sym_Shndx * shndx = NULL;
dd24e3da 5114 Elf_Internal_Sym * isyms = NULL;
2cf0635d 5115 Elf_Internal_Sym * psym;
b34976b6 5116 unsigned int j;
252b5132 5117
c9c1d674
EG		 5118 if (section->sh_size == 0)
5119 {
5120 if (num_syms_return != NULL)
5121 * num_syms_return = 0;
5122 return NULL;
5123 }
5124
dd24e3da 5125 /* Run some sanity checks first. */
c9c1d674 5126 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 5127 {
c9c1d674
EG		 5128 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5129 printable_section_name (section), (unsigned long) section->sh_entsize);
ba5cdace 5130 goto exit_point;
dd24e3da
NC		 5131 }
5132
f54498b4
NC		 5133 if (section->sh_size > current_file_size)
5134 {
5135 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
74e1a04b 5136 printable_section_name (section), (unsigned long) section->sh_size);
f54498b4
NC		 5137 goto exit_point;
5138 }
5139
dd24e3da
NC		 5140 number = section->sh_size / section->sh_entsize;
5141
5142 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5143 {
c9c1d674 5144 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 5145 (unsigned long) section->sh_size,
5146 printable_section_name (section),
5147 (unsigned long) section->sh_entsize);
ba5cdace 5148 goto exit_point;
dd24e3da
NC		 5149 }
5150
3f5e193b
NC		 5151 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5152 section->sh_size, _("symbols"));
dd24e3da 5153 if (esyms == NULL)
ba5cdace 5154 goto exit_point;
252b5132 5155
6a40cf0c
NC		 5156 {
5157 elf_section_list * entry;
5158
5159 shndx = NULL;
5160 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5161 if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
c9c1d674 5162 {
6a40cf0c
NC		 5163 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5164 entry->hdr->sh_offset,
5165 1, entry->hdr->sh_size,
5166 _("symbol table section indicies"));
5167 if (shndx == NULL)
5168 goto exit_point;
5169 /* PR17531: file: heap-buffer-overflow */
5170 else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5171 {
5172 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5173 printable_section_name (entry->hdr),
5174 (unsigned long) entry->hdr->sh_size,
5175 (unsigned long) section->sh_size);
5176 goto exit_point;
5177 }
c9c1d674 5178 }
6a40cf0c 5179 }
9ad5cbcf 5180
3f5e193b 5181 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
252b5132
RH		 5182
5183 if (isyms == NULL)
5184 {
8b73c356
NC		 5185 error (_("Out of memory reading %lu symbols\n"),
5186 (unsigned long) number);
dd24e3da 5187 goto exit_point;
252b5132
RH		 5188 }
5189
dd24e3da 5190 for (j = 0, psym = isyms; j < number; j++, psym++)
252b5132
RH		 5191 {
5192 psym->st_name = BYTE_GET (esyms[j].st_name);
5193 psym->st_value = BYTE_GET (esyms[j].st_value);
5194 psym->st_size = BYTE_GET (esyms[j].st_size);
5195 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4fbb74a6 5196 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5197 psym->st_shndx
5198 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5199 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5200 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
252b5132
RH		 5201 psym->st_info = BYTE_GET (esyms[j].st_info);
5202 psym->st_other = BYTE_GET (esyms[j].st_other);
5203 }
5204
dd24e3da 5205 exit_point:
ba5cdace 5206 if (shndx != NULL)
9ad5cbcf 5207 free (shndx);
ba5cdace 5208 if (esyms != NULL)
dd24e3da 5209 free (esyms);
252b5132 5210
ba5cdace
NC		 5211 if (num_syms_return != NULL)
5212 * num_syms_return = isyms == NULL ? 0 : number;
5213
252b5132
RH		 5214 return isyms;
5215}
5216
9ea033b2 5217static Elf_Internal_Sym *
ba5cdace
NC		 5218get_64bit_elf_symbols (FILE * file,
5219 Elf_Internal_Shdr * section,
5220 unsigned long * num_syms_return)
9ea033b2 5221{
ba5cdace
NC		 5222 unsigned long number = 0;
5223 Elf64_External_Sym * esyms = NULL;
5224 Elf_External_Sym_Shndx * shndx = NULL;
5225 Elf_Internal_Sym * isyms = NULL;
2cf0635d 5226 Elf_Internal_Sym * psym;
b34976b6 5227 unsigned int j;
9ea033b2 5228
c9c1d674
EG		 5229 if (section->sh_size == 0)
5230 {
5231 if (num_syms_return != NULL)
5232 * num_syms_return = 0;
5233 return NULL;
5234 }
5235
dd24e3da 5236 /* Run some sanity checks first. */
c9c1d674 5237 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
dd24e3da 5238 {
c9c1d674 5239 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
8066deb1
AM		 5240 printable_section_name (section),
5241 (unsigned long) section->sh_entsize);
ba5cdace 5242 goto exit_point;
dd24e3da
NC		 5243 }
5244
f54498b4
NC		 5245 if (section->sh_size > current_file_size)
5246 {
5247 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
8066deb1
AM		 5248 printable_section_name (section),
5249 (unsigned long) section->sh_size);
f54498b4
NC		 5250 goto exit_point;
5251 }
5252
dd24e3da
NC		 5253 number = section->sh_size / section->sh_entsize;
5254
5255 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5256 {
c9c1d674 5257 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
8066deb1
AM		 5258 (unsigned long) section->sh_size,
5259 printable_section_name (section),
5260 (unsigned long) section->sh_entsize);
ba5cdace 5261 goto exit_point;
dd24e3da
NC		 5262 }
5263
3f5e193b
NC		 5264 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5265 section->sh_size, _("symbols"));
a6e9f9df 5266 if (!esyms)
ba5cdace 5267 goto exit_point;
9ea033b2 5268
6a40cf0c
NC		 5269 {
5270 elf_section_list * entry;
5271
5272 shndx = NULL;
5273 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5274 if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
c9c1d674 5275 {
6a40cf0c
NC		 5276 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5277 entry->hdr->sh_offset,
5278 1, entry->hdr->sh_size,
5279 _("symbol table section indicies"));
5280 if (shndx == NULL)
5281 goto exit_point;
5282 /* PR17531: file: heap-buffer-overflow */
5283 else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5284 {
5285 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5286 printable_section_name (entry->hdr),
5287 (unsigned long) entry->hdr->sh_size,
5288 (unsigned long) section->sh_size);
5289 goto exit_point;
5290 }
c9c1d674 5291 }
6a40cf0c 5292 }
9ad5cbcf 5293
3f5e193b 5294 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
9ea033b2
NC		 5295
5296 if (isyms == NULL)
5297 {
8b73c356
NC		 5298 error (_("Out of memory reading %lu symbols\n"),
5299 (unsigned long) number);
ba5cdace 5300 goto exit_point;
9ea033b2
NC		 5301 }
5302
ba5cdace 5303 for (j = 0, psym = isyms; j < number; j++, psym++)
9ea033b2
NC		 5304 {
5305 psym->st_name = BYTE_GET (esyms[j].st_name);
5306 psym->st_info = BYTE_GET (esyms[j].st_info);
5307 psym->st_other = BYTE_GET (esyms[j].st_other);
5308 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
ba5cdace 5309
4fbb74a6 5310 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
9ad5cbcf
AM		 5311 psym->st_shndx
5312 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4fbb74a6
AM		 5313 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5314 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
ba5cdace 5315
66543521
AM		 5316 psym->st_value = BYTE_GET (esyms[j].st_value);
5317 psym->st_size = BYTE_GET (esyms[j].st_size);
9ea033b2
NC		 5318 }
5319
ba5cdace
NC		 5320 exit_point:
5321 if (shndx != NULL)
9ad5cbcf 5322 free (shndx);
ba5cdace
NC		 5323 if (esyms != NULL)
5324 free (esyms);
5325
5326 if (num_syms_return != NULL)
5327 * num_syms_return = isyms == NULL ? 0 : number;
9ea033b2
NC		 5328
5329 return isyms;
5330}
5331
d1133906 5332static const char *
d3ba0551 5333get_elf_section_flags (bfd_vma sh_flags)
d1133906 5334{
5477e8a0 5335 static char buff[1024];
2cf0635d 5336 char * p = buff;
8d5ff12c 5337 int field_size = is_32bit_elf ? 8 : 16;
91d6fa6a
NC		 5338 int sindex;
5339 int size = sizeof (buff) - (field_size + 4 + 1);
8d5ff12c
L		 5340 bfd_vma os_flags = 0;
5341 bfd_vma proc_flags = 0;
5342 bfd_vma unknown_flags = 0;
148b93f2 5343 static const struct
5477e8a0 5344 {
2cf0635d 5345 const char * str;
5477e8a0
L		 5346 int len;
5347 }
5348 flags [] =
5349 {
cfcac11d
NC		 5350 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5351 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5352 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5353 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5354 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5355 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5356 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5357 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5358 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5359 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5360 /* IA-64 specific. */
5361 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5362 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5363 /* IA-64 OpenVMS specific. */
5364 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5365 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5366 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5367 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5368 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5369 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
18ae9cc1 5370 /* Generic. */
cfcac11d 5371 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
18ae9cc1 5372 /* SPARC specific. */
77115a4a 5373 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
ac4c9b04
MG		 5374 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5375 /* ARM specific. */
5376 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5377 /* 22 */ { STRING_COMMA_LEN ("ARM_NOREAD") },
5378 /* 23 */ { STRING_COMMA_LEN ("COMDEF") }
5477e8a0
L		 5379 };
5380
5381 if (do_section_details)
5382 {
8d5ff12c
L		 5383 sprintf (buff, "[%*.*lx]: ",
5384 field_size, field_size, (unsigned long) sh_flags);
5385 p += field_size + 4;
5477e8a0 5386 }
76da6bbe 5387
d1133906
NC		 5388 while (sh_flags)
5389 {
5390 bfd_vma flag;
5391
5392 flag = sh_flags & - sh_flags;
5393 sh_flags &= ~ flag;
76da6bbe 5394
5477e8a0 5395 if (do_section_details)
d1133906 5396 {
5477e8a0
L		 5397 switch (flag)
5398 {
91d6fa6a
NC		 5399 case SHF_WRITE: sindex = 0; break;
5400 case SHF_ALLOC: sindex = 1; break;
5401 case SHF_EXECINSTR: sindex = 2; break;
5402 case SHF_MERGE: sindex = 3; break;
5403 case SHF_STRINGS: sindex = 4; break;
5404 case SHF_INFO_LINK: sindex = 5; break;
5405 case SHF_LINK_ORDER: sindex = 6; break;
5406 case SHF_OS_NONCONFORMING: sindex = 7; break;
5407 case SHF_GROUP: sindex = 8; break;
5408 case SHF_TLS: sindex = 9; break;
18ae9cc1 5409 case SHF_EXCLUDE: sindex = 18; break;
77115a4a 5410 case SHF_COMPRESSED: sindex = 20; break;
76da6bbe 5411
5477e8a0 5412 default:
91d6fa6a 5413 sindex = -1;
cfcac11d 5414 switch (elf_header.e_machine)
148b93f2 5415 {
cfcac11d 5416 case EM_IA_64:
148b93f2 5417 if (flag == SHF_IA_64_SHORT)
91d6fa6a 5418 sindex = 10;
148b93f2 5419 else if (flag == SHF_IA_64_NORECOV)
91d6fa6a 5420 sindex = 11;
148b93f2
NC		 5421#ifdef BFD64
5422 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5423 switch (flag)
5424 {
91d6fa6a
NC		 5425 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5426 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5427 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5428 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5429 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5430 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
148b93f2
NC		 5431 default: break;
5432 }
5433#endif
cfcac11d
NC		 5434 break;
5435
caa83f8b 5436 case EM_386:
22abe556 5437 case EM_IAMCU:
caa83f8b 5438 case EM_X86_64:
7f502d6c 5439 case EM_L1OM:
7a9068fe 5440 case EM_K1OM:
cfcac11d
NC		 5441 case EM_OLD_SPARCV9:
5442 case EM_SPARC32PLUS:
5443 case EM_SPARCV9:
5444 case EM_SPARC:
18ae9cc1 5445 if (flag == SHF_ORDERED)
91d6fa6a 5446 sindex = 19;
cfcac11d 5447 break;
ac4c9b04
MG		 5448
5449 case EM_ARM:
5450 switch (flag)
5451 {
5452 case SHF_ENTRYSECT: sindex = 21; break;
5453 case SHF_ARM_NOREAD: sindex = 22; break;
5454 case SHF_COMDEF: sindex = 23; break;
5455 default: break;
5456 }
5457 break;
5458
cfcac11d
NC		 5459 default:
5460 break;
148b93f2 5461 }
5477e8a0
L		 5462 }
5463
91d6fa6a 5464 if (sindex != -1)
5477e8a0 5465 {
8d5ff12c
L		 5466 if (p != buff + field_size + 4)
5467 {
5468 if (size < (10 + 2))
bee0ee85
NC		 5469 {
5470 warn (_("Internal error: not enough buffer room for section flag info"));
5471 return _("<unknown>");
5472 }
8d5ff12c
L		 5473 size -= 2;
5474 *p++ = ',';
5475 *p++ = ' ';
5476 }
5477
91d6fa6a
NC		 5478 size -= flags [sindex].len;
5479 p = stpcpy (p, flags [sindex].str);
5477e8a0 5480 }
3b22753a 5481 else if (flag & SHF_MASKOS)
8d5ff12c 5482 os_flags |= flag;
d1133906 5483 else if (flag & SHF_MASKPROC)
8d5ff12c 5484 proc_flags |= flag;
d1133906 5485 else
8d5ff12c 5486 unknown_flags |= flag;
5477e8a0
L		 5487 }
5488 else
5489 {
5490 switch (flag)
5491 {
5492 case SHF_WRITE: *p = 'W'; break;
5493 case SHF_ALLOC: *p = 'A'; break;
5494 case SHF_EXECINSTR: *p = 'X'; break;
5495 case SHF_MERGE: *p = 'M'; break;
5496 case SHF_STRINGS: *p = 'S'; break;
5497 case SHF_INFO_LINK: *p = 'I'; break;
5498 case SHF_LINK_ORDER: *p = 'L'; break;
5499 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5500 case SHF_GROUP: *p = 'G'; break;
5501 case SHF_TLS: *p = 'T'; break;
18ae9cc1 5502 case SHF_EXCLUDE: *p = 'E'; break;
77115a4a 5503 case SHF_COMPRESSED: *p = 'C'; break;
5477e8a0
L		 5504
5505 default:
8a9036a4 5506 if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 5507 || elf_header.e_machine == EM_L1OM
5508 || elf_header.e_machine == EM_K1OM)
5477e8a0
L		 5509 && flag == SHF_X86_64_LARGE)
5510 *p = 'l';
91f68a68
MG		 5511 else if (elf_header.e_machine == EM_ARM
5512 && flag == SHF_ARM_NOREAD)
5513 *p = 'y';
5477e8a0
L		 5514 else if (flag & SHF_MASKOS)
5515 {
5516 *p = 'o';
5517 sh_flags &= ~ SHF_MASKOS;
5518 }
5519 else if (flag & SHF_MASKPROC)
5520 {
5521 *p = 'p';
5522 sh_flags &= ~ SHF_MASKPROC;
5523 }
5524 else
5525 *p = 'x';
5526 break;
5527 }
5528 p++;
d1133906
NC		 5529 }
5530 }
76da6bbe 5531
8d5ff12c
L		 5532 if (do_section_details)
5533 {
5534 if (os_flags)
5535 {
5536 size -= 5 + field_size;
5537 if (p != buff + field_size + 4)
5538 {
5539 if (size < (2 + 1))
bee0ee85
NC		 5540 {
5541 warn (_("Internal error: not enough buffer room for section flag info"));
5542 return _("<unknown>");
5543 }
8d5ff12c
L		 5544 size -= 2;
5545 *p++ = ',';
5546 *p++ = ' ';
5547 }
5548 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5549 (unsigned long) os_flags);
5550 p += 5 + field_size;
5551 }
5552 if (proc_flags)
5553 {
5554 size -= 7 + field_size;
5555 if (p != buff + field_size + 4)
5556 {
5557 if (size < (2 + 1))
bee0ee85
NC		 5558 {
5559 warn (_("Internal error: not enough buffer room for section flag info"));
5560 return _("<unknown>");
5561 }
8d5ff12c
L		 5562 size -= 2;
5563 *p++ = ',';
5564 *p++ = ' ';
5565 }
5566 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5567 (unsigned long) proc_flags);
5568 p += 7 + field_size;
5569 }
5570 if (unknown_flags)
5571 {
5572 size -= 10 + field_size;
5573 if (p != buff + field_size + 4)
5574 {
5575 if (size < (2 + 1))
bee0ee85
NC		 5576 {
5577 warn (_("Internal error: not enough buffer room for section flag info"));
5578 return _("<unknown>");
5579 }
8d5ff12c
L		 5580 size -= 2;
5581 *p++ = ',';
5582 *p++ = ' ';
5583 }
2b692964 5584 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
8d5ff12c
L		 5585 (unsigned long) unknown_flags);
5586 p += 10 + field_size;
5587 }
5588 }
5589
e9e44622 5590 *p = '\0';
d1133906
NC		 5591 return buff;
5592}
5593
77115a4a
L		 5594static unsigned int
5595get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf)
5596{
5597 if (is_32bit_elf)
5598 {
5599 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5600 chdr->ch_type = BYTE_GET (echdr->ch_type);
5601 chdr->ch_size = BYTE_GET (echdr->ch_size);
5602 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5603 return sizeof (*echdr);
5604 }
5605 else
5606 {
5607 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5608 chdr->ch_type = BYTE_GET (echdr->ch_type);
5609 chdr->ch_size = BYTE_GET (echdr->ch_size);
5610 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5611 return sizeof (*echdr);
5612 }
5613}
5614
252b5132 5615static int
2cf0635d 5616process_section_headers (FILE * file)
252b5132 5617{
2cf0635d 5618 Elf_Internal_Shdr * section;
b34976b6 5619 unsigned int i;
252b5132
RH		 5620
5621 section_headers = NULL;
5622
5623 if (elf_header.e_shnum == 0)
5624 {
82f2dbf7
NC		 5625 /* PR binutils/12467. */
5626 if (elf_header.e_shoff != 0)
5627 warn (_("possibly corrupt ELF file header - it has a non-zero"
5628 " section header offset, but no section headers\n"));
5629 else if (do_sections)
252b5132
RH		 5630 printf (_("\nThere are no sections in this file.\n"));
5631
5632 return 1;
5633 }
5634
5635 if (do_sections && !do_header)
9ea033b2 5636 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 5637 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5638
9ea033b2
NC		 5639 if (is_32bit_elf)
5640 {
049b0c3a 5641 if (! get_32bit_section_headers (file, FALSE))
9ea033b2
NC		 5642 return 0;
5643 }
049b0c3a 5644 else if (! get_64bit_section_headers (file, FALSE))
252b5132
RH		 5645 return 0;
5646
5647 /* Read in the string table, so that we have names to display. */
0b49d371 5648 if (elf_header.e_shstrndx != SHN_UNDEF
4fbb74a6 5649 && elf_header.e_shstrndx < elf_header.e_shnum)
252b5132 5650 {
4fbb74a6 5651 section = section_headers + elf_header.e_shstrndx;
d40ac9bd 5652
c256ffe7
JJ		 5653 if (section->sh_size != 0)
5654 {
3f5e193b
NC		 5655 string_table = (char *) get_data (NULL, file, section->sh_offset,
5656 1, section->sh_size,
5657 _("string table"));
0de14b54 5658
c256ffe7
JJ		 5659 string_table_length = string_table != NULL ? section->sh_size : 0;
5660 }
252b5132
RH		 5661 }
5662
5663 /* Scan the sections for the dynamic symbol table
e3c8793a 5664 and dynamic string table and debug sections. */
252b5132
RH		 5665 dynamic_symbols = NULL;
5666 dynamic_strings = NULL;
5667 dynamic_syminfo = NULL;
6a40cf0c 5668 symtab_shndx_list = NULL;
103f02d3 5669
89fac5e3
RS		 5670 eh_addr_size = is_32bit_elf ? 4 : 8;
5671 switch (elf_header.e_machine)
5672 {
5673 case EM_MIPS:
5674 case EM_MIPS_RS3_LE:
5675 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5676 FDE addresses. However, the ABI also has a semi-official ILP32
5677 variant for which the normal FDE address size rules apply.
5678
5679 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5680 section, where XX is the size of longs in bits. Unfortunately,
5681 earlier compilers provided no way of distinguishing ILP32 objects
5682 from LP64 objects, so if there's any doubt, we should assume that
5683 the official LP64 form is being used. */
5684 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5685 && find_section (".gcc_compiled_long32") == NULL)
5686 eh_addr_size = 8;
5687 break;
0f56a26a
DD		 5688
5689 case EM_H8_300:
5690 case EM_H8_300H:
5691 switch (elf_header.e_flags & EF_H8_MACH)
5692 {
5693 case E_H8_MACH_H8300:
5694 case E_H8_MACH_H8300HN:
5695 case E_H8_MACH_H8300SN:
5696 case E_H8_MACH_H8300SXN:
5697 eh_addr_size = 2;
5698 break;
5699 case E_H8_MACH_H8300H:
5700 case E_H8_MACH_H8300S:
5701 case E_H8_MACH_H8300SX:
5702 eh_addr_size = 4;
5703 break;
5704 }
f4236fe4
DD		 5705 break;
5706
ff7eeb89 5707 case EM_M32C_OLD:
f4236fe4
DD		 5708 case EM_M32C:
5709 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5710 {
5711 case EF_M32C_CPU_M16C:
5712 eh_addr_size = 2;
5713 break;
5714 }
5715 break;
89fac5e3
RS		 5716 }
5717
76ca31c0
NC		 5718#define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5719 do \
5720 { \
5721 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5722 if (section->sh_entsize != expected_entsize) \
9dd3a467 5723 { \
76ca31c0
NC		 5724 char buf[40]; \
5725 sprintf_vma (buf, section->sh_entsize); \
5726 /* Note: coded this way so that there is a single string for \
5727 translation. */ \
5728 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5729 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5730 (unsigned) expected_entsize); \
9dd3a467 5731 section->sh_entsize = expected_entsize; \
76ca31c0
NC		 5732 } \
5733 } \
08d8fa11 5734 while (0)
9dd3a467
NC		 5735
5736#define CHECK_ENTSIZE(section, i, type) \
08d8fa11
JJ		 5737 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5738 sizeof (Elf64_External_##type))
5739
252b5132
RH		 5740 for (i = 0, section = section_headers;
5741 i < elf_header.e_shnum;
b34976b6 5742 i++, section++)
252b5132 5743 {
2cf0635d 5744 char * name = SECTION_NAME (section);
252b5132
RH		 5745
5746 if (section->sh_type == SHT_DYNSYM)
5747 {
5748 if (dynamic_symbols != NULL)
5749 {
5750 error (_("File contains multiple dynamic symbol tables\n"));
5751 continue;
5752 }
5753
08d8fa11 5754 CHECK_ENTSIZE (section, i, Sym);
ba5cdace 5755 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
252b5132
RH		 5756 }
5757 else if (section->sh_type == SHT_STRTAB
18bd398b 5758 && streq (name, ".dynstr"))
252b5132
RH		 5759 {
5760 if (dynamic_strings != NULL)
5761 {
5762 error (_("File contains multiple dynamic string tables\n"));
5763 continue;
5764 }
5765
3f5e193b
NC		 5766 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5767 1, section->sh_size,
5768 _("dynamic strings"));
59245841 5769 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
252b5132 5770 }
9ad5cbcf
AM		 5771 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5772 {
6a40cf0c
NC		 5773 elf_section_list * entry = xmalloc (sizeof * entry);
5774 entry->hdr = section;
5775 entry->next = symtab_shndx_list;
5776 symtab_shndx_list = entry;
9ad5cbcf 5777 }
08d8fa11
JJ		 5778 else if (section->sh_type == SHT_SYMTAB)
5779 CHECK_ENTSIZE (section, i, Sym);
5780 else if (section->sh_type == SHT_GROUP)
5781 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5782 else if (section->sh_type == SHT_REL)
5783 CHECK_ENTSIZE (section, i, Rel);
5784 else if (section->sh_type == SHT_RELA)
5785 CHECK_ENTSIZE (section, i, Rela);
252b5132 5786 else if ((do_debugging || do_debug_info || do_debug_abbrevs
f9f0e732 5787 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
cb8f3167 5788 || do_debug_aranges || do_debug_frames || do_debug_macinfo
657d0d47
CC		 5789 || do_debug_str || do_debug_loc || do_debug_ranges
5790 || do_debug_addr || do_debug_cu_index)
1b315056
CS		 5791 && (const_strneq (name, ".debug_")
5792 || const_strneq (name, ".zdebug_")))
252b5132 5793 {
1b315056
CS		 5794 if (name[1] == 'z')
5795 name += sizeof (".zdebug_") - 1;
5796 else
5797 name += sizeof (".debug_") - 1;
252b5132
RH		 5798
5799 if (do_debugging
4723351a
CC		 5800 || (do_debug_info && const_strneq (name, "info"))
5801 || (do_debug_info && const_strneq (name, "types"))
5802 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
b40bf0a2
NC		 5803 || (do_debug_lines && strcmp (name, "line") == 0)
5804 || (do_debug_lines && const_strneq (name, "line."))
4723351a
CC		 5805 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5806 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
459d52c8
DE		 5807 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5808 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
4723351a
CC		 5809 || (do_debug_aranges && const_strneq (name, "aranges"))
5810 || (do_debug_ranges && const_strneq (name, "ranges"))
5811 || (do_debug_frames && const_strneq (name, "frame"))
5812 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5813 || (do_debug_macinfo && const_strneq (name, "macro"))
5814 || (do_debug_str && const_strneq (name, "str"))
5815 || (do_debug_loc && const_strneq (name, "loc"))
657d0d47
CC		 5816 || (do_debug_addr && const_strneq (name, "addr"))
5817 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5818 || (do_debug_cu_index && const_strneq (name, "tu_index"))
252b5132 5819 )
09c11c86 5820 request_dump_bynumber (i, DEBUG_DUMP);
252b5132 5821 }
a262ae96 5822 /* Linkonce section to be combined with .debug_info at link time. */
09fd7e38 5823 else if ((do_debugging || do_debug_info)
0112cd26 5824 && const_strneq (name, ".gnu.linkonce.wi."))
09c11c86 5825 request_dump_bynumber (i, DEBUG_DUMP);
18bd398b 5826 else if (do_debug_frames && streq (name, ".eh_frame"))
09c11c86 5827 request_dump_bynumber (i, DEBUG_DUMP);
5bbdf3d5
DE		 5828 else if (do_gdb_index && streq (name, ".gdb_index"))
5829 request_dump_bynumber (i, DEBUG_DUMP);
6f875884
TG		 5830 /* Trace sections for Itanium VMS. */
5831 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5832 || do_trace_aranges)
5833 && const_strneq (name, ".trace_"))
5834 {
5835 name += sizeof (".trace_") - 1;
5836
5837 if (do_debugging
5838 || (do_trace_info && streq (name, "info"))
5839 || (do_trace_abbrevs && streq (name, "abbrev"))
5840 || (do_trace_aranges && streq (name, "aranges"))
5841 )
5842 request_dump_bynumber (i, DEBUG_DUMP);
5843 }
252b5132
RH		 5844 }
5845
5846 if (! do_sections)
5847 return 1;
5848
3a1a2036
NC		 5849 if (elf_header.e_shnum > 1)
5850 printf (_("\nSection Headers:\n"));
5851 else
5852 printf (_("\nSection Header:\n"));
76da6bbe 5853
f7a99963 5854 if (is_32bit_elf)
595cf52e 5855 {
5477e8a0 5856 if (do_section_details)
595cf52e
L		 5857 {
5858 printf (_(" [Nr] Name\n"));
5477e8a0 5859 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
595cf52e
L		 5860 }
5861 else
5862 printf
5863 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5864 }
d974e256 5865 else if (do_wide)
595cf52e 5866 {
5477e8a0 5867 if (do_section_details)
595cf52e
L		 5868 {
5869 printf (_(" [Nr] Name\n"));
5477e8a0 5870 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
595cf52e
L		 5871 }
5872 else
5873 printf
5874 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5875 }
f7a99963
NC		 5876 else
5877 {
5477e8a0 5878 if (do_section_details)
595cf52e
L		 5879 {
5880 printf (_(" [Nr] Name\n"));
5477e8a0
L		 5881 printf (_(" Type Address Offset Link\n"));
5882 printf (_(" Size EntSize Info Align\n"));
595cf52e
L		 5883 }
5884 else
5885 {
5886 printf (_(" [Nr] Name Type Address Offset\n"));
5887 printf (_(" Size EntSize Flags Link Info Align\n"));
5888 }
f7a99963 5889 }
252b5132 5890
5477e8a0
L		 5891 if (do_section_details)
5892 printf (_(" Flags\n"));
5893
252b5132
RH		 5894 for (i = 0, section = section_headers;
5895 i < elf_header.e_shnum;
b34976b6 5896 i++, section++)
252b5132 5897 {
7bfd842d 5898 printf (" [%2u] ", i);
5477e8a0 5899 if (do_section_details)
74e1a04b 5900 printf ("%s\n ", printable_section_name (section));
595cf52e 5901 else
74e1a04b 5902 print_symbol (-17, SECTION_NAME (section));
0b4362b0 5903
ea52a088
NC		 5904 printf (do_wide ? " %-15s " : " %-15.15s ",
5905 get_section_type_name (section->sh_type));
0b4362b0 5906
f7a99963
NC		 5907 if (is_32bit_elf)
5908 {
cfcac11d
NC		 5909 const char * link_too_big = NULL;
5910
f7a99963 5911 print_vma (section->sh_addr, LONG_HEX);
76da6bbe 5912
f7a99963
NC		 5913 printf ( " %6.6lx %6.6lx %2.2lx",
5914 (unsigned long) section->sh_offset,
5915 (unsigned long) section->sh_size,
5916 (unsigned long) section->sh_entsize);
d1133906 5917
5477e8a0
L		 5918 if (do_section_details)
5919 fputs (" ", stdout);
5920 else
5921 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 5922
cfcac11d
NC		 5923 if (section->sh_link >= elf_header.e_shnum)
5924 {
5925 link_too_big = "";
5926 /* The sh_link value is out of range. Normally this indicates
caa83f8b 5927 an error but it can have special values in Solaris binaries. */
cfcac11d
NC		 5928 switch (elf_header.e_machine)
5929 {
caa83f8b 5930 case EM_386:
22abe556 5931 case EM_IAMCU:
caa83f8b 5932 case EM_X86_64:
7f502d6c 5933 case EM_L1OM:
7a9068fe 5934 case EM_K1OM:
cfcac11d
NC		 5935 case EM_OLD_SPARCV9:
5936 case EM_SPARC32PLUS:
5937 case EM_SPARCV9:
5938 case EM_SPARC:
5939 if (section->sh_link == (SHN_BEFORE & 0xffff))
5940 link_too_big = "BEFORE";
5941 else if (section->sh_link == (SHN_AFTER & 0xffff))
5942 link_too_big = "AFTER";
5943 break;
5944 default:
5945 break;
5946 }
5947 }
5948
5949 if (do_section_details)
5950 {
5951 if (link_too_big != NULL && * link_too_big)
5952 printf ("<%s> ", link_too_big);
5953 else
5954 printf ("%2u ", section->sh_link);
5955 printf ("%3u %2lu\n", section->sh_info,
5956 (unsigned long) section->sh_addralign);
5957 }
5958 else
5959 printf ("%2u %3u %2lu\n",
5960 section->sh_link,
5961 section->sh_info,
5962 (unsigned long) section->sh_addralign);
5963
5964 if (link_too_big && ! * link_too_big)
5965 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5966 i, section->sh_link);
f7a99963 5967 }
d974e256
JJ		 5968 else if (do_wide)
5969 {
5970 print_vma (section->sh_addr, LONG_HEX);
5971
5972 if ((long) section->sh_offset == section->sh_offset)
5973 printf (" %6.6lx", (unsigned long) section->sh_offset);
5974 else
5975 {
5976 putchar (' ');
5977 print_vma (section->sh_offset, LONG_HEX);
5978 }
5979
5980 if ((unsigned long) section->sh_size == section->sh_size)
5981 printf (" %6.6lx", (unsigned long) section->sh_size);
5982 else
5983 {
5984 putchar (' ');
5985 print_vma (section->sh_size, LONG_HEX);
5986 }
5987
5988 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5989 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5990 else
5991 {
5992 putchar (' ');
5993 print_vma (section->sh_entsize, LONG_HEX);
5994 }
5995
5477e8a0
L		 5996 if (do_section_details)
5997 fputs (" ", stdout);
5998 else
5999 printf (" %3s ", get_elf_section_flags (section->sh_flags));
d974e256 6000
72de5009 6001 printf ("%2u %3u ", section->sh_link, section->sh_info);
d974e256
JJ		 6002
6003 if ((unsigned long) section->sh_addralign == section->sh_addralign)
72de5009 6004 printf ("%2lu\n", (unsigned long) section->sh_addralign);
d974e256
JJ		 6005 else
6006 {
6007 print_vma (section->sh_addralign, DEC);
6008 putchar ('\n');
6009 }
6010 }
5477e8a0 6011 else if (do_section_details)
595cf52e 6012 {
5477e8a0 6013 printf (" %-15.15s ",
595cf52e 6014 get_section_type_name (section->sh_type));
595cf52e
L		 6015 print_vma (section->sh_addr, LONG_HEX);
6016 if ((long) section->sh_offset == section->sh_offset)
5477e8a0 6017 printf (" %16.16lx", (unsigned long) section->sh_offset);
595cf52e
L		 6018 else
6019 {
6020 printf (" ");
6021 print_vma (section->sh_offset, LONG_HEX);
6022 }
72de5009 6023 printf (" %u\n ", section->sh_link);
595cf52e 6024 print_vma (section->sh_size, LONG_HEX);
5477e8a0 6025 putchar (' ');
595cf52e
L		 6026 print_vma (section->sh_entsize, LONG_HEX);
6027
72de5009
AM		 6028 printf (" %-16u %lu\n",
6029 section->sh_info,
595cf52e
L		 6030 (unsigned long) section->sh_addralign);
6031 }
f7a99963
NC		 6032 else
6033 {
6034 putchar (' ');
6035 print_vma (section->sh_addr, LONG_HEX);
53c7db4b
KH		 6036 if ((long) section->sh_offset == section->sh_offset)
6037 printf (" %8.8lx", (unsigned long) section->sh_offset);
6038 else
6039 {
6040 printf (" ");
6041 print_vma (section->sh_offset, LONG_HEX);
6042 }
f7a99963
NC		 6043 printf ("\n ");
6044 print_vma (section->sh_size, LONG_HEX);
6045 printf (" ");
6046 print_vma (section->sh_entsize, LONG_HEX);
76da6bbe 6047
d1133906 6048 printf (" %3s ", get_elf_section_flags (section->sh_flags));
76da6bbe 6049
72de5009
AM		 6050 printf (" %2u %3u %lu\n",
6051 section->sh_link,
6052 section->sh_info,
f7a99963
NC		 6053 (unsigned long) section->sh_addralign);
6054 }
5477e8a0
L		 6055
6056 if (do_section_details)
77115a4a
L		 6057 {
6058 printf (" %s\n", get_elf_section_flags (section->sh_flags));
6059 if ((section->sh_flags & SHF_COMPRESSED) != 0)
6060 {
6061 /* Minimum section size is 12 bytes for 32-bit compression
6062 header + 12 bytes for compressed data header. */
6063 unsigned char buf[24];
6064 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6065 if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
6066 sizeof (buf), _("compression header")))
6067 {
6068 Elf_Internal_Chdr chdr;
6069 get_compression_header (&chdr, buf);
6070 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6071 printf (" ZLIB, ");
6072 else
6073 printf (_(" [<unknown>: 0x%x], "),
6074 chdr.ch_type);
6075 print_vma (chdr.ch_size, LONG_HEX);
6076 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6077 }
6078 }
6079 }
252b5132
RH		 6080 }
6081
5477e8a0 6082 if (!do_section_details)
3dbcc61d 6083 {
9fb71ee4
NC		 6084 /* The ordering of the letters shown here matches the ordering of the
6085 corresponding SHF_xxx values, and hence the order in which these
6086 letters will be displayed to the user. */
6087 printf (_("Key to Flags:\n\
6088 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6089 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
fd85a6a1 6090 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
3dbcc61d 6091 if (elf_header.e_machine == EM_X86_64
7a9068fe
L		 6092 || elf_header.e_machine == EM_L1OM
6093 || elf_header.e_machine == EM_K1OM)
9fb71ee4 6094 printf (_("l (large), "));
91f68a68 6095 else if (elf_header.e_machine == EM_ARM)
9fb71ee4
NC		 6096 printf (_("y (noread), "));
6097 printf ("p (processor specific)\n");
0b4362b0 6098 }
d1133906 6099
252b5132
RH		 6100 return 1;
6101}
6102
f5842774
L		 6103static const char *
6104get_group_flags (unsigned int flags)
6105{
6106 static char buff[32];
6107 switch (flags)
6108 {
220453ec
AM		 6109 case 0:
6110 return "";
6111
f5842774 6112 case GRP_COMDAT:
220453ec 6113 return "COMDAT ";
f5842774
L		 6114
6115 default:
220453ec 6116 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
f5842774
L		 6117 break;
6118 }
6119 return buff;
6120}
6121
6122static int
2cf0635d 6123process_section_groups (FILE * file)
f5842774 6124{
2cf0635d 6125 Elf_Internal_Shdr * section;
f5842774 6126 unsigned int i;
2cf0635d
NC		 6127 struct group * group;
6128 Elf_Internal_Shdr * symtab_sec;
6129 Elf_Internal_Shdr * strtab_sec;
6130 Elf_Internal_Sym * symtab;
ba5cdace 6131 unsigned long num_syms;
2cf0635d 6132 char * strtab;
c256ffe7 6133 size_t strtab_size;
d1f5c6e3
L		 6134
6135 /* Don't process section groups unless needed. */
6136 if (!do_unwind && !do_section_groups)
6137 return 1;
f5842774
L		 6138
6139 if (elf_header.e_shnum == 0)
6140 {
6141 if (do_section_groups)
82f2dbf7 6142 printf (_("\nThere are no sections to group in this file.\n"));
f5842774
L		 6143
6144 return 1;
6145 }
6146
6147 if (section_headers == NULL)
6148 {
6149 error (_("Section headers are not available!\n"));
fa1908fd
NC		 6150 /* PR 13622: This can happen with a corrupt ELF header. */
6151 return 0;
f5842774
L		 6152 }
6153
3f5e193b
NC		 6154 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
6155 sizeof (struct group *));
e4b17d5c
L		 6156
6157 if (section_headers_groups == NULL)
6158 {
8b73c356
NC		 6159 error (_("Out of memory reading %u section group headers\n"),
6160 elf_header.e_shnum);
e4b17d5c
L		 6161 return 0;
6162 }
6163
f5842774 6164 /* Scan the sections for the group section. */
d1f5c6e3 6165 group_count = 0;
f5842774
L		 6166 for (i = 0, section = section_headers;
6167 i < elf_header.e_shnum;
6168 i++, section++)
e4b17d5c
L		 6169 if (section->sh_type == SHT_GROUP)
6170 group_count++;
6171
d1f5c6e3
L		 6172 if (group_count == 0)
6173 {
6174 if (do_section_groups)
6175 printf (_("\nThere are no section groups in this file.\n"));
6176
6177 return 1;
6178 }
6179
3f5e193b 6180 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
e4b17d5c
L		 6181
6182 if (section_groups == NULL)
6183 {
8b73c356
NC		 6184 error (_("Out of memory reading %lu groups\n"),
6185 (unsigned long) group_count);
e4b17d5c
L		 6186 return 0;
6187 }
6188
d1f5c6e3
L		 6189 symtab_sec = NULL;
6190 strtab_sec = NULL;
6191 symtab = NULL;
ba5cdace 6192 num_syms = 0;
d1f5c6e3 6193 strtab = NULL;
c256ffe7 6194 strtab_size = 0;
e4b17d5c
L		 6195 for (i = 0, section = section_headers, group = section_groups;
6196 i < elf_header.e_shnum;
6197 i++, section++)
f5842774
L		 6198 {
6199 if (section->sh_type == SHT_GROUP)
6200 {
74e1a04b
NC		 6201 const char * name = printable_section_name (section);
6202 const char * group_name;
2cf0635d
NC		 6203 unsigned char * start;
6204 unsigned char * indices;
f5842774 6205 unsigned int entry, j, size;
2cf0635d
NC		 6206 Elf_Internal_Shdr * sec;
6207 Elf_Internal_Sym * sym;
f5842774
L		 6208
6209 /* Get the symbol table. */
4fbb74a6
AM		 6210 if (section->sh_link >= elf_header.e_shnum
6211 || ((sec = section_headers + section->sh_link)->sh_type
c256ffe7 6212 != SHT_SYMTAB))
f5842774
L		 6213 {
6214 error (_("Bad sh_link in group section `%s'\n"), name);
6215 continue;
6216 }
d1f5c6e3
L		 6217
6218 if (symtab_sec != sec)
6219 {
6220 symtab_sec = sec;
6221 if (symtab)
6222 free (symtab);
ba5cdace 6223 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
d1f5c6e3 6224 }
f5842774 6225
dd24e3da
NC		 6226 if (symtab == NULL)
6227 {
6228 error (_("Corrupt header in group section `%s'\n"), name);
6229 continue;
6230 }
6231
ba5cdace
NC		 6232 if (section->sh_info >= num_syms)
6233 {
6234 error (_("Bad sh_info in group section `%s'\n"), name);
6235 continue;
6236 }
6237
f5842774
L		 6238 sym = symtab + section->sh_info;
6239
6240 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6241 {
4fbb74a6
AM		 6242 if (sym->st_shndx == 0
6243 || sym->st_shndx >= elf_header.e_shnum)
f5842774
L		 6244 {
6245 error (_("Bad sh_info in group section `%s'\n"), name);
6246 continue;
6247 }
ba2685cc 6248
4fbb74a6 6249 group_name = SECTION_NAME (section_headers + sym->st_shndx);
c256ffe7
JJ		 6250 strtab_sec = NULL;
6251 if (strtab)
6252 free (strtab);
f5842774 6253 strtab = NULL;
c256ffe7 6254 strtab_size = 0;
f5842774
L		 6255 }
6256 else
6257 {
6258 /* Get the string table. */
4fbb74a6 6259 if (symtab_sec->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 6260 {
6261 strtab_sec = NULL;
6262 if (strtab)
6263 free (strtab);
6264 strtab = NULL;
6265 strtab_size = 0;
6266 }
6267 else if (strtab_sec
4fbb74a6 6268 != (sec = section_headers + symtab_sec->sh_link))
d1f5c6e3
L		 6269 {
6270 strtab_sec = sec;
6271 if (strtab)
6272 free (strtab);
071436c6 6273
3f5e193b 6274 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
071436c6
NC		 6275 1, strtab_sec->sh_size,
6276 _("string table"));
c256ffe7 6277 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
d1f5c6e3 6278 }
c256ffe7 6279 group_name = sym->st_name < strtab_size
2b692964 6280 ? strtab + sym->st_name : _("<corrupt>");
f5842774
L		 6281 }
6282
c9c1d674
EG		 6283 /* PR 17531: file: loop. */
6284 if (section->sh_entsize > section->sh_size)
6285 {
6286 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6287 printable_section_name (section),
8066deb1
AM		 6288 (unsigned long) section->sh_entsize,
6289 (unsigned long) section->sh_size);
c9c1d674
EG		 6290 break;
6291 }
6292
3f5e193b
NC		 6293 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6294 1, section->sh_size,
6295 _("section data"));
59245841
NC		 6296 if (start == NULL)
6297 continue;
f5842774
L		 6298
6299 indices = start;
6300 size = (section->sh_size / section->sh_entsize) - 1;
6301 entry = byte_get (indices, 4);
6302 indices += 4;
e4b17d5c
L		 6303
6304 if (do_section_groups)
6305 {
2b692964 6306 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
391cb864 6307 get_group_flags (entry), i, name, group_name, size);
ba2685cc 6308
e4b17d5c
L		 6309 printf (_(" [Index] Name\n"));
6310 }
6311
6312 group->group_index = i;
6313
f5842774
L		 6314 for (j = 0; j < size; j++)
6315 {
2cf0635d 6316 struct group_list * g;
e4b17d5c 6317
f5842774
L		 6318 entry = byte_get (indices, 4);
6319 indices += 4;
6320
4fbb74a6 6321 if (entry >= elf_header.e_shnum)
391cb864 6322 {
57028622
NC		 6323 static unsigned num_group_errors = 0;
6324
6325 if (num_group_errors ++ < 10)
6326 {
6327 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6328 entry, i, elf_header.e_shnum - 1);
6329 if (num_group_errors == 10)
6330 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6331 }
391cb864
L		 6332 continue;
6333 }
391cb864 6334
4fbb74a6 6335 if (section_headers_groups [entry] != NULL)
e4b17d5c 6336 {
d1f5c6e3
L		 6337 if (entry)
6338 {
57028622
NC		 6339 static unsigned num_errs = 0;
6340
6341 if (num_errs ++ < 10)
6342 {
6343 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6344 entry, i,
6345 section_headers_groups [entry]->group_index);
6346 if (num_errs == 10)
6347 warn (_("Further error messages about already contained group sections suppressed\n"));
6348 }
d1f5c6e3
L		 6349 continue;
6350 }
6351 else
6352 {
6353 /* Intel C/C++ compiler may put section 0 in a
6354 section group. We just warn it the first time
6355 and ignore it afterwards. */
6356 static int warned = 0;
6357 if (!warned)
6358 {
6359 error (_("section 0 in group section [%5u]\n"),
4fbb74a6 6360 section_headers_groups [entry]->group_index);
d1f5c6e3
L		 6361 warned++;
6362 }
6363 }
e4b17d5c
L		 6364 }
6365
4fbb74a6 6366 section_headers_groups [entry] = group;
e4b17d5c
L		 6367
6368 if (do_section_groups)
6369 {
4fbb74a6 6370 sec = section_headers + entry;
74e1a04b 6371 printf (" [%5u] %s\n", entry, printable_section_name (sec));
ba2685cc
AM		 6372 }
6373
3f5e193b 6374 g = (struct group_list *) xmalloc (sizeof (struct group_list));
e4b17d5c
L		 6375 g->section_index = entry;
6376 g->next = group->root;
6377 group->root = g;
f5842774
L		 6378 }
6379
f5842774
L		 6380 if (start)
6381 free (start);
e4b17d5c
L		 6382
6383 group++;
f5842774
L		 6384 }
6385 }
6386
d1f5c6e3
L		 6387 if (symtab)
6388 free (symtab);
6389 if (strtab)
6390 free (strtab);
f5842774
L		 6391 return 1;
6392}
6393
28f997cf
TG		 6394/* Data used to display dynamic fixups. */
6395
6396struct ia64_vms_dynfixup
6397{
6398 bfd_vma needed_ident; /* Library ident number. */
6399 bfd_vma needed; /* Index in the dstrtab of the library name. */
6400 bfd_vma fixup_needed; /* Index of the library. */
6401 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6402 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6403};
6404
6405/* Data used to display dynamic relocations. */
6406
6407struct ia64_vms_dynimgrela
6408{
6409 bfd_vma img_rela_cnt; /* Number of relocations. */
6410 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6411};
6412
6413/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6414 library). */
6415
6416static void
6417dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6418 const char *strtab, unsigned int strtab_sz)
6419{
6420 Elf64_External_VMS_IMAGE_FIXUP *imfs;
6421 long i;
6422 const char *lib_name;
6423
6424 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6425 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6426 _("dynamic section image fixups"));
6427 if (!imfs)
6428 return;
6429
6430 if (fixup->needed < strtab_sz)
6431 lib_name = strtab + fixup->needed;
6432 else
6433 {
6434 warn ("corrupt library name index of 0x%lx found in dynamic entry",
7f01b0c6 6435 (unsigned long) fixup->needed);
28f997cf
TG		 6436 lib_name = "???";
6437 }
6438 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6439 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6440 printf
6441 (_("Seg Offset Type SymVec DataType\n"));
6442
6443 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6444 {
6445 unsigned int type;
6446 const char *rtype;
6447
6448 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6449 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6450 type = BYTE_GET (imfs [i].type);
6451 rtype = elf_ia64_reloc_type (type);
6452 if (rtype == NULL)
6453 printf (" 0x%08x ", type);
6454 else
6455 printf (" %-32s ", rtype);
6456 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6457 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6458 }
6459
6460 free (imfs);
6461}
6462
6463/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6464
6465static void
6466dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6467{
6468 Elf64_External_VMS_IMAGE_RELA *imrs;
6469 long i;
6470
6471 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6472 1, imgrela->img_rela_cnt * sizeof (*imrs),
9cf03b7e 6473 _("dynamic section image relocations"));
28f997cf
TG		 6474 if (!imrs)
6475 return;
6476
6477 printf (_("\nImage relocs\n"));
6478 printf
6479 (_("Seg Offset Type Addend Seg Sym Off\n"));
6480
6481 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6482 {
6483 unsigned int type;
6484 const char *rtype;
6485
6486 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6487 printf ("%08" BFD_VMA_FMT "x ",
6488 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6489 type = BYTE_GET (imrs [i].type);
6490 rtype = elf_ia64_reloc_type (type);
6491 if (rtype == NULL)
6492 printf ("0x%08x ", type);
6493 else
6494 printf ("%-31s ", rtype);
6495 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6496 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6497 printf ("%08" BFD_VMA_FMT "x\n",
6498 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6499 }
6500
6501 free (imrs);
6502}
6503
6504/* Display IA-64 OpenVMS dynamic relocations and fixups. */
6505
6506static int
6507process_ia64_vms_dynamic_relocs (FILE *file)
6508{
6509 struct ia64_vms_dynfixup fixup;
6510 struct ia64_vms_dynimgrela imgrela;
6511 Elf_Internal_Dyn *entry;
6512 int res = 0;
6513 bfd_vma strtab_off = 0;
6514 bfd_vma strtab_sz = 0;
6515 char *strtab = NULL;
6516
6517 memset (&fixup, 0, sizeof (fixup));
6518 memset (&imgrela, 0, sizeof (imgrela));
6519
6520 /* Note: the order of the entries is specified by the OpenVMS specs. */
6521 for (entry = dynamic_section;
6522 entry < dynamic_section + dynamic_nent;
6523 entry++)
6524 {
6525 switch (entry->d_tag)
6526 {
6527 case DT_IA_64_VMS_STRTAB_OFFSET:
6528 strtab_off = entry->d_un.d_val;
6529 break;
6530 case DT_STRSZ:
6531 strtab_sz = entry->d_un.d_val;
6532 if (strtab == NULL)
6533 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6534 1, strtab_sz, _("dynamic string section"));
6535 break;
6536
6537 case DT_IA_64_VMS_NEEDED_IDENT:
6538 fixup.needed_ident = entry->d_un.d_val;
6539 break;
6540 case DT_NEEDED:
6541 fixup.needed = entry->d_un.d_val;
6542 break;
6543 case DT_IA_64_VMS_FIXUP_NEEDED:
6544 fixup.fixup_needed = entry->d_un.d_val;
6545 break;
6546 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6547 fixup.fixup_rela_cnt = entry->d_un.d_val;
6548 break;
6549 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6550 fixup.fixup_rela_off = entry->d_un.d_val;
6551 res++;
6552 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6553 break;
6554
6555 case DT_IA_64_VMS_IMG_RELA_CNT:
6556 imgrela.img_rela_cnt = entry->d_un.d_val;
6557 break;
6558 case DT_IA_64_VMS_IMG_RELA_OFF:
6559 imgrela.img_rela_off = entry->d_un.d_val;
6560 res++;
6561 dump_ia64_vms_dynamic_relocs (file, &imgrela);
6562 break;
6563
6564 default:
6565 break;
6566 }
6567 }
6568
6569 if (strtab != NULL)
6570 free (strtab);
6571
6572 return res;
6573}
6574
85b1c36d 6575static struct
566b0d53 6576{
2cf0635d 6577 const char * name;
566b0d53
L		 6578 int reloc;
6579 int size;
6580 int rela;
6581} dynamic_relocations [] =
6582{
6583 { "REL", DT_REL, DT_RELSZ, FALSE },
6584 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6585 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6586};
6587
252b5132 6588/* Process the reloc section. */
18bd398b 6589
252b5132 6590static int
2cf0635d 6591process_relocs (FILE * file)
252b5132 6592{
b34976b6
AM		 6593 unsigned long rel_size;
6594 unsigned long rel_offset;
252b5132
RH		 6595
6596
6597 if (!do_reloc)
6598 return 1;
6599
6600 if (do_using_dynamic)
6601 {
566b0d53 6602 int is_rela;
2cf0635d 6603 const char * name;
566b0d53
L		 6604 int has_dynamic_reloc;
6605 unsigned int i;
0de14b54 6606
566b0d53 6607 has_dynamic_reloc = 0;
252b5132 6608
566b0d53 6609 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
252b5132 6610 {
566b0d53
L		 6611 is_rela = dynamic_relocations [i].rela;
6612 name = dynamic_relocations [i].name;
6613 rel_size = dynamic_info [dynamic_relocations [i].size];
6614 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
103f02d3 6615
566b0d53
L		 6616 has_dynamic_reloc |= rel_size;
6617
6618 if (is_rela == UNKNOWN)
aa903cfb 6619 {
566b0d53
L		 6620 if (dynamic_relocations [i].reloc == DT_JMPREL)
6621 switch (dynamic_info[DT_PLTREL])
6622 {
6623 case DT_REL:
6624 is_rela = FALSE;
6625 break;
6626 case DT_RELA:
6627 is_rela = TRUE;
6628 break;
6629 }
aa903cfb 6630 }
252b5132 6631
566b0d53
L		 6632 if (rel_size)
6633 {
6634 printf
6635 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6636 name, rel_offset, rel_size);
252b5132 6637
d93f0186
NC		 6638 dump_relocations (file,
6639 offset_from_vma (file, rel_offset, rel_size),
6640 rel_size,
566b0d53 6641 dynamic_symbols, num_dynamic_syms,
bb4d2ac2
L		 6642 dynamic_strings, dynamic_strings_length,
6643 is_rela, 1);
566b0d53 6644 }
252b5132 6645 }
566b0d53 6646
28f997cf
TG		 6647 if (is_ia64_vms ())
6648 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6649
566b0d53 6650 if (! has_dynamic_reloc)
252b5132
RH		 6651 printf (_("\nThere are no dynamic relocations in this file.\n"));
6652 }
6653 else
6654 {
2cf0635d 6655 Elf_Internal_Shdr * section;
b34976b6
AM		 6656 unsigned long i;
6657 int found = 0;
252b5132
RH		 6658
6659 for (i = 0, section = section_headers;
6660 i < elf_header.e_shnum;
b34976b6 6661 i++, section++)
252b5132
RH		 6662 {
6663 if ( section->sh_type != SHT_RELA
6664 && section->sh_type != SHT_REL)
6665 continue;
6666
6667 rel_offset = section->sh_offset;
6668 rel_size = section->sh_size;
6669
6670 if (rel_size)
6671 {
2cf0635d 6672 Elf_Internal_Shdr * strsec;
b34976b6 6673 int is_rela;
103f02d3 6674
252b5132
RH		 6675 printf (_("\nRelocation section "));
6676
6677 if (string_table == NULL)
19936277 6678 printf ("%d", section->sh_name);
252b5132 6679 else
74e1a04b 6680 printf ("'%s'", printable_section_name (section));
252b5132
RH		 6681
6682 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6683 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6684
d79b3d50
NC		 6685 is_rela = section->sh_type == SHT_RELA;
6686
4fbb74a6
AM		 6687 if (section->sh_link != 0
6688 && section->sh_link < elf_header.e_shnum)
af3fc3bc 6689 {
2cf0635d
NC		 6690 Elf_Internal_Shdr * symsec;
6691 Elf_Internal_Sym * symtab;
d79b3d50 6692 unsigned long nsyms;
c256ffe7 6693 unsigned long strtablen = 0;
2cf0635d 6694 char * strtab = NULL;
57346661 6695
4fbb74a6 6696 symsec = section_headers + section->sh_link;
08d8fa11
JJ		 6697 if (symsec->sh_type != SHT_SYMTAB
6698 && symsec->sh_type != SHT_DYNSYM)
6699 continue;
6700
ba5cdace 6701 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
252b5132 6702
af3fc3bc
AM		 6703 if (symtab == NULL)
6704 continue;
252b5132 6705
4fbb74a6
AM		 6706 if (symsec->sh_link != 0
6707 && symsec->sh_link < elf_header.e_shnum)
c256ffe7 6708 {
4fbb74a6 6709 strsec = section_headers + symsec->sh_link;
103f02d3 6710
3f5e193b 6711 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
071436c6
NC		 6712 1, strsec->sh_size,
6713 _("string table"));
c256ffe7
JJ		 6714 strtablen = strtab == NULL ? 0 : strsec->sh_size;
6715 }
252b5132 6716
d79b3d50 6717 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2
L		 6718 symtab, nsyms, strtab, strtablen,
6719 is_rela,
6720 symsec->sh_type == SHT_DYNSYM);
d79b3d50
NC		 6721 if (strtab)
6722 free (strtab);
6723 free (symtab);
6724 }
6725 else
6726 dump_relocations (file, rel_offset, rel_size,
bb4d2ac2 6727 NULL, 0, NULL, 0, is_rela, 0);
252b5132
RH		 6728
6729 found = 1;
6730 }
6731 }
6732
6733 if (! found)
6734 printf (_("\nThere are no relocations in this file.\n"));
6735 }
6736
6737 return 1;
6738}
6739
4d6ed7c8
NC		 6740/* An absolute address consists of a section and an offset. If the
6741 section is NULL, the offset itself is the address, otherwise, the
6742 address equals to LOAD_ADDRESS(section) + offset. */
6743
6744struct absaddr
948f632f
DA		 6745{
6746 unsigned short section;
6747 bfd_vma offset;
6748};
4d6ed7c8 6749
1949de15
L		 6750#define ABSADDR(a) \
6751 ((a).section \
6752 ? section_headers [(a).section].sh_addr + (a).offset \
6753 : (a).offset)
6754
948f632f
DA		 6755/* Find the nearest symbol at or below ADDR. Returns the symbol
6756 name, if found, and the offset from the symbol to ADDR. */
4d6ed7c8 6757
4d6ed7c8 6758static void
2cf0635d 6759find_symbol_for_address (Elf_Internal_Sym * symtab,
948f632f
DA		 6760 unsigned long nsyms,
6761 const char * strtab,
6762 unsigned long strtab_size,
6763 struct absaddr addr,
6764 const char ** symname,
6765 bfd_vma * offset)
4d6ed7c8 6766{
d3ba0551 6767 bfd_vma dist = 0x100000;
2cf0635d 6768 Elf_Internal_Sym * sym;
948f632f
DA		 6769 Elf_Internal_Sym * beg;
6770 Elf_Internal_Sym * end;
2cf0635d 6771 Elf_Internal_Sym * best = NULL;
4d6ed7c8 6772
0b6ae522 6773 REMOVE_ARCH_BITS (addr.offset);
948f632f
DA		 6774 beg = symtab;
6775 end = symtab + nsyms;
0b6ae522 6776
948f632f 6777 while (beg < end)
4d6ed7c8 6778 {
948f632f
DA		 6779 bfd_vma value;
6780
6781 sym = beg + (end - beg) / 2;
0b6ae522 6782
948f632f 6783 value = sym->st_value;
0b6ae522
DJ		 6784 REMOVE_ARCH_BITS (value);
6785
948f632f 6786 if (sym->st_name != 0
4d6ed7c8 6787 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
0b6ae522
DJ		 6788 && addr.offset >= value
6789 && addr.offset - value < dist)
4d6ed7c8
NC		 6790 {
6791 best = sym;
0b6ae522 6792 dist = addr.offset - value;
4d6ed7c8
NC		 6793 if (!dist)
6794 break;
6795 }
948f632f
DA		 6796
6797 if (addr.offset < value)
6798 end = sym;
6799 else
6800 beg = sym + 1;
4d6ed7c8 6801 }
1b31d05e 6802
4d6ed7c8
NC		 6803 if (best)
6804 {
57346661 6805 *symname = (best->st_name >= strtab_size
2b692964 6806 ? _("<corrupt>") : strtab + best->st_name);
4d6ed7c8
NC		 6807 *offset = dist;
6808 return;
6809 }
1b31d05e 6810
4d6ed7c8
NC		 6811 *symname = NULL;
6812 *offset = addr.offset;
6813}
6814
948f632f
DA		 6815static int
6816symcmp (const void *p, const void *q)
6817{
6818 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
6819 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
6820
6821 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
6822}
6823
6824/* Process the unwind section. */
6825
6826#include "unwind-ia64.h"
6827
6828struct ia64_unw_table_entry
6829{
6830 struct absaddr start;
6831 struct absaddr end;
6832 struct absaddr info;
6833};
6834
6835struct ia64_unw_aux_info
6836{
6837 struct ia64_unw_table_entry *table; /* Unwind table. */
6838 unsigned long table_len; /* Length of unwind table. */
6839 unsigned char * info; /* Unwind info. */
6840 unsigned long info_size; /* Size of unwind info. */
6841 bfd_vma info_addr; /* Starting address of unwind info. */
6842 bfd_vma seg_base; /* Starting address of segment. */
6843 Elf_Internal_Sym * symtab; /* The symbol table. */
6844 unsigned long nsyms; /* Number of symbols. */
6845 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
6846 unsigned long nfuns; /* Number of entries in funtab. */
6847 char * strtab; /* The string table. */
6848 unsigned long strtab_size; /* Size of string table. */
6849};
6850
4d6ed7c8 6851static void
2cf0635d 6852dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4d6ed7c8 6853{
2cf0635d 6854 struct ia64_unw_table_entry * tp;
948f632f 6855 unsigned long j, nfuns;
4d6ed7c8 6856 int in_body;
7036c0e1 6857
948f632f
DA		 6858 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
6859 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
6860 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
6861 aux->funtab[nfuns++] = aux->symtab[j];
6862 aux->nfuns = nfuns;
6863 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
6864
4d6ed7c8
NC		 6865 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6866 {
6867 bfd_vma stamp;
6868 bfd_vma offset;
2cf0635d
NC		 6869 const unsigned char * dp;
6870 const unsigned char * head;
53774b7e 6871 const unsigned char * end;
2cf0635d 6872 const char * procname;
4d6ed7c8 6873
948f632f 6874 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661 6875 aux->strtab_size, tp->start, &procname, &offset);
4d6ed7c8
NC		 6876
6877 fputs ("\n<", stdout);
6878
6879 if (procname)
6880 {
6881 fputs (procname, stdout);
6882
6883 if (offset)
6884 printf ("+%lx", (unsigned long) offset);
6885 }
6886
6887 fputs (">: [", stdout);
6888 print_vma (tp->start.offset, PREFIX_HEX);
6889 fputc ('-', stdout);
6890 print_vma (tp->end.offset, PREFIX_HEX);
86f55779 6891 printf ("], info at +0x%lx\n",
4d6ed7c8
NC		 6892 (unsigned long) (tp->info.offset - aux->seg_base));
6893
53774b7e
NC		 6894 /* PR 17531: file: 86232b32. */
6895 if (aux->info == NULL)
6896 continue;
6897
6898 /* PR 17531: file: 0997b4d1. */
6899 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
6900 {
6901 warn (_("Invalid offset %lx in table entry %ld\n"),
6902 (long) tp->info.offset, (long) (tp - aux->table));
6903 continue;
6904 }
6905
1949de15 6906 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
a4a00738 6907 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4d6ed7c8 6908
86f55779 6909 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4d6ed7c8
NC		 6910 (unsigned) UNW_VER (stamp),
6911 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6912 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6913 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
89fac5e3 6914 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4d6ed7c8
NC		 6915
6916 if (UNW_VER (stamp) != 1)
6917 {
2b692964 6918 printf (_("\tUnknown version.\n"));
4d6ed7c8
NC		 6919 continue;
6920 }
6921
6922 in_body = 0;
53774b7e
NC		 6923 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
6924 /* PR 17531: file: 16ceda89. */
6925 if (end > aux->info + aux->info_size)
6926 end = aux->info + aux->info_size;
6927 for (dp = head + 8; dp < end;)
b4477bc8 6928 dp = unw_decode (dp, in_body, & in_body, end);
4d6ed7c8 6929 }
948f632f
DA		 6930
6931 free (aux->funtab);
4d6ed7c8
NC		 6932}
6933
53774b7e 6934static bfd_boolean
2cf0635d
NC		 6935slurp_ia64_unwind_table (FILE * file,
6936 struct ia64_unw_aux_info * aux,
6937 Elf_Internal_Shdr * sec)
4d6ed7c8 6938{
89fac5e3 6939 unsigned long size, nrelas, i;
2cf0635d
NC		 6940 Elf_Internal_Phdr * seg;
6941 struct ia64_unw_table_entry * tep;
6942 Elf_Internal_Shdr * relsec;
6943 Elf_Internal_Rela * rela;
6944 Elf_Internal_Rela * rp;
6945 unsigned char * table;
6946 unsigned char * tp;
6947 Elf_Internal_Sym * sym;
6948 const char * relname;
4d6ed7c8 6949
53774b7e
NC		 6950 aux->table_len = 0;
6951
4d6ed7c8
NC		 6952 /* First, find the starting address of the segment that includes
6953 this section: */
6954
6955 if (elf_header.e_phnum)
6956 {
d93f0186 6957 if (! get_program_headers (file))
53774b7e 6958 return FALSE;
4d6ed7c8 6959
d93f0186
NC		 6960 for (seg = program_headers;
6961 seg < program_headers + elf_header.e_phnum;
6962 ++seg)
4d6ed7c8
NC		 6963 {
6964 if (seg->p_type != PT_LOAD)
6965 continue;
6966
6967 if (sec->sh_addr >= seg->p_vaddr
6968 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6969 {
6970 aux->seg_base = seg->p_vaddr;
6971 break;
6972 }
6973 }
4d6ed7c8
NC		 6974 }
6975
6976 /* Second, build the unwind table from the contents of the unwind section: */
6977 size = sec->sh_size;
3f5e193b
NC		 6978 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6979 _("unwind table"));
a6e9f9df 6980 if (!table)
53774b7e 6981 return FALSE;
4d6ed7c8 6982
53774b7e 6983 aux->table_len = size / (3 * eh_addr_size);
3f5e193b 6984 aux->table = (struct ia64_unw_table_entry *)
53774b7e 6985 xcmalloc (aux->table_len, sizeof (aux->table[0]));
89fac5e3 6986 tep = aux->table;
53774b7e
NC		 6987
6988 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
4d6ed7c8
NC		 6989 {
6990 tep->start.section = SHN_UNDEF;
6991 tep->end.section = SHN_UNDEF;
6992 tep->info.section = SHN_UNDEF;
c6a0c689
AM		 6993 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6994 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6995 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4d6ed7c8
NC		 6996 tep->start.offset += aux->seg_base;
6997 tep->end.offset += aux->seg_base;
6998 tep->info.offset += aux->seg_base;
6999 }
7000 free (table);
7001
41e92641 7002 /* Third, apply any relocations to the unwind table: */
4d6ed7c8
NC		 7003 for (relsec = section_headers;
7004 relsec < section_headers + elf_header.e_shnum;
7005 ++relsec)
7006 {
7007 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 7008 || relsec->sh_info >= elf_header.e_shnum
7009 || section_headers + relsec->sh_info != sec)
4d6ed7c8
NC		 7010 continue;
7011
7012 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7013 & rela, & nrelas))
53774b7e
NC		 7014 {
7015 free (aux->table);
7016 aux->table = NULL;
7017 aux->table_len = 0;
7018 return FALSE;
7019 }
4d6ed7c8
NC		 7020
7021 for (rp = rela; rp < rela + nrelas; ++rp)
7022 {
aca88567
NC		 7023 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
7024 sym = aux->symtab + get_reloc_symindex (rp->r_info);
4d6ed7c8 7025
82b1b41b
NC		 7026 /* PR 17531: file: 9fa67536. */
7027 if (relname == NULL)
7028 {
7029 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
7030 continue;
7031 }
948f632f 7032
0112cd26 7033 if (! const_strneq (relname, "R_IA64_SEGREL"))
4d6ed7c8 7034 {
82b1b41b 7035 warn (_("Skipping unexpected relocation type: %s\n"), relname);
4d6ed7c8
NC		 7036 continue;
7037 }
7038
89fac5e3 7039 i = rp->r_offset / (3 * eh_addr_size);
4d6ed7c8 7040
53774b7e
NC		 7041 /* PR 17531: file: 5bc8d9bf. */
7042 if (i >= aux->table_len)
7043 {
7044 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7045 continue;
7046 }
7047
7048 switch (rp->r_offset / eh_addr_size % 3)
4d6ed7c8
NC		 7049 {
7050 case 0:
7051 aux->table[i].start.section = sym->st_shndx;
e466bc6e 7052 aux->table[i].start.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 7053 break;
7054 case 1:
7055 aux->table[i].end.section = sym->st_shndx;
e466bc6e 7056 aux->table[i].end.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 7057 break;
7058 case 2:
7059 aux->table[i].info.section = sym->st_shndx;
e466bc6e 7060 aux->table[i].info.offset = rp->r_addend + sym->st_value;
4d6ed7c8
NC		 7061 break;
7062 default:
7063 break;
7064 }
7065 }
7066
7067 free (rela);
7068 }
7069
53774b7e 7070 return TRUE;
4d6ed7c8
NC		 7071}
7072
1b31d05e 7073static void
2cf0635d 7074ia64_process_unwind (FILE * file)
4d6ed7c8 7075{
2cf0635d
NC		 7076 Elf_Internal_Shdr * sec;
7077 Elf_Internal_Shdr * unwsec = NULL;
7078 Elf_Internal_Shdr * strsec;
89fac5e3 7079 unsigned long i, unwcount = 0, unwstart = 0;
57346661 7080 struct ia64_unw_aux_info aux;
f1467e33 7081
4d6ed7c8
NC		 7082 memset (& aux, 0, sizeof (aux));
7083
4d6ed7c8
NC		 7084 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7085 {
c256ffe7 7086 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 7087 && sec->sh_link < elf_header.e_shnum)
4d6ed7c8 7088 {
ba5cdace 7089 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
4d6ed7c8 7090
4fbb74a6 7091 strsec = section_headers + sec->sh_link;
4082ef84
NC		 7092 if (aux.strtab != NULL)
7093 {
7094 error (_("Multiple auxillary string tables encountered\n"));
7095 free (aux.strtab);
7096 }
3f5e193b
NC		 7097 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7098 1, strsec->sh_size,
7099 _("string table"));
c256ffe7 7100 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4d6ed7c8
NC		 7101 }
7102 else if (sec->sh_type == SHT_IA_64_UNWIND)
579f31ac
JJ		 7103 unwcount++;
7104 }
7105
7106 if (!unwcount)
7107 printf (_("\nThere are no unwind sections in this file.\n"));
7108
7109 while (unwcount-- > 0)
7110 {
2cf0635d 7111 char * suffix;
579f31ac
JJ		 7112 size_t len, len2;
7113
4082ef84 7114 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
579f31ac
JJ		 7115 i < elf_header.e_shnum; ++i, ++sec)
7116 if (sec->sh_type == SHT_IA_64_UNWIND)
7117 {
7118 unwsec = sec;
7119 break;
7120 }
4082ef84
NC		 7121 /* We have already counted the number of SHT_IA64_UNWIND
7122 sections so the loop above should never fail. */
7123 assert (unwsec != NULL);
579f31ac
JJ		 7124
7125 unwstart = i + 1;
7126 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7127
e4b17d5c
L		 7128 if ((unwsec->sh_flags & SHF_GROUP) != 0)
7129 {
7130 /* We need to find which section group it is in. */
4082ef84 7131 struct group_list * g;
e4b17d5c 7132
4082ef84
NC		 7133 if (section_headers_groups == NULL
7134 || section_headers_groups [i] == NULL)
7135 i = elf_header.e_shnum;
7136 else
e4b17d5c 7137 {
4082ef84 7138 g = section_headers_groups [i]->root;
18bd398b 7139
4082ef84
NC		 7140 for (; g != NULL; g = g->next)
7141 {
7142 sec = section_headers + g->section_index;
e4b17d5c 7143
4082ef84
NC		 7144 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7145 break;
7146 }
7147
7148 if (g == NULL)
7149 i = elf_header.e_shnum;
7150 }
e4b17d5c 7151 }
18bd398b 7152 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
579f31ac 7153 {
18bd398b 7154 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
579f31ac
JJ		 7155 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7156 suffix = SECTION_NAME (unwsec) + len;
7157 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7158 ++i, ++sec)
18bd398b
NC		 7159 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7160 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 7161 break;
7162 }
7163 else
7164 {
7165 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
18bd398b 7166 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
579f31ac
JJ		 7167 len = sizeof (ELF_STRING_ia64_unwind) - 1;
7168 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7169 suffix = "";
18bd398b 7170 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
579f31ac
JJ		 7171 suffix = SECTION_NAME (unwsec) + len;
7172 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7173 ++i, ++sec)
18bd398b
NC		 7174 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7175 && streq (SECTION_NAME (sec) + len2, suffix))
579f31ac
JJ		 7176 break;
7177 }
7178
7179 if (i == elf_header.e_shnum)
7180 {
7181 printf (_("\nCould not find unwind info section for "));
7182
7183 if (string_table == NULL)
7184 printf ("%d", unwsec->sh_name);
7185 else
74e1a04b 7186 printf ("'%s'", printable_section_name (unwsec));
579f31ac
JJ		 7187 }
7188 else
4d6ed7c8 7189 {
4d6ed7c8 7190 aux.info_addr = sec->sh_addr;
3f5e193b 7191 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
4082ef84
NC		 7192 sec->sh_size,
7193 _("unwind info"));
59245841 7194 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
4d6ed7c8 7195
579f31ac 7196 printf (_("\nUnwind section "));
4d6ed7c8 7197
579f31ac
JJ		 7198 if (string_table == NULL)
7199 printf ("%d", unwsec->sh_name);
7200 else
74e1a04b 7201 printf ("'%s'", printable_section_name (unwsec));
4d6ed7c8 7202
579f31ac 7203 printf (_(" at offset 0x%lx contains %lu entries:\n"),
e59b4dfb 7204 (unsigned long) unwsec->sh_offset,
89fac5e3 7205 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4d6ed7c8 7206
53774b7e
NC		 7207 if (slurp_ia64_unwind_table (file, & aux, unwsec)
7208 && aux.table_len > 0)
579f31ac
JJ		 7209 dump_ia64_unwind (& aux);
7210
7211 if (aux.table)
7212 free ((char *) aux.table);
7213 if (aux.info)
7214 free ((char *) aux.info);
7215 aux.table = NULL;
7216 aux.info = NULL;
7217 }
4d6ed7c8 7218 }
4d6ed7c8 7219
4d6ed7c8
NC		 7220 if (aux.symtab)
7221 free (aux.symtab);
7222 if (aux.strtab)
7223 free ((char *) aux.strtab);
4d6ed7c8
NC		 7224}
7225
3f5e193b
NC		 7226struct hppa_unw_table_entry
7227 {
7228 struct absaddr start;
7229 struct absaddr end;
948f632f 7230 unsigned int Cannot_unwind:1; /* 0 */
3f5e193b
NC		 7231 unsigned int Millicode:1; /* 1 */
7232 unsigned int Millicode_save_sr0:1; /* 2 */
7233 unsigned int Region_description:2; /* 3..4 */
7234 unsigned int reserved1:1; /* 5 */
7235 unsigned int Entry_SR:1; /* 6 */
7236 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
7237 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
7238 unsigned int Args_stored:1; /* 16 */
948f632f
DA		 7239 unsigned int Variable_Frame:1; /* 17 */
7240 unsigned int Separate_Package_Body:1; /* 18 */
3f5e193b 7241 unsigned int Frame_Extension_Millicode:1; /* 19 */
948f632f
DA		 7242 unsigned int Stack_Overflow_Check:1; /* 20 */
7243 unsigned int Two_Instruction_SP_Increment:1;/* 21 */
3f5e193b
NC		 7244 unsigned int Ada_Region:1; /* 22 */
7245 unsigned int cxx_info:1; /* 23 */
948f632f
DA		 7246 unsigned int cxx_try_catch:1; /* 24 */
7247 unsigned int sched_entry_seq:1; /* 25 */
3f5e193b 7248 unsigned int reserved2:1; /* 26 */
948f632f
DA		 7249 unsigned int Save_SP:1; /* 27 */
7250 unsigned int Save_RP:1; /* 28 */
3f5e193b
NC		 7251 unsigned int Save_MRP_in_frame:1; /* 29 */
7252 unsigned int extn_ptr_defined:1; /* 30 */
948f632f 7253 unsigned int Cleanup_defined:1; /* 31 */
3f5e193b 7254
948f632f
DA		 7255 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
7256 unsigned int HP_UX_interrupt_marker:1; /* 1 */
3f5e193b 7257 unsigned int Large_frame:1; /* 2 */
948f632f 7258 unsigned int Pseudo_SP_Set:1; /* 3 */
3f5e193b
NC		 7259 unsigned int reserved4:1; /* 4 */
7260 unsigned int Total_frame_size:27; /* 5..31 */
7261 };
7262
57346661 7263struct hppa_unw_aux_info
948f632f
DA		 7264{
7265 struct hppa_unw_table_entry * table; /* Unwind table. */
7266 unsigned long table_len; /* Length of unwind table. */
7267 bfd_vma seg_base; /* Starting address of segment. */
7268 Elf_Internal_Sym * symtab; /* The symbol table. */
7269 unsigned long nsyms; /* Number of symbols. */
7270 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7271 unsigned long nfuns; /* Number of entries in funtab. */
7272 char * strtab; /* The string table. */
7273 unsigned long strtab_size; /* Size of string table. */
7274};
57346661
AM		 7275
7276static void
2cf0635d 7277dump_hppa_unwind (struct hppa_unw_aux_info * aux)
57346661 7278{
2cf0635d 7279 struct hppa_unw_table_entry * tp;
948f632f
DA		 7280 unsigned long j, nfuns;
7281
7282 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7283 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7284 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7285 aux->funtab[nfuns++] = aux->symtab[j];
7286 aux->nfuns = nfuns;
7287 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
57346661 7288
57346661
AM		 7289 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7290 {
7291 bfd_vma offset;
2cf0635d 7292 const char * procname;
57346661 7293
948f632f 7294 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
57346661
AM		 7295 aux->strtab_size, tp->start, &procname,
7296 &offset);
7297
7298 fputs ("\n<", stdout);
7299
7300 if (procname)
7301 {
7302 fputs (procname, stdout);
7303
7304 if (offset)
7305 printf ("+%lx", (unsigned long) offset);
7306 }
7307
7308 fputs (">: [", stdout);
7309 print_vma (tp->start.offset, PREFIX_HEX);
7310 fputc ('-', stdout);
7311 print_vma (tp->end.offset, PREFIX_HEX);
7312 printf ("]\n\t");
7313
18bd398b
NC		 7314#define PF(_m) if (tp->_m) printf (#_m " ");
7315#define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
57346661
AM		 7316 PF(Cannot_unwind);
7317 PF(Millicode);
7318 PF(Millicode_save_sr0);
18bd398b 7319 /* PV(Region_description); */
57346661
AM		 7320 PF(Entry_SR);
7321 PV(Entry_FR);
7322 PV(Entry_GR);
7323 PF(Args_stored);
7324 PF(Variable_Frame);
7325 PF(Separate_Package_Body);
7326 PF(Frame_Extension_Millicode);
7327 PF(Stack_Overflow_Check);
7328 PF(Two_Instruction_SP_Increment);
7329 PF(Ada_Region);
7330 PF(cxx_info);
7331 PF(cxx_try_catch);
7332 PF(sched_entry_seq);
7333 PF(Save_SP);
7334 PF(Save_RP);
7335 PF(Save_MRP_in_frame);
7336 PF(extn_ptr_defined);
7337 PF(Cleanup_defined);
7338 PF(MPE_XL_interrupt_marker);
7339 PF(HP_UX_interrupt_marker);
7340 PF(Large_frame);
7341 PF(Pseudo_SP_Set);
7342 PV(Total_frame_size);
7343#undef PF
7344#undef PV
7345 }
7346
18bd398b 7347 printf ("\n");
948f632f
DA		 7348
7349 free (aux->funtab);
57346661
AM		 7350}
7351
7352static int
2cf0635d
NC		 7353slurp_hppa_unwind_table (FILE * file,
7354 struct hppa_unw_aux_info * aux,
7355 Elf_Internal_Shdr * sec)
57346661 7356{
1c0751b2 7357 unsigned long size, unw_ent_size, nentries, nrelas, i;
2cf0635d
NC		 7358 Elf_Internal_Phdr * seg;
7359 struct hppa_unw_table_entry * tep;
7360 Elf_Internal_Shdr * relsec;
7361 Elf_Internal_Rela * rela;
7362 Elf_Internal_Rela * rp;
7363 unsigned char * table;
7364 unsigned char * tp;
7365 Elf_Internal_Sym * sym;
7366 const char * relname;
57346661 7367
57346661
AM		 7368 /* First, find the starting address of the segment that includes
7369 this section. */
7370
7371 if (elf_header.e_phnum)
7372 {
7373 if (! get_program_headers (file))
7374 return 0;
7375
7376 for (seg = program_headers;
7377 seg < program_headers + elf_header.e_phnum;
7378 ++seg)
7379 {
7380 if (seg->p_type != PT_LOAD)
7381 continue;
7382
7383 if (sec->sh_addr >= seg->p_vaddr
7384 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7385 {
7386 aux->seg_base = seg->p_vaddr;
7387 break;
7388 }
7389 }
7390 }
7391
7392 /* Second, build the unwind table from the contents of the unwind
7393 section. */
7394 size = sec->sh_size;
3f5e193b
NC		 7395 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7396 _("unwind table"));
57346661
AM		 7397 if (!table)
7398 return 0;
7399
1c0751b2
DA		 7400 unw_ent_size = 16;
7401 nentries = size / unw_ent_size;
7402 size = unw_ent_size * nentries;
57346661 7403
3f5e193b
NC		 7404 tep = aux->table = (struct hppa_unw_table_entry *)
7405 xcmalloc (nentries, sizeof (aux->table[0]));
57346661 7406
1c0751b2 7407 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
57346661
AM		 7408 {
7409 unsigned int tmp1, tmp2;
7410
7411 tep->start.section = SHN_UNDEF;
7412 tep->end.section = SHN_UNDEF;
7413
1c0751b2
DA		 7414 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7415 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7416 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7417 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7418
7419 tep->start.offset += aux->seg_base;
7420 tep->end.offset += aux->seg_base;
57346661
AM		 7421
7422 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7423 tep->Millicode = (tmp1 >> 30) & 0x1;
7424 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7425 tep->Region_description = (tmp1 >> 27) & 0x3;
7426 tep->reserved1 = (tmp1 >> 26) & 0x1;
7427 tep->Entry_SR = (tmp1 >> 25) & 0x1;
7428 tep->Entry_FR = (tmp1 >> 21) & 0xf;
7429 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7430 tep->Args_stored = (tmp1 >> 15) & 0x1;
7431 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7432 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7433 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7434 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7435 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7436 tep->Ada_Region = (tmp1 >> 9) & 0x1;
7437 tep->cxx_info = (tmp1 >> 8) & 0x1;
7438 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7439 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7440 tep->reserved2 = (tmp1 >> 5) & 0x1;
7441 tep->Save_SP = (tmp1 >> 4) & 0x1;
7442 tep->Save_RP = (tmp1 >> 3) & 0x1;
7443 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7444 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7445 tep->Cleanup_defined = tmp1 & 0x1;
7446
7447 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7448 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7449 tep->Large_frame = (tmp2 >> 29) & 0x1;
7450 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7451 tep->reserved4 = (tmp2 >> 27) & 0x1;
7452 tep->Total_frame_size = tmp2 & 0x7ffffff;
57346661
AM		 7453 }
7454 free (table);
7455
7456 /* Third, apply any relocations to the unwind table. */
57346661
AM		 7457 for (relsec = section_headers;
7458 relsec < section_headers + elf_header.e_shnum;
7459 ++relsec)
7460 {
7461 if (relsec->sh_type != SHT_RELA
4fbb74a6
AM		 7462 || relsec->sh_info >= elf_header.e_shnum
7463 || section_headers + relsec->sh_info != sec)
57346661
AM		 7464 continue;
7465
7466 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7467 & rela, & nrelas))
7468 return 0;
7469
7470 for (rp = rela; rp < rela + nrelas; ++rp)
7471 {
aca88567
NC		 7472 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7473 sym = aux->symtab + get_reloc_symindex (rp->r_info);
57346661
AM		 7474
7475 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
0112cd26 7476 if (! const_strneq (relname, "R_PARISC_SEGREL"))
57346661
AM		 7477 {
7478 warn (_("Skipping unexpected relocation type %s\n"), relname);
7479 continue;
7480 }
7481
7482 i = rp->r_offset / unw_ent_size;
7483
89fac5e3 7484 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
57346661
AM		 7485 {
7486 case 0:
7487 aux->table[i].start.section = sym->st_shndx;
1e456d54 7488 aux->table[i].start.offset = sym->st_value + rp->r_addend;
57346661
AM		 7489 break;
7490 case 1:
7491 aux->table[i].end.section = sym->st_shndx;
1e456d54 7492 aux->table[i].end.offset = sym->st_value + rp->r_addend;
57346661
AM		 7493 break;
7494 default:
7495 break;
7496 }
7497 }
7498
7499 free (rela);
7500 }
7501
1c0751b2 7502 aux->table_len = nentries;
57346661
AM		 7503
7504 return 1;
7505}
7506
1b31d05e 7507static void
2cf0635d 7508hppa_process_unwind (FILE * file)
57346661 7509{
57346661 7510 struct hppa_unw_aux_info aux;
2cf0635d
NC		 7511 Elf_Internal_Shdr * unwsec = NULL;
7512 Elf_Internal_Shdr * strsec;
7513 Elf_Internal_Shdr * sec;
18bd398b 7514 unsigned long i;
57346661 7515
c256ffe7 7516 if (string_table == NULL)
1b31d05e
NC		 7517 return;
7518
7519 memset (& aux, 0, sizeof (aux));
57346661
AM		 7520
7521 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7522 {
c256ffe7 7523 if (sec->sh_type == SHT_SYMTAB
4fbb74a6 7524 && sec->sh_link < elf_header.e_shnum)
57346661 7525 {
ba5cdace 7526 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
57346661 7527
4fbb74a6 7528 strsec = section_headers + sec->sh_link;
4082ef84
NC		 7529 if (aux.strtab != NULL)
7530 {
7531 error (_("Multiple auxillary string tables encountered\n"));
7532 free (aux.strtab);
7533 }
3f5e193b
NC		 7534 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7535 1, strsec->sh_size,
7536 _("string table"));
c256ffe7 7537 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
57346661 7538 }
18bd398b 7539 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661
AM		 7540 unwsec = sec;
7541 }
7542
7543 if (!unwsec)
7544 printf (_("\nThere are no unwind sections in this file.\n"));
7545
7546 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7547 {
18bd398b 7548 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
57346661 7549 {
74e1a04b
NC		 7550 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7551 printable_section_name (sec),
57346661 7552 (unsigned long) sec->sh_offset,
89fac5e3 7553 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
57346661
AM		 7554
7555 slurp_hppa_unwind_table (file, &aux, sec);
7556 if (aux.table_len > 0)
7557 dump_hppa_unwind (&aux);
7558
7559 if (aux.table)
7560 free ((char *) aux.table);
7561 aux.table = NULL;
7562 }
7563 }
7564
7565 if (aux.symtab)
7566 free (aux.symtab);
7567 if (aux.strtab)
7568 free ((char *) aux.strtab);
57346661
AM		 7569}
7570
0b6ae522
DJ		 7571struct arm_section
7572{
a734115a
NC		 7573 unsigned char * data; /* The unwind data. */
7574 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
7575 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
7576 unsigned long nrelas; /* The number of relocations. */
7577 unsigned int rel_type; /* REL or RELA ? */
7578 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
0b6ae522
DJ		 7579};
7580
7581struct arm_unw_aux_info
7582{
a734115a
NC		 7583 FILE * file; /* The file containing the unwind sections. */
7584 Elf_Internal_Sym * symtab; /* The file's symbol table. */
7585 unsigned long nsyms; /* Number of symbols. */
948f632f
DA		 7586 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7587 unsigned long nfuns; /* Number of these symbols. */
a734115a
NC		 7588 char * strtab; /* The file's string table. */
7589 unsigned long strtab_size; /* Size of string table. */
0b6ae522
DJ		 7590};
7591
7592static const char *
7593arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7594 bfd_vma fn, struct absaddr addr)
7595{
7596 const char *procname;
7597 bfd_vma sym_offset;
7598
7599 if (addr.section == SHN_UNDEF)
7600 addr.offset = fn;
7601
948f632f 7602 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
0b6ae522
DJ		 7603 aux->strtab_size, addr, &procname,
7604 &sym_offset);
7605
7606 print_vma (fn, PREFIX_HEX);
7607
7608 if (procname)
7609 {
7610 fputs (" <", stdout);
7611 fputs (procname, stdout);
7612
7613 if (sym_offset)
7614 printf ("+0x%lx", (unsigned long) sym_offset);
7615 fputc ('>', stdout);
7616 }
7617
7618 return procname;
7619}
7620
7621static void
7622arm_free_section (struct arm_section *arm_sec)
7623{
7624 if (arm_sec->data != NULL)
7625 free (arm_sec->data);
7626
7627 if (arm_sec->rela != NULL)
7628 free (arm_sec->rela);
7629}
7630
a734115a
NC		 7631/* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7632 cached section and install SEC instead.
7633 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7634 and return its valued in * WORDP, relocating if necessary.
1b31d05e 7635 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
a734115a 7636 relocation's offset in ADDR.
1b31d05e
NC		 7637 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7638 into the string table of the symbol associated with the reloc. If no
7639 reloc was applied store -1 there.
7640 5) Return TRUE upon success, FALSE otherwise. */
a734115a
NC		 7641
7642static bfd_boolean
1b31d05e
NC		 7643get_unwind_section_word (struct arm_unw_aux_info * aux,
7644 struct arm_section * arm_sec,
7645 Elf_Internal_Shdr * sec,
7646 bfd_vma word_offset,
7647 unsigned int * wordp,
7648 struct absaddr * addr,
7649 bfd_vma * sym_name)
0b6ae522
DJ		 7650{
7651 Elf_Internal_Rela *rp;
7652 Elf_Internal_Sym *sym;
7653 const char * relname;
7654 unsigned int word;
7655 bfd_boolean wrapped;
7656
e0a31db1
NC		 7657 if (sec == NULL || arm_sec == NULL)
7658 return FALSE;
7659
0b6ae522
DJ		 7660 addr->section = SHN_UNDEF;
7661 addr->offset = 0;
7662
1b31d05e
NC		 7663 if (sym_name != NULL)
7664 *sym_name = (bfd_vma) -1;
7665
a734115a 7666 /* If necessary, update the section cache. */
0b6ae522
DJ		 7667 if (sec != arm_sec->sec)
7668 {
7669 Elf_Internal_Shdr *relsec;
7670
7671 arm_free_section (arm_sec);
7672
7673 arm_sec->sec = sec;
7674 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7675 sec->sh_size, _("unwind data"));
0b6ae522
DJ		 7676 arm_sec->rela = NULL;
7677 arm_sec->nrelas = 0;
7678
7679 for (relsec = section_headers;
7680 relsec < section_headers + elf_header.e_shnum;
7681 ++relsec)
7682 {
7683 if (relsec->sh_info >= elf_header.e_shnum
1ae40aa4
NC		 7684 || section_headers + relsec->sh_info != sec
7685 /* PR 15745: Check the section type as well. */
7686 || (relsec->sh_type != SHT_REL
7687 && relsec->sh_type != SHT_RELA))
0b6ae522
DJ		 7688 continue;
7689
a734115a 7690 arm_sec->rel_type = relsec->sh_type;
0b6ae522
DJ		 7691 if (relsec->sh_type == SHT_REL)
7692 {
7693 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7694 relsec->sh_size,
7695 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7696 return FALSE;
0b6ae522 7697 }
1ae40aa4 7698 else /* relsec->sh_type == SHT_RELA */
0b6ae522
DJ		 7699 {
7700 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7701 relsec->sh_size,
7702 & arm_sec->rela, & arm_sec->nrelas))
a734115a 7703 return FALSE;
0b6ae522 7704 }
1ae40aa4 7705 break;
0b6ae522
DJ		 7706 }
7707
7708 arm_sec->next_rela = arm_sec->rela;
7709 }
7710
a734115a 7711 /* If there is no unwind data we can do nothing. */
0b6ae522 7712 if (arm_sec->data == NULL)
a734115a 7713 return FALSE;
0b6ae522 7714
e0a31db1 7715 /* If the offset is invalid then fail. */
1a915552
NC		 7716 if (word_offset > (sec->sh_size - 4)
7717 /* PR 18879 */
7718 || (sec->sh_size < 5 && word_offset >= sec->sh_size)
7719 || ((bfd_signed_vma) word_offset) < 0)
e0a31db1
NC		 7720 return FALSE;
7721
a734115a 7722 /* Get the word at the required offset. */
0b6ae522
DJ		 7723 word = byte_get (arm_sec->data + word_offset, 4);
7724
0eff7165
NC		 7725 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7726 if (arm_sec->rela == NULL)
7727 {
7728 * wordp = word;
7729 return TRUE;
7730 }
7731
a734115a 7732 /* Look through the relocs to find the one that applies to the provided offset. */
0b6ae522
DJ		 7733 wrapped = FALSE;
7734 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7735 {
7736 bfd_vma prelval, offset;
7737
7738 if (rp->r_offset > word_offset && !wrapped)
7739 {
7740 rp = arm_sec->rela;
7741 wrapped = TRUE;
7742 }
7743 if (rp->r_offset > word_offset)
7744 break;
7745
7746 if (rp->r_offset & 3)
7747 {
7748 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7749 (unsigned long) rp->r_offset);
7750 continue;
7751 }
7752
7753 if (rp->r_offset < word_offset)
7754 continue;
7755
74e1a04b
NC		 7756 /* PR 17531: file: 027-161405-0.004 */
7757 if (aux->symtab == NULL)
7758 continue;
7759
0b6ae522
DJ		 7760 if (arm_sec->rel_type == SHT_REL)
7761 {
7762 offset = word & 0x7fffffff;
7763 if (offset & 0x40000000)
7764 offset |= ~ (bfd_vma) 0x7fffffff;
7765 }
a734115a 7766 else if (arm_sec->rel_type == SHT_RELA)
0b6ae522 7767 offset = rp->r_addend;
a734115a 7768 else
74e1a04b
NC		 7769 {
7770 error (_("Unknown section relocation type %d encountered\n"),
7771 arm_sec->rel_type);
7772 break;
7773 }
0b6ae522 7774
071436c6
NC		 7775 /* PR 17531 file: 027-1241568-0.004. */
7776 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7777 {
7778 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7779 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7780 break;
7781 }
7782
7783 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
0b6ae522
DJ		 7784 offset += sym->st_value;
7785 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7786
a734115a
NC		 7787 /* Check that we are processing the expected reloc type. */
7788 if (elf_header.e_machine == EM_ARM)
7789 {
7790 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7791 if (relname == NULL)
7792 {
7793 warn (_("Skipping unknown ARM relocation type: %d\n"),
7794 (int) ELF32_R_TYPE (rp->r_info));
7795 continue;
7796 }
a734115a
NC		 7797
7798 if (streq (relname, "R_ARM_NONE"))
7799 continue;
0b4362b0 7800
a734115a
NC		 7801 if (! streq (relname, "R_ARM_PREL31"))
7802 {
071436c6 7803 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
a734115a
NC		 7804 continue;
7805 }
7806 }
7807 else if (elf_header.e_machine == EM_TI_C6000)
7808 {
7809 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
071436c6
NC		 7810 if (relname == NULL)
7811 {
7812 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7813 (int) ELF32_R_TYPE (rp->r_info));
7814 continue;
7815 }
0b4362b0 7816
a734115a
NC		 7817 if (streq (relname, "R_C6000_NONE"))
7818 continue;
7819
7820 if (! streq (relname, "R_C6000_PREL31"))
7821 {
071436c6 7822 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
a734115a
NC		 7823 continue;
7824 }
7825
7826 prelval >>= 1;
7827 }
7828 else
74e1a04b
NC		 7829 {
7830 /* This function currently only supports ARM and TI unwinders. */
7831 warn (_("Only TI and ARM unwinders are currently supported\n"));
7832 break;
7833 }
fa197c1c 7834
0b6ae522
DJ		 7835 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7836 addr->section = sym->st_shndx;
7837 addr->offset = offset;
74e1a04b 7838
1b31d05e
NC		 7839 if (sym_name)
7840 * sym_name = sym->st_name;
0b6ae522
DJ		 7841 break;
7842 }
7843
7844 *wordp = word;
7845 arm_sec->next_rela = rp;
7846
a734115a 7847 return TRUE;
0b6ae522
DJ		 7848}
7849
a734115a
NC		 7850static const char *tic6x_unwind_regnames[16] =
7851{
0b4362b0
RM		 7852 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7853 "A14", "A13", "A12", "A11", "A10",
a734115a
NC		 7854 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7855};
fa197c1c 7856
0b6ae522 7857static void
fa197c1c 7858decode_tic6x_unwind_regmask (unsigned int mask)
0b6ae522 7859{
fa197c1c
PB		 7860 int i;
7861
7862 for (i = 12; mask; mask >>= 1, i--)
7863 {
7864 if (mask & 1)
7865 {
7866 fputs (tic6x_unwind_regnames[i], stdout);
7867 if (mask > 1)
7868 fputs (", ", stdout);
7869 }
7870 }
7871}
0b6ae522
DJ		 7872
7873#define ADVANCE \
7874 if (remaining == 0 && more_words) \
7875 { \
7876 data_offset += 4; \
1b31d05e
NC		 7877 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7878 data_offset, & word, & addr, NULL)) \
0b6ae522
DJ		 7879 return; \
7880 remaining = 4; \
7881 more_words--; \
7882 } \
7883
7884#define GET_OP(OP) \
7885 ADVANCE; \
7886 if (remaining) \
7887 { \
7888 remaining--; \
7889 (OP) = word >> 24; \
7890 word <<= 8; \
7891 } \
7892 else \
7893 { \
2b692964 7894 printf (_("[Truncated opcode]\n")); \
0b6ae522
DJ		 7895 return; \
7896 } \
cc5914eb 7897 printf ("0x%02x ", OP)
0b6ae522 7898
fa197c1c 7899static void
948f632f
DA		 7900decode_arm_unwind_bytecode (struct arm_unw_aux_info * aux,
7901 unsigned int word,
7902 unsigned int remaining,
7903 unsigned int more_words,
7904 bfd_vma data_offset,
7905 Elf_Internal_Shdr * data_sec,
7906 struct arm_section * data_arm_sec)
fa197c1c
PB		 7907{
7908 struct absaddr addr;
0b6ae522
DJ		 7909
7910 /* Decode the unwinding instructions. */
7911 while (1)
7912 {
7913 unsigned int op, op2;
7914
7915 ADVANCE;
7916 if (remaining == 0)
7917 break;
7918 remaining--;
7919 op = word >> 24;
7920 word <<= 8;
7921
cc5914eb 7922 printf (" 0x%02x ", op);
0b6ae522
DJ		 7923
7924 if ((op & 0xc0) == 0x00)
7925 {
7926 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7927
cc5914eb 7928 printf (" vsp = vsp + %d", offset);
0b6ae522
DJ		 7929 }
7930 else if ((op & 0xc0) == 0x40)
7931 {
7932 int offset = ((op & 0x3f) << 2) + 4;
61865e30 7933
cc5914eb 7934 printf (" vsp = vsp - %d", offset);
0b6ae522
DJ		 7935 }
7936 else if ((op & 0xf0) == 0x80)
7937 {
7938 GET_OP (op2);
7939 if (op == 0x80 && op2 == 0)
7940 printf (_("Refuse to unwind"));
7941 else
7942 {
7943 unsigned int mask = ((op & 0x0f) << 8) | op2;
7944 int first = 1;
7945 int i;
2b692964 7946
0b6ae522
DJ		 7947 printf ("pop {");
7948 for (i = 0; i < 12; i++)
7949 if (mask & (1 << i))
7950 {
7951 if (first)
7952 first = 0;
7953 else
7954 printf (", ");
7955 printf ("r%d", 4 + i);
7956 }
7957 printf ("}");
7958 }
7959 }
7960 else if ((op & 0xf0) == 0x90)
7961 {
7962 if (op == 0x9d || op == 0x9f)
7963 printf (_(" [Reserved]"));
7964 else
cc5914eb 7965 printf (" vsp = r%d", op & 0x0f);
0b6ae522
DJ		 7966 }
7967 else if ((op & 0xf0) == 0xa0)
7968 {
7969 int end = 4 + (op & 0x07);
7970 int first = 1;
7971 int i;
61865e30 7972
0b6ae522
DJ		 7973 printf (" pop {");
7974 for (i = 4; i <= end; i++)
7975 {
7976 if (first)
7977 first = 0;
7978 else
7979 printf (", ");
7980 printf ("r%d", i);
7981 }
7982 if (op & 0x08)
7983 {
1b31d05e 7984 if (!first)
0b6ae522
DJ		 7985 printf (", ");
7986 printf ("r14");
7987 }
7988 printf ("}");
7989 }
7990 else if (op == 0xb0)
7991 printf (_(" finish"));
7992 else if (op == 0xb1)
7993 {
7994 GET_OP (op2);
7995 if (op2 == 0 || (op2 & 0xf0) != 0)
7996 printf (_("[Spare]"));
7997 else
7998 {
7999 unsigned int mask = op2 & 0x0f;
8000 int first = 1;
8001 int i;
61865e30 8002
0b6ae522
DJ		 8003 printf ("pop {");
8004 for (i = 0; i < 12; i++)
8005 if (mask & (1 << i))
8006 {
8007 if (first)
8008 first = 0;
8009 else
8010 printf (", ");
8011 printf ("r%d", i);
8012 }
8013 printf ("}");
8014 }
8015 }
8016 else if (op == 0xb2)
8017 {
b115cf96 8018 unsigned char buf[9];
0b6ae522
DJ		 8019 unsigned int i, len;
8020 unsigned long offset;
61865e30 8021
b115cf96 8022 for (i = 0; i < sizeof (buf); i++)
0b6ae522
DJ		 8023 {
8024 GET_OP (buf[i]);
8025 if ((buf[i] & 0x80) == 0)
8026 break;
8027 }
4082ef84
NC		 8028 if (i == sizeof (buf))
8029 printf (_("corrupt change to vsp"));
8030 else
8031 {
8032 offset = read_uleb128 (buf, &len, buf + i + 1);
8033 assert (len == i + 1);
8034 offset = offset * 4 + 0x204;
8035 printf ("vsp = vsp + %ld", offset);
8036 }
0b6ae522 8037 }
61865e30 8038 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
0b6ae522 8039 {
61865e30
NC		 8040 unsigned int first, last;
8041
8042 GET_OP (op2);
8043 first = op2 >> 4;
8044 last = op2 & 0x0f;
8045 if (op == 0xc8)
8046 first = first + 16;
8047 printf ("pop {D%d", first);
8048 if (last)
8049 printf ("-D%d", first + last);
8050 printf ("}");
8051 }
8052 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8053 {
8054 unsigned int count = op & 0x07;
8055
8056 printf ("pop {D8");
8057 if (count)
8058 printf ("-D%d", 8 + count);
8059 printf ("}");
8060 }
8061 else if (op >= 0xc0 && op <= 0xc5)
8062 {
8063 unsigned int count = op & 0x07;
8064
8065 printf (" pop {wR10");
8066 if (count)
8067 printf ("-wR%d", 10 + count);
8068 printf ("}");
8069 }
8070 else if (op == 0xc6)
8071 {
8072 unsigned int first, last;
8073
8074 GET_OP (op2);
8075 first = op2 >> 4;
8076 last = op2 & 0x0f;
8077 printf ("pop {wR%d", first);
8078 if (last)
8079 printf ("-wR%d", first + last);
8080 printf ("}");
8081 }
8082 else if (op == 0xc7)
8083 {
8084 GET_OP (op2);
8085 if (op2 == 0 || (op2 & 0xf0) != 0)
8086 printf (_("[Spare]"));
0b6ae522
DJ		 8087 else
8088 {
61865e30
NC		 8089 unsigned int mask = op2 & 0x0f;
8090 int first = 1;
8091 int i;
8092
8093 printf ("pop {");
8094 for (i = 0; i < 4; i++)
8095 if (mask & (1 << i))
8096 {
8097 if (first)
8098 first = 0;
8099 else
8100 printf (", ");
8101 printf ("wCGR%d", i);
8102 }
8103 printf ("}");
0b6ae522
DJ		 8104 }
8105 }
61865e30
NC		 8106 else
8107 printf (_(" [unsupported opcode]"));
0b6ae522
DJ		 8108 printf ("\n");
8109 }
fa197c1c
PB		 8110}
8111
8112static void
948f632f
DA		 8113decode_tic6x_unwind_bytecode (struct arm_unw_aux_info * aux,
8114 unsigned int word,
8115 unsigned int remaining,
8116 unsigned int more_words,
8117 bfd_vma data_offset,
8118 Elf_Internal_Shdr * data_sec,
8119 struct arm_section * data_arm_sec)
fa197c1c
PB		 8120{
8121 struct absaddr addr;
8122
8123 /* Decode the unwinding instructions. */
8124 while (1)
8125 {
8126 unsigned int op, op2;
8127
8128 ADVANCE;
8129 if (remaining == 0)
8130 break;
8131 remaining--;
8132 op = word >> 24;
8133 word <<= 8;
8134
9cf03b7e 8135 printf (" 0x%02x ", op);
fa197c1c
PB		 8136
8137 if ((op & 0xc0) == 0x00)
8138 {
8139 int offset = ((op & 0x3f) << 3) + 8;
9cf03b7e 8140 printf (" sp = sp + %d", offset);
fa197c1c
PB		 8141 }
8142 else if ((op & 0xc0) == 0x80)
8143 {
8144 GET_OP (op2);
8145 if (op == 0x80 && op2 == 0)
8146 printf (_("Refuse to unwind"));
8147 else
8148 {
8149 unsigned int mask = ((op & 0x1f) << 8) | op2;
8150 if (op & 0x20)
8151 printf ("pop compact {");
8152 else
8153 printf ("pop {");
8154
8155 decode_tic6x_unwind_regmask (mask);
8156 printf("}");
8157 }
8158 }
8159 else if ((op & 0xf0) == 0xc0)
8160 {
8161 unsigned int reg;
8162 unsigned int nregs;
8163 unsigned int i;
8164 const char *name;
a734115a
NC		 8165 struct
8166 {
fa197c1c
PB		 8167 unsigned int offset;
8168 unsigned int reg;
8169 } regpos[16];
8170
8171 /* Scan entire instruction first so that GET_OP output is not
8172 interleaved with disassembly. */
8173 nregs = 0;
8174 for (i = 0; nregs < (op & 0xf); i++)
8175 {
8176 GET_OP (op2);
8177 reg = op2 >> 4;
8178 if (reg != 0xf)
8179 {
8180 regpos[nregs].offset = i * 2;
8181 regpos[nregs].reg = reg;
8182 nregs++;
8183 }
8184
8185 reg = op2 & 0xf;
8186 if (reg != 0xf)
8187 {
8188 regpos[nregs].offset = i * 2 + 1;
8189 regpos[nregs].reg = reg;
8190 nregs++;
8191 }
8192 }
8193
8194 printf (_("pop frame {"));
8195 reg = nregs - 1;
8196 for (i = i * 2; i > 0; i--)
8197 {
8198 if (regpos[reg].offset == i - 1)
8199 {
8200 name = tic6x_unwind_regnames[regpos[reg].reg];
8201 if (reg > 0)
8202 reg--;
8203 }
8204 else
8205 name = _("[pad]");
8206
8207 fputs (name, stdout);
8208 if (i > 1)
8209 printf (", ");
8210 }
8211
8212 printf ("}");
8213 }
8214 else if (op == 0xd0)
8215 printf (" MOV FP, SP");
8216 else if (op == 0xd1)
8217 printf (" __c6xabi_pop_rts");
8218 else if (op == 0xd2)
8219 {
8220 unsigned char buf[9];
8221 unsigned int i, len;
8222 unsigned long offset;
a734115a 8223
fa197c1c
PB		 8224 for (i = 0; i < sizeof (buf); i++)
8225 {
8226 GET_OP (buf[i]);
8227 if ((buf[i] & 0x80) == 0)
8228 break;
8229 }
0eff7165
NC		 8230 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8231 if (i == sizeof (buf))
8232 {
8233 printf ("<corrupt sp adjust>\n");
8234 warn (_("Corrupt stack pointer adjustment detected\n"));
8235 return;
8236 }
948f632f 8237
f6f0e17b 8238 offset = read_uleb128 (buf, &len, buf + i + 1);
fa197c1c
PB		 8239 assert (len == i + 1);
8240 offset = offset * 8 + 0x408;
8241 printf (_("sp = sp + %ld"), offset);
8242 }
8243 else if ((op & 0xf0) == 0xe0)
8244 {
8245 if ((op & 0x0f) == 7)
8246 printf (" RETURN");
8247 else
8248 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8249 }
8250 else
8251 {
8252 printf (_(" [unsupported opcode]"));
8253 }
8254 putchar ('\n');
8255 }
8256}
8257
8258static bfd_vma
a734115a 8259arm_expand_prel31 (bfd_vma word, bfd_vma where)
fa197c1c
PB		 8260{
8261 bfd_vma offset;
8262
8263 offset = word & 0x7fffffff;
8264 if (offset & 0x40000000)
8265 offset |= ~ (bfd_vma) 0x7fffffff;
8266
8267 if (elf_header.e_machine == EM_TI_C6000)
8268 offset <<= 1;
8269
8270 return offset + where;
8271}
8272
8273static void
1b31d05e
NC		 8274decode_arm_unwind (struct arm_unw_aux_info * aux,
8275 unsigned int word,
8276 unsigned int remaining,
8277 bfd_vma data_offset,
8278 Elf_Internal_Shdr * data_sec,
8279 struct arm_section * data_arm_sec)
fa197c1c
PB		 8280{
8281 int per_index;
8282 unsigned int more_words = 0;
37e14bc3 8283 struct absaddr addr;
1b31d05e 8284 bfd_vma sym_name = (bfd_vma) -1;
fa197c1c
PB		 8285
8286 if (remaining == 0)
8287 {
1b31d05e
NC		 8288 /* Fetch the first word.
8289 Note - when decoding an object file the address extracted
8290 here will always be 0. So we also pass in the sym_name
8291 parameter so that we can find the symbol associated with
8292 the personality routine. */
8293 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8294 & word, & addr, & sym_name))
fa197c1c 8295 return;
1b31d05e 8296
fa197c1c
PB		 8297 remaining = 4;
8298 }
8299
8300 if ((word & 0x80000000) == 0)
8301 {
8302 /* Expand prel31 for personality routine. */
8303 bfd_vma fn;
8304 const char *procname;
8305
a734115a 8306 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
fa197c1c 8307 printf (_(" Personality routine: "));
1b31d05e
NC		 8308 if (fn == 0
8309 && addr.section == SHN_UNDEF && addr.offset == 0
8310 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8311 {
8312 procname = aux->strtab + sym_name;
8313 print_vma (fn, PREFIX_HEX);
8314 if (procname)
8315 {
8316 fputs (" <", stdout);
8317 fputs (procname, stdout);
8318 fputc ('>', stdout);
8319 }
8320 }
8321 else
8322 procname = arm_print_vma_and_name (aux, fn, addr);
fa197c1c
PB		 8323 fputc ('\n', stdout);
8324
8325 /* The GCC personality routines use the standard compact
8326 encoding, starting with one byte giving the number of
8327 words. */
8328 if (procname != NULL
8329 && (const_strneq (procname, "__gcc_personality_v0")
8330 || const_strneq (procname, "__gxx_personality_v0")
8331 || const_strneq (procname, "__gcj_personality_v0")
8332 || const_strneq (procname, "__gnu_objc_personality_v0")))
8333 {
8334 remaining = 0;
8335 more_words = 1;
8336 ADVANCE;
8337 if (!remaining)
8338 {
8339 printf (_(" [Truncated data]\n"));
8340 return;
8341 }
8342 more_words = word >> 24;
8343 word <<= 8;
8344 remaining--;
8345 per_index = -1;
8346 }
8347 else
8348 return;
8349 }
8350 else
8351 {
1b31d05e 8352 /* ARM EHABI Section 6.3:
0b4362b0 8353
1b31d05e 8354 An exception-handling table entry for the compact model looks like:
0b4362b0 8355
1b31d05e
NC		 8356 31 30-28 27-24 23-0
8357 -- ----- ----- ----
8358 1 0 index Data for personalityRoutine[index] */
8359
8360 if (elf_header.e_machine == EM_ARM
8361 && (word & 0x70000000))
83c257ca 8362 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
1b31d05e 8363
fa197c1c 8364 per_index = (word >> 24) & 0x7f;
1b31d05e 8365 printf (_(" Compact model index: %d\n"), per_index);
fa197c1c
PB		 8366 if (per_index == 0)
8367 {
8368 more_words = 0;
8369 word <<= 8;
8370 remaining--;
8371 }
8372 else if (per_index < 3)
8373 {
8374 more_words = (word >> 16) & 0xff;
8375 word <<= 16;
8376 remaining -= 2;
8377 }
8378 }
8379
8380 switch (elf_header.e_machine)
8381 {
8382 case EM_ARM:
8383 if (per_index < 3)
8384 {
8385 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8386 data_offset, data_sec, data_arm_sec);
8387 }
8388 else
1b31d05e
NC		 8389 {
8390 warn (_("Unknown ARM compact model index encountered\n"));
8391 printf (_(" [reserved]\n"));
8392 }
fa197c1c
PB		 8393 break;
8394
8395 case EM_TI_C6000:
8396 if (per_index < 3)
8397 {
8398 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
1b31d05e 8399 data_offset, data_sec, data_arm_sec);
fa197c1c
PB		 8400 }
8401 else if (per_index < 5)
8402 {
8403 if (((word >> 17) & 0x7f) == 0x7f)
8404 printf (_(" Restore stack from frame pointer\n"));
8405 else
8406 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
8407 printf (_(" Registers restored: "));
8408 if (per_index == 4)
8409 printf (" (compact) ");
8410 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8411 putchar ('\n');
8412 printf (_(" Return register: %s\n"),
8413 tic6x_unwind_regnames[word & 0xf]);
8414 }
8415 else
1b31d05e 8416 printf (_(" [reserved (%d)]\n"), per_index);
fa197c1c
PB		 8417 break;
8418
8419 default:
74e1a04b 8420 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
1b31d05e 8421 elf_header.e_machine);
fa197c1c 8422 }
0b6ae522
DJ		 8423
8424 /* Decode the descriptors. Not implemented. */
8425}
8426
8427static void
8428dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8429{
8430 struct arm_section exidx_arm_sec, extab_arm_sec;
8431 unsigned int i, exidx_len;
948f632f 8432 unsigned long j, nfuns;
0b6ae522
DJ		 8433
8434 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8435 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8436 exidx_len = exidx_sec->sh_size / 8;
8437
948f632f
DA		 8438 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8439 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8440 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8441 aux->funtab[nfuns++] = aux->symtab[j];
8442 aux->nfuns = nfuns;
8443 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8444
0b6ae522
DJ		 8445 for (i = 0; i < exidx_len; i++)
8446 {
8447 unsigned int exidx_fn, exidx_entry;
8448 struct absaddr fn_addr, entry_addr;
8449 bfd_vma fn;
8450
8451 fputc ('\n', stdout);
8452
1b31d05e
NC		 8453 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8454 8 * i, & exidx_fn, & fn_addr, NULL)
8455 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8456 8 * i + 4, & exidx_entry, & entry_addr, NULL))
0b6ae522 8457 {
948f632f 8458 free (aux->funtab);
1b31d05e
NC		 8459 arm_free_section (& exidx_arm_sec);
8460 arm_free_section (& extab_arm_sec);
0b6ae522
DJ		 8461 return;
8462 }
8463
83c257ca
NC		 8464 /* ARM EHABI, Section 5:
8465 An index table entry consists of 2 words.
8466 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8467 if (exidx_fn & 0x80000000)
8468 warn (_("corrupt index table entry: %x\n"), exidx_fn);
8469
a734115a 8470 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
0b6ae522 8471
a734115a 8472 arm_print_vma_and_name (aux, fn, fn_addr);
0b6ae522
DJ		 8473 fputs (": ", stdout);
8474
8475 if (exidx_entry == 1)
8476 {
8477 print_vma (exidx_entry, PREFIX_HEX);
8478 fputs (" [cantunwind]\n", stdout);
8479 }
8480 else if (exidx_entry & 0x80000000)
8481 {
8482 print_vma (exidx_entry, PREFIX_HEX);
8483 fputc ('\n', stdout);
8484 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8485 }
8486 else
8487 {
8f73510c 8488 bfd_vma table, table_offset = 0;
0b6ae522
DJ		 8489 Elf_Internal_Shdr *table_sec;
8490
8491 fputs ("@", stdout);
a734115a 8492 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
0b6ae522
DJ		 8493 print_vma (table, PREFIX_HEX);
8494 printf ("\n");
8495
8496 /* Locate the matching .ARM.extab. */
8497 if (entry_addr.section != SHN_UNDEF
8498 && entry_addr.section < elf_header.e_shnum)
8499 {
8500 table_sec = section_headers + entry_addr.section;
8501 table_offset = entry_addr.offset;
1a915552
NC		 8502 /* PR 18879 */
8503 if (table_offset > table_sec->sh_size
8504 || ((bfd_signed_vma) table_offset) < 0)
8505 {
8506 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8507 (unsigned long) table_offset,
8508 printable_section_name (table_sec));
8509 continue;
8510 }
0b6ae522
DJ		 8511 }
8512 else
8513 {
8514 table_sec = find_section_by_address (table);
8515 if (table_sec != NULL)
8516 table_offset = table - table_sec->sh_addr;
8517 }
8518 if (table_sec == NULL)
8519 {
8520 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8521 (unsigned long) table);
8522 continue;
8523 }
8524 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8525 &extab_arm_sec);
8526 }
8527 }
8528
8529 printf ("\n");
8530
948f632f 8531 free (aux->funtab);
0b6ae522
DJ		 8532 arm_free_section (&exidx_arm_sec);
8533 arm_free_section (&extab_arm_sec);
8534}
8535
fa197c1c 8536/* Used for both ARM and C6X unwinding tables. */
1b31d05e
NC		 8537
8538static void
0b6ae522
DJ		 8539arm_process_unwind (FILE *file)
8540{
8541 struct arm_unw_aux_info aux;
8542 Elf_Internal_Shdr *unwsec = NULL;
8543 Elf_Internal_Shdr *strsec;
8544 Elf_Internal_Shdr *sec;
8545 unsigned long i;
fa197c1c 8546 unsigned int sec_type;
0b6ae522 8547
fa197c1c
PB		 8548 switch (elf_header.e_machine)
8549 {
8550 case EM_ARM:
8551 sec_type = SHT_ARM_EXIDX;
8552 break;
8553
8554 case EM_TI_C6000:
8555 sec_type = SHT_C6000_UNWIND;
8556 break;
8557
0b4362b0 8558 default:
74e1a04b 8559 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
1b31d05e
NC		 8560 elf_header.e_machine);
8561 return;
fa197c1c
PB		 8562 }
8563
0b6ae522 8564 if (string_table == NULL)
1b31d05e
NC		 8565 return;
8566
8567 memset (& aux, 0, sizeof (aux));
8568 aux.file = file;
0b6ae522
DJ		 8569
8570 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8571 {
8572 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8573 {
ba5cdace 8574 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
0b6ae522
DJ		 8575
8576 strsec = section_headers + sec->sh_link;
74e1a04b
NC		 8577
8578 /* PR binutils/17531 file: 011-12666-0.004. */
8579 if (aux.strtab != NULL)
8580 {
4082ef84 8581 error (_("Multiple string tables found in file.\n"));
74e1a04b
NC		 8582 free (aux.strtab);
8583 }
0b6ae522
DJ		 8584 aux.strtab = get_data (NULL, file, strsec->sh_offset,
8585 1, strsec->sh_size, _("string table"));
8586 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8587 }
fa197c1c 8588 else if (sec->sh_type == sec_type)
0b6ae522
DJ		 8589 unwsec = sec;
8590 }
8591
1b31d05e 8592 if (unwsec == NULL)
0b6ae522 8593 printf (_("\nThere are no unwind sections in this file.\n"));
1b31d05e
NC		 8594 else
8595 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8596 {
8597 if (sec->sh_type == sec_type)
8598 {
8599 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
74e1a04b 8600 printable_section_name (sec),
1b31d05e
NC		 8601 (unsigned long) sec->sh_offset,
8602 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
0b6ae522 8603
1b31d05e
NC		 8604 dump_arm_unwind (&aux, sec);
8605 }
8606 }
0b6ae522
DJ		 8607
8608 if (aux.symtab)
8609 free (aux.symtab);
8610 if (aux.strtab)
8611 free ((char *) aux.strtab);
0b6ae522
DJ		 8612}
8613
1b31d05e 8614static void
2cf0635d 8615process_unwind (FILE * file)
57346661 8616{
2cf0635d
NC		 8617 struct unwind_handler
8618 {
57346661 8619 int machtype;
1b31d05e 8620 void (* handler)(FILE *);
2cf0635d
NC		 8621 } handlers[] =
8622 {
0b6ae522 8623 { EM_ARM, arm_process_unwind },
57346661
AM		 8624 { EM_IA_64, ia64_process_unwind },
8625 { EM_PARISC, hppa_process_unwind },
fa197c1c 8626 { EM_TI_C6000, arm_process_unwind },
57346661
AM		 8627 { 0, 0 }
8628 };
8629 int i;
8630
8631 if (!do_unwind)
1b31d05e 8632 return;
57346661
AM		 8633
8634 for (i = 0; handlers[i].handler != NULL; i++)
8635 if (elf_header.e_machine == handlers[i].machtype)
9f758fdc
NC		 8636 {
8637 handlers[i].handler (file);
8638 return;
8639 }
57346661 8640
1b31d05e
NC		 8641 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8642 get_machine_name (elf_header.e_machine));
57346661
AM		 8643}
8644
252b5132 8645static void
2cf0635d 8646dynamic_section_mips_val (Elf_Internal_Dyn * entry)
252b5132
RH		 8647{
8648 switch (entry->d_tag)
8649 {
8650 case DT_MIPS_FLAGS:
8651 if (entry->d_un.d_val == 0)
4b68bca3 8652 printf (_("NONE"));
252b5132
RH		 8653 else
8654 {
8655 static const char * opts[] =
8656 {
8657 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8658 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8659 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8660 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8661 "RLD_ORDER_SAFE"
8662 };
8663 unsigned int cnt;
8664 int first = 1;
2b692964 8665
60bca95a 8666 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
252b5132
RH		 8667 if (entry->d_un.d_val & (1 << cnt))
8668 {
8669 printf ("%s%s", first ? "" : " ", opts[cnt]);
8670 first = 0;
8671 }
252b5132
RH		 8672 }
8673 break;
103f02d3 8674
252b5132 8675 case DT_MIPS_IVERSION:
d79b3d50 8676 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
4b68bca3 8677 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 8678 else
76ca31c0
NC		 8679 {
8680 char buf[40];
8681 sprintf_vma (buf, entry->d_un.d_ptr);
8682 /* Note: coded this way so that there is a single string for translation. */
8683 printf (_("<corrupt: %s>"), buf);
8684 }
252b5132 8685 break;
103f02d3 8686
252b5132
RH		 8687 case DT_MIPS_TIME_STAMP:
8688 {
8689 char timebuf[20];
2cf0635d 8690 struct tm * tmp;
91d6fa6a 8691 time_t atime = entry->d_un.d_val;
82b1b41b 8692
91d6fa6a 8693 tmp = gmtime (&atime);
82b1b41b
NC		 8694 /* PR 17531: file: 6accc532. */
8695 if (tmp == NULL)
8696 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8697 else
8698 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8699 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8700 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4b68bca3 8701 printf (_("Time Stamp: %s"), timebuf);
252b5132
RH		 8702 }
8703 break;
103f02d3 8704
252b5132
RH		 8705 case DT_MIPS_RLD_VERSION:
8706 case DT_MIPS_LOCAL_GOTNO:
8707 case DT_MIPS_CONFLICTNO:
8708 case DT_MIPS_LIBLISTNO:
8709 case DT_MIPS_SYMTABNO:
8710 case DT_MIPS_UNREFEXTNO:
8711 case DT_MIPS_HIPAGENO:
8712 case DT_MIPS_DELTA_CLASS_NO:
8713 case DT_MIPS_DELTA_INSTANCE_NO:
8714 case DT_MIPS_DELTA_RELOC_NO:
8715 case DT_MIPS_DELTA_SYM_NO:
8716 case DT_MIPS_DELTA_CLASSSYM_NO:
8717 case DT_MIPS_COMPACT_SIZE:
4b68bca3 8718 print_vma (entry->d_un.d_ptr, DEC);
252b5132 8719 break;
103f02d3
UD		 8720
8721 default:
4b68bca3 8722 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
103f02d3 8723 }
4b68bca3 8724 putchar ('\n');
103f02d3
UD		 8725}
8726
103f02d3 8727static void
2cf0635d 8728dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
103f02d3
UD		 8729{
8730 switch (entry->d_tag)
8731 {
8732 case DT_HP_DLD_FLAGS:
8733 {
8734 static struct
8735 {
8736 long int bit;
2cf0635d 8737 const char * str;
5e220199
NC		 8738 }
8739 flags[] =
8740 {
8741 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8742 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8743 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8744 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8745 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8746 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8747 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8748 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8749 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8750 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
eec8f817
DA		 8751 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8752 { DT_HP_GST, "HP_GST" },
8753 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8754 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8755 { DT_HP_NODELETE, "HP_NODELETE" },
8756 { DT_HP_GROUP, "HP_GROUP" },
8757 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5e220199 8758 };
103f02d3 8759 int first = 1;
5e220199 8760 size_t cnt;
f7a99963 8761 bfd_vma val = entry->d_un.d_val;
103f02d3 8762
60bca95a 8763 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
103f02d3 8764 if (val & flags[cnt].bit)
30800947
NC		 8765 {
8766 if (! first)
8767 putchar (' ');
8768 fputs (flags[cnt].str, stdout);
8769 first = 0;
8770 val ^= flags[cnt].bit;
8771 }
76da6bbe 8772
103f02d3 8773 if (val != 0 || first)
f7a99963
NC		 8774 {
8775 if (! first)
8776 putchar (' ');
8777 print_vma (val, HEX);
8778 }
103f02d3
UD		 8779 }
8780 break;
76da6bbe 8781
252b5132 8782 default:
f7a99963
NC		 8783 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8784 break;
252b5132 8785 }
35b1837e 8786 putchar ('\n');
252b5132
RH		 8787}
8788
28f997cf
TG		 8789#ifdef BFD64
8790
8791/* VMS vs Unix time offset and factor. */
8792
8793#define VMS_EPOCH_OFFSET 35067168000000000LL
8794#define VMS_GRANULARITY_FACTOR 10000000
8795
8796/* Display a VMS time in a human readable format. */
8797
8798static void
8799print_vms_time (bfd_int64_t vmstime)
8800{
8801 struct tm *tm;
8802 time_t unxtime;
8803
8804 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8805 tm = gmtime (&unxtime);
8806 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8807 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8808 tm->tm_hour, tm->tm_min, tm->tm_sec);
8809}
8810#endif /* BFD64 */
8811
ecc51f48 8812static void
2cf0635d 8813dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
ecc51f48
NC		 8814{
8815 switch (entry->d_tag)
8816 {
0de14b54 8817 case DT_IA_64_PLT_RESERVE:
bdf4d63a 8818 /* First 3 slots reserved. */
ecc51f48
NC		 8819 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8820 printf (" -- ");
8821 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
bdf4d63a
JJ		 8822 break;
8823
28f997cf
TG		 8824 case DT_IA_64_VMS_LINKTIME:
8825#ifdef BFD64
8826 print_vms_time (entry->d_un.d_val);
8827#endif
8828 break;
8829
8830 case DT_IA_64_VMS_LNKFLAGS:
8831 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8832 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8833 printf (" CALL_DEBUG");
8834 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8835 printf (" NOP0BUFS");
8836 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8837 printf (" P0IMAGE");
8838 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8839 printf (" MKTHREADS");
8840 if (entry->d_un.d_val & VMS_LF_UPCALLS)
8841 printf (" UPCALLS");
8842 if (entry->d_un.d_val & VMS_LF_IMGSTA)
8843 printf (" IMGSTA");
8844 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8845 printf (" INITIALIZE");
8846 if (entry->d_un.d_val & VMS_LF_MAIN)
8847 printf (" MAIN");
8848 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8849 printf (" EXE_INIT");
8850 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8851 printf (" TBK_IN_IMG");
8852 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8853 printf (" DBG_IN_IMG");
8854 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8855 printf (" TBK_IN_DSF");
8856 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8857 printf (" DBG_IN_DSF");
8858 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8859 printf (" SIGNATURES");
8860 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8861 printf (" REL_SEG_OFF");
8862 break;
8863
bdf4d63a
JJ		 8864 default:
8865 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8866 break;
ecc51f48 8867 }
bdf4d63a 8868 putchar ('\n');
ecc51f48
NC		 8869}
8870
252b5132 8871static int
2cf0635d 8872get_32bit_dynamic_section (FILE * file)
252b5132 8873{
2cf0635d
NC		 8874 Elf32_External_Dyn * edyn;
8875 Elf32_External_Dyn * ext;
8876 Elf_Internal_Dyn * entry;
103f02d3 8877
3f5e193b
NC		 8878 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8879 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8880 if (!edyn)
8881 return 0;
103f02d3 8882
071436c6
NC		 8883 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8884 might not have the luxury of section headers. Look for the DT_NULL
8885 terminator to determine the number of entries. */
ba2685cc 8886 for (ext = edyn, dynamic_nent = 0;
53c3012c 8887 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
ba2685cc
AM		 8888 ext++)
8889 {
8890 dynamic_nent++;
8891 if (BYTE_GET (ext->d_tag) == DT_NULL)
8892 break;
8893 }
252b5132 8894
3f5e193b
NC		 8895 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8896 sizeof (* entry));
b2d38a17 8897 if (dynamic_section == NULL)
252b5132 8898 {
8b73c356
NC		 8899 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8900 (unsigned long) dynamic_nent);
9ea033b2
NC		 8901 free (edyn);
8902 return 0;
8903 }
252b5132 8904
fb514b26 8905 for (ext = edyn, entry = dynamic_section;
ba2685cc 8906 entry < dynamic_section + dynamic_nent;
fb514b26 8907 ext++, entry++)
9ea033b2 8908 {
fb514b26
AM		 8909 entry->d_tag = BYTE_GET (ext->d_tag);
8910 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8911 }
8912
9ea033b2
NC		 8913 free (edyn);
8914
8915 return 1;
8916}
8917
8918static int
2cf0635d 8919get_64bit_dynamic_section (FILE * file)
9ea033b2 8920{
2cf0635d
NC		 8921 Elf64_External_Dyn * edyn;
8922 Elf64_External_Dyn * ext;
8923 Elf_Internal_Dyn * entry;
103f02d3 8924
071436c6 8925 /* Read in the data. */
3f5e193b
NC		 8926 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8927 dynamic_size, _("dynamic section"));
a6e9f9df
AM		 8928 if (!edyn)
8929 return 0;
103f02d3 8930
071436c6
NC		 8931 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8932 might not have the luxury of section headers. Look for the DT_NULL
8933 terminator to determine the number of entries. */
ba2685cc 8934 for (ext = edyn, dynamic_nent = 0;
53c3012c
AM		 8935 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
8936 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
ba2685cc
AM		 8937 ext++)
8938 {
8939 dynamic_nent++;
66543521 8940 if (BYTE_GET (ext->d_tag) == DT_NULL)
ba2685cc
AM		 8941 break;
8942 }
252b5132 8943
3f5e193b
NC		 8944 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8945 sizeof (* entry));
b2d38a17 8946 if (dynamic_section == NULL)
252b5132 8947 {
8b73c356
NC		 8948 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8949 (unsigned long) dynamic_nent);
252b5132
RH		 8950 free (edyn);
8951 return 0;
8952 }
8953
071436c6 8954 /* Convert from external to internal formats. */
fb514b26 8955 for (ext = edyn, entry = dynamic_section;
ba2685cc 8956 entry < dynamic_section + dynamic_nent;
fb514b26 8957 ext++, entry++)
252b5132 8958 {
66543521
AM		 8959 entry->d_tag = BYTE_GET (ext->d_tag);
8960 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
252b5132
RH		 8961 }
8962
8963 free (edyn);
8964
9ea033b2
NC		 8965 return 1;
8966}
8967
e9e44622
JJ		 8968static void
8969print_dynamic_flags (bfd_vma flags)
d1133906 8970{
e9e44622 8971 int first = 1;
13ae64f3 8972
d1133906
NC		 8973 while (flags)
8974 {
8975 bfd_vma flag;
8976
8977 flag = flags & - flags;
8978 flags &= ~ flag;
8979
e9e44622
JJ		 8980 if (first)
8981 first = 0;
8982 else
8983 putc (' ', stdout);
13ae64f3 8984
d1133906
NC		 8985 switch (flag)
8986 {
e9e44622
JJ		 8987 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
8988 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
8989 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
8990 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
8991 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
2b692964 8992 default: fputs (_("unknown"), stdout); break;
d1133906
NC		 8993 }
8994 }
e9e44622 8995 puts ("");
d1133906
NC		 8996}
8997
b2d38a17
NC		 8998/* Parse and display the contents of the dynamic section. */
8999
9ea033b2 9000static int
2cf0635d 9001process_dynamic_section (FILE * file)
9ea033b2 9002{
2cf0635d 9003 Elf_Internal_Dyn * entry;
9ea033b2
NC		 9004
9005 if (dynamic_size == 0)
9006 {
9007 if (do_dynamic)
b2d38a17 9008 printf (_("\nThere is no dynamic section in this file.\n"));
9ea033b2
NC		 9009
9010 return 1;
9011 }
9012
9013 if (is_32bit_elf)
9014 {
b2d38a17 9015 if (! get_32bit_dynamic_section (file))
9ea033b2
NC		 9016 return 0;
9017 }
b2d38a17 9018 else if (! get_64bit_dynamic_section (file))
9ea033b2
NC		 9019 return 0;
9020
252b5132
RH		 9021 /* Find the appropriate symbol table. */
9022 if (dynamic_symbols == NULL)
9023 {
86dba8ee
AM		 9024 for (entry = dynamic_section;
9025 entry < dynamic_section + dynamic_nent;
9026 ++entry)
252b5132 9027 {
c8286bd1 9028 Elf_Internal_Shdr section;
252b5132
RH		 9029
9030 if (entry->d_tag != DT_SYMTAB)
9031 continue;
9032
9033 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9034
9035 /* Since we do not know how big the symbol table is,
9036 we default to reading in the entire file (!) and
9037 processing that. This is overkill, I know, but it
e3c8793a 9038 should work. */
d93f0186 9039 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132 9040
fb52b2f4
NC		 9041 if (archive_file_offset != 0)
9042 section.sh_size = archive_file_size - section.sh_offset;
9043 else
9044 {
9045 if (fseek (file, 0, SEEK_END))
591a748a 9046 error (_("Unable to seek to end of file!\n"));
fb52b2f4
NC		 9047
9048 section.sh_size = ftell (file) - section.sh_offset;
9049 }
252b5132 9050
9ea033b2 9051 if (is_32bit_elf)
9ad5cbcf 9052 section.sh_entsize = sizeof (Elf32_External_Sym);
9ea033b2 9053 else
9ad5cbcf 9054 section.sh_entsize = sizeof (Elf64_External_Sym);
071436c6 9055 section.sh_name = string_table_length;
252b5132 9056
ba5cdace 9057 dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
19936277 9058 if (num_dynamic_syms < 1)
252b5132
RH		 9059 {
9060 error (_("Unable to determine the number of symbols to load\n"));
9061 continue;
9062 }
252b5132
RH		 9063 }
9064 }
9065
9066 /* Similarly find a string table. */
9067 if (dynamic_strings == NULL)
9068 {
86dba8ee
AM		 9069 for (entry = dynamic_section;
9070 entry < dynamic_section + dynamic_nent;
9071 ++entry)
252b5132
RH		 9072 {
9073 unsigned long offset;
b34976b6 9074 long str_tab_len;
252b5132
RH		 9075
9076 if (entry->d_tag != DT_STRTAB)
9077 continue;
9078
9079 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9080
9081 /* Since we do not know how big the string table is,
9082 we default to reading in the entire file (!) and
9083 processing that. This is overkill, I know, but it
e3c8793a 9084 should work. */
252b5132 9085
d93f0186 9086 offset = offset_from_vma (file, entry->d_un.d_val, 0);
fb52b2f4
NC		 9087
9088 if (archive_file_offset != 0)
9089 str_tab_len = archive_file_size - offset;
9090 else
9091 {
9092 if (fseek (file, 0, SEEK_END))
9093 error (_("Unable to seek to end of file\n"));
9094 str_tab_len = ftell (file) - offset;
9095 }
252b5132
RH		 9096
9097 if (str_tab_len < 1)
9098 {
9099 error
9100 (_("Unable to determine the length of the dynamic string table\n"));
9101 continue;
9102 }
9103
3f5e193b
NC		 9104 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
9105 str_tab_len,
9106 _("dynamic string table"));
59245841 9107 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
252b5132
RH		 9108 break;
9109 }
9110 }
9111
9112 /* And find the syminfo section if available. */
9113 if (dynamic_syminfo == NULL)
9114 {
3e8bba36 9115 unsigned long syminsz = 0;
252b5132 9116
86dba8ee
AM		 9117 for (entry = dynamic_section;
9118 entry < dynamic_section + dynamic_nent;
9119 ++entry)
252b5132
RH		 9120 {
9121 if (entry->d_tag == DT_SYMINENT)
9122 {
9123 /* Note: these braces are necessary to avoid a syntax
9124 error from the SunOS4 C compiler. */
049b0c3a
NC		 9125 /* PR binutils/17531: A corrupt file can trigger this test.
9126 So do not use an assert, instead generate an error message. */
9127 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
071436c6 9128 error (_("Bad value (%d) for SYMINENT entry\n"),
049b0c3a 9129 (int) entry->d_un.d_val);
252b5132
RH		 9130 }
9131 else if (entry->d_tag == DT_SYMINSZ)
9132 syminsz = entry->d_un.d_val;
9133 else if (entry->d_tag == DT_SYMINFO)
d93f0186
NC		 9134 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
9135 syminsz);
252b5132
RH		 9136 }
9137
9138 if (dynamic_syminfo_offset != 0 && syminsz != 0)
9139 {
2cf0635d
NC		 9140 Elf_External_Syminfo * extsyminfo;
9141 Elf_External_Syminfo * extsym;
9142 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 9143
9144 /* There is a syminfo section. Read the data. */
3f5e193b
NC		 9145 extsyminfo = (Elf_External_Syminfo *)
9146 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
9147 _("symbol information"));
a6e9f9df
AM		 9148 if (!extsyminfo)
9149 return 0;
252b5132 9150
3f5e193b 9151 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
252b5132
RH		 9152 if (dynamic_syminfo == NULL)
9153 {
8b73c356
NC		 9154 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9155 (unsigned long) syminsz);
252b5132
RH		 9156 return 0;
9157 }
9158
9159 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
86dba8ee
AM		 9160 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9161 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9162 ++syminfo, ++extsym)
252b5132 9163 {
86dba8ee
AM		 9164 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9165 syminfo->si_flags = BYTE_GET (extsym->si_flags);
252b5132
RH		 9166 }
9167
9168 free (extsyminfo);
9169 }
9170 }
9171
9172 if (do_dynamic && dynamic_addr)
8b73c356
NC		 9173 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9174 dynamic_addr, (unsigned long) dynamic_nent);
252b5132
RH		 9175 if (do_dynamic)
9176 printf (_(" Tag Type Name/Value\n"));
9177
86dba8ee
AM		 9178 for (entry = dynamic_section;
9179 entry < dynamic_section + dynamic_nent;
9180 entry++)
252b5132
RH		 9181 {
9182 if (do_dynamic)
f7a99963 9183 {
2cf0635d 9184 const char * dtype;
e699b9ff 9185
f7a99963
NC		 9186 putchar (' ');
9187 print_vma (entry->d_tag, FULL_HEX);
e699b9ff
ILT		 9188 dtype = get_dynamic_type (entry->d_tag);
9189 printf (" (%s)%*s", dtype,
9190 ((is_32bit_elf ? 27 : 19)
9191 - (int) strlen (dtype)),
f7a99963
NC		 9192 " ");
9193 }
252b5132
RH		 9194
9195 switch (entry->d_tag)
9196 {
d1133906
NC		 9197 case DT_FLAGS:
9198 if (do_dynamic)
e9e44622 9199 print_dynamic_flags (entry->d_un.d_val);
d1133906 9200 break;
76da6bbe 9201
252b5132
RH		 9202 case DT_AUXILIARY:
9203 case DT_FILTER:
019148e4
L		 9204 case DT_CONFIG:
9205 case DT_DEPAUDIT:
9206 case DT_AUDIT:
252b5132
RH		 9207 if (do_dynamic)
9208 {
019148e4 9209 switch (entry->d_tag)
b34976b6 9210 {
019148e4
L		 9211 case DT_AUXILIARY:
9212 printf (_("Auxiliary library"));
9213 break;
9214
9215 case DT_FILTER:
9216 printf (_("Filter library"));
9217 break;
9218
b34976b6 9219 case DT_CONFIG:
019148e4
L		 9220 printf (_("Configuration file"));
9221 break;
9222
9223 case DT_DEPAUDIT:
9224 printf (_("Dependency audit library"));
9225 break;
9226
9227 case DT_AUDIT:
9228 printf (_("Audit library"));
9229 break;
9230 }
252b5132 9231
d79b3d50
NC		 9232 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9233 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
252b5132 9234 else
f7a99963
NC		 9235 {
9236 printf (": ");
9237 print_vma (entry->d_un.d_val, PREFIX_HEX);
9238 putchar ('\n');
9239 }
252b5132
RH		 9240 }
9241 break;
9242
dcefbbbd 9243 case DT_FEATURE:
252b5132
RH		 9244 if (do_dynamic)
9245 {
9246 printf (_("Flags:"));
86f55779 9247
252b5132
RH		 9248 if (entry->d_un.d_val == 0)
9249 printf (_(" None\n"));
9250 else
9251 {
9252 unsigned long int val = entry->d_un.d_val;
86f55779 9253
252b5132
RH		 9254 if (val & DTF_1_PARINIT)
9255 {
9256 printf (" PARINIT");
9257 val ^= DTF_1_PARINIT;
9258 }
dcefbbbd
L		 9259 if (val & DTF_1_CONFEXP)
9260 {
9261 printf (" CONFEXP");
9262 val ^= DTF_1_CONFEXP;
9263 }
252b5132
RH		 9264 if (val != 0)
9265 printf (" %lx", val);
9266 puts ("");
9267 }
9268 }
9269 break;
9270
9271 case DT_POSFLAG_1:
9272 if (do_dynamic)
9273 {
9274 printf (_("Flags:"));
86f55779 9275
252b5132
RH		 9276 if (entry->d_un.d_val == 0)
9277 printf (_(" None\n"));
9278 else
9279 {
9280 unsigned long int val = entry->d_un.d_val;
86f55779 9281
252b5132
RH		 9282 if (val & DF_P1_LAZYLOAD)
9283 {
9284 printf (" LAZYLOAD");
9285 val ^= DF_P1_LAZYLOAD;
9286 }
9287 if (val & DF_P1_GROUPPERM)
9288 {
9289 printf (" GROUPPERM");
9290 val ^= DF_P1_GROUPPERM;
9291 }
9292 if (val != 0)
9293 printf (" %lx", val);
9294 puts ("");
9295 }
9296 }
9297 break;
9298
9299 case DT_FLAGS_1:
9300 if (do_dynamic)
9301 {
9302 printf (_("Flags:"));
9303 if (entry->d_un.d_val == 0)
9304 printf (_(" None\n"));
9305 else
9306 {
9307 unsigned long int val = entry->d_un.d_val;
86f55779 9308
252b5132
RH		 9309 if (val & DF_1_NOW)
9310 {
9311 printf (" NOW");
9312 val ^= DF_1_NOW;
9313 }
9314 if (val & DF_1_GLOBAL)
9315 {
9316 printf (" GLOBAL");
9317 val ^= DF_1_GLOBAL;
9318 }
9319 if (val & DF_1_GROUP)
9320 {
9321 printf (" GROUP");
9322 val ^= DF_1_GROUP;
9323 }
9324 if (val & DF_1_NODELETE)
9325 {
9326 printf (" NODELETE");
9327 val ^= DF_1_NODELETE;
9328 }
9329 if (val & DF_1_LOADFLTR)
9330 {
9331 printf (" LOADFLTR");
9332 val ^= DF_1_LOADFLTR;
9333 }
9334 if (val & DF_1_INITFIRST)
9335 {
9336 printf (" INITFIRST");
9337 val ^= DF_1_INITFIRST;
9338 }
9339 if (val & DF_1_NOOPEN)
9340 {
9341 printf (" NOOPEN");
9342 val ^= DF_1_NOOPEN;
9343 }
9344 if (val & DF_1_ORIGIN)
9345 {
9346 printf (" ORIGIN");
9347 val ^= DF_1_ORIGIN;
9348 }
9349 if (val & DF_1_DIRECT)
9350 {
9351 printf (" DIRECT");
9352 val ^= DF_1_DIRECT;
9353 }
9354 if (val & DF_1_TRANS)
9355 {
9356 printf (" TRANS");
9357 val ^= DF_1_TRANS;
9358 }
9359 if (val & DF_1_INTERPOSE)
9360 {
9361 printf (" INTERPOSE");
9362 val ^= DF_1_INTERPOSE;
9363 }
f7db6139 9364 if (val & DF_1_NODEFLIB)
dcefbbbd 9365 {
f7db6139
L		 9366 printf (" NODEFLIB");
9367 val ^= DF_1_NODEFLIB;
dcefbbbd
L		 9368 }
9369 if (val & DF_1_NODUMP)
9370 {
9371 printf (" NODUMP");
9372 val ^= DF_1_NODUMP;
9373 }
34b60028 9374 if (val & DF_1_CONFALT)
dcefbbbd 9375 {
34b60028
L		 9376 printf (" CONFALT");
9377 val ^= DF_1_CONFALT;
9378 }
9379 if (val & DF_1_ENDFILTEE)
9380 {
9381 printf (" ENDFILTEE");
9382 val ^= DF_1_ENDFILTEE;
9383 }
9384 if (val & DF_1_DISPRELDNE)
9385 {
9386 printf (" DISPRELDNE");
9387 val ^= DF_1_DISPRELDNE;
9388 }
9389 if (val & DF_1_DISPRELPND)
9390 {
9391 printf (" DISPRELPND");
9392 val ^= DF_1_DISPRELPND;
9393 }
9394 if (val & DF_1_NODIRECT)
9395 {
9396 printf (" NODIRECT");
9397 val ^= DF_1_NODIRECT;
9398 }
9399 if (val & DF_1_IGNMULDEF)
9400 {
9401 printf (" IGNMULDEF");
9402 val ^= DF_1_IGNMULDEF;
9403 }
9404 if (val & DF_1_NOKSYMS)
9405 {
9406 printf (" NOKSYMS");
9407 val ^= DF_1_NOKSYMS;
9408 }
9409 if (val & DF_1_NOHDR)
9410 {
9411 printf (" NOHDR");
9412 val ^= DF_1_NOHDR;
9413 }
9414 if (val & DF_1_EDITED)
9415 {
9416 printf (" EDITED");
9417 val ^= DF_1_EDITED;
9418 }
9419 if (val & DF_1_NORELOC)
9420 {
9421 printf (" NORELOC");
9422 val ^= DF_1_NORELOC;
9423 }
9424 if (val & DF_1_SYMINTPOSE)
9425 {
9426 printf (" SYMINTPOSE");
9427 val ^= DF_1_SYMINTPOSE;
9428 }
9429 if (val & DF_1_GLOBAUDIT)
9430 {
9431 printf (" GLOBAUDIT");
9432 val ^= DF_1_GLOBAUDIT;
9433 }
9434 if (val & DF_1_SINGLETON)
9435 {
9436 printf (" SINGLETON");
9437 val ^= DF_1_SINGLETON;
dcefbbbd 9438 }
5c383f02
RO		 9439 if (val & DF_1_STUB)
9440 {
9441 printf (" STUB");
9442 val ^= DF_1_STUB;
9443 }
9444 if (val & DF_1_PIE)
9445 {
9446 printf (" PIE");
9447 val ^= DF_1_PIE;
9448 }
252b5132
RH		 9449 if (val != 0)
9450 printf (" %lx", val);
9451 puts ("");
9452 }
9453 }
9454 break;
9455
9456 case DT_PLTREL:
566b0d53 9457 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9458 if (do_dynamic)
9459 puts (get_dynamic_type (entry->d_un.d_val));
9460 break;
9461
9462 case DT_NULL :
9463 case DT_NEEDED :
9464 case DT_PLTGOT :
9465 case DT_HASH :
9466 case DT_STRTAB :
9467 case DT_SYMTAB :
9468 case DT_RELA :
9469 case DT_INIT :
9470 case DT_FINI :
9471 case DT_SONAME :
9472 case DT_RPATH :
9473 case DT_SYMBOLIC:
9474 case DT_REL :
9475 case DT_DEBUG :
9476 case DT_TEXTREL :
9477 case DT_JMPREL :
019148e4 9478 case DT_RUNPATH :
252b5132
RH		 9479 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9480
9481 if (do_dynamic)
9482 {
2cf0635d 9483 char * name;
252b5132 9484
d79b3d50
NC		 9485 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9486 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9487 else
d79b3d50 9488 name = NULL;
252b5132
RH		 9489
9490 if (name)
9491 {
9492 switch (entry->d_tag)
9493 {
9494 case DT_NEEDED:
9495 printf (_("Shared library: [%s]"), name);
9496
18bd398b 9497 if (streq (name, program_interpreter))
f7a99963 9498 printf (_(" program interpreter"));
252b5132
RH		 9499 break;
9500
9501 case DT_SONAME:
f7a99963 9502 printf (_("Library soname: [%s]"), name);
252b5132
RH		 9503 break;
9504
9505 case DT_RPATH:
f7a99963 9506 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 9507 break;
9508
019148e4
L		 9509 case DT_RUNPATH:
9510 printf (_("Library runpath: [%s]"), name);
9511 break;
9512
252b5132 9513 default:
f7a99963
NC		 9514 print_vma (entry->d_un.d_val, PREFIX_HEX);
9515 break;
252b5132
RH		 9516 }
9517 }
9518 else
f7a99963
NC		 9519 print_vma (entry->d_un.d_val, PREFIX_HEX);
9520
9521 putchar ('\n');
252b5132
RH		 9522 }
9523 break;
9524
9525 case DT_PLTRELSZ:
9526 case DT_RELASZ :
9527 case DT_STRSZ :
9528 case DT_RELSZ :
9529 case DT_RELAENT :
9530 case DT_SYMENT :
9531 case DT_RELENT :
566b0d53 9532 dynamic_info[entry->d_tag] = entry->d_un.d_val;
252b5132
RH		 9533 case DT_PLTPADSZ:
9534 case DT_MOVEENT :
9535 case DT_MOVESZ :
9536 case DT_INIT_ARRAYSZ:
9537 case DT_FINI_ARRAYSZ:
047b2264
JJ		 9538 case DT_GNU_CONFLICTSZ:
9539 case DT_GNU_LIBLISTSZ:
252b5132 9540 if (do_dynamic)
f7a99963
NC		 9541 {
9542 print_vma (entry->d_un.d_val, UNSIGNED);
2b692964 9543 printf (_(" (bytes)\n"));
f7a99963 9544 }
252b5132
RH		 9545 break;
9546
9547 case DT_VERDEFNUM:
9548 case DT_VERNEEDNUM:
9549 case DT_RELACOUNT:
9550 case DT_RELCOUNT:
9551 if (do_dynamic)
f7a99963
NC		 9552 {
9553 print_vma (entry->d_un.d_val, UNSIGNED);
9554 putchar ('\n');
9555 }
252b5132
RH		 9556 break;
9557
9558 case DT_SYMINSZ:
9559 case DT_SYMINENT:
9560 case DT_SYMINFO:
9561 case DT_USED:
9562 case DT_INIT_ARRAY:
9563 case DT_FINI_ARRAY:
9564 if (do_dynamic)
9565 {
d79b3d50
NC		 9566 if (entry->d_tag == DT_USED
9567 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
252b5132 9568 {
2cf0635d 9569 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
252b5132 9570
b34976b6 9571 if (*name)
252b5132
RH		 9572 {
9573 printf (_("Not needed object: [%s]\n"), name);
9574 break;
9575 }
9576 }
103f02d3 9577
f7a99963
NC		 9578 print_vma (entry->d_un.d_val, PREFIX_HEX);
9579 putchar ('\n');
252b5132
RH		 9580 }
9581 break;
9582
9583 case DT_BIND_NOW:
9584 /* The value of this entry is ignored. */
35b1837e
AM		 9585 if (do_dynamic)
9586 putchar ('\n');
252b5132 9587 break;
103f02d3 9588
047b2264
JJ		 9589 case DT_GNU_PRELINKED:
9590 if (do_dynamic)
9591 {
2cf0635d 9592 struct tm * tmp;
91d6fa6a 9593 time_t atime = entry->d_un.d_val;
047b2264 9594
91d6fa6a 9595 tmp = gmtime (&atime);
071436c6
NC		 9596 /* PR 17533 file: 041-1244816-0.004. */
9597 if (tmp == NULL)
5a2cbcf4
L		 9598 printf (_("<corrupt time val: %lx"),
9599 (unsigned long) atime);
071436c6
NC		 9600 else
9601 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9602 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9603 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 9604
9605 }
9606 break;
9607
fdc90cb4
JJ		 9608 case DT_GNU_HASH:
9609 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9610 if (do_dynamic)
9611 {
9612 print_vma (entry->d_un.d_val, PREFIX_HEX);
9613 putchar ('\n');
9614 }
9615 break;
9616
252b5132
RH		 9617 default:
9618 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
b34976b6 9619 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
252b5132
RH		 9620 entry->d_un.d_val;
9621
9622 if (do_dynamic)
9623 {
9624 switch (elf_header.e_machine)
9625 {
9626 case EM_MIPS:
4fe85591 9627 case EM_MIPS_RS3_LE:
b2d38a17 9628 dynamic_section_mips_val (entry);
252b5132 9629 break;
103f02d3 9630 case EM_PARISC:
b2d38a17 9631 dynamic_section_parisc_val (entry);
103f02d3 9632 break;
ecc51f48 9633 case EM_IA_64:
b2d38a17 9634 dynamic_section_ia64_val (entry);
ecc51f48 9635 break;
252b5132 9636 default:
f7a99963
NC		 9637 print_vma (entry->d_un.d_val, PREFIX_HEX);
9638 putchar ('\n');
252b5132
RH		 9639 }
9640 }
9641 break;
9642 }
9643 }
9644
9645 return 1;
9646}
9647
9648static char *
d3ba0551 9649get_ver_flags (unsigned int flags)
252b5132 9650{
b34976b6 9651 static char buff[32];
252b5132
RH		 9652
9653 buff[0] = 0;
9654
9655 if (flags == 0)
9656 return _("none");
9657
9658 if (flags & VER_FLG_BASE)
9659 strcat (buff, "BASE ");
9660
9661 if (flags & VER_FLG_WEAK)
9662 {
9663 if (flags & VER_FLG_BASE)
9664 strcat (buff, "| ");
9665
9666 strcat (buff, "WEAK ");
9667 }
9668
44ec90b9
RO		 9669 if (flags & VER_FLG_INFO)
9670 {
9671 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9672 strcat (buff, "| ");
9673
9674 strcat (buff, "INFO ");
9675 }
9676
9677 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
2b692964 9678 strcat (buff, _("| <unknown>"));
252b5132
RH		 9679
9680 return buff;
9681}
9682
9683/* Display the contents of the version sections. */
98fb390a 9684
252b5132 9685static int
2cf0635d 9686process_version_sections (FILE * file)
252b5132 9687{
2cf0635d 9688 Elf_Internal_Shdr * section;
b34976b6
AM		 9689 unsigned i;
9690 int found = 0;
252b5132
RH		 9691
9692 if (! do_version)
9693 return 1;
9694
9695 for (i = 0, section = section_headers;
9696 i < elf_header.e_shnum;
b34976b6 9697 i++, section++)
252b5132
RH		 9698 {
9699 switch (section->sh_type)
9700 {
9701 case SHT_GNU_verdef:
9702 {
2cf0635d 9703 Elf_External_Verdef * edefs;
b34976b6
AM		 9704 unsigned int idx;
9705 unsigned int cnt;
2cf0635d 9706 char * endbuf;
252b5132
RH		 9707
9708 found = 1;
9709
74e1a04b
NC		 9710 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9711 printable_section_name (section),
9712 section->sh_info);
252b5132
RH		 9713
9714 printf (_(" Addr: 0x"));
9715 printf_vma (section->sh_addr);
74e1a04b 9716 printf (_(" Offset: %#08lx Link: %u (%s)"),
1b228002 9717 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9718 printable_section_name_from_index (section->sh_link));
252b5132 9719
3f5e193b
NC		 9720 edefs = (Elf_External_Verdef *)
9721 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9722 _("version definition section"));
a6e9f9df
AM		 9723 if (!edefs)
9724 break;
59245841 9725 endbuf = (char *) edefs + section->sh_size;
252b5132 9726
b34976b6 9727 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
252b5132 9728 {
2cf0635d
NC		 9729 char * vstart;
9730 Elf_External_Verdef * edef;
b34976b6 9731 Elf_Internal_Verdef ent;
2cf0635d 9732 Elf_External_Verdaux * eaux;
b34976b6
AM		 9733 Elf_Internal_Verdaux aux;
9734 int j;
9735 int isum;
103f02d3 9736
7e26601c
NC		 9737 /* Check for very large indicies. */
9738 if (idx > (size_t) (endbuf - (char *) edefs))
dd24e3da
NC		 9739 break;
9740
252b5132 9741 vstart = ((char *) edefs) + idx;
54806181
AM		 9742 if (vstart + sizeof (*edef) > endbuf)
9743 break;
252b5132
RH		 9744
9745 edef = (Elf_External_Verdef *) vstart;
9746
9747 ent.vd_version = BYTE_GET (edef->vd_version);
9748 ent.vd_flags = BYTE_GET (edef->vd_flags);
9749 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
9750 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
9751 ent.vd_hash = BYTE_GET (edef->vd_hash);
9752 ent.vd_aux = BYTE_GET (edef->vd_aux);
9753 ent.vd_next = BYTE_GET (edef->vd_next);
9754
9755 printf (_(" %#06x: Rev: %d Flags: %s"),
9756 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9757
9758 printf (_(" Index: %d Cnt: %d "),
9759 ent.vd_ndx, ent.vd_cnt);
9760
dd24e3da 9761 /* Check for overflow. */
7e26601c 9762 if (ent.vd_aux > (size_t) (endbuf - vstart))
dd24e3da
NC		 9763 break;
9764
252b5132
RH		 9765 vstart += ent.vd_aux;
9766
9767 eaux = (Elf_External_Verdaux *) vstart;
9768
9769 aux.vda_name = BYTE_GET (eaux->vda_name);
9770 aux.vda_next = BYTE_GET (eaux->vda_next);
9771
d79b3d50
NC		 9772 if (VALID_DYNAMIC_NAME (aux.vda_name))
9773 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9774 else
9775 printf (_("Name index: %ld\n"), aux.vda_name);
9776
9777 isum = idx + ent.vd_aux;
9778
b34976b6 9779 for (j = 1; j < ent.vd_cnt; j++)
252b5132 9780 {
dd24e3da 9781 /* Check for overflow. */
7e26601c 9782 if (aux.vda_next > (size_t) (endbuf - vstart))
dd24e3da
NC		 9783 break;
9784
252b5132
RH		 9785 isum += aux.vda_next;
9786 vstart += aux.vda_next;
9787
9788 eaux = (Elf_External_Verdaux *) vstart;
54806181
AM		 9789 if (vstart + sizeof (*eaux) > endbuf)
9790 break;
252b5132
RH		 9791
9792 aux.vda_name = BYTE_GET (eaux->vda_name);
9793 aux.vda_next = BYTE_GET (eaux->vda_next);
9794
d79b3d50 9795 if (VALID_DYNAMIC_NAME (aux.vda_name))
252b5132 9796 printf (_(" %#06x: Parent %d: %s\n"),
d79b3d50 9797 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
252b5132
RH		 9798 else
9799 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9800 isum, j, aux.vda_name);
9801 }
dd24e3da 9802
54806181
AM		 9803 if (j < ent.vd_cnt)
9804 printf (_(" Version def aux past end of section\n"));
252b5132 9805
5d921cbd
NC		 9806 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9807 if (idx + ent.vd_next <= idx)
9808 break;
9809
252b5132
RH		 9810 idx += ent.vd_next;
9811 }
dd24e3da 9812
54806181
AM		 9813 if (cnt < section->sh_info)
9814 printf (_(" Version definition past end of section\n"));
252b5132
RH		 9815
9816 free (edefs);
9817 }
9818 break;
103f02d3 9819
252b5132
RH		 9820 case SHT_GNU_verneed:
9821 {
2cf0635d 9822 Elf_External_Verneed * eneed;
b34976b6
AM		 9823 unsigned int idx;
9824 unsigned int cnt;
2cf0635d 9825 char * endbuf;
252b5132
RH		 9826
9827 found = 1;
9828
72de5009 9829 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
74e1a04b 9830 printable_section_name (section), section->sh_info);
252b5132
RH		 9831
9832 printf (_(" Addr: 0x"));
9833 printf_vma (section->sh_addr);
72de5009 9834 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9835 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9836 printable_section_name_from_index (section->sh_link));
252b5132 9837
3f5e193b
NC		 9838 eneed = (Elf_External_Verneed *) get_data (NULL, file,
9839 section->sh_offset, 1,
9840 section->sh_size,
9cf03b7e 9841 _("Version Needs section"));
a6e9f9df
AM		 9842 if (!eneed)
9843 break;
59245841 9844 endbuf = (char *) eneed + section->sh_size;
252b5132
RH		 9845
9846 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9847 {
2cf0635d 9848 Elf_External_Verneed * entry;
b34976b6
AM		 9849 Elf_Internal_Verneed ent;
9850 int j;
9851 int isum;
2cf0635d 9852 char * vstart;
252b5132 9853
7e26601c 9854 if (idx > (size_t) (endbuf - (char *) eneed))
dd24e3da
NC		 9855 break;
9856
252b5132 9857 vstart = ((char *) eneed) + idx;
54806181
AM		 9858 if (vstart + sizeof (*entry) > endbuf)
9859 break;
252b5132
RH		 9860
9861 entry = (Elf_External_Verneed *) vstart;
9862
9863 ent.vn_version = BYTE_GET (entry->vn_version);
9864 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
9865 ent.vn_file = BYTE_GET (entry->vn_file);
9866 ent.vn_aux = BYTE_GET (entry->vn_aux);
9867 ent.vn_next = BYTE_GET (entry->vn_next);
9868
9869 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
9870
d79b3d50
NC		 9871 if (VALID_DYNAMIC_NAME (ent.vn_file))
9872 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
252b5132
RH		 9873 else
9874 printf (_(" File: %lx"), ent.vn_file);
9875
9876 printf (_(" Cnt: %d\n"), ent.vn_cnt);
9877
dd24e3da 9878 /* Check for overflow. */
7e26601c 9879 if (ent.vn_aux > (size_t) (endbuf - vstart))
dd24e3da 9880 break;
252b5132
RH		 9881 vstart += ent.vn_aux;
9882
9883 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9884 {
2cf0635d 9885 Elf_External_Vernaux * eaux;
b34976b6 9886 Elf_Internal_Vernaux aux;
252b5132 9887
54806181
AM		 9888 if (vstart + sizeof (*eaux) > endbuf)
9889 break;
252b5132
RH		 9890 eaux = (Elf_External_Vernaux *) vstart;
9891
9892 aux.vna_hash = BYTE_GET (eaux->vna_hash);
9893 aux.vna_flags = BYTE_GET (eaux->vna_flags);
9894 aux.vna_other = BYTE_GET (eaux->vna_other);
9895 aux.vna_name = BYTE_GET (eaux->vna_name);
9896 aux.vna_next = BYTE_GET (eaux->vna_next);
9897
d79b3d50 9898 if (VALID_DYNAMIC_NAME (aux.vna_name))
ecc2063b 9899 printf (_(" %#06x: Name: %s"),
d79b3d50 9900 isum, GET_DYNAMIC_NAME (aux.vna_name));
252b5132 9901 else
ecc2063b 9902 printf (_(" %#06x: Name index: %lx"),
252b5132
RH		 9903 isum, aux.vna_name);
9904
9905 printf (_(" Flags: %s Version: %d\n"),
9906 get_ver_flags (aux.vna_flags), aux.vna_other);
9907
dd24e3da 9908 /* Check for overflow. */
53774b7e
NC		 9909 if (aux.vna_next > (size_t) (endbuf - vstart)
9910 || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
9911 {
9912 warn (_("Invalid vna_next field of %lx\n"),
9913 aux.vna_next);
9914 j = ent.vn_cnt;
9915 break;
9916 }
252b5132
RH		 9917 isum += aux.vna_next;
9918 vstart += aux.vna_next;
9919 }
9cf03b7e 9920
54806181 9921 if (j < ent.vn_cnt)
9cf03b7e 9922 warn (_("Missing Version Needs auxillary information\n"));
252b5132 9923
bcf83b2a 9924 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
c24cf8b6
NC		 9925 {
9926 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9927 cnt = section->sh_info;
9928 break;
9929 }
252b5132
RH		 9930 idx += ent.vn_next;
9931 }
9cf03b7e 9932
54806181 9933 if (cnt < section->sh_info)
9cf03b7e 9934 warn (_("Missing Version Needs information\n"));
103f02d3 9935
252b5132
RH		 9936 free (eneed);
9937 }
9938 break;
9939
9940 case SHT_GNU_versym:
9941 {
2cf0635d 9942 Elf_Internal_Shdr * link_section;
8b73c356
NC		 9943 size_t total;
9944 unsigned int cnt;
2cf0635d
NC		 9945 unsigned char * edata;
9946 unsigned short * data;
9947 char * strtab;
9948 Elf_Internal_Sym * symbols;
9949 Elf_Internal_Shdr * string_sec;
ba5cdace 9950 unsigned long num_syms;
d3ba0551 9951 long off;
252b5132 9952
4fbb74a6 9953 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9954 break;
9955
4fbb74a6 9956 link_section = section_headers + section->sh_link;
08d8fa11 9957 total = section->sh_size / sizeof (Elf_External_Versym);
252b5132 9958
4fbb74a6 9959 if (link_section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 9960 break;
9961
252b5132
RH		 9962 found = 1;
9963
ba5cdace 9964 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
dd24e3da
NC		 9965 if (symbols == NULL)
9966 break;
252b5132 9967
4fbb74a6 9968 string_sec = section_headers + link_section->sh_link;
252b5132 9969
3f5e193b
NC		 9970 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9971 string_sec->sh_size,
9972 _("version string table"));
a6e9f9df 9973 if (!strtab)
0429c154
MS		 9974 {
9975 free (symbols);
9976 break;
9977 }
252b5132 9978
8b73c356
NC		 9979 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9980 printable_section_name (section), (unsigned long) total);
252b5132
RH		 9981
9982 printf (_(" Addr: "));
9983 printf_vma (section->sh_addr);
72de5009 9984 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
1b228002 9985 (unsigned long) section->sh_offset, section->sh_link,
74e1a04b 9986 printable_section_name (link_section));
252b5132 9987
d3ba0551
AM		 9988 off = offset_from_vma (file,
9989 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9990 total * sizeof (short));
3f5e193b
NC		 9991 edata = (unsigned char *) get_data (NULL, file, off, total,
9992 sizeof (short),
9993 _("version symbol data"));
a6e9f9df
AM		 9994 if (!edata)
9995 {
9996 free (strtab);
0429c154 9997 free (symbols);
a6e9f9df
AM		 9998 break;
9999 }
252b5132 10000
3f5e193b 10001 data = (short unsigned int *) cmalloc (total, sizeof (short));
252b5132
RH		 10002
10003 for (cnt = total; cnt --;)
b34976b6
AM		 10004 data[cnt] = byte_get (edata + cnt * sizeof (short),
10005 sizeof (short));
252b5132
RH		 10006
10007 free (edata);
10008
10009 for (cnt = 0; cnt < total; cnt += 4)
10010 {
10011 int j, nn;
ab273396
AM		 10012 char *name;
10013 char *invalid = _("*invalid*");
252b5132
RH		 10014
10015 printf (" %03x:", cnt);
10016
10017 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
b34976b6 10018 switch (data[cnt + j])
252b5132
RH		 10019 {
10020 case 0:
10021 fputs (_(" 0 (*local*) "), stdout);
10022 break;
10023
10024 case 1:
10025 fputs (_(" 1 (*global*) "), stdout);
10026 break;
10027
10028 default:
c244d050
NC		 10029 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10030 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
252b5132 10031
dd24e3da 10032 /* If this index value is greater than the size of the symbols
ba5cdace
NC		 10033 array, break to avoid an out-of-bounds read. */
10034 if ((unsigned long)(cnt + j) >= num_syms)
dd24e3da
NC		 10035 {
10036 warn (_("invalid index into symbol array\n"));
10037 break;
10038 }
10039
ab273396
AM		 10040 name = NULL;
10041 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
252b5132 10042 {
b34976b6
AM		 10043 Elf_Internal_Verneed ivn;
10044 unsigned long offset;
252b5132 10045
d93f0186
NC		 10046 offset = offset_from_vma
10047 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10048 sizeof (Elf_External_Verneed));
252b5132 10049
b34976b6 10050 do
252b5132 10051 {
b34976b6
AM		 10052 Elf_Internal_Vernaux ivna;
10053 Elf_External_Verneed evn;
10054 Elf_External_Vernaux evna;
10055 unsigned long a_off;
252b5132 10056
59245841
NC		 10057 if (get_data (&evn, file, offset, sizeof (evn), 1,
10058 _("version need")) == NULL)
10059 break;
0b4362b0 10060
252b5132
RH		 10061 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10062 ivn.vn_next = BYTE_GET (evn.vn_next);
10063
10064 a_off = offset + ivn.vn_aux;
10065
10066 do
10067 {
59245841
NC		 10068 if (get_data (&evna, file, a_off, sizeof (evna),
10069 1, _("version need aux (2)")) == NULL)
10070 {
10071 ivna.vna_next = 0;
10072 ivna.vna_other = 0;
10073 }
10074 else
10075 {
10076 ivna.vna_next = BYTE_GET (evna.vna_next);
10077 ivna.vna_other = BYTE_GET (evna.vna_other);
10078 }
252b5132
RH		 10079
10080 a_off += ivna.vna_next;
10081 }
b34976b6 10082 while (ivna.vna_other != data[cnt + j]
252b5132
RH		 10083 && ivna.vna_next != 0);
10084
b34976b6 10085 if (ivna.vna_other == data[cnt + j])
252b5132
RH		 10086 {
10087 ivna.vna_name = BYTE_GET (evna.vna_name);
10088
54806181 10089 if (ivna.vna_name >= string_sec->sh_size)
ab273396 10090 name = invalid;
54806181
AM		 10091 else
10092 name = strtab + ivna.vna_name;
252b5132
RH		 10093 break;
10094 }
10095
10096 offset += ivn.vn_next;
10097 }
10098 while (ivn.vn_next);
10099 }
00d93f34 10100
ab273396 10101 if (data[cnt + j] != 0x8001
b34976b6 10102 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
252b5132 10103 {
b34976b6
AM		 10104 Elf_Internal_Verdef ivd;
10105 Elf_External_Verdef evd;
10106 unsigned long offset;
252b5132 10107
d93f0186
NC		 10108 offset = offset_from_vma
10109 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10110 sizeof evd);
252b5132
RH		 10111
10112 do
10113 {
59245841
NC		 10114 if (get_data (&evd, file, offset, sizeof (evd), 1,
10115 _("version def")) == NULL)
10116 {
10117 ivd.vd_next = 0;
948f632f 10118 /* PR 17531: file: 046-1082287-0.004. */
3102e897
NC		 10119 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
10120 break;
59245841
NC		 10121 }
10122 else
10123 {
10124 ivd.vd_next = BYTE_GET (evd.vd_next);
10125 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10126 }
252b5132
RH		 10127
10128 offset += ivd.vd_next;
10129 }
c244d050 10130 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
252b5132
RH		 10131 && ivd.vd_next != 0);
10132
c244d050 10133 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
252b5132 10134 {
b34976b6
AM		 10135 Elf_External_Verdaux evda;
10136 Elf_Internal_Verdaux ivda;
252b5132
RH		 10137
10138 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10139
59245841
NC		 10140 if (get_data (&evda, file,
10141 offset - ivd.vd_next + ivd.vd_aux,
10142 sizeof (evda), 1,
10143 _("version def aux")) == NULL)
10144 break;
252b5132
RH		 10145
10146 ivda.vda_name = BYTE_GET (evda.vda_name);
10147
54806181 10148 if (ivda.vda_name >= string_sec->sh_size)
ab273396
AM		 10149 name = invalid;
10150 else if (name != NULL && name != invalid)
10151 name = _("*both*");
54806181
AM		 10152 else
10153 name = strtab + ivda.vda_name;
252b5132
RH		 10154 }
10155 }
ab273396
AM		 10156 if (name != NULL)
10157 nn += printf ("(%s%-*s",
10158 name,
10159 12 - (int) strlen (name),
10160 ")");
252b5132
RH		 10161
10162 if (nn < 18)
10163 printf ("%*c", 18 - nn, ' ');
10164 }
10165
10166 putchar ('\n');
10167 }
10168
10169 free (data);
10170 free (strtab);
10171 free (symbols);
10172 }
10173 break;
103f02d3 10174
252b5132
RH		 10175 default:
10176 break;
10177 }
10178 }
10179
10180 if (! found)
10181 printf (_("\nNo version information found in this file.\n"));
10182
10183 return 1;
10184}
10185
d1133906 10186static const char *
d3ba0551 10187get_symbol_binding (unsigned int binding)
252b5132 10188{
b34976b6 10189 static char buff[32];
252b5132
RH		 10190
10191 switch (binding)
10192 {
b34976b6
AM		 10193 case STB_LOCAL: return "LOCAL";
10194 case STB_GLOBAL: return "GLOBAL";
10195 case STB_WEAK: return "WEAK";
252b5132
RH		 10196 default:
10197 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
e9e44622
JJ		 10198 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10199 binding);
252b5132 10200 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3e7a7d11
NC		 10201 {
10202 if (binding == STB_GNU_UNIQUE
9c55345c
TS		 10203 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10204 /* GNU is still using the default value 0. */
3e7a7d11
NC		 10205 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10206 return "UNIQUE";
10207 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10208 }
252b5132 10209 else
e9e44622 10210 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
252b5132
RH		 10211 return buff;
10212 }
10213}
10214
d1133906 10215static const char *
d3ba0551 10216get_symbol_type (unsigned int type)
252b5132 10217{
b34976b6 10218 static char buff[32];
252b5132
RH		 10219
10220 switch (type)
10221 {
b34976b6
AM		 10222 case STT_NOTYPE: return "NOTYPE";
10223 case STT_OBJECT: return "OBJECT";
10224 case STT_FUNC: return "FUNC";
10225 case STT_SECTION: return "SECTION";
10226 case STT_FILE: return "FILE";
10227 case STT_COMMON: return "COMMON";
10228 case STT_TLS: return "TLS";
15ab5209
DB		 10229 case STT_RELC: return "RELC";
10230 case STT_SRELC: return "SRELC";
252b5132
RH		 10231 default:
10232 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af 10233 {
3510a7b8
NC		 10234 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10235 return "THUMB_FUNC";
103f02d3 10236
351b4b40 10237 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 10238 return "REGISTER";
10239
10240 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10241 return "PARISC_MILLI";
10242
e9e44622 10243 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
df75f1af 10244 }
252b5132 10245 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 10246 {
10247 if (elf_header.e_machine == EM_PARISC)
10248 {
10249 if (type == STT_HP_OPAQUE)
10250 return "HP_OPAQUE";
10251 if (type == STT_HP_STUB)
10252 return "HP_STUB";
10253 }
10254
d8045f23 10255 if (type == STT_GNU_IFUNC
9c55345c 10256 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
83c257ca 10257 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9c55345c 10258 /* GNU is still using the default value 0. */
d8045f23
NC		 10259 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10260 return "IFUNC";
10261
e9e44622 10262 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
103f02d3 10263 }
252b5132 10264 else
e9e44622 10265 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
252b5132
RH		 10266 return buff;
10267 }
10268}
10269
d1133906 10270static const char *
d3ba0551 10271get_symbol_visibility (unsigned int visibility)
d1133906
NC		 10272{
10273 switch (visibility)
10274 {
b34976b6
AM		 10275 case STV_DEFAULT: return "DEFAULT";
10276 case STV_INTERNAL: return "INTERNAL";
10277 case STV_HIDDEN: return "HIDDEN";
d1133906 10278 case STV_PROTECTED: return "PROTECTED";
bee0ee85
NC		 10279 default:
10280 error (_("Unrecognized visibility value: %u"), visibility);
10281 return _("<unknown>");
d1133906
NC		 10282 }
10283}
10284
fd85a6a1
NC		 10285static const char *
10286get_solaris_symbol_visibility (unsigned int visibility)
10287{
10288 switch (visibility)
10289 {
10290 case 4: return "EXPORTED";
10291 case 5: return "SINGLETON";
10292 case 6: return "ELIMINATE";
10293 default: return get_symbol_visibility (visibility);
10294 }
10295}
10296
5e2b0d47
NC		 10297static const char *
10298get_mips_symbol_other (unsigned int other)
10299{
10300 switch (other)
10301 {
df58fc94
RS		 10302 case STO_OPTIONAL:
10303 return "OPTIONAL";
10304 case STO_MIPS_PLT:
10305 return "MIPS PLT";
10306 case STO_MIPS_PIC:
10307 return "MIPS PIC";
10308 case STO_MICROMIPS:
10309 return "MICROMIPS";
10310 case STO_MICROMIPS | STO_MIPS_PIC:
10311 return "MICROMIPS, MIPS PIC";
10312 case STO_MIPS16:
10313 return "MIPS16";
10314 default:
10315 return NULL;
5e2b0d47
NC		 10316 }
10317}
10318
28f997cf
TG		 10319static const char *
10320get_ia64_symbol_other (unsigned int other)
10321{
10322 if (is_ia64_vms ())
10323 {
10324 static char res[32];
10325
10326 res[0] = 0;
10327
10328 /* Function types is for images and .STB files only. */
10329 switch (elf_header.e_type)
10330 {
10331 case ET_DYN:
10332 case ET_EXEC:
10333 switch (VMS_ST_FUNC_TYPE (other))
10334 {
10335 case VMS_SFT_CODE_ADDR:
10336 strcat (res, " CA");
10337 break;
10338 case VMS_SFT_SYMV_IDX:
10339 strcat (res, " VEC");
10340 break;
10341 case VMS_SFT_FD:
10342 strcat (res, " FD");
10343 break;
10344 case VMS_SFT_RESERVE:
10345 strcat (res, " RSV");
10346 break;
10347 default:
bee0ee85
NC		 10348 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10349 VMS_ST_FUNC_TYPE (other));
10350 strcat (res, " <unknown>");
10351 break;
28f997cf
TG		 10352 }
10353 break;
10354 default:
10355 break;
10356 }
10357 switch (VMS_ST_LINKAGE (other))
10358 {
10359 case VMS_STL_IGNORE:
10360 strcat (res, " IGN");
10361 break;
10362 case VMS_STL_RESERVE:
10363 strcat (res, " RSV");
10364 break;
10365 case VMS_STL_STD:
10366 strcat (res, " STD");
10367 break;
10368 case VMS_STL_LNK:
10369 strcat (res, " LNK");
10370 break;
10371 default:
bee0ee85
NC		 10372 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10373 VMS_ST_LINKAGE (other));
10374 strcat (res, " <unknown>");
10375 break;
28f997cf
TG		 10376 }
10377
10378 if (res[0] != 0)
10379 return res + 1;
10380 else
10381 return res;
10382 }
10383 return NULL;
10384}
10385
6911b7dc
AM		 10386static const char *
10387get_ppc64_symbol_other (unsigned int other)
10388{
10389 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10390 {
10391 static char buf[32];
10392 snprintf (buf, sizeof buf, _("<localentry>: %d"),
10393 PPC64_LOCAL_ENTRY_OFFSET (other));
10394 return buf;
10395 }
10396 return NULL;
10397}
10398
5e2b0d47
NC		 10399static const char *
10400get_symbol_other (unsigned int other)
10401{
10402 const char * result = NULL;
10403 static char buff [32];
10404
10405 if (other == 0)
10406 return "";
10407
10408 switch (elf_header.e_machine)
10409 {
10410 case EM_MIPS:
10411 result = get_mips_symbol_other (other);
28f997cf
TG		 10412 break;
10413 case EM_IA_64:
10414 result = get_ia64_symbol_other (other);
10415 break;
6911b7dc
AM		 10416 case EM_PPC64:
10417 result = get_ppc64_symbol_other (other);
10418 break;
5e2b0d47 10419 default:
fd85a6a1 10420 result = NULL;
5e2b0d47
NC		 10421 break;
10422 }
10423
10424 if (result)
10425 return result;
10426
10427 snprintf (buff, sizeof buff, _("<other>: %x"), other);
10428 return buff;
10429}
10430
d1133906 10431static const char *
d3ba0551 10432get_symbol_index_type (unsigned int type)
252b5132 10433{
b34976b6 10434 static char buff[32];
5cf1065c 10435
252b5132
RH		 10436 switch (type)
10437 {
b34976b6
AM		 10438 case SHN_UNDEF: return "UND";
10439 case SHN_ABS: return "ABS";
10440 case SHN_COMMON: return "COM";
252b5132 10441 default:
9ce701e2
L		 10442 if (type == SHN_IA_64_ANSI_COMMON
10443 && elf_header.e_machine == EM_IA_64
10444 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10445 return "ANSI_COM";
8a9036a4 10446 else if ((elf_header.e_machine == EM_X86_64
7a9068fe
L		 10447 || elf_header.e_machine == EM_L1OM
10448 || elf_header.e_machine == EM_K1OM)
3b22753a
L		 10449 && type == SHN_X86_64_LCOMMON)
10450 return "LARGE_COM";
ac145307
BS		 10451 else if ((type == SHN_MIPS_SCOMMON
10452 && elf_header.e_machine == EM_MIPS)
10453 || (type == SHN_TIC6X_SCOMMON
10454 && elf_header.e_machine == EM_TI_C6000))
172553c7
TS		 10455 return "SCOM";
10456 else if (type == SHN_MIPS_SUNDEFINED
10457 && elf_header.e_machine == EM_MIPS)
10458 return "SUND";
9ce701e2 10459 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4fbb74a6 10460 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
252b5132 10461 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4fbb74a6
AM		 10462 sprintf (buff, "OS [0x%04x]", type & 0xffff);
10463 else if (type >= SHN_LORESERVE)
10464 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
c6d8cab4 10465 else if (type >= elf_header.e_shnum)
e0a31db1 10466 sprintf (buff, _("bad section index[%3d]"), type);
252b5132 10467 else
232e7cb8 10468 sprintf (buff, "%3d", type);
5cf1065c 10469 break;
252b5132 10470 }
5cf1065c
NC		 10471
10472 return buff;
252b5132
RH		 10473}
10474
66543521 10475static bfd_vma *
57028622 10476get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
252b5132 10477{
2cf0635d
NC		 10478 unsigned char * e_data;
10479 bfd_vma * i_data;
252b5132 10480
57028622
NC		 10481 /* If the size_t type is smaller than the bfd_size_type, eg because
10482 you are building a 32-bit tool on a 64-bit host, then make sure
10483 that when (number) is cast to (size_t) no information is lost. */
10484 if (sizeof (size_t) < sizeof (bfd_size_type)
10485 && (bfd_size_type) ((size_t) number) != number)
10486 {
ed754a13
AM		 10487 error (_("Size truncation prevents reading %" BFD_VMA_FMT "u"
10488 " elements of size %u\n"),
10489 number, ent_size);
57028622
NC		 10490 return NULL;
10491 }
948f632f 10492
3102e897
NC		 10493 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10494 attempting to allocate memory when the read is bound to fail. */
10495 if (ent_size * number > current_file_size)
10496 {
ed754a13
AM		 10497 error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT "u\n"),
10498 number);
3102e897
NC		 10499 return NULL;
10500 }
10501
57028622 10502 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
252b5132
RH		 10503 if (e_data == NULL)
10504 {
ed754a13
AM		 10505 error (_("Out of memory reading %" BFD_VMA_FMT "u dynamic entries\n"),
10506 number);
252b5132
RH		 10507 return NULL;
10508 }
10509
57028622 10510 if (fread (e_data, ent_size, (size_t) number, file) != number)
252b5132 10511 {
ed754a13
AM		 10512 error (_("Unable to read in %" BFD_VMA_FMT "u bytes of dynamic data\n"),
10513 number * ent_size);
3102e897 10514 free (e_data);
252b5132
RH		 10515 return NULL;
10516 }
10517
57028622 10518 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
252b5132
RH		 10519 if (i_data == NULL)
10520 {
ed754a13
AM		 10521 error (_("Out of memory allocating space for %" BFD_VMA_FMT "u"
10522 " dynamic entries\n"),
10523 number);
252b5132
RH		 10524 free (e_data);
10525 return NULL;
10526 }
10527
10528 while (number--)
66543521 10529 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
252b5132
RH		 10530
10531 free (e_data);
10532
10533 return i_data;
10534}
10535
6bd1a22c
L		 10536static void
10537print_dynamic_symbol (bfd_vma si, unsigned long hn)
10538{
2cf0635d 10539 Elf_Internal_Sym * psym;
6bd1a22c
L		 10540 int n;
10541
6bd1a22c
L		 10542 n = print_vma (si, DEC_5);
10543 if (n < 5)
0b4362b0 10544 fputs (&" "[n], stdout);
6bd1a22c 10545 printf (" %3lu: ", hn);
e0a31db1
NC		 10546
10547 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10548 {
3102e897
NC		 10549 printf (_("<No info available for dynamic symbol number %lu>\n"),
10550 (unsigned long) si);
e0a31db1
NC		 10551 return;
10552 }
10553
10554 psym = dynamic_symbols + si;
6bd1a22c
L		 10555 print_vma (psym->st_value, LONG_HEX);
10556 putchar (' ');
10557 print_vma (psym->st_size, DEC_5);
10558
f4be36b3
AM		 10559 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10560 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
fd85a6a1
NC		 10561
10562 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
10563 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
10564 else
10565 {
10566 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
10567
10568 printf (" %-7s", get_symbol_visibility (vis));
10569 /* Check to see if any other bits in the st_other field are set.
10570 Note - displaying this information disrupts the layout of the
10571 table being generated, but for the moment this case is very
10572 rare. */
10573 if (psym->st_other ^ vis)
10574 printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
10575 }
10576
6bd1a22c
L		 10577 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10578 if (VALID_DYNAMIC_NAME (psym->st_name))
10579 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10580 else
2b692964 10581 printf (_(" <corrupt: %14ld>"), psym->st_name);
6bd1a22c
L		 10582 putchar ('\n');
10583}
10584
bb4d2ac2
L		 10585static const char *
10586get_symbol_version_string (FILE *file, int is_dynsym,
10587 const char *strtab,
10588 unsigned long int strtab_size,
10589 unsigned int si, Elf_Internal_Sym *psym,
10590 enum versioned_symbol_info *sym_info,
10591 unsigned short *vna_other)
10592{
ab273396
AM		 10593 unsigned char data[2];
10594 unsigned short vers_data;
10595 unsigned long offset;
bb4d2ac2 10596
ab273396
AM		 10597 if (!is_dynsym
10598 || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
10599 return NULL;
bb4d2ac2 10600
ab273396
AM		 10601 offset = offset_from_vma (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10602 sizeof data + si * sizeof (vers_data));
bb4d2ac2 10603
ab273396
AM		 10604 if (get_data (&data, file, offset + si * sizeof (vers_data),
10605 sizeof (data), 1, _("version data")) == NULL)
10606 return NULL;
10607
10608 vers_data = byte_get (data, 2);
bb4d2ac2 10609
ab273396
AM		 10610 if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
10611 return NULL;
bb4d2ac2 10612
ab273396
AM		 10613 /* Usually we'd only see verdef for defined symbols, and verneed for
10614 undefined symbols. However, symbols defined by the linker in
10615 .dynbss for variables copied from a shared library in order to
10616 avoid text relocations are defined yet have verneed. We could
10617 use a heuristic to detect the special case, for example, check
10618 for verneed first on symbols defined in SHT_NOBITS sections, but
10619 it is simpler and more reliable to just look for both verdef and
10620 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
bb4d2ac2 10621
ab273396
AM		 10622 if (psym->st_shndx != SHN_UNDEF
10623 && vers_data != 0x8001
10624 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10625 {
10626 Elf_Internal_Verdef ivd;
10627 Elf_Internal_Verdaux ivda;
10628 Elf_External_Verdaux evda;
10629 unsigned long off;
bb4d2ac2 10630
ab273396
AM		 10631 off = offset_from_vma (file,
10632 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10633 sizeof (Elf_External_Verdef));
10634
10635 do
bb4d2ac2 10636 {
ab273396
AM		 10637 Elf_External_Verdef evd;
10638
10639 if (get_data (&evd, file, off, sizeof (evd), 1,
10640 _("version def")) == NULL)
10641 {
10642 ivd.vd_ndx = 0;
10643 ivd.vd_aux = 0;
10644 ivd.vd_next = 0;
10645 }
10646 else
bb4d2ac2 10647 {
ab273396
AM		 10648 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10649 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10650 ivd.vd_next = BYTE_GET (evd.vd_next);
10651 }
bb4d2ac2 10652
ab273396
AM		 10653 off += ivd.vd_next;
10654 }
10655 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
bb4d2ac2 10656
ab273396
AM		 10657 if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
10658 {
10659 off -= ivd.vd_next;
10660 off += ivd.vd_aux;
bb4d2ac2 10661
ab273396
AM		 10662 if (get_data (&evda, file, off, sizeof (evda), 1,
10663 _("version def aux")) != NULL)
10664 {
10665 ivda.vda_name = BYTE_GET (evda.vda_name);
bb4d2ac2 10666
ab273396
AM		 10667 if (psym->st_name != ivda.vda_name)
10668 {
10669 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10670 ? symbol_hidden : symbol_public);
10671 return (ivda.vda_name < strtab_size
10672 ? strtab + ivda.vda_name : _("<corrupt>"));
10673 }
10674 }
10675 }
10676 }
bb4d2ac2 10677
ab273396
AM		 10678 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10679 {
10680 Elf_External_Verneed evn;
10681 Elf_Internal_Verneed ivn;
10682 Elf_Internal_Vernaux ivna;
bb4d2ac2 10683
ab273396
AM		 10684 offset = offset_from_vma (file,
10685 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10686 sizeof evn);
10687 do
10688 {
10689 unsigned long vna_off;
bb4d2ac2 10690
ab273396
AM		 10691 if (get_data (&evn, file, offset, sizeof (evn), 1,
10692 _("version need")) == NULL)
10693 {
10694 ivna.vna_next = 0;
10695 ivna.vna_other = 0;
10696 ivna.vna_name = 0;
10697 break;
10698 }
bb4d2ac2 10699
ab273396
AM		 10700 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10701 ivn.vn_next = BYTE_GET (evn.vn_next);
bb4d2ac2 10702
ab273396 10703 vna_off = offset + ivn.vn_aux;
bb4d2ac2 10704
ab273396
AM		 10705 do
10706 {
10707 Elf_External_Vernaux evna;
bb4d2ac2 10708
ab273396
AM		 10709 if (get_data (&evna, file, vna_off, sizeof (evna), 1,
10710 _("version need aux (3)")) == NULL)
bb4d2ac2 10711 {
ab273396
AM		 10712 ivna.vna_next = 0;
10713 ivna.vna_other = 0;
10714 ivna.vna_name = 0;
bb4d2ac2 10715 }
bb4d2ac2 10716 else
bb4d2ac2 10717 {
ab273396
AM		 10718 ivna.vna_other = BYTE_GET (evna.vna_other);
10719 ivna.vna_next = BYTE_GET (evna.vna_next);
10720 ivna.vna_name = BYTE_GET (evna.vna_name);
10721 }
bb4d2ac2 10722
ab273396
AM		 10723 vna_off += ivna.vna_next;
10724 }
10725 while (ivna.vna_other != vers_data && ivna.vna_next != 0);
bb4d2ac2 10726
ab273396
AM		 10727 if (ivna.vna_other == vers_data)
10728 break;
bb4d2ac2 10729
ab273396
AM		 10730 offset += ivn.vn_next;
10731 }
10732 while (ivn.vn_next != 0);
bb4d2ac2 10733
ab273396
AM		 10734 if (ivna.vna_other == vers_data)
10735 {
10736 *sym_info = symbol_undefined;
10737 *vna_other = ivna.vna_other;
10738 return (ivna.vna_name < strtab_size
10739 ? strtab + ivna.vna_name : _("<corrupt>"));
bb4d2ac2
L		 10740 }
10741 }
ab273396 10742 return NULL;
bb4d2ac2
L		 10743}
10744
e3c8793a 10745/* Dump the symbol table. */
252b5132 10746static int
2cf0635d 10747process_symbol_table (FILE * file)
252b5132 10748{
2cf0635d 10749 Elf_Internal_Shdr * section;
8b73c356
NC		 10750 bfd_size_type nbuckets = 0;
10751 bfd_size_type nchains = 0;
2cf0635d
NC		 10752 bfd_vma * buckets = NULL;
10753 bfd_vma * chains = NULL;
fdc90cb4 10754 bfd_vma ngnubuckets = 0;
2cf0635d
NC		 10755 bfd_vma * gnubuckets = NULL;
10756 bfd_vma * gnuchains = NULL;
6bd1a22c 10757 bfd_vma gnusymidx = 0;
071436c6 10758 bfd_size_type ngnuchains = 0;
252b5132 10759
2c610e4b 10760 if (!do_syms && !do_dyn_syms && !do_histogram)
252b5132
RH		 10761 return 1;
10762
6bd1a22c
L		 10763 if (dynamic_info[DT_HASH]
10764 && (do_histogram
2c610e4b
L		 10765 || (do_using_dynamic
10766 && !do_dyn_syms
10767 && dynamic_strings != NULL)))
252b5132 10768 {
66543521
AM		 10769 unsigned char nb[8];
10770 unsigned char nc[8];
8b73c356 10771 unsigned int hash_ent_size = 4;
66543521
AM		 10772
10773 if ((elf_header.e_machine == EM_ALPHA
10774 || elf_header.e_machine == EM_S390
10775 || elf_header.e_machine == EM_S390_OLD)
10776 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10777 hash_ent_size = 8;
10778
fb52b2f4
NC		 10779 if (fseek (file,
10780 (archive_file_offset
10781 + offset_from_vma (file, dynamic_info[DT_HASH],
10782 sizeof nb + sizeof nc)),
d93f0186 10783 SEEK_SET))
252b5132 10784 {
591a748a 10785 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10786 goto no_hash;
252b5132
RH		 10787 }
10788
66543521 10789 if (fread (nb, hash_ent_size, 1, file) != 1)
252b5132
RH		 10790 {
10791 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10792 goto no_hash;
252b5132
RH		 10793 }
10794
66543521 10795 if (fread (nc, hash_ent_size, 1, file) != 1)
252b5132
RH		 10796 {
10797 error (_("Failed to read in number of chains\n"));
d3a44ec6 10798 goto no_hash;
252b5132
RH		 10799 }
10800
66543521
AM		 10801 nbuckets = byte_get (nb, hash_ent_size);
10802 nchains = byte_get (nc, hash_ent_size);
252b5132 10803
66543521
AM		 10804 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10805 chains = get_dynamic_data (file, nchains, hash_ent_size);
252b5132 10806
d3a44ec6 10807 no_hash:
252b5132 10808 if (buckets == NULL || chains == NULL)
d3a44ec6
JJ		 10809 {
10810 if (do_using_dynamic)
10811 return 0;
10812 free (buckets);
10813 free (chains);
10814 buckets = NULL;
10815 chains = NULL;
10816 nbuckets = 0;
10817 nchains = 0;
10818 }
252b5132
RH		 10819 }
10820
6bd1a22c
L		 10821 if (dynamic_info_DT_GNU_HASH
10822 && (do_histogram
2c610e4b
L		 10823 || (do_using_dynamic
10824 && !do_dyn_syms
10825 && dynamic_strings != NULL)))
252b5132 10826 {
6bd1a22c
L		 10827 unsigned char nb[16];
10828 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10829 bfd_vma buckets_vma;
10830
10831 if (fseek (file,
10832 (archive_file_offset
10833 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10834 sizeof nb)),
10835 SEEK_SET))
10836 {
10837 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10838 goto no_gnu_hash;
6bd1a22c 10839 }
252b5132 10840
6bd1a22c
L		 10841 if (fread (nb, 16, 1, file) != 1)
10842 {
10843 error (_("Failed to read in number of buckets\n"));
d3a44ec6 10844 goto no_gnu_hash;
6bd1a22c
L		 10845 }
10846
10847 ngnubuckets = byte_get (nb, 4);
10848 gnusymidx = byte_get (nb + 4, 4);
10849 bitmaskwords = byte_get (nb + 8, 4);
10850 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
f7a99963 10851 if (is_32bit_elf)
6bd1a22c 10852 buckets_vma += bitmaskwords * 4;
f7a99963 10853 else
6bd1a22c 10854 buckets_vma += bitmaskwords * 8;
252b5132 10855
6bd1a22c
L		 10856 if (fseek (file,
10857 (archive_file_offset
10858 + offset_from_vma (file, buckets_vma, 4)),
10859 SEEK_SET))
252b5132 10860 {
6bd1a22c 10861 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10862 goto no_gnu_hash;
6bd1a22c
L		 10863 }
10864
10865 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
252b5132 10866
6bd1a22c 10867 if (gnubuckets == NULL)
d3a44ec6 10868 goto no_gnu_hash;
6bd1a22c
L		 10869
10870 for (i = 0; i < ngnubuckets; i++)
10871 if (gnubuckets[i] != 0)
10872 {
10873 if (gnubuckets[i] < gnusymidx)
10874 return 0;
10875
10876 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10877 maxchain = gnubuckets[i];
10878 }
10879
10880 if (maxchain == 0xffffffff)
d3a44ec6 10881 goto no_gnu_hash;
6bd1a22c
L		 10882
10883 maxchain -= gnusymidx;
10884
10885 if (fseek (file,
10886 (archive_file_offset
10887 + offset_from_vma (file, buckets_vma
10888 + 4 * (ngnubuckets + maxchain), 4)),
10889 SEEK_SET))
10890 {
10891 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10892 goto no_gnu_hash;
6bd1a22c
L		 10893 }
10894
10895 do
10896 {
10897 if (fread (nb, 4, 1, file) != 1)
252b5132 10898 {
6bd1a22c 10899 error (_("Failed to determine last chain length\n"));
d3a44ec6 10900 goto no_gnu_hash;
6bd1a22c 10901 }
252b5132 10902
6bd1a22c 10903 if (maxchain + 1 == 0)
d3a44ec6 10904 goto no_gnu_hash;
252b5132 10905
6bd1a22c
L		 10906 ++maxchain;
10907 }
10908 while ((byte_get (nb, 4) & 1) == 0);
76da6bbe 10909
6bd1a22c
L		 10910 if (fseek (file,
10911 (archive_file_offset
10912 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10913 SEEK_SET))
10914 {
10915 error (_("Unable to seek to start of dynamic information\n"));
d3a44ec6 10916 goto no_gnu_hash;
6bd1a22c
L		 10917 }
10918
10919 gnuchains = get_dynamic_data (file, maxchain, 4);
071436c6 10920 ngnuchains = maxchain;
6bd1a22c 10921
d3a44ec6 10922 no_gnu_hash:
6bd1a22c 10923 if (gnuchains == NULL)
d3a44ec6
JJ		 10924 {
10925 free (gnubuckets);
d3a44ec6
JJ		 10926 gnubuckets = NULL;
10927 ngnubuckets = 0;
f64fddf1
NC		 10928 if (do_using_dynamic)
10929 return 0;
d3a44ec6 10930 }
6bd1a22c
L		 10931 }
10932
10933 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10934 && do_syms
10935 && do_using_dynamic
3102e897
NC		 10936 && dynamic_strings != NULL
10937 && dynamic_symbols != NULL)
6bd1a22c
L		 10938 {
10939 unsigned long hn;
10940
10941 if (dynamic_info[DT_HASH])
10942 {
10943 bfd_vma si;
10944
10945 printf (_("\nSymbol table for image:\n"));
10946 if (is_32bit_elf)
10947 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10948 else
10949 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10950
10951 for (hn = 0; hn < nbuckets; hn++)
10952 {
10953 if (! buckets[hn])
10954 continue;
10955
10956 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10957 print_dynamic_symbol (si, hn);
252b5132
RH		 10958 }
10959 }
6bd1a22c
L		 10960
10961 if (dynamic_info_DT_GNU_HASH)
10962 {
10963 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10964 if (is_32bit_elf)
10965 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10966 else
10967 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10968
10969 for (hn = 0; hn < ngnubuckets; ++hn)
10970 if (gnubuckets[hn] != 0)
10971 {
10972 bfd_vma si = gnubuckets[hn];
10973 bfd_vma off = si - gnusymidx;
10974
10975 do
10976 {
10977 print_dynamic_symbol (si, hn);
10978 si++;
10979 }
071436c6 10980 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
6bd1a22c
L		 10981 }
10982 }
252b5132 10983 }
8b73c356
NC		 10984 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10985 && section_headers != NULL)
252b5132 10986 {
b34976b6 10987 unsigned int i;
252b5132
RH		 10988
10989 for (i = 0, section = section_headers;
10990 i < elf_header.e_shnum;
10991 i++, section++)
10992 {
b34976b6 10993 unsigned int si;
2cf0635d 10994 char * strtab = NULL;
c256ffe7 10995 unsigned long int strtab_size = 0;
2cf0635d
NC		 10996 Elf_Internal_Sym * symtab;
10997 Elf_Internal_Sym * psym;
ba5cdace 10998 unsigned long num_syms;
252b5132 10999
2c610e4b
L		 11000 if ((section->sh_type != SHT_SYMTAB
11001 && section->sh_type != SHT_DYNSYM)
11002 || (!do_syms
11003 && section->sh_type == SHT_SYMTAB))
252b5132
RH		 11004 continue;
11005
dd24e3da
NC		 11006 if (section->sh_entsize == 0)
11007 {
11008 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
74e1a04b 11009 printable_section_name (section));
dd24e3da
NC		 11010 continue;
11011 }
11012
252b5132 11013 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
74e1a04b 11014 printable_section_name (section),
252b5132 11015 (unsigned long) (section->sh_size / section->sh_entsize));
dd24e3da 11016
f7a99963 11017 if (is_32bit_elf)
ca47b30c 11018 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 11019 else
ca47b30c 11020 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 11021
ba5cdace 11022 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
252b5132
RH		 11023 if (symtab == NULL)
11024 continue;
11025
11026 if (section->sh_link == elf_header.e_shstrndx)
c256ffe7
JJ		 11027 {
11028 strtab = string_table;
11029 strtab_size = string_table_length;
11030 }
4fbb74a6 11031 else if (section->sh_link < elf_header.e_shnum)
252b5132 11032 {
2cf0635d 11033 Elf_Internal_Shdr * string_sec;
252b5132 11034
4fbb74a6 11035 string_sec = section_headers + section->sh_link;
252b5132 11036
3f5e193b
NC		 11037 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
11038 1, string_sec->sh_size,
11039 _("string table"));
c256ffe7 11040 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
252b5132
RH		 11041 }
11042
ba5cdace 11043 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
252b5132 11044 {
bb4d2ac2
L		 11045 const char *version_string;
11046 enum versioned_symbol_info sym_info;
11047 unsigned short vna_other;
11048
5e220199 11049 printf ("%6d: ", si);
f7a99963
NC		 11050 print_vma (psym->st_value, LONG_HEX);
11051 putchar (' ');
11052 print_vma (psym->st_size, DEC_5);
d1133906
NC		 11053 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
11054 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
fd85a6a1
NC		 11055 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11056 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
11057 else
11058 {
11059 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11060
11061 printf (" %-7s", get_symbol_visibility (vis));
11062 /* Check to see if any other bits in the st_other field are set.
11063 Note - displaying this information disrupts the layout of the
11064 table being generated, but for the moment this case is very rare. */
11065 if (psym->st_other ^ vis)
11066 printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
11067 }
31104126 11068 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
c256ffe7 11069 print_symbol (25, psym->st_name < strtab_size
2b692964 11070 ? strtab + psym->st_name : _("<corrupt>"));
252b5132 11071
bb4d2ac2
L		 11072 version_string
11073 = get_symbol_version_string (file,
11074 section->sh_type == SHT_DYNSYM,
11075 strtab, strtab_size, si,
11076 psym, &sym_info, &vna_other);
11077 if (version_string)
252b5132 11078 {
bb4d2ac2
L		 11079 if (sym_info == symbol_undefined)
11080 printf ("@%s (%d)", version_string, vna_other);
11081 else
11082 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11083 version_string);
252b5132
RH		 11084 }
11085
11086 putchar ('\n');
11087 }
11088
11089 free (symtab);
11090 if (strtab != string_table)
11091 free (strtab);
11092 }
11093 }
11094 else if (do_syms)
11095 printf
11096 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11097
11098 if (do_histogram && buckets != NULL)
11099 {
2cf0635d
NC		 11100 unsigned long * lengths;
11101 unsigned long * counts;
66543521
AM		 11102 unsigned long hn;
11103 bfd_vma si;
11104 unsigned long maxlength = 0;
11105 unsigned long nzero_counts = 0;
11106 unsigned long nsyms = 0;
94d15024 11107 unsigned long chained;
252b5132 11108
66543521
AM		 11109 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11110 (unsigned long) nbuckets);
252b5132 11111
3f5e193b 11112 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
252b5132
RH		 11113 if (lengths == NULL)
11114 {
8b73c356 11115 error (_("Out of memory allocating space for histogram buckets\n"));
252b5132
RH		 11116 return 0;
11117 }
8b73c356
NC		 11118
11119 printf (_(" Length Number %% of total Coverage\n"));
252b5132
RH		 11120 for (hn = 0; hn < nbuckets; ++hn)
11121 {
94d15024
MF		 11122 for (si = buckets[hn], chained = 0;
11123 si > 0 && si < nchains && si < nbuckets && chained <= nchains;
11124 si = chains[si], ++chained)
252b5132 11125 {
b34976b6 11126 ++nsyms;
252b5132 11127 if (maxlength < ++lengths[hn])
b34976b6 11128 ++maxlength;
252b5132 11129 }
94d15024
MF		 11130
11131 /* PR binutils/17531: A corrupt binary could contain broken
11132 histogram data. Do not go into an infinite loop trying
11133 to process it. */
11134 if (chained > nchains)
11135 {
11136 error (_("histogram chain is corrupt\n"));
11137 break;
11138 }
252b5132
RH		 11139 }
11140
3f5e193b 11141 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
252b5132
RH		 11142 if (counts == NULL)
11143 {
b2e951ec 11144 free (lengths);
8b73c356 11145 error (_("Out of memory allocating space for histogram counts\n"));
252b5132
RH		 11146 return 0;
11147 }
11148
11149 for (hn = 0; hn < nbuckets; ++hn)
b34976b6 11150 ++counts[lengths[hn]];
252b5132 11151
103f02d3 11152 if (nbuckets > 0)
252b5132 11153 {
66543521
AM		 11154 unsigned long i;
11155 printf (" 0 %-10lu (%5.1f%%)\n",
103f02d3 11156 counts[0], (counts[0] * 100.0) / nbuckets);
66543521 11157 for (i = 1; i <= maxlength; ++i)
103f02d3 11158 {
66543521
AM		 11159 nzero_counts += counts[i] * i;
11160 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11161 i, counts[i], (counts[i] * 100.0) / nbuckets,
103f02d3
UD		 11162 (nzero_counts * 100.0) / nsyms);
11163 }
252b5132
RH		 11164 }
11165
11166 free (counts);
11167 free (lengths);
11168 }
11169
11170 if (buckets != NULL)
11171 {
11172 free (buckets);
11173 free (chains);
11174 }
11175
d3a44ec6 11176 if (do_histogram && gnubuckets != NULL)
fdc90cb4 11177 {
2cf0635d
NC		 11178 unsigned long * lengths;
11179 unsigned long * counts;
fdc90cb4
JJ		 11180 unsigned long hn;
11181 unsigned long maxlength = 0;
11182 unsigned long nzero_counts = 0;
11183 unsigned long nsyms = 0;
fdc90cb4 11184
8b73c356
NC		 11185 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11186 (unsigned long) ngnubuckets);
11187
3f5e193b 11188 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
fdc90cb4
JJ		 11189 if (lengths == NULL)
11190 {
8b73c356 11191 error (_("Out of memory allocating space for gnu histogram buckets\n"));
fdc90cb4
JJ		 11192 return 0;
11193 }
11194
fdc90cb4
JJ		 11195 printf (_(" Length Number %% of total Coverage\n"));
11196
11197 for (hn = 0; hn < ngnubuckets; ++hn)
11198 if (gnubuckets[hn] != 0)
11199 {
11200 bfd_vma off, length = 1;
11201
6bd1a22c 11202 for (off = gnubuckets[hn] - gnusymidx;
071436c6
NC		 11203 /* PR 17531 file: 010-77222-0.004. */
11204 off < ngnuchains && (gnuchains[off] & 1) == 0;
11205 ++off)
fdc90cb4
JJ		 11206 ++length;
11207 lengths[hn] = length;
11208 if (length > maxlength)
11209 maxlength = length;
11210 nsyms += length;
11211 }
11212
3f5e193b 11213 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
fdc90cb4
JJ		 11214 if (counts == NULL)
11215 {
b2e951ec 11216 free (lengths);
8b73c356 11217 error (_("Out of memory allocating space for gnu histogram counts\n"));
fdc90cb4
JJ		 11218 return 0;
11219 }
11220
11221 for (hn = 0; hn < ngnubuckets; ++hn)
11222 ++counts[lengths[hn]];
11223
11224 if (ngnubuckets > 0)
11225 {
11226 unsigned long j;
11227 printf (" 0 %-10lu (%5.1f%%)\n",
11228 counts[0], (counts[0] * 100.0) / ngnubuckets);
11229 for (j = 1; j <= maxlength; ++j)
11230 {
11231 nzero_counts += counts[j] * j;
11232 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11233 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11234 (nzero_counts * 100.0) / nsyms);
11235 }
11236 }
11237
11238 free (counts);
11239 free (lengths);
11240 free (gnubuckets);
11241 free (gnuchains);
11242 }
11243
252b5132
RH		 11244 return 1;
11245}
11246
11247static int
2cf0635d 11248process_syminfo (FILE * file ATTRIBUTE_UNUSED)
252b5132 11249{
b4c96d0d 11250 unsigned int i;
252b5132
RH		 11251
11252 if (dynamic_syminfo == NULL
11253 || !do_dynamic)
11254 /* No syminfo, this is ok. */
11255 return 1;
11256
11257 /* There better should be a dynamic symbol section. */
11258 if (dynamic_symbols == NULL || dynamic_strings == NULL)
11259 return 0;
11260
11261 if (dynamic_addr)
11262 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11263 dynamic_syminfo_offset, dynamic_syminfo_nent);
11264
11265 printf (_(" Num: Name BoundTo Flags\n"));
11266 for (i = 0; i < dynamic_syminfo_nent; ++i)
11267 {
11268 unsigned short int flags = dynamic_syminfo[i].si_flags;
11269
31104126 11270 printf ("%4d: ", i);
4082ef84
NC		 11271 if (i >= num_dynamic_syms)
11272 printf (_("<corrupt index>"));
11273 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
d79b3d50
NC		 11274 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11275 else
2b692964 11276 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
31104126 11277 putchar (' ');
252b5132
RH		 11278
11279 switch (dynamic_syminfo[i].si_boundto)
11280 {
11281 case SYMINFO_BT_SELF:
11282 fputs ("SELF ", stdout);
11283 break;
11284 case SYMINFO_BT_PARENT:
11285 fputs ("PARENT ", stdout);
11286 break;
11287 default:
11288 if (dynamic_syminfo[i].si_boundto > 0
d79b3d50
NC		 11289 && dynamic_syminfo[i].si_boundto < dynamic_nent
11290 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
31104126 11291 {
d79b3d50 11292 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
31104126
NC		 11293 putchar (' ' );
11294 }
252b5132
RH		 11295 else
11296 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11297 break;
11298 }
11299
11300 if (flags & SYMINFO_FLG_DIRECT)
11301 printf (" DIRECT");
11302 if (flags & SYMINFO_FLG_PASSTHRU)
11303 printf (" PASSTHRU");
11304 if (flags & SYMINFO_FLG_COPY)
11305 printf (" COPY");
11306 if (flags & SYMINFO_FLG_LAZYLOAD)
11307 printf (" LAZYLOAD");
11308
11309 puts ("");
11310 }
11311
11312 return 1;
11313}
11314
cf13d699
NC		 11315/* Check to see if the given reloc needs to be handled in a target specific
11316 manner. If so then process the reloc and return TRUE otherwise return
11317 FALSE. */
09c11c86 11318
cf13d699
NC		 11319static bfd_boolean
11320target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11321 unsigned char * start,
11322 Elf_Internal_Sym * symtab)
252b5132 11323{
cf13d699 11324 unsigned int reloc_type = get_reloc_type (reloc->r_info);
252b5132 11325
cf13d699 11326 switch (elf_header.e_machine)
252b5132 11327 {
13761a11
NC		 11328 case EM_MSP430:
11329 case EM_MSP430_OLD:
11330 {
11331 static Elf_Internal_Sym * saved_sym = NULL;
11332
11333 switch (reloc_type)
11334 {
11335 case 10: /* R_MSP430_SYM_DIFF */
11336 if (uses_msp430x_relocs ())
11337 break;
11338 case 21: /* R_MSP430X_SYM_DIFF */
11339 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11340 return TRUE;
11341
11342 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11343 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11344 goto handle_sym_diff;
0b4362b0 11345
13761a11
NC		 11346 case 5: /* R_MSP430_16_BYTE */
11347 case 9: /* R_MSP430_8 */
11348 if (uses_msp430x_relocs ())
11349 break;
11350 goto handle_sym_diff;
11351
11352 case 2: /* R_MSP430_ABS16 */
11353 case 15: /* R_MSP430X_ABS16 */
11354 if (! uses_msp430x_relocs ())
11355 break;
11356 goto handle_sym_diff;
0b4362b0 11357
13761a11
NC		 11358 handle_sym_diff:
11359 if (saved_sym != NULL)
11360 {
11361 bfd_vma value;
11362
11363 value = reloc->r_addend
11364 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11365 - saved_sym->st_value);
11366
11367 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11368
11369 saved_sym = NULL;
11370 return TRUE;
11371 }
11372 break;
11373
11374 default:
11375 if (saved_sym != NULL)
071436c6 11376 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13761a11
NC		 11377 break;
11378 }
11379 break;
11380 }
11381
cf13d699
NC		 11382 case EM_MN10300:
11383 case EM_CYGNUS_MN10300:
11384 {
11385 static Elf_Internal_Sym * saved_sym = NULL;
252b5132 11386
cf13d699
NC		 11387 switch (reloc_type)
11388 {
11389 case 34: /* R_MN10300_ALIGN */
11390 return TRUE;
11391 case 33: /* R_MN10300_SYM_DIFF */
11392 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11393 return TRUE;
11394 case 1: /* R_MN10300_32 */
11395 case 2: /* R_MN10300_16 */
11396 if (saved_sym != NULL)
11397 {
11398 bfd_vma value;
252b5132 11399
cf13d699
NC		 11400 value = reloc->r_addend
11401 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11402 - saved_sym->st_value);
252b5132 11403
cf13d699 11404 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
252b5132 11405
cf13d699
NC		 11406 saved_sym = NULL;
11407 return TRUE;
11408 }
11409 break;
11410 default:
11411 if (saved_sym != NULL)
071436c6 11412 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
cf13d699
NC		 11413 break;
11414 }
11415 break;
11416 }
6ff71e76
NC		 11417
11418 case EM_RL78:
11419 {
11420 static bfd_vma saved_sym1 = 0;
11421 static bfd_vma saved_sym2 = 0;
11422 static bfd_vma value;
11423
11424 switch (reloc_type)
11425 {
11426 case 0x80: /* R_RL78_SYM. */
11427 saved_sym1 = saved_sym2;
11428 saved_sym2 = symtab[get_reloc_symindex (reloc->r_info)].st_value;
11429 saved_sym2 += reloc->r_addend;
11430 return TRUE;
11431
11432 case 0x83: /* R_RL78_OPsub. */
11433 value = saved_sym1 - saved_sym2;
11434 saved_sym2 = saved_sym1 = 0;
11435 return TRUE;
11436 break;
11437
11438 case 0x41: /* R_RL78_ABS32. */
11439 byte_put (start + reloc->r_offset, value, 4);
11440 value = 0;
11441 return TRUE;
11442
11443 case 0x43: /* R_RL78_ABS16. */
11444 byte_put (start + reloc->r_offset, value, 2);
11445 value = 0;
11446 return TRUE;
11447
11448 default:
11449 break;
11450 }
11451 break;
11452 }
252b5132
RH		 11453 }
11454
cf13d699 11455 return FALSE;
252b5132
RH		 11456}
11457
aca88567
NC		 11458/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11459 DWARF debug sections. This is a target specific test. Note - we do not
11460 go through the whole including-target-headers-multiple-times route, (as
11461 we have already done with <elf/h8.h>) because this would become very
11462 messy and even then this function would have to contain target specific
11463 information (the names of the relocs instead of their numeric values).
11464 FIXME: This is not the correct way to solve this problem. The proper way
11465 is to have target specific reloc sizing and typing functions created by
11466 the reloc-macros.h header, in the same way that it already creates the
11467 reloc naming functions. */
11468
11469static bfd_boolean
11470is_32bit_abs_reloc (unsigned int reloc_type)
11471{
11472 switch (elf_header.e_machine)
11473 {
41e92641 11474 case EM_386:
22abe556 11475 case EM_IAMCU:
41e92641 11476 return reloc_type == 1; /* R_386_32. */
aca88567
NC		 11477 case EM_68K:
11478 return reloc_type == 1; /* R_68K_32. */
11479 case EM_860:
11480 return reloc_type == 1; /* R_860_32. */
137b6b5f
AM		 11481 case EM_960:
11482 return reloc_type == 2; /* R_960_32. */
a06ea964
NC		 11483 case EM_AARCH64:
11484 return reloc_type == 258; /* R_AARCH64_ABS32 */
aca88567 11485 case EM_ALPHA:
137b6b5f 11486 return reloc_type == 1; /* R_ALPHA_REFLONG. */
41e92641
NC		 11487 case EM_ARC:
11488 return reloc_type == 1; /* R_ARC_32. */
886a2506
NC		 11489 case EM_ARC_COMPACT:
11490 case EM_ARC_COMPACT2:
11491 return reloc_type == 4; /* R_ARC_32. */
41e92641
NC		 11492 case EM_ARM:
11493 return reloc_type == 2; /* R_ARM_ABS32 */
cb8f3167 11494 case EM_AVR_OLD:
aca88567
NC		 11495 case EM_AVR:
11496 return reloc_type == 1;
cfb8c092
NC		 11497 case EM_ADAPTEVA_EPIPHANY:
11498 return reloc_type == 3;
aca88567
NC		 11499 case EM_BLACKFIN:
11500 return reloc_type == 0x12; /* R_byte4_data. */
11501 case EM_CRIS:
11502 return reloc_type == 3; /* R_CRIS_32. */
11503 case EM_CR16:
11504 return reloc_type == 3; /* R_CR16_NUM32. */
11505 case EM_CRX:
11506 return reloc_type == 15; /* R_CRX_NUM32. */
11507 case EM_CYGNUS_FRV:
11508 return reloc_type == 1;
41e92641
NC		 11509 case EM_CYGNUS_D10V:
11510 case EM_D10V:
11511 return reloc_type == 6; /* R_D10V_32. */
aca88567
NC		 11512 case EM_CYGNUS_D30V:
11513 case EM_D30V:
11514 return reloc_type == 12; /* R_D30V_32_NORMAL. */
41e92641
NC		 11515 case EM_DLX:
11516 return reloc_type == 3; /* R_DLX_RELOC_32. */
aca88567
NC		 11517 case EM_CYGNUS_FR30:
11518 case EM_FR30:
11519 return reloc_type == 3; /* R_FR30_32. */
3f8107ab
AM		 11520 case EM_FT32:
11521 return reloc_type == 1; /* R_FT32_32. */
aca88567
NC		 11522 case EM_H8S:
11523 case EM_H8_300:
11524 case EM_H8_300H:
11525 return reloc_type == 1; /* R_H8_DIR32. */
3730236a 11526 case EM_IA_64:
d1c4b12b
NC		 11527 return reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
11528 || reloc_type == 0x25; /* R_IA64_DIR32LSB. */
aca88567
NC		 11529 case EM_IP2K_OLD:
11530 case EM_IP2K:
11531 return reloc_type == 2; /* R_IP2K_32. */
11532 case EM_IQ2000:
11533 return reloc_type == 2; /* R_IQ2000_32. */
84e94c90
NC		 11534 case EM_LATTICEMICO32:
11535 return reloc_type == 3; /* R_LM32_32. */
ff7eeb89 11536 case EM_M32C_OLD:
aca88567
NC		 11537 case EM_M32C:
11538 return reloc_type == 3; /* R_M32C_32. */
11539 case EM_M32R:
11540 return reloc_type == 34; /* R_M32R_32_RELA. */
adec12c1
AM		 11541 case EM_68HC11:
11542 case EM_68HC12:
11543 return reloc_type == 6; /* R_M68HC11_32. */
aca88567
NC		 11544 case EM_MCORE:
11545 return reloc_type == 1; /* R_MCORE_ADDR32. */
11546 case EM_CYGNUS_MEP:
11547 return reloc_type == 4; /* R_MEP_32. */
a3c62988
NC		 11548 case EM_METAG:
11549 return reloc_type == 2; /* R_METAG_ADDR32. */
137b6b5f
AM		 11550 case EM_MICROBLAZE:
11551 return reloc_type == 1; /* R_MICROBLAZE_32. */
aca88567
NC		 11552 case EM_MIPS:
11553 return reloc_type == 2; /* R_MIPS_32. */
11554 case EM_MMIX:
11555 return reloc_type == 4; /* R_MMIX_32. */
11556 case EM_CYGNUS_MN10200:
11557 case EM_MN10200:
11558 return reloc_type == 1; /* R_MN10200_32. */
11559 case EM_CYGNUS_MN10300:
11560 case EM_MN10300:
11561 return reloc_type == 1; /* R_MN10300_32. */
5506d11a
AM		 11562 case EM_MOXIE:
11563 return reloc_type == 1; /* R_MOXIE_32. */
aca88567
NC		 11564 case EM_MSP430_OLD:
11565 case EM_MSP430:
13761a11 11566 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
aca88567
NC		 11567 case EM_MT:
11568 return reloc_type == 2; /* R_MT_32. */
35c08157
KLC		 11569 case EM_NDS32:
11570 return reloc_type == 20; /* R_NDS32_RELA. */
3e0873ac 11571 case EM_ALTERA_NIOS2:
36591ba1 11572 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
3e0873ac
NC		 11573 case EM_NIOS32:
11574 return reloc_type == 1; /* R_NIOS_32. */
73589c9d
CS		 11575 case EM_OR1K:
11576 return reloc_type == 1; /* R_OR1K_32. */
aca88567 11577 case EM_PARISC:
5fda8eca
NC		 11578 return (reloc_type == 1 /* R_PARISC_DIR32. */
11579 || reloc_type == 41); /* R_PARISC_SECREL32. */
aca88567
NC		 11580 case EM_PJ:
11581 case EM_PJ_OLD:
11582 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
11583 case EM_PPC64:
11584 return reloc_type == 1; /* R_PPC64_ADDR32. */
11585 case EM_PPC:
11586 return reloc_type == 1; /* R_PPC_ADDR32. */
99c513f6
DD		 11587 case EM_RL78:
11588 return reloc_type == 1; /* R_RL78_DIR32. */
c7927a3c
NC		 11589 case EM_RX:
11590 return reloc_type == 1; /* R_RX_DIR32. */
aca88567
NC		 11591 case EM_S370:
11592 return reloc_type == 1; /* R_I370_ADDR31. */
11593 case EM_S390_OLD:
11594 case EM_S390:
11595 return reloc_type == 4; /* R_S390_32. */
41e92641
NC		 11596 case EM_SCORE:
11597 return reloc_type == 8; /* R_SCORE_ABS32. */
aca88567
NC		 11598 case EM_SH:
11599 return reloc_type == 1; /* R_SH_DIR32. */
11600 case EM_SPARC32PLUS:
11601 case EM_SPARCV9:
11602 case EM_SPARC:
11603 return reloc_type == 3 /* R_SPARC_32. */
11604 || reloc_type == 23; /* R_SPARC_UA32. */
a7dd7d05
AM		 11605 case EM_SPU:
11606 return reloc_type == 6; /* R_SPU_ADDR32 */
40b36596
JM		 11607 case EM_TI_C6000:
11608 return reloc_type == 1; /* R_C6000_ABS32. */
aa137e4d
NC		 11609 case EM_TILEGX:
11610 return reloc_type == 2; /* R_TILEGX_32. */
11611 case EM_TILEPRO:
11612 return reloc_type == 1; /* R_TILEPRO_32. */
aca88567
NC		 11613 case EM_CYGNUS_V850:
11614 case EM_V850:
11615 return reloc_type == 6; /* R_V850_ABS32. */
708e2187
NC		 11616 case EM_V800:
11617 return reloc_type == 0x33; /* R_V810_WORD. */
aca88567
NC		 11618 case EM_VAX:
11619 return reloc_type == 1; /* R_VAX_32. */
619ed720
EB		 11620 case EM_VISIUM:
11621 return reloc_type == 3; /* R_VISIUM_32. */
aca88567 11622 case EM_X86_64:
8a9036a4 11623 case EM_L1OM:
7a9068fe 11624 case EM_K1OM:
aca88567 11625 return reloc_type == 10; /* R_X86_64_32. */
c29aca4a
NC		 11626 case EM_XC16X:
11627 case EM_C166:
11628 return reloc_type == 3; /* R_XC16C_ABS_32. */
f6c1a2d5
NC		 11629 case EM_XGATE:
11630 return reloc_type == 4; /* R_XGATE_32. */
aca88567
NC		 11631 case EM_XSTORMY16:
11632 return reloc_type == 1; /* R_XSTROMY16_32. */
11633 case EM_XTENSA_OLD:
11634 case EM_XTENSA:
11635 return reloc_type == 1; /* R_XTENSA_32. */
aca88567 11636 default:
bee0ee85
NC		 11637 {
11638 static unsigned int prev_warn = 0;
11639
11640 /* Avoid repeating the same warning multiple times. */
11641 if (prev_warn != elf_header.e_machine)
11642 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11643 elf_header.e_machine);
11644 prev_warn = elf_header.e_machine;
11645 return FALSE;
11646 }
aca88567
NC		 11647 }
11648}
11649
11650/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11651 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11652
11653static bfd_boolean
11654is_32bit_pcrel_reloc (unsigned int reloc_type)
11655{
11656 switch (elf_header.e_machine)
11657 {
41e92641 11658 case EM_386:
22abe556 11659 case EM_IAMCU:
3e0873ac 11660 return reloc_type == 2; /* R_386_PC32. */
aca88567 11661 case EM_68K:
3e0873ac 11662 return reloc_type == 4; /* R_68K_PC32. */
a06ea964
NC		 11663 case EM_AARCH64:
11664 return reloc_type == 261; /* R_AARCH64_PREL32 */
cfb8c092
NC		 11665 case EM_ADAPTEVA_EPIPHANY:
11666 return reloc_type == 6;
aca88567
NC		 11667 case EM_ALPHA:
11668 return reloc_type == 10; /* R_ALPHA_SREL32. */
726c18e1
CZ		 11669 case EM_ARC_COMPACT:
11670 case EM_ARC_COMPACT2:
11671 return reloc_type == 49; /* R_ARC_32_PCREL. */
41e92641 11672 case EM_ARM:
3e0873ac 11673 return reloc_type == 3; /* R_ARM_REL32 */
137b6b5f
AM		 11674 case EM_MICROBLAZE:
11675 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
73589c9d
CS		 11676 case EM_OR1K:
11677 return reloc_type == 9; /* R_OR1K_32_PCREL. */
aca88567 11678 case EM_PARISC:
85acf597 11679 return reloc_type == 9; /* R_PARISC_PCREL32. */
aca88567
NC		 11680 case EM_PPC:
11681 return reloc_type == 26; /* R_PPC_REL32. */
11682 case EM_PPC64:
3e0873ac 11683 return reloc_type == 26; /* R_PPC64_REL32. */
aca88567
NC		 11684 case EM_S390_OLD:
11685 case EM_S390:
3e0873ac 11686 return reloc_type == 5; /* R_390_PC32. */
aca88567 11687 case EM_SH:
3e0873ac 11688 return reloc_type == 2; /* R_SH_REL32. */
aca88567
NC		 11689 case EM_SPARC32PLUS:
11690 case EM_SPARCV9:
11691 case EM_SPARC:
3e0873ac 11692 return reloc_type == 6; /* R_SPARC_DISP32. */
a7dd7d05
AM		 11693 case EM_SPU:
11694 return reloc_type == 13; /* R_SPU_REL32. */
aa137e4d
NC		 11695 case EM_TILEGX:
11696 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
11697 case EM_TILEPRO:
11698 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
619ed720
EB		 11699 case EM_VISIUM:
11700 return reloc_type == 6; /* R_VISIUM_32_PCREL */
aca88567 11701 case EM_X86_64:
8a9036a4 11702 case EM_L1OM:
7a9068fe 11703 case EM_K1OM:
3e0873ac 11704 return reloc_type == 2; /* R_X86_64_PC32. */
2fcb9706
BW		 11705 case EM_XTENSA_OLD:
11706 case EM_XTENSA:
11707 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
aca88567
NC		 11708 default:
11709 /* Do not abort or issue an error message here. Not all targets use
11710 pc-relative 32-bit relocs in their DWARF debug information and we
11711 have already tested for target coverage in is_32bit_abs_reloc. A
cf13d699
NC		 11712 more helpful warning message will be generated by apply_relocations
11713 anyway, so just return. */
aca88567
NC		 11714 return FALSE;
11715 }
11716}
11717
11718/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11719 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11720
11721static bfd_boolean
11722is_64bit_abs_reloc (unsigned int reloc_type)
11723{
11724 switch (elf_header.e_machine)
11725 {
a06ea964
NC		 11726 case EM_AARCH64:
11727 return reloc_type == 257; /* R_AARCH64_ABS64. */
aca88567
NC		 11728 case EM_ALPHA:
11729 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
3730236a
NC		 11730 case EM_IA_64:
11731 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
3e0873ac
NC		 11732 case EM_PARISC:
11733 return reloc_type == 80; /* R_PARISC_DIR64. */
aca88567
NC		 11734 case EM_PPC64:
11735 return reloc_type == 38; /* R_PPC64_ADDR64. */
11736 case EM_SPARC32PLUS:
11737 case EM_SPARCV9:
11738 case EM_SPARC:
11739 return reloc_type == 54; /* R_SPARC_UA64. */
11740 case EM_X86_64:
8a9036a4 11741 case EM_L1OM:
7a9068fe 11742 case EM_K1OM:
aca88567 11743 return reloc_type == 1; /* R_X86_64_64. */
e819ade1
AS		 11744 case EM_S390_OLD:
11745 case EM_S390:
aa137e4d
NC		 11746 return reloc_type == 22; /* R_S390_64. */
11747 case EM_TILEGX:
11748 return reloc_type == 1; /* R_TILEGX_64. */
85a82265 11749 case EM_MIPS:
aa137e4d 11750 return reloc_type == 18; /* R_MIPS_64. */
aca88567
NC		 11751 default:
11752 return FALSE;
11753 }
11754}
11755
85acf597
RH		 11756/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11757 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11758
11759static bfd_boolean
11760is_64bit_pcrel_reloc (unsigned int reloc_type)
11761{
11762 switch (elf_header.e_machine)
11763 {
a06ea964
NC		 11764 case EM_AARCH64:
11765 return reloc_type == 260; /* R_AARCH64_PREL64. */
85acf597 11766 case EM_ALPHA:
aa137e4d 11767 return reloc_type == 11; /* R_ALPHA_SREL64. */
85acf597 11768 case EM_IA_64:
aa137e4d 11769 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
85acf597 11770 case EM_PARISC:
aa137e4d 11771 return reloc_type == 72; /* R_PARISC_PCREL64. */
85acf597 11772 case EM_PPC64:
aa137e4d 11773 return reloc_type == 44; /* R_PPC64_REL64. */
85acf597
RH		 11774 case EM_SPARC32PLUS:
11775 case EM_SPARCV9:
11776 case EM_SPARC:
aa137e4d 11777 return reloc_type == 46; /* R_SPARC_DISP64. */
85acf597 11778 case EM_X86_64:
8a9036a4 11779 case EM_L1OM:
7a9068fe 11780 case EM_K1OM:
aa137e4d 11781 return reloc_type == 24; /* R_X86_64_PC64. */
85acf597
RH		 11782 case EM_S390_OLD:
11783 case EM_S390:
aa137e4d
NC		 11784 return reloc_type == 23; /* R_S390_PC64. */
11785 case EM_TILEGX:
11786 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
85acf597
RH		 11787 default:
11788 return FALSE;
11789 }
11790}
11791
4dc3c23d
AM		 11792/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11793 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11794
11795static bfd_boolean
11796is_24bit_abs_reloc (unsigned int reloc_type)
11797{
11798 switch (elf_header.e_machine)
11799 {
11800 case EM_CYGNUS_MN10200:
11801 case EM_MN10200:
11802 return reloc_type == 4; /* R_MN10200_24. */
11803 default:
11804 return FALSE;
11805 }
11806}
11807
aca88567
NC		 11808/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11809 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11810
11811static bfd_boolean
11812is_16bit_abs_reloc (unsigned int reloc_type)
4b78141a
NC		 11813{
11814 switch (elf_header.e_machine)
11815 {
886a2506
NC		 11816 case EM_ARC:
11817 case EM_ARC_COMPACT:
11818 case EM_ARC_COMPACT2:
11819 return reloc_type == 2; /* R_ARC_16. */
aca88567
NC		 11820 case EM_AVR_OLD:
11821 case EM_AVR:
11822 return reloc_type == 4; /* R_AVR_16. */
cfb8c092
NC		 11823 case EM_ADAPTEVA_EPIPHANY:
11824 return reloc_type == 5;
41e92641
NC		 11825 case EM_CYGNUS_D10V:
11826 case EM_D10V:
11827 return reloc_type == 3; /* R_D10V_16. */
4b78141a
NC		 11828 case EM_H8S:
11829 case EM_H8_300:
11830 case EM_H8_300H:
aca88567
NC		 11831 return reloc_type == R_H8_DIR16;
11832 case EM_IP2K_OLD:
11833 case EM_IP2K:
11834 return reloc_type == 1; /* R_IP2K_16. */
ff7eeb89 11835 case EM_M32C_OLD:
f4236fe4
DD		 11836 case EM_M32C:
11837 return reloc_type == 1; /* R_M32C_16 */
aca88567 11838 case EM_MSP430:
13761a11
NC		 11839 if (uses_msp430x_relocs ())
11840 return reloc_type == 2; /* R_MSP430_ABS16. */
78c8d46c 11841 case EM_MSP430_OLD:
aca88567 11842 return reloc_type == 5; /* R_MSP430_16_BYTE. */
35c08157
KLC		 11843 case EM_NDS32:
11844 return reloc_type == 19; /* R_NDS32_RELA. */
3e0873ac 11845 case EM_ALTERA_NIOS2:
36591ba1 11846 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
3e0873ac
NC		 11847 case EM_NIOS32:
11848 return reloc_type == 9; /* R_NIOS_16. */
73589c9d
CS		 11849 case EM_OR1K:
11850 return reloc_type == 2; /* R_OR1K_16. */
40b36596
JM		 11851 case EM_TI_C6000:
11852 return reloc_type == 2; /* R_C6000_ABS16. */
c29aca4a
NC		 11853 case EM_XC16X:
11854 case EM_C166:
11855 return reloc_type == 2; /* R_XC16C_ABS_16. */
e63734a3
AM		 11856 case EM_CYGNUS_MN10200:
11857 case EM_MN10200:
11858 return reloc_type == 2; /* R_MN10200_16. */
0a22ae8e
NC		 11859 case EM_CYGNUS_MN10300:
11860 case EM_MN10300:
11861 return reloc_type == 2; /* R_MN10300_16. */
619ed720
EB		 11862 case EM_VISIUM:
11863 return reloc_type == 2; /* R_VISIUM_16. */
f6c1a2d5
NC		 11864 case EM_XGATE:
11865 return reloc_type == 3; /* R_XGATE_16. */
4b78141a 11866 default:
aca88567 11867 return FALSE;
4b78141a
NC		 11868 }
11869}
11870
2a7b2e88
JK		 11871/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11872 relocation entries (possibly formerly used for SHT_GROUP sections). */
11873
11874static bfd_boolean
11875is_none_reloc (unsigned int reloc_type)
11876{
11877 switch (elf_header.e_machine)
11878 {
cb8f3167
NC		 11879 case EM_68K: /* R_68K_NONE. */
11880 case EM_386: /* R_386_NONE. */
2a7b2e88
JK		 11881 case EM_SPARC32PLUS:
11882 case EM_SPARCV9:
cb8f3167
NC		 11883 case EM_SPARC: /* R_SPARC_NONE. */
11884 case EM_MIPS: /* R_MIPS_NONE. */
11885 case EM_PARISC: /* R_PARISC_NONE. */
11886 case EM_ALPHA: /* R_ALPHA_NONE. */
cfb8c092 11887 case EM_ADAPTEVA_EPIPHANY:
cb8f3167
NC		 11888 case EM_PPC: /* R_PPC_NONE. */
11889 case EM_PPC64: /* R_PPC64_NONE. */
886a2506
NC		 11890 case EM_ARC: /* R_ARC_NONE. */
11891 case EM_ARC_COMPACT: /* R_ARC_NONE. */
11892 case EM_ARC_COMPACT2: /* R_ARC_NONE. */
cb8f3167
NC		 11893 case EM_ARM: /* R_ARM_NONE. */
11894 case EM_IA_64: /* R_IA64_NONE. */
11895 case EM_SH: /* R_SH_NONE. */
2a7b2e88 11896 case EM_S390_OLD:
cb8f3167
NC		 11897 case EM_S390: /* R_390_NONE. */
11898 case EM_CRIS: /* R_CRIS_NONE. */
11899 case EM_X86_64: /* R_X86_64_NONE. */
8a9036a4 11900 case EM_L1OM: /* R_X86_64_NONE. */
7a9068fe 11901 case EM_K1OM: /* R_X86_64_NONE. */
cb8f3167 11902 case EM_MN10300: /* R_MN10300_NONE. */
3f8107ab 11903 case EM_FT32: /* R_FT32_NONE. */
5506d11a 11904 case EM_MOXIE: /* R_MOXIE_NONE. */
cb8f3167 11905 case EM_M32R: /* R_M32R_NONE. */
40b36596 11906 case EM_TI_C6000:/* R_C6000_NONE. */
aa137e4d
NC		 11907 case EM_TILEGX: /* R_TILEGX_NONE. */
11908 case EM_TILEPRO: /* R_TILEPRO_NONE. */
c29aca4a
NC		 11909 case EM_XC16X:
11910 case EM_C166: /* R_XC16X_NONE. */
36591ba1
SL		 11911 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
11912 case EM_NIOS32: /* R_NIOS_NONE. */
73589c9d 11913 case EM_OR1K: /* R_OR1K_NONE. */
cb8f3167 11914 return reloc_type == 0;
a06ea964
NC		 11915 case EM_AARCH64:
11916 return reloc_type == 0 || reloc_type == 256;
35c08157
KLC		 11917 case EM_NDS32:
11918 return (reloc_type == 0 /* R_XTENSA_NONE. */
11919 || reloc_type == 204 /* R_NDS32_DIFF8. */
11920 || reloc_type == 205 /* R_NDS32_DIFF16. */
11921 || reloc_type == 206 /* R_NDS32_DIFF32. */
11922 || reloc_type == 207 /* R_NDS32_ULEB128. */);
58332dda
JK		 11923 case EM_XTENSA_OLD:
11924 case EM_XTENSA:
4dc3c23d
AM		 11925 return (reloc_type == 0 /* R_XTENSA_NONE. */
11926 || reloc_type == 17 /* R_XTENSA_DIFF8. */
11927 || reloc_type == 18 /* R_XTENSA_DIFF16. */
11928 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
a3c62988
NC		 11929 case EM_METAG:
11930 return reloc_type == 3; /* R_METAG_NONE. */
2a7b2e88
JK		 11931 }
11932 return FALSE;
11933}
11934
d1c4b12b
NC		 11935/* Returns TRUE if there is a relocation against
11936 section NAME at OFFSET bytes. */
11937
11938bfd_boolean
11939reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
11940{
11941 Elf_Internal_Rela * relocs;
11942 Elf_Internal_Rela * rp;
11943
11944 if (dsec == NULL || dsec->reloc_info == NULL)
11945 return FALSE;
11946
11947 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
11948
11949 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
11950 if (rp->r_offset == offset)
11951 return TRUE;
11952
11953 return FALSE;
11954}
11955
cf13d699
NC		 11956/* Apply relocations to a section.
11957 Note: So far support has been added only for those relocations
11958 which can be found in debug sections.
d1c4b12b
NC		 11959 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
11960 loaded relocs. It is then the caller's responsibility to free them.
cf13d699 11961 FIXME: Add support for more relocations ? */
1b315056 11962
cf13d699 11963static void
d1c4b12b
NC		 11964apply_relocations (void * file,
11965 const Elf_Internal_Shdr * section,
11966 unsigned char * start,
11967 bfd_size_type size,
11968 void ** relocs_return,
11969 unsigned long * num_relocs_return)
1b315056 11970{
cf13d699 11971 Elf_Internal_Shdr * relsec;
0d2a7a93 11972 unsigned char * end = start + size;
cb8f3167 11973
d1c4b12b
NC		 11974 if (relocs_return != NULL)
11975 {
11976 * (Elf_Internal_Rela **) relocs_return = NULL;
11977 * num_relocs_return = 0;
11978 }
11979
cf13d699
NC		 11980 if (elf_header.e_type != ET_REL)
11981 return;
1b315056 11982
cf13d699 11983 /* Find the reloc section associated with the section. */
5b18a4bc
NC		 11984 for (relsec = section_headers;
11985 relsec < section_headers + elf_header.e_shnum;
11986 ++relsec)
252b5132 11987 {
41e92641
NC		 11988 bfd_boolean is_rela;
11989 unsigned long num_relocs;
2cf0635d
NC		 11990 Elf_Internal_Rela * relocs;
11991 Elf_Internal_Rela * rp;
11992 Elf_Internal_Shdr * symsec;
11993 Elf_Internal_Sym * symtab;
ba5cdace 11994 unsigned long num_syms;
2cf0635d 11995 Elf_Internal_Sym * sym;
252b5132 11996
41e92641 11997 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
4fbb74a6
AM		 11998 || relsec->sh_info >= elf_header.e_shnum
11999 || section_headers + relsec->sh_info != section
c256ffe7 12000 || relsec->sh_size == 0
4fbb74a6 12001 || relsec->sh_link >= elf_header.e_shnum)
5b18a4bc 12002 continue;
428409d5 12003
41e92641
NC		 12004 is_rela = relsec->sh_type == SHT_RELA;
12005
12006 if (is_rela)
12007 {
3f5e193b
NC		 12008 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
12009 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 12010 return;
12011 }
12012 else
12013 {
3f5e193b
NC		 12014 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
12015 relsec->sh_size, & relocs, & num_relocs))
41e92641
NC		 12016 return;
12017 }
12018
12019 /* SH uses RELA but uses in place value instead of the addend field. */
12020 if (elf_header.e_machine == EM_SH)
12021 is_rela = FALSE;
428409d5 12022
4fbb74a6 12023 symsec = section_headers + relsec->sh_link;
ba5cdace 12024 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
103f02d3 12025
41e92641 12026 for (rp = relocs; rp < relocs + num_relocs; ++rp)
252b5132 12027 {
41e92641
NC		 12028 bfd_vma addend;
12029 unsigned int reloc_type;
12030 unsigned int reloc_size;
91d6fa6a 12031 unsigned char * rloc;
ba5cdace 12032 unsigned long sym_index;
4b78141a 12033
aca88567 12034 reloc_type = get_reloc_type (rp->r_info);
41e92641 12035
98fb390a 12036 if (target_specific_reloc_handling (rp, start, symtab))
2a7b2e88 12037 continue;
98fb390a
NC		 12038 else if (is_none_reloc (reloc_type))
12039 continue;
12040 else if (is_32bit_abs_reloc (reloc_type)
12041 || is_32bit_pcrel_reloc (reloc_type))
aca88567 12042 reloc_size = 4;
85acf597
RH		 12043 else if (is_64bit_abs_reloc (reloc_type)
12044 || is_64bit_pcrel_reloc (reloc_type))
aca88567 12045 reloc_size = 8;
4dc3c23d
AM		 12046 else if (is_24bit_abs_reloc (reloc_type))
12047 reloc_size = 3;
aca88567
NC		 12048 else if (is_16bit_abs_reloc (reloc_type))
12049 reloc_size = 2;
12050 else
4b78141a 12051 {
bee0ee85
NC		 12052 static unsigned int prev_reloc = 0;
12053 if (reloc_type != prev_reloc)
12054 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12055 reloc_type, printable_section_name (section));
12056 prev_reloc = reloc_type;
4b78141a
NC		 12057 continue;
12058 }
103f02d3 12059
91d6fa6a 12060 rloc = start + rp->r_offset;
c8da6823 12061 if ((rloc + reloc_size) > end || (rloc < start))
700dd8b7
L		 12062 {
12063 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12064 (unsigned long) rp->r_offset,
74e1a04b 12065 printable_section_name (section));
700dd8b7
L		 12066 continue;
12067 }
103f02d3 12068
ba5cdace
NC		 12069 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
12070 if (sym_index >= num_syms)
12071 {
12072 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
74e1a04b 12073 sym_index, printable_section_name (section));
ba5cdace
NC		 12074 continue;
12075 }
12076 sym = symtab + sym_index;
41e92641
NC		 12077
12078 /* If the reloc has a symbol associated with it,
55f25fc3
L		 12079 make sure that it is of an appropriate type.
12080
12081 Relocations against symbols without type can happen.
12082 Gcc -feliminate-dwarf2-dups may generate symbols
12083 without type for debug info.
12084
12085 Icc generates relocations against function symbols
12086 instead of local labels.
12087
12088 Relocations against object symbols can happen, eg when
12089 referencing a global array. For an example of this see
12090 the _clz.o binary in libgcc.a. */
aca88567 12091 if (sym != symtab
b8871f35 12092 && ELF_ST_TYPE (sym->st_info) != STT_COMMON
55f25fc3 12093 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
5b18a4bc 12094 {
41e92641 12095 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
aca88567 12096 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
99dcb0b9 12097 (long int)(rp - relocs),
74e1a04b 12098 printable_section_name (relsec));
aca88567 12099 continue;
5b18a4bc 12100 }
252b5132 12101
4dc3c23d
AM		 12102 addend = 0;
12103 if (is_rela)
12104 addend += rp->r_addend;
c47320c3
AM		 12105 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12106 partial_inplace. */
4dc3c23d
AM		 12107 if (!is_rela
12108 || (elf_header.e_machine == EM_XTENSA
12109 && reloc_type == 1)
12110 || ((elf_header.e_machine == EM_PJ
12111 || elf_header.e_machine == EM_PJ_OLD)
c47320c3
AM		 12112 && reloc_type == 1)
12113 || ((elf_header.e_machine == EM_D30V
12114 || elf_header.e_machine == EM_CYGNUS_D30V)
12115 && reloc_type == 12))
91d6fa6a 12116 addend += byte_get (rloc, reloc_size);
cb8f3167 12117
85acf597
RH		 12118 if (is_32bit_pcrel_reloc (reloc_type)
12119 || is_64bit_pcrel_reloc (reloc_type))
12120 {
12121 /* On HPPA, all pc-relative relocations are biased by 8. */
12122 if (elf_header.e_machine == EM_PARISC)
12123 addend -= 8;
91d6fa6a 12124 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
85acf597
RH		 12125 reloc_size);
12126 }
41e92641 12127 else
91d6fa6a 12128 byte_put (rloc, addend + sym->st_value, reloc_size);
5b18a4bc 12129 }
252b5132 12130
5b18a4bc 12131 free (symtab);
d1c4b12b
NC		 12132
12133 if (relocs_return)
12134 {
12135 * (Elf_Internal_Rela **) relocs_return = relocs;
12136 * num_relocs_return = num_relocs;
12137 }
12138 else
12139 free (relocs);
12140
5b18a4bc
NC		 12141 break;
12142 }
5b18a4bc 12143}
103f02d3 12144
cf13d699
NC		 12145#ifdef SUPPORT_DISASSEMBLY
12146static int
12147disassemble_section (Elf_Internal_Shdr * section, FILE * file)
12148{
74e1a04b 12149 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
cf13d699 12150
74e1a04b 12151 /* FIXME: XXX -- to be done --- XXX */
cf13d699
NC		 12152
12153 return 1;
12154}
12155#endif
12156
12157/* Reads in the contents of SECTION from FILE, returning a pointer
12158 to a malloc'ed buffer or NULL if something went wrong. */
12159
12160static char *
12161get_section_contents (Elf_Internal_Shdr * section, FILE * file)
12162{
12163 bfd_size_type num_bytes;
12164
12165 num_bytes = section->sh_size;
12166
12167 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
12168 {
12169 printf (_("\nSection '%s' has no data to dump.\n"),
74e1a04b 12170 printable_section_name (section));
cf13d699
NC		 12171 return NULL;
12172 }
12173
3f5e193b
NC		 12174 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
12175 _("section contents"));
cf13d699
NC		 12176}
12177
0e602686
NC		 12178/* Uncompresses a section that was compressed using zlib, in place. */
12179
12180static bfd_boolean
12181uncompress_section_contents (unsigned char **buffer,
12182 dwarf_size_type uncompressed_size,
12183 dwarf_size_type *size)
12184{
12185 dwarf_size_type compressed_size = *size;
12186 unsigned char * compressed_buffer = *buffer;
12187 unsigned char * uncompressed_buffer;
12188 z_stream strm;
12189 int rc;
12190
12191 /* It is possible the section consists of several compressed
12192 buffers concatenated together, so we uncompress in a loop. */
12193 /* PR 18313: The state field in the z_stream structure is supposed
12194 to be invisible to the user (ie us), but some compilers will
12195 still complain about it being used without initialisation. So
12196 we first zero the entire z_stream structure and then set the fields
12197 that we need. */
12198 memset (& strm, 0, sizeof strm);
12199 strm.avail_in = compressed_size;
12200 strm.next_in = (Bytef *) compressed_buffer;
12201 strm.avail_out = uncompressed_size;
12202 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
12203
12204 rc = inflateInit (& strm);
12205 while (strm.avail_in > 0)
12206 {
12207 if (rc != Z_OK)
12208 goto fail;
12209 strm.next_out = ((Bytef *) uncompressed_buffer
12210 + (uncompressed_size - strm.avail_out));
12211 rc = inflate (&strm, Z_FINISH);
12212 if (rc != Z_STREAM_END)
12213 goto fail;
12214 rc = inflateReset (& strm);
12215 }
12216 rc = inflateEnd (& strm);
12217 if (rc != Z_OK
12218 || strm.avail_out != 0)
12219 goto fail;
12220
12221 *buffer = uncompressed_buffer;
12222 *size = uncompressed_size;
12223 return TRUE;
12224
12225 fail:
12226 free (uncompressed_buffer);
12227 /* Indicate decompression failure. */
12228 *buffer = NULL;
12229 return FALSE;
12230}
dd24e3da 12231
cf13d699
NC		 12232static void
12233dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12234{
0e602686
NC		 12235 Elf_Internal_Shdr * relsec;
12236 bfd_size_type num_bytes;
fd8008d8
L		 12237 unsigned char * data;
12238 unsigned char * end;
12239 unsigned char * real_start;
12240 unsigned char * start;
0e602686 12241 bfd_boolean some_strings_shown;
cf13d699 12242
fd8008d8
L		 12243 real_start = start = (unsigned char *) get_section_contents (section,
12244 file);
cf13d699
NC		 12245 if (start == NULL)
12246 return;
0e602686 12247 num_bytes = section->sh_size;
cf13d699 12248
74e1a04b 12249 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
cf13d699 12250
0e602686
NC		 12251 if (decompress_dumps)
12252 {
12253 dwarf_size_type new_size = num_bytes;
12254 dwarf_size_type uncompressed_size = 0;
12255
12256 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12257 {
12258 Elf_Internal_Chdr chdr;
12259 unsigned int compression_header_size
12260 = get_compression_header (& chdr, (unsigned char *) start);
12261
813dabb9 12262 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
0e602686 12263 {
813dabb9
L		 12264 warn (_("section '%s' has unsupported compress type: %d\n"),
12265 printable_section_name (section), chdr.ch_type);
12266 return;
12267 }
12268 else if (chdr.ch_addralign != section->sh_addralign)
12269 {
12270 warn (_("compressed section '%s' is corrupted\n"),
12271 printable_section_name (section));
12272 return;
0e602686 12273 }
813dabb9
L		 12274 uncompressed_size = chdr.ch_size;
12275 start += compression_header_size;
12276 new_size -= compression_header_size;
0e602686
NC		 12277 }
12278 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12279 {
12280 /* Read the zlib header. In this case, it should be "ZLIB"
12281 followed by the uncompressed section size, 8 bytes in
12282 big-endian order. */
12283 uncompressed_size = start[4]; uncompressed_size <<= 8;
12284 uncompressed_size += start[5]; uncompressed_size <<= 8;
12285 uncompressed_size += start[6]; uncompressed_size <<= 8;
12286 uncompressed_size += start[7]; uncompressed_size <<= 8;
12287 uncompressed_size += start[8]; uncompressed_size <<= 8;
12288 uncompressed_size += start[9]; uncompressed_size <<= 8;
12289 uncompressed_size += start[10]; uncompressed_size <<= 8;
12290 uncompressed_size += start[11];
12291 start += 12;
12292 new_size -= 12;
12293 }
12294
12295 if (uncompressed_size
fd8008d8 12296 && uncompress_section_contents (& start,
0e602686
NC		 12297 uncompressed_size, & new_size))
12298 num_bytes = new_size;
12299 }
fd8008d8 12300
cf13d699
NC		 12301 /* If the section being dumped has relocations against it the user might
12302 be expecting these relocations to have been applied. Check for this
12303 case and issue a warning message in order to avoid confusion.
12304 FIXME: Maybe we ought to have an option that dumps a section with
12305 relocs applied ? */
12306 for (relsec = section_headers;
12307 relsec < section_headers + elf_header.e_shnum;
12308 ++relsec)
12309 {
12310 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12311 || relsec->sh_info >= elf_header.e_shnum
12312 || section_headers + relsec->sh_info != section
12313 || relsec->sh_size == 0
12314 || relsec->sh_link >= elf_header.e_shnum)
12315 continue;
12316
12317 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12318 break;
12319 }
12320
cf13d699
NC		 12321 data = start;
12322 end = start + num_bytes;
12323 some_strings_shown = FALSE;
12324
12325 while (data < end)
12326 {
12327 while (!ISPRINT (* data))
12328 if (++ data >= end)
12329 break;
12330
12331 if (data < end)
12332 {
071436c6
NC		 12333 size_t maxlen = end - data;
12334
cf13d699 12335#ifndef __MSVCRT__
c975cc98
NC		 12336 /* PR 11128: Use two separate invocations in order to work
12337 around bugs in the Solaris 8 implementation of printf. */
12338 printf (" [%6tx] ", data - start);
cf13d699 12339#else
071436c6 12340 printf (" [%6Ix] ", (size_t) (data - start));
cf13d699 12341#endif
4082ef84
NC		 12342 if (maxlen > 0)
12343 {
fd8008d8 12344 print_symbol ((int) maxlen, (const char *) data);
4082ef84 12345 putchar ('\n');
fd8008d8 12346 data += strnlen ((const char *) data, maxlen);
4082ef84
NC		 12347 }
12348 else
12349 {
12350 printf (_("<corrupt>\n"));
12351 data = end;
12352 }
cf13d699
NC		 12353 some_strings_shown = TRUE;
12354 }
12355 }
12356
12357 if (! some_strings_shown)
12358 printf (_(" No strings found in this section."));
12359
0e602686 12360 free (real_start);
cf13d699
NC		 12361
12362 putchar ('\n');
12363}
12364
12365static void
12366dump_section_as_bytes (Elf_Internal_Shdr * section,
12367 FILE * file,
12368 bfd_boolean relocate)
12369{
12370 Elf_Internal_Shdr * relsec;
0e602686
NC		 12371 bfd_size_type bytes;
12372 bfd_size_type section_size;
12373 bfd_vma addr;
12374 unsigned char * data;
12375 unsigned char * real_start;
12376 unsigned char * start;
12377
12378 real_start = start = (unsigned char *) get_section_contents (section, file);
cf13d699
NC		 12379 if (start == NULL)
12380 return;
0e602686 12381 section_size = section->sh_size;
cf13d699 12382
74e1a04b 12383 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
cf13d699 12384
0e602686
NC		 12385 if (decompress_dumps)
12386 {
12387 dwarf_size_type new_size = section_size;
12388 dwarf_size_type uncompressed_size = 0;
12389
12390 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12391 {
12392 Elf_Internal_Chdr chdr;
12393 unsigned int compression_header_size
12394 = get_compression_header (& chdr, start);
12395
813dabb9 12396 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
0e602686 12397 {
813dabb9
L		 12398 warn (_("section '%s' has unsupported compress type: %d\n"),
12399 printable_section_name (section), chdr.ch_type);
12400 return;
0e602686 12401 }
813dabb9
L		 12402 else if (chdr.ch_addralign != section->sh_addralign)
12403 {
12404 warn (_("compressed section '%s' is corrupted\n"),
12405 printable_section_name (section));
12406 return;
12407 }
12408 uncompressed_size = chdr.ch_size;
12409 start += compression_header_size;
12410 new_size -= compression_header_size;
0e602686
NC		 12411 }
12412 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12413 {
12414 /* Read the zlib header. In this case, it should be "ZLIB"
12415 followed by the uncompressed section size, 8 bytes in
12416 big-endian order. */
12417 uncompressed_size = start[4]; uncompressed_size <<= 8;
12418 uncompressed_size += start[5]; uncompressed_size <<= 8;
12419 uncompressed_size += start[6]; uncompressed_size <<= 8;
12420 uncompressed_size += start[7]; uncompressed_size <<= 8;
12421 uncompressed_size += start[8]; uncompressed_size <<= 8;
12422 uncompressed_size += start[9]; uncompressed_size <<= 8;
12423 uncompressed_size += start[10]; uncompressed_size <<= 8;
12424 uncompressed_size += start[11];
12425 start += 12;
12426 new_size -= 12;
12427 }
12428
12429 if (uncompressed_size
12430 && uncompress_section_contents (& start, uncompressed_size,
12431 & new_size))
12432 section_size = new_size;
12433 }
14ae95f2 12434
cf13d699
NC		 12435 if (relocate)
12436 {
0e602686 12437 apply_relocations (file, section, start, section_size, NULL, NULL);
cf13d699
NC		 12438 }
12439 else
12440 {
12441 /* If the section being dumped has relocations against it the user might
12442 be expecting these relocations to have been applied. Check for this
12443 case and issue a warning message in order to avoid confusion.
12444 FIXME: Maybe we ought to have an option that dumps a section with
12445 relocs applied ? */
12446 for (relsec = section_headers;
12447 relsec < section_headers + elf_header.e_shnum;
12448 ++relsec)
12449 {
12450 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12451 || relsec->sh_info >= elf_header.e_shnum
12452 || section_headers + relsec->sh_info != section
12453 || relsec->sh_size == 0
12454 || relsec->sh_link >= elf_header.e_shnum)
12455 continue;
12456
12457 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12458 break;
12459 }
12460 }
12461
12462 addr = section->sh_addr;
0e602686 12463 bytes = section_size;
cf13d699
NC		 12464 data = start;
12465
12466 while (bytes)
12467 {
12468 int j;
12469 int k;
12470 int lbytes;
12471
12472 lbytes = (bytes > 16 ? 16 : bytes);
12473
12474 printf (" 0x%8.8lx ", (unsigned long) addr);
12475
12476 for (j = 0; j < 16; j++)
12477 {
12478 if (j < lbytes)
12479 printf ("%2.2x", data[j]);
12480 else
12481 printf (" ");
12482
12483 if ((j & 3) == 3)
12484 printf (" ");
12485 }
12486
12487 for (j = 0; j < lbytes; j++)
12488 {
12489 k = data[j];
12490 if (k >= ' ' && k < 0x7f)
12491 printf ("%c", k);
12492 else
12493 printf (".");
12494 }
12495
12496 putchar ('\n');
12497
12498 data += lbytes;
12499 addr += lbytes;
12500 bytes -= lbytes;
12501 }
12502
0e602686 12503 free (real_start);
cf13d699
NC		 12504
12505 putchar ('\n');
12506}
12507
d966045b
DJ		 12508static int
12509load_specific_debug_section (enum dwarf_section_display_enum debug,
0d2a7a93 12510 const Elf_Internal_Shdr * sec, void * file)
1007acb3 12511{
2cf0635d 12512 struct dwarf_section * section = &debug_displays [debug].section;
19e6b90e 12513 char buf [64];
1007acb3 12514
19e6b90e
L		 12515 /* If it is already loaded, do nothing. */
12516 if (section->start != NULL)
12517 return 1;
1007acb3 12518
19e6b90e
L		 12519 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12520 section->address = sec->sh_addr;
06614111 12521 section->user_data = NULL;
3f5e193b
NC		 12522 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12523 sec->sh_offset, 1,
12524 sec->sh_size, buf);
59245841
NC		 12525 if (section->start == NULL)
12526 section->size = 0;
12527 else
12528 {
77115a4a
L		 12529 unsigned char *start = section->start;
12530 dwarf_size_type size = sec->sh_size;
dab394de 12531 dwarf_size_type uncompressed_size = 0;
77115a4a
L		 12532
12533 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
12534 {
12535 Elf_Internal_Chdr chdr;
12536 unsigned int compression_header_size
12537 = get_compression_header (&chdr, start);
813dabb9
L		 12538 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12539 {
12540 warn (_("section '%s' has unsupported compress type: %d\n"),
12541 section->name, chdr.ch_type);
12542 return 0;
12543 }
12544 else if (chdr.ch_addralign != sec->sh_addralign)
12545 {
12546 warn (_("compressed section '%s' is corrupted\n"),
12547 section->name);
12548 return 0;
12549 }
dab394de 12550 uncompressed_size = chdr.ch_size;
77115a4a
L		 12551 start += compression_header_size;
12552 size -= compression_header_size;
12553 }
dab394de
L		 12554 else if (size > 12 && streq ((char *) start, "ZLIB"))
12555 {
12556 /* Read the zlib header. In this case, it should be "ZLIB"
12557 followed by the uncompressed section size, 8 bytes in
12558 big-endian order. */
12559 uncompressed_size = start[4]; uncompressed_size <<= 8;
12560 uncompressed_size += start[5]; uncompressed_size <<= 8;
12561 uncompressed_size += start[6]; uncompressed_size <<= 8;
12562 uncompressed_size += start[7]; uncompressed_size <<= 8;
12563 uncompressed_size += start[8]; uncompressed_size <<= 8;
12564 uncompressed_size += start[9]; uncompressed_size <<= 8;
12565 uncompressed_size += start[10]; uncompressed_size <<= 8;
12566 uncompressed_size += start[11];
12567 start += 12;
12568 size -= 12;
12569 }
12570
12571 if (uncompressed_size
12572 && uncompress_section_contents (&start, uncompressed_size,
12573 &size))
77115a4a
L		 12574 {
12575 /* Free the compressed buffer, update the section buffer
12576 and the section size if uncompress is successful. */
12577 free (section->start);
12578 section->start = start;
77115a4a
L		 12579 }
12580 section->size = size;
59245841 12581 }
4a114e3e 12582
1b315056
CS		 12583 if (section->start == NULL)
12584 return 0;
12585
19e6b90e 12586 if (debug_displays [debug].relocate)
d1c4b12b
NC		 12587 apply_relocations ((FILE *) file, sec, section->start, section->size,
12588 & section->reloc_info, & section->num_relocs);
12589 else
12590 {
12591 section->reloc_info = NULL;
12592 section->num_relocs = 0;
12593 }
1007acb3 12594
1b315056 12595 return 1;
1007acb3
L		 12596}
12597
657d0d47
CC		 12598/* If this is not NULL, load_debug_section will only look for sections
12599 within the list of sections given here. */
12600unsigned int *section_subset = NULL;
12601
d966045b 12602int
2cf0635d 12603load_debug_section (enum dwarf_section_display_enum debug, void * file)
d966045b 12604{
2cf0635d
NC		 12605 struct dwarf_section * section = &debug_displays [debug].section;
12606 Elf_Internal_Shdr * sec;
d966045b
DJ		 12607
12608 /* Locate the debug section. */
657d0d47 12609 sec = find_section_in_set (section->uncompressed_name, section_subset);
d966045b
DJ		 12610 if (sec != NULL)
12611 section->name = section->uncompressed_name;
12612 else
12613 {
657d0d47 12614 sec = find_section_in_set (section->compressed_name, section_subset);
d966045b
DJ		 12615 if (sec != NULL)
12616 section->name = section->compressed_name;
12617 }
12618 if (sec == NULL)
12619 return 0;
12620
657d0d47
CC		 12621 /* If we're loading from a subset of sections, and we've loaded
12622 a section matching this name before, it's likely that it's a
12623 different one. */
12624 if (section_subset != NULL)
12625 free_debug_section (debug);
12626
3f5e193b 12627 return load_specific_debug_section (debug, sec, (FILE *) file);
d966045b
DJ		 12628}
12629
19e6b90e
L		 12630void
12631free_debug_section (enum dwarf_section_display_enum debug)
1007acb3 12632{
2cf0635d 12633 struct dwarf_section * section = &debug_displays [debug].section;
1007acb3 12634
19e6b90e
L		 12635 if (section->start == NULL)
12636 return;
1007acb3 12637
19e6b90e
L		 12638 free ((char *) section->start);
12639 section->start = NULL;
12640 section->address = 0;
12641 section->size = 0;
1007acb3
L		 12642}
12643
1007acb3 12644static int
657d0d47 12645display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
1007acb3 12646{
2cf0635d 12647 char * name = SECTION_NAME (section);
74e1a04b 12648 const char * print_name = printable_section_name (section);
19e6b90e
L		 12649 bfd_size_type length;
12650 int result = 1;
3f5e193b 12651 int i;
1007acb3 12652
19e6b90e
L		 12653 length = section->sh_size;
12654 if (length == 0)
1007acb3 12655 {
74e1a04b 12656 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
19e6b90e 12657 return 0;
1007acb3 12658 }
5dff79d8
NC		 12659 if (section->sh_type == SHT_NOBITS)
12660 {
12661 /* There is no point in dumping the contents of a debugging section
12662 which has the NOBITS type - the bits in the file will be random.
12663 This can happen when a file containing a .eh_frame section is
12664 stripped with the --only-keep-debug command line option. */
74e1a04b
NC		 12665 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12666 print_name);
5dff79d8
NC		 12667 return 0;
12668 }
1007acb3 12669
0112cd26 12670 if (const_strneq (name, ".gnu.linkonce.wi."))
19e6b90e 12671 name = ".debug_info";
1007acb3 12672
19e6b90e
L		 12673 /* See if we know how to display the contents of this section. */
12674 for (i = 0; i < max; i++)
1b315056 12675 if (streq (debug_displays[i].section.uncompressed_name, name)
b40bf0a2 12676 || (i == line && const_strneq (name, ".debug_line."))
1b315056 12677 || streq (debug_displays[i].section.compressed_name, name))
19e6b90e 12678 {
2cf0635d 12679 struct dwarf_section * sec = &debug_displays [i].section;
d966045b
DJ		 12680 int secondary = (section != find_section (name));
12681
12682 if (secondary)
3f5e193b 12683 free_debug_section ((enum dwarf_section_display_enum) i);
1007acb3 12684
b40bf0a2
NC		 12685 if (i == line && const_strneq (name, ".debug_line."))
12686 sec->name = name;
12687 else if (streq (sec->uncompressed_name, name))
d966045b
DJ		 12688 sec->name = sec->uncompressed_name;
12689 else
12690 sec->name = sec->compressed_name;
3f5e193b
NC		 12691 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12692 section, file))
19e6b90e 12693 {
657d0d47
CC		 12694 /* If this debug section is part of a CU/TU set in a .dwp file,
12695 restrict load_debug_section to the sections in that set. */
12696 section_subset = find_cu_tu_set (file, shndx);
12697
19e6b90e 12698 result &= debug_displays[i].display (sec, file);
1007acb3 12699
657d0d47
CC		 12700 section_subset = NULL;
12701
d966045b 12702 if (secondary || (i != info && i != abbrev))
3f5e193b 12703 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 12704 }
1007acb3 12705
19e6b90e
L		 12706 break;
12707 }
1007acb3 12708
19e6b90e 12709 if (i == max)
1007acb3 12710 {
74e1a04b 12711 printf (_("Unrecognized debug section: %s\n"), print_name);
19e6b90e 12712 result = 0;
1007acb3
L		 12713 }
12714
19e6b90e 12715 return result;
5b18a4bc 12716}
103f02d3 12717
aef1f6d0
DJ		 12718/* Set DUMP_SECTS for all sections where dumps were requested
12719 based on section name. */
12720
12721static void
12722initialise_dumps_byname (void)
12723{
2cf0635d 12724 struct dump_list_entry * cur;
aef1f6d0
DJ		 12725
12726 for (cur = dump_sects_byname; cur; cur = cur->next)
12727 {
12728 unsigned int i;
12729 int any;
12730
12731 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12732 if (streq (SECTION_NAME (section_headers + i), cur->name))
12733 {
09c11c86 12734 request_dump_bynumber (i, cur->type);
aef1f6d0
DJ		 12735 any = 1;
12736 }
12737
12738 if (!any)
12739 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12740 cur->name);
12741 }
12742}
12743
5b18a4bc 12744static void
2cf0635d 12745process_section_contents (FILE * file)
5b18a4bc 12746{
2cf0635d 12747 Elf_Internal_Shdr * section;
19e6b90e 12748 unsigned int i;
103f02d3 12749
19e6b90e
L		 12750 if (! do_dump)
12751 return;
103f02d3 12752
aef1f6d0
DJ		 12753 initialise_dumps_byname ();
12754
19e6b90e
L		 12755 for (i = 0, section = section_headers;
12756 i < elf_header.e_shnum && i < num_dump_sects;
12757 i++, section++)
12758 {
12759#ifdef SUPPORT_DISASSEMBLY
12760 if (dump_sects[i] & DISASS_DUMP)
12761 disassemble_section (section, file);
12762#endif
12763 if (dump_sects[i] & HEX_DUMP)
cf13d699 12764 dump_section_as_bytes (section, file, FALSE);
103f02d3 12765
cf13d699
NC		 12766 if (dump_sects[i] & RELOC_DUMP)
12767 dump_section_as_bytes (section, file, TRUE);
09c11c86
NC		 12768
12769 if (dump_sects[i] & STRING_DUMP)
12770 dump_section_as_strings (section, file);
cf13d699
NC		 12771
12772 if (dump_sects[i] & DEBUG_DUMP)
657d0d47 12773 display_debug_section (i, section, file);
5b18a4bc 12774 }
103f02d3 12775
19e6b90e
L		 12776 /* Check to see if the user requested a
12777 dump of a section that does not exist. */
12778 while (i++ < num_dump_sects)
12779 if (dump_sects[i])
12780 warn (_("Section %d was not dumped because it does not exist!\n"), i);
5b18a4bc 12781}
103f02d3 12782
5b18a4bc 12783static void
19e6b90e 12784process_mips_fpe_exception (int mask)
5b18a4bc 12785{
19e6b90e
L		 12786 if (mask)
12787 {
12788 int first = 1;
12789 if (mask & OEX_FPU_INEX)
12790 fputs ("INEX", stdout), first = 0;
12791 if (mask & OEX_FPU_UFLO)
12792 printf ("%sUFLO", first ? "" : "|"), first = 0;
12793 if (mask & OEX_FPU_OFLO)
12794 printf ("%sOFLO", first ? "" : "|"), first = 0;
12795 if (mask & OEX_FPU_DIV0)
12796 printf ("%sDIV0", first ? "" : "|"), first = 0;
12797 if (mask & OEX_FPU_INVAL)
12798 printf ("%sINVAL", first ? "" : "|");
12799 }
5b18a4bc 12800 else
19e6b90e 12801 fputs ("0", stdout);
5b18a4bc 12802}
103f02d3 12803
f6f0e17b
NC		 12804/* Display's the value of TAG at location P. If TAG is
12805 greater than 0 it is assumed to be an unknown tag, and
12806 a message is printed to this effect. Otherwise it is
12807 assumed that a message has already been printed.
12808
12809 If the bottom bit of TAG is set it assumed to have a
12810 string value, otherwise it is assumed to have an integer
12811 value.
12812
12813 Returns an updated P pointing to the first unread byte
12814 beyond the end of TAG's value.
12815
12816 Reads at or beyond END will not be made. */
12817
12818static unsigned char *
12819display_tag_value (int tag,
12820 unsigned char * p,
12821 const unsigned char * const end)
12822{
12823 unsigned long val;
12824
12825 if (tag > 0)
12826 printf (" Tag_unknown_%d: ", tag);
12827
12828 if (p >= end)
12829 {
4082ef84 12830 warn (_("<corrupt tag>\n"));
f6f0e17b
NC		 12831 }
12832 else if (tag & 1)
12833 {
071436c6
NC		 12834 /* PR 17531 file: 027-19978-0.004. */
12835 size_t maxlen = (end - p) - 1;
12836
12837 putchar ('"');
4082ef84
NC		 12838 if (maxlen > 0)
12839 {
12840 print_symbol ((int) maxlen, (const char *) p);
12841 p += strnlen ((char *) p, maxlen) + 1;
12842 }
12843 else
12844 {
12845 printf (_("<corrupt string tag>"));
12846 p = (unsigned char *) end;
12847 }
071436c6 12848 printf ("\"\n");
f6f0e17b
NC		 12849 }
12850 else
12851 {
12852 unsigned int len;
12853
12854 val = read_uleb128 (p, &len, end);
12855 p += len;
12856 printf ("%ld (0x%lx)\n", val, val);
12857 }
12858
4082ef84 12859 assert (p <= end);
f6f0e17b
NC		 12860 return p;
12861}
12862
11c1ff18
PB		 12863/* ARM EABI attributes section. */
12864typedef struct
12865{
70e99720 12866 unsigned int tag;
2cf0635d 12867 const char * name;
11c1ff18 12868 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
70e99720 12869 unsigned int type;
2cf0635d 12870 const char ** table;
11c1ff18
PB		 12871} arm_attr_public_tag;
12872
2cf0635d 12873static const char * arm_attr_tag_CPU_arch[] =
11c1ff18 12874 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
ff8646ee
TP		 12875 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
12876 "v8-M.mainline"};
2cf0635d
NC		 12877static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12878static const char * arm_attr_tag_THUMB_ISA_use[] =
4ed7ed8d 12879 {"No", "Thumb-1", "Thumb-2", "Yes"};
75375b3e 12880static const char * arm_attr_tag_FP_arch[] =
bca38921 12881 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
a715796b 12882 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
2cf0635d 12883static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
dd24e3da 12884static const char * arm_attr_tag_Advanced_SIMD_arch[] =
9411fd44
MW		 12885 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
12886 "NEON for ARMv8.1"};
2cf0635d 12887static const char * arm_attr_tag_PCS_config[] =
11c1ff18
PB		 12888 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12889 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
2cf0635d 12890static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11c1ff18 12891 {"V6", "SB", "TLS", "Unused"};
2cf0635d 12892static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11c1ff18 12893 {"Absolute", "PC-relative", "SB-relative", "None"};
2cf0635d 12894static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11c1ff18 12895 {"Absolute", "PC-relative", "None"};
2cf0635d 12896static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11c1ff18 12897 {"None", "direct", "GOT-indirect"};
2cf0635d 12898static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11c1ff18 12899 {"None", "??? 1", "2", "??? 3", "4"};
2cf0635d
NC		 12900static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12901static const char * arm_attr_tag_ABI_FP_denormal[] =
f5f53991 12902 {"Unused", "Needed", "Sign only"};
2cf0635d
NC		 12903static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12904static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12905static const char * arm_attr_tag_ABI_FP_number_model[] =
11c1ff18 12906 {"Unused", "Finite", "RTABI", "IEEE 754"};
2cf0635d 12907static const char * arm_attr_tag_ABI_enum_size[] =
11c1ff18 12908 {"Unused", "small", "int", "forced to int"};
2cf0635d 12909static const char * arm_attr_tag_ABI_HardFP_use[] =
99654aaf 12910 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
2cf0635d 12911static const char * arm_attr_tag_ABI_VFP_args[] =
5c294fee 12912 {"AAPCS", "VFP registers", "custom", "compatible"};
2cf0635d 12913static const char * arm_attr_tag_ABI_WMMX_args[] =
11c1ff18 12914 {"AAPCS", "WMMX registers", "custom"};
2cf0635d 12915static const char * arm_attr_tag_ABI_optimization_goals[] =
11c1ff18
PB		 12916 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12917 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
2cf0635d 12918static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11c1ff18
PB		 12919 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12920 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
2cf0635d 12921static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
75375b3e 12922static const char * arm_attr_tag_FP_HP_extension[] =
8e79c3df 12923 {"Not Allowed", "Allowed"};
2cf0635d 12924static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8e79c3df 12925 {"None", "IEEE 754", "Alternative Format"};
dd24e3da 12926static const char * arm_attr_tag_MPextension_use[] =
cd21e546
MGD		 12927 {"Not Allowed", "Allowed"};
12928static const char * arm_attr_tag_DIV_use[] =
dd24e3da 12929 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
cd21e546 12930 "Allowed in v7-A with integer division extension"};
2cf0635d
NC		 12931static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12932static const char * arm_attr_tag_Virtualization_use[] =
dd24e3da 12933 {"Not Allowed", "TrustZone", "Virtualization Extensions",
cd21e546 12934 "TrustZone and Virtualization Extensions"};
dd24e3da 12935static const char * arm_attr_tag_MPextension_use_legacy[] =
f5f53991 12936 {"Not Allowed", "Allowed"};
11c1ff18
PB		 12937
12938#define LOOKUP(id, name) \
12939 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
d70c5fc7 12940static arm_attr_public_tag arm_attr_public_tags[] =
11c1ff18
PB		 12941{
12942 {4, "CPU_raw_name", 1, NULL},
12943 {5, "CPU_name", 1, NULL},
12944 LOOKUP(6, CPU_arch),
12945 {7, "CPU_arch_profile", 0, NULL},
12946 LOOKUP(8, ARM_ISA_use),
12947 LOOKUP(9, THUMB_ISA_use),
75375b3e 12948 LOOKUP(10, FP_arch),
11c1ff18 12949 LOOKUP(11, WMMX_arch),
f5f53991
AS		 12950 LOOKUP(12, Advanced_SIMD_arch),
12951 LOOKUP(13, PCS_config),
11c1ff18
PB		 12952 LOOKUP(14, ABI_PCS_R9_use),
12953 LOOKUP(15, ABI_PCS_RW_data),
f5f53991 12954 LOOKUP(16, ABI_PCS_RO_data),
11c1ff18
PB		 12955 LOOKUP(17, ABI_PCS_GOT_use),
12956 LOOKUP(18, ABI_PCS_wchar_t),
12957 LOOKUP(19, ABI_FP_rounding),
12958 LOOKUP(20, ABI_FP_denormal),
12959 LOOKUP(21, ABI_FP_exceptions),
12960 LOOKUP(22, ABI_FP_user_exceptions),
12961 LOOKUP(23, ABI_FP_number_model),
75375b3e
MGD		 12962 {24, "ABI_align_needed", 0, NULL},
12963 {25, "ABI_align_preserved", 0, NULL},
11c1ff18
PB		 12964 LOOKUP(26, ABI_enum_size),
12965 LOOKUP(27, ABI_HardFP_use),
12966 LOOKUP(28, ABI_VFP_args),
12967 LOOKUP(29, ABI_WMMX_args),
12968 LOOKUP(30, ABI_optimization_goals),
12969 LOOKUP(31, ABI_FP_optimization_goals),
8e79c3df 12970 {32, "compatibility", 0, NULL},
f5f53991 12971 LOOKUP(34, CPU_unaligned_access),
75375b3e 12972 LOOKUP(36, FP_HP_extension),
8e79c3df 12973 LOOKUP(38, ABI_FP_16bit_format),
cd21e546
MGD		 12974 LOOKUP(42, MPextension_use),
12975 LOOKUP(44, DIV_use),
f5f53991
AS		 12976 {64, "nodefaults", 0, NULL},
12977 {65, "also_compatible_with", 0, NULL},
12978 LOOKUP(66, T2EE_use),
12979 {67, "conformance", 1, NULL},
12980 LOOKUP(68, Virtualization_use),
cd21e546 12981 LOOKUP(70, MPextension_use_legacy)
11c1ff18
PB		 12982};
12983#undef LOOKUP
12984
11c1ff18 12985static unsigned char *
f6f0e17b
NC		 12986display_arm_attribute (unsigned char * p,
12987 const unsigned char * const end)
11c1ff18 12988{
70e99720 12989 unsigned int tag;
11c1ff18 12990 unsigned int len;
70e99720 12991 unsigned int val;
2cf0635d 12992 arm_attr_public_tag * attr;
11c1ff18 12993 unsigned i;
70e99720 12994 unsigned int type;
11c1ff18 12995
f6f0e17b 12996 tag = read_uleb128 (p, &len, end);
11c1ff18
PB		 12997 p += len;
12998 attr = NULL;
2cf0635d 12999 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11c1ff18
PB		 13000 {
13001 if (arm_attr_public_tags[i].tag == tag)
13002 {
13003 attr = &arm_attr_public_tags[i];
13004 break;
13005 }
13006 }
13007
13008 if (attr)
13009 {
13010 printf (" Tag_%s: ", attr->name);
13011 switch (attr->type)
13012 {
13013 case 0:
13014 switch (tag)
13015 {
13016 case 7: /* Tag_CPU_arch_profile. */
f6f0e17b 13017 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 13018 p += len;
13019 switch (val)
13020 {
2b692964
NC		 13021 case 0: printf (_("None\n")); break;
13022 case 'A': printf (_("Application\n")); break;
13023 case 'R': printf (_("Realtime\n")); break;
13024 case 'M': printf (_("Microcontroller\n")); break;
13025 case 'S': printf (_("Application or Realtime\n")); break;
11c1ff18
PB		 13026 default: printf ("??? (%d)\n", val); break;
13027 }
13028 break;
13029
75375b3e 13030 case 24: /* Tag_align_needed. */
f6f0e17b 13031 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 13032 p += len;
13033 switch (val)
13034 {
2b692964
NC		 13035 case 0: printf (_("None\n")); break;
13036 case 1: printf (_("8-byte\n")); break;
13037 case 2: printf (_("4-byte\n")); break;
75375b3e
MGD		 13038 case 3: printf ("??? 3\n"); break;
13039 default:
13040 if (val <= 12)
dd24e3da 13041 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 13042 1 << val);
13043 else
13044 printf ("??? (%d)\n", val);
13045 break;
13046 }
13047 break;
13048
13049 case 25: /* Tag_align_preserved. */
f6f0e17b 13050 val = read_uleb128 (p, &len, end);
75375b3e
MGD		 13051 p += len;
13052 switch (val)
13053 {
2b692964
NC		 13054 case 0: printf (_("None\n")); break;
13055 case 1: printf (_("8-byte, except leaf SP\n")); break;
13056 case 2: printf (_("8-byte\n")); break;
75375b3e
MGD		 13057 case 3: printf ("??? 3\n"); break;
13058 default:
13059 if (val <= 12)
dd24e3da 13060 printf (_("8-byte and up to %d-byte extended\n"),
75375b3e
MGD		 13061 1 << val);
13062 else
13063 printf ("??? (%d)\n", val);
13064 break;
13065 }
13066 break;
13067
11c1ff18 13068 case 32: /* Tag_compatibility. */
071436c6 13069 {
071436c6
NC		 13070 val = read_uleb128 (p, &len, end);
13071 p += len;
071436c6 13072 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 13073 if (p < end - 1)
13074 {
13075 size_t maxlen = (end - p) - 1;
13076
13077 print_symbol ((int) maxlen, (const char *) p);
13078 p += strnlen ((char *) p, maxlen) + 1;
13079 }
13080 else
13081 {
13082 printf (_("<corrupt>"));
13083 p = (unsigned char *) end;
13084 }
071436c6 13085 putchar ('\n');
071436c6 13086 }
11c1ff18
PB		 13087 break;
13088
f5f53991 13089 case 64: /* Tag_nodefaults. */
541a3cbd
NC		 13090 /* PR 17531: file: 001-505008-0.01. */
13091 if (p < end)
13092 p++;
2b692964 13093 printf (_("True\n"));
f5f53991
AS		 13094 break;
13095
13096 case 65: /* Tag_also_compatible_with. */
f6f0e17b 13097 val = read_uleb128 (p, &len, end);
f5f53991
AS		 13098 p += len;
13099 if (val == 6 /* Tag_CPU_arch. */)
13100 {
f6f0e17b 13101 val = read_uleb128 (p, &len, end);
f5f53991 13102 p += len;
071436c6 13103 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
f5f53991
AS		 13104 printf ("??? (%d)\n", val);
13105 else
13106 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
13107 }
13108 else
13109 printf ("???\n");
071436c6
NC		 13110 while (p < end && *(p++) != '\0' /* NUL terminator. */)
13111 ;
f5f53991
AS		 13112 break;
13113
11c1ff18 13114 default:
bee0ee85
NC		 13115 printf (_("<unknown: %d>\n"), tag);
13116 break;
11c1ff18
PB		 13117 }
13118 return p;
13119
13120 case 1:
f6f0e17b 13121 return display_tag_value (-1, p, end);
11c1ff18 13122 case 2:
f6f0e17b 13123 return display_tag_value (0, p, end);
11c1ff18
PB		 13124
13125 default:
13126 assert (attr->type & 0x80);
f6f0e17b 13127 val = read_uleb128 (p, &len, end);
11c1ff18
PB		 13128 p += len;
13129 type = attr->type & 0x7f;
13130 if (val >= type)
13131 printf ("??? (%d)\n", val);
13132 else
13133 printf ("%s\n", attr->table[val]);
13134 return p;
13135 }
13136 }
11c1ff18 13137
f6f0e17b 13138 return display_tag_value (tag, p, end);
11c1ff18
PB		 13139}
13140
104d59d1 13141static unsigned char *
60bca95a 13142display_gnu_attribute (unsigned char * p,
f6f0e17b
NC		 13143 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
13144 const unsigned char * const end)
104d59d1
JM		 13145{
13146 int tag;
13147 unsigned int len;
13148 int val;
104d59d1 13149
f6f0e17b 13150 tag = read_uleb128 (p, &len, end);
104d59d1
JM		 13151 p += len;
13152
13153 /* Tag_compatibility is the only generic GNU attribute defined at
13154 present. */
13155 if (tag == 32)
13156 {
f6f0e17b 13157 val = read_uleb128 (p, &len, end);
104d59d1 13158 p += len;
071436c6
NC		 13159
13160 printf (_("flag = %d, vendor = "), val);
f6f0e17b
NC		 13161 if (p == end)
13162 {
071436c6 13163 printf (_("<corrupt>\n"));
f6f0e17b
NC		 13164 warn (_("corrupt vendor attribute\n"));
13165 }
13166 else
13167 {
4082ef84
NC		 13168 if (p < end - 1)
13169 {
13170 size_t maxlen = (end - p) - 1;
071436c6 13171
4082ef84
NC		 13172 print_symbol ((int) maxlen, (const char *) p);
13173 p += strnlen ((char *) p, maxlen) + 1;
13174 }
13175 else
13176 {
13177 printf (_("<corrupt>"));
13178 p = (unsigned char *) end;
13179 }
071436c6 13180 putchar ('\n');
f6f0e17b 13181 }
104d59d1
JM		 13182 return p;
13183 }
13184
13185 if ((tag & 2) == 0 && display_proc_gnu_attribute)
f6f0e17b 13186 return display_proc_gnu_attribute (p, tag, end);
104d59d1 13187
f6f0e17b 13188 return display_tag_value (tag, p, end);
104d59d1
JM		 13189}
13190
34c8bcba 13191static unsigned char *
f6f0e17b
NC		 13192display_power_gnu_attribute (unsigned char * p,
13193 int tag,
13194 const unsigned char * const end)
34c8bcba 13195{
34c8bcba
JM		 13196 unsigned int len;
13197 int val;
13198
13199 if (tag == Tag_GNU_Power_ABI_FP)
13200 {
f6f0e17b 13201 val = read_uleb128 (p, &len, end);
34c8bcba
JM		 13202 p += len;
13203 printf (" Tag_GNU_Power_ABI_FP: ");
60bca95a 13204
34c8bcba
JM		 13205 switch (val)
13206 {
13207 case 0:
2b692964 13208 printf (_("Hard or soft float\n"));
34c8bcba
JM		 13209 break;
13210 case 1:
2b692964 13211 printf (_("Hard float\n"));
34c8bcba
JM		 13212 break;
13213 case 2:
2b692964 13214 printf (_("Soft float\n"));
34c8bcba 13215 break;
3c7b9897 13216 case 3:
2b692964 13217 printf (_("Single-precision hard float\n"));
3c7b9897 13218 break;
34c8bcba
JM		 13219 default:
13220 printf ("??? (%d)\n", val);
13221 break;
13222 }
13223 return p;
13224 }
13225
c6e65352
DJ		 13226 if (tag == Tag_GNU_Power_ABI_Vector)
13227 {
f6f0e17b 13228 val = read_uleb128 (p, &len, end);
c6e65352
DJ		 13229 p += len;
13230 printf (" Tag_GNU_Power_ABI_Vector: ");
13231 switch (val)
13232 {
13233 case 0:
2b692964 13234 printf (_("Any\n"));
c6e65352
DJ		 13235 break;
13236 case 1:
2b692964 13237 printf (_("Generic\n"));
c6e65352
DJ		 13238 break;
13239 case 2:
13240 printf ("AltiVec\n");
13241 break;
13242 case 3:
13243 printf ("SPE\n");
13244 break;
13245 default:
13246 printf ("??? (%d)\n", val);
13247 break;
13248 }
13249 return p;
13250 }
13251
f82e0623
NF		 13252 if (tag == Tag_GNU_Power_ABI_Struct_Return)
13253 {
f6f0e17b
NC		 13254 if (p == end)
13255 {
071436c6 13256 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
f6f0e17b
NC		 13257 return p;
13258 }
0b4362b0 13259
f6f0e17b 13260 val = read_uleb128 (p, &len, end);
f82e0623
NF		 13261 p += len;
13262 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13263 switch (val)
13264 {
13265 case 0:
2b692964 13266 printf (_("Any\n"));
f82e0623
NF		 13267 break;
13268 case 1:
13269 printf ("r3/r4\n");
13270 break;
13271 case 2:
2b692964 13272 printf (_("Memory\n"));
f82e0623
NF		 13273 break;
13274 default:
13275 printf ("??? (%d)\n", val);
13276 break;
13277 }
13278 return p;
13279 }
13280
f6f0e17b 13281 return display_tag_value (tag & 1, p, end);
34c8bcba
JM		 13282}
13283
643f7afb
AK		 13284static unsigned char *
13285display_s390_gnu_attribute (unsigned char * p,
13286 int tag,
13287 const unsigned char * const end)
13288{
13289 unsigned int len;
13290 int val;
13291
13292 if (tag == Tag_GNU_S390_ABI_Vector)
13293 {
13294 val = read_uleb128 (p, &len, end);
13295 p += len;
13296 printf (" Tag_GNU_S390_ABI_Vector: ");
13297
13298 switch (val)
13299 {
13300 case 0:
13301 printf (_("any\n"));
13302 break;
13303 case 1:
13304 printf (_("software\n"));
13305 break;
13306 case 2:
13307 printf (_("hardware\n"));
13308 break;
13309 default:
13310 printf ("??? (%d)\n", val);
13311 break;
13312 }
13313 return p;
13314 }
13315
13316 return display_tag_value (tag & 1, p, end);
13317}
13318
9e8c70f9
DM		 13319static void
13320display_sparc_hwcaps (int mask)
13321{
13322 if (mask)
13323 {
13324 int first = 1;
071436c6 13325
9e8c70f9
DM		 13326 if (mask & ELF_SPARC_HWCAP_MUL32)
13327 fputs ("mul32", stdout), first = 0;
13328 if (mask & ELF_SPARC_HWCAP_DIV32)
13329 printf ("%sdiv32", first ? "" : "|"), first = 0;
13330 if (mask & ELF_SPARC_HWCAP_FSMULD)
13331 printf ("%sfsmuld", first ? "" : "|"), first = 0;
13332 if (mask & ELF_SPARC_HWCAP_V8PLUS)
13333 printf ("%sv8plus", first ? "" : "|"), first = 0;
13334 if (mask & ELF_SPARC_HWCAP_POPC)
13335 printf ("%spopc", first ? "" : "|"), first = 0;
13336 if (mask & ELF_SPARC_HWCAP_VIS)
13337 printf ("%svis", first ? "" : "|"), first = 0;
13338 if (mask & ELF_SPARC_HWCAP_VIS2)
13339 printf ("%svis2", first ? "" : "|"), first = 0;
13340 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
13341 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
13342 if (mask & ELF_SPARC_HWCAP_FMAF)
13343 printf ("%sfmaf", first ? "" : "|"), first = 0;
13344 if (mask & ELF_SPARC_HWCAP_VIS3)
13345 printf ("%svis3", first ? "" : "|"), first = 0;
13346 if (mask & ELF_SPARC_HWCAP_HPC)
13347 printf ("%shpc", first ? "" : "|"), first = 0;
13348 if (mask & ELF_SPARC_HWCAP_RANDOM)
13349 printf ("%srandom", first ? "" : "|"), first = 0;
13350 if (mask & ELF_SPARC_HWCAP_TRANS)
13351 printf ("%strans", first ? "" : "|"), first = 0;
13352 if (mask & ELF_SPARC_HWCAP_FJFMAU)
13353 printf ("%sfjfmau", first ? "" : "|"), first = 0;
13354 if (mask & ELF_SPARC_HWCAP_IMA)
13355 printf ("%sima", first ? "" : "|"), first = 0;
13356 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
13357 printf ("%scspare", first ? "" : "|"), first = 0;
13358 }
13359 else
071436c6
NC		 13360 fputc ('0', stdout);
13361 fputc ('\n', stdout);
9e8c70f9
DM		 13362}
13363
3d68f91c
JM		 13364static void
13365display_sparc_hwcaps2 (int mask)
13366{
13367 if (mask)
13368 {
13369 int first = 1;
071436c6 13370
3d68f91c
JM		 13371 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
13372 fputs ("fjathplus", stdout), first = 0;
13373 if (mask & ELF_SPARC_HWCAP2_VIS3B)
13374 printf ("%svis3b", first ? "" : "|"), first = 0;
13375 if (mask & ELF_SPARC_HWCAP2_ADP)
13376 printf ("%sadp", first ? "" : "|"), first = 0;
13377 if (mask & ELF_SPARC_HWCAP2_SPARC5)
13378 printf ("%ssparc5", first ? "" : "|"), first = 0;
13379 if (mask & ELF_SPARC_HWCAP2_MWAIT)
13380 printf ("%smwait", first ? "" : "|"), first = 0;
13381 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
13382 printf ("%sxmpmul", first ? "" : "|"), first = 0;
13383 if (mask & ELF_SPARC_HWCAP2_XMONT)
13384 printf ("%sxmont2", first ? "" : "|"), first = 0;
13385 if (mask & ELF_SPARC_HWCAP2_NSEC)
13386 printf ("%snsec", first ? "" : "|"), first = 0;
13387 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
13388 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
13389 if (mask & ELF_SPARC_HWCAP2_FJDES)
13390 printf ("%sfjdes", first ? "" : "|"), first = 0;
13391 if (mask & ELF_SPARC_HWCAP2_FJAES)
13392 printf ("%sfjaes", first ? "" : "|"), first = 0;
13393 }
13394 else
071436c6
NC		 13395 fputc ('0', stdout);
13396 fputc ('\n', stdout);
3d68f91c
JM		 13397}
13398
9e8c70f9 13399static unsigned char *
f6f0e17b
NC		 13400display_sparc_gnu_attribute (unsigned char * p,
13401 int tag,
13402 const unsigned char * const end)
9e8c70f9 13403{
3d68f91c
JM		 13404 unsigned int len;
13405 int val;
13406
9e8c70f9
DM		 13407 if (tag == Tag_GNU_Sparc_HWCAPS)
13408 {
f6f0e17b 13409 val = read_uleb128 (p, &len, end);
9e8c70f9
DM		 13410 p += len;
13411 printf (" Tag_GNU_Sparc_HWCAPS: ");
9e8c70f9
DM		 13412 display_sparc_hwcaps (val);
13413 return p;
3d68f91c
JM		 13414 }
13415 if (tag == Tag_GNU_Sparc_HWCAPS2)
13416 {
13417 val = read_uleb128 (p, &len, end);
13418 p += len;
13419 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13420 display_sparc_hwcaps2 (val);
13421 return p;
13422 }
9e8c70f9 13423
f6f0e17b 13424 return display_tag_value (tag, p, end);
9e8c70f9
DM		 13425}
13426
351cdf24
MF		 13427static void
13428print_mips_fp_abi_value (int val)
13429{
13430 switch (val)
13431 {
13432 case Val_GNU_MIPS_ABI_FP_ANY:
13433 printf (_("Hard or soft float\n"));
13434 break;
13435 case Val_GNU_MIPS_ABI_FP_DOUBLE:
13436 printf (_("Hard float (double precision)\n"));
13437 break;
13438 case Val_GNU_MIPS_ABI_FP_SINGLE:
13439 printf (_("Hard float (single precision)\n"));
13440 break;
13441 case Val_GNU_MIPS_ABI_FP_SOFT:
13442 printf (_("Soft float\n"));
13443 break;
13444 case Val_GNU_MIPS_ABI_FP_OLD_64:
13445 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13446 break;
13447 case Val_GNU_MIPS_ABI_FP_XX:
13448 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13449 break;
13450 case Val_GNU_MIPS_ABI_FP_64:
13451 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13452 break;
13453 case Val_GNU_MIPS_ABI_FP_64A:
13454 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13455 break;
3350cc01
CM		 13456 case Val_GNU_MIPS_ABI_FP_NAN2008:
13457 printf (_("NaN 2008 compatibility\n"));
13458 break;
351cdf24
MF		 13459 default:
13460 printf ("??? (%d)\n", val);
13461 break;
13462 }
13463}
13464
2cf19d5c 13465static unsigned char *
f6f0e17b
NC		 13466display_mips_gnu_attribute (unsigned char * p,
13467 int tag,
13468 const unsigned char * const end)
2cf19d5c 13469{
2cf19d5c
JM		 13470 if (tag == Tag_GNU_MIPS_ABI_FP)
13471 {
f6f0e17b
NC		 13472 unsigned int len;
13473 int val;
13474
13475 val = read_uleb128 (p, &len, end);
2cf19d5c
JM		 13476 p += len;
13477 printf (" Tag_GNU_MIPS_ABI_FP: ");
60bca95a 13478
351cdf24
MF		 13479 print_mips_fp_abi_value (val);
13480
2cf19d5c
JM		 13481 return p;
13482 }
13483
a9f58168
CF		 13484 if (tag == Tag_GNU_MIPS_ABI_MSA)
13485 {
13486 unsigned int len;
13487 int val;
13488
13489 val = read_uleb128 (p, &len, end);
13490 p += len;
13491 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13492
13493 switch (val)
13494 {
13495 case Val_GNU_MIPS_ABI_MSA_ANY:
13496 printf (_("Any MSA or not\n"));
13497 break;
13498 case Val_GNU_MIPS_ABI_MSA_128:
13499 printf (_("128-bit MSA\n"));
13500 break;
13501 default:
13502 printf ("??? (%d)\n", val);
13503 break;
13504 }
13505 return p;
13506 }
13507
f6f0e17b 13508 return display_tag_value (tag & 1, p, end);
2cf19d5c
JM		 13509}
13510
59e6276b 13511static unsigned char *
f6f0e17b
NC		 13512display_tic6x_attribute (unsigned char * p,
13513 const unsigned char * const end)
59e6276b
JM		 13514{
13515 int tag;
13516 unsigned int len;
13517 int val;
13518
f6f0e17b 13519 tag = read_uleb128 (p, &len, end);
59e6276b
JM		 13520 p += len;
13521
13522 switch (tag)
13523 {
75fa6dc1 13524 case Tag_ISA:
f6f0e17b 13525 val = read_uleb128 (p, &len, end);
59e6276b 13526 p += len;
75fa6dc1 13527 printf (" Tag_ISA: ");
59e6276b
JM		 13528
13529 switch (val)
13530 {
75fa6dc1 13531 case C6XABI_Tag_ISA_none:
59e6276b
JM		 13532 printf (_("None\n"));
13533 break;
75fa6dc1 13534 case C6XABI_Tag_ISA_C62X:
59e6276b
JM		 13535 printf ("C62x\n");
13536 break;
75fa6dc1 13537 case C6XABI_Tag_ISA_C67X:
59e6276b
JM		 13538 printf ("C67x\n");
13539 break;
75fa6dc1 13540 case C6XABI_Tag_ISA_C67XP:
59e6276b
JM		 13541 printf ("C67x+\n");
13542 break;
75fa6dc1 13543 case C6XABI_Tag_ISA_C64X:
59e6276b
JM		 13544 printf ("C64x\n");
13545 break;
75fa6dc1 13546 case C6XABI_Tag_ISA_C64XP:
59e6276b
JM		 13547 printf ("C64x+\n");
13548 break;
75fa6dc1 13549 case C6XABI_Tag_ISA_C674X:
59e6276b
JM		 13550 printf ("C674x\n");
13551 break;
13552 default:
13553 printf ("??? (%d)\n", val);
13554 break;
13555 }
13556 return p;
13557
87779176 13558 case Tag_ABI_wchar_t:
f6f0e17b 13559 val = read_uleb128 (p, &len, end);
87779176
JM		 13560 p += len;
13561 printf (" Tag_ABI_wchar_t: ");
13562 switch (val)
13563 {
13564 case 0:
13565 printf (_("Not used\n"));
13566 break;
13567 case 1:
13568 printf (_("2 bytes\n"));
13569 break;
13570 case 2:
13571 printf (_("4 bytes\n"));
13572 break;
13573 default:
13574 printf ("??? (%d)\n", val);
13575 break;
13576 }
13577 return p;
13578
13579 case Tag_ABI_stack_align_needed:
f6f0e17b 13580 val = read_uleb128 (p, &len, end);
87779176
JM		 13581 p += len;
13582 printf (" Tag_ABI_stack_align_needed: ");
13583 switch (val)
13584 {
13585 case 0:
13586 printf (_("8-byte\n"));
13587 break;
13588 case 1:
13589 printf (_("16-byte\n"));
13590 break;
13591 default:
13592 printf ("??? (%d)\n", val);
13593 break;
13594 }
13595 return p;
13596
13597 case Tag_ABI_stack_align_preserved:
f6f0e17b 13598 val = read_uleb128 (p, &len, end);
87779176
JM		 13599 p += len;
13600 printf (" Tag_ABI_stack_align_preserved: ");
13601 switch (val)
13602 {
13603 case 0:
13604 printf (_("8-byte\n"));
13605 break;
13606 case 1:
13607 printf (_("16-byte\n"));
13608 break;
13609 default:
13610 printf ("??? (%d)\n", val);
13611 break;
13612 }
13613 return p;
13614
b5593623 13615 case Tag_ABI_DSBT:
f6f0e17b 13616 val = read_uleb128 (p, &len, end);
b5593623
JM		 13617 p += len;
13618 printf (" Tag_ABI_DSBT: ");
13619 switch (val)
13620 {
13621 case 0:
13622 printf (_("DSBT addressing not used\n"));
13623 break;
13624 case 1:
13625 printf (_("DSBT addressing used\n"));
13626 break;
13627 default:
13628 printf ("??? (%d)\n", val);
13629 break;
13630 }
13631 return p;
13632
87779176 13633 case Tag_ABI_PID:
f6f0e17b 13634 val = read_uleb128 (p, &len, end);
87779176
JM		 13635 p += len;
13636 printf (" Tag_ABI_PID: ");
13637 switch (val)
13638 {
13639 case 0:
13640 printf (_("Data addressing position-dependent\n"));
13641 break;
13642 case 1:
13643 printf (_("Data addressing position-independent, GOT near DP\n"));
13644 break;
13645 case 2:
13646 printf (_("Data addressing position-independent, GOT far from DP\n"));
13647 break;
13648 default:
13649 printf ("??? (%d)\n", val);
13650 break;
13651 }
13652 return p;
13653
13654 case Tag_ABI_PIC:
f6f0e17b 13655 val = read_uleb128 (p, &len, end);
87779176
JM		 13656 p += len;
13657 printf (" Tag_ABI_PIC: ");
13658 switch (val)
13659 {
13660 case 0:
13661 printf (_("Code addressing position-dependent\n"));
13662 break;
13663 case 1:
13664 printf (_("Code addressing position-independent\n"));
13665 break;
13666 default:
13667 printf ("??? (%d)\n", val);
13668 break;
13669 }
13670 return p;
13671
13672 case Tag_ABI_array_object_alignment:
f6f0e17b 13673 val = read_uleb128 (p, &len, end);
87779176
JM		 13674 p += len;
13675 printf (" Tag_ABI_array_object_alignment: ");
13676 switch (val)
13677 {
13678 case 0:
13679 printf (_("8-byte\n"));
13680 break;
13681 case 1:
13682 printf (_("4-byte\n"));
13683 break;
13684 case 2:
13685 printf (_("16-byte\n"));
13686 break;
13687 default:
13688 printf ("??? (%d)\n", val);
13689 break;
13690 }
13691 return p;
13692
13693 case Tag_ABI_array_object_align_expected:
f6f0e17b 13694 val = read_uleb128 (p, &len, end);
87779176
JM		 13695 p += len;
13696 printf (" Tag_ABI_array_object_align_expected: ");
13697 switch (val)
13698 {
13699 case 0:
13700 printf (_("8-byte\n"));
13701 break;
13702 case 1:
13703 printf (_("4-byte\n"));
13704 break;
13705 case 2:
13706 printf (_("16-byte\n"));
13707 break;
13708 default:
13709 printf ("??? (%d)\n", val);
13710 break;
13711 }
13712 return p;
13713
3cbd1c06 13714 case Tag_ABI_compatibility:
071436c6 13715 {
071436c6
NC		 13716 val = read_uleb128 (p, &len, end);
13717 p += len;
13718 printf (" Tag_ABI_compatibility: ");
071436c6 13719 printf (_("flag = %d, vendor = "), val);
4082ef84
NC		 13720 if (p < end - 1)
13721 {
13722 size_t maxlen = (end - p) - 1;
13723
13724 print_symbol ((int) maxlen, (const char *) p);
13725 p += strnlen ((char *) p, maxlen) + 1;
13726 }
13727 else
13728 {
13729 printf (_("<corrupt>"));
13730 p = (unsigned char *) end;
13731 }
071436c6 13732 putchar ('\n');
071436c6
NC		 13733 return p;
13734 }
87779176
JM		 13735
13736 case Tag_ABI_conformance:
071436c6 13737 {
4082ef84
NC		 13738 printf (" Tag_ABI_conformance: \"");
13739 if (p < end - 1)
13740 {
13741 size_t maxlen = (end - p) - 1;
071436c6 13742
4082ef84
NC		 13743 print_symbol ((int) maxlen, (const char *) p);
13744 p += strnlen ((char *) p, maxlen) + 1;
13745 }
13746 else
13747 {
13748 printf (_("<corrupt>"));
13749 p = (unsigned char *) end;
13750 }
071436c6 13751 printf ("\"\n");
071436c6
NC		 13752 return p;
13753 }
59e6276b
JM		 13754 }
13755
f6f0e17b
NC		 13756 return display_tag_value (tag, p, end);
13757}
59e6276b 13758
f6f0e17b
NC		 13759static void
13760display_raw_attribute (unsigned char * p, unsigned char * end)
13761{
13762 unsigned long addr = 0;
13763 size_t bytes = end - p;
13764
e0a31db1 13765 assert (end > p);
f6f0e17b 13766 while (bytes)
87779176 13767 {
f6f0e17b
NC		 13768 int j;
13769 int k;
13770 int lbytes = (bytes > 16 ? 16 : bytes);
13771
13772 printf (" 0x%8.8lx ", addr);
13773
13774 for (j = 0; j < 16; j++)
13775 {
13776 if (j < lbytes)
13777 printf ("%2.2x", p[j]);
13778 else
13779 printf (" ");
13780
13781 if ((j & 3) == 3)
13782 printf (" ");
13783 }
13784
13785 for (j = 0; j < lbytes; j++)
13786 {
13787 k = p[j];
13788 if (k >= ' ' && k < 0x7f)
13789 printf ("%c", k);
13790 else
13791 printf (".");
13792 }
13793
13794 putchar ('\n');
13795
13796 p += lbytes;
13797 bytes -= lbytes;
13798 addr += lbytes;
87779176 13799 }
59e6276b 13800
f6f0e17b 13801 putchar ('\n');
59e6276b
JM		 13802}
13803
13761a11
NC		 13804static unsigned char *
13805display_msp430x_attribute (unsigned char * p,
13806 const unsigned char * const end)
13807{
13808 unsigned int len;
13809 int val;
13810 int tag;
13811
13812 tag = read_uleb128 (p, & len, end);
13813 p += len;
0b4362b0 13814
13761a11
NC		 13815 switch (tag)
13816 {
13817 case OFBA_MSPABI_Tag_ISA:
13818 val = read_uleb128 (p, &len, end);
13819 p += len;
13820 printf (" Tag_ISA: ");
13821 switch (val)
13822 {
13823 case 0: printf (_("None\n")); break;
13824 case 1: printf (_("MSP430\n")); break;
13825 case 2: printf (_("MSP430X\n")); break;
13826 default: printf ("??? (%d)\n", val); break;
13827 }
13828 break;
13829
13830 case OFBA_MSPABI_Tag_Code_Model:
13831 val = read_uleb128 (p, &len, end);
13832 p += len;
13833 printf (" Tag_Code_Model: ");
13834 switch (val)
13835 {
13836 case 0: printf (_("None\n")); break;
13837 case 1: printf (_("Small\n")); break;
13838 case 2: printf (_("Large\n")); break;
13839 default: printf ("??? (%d)\n", val); break;
13840 }
13841 break;
13842
13843 case OFBA_MSPABI_Tag_Data_Model:
13844 val = read_uleb128 (p, &len, end);
13845 p += len;
13846 printf (" Tag_Data_Model: ");
13847 switch (val)
13848 {
13849 case 0: printf (_("None\n")); break;
13850 case 1: printf (_("Small\n")); break;
13851 case 2: printf (_("Large\n")); break;
13852 case 3: printf (_("Restricted Large\n")); break;
13853 default: printf ("??? (%d)\n", val); break;
13854 }
13855 break;
13856
13857 default:
13858 printf (_(" <unknown tag %d>: "), tag);
13859
13860 if (tag & 1)
13861 {
071436c6 13862 putchar ('"');
4082ef84
NC		 13863 if (p < end - 1)
13864 {
13865 size_t maxlen = (end - p) - 1;
13866
13867 print_symbol ((int) maxlen, (const char *) p);
13868 p += strnlen ((char *) p, maxlen) + 1;
13869 }
13870 else
13871 {
13872 printf (_("<corrupt>"));
13873 p = (unsigned char *) end;
13874 }
071436c6 13875 printf ("\"\n");
13761a11
NC		 13876 }
13877 else
13878 {
13879 val = read_uleb128 (p, &len, end);
13880 p += len;
13881 printf ("%d (0x%x)\n", val, val);
13882 }
13883 break;
13884 }
13885
4082ef84 13886 assert (p <= end);
13761a11
NC		 13887 return p;
13888}
13889
11c1ff18 13890static int
60bca95a
NC		 13891process_attributes (FILE * file,
13892 const char * public_name,
104d59d1 13893 unsigned int proc_type,
f6f0e17b
NC		 13894 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13895 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
11c1ff18 13896{
2cf0635d 13897 Elf_Internal_Shdr * sect;
11c1ff18
PB		 13898 unsigned i;
13899
13900 /* Find the section header so that we get the size. */
13901 for (i = 0, sect = section_headers;
13902 i < elf_header.e_shnum;
13903 i++, sect++)
13904 {
071436c6
NC		 13905 unsigned char * contents;
13906 unsigned char * p;
13907
104d59d1 13908 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11c1ff18
PB		 13909 continue;
13910
3f5e193b
NC		 13911 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13912 sect->sh_size, _("attributes"));
60bca95a 13913 if (contents == NULL)
11c1ff18 13914 continue;
60bca95a 13915
11c1ff18
PB		 13916 p = contents;
13917 if (*p == 'A')
13918 {
071436c6
NC		 13919 bfd_vma section_len;
13920
13921 section_len = sect->sh_size - 1;
11c1ff18 13922 p++;
60bca95a 13923
071436c6 13924 while (section_len > 0)
11c1ff18 13925 {
071436c6 13926 bfd_vma attr_len;
e9847026 13927 unsigned int namelen;
11c1ff18 13928 bfd_boolean public_section;
104d59d1 13929 bfd_boolean gnu_section;
11c1ff18 13930
071436c6 13931 if (section_len <= 4)
e0a31db1
NC		 13932 {
13933 error (_("Tag section ends prematurely\n"));
13934 break;
13935 }
071436c6 13936 attr_len = byte_get (p, 4);
11c1ff18 13937 p += 4;
60bca95a 13938
071436c6 13939 if (attr_len > section_len)
11c1ff18 13940 {
071436c6
NC		 13941 error (_("Bad attribute length (%u > %u)\n"),
13942 (unsigned) attr_len, (unsigned) section_len);
13943 attr_len = section_len;
11c1ff18 13944 }
74e1a04b 13945 /* PR 17531: file: 001-101425-0.004 */
071436c6 13946 else if (attr_len < 5)
74e1a04b 13947 {
071436c6 13948 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
74e1a04b
NC		 13949 break;
13950 }
e9847026 13951
071436c6
NC		 13952 section_len -= attr_len;
13953 attr_len -= 4;
13954
13955 namelen = strnlen ((char *) p, attr_len) + 1;
13956 if (namelen == 0 || namelen >= attr_len)
e9847026
NC		 13957 {
13958 error (_("Corrupt attribute section name\n"));
13959 break;
13960 }
13961
071436c6
NC		 13962 printf (_("Attribute Section: "));
13963 print_symbol (INT_MAX, (const char *) p);
13964 putchar ('\n');
60bca95a
NC		 13965
13966 if (public_name && streq ((char *) p, public_name))
11c1ff18
PB		 13967 public_section = TRUE;
13968 else
13969 public_section = FALSE;
60bca95a
NC		 13970
13971 if (streq ((char *) p, "gnu"))
104d59d1
JM		 13972 gnu_section = TRUE;
13973 else
13974 gnu_section = FALSE;
60bca95a 13975
11c1ff18 13976 p += namelen;
071436c6 13977 attr_len -= namelen;
e0a31db1 13978
071436c6 13979 while (attr_len > 0 && p < contents + sect->sh_size)
11c1ff18 13980 {
e0a31db1 13981 int tag;
11c1ff18
PB		 13982 int val;
13983 bfd_vma size;
071436c6 13984 unsigned char * end;
60bca95a 13985
e0a31db1 13986 /* PR binutils/17531: Safe handling of corrupt files. */
071436c6 13987 if (attr_len < 6)
e0a31db1
NC		 13988 {
13989 error (_("Unused bytes at end of section\n"));
13990 section_len = 0;
13991 break;
13992 }
13993
13994 tag = *(p++);
11c1ff18 13995 size = byte_get (p, 4);
071436c6 13996 if (size > attr_len)
11c1ff18 13997 {
e9847026 13998 error (_("Bad subsection length (%u > %u)\n"),
071436c6
NC		 13999 (unsigned) size, (unsigned) attr_len);
14000 size = attr_len;
11c1ff18 14001 }
e0a31db1
NC		 14002 /* PR binutils/17531: Safe handling of corrupt files. */
14003 if (size < 6)
14004 {
14005 error (_("Bad subsection length (%u < 6)\n"),
14006 (unsigned) size);
14007 section_len = 0;
14008 break;
14009 }
60bca95a 14010
071436c6 14011 attr_len -= size;
11c1ff18 14012 end = p + size - 1;
071436c6 14013 assert (end <= contents + sect->sh_size);
11c1ff18 14014 p += 4;
60bca95a 14015
11c1ff18
PB		 14016 switch (tag)
14017 {
14018 case 1:
2b692964 14019 printf (_("File Attributes\n"));
11c1ff18
PB		 14020 break;
14021 case 2:
2b692964 14022 printf (_("Section Attributes:"));
11c1ff18
PB		 14023 goto do_numlist;
14024 case 3:
2b692964 14025 printf (_("Symbol Attributes:"));
11c1ff18
PB		 14026 do_numlist:
14027 for (;;)
14028 {
91d6fa6a 14029 unsigned int j;
60bca95a 14030
f6f0e17b 14031 val = read_uleb128 (p, &j, end);
91d6fa6a 14032 p += j;
11c1ff18
PB		 14033 if (val == 0)
14034 break;
14035 printf (" %d", val);
14036 }
14037 printf ("\n");
14038 break;
14039 default:
2b692964 14040 printf (_("Unknown tag: %d\n"), tag);
11c1ff18
PB		 14041 public_section = FALSE;
14042 break;
14043 }
60bca95a 14044
071436c6 14045 if (public_section && display_pub_attribute != NULL)
11c1ff18
PB		 14046 {
14047 while (p < end)
f6f0e17b 14048 p = display_pub_attribute (p, end);
071436c6 14049 assert (p <= end);
104d59d1 14050 }
071436c6 14051 else if (gnu_section && display_proc_gnu_attribute != NULL)
104d59d1
JM		 14052 {
14053 while (p < end)
14054 p = display_gnu_attribute (p,
f6f0e17b
NC		 14055 display_proc_gnu_attribute,
14056 end);
071436c6 14057 assert (p <= end);
11c1ff18 14058 }
071436c6 14059 else if (p < end)
11c1ff18 14060 {
071436c6 14061 printf (_(" Unknown attribute:\n"));
f6f0e17b 14062 display_raw_attribute (p, end);
11c1ff18
PB		 14063 p = end;
14064 }
071436c6
NC		 14065 else
14066 attr_len = 0;
11c1ff18
PB		 14067 }
14068 }
14069 }
14070 else
e9847026 14071 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
d70c5fc7 14072
60bca95a 14073 free (contents);
11c1ff18
PB		 14074 }
14075 return 1;
14076}
14077
104d59d1 14078static int
2cf0635d 14079process_arm_specific (FILE * file)
104d59d1
JM		 14080{
14081 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
14082 display_arm_attribute, NULL);
14083}
14084
34c8bcba 14085static int
2cf0635d 14086process_power_specific (FILE * file)
34c8bcba
JM		 14087{
14088 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14089 display_power_gnu_attribute);
14090}
14091
643f7afb
AK		 14092static int
14093process_s390_specific (FILE * file)
14094{
14095 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14096 display_s390_gnu_attribute);
14097}
14098
9e8c70f9
DM		 14099static int
14100process_sparc_specific (FILE * file)
14101{
14102 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14103 display_sparc_gnu_attribute);
14104}
14105
59e6276b
JM		 14106static int
14107process_tic6x_specific (FILE * file)
14108{
14109 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
14110 display_tic6x_attribute, NULL);
14111}
14112
13761a11
NC		 14113static int
14114process_msp430x_specific (FILE * file)
14115{
14116 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
14117 display_msp430x_attribute, NULL);
14118}
14119
ccb4c951
RS		 14120/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14121 Print the Address, Access and Initial fields of an entry at VMA ADDR
82b1b41b
NC		 14122 and return the VMA of the next entry, or -1 if there was a problem.
14123 Does not read from DATA_END or beyond. */
ccb4c951
RS		 14124
14125static bfd_vma
82b1b41b
NC		 14126print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
14127 unsigned char * data_end)
ccb4c951
RS		 14128{
14129 printf (" ");
14130 print_vma (addr, LONG_HEX);
14131 printf (" ");
14132 if (addr < pltgot + 0xfff0)
14133 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
14134 else
14135 printf ("%10s", "");
14136 printf (" ");
14137 if (data == NULL)
2b692964 14138 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
ccb4c951
RS		 14139 else
14140 {
14141 bfd_vma entry;
82b1b41b 14142 unsigned char * from = data + addr - pltgot;
ccb4c951 14143
82b1b41b
NC		 14144 if (from + (is_32bit_elf ? 4 : 8) > data_end)
14145 {
14146 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14147 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
14148 return (bfd_vma) -1;
14149 }
14150 else
14151 {
14152 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14153 print_vma (entry, LONG_HEX);
14154 }
ccb4c951
RS		 14155 }
14156 return addr + (is_32bit_elf ? 4 : 8);
14157}
14158
861fb55a
DJ		 14159/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14160 PLTGOT. Print the Address and Initial fields of an entry at VMA
14161 ADDR and return the VMA of the next entry. */
14162
14163static bfd_vma
2cf0635d 14164print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
861fb55a
DJ		 14165{
14166 printf (" ");
14167 print_vma (addr, LONG_HEX);
14168 printf (" ");
14169 if (data == NULL)
2b692964 14170 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
861fb55a
DJ		 14171 else
14172 {
14173 bfd_vma entry;
14174
14175 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14176 print_vma (entry, LONG_HEX);
14177 }
14178 return addr + (is_32bit_elf ? 4 : 8);
14179}
14180
351cdf24
MF		 14181static void
14182print_mips_ases (unsigned int mask)
14183{
14184 if (mask & AFL_ASE_DSP)
14185 fputs ("\n\tDSP ASE", stdout);
14186 if (mask & AFL_ASE_DSPR2)
14187 fputs ("\n\tDSP R2 ASE", stdout);
14188 if (mask & AFL_ASE_EVA)
14189 fputs ("\n\tEnhanced VA Scheme", stdout);
14190 if (mask & AFL_ASE_MCU)
14191 fputs ("\n\tMCU (MicroController) ASE", stdout);
14192 if (mask & AFL_ASE_MDMX)
14193 fputs ("\n\tMDMX ASE", stdout);
14194 if (mask & AFL_ASE_MIPS3D)
14195 fputs ("\n\tMIPS-3D ASE", stdout);
14196 if (mask & AFL_ASE_MT)
14197 fputs ("\n\tMT ASE", stdout);
14198 if (mask & AFL_ASE_SMARTMIPS)
14199 fputs ("\n\tSmartMIPS ASE", stdout);
14200 if (mask & AFL_ASE_VIRT)
14201 fputs ("\n\tVZ ASE", stdout);
14202 if (mask & AFL_ASE_MSA)
14203 fputs ("\n\tMSA ASE", stdout);
14204 if (mask & AFL_ASE_MIPS16)
14205 fputs ("\n\tMIPS16 ASE", stdout);
14206 if (mask & AFL_ASE_MICROMIPS)
14207 fputs ("\n\tMICROMIPS ASE", stdout);
14208 if (mask & AFL_ASE_XPA)
14209 fputs ("\n\tXPA ASE", stdout);
14210 if (mask == 0)
14211 fprintf (stdout, "\n\t%s", _("None"));
00ac7aa0
MF		 14212 else if ((mask & ~AFL_ASE_MASK) != 0)
14213 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
351cdf24
MF		 14214}
14215
14216static void
14217print_mips_isa_ext (unsigned int isa_ext)
14218{
14219 switch (isa_ext)
14220 {
14221 case 0:
14222 fputs (_("None"), stdout);
14223 break;
14224 case AFL_EXT_XLR:
14225 fputs ("RMI XLR", stdout);
14226 break;
2c629856
N		 14227 case AFL_EXT_OCTEON3:
14228 fputs ("Cavium Networks Octeon3", stdout);
14229 break;
351cdf24
MF		 14230 case AFL_EXT_OCTEON2:
14231 fputs ("Cavium Networks Octeon2", stdout);
14232 break;
14233 case AFL_EXT_OCTEONP:
14234 fputs ("Cavium Networks OcteonP", stdout);
14235 break;
14236 case AFL_EXT_LOONGSON_3A:
14237 fputs ("Loongson 3A", stdout);
14238 break;
14239 case AFL_EXT_OCTEON:
14240 fputs ("Cavium Networks Octeon", stdout);
14241 break;
14242 case AFL_EXT_5900:
14243 fputs ("Toshiba R5900", stdout);
14244 break;
14245 case AFL_EXT_4650:
14246 fputs ("MIPS R4650", stdout);
14247 break;
14248 case AFL_EXT_4010:
14249 fputs ("LSI R4010", stdout);
14250 break;
14251 case AFL_EXT_4100:
14252 fputs ("NEC VR4100", stdout);
14253 break;
14254 case AFL_EXT_3900:
14255 fputs ("Toshiba R3900", stdout);
14256 break;
14257 case AFL_EXT_10000:
14258 fputs ("MIPS R10000", stdout);
14259 break;
14260 case AFL_EXT_SB1:
14261 fputs ("Broadcom SB-1", stdout);
14262 break;
14263 case AFL_EXT_4111:
14264 fputs ("NEC VR4111/VR4181", stdout);
14265 break;
14266 case AFL_EXT_4120:
14267 fputs ("NEC VR4120", stdout);
14268 break;
14269 case AFL_EXT_5400:
14270 fputs ("NEC VR5400", stdout);
14271 break;
14272 case AFL_EXT_5500:
14273 fputs ("NEC VR5500", stdout);
14274 break;
14275 case AFL_EXT_LOONGSON_2E:
14276 fputs ("ST Microelectronics Loongson 2E", stdout);
14277 break;
14278 case AFL_EXT_LOONGSON_2F:
14279 fputs ("ST Microelectronics Loongson 2F", stdout);
14280 break;
14281 default:
00ac7aa0 14282 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
351cdf24
MF		 14283 }
14284}
14285
14286static int
14287get_mips_reg_size (int reg_size)
14288{
14289 return (reg_size == AFL_REG_NONE) ? 0
14290 : (reg_size == AFL_REG_32) ? 32
14291 : (reg_size == AFL_REG_64) ? 64
14292 : (reg_size == AFL_REG_128) ? 128
14293 : -1;
14294}
14295
19e6b90e 14296static int
2cf0635d 14297process_mips_specific (FILE * file)
5b18a4bc 14298{
2cf0635d 14299 Elf_Internal_Dyn * entry;
351cdf24 14300 Elf_Internal_Shdr *sect = NULL;
19e6b90e
L		 14301 size_t liblist_offset = 0;
14302 size_t liblistno = 0;
14303 size_t conflictsno = 0;
14304 size_t options_offset = 0;
14305 size_t conflicts_offset = 0;
861fb55a
DJ		 14306 size_t pltrelsz = 0;
14307 size_t pltrel = 0;
ccb4c951 14308 bfd_vma pltgot = 0;
861fb55a
DJ		 14309 bfd_vma mips_pltgot = 0;
14310 bfd_vma jmprel = 0;
ccb4c951
RS		 14311 bfd_vma local_gotno = 0;
14312 bfd_vma gotsym = 0;
14313 bfd_vma symtabno = 0;
103f02d3 14314
2cf19d5c
JM		 14315 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14316 display_mips_gnu_attribute);
14317
351cdf24
MF		 14318 sect = find_section (".MIPS.abiflags");
14319
14320 if (sect != NULL)
14321 {
14322 Elf_External_ABIFlags_v0 *abiflags_ext;
14323 Elf_Internal_ABIFlags_v0 abiflags_in;
14324
14325 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
14326 fputs ("\nCorrupt ABI Flags section.\n", stdout);
14327 else
14328 {
14329 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
14330 sect->sh_size, _("MIPS ABI Flags section"));
14331 if (abiflags_ext)
14332 {
14333 abiflags_in.version = BYTE_GET (abiflags_ext->version);
14334 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
14335 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
14336 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
14337 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
14338 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
14339 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
14340 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
14341 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
14342 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
14343 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
14344
14345 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
14346 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
14347 if (abiflags_in.isa_rev > 1)
14348 printf ("r%d", abiflags_in.isa_rev);
14349 printf ("\nGPR size: %d",
14350 get_mips_reg_size (abiflags_in.gpr_size));
14351 printf ("\nCPR1 size: %d",
14352 get_mips_reg_size (abiflags_in.cpr1_size));
14353 printf ("\nCPR2 size: %d",
14354 get_mips_reg_size (abiflags_in.cpr2_size));
14355 fputs ("\nFP ABI: ", stdout);
14356 print_mips_fp_abi_value (abiflags_in.fp_abi);
14357 fputs ("ISA Extension: ", stdout);
14358 print_mips_isa_ext (abiflags_in.isa_ext);
14359 fputs ("\nASEs:", stdout);
14360 print_mips_ases (abiflags_in.ases);
14361 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
14362 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
14363 fputc ('\n', stdout);
14364 free (abiflags_ext);
14365 }
14366 }
14367 }
14368
19e6b90e
L		 14369 /* We have a lot of special sections. Thanks SGI! */
14370 if (dynamic_section == NULL)
14371 /* No information available. */
14372 return 0;
252b5132 14373
071436c6
NC		 14374 for (entry = dynamic_section;
14375 /* PR 17531 file: 012-50589-0.004. */
14376 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
14377 ++entry)
252b5132
RH		 14378 switch (entry->d_tag)
14379 {
14380 case DT_MIPS_LIBLIST:
d93f0186
NC		 14381 liblist_offset
14382 = offset_from_vma (file, entry->d_un.d_val,
14383 liblistno * sizeof (Elf32_External_Lib));
252b5132
RH		 14384 break;
14385 case DT_MIPS_LIBLISTNO:
14386 liblistno = entry->d_un.d_val;
14387 break;
14388 case DT_MIPS_OPTIONS:
d93f0186 14389 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
252b5132
RH		 14390 break;
14391 case DT_MIPS_CONFLICT:
d93f0186
NC		 14392 conflicts_offset
14393 = offset_from_vma (file, entry->d_un.d_val,
14394 conflictsno * sizeof (Elf32_External_Conflict));
252b5132
RH		 14395 break;
14396 case DT_MIPS_CONFLICTNO:
14397 conflictsno = entry->d_un.d_val;
14398 break;
ccb4c951 14399 case DT_PLTGOT:
861fb55a
DJ		 14400 pltgot = entry->d_un.d_ptr;
14401 break;
ccb4c951
RS		 14402 case DT_MIPS_LOCAL_GOTNO:
14403 local_gotno = entry->d_un.d_val;
14404 break;
14405 case DT_MIPS_GOTSYM:
14406 gotsym = entry->d_un.d_val;
14407 break;
14408 case DT_MIPS_SYMTABNO:
14409 symtabno = entry->d_un.d_val;
14410 break;
861fb55a
DJ		 14411 case DT_MIPS_PLTGOT:
14412 mips_pltgot = entry->d_un.d_ptr;
14413 break;
14414 case DT_PLTREL:
14415 pltrel = entry->d_un.d_val;
14416 break;
14417 case DT_PLTRELSZ:
14418 pltrelsz = entry->d_un.d_val;
14419 break;
14420 case DT_JMPREL:
14421 jmprel = entry->d_un.d_ptr;
14422 break;
252b5132
RH		 14423 default:
14424 break;
14425 }
14426
14427 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
14428 {
2cf0635d 14429 Elf32_External_Lib * elib;
252b5132
RH		 14430 size_t cnt;
14431
3f5e193b
NC		 14432 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
14433 liblistno,
14434 sizeof (Elf32_External_Lib),
9cf03b7e 14435 _("liblist section data"));
a6e9f9df 14436 if (elib)
252b5132 14437 {
2b692964 14438 printf (_("\nSection '.liblist' contains %lu entries:\n"),
a6e9f9df 14439 (unsigned long) liblistno);
2b692964 14440 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
a6e9f9df
AM		 14441 stdout);
14442
14443 for (cnt = 0; cnt < liblistno; ++cnt)
252b5132 14444 {
a6e9f9df 14445 Elf32_Lib liblist;
91d6fa6a 14446 time_t atime;
a6e9f9df 14447 char timebuf[20];
2cf0635d 14448 struct tm * tmp;
a6e9f9df
AM		 14449
14450 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 14451 atime = BYTE_GET (elib[cnt].l_time_stamp);
a6e9f9df
AM		 14452 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14453 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14454 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14455
91d6fa6a 14456 tmp = gmtime (&atime);
e9e44622
JJ		 14457 snprintf (timebuf, sizeof (timebuf),
14458 "%04u-%02u-%02uT%02u:%02u:%02u",
14459 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14460 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
a6e9f9df 14461
31104126 14462 printf ("%3lu: ", (unsigned long) cnt);
d79b3d50
NC		 14463 if (VALID_DYNAMIC_NAME (liblist.l_name))
14464 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
14465 else
2b692964 14466 printf (_("<corrupt: %9ld>"), liblist.l_name);
31104126
NC		 14467 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
14468 liblist.l_version);
a6e9f9df
AM		 14469
14470 if (liblist.l_flags == 0)
2b692964 14471 puts (_(" NONE"));
a6e9f9df
AM		 14472 else
14473 {
14474 static const struct
252b5132 14475 {
2cf0635d 14476 const char * name;
a6e9f9df 14477 int bit;
252b5132 14478 }
a6e9f9df
AM		 14479 l_flags_vals[] =
14480 {
14481 { " EXACT_MATCH", LL_EXACT_MATCH },
14482 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
14483 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
14484 { " EXPORTS", LL_EXPORTS },
14485 { " DELAY_LOAD", LL_DELAY_LOAD },
14486 { " DELTA", LL_DELTA }
14487 };
14488 int flags = liblist.l_flags;
14489 size_t fcnt;
14490
60bca95a 14491 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
a6e9f9df
AM		 14492 if ((flags & l_flags_vals[fcnt].bit) != 0)
14493 {
14494 fputs (l_flags_vals[fcnt].name, stdout);
14495 flags ^= l_flags_vals[fcnt].bit;
14496 }
14497 if (flags != 0)
14498 printf (" %#x", (unsigned int) flags);
252b5132 14499
a6e9f9df
AM		 14500 puts ("");
14501 }
252b5132 14502 }
252b5132 14503
a6e9f9df
AM		 14504 free (elib);
14505 }
252b5132
RH		 14506 }
14507
14508 if (options_offset != 0)
14509 {
2cf0635d 14510 Elf_External_Options * eopt;
2cf0635d
NC		 14511 Elf_Internal_Options * iopt;
14512 Elf_Internal_Options * option;
252b5132
RH		 14513 size_t offset;
14514 int cnt;
351cdf24 14515 sect = section_headers;
252b5132
RH		 14516
14517 /* Find the section header so that we get the size. */
071436c6 14518 sect = find_section_by_type (SHT_MIPS_OPTIONS);
948f632f 14519 /* PR 17533 file: 012-277276-0.004. */
071436c6
NC		 14520 if (sect == NULL)
14521 {
14522 error (_("No MIPS_OPTIONS header found\n"));
14523 return 0;
14524 }
252b5132 14525
3f5e193b
NC		 14526 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
14527 sect->sh_size, _("options"));
a6e9f9df 14528 if (eopt)
252b5132 14529 {
3f5e193b
NC		 14530 iopt = (Elf_Internal_Options *)
14531 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
a6e9f9df
AM		 14532 if (iopt == NULL)
14533 {
8b73c356 14534 error (_("Out of memory allocatinf space for MIPS options\n"));
a6e9f9df
AM		 14535 return 0;
14536 }
76da6bbe 14537
a6e9f9df
AM		 14538 offset = cnt = 0;
14539 option = iopt;
252b5132 14540
82b1b41b 14541 while (offset <= sect->sh_size - sizeof (* eopt))
a6e9f9df 14542 {
2cf0635d 14543 Elf_External_Options * eoption;
252b5132 14544
a6e9f9df 14545 eoption = (Elf_External_Options *) ((char *) eopt + offset);
252b5132 14546
a6e9f9df
AM		 14547 option->kind = BYTE_GET (eoption->kind);
14548 option->size = BYTE_GET (eoption->size);
14549 option->section = BYTE_GET (eoption->section);
14550 option->info = BYTE_GET (eoption->info);
76da6bbe 14551
82b1b41b
NC		 14552 /* PR 17531: file: ffa0fa3b. */
14553 if (option->size < sizeof (* eopt)
14554 || offset + option->size > sect->sh_size)
14555 {
55325047
NC		 14556 error (_("Invalid size (%u) for MIPS option\n"), option->size);
14557 return 0;
82b1b41b 14558 }
a6e9f9df 14559 offset += option->size;
14ae95f2 14560
a6e9f9df
AM		 14561 ++option;
14562 ++cnt;
14563 }
252b5132 14564
a6e9f9df 14565 printf (_("\nSection '%s' contains %d entries:\n"),
74e1a04b 14566 printable_section_name (sect), cnt);
76da6bbe 14567
a6e9f9df 14568 option = iopt;
82b1b41b 14569 offset = 0;
252b5132 14570
a6e9f9df 14571 while (cnt-- > 0)
252b5132 14572 {
a6e9f9df
AM		 14573 size_t len;
14574
14575 switch (option->kind)
252b5132 14576 {
a6e9f9df
AM		 14577 case ODK_NULL:
14578 /* This shouldn't happen. */
14579 printf (" NULL %d %lx", option->section, option->info);
14580 break;
14581 case ODK_REGINFO:
14582 printf (" REGINFO ");
14583 if (elf_header.e_machine == EM_MIPS)
14584 {
14585 /* 32bit form. */
2cf0635d 14586 Elf32_External_RegInfo * ereg;
b34976b6 14587 Elf32_RegInfo reginfo;
a6e9f9df
AM		 14588
14589 ereg = (Elf32_External_RegInfo *) (option + 1);
14590 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14591 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14592 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14593 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14594 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14595 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14596
14597 printf ("GPR %08lx GP 0x%lx\n",
14598 reginfo.ri_gprmask,
14599 (unsigned long) reginfo.ri_gp_value);
14600 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14601 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14602 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14603 }
14604 else
14605 {
14606 /* 64 bit form. */
2cf0635d 14607 Elf64_External_RegInfo * ereg;
a6e9f9df
AM		 14608 Elf64_Internal_RegInfo reginfo;
14609
14610 ereg = (Elf64_External_RegInfo *) (option + 1);
14611 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14612 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14613 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14614 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14615 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
66543521 14616 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
a6e9f9df
AM		 14617
14618 printf ("GPR %08lx GP 0x",
14619 reginfo.ri_gprmask);
14620 printf_vma (reginfo.ri_gp_value);
14621 printf ("\n");
14622
14623 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14624 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14625 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14626 }
14627 ++option;
14628 continue;
14629 case ODK_EXCEPTIONS:
14630 fputs (" EXCEPTIONS fpe_min(", stdout);
14631 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
14632 fputs (") fpe_max(", stdout);
14633 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
14634 fputs (")", stdout);
14635
14636 if (option->info & OEX_PAGE0)
14637 fputs (" PAGE0", stdout);
14638 if (option->info & OEX_SMM)
14639 fputs (" SMM", stdout);
14640 if (option->info & OEX_FPDBUG)
14641 fputs (" FPDBUG", stdout);
14642 if (option->info & OEX_DISMISS)
14643 fputs (" DISMISS", stdout);
14644 break;
14645 case ODK_PAD:
14646 fputs (" PAD ", stdout);
14647 if (option->info & OPAD_PREFIX)
14648 fputs (" PREFIX", stdout);
14649 if (option->info & OPAD_POSTFIX)
14650 fputs (" POSTFIX", stdout);
14651 if (option->info & OPAD_SYMBOL)
14652 fputs (" SYMBOL", stdout);
14653 break;
14654 case ODK_HWPATCH:
14655 fputs (" HWPATCH ", stdout);
14656 if (option->info & OHW_R4KEOP)
14657 fputs (" R4KEOP", stdout);
14658 if (option->info & OHW_R8KPFETCH)
14659 fputs (" R8KPFETCH", stdout);
14660 if (option->info & OHW_R5KEOP)
14661 fputs (" R5KEOP", stdout);
14662 if (option->info & OHW_R5KCVTL)
14663 fputs (" R5KCVTL", stdout);
14664 break;
14665 case ODK_FILL:
14666 fputs (" FILL ", stdout);
14667 /* XXX Print content of info word? */
14668 break;
14669 case ODK_TAGS:
14670 fputs (" TAGS ", stdout);
14671 /* XXX Print content of info word? */
14672 break;
14673 case ODK_HWAND:
14674 fputs (" HWAND ", stdout);
14675 if (option->info & OHWA0_R4KEOP_CHECKED)
14676 fputs (" R4KEOP_CHECKED", stdout);
14677 if (option->info & OHWA0_R4KEOP_CLEAN)
14678 fputs (" R4KEOP_CLEAN", stdout);
14679 break;
14680 case ODK_HWOR:
14681 fputs (" HWOR ", stdout);
14682 if (option->info & OHWA0_R4KEOP_CHECKED)
14683 fputs (" R4KEOP_CHECKED", stdout);
14684 if (option->info & OHWA0_R4KEOP_CLEAN)
14685 fputs (" R4KEOP_CLEAN", stdout);
14686 break;
14687 case ODK_GP_GROUP:
14688 printf (" GP_GROUP %#06lx self-contained %#06lx",
14689 option->info & OGP_GROUP,
14690 (option->info & OGP_SELF) >> 16);
14691 break;
14692 case ODK_IDENT:
14693 printf (" IDENT %#06lx self-contained %#06lx",
14694 option->info & OGP_GROUP,
14695 (option->info & OGP_SELF) >> 16);
14696 break;
14697 default:
14698 /* This shouldn't happen. */
14699 printf (" %3d ??? %d %lx",
14700 option->kind, option->section, option->info);
14701 break;
252b5132 14702 }
a6e9f9df 14703
2cf0635d 14704 len = sizeof (* eopt);
a6e9f9df 14705 while (len < option->size)
82b1b41b 14706 {
7e27a9d5 14707 unsigned char datum = * ((unsigned char *) eopt + offset + len);
a6e9f9df 14708
82b1b41b
NC		 14709 if (ISPRINT (datum))
14710 printf ("%c", datum);
14711 else
14712 printf ("\\%03o", datum);
14713 len ++;
14714 }
a6e9f9df 14715 fputs ("\n", stdout);
82b1b41b
NC		 14716
14717 offset += option->size;
252b5132 14718 ++option;
252b5132
RH		 14719 }
14720
a6e9f9df 14721 free (eopt);
252b5132 14722 }
252b5132
RH		 14723 }
14724
14725 if (conflicts_offset != 0 && conflictsno != 0)
14726 {
2cf0635d 14727 Elf32_Conflict * iconf;
252b5132
RH		 14728 size_t cnt;
14729
14730 if (dynamic_symbols == NULL)
14731 {
591a748a 14732 error (_("conflict list found without a dynamic symbol table\n"));
252b5132
RH		 14733 return 0;
14734 }
14735
3f5e193b 14736 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
252b5132
RH		 14737 if (iconf == NULL)
14738 {
8b73c356 14739 error (_("Out of memory allocating space for dynamic conflicts\n"));
252b5132
RH		 14740 return 0;
14741 }
14742
9ea033b2 14743 if (is_32bit_elf)
252b5132 14744 {
2cf0635d 14745 Elf32_External_Conflict * econf32;
a6e9f9df 14746
3f5e193b
NC		 14747 econf32 = (Elf32_External_Conflict *)
14748 get_data (NULL, file, conflicts_offset, conflictsno,
14749 sizeof (* econf32), _("conflict"));
a6e9f9df
AM		 14750 if (!econf32)
14751 return 0;
252b5132
RH		 14752
14753 for (cnt = 0; cnt < conflictsno; ++cnt)
14754 iconf[cnt] = BYTE_GET (econf32[cnt]);
a6e9f9df
AM		 14755
14756 free (econf32);
252b5132
RH		 14757 }
14758 else
14759 {
2cf0635d 14760 Elf64_External_Conflict * econf64;
a6e9f9df 14761
3f5e193b
NC		 14762 econf64 = (Elf64_External_Conflict *)
14763 get_data (NULL, file, conflicts_offset, conflictsno,
14764 sizeof (* econf64), _("conflict"));
a6e9f9df
AM		 14765 if (!econf64)
14766 return 0;
252b5132
RH		 14767
14768 for (cnt = 0; cnt < conflictsno; ++cnt)
14769 iconf[cnt] = BYTE_GET (econf64[cnt]);
a6e9f9df
AM		 14770
14771 free (econf64);
252b5132
RH		 14772 }
14773
c7e7ca54
NC		 14774 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14775 (unsigned long) conflictsno);
252b5132
RH		 14776 puts (_(" Num: Index Value Name"));
14777
14778 for (cnt = 0; cnt < conflictsno; ++cnt)
14779 {
b34976b6 14780 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
e0a31db1
NC		 14781
14782 if (iconf[cnt] >= num_dynamic_syms)
14783 printf (_("<corrupt symbol index>"));
d79b3d50 14784 else
e0a31db1
NC		 14785 {
14786 Elf_Internal_Sym * psym;
14787
14788 psym = & dynamic_symbols[iconf[cnt]];
14789 print_vma (psym->st_value, FULL_HEX);
14790 putchar (' ');
14791 if (VALID_DYNAMIC_NAME (psym->st_name))
14792 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14793 else
14794 printf (_("<corrupt: %14ld>"), psym->st_name);
14795 }
31104126 14796 putchar ('\n');
252b5132
RH		 14797 }
14798
252b5132
RH		 14799 free (iconf);
14800 }
14801
ccb4c951
RS		 14802 if (pltgot != 0 && local_gotno != 0)
14803 {
91d6fa6a 14804 bfd_vma ent, local_end, global_end;
bbeee7ea 14805 size_t i, offset;
2cf0635d 14806 unsigned char * data;
82b1b41b 14807 unsigned char * data_end;
bbeee7ea 14808 int addr_size;
ccb4c951 14809
91d6fa6a 14810 ent = pltgot;
ccb4c951
RS		 14811 addr_size = (is_32bit_elf ? 4 : 8);
14812 local_end = pltgot + local_gotno * addr_size;
ccb4c951 14813
74e1a04b
NC		 14814 /* PR binutils/17533 file: 012-111227-0.004 */
14815 if (symtabno < gotsym)
14816 {
14817 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
82b1b41b 14818 (unsigned long) gotsym, (unsigned long) symtabno);
74e1a04b
NC		 14819 return 0;
14820 }
82b1b41b 14821
74e1a04b 14822 global_end = local_end + (symtabno - gotsym) * addr_size;
82b1b41b
NC		 14823 /* PR 17531: file: 54c91a34. */
14824 if (global_end < local_end)
14825 {
14826 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14827 return 0;
14828 }
948f632f 14829
ccb4c951 14830 offset = offset_from_vma (file, pltgot, global_end - pltgot);
3f5e193b 14831 data = (unsigned char *) get_data (NULL, file, offset,
9cf03b7e
NC		 14832 global_end - pltgot, 1,
14833 _("Global Offset Table data"));
59245841
NC		 14834 if (data == NULL)
14835 return 0;
82b1b41b 14836 data_end = data + (global_end - pltgot);
59245841 14837
ccb4c951
RS		 14838 printf (_("\nPrimary GOT:\n"));
14839 printf (_(" Canonical gp value: "));
14840 print_vma (pltgot + 0x7ff0, LONG_HEX);
14841 printf ("\n\n");
14842
14843 printf (_(" Reserved entries:\n"));
14844 printf (_(" %*s %10s %*s Purpose\n"),
2b692964
NC		 14845 addr_size * 2, _("Address"), _("Access"),
14846 addr_size * 2, _("Initial"));
82b1b41b 14847 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14848 printf (_(" Lazy resolver\n"));
82b1b41b
NC		 14849 if (ent == (bfd_vma) -1)
14850 goto got_print_fail;
ccb4c951 14851 if (data
91d6fa6a 14852 && (byte_get (data + ent - pltgot, addr_size)
ccb4c951
RS		 14853 >> (addr_size * 8 - 1)) != 0)
14854 {
82b1b41b 14855 ent = print_mips_got_entry (data, pltgot, ent, data_end);
2b692964 14856 printf (_(" Module pointer (GNU extension)\n"));
82b1b41b
NC		 14857 if (ent == (bfd_vma) -1)
14858 goto got_print_fail;
ccb4c951
RS		 14859 }
14860 printf ("\n");
14861
91d6fa6a 14862 if (ent < local_end)
ccb4c951
RS		 14863 {
14864 printf (_(" Local entries:\n"));
cc5914eb 14865 printf (" %*s %10s %*s\n",
2b692964
NC		 14866 addr_size * 2, _("Address"), _("Access"),
14867 addr_size * 2, _("Initial"));
91d6fa6a 14868 while (ent < local_end)
ccb4c951 14869 {
82b1b41b 14870 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14871 printf ("\n");
82b1b41b
NC		 14872 if (ent == (bfd_vma) -1)
14873 goto got_print_fail;
ccb4c951
RS		 14874 }
14875 printf ("\n");
14876 }
14877
14878 if (gotsym < symtabno)
14879 {
14880 int sym_width;
14881
14882 printf (_(" Global entries:\n"));
cc5914eb 14883 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
9cf03b7e
NC		 14884 addr_size * 2, _("Address"),
14885 _("Access"),
2b692964 14886 addr_size * 2, _("Initial"),
9cf03b7e
NC		 14887 addr_size * 2, _("Sym.Val."),
14888 _("Type"),
14889 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14890 _("Ndx"), _("Name"));
0b4362b0 14891
ccb4c951 14892 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
e0a31db1 14893
ccb4c951
RS		 14894 for (i = gotsym; i < symtabno; i++)
14895 {
82b1b41b 14896 ent = print_mips_got_entry (data, pltgot, ent, data_end);
ccb4c951 14897 printf (" ");
e0a31db1
NC		 14898
14899 if (dynamic_symbols == NULL)
14900 printf (_("<no dynamic symbols>"));
14901 else if (i < num_dynamic_syms)
14902 {
14903 Elf_Internal_Sym * psym = dynamic_symbols + i;
14904
14905 print_vma (psym->st_value, LONG_HEX);
14906 printf (" %-7s %3s ",
14907 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14908 get_symbol_index_type (psym->st_shndx));
14909
14910 if (VALID_DYNAMIC_NAME (psym->st_name))
14911 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14912 else
14913 printf (_("<corrupt: %14ld>"), psym->st_name);
14914 }
ccb4c951 14915 else
7fc5ac57
JBG		 14916 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14917 (unsigned long) i);
e0a31db1 14918
ccb4c951 14919 printf ("\n");
82b1b41b
NC		 14920 if (ent == (bfd_vma) -1)
14921 break;
ccb4c951
RS		 14922 }
14923 printf ("\n");
14924 }
14925
82b1b41b 14926 got_print_fail:
ccb4c951
RS		 14927 if (data)
14928 free (data);
14929 }
14930
861fb55a
DJ		 14931 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14932 {
91d6fa6a 14933 bfd_vma ent, end;
861fb55a
DJ		 14934 size_t offset, rel_offset;
14935 unsigned long count, i;
2cf0635d 14936 unsigned char * data;
861fb55a 14937 int addr_size, sym_width;
2cf0635d 14938 Elf_Internal_Rela * rels;
861fb55a
DJ		 14939
14940 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14941 if (pltrel == DT_RELA)
14942 {
14943 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14944 return 0;
14945 }
14946 else
14947 {
14948 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14949 return 0;
14950 }
14951
91d6fa6a 14952 ent = mips_pltgot;
861fb55a
DJ		 14953 addr_size = (is_32bit_elf ? 4 : 8);
14954 end = mips_pltgot + (2 + count) * addr_size;
14955
14956 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
3f5e193b 14957 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
9cf03b7e 14958 1, _("Procedure Linkage Table data"));
59245841
NC		 14959 if (data == NULL)
14960 return 0;
14961
9cf03b7e 14962 printf ("\nPLT GOT:\n\n");
861fb55a
DJ		 14963 printf (_(" Reserved entries:\n"));
14964 printf (_(" %*s %*s Purpose\n"),
2b692964 14965 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
91d6fa6a 14966 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14967 printf (_(" PLT lazy resolver\n"));
91d6fa6a 14968 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
2b692964 14969 printf (_(" Module pointer\n"));
861fb55a
DJ		 14970 printf ("\n");
14971
14972 printf (_(" Entries:\n"));
cc5914eb 14973 printf (" %*s %*s %*s %-7s %3s %s\n",
2b692964
NC		 14974 addr_size * 2, _("Address"),
14975 addr_size * 2, _("Initial"),
14976 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
861fb55a
DJ		 14977 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14978 for (i = 0; i < count; i++)
14979 {
df97ab2a 14980 unsigned long idx = get_reloc_symindex (rels[i].r_info);
861fb55a 14981
91d6fa6a 14982 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
861fb55a 14983 printf (" ");
e0a31db1 14984
df97ab2a
MF		 14985 if (idx >= num_dynamic_syms)
14986 printf (_("<corrupt symbol index: %lu>"), idx);
861fb55a 14987 else
e0a31db1 14988 {
df97ab2a 14989 Elf_Internal_Sym * psym = dynamic_symbols + idx;
e0a31db1
NC		 14990
14991 print_vma (psym->st_value, LONG_HEX);
14992 printf (" %-7s %3s ",
14993 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14994 get_symbol_index_type (psym->st_shndx));
14995 if (VALID_DYNAMIC_NAME (psym->st_name))
14996 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14997 else
14998 printf (_("<corrupt: %14ld>"), psym->st_name);
14999 }
861fb55a
DJ		 15000 printf ("\n");
15001 }
15002 printf ("\n");
15003
15004 if (data)
15005 free (data);
15006 free (rels);
15007 }
15008
252b5132
RH		 15009 return 1;
15010}
15011
35c08157
KLC		 15012static int
15013process_nds32_specific (FILE * file)
15014{
15015 Elf_Internal_Shdr *sect = NULL;
15016
15017 sect = find_section (".nds32_e_flags");
15018 if (sect != NULL)
15019 {
15020 unsigned int *flag;
15021
15022 printf ("\nNDS32 elf flags section:\n");
15023 flag = get_data (NULL, file, sect->sh_offset, 1,
15024 sect->sh_size, _("NDS32 elf flags section"));
15025
15026 switch ((*flag) & 0x3)
15027 {
15028 case 0:
15029 printf ("(VEC_SIZE):\tNo entry.\n");
15030 break;
15031 case 1:
15032 printf ("(VEC_SIZE):\t4 bytes\n");
15033 break;
15034 case 2:
15035 printf ("(VEC_SIZE):\t16 bytes\n");
15036 break;
15037 case 3:
15038 printf ("(VEC_SIZE):\treserved\n");
15039 break;
15040 }
15041 }
15042
15043 return TRUE;
15044}
15045
047b2264 15046static int
2cf0635d 15047process_gnu_liblist (FILE * file)
047b2264 15048{
2cf0635d
NC		 15049 Elf_Internal_Shdr * section;
15050 Elf_Internal_Shdr * string_sec;
15051 Elf32_External_Lib * elib;
15052 char * strtab;
c256ffe7 15053 size_t strtab_size;
047b2264
JJ		 15054 size_t cnt;
15055 unsigned i;
15056
15057 if (! do_arch)
15058 return 0;
15059
15060 for (i = 0, section = section_headers;
15061 i < elf_header.e_shnum;
b34976b6 15062 i++, section++)
047b2264
JJ		 15063 {
15064 switch (section->sh_type)
15065 {
15066 case SHT_GNU_LIBLIST:
4fbb74a6 15067 if (section->sh_link >= elf_header.e_shnum)
c256ffe7
JJ		 15068 break;
15069
3f5e193b
NC		 15070 elib = (Elf32_External_Lib *)
15071 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9cf03b7e 15072 _("liblist section data"));
047b2264
JJ		 15073
15074 if (elib == NULL)
15075 break;
4fbb74a6 15076 string_sec = section_headers + section->sh_link;
047b2264 15077
3f5e193b
NC		 15078 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
15079 string_sec->sh_size,
15080 _("liblist string table"));
047b2264
JJ		 15081 if (strtab == NULL
15082 || section->sh_entsize != sizeof (Elf32_External_Lib))
15083 {
15084 free (elib);
2842702f 15085 free (strtab);
047b2264
JJ		 15086 break;
15087 }
59245841 15088 strtab_size = string_sec->sh_size;
047b2264
JJ		 15089
15090 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
74e1a04b 15091 printable_section_name (section),
0af1713e 15092 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
047b2264 15093
2b692964 15094 puts (_(" Library Time Stamp Checksum Version Flags"));
047b2264
JJ		 15095
15096 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
15097 ++cnt)
15098 {
15099 Elf32_Lib liblist;
91d6fa6a 15100 time_t atime;
047b2264 15101 char timebuf[20];
2cf0635d 15102 struct tm * tmp;
047b2264
JJ		 15103
15104 liblist.l_name = BYTE_GET (elib[cnt].l_name);
91d6fa6a 15105 atime = BYTE_GET (elib[cnt].l_time_stamp);
047b2264
JJ		 15106 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15107 liblist.l_version = BYTE_GET (elib[cnt].l_version);
15108 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15109
91d6fa6a 15110 tmp = gmtime (&atime);
e9e44622
JJ		 15111 snprintf (timebuf, sizeof (timebuf),
15112 "%04u-%02u-%02uT%02u:%02u:%02u",
15113 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15114 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
047b2264
JJ		 15115
15116 printf ("%3lu: ", (unsigned long) cnt);
15117 if (do_wide)
c256ffe7 15118 printf ("%-20s", liblist.l_name < strtab_size
2b692964 15119 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264 15120 else
c256ffe7 15121 printf ("%-20.20s", liblist.l_name < strtab_size
2b692964 15122 ? strtab + liblist.l_name : _("<corrupt>"));
047b2264
JJ		 15123 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
15124 liblist.l_version, liblist.l_flags);
15125 }
15126
15127 free (elib);
2842702f 15128 free (strtab);
047b2264
JJ		 15129 }
15130 }
15131
15132 return 1;
15133}
15134
9437c45b 15135static const char *
d3ba0551 15136get_note_type (unsigned e_type)
779fe533
NC		 15137{
15138 static char buff[64];
103f02d3 15139
1ec5cd37
NC		 15140 if (elf_header.e_type == ET_CORE)
15141 switch (e_type)
15142 {
57346661 15143 case NT_AUXV:
1ec5cd37 15144 return _("NT_AUXV (auxiliary vector)");
57346661 15145 case NT_PRSTATUS:
1ec5cd37 15146 return _("NT_PRSTATUS (prstatus structure)");
57346661 15147 case NT_FPREGSET:
1ec5cd37 15148 return _("NT_FPREGSET (floating point registers)");
57346661 15149 case NT_PRPSINFO:
1ec5cd37 15150 return _("NT_PRPSINFO (prpsinfo structure)");
57346661 15151 case NT_TASKSTRUCT:
1ec5cd37 15152 return _("NT_TASKSTRUCT (task structure)");
57346661 15153 case NT_PRXFPREG:
1ec5cd37 15154 return _("NT_PRXFPREG (user_xfpregs structure)");
e1e95dec
AM		 15155 case NT_PPC_VMX:
15156 return _("NT_PPC_VMX (ppc Altivec registers)");
89eeb0bc
LM		 15157 case NT_PPC_VSX:
15158 return _("NT_PPC_VSX (ppc VSX registers)");
ff826ef3
TT		 15159 case NT_386_TLS:
15160 return _("NT_386_TLS (x86 TLS information)");
15161 case NT_386_IOPERM:
15162 return _("NT_386_IOPERM (x86 I/O permissions)");
4339cae0
L		 15163 case NT_X86_XSTATE:
15164 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
0675e188
UW		 15165 case NT_S390_HIGH_GPRS:
15166 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
d7eeb400
MS		 15167 case NT_S390_TIMER:
15168 return _("NT_S390_TIMER (s390 timer register)");
15169 case NT_S390_TODCMP:
15170 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15171 case NT_S390_TODPREG:
15172 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15173 case NT_S390_CTRS:
15174 return _("NT_S390_CTRS (s390 control registers)");
15175 case NT_S390_PREFIX:
15176 return _("NT_S390_PREFIX (s390 prefix register)");
a367d729
AK		 15177 case NT_S390_LAST_BREAK:
15178 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15179 case NT_S390_SYSTEM_CALL:
15180 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
abb3f6cc
NC		 15181 case NT_S390_TDB:
15182 return _("NT_S390_TDB (s390 transaction diagnostic block)");
4ef9f41a
AA		 15183 case NT_S390_VXRS_LOW:
15184 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15185 case NT_S390_VXRS_HIGH:
15186 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
faa9a424
UW		 15187 case NT_ARM_VFP:
15188 return _("NT_ARM_VFP (arm VFP registers)");
652451f8
YZ		 15189 case NT_ARM_TLS:
15190 return _("NT_ARM_TLS (AArch TLS registers)");
15191 case NT_ARM_HW_BREAK:
15192 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15193 case NT_ARM_HW_WATCH:
15194 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
57346661 15195 case NT_PSTATUS:
1ec5cd37 15196 return _("NT_PSTATUS (pstatus structure)");
57346661 15197 case NT_FPREGS:
1ec5cd37 15198 return _("NT_FPREGS (floating point registers)");
57346661 15199 case NT_PSINFO:
1ec5cd37 15200 return _("NT_PSINFO (psinfo structure)");
57346661 15201 case NT_LWPSTATUS:
1ec5cd37 15202 return _("NT_LWPSTATUS (lwpstatus_t structure)");
57346661 15203 case NT_LWPSINFO:
1ec5cd37 15204 return _("NT_LWPSINFO (lwpsinfo_t structure)");
57346661 15205 case NT_WIN32PSTATUS:
1ec5cd37 15206 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9ece1fa9
TT		 15207 case NT_SIGINFO:
15208 return _("NT_SIGINFO (siginfo_t data)");
15209 case NT_FILE:
15210 return _("NT_FILE (mapped files)");
1ec5cd37
NC		 15211 default:
15212 break;
15213 }
15214 else
15215 switch (e_type)
15216 {
15217 case NT_VERSION:
15218 return _("NT_VERSION (version)");
15219 case NT_ARCH:
15220 return _("NT_ARCH (architecture)");
15221 default:
15222 break;
15223 }
15224
e9e44622 15225 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
1ec5cd37 15226 return buff;
779fe533
NC		 15227}
15228
9ece1fa9
TT		 15229static int
15230print_core_note (Elf_Internal_Note *pnote)
15231{
15232 unsigned int addr_size = is_32bit_elf ? 4 : 8;
15233 bfd_vma count, page_size;
15234 unsigned char *descdata, *filenames, *descend;
15235
15236 if (pnote->type != NT_FILE)
15237 return 1;
15238
15239#ifndef BFD64
15240 if (!is_32bit_elf)
15241 {
15242 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15243 /* Still "successful". */
15244 return 1;
15245 }
15246#endif
15247
15248 if (pnote->descsz < 2 * addr_size)
15249 {
15250 printf (_(" Malformed note - too short for header\n"));
15251 return 0;
15252 }
15253
15254 descdata = (unsigned char *) pnote->descdata;
15255 descend = descdata + pnote->descsz;
15256
15257 if (descdata[pnote->descsz - 1] != '\0')
15258 {
15259 printf (_(" Malformed note - does not end with \\0\n"));
15260 return 0;
15261 }
15262
15263 count = byte_get (descdata, addr_size);
15264 descdata += addr_size;
15265
15266 page_size = byte_get (descdata, addr_size);
15267 descdata += addr_size;
15268
15269 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
15270 {
15271 printf (_(" Malformed note - too short for supplied file count\n"));
15272 return 0;
15273 }
15274
15275 printf (_(" Page size: "));
15276 print_vma (page_size, DEC);
15277 printf ("\n");
15278
15279 printf (_(" %*s%*s%*s\n"),
15280 (int) (2 + 2 * addr_size), _("Start"),
15281 (int) (4 + 2 * addr_size), _("End"),
15282 (int) (4 + 2 * addr_size), _("Page Offset"));
15283 filenames = descdata + count * 3 * addr_size;
595712bb 15284 while (count-- > 0)
9ece1fa9
TT		 15285 {
15286 bfd_vma start, end, file_ofs;
15287
15288 if (filenames == descend)
15289 {
15290 printf (_(" Malformed note - filenames end too early\n"));
15291 return 0;
15292 }
15293
15294 start = byte_get (descdata, addr_size);
15295 descdata += addr_size;
15296 end = byte_get (descdata, addr_size);
15297 descdata += addr_size;
15298 file_ofs = byte_get (descdata, addr_size);
15299 descdata += addr_size;
15300
15301 printf (" ");
15302 print_vma (start, FULL_HEX);
15303 printf (" ");
15304 print_vma (end, FULL_HEX);
15305 printf (" ");
15306 print_vma (file_ofs, FULL_HEX);
15307 printf ("\n %s\n", filenames);
15308
15309 filenames += 1 + strlen ((char *) filenames);
15310 }
15311
15312 return 1;
15313}
15314
1118d252
RM		 15315static const char *
15316get_gnu_elf_note_type (unsigned e_type)
15317{
15318 static char buff[64];
15319
15320 switch (e_type)
15321 {
15322 case NT_GNU_ABI_TAG:
15323 return _("NT_GNU_ABI_TAG (ABI version tag)");
15324 case NT_GNU_HWCAP:
15325 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15326 case NT_GNU_BUILD_ID:
15327 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
0297aed6
DM		 15328 case NT_GNU_GOLD_VERSION:
15329 return _("NT_GNU_GOLD_VERSION (gold version)");
1118d252
RM		 15330 default:
15331 break;
15332 }
15333
15334 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15335 return buff;
15336}
15337
664f90a3
TT		 15338static int
15339print_gnu_note (Elf_Internal_Note *pnote)
15340{
15341 switch (pnote->type)
15342 {
15343 case NT_GNU_BUILD_ID:
15344 {
15345 unsigned long i;
15346
15347 printf (_(" Build ID: "));
15348 for (i = 0; i < pnote->descsz; ++i)
15349 printf ("%02x", pnote->descdata[i] & 0xff);
9cf03b7e 15350 printf ("\n");
664f90a3
TT		 15351 }
15352 break;
15353
15354 case NT_GNU_ABI_TAG:
15355 {
15356 unsigned long os, major, minor, subminor;
15357 const char *osname;
15358
3102e897
NC		 15359 /* PR 17531: file: 030-599401-0.004. */
15360 if (pnote->descsz < 16)
15361 {
15362 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15363 break;
15364 }
15365
664f90a3
TT		 15366 os = byte_get ((unsigned char *) pnote->descdata, 4);
15367 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
15368 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
15369 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
15370
15371 switch (os)
15372 {
15373 case GNU_ABI_TAG_LINUX:
15374 osname = "Linux";
15375 break;
15376 case GNU_ABI_TAG_HURD:
15377 osname = "Hurd";
15378 break;
15379 case GNU_ABI_TAG_SOLARIS:
15380 osname = "Solaris";
15381 break;
15382 case GNU_ABI_TAG_FREEBSD:
15383 osname = "FreeBSD";
15384 break;
15385 case GNU_ABI_TAG_NETBSD:
15386 osname = "NetBSD";
15387 break;
14ae95f2
RM		 15388 case GNU_ABI_TAG_SYLLABLE:
15389 osname = "Syllable";
15390 break;
15391 case GNU_ABI_TAG_NACL:
15392 osname = "NaCl";
15393 break;
664f90a3
TT		 15394 default:
15395 osname = "Unknown";
15396 break;
15397 }
15398
15399 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
15400 major, minor, subminor);
15401 }
15402 break;
926c5385
CC		 15403
15404 case NT_GNU_GOLD_VERSION:
15405 {
15406 unsigned long i;
15407
15408 printf (_(" Version: "));
15409 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
15410 printf ("%c", pnote->descdata[i]);
15411 printf ("\n");
15412 }
15413 break;
664f90a3
TT		 15414 }
15415
15416 return 1;
15417}
15418
685080f2
NC		 15419static const char *
15420get_v850_elf_note_type (enum v850_notes n_type)
15421{
15422 static char buff[64];
15423
15424 switch (n_type)
15425 {
15426 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
15427 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
15428 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
15429 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
15430 case V850_NOTE_CACHE_INFO: return _("Use of cache");
15431 case V850_NOTE_MMU_INFO: return _("Use of MMU");
15432 default:
15433 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
15434 return buff;
15435 }
15436}
15437
15438static int
15439print_v850_note (Elf_Internal_Note * pnote)
15440{
15441 unsigned int val;
15442
15443 if (pnote->descsz != 4)
15444 return 0;
15445 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
15446
15447 if (val == 0)
15448 {
15449 printf (_("not set\n"));
15450 return 1;
15451 }
15452
15453 switch (pnote->type)
15454 {
15455 case V850_NOTE_ALIGNMENT:
15456 switch (val)
15457 {
15458 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
15459 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
15460 }
15461 break;
14ae95f2 15462
685080f2
NC		 15463 case V850_NOTE_DATA_SIZE:
15464 switch (val)
15465 {
15466 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
15467 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
15468 }
15469 break;
14ae95f2 15470
685080f2
NC		 15471 case V850_NOTE_FPU_INFO:
15472 switch (val)
15473 {
15474 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
15475 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
15476 }
15477 break;
14ae95f2 15478
685080f2
NC		 15479 case V850_NOTE_MMU_INFO:
15480 case V850_NOTE_CACHE_INFO:
15481 case V850_NOTE_SIMD_INFO:
15482 if (val == EF_RH850_SIMD)
15483 {
15484 printf (_("yes\n"));
15485 return 1;
15486 }
15487 break;
15488
15489 default:
15490 /* An 'unknown note type' message will already have been displayed. */
15491 break;
15492 }
15493
15494 printf (_("unknown value: %x\n"), val);
15495 return 0;
15496}
15497
c6056a74
SF		 15498static int
15499process_netbsd_elf_note (Elf_Internal_Note * pnote)
15500{
15501 unsigned int version;
15502
15503 switch (pnote->type)
15504 {
15505 case NT_NETBSD_IDENT:
15506 version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
15507 if ((version / 10000) % 100)
15508 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
15509 version, version / 100000000, (version / 1000000) % 100,
15510 (version / 10000) % 100 > 26 ? "Z" : "",
15511 'A' + (version / 10000) % 26);
15512 else
15513 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
15514 version, version / 100000000, (version / 1000000) % 100,
15515 (version / 100) % 100);
15516 return 1;
15517
15518 case NT_NETBSD_MARCH:
15519 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
15520 pnote->descdata);
15521 return 1;
15522
15523 default:
15524 break;
15525 }
15526
15527 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
15528 pnote->type);
15529 return 1;
15530}
15531
f4ddf30f
JB		 15532static const char *
15533get_freebsd_elfcore_note_type (unsigned e_type)
15534{
f4ddf30f
JB		 15535 switch (e_type)
15536 {
15537 case NT_FREEBSD_THRMISC:
15538 return _("NT_THRMISC (thrmisc structure)");
15539 case NT_FREEBSD_PROCSTAT_PROC:
15540 return _("NT_PROCSTAT_PROC (proc data)");
15541 case NT_FREEBSD_PROCSTAT_FILES:
15542 return _("NT_PROCSTAT_FILES (files data)");
15543 case NT_FREEBSD_PROCSTAT_VMMAP:
15544 return _("NT_PROCSTAT_VMMAP (vmmap data)");
15545 case NT_FREEBSD_PROCSTAT_GROUPS:
15546 return _("NT_PROCSTAT_GROUPS (groups data)");
15547 case NT_FREEBSD_PROCSTAT_UMASK:
15548 return _("NT_PROCSTAT_UMASK (umask data)");
15549 case NT_FREEBSD_PROCSTAT_RLIMIT:
15550 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
15551 case NT_FREEBSD_PROCSTAT_OSREL:
15552 return _("NT_PROCSTAT_OSREL (osreldate data)");
15553 case NT_FREEBSD_PROCSTAT_PSSTRINGS:
15554 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
15555 case NT_FREEBSD_PROCSTAT_AUXV:
15556 return _("NT_PROCSTAT_AUXV (auxv data)");
15557 }
15558 return get_note_type (e_type);
15559}
15560
9437c45b 15561static const char *
d3ba0551 15562get_netbsd_elfcore_note_type (unsigned e_type)
9437c45b
JT		 15563{
15564 static char buff[64];
15565
b4db1224 15566 if (e_type == NT_NETBSDCORE_PROCINFO)
9437c45b
JT		 15567 {
15568 /* NetBSD core "procinfo" structure. */
15569 return _("NetBSD procinfo structure");
15570 }
15571
15572 /* As of Jan 2002 there are no other machine-independent notes
15573 defined for NetBSD core files. If the note type is less
15574 than the start of the machine-dependent note types, we don't
15575 understand it. */
15576
b4db1224 15577 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9437c45b 15578 {
e9e44622 15579 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9437c45b
JT		 15580 return buff;
15581 }
15582
15583 switch (elf_header.e_machine)
15584 {
15585 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15586 and PT_GETFPREGS == mach+2. */
15587
15588 case EM_OLD_ALPHA:
15589 case EM_ALPHA:
15590 case EM_SPARC:
15591 case EM_SPARC32PLUS:
15592 case EM_SPARCV9:
15593 switch (e_type)
15594 {
2b692964 15595 case NT_NETBSDCORE_FIRSTMACH + 0:
b4db1224 15596 return _("PT_GETREGS (reg structure)");
2b692964 15597 case NT_NETBSDCORE_FIRSTMACH + 2:
b4db1224 15598 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15599 default:
15600 break;
15601 }
15602 break;
15603
15604 /* On all other arch's, PT_GETREGS == mach+1 and
15605 PT_GETFPREGS == mach+3. */
15606 default:
15607 switch (e_type)
15608 {
2b692964 15609 case NT_NETBSDCORE_FIRSTMACH + 1:
b4db1224 15610 return _("PT_GETREGS (reg structure)");
2b692964 15611 case NT_NETBSDCORE_FIRSTMACH + 3:
b4db1224 15612 return _("PT_GETFPREGS (fpreg structure)");
9437c45b
JT		 15613 default:
15614 break;
15615 }
15616 }
15617
9cf03b7e 15618 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
e9e44622 15619 e_type - NT_NETBSDCORE_FIRSTMACH);
9437c45b
JT		 15620 return buff;
15621}
15622
70616151
TT		 15623static const char *
15624get_stapsdt_note_type (unsigned e_type)
15625{
15626 static char buff[64];
15627
15628 switch (e_type)
15629 {
15630 case NT_STAPSDT:
15631 return _("NT_STAPSDT (SystemTap probe descriptors)");
15632
15633 default:
15634 break;
15635 }
15636
15637 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15638 return buff;
15639}
15640
c6a9fc58
TT		 15641static int
15642print_stapsdt_note (Elf_Internal_Note *pnote)
15643{
15644 int addr_size = is_32bit_elf ? 4 : 8;
15645 char *data = pnote->descdata;
15646 char *data_end = pnote->descdata + pnote->descsz;
15647 bfd_vma pc, base_addr, semaphore;
15648 char *provider, *probe, *arg_fmt;
15649
15650 pc = byte_get ((unsigned char *) data, addr_size);
15651 data += addr_size;
15652 base_addr = byte_get ((unsigned char *) data, addr_size);
15653 data += addr_size;
15654 semaphore = byte_get ((unsigned char *) data, addr_size);
15655 data += addr_size;
15656
15657 provider = data;
15658 data += strlen (data) + 1;
15659 probe = data;
15660 data += strlen (data) + 1;
15661 arg_fmt = data;
15662 data += strlen (data) + 1;
15663
15664 printf (_(" Provider: %s\n"), provider);
15665 printf (_(" Name: %s\n"), probe);
15666 printf (_(" Location: "));
15667 print_vma (pc, FULL_HEX);
15668 printf (_(", Base: "));
15669 print_vma (base_addr, FULL_HEX);
15670 printf (_(", Semaphore: "));
15671 print_vma (semaphore, FULL_HEX);
9cf03b7e 15672 printf ("\n");
c6a9fc58
TT		 15673 printf (_(" Arguments: %s\n"), arg_fmt);
15674
15675 return data == data_end;
15676}
15677
00e98fc7
TG		 15678static const char *
15679get_ia64_vms_note_type (unsigned e_type)
15680{
15681 static char buff[64];
15682
15683 switch (e_type)
15684 {
15685 case NT_VMS_MHD:
15686 return _("NT_VMS_MHD (module header)");
15687 case NT_VMS_LNM:
15688 return _("NT_VMS_LNM (language name)");
15689 case NT_VMS_SRC:
15690 return _("NT_VMS_SRC (source files)");
15691 case NT_VMS_TITLE:
9cf03b7e 15692 return "NT_VMS_TITLE";
00e98fc7
TG		 15693 case NT_VMS_EIDC:
15694 return _("NT_VMS_EIDC (consistency check)");
15695 case NT_VMS_FPMODE:
15696 return _("NT_VMS_FPMODE (FP mode)");
15697 case NT_VMS_LINKTIME:
9cf03b7e 15698 return "NT_VMS_LINKTIME";
00e98fc7
TG		 15699 case NT_VMS_IMGNAM:
15700 return _("NT_VMS_IMGNAM (image name)");
15701 case NT_VMS_IMGID:
15702 return _("NT_VMS_IMGID (image id)");
15703 case NT_VMS_LINKID:
15704 return _("NT_VMS_LINKID (link id)");
15705 case NT_VMS_IMGBID:
15706 return _("NT_VMS_IMGBID (build id)");
15707 case NT_VMS_GSTNAM:
15708 return _("NT_VMS_GSTNAM (sym table name)");
15709 case NT_VMS_ORIG_DYN:
9cf03b7e 15710 return "NT_VMS_ORIG_DYN";
00e98fc7 15711 case NT_VMS_PATCHTIME:
9cf03b7e 15712 return "NT_VMS_PATCHTIME";
00e98fc7
TG		 15713 default:
15714 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15715 return buff;
15716 }
15717}
15718
15719static int
15720print_ia64_vms_note (Elf_Internal_Note * pnote)
15721{
15722 switch (pnote->type)
15723 {
15724 case NT_VMS_MHD:
15725 if (pnote->descsz > 36)
15726 {
15727 size_t l = strlen (pnote->descdata + 34);
15728 printf (_(" Creation date : %.17s\n"), pnote->descdata);
15729 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
15730 printf (_(" Module name : %s\n"), pnote->descdata + 34);
15731 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
15732 }
15733 else
15734 printf (_(" Invalid size\n"));
15735 break;
15736 case NT_VMS_LNM:
15737 printf (_(" Language: %s\n"), pnote->descdata);
15738 break;
15739#ifdef BFD64
15740 case NT_VMS_FPMODE:
9cf03b7e 15741 printf (_(" Floating Point mode: "));
4a5cb34f 15742 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15743 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
00e98fc7
TG		 15744 break;
15745 case NT_VMS_LINKTIME:
15746 printf (_(" Link time: "));
15747 print_vms_time
15748 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15749 printf ("\n");
15750 break;
15751 case NT_VMS_PATCHTIME:
15752 printf (_(" Patch time: "));
15753 print_vms_time
15754 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15755 printf ("\n");
15756 break;
15757 case NT_VMS_ORIG_DYN:
15758 printf (_(" Major id: %u, minor id: %u\n"),
15759 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
15760 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
9cf03b7e 15761 printf (_(" Last modified : "));
00e98fc7
TG		 15762 print_vms_time
15763 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
9cf03b7e 15764 printf (_("\n Link flags : "));
4a5cb34f 15765 printf ("0x%016" BFD_VMA_FMT "x\n",
948f632f 15766 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
00e98fc7 15767 printf (_(" Header flags: 0x%08x\n"),
948f632f 15768 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
00e98fc7
TG		 15769 printf (_(" Image id : %s\n"), pnote->descdata + 32);
15770 break;
15771#endif
15772 case NT_VMS_IMGNAM:
15773 printf (_(" Image name: %s\n"), pnote->descdata);
15774 break;
15775 case NT_VMS_GSTNAM:
15776 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
15777 break;
15778 case NT_VMS_IMGID:
15779 printf (_(" Image id: %s\n"), pnote->descdata);
15780 break;
15781 case NT_VMS_LINKID:
15782 printf (_(" Linker id: %s\n"), pnote->descdata);
15783 break;
15784 default:
15785 break;
15786 }
15787 return 1;
15788}
15789
6d118b09
NC		 15790/* Note that by the ELF standard, the name field is already null byte
15791 terminated, and namesz includes the terminating null byte.
15792 I.E. the value of namesz for the name "FSF" is 4.
15793
e3c8793a 15794 If the value of namesz is zero, there is no name present. */
779fe533 15795static int
2cf0635d 15796process_note (Elf_Internal_Note * pnote)
779fe533 15797{
2cf0635d
NC		 15798 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
15799 const char * nt;
9437c45b
JT		 15800
15801 if (pnote->namesz == 0)
1ec5cd37
NC		 15802 /* If there is no note name, then use the default set of
15803 note type strings. */
15804 nt = get_note_type (pnote->type);
15805
1118d252
RM		 15806 else if (const_strneq (pnote->namedata, "GNU"))
15807 /* GNU-specific object file notes. */
15808 nt = get_gnu_elf_note_type (pnote->type);
f4ddf30f
JB		 15809
15810 else if (const_strneq (pnote->namedata, "FreeBSD"))
15811 /* FreeBSD-specific core file notes. */
15812 nt = get_freebsd_elfcore_note_type (pnote->type);
1118d252 15813
0112cd26 15814 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
1ec5cd37
NC		 15815 /* NetBSD-specific core file notes. */
15816 nt = get_netbsd_elfcore_note_type (pnote->type);
15817
c6056a74
SF		 15818 else if (const_strneq (pnote->namedata, "NetBSD"))
15819 /* NetBSD-specific core file notes. */
15820 return process_netbsd_elf_note (pnote);
15821
b15fa79e
AM		 15822 else if (strneq (pnote->namedata, "SPU/", 4))
15823 {
15824 /* SPU-specific core file notes. */
15825 nt = pnote->namedata + 4;
15826 name = "SPU";
15827 }
15828
00e98fc7
TG		 15829 else if (const_strneq (pnote->namedata, "IPF/VMS"))
15830 /* VMS/ia64-specific file notes. */
15831 nt = get_ia64_vms_note_type (pnote->type);
15832
70616151
TT		 15833 else if (const_strneq (pnote->namedata, "stapsdt"))
15834 nt = get_stapsdt_note_type (pnote->type);
15835
9437c45b 15836 else
1ec5cd37
NC		 15837 /* Don't recognize this note name; just use the default set of
15838 note type strings. */
00e98fc7 15839 nt = get_note_type (pnote->type);
9437c45b 15840
2aee03ae 15841 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
00e98fc7
TG		 15842
15843 if (const_strneq (pnote->namedata, "IPF/VMS"))
15844 return print_ia64_vms_note (pnote);
664f90a3
TT		 15845 else if (const_strneq (pnote->namedata, "GNU"))
15846 return print_gnu_note (pnote);
c6a9fc58
TT		 15847 else if (const_strneq (pnote->namedata, "stapsdt"))
15848 return print_stapsdt_note (pnote);
9ece1fa9
TT		 15849 else if (const_strneq (pnote->namedata, "CORE"))
15850 return print_core_note (pnote);
00e98fc7
TG		 15851 else
15852 return 1;
779fe533
NC		 15853}
15854
6d118b09 15855
779fe533 15856static int
2cf0635d 15857process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
779fe533 15858{
2cf0635d
NC		 15859 Elf_External_Note * pnotes;
15860 Elf_External_Note * external;
c8071705 15861 char * end;
b34976b6 15862 int res = 1;
103f02d3 15863
779fe533
NC		 15864 if (length <= 0)
15865 return 0;
103f02d3 15866
3f5e193b 15867 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15b42fb0 15868 _("notes"));
dd24e3da 15869 if (pnotes == NULL)
a6e9f9df 15870 return 0;
779fe533 15871
103f02d3 15872 external = pnotes;
103f02d3 15873
9dd3a467 15874 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
f3485b74 15875 (unsigned long) offset, (unsigned long) length);
2aee03ae 15876 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
103f02d3 15877
c8071705
NC		 15878 end = (char *) pnotes + length;
15879 while ((char *) external < end)
779fe533 15880 {
b34976b6 15881 Elf_Internal_Note inote;
15b42fb0
AM		 15882 size_t min_notesz;
15883 char *next;
2cf0635d 15884 char * temp = NULL;
c8071705 15885 size_t data_remaining = end - (char *) external;
6d118b09 15886
00e98fc7 15887 if (!is_ia64_vms ())
15b42fb0 15888 {
9dd3a467
NC		 15889 /* PR binutils/15191
15890 Make sure that there is enough data to read. */
15b42fb0
AM		 15891 min_notesz = offsetof (Elf_External_Note, name);
15892 if (data_remaining < min_notesz)
9dd3a467
NC		 15893 {
15894 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15895 (int) data_remaining);
15896 break;
15897 }
15b42fb0
AM		 15898 inote.type = BYTE_GET (external->type);
15899 inote.namesz = BYTE_GET (external->namesz);
15900 inote.namedata = external->name;
15901 inote.descsz = BYTE_GET (external->descsz);
15902 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
834f871c 15903 /* PR 17531: file: 3443835e. */
c8071705 15904 if (inote.descdata < (char *) pnotes || inote.descdata > end)
834f871c
NC		 15905 {
15906 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15907 inote.descdata = inote.namedata;
15908 inote.namesz = 0;
15909 }
14ae95f2 15910
15b42fb0
AM		 15911 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15912 next = inote.descdata + align_power (inote.descsz, 2);
15913 }
00e98fc7 15914 else
15b42fb0
AM		 15915 {
15916 Elf64_External_VMS_Note *vms_external;
00e98fc7 15917
9dd3a467
NC		 15918 /* PR binutils/15191
15919 Make sure that there is enough data to read. */
15b42fb0
AM		 15920 min_notesz = offsetof (Elf64_External_VMS_Note, name);
15921 if (data_remaining < min_notesz)
9dd3a467
NC		 15922 {
15923 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15924 (int) data_remaining);
15925 break;
15926 }
3e55a963 15927
15b42fb0
AM		 15928 vms_external = (Elf64_External_VMS_Note *) external;
15929 inote.type = BYTE_GET (vms_external->type);
15930 inote.namesz = BYTE_GET (vms_external->namesz);
15931 inote.namedata = vms_external->name;
15932 inote.descsz = BYTE_GET (vms_external->descsz);
15933 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
15934 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15935 next = inote.descdata + align_power (inote.descsz, 3);
15936 }
15937
15938 if (inote.descdata < (char *) external + min_notesz
15939 || next < (char *) external + min_notesz
5d921cbd
NC		 15940 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15941 || inote.namedata + inote.namesz < inote.namedata
15942 || inote.descdata + inote.descsz < inote.descdata
15b42fb0 15943 || data_remaining < (size_t)(next - (char *) external))
3e55a963 15944 {
15b42fb0 15945 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
0af1713e 15946 (unsigned long) ((char *) external - (char *) pnotes));
9dd3a467 15947 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
3e55a963
NC		 15948 inote.type, inote.namesz, inote.descsz);
15949 break;
15950 }
15951
15b42fb0 15952 external = (Elf_External_Note *) next;
dd24e3da 15953
6d118b09
NC		 15954 /* Verify that name is null terminated. It appears that at least
15955 one version of Linux (RedHat 6.0) generates corefiles that don't
15956 comply with the ELF spec by failing to include the null byte in
15957 namesz. */
8b971f9f 15958 if (inote.namedata[inote.namesz - 1] != '\0')
6d118b09 15959 {
3f5e193b 15960 temp = (char *) malloc (inote.namesz + 1);
6d118b09
NC		 15961 if (temp == NULL)
15962 {
8b73c356 15963 error (_("Out of memory allocating space for inote name\n"));
6d118b09
NC		 15964 res = 0;
15965 break;
15966 }
76da6bbe 15967
6d118b09
NC		 15968 strncpy (temp, inote.namedata, inote.namesz);
15969 temp[inote.namesz] = 0;
76da6bbe 15970
6d118b09
NC		 15971 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15972 inote.namedata = temp;
15973 }
15974
15975 res &= process_note (& inote);
103f02d3 15976
6d118b09
NC		 15977 if (temp != NULL)
15978 {
15979 free (temp);
15980 temp = NULL;
15981 }
779fe533
NC		 15982 }
15983
15984 free (pnotes);
103f02d3 15985
779fe533
NC		 15986 return res;
15987}
15988
15989static int
2cf0635d 15990process_corefile_note_segments (FILE * file)
779fe533 15991{
2cf0635d 15992 Elf_Internal_Phdr * segment;
b34976b6
AM		 15993 unsigned int i;
15994 int res = 1;
103f02d3 15995
d93f0186 15996 if (! get_program_headers (file))
779fe533 15997 return 0;
103f02d3 15998
779fe533
NC		 15999 for (i = 0, segment = program_headers;
16000 i < elf_header.e_phnum;
b34976b6 16001 i++, segment++)
779fe533
NC		 16002 {
16003 if (segment->p_type == PT_NOTE)
103f02d3 16004 res &= process_corefile_note_segment (file,
30800947
NC		 16005 (bfd_vma) segment->p_offset,
16006 (bfd_vma) segment->p_filesz);
779fe533 16007 }
103f02d3 16008
779fe533
NC		 16009 return res;
16010}
16011
685080f2
NC		 16012static int
16013process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
16014{
16015 Elf_External_Note * pnotes;
16016 Elf_External_Note * external;
c8071705 16017 char * end;
685080f2
NC		 16018 int res = 1;
16019
16020 if (length <= 0)
16021 return 0;
16022
16023 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
16024 _("v850 notes"));
16025 if (pnotes == NULL)
16026 return 0;
16027
16028 external = pnotes;
c8071705 16029 end = (char*) pnotes + length;
685080f2
NC		 16030
16031 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
16032 (unsigned long) offset, (unsigned long) length);
16033
c8071705 16034 while ((char *) external + sizeof (Elf_External_Note) < end)
685080f2
NC		 16035 {
16036 Elf_External_Note * next;
16037 Elf_Internal_Note inote;
16038
16039 inote.type = BYTE_GET (external->type);
16040 inote.namesz = BYTE_GET (external->namesz);
16041 inote.namedata = external->name;
16042 inote.descsz = BYTE_GET (external->descsz);
16043 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
16044 inote.descpos = offset + (inote.descdata - (char *) pnotes);
16045
c8071705
NC		 16046 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
16047 {
16048 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
16049 inote.descdata = inote.namedata;
16050 inote.namesz = 0;
16051 }
16052
685080f2
NC		 16053 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
16054
c8071705 16055 if ( ((char *) next > end)
685080f2
NC		 16056 || ((char *) next < (char *) pnotes))
16057 {
16058 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
16059 (unsigned long) ((char *) external - (char *) pnotes));
16060 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16061 inote.type, inote.namesz, inote.descsz);
16062 break;
16063 }
16064
16065 external = next;
16066
16067 /* Prevent out-of-bounds indexing. */
c8071705 16068 if ( inote.namedata + inote.namesz > end
685080f2
NC		 16069 || inote.namedata + inote.namesz < inote.namedata)
16070 {
16071 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
16072 (unsigned long) ((char *) external - (char *) pnotes));
16073 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16074 inote.type, inote.namesz, inote.descsz);
16075 break;
16076 }
16077
16078 printf (" %s: ", get_v850_elf_note_type (inote.type));
16079
16080 if (! print_v850_note (& inote))
16081 {
16082 res = 0;
16083 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
16084 inote.namesz, inote.descsz);
16085 }
16086 }
16087
16088 free (pnotes);
16089
16090 return res;
16091}
16092
779fe533 16093static int
2cf0635d 16094process_note_sections (FILE * file)
1ec5cd37 16095{
2cf0635d 16096 Elf_Internal_Shdr * section;
1ec5cd37 16097 unsigned long i;
df565f32 16098 int n = 0;
1ec5cd37
NC		 16099 int res = 1;
16100
16101 for (i = 0, section = section_headers;
fa1908fd 16102 i < elf_header.e_shnum && section != NULL;
1ec5cd37 16103 i++, section++)
685080f2
NC		 16104 {
16105 if (section->sh_type == SHT_NOTE)
16106 {
16107 res &= process_corefile_note_segment (file,
16108 (bfd_vma) section->sh_offset,
16109 (bfd_vma) section->sh_size);
16110 n++;
16111 }
16112
16113 if (( elf_header.e_machine == EM_V800
16114 || elf_header.e_machine == EM_V850
16115 || elf_header.e_machine == EM_CYGNUS_V850)
16116 && section->sh_type == SHT_RENESAS_INFO)
16117 {
16118 res &= process_v850_notes (file,
16119 (bfd_vma) section->sh_offset,
16120 (bfd_vma) section->sh_size);
16121 n++;
16122 }
16123 }
df565f32
NC		 16124
16125 if (n == 0)
16126 /* Try processing NOTE segments instead. */
16127 return process_corefile_note_segments (file);
1ec5cd37
NC		 16128
16129 return res;
16130}
16131
16132static int
2cf0635d 16133process_notes (FILE * file)
779fe533
NC		 16134{
16135 /* If we have not been asked to display the notes then do nothing. */
16136 if (! do_notes)
16137 return 1;
103f02d3 16138
779fe533 16139 if (elf_header.e_type != ET_CORE)
1ec5cd37 16140 return process_note_sections (file);
103f02d3 16141
779fe533 16142 /* No program headers means no NOTE segment. */
1ec5cd37
NC		 16143 if (elf_header.e_phnum > 0)
16144 return process_corefile_note_segments (file);
779fe533 16145
1ec5cd37
NC		 16146 printf (_("No note segments present in the core file.\n"));
16147 return 1;
779fe533
NC		 16148}
16149
252b5132 16150static int
2cf0635d 16151process_arch_specific (FILE * file)
252b5132 16152{
a952a375
NC		 16153 if (! do_arch)
16154 return 1;
16155
252b5132
RH		 16156 switch (elf_header.e_machine)
16157 {
11c1ff18
PB		 16158 case EM_ARM:
16159 return process_arm_specific (file);
252b5132 16160 case EM_MIPS:
4fe85591 16161 case EM_MIPS_RS3_LE:
252b5132
RH		 16162 return process_mips_specific (file);
16163 break;
35c08157
KLC		 16164 case EM_NDS32:
16165 return process_nds32_specific (file);
16166 break;
34c8bcba
JM		 16167 case EM_PPC:
16168 return process_power_specific (file);
16169 break;
643f7afb
AK		 16170 case EM_S390:
16171 case EM_S390_OLD:
16172 return process_s390_specific (file);
16173 break;
9e8c70f9
DM		 16174 case EM_SPARC:
16175 case EM_SPARC32PLUS:
16176 case EM_SPARCV9:
16177 return process_sparc_specific (file);
16178 break;
59e6276b
JM		 16179 case EM_TI_C6000:
16180 return process_tic6x_specific (file);
16181 break;
13761a11
NC		 16182 case EM_MSP430:
16183 return process_msp430x_specific (file);
252b5132
RH		 16184 default:
16185 break;
16186 }
16187 return 1;
16188}
16189
16190static int
2cf0635d 16191get_file_header (FILE * file)
252b5132 16192{
9ea033b2
NC		 16193 /* Read in the identity array. */
16194 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 16195 return 0;
16196
9ea033b2 16197 /* Determine how to read the rest of the header. */
b34976b6 16198 switch (elf_header.e_ident[EI_DATA])
9ea033b2
NC		 16199 {
16200 default: /* fall through */
16201 case ELFDATANONE: /* fall through */
adab8cdc
AO		 16202 case ELFDATA2LSB:
16203 byte_get = byte_get_little_endian;
16204 byte_put = byte_put_little_endian;
16205 break;
16206 case ELFDATA2MSB:
16207 byte_get = byte_get_big_endian;
16208 byte_put = byte_put_big_endian;
16209 break;
9ea033b2
NC		 16210 }
16211
16212 /* For now we only support 32 bit and 64 bit ELF files. */
b34976b6 16213 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9ea033b2
NC		 16214
16215 /* Read in the rest of the header. */
16216 if (is_32bit_elf)
16217 {
16218 Elf32_External_Ehdr ehdr32;
252b5132 16219
9ea033b2
NC		 16220 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
16221 return 0;
103f02d3 16222
9ea033b2
NC		 16223 elf_header.e_type = BYTE_GET (ehdr32.e_type);
16224 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
16225 elf_header.e_version = BYTE_GET (ehdr32.e_version);
16226 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
16227 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
16228 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
16229 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
16230 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
16231 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
16232 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
16233 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
16234 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
16235 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
16236 }
252b5132 16237 else
9ea033b2
NC		 16238 {
16239 Elf64_External_Ehdr ehdr64;
a952a375
NC		 16240
16241 /* If we have been compiled with sizeof (bfd_vma) == 4, then
16242 we will not be able to cope with the 64bit data found in
16243 64 ELF files. Detect this now and abort before we start
50c2245b 16244 overwriting things. */
a952a375
NC		 16245 if (sizeof (bfd_vma) < 8)
16246 {
e3c8793a
NC		 16247 error (_("This instance of readelf has been built without support for a\n\
1624864 bit data type and so it cannot read 64 bit ELF files.\n"));
a952a375
NC		 16249 return 0;
16250 }
103f02d3 16251
9ea033b2
NC		 16252 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
16253 return 0;
103f02d3 16254
9ea033b2
NC		 16255 elf_header.e_type = BYTE_GET (ehdr64.e_type);
16256 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
16257 elf_header.e_version = BYTE_GET (ehdr64.e_version);
66543521
AM		 16258 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
16259 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
16260 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9ea033b2
NC		 16261 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
16262 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
16263 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
16264 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
16265 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
16266 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
16267 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
16268 }
252b5132 16269
7ece0d85
JJ		 16270 if (elf_header.e_shoff)
16271 {
16272 /* There may be some extensions in the first section header. Don't
16273 bomb if we can't read it. */
16274 if (is_32bit_elf)
049b0c3a 16275 get_32bit_section_headers (file, TRUE);
7ece0d85 16276 else
049b0c3a 16277 get_64bit_section_headers (file, TRUE);
7ece0d85 16278 }
560f3c1c 16279
252b5132
RH		 16280 return 1;
16281}
16282
fb52b2f4
NC		 16283/* Process one ELF object file according to the command line options.
16284 This file may actually be stored in an archive. The file is
16285 positioned at the start of the ELF object. */
16286
ff78d6d6 16287static int
2cf0635d 16288process_object (char * file_name, FILE * file)
252b5132 16289{
252b5132
RH		 16290 unsigned int i;
16291
252b5132
RH		 16292 if (! get_file_header (file))
16293 {
16294 error (_("%s: Failed to read file header\n"), file_name);
ff78d6d6 16295 return 1;
252b5132
RH		 16296 }
16297
16298 /* Initialise per file variables. */
60bca95a 16299 for (i = ARRAY_SIZE (version_info); i--;)
252b5132
RH		 16300 version_info[i] = 0;
16301
60bca95a 16302 for (i = ARRAY_SIZE (dynamic_info); i--;)
252b5132 16303 dynamic_info[i] = 0;
5115b233 16304 dynamic_info_DT_GNU_HASH = 0;
252b5132
RH		 16305
16306 /* Process the file. */
16307 if (show_name)
16308 printf (_("\nFile: %s\n"), file_name);
16309
18bd398b
NC		 16310 /* Initialise the dump_sects array from the cmdline_dump_sects array.
16311 Note we do this even if cmdline_dump_sects is empty because we
16312 must make sure that the dump_sets array is zeroed out before each
16313 object file is processed. */
16314 if (num_dump_sects > num_cmdline_dump_sects)
09c11c86 16315 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18bd398b
NC		 16316
16317 if (num_cmdline_dump_sects > 0)
16318 {
16319 if (num_dump_sects == 0)
16320 /* A sneaky way of allocating the dump_sects array. */
09c11c86 16321 request_dump_bynumber (num_cmdline_dump_sects, 0);
18bd398b
NC		 16322
16323 assert (num_dump_sects >= num_cmdline_dump_sects);
09c11c86
NC		 16324 memcpy (dump_sects, cmdline_dump_sects,
16325 num_cmdline_dump_sects * sizeof (* dump_sects));
18bd398b 16326 }
d70c5fc7 16327
252b5132 16328 if (! process_file_header ())
fb52b2f4 16329 return 1;
252b5132 16330
d1f5c6e3 16331 if (! process_section_headers (file))
2f62977e 16332 {
d1f5c6e3
L		 16333 /* Without loaded section headers we cannot process lots of
16334 things. */
2f62977e 16335 do_unwind = do_version = do_dump = do_arch = 0;
252b5132 16336
2f62977e 16337 if (! do_using_dynamic)
2c610e4b 16338 do_syms = do_dyn_syms = do_reloc = 0;
2f62977e 16339 }
252b5132 16340
d1f5c6e3
L		 16341 if (! process_section_groups (file))
16342 {
16343 /* Without loaded section groups we cannot process unwind. */
16344 do_unwind = 0;
16345 }
16346
2f62977e 16347 if (process_program_headers (file))
b2d38a17 16348 process_dynamic_section (file);
252b5132
RH		 16349
16350 process_relocs (file);
16351
4d6ed7c8
NC		 16352 process_unwind (file);
16353
252b5132
RH		 16354 process_symbol_table (file);
16355
16356 process_syminfo (file);
16357
16358 process_version_sections (file);
16359
16360 process_section_contents (file);
f5842774 16361
1ec5cd37 16362 process_notes (file);
103f02d3 16363
047b2264
JJ		 16364 process_gnu_liblist (file);
16365
252b5132
RH		 16366 process_arch_specific (file);
16367
d93f0186
NC		 16368 if (program_headers)
16369 {
16370 free (program_headers);
16371 program_headers = NULL;
16372 }
16373
252b5132
RH		 16374 if (section_headers)
16375 {
16376 free (section_headers);
16377 section_headers = NULL;
16378 }
16379
16380 if (string_table)
16381 {
16382 free (string_table);
16383 string_table = NULL;
d40ac9bd 16384 string_table_length = 0;
252b5132
RH		 16385 }
16386
16387 if (dynamic_strings)
16388 {
16389 free (dynamic_strings);
16390 dynamic_strings = NULL;
d79b3d50 16391 dynamic_strings_length = 0;
252b5132
RH		 16392 }
16393
16394 if (dynamic_symbols)
16395 {
16396 free (dynamic_symbols);
16397 dynamic_symbols = NULL;
19936277 16398 num_dynamic_syms = 0;
252b5132
RH		 16399 }
16400
16401 if (dynamic_syminfo)
16402 {
16403 free (dynamic_syminfo);
16404 dynamic_syminfo = NULL;
16405 }
ff78d6d6 16406
293c573e
MR		 16407 if (dynamic_section)
16408 {
16409 free (dynamic_section);
16410 dynamic_section = NULL;
16411 }
16412
e4b17d5c
L		 16413 if (section_headers_groups)
16414 {
16415 free (section_headers_groups);
16416 section_headers_groups = NULL;
16417 }
16418
16419 if (section_groups)
16420 {
2cf0635d
NC		 16421 struct group_list * g;
16422 struct group_list * next;
e4b17d5c
L		 16423
16424 for (i = 0; i < group_count; i++)
16425 {
16426 for (g = section_groups [i].root; g != NULL; g = next)
16427 {
16428 next = g->next;
16429 free (g);
16430 }
16431 }
16432
16433 free (section_groups);
16434 section_groups = NULL;
16435 }
16436
19e6b90e 16437 free_debug_memory ();
18bd398b 16438
ff78d6d6 16439 return 0;
252b5132
RH		 16440}
16441
2cf0635d
NC		 16442/* Process an ELF archive.
16443 On entry the file is positioned just after the ARMAG string. */
16444
16445static int
16446process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
16447{
16448 struct archive_info arch;
16449 struct archive_info nested_arch;
16450 size_t got;
2cf0635d
NC		 16451 int ret;
16452
16453 show_name = 1;
16454
16455 /* The ARCH structure is used to hold information about this archive. */
16456 arch.file_name = NULL;
16457 arch.file = NULL;
16458 arch.index_array = NULL;
16459 arch.sym_table = NULL;
16460 arch.longnames = NULL;
16461
16462 /* The NESTED_ARCH structure is used as a single-item cache of information
16463 about a nested archive (when members of a thin archive reside within
16464 another regular archive file). */
16465 nested_arch.file_name = NULL;
16466 nested_arch.file = NULL;
16467 nested_arch.index_array = NULL;
16468 nested_arch.sym_table = NULL;
16469 nested_arch.longnames = NULL;
16470
16471 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
16472 {
16473 ret = 1;
16474 goto out;
4145f1d5 16475 }
fb52b2f4 16476
4145f1d5
NC		 16477 if (do_archive_index)
16478 {
2cf0635d 16479 if (arch.sym_table == NULL)
4145f1d5
NC		 16480 error (_("%s: unable to dump the index as none was found\n"), file_name);
16481 else
16482 {
591f7597 16483 unsigned long i, l;
4145f1d5
NC		 16484 unsigned long current_pos;
16485
591f7597
NC		 16486 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16487 file_name, (unsigned long) arch.index_num, arch.sym_size);
4145f1d5
NC		 16488 current_pos = ftell (file);
16489
2cf0635d 16490 for (i = l = 0; i < arch.index_num; i++)
4145f1d5 16491 {
2cf0635d
NC		 16492 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
16493 {
16494 char * member_name;
4145f1d5 16495
2cf0635d
NC		 16496 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
16497
16498 if (member_name != NULL)
16499 {
16500 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
16501
16502 if (qualified_name != NULL)
16503 {
c2a7d3f5
NC		 16504 printf (_("Contents of binary %s at offset "), qualified_name);
16505 (void) print_vma (arch.index_array[i], PREFIX_HEX);
16506 putchar ('\n');
2cf0635d
NC		 16507 free (qualified_name);
16508 }
4145f1d5
NC		 16509 }
16510 }
2cf0635d
NC		 16511
16512 if (l >= arch.sym_size)
4145f1d5
NC		 16513 {
16514 error (_("%s: end of the symbol table reached before the end of the index\n"),
16515 file_name);
cb8f3167 16516 break;
4145f1d5 16517 }
591f7597
NC		 16518 /* PR 17531: file: 0b6630b2. */
16519 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
16520 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
4145f1d5
NC		 16521 }
16522
c2a7d3f5
NC		 16523 if (arch.uses_64bit_indicies)
16524 l = (l + 7) & ~ 7;
16525 else
16526 l += l & 1;
16527
2cf0635d 16528 if (l < arch.sym_size)
c2a7d3f5
NC		 16529 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16530 file_name, arch.sym_size - l);
4145f1d5 16531
4145f1d5
NC		 16532 if (fseek (file, current_pos, SEEK_SET) != 0)
16533 {
16534 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
2cf0635d
NC		 16535 ret = 1;
16536 goto out;
4145f1d5 16537 }
fb52b2f4 16538 }
4145f1d5
NC		 16539
16540 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
16541 && !do_segments && !do_header && !do_dump && !do_version
16542 && !do_histogram && !do_debugging && !do_arch && !do_notes
2c610e4b 16543 && !do_section_groups && !do_dyn_syms)
2cf0635d
NC		 16544 {
16545 ret = 0; /* Archive index only. */
16546 goto out;
16547 }
fb52b2f4
NC		 16548 }
16549
d989285c 16550 ret = 0;
fb52b2f4
NC		 16551
16552 while (1)
16553 {
2cf0635d
NC		 16554 char * name;
16555 size_t namelen;
16556 char * qualified_name;
16557
16558 /* Read the next archive header. */
16559 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
16560 {
16561 error (_("%s: failed to seek to next archive header\n"), file_name);
16562 return 1;
16563 }
16564 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
16565 if (got != sizeof arch.arhdr)
16566 {
16567 if (got == 0)
16568 break;
16569 error (_("%s: failed to read archive header\n"), file_name);
16570 ret = 1;
16571 break;
16572 }
16573 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
16574 {
16575 error (_("%s: did not find a valid archive header\n"), arch.file_name);
16576 ret = 1;
16577 break;
16578 }
16579
16580 arch.next_arhdr_offset += sizeof arch.arhdr;
16581
16582 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
16583 if (archive_file_size & 01)
16584 ++archive_file_size;
16585
16586 name = get_archive_member_name (&arch, &nested_arch);
16587 if (name == NULL)
fb52b2f4 16588 {
0fd3a477 16589 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 16590 ret = 1;
16591 break;
fb52b2f4 16592 }
2cf0635d 16593 namelen = strlen (name);
fb52b2f4 16594
2cf0635d
NC		 16595 qualified_name = make_qualified_name (&arch, &nested_arch, name);
16596 if (qualified_name == NULL)
fb52b2f4 16597 {
2cf0635d 16598 error (_("%s: bad archive file name\n"), file_name);
d989285c
ILT		 16599 ret = 1;
16600 break;
fb52b2f4
NC		 16601 }
16602
2cf0635d
NC		 16603 if (is_thin_archive && arch.nested_member_origin == 0)
16604 {
16605 /* This is a proxy for an external member of a thin archive. */
16606 FILE * member_file;
16607 char * member_file_name = adjust_relative_path (file_name, name, namelen);
16608 if (member_file_name == NULL)
16609 {
16610 ret = 1;
16611 break;
16612 }
16613
16614 member_file = fopen (member_file_name, "rb");
16615 if (member_file == NULL)
16616 {
16617 error (_("Input file '%s' is not readable.\n"), member_file_name);
16618 free (member_file_name);
16619 ret = 1;
16620 break;
16621 }
16622
16623 archive_file_offset = arch.nested_member_origin;
16624
16625 ret |= process_object (qualified_name, member_file);
16626
16627 fclose (member_file);
16628 free (member_file_name);
16629 }
16630 else if (is_thin_archive)
16631 {
a043396b
NC		 16632 /* PR 15140: Allow for corrupt thin archives. */
16633 if (nested_arch.file == NULL)
16634 {
16635 error (_("%s: contains corrupt thin archive: %s\n"),
16636 file_name, name);
16637 ret = 1;
16638 break;
16639 }
16640
2cf0635d
NC		 16641 /* This is a proxy for a member of a nested archive. */
16642 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
16643
16644 /* The nested archive file will have been opened and setup by
16645 get_archive_member_name. */
16646 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
16647 {
16648 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
16649 ret = 1;
16650 break;
16651 }
16652
16653 ret |= process_object (qualified_name, nested_arch.file);
16654 }
16655 else
16656 {
16657 archive_file_offset = arch.next_arhdr_offset;
16658 arch.next_arhdr_offset += archive_file_size;
fb52b2f4 16659
2cf0635d
NC		 16660 ret |= process_object (qualified_name, file);
16661 }
fb52b2f4 16662
2b52916e
L		 16663 if (dump_sects != NULL)
16664 {
16665 free (dump_sects);
16666 dump_sects = NULL;
16667 num_dump_sects = 0;
16668 }
16669
2cf0635d 16670 free (qualified_name);
fb52b2f4
NC		 16671 }
16672
4145f1d5 16673 out:
2cf0635d
NC		 16674 if (nested_arch.file != NULL)
16675 fclose (nested_arch.file);
16676 release_archive (&nested_arch);
16677 release_archive (&arch);
fb52b2f4 16678
d989285c 16679 return ret;
fb52b2f4
NC		 16680}
16681
16682static int
2cf0635d 16683process_file (char * file_name)
fb52b2f4 16684{
2cf0635d 16685 FILE * file;
fb52b2f4
NC		 16686 struct stat statbuf;
16687 char armag[SARMAG];
16688 int ret;
16689
16690 if (stat (file_name, &statbuf) < 0)
16691 {
f24ddbdd
NC		 16692 if (errno == ENOENT)
16693 error (_("'%s': No such file\n"), file_name);
16694 else
16695 error (_("Could not locate '%s'. System error message: %s\n"),
16696 file_name, strerror (errno));
16697 return 1;
16698 }
16699
16700 if (! S_ISREG (statbuf.st_mode))
16701 {
16702 error (_("'%s' is not an ordinary file\n"), file_name);
fb52b2f4
NC		 16703 return 1;
16704 }
16705
16706 file = fopen (file_name, "rb");
16707 if (file == NULL)
16708 {
f24ddbdd 16709 error (_("Input file '%s' is not readable.\n"), file_name);
fb52b2f4
NC		 16710 return 1;
16711 }
16712
16713 if (fread (armag, SARMAG, 1, file) != 1)
16714 {
4145f1d5 16715 error (_("%s: Failed to read file's magic number\n"), file_name);
fb52b2f4
NC		 16716 fclose (file);
16717 return 1;
16718 }
16719
f54498b4
NC		 16720 current_file_size = (bfd_size_type) statbuf.st_size;
16721
fb52b2f4 16722 if (memcmp (armag, ARMAG, SARMAG) == 0)
2cf0635d
NC		 16723 ret = process_archive (file_name, file, FALSE);
16724 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
16725 ret = process_archive (file_name, file, TRUE);
fb52b2f4
NC		 16726 else
16727 {
4145f1d5
NC		 16728 if (do_archive_index)
16729 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16730 file_name);
16731
fb52b2f4
NC		 16732 rewind (file);
16733 archive_file_size = archive_file_offset = 0;
16734 ret = process_object (file_name, file);
16735 }
16736
16737 fclose (file);
16738
f54498b4 16739 current_file_size = 0;
fb52b2f4
NC		 16740 return ret;
16741}
16742
252b5132
RH		 16743#ifdef SUPPORT_DISASSEMBLY
16744/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2 16745 fix this so that we insert symbolic addresses here, esp for GOT/PLT
e3c8793a 16746 symbols. */
252b5132
RH		 16747
16748void
2cf0635d 16749print_address (unsigned int addr, FILE * outfile)
252b5132
RH		 16750{
16751 fprintf (outfile,"0x%8.8x", addr);
16752}
16753
e3c8793a 16754/* Needed by the i386 disassembler. */
252b5132
RH		 16755void
16756db_task_printsym (unsigned int addr)
16757{
16758 print_address (addr, stderr);
16759}
16760#endif
16761
16762int
2cf0635d 16763main (int argc, char ** argv)
252b5132 16764{
ff78d6d6
L		 16765 int err;
16766
252b5132
RH		 16767#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16768 setlocale (LC_MESSAGES, "");
3882b010
L		 16769#endif
16770#if defined (HAVE_SETLOCALE)
16771 setlocale (LC_CTYPE, "");
252b5132
RH		 16772#endif
16773 bindtextdomain (PACKAGE, LOCALEDIR);
16774 textdomain (PACKAGE);
16775
869b9d07
MM		 16776 expandargv (&argc, &argv);
16777
252b5132
RH		 16778 parse_args (argc, argv);
16779
18bd398b 16780 if (num_dump_sects > 0)
59f14fc0 16781 {
18bd398b 16782 /* Make a copy of the dump_sects array. */
3f5e193b
NC		 16783 cmdline_dump_sects = (dump_type *)
16784 malloc (num_dump_sects * sizeof (* dump_sects));
59f14fc0 16785 if (cmdline_dump_sects == NULL)
591a748a 16786 error (_("Out of memory allocating dump request table.\n"));
59f14fc0
AS		 16787 else
16788 {
09c11c86
NC		 16789 memcpy (cmdline_dump_sects, dump_sects,
16790 num_dump_sects * sizeof (* dump_sects));
59f14fc0
AS		 16791 num_cmdline_dump_sects = num_dump_sects;
16792 }
16793 }
16794
18bd398b
NC		 16795 if (optind < (argc - 1))
16796 show_name = 1;
5656ba2c
L		 16797 else if (optind >= argc)
16798 {
16799 warn (_("Nothing to do.\n"));
16800 usage (stderr);
16801 }
18bd398b 16802
ff78d6d6 16803 err = 0;
252b5132 16804 while (optind < argc)
18bd398b 16805 err |= process_file (argv[optind++]);
252b5132
RH		 16806
16807 if (dump_sects != NULL)
16808 free (dump_sects);
59f14fc0
AS		 16809 if (cmdline_dump_sects != NULL)
16810 free (cmdline_dump_sects);
252b5132 16811
ff78d6d6 16812 return err;
252b5132 16813}
A mirror of the official binutils-gdb repository